Tuck items under the WASM

client.c3

@@ -916,9 +916,9 @@ fn void key_up(uint key_code) @extern("key_up") @wasm {
     }
 }
 
-fn void render_game(Image *display, float *zbuffer, SpritePool *sprite_pool, ParticlePool *particle_pool, Scene *scene, Item[] *items, Bombs *bombs, Image *key_image, Image *bomb_image, Image *particle_image, Image *wall_image, Image *player_image, float delta_time, float time) @extern("render_game") @wasm {
+fn void render_game(Image *display, float *zbuffer, SpritePool *sprite_pool, ParticlePool *particle_pool, Scene *scene, Bombs *bombs, Image *key_image, Image *bomb_image, Image *particle_image, Image *wall_image, Image *player_image, float delta_time, float time) @extern("render_game") @wasm {
     update_all_players(scene, delta_time);
-    update_items(sprite_pool, time, items, key_image, bomb_image);
+    update_items(sprite_pool, time, &common::items, key_image, bomb_image);
     update_bombs_on_client_side(sprite_pool, particle_pool, bomb_image, scene, delta_time, bombs);
     update_particles(particle_image, sprite_pool, delta_time, scene, particle_pool);
 
@@ -962,10 +962,10 @@ fn uint ping_msecs() @extern("ping_msecs") @wasm {
     return ping;
 }
 
-fn bool process_message(Message *message, Item[] *items, Bombs *bombs, ParticlePool *particle_pool) @extern("process_message") @wasm {
+fn bool process_message(Message *message, Bombs *bombs, ParticlePool *particle_pool) @extern("process_message") @wasm {
     // TODO: verify_* functions should return the typed message with exception, so we can turn this into sequence of if-try-s
     if (verify_hello_message(message)) {
-        apply_hello_message_to_me((HelloMessage*)message, items);
+        apply_hello_message_to_me((HelloMessage*)message, &common::items);
     } else if (verify_players_joined_batch_message(message)) {
         apply_players_joined_batch_message((PlayersJoinedBatchMessage*)message);
     } else if (verify_players_left_batch_message(message)) {
@@ -977,11 +977,11 @@ fn bool process_message(Message *message, Item[] *items, Bombs *bombs, ParticleP
     } else if (verify_pong_message(message)) {
         process_pong_message((PongMessage*)message);
     } else if (verify_items_collected_batch_message(message)) {
-        if (!apply_items_collected_batch_message_to_level_items((ItemsCollectedBatchMessage*)message, items)) {
+        if (!apply_items_collected_batch_message_to_level_items((ItemsCollectedBatchMessage*)message, &common::items)) {
             return false;
         }
     } else if (verify_items_spawned_batch_message(message)) {
-        if (!apply_items_spawned_batch_message_to_level_items((ItemsSpawnedBatchMessage*)message, items)) {
+        if (!apply_items_spawned_batch_message_to_level_items((ItemsSpawnedBatchMessage*)message, &common::items)) {
             return false;
         }
     } else if (verify_bombs_spawned_batch_message(message)) {

client.mjs

@@ -231,7 +231,7 @@ async function createGame() {
             return;
         }
         const eventDataPtr = common.arrayBufferAsMessageInWasm(wasmClient, event.data);
-        if (!game.wasmClient.process_message(eventDataPtr, game.level.itemsPtr, game.level.bombsPtr, game.particlesPtr)) {
+        if (!game.wasmClient.process_message(eventDataPtr, game.level.bombsPtr, game.particlesPtr)) {
             ws?.close();
             return;
         }
@@ -242,7 +242,7 @@ async function createGame() {
     return game;
 }
 function renderGame(display, deltaTime, time, game) {
-    game.wasmClient.render_game(display.backImagePtr, display.zBufferPtr, game.spritePoolPtr, game.particlesPtr, game.level.scenePtr, game.level.itemsPtr, game.level.bombsPtr, game.assets.keyImagePtr, game.assets.bombImagePtr, game.assets.particleImagePtr, game.assets.wallImagePtr, game.assets.playerImagePtr, deltaTime, time);
+    game.wasmClient.render_game(display.backImagePtr, display.zBufferPtr, game.spritePoolPtr, game.particlesPtr, game.level.scenePtr, game.level.bombsPtr, game.assets.keyImagePtr, game.assets.bombImagePtr, game.assets.particleImagePtr, game.assets.wallImagePtr, game.assets.playerImagePtr, deltaTime, time);
     displaySwapBackImageData(display, game.wasmClient);
     if (MINIMAP)
         game.wasmClient.render_minimap(display.minimapPtr, game.level.scenePtr, game.spritePoolPtr);

client.mts

@@ -70,10 +70,10 @@ interface WasmClient extends common.WasmCommon {
     unregister_all_other_players: () => void,
     key_down: (key_code: number, bombs: number) => void,
     key_up: (key_code: number) => void,
-    render_game: (display: number, zbuffer: number, sprite_pool: number, particle_pool: number, scene: number, items: number, bombs: number, key_image: number, bomb_image: number, particle_image: number, wall_image: number, player_image: number, delta_time: number, time: number) => void,
+    render_game: (display: number, zbuffer: number, sprite_pool: number, particle_pool: number, scene: number, bombs: number, key_image: number, bomb_image: number, particle_image: number, wall_image: number, player_image: number, delta_time: number, time: number) => void,
     ping_server_if_needed: () => void,
     ping_msecs: () => number,
-    process_message: (message: number, items: number, bombs: number, particle_pool: number) => boolean,
+    process_message: (message: number, bombs: number, particle_pool: number) => boolean,
 }
 
 function createDisplay(wasmClient: WasmClient, backImageWidth: number, backImageHeight: number): Display {
@@ -236,7 +236,7 @@ async function instantiateWasmClient(url: string): Promise<WasmClient> {
         unregister_all_other_players: wasm.instance.exports.unregister_all_other_players as () => void,
         key_down: wasm.instance.exports.key_down as (key_code: number) => void,
         key_up: wasm.instance.exports.key_up as (key_code: number) => void,
-        render_game: wasm.instance.exports.render_game as (display: number, zbuffer: number, sprite_pool: number, particle_pool: number, scene: number, items: number, bombs: number, key_image: number, bomb_image: number, particle_image: number, wall_image: number, player_image: number, delta_time: number, time: number) => void,
+        render_game: wasm.instance.exports.render_game as (display: number, zbuffer: number, sprite_pool: number, particle_pool: number, scene: number, bombs: number, key_image: number, bomb_image: number, particle_image: number, wall_image: number, player_image: number, delta_time: number, time: number) => void,
         ping_server_if_needed: wasm.instance.exports.ping_server_if_needed as () => void,
         ping_msecs: wasm.instance.exports.ping_msecs as () => number,
         process_message: wasm.instance.exports.process_message as (message: number) => boolean,
@@ -315,7 +315,7 @@ async function createGame(): Promise<Game> {
         }
         const eventDataPtr = common.arrayBufferAsMessageInWasm(wasmClient, event.data);
         // console.log(`Received message from server`, new Uint8ClampedArray(event.data));
-        if (!game.wasmClient.process_message(eventDataPtr, game.level.itemsPtr, game.level.bombsPtr, game.particlesPtr)) {
+        if (!game.wasmClient.process_message(eventDataPtr, game.level.bombsPtr, game.particlesPtr)) {
             ws?.close();
             return;
         }
@@ -328,7 +328,7 @@ async function createGame(): Promise<Game> {
 }
 
 function renderGame(display: Display, deltaTime: number, time: number, game: Game) {
-    game.wasmClient.render_game(display.backImagePtr, display.zBufferPtr, game.spritePoolPtr, game.particlesPtr, game.level.scenePtr, game.level.itemsPtr, game.level.bombsPtr, game.assets.keyImagePtr, game.assets.bombImagePtr, game.assets.particleImagePtr, game.assets.wallImagePtr, game.assets.playerImagePtr, deltaTime, time);
+    game.wasmClient.render_game(display.backImagePtr, display.zBufferPtr, game.spritePoolPtr, game.particlesPtr, game.level.scenePtr, game.level.bombsPtr, game.assets.keyImagePtr, game.assets.bombImagePtr, game.assets.particleImagePtr, game.assets.wallImagePtr, game.assets.playerImagePtr, deltaTime, time);
     displaySwapBackImageData(display, game.wasmClient);
 
     if (MINIMAP) game.wasmClient.render_minimap(display.minimapPtr, game.level.scenePtr, game.spritePoolPtr);

common.c3

@@ -158,10 +158,6 @@ Item[] items = {
     },
 };
 
-fn Item[]* allocate_items() @export("allocate_items") @wasm {
-    return &items;
-}
-
 fn bool collect_item(float player_position_x, float player_position_y, Item[] *items, usz item_index) @extern("collect_item") @wasm {
     if (item_index >= items.len) return false;
     Item *item = &(*items)[item_index];

common.mjs

@@ -5,7 +5,6 @@ export function makeWasmCommon(wasm) {
         wasm,
         memory: wasm.instance.exports.memory,
         _initialize: wasm.instance.exports._initialize,
-        allocate_items: wasm.instance.exports.allocate_items,
         reset_temp_mark: wasm.instance.exports.reset_temp_mark,
         allocate_temporary_buffer: wasm.instance.exports.allocate_temporary_buffer,
         allocate_bombs: wasm.instance.exports.allocate_bombs,
@@ -14,9 +13,8 @@ export function makeWasmCommon(wasm) {
 }
 export function createLevel(wasmCommon) {
     const scenePtr = wasmCommon.allocate_default_scene();
-    const itemsPtr = wasmCommon.allocate_items();
     const bombsPtr = wasmCommon.allocate_bombs();
-    return { scenePtr, itemsPtr, bombsPtr };
+    return { scenePtr, bombsPtr };
 }
 export function arrayBufferAsMessageInWasm(wasmCommon, buffer) {
     const wasmBufferSize = buffer.byteLength + UINT32_SIZE;

common.mts

@@ -5,7 +5,6 @@ export interface WasmCommon {
     wasm: WebAssembly.WebAssemblyInstantiatedSource,
     memory: WebAssembly.Memory,
     _initialize: () => void,
-    allocate_items: () => number,
     reset_temp_mark: () => void,
     allocate_temporary_buffer: (size: number) => number,
     allocate_bombs: () => number,
@@ -17,7 +16,6 @@ export function makeWasmCommon(wasm: WebAssembly.WebAssemblyInstantiatedSource):
         wasm,
         memory: wasm.instance.exports.memory  as WebAssembly.Memory,
         _initialize: wasm.instance.exports._initialize as () => void,
-        allocate_items: wasm.instance.exports.allocate_items as () => number,
         reset_temp_mark: wasm.instance.exports.reset_temp_mark as () => void,
         allocate_temporary_buffer: wasm.instance.exports.allocate_temporary_buffer as (size: number) => number,
         allocate_bombs: wasm.instance.exports.allocate_bombs as () => number,
@@ -29,15 +27,13 @@ export function makeWasmCommon(wasm: WebAssembly.WebAssemblyInstantiatedSource):
 // between Client and Server and constantly synced over the network.
 export interface Level {
     scenePtr: number,
-    itemsPtr: number,
     bombsPtr: number,
 }
 
 export function createLevel(wasmCommon: WasmCommon): Level {
     const scenePtr = wasmCommon.allocate_default_scene();
-    const itemsPtr = wasmCommon.allocate_items();
     const bombsPtr = wasmCommon.allocate_bombs();
-    return {scenePtr, itemsPtr, bombsPtr};
+    return {scenePtr, bombsPtr};
 }
 
 export function arrayBufferAsMessageInWasm(wasmCommon: WasmCommon, buffer: ArrayBuffer): number {

server.c3

@@ -598,16 +598,16 @@ fn bool process_message_on_server(uint id, Message *message, Bombs *bombs) @exte
 }
 
 uint previous_timestamp = 0;
-fn uint tick(Item[]* items, Bombs *bombs, Scene *scene) @extern("tick") @wasm {
+fn uint tick(Bombs *bombs, Scene *scene) @extern("tick") @wasm {
     uint timestamp = platform_now_msecs();
     float delta_time = (float)(timestamp - previous_timestamp)/1000.0f;
     previous_timestamp = timestamp;
 
-    process_joined_players(items);
+    process_joined_players(&common::items);
     process_left_players();
     process_moving_players();
     process_thrown_bombs(bombs);
-    process_world_simulation(items, scene, bombs, delta_time);
+    process_world_simulation(&common::items, scene, bombs, delta_time);
     process_pings();
 
     uint tickTime = platform_now_msecs() - timestamp;

server.mjs

@@ -85,7 +85,7 @@ wss.on("connection", (ws, req) => {
     });
 });
 function tick() {
-    const tickTime = wasmServer.tick(level.itemsPtr, level.bombsPtr, level.scenePtr);
+    const tickTime = wasmServer.tick(level.bombsPtr, level.scenePtr);
     setTimeout(tick, Math.max(0, 1000 / SERVER_FPS - tickTime));
 }
 function platform_now_secs() {

server.mts

@@ -104,7 +104,7 @@ wss.on("connection", (ws, req) => {
 })
 
 function tick() {
-    const tickTime = wasmServer.tick(level.itemsPtr, level.bombsPtr, level.scenePtr);
+    const tickTime = wasmServer.tick(level.bombsPtr, level.scenePtr);
     setTimeout(tick, Math.max(0, 1000/SERVER_FPS - tickTime));
 }
 
@@ -113,7 +113,7 @@ interface WasmServer extends common.WasmCommon {
     register_new_player: (id: number, x: number, y: number, hue: number) => void,
     unregister_player: (id: number) => void,
     process_message_on_server: (id: number, message: number, bombs: number) => boolean,
-    tick: (items: number, bombs: number, scene: number) => number,
+    tick: (bombs: number, scene: number) => number,
 }
 
 function platform_now_secs(): number {
@@ -155,7 +155,7 @@ async function instantiateWasmServer(path: string): Promise<WasmServer> {
         register_new_player: wasm.instance.exports.register_new_player as (id: number, x: number, y: number, hue: number) => void,
         unregister_player: wasm.instance.exports.unregister_player as (id: number) => void,
         process_message_on_server: wasm.instance.exports.process_message_on_server as (id: number, message: number, bombs: number) => boolean,
-        tick: wasm.instance.exports.tick as (items: number, bombs: number, scene: number) => number,
+        tick: wasm.instance.exports.tick as (bombs: number, scene: number) => number,
     };
 }