izzy/2ship2harkinian-Android
0
0
Fork 0
mirror of https://github.com/izzy2lost/2ship2harkinian-Android.git synced 2026-06-19 01:20:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

Match func_80116114

Browse Source
This commit is contained in:
engineer124
2021-12-28 23:33:39 +11:00
parent 1ddf4982ef
commit 1fb26cdffa
1 changed files with 98 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/code/z_parameter.c
+98 -42
View File
@@ -12,6 +12,56 @@ extern Gfx D_0E0002E0[]; // Display List
extern u8 D_801ABAB0[];
extern u8 D_801E3BB0[];
/**
* Steps `var` towards `target` linearly, so that it will arrive in `timeRemaining` seconds. Can be used from either
* direction. `timeRemaining` must be decremented separately for this to work properly, and obviously timeRemaining = 0
* must be handled separately.
*
* @param var Variable to step.
* @param target Target to step towards.
* @param timeRemaining Number of times this function should be run for `var` to reach `target`
* @param stepVar Variable to use for the step (required to match).
*
* The progression is not quite linear because of truncation in the division, but the variable will always reach
* `target` at the appropriate time since the last step is always the full difference.
*/
#define TIMED_STEP_TO(var, target, timeRemaining, stepVar) \
{ \
stepVar = ABS_ALT(var - target) / timeRemaining; \
if (var >= target) { \
var -= stepVar; \
} else { \
var += stepVar; \
} \
} \
(void)0
/**
* Similar to `TIMED_STEP_TO`, but will always increase `var`. If var > target, this will eventually increase `var` by
* an amount that is at most ( timeRemaining + 1 ) * | var - target |, but which depends on the amount lost to
* truncation from the divisions.
*/
#define TIMED_STEP_UP_TO(var, target, timeRemaining, stepVar) \
{ \
stepVar = ABS_ALT(var - target) / timeRemaining; \
var += stepVar; \
} \
(void)0
/**
* Similar to `TIMED_STEP_TO`, but will always increase `var`. If var < target, this will eventually dncrease `var` by
* an amount that is at most ( timeRemaining + 1 ) * | var - target |, but which depends on the amount lost to
* truncation from the divisions.
*/
#define TIMED_STEP_DOWN_TO(var, target, timeRemaining, stepVar) \
{ \
stepVar = ABS_ALT(var - target) / timeRemaining; \
var -= stepVar; \
} \
(void)0
typedef struct {
/* 0x00 */ u8 scene;
/* 0x01 */ u8 flags1;
@@ -2194,12 +2244,54 @@ void func_80116088(void) {
}
}
s16 D_801BFAB8[] = {
255, 255, 255, 150, 150, 150,
};
s16 D_801BFAC4[] = { 0, 1, 1, 0 };
s16 D_801BFACC[] = { 2, 1, 2, 1 };
#pragma GLOBAL_ASM("asm/non_matchings/code/z_parameter/func_80116114.s")
void func_80116114(void) {
static s16 magicBorderColors[][3] = {
{ 255, 255, 255 },
{ 150, 150, 150 },
};
static s16 magicBorderIndices[] = { 0, 1, 1, 0 };
static s16 magicBorderColorTimerIndex[] = { 2, 1, 2, 1 };
s16 colorStep1;
s16 colorStep2;
s16 colorStep3;
s16 index;
index = magicBorderIndices[D_801BF8B0];
colorStep1 = ABS_ALT(sMagicBarOutlinePrimRed - magicBorderColors[index][0]) / D_801BF8AC;
colorStep2 = ABS_ALT(sMagicBarOutlinePrimGreen - magicBorderColors[index][1]) / D_801BF8AC;
colorStep3 = ABS_ALT(sMagicBarOutlinePrimBlue - magicBorderColors[index][2]) / D_801BF8AC;
if (sMagicBarOutlinePrimRed >= magicBorderColors[index][0]) {
sMagicBarOutlinePrimRed -= colorStep1;
} else {
sMagicBarOutlinePrimRed += colorStep1;
}
if (sMagicBarOutlinePrimGreen >= magicBorderColors[index][1]) {
sMagicBarOutlinePrimGreen -= colorStep2;
} else {
sMagicBarOutlinePrimGreen += colorStep2;
}
if (sMagicBarOutlinePrimBlue >= magicBorderColors[index][2]) {
sMagicBarOutlinePrimBlue -= colorStep3;
} else {
sMagicBarOutlinePrimBlue += colorStep3;
}
D_801BF8AC--;
if (D_801BF8AC == 0) {
sMagicBarOutlinePrimRed = magicBorderColors[index][0];
sMagicBarOutlinePrimGreen = magicBorderColors[index][1];
sMagicBarOutlinePrimBlue = magicBorderColors[index][2];
D_801BF8AC = magicBorderColorTimerIndex[D_801BF8B0];
D_801BF8B0++;
if (D_801BF8B0 >= 4) {
D_801BF8B0 = 0;
}
}
}
void Interface_UpdateMagicBar(GlobalContext* globalCtx);
#pragma GLOBAL_ASM("asm/non_matchings/code/z_parameter/Interface_UpdateMagicBar.s")
@@ -2343,42 +2435,6 @@ s16 D_801BFB24[] = { 0, 255, 100, 0 };
void func_80119030(GlobalContext* globalCtx);
#pragma GLOBAL_ASM("asm/non_matchings/code/z_parameter/func_80119030.s")
/**
* Steps `var` towards `target` linearly, so that it will arrive in `timeRemaining` seconds. Can be used from either
* direction. `timeRemaining` must be decremented separately for this to work properly, and obviously timeRemaining = 0
* must be handled separately.
*
* @param var Variable to step.
* @param target Target to step towards.
* @param timeRemaining Number of times this function should be run for `var` to reach `target`
* @param stepVar Variable to use for the step (required to match).
*
* The progression is not quite linear because of truncation in the division, but the variable will always reach
* `target` at the appropriate time since the last step is always the full difference.
*/
#define TIMED_STEP_TO(var, target, timeRemaining, stepVar) \
{ \
stepVar = ABS_ALT(var - target) / timeRemaining; \
if (var >= target) { \
var -= stepVar; \
} else { \
var += stepVar; \
} \
} \
(void)0
/**
* Similar to `TIMED_STEP_TO`, but will always increase `var`. If var > target, this will eventually increase `var` by
* an amount that is at most ( timeRemaining + 1 ) * | var - target |, but which depends on the amount lost to
* truncation from the divisions.
*/
#define TIMED_STEP_UP_TO(var, target, timeRemaining, stepVar) \
{ \
stepVar = ABS_ALT(var - target) / timeRemaining; \
var += stepVar; \
} \
(void)0
/**
* Draws either the analog three-day clock or the digital final-hours clock
*/