From 01ae17b06c44ba13b58a833d6b49d21d8d6c4804 Mon Sep 17 00:00:00 2001 From: j3lee Date: Mon, 12 Oct 2026 13:07:05 +0930 Subject: [PATCH 1/4] hikari2: import and decompile the overlay --- CMakeLists.txt | 1 + config/symbols.magic-hikari2.us.txt | 10 ++ config/us.yaml | 13 ++ src/magic/hikari2.c | 197 ++++++++++++++++++++++++++++ src/magic/hikari2.h | 6 + tools/builder/builder/objdiff.go | 1 + 6 files changed, 228 insertions(+) create mode 100644 config/symbols.magic-hikari2.us.txt create mode 100644 src/magic/hikari2.c create mode 100644 src/magic/hikari2.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 14280eff..004db70a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -89,6 +89,7 @@ set(FF7_MINI set(FF7_MAGIC src/magic/barrier.c src/magic/brizad.c + src/magic/hikari2.c src/magic/lv5deth.c src/magic/mabaria.c src/magic/sennkoku.c diff --git a/config/symbols.magic-hikari2.us.txt b/config/symbols.magic-hikari2.us.txt new file mode 100644 index 00000000..e3cca5d9 --- /dev/null +++ b/config/symbols.magic-hikari2.us.txt @@ -0,0 +1,10 @@ +MAGIC_Hikari2 = 0x801B0000; +Hikari2DoubleBufferFlip = 0x801B0020; +Hikari2ViewportFlashTick = 0x801B008C; +Hikari2FlashFadeInSetup = 0x801B0120; +Hikari2FlashFadeOutSetup = 0x801B01B4; +Hikari2SparkSpriteTick = 0x801B0228; +Hikari2HitSpriteTick = 0x801B02E0; +Hikari2TargetTick = 0x801B039C; +Hikari2TargetSetup = 0x801B07CC; +Hikari2Start = 0x801B0854; diff --git a/config/us.yaml b/config/us.yaml index 69eaa150..6a767717 100644 --- a/config/us.yaml +++ b/config/us.yaml @@ -807,3 +807,16 @@ overlays: - [0, c, sennkoku] - [0x930, data, sennkoku_model] - [0x559C, data, sennkoku_buffers] + # HIKARI2.BIN -- effect overlay + - name: hikari2 + disk_path: disks/us/MAGIC/HIKARI2.BIN + sha1: 5b5d2cbf47408af9c01cda011172649b3ecf59ca + base_path: magic + imports: [main, battle] + vram_start: 0x801B0000 + symbol_addrs_path: + - config/symbols.magic-hikari2.us.txt + segments: + - [0, c, hikari2] + - [0x8E8, data, hikari2_model] + - [0x8AE0, data, hikari2_buffers] # REVIEW (split): first aligned word after the last non-zero byte; a cut inside the zero fill is byte-neutral diff --git a/src/magic/hikari2.c b/src/magic/hikari2.c new file mode 100644 index 00000000..71679084 --- /dev/null +++ b/src/magic/hikari2.c @@ -0,0 +1,197 @@ +//! PSYQ=3.3 CC1=2.6.3 + +#include "common.h" +#include "magic.h" +#include "hikari2.h" +#include "../battle/battle.h" + +void Hikari2Start(s32 targetMask, s32 callbackArg); +void Hikari2SparkSpriteTick(void); +void Hikari2HitSpriteTick(void); + +void Hikari2FlashFadeOutSetup(s16 frames); +extern s16 D_801D0AE8[]; +extern s16 D_800F5B74; +void Hikari2ViewportFlashTick(void); +void Hikari2TargetTick(void); +void Hikari2DoubleBufferFlip(void); +void Hikari2TargetSetup(s32 target, s32 callbackArg); + +// Primitive buffer pages, one 0xC000 page per double-buffered frame. +extern u8 D_801B8AE4[2][0xC000]; +extern void* D_801D0AE4; +extern void* D_80163C74; +extern s16 D_801B8AC8; +extern s16 D_801B8ACA; +extern SpriteRenderDesc D_801B8ACC; +extern SpriteRenderDesc D_801B8AD8; +extern s32 D_801B492C; +extern s32 D_801B8A04; +extern u_long D_801B08E8[]; +extern u_long D_801B49C0[]; +extern u8 D_800F5B70; +extern u8 D_800F5B71; +extern u8 D_800F5B72; + +// Only StartFrame/AnimationFrame are common to every magic overlay. +typedef struct { + /* 0x00 */ s16 StartFrame; + /* 0x02 */ s16 AnimationFrame; + /* 0x04 */ SVECTOR Pos; + /* 0x0C */ SVECTOR unkC; + /* 0x14 */ char pad14[6]; + /* 0x1A */ s16 unk1A; + /* 0x1C */ char pad1C[4]; +} Hikari2Data; // size:0x20 + +extern Hikari2Data g_BattleEffectSlots[]; + +void MAGIC_Hikari2(s32 targetMask, s32 callbackArg) { Hikari2Start(targetMask, callbackArg); } + +// Same as BioraDoubleBufferFlip. +void Hikari2DoubleBufferFlip(void) { + Hikari2Data* effect; + + effect = &g_BattleEffectSlots[g_BattleEffectCursor]; + D_801D0AE4 = D_801B8AE4[effect->AnimationFrame]; + effect->AnimationFrame ^= 1; + if (g_BattleEffectCount < 2) { + effect->StartFrame = -1; + } +} + +void Hikari2ViewportFlashTick(void) { + Hikari2Data* effect; + + effect = &g_BattleEffectSlots[g_BattleEffectCursor]; + D_80163C74 = func_800C4FC8(0, 0, D_801B8AC8); + if (!D_80062D98) { + D_801B8AC8 += D_801B8ACA; + if (!D_801B8AC8) { + effect->StartFrame = -1; + } + } +} + +void Hikari2FlashFadeInSetup(s16 frames) { + D_801B8AC8 = 0; + D_801B8ACA = 0xFF / frames; + BattleEffectRegister(Hikari2ViewportFlashTick); + D_800F5B70 = D_800F5B71 = D_800F5B72 = 0; + BattleFixedPointRampUpdateInit(0x1000, 15); +} + +void Hikari2FlashFadeOutSetup(s16 frames) { + D_801B8AC8 = 0xFF; + D_801B8ACA = -(0xFF / frames); + BattleFixedPointRampUpdateInit(0, 15); +} + +void Hikari2SparkSpriteTick(void) { + Hikari2Data* effect; + + effect = &g_BattleEffectSlots[g_BattleEffectCursor]; + BattleSetBillboardMatrix(&effect->Pos, 0x1800, 0); + D_801B8ACC.frameIndex = effect->AnimationFrame; + D_801D0AE4 = func_800D4D90(&D_801B8ACC, g_cDb->unk70, 12, D_801D0AE4); + if (!D_80062D98) { + effect->AnimationFrame++; + if (effect->AnimationFrame == D_801B492C) { + effect->StartFrame = -1; + } + } +} + +void Hikari2HitSpriteTick(void) { + Hikari2Data* effect; + + effect = &g_BattleEffectSlots[g_BattleEffectCursor]; + BattleSetBillboardMatrix(&effect->Pos, 0x1800, 0); + D_801B8AD8.frameIndex = effect->AnimationFrame; + D_801D0AE4 = func_800D4D90(&D_801B8AD8, g_cDb->unk70, 12, D_801D0AE4); + if (!D_80062D98) { + effect->AnimationFrame++; + if (effect->AnimationFrame >= D_801B8A04) { + effect->StartFrame = -1; + } + } +} + +void Hikari2TargetTick(void) { + Hikari2Data* effect; + Hikari2Data* child; + SVECTOR vec; + MATRIX matrix; + s32 flag; + s16 i; + + effect = &g_BattleEffectSlots[g_BattleEffectCursor]; + if (!D_80062D98) { + if (!effect->AnimationFrame) { + child = &g_BattleEffectSlots[BattleEffectRegister(Hikari2SparkSpriteTick)]; + child->unkC.vx = 0; + child->unkC.vy = ratan2(effect->unkC.vx - effect->Pos.vx, effect->unkC.vz - effect->Pos.vz); + vec.vx = vec.vy = 0; + vec.vz = 100; + RotMatrixYXZ(&child->unkC, &matrix); + matrix.t[0] = matrix.t[1] = matrix.t[2] = 0; + SetRotMatrix(&matrix); + SetTransMatrix(&matrix); + RotTransSV(&vec, &vec, &flag); + child->Pos.vx = effect->Pos.vx + vec.vx; + child->Pos.vy = effect->Pos.vy + vec.vy; + child->Pos.vz = effect->Pos.vz + vec.vz; + } + if (effect->AnimationFrame == 2) { + D_800F5B70 = D_800F5B71 = D_800F5B72 = 0; + D_800F5B74 = 0x1000; + for (i = 0; i < 10; i++) { + D_801D0AE8[i] = g_BattleModels[i].specialFlags; + g_BattleModels[i].specialFlags |= 2; + } + } + if (effect->AnimationFrame == 4) { + D_800F5B74 = 0; + Hikari2FlashFadeInSetup(15); + for (i = 0; i < 10; i++) { + g_BattleModels[i].specialFlags = D_801D0AE8[i]; + } + } + if (effect->AnimationFrame == 20) { + Hikari2FlashFadeOutSetup(15); + } + if (effect->AnimationFrame == 30) { + func_800D5774(effect->unk1A); + func_800BBA84(0x95, effect->unk1A, 0x40); + } + if (effect->AnimationFrame >= 31 && effect->AnimationFrame < 35) { + for (i = 0; i < 2; i++) { + child = &g_BattleEffectSlots[BattleEffectRegister(Hikari2HitSpriteTick)]; + BattleGetPartPosition(effect->unk1A, g_BattleModels[effect->unk1A].boneIndices[0], &child->Pos); + child->Pos.vx += rand() % 1000 - 500; + child->Pos.vy += rand() % 1000 - 500; + child->Pos.vz += rand() % 1000 - 500; + } + } + effect->AnimationFrame++; + if (effect->AnimationFrame == 40) { + effect->StartFrame = -1; + } + } +} + +void Hikari2TargetSetup(s32 target, s32 callbackArg) { + Hikari2Data* effect; + + effect = &g_BattleEffectSlots[BattleEffectRegister(Hikari2TargetTick)]; + BattleGetPartPosition(callbackArg, g_BattleModels[callbackArg].boneIndices[9], &effect->Pos); + effect->unk1A = target; +} + +void Hikari2Start(s32 targetMask, s32 callbackArg) { + BattleEffectRegister(Hikari2DoubleBufferFlip); + BattleSetLoadTimToVram(D_801B08E8, 0, 0, 0); + BattleSetLoadTimToVram(D_801B49C0, 0, 0, 0); + MagicAnimationRegister(targetMask, callbackArg, 4, Hikari2TargetSetup); + func_800BBA84(0x6B, callbackArg, 0x40); +} diff --git a/src/magic/hikari2.h b/src/magic/hikari2.h new file mode 100644 index 00000000..9c36bc3f --- /dev/null +++ b/src/magic/hikari2.h @@ -0,0 +1,6 @@ +#ifndef HIKARI2_H +#define HIKARI2_H + +#include "magic.h" + +#endif diff --git a/tools/builder/builder/objdiff.go b/tools/builder/builder/objdiff.go index 23967455..8ae0e653 100644 --- a/tools/builder/builder/objdiff.go +++ b/tools/builder/builder/objdiff.go @@ -113,6 +113,7 @@ var metaOverlays = map[string]metaOverlay{ "lv5deth": {"lv5deth", "magic", "LV.5 Death"}, "choco0": {"choco0", "magic", "choco0"}, "sennkoku": {"sennkoku", "magic", "Death Sentence / Roulette"}, + "hikari2": {"hikari2", "magic", "HIKARI2"}, } func makeObjdiffConfig(b BuildConfig) objdiffConfig { From a3eec334ff7b7594000a50db18187bf5fe4e4324 Mon Sep 17 00:00:00 2001 From: j3lee Date: Mon, 12 Oct 2026 13:07:06 +0930 Subject: [PATCH 2/4] hikari3: import and decompile the overlay --- CMakeLists.txt | 1 + config/symbols.magic-hikari3.us.txt | 10 ++ config/us.yaml | 13 ++ src/magic/hikari3.c | 190 ++++++++++++++++++++++++++++ src/magic/hikari3.h | 6 + tools/builder/builder/objdiff.go | 1 + 6 files changed, 221 insertions(+) create mode 100644 config/symbols.magic-hikari3.us.txt create mode 100644 src/magic/hikari3.c create mode 100644 src/magic/hikari3.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 004db70a..ade94dc6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -90,6 +90,7 @@ set(FF7_MAGIC src/magic/barrier.c src/magic/brizad.c src/magic/hikari2.c + src/magic/hikari3.c src/magic/lv5deth.c src/magic/mabaria.c src/magic/sennkoku.c diff --git a/config/symbols.magic-hikari3.us.txt b/config/symbols.magic-hikari3.us.txt new file mode 100644 index 00000000..23accd02 --- /dev/null +++ b/config/symbols.magic-hikari3.us.txt @@ -0,0 +1,10 @@ +MAGIC_Hikari3 = 0x801B0000; +Hikari3DoubleBufferFlip = 0x801B0020; +Hikari3ViewportFlashTick = 0x801B008C; +Hikari3FlashFadeInSetup = 0x801B0120; +Hikari3FlashFadeOutSetup = 0x801B0190; +Hikari3SparkSpriteTick = 0x801B01E8; +Hikari3HitSpriteTick = 0x801B02A0; +Hikari3TargetTick = 0x801B035C; +Hikari3TargetSetup = 0x801B078C; +Hikari3Start = 0x801B0814; diff --git a/config/us.yaml b/config/us.yaml index 6a767717..0fb1cba9 100644 --- a/config/us.yaml +++ b/config/us.yaml @@ -820,3 +820,16 @@ overlays: - [0, c, hikari2] - [0x8E8, data, hikari2_model] - [0x8AE0, data, hikari2_buffers] # REVIEW (split): first aligned word after the last non-zero byte; a cut inside the zero fill is byte-neutral + # HIKARI3.BIN -- effect overlay + - name: hikari3 + disk_path: disks/us/MAGIC/HIKARI3.BIN + sha1: 9c541c2e30e2fa5eca482081d46168bf97d7852d + base_path: magic + imports: [main, battle] + vram_start: 0x801B0000 + symbol_addrs_path: + - config/symbols.magic-hikari3.us.txt + segments: + - [0, c, hikari3] + - [0x8A8, data, hikari3_model] + - [0x8AA0, data, hikari3_buffers] # REVIEW (split): first aligned word after the last non-zero byte; a cut inside the zero fill is byte-neutral diff --git a/src/magic/hikari3.c b/src/magic/hikari3.c new file mode 100644 index 00000000..d6655613 --- /dev/null +++ b/src/magic/hikari3.c @@ -0,0 +1,190 @@ +//! PSYQ=3.3 CC1=2.6.3 + +#include "common.h" +#include "magic.h" +#include "hikari3.h" +#include "../battle/battle.h" + +void Hikari3Start(s32 targetMask, s32 callbackArg); +extern s16 D_801D0AA8[]; +extern s16 D_800F5B74; +extern u8 D_800F5B70; +extern u8 D_800F5B71; +extern u8 D_800F5B72; +void Hikari3ViewportFlashTick(void); +void Hikari3TargetTick(void); +void Hikari3DoubleBufferFlip(void); +void Hikari3TargetSetup(s32 target, s32 callbackArg); + +// Primitive buffer pages, one 0xC000 page per double-buffered frame. +extern u8 D_801B8AA4[2][0xC000]; +extern void* D_801D0AA4; +extern void* D_80163C74; +extern s16 D_801B8A88; +extern s16 D_801B8A8A; +extern SpriteRenderDesc D_801B8A8C; +extern SpriteRenderDesc D_801B8A98; +extern s32 D_801B48EC; +extern s32 D_801B89C4; +extern u_long D_801B08A8[]; +extern u_long D_801B4980[]; + +// Only StartFrame/AnimationFrame are common to every magic overlay. +typedef struct { + /* 0x00 */ s16 StartFrame; + /* 0x02 */ s16 AnimationFrame; + /* 0x04 */ SVECTOR Pos; + /* 0x0C */ SVECTOR unkC; + /* 0x14 */ char pad14[6]; + /* 0x1A */ s16 unk1A; + /* 0x1C */ char pad1C[4]; +} Hikari3Data; // size:0x20 + +extern Hikari3Data g_BattleEffectSlots[]; + +void MAGIC_Hikari3(s32 targetMask, s32 callbackArg) { Hikari3Start(targetMask, callbackArg); } + +// Same as BioraDoubleBufferFlip. +void Hikari3DoubleBufferFlip(void) { + Hikari3Data* effect; + + effect = &g_BattleEffectSlots[g_BattleEffectCursor]; + D_801D0AA4 = D_801B8AA4[effect->AnimationFrame]; + effect->AnimationFrame ^= 1; + if (g_BattleEffectCount < 2) { + effect->StartFrame = -1; + } +} + +void Hikari3ViewportFlashTick(void) { + Hikari3Data* effect; + + effect = &g_BattleEffectSlots[g_BattleEffectCursor]; + D_80163C74 = func_800C4FC8(D_801B8A88, 0, 0); + if (!D_80062D98) { + D_801B8A88 += D_801B8A8A; + if (!D_801B8A88) { + effect->StartFrame = -1; + } + } +} + +void Hikari3FlashFadeInSetup(s16 frames) { + D_801B8A88 = 0; + D_801B8A8A = 0xFF / frames; + BattleEffectRegister(Hikari3ViewportFlashTick); +} + +void Hikari3FlashFadeOutSetup(s16 frames) { + D_801B8A88 = 0xFF; + D_801B8A8A = -(0xFF / frames); +} + +void Hikari3SparkSpriteTick(void) { + Hikari3Data* effect; + + effect = &g_BattleEffectSlots[g_BattleEffectCursor]; + BattleSetBillboardMatrix(&effect->Pos, 0x1800, 0); + D_801B8A8C.frameIndex = effect->AnimationFrame; + D_801D0AA4 = func_800D4D90(&D_801B8A8C, g_cDb->unk70, 12, D_801D0AA4); + if (!D_80062D98) { + effect->AnimationFrame++; + if (effect->AnimationFrame == D_801B48EC) { + effect->StartFrame = -1; + } + } +} + +void Hikari3HitSpriteTick(void) { + Hikari3Data* effect; + + effect = &g_BattleEffectSlots[g_BattleEffectCursor]; + BattleSetBillboardMatrix(&effect->Pos, 0x1800, 0); + D_801B8A98.frameIndex = effect->AnimationFrame; + D_801D0AA4 = func_800D4D90(&D_801B8A98, g_cDb->unk70, 12, D_801D0AA4); + if (!D_80062D98) { + effect->AnimationFrame++; + if (effect->AnimationFrame >= D_801B89C4) { + effect->StartFrame = -1; + } + } +} + +void Hikari3TargetTick(void) { + Hikari3Data* effect; + Hikari3Data* child; + SVECTOR vec; + MATRIX matrix; + s32 flag; + s16 i; + + effect = &g_BattleEffectSlots[g_BattleEffectCursor]; + if (!D_80062D98) { + if (!effect->AnimationFrame) { + child = &g_BattleEffectSlots[BattleEffectRegister(Hikari3SparkSpriteTick)]; + child->unkC.vx = 0; + child->unkC.vy = ratan2(effect->unkC.vx - effect->Pos.vx, effect->unkC.vz - effect->Pos.vz); + vec.vx = vec.vy = 0; + vec.vz = 100; + RotMatrixYXZ(&child->unkC, &matrix); + matrix.t[0] = matrix.t[1] = matrix.t[2] = 0; + SetRotMatrix(&matrix); + SetTransMatrix(&matrix); + RotTransSV(&vec, &vec, &flag); + child->Pos.vx = effect->Pos.vx + vec.vx; + child->Pos.vy = effect->Pos.vy + vec.vy; + child->Pos.vz = effect->Pos.vz + vec.vz; + } + if (effect->AnimationFrame == 2) { + D_800F5B70 = D_800F5B71 = D_800F5B72 = 0; + D_800F5B74 = 0x1000; + for (i = 0; i < 10; i++) { + D_801D0AA8[i] = g_BattleModels[i].specialFlags; + g_BattleModels[i].specialFlags |= 2; + } + } + if (effect->AnimationFrame == 4) { + D_800F5B74 = 0; + Hikari3FlashFadeInSetup(15); + for (i = 0; i < 10; i++) { + g_BattleModels[i].specialFlags = D_801D0AA8[i]; + } + } + if (effect->AnimationFrame == 20) { + Hikari3FlashFadeOutSetup(15); + } + if (effect->AnimationFrame == 30) { + func_800D5774(effect->unk1A); + func_800BBA84(0x95, effect->unk1A, 0x40); + } + if (effect->AnimationFrame >= 31 && effect->AnimationFrame < 35) { + for (i = 0; i < 2; i++) { + child = &g_BattleEffectSlots[BattleEffectRegister(Hikari3HitSpriteTick)]; + BattleGetPartPosition(effect->unk1A, g_BattleModels[effect->unk1A].boneIndices[0], &child->Pos); + child->Pos.vx += rand() % 1000 - 500; + child->Pos.vy += rand() % 1000 - 500; + child->Pos.vz += rand() % 1000 - 500; + } + } + effect->AnimationFrame++; + if (effect->AnimationFrame == 40) { + effect->StartFrame = -1; + } + } +} + +void Hikari3TargetSetup(s32 target, s32 callbackArg) { + Hikari3Data* effect; + + effect = &g_BattleEffectSlots[BattleEffectRegister(Hikari3TargetTick)]; + BattleGetPartPosition(callbackArg, g_BattleModels[callbackArg].boneIndices[9], &effect->Pos); + effect->unk1A = target; +} + +void Hikari3Start(s32 targetMask, s32 callbackArg) { + BattleEffectRegister(Hikari3DoubleBufferFlip); + BattleSetLoadTimToVram(D_801B08A8, 0, 0, 0); + BattleSetLoadTimToVram(D_801B4980, 0, 0, 0); + MagicAnimationRegister(targetMask, callbackArg, 4, Hikari3TargetSetup); + func_800BBA84(0x6B, callbackArg, 0x40); +} diff --git a/src/magic/hikari3.h b/src/magic/hikari3.h new file mode 100644 index 00000000..4e240782 --- /dev/null +++ b/src/magic/hikari3.h @@ -0,0 +1,6 @@ +#ifndef HIKARI3_H +#define HIKARI3_H + +#include "magic.h" + +#endif diff --git a/tools/builder/builder/objdiff.go b/tools/builder/builder/objdiff.go index 8ae0e653..086e510c 100644 --- a/tools/builder/builder/objdiff.go +++ b/tools/builder/builder/objdiff.go @@ -114,6 +114,7 @@ var metaOverlays = map[string]metaOverlay{ "choco0": {"choco0", "magic", "choco0"}, "sennkoku": {"sennkoku", "magic", "Death Sentence / Roulette"}, "hikari2": {"hikari2", "magic", "HIKARI2"}, + "hikari3": {"hikari3", "magic", "HIKARI3"}, } func makeObjdiffConfig(b BuildConfig) objdiffConfig { From 9cc6b9b0cbd127e859a83c9fae34ec45a144db3b Mon Sep 17 00:00:00 2001 From: j3lee Date: Mon, 12 Oct 2026 13:09:10 +0930 Subject: [PATCH 3/4] magic: name the effects in the file headers --- src/magic/hikari2.c | 2 ++ src/magic/hikari3.c | 3 +++ 2 files changed, 5 insertions(+) diff --git a/src/magic/hikari2.c b/src/magic/hikari2.c index 71679084..8a1a5401 100644 --- a/src/magic/hikari2.c +++ b/src/magic/hikari2.c @@ -5,6 +5,8 @@ #include "hikari2.h" #include "../battle/battle.h" +// Effect shared by Blue Light (青い光), Smog Alert (超有害スモッグ) and Eyesight (眼力). + void Hikari2Start(s32 targetMask, s32 callbackArg); void Hikari2SparkSpriteTick(void); void Hikari2HitSpriteTick(void); diff --git a/src/magic/hikari3.c b/src/magic/hikari3.c index d6655613..540101a4 100644 --- a/src/magic/hikari3.c +++ b/src/magic/hikari3.c @@ -5,6 +5,9 @@ #include "hikari3.h" #include "../battle/battle.h" +// Effect shared by Red Light (赤い光), Petrif-Eye (石化にらみ), Heatwing (ヒートウィング) +// and Eyesight (眼力). + void Hikari3Start(s32 targetMask, s32 callbackArg); extern s16 D_801D0AA8[]; extern s16 D_800F5B74; From aef6bc655b4e2f0e649fc06c5698a44cc2d6ede0 Mon Sep 17 00:00:00 2001 From: j3lee Date: Mon, 12 Oct 2026 13:12:34 +0930 Subject: [PATCH 4/4] magic: point the "same as" comments at upstream functions Cites functions that exist on origin/main (or in this PR); comments that named draft-only functions are repointed or dropped. --- src/magic/hikari2.c | 2 +- src/magic/hikari3.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/magic/hikari2.c b/src/magic/hikari2.c index 8a1a5401..875006c3 100644 --- a/src/magic/hikari2.c +++ b/src/magic/hikari2.c @@ -50,7 +50,7 @@ extern Hikari2Data g_BattleEffectSlots[]; void MAGIC_Hikari2(s32 targetMask, s32 callbackArg) { Hikari2Start(targetMask, callbackArg); } -// Same as BioraDoubleBufferFlip. +// Same as BarrierDoubleBufferFlip. void Hikari2DoubleBufferFlip(void) { Hikari2Data* effect; diff --git a/src/magic/hikari3.c b/src/magic/hikari3.c index 540101a4..b08f29ca 100644 --- a/src/magic/hikari3.c +++ b/src/magic/hikari3.c @@ -47,7 +47,7 @@ extern Hikari3Data g_BattleEffectSlots[]; void MAGIC_Hikari3(s32 targetMask, s32 callbackArg) { Hikari3Start(targetMask, callbackArg); } -// Same as BioraDoubleBufferFlip. +// Same as BarrierDoubleBufferFlip. void Hikari3DoubleBufferFlip(void) { Hikari3Data* effect;