summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/braille_puzzles.c72
-rw-r--r--src/field_weather.c5
-rw-r--r--src/field_weather_effect.c721
3 files changed, 416 insertions, 382 deletions
diff --git a/src/braille_puzzles.c b/src/braille_puzzles.c
index 07b941f11..659f8682e 100644
--- a/src/braille_puzzles.c
+++ b/src/braille_puzzles.c
@@ -25,42 +25,42 @@ EWRAM_DATA static u8 sBraillePuzzleCallbackFlag = 0;
static const u8 gRegicePathCoords[][2] =
{
- {0x04, 0x15},
- {0x05, 0x15},
- {0x06, 0x15},
- {0x07, 0x15},
- {0x08, 0x15},
- {0x09, 0x15},
- {0x0a, 0x15},
- {0x0b, 0x15},
- {0x0c, 0x15},
- {0x0c, 0x16},
- {0x0c, 0x17},
- {0x0d, 0x17},
- {0x0d, 0x18},
- {0x0d, 0x19},
- {0x0d, 0x1a},
- {0x0d, 0x1b},
- {0x0c, 0x1b},
- {0x0c, 0x1c},
- {0x04, 0x1d},
- {0x05, 0x1d},
- {0x06, 0x1d},
- {0x07, 0x1d},
- {0x08, 0x1d},
- {0x09, 0x1d},
- {0x0a, 0x1d},
- {0x0b, 0x1d},
- {0x0c, 0x1d},
- {0x04, 0x1c},
- {0x04, 0x1b},
- {0x03, 0x1b},
- {0x03, 0x1a},
- {0x03, 0x19},
- {0x03, 0x18},
- {0x03, 0x17},
- {0x04, 0x17},
- {0x04, 0x16},
+ {4, 21},
+ {5, 21},
+ {6, 21},
+ {7, 21},
+ {8, 21},
+ {9, 21},
+ {10, 21},
+ {11, 21},
+ {12, 21},
+ {12, 22},
+ {12, 23},
+ {13, 23},
+ {13, 24},
+ {13, 25},
+ {13, 26},
+ {13, 27},
+ {12, 27},
+ {12, 28},
+ {4, 29},
+ {5, 29},
+ {6, 29},
+ {7, 29},
+ {8, 29},
+ {9, 29},
+ {10, 29},
+ {11, 29},
+ {12, 29},
+ {4, 28},
+ {4, 27},
+ {3, 27},
+ {3, 26},
+ {3, 25},
+ {3, 24},
+ {3, 23},
+ {4, 23},
+ {4, 22},
};
void SealedChamberShakingEffect(u8);
diff --git a/src/field_weather.c b/src/field_weather.c
index 9913e9a61..a2c40052b 100644
--- a/src/field_weather.c
+++ b/src/field_weather.c
@@ -167,7 +167,7 @@ void StartWeather(void)
gWeatherPtr->altGammaSpritePalIndex = index;
gWeatherPtr->weatherPicSpritePalIndex = AllocSpritePalette(0x1201);
gWeatherPtr->rainSpriteCount = 0;
- gWeatherPtr->unknown_6D8 = 0;
+ gWeatherPtr->curRainSpriteIndex = 0;
gWeatherPtr->cloudSpritesCreated = 0;
gWeatherPtr->snowflakeSpriteCount = 0;
gWeatherPtr->ashSpritesCreated = 0;
@@ -234,7 +234,8 @@ static void Task_WeatherMain(u8 taskId)
{
if (gWeatherPtr->currWeather != gWeatherPtr->nextWeather)
{
- if (!sWeatherFuncs[gWeatherPtr->currWeather].finish() && gWeatherPtr->palProcessingState != WEATHER_PAL_STATE_SCREEN_FADING_OUT)
+ if (!sWeatherFuncs[gWeatherPtr->currWeather].finish()
+ && gWeatherPtr->palProcessingState != WEATHER_PAL_STATE_SCREEN_FADING_OUT)
{
// Finished cleaning up previous weather. Now transition to next weather.
sWeatherFuncs[gWeatherPtr->nextWeather].initVars();
diff --git a/src/field_weather_effect.c b/src/field_weather_effect.c
index 6ec83f1a0..95f80d061 100644
--- a/src/field_weather_effect.c
+++ b/src/field_weather_effect.c
@@ -12,9 +12,6 @@
#include "trig.h"
#include "gpu_regs.h"
-// This file's functions.
-void sub_80AC6B4(struct Sprite *);
-
// EWRAM
EWRAM_DATA static u8 gCurrentAlternatingWeather = 0;
EWRAM_DATA static u16 gUnusedWeatherRelated = 0;
@@ -32,6 +29,12 @@ const u8 gWeatherAshTiles[] = INCBIN_U8("graphics/weather/ash.4bpp");
const u8 gWeatherRainTiles[] = INCBIN_U8("graphics/weather/rain.4bpp");
const u8 gWeatherSandstormTiles[] = INCBIN_U8("graphics/weather/sandstorm.4bpp");
+//------------------------------------------------------------------------------
+// Clouds
+//------------------------------------------------------------------------------
+
+static void sub_80AC6B4(struct Sprite *);
+
static const struct Coords16 gUnknown_0854FB50[] =
{
{ 0, 66},
@@ -39,7 +42,12 @@ static const struct Coords16 gUnknown_0854FB50[] =
{10, 78},
};
-static const struct SpriteSheet sCloudSpriteSheet = {gWeatherCloudTiles, sizeof(gWeatherCloudTiles), 0x1200};
+static const struct SpriteSheet sCloudSpriteSheet =
+{
+ .data = gWeatherCloudTiles,
+ .size = sizeof(gWeatherCloudTiles),
+ .tag = 0x1200
+};
static const struct OamData gOamData_839A9DC =
{
@@ -80,10 +88,6 @@ static const struct SpriteTemplate sCloudSpriteTemplate =
.callback = sub_80AC6B4,
};
-//------------------------------------------------------------------------------
-// Clouds
-//------------------------------------------------------------------------------
-
void Clouds_InitVars(void)
{
gWeatherPtr->gammaTargetIndex = 0;
@@ -214,7 +218,7 @@ void sub_807E0A0(void)
gWeatherPtr->cloudSpritesCreated = FALSE;
}
-void sub_80AC6B4(struct Sprite *sprite)
+static void sub_80AC6B4(struct Sprite *sprite)
{
sprite->data[0] = (sprite->data[0] + 1) & 1;
if (sprite->data[0] != 0)
@@ -350,14 +354,128 @@ void task50_0807B6D4(u8 taskId)
// Light Rain
//------------------------------------------------------------------------------
+static void LoadRainSpriteSheet(void);
+static bool8 CreateRainSprite(void);
+static void UpdateRainSprite(struct Sprite *sprite);
+static bool8 UpdateVisibleRainSprites(void);
+static void DestroyRainSprites(void);
+
+static const struct Coords16 sRainSpriteCoords[] =
+{
+ { 0, 0},
+ { 0, 160},
+ { 0, 64},
+ {144, 224},
+ {144, 128},
+ { 32, 32},
+ { 32, 192},
+ { 32, 96},
+ { 72, 128},
+ { 72, 32},
+ { 72, 192},
+ {216, 96},
+ {216, 0},
+ {104, 160},
+ {104, 64},
+ {104, 224},
+ {144, 0},
+ {144, 160},
+ {144, 64},
+ { 32, 224},
+ { 32, 128},
+ { 72, 32},
+ { 72, 192},
+ { 48, 96},
+};
+
+static const struct OamData sRainSpriteOamData =
+{
+ .y = 0,
+ .affineMode = 0,
+ .objMode = 0,
+ .mosaic = 0,
+ .bpp = 0,
+ .shape = SPRITE_SHAPE(16x32),
+ .x = 0,
+ .matrixNum = 0,
+ .size = SPRITE_SIZE(16x32),
+ .tileNum = 0,
+ .priority = 1,
+ .paletteNum = 2,
+ .affineParam = 0,
+};
+
+static const union AnimCmd sRainSpriteFallAnimCmd[] =
+{
+ ANIMCMD_FRAME(0, 16),
+ ANIMCMD_JUMP(0),
+};
+
+static const union AnimCmd sRainSpriteSplashAnimCmd[] =
+{
+ ANIMCMD_FRAME(8, 3),
+ ANIMCMD_FRAME(32, 2),
+ ANIMCMD_FRAME(40, 2),
+ ANIMCMD_END,
+};
+
+static const union AnimCmd sRainSpriteHeavySplashAnimCmd[] =
+{
+ ANIMCMD_FRAME(8, 3),
+ ANIMCMD_FRAME(16, 3),
+ ANIMCMD_FRAME(24, 4),
+ ANIMCMD_END,
+};
+
+static const union AnimCmd *const sRainSpriteAnimCmds[] =
+{
+ sRainSpriteFallAnimCmd,
+ sRainSpriteSplashAnimCmd,
+ sRainSpriteHeavySplashAnimCmd,
+};
+
+static const struct SpriteTemplate sRainSpriteTemplate =
+{
+ .tileTag = 4614,
+ .paletteTag = 4608,
+ .oam = &sRainSpriteOamData,
+ .anims = sRainSpriteAnimCmds,
+ .images = NULL,
+ .affineAnims = gDummySpriteAffineAnimTable,
+ .callback = UpdateRainSprite,
+};
+
+// Q28.4 fixed-point format values
+static const s16 sRainSpriteMovement[][2] =
+{
+ {-0x68, 0xD0},
+ {-0xA0, 0x140},
+};
+
+// First byte is the number of frames a raindrop falls before it splashes.
+// Second byte is the maximum number of frames a raindrop can "wait" before
+// it appears and starts falling. (This is only for the initial raindrop spawn.)
+static const u16 sRainSpriteFallingDurations[][2] =
+{
+ {18, 7},
+ {12, 10},
+};
+
+static const struct SpriteSheet sRainSpriteSheet =
+{
+ .data = gWeatherRainTiles,
+ .size = sizeof(gWeatherRainTiles),
+ .tag = 0x1206,
+};
+
void LightRain_InitVars(void)
{
gWeatherPtr->initStep = 0;
gWeatherPtr->weatherGfxLoaded = FALSE;
- gWeatherPtr->unknown_6D6 = 0;
- gWeatherPtr->unknown_6DB = 8;
- gWeatherPtr->unknown_6DC = 0;
- gWeatherPtr->unknown_6D9 = 10;
+ gWeatherPtr->rainSpriteVisibleCounter = 0;
+ gWeatherPtr->rainSpriteVisibleDelay = 8;
+ gWeatherPtr->isHeavyRain = 0;
+ gWeatherPtr->maxRainSprites = 10;
gWeatherPtr->gammaTargetIndex = 3;
gWeatherPtr->gammaStepDelay = 20;
SetRainStrengthFromSoundEffect(SE_T_KOAME);
@@ -366,14 +484,10 @@ void LightRain_InitVars(void)
void LightRain_InitAll(void)
{
LightRain_InitVars();
- while (gWeatherPtr->weatherGfxLoaded == FALSE)
+ while (!gWeatherPtr->weatherGfxLoaded)
LightRain_Main();
}
-void LoadRainSpriteSheet(void);
-u8 CreateRainSprite(void);
-u8 sub_807E8E8(void);
-
void LightRain_Main(void)
{
switch (gWeatherPtr->initStep)
@@ -383,11 +497,11 @@ void LightRain_Main(void)
gWeatherPtr->initStep++;
break;
case 1:
- if (CreateRainSprite() == 0)
+ if (!CreateRainSprite())
gWeatherPtr->initStep++;
break;
case 2:
- if (sub_807E8E8() == FALSE)
+ if (!UpdateVisibleRainSprites())
{
gWeatherPtr->weatherGfxLoaded = TRUE;
gWeatherPtr->initStep++;
@@ -396,8 +510,6 @@ void LightRain_Main(void)
}
}
-void DestroyRainSprites(void);
-
bool8 LightRain_Finish(void)
{
switch (gWeatherPtr->finishStep)
@@ -412,12 +524,12 @@ bool8 LightRain_Finish(void)
}
else
{
- gWeatherPtr->unknown_6D9 = 0;
+ gWeatherPtr->maxRainSprites = 0;
gWeatherPtr->finishStep++;
}
// fall through
case 1:
- if (sub_807E8E8() == FALSE)
+ if (!UpdateVisibleRainSprites())
{
DestroyRainSprites();
gWeatherPtr->finishStep++;
@@ -428,66 +540,74 @@ bool8 LightRain_Finish(void)
return FALSE;
}
-// defined below
-extern const s16 gUnknown_0839AABC[][2];
-extern const u16 gUnknown_0839AAC4[][2];
+#define tCounter data[0]
+#define tRandom data[1]
+#define tPosX data[2]
+#define tPosY data[3]
+#define tState data[4]
+#define tActive data[5]
+#define tWaiting data[6]
-void sub_807E4EC(struct Sprite *sprite)
+static void StartRainSpriteFall(struct Sprite *sprite)
{
- u32 randVal;
- u16 r6;
- s32 r4;
- s32 r0;
+ u32 rand;
+ u16 numFallingFrames;
+ int tileX;
+ int tileY;
- if (sprite->data[1] == 0)
- sprite->data[1] = 361;
- randVal = sprite->data[1] * 1103515245 + 12345;
- sprite->data[1] = ((randVal & 0x7FFF0000) >> 16) % 600;
+ if (sprite->tRandom == 0)
+ sprite->tRandom = 361;
- r6 = gUnknown_0839AAC4[gWeatherPtr->unknown_6DC][0];
+ // Standard RNG sequence.
+ rand = sprite->tRandom * 1103515245 + 12345;
+ sprite->tRandom = ((rand & 0x7FFF0000) >> 16) % 600;
- r4 = sprite->data[1] % 30;
- sprite->data[2] = r4 * 8; // useless assignment
+ numFallingFrames = sRainSpriteFallingDurations[gWeatherPtr->isHeavyRain][0];
- r0 = sprite->data[1] / 30;
- sprite->data[3] = r0 * 8; // useless assignment
+ tileX = sprite->tRandom % 30;
+ sprite->tPosX = tileX * 8; // Useless assignment, leftover from before fixed-point values were used
- sprite->data[2] = r4;
- sprite->data[2] <<= 7;
+ tileY = sprite->tRandom / 30;
+ sprite->tPosY = tileY * 8; // Useless assignment, leftover from before fixed-point values were used
- sprite->data[3] = r0;
- sprite->data[3] <<= 7;
+ sprite->tPosX = tileX;
+ sprite->tPosX <<= 7; // This is tileX * 8, using a fixed-point value with 4 decimal places
- sprite->data[2] -= gUnknown_0839AABC[gWeatherPtr->unknown_6DC][0] * r6;
- sprite->data[3] -= gUnknown_0839AABC[gWeatherPtr->unknown_6DC][1] * r6;
+ sprite->tPosY = tileY;
+ sprite->tPosY <<= 7; // This is tileX * 8, using a fixed-point value with 4 decimal places
+
+ // "Rewind" the rain sprites, from their ending position.
+ sprite->tPosX -= sRainSpriteMovement[gWeatherPtr->isHeavyRain][0] * numFallingFrames;
+ sprite->tPosY -= sRainSpriteMovement[gWeatherPtr->isHeavyRain][1] * numFallingFrames;
StartSpriteAnim(sprite, 0);
- sprite->data[4] = 0;
+ sprite->tState = 0;
sprite->coordOffsetEnabled = FALSE;
- sprite->data[0] = r6;
+ sprite->tCounter = numFallingFrames;
}
-void sub_807E5C0(struct Sprite *sprite)
+static void UpdateRainSprite(struct Sprite *sprite)
{
- if (sprite->data[4] == 0)
+ if (sprite->tState == 0)
{
- sprite->data[2] += gUnknown_0839AABC[gWeatherPtr->unknown_6DC][0];
- sprite->data[3] += gUnknown_0839AABC[gWeatherPtr->unknown_6DC][1];
- sprite->pos1.x = sprite->data[2] >> 4;
- sprite->pos1.y = sprite->data[3] >> 4;
+ // Raindrop is in its "falling" motion.
+ sprite->tPosX += sRainSpriteMovement[gWeatherPtr->isHeavyRain][0];
+ sprite->tPosY += sRainSpriteMovement[gWeatherPtr->isHeavyRain][1];
+ sprite->pos1.x = sprite->tPosX >> 4;
+ sprite->pos1.y = sprite->tPosY >> 4;
- if (sprite->data[5] != 0
+ if (sprite->tActive
&& (sprite->pos1.x >= -8 && sprite->pos1.x <= 248)
&& sprite->pos1.y >= -16 && sprite->pos1.y <= 176)
sprite->invisible = FALSE;
else
sprite->invisible = TRUE;
- sprite->data[0]--;
- if (sprite->data[0] == 0)
+ if (--sprite->tCounter == 0)
{
- StartSpriteAnim(sprite, gWeatherPtr->unknown_6DC + 1);
- sprite->data[4] = 1;
+ // Make raindrop splash on the ground
+ StartSpriteAnim(sprite, gWeatherPtr->isHeavyRain + 1);
+ sprite->tState = 1;
sprite->pos1.x -= gSpriteCoordOffsetX;
sprite->pos1.y -= gSpriteCoordOffsetY;
sprite->coordOffsetEnabled = TRUE;
@@ -495,151 +615,230 @@ void sub_807E5C0(struct Sprite *sprite)
}
else if (sprite->animEnded)
{
+ // The splashing animation ended.
sprite->invisible = TRUE;
- sub_807E4EC(sprite);
+ StartRainSpriteFall(sprite);
}
}
-void sub_807E6C4(struct Sprite *sprite)
+static void WaitRainSprite(struct Sprite *sprite)
{
- if (sprite->data[0] == 0)
+ if (sprite->tCounter == 0)
{
- sub_807E4EC(sprite);
- sprite->callback = sub_807E5C0;
+ StartRainSpriteFall(sprite);
+ sprite->callback = UpdateRainSprite;
}
else
{
- sprite->data[0]--;
+ sprite->tCounter--;
}
}
-void sub_807E6F0(struct Sprite *sprite, u16 b)
+static void InitRainSpriteMovement(struct Sprite *sprite, u16 val)
{
- u16 r8 = gUnknown_0839AAC4[gWeatherPtr->unknown_6DC][0];
- u16 r6 = b / (gUnknown_0839AAC4[gWeatherPtr->unknown_6DC][1] + r8);
- u16 r4 = b % (gUnknown_0839AAC4[gWeatherPtr->unknown_6DC][1] + r8);
+ u16 numFallingFrames = sRainSpriteFallingDurations[gWeatherPtr->isHeavyRain][0];
+ u16 numAdvanceRng = val / (sRainSpriteFallingDurations[gWeatherPtr->isHeavyRain][1] + numFallingFrames);
+ u16 frameVal = val % (sRainSpriteFallingDurations[gWeatherPtr->isHeavyRain][1] + numFallingFrames);
+
+ while (--numAdvanceRng != 0xFFFF)
+ StartRainSpriteFall(sprite);
- while (--r6 != 0xFFFF)
- sub_807E4EC(sprite);
- if (r4 < r8)
+ if (frameVal < numFallingFrames)
{
- while (--r4 != 0xFFFF)
- sub_807E5C0(sprite);
- sprite->data[6] = 0;
+ while (--frameVal != 0xFFFF)
+ UpdateRainSprite(sprite);
+
+ sprite->tWaiting = 0;
}
else
{
- sprite->data[0] = r4 - r8;
+ sprite->tCounter = frameVal - numFallingFrames;
sprite->invisible = TRUE;
- sprite->data[6] = 1;
+ sprite->tWaiting = 1;
}
}
-extern const struct SpriteSheet sRainSpriteSheet; // defined below
-
-void LoadRainSpriteSheet(void)
+static void LoadRainSpriteSheet(void)
{
LoadSpriteSheet(&sRainSpriteSheet);
}
-static const struct Coords16 sRainSpriteCoords[] =
+static bool8 CreateRainSprite(void)
{
- { 0, 0},
- { 0, 160},
- { 0, 64},
- {144, 224},
- {144, 128},
- { 32, 32},
- { 32, 192},
- { 32, 96},
- { 72, 128},
- { 72, 32},
- { 72, 192},
- {216, 96},
- {216, 0},
- {104, 160},
- {104, 64},
- {104, 224},
- {144, 0},
- {144, 160},
- {144, 64},
- { 32, 224},
- { 32, 128},
- { 72, 32},
- { 72, 192},
- { 48, 96},
-};
+ u8 spriteIndex;
+ u8 spriteId;
-static const struct OamData gOamData_839AA68 =
-{
- .y = 0,
- .affineMode = 0,
- .objMode = 0,
- .mosaic = 0,
- .bpp = 0,
- .shape = SPRITE_SHAPE(16x32),
- .x = 0,
- .matrixNum = 0,
- .size = SPRITE_SIZE(16x32),
- .tileNum = 0,
- .priority = 1,
- .paletteNum = 2,
- .affineParam = 0,
-};
+ if (gWeatherPtr->rainSpriteCount == MAX_RAIN_SPRITES)
+ return FALSE;
+
+ spriteIndex = gWeatherPtr->rainSpriteCount;
+ spriteId = CreateSpriteAtEnd(&sRainSpriteTemplate,
+ sRainSpriteCoords[spriteIndex].x, sRainSpriteCoords[spriteIndex].y, 78);
+
+ if (spriteId != MAX_SPRITES)
+ {
+ gSprites[spriteId].tActive = 0;
+ gSprites[spriteId].tRandom = spriteIndex * 145;
+ while (gSprites[spriteId].tRandom >= 600)
+ gSprites[spriteId].tRandom -= 600;
+
+ StartRainSpriteFall(&gSprites[spriteId]);
+ InitRainSpriteMovement(&gSprites[spriteId], spriteIndex * 9);
+ gSprites[spriteId].invisible = TRUE;
+ gWeatherPtr->sprites.s1.rainSprites[spriteIndex] = &gSprites[spriteId];
+ }
+ else
+ {
+ gWeatherPtr->sprites.s1.rainSprites[spriteIndex] = NULL;
+ }
+
+ if (++gWeatherPtr->rainSpriteCount == MAX_RAIN_SPRITES)
+ {
+ u16 i;
+ for (i = 0; i < MAX_RAIN_SPRITES; i++)
+ {
+ if (gWeatherPtr->sprites.s1.rainSprites[i])
+ {
+ if (!gWeatherPtr->sprites.s1.rainSprites[i]->tWaiting)
+ gWeatherPtr->sprites.s1.rainSprites[i]->callback = UpdateRainSprite;
+ else
+ gWeatherPtr->sprites.s1.rainSprites[i]->callback = WaitRainSprite;
+ }
+ }
+
+ return FALSE;
+ }
-static const union AnimCmd gSpriteAnim_839AA70[] =
+ return TRUE;
+}
+
+static bool8 UpdateVisibleRainSprites(void)
{
- ANIMCMD_FRAME(0, 16),
- ANIMCMD_JUMP(0),
-};
+ if (gWeatherPtr->curRainSpriteIndex == gWeatherPtr->maxRainSprites)
+ return FALSE;
-static const union AnimCmd gSpriteAnim_839AA78[] =
+ if (++gWeatherPtr->rainSpriteVisibleCounter > gWeatherPtr->rainSpriteVisibleDelay)
+ {
+ gWeatherPtr->rainSpriteVisibleCounter = 0;
+ if (gWeatherPtr->curRainSpriteIndex < gWeatherPtr->maxRainSprites)
+ {
+ gWeatherPtr->sprites.s1.rainSprites[gWeatherPtr->curRainSpriteIndex++]->tActive = 1;
+ }
+ else
+ {
+ gWeatherPtr->curRainSpriteIndex--;
+ gWeatherPtr->sprites.s1.rainSprites[gWeatherPtr->curRainSpriteIndex]->tActive = 0;
+ gWeatherPtr->sprites.s1.rainSprites[gWeatherPtr->curRainSpriteIndex]->invisible = TRUE;
+ }
+ }
+ return TRUE;
+}
+
+static void DestroyRainSprites(void)
{
- ANIMCMD_FRAME(8, 3),
- ANIMCMD_FRAME(32, 2),
- ANIMCMD_FRAME(40, 2),
- ANIMCMD_END,
-};
+ u16 i;
+
+ for (i = 0; i < gWeatherPtr->rainSpriteCount; i++)
+ {
+ if (gWeatherPtr->sprites.s1.rainSprites[i] != NULL)
+ DestroySprite(gWeatherPtr->sprites.s1.rainSprites[i]);
+ }
+ gWeatherPtr->rainSpriteCount = 0;
+ FreeSpriteTilesByTag(0x1206);
+}
-static const union AnimCmd gSpriteAnim_839AA88[] =
+#undef tCounter
+#undef tRandom
+#undef tPosX
+#undef tPosY
+#undef tState
+#undef tActive
+#undef tWaiting
+
+//------------------------------------------------------------------------------
+// Snow
+//------------------------------------------------------------------------------
+
+void Snow_InitVars(void)
{
- ANIMCMD_FRAME(8, 3),
- ANIMCMD_FRAME(16, 3),
- ANIMCMD_FRAME(24, 4),
- ANIMCMD_END,
-};
+ gWeatherPtr->initStep = 0;
+ gWeatherPtr->weatherGfxLoaded = FALSE;
+ gWeatherPtr->gammaTargetIndex = 3;
+ gWeatherPtr->gammaStepDelay = 20;
+ gWeatherPtr->unknown_6E5 = 16;
+ gWeatherPtr->unknown_6E0 = 0;
+}
+
+void Snow_Main(void);
+void sub_807ED48(struct Sprite *);
-static const union AnimCmd *const gSpriteAnimTable_839AA98[] =
+void Snow_InitAll(void)
{
- gSpriteAnim_839AA70,
- gSpriteAnim_839AA78,
- gSpriteAnim_839AA88,
-};
+ Snow_InitVars();
+ while (gWeatherPtr->weatherGfxLoaded == FALSE)
+ {
+ u16 i;
-static const struct SpriteTemplate sRainSpriteTemplate =
+ Snow_Main();
+ for (i = 0; i < gWeatherPtr->snowflakeSpriteCount; i++)
+ {
+ sub_807ED48(gWeatherPtr->sprites.s1.snowflakeSprites[i]);
+ }
+ }
+}
+
+u8 snowflakes_progress(void);
+
+void Snow_Main(void)
{
- .tileTag = 4614,
- .paletteTag = 4608,
- .oam = &gOamData_839AA68,
- .anims = gSpriteAnimTable_839AA98,
- .images = NULL,
- .affineAnims = gDummySpriteAffineAnimTable,
- .callback = sub_807E5C0,
-};
+ if (gWeatherPtr->initStep == 0 && snowflakes_progress() == FALSE)
+ {
+ gWeatherPtr->weatherGfxLoaded = TRUE;
+ gWeatherPtr->initStep++;
+ }
+}
-const s16 gUnknown_0839AABC[][2] =
+bool8 Snow_Finish(void)
{
- {-104, 208},
- {-160, 320},
-};
+ switch (gWeatherPtr->finishStep)
+ {
+ case 0:
+ gWeatherPtr->unknown_6E5 = 0;
+ gWeatherPtr->unknown_6E0 = 0;
+ gWeatherPtr->finishStep++;
+ // fall through
+ case 1:
+ if (snowflakes_progress() == FALSE)
+ {
+ gWeatherPtr->finishStep++;
+ return FALSE;
+ }
+ return TRUE;
+ }
+ return FALSE;
+}
-const u16 gUnknown_0839AAC4[][2] =
+bool8 CreateSnowflakeSprite(void);
+bool8 RemoveSnowflakeSprite(void);
+
+bool8 snowflakes_progress(void)
{
- {18, 7},
- {12, 10},
-};
+ if (gWeatherPtr->snowflakeSpriteCount == gWeatherPtr->unknown_6E5)
+ return FALSE;
-static const struct SpriteSheet sRainSpriteSheet = {gWeatherRainTiles, sizeof(gWeatherRainTiles), 0x1206};
+ gWeatherPtr->unknown_6E0++;
+ if (gWeatherPtr->unknown_6E0 > 36)
+ {
+ gWeatherPtr->unknown_6E0 = 0;
+ if (gWeatherPtr->snowflakeSpriteCount < gWeatherPtr->unknown_6E5)
+ CreateSnowflakeSprite();
+ else
+ RemoveSnowflakeSprite();
+ }
+ return (gWeatherPtr->snowflakeSpriteCount != gWeatherPtr->unknown_6E5);
+}
+
+void sub_807EC40(struct Sprite *);
static const struct OamData gOamData_839AAD4 =
{
@@ -783,172 +982,6 @@ static const struct SpriteTemplate sFog1SpriteTemplate =
.callback = Fog1SpriteCallback,
};
-bool8 CreateRainSprite(void)
-{
- u8 spriteNum;
- u8 spriteId;
-
- if (gWeatherPtr->rainSpriteCount == 24)
- return FALSE;
-
- spriteNum = gWeatherPtr->rainSpriteCount;
- spriteId = CreateSpriteAtEnd(&sRainSpriteTemplate,
- sRainSpriteCoords[spriteNum].x, sRainSpriteCoords[spriteNum].y, 78);
- if (spriteId != MAX_SPRITES)
- {
- gSprites[spriteId].data[5] = 0;
- gSprites[spriteId].data[1] = spriteNum * 145;
- while (gSprites[spriteId].data[1] >= 600)
- gSprites[spriteId].data[1] -= 600;
- sub_807E4EC(&gSprites[spriteId]);
- sub_807E6F0(&gSprites[spriteId], spriteNum * 9);
- gSprites[spriteId].invisible = TRUE;
- gWeatherPtr->sprites.s1.rainSprites[spriteNum] = &gSprites[spriteId];
- }
- else
- {
- gWeatherPtr->sprites.s1.rainSprites[spriteNum] = NULL;
- }
-
- if (++gWeatherPtr->rainSpriteCount == 24)
- {
- u16 i;
-
- for (i = 0; i < 24; i++)
- {
- if (gWeatherPtr->sprites.s1.rainSprites[i] != NULL)
- {
- if (gWeatherPtr->sprites.s1.rainSprites[i]->data[6] == 0)
- gWeatherPtr->sprites.s1.rainSprites[i]->callback = sub_807E5C0;
- else
- gWeatherPtr->sprites.s1.rainSprites[i]->callback = sub_807E6C4;
- }
- }
- return FALSE;
- }
- return TRUE;
-}
-
-bool8 sub_807E8E8(void)
-{
- if (gWeatherPtr->unknown_6D8 == gWeatherPtr->unknown_6D9)
- return FALSE;
-
- if (++gWeatherPtr->unknown_6D6 > gWeatherPtr->unknown_6DB)
- {
- gWeatherPtr->unknown_6D6 = 0;
- if (gWeatherPtr->unknown_6D8 < gWeatherPtr->unknown_6D9)
- {
- gWeatherPtr->sprites.s1.rainSprites[gWeatherPtr->unknown_6D8++]->data[5] = 1;
- }
- else
- {
- gWeatherPtr->unknown_6D8--;
- gWeatherPtr->sprites.s1.rainSprites[gWeatherPtr->unknown_6D8]->data[5] = 0;
- gWeatherPtr->sprites.s1.rainSprites[gWeatherPtr->unknown_6D8]->invisible = TRUE;
- }
- }
- return TRUE;
-}
-
-void DestroyRainSprites(void)
-{
- u16 i;
-
- for (i = 0; i < gWeatherPtr->rainSpriteCount; i++)
- {
- if (gWeatherPtr->sprites.s1.rainSprites[i] != NULL)
- DestroySprite(gWeatherPtr->sprites.s1.rainSprites[i]);
- }
- gWeatherPtr->rainSpriteCount = 0;
- FreeSpriteTilesByTag(0x1206);
-}
-
-//------------------------------------------------------------------------------
-// Snow
-//------------------------------------------------------------------------------
-
-void Snow_InitVars(void)
-{
- gWeatherPtr->initStep = 0;
- gWeatherPtr->weatherGfxLoaded = FALSE;
- gWeatherPtr->gammaTargetIndex = 3;
- gWeatherPtr->gammaStepDelay = 20;
- gWeatherPtr->unknown_6E5 = 16;
- gWeatherPtr->unknown_6E0 = 0;
-}
-
-void Snow_Main(void);
-void sub_807ED48(struct Sprite *);
-
-void Snow_InitAll(void)
-{
- Snow_InitVars();
- while (gWeatherPtr->weatherGfxLoaded == FALSE)
- {
- u16 i;
-
- Snow_Main();
- for (i = 0; i < gWeatherPtr->snowflakeSpriteCount; i++)
- {
- sub_807ED48(gWeatherPtr->sprites.s1.snowflakeSprites[i]);
- }
- }
-}
-
-u8 snowflakes_progress(void);
-
-void Snow_Main(void)
-{
- if (gWeatherPtr->initStep == 0 && snowflakes_progress() == FALSE)
- {
- gWeatherPtr->weatherGfxLoaded = TRUE;
- gWeatherPtr->initStep++;
- }
-}
-
-bool8 Snow_Finish(void)
-{
- switch (gWeatherPtr->finishStep)
- {
- case 0:
- gWeatherPtr->unknown_6E5 = 0;
- gWeatherPtr->unknown_6E0 = 0;
- gWeatherPtr->finishStep++;
- // fall through
- case 1:
- if (snowflakes_progress() == FALSE)
- {
- gWeatherPtr->finishStep++;
- return FALSE;
- }
- return TRUE;
- }
- return FALSE;
-}
-
-bool8 CreateSnowflakeSprite(void);
-bool8 RemoveSnowflakeSprite(void);
-
-bool8 snowflakes_progress(void)
-{
- if (gWeatherPtr->snowflakeSpriteCount == gWeatherPtr->unknown_6E5)
- return FALSE;
-
- gWeatherPtr->unknown_6E0++;
- if (gWeatherPtr->unknown_6E0 > 36)
- {
- gWeatherPtr->unknown_6E0 = 0;
- if (gWeatherPtr->snowflakeSpriteCount < gWeatherPtr->unknown_6E5)
- CreateSnowflakeSprite();
- else
- RemoveSnowflakeSprite();
- }
- return (gWeatherPtr->snowflakeSpriteCount != gWeatherPtr->unknown_6E5);
-}
-
-void sub_807EC40(struct Sprite *);
-
bool8 CreateSnowflakeSprite(void)
{
u8 spriteId = CreateSpriteAtEnd(&sSnowflakeSpriteTemplate, 0, 0, 78);
@@ -1057,10 +1090,10 @@ void MedRain_InitVars(void)
{
gWeatherPtr->initStep = 0;
gWeatherPtr->weatherGfxLoaded = FALSE;
- gWeatherPtr->unknown_6D6 = 0;
- gWeatherPtr->unknown_6DB = 4;
- gWeatherPtr->unknown_6DC = 0;
- gWeatherPtr->unknown_6D9 = 16;
+ gWeatherPtr->rainSpriteVisibleCounter = 0;
+ gWeatherPtr->rainSpriteVisibleDelay = 4;
+ gWeatherPtr->isHeavyRain = 0;
+ gWeatherPtr->maxRainSprites = 16;
gWeatherPtr->gammaTargetIndex = 3;
gWeatherPtr->gammaStepDelay = 20;
gWeatherPtr->weatherGfxLoaded = FALSE; // duplicate assignment
@@ -1085,10 +1118,10 @@ void HeavyRain_InitVars(void)
{
gWeatherPtr->initStep = 0;
gWeatherPtr->weatherGfxLoaded = FALSE;
- gWeatherPtr->unknown_6D6 = 0;
- gWeatherPtr->unknown_6DB = 4;
- gWeatherPtr->unknown_6DC = 1;
- gWeatherPtr->unknown_6D9 = 24;
+ gWeatherPtr->rainSpriteVisibleCounter = 0;
+ gWeatherPtr->rainSpriteVisibleDelay = 4;
+ gWeatherPtr->isHeavyRain = 1;
+ gWeatherPtr->maxRainSprites = 24;
gWeatherPtr->gammaTargetIndex = 3;
gWeatherPtr->gammaStepDelay = 20;
gWeatherPtr->weatherGfxLoaded = FALSE; // duplicate assignment
@@ -1102,8 +1135,8 @@ void HeavyRain_InitAll(void)
Rain_Main();
}
-void UpdateThunderSound(void);
-void SetThunderCounter(u16);
+static void UpdateThunderSound(void);
+static void SetThunderCounter(u16);
void Rain_Main(void)
{
@@ -1120,7 +1153,7 @@ void Rain_Main(void)
gWeatherPtr->initStep++;
break;
case 2:
- if (sub_807E8E8())
+ if (UpdateVisibleRainSprites())
break;
gWeatherPtr->weatherGfxLoaded = TRUE;
gWeatherPtr->initStep++;
@@ -1224,12 +1257,12 @@ bool8 Rain_Finish(void)
|| gWeatherPtr->nextWeather == WEATHER_RAIN_MED
|| gWeatherPtr->nextWeather == WEATHER_RAIN_HEAVY)
return FALSE;
- gWeatherPtr->unknown_6D9 = 0;
+ gWeatherPtr->maxRainSprites = 0;
gWeatherPtr->finishStep++;
}
break;
case 2:
- if (sub_807E8E8())
+ if (UpdateVisibleRainSprites())
break;
DestroyRainSprites();
gWeatherPtr->unknown_6ED = 0;
@@ -1241,7 +1274,7 @@ bool8 Rain_Finish(void)
return TRUE;
}
-void SetThunderCounter(u16 max)
+static void SetThunderCounter(u16 max)
{
if (gWeatherPtr->unknown_6ED == 0)
{
@@ -1250,7 +1283,7 @@ void SetThunderCounter(u16 max)
}
}
-void UpdateThunderSound(void)
+static void UpdateThunderSound(void)
{
if (gWeatherPtr->unknown_6ED == 1)
{
@@ -2125,7 +2158,7 @@ bool8 Shade_Finish(void)
}
//------------------------------------------------------------------------------
-// Weather 14
+// Bubbles
//------------------------------------------------------------------------------
const u8 gUnknown_0839AC68[] = {40, 90, 60, 90, 2, 60, 40, 30};
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-06 12:45:25 +0000