ascension: comparison test/snake/snake.c

-:653869cd653f
+:5c915d01bdc0
 CxList *trace;
 /**
 * The new position of the player when @c reset_position is @c true.
 */
 asc_vec2i new_position;
+unsigned health;
 bool reset_position;
 uint8_t number;
 } Player;
 #define GAME_FIELD_SIZE 32
 typedef struct {
 AscSceneNode *nodes[GAME_FIELD_SIZE][GAME_FIELD_SIZE];
 int8_t tile_data[GAME_FIELD_SIZE][GAME_FIELD_SIZE];
 } GameField;
+#define GAME_STATE_MENU 0
+#define GAME_STATE_PLAYING 1
+#define GAME_STATE_GAME_OVER 2
+typedef struct {
+int state;
+GameField *field;
+Player *players[4];
+} GameState;
+GameState game = {0};
 static void globals_init(void) {
 asc_transform_identity(rotations[MOVE_UP]);
 asc_transform_roll(rotations[MOVE_LEFT], asc_rad(-90));
 asc_transform_roll(rotations[MOVE_RIGHT], asc_rad(90));
 asc_behavior_add(node, fps_counter_tie_to_corner);
 asc_ui_add_node(node);
 return node;
 }
-static GameField *game_field;
 static bool game_field_tile_chown(asc_vec2u coords, Player *player) {
 unsigned x = coords.x, y = coords.y;
-asc_ptr_cast(AscRectangle, tile, game_field->nodes[x][y]);
+asc_ptr_cast(AscRectangle, tile, game.field->nodes[x][y]);
-int old_owner = game_field->tile_data[x][y] & GAME_FIELD_TILE_OWNER_MASK;
+int old_owner = game.field->tile_data[x][y] & GAME_FIELD_TILE_OWNER_MASK;
 if (player == NULL) {
-asc_clear_flag(game_field->tile_data[x][y], GAME_FIELD_TILE_OWNER_MASK);
+asc_clear_flag(game.field->tile_data[x][y], GAME_FIELD_TILE_OWNER_MASK);
 tile->color = ASC_RGBi(16, 50, 160);
 } else {
-asc_set_flag_masked(game_field->tile_data[x][y], GAME_FIELD_TILE_OWNER_MASK, player->number);
+asc_set_flag_masked(game.field->tile_data[x][y], GAME_FIELD_TILE_OWNER_MASK, player->number);
 tile->color = player->color;
 }
-int new_owner = game_field->tile_data[x][y] & GAME_FIELD_TILE_OWNER_MASK;
+int new_owner = game.field->tile_data[x][y] & GAME_FIELD_TILE_OWNER_MASK;
 return old_owner != new_owner;
 }
-static GameField *game_field_create() {
+static void game_field_create() {
 // TODO: create a more interesting map than just a basic grid
 AscSceneNode *node = asc_scene_node_empty();
-game_field = asc_scene_node_allocate_data(node, sizeof(GameField));
+game.field = asc_scene_node_allocate_data(node, sizeof(GameField));
 for (unsigned x = 0; x < GAME_FIELD_SIZE; x++) {
 for (unsigned y = 0; y < GAME_FIELD_SIZE; y++) {
 AscSceneNode *tile = asc_rectangle(
 .x = x*GAME_FIELD_TILE_SIZE, .y = y*GAME_FIELD_TILE_SIZE, .filled = true, .thickness = 2,
 .width = GAME_FIELD_TILE_SIZE, .height = GAME_FIELD_TILE_SIZE,
 .color = ASC_RGBi(16, 50, 160),
 .border_color = ASC_RGBi(20, 84, 128),
 );
-game_field->tile_data[x][y] = GAME_FIELD_TILE_EXISTS_FLAG;
+game.field->tile_data[x][y] = GAME_FIELD_TILE_EXISTS_FLAG;
-game_field->nodes[x][y] = tile;
+game.field->nodes[x][y] = tile;
 asc_scene_node_link(node, tile);
 }
 }
 asc_scene_node_set_zindex(node, -2);
 asc_scene_add_node(MAIN_SCENE, node);
-return game_field;
 }
 static asc_vec2u game_field_tile_at_position(asc_vec3f position) {
 return ASC_VEC2U((int)position.x / GAME_FIELD_TILE_SIZE, (int)position.y / GAME_FIELD_TILE_SIZE);
 }
 asc_texture_bind(TEXTURE_PLAYER_COLOR_MAP, shader->map_color, 1);
 asc_shader_upload_color(shader->color, player->color);
 asc_mesh_draw_triangle_strip(&sprite->mesh);
 }
