Merge pull request #123 from yenatch/fieldmap

Decompile src/fieldmap.c

1 files changed, 939 insertions, 0 deletions

diff --git a/src/fieldmap.c b/src/fieldmap.c
new file mode 100644
index 000000000..b6d451525
--- /dev/null
+++ b/src/fieldmap.c
@@ -0,0 +1,939 @@
+#include "global.h"
+#include "palette.h"
+
+struct BackupMapData
+{
+    s32 width;
+    s32 height;
+    u16 *map;
+};
+
+extern struct MapHeader * const get_mapheader_by_bank_and_number(u8, u8);
+extern void mapheader_run_script_with_tag_x1(void);
+extern void sub_80BB970(struct MapEvents *);
+extern void sub_80BBCCC();
+extern void sub_8056670();
+extern void UpdateTVScreensOnMap();
+extern void sub_80538F0(u8 mapGroup, u8 mapNum);
+
+struct Camera {
+	bool8 field_0:1;
+	s32 x;
+	s32 y;
+};
+
+struct ConnectionFlags {
+	u8 south:1;
+	u8 north:1;
+	u8 west:1;
+	u8 east:1;
+};
+
+struct Coords32 {
+	s32 x;
+	s32 y;
+};
+
+extern const struct Coords32 gUnknown_0821664C[];
+extern struct BackupMapData gUnknown_03004870;
+
+EWRAM_DATA static u16 gUnknown_02029828[0x2800] = {0};
+EWRAM_DATA struct MapHeader gMapHeader = {0};
+EWRAM_DATA struct Camera gUnknown_0202E844 = {0};
+EWRAM_DATA static struct ConnectionFlags gUnknown_0202E850 = {0};
+
+extern const struct ConnectionFlags gUnknown_08308E28;
+
+void mapheader_copy_mapdata_with_padding(struct MapHeader *mapHeader);
+void sub_80560AC(struct MapHeader *);
+void map_copy_with_padding(u16 *map, u16 width, u16 height);
+void fillSouthConnection(struct MapHeader *, struct MapHeader *, s32);
+void fillNorthConnection(struct MapHeader *, struct MapHeader *, s32);
+void fillWestConnection(struct MapHeader *, struct MapHeader *, s32);
+void fillEastConnection(struct MapHeader *, struct MapHeader *, s32);
+u32 GetBehaviorByMetatileId(u16 metatile);
+struct MapConnection *sub_8056A64(u8 direction, int x, int y);
+bool8 sub_8056ABC(u8 direction, int x, int y, struct MapConnection *connection);
+bool8 sub_8056B20(int x, int src_width, int dest_width, int offset);
+
+struct MapHeader *mapconnection_get_mapheader(struct MapConnection *connection) {
+	return get_mapheader_by_bank_and_number(connection->mapGroup, connection->mapNum);
+}
+
+void not_trainer_hill_battle_pyramid(void) {
+	mapheader_copy_mapdata_with_padding(&gMapHeader);
+	sub_80BB970(gMapHeader.events);
+	mapheader_run_script_with_tag_x1();
+}
+
+void sub_8055FC0(void) {
+	mapheader_copy_mapdata_with_padding(&gMapHeader);
+	sub_80BBCCC(0);
+	sub_80BB970(gMapHeader.events);
+	sub_8056670();
+	mapheader_run_script_with_tag_x1();
+	UpdateTVScreensOnMap(gUnknown_03004870.width, gUnknown_03004870.height);
+}
+
+void mapheader_copy_mapdata_with_padding(struct MapHeader *mapHeader) {
+	struct MapData *mapData;
+	int width;
+	int height;
+	mapData = mapHeader->mapData;
+	CpuFastFill16(0x03ff, gUnknown_02029828, sizeof(gUnknown_02029828));
+	gUnknown_03004870.map = gUnknown_02029828;
+	width = mapData->width + 15;
+	gUnknown_03004870.width = width;
+	height = mapData->height + 14;
+	gUnknown_03004870.height = height;
+	if (width * height <= 0x2800) {
+		map_copy_with_padding(mapData->map, mapData->width, mapData->height);
+		sub_80560AC(mapHeader);
+	}
+}
+
+void map_copy_with_padding(u16 *map, u16 width, u16 height) {
+	u16 *dest;
+	int y;
+	dest = gUnknown_03004870.map;
+	dest += gUnknown_03004870.width * 7 + 7;
+	for (y = 0; y < height; y++) {
+		CpuCopy16(map, dest, width * 2);
+		dest += width + 0xf;
+		map += width;
+	}
+}
+
+void sub_80560AC(struct MapHeader *mapHeader) {
+	int i;
+	struct MapConnection *connection;
+	struct MapHeader *cMap;
+	u32 offset;
+	int count;
+	count = mapHeader->connections->count;
+	connection = mapHeader->connections->connections;
+	gUnknown_0202E850 = gUnknown_08308E28;
+	for (i = 0; i < count; i++, connection++) {
+		cMap = mapconnection_get_mapheader(connection);
+		offset = connection->offset;
+		switch (connection->direction) {
+		case CONNECTION_SOUTH:
+			fillSouthConnection(mapHeader, cMap, offset);
+			gUnknown_0202E850.south = 1;
+			break;
+		case CONNECTION_NORTH:
+			fillNorthConnection(mapHeader, cMap, offset);
+			gUnknown_0202E850.north = 1;
+			break;
+		case CONNECTION_WEST:
+			fillWestConnection(mapHeader, cMap, offset);
+			gUnknown_0202E850.west = 1;
+			break;
+		case CONNECTION_EAST:
+			fillEastConnection(mapHeader, cMap, offset);
+			gUnknown_0202E850.east = 1;
+			break;
+		}
+	}
+}
+
+void sub_8056134(int x, int y, struct MapHeader *mapHeader, int x2, int y2, int width, int height) {
+	int i;
+	u16 *src;
+	u16 *dest;
+	int mapWidth;
+
+	mapWidth = mapHeader->mapData->width;
+	src = &mapHeader->mapData->map[mapWidth * y2 + x2];
+	dest = &gUnknown_03004870.map[gUnknown_03004870.width * y + x];
+
+	for (i = 0; i < height; i++) {
+		CpuCopy16(src, dest, width * 2);
+		dest += gUnknown_03004870.width;
+		src += mapWidth;
+	}
+}
+
+void fillSouthConnection(struct MapHeader *mapHeader, struct MapHeader *connectedMapHeader, s32 offset) {
+	int x, y;
+	int x2, y2;
+	int width, height;
+	int cWidth;
+
+	if (connectedMapHeader) {
+		cWidth = connectedMapHeader->mapData->width;
+		x = offset + 7;
+		y = mapHeader->mapData->height + 7;
+		if (x < 0) {
+			x2 = -x;
+			x += cWidth;
+			if (x < gUnknown_03004870.width) {
+				width = x;
+			} else {
+				width = gUnknown_03004870.width;
+			}
+			x = 0;
+		} else {
+			x2 = 0;
+			if (x + cWidth < gUnknown_03004870.width) {
+				width = cWidth;
+			} else {
+				width = gUnknown_03004870.width - x;
+			}
+		}
+		sub_8056134(
+		    x, y,
+		    connectedMapHeader,
+		    x2, /*y2*/ 0,
+		    width, /*height*/ 7);
+	}
+}
+
+void fillNorthConnection(struct MapHeader *mapHeader, struct MapHeader *connectedMapHeader, s32 offset) {
+	int x, y;
+	int x2, y2;
+	int width, height;
+	int cWidth, cHeight;
+
+	if (connectedMapHeader) {
+		cWidth = connectedMapHeader->mapData->width;
+		cHeight = connectedMapHeader->mapData->height;
+		x = offset + 7;
+		y2 = cHeight - 7;
+		if (x < 0) {
+			x2 = -x;
+			x += cWidth;
+			if (x < gUnknown_03004870.width) {
+				width = x;
+			} else {
+				width = gUnknown_03004870.width;
+			}
+			x = 0;
+		} else {
+			x2 = 0;
+			if (x + cWidth < gUnknown_03004870.width) {
+				width = cWidth;
+			} else {
+				width = gUnknown_03004870.width - x;
+			}
+		}
+
+		sub_8056134(
+		    x, /*y*/ 0,
+		    connectedMapHeader,
+		    x2, y2,
+		    width, /*height*/ 7);
+
+	}
+}
+
+
+void fillWestConnection(struct MapHeader *mapHeader, struct MapHeader *connectedMapHeader, s32 offset) {
+	int x, y;
+	int x2, y2;
+	int width, height;
+	int cWidth, cHeight;
+	if (connectedMapHeader) {
+		cWidth = connectedMapHeader->mapData->width;
+		cHeight = connectedMapHeader->mapData->height;
+		y = offset + 7;
+		x2 = cWidth - 7;
+		if (y < 0) {
+			y2 = -y;
+			if (y + cHeight < gUnknown_03004870.height) {
+				height = y + cHeight;
+			} else {
+				height = gUnknown_03004870.height;
+			}
+			y = 0;
+		} else {
+			y2 = 0;
+			if (y + cHeight < gUnknown_03004870.height) {
+				height = cHeight;
+			} else {
+				height = gUnknown_03004870.height - y;
+			}
+		}
+
+		sub_8056134(
+		    /*x*/ 0, y,
+		    connectedMapHeader,
+		    x2, y2,
+		    /*width*/ 7, height);
+	}
+}
+
+void fillEastConnection(struct MapHeader *mapHeader, struct MapHeader *connectedMapHeader, s32 offset) {
+	int x, y;
+	int x2, y2;
+	int width, height;
+	int cWidth, cHeight;
+	if (connectedMapHeader) {
+		cHeight = connectedMapHeader->mapData->height;
+		x = mapHeader->mapData->width + 7;
+		y = offset + 7;
+		if (y < 0) {
+			y2 = -y;
+			if (y + cHeight < gUnknown_03004870.height) {
+				height = y + cHeight;
+			} else {
+				height = gUnknown_03004870.height;
+			}
+			y = 0;
+		} else {
+			y2 = 0;
+			if (y + cHeight < gUnknown_03004870.height) {
+				height = cHeight;
+			} else {
+				height = gUnknown_03004870.height - y;
+			}
+		}
+
+		sub_8056134(
+		    x, y,
+		    connectedMapHeader,
+		    /*x2*/ 0, y2,
+		    /*width*/ 8, height);
+	}
+}
+
+union Block {
+	struct {
+		u16 block:10;
+		u16 collision:2;
+		u16 elevation:4;
+	} block;
+	u16 value;
+};
+
+u16 MapGridGetZCoordAt(int x, int y) {
+	u16 block;
+	int i;
+	u16 *border;
+
+	if (x >= 0 && x < gUnknown_03004870.width
+	 && y >= 0 && y < gUnknown_03004870.height) {
+		block = gUnknown_03004870.map[x + gUnknown_03004870.width * y];
+	} else {
+		border = gMapHeader.mapData->border;
+		i = (x + 1) & 1;
+		i += ((y + 1) & 1) * 2;
+		block = gMapHeader.mapData->border[i];
+		block |= 0xc00;
+	}
+	if (block == 0x3ff) {
+		return 0;
+	}
+	return block >> 12;
+}
+
+u16 MapGridIsImpassableAt(int x, int y) {
+	u16 block;
+	int i;
+	u16 *border;
+
+	if (x >= 0 && x < gUnknown_03004870.width
+	 && y >= 0 && y < gUnknown_03004870.height) {
+		block = gUnknown_03004870.map[x + gUnknown_03004870.width * y];
+	} else {
+		border = gMapHeader.mapData->border;
+		i = (x + 1) & 1;
+		i += ((y + 1) & 1) * 2;
+		block = gMapHeader.mapData->border[i];
+		block |= 0xc00;
+	}
+	if (block == 0x3ff) {
+		return 1;
+	}
+	return (block & 0xc00) >> 10;
+}
+
+u16 MapGridGetMetatileIdAt(int x, int y) {
+	u16 block;
+	int i;
+	int j;
+	struct MapData *mapData;
+	u16 *border;
+	u16 block2;
+
+	if (x >= 0 && x < gUnknown_03004870.width
+	 && y >= 0 && y < gUnknown_03004870.height) {
+		block = gUnknown_03004870.map[x + gUnknown_03004870.width * y];
+	} else {
+		mapData = gMapHeader.mapData;
+		i = (x + 1) & 1;
+		i += ((y + 1) & 1) * 2;
+		block = mapData->border[i] | 0xc00;
+	}
+	if (block == 0x3ff) {
+		border = gMapHeader.mapData->border;
+		j = (x + 1) & 1;
+		j += ((y + 1) & 1) * 2;
+		block2 = gMapHeader.mapData->border[j];
+		block2 |= 0xc00;
+		return block2 & block;
+	}
+	return block & 0x3ff;
+}
+
+u32 MapGridGetMetatileBehaviorAt(int x, int y) {
+	u16 metatile;
+	metatile = MapGridGetMetatileIdAt(x, y);
+	return GetBehaviorByMetatileId(metatile) & 0xff;
+}
+
+u16 MapGridGetMetatileLayerTypeAt(int x, int y) {
+	u16 metatile;
+	metatile = MapGridGetMetatileIdAt(x, y);
+	return (GetBehaviorByMetatileId(metatile) & 0xf000) >> 12;
+}
+
+void MapGridSetMetatileIdAt(int x, int y, u16 metatile) {
+	int i;
+	if (x >= 0 && x < gUnknown_03004870.width
+	 && y >= 0 && y < gUnknown_03004870.height) {
+		i = x + y * gUnknown_03004870.width;
+		gUnknown_03004870.map[i] = (gUnknown_03004870.map[i] & 0xf000) | (metatile & 0xfff); 
+	}
+}
+
+void MapGridSetMetatileEntryAt(int x, int y, u16 metatile) {
+	int i;
+	if (x >= 0 && x < gUnknown_03004870.width
+	 && y >= 0 && y < gUnknown_03004870.height) {
+		i = x + gUnknown_03004870.width * y;
+		gUnknown_03004870.map[i] = metatile;
+	}
+}
+
+u32 GetBehaviorByMetatileId(u16 metatile) {
+	u16 *attributes;
+	if (metatile <= 0x1ff) {
+		attributes = gMapHeader.mapData->primaryTileset->metatileAttributes;
+		return attributes[metatile];
+	} else if (metatile <= 0x3ff) {
+		attributes = gMapHeader.mapData->secondaryTileset->metatileAttributes;
+		return attributes[metatile - 0x200];
+	} else {
+		return 0xff;
+	}
+}
+
+void save_serialize_map(void) {
+	int i, j;
+	int x, y;
+	u16 *mapView;
+	int width;
+	mapView = gSaveBlock1.mapView;
+	width = gUnknown_03004870.width;
+	x = gSaveBlock1.pos.x;
+	y = gSaveBlock1.pos.y;
+	for (i = y; i < y + 14; i++)
+	for (j = x; j < x + 15; j++) {
+		*mapView++ = gUnknown_02029828[width * i + j];
+	}
+}
+
+int sub_8056618(void) {
+	u16 i;
+	u32 r2;
+	r2 = 0;
+	for (i = 0; i < 0x200; i++) {
+		r2 |= gSaveBlock1.mapView[i];
+	}
+	if (r2 == 0) {
+		return 1;
+	}
+	return 0;
+}
+
+void sav2_mapdata_clear(void) {
+	CpuFill16(0, gSaveBlock1.mapView, sizeof(gSaveBlock1.mapView));
+}
+
+void sub_8056670(void) {
+	int i, j;
+	int x, y;
+	u16 *mapView;
+	int width;
+	mapView = gSaveBlock1.mapView;
+	if (!sub_8056618()) {
+		width = gUnknown_03004870.width;
+		x = gSaveBlock1.pos.x;
+		y = gSaveBlock1.pos.y;
+		for (i = y; i < y + 14; i++)
+		for (j = x; j < x + 15; j++) {
+			gUnknown_02029828[width * i + j] = *mapView++;
+		}
+		sav2_mapdata_clear();
+	}
+}
+
+void sub_80566F0(u8 a1) {
+	u16 *mapView;
+	int width;
+	int x0, y0;
+	int x2, y2;
+	u16 *src, *dest;
+	int srci, desti;
+	int r9, r8;
+	int x, y;
+	int i, j;
+	mapView = gSaveBlock1.mapView;
+	width = gUnknown_03004870.width;
+	r9 = 0;
+	r8 = 0;
+	x0 = gSaveBlock1.pos.x;
+	y0 = gSaveBlock1.pos.y;
+	x2 = 15;
+	y2 = 14;
+	switch (a1) {
+		case 2:
+			y0 += 1;
+			y2 = 13;
+			break;
+		case 1:
+			r8 = 1;
+			y2 = 13;
+			break;
+		case 3:
+			x0 += 1;
+			x2 = 14;
+			break;
+		case 4:
+			r9 = 1;
+			x2 = 14;
+			break;
+	}
+	for (y = 0; y < y2; y++) {
+		i = 0;
+		j = 0;
+		for (x = 0; x < x2; x++) {
+			desti = width * (y + y0);
+			srci = (y + r8) * 15 + r9;
+			src = &mapView[srci + i];
+			dest = &gUnknown_02029828[x0 + desti + j];
+			*dest = *src;
+			i++;
+			j++;
+		}
+	}
+	sav2_mapdata_clear();
+}
+
+#ifdef NONMATCHING
+// TODO FIXME returns are in the wrong order
+int GetMapBorderIdAt(int x, int y) {
+	struct MapData *mapData;
+	u16 block, block2;
+	int i, j;
+	if (x >= 0 && x < gUnknown_03004870.width
+	 && y >= 0 && y < gUnknown_03004870.height) {
+		i = gUnknown_03004870.width;
+		i *= y;
+		block = gUnknown_03004870.map[x + i];
+		if (block == 0x3ff) {
+			return -1;
+		}
+	} else {
+		mapData = gMapHeader.mapData;
+		j = (x + 1) & 1;
+		j += ((y + 1) & 1) * 2;
+		block2 = 0xc00 | mapData->border[j];
+		if (block2 == 0x3ff) {
+			return -1;
+		}
+	}
+	if (x >= (gUnknown_03004870.width - 8)) {
+		if (gUnknown_0202E850.east) {
+			return CONNECTION_EAST;
+		} else {
+			return -1;
+		}
+	} else if (x < 7) {
+		if (gUnknown_0202E850.west) {
+			return CONNECTION_WEST;
+		} else {
+			return -1;
+		}
+	} else if (y >= (gUnknown_03004870.height - 7)) {
+		if (gUnknown_0202E850.south) {
+			return CONNECTION_SOUTH;
+		} else {
+			return -1;
+		}
+	} else if (y < 7) {
+		if (gUnknown_0202E850.north) {
+			return CONNECTION_NORTH;
+		} else {
+			return -1;
+		}
+	}
+	return 0;
+}
+#else
+__attribute__((naked))
+int GetMapBorderIdAt(int x, int y) {
+asm(
+"	.syntax unified\n"
+"\n"
+"	push {r4,r5,lr}\n"
+"	adds r4, r0, 0\n"
+"	adds r5, r1, 0\n"
+"	cmp r4, 0\n"
+"	blt _080567FC\n"
+"	ldr r1, _080567F4 @ =gUnknown_03004870\n"
+"	ldr r2, [r1]\n"
+"	cmp r4, r2\n"
+"	bge _080567FC\n"
+"	cmp r5, 0\n"
+"	blt _080567FC\n"
+"	ldr r0, [r1, 0x4]\n"
+"	cmp r5, r0\n"
+"	bge _080567FC\n"
+"	adds r0, r2, 0\n"
+"	muls r0, r5\n"
+"	adds r0, r4, r0\n"
+"	ldr r1, [r1, 0x8]\n"
+"	lsls r0, 1\n"
+"	adds r0, r1\n"
+"	ldrh r1, [r0]\n"
+"	ldr r0, _080567F8 @ =0x000003ff\n"
+"	cmp r1, r0\n"
+"	beq _08056894\n"
+"	b _08056824\n"
+"	.align 2, 0\n"
+"_080567F4: .4byte gUnknown_03004870\n"
+"_080567F8: .4byte 0x000003ff\n"
+"_080567FC:\n"
+"	ldr r0, _08056840 @ =gMapHeader\n"
+"	ldr r3, [r0]\n"
+"	adds r1, r4, 0x1\n"
+"	movs r2, 0x1\n"
+"	ands r1, r2\n"
+"	adds r0, r5, 0x1\n"
+"	ands r0, r2\n"
+"	lsls r0, 1\n"
+"	adds r1, r0\n"
+"	ldr r0, [r3, 0x8]\n"
+"	lsls r1, 1\n"
+"	adds r1, r0\n"
+"	ldrh r1, [r1]\n"
+"	movs r2, 0xC0\n"
+"	lsls r2, 4\n"
+"	adds r0, r2, 0\n"
+"	orrs r0, r1\n"
+"	ldr r1, _08056844 @ =0x000003ff\n"
+"	cmp r0, r1\n"
+"	beq _08056894\n"
+"_08056824:\n"
+"	ldr r1, _08056848 @ =gUnknown_03004870\n"
+"	ldr r0, [r1]\n"
+"	subs r0, 0x8\n"
+"	cmp r4, r0\n"
+"	blt _08056850\n"
+"	ldr r0, _0805684C @ =gUnknown_0202E850\n"
+"	ldrb r1, [r0]\n"
+"	movs r0, 0x8\n"
+"	ands r0, r1\n"
+"	cmp r0, 0\n"
+"	beq _08056894\n"
+"	movs r0, 0x4\n"
+"	b _080568A6\n"
+"	.align 2, 0\n"
+"_08056840: .4byte gMapHeader\n"
+"_08056844: .4byte 0x000003ff\n"
+"_08056848: .4byte gUnknown_03004870\n"
+"_0805684C: .4byte gUnknown_0202E850\n"
+"_08056850:\n"
+"	cmp r4, 0x6\n"
+"	bgt _08056868\n"
+"	ldr r0, _08056864 @ =gUnknown_0202E850\n"
+"	ldrb r1, [r0]\n"
+"	movs r0, 0x4\n"
+"	ands r0, r1\n"
+"	cmp r0, 0\n"
+"	beq _08056894\n"
+"	movs r0, 0x3\n"
+"	b _080568A6\n"
+"	.align 2, 0\n"
+"_08056864: .4byte gUnknown_0202E850\n"
+"_08056868:\n"
+"	ldr r0, [r1, 0x4]\n"
+"	subs r0, 0x7\n"
+"	cmp r5, r0\n"
+"	blt _08056884\n"
+"	ldr r0, _08056880 @ =gUnknown_0202E850\n"
+"	ldrb r1, [r0]\n"
+"	movs r0, 0x1\n"
+"	ands r0, r1\n"
+"	cmp r0, 0\n"
+"	beq _08056894\n"
+"	movs r0, 0x1\n"
+"	b _080568A6\n"
+"	.align 2, 0\n"
+"_08056880: .4byte gUnknown_0202E850\n"
+"_08056884:\n"
+"	cmp r5, 0x6\n"
+"	bgt _080568A4\n"
+"	ldr r0, _0805689C @ =gUnknown_0202E850\n"
+"	ldrb r1, [r0]\n"
+"	movs r0, 0x2\n"
+"	ands r0, r1\n"
+"	cmp r0, 0\n"
+"	bne _080568A0\n"
+"_08056894:\n"
+"	movs r0, 0x1\n"
+"	negs r0, r0\n"
+"	b _080568A6\n"
+"	.align 2, 0\n"
+"_0805689C: .4byte gUnknown_0202E850\n"
+"_080568A0:\n"
+"	movs r0, 0x2\n"
+"	b _080568A6\n"
+"_080568A4:\n"
+"	movs r0, 0\n"
+"_080568A6:\n"
+"	pop {r4,r5}\n"
+"	pop {r1}\n"
+"	bx r1\n"
+"	.syntax divided\n"
+);
+}
+#endif
+
+int GetPostCameraMoveMapBorderId(int x, int y) {
+	return GetMapBorderIdAt(gSaveBlock1.pos.x + 7 + x, gSaveBlock1.pos.y + 7 + y);
+}
+
+int CanCameraMoveInDirection(int direction) {
+	int x, y;
+	x = gSaveBlock1.pos.x + 7 + gUnknown_0821664C[direction].x;
+	y = gSaveBlock1.pos.y + 7 + gUnknown_0821664C[direction].y;
+	if (GetMapBorderIdAt(x, y) == -1) {
+		return 0;
+	}
+	return 1;
+}
+
+void sub_8056918(struct MapConnection *connection, int direction, int x, int y) {
+	struct MapHeader *mapHeader;
+	mapHeader = mapconnection_get_mapheader(connection);
+	switch (direction) {
+	case CONNECTION_EAST:
+		gSaveBlock1.pos.x = -x;
+		gSaveBlock1.pos.y -= connection->offset;
+		break;
+	case CONNECTION_WEST:
+		gSaveBlock1.pos.x = mapHeader->mapData->width;
+		gSaveBlock1.pos.y -= connection->offset;
+		break;
+	case CONNECTION_SOUTH:
+		gSaveBlock1.pos.x -= connection->offset;
+		gSaveBlock1.pos.y = -y;
+		break;
+	case CONNECTION_NORTH:
+		gSaveBlock1.pos.x -= connection->offset;
+		gSaveBlock1.pos.y = mapHeader->mapData->height;
+		break;
+	}
+}
+
+bool8 CameraMove(int x, int y) {
+	unsigned int direction;
+	struct MapConnection *connection;
+	int old_x, old_y;
+	gUnknown_0202E844.field_0 = FALSE;
+	direction = GetPostCameraMoveMapBorderId(x, y);
+	if (direction + 1 <= 1) {
+		gSaveBlock1.pos.x += x;
+		gSaveBlock1.pos.y += y;
+	} else {
+		save_serialize_map();
+		old_x = gSaveBlock1.pos.x;
+		old_y = gSaveBlock1.pos.y;
+		connection = sub_8056A64(direction, gSaveBlock1.pos.x, gSaveBlock1.pos.y);
+		sub_8056918(connection, direction, x, y);
+		sub_80538F0(connection->mapGroup, connection->mapNum);
+		gUnknown_0202E844.field_0 = TRUE;
+		gUnknown_0202E844.x = old_x - gSaveBlock1.pos.x;
+		gUnknown_0202E844.y = old_y - gSaveBlock1.pos.y;
+		gSaveBlock1.pos.x += x;
+		gSaveBlock1.pos.y += y;
+		sub_80566F0(direction);
+	}
+	return gUnknown_0202E844.field_0;
+}
+
+struct MapConnection *sub_8056A64(u8 direction, int x, int y) {
+	int count;
+	struct MapConnection *connection;
+	int i;
+	count = gMapHeader.connections->count;
+	connection = gMapHeader.connections->connections;
+	for (i = 0; i < count; i++, connection++) {
+		if (connection->direction == direction) {
+			if (sub_8056ABC(direction, x, y, connection) == TRUE) {
+				return connection;
+			}
+		}
+	}
+	return NULL;
+}
+
+bool8 sub_8056ABC(u8 direction, int x, int y, struct MapConnection *connection) {
+	struct MapHeader *mapHeader;
+	mapHeader = mapconnection_get_mapheader(connection);
+	switch (direction) {
+	case CONNECTION_SOUTH:
+	case CONNECTION_NORTH:
+		return sub_8056B20(x, gMapHeader.mapData->width, mapHeader->mapData->width, connection->offset);
+	case CONNECTION_WEST:
+	case CONNECTION_EAST:
+		return sub_8056B20(y, gMapHeader.mapData->height, mapHeader->mapData->height, connection->offset);
+	}
+	return FALSE;
+}
+
+bool8 sub_8056B20(int x, int src_width, int dest_width, int offset) {
+	int offset2;
+	offset2 = offset;
+	if (offset2 < 0) {
+		offset2 = 0;
+	}
+	if (dest_width + offset < src_width) {
+		src_width = dest_width + offset;
+	}
+	if (offset2 <= x && x <= src_width) {
+		return TRUE;
+	}
+	return FALSE;
+}
+
+int sub_8056B4C(int x, int width) {
+	if (x >= 0 && x < width) {
+		return TRUE;
+	}
+	return FALSE;
+}
+
+int sub_8056B60(struct MapConnection *connection, int x, int y) {
+	struct MapHeader *mapHeader;
+	mapHeader = mapconnection_get_mapheader(connection);
+	switch (connection->direction) {
+		case CONNECTION_SOUTH:
+		case CONNECTION_NORTH:
+			return sub_8056B4C(x - connection->offset, mapHeader->mapData->width);
+		case CONNECTION_WEST:
+		case CONNECTION_EAST:
+			return sub_8056B4C(y - connection->offset, mapHeader->mapData->height);
+	}
+	return FALSE;
+}
+
+struct MapConnection *sub_8056BA0(s16 x, s16 y) {
+	int count;
+	struct MapConnection *connection;
+	int i;
+	u8 direction;
+	if (!gMapHeader.connections) {
+		return NULL;
+	} else {
+		count = gMapHeader.connections->count;
+		connection = gMapHeader.connections->connections;
+		for (i = 0; i < count; i++, connection++) {
+			direction = connection->direction;
+			if (
+				(direction == CONNECTION_DIVE || direction == CONNECTION_EMERGE)
+				|| (direction == CONNECTION_NORTH && y > 6)
+				|| (direction == CONNECTION_SOUTH && y < gMapHeader.mapData->height + 7)
+				|| (direction == CONNECTION_WEST && x > 6)
+				|| (direction == CONNECTION_EAST && x < gMapHeader.mapData->width + 7)
+			) {
+				continue;
+			}
+			if (sub_8056B60(connection, x - 7, y - 7) == TRUE) {
+				return connection;
+			}
+		}
+	}
+	return NULL;
+}
+
+void sub_8056C50(u16 x, u16 y) {
+	gSaveBlock1.pos.x = x - 7;
+	gSaveBlock1.pos.y = y - 7;
+}
+
+void sav1_camera_get_focus_coords(u16 *x, u16 *y) {
+	*x = gSaveBlock1.pos.x + 7;
+	*y = gSaveBlock1.pos.y + 7;
+}
+
+void unref_sub_8056C7C(u16 x, u16 y) {
+	gSaveBlock1.pos.x = x;
+	gSaveBlock1.pos.y = y;
+}
+
+void GetCameraCoords(u16 *x, u16 *y) {
+	*x = gSaveBlock1.pos.x;
+	*y = gSaveBlock1.pos.y;
+}
+
+void sub_8056C98(struct Tileset *tileset, void *src) {
+	if (tileset) {
+		if (!tileset->isCompressed) {
+			CpuFastSet(tileset->tiles, src, 0x1000);
+		} else {
+			LZ77UnCompVram(tileset->tiles, src);
+		}
+	}
+}
+
+void sub_8056CBC(struct Tileset *tileset, int offset, int size) {
+	u16 black;
+	if (tileset) {
+		if (tileset->isSecondary == FALSE) {
+			black = 0;
+			LoadPalette(&black, offset, 2);
+			LoadPalette(tileset->palettes + 2, offset + 1, size - 2);
+		} else if (tileset->isSecondary == TRUE) {
+			LoadPalette(tileset->palettes + 0xc0, offset, size);
+		} else {
+			LZ77UnCompVram(tileset->palettes, (void*)0x2000000);
+			LoadPalette((void*)0x2000000, offset, size);
+		}
+	}
+}
+
+void sub_8056D28(struct MapData *mapData) {
+	void *src = (void*)(BG_VRAM);
+	sub_8056C98(mapData->primaryTileset, src);
+}
+
+void sub_8056D38(struct MapData *mapData) {
+	void *src = (void*)(BG_VRAM + 0x4000);
+	sub_8056C98(mapData->secondaryTileset, src);
+}
+
+void apply_map_tileset1_palette(struct MapData *mapData) {
+	sub_8056CBC(mapData->primaryTileset, 0, 0xc0);
+}
+
+void apply_map_tileset2_palette(struct MapData *mapData) {
+	sub_8056CBC(mapData->secondaryTileset, 0x60, 0xc0);
+}
+
+void copy_map_tileset1_tileset2_to_vram(struct MapData *mapData) {
+	if (mapData) {
+		sub_8056D28(mapData);
+		sub_8056D38(mapData);
+	}
+}
+
+void apply_map_tileset1_tileset2_palette(struct MapData *mapData) {
+	if (mapData) {
+		apply_map_tileset1_palette(mapData);
+		apply_map_tileset2_palette(mapData);
+	}
+}