// initialization
    renderer_t *renderer = create_renderer();
    world_t *world = create_world();
    enemies_t *enemies = spawn_enemies();
    player_t player;
    input_t input;

    // main loop
    while(1) {

        // handle events here

        update_and_render(renderer, world, enemies, player, input);
    }

struct TitleScreenData {
    //...whatever a title screen would have
};

struct GameData {
    //entities, map, camera, etc.
};

enum StateType {
    STATE_TITLE,
    STATE_GAME,
    MAX_STATE
};

struct Gamestate {
    int type;
    union {
        TitleScreenData *title;
        GameData *game;
    };
};

Gamestate *new_title(/*stuff you need to initialize a title screen*/); //allocates title, etc.
Gamestate *new_game(/*stuff you need to initialize a game... for instance, a path to a player save file*/); //allocates game, etc.
Gamestate *update_gamestate(Gamestate *g);
void render_gamestate(Gamestate *g);

Gamestate *update_gamestate(Gamestate *g) {
    switch(g->type) {
        case STATE_TITLE: {
            //update the title screen, using the TitleScreenData struct
            break;
        }
        case STATE_GAME: {
            //update the game, using the GameData struct
            break;
        }
        //note: my strategy is to branch further into specific update_title and update_game
        //      functions; this isn't necessarily fastest as it causes more indirection but it helps
        //      with organization (game functions can be thrown into a separate file, and same with
        //      title functions)
        default: break;
    }
    return g;
}

Gamestate *current = NULL, *next = NULL;
current = new_title();

//...

//at the end of a game loop, maybe somewhere you set next to be the result of new_game()
if(next) {
    free_gamestate(current);
    current = next;
    next = NULL;
}

//in title update function
if(play_button_clicked) {
    next = new_game();
}

//at the end of this loop, the current state will be freed and reassigned to next
//this will begin updating and rendering using the /GameData/ instead of the
//TitleScreenData. This, of course, assumes that new_game() returns a valid Gamestate *
//that properly allocates and initializes a GameData struct.

struct game_state_t {
    renderer_t renderer;
    world_t world;
    enemies_t enemies;
    player_t player;
    input_t input;
};

void main( void ) {

    game_state_t state; // Allocate the state the way you want (global, stack, malloc... ).

    // Initialize where you want (e.g. instead of here, it could be the first time you enter update_and_render).
    create_renderer( &state.renderer );
    create_world( &state.world );
    spawn_enemies( &state.enemies );

    while ( 1 ) {
        update_and_render( &state );
    }
}

void update_and_render( game_state_t* state ) {
    simulate( &state->world );
    ...
    render( &state->renderer );
}

typedef struct
{
  double x;
  double y;
  v2 velocity;
  texture_t image;
  int w;
  int h;
} player_h;

typedef struct
{
  double x;
  double y;
  v2 velocity;
  texture_t image;
  int w;
  int h;
  behavior_t behavior;
  skill_t skills[5]; // array of skills
  int skills_count; // how many skills does he have
} enemy_t;

typedef struct
{
  double x;
  double y;
  v2 velocity;
  texture_t image;
  int w;
  int h;
} particle_t;

enum Entity_Type { PLAYER_ENTITY, ENEMY_ENTITY, PARTICLE_ENTITY };
typedef struct {
  float x;
  float y;
  Vector2 velocity;
  Texture image;
  int w;
  int h;
  int type;
  union { 
    struct { // Enemy Data:
      Behavior behavior;
      Skill skills[5];
      int skills_count;
    };
    struct { // Player Data:
      // Player Data...
    };
  };
} Entity;

// You don't necessarily need these:
typedef Entity Player;
typedef Entity Enemy;
typedef Entity Particle;

void simulate_gravity(Entity *e) {
  // Simulate Gravity...
}

typedef struct
{
  double x;
  double y;
  v2 velocity;
  texture_t image;
  int w;
  int h;
} particle_t;

typedef struct
{
  particle_t particle;
} player_h;

typedef struct
{
  particle_t particle;
  behavior_t behavior;
  skill_t skills[5]; // array of skills
  int skills_count; // how many skills does he have
} enemy_t;

struct Position
{
    double x;
    double y;
    v2 velocity;
};

typedef struct
{
  Position p;
  texture_t image;
  int w;
  int h;
} player_h;

typedef struct
{
  Position p;
  texture_t image;
  int w;
  int h;
  behavior_t behavior;
  skill_t skills[5]; // array of skills
  int skills_count; // how many skills does he have
} enemy_t;

typedef struct
{
  Position p;;
  texture_t image;
  int w;
  int h;
} particle_t;

struct Texture
{
  texture_t image;
  int w;
  int h;
};

typedef struct
{
  Position p;
  Texture tex;
} player_h;

typedef struct
{
  Position p;
  Texture tex;
  behavior_t behavior;
  skill_t skills[5]; // array of skills
  int skills_count; // how many skills does he have
} enemy_t;

typedef struct
{
  Position p;
  Texture tex;
} particle_t;