[game] Render tiles from all layers, support multiple IntGrid layers

game/level.ts

@@ -51,7 +51,7 @@ export interface Level {
   ch: number;
   tile_layers: TileLayer[];
   entities: Entity[];
-  values: number[];
+  values: { [key: string]: number[] };
 }
 
 export interface World {
@@ -82,25 +82,35 @@ async function load_tileset(def: LDTKTilesetDef): Promise<TileSet> {
   return { id: def.uid, texture, tags };
 }
 
+interface LDTKTile {
+  px: [number, number];
+  src: [number, number];
+  f: number;
+  t: number;
+  a: number;
+}
+
 interface LDTKTileLayerInstance {
-  __type: "Tiles";
+  __type: "Tiles" | "IntGrid";
+  __identifier: string;
   __gridSize: number;
   __pxTotalOffsetX: number;
   __pxTotalOffsetY: number;
   __tilesetDefUid: number;
-  gridTiles: {
-    px: [number, number];
-    src: [number, number];
-    f: number;
-    t: number;
-    a: number;
-  }[];
+
+  autoLayerTiles: LDTKTile[];
+  gridTiles: LDTKTile[];
 }
 
 function load_tile_layer_instance(
   tile_sets: Map<number, TileSet>,
   li: LDTKTileLayerInstance
-): TileLayer {
+): TileLayer | undefined {
+  const tiles = li.autoLayerTiles.concat(li.gridTiles);
+  if (tiles.length == 0) {
+    return;
+  }
+
   const tileset = tile_sets.get(li.__tilesetDefUid);
   if (!tileset) {
     throw new Error("Unable to find texture!!! " + li.__tilesetDefUid);
@@ -111,7 +121,7 @@ function load_tile_layer_instance(
     tileset,
     grid_size: li.__gridSize,
     offset: [li.__pxTotalOffsetX, li.__pxTotalOffsetY],
-    tiles: li.gridTiles,
+    tiles,
   };
 }
 
@@ -139,6 +149,7 @@ function load_entity_layer_instance(li: LDTKEntityLayerInstance): Entity[] {
 
 interface LDTKIntGridLayerInstance {
   __type: "IntGrid";
+  __identifier: string;
   __cWid: number;
   __cHei: number;
   intGridCsv: number[];
@@ -152,7 +163,7 @@ type LDTKLayerInstance =
 function is_tile_layer_instance(
   x: LDTKLayerInstance
 ): x is LDTKTileLayerInstance {
-  return x.__type == "Tiles";
+  return x.__type == "Tiles" || x.__type == "IntGrid";
 }
 
 function is_entity_layer_instance(
@@ -185,26 +196,30 @@ function load_level(tile_sets: Map<number, TileSet>, def: LDTKLevel): Level {
     ch: 0,
     tile_layers: [],
     entities: [],
-    values: [],
+    values: {},
   };
 
   for (const li of def.layerInstances) {
     if (is_tile_layer_instance(li)) {
       const tli = load_tile_layer_instance(tile_sets, li);
+      if (tli) {
+        result.tile_layers.push(tli);
+      }
+    }
 
-      result.tile_layers.push(tli);
-    } else if (is_entity_layer_instance(li)) {
+    if (is_entity_layer_instance(li)) {
       // TODO: Why would I support multiple entity layers?
       result.entities = load_entity_layer_instance(li);
-    } else if (is_intgrid_layer_instance(li)) {
+    }
+
+    if (is_intgrid_layer_instance(li)) {
       result.cw = li.__cWid;
       result.ch = li.__cHei;
-      result.values = li.intGridCsv; // ?
-    } else {
-      print("WARNING: Unknown layer type");
+      result.values[li.__identifier] = li.intGridCsv;
     }
   }
 
+  result.tile_layers = result.tile_layers.reverse();
   return result;
 }
 
@@ -266,7 +281,9 @@ export function has_collision(level: Level, cx: number, cy: number): boolean {
   if (!level) return true;
   if (cx < 0 || cx >= level.cw) return false;
   if (cy < 0 || cy >= level.ch) return false;
-  return level.values[cy * level.cw + cx] != 0; // TODO: MAGIC NUMBER?
+
+  const values = level.values.collisions;
+  return values[cy * level.cw + cx] != 0; // TODO: MAGIC NUMBER?
 }
 
 export function draw_level(