Moves and some friend_area_action_menu

15 files changed, 1291 insertions, 73 deletions

diff --git a/src/code_801AFA4.c b/src/code_801AFA4.c
index 9ab6fec..14b9e99 100644
--- a/src/code_801AFA4.c
+++ b/src/code_801AFA4.c
@@ -26,7 +26,7 @@ extern u8 gUnknown_202E1C8[0x50];
 extern u8 gAvailablePokemonNames[0x50];
 extern u8 gUnknown_202E218[0x50];
 
-extern void sub_8092AD4(struct PokemonMove*, u16);
+extern void InitZeroedPPPokemonMove(struct PokemonMove*, u16);
 extern void sub_809401C(struct PokemonMove *, struct PokemonMove *);
 extern bool8 IsHMItem(u8);
 extern void DisplayGulpinDialogueSprite(u32, u32, void *);
@@ -195,7 +195,7 @@ void sub_801B200(void)
                     pokeMove = &gUnknown_203B22C->moves[moveIndex];
                     if((pokeMove->moveFlags & MOVE_FLAG_EXISTS) == 0)
                     {
-                        sub_8092AD4(pokeMove, gUnknown_203B22C->moveID);
+                        InitZeroedPPPokemonMove(pokeMove, gUnknown_203B22C->moveID);
                         break;
                     }
                 }
