Port field_weather from Emerald

3 files changed, 1334 insertions, 2 deletions

diff --git a/src/credits.c b/src/credits.c
index e0d57a2a4..4d7bbd67b 100644
--- a/src/credits.c
+++ b/src/credits.c
@@ -910,7 +910,7 @@ static s32 RollCredits(void)
             case CREDITSSCRCMD_MAPNEXT:
                 sCreditsMgr->mainseqno = CREDITSSCENE_MAPNEXT_DESTROYWINDOW;
                 sCreditsMgr->whichMon = sCreditsScript[sCreditsMgr->scrcmdidx].param;
-                FieldWeather_StartFadingOutCreditsMap(1, 0, 0x3FFFFFFF);
+                FadeSelectedPals(1, 0, 0x3FFFFFFF);
                 break;
             case CREDITSSCRCMD_MAP:
                 sCreditsMgr->mainseqno = CREDITSSCENE_MAP_LOADMAP_CREATESPRITES;
@@ -1305,7 +1305,7 @@ static s32 RollCredits(void)
                 "\tldr r2, _080F3E0C @ =0x3fffffff\n"
                 "\tmovs r0, 0x1\n"
                 "\tmovs r1, 0\n"
-                "\tbl FieldWeather_StartFadingOutCreditsMap\n"
+                "\tbl FadeSelectedPals\n"
                 "\tb _080F3E94\n"
                 "\t.align 2, 0\n"
                 "_080F3E04: .4byte sCreditsMgr\n"
