Merge pull request #1 from pret/master

Update fork to match main fork.

1 files changed, 697 insertions, 213 deletions

diff --git a/src/wallclock.c b/src/wallclock.c
index e3b79efea..8db13dc2d 100644
--- a/src/wallclock.c
+++ b/src/wallclock.c
@@ -1,32 +1,152 @@
 #include "global.h"
 #include "wallclock.h"
-#include "asm.h"
 #include "decompress.h"
 #include "main.h"
 #include "menu.h"
 #include "palette.h"
 #include "rtc.h"
 #include "songs.h"
+#include "sound.h"
+#include "strings2.h"
 #include "task.h"
 #include "trig.h"
-#include "sound.h"
+#include "unknown_task.h"
 
 extern u16 gSpecialVar_0x8004;
-extern u16 gMiscClockMale_Pal[];
-extern u16 gMiscClockFemale_Pal[];
 extern u8 gMiscClock_Gfx[];
-extern struct SpriteSheet gUnknown_083F7A90;
-extern struct SpritePalette gUnknown_083F7AA0;
 extern u8 gUnknown_08E95774[];
 extern u8 gUnknown_08E954B0[];
-extern u8 gOtherText_CorrectTimePrompt[];
-extern const struct MenuAction gUnknown_08376D74[];
-extern s8 gClockHandCoords[][2];
+extern u16 gMiscClockMale_Pal[];
+extern u16 gMiscClockFemale_Pal[];
+
+//--------------------------------------------------
+// Graphics Data
+//--------------------------------------------------
 
-extern struct SpriteTemplate gSpriteTemplate_83F7AD8;
-extern struct SpriteTemplate gSpriteTemplate_83F7AF0;
-extern struct SpriteTemplate gSpriteTemplate_83F7B28;
-extern struct SpriteTemplate gSpriteTemplate_83F7B40;
+static const u8 ClockGfx_Misc[] = INCBIN_U8("graphics/misc/clock_misc.4bpp.lz");
+static const struct CompressedSpriteSheet gUnknown_083F7A90[] =
+{
+    {ClockGfx_Misc, 0x2000, 0x1000},
+    {NULL},
+};
+static const struct SpritePalette gUnknown_083F7AA0[] =
+{
+    {gMiscClockMale_Pal, 0x1000},
+    {gMiscClockFemale_Pal, 0x1001},
+    {NULL},
+};
+static const struct OamData gOamData_83F7AB8 =
+{
+    .y = 160,
+    .affineMode = 0,
+    .objMode = 0,
+    .mosaic = 0,
+    .bpp = 0,
+    .shape = 0,
+    .x = 0,
+    .matrixNum = 0,
+    .size = 3,
+    .tileNum = 0,
+    .priority = 1,
+    .paletteNum = 0,
+    .affineParam = 0,
+};
+static const union AnimCmd gSpriteAnim_83F7AC0[] =
+{
+    ANIMCMD_FRAME(0, 30),
+    ANIMCMD_END,
+};
+static const union AnimCmd gSpriteAnim_83F7AC8[] =
+{
+    ANIMCMD_FRAME(64, 30),
+    ANIMCMD_END,
+};
+static const union AnimCmd *const gSpriteAnimTable_83F7AD0[] =
+{
+    gSpriteAnim_83F7AC0,
+};
+static const union AnimCmd *const gSpriteAnimTable_83F7AD4[] =
+{
+    gSpriteAnim_83F7AC8,
+};
+static void sub_810B05C(struct Sprite *sprite);
+static const struct SpriteTemplate gSpriteTemplate_83F7AD8 =
+{
+    .tileTag = 0x1000,
+    .paletteTag = 0x1000,
+    .oam = &gOamData_83F7AB8,
+    .anims = gSpriteAnimTable_83F7AD0,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = sub_810B05C,
+};
+static void sub_810B0F4(struct Sprite *sprite);
+static const struct SpriteTemplate gSpriteTemplate_83F7AF0 =
+{
+    .tileTag = 0x1000,
+    .paletteTag = 0x1000,
+    .oam = &gOamData_83F7AB8,
+    .anims = gSpriteAnimTable_83F7AD4,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = sub_810B0F4,
+};
+static const struct OamData gOamData_83F7B08 =
+{
+    .y = 160,
+    .affineMode = 0,
+    .objMode = 0,
+    .mosaic = 0,
+    .bpp = 0,
+    .shape = 0,
+    .x = 0,
+    .matrixNum = 0,
+    .size = 1,
+    .tileNum = 0,
+    .priority = 2,
+    .paletteNum = 0,
+    .affineParam = 0,
+};
+static const union AnimCmd gSpriteAnim_83F7B10[] =
+{
+    ANIMCMD_FRAME(132, 30),
+    ANIMCMD_END,
+};
+static const union AnimCmd gSpriteAnim_83F7B18[] =
+{
+    ANIMCMD_FRAME(128, 30),
+    ANIMCMD_END,
+};
+static const union AnimCmd *const gSpriteAnimTable_83F7B20[] =
+{
+    gSpriteAnim_83F7B10,
+};
+static const union AnimCmd *const gSpriteAnimTable_83F7B24[] =
+{
+    gSpriteAnim_83F7B18,
+};
+static void sub_810B18C(struct Sprite *sprite);
+static const struct SpriteTemplate gSpriteTemplate_83F7B28 =
+{
+    .tileTag = 0x1000,
+    .paletteTag = 0x1000,
+    .oam = &gOamData_83F7B08,
+    .anims = gSpriteAnimTable_83F7B20,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = sub_810B18C,
+};
+static void sub_810B230(struct Sprite *sprite);
+static const struct SpriteTemplate gSpriteTemplate_83F7B40 =
+{
+    .tileTag = 0x1000,
+    .paletteTag = 0x1000,
+    .oam = &gOamData_83F7B08,
+    .anims = gSpriteAnimTable_83F7B24,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = sub_810B230,
+};
 
 static void WallClockVblankCallback(void);
 static void LoadWallClockGraphics(void);
