ascension: comparison test/snake/snake.c

-:943980fa37b5
+:4b3c974eab44
 MOVE_DOWN,
 MOVE_RIGHT
 };
 static asc_transform rotations[4];
-static asc_vec2f directions[4];
+static asc_vec2i directions[4];
 typedef struct {
 enum MoveDirection direction;
 enum MoveDirection target_direction;
 /**
 * The speed in tiles per second.
 */
 float speed;
 } Spaceship;
-static const unsigned game_field_size = 512;
+static const unsigned game_field_size = 16;
 static const unsigned game_field_tile_size = 32;
 static void init_globals(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_transform_roll(rotations[MOVE_DOWN], asc_rad(180));
-directions[MOVE_UP] = ASC_VEC2F(0, -1);
+directions[MOVE_UP] = ASC_VEC2I(0, -1);
-directions[MOVE_LEFT] = ASC_VEC2F(-1, 0);
+directions[MOVE_LEFT] = ASC_VEC2I(-1, 0);
-directions[MOVE_DOWN] = ASC_VEC2F(0, 1);
+directions[MOVE_DOWN] = ASC_VEC2I(0, 1);
-directions[MOVE_RIGHT] = ASC_VEC2F(1, 0);
+directions[MOVE_RIGHT] = ASC_VEC2I(1, 0);
 }
 static void destroy_textures(void) {
 asc_texture_destroy(tex2d, TEX2D_COUNT);
 }
 }
 static void move_spaceship(AscBehavior *behavior) {
 AscSceneNode *node = behavior->node;
 Spaceship *spaceship = node->user_data;
-const float ts = (float) game_field_tile_size;
+const int ts = (int) game_field_tile_size;
-const float speed = ts * spaceship->speed * asc_context.frame_factor;
+const float fts = (float) ts;
-const asc_vec2f dvec = directions[spaceship->direction];
+const float speed = fts * spaceship->speed * asc_context.frame_factor;
-const asc_vec2f movement = asc_vec2f_scale(dvec, speed);
+const asc_vec2i dir = directions[spaceship->direction];
+const asc_vec2f movement = asc_vec2f_scale(asc_vec2_itof(dir), speed);
+// check if we are supposed to change the direction
 if (spaceship->direction == spaceship->target_direction) {
-// no change of direction - keep moving
+// move without changing the direction
 asc_scene_node_move2f(node, movement);
 } else {
-// identify the tile we are currently in
+// determine axis
-int x = (int) (node->position.x / ts);
+// and check if we are about to cross the center
-int y = (int) (node->position.y / ts);
+// this relies on positive positions!
-const asc_vec2f tcenter = ASC_VEC2F(x*ts, y*ts);
+bool rotate = false;
-// calculate the (squared) distance to the tile's center
+if (movement.x == 0) {
-float cdist = asc_vec2f_sqrlen(asc_vec2f_sub(tcenter, ASC_VEC2F(node->position.x, node->position.y)));
+// vertical movement
-// if it is less than squared length of the movement vector, snap to the center and rotate
+const int y0 = (int)node->position.y / ts;
-// TODO: think about if we should allow changing direction only when we haven't passed the center yet
+const int y1 = (int)(node->position.y+movement.y) / ts;
-if (cdist < asc_vec2f_sqrlen(dvec)) {
+rotate = y0 != y1 && asc_sgn(y1-y0) == dir.y;
-asc_scene_node_set_position2f(node, tcenter);
+} else {
+// horizontal movement
+const int x0 = (int)node->position.x / ts;
+const int x1 = (int)(node->position.x+movement.x) / ts;
+rotate = x0 != x1 && asc_sgn(x1-x0) == dir.x;
+}
+if (rotate) {
+// snap position to the center of the tile
+node->position.x = roundf(node->position.x / fts) * fts;
+node->position.y = roundf(node->position.y / fts) * fts;
 spaceship->direction = spaceship->target_direction;
 asc_scene_node_set_rotation(node, rotations[spaceship->direction]);
-// TODO: this is losing some speed - improve the calculation and add partial movement after rotation
 } else {
-// too far away from center, continue normal movement
+// changing the direction not permitted, yet, continue movement
 asc_scene_node_move2f(node, movement);
 }
 }
 }
 }
 static void create_gamefield() {
 // TODO: create a proper data structure and a more interesting map than just a basic grid
 AscSceneNode *gamefield = asc_scene_node_empty();
-for (unsigned x = 0; x < game_field_size; x+=game_field_tile_size) {
+for (unsigned x = 1; x <= game_field_size; x++) {
-for (unsigned y = 0; y < game_field_size; y+=game_field_tile_size) {
+for (unsigned y = 1; y <= game_field_size; y++) {
 AscSceneNode *tile = asc_rectangle(
-.x = x, .y = y, .filled = true, .thickness = 1,
+.x = x*game_field_tile_size, .y = y*game_field_tile_size, .filled = true, .thickness = 1,
 .origin_x = game_field_tile_size / 2, .origin_y = game_field_tile_size / 2,
 .width = game_field_tile_size, .height = game_field_tile_size,
 .color = ASC_RGB(0, 128, 255),
 .border_color = ASC_RGB(64, 196, 255),
 );
 .type = ASC_CAMERA_ORTHO,
 .projection_update_func = asc_camera_ortho_update_size
 );
 asc_scene_init(MAIN_SCENE,
 .type = ASC_CAMERA_ORTHO,
-.ortho.rect = ASC_RECT(
+.ortho.rect = ASC_RECT(0, 0,
--game_field_tile_size,
+(game_field_size+1)*game_field_tile_size,
--game_field_tile_size,
+(game_field_size+1)*game_field_tile_size
-game_field_size+game_field_tile_size,
-game_field_size+game_field_tile_size
 ),
 .viewport_clear = true,
 .clear_color = ASC_RGB(0, 128, 90),
 .viewport_update_func = update_viewport_for_window_resize
 );
 asc_clear_error();
 asc_context_quit();
 }
 // player rotation
+// TODO: queue up to two movement commands (for sharp 90° turns)
 if (asc_key_pressed(ASC_KEY(LEFT))) {
 if (spaceship->direction != MOVE_RIGHT) {
 spaceship->target_direction = MOVE_LEFT;
 }
 }

Mercurial > hg > ascension / file comparison

comparison: test/snake/snake.c

test/snake/snake.c