decompile more of field_map_obj (#231)

* decompile more code

* decompile more of field_map_obj

* decompile more of field_map_obj

6 files changed, 856 insertions, 27 deletions

diff --git a/src/field_map_obj.c b/src/field_map_obj.c
index bd57e7abe..e56ea9787 100644
--- a/src/field_map_obj.c
+++ b/src/field_map_obj.c
@@ -1,7 +1,10 @@
 #include "global.h"
 #include "asm.h"
+#include "berry.h"
 #include "event_data.h"
 #include "field_map_obj.h"
+#include "field_player_avatar.h"
+#include "palette.h"
 #include "rom4.h"
 #include "sprite.h"
 
@@ -9,10 +12,13 @@ extern const struct SpriteTemplate *const gFieldEffectObjectTemplatePointers[36]
 
 extern void strange_npc_table_clear(void);
 extern void ClearPlayerAvatarInfo(void);
-extern void npc_load_two_palettes__no_record();
-extern void npc_load_two_palettes__and_record();
+extern void npc_load_two_palettes__no_record(u16, u8);
+extern void npc_load_two_palettes__and_record(u16, u8);
 extern void sub_8060388(s16, s16, s16 *, s16 *);
 extern void sub_80634D0();
+extern void pal_patch_for_npc(u16, u16);
+extern void sub_80603CC();
+extern void CameraObjectReset1(void);
 
 void sub_805AAB0(void);
 u8 GetFieldObjectIdByLocalId(u8);
@@ -20,17 +26,37 @@ u8 GetFieldObjectIdByLocalIdAndMapInternal(u8, u8, u8);
 u8 GetAvailableFieldObjectSlot(u16, u8, u8, u8 *);
 void FieldObjectHandleDynamicGraphicsId();
 void RemoveFieldObjectInternal(struct MapObject *);
-u16 GetFieldObjectFlagIdByFieldObjectId();
+u16 GetFieldObjectFlagIdByFieldObjectId(u8);
 void MakeObjectTemplateFromFieldObjectTemplate(struct MapObjectTemplate *mapObjTemplate, struct SpriteTemplate *sprTemplate, struct SubspriteTable **subspriteTables);
-struct MapObjectTemplate *GetFieldObjectTemplateByLocalIdAndMap();
+struct MapObjectTemplate *GetFieldObjectTemplateByLocalIdAndMap(u8, u8, u8);
 void GetFieldObjectMovingCameraOffset(s16 *, s16 *);
-void sub_805BDF8();
+void sub_805BDF8(u16);
+u8 sub_805BE58(const struct SpritePalette *);
+u8 FindFieldObjectPaletteIndexByTag(u16);
 
-extern struct LinkPlayerMapObject gLinkPlayerMapObjects[];
+struct PairedPalettes
+{
+    u16 tag;
+    u16 *data;
+};
 
+extern struct LinkPlayerMapObject gLinkPlayerMapObjects[];
+extern u8 gReservedSpritePaletteCount;
+extern struct Camera gUnknown_0202E844;
+extern u8 gUnknown_030005A4;
+extern u16 gUnknown_030005A6;
 extern const u8 gUnknown_0836DBBC[];
 extern const u8 gUnknown_0836DC09[];
 extern void (*const gUnknown_0836DA88[])(struct Sprite *);
+extern const u8 *const gBerryTreeGraphicsIdTablePointers[];
+extern const struct SpriteFrameImage *const gBerryTreePicTablePointers[];
+extern const u8 *const gBerryTreePaletteSlotTablePointers[];
+extern const struct MapObjectGraphicsInfo *const gMapObjectGraphicsInfoPointers[];
+extern const struct SpritePalette gUnknown_0837377C[];
+extern const struct PairedPalettes gUnknown_08373874[];
+extern const struct PairedPalettes gUnknown_083738E4[];
+extern const struct SpriteTemplate gSpriteTemplate_830FD24;
+extern const u16 *const gUnknown_0837399C[];
 
 void npc_clear_ids_and_state(struct MapObject *mapObj)
 {
@@ -364,7 +390,7 @@ u8 sub_805ADDC(u8 localId)
     {
         struct MapObjectTemplate *template = &gSaveBlock1.mapObjectTemplates[i];
         
-        if (template->localId == localId && !FlagGet(template->unk14))
+        if (template->localId == localId && !FlagGet(template->flagId))
             return InitFieldObjectStateFromTemplate(template, gSaveBlock1.location.mapNum, gSaveBlock1.location.mapGroup);
     }
     return 16;
@@ -409,7 +435,7 @@ void RemoveFieldObjectByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup)
 void RemoveFieldObjectInternal(struct MapObject *mapObject)
 {
     struct SpriteFrameImage image;
-    struct MapObjectGraphicsInfo *gfxInfo = GetFieldObjectGraphicsInfo(mapObject->graphicsId);
+    const struct MapObjectGraphicsInfo *gfxInfo = GetFieldObjectGraphicsInfo(mapObject->graphicsId);
     
     image.size = gfxInfo->size;
     gSprites[mapObject->spriteId].images = ℑ
@@ -431,7 +457,7 @@ u8 sub_805AFCC(struct MapObjectTemplate *mapObjTemplate, struct SpriteTemplate *
 {
     u8 mapObjectId;
     u8 spriteId;
-    struct MapObjectGraphicsInfo *gfxInfo;
+    const struct MapObjectGraphicsInfo *gfxInfo;
     struct MapObject *mapObject;
     struct Sprite *sprite;
     
@@ -482,7 +508,7 @@ u8 SpawnFieldObject(struct MapObjectTemplate *mapObjTemplate, u8 b, u8 c, s16 d,
     struct SpriteTemplate spriteTemplate;
     struct SubspriteTable *subspriteTables = NULL;
     struct SpriteFrameImage spriteFrameImage;
-    struct MapObjectGraphicsInfo *gfxInfo;
+    const struct MapObjectGraphicsInfo *gfxInfo;
     u8 mapObjectId;
     
     gfxInfo = GetFieldObjectGraphicsInfo(mapObjTemplate->graphicsId);
@@ -542,7 +568,7 @@ u8 show_sprite(u8 a, u8 b, u8 c)
 
 void MakeObjectTemplateFromFieldObjectGraphicsInfo(u16 graphicsId, void (*callback)(struct Sprite *), struct SpriteTemplate *sprTemplate, struct SubspriteTable **subspriteTables)
 {
-    struct MapObjectGraphicsInfo *gfxInfo = GetFieldObjectGraphicsInfo(graphicsId);
+    const struct MapObjectGraphicsInfo *gfxInfo = GetFieldObjectGraphicsInfo(graphicsId);
     
     sprTemplate->tileTag = gfxInfo->tileTag;
     sprTemplate->paletteTag = gfxInfo->paletteTag1;
@@ -588,7 +614,7 @@ extern void InitObjectPriorityByZCoord();
 
 u8 sub_805B410(u8 a, u8 b, s16 c, s16 d, u8 e, u8 f)
 {
-    struct MapObjectGraphicsInfo *gfxInfo;
+    const struct MapObjectGraphicsInfo *gfxInfo;
     struct SpriteTemplate spriteTemplate;
     struct SubspriteTable *subspriteTables;
     u8 spriteId;
@@ -648,7 +674,7 @@ void sub_805B55C(s16 a, s16 b)
             s16 bar = template->y + 7;
             
             if (r10 <= bar && spC >= bar && r9 <= foo && sp8 >= foo
-             && !FlagGet(template->unk14))
+             && !FlagGet(template->flagId))
                 SpawnFieldObject(template, gSaveBlock1.location.mapNum, gSaveBlock1.location.mapGroup, a, b);
         }
     }
@@ -696,7 +722,7 @@ void RemoveFieldObjectIfOutsideView(struct MapObject *mapObject)
     RemoveFieldObject(mapObject);
 }
 
-void sub_805B75C(int, s16, s16);
+void sub_805B75C(u8, s16, s16);
 
 void sub_805B710(u16 a, u16 b)
 {
@@ -710,3 +736,814 @@ void sub_805B710(u16 a, u16 b)
     }
     sub_805AAB0();
 }
+
+extern void SetPlayerAvatarFieldObjectIdAndObjectId(u8, u8);
+extern void sub_805B914(struct MapObject *);
+
+void sub_805B75C(u8 a, s16 b, s16 c)
+{
+    struct SpriteTemplate sp0;
+    struct SpriteFrameImage sp18;
+    struct SubspriteTable *subspriteTables;
+    const struct MapObjectGraphicsInfo *gfxInfo;
+    struct MapObject *mapObject;
+    u8 spriteId;
+    
+    #define i spriteId
+    for (i = 0; i < 4; i++)
+    {
+        if (gLinkPlayerMapObjects[i].active && a == gLinkPlayerMapObjects[i].mapObjId)
+            return;
+    }
+    #undef i
+    
+    mapObject = &gMapObjects[a];
+    asm("":::"r5");
+    subspriteTables = NULL;
+    gfxInfo = GetFieldObjectGraphicsInfo(mapObject->graphicsId);
+    sp18.size = gfxInfo->size;
+    MakeObjectTemplateFromFieldObjectGraphicsInfoWithCallbackIndex(mapObject->graphicsId, mapObject->animPattern, &sp0, &subspriteTables);
+    sp0.images = &sp18;
+    *(u16 *)&sp0.paletteTag = 0xFFFF;
+    if (gfxInfo->paletteSlot == 0)
+        npc_load_two_palettes__no_record(gfxInfo->paletteTag1, gfxInfo->paletteSlot);
+    if (gfxInfo->paletteSlot > 9)
+        npc_load_two_palettes__and_record(gfxInfo->paletteTag1, gfxInfo->paletteSlot);
+    *(u16 *)&sp0.paletteTag = 0xFFFF;
+    spriteId = CreateSprite(&sp0, 0, 0, 0);
+    if (spriteId != 64)
+    {
+        struct Sprite *sprite = &gSprites[spriteId];
+        
+        sub_8060388(b + mapObject->coords2.x, c + mapObject->coords2.y, &sprite->pos1.x, &sprite->pos1.y);
+        sprite->centerToCornerVecX = -(gfxInfo->width >> 1);
+        sprite->centerToCornerVecY = -(gfxInfo->height >> 1);
+        sprite->pos1.x += 8;
+        sprite->pos1.y += 16 + sprite->centerToCornerVecY;
+        sprite->images = gfxInfo->images;
+        if (mapObject->animPattern == 11)
+        {
+            SetPlayerAvatarFieldObjectIdAndObjectId(a, spriteId);
+            mapObject->mapobj_unk_1B = sub_8126B54();
+        }
+        if (subspriteTables != NULL)
+            SetSubspriteTables(sprite, subspriteTables);
+        sprite->oam.paletteNum = gfxInfo->paletteSlot;
+        sprite->coordOffsetEnabled = TRUE;
+        sprite->data0 = a;
+        mapObject->spriteId = spriteId;
+        if (!mapObject->mapobj_bit_12 && mapObject->animPattern != 11)
+            StartSpriteAnim(sprite, FieldObjectDirectionToImageAnimId(mapObject->mapobj_unk_18));
+        sub_805B914(mapObject);
+        SetObjectSubpriorityByZCoord(mapObject->elevation, sprite, 1);
+    }
+}
+
+void sub_805B914(struct MapObject *mapObject)
+{
+    mapObject->mapobj_bit_1 = FALSE;
+    mapObject->mapobj_bit_2 = TRUE;
+    mapObject->mapobj_bit_22 = FALSE;
+    mapObject->mapobj_bit_17 = FALSE;
+    mapObject->mapobj_bit_18 = FALSE;
+    mapObject->mapobj_bit_19 = FALSE;
+    mapObject->mapobj_bit_20 = FALSE;
+    mapObject->mapobj_bit_21 = FALSE;
+    FieldObjectClearAnim(mapObject);
+}
+
+void SetPlayerAvatarFieldObjectIdAndObjectId(u8 mapObjectId, u8 spriteId)
+{
+    gPlayerAvatar.mapObjectId = mapObjectId;
+    gPlayerAvatar.spriteId = spriteId;
+    gPlayerAvatar.gender = GetPlayerAvatarGenderByGraphicsId(gMapObjects[mapObjectId].graphicsId);
+    SetPlayerAvatarExtraStateTransition(gMapObjects[mapObjectId].graphicsId, 0x20);
+}
+
+void sub_805B980(struct MapObject *mapObject, u8 graphicsId)
+{
+    const struct MapObjectGraphicsInfo *gfxInfo;
+    struct Sprite *sprite;
+    
+    gfxInfo = GetFieldObjectGraphicsInfo(graphicsId);
+    sprite = &gSprites[mapObject->spriteId];
+    if (gfxInfo->paletteSlot == 0)
+        pal_patch_for_npc(gfxInfo->paletteTag1, gfxInfo->paletteSlot);
+    if (gfxInfo->paletteSlot == 10)
+        npc_load_two_palettes__and_record(gfxInfo->paletteTag1, gfxInfo->paletteSlot);
+    sprite->oam.shape = gfxInfo->oam->shape;
+    sprite->oam.size = gfxInfo->oam->size;
+    sprite->images = gfxInfo->images;
+    sprite->anims = gfxInfo->anims;
+    sprite->subspriteTables = gfxInfo->subspriteTables;
+    sprite->oam.paletteNum = gfxInfo->paletteSlot;
+    mapObject->mapobj_bit_12 = gfxInfo->inanimate;
+    mapObject->graphicsId = graphicsId;
+    sub_80603CC(mapObject->coords2.x, mapObject->coords2.y, &sprite->pos1.x, &sprite->pos1.y);
+    sprite->centerToCornerVecX = -(gfxInfo->width >> 1);
+    sprite->centerToCornerVecY = -(gfxInfo->height >> 1);
+    sprite->pos1.x += 8;
+    sprite->pos1.y += 16 + sprite->centerToCornerVecY;
+    if (mapObject->mapobj_bit_15)
+        CameraObjectReset1();
+}
+
+void unref_sub_805BA80(u8 localId, u8 mapNum, u8 mapGroup, u8 graphicsId)
+{
+    u8 mapObjectId;
+    
+    if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId))
+        sub_805B980(&gMapObjects[mapObjectId], graphicsId);
+}
+
+void FieldObjectTurn(struct MapObject *mapObject, u8 direction)
+{
+    FieldObjectSetDirection(mapObject, direction);
+    if (!mapObject->mapobj_bit_12)
+    {
+        StartSpriteAnim(&gSprites[mapObject->spriteId], FieldObjectDirectionToImageAnimId(mapObject->mapobj_unk_18));
+        SeekSpriteAnim(&gSprites[mapObject->spriteId], 0);
+    }
+}
+
+void FieldObjectTurnByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup, u8 direction)
+{
+    u8 mapObjectId;
+    
+    if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId))
+        FieldObjectTurn(&gMapObjects[mapObjectId], direction);
+}
+
+void unref_TurnPlayer(struct PlayerAvatar *player, u8 direction)
+{
+    FieldObjectTurn(&gMapObjects[player->mapObjectId], direction);
+}
+
+void get_berry_tree_graphics(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    u8 treeStage;
+    u8 treeId;
+    
+    mapObject->mapobj_bit_13 = TRUE;
+    sprite->invisible = TRUE;
+    treeStage = GetStageByBerryTreeId(mapObject->trainerRange_berryTreeId);
+    if (treeStage != 0)
+    {
+        mapObject->mapobj_bit_13 = FALSE;
+        sprite->invisible = FALSE;
+        treeId = GetBerryTypeByBerryTreeId(mapObject->trainerRange_berryTreeId) - 1;
+        treeStage--;
+        if (treeId > 0x2B)
+            treeId = 0;
+        sub_805B980(mapObject, gBerryTreeGraphicsIdTablePointers[treeId][treeStage]);
+        sprite->images = gBerryTreePicTablePointers[treeId];
+        sprite->oam.paletteNum = gBerryTreePaletteSlotTablePointers[treeId][treeStage];
+        StartSpriteAnim(sprite, treeStage);
+    }
+}
+
+const struct MapObjectGraphicsInfo *GetFieldObjectGraphicsInfo(u8 graphicsId)
+{
+    if (graphicsId > 0xEF)
+        graphicsId = VarGetFieldObjectGraphicsId(graphicsId + 16);
+    if (graphicsId > 0xD9)
+        graphicsId = 5;
+    return gMapObjectGraphicsInfoPointers[graphicsId];
+}
+
+void FieldObjectHandleDynamicGraphicsId(struct MapObject *mapObject)
+{
+    if (mapObject->graphicsId > 0xEF)
+        mapObject->graphicsId = VarGetFieldObjectGraphicsId(mapObject->graphicsId + 16);
+}
+
+void npc_by_local_id_and_map_set_field_1_bit_x20(u8 localId, u8 mapNum, u8 mapGroup, u8 d)
+{
+    u8 mapObjectId;
+    
+    if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId))
+        gMapObjects[mapObjectId].mapobj_bit_13 = d;
+}
+
+void FieldObjectGetLocalIdAndMap(struct MapObject *mapObject, u8 *localId, u8 *mapNum, u8 *mapGroup)
+{
+    *localId = mapObject->localId;
+    *mapNum = mapObject->mapNum;
+    *mapGroup = mapObject->mapGroup;
+}
+
+void sub_805BCC0(s16 x, s16 y)
+{
+    u8 mapObjectId;
+    struct MapObject *mapObject;
+    
+    mapObjectId = GetFieldObjectIdByXY(x, y);
+    if (mapObjectId != 16)
+    {
+        mapObject = &gMapObjects[mapObjectId];
+        mapObject->mapobj_bit_2 = TRUE;
+    }
+}
+
+void sub_805BCF0(u8 localId, u8 mapNum, u8 mapGroup, u8 subpriority)
+{
+    u8 mapObjectId;
+    struct MapObject *mapObject;
+    struct Sprite *sprite;
+    
+    if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId))
+    {
+        mapObject = &gMapObjects[mapObjectId];
+        sprite = &gSprites[mapObject->spriteId];
+        mapObject->mapobj_bit_26 = TRUE;
+        sprite->subpriority = subpriority;
+    }
+}
+
+void sub_805BD48(u8 localId, u8 mapNum, u8 mapGroup)
+{
+    u8 mapObjectId;
+    struct MapObject *mapObject;
+    
+    if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId))
+    {
+        mapObject = &gMapObjects[mapObjectId];
+        mapObject->mapobj_bit_26 = FALSE;
+        mapObject->mapobj_bit_2 = TRUE;
+    }
+}
+
+void sub_805BD90(u8 localId, u8 mapNum, u8 mapGroup, s16 x, s16 y)
+{
+    u8 mapObjectId;
+    struct Sprite *sprite;
+    
+    if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId))
+    {
+        sprite = &gSprites[gMapObjects[mapObjectId].spriteId];
+        sprite->pos2.x = x;
+        sprite->pos2.y = y;
+    }
+}
+
+void gpu_pal_allocator_reset__manage_upper_four(void)
+{
+    FreeAllSpritePalettes();
+    gReservedSpritePaletteCount = 12;
+}
+
+void sub_805BDF8(u16 tag)
+{
+    u16 paletteIndex = FindFieldObjectPaletteIndexByTag(tag);
+    
+    if (paletteIndex != 0x11FF)  //always happens. FindFieldObjectPaletteIndexByTag returns u8
+        sub_805BE58(&gUnknown_0837377C[paletteIndex]);
+}
+
+void unref_sub_805BE24(u16 *arr)
+{
+    u8 i;
+    
+    for (i = 0; arr[i] != 0x11FF; i++)
+        sub_805BDF8(arr[i]);
+}
+
+u8 sub_805BE58(const struct SpritePalette *palette)
+{
+    if (IndexOfSpritePaletteTag(palette->tag) != 0xFF)
+        return 0xFF;
+    else
+        return LoadSpritePalette(palette);
+}
+
+void pal_patch_for_npc(u16 a, u16 b)
+{
+    u8 var = b;
+    u8 paletteIndex = FindFieldObjectPaletteIndexByTag(a);
+    
+    LoadPalette(gUnknown_0837377C[paletteIndex].data, var * 16 + 0x100, 0x20);
+}
+
+void pal_patch_for_npc_range(const u16 *arr, u8 b, u8 c)
+{
+    for (; b < c; arr++, b++)
+        pal_patch_for_npc(*arr, b);
+}
+
+u8 FindFieldObjectPaletteIndexByTag(u16 tag)
+{
+    u8 i;
+    
+    for (i = 0; gUnknown_0837377C[i].tag != 0x11FF; i++)
+    {
+        if (gUnknown_0837377C[i].tag == tag)
+            return i;
+    }
+    return 0xFF;
+}
+
+const u8 gUnknown_0830FD14[] = {1, 1, 6, 7, 8, 9, 6, 7, 8, 9, 11, 11, 0, 0, 0, 0};
+
+void npc_load_two_palettes__no_record(u16 a, u8 b)
+{
+    u8 i;
+    
+    pal_patch_for_npc(a, b);
+    for (i = 0; gUnknown_08373874[i].tag != 0x11FF; i++)
+    {
+        if (gUnknown_08373874[i].tag == a)
+        {
+            pal_patch_for_npc(gUnknown_08373874[i].data[gUnknown_030005A4], gUnknown_0830FD14[b]);
+            break;
+        }
+    }
+}
+
+void npc_load_two_palettes__and_record(u16 a, u8 b)
+{
+    u8 i;
+    
+    gUnknown_030005A6 = a;
+    pal_patch_for_npc(a, b);
+    for (i = 0; gUnknown_083738E4[i].tag != 0x11FF; i++)
+    {
+        if (gUnknown_083738E4[i].tag == a)
+        {
+            pal_patch_for_npc(gUnknown_083738E4[i].data[gUnknown_030005A4], gUnknown_0830FD14[b]);
+            break;
+        }
+    }
+}
+
+void unref_sub_805C014(struct MapObject *mapObject, s16 x, s16 y)
+{
+    mapObject->coords3.x = mapObject->coords2.x;
+    mapObject->coords3.y = mapObject->coords2.y;
+    mapObject->coords2.x += x;
+    mapObject->coords2.y += y;
+}
+
+void npc_coords_shift(struct MapObject *mapObject, s16 x, s16 y)
+{
+    mapObject->coords3.x = mapObject->coords2.x;
+    mapObject->coords3.y = mapObject->coords2.y;
+    mapObject->coords2.x = x;
+    mapObject->coords2.y = y;
+}
+
+void npc_coords_set(struct MapObject *mapObject, s16 x, s16 y)
+{
+    mapObject->coords3.x = x;
+    mapObject->coords3.y = y;
+    mapObject->coords2.x = x;
+    mapObject->coords2.y = y;
+}
+
+void sub_805C058(struct MapObject *mapObject, s16 x, s16 y)
+{
+    struct Sprite *sprite = &gSprites[mapObject->spriteId];
+    const struct MapObjectGraphicsInfo *gfxInfo = GetFieldObjectGraphicsInfo(mapObject->graphicsId);
+    
+    npc_coords_set(mapObject, x, y);
+    sub_80603CC(mapObject->coords2.x, mapObject->coords2.y, &sprite->pos1.x, &sprite->pos1.y);
+    sprite->centerToCornerVecX = -(gfxInfo->width >> 1);
+    sprite->centerToCornerVecY = -(gfxInfo->height >> 1);
+    sprite->pos1.x += 8;
+    sprite->pos1.y += 16 + sprite->centerToCornerVecY;
+    sub_805B914(mapObject);
+    if (mapObject->mapobj_bit_15)
+        CameraObjectReset1();
+}
+
+void sub_805C0F8(u8 localId, u8 mapNum, u8 mapGroup, s16 x, s16 y)
+{
+    u8 mapObjectId;
+    
+    if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId))
+    {
+        x += 7;
+        y += 7;
+        sub_805C058(&gMapObjects[mapObjectId], x, y);
+    }
+}
+
+void npc_coords_shift_still(struct MapObject *mapObject)
+{
+    npc_coords_shift(mapObject, mapObject->coords2.x, mapObject->coords2.y);
+}
+
+void UpdateFieldObjectCoordsForCameraUpdate(void)
+{
+    u8 i;
+    s16 deltaX;
+    s16 deltaY;
+    
+#ifndef NONMATCHING
+    asm(""::"r"(i));  //makes the compiler store i in r3
+#endif
+
+    if (gUnknown_0202E844.field_0)
+    {    
+        for (i = 0, deltaX = gUnknown_0202E844.x, deltaY = gUnknown_0202E844.y; i < 16; i++)
+        {
+            struct MapObject *mapObject = &gMapObjects[i];
+            
+            if (mapObject->active)
+            {
+                mapObject->coords1.x -= deltaX;
+                mapObject->coords1.y -= deltaY;
+                mapObject->coords2.x -= deltaX;
+                mapObject->coords2.y -= deltaY;
+                mapObject->coords3.x -= deltaX;
+                mapObject->coords3.y -= deltaY;
+            }
+        }
+    }
+}
+
+bool8 FieldObjectDoesZCoordMatch(struct MapObject *, u8);
+
+u8 GetFieldObjectIdByXYZ(u16 x, u16 y, u8 z)
+{
+    u8 i;
+    
+    for (i = 0; i < 16; i++)
+    {
+        if (gMapObjects[i].active && gMapObjects[i].coords2.x == x && gMapObjects[i].coords2.y == y
+         && FieldObjectDoesZCoordMatch(&gMapObjects[i], z))
+            return i;
+    }
+    return 16;
+}
+
+bool8 FieldObjectDoesZCoordMatch(struct MapObject *mapObject, u8 z)
+{
+    if (mapObject->mapobj_unk_0B_0 != 0 && z != 0
+     && mapObject->mapobj_unk_0B_0 != z)
+        return FALSE;
+    else
+        return TRUE;
+}
+
+void UpdateFieldObjectsForCameraUpdate(s16 x, s16 y)
+{
+    UpdateFieldObjectCoordsForCameraUpdate();
+    sub_805B55C(x, y);
+    RemoveFieldObjectsOutsideView();
+}
+
+void ObjectCB_CameraObject(struct Sprite *sprite);
+const struct SpriteTemplate gSpriteTemplate_830FD24 =
+{
+    .tileTag = 0,
+    .paletteTag = 0xFFFF,
+    .oam = &gDummyOamData,
+    .anims = gDummySpriteAnimTable,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = ObjectCB_CameraObject,
+};
+
+u8 AddCameraObject(u8 a)
+{
+    u8 spriteId = CreateSprite(&gSpriteTemplate_830FD24, 0, 0, 4);
+    
+    gSprites[spriteId].invisible = TRUE;
+    gSprites[spriteId].data0 = a;
+    return spriteId;
+}
+
+void CameraObject_0(struct Sprite *);
+void CameraObject_1(struct Sprite *);
+void CameraObject_2(struct Sprite *);
+
+void ObjectCB_CameraObject(struct Sprite *sprite)
+{
+    void (*const cameraObjectFuncs[])(struct Sprite *) =
+    {
+        CameraObject_0,
+        CameraObject_1,
+        CameraObject_2,
+    };
+    
+    cameraObjectFuncs[sprite->data1](sprite);
+}
+
+void CameraObject_0(struct Sprite *sprite)
+{
+    sprite->pos1.x = gSprites[sprite->data0].pos1.x;
+    sprite->pos1.y = gSprites[sprite->data0].pos1.y;
+    sprite->invisible = TRUE;
+    sprite->data1 = 1;
+    CameraObject_1(sprite);
+}
+
+void CameraObject_1(struct Sprite *sprite)
+{
+    s16 x = gSprites[sprite->data0].pos1.x;
+    s16 y = gSprites[sprite->data0].pos1.y;
+    
+    sprite->data2 = x - sprite->pos1.x;
+    sprite->data3 = y - sprite->pos1.y;
+    sprite->pos1.x = x;
+    sprite->pos1.y = y;
+}
+
+void CameraObject_2(struct Sprite *sprite)
+{
+    sprite->pos1.x = gSprites[sprite->data0].pos1.x;
+    sprite->pos1.y = gSprites[sprite->data0].pos1.y;
+    sprite->data2 = 0;
+    sprite->data3 = 0;
+}
+
+struct Sprite *FindCameraObject(void)
+{
+    u8 i;
+    
+    for (i = 0; i < 64; i++)
+    {
+        if (gSprites[i].inUse && gSprites[i].callback == ObjectCB_CameraObject)
+            return &gSprites[i];
+    }
+    return NULL;
+}
+
+void CameraObjectReset1(void)
+{
+    struct Sprite *cameraSprite = FindCameraObject();
+    
+    if (cameraSprite != NULL)
+    {
+        cameraSprite->data1 = 0;
+        cameraSprite->callback(cameraSprite);
+    }
+}
+
+void CameraObjectSetFollowedObjectId(u8 state)
+{
+    struct Sprite *cameraSprite = FindCameraObject();
+    
+    if (cameraSprite != NULL)
+    {
+        cameraSprite->data0 = state;
+        CameraObjectReset1();
+    }
+}
+
+u8 CameraObjectGetFollowedObjectId(void)
+{
+    struct Sprite *cameraSprite = FindCameraObject();
+    
+    if (cameraSprite == NULL)
+        return 64;
+    else
+        return cameraSprite->data0;
+}
+
+void CameraObjectReset2(void)
+{
+    struct Sprite *cameraSprite = FindCameraObject();
+    
+    cameraSprite->data1 = 2;
+}
+
+u8 unref_sub_805C43C(struct Sprite *src, s16 x, s16 y, u8 subpriority)
+{
+    u8 i;
+    
+    for (i = 0; i < 64; i++)
+    {
+        if (!gSprites[i].inUse)
+        {
+            gSprites[i] = *src;
+            gSprites[i].pos1.x = x;
+            gSprites[i].pos1.y = y;
+            gSprites[i].subpriority = subpriority;
+            break;
+        }
+    }
+    return i;
+}
+
+u8 obj_unfreeze(struct Sprite *src, s16 x, s16 y, u8 subpriority)
+{
+    s16 i;
+    
+    for (i = 63; i > -1; i--)
+    {
+        if (!gSprites[i].inUse)
+        {
+            gSprites[i] = *src;
+            gSprites[i].pos1.x = x;
+            gSprites[i].pos1.y = y;
+            gSprites[i].subpriority = subpriority;
+            return i;
+        }
+    }
+    return 64;
+}
+
+void FieldObjectSetDirection(struct MapObject *mapObject, u8 direction)
+{
+    mapObject->mapobj_unk_20 = mapObject->mapobj_unk_18;
+    if (!mapObject->mapobj_bit_9)
+    {
+        s8 _direction = direction;  //needed for the asm to match
+        mapObject->mapobj_unk_18 = _direction;
+    }
+    mapObject->placeholder18 = direction;
+}
+
+u8 *GetFieldObjectScriptPointerByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup)
+{
+    struct MapObjectTemplate *template = GetFieldObjectTemplateByLocalIdAndMap(localId, mapNum, mapGroup);
+    
+    return template->script;
+}
+
+u8 *GetFieldObjectScriptPointerByFieldObjectId(u8 mapObjectId)
+{
+    return GetFieldObjectScriptPointerByLocalIdAndMap(gMapObjects[mapObjectId].localId, gMapObjects[mapObjectId].mapNum, gMapObjects[mapObjectId].mapGroup);
+}
+
+u16 GetFieldObjectFlagIdByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup)
+{
+    struct MapObjectTemplate *template = GetFieldObjectTemplateByLocalIdAndMap(localId, mapNum, mapGroup);
+    
+    return template->flagId;
+}
+
+u16 GetFieldObjectFlagIdByFieldObjectId(u8 mapObjectId)
+{
+    return GetFieldObjectFlagIdByLocalIdAndMap(gMapObjects[mapObjectId].localId, gMapObjects[mapObjectId].mapNum, gMapObjects[mapObjectId].mapGroup);
+}
+
+u8 unref_sub_805C5D0(u8 localId, u8 mapNum, u8 mapGroup)
+{
+    u8 mapObjectId;
+    
+    if (TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId))
+        return 0xFF;
+    else
+        return gMapObjects[mapObjectId].trainerType;
+}
+
+u8 unref_sub_805C60C(u8 mapObjectId)
+{
+    return gMapObjects[mapObjectId].trainerType;
+}
+
+u8 unref_sub_805C624(u8 localId, u8 mapNum, u8 mapGroup)
+{
+    u8 mapObjectId;
+    
+    if (TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId))
+        return 0xFF;
+    else
+        return gMapObjects[mapObjectId].trainerRange_berryTreeId;
+}
+
+u8 FieldObjectGetBerryTreeId(u8 mapObjectId)
+{
+    return gMapObjects[mapObjectId].trainerRange_berryTreeId;
+}
+
+struct MapObjectTemplate *FindFieldObjectTemplateInArrayByLocalId(u8, struct MapObjectTemplate *, u8);
+
+struct MapObjectTemplate *GetFieldObjectTemplateByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup)
+{
+    if (gSaveBlock1.location.mapNum == mapNum && gSaveBlock1.location.mapGroup == mapGroup)
+        return FindFieldObjectTemplateInArrayByLocalId(localId, gSaveBlock1.mapObjectTemplates, gMapHeader.events->mapObjectCount);
+    else
+    {
+        struct MapHeader *mapHeader = get_mapheader_by_bank_and_number(mapGroup, mapNum);
+        
+        return FindFieldObjectTemplateInArrayByLocalId(localId, mapHeader->events->mapObjects, mapHeader->events->mapObjectCount);
+    }
+}
+
+struct MapObjectTemplate *FindFieldObjectTemplateInArrayByLocalId(u8 localId, struct MapObjectTemplate *templates, u8 count)
+{
+    u8 i;
+    
+    for (i = 0; i < count; i++)
+    {
+        if (templates[i].localId == localId)
+            return &templates[i];
+    }
+    return NULL;
+}
+
+struct MapObjectTemplate *sub_805C700(struct MapObject *mapObject)
+{
+    s32 i;
+    
+    if (mapObject->mapNum != gSaveBlock1.location.mapNum
+     || mapObject->mapGroup != gSaveBlock1.location.mapGroup)
+        return NULL;
+    
+    for (i = 0; i < 64; i++)
+    {
+        if (mapObject->localId == gSaveBlock1.mapObjectTemplates[i].localId)
+            return &gSaveBlock1.mapObjectTemplates[i];
+    }
+    return NULL;
+}
+
+void sub_805C754(struct MapObject *mapObject)
+{
+    struct MapObjectTemplate *template = sub_805C700(mapObject);
+    
+    if (template != NULL)
+    {
+        template->x = mapObject->coords2.x - 7;
+        template->y = mapObject->coords2.y - 7;
+    }
+}
+
+void sub_805C774(struct MapObject *mapObject, u8 movementType)
+{
+    struct MapObjectTemplate *template = sub_805C700(mapObject);
+    
+    if (template != NULL)
+        template->movementType = movementType;
+}
+
+void sub_805C78C(u8 localId, u8 mapNum, u8 mapGroup)
+{
+    u8 mapObjectId;
+    
+    if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId))
+        sub_805C754(&gMapObjects[mapObjectId]);
+}
+
+void sub_805C7C4(u8 a)
+{
+    gpu_pal_allocator_reset__manage_upper_four();
+    gUnknown_030005A6 = 0x11FF;
+    gUnknown_030005A4 = a;
+    pal_patch_for_npc_range(gUnknown_0837399C[gUnknown_030005A4], 0, 10);
+}
+
+u16 npc_paltag_by_palslot(u8 a)
+{
+    u8 i;
+    
+    if (a < 10)
+        return gUnknown_0837399C[gUnknown_030005A4][a];
+    
+    for (i = 0; gUnknown_083738E4[i].tag != 0x11FF; i++)
+    {
+        if (gUnknown_083738E4[i].tag == gUnknown_030005A6)
+        {
+            return gUnknown_083738E4[i].data[gUnknown_030005A4];
+        }
+    }
+    return 0x11FF;
+}
+
+u32 sub_805C8A8(void);
+
+void sub_805C884(struct Sprite *sprite)
+{
+    meta_step(&gMapObjects[sprite->data0], sprite, sub_805C8A8);
+}
+
+u32 sub_805C8A8(void)
+{
+    return 0;
+}
+
+u32 sub_805C8D0(struct MapObject *, struct Sprite *);
+
+void sub_805C8AC(struct Sprite *sprite)
+{
+    meta_step(&gMapObjects[sprite->data0], sprite, sub_805C8D0);
+}
+
+extern u8 (*const gUnknown_08375224[])();
+
+u32 sub_805C8D0(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    return gUnknown_08375224[sprite->data1](mapObject, sprite);
+}
+
+void npc_reset();
+
+u8 sub_805C8F0(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    npc_reset(mapObject);
+    sprite->data1 = 1;
+    return 1;
+}
+
+extern void FieldObjectSetRegularAnim();
+
+u8 sub_805C904(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18));
+    sprite->data1 = 2;
+    return 1;
+}
+
diff --git a/src/field_map_obj_helpers.c b/src/field_map_obj_helpers.c
index 815a5aabd..afc3c680c 100644
--- a/src/field_map_obj_helpers.c
+++ b/src/field_map_obj_helpers.c
@@ -311,7 +311,7 @@ void DoShadowFieldEffect(struct MapObject *mapObject)
 
 void DoRippleFieldEffect(struct MapObject *mapObject, struct Sprite *sprite)
 {
-    struct MapObjectGraphicsInfo *gfxInfo = GetFieldObjectGraphicsInfo(mapObject->graphicsId);
+    const struct MapObjectGraphicsInfo *gfxInfo = GetFieldObjectGraphicsInfo(mapObject->graphicsId);
     gUnknown_0202FF84[0] = sprite->pos1.x;
     gUnknown_0202FF84[1] = sprite->pos1.y + (gfxInfo->height >> 1) - 2;
     gUnknown_0202FF84[2] = 151;
diff --git a/src/field_player_avatar.c b/src/field_player_avatar.c
index e4c3b78c9..51a2d8089 100644
--- a/src/field_player_avatar.c
+++ b/src/field_player_avatar.c
@@ -1185,7 +1185,7 @@ void InitPlayerAvatar(s16 x, s16 y, u8 direction, u8 gender)
     playerMapObjTemplate.unkC = 0;
     playerMapObjTemplate.unkE = 0;
     playerMapObjTemplate.script = NULL;
-    playerMapObjTemplate.unk14 = 0;
+    playerMapObjTemplate.flagId = 0;
     mapObjectId = SpawnSpecialFieldObject(&playerMapObjTemplate);
     mapObject = &gMapObjects[mapObjectId];
     mapObject->mapobj_bit_16 = 1;
diff --git a/src/fieldmap.c b/src/fieldmap.c
index f3794f286..7a24897c4 100644
--- a/src/fieldmap.c
+++ b/src/fieldmap.c
@@ -16,13 +16,6 @@ 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;
diff --git a/src/pokemon_2.c b/src/pokemon_2.c
index c591e893a..9030fe096 100644
--- a/src/pokemon_2.c
+++ b/src/pokemon_2.c
@@ -249,8 +249,7 @@ void GetMonSpriteTemplate_803C56C(u16 species, u8 a2)
 {
     gUnknown_02024E8C = gSpriteTemplate_8208288[a2];
     gUnknown_02024E8C.paletteTag = species;
-    //Don't know why the compiler says this is incompatible
-    gUnknown_02024E8C.anims = (const union AnimCmd *const *)gSpriteAnimTable_81E7C64;
+    gUnknown_02024E8C.anims = (const union AnimCmd *const *)gSpriteAnimTable_81E7C64;  //Why do I have to cast this?
 }
 
 void GetMonSpriteTemplate_803C5A0(u16 species, u8 a2)
diff --git a/src/sprite.c b/src/sprite.c
index 43ee5696b..409c66cfa 100644
--- a/src/sprite.c
+++ b/src/sprite.c
@@ -58,7 +58,7 @@ static void ResetOamMatrices(void);
 static void ResetSprite(struct Sprite *sprite);
 static s16 AllocSpriteTiles(u16 tileCount);
 u8 SpriteTileAllocBitmapOp(u16 bit, u8 op);
-static void RequestSpriteFrameImageCopy(u16 index, u16 tileNum, struct SpriteFrameImage *images);
+static void RequestSpriteFrameImageCopy(u16 index, u16 tileNum, const struct SpriteFrameImage *images);
 static void ResetAllSprites(void);
 static void BeginAnim(struct Sprite *sprite);
 static void ContinueAnim(struct Sprite *sprite);
@@ -829,7 +829,7 @@ void ProcessSpriteCopyRequests(void)
     }
 }
 
-static void RequestSpriteFrameImageCopy(u16 index, u16 tileNum, struct SpriteFrameImage *images)
+static void RequestSpriteFrameImageCopy(u16 index, u16 tileNum, const struct SpriteFrameImage *images)
 {
     if (gSpriteCopyRequestCount < MAX_SPRITE_COPY_REQUESTS)
     {