Revert "Simplify tile assets - repo clones may need to run make extract again"

This reverts commit 306613e462.

It turns out we do actually need tiles to be built using the asset
manager :\

tools/assetmgr/mktiles

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+
+import assetmgr
+import json
+import os
+import re
+import struct
+import sys
+
+class App():
+
+    floortypes = {
+        'default': 0,
+        'wood':    1,
+        'stone':   2,
+        'carpet':  3,
+        'metal':   4,
+        'mud':     5,
+        'water':   6,
+        'dirt':    7,
+        'snow':    8,
+    }
+
+    def run(self):
+        self.load_data()
+
+        self.room_names = self.json['rooms'].keys()
+
+        self.make_header()
+        self.make_object()
+
+    def load_data(self):
+        fd = open(sys.argv[1], 'r')
+        data = fd.read()
+        fd.close()
+
+        self.json = json.loads(data)
+
+        self.shortname = os.path.basename(sys.argv[1]).replace('.json', '')
+
+    def make_header(self):
+        typename = 'room_%s' % self.shortname
+        enums = self.json['rooms'].keys()
+        filename = 'tiles/%s.h' % self.shortname
+        terminator = 'ROOM_%s_END' % self.shortname.upper()
+        assetmgr.write_enums(typename, enums, filename, terminator)
+
+    def make_object(self):
+        binary = self.make_binary()
+        zipped = assetmgr.zip(binary)
+
+        # Write the zipped file, purely so `make test` can verify it
+        assetmgr.writefile('build/%s/assets/files/bgdata/bg_%s_tilesZ' % (os.environ['ROMID'], self.shortname), zipped)
+
+        filename = 'files/bgdata/bg_%s_tilesZ.o' % self.shortname
+        assetmgr.write_object(zipped, filename)
+
+    # Order of stuff:
+    # - 0x00: number of rooms
+    # - 0x04: room offset table, with end marker
+    # - Room data
+    def make_binary(self):
+        rooms = self.make_rooms()
+
+        output = bytes()
+
+        # Write number of rooms
+        output += len(rooms).to_bytes(4, 'big')
+
+        # Write room offset table
+        pos = 4 + len(rooms) * 4 + 4
+
+        for room in rooms:
+            output += pos.to_bytes(4, 'big')
+            pos += len(room)
+
+        # Write end marker
+        output += pos.to_bytes(4, 'big')
+
+        # Write room data
+        output += b''.join(rooms)
+
+        output = assetmgr.pad16(output)
+
+        return output
+
+    def make_rooms(self):
+        rooms = []
+
+        for data in self.json['rooms'].values():
+            rooms.append(self.make_room(data))
+
+        return rooms
+
+    def make_room(self, tiles):
+        output = bytes()
+
+        for tile in tiles:
+            output += self.make_tile(tile)
+
+        return output
+
+    def make_tile(self, tile):
+        output = bytes()
+
+        bbox = self.find_bbox(tile['vertices'])
+
+        output += b'\x00'
+        output += len(tile['vertices']).to_bytes(1, 'big')
+        output += self.make_flags(tile).to_bytes(2, 'big')
+        output += self.floortypes[tile['floortype']].to_bytes(2, 'big')
+        output += bbox['xmin'].to_bytes(1, 'big')
+        output += bbox['ymin'].to_bytes(1, 'big')
+        output += bbox['zmin'].to_bytes(1, 'big')
+        output += bbox['xmax'].to_bytes(1, 'big')
+        output += bbox['ymax'].to_bytes(1, 'big')
+        output += bbox['zmax'].to_bytes(1, 'big')
+        output += tile['floorcolour'].to_bytes(2, 'big')
+
+        for vert in tile['vertices']:
+            output += self.make_unsigned(vert['x']).to_bytes(2, 'big')
+            output += self.make_unsigned(vert['y']).to_bytes(2, 'big')
+            output += self.make_unsigned(vert['z']).to_bytes(2, 'big')
+
+        return output
+
+    def find_bbox(self, verts):
+        values = {}
+        indices = {}
+        values['xmin'] = 99999
+        values['ymin'] = 99999
+        values['zmin'] = 99999
+        values['xmax'] = -99999
+        values['ymax'] = -99999
+        values['zmax'] = -99999
+        indices['xmin'] = 0
+        indices['ymin'] = 0
+        indices['zmin'] = 0
+        indices['xmax'] = 0
+        indices['ymax'] = 0
+        indices['zmax'] = 0
+
+        for index, vert in enumerate(verts):
+            if vert['x'] < values['xmin']:
+                values['xmin'] = vert['x']
+                indices['xmin'] = index
+            if vert['y'] < values['ymin']:
+                values['ymin'] = vert['y']
+                indices['ymin'] = index
+            if vert['z'] < values['zmin']:
+                values['zmin'] = vert['z']
+                indices['zmin'] = index
+            if vert['x'] > values['xmax']:
+                values['xmax'] = vert['x']
+                indices['xmax'] = index
+            if vert['y'] > values['ymax']:
+                values['ymax'] = vert['y']
+                indices['ymax'] = index
+            if vert['z'] > values['zmax']:
+                values['zmax'] = vert['z']
+                indices['zmax'] = index
+
+        return indices
+
+    def make_flags(self, room):
+        names = [
+            'flag0001',
+            'flag0002',
+            'flag0004',
+            'flag0008',
+            'flag0010',
+            'flag0020',
+            'ladder',
+            'flag0080',
+            'flag0100',
+            'underwater',
+            'flag0400',
+            'aibotcrouch',
+            'aibotduck',
+            'flag2000',
+            'die',
+            'climbableledge',
+        ]
+
+        flags = 0
+
+        for index, name in enumerate(names):
+            if room[name]:
+                flags |= 1 << index
+
+        return flags
+
+    def make_unsigned(self, value):
+        if value < 0:
+            value = 0x10000 - abs(value)
+        return value
+
+app = App()
+app.run()

tools/extract

@@ -125,7 +125,7 @@ class Extractor:
             elif name.endswith('padsZ'):
                 self.write_asset('files/bgdata/%s.bin' % os.path.basename(unzippedname), unzipped)
             elif name.endswith('tilesZ'):
-                self.write_asset('files/bgdata/%s.bin' % os.path.basename(unzippedname), unzipped)
+                self.write_extracted('files/bgdata/%s.bin' % os.path.basename(unzippedname), unzipped)
             elif name.startswith('A'):
                 self.write_asset('files/audio/%s.mp3' % unzippedname[1:-1], content)
             elif name.startswith('C'):