+static void player_set_health(Player *player, unsigned health) {
+player->health = health;
+// TODO: probably we want to add more effects when the health changes
+}
+static unsigned player_get_health(Player *player) {
+return player->health;
+}
 static void player_move(AscBehavior *behavior) {
 AscSceneNode *node = behavior->node;
 Player *player = node->user_data;
+// TODO: instead of skipping this behavior, it should be disabled when health is zero
+if (player_get_health(player) == 0) return;
+// TODO: move this to a different behavior
+asc_scene_node_show(node);
 const float ts = (float) GAME_FIELD_TILE_SIZE;
 // check if the position is set programmatically
 if (player->reset_position) {
 asc_scene_node_set_position2f(node,
 // changing the direction not permitted, yet, continue movement
 asc_scene_node_move2f(node, movement);
 }
 }
+// die when leaving the game field
+if (node->position.x < 0 || node->position.y < 0 ||
+node->position.x > GAME_FIELD_SIZE*GAME_FIELD_TILE_SIZE ||
+node->position.y > GAME_FIELD_SIZE*GAME_FIELD_TILE_SIZE) {
+// TODO: add fancy death animation
+asc_scene_node_hide(node);
+player_set_health(player, 0);
+// TODO: remove the trace gradually (dequeuing the trace should be a different behavior)
+cxListClear(player->trace);
+game.state = GAME_STATE_GAME_OVER;
+return;
+}
 // TODO: collision detection
 // update the trace, if necessary.
 // remark: some calculations are repeated here, but they are cheap enough
 {
 // new owner of the tile!
 asc_vec2u p = tile_coords;
 cxListAdd(player->trace, &p);
 if (cxListSize(player->trace) > 7) {
 // TODO: implement power-up which makes the trace longer
-cxListPopFront(player->trace, &p);
+cxListRemove(player->trace, 0);
-game_field_tile_chown(p, NULL);
 }
 }
 }
 }
 }
 static void player_destroy(CxAllocator *allocator, Player *player) {
 cxListFree(player->trace);
 cxFree(allocator, player);
+}
+static void player_trace_release_tile(asc_vec2u *coords) {
+game_field_tile_chown(*coords, NULL);
 }
 static Player *player_create(void) {
 AscSceneNode *node = asc_sprite(
 .name = "Player",
 asc_scene_add_node(MAIN_SCENE, node);
 Player *player = asc_scene_node_allocate_data(node, sizeof(Player));
 player_position(player, 12, 8);
 player->speed = 3.f; // start with 3 tiles/sec
 player->number = 1;
+player->health = 100;
 player->color = ASC_RGB(1, 0, 0);
-player->trace = cxLinkedListCreateSimple(sizeof(asc_vec2i));
+player->trace = cxLinkedListCreateSimple(sizeof(asc_vec2u));
+cxDefineDestructor(player->trace, player_trace_release_tile);
 node->draw_func = player_draw;
 node->user_data_free_func = (cx_destructor_func2)player_destroy;
 asc_behavior_add(node, player_move);
 return player;
 }
 offset_y += margin;
 // Set the viewport to the scaled and centered region
 return ASC_RECT(offset_x, offset_y, viewport_size, viewport_size);
 }
-#define GAME_STATE_MENU 0
-#define GAME_STATE_PLAYING 1
-#define GAME_STATE_GAME_OVER 2
-typedef struct {
-int state;
-GameField *field;
-Player *players[4];
-} GameState;
 int main(void) {
 asc_context_initialize();
 if (asc_has_error()) {
 SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR,
 // create the fps counter
 AscSceneNode *fps_counter = fps_counter_create();
 asc_scene_node_hide(fps_counter);
-// create the game state
+// create game over text
-GameState game = {0};
+AscSceneNode *text_game_over = asc_text(
+.name = "game_over_text",
+.text = "Game Over\nPress R to Restart",
+.color = ASC_RGB(1, 1, 1),
+.font = asc_font(ASC_FONT_REGULAR, 36),
+.alignment = ASC_TEXT_ALIGN_CENTER,
+.centered = true,
+.x = (GAME_FIELD_SIZE+2)*GAME_FIELD_TILE_SIZE/2,
+.y = (GAME_FIELD_SIZE+2)*GAME_FIELD_TILE_SIZE/2 - 60,
+);
+asc_scene_node_hide(text_game_over);
+// TODO: add as a UI node and add a behavior which centers the node in the main scenes viewport
+//       otherwise we won't be able to implement a moving camera in the future
+asc_scene_add_node(MAIN_SCENE, text_game_over);
+// initialize the game state
 // TODO: add a main menu and start with the menu
 game.state = GAME_STATE_PLAYING;
-game.field = game_field_create();
 game.players[0] = player_create();
+game_field_create();
 // Main Loop
 do {
 // quit application on any error
 if (asc_has_error()) {
 asc_clear_error();
 asc_context_quit();
 }
 // game states
+// TODO: move all this into behaviors
 if (game.state == GAME_STATE_PLAYING) {
 // TODO: implement hot seat 1on1 multiplayer
 player_controls(game.players[0]);
+} else if (game.state == GAME_STATE_GAME_OVER) {
+asc_scene_node_show(text_game_over);
+if (asc_key_pressed(ASC_KEY(R))) {
+// TODO: re-load the "level"
+player_position(game.players[0], 12, 8);
+player_set_health(game.players[0], 100);
+game.state = GAME_STATE_PLAYING;
+asc_scene_node_hide(text_game_over);
+}
 }
 // debug-key for clearing the shader registry
 if (asc_key_pressed(ASC_KEY(S))) {
 asc_shader_clear_registry();

Mercurial > hg > ascension / file comparison

comparison: test/snake/snake.c

test/snake/snake.c