summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/bg.c314
-rw-r--r--src/dma3_manager.c34
-rw-r--r--src/egg_hatch.c893
-rw-r--r--src/gpu_regs.c25
-rw-r--r--src/pokemon_3.c2
-rw-r--r--src/safari_zone.c4
-rw-r--r--src/text.c3
-rw-r--r--src/trig.c6
8 files changed, 1073 insertions, 208 deletions
diff --git a/src/bg.c b/src/bg.c
index 390a99d50..74e3ea830 100644
--- a/src/bg.c
+++ b/src/bg.c
@@ -1,21 +1,12 @@
#include "global.h"
-#include "dma3.h"
#include "bg.h"
+#include "dma3.h"
+#include "gpu_regs.h"
-#define DISPCNT_ALL_BG_AND_MODE_BITS 0x0F07
-
-enum {
- BG_CTRL_ATTR_VISIBLE = 1,
- BG_CTRL_ATTR_CHARBASEINDEX = 2,
- BG_CTRL_ATTR_MAPBASEINDEX = 3,
- BG_CTRL_ATTR_SCREENSIZE = 4,
- BG_CTRL_ATTR_PALETTEMODE = 5,
- BG_CTRL_ATTR_PRIORITY = 6,
- BG_CTRL_ATTR_MOSAIC = 7,
- BG_CTRL_ATTR_WRAPAROUND = 8,
-};
+#define DISPCNT_ALL_BG_AND_MODE_BITS (DISPCNT_BG_ALL_ON | 0x7)
-struct BgControl {
+struct BgControl
+{
struct BgConfig {
u16 visible:1;
u16 unknown_1:1;
@@ -35,7 +26,8 @@ struct BgControl {
u16 bgVisibilityAndMode;
};
-struct BgConfig2 {
+struct BgConfig2
+{
u32 baseTile:10;
u32 basePalette:4;
u32 unk_3:18;
@@ -45,54 +37,36 @@ struct BgConfig2 {
u32 bg_y;
};
-static struct BgControl gGpuBgConfigs;
-static struct BgConfig2 gGpuBgConfigs2[4];
-static u32 gDmaBusyBitfield[4];
+static IWRAM_DATA struct BgControl sGpuBgConfigs;
+static IWRAM_DATA struct BgConfig2 sGpuBgConfigs2[4];
+static IWRAM_DATA u32 sDmaBusyBitfield[4];
u32 gUnneededFireRedVariable;
-static const struct BgConfig gZeroedBgControlStruct = { 0 };
-
-extern void SetGpuReg(u8 regOffset, u16 value);
-extern void SetGpuReg_ForcedBlank(u8 regOffset, u16 value);
-extern u16 GetGpuReg(u8 regOffset);
-extern int CheckForSpaceForDma3Request(s16 index);
-
-bool32 IsInvalidBg32(u8);
-void ResetBgControlStructs();
-u16 GetBgMetricTextMode(u8, u8);
-u32 GetBgMetricAffineMode(u8, u8);
-u32 GetBgType(u8);
-void SetTextModeAndHideBgs();
-bool8 IsInvalidBg(u8);
-bool32 IsTileMapOutsideWram(u8);
-void CopyRectToBgTilemapBufferRect(u8, void*, u8, u8, u8, u8, u8, u8, u8, u8, u8, u16, u16);
-void CopyTileMapEntry(u16*, u16*, s32, u32, u32);
-u32 GetTileMapIndexFromCoords(s32, s32, s32, u32, u32);
-void WriteSequenceToBgTilemapBuffer(u8, u16, u8, u8, u8, u8, u8, s16);
+static const struct BgConfig sZeroedBgControlStruct = { 0 };
void ResetBgs(void)
{
ResetBgControlStructs();
- gGpuBgConfigs.bgVisibilityAndMode = 0;
+ sGpuBgConfigs.bgVisibilityAndMode = 0;
SetTextModeAndHideBgs();
}
-void SetBgModeInternal(u8 bgMode)
+static void SetBgModeInternal(u8 bgMode)
{
- gGpuBgConfigs.bgVisibilityAndMode &= 0xFFF8;
- gGpuBgConfigs.bgVisibilityAndMode |= bgMode;
+ sGpuBgConfigs.bgVisibilityAndMode &= 0xFFF8;
+ sGpuBgConfigs.bgVisibilityAndMode |= bgMode;
}
u8 GetBgMode(void)
{
- return gGpuBgConfigs.bgVisibilityAndMode & 0x7;
+ return sGpuBgConfigs.bgVisibilityAndMode & 0x7;
}
void ResetBgControlStructs(void)
{
- struct BgConfig* bgConfigs = &gGpuBgConfigs.configs[0];
- struct BgConfig zeroedConfig = gZeroedBgControlStruct;
+ struct BgConfig* bgConfigs = &sGpuBgConfigs.configs[0];
+ struct BgConfig zeroedConfig = sZeroedBgControlStruct;
int i;
for (i = 0; i < 4; i++)
@@ -105,7 +79,7 @@ void Unused_ResetBgControlStruct(u8 bg)
{
if (IsInvalidBg(bg) == FALSE)
{
- gGpuBgConfigs.configs[bg] = gZeroedBgControlStruct;
+ sGpuBgConfigs.configs[bg] = sZeroedBgControlStruct;
}
}
@@ -115,88 +89,88 @@ void SetBgControlAttributes(u8 bg, u8 charBaseIndex, u8 mapBaseIndex, u8 screenS
{
if (charBaseIndex != 0xFF)
{
- gGpuBgConfigs.configs[bg].charBaseIndex = charBaseIndex & 0x3;
+ sGpuBgConfigs.configs[bg].charBaseIndex = charBaseIndex & 0x3;
}
if (mapBaseIndex != 0xFF)
{
- gGpuBgConfigs.configs[bg].mapBaseIndex = mapBaseIndex & 0x1F;
+ sGpuBgConfigs.configs[bg].mapBaseIndex = mapBaseIndex & 0x1F;
}
if (screenSize != 0xFF)
{
- gGpuBgConfigs.configs[bg].screenSize = screenSize & 0x3;
+ sGpuBgConfigs.configs[bg].screenSize = screenSize & 0x3;
}
if (paletteMode != 0xFF)
{
- gGpuBgConfigs.configs[bg].paletteMode = paletteMode;
+ sGpuBgConfigs.configs[bg].paletteMode = paletteMode;
}
if (priority != 0xFF)
{
- gGpuBgConfigs.configs[bg].priority = priority & 0x3;
+ sGpuBgConfigs.configs[bg].priority = priority & 0x3;
}
if (mosaic != 0xFF)
{
- gGpuBgConfigs.configs[bg].mosaic = mosaic & 0x1;
+ sGpuBgConfigs.configs[bg].mosaic = mosaic & 0x1;
}
if (wraparound != 0xFF)
{
- gGpuBgConfigs.configs[bg].wraparound = wraparound;
+ sGpuBgConfigs.configs[bg].wraparound = wraparound;
}
- gGpuBgConfigs.configs[bg].unknown_2 = 0;
- gGpuBgConfigs.configs[bg].unknown_3 = 0;
+ sGpuBgConfigs.configs[bg].unknown_2 = 0;
+ sGpuBgConfigs.configs[bg].unknown_3 = 0;
- gGpuBgConfigs.configs[bg].visible = 1;
+ sGpuBgConfigs.configs[bg].visible = 1;
}
}
u16 GetBgControlAttribute(u8 bg, u8 attributeId)
{
- if (IsInvalidBg(bg) == FALSE && gGpuBgConfigs.configs[bg].visible != FALSE)
+ if (IsInvalidBg(bg) == FALSE && sGpuBgConfigs.configs[bg].visible != FALSE)
{
switch (attributeId)
{
case BG_CTRL_ATTR_VISIBLE:
- return gGpuBgConfigs.configs[bg].visible;
+ return sGpuBgConfigs.configs[bg].visible;
case BG_CTRL_ATTR_CHARBASEINDEX:
- return gGpuBgConfigs.configs[bg].charBaseIndex;
+ return sGpuBgConfigs.configs[bg].charBaseIndex;
case BG_CTRL_ATTR_MAPBASEINDEX:
- return gGpuBgConfigs.configs[bg].mapBaseIndex;
+ return sGpuBgConfigs.configs[bg].mapBaseIndex;
case BG_CTRL_ATTR_SCREENSIZE:
- return gGpuBgConfigs.configs[bg].screenSize;
+ return sGpuBgConfigs.configs[bg].screenSize;
case BG_CTRL_ATTR_PALETTEMODE:
- return gGpuBgConfigs.configs[bg].paletteMode;
+ return sGpuBgConfigs.configs[bg].paletteMode;
case BG_CTRL_ATTR_PRIORITY:
- return gGpuBgConfigs.configs[bg].priority;
+ return sGpuBgConfigs.configs[bg].priority;
case BG_CTRL_ATTR_MOSAIC:
- return gGpuBgConfigs.configs[bg].mosaic;
+ return sGpuBgConfigs.configs[bg].mosaic;
case BG_CTRL_ATTR_WRAPAROUND:
- return gGpuBgConfigs.configs[bg].wraparound;
+ return sGpuBgConfigs.configs[bg].wraparound;
}
}
return 0xFF;
}
-u8 LoadBgVram(u8 bg, void *src, u16 size, u16 destOffset, u8 mode)
+u8 LoadBgVram(u8 bg, const void *src, u16 size, u16 destOffset, u8 mode)
{
u16 offset;
s8 cursor;
- if (IsInvalidBg(bg) == FALSE && gGpuBgConfigs.configs[bg].visible != FALSE)
+ if (IsInvalidBg(bg) == FALSE && sGpuBgConfigs.configs[bg].visible != FALSE)
{
switch (mode)
{
case 0x1:
- offset = gGpuBgConfigs.configs[bg].charBaseIndex * BG_CHAR_SIZE;
+ offset = sGpuBgConfigs.configs[bg].charBaseIndex * BG_CHAR_SIZE;
break;
case 0x2:
- offset = gGpuBgConfigs.configs[bg].mapBaseIndex * BG_SCREEN_SIZE;
+ offset = sGpuBgConfigs.configs[bg].mapBaseIndex * BG_SCREEN_SIZE;
break;
default:
cursor = -1;
@@ -221,51 +195,51 @@ end:
return cursor;
}
-void ShowBgInternal(u8 bg)
+static void ShowBgInternal(u8 bg)
{
u16 value;
- if (IsInvalidBg(bg) == FALSE && gGpuBgConfigs.configs[bg].visible != FALSE)
+ if (IsInvalidBg(bg) == FALSE && sGpuBgConfigs.configs[bg].visible != FALSE)
{
- value = gGpuBgConfigs.configs[bg].priority |
- (gGpuBgConfigs.configs[bg].charBaseIndex << 2) |
- (gGpuBgConfigs.configs[bg].mosaic << 6) |
- (gGpuBgConfigs.configs[bg].paletteMode << 7) |
- (gGpuBgConfigs.configs[bg].mapBaseIndex << 8) |
- (gGpuBgConfigs.configs[bg].wraparound << 13) |
- (gGpuBgConfigs.configs[bg].screenSize << 14);
+ value = sGpuBgConfigs.configs[bg].priority |
+ (sGpuBgConfigs.configs[bg].charBaseIndex << 2) |
+ (sGpuBgConfigs.configs[bg].mosaic << 6) |
+ (sGpuBgConfigs.configs[bg].paletteMode << 7) |
+ (sGpuBgConfigs.configs[bg].mapBaseIndex << 8) |
+ (sGpuBgConfigs.configs[bg].wraparound << 13) |
+ (sGpuBgConfigs.configs[bg].screenSize << 14);
SetGpuReg((bg << 1) + 0x8, value);
- gGpuBgConfigs.bgVisibilityAndMode |= 1 << (bg + 8);
- gGpuBgConfigs.bgVisibilityAndMode &= DISPCNT_ALL_BG_AND_MODE_BITS;
+ sGpuBgConfigs.bgVisibilityAndMode |= 1 << (bg + 8);
+ sGpuBgConfigs.bgVisibilityAndMode &= DISPCNT_ALL_BG_AND_MODE_BITS;
}
}
-void HideBgInternal(u8 bg)
+static void HideBgInternal(u8 bg)
{
if (IsInvalidBg(bg) == FALSE)
{
- gGpuBgConfigs.bgVisibilityAndMode &= ~(1 << (bg + 8));
- gGpuBgConfigs.bgVisibilityAndMode &= DISPCNT_ALL_BG_AND_MODE_BITS;
+ sGpuBgConfigs.bgVisibilityAndMode &= ~(1 << (bg + 8));
+ sGpuBgConfigs.bgVisibilityAndMode &= DISPCNT_ALL_BG_AND_MODE_BITS;
}
}
-void SyncBgVisibilityAndMode()
+static void SyncBgVisibilityAndMode(void)
{
- SetGpuReg(0, (GetGpuReg(0) & ~DISPCNT_ALL_BG_AND_MODE_BITS) | gGpuBgConfigs.bgVisibilityAndMode);
+ SetGpuReg(0, (GetGpuReg(0) & ~DISPCNT_ALL_BG_AND_MODE_BITS) | sGpuBgConfigs.bgVisibilityAndMode);
}
-void SetTextModeAndHideBgs()
+void SetTextModeAndHideBgs(void)
{
SetGpuReg(0, GetGpuReg(0) & ~DISPCNT_ALL_BG_AND_MODE_BITS);
}
-void SetBgAffineInternal(u8 bg, u32 srcCenterX, u32 srcCenterY, s16 dispCenterX, s16 dispCenterY, s16 scaleX, s16 scaleY, u16 rotationAngle)
+static void SetBgAffineInternal(u8 bg, u32 srcCenterX, u32 srcCenterY, s16 dispCenterX, s16 dispCenterY, s16 scaleX, s16 scaleY, u16 rotationAngle)
{
struct BgAffineSrcData src;
struct BgAffineDstData dest;
- switch (gGpuBgConfigs.bgVisibilityAndMode & 0x7)
+ switch (sGpuBgConfigs.bgVisibilityAndMode & 0x7)
{
case 1:
if (bg != 2)
@@ -320,7 +294,7 @@ void ResetBgsAndClearDma3BusyFlags(u32 leftoverFireRedLeafGreenVariable)
for (i = 0; i < 4; i++)
{
- gDmaBusyBitfield[i] = 0;
+ sDmaBusyBitfield[i] = 0;
}
gUnneededFireRedVariable = leftoverFireRedLeafGreenVariable;
@@ -347,13 +321,13 @@ void InitBgsFromTemplates(u8 bgMode, const struct BgTemplate *templates, u8 numT
0,
0);
- gGpuBgConfigs2[bg].baseTile = templates[i].baseTile;
- gGpuBgConfigs2[bg].basePalette = 0;
- gGpuBgConfigs2[bg].unk_3 = 0;
+ sGpuBgConfigs2[bg].baseTile = templates[i].baseTile;
+ sGpuBgConfigs2[bg].basePalette = 0;
+ sGpuBgConfigs2[bg].unk_3 = 0;
- gGpuBgConfigs2[bg].tilemap = NULL;
- gGpuBgConfigs2[bg].bg_x = 0;
- gGpuBgConfigs2[bg].bg_y = 0;
+ sGpuBgConfigs2[bg].tilemap = NULL;
+ sGpuBgConfigs2[bg].bg_x = 0;
+ sGpuBgConfigs2[bg].bg_y = 0;
}
}
}
@@ -373,13 +347,13 @@ void InitBgFromTemplate(const struct BgTemplate *template)
0,
0);
- gGpuBgConfigs2[bg].baseTile = template->baseTile;
- gGpuBgConfigs2[bg].basePalette = 0;
- gGpuBgConfigs2[bg].unk_3 = 0;
+ sGpuBgConfigs2[bg].baseTile = template->baseTile;
+ sGpuBgConfigs2[bg].basePalette = 0;
+ sGpuBgConfigs2[bg].unk_3 = 0;
- gGpuBgConfigs2[bg].tilemap = NULL;
- gGpuBgConfigs2[bg].bg_x = 0;
- gGpuBgConfigs2[bg].bg_y = 0;
+ sGpuBgConfigs2[bg].tilemap = NULL;
+ sGpuBgConfigs2[bg].bg_x = 0;
+ sGpuBgConfigs2[bg].bg_y = 0;
}
}
@@ -388,18 +362,18 @@ void SetBgMode(u8 bgMode)
SetBgModeInternal(bgMode);
}
-u16 LoadBgTiles(u8 bg, void* src, u16 size, u16 destOffset)
+u16 LoadBgTiles(u8 bg, const void* src, u16 size, u16 destOffset)
{
u16 tileOffset;
u8 cursor;
if (GetBgControlAttribute(bg, BG_CTRL_ATTR_PALETTEMODE) == 0)
{
- tileOffset = (gGpuBgConfigs2[bg].baseTile + destOffset) * 0x20;
+ tileOffset = (sGpuBgConfigs2[bg].baseTile + destOffset) * 0x20;
}
else
{
- tileOffset = (gGpuBgConfigs2[bg].baseTile + destOffset) * 0x40;
+ tileOffset = (sGpuBgConfigs2[bg].baseTile + destOffset) * 0x40;
}
cursor = LoadBgVram(bg, src, size, tileOffset, DISPCNT_MODE_1);
@@ -409,7 +383,7 @@ u16 LoadBgTiles(u8 bg, void* src, u16 size, u16 destOffset)
return -1;
}
- gDmaBusyBitfield[cursor / 0x20] |= (1 << (cursor % 0x20));
+ sDmaBusyBitfield[cursor / 0x20] |= (1 << (cursor % 0x20));
if (gUnneededFireRedVariable == 1)
{
@@ -419,7 +393,7 @@ u16 LoadBgTiles(u8 bg, void* src, u16 size, u16 destOffset)
return cursor;
}
-u16 LoadBgTilemap(u8 bg, void *src, u16 size, u16 destOffset)
+u16 LoadBgTilemap(u8 bg, const void *src, u16 size, u16 destOffset)
{
u8 cursor;
@@ -430,19 +404,19 @@ u16 LoadBgTilemap(u8 bg, void *src, u16 size, u16 destOffset)
return -1;
}
- gDmaBusyBitfield[cursor / 0x20] |= (1 << (cursor % 0x20));
+ sDmaBusyBitfield[cursor / 0x20] |= (1 << (cursor % 0x20));
return cursor;
}
-u16 Unused_LoadBgPalette(u8 bg, void *src, u16 size, u16 destOffset)
+u16 Unused_LoadBgPalette(u8 bg, const void *src, u16 size, u16 destOffset)
{
u16 paletteOffset;
s8 cursor;
if (IsInvalidBg32(bg) == FALSE)
{
- paletteOffset = (gGpuBgConfigs2[bg].basePalette * 0x20) + (destOffset * 2);
+ paletteOffset = (sGpuBgConfigs2[bg].basePalette * 0x20) + (destOffset * 2);
cursor = RequestDma3Copy(src, (void*)(paletteOffset + BG_PLTT), size, 0);
if (cursor == -1)
@@ -455,7 +429,7 @@ u16 Unused_LoadBgPalette(u8 bg, void *src, u16 size, u16 destOffset)
return -1;
}
- gDmaBusyBitfield[cursor / 0x20] |= (1 << (cursor % 0x20));
+ sDmaBusyBitfield[cursor / 0x20] |= (1 << (cursor % 0x20));
return (u8)cursor;
}
@@ -474,7 +448,7 @@ bool8 IsDma3ManagerBusyWithBgCopy(void)
div = i / 0x20;
mod = i % 0x20;
- if ((gDmaBusyBitfield[div] & (1 << mod)) != FALSE)
+ if ((sDmaBusyBitfield[div] & (1 << mod)) != FALSE)
{
reqSpace = CheckForSpaceForDma3Request(i);
if (reqSpace == -1)
@@ -482,7 +456,7 @@ bool8 IsDma3ManagerBusyWithBgCopy(void)
return TRUE;
}
- gDmaBusyBitfield[div] &= ~(1 << mod);
+ sDmaBusyBitfield[div] &= ~(1 << mod);
}
}
@@ -508,7 +482,7 @@ _08001AE4:\n\
sub r0, r5, r0\n\
lsl r0, #24\n\
lsr r0, #24\n\
- ldr r1, =gDmaBusyBitfield\n\
+ ldr r1, =sDmaBusyBitfield\n\
lsr r2, #22\n\
add r4, r2, r1\n\
mov r6, #0x1\n\
@@ -614,7 +588,7 @@ u16 GetBgAttribute(u8 bg, u8 attributeId)
case 9:
return GetBgType(bg);
case 10:
- return gGpuBgConfigs2[bg].baseTile;
+ return sGpuBgConfigs2[bg].baseTile;
default:
return -1;
}
@@ -635,13 +609,13 @@ u32 ChangeBgX(u8 bg, u32 value, u8 op)
{
case 0:
default:
- gGpuBgConfigs2[bg].bg_x = value;
+ sGpuBgConfigs2[bg].bg_x = value;
break;
case 1:
- gGpuBgConfigs2[bg].bg_x += value;
+ sGpuBgConfigs2[bg].bg_x += value;
break;
case 2:
- gGpuBgConfigs2[bg].bg_x -= value;
+ sGpuBgConfigs2[bg].bg_x -= value;
break;
}
@@ -650,23 +624,23 @@ u32 ChangeBgX(u8 bg, u32 value, u8 op)
switch (bg)
{
case 0:
- temp1 = gGpuBgConfigs2[0].bg_x >> 0x8;
+ temp1 = sGpuBgConfigs2[0].bg_x >> 0x8;
SetGpuReg(REG_OFFSET_BG0HOFS, temp1);
break;
case 1:
- temp1 = gGpuBgConfigs2[1].bg_x >> 0x8;
+ temp1 = sGpuBgConfigs2[1].bg_x >> 0x8;
SetGpuReg(REG_OFFSET_BG1HOFS, temp1);
break;
case 2:
if (mode == 0)
{
- temp1 = gGpuBgConfigs2[2].bg_x >> 0x8;
+ temp1 = sGpuBgConfigs2[2].bg_x >> 0x8;
SetGpuReg(REG_OFFSET_BG2HOFS, temp1);
}
else
{
- temp1 = gGpuBgConfigs2[2].bg_x >> 0x10;
- temp2 = gGpuBgConfigs2[2].bg_x & 0xFFFF;
+ temp1 = sGpuBgConfigs2[2].bg_x >> 0x10;
+ temp2 = sGpuBgConfigs2[2].bg_x & 0xFFFF;
SetGpuReg(REG_OFFSET_BG2X_H, temp1);
SetGpuReg(REG_OFFSET_BG2X_L, temp2);
}
@@ -674,20 +648,20 @@ u32 ChangeBgX(u8 bg, u32 value, u8 op)
case 3:
if (mode == 0)
{
- temp1 = gGpuBgConfigs2[3].bg_x >> 0x8;
+ temp1 = sGpuBgConfigs2[3].bg_x >> 0x8;
SetGpuReg(REG_OFFSET_BG3HOFS, temp1);
}
else if (mode == 2)
{
- temp1 = gGpuBgConfigs2[3].bg_x >> 0x10;
- temp2 = gGpuBgConfigs2[3].bg_x & 0xFFFF;
+ temp1 = sGpuBgConfigs2[3].bg_x >> 0x10;
+ temp2 = sGpuBgConfigs2[3].bg_x & 0xFFFF;
SetGpuReg(REG_OFFSET_BG3X_H, temp1);
SetGpuReg(REG_OFFSET_BG3X_L, temp2);
}
break;
}
- return gGpuBgConfigs2[bg].bg_x;
+ return sGpuBgConfigs2[bg].bg_x;
}
u32 GetBgX(u8 bg)
@@ -696,7 +670,7 @@ u32 GetBgX(u8 bg)
return -1;
if (GetBgControlAttribute(bg, BG_CTRL_ATTR_VISIBLE) == 0)
return -1;
- return gGpuBgConfigs2[bg].bg_x;
+ return sGpuBgConfigs2[bg].bg_x;
}
u32 ChangeBgY(u8 bg, u32 value, u8 op)
@@ -714,13 +688,13 @@ u32 ChangeBgY(u8 bg, u32 value, u8 op)
{
case 0:
default:
- gGpuBgConfigs2[bg].bg_y = value;
+ sGpuBgConfigs2[bg].bg_y = value;
break;
case 1:
- gGpuBgConfigs2[bg].bg_y += value;
+ sGpuBgConfigs2[bg].bg_y += value;
break;
case 2:
- gGpuBgConfigs2[bg].bg_y -= value;
+ sGpuBgConfigs2[bg].bg_y -= value;
break;
}
@@ -729,23 +703,23 @@ u32 ChangeBgY(u8 bg, u32 value, u8 op)
switch (bg)
{
case 0:
- temp1 = gGpuBgConfigs2[0].bg_y >> 0x8;
+ temp1 = sGpuBgConfigs2[0].bg_y >> 0x8;
SetGpuReg(REG_OFFSET_BG0VOFS, temp1);
break;
case 1:
- temp1 = gGpuBgConfigs2[1].bg_y >> 0x8;
+ temp1 = sGpuBgConfigs2[1].bg_y >> 0x8;
SetGpuReg(REG_OFFSET_BG1VOFS, temp1);
break;
case 2:
if (mode == 0)
{
- temp1 = gGpuBgConfigs2[2].bg_y >> 0x8;
+ temp1 = sGpuBgConfigs2[2].bg_y >> 0x8;
SetGpuReg(REG_OFFSET_BG2VOFS, temp1);
}
else
{
- temp1 = gGpuBgConfigs2[2].bg_y >> 0x10;
- temp2 = gGpuBgConfigs2[2].bg_y & 0xFFFF;
+ temp1 = sGpuBgConfigs2[2].bg_y >> 0x10;
+ temp2 = sGpuBgConfigs2[2].bg_y & 0xFFFF;
SetGpuReg(REG_OFFSET_BG2Y_H, temp1);
SetGpuReg(REG_OFFSET_BG2Y_L, temp2);
}
@@ -753,20 +727,20 @@ u32 ChangeBgY(u8 bg, u32 value, u8 op)
case 3:
if (mode == 0)
{
- temp1 = gGpuBgConfigs2[3].bg_y >> 0x8;
+ temp1 = sGpuBgConfigs2[3].bg_y >> 0x8;
SetGpuReg(REG_OFFSET_BG3VOFS, temp1);
}
else if (mode == 2)
{
- temp1 = gGpuBgConfigs2[3].bg_y >> 0x10;
- temp2 = gGpuBgConfigs2[3].bg_y & 0xFFFF;
+ temp1 = sGpuBgConfigs2[3].bg_y >> 0x10;
+ temp2 = sGpuBgConfigs2[3].bg_y & 0xFFFF;
SetGpuReg(REG_OFFSET_BG3Y_H, temp1);
SetGpuReg(REG_OFFSET_BG3Y_L, temp2);
}
break;
}
- return gGpuBgConfigs2[bg].bg_y;
+ return sGpuBgConfigs2[bg].bg_y;
}
u32 ChangeBgY_ScreenOff(u8 bg, u32 value, u8 op)
@@ -784,13 +758,13 @@ u32 ChangeBgY_ScreenOff(u8 bg, u32 value, u8 op)
{
case 0:
default:
- gGpuBgConfigs2[bg].bg_y = value;
+ sGpuBgConfigs2[bg].bg_y = value;
break;
case 1:
- gGpuBgConfigs2[bg].bg_y += value;
+ sGpuBgConfigs2[bg].bg_y += value;
break;
case 2:
- gGpuBgConfigs2[bg].bg_y -= value;
+ sGpuBgConfigs2[bg].bg_y -= value;
break;
}
@@ -799,24 +773,24 @@ u32 ChangeBgY_ScreenOff(u8 bg, u32 value, u8 op)
switch (bg)
{
case 0:
- temp1 = gGpuBgConfigs2[0].bg_y >> 0x8;
+ temp1 = sGpuBgConfigs2[0].bg_y >> 0x8;
SetGpuReg_ForcedBlank(REG_OFFSET_BG0VOFS, temp1);
break;
case 1:
- temp1 = gGpuBgConfigs2[1].bg_y >> 0x8;
+ temp1 = sGpuBgConfigs2[1].bg_y >> 0x8;
SetGpuReg_ForcedBlank(REG_OFFSET_BG1VOFS, temp1);
break;
case 2:
if (mode == 0)
{
- temp1 = gGpuBgConfigs2[2].bg_y >> 0x8;
+ temp1 = sGpuBgConfigs2[2].bg_y >> 0x8;
SetGpuReg_ForcedBlank(REG_OFFSET_BG2VOFS, temp1);
}
else
{
- temp1 = gGpuBgConfigs2[2].bg_y >> 0x10;
- temp2 = gGpuBgConfigs2[2].bg_y & 0xFFFF;
+ temp1 = sGpuBgConfigs2[2].bg_y >> 0x10;
+ temp2 = sGpuBgConfigs2[2].bg_y & 0xFFFF;
SetGpuReg_ForcedBlank(REG_OFFSET_BG2Y_H, temp1);
SetGpuReg_ForcedBlank(REG_OFFSET_BG2Y_L, temp2);
}
@@ -824,20 +798,20 @@ u32 ChangeBgY_ScreenOff(u8 bg, u32 value, u8 op)
case 3:
if (mode == 0)
{
- temp1 = gGpuBgConfigs2[3].bg_y >> 0x8;
+ temp1 = sGpuBgConfigs2[3].bg_y >> 0x8;
SetGpuReg_ForcedBlank(REG_OFFSET_BG3VOFS, temp1);
}
else if (mode == 2)
{
- temp1 = gGpuBgConfigs2[3].bg_y >> 0x10;
- temp2 = gGpuBgConfigs2[3].bg_y & 0xFFFF;
+ temp1 = sGpuBgConfigs2[3].bg_y >> 0x10;
+ temp2 = sGpuBgConfigs2[3].bg_y & 0xFFFF;
SetGpuReg_ForcedBlank(REG_OFFSET_BG3Y_H, temp1);
SetGpuReg_ForcedBlank(REG_OFFSET_BG3Y_L, temp2);
}
break;
}
- return gGpuBgConfigs2[bg].bg_y;
+ return sGpuBgConfigs2[bg].bg_y;
}
u32 GetBgY(u8 bg)
@@ -846,7 +820,7 @@ u32 GetBgY(u8 bg)
return -1;
if (GetBgControlAttribute(bg, BG_CTRL_ATTR_VISIBLE) == 0)
return -1;
- return gGpuBgConfigs2[bg].bg_y;
+ return sGpuBgConfigs2[bg].bg_y;
}
void SetBgAffine(u8 bg, u32 srcCenterX, u32 srcCenterY, s16 dispCenterX, s16 dispCenterY, s16 scaleX, s16 scaleY, u16 rotationAngle)
@@ -933,7 +907,7 @@ void SetBgTilemapBuffer(u8 bg, void *tilemap)
{
if (IsInvalidBg32(bg) == FALSE && GetBgControlAttribute(bg, BG_CTRL_ATTR_VISIBLE) != 0x0)
{
- gGpuBgConfigs2[bg].tilemap = tilemap;
+ sGpuBgConfigs2[bg].tilemap = tilemap;
}
}
@@ -941,7 +915,7 @@ void UnsetBgTilemapBuffer(u8 bg)
{
if (IsInvalidBg32(bg) == FALSE && GetBgControlAttribute(bg, BG_CTRL_ATTR_VISIBLE) != 0x0)
{
- gGpuBgConfigs2[bg].tilemap = NULL;
+ sGpuBgConfigs2[bg].tilemap = NULL;
}
}
@@ -951,20 +925,20 @@ void* GetBgTilemapBuffer(u8 bg)
return NULL;
if (GetBgControlAttribute(bg, BG_CTRL_ATTR_VISIBLE) == 0)
return NULL;
- return gGpuBgConfigs2[bg].tilemap;
+ return sGpuBgConfigs2[bg].tilemap;
}
-void CopyToBgTilemapBuffer(u8 bg, void *src, u16 mode, u16 destOffset)
+void CopyToBgTilemapBuffer(u8 bg, const void *src, u16 mode, u16 destOffset)
{
if (IsInvalidBg32(bg) == FALSE && IsTileMapOutsideWram(bg) == FALSE)
{
if (mode != 0)
{
- CpuCopy16(src, (void *)(gGpuBgConfigs2[bg].tilemap + (destOffset * 2)), mode);
+ CpuCopy16(src, (void *)(sGpuBgConfigs2[bg].tilemap + (destOffset * 2)), mode);
}
else
{
- LZ77UnCompWram(src, (void *)(gGpuBgConfigs2[bg].tilemap + (destOffset * 2)));
+ LZ77UnCompWram(src, (void *)(sGpuBgConfigs2[bg].tilemap + (destOffset * 2)));
}
}
}
@@ -987,7 +961,7 @@ void CopyBgTilemapBufferToVram(u8 bg)
sizeToLoad = 0;
break;
}
- LoadBgVram(bg, gGpuBgConfigs2[bg].tilemap, sizeToLoad, 0, 2);
+ LoadBgVram(bg, sGpuBgConfigs2[bg].tilemap, sizeToLoad, 0, 2);
}
}
@@ -1008,7 +982,7 @@ void CopyToBgTilemapBufferRect(u8 bg, void* src, u8 destX, u8 destY, u8 width, u
{
for (destX16 = destX; destX16 < (destX + width); destX16++)
{
- ((u16*)gGpuBgConfigs2[bg].tilemap)[((destY16 * 0x20) + destX16)] = *((u16*)srcCopy)++;
+ ((u16*)sGpuBgConfigs2[bg].tilemap)[((destY16 * 0x20) + destX16)] = *((u16*)srcCopy)++;
}
}
break;
@@ -1019,7 +993,7 @@ void CopyToBgTilemapBufferRect(u8 bg, void* src, u8 destX, u8 destY, u8 width, u
{
for (destX16 = destX; destX16 < (destX + width); destX16++)
{
- ((u8*)gGpuBgConfigs2[bg].tilemap)[((destY16 * mode) + destX16)] = *((u8*)srcCopy)++;
+ ((u8*)sGpuBgConfigs2[bg].tilemap)[((destY16 * mode) + destX16)] = *((u8*)srcCopy)++;
}
}
break;
@@ -1056,7 +1030,7 @@ void CopyRectToBgTilemapBufferRect(u8 bg, void* src, u8 srcX, u8 srcY, u8 srcWid
{
for (destX16 = destX; destX16 < (destX + rectWidth); destX16++)
{
- CopyTileMapEntry(&((u16*)srcCopy)[(srcY * rectWidth) + srcX], &((u16*)gGpuBgConfigs2[bg].tilemap)[GetTileMapIndexFromCoords(destX16, destY16, attribute, mode, mode2)], palette1, tileOffset, palette2);
+ CopyTileMapEntry(&((u16*)srcCopy)[(srcY * rectWidth) + srcX], &((u16*)sGpuBgConfigs2[bg].tilemap)[GetTileMapIndexFromCoords(destX16, destY16, attribute, mode, mode2)], palette1, tileOffset, palette2);
}
}
break;
@@ -1067,7 +1041,7 @@ void CopyRectToBgTilemapBufferRect(u8 bg, void* src, u8 srcX, u8 srcY, u8 srcWid
{
for (destX16 = destX; destX16 < (destX + rectWidth); destX16++)
{
- CopyTileMapEntry(&((u16*)srcCopy)[(srcY * rectWidth) + srcX], &((u16*)gGpuBgConfigs2[bg].tilemap)[GetTileMapIndexFromCoords(destX16, destY16, attribute, mode, mode2)], palette1, tileOffset, palette2);
+ CopyTileMapEntry(&((u16*)srcCopy)[(srcY * rectWidth) + srcX], &((u16*)sGpuBgConfigs2[bg].tilemap)[GetTileMapIndexFromCoords(destX16, destY16, attribute, mode, mode2)], palette1, tileOffset, palette2);
}
}
break;
@@ -1195,7 +1169,7 @@ _080025F8:\n\
bge _0800265A\n\
ldr r2, [sp, #0x4]\n\
lsl r0, r2, #4\n\
- ldr r1, =gGpuBgConfigs2+4\n\
+ ldr r1, =sGpuBgConfigs2+4\n\
add r0, r1\n\
mov r10, r0\n\
ldr r7, [sp, #0x20]\n\
@@ -1267,7 +1241,7 @@ _08002674:\n\
sub r2, r7, r2\n\
str r2, [sp, #0x34]\n\
str r0, [sp, #0x38]\n\
- ldr r7, =gGpuBgConfigs2+4\n\
+ ldr r7, =sGpuBgConfigs2+4\n\
mov r10, r7\n\
ldr r0, [sp, #0x4]\n\
lsl r0, #4\n\
@@ -1337,7 +1311,7 @@ void FillBgTilemapBufferRect_Palette0(u8 bg, u16 tileNum, u8 x, u8 y, u8 width,
{
for (x16 = x; x16 < (x + width); x16++)
{
- ((u16*)gGpuBgConfigs2[bg].tilemap)[((y16 * 0x20) + x16)] = tileNum;
+ ((u16*)sGpuBgConfigs2[bg].tilemap)[((y16 * 0x20) + x16)] = tileNum;
}
}
break;
@@ -1347,7 +1321,7 @@ void FillBgTilemapBufferRect_Palette0(u8 bg, u16 tileNum, u8 x, u8 y, u8 width,
{
for (x16 = x; x16 < (x + width); x16++)
{
- ((u8*)gGpuBgConfigs2[bg].tilemap)[((y16 * mode) + x16)] = tileNum;
+ ((u8*)sGpuBgConfigs2[bg].tilemap)[((y16 * mode) + x16)] = tileNum;
}
}
break;
@@ -1382,7 +1356,7 @@ void WriteSequenceToBgTilemapBuffer(u8 bg, u16 firstTileNum, u8 x, u8 y, u8 widt
{
for (x16 = x; x16 < (x + width); x16++)
{
- CopyTileMapEntry(&firstTileNum, &((u16*)gGpuBgConfigs2[bg].tilemap)[(u16)GetTileMapIndexFromCoords(x16, y16, attribute, mode, mode2)], paletteSlot, 0, 0);
+ CopyTileMapEntry(&firstTileNum, &((u16*)sGpuBgConfigs2[bg].tilemap)[(u16)GetTileMapIndexFromCoords(x16, y16, attribute, mode, mode2)], paletteSlot, 0, 0);
firstTileNum = (firstTileNum & 0xFC00) + ((firstTileNum + tileNumDelta) & 0x3FF);
}
}
@@ -1393,7 +1367,7 @@ void WriteSequenceToBgTilemapBuffer(u8 bg, u16 firstTileNum, u8 x, u8 y, u8 widt
{
for (x16 = x; x16 < (x + width); x16++)
{
- ((u8*)gGpuBgConfigs2[bg].tilemap)[(y16 * mode3) + x16] = firstTileNum;
+ ((u8*)sGpuBgConfigs2[bg].tilemap)[(y16 * mode3) + x16] = firstTileNum;
firstTileNum = (firstTileNum & 0xFC00) + ((firstTileNum + tileNumDelta) & 0x3FF);
}
}
@@ -1625,9 +1599,9 @@ bool32 IsInvalidBg32(u8 bg)
bool32 IsTileMapOutsideWram(u8 bg)
{
- if (gGpuBgConfigs2[bg].tilemap > (void*)IWRAM_END)
+ if (sGpuBgConfigs2[bg].tilemap > (void*)IWRAM_END)
return TRUE;
- if (gGpuBgConfigs2[bg].tilemap == 0x0)
+ if (sGpuBgConfigs2[bg].tilemap == 0x0)
return TRUE;
return FALSE;
}
diff --git a/src/dma3_manager.c b/src/dma3_manager.c
index 6d12dec05..7cce06c15 100644
--- a/src/dma3_manager.c
+++ b/src/dma3_manager.c
@@ -14,7 +14,7 @@ void ClearDma3Requests(void)
gDma3Requests[i].src = 0;
gDma3Requests[i].dest = 0;
}
-
+
gDma3ManagerLocked = FALSE;
}
@@ -24,7 +24,7 @@ void ProcessDma3Requests(void)
// NOTE: the fillerA member of the DMA struct is actually u32 value;
// NOTE: gUnknown_0300001C is just a pointer inside the gDma3Requests structure, not a true symbol; feel free to remove
u16 total_size;
-
+
if (gDma3ManagerLocked)
return;
@@ -34,7 +34,7 @@ void ProcessDma3Requests(void)
while (gDma3Requests[gDma3RequestCursor].size)
{
total_size += gDma3Requests[gDma3RequestCursor].size;
-
+
if (total_size > 0xA000)
return; // don't do too much at once
@@ -90,14 +90,14 @@ void ProcessDma3Requests(void)
}
DmaFill16(3, gDma3Requests[gDma3RequestCursor].value, gDma3Requests[gDma3RequestCursor].dest, gDma3Requests[gDma3RequestCursor].size);
break;
- }
- gDma3Requests[gDma3RequestCursor].src = 0;
- gDma3Requests[gDma3RequestCursor].dest = 0;
+ }
+ gDma3Requests[gDma3RequestCursor].src = NULL;
+ gDma3Requests[gDma3RequestCursor].dest = NULL;
gDma3Requests[gDma3RequestCursor].size = 0;
gDma3Requests[gDma3RequestCursor].mode = 0;
gDma3Requests[gDma3RequestCursor].value = 0;
gDma3RequestCursor++;
-
+
if (gDma3RequestCursor >= 128) // loop back to the first DMA request
gDma3RequestCursor = 0;
}
@@ -419,13 +419,13 @@ _08000E46:\n\
}
#endif
-int RequestDma3Copy(void *src, void *dest, u16 size, u8 mode)
+int RequestDma3Copy(const void *src, void *dest, u16 size, u8 mode)
{
int cursor;
int var = 0;
-
+
gDma3ManagerLocked = 1;
-
+
cursor = gDma3RequestCursor;
while(1)
{
@@ -434,12 +434,12 @@ int RequestDma3Copy(void *src, void *dest, u16 size, u8 mode)
gDma3Requests[cursor].src = src;
gDma3Requests[cursor].dest = dest;
gDma3Requests[cursor].size = size;
-
+
if(mode == 1)
gDma3Requests[cursor].mode = mode;
else
gDma3Requests[cursor].mode = 3;
-
+
gDma3ManagerLocked = FALSE;
return (s16)cursor;
}
@@ -460,10 +460,10 @@ int RequestDma3Fill(s32 value, void *dest, u16 size, u8 mode)
{
int cursor;
int var = 0;
-
+
cursor = gDma3RequestCursor;
gDma3ManagerLocked = 1;
-
+
while(1)
{
if(!gDma3Requests[cursor].size)
@@ -477,7 +477,7 @@ int RequestDma3Fill(s32 value, void *dest, u16 size, u8 mode)
gDma3Requests[cursor].mode = 2;
else
gDma3Requests[cursor].mode = 4;
-
+
gDma3ManagerLocked = FALSE;
return (s16)cursor;
}
@@ -503,9 +503,9 @@ int CheckForSpaceForDma3Request(s16 index)
for (; current < 0x80; current ++)
if (gDma3Requests[current].size)
return -1;
-
+
return 0;
- }
+ }
if (gDma3Requests[index].size)
return -1;
diff --git a/src/egg_hatch.c b/src/egg_hatch.c
new file mode 100644
index 000000000..6d14e92f0
--- /dev/null
+++ b/src/egg_hatch.c
@@ -0,0 +1,893 @@
+#include "global.h"
+#include "pokemon.h"
+#include "pokedex.h"
+#include "items.h"
+#include "script.h"
+#include "decompress.h"
+#include "task.h"
+#include "palette.h"
+#include "main.h"
+#include "event_data.h"
+#include "sound.h"
+#include "songs.h"
+#include "text.h"
+#include "text_window.h"
+#include "string_util.h"
+#include "menu.h"
+#include "trig.h"
+#include "rng.h"
+#include "malloc.h"
+#include "dma3.h"
+#include "gpu_regs.h"
+#include "bg.h"
+#include "m4a.h"
+#include "window.h"
+#include "abilities.h"
+#include "battle.h" // to get rid of later
+
+struct EggHatchData
+{
+ u8 eggSpriteID;
+ u8 pokeSpriteID;
+ u8 CB2_state;
+ u8 CB2_PalCounter;
+ u8 eggPartyID;
+ u8 unused_5;
+ u8 unused_6;
+ u8 eggShardVelocityID;
+ u8 windowId;
+ u8 unused_9;
+ u8 unused_A;
+ u16 species;
+ struct TextColor textColor;
+};
+
+extern struct SpriteTemplate gUnknown_0202499C;
+extern void (*gFieldCallback)(void);
+
+extern const struct CompressedSpriteSheet gMonFrontPicTable[];
+extern const u8 gUnknown_08C00000[];
+extern const u8 gUnknown_08C00524[];
+extern const u8 gUnknown_08C004E0[];
+extern const u16 gUnknown_08DD7300[]; // palette, gameboy advance
+extern const u32 gUnknown_08DD7360[]; // tileset gameboy advance
+extern const u32 gUnknown_08331F60[]; // tilemap gameboy circle
+extern const u8 gText_HatchedFromEgg[];
+extern const u8 gText_NickHatchPrompt[];
+
+extern u8* GetMonNick(struct Pokemon* mon, u8* dst);
+extern u8* GetBoxMonNick(struct BoxPokemon* boxMon, u8* dst);
+extern u8 sav1_map_get_name(void);
+extern s8 sub_8198C58(void);
+extern void sub_81DB5E8(u8* str1, u8* str2, u8);
+extern void sub_806A068(u16, u8);
+extern void fade_screen(u8, u8);
+extern void overworld_free_bg_tilemaps(void);
+extern void sub_80AF168(void);
+extern void init_uns_table_pokemon_copy(void);
+extern void sub_805F094(void);
+extern void remove_some_task(void);
+extern void reset_temp_tile_data_buffers(void);
+extern void c2_exit_to_overworld_2_switch(void);
+extern void play_some_sound(void);
+extern void copy_decompressed_tile_data_to_vram_autofree(u8 bg_id, const void* src, u16 size, u16 offset, u8 mode);
+extern void CreateYesNoMenu(const struct WindowTemplate*, u16, u8, u8);
+extern void DoNamingScreen(u8, const u8*, u16, u8, u32, MainCallback);
+extern void AddTextPrinterParametrized2(u8 windowId, u8 fontId, u8 x, u8 y, u8 letterSpacing, u8 lineSpacing, struct TextColor* colors, s8 speed, u8 *str);
+extern u16 sub_80D22D0(void);
+extern u8 sub_80C7050(u8);
+
+static void Task_EggHatch(u8 taskID);
+static void CB2_EggHatch_0(void);
+static void CB2_EggHatch_1(void);
+static void SpriteCB_Egg_0(struct Sprite* sprite);
+static void SpriteCB_Egg_1(struct Sprite* sprite);
+static void SpriteCB_Egg_2(struct Sprite* sprite);
+static void SpriteCB_Egg_3(struct Sprite* sprite);
+static void SpriteCB_Egg_4(struct Sprite* sprite);
+static void SpriteCB_Egg_5(struct Sprite* sprite);
+static void SpriteCB_EggShard(struct Sprite* sprite);
+static void EggHatchPrintMessage(u8 windowId, u8* string, u8 x, u8 y, u8 speed);
+static void CreateRandomEggShardSprite(void);
+static void CreateEggShardSprite(u8 x, u8 y, s16 data1, s16 data2, s16 data3, u8 spriteAnimIndex);
+
+// IWRAM bss
+static IWRAM_DATA struct EggHatchData* sEggHatchData;
+
+// rom data
+static const u16 sEggPalette[] = INCBIN_U16("graphics/pokemon/palettes/egg_palette.gbapal");
+static const u8 sEggHatchTiles[] = INCBIN_U8("graphics/misc/egg_hatch.4bpp");
+static const u8 sEggShardTiles[] = INCBIN_U8("graphics/misc/egg_shard.4bpp");
+
+static const struct OamData sOamData_EggHatch =
+{
+ .y = 0,
+ .affineMode = 0,
+ .objMode = 0,
+ .mosaic = 0,
+ .bpp = 0,
+ .shape = 0,
+ .x = 0,
+ .matrixNum = 0,
+ .size = 2,
+ .tileNum = 0,
+ .priority = 1,
+ .paletteNum = 0,
+ .affineParam = 0,
+};
+
+static const union AnimCmd sSpriteAnim_EggHatch0[] =
+{
+ ANIMCMD_FRAME(0, 5),
+ ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnim_EggHatch1[] =
+{
+ ANIMCMD_FRAME(16, 5),
+ ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnim_EggHatch2[] =
+{
+ ANIMCMD_FRAME(32, 5),
+ ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnim_EggHatch3[] =
+{
+ ANIMCMD_FRAME(48, 5),
+ ANIMCMD_END
+};
+
+static const union AnimCmd *const sSpriteAnimTable_EggHatch[] =
+{
+ sSpriteAnim_EggHatch0,
+ sSpriteAnim_EggHatch1,
+ sSpriteAnim_EggHatch2,
+ sSpriteAnim_EggHatch3,
+};
+
+static const struct SpriteSheet sEggHatch_Sheet =
+{
+ .data = sEggHatchTiles,
+ .size = 2048,
+ .tag = 12345,
+};
+
+static const struct SpriteSheet sEggShards_Sheet =
+{
+ .data = sEggShardTiles,
+ .size = 128,
+ .tag = 23456,
+};
+
+static const struct SpritePalette sEgg_SpritePalette =
+{
+ .data = sEggPalette,
+ .tag = 54321
+};
+
+static const struct SpriteTemplate sSpriteTemplate_EggHatch =
+{
+ .tileTag = 12345,
+ .paletteTag = 54321,
+ .oam = &sOamData_EggHatch,
+ .anims = sSpriteAnimTable_EggHatch,
+ .images = NULL,
+ .affineAnims = gDummySpriteAffineAnimTable,
+ .callback = SpriteCallbackDummy
+};
+
+static const struct OamData sOamData_EggShard =
+{
+ .y = 0,
+ .affineMode = 0,
+ .objMode = 0,
+ .mosaic = 0,
+ .bpp = 0,
+ .shape = 0,
+ .x = 0,
+ .matrixNum = 0,
+ .size = 0,
+ .tileNum = 0,
+ .priority = 2,
+ .paletteNum = 0,
+ .affineParam = 0,
+};
+
+static const union AnimCmd sSpriteAnim_EggShard0[] =
+{
+ ANIMCMD_FRAME(0, 5),
+ ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnim_EggShard1[] =
+{
+ ANIMCMD_FRAME(1, 5),
+ ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnim_EggShard2[] =
+{
+ ANIMCMD_FRAME(2, 5),
+ ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnim_EggShard3[] =
+{
+ ANIMCMD_FRAME(3, 5),
+ ANIMCMD_END
+};
+
+static const union AnimCmd *const sSpriteAnimTable_EggShard[] =
+{
+ sSpriteAnim_EggShard0,
+ sSpriteAnim_EggShard1,
+ sSpriteAnim_EggShard2,
+ sSpriteAnim_EggShard3,
+};
+
+static const struct SpriteTemplate sSpriteTemplate_EggShard =
+{
+ .tileTag = 23456,
+ .paletteTag = 54321,
+ .oam = &sOamData_EggShard,
+ .anims = sSpriteAnimTable_EggShard,
+ .images = NULL,
+ .affineAnims = gDummySpriteAffineAnimTable,
+ .callback = SpriteCB_EggShard
+};
+
+static const struct BgTemplate sBgTemplates_EggHatch[2] =
+{
+ {
+ .bg = 0,
+ .charBaseIndex = 2,
+ .mapBaseIndex = 24,
+ .screenSize = 3,
+ .paletteMode = 0,
+ .priority = 0,
+ .baseTile = 0
+ },
+
+ {
+ .bg = 1,
+ .charBaseIndex = 0,
+ .mapBaseIndex = 8,
+ .screenSize = 1,
+ .paletteMode = 0,
+ .priority = 2,
+ .baseTile = 0
+ },
+};
+
+static const struct WindowTemplate sWinTemplates_EggHatch[2] =
+{
+ {0, 2, 0xF, 0x1A, 4, 0, 0x40},
+ DUMMY_WIN_TEMPLATE
+};
+
+static const struct WindowTemplate sYesNoWinTemplate =
+{
+ 0, 0x15, 9, 5, 4, 0xF, 0x1A8
+};
+
+static const s16 sEggShardVelocities[][2] =
+{
+ {Q_8_8(-1.5), Q_8_8(-3.75)},
+ {Q_8_8(-5), Q_8_8(-3)},
+ {Q_8_8(3.5), Q_8_8(-3)},
+ {Q_8_8(-4), Q_8_8(-3.75)},
+ {Q_8_8(2), Q_8_8(-1.5)},
+ {Q_8_8(-0.5), Q_8_8(-6.75)},
+ {Q_8_8(5), Q_8_8(-2.25)},
+ {Q_8_8(-1.5), Q_8_8(-3.75)},
+ {Q_8_8(4.5), Q_8_8(-1.5)},
+ {Q_8_8(-1), Q_8_8(-6.75)},
+ {Q_8_8(4), Q_8_8(-2.25)},
+ {Q_8_8(-3.5), Q_8_8(-3.75)},
+ {Q_8_8(1), Q_8_8(-1.5)},
+ {Q_8_8(-3.515625), Q_8_8(-6.75)},
+ {Q_8_8(4.5), Q_8_8(-2.25)},
+ {Q_8_8(-0.5), Q_8_8(-7.5)},
+ {Q_8_8(1), Q_8_8(-4.5)},
+ {Q_8_8(-2.5), Q_8_8(-2.25)},
+ {Q_8_8(2.5), Q_8_8(-7.5)},
+};
+
+// code
+
+static void CreatedHatchedMon(struct Pokemon *egg, struct Pokemon *temp)
+{
+ u16 species;
+ u32 personality, pokerus;
+ u8 i, friendship, language, gameMet, markings, obedience;
+ u16 moves[4];
+ u32 ivs[6];
+
+
+ species = GetMonData(egg, MON_DATA_SPECIES);
+
+ for (i = 0; i < 4; i++)
+ {
+ moves[i] = GetMonData(egg, MON_DATA_MOVE1 + i);
+ }
+
+ personality = GetMonData(egg, MON_DATA_PERSONALITY);
+
+ for (i = 0; i < 6; i++)
+ {
+ ivs[i] = GetMonData(egg, MON_DATA_HP_IV + i);
+ }
+
+ language = GetMonData(egg, MON_DATA_LANGUAGE);
+ gameMet = GetMonData(egg, MON_DATA_MET_GAME);
+ markings = GetMonData(egg, MON_DATA_MARKINGS);
+ pokerus = GetMonData(egg, MON_DATA_POKERUS);
+ obedience = GetMonData(egg, MON_DATA_OBEDIENCE);
+
+ CreateMon(temp, species, 5, 32, TRUE, personality, 0, 0);
+
+ for (i = 0; i < 4; i++)
+ {
+ SetMonData(temp, MON_DATA_MOVE1 + i, &moves[i]);
+ }
+
+ for (i = 0; i < 6; i++)
+ {
+ SetMonData(temp, MON_DATA_HP_IV + i, &ivs[i]);
+ }
+
+ language = GAME_LANGUAGE;
+ SetMonData(temp, MON_DATA_LANGUAGE, &language);
+ SetMonData(temp, MON_DATA_MET_GAME, &gameMet);
+ SetMonData(temp, MON_DATA_MARKINGS, &markings);
+
+ friendship = 120;
+ SetMonData(temp, MON_DATA_FRIENDSHIP, &friendship);
+ SetMonData(temp, MON_DATA_POKERUS, &pokerus);
+ SetMonData(temp, MON_DATA_OBEDIENCE, &obedience);
+
+ *egg = *temp;
+}
+
+static void AddHatchedMonToParty(u8 id)
+{
+ u8 isEgg = 0x46; // ?
+ u16 pokeNum;
+ u8 name[12];
+ u16 ball;
+ u16 caughtLvl;
+ u8 mapNameID;
+ struct Pokemon* mon = &gPlayerParty[id];
+
+ CreatedHatchedMon(mon, &gEnemyParty[0]);
+ SetMonData(mon, MON_DATA_IS_EGG, &isEgg);
+
+ pokeNum = GetMonData(mon, MON_DATA_SPECIES);
+ GetSpeciesName(name, pokeNum);
+ SetMonData(mon, MON_DATA_NICKNAME, name);
+
+ pokeNum = SpeciesToNationalPokedexNum(pokeNum);
+ GetSetPokedexFlag(pokeNum, FLAG_SET_SEEN);
+ GetSetPokedexFlag(pokeNum, FLAG_SET_CAUGHT);
+
+ GetMonNick(mon, gStringVar1);
+
+ ball = ITEM_POKE_BALL;
+ SetMonData(mon, MON_DATA_POKEBALL, &ball);
+
+ caughtLvl = 0;
+ SetMonData(mon, MON_DATA_MET_LEVEL, &caughtLvl);
+
+ mapNameID = sav1_map_get_name();
+ SetMonData(mon, MON_DATA_MET_LOCATION, &mapNameID);
+
+ MonRestorePP(mon);
+ CalculateMonStats(mon);
+}
+
+void ScriptHatchMon(void)
+{
+ AddHatchedMonToParty(gSpecialVar_0x8004);
+}
+
+static bool8 sub_807158C(struct DaycareData* daycare, u8 daycareId)
+{
+ u8 nick[0x20];
+ struct DaycareMon* daycareMon = &daycare->mons[daycareId];
+
+ GetBoxMonNick(&daycareMon->mon, nick);
+ if (daycareMon->mail.itemId != 0
+ && (StringCompareWithoutExtCtrlCodes(nick, daycareMon->monName) != 0
+ || StringCompareWithoutExtCtrlCodes(gSaveBlock2Ptr->playerName, daycareMon->OT_name) != 0))
+ {
+ StringCopy(gStringVar1, nick);
+ sub_81DB5E8(gStringVar2, daycareMon->OT_name, daycareMon->language_maybe);
+ sub_81DB5E8(gStringVar3, daycareMon->monName, daycareMon->unknown);
+ return TRUE;
+ }
+ return FALSE;
+}
+
+bool8 sub_8071614(void)
+{
+ return sub_807158C(&gSaveBlock1Ptr->daycare, gSpecialVar_0x8004);
+}
+
+static u8 EggHatchCreateMonSprite(u8 a0, u8 switchID, u8 pokeID, u16* speciesLoc)
+{
+ u8 r5 = 0;
+ u8 spriteID = 0;
+ struct Pokemon* mon = NULL;
+
+ if (a0 == 0)
+ {
+ mon = &gPlayerParty[pokeID];
+ r5 = 1;
+ }
+ if (a0 == 1)
+ {
+ mon = &gPlayerParty[pokeID];
+ r5 = 3;
+ }
+ switch (switchID)
+ {
+ case 0:
+ {
+ u16 species = GetMonData(mon, MON_DATA_SPECIES);
+ u32 pid = GetMonData(mon, MON_DATA_PERSONALITY);
+ HandleLoadSpecialPokePic_DontHandleDeoxys(&gMonFrontPicTable[species],
+ gBattleSpritesGfx->sprites[(a0 * 2) + 1],
+ species, pid);
+ LoadCompressedObjectPalette(sub_806E794(mon));
+ *speciesLoc = species;
+ }
+ break;
+ case 1:
+ sub_806A068(sub_806E794(mon)->tag, r5);
+ spriteID = CreateSprite(&gUnknown_0202499C, 120, 75, 6);
+ gSprites[spriteID].invisible = 1;
+ gSprites[spriteID].callback = SpriteCallbackDummy;
+ break;
+ }
+ return spriteID;
+}
+
+static void VBlankCB_EggHatch(void)
+{
+ LoadOam();
+ ProcessSpriteCopyRequests();
+ TransferPlttBuffer();
+}
+
+static void EggHatch(void)
+{
+ ScriptContext2_Enable();
+ CreateTask(Task_EggHatch, 10);
+ fade_screen(1, 0);
+}
+
+static void Task_EggHatch(u8 taskID)
+{
+ if (!gPaletteFade.active)
+ {
+ overworld_free_bg_tilemaps();
+ SetMainCallback2(CB2_EggHatch_0);
+ gFieldCallback = sub_80AF168;
+ DestroyTask(taskID);
+ }
+}
+
+static void CB2_EggHatch_0(void)
+{
+ switch (gMain.state)
+ {
+ case 0:
+ SetGpuReg(REG_OFFSET_DISPCNT, 0);
+
+ sEggHatchData = Alloc(sizeof(struct EggHatchData));
+ init_uns_table_pokemon_copy();
+ sEggHatchData->eggPartyID = gSpecialVar_0x8004;
+ sEggHatchData->eggShardVelocityID = 0;
+
+ SetVBlankCallback(VBlankCB_EggHatch);
+ gSpecialVar_0x8005 = GetCurrentMapMusic();
+
+ reset_temp_tile_data_buffers();
+ ResetBgsAndClearDma3BusyFlags(0);
+ InitBgsFromTemplates(0, sBgTemplates_EggHatch, ARRAY_COUNT(sBgTemplates_EggHatch));
+
+ ChangeBgX(1, 0, 0);
+ ChangeBgY(1, 0, 0);
+ ChangeBgX(0, 0, 0);
+ ChangeBgY(0, 0, 0);
+
+ SetBgAttribute(1, BG_CTRL_ATTR_MOSAIC, 2);
+ SetBgTilemapBuffer(1, Alloc(0x1000));
+ SetBgTilemapBuffer(0, Alloc(0x2000));
+
+ DeactivateAllTextPrinters();
+ ResetPaletteFade();
+ FreeAllSpritePalettes();
+ ResetSpriteData();
+ ResetTasks();
+ remove_some_task();
+ m4aSoundVSyncOn();
+ gMain.state++;
+ break;
+ case 1:
+ InitWindows(sWinTemplates_EggHatch);
+ sEggHatchData->windowId = 0;
+ gMain.state++;
+ break;
+ case 2:
+ copy_decompressed_tile_data_to_vram_autofree(0, gUnknown_08C00000, 0, 0, 0);
+ CopyToBgTilemapBuffer(0, gUnknown_08C00524, 0, 0);
+ LoadCompressedPalette(gUnknown_08C004E0, 0, 0x20);
+ gMain.state++;
+ break;
+ case 3:
+ LoadSpriteSheet(&sEggHatch_Sheet);
+ LoadSpriteSheet(&sEggShards_Sheet);
+ LoadSpritePalette(&sEgg_SpritePalette);
+ gMain.state++;
+ break;
+ case 4:
+ CopyBgTilemapBufferToVram(0);
+ AddHatchedMonToParty(sEggHatchData->eggPartyID);
+ gMain.state++;
+ break;
+ case 5:
+ EggHatchCreateMonSprite(0, 0, sEggHatchData->eggPartyID, &sEggHatchData->species);
+ gMain.state++;
+ break;
+ case 6:
+ sEggHatchData->pokeSpriteID = EggHatchCreateMonSprite(0, 1, sEggHatchData->eggPartyID, &sEggHatchData->species);
+ gMain.state++;
+ break;
+ case 7:
+ SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP);
+ LoadPalette(gUnknown_08DD7300, 0x10, 0xA0);
+ LoadBgTiles(1, gUnknown_08DD7360, 0x1420, 0);
+ CopyToBgTilemapBuffer(1, gUnknown_08331F60, 0x1000, 0);
+ CopyBgTilemapBufferToVram(1);
+ gMain.state++;
+ break;
+ case 8:
+ SetMainCallback2(CB2_EggHatch_1);
+ sEggHatchData->CB2_state = 0;
+ break;
+ }
+ RunTasks();
+ RunTextPrinters();
+ AnimateSprites();
+ BuildOamBuffer();
+ UpdatePaletteFade();
+}
+
+static void EggHatchSetMonNickname(void)
+{
+ SetMonData(&gPlayerParty[gSpecialVar_0x8004], MON_DATA_NICKNAME, gStringVar3);
+ sub_805F094();
+ Free(sEggHatchData);
+ SetMainCallback2(c2_exit_to_overworld_2_switch);
+}
+
+static void Task_EggHatchPlayBGM(u8 taskID)
+{
+ if (gTasks[taskID].data[0] == 0)
+ {
+ StopMapMusic();
+ play_some_sound();
+ }
+ if (gTasks[taskID].data[0] == 1)
+ PlayBGM(376);
+ if (gTasks[taskID].data[0] > 60)
+ {
+ PlayBGM(377);
+ DestroyTask(taskID);
+ // UB: task is destroyed, yet the value is incremented
+ }
+ gTasks[taskID].data[0]++;
+}
+
+static void CB2_EggHatch_1(void)
+{
+ u16 species;
+ u8 gender;
+ u32 personality;
+
+ switch (sEggHatchData->CB2_state)
+ {
+ case 0:
+ BeginNormalPaletteFade(-1, 0, 0x10, 0, 0);
+ sEggHatchData->eggSpriteID = CreateSprite(&sSpriteTemplate_EggHatch, 120, 75, 5);
+ ShowBg(0);
+ ShowBg(1);
+ sEggHatchData->CB2_state++;
+ CreateTask(Task_EggHatchPlayBGM, 5);
+ break;
+ case 1:
+ if (!gPaletteFade.active)
+ {
+ FillWindowPixelBuffer(sEggHatchData->windowId, 0);
+ sEggHatchData->CB2_PalCounter = 0;
+ sEggHatchData->CB2_state++;
+ }
+ break;
+ case 2:
+ if (++sEggHatchData->CB2_PalCounter > 30)
+ {
+ sEggHatchData->CB2_state++;
+ gSprites[sEggHatchData->eggSpriteID].callback = SpriteCB_Egg_0;
+ }
+ break;
+ case 3:
+ if (gSprites[sEggHatchData->eggSpriteID].callback == SpriteCallbackDummy)
+ {
+ species = GetMonData(&gPlayerParty[sEggHatchData->eggPartyID], MON_DATA_SPECIES);
+ DoMonFrontSpriteAnimation(&gSprites[sEggHatchData->pokeSpriteID], species, FALSE, 1);
+ sEggHatchData->CB2_state++;
+ }
+ break;
+ case 4:
+ if (gSprites[sEggHatchData->pokeSpriteID].callback == SpriteCallbackDummy)
+ {
+ sEggHatchData->CB2_state++;
+ }
+ break;
+ case 5:
+ GetMonNick(&gPlayerParty[sEggHatchData->eggPartyID], gStringVar1);
+ StringExpandPlaceholders(gStringVar4, gText_HatchedFromEgg);
+ EggHatchPrintMessage(sEggHatchData->windowId, gStringVar4, 0, 3, 0xFF);
+ PlayFanfare(371);
+ sEggHatchData->CB2_state++;
+ PutWindowTilemap(sEggHatchData->windowId);
+ CopyWindowToVram(sEggHatchData->windowId, 3);
+ break;
+ case 6:
+ if (IsFanfareTaskInactive())
+ sEggHatchData->CB2_state++;
+ break;
+ case 7:
+ if (IsFanfareTaskInactive())
+ sEggHatchData->CB2_state++;
+ break;
+ case 8:
+ GetMonNick(&gPlayerParty[sEggHatchData->eggPartyID], gStringVar1);
+ StringExpandPlaceholders(gStringVar4, gText_NickHatchPrompt);
+ EggHatchPrintMessage(sEggHatchData->windowId, gStringVar4, 0, 2, 1);
+ sEggHatchData->CB2_state++;
+ break;
+ case 9:
+ if (!IsTextPrinterActive(sEggHatchData->windowId))
+ {
+ sub_809882C(sEggHatchData->windowId, 0x140, 0xE0);
+ CreateYesNoMenu(&sYesNoWinTemplate, 0x140, 0xE, 0);
+ sEggHatchData->CB2_state++;
+ }
+ break;
+ case 10:
+ switch (sub_8198C58())
+ {
+ case 0:
+ GetMonNick(&gPlayerParty[sEggHatchData->eggPartyID], gStringVar3);
+ species = GetMonData(&gPlayerParty[sEggHatchData->eggPartyID], MON_DATA_SPECIES);
+ gender = GetMonGender(&gPlayerParty[sEggHatchData->eggPartyID]);
+ personality = GetMonData(&gPlayerParty[sEggHatchData->eggPartyID], MON_DATA_PERSONALITY, 0);
+ DoNamingScreen(3, gStringVar3, species, gender, personality, EggHatchSetMonNickname);
+ break;
+ case 1:
+ case -1:
+ sEggHatchData->CB2_state++;
+ }
+ break;
+ case 11:
+ BeginNormalPaletteFade(-1, 0, 0, 0x10, 0);
+ sEggHatchData->CB2_state++;
+ break;
+ case 12:
+ if (!gPaletteFade.active)
+ {
+ sub_805F094();
+ RemoveWindow(sEggHatchData->windowId);
+ UnsetBgTilemapBuffer(0);
+ UnsetBgTilemapBuffer(1);
+ Free(sEggHatchData);
+ SetMainCallback2(c2_exit_to_overworld_2_switch);
+ }
+ break;
+ }
+
+ RunTasks();
+ RunTextPrinters();
+ AnimateSprites();
+ BuildOamBuffer();
+ UpdatePaletteFade();
+}
+
+static void SpriteCB_Egg_0(struct Sprite* sprite)
+{
+ if (++sprite->data0 > 20)
+ {
+ sprite->callback = SpriteCB_Egg_1;
+ sprite->data0 = 0;
+ }
+ else
+ {
+ sprite->data1 = (sprite->data1 + 20) & 0xFF;
+ sprite->pos2.x = Sin(sprite->data1, 1);
+ if (sprite->data0 == 15)
+ {
+ PlaySE(SE_BOWA);
+ StartSpriteAnim(sprite, 1);
+ CreateRandomEggShardSprite();
+ }
+ }
+}
+
+static void SpriteCB_Egg_1(struct Sprite* sprite)
+{
+ if (++sprite->data2 > 30)
+ {
+ if (++sprite->data0 > 20)
+ {
+ sprite->callback = SpriteCB_Egg_2;
+ sprite->data0 = 0;
+ sprite->data2 = 0;
+ }
+ else
+ {
+ sprite->data1 = (sprite->data1 + 20) & 0xFF;
+ sprite->pos2.x = Sin(sprite->data1, 2);
+ if (sprite->data0 == 15)
+ {
+ PlaySE(SE_BOWA);
+ StartSpriteAnim(sprite, 2);
+ }
+ }
+ }
+}
+
+static void SpriteCB_Egg_2(struct Sprite* sprite)
+{
+ if (++sprite->data2 > 30)
+ {
+ if (++sprite->data0 > 38)
+ {
+ u16 species;
+
+ sprite->callback = SpriteCB_Egg_3;
+ sprite->data0 = 0;
+ species = GetMonData(&gPlayerParty[sEggHatchData->eggPartyID], MON_DATA_SPECIES);
+ gSprites[sEggHatchData->pokeSpriteID].pos2.x = 0;
+ gSprites[sEggHatchData->pokeSpriteID].pos2.y = 0;
+ }
+ else
+ {
+ sprite->data1 = (sprite->data1 + 20) & 0xFF;
+ sprite->pos2.x = Sin(sprite->data1, 2);
+ if (sprite->data0 == 15)
+ {
+ PlaySE(SE_BOWA);
+ StartSpriteAnim(sprite, 2);
+ CreateRandomEggShardSprite();
+ CreateRandomEggShardSprite();
+ }
+ if (sprite->data0 == 30)
+ PlaySE(SE_BOWA);
+ }
+ }
+}
+
+static void SpriteCB_Egg_3(struct Sprite* sprite)
+{
+ if (++sprite->data0 > 50)
+ {
+ sprite->callback = SpriteCB_Egg_4;
+ sprite->data0 = 0;
+ }
+}
+
+static void SpriteCB_Egg_4(struct Sprite* sprite)
+{
+ s16 i;
+ if (sprite->data0 == 0)
+ BeginNormalPaletteFade(-1, -1, 0, 0x10, 0xFFFF);
+ if (sprite->data0 < 4u)
+ {
+ for (i = 0; i <= 3; i++)
+ CreateRandomEggShardSprite();
+ }
+ sprite->data0++;
+ if (!gPaletteFade.active)
+ {
+ PlaySE(SE_TAMAGO);
+ sprite->invisible = 1;
+ sprite->callback = SpriteCB_Egg_5;
+ sprite->data0 = 0;
+ }
+}
+
+static void SpriteCB_Egg_5(struct Sprite* sprite)
+{
+ if (sprite->data0 == 0)
+ {
+ gSprites[sEggHatchData->pokeSpriteID].invisible = 0;
+ StartSpriteAffineAnim(&gSprites[sEggHatchData->pokeSpriteID], 1);
+ }
+ if (sprite->data0 == 8)
+ BeginNormalPaletteFade(-1, -1, 0x10, 0, 0xFFFF);
+ if (sprite->data0 <= 9)
+ gSprites[sEggHatchData->pokeSpriteID].pos1.y -= 1;
+ if (sprite->data0 > 40)
+ sprite->callback = SpriteCallbackDummy;
+ sprite->data0++;
+}
+
+static void SpriteCB_EggShard(struct Sprite* sprite)
+{
+ sprite->data4 += sprite->data1;
+ sprite->data5 += sprite->data2;
+
+ sprite->pos2.x = sprite->data4 / 256;
+ sprite->pos2.y = sprite->data5 / 256;
+
+ sprite->data2 += sprite->data3;
+
+ if (sprite->pos1.y + sprite->pos2.y > sprite->pos1.y + 20 && sprite->data2 > 0)
+ DestroySprite(sprite);
+}
+
+static void CreateRandomEggShardSprite(void)
+{
+ u16 spriteAnimIndex;
+
+ s16 velocity1 = sEggShardVelocities[sEggHatchData->eggShardVelocityID][0];
+ s16 velocity2 = sEggShardVelocities[sEggHatchData->eggShardVelocityID][1];
+ sEggHatchData->eggShardVelocityID++;
+ spriteAnimIndex = Random() % 4;
+ CreateEggShardSprite(120, 60, velocity1, velocity2, 100, spriteAnimIndex);
+}
+
+static void CreateEggShardSprite(u8 x, u8 y, s16 data1, s16 data2, s16 data3, u8 spriteAnimIndex)
+{
+ u8 spriteID = CreateSprite(&sSpriteTemplate_EggShard, x, y, 4);
+ gSprites[spriteID].data1 = data1;
+ gSprites[spriteID].data2 = data2;
+ gSprites[spriteID].data3 = data3;
+ StartSpriteAnim(&gSprites[spriteID], spriteAnimIndex);
+}
+
+static void EggHatchPrintMessage(u8 windowId, u8* string, u8 x, u8 y, u8 speed)
+{
+ FillWindowPixelBuffer(windowId, 0xFF);
+ sEggHatchData->textColor.fgColor = 0;
+ sEggHatchData->textColor.bgColor = 5;
+ sEggHatchData->textColor.shadowColor = 6;
+ AddTextPrinterParametrized2(windowId, 1, x, y, 0, 0, &sEggHatchData->textColor, speed, string);
+}
+
+u8 GetEggStepsToSubtract(void)
+{
+ u8 count, i;
+ for (count = CalculatePlayerPartyCount(), i = 0; i < count; i++)
+ {
+ if (!GetMonData(&gPlayerParty[i], MON_DATA_SANITY_BIT3))
+ {
+ u8 ability = GetMonAbility(&gPlayerParty[i]);
+ if (ability == ABILITY_MAGMA_ARMOR || ability == ABILITY_FLAME_BODY)
+ return 2;
+ }
+ }
+ return 1;
+}
+
+u16 sub_80722E0(void)
+{
+ u16 value = sub_80D22D0();
+ value += sub_80C7050(6);
+ return value;
+}
diff --git a/src/gpu_regs.c b/src/gpu_regs.c
index be1f153d4..805f23b48 100644
--- a/src/gpu_regs.c
+++ b/src/gpu_regs.c
@@ -1,4 +1,5 @@
#include "global.h"
+#include "gpu_regs.h"
#define GPU_REG_BUF_SIZE 0x60
@@ -14,14 +15,15 @@ static bool8 sShouldSyncRegIE;
static u16 sRegIE;
static void CopyBufferedValueToGpuReg(u8 regOffset);
-static void SyncRegIE();
+static void SyncRegIE(void);
static void UpdateRegDispstatIntrBits(u16 regIE);
-void InitGpuRegManager()
+void InitGpuRegManager(void)
{
s32 i;
- for (i = 0; i < GPU_REG_BUF_SIZE; i++) {
+ for (i = 0; i < GPU_REG_BUF_SIZE; i++)
+ {
sGpuRegBuffer[i] = 0;
sGpuRegWaitingList[i] = EMPTY_SLOT;
}
@@ -33,20 +35,25 @@ void InitGpuRegManager()
static void CopyBufferedValueToGpuReg(u8 regOffset)
{
- if (regOffset == REG_OFFSET_DISPSTAT) {
+ if (regOffset == REG_OFFSET_DISPSTAT)
+ {
REG_DISPSTAT &= ~(DISPSTAT_HBLANK_INTR | DISPSTAT_VBLANK_INTR);
REG_DISPSTAT |= GPU_REG_BUF(REG_OFFSET_DISPSTAT);
- } else {
+ }
+ else
+ {
GPU_REG(regOffset) = GPU_REG_BUF(regOffset);
}
}
-void CopyBufferedValuesToGpuRegs()
+void CopyBufferedValuesToGpuRegs(void)
{
- if (!sGpuRegBufferLocked) {
+ if (!sGpuRegBufferLocked)
+ {
s32 i;
- for (i = 0; i < GPU_REG_BUF_SIZE; i++) {
+ for (i = 0; i < GPU_REG_BUF_SIZE; i++)
+ {
u8 regOffset = sGpuRegWaitingList[i];
if (regOffset == EMPTY_SLOT)
return;
@@ -135,7 +142,7 @@ void ClearGpuRegBits(u8 regOffset, u16 mask)
SetGpuReg(regOffset, regValue & ~mask);
}
-static void SyncRegIE()
+static void SyncRegIE(void)
{
if (sShouldSyncRegIE) {
u16 temp = REG_IME;
diff --git a/src/pokemon_3.c b/src/pokemon_3.c
index 569222e33..603732a34 100644
--- a/src/pokemon_3.c
+++ b/src/pokemon_3.c
@@ -1511,8 +1511,6 @@ static void Task_PokemonSummaryAnimateAfterDelay(u8 taskId)
}
}
-void DoMonFrontSpriteAnimation(struct Sprite* sprite, u16 species, bool8 noCry, u8 arg3);
-
void BattleAnimateFrontSprite(struct Sprite* sprite, u16 species, bool8 noCry, u8 arg3)
{
if (gHitMarker & HITMARKER_NO_ANIMATIONS && !(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_x2000000)))
diff --git a/src/safari_zone.c b/src/safari_zone.c
index fdfdd961a..3e25468bf 100644
--- a/src/safari_zone.c
+++ b/src/safari_zone.c
@@ -18,7 +18,7 @@ struct PokeblockFeeder
#define NUM_POKEBLOCK_FEEDERS 10
extern u8 gBattleOutcome;
-extern void* gUnknown_03005DAC;
+extern void* gFieldCallback;
extern u8 gUnknown_082A4B8A[];
extern u8 gUnknown_082A4B6F[];
@@ -118,7 +118,7 @@ void sub_80FC190(void)
{
ScriptContext2_RunNewScript(gUnknown_082A4B4C);
warp_in();
- gUnknown_03005DAC = sub_80AF6F0;
+ gFieldCallback = sub_80AF6F0;
SetMainCallback2(c2_load_new_map);
}
else if (gBattleOutcome == BATTLE_CAUGHT)
diff --git a/src/text.c b/src/text.c
index aa4e201c0..0081a8244 100644
--- a/src/text.c
+++ b/src/text.c
@@ -244,12 +244,11 @@ void RunTextPrinters(void)
}
}
-bool8 IsTextPrinterActive(u8 id)
+bool16 IsTextPrinterActive(u8 id)
{
return gTextPrinters[id].sub_union.sub.active;
}
-
u32 RenderFont(struct TextPrinter *textPrinter)
{
u32 ret;
diff --git a/src/trig.c b/src/trig.c
index e16a69e63..c2bca3059 100644
--- a/src/trig.c
+++ b/src/trig.c
@@ -1,12 +1,6 @@
#include "global.h"
#include "trig.h"
-// Converts a number to Q8.8 fixed-point format
-#define Q_8_8(n) ((s16)((n) * 256))
-
-// Converts a number to Q4.12 fixed-point format
-#define Q_4_12(n) ((s16)((n) * 4096))
-
// Values of sin(x*(π/128)) as Q8.8 fixed-point numbers from x = 0 to x = 319
const s16 gSineTable[] =
{
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-06 09:35:47 +0000