m_kankyo OK (#207)

* implement kankyo

* m_kankyo OK

18 files changed, 1887 insertions, 162 deletions

diff --git a/include/m_clip.h b/include/m_clip.h
index 56714f7..203a7ea 100644
--- a/include/m_clip.h
+++ b/include/m_clip.h
@@ -185,10 +185,13 @@ typedef struct StructureClip {
 
 typedef void (*Clip_unk_090_unk_00)(s8, struct xyz_t, s32, s32, struct Game_Play*, s32, s32, s32);
 typedef void (*Clip_unk_090_unk_30)(Color_RGBA8, s16,s16,s32);
+typedef s32 (*Clip_unk_090_unk_3C)(Color_RGBA8*, s32*);
 typedef struct Clip_unk_090 {
     /* 0x00 */ Clip_unk_090_unk_00 unk_00;
     /* 0x04 */ UNK_TYPE1 unk_04[0x2C];
     /* 0x30 */ Clip_unk_090_unk_30 unk_30;
+    /* 0x34 */ s8 unk_34[0x8];
+    /* 0x3C */ Clip_unk_090_unk_3C unk_3C;
 } Clip_unk_090; // size >= 0x34
 
 typedef void (*Clip_unk_09C_unk_C)(void);
diff --git a/include/m_common_data.h b/include/m_common_data.h
index 9778e70..fb351af 100644
--- a/include/m_common_data.h
+++ b/include/m_common_data.h
@@ -116,7 +116,7 @@ typedef struct CommonData {
     /* 0x00000 */ Save save;
     /* 0x10000 */ u8 unk_10000; // named "game_started" in AC GCN decomp
     /* 0x10001 */ u8 unk_10001;
-    /* 0x10002 */ u8 unk_10002;
+    /* 0x10002 */ u8 fieldDrawType;
     /* 0x10003 */ u8 playerNumber;
     /* 0x10004 */ s32 unk_10004; // named "last_scene_no" in AC GCN decomp
     /* 0x10008 */ s32 playerDataMode;
@@ -126,7 +126,8 @@ typedef struct CommonData {
     /* 0x1013C */ u8 unk_1013C[0x4];
     /* 0x10140 */ u8 unk_10140;
     /* 0x10141 */ u8 fish_location;
-    /* 0x10142 */ u8 unk_10142[0x7];
+    /* 0x10142 */ u8 unk_10142[0x6];
+    /* 0x10148 */ u8 unk_10148;
     /* 0x10149 */ u8 unk_10149;
     /* 0x1014A */ u8 unk_1014A;
     /* 0x1014B */ u8 unk_1014B; // named "wipeType" in AC GCN decomp
diff --git a/include/m_event.h b/include/m_event.h
index 9ef174b..e8d3aad 100644
--- a/include/m_event.h
+++ b/include/m_event.h
@@ -103,9 +103,9 @@ void mEv_2nd_init(Event* event);
 // void func_8007F950_jp();
 void mEv_run(Event* event);
 void mEv_finish(Event* event);
-// void func_8007FCB8_jp();
+s32 mEv_check_schedule(s32);
 // void func_8007FD40_jp();
-// void func_8007FDA8_jp();
+s32 mEv_set_status(s32,s32);
 // void func_8007FE0C_jp();
 void mEv_clear_status(s32, s16);
 // void func_8007FEBC_jp();
@@ -116,7 +116,7 @@ s32 mEv_check_status(s32, s16);
 // void func_80080040_jp();
 // void func_80080080_jp();
 // void func_80080200_jp();
-u8* func_8008033C_jp(s32,s32);
+u8* mEv_get_save_area(s32,s32);
 // void func_800804AC_jp();
 // void func_800806A0_jp();
 // void func_800807E0_jp();
diff --git a/include/m_field_info.h b/include/m_field_info.h
index cb9d6f1..f954aae 100644
--- a/include/m_field_info.h
+++ b/include/m_field_info.h
@@ -102,7 +102,7 @@ u8 mFI_BkNum2BlockType(s32,s32);
 // void func_80089348_jp();
 // void func_800893C8_jp();
 s32 mFI_CheckBlockKind_OR(s32, s32, s32);
-void mFI_BlockKind2BkNum(s32*,s32*,s32);
+s32 mFI_BlockKind2BkNum(s32*,s32*,s32);
 // void func_800894D0_jp();
 mCoBG_unkStructUnion* mFI_GetBkNum2ColTop(s32 arg0, s32 arg1);
 // void func_800895B8_jp();
diff --git a/include/m_kankyo.h b/include/m_kankyo.h
index 109586e..7535acb 100644
--- a/include/m_kankyo.h
+++ b/include/m_kankyo.h
@@ -3,88 +3,151 @@
 
 #include "ultra64.h"
 #include "unk.h"
+#include "m_lights.h"
+#include "lb_rtc.h"
 
 struct Actor;
 struct Global_light;
-struct Lights;
 struct s_xyz;
+struct Game_Play;
 
-typedef void (*Kankyo_unk_C0)(struct Actor*);
+#define ENV_SAVE_GET_WEATHER_TYPE(w) (((w) & 0xF0) >> 4) 
+#define ENV_SAVE_GET_WEATHER_INTENSITY(w) ((w) & 0xF)
+#define ENV_SAVE_SET_WEATHER(intensity, type) ( intensity | type << 4)
+
+#define mEnv_TERM 8
+#define mEnv_FOG_NEAR_MAX 996
+#define mEnv_FOG_FAR_MAX 1600
+
+typedef enum mEnv_Weather {
+    /* 0 */ mEnv_WEATHER_CLEAR,
+    /* 1 */ mEnv_WEATHER_RAIN,
+    /* 2 */ mEnv_WEATHER_SNOW,
+    /* 3 */ mEnv_WEATHER_SAKURA,
+    /* 4 */ mEnv_WEATHER_LEAVES,
+    /* 5 */ mEnv_WEATHER_MAX
+} mEnv_Weather;
+
+typedef enum mEnv_WeatherIntensity {
+    /* 0 */ mEnv_WEATHER_INTENSITY_NONE,
+    /* 1 */ mEnv_WEATHER_INTENSITY_LIGHT,
+    /* 2 */ mEnv_WEATHER_INTENSITY_NORMAL,
+    /* 3 */ mEnv_WEATHER_INTENSITY_HEAVY,
+    /* 4 */ mEnv_WEATHER_INTENSITY_MAX
+} mEnv_WeatherIntensity;
+
+typedef struct mEnv_WindInfo {
+   /* 0x00 */ lbRTC_time_c time;
+   /* 0x08 */ f32 unk8;
+   /* 0x0C */ f32 windAngleS;
+   /* 0x10 */ f32 unk10;
+   /* 0x14 */ f32 unk14;
+   /* 0x18 */ f32 windPowerF;
+   /* 0x1C */ f32 unk1C;
+} mEnv_WindInfo; // size = 0x20
+
+typedef void (*NatureProc)(struct Actor*);
+
+typedef struct BaseLight {
+    /* 0x00 */ u8 ambientColor[3];
+    /* 0x03 */ s8 sunDir[3];
+    /* 0x06 */ u8 sunColor[3];
+    /* 0x09 */ s8 moonDir[3];
+    /* 0x0C */ u8 moonColor[3];
+    /* 0x0F */ u8 fogColor[3];
+    /* 0x12 */ s16 fogNear;
+    /* 0x14 */ s16 fogFar;
+    /* 0x16 */ u8 shadowColor[3];
+    /* 0x19 */ u8 roomColor[3];
+    /* 0x1C */ u8 sunColorWindow[3];
+    /* 0x1F */ u8 moonColorWindow[3];
+    /* 0x22 */ u8 bgColor[3];
+} BaseLight; // size = 0x26
+
+typedef struct AddLightInfo {
+    /* 0x00 */ s16 ambientColor[3];
+    /* 0x06 */ s16 diffuseColor[3];
+    /* 0x0C */ s16 fogColor[3];
+    /* 0x12 */ s16 fogNear;
+    /* 0x14 */ s16 fogFar;
+} AddLightInfo; // size = 0x16
+
+typedef struct KankyoNature {
+    /* 0x0 */ NatureProc proc;
+    /* 0x4 */ void* arg;
+} KankyoNature; // size = 0x8
 
 typedef struct Kankyo {
-    /* 0x00 */ UNK_TYPE1 unk_00[0x2];
-    /* 0x02 */ s8 unk_02;
-    /* 0x03 */ s8 unk_03;
-    /* 0x04 */ s8 unk_04;
-    /* 0x05 */ UNK_TYPE1 unk_05[0x3];
-    /* 0x08 */ UNK_TYPE1 unk_08[0x14];
+    /* 0x00 */ Lights sunLight;
+    /* 0x0E */ Lights moonLight;
     /* 0x1C */ struct Lights* unk_1C;
-    /* 0x2C */ UNK_TYPE1 unk_20[0x72];
-    /* 0x92 */ u8 sunColor[3];
-    /* 0x95 */ UNK_TYPE1 unk_95[0x19];
-    /* 0xAE */ u8 unk_AE;
-    /* 0xAF */ u8 unk_AF;
-    /* 0xB0 */ u8 unk_B0;
-    /* 0xB1 */ UNK_TYPE1 unk_B1[0xB];
+    /* 0x20 */ Lights pointLight; 
+    /* 0x2E */ s16 unk2E;
+    /* 0x30 */ UNK_TYPE1 unk_30[0x40];
+    /* 0x70 */ AddLightInfo addLightsInfo;
+    /* 0x86 */ UNK_TYPE1 unk_86[0x6];
+    /* 0x8C */ BaseLight baseLight; 
+    /* 0xB2 */ UNK_TYPE1 unk_B2[0x6];
+    /* 0xB8 */ f32 shadowPos;
     /* 0xBC */ u8 shadowAlpha;
-    /* 0xBD */ UNK_TYPE1 unk_BD[0x2];
-    /* 0xC0 */ Kankyo_unk_C0 unk_C0;
-    /* 0xC4 */ UNK_TYPE1 unk_C4[0x4];
+    /* 0xBD */ u8 countdownTimer;
+    /* 0xBE */ s8 unk_BE;
+    /* 0xBC */ KankyoNature nature;
 } Kankyo; // size = 0xC8
 
-// void mEnv_regist_nature();
-// void func_80096CA0_jp();
-// void func_80096CDC_jp();
-// void func_80096D60_jp();
-// void func_80096F5C_jp();
-// void func_80097048_jp();
-// void mEnv_RoomTypeLightSet();
-void Global_kankyo_ct(struct Game_Play* game_play, struct Kankyo* kankyo);
-// void mEnv_MakeShadowInfo();
-// void mEnv_set_time();
-// void func_800976BC_jp();
-// void func_80097738_jp();
-// void func_800978EC_jp();
-// void func_80097AE8_jp();
-// void func_80097BB0_jp();
-// void func_80097C54_jp();
-// void func_80097D40_jp();
-// void func_80097F88_jp();
-// void func_80097FB4_jp();
-// void func_8009802C_jp();
-// void func_800980C0_jp();
-// void func_80098158_jp();
-// void func_800981B8_jp();
-// 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 mEnv_DecideWindDirect(struct s_xyz*, s16,s16);
-// void func_8009867C_jp();
-void mEnv_RandomWeather(s16*, s16*);
+void mEnv_regist_nature(Kankyo* kankyo, NatureProc natureProc, void* arg);
+s32 mEnv_unregist_nature(Kankyo* kankyo, NatureProc natureProc);
+s32 func_80096CDC_jp(void);
+s32 mEnv_GetNowRoomPointLightInfo(struct Game_Play* play, struct s_xyz* pos, u8* color, s16* power, s16* isFlame);
+void mEnv_RoomTypePointLightSet(struct Game_Play* play);
+void mEnv_RoomTypediffuseLightSet(struct Game_Play* play, Kankyo* kankyo);
+void mEnv_RoomTypeLightSet(struct Game_Play* play, Kankyo* kankyo);
+void Global_kankyo_ct(struct Game_Play* play, Kankyo* kankyo);
+void mEnv_MakeShadowInfo(Kankyo* kankyo);
+void mEnv_set_time(Kankyo* kankyo);
+void mEnv_ChangeRGBLight(u8* dst, u8* light0, u8* light1, f32 f0);
+void mEnv_ChangeDiffuseVctlSet(BaseLight* baseLight);
+void mEnv_ChangeDiffuseLight(BaseLight* dst, BaseLight* light0, BaseLight* light1, f32 f0);
+void mEnv_ChangeFogLight(BaseLight* dst, BaseLight* light0, BaseLight* light1, f32 f0);
+void mEnv_CalcSetLight_train(BaseLight* light);
+void mEnv_CalcSetLight(BaseLight* dst, BaseLight* light0, BaseLight* light1, f32 f0);
+void mEnv_SetBaseLight(Kankyo* kankyo);
+u8 mEnv_LimitChkRGBColor(s32 c);
+void mEnv_AddAndSetRGBColor(u8* dst, u8* src0, s16* src1);
+void mEnv_SetDiffuseLight(Kankyo* kankyo);
+void mEnv_SetFog(Kankyo* kankyo, Global_light* gLight);
+void mEnv_PermitCheckDiffuseLight(Kankyo* kankyo);
+void Global_kankyo_set_room_prim(struct Game_Play* play);
+void mEnv_check_countdown_start(struct Game_Play* play);
+void mEnv_countdown_proc(struct Game_Play* play);
+void Global_kankyo_set(struct Game_Play* play, Kankyo* kankyo, Global_light* gLight);
+void mEnv_DecideWindDirect(s_xyz* dir, s16 x, s16 z);
+s32 mEnv_GetWeatherChangeStep(void);
+void mEnv_RandomWeather(s16* next_weather, s16* next_intensity);
 s16 mEnv_GetWindAngleS(void);
 f32 mEnv_GetWindPowerF(void);
-// void func_80098990_jp();
-// void func_80098A90_jp();
+void mEnv_ChangeWind(void);
+void mEnv_InitWind(void);
 void mEnv_WindMove(void);
-// void func_80098CCC_jp();
-// void func_80098D88_jp();
+void mEnv_DecideWeather_GameStart(void);
+void mEnv_DecideWeather_FirstGameStart(void);
 void mEnv_DecideWeather_NormalGameStart(void);
-// void mEnv_NowWeather();
-// void func_80098F68_jp();
-// void func_80098FF0_jp();
-// void func_800990A8_jp();
-// void func_8009915C_jp();
-// void func_800991EC_jp();
-// void func_800992C8_jp();
-// void func_80099378_jp();
-// void func_8009944C_jp();
-// void func_8009949C_jp();
-// void func_80099594_jp();
-// void func_800996CC_jp();
-void mEnv_GetShadowPrimColor_Light(u8*,u8*,u8*, struct Game*);
-// void func_80099718_jp();
-// void func_80099728_jp();
-// void mEnv_MakeWindowLightAlpha();
-// void func_800998AC_jp();
+s32 mEnv_NowWeather(void);
+s32 mEnv_CheckNpcRoomPointLightNiceStatus(void);
+void mEnv_TaimatuPointLightWaveMoveProc(struct Game_Play* play);
+void mEnv_CheckNpcLight_ToSwitchON(struct Game_Play* play);
+void target_lighting_amb(struct Game_Play* play, f32 f0);
+void target_lighting_dif(struct Game_Play* play, f32 f0);
+void target_lighting_fog(struct Game_Play* play, f32 f0);
+void mEnv_PointLightSet(struct Game_Play* play, f32 f0);
+void staffroll_light_init(struct Game_Play* play);
+void staffroll_light_proc_start(struct Game_Play* play);
+s32 staffroll_light_proc_end(struct Game_Play* play);
+void staffroll_light_dt(struct Game_Play* play);
+void mEnv_GetShadowPrimColor_Light(u8* r, u8* g, u8* b, struct Game_Play* play);
+u8 mEnv_GetCurrentLightSwitchStatus(void);
+s32 mEnv_HereIsPlayerSelect(void);
+void mEnv_MakeWindowLightAlpha(s32 enabled);
+f32 mKK_windowlight_alpha_get(void);
 
 #endif
diff --git a/include/m_scene.h b/include/m_scene.h
index 1c9b9a1..6403836 100644
--- a/include/m_scene.h
+++ b/include/m_scene.h
@@ -115,6 +115,14 @@ typedef union SceneData {
     SceneDataArrangeFtr arrangeFtr;
 } SceneData; // size = 0x8
 
+typedef enum SceneFieldDrawType {
+    /* 0 */ FIELD_DRAW_TYPE_OUTDOORS,
+    /* 1 */ FIELD_DRAW_TYPE_INDOORS,
+    /* 2 */ FIELD_DRAW_TYPE_TRAIN,
+    /* 3 */ FIELD_DRAW_TYPE_PLAYER_SELECT,
+    /* 4 */ FIELD_DRAW_TYPE_MAX
+} SceneFieldDrawType;
+
 s32 func_800C59B0_jp(ObjectExchangeBank* objectExchangeBank);
 s32 func_800C5A08_jp(ObjectExchangeBank* objectExchangeBank);
 s32 func_800C5A60_jp(ObjectExchangeBank* objectExchangeBank);
@@ -138,15 +146,15 @@ void mSc_data_bank_ct(struct Game_Play* game_play, ObjectExchangeBank* objectExc
 void mSc_decide_exchange_bank(ObjectExchangeBank* objectExchangeBank);
 void Scene_player_select(s32 sceneNo, s32 npcActor);
 void Scene_ct(struct Game_Play* play, SceneData* sceneData);
-void Scene_Proc_Player_Ptr(struct Game_Play* play, SceneData* scene_data);
+void Scene_Proc_Player_Ptr(struct Game_Play* play, SceneData* sceneData);
 void Scene_Proc_CtrlActor_Ptr(struct Game_Play* play, SceneData* scene_data);
-void Scene_Proc_Actor_Ptr(struct Game_Play* play, SceneData* scene_data);
-void Scene_Proc_Object_Exchange_Bank_Ptr(struct Game_Play* play, SceneData* scene_data);
-void Scene_Proc_Door_Data_Ptr(struct Game_Play* play, SceneData* scene_data);
+void Scene_Proc_Actor_Ptr(struct Game_Play* play, SceneData* sceneData);
+void Scene_Proc_Object_Exchange_Bank_Ptr(struct Game_Play* play, SceneData* sceneData);
+void Scene_Proc_Door_Data_Ptr(struct Game_Play* play, SceneData* sceneData);
 void Door_info_ct(DoorInfo* door_info);
 void Scene_Proc_Sound(struct Game_Play* play, SceneData* scene_data);
 void set_item_info(struct Game_Play* play, SceneDataField* field);
-void Scene_Proc_Field_ct(struct Game_Play* play, SceneData* scene_data);
+void Scene_Proc_Field_ct(struct Game_Play* play, SceneData* sceneData);
 void Scene_Proc_ArrangeRoom_ct(struct Game_Play* play, SceneData* data);
 void Scene_Proc_ArrangeFurniture_ct(struct Game_Play* play, SceneData* data);
 s32 goto_other_scene(struct Game_Play* play, DoorData* door_data, s32 updatePlayer);
diff --git a/include/m_time.h b/include/m_time.h
index e932ffe..e1b07c7 100644
--- a/include/m_time.h
+++ b/include/m_time.h
@@ -60,6 +60,8 @@ typedef enum mTM_RENEW_TIME{
 
 #define mTM_MINUTES_IN_HOUR 60
 
+#define mTM_TIME_TO_SEC(hour, min, sec) ((hour)*mTM_SECONDS_IN_HOUR + (min)*mTM_SECONDS_IN_MINUTE + (sec))
+
 typedef struct TimeCalendarTerm {
     /* 0x00 */ lbRTC_month_t month;
     /* 0x01 */ lbRTC_day_t day;
diff --git a/linker_scripts/jp/symbol_addrs_code.txt b/linker_scripts/jp/symbol_addrs_code.txt
index 4d03bb5..9c14123 100644
--- a/linker_scripts/jp/symbol_addrs_code.txt
+++ b/linker_scripts/jp/symbol_addrs_code.txt
@@ -1139,9 +1139,9 @@ mEv_2nd_init = 0x8007F8DC; // type:func
 func_8007F950_jp = 0x8007F950; // type:func
 mEv_run = 0x8007F988; // type:func
 mEv_finish = 0x8007FB44; // type:func
-func_8007FCB8_jp = 0x8007FCB8; // type:func
+mEv_check_schedule = 0x8007FCB8; // type:func
 func_8007FD40_jp = 0x8007FD40; // type:func
-func_8007FDA8_jp = 0x8007FDA8; // type:func
+mEv_set_status = 0x8007FDA8; // type:func
 func_8007FE0C_jp = 0x8007FE0C; // type:func
 mEv_clear_status = 0x8007FE74; // type:func
 func_8007FEBC_jp = 0x8007FEBC; // type:func
@@ -1152,7 +1152,7 @@ func_80080000_jp = 0x80080000; // type:func
 func_80080040_jp = 0x80080040; // type:func
 func_80080080_jp = 0x80080080; // type:func
 func_80080200_jp = 0x80080200; // type:func
-func_8008033C_jp = 0x8008033C; // type:func
+mEv_get_save_area = 0x8008033C; // type:func
 func_800804AC_jp = 0x800804AC; // type:func
 func_800806A0_jp = 0x800806A0; // type:func
 func_800807E0_jp = 0x800807E0; // type:func
@@ -1711,59 +1711,59 @@ func_80096B4C_jp = 0x80096B4C; // type:func
 Kabu_manager = 0x80096B64; // type:func
 func_80096BF0_jp = 0x80096BF0; // type:func
 mEnv_regist_nature = 0x80096C90; // type:func
-func_80096CA0_jp = 0x80096CA0; // type:func
+mEnv_unregist_nature = 0x80096CA0; // type:func
 func_80096CDC_jp = 0x80096CDC; // type:func
-func_80096D60_jp = 0x80096D60; // type:func
-func_80096F5C_jp = 0x80096F5C; // type:func
-func_80097048_jp = 0x80097048; // type:func
+mEnv_GetNowRoomPointLightInfo = 0x80096D60; // type:func
+mEnv_RoomTypePointLightSet = 0x80096F5C; // type:func
+mEnv_RoomTypediffuseLightSet = 0x80097048; // type:func
 mEnv_RoomTypeLightSet = 0x800970D4; // type:func
 Global_kankyo_ct = 0x80097108; // type:func
 mEnv_MakeShadowInfo = 0x800971B4; // type:func
 mEnv_set_time = 0x80097510; // type:func
-func_800976BC_jp = 0x800976BC; // type:func
-func_80097738_jp = 0x80097738; // type:func
-func_800978EC_jp = 0x800978EC; // type:func
-func_80097AE8_jp = 0x80097AE8; // type:func
-func_80097BB0_jp = 0x80097BB0; // type:func
-func_80097C54_jp = 0x80097C54; // type:func
-func_80097D40_jp = 0x80097D40; // type:func
-func_80097F88_jp = 0x80097F88; // type:func
-func_80097FB4_jp = 0x80097FB4; // type:func
-func_8009802C_jp = 0x8009802C; // type:func
-func_800980C0_jp = 0x800980C0; // type:func
-func_80098158_jp = 0x80098158; // type:func
-func_800981B8_jp = 0x800981B8; // type:func
-func_8009836C_jp = 0x8009836C; // type:func
-func_800983F0_jp = 0x800983F0; // type:func
+mEnv_ChangeRGBLight = 0x800976BC; // type:func
+mEnv_ChangeDiffuseVctlSet = 0x80097738; // type:func
+mEnv_ChangeDiffuseLight = 0x800978EC; // type:func
+mEnv_ChangeFogLight = 0x80097AE8; // type:func
+mEnv_CalcSetLight_train = 0x80097BB0; // type:func
+mEnv_CalcSetLight = 0x80097C54; // type:func
+mEnv_SetBaseLight = 0x80097D40; // type:func
+mEnv_LimitChkRGBColor = 0x80097F88; // type:func
+mEnv_AddAndSetRGBColor = 0x80097FB4; // type:func
+mEnv_SetDiffuseLight = 0x8009802C; // type:func
+mEnv_SetFog = 0x800980C0; // type:func
+mEnv_PermitCheckDiffuseLight = 0x80098158; // type:func
+Global_kankyo_set_room_prim = 0x800981B8; // type:func
+mEnv_check_countdown_start = 0x8009836C; // type:func
+mEnv_countdown_proc = 0x800983F0; // type:func
 Global_kankyo_set = 0x800984CC; // type:func
 mEnv_DecideWindDirect = 0x80098558; // type:func
-func_8009867C_jp = 0x8009867C; // type:func
+mEnv_GetWeatherChangeStep = 0x8009867C; // type:func
 mEnv_RandomWeather = 0x80098794; // type:func
 mEnv_GetWindAngleS = 0x8009895C; // type:func
 mEnv_GetWindPowerF = 0x80098980; // type:func
-func_80098990_jp = 0x80098990; // type:func
-func_80098A90_jp = 0x80098A90; // type:func
+mEnv_ChangeWind = 0x80098990; // type:func
+mEnv_InitWind = 0x80098A90; // type:func
 mEnv_WindMove = 0x80098B50; // type:func
-func_80098CCC_jp = 0x80098CCC; // type:func
-func_80098D88_jp = 0x80098D88; // type:func
+mEnv_DecideWeather_GameStart = 0x80098CCC; // type:func
+mEnv_DecideWeather_FirstGameStart = 0x80098D88; // type:func
 mEnv_DecideWeather_NormalGameStart = 0x80098DE0; // type:func
 mEnv_NowWeather = 0x80098EE4; // type:func
-func_80098F68_jp = 0x80098F68; // type:func
-func_80098FF0_jp = 0x80098FF0; // type:func
-func_800990A8_jp = 0x800990A8; // type:func
-func_8009915C_jp = 0x8009915C; // type:func
-func_800991EC_jp = 0x800991EC; // type:func
-func_800992C8_jp = 0x800992C8; // type:func
-func_80099378_jp = 0x80099378; // type:func
-func_8009944C_jp = 0x8009944C; // type:func
-func_8009949C_jp = 0x8009949C; // type:func
-func_80099594_jp = 0x80099594; // type:func
-func_800996CC_jp = 0x800996CC; // type:func
+mEnv_CheckNpcRoomPointLightNiceStatus = 0x80098F68; // type:func
+mEnv_TaimatuPointLightWaveMoveProc = 0x80098FF0; // type:func
+mEnv_CheckNpcLight_ToSwitchON = 0x800990A8; // type:func
+target_lighting_amb = 0x8009915C; // type:func
+target_lighting_dif = 0x800991EC; // type:func
+target_lighting_fog = 0x800992C8; // type:func
+mEnv_PointLightSet = 0x80099378; // type:func
+staffroll_light_init = 0x8009944C; // type:func
+staffroll_light_proc_start = 0x8009949C; // type:func
+staffroll_light_proc_end = 0x80099594; // type:func
+staffroll_light_dt = 0x800996CC; // type:func
 mEnv_GetShadowPrimColor_Light = 0x800996F8; // type:func
-func_80099718_jp = 0x80099718; // type:func
-func_80099728_jp = 0x80099728; // type:func
+mEnv_GetCurrentLightSwitchStatus = 0x80099718; // type:func
+mEnv_HereIsPlayerSelect = 0x80099728; // type:func
 mEnv_MakeWindowLightAlpha = 0x80099770; // type:func
-func_800998AC_jp = 0x800998AC; // type:func
+mKK_windowlight_alpha_get = 0x800998AC; // type:func
 mem_copy = 0x800998C0; // type:func
 mem_clear = 0x8009992C; // type:func
 mem_cmp = 0x80099980; // type:func
diff --git a/src/code/m_actor.c b/src/code/m_actor.c
index 0ed22bb..53c22f9 100644
--- a/src/code/m_actor.c
+++ b/src/code/m_actor.c
@@ -60,7 +60,7 @@ void Actor_position_move(Actor* actor) {
 
     speedRate = game_GameFrame_2F;
 
-    kankyo->unk_C0(actor);
+    kankyo->nature.proc(actor);
 
     actor->world.pos.x += actor->velocity.x * speedRate + actor->colStatus.displacement.x;
     actor->world.pos.y += actor->velocity.y * speedRate + actor->colStatus.displacement.y;
@@ -1111,26 +1111,26 @@ Hilite* HiliteReflect_light_init(xyz_t* object, xyz_t* eye, xyz_t* lightDir, Gra
 Hilite* Setpos_HiliteReflect_init(xyz_t* object, Game_Play* game_play) {
     xyz_t sp24;
 
-    sp24.x = game_play->kankyo.unk_02;
-    sp24.y = game_play->kankyo.unk_03;
-    sp24.z = game_play->kankyo.unk_04;
+    sp24.x = game_play->kankyo.sunLight.lights.diffuse.x;
+    sp24.y = game_play->kankyo.sunLight.lights.diffuse.y;
+    sp24.z = game_play->kankyo.sunLight.lights.diffuse.z;
     return HiliteReflect_init(object, &game_play->view.eye, &sp24, game_play->state.gfxCtx);
 }
 
 Hilite* Setpos_HiliteReflect_xlu_init(xyz_t* object, Game_Play* game_play) {
     xyz_t sp24;
 
-    sp24.x = game_play->kankyo.unk_02;
-    sp24.y = game_play->kankyo.unk_03;
-    sp24.z = game_play->kankyo.unk_04;
+    sp24.x = game_play->kankyo.sunLight.lights.diffuse.x;
+    sp24.y = game_play->kankyo.sunLight.lights.diffuse.y;
+    sp24.z = game_play->kankyo.sunLight.lights.diffuse.z;
     return HiliteReflect_xlu_init(object, &game_play->view.eye, &sp24, game_play->state.gfxCtx);
 }
 
 Hilite* Setpos_HiliteReflect_light_init(xyz_t* object, Game_Play* game_play) {
     xyz_t sp24;
 
-    sp24.x = game_play->kankyo.unk_02;
-    sp24.y = game_play->kankyo.unk_03;
-    sp24.z = game_play->kankyo.unk_04;
+    sp24.x = game_play->kankyo.sunLight.lights.diffuse.x;
+    sp24.y = game_play->kankyo.sunLight.lights.diffuse.y;
+    sp24.z = game_play->kankyo.sunLight.lights.diffuse.z;
     return HiliteReflect_xlu_init(object, &game_play->view.eye, &sp24, game_play->state.gfxCtx);
 }
diff --git a/src/code/m_actor_shadow.c b/src/code/m_actor_shadow.c
index 6ddc884..0856920 100644
--- a/src/code/m_actor_shadow.c
+++ b/src/code/m_actor_shadow.c
@@ -261,7 +261,7 @@ void mActorShadow_DrawActorShadow(Actor* actor, ShadowInfo* shadow, Game* game,
     }
 
     gSPMatrix(SHADOW_DISP++, _Matrix_to_Mtx_new(play->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
-    mEnv_GetShadowPrimColor_Light(&r, &g, &b, &play->state);
+    mEnv_GetShadowPrimColor_Light(&r, &g, &b, play);
     gDPSetPrimColor(SHADOW_DISP++, 0, 0xFF, r, g, b, (u8)alpha);
 
     if ((shadow->kind == 0) && (id == 0)) {
diff --git a/src/code/m_kankyo.c b/src/code/m_kankyo.c
new file mode 100644
index 0000000..faa526d
--- /dev/null
+++ b/src/code/m_kankyo.c
@@ -0,0 +1,1649 @@
+#include "m_kankyo.h"
+#include "m_time.h"
+#include "m_lib.h"
+#include "m_common_data.h"
+#include "m_scene_table.h"
+#include "macros.h"
+#include "m_field_info.h"
+#include "m_event.h"
+#include "audio.h"
+#include "m_all_grow.h"
+#include "overlays/actors/player_actor/m_player.h"
+#include "m_player_lib.h"
+
+// fake names following l_mEnv_electric_light naming convention, since that's what these got refactored to
+u8 l_mEnv_index_light_switch_electric_light = 0; // needs to be signed in iQue
+s16 l_mEnv_point_light_is_flame_electric_light = 0;
+
+s32 klight_chg_time[] = {
+    mTM_TIME_TO_SEC(0, 0, 0),  mTM_TIME_TO_SEC(4, 0, 0),  mTM_TIME_TO_SEC(6, 0, 0),
+    mTM_TIME_TO_SEC(8, 0, 0),  mTM_TIME_TO_SEC(12, 0, 0), mTM_TIME_TO_SEC(16, 0, 0),
+    mTM_TIME_TO_SEC(18, 0, 0), mTM_TIME_TO_SEC(20, 0, 0), mTM_TIME_TO_SEC(24, 0, 0),
+};
+
+BaseLight l_mEnv_kcolor_fine_data[] = {
+    /* 00:00 -> 03:59 */
+    {
+        { 20, 10, 120 }, // ambient color
+
+        { 73, 73, 73 }, // sun direction
+        { 0, 0, 0 },    // sun color
+
+        { 73, 73, 73 },   // moon direction
+        { 120, 180, 80 }, // moon color
+
+        { 20, 20, 80 }, // fog color
+        1799,           // fog near
+        1000,           // fog far
+
+        { 0, 0, 20 },      // shadow color
+        { 120, 160, 150 }, // room color
+        { 120, 160, 150 }, // window sun color
+        { 240, 255, 120 }, // window moon color
+        { 28, 32, 92 }     // background color
+    },
+
+    {
+        { 0, 20, 100 }, // ambient color
+
+        { 73, 73, 73 }, // sun direction
+        { 0, 20, 40 },  // sun color
+
+        { 73, 73, 73 },    // moon direction
+        { 150, 200, 100 }, // moon color
+
+        { 60, 80, 120 }, // fog color
+        1799,            // fog near
+        950,             // fog far
+
+        { 0, 10, 30 },     // shadow color
+        { 120, 180, 200 }, // room color
+        { 120, 200, 200 }, // window sun color
+        { 240, 255, 120 }, // window moon color
+        { 32, 48, 104 }    // background color
+    },
+
+    {
+        { 60, 60, 120 }, // ambient color
+
+        { 73, 73, 73 },    // sun direction
+        { 255, 255, 200 }, // sun color
+
+        { 73, 73, 73 }, // moon direction
+        { 10, 40, 60 }, // moon color
+
+        { 120, 120, 120 }, // fog color
+        1799,              // fog near
+        900,               // fog far
+
+        { 0, 20, 40 },     // shadow color
+        { 240, 255, 255 }, // room color
+        { 240, 255, 255 }, // window sun color
+        { 240, 255, 120 }, // window moon color
+        { 48, 52, 128 }    // background color
+    },
+
+    {
+        { 100, 100, 150 }, // ambient color
+
+        { 73, 73, 73 },    // sun direction
+        { 255, 255, 200 }, // sun color
+
+        { 73, 73, 73 }, // moon direction
+        { 0, 10, 20 },  // moon color
+
+        { 80, 100, 120 }, // fog color
+        1799,             // fog near
+        1000,             // fog far
+
+        { 0, 30, 60 },     // shadow color
+        { 255, 255, 220 }, // room color
+        { 255, 255, 240 }, // window sun color
+        { 240, 255, 120 }, // window moon color
+        { 40, 56, 140 }    // background color
+    },
+
+    {
+        { 80, 80, 150 }, // ambient color
+
+        { 73, 73, 73 },    // sun direction
+        { 255, 255, 200 }, // sun color
+
+        { 73, 73, 73 }, // moon direction
+        { 0, 0, 0 },    // moon color
+
+        { 180, 100, 120 }, // fog color
+        1949,              // fog near
+        1000,              // fog far
+
+        { 0, 20, 60 },     // shadow color
+        { 255, 255, 220 }, // room color
+        { 255, 255, 240 }, // window sun color
+        { 240, 255, 120 }, // window moon color
+        { 32, 48, 144 }    // background color
+    },
+
+    {
+        { 80, 80, 120 }, // ambient color
+
+        { 73, 73, 73 },    // sun direction
+        { 255, 240, 100 }, // sun color
+
+        { 73, 73, 73 }, // moon direction
+        { 10, 0, 30 },  // moon color
+
+        { 80, 100, 120 }, // fog color
+        1949,             // fog near
+        1000,             // fog far
+
+        { 0, 0, 60 },      // shadow color
+        { 255, 250, 200 }, // room color
+        { 255, 250, 200 }, // window sun color
+        { 240, 255, 120 }, // window moon color
+        { 36, 40, 104 }    // background color
+    },
+
+    {
+        { 60, 60, 120 }, // ambient color
+
+        { 73, 73, 73 },  // sun direction
+        { 255, 100, 0 }, // sun color
+
+        { 73, 73, 73 }, // moon direction
+        { 20, 0, 60 },  // moon color
+
+        { 50, 60, 100 }, // fog color
+        1949,            // fog near
+        1000,            // fog far
+
+        { 0, 0, 40 },      // shadow color
+        { 255, 140, 120 }, // room color
+        { 255, 160, 140 }, // window sun color
+        { 240, 255, 120 }, // window moon color
+        { 24, 24, 80 }     // background color
+    },
+
+    {
+        { 30, 30, 120 }, // ambient color
+
+        { 73, 73, 73 }, // sun direction
+        { 60, 60, 0 },  // sun color
+
+        { 73, 73, 73 },   // moon direction
+        { 120, 180, 80 }, // moon color
+
+        { 20, 20, 80 }, // fog color
+        1949,           // fog near
+        1000,           // fog far
+
+        { 0, 0, 30 },      // shadow color
+        { 150, 130, 120 }, // room color
+        { 255, 160, 140 }, // window sun color
+        { 240, 255, 120 }, // window moon color
+        { 24, 24, 96 }     // background color
+    }
+};
+
+BaseLight l_mEnv_kcolor_rain_data[] = {
+    {
+        { 20, 10, 120 }, // ambient color
+
+        { 73, 73, 73 }, // sun direction
+        { 0, 0, 0 },    // sun color
+
+        { 73, 73, 73 },   // moon direction
+        { 120, 180, 80 }, // moon color
+
+        { 20, 20, 80 }, // fog color
+        1799,           // fog near
+        1000,           // fog far
+
+        { 0, 0, 20 },      // shadow color
+        { 120, 160, 150 }, // room color
+        { 120, 160, 150 }, // window sun color
+        { 230, 230, 120 }, // window moon color
+        { 28, 32, 92 }     // background color
+    },
+
+    {
+        { 30, 20, 120 }, // ambient color
+
+        { 73, 73, 73 }, // sun direction
+        { 0, 20, 40 },  // sun color
+
+        { 73, 73, 73 },   // moon direction
+        { 120, 180, 80 }, // moon color
+
+        { 80, 100, 120 }, // fog color
+        1774,             // fog near
+        1000,             // fog far
+
+        { 0, 10, 30 },     // shadow color
+        { 140, 190, 190 }, // room color
+        { 150, 170, 170 }, // window sun color
+        { 230, 230, 120 }, // window moon color
+        { 44, 52, 112 }    // background color
+    },
+
+    {
+        { 60, 60, 120 }, // ambient color
+
+        { 73, 73, 73 },    // sun direction
+        { 150, 180, 180 }, // sun color
+
+        { 73, 73, 73 }, // moon direction
+        { 10, 40, 60 }, // moon color
+
+        { 120, 150, 150 }, // fog color
+        1749,              // fog near
+        950,               // fog far
+
+        { 0, 20, 40 },     // shadow color
+        { 180, 210, 210 }, // room color
+        { 160, 180, 180 }, // window sun color
+        { 230, 230, 120 }, // window moon color
+        { 60, 76, 120 }    // background color
+    },
+
+    {
+        { 80, 80, 150 }, // ambient color
+
+        { 73, 73, 73 },    // sun direction
+        { 180, 220, 220 }, // sun color
+
+        { 73, 73, 73 }, // moon direction
+        { 0, 10, 20 },  // moon color
+
+        { 80, 120, 150 }, // fog color
+        1749,             // fog near
+        1000,             // fog far
+
+        { 0, 20, 60 },     // shadow color
+        { 210, 240, 240 }, // room color
+        { 190, 220, 220 }, // window sun color
+        { 230, 230, 120 }, // window moon color
+        { 56, 72, 140 }    // background color
+    },
+
+    {
+        { 80, 80, 150 }, // ambient color
+
+        { 73, 73, 73 },    // sun direction
+        { 200, 240, 240 }, // sun color
+
+        { 73, 73, 73 }, // moon direction
+        { 0, 0, 0 },    // moon color
+
+        { 80, 120, 150 }, // fog color
+        1749,             // fog near
+        1000,             // fog far
+
+        { 0, 20, 60 },     // shadow color
+        { 220, 250, 250 }, // room color
+        { 210, 240, 240 }, // window sun color
+        { 230, 230, 120 }, // window moon color
+        { 52, 78, 144 }    // background color
+    },
+
+    {
+        { 80, 80, 150 }, // ambient color
+
+        { 73, 73, 73 },    // sun direction
+        { 200, 240, 240 }, // sun color
+
+        { 73, 73, 73 }, // moon direction
+        { 10, 0, 30 },  // moon color
+
+        { 80, 120, 150 }, // fog color
+        1749,             // fog near
+        1000,             // fog far
+
+        { 0, 20, 60 },     // shadow color
+        { 220, 250, 250 }, // room color
+        { 220, 240, 240 }, // window sun color
+        { 230, 230, 120 }, // window moon color
+        { 48, 72, 140 }    // background color
+    },
+
+    {
+        { 60, 60, 150 }, // ambient color
+
+        { 73, 73, 73 },  // sun direction
+        { 200, 120, 0 }, // sun color
+
+        { 73, 73, 73 }, // moon direction
+        { 20, 0, 80 },  // moon color
+
+        { 20, 20, 80 }, // fog color
+        1774,           // fog near
+        1000,           // fog far
+
+        { 0, 20, 50 },     // shadow color
+        { 190, 120, 120 }, // room color
+        { 180, 120, 120 }, // window sun color
+        { 230, 230, 120 }, // window moon color
+        { 32, 32, 92 }     // background color
+    },
+
+    {
+        { 30, 30, 120 }, // ambient color
+
+        { 73, 73, 73 }, // sun direction
+        { 60, 60, 0 },  // sun color
+
+        { 73, 73, 73 },   // moon direction
+        { 120, 180, 80 }, // moon color
+
+        { 20, 20, 80 }, // fog color
+        1774,           // fog near
+        1000,           // fog far
+
+        { 0, 0, 30 },      // shadow color
+        { 130, 160, 160 }, // room color
+        { 180, 120, 120 }, // window sun color
+        { 230, 230, 120 }, // window moon color
+        { 28, 28, 92 }     // background color
+    },
+};
+
+BaseLight l_mEnv_kcolor_data_p_sel = {
+    { 30, 30, 80 }, // ambient color
+
+    { 0, 89, 79 },     // sun direction
+    { 255, 255, 200 }, // sun color
+
+    { 0, 185, 160 }, // moon direction
+    { 0, 0, 0 },     // moon color
+
+    { 100, 100, 120 }, // fog color
+    2000,              // fog near
+    1280,              // fog far
+
+    { 0, 20, 60 },     // shadow color
+    { 255, 255, 255 }, // room color
+    { 0, 0, 0 },       // window sun color
+    { 0, 0, 0 },       // window moon color
+    { 22, 27, 94 }     // background color
+};
+
+BaseLight l_mEnv_kcolor_shop = {
+    { 20, 10, 100 }, // ambient color
+
+    { 0, 69, 97 },     // sun direction
+    { 150, 160, 130 }, // sun color
+
+    { 0, 223, 115 }, // moon direction
+    { 50, 40, 20 },  // moon color
+
+    { 100, 100, 120 }, // fog color
+    2000,              // fog near
+    1280,              // fog far
+
+    { 0, 20, 60 },     // shadow color
+    { 255, 255, 255 }, // room color
+    { 0, 0, 0 },       // window sun color
+    { 0, 0, 0 },       // window moon color
+    { 22, 27, 94 }     // background color
+};
+
+BaseLight l_mEnv_kcolor_buggy = {
+    { 30, 30, 30 }, // ambient color
+
+    { 0, 69, 97 }, // sun direction
+    { 0, 0, 0 },   // sun color
+
+    { 0, 223, 115 }, // moon direction
+    { 0, 60, 90 },   // moon color
+
+    { 100, 100, 120 }, // fog color
+    2000,              // fog near
+    1280,              // fog far
+
+    { 0, 20, 60 },     // shadow color
+    { 175, 175, 155 }, // room color
+    { 0, 0, 0 },       // window sun color
+    { 0, 0, 0 },       // window moon color
+    { 22, 27, 94 }     // background color
+};
+
+BaseLight l_mEnv_kcolor_kamakura = {
+    { 50, 25, 20 }, // ambient color
+
+    { 0, 69, 97 }, // sun direction
+    { 50, 40, 5 }, // sun color
+
+    { 0, 223, 115 }, // moon direction
+    { 50, 80, 85 },  // moon color
+
+    { 100, 100, 120 }, // fog color
+    2000,              // fog near
+    1280,              // fog far
+
+    { 0, 20, 60 },     // shadow color
+    { 250, 240, 160 }, // room color
+    { 0, 0, 0 },       // window sun color
+    { 0, 0, 0 },       // window moon color
+    { 22, 27, 94 }     // background color
+};
+
+BaseLight* l_mEnv_normal_kcolor_data[] = {
+    l_mEnv_kcolor_fine_data, // clear
+    l_mEnv_kcolor_rain_data, // rain
+    l_mEnv_kcolor_rain_data, // snow
+    l_mEnv_kcolor_fine_data  // cherry blossoms
+};
+
+LightNode* S_get_light_list;
+
+// fake names following l_mEnv_electric_light naming convention, since that's what these got refactored to
+u8 l_mEnv_point_light_on_electric_light;
+s16 l_mEnv_add_moon_color_electric_light[3];
+f32 l_mEnv_staffroll_fade_rate_electric_light;
+f32 l_mEnv_sun_percent_electric_light;
+f32 l_mEnv_shadow_adjust_electric_light;
+f32 l_mEnv_windowlight_alpha_electric_light;
+LightNode* l_mEnv_current_lightnode_electric_light;
+
+void mEnv_regist_nature(Kankyo* kankyo, NatureProc natureProc, void* arg) {
+    kankyo->nature.proc = natureProc;
+    kankyo->nature.arg = arg;
+}
+
+s32 mEnv_unregist_nature(Kankyo* kankyo, NatureProc natureProc) {
+    s32 res = FALSE;
+
+    if (natureProc == kankyo->nature.proc) {
+        mEnv_regist_nature(kankyo, (void*)none_proc1, NULL);
+        res = TRUE;
+    }
+
+    return res;
+}
+
+s32 func_80096CDC_jp() {
+    s32 ret = TRUE;
+    UNUSED s32 pad;
+    u16 homeId = common_data.houseOwnerName & 3;
+
+    if (!mEv_CheckFirstIntro() && mPr_NullCheckPersonalID(&common_data.save.homes[homeId].ownerID)) {
+        ret = FALSE;
+    }
+
+    return ret;
+}
+
+#define SET_COLOR(color, r, g, b) \
+    (color[0] = r);               \
+    (color[1] = g);               \
+    (color[2] = b)
+
+#define SET_POS(pos, xValue, yValue, zValue) \
+    (pos->x = xValue);                       \
+    (pos->y = yValue);                       \
+    (pos->z = zValue)
+
+s32 mEnv_GetNowRoomPointLightInfo(UNUSED Game_Play* play, s_xyz* pos, u8* color, s16* power, s16* isFlame) {
+    u8 res = TRUE;
+
+    switch (common_data.fieldDrawType) {
+        case FIELD_DRAW_TYPE_INDOORS: {
+            SET_COLOR(color, 160, 160, 160);
+
+            power[0] = 1000;
+
+            switch (common_data.save.sceneNo) {
+                case SCENE_MY_ROOM_S: {
+                    if (func_80096CDC_jp() == TRUE) {
+                        SET_POS(pos, 120, 180, 180);
+                    } else {
+                        res = FALSE;
+                    }
+
+                    break;
+                }
+
+                case SCENE_MY_ROOM_M:
+                case SCENE_SHOP0:
+                case SCENE_POST_OFFICE:
+                case SCENE_NPC_HOUSE: {
+                    SET_POS(pos, 160, 180, 240);
+
+                    break;
+                }
+
+                case SCENE_BUGGY: {
+                    SET_POS(pos, 160, 80, 200);
+                    SET_COLOR(color, 205, 165, 110);
+
+                    power[0] = 155;
+                    *isFlame = TRUE;
+
+                    break;
+                }
+
+                case SCENE_MY_ROOM_L:
+                case SCENE_POLICE_BOX: {
+                    SET_POS(pos, 200, 220, 300);
+
+                    break;
+                }
+
+                case SCENE_KAMAKURA: {
+                    SET_POS(pos, 160, 80, 38);
+                    SET_COLOR(color, 250, 240, 120);
+
+                    power[0] = 300;
+                    *isFlame = TRUE;
+
+                    break;
+                }
+
+                default: {
+                    SET_POS(pos, 250, 1000, 378);
+
+                    power[0] = 8000;
+
+                    break;
+                }
+            }
+
+            break;
+        }
+
+        case FIELD_DRAW_TYPE_TRAIN: {
+            switch (common_data.save.sceneNo) {
+                case SCENE_START_DEMO: {
+                    common_data.sunlightFlag = FALSE;
+
+                    break;
+                }
+            }
+
+            l_mEnv_sun_percent_electric_light = 0.0f;
+
+            SET_POS(pos, 80, 120, 510);
+            SET_COLOR(color, 255, 255, 160);
+
+            power[0] = 1200;
+
+            break;
+        }
+
+        default:
+            res = FALSE;
+            break;
+    }
+
+    return res;
+}
+
+void mEnv_RoomTypePointLightSet(Game_Play* play) {
+    Game_Play* play2 = play;
+    u8 color[3];
+    s16 power;
+    s_xyz pos;
+
+    l_mEnv_point_light_on_electric_light = 0;
+    l_mEnv_point_light_is_flame_electric_light = FALSE;
+
+    if (mEnv_GetNowRoomPointLightInfo(play2, &pos, color, &power, &l_mEnv_point_light_is_flame_electric_light) ==
+        TRUE) {
+        if (common_data.save.sceneNo == SCENE_NPC_HOUSE && mEnv_CheckNpcRoomPointLightNiceStatus() == FALSE) {
+            l_mEnv_index_light_switch_electric_light = 1;
+        } else {
+            l_mEnv_index_light_switch_electric_light = 0;
+
+            Light_point_ct(&play2->kankyo.pointLight, pos.x, pos.y, pos.z, color[0], color[1], color[2], power);
+
+            l_mEnv_current_lightnode_electric_light =
+                Global_light_list_new(play2, &play2->glight, &play2->kankyo.pointLight);
+            l_mEnv_point_light_on_electric_light = 1;
+        }
+    }
+}
+
+void mEnv_RoomTypediffuseLightSet(Game_Play* play, Kankyo* kankyo) {
+    Game_Play* play2 = play;
+
+    Light_diffuse_ct(&kankyo->sunLight, 1, 0, 0, 0, 0, 0);
+    Global_light_list_new(play2, &play2->glight, &kankyo->sunLight);
+
+    Light_diffuse_ct(&kankyo->moonLight, 1, 0, 0, 0, 0, 0);
+    Global_light_list_new(play2, &play2->glight, &kankyo->moonLight);
+}
+
+void mEnv_RoomTypeLightSet(Game_Play* play, Kankyo* kankyo) {
+    Game_Play* play2 = play;
+
+    mEnv_RoomTypePointLightSet(play2);
+    mEnv_RoomTypediffuseLightSet(play2, kankyo);
+}
+
+void Global_kankyo_ct(Game_Play* play, Kankyo* kankyo) {
+    l_mEnv_shadow_adjust_electric_light = 1.0f;
+    l_mEnv_sun_percent_electric_light = 1.0f;
+    l_mEnv_index_light_switch_electric_light = 0;
+    l_mEnv_current_lightnode_electric_light = NULL;
+
+    bzero(kankyo, sizeof(Kankyo));
+    bzero(l_mEnv_add_moon_color_electric_light, sizeof(l_mEnv_add_moon_color_electric_light));
+
+    common_data.unk_10148 = 0;
+
+    mEnv_set_time(kankyo);
+    kankyo->countdownTimer = 0xFF;
+    mEnv_RoomTypeLightSet(play, kankyo);
+    mEnv_regist_nature(kankyo, (void*)none_proc1, NULL);
+    mEnv_MakeWindowLightAlpha(FALSE);
+}
+void mEnv_MakeShadowInfo(Kankyo* kankyo) {
+    u8 hour = common_data.time.rtcTime.hour;
+    u8 min = common_data.time.rtcTime.min;
+    u8 sec = common_data.time.rtcTime.sec;
+    s32 time = mTM_TIME_TO_SEC(hour, min, sec);
+    f32 shadowAdjust;
+    f32 preAdjust;
+    s32 tmp;
+    s32 transitionZero = FALSE;
+
+    if (time > mTM_TIME_TO_SEC(6, 0, 0) && time < mTM_TIME_TO_SEC(18, 0, 0)) {
+        shadowAdjust = 1.0f;
+    } else if (time < mTM_TIME_TO_SEC(3, 59, 30) || time > mTM_TIME_TO_SEC(20, 0, 3)) {
+        shadowAdjust = 0.4f;
+    } else if (time >= mTM_TIME_TO_SEC(4, 0, 3) && time <= mTM_TIME_TO_SEC(6, 0, 0)) {
+        preAdjust = ((time - mTM_TIME_TO_SEC(3, 59, 57)) / (f32)mTM_TIME_TO_SEC(2, 0, 3));
+        shadowAdjust = 0.6f * preAdjust + 0.4f;
+    } else if (time >= mTM_TIME_TO_SEC(18, 0, 0) && time <= mTM_TIME_TO_SEC(19, 59, 30)) {
+        preAdjust = (1.0f - ((time - mTM_TIME_TO_SEC(18, 0, 0)) / (f32)mTM_TIME_TO_SEC(1, 59, 30)));
+        shadowAdjust = 0.6f * preAdjust + 0.4f;
+
+    } else {
+        transitionZero = TRUE;
+        shadowAdjust = 0.4f;
+    }
+
+    if (transitionZero == TRUE) {
+        if ((time > mTM_TIME_TO_SEC(3, 59, 55) && time < mTM_TIME_TO_SEC(4, 0, 3)) ||
+            (time > mTM_TIME_TO_SEC(19, 59, 55) && time < mTM_TIME_TO_SEC(20, 0, 3))) {
+            add_calc(&l_mEnv_shadow_adjust_electric_light, 0.0f, 0.5f, 0.01f, 0.01f);
+        } else {
+            add_calc(&l_mEnv_shadow_adjust_electric_light, 0.0f, 0.1f, 0.0012f, 0.0008f);
+        }
+    } else {
+        add_calc(&l_mEnv_shadow_adjust_electric_light, 1.0f, 0.1f, 0.001f, 0.0001f);
+    }
+
+    if (common_data.weather == mEnv_WEATHER_RAIN || common_data.weather == mEnv_WEATHER_SNOW) {
+        shadowAdjust *= 0.75f;
+    }
+
+    kankyo->shadowAlpha = (s32)(255.0f * shadowAdjust * l_mEnv_shadow_adjust_electric_light);
+
+    if (mEnv_HereIsPlayerSelect() == TRUE) {
+        kankyo->shadowAlpha = 200.0f;
+    }
+
+    if (time >= mTM_TIME_TO_SEC(4, 0, 0) && time <= mTM_TIME_TO_SEC(20, 0, 0)) {
+        tmp = mTM_TIME_TO_SEC(16, 0, 0);
+        preAdjust = (f32)(time - mTM_TIME_TO_SEC(4, 0, 0)) / (f32)tmp;
+    } else {
+        if (time < mTM_TIME_TO_SEC(20, 0, 0)) {
+            time += mTM_SECONDS_IN_DAY;
+        }
+
+        tmp = mTM_TIME_TO_SEC(8, 0, 0);
+        if (1) {}
+        preAdjust = (f32)(time - mTM_TIME_TO_SEC(20, 0, 0)) / (f32)tmp;
+    }
+
+    kankyo->shadowPos = 200.0f * preAdjust - 100.0f;
+}
+void mEnv_set_time(Kankyo* kankyo) {
+    u8 hour = common_data.time.rtcTime.hour;
+    s16 timeAngle = ((common_data.time.nowSec - mTM_SECONDS_IN_HALFDAY) / (f32)(mTM_SECONDS_IN_DAY)) * 65536.0f;
+    UNUSED f32 sin = sin_s(timeAngle);
+    f32 cos = cos_s(timeAngle);
+    UNUSED f32 end = 0;
+    f32 tmp;
+    Color_RGBA8 lightColor;
+    s32 shadowsAffected;
+    u32 min;
+
+    tmp = ABS(cos) * 255.0f + 10.0f;
+
+    min = hour - 6;
+    if (min < 12) {
+        if (tmp > 255.0f) {
+            tmp = 255.0f;
+        }
+    }
+
+    mEnv_MakeShadowInfo(kankyo);
+
+    if (common_data.clip.unk_090 != NULL && common_data.clip.unk_090->unk_3C(&lightColor, &shadowsAffected) &&
+        shadowsAffected == TRUE) {
+        f32 colorAdd;
+        f32 adjustedShadowAlpha;
+
+        colorAdd = lightColor.r + lightColor.g + lightColor.b;
+        adjustedShadowAlpha = kankyo->shadowAlpha;
+
+        if (colorAdd > 200.0f) {
+            colorAdd = 200.0f;
+        }
+
+        adjustedShadowAlpha += (colorAdd / 200.0f) * 110.0f;
+
+        if (adjustedShadowAlpha > 255.0f) {
+            adjustedShadowAlpha = 255.0f;
+        }
+
+        if (adjustedShadowAlpha < 0.0f) {
+            adjustedShadowAlpha = 0.0f;
+        }
+
+        kankyo->shadowAlpha = (s32)adjustedShadowAlpha;
+    }
+
+    mNPS_schedule_manager();
+}
+void mEnv_ChangeRGBLight(u8* dst, u8* light0, u8* light1, f32 f0) {
+    s32 i;
+
+    for (i = 0; i < 3; i++) {
+        dst[0] = (s32)(((*light1 - *light0) * f0 + *light0) * l_mEnv_sun_percent_electric_light);
+
+        light0++;
+        light1++;
+
+        dst++;
+    }
+}
+void mEnv_ChangeDiffuseVctlSet(BaseLight* baseLight) {
+    s32 secondsRadAngle;
+
+    if (common_data.save.sceneNo == SCENE_CONVENI || common_data.save.sceneNo == SCENE_SUPER ||
+        common_data.save.sceneNo == SCENE_DEPART || common_data.save.sceneNo == SCENE_DEPART_2 ||
+        common_data.save.sceneNo == SCENE_BUGGY || common_data.save.sceneNo == SCENE_KAMAKURA) {
+        baseLight->sunDir[0] = 0;
+        baseLight->sunDir[1] = 69;
+        baseLight->sunDir[2] = 97;
+
+        baseLight->moonDir[0] = 0;
+        baseLight->moonDir[1] = -33;
+        baseLight->moonDir[2] = 115;
+    } else {
+        f32 diff;
+        xyz_t dir;
+
+        switch (common_data.fieldDrawType) {
+            case FIELD_DRAW_TYPE_TRAIN:
+            case FIELD_DRAW_TYPE_PLAYER_SELECT:
+                dir.x = 0.0f;
+                dir.y = 60.0f;
+                dir.z = 60.0f;
+                break;
+            default:
+                diff = common_data.time.nowSec - mTM_SECONDS_IN_HALFDAY;
+                secondsRadAngle = (diff / (f32)(mTM_SECONDS_IN_HALFDAY)) * (f32)(0x8000);
+
+                dir.x = 60.0f * sin_s(secondsRadAngle);
+                dir.y = 60.0f * cos_s(secondsRadAngle);
+                dir.z = 60.f * cos_s(secondsRadAngle);
+                break;
+        }
+
+        baseLight->sunDir[0] = -dir.x;
+        baseLight->sunDir[1] = dir.y + 30.0f;
+        baseLight->sunDir[2] = dir.z + 20.0f;
+        baseLight->moonDir[0] = dir.x;
+        baseLight->moonDir[1] = (-dir.y) + 30.0f;
+        baseLight->moonDir[2] = (-dir.z) + 20.0f;
+    }
+}
+
+void mEnv_ChangeDiffuseLight(BaseLight* dst, BaseLight* light0, BaseLight* light1, f32 f0) {
+    u8 current[3];
+    u8 current2[3];
+    s32 i;
+
+    mEnv_ChangeDiffuseVctlSet(dst);
+    if (common_data.sunlightFlag == TRUE) {
+        add_calc(&l_mEnv_sun_percent_electric_light, 1.0f, 0.5f, 0.2f, 0.01f);
+    } else {
+        add_calc(&l_mEnv_sun_percent_electric_light, 0.0f, 0.5f, 0.2f, 0.01f);
+    }
+
+    for (i = 0; i < 3; i++) {
+        current[i] = (s32)(light0->sunColor[i] * l_mEnv_sun_percent_electric_light);
+        current2[i] = (s32)(light1->sunColor[i] * l_mEnv_sun_percent_electric_light);
+    }
+    mEnv_ChangeRGBLight(dst->sunColor, current, current2, f0);
+
+    for (i = 0; i < 3; i++) {
+        current[i] = (s32)(light0->moonColor[i] * l_mEnv_sun_percent_electric_light);
+        current2[i] = (s32)(light1->moonColor[i] * l_mEnv_sun_percent_electric_light);
+    }
+
+    mEnv_ChangeRGBLight(dst->moonColor, light0->moonColor, light1->moonColor, f0);
+}
+void mEnv_ChangeFogLight(BaseLight* dst, BaseLight* light0, BaseLight* light1, f32 f0) {
+    mEnv_ChangeRGBLight(dst->fogColor, light0->fogColor, light1->fogColor, f0);
+
+    dst->fogNear = (((light1->fogNear & 0x3FF) - (light0->fogNear & 0x3FF)) * f0) + (light0->fogNear & 0x3FF);
+    dst->fogFar = (((light1->fogFar) - (light0->fogFar)) * f0) + light0->fogFar;
+}
+
+void mEnv_CalcSetLight_train(BaseLight* light) {
+    s32 rColor;
+    s32 gColor;
+    s32 bColor;
+    f32 inv;
+
+    if (common_data.save.sceneNo == SCENE_START_DEMO && l_mEnv_sun_percent_electric_light < 1.0f) {
+        inv = 1.0f - l_mEnv_sun_percent_electric_light;
+        if (common_data.save.sceneNo == SCENE_START_DEMO) {
+            rColor = 35.0f * inv;
+            gColor = 30.0f * inv;
+            bColor = 40.0f * inv;
+
+            light->ambientColor[0] += (u8)rColor;
+            light->ambientColor[1] += (u8)gColor;
+            light->ambientColor[2] += (u8)bColor;
+        }
+    }
+}
+
+void mEnv_CalcSetLight(BaseLight* dst, BaseLight* light0, BaseLight* light1, f32 f0) {
+    mEnv_ChangeRGBLight(dst->ambientColor, light0->ambientColor, light1->ambientColor, f0);
+    mEnv_CalcSetLight_train(dst);
+    mEnv_ChangeDiffuseLight(dst, light0, light1, f0);
+    mEnv_ChangeFogLight(dst, light0, light1, f0);
+
+    mEnv_ChangeRGBLight(dst->shadowColor, light0->shadowColor, light1->shadowColor, f0);
+    mEnv_ChangeRGBLight(dst->roomColor, light0->roomColor, light1->roomColor, f0);
+    mEnv_ChangeRGBLight(dst->sunColorWindow, light0->sunColorWindow, light1->sunColorWindow, f0);
+    mEnv_ChangeRGBLight(dst->moonColorWindow, light0->moonColorWindow, light1->moonColorWindow, f0);
+    mEnv_ChangeRGBLight(dst->bgColor, light0->bgColor, light1->bgColor, f0);
+}
+
+void mEnv_SetBaseLight(Kankyo* kankyo) {
+    f32 percent;
+    s32 i;
+    s32 fogEnabled;
+    s32 weather;
+    s32 nowSec;
+    s32* cur;
+    s32 term;
+
+    nowSec = common_data.time.nowSec;
+    fogEnabled = TRUE;
+    cur = klight_chg_time;
+
+    for (i = 0; i < mEnv_TERM; i++) {
+        if (klight_chg_time[i + 1] >= nowSec) {
+            break;
+        }
+    }
+
+    term = i + 1;
+    weather = common_data.weather;
+    percent = get_percent(cur[term], cur[i], nowSec);
+
+    switch (common_data.fieldDrawType) {
+        case FIELD_DRAW_TYPE_TRAIN:
+            mEnv_CalcSetLight(&kankyo->baseLight, &l_mEnv_normal_kcolor_data[weather][i],
+                              &l_mEnv_normal_kcolor_data[weather][(term) % 8], percent);
+            break;
+        case FIELD_DRAW_TYPE_PLAYER_SELECT:
+
+            mEnv_CalcSetLight(&kankyo->baseLight, &l_mEnv_kcolor_data_p_sel, &l_mEnv_kcolor_data_p_sel, 0.5f);
+            break;
+        default:
+            if (common_data.save.sceneNo == SCENE_CONVENI || common_data.save.sceneNo == SCENE_SUPER ||
+                common_data.save.sceneNo == SCENE_DEPART || common_data.save.sceneNo == SCENE_DEPART_2) {
+                mEnv_CalcSetLight(&kankyo->baseLight, &l_mEnv_kcolor_shop, &l_mEnv_kcolor_shop, 0.5f);
+            } else if (common_data.save.sceneNo == SCENE_BUGGY) {
+                mEnv_CalcSetLight(&kankyo->baseLight, &l_mEnv_kcolor_buggy, &l_mEnv_kcolor_buggy, 0.5f);
+            } else if (common_data.save.sceneNo == SCENE_KAMAKURA) {
+                mEnv_CalcSetLight(&kankyo->baseLight, &l_mEnv_kcolor_kamakura, &l_mEnv_kcolor_kamakura, 0.5f);
+            } else {
+                mEnv_CalcSetLight(&kankyo->baseLight, &l_mEnv_normal_kcolor_data[weather][i],
+                                  &l_mEnv_normal_kcolor_data[weather][(i + 1) % 8], percent);
+            }
+
+            if (common_data.unk_10001 == 0) {
+                fogEnabled = FALSE;
+            }
+
+            break;
+    }
+
+    if (fogEnabled == TRUE) {
+        kankyo->baseLight.fogColor[2] = 0;
+        kankyo->baseLight.fogColor[1] = 0;
+        kankyo->baseLight.fogColor[0] = 0;
+        kankyo->baseLight.fogNear = 2020;
+        kankyo->baseLight.fogFar = 1000;
+    }
+}
+
+u8 mEnv_LimitChkRGBColor(s32 c) {
+    if (c > 255) {
+        c = 255;
+    } else if (c < 0) {
+        c = 0;
+    }
+
+    return c;
+}
+
+void mEnv_AddAndSetRGBColor(u8* dst, u8* src0, s16* src1) {
+    s32 i;
+
+    for (i = 0; i < 3; i++) {
+        dst[0] = mEnv_LimitChkRGBColor(src0[0] + src1[0]);
+
+        dst++;
+        src0++;
+        src1++;
+    }
+}
+
+void mEnv_SetDiffuseLight(Kankyo* kankyo) {
+    LightParams* sunLight = &kankyo->sunLight.lights;
+    LightParams* moonLight = &kankyo->moonLight.lights;
+    BaseLight* light = &kankyo->baseLight;
+    UNUSED s32 pad;
+    UNUSED s32 pad2;
+
+    mEnv_AddAndSetRGBColor(sunLight->diffuse.color, light->sunColor, kankyo->addLightsInfo.diffuseColor);
+    mEnv_AddAndSetRGBColor(moonLight->diffuse.color, light->moonColor, l_mEnv_add_moon_color_electric_light);
+
+    sunLight->diffuse.x = light->sunDir[0];
+    sunLight->diffuse.y = light->sunDir[1];
+    sunLight->diffuse.z = light->sunDir[2];
+
+    moonLight->diffuse.x = light->moonDir[0];
+    moonLight->diffuse.y = light->moonDir[1];
+    moonLight->diffuse.z = light->moonDir[2];
+}
+
+void mEnv_SetFog(Kankyo* kankyo, Global_light* gLight) {
+    BaseLight* light = &kankyo->baseLight;
+    AddLightInfo* info = &kankyo->addLightsInfo;
+
+    mEnv_AddAndSetRGBColor(gLight->fogColor, light->fogColor, info->fogColor);
+
+    if (light->fogNear + info->fogNear <= mEnv_FOG_NEAR_MAX) {
+        gLight->fogNear = light->fogNear + info->fogNear;
+    } else {
+        gLight->fogNear = mEnv_FOG_NEAR_MAX;
+    }
+
+    if (light->fogFar + info->fogFar <= mEnv_FOG_FAR_MAX) {
+        gLight->fogFar = light->fogFar + info->fogFar;
+    } else {
+        gLight->fogFar = mEnv_FOG_FAR_MAX;
+    }
+}
+void mEnv_PermitCheckDiffuseLight(Kankyo* kankyo) {
+    if (kankyo->sunLight.lights.diffuse.x == 0 && kankyo->sunLight.lights.diffuse.y == 0 &&
+        kankyo->sunLight.lights.diffuse.z == 0) {
+        kankyo->sunLight.lights.diffuse.x = 1;
+    }
+
+    if (kankyo->moonLight.lights.diffuse.x == 0 && kankyo->moonLight.lights.diffuse.y == 0 &&
+        kankyo->moonLight.lights.diffuse.z == 0) {
+        kankyo->moonLight.lights.diffuse.x = 1;
+    }
+}
+void Global_kankyo_set_room_prim(Game_Play* play) {
+    GraphicsContext* graph;
+    s32 i;
+    s32 color;
+    u8 colors[3];
+    s32 lightOn;
+    u8* pointColor;
+    u8* roomColor;
+
+    if (l_mEnv_point_light_on_electric_light != 0) {
+        lightOn = TRUE;
+    } else {
+        lightOn = FALSE;
+    }
+
+    pointColor = play->kankyo.pointLight.lights.point.color;
+    roomColor = play->kankyo.baseLight.roomColor;
+
+    for (i = 0; i < 3; i++) {
+        if (lightOn == TRUE) {
+            if (l_mEnv_point_light_is_flame_electric_light) {
+                color = (*pointColor >> 1) + (*roomColor >> 1);
+            } else {
+                color = (*roomColor * 0.7f) + (*pointColor * 0.6f);
+            }
+        } else {
+            color = *roomColor;
+        }
+
+        if (color < 0) {
+            color = 0;
+        } else if (color > 255) {
+            color = 255;
+        }
+
+        colors[i] = color;
+        pointColor++;
+        roomColor++;
+    }
+
+    graph = play->state.gfxCtx;
+
+    OPEN_DISPS(graph);
+
+    gDPPipeSync(POLY_OPA_DISP++);
+    gDPSetPrimColor(POLY_OPA_DISP++, 0, 128, colors[0], colors[1], colors[2], 255);
+    gDPPipeSync(POLY_XLU_DISP++);
+    gDPSetPrimColor(POLY_XLU_DISP++, 0, 128, colors[0], colors[1], colors[2], 255);
+
+    CLOSE_DISPS(graph);
+}
+
+void mEnv_check_countdown_start(Game_Play* play) {
+    s32 time = mTM_TIME_TO_SEC(23, 59, 0);
+
+    if (mEv_check_status(6, 8) == FALSE) {
+        s32 bx;
+        s32 bz;
+
+        mFI_BlockKind2BkNum(&bx, &bz, 0x8000);
+
+        if (bx != play->unk_00E4 || bz != play->unk_00E5) {
+            if (common_data.time.nowSec >= time) {
+                mEv_set_status(6, 8);
+            }
+        }
+    }
+}
+
+void mEnv_countdown_proc(Game_Play* play) {
+    UNUSED u8 pad;
+    u8 timer;
+
+    if (common_data.fieldDrawType != FIELD_DRAW_TYPE_TRAIN &&
+        common_data.fieldDrawType != FIELD_DRAW_TYPE_PLAYER_SELECT && mEv_check_status(6, 1) == 1) {
+        mEnv_check_countdown_start(play);
+
+        if (mEv_check_status(6, 8) == 1) {
+            u16 sfx;
+            u8 cur = play->kankyo.countdownTimer;
+
+            if (common_data.time.rtcTime.month != lbRTC_DECEMBER) {
+                timer = 0;
+            } else {
+                timer = mTM_SECONDS_IN_DAY - common_data.time.nowSec;
+            }
+
+            if (timer != cur) {
+                if (timer == 0) {
+                    sfx = 0x151;
+                } else if (timer <= 10) {
+                    sfx = 0x150;
+                } else {
+                    sfx = 0x431;
+                }
+
+                sAdo_SysTrgStart(sfx);
+
+                play->kankyo.countdownTimer = timer;
+            }
+        }
+    }
+}
+
+void Global_kankyo_set(Game_Play* play, Kankyo* kankyo, Global_light* gLight) {
+    mEnv_set_time(kankyo);
+    mEnv_SetBaseLight(kankyo);
+    mEnv_AddAndSetRGBColor(gLight->ambientColor, kankyo->baseLight.ambientColor, kankyo->addLightsInfo.ambientColor);
+    mEnv_SetDiffuseLight(kankyo);
+    mEnv_SetFog(kankyo, gLight);
+    mEnv_PermitCheckDiffuseLight(kankyo);
+    mEnv_TaimatuPointLightWaveMoveProc(play);
+    mEnv_CheckNpcLight_ToSwitchON(play);
+    mEnv_countdown_proc(play);
+    mEnv_MakeWindowLightAlpha(TRUE);
+}
+
+void mEnv_DecideWindDirect(s_xyz* dir, s16 x, s16 z) {
+    xyz_t windDir = { 0.0f, -100.0f, 0.0f };
+    f32 xF = x;
+    f32 zF = z;
+    s16 rotX;
+    s16 rotZ;
+    f32 frotX;
+    f32 frotZ;
+
+    rotX = (RANDOM_F(xF) - xF);
+    rotZ = (RANDOM_F(zF) - zF);
+
+    frotX = BINANG_TO_RAD(rotX);
+    frotZ = BINANG_TO_RAD(rotZ);
+
+    sMath_RotateX(&windDir, frotX);
+
+    sMath_RotateZ(&windDir, frotZ);
+
+    dir->x = windDir.x;
+    dir->y = windDir.y;
+    dir->z = windDir.z;
+}
+
+s32 mEnv_GetWeatherChangeStep() {
+    static u8 weather_term_table[][2] = {
+        { lbRTC_JANUARY, 7 },    // January 1st - January 7th
+        { lbRTC_FEBRUARY, 24 },  // January 8th - February 24th
+        { lbRTC_MARCH, 31 },     // February 25th - March 31st
+        { lbRTC_APRIL, 4 },      // April 1st - April 4th
+        { lbRTC_APRIL, 7 },      // April 5th - April 7th
+        { lbRTC_APRIL, 8 },      // April 8th - April 8th
+        { lbRTC_APRIL, 19 },     // April 9th - April 19th
+        { lbRTC_APRIL, 20 },     // April 20th - April 20th
+        { lbRTC_JUNE, 15 },      // April 21st - June 15th
+        { lbRTC_JULY, 15 },      // June 16th - July 15th
+        { lbRTC_AUGUST, 31 },    // July 16th - August 31st
+        { lbRTC_SEPTEMBER, 30 }, // September 1st - September 30th
+        { lbRTC_OCTOBER, 30 },   // October 1st - October 30th
+        { lbRTC_OCTOBER, 31 },   // October 31st - Octber 31st
+        { lbRTC_NOVEMBER, 15 },  // November 1st - November 15th
+        { lbRTC_DECEMBER, 9 },   // November 16th - December 9th
+        { lbRTC_DECEMBER, 10 },  // December 10th - December 10th
+        { lbRTC_DECEMBER, 23 },  // December 11th - December 23rd
+        { lbRTC_DECEMBER, 30 },  // December 24th - December 30th
+        { lbRTC_DECEMBER, 31 }   // December 31st - December 31st
+    };
+
+    lbRTC_month_t month = common_data.time.rtcTime.month;
+    lbRTC_day_t day = common_data.time.rtcTime.day;
+    s32 i;
+
+    for (i = 0; i < 20; i++) {
+        if (month < weather_term_table[i][0]) {
+            return i;
+        } else if (month == weather_term_table[i][0] && day <= weather_term_table[i][1]) {
+            return i;
+        }
+    }
+
+    return 1;
+}
+
+#define mEnv_MAKE_WEATHER_TABLE_ENTRY(clear, rain, thunder, snow, blizzard, sakura, heavySakura)    \
+    ((((clear)&0xF) << 24) | (((rain)&0xF) << 16) | (((thunder)&0xF) << 20) | (((snow)&0xF) << 8) | \
+     (((blizzard)&0xF) << 12) | (((sakura)&0xF) << 0) | (((heavySakura)&0xF) << 4))
+
+void mEnv_RandomWeather(s16* next_weather, s16* next_intensity) {
+    static const u32 weather_table[] = {
+        mEnv_MAKE_WEATHER_TABLE_ENTRY(10, 0, 0, 0, 0, 0, 0), // 100% chance of clear weather
+        mEnv_MAKE_WEATHER_TABLE_ENTRY(6, 0, 0, 3, 1, 0,
+                                      0), // 60% chance of clear weather, 30% chance of snow, 10% chance of blizzard
+        mEnv_MAKE_WEATHER_TABLE_ENTRY(8, 2, 0, 0, 0, 0, 0),  // 80% chance of clear weather, 20% chance of rain
+        mEnv_MAKE_WEATHER_TABLE_ENTRY(10, 0, 0, 0, 0, 0, 0), // 100% chance of clear weather
+        mEnv_MAKE_WEATHER_TABLE_ENTRY(0, 0, 0, 0, 0, 10, 0), // 100% chance of light cherry blossoms
+        mEnv_MAKE_WEATHER_TABLE_ENTRY(0, 0, 0, 0, 0, 0, 10), // 100% chance of heavy cherry blossoms
+        mEnv_MAKE_WEATHER_TABLE_ENTRY(8, 2, 0, 0, 0, 0, 0),  // 80% chance of clear weather, 20% chance of rain
+        mEnv_MAKE_WEATHER_TABLE_ENTRY(10, 0, 0, 0, 0, 0, 0), // 100% chance of clear weather
+        mEnv_MAKE_WEATHER_TABLE_ENTRY(
+            7, 2, 1, 0, 0, 0, 0), // 70% chance of clear weather, 20% chance of rain, 10% chance of thunderstorms
+        mEnv_MAKE_WEATHER_TABLE_ENTRY(
+            2, 5, 3, 0, 0, 0, 0), // 20% chance of clear weather, 50% chance of rain, 30% chance of thunderstorms
+        mEnv_MAKE_WEATHER_TABLE_ENTRY(9, 0, 1, 0, 0, 0, 0),  // 90% chance of clear weather, 10% chance of thunderstorms
+        mEnv_MAKE_WEATHER_TABLE_ENTRY(6, 0, 4, 0, 0, 0, 0),  // 60% chance of clear weather, 40% chance of thunderstorms
+        mEnv_MAKE_WEATHER_TABLE_ENTRY(8, 2, 0, 0, 0, 0, 0),  // 80% chance of clear weather, 20% chance of rain
+        mEnv_MAKE_WEATHER_TABLE_ENTRY(10, 0, 0, 0, 0, 0, 0), // 100% chance of clear weather
+        mEnv_MAKE_WEATHER_TABLE_ENTRY(8, 1, 0, 1, 0, 0,
+                                      0), // 80% chance of clear weather, 10% chance of rain, 10% chance of snow
+        mEnv_MAKE_WEATHER_TABLE_ENTRY(7, 0, 0, 3, 0, 0, 0),  // 70% chance of clear weather, 30% chance of snow
+        mEnv_MAKE_WEATHER_TABLE_ENTRY(0, 0, 0, 0, 10, 0, 0), // 100% chance of blizzard
+        mEnv_MAKE_WEATHER_TABLE_ENTRY(4, 0, 0, 4, 2, 0,
+                                      0), // 40% chance of clear weather, 40% chance of snow, 20% chance of blizzard
+        mEnv_MAKE_WEATHER_TABLE_ENTRY(0, 0, 0, 6, 4, 0, 0), // 60% chance of snow, 40% chance of blizzard
+        mEnv_MAKE_WEATHER_TABLE_ENTRY(10, 0, 0, 0, 0, 0, 0) // 100% chance of clear weather
+    };
+
+    s32 step = mEnv_GetWeatherChangeStep();
+
+    u32 weather = weather_table[step];
+    u32 selected;
+    u32 c0;
+    u32 c1;
+    u32 c2;
+    u32 c3;
+    u32 c4;
+    u32 c5;
+
+    c0 = (weather >> 24) & 0xF;
+    c1 = (weather >> 16) & 0xF;
+    c2 = (weather >> 20) & 0xF;
+    c3 = (weather >> 8) & 0xF;
+    c4 = (weather >> 12) & 0xF;
+    c5 = (weather >> 8) & 0xF; // !@bug sets blizzard again, making light sakura weather impossible to get
+
+    selected = RANDOM_F(10.0f);
+
+    if (selected < c0) {
+        next_weather[0] = mEnv_WEATHER_CLEAR;
+        next_intensity[0] = mEnv_WEATHER_INTENSITY_LIGHT;
+    } else if (selected < c0 + c1) {
+        next_weather[0] = mEnv_WEATHER_RAIN;
+        next_intensity[0] = mEnv_WEATHER_INTENSITY_LIGHT;
+    } else if (selected < c0 + c1 + c2) {
+        next_weather[0] = mEnv_WEATHER_RAIN;
+        next_intensity[0] = mEnv_WEATHER_INTENSITY_HEAVY;
+    } else if (selected < c0 + c1 + c2 + c3) {
+        next_weather[0] = mEnv_WEATHER_SNOW;
+        next_intensity[0] = mEnv_WEATHER_INTENSITY_LIGHT;
+    } else if (selected < c0 + c1 + c2 + c3 + c4) {
+        next_weather[0] = mEnv_WEATHER_SNOW;
+        next_intensity[0] = mEnv_WEATHER_INTENSITY_HEAVY;
+    } else if (selected < c0 + c1 + c2 + c3 + c4 + c5) {
+        next_weather[0] = mEnv_WEATHER_SAKURA;
+        next_intensity[0] = mEnv_WEATHER_INTENSITY_LIGHT;
+    } else {
+        next_weather[0] = mEnv_WEATHER_SAKURA;
+        next_intensity[0] = mEnv_WEATHER_INTENSITY_HEAVY;
+    }
+}
+
+mEnv_WindInfo mEnv_wind_info = {
+    { 0, 0, 0, 1, 0, lbRTC_JANUARY, 2000 }, 8192.0f, 8192.0f, 0.0f, 0.5f, 0.5f, 0.0f,
+};
+
+s16 mEnv_GetWindAngleS() {
+    return mEnv_wind_info.windAngleS;
+}
+
+f32 mEnv_GetWindPowerF(void) {
+    return mEnv_wind_info.windPowerF;
+}
+
+void mEnv_ChangeWind() {
+    f32 angle;
+    f32 power;
+    f32 rand;
+
+    if (mEv_check_schedule(0x18)) {
+        mEnv_wind_info.unk8 = 24576.0f;
+        mEnv_wind_info.unk14 = 1.0f;
+    } else {
+        angle = RANDOM_F(5461.0f) - 2730.5f;
+        rand = fqrand();
+        power = (rand * 0.4f) - 0.2f;
+
+        mEnv_wind_info.unk8 = mEnv_wind_info.windAngleS + angle;
+        mEnv_wind_info.unk10 = angle / 18000.0f;
+
+        mEnv_wind_info.unk14 = mEnv_wind_info.windPowerF + power;
+        mEnv_wind_info.unk1C = power / 18000.0f;
+
+        if (mEnv_wind_info.unk14 < 0.0f) {
+            mEnv_wind_info.unk14 = 0.0f;
+        } else if (mEnv_wind_info.unk14 > 1.0f) {
+            mEnv_wind_info.unk14 = 1.0f;
+        }
+    }
+}
+
+void mEnv_InitWind() {
+    if (mEv_check_schedule(0x18)) {
+        mEnv_wind_info.unk8 = 24576.0f;
+        mEnv_wind_info.unk14 = 1.0f;
+    } else {
+        mEnv_wind_info.unk8 = RANDOM_F(65536);
+        mEnv_wind_info.unk14 = fqrand();
+    }
+
+    mEnv_wind_info.time = common_data.time.rtcTime;
+    mEnv_wind_info.windAngleS = mEnv_wind_info.unk8;
+    mEnv_wind_info.unk10 = 0.0f;
+    mEnv_wind_info.unk1C = 0.0f;
+    mEnv_wind_info.windPowerF = mEnv_wind_info.unk14;
+
+    mEnv_WindMove();
+}
+
+void mEnv_WindMove() {
+    if (lbRTC_IsOverTime(&mEnv_wind_info.time, &common_data.time.rtcTime) == TRUE) {
+        mEnv_ChangeWind();
+        mEnv_wind_info.time = common_data.time.rtcTime;
+        lbRTC_Add_mm(&mEnv_wind_info.time, 10);
+    }
+    if (mEnv_wind_info.unk8 != mEnv_wind_info.windAngleS) {
+        mEnv_wind_info.windAngleS += mEnv_wind_info.unk10;
+        if (mEnv_wind_info.unk10 > 0.0f) {
+            if (mEnv_wind_info.unk8 <= mEnv_wind_info.windAngleS) {
+                mEnv_wind_info.windAngleS = mEnv_wind_info.unk8;
+                mEnv_wind_info.unk10 = 0.0f;
+            }
+        } else if (mEnv_wind_info.unk10 < 0.0f && mEnv_wind_info.windAngleS <= mEnv_wind_info.unk8) {
+            mEnv_wind_info.windAngleS = mEnv_wind_info.unk8;
+            mEnv_wind_info.unk10 = 0.0f;
+        }
+    }
+    if (mEnv_wind_info.unk14 != mEnv_wind_info.windPowerF) {
+        mEnv_wind_info.windPowerF += mEnv_wind_info.unk1C;
+        if (mEnv_wind_info.unk1C > 0.0f) {
+            if (mEnv_wind_info.unk14 <= mEnv_wind_info.windPowerF) {
+                mEnv_wind_info.windPowerF = mEnv_wind_info.unk14;
+                mEnv_wind_info.unk1C = 0.0f;
+            }
+        } else if (mEnv_wind_info.unk1C < 0.0f && mEnv_wind_info.windPowerF <= mEnv_wind_info.unk14) {
+            mEnv_wind_info.windPowerF = mEnv_wind_info.unk14;
+            mEnv_wind_info.unk1C = 0.0f;
+        }
+    }
+}
+
+void mEnv_DecideWeather_GameStart() {
+    s16 weather;
+    s16 intensity;
+    s16 eventWeather;
+    s16 eventIntensity;
+
+    mEnv_RandomWeather(&weather, &intensity);
+    mEv_GetEventWeather(&eventWeather, &eventIntensity);
+
+    if (eventWeather != -1) {
+        weather = eventWeather;
+        intensity = eventIntensity;
+    }
+
+    if (mEv_CheckRealArbeit() == TRUE && weather == mEnv_WEATHER_RAIN) {
+        weather = mEnv_WEATHER_CLEAR;
+        intensity = mEnv_WEATHER_INTENSITY_NONE;
+    }
+
+    common_data.weather = weather;
+    common_data.weatherIntensity = intensity;
+    common_data.weatherTime = common_data.time.rtcTime;
+    mEnv_InitWind();
+}
+
+void mEnv_DecideWeather_FirstGameStart() {
+    u8 saveWeather;
+    u8 intensity;
+    u8 weather;
+
+    mEnv_DecideWeather_GameStart();
+
+    weather = (u8)common_data.weather;
+    intensity = (u8)common_data.weatherIntensity;
+
+    saveWeather = ENV_SAVE_SET_WEATHER(intensity, weather);
+
+    common_data.save.saveWeather = saveWeather;
+
+    if (mTM_check_renew_time(mTM_RENEW_TIME_WEATHER)) {
+        mTM_off_renew_time(mTM_RENEW_TIME_WEATHER);
+    }
+}
+
+void mEnv_DecideWeather_NormalGameStart() {
+    u8 saveWeather;
+    u8 weather;
+    u8 intensity;
+    u8 lastWeather;
+
+    if (mTM_check_renew_time(mTM_RENEW_TIME_WEATHER)) {
+        mEnv_DecideWeather_GameStart();
+        mTM_off_renew_time(mTM_RENEW_TIME_WEATHER);
+
+        weather = common_data.weather;
+        intensity = common_data.weatherIntensity;
+        saveWeather = (common_data.save.saveWeather & 0xF0);
+        lastWeather = ENV_SAVE_GET_WEATHER_TYPE(common_data.save.saveWeather);
+
+        if (weather == mEnv_WEATHER_CLEAR || weather == mEnv_WEATHER_SAKURA) {
+            if (lastWeather == mEnv_WEATHER_SNOW || lastWeather == mEnv_WEATHER_RAIN) {
+                mAGrw_OrderSetHaniwa();
+            }
+        }
+        common_data.save.saveWeather = ENV_SAVE_SET_WEATHER(intensity, weather);
+    } else {
+        saveWeather = common_data.save.saveWeather;
+        weather = ENV_SAVE_GET_WEATHER_TYPE(saveWeather);
+        intensity = ENV_SAVE_GET_WEATHER_INTENSITY(saveWeather);
+
+        if (mEv_CheckRealArbeit() == TRUE && weather == mEnv_WEATHER_RAIN) {
+            weather = mEnv_WEATHER_CLEAR;
+            intensity = mEnv_WEATHER_INTENSITY_NONE;
+
+            common_data.save.saveWeather = ENV_SAVE_SET_WEATHER(intensity, weather);
+        }
+
+        common_data.weather = weather;
+        common_data.weatherIntensity = intensity;
+    }
+}
+
+s32 mEnv_NowWeather() {
+    switch (mEv_CheckTitleDemo()) {
+        case 1:
+            return mEnv_WEATHER_SAKURA;
+        case 2:
+            return mEnv_WEATHER_RAIN;
+        case 3:
+        case 4:
+            return mEnv_WEATHER_CLEAR;
+        case 5:
+            return mEnv_WEATHER_SNOW;
+    }
+    if (FI_GET_TYPE(mFI_GetFieldId()) == 0) {
+        return common_data.weather;
+    }
+
+    return mEnv_WEATHER_CLEAR;
+}
+
+s32 mEnv_CheckNpcRoomPointLightNiceStatus() {
+    Animal_c* animal;
+    NpsSchedule* schedule;
+    s32 ret = FALSE;
+
+    animal = mNpc_GetAnimalInfoP(common_data.houseOwnerName);
+
+    if (animal != NULL) {
+        schedule = mNPS_get_schedule_area(&animal->id);
+
+        if (schedule != NULL) {
+            if (schedule->currentType == NPS_SCHEDULE_IN_HOUSE && animal->isHome == TRUE &&
+                (common_data.time.nowSec < mTM_TIME_TO_SEC(5, 0, 0) ||
+                 common_data.time.nowSec >= mTM_TIME_TO_SEC(18, 0, 0))) {
+                ret = TRUE;
+            }
+        }
+    }
+
+    return ret;
+}
+
+void mEnv_TaimatuPointLightWaveMoveProc(Game_Play* play) {
+    static s16 point_light_wave_counter;
+
+    point_light_wave_counter += 800;
+
+    if (l_mEnv_point_light_is_flame_electric_light) {
+        f32 wave = sin_s(point_light_wave_counter);
+        u8 c = (s32)(((wave >= 0.0f ? sin_s(point_light_wave_counter) : -sin_s(point_light_wave_counter)) * 40.0f) +
+                     40.0f);
+
+        play->kankyo.pointLight.lights.point.color[0] = 255 - c;
+        play->kankyo.pointLight.lights.point.color[1] = 240 - c;
+    }
+}
+
+void mEnv_CheckNpcLight_ToSwitchON(Game_Play* play) {
+    UNUSED s32 pad;
+    if (common_data.save.sceneNo == SCENE_NPC_HOUSE && l_mEnv_index_light_switch_electric_light != 0 &&
+        mEnv_CheckNpcRoomPointLightNiceStatus()) {
+        l_mEnv_point_light_on_electric_light = TRUE;
+        l_mEnv_index_light_switch_electric_light = FALSE;
+        Light_point_ct(&play->kankyo.pointLight, 160, 180, 240, 220, 220, 180, 1000);
+        l_mEnv_current_lightnode_electric_light = Global_light_list_new(play, &play->glight, &play->kankyo.pointLight);
+    }
+}
+
+void target_lighting_amb(Game_Play* play, f32 f0) {
+    u16 i;
+
+    if (f0 > 0.999f) {
+        for (i = 0; i < 3; i++) {
+            play->kankyo.addLightsInfo.ambientColor[i] = -255;
+        }
+    } else {
+        for (i = 0; i < 3; i++) {
+            play->kankyo.addLightsInfo.ambientColor[i] = (s32)((f32)-play->kankyo.baseLight.ambientColor[i] * f0);
+        }
+    }
+}
+
+void target_lighting_dif(Game_Play* play, f32 f0) {
+    u16 i;
+
+    if (f0 > 0.999f) {
+        for (i = 0; i < 3; i++) {
+            play->kankyo.addLightsInfo.diffuseColor[i] = l_mEnv_add_moon_color_electric_light[i] = -255;
+        }
+    } else {
+        for (i = 0; i < 3; i++) {
+            play->kankyo.addLightsInfo.diffuseColor[i] = (s32)(-play->kankyo.baseLight.sunColor[i] * f0);
+            l_mEnv_add_moon_color_electric_light[i] = (s32)((f32)-play->kankyo.baseLight.moonColor[i] * f0);
+        }
+    }
+}
+
+void target_lighting_fog(Game_Play* play, f32 f0) {
+
+    if (f0 > 0.999f) {
+        u16 i;
+        for (i = 0; i < 3; i++) {
+            play->kankyo.addLightsInfo.fogNear = mEnv_FOG_NEAR_MAX;
+            play->kankyo.addLightsInfo.fogFar = mEnv_FOG_FAR_MAX;
+        }
+    } else {
+        s16 near = mEnv_FOG_NEAR_MAX - play->kankyo.baseLight.fogNear;
+        s16 far = mEnv_FOG_FAR_MAX - play->kankyo.baseLight.fogFar;
+
+        play->kankyo.addLightsInfo.fogNear = near * f0;
+        play->kankyo.addLightsInfo.fogFar = far * f0;
+    }
+}
+
+void mEnv_PointLightSet(Game_Play* play, f32 f0) {
+    Player* player = get_player_actor_withoutCheck(play);
+    s16* KKData = (s16*)mEv_get_save_area(0x21, 0xA);
+
+    Light_point_ct(&play->kankyo.pointLight, player->actor.world.pos.x, player->actor.world.pos.y,
+                   player->actor.world.pos.z - 25.0f, 255, 255, 220, (*KKData * (1.0f - f0)));
+}
+
+void staffroll_light_init(Game_Play* play) {
+    l_mEnv_staffroll_fade_rate_electric_light = 1.0f;
+    mEnv_PointLightSet(play, l_mEnv_staffroll_fade_rate_electric_light);
+    S_get_light_list = Global_light_list_new(play, &play->glight, &play->kankyo.pointLight);
+}
+
+void staffroll_light_proc_start(Game_Play* play) {
+    add_calc(&l_mEnv_staffroll_fade_rate_electric_light, 0.0f, 0.5f, 0.01f, 0.00001f);
+    target_lighting_amb(play, 1.0f - l_mEnv_staffroll_fade_rate_electric_light);
+    target_lighting_dif(play, 1.0f - l_mEnv_staffroll_fade_rate_electric_light);
+    target_lighting_fog(play, 1.0f - l_mEnv_staffroll_fade_rate_electric_light);
+
+    play->kankyo.shadowAlpha = (s32)(play->kankyo.shadowAlpha * l_mEnv_staffroll_fade_rate_electric_light);
+    mEnv_PointLightSet(play, l_mEnv_staffroll_fade_rate_electric_light);
+}
+
+s32 staffroll_light_proc_end(Game_Play* play) {
+    s32 ret = FALSE;
+    add_calc(&l_mEnv_staffroll_fade_rate_electric_light, 1.0f, 0.5f, 0.01f, 0.00001f);
+    target_lighting_amb(play, 1.0f - l_mEnv_staffroll_fade_rate_electric_light);
+    target_lighting_dif(play, 1.0f - l_mEnv_staffroll_fade_rate_electric_light);
+    target_lighting_fog(play, 1.0f - l_mEnv_staffroll_fade_rate_electric_light);
+
+    play->kankyo.shadowAlpha = (s32)(play->kankyo.shadowAlpha * l_mEnv_staffroll_fade_rate_electric_light);
+    mEnv_PointLightSet(play, l_mEnv_staffroll_fade_rate_electric_light);
+
+    if ((s16)(l_mEnv_staffroll_fade_rate_electric_light * 1000.0f) >= 1000) {
+        ret = TRUE;
+    }
+    return ret;
+}
+
+void staffroll_light_dt(Game_Play* play) {
+    Global_light_list_delete(&play->glight, S_get_light_list);
+}
+
+void mEnv_GetShadowPrimColor_Light(u8* r, u8* g, u8* b, Game_Play* play) {
+    Kankyo* kankyo = &play->kankyo;
+
+    r[0] = kankyo->baseLight.shadowColor[0];
+    g[0] = kankyo->baseLight.shadowColor[1];
+    b[0] = kankyo->baseLight.shadowColor[2];
+}
+
+u8 mEnv_GetCurrentLightSwitchStatus() {
+    return l_mEnv_point_light_on_electric_light;
+}
+
+s32 mEnv_HereIsPlayerSelect() {
+    static s32 place_chk[4] = { SCENE_PLAYERSELECT, SCENE_PLAYERSELECT_2, SCENE_PLAYERSELECT_3,
+                                SCENE_PLAYERSELECT_SAVE };
+    s32 ret = FALSE;
+    s32 i;
+
+    for (i = 0; i < 4; i++) {
+        if (common_data.save.sceneNo == place_chk[i]) {
+            ret = TRUE;
+            break;
+        }
+    }
+
+    return ret;
+}
+void mEnv_MakeWindowLightAlpha(s32 enabled) {
+    f32 step = 1.0f / 100.0f;
+    f32 target = 0.0f;
+    if (common_data.fieldDrawType == FIELD_DRAW_TYPE_INDOORS) {
+        if (enabled == FALSE) {
+            step = 1.0f;
+            l_mEnv_windowlight_alpha_electric_light = 0.0f;
+        }
+
+        if (common_data.save.sceneNo == SCENE_MY_ROOM_S || common_data.save.sceneNo == SCENE_MY_ROOM_M ||
+            common_data.save.sceneNo == SCENE_MY_ROOM_L) {
+            if (common_data.time.nowSec >= mTM_TIME_TO_SEC(5, 0, 0) &&
+                common_data.time.nowSec < mTM_TIME_TO_SEC(18, 0, 0)) {
+                target = 1.0f;
+            } else {
+                target = 0.0f;
+
+                if (mEnv_GetCurrentLightSwitchStatus() == 0) {
+                    target = 1.0f;
+                }
+            }
+        } else if (common_data.save.sceneNo == SCENE_NPC_HOUSE) {
+            target = 0.0f;
+            if (mEnv_GetCurrentLightSwitchStatus() == 0) {
+                target = 1.0f;
+            }
+        } else if (common_data.time.nowSec >= mTM_TIME_TO_SEC(5, 0, 0) &&
+                   common_data.time.nowSec < mTM_TIME_TO_SEC(18, 0, 0)) {
+            target = 1.0f;
+        }
+        add_calc(&l_mEnv_windowlight_alpha_electric_light, target, 0.2f, step, step);
+    }
+}
+
+f32 mKK_windowlight_alpha_get() {
+    return l_mEnv_windowlight_alpha_electric_light;
+}
diff --git a/src/code/m_npc.c b/src/code/m_npc.c
index 6e0ab8a..7320eb9 100644
--- a/src/code/m_npc.c
+++ b/src/code/m_npc.c
@@ -2329,7 +2329,7 @@ void mNpc_AddNpc_inNpcRoom(FieldMakeMoveActor* moveActor, u8 bx, u8 bz) {
                     }
                 }
             } else if (fieldId == 0x300A) {
-                animalIdInField = func_8008033C_jp(0xE, 0xF);
+                animalIdInField = mEv_get_save_area(0xE, 0xF);
                 if (animalIdInField != NULL) {
                     npcId = *animalIdInField;
                     currentNpc = common_data.save.animals[npcId].id.npcId;
diff --git a/src/code/m_private.c b/src/code/m_private.c
index b35c1dd..2c25f70 100644
--- a/src/code/m_private.c
+++ b/src/code/m_private.c
@@ -11,6 +11,7 @@
 #include "m_handbill.h"
 #include "m_house.h"
 #include "6DA460.h"
+#include "prevent_bss_reordering.h"
 
 PrivateInfo g_foreigner_private;
 Mail_c l_mpr_mail;
diff --git a/src/code/m_scene.c b/src/code/m_scene.c
index 80bc5c2..eb27d6e 100644
--- a/src/code/m_scene.c
+++ b/src/code/m_scene.c
@@ -522,7 +522,7 @@ void Scene_player_select(s32 sceneNo, s32 npcActor) {
     mNpc_RegistEventNpc(npcActor, npcId, npcId, common_data.save.animals[found].cloth);
 }
 
-void Scene_Proc_Ctrl_Actor_Ptr(Game_Play* play, SceneData* scene_data);
+void Scene_Proc_Ctrl_Actor_Ptr(Game_Play* play, SceneData* sceneData);
 
 void Scene_Proc_MyRoom_ct(Game_Play* play, SceneData* data);
 
@@ -562,12 +562,12 @@ void Scene_ct(Game_Play* play, SceneData* sceneData) {
     Scene_player_select(SCENE_PLAYERSELECT_SAVE, 0xD06A); // save
 }
 
-void Scene_Proc_Player_Ptr(Game_Play* play, SceneData* scene_data) {
+void Scene_Proc_Player_Ptr(Game_Play* play, SceneData* sceneData) {
     static s16 angle_table[] = {
         0x0000, 0x2000, 0x4000, 0x6000, 0x8000, 0xA000, 0xC000, 0xE000,
     };
 
-    ActorEntry* data = Lib_SegmentedToVirtual(scene_data->actor.actorDataPtr);
+    ActorEntry* data = Lib_SegmentedToVirtual(sceneData->actor.actorDataPtr);
 
     play->unk_1EA8 = data;
 
@@ -581,30 +581,30 @@ void Scene_Proc_Player_Ptr(Game_Play* play, SceneData* scene_data) {
     mSM_Object_Exchange_keep_new_Menu(play);
 }
 
-void Scene_Proc_Ctrl_Actor_Ptr(Game_Play* play, SceneData* scene_data) {
-    s16* data = scene_data->controlActor.ctrlActorDataPtr;
+void Scene_Proc_Ctrl_Actor_Ptr(Game_Play* play, SceneData* sceneData) {
+    s16* data = sceneData->controlActor.ctrlActorDataPtr;
 
-    play->unk_1EA6 = scene_data->controlActor.numCtrlActors;
+    play->unk_1EA6 = sceneData->controlActor.numCtrlActors;
     play->unk_1EB0 = Lib_SegmentedToVirtual(data);
 }
 
-void Scene_Proc_Actor_Ptr(Game_Play* play, SceneData* scene_data) {
-    ActorEntry* data = scene_data->actor.actorDataPtr;
+void Scene_Proc_Actor_Ptr(Game_Play* play, SceneData* sceneData) {
+    ActorEntry* data = sceneData->actor.actorDataPtr;
 
-    play->unk_1EA5 = scene_data->actor.numActors;
+    play->unk_1EA5 = sceneData->actor.numActors;
     play->unk_1EAC = Lib_SegmentedToVirtual(data);
 }
 
-void Scene_Proc_Object_Exchange_Bank_Ptr(Game_Play* play, SceneData* scene_data) {
+void Scene_Proc_Object_Exchange_Bank_Ptr(Game_Play* play, SceneData* sceneData) {
 
-    play->unk_1EA7 = scene_data->objectBank.numBanks;
-    play->unk_1EB4 = Lib_SegmentedToVirtual(scene_data->objectBank.banksDataPtr);
+    play->unk_1EA7 = sceneData->objectBank.numBanks;
+    play->unk_1EB4 = Lib_SegmentedToVirtual(sceneData->objectBank.banksDataPtr);
 }
 
-void Scene_Proc_Door_Data_Ptr(Game_Play* play, SceneData* scene_data) {
-    DoorData* data = scene_data->doorData.doorDataPtr;
+void Scene_Proc_Door_Data_Ptr(Game_Play* play, SceneData* sceneData) {
+    DoorData* data = sceneData->doorData.doorDataPtr;
 
-    play->sceneDoorInfo.numDoors = scene_data->doorData.numDoors;
+    play->sceneDoorInfo.numDoors = sceneData->doorData.numDoors;
     play->sceneDoorInfo.doorDataPtr = Lib_SegmentedToVirtual(data);
 }
 
@@ -612,7 +612,7 @@ void Door_info_ct(DoorInfo* door_info) {
     door_info->numDoors = 0;
 }
 
-void Scene_Proc_Sound(UNUSED Game_Play* play, UNUSED SceneData* scene_data) {
+void Scene_Proc_Sound(UNUSED Game_Play* play, UNUSED SceneData* sceneData) {
 }
 
 void set_item_info(Game_Play* play, SceneDataField* field) {
@@ -636,10 +636,10 @@ void set_item_info(Game_Play* play, SceneDataField* field) {
     }
 }
 
-void Scene_Proc_Field_ct(Game_Play* play, SceneData* scene_data) {
-    mFM_SetFieldInitData(scene_data->field.bgNum, scene_data->field.bgDispSize);
-    set_item_info(play, &scene_data->field);
-    common_data.unk_10002 = scene_data->field.drawType;
+void Scene_Proc_Field_ct(Game_Play* play, SceneData* sceneData) {
+    mFM_SetFieldInitData(sceneData->field.bgNum, sceneData->field.bgDispSize);
+    set_item_info(play, &sceneData->field);
+    common_data.fieldDrawType = sceneData->field.drawType;
     common_data.unk_10000 = FALSE;
     common_data.unk_104AC = TRUE;
     common_data.sunlightFlag = TRUE;
diff --git a/src/overlays/actors/ovl_Train_Window/ac_train_window.c b/src/overlays/actors/ovl_Train_Window/ac_train_window.c
index a714a8b..36559c6 100644
--- a/src/overlays/actors/ovl_Train_Window/ac_train_window.c
+++ b/src/overlays/actors/ovl_Train_Window/ac_train_window.c
@@ -261,7 +261,7 @@ void aTrainWindow_SetLightPrimColorDetail(Game* game, u8 l, u8 polyAlpha, u8 xlu
     s32 current;
 
     for (i = 0; i < 3; i++) {
-        current = play->glight.ambientColor[i] + play->kankyo.sunColor[i];
+        current = play->glight.ambientColor[i] + play->kankyo.baseLight.sunColor[i];
         if (current < 0) {
             current = 0;
         } else if (current >= 256) {
diff --git a/src/overlays/actors/ovl_Weather/ac_weather.h b/src/overlays/actors/ovl_Weather/ac_weather.h
index 3a972d4..0b1b294 100644
--- a/src/overlays/actors/ovl_Weather/ac_weather.h
+++ b/src/overlays/actors/ovl_Weather/ac_weather.h
@@ -10,10 +10,6 @@ struct Game_Play;
 
 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;
diff --git a/src/overlays/gamestates/ovl_play/m_play.c b/src/overlays/gamestates/ovl_play/m_play.c
index add724a..8554be5 100644
--- a/src/overlays/gamestates/ovl_play/m_play.c
+++ b/src/overlays/gamestates/ovl_play/m_play.c
@@ -740,9 +740,9 @@ label:;
     func_80803810_jp(game_play, gfxCtx);
     if (common_data.unk_10001 == 0) {
         if (mEv_CheckTitleDemo() != -9) {
-            sp2B = game_play->kankyo.unk_AE;
-            sp2A = game_play->kankyo.unk_AF;
-            sp29 = game_play->kankyo.unk_B0;
+            sp2B = game_play->kankyo.baseLight.bgColor[0];
+            sp2A = game_play->kankyo.baseLight.bgColor[1];
+            sp29 = game_play->kankyo.baseLight.bgColor[2];
         }
     }
 
diff --git a/yamls/jp/code.yaml b/yamls/jp/code.yaml
index b909c21..fed4dbe 100644
--- a/yamls/jp/code.yaml
+++ b/yamls/jp/code.yaml
@@ -46,7 +46,7 @@
       - [0x6B8F20, asm, code/6B8F20]
       - [0x6BA3B0, asm, code/m_item_name]
       - [0x6BA500, asm, code/6BA500]
-      - [0x6BA930, asm, code/m_kankyo]
+      - [0x6BA930, c, code/m_kankyo]
       - [0x6BD560, c, code/m_lib]
       - [0x6BEE80, c, code/m_lights]
       - [0x6BFC60, c, code/m_malloc]
@@ -160,6 +160,7 @@
       - [0x7284B0, data, code/69E2C0]
       - [0x72AAC0, .data, code/m_game_dlftbls]
       - [0x72ACB0, data, code/72ACB0]
+      - [0x72B400, .data, code/m_kankyo]
       - [0x72B7A0, .data, code/m_lib]
       - [0x72B7D0, .data, code/m_lights]
       - [0x72B7F0, data, code/72B7F0]
@@ -230,7 +231,7 @@
       - [0x73AD40, rodata, code/73AD40]
       - [0x73AD50, rodata, code/73AD50]
       - [0x73AD70, rodata, code/73AD70]
-      - [0x73AD90, rodata, code/m_kankyo]
+      - [0x73AD90, .rodata, code/m_kankyo]
       - [0x73AED0, .rodata, code/m_lib]
       - [0x73AEE0, .rodata, code/m_lights]
       - [0x73AEF0, rodata, code/m_msg_main]
@@ -294,6 +295,7 @@
       - { start: 0x73F4D0, type: .bss, vram: 0x80138E50, name: code/m_debug}
       - { start: 0x73F4D0, type: .bss, vram: 0x80138E60, name: code/m_debug_display}
       - { start: 0x73F4E0, type: bss, vram: 0x80138E70, name: code/80138E70 }
+      - { start: 0x73F4D0, type: .bss, vram: 0x80141DE0, name: code/m_kankyo }
       - { start: 0x73F4D0, type: .bss, vram: 0x80141E10, name: code/m_lights }
       - { start: 0x75B600, type: .bss, vram: 0x80141FA0, name: code/m_malloc }
       - { start: 0x75B600, type: bss, vram: 0x80141FE0, name: code/80141FE0 }