mirror of
https://github.com/pret/pmd-red.git
synced 2026-03-21 17:46:39 -05:00
1028 lines
25 KiB
C
1028 lines
25 KiB
C
#include "global.h"
|
|
#include "globaldata.h"
|
|
#include "structs/str_ground_script.h"
|
|
#include "debug.h"
|
|
#include "data_script.h"
|
|
#include "event_flag.h"
|
|
#include "ground_script.h"
|
|
#include "ground_sprite.h"
|
|
#include "memory.h"
|
|
|
|
typedef struct GroundObject {
|
|
// size: 0x1C4
|
|
u8 unk0[4];
|
|
s16 id;
|
|
s16 unk6; // kind
|
|
s16 unk8; // scriptID / group
|
|
s8 unkA; // sector
|
|
u8 unkB;
|
|
PixelPos unkC;
|
|
PixelPos unk14;
|
|
s8 unk1C;
|
|
PixelPos unk20;
|
|
PixelPos unk28;
|
|
PixelPos unk30;
|
|
Action unk38;
|
|
u32 flags;
|
|
s8 direction;
|
|
PixelPos unk124;
|
|
PixelPos unk12C;
|
|
PixelPos unk134;
|
|
u8 directionRelated;
|
|
s16 unk13E;
|
|
s16 unk140;
|
|
struct UnkGroundSpriteStruct unk144;
|
|
} GroundObject;
|
|
|
|
IWRAM_INIT GroundObject *gGroundObjects = NULL;
|
|
|
|
struct GroundObjectTypeData
|
|
{
|
|
s16 unk0;
|
|
u8 unk2;
|
|
u8 unk3;
|
|
};
|
|
|
|
extern struct GroundObjectTypeData gGroundObjectTypes[];
|
|
|
|
void DeleteGroundObjects(void);
|
|
void GroundObject_Delete(s32);
|
|
|
|
const struct GroundScriptHeader *GetGroundScript(s16 a0, DebugLocation *);
|
|
void sub_80A7658(struct UnkGroundSpriteStruct *);
|
|
extern bool8 GroundScriptNotify(Action*, s32);
|
|
extern bool8 GroundScript_Cancel(Action *r0);
|
|
void SetPredefinedScript(Action *param_1, s16 index, const ScriptCommand *param_3);
|
|
|
|
extern bool8 GetCurrentDungeonBounds(PixelPos *a0, PixelPos *a1);
|
|
void sub_80A75CC(void *, s32, s32, s32);
|
|
bool8 SpriteHasPokemonSize_80A66A4(struct UnkGroundSpriteStruct *ptr);
|
|
|
|
|
|
s32 GroundObject_Add(s32 id_,const GroundObjectData *objectData,s32 group_,s32 sector_);
|
|
|
|
static s16 CallbackObjectGetIndex(void *ptr);
|
|
static void CallbackObjectGetSize(void *objectPtr_, PixelPos *out);
|
|
static void CallbackObjectSetHitboxPos(void *objectPtr_, PixelPos *posOrNull);
|
|
static void CallbackObjectSetPositionBounds(void *objectPtr_, PixelPos *from, PixelPos *to);
|
|
static void CallbackObjectGetHitboxCenter(void *objectPtr_, PixelPos *out);
|
|
static s32 CallbackObjectMoveReal(void *objectPtr_, PixelPos *pos);
|
|
static void CallbackObjectGetPosHeightAndUnk(void *objectPtr_, u32 *height, u32 *unk);
|
|
static void CallbackObjectSetPosHeight(void *objectPtr_, u32 height);
|
|
static void CallbackObjectGetDirection(void *objectPtr_, s8 *dir);
|
|
static void CallbackObjectSetDirection(void *objectPtr_, s32 dir_);
|
|
static void CallbackObjectSetEventIndex(void *objectPtr_, u16 a1);
|
|
static void CallbackObjectSetUnk_80AC998(void *objectPtr_, s32 a1_, s32 a2);
|
|
static bool8 CallbackObjectSpriteRelatedCheck_80AC9B8(void *objectPtr_);
|
|
static bool8 CallbackObjectSpriteRelated_80AC9DC(void *objectPtr_);
|
|
static void CallbackObjectGetFlags(void *objectPtr_, u32 *flags);
|
|
static void CallbackObjectSetFlags(void *objectPtr_, u32 flags);
|
|
static void CallbackObjectClearFlags(void *objectPtr_, u32 flags);
|
|
static s32 CallbackObjectMoveRelative(void *objectPtr_, PixelPos *pos);
|
|
|
|
|
|
static const CallbackData gGroundObjectCallbacks = {
|
|
.maybeId = 2,
|
|
.getIndex = CallbackObjectGetIndex,
|
|
.getSize = CallbackObjectGetSize,
|
|
.getHitboxCenter = CallbackObjectGetHitboxCenter,
|
|
.getPosHeightAndUnk = CallbackObjectGetPosHeightAndUnk,
|
|
.getDirection = CallbackObjectGetDirection,
|
|
.getFlags = CallbackObjectGetFlags,
|
|
.setHitboxPos = CallbackObjectSetHitboxPos,
|
|
.setPositionBounds = CallbackObjectSetPositionBounds,
|
|
.moveReal = CallbackObjectMoveReal,
|
|
.setPosHeight = CallbackObjectSetPosHeight,
|
|
.setDirection = CallbackObjectSetDirection,
|
|
.setEventIndex = CallbackObjectSetEventIndex,
|
|
.livesOnlyNullsub = NULL,
|
|
.func38 = CallbackObjectSetUnk_80AC998,
|
|
.setFlags = CallbackObjectSetFlags,
|
|
.clearFlags = CallbackObjectClearFlags,
|
|
.func44_livesOnlySpriteRelated = NULL,
|
|
.moveRelative = CallbackObjectMoveRelative,
|
|
.func4C_spriteRelatedCheck = CallbackObjectSpriteRelatedCheck_80AC9B8,
|
|
.func50_spriteRelated = CallbackObjectSpriteRelated_80AC9DC,
|
|
};
|
|
const u8 gGroundObjectFileName[];
|
|
#define FAKE_FILENAME gGroundObjectFileName
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static const struct ScriptCommand gUnknown_81182F4[] = {
|
|
DEBUGINFO, // Needs to be line 159
|
|
LABEL(0),
|
|
WAIT(0x78),
|
|
JUMP_LABEL(0),
|
|
};
|
|
ALIGNED(4) const u8 gGroundObjectFileName[] = "../ground/ground_object.c";
|
|
static const struct ScriptCommand gUnknown_8118350[] = {
|
|
DEBUGINFO, // Needs to be line 166
|
|
{ 0x54, 0, 1, 0, 0, NULL },
|
|
LABEL(0),
|
|
WAIT(0x78),
|
|
JUMP_LABEL(0),
|
|
};
|
|
|
|
const s16 gUnknown_81183A0[] = {
|
|
-1,
|
|
0x800,
|
|
0x801,
|
|
0x1000,
|
|
0x1001,
|
|
0x1002,
|
|
0x1003,
|
|
0x800,
|
|
0x801,
|
|
0x802,
|
|
0x803,
|
|
0x804,
|
|
0x805,
|
|
0x806,
|
|
0x807,
|
|
0x808,
|
|
0x809,
|
|
0x80A,
|
|
0x80B,
|
|
0x80C,
|
|
0x80D,
|
|
0x80E,
|
|
0x80F,
|
|
0};
|
|
|
|
void AllocGroundObjects(void)
|
|
{
|
|
|
|
GroundObject *ptr;
|
|
s32 index;
|
|
|
|
gGroundObjects = MemoryAlloc(sizeof(GroundObject) * 0x10, 6);
|
|
|
|
for(index = 0, ptr = &gGroundObjects[index]; index < 0x10; index = (s16)(index + 1), ptr++)
|
|
{
|
|
ptr->unk6 |= -1;
|
|
}
|
|
DeleteGroundObjects();
|
|
}
|
|
|
|
void DeleteGroundObjects(void)
|
|
{
|
|
GroundObject *ptr;
|
|
s32 index;
|
|
|
|
ptr = &gGroundObjects[0];
|
|
for(index = 0; index < 0x10; index = (s16)(index + 1), ptr++)
|
|
{
|
|
if(ptr->unk6 != -1)
|
|
GroundObject_Delete(index);
|
|
}
|
|
}
|
|
|
|
void FreeGroundObjects(void)
|
|
{
|
|
DeleteGroundObjects();
|
|
MemoryFree(gGroundObjects);
|
|
gGroundObjects = NULL;
|
|
}
|
|
|
|
void GroundObject_Select(s32 scriptID, s32 group, s32 sector)
|
|
{
|
|
const struct GroundScriptHeader *scriptPtr;
|
|
const struct GroundScriptSector *sectorPtr;
|
|
const struct GroundScriptGroup *groupPtr;
|
|
|
|
s32 i;
|
|
s32 size;
|
|
const GroundObjectData *objectData;
|
|
s32 sector_s32;
|
|
s32 group_s32;
|
|
s32 scriptID_s32;
|
|
|
|
scriptID_s32 = (s16)scriptID;
|
|
group_s32 = (s16)group;
|
|
sector_s32 = (s8)sector;
|
|
scriptPtr = GetGroundScript(scriptID_s32, DEBUG_LOC_PTR(gGroundObjectFileName, 0x126, "GroundObject_Select"));
|
|
Log(0,"GroundObject Select %3d %3d %3d", scriptID_s32, group_s32, sector_s32);
|
|
|
|
groupPtr = &scriptPtr->groups[group_s32];
|
|
sectorPtr = &groupPtr->sectors[sector_s32];
|
|
objectData = sectorPtr->objects;
|
|
|
|
size = sectorPtr->nObjects;
|
|
for (i = 0; i < size; i++, objectData++)
|
|
{
|
|
GroundObject_Add(-1,objectData,group_s32,sector_s32);
|
|
}
|
|
}
|
|
|
|
void GroundObject_Cancel(s32 scriptID, s32 sector)
|
|
{
|
|
s32 index;
|
|
GroundObject *ptr;
|
|
s32 sector_s32;
|
|
s32 scriptID_s32;
|
|
|
|
scriptID_s32 = (s16)scriptID;
|
|
sector_s32 = (s8) sector;
|
|
|
|
|
|
Log(0,"GroundObject Cancel %3d", scriptID_s32);
|
|
|
|
index = 0;
|
|
ptr = &gGroundObjects[0];
|
|
for(; index < 0x10; index = (s16)(index + 1), ptr++)
|
|
{
|
|
if((ptr->unk6 != -1) && (ptr->unk8 == scriptID_s32))
|
|
if(sector_s32 < 0 || ptr->unkA == sector_s32)
|
|
GroundObject_Delete(index);
|
|
}
|
|
}
|
|
|
|
void GroundObject_CancelBlank(void)
|
|
{
|
|
s32 index;
|
|
GroundObject *ptr;
|
|
PixelPos stack;
|
|
|
|
Log(0,"GroundObject CancelBlank");
|
|
|
|
index = 0;
|
|
ptr = &gGroundObjects[0];
|
|
for(; index < 0x10; index = (s16)(index + 1), ptr++)
|
|
{
|
|
if(ptr->unk6 != -1)
|
|
{
|
|
stack.x = ptr->unk124.x + ptr->unk14.x;
|
|
stack.y = ptr->unk124.y + ptr->unk14.y;
|
|
if(!IsOnscreen_80A675C(&ptr->unk144, &stack))
|
|
GroundObject_Delete(index);
|
|
}
|
|
}
|
|
}
|
|
|
|
s32 sub_80ABD48(s32 r0)
|
|
{
|
|
s32 index;
|
|
GroundObject *ptr;
|
|
|
|
s32 r0_s32 = (s16)r0;
|
|
|
|
index = 0;
|
|
ptr = &gGroundObjects[0];
|
|
for(; index < 0x10; index = (s16)(index + 1), ptr++)
|
|
{
|
|
if(ptr->unk6 == r0_s32) return index;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
s32 GroundObject_Add(s32 id_,const GroundObjectData *objectData,s32 group_,s32 sector_)
|
|
{
|
|
s32 sVar3;
|
|
s32 sVar4;
|
|
|
|
int index;
|
|
s32 kind;
|
|
GroundObject *parent;
|
|
register s32 id;
|
|
register s32 group;
|
|
register s32 sector;
|
|
bool8 bVar12;
|
|
struct GroundObjectTypeData *typeDataPtr;
|
|
|
|
id = (s16)id_;
|
|
group = (s16)group_;
|
|
sector = (s8)sector_;
|
|
|
|
|
|
|
|
kind = objectData->kind;
|
|
if (kind == 0x1a) {
|
|
if (GetScriptVarValue(NULL,BASE_LEVEL) < 2) {
|
|
kind = 0x1b;
|
|
}
|
|
else {
|
|
sVar4 = GetScriptVarValue(NULL,FLAG_KIND);
|
|
if (sVar4 == 0) {
|
|
sVar3 = GetScriptVarValue(NULL,BASE_KIND) + 0x1c;
|
|
}
|
|
else {
|
|
sVar3 = sVar4 + 0x2b;
|
|
}
|
|
kind = (s16)sVar3;
|
|
}
|
|
}
|
|
|
|
typeDataPtr = &gGroundObjectTypes[kind];
|
|
|
|
if (id < 0) {
|
|
|
|
switch(kind)
|
|
{
|
|
case 0xD:
|
|
case 0xE:
|
|
id = sub_80ABD48(kind);
|
|
break;
|
|
|
|
}
|
|
|
|
if (id < 0) {
|
|
for(index = 0, parent = gGroundObjects; index < 0x10; index = (s16)(index + 1), parent++)
|
|
{
|
|
if(parent->unk6 == -1)
|
|
{
|
|
id = index;
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
if (id < 0) {
|
|
return -1;
|
|
}
|
|
}
|
|
parent = &gGroundObjects[id];
|
|
Log(0,"GroundObject Add id %3d kind %3d[%3d] type %3d group %3d sector %3d",id,kind,objectData->kind,typeDataPtr->unk0,group,sector);
|
|
bVar12 = (parent->unk6 == -1);
|
|
parent->id = id;
|
|
parent->unk6 = kind;
|
|
parent->unk8 = group;
|
|
parent->unkA = sector;
|
|
switch(typeDataPtr->unk0) {
|
|
case 1:
|
|
case 0xB:
|
|
parent->flags = 0;
|
|
break;
|
|
case 0xA:
|
|
parent->flags = 0x20000;
|
|
break;
|
|
case 0xC:
|
|
parent->flags = 0x40000;
|
|
break;
|
|
case 0xF:
|
|
parent->flags = 0x20C0000;
|
|
break;
|
|
case 0xE:
|
|
parent->flags = 0x220C0000;
|
|
break;
|
|
case 0xD:
|
|
parent->flags = 0x20010000;
|
|
break;
|
|
case 9:
|
|
parent->flags = 5;
|
|
break;
|
|
case 3:
|
|
parent->flags = 0x22000184;
|
|
break;
|
|
case 4:
|
|
case 5:
|
|
parent->flags = 0x184;
|
|
break;
|
|
case 6:
|
|
parent->flags = 0x44;
|
|
break;
|
|
case 7:
|
|
parent->flags = 0x84;
|
|
break;
|
|
case 0x8:
|
|
parent->flags = 0x180;
|
|
break;
|
|
case 0x2:
|
|
parent->flags = 0x20000C4;
|
|
break;
|
|
default:
|
|
parent->flags = 0x2000185;
|
|
break;
|
|
}
|
|
|
|
if (typeDataPtr->unk2 == '\0') {
|
|
parent->unkC.x = objectData->width << 0xb;
|
|
parent->unkC.y = objectData->height << 0xb;
|
|
}
|
|
else {
|
|
parent->unkC.x = typeDataPtr->unk2 << 0xb;
|
|
parent->unkC.y = typeDataPtr->unk3 << 0xb;
|
|
}
|
|
|
|
parent->unk14.x = parent->unkC.x / 2;
|
|
parent->unk14.y = parent->unkC.y / 2;
|
|
parent->unk1C = objectData->unk1;
|
|
|
|
SetUnkInGroundEvent(&objectData->pos, &parent->unk20);
|
|
|
|
if (bVar12) {
|
|
parent->direction = parent->unk1C;
|
|
parent->unk124.x = parent->unk20.x - parent->unk14.x;
|
|
parent->unk12C.x = parent->unk20.x + parent->unk14.x;
|
|
parent->unk124.y = parent->unk20.y - parent->unk14.y;
|
|
parent->unk12C.y = parent->unk20.y + parent->unk14.y;
|
|
parent->unk134.x = parent->unk134.y = 0;
|
|
}
|
|
GetCurrentDungeonBounds(&parent->unk28,&parent->unk30);
|
|
if (bVar12) {
|
|
parent->unk13E = 0x800;
|
|
parent->directionRelated = 1;
|
|
parent->unk140 = 0;
|
|
sub_80A75CC(&(parent->unk144),id,parent->unk6, parent->flags);
|
|
}
|
|
|
|
InitActionWithParams(&parent->unk38,&gGroundObjectCallbacks,parent,group,sector);
|
|
|
|
// What an ugly way of coding that...
|
|
SetPredefinedScript(&parent->unk38,1, (objectData->scripts[1] != NULL) ? objectData->scripts[1]
|
|
: (SpriteHasPokemonSize_80A66A4(&parent->unk144)) ? gUnknown_8118350 : gUnknown_81182F4);
|
|
SetPredefinedScript(&parent->unk38,2,(objectData->scripts[2] != NULL) ? objectData->scripts[2]
|
|
: gFunctionScriptTable[4].script);
|
|
SetPredefinedScript(&parent->unk38,3,(objectData->scripts[3] != NULL) ? objectData->scripts[3]
|
|
: gFunctionScriptTable[8].script);
|
|
|
|
if (objectData->scripts[0] != NULL) {
|
|
SetPredefinedScript(&parent->unk38,0,objectData->scripts[0]);
|
|
ExecutePredefinedScript(&parent->unk38,NULL,0,DEBUG_LOC_PTR(gGroundObjectFileName, 0x283, "GroundObject_Add"));
|
|
}
|
|
return id;
|
|
}
|
|
|
|
|
|
void sub_80A6688(struct UnkGroundSpriteStruct *, s32);
|
|
|
|
void GroundObject_Delete(s32 index_) {
|
|
s32 index = (s16)index_;
|
|
GroundObject *parent = &gGroundObjects[index];
|
|
|
|
Log(0, "GroundObject Delete id %3d", index);
|
|
sub_80A7658(&parent->unk144);
|
|
InitAction2(&parent->unk38);
|
|
parent->unk6 = -1;
|
|
}
|
|
|
|
void sub_80AC1B0(s32 index_, s32 flag)
|
|
{
|
|
s32 index = (s16)index_;
|
|
GroundObject *parent = &gGroundObjects[index];
|
|
|
|
if(parent->unk6 != -1)
|
|
{
|
|
parent->flags |= flag;
|
|
sub_80A6688(&parent->unk144, parent->flags);
|
|
}
|
|
}
|
|
|
|
void sub_80AC1F4(s32 index_, s32 flag)
|
|
{
|
|
s32 index = (s16)index_;
|
|
GroundObject *parent = &gGroundObjects[index];
|
|
|
|
if(parent->unk6 != -1)
|
|
{
|
|
parent->flags &= (0x337fffff ^ flag);
|
|
sub_80A6688(&parent->unk144, parent->flags);
|
|
}
|
|
}
|
|
|
|
Action *sub_80AC240(s32 index_)
|
|
{
|
|
s32 index = (s16)index_;
|
|
GroundObject *parent = &gGroundObjects[index];
|
|
|
|
if(parent->unk6 != -1)
|
|
return &parent->unk38;
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
extern bool8 GetPredefinedScript(Action *param_1, ScriptInfoSmall *script, s32 _index);
|
|
|
|
|
|
bool8 sub_80AC274(s32 index_, ScriptInfoSmall *scriptInfo, s32 a2_)
|
|
{
|
|
s32 index = (s16)index_;
|
|
s32 a2 = (s16)a2_;
|
|
GroundObject *parent = &gGroundObjects[index];
|
|
|
|
if(parent->unk6 != -1)
|
|
return GetPredefinedScript(&parent->unk38, scriptInfo, a2);
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
extern DebugLocation gUnknown_8118504;
|
|
|
|
bool8 GroundObject_ExecuteScript(s32 index_, void *a1, ScriptInfoSmall *script)
|
|
{
|
|
s32 index = (s16)index_;
|
|
GroundObject *parent = &gGroundObjects[index];
|
|
|
|
Log(0, "GroundObject Execute %3d ", index);
|
|
|
|
if(parent->unk6 != -1)
|
|
{
|
|
GroundScript_ExecutePP(&parent->unk38, (ActionUnkIds *)a1, script, DEBUG_LOC_PTR(gGroundObjectFileName, 0x303, "GroundObject_ExecuteScript"));
|
|
parent->directionRelated = 1;
|
|
return 1;
|
|
}
|
|
else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
bool8 GroundObjectsNotifyAll(s32 index_)
|
|
{
|
|
s32 index = (s16)index_;
|
|
s32 counter;
|
|
GroundObject *parent = &gGroundObjects[0];
|
|
bool8 flag = FALSE;
|
|
|
|
for(counter = 0; counter < 0x10; counter = (s16)(counter + 1), parent++)
|
|
{
|
|
if(parent->unk6 != -1)
|
|
flag |= GroundScriptNotify(&parent->unk38, index);
|
|
}
|
|
|
|
return flag;
|
|
}
|
|
|
|
bool8 GroundObjectsCancelAll(void)
|
|
{
|
|
s32 counter;
|
|
GroundObject *parent = &gGroundObjects[0];
|
|
bool8 flag = FALSE;
|
|
|
|
for(counter = 0; counter < 0x10; counter = (s16)(counter + 1), parent++)
|
|
{
|
|
if(parent->unk6 != -1)
|
|
flag |= GroundScript_Cancel(&parent->unk38);
|
|
}
|
|
|
|
return flag;
|
|
}
|
|
|
|
static UNUSED s16 sub_80AC3C0(s32 index_)
|
|
{
|
|
s32 index = (s16)index_;
|
|
GroundObject *parent = &gGroundObjects[index];
|
|
return parent->unk6;
|
|
}
|
|
|
|
s16 sub_80AC3E0(s32 index_, s32 *a1)
|
|
{
|
|
s32 index = (s16)index_;
|
|
GroundObject *parent = &gGroundObjects[index];
|
|
*a1 = parent->flags;
|
|
return parent->unk6;
|
|
}
|
|
|
|
static UNUSED s16 sub_80AC408(s32 index_, PixelPos *a1)
|
|
{
|
|
s32 index = (s16)index_;
|
|
GroundObject *parent = &gGroundObjects[index];
|
|
if(parent->unk6 == -1)
|
|
{
|
|
a1->x = 0;
|
|
a1->y = 0;
|
|
}
|
|
else
|
|
{
|
|
*a1 = parent->unkC;
|
|
}
|
|
return parent->unk6;
|
|
}
|
|
|
|
s16 sub_80AC448(s32 index_, PixelPos *pos)
|
|
{
|
|
s32 index = (s16)index_;
|
|
GroundObject *parent = &gGroundObjects[index];
|
|
|
|
if(parent->unk6 == -1)
|
|
{
|
|
pos->x = 0;
|
|
pos->y = 0;
|
|
}
|
|
else {
|
|
pos->x = parent->unk124.x + parent->unk14.x;
|
|
pos->y = parent->unk124.y + parent->unk14.y;
|
|
}
|
|
|
|
return parent->unk6;
|
|
}
|
|
|
|
extern s32 TryMoveObjectRelative_80AC6AC(GroundObject *, PixelPos *);
|
|
|
|
|
|
s16 sub_80AC49C(s32 index_, PixelPos *pos)
|
|
{
|
|
s32 index = (s16)index_;
|
|
GroundObject *parent = &gGroundObjects[index];
|
|
|
|
TryMoveObjectRelative_80AC6AC(parent, pos);
|
|
|
|
return parent->unk6;
|
|
}
|
|
|
|
s32 sub_80AC4C8(s32 index, PixelPos *a0, PixelPos *a1) {
|
|
GroundObject *parent = &gGroundObjects[0];
|
|
s32 counter;
|
|
|
|
for(counter = 0; counter < 0x10; counter = (s16)(counter + 1), parent++)
|
|
{
|
|
if(parent->unk6 != -1)
|
|
{
|
|
if(parent->flags & index)
|
|
{
|
|
if((parent->unk124.x < a1->x) && (parent->unk12C.x > a0->x))
|
|
{
|
|
if((parent->unk124.y < a1->y) && (parent->unk12C.y > a0->y))
|
|
return counter;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
s32 sub_80AC554(s32 flag, PixelPos *param_2,PixelPos *param_3)
|
|
{
|
|
s32 i;
|
|
GroundObject *parent;
|
|
|
|
parent = &gGroundObjects[0];
|
|
for(i = 0; i < 0x10; i = (s16)(i + 1), parent++) {
|
|
if ((parent->unk6 != -1))
|
|
{
|
|
if((parent->flags & flag)) {
|
|
PixelPos pos = {(parent->unk124).x + (parent->unk14).x, (parent->unk124).y + (parent->unk14).y};
|
|
if ((pos.x < param_3->x) && (((pos.x > param_2->x))))
|
|
if(((pos.y < param_3->y)) && (pos.y > param_2->y)) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
bool8 CheckMapCollision_80A585C(PixelPos *, PixelPos *);
|
|
s32 GetLivesCollision_80A92A0(s32 id, u32 flags, PixelPos *, PixelPos *);
|
|
|
|
s32 GetObjectCollision_80AC5F4(GroundObject *param_1, PixelPos *param_2, PixelPos *param_3)
|
|
{
|
|
PixelPos local_28 = { param_2->x / 2048 , param_2->y / 2048 };
|
|
PixelPos iVar1 = { (param_3->x - 1) / 2048, (param_3->y - 1) / 2048 };
|
|
PixelPos local_20 = { (iVar1.x - local_28.x) + 1, (iVar1.y - local_28.y) + 1 };
|
|
|
|
if (param_1->flags & 1)
|
|
{
|
|
if(CheckMapCollision_80A585C(&local_28,&local_20))
|
|
return 1;
|
|
}
|
|
if (((param_1->flags & 4))) {
|
|
if(((s16)GetLivesCollision_80A92A0(-1,4,param_2,param_3) >= 0))
|
|
return 4;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
s32 TryMoveObjectRelative_80AC6AC(GroundObject *param_1,PixelPos *param_2)
|
|
{
|
|
PixelPos local_1c;
|
|
PixelPos local_14;
|
|
|
|
local_1c.x = param_2->x - (param_1->unk14).x;
|
|
local_1c.y = param_2->y - (param_1->unk14).y;
|
|
local_14.x = param_2->x + (param_1->unk14).x;
|
|
local_14.y = param_2->y + (param_1->unk14).y;
|
|
if ((((local_1c.x < param_1->unk28.x) || (local_14.x >= param_1->unk30.x)) ||
|
|
(local_1c.y < param_1->unk28.y)) || (local_14.y >= param_1->unk30.y)) {
|
|
return 1;
|
|
}
|
|
else {
|
|
s32 ret = GetObjectCollision_80AC5F4(param_1,&local_1c,&local_14);
|
|
if (ret == 0) {
|
|
(param_1->unk124) = local_1c;
|
|
param_1->unk12C = local_14;
|
|
return 0;
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
s32 TryMoveRelative_80AC720(GroundObject *param_1,PixelPos *param_2)
|
|
{
|
|
s32 ret;
|
|
bool8 bVar1;
|
|
PixelPos iVar2;
|
|
PixelPos uVar4;
|
|
|
|
iVar2.x = (param_1->unk124).x + param_2->x;
|
|
iVar2.y = (param_1->unk124).y + param_2->y;
|
|
uVar4.x = param_1->unk12C.x + param_2->x;
|
|
uVar4.y = param_1->unk12C.y + param_2->y;
|
|
|
|
bVar1 = 0;
|
|
|
|
|
|
if (iVar2.x < param_1->unk28.x) {
|
|
iVar2.x = param_1->unk28.x;
|
|
uVar4.x = param_1->unk28.x + param_1->unkC.x;
|
|
bVar1 = 1;
|
|
}
|
|
else {
|
|
if (uVar4.x >= param_1->unk30.x) {
|
|
iVar2.x = param_1->unk30.x - param_1->unkC.x;
|
|
uVar4.x = param_1->unk30.x;
|
|
bVar1 = 1;
|
|
}
|
|
}
|
|
|
|
if (iVar2.y < param_1->unk28.y) {
|
|
iVar2.y = param_1->unk28.y;
|
|
uVar4.y = param_1->unk28.y + param_1->unkC.y;
|
|
bVar1 = 1;
|
|
}
|
|
else {
|
|
if (uVar4.y >= param_1->unk30.y){
|
|
iVar2.y = param_1->unk30.y - param_1->unkC.y;
|
|
uVar4.y = param_1->unk30.y;
|
|
bVar1 = 1;
|
|
}
|
|
}
|
|
|
|
ret = GetObjectCollision_80AC5F4(param_1,&iVar2,&uVar4);
|
|
if (ret == 0) {
|
|
(param_1->unk124) = iVar2;
|
|
param_1->unk12C = uVar4;
|
|
if (!bVar1) {
|
|
return 0;
|
|
}
|
|
else {
|
|
return 1;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static s16 CallbackObjectGetIndex(void *ptr)
|
|
{
|
|
struct GroundObject *groundObject = ptr;
|
|
return groundObject->id;
|
|
}
|
|
|
|
static void CallbackObjectGetSize(void *objectPtr_, PixelPos *out)
|
|
{
|
|
struct GroundObject *objectPtr = objectPtr_;
|
|
*out = objectPtr->unkC;
|
|
}
|
|
|
|
static void CallbackObjectSetHitboxPos(void *objectPtr_, PixelPos *posOrNull)
|
|
{
|
|
struct GroundObject *objectPtr = objectPtr_;
|
|
|
|
if (posOrNull != NULL) {
|
|
objectPtr->unk124.x = posOrNull->x - objectPtr->unk14.x;
|
|
objectPtr->unk12C.x = posOrNull->x + objectPtr->unk14.x;
|
|
objectPtr->unk124.y = posOrNull->y - objectPtr->unk14.y;
|
|
objectPtr->unk12C.y = posOrNull->y + objectPtr->unk14.y;
|
|
}
|
|
else {
|
|
objectPtr->unk124.x = objectPtr->unk20.x - objectPtr->unk14.x;
|
|
objectPtr->unk12C.x = objectPtr->unk20.x + objectPtr->unk14.x;
|
|
objectPtr->unk124.y = objectPtr->unk20.y - objectPtr->unk14.y;
|
|
objectPtr->unk12C.y = objectPtr->unk20.y + objectPtr->unk14.y;
|
|
objectPtr->unk134.x = objectPtr->unk134.y = 0;
|
|
if (objectPtr->direction != objectPtr->unk1C) {
|
|
objectPtr->directionRelated = TRUE;
|
|
}
|
|
objectPtr->direction = objectPtr->unk1C;
|
|
}
|
|
}
|
|
|
|
static void CallbackObjectSetPositionBounds(void *objectPtr_, PixelPos *from, PixelPos *to)
|
|
{
|
|
struct GroundObject *objectPtr = objectPtr_;
|
|
|
|
objectPtr->unk28 = *from;
|
|
objectPtr->unk30 = *to;
|
|
}
|
|
|
|
static void CallbackObjectGetHitboxCenter(void *objectPtr_, PixelPos *out)
|
|
{
|
|
struct GroundObject *objectPtr = objectPtr_;
|
|
|
|
out->x = objectPtr->unk124.x + objectPtr->unk14.x;
|
|
out->y = objectPtr->unk124.y + objectPtr->unk14.y;
|
|
}
|
|
|
|
static s32 CallbackObjectMoveReal(void *objectPtr_, PixelPos *pos)
|
|
{
|
|
struct GroundObject *objectPtr = objectPtr_;
|
|
return TryMoveObjectRelative_80AC6AC(objectPtr, pos);
|
|
}
|
|
|
|
static void CallbackObjectGetPosHeightAndUnk(void *objectPtr_, u32 *height, u32 *unk)
|
|
{
|
|
struct GroundObject *objectPtr = objectPtr_;
|
|
|
|
*height = objectPtr->unk134.x;
|
|
*unk= objectPtr->unk134.y;
|
|
}
|
|
|
|
static void CallbackObjectSetPosHeight(void *objectPtr_, u32 height)
|
|
{
|
|
struct GroundObject *objectPtr = objectPtr_;
|
|
objectPtr->unk134.x = height;
|
|
|
|
}
|
|
|
|
static void CallbackObjectGetDirection(void *objectPtr_, s8 *dir)
|
|
{
|
|
struct GroundObject *objectPtr = objectPtr_;
|
|
*dir = objectPtr->direction;
|
|
|
|
}
|
|
|
|
static void CallbackObjectSetDirection(void *livesPtr_, s32 direction)
|
|
{
|
|
struct GroundObject *livesPtr = livesPtr_;
|
|
s32 dir = (s8) direction;
|
|
|
|
if (dir != -1) {
|
|
livesPtr->direction = dir;
|
|
}
|
|
}
|
|
|
|
static void CallbackObjectSetEventIndex(void *livesPtr_, u16 a1) {
|
|
struct GroundObject *livesPtr = livesPtr_;
|
|
|
|
u32 r1;
|
|
u16 f1 = a1 & 0xFF;
|
|
|
|
if (f1 != 0)
|
|
{
|
|
r1 = gUnknown_81183A0[f1];
|
|
}
|
|
else
|
|
{
|
|
r1 = livesPtr->unk13E;
|
|
}
|
|
|
|
if(livesPtr->unk13E != (s16) r1)
|
|
{
|
|
livesPtr->unk13E = r1;
|
|
livesPtr->directionRelated = 1;
|
|
}
|
|
else if((livesPtr->unk13E & 0x1000))
|
|
livesPtr->directionRelated = 1;
|
|
}
|
|
|
|
|
|
static void CallbackObjectSetUnk_80AC998(void *objectPtr_, s32 a1_, s32 a2) {
|
|
struct GroundObject *livesPtr = objectPtr_;
|
|
|
|
s32 a1Match = (s16) a1_;
|
|
#ifndef NONMATCHING
|
|
register s16 a1 asm("r2") = a1Match;
|
|
#else
|
|
s32 a1 = a1Match;
|
|
#endif
|
|
|
|
if (a1Match == 0) {
|
|
a1 = 448;
|
|
}
|
|
|
|
livesPtr->unk140 = a1;
|
|
}
|
|
|
|
extern bool8 sub_80A66F8(struct UnkGroundSpriteStruct *ptr);
|
|
extern bool8 sub_80A671C(struct UnkGroundSpriteStruct *ptr);
|
|
|
|
static bool8 CallbackObjectSpriteRelatedCheck_80AC9B8(void *objectPtr_)
|
|
{
|
|
struct GroundObject *livesPtr = objectPtr_;
|
|
|
|
if (livesPtr->directionRelated) {
|
|
return TRUE;
|
|
}
|
|
else {
|
|
return sub_80A66F8(&livesPtr->unk144);
|
|
}
|
|
}
|
|
|
|
static bool8 CallbackObjectSpriteRelated_80AC9DC(void *objectPtr_)
|
|
{
|
|
struct GroundObject *livesPtr = objectPtr_;
|
|
|
|
if (livesPtr->unk140 != 0) {
|
|
return TRUE;
|
|
}
|
|
else {
|
|
return sub_80A671C(&livesPtr->unk144);
|
|
}
|
|
}
|
|
|
|
static void CallbackObjectGetFlags(void *livesPtr_, u32 *flags)
|
|
{
|
|
struct GroundObject *livesPtr = livesPtr_;
|
|
|
|
*flags = livesPtr->flags;
|
|
}
|
|
|
|
static void CallbackObjectSetFlags(void *livesPtr_, u32 flags)
|
|
{
|
|
struct GroundObject *livesPtr = livesPtr_;
|
|
|
|
sub_80AC1B0(livesPtr->id, flags);
|
|
}
|
|
|
|
static void CallbackObjectClearFlags(void *livesPtr_, u32 flags)
|
|
{
|
|
struct GroundObject *livesPtr = livesPtr_;
|
|
|
|
sub_80AC1F4(livesPtr->id, flags);
|
|
}
|
|
|
|
static s32 CallbackObjectMoveRelative(void *livesPtr_, PixelPos *pos)
|
|
{
|
|
struct GroundObject *livesPtr = livesPtr_;
|
|
|
|
return TryMoveRelative_80AC720(livesPtr, pos);
|
|
}
|
|
|
|
extern s16 HandleAction(Action *action, DebugLocation *debug);
|
|
|
|
void GroundObject_Action(void)
|
|
{
|
|
GroundObject *objectPtr;
|
|
s32 i;
|
|
s32 ret;
|
|
|
|
for (objectPtr = &gGroundObjects[0], i = 0; i < 0x10; i = (s16)(i + 1), objectPtr++)
|
|
{
|
|
if (objectPtr->unk6 != -1) {
|
|
ret = HandleAction(&objectPtr->unk38, DEBUG_LOC_PTR(gGroundObjectFileName, 0x60D, "GroundObject_Action"));
|
|
switch(ret)
|
|
{
|
|
case 4:
|
|
GroundObject_Delete(i);
|
|
continue;
|
|
case 0:
|
|
ExecutePredefinedScript(&objectPtr->unk38, NULL, 1, DEBUG_LOC_PTR(gGroundObjectFileName, 0x617, "GroundObject_Action"));
|
|
break;
|
|
}
|
|
|
|
if (objectPtr->directionRelated) {
|
|
objectPtr->directionRelated = FALSE;
|
|
sub_80A6EFC(&objectPtr->unk144,objectPtr->unk13E & 0x1f00,(s8)objectPtr->unk13E);
|
|
}
|
|
}
|
|
}
|
|
}
|