diff --git a/src/code_801DCC4.c b/src/code_801DCC4.c
index a17b3b9..5a42567 100644
--- a/src/code_801DCC4.c
+++ b/src/code_801DCC4.c
@@ -8,7 +8,7 @@ struct unkStruct_203B25C
 {
     // size: 0x11C
     u32 state;
-    u32 unk4;
+    u32 chosenHintIndex;
     struct UnkSaveStruct1 unk8;
     u32 unk18;
     const char *unk1C;
@@ -31,17 +31,17 @@ extern void sub_801DED0();
 extern void sub_8012D60(const char **, struct MenuItem *, u32, u16 *, u32, u32);
 extern u32 sub_801E198(struct UnkSaveStruct1 *);
 extern void sub_8014248(const char *, u32, u32, struct MenuItem *, u32, u32, u32, u32, u32);
-extern void sub_801E658(u32);
+extern void CreateHintDisplayScreen(u32);
 extern void sub_801E3F0(u32);
-extern void sub_801E510(u32);
+extern void CreateHintSelectionScreen(u32);
 extern void CreateChangeSettingsConfirmMenu(void);
 extern u8 sub_8012FD8(u32 *);
 extern void sub_8013114(u32 *, u32 *);
 extern u32 sub_801E474(u32);
-extern u32 sub_801E4F4(void);
+extern u32 GetChosenHintIndex(void);
 extern void sub_801E54C(void);
-extern u32 sub_801E6CC(void);
-extern void sub_801E724(void);
+extern u32 HandleHintDisplayScreenInput(void);
+extern void DestroyHintDisplayScreen(void);
 extern u32 sub_801E218(void);
 extern bool8 GameOptionsNotChange(struct UnkSaveStruct1 *);
 extern void sub_801E2C4(void);
@@ -358,10 +358,10 @@ void sub_801DED0(void)
         sub_801E3F0(0);
         break;
     case 4:
-        sub_801E510(1);
+        CreateHintSelectionScreen(1);
         break;
     case 5:
-        sub_801E658(gUnknown_203B25C->unk4);
+        CreateHintDisplayScreen(gUnknown_203B25C->chosenHintIndex);
         break;
     case 6:
         // Load our current options?
@@ -446,7 +446,7 @@ void sub_801E088(void)
   {
     case 3:
     case 4:
-        gUnknown_203B25C->unk4 = sub_801E4F4();
+        gUnknown_203B25C->chosenHintIndex = GetChosenHintIndex();
         sub_801DD6C(5);
         break;
     case 2:
@@ -463,11 +463,11 @@ void sub_801E088(void)
 
 void sub_801E0E0(void)
 {
-  switch(sub_801E6CC()) 
+  switch(HandleHintDisplayScreenInput())
   {
     case 3:
     case 2:
-        sub_801E724();
+        DestroyHintDisplayScreen();
         sub_801DD6C(4);
         break;
     case 0:
diff --git a/src/code_8057824.c b/src/code_8057824.c
index 9d0e673..7f02fd5 100644
--- a/src/code_8057824.c
+++ b/src/code_8057824.c
@@ -1,6 +1,7 @@
 #include "global.h"
 #include "dungeon_global_data.h"
 #include "dungeon_entity.h"
+#include "constants/move.h"
 
 extern struct DungeonGlobalData *gDungeonGlobalData;
 
@@ -31,7 +32,7 @@ extern void sub_806F370(struct DungeonEntity *r0, struct DungeonEntity *r1, u32,
 
 extern u32 gUnknown_80FD018;
 extern s16 sub_8057600(void*, u32);
-extern u32 sub_8092B00(void*);
+extern u32 GetMoveType(void*);
 
 bool32 sub_8057824(struct DungeonEntity *param_1, struct DungeonEntity *param_2)
 {
@@ -100,7 +101,7 @@ bool32 sub_8057954(struct DungeonEntity *param_1, struct DungeonEntity *param_2,
   return TRUE;
 }
 
-bool32 sub_8057974(struct DungeonEntity *param_1, struct DungeonEntity *param_2, void* param_3, u32 param_4)
+bool32 sub_8057974(struct DungeonEntity *param_1, struct DungeonEntity *param_2, struct PokemonMove *param_3, u32 param_4)
 {
   s32 newHP;
   u8 local_24;
@@ -108,7 +109,7 @@ bool32 sub_8057974(struct DungeonEntity *param_1, struct DungeonEntity *param_2,
   newHP = param_2->entityData->HP / 2;
   local_24 = 0;
   if (newHP != 0) {
-    sub_806F370(param_1,param_2,newHP,1,&local_24,sub_8092B00(param_3),sub_8057600(param_3,param_4),0,1,0);
+    sub_806F370(param_1,param_2,newHP,1,&local_24,GetMoveType(param_3),sub_8057600(param_3,param_4),0,1,0);
     local_24 = local_24 == 0;
   }
   else
diff --git a/src/friend_area_action_menu.c b/src/friend_area_action_menu.c
index 3cd9c84..e6d09cd 100644
--- a/src/friend_area_action_menu.c
+++ b/src/friend_area_action_menu.c
@@ -21,13 +21,13 @@ extern const char gUnknown_80DD8D0[];
 extern void sub_80141B4(const char *r0, u32, u32 *r1, u32);
 extern void sub_8014248(const char *r0, u32, u32, struct MenuItem *r4, u32, u32, u32, u32 *r5, u32);
 extern void sub_8012D60(u32 *, struct MenuItem *, u32, u32 *, u32, u32);
-extern void sub_8027D40(u32, struct ItemSlot *);
+extern void sub_8027D40(u32, struct HeldItem *);
 extern void sub_8023868(u32, u32, u32, u32);
 extern void sub_8023B7C(u32);
 extern void sub_8023DA4();
 extern void sub_8024458(s16, u32);
 extern void sub_801BEEC(s16);
-extern void sub_8093560(u32, u32 *, u32 *);
+extern void sub_8093560(u32, struct PokemonMove *, u32 *);
 extern void sub_801F808(u32 *);
 extern void sub_8027794();
 extern void sub_801A5D8(u32, u32, u32, u32);
@@ -35,8 +35,8 @@ extern void sub_801A8D0(u32);
 extern void sub_801A9E0();
 extern void sub_801F1B0(u32, u32);
 extern void sub_801B3C0(struct ItemSlot *);
-extern void sub_809401C(u32 *, struct PokemonMove *);
-extern void sub_801EE10(u32, s16, u32 *, u32, u32, u32);
+extern void sub_809401C(struct PokemonMove *, struct PokemonMove *);
+extern void sub_801EE10(u32, s16, struct PokemonMove *, u32, u32, u32);
 
 extern void sub_8012CAC(struct UnkTextStruct2 *, struct MenuItem *);
 extern void SetFriendAreaActionMenuState(u32);
@@ -206,8 +206,8 @@ void sub_8027274(void)
         sub_801B3C0(&slot);
         break;
     case 0xe:
-        sub_809401C(&gUnknown_203B2BC->unk28,gUnknown_203B2BC->unk18->moves);
-        sub_801EE10(3,gUnknown_203B2BC->targetPoke,&gUnknown_203B2BC->unk28,0,0,0);
+        sub_809401C(gUnknown_203B2BC->unk28,gUnknown_203B2BC->unk18->moves);
+        sub_801EE10(3,gUnknown_203B2BC->targetPoke,gUnknown_203B2BC->unk28,0,0,0);
         break;
     case 0xf:
         sub_801F1B0(1,0);
@@ -229,7 +229,7 @@ void sub_8027274(void)
         sub_8014248(gUnknown_80DD7FC,0,3,gUnknown_203B2BC->menuItems,0,4,0,0,0x101);
         break;
     case 0x10:
-        sub_8093560(gUnknown_203B2BC->unk20,&gUnknown_203B2BC->unk28,&gUnknown_203B2BC->unk68);
+        sub_8093560(gUnknown_203B2BC->unk20,gUnknown_203B2BC->unk28,&gUnknown_203B2BC->unk68);
         sub_801F808(&gUnknown_203B2BC->unk68);
         break;
     case 6:
diff --git a/src/friend_area_action_menu_1.c b/src/friend_area_action_menu_1.c
index 33cbded..6856d5f 100644
--- a/src/friend_area_action_menu_1.c
+++ b/src/friend_area_action_menu_1.c
@@ -4,6 +4,7 @@
 #include "menu.h"
 #include "item.h"
 #include "team_inventory.h"
+#include "pokemon.h"
 #include "friend_area_action_menu.h"
 
 extern struct unkStruct_203B2BC *gUnknown_203B2BC;
@@ -11,17 +12,14 @@ extern struct TeamInventory *gTeamInventory_203B460;
 
 u32 sub_801B410();
 void sub_801B450();
-u32 sub_801EF38(u8 r0);
-void sub_801F214();
+extern u32 sub_801EF38(u8 r0);
+extern void sub_801F214();
 
 extern void SetFriendAreaActionMenuState(u32);
 extern u8 sub_8012FD8(u32 *r0);
 extern void sub_8013114(u32 *, s32 *);
 extern void PlaySound(u32);
-extern void ShiftItemsDownFrom(u32);
-extern void FillInventoryGaps();
 extern void nullsub_104();
-extern void sub_8091274(struct ItemSlot *);
 extern void sub_801A928();
 extern void sub_8099690(u32);
 extern void GivePokemonItem(s16, struct HeldItem *);
@@ -31,6 +29,21 @@ extern u32 sub_801A6E8(u32);
 extern s32 sub_80144A4(s32 *);
 extern void sub_8027EB8();
 extern void sub_808D31C(struct PokemonStruct *);
+u32 sub_8027E18(struct PokemonStruct *);
+bool8 IsNotMoneyOrUsedTMItem(u8 id);
+u8 sub_8027E4C(struct PokemonStruct *r0);
+extern u8 sub_80023E4(u32);
+extern struct PokemonStruct *sub_808D3F8(void);
+extern struct PokemonStruct *sub_808D3BC(void);
+extern u32 sub_801F890(void);
+extern void sub_801F8D0(void);
+extern u8 gUnknown_80DD958[];
+extern void xxx_format_and_draw(u32, u32, u8 *, ...);
+extern void sub_8008C54(u32);
+extern void sub_80073B8(u32);
+extern void sub_80073E0(u32);
+extern u8 gUnknown_202DE58[];
+extern u32 sub_801F194(void);
 
 void sub_8027AE4(void)
 {
@@ -93,7 +106,7 @@ void sub_8027BD8(void)
         PlaySound(0x14d);
         ShiftItemsDownFrom(gUnknown_203B2BC->itemIndex);
         FillInventoryGaps();
-        if (gUnknown_203B2BC->unk14.itemFlags != 0) {
+        if (gUnknown_203B2BC->unk14.itemIndex != 0) {
             sub_8091274(&gUnknown_203B2BC->unk14);
         }
         GivePokemonItem(gUnknown_203B2BC->targetPoke,&gUnknown_203B2BC->itemToGive);
@@ -124,3 +137,172 @@ void sub_8027C84()
             break;
     }
 }
+
+void sub_8027CA0(void)
+{
+    switch(sub_801EF38(1))
+    {
+        case 3:
+        case 4:
+            gUnknown_203B2BC->unk20 = sub_801F194();
+            gUnknown_203B2BC->unk24 = gUnknown_203B2BC->unk28[gUnknown_203B2BC->unk20].moveID;
+            SetFriendAreaActionMenuState(0x10);
+            break;
+        case 2:
+            sub_801F214();
+            SetFriendAreaActionMenuState(0x2);
+            break;
+        case 0:
+        case 1:
+            break;
+    }
+}
+
+void sub_8027D00(void)
+{
+    switch(sub_801F890())
+    {
+        case 2:
+        case 3:
+            sub_801F8D0();
+            SetFriendAreaActionMenuState(0xF);
+            break;
+        case 0:
+        case 1:
+            break;
+    }
+}
+
+void sub_8027D1C(void)
+{
+    s32 temp;
+    if(sub_80144A4(&temp) == 0)
+    {
+        SetFriendAreaActionMenuState(gUnknown_203B2BC->unk4);
+    }
+}
+
+void sub_8027D40(u32 r0, struct HeldItem *heldItem)
+{
+
+    struct ItemSlot slot;
+    struct unkStruct_8090F58 a3;
+
+    sub_8008C54(r0);
+    sub_80073B8(r0);
+    HeldItemToSlot(&slot, heldItem);
+    a3.unk0 = 0;
+    a3.unk4 = 0;
+    a3.unk8 = 1;
+    slot.itemFlags = 1;
+    sub_8090E14(gUnknown_202DE58, &slot, &a3);
+    xxx_format_and_draw(4, 3, gUnknown_80DD958, r0, 0);
+    sub_80073E0(r0);
+}
+
+u32 sub_8027D9C(struct PokemonStruct *r0)
+{
+    u32 var1;
+    if(r0->unk2 == 0)
+    {
+        var1 = 0;
+        if(r0->unk4.unk4 == 0x41)
+            var1 = 1;
+            if(var1 != 0)
+            {
+                if(sub_80023E4(8) == 0)
+                    return 0;
+            }
+    }
+    else
+        return 0;
+    return 1;
+}
+
+u32 sub_8027DCC(struct PokemonStruct *r0)
+{
+    u32 var1;
+    if(sub_808D3BC() != r0)
+        if(sub_808D3F8() != r0)
+            if(r0->unk2 == 0)
+            {
+                var1 = 0;
+                if(r0->unk4.unk4 == 0x41)
+                    var1 = 1;
+                if(var1 != 0)
+                {
+                    if(sub_80023E4(8) != 0)
+                        goto check;
+                }
+                else
+                {
+                    check:
+                    if(sub_8027E18(r0) != 3)
+                        return 1;
+                }
+            }
+    return 0;
+}
+
+u32 sub_8027E18(struct PokemonStruct *r0)
+{
+    if(r0->heldItem.itemIndex == 0)
+        return 0;
+    else if(GetNumberOfFilledInventorySlots() < INVENTORY_SIZE)
+        return 1;
+    else if(sub_8027E4C(r0))
+        return 2;
+    else
+        return 3;
+}
+
+u8 sub_8027E4C(struct PokemonStruct *r0)
+{
+    if(!IsNotMoneyOrUsedTMItem(r0->heldItem.itemIndex))
+        return 0;
+    else
+    {
+        if(IsThrowableItem(r0->heldItem.itemIndex))
+        {
+            if(gTeamInventory_203B460->teamStorage[r0->heldItem.itemIndex] + r0->heldItem.numItems > 0x3e7)
+                return 0;
+        }
+        else if(gTeamInventory_203B460->teamStorage[r0->heldItem.itemIndex] > 0x3e6)
+        {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+void sub_8027EB8(void)
+{
+    switch(sub_8027E18(gUnknown_203B2BC->unk18))
+    {
+        case 1:
+            PlaySound(0x14d);
+            sub_8091274(&gUnknown_203B2BC->unk14);
+            FillInventoryGaps();
+            gUnknown_203B2BC->unk14.itemIndex = 0;
+            gUnknown_203B2BC->unk14.numItems = 0;
+            GivePokemonItem(gUnknown_203B2BC->targetPoke, &gUnknown_203B2BC->unk14);
+            SetFriendAreaActionMenuState(6);
+            break;
+        case 2:
+            PlaySound(0x14d);
+            if(IsThrowableItem(gUnknown_203B2BC->unk14.itemIndex))
+                gTeamInventory_203B460->teamStorage[gUnknown_203B2BC->unk14.itemIndex] += gUnknown_203B2BC->unk14.numItems;
+            else
+                gTeamInventory_203B460->teamStorage[gUnknown_203B2BC->unk14.itemIndex] += 1;
+            gUnknown_203B2BC->unk14.itemIndex = 0;
+            gUnknown_203B2BC->unk14.numItems = 0;
+            GivePokemonItem(gUnknown_203B2BC->targetPoke, &gUnknown_203B2BC->unk14);
+            SetFriendAreaActionMenuState(7);
+            break;
+        case 0:
+        default:
+            SetFriendAreaActionMenuState(2);
+            break;
+    }
+}
+
diff --git a/src/gulpin_shop.c b/src/gulpin_shop.c
index d5ebc6b..8dfa0d9 100644
--- a/src/gulpin_shop.c
+++ b/src/gulpin_shop.c
@@ -21,7 +21,7 @@ extern void sub_801EA28();
 extern void sub_8012CAC(struct UnkTextStruct2 *, struct MenuItem *);
 extern void sub_801EBC4();
 
-u32 DisplayGulpinDialogueSprite(s32 param_1,s16 pokeSpecies,struct unkStruct_Gulpin *param_3)
+u32 DisplayGulpinDialogueSprite(s32 param_1,s16 pokeSpecies,struct PokemonMove *param_3)
 {
   struct OpenedFile *faceFile;
   s32 species_32;
@@ -32,7 +32,7 @@ u32 DisplayGulpinDialogueSprite(s32 param_1,s16 pokeSpecies,struct unkStruct_Gul
   gUnknown_203B26C->unk0 = param_1;
   gUnknown_203B26C->speciesNum = species_32;
   gUnknown_203B26C->unk10 = param_3;
-  gUnknown_203B26C->unk1C = param_3->unk22;
+  gUnknown_203B26C->unk1C = param_3[4].moveID;
 
   if (param_1 == 0) {
    gUnknown_203B26C->unk128 = &gUnknown_203B26C->faceFile;
diff --git a/src/gulpin_shop_1.c b/src/gulpin_shop_1.c
index 2eadcfe..e9468a8 100644
--- a/src/gulpin_shop_1.c
+++ b/src/gulpin_shop_1.c
@@ -9,14 +9,14 @@
 
 extern struct unkStruct_203B26C *gUnknown_203B26C;
 extern void UpdateGulpinShopState(u32);
-extern void sub_8093CF8(struct unkStruct_Gulpin *, u32);
+extern void sub_8093CF8(struct PokemonMove *, u32);
 extern void sub_801F214(void);
 extern s32 sub_80144A4(s32 *);
 extern u32 sub_801F890(void);
 extern void sub_801F8D0(void);
 extern u8 sub_8012FD8(u32 *);
 extern void sub_8013114(u32 *, u32 *);
-extern u8 sub_80934B0(u32, struct unkStruct_Gulpin *);
+extern u8 sub_80934B0(u32, struct PokemonMove *);
 extern void PlaySound(u32);
 extern void sub_801EF38(u32);
 
diff --git a/src/hints_menu.c b/src/hints_menu.c
new file mode 100644
index 0000000..15c1936
--- /dev/null
+++ b/src/hints_menu.c
@@ -0,0 +1,285 @@
+#include "global.h"
+#include "memory.h"
+#include "text.h"
+#include "input.h"
+
+#define MAX_HINTS 5
+
+struct Hints
+{
+    u8 *heading;
+    u8 *body;
+};
+
+struct unkStruct_203B268
+{
+    // size: 0xA0
+    u32 unk0;
+    u8 fill4[0x1E - 0x4];
+    s16 helpPageIndex;
+    u16 unk20;
+    u8 fill22[0x34 - 0x22];
+    u32 unk34;
+    struct UnkTextStruct2 *unk38;
+    struct UnkTextStruct2 unk3C[4];
+    u8 unk9C[4];
+};
+
+struct unkStruct_203B264
+{
+    // size: 0x9C
+    u32 unk0;
+    u8 fill4[0x18 - 0x4];
+    s16 unk18;
+    s16 unk1A;
+    s16 unk1C;
+    s16 unk1E;
+    u16 unk20;
+    u8 fill22[0x34 - 0x22];
+    u32 unk34;
+    struct UnkTextStruct2 *unk38;
+    struct UnkTextStruct2 unk3C[4];
+};
+
+extern struct unkStruct_203B264 *gUnknown_203B264;
+
+extern struct unkStruct_203B268 *gUnknown_203B268;
+
+extern struct UnkTextStruct2 gUnknown_80DC0A0;
+extern struct UnkTextStruct2 gUnknown_80DC0BC;
+extern struct UnkTextStruct2 gUnknown_80DC0E4;
+extern struct UnkTextStruct2 gUnknown_80DC0FC;
+extern struct Hints gGameHints[MAX_HINTS];
+extern u8 gUnknown_80DC0D4[MAX_HINTS];
+
+extern void sub_801E714(void);
+extern void sub_8013818(void *, u32, u32, u32);
+extern bool8 sub_8013938(void *);
+extern s32 GetKeyPress(void *);
+extern void PlayMenuSoundEffect(u32);
+extern void sub_801E714(void);
+extern void sub_801E76C(void);
+extern void DisplayChosenHint(void);
+extern void xxx_call_draw_string(s32, u32, u8 *, u32, u32);
+extern void sub_80073E0(u32);
+extern void sub_80073B8(u32);
+extern s32 sub_8013800(void *, u32);
+extern void sub_8008C54(u32);
+void DrawHintSelectionMenu(void);
+void sub_801E594(void);
+void sub_8013984(void *);
+void AddMenuCursorSprite(void *);
+extern u8 sub_80138B8(void *, u32);
+extern void sub_8013660(void *);
+extern void sub_8012D08(struct UnkTextStruct2 *, u32);
+
+u32 sub_801E3F0(u32 r0)
+{
+    if(gUnknown_203B264 == NULL)
+        gUnknown_203B264 = MemoryAlloc(sizeof(struct unkStruct_203B264), 8);
+    gUnknown_203B264->unk34 = r0;
+    gUnknown_203B264->unk38 = &gUnknown_203B264->unk3C[r0];
+    sub_8006518(gUnknown_203B264->unk3C);
+    gUnknown_203B264->unk3C[gUnknown_203B264->unk34] = gUnknown_80DC0BC;
+    sub_8012D08(gUnknown_203B264->unk38, 0xA);
+    ResetUnusedInputStruct();
+    sub_800641C(gUnknown_203B264->unk3C, 1, 1);
+    sub_8013818(gUnknown_203B264, 0x5, 0xA, r0);
+    sub_801E594();
+    DrawHintSelectionMenu();
+    return 1;
+}
+
+u32 sub_801E474(u8 r0)
+{
+    if(r0 == 0)
+    {
+        sub_8013660(gUnknown_203B264);
+        return 0;
+    }
+    switch(GetKeyPress(gUnknown_203B264))
+    {
+        case 2:
+            PlayMenuSoundEffect(1);
+            return 2;
+        case 1:
+            PlayMenuSoundEffect(0);
+            return 3;
+        case 4:
+            PlayMenuSoundEffect(4);
+            return 4;
+        default:
+            if(sub_80138B8(gUnknown_203B264, 1))
+            {
+                sub_801E594();
+                DrawHintSelectionMenu();
+                return 1;
+            }
+            else
+                return 0;
+    }
+}
+
+s32 GetChosenHintIndex(void)
+{
+    return (gUnknown_203B264->unk1E * gUnknown_203B264->unk1C) + gUnknown_203B264->unk18;
+}
+
+void CreateHintSelectionScreen(u32 r0)
+{
+    u8 bool8_r0;
+    bool8_r0 = r0;
+
+    ResetUnusedInputStruct();
+    sub_800641C(gUnknown_203B264->unk3C, 0, 0);
+    sub_8013984(gUnknown_203B264);
+    sub_801E594();
+    DrawHintSelectionMenu();
+    if(bool8_r0)
+        AddMenuCursorSprite(gUnknown_203B264);
+}
+
+void sub_801E54C(void)
+{
+    if(gUnknown_203B264 != NULL)
+    {
+        gUnknown_203B264->unk3C[gUnknown_203B264->unk34] = gUnknown_80DC0A0;
+        ResetUnusedInputStruct();
+        sub_800641C(gUnknown_203B264->unk3C, 1, 1);
+        MemoryFree(gUnknown_203B264);
+        gUnknown_203B264 = NULL;
+    }
+}
+
+NAKED
+void sub_801E594(void)
+{
+    asm_unified(
+	"\tpush {r4,lr}\n"
+	"\tldr r4, _0801E5E4\n"
+	"\tldr r0, [r4]\n"
+	"\tmovs r1, 0x1A\n"
+	"\tldrsh r0, [r0, r1]\n"
+	"\tmovs r1, 0xC\n"
+	"\tbl sub_80095E4\n"
+	"\tadds r0, 0x2\n"
+	"\tlsls r0, 16\n"
+	"\tldr r2, [r4]\n"
+	"\tldr r3, [r2, 0x34]\n"
+	"\tlsls r1, r3, 1\n"
+	"\tadds r1, r3\n"
+	"\tlsls r1, 3\n"
+	"\tadds r1, r2, r1\n"
+	"\tadds r1, 0x4A\n"
+	"\tasrs r3, r0, 16\n"
+	"\tlsrs r0, 16\n"
+	"\tstrh r0, [r1]\n"
+	"\tldr r1, [r2, 0x34]\n"
+	"\tlsls r0, r1, 1\n"
+	"\tadds r0, r1\n"
+	"\tlsls r0, 3\n"
+	"\tadds r2, r0\n"
+	"\tadds r3, 0x2\n"
+	"\tadds r2, 0x4C\n"
+	"\tstrh r3, [r2]\n"
+	"\tbl ResetUnusedInputStruct\n"
+	"\tldr r0, [r4]\n"
+	"\tadds r0, 0x3C\n"
+	"\tmovs r1, 0x1\n"
+	"\tmovs r2, 0x1\n"
+	"\tbl sub_800641C\n"
+	"\tpop {r4}\n"
+	"\tpop {r0}\n"
+	"\tbx r0\n"
+	"\t.align 2, 0\n"
+"_0801E5E4: .4byte gUnknown_203B264");
+}
+
+void DrawHintSelectionMenu(void)
+{
+    s32 hintIndex;
+    s32 y;
+
+    sub_8008C54(gUnknown_203B264->unk34);
+    sub_80073B8(gUnknown_203B264->unk34);
+    xxx_call_draw_string(16, 0, gUnknown_80DC0D4, gUnknown_203B264->unk34, 0);
+    for(hintIndex = 0; hintIndex < MAX_HINTS; hintIndex++)
+    {
+        y = sub_8013800(gUnknown_203B264, hintIndex);
+        xxx_call_draw_string(10, y, gGameHints[hintIndex].heading, gUnknown_203B264->unk34, 0);
+    }
+    sub_80073E0(gUnknown_203B264->unk34);
+}
+
+u32 CreateHintDisplayScreen(u32 index)
+{
+    gUnknown_203B268 = MemoryAlloc(sizeof(struct unkStruct_203B268), 8);
+    gUnknown_203B268->unk34 = 0;
+    gUnknown_203B268->unk38 = gUnknown_203B268->unk3C;
+    sub_8006518(gUnknown_203B268->unk3C);
+    gUnknown_203B268->unk3C[gUnknown_203B268->unk34] = gUnknown_80DC0FC;
+    gUnknown_203B268->unk38->unk14 = gUnknown_203B268->unk9C;
+    ResetUnusedInputStruct();
+    sub_800641C(gUnknown_203B268->unk3C, 1, 1);
+    sub_8013818(gUnknown_203B268, 5, 1, gUnknown_203B268->unk34);
+    gUnknown_203B268->helpPageIndex = index;
+    sub_801E714();
+
+    return 1;
+}
+
+u32 HandleHintDisplayScreenInput(void)
+{
+    switch(GetKeyPress(gUnknown_203B268))
+    {
+        case 2:
+            PlayMenuSoundEffect(1);
+            return 2;
+        case 1:
+            PlayMenuSoundEffect(0);
+            return 3;
+        default:
+            if(sub_8013938(gUnknown_203B268)){
+                sub_801E714();
+                return 1;
+            }
+            else
+                return 0;
+    }
+}
+
+void sub_801E714(void)
+{
+    sub_801E76C();
+    DisplayChosenHint();
+}
+
+void DestroyHintDisplayScreen(void)
+{
+    if(gUnknown_203B268 != NULL)
+    {
+        gUnknown_203B268->unk3C[gUnknown_203B268->unk34] = gUnknown_80DC0E4;
+        ResetUnusedInputStruct();
+        sub_800641C(gUnknown_203B268->unk3C, 1, 1);
+        MemoryFree(gUnknown_203B268);
+        gUnknown_203B268 = NULL;
+    }
+}
+
+void sub_801E76C(void)
+{
+    gUnknown_203B268->unk9C[0] = gUnknown_203B268->unk20;
+    gUnknown_203B268->unk9C[1] = gUnknown_203B268->helpPageIndex;
+    gUnknown_203B268->unk9C[2] = 0xF;
+    gUnknown_203B268->unk9C[3] = 0;
+    ResetUnusedInputStruct();
+    sub_800641C(gUnknown_203B268->unk3C, 1, 1);
+}
+
+void DisplayChosenHint(void)
+{
+    sub_80073B8(gUnknown_203B268->unk34);
+    xxx_call_draw_string((gUnknown_203B268->helpPageIndex << 3) + 0x10, 0, gGameHints[gUnknown_203B268->helpPageIndex].heading, gUnknown_203B268->unk34, 0);
+    xxx_call_draw_string(0xA, 0x14, gGameHints[gUnknown_203B268->helpPageIndex].body, gUnknown_203B268->unk34, 0);
+    sub_80073E0(gUnknown_203B268->unk34);
+}
diff --git a/src/items.c b/src/items.c
index 0d41510..86174b9 100644
--- a/src/items.c
+++ b/src/items.c
@@ -37,11 +37,11 @@ extern void ExpandPlaceholdersBuffer(u8 *, const u8 *, ...);
 extern s32 sub_8090FEC(s32 a1, u8* a2, u8 a3);
 extern void sub_80073B8(u32);
 extern u32 sub_8097DF0(char *, struct subStruct_203B240 **);
-extern void sub_8092A88(void*, u16);  // first arg is some struct
+extern void InitPokemonMove(void*, u16);  // first arg is some struct
 extern void sub_80078A4(u32, u32, u32, u32, u32);
-extern u32 sub_8092B00(void*);
+extern u32 GetMoveType(void*);
 extern u8* GetUnformattedTypeString(s16);
-extern u32 sub_8092BF4(void*);
+extern u32 GetMoveMaxPP(void*);
 extern void sub_80073E0(u32);
 extern void xxx_format_and_draw(u32, u32, u8 *, u32, u32);
 extern s32 sub_8091E94(s32 a1, s32 a2, s32 a3);
@@ -565,11 +565,11 @@ s32 GetItemPossessionCount(u8 itemIndex)
 void ShiftItemsDownFrom(s32 start)
 {
   s32 i, j;
-  for (i = start, j = start + 1; i < 19; i++, j++) {
+  for (i = start, j = start + 1; i < INVENTORY_SIZE - 1; i++, j++) {
     gTeamInventory_203B460->teamItems[i] = gTeamInventory_203B460->teamItems[j];
   }
-  gTeamInventory_203B460->teamItems[19].itemIndex = 0;
-  gTeamInventory_203B460->teamItems[19].itemFlags = 0;
+  gTeamInventory_203B460->teamItems[INVENTORY_SIZE - 1].itemIndex = 0;
+  gTeamInventory_203B460->teamItems[INVENTORY_SIZE - 1].itemFlags = 0;
 }
 
 void ClearItemSlotAt(u32 index)
@@ -703,13 +703,13 @@ u32 sub_80913E0(struct ItemSlot* slot, u32 a2, struct subStruct_203B240 ** a3)
     u8* typestring;
     u32 result;
 
-    sub_8092A88(buffer8, move);
+    InitPokemonMove(buffer8, move);
     sub_80078A4(a2, 4, 82, 200, 7);
     xxx_format_and_draw(4, 84, gPtrTypeText, a2, 0);
-    moves_data = sub_8092B00(buffer8);
+    moves_data = GetMoveType(buffer8);
     typestring = GetUnformattedTypeString(moves_data);
     xxx_format_and_draw(64, 84, typestring, a2, 0);
-    result = sub_8092BF4(buffer8);
+    result = GetMoveMaxPP(buffer8);
     gUnknown_202DE30 = result;
     xxx_format_and_draw(128, 84, gPtrPPD0Text, a2, 0);
   }
diff --git a/src/kangaskhan_storage_2.c b/src/kangaskhan_storage_2.c
index 007aea6..3c5099d 100644
--- a/src/kangaskhan_storage_2.c
+++ b/src/kangaskhan_storage_2.c
@@ -9,31 +9,6 @@
 
 extern struct unkStruct_203B208 *gUnknown_203B208;
 
-struct unkStruct_203B20C
-{
-    u32 state;
-    u8 unk4[4];
-    struct ItemSlot unk8;
-    u8 fillC[0x14 - 0xC];
-    u32 unk14;
-    u32 unk18;
-    u32 unk1C;
-    struct MenuItem unk20[8];
-    u16 unk60[8];
-    u32 unk70;
-    u8 fill74[0xC0 - 0x74];
-    u32 unkC0;
-    u32 unkC4;
-    u32 unkC8;
-    u32 unkCC;
-    u32 unkD0;
-    u32 unkD4;
-    struct UnkTextStruct2 *unkD8;
-    u32 unkDC;
-    u32 unkE0;
-    u8 fillE4[0xF0 - 0xE4];
-    struct UnkTextStruct2 unkF0[4];
-};
 extern struct unkStruct_203B20C *gUnknown_203B20C;
 
 extern void sub_8017F10(u32);
diff --git a/src/kangaskhan_storage_3.c b/src/kangaskhan_storage_3.c
index e5382c3..f1ce8ce 100644
--- a/src/kangaskhan_storage_3.c
+++ b/src/kangaskhan_storage_3.c
@@ -1,9 +1,349 @@
 #include "global.h"
+#include "kangaskhan_storage.h"
+#include "team_inventory.h"
+
+extern struct unkStruct_203B20C *gUnknown_203B20C;
 
 extern u32 sub_801B410();
 extern void sub_801B450();
 extern void sub_8017F10(u32);
 
+extern u8 sub_801CF14(u32);
+
+struct HeldItem_Alt {
+  union tempHeld
+  {
+      struct HeldItem norm;
+      u32 full_bits;
+  } temp;
+};
+
+extern u8 sub_8012FD8(u32 *r0);
+extern void sub_8013114(u32 *, s32 *);
+extern void sub_801CBB8(void);
+extern void sub_8017F10(u32);
+extern void sub_8012EA4(u32 *, u32);
+
+bool8 IsNotMoneyOrUsedTMItem(u8 id);
+extern u8 sub_801ADA0(s32);
+extern void sub_801A928(void);
+extern void sub_8099690(u32);
+extern u32 sub_801A6E8(u32);
+
+extern u32 sub_8013BBC(u32 *);
+extern u32 sub_801CA08(u32);
+extern void sub_8018280(void);
+
+extern void sub_801CF94(void);
+extern u8 sub_801CB24();
+extern u32 sub_801CFB8(void);
+extern void sub_801AD34(u32);
+extern u32 sub_801CFE0(u8);
+
+extern u32 sub_801A8AC(void);
+extern u32 sub_801AEA8(void);
+extern u32 sub_801AED0(u32);
+extern void sub_801AE84(void);
+extern u8 sub_801CF50(u32);
+
+
+void sub_8018588(void)
+{
+    s32 temp;
+    temp = 0;
+
+    if(sub_8012FD8(&gUnknown_203B20C->unk70) == 0)
+    {
+        sub_8013114(&gUnknown_203B20C->unk70, &temp);
+        if(temp != 1) gUnknown_203B20C->unk14 = temp;
+    }
+
+    switch(temp)
+    {
+        case 2:
+            if((GetNumberOfFilledInventorySlots() != 0) && sub_801CF50(0) == 0)
+                sub_8017F10(4);
+            else
+                sub_8012EA4(&gUnknown_203B20C->unk70, 1);;
+            break;
+        case 3:
+            if(sub_801CF14(1) != 0)
+                sub_8012EA4(&gUnknown_203B20C->unk70, 1);
+            else
+                sub_8017F10(0xA);
+            break;
+        case 1:
+            sub_8017F10(3);
+            break;
+    }
+}
+
+void sub_8018620(void)
+{
+    s32 iVar6;
+    switch(sub_801A6E8(1))
+    {
+        case 3:
+            if(sub_801AEA8() != 0)
+            {
+                for(iVar6 = 0; iVar6 < INVENTORY_SIZE; iVar6++)
+                {
+                    if(sub_801AED0(iVar6) != 0)
+                    {
+                        MoveToStorage(&gTeamInventory_203B460->teamItems[iVar6]);
+                        gTeamInventory_203B460->teamItems[iVar6].itemIndex = 0;
+                        gTeamInventory_203B460->teamItems[iVar6].itemFlags = 0;
+                    }
+                }
+                FillInventoryGaps();
+                sub_801AE84();
+                if(GetNumberOfFilledInventorySlots() == 0)
+                {
+                    sub_801A928();
+                    sub_8017F10(1);
+                }
+                else
+                {
+                    sub_8017F10(5);
+                }
+            }
+            else
+            {
+                gUnknown_203B20C->unkC = sub_801A8AC();
+                gUnknown_203B20C->unk8 = gTeamInventory_203B460->teamItems[gUnknown_203B20C->unkC];
+                sub_8017F10(6);
+            }
+            break;
+        case 4:
+            gUnknown_203B20C->unkC = sub_801A8AC();
+            gUnknown_203B20C->unk8 = gTeamInventory_203B460->teamItems[gUnknown_203B20C->unkC];
+            sub_8017F10(7);
+            break;
+        case 2:
+            sub_801A928();
+            sub_8017F10(1);
+            break;
+    }
+}
+
+void sub_80186F8(void)
+{
+    struct HeldItem_Alt item;
+    u16 cast;
+    s32 iVar6;
+    u8 iVar6_32;
+
+    switch(sub_801CA08(1))
+    {
+        case 3:
+            if(sub_801CFB8() != 0)
+            {
+                for(iVar6 = 0; iVar6 < NUMBER_OF_ITEM_IDS; iVar6++)
+                {
+                    iVar6_32 = iVar6; // dumb cast needed to match
+                    if(sub_801CFE0(iVar6) != 0)
+                    {
+                        item.temp.full_bits = (item.temp.full_bits & 0xffffff00) | iVar6_32;
+                        if(IsThrowableItem(item.temp.norm.itemIndex))
+                            if(gTeamInventory_203B460->teamStorage[item.temp.norm.itemIndex] > 0x63)
+                            {
+                                item.temp.full_bits = (item.temp.full_bits & 0xffff00ff) | (0xC6 << 7);
+                            }
+                            else
+                            {
+                                cast = gTeamInventory_203B460->teamStorage[item.temp.norm.itemIndex] << 8;
+                                item.temp.full_bits = (item.temp.full_bits & 0xffff00ff) | cast;
+                            }
+                        else
+                        {
+                            item.temp.full_bits = (item.temp.full_bits & 0xffff00ff) | (0x80 << 1);
+                        }
+                        gTeamInventory_203B460->teamStorage[item.temp.norm.itemIndex] -= item.temp.norm.numItems;
+                        sub_8091274((struct HeldItem *)&item);
+                    }
+                }
+                FillInventoryGaps();
+                sub_801CF94();
+                if((sub_801CF14(1) == 0) && (GetNumberOfFilledInventorySlots() < INVENTORY_SIZE))
+                    sub_8017F10(0xB);
+                else
+                {
+                    sub_801CBB8();
+                    sub_8017F10(1);
+                }
+            }
+            else
+            {
+                gUnknown_203B20C->itemIndex = sub_801CB24();
+                xxx_init_itemslot_8090A8C(&gUnknown_203B20C->unk8, gUnknown_203B20C->itemIndex, 0);
+                gUnknown_203B20C->unk8.numItems = 1;
+                sub_8017F10(0xD);
+            }
+            break;
+        case 4:
+            gUnknown_203B20C->itemIndex = sub_801CB24();
+            xxx_init_itemslot_8090A8C(&gUnknown_203B20C->unk8, gUnknown_203B20C->itemIndex, 0);
+            gUnknown_203B20C->unk8.numItems = 1;
+            sub_8017F10(0xE);
+            break;
+        case 2:
+            sub_801CBB8();
+            sub_8017F10(1);
+            break;
+        case 1:
+            sub_801AD34(0);
+            break;
+    }
+}
+
+void sub_8018854(void)
+{
+    struct HeldItem_Alt item;
+    u32 itemsCast;
+    u32 indexCast;
+
+    sub_801CA08(0);
+    sub_8012FD8(&gUnknown_203B20C->unk70);
+
+    switch(sub_8013BBC(&gUnknown_203B20C->unkC0))
+    {
+        case 3:
+            gUnknown_203B20C->unk8.numItems = gUnknown_203B20C->unkC0;
+
+            gTeamInventory_203B460->teamStorage[gUnknown_203B20C->unk8.itemIndex] -= gUnknown_203B20C->unk8.numItems;
+
+            indexCast = gUnknown_203B20C->unk8.itemIndex;
+            item.temp.full_bits = (item.temp.full_bits & 0xffffff00) | indexCast;
+
+            itemsCast = (gUnknown_203B20C->unk8.numItems << 8);
+            item.temp.full_bits = (item.temp.full_bits & 0xffff00ff) | itemsCast;
+
+            sub_8091274((struct HeldItem *)&item);
+            if(sub_801CF14(1) == 0)
+                if(GetNumberOfFilledInventorySlots() >= INVENTORY_SIZE)
+                {
+                    error:
+                        sub_801CBB8();
+                        sub_8017F10(0x1);
+                }
+                else
+                    sub_8017F10(0xB);
+            else
+                goto error;
+            break;
+        case 2:
+            sub_8017F10(0xB);
+            break;
+        case 1:
+            sub_8018280();
+            break;
+        case 0:
+            break;
+    }
+}
+
+void sub_8018904(void)
+{
+    s32 temp;
+
+    temp = 0;
+
+    sub_801A6E8(0);
+    if(sub_8012FD8(&gUnknown_203B20C->unk70) == 0)
+    {
+        sub_8013114(&gUnknown_203B20C->unk70, &temp);
+        if(temp != 1) gUnknown_203B20C->unk18 = temp;
+    }
+    switch(temp)
+    {
+        case 2:
+            if(IsNotMoneyOrUsedTMItem(gUnknown_203B20C->unk8.itemIndex))
+                if(sub_801ADA0(gUnknown_203B20C->unkC) == 0)
+            error:
+                    sub_8012EA4(&gUnknown_203B20C->unk70, 1);
+                else
+                {
+                    MoveToStorage(&gUnknown_203B20C->unk8);
+                    ShiftItemsDownFrom(gUnknown_203B20C->unkC);
+                    FillInventoryGaps();
+                    if(GetNumberOfFilledInventorySlots() == 0)
+                    {
+                        sub_801A928();
+                        sub_8017F10(1);
+                    }
+                    else
+                        sub_8017F10(5);
+                }
+            else
+                goto error;
+            break;
+        case 4:
+            sub_8099690(0);
+            sub_8017F10(7);
+            break;
+        case 1:
+            sub_8017F10(5);
+            break;
+    }
+}
+
+void sub_80189C8(void)
+{
+    struct HeldItem_Alt item;
+    s32 temp;
+    u32 itemsCast;
+    u32 indexCast;
+
+    temp = 0;
+
+    sub_801CA08(0);
+    if(sub_8012FD8(&gUnknown_203B20C->unk70) == 0)
+    {
+        sub_8013114(&gUnknown_203B20C->unk70, &temp);
+        if(temp != 1) gUnknown_203B20C->unk1C = temp;
+    }
+    switch(temp)
+    {
+        case 3:
+            if(GetNumberOfFilledInventorySlots() >= INVENTORY_SIZE)
+                sub_8012EA4(&gUnknown_203B20C->unk70, 1);
+            else if(IsThrowableItem(gUnknown_203B20C->unk8.itemIndex))
+                sub_8017F10(0xC);
+            else
+            {
+                gTeamInventory_203B460->teamStorage[gUnknown_203B20C->unk8.itemIndex] -= gUnknown_203B20C->unk8.numItems;
+
+                indexCast = gUnknown_203B20C->unk8.itemIndex;
+                item.temp.full_bits = (item.temp.full_bits & 0xffffff00) | indexCast;
+
+                itemsCast = (gUnknown_203B20C->unk8.numItems << 8);
+                item.temp.full_bits = (item.temp.full_bits & 0xffff00ff) | itemsCast;
+
+                sub_8091274((struct HeldItem *)&item);
+                if(sub_801CF14(1) == 0)
+                    if(GetNumberOfFilledInventorySlots() >= INVENTORY_SIZE)
+                    {
+                        error:
+                            sub_801CBB8();
+                            sub_8017F10(1);
+                    }
+                    else
+                    {
+                        sub_8017F10(0xB);
+                    }
+                else
+                    goto error;
+            }
+            break;
+        case 4:
+            sub_8017F10(0xE);
+            break;
+        case 1:
+            sub_8017F10(0xB);
+            break;
+    }
+}
+
 void sub_8018AC8(void)
 {
     switch(sub_801B410())
diff --git a/src/kecleon_items_1.c b/src/kecleon_items_1.c
index 610fd4f..89cd19f 100644
--- a/src/kecleon_items_1.c
+++ b/src/kecleon_items_1.c
@@ -62,7 +62,6 @@ extern u8 sub_8019FB0(void);
 extern u8 sub_80138B8(void *, u32);
 
 extern void PlayMenuSoundEffect(u32);
-extern s32 GetStackBuyPrice(struct ItemSlot *);
 extern s32 GetKeyPress(void *);
 extern void sub_8013660(void *);
 
@@ -228,7 +227,7 @@ void sub_8019DAC(void)
 
   gUnknown_203B210->unk14 = 0;
   gUnknown_203B210->unk18 = 0;
-  for(iVar5 = 0; iVar5 < 0x14; iVar5++){
+  for(iVar5 = 0; iVar5 < INVENTORY_SIZE; iVar5++){
     pbVar4 = &gTeamInventory_203B460->teamItems[iVar5];
     if (((pbVar4->itemFlags & ITEM_FLAG_EXISTS) != 0) && (CanSellItem(pbVar4->itemIndex))) {
       iVar3 = GetStackSellPrice(pbVar4);
diff --git a/src/moves.c b/src/moves.c
new file mode 100644
index 0000000..0f59f0b
--- /dev/null
+++ b/src/moves.c
@@ -0,0 +1,336 @@
+#include "global.h"
+#include "file_system.h"
+#include "constants/move.h"
+#include "constants/move_id.h"
+
+struct MoveDataFile
+{
+    struct MoveData *moveData;
+    u8 *unk4; // unsure of this struct's structure yet
+};
+
+struct unkStruct_80928C0
+{
+    u32 unk0;
+    u32 unk4;
+    u8 unk8;
+    u8 unk9;
+};
+
+extern struct unkStruct_80928C0 gUnknown_81098C4;
+extern struct FileArchive gSystemFileArchive;
+extern struct OpenedFile *gWazaParametersFile;
+extern struct MoveData *gMovesData;
+extern u8 *gMovesRelated_2038C6C;
+
+extern u8 gUnknown_81098D0[];
+extern u8 gUnknown_81098DC[];
+extern u8 gUnknown_810990C[];
+extern u8 gUnknown_8109908[];
+extern u8 gUnknown_8109928[];
+extern u8 gUnknown_8109910[];
+extern u8 gUnknown_81098E0[];
+extern u8 gUnknown_81098EC[];
+extern u8 *gRangeNames[];
+extern u8 gUnknown_810992C[];
+
+extern void sub_8093F10(struct PokemonMove *, struct PokemonMove *);
+extern void sub_80928C0(u8 *, struct PokemonMove *, struct unkStruct_80928C0 *);
+extern u32 GetMoveMaxPP(struct PokemonMove*);
+bool8 DoesMoveCharge(u16 move);
+extern void ExpandPlaceholdersBuffer(u8 *, u8 *, ...);
+
+void LoadWazaParameters(void)
+{
+    gWazaParametersFile = OpenFileAndGetFileDataPtr(gUnknown_81098D0, &gSystemFileArchive);
+
+    gMovesData = ((struct MoveDataFile *)(gWazaParametersFile->data))->moveData;
+    gMovesRelated_2038C6C = ((struct MoveDataFile *)(gWazaParametersFile->data))->unk4;
+}
+
+u8 sub_809287C(struct PokemonMove *move)
+{
+    if((move->moveFlags & MOVE_FLAG_DISABLED) != 0)
+        return 0x32;
+    else if((move->sealed & 1) == 0)
+        return 0x34;
+    else
+        return 0x32;
+}
+
+void sub_80928A0(u8 *buffer, struct PokemonMove *move, struct unkStruct_80928C0 *r2)
+{
+    struct PokemonMove stack;
+    sub_8093F10(&stack, move);
+    sub_80928C0(buffer, &stack, r2);
+}
+
+void sub_80928C0(u8 *buffer, struct PokemonMove *move, struct unkStruct_80928C0 *param_3)
+{
+  u32 uVar2;
+  u32 maxPP;
+  u8 localBuffer[12];
+
+  uVar2 = sub_809287C(move);
+  if (param_3 == NULL) {
+    param_3 = &gUnknown_81098C4;
+  }
+
+  if (move->powerBoost != 0)
+      ExpandPlaceholdersBuffer(localBuffer,gUnknown_81098DC,move->powerBoost); // %+d
+  else
+      localBuffer[0] = '\0';
+
+  if (param_3->unk8 != 0) {
+        uVar2 = 2;
+  }
+  if (param_3->unk9 != 0 && DoesMoveCharge(move->moveID)) {
+        uVar2 = 2;
+  }
+  switch(param_3->unk0) {
+        case 0:
+            ExpandPlaceholdersBuffer
+                    (buffer,gUnknown_81098E0,uVar2,
+                    gMovesData[move->moveID].namePointer,localBuffer);
+            break;
+
+        case 1:
+            maxPP = GetMoveMaxPP(move);
+            ExpandPlaceholdersBuffer
+                    (buffer,gUnknown_81098EC,uVar2,move->moveFlags & MOVE_FLAG_SET ? gUnknown_8109908 : gUnknown_810990C,
+                    gMovesData[move->moveID].namePointer,localBuffer,param_3->unk4,
+                    move->pp,maxPP);
+            break;
+
+        case 2:
+            maxPP = GetMoveMaxPP(move);
+            ExpandPlaceholdersBuffer
+                    (buffer,gUnknown_8109910,uVar2,move->moveFlags & MOVE_FLAG_SET ? gUnknown_8109908 : gUnknown_810990C,
+                    gMovesData[move->moveID].namePointer,localBuffer,param_3->unk4,
+                    move->pp,maxPP);
+            break;
+
+        case 3:
+            maxPP = GetMoveMaxPP(move);
+            ExpandPlaceholdersBuffer
+                    (buffer,gUnknown_81098EC,uVar2,move->moveFlags & MOVE_FLAG_ENABLED ? gUnknown_8109928 : gUnknown_810990C,
+                    gMovesData[move->moveID].namePointer,localBuffer,param_3->unk4,
+                    move->pp,maxPP);
+            break;
+
+        case 4:
+            maxPP = GetMoveMaxPP(move);
+            ExpandPlaceholdersBuffer
+                    (buffer,gUnknown_8109910,uVar2, move->moveFlags & MOVE_FLAG_ENABLED ? gUnknown_8109928 : gUnknown_810990C,
+                    gMovesData[move->moveID].namePointer,localBuffer,param_3->unk4,
+                    move->pp,maxPP);
+            break;
+        }
+}
+
+void InitPokemonMove(struct PokemonMove *move, u16 moveID)
+{
+    move->moveFlags = MOVE_FLAG_ENABLED | MOVE_FLAG_EXISTS;
+    move->sealed = FALSE;
+    move->moveID = moveID;
+    move->pp = GetMoveMaxPP(move);
+    move->powerBoost = 0;
+}
+
+void sub_8092AA8(struct PokemonMove *move, u16 moveID)
+{
+    if(moveID == 0)
+        move->moveFlags = 0;
+    else
+    {
+        move->moveFlags = MOVE_FLAG_ENABLED | MOVE_FLAG_EXISTS;
+        move->sealed = FALSE;
+        move->moveID = moveID;
+        move->pp = GetMoveMaxPP(move);
+        move->powerBoost = 0;
+    }
+}
+
+void InitZeroedPPPokemonMove(struct PokemonMove *move, u16 moveID)
+{
+    move->moveFlags = MOVE_FLAG_ENABLED | MOVE_FLAG_EXISTS;
+    move->moveID = moveID;
+    move->pp = 0;
+}
+
+s16 GetMoveTargetingFlags(struct PokemonMove *move, u32 r1)
+{
+    return gMovesData[move->moveID].targetingFlags[r1];
+}
+
+u8 GetMoveType(struct PokemonMove *move)
+{
+    return gMovesData[move->moveID].type;
+}
+
+NAKED
+void sub_8092B18(s16 species)
+{
+	asm_unified("\tpush {lr}\n"
+	"\tlsls r0, 16\n"
+	"\tasrs r1, r0, 16\n"
+	"\tadds r2, r1, 0\n"
+	"\tldr r0, _08092B40\n"
+	"\tcmp r1, r0\n"
+	"\tbeq _08092B48\n"
+	"\tcmp r1, 0\n"
+	"\tbeq _08092B48\n"
+	"\tmovs r0, 0xD2\n"
+	"\tlsls r0, 1\n"
+	"\tcmp r2, r0\n"
+	"\tbeq _08092B48\n"
+	"\tldr r0, _08092B44\n"
+	"\tldr r1, [r0]\n"
+	"\tlsls r0, r2, 3\n"
+	"\tadds r0, r1\n"
+	"\tldr r0, [r0]\n"
+	"\tb _08092B4A\n"
+	"\t.align 2, 0\n"
+"_08092B40: .4byte 0x000001a5\n"
+"_08092B44: .4byte gMovesRelated_2038C6C\n"
+"_08092B48:\n"
+	"\tldr r0, _08092B50\n"
+"_08092B4A:\n"
+	"\tpop {r1}\n"
+	"\tbx r1\n"
+	"\t.align 2, 0\n"
+"_08092B50: .4byte gUnknown_810992B");
+}
+
+NAKED
+void sub_8092B54(s16 species)
+{
+	asm_unified("\tpush {lr}\n"
+	"\tlsls r0, 16\n"
+	"\tasrs r1, r0, 16\n"
+	"\tadds r2, r1, 0\n"
+	"\tldr r0, _08092B7C\n"
+	"\tcmp r1, r0\n"
+	"\tbeq _08092B84\n"
+	"\tcmp r1, 0\n"
+	"\tbeq _08092B84\n"
+	"\tmovs r0, 0xD2\n"
+	"\tlsls r0, 1\n"
+	"\tcmp r2, r0\n"
+	"\tbeq _08092B84\n"
+	"\tldr r0, _08092B80\n"
+	"\tldr r1, [r0]\n"
+	"\tlsls r0, r2, 3\n"
+	"\tadds r0, r1\n"
+	"\tldr r0, [r0, 0x4]\n"
+	"\tb _08092B86\n"
+	"\t.align 2, 0\n"
+"_08092B7C: .4byte 0x000001a5\n"
+"_08092B80: .4byte gMovesRelated_2038C6C\n"
+"_08092B84:\n"
+	"\tldr r0, _08092B8C\n"
+"_08092B86:\n"
+	"\tpop {r1}\n"
+	"\tbx r1\n"
+	"\t.align 2, 0\n"
+"_08092B8C: .4byte gUnknown_810992B");
+}
+
+u8 GetMoveWeight(struct PokemonMove *move)
+{
+    return gMovesData[move->moveID].weight;
+}
+
+u8 GetMoveHitCount(struct PokemonMove *move)
+{
+    return gMovesData[move->moveID].hitCount;
+}
+
+s16 GetMovePower(struct PokemonMove *move)
+{
+    return gMovesData[move->moveID].power;
+}
+
+u8 GetMoveAccuracy(struct PokemonMove *move, u32 r1)
+{
+    return gMovesData[move->moveID].accuracy[r1];
+}
+
+u32 GetMoveMaxPP(struct PokemonMove *move)
+{
+    return gMovesData[move->moveID].maxPP;
+}
+
+u8 GetMoveUnk12(struct PokemonMove *move)
+{
+    return gMovesData[move->moveID].unk12;
+}
+
+u8 GetMoveCriticalHitChance(struct PokemonMove *move)
+{
+    return gMovesData[move->moveID].criticalHitChance;
+}
+
+u8 GetMoveCannotHitFrozen(struct PokemonMove *move)
+{
+    return gMovesData[move->moveID].cannotHitFrozen;
+}
+
+u8 GetMoveDealsDirectDamage(struct PokemonMove *move)
+{
+    return gMovesData[move->moveID].dealsDirectDamage;
+}
+
+u32 GetMoveRangeType(struct PokemonMove *move)
+{
+    return gMovesData[move->moveID].rangeType;
+}
+
+void sub_8092C84(u8 *buffer, u16 moveID)
+{
+    struct PokemonMove stack;
+    InitPokemonMove(&stack, moveID);
+    sub_80928C0(buffer, &stack, NULL);
+}
+
+u8 *GetMoveUseText(u16 moveID)
+{
+    return gMovesData[moveID].useText;
+}
+
+u8 GetMoveAffectedByMagicCoat(u16 moveID)
+{
+    return gMovesData[moveID].affectedByMagicCoat;
+}
+
+u8 GetMoveTargetsUser(u16 moveID)
+{
+    return gMovesData[moveID].targetsUser;
+}
+
+u8 GetMoveAffectedByMuzzled(u16 moveID)
+{
+    return gMovesData[moveID].affectedByMuzzled;
+}
+
+bool8 IsBlockedBySoundproof(struct PokemonMove *move)
+{
+    if(move->moveID == MOVE_GROWL)  return TRUE;
+    if(move->moveID == MOVE_ROAR)  return TRUE;
+    if(move->moveID == MOVE_METAL_SOUND)  return TRUE;
+    if(move->moveID == MOVE_SING)  return TRUE;
+    if(move->moveID == MOVE_GRASSWHISTLE)  return TRUE;
+    if(move->moveID == MOVE_SUPERSONIC)  return TRUE;
+    if(move->moveID == MOVE_PERISH_SONG)  return TRUE;
+    if(move->moveID == MOVE_SCREECH)  return TRUE;
+    if(move->moveID == MOVE_HYPER_VOICE)  return TRUE;
+    if(move->moveID == MOVE_SNORE)  return TRUE;
+    if(move->moveID == MOVE_HEAL_BELL)  return TRUE;
+
+    return FALSE;
+}
+
+void sub_8092D54(u8 *buffer, struct PokemonMove *move)
+{
+    ExpandPlaceholdersBuffer(buffer, gUnknown_810992C, gRangeNames[GetMoveRangeType(move)]);
+}
diff --git a/src/moves_1.c b/src/moves_1.c
new file mode 100644
index 0000000..db84d41
--- /dev/null
+++ b/src/moves_1.c
@@ -0,0 +1,100 @@
+#include "global.h"
+#include "code_8092334.h"
+#include "pokemon.h"
+#include "constants/move_id.h"
+
+void SavePokemonMove(struct unkStruct_8094924 *r0, struct PokemonMove *move)
+{
+    SaveIntegerBits(r0, &move->moveFlags, 4);
+    SaveIntegerBits(r0, &move->moveID, 9);
+    SaveIntegerBits(r0, &move->pp, 7);
+}
+
+void RestorePokemonMove(struct unkStruct_8094924 *r0, struct PokemonMove *move)
+{
+    RestoreIntegerBits(r0, &move->moveFlags, 4);
+    RestoreIntegerBits(r0, &move->moveID, 9);
+    RestoreIntegerBits(r0, &move->pp, 7);
+}
+
+void SavePokemonMoves(struct unkStruct_8094924 *r0, struct PokemonMove *moveSet)
+{
+    s32 iVar4;
+    for(iVar4 = 0; iVar4 < MAX_MON_MOVES; iVar4++)
+    {
+        SavePokemonMove(r0, &moveSet[iVar4]);
+    }
+}
+
+void RestorePokemonMoves(struct unkStruct_8094924 *r0, struct PokemonMove *moveSet)
+{
+    s32 iVar4;
+    for(iVar4 = 0; iVar4 < MAX_MON_MOVES; iVar4++)
+    {
+        RestorePokemonMove(r0, &moveSet[iVar4]);
+    }
+}
+
+void sub_8094148(struct unkStruct_8094924 *r0, struct PokemonMove *move)
+{
+    SaveIntegerBits(r0, &move->moveFlags, 4);
+    SaveIntegerBits(r0, &move->sealed, 1);
+    SaveIntegerBits(r0, &move->moveID, 9);
+    SaveIntegerBits(r0, &move->pp, 7);
+    SaveIntegerBits(r0, &move->powerBoost, 7);
+}
+
+void sub_8094184(struct unkStruct_8094924 *r0, struct unkStruct_8094184 *r1)
+{
+    s32 r4;
+
+    for(r4 = 0; r4 < MAX_MON_MOVES; r4++)
+    {
+        sub_8094148(r0, &r1->moves[r4]);
+    }
+    SaveIntegerBits(r0, &r1->unk20, 8);
+}
+
+void sub_80941B0(struct unkStruct_8094924 *r0, struct PokemonMove *move)
+{
+    memset(move, 0, sizeof(struct PokemonMove));
+    RestoreIntegerBits(r0, &move->moveFlags, 4);
+    RestoreIntegerBits(r0, &move->sealed, 1);
+    RestoreIntegerBits(r0, &move->moveID, 9);
+    RestoreIntegerBits(r0, &move->pp, 7);
+    RestoreIntegerBits(r0, &move->powerBoost, 7);
+}
+
+void sub_80941FC(struct unkStruct_8094924 *r0, struct unkStruct_8094184 *r1)
+{
+    s32 iVar4;
+    for(iVar4 = 0; iVar4 < MAX_MON_MOVES; iVar4++)
+    {
+        sub_80941B0(r0, &r1->moves[iVar4]);
+    }
+    r1->unk20 = 0;
+    RestoreIntegerBits(r0, &r1->unk20, 8);
+}
+
+bool8 DoesMoveCharge(u16 move)
+{
+    if(move == MOVE_SOLARBEAM)
+        return TRUE;
+    if(move == MOVE_SKY_ATTACK)
+        return TRUE;
+    if(move == MOVE_RAZOR_WIND)
+        return TRUE;
+    if(move == MOVE_FOCUS_PUNCH)
+        return TRUE;
+    if(move == MOVE_SKULL_BASH)
+        return TRUE;
+    if(move == MOVE_FLY)
+        return TRUE;
+    if(move == MOVE_BOUNCE)
+        return TRUE;
+    if(move == MOVE_DIVE)
+        return TRUE;
+    if(move == MOVE_DIG)
+        return TRUE;
+    return FALSE;
+}
diff --git a/src/pokemon_mid.c b/src/pokemon_mid.c
index 6429755..94387b2 100644
--- a/src/pokemon_mid.c
+++ b/src/pokemon_mid.c
@@ -38,7 +38,7 @@ extern void xxx_pokemon2_to_pokemonstruct_808DF44(struct PokemonStruct*, struct
 extern u8* sub_8092B18(s16);
 extern u8* sub_808E07C(u8* a1, u16* a2);
 extern u8* sub_8092B54(s32);
-extern void sub_8092AD4(struct PokemonMove*, u16);
+extern void InitZeroedPPPokemonMove(struct PokemonMove*, u16);
 extern u32 sub_8097DF0(char *, struct subStruct_203B240 **);
 
 struct unkStruct_8107654 {
@@ -570,7 +570,7 @@ void xxx_pokemon2_to_pokemonstruct_index_808DF2C(s32 a1, struct PokemonStruct2*
     xxx_pokemon2_to_pokemonstruct_808DF44(&a1[gRecruitedPokemonRef->pokemon], a2);
 }
 
-extern void sub_8093FA8(struct PokemonMove*, struct PokemonMove*);
+extern void sub_8093FA8(struct PokemonMove*, struct unkStruct_8094184*);
 
 
 void xxx_pokemon2_to_pokemonstruct_808DF44(struct PokemonStruct* pokemon, struct PokemonStruct2* a2)
@@ -593,7 +593,7 @@ void xxx_pokemon2_to_pokemonstruct_808DF44(struct PokemonStruct* pokemon, struct
     }
 
     pokemon->unk1C = a2->unk18;
-    sub_8093FA8(pokemon->moves, a2->moves);
+    sub_8093FA8(pokemon->moves, &a2->moves);
 
     for (i = 0; i < POKEMON_NAME_LENGTH; i++) {
         pokemon->name[i] = a2->name[i];
@@ -910,7 +910,7 @@ void sub_808E490(struct PokemonMove* a1, s16 species)
     i = 0;
     if (i < count) {
         while (i < count) {
-            sub_8092AD4(&a1[i], buffer[i]);
+            InitZeroedPPPokemonMove(&a1[i], buffer[i]);
             i++;
         }
         i = count;