[oden][game] Draw the world

This involved basically a giant rewrite of the renderer because I now
need to share the vertex buffer across textures and it is *a lot* let
me tell you.

There's like a vertical seam which I don't understand yet.

game/level.ts

@@ -0,0 +1,141 @@
+// NOTE: It's super not clear how much of this should be in rust vs
+//       javascript. Dealing with the level code is really nice in javascript
+//       but there's a bunch of weird stuff that really feels lower level.
+import { load_texture } from "./assets";
+import { Texture, print, spr, use_texture } from "./graphics";
+import { load_string } from "./io";
+
+// TODO: Use io-ts? YIKES.
+
+export type Tile = {
+  px: [number, number];
+  src: [number, number];
+  f: number;
+  t: number;
+  a: number;
+};
+
+export type TileLayer = {
+  type: "tile";
+  texture: Texture;
+  grid_size: number;
+  offset: [number, number];
+  tiles: Tile[];
+};
+
+export type Layer = TileLayer;
+
+export type Level = {
+  world_x: number;
+  world_y: number;
+  width: number;
+  height: number;
+  layers: Layer[];
+};
+
+export type TileSet = { id: number; texture: Texture };
+
+export type World = { levels: Level[]; tilesets: Map<number, TileSet> };
+
+async function load_tileset(def: {
+  uid: number;
+  relPath: string;
+}): Promise<TileSet> {
+  let relPath = def.relPath as string;
+  if (relPath.endsWith(".aseprite")) {
+    // Whoops let's load the export instead?
+    relPath = relPath.substring(0, relPath.length - 8) + "png";
+  }
+  let texture = await load_texture(relPath);
+
+  print("Loaded tileset", def.uid, "from", relPath, "as ID", texture.id());
+  return { id: def.uid, texture };
+}
+
+function load_level(
+  tile_sets: Map<number, TileSet>,
+  def: {
+    worldX: number;
+    worldY: number;
+    pxWid: number;
+    pxHei: number;
+    layerInstances: {
+      __gridSize: number;
+      __pxTotalOffsetX: number;
+      __pxTotalOffsetY: number;
+      __tilesetDefUid: number;
+      gridTiles: {
+        px: [number, number];
+        src: [number, number];
+        f: number;
+        t: number;
+        a: number;
+      }[];
+    }[];
+  }
+): Level {
+  return {
+    world_x: def.worldX,
+    world_y: def.worldY,
+    width: def.pxWid,
+    height: def.pxHei,
+    layers: def.layerInstances.map((li) => {
+      const tileset = tile_sets.get(li.__tilesetDefUid);
+      if (!tileset) {
+        throw new Error("Unable to find texture!!! " + li.__tilesetDefUid);
+      }
+
+      return {
+        type: "tile",
+        texture: tileset.texture,
+        grid_size: li.__gridSize,
+        offset: [li.__pxTotalOffsetX, li.__pxTotalOffsetY],
+        tiles: li.gridTiles,
+      };
+    }),
+  };
+}
+
+export async function load_world(path: string): Promise<World> {
+  print("Loading map:", path);
+  const blob = await load_string(path);
+  const map = JSON.parse(blob);
+
+  const tilesets = new Map<number, TileSet>();
+  let loaded_tilesets = await Promise.all(
+    map.defs.tilesets
+      .filter((def: any) => def.relPath != null)
+      .map((def: any) => load_tileset(def))
+  );
+  for (const ts of loaded_tilesets) {
+    tilesets.set(ts.id, ts);
+  }
+
+  const levels = map.levels.map((l: any) => load_level(tilesets, l));
+  return { levels, tilesets };
+}
+
+export function draw_level(
+  level: Level,
+  offset_x: number = 0,
+  offset_y: number = 0
+) {
+  for (const layer of level.layers) {
+    use_texture(layer.texture);
+
+    let [ofx, ofy] = layer.offset;
+    ofx += offset_x;
+    ofy += offset_y;
+    for (const tile of layer.tiles) {
+      // TODO: Flip and whatnot.
+      spr(
+        tile.px[0] + ofx,
+        tile.px[1] + ofy,
+        layer.grid_size,
+        layer.grid_size,
+        tile.src[0],
+        tile.src[1]
+      );
+    }
+  }
+}