[common] get rid of the HashMap in the scene implementation

Author: rexim

client.wasm

@@ -278,29 +278,29 @@ fn Vector2 ray_step(Vector2 p1, Vector2 p2) {
     return p3;
 }
 
-fn Vector2 cast_ray(Scene *scene, Vector2 p1, Vector2 p2) {
+fn Vector2 cast_ray(Vector2 p1, Vector2 p2) {
     Vector2 start = p1;
     while (vector2::distance(start, p1) < FAR_CLIPPING_PLANE) {
         Vector2 c = hitting_cell(p1, p2);
-        if (scene.get_tile(c)) break;
+        if (common::scene_get_tile(c)) break;
         Vector2 p3 = ray_step(p1, p2);
         p1 = p2;
         p2 = p3;
     }
     return p2;
 }
 
-fn void render_walls(Image *display, float *zbuffer, Image *wall, Scene *scene) {
+fn void render_walls(Image *display, float *zbuffer, Image *wall) {
     Camera camera = { .position = {me.position.x, me.position.y}, .direction = me.direction };
     camera.update();
 
     Vector2 d = vector2::from_polar(camera.direction, 1.0f);
     for (int x = 0; x < display.width; ++x) {
-        Vector2 p = cast_ray(scene, camera.position, vector2::lerp(camera.fovLeft, camera.fovRight, (float)x/display.width));
+        Vector2 p = cast_ray(camera.position, vector2::lerp(camera.fovLeft, camera.fovRight, (float)x/display.width));
         Vector2 c = hitting_cell(camera.position, p);
         Vector2 v = vector2::sub(p, camera.position);
         zbuffer[x] = vector2::dot(v, d);
-        if (scene.get_tile(c)) render_column_of_wall(display, zbuffer, wall, x, p, c);
+        if (common::scene_get_tile(c)) render_column_of_wall(display, zbuffer, wall, x, p, c);
     }
 }
 
@@ -414,14 +414,14 @@ fn void emit_particle(Vector3 source, ParticlePool *particle_pool) {
     }
 }
 
-fn void update_particles(Image *image, SpritePool *sprite_pool, float deltaTime, Scene *scene, ParticlePool *particle_pool) {
+fn void update_particles(Image *image, SpritePool *sprite_pool, float deltaTime, ParticlePool *particle_pool) {
     foreach (&particle: particle_pool.items) {
         if (particle.lifetime > 0) {
             particle.lifetime -= deltaTime;
             particle.velocity_z -= common::BOMB_GRAVITY*deltaTime;
 
             Vector2 new_position = vector2::add(particle.position, vector2::mul(particle.velocity, vector2::xx(deltaTime)));
-            if (scene.get_tile(new_position)) {
+            if (common::scene_get_tile(new_position)) {
                 float dx = math::abs(math::floor(particle.position.x) - math::floor(new_position.x));
                 float dy = math::abs(math::floor(particle.position.y) - math::floor(new_position.y));
 
@@ -539,12 +539,12 @@ fn void explode_bomb(Vector3 bomb_position, Vector2 player_position, ParticlePoo
     }
 }
 
-fn void update_bombs_on_client_side(SpritePool *sprite_pool, ParticlePool *particle_pool, Image *bomb_image, Scene *scene, float delta_time, Bombs *bombs) {
+fn void update_bombs_on_client_side(SpritePool *sprite_pool, ParticlePool *particle_pool, Image *bomb_image, float delta_time, Bombs *bombs) {
     foreach (&bomb: *bombs) {
         if (bomb.lifetime > 0) {
             push_sprite(sprite_pool, bomb_image, {bomb.position.x, bomb.position.y, bomb.position_z}, common::BOMB_SCALE, {0, 0}, {bomb_image.width, bomb_image.height});
 
-            if (common::update_bomb(bomb, scene, delta_time)) {
+            if (common::update_bomb(bomb, delta_time)) {
                 platform::play_sound(BOMB_RICOCHET, me.position.x, me.position.y, bomb.position.x, bomb.position.y);
             }
 
@@ -699,11 +699,11 @@ fn uint sprite_angle_index(Vector2 camera_position, Player entity) {
     return (uint)math::floor(common::proper_mod(common::proper_mod(entity.direction, TAU) - common::proper_mod(vector2::sub(entity.position, camera_position).angle_fixed(), TAU) - PI + PI/8, TAU)/TAU*SPRITE_ANGLES_COUNT);
 }
 
-fn void update_all_players(Scene *scene, float delta_time) {
+fn void update_all_players(float delta_time) {
     other_players.@each_entry(; OtherPlayersEntry *entry) {
-        common::update_player(&entry.value, scene, delta_time);
+        common::update_player(&entry.value, delta_time);
     };
-    common::update_player(&me, scene, delta_time);
+    common::update_player(&me, delta_time);
 }
 
 fn void render_other_players(SpritePool *sprite_pool, Image *player_image) {
@@ -801,15 +801,15 @@ fn void render_game(float delta_time, float time) @extern("render_game") @wasm {
     assert(asset);
     Image player_image = {asset.width, asset.height, (Color*)&pack[asset.offset]};
 
-    update_all_players(&common::scene, delta_time);
+    update_all_players(delta_time);
     update_items(&sprite_pool, time, common::items_ptr(), common::items_len(), &key_image, &bomb_image);
-    update_bombs_on_client_side(&sprite_pool, &particle_pool, &bomb_image, &common::scene, delta_time, &common::bombs);
-    update_particles(&particle_image, &sprite_pool, delta_time, &common::scene, &particle_pool);
+    update_bombs_on_client_side(&sprite_pool, &particle_pool, &bomb_image, delta_time, &common::bombs);
+    update_particles(&particle_image, &sprite_pool, delta_time, &particle_pool);
 
     render_other_players(&sprite_pool, &player_image);
 
     render_floor_and_ceiling(&display.image);
-    render_walls(&display.image, display.zbuffer, &wall_image, &common::scene);
+    render_walls(&display.image, display.zbuffer, &wall_image);
     cull_and_sort_sprites(&sprite_pool);
     render_sprites(&display.image, display.zbuffer, &sprite_pool);
 
@@ -906,7 +906,6 @@ fn void entry() @init(2048) @private {
         return buffer.len;
     };
     common::temp_mark = allocator::temp().used;
-    common::load_default_scene();
 }
 
 module client::platform;

src/client.c3

@@ -161,7 +161,7 @@ int throw_bomb(Vector2 position, float direction, Bombs *bombs) {
 
 // Player //////////////////////////////
 
-void update_player(Player *player, Scene *scene, float delta_time) {
+void update_player(Player *player, float delta_time) {
     Vector2 control_velocity = {0, 0};
     float angular_velocity = 0.0;
     if ((player->moving>>(uint32_t)MOVING_FORWARD)&1) {
@@ -179,11 +179,11 @@ void update_player(Player *player, Scene *scene, float delta_time) {
     player->direction = __builtin_fmodf(player->direction + angular_velocity*delta_time, 2*PI);
 
     float nx = player->position.x + control_velocity.x*delta_time;
-    if (scene_can_rectangle_fit_here(scene, nx, player->position.y, PLAYER_SIZE, PLAYER_SIZE)) {
+    if (scene_can_rectangle_fit_here(nx, player->position.y, PLAYER_SIZE, PLAYER_SIZE)) {
         player->position.x = nx;
     }
     float ny = player->position.y + control_velocity.y*delta_time;
-    if (scene_can_rectangle_fit_here(scene, player->position.x, ny, PLAYER_SIZE, PLAYER_SIZE)) {
+    if (scene_can_rectangle_fit_here(player->position.x, ny, PLAYER_SIZE, PLAYER_SIZE)) {
         player->position.y = ny;
     }
 }

src/common.c

@@ -57,47 +57,33 @@ struct Message @packed {
 
 /// Scene //////////////////////////////
 
-struct Scene {
-    HashMap(<IVector2, bool>) walls;
-}
-
-Scene scene;
-fn void load_default_scene() {
-    bool[*][*] default_walls = {
-        { false, false, true, true, true, false, false},
-        { false, false, false, false, false, true, false},
-        { true, false, false, false, false, true, false},
-        { true,  false, false, false, false, true, false},
-        { true, false, false, false, false, false, false},
-        { false,  true, true, true, false, false, false},
-        { false,  false, false, false, false, false, false},
-    };
-    usz width = default_walls[0].len;
-    usz height = default_walls.len;
-    for (int y = 0; y < height; ++y) {
-        for (int x = 0; x < width; ++x) {
-            if (default_walls[y][x]) {
-                scene.walls.set({x, y}, default_walls[y][x]);
-            }
-        }
-    }
-}
-
-fn bool Scene.get_tile(&scene, Vector2 p) {
-    if (try tile = scene.walls.get(ivector2::from_vector2(vector2::floor(p)))) {
-        return tile;
-    }
-    return false;
-}
-
-fn bool scene_can_rectangle_fit_here(Scene *scene, float px, float py, float sx, float sy) @export("scene_can_rectangle_fit_here") {
+const usz WALLS_WIDTH = 7;
+const usz WALLS_HEIGHT = 7;
+bool[WALLS_HEIGHT][WALLS_WIDTH] walls = {
+    { false, false, true, true, true, false, false},
+    { false, false, false, false, false, true, false},
+    { true, false, false, false, false, true, false},
+    { true,  false, false, false, false, true, false},
+    { true, false, false, false, false, false, false},
+    { false,  true, true, true, false, false, false},
+    { false,  false, false, false, false, false, false},
+};
+
+fn bool scene_get_tile(Vector2 p) {
+    IVector2 ip = ivector2::from_vector2(vector2::floor(p));
+    if (!(0 <= ip.x && ip.x < WALLS_WIDTH)) return false;
+    if (!(0 <= ip.y && ip.y < WALLS_HEIGHT)) return false;
+    return walls[ip.y][ip.x];
+}
+
+fn bool scene_can_rectangle_fit_here(float px, float py, float sx, float sy) @export("scene_can_rectangle_fit_here") {
     int x1 = (int)math::floor(px - sx*0.5f);
     int x2 = (int)math::floor(px + sx*0.5f);
     int y1 = (int)math::floor(py - sy*0.5f);
     int y2 = (int)math::floor(py + sy*0.5f);
     for (int x = x1; x <= x2; ++x) {
         for (int y = y1; y <= y2; ++y) {
-            if (scene.get_tile({x, y})) {
+            if (scene_get_tile({x, y})) {
                 return false;
             }
         }
@@ -177,14 +163,14 @@ fn int throw_bomb(Vector2 position, float direction, Bombs *bombs) {
     return -1;
 }
 
-fn bool update_bomb(Bomb *bomb, Scene* scene, float delta_time) @export("update_bomb") {
+fn bool update_bomb(Bomb *bomb, float delta_time) @export("update_bomb") {
     bool collided = false;
     bomb.lifetime -= delta_time;
     bomb.velocity_z -= BOMB_GRAVITY*delta_time;
 
     float nx = bomb.position.x + bomb.velocity.x*delta_time;
     float ny = bomb.position.y + bomb.velocity.y*delta_time;
-    if (scene.get_tile({nx, ny})) {
+    if (scene_get_tile({nx, ny})) {
         float dx = math::abs(math::floor(bomb.position.x) - math::floor(nx));
         float dy = math::abs(math::floor(bomb.position.y) - math::floor(ny));
 
@@ -345,7 +331,7 @@ struct PingMessage @packed {
 }
 macro verify_ping_message(message) => msg::batch::verify(MessageKind.PING, message, uint.sizeof);
 
-extern fn void update_player(Player *player, Scene *scene, float delta_time) @extern("update_player");
+extern fn void update_player(Player *player, float delta_time) @extern("update_player");
 
 /// Temporary Memory //////////////////////////////
 

src/common.c3

@@ -58,7 +58,7 @@ typedef struct {
 
 typedef void Scene;
 
-bool scene_can_rectangle_fit_here(Scene *scene, float px, float py, float sx, float sy); // Implemented in C3
+bool scene_can_rectangle_fit_here(float px, float py, float sx, float sy); // Implemented in C3
 
 // Player //////////////////////////////
 
@@ -78,7 +78,7 @@ typedef struct {
     uint8_t hue;
 } Player;
 
-void update_player(Player *player, Scene *scene, float delta_time);
+void update_player(Player *player, float delta_time);
 
 // Items //////////////////////////////
 
@@ -116,7 +116,7 @@ typedef struct {
 extern Bombs bombs;             // Implemented in C3
 
 int throw_bomb(Vector2 position, float direction, Bombs *bombs);
-bool update_bomb(Bomb *bomb, Scene *scene, float delta_time); // Implemented in C3
+bool update_bomb(Bomb *bomb, float delta_time); // Implemented in C3
 
 // Messages //////////////////////////////
 

src/common.h

@@ -385,11 +385,11 @@ BombsSpawnedBatchMessage *thrown_bombs_as_batch_message(Bombs *bombs) {
 
 Indices exploded_bombs = {0};
 
-void update_bombs_on_server_side(Scene *scene, float delta_time, Bombs *bombs) {
+void update_bombs_on_server_side(float delta_time, Bombs *bombs) {
     for (size_t bombIndex = 0; bombIndex < BOMBS_CAPACITY; ++bombIndex) {
         Bomb *bomb = &bombs->items[bombIndex];
         if (bomb->lifetime > 0) {
-            update_bomb(bomb, scene, delta_time);
+            update_bomb(bomb, delta_time);
             if (bomb->lifetime <= 0) {
                 da_append(&exploded_bombs, bombIndex);
             }
@@ -426,11 +426,11 @@ void process_thrown_bombs(Bombs *bombs) {
 
 // World //////////////////////////////
 
-void process_world_simulation(Item *items, size_t items_len, Scene *scene, Bombs *bombs, float delta_time) {
+void process_world_simulation(Item *items, size_t items_len, Bombs *bombs, float delta_time) {
     // Simulating the world for one server tick.
     for (ptrdiff_t i = 0; i < hmlen(players); ++i) {
         PlayerOnServerEntry* entry = &players[i];
-        update_player(&entry->value.player, scene, delta_time);
+        update_player(&entry->value.player, delta_time);
         collect_items_by_player(entry->value.player, items, items_len);
     }
 
@@ -442,7 +442,7 @@ void process_world_simulation(Item *items, size_t items_len, Scene *scene, Bombs
         }
     }
 
-    update_bombs_on_server_side(scene, delta_time, bombs);
+    update_bombs_on_server_side(delta_time, bombs);
     BombsExplodedBatchMessage *bombs_exploded_batch_message = exploded_bombs_as_batch_message(bombs);
     if (bombs_exploded_batch_message) {
         for (ptrdiff_t i = 0; i < hmlen(players); ++i) {

src/server.c

@@ -33,7 +33,7 @@ extern fn ItemsCollectedBatchMessage *collected_items_as_batch_message() @extern
 
 extern fn void throw_bomb_on_server_side(uint player_id, Bombs *bombs) @extern("throw_bomb_on_server_side");
 extern fn BombsSpawnedBatchMessage *thrown_bombs_as_batch_message(Bombs *bombs) @extern("thrown_bombs_as_batch_message");
-extern fn void update_bombs_on_server_side(Scene *scene, float delta_time, Bombs *bombs) @extern("update_bombs_on_server_side");
+extern fn void update_bombs_on_server_side(float delta_time, Bombs *bombs) @extern("update_bombs_on_server_side");
 extern fn BombsExplodedBatchMessage* exploded_bombs_as_batch_message(Bombs* bombs) @extern("exploded_bombs_as_batch_message");
 
 /// Player //////////////////////////////
@@ -70,7 +70,7 @@ extern fn void process_left_players() @extern("process_left_players");
 extern fn void process_moving_players() @extern("process_moving_players");
 extern fn void process_thrown_bombs(Bombs *bombs) @extern("process_thrown_bombs");
 
-extern fn void process_world_simulation(Item *items, usz items_len, Scene *scene, Bombs *bombs, float delta_time) @extern("process_world_simulation");
+extern fn void process_world_simulation(Item *items, usz items_len, Bombs *bombs, float delta_time) @extern("process_world_simulation");
 
 extern fn void process_pings() @extern("process_pings");
 extern fn void clear_intermediate_ids() @extern("clear_intermediate_ids");
@@ -85,7 +85,7 @@ fn uint tick() @extern("tick") @wasm {
     process_left_players();
     process_moving_players();
     process_thrown_bombs(&common::bombs);
-    process_world_simulation(common::items_ptr(), common::items_len(), &common::scene, &common::bombs, delta_time);
+    process_world_simulation(common::items_ptr(), common::items_len(), &common::bombs, delta_time);
     process_pings();
 
     uint tickTime = now_msecs() - timestamp;
@@ -125,7 +125,6 @@ fn int main() {
 
     stats::start_timer_at(StatEntry.UPTIME, now_msecs());
     common::temp_mark = allocator::temp().used;
-    common::load_default_scene();
     server::previous_timestamp = now_msecs();
 
     const String HOST = "0.0.0.0";