@@ -48,25 +168,17 @@ static u8 AdvanceClock(u8 taskId, u8 direction);
 static void UpdateClockPeriod(u8 taskId, u8 direction);
 static void InitClockWithRtc(u8 taskId);
 
-//Task data
-enum {
-    TD_MHAND_ANGLE,
-    TD_HHAND_ANGLE,
-    TD_HOURS,
-    TD_MINUTES,
-    TD_SETDIRECTION,    //Movement direction when setting the clock
-    TD_PERIOD,          //Whether the time is AM or PM
-    TD_SETSPEED,        //Movement speed when setting the clock
-};
-
-enum {
-    AM,
-    PM
+enum
+{
+    PERIOD_AM,
+    PERIOD_PM,
 };
 
-enum {
-    BACKWARD = 1,
-    FORWARD
+enum
+{
+    MVMT_NONE,
+    MVMT_BACKWARD,
+    MVMT_FORWARD,
 };
 
 static void WallClockVblankCallback(void)
@@ -80,7 +192,7 @@ static void LoadWallClockGraphics(void)
 {
     u8 *addr;
     u32 size;
-    
+
     SetVBlankCallback(0);
     REG_DISPCNT = 0;
     REG_BG3CNT = 0;
@@ -95,15 +207,15 @@ static void LoadWallClockGraphics(void)
     REG_BG1VOFS = 0;
     REG_BG0HOFS = 0;
     REG_BG0VOFS = 0;
-    
+
     addr = (void *)VRAM;
     size = 0x18000;
-    while(1)
+    while (1)
     {
         DmaFill16(3, 0, addr, 0x1000);
         addr += 0x1000;
         size -= 0x1000;
-        if(size <= 0x1000)
+        if (size <= 0x1000)
         {
             DmaFill16(3, 0, addr, size);
             break;
@@ -111,9 +223,9 @@ static void LoadWallClockGraphics(void)
     }
     DmaClear32(3, OAM, OAM_SIZE);
     DmaClear16(3, PLTT, PLTT_SIZE);
-    
+
     LZ77UnCompVram(gMiscClock_Gfx, (void *)VRAM);
-    if(gSpecialVar_0x8004 == MALE)
+    if (gSpecialVar_0x8004 == MALE)
         LoadPalette(gMiscClockMale_Pal, 0, 32);
     else
         LoadPalette(gMiscClockFemale_Pal, 0, 32);
@@ -122,8 +234,8 @@ static void LoadWallClockGraphics(void)
     ResetSpriteData();
     ResetPaletteFade();
     FreeAllSpritePalettes();
-    LoadCompressedObjectPic(&gUnknown_083F7A90);
-    LoadSpritePalettes(&gUnknown_083F7AA0);
+    LoadCompressedObjectPic(&gUnknown_083F7A90[0]);
+    LoadSpritePalettes(gUnknown_083F7AA0);
     SetUpWindowConfig(&gWindowConfig_81E6C3C);
     InitMenuWindow(&gWindowConfig_81E6CE4);
 }
@@ -131,7 +243,7 @@ static void LoadWallClockGraphics(void)
 static void WallClockInit(void)
 {
     u16 ime;
-    
+
     BeginNormalPaletteFade(-1, 0, 0x10, 0, 0);
     ime = REG_IME;
     REG_IME = 0;
@@ -143,65 +255,73 @@ static void WallClockInit(void)
     REG_BLDCNT = 0;
     REG_BLDALPHA = 0;
     REG_BLDY = 0;
-    REG_BG3CNT = 0x701;
-    REG_BG0CNT = 0x1F08;
+    REG_BG3CNT = BGCNT_PRIORITY(1) | BGCNT_CHARBASE(0) | BGCNT_SCREENBASE(7)  | BGCNT_16COLOR | BGCNT_TXT256x256;
+    REG_BG0CNT = BGCNT_PRIORITY(0) | BGCNT_CHARBASE(2) | BGCNT_SCREENBASE(31) | BGCNT_16COLOR | BGCNT_TXT256x256;
     REG_DISPCNT = DISPCNT_MODE_0 | DISPCNT_OBJ_1D_MAP | DISPCNT_BG0_ON |
       DISPCNT_BG3_ON | DISPCNT_OBJ_ON;
 }
 
+#define tMinuteHandAngle data[0]
+#define tHourHandAngle data[1]
+#define tHours data[2]
+#define tMinutes data[3]
+#define tMvmtDir data[4]
+#define tPeriod data[5]
+#define tMvmtSpeed data[6]
+
 //Allow player to set the clock
-void Cb2_StartWallClock(void)
+void CB2_StartWallClock(void)
 {
     u8 taskId;
     u8 spriteId;
-    
+
     LoadWallClockGraphics();
     LZ77UnCompVram(&gUnknown_08E954B0, (void *)(VRAM + 0x3800));
-    
+
     taskId = CreateTask(Task_SetClock1, 0);
-    gTasks[taskId].data[TD_HOURS] = 10;
-    gTasks[taskId].data[TD_MINUTES] = 0;
-    gTasks[taskId].data[TD_SETDIRECTION] = 0;
-    gTasks[taskId].data[TD_PERIOD] = AM;
-    gTasks[taskId].data[TD_SETSPEED] = 0;
-    gTasks[taskId].data[TD_MHAND_ANGLE] = 0;
-    gTasks[taskId].data[TD_HHAND_ANGLE] = 300;
-    
-    spriteId = CreateSprite(&gSpriteTemplate_83F7AD8, 0x78, 0x50, 1);
+    gTasks[taskId].tHours = 10;
+    gTasks[taskId].tMinutes = 0;
+    gTasks[taskId].tMvmtDir = MVMT_NONE;
+    gTasks[taskId].tPeriod = PERIOD_AM;
+    gTasks[taskId].tMvmtSpeed = 0;
+    gTasks[taskId].tMinuteHandAngle = 0;
+    gTasks[taskId].tHourHandAngle = 300;
+
+    spriteId = CreateSprite(&gSpriteTemplate_83F7AD8, DISPLAY_WIDTH / 2, DISPLAY_HEIGHT / 2, 1);
     gSprites[spriteId].data0 = taskId;
     gSprites[spriteId].oam.affineMode = ST_OAM_AFFINE_NORMAL;
     gSprites[spriteId].oam.matrixNum = 0;
-    
-    spriteId = CreateSprite(&gSpriteTemplate_83F7AF0, 0x78, 0x50, 0);
+
+    spriteId = CreateSprite(&gSpriteTemplate_83F7AF0, DISPLAY_WIDTH / 2, DISPLAY_HEIGHT / 2, 0);
     gSprites[spriteId].data0 = taskId;
     gSprites[spriteId].oam.affineMode = ST_OAM_AFFINE_NORMAL;
     gSprites[spriteId].oam.matrixNum = 1;
-    
-    spriteId = CreateSprite(&gSpriteTemplate_83F7B28, 0x78, 0x50, 2);
+
+    spriteId = CreateSprite(&gSpriteTemplate_83F7B28, DISPLAY_WIDTH / 2, DISPLAY_HEIGHT / 2, 2);
     gSprites[spriteId].data0 = taskId;
     gSprites[spriteId].data1 = 45;
-    
-    spriteId = CreateSprite(&gSpriteTemplate_83F7B40, 0x78, 0x50, 2);
+
+    spriteId = CreateSprite(&gSpriteTemplate_83F7B40, DISPLAY_WIDTH / 2, DISPLAY_HEIGHT / 2, 2);
     gSprites[spriteId].data0 = taskId;
     gSprites[spriteId].data1 = 90;
-    
+
     WallClockInit();
 }
 
 //View, but don't set, the clock
-void Cb2_ViewWallClock(void)
+void CB2_ViewWallClock(void)
 {
     u8 taskId;
     s16 angle1;
     s16 angle2;
     u8 spriteId;
-    
+
     LoadWallClockGraphics();
     LZ77UnCompVram(gUnknown_08E95774, (void *)(VRAM + 0x3800));
-    
+
     taskId = CreateTask(Task_ViewClock1, 0);
     InitClockWithRtc(taskId);
-    if(gTasks[taskId].data[TD_PERIOD] == 0)
+    if (gTasks[taskId].tPeriod == PERIOD_AM)
     {
         angle1 = 45;
         angle2 = 90;
@@ -211,25 +331,25 @@ void Cb2_ViewWallClock(void)
         angle1 = 90;
         angle2 = 135;
     }
-    
+
     spriteId = CreateSprite(&gSpriteTemplate_83F7AD8, 120, 80, 1);
     gSprites[spriteId].data0 = taskId;
     gSprites[spriteId].oam.affineMode = ST_OAM_AFFINE_NORMAL;
     gSprites[spriteId].oam.matrixNum = 0;
-    
+
     spriteId = CreateSprite(&gSpriteTemplate_83F7AF0, 120, 80, 0);
     gSprites[spriteId].data0 = taskId;
     gSprites[spriteId].oam.affineMode = ST_OAM_AFFINE_NORMAL;
     gSprites[spriteId].oam.matrixNum = 1;
-    
+
     spriteId = CreateSprite(&gSpriteTemplate_83F7B28, 120, 80, 2);
     gSprites[spriteId].data0 = taskId;
     gSprites[spriteId].data1 = angle1;
-    
+
     spriteId = CreateSprite(&gSpriteTemplate_83F7B40, 120, 80, 2);
     gSprites[spriteId].data0 = taskId;
     gSprites[spriteId].data1 = angle2;
-    
+
     WallClockInit();
 }
 
@@ -243,49 +363,49 @@ static void WallClockMainCallback(void)
 
 static void Task_SetClock1(u8 taskId)
 {
-    if(!gPaletteFade.active)
+    if (!gPaletteFade.active)
         gTasks[taskId].func = Task_SetClock2;
 }
 
 //Handle keypresses when setting clock
 static void Task_SetClock2(u8 taskId)
 {
-    if(gTasks[taskId].data[TD_MHAND_ANGLE] % 6)
+    if (gTasks[taskId].tMinuteHandAngle % 6)
     {
-        gTasks[taskId].data[TD_MHAND_ANGLE] = CalcNewMinHandAngle(
-          gTasks[taskId].data[TD_MHAND_ANGLE],
-          gTasks[taskId].data[TD_SETDIRECTION],
-          gTasks[taskId].data[TD_SETSPEED]);
+        gTasks[taskId].tMinuteHandAngle = CalcNewMinHandAngle(
+          gTasks[taskId].tMinuteHandAngle,
+          gTasks[taskId].tMvmtDir,
+          gTasks[taskId].tMvmtSpeed);
     }
     else
     {
-        gTasks[taskId].data[TD_MHAND_ANGLE] = gTasks[taskId].data[TD_MINUTES] * 6;
-        gTasks[taskId].data[TD_HHAND_ANGLE] = (gTasks[taskId].data[TD_HOURS] % 12) * 30 + (gTasks[taskId].data[TD_MINUTES] / 10) * 5;
-        if(gMain.newKeys & A_BUTTON)
+        gTasks[taskId].tMinuteHandAngle = gTasks[taskId].tMinutes * 6;
+        gTasks[taskId].tHourHandAngle = (gTasks[taskId].tHours % 12) * 30 + (gTasks[taskId].tMinutes / 10) * 5;
+        if (gMain.newKeys & A_BUTTON)
         {
             gTasks[taskId].func = Task_SetClock3;
             return;
         }
         else
         {
-            gTasks[taskId].data[TD_SETDIRECTION] = gMain.newKeys & A_BUTTON;
-            if(gMain.heldKeys & DPAD_LEFT)
-                gTasks[taskId].data[TD_SETDIRECTION] = BACKWARD;
-            if(gMain.heldKeys & DPAD_RIGHT)
-                gTasks[taskId].data[TD_SETDIRECTION] = FORWARD;
-            if(gTasks[taskId].data[TD_SETDIRECTION])
+            gTasks[taskId].tMvmtDir = gMain.newKeys & A_BUTTON;
+            if (gMain.heldKeys & DPAD_LEFT)
+                gTasks[taskId].tMvmtDir = MVMT_BACKWARD;
+            if (gMain.heldKeys & DPAD_RIGHT)
+                gTasks[taskId].tMvmtDir = MVMT_FORWARD;
+            if (gTasks[taskId].tMvmtDir)
             {
-                if(gTasks[taskId].data[TD_SETSPEED] <= 0xFE)
-                    gTasks[taskId].data[TD_SETSPEED]++;
-                gTasks[taskId].data[TD_MHAND_ANGLE] = CalcNewMinHandAngle(
-                  gTasks[taskId].data[TD_MHAND_ANGLE],
-                  gTasks[taskId].data[TD_SETDIRECTION],
-                  gTasks[taskId].data[TD_SETSPEED]);
-                AdvanceClock(taskId, gTasks[taskId].data[TD_SETDIRECTION]);
+                if (gTasks[taskId].tMvmtSpeed < 0xFF)
+                    gTasks[taskId].tMvmtSpeed++;
+                gTasks[taskId].tMinuteHandAngle = CalcNewMinHandAngle(
+                  gTasks[taskId].tMinuteHandAngle,
+                  gTasks[taskId].tMvmtDir,
+                  gTasks[taskId].tMvmtSpeed);
+                AdvanceClock(taskId, gTasks[taskId].tMvmtDir);
             }
             else
             {
-                gTasks[taskId].data[TD_SETSPEED] = 0;
+                gTasks[taskId].tMvmtSpeed = 0;
             }
         }
     }
@@ -297,7 +417,7 @@ static void Task_SetClock3(u8 taskId)
     MenuDrawTextWindow(2, 16, 27, 19);
     MenuPrint(gOtherText_CorrectTimePrompt, 3, 17);
     MenuDrawTextWindow(23, 8, 29, 13);
-    PrintMenuItems(24, 9, 2, gUnknown_08376D74);
+    PrintMenuItems(24, 9, 2, gMenuYesNoItems);
     InitMenu(0, 24, 9, 2, 1, 5);
     gTasks[taskId].func = Task_SetClock4;
 }
@@ -305,39 +425,39 @@ static void Task_SetClock3(u8 taskId)
 //Get menu selection
 static void Task_SetClock4(u8 taskId)
 {
-    switch(ProcessMenuInputNoWrap_())
+    switch (ProcessMenuInputNoWrap_())
     {
-        case 0:     //YES
-            PlaySE(SE_SELECT);
-            gTasks[taskId].func = Task_SetClock5;   //Move on
-            return;
-        case -1:    //B button
-        case 1:     //NO
-            sub_8072DEC();
-            PlaySE(SE_SELECT);
-            MenuZeroFillWindowRect(23, 8, 29, 13);
-            MenuZeroFillWindowRect(2, 16, 27, 19);
-            gTasks[taskId].func = Task_SetClock2;   //Go back and let player adjust clock
+    case 0:     //YES
+        PlaySE(SE_SELECT);
+        gTasks[taskId].func = Task_SetClock5;   //Move on
+        return;
+    case -1:    //B button
+    case 1:     //NO
+        HandleDestroyMenuCursors();
+        PlaySE(SE_SELECT);
+        MenuZeroFillWindowRect(23, 8, 29, 13);
+        MenuZeroFillWindowRect(2, 16, 27, 19);
+        gTasks[taskId].func = Task_SetClock2;   //Go back and let player adjust clock
     }
 }
 
 //Set the time offset based on the wall clock's time
 static void Task_SetClock5(u8 taskId)
 {
-    RtcInitLocalTimeOffset(gTasks[taskId].data[TD_HOURS], gTasks[taskId].data[TD_MINUTES]);
+    RtcInitLocalTimeOffset(gTasks[taskId].tHours, gTasks[taskId].tMinutes);
     BeginNormalPaletteFade(-1, 0, 0, 16, 0);
     gTasks[taskId].func = Task_SetClock6;
 }
 
 static void Task_SetClock6(u8 taskId)
 {
-    if(!gPaletteFade.active)
-        SetMainCallback2((MainCallback)gMain.field_8);
+    if (!gPaletteFade.active)
+        SetMainCallback2((MainCallback)gMain.savedCallback);
 }
 
 static void Task_ViewClock1(u8 taskId)
 {
-    if(!gPaletteFade.active)
+    if (!gPaletteFade.active)
         gTasks[taskId].func = Task_ViewClock2;
 }
 
@@ -345,7 +465,7 @@ static void Task_ViewClock1(u8 taskId)
 static void Task_ViewClock2(u8 taskId)
 {
     InitClockWithRtc(taskId);
-    if(gMain.newKeys & (A_BUTTON | B_BUTTON))
+    if (gMain.newKeys & (A_BUTTON | B_BUTTON))
         gTasks[taskId].func = Task_ViewClock3;
 }
 
@@ -357,41 +477,41 @@ static void Task_ViewClock3(u8 taskId)
 
 static void Task_ViewClock4(u8 taskId)
 {
-    if(!gPaletteFade.active)
-        SetMainCallback2((MainCallback)gMain.field_8);
+    if (!gPaletteFade.active)
+        SetMainCallback2((MainCallback)gMain.savedCallback);
 }
 
 static u8 CalcMinHandDelta(u16 speed)
 {
-    if(speed > 60)
+    if (speed > 60)
         return 6;
-    else if(speed > 30)
+    else if (speed > 30)
         return 3;
-    else if(speed > 10)
+    else if (speed > 10)
         return 2;
     else
         return 1;
 }
 
-//Calculates the new position of the minute hand when setting the clock
+//Calculates the new angle of the minute hand when setting the clock
 static u16 CalcNewMinHandAngle(u16 angle, u8 direction, u8 speed)
 {
     u8 delta = CalcMinHandDelta(speed);
-    
-    switch(direction)
+
+    switch (direction)
     {
-        case BACKWARD:
-            if(angle)
-                angle = angle - delta;
-            else
-                angle = 360 - delta;
-            break;
-        case FORWARD:
-            if(angle < 360 - delta)
-                angle = angle + delta;
-            else
-                angle = 0;
-            break;
+    case MVMT_BACKWARD:
+        if (angle)
+            angle = angle - delta;
+        else
+            angle = 360 - delta;
+        break;
+    case MVMT_FORWARD:
+        if (angle < 360 - delta)
+            angle = angle + delta;
+        else
+            angle = 0;
+        break;
     }
     return angle;
 }
@@ -399,34 +519,34 @@ static u16 CalcNewMinHandAngle(u16 angle, u8 direction, u8 speed)
 //Advances clock forward or backward by 1 minute
 static u8 AdvanceClock(u8 taskId, u8 direction)
 {
-    switch(direction)
+    switch (direction)
     {
-        case BACKWARD:
-            if(gTasks[taskId].data[TD_MINUTES] > 0)
-                gTasks[taskId].data[TD_MINUTES]--;
+    case MVMT_BACKWARD:
+        if (gTasks[taskId].tMinutes > 0)
+            gTasks[taskId].tMinutes--;
+        else
+        {
+            gTasks[taskId].tMinutes = 59;
+            if (gTasks[taskId].tHours > 0)
+                gTasks[taskId].tHours--;
             else
-            {
-                gTasks[taskId].data[TD_MINUTES] = 59;
-                if(gTasks[taskId].data[TD_HOURS] > 0)
-                    gTasks[taskId].data[TD_HOURS]--;
-                else
-                    gTasks[taskId].data[TD_HOURS] = 23;
-                UpdateClockPeriod(taskId, direction);
-            }
-            break;
-        case FORWARD:
-            if(gTasks[taskId].data[TD_MINUTES] <= 58)
-                gTasks[taskId].data[TD_MINUTES]++;
+                gTasks[taskId].tHours = 23;
+            UpdateClockPeriod(taskId, direction);
+        }
+        break;
+    case MVMT_FORWARD:
+        if (gTasks[taskId].tMinutes < 59)
+            gTasks[taskId].tMinutes++;
+        else
+        {
+            gTasks[taskId].tMinutes = 0;
+            if (gTasks[taskId].tHours < 23)
+                gTasks[taskId].tHours++;
             else
-            {
-                gTasks[taskId].data[TD_MINUTES] = 0;
-                if(gTasks[taskId].data[TD_HOURS] <= 22)
-                    gTasks[taskId].data[TD_HOURS]++;
-                else
-                    gTasks[taskId].data[TD_HOURS] = 0;
-                UpdateClockPeriod(taskId, direction);
-            }
-            break;
+                gTasks[taskId].tHours = 0;
+            UpdateClockPeriod(taskId, direction);
+        }
+        break;
     }
     return 0;
 }
@@ -434,115 +554,479 @@ static u8 AdvanceClock(u8 taskId, u8 direction)
 //Updates the clock period (AM/PM) if it needs to change
 static void UpdateClockPeriod(u8 taskId, u8 direction)
 {
-    u8 hours = gTasks[taskId].data[TD_HOURS];
-    
-    switch(direction)
+    u8 hours = gTasks[taskId].tHours;
+
+    switch (direction)
     {
-        case BACKWARD:
-            switch(hours)
-            {
-                case 11:
-                    gTasks[taskId].data[TD_PERIOD] = AM;
-                    break;
-                case 23:
-                    gTasks[taskId].data[TD_PERIOD] = PM;
-                    break;
-            }
+    case MVMT_BACKWARD:
+        switch (hours)
+        {
+        case 11:
+            gTasks[taskId].tPeriod = PERIOD_AM;
             break;
-        case FORWARD:
-            switch(hours)
-            {
-                case 0:
-                    gTasks[taskId].data[TD_PERIOD] = AM;
-                    break;
-                case 12:
-                    gTasks[taskId].data[TD_PERIOD] = PM;
-                    break;
-            }
+        case 23:
+            gTasks[taskId].tPeriod = PERIOD_PM;
+            break;
+        }
+        break;
+    case MVMT_FORWARD:
+        switch (hours)
+        {
+        case 0:
+            gTasks[taskId].tPeriod = PERIOD_AM;
             break;
+        case 12:
+            gTasks[taskId].tPeriod = PERIOD_PM;
+            break;
+        }
+        break;
     }
 }
 
 static void InitClockWithRtc(u8 taskId)
 {
     RtcCalcLocalTime();
-    gTasks[taskId].data[TD_HOURS] = gLocalTime.hours;
-    gTasks[taskId].data[TD_MINUTES] = gLocalTime.minutes;
-    gTasks[taskId].data[TD_MHAND_ANGLE] = gTasks[taskId].data[TD_MINUTES] * 6;
-    gTasks[taskId].data[TD_HHAND_ANGLE] = (gTasks[taskId].data[TD_HOURS] % 12) * 30 + (gTasks[taskId].data[TD_MINUTES] / 10) * 5;
-    if(gLocalTime.hours <= 11)
-        gTasks[taskId].data[TD_PERIOD] = AM;
+    gTasks[taskId].tHours = gLocalTime.hours;
+    gTasks[taskId].tMinutes = gLocalTime.minutes;
+    gTasks[taskId].tMinuteHandAngle = gTasks[taskId].tMinutes * 6;
+    gTasks[taskId].tHourHandAngle = (gTasks[taskId].tHours % 12) * 30 + (gTasks[taskId].tMinutes / 10) * 5;
+    if (gLocalTime.hours <= 11)
+        gTasks[taskId].tPeriod = PERIOD_AM;
     else
-        gTasks[taskId].data[TD_PERIOD] = PM;
+        gTasks[taskId].tPeriod = PERIOD_PM;
 }
 
-void sub_810B05C(struct Sprite *sprite)
+static const s8 gClockHandCoords[][2] =
+{
+    {  0, -24},
+    {  1, -25},
+    {  1, -25},
+    {  2, -25},
+    {  2, -25},
+    {  2, -25},
+    {  3, -24},
+    {  3, -25},
+    {  4, -25},
+    {  4, -25},
+    {  4, -25},
+    {  5, -25},
+    {  5, -25},
+    {  6, -24},
+    {  6, -24},
+    {  6, -24},
+    {  7, -24},
+    {  7, -24},
+    {  7, -24},
+    {  8, -24},
+    {  8, -24},
+    {  9, -24},
+    {  9, -24},
+    { 10, -23},
+    { 10, -23},
+    { 11, -22},
+    { 11, -22},
+    { 11, -22},
+    { 12, -22},
+    { 12, -21},
+    { 13, -21},
+    { 13, -21},
+    { 13, -21},
+    { 14, -21},
+    { 14, -21},
+    { 14, -20},
+    { 14, -20},
+    { 15, -20},
+    { 15, -19},
+    { 16, -19},
+    { 16, -19},
+    { 16, -19},
+    { 16, -18},
+    { 16, -18},
+    { 17, -18},
+    { 17, -17},
+    { 17, -17},
+    { 18, -17},
+    { 18, -17},
+    { 18, -16},
+    { 18, -16},
+    { 19, -16},
+    { 19, -15},
+    { 19, -15},
+    { 20, -15},
+    { 20, -14},
+    { 20, -14},
+    { 20, -13},
+    { 20, -13},
+    { 21, -13},
+    { 21, -13},
+    { 21, -12},
+    { 22, -12},
+    { 22, -12},
+    { 22, -11},
+    { 22, -11},
+    { 22, -10},
+    { 23, -10},
+    { 23,  -9},
+    { 23,  -9},
+    { 23,  -9},
+    { 23,  -9},
+    { 23,  -8},
+    { 23,  -8},
+    { 23,  -7},
+    { 23,  -7},
+    { 23,  -6},
+    { 24,  -6},
+    { 24,  -6},
+    { 25,  -5},
+    { 25,  -5},
+    { 24,  -4},
+    { 25,  -4},
+    { 24,  -3},
+    { 25,  -3},
+    { 25,  -3},
+    { 25,  -2},
+    { 25,  -2},
+    { 24,  -1},
+    { 25,  -1},
+    { 24,   0},
+    { 24,   0},
+    { 24,   0},
+    { 24,   1},
+    { 24,   1},
+    { 25,   2},
+    { 24,   2},
+    { 25,   2},
+    { 24,   3},
+    { 24,   3},
+    { 25,   4},
+    { 24,   4},
+    { 24,   5},
+    { 24,   5},
+    { 24,   5},
+    { 24,   6},
+    { 23,   6},
+    { 23,   6},
+    { 23,   7},
+    { 23,   8},
+    { 23,   8},
+    { 23,   8},
+    { 23,   9},
+    { 23,   9},
+    { 23,  10},
+    { 22,  10},
+    { 22,  10},
+    { 22,  11},
+    { 22,  11},
+    { 22,  11},
+    { 22,  12},
+    { 21,  12},
+    { 21,  12},
+    { 21,  13},
+    { 20,  13},
+    { 20,  13},
+    { 19,  13},
+    { 19,  13},
+    { 19,  14},
+    { 19,  14},
+    { 19,  15},
+    { 19,  15},
+    { 18,  15},
+    { 18,  16},
+    { 17,  16},
+    { 17,  16},
+    { 17,  17},
+    { 17,  17},
+    { 16,  17},
+    { 16,  18},
+    { 16,  18},
+    { 15,  18},
+    { 14,  18},
+    { 15,  19},
+    { 14,  19},
+    { 14,  19},
+    { 13,  19},
+    { 13,  20},
+    { 13,  20},
+    { 13,  20},
+    { 12,  20},
+    { 12,  20},
+    { 12,  21},
+    { 11,  21},
+    { 11,  21},
+    { 11,  21},
+    { 10,  21},
+    { 10,  22},
+    { 10,  22},
+    {  9,  22},
+    {  9,  22},
+    {  8,  22},
+    {  7,  22},
+    {  7,  23},
+    {  7,  23},
+    {  6,  23},
+    {  6,  23},
+    {  5,  23},
+    {  5,  23},
+    {  5,  24},
+    {  4,  24},
+    {  4,  24},
+    {  4,  24},
+    {  3,  24},
+    {  2,  24},
+    {  2,  24},
+    {  1,  24},
+    {  1,  24},
+    {  0,  24},
+    {  0,  24},
+    { -1,  23},
+    {  0,  24},
+    {  0,  24},
+    { -1,  24},
+    { -1,  24},
+    { -2,  24},
+    { -2,  24},
+    { -3,  24},
+    { -3,  24},
+    { -4,  24},
+    { -4,  24},
+    { -5,  24},
+    { -5,  23},
+    { -5,  23},
+    { -6,  23},
+    { -6,  23},
+    { -7,  23},
+    { -7,  23},
+    { -7,  23},
+    { -8,  23},
+    { -8,  22},
+    { -9,  22},
+    { -9,  22},
+    {-10,  22},
+    {-10,  22},
+    {-10,  21},
+    {-11,  21},
+    {-11,  21},
+    {-11,  21},
+    {-11,  20},
+    {-12,  20},
+    {-12,  20},
+    {-13,  20},
+    {-13,  20},
+    {-13,  19},
+    {-14,  19},
+    {-14,  19},
+    {-14,  19},
+    {-14,  18},
+    {-15,  18},
+    {-15,  18},
+    {-15,  17},
+    {-16,  17},
+    {-16,  17},
+    {-17,  17},
+    {-17,  16},
+    {-17,  16},
+    {-18,  16},
+    {-17,  15},
+    {-18,  15},
+    {-18,  15},
+    {-19,  15},
+    {-19,  14},
+    {-19,  14},
+    {-19,  13},
+    {-19,  13},
+    {-20,  13},
+    {-20,  12},
+    {-20,  12},
+    {-21,  12},
+    {-21,  12},
+    {-21,  11},
+    {-21,  11},
+    {-21,  10},
+    {-21,  10},
+    {-21,   9},
+    {-22,   9},
+    {-22,   9},
+    {-22,   8},
+    {-22,   8},
+    {-22,   7},
+    {-23,   7},
+    {-23,   7},
+    {-23,   6},
+    {-23,   6},
+    {-23,   5},
+    {-24,   5},
+    {-23,   4},
+    {-23,   4},
+    {-24,   4},
+    {-24,   4},
+    {-24,   3},
+    {-24,   3},
+    {-24,   2},
+    {-24,   2},
+    {-24,   1},
+    {-24,   1},
+    {-24,   1},
+    {-24,   0},
+    {-25,   0},
+    {-24,  -1},
+    {-25,  -1},
+    {-24,  -1},
+    {-24,  -2},
+    {-24,  -2},
+    {-24,  -3},
+    {-24,  -3},
+    {-24,  -4},
+    {-24,  -4},
+    {-24,  -4},
+    {-24,  -5},
+    {-24,  -5},
+    {-24,  -6},
+    {-24,  -6},
+    {-23,  -6},
+    {-23,  -7},
+    {-23,  -7},
+    {-23,  -8},
+    {-23,  -8},
+    {-23,  -9},
+    {-23,  -9},
+    {-22,  -9},
+    {-22,  -9},
+    {-22, -10},
+    {-22, -10},
+    {-21, -10},
+    {-21, -11},
+    {-22, -11},
+    {-22, -12},
+    {-21, -12},
+    {-21, -13},
+    {-21, -13},
+    {-20, -13},
+    {-21, -14},
+    {-20, -14},
+    {-20, -14},
+    {-19, -14},
+    {-19, -15},
+    {-19, -15},
+    {-18, -16},
+    {-18, -16},
+    {-18, -16},
+    {-18, -17},
+    {-18, -17},
+    {-17, -17},
+    {-17, -18},
+    {-17, -18},
+    {-16, -18},
+    {-16, -18},
+    {-16, -19},
+    {-16, -19},
+    {-15, -19},
+    {-15, -19},
+    {-15, -20},
+    {-14, -20},
+    {-14, -20},
+    {-14, -21},
+    {-13, -21},
+    {-13, -21},
+    {-13, -21},
+    {-12, -21},
+    {-12, -22},
+    {-11, -22},
+    {-11, -22},
+    {-11, -22},
+    {-10, -22},
+    {-10, -22},
+    { -9, -22},
+    { -9, -23},
+    { -9, -23},
+    { -8, -23},
+    { -8, -23},
+    { -7, -23},
+    { -7, -23},
+    { -7, -24},
+    { -6, -24},
+    { -6, -24},
+    { -5, -24},
+    { -5, -24},
+    { -4, -24},
+    { -4, -24},
+    { -4, -24},
+    { -4, -25},
+    { -3, -25},
+    { -2, -25},
+    { -2, -24},
+    { -2, -24},
+    { -1, -25},
+    { -1, -25},
+    {  0, -25},
+};
+
+static void sub_810B05C(struct Sprite *sprite)
 {
     u16 angle;
     s16 sin;
     s16 cos;
     u16 x;
     u16 y;
-    
-    angle = gTasks[sprite->data0].data[TD_MHAND_ANGLE];
+
+    angle = gTasks[sprite->data0].tMinuteHandAngle;
     sin = Sin2(angle) / 16;
     cos = Cos2(angle) / 16;
     SetOamMatrix(0, cos, sin, -sin, cos);
     x = gClockHandCoords[angle][0];
     y = gClockHandCoords[angle][1];
-    
+
     //Manual sign extension
-    if(x > 0x80)
+    if (x > 0x80)
         x |= 0xFF00;
-    if(y > 0x80)
+    if (y > 0x80)
         y |= 0xFF00;
-    
+
     sprite->pos2.x = x;
     sprite->pos2.y = y;
 }
 
-void sub_810B0F4(struct Sprite *sprite)
+static void sub_810B0F4(struct Sprite *sprite)
 {
     u16 angle;
     s16 sin;
     s16 cos;
     u16 x;
     u16 y;
-    
-    angle = gTasks[sprite->data0].data[TD_HHAND_ANGLE];
+
+    angle = gTasks[sprite->data0].tHourHandAngle;
     sin = Sin2(angle) / 16;
     cos = Cos2(angle) / 16;
     SetOamMatrix(1, cos, sin, -sin, cos);
     x = gClockHandCoords[angle][0];
     y = gClockHandCoords[angle][1];
-    
+
     //Manual sign extension
-    if(x > 0x80)
+    if (x > 0x80)
         x |= 0xFF00;
-    if(y > 0x80)
+    if (y > 0x80)
         y |= 0xFF00;
-    
+
     sprite->pos2.x = x;
     sprite->pos2.y = y;
 }
 
-void sub_810B18C(struct Sprite *sprite)
+static void sub_810B18C(struct Sprite *sprite)
 {
     s16 sin;
     s16 cos;
-    
-    if(gTasks[sprite->data0].data[TD_PERIOD] != AM)
+
+    if (gTasks[sprite->data0].tPeriod != PERIOD_AM)
     {
-        if((u16)(sprite->data1 - 60) <= 29)
+        if (sprite->data1 >= 60 && sprite->data1 < 90)
             sprite->data1 += 5;
-        if(sprite->data1 <= 59)
+        if (sprite->data1 < 60)
             sprite->data1++;
     }
     else
     {
-        if((u16)(sprite->data1 - 46) <= 29)
+        if (sprite->data1 > 45 && sprite->data1 <= 75)
             sprite->data1 -= 5;
-        if(sprite->data1 > 75)
+        if (sprite->data1 > 75)
             sprite->data1--;
     }
     cos = Cos2((u16)sprite->data1);
@@ -551,23 +1035,23 @@ void sub_810B18C(struct Sprite *sprite)
     sprite->pos2.y = sin * 30 / 4096;
 }
 
-void sub_810B230(struct Sprite *sprite)
+static void sub_810B230(struct Sprite *sprite)
 {
     s16 sin;
     s16 cos;
-    
-    if(gTasks[sprite->data0].data[TD_PERIOD] != AM)
+
+    if (gTasks[sprite->data0].tPeriod != PERIOD_AM)
     {
-        if(sprite->data1 >= 105 && sprite->data1 < 135)
+        if (sprite->data1 >= 105 && sprite->data1 < 135)
             sprite->data1 += 5;
-        if(sprite->data1 < 105)
+        if (sprite->data1 < 105)
             sprite->data1++;
     }
     else
     {
-        if(sprite->data1 > 90 && sprite->data1 <= 120)
+        if (sprite->data1 > 90 && sprite->data1 <= 120)
             sprite->data1 -= 5;
-        if(sprite->data1 > 120)
+        if (sprite->data1 > 120)
             sprite->data1--;
     }
     cos = Cos2((u16)sprite->data1);