kobayashi90/marioparty4
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
marioparty4/src/game/board/ui.c
gamemasterplc f5ca9fba8e More name cleanups
2024-06-09 11:05:21 -05:00

1988 lines
58 KiB
C
Executable file
Raw Blame History

#include "game/board/ui.h"
#include "game/audio.h"
#include "game/chrman.h"
#include "game/data.h"
#include "game/gamework.h"
#include "game/gamework_data.h"
#include "game/hsfex.h"
#include "game/hsfman.h"
#include "game/object.h"
#include "game/pad.h"
#include "game/process.h"
#include "game/sprite.h"
#include "game/window.h"
#include "game/board/com.h"
#include "game/board/item.h"
#include "game/board/main.h"
#include "game/board/model.h"
#include "game/board/player.h"
#include "game/board/tutorial.h"
#include "ext_math.h"
typedef struct {
/* 0x00 */ struct {
u8 unk00_bit0 : 1;
u8 unk00_bit1 : 1;
u8 unk00_bit2 : 1;
u8 unk00_bit3 : 1;
u8 unk00_bit4 : 1;
u8 unk00_bit5 : 1;
u8 unk00_bit6 : 1;
};
/* 0x01 */ s8 unk01;
/* 0x02 */ s16 unk02;
/* 0x04 */ Vec unk04;
/* 0x10 */ Vec unk10;
} UnkUiStatusStruct; // Size 0x1C
typedef struct {
/* 0x00 */ s8 unk00[6];
/* 0x06 */ s16 unk06[6];
/* 0x12 */ s16 unk12[6];
/* 0x1E */ s16 unk1E[6];
/* 0x2A */ char unk2A[2];
/* 0x2C */ Vec unk2C[6];
/* 0x74 */ Vec unk74[6];
} UnkUiWindowStruct; // Size 0xBC
typedef struct {
struct {
u8 unk00_bit0 : 1;
u8 unk00_bit3 : 3;
u8 unk00_bit5 : 2;
u8 unk00_bit6 : 1;
u8 unk00_bit7 : 1;
};
s8 unk01;
s8 unk02;
u8 unk03;
s16 unk04;
s16 unk06;
} UnkUiWork01;
typedef struct {
struct {
u8 unk00_bit0 : 1;
u8 unk00_bit3 : 3;
u8 unk00_bit5 : 2;
};
s8 unk01;
char unk02[2];
float unk04;
} UnkUiWork02;
typedef struct {
struct {
u8 unk00_bit0 : 1;
u8 unk00_bit1 : 1;
};
s8 unk01;
s8 unk02;
s8 unk03;
Vec *unk04;
} UnkUiWork03;
typedef struct {
struct {
u8 unk00_bit0 : 1;
};
s8 unk01;
s8 unk02;
s8 unk03;
UnkUiWindowStruct *unk04;
} UnkUiWork04;
void BoardPlayerSparkSet(s32);
void BoardBowserSuitMotionCreate(void);
s16 BoardBowserSuitPlayerModelGet(void);
static void KillAllBoardStatus(void);
static void CreateBoardStatusSprite(s32 arg0, UnkUiStatusStruct *arg1);
static s32 UpdateBoardStatus(void);
static void BoardStatusProc(void);
static void MoveBoardStatus(s32 arg0);
static void UpdateStatusItem(UnkUiStatusStruct *arg0, s32 arg1, s32 arg2);
static void UpdatePicker(omObjData *arg0);
static void UpdatePickerInput(UnkUiWork01 *arg0, omObjData *arg1);
static void MovePicker(UnkUiWork01 *arg0, omObjData *arg1);
static void UpdateComPickerButton(UnkUiWork01 *arg0, omObjData *arg1, s32 *arg2);
static BOOL CheckPickerButton(UnkUiWork01 *arg0, omObjData *arg1, u32 arg2);
static void UpdateYourTurn(omObjData *arg0);
static void GrowYourTurn(UnkUiWork02 *arg0, omObjData *arg1);
static void WaitYourTurn(UnkUiWork02 *arg0, omObjData *arg1);
static void ShrinkYourTurn(UnkUiWork02 *arg0, omObjData *arg1);
static void ItemUseTeamProc(s32 arg0);
static void ItemUseProc(void);
static void FinishItemUse(s16 arg0, s32 arg1);
static void DestroyItemUse(void);
static void TeamItemPosSet(s32 arg0, s32 arg1, Vec *arg2);
static void ExecItemPick(void);
static void UpdateItemPick(omObjData *arg0);
static void MakeItemPickSpace(UnkUiWork03 *arg0);
static void SetItemUIStatus(s32 arg0);
static void ItemGetPos(s32 arg0, Vec *arg1);
static void UpdateItemPickGfx(omObjData *arg0);
static void UpdateItemPickup(omObjData *arg0);
static BOOL CheckItemWindow(void);
static void HideItemWindow(void);
static void CreateItemWindow(s32 arg0, s32 arg1);
static BOOL CheckItemWindowSlide(void);
static void KillItemWindow(void);
static void SetItemWindowCurr(s32 arg0);
static void UpdateItemWindow(omObjData *arg0);
static void CreatePickerWindow(UnkUiWork01 *arg0, s32 arg1);
static void KillPickerWindow(UnkUiWork01 *arg0);
static s16 itemMdlId[4][3];
static Vec pickerPos[4];
static Vec itemPosTemp[6];
static s8 itemTeam;
static s8 itemTeamF;
s8 boardItemUser;
static s8 pickerChoice;
static s8 pickerChoiceDefault;
static s32 pickerBackF;
s32 lbl_801D40D0;
static s16 yourTurnSpr;
static s8 itemPlayer;
static s8 itemUsed;
static s8 teamItemPlayer;
static s16 itemRandTbl[3];
static float itemPickupPos;
static omObjData *itemPickObj;
static Process *itemUseProc;
static omObjData *yourTurnObj;
static omObjData *pickerObj;
static omObjData *itemWindowObj;
static Process *statusProc;
static s16 itemPickupMdlId = -1;
static s16 yourTurnSprGrp = -1;
static UnkUiStatusStruct uiStatus[4] = { 0 };
static s32 statusSprTbl[11] = {
0x00070027,
0x00070026,
0x00070029,
0x00070028,
0x00070028,
0x00070028,
0x0007002D,
0x00070028,
0x00070028,
0x00070028,
0x0007002C
};
static s16 statusSprPrioTbl[12] = {
0x05F0, 0x05E6, 0x05DC, 0x05D2,
0x05DC, 0x05DC, 0x05DC, 0x05DC,
0x05DC, 0x05DC, 0x05DC, 0x05DC
};
static float statusHideOfsTbl[4] = {
-230.0f, 230.0f, -230.0f, 230.0f
};
static float statusPosTbl[4][2] = {
{ 114.0f, 84.0f },
{ 462.0f, 84.0f },
{ 114.0f, 396.0f },
{ 462.0f, 396.0f }
};
static u8 statusColTbl[4][4] = {
{ 0x80, 0x80, 0x80, 0x00 },
{ 0x1A, 0x84, 0xFF, 0x00 },
{ 0xFF, 0x1A, 0x2D, 0x00 },
{ 0x0A, 0xB4, 0x3C, 0x00 }
};
static float statusSprPosTbl[17][2] = {
{ 0.0f, 0.0f },
{ 0.0f, 0.0f },
{ -68.0f, 0.0f },
{ 80.0f, 14.0f },
{ 64.0f, 14.0f },
{ 48.0f, 14.0f },
{ 26.0f, 14.0f },
{ 80.0f, -12.0f },
{ 64.0f, -12.0f },
{ 48.0f, -12.0f },
{ 26.0f, -12.0f },
{ -16.0f, 0.0f },
{ -18.0f, 32.0f },
{ 24.0f, -34.0f },
{ 48.0f, -34.0f },
{ 72.0f, -34.0f },
{ -32.0f, -16.0f }
};
static float statusItemPosTbl[6][2] = {
{ -56.0f, 0.0f },
{ -58.0f, 32.0f },
{ -2.0f, 4.0f },
{ 34.0f, -8.0f },
{ 70.0f, 4.0f },
{ -56.0f, -16.0f }
};
static s32 itemMdlTbl[14] = {
0x00070083,
0x00070084,
0x00070085,
0x00070086,
0x00070087,
0x00070088,
0x00070089,
0x0007008A,
0x0007008B,
0x0007008C,
0x0007008D,
0x0007008E,
0x0007008F,
0x00070090
};
static Vec teamItemStatusPosTbl[2] = {
{ 190.0f, 116.0f, 0.0f },
{ 386.0f, 116.0f, 0.0f }
};
s32 BoardItemModelGet(s32 arg0) {
s32 sp8[14] = {
0x0007006D,
0x0007006E,
0x0007006F,
0x00070070,
0x00070071,
0x00070072,
0x00070073,
0x00070074,
0x00070076,
0x00070077,
0x00070078,
0x00070079,
0x0007007A,
0x0007007B
};
return sp8[arg0];
}
s32 BoardItemNameGet(s32 arg0) {
s32 sp8[15] = {
0x00120000,
0x00120001,
0x00120002,
0x00120003,
0x00120004,
0x00120005,
0x00120006,
0x00120007,
0x00120008,
0x00120009,
0x0012000A,
0x0012000B,
0x0012000C,
0x0012000D,
0x0012000E
};
return sp8[arg0];
}
BOOL BoardStatusStopCheck(s32 arg0) {
return (uiStatus[arg0].unk00_bit2) ? FALSE : TRUE;
}
s32 BoardStatusVisibleGet(s32 arg0) {
return uiStatus[arg0].unk00_bit1;
}
void BoardStatusShowSetAll(s32 arg0) {
s32 i;
for (i = 0; i < 4; i++) {
BoardStatusShowSet(i, arg0);
}
}
void BoardStatusItemSet(s32 arg0) {
UnkUiStatusStruct *temp_r31;
s32 i;
s32 j;
for (i = 0; i < 4; i++) {
temp_r31 = &uiStatus[i];
BoardStatusShowSet(i, arg0);
temp_r31->unk04.x = temp_r31->unk10.x;
temp_r31->unk04.y = temp_r31->unk10.y;
temp_r31->unk00_bit2 = 0;
HuSprGrpPosSet(temp_r31->unk02, temp_r31->unk04.x, temp_r31->unk04.y);
for (j = 0; j < 3; j++) {
if (itemMdlId[i][j] != -1) {
BoardModelVisibilitySet(itemMdlId[i][j], arg0);
}
}
}
}
void BoardStatusShowSetForce(s32 arg0) {
uiStatus[arg0].unk00_bit3 = 1;
}
void BoardStatusGraySet(s32 arg0, s32 arg1) {
UnkUiStatusStruct *temp_r31;
s16 sp10[9] = { 3, 4, 5, 7, 8, 9, 2, 6, 10 };
s16 var_r28;
u8 var_r29;
s32 i;
temp_r31 = &uiStatus[arg0];
if (arg1 != 0) {
var_r29 = 0xFF;
temp_r31->unk00_bit4 = 1;
var_r28 = 1500;
} else {
var_r29 = 0x3F;
temp_r31->unk00_bit4 = 0;
var_r28 = 1530;
}
for (i = 0; i < 9; i++) {
HuSprPriSet(temp_r31->unk02, sp10[i], var_r28);
HuSprColorSet(temp_r31->unk02, sp10[i], var_r29, var_r29, var_r29);
}
}
void BoardStatusShowSet(s32 arg0, s32 arg1) {
UnkUiStatusStruct *temp_r31 = &uiStatus[arg0];
if (temp_r31->unk00_bit3) {
arg0 = 0;
}
if (arg1 == 0) {
if (temp_r31->unk00_bit1) {
temp_r31->unk00_bit1 = 0;
temp_r31->unk10.x = statusPosTbl[arg0][0] + statusHideOfsTbl[arg0];
temp_r31->unk10.y = statusPosTbl[arg0][1];
temp_r31->unk00_bit3 = 0;
}
} else {
if (!temp_r31->unk00_bit1) {
temp_r31->unk00_bit1 = 1;
temp_r31->unk10.x = statusPosTbl[arg0][0];
temp_r31->unk10.y = statusPosTbl[arg0][1];
temp_r31->unk04.x = statusPosTbl[arg0][0] + statusHideOfsTbl[arg0];
temp_r31->unk04.y = statusPosTbl[arg0][1];
}
}
}
void BoardStatusItemHideSet(s32 arg0, s32 arg1) {
UnkUiStatusStruct *temp_r31 = &uiStatus[arg0];
if (arg1 != 0) {
temp_r31->unk00_bit5 = 1;
} else {
temp_r31->unk00_bit5 = 0;
}
}
void BoardStatusTargetPosSet(s32 arg0, Vec *arg1) {
UnkUiStatusStruct *temp_r31 = &uiStatus[arg0];
temp_r31->unk10.x = arg1->x;
temp_r31->unk10.y = arg1->y;
temp_r31->unk00_bit2 = 1;
}
void BoardStatusPosGet(s32 arg0, Vec *arg1) {
UnkUiStatusStruct *temp_r31 = &uiStatus[arg0];
arg1->x = temp_r31->unk04.x;
arg1->y = temp_r31->unk04.y;
}
void BoardStatusPosSet(s32 arg0, Vec *arg1) {
UnkUiStatusStruct *temp_r30 = &uiStatus[arg0];
temp_r30->unk04.x = arg1->x;
temp_r30->unk04.y = arg1->y;
BoardStatusTargetPosSet(arg0, arg1);
}
void BoardStatusHammerCreate(s32 arg0) {
UnkUiStatusStruct *temp_r31 = &uiStatus[arg0];
float spC[2];
s32 var_r30;
s32 temp_r29;
s16 sp8;
temp_r29 = BoardPlayerAutoSizeGet(arg0);
switch (temp_r29) {
case 0:
return;
case 2:
var_r30 = 0x70093;
break;
case 1:
var_r30 = 0x70092;
break;
}
if (!temp_r31->unk00_bit6) {
BoardSpriteCreate(var_r30, 0x5DC, NULL, &sp8);
spC[0] = statusSprPosTbl[16][0];
spC[1] = statusSprPosTbl[16][1];
HuSprGrpMemberSet(temp_r31->unk02, 0x10, sp8);
HuSprPosSet(temp_r31->unk02, 0x10, spC[0], spC[1]);
HuSprScaleSet(temp_r31->unk02, 0x10, 2.0f, 2.0f);
HuSprAttrSet(temp_r31->unk02, 0x10, 2);
HuSprAttrSet(temp_r31->unk02, 0x10, 8);
HuSprDrawNoSet(temp_r31->unk02, 0x10, 0x40);
temp_r31->unk00_bit6 = 1;
}
}
void BoardStatusHammerShowSet(s32 arg0, s32 arg1) {
UnkUiStatusStruct *temp_r31 = &uiStatus[arg0];
if (temp_r31->unk00_bit6) {
if (arg1 != 0) {
HuSprAttrSet(temp_r31->unk02, 0x10, 2);
} else {
HuSprAttrReset(temp_r31->unk02, 0x10, 2);
HuSprAttrSet(temp_r31->unk02, 0x10, 1);
}
}
}
void BoardStatusHammerKill(s32 arg0) {
UnkUiStatusStruct *temp_r31 = &uiStatus[arg0];
if (temp_r31->unk00_bit6) {
HuSprGrpMemberKill(temp_r31->unk02, 0x10);
temp_r31->unk00_bit6 = 0;
}
}
void BoardStatusKill(void) {
UnkUiStatusStruct *temp_r31;
s32 i;
for (i = 0; i < 4; i++) {
temp_r31 = &uiStatus[i];
if (temp_r31->unk00_bit0) {
if (temp_r31->unk02 != -1) {
HuSprGrpKill(temp_r31->unk02);
temp_r31->unk02 = -1;
}
temp_r31->unk00_bit6 = 0;
}
}
}
void BoardStatusCreate(void) {
s32 i;
memset(uiStatus, 0, 0x70);
for (i = 0; i < 4; i++) {
CreateBoardStatusSprite(i, &uiStatus[i]);
uiStatus[i].unk00_bit0 = 1;
uiStatus[i].unk00_bit2 = 0;
uiStatus[i].unk00_bit3 = 0;
uiStatus[i].unk00_bit4 = 1;
uiStatus[i].unk00_bit5 = 1;
uiStatus[i].unk00_bit6 = 0;
uiStatus[i].unk01 = 9;
uiStatus[i].unk04.x = statusPosTbl[i][0] + statusHideOfsTbl[i];
uiStatus[i].unk04.y = statusPosTbl[i][1];
uiStatus[i].unk04.z = 0.0f;
uiStatus[i].unk10 = uiStatus[i].unk04;
HuSprGrpDrawNoSet(uiStatus[i].unk02, 0x40);
}
HuSprExecLayerSet(0x40, 5);
if (statusProc == 0) {
statusProc = HuPrcChildCreate(BoardStatusProc, 0x1FFF, 0x4000, 0, HuPrcCurrentGet());
HuPrcDestructorSet2(statusProc, KillAllBoardStatus);
}
}
static void KillAllBoardStatus(void) {
BoardStatusKill();
statusProc = NULL;
}
static void CreateBoardStatusSprite(s32 arg0, UnkUiStatusStruct *arg1) {
float var_f31;
float var_f30;
s16 sp8;
s32 temp_r28;
s32 temp_r27;
s16 temp_r26;
s32 spC[] = {
0x0007002E,
0x0007002F,
0x00070030,
0x00070031,
0x00070032,
0x00070033,
0x00070034,
0x00070035
};
s32 i;
temp_r28 = GWPlayerCfg[arg0].character;
arg1->unk02 = HuSprGrpCreate(0x11);
for (i = 0; i < 11; i++) {
temp_r27 = statusSprTbl[i];
temp_r26 = statusSprPrioTbl[i];
BoardSpriteCreate(temp_r27, temp_r26, NULL, &sp8);
HuSprGrpMemberSet(arg1->unk02, i, sp8);
HuSprAttrSet(arg1->unk02, i, 1);
HuSprAttrSet(arg1->unk02, i, 8);
HuSprPosSet(arg1->unk02, i, statusSprPosTbl[i][0], statusSprPosTbl[i][1]);
}
if ((s32) GWSystem.team != 0) {
if (GWPlayerTeamGet(arg0) == 0) {
HuSprBankSet(arg1->unk02, 1, 2);
} else {
HuSprBankSet(arg1->unk02, 1, 1);
}
}
BoardSpriteCreate(spC[temp_r28], 0x5DC, NULL, &sp8);
HuSprGrpMemberSet(arg1->unk02, 0xB, sp8);
HuSprAttrSet(arg1->unk02, 0xB, 8);
var_f31 = statusSprPosTbl[11][0];
var_f30 = statusSprPosTbl[11][1];
HuSprPosSet(arg1->unk02, 11, var_f31, var_f30);
BoardSpriteCreate(0x7002A, 0x5DC, NULL, &sp8);
HuSprGrpMemberSet(arg1->unk02, 0xC, sp8);
var_f31 = statusSprPosTbl[12][0];
var_f30 = statusSprPosTbl[12][1];
HuSprPosSet(arg1->unk02, 12, var_f31, var_f30);
HuSprAttrSet(arg1->unk02, 0xC, 8);
for (i = 0; i < 3; i++) {
BoardSpriteCreate(0x70091, 0x5DC, NULL, &sp8);
HuSprGrpMemberSet(arg1->unk02, i + 0xD, sp8);
HuSprAttrSet(arg1->unk02, i + 0xD, 1);
HuSprAttrSet(arg1->unk02, i + 0xD, 8);
}
arg1->unk00_bit6 = 0;
HuSprTPLvlSet(arg1->unk02, 0, 0.7f);
if (GWBoardGet() == 7 || GWBoardGet() == 8) {
HuSprAttrSet(arg1->unk02, 7, 4);
HuSprAttrSet(arg1->unk02, 8, 4);
HuSprAttrSet(arg1->unk02, 9, 4);
HuSprAttrSet(arg1->unk02, 0xA, 4);
}
}
void BoardSpriteCreate(s32 file, s32 prio, AnimData **anim, s16 *sprite) {
s16 temp_r28;
void *temp_r27;
AnimData *temp_r31;
temp_r27 = HuDataSelHeapReadNum(file, MEMORY_DEFAULT_NUM, HEAP_DATA);
temp_r31 = HuSprAnimRead(temp_r27);
temp_r28 = HuSprCreate(temp_r31, prio, 0);
if (anim) {
*anim = temp_r31;
}
if (sprite) {
*sprite = temp_r28;
}
}
static s32 UpdateBoardStatus(void) {
UnkUiStatusStruct *temp_r31;
u8 *temp_r28;
s32 temp_r27;
s32 i;
s32 j;
for (i = 0; i < 4; i++) {
temp_r31 = &uiStatus[i];
if (temp_r31->unk02 == -1) {
return -1;
}
GWPlayer[i].rank = BoardPlayerRankCalc(i);
HuSprBankSet(temp_r31->unk02, 2, GWPlayer[i].rank);
BoardSpriteDigitUpdate(temp_r31->unk02, 3, BoardPlayerCoinsGet(i));
BoardSpriteDigitUpdate(temp_r31->unk02, 7, GWStarsGet(i));
for (j = 0; j < 3; j++) {
temp_r27 = GWPlayer[i].items[j];
if (temp_r27 != -1 && temp_r31->unk00_bit5) {
UpdateStatusItem(temp_r31, j, temp_r27);
HuSprAttrReset(temp_r31->unk02, j + 0xD, 4);
} else {
HuSprAttrSet(temp_r31->unk02, j + 0xD, 4);
}
}
if (GWPlayer[i].com) {
HuSprAttrReset(temp_r31->unk02, 0xC, 4);
} else {
HuSprAttrSet(temp_r31->unk02, 0xC, 4);
}
temp_r28 = statusColTbl[GWPlayer[i].color];
HuSprColorSet(temp_r31->unk02, 0, temp_r28[0], temp_r28[1], temp_r28[2]);
MoveBoardStatus(i);
HuSprGrpPosSet(temp_r31->unk02, temp_r31->unk04.x, temp_r31->unk04.y);
}
return 0;
}
static void BoardStatusProc(void) {
while (1) {
if (omSysExitReq != 0 || UpdateBoardStatus() != 0) {
break;
}
HuPrcVSleep();
}
HuPrcEnd();
}
static void MoveBoardStatus(s32 arg0) {
UnkUiStatusStruct *temp_r30 = &uiStatus[arg0];
float var_f30;
Vec spC;
PSVECSubtract(&temp_r30->unk10, &temp_r30->unk04, &spC);
if (ABS(spC.x) < 1.0f && ABS(spC.y) < 1.0f) {
spC = temp_r30->unk10;
temp_r30->unk00_bit2 = 0;
} else {
OSs8tof32(&temp_r30->unk01, &var_f30);
var_f30 /= 32;
PSVECScale(&spC, &spC, var_f30);
PSVECAdd(&temp_r30->unk04, &spC, &spC);
temp_r30->unk00_bit2 = 1;
}
temp_r30->unk04.x = spC.x;
temp_r30->unk04.y = spC.y;
}
void BoardSpriteDigitUpdate(s16 arg0, s16 arg1, s32 arg2) {
s32 temp_r29;
s32 temp_r28;
s32 temp_r27;
temp_r29 = arg2 / 100;
temp_r28 = (arg2 - temp_r29 * 100) / 10;
temp_r27 = (arg2 - (temp_r29 * 100 + temp_r28 * 10)) % 10;
if (temp_r29 == 0) {
HuSprBankSet(arg0, arg1 + 2, 0xA);
} else {
HuSprBankSet(arg0, arg1 + 2, temp_r29);
}
if (temp_r28 == 0 && temp_r29 == 0) {
HuSprBankSet(arg0, arg1 + 1, temp_r27);
HuSprAttrSet(arg0, arg1, 4);
} else {
HuSprBankSet(arg0, arg1 + 1, temp_r28);
HuSprBankSet(arg0, arg1, temp_r27);
HuSprAttrReset(arg0, arg1, 4);
}
}
static void UpdateStatusItem(UnkUiStatusStruct *arg0, s32 arg1, s32 arg2) {
float temp_f31;
float temp_f30;
temp_f31 = statusSprPosTbl[arg1 + 0xD][0];
temp_f30 = statusSprPosTbl[arg1 + 0xD][1];
HuSprBankSet(arg0->unk02, arg1 + 0xD, arg2);
HuSprPosSet(arg0->unk02, arg1 + 0xD, temp_f31, temp_f30);
}
void BoardPickerCreate(s32 arg0, s8 arg1, void *arg2, s8 arg3) {
UnkUiWork01 *temp_r31;
omObjData *temp_r30;
s32 temp_r28;
s16 sp12;
s32 sp14[] = {
0x0007001E,
0x0007001F,
0x00070020,
0x00070021,
0x00070022,
0x00070023,
0x00070024,
0x00070025
};
temp_r28 = GWPlayer[arg0].character;
temp_r30 = omAddObjEx(boardObjMan, 0x107, 0, 0, -1, &UpdatePicker);
pickerObj = temp_r30;
temp_r31 = OM_GET_WORK_PTR(temp_r30, UnkUiWork01);
temp_r31->unk00_bit0 = 0;
temp_r31->unk00_bit6 = 0;
temp_r31->unk00_bit5 = arg0;
temp_r31->unk01 = arg3;
temp_r31->unk00_bit7 = 0;
temp_r31->unk02 = 0;
temp_r31->unk00_bit3 = 0;
temp_r31->unk03 = 0xA;
pickerBackF = 0;
pickerChoiceDefault = arg1;
memset(&pickerPos, 0, sizeof(pickerPos));
memcpy(&pickerPos, arg2, pickerChoiceDefault * sizeof(Vec));
temp_r31->unk04 = HuSprGrpCreate(1);
pickerChoice = -1;
temp_r30->trans.x = temp_r30->rot.x = pickerPos[temp_r31->unk02].x;
temp_r30->trans.y = temp_r30->rot.y = pickerPos[temp_r31->unk02].y;
temp_r30->trans.z = temp_r30->rot.z = 0.0f;
BoardSpriteCreate(sp14[temp_r28], 90, NULL, &sp12);
HuSprGrpMemberSet(temp_r31->unk04, 0, sp12);
HuSprPosSet(temp_r31->unk04, 0, temp_r30->trans.x, temp_r30->trans.y);
HuSprBankSet(temp_r31->unk04, 0, 0);
HuSprAttrSet(temp_r31->unk04, 0, 1);
HuSprAttrSet(temp_r31->unk04, 0, 2);
HuSprAttrSet(temp_r31->unk04, 0, 8);
CreatePickerWindow(temp_r31, 1);
}
void BoardPickerBackFlagSet(s32 arg0) {
if (pickerObj) {
if (arg0 != 0) {
pickerBackF = 0;
} else {
pickerBackF = 1;
}
if (arg0 == 0) {
KillPickerWindow(OM_GET_WORK_PTR(pickerObj, UnkUiWork01));
CreatePickerWindow(OM_GET_WORK_PTR(pickerObj, UnkUiWork01), 0);
}
}
}
BOOL BoardPickerDoneCheck(void) {
if (pickerObj) {
return FALSE;
} else {
return TRUE;
}
}
s32 BoardPickerPosGet(Vec *arg0) {
if (pickerObj == 0 || arg0 == 0) {
return -1;
}
arg0->x = pickerObj->trans.x;
arg0->y = pickerObj->trans.y;
arg0->z = pickerObj->trans.z;
return 0;
}
s32 BoardPickerChoiceGet(void) {
return pickerChoice;
}
static void UpdatePicker(omObjData *arg0) {
UnkUiWork01 *temp_r31 = OM_GET_WORK_PTR(arg0, UnkUiWork01);
if (temp_r31->unk00_bit0 || BoardIsKill()) {
HuWinKill(temp_r31->unk06);
HuSprGrpKill(temp_r31->unk04);
pickerObj = NULL;
omDelObjEx(HuPrcCurrentGet(), arg0);
} else {
if (temp_r31->unk03 != 0) {
temp_r31->unk03--;
} else if (pickerChoice != -1 || temp_r31->unk00_bit7) {
temp_r31->unk00_bit0 = 1;
} else {
UpdatePickerInput(temp_r31, arg0);
}
MovePicker(temp_r31, arg0);
HuSprPosSet(temp_r31->unk04, 0, arg0->trans.x, arg0->trans.y);
}
}
static void UpdatePickerInput(UnkUiWork01 *arg0, omObjData *arg1) {
s32 sp8;
s32 temp_r29;
if (!arg0->unk00_bit6) {
sp8 = 0;
if (GWPlayer[arg0->unk00_bit5].com && arg0->unk01 != -1) {
UpdateComPickerButton(arg0, arg1, &sp8);
} else {
temp_r29 = GWPlayer[arg0->unk00_bit5].port;
sp8 = HuPadDStkRep[temp_r29] | HuPadBtnDown[temp_r29];
}
if (CheckPickerButton(arg0, arg1, sp8) != 0) {
arg1->rot.x = pickerPos[arg0->unk02].x;
arg1->rot.y = pickerPos[arg0->unk02].y;
arg1->rot.z = pickerPos[arg0->unk02].z;
}
}
}
static void MovePicker(UnkUiWork01 *arg0, omObjData *arg1) {
float temp_f31 = 0.5f;
Vec sp14;
Vec sp8;
sp8.x = arg1->rot.x;
sp8.y = arg1->rot.y;
sp8.z = arg1->rot.z;
sp14.x = arg1->trans.x;
sp14.y = arg1->trans.y;
sp14.z = arg1->trans.z;
PSVECSubtract(&sp8, &sp14, &sp8);
if (PSVECMag(&sp8) < 1.0f) {
arg1->trans.x = arg1->rot.x;
arg1->trans.y = arg1->rot.y;
arg1->trans.z = arg1->rot.z;
arg0->unk00_bit6 = 0;
} else {
PSVECScale(&sp8, &sp8, temp_f31);
PSVECAdd(&sp14, &sp8, &sp8);
arg1->trans.x = sp8.x;
arg1->trans.y = sp8.y;
arg1->trans.z = sp8.z;
arg0->unk00_bit6 = 1;
}
}
static void UpdateComPickerButton(UnkUiWork01 *arg0, omObjData *arg1, s32 *arg2) {
if (arg0->unk02 == arg0->unk01) {
*arg2 = 0x100;
} else {
*arg2 = 2;
}
}
static BOOL CheckPickerButton(UnkUiWork01 *arg0, omObjData *arg1, u32 arg2) {
BOOL var_r30 = FALSE;
if (arg2 == 0x100) {
pickerChoice = arg0->unk02;
HuAudFXPlay(2);
var_r30 = TRUE;
} else if (arg2 == 0x200 && pickerBackF == 0) {
arg0->unk00_bit0 = 1;
arg0->unk00_bit7 = 1;
pickerChoice = -1;
HuAudFXPlay(3);
var_r30 = TRUE;
} else if (arg2 & 1) {
var_r30 = TRUE;
if (pickerChoiceDefault > 1) {
HuAudFXPlay(0);
}
arg0->unk02--;
} else if (arg2 & 2) {
var_r30 = TRUE;
if (pickerChoiceDefault > 1) {
HuAudFXPlay(0);
}
arg0->unk02++;
}
if (arg0->unk02 < 0) {
arg0->unk02 = pickerChoiceDefault - 1;
}
if (arg0->unk02 >= pickerChoiceDefault) {
arg0->unk02 = 0;
}
if (GWPlayer[arg0->unk00_bit5].com && var_r30 != 0) {
arg0->unk03 = GWMessDelayGet();
}
return var_r30;
}
void BoardYourTurnExec(s32 arg0) {
s32 temp_r29;
UnkUiWork02 *temp_r31;
s32 sp8[] = {
0x00070043,
0x00070044,
0x00070045,
0x00070046,
0x00070047,
0x00070048,
0x00070049,
0x0007004A
};
temp_r29 = GWPlayer[arg0].character;
yourTurnObj = omAddObjEx(boardObjMan, 0x10B, 0, 0, -1, &UpdateYourTurn);
temp_r31 = OM_GET_WORK_PTR(yourTurnObj, UnkUiWork02);
temp_r31->unk00_bit0 = 0;
temp_r31->unk00_bit5 = arg0;
temp_r31->unk00_bit3 = 0;
temp_r31->unk01 = 0;
yourTurnSprGrp = HuSprGrpCreate(3);
BoardSpriteCreate(sp8[temp_r29], 0x5DC, NULL, &yourTurnSpr);
HuSprGrpMemberSet(yourTurnSprGrp, 0, yourTurnSpr);
HuSprPosSet(yourTurnSprGrp, 0, 0.0f, 0.0f);
HuSprAttrSet(yourTurnSprGrp, 0, 1);
HuSprScaleSet(yourTurnSprGrp, 0, 0.001f, 0.001f);
HuSprAttrSet(yourTurnSprGrp, 0, 8);
HuSprGrpPosSet(yourTurnSprGrp, 288.0f, 240.0f);
HuAudFXPlay(0x307);
while (yourTurnObj) {
HuPrcVSleep();
}
}
static void UpdateYourTurn(omObjData *arg0) {
UnkUiWork02 *temp_r31 = OM_GET_WORK_PTR(arg0, UnkUiWork02);
if (temp_r31->unk00_bit0 || BoardIsKill()) {
HuSprGrpKill(yourTurnSprGrp);
yourTurnSprGrp = -1;
yourTurnObj = NULL;
omDelObjEx(HuPrcCurrentGet(), arg0);
} else {
switch (temp_r31->unk00_bit3) {
case 0:
GrowYourTurn(temp_r31, arg0);
break;
case 2:
WaitYourTurn(temp_r31, arg0);
break;
case 1:
ShrinkYourTurn(temp_r31, arg0);
break;
}
}
}
static void GrowYourTurn(UnkUiWork02 *arg0, omObjData *arg1) {
float temp_f30;
arg0->unk01 += 7;
if (arg0->unk01 > 90) {
arg0->unk01 = 90;
arg0->unk00_bit3 = 1;
}
OSs8tof32(&arg0->unk01, &temp_f30);
temp_f30 = 1.3f * sind(temp_f30);
HuSprScaleSet(yourTurnSprGrp, 0, temp_f30, temp_f30);
}
static void WaitYourTurn(UnkUiWork02 *arg0, omObjData *arg1) {
float temp_f30;
arg0->unk01 += 7;
if (arg0->unk01 > 90) {
arg0->unk01 = 90;
arg0->unk00_bit0 = 1;
}
OSs8tof32(&arg0->unk01, &temp_f30);
temp_f30 = sind(temp_f30);
HuSprScaleSet(yourTurnSprGrp, 0, 1.3f + temp_f30, 1.3f + temp_f30);
HuSprTPLvlSet(yourTurnSprGrp, 0, 1.0f - temp_f30);
}
static void ShrinkYourTurn(UnkUiWork02 *arg0, omObjData *arg1) {
s32 temp_r30 = GWPlayer[arg0->unk00_bit5].port;
if ((HuPadBtnDown[temp_r30] & 0x100) || GWPlayer[arg0->unk00_bit5].com || _CheckFlag(0x1000B)) {
arg0->unk00_bit3 = 2;
arg0->unk01 = 0;
arg0->unk04 = 1.0f;
}
}
s32 BoardItemUseExec(s32 arg0) {
BoardPauseDisableSet(1);
itemPlayer = arg0;
itemUseProc = HuPrcChildCreate(ItemUseProc, 0x2004, 0x4000, 0, boardMainProc);
HuPrcDestructorSet2(itemUseProc, DestroyItemUse);
while (itemUseProc) {
HuPrcVSleep();
}
return itemUsed;
}
static void ItemUseTeamProc(s32 arg0) {
UnkUiStatusStruct *temp_r22;
Vec sp40;
Vec sp34;
s32 sp2C[2];
s32 i;
s32 j;
if (GWTeamGet()) {
if (arg0 != 0) {
teamItemPlayer = BoardPlayerSameTeamFind(itemPlayer);
if (itemTeamF != 0) {
BoardStatusTargetPosSet(itemPlayer, &teamItemStatusPosTbl[0]);
BoardStatusTargetPosSet(teamItemPlayer, &teamItemStatusPosTbl[1]);
} else {
BoardStatusTargetPosSet(itemPlayer, (Vec*) statusPosTbl[0]);
BoardStatusTargetPosSet(teamItemPlayer, (Vec*) statusPosTbl[1]);
}
sp2C[0] = BoardPlayerTeamFind(itemPlayer);
sp2C[1] = BoardPlayerSameTeamFind(sp2C[0]);
for (i = 0; i < 2; i++) {
sp40.x = statusPosTbl[sp2C[i]][0] + statusHideOfsTbl[sp2C[i]];
sp40.y = statusPosTbl[sp2C[i]][1];
BoardStatusTargetPosSet(sp2C[i], &sp40);
}
while (!BoardStatusStopCheck(itemPlayer) || !BoardStatusStopCheck(teamItemPlayer)) {
HuPrcVSleep();
}
} else {
for (i = 0; i < 4; i++) {
sp40.x = statusPosTbl[i][0];
sp40.y = statusPosTbl[i][1];
BoardStatusTargetPosSet(i, &sp40);
}
while (!BoardStatusStopCheck(0)
|| !BoardStatusStopCheck(1)
|| !BoardStatusStopCheck(2)
|| !BoardStatusStopCheck(3)) {
sp34.z = 0.0f;
for (i = 0; i < 4; i++) {
temp_r22 = &uiStatus[i];
sp40.x = temp_r22->unk04.x;
sp40.y = temp_r22->unk04.y;
for (j = 0; j < BoardPlayerItemCount(i); j++) {
sp34.x = sp40.x + statusItemPosTbl[j + 2][0];
sp34.y = sp40.y + statusItemPosTbl[j + 2][1];
TeamItemPosSet(i, j, &sp34);
}
}
HuPrcVSleep();
}
}
}
}
static void ItemUseProc(void) {
s32 var_r24;
s16 temp_r23;
s32 var_r25;
s32 var_r27;
s32 i;
var_r27 = -1;
itemTeam = GWPlayerTeamGet(itemPlayer);
if (GWTeamGet()) {
itemTeamF = 1;
} else {
itemTeamF = 0;
}
for (i = 0; i < 4; i++) {
GWPlayer[i].show_next = 0;
}
for (var_r25 = i = 0; i < 3; i++) {
if (GWPlayer[itemPlayer].items[i] == 8) {
var_r25++;
}
}
temp_r23 = GWPlayer[itemPlayer].space_curr;
ItemUseTeamProc(1);
BoardFilterFadeInit(0x1E, 0xA0);
ExecItemPick();
ItemUseTeamProc(0);
itemTeamF = 0;
BoardFilterFadeOut(0x1E);
if (itemUsed == 0xA) {
var_r27 = 0x40000;
}
if (itemUsed == 0xB) {
var_r27 = 0x90000;
}
if (var_r27 != -1) {
var_r24 = BoardDataDirReadAsync(var_r27);
BoardDataAsyncWait(var_r24);
}
HideItemWindow();
BoardItemPrevSet(itemUsed);
if (itemUsed != -1) {
switch (itemUsed) {
case 13:
BoardMakeRandomItem();
break;
case 11:
SetItemUIStatus(3);
break;
case 12:
SetItemUIStatus(3);
HuPrcSleep(0xA);
BoardStatusShowSetAll(0);
_SetFlag(0x1001C);
_SetFlag(0x1000E);
break;
}
BoardItemStart(itemPlayer, itemUsed);
while (BoardItemDoneCheck() == 0) {
HuPrcVSleep();
}
if (_CheckFlag(0x1000B) != 0) {
BoardTutorialHookExec(0x17, 0);
}
FinishItemUse(temp_r23, var_r25);
}
if (itemUsed != 0xB && itemUsed != 0xC) {
SetItemUIStatus(3);
}
while (itemPickObj) {
HuPrcVSleep();
}
while (!BoardFilterFadePauseCheck()) {
HuPrcVSleep();
}
HuPrcEnd();
}
static void FinishItemUse(s16 arg0, s32 arg1) {
s32 var_r30;
s32 var_r31;
s16 temp_r29;
switch (itemUsed) {
case 12:
temp_r29 = BoardModelIDGet(BoardPlayerModelGet(itemPlayer));
Hu3DModelShadowReset(temp_r29);
_ClearFlag(0x1001C);
_ClearFlag(0x1000E);
Hu3DShadowF = 0;
break;
case 10:
HuPrcSleep(2);
BoardBowserSuitMotionCreate();
BoardPlayerIdleSet(itemPlayer);
BoardModelLayerSet(BoardBowserSuitModelGet(), 0);
BoardModelLayerSet(BoardBowserSuitPlayerModelGet(), 0);
break;
case 7:
BoardPlayerSparkSet(itemPlayer);
break;
case 8:
for (var_r30 = var_r31 = 0; var_r31 < 3; var_r31++) {
if (GWPlayer[itemPlayer].items[var_r31] == 8) {
var_r30++;
}
}
if (var_r30 == arg1) {
itemUsed = -1;
}
break;
}
}
static void DestroyItemUse(void) {
s32 i;
CharModelLayerSetAll(1);
for (i = 0; i < 4; i++) {
GWPlayer[i].show_next = 1;
}
HuDataDirClose(0x40000);
HuDataDirClose(0x90000);
itemUseProc = NULL;
}
void BoardMakeRandomItem(void) {
s32 temp_r3;
s32 i;
for (i = 0; i < 3; i++) {
temp_r3 = BoardRandMod(0xE);
if (temp_r3 != 0xA && temp_r3 != 0xD) {
itemRandTbl[i] = temp_r3;
}
}
BoardItemBagItemSet(itemRandTbl);
}
static inline void TeamItemPosSetInlineFunc01(s32 arg0, s32 arg1, Vec *arg2) {
UnkUiWork03 *temp_r29 = OM_GET_WORK_PTR(itemPickObj, UnkUiWork03);
Vec (*temp_r31)[6] = (void*) temp_r29->unk04;
temp_r31[arg0][arg1 + 2].x = arg2->x;
temp_r31[arg0][arg1 + 2].y = arg2->y;
temp_r31[arg0][arg1 + 2].z = arg2->z;
}
static inline void TeamItemPosSetInlineFunc02(s32 arg0, s32 arg1, Vec *arg2) {
UnkUiWork03 *temp_r29 = OM_GET_WORK_PTR(itemPickObj, UnkUiWork03);
Vec (*temp_r31)[6] = (void*) temp_r29->unk04;
(temp_r31 + 4)[arg0][arg1 + 2].x = arg2->x;
(temp_r31 + 4)[arg0][arg1 + 2].y = arg2->y;
(temp_r31 + 4)[arg0][arg1 + 2].z = arg2->z;
}
static void TeamItemPosSet(s32 arg0, s32 arg1, Vec *arg2) {
TeamItemPosSetInlineFunc01(arg0, arg1, arg2);
TeamItemPosSetInlineFunc02(arg0, arg1, arg2);
}
static inline void ExecItemPickInlineFunc01(Vec (*arg0)[6]) {
Vec sp1C;
Vec sp28;
Vec sp34;
s16 temp_r24;
s32 sp14;
s32 i;
s32 j;
for (i = 0; i < 4; i++) {
for (j = 0; j < 3; j++) {
sp14 = GWPlayer[i].items[j];
if (sp14 == -1) {
itemMdlId[i][j] = -1;
} else {
BoardCameraRotGet(&sp1C);
temp_r24 = BoardModelCreate(itemMdlTbl[sp14], 0, 0);
itemMdlId[i][j] = temp_r24;
sp28.x = arg0[i][j + 2].x;
sp28.y = arg0[i][j + 2].y;
sp28.z = 4000.0f;
Hu3D2Dto3D(&sp28, 1, &sp34);
BoardModelPosSetV(temp_r24, &sp34);
BoardModelLayerSet(temp_r24, 5);
BoardModelRotSet(temp_r24, sp1C.x, 0.0f, 0.0f);
BoardModelScaleSet(temp_r24, 1.0f, 1.0f, 1.0f);
BoardModelMotionStart(temp_r24, 0, 0x400000);
BoardModelMotionStartEndSet(temp_r24, 0, 0x27);
BoardModelMotionSpeedSet(temp_r24, 0.0f);
}
}
}
}
static inline void ExecItemPickInlineFunc02(s32 arg0, s8 arg1, s32 arg2) {
UnkUiWork03 *sp10;
BoardPickerCreate(arg0, arg1, itemPosTemp, arg2);
CreateItemWindow(arg0, arg1);
sp10 = OM_GET_WORK_PTR(pickerObj, UnkUiWork03);
pickerObj->func = UpdateItemPickGfx;
while (!CheckItemWindow()) {
HuPrcVSleep();
}
if (_CheckFlag(0x1000B)) {
BoardTutorialHostHide(1);
}
}
static void ExecItemPick(void) {
Vec sp40;
s32 sp18;
s32 var_r22;
s32 var_r23;
s32 i;
s32 j;
UnkUiWork03 *temp_r27;
Vec (*temp_r28)[6];
if (_CheckFlag(0x1000B)) {
BoardTutorialHostHide(0);
}
itemPickObj = omAddObjEx(boardObjMan, 0x7E03, 0, 0, -1, &UpdateItemPick);
temp_r27 = OM_GET_WORK_PTR(itemPickObj, UnkUiWork03);
temp_r27->unk04 = HuMemDirectMallocNum(HEAP_SYSTEM, 0x240, MEMORY_DEFAULT_NUM);
temp_r27->unk00_bit0 = 0;
temp_r27->unk01 = 0;
temp_r27->unk02 = 0;
temp_r27->unk03 = 0;
temp_r27->unk00_bit1 = 0;
BoardStatusItemHideSet(0, 0);
BoardStatusItemHideSet(1, 0);
BoardStatusItemHideSet(2, 0);
BoardStatusItemHideSet(3, 0);
temp_r28 = (void*) temp_r27->unk04;
for (var_r22 = i = 0; i < 4; i++) {
if (itemTeamF != 0) {
if (itemTeam == GWPlayerTeamGet(i)) {
if (itemPlayer == i) {
var_r22 = 0;
} else {
var_r22 = 1;
}
sp40.x = teamItemStatusPosTbl[var_r22].x;
sp40.y = teamItemStatusPosTbl[var_r22].y;
} else {
sp40.x = statusPosTbl[i][0] + statusHideOfsTbl[i];
sp40.y = statusPosTbl[i][1];
}
} else {
sp40.x = statusPosTbl[i][0];
sp40.y = statusPosTbl[i][1];
}
for (j = 0; j < 6; j++) {
temp_r28[i][j].x = statusSprPosTbl[j + 0xB][0];
temp_r28[i][j].y = statusSprPosTbl[j + 0xB][1];
(temp_r28 + 4)[i][j].x = statusItemPosTbl[j][0];
(temp_r28 + 4)[i][j].y = statusItemPosTbl[j][1];
if (j >= 2 && j <= 4) {
temp_r28[i][j].x += sp40.x;
temp_r28[i][j].y += sp40.y;
(temp_r28 + 4)[i][j].x += sp40.x;
(temp_r28 + 4)[i][j].y += sp40.y;
}
(temp_r28 + 4)[i][j].z = temp_r28[i][j].z = 0.0f;
}
}
ExecItemPickInlineFunc01((void*) temp_r27->unk04);
memset(itemPosTemp, 0, 0x48);
var_r23 = BoardPlayerItemCount(itemPlayer);
ItemGetPos(itemPlayer, &itemPosTemp[0]);
if (GWTeamGet()) {
ItemGetPos(teamItemPlayer, &itemPosTemp[var_r23]);
var_r23 += BoardPlayerItemCount(teamItemPlayer);
}
for (j = 0; j < var_r23; j++) {
itemPosTemp[j].x -= 8.0f;
itemPosTemp[j].y += 16.0f;
}
sp18 = BoardComUseItemSlotGet(itemPlayer);
ExecItemPickInlineFunc02(itemPlayer, var_r23, sp18);
}
static void UpdateItemPick(omObjData *arg0) {
UnkUiWork03 *temp_r28 = OM_GET_WORK_PTR(arg0, UnkUiWork03);
UnkUiStatusStruct *temp_r26;
Vec (*temp_r27)[6];
Vec sp14;
Vec sp8;
float temp_f30;
s32 i;
s32 j;
if (temp_r28->unk00_bit0 || BoardIsKill()) {
for (i = 0; i < 4; i++) {
for (j = 0; j < 3; j++) {
if (itemMdlId[i][j] != -1) {
BoardModelKill(itemMdlId[i][j]);
itemMdlId[i][j] = -1;
}
}
}
BoardStatusItemHideSet(0, 1);
BoardStatusItemHideSet(1, 1);
BoardStatusItemHideSet(2, 1);
BoardStatusItemHideSet(3, 1);
HuMemDirectFree(temp_r28->unk04);
itemPickObj = NULL;
omDelObjEx(HuPrcCurrentGet(), arg0);
} else {
if (temp_r28->unk02 != 0) {
temp_r28->unk02--;
} else {
switch (temp_r28->unk01) {
case 3:
temp_r28->unk00_bit1 = 1;
/* fallthrough */
case 0:
temp_r28->unk01 = 1;
break;
case 1:
break;
default:
return;
}
}
MakeItemPickSpace(temp_r28);
temp_r27 = (void*) temp_r28->unk04;
for (i = 0; i < 4; i++) {
temp_r26 = &uiStatus[i];
for (j = 0; j < 6; j++) {
if (j != 5 || temp_r26->unk00_bit6) {
HuSprPosSet(temp_r26->unk02, j + 0xB, temp_r27[i][j].x, temp_r27[i][j].y);
}
}
for (j = 0; j < 3; j++) {
if (itemMdlId[i][j] != -1) {
OSs8tof32(&temp_r28->unk03, &temp_f30);
temp_f30 = 1.0 + 0.5 * sind(temp_f30);
BoardModelScaleSet(itemMdlId[i][j], temp_f30, temp_f30, temp_f30);
sp14.x = temp_r27[i][j + 2].x;
sp14.y = temp_r27[i][j + 2].y;
sp14.z = 4000.0f;
Hu3D2Dto3D(&sp14, 1, &sp8);
BoardModelPosSetV(itemMdlId[i][j], &sp8);
}
}
}
}
}
static void MakeItemPickSpace(UnkUiWork03 *arg0) {
Vec sp8;
float var_f29;
s32 i;
s32 j;
Vec (*temp_r28)[6];
temp_r28 = (void*) arg0->unk04;
if (!arg0->unk00_bit1) {
if (arg0->unk03 < 90) {
if (arg0->unk03 == 0) {
for (j = 0; j < 4; j++) {
BoardStatusGraySet(j, 0);
}
}
arg0->unk03 += 6;
if (arg0->unk03 > 90) {
arg0->unk03 = 90;
}
}
} else {
if (arg0->unk03 > 0) {
arg0->unk03 -= 6;
if (arg0->unk03 < 0) {
arg0->unk03 = 0;
}
if (arg0->unk03 == 0) {
for (j = 0; j < 4; j++) {
BoardStatusGraySet(j, 1);
}
}
}
}
for (i = 0; i < 4; i++) {
for (j = 0; j < 6; j++) {
PSVECSubtract(&(temp_r28 + 4)[i][j], &temp_r28[i][j], &sp8);
if (ABS(sp8.x) < 1.0f && ABS(sp8.y) < 1.0f) {
sp8 = (temp_r28 + 4)[i][j];
if (arg0->unk00_bit1 && arg0->unk03 == 0) {
arg0->unk00_bit0 = 1;
}
} else {
var_f29 = 0.3f;
PSVECScale(&sp8, &sp8, var_f29);
PSVECAdd(&temp_r28[i][j], &sp8, &sp8);
}
temp_r28[i][j].x = sp8.x;
temp_r28[i][j].y = sp8.y;
}
}
}
static void SetItemUIStatus(s32 arg0) {
UnkUiWork03 *temp_r27 = OM_GET_WORK_PTR(itemPickObj, UnkUiWork03);
Vec (*temp_r28)[6] = (void*) temp_r27->unk04;
float var_f31;
float var_f30;
s32 i;
s32 j;
switch (arg0) {
case 3:
case 0:
for (i = 0; i < 4; i++) {
var_f31 = statusPosTbl[i][0];
var_f30 = statusPosTbl[i][1];
for (j = 0; j < 6; j++) {
(temp_r28 + 4)[i][j].x = statusSprPosTbl[j + 0xB][0];
(temp_r28 + 4)[i][j].y = statusSprPosTbl[j + 0xB][1];
if (j + 0xB >= 0xD && j + 0xB <= 0xF) {
(temp_r28 + 4)[i][j].x += var_f31;
(temp_r28 + 4)[i][j].y += var_f30;
}
}
}
break;
case 2:
for (i = 0; i < 4; i++) {
var_f31 = statusPosTbl[i][0];
var_f30 = statusPosTbl[i][1];
for (j = 0; j < 6; j++) {
(temp_r28 + 4)[i][j].x = statusItemPosTbl[j][0];
(temp_r28 + 4)[i][j].y = statusItemPosTbl[j][1];
if ((j >= 2) && (j <= 4)) {
(temp_r28 + 4)[i][j].x += var_f31;
(temp_r28 + 4)[i][j].y += var_f30;
}
}
}
break;
default:
return;
}
temp_r27->unk01 = arg0;
}
void BoardItemGetDestPos(s32 arg0, Vec *arg1) {
Vec spC;
s32 i;
spC.x = statusPosTbl[arg0][0];
spC.y = statusPosTbl[arg0][1];
spC.z = 0.0f;
for (i = 0; i < 3; i++) {
PSVECAdd((Vec*) &statusItemPosTbl[i + 2], &spC, &arg1[i]);
}
}
static void ItemGetPos(s32 arg0, Vec *arg1) {
Vec spC;
s32 var_r29;
s32 i;
if (itemTeamF != 0) {
if (itemPlayer == arg0) {
var_r29 = 0;
} else {
var_r29 = 1;
}
spC.x = teamItemStatusPosTbl[var_r29].x;
spC.y = teamItemStatusPosTbl[var_r29].y;
} else {
spC.x = statusPosTbl[arg0][0];
spC.y = statusPosTbl[arg0][1];
}
spC.z = 0.0f;
for (i = 0; i < 3; i++) {
PSVECAdd((Vec*) statusItemPosTbl[i + 2], &spC, &arg1[i]);
}
}
void BoardItemStatusKill(s32 arg0) {
Vec sp68[3];
Vec sp44[3];
Vec sp20[3];
Vec sp14;
Vec sp8;
s16 temp_r28;
s16 temp_r25;
s16 i;
if (itemPickObj) {
if (itemTeamF != 0) {
if (arg0 == itemPlayer) {
sp8.x = teamItemStatusPosTbl[0].x;
sp8.y = teamItemStatusPosTbl[0].y;
} else {
sp8.x = teamItemStatusPosTbl[1].x;
sp8.y = teamItemStatusPosTbl[1].y;
}
} else {
sp8.x = statusPosTbl[arg0][0];
sp8.y = statusPosTbl[arg0][1];
}
sp8.z = 0.0f;
for (i = 0; i < 3; i++) {
PSVECAdd((Vec*) statusItemPosTbl[i + 2], &sp8, &sp68[i]);
if (itemMdlId[arg0][i] != -1) {
BoardModelRotGet(itemMdlId[arg0][i], &sp44[i]);
BoardModelScaleGet(itemMdlId[arg0][i], &sp20[i]);
BoardModelKill(itemMdlId[arg0][i]);
itemMdlId[arg0][i] = -1;
}
}
for (i = 0; i < 3; i++) {
temp_r25 = GWPlayer[arg0].items[i];
if (temp_r25 != -1) {
temp_r28 = BoardModelCreate(itemMdlTbl[temp_r25], 0, 0);
itemMdlId[arg0][i] = temp_r28;
BoardCameraRotGet(&sp14);
BoardModelPosSetV(temp_r28, &sp68[i]);
BoardModelRotSet(temp_r28, sp14.x, 0.0f, 0.0f);
BoardModelScaleSetV(temp_r28, &sp20[i]);
BoardModelLayerSet(temp_r28, 6);
BoardModelMotionStart(temp_r28, 0, 0x400000);
BoardModelMotionSpeedSet(temp_r28, 0.0f);
TeamItemPosSet(arg0, i, &sp68[i]);
}
}
}
}
static void UpdateItemPickGfx(omObjData *arg0) {
UnkUiWork01 *temp_r30 = OM_GET_WORK_PTR(arg0, UnkUiWork01);
if (temp_r30->unk00_bit0 || BoardIsKill()) {
HuWinKill(temp_r30->unk06);
HuSprGrpKill(temp_r30->unk04);
pickerObj = NULL;
omDelObjEx(HuPrcCurrentGet(), arg0);
} else {
if (temp_r30->unk03 != 0) {
temp_r30->unk03--;
} else {
if (!CheckItemWindowSlide()) {
temp_r30->unk00_bit6 = 1;
}
UpdatePickerInput(temp_r30, arg0);
}
MovePicker(temp_r30, arg0);
SetItemWindowCurr(temp_r30->unk02);
if (pickerChoice != -1 || temp_r30->unk00_bit7) {
KillItemWindow();
if (!temp_r30->unk00_bit7) {
temp_r30->unk00_bit3 = 1;
HuSprBankSet(temp_r30->unk04, 0, 1);
HuSprAttrSet(temp_r30->unk04, 0, 2);
HuSprAttrReset(temp_r30->unk04, 0, 1);
arg0->func = UpdateItemPickup;
HuWinDispOff(temp_r30->unk06);
} else {
itemUsed = -1;
}
}
HuSprPosSet(temp_r30->unk04, 0, arg0->trans.x, arg0->trans.y);
}
}
static void UpdateItemPickup(omObjData *arg0) {
UnkUiWork01 *temp_r31 = OM_GET_WORK_PTR(arg0, UnkUiWork01);
Vec sp50;
Vec sp44;
Vec sp38;
Vec sp2C;
Vec sp20;
Vec sp14;
Vec sp8;
s16 var_r29;
s16 var_r28;
s16 var_r27;
s16 var_r25;
s16 var_r26;
if (temp_r31->unk00_bit0 || BoardIsKill()) {
HuWinKill(temp_r31->unk06);
BoardModelKill(itemPickupMdlId);
itemPickupMdlId = -1;
HuSprGrpKill(temp_r31->unk04);
pickerObj = NULL;
omDelObjEx(HuPrcCurrentGet(), arg0);
} else if (temp_r31->unk03 != 0) {
temp_r31->unk03--;
} else if (pickerChoice == -1) {
temp_r31->unk00_bit0 = 1;
} else {
var_r29 = temp_r31->unk00_bit5;
var_r28 = pickerChoice;
if (GWTeamGet() && pickerChoice >= BoardPlayerItemCount(temp_r31->unk00_bit5)) {
var_r29 = teamItemPlayer;
var_r28 -= BoardPlayerItemCount(temp_r31->unk00_bit5);
}
switch (temp_r31->unk00_bit3) {
case 1:
BoardModelVisibilitySet(itemMdlId[var_r29][var_r28], 0);
BoardModelPosGet(itemMdlId[var_r29][var_r28], &sp50);
BoardModelRotGet(itemMdlId[var_r29][var_r28], &sp38);
BoardModelScaleGet(itemMdlId[var_r29][var_r28], &sp44);
itemUsed = GWPlayer[var_r29].items[var_r28];
boardItemUser = var_r29;
itemPickupMdlId = BoardModelCreate(itemMdlTbl[itemUsed], NULL, 0);
BoardModelPosSetV(itemPickupMdlId, &sp50);
BoardModelRotSetV(itemPickupMdlId, &sp38);
BoardModelScaleSetV(itemPickupMdlId, &sp44);
BoardModelLayerSet(itemPickupMdlId, 6);
BoardModelMotionStart(itemPickupMdlId, 0, 0x400000);
BoardModelMotionSpeedSet(itemPickupMdlId, 0.0f);
temp_r31->unk00_bit3 = 2;
break;
case 2:
var_r27 = 0x27;
var_r25 = var_r27 + 0x27;
BoardModelMotionStart(itemPickupMdlId, 0, 0);
BoardModelMotionTimeSet(itemPickupMdlId, var_r27);
BoardModelMotionStartEndSet(itemPickupMdlId, var_r27, var_r25);
HuSprBankSet(temp_r31->unk04, 0, 1);
HuSprAttrSet(temp_r31->unk04, 0, 2);
HuSprSpeedSet(temp_r31->unk04, 0, 1.0f);
itemPickupPos = 1.0f;
temp_r31->unk00_bit3 = 3;
HuAudFXPlay(0x30E);
break;
case 3:
var_r26 = 0x27;
if (BoardModelMotionTimeGet(itemPickupMdlId) < var_r26 + 0x17) {
arg0->trans.x -= itemPickupPos;
arg0->trans.y += itemPickupPos;
itemPickupPos *= 0.98f;
} else {
sp50.x = arg0->trans.x;
sp50.y = arg0->trans.y;
sp50.z = 3200.0f;
Hu3D2Dto3D(&sp50, 1, &sp50);
BoardModelPosSetV(itemPickupMdlId, &sp50);
itemPickupPos = 4.0f;
temp_r31->unk00_bit3 = 4;
HuAudFXPlay(0x30F);
}
break;
case 4:
var_r26 = 0x4E;
if (BoardModelMotionTimeGet(itemPickupMdlId) >= var_r26) {
temp_r31->unk03 = 0x12;
BoardPlayerItemRemove(var_r29, var_r28);
temp_r31->unk00_bit3 = 5;
} else {
arg0->trans.x -= itemPickupPos;
arg0->trans.y += itemPickupPos;
itemPickupPos *= 0.9f;
sp50.x = arg0->trans.x;
sp50.y = arg0->trans.y;
sp50.z = 3200.0f;
Hu3D2Dto3D(&sp50, 1, &sp50);
BoardModelPosSetV(itemPickupMdlId, &sp50);
}
break;
case 5:
BoardPlayerPosGet(temp_r31->unk00_bit5, &sp2C);
sp2C.y += 300.0f;
sp8 = sp2C;
Hu3D3Dto2D(&sp2C, 1, &sp2C);
sp20.x = arg0->trans.x;
sp20.y = arg0->trans.y;
PSVECSubtract(&sp2C, &sp20, &sp14);
if (ABS(sp14.x) < 1.0f && ABS(sp14.y) < 1.0f) {
HuSprAttrSet(temp_r31->unk04, 0, 4);
temp_r31->unk00_bit3 = 6;
} else {
PSVECScale(&sp14, &sp14, 0.1f);
PSVECAdd(&sp20, &sp14, &sp50);
sp50.z = 3200.0f;
arg0->trans.x = sp50.x;
arg0->trans.y = sp50.y;
Hu3D2Dto3D(&sp50, 1, &sp50);
BoardModelPosSetV(itemPickupMdlId, &sp50);
}
break;
case 6:
break;
}
HuSprPosSet(temp_r31->unk04, 0, arg0->trans.x, arg0->trans.y);
}
}
static BOOL CheckItemWindow(void) {
UnkUiWork01 *temp_r31;
if (pickerObj == 0) {
return TRUE;
}
temp_r31 = OM_GET_WORK_PTR(pickerObj, UnkUiWork01);
if (temp_r31->unk00_bit3 == 6) {
return TRUE;
} else {
return FALSE;
}
}
static void HideItemWindow(void) {
UnkUiWork01 *temp_r31;
if (pickerObj) {
temp_r31 = OM_GET_WORK_PTR(pickerObj, UnkUiWork01);
temp_r31->unk00_bit0 = 1;
}
}
static void CreateItemWindow(s32 arg0, s32 arg1) {
Vec sp10;
float sp8[2];
float temp_f31;
float var_f30;
s32 var_r27;
s32 temp_r28;
s32 i;
omObjData *temp_r26;
UnkUiWork04 *temp_r29;
UnkUiWindowStruct *temp_r31;
temp_f31 = 0.25f;
temp_r26 = omAddObjEx(boardObjMan, 0x107, 0, 0, -1, UpdateItemWindow);
itemWindowObj = temp_r26;
temp_r29 = OM_GET_WORK_PTR(temp_r26, UnkUiWork04);
temp_r29->unk00_bit0 = 0;
temp_r29->unk01 = 0;
temp_r29->unk03 = 0;
temp_r29->unk02 = arg1;
temp_r29->unk04 = HuMemDirectMallocNum(HEAP_SYSTEM, sizeof(UnkUiWindowStruct), MEMORY_DEFAULT_NUM);
temp_r26->trans.x = 0.0f;
if (GWTeamGet()) {
var_f30 = 32.0f;
} else {
var_f30 = 0.0f;
}
temp_r31 = temp_r29->unk04;
for (i = 0; i < arg1; i++) {
var_r27 = i;
if (GWTeamGet() && i >= BoardPlayerItemCount(itemPlayer)) {
arg0 = teamItemPlayer;
var_r27 -= BoardPlayerItemCount(itemPlayer);
}
temp_r28 = GWPlayer[arg0].items[var_r27];
if (temp_r28 == -1) {
temp_r31->unk12[i] = temp_r31->unk1E[i]
= temp_r31->unk06[i] = temp_r31->unk00[i] = -1;
} else {
temp_r31->unk00[i] = temp_r28;
temp_r31->unk74[i].x = i * 576.0f + 36.0f;
temp_r31->unk74[i].y = var_f30 + 240.0f;
temp_r31->unk74[i].z = 0.0f;
temp_r31->unk2C[i] = temp_r31->unk74[i];
temp_r31->unk12[i] = HuWinCreate(temp_r31->unk2C[i].x, temp_r31->unk2C[i].y, 0x1F8, 0x60, 0);
HuWinDrawNoSet(temp_r31->unk12[i], 0x40);
HuWinCenterPosSet(temp_r31->unk12[i], 0.0f, 48.0f);
HuWinMesSpeedSet(temp_r31->unk12[i], 0);
HuWinMesSet(temp_r31->unk12[i], BoardItemNameGet(temp_r28));
HuWinMesMaxSizeGet(1, sp8, temp_r28 + 0x8000E);
temp_r31->unk1E[i] = HuWinCreate(temp_r31->unk2C[i].x, temp_r31->unk2C[i].y - (-94.0f), sp8[0], sp8[1], 0);
HuWinDrawNoSet(temp_r31->unk1E[i], 0x40);
HuWinMesSpeedSet(temp_r31->unk1E[i], 0);
HuWinMesSet(temp_r31->unk1E[i], temp_r28 + 0x8000E);
sp10.x = temp_r31->unk2C[i].x + 48.0f;
sp10.y = temp_r31->unk2C[i].y;
sp10.z = 400.0f;
Hu3D2Dto3D(&sp10, 1, &sp10);
temp_r31->unk06[i] = BoardModelCreate(BoardItemModelGet(temp_r28), NULL, 0);
BoardModelLayerSet(temp_r31->unk06[i], 6);
BoardModelPosSetV(temp_r31->unk06[i], &sp10);
BoardModelScaleSet(temp_r31->unk06[i], temp_f31, temp_f31, temp_f31);
if (temp_r28 == 4) {
BoardModelMotionStart(temp_r31->unk06[i], 0, 0x40000001);
BoardModelMotionSpeedSet(temp_r31->unk06[i], 0.033333335f);
}
}
}
for (; i < 6; i++) {
temp_r31->unk06[i] = -1;
temp_r31->unk12[i] = -1;
temp_r31->unk1E[i] = -1;
}
}
static BOOL CheckItemWindowSlide(void) {
UnkUiWork04 *temp_r31;
if (itemWindowObj == 0) {
return TRUE;
}
temp_r31 = OM_GET_WORK_PTR(itemWindowObj, UnkUiWork04);
return (temp_r31->unk03 != 0) ? FALSE : TRUE;
}
static void KillItemWindow(void) {
UnkUiWork04 *temp_r31;
if (itemWindowObj) {
temp_r31 = OM_GET_WORK_PTR(itemWindowObj, UnkUiWork04);
temp_r31->unk00_bit0 = 1;
}
}
static void SetItemWindowCurr(s32 arg0) {
UnkUiWork04 *temp_r31;
UnkUiWindowStruct *temp_r30;
if (itemWindowObj) {
temp_r31 = OM_GET_WORK_PTR(itemWindowObj, UnkUiWork04);
if (temp_r31->unk02 > 1 && arg0 != temp_r31->unk01) {
temp_r30 = temp_r31->unk04;
temp_r30->unk74[temp_r31->unk01].x = -576.0f;
temp_r30->unk74[arg0].x = temp_r30->unk2C[temp_r31->unk01].x;
temp_r30->unk2C[arg0].x = 576.0f;
temp_r31->unk01 = arg0;
}
}
}
static void UpdateItemWindow(omObjData *arg0) {
Vec sp20;
Vec sp14;
Vec sp8;
UnkUiWork04 *temp_r29;
UnkUiWindowStruct *temp_r31;
s32 var_r27;
s32 i;
Mtx sp5C;
Mtx sp2C;
temp_r29 = OM_GET_WORK_PTR(arg0, UnkUiWork04);
temp_r31 = temp_r29->unk04;
if (temp_r29->unk00_bit0 || (BoardIsKill() != 0)) {
for (i = 0; i < temp_r29->unk02; i++) {
if (temp_r31->unk12[i] != -1) {
HuWinKill(temp_r31->unk12[i]);
}
if (temp_r31->unk1E[i] != -1) {
HuWinKill(temp_r31->unk1E[i]);
}
if (temp_r31->unk06[i] != -1) {
BoardModelKill(temp_r31->unk06[i]);
}
}
HuMemDirectFree(temp_r29->unk04);
itemWindowObj = NULL;
omDelObjEx(HuPrcCurrentGet(), arg0);
} else {
var_r27 = 0;
for (i = 0; i < temp_r29->unk02; i++) {
if ((temp_r31->unk06[i] != -1) && (temp_r31->unk12[i] != -1)) {
PSVECSubtract(&temp_r31->unk74[i], &temp_r31->unk2C[i], &sp20);
if (PSVECMag(&sp20) <= 1.0f) {
temp_r31->unk2C[i] = temp_r31->unk74[i];
} else {
PSVECScale(&sp20, &sp20, 0.3f);
PSVECAdd(&sp20, &temp_r31->unk2C[i], &temp_r31->unk2C[i]);
var_r27 = 1;
}
HuWinPosSet(temp_r31->unk12[i], temp_r31->unk2C[i].x, temp_r31->unk2C[i].y);
HuWinPosSet(temp_r31->unk1E[i], temp_r31->unk2C[i].x, temp_r31->unk2C[i].y + (-94.0f));
sp14.x = temp_r31->unk2C[i].x + 48.0f;
sp14.y = temp_r31->unk2C[i].y;
sp14.z = 400.0f;
if (temp_r31->unk00[i] == 5) {
sp14.y += 35.0f;
}
Hu3D2Dto3D(&sp14, 1, &sp14);
BoardModelPosSetV(temp_r31->unk06[i], &sp14);
BoardCameraRotGet(&sp8);
PSMTXRotRad(sp2C, 'y', MTXDegToRad(arg0->trans.x));
PSMTXRotRad(sp5C, 'x', MTXDegToRad(sp8.x + 10.0f));
PSMTXConcat(sp5C, sp2C, sp2C);
BoardModelMtxSet(temp_r31->unk06[i], &sp2C);
BoardModelRotSet(temp_r31->unk06[i], 0.0f, 0.0f, 0.0f);
}
}
temp_r29->unk03 = var_r27;
arg0->trans.x = BoardDAngleCalc(arg0->trans.x + 2.0f);
}
}
static void CreatePickerWindow(UnkUiWork01 *arg0, s32 arg1) {
float spC[2];
float var_f31;
float var_f30;
float var_f29;
s32 var_r30;
switch (GWGameStat.language) {
case 1:
var_f31 = 0.0f;
break;
case 0:
var_f31 = 0.0f;
break;
}
if (arg1 != 0) {
var_r30 = 0x10001A;
} else {
var_r30 = 0x10001B;
}
HuWinMesMaxSizeGet(1, spC, var_r30);
var_f30 = -10000.0f;
var_f29 = var_f31 + 352.0f;
arg0->unk06 = HuWinCreate(var_f30, var_f29, spC[0], spC[1], 0);
HuWinBGTPLvlSet(arg0->unk06, 0.0f);
HuWinMesSpeedSet(arg0->unk06, 0);
HuWinMesSet(arg0->unk06, var_r30);
if (_CheckFlag(0x1000B)) {
HuWinDispOff(arg0->unk06);
}
}
static void KillPickerWindow(UnkUiWork01 *arg0) {
if (arg0->unk06 != -1) {
HuWinKill(arg0->unk06);
arg0->unk06 = -1;
}
}
Reference in a new issue View git blame Copy permalink