z_lifemeter (#247)

* z_lifemeter done.

* fix new warning I didn't saw. add variables.txt

* suggested changes

* add new texture ptrs to undefined_sym, changed heartTex & temp to TexturePtr in LifeMeter_Draw

* change hex literal to decimal and other small suggestions

* change bool to u32; change hexa literal to decimal in LifeMeter_IsCritical; renamed undefined sym to their D_02 addresses

* re-applied format.sh on z_lifemeter

* coding style fixes

* fix typo in undefined_sym

* named func and vars.

* changed modulo check

* add extra line after var declaration in LifeMeter_Draw

Co-authored-by: engineer124 <47598039+engineer124@users.noreply.github.com>

* changed unkTimer to camelCase; timer constant as decimal; flip some comparison in LifeMeter_Draw

* uncomment & rename func_ in functions.h

* Update include/functions.h

Co-authored-by: engineer124 <47598039+engineer124@users.noreply.github.com>

Co-authored-by: Andzura <andzura@andzura.fr>
Co-authored-by: engineer124 <47598039+engineer124@users.noreply.github.com>

7 files changed, 476 insertions, 67 deletions

diff --git a/include/functions.h b/include/functions.h
index dd2ecd2a8..6504cdbeb 100644
--- a/include/functions.h
+++ b/include/functions.h
@@ -2000,12 +2000,12 @@ void* Lib_PhysicalToVirtual(void* ptr);
 void* Lib_PhysicalToVirtualNull(void* ptr);
 void LifeMeter_Init(GlobalContext* globalCtx);
 void LifeMeter_UpdateColors(GlobalContext* globalCtx);
-// UNK_TYPE4 func_80100A80(GlobalContext* globalCtx);
-// UNK_TYPE4 func_80100AA0(GlobalContext* globalCtx);
-// UNK_TYPE4 func_80100AF0(GlobalContext* globalCtx);
+s32 LifeMeter_SaveInterfaceHealth(GlobalContext* globalCtx);
+s32 LifeMeter_IncreaseInterfaceHealth(GlobalContext* globalCtx);
+s32 LifeMeter_DecreaseInterfaceHealth(GlobalContext* globalCtx);
 void LifeMeter_Draw(GlobalContext* globalCtx);
 void LifeMeter_UpdateSizeAndBeep(GlobalContext* globalCtx);
-// s32 LifeMeter_IsCritical(void);
+bool LifeMeter_IsCritical(void);
 void Lights_PointSetInfo(LightInfo* info, s16 x, s16 y, s16 z, u8 r, u8 g, u8 b, s16 radius, s32 type);
 void Lights_PointNoGlowSetInfo(LightInfo* info, s16 x, s16 y, s16 z, u8 r, u8 g, u8 b, s16 radius);
 void Lights_PointGlowSetInfo(LightInfo* info, s16 x, s16 y, s16 z, u8 r, u8 g, u8 b, s16 radius);
@@ -3389,15 +3389,16 @@ void Sched_Init(SchedContext* sched, void* stack, OSPri pri, UNK_TYPE arg3, UNK_
 void func_801773A0(void* arg0);
 void func_801773C4(void* arg0);
 void SpeedMeter_DrawTimeEntries(void* displayList, GraphicsContext* gCtx);
-// void func_80177A84(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE2 param_5,
-// UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8, UNK_TYPE4 param_9); void func_80177AC8(void);
-void SpeedMeter_DrawAllocEntries(void* displayList, GraphicsContext* gCtx, GameState* ctx);
-// void func_801780F0(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5,
-// UNK_TYPE4 param_6, UNK_TYPE4 param_7); void func_801781EC(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3,
-// UNK_TYPE1 param_4, UNK_TYPE4 param_5); void func_8017842C(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3,
-// UNK_TYPE1 param_4, UNK_TYPE2 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8, UNK_TYPE4 param_9,
-// UNK_TYPE4 param_10, UNK_TYPE4 param_11); void func_80178750(void); void func_80178818(void); void
-// func_80178978(void); void func_801789D4(void);
+// void func_80177A84(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE2 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8, UNK_TYPE4 param_9);
+// void func_80177AC8(void);
+void SpeedMeter_DrawAllocEntries(void* displayList, GraphicsContext* gfxCtx, GameState* gameState);
+void func_801780F0(Mtx* param_1, f32 param_2, f32 param_3, f32 param_4, f32 param_5, f32 param_6, f32 param_7);
+// void func_801781EC(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5);
+// void func_8017842C(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE2 param_5, UNK_TYPE4 param_6, UNK_TYPE4 param_7, UNK_TYPE4 param_8, UNK_TYPE4 param_9, UNK_TYPE4 param_10, UNK_TYPE4 param_11);
+// void func_80178750(void);
+// void func_80178818(void);
+// void func_80178978(void);
+// void func_801789D4(void);
 u32* get_framebuffer(s32 index);
 // u16* get_zbuffer(void);
 // UNK_TYPE4 func_80178A24(void);
diff --git a/include/variables.h b/include/variables.h
index 31443e6a8..6c79074ad 100644
--- a/include/variables.h
+++ b/include/variables.h
@@ -1001,28 +1001,28 @@ extern u8 kanfontOrdering[92];
 // extern UNK_TYPE1 D_801BE92C;
 // extern UNK_TYPE1 D_801BE944;
 // extern actor_init_var_func sInitChainHandlers[11];
-// extern UNK_TYPE2 D_801BE990;
+// extern UNK_TYPE2 sHeartsPrimColors;
 // extern UNK_TYPE2 D_801BE992;
 // extern UNK_TYPE2 D_801BE994;
-// extern UNK_TYPE2 D_801BE9A4;
+// extern UNK_TYPE2 sHeartsEnvColors;
 // extern UNK_TYPE2 D_801BE9A6;
 // extern UNK_TYPE2 D_801BE9A8;
-// extern UNK_TYPE2 D_801BE9B8;
-// extern UNK_TYPE2 D_801BE9CC;
-// extern UNK_TYPE2 D_801BE9E0;
+// extern UNK_TYPE2 sHeartsPrimFactors;
+// extern UNK_TYPE2 sHeartsEnvFactors;
+// extern UNK_TYPE2 sHeartsDDPrimColors;
 // extern UNK_TYPE2 D_801BE9E2;
 // extern UNK_TYPE2 D_801BE9E4;
-// extern UNK_TYPE2 D_801BE9F4;
+// extern UNK_TYPE2 sHeartsDDEnvColors;
 // extern UNK_TYPE2 D_801BE9F6;
 // extern UNK_TYPE2 D_801BE9F8;
-// extern UNK_TYPE2 D_801BEA08;
+// extern UNK_TYPE2 sHeartsDDPrimFactors;
 // extern UNK_TYPE2 D_801BEA0A;
 // extern UNK_TYPE2 D_801BEA0C;
-// extern UNK_TYPE2 D_801BEA1C;
+// extern UNK_TYPE2 sHeartsDDEnvFactors;
 // extern UNK_TYPE2 D_801BEA1E;
 // extern UNK_TYPE2 D_801BEA20;
-// extern UNK_TYPE1 D_801BEA30;
-// extern UNK_TYPE1 D_801BEA70;
+// extern UNK_TYPE1 HeartTextures;
+// extern UNK_TYPE1 HeartDDTextures;
 //extern LightsPosBindFunc posBindFuncs[3];
 //extern LightsBindFunc dirBindFuncs[3];
 // extern UNK_TYPE4 D_801BEAD4;
@@ -3333,9 +3333,9 @@ extern f32 D_801F4E70;
 // extern UNK_TYPE1 D_801F4F33;
 // extern UNK_TYPE1 D_801F4F34;
 // extern UNK_TYPE1 D_801F4F38;
-// extern UNK_TYPE1 D_801F4F40;
-// extern UNK_TYPE1 D_801F4F48;
-// extern UNK_TYPE1 D_801F4F50;
+// extern UNK_TYPE1 sBeatingHeartsDDPrim;
+// extern UNK_TYPE1 sBeatingHeartsDDEnv;
+// extern UNK_TYPE1 sHeartsDDPrim;
 // extern UNK_TYPE1 D_801F4F56;
 // extern UNK_TYPE1 D_801F4F58;
 // extern UNK_TYPE1 D_801F4F5A;
diff --git a/include/z64.h b/include/z64.h
index 107435011..9f186285f 100644
--- a/include/z64.h
+++ b/include/z64.h
@@ -737,8 +737,8 @@ typedef struct {
     /* 0x242 */ s16 heartsEnvR[2];
     /* 0x246 */ s16 heartsEnvG[2];
     /* 0x24A */ s16 heartsEnvB[2];
-    /* 0x24E */ s16 unk_24E;
-    /* 0x250 */ s16 unk_250;
+    /* 0x24E */ s16 health;
+    /* 0x250 */ s16 unkTimer;
     /* 0x252 */ s16 lifeSizeChange;
     /* 0x254 */ s16 lifeSizeChangeDirection; // 1 means shrinking, 0 growing
     /* 0x256 */ s16 unk_256;
diff --git a/spec b/spec
index c2087fea8..b8bfea0ac 100644
--- a/spec
+++ b/spec
@@ -520,8 +520,6 @@ beginseg
     include "build/data/code/z_kankyo.bss.o"
     include "build/src/code/z_lib.o"
     include "build/src/code/z_lifemeter.o"
-    include "build/data/code/z_lifemeter.data.o"
-    include "build/data/code/z_lifemeter.bss.o"
     include "build/src/code/z_lights.o"
     include "build/data/code/z_lights.bss.o"
     include "build/src/code/z_malloc.o"
diff --git a/src/code/z_lifemeter.c b/src/code/z_lifemeter.c
index ec532fc60..e2a91199d 100644
--- a/src/code/z_lifemeter.c
+++ b/src/code/z_lifemeter.c
@@ -1,17 +1,436 @@
 #include "global.h"
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_lifemeter/LifeMeter_Init.s")
+static s16 sHeartsPrimColors[3][3] = { { 255, 70, 50 }, { 255, 190, 0 }, { 100, 100, 255 } };
+static s16 sHeartsEnvColors[3][3] = { { 50, 40, 60 }, { 255, 0, 0 }, { 0, 0, 255 } };
+static s16 sHeartsPrimFactors[3][3] = { { 0, 0, 0 }, { 0, 120, -50 }, { -155, 30, 205 } };
+static s16 sHeartsEnvFactors[3][3] = { { 0, 0, 0 }, { 205, -40, -60 }, { -50, -40, 195 } };
+static s16 sHeartsDDPrimColors[3][3] = { { 255, 255, 255 }, { 255, 190, 0 }, { 100, 100, 255 } };
+static s16 sHeartsDDEnvColors[3][3] = { { 200, 0, 0 }, { 255, 0, 0 }, { 0, 0, 255 } };
+static s16 sHeartsDDPrimFactors[3][3] = { { 0, 0, 0 }, { 0, -65, -255 }, { -155, -155, 0 } };
+static s16 sHeartsDDEnvFactors[3][3] = { { 0, 0, 0 }, { 55, 0, 0 }, { -200, 0, 255 } };
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_lifemeter/LifeMeter_UpdateColors.s")
+s16 sBeatingHeartsDDPrim[3];
+s16 sBeatingHeartsDDEnv[3];
+s16 sHeartsDDPrim[2][3];
+s16 sHeartsDDEnv[2][3];
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_lifemeter/func_80100A80.s")
+extern TexturePtr D_02000000; // Empty heart texture
+extern TexturePtr D_02000100; // Quarter Heart Texture
+extern TexturePtr D_02000200; // Half Heart Texture
+extern TexturePtr D_02000300; // Three Quarter Heart Texture
+extern TexturePtr D_02000400; // Full heart texture
+extern TexturePtr D_02000500; // Empty Double Defense Heart texture
+extern TexturePtr D_02000600; // Quarter Double Defense Heart Texture
+extern TexturePtr D_02000700; // Half Double Defense Heart Texture
+extern TexturePtr D_02000800; // Three Quarter Double Defense Heart Texture
+extern TexturePtr D_02000900; // Full Double Defense Heart texture
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_lifemeter/func_80100AA0.s")
+TexturePtr HeartTextures[] = { &D_02000400, &D_02000100, &D_02000100, &D_02000100, &D_02000100, &D_02000100,
+                               &D_02000200, &D_02000200, &D_02000200, &D_02000200, &D_02000200, &D_02000300,
+                               &D_02000300, &D_02000300, &D_02000300, &D_02000300 };
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_lifemeter/func_80100AF0.s")
+TexturePtr HeartDDTextures[] = { &D_02000900, &D_02000600, &D_02000600, &D_02000600, &D_02000600, &D_02000600,
+                                 &D_02000700, &D_02000700, &D_02000700, &D_02000700, &D_02000700, &D_02000800,
+                                 &D_02000800, &D_02000800, &D_02000800, &D_02000800 };
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_lifemeter/LifeMeter_Draw.s")
+void LifeMeter_Init(GlobalContext* globalCtx) {
+    InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_lifemeter/LifeMeter_UpdateSizeAndBeep.s")
+    interfaceCtx->unkTimer = 320;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_lifemeter/LifeMeter_IsCritical.s")
+    interfaceCtx->health = gSaveContext.health;
+
+    interfaceCtx->lifeColorChange = 0;
+    interfaceCtx->lifeColorChangeDirection = 0;
+
+    interfaceCtx->lifeSizeChange = interfaceCtx->lifeColorChange;
+    interfaceCtx->lifeSizeChangeDirection = interfaceCtx->lifeColorChangeDirection;
+
+    interfaceCtx->heartsPrimR[0] = 255;
+    interfaceCtx->heartsPrimG[0] = 70;
+    interfaceCtx->heartsPrimB[0] = 50;
+
+    interfaceCtx->heartsEnvR[0] = 50;
+    interfaceCtx->heartsEnvG[0] = 40;
+    interfaceCtx->heartsEnvB[0] = 60;
+
+    interfaceCtx->heartsPrimR[1] = 255;
+    interfaceCtx->heartsPrimG[1] = 70;
+    interfaceCtx->heartsPrimB[1] = 50;
+
+    interfaceCtx->heartsEnvR[1] = 50;
+    interfaceCtx->heartsEnvG[1] = 40;
+    interfaceCtx->heartsEnvB[1] = 60;
+
+    sHeartsDDPrim[0][0] = sHeartsDDPrim[1][0] = 255;
+    sHeartsDDPrim[0][1] = sHeartsDDPrim[1][1] = 255;
+    sHeartsDDPrim[0][2] = sHeartsDDPrim[1][2] = 255;
+
+    sHeartsDDEnv[0][0] = sHeartsDDEnv[1][0] = 200;
+    sHeartsDDEnv[0][1] = sHeartsDDEnv[1][1] = 0;
+    sHeartsDDEnv[0][2] = sHeartsDDEnv[1][2] = 0;
+}
+
+void LifeMeter_UpdateColors(GlobalContext* globalCtx) {
+    InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
+    f32 factorBeating = interfaceCtx->lifeColorChange * 0.1f;
+    f32 ddFactor;
+    s32 type = 0;
+    s32 ddType;
+    s16 rFactor;
+    s16 gFactor;
+    s16 bFactor;
+
+    if (interfaceCtx) {}
+
+    if (interfaceCtx->lifeColorChangeDirection != 0) {
+        interfaceCtx->lifeColorChange--;
+        if (interfaceCtx->lifeColorChange <= 0) {
+            interfaceCtx->lifeColorChange = 0;
+            interfaceCtx->lifeColorChangeDirection = 0;
+        }
+    } else {
+        interfaceCtx->lifeColorChange++;
+        if (interfaceCtx->lifeColorChange >= 10) {
+            interfaceCtx->lifeColorChange = 10;
+            interfaceCtx->lifeColorChangeDirection = 1;
+        }
+    }
+
+    ddFactor = factorBeating;
+
+    interfaceCtx->heartsPrimR[0] = 255;
+    interfaceCtx->heartsPrimG[0] = 70;
+    interfaceCtx->heartsPrimB[0] = 50;
+
+    interfaceCtx->heartsEnvR[0] = 50;
+    interfaceCtx->heartsEnvG[0] = 40;
+    interfaceCtx->heartsEnvB[0] = 60;
+
+    interfaceCtx->heartsPrimR[1] = sHeartsPrimColors[type][0];
+    interfaceCtx->heartsPrimG[1] = sHeartsPrimColors[type][1];
+    interfaceCtx->heartsPrimB[1] = sHeartsPrimColors[type][2];
+
+    interfaceCtx->heartsEnvR[1] = sHeartsEnvColors[type][0];
+    interfaceCtx->heartsEnvG[1] = sHeartsEnvColors[type][1];
+    interfaceCtx->heartsEnvB[1] = sHeartsEnvColors[type][2];
+
+    rFactor = sHeartsPrimFactors[0][0] * factorBeating;
+    gFactor = sHeartsPrimFactors[0][1] * factorBeating;
+    bFactor = sHeartsPrimFactors[0][2] * factorBeating;
+
+    interfaceCtx->beatingHeartPrim[0] = (u8)(rFactor + 255) & 0xFF;
+    interfaceCtx->beatingHeartPrim[1] = (u8)(gFactor + 70) & 0xFF;
+    interfaceCtx->beatingHeartPrim[2] = (u8)(bFactor + 50) & 0xFF;
+
+    rFactor = sHeartsEnvFactors[0][0] * factorBeating;
+    gFactor = sHeartsEnvFactors[0][1] * factorBeating;
+    bFactor = sHeartsEnvFactors[0][2] * factorBeating;
+
+    if (1) {}
+    ddType = type;
+
+    interfaceCtx->beatingHeartEnv[0] = (u8)(rFactor + 50) & 0xFF;
+    interfaceCtx->beatingHeartEnv[1] = (u8)(gFactor + 40) & 0xFF;
+    interfaceCtx->beatingHeartEnv[2] = (u8)(bFactor + 60) & 0xFF;
+
+    sHeartsDDPrim[0][0] = 255;
+    sHeartsDDPrim[0][1] = 255;
+    sHeartsDDPrim[0][2] = 255;
+
+    sHeartsDDEnv[0][0] = 200;
+    sHeartsDDEnv[0][1] = 0;
+    sHeartsDDEnv[0][2] = 0;
+
+    sHeartsDDPrim[1][0] = sHeartsDDPrimColors[ddType][0];
+    sHeartsDDPrim[1][1] = sHeartsDDPrimColors[ddType][1];
+    sHeartsDDPrim[1][2] = sHeartsDDPrimColors[ddType][2];
+
+    sHeartsDDEnv[1][0] = sHeartsDDEnvColors[ddType][0];
+    sHeartsDDEnv[1][1] = sHeartsDDEnvColors[ddType][1];
+    sHeartsDDEnv[1][2] = sHeartsDDEnvColors[ddType][2];
+
+    rFactor = sHeartsDDPrimFactors[ddType][0] * ddFactor;
+    gFactor = sHeartsDDPrimFactors[ddType][1] * ddFactor;
+    bFactor = sHeartsDDPrimFactors[ddType][2] * ddFactor;
+
+    sBeatingHeartsDDPrim[0] = (u8)(rFactor + 255) & 0xFF;
+    sBeatingHeartsDDPrim[1] = (u8)(gFactor + 255) & 0xFF;
+    sBeatingHeartsDDPrim[2] = (u8)(bFactor + 255) & 0xFF;
+
+    rFactor = sHeartsDDEnvFactors[ddType][0] * ddFactor;
+    gFactor = sHeartsDDEnvFactors[ddType][1] * ddFactor;
+    bFactor = sHeartsDDEnvFactors[ddType][2] * ddFactor;
+
+    sBeatingHeartsDDEnv[0] = (u8)(rFactor + 200) & 0xFF;
+    sBeatingHeartsDDEnv[1] = (u8)(gFactor + 0) & 0xFF;
+    sBeatingHeartsDDEnv[2] = (u8)(bFactor + 0) & 0xFF;
+}
+
+s32 LifeMeter_SaveInterfaceHealth(GlobalContext* globalCtx) {
+    gSaveContext.health = globalCtx->interfaceCtx.health;
+    
+    return 1;
+}
+
+s32 LifeMeter_IncreaseInterfaceHealth(GlobalContext* globalCtx) {
+    InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
+
+    interfaceCtx->unkTimer = 320;
+    interfaceCtx->health += 0x10;
+    if (globalCtx->interfaceCtx.health >= gSaveContext.health) {
+        globalCtx->interfaceCtx.health = gSaveContext.health;
+        return 1;
+    }
+    return 0;
+}
+
+s32 LifeMeter_DecreaseInterfaceHealth(GlobalContext* globalCtx) {
+    InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
+
+    if (interfaceCtx->unkTimer != 0) {
+        interfaceCtx->unkTimer--;
+    } else {
+        interfaceCtx->unkTimer = 320;
+        interfaceCtx->health -= 0x10;
+        if (interfaceCtx->health <= 0) {
+            interfaceCtx->health = 0;
+            globalCtx->damagePlayer(globalCtx, -(((void)0, gSaveContext.health) + 1));
+            return 1;
+        }
+    }
+    return 0;
+}
+
+void LifeMeter_Draw(GlobalContext* globalCtx) {
+    s32 pad[5];
+    TexturePtr heartTex;
+    s32 curColorSet;
+    f32 offsetX;
+    f32 offsetY;
+    s32 i;
+    f32 posY;
+    f32 posX;
+    f32 halfTexSize;
+    f32 temp_f4;
+    GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
+    InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
+    Vtx* beatingHeartVtx = interfaceCtx->beatingHeartVtx;
+    s32 fractionHeartCount = gSaveContext.health % 0x10;
+    s16 healthCapacity = gSaveContext.healthCapacity / 0x10;
+    s16 fullHeartCount = gSaveContext.health / 0x10;
+    s32 pad2;
+    f32 lifesize = interfaceCtx->lifeSizeChange * 0.1f;
+    u32 curCombineModeSet = 0;
+    TexturePtr temp = NULL;
+    s32 ddCount = gSaveContext.inventory.dungeonKeys[9] - 1;
+
+    OPEN_DISPS(gfxCtx);
+
+    if ((gSaveContext.health % 0x10) == 0){
+        fullHeartCount--;
+    }
+    offsetY = 0.0f;
+    offsetX = 0.0f;
+    curColorSet = -1;
+
+    for (i = 0; i < healthCapacity; i++) {
+        if ((ddCount < 0) || (ddCount < i)) {
+            if (i < fullHeartCount) {
+                if (curColorSet != 0) {
+                    curColorSet = 0;
+                    gDPPipeSync(OVERLAY_DISP++);
+                    gDPSetPrimColor(OVERLAY_DISP++, 0, 0, interfaceCtx->heartsPrimR[0], interfaceCtx->heartsPrimG[0],
+                                    interfaceCtx->heartsPrimB[0], interfaceCtx->healthAlpha);
+                    gDPSetEnvColor(OVERLAY_DISP++, interfaceCtx->heartsEnvR[0], interfaceCtx->heartsEnvG[0],
+                                   interfaceCtx->heartsEnvB[0], 255);
+                }
+            } else if (i == fullHeartCount) {
+                if (curColorSet != 1) {
+                    curColorSet = 1;
+                    gDPPipeSync(OVERLAY_DISP++);
+                    gDPSetPrimColor(OVERLAY_DISP++, 0, 0, interfaceCtx->beatingHeartPrim[0],
+                                    interfaceCtx->beatingHeartPrim[1], interfaceCtx->beatingHeartPrim[2],
+                                    interfaceCtx->healthAlpha);
+                    gDPSetEnvColor(OVERLAY_DISP++, interfaceCtx->beatingHeartEnv[0], interfaceCtx->beatingHeartEnv[1],
+                                   interfaceCtx->beatingHeartEnv[2], 255);
+                }
+            } else if (fullHeartCount < i) {
+                if (curColorSet != 2) {
+                    curColorSet = 2;
+                    gDPPipeSync(OVERLAY_DISP++);
+                    gDPSetPrimColor(OVERLAY_DISP++, 0, 0, interfaceCtx->heartsPrimR[0], interfaceCtx->heartsPrimG[0],
+                                    interfaceCtx->heartsPrimB[0], interfaceCtx->healthAlpha);
+                    gDPSetEnvColor(OVERLAY_DISP++, interfaceCtx->heartsEnvR[0], interfaceCtx->heartsEnvG[0],
+                                   interfaceCtx->heartsEnvB[0], 255);
+                }
+            } else {
+                if (curColorSet != 3) {
+                    curColorSet = 3;
+                    gDPPipeSync(OVERLAY_DISP++);
+                    gDPSetPrimColor(OVERLAY_DISP++, 0, 0, interfaceCtx->heartsPrimR[1], interfaceCtx->heartsPrimG[1],
+                                    interfaceCtx->heartsPrimB[1], interfaceCtx->healthAlpha);
+                    gDPSetEnvColor(OVERLAY_DISP++, interfaceCtx->heartsEnvR[1], interfaceCtx->heartsEnvG[1],
+                                   interfaceCtx->heartsEnvB[1], 255);
+                }
+            }
+
+            if (i < fullHeartCount) {
+                heartTex = &D_02000400;
+            } else if (i == fullHeartCount) {
+                heartTex = HeartTextures[fractionHeartCount];
+            } else {
+                heartTex = &D_02000000;
+            }
+        } else {
+            if (i < fullHeartCount) {
+                if (curColorSet != 4) {
+                    curColorSet = 4;
+                    gDPPipeSync(OVERLAY_DISP++);
+                    gDPSetPrimColor(OVERLAY_DISP++, 0, 0, sHeartsDDPrim[0][0], sHeartsDDPrim[0][1], sHeartsDDPrim[0][2],
+                                    interfaceCtx->healthAlpha);
+                    gDPSetEnvColor(OVERLAY_DISP++, sHeartsDDEnv[0][0], sHeartsDDEnv[0][1], sHeartsDDEnv[0][2], 255);
+                }
+            } else if (i == fullHeartCount) {
+                if (curColorSet != 5) {
+                    curColorSet = 5;
+                    gDPPipeSync(OVERLAY_DISP++);
+                    gDPSetPrimColor(OVERLAY_DISP++, 0, 0, sBeatingHeartsDDPrim[0], sBeatingHeartsDDPrim[1],
+                                    sBeatingHeartsDDPrim[2], interfaceCtx->healthAlpha);
+                    gDPSetEnvColor(OVERLAY_DISP++, sBeatingHeartsDDEnv[0], sBeatingHeartsDDEnv[1],
+                                   sBeatingHeartsDDEnv[2], 255);
+                }
+            } else if (i > fullHeartCount) {
+                if (curColorSet != 6) {
+                    curColorSet = 6;
+                    gDPPipeSync(OVERLAY_DISP++);
+                    gDPSetPrimColor(OVERLAY_DISP++, 0, 0, sHeartsDDPrim[0][0], sHeartsDDPrim[0][1], sHeartsDDPrim[0][2],
+                                    interfaceCtx->healthAlpha);
+                    gDPSetEnvColor(OVERLAY_DISP++, sHeartsDDEnv[0][0], sHeartsDDEnv[0][1], sHeartsDDEnv[0][2], 255);
+                }
+            } else if (curColorSet != 7) {
+                curColorSet = 7;
+                gDPPipeSync(OVERLAY_DISP++);
+                gDPSetPrimColor(OVERLAY_DISP++, 0, 0, sHeartsDDPrim[1][0], sHeartsDDPrim[1][1], sHeartsDDPrim[1][2],
+                                interfaceCtx->healthAlpha);
+                gDPSetEnvColor(OVERLAY_DISP++, sHeartsDDEnv[1][0], sHeartsDDEnv[1][1], sHeartsDDEnv[1][2], 255);
+            }
+            if (i < fullHeartCount) {
+                heartTex = &D_02000900;
+            } else if (i == fullHeartCount) {
+                heartTex = HeartDDTextures[fractionHeartCount];
+            } else {
+                heartTex = &D_02000500;
+            }
+        }
+
+        if (temp != heartTex) {
+            temp = heartTex;
+            gDPLoadTextureBlock(OVERLAY_DISP++, heartTex, G_IM_FMT_IA, G_IM_SIZ_8b, 16, 16, 0,
+                                G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
+                                G_TX_NOLOD, G_TX_NOLOD);
+        }
+
+        if (i != fullHeartCount) {
+            if ((ddCount < 0) || (i > ddCount)) {
+                if (curCombineModeSet != 1) {
+                    curCombineModeSet = 1;
+                    func_8012C654(gfxCtx);
+                    gDPSetCombineLERP(OVERLAY_DISP++, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE,
+                                      0, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0);
+                }
+            } else if (curCombineModeSet != 3) {
+                curCombineModeSet = 3;
+                func_8012C654(gfxCtx);
+                gDPSetCombineLERP(OVERLAY_DISP++, ENVIRONMENT, PRIMITIVE, TEXEL0, PRIMITIVE, TEXEL0, 0, PRIMITIVE,
+                                    0, ENVIRONMENT, PRIMITIVE, TEXEL0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0);
+            }
+            posY = 26.0f + offsetY;
+            posX = 30.0f + offsetX;
+            temp_f4 = 1.0f;
+            temp_f4 /= 0.68f;
+            temp_f4 *= 1 << 10;
+            halfTexSize = 8.0f;
+            halfTexSize *= 0.68f;
+            gSPTextureRectangle(OVERLAY_DISP++, (s32)((posX - halfTexSize) * 4), (s32)((posY - halfTexSize) * 4),
+                                (s32)((posX + halfTexSize) * 4), (s32)((posY + halfTexSize) * 4), G_TX_RENDERTILE,
+                                0, 0, (s32) temp_f4, (s32) temp_f4);
+        } else {
+            Mtx* mtx;
+            
+            if ((ddCount < 0) || (ddCount < i)) {
+                if (curCombineModeSet != 2) {
+                    curCombineModeSet = 2;
+                    func_8012C8D4(gfxCtx);
+                    gDPSetCombineLERP(OVERLAY_DISP++, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE,
+                                      0, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0);
+                    gDPSetAlphaCompare(OVERLAY_DISP++, G_AC_THRESHOLD);
+                }
+            } else {
+                if (curCombineModeSet != 4) {
+                    curCombineModeSet = 4;
+                    func_8012C8D4(gfxCtx);
+                    gDPSetCombineLERP(OVERLAY_DISP++, ENVIRONMENT, PRIMITIVE, TEXEL0, PRIMITIVE, TEXEL0, 0, PRIMITIVE,
+                                      0, ENVIRONMENT, PRIMITIVE, TEXEL0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0);
+                    gDPSetAlphaCompare(OVERLAY_DISP++, G_AC_THRESHOLD);
+                }
+            }
+            mtx = GRAPH_ALLOC(gfxCtx, sizeof(Mtx));
+            func_801780F0(mtx, 1.0f - (0.32f * lifesize), 1.0f - (0.32f * lifesize), 1.0f - (0.32f * lifesize),
+                          -130.0f + offsetX, 94.5f - offsetY, 0.0f);
+            gSPMatrix(OVERLAY_DISP++, mtx, G_MTX_LOAD | G_MTX_MODELVIEW);
+            gSPVertex(OVERLAY_DISP++, beatingHeartVtx, 4, 0);
+            gSP1Quadrangle(OVERLAY_DISP++, 0, 2, 3, 1, 0);
+        }
+        offsetX += 10.0f;
+        if (i == 9) {
+            offsetY += 10.0f;
+            offsetX = 0.0f;
+        }
+    }
+    CLOSE_DISPS(gfxCtx);
+}
+
+void LifeMeter_UpdateSizeAndBeep(GlobalContext* globalCtx) {
+    InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
+
+    if (interfaceCtx->lifeSizeChangeDirection != 0) {
+        interfaceCtx->lifeSizeChange--;
+        if (interfaceCtx->lifeSizeChange <= 0) {
+            interfaceCtx->lifeSizeChange = 0;
+            interfaceCtx->lifeSizeChangeDirection = 0;
+            if (func_801233E4(globalCtx) == 0 && (globalCtx->pauseCtx.state == 0) &&
+                (globalCtx->pauseCtx.debugState == 0) && LifeMeter_IsCritical() && func_801690CC(globalCtx) == 0) {
+                //func_801233E4 and func_801690CC : Check if in Cutscene
+                play_sound(NA_SE_SY_HITPOINT_ALARM);
+            }
+        }
+    } else {
+        interfaceCtx->lifeSizeChange++;
+        if ((s32)interfaceCtx->lifeSizeChange >= 10) {
+            interfaceCtx->lifeSizeChange = 10;
+            interfaceCtx->lifeSizeChangeDirection = 1;
+        }
+    }
+}
+
+u32 LifeMeter_IsCritical(void) {
+    s16 criticalThreshold;
+
+    if (gSaveContext.healthCapacity <= 80) { // healthCapacity <= 5 hearts?
+        criticalThreshold = 16;
+
+    } else if (gSaveContext.healthCapacity <= 160) { // healthCapacity <= 10 hearts?
+        criticalThreshold = 24;
+
+    } else if (gSaveContext.healthCapacity <= 240) { // healthCapacity <= 15 hearts?
+        criticalThreshold = 32;
+    } else {
+        criticalThreshold = 44;
+    }
+
+    if ((criticalThreshold >= gSaveContext.health) && (gSaveContext.health > 0)) {
+        return true;
+    }
+    return false;
+}
diff --git a/tools/disasm/variables.txt b/tools/disasm/variables.txt
index 09ef0230c..994dd73f6 100644
--- a/tools/disasm/variables.txt
+++ b/tools/disasm/variables.txt
@@ -1000,28 +1000,16 @@
     0x801BE92C:("D_801BE92C","UNK_TYPE1","",0x1),
     0x801BE944:("D_801BE944","UNK_TYPE1","",0x1),
     0x801BE960:("sInitChainHandlers","actor_init_var_func","[11]",0x2c),
-    0x801BE990:("D_801BE990","UNK_TYPE2","",0x2),
-    0x801BE992:("D_801BE992","UNK_TYPE2","",0x2),
-    0x801BE994:("D_801BE994","UNK_TYPE2","",0x2),
-    0x801BE9A4:("D_801BE9A4","UNK_TYPE2","",0x2),
-    0x801BE9A6:("D_801BE9A6","UNK_TYPE2","",0x2),
-    0x801BE9A8:("D_801BE9A8","UNK_TYPE2","",0x2),
-    0x801BE9B8:("D_801BE9B8","UNK_TYPE2","",0x2),
-    0x801BE9CC:("D_801BE9CC","UNK_TYPE2","",0x2),
-    0x801BE9E0:("D_801BE9E0","UNK_TYPE2","",0x2),
-    0x801BE9E2:("D_801BE9E2","UNK_TYPE2","",0x2),
-    0x801BE9E4:("D_801BE9E4","UNK_TYPE2","",0x2),
-    0x801BE9F4:("D_801BE9F4","UNK_TYPE2","",0x2),
-    0x801BE9F6:("D_801BE9F6","UNK_TYPE2","",0x2),
-    0x801BE9F8:("D_801BE9F8","UNK_TYPE2","",0x2),
-    0x801BEA08:("D_801BEA08","UNK_TYPE2","",0x2),
-    0x801BEA0A:("D_801BEA0A","UNK_TYPE2","",0x2),
-    0x801BEA0C:("D_801BEA0C","UNK_TYPE2","",0x2),
-    0x801BEA1C:("D_801BEA1C","UNK_TYPE2","",0x2),
-    0x801BEA1E:("D_801BEA1E","UNK_TYPE2","",0x2),
-    0x801BEA20:("D_801BEA20","UNK_TYPE2","",0x2),
-    0x801BEA30:("D_801BEA30","UNK_TYPE1","",0x1),
-    0x801BEA70:("D_801BEA70","UNK_TYPE1","",0x1),
+    0x801BE990:("sHeartsPrimColors","s16","[3][3]",0x12),
+    0x801BE9A4:("sHeartsEnvColors","s16","[3][3]",0x12),
+    0x801BE9B8:("sHeartsPrimFactors","s16","[3][3]",0x12),
+    0x801BE9CC:("sHeartsEnvFactors","s16","[3][3]",0x12),
+    0x801BE9E0:("sHeartsDDPrimColors","s16","[3][3]",0x12),
+    0x801BE9F4:("sHeartsDDEnvColors","s16","[3][3]",0x12),
+    0x801BEA08:("sHeartsDDPrimFactors","s16","[3][3]",0x12),
+    0x801BEA1C:("sHeartsDDEnvFactors","s16","[3][3]",0x12),
+    0x801BEA30:("HeartTextures","UNK_TYPE1","",0x1),
+    0x801BEA70:("HeartDDTextures","UNK_TYPE1","",0x1),
     0x801BEAB0:("posBindFuncs","LightsPosBindFunc","[3]",0xc),
     0x801BEABC:("dirBindFuncs","LightsBindFunc","[3]",0xc),
     0x801BEAD4:("D_801BEAD4","UNK_TYPE4","",0x4),
@@ -4095,13 +4083,10 @@
     0x801F4F33:("D_801F4F33","UNK_TYPE1","",0x1),
     0x801F4F34:("D_801F4F34","UNK_TYPE1","",0x1),
     0x801F4F38:("D_801F4F38","UNK_TYPE1","",0x1),
-    0x801F4F40:("D_801F4F40","UNK_TYPE1","",0x1),
-    0x801F4F48:("D_801F4F48","UNK_TYPE1","",0x1),
-    0x801F4F50:("D_801F4F50","UNK_TYPE1","",0x1),
-    0x801F4F56:("D_801F4F56","UNK_TYPE1","",0x1),
-    0x801F4F58:("D_801F4F58","UNK_TYPE1","",0x1),
-    0x801F4F5A:("D_801F4F5A","UNK_TYPE1","",0x1),
-    0x801F4F60:("D_801F4F60","UNK_TYPE1","",0x1),
+    0x801F4F40:("sBeatingHeartsDDPrim","s32","[3]",0x6),
+    0x801F4F48:("sBeatingHeartsDDEnv","s32","[3]",0x6),
+    0x801F4F50:("sHeartsDDPrim","s32","[2][3]",0xC),
+    0x801F4F60:("sHeartsDDEnv","s32","[2][3]",0xC),
     0x801F4F66:("D_801F4F66","UNK_TYPE1","",0x1),
     0x801F4F68:("D_801F4F68","UNK_TYPE1","",0x1),
     0x801F4F6A:("D_801F4F6A","UNK_TYPE1","",0x1),
diff --git a/undefined_syms.txt b/undefined_syms.txt
index 6a655950f..00f55c3fe 100644
--- a/undefined_syms.txt
+++ b/undefined_syms.txt
@@ -157,8 +157,14 @@ D_01031618 = 0x01031618;
 // segment 0x02
 
 D_02000000 = 0x02000000;
+D_02000100 = 0x02000100;
+D_02000200 = 0x02000200;
+D_02000300 = 0x02000300;
 D_02000400 = 0x02000400;
 D_02000500 = 0x02000500;
+D_02000600 = 0x02000600;
+D_02000700 = 0x02000700;
+D_02000800 = 0x02000800;
 D_02000900 = 0x02000900;
 D_02000A00 = 0x02000A00;
 D_02000BE0 = 0x02000BE0;