ac_weather OK (#155)

* weather werk

* ac_weather OK

* format

* review

28 files changed, 1061 insertions, 165 deletions

diff --git a/include/6792F0.h b/include/6792F0.h
index 2cd1e57..8e42fb7 100644
--- a/include/6792F0.h
+++ b/include/6792F0.h
@@ -12,7 +12,7 @@
 // void func_80055B84_jp();
 // void mAGrw_PrintFossilHaniwa_debug();
 // void func_80055D94_jp();
-// void func_80055E20_jp();
+void mAGrw_OrderSetHaniwa(void);
 // void func_80055E34_jp();
 // void func_80055E5C_jp();
 // void func_80055EF8_jp();
diff --git a/include/683030.h b/include/683030.h
index 663caf6..a20a1c3 100644
--- a/include/683030.h
+++ b/include/683030.h
@@ -2,9 +2,16 @@
 #define C_683030_H
 
 #include "ultra64.h"
+#include "unk.h"
+#include "z64math.h"
 
 struct Game_Play;
-struct xyz_t;
+
+typedef struct Camera2{
+    /* 0x000 */ xyz_t unk0;
+    /* 0x00C */ xyz_t unk4; 
+    /* 0x018 */ UNK_TYPE1 unk18[0x120];
+} Camera2; //size = 0x138
 
 // void func_8005F390_jp();
 // void func_8005F3DC_jp();
@@ -37,7 +44,7 @@ struct xyz_t;
 // void func_80060574_jp();
 // void func_8006058C_jp();
 // void func_800608C8_jp();
-// void func_800608DC_jp();
+xyz_t* Camera2_getCenterPos_p(void);
 // void func_800608F0_jp();
 // void func_80060904_jp();
 // void func_80060918_jp();
@@ -47,7 +54,7 @@ struct xyz_t;
 void Camera2_ClearActorTalking_Cull(struct Game_Play* game_play);
 // void func_80060D1C_jp();
 // void func_80060D58_jp();
-struct xyz_t* Camera2_getMicPos_p(struct Game_Play* game_play);
+xyz_t* Camera2_getMicPos_p(struct Game_Play* game_play);
 // void func_80060D78_jp();
 // void func_80060DA8_jp();
 // void func_80060FDC_jp();
diff --git a/include/6EDD10.h b/include/6EDD10.h
index 905fd1e..6d4f338 100644
--- a/include/6EDD10.h
+++ b/include/6EDD10.h
@@ -9,8 +9,8 @@ struct lbRTC_time_c;
 // void func_800CA070_jp();
 void mTM_set_season(void);
 // void func_800CA230_jp();
-// void func_800CA240_jp();
-// void func_800CA278_jp();
+s32 mTM_check_renew_time(u8);
+void mTM_off_renew_time(u8);
 // void func_800CA2A8_jp();
 void mTM_set_renew_time(struct lbRTC_ymd_t*, struct lbRTC_time_c*);
 void mTM_renewal_renew_time(void);
diff --git a/include/color.h b/include/color.h
index def50ca..c763bb3 100644
--- a/include/color.h
+++ b/include/color.h
@@ -12,7 +12,7 @@ typedef struct {
     /* 0x2 */ u8 b;
 } Color_RGB8; // size = 0x3
 
-typedef struct {
+typedef struct Color_RGBA8 {
     /* 0x0 */ u8 r;
     /* 0x1 */ u8 g;
     /* 0x2 */ u8 b;
diff --git a/include/m_clip.h b/include/m_clip.h
index c06a214..f58b2ba 100644
--- a/include/m_clip.h
+++ b/include/m_clip.h
@@ -3,6 +3,7 @@
 
 #include "ultra64.h"
 #include "unk.h"
+#include "color.h"
 
 struct Actor;
 struct ActorOverlay;
@@ -14,6 +15,7 @@ struct struct_809AEFA4;
 struct ToolClip;
 struct ShadowData;
 struct FurnitureActor;
+struct WeatherClip;
 
 typedef UNK_RET (*Clip_unk_040_unk_04)(struct ActorOverlay*, const struct struct_801161E8_jp*, size_t, s32);
 typedef UNK_RET (*Clip_unk_040_unk_08)(void);
@@ -106,10 +108,16 @@ typedef struct Clip_unk_08C {
     /* 0x86C */ UNK_TYPE unk_86C;
 } Clip_unk_08C; // size >= 0x870
 
+typedef void (*Clip_unk_090_unk_30)(Color_RGBA8, s16,s16,s32);
+typedef struct Clip_unk_090 {
+    /* 0x00 */ UNK_TYPE1 unk_00[0x30];
+    /* 0x30 */ Clip_unk_090_unk_30 unk_30;
+} Clip_unk_090; // size >= 0x34
+
 typedef void (*Clip_unk_0D8_unk_00)(struct Game_Play* game_play);
 typedef struct Clip_unk_0D8 {
-               Clip_unk_0D8_unk_00 unk_00;
-} Clip_unk_0D8;
+    /* 0x00 */ Clip_unk_0D8_unk_00 unk_00;
+} Clip_unk_0D8; // size >= 0x4
 
 
 typedef struct Clip {
@@ -119,11 +127,12 @@ typedef struct Clip {
     /* 0x06C */ Clip_unk_06C* unk_06C;
     /* 0x070 */ UNK_TYPE1 unk_070[0x4];
     /* 0x074 */ Clip_unk_074* unk_074;
-    /* 0x078 */ UNK_TYPE1 unk_078[0x8];
+    /* 0x078 */ struct WeatherClip* weatherClip;
+    /* 0x07C */ UNK_TYPE1 unk_07C[0x4];
     /* 0x080 */ Clip_unk_080* unk_080;
     /* 0x084 */ UNK_TYPE1 unk_084[0x8];
     /* 0x08C */ Clip_unk_08C* unk_08C;
-    /* 0x090 */ UNK_TYPE1 unk_090[0x4];
+    /* 0x090 */ Clip_unk_090* unk_090;
     /* 0x094 */ struct ToolClip* toolClip;
     /* 0x098 */ UNK_TYPE1 unk_098[0x40];
     /* 0x0D8 */ Clip_unk_0D8* unk_0D8;
diff --git a/include/m_common_data.h b/include/m_common_data.h
index e296bff..e32ea78 100644
--- a/include/m_common_data.h
+++ b/include/m_common_data.h
@@ -170,7 +170,9 @@ typedef struct CommonData {
     /* 0x10A82 */ s16 unk_10A82;
     /* 0x10A84 */ UNK_TYPE1 unk_10A84[0x2C];
     /* 0x10AB0 */ u8 unk_10AB0; // named "pad_connected" in AC GCN decomp
-    /* 0x10AB1 */ UNK_TYPE1 unk_10AB1[0x7];
+    /* 0x10AB1 */ UNK_TYPE1 unk_10AB1;
+    /* 0x10AB2 */ s16 currentSoundEffect;
+    /* 0x10AB4 */ UNK_TYPE1 unk_10AB4[0x4];
 } CommonData; // size = 0x10AB8
 
 void common_data_reinit(void);
diff --git a/include/m_event.h b/include/m_event.h
index 8a13010..88d61af 100644
--- a/include/m_event.h
+++ b/include/m_event.h
@@ -45,7 +45,7 @@ void mEv_ClearEventInfo(void);
 // void func_8007D578_jp();
 // void func_8007D58C_jp();
 // void func_8007D59C_jp();
-// void func_8007D5D4_jp();
+s32 mEv_CheckRealArbeit(void);
 // void func_8007D650_jp();
 s32 mEv_CheckFirstJob(void);
 // void func_8007D734_jp();
@@ -60,7 +60,7 @@ s32 mEv_CheckTitleDemo(void);
 // void func_8007D930_jp();
 // void func_8007D9C8_jp();
 // void func_8007DA64_jp();
-// void func_8007DA6C_jp();
+void mEv_GetEventWeather(s16*,s16*);
 // void func_8007DACC_jp();
 // void func_8007DB20_jp();
 // void func_8007DBB0_jp();
diff --git a/include/m_kankyo.h b/include/m_kankyo.h
index 8061f79..b640d21 100644
--- a/include/m_kankyo.h
+++ b/include/m_kankyo.h
@@ -7,6 +7,7 @@
 struct Actor;
 struct Global_light;
 struct Lights;
+struct s_xyz;
 
 typedef void (*Kankyo_unk_C0)(struct Actor*);
 
@@ -57,9 +58,9 @@ void Global_kankyo_ct(struct Game_Play* game_play, struct Kankyo* kankyo);
 // void func_8009836C_jp();
 // void func_800983F0_jp();
 void Global_kankyo_set(struct Game_Play* game_play, struct Kankyo* kankyo, struct Global_light* arg2);
-// void func_80098558_jp();
+void mEnv_DecideWindDirect(struct s_xyz*, s16,s16);
 // void func_8009867C_jp();
-// void func_80098794_jp();
+void mEnv_RandomWeather(s16*, s16*);
 // void func_8009895C_jp();
 // void func_80098980_jp();
 // void func_80098990_jp();
diff --git a/include/m_player_lib.h b/include/m_player_lib.h
index 0cd50ca..14e9150 100644
--- a/include/m_player_lib.h
+++ b/include/m_player_lib.h
@@ -116,7 +116,7 @@ void mPlib_change_player_cloth_info_lv2(struct PrivateInfo*, u16);
 // void func_800B33AC_jp();
 s32 mPlib_able_submenu_type1(struct Game_Play* game_play);
 // void func_800B34B8_jp();
-// void func_800B34F4_jp();
+s32 mPlib_check_player_open_umbrella(struct Game_Play* game_play);
 // void func_800B3534_jp();
 // void func_800B3588_jp();
 // void func_800B35E4_jp();
diff --git a/include/segment_symbols.h b/include/segment_symbols.h
index 7d7cbc1..f320ec6 100644
--- a/include/segment_symbols.h
+++ b/include/segment_symbols.h
@@ -97,6 +97,12 @@ DECLARE_SEGMENT(catalog_ovl);
 DECLARE_SEGMENT(ac_set_ovl_insect);
 DECLARE_SEGMENT(ac_set_ovl_gyoei);
 
+DECLARE_SEGMENT(ac_weather_fine);
+DECLARE_SEGMENT(ac_weather_rain);
+DECLARE_SEGMENT(ac_weather_snow);
+DECLARE_SEGMENT(ac_weather_sakura);
+DECLARE_SEGMENT(ac_weather_leaf);
+
 DECLARE_SEGMENT(locerrmsg);
 
 DECLARE_SEGMENT(segment_00A58000);
@@ -105,6 +111,10 @@ DECLARE_SEGMENT(segment_00E02000);
 DECLARE_SEGMENT(segment_00E03000);
 DECLARE_SEGMENT(segment_00E04000);
 DECLARE_SEGMENT(segment_00E0D000);
-
+ 
+DECLARE_SEGMENT(segment_01408000);
+DECLARE_SEGMENT(segment_01409000);
+DECLARE_SEGMENT(segment_0140A000);
+DECLARE_SEGMENT(segment_0140B000);
 
 #endif
diff --git a/include/tables/dmatables/dmadata_table_jp.h b/include/tables/dmatables/dmadata_table_jp.h
index 876c72b..78b6d2f 100644
--- a/include/tables/dmatables/dmadata_table_jp.h
+++ b/include/tables/dmatables/dmadata_table_jp.h
@@ -522,16 +522,16 @@ DEFINE_DMA_ENTRY(ovl__009031F0, "ovl__009031F0")
 DEFINE_DMA_ENTRY(ovl__009031F0_reloc, "ovl__009031F0_reloc")
 DEFINE_DMA_ENTRY(ovl__00903460, "ovl__00903460")
 DEFINE_DMA_ENTRY(ovl__00903460_reloc, "ovl__00903460_reloc")
-DEFINE_DMA_ENTRY(ovl__00903B90, "ovl__00903B90")
-DEFINE_DMA_ENTRY(ovl__00903B90_reloc, "ovl__00903B90_reloc")
-DEFINE_DMA_ENTRY(ovl__00903BD0, "ovl__00903BD0")
-DEFINE_DMA_ENTRY(ovl__00903BD0_reloc, "ovl__00903BD0_reloc")
-DEFINE_DMA_ENTRY(ovl__00904330, "ovl__00904330")
-DEFINE_DMA_ENTRY(ovl__00904330_reloc, "ovl__00904330_reloc")
-DEFINE_DMA_ENTRY(ovl__00904AB0, "ovl__00904AB0")
-DEFINE_DMA_ENTRY(ovl__00904AB0_reloc, "ovl__00904AB0_reloc")
-DEFINE_DMA_ENTRY(ovl__00905280, "ovl__00905280")
-DEFINE_DMA_ENTRY(ovl__00905280_reloc, "ovl__00905280_reloc")
+DEFINE_DMA_ENTRY(ac_weather_fine, "ac_weather_fine")
+DEFINE_DMA_ENTRY(ac_weather_fine_reloc, "ac_weather_fine_reloc")
+DEFINE_DMA_ENTRY(ac_weather_rain, "ac_weather_rain")
+DEFINE_DMA_ENTRY(ac_weather_rain_reloc, "ac_weather_rain_reloc")
+DEFINE_DMA_ENTRY(ac_weather_snow, "ac_weather_snow")
+DEFINE_DMA_ENTRY(ac_weather_snow_reloc, "ac_weather_snow_reloc")
+DEFINE_DMA_ENTRY(ac_weather_sakura, "ac_weather_sakura")
+DEFINE_DMA_ENTRY(ac_weather_sakura_reloc, "ac_weather_sakura_reloc")
+DEFINE_DMA_ENTRY(ac_weather_leaf, "ac_weather_leaf")
+DEFINE_DMA_ENTRY(ac_weather_leaf_reloc, "ac_weather_leaf_reloc")
 DEFINE_DMA_ENTRY(ovl__00905A30, "ovl__00905A30")
 DEFINE_DMA_ENTRY(ovl__00905A30_reloc, "ovl__00905A30_reloc")
 DEFINE_DMA_ENTRY(ovl__00906060, "ovl__00906060")
diff --git a/include/z64math.h b/include/z64math.h
index 9828756..4187622 100644
--- a/include/z64math.h
+++ b/include/z64math.h
@@ -30,7 +30,7 @@ typedef struct {
     /* 0x4 */ u16 z;
 } Vec3us; // size = 0x6
 
-typedef struct {
+typedef struct s_xyz {
     /* 0x0 */ s16 x;
     /* 0x2 */ s16 y;
     /* 0x4 */ s16 z;
diff --git a/linker_scripts/jp/symbol_addrs_code.txt b/linker_scripts/jp/symbol_addrs_code.txt
index dba1ffc..ebf7290 100644
--- a/linker_scripts/jp/symbol_addrs_code.txt
+++ b/linker_scripts/jp/symbol_addrs_code.txt
@@ -64,7 +64,7 @@ func_80055A54_jp = 0x80055A54; // type:func
 func_80055B84_jp = 0x80055B84; // type:func
 mAGrw_PrintFossilHaniwa_debug = 0x80055C74; // type:func
 func_80055D94_jp = 0x80055D94; // type:func
-func_80055E20_jp = 0x80055E20; // type:func
+mAGrw_OrderSetHaniwa = 0x80055E20; // type:func
 func_80055E34_jp = 0x80055E34; // type:func
 func_80055E5C_jp = 0x80055E5C; // type:func
 func_80055EF8_jp = 0x80055EF8; // type:func
@@ -378,7 +378,7 @@ func_80060564_jp = 0x80060564; // type:func
 func_80060574_jp = 0x80060574; // type:func
 func_8006058C_jp = 0x8006058C; // type:func
 func_800608C8_jp = 0x800608C8; // type:func
-func_800608DC_jp = 0x800608DC; // type:func
+Camera2_getCenterPos_p = 0x800608DC; // type:func
 func_800608F0_jp = 0x800608F0; // type:func
 func_80060904_jp = 0x80060904; // type:func
 func_80060918_jp = 0x80060918; // type:func
@@ -1081,7 +1081,7 @@ func_8007D554_jp = 0x8007D554; // type:func
 func_8007D578_jp = 0x8007D578; // type:func
 func_8007D58C_jp = 0x8007D58C; // type:func
 func_8007D59C_jp = 0x8007D59C; // type:func
-func_8007D5D4_jp = 0x8007D5D4; // type:func
+mEv_CheckRealArbeit = 0x8007D5D4; // type:func
 func_8007D650_jp = 0x8007D650; // type:func
 mEv_CheckFirstJob = 0x8007D6E0; // type:func
 func_8007D734_jp = 0x8007D734; // type:func
@@ -1096,7 +1096,7 @@ func_8007D91C_jp = 0x8007D91C; // type:func
 func_8007D930_jp = 0x8007D930; // type:func
 func_8007D9C8_jp = 0x8007D9C8; // type:func
 func_8007DA64_jp = 0x8007DA64; // type:func
-func_8007DA6C_jp = 0x8007DA6C; // type:func
+mEv_GetEventWeather = 0x8007DA6C; // type:func
 func_8007DACC_jp = 0x8007DACC; // type:func
 func_8007DB20_jp = 0x8007DB20; // type:func
 func_8007DBB0_jp = 0x8007DBB0; // type:func
@@ -1736,9 +1736,9 @@ func_800981B8_jp = 0x800981B8; // type:func
 func_8009836C_jp = 0x8009836C; // type:func
 func_800983F0_jp = 0x800983F0; // type:func
 Global_kankyo_set = 0x800984CC; // type:func
-func_80098558_jp = 0x80098558; // type:func
+mEnv_DecideWindDirect = 0x80098558; // type:func
 func_8009867C_jp = 0x8009867C; // type:func
-func_80098794_jp = 0x80098794; // type:func
+mEnv_RandomWeather = 0x80098794; // type:func
 func_8009895C_jp = 0x8009895C; // type:func
 func_80098980_jp = 0x80098980; // type:func
 func_80098990_jp = 0x80098990; // type:func
@@ -2611,7 +2611,7 @@ func_800B3330_jp = 0x800B3330; // type:func
 func_800B33AC_jp = 0x800B33AC; // type:func
 mPlib_able_submenu_type1 = 0x800B3408; // type:func
 func_800B34B8_jp = 0x800B34B8; // type:func
-func_800B34F4_jp = 0x800B34F4; // type:func
+mPlib_check_player_open_umbrella = 0x800B34F4; // type:func
 func_800B3534_jp = 0x800B3534; // type:func
 func_800B3588_jp = 0x800B3588; // type:func
 func_800B35E4_jp = 0x800B35E4; // type:func
@@ -3178,8 +3178,8 @@ mTRC_move = 0x800CA008; // type:func
 func_800CA070_jp = 0x800CA070; // type:func
 mTM_set_season = 0x800CA1DC; // type:func
 func_800CA230_jp = 0x800CA230; // type:func
-func_800CA240_jp = 0x800CA240; // type:func
-func_800CA278_jp = 0x800CA278; // type:func
+mTM_check_renew_time = 0x800CA240; // type:func
+mTM_off_renew_time = 0x800CA278; // type:func
 func_800CA2A8_jp = 0x800CA2A8; // type:func
 mTM_set_renew_time = 0x800CA2BC; // type:func
 mTM_renewal_renew_time = 0x800CA2DC; // type:func
diff --git a/linker_scripts/jp/symbol_addrs_overlays.txt b/linker_scripts/jp/symbol_addrs_overlays.txt
index 29fced2..12a4b41 100644
--- a/linker_scripts/jp/symbol_addrs_overlays.txt
+++ b/linker_scripts/jp/symbol_addrs_overlays.txt
@@ -16117,7 +16117,7 @@ RO_FLT_80A3C094_jp = 0x80A3C094; // type:f32
 
 // .data
 
-D_80A3C0F0_jp = 0x80A3C0F0; //
+iam_weather_fine = 0x80A3C0F0; //
 
 // .text
 
@@ -16133,7 +16133,7 @@ func_80A3C5F0_jp = 0x80A3C5F0; // type:func
 // .data
 
 D_80A3C7C0_jp = 0x80A3C7C0; //
-D_80A3C7D0_jp = 0x80A3C7D0; //
+iam_weather_rain = 0x80A3C7D0; //
 D_80A3C7E4_jp = 0x80A3C7E4; //
 D_80A3C7F0_jp = 0x80A3C7F0; //
 D_80A3C7F4_jp = 0x80A3C7F4; //
@@ -16156,7 +16156,7 @@ func_80A3CD84_jp = 0x80A3CD84; // type:func
 
 // .data
 
-D_80A3CF80_jp = 0x80A3CF80; //
+iam_weather_snow = 0x80A3CF80; //
 D_80A3CF94_jp = 0x80A3CF94; //
 
 // .rodata
@@ -16179,7 +16179,7 @@ func_80A3D55C_jp = 0x80A3D55C; // type:func
 
 // .data
 
-D_80A3D700_jp = 0x80A3D700; //
+iam_weather_sakura = 0x80A3D700; //
 D_80A3D714_jp = 0x80A3D714; //
 D_80A3D720_jp = 0x80A3D720; //
 
@@ -16209,7 +16209,7 @@ func_80A3DD20_jp = 0x80A3DD20; // type:func
 // .data
 
 D_80A3DEB0_jp = 0x80A3DEB0; //
-D_80A3DEBC_jp = 0x80A3DEBC; //
+iam_weather_leaf = 0x80A3DEBC; //
 D_80A3DED0_jp = 0x80A3DED0; //
 
 // .rodata
diff --git a/linker_scripts/jp/undefined_syms.ld b/linker_scripts/jp/undefined_syms.ld
index 28aa199..2ce63ba 100644
--- a/linker_scripts/jp/undefined_syms.ld
+++ b/linker_scripts/jp/undefined_syms.ld
@@ -1474,23 +1474,23 @@ D_6006AF8 = 0x06006AF8;
 
 D_600DA48 = 0x0600DA48;
 
-// ovl__00903BD0
+// ac_weather_rain
 
 D_6000040 = 0x06000040;
 D_6000120 = 0x06000120;
 D_6000228 = 0x06000228;
 
-// ovl__00904330
+// ac_weather_snow
 
 D_6000048 = 0x06000048;
 D_60000D0 = 0x060000D0;
 
-// ovl__00904AB0
+// ac_weather_sakura
 
 D_6000040 = 0x06000040;
 D_60000C0 = 0x060000C0;
 
-// ovl__00905280
+// ac_weather_leaf
 
 D_6000000 = 0x06000000;
 
diff --git a/src/overlays/actors/ovl_Weather/ac_weather.c b/src/overlays/actors/ovl_Weather/ac_weather.c
index 0442a93..ad807c8 100644
--- a/src/overlays/actors/ovl_Weather/ac_weather.c
+++ b/src/overlays/actors/ovl_Weather/ac_weather.c
@@ -2,13 +2,61 @@
 #include "m_actor_dlftbls.h"
 #include "m_object.h"
 #include "overlays/gamestates/ovl_play/m_play.h"
-
-void Weather_Actor_ct(Actor* thisx, Game_Play* game_play);
+#include "audio.h"
+#include "m_common_data.h"
+#include "m_scene_table.h"
+#include "m_player_lib.h"
+#include "ovlmgr.h"
+#include "m_malloc.h"
+#include "m_field_info.h"
+#include "m_rcp.h"
+#include "code_variables.h"
+#include "m_kankyo.h"
+#include "6EDD10.h"
+#include "m_event.h"
+#include "6792F0.h"
+#include "683030.h"
+#include "segment_symbols.h"
+
+#include "overlays/weather/ac_weather_fine/ac_weather_fine.h"
+#include "overlays/weather/ac_weather_rain/ac_weather_rain.h"
+#include "overlays/weather/ac_weather_snow/ac_weather_snow.h"
+#include "overlays/weather/ac_weather_sakura/ac_weather_sakura.h"
+#include "overlays/weather/ac_weather_leaf/ac_weather_leaf.h"
+
+void Weather_Actor_ct(Actor* thisx, Game_Play* play);
 void Weather_Actor_dt(Actor* thisx, Game_Play* game_play);
-void Weather_Actor_move(Actor* thisx, Game_Play* game_play);
-void Weather_Actor_draw(Actor* thisx, Game_Play* game_play);
+void Weather_Actor_move(Actor* thisx, Game_Play* play);
+void Weather_Actor_draw(Actor* thisx, Game_Play* play);
+
+WeatherOvlInfo profile_tbl[] = {
+    WEATHER_OVERLAY_NONE(ac_weather_fine, &iam_weather_fine),
+    WEATHER_OVERLAY(ac_weather_rain, func_80A3C130_jp, &iam_weather_rain),
+    WEATHER_OVERLAY(ac_weather_snow, func_80A3C890_jp, &iam_weather_snow),
+    WEATHER_OVERLAY(ac_weather_sakura, func_80A3D010_jp, &iam_weather_sakura),
+    WEATHER_OVERLAY(ac_weather_leaf, func_80A3D7E0_jp, &iam_weather_leaf),
+};
+
+WeatherDmaInfo WeatherRainDmaInfo = {
+    WEATHER_SEGMENT_DMA(segment_01408000),
+};
+
+WeatherDmaInfo WeatherSnowDmaInfo = {
+    WEATHER_SEGMENT_DMA(segment_01409000),
+};
+
+WeatherDmaInfo WeatherSakuraDmaInfo = {
+    WEATHER_SEGMENT_DMA(segment_0140A000),
+};
+
+WeatherDmaInfo WeatherLeafDmaInfo = {
+    WEATHER_SEGMENT_DMA(segment_0140B000),
+};
+
+WeatherDmaInfo* weatherDmaTable[] = {
+    NULL, &WeatherRainDmaInfo, &WeatherSnowDmaInfo, &WeatherSakuraDmaInfo, &WeatherLeafDmaInfo,
+};
 
-#if 0
 ActorProfile Weather_Profile = {
     /* */ ACTOR_WEATHER,
     /* */ ACTOR_PART_7,
@@ -22,74 +70,672 @@ ActorProfile Weather_Profile = {
     /* */ Weather_Actor_draw,
     /* */ NULL,
 };
-#endif
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A21670_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A216C4_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A216E4_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A21724_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A21760_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A217A8_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A21828_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A21858_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A21914_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A219A0_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A21A64_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A21B04_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A21CD8_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A21D90_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A21DFC_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A21E78_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A21F14_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A21F3C_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A21FA0_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A22028_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A220CC_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/Weather_Actor_ct.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/Weather_Actor_dt.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A2236C_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/Weather_Actor_draw.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A22484_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A224C8_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A225D0_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A22644_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A22740_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A2276C_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A227E4_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A22950_jp.s")
-
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/Weather_Actor_move.s")
 
-#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/actors/ovl_Weather/ac_weather/func_80A22BF0_jp.s")
+void func_80A21DFC_jp(Actor* thisx, s16 id);
+void aWeather_ChangingWeather(void);
+s32 aWeather_CountWeatherPrivate(Weather* this);
+void aWeather_AbolishPrivate(Actor* thisx, s32 num);
+void aWeather_SetNowProfile(Actor* thisx, s16 id);
+
+void aWeather_SysLevCall_MoveEnd(Weather* this) {
+    if (this->stopSoundEffect != 0) {
+        sAdo_SysLevStop(this->stopSoundEffect);
+    }
+    if (this->startSoundEffect != 0) {
+        sAdo_SysLevStart(this->startSoundEffect);
+    }
+    this->stopSoundEffect = 0;
+    this->startSoundEffect = 0;
+}
+
+void aWeather_SysLevStart(u8 flag) {
+    s32 startFlag = flag;
+    Weather* this = common_data.clip.weatherClip->actor;
+    this->startSoundEffect = startFlag;
+}
+
+void aWeather_SysLevStop(u8 flag) {
+    Weather* this = common_data.clip.weatherClip->actor;
+    s16 stopFlag = flag;
+
+    if (this->startSoundEffect == stopFlag) {
+        this->startSoundEffect = 0;
+    } else {
+        this->stopSoundEffect = flag;
+    }
+}
+void aWeather_weatherinfo_CommonSet(s16 type, s16 intensity) {
+    if (type >= 4) {
+        type = 0;
+    }
+
+    common_data.weather = type;
+    common_data.weatherIntensity = intensity;
+}
+
+void aWeather_RequestChangeWeather(Actor* thisx, s16 status, s16 level) {
+    Weather* this = (Weather*)thisx;
+
+    if (status != this->currentStatus) {
+        this->nextStatus = status;
+        this->nextLevel = level;
+        this->requestChange = TRUE;
+        this->currentAimLevel = 0;
+    } else {
+        this->currentAimLevel = level;
+    }
+}
+
+s32 aWeather_GetWeatherPrvNum(Actor* thisx) {
+    Weather* this = (Weather*)thisx;
+    WeatherPrv* priv = this->priv;
+
+    s32 i;
+
+    for (i = 0; i != 100; i++) {
+        if (priv->use == 0) {
+            return i;
+        }
+        priv++;
+    }
+
+    return -1;
+}
+
+void aWeather_AbolishPrivate(Actor* thisx, s32 num) {
+    Weather* this = (Weather*)thisx;
+    WeatherPrv* priv = this->priv;
+
+    if (priv != NULL) {
+        if ((&priv[num])->use != 0) {
+            (&priv[num])->use = 0;
+        }
+    }
+}
+
+WeatherPrv* aWeather_GetWeatherPrv(u8 status, s16 timer, xyz_t* pos, xyz_t* speed, Actor* thisx, int id) {
+    Weather* this = (Weather*)thisx;
+    WeatherPrv* priv = this->priv;
+
+    if ((id != -1) && (id < 100)) {
+        if (priv[id].use == 0) {
+            priv[id].use = 1;
+            priv[id].status = status;
+            priv[id].timer = timer;
+            priv[id].id = id;
+            if (pos != NULL) {
+                priv[id].pos = *pos;
+            }
+            if (speed != NULL) {
+                priv[id].speed = *speed;
+            }
+            return &priv[id];
+        }
+        return NULL;
+    }
+    return NULL;
+}
+
+s32 aWeather_StopSysLevSE() {
+    Weather* this = common_data.clip.weatherClip->actor;
+
+    u8 current = this->currentSoundEffect;
+
+    if (this->soundFlag == 0) {
+        if ((current == 7) || (current == 8) || (current == 9) || (current == 18) || (current == 19) ||
+            (current == 20)) {
+            aWeather_SysLevStop(current);
+        }
+        this->soundFlag = 1;
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+s32 aWeather_StartSysLevSE() {
+    Weather* this = common_data.clip.weatherClip->actor;
+
+    if (this->soundFlag == 1) {
+        if (ENV_SAVE_GET_WEATHER_TYPE(common_data.saveWeather) == 1) {
+            switch (ENV_SAVE_GET_WEATHER_INTENSITY(common_data.saveWeather)) {
+                case 1:
+                    aWeather_SysLevStart(7);
+                    this->currentSoundEffect = 7;
+                    break;
+
+                case 2:
+                    aWeather_SysLevStart(8);
+                    this->currentSoundEffect = 8;
+                    break;
+
+                case 3:
+                    aWeather_SysLevStart(9);
+                    this->currentSoundEffect = 9;
+                    break;
+            }
+        }
+        this->soundFlag = 2;
+    }
+    return 0;
+}
+
+void aWeather_ChangeWeatherInstance(Weather* this, s16 status, s16 level) {
+    this->nextStatus = status;
+    this->nextLevel = level;
+    this->currentStatus = status;
+    this->currentLevel = 0;
+    this->requestChange = TRUE;
+
+    if (!aWeather_CountWeatherPrivate(this)) {
+        this->currentStatus = this->nextStatus;
+        aWeather_SetNowProfile(&this->actor, this->currentStatus);
+        func_80A21DFC_jp(&this->actor, this->currentStatus);
+        aWeather_weatherinfo_CommonSet(this->currentStatus, this->nextLevel);
+        this->currentLevel = level;
+        this->currentAimLevel = this->nextLevel;
+        this->requestChange = FALSE;
+    }
+}
+
+void aWeather_ChangeEnvSE(Weather* this, Game_Play* play, s16 status, s16 level) {
+    UNUSED s32 pad;
+    u8 current = this->currentSoundEffect;
+
+    if (this->soundFlag == 1 || this->soundFlag == 2) {
+        return;
+    }
+
+    if ((current == 7) || (current == 8) || (current == 9) || (current == 18) || (current == 19) || (current == 20)) {
+        aWeather_SysLevStop(current);
+        this->currentSoundEffect = -1000;
+    }
+
+    if (mEv_CheckTitleDemo() <= 0) {
+        if (common_data.sceneNo == SCENE_START_DEMO || common_data.sceneNo == SCENE_START_DEMO2) {
+            return;
+        }
+        if ((status == 1) && (this->currentSoundEffect == -1000)) {
+            switch (level) {
+                case 1:
+                    if (mPlib_check_player_open_umbrella(play) != 0) {
+                        aWeather_SysLevStart(0x12);
+                        this->currentSoundEffect = 0x12;
+                    } else {
+                        aWeather_SysLevStart(7);
+                        this->currentSoundEffect = 7;
+                    }
+                    break;
+                case 2:
+                    if (mPlib_check_player_open_umbrella(play) != 0) {
+                        aWeather_SysLevStart(0x13);
+                        this->currentSoundEffect = 0x13;
+                    } else {
+                        aWeather_SysLevStart(8);
+                        this->currentSoundEffect = 8;
+                    }
+                    break;
+                case 3:
+                    if (mPlib_check_player_open_umbrella(play) != 0) {
+                        aWeather_SysLevStart(0x14);
+                        this->currentSoundEffect = 0x14;
+                    } else {
+                        aWeather_SysLevStart(9);
+                        this->currentSoundEffect = 9;
+                    }
+                    break;
+            }
+        }
+    }
+}
+
+void aWeather_EndEnvSE(Actor* thisx) {
+    Weather* this = (Weather*)thisx;
+    u8 current = this->currentSoundEffect;
+
+    if (sAdo_GameframeEnd_Check() == 1) {
+        if ((current == 7) || (current == 8) || (current == 9) || (current == 18) || (current == 19) ||
+            (current == 20)) {
+            aWeather_SysLevStop(current);
+            this->currentSoundEffect = -1000;
+            common_data.currentSoundEffect = -1000;
+        }
+    } else if (sAdo_GameframeEnd_Check() == 2) {
+        common_data.currentSoundEffect = this->currentSoundEffect;
+    }
+
+    aWeather_SysLevCall_MoveEnd(this);
+}
+// fabricated name from ac_tools
+void aWeather_secure_bank_area(Weather* this, Game_Play* play) {
+    UNUSED s32 pad[3];
+    s32 bank = play->objectExchangeBank.num;
+
+    if (mSc_secure_exchange_keep_bank(&play->objectExchangeBank, 0, 0xA00)) {
+        this->segment = play->objectExchangeBank.status[bank].segment;
+    }
+}
+
+void func_80A21DFC_jp(Actor* thisx, s16 id) {
+    Weather* this = (Weather*)thisx;
+
+    if (weatherDmaTable[id] != NULL) {
+        if (this->segment != NULL) {
+            if (weatherDmaTable[id]->vromStart != 0) {
+                if (weatherDmaTable[id]->vromEnd != 0) {
+                    DmaMgr_RequestSyncDebug(this->segment, weatherDmaTable[id]->vromStart,
+                                            weatherDmaTable[id]->vromEnd - weatherDmaTable[id]->vromStart,
+                                            "../ac_weather.c", 836);
+                }
+            }
+        }
+    }
+}
+
+void aWeather_SetNowProfile(Actor* thisx, s16 id) {
+    Weather* this = (Weather*)thisx;
+
+    this->currentProfile = NULL;
+    if (this->allocatedSize != NULL) {
+        uintptr_t size = (uintptr_t)profile_tbl[id].vramEnd - (uintptr_t)profile_tbl[id].vramStart;
+        if (size <= 0xC00) {
+            ovlmgr_Load(profile_tbl[id].vromStart, profile_tbl[id].vromEnd, profile_tbl[id].vramStart,
+                        profile_tbl[id].vramEnd, this->allocatedSize);
+            this->currentProfile =
+                (WeatherProfile*)(((uintptr_t)this->allocatedSize + (uintptr_t)profile_tbl[id].ovlTypeEnd) -
+                                  (uintptr_t)profile_tbl[id].vramStart);
+        }
+    }
+}
+
+void func_80A21F14_jp(Weather* this) {
+    this->allocatedSize = zelda_malloc(0xC00);
+}
+
+void aWeather_SecureWeatherPrivateWork(Weather* this) {
+    s32 i;
+
+    this->priv = zelda_malloc(sizeof(WeatherPrv) * 100);
+
+    if (this->priv != NULL) {
+        for (i = 0; i < 100; i++) {
+            bzero(&this->priv[i], sizeof(WeatherPrv));
+        }
+    }
+}
+
+void aWeather_SetClip(Weather* this, s32 flag) {
+    WeatherClip* clip;
+
+    if (flag != 0) {
+        common_data.clip.weatherClip = NULL;
+    } else {
+        clip = &this->clip;
+
+        clip->actor = this;
+        clip->changingWeather = aWeather_ChangingWeather;
+        clip->changeWeather = aWeather_RequestChangeWeather;
+        clip->getPrvNum = aWeather_GetWeatherPrvNum;
+        clip->removePrv = aWeather_AbolishPrivate;
+        clip->getPrv = aWeather_GetWeatherPrv;
+        clip->stopSound = aWeather_StopSysLevSE;
+        clip->startSound = aWeather_StartSysLevSE;
+        clip->changeWeatherInstance = aWeather_ChangeWeatherInstance;
+
+        common_data.clip.weatherClip = clip;
+    }
+}
+
+void aWeather_RenewWindInfo(Weather* this) {
+    UNUSED s32 pad;
+    s_xyz pos = common_data.wind;
+    f32 factor = 1.0f / 1.0f;
+    f32 speed = common_data.windSpeed * 0.01f;
+
+    this->windInfo.x = (pos.x * speed * factor);
+    this->windInfo.y = (pos.y * speed * factor);
+    this->windInfo.z = (pos.z * speed * factor);
+}
+
+void aWeather_SnowInAdvance(Weather* this, Game_Play* play, s32 moves) {
+    s32 i;
+
+    for (i = 0; i < moves; i++) {
+        Weather_Actor_move(&this->actor, play);
+    }
+}
+
+void Weather_Actor_ct(Actor* thisx, Game_Play* play) {
+    static s16 DemoWeatherTbl[5][2] = {
+        3, 1, 1, 2, 0, 0, 0, 0, 2, 1,
+    };
+    Weather* this = (Weather*)thisx;
+    UNUSED s32 pad;
+
+    xyz_t* pos = Camera2_getCenterPos_p();
+    s32 cur;
+
+    aWeather_SetClip(this, 0);
+
+    if (mEv_CheckTitleDemo() > 0) {
+        UNUSED s32 scopedTemp;
+
+        cur = mEv_CheckTitleDemo() - 1;
+
+        this->currentStatus = DemoWeatherTbl[cur][0];
+        this->nextStatus = DemoWeatherTbl[cur][0];
+        this->currentLevel = DemoWeatherTbl[cur][1];
+        this->currentAimLevel = DemoWeatherTbl[cur][1];
+
+    } else {
+        this->currentStatus = common_data.weather;
+        this->nextStatus = this->currentStatus;
+        this->currentLevel = common_data.weatherIntensity;
+        this->currentAimLevel = common_data.weatherIntensity;
+    }
+
+    this->segment = NULL;
+    this->priv = NULL;
+    this->requestChange = FALSE;
+
+    this->pos = *pos;
+
+    this->timer = 0;
+    this->timer2 = 0;
+    this->lightningTimer = 0;
+    this->lightningTimer2 = 30;
+
+    this->soundFlag = 0;
+    aWeather_RenewWindInfo(this);
+
+    if (!FI_GET_TYPE(mFI_GetFieldId())) {
+        func_80A21F14_jp(this);
+        aWeather_secure_bank_area(this, play);
+        aWeather_SecureWeatherPrivateWork(this);
+    }
+
+    aWeather_SetNowProfile(thisx, this->currentStatus);
+    func_80A21DFC_jp(&this->actor, this->currentStatus);
+
+    if ((this->currentStatus == 2) || (this->currentStatus == 3)) {
+        this->pos.y -= 50.0f;
+        aWeather_SnowInAdvance(this, play, 0x28);
+        this->pos.y += 50.0f;
+    }
+
+    this->stopSoundEffect = 0;
+    this->startSoundEffect = 0;
+    if (play->unk_1EE1 == 6) {
+        this->currentSoundEffect = common_data.currentSoundEffect;
+    } else {
+        this->currentSoundEffect = -1000;
+        aWeather_ChangeEnvSE(this, play, this->currentStatus, this->currentLevel);
+        aWeather_SysLevCall_MoveEnd(this);
+    }
+}
+
+void Weather_Actor_dt(Actor* thisx, UNUSED Game_Play* play) {
+    Weather* this = (Weather*)thisx;
+
+    if (this->priv != NULL) {
+        zelda_free(this->priv);
+    }
+    if (this->allocatedSize != 0) {
+        zelda_free(this->allocatedSize);
+    }
+
+    aWeather_SetClip(this, 1);
+}
+
+void aWeather_DrawWeatherPrv(Actor* thisx, Game_Play* play) {
+    Weather* this = (Weather*)thisx;
+
+    WeatherPrv* priv = this->priv;
+    s32 i;
+
+    _texture_z_light_fog_prim_xlu(play->state.gfxCtx);
+    gSegments[6] = OS_K0_TO_PHYSICAL(this->segment);
+
+    OPEN_DISPS(play->state.gfxCtx);
+
+    gSPSegment(POLY_XLU_DISP++, 6, this->segment);
+
+    CLOSE_DISPS(play->state.gfxCtx);
+
+    if ((this->currentProfile != NULL) && (priv != NULL)) {
+        if (this->currentProfile->st != NULL) {
+            this->currentProfile->st(play);
+        }
+        if (this->currentProfile->dw != NULL) {
+            for (i = 0; i < 100; i++, priv++) {
+                if (priv->use != 0) {
+                    this->currentProfile->dw(priv, play);
+                }
+            }
+        }
+    }
+}
+
+void Weather_Actor_draw(Actor* thisx, Game_Play* play) {
+    aWeather_DrawWeatherPrv(thisx, play);
+}
+
+void aWeather_MakeWeatherPrv(Actor* thisx, Game_Play* play) {
+    Weather* this = (Weather*)thisx;
+
+    if (this->currentLevel != 0) {
+        if (this->currentProfile != NULL) {
+            if (this->currentProfile->mk != NULL) {
+                this->currentProfile->mk(thisx, play);
+            }
+        }
+    }
+}
+
+void aWeather_MoveWeatherPrv(Weather* this, Game_Play* play) {
+    WeatherPrv* priv = this->priv;
+    s32 i;
+
+    if ((this->currentProfile != NULL) && (priv != NULL) && (this->currentProfile->mv != NULL)) {
+        gSegments[6] = OS_K0_TO_PHYSICAL(this->segment);
+
+        OPEN_DISPS(play->state.gfxCtx);
+
+        gSPSegment(POLY_XLU_DISP++, 6, this->segment);
+
+        CLOSE_DISPS(play->state.gfxCtx);
+
+        for (i = 0; i != 100; priv++) {
+            if (priv->use != 0) {
+                this->currentProfile->mv(priv, play);
+
+                if (priv->timer != -100) {
+                    priv->timer--;
+
+                    if (priv->timer <= 0) {
+                        aWeather_AbolishPrivate(&this->actor, i);
+                    }
+                }
+            }
+            // FAKE!!
+            { i++, i--, i++; }
+        }
+    }
+}
+
+s32 aWeather_CountWeatherPrivate(Weather* this) {
+    s32 i;
+    s32 count;
+    WeatherPrv* priv = this->priv;
+
+    count = 0;
+
+    for (i = 0; i < 100; i++, priv++) {
+        if (priv->use != 0) {
+            count++;
+        }
+    }
+
+    return count;
+}
+
+void aWeather_ChangeWeather(Weather* this, Game_Play* play) {
+    if ((this->requestChange == TRUE) && (this->currentLevel == 0)) {
+        if (FI_GET_TYPE(mFI_GetFieldId())) {
+            this->currentStatus = this->nextStatus;
+            aWeather_weatherinfo_CommonSet(this->currentStatus, this->nextLevel);
+            this->currentLevel = 1;
+            this->currentAimLevel = this->nextLevel;
+            aWeather_ChangeEnvSE(this, play, this->currentStatus, this->currentLevel);
+            this->requestChange = FALSE;
+        } else if (aWeather_CountWeatherPrivate(this) == 0) {
+            this->currentStatus = this->nextStatus;
+            aWeather_SetNowProfile(&this->actor, this->currentStatus);
+            func_80A21DFC_jp(&this->actor, this->currentStatus);
+            aWeather_weatherinfo_CommonSet(this->currentStatus, this->nextLevel);
+            this->currentLevel = 1;
+            this->currentAimLevel = this->nextLevel;
+            aWeather_ChangeEnvSE(this, play, this->currentStatus, this->currentLevel);
+            this->requestChange = FALSE;
+        }
+    }
+}
+
+void aWeather_CheckWeatherTimer(UNUSED Weather* this) {
+    s_xyz dir;
+
+    mEnv_DecideWindDirect(&dir, 0x3000, 0x3000);
+}
+
+void aWeather_RenewWeatherLevel(Weather* this, Game_Play* play) {
+    if (this->currentLevel != this->currentAimLevel) {
+        this->counter++;
+        if (this->counter >= 90) {
+            this->counter = 0;
+            if (this->currentAimLevel < this->currentLevel) {
+                this->currentLevel--;
+            } else {
+                this->currentLevel++;
+            }
+            aWeather_ChangeEnvSE(this, play, this->currentStatus, this->currentLevel);
+        }
+    }
+}
+
+void aWeather_ChangeWeatherTime0(Weather* this) {
+    UNUSED s32 pad;
+    s16 saveWeather;
+    s16 rndWeather;
+    s16 rndIntensity;
+    s16 evWeather;
+    s16 evIntensity;
+    s16 saveRnd;
+
+    if ((mEv_CheckTitleDemo() <= 0)) {
+        if ((common_data.sceneNo == 15) || (common_data.sceneNo == 16)) {
+            return;
+        }
+        if ((mTM_check_renew_time(0) != 0)) {
+            mEnv_RandomWeather(&rndWeather, &rndIntensity);
+            mEv_GetEventWeather(&evWeather, &evIntensity);
+            if (evWeather != -1) {
+                rndWeather = evWeather;
+                rndIntensity = evIntensity;
+            }
+            if ((mEv_CheckRealArbeit() == 1) && (rndWeather == 1)) {
+                rndWeather = 0;
+                rndIntensity = 0;
+            }
+            mTM_off_renew_time(0);
+
+            saveWeather = ENV_SAVE_GET_WEATHER_TYPE(common_data.saveWeather);
+            if (rndWeather == 0 || rndWeather == 3) {
+                if (saveWeather == 2 || saveWeather == 1) {
+                    mAGrw_OrderSetHaniwa();
+                }
+            }
+            saveRnd = rndIntensity | ((rndWeather ^ 0) * 16);
+            common_data.saveWeather = saveRnd;
+
+            if (((mEv_CheckTitleDemo() != -9) || (this->soundFlag != 1))) {
+                aWeather_RequestChangeWeather(&this->actor, rndWeather, rndIntensity);
+            }
+            common_data.weatherTime = common_data.time.rtcTime;
+        }
+    }
+}
+
+void aWeather_MakeKaminari(Actor* thisx) {
+    Weather* this = (Weather*)thisx;
+    lbRTC_time_c time = common_data.time.rtcTime;
+    u8 month = time.month;
+
+    if ((common_data.sceneNo != 15) && (common_data.sceneNo != 16)) {
+        if ((month >= lbRTC_JUNE) && (month <= lbRTC_AUGUST) && (this->currentStatus == 1)) {
+            s16* ptr = &this->lightningTimer;
+            if (this->currentLevel == 3) {
+                s16 timer = ptr[0] % 1000;
+                if (((timer == this->lightningTimer2) || (timer == (this->lightningTimer2 + 20))) &&
+                    (common_data.clip.unk_090 != NULL)) {
+                    Color_RGBA8 color = { 70, 70, 160, 255 };
+
+                    common_data.clip.unk_090->unk_30(color, 2, 0x23, 0);
+                }
+                if (timer == (this->lightningTimer2 + 65)) {
+                    sAdo_SysTrgStart(0x424);
+                    this->lightningTimer2 = ((RANDOM_F(500.0f) + 100.0f));
+                }
+                ptr[0]++;
+            }
+        }
+    }
+}
+
+void Weather_Actor_move(Actor* thisx, Game_Play* play) {
+    xyz_t* pos = Camera2_getCenterPos_p();
+    Weather* this = (Weather*)thisx;
+
+    UNUSED s32 pad[3];
+    s16 angle = search_position_angleY(&play->camera.unk4, &play->camera.unk0);
+    s16 umbrella;
+
+    aWeather_MakeKaminari(thisx);
+    aWeather_CheckWeatherTimer(this);
+    aWeather_MakeWeatherPrv(thisx, play);
+    aWeather_RenewWeatherLevel(this, play);
+    aWeather_MoveWeatherPrv(this, play);
+    aWeather_ChangeWeather(this, play);
+
+    this->pos = *pos;
+
+    aWeather_ChangeWeatherTime0(this);
+
+    if (common_data.weather == 1) {
+        umbrella = mPlib_check_player_open_umbrella(play);
+        if (umbrella != this->umbrellaFlag) {
+            aWeather_ChangeEnvSE(this, play, this->currentStatus, this->currentLevel);
+        }
+
+        this->umbrellaFlag = umbrella;
+        this->currentYAngle = angle;
+    }
+
+    if (this->soundFlag == 2) {
+        this->soundFlag = 0;
+    }
+
+    aWeather_EndEnvSE(thisx);
+}
+
+void aWeather_ChangingWeather() {
+    Weather* this;
+
+    if (common_data.clip.weatherClip != NULL) {
+        this = common_data.clip.weatherClip->actor;
+        if (this != NULL) {
+            this->requestChange = FALSE;
+            this->nextStatus = this->currentStatus;
+            func_80A21DFC_jp(&this->actor, this->currentStatus);
+        }
+    }
+}
diff --git a/src/overlays/actors/ovl_Weather/ac_weather.h b/src/overlays/actors/ovl_Weather/ac_weather.h
index de9ef8c..73046a5 100644
--- a/src/overlays/actors/ovl_Weather/ac_weather.h
+++ b/src/overlays/actors/ovl_Weather/ac_weather.h
@@ -4,15 +4,112 @@
 #include "ultra64.h"
 #include "m_actor.h"
 #include "unk.h"
+#include "other_types.h"
 
 struct Game_Play;
-struct Weather;
+
+typedef struct Weather Weather;
+
+//these might go better on kankyo
+#define ENV_SAVE_GET_WEATHER_TYPE(w) (((w) & 0xF0) >> 4) 
+#define ENV_SAVE_GET_WEATHER_INTENSITY(w) ((w) & 0xF)
+
+typedef struct WeatherPrv {
+    /* 0x00 */ xyz_t pos;
+    /* 0x0C */ xyz_t speed;
+    /* 0x18 */ f32 currentY;
+    /* 0x1C */ f32 unk1C;
+    /* 0x20 */ s16 timer;
+    /* 0x22 */ s16 work[5]; 
+    /* 0x2C */ u8 use;
+    /* 0x2D */ u8 id;
+    /* 0x2E */ u8 status;
+} WeatherPrv; // size = 0x30
+
+typedef void (*ChangingWeatherProc)();
+typedef void (*ChangeWeatherProc)(Actor* thisx, s16 status, s16 level);
+typedef s32 (*GetWeatherPrvvNumProc)(Actor* thisx);
+typedef void (*RemoveWeatherPrvProc)(Actor* thisx, s32 id);
+typedef WeatherPrv* (*GetWeatherPrvProc)(u8 status, s16 timer, xyz_t* pos, xyz_t* speed, Actor* weather, int id);
+typedef s32 (*WeatherSoundEffectProc)();
+typedef void (*ChangeWeatherInstanceProc)(Weather* weather, s16 status, s16 level);
+
+typedef struct WeatherClip {
+    /* 0x00 */ Weather* actor;
+    /* 0x04 */ ChangingWeatherProc changingWeather;
+    /* 0x08 */ ChangeWeatherProc changeWeather;
+    /* 0x0C */ GetWeatherPrvvNumProc getPrvNum;
+    /* 0x10 */ RemoveWeatherPrvProc removePrv;
+    /* 0x14 */ GetWeatherPrvProc getPrv;
+    /* 0x18 */ WeatherSoundEffectProc stopSound;
+    /* 0x1C */ WeatherSoundEffectProc startSound;
+    /* 0x20 */ ChangeWeatherInstanceProc changeWeatherInstance;
+} WeatherClip; // size = 0x24 
+
+typedef void (*MakeWeatherProc)(Actor*, struct Game_Play*);
+typedef void (*CtWeatherProc)(WeatherPrv*, struct Game_Play*);
+typedef void (*MvWeatherProc)(WeatherPrv*, struct Game_Play*);
+typedef void (*StWeatherProc)(struct Game_Play*);
+typedef void (*DwWeatherProc)(WeatherPrv*, struct Game_Play*);
+
+typedef struct WeatherProfile {
+    /* 0x00 */ MakeWeatherProc mk;
+    /* 0x04 */ CtWeatherProc ct;
+    /* 0x08 */ MvWeatherProc mv;
+    /* 0x0C */ StWeatherProc st;
+    /* 0x10 */ DwWeatherProc dw;
+} WeatherProfile; // size = 0x14
+
+typedef struct WeatherOvlInfo {
+    /* 0x00 */ RomOffset vromStart;
+    /* 0x04 */ RomOffset vromEnd;
+    /* 0x08 */ void* vramStart;
+    /* 0x0C */ void* vramEnd;
+    /* 0x10 */ void* ovlTypeEnd;
+} WeatherOvlInfo; // size = 0x14
+
+typedef struct WeatherDmaInfo {
+    /* 0x00 */ RomOffset vromStart;
+    /* 0x04 */ RomOffset vromEnd;
+} WeatherDmaInfo;
+
+#define WEATHER_OVERLAY_NONE(name,profile)\
+    { SEGMENT_ROM_START(name), SEGMENT_ROM_END(name), profile, SEGMENT_VRAM_END(name),  profile, }
+#define WEATHER_OVERLAY(name,proc,profile) \
+    { SEGMENT_ROM_START(name), SEGMENT_ROM_END(name), proc, SEGMENT_VRAM_END(name),  profile, }
+
+#define WEATHER_SEGMENT_DMA(name)\
+    SEGMENT_ROM_START(name), SEGMENT_ROM_END(name)
 
 typedef void (*WeatherActionFunc)(struct Weather*, struct Game_Play*);
 
-typedef struct Weather {
+struct Weather {
     /* 0x000 */ Actor actor;
-    /* 0x174 */ UNK_TYPE1 unk_174[0x70];
-} Weather; // size = 0x1E4
+    /* 0x174 */ WeatherProfile* currentProfile; 
+    /* 0x178 */ s16 currentStatus;
+    /* 0x17A */ s16 nextStatus;
+    /* 0x17C */ s16 counter;
+    /* 0x17E */ s16 currentLevel;
+    /* 0x180 */ s16 currentAimLevel;
+    /* 0x182 */ s16 nextLevel;
+    /* 0x184 */ u8* segment;
+    /* 0x188 */ xyz_t pos;
+    /* 0x194 */ WeatherPrv* priv;
+    /* 0x198 */ void* allocatedSize; 
+    /* 0x19C */ u8 requestChange;
+    /* 0x19E */ s16 unk19E;
+    /* 0x1A0 */ WeatherClip clip; 
+    /* 0x1C4 */ s16 timer;
+    /* 0x1C6 */ s16 timer2;
+    /* 0x1C8 */ xyz_t windInfo;
+    /* 0x1D4 */ s16 lightningTimer;
+    /* 0x1D6 */ s16 lightningTimer2;
+    /* 0x1D8 */ s16 currentSoundEffect;
+    /* 0x1DA */ s16 umbrellaFlag;
+    /* 0x1DC */ s16 currentYAngle;
+    /* 0x1DE */ s16 soundFlag;
+    /* 0x1E0 */ s16 startSoundEffect;
+    /* 0x1E2 */ s16 stopSoundEffect;
+};  // size = 0x1E4
 
 #endif
diff --git a/src/overlays/gamestates/ovl_play/m_play.h b/src/overlays/gamestates/ovl_play/m_play.h
index fc1e404..5f523b0 100644
--- a/src/overlays/gamestates/ovl_play/m_play.h
+++ b/src/overlays/gamestates/ovl_play/m_play.h
@@ -21,6 +21,7 @@
 #include "m_pause.h"
 #include "6A8180.h"
 #include "m_scene.h"
+#include "683030.h"
 
 struct Actor;
 struct ActorEntry;
@@ -68,7 +69,7 @@ typedef struct Game_Play {
     /* 0x010C */ void* unk_010C;
     /* 0x0110 */ ObjectExchangeBank objectExchangeBank;
     /* 0x1938 */ Game_Play1938 unk_1938;
-    /* 0x1A60 */ UNK_TYPE1 unk_1A60[0x138];
+    /* 0x1A60 */ Camera2 camera;
     /* 0x1B98 */ Kankyo kankyo;
     /* 0x1C60 */ Global_light glight;
     /* 0x1C70 */ Pause pause;
diff --git a/src/overlays/weather/ac_weather_fine/ac_weather_fine.h b/src/overlays/weather/ac_weather_fine/ac_weather_fine.h
new file mode 100644
index 0000000..d17e5f4
--- /dev/null
+++ b/src/overlays/weather/ac_weather_fine/ac_weather_fine.h
@@ -0,0 +1,9 @@
+#ifndef AC_WEATHER_FINE_H
+#define AC_WEATHER_FINE_H
+
+#include "ultra64.h"
+#include "overlays/actors/ovl_Weather/ac_weather.h"
+
+extern WeatherProfile iam_weather_fine;
+
+#endif
diff --git a/src/overlays/weather/ac_weather_leaf/ac_weather_leaf.c b/src/overlays/weather/ac_weather_leaf/ac_weather_leaf.c
new file mode 100644
index 0000000..e47e19f
--- /dev/null
+++ b/src/overlays/weather/ac_weather_leaf/ac_weather_leaf.c
@@ -0,0 +1,19 @@
+#include "global.h"
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_leaf/ac_weather_leaf/func_80A3D7E0_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_leaf/ac_weather_leaf/func_80A3D834_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_leaf/ac_weather_leaf/func_80A3DA08_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_leaf/ac_weather_leaf/func_80A3DA8C_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_leaf/ac_weather_leaf/func_80A3DB5C_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_leaf/ac_weather_leaf/func_80A3DC54_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_leaf/ac_weather_leaf/func_80A3DC70_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_leaf/ac_weather_leaf/func_80A3DCF4_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_leaf/ac_weather_leaf/func_80A3DD20_jp.s")
diff --git a/src/overlays/weather/ac_weather_leaf/ac_weather_leaf.h b/src/overlays/weather/ac_weather_leaf/ac_weather_leaf.h
new file mode 100644
index 0000000..ded74aa
--- /dev/null
+++ b/src/overlays/weather/ac_weather_leaf/ac_weather_leaf.h
@@ -0,0 +1,10 @@
+#ifndef AC_WEATHER_LEAF_H
+#define AC_WEATHER_LEAF_H
+
+#include "ultra64.h"
+#include "overlays/actors/ovl_Weather/ac_weather.h"
+
+extern WeatherProfile iam_weather_leaf;
+extern void func_80A3D7E0_jp(void);
+
+#endif
diff --git a/src/overlays/weather/ac_weather_rain/ac_weather_rain.c b/src/overlays/weather/ac_weather_rain/ac_weather_rain.c
new file mode 100644
index 0000000..f82bd4f
--- /dev/null
+++ b/src/overlays/weather/ac_weather_rain/ac_weather_rain.c
@@ -0,0 +1,17 @@
+#include "global.h"
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_rain/ac_weather_rain/func_80A3C130_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_rain/ac_weather_rain/func_80A3C168_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_rain/ac_weather_rain/func_80A3C3D8_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_rain/ac_weather_rain/func_80A3C3E8_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_rain/ac_weather_rain/func_80A3C420_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_rain/ac_weather_rain/func_80A3C510_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_rain/ac_weather_rain/func_80A3C53C_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_rain/ac_weather_rain/func_80A3C5F0_jp.s")
diff --git a/src/overlays/weather/ac_weather_rain/ac_weather_rain.h b/src/overlays/weather/ac_weather_rain/ac_weather_rain.h
new file mode 100644
index 0000000..ef6ca16
--- /dev/null
+++ b/src/overlays/weather/ac_weather_rain/ac_weather_rain.h
@@ -0,0 +1,10 @@
+#ifndef AC_WEATHER_RAIN_H
+#define AC_WEATHER_RAIN_H
+
+#include "ultra64.h"
+#include "overlays/actors/ovl_Weather/ac_weather.h"
+
+extern WeatherProfile iam_weather_rain;
+extern void func_80A3C130_jp(void);
+
+#endif
diff --git a/src/overlays/weather/ac_weather_sakura/ac_weather_sakura.c b/src/overlays/weather/ac_weather_sakura/ac_weather_sakura.c
new file mode 100644
index 0000000..f724af2
--- /dev/null
+++ b/src/overlays/weather/ac_weather_sakura/ac_weather_sakura.c
@@ -0,0 +1,19 @@
+#include "global.h"
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_sakura/ac_weather_sakura/func_80A3D010_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_sakura/ac_weather_sakura/func_80A3D064_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_sakura/ac_weather_sakura/func_80A3D238_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_sakura/ac_weather_sakura/func_80A3D2BC_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_sakura/ac_weather_sakura/func_80A3D38C_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_sakura/ac_weather_sakura/func_80A3D484_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_sakura/ac_weather_sakura/func_80A3D4A0_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_sakura/ac_weather_sakura/func_80A3D530_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_sakura/ac_weather_sakura/func_80A3D55C_jp.s")
diff --git a/src/overlays/weather/ac_weather_sakura/ac_weather_sakura.h b/src/overlays/weather/ac_weather_sakura/ac_weather_sakura.h
new file mode 100644
index 0000000..2158b42
--- /dev/null
+++ b/src/overlays/weather/ac_weather_sakura/ac_weather_sakura.h
@@ -0,0 +1,10 @@
+#ifndef AC_WEATHER_SAKURA_H
+#define AC_WEATHER_SAKURA_H
+
+#include "ultra64.h"
+#include "overlays/actors/ovl_Weather/ac_weather.h"
+
+extern WeatherProfile iam_weather_sakura;
+extern void func_80A3D010_jp(void);
+
+#endif
diff --git a/src/overlays/weather/ac_weather_snow/ac_weather_snow.c b/src/overlays/weather/ac_weather_snow/ac_weather_snow.c
new file mode 100644
index 0000000..0015ff2
--- /dev/null
+++ b/src/overlays/weather/ac_weather_snow/ac_weather_snow.c
@@ -0,0 +1,19 @@
+#include "global.h"
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_snow/ac_weather_snow/func_80A3C890_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_snow/ac_weather_snow/func_80A3C8F8_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_snow/ac_weather_snow/func_80A3CACC_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_snow/ac_weather_snow/func_80A3CADC_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_snow/ac_weather_snow/func_80A3CB8C_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_snow/ac_weather_snow/func_80A3CCB4_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_snow/ac_weather_snow/func_80A3CD08_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_snow/ac_weather_snow/func_80A3CD58_jp.s")
+
+#pragma GLOBAL_ASM("asm/jp/nonmatchings/overlays/weather/ac_weather_snow/ac_weather_snow/func_80A3CD84_jp.s")
diff --git a/src/overlays/weather/ac_weather_snow/ac_weather_snow.h b/src/overlays/weather/ac_weather_snow/ac_weather_snow.h
new file mode 100644
index 0000000..61102a4
--- /dev/null
+++ b/src/overlays/weather/ac_weather_snow/ac_weather_snow.h
@@ -0,0 +1,10 @@
+#ifndef AC_WEATHER_SNOW_H
+#define AC_WEATHER_SNOW_H
+
+#include "ultra64.h"
+#include "overlays/actors/ovl_Weather/ac_weather.h"
+
+extern WeatherProfile iam_weather_snow;
+extern void func_80A3C890_jp(void);
+
+#endif
diff --git a/yamls/jp/overlays.yaml b/yamls/jp/overlays.yaml
index b45e230..4c9ecab 100644
--- a/yamls/jp/overlays.yaml
+++ b/yamls/jp/overlays.yaml
@@ -3546,7 +3546,7 @@
     bss_size: 0x0
     subsegments:
       - [0x8E9130, c, overlays/actors/ovl_Weather/ac_weather]
-      - [0x8EA700, data, overlays/actors/ovl_Weather/ac_weather]
+      - [0x8EA700, .data, overlays/actors/ovl_Weather/ac_weather]
       - [0x8EA7E0, .rodata, overlays/actors/ovl_Weather/ac_weather]
   - name: ovl_Weather_reloc
     type: code
@@ -5084,7 +5084,7 @@
     subsegments:
       - [0x903B40, data, overlays/other_ovl/ovl__00903460/ovl__00903460_reloc]
 
-  - name: ovl__00903B90
+  - name: ac_weather_fine
     type: code
     start: 0x903B90
     vram: 0x80A3C0F0
@@ -5092,100 +5092,100 @@
     compress: True
     bss_size: 0x0
     subsegments:
-      - [0x903B90, data, overlays/other_ovl/ovl__00903B90/ovl__00903B90]
-  - name: ovl__00903B90_reloc
+      - [0x903B90, data, overlays/weather/ac_weather_fine/ac_weather_fine]
+  - name: ac_weather_fine_reloc
     type: code
     start: 0x903BB0
     vram: 0x80A3C110
-    follows_vram: ovl__00903B90
+    follows_vram: ac_weather_fine
     compress: True
     subsegments:
-      - [0x903BB0, data, overlays/other_ovl/ovl__00903B90/ovl__00903B90_reloc]
+      - [0x903BB0, data, overlays/weather/ac_weather_fine/ac_weather_fine_reloc]
 
-  - name: ovl__00903BD0
+  - name: ac_weather_rain
     type: code
     start: 0x903BD0
     vram: 0x80A3C130
-    follows_vram: ovl__00903B90_reloc
+    follows_vram: ac_weather_fine_reloc
     compress: True
     bss_size: 0x0
     subsegments:
-      - [0x903BD0, asm, overlays/other_ovl/ovl__00903BD0/ovl__00903BD0]
-      - [0x904260, data, overlays/other_ovl/ovl__00903BD0/ovl__00903BD0]
-  - name: ovl__00903BD0_reloc
+      - [0x903BD0, c, overlays/weather/ac_weather_rain/ac_weather_rain]
+      - [0x904260, data, overlays/weather/ac_weather_rain/ac_weather_rain]
+  - name: ac_weather_rain_reloc
     type: code
     start: 0x9042B0
     vram: 0x80A3C810
-    follows_vram: ovl__00903BD0
+    follows_vram: ac_weather_rain
     compress: True
     subsegments:
-      - [0x9042B0, data, overlays/other_ovl/ovl__00903BD0/ovl__00903BD0_reloc]
+      - [0x9042B0, data, overlays/weather/ac_weather_rain/ac_weather_rain_reloc]
 
-  - name: ovl__00904330
+  - name: ac_weather_snow
     type: code
     start: 0x904330
     vram: 0x80A3C890
-    follows_vram: ovl__00903BD0_reloc
+    follows_vram: ac_weather_rain_reloc
     compress: True
     bss_size: 0x0
     subsegments:
-      - [0x904330, asm, overlays/other_ovl/ovl__00904330/ovl__00904330]
-      - [0x904A20, data, overlays/other_ovl/ovl__00904330/ovl__00904330]
-      - [0x904A40, rodata, overlays/other_ovl/ovl__00904330/ovl__00904330]
-  - name: ovl__00904330_reloc
+      - [0x904330, c, overlays/weather/ac_weather_snow/ac_weather_snow]
+      - [0x904A20, data, overlays/weather/ac_weather_snow/ac_weather_snow]
+      - [0x904A40, .rodata, overlays/weather/ac_weather_snow/ac_weather_snow]
+  - name: ac_weather_snow_reloc
     type: code
     start: 0x904A50
     vram: 0x80A3CFB0
-    follows_vram: ovl__00904330
+    follows_vram: ac_weather_snow
     compress: True
     subsegments:
-      - [0x904A50, data, overlays/other_ovl/ovl__00904330/ovl__00904330_reloc]
+      - [0x904A50, data, overlays/weather/ac_weather_snow/ac_weather_snow_reloc]
 
-  - name: ovl__00904AB0
+  - name: ac_weather_sakura
     type: code
     start: 0x904AB0
     vram: 0x80A3D010
-    follows_vram: ovl__00904330_reloc
+    follows_vram: ac_weather_snow_reloc
     compress: True
     bss_size: 0x0
     subsegments:
-      - [0x904AB0, asm, overlays/other_ovl/ovl__00904AB0/ovl__00904AB0]
-      - [0x9051A0, data, overlays/other_ovl/ovl__00904AB0/ovl__00904AB0]
-      - [0x9051D0, rodata, overlays/other_ovl/ovl__00904AB0/ovl__00904AB0]
-  - name: ovl__00904AB0_reloc
+      - [0x904AB0, c, overlays/weather/ac_weather_sakura/ac_weather_sakura]
+      - [0x9051A0, data, overlays/weather/ac_weather_sakura/ac_weather_sakura]
+      - [0x9051D0, .rodata, overlays/weather/ac_weather_sakura/ac_weather_sakura]
+  - name: ac_weather_sakura_reloc
     type: code
     start: 0x9051F0
     vram: 0x80A3D750
-    follows_vram: ovl__00904AB0
+    follows_vram: ac_weather_sakura
     compress: True
     subsegments:
-      - [0x9051F0, data, overlays/other_ovl/ovl__00904AB0/ovl__00904AB0_reloc]
+      - [0x9051F0, data, overlays/weather/ac_weather_sakura/ac_weather_sakura_reloc]
 
-  - name: ovl__00905280
+  - name: ac_weather_leaf
     type: code
     start: 0x905280
     vram: 0x80A3D7E0
-    follows_vram: ovl__00904AB0_reloc
+    follows_vram: ac_weather_sakura_reloc
     compress: True
     bss_size: 0x0
     subsegments:
-      - [0x905280, asm, overlays/other_ovl/ovl__00905280/ovl__00905280]
-      - [0x905950, data, overlays/other_ovl/ovl__00905280/ovl__00905280]
-      - [0x905980, rodata, overlays/other_ovl/ovl__00905280/ovl__00905280]
-  - name: ovl__00905280_reloc
+      - [0x905280, c, overlays/weather/ac_weather_leaf/ac_weather_leaf]
+      - [0x905950, data, overlays/weather/ac_weather_leaf/ac_weather_leaf]
+      - [0x905980, .rodata, overlays/weather/ac_weather_leaf/ac_weather_leaf]
+  - name: ac_weather_leaf_reloc
     type: code
     start: 0x9059A0
     vram: 0x80A3DF00
-    follows_vram: ovl__00905280
+    follows_vram: ac_weather_leaf
     compress: True
     subsegments:
-      - [0x9059A0, data, overlays/other_ovl/ovl__00905280/ovl__00905280_reloc]
+      - [0x9059A0, data, overlays/weather/ac_weather_leaf/ac_weather_leaf_reloc]
 
   - name: ovl__00905A30
     type: code
     start: 0x905A30
     vram: 0x80A3DF90
-    follows_vram: ovl__00905280_reloc
+    follows_vram: ac_weather_leaf_reloc
     compress: True
     bss_size: 0x0
     subsegments: