falso
/
tmc
mirror of https://github.com/zeldaret/tmc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
tmc/src/kinstone.c

540 lines
15 KiB
C
Raw Blame History

#include "area.h"
#include "asm.h"
#include "common.h"
#include "flags.h"
#include "global.h"
#include "item.h"
#include "kinstone.h"
#include "manager.h"
#include "message.h"
#include "player.h"
#include "room.h"
#include "subtask.h"
extern const struct_gUnk_080B3D20 gUnk_080B3D20[];
extern EntityData gUnk_080FEC28[];
extern EntityData gUnk_080FEBE8[];
extern EntityData gUnk_080FECC8[];
extern EntityData gUnk_080FEE78[];
extern EntityData gUnk_080FED58[];
extern const EntityData gUnk_080FED18[];
extern const EntityData gUnk_080FEE38[];
extern const EntityData gUnk_080FEE18[];
extern const EntityData gUnk_080FEE48[];
extern const EntityData gUnk_080FEE58[];
extern const void* gUnk_080FED98[];
void sub_08018AB4(int);
void sub_08018BB4(u32 worldEventId);
void sub_08018A58(u32 worldEventId);
void sub_08018B50(u32 worldEventId);
void sub_080189EC(u32 worldEventId);
void sub_0801876C(u32 worldEventId, bool32 isKinstoneFused);
void sub_08018738(u32 kinstoneId, u32 worldEventId);
void ShuffleEzloHints(int count, u16* basePtr);
void sub_08018500();
bool32 sub_080185B4(const struct_gUnk_080B3D20* param_1);
const u16 gEzloHintTextBase[] = { TEXT_INDEX(TEXT_EZLO2, 0x0), TEXT_INDEX(TEXT_EZLO2, 0x12),
TEXT_INDEX(TEXT_EZLO2, 0x2d), TEXT_INDEX(TEXT_EZLO2, 0x48),
TEXT_INDEX(TEXT_EZLO2, 0x57), TEXT_INDEX(TEXT_EZLO2, 0x6f) };
void sub_08018500(void) {
s32 sVar1;
u32 i;
u16* puVar3;
u16* puVar4;
struct_area_28* ptr = &gArea.unk28;
puVar3 = ptr->ezloHintTexts;
sVar1 = gEzloHintTextBase[ptr->textBaseIndex] + ptr->textIndexOffset * 3;
for (i = 0; i < 3; i++) {
*puVar3 = sVar1;
sVar1++;
puVar3++;
}
sVar1 = ptr->textBaseIndex * 5 + 0xc81;
for (i = 0, puVar4 = &ptr->ezloHintTexts[3]; i < 5; i++) {
*puVar3 = sVar1;
sVar1++;
puVar3++;
}
ShuffleEzloHints(5, puVar4);
ptr->currentHint = 0;
}
/*
Some sort of ezlo hint? Seem to be the ezlo hints depending on the current progress.
*/
#define CHECK_ITEM 0xfe
#define CHECK_KINSTONE 0xfd
const struct_gUnk_080B3D20 gUnk_080B3D20[] = {
{ LOCAL_BANK_0, EZERO_1ST, 0, 0 },
{ LOCAL_BANK_0, ENTRANCE_0, 0, 1 },
{ LOCAL_BANK_2, KOBITO_MORI_1ST, 0, 2 },
{ LOCAL_BANK_2, M_PRIEST_TALK, 0, 3 },
{ CHECK_ITEM, ITEM_JABBERNUT, 0, 4 },
{ LOCAL_BANK_2, M_ELDER_TALK1ST, 0, 5 },
{ LOCAL_BANK_0, LV1_CLEAR, 1, 0 },
{ LOCAL_BANK_2, M_ELDER_TALK2ND, 1, 1 },
{ CHECK_ITEM, ITEM_KINSTONE_BAG, 1, 2 },
{ CHECK_ITEM, ITEM_SKILL_SPIN_ATTACK, 1, 3 },
{ LOCAL_BANK_1, YAMA_00_01, 1, 4 },
{ LOCAL_BANK_0, WATERBEAN_PUT, 1, 5 },
{ LOCAL_BANK_1, YAMA_00_00, 1, 6 },
{ LOCAL_BANK_2, KOBITO_YAMA_ENTER, 1, 7 },
{ LOCAL_BANK_2, OYAKATA_DEMO, 1, 8 },
{ LOCAL_BANK_0, LV2_CLEAR, 2, 0 },
{ CHECK_ITEM, ITEM_GREEN_SWORD, 2, 1 },
{ LOCAL_BANK_3, SEIIKI_ENTER, 2, 2 },
{ LOCAL_BANK_3, SEIIKI_BUNSHIN, 2, 3 },
{ LOCAL_BANK_0, DASHBOOTS, 2, 4 },
{ LOCAL_BANK_2, KHOUSE52_KINOKO, 2, 5 },
{ CHECK_ITEM, ITEM_QST_MUSHROOM, 2, 6 },
{ CHECK_ITEM, ITEM_PEGASUS_BOOTS, 2, 7 },
{ LOCAL_BANK_1, LOST_00_ENTER, 2, 8 },
{ CHECK_ITEM, ITEM_OCARINA, 3, 0 },
{ LOCAL_BANK_0, MIZUKAKI_START, 3, 1 },
{ LOCAL_BANK_0, MIZUKAKI_NECHAN, 3, 2 },
{ LOCAL_BANK_2, MIZUKAKI_BOOK_ALLBACK, 3, 3 },
{ CHECK_ITEM, ITEM_FLIPPERS, 3, 4 },
{ LOCAL_BANK_1, LV4_CLEAR_MES, 4, 0 },
{ CHECK_ITEM, ITEM_BLUE_SWORD, 4, 1 },
{ LOCAL_BANK_3, LV4_HAKA_08_CAP_0, 4, 2 },
{ LOCAL_BANK_3, OUBO_KAKERA, 4, 3 },
{ CHECK_KINSTONE, KINSTONE_SOURCE_FLOW, 4, 4 },
{ LOCAL_BANK_0, TATSUMAKI, 4, 5 },
{ LOCAL_BANK_2, SORA_YAKATA_ENTER, 4, 6 },
{ LOCAL_BANK_2, SORA_CHIEF_TALK, 4, 7 },
{ LOCAL_BANK_0, LV5_CLEAR, 5, 0 },
{ CHECK_ITEM, ITEM_FOURSWORD, 5, 1 },
{ LOCAL_BANK_10, LV6_1d_KEYGET, 5, 2 },
{ LOCAL_BANK_10, LV6_KANE_START, 5, 3 },
{ LOCAL_BANK_10, LV6_GUFUU2_DEAD, 5, 4 },
{ LOCAL_BANK_10, LV6_ZELDA_DISCURSE, 5, 5 },
{ 0xff, 0xff, 0xff, 0xff },
};
void sub_0801855C(void) {
u32 bVar3;
struct_area_28* ptr;
// TODO: Figure out what is up with the pointer assignment
const struct_gUnk_080B3D20* pcVar2 = (const struct_gUnk_080B3D20*)&gArea.unk28;
MemClear((void*)pcVar2, sizeof(struct_area_28));
ptr = (struct_area_28*)pcVar2;
// Find the latest hint that is true.
for (pcVar2 = gUnk_080B3D20, bVar3 = 0; pcVar2->unk0 != 0xff; pcVar2++) {
if (sub_080185B4(pcVar2)) {
bVar3 = ptr->unk2b;
}
ptr->unk2b++;
}
ptr->unk2b = bVar3;
pcVar2 = &gUnk_080B3D20[ptr->unk2b];
ptr->textBaseIndex = pcVar2->unk2;
ptr->textIndexOffset = pcVar2->unk3;
ptr->unk2b = bVar3 + 1;
sub_08018500();
}
bool32 sub_080185B4(const struct_gUnk_080B3D20* param_1) {
if (param_1->unk0 == 0xff)
return FALSE;
if (param_1->unk0 == CHECK_ITEM) {
return GetInventoryValue(param_1->unk1) != 0;
}
if (param_1->unk0 == CHECK_KINSTONE) {
return CheckKinstoneFused(param_1->unk1);
}
return CheckLocalFlagByBank(gLocalFlagBanks[param_1->unk0], param_1->unk1);
}
void sub_080185F8(void) {
struct_area_28* ptr2 = &gArea.unk28;
const struct_gUnk_080B3D20* ptr = &gUnk_080B3D20[ptr2->unk2b];
if (sub_080185B4(ptr)) {
ptr2->textBaseIndex = ptr->unk2;
ptr2->textIndexOffset = ptr->unk3;
ptr2->unk2b++;
sub_08018500();
}
}
void GenerateAreaHint(void) {
u16 tmp;
struct_area_28* ptr;
gPlayerState.queued_action = PLAYER_TALKEZLO;
#if defined(EU) || defined(JP)
// TODO what fields of the room transition are switched in these variants?
gRoomTransition.field_0x2c[7] = 0;
#else
gRoomTransition.hint_height = 0;
#endif
ptr = &gArea.unk28;
if (ptr->textBaseIndex == 0xff) {
gRoomTransition.hint_idx = ptr->ezloHintTexts[0];
} else {
gRoomTransition.hint_idx = ptr->ezloHintTexts[ptr->currentHint];
ptr->currentHint++;
if (ptr->currentHint > 7) {
ptr->currentHint = 0;
ShuffleEzloHints(8, ptr->ezloHintTexts);
if (ptr->ezloHintTexts[0] == gRoomTransition.hint_idx) {
tmp = ptr->ezloHintTexts[0];
ptr->ezloHintTexts[0] = ptr->ezloHintTexts[7];
ptr->ezloHintTexts[7] = tmp;
}
}
}
}
void ShuffleEzloHints(int count, u16* basePtr) {
u32 uVar1;
s32 uVar4;
s32 uVar2;
s32 iVar3;
u16* puVar4;
u16* puVar5;
uVar4 = count - 1;
if (uVar4 != 0) {
puVar5 = (u16*)(uVar4 * 2 + (int)basePtr);
do {
uVar2 = Random();
iVar3 = uVar2 % (uVar4 + 1);
uVar1 = *puVar5;
puVar4 = (u16*)(iVar3 * 2 + (int)basePtr);
*puVar5 = *puVar4;
*puVar4 = uVar1;
puVar5--;
uVar4--;
} while (uVar4 != 0);
}
}
void SetNextAreaHint(u32 textId) {
gArea.unk28.textBaseIndex = 0xff;
gArea.unk28.ezloHintTexts[0] = textId;
}
void sub_080186D4(void) {
if (gArea.unk28.textBaseIndex == 0xff) {
sub_0801855C();
}
}
void sub_080186EC(u32 param_1) {
const KinstoneWorldEvent* psVar1;
u32 i;
for (i = 0, psVar1 = gKinstoneWorldEvents; i <= 100; psVar1++, i++) {
if (psVar1->subtask == SUBTASK_WORLDEVENT) {
sub_08018738(i, psVar1->worldEventId);
}
}
}
void sub_08018710(u32 previousworldEventId) {
const KinstoneWorldEvent* psVar1;
u32 i;
for (i = 0, psVar1 = gKinstoneWorldEvents; i <= 100; psVar1++, i++) {
if (psVar1->subtask == SUBTASK_WORLDEVENT && previousworldEventId != psVar1->worldEventId) {
sub_08018738(i, psVar1->worldEventId);
}
}
}
void sub_08018738(u32 kinstoneId, u32 worldEventId) {
const WorldEvent* ptr = &gWorldEvents[worldEventId];
if (ptr->area == gRoomControls.area && ptr->room == gRoomControls.room) {
sub_0801876C(worldEventId, CheckKinstoneFused(kinstoneId));
}
}
void sub_0801876C(u32 worldEventId, bool32 isKinstoneFused) {
Entity* roomEnt;
Entity* ent;
u32 uVar3;
u32 tmp;
u8* puVar4;
u32 uVar5;
const WorldEvent* ptr;
ptr = &gWorldEvents[worldEventId];
switch (ptr->type) {
case WORLD_EVENT_TYPE_6:
if (isKinstoneFused == 0) {
sub_08018AB4((ptr->x >> 4 & 0x3f) | (ptr->y >> 4 & 0x3f) << 6);
}
break;
case WORLD_EVENT_TYPE_0:
break;
case WORLD_EVENT_TYPE_2:
if (isKinstoneFused != 0) {
sub_08018BB4(worldEventId);
}
break;
case WORLD_EVENT_TYPE_1:
if (isKinstoneFused == 0) {
return;
}
if (CheckGlobalFlag(ptr->flag)) {
return;
}
LoadRoomEntity(gUnk_080FEC28 + ptr->entity_idx);
break;
case WORLD_EVENT_TYPE_3:
if (isKinstoneFused == 0) {
return;
}
if (GetInventoryValue(ptr->flag)) {
return;
}
LoadRoomEntity(gUnk_080FEBE8 + ptr->entity_idx);
break;
case WORLD_EVENT_TYPE_4:
if (isKinstoneFused == 0) {
sub_08018A58(worldEventId);
}
break;
case WORLD_EVENT_TYPE_5:
if (isKinstoneFused != 0) {
sub_08018B50(worldEventId);
}
break;
case WORLD_EVENT_TYPE_7:
if (isKinstoneFused != 0) {
return;
}
if (ptr->entity_idx != 0x80) {
LoadRoomEntity(gUnk_080FECC8 + ptr->entity_idx);
} else {
sub_080189EC(worldEventId);
}
break;
case WORLD_EVENT_TYPE_25:
roomEnt = LoadRoomEntity(&gUnk_080FED18[ptr->entity_idx]);
if (roomEnt != 0) {
roomEnt->type = isKinstoneFused ? 2 : 0;
}
break;
case WORLD_EVENT_TYPE_8:
if (isKinstoneFused == 0) {
return;
}
SetTileType(0x168, (ptr->x >> 4 & 0x3f) | (ptr->y >> 4 & 0x3f) << 6, 1);
break;
case WORLD_EVENT_TYPE_11:
if (isKinstoneFused != 0) {
LoadRoomEntity(&gUnk_080FED58[ptr->entity_idx]);
gRoomVars.field_0x8c[ptr->entity_idx] = (void*)gUnk_080FED98[ptr->entity_idx];
}
break;
case WORLD_EVENT_TYPE_9:
if (isKinstoneFused == 0) {
return;
}
ent = LoadRoomEntity(&gUnk_080FEE78[ptr->entity_idx]);
if (ent != 0) {
*(u16*)&ent->collisionLayer = ptr->x + gRoomControls.origin_x;
*(u16*)&ent->gustJarState = ptr->y + gRoomControls.origin_y;
}
if (ptr->entity_idx == 0) {
SetTileType(0x8d, (ptr->x >> 4 & 0x3f) | (ptr->y >> 4 & 0x3f) << 6, 1);
} else {
uVar5 = (ptr->x >> 4 & 0x3f) | (ptr->y >> 4 & 0x3f) << 6;
SetTileType(0x8c, uVar5 - 1, 1);
uVar3 = 0x8e;
SetTileType(uVar3, uVar5, 1);
}
break;
case WORLD_EVENT_TYPE_24:
if (isKinstoneFused != 0) {
LoadRoomEntityList(gUnk_080FEE18);
}
break;
case WORLD_EVENT_TYPE_15:
if (isKinstoneFused != 0) {
LoadRoomEntity(gUnk_080FEE58);
} else {
LoadRoomEntity(gUnk_080FEE48);
}
break;
case WORLD_EVENT_TYPE_17:
if (isKinstoneFused != 0) {
SetLocalFlagByBank(FLAG_BANK_1, SOUGEN_05_BOMB_00);
LoadRoomEntityList(gUnk_080FEE38);
}
break;
case WORLD_EVENT_TYPE_26:
case WORLD_EVENT_TYPE_27:
case WORLD_EVENT_TYPE_28:
break;
}
}
void sub_080189EC(u32 worldEventId) {
u32 i;
int iVar1;
int tilePosition;
const WorldEvent* ptr;
ptr = &gWorldEvents[worldEventId];
tilePosition = (ptr->x >> 4) & 0x3f;
tilePosition |= ((ptr->y >> 4) & 0x3f) << 6;
tilePosition -= 0x42;
for (i = 0; i < 4; i++) {
SetTileType(i + 0x1df, tilePosition + i, 2);
}
tilePosition += 0x40;
for (i = 0; i < 4; i++) {
SetTileType(i + 0x1e3, tilePosition + i, 2);
SetTileType(i + 0x1db, tilePosition + i, 1);
}
}
void sub_08018A58(u32 worldEventId) {
u32 i;
int iVar2;
u32 j;
int tilePosition;
const WorldEvent* ptr;
ptr = &gWorldEvents[worldEventId];
tilePosition = (ptr->x >> 4) & 0x3f;
tilePosition |= ((ptr->y >> 4) & 0x3f) << 6;
tilePosition -= 0x43;
iVar2 = 0x232;
for (i = 0; i < 4; tilePosition += 0x40, i++) {
for (j = 0; j < 7; j++) {
SetTileType(iVar2++, tilePosition + j, 1);
}
}
}
void sub_08018AB4(int param_1) {
u32 i;
int iVar2;
u32 j;
int iVar6;
iVar2 = 0x1e8;
iVar6 = 500;
for (i = 0; i < 3; i++) {
j = 0;
for (; j < 4; j++) {
SetTileType(iVar2++, param_1 + j, 1);
SetTileType(iVar6++, param_1 - 0x40 + j, 2);
}
param_1 += 0x40;
}
}
void sub_08018B10(int param_1) {
int iVar1;
u32 index;
int iVar3;
int iVar4;
iVar4 = 0x1f0;
iVar3 = 0x1fc;
index = 0;
iVar1 = param_1 - 0x40;
for (; index < 4; iVar1++, index++) {
SetTileType(iVar4++, param_1 + index, 1);
SetTileType(iVar3++, iVar1, 2);
}
}
void sub_08018B50(u32 worldEventId) {
u32 i;
int iVar2;
u32 j;
int tilePosition;
const WorldEvent* ptr;
ptr = &gWorldEvents[worldEventId];
if ((ptr->entity_idx & 0x80) == 0) {
iVar2 = 0x200;
} else {
iVar2 = 0x219;
}
tilePosition = (ptr->x >> 4) & 0x3f;
tilePosition |= ((ptr->y >> 4) & 0x3f) << 6;
tilePosition -= 0x82;
for (i = 0; i < 5; tilePosition += 0x40, i++) {
for (j = 0; j < 5; j++) {
SetTileType(iVar2++, tilePosition + j, 1);
}
}
}
// TODO world event that loads tile entity
void sub_08018BB4(u32 worldEventId) {
u32 layer;
TileEntity tile;
const WorldEvent* ptr;
u32 position;
MemCopy(gUnk_080FEAC8 + worldEventId, &tile, sizeof(TileEntity));
ptr = &gWorldEvents[worldEventId];
tile.tilePos = (ptr->x >> 4 & 0x3f) | (((ptr->y) >> 4 & 0x3f) << 6);
sub_0804B3C4(&tile);
if (CheckLocalFlag(tile.localFlag) == 0) {
position = tile.tilePos;
if ((tile._6 & 1) == 0) {
layer = 1;
} else {
layer = 2;
}
SetTileType(0x73, position, layer);
}
}
void CreateMinishEntrance(u32 tilePos) {
u32 x, y;
u32 tileID = 0x185;
for (y = 0; y <= 3; y++) {
for (x = 0; x <= 4; x++) {
SetTileType(tileID++, tilePos + x, 1);
}
tilePos += 0x40;
}
}
void sub_08018C58(u32 tilePos) {
u32 i;
for (i = 0; i < 6; i += 2, tilePos += 0x40) {
SetTileType(0x260 + i, tilePos, 1);
SetTileType(0x261 + i, tilePos + 1, 1);
}
}
Reference in New Issue View Git Blame Copy Permalink