diff --git a/src/field_weather.c b/src/field_weather.c
new file mode 100644
index 000000000..fb5f4eee7
--- /dev/null
+++ b/src/field_weather.c
@@ -0,0 +1,1320 @@
+#include "global.h"
+#include "gflib.h"
+#include "blend_palette.h"
+#include "field_effect.h"
+#include "field_weather.h"
+#include "field_weather_util.h"
+#include "task.h"
+#include "trig.h"
+#include "constants/field_weather.h"
+#include "constants/weather.h"
+#include "constants/songs.h"
+
+#define DROUGHT_COLOR_INDEX(color) ((((color) >> 1) & 0xF) | (((color) >> 2) & 0xF0) | (((color) >> 3) & 0xF00))
+
+enum
+{
+    GAMMA_NONE,
+    GAMMA_NORMAL,
+    GAMMA_ALT,
+};
+
+struct RGBColor
+{
+    u16 r:5;
+    u16 g:5;
+    u16 b:5;
+};
+
+struct WeatherPaletteData
+{
+    u16 gammaShiftColors[8][0x1000]; // 0x1000 is the number of bytes that make up all palettes.
+};
+
+struct WeatherCallbacks
+{
+    void (*initVars)(void);
+    void (*main)(void);
+    void (*initAll)(void);
+    bool8 (*finish)(void);
+};
+
+struct Weather
+{
+    union
+    {
+        struct
+        {
+            struct Sprite *rainSprites[MAX_RAIN_SPRITES];
+            struct Sprite *snowflakeSprites[101];
+            struct Sprite *cloudSprites[NUM_CLOUD_SPRITES];
+        } s1;
+        struct
+        {
+            u8 filler0[0xA0];
+            struct Sprite *fogHSprites[NUM_FOG_HORIZONTAL_SPRITES];
+            struct Sprite *ashSprites[NUM_ASH_SPRITES];
+            struct Sprite *fogDSprites[NUM_FOG_DIAGONAL_SPRITES];
+            struct Sprite *sandstormSprites1[NUM_SANDSTORM_SPRITES];
+            struct Sprite *sandstormSprites2[NUM_SWIRL_SANDSTORM_SPRITES];
+        } s2;
+    } sprites;
+    u8 gammaShifts[19][32];
+    u8 altGammaShifts[19][32];
+    s8 gammaIndex;
+    s8 gammaTargetIndex;
+    u8 gammaStepDelay;
+    u8 gammaStepFrameCounter;
+    u16 fadeDestColor;
+    /*0x6C6*/ u8 palProcessingState;
+    /*0x6C7*/ u8 fadeScreenCounter;
+    /*0x6C8*/ bool8 readyForInit;
+    /*0x6C9*/ u8 taskId;
+    /*0x6CA*/ u8 unknown_6CA;
+    u8 unknown_6CB;
+    u16 initStep;
+    u16 finishStep;
+    u8 currWeather;
+    u8 nextWeather;
+    u8 weatherGfxLoaded;
+    bool8 weatherChangeComplete;
+    u8 weatherPicSpritePalIndex;
+    u8 altGammaSpritePalIndex;
+    u16 rainSpriteVisibleCounter;
+    u8 curRainSpriteIndex;
+    u8 targetRainSpriteCount;
+    u8 rainSpriteCount;
+    u8 rainSpriteVisibleDelay;
+    u8 isDownpour;
+    u8 rainStrength;
+    /*0x6DE*/ u8 cloudSpritesCreated;
+    u8 filler_6DF[1];
+    u16 snowflakeVisibleCounter;
+    u16 unknown_6E2;
+    u8 snowflakeSpriteCount;
+    u8 targetSnowflakeSpriteCount;
+    u16 unknown_6E6;
+    u16 thunderCounter;
+    u8 unknown_6EA;
+    u8 unknown_6EB;
+    u8 unknown_6EC;
+    u8 thunderTriggered;
+    u16 fogHScrollPosX;
+    u16 fogHScrollCounter;
+    u16 fogHScrollOffset;
+    u8 lightenedFogSpritePals[6];
+    u8 lightenedFogSpritePalsCount;
+    u8 fogHSpritesCreated;
+    u16 ashBaseSpritesX;
+    u16 unknown_6FE;
+    u8 ashSpritesCreated;
+    u8 filler_701[3];
+    u32 sandstormXOffset;
+    u32 sandstormYOffset;
+    u8 filler_70C[2];
+    u16 sandstormBaseSpritesX;
+    u16 sandstormPosY;
+    u16 sandstormWaveIndex;
+    u16 sandstormWaveCounter;
+    u8 sandstormSpritesCreated;
+    u8 sandstormSwirlSpritesCreated;
+    u16 fogDBaseSpritesX;
+    u16 fogDPosY;
+    u16 fogDScrollXCounter;
+    u16 fogDScrollYCounter;
+    u16 fogDXOffset;
+    u16 fogDYOffset;
+    u8 fogDSpritesCreated;
+    u8 filler_725[1];
+    u16 bubblesDelayCounter;
+    u16 bubblesDelayIndex;
+    u16 bubblesCoordsIndex;
+    u16 bubblesSpriteCount;
+    u8 bubblesSpritesCreated;
+    u8 filler_72F;
+    u16 currBlendEVA;
+    u16 currBlendEVB;
+    u16 targetBlendEVA;
+    u16 targetBlendEVB;
+    u8 blendUpdateCounter;
+    u8 blendFrameCounter;
+    u8 blendDelay;
+    u8 filler_73B[0x3C-0x3B];
+    s16 unknown_73C;
+    s16 unknown_73E;
+    s16 unknown_740;
+    s16 unknown_742;
+    u8 filler_744[0xD-4];
+    s8 loadDroughtPalsIndex;
+    u8 loadDroughtPalsOffset;
+};
+
+EWRAM_DATA struct Weather gWeather = {};
+EWRAM_DATA u8 sFieldEffectPaletteGammaTypes[32] = {};
+EWRAM_DATA const u8 *sPaletteGammaTypes = NULL;
+EWRAM_DATA u16 gUnknown_20386A8 = 0;
+
+void Task_WeatherMain(u8 taskId);
+void Task_WeatherInit(u8 taskId);
+void None_Init(void);
+void None_Main(void);
+bool8 None_Finish(void);
+void BuildGammaShiftTables(void);
+void UpdateWeatherGammaShift(void);
+void ApplyGammaShift(u8 startPalIndex, u8 numPalettes, s8 gammaIndex);
+void ApplyGammaShiftWithBlend(u8 startPalIndex, u8 numPalettes, s8 gammaIndex, u8 blendCoeff, u16 blendColor);
+void ApplyDroughtGammaShiftWithBlend(s8 gammaIndex, u8 blendCoeff, u16 blendColor);
+void FadeInScreenWithWeather(void);
+bool8 FadeInScreen_RainShowShade(void);
+bool8 FadeInScreen_Drought(void);
+bool8 FadeInScreen_FogHorizontal(void);
+void DoNothing(void);
+void ApplyFogBlend(u8 blendCoeff, u16 blendColor);
+bool8 LightenSpritePaletteInFog(u8 paletteIndex);
+void Weather_SetBlendCoeffs(u8, u8);
+bool8 Ash_Finish(void);
+bool8 Bubbles_Finish(void);
+bool8 Clouds_Finish(void);
+bool8 Fog1_Finish(void);
+bool8 Fog2_Finish(void);
+bool8 LightRain_Finish(void);
+bool8 Rain_Finish(void);
+bool8 Sandstorm_Finish(void);
+bool8 Snow_Finish(void);
+bool8 sub_807B434(void);
+bool8 sub_807B6BC(void);
+bool8 sub_807D8D0(void);
+void Ash_InitAll(void);
+void Ash_InitVars(void);
+void Ash_Main(void);
+void Bubbles_InitAll(void);
+void Bubbles_InitVars(void);
+void Bubbles_Main(void);
+void Clouds_InitAll(void);
+void Clouds_InitVars(void);
+void Clouds_Main(void);
+void Drought_InitAll(void);
+void Drought_InitVars(void);
+void Drought_Main(void);
+void Fog1_InitAll(void);
+void Fog1_InitVars(void);
+void Fog1_Main(void);
+void Fog2_InitAll(void);
+void Fog2_InitVars(void);
+void Fog2_Main(void);
+void LightRain_InitAll(void);
+void LightRain_InitVars(void);
+void LightRain_Main(void);
+void Rain_Main(void);
+void Sandstorm_InitAll(void);
+void Sandstorm_InitVars(void);
+void Sandstorm_Main(void);
+void Snow_InitAll(void);
+void Snow_InitVars(void);
+void Weather11_InitAll(void);
+void Weather11_InitVars(void);
+void Weather2_InitAll(void);
+void Weather2_InitVars(void);
+void nullsub_48(void);
+void nullsub_49(void);
+void snowflakes_progress2(void);
+void sub_807C2E4(void);
+void sub_807C358(void);
+void sub_807C388(void);
+void sub_807C3F4(void);
+
+const u32 gUnknown_83BFBE4[] = INCBIN_U32("graphics/field_effects/unk_83BFBE4.bin.lz");
+const u32 gUnknown_83C0408[] = INCBIN_U32("graphics/field_effects/unk_83C0408.bin.lz");
+const u32 gUnknown_83C0C00[] = INCBIN_U32("graphics/field_effects/unk_83C0C00.bin.lz");
+const u32 gUnknown_83C139C[] = INCBIN_U32("graphics/field_effects/unk_83C139C.bin.lz");
+const u32 gUnknown_83C1BB8[] = INCBIN_U32("graphics/field_effects/unk_83C1BB8.bin.lz");
+const u32 gUnknown_83C2380[] = INCBIN_U32("graphics/field_effects/unk_83C2380.bin.lz");
+
+const u32 *const gUnknown_83C2BA4[] = {
+    gUnknown_83BFBE4,
+    gUnknown_83C0408,
+    gUnknown_83C0C00,
+    gUnknown_83C139C,
+    gUnknown_83C1BB8,
+    gUnknown_83C2380
+};
+
+struct Weather *const gWeatherPtr = &gWeather;
+
+const struct WeatherCallbacks sWeatherFuncs[] = {
+    {None_Init, None_Main, None_Init, None_Finish},
+    {Clouds_InitVars, Clouds_Main, Clouds_InitAll, Clouds_Finish},
+    {Weather2_InitVars, nullsub_48, Weather2_InitAll, sub_807B434},
+    {LightRain_InitVars, LightRain_Main, LightRain_InitAll, LightRain_Finish},
+    {Snow_InitVars, snowflakes_progress2, Snow_InitAll, Snow_Finish},
+    {sub_807C2E4, Rain_Main, sub_807C358, Rain_Finish},
+    {Fog1_InitVars, Fog1_Main, Fog1_InitAll, Fog1_Finish},
+    {Ash_InitVars, Ash_Main, Ash_InitAll, Ash_Finish},
+    {Sandstorm_InitVars, Sandstorm_Main, Sandstorm_InitAll, Sandstorm_Finish},
+    {Fog2_InitVars, Fog2_Main, Fog2_InitAll, Fog2_Finish},
+    {Fog1_InitVars, Fog1_Main, Fog1_InitAll, Fog1_Finish},
+    {Weather11_InitVars, nullsub_49, Weather11_InitAll, sub_807D8D0},
+    {Drought_InitVars, Drought_Main, Drought_InitAll, sub_807B6BC},
+    {sub_807C388, Rain_Main, sub_807C3F4, Rain_Finish},
+    {Bubbles_InitVars, Bubbles_Main, Bubbles_InitAll, Bubbles_Finish},
+};
+
+void (*const gWeatherPalStateFuncs[])(void) = {
+    UpdateWeatherGammaShift,
+    FadeInScreenWithWeather,
+    DoNothing,
+    DoNothing
+};
+
+const u8 sBasePaletteGammaTypes[32] = {
+    // background palettes
+    GAMMA_NORMAL,
+    GAMMA_NORMAL,
+    GAMMA_NORMAL,
+    GAMMA_NORMAL,
+    GAMMA_NORMAL,
+    GAMMA_NORMAL,
+    GAMMA_NORMAL,
+    GAMMA_NORMAL,
+    GAMMA_NORMAL,
+    GAMMA_NORMAL,
+    GAMMA_NORMAL,
+    GAMMA_NORMAL,
+    GAMMA_NORMAL,
+    GAMMA_NONE,
+    GAMMA_NONE,
+    GAMMA_NONE,
+    // sprite palettes
+    GAMMA_ALT,
+    GAMMA_NORMAL,
+    GAMMA_ALT,
+    GAMMA_ALT,
+    GAMMA_ALT,
+    GAMMA_ALT,
+    GAMMA_NORMAL,
+    GAMMA_NORMAL,
+    GAMMA_NORMAL,
+    GAMMA_NORMAL,
+    GAMMA_ALT,
+    GAMMA_NORMAL,
+    GAMMA_NORMAL,
+    GAMMA_NORMAL,
+    GAMMA_NORMAL,
+    GAMMA_NORMAL,
+};
+
+const u16 gUnknown_83C2CE0[] = INCBIN_U16("graphics/field_effects/unk_83C2CE0.gbapal");
+
+// code
+void StartWeather(void)
+{
+    if (!FuncIsActiveTask(Task_WeatherMain))
+    {
+        u8 index = AllocSpritePalette(0x1200);
+        CpuCopy32(gUnknown_83C2CE0, &gPlttBufferUnfaded[0x100 + index * 16], 32);
+        sub_8083598(index);
+        BuildGammaShiftTables();
+        gWeatherPtr->altGammaSpritePalIndex = index;
+        gWeatherPtr->weatherPicSpritePalIndex = index;
+        gWeatherPtr->rainSpriteCount = 0;
+        gWeatherPtr->curRainSpriteIndex = 0;
+        gWeatherPtr->cloudSpritesCreated = 0;
+        gWeatherPtr->snowflakeSpriteCount = 0;
+        gWeatherPtr->ashSpritesCreated = 0;
+        gWeatherPtr->fogHSpritesCreated = 0;
+        gWeatherPtr->fogDSpritesCreated = 0;
+        gWeatherPtr->sandstormSpritesCreated = 0;
+        gWeatherPtr->sandstormSwirlSpritesCreated = 0;
+        gWeatherPtr->bubblesSpritesCreated = 0;
+        gWeatherPtr->lightenedFogSpritePalsCount = 0;
+        Weather_SetBlendCoeffs(16, 0);
+        gWeatherPtr->currWeather = 0;
+        gWeatherPtr->palProcessingState = WEATHER_PAL_STATE_IDLE;
+        gWeatherPtr->readyForInit = FALSE;
+        gWeatherPtr->weatherChangeComplete = TRUE;
+        gWeatherPtr->taskId = CreateTask(Task_WeatherInit, 80);
+    }
+}
+
+void SetNextWeather(u8 weather)
+{
+    if (weather != WEATHER_RAIN && weather != WEATHER_RAIN_THUNDERSTORM && weather != WEATHER_DOWNPOUR)
+    {
+        PlayRainStoppingSoundEffect();
+    }
+
+    if (gWeatherPtr->nextWeather != weather && gWeatherPtr->currWeather == weather)
+    {
+        sWeatherFuncs[weather].initVars();
+    }
+
+    gWeatherPtr->weatherChangeComplete = FALSE;
+    gWeatherPtr->nextWeather = weather;
+    gWeatherPtr->finishStep = 0;
+}
+
+
+void SetCurrentAndNextWeather(u8 weather)
+{
+    PlayRainStoppingSoundEffect();
+    gWeatherPtr->currWeather = weather;
+    gWeatherPtr->nextWeather = weather;
+}
+
+void SetCurrentAndNextWeatherNoDelay(u8 weather)
+{
+    PlayRainStoppingSoundEffect();
+    gWeatherPtr->currWeather = weather;
+    gWeatherPtr->nextWeather = weather;
+    // Overrides the normal delay during screen fading.
+    gWeatherPtr->readyForInit = TRUE;
+}
+
+void Task_WeatherInit(u8 taskId)
+{
+    // Waits until it's ok to initialize weather.
+    // When the screen fades in, this is set to TRUE.
+    if (gWeatherPtr->readyForInit)
+    {
+        sWeatherFuncs[gWeatherPtr->currWeather].initAll();
+        gTasks[taskId].func = Task_WeatherMain;
+    }
+}
+
+void Task_WeatherMain(u8 taskId)
+{
+    if (gWeatherPtr->currWeather != gWeatherPtr->nextWeather)
+    {
+        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();
+            gWeatherPtr->gammaStepFrameCounter = 0;
+            gWeatherPtr->palProcessingState = WEATHER_PAL_STATE_CHANGING_WEATHER;
+            gWeatherPtr->currWeather = gWeatherPtr->nextWeather;
+            gWeatherPtr->weatherChangeComplete = TRUE;
+        }
+    }
+    else
+    {
+        sWeatherFuncs[gWeatherPtr->currWeather].main();
+    }
+
+    gWeatherPalStateFuncs[gWeatherPtr->palProcessingState]();
+}
+
+
+void None_Init(void)
+{
+    gWeatherPtr->gammaTargetIndex = 0;
+    gWeatherPtr->gammaStepDelay = 0;
+}
+
+void None_Main(void)
+{
+}
+
+u8 None_Finish(void)
+{
+    return 0;
+}
+
+// Builds two tables that contain gamma shifts for palette colors.
+// It's unclear why the two tables aren't declared as const arrays, since
+// this function always builds the same two tables.
+void BuildGammaShiftTables(void)
+{
+    u16 v0;
+    u8 (*gammaTable)[32];
+    u16 v2;
+    u16 v4;
+    u16 v5;
+    u16 gammaIndex;
+    u16 v9;
+    u32 v10;
+    u16 v11;
+    s16 dunno;
+
+    sPaletteGammaTypes = sBasePaletteGammaTypes;
+    for (v0 = 0; v0 <= 1; v0++)
+    {
+        if (v0 == 0)
+            gammaTable = gWeatherPtr->gammaShifts;
+        else
+            gammaTable = gWeatherPtr->altGammaShifts;
+
+        for (v2 = 0; v2 < 32; v2++)
+        {
+            v4 = v2 << 8;
+            if (v0 == 0)
+                v5 = (v2 << 8) / 16;
+            else
+                v5 = 0;
+            for (gammaIndex = 0; gammaIndex <= 2; gammaIndex++)
+            {
+                v4 = (v4 - v5);
+                gammaTable[gammaIndex][v2] = v4 >> 8;
+            }
+            v9 = v4;
+            v10 = 0x1f00 - v4;
+            if ((0x1f00 - v4) < 0)
+            {
+                v10 += 0xf;
+            }
+            v11 = v10 >> 4;
+            if (v2 < 12)
+            {
+                for (; gammaIndex < 19; gammaIndex++)
+                {
+                    v4 += v11;
+                    dunno = v4 - v9;
+                    if (dunno > 0)
+                        v4 -= (dunno + ((u16)dunno >> 15)) >> 1;
+                    gammaTable[gammaIndex][v2] = v4 >> 8;
+                    if (gammaTable[gammaIndex][v2] > 0x1f)
+                        gammaTable[gammaIndex][v2] = 0x1f;
+                }
+            }
+            else
+            {
+                for (; gammaIndex < 19; gammaIndex++)
+                {
+                    v4 += v11;
+                    gammaTable[gammaIndex][v2] = v4 >> 8;
+                    if (gammaTable[gammaIndex][v2] > 0x1f)
+                        gammaTable[gammaIndex][v2] = 0x1f;
+                }
+            }
+        }
+    }
+}
+
+// When the weather is changing, it gradually updates the palettes
+// towards the desired gamma shift.
+void UpdateWeatherGammaShift(void)
+{
+    if (gWeatherPtr->gammaIndex == gWeatherPtr->gammaTargetIndex)
+    {
+        gWeatherPtr->palProcessingState = WEATHER_PAL_STATE_IDLE;
+    }
+    else
+    {
+        if (++gWeatherPtr->gammaStepFrameCounter >= gWeatherPtr->gammaStepDelay)
+        {
+            gWeatherPtr->gammaStepFrameCounter = 0;
+            if (gWeatherPtr->gammaIndex < gWeatherPtr->gammaTargetIndex)
+                gWeatherPtr->gammaIndex++;
+            else
+                gWeatherPtr->gammaIndex--;
+
+            ApplyGammaShift(0, 32, gWeatherPtr->gammaIndex);
+        }
+    }
+}
+
+void FadeInScreenWithWeather(void)
+{
+    if (++gWeatherPtr->unknown_6CB > 1)
+        gWeatherPtr->unknown_6CA = 0;
+
+    switch (gWeatherPtr->currWeather)
+    {
+    case WEATHER_RAIN:
+    case WEATHER_RAIN_THUNDERSTORM:
+    case WEATHER_DOWNPOUR:
+    case WEATHER_SNOW:
+    case WEATHER_SHADE:
+        if (FadeInScreen_RainShowShade() == FALSE)
+        {
+            gWeatherPtr->gammaIndex = 3;
+            gWeatherPtr->palProcessingState = WEATHER_PAL_STATE_IDLE;
+        }
+        break;
+    case WEATHER_DROUGHT:
+        if (FadeInScreen_Drought() == FALSE)
+        {
+            gWeatherPtr->gammaIndex = -6;
+            gWeatherPtr->palProcessingState = WEATHER_PAL_STATE_IDLE;
+        }
+        break;
+    case WEATHER_FOG_HORIZONTAL:
+        if (FadeInScreen_FogHorizontal() == FALSE)
+        {
+            gWeatherPtr->gammaIndex = 0;
+            gWeatherPtr->palProcessingState = WEATHER_PAL_STATE_IDLE;
+        }
+        break;
+    case WEATHER_VOLCANIC_ASH:
+    case WEATHER_SANDSTORM:
+    case WEATHER_FOG_DIAGONAL:
+    case WEATHER_UNDERWATER:
+    default:
+        if (!gPaletteFade.active)
+        {
+            gWeatherPtr->gammaIndex = gWeatherPtr->gammaTargetIndex;
+            gWeatherPtr->palProcessingState = WEATHER_PAL_STATE_IDLE;
+        }
+        break;
+    }
+}
+
+bool8 FadeInScreen_RainShowShade(void)
+{
+    if (gWeatherPtr->fadeScreenCounter == 16)
+        return FALSE;
+
+    if (++gWeatherPtr->fadeScreenCounter >= 16)
+    {
+        ApplyGammaShift(0, 32, 3);
+        gWeatherPtr->fadeScreenCounter = 16;
+        return FALSE;
+    }
+
+    ApplyGammaShiftWithBlend(0, 32, 3, 16 - gWeatherPtr->fadeScreenCounter, gWeatherPtr->fadeDestColor);
+    return TRUE;
+}
+
+bool8 FadeInScreen_Drought(void)
+{
+    if (gWeatherPtr->fadeScreenCounter == 16)
+        return FALSE;
+
+    if (++gWeatherPtr->fadeScreenCounter >= 16)
+    {
+        ApplyGammaShift(0, 32, -6);
+        gWeatherPtr->fadeScreenCounter = 16;
+        return FALSE;
+    }
+
+    ApplyDroughtGammaShiftWithBlend(-6, 16 - gWeatherPtr->fadeScreenCounter, gWeatherPtr->fadeDestColor);
+    return TRUE;
+}
+
+bool8 FadeInScreen_FogHorizontal(void)
+{
+    if (gWeatherPtr->fadeScreenCounter == 16)
+        return FALSE;
+
+    gWeatherPtr->fadeScreenCounter++;
+    ApplyFogBlend(16 - gWeatherPtr->fadeScreenCounter, gWeatherPtr->fadeDestColor);
+    return TRUE;
+}
+
+void DoNothing(void)
+{ }
+
+void ApplyGammaShift(u8 startPalIndex, u8 numPalettes, s8 gammaIndex)
+{
+    u16 curPalIndex;
+    u16 palOffset;
+    u8 *gammaTable;
+    u16 i;
+
+    if (gammaIndex > 0)
+    {
+        gammaIndex--;
+        palOffset = startPalIndex * 16;
+        numPalettes += startPalIndex;
+        curPalIndex = startPalIndex;
+
+        // Loop through the speficied palette range and apply necessary gamma shifts to the colors.
+        while (curPalIndex < numPalettes)
+        {
+            if (sPaletteGammaTypes[curPalIndex] == GAMMA_NONE)
+            {
+                // No palette change.
+                CpuFastCopy(gPlttBufferUnfaded + palOffset, gPlttBufferFaded + palOffset, 16 * sizeof(u16));
+                palOffset += 16;
+            }
+            else
+            {
+                u8 r, g, b;
+
+                if (sPaletteGammaTypes[curPalIndex] == GAMMA_ALT || curPalIndex - 16 == gWeatherPtr->altGammaSpritePalIndex)
+                    gammaTable = gWeatherPtr->altGammaShifts[gammaIndex];
+                else
+                    gammaTable = gWeatherPtr->gammaShifts[gammaIndex];
+
+                for (i = 0; i < 16; i++)
+                {
+                    // Apply gamma shift to the original color.
+                    struct RGBColor baseColor = *(struct RGBColor *)&gPlttBufferUnfaded[palOffset];
+                    r = gammaTable[baseColor.r];
+                    g = gammaTable[baseColor.g];
+                    b = gammaTable[baseColor.b];
+                    gPlttBufferFaded[palOffset++] = (b << 10) | (g << 5) | r;
+                }
+            }
+
+            curPalIndex++;
+        }
+    }
+    else if (gammaIndex < 0)
+    {
+        // A negative gammIndex value means that the blending will come from the special Drought weather's palette tables.
+        // Dummied out in FRLG
+
+        // gammaIndex = -gammaIndex - 1;
+        // palOffset = startPalIndex * 16;
+        // numPalettes += startPalIndex;
+        // curPalIndex = startPalIndex;
+        //
+        // CpuFastCopy(gPlttBufferUnfaded + palOffset, gPlttBufferFaded + palOffset, 16 * sizeof(u16));
+        // while (curPalIndex < numPalettes)
+        // {
+        //     if (sPaletteGammaTypes[curPalIndex] == GAMMA_NONE)
+        //     {
+        //         // No palette change.
+        //         palOffset += 16;
+        //     }
+        //     else
+        //     {
+        //
+        //         for (i = 0; i < 16; i++)
+        //         {
+        //             gPlttBufferFaded[palOffset] = sDroughtWeatherColors[gammaIndex][DROUGHT_COLOR_INDEX(gPlttBufferUnfaded[palOffset])];
+        //             palOffset++;
+        //         }
+        //     }
+        //
+        //     curPalIndex++;
+        // }
+    }
+    else
+    {
+        // No palette blending.
+        CpuFastCopy(gPlttBufferUnfaded + startPalIndex * 16, gPlttBufferFaded + startPalIndex * 16, numPalettes * 16 * sizeof(u16));
+    }
+}
+
+void ApplyGammaShiftWithBlend(u8 startPalIndex, u8 numPalettes, s8 gammaIndex, u8 blendCoeff, u16 blendColor)
+{
+    u16 palOffset;
+    u16 curPalIndex;
+    u16 i;
+    struct RGBColor color = *(struct RGBColor *)&blendColor;
+    u8 rBlend = color.r;
+    u8 gBlend = color.g;
+    u8 bBlend = color.b;
+
+    palOffset = startPalIndex * 16;
+    numPalettes += startPalIndex;
+    gammaIndex--;
+    curPalIndex = startPalIndex;
+
+    while (curPalIndex < numPalettes)
+    {
+        if (sPaletteGammaTypes[curPalIndex] == GAMMA_NONE)
+        {
+            // No gamma shift. Simply blend the colors.
+            BlendPalette(palOffset, 16, blendCoeff, blendColor);
+            palOffset += 16;
+        }
+        else
+        {
+            u8 *gammaTable;
+
+            if (sPaletteGammaTypes[curPalIndex] == GAMMA_NORMAL)
+                gammaTable = gWeatherPtr->gammaShifts[gammaIndex];
+            else
+                gammaTable = gWeatherPtr->altGammaShifts[gammaIndex];
+
+            for (i = 0; i < 16; i++)
+            {
+                struct RGBColor baseColor = *(struct RGBColor *)&gPlttBufferUnfaded[palOffset];
+                u8 r = gammaTable[baseColor.r];
+                u8 g = gammaTable[baseColor.g];
+                u8 b = gammaTable[baseColor.b];
+
+                // Apply gamma shift and target blend color to the original color.
+                r += ((rBlend - r) * blendCoeff) >> 4;
+                g += ((gBlend - g) * blendCoeff) >> 4;
+                b += ((bBlend - b) * blendCoeff) >> 4;
+                gPlttBufferFaded[palOffset++] = (b << 10) | (g << 5) | r;
+            }
+        }
+
+        curPalIndex++;
+    }
+}
+
+void ApplyDroughtGammaShiftWithBlend(s8 gammaIndex, u8 blendCoeff, u16 blendColor)
+{
+    struct RGBColor color;
+    u8 rBlend;
+    u8 gBlend;
+    u8 bBlend;
+    u16 curPalIndex;
+    u16 palOffset;
+    u16 i;
+
+    gammaIndex = -gammaIndex - 1;
+    color = *(struct RGBColor *)&blendColor;
+    rBlend = color.r;
+    gBlend = color.g;
+    bBlend = color.b;
+    palOffset = 0;
+    for (curPalIndex = 0; curPalIndex < 32; curPalIndex++)
+    {
+        if (sPaletteGammaTypes[curPalIndex] == GAMMA_NONE)
+        {
+            // No gamma shift. Simply blend the colors.
+            BlendPalette(palOffset, 16, blendCoeff, blendColor);
+            palOffset += 16;
+        }
+        else
+        {
+            for (i = 0; i < 16; i++)
+            {
+                u32 offset;
+                struct RGBColor color1;
+                struct RGBColor color2;
+                u8 r1, g1, b1;
+                u8 r2, g2, b2;
+
+                color1 = *(struct RGBColor *)&gPlttBufferUnfaded[palOffset];
+                r1 = color1.r;
+                g1 = color1.g;
+                b1 = color1.b;
+
+                r1 += ((rBlend - r1) * blendCoeff) >> 4;
+                g1 += ((gBlend - g1) * blendCoeff) >> 4;
+                b1 += ((bBlend - b1) * blendCoeff) >> 4;
+
+                gPlttBufferFaded[palOffset++] = (b1 << 10) | (g1 << 5) | r1;
+            }
+        }
+    }
+}
+
+void ApplyFogBlend(u8 blendCoeff, u16 blendColor)
+{
+    struct RGBColor color;
+    u8 rBlend;
+    u8 gBlend;
+    u8 bBlend;
+    u16 curPalIndex;
+
+    BlendPalette(0, 256, blendCoeff, blendColor);
+    color = *(struct RGBColor *)&blendColor;
+    rBlend = color.r;
+    gBlend = color.g;
+    bBlend = color.b;
+
+    for (curPalIndex = 16; curPalIndex < 32; curPalIndex++)
+    {
+        if (LightenSpritePaletteInFog(curPalIndex))
+        {
+            u16 palEnd = (curPalIndex + 1) * 16;
+            u16 palOffset = curPalIndex * 16;
+
+            while (palOffset < palEnd)
+            {
+                struct RGBColor color = *(struct RGBColor *)&gPlttBufferUnfaded[palOffset];
+                u8 r = color.r;
+                u8 g = color.g;
+                u8 b = color.b;
+
+                r += ((28 - r) * 3) >> 2;
+                g += ((31 - g) * 3) >> 2;
+                b += ((28 - b) * 3) >> 2;
+
+                r += ((rBlend - r) * blendCoeff) >> 4;
+                g += ((gBlend - g) * blendCoeff) >> 4;
+                b += ((bBlend - b) * blendCoeff) >> 4;
+
+                gPlttBufferFaded[palOffset] = (b << 10) | (g << 5) | r;
+                palOffset++;
+            }
+        }
+        else
+        {
+            BlendPalette(curPalIndex * 16, 16, blendCoeff, blendColor);
+        }
+    }
+}
+
+void MarkFogSpritePalToLighten(u8 paletteIndex)
+{
+    if (gWeatherPtr->lightenedFogSpritePalsCount < 6)
+    {
+        gWeatherPtr->lightenedFogSpritePals[gWeatherPtr->lightenedFogSpritePalsCount] = paletteIndex;
+        gWeatherPtr->lightenedFogSpritePalsCount++;
+    }
+}
+
+bool8 LightenSpritePaletteInFog(u8 paletteIndex)
+{
+    u16 i;
+
+    for (i = 0; i < gWeatherPtr->lightenedFogSpritePalsCount; i++)
+    {
+        if (gWeatherPtr->lightenedFogSpritePals[i] == paletteIndex)
+            return TRUE;
+    }
+
+    return FALSE;
+}
+
+void sub_807A790(s8 gammaIndex)
+{
+    if (gWeatherPtr->palProcessingState == WEATHER_PAL_STATE_IDLE)
+    {
+        ApplyGammaShift(0, 32, gammaIndex);
+        gWeatherPtr->gammaIndex = gammaIndex;
+    }
+}
+
+void sub_807A7C4(u8 gammaIndex, u8 gammaTargetIndex, u8 gammaStepDelay)
+{
+    if (gWeatherPtr->palProcessingState == WEATHER_PAL_STATE_IDLE)
+    {
+        gWeatherPtr->palProcessingState = WEATHER_PAL_STATE_CHANGING_WEATHER;
+        gWeatherPtr->gammaIndex = gammaIndex;
+        gWeatherPtr->gammaTargetIndex = gammaTargetIndex;
+        gWeatherPtr->gammaStepFrameCounter = 0;
+        gWeatherPtr->gammaStepDelay = gammaStepDelay;
+        sub_807A790(gammaIndex);
+    }
+}
+
+void FadeScreen(u8 mode, s8 delay)
+{
+    u32 fadeColor;
+    bool8 fadeOut;
+    bool8 useWeatherPal;
+
+    switch (mode)
+    {
+    case FADE_FROM_BLACK:
+        fadeColor = RGB_BLACK;
+        fadeOut = FALSE;
+        break;
+    case FADE_FROM_WHITE:
+        fadeColor = RGB_WHITEALPHA;
+        fadeOut = FALSE;
+        break;
+    case FADE_TO_BLACK:
+        fadeColor = RGB_BLACK;
+        fadeOut = TRUE;
+        break;
+    case FADE_TO_WHITE:
+        fadeColor = RGB_WHITEALPHA;
+        fadeOut = TRUE;
+        break;
+    default:
+        return;
+    }
+
+    switch (gWeatherPtr->currWeather)
+    {
+    case WEATHER_RAIN:
+    case WEATHER_RAIN_THUNDERSTORM:
+    case WEATHER_DOWNPOUR:
+    case WEATHER_SNOW:
+    case WEATHER_FOG_HORIZONTAL:
+    case WEATHER_SHADE:
+    case WEATHER_DROUGHT:
+        useWeatherPal = TRUE;
+        break;
+    default:
+        useWeatherPal = FALSE;
+        break;
+    }
+
+    if (fadeOut)
+    {
+        if (useWeatherPal)
+            CpuFastCopy(gPlttBufferFaded, gPlttBufferUnfaded, 0x400);
+
+        BeginNormalPaletteFade(0xFFFFFFFF, delay, 0, 16, fadeColor);
+        gWeatherPtr->palProcessingState = WEATHER_PAL_STATE_SCREEN_FADING_OUT;
+    }
+    else
+    {
+        gWeatherPtr->fadeDestColor = fadeColor;
+        if (useWeatherPal)
+            gWeatherPtr->fadeScreenCounter = 0;
+        else
+            BeginNormalPaletteFade(0xFFFFFFFF, delay, 16, 0, fadeColor);
+
+        gWeatherPtr->palProcessingState = WEATHER_PAL_STATE_SCREEN_FADING_IN;
+        gWeatherPtr->unknown_6CA = 1;
+        gWeatherPtr->unknown_6CB = 0;
+        Weather_SetBlendCoeffs(gWeatherPtr->currBlendEVA, gWeatherPtr->currBlendEVB);
+        gWeatherPtr->readyForInit = TRUE;
+    }
+}
+
+void FadeSelectedPals(u8 mode, s8 delay, u32 selectedPalettes)
+{
+    u32 fadeColor;
+    bool8 fadeOut;
+    bool8 useWeatherPal;
+
+    switch (mode)
+    {
+    case FADE_FROM_BLACK:
+        fadeColor = RGB_BLACK;
+        fadeOut = FALSE;
+        break;
+    case FADE_FROM_WHITE:
+        fadeColor = RGB_WHITEALPHA;
+        fadeOut = FALSE;
+        break;
+    case FADE_TO_BLACK:
+        fadeColor = RGB_BLACK;
+        fadeOut = TRUE;
+        break;
+    case FADE_TO_WHITE:
+        fadeColor = RGB_WHITEALPHA;
+        fadeOut = TRUE;
+        break;
+    default:
+        return;
+    }
+
+    switch (gWeatherPtr->currWeather)
+    {
+    case WEATHER_RAIN:
+    case WEATHER_RAIN_THUNDERSTORM:
+    case WEATHER_DOWNPOUR:
+    case WEATHER_SNOW:
+    case WEATHER_FOG_HORIZONTAL:
+    case WEATHER_SHADE:
+    case WEATHER_DROUGHT:
+        useWeatherPal = TRUE;
+        break;
+    default:
+        useWeatherPal = FALSE;
+        break;
+    }
+
+    if (fadeOut)
+    {
+        if (useWeatherPal)
+            CpuFastCopy(gPlttBufferFaded, gPlttBufferUnfaded, 0x400);
+
+        BeginNormalPaletteFade(selectedPalettes, delay, 0, 16, fadeColor);
+        gWeatherPtr->palProcessingState = WEATHER_PAL_STATE_SCREEN_FADING_OUT;
+    }
+    else
+    {
+        gWeatherPtr->fadeDestColor = fadeColor;
+        if (useWeatherPal)
+            gWeatherPtr->fadeScreenCounter = 0;
+        else
+            BeginNormalPaletteFade(selectedPalettes, delay, 16, 0, fadeColor);
+
+        gWeatherPtr->palProcessingState = WEATHER_PAL_STATE_SCREEN_FADING_IN;
+        gWeatherPtr->unknown_6CA = 1;
+        gWeatherPtr->unknown_6CB = 0;
+        Weather_SetBlendCoeffs(gWeatherPtr->currBlendEVA, gWeatherPtr->currBlendEVB);
+        gWeatherPtr->readyForInit = TRUE;
+    }
+}
+
+
+bool8 IsWeatherNotFadingIn(void)
+{
+    return (gWeatherPtr->palProcessingState != WEATHER_PAL_STATE_SCREEN_FADING_IN);
+}
+
+void UpdateSpritePaletteWithWeather(u8 spritePaletteIndex)
+{
+    u16 paletteIndex = 16 + spritePaletteIndex;
+    u16 i;
+
+    switch (gWeatherPtr->palProcessingState)
+    {
+    case WEATHER_PAL_STATE_SCREEN_FADING_IN:
+        if (gWeatherPtr->unknown_6CA != 0)
+        {
+            if (gWeatherPtr->currWeather == WEATHER_FOG_HORIZONTAL)
+                MarkFogSpritePalToLighten(paletteIndex);
+            paletteIndex *= 16;
+            for (i = 0; i < 16; i++)
+                gPlttBufferFaded[paletteIndex + i] = gWeatherPtr->fadeDestColor;
+        }
+        break;
+    case WEATHER_PAL_STATE_SCREEN_FADING_OUT:
+        paletteIndex *= 16;
+        CpuFastCopy(gPlttBufferFaded + paletteIndex, gPlttBufferUnfaded + paletteIndex, 32);
+        BlendPalette(paletteIndex, 16, gPaletteFade.y, gPaletteFade.blendColor);
+        break;
+        // WEATHER_PAL_STATE_CHANGING_WEATHER
+        // WEATHER_PAL_STATE_CHANGING_IDLE
+    default:
+        if (gWeatherPtr->currWeather != WEATHER_FOG_HORIZONTAL)
+        {
+            ApplyGammaShift(paletteIndex, 1, gWeatherPtr->gammaIndex);
+        }
+        else
+        {
+            paletteIndex *= 16;
+            BlendPalette(paletteIndex, 16, 12, RGB(28, 31, 28));
+        }
+        break;
+    }
+}
+
+void ApplyWeatherGammaShiftToPal(u8 paletteIndex)
+{
+    ApplyGammaShift(paletteIndex, 1, gWeatherPtr->gammaIndex);
+}
+
+u8 sub_80ABF20(void)
+{
+    if (gWeatherPtr->palProcessingState == WEATHER_PAL_STATE_SCREEN_FADING_IN)
+        return gWeatherPtr->unknown_6CA;
+    else
+        return 0;
+}
+
+void LoadCustomWeatherSpritePalette(const u16 *palette)
+{
+    LoadPalette(palette, 0x100 + gWeatherPtr->weatherPicSpritePalIndex * 16, 32);
+    UpdateSpritePaletteWithWeather(gWeatherPtr->weatherPicSpritePalIndex);
+}
+
+static void LoadDroughtWeatherPalette(u8 *gammaIndexPtr, u8 *a1)
+{
+    // Dummied out in FRLG
+    // *gammaIndexPtr = 0x20;
+    // *a1 = 0x20;
+}
+
+void ResetDroughtWeatherPaletteLoading(void)
+{
+    gWeatherPtr->loadDroughtPalsIndex = 1;
+    gWeatherPtr->loadDroughtPalsOffset = 1;
+}
+
+bool8 LoadDroughtWeatherPalettes(void)
+{
+    if (gWeatherPtr->loadDroughtPalsIndex < 32)
+    {
+        LoadDroughtWeatherPalette(&gWeatherPtr->loadDroughtPalsIndex, &gWeatherPtr->loadDroughtPalsOffset);
+        if (gWeatherPtr->loadDroughtPalsIndex < 32)
+            return TRUE;
+    }
+    return FALSE;
+}
+
+void sub_807AC50(s8 gammaIndex)
+{
+    sub_807A790(-gammaIndex - 1);
+}
+
+void sub_807AC60(void)
+{
+    gWeatherPtr->unknown_73C = 0;
+    gWeatherPtr->unknown_740 = 0;
+    gWeatherPtr->unknown_742 = 0;
+    gWeatherPtr->unknown_73E = 0;
+    gUnknown_20386A8 = 5;
+}
+
+void sub_807AC98(void)
+{
+    switch (gWeatherPtr->unknown_742)
+    {
+    case 0:
+        if (++gWeatherPtr->unknown_740 > gUnknown_20386A8)
+        {
+            gWeatherPtr->unknown_740 = 0;
+            sub_807AC50(gWeatherPtr->unknown_73C++);
+            if (gWeatherPtr->unknown_73C > 5)
+            {
+                gWeatherPtr->unknown_73E = gWeatherPtr->unknown_73C;
+                gWeatherPtr->unknown_742 = 1;
+                gWeatherPtr->unknown_740 = 0x3C;
+            }
+        }
+        break;
+    case 1:
+        gWeatherPtr->unknown_740 = (gWeatherPtr->unknown_740 + 3) & 0x7F;
+        gWeatherPtr->unknown_73C = ((gSineTable[gWeatherPtr->unknown_740] - 1) >> 6) + 2;
+        if (gWeatherPtr->unknown_73C != gWeatherPtr->unknown_73E)
+            sub_807AC50(gWeatherPtr->unknown_73C);
+        gWeatherPtr->unknown_73E = gWeatherPtr->unknown_73C;
+        break;
+    case 2:
+        if (++gWeatherPtr->unknown_740 > gUnknown_20386A8)
+        {
+            gWeatherPtr->unknown_740 = 0;
+            sub_807AC50(--gWeatherPtr->unknown_73C);
+            if (gWeatherPtr->unknown_73C == 3)
+                gWeatherPtr->unknown_742 = 0;
+        }
+        break;
+    }
+}
+
+void Weather_SetBlendCoeffs(u8 eva, u8 evb)
+{
+    gWeatherPtr->currBlendEVA = eva;
+    gWeatherPtr->currBlendEVB = evb;
+    gWeatherPtr->targetBlendEVA = eva;
+    gWeatherPtr->targetBlendEVB = evb;
+    SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(eva, evb));
+}
+
+void Weather_SetTargetBlendCoeffs(u8 eva, u8 evb, int delay)
+{
+    gWeatherPtr->targetBlendEVA = eva;
+    gWeatherPtr->targetBlendEVB = evb;
+    gWeatherPtr->blendDelay = delay;
+    gWeatherPtr->blendFrameCounter = 0;
+    gWeatherPtr->blendUpdateCounter = 0;
+}
+
+bool8 Weather_UpdateBlend(void)
+{
+    if (gWeatherPtr->currBlendEVA == gWeatherPtr->targetBlendEVA
+        && gWeatherPtr->currBlendEVB == gWeatherPtr->targetBlendEVB)
+        return TRUE;
+
+    if (++gWeatherPtr->blendFrameCounter > gWeatherPtr->blendDelay)
+    {
+        gWeatherPtr->blendFrameCounter = 0;
+        gWeatherPtr->blendUpdateCounter++;
+
+        // Update currBlendEVA and currBlendEVB on alternate frames
+        if (gWeatherPtr->blendUpdateCounter & 1)
+        {
+            if (gWeatherPtr->currBlendEVA < gWeatherPtr->targetBlendEVA)
+                gWeatherPtr->currBlendEVA++;
+            else if (gWeatherPtr->currBlendEVA > gWeatherPtr->targetBlendEVA)
+                gWeatherPtr->currBlendEVA--;
+        }
+        else
+        {
+            if (gWeatherPtr->currBlendEVB < gWeatherPtr->targetBlendEVB)
+                gWeatherPtr->currBlendEVB++;
+            else if (gWeatherPtr->currBlendEVB > gWeatherPtr->targetBlendEVB)
+                gWeatherPtr->currBlendEVB--;
+        }
+    }
+
+    SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gWeatherPtr->currBlendEVA, gWeatherPtr->currBlendEVB));
+
+    if (gWeatherPtr->currBlendEVA == gWeatherPtr->targetBlendEVA
+        && gWeatherPtr->currBlendEVB == gWeatherPtr->targetBlendEVB)
+        return TRUE;
+
+    return FALSE;
+}
+
+void sub_807AF00(u8 a)
+{
+    switch (a)
+    {
+    case 1:
+        SetWeather(WEATHER_SUNNY_CLOUDS);
+        break;
+    case 2:
+        SetWeather(WEATHER_SUNNY);
+        break;
+    case 3:
+        SetWeather(WEATHER_RAIN);
+        break;
+    case 4:
+        SetWeather(WEATHER_SNOW);
+        break;
+    case 5:
+        SetWeather(WEATHER_RAIN_THUNDERSTORM);
+        break;
+    case 6:
+        SetWeather(WEATHER_FOG_HORIZONTAL);
+        break;
+    case 7:
+        SetWeather(WEATHER_FOG_DIAGONAL);
+        break;
+    case 8:
+        SetWeather(WEATHER_VOLCANIC_ASH);
+        break;
+    case 9:
+        SetWeather(WEATHER_SANDSTORM);
+        break;
+    case 10:
+        SetWeather(WEATHER_SHADE);
+        break;
+    }
+}
+
+u8 GetCurrentWeather(void)
+{
+    return gWeatherPtr->currWeather;
+}
+
+void SetRainStrengthFromSoundEffect(u16 soundEffect)
+{
+    if (gWeatherPtr->palProcessingState != WEATHER_PAL_STATE_SCREEN_FADING_OUT)
+    {
+        switch (soundEffect)
+        {
+        case SE_T_KOAME:
+            gWeatherPtr->rainStrength = 0;
+            break;
+        case SE_T_OOAME:
+            gWeatherPtr->rainStrength = 1;
+            break;
+        case SE_T_AME:
+            gWeatherPtr->rainStrength = 2;
+            break;
+        default:
+            return;
+        }
+
+        PlaySE(soundEffect);
+    }
+}
+
+void PlayRainStoppingSoundEffect(void)
+{
+    if (IsSpecialSEPlaying())
+    {
+        switch (gWeatherPtr->rainStrength)
+        {
+        case 0:
+            PlaySE(SE_T_KOAME_E);
+            break;
+        case 1:
+            PlaySE(SE_T_OOAME_E);
+            break;
+        case 2:
+        default:
+            PlaySE(SE_T_AME_E);
+            break;
+        }
+    }
+}
+
+u8 IsWeatherChangeComplete(void)
+{
+    return gWeatherPtr->weatherChangeComplete;
+}
+
+void SetWeatherScreenFadeOut(void)
+{
+    gWeatherPtr->palProcessingState = WEATHER_PAL_STATE_SCREEN_FADING_OUT;
+}
+
+void sub_807B070(void)
+{
+    gWeatherPtr->palProcessingState = WEATHER_PAL_STATE_IDLE;
+}
+
+void PreservePaletteInWeather(u8 preservedPalIndex)
+{
+    CpuCopy16(sBasePaletteGammaTypes, sFieldEffectPaletteGammaTypes, 32);
+    sFieldEffectPaletteGammaTypes[preservedPalIndex] = GAMMA_NONE;
+    sPaletteGammaTypes = sFieldEffectPaletteGammaTypes;
+}
+
+void ResetPreservedPalettesInWeather(void)
+{
+    sPaletteGammaTypes = sBasePaletteGammaTypes;
+}
diff --git a/src/field_weather_util.c b/src/field_weather_util.c
new file mode 100644
index 000000000..ed1ce5236
--- /dev/null
+++ b/src/field_weather_util.c
@@ -0,0 +1,12 @@
+#include "global.h"
+
+const u16 gUnknown_83C2D00[] = INCBIN_U16("graphics/field_effects/unk_83C2D00.gbapal");
+const u16 gUnknown_83C2D20[] = INCBIN_U16("graphics/field_effects/unk_83C2D20.gbapal");
+const u16 gUnknown_83C2D40[] = INCBIN_U16("graphics/field_effects/unk_83C2D40.4bpp");
+const u16 gWeatherFog1Tiles[] = INCBIN_U16("graphics/field_effects/unk_83C3540.4bpp");
+const u16 gUnknown_83C3D40[] = INCBIN_U16("graphics/field_effects/unk_83C3D40.4bpp");
+const u16 gUnknown_83C4540[] = INCBIN_U16("graphics/field_effects/unk_83C4540.4bpp");
+const u16 gUnknown_83C4580[] = INCBIN_U16("graphics/field_effects/unk_83C4580.4bpp");
+const u16 gUnknown_83C45C0[] = INCBIN_U16("graphics/field_effects/unk_83C45C0.4bpp");
+const u16 gUnknown_83C55C0[] = INCBIN_U16("graphics/field_effects/unk_83C55C0.4bpp");
+const u16 gUnknown_83C5BC0[] = INCBIN_U16("graphics/field_effects/unk_83C5BC0.4bpp");