mirror/st
1
0
Fork 0
mirror of https://github.com/zeldaret/st synced 2026-08-05 09:34:10 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
f90c7cd5311d89505b56391cd10cfde49f83d324
st/src/031_Land/Actor/ActorShotArrow.cpp
T
Alessevan f90c7cd531 Decompiling some actors and objects of overlay 031 (#123) 
* feat: decompiling skdo

* feat: update

* fix: match back .data of doors

* feat: fully decompiled SWCH for eur missing bss for JP

* feat: increase matching code

* feat: decompile most part of SCCN

* feat: update

* feat: progress sccn jap data

* feat: progress decompiling

* fix: build issues

* feat: increase matching

* refactor: rename BLST to Blast

* feat: increase grss

* refactor: rename unkgrss to grass

* refactor: rename id

* refactor: change to fx32

* feat: complete RMTG actor

* refactor: use ARRAY_LENGTH macro
2026-08-02 14:09:49 +02:00

1148 lines
35 KiB
C++
Raw Blame History

#include "Actor/ActorShotArrow.hpp"
#include "Actor/ActorManager.hpp"
#include "Actor/ActorUnkGYAM.hpp"
#include "Actor/ActorUnkIWTS.hpp"
#include "Actor/ActorUnkMRD2.hpp"
#include "System/OverlayManager.hpp"
#include "System/SysNew.hpp"
#include "Unknown/UnkStruct_027e09a8.hpp"
#include "Unknown/UnkStruct_027e09b4.hpp"
#include "Unknown/UnkStruct_027e09bc.hpp"
#include "Unknown/UnkStruct_027e09c0.hpp"
#include "Unknown/UnkStruct_027e0cd8.hpp"
#include "Unknown/UnkStruct_027e0ce0.hpp"
#include "Unknown/UnkStruct_027e0cec.hpp"
#include "Unknown/UnkStruct_027e0d30.hpp"
typedef struct UnkResourceStruct2 {
/* 00 */ unk32 mUnk_00;
/* 04 */ unk32 mUnk_04;
/* 08 */ unk32 mUnk_08;
/* 0C */
} UnkResourceStruct2;
typedef struct {
/* 00 */ VecFx32 mUnk_00;
/* 0C */ VecFx32 mUnk_0C;
/* 18 */ unk32 mUnk_18;
/* 1C */ VecFx32 mUnk_1C;
/* 28 */ VecFx32 mUnk_28;
/* 34 */
} UnkStruct_020f374c;
typedef struct {
/* 00 */ STRUCT_PAD(0x00, 0x04);
/* 04 */ ActorRef mUnk_04;
/* 08 */ unk32 mUnk_08;
/* 0C */ Mat4x3p *mUnk_0C;
/* 10 */ VecFx32 mUnk_10;
/* 1C */ VecFx32 mUnk_1C;
/* 28 */
} UnkStruct_020f38b0;
typedef struct {
/* 00 */ STRUCT_PAD(0x00, 0x04);
/* 04 */ VecFx32 mUnk_04;
/* 10 */ STRUCT_PAD(0x10, 0x14);
/* 14 */ VecFx32 mUnk_14;
/* 20 */
} UnkStruct_020f3c38;
typedef struct {
/* 000 */ STRUCT_PAD(0x0, 0x25B);
/* 25B */ bool mUnk_25B;
/* 25C */
} UnkStruct_ov060_02163ff4;
typedef struct {
/* 0C */ Mat3p mUnk_0C;
/* 30 */ Mat3p mUnk_30;
/* 54 */ VecFx32 mUnk_54;
/* 60 */ Mat3p mUnk_60;
/* 84 */ Mat4x3p mUnk_84;
/* B4 */ Mat4x3p mUnk_B4;
/* E4 */ VecFx32 mUnk_E4;
/* F0 */ fx32 mUnk_F0;
} UnkStack_ov031_020f2310;
struct UnkStruct_020f1b04 {
/* 0C */ Actor *mUnk_0C;
/* 10 */ STRUCT_PAD(0x10, 0x24);
/* 24 */
};
extern "C" u8 data_ov031_02110b01[]; // = {0x08, 0x02, 0x02, 0x0C, 0x04, 0x00};
extern "C" char data_ov031_02110b3c[0x10]; // = "arrow";
extern "C" char data_ov031_02110b4c[0x10]; // = "arrow_s";
extern "C" char data_ov031_02110b5c[0x14]; // = "ef_arrowB";
extern "C" char data_ov031_02110b08[0x34]; // = "ef_arrowB";
extern Mat4x3p data_027e0964;
extern ActorUnkIWTS *data_027e0d80;
extern bool data_ov060_02163fe0;
extern UnkStruct_ov060_02163ff4 data_ov060_02163ff4;
extern ActorUnkMRD2 *data_ov075_02163518;
extern "C" unk32 func_01ff9258(fx32, fx32);
extern "C" void func_01ff93c0(VecFx32 *, unk32);
extern "C" void func_01ff94cc(VecFx32 *, VecFx32 *, VecFx32 *);
extern "C" void func_01ff95a0(VecFx32 *, unk16);
extern "C" void func_01ff9638(VecFx32 *vec, s16 angle);
extern "C" void func_01ffa7a0(VecFx32 *, Mat3p *, VecFx32 *);
extern "C" void func_01ffa9e8(Mat4x3p *, Mat4x3p *);
extern "C" void func_01ffad5c(Mat4x3p *, Mat4x3p *, Mat4x3p *);
extern "C" void func_01ffb714(VecFx32 *, VecFx32 *, VecFx32 *);
extern "C" fx16 func_01ffbbe0(fx32, fx32);
extern "C" bool func_01ffccf4(Cylinder *, VecFx32 *, VecFx32 *, unk32 *);
extern "C" void func_01ffe6c4(Actor **, ActorRef, VecFx32 *, VecFx32 *, s32, VecFx32 *, unk32);
extern "C" void func_0200eab0(G3d_Model *, unk16, u8);
extern "C" UnkResourceStruct2 *func_0200f05c(G3d_NameList *, char *);
extern "C" bool func_ov000_0205aeac();
extern "C" void func_ov000_0207b6c0();
extern "C" unk32 func_ov000_0207df88(unk32 *, Cylinder *, unk32);
extern "C" void func_ov075_02160864(ActorShotArrow *, unk32);
extern "C" void GX_func_02024a84(Mat3p *param1);
extern "C" void CopySingle288(Mat4x3p *, Mat3p *);
extern "C" void func_01ffa60c(const Mat3p *, Mat3p *, Mat3p *);
MapObjectProfile_Derived2_20_Base *func_ov031_020f1404() {
return data_027e0ce0->mUnk_1C->mUnk_08[PlayerCharacter_Link][1];
}
DECL_PROFILE(ActorProfileShotArrow);
Actor *ActorProfileShotArrow::Create() {
return new(HeapIndex_2) ActorShotArrow();
}
ActorProfileShotArrow::ActorProfileShotArrow() :
ActorProfile(ActorId_ShotArrow) {
this->mUnk_04.Init(FLOAT_TO_FX32(0.2f));
}
ActorShotArrow::ActorShotArrow() :
mUnk_9C(true),
mUnk_A0(GetModelFromProfile3(func_ov031_020f1404(), data_ov031_02110b5c)),
mUnk_100(&this->mUnk_120, GetModelFromProfile3(func_ov031_020f1404(), data_ov031_02110b5c),
func_ov031_020f1404()->func_ov000_02058a84(0, data_ov031_02110b08)),
mUnk_140(this),
mUnk_168(0),
mUnk_16C(0),
mUnk_170(0x1F),
mUnk_172(0x1F),
mUnk_174(0),
mUnk_176(0),
mUnk_178(this),
mUnk_194(this),
mUnk_1DC(0x548, 0),
mUnk_258(0) {
this->mUnk_140.mUnk_04 |= 0x8000;
this->mUnk_140.mUnk_24 = true;
this->mUnk_224 = 0;
this->mUnk_25B = false;
this->mUnk_25C = false;
this->mUnk_25D = false;
bool var_r1_2 = true;
if (this->mUnk_5C.mParams[1] != 3 && this->mUnk_5C.mParams[1] != 4) {
var_r1_2 = false;
}
if (var_r1_2) {
this->func_ov031_020f2794(2);
} else {
this->func_ov031_020f2794(0);
}
if (gOverlayManager.IsPirateHideout() && data_ov060_02163fe0) {
this->mUnk_25C = true;
}
}
ActorShotArrow::~ActorShotArrow() {
if (func_ov000_0205aeac()) {
bool paramIs3Or4 = this->mUnk_5C.mParams[1] == 0x3 || this->mUnk_5C.mParams[1] == 0x4;
if (paramIs3Or4) {
data_027e0cd8->mUnk_0C->func_ov000_02080a78(&this->mUnk_1DC.mUnk_00);
}
}
}
bool ActorShotArrow::vfunc_18(unk32 param1) {
fx32 sin_value = SIN((u16) this->mAngle);
fx32 cos_value = COS((u16) this->mAngle);
this->mUnk_2C = 0;
this->mVel.x = MUL_FX32(sin_value, 1024);
this->mVel.z = MUL_FX32(cos_value, 1024);
this->mVel.y = 0;
this->mUnk_16C = VecFx32_Length(&this->mVel);
if (func_ov000_0205aeac()) {
bool paramIs3Or4 = this->mUnk_5C.mParams[1] == 0x3 || this->mUnk_5C.mParams[1] == 0x4;
if (paramIs3Or4) {
VecFx32_Copy(&this->mPos, &this->mUnk_1DC.mUnk_00);
data_027e0cd8->mUnk_0C->func_ov000_02080a5c(&this->mUnk_1DC.mUnk_00);
}
}
this->SetState(ActorShotArrowState_0);
this->mUnk_194.mUnk_04 = this->mRef.Get32();
VecFx32_Copy(&this->mPos, &this->mUnk_194.mUnk_0C.pos);
this->mUnk_194.mUnk_0C.size = FLOAT_TO_FX32(0.20f);
this->mUnk_44 = 0x1F;
return true;
}
void ActorShotArrow::func_ov031_020f1868() {
this->mUnk_2C = 0;
}
void ActorShotArrow::func_ov031_020f1874() {}
static PTMF<ActorShotArrow> data_ov031_021142c0[ActorShotArrowState_Max] = {
ActorShotArrow::func_ov031_020f1a64, // ActorShotArrowState_0
ActorShotArrow::func_ov031_020f1c24, // ActorShotArrowState_1
ActorShotArrow::func_ov031_020f1dd4, // ActorShotArrowState_2
ActorShotArrow::func_ov031_020f1f54, // ActorShotArrowState_3
ActorShotArrow::func_ov031_020f206c, // ActorShotArrowState_4
ActorShotArrow::func_ov031_020f2134, // ActorShotArrowState_5
ActorShotArrow::func_ov031_020f21dc, // ActorShotArrowState_6
ActorShotArrow::func_ov031_020f1874 // ActorShotArrowState_7
};
void ActorShotArrow::SetState(ActorShotArrowState state) {
this->mState = state;
this->func_ov031_020f1868();
CALL_PTMF(PTMF<ActorShotArrow>, data_ov031_021142c0[this->mState]);
}
void ActorShotArrow::vfunc_24() {
if (this->mUnk_25A) {
if (this->mUnk_25E < 0x1F) {
if ((this->mUnk_25E = this->mUnk_25E + 0x4 & 0xFF) >= 0x1F) {
this->mUnk_25E = 0x1F;
}
}
this->mUnk_100.func_01ffc3b4();
}
if (func_ov000_0205aeac() != 0) {
bool paramIs3Or4 = this->mUnk_5C.mParams[1] == 0x3 || this->mUnk_5C.mParams[1] == 0x4;
if (paramIs3Or4) {
this->func_ov031_020f3000();
}
}
if (this->mState != ActorShotArrowState_1 && this->mState != ActorShotArrowState_2 &&
this->mState != ActorShotArrowState_3) {
return;
}
this->func_ov031_020f3258(0x1);
this->func_ov031_020f2280();
}
void ActorShotArrow::func_ov031_020f1958() {}
static PTMF<ActorShotArrow> data_ov031_02114300[ActorShotArrowState_Max] = {
ActorShotArrow::func_ov031_020f1b04, // ActorShotArrowState_0
ActorShotArrow::func_ov031_020f1c7c, // ActorShotArrowState_1
ActorShotArrow::func_ov031_020f1e3c, // ActorShotArrowState_2
ActorShotArrow::func_ov031_020f2010, // ActorShotArrowState_3
ActorShotArrow::func_ov031_020f20bc, // ActorShotArrowState_4
ActorShotArrow::func_ov031_020f2160, // ActorShotArrowState_5
ActorShotArrow::func_ov031_020f2214, // ActorShotArrowState_6
ActorShotArrow::func_ov031_020f1958 // ActorShotArrowState_7
};
void ActorShotArrow::vfunc_20() {
this->mUnk_3C = &this->mUnk_140;
CALL_PTMF(PTMF<ActorShotArrow>, data_ov031_02114300[this->mState]);
if (this->mUnk_25A) {
if (this->mUnk_25E < 0x1F && (this->mUnk_25E = this->mUnk_25E + 0x4 & 0xFF) >= 0x1F) {
this->mUnk_25E = 0x1F;
}
this->mUnk_100.func_01ffc3b4();
}
if (func_ov000_0205aeac()) {
bool paramIs3Or4 = this->mUnk_5C.mParams[1] == 0x3 || this->mUnk_5C.mParams[1] == 0x4;
if (paramIs3Or4) {
if (this->mUnk_170 > 0x10) {
this->func_ov031_020f3000();
} else {
data_027e0cd8->mUnk_0C->func_ov000_02080a78(&this->mUnk_1DC.mUnk_00);
}
}
}
if (this->mUnk_178.mUnk_18 & 0x1) {
this->func_ov031_020f2cac(&this->mUnk_178.mUnk_0C, true);
this->mUnk_178.func_ov031_020f3304();
}
this->func_ov031_020f229c();
}
// non-matching
void ActorShotArrow::func_ov031_020f1a64() {
if (this->mUnk_5C.mParams[1] == 0x1 || this->mUnk_5C.mParams[1] == 0x4) {
this->mUnk_50 = 0x0;
this->mUnk_52 = 0x78;
} else {
this->mUnk_50 = 0x0;
this->mUnk_52 = 0x3C;
}
unk32 value_func_020f2270 = this->func_ov031_020f2270();
unk16 sin_value = SIN((u16) this->mAngle);
unk16 cos_value = COS((u16) this->mAngle);
this->mVel.x = MUL_FX32(sin_value, value_func_020f2270);
this->mVel.y = FLOAT_TO_FX32(0.0f);
this->mVel.z = MUL_FX32(cos_value, value_func_020f2270);
}
// non-matching
void ActorShotArrow::func_ov031_020f1b04() {
UnkStruct_020f1b04 stack;
if (this->IsTimerOut()) {
this->SetState(ActorShotArrowState_6);
return;
}
this->func_ov031_020f28ac();
this->func_ov000_02098838();
VecFx32_Copy(&this->mPos, &this->mPrevPos);
VecFx32_Add(&this->mPos, &this->mVel, &this->mPos);
this->mUnk_16C = VecFx32_Length(&this->mVel);
if (this->mUnk_5C.mParams[1] == 0x1 || this->mUnk_5C.mParams[1] == 0x4) {
data_027e0d30->func_ov031_020d9684(this->mUnk_5C.mParams[2], &this->mPos);
}
if (!this->func_ov017_020beeec(0x0)) {
stack.mUnk_0C = NULL;
VecFx32 *mPos = &this->mPos;
func_01ffe6c4(&stack.mUnk_0C, this->mRef, mPos, &this->mPrevPos, (s16) this->mUnk_44, mPos, 0);
if (this->func_ov000_0207e294(this->mUnk_30)) {
this->Kill();
}
return;
}
this->func_ov031_020f2ef0();
}
void ActorShotArrow::func_ov031_020f1c24() {
this->mVel.x = FLOAT_TO_FX32(0.0f);
this->mVel.y = FLOAT_TO_FX32(0.0f);
this->mVel.z = FLOAT_TO_FX32(0.0f);
this->func_ov031_020f2794(0x1);
this->mUnk_174 = 0x1555;
data_027e09a8->func_ov000_02071b30(0x8D7A, &this->mPos, 0);
this->mUnk_16C = 0;
}
// non-matching
void ActorShotArrow::func_ov031_020f1c7c() {
if (this->func_ov031_020f3210(0x1)) {
this->Kill();
}
if (this->mUnk_1C8.mUnk_00 && GET_FLAG(this->mUnk_1C8.mUnk_00->mFlags, ActorFlag_Alive) &&
!GET_FLAG(this->mUnk_1C8.mUnk_00->mFlags, ActorFlag_18)) {
VecFx32_Copy(&this->mUnk_1C8.mUnk_00->mPos, &this->mPos);
s16 delta = this->mUnk_1C8.mUnk_00->mAngle - this->mUnk_1C8.mUnk_10;
VecFx32 vec_fx32 = this->mUnk_1C8.mUnk_04;
func_01ff9638(&vec_fx32, delta);
VecFx32_Add(&this->mPos, &vec_fx32, &this->mPos);
this->mAngle = this->mUnk_1C8.mUnk_00->mAngle + (s16) (this->mUnk_1C8.mUnk_12 - this->mUnk_1C8.mUnk_10);
} else {
this->func_ov031_020f2c08(0x400);
}
this->func_ov031_020f2280();
this->func_ov000_02098838();
VecFx32_Copy(&this->mPos, &this->mPrevPos);
VecFx32_Add(&this->mPos, &this->mVel, &this->mPos);
if (func_ov000_0205aeac() && (this->mUnk_5C.mParams[1] == 0x3 || this->mUnk_5C.mParams[1] == 0x4) != false) {
data_027e0cd8->mUnk_0C->func_ov000_02080a78(&this->mUnk_1DC.mUnk_00);
}
}
void ActorShotArrow::func_ov031_020f1dd4() {
this->mVel.x = FLOAT_TO_FX32(0.0f);
this->mVel.y = FLOAT_TO_FX32(0.0f);
this->mVel.z = FLOAT_TO_FX32(0.0f);
this->func_ov031_020f2794(0x1);
this->mUnk_174 = 0x1555;
data_027e09a8->func_ov000_02071b30(0x8D7A, &this->mPos, 0);
this->mUnk_16C = 0;
this->mUnk_50 = 0;
this->mUnk_52 = this->mUnk_258;
}
void ActorShotArrow::func_ov031_020f1e3c() {
if (!this->mUnk_25B && this->IsTimerOut()) {
if (this->func_ov031_020f3210(0x1)) {
this->Kill();
return;
}
this->mUnk_52 = this->mUnk_258;
this->mUnk_50 = 0;
}
Actor *targetActor = this->mUnk_1C8.mUnk_00;
if (targetActor == NULL || !GET_FLAG(targetActor->mFlags, ActorFlag_Alive) ||
GET_FLAG(targetActor->mFlags, ActorFlag_18)) {
this->func_ov031_020f2c08(0x400);
}
this->func_ov031_020f2280();
this->func_ov000_02098838();
VecFx32_Copy(&this->mPos, &this->mPrevPos);
VecFx32_Add(&this->mPos, &this->mVel, &this->mPos);
if (!func_ov000_0205aeac()) {
return;
}
bool paramIs3Or4 = this->mUnk_5C.mParams[1] == 0x3 || this->mUnk_5C.mParams[1] == 0x4;
if (!paramIs3Or4) {
return;
}
data_027e0cd8->mUnk_0C->func_ov000_02080a78(&this->mUnk_1DC.mUnk_00);
}
void ActorShotArrow::func_ov031_020f1f54() {
this->mVel.x = FLOAT_TO_FX32(0.0f);
this->mVel.y = FLOAT_TO_FX32(0.0f);
this->mVel.z = FLOAT_TO_FX32(0.0f);
this->func_ov031_020f2794(0x1);
this->mUnk_174 = 0x1555;
data_027e09a8->func_ov000_02071b30(0x8D7A, &this->mPos, 0);
this->mUnk_16C = 0;
if (func_ov000_0205aeac()) {
bool paramIs3Or4 = this->mUnk_5C.mParams[1] == 0x3 || this->mUnk_5C.mParams[1] == 0x4;
if (paramIs3Or4) {
data_027e0cd8->mUnk_0C->func_ov000_02080a78(&this->mUnk_1DC.mUnk_00);
}
}
if (this->mUnk_25C && !this->mUnk_25D) {
data_ov060_02163ff4.mUnk_25B = true;
}
}
void ActorShotArrow::func_ov031_020f2010() {
if (this->func_ov031_020f3210(0x1) != 0) {
this->Kill();
}
this->func_ov031_020f2280();
this->func_ov000_02098838();
VecFx32_Copy(&this->mPos, &this->mPrevPos);
VecFx32_Add(&this->mPos, &this->mVel, &this->mPos);
}
void ActorShotArrow::func_ov031_020f206c() {
this->func_ov031_020f2794(0);
this->mUnk_170 = 0x10;
this->mUnk_16C = 0;
this->mUnk_168 = 0;
if (this->mUnk_25C && !this->mUnk_25D) {
data_ov060_02163ff4.mUnk_25B = true;
}
}
void ActorShotArrow::func_ov031_020f20bc() {
if (this->func_ov031_020f3210(0x1) != 0) {
this->Kill();
}
this->mUnk_176 += -0x11C7;
this->mVel.y -= FLOAT_TO_FX32(0.002f);
this->func_ov000_02098838();
VecFx32_Copy(&this->mPos, &this->mPrevPos);
VecFx32_Add(&this->mPos, &this->mVel, &this->mPos);
}
void ActorShotArrow::func_ov031_020f2134() {
data_027e09a8->func_ov000_02071b30(0x8D7A, &this->mPos, 0);
}
void ActorShotArrow::func_ov031_020f2160() {
if (!this->mUnk_1C8.mUnk_00 || !GET_FLAG(this->mUnk_1C8.mUnk_00->mFlags, ActorFlag_Alive)) {
this->func_ov031_020f2c08(0x400);
return;
}
this->func_ov000_02098838();
VecFx32_Copy(&this->mPos, &this->mPrevPos);
VecFx32_Add(&this->mPos, &this->mVel, &this->mPos);
this->mUnk_16C = VecFx32_Length(&this->mVel);
this->func_ov031_020f2f9c();
this->func_ov031_020f2ef0();
}
void ActorShotArrow::func_ov031_020f21dc() {
this->mUnk_172 = 0;
this->mUnk_16C = 0;
if (this->mUnk_25C && !this->mUnk_25D) {
data_ov060_02163ff4.mUnk_25B = true;
}
}
void ActorShotArrow::func_ov031_020f2214() {
if (this->mUnk_170 > (s16) 0x4) {
this->mUnk_170 -= 0x4;
} else {
this->Kill();
}
this->func_ov000_02098838();
VecFx32_Copy(&this->mPos, &this->mPrevPos);
VecFx32_Add(&this->mPos, &this->mVel, &this->mPos);
}
unk32 ActorShotArrow::func_ov031_020f2270() {
return (this->mUnk_5C.mParams[0] << 0x4) + 0x400;
}
void ActorShotArrow::func_ov031_020f2280() {
this->mUnk_174 = (-this->mUnk_174 * 15) >> 4;
}
void ActorShotArrow::func_ov031_020f229c() {
this->mUnk_168 = MUL_FX32(this->mUnk_168 + this->mUnk_16C, FLOAT_TO_FX32(0.8f));
}
void ActorShotArrow::func_ov031_020f22d4(Mat3p *param1, VecFx32 *param2) {
func_0200eab0(this->mUnk_A0.mpModel, 0x0, this->mUnk_25E);
this->mUnk_A0.vfunc_14(param1, param2);
}
// non-matching
void ActorShotArrow::vfunc_2C(unk32 param1) {
UnkStack_ov031_020f2310 stack;
VecFx32_Copy(&this->mPos, &stack.mUnk_E4);
stack.mUnk_F0 = 0x2000;
if (!data_027e09bc->mUnk_04->func_01ffd640(&stack.mUnk_E4)) {
return;
}
u8 var4 = 0x1F;
u8 var5 = 0x1F;
if (this->mUnk_170 < (s16) 0x10) {
var4 = FLOAT_TO_FX32(this->mUnk_170);
}
if (this->mUnk_172 < (s16) 0x10) {
var5 = FLOAT_TO_FX32(this->mUnk_170);
}
if (var4 == 0) {
return;
}
func_0200eab0(this->mUnk_94.mpModel, 0x0, var4);
if (this->mState == ActorShotArrowState_2 && this->mUnk_224 != NULL) {
Mat4x3p_InitXRotation(&stack.mUnk_84, SIN((u16) this->mUnk_174), COS((u16) this->mUnk_174));
func_01ffad5c(this->mUnk_224, &data_027e0964, &stack.mUnk_B4);
func_01ffad5c(&stack.mUnk_84, &this->mUnk_228, &stack.mUnk_84);
func_01ffad5c(&stack.mUnk_84, &stack.mUnk_B4, &stack.mUnk_B4);
CopySingle288(&stack.mUnk_B4, &stack.mUnk_60);
VecFx32_Copy(&this->mPos, &this->mPrevPos);
VecFx32_Copy(&stack.mUnk_B4.wColumn, &this->mPos);
this->mUnk_94.vfunc_14(&stack.mUnk_60, &this->mPos);
if (var5 >= 0x1F) {
this->func_ov031_020f2654(&stack.mUnk_60);
}
} else {
VecFx32_Copy(&this->mPos, &stack.mUnk_30.zColumn);
Mat3p_InitYRotation(&stack.mUnk_30, SIN((u16) this->mAngle), COS((u16) this->mAngle));
Mat3p_InitXRotation(&stack.mUnk_30, SIN((u16) (s16) (this->mUnk_174 + this->mUnk_176)),
COS((u16) (s16) (this->mUnk_174 + this->mUnk_176)));
func_01ffa60c(&stack.mUnk_0C, &stack.mUnk_30, &stack.mUnk_30);
// should have if/else structure
stack.mUnk_54.y = MUL_FX32(FLOAT_TO_FX32(0.2f), SIN(this->mUnk_174 + this->mUnk_176));
this->mUnk_94.vfunc_14(&stack.mUnk_30, &stack.mUnk_54);
if (this->mUnk_25A) {
this->func_ov031_020f22d4(&stack.mUnk_30, &stack.mUnk_54);
}
if (var5 >= 0x1F && this->mState != ActorShotArrowState_4) {
this->func_ov031_020f2654(&stack.mUnk_30);
}
}
data_027e09b4->func_ov017_020c08c4(&this->mPos, 0x7B, 0x666, var4, this->mAngle, 0x1);
}
// non-matching
void ActorShotArrow::func_ov031_020f2654(Mat3p *param1) {}
void ActorShotArrow::func_ov031_020f2794(unk16 param1) {
switch (param1) {
case 0x0:
this->mUnk_94.vfunc_08(GetModelFromProfile3(func_ov031_020f1404(), data_ov031_02110b3c));
this->mUnk_25A = false;
break;
case 0x1:
this->mUnk_94.vfunc_08(GetModelFromProfile3(func_ov031_020f1404(), data_ov031_02110b4c));
this->mUnk_25A = false;
break;
case 0x2:
this->mUnk_94.vfunc_08(GetModelFromProfile3(func_ov031_020f1404(), data_ov031_02110b4c));
this->mUnk_25A = true;
this->mUnk_A0.func_ov000_02057c98(&this->mUnk_100);
break;
default:
break;
}
}
// non-matching
void ActorShotArrow::func_ov031_020f28ac() {
VecFx32 vec1;
VecFx32 vec2;
this->func_ov000_020989e0();
bool notEarlyReturn = true;
if (this->mUnk_140.mUnk_08 == 0x3FFFF) {
notEarlyReturn = false;
switch (this->mUnk_140.mUnk_1C) {
case 0x8:
if ((s16) this->mUnk_140.mUnk_0C.index == 0x102) {
bool var = false;
if ((s16) this->mUnk_140.mUnk_0C.index == 0x102) {
if (this->mUnk_140.mUnk_0C.data == 0x1 || this->mUnk_140.mUnk_0C.data == 0x3) {
var = true;
}
}
bool var2 = false;
if (!var) {
var2 = true;
}
VecFx32 *result = this->func_ov000_0209853c(var2);
func_01ffb714(&this->mPos, result, &vec1);
this->func_ov031_020f2cac(&vec1, true);
break;
}
if (!func_ov000_0205cbc4(this->mUnk_140.mUnk_0C.Get32(), &vec2)) {
vec1.x = FLOAT_TO_FX32(0.0f);
vec1.y = FLOAT_TO_FX32(0.0f);
vec1.z = FLOAT_TO_FX32(0.0f);
} else {
func_01ffb714(&this->mPos, &vec2, &vec1);
}
this->func_ov031_020f2cac(&vec1, true);
break;
case 0x4:
Actor *actor = gpActorManager->func_01fff3b4(this->mUnk_140.mUnk_0C);
if (actor != NULL) {
func_01ffb714(&this->mPos, &actor->mPrevPos, &vec1);
this->func_ov031_020f2cac(&vec1, true);
}
break;
case 0xE:
if (this->mUnk_140.mUnk_0C.index == 0x102) {
bool var = false;
if (this->mUnk_140.mUnk_0C.index == 0x102) {
if (this->mUnk_140.mUnk_0C.data == 0x1 || this->mUnk_140.mUnk_0C.data == 0x3) {
var = true;
}
}
bool var2 = true;
if (!var) {
var2 = false;
}
if (this->func_ov000_02098800(var2)) {
notEarlyReturn = true;
} else {
data_027e0ce0->func_ov000_0208bd30(var2, 0xE6, 0, 0);
func_01ffb714(&this->mPos, this->func_ov000_0209853c(0), &vec1);
this->func_ov031_020f2cac(&vec1, true);
}
}
break;
case 0xF:
if (this->mUnk_5C.mParams[1] == 0x0 || this->mUnk_5C.mParams[1] == 0x3) {
data_027e0ce0->func_ov000_0208bc1c(1, 0, 0x18, 0, 0, 0);
}
VecFx32 *result = this->func_ov000_0209853c(0x1);
func_01ffb714(&this->mPos, result, &vec1);
this->func_ov031_020f2cac(&vec1, true);
break;
case 0x3:
if (this->mUnk_140.mUnk_0C.type != ActorRefType_0) {
Actor *actor = gpActorManager->func_01fff3b4(this->mUnk_140.mUnk_0C);
if (actor) {
func_01ffb714(&actor->mPos, &actor->mPrevPos, &vec1);
VecFx32_TryNormalize(&vec1);
this->func_ov031_020f2cac(&vec1, true);
}
}
break;
default:
break;
}
}
if (!notEarlyReturn) {
return;
}
this->func_ov031_020f2f9c();
if ((this->mUnk_5C.mParams[1] != 0) && (this->mUnk_5C.mParams[1] != 3)) {
u32 var_r0 = this->func_ov000_02098ab4(data_ov031_02110b01[this->mUnk_5C.mParams[1]], 0, 1, &this->mVel);
if (var_r0) {
this->Kill();
}
}
}
void ActorShotArrow::func_ov031_020f2b8c() {
if (this->mState == ActorShotArrowState_0 || this->mState == ActorShotArrowState_5) {
this->mUnk_178.mUnk_18 |= 2;
this->SetState(ActorShotArrowState_3);
}
}
void ActorShotArrow::func_ov031_020f2bbc() {
if (this->mState == ActorShotArrowState_0 || this->mState == ActorShotArrowState_5) {
this->mUnk_178.mUnk_18 |= 2;
this->SetState(ActorShotArrowState_1);
}
}
void ActorShotArrow::func_ov031_020f2bec() {
if (this->mState == ActorShotArrowState_0) {
this->SetState(ActorShotArrowState_5);
}
}
// non-matching
void ActorShotArrow::func_ov031_020f2c08(unk16 param1) {
VecFx32 vel;
this->mVel.x = MUL_FX32(SIN((u16) this->mAngle), param1);
this->mVel.z = MUL_FX32(COS((u16) this->mAngle), param1);
this->mVel.y = FLOAT_TO_FX32(0.0f);
vel = this->mVel;
func_01ff93c0(&vel, -0x1000);
this->func_ov031_020f2cac(&vel, false);
}
// non-matching
void ActorShotArrow::func_ov031_020f2cac(VecFx32 *param1, bool param2) {
VecFx32 vel;
VecFx32 pos;
VecFx16 vec;
if (this->mState == ActorShotArrowState_4) {
return;
}
this->mUnk_140.mUnk_04 &= ~0x8;
this->SetState(ActorShotArrowState_4);
if (param1->x == 0 && param1->y == 0) {
if (param1->z != 0) {
vel = this->mVel;
if (this->mVel.x == 0 && this->mVel.y == 0 && this->mVel.z == 0) {
VecFx32_Copy(&this->mVel, param1);
} else {
func_01ff94cc(&this->mVel, param1, &vel);
}
} else {
this->mVel.x = -this->mVel.x;
this->mVel.y = -this->mVel.y;
this->mVel.z = -this->mVel.z;
}
}
VecFx32_TryNormalize(&this->mVel);
func_01ff93c0(&this->mVel, 0x19A);
this->mVel.y = 0xCD;
if (param2) {
pos = this->mPos;
this->mPos.x -= FLOAT_TO_FX32(SIN((u16) this->mAngle));
this->mPos.z -= FLOAT_TO_FX32(COS((u16) this->mAngle));
data_027e09a8->func_ov000_02071eac(&this->mPos);
data_027e09a8->func_ov000_02071b30(0x8D7B, &pos, 0x0);
vec.x = (fx16) FLOAT_TO_FX32(SIN((u16) (this->mAngle - 0x8000)));
vec.y = (fx16) FLOAT_TO_FX32(0.0f);
vec.z = (fx16) FLOAT_TO_FX32(COS((u16) (this->mAngle - 0x8000)));
data_027e0cec->func_ov000_0209feac(0x804, &pos, 0x2, 0x0, 0x0);
data_027e0cec->func_ov000_0209ff24(0x805, &pos, &vec, 2);
}
this->mAngle = func_01ffbbe0(this->mVel.x, this->mVel.z);
}
// non-matching
void ActorShotArrow::func_ov031_020f2ef0() {
Actor *value = NULL;
ActorShotArrow_178 *unk_178;
unk_178 = &this->mUnk_178;
func_01ffe6c4(&value, this->mRef.Get32(), &this->mPos, &this->mVel, (s16) this->mUnk_44, &this->mPos, 0);
this->mUnk_46 = (s16) (value->func_ov000_0207df88(this->mUnk_30, 0x3) | func_ov000_0207e294(this->mUnk_30));
}
void ActorShotArrow::func_ov031_020f2f5c(VecFx32 *param1) {
VecFx32_Copy(&this->mPos, &this->mPrevPos);
VecFx32_Add(&this->mPos, param1, &this->mPos);
func_01ffb714(&this->mPos, &this->mVel, &this->mPos);
}
bool ActorShotArrow::func_ov031_020f2f9c() {
VecFx32_Copy(&this->mPos, &this->mUnk_194.mUnk_0C.pos);
this->mUnk_194.mUnk_0C.size = FLOAT_TO_FX32(0.2f);
data_027e09c0->func_ov000_0207e58c(this->mRef, 0x3, data_ov031_02110b01[this->mUnk_5C.mParams[1]], &this->mUnk_194);
return true;
}
// non-matching
void ActorShotArrow::func_ov031_020f3000() {
VecFx32 vec;
Mat3p m1;
Mat3p m2;
vec.x = FLOAT_TO_FX32(0.0f);
vec.y = FLOAT_TO_FX32(0.0f);
vec.z = FLOAT_TO_FX32(0.4f);
Mat3p_InitYRotation(&m1, SIN((u16) this->mAngle), COS((u16) this->mAngle));
Mat3p_InitXRotation(&m2, SIN((u16) (s16) (this->mUnk_174 + this->mUnk_176)),
COS((u16) (s16) (this->mUnk_174 + this->mUnk_176)));
func_01ffa60c(&m2, &m1, &m1);
func_01ffa7a0(&vec, &m1, &vec);
vec.y = MUL_FX32(vec.y, 0x800);
VecFx32_Add(&vec, &this->mPos, &vec);
VecFx32_Copy(&vec, &this->mUnk_1DC.mUnk_00);
}
void ActorShotArrow::func_ov031_020f311c(Mat4x3p *param1) {
Mat4x3p m1;
Mat4x3p m2;
UNSET_FLAG(this->mFlags, ActorFlag_Visible);
this->mUnk_224 = param1;
if (param1 != NULL) {
Mat4x3p_InitXRotation(&m1, SIN((u16) this->mUnk_176), COS((u16) this->mUnk_176));
Mat4x3p_InitYRotation(&m2, SIN((u16) this->mAngle), COS((u16) this->mAngle));
func_01ffad5c(&m1, &m2, &m1);
VecFx32_Copy(&this->mPos, &m1.wColumn);
func_01ffad5c(this->mUnk_224, &data_027e0964, &m2);
func_01ffa9e8(&m2, &m2);
func_01ffad5c(&m1, &m2, &this->mUnk_228);
}
this->SetState(ActorShotArrowState_2);
}
bool ActorShotArrow::func_ov031_020f3210(u16 param1) {
if (this->mUnk_25B) {
return false;
}
if (this->mUnk_170 == 0) {
return true;
}
u32 value = this->mUnk_170 - param1;
if (this->mUnk_170 <= param1) {
value = 0;
}
this->mUnk_170 = value;
this->func_ov031_020f3258(param1);
return false;
}
// non-matching
bool ActorShotArrow::func_ov031_020f3258(u16 param1) {
if (this->mUnk_172 == 0) {
return true;
}
if (this->mUnk_172 > param1) {
this->mUnk_172 -= param1;
} else {
this->mUnk_172 = 0;
}
return false;
}
ActorShotArrow_178::ActorShotArrow_178(ActorShotArrow *param1) {
this->mUnk_08 = param1;
this->mUnk_0C.x = FLOAT_TO_FX32(0.0f);
this->mUnk_0C.y = FLOAT_TO_FX32(0.0f);
this->mUnk_0C.z = FLOAT_TO_FX32(0.0f);
this->mUnk_18 = 0;
}
ActorShotArrow_178::~ActorShotArrow_178() {
this->mUnk_08 = NULL;
}
void ActorShotArrow_178::func_ov031_020f3304() {
this->mUnk_18 = FLOAT_TO_FX32(0.0f);
}
// non-matching
bool ActorShotArrow_178::vfunc_08(const UnkStruct_ov031_020f3310 *param1) {
u32 var = param1->mUnk_04->mUnk_24[param1->mUnk_00->mUnk_06];
if ((var >> 0x17 & 1) == 1) {
return false;
}
if ((this->mUnk_08->mUnk_178.mUnk_18 & 0x1) == 0 && (var >> 0x1F & 1) == 1) {
this->mUnk_08->func_ov031_020f2b8c();
} else if ((this->mUnk_08->mUnk_178.mUnk_18 & 0x2) == 0) {
if (this->mUnk_08->mState == ActorShotArrowState_4) {
this->mUnk_08->Kill();
return false;
}
this->mUnk_08->mUnk_178.mUnk_18 |= 0x1;
VecFx16_Copy2VecFx32(&param1->mUnk_08, &this->mUnk_08->mUnk_178.mUnk_0C);
}
return true;
}
// non-matching
bool ActorShotArrow_178::vfunc_0C(const UnkStruct_ov031_020e54d4 *param1, unk32 param2) {}
ActorShotArrow_194::ActorShotArrow_194(ActorShotArrow *param1) {
this->mUnk_2C = param1;
this->mUnk_30 = 0;
}
void ActorShotArrow_194::func_ov031_020f374c(Actor *actor) {
UnkStruct_020f374c stack;
stack.mUnk_28 = this->mUnk_2C->mVel;
func_01ff93c0(&stack.mUnk_28, this->mUnk_30);
stack.mUnk_1C = this->mUnk_0C.pos;
VecFx32_Add(&stack.mUnk_1C, &stack.mUnk_28, &stack.mUnk_1C);
func_01ffb714(&stack.mUnk_1C, &actor->mVel, &stack.mUnk_1C);
actor->vfunc_10(&stack.mUnk_0C);
stack.mUnk_00 = stack.mUnk_0C;
func_01ffb714(&stack.mUnk_00, &stack.mUnk_1C, &stack.mUnk_00);
unk32 temp = func_01ff9258(stack.mUnk_00.x, stack.mUnk_00.z);
//! @bug: stack.mUnk_18 is used uninitialized?
if (temp > stack.mUnk_18 && stack.mUnk_18 > FLOAT_TO_FX32(0.15f)) {
fx32 temp_r5 = (temp - stack.mUnk_18) + FLOAT_TO_FX32(0.15f);
u16 value = (u32) (s16) (s32) func_01ffbbe0(stack.mUnk_00.x, stack.mUnk_00.z);
fx16 sin = SIN(value);
fx16 cos = COS(value);
stack.mUnk_28.x += MUL_FX32(sin, temp_r5);
stack.mUnk_28.z += MUL_FX32(cos, temp_r5);
}
this->mUnk_2C->func_ov031_020f2f5c(&stack.mUnk_28);
this->mUnk_2C->mUnk_1C8.mUnk_00 = actor;
}
// non-matching
void ActorShotArrow_194::vfunc_10(Actor *actor) {
UnkStruct_020f38b0 stack;
if (!(this->mUnk_04 != actor->mRef && actor->mUnk_34 != NULL)) {
return;
}
if (this->mUnk_2C->mState != ActorShotArrowState_0 && this->mUnk_2C->mState != ActorShotArrowState_5) {
return;
}
if (actor->GetActorId() == ActorId_ShotArrow) {
return;
}
s16 result = func_01ffbbe0(this->mUnk_2C->mVel.x, this->mUnk_2C->mVel.z);
switch (actor->GetActorId()) {
case ActorId_WIDR:
this->func_ov031_020f374c(actor);
this->mUnk_2C->func_ov031_020f2bec();
if (actor != NULL) {
func_01ffb714(&this->mUnk_2C->mPos, &actor->mPos, &stack.mUnk_1C);
VecFx32_Copy(&stack.mUnk_1C, &this->mUnk_2C->mUnk_1C8.mUnk_04);
this->mUnk_2C->mUnk_1C8.mUnk_10 = actor->mAngle;
this->mUnk_2C->mUnk_1C8.mUnk_12 = result;
}
break;
case ActorId_IWTS:
this->func_ov031_020f374c(actor);
stack.mUnk_0C = NULL;
if (!data_027e0d80->func_ov084_02153064(&this->mUnk_2C->mRef, &stack.mUnk_0C)) {
this->mUnk_2C->func_ov031_020f311c(stack.mUnk_0C);
this->mUnk_2C->mUnk_258 = 0x01;
}
break;
case ActorId_MRD2:
if (data_ov075_02163518->mUnk_910 != 1) {
this->func_ov031_020f374c(actor);
stack.mUnk_08 = 0;
if (data_ov075_02163518->func_ov075_0215bbf0(&this->mUnk_2C->mRef, &stack.mUnk_08)) {
func_ov075_02160864(this->mUnk_2C, stack.mUnk_08);
this->mUnk_2C->mUnk_258 = 0x01;
}
}
break;
case ActorId_RYAW:
this->mUnk_2C->SetState(ActorShotArrowState_6);
UNSET_FLAG(this->mUnk_2C->mFlags, ActorFlag_Visible);
break;
case ActorId_LOCK:
stack.mUnk_04 = actor->mUnk_5C.mUnk_28;
if (stack.mUnk_04.data != 0 && stack.mUnk_04.type != ActorRefType_0) {
ActorUnkGYAM *lockedActor = (ActorUnkGYAM *) gpActorManager->func_01fff3b4(actor->mUnk_5C.mUnk_28);
if (lockedActor != NULL && lockedActor->GetActorId() == ActorId_GYAM) {
this->func_ov031_020f374c(actor);
this->mUnk_2C->func_ov031_020f311c(&lockedActor->mUnk_220);
SET_FLAG(this->mUnk_2C->mFlags, ActorFlag_Visible);
this->mUnk_2C->mUnk_258 = 0x0;
break;
}
}
// fallthrough
default:
if (!this->IsParam1_3Or4()) {
this->func_ov031_020f374c(actor);
this->mUnk_2C->func_ov031_020f2bbc();
if (actor) {
func_01ffb714(&this->mUnk_2C->mPos, &actor->mPos, &stack.mUnk_10);
VecFx32_Copy(&stack.mUnk_10, &this->mUnk_2C->mUnk_1C8.mUnk_04);
this->mUnk_2C->mUnk_1C8.mUnk_10 = actor->mAngle;
this->mUnk_2C->mUnk_1C8.mUnk_12 = result;
}
}
if (this->mUnk_2C->mUnk_25C) {
this->mUnk_2C->mUnk_25D = true;
}
break;
}
}
// non-matching
bool ActorShotArrow_194::vfunc_0C(Actor *actor, VecFx32 *vector) {
UnkStruct_020f3c38 stack;
if (!(actor->mRef != this->mUnk_04 && actor->mUnk_34 != NULL) ||
!(this->mUnk_2C->mState == ActorShotArrowState_0 || this->mUnk_2C->mState == ActorShotArrowState_5)) {
return false;
}
func_01ffb714(&actor->mVel, &this->mUnk_2C->mVel, &stack.mUnk_14);
actor->vfunc_10(&stack.mUnk_04);
if (!func_01ffccf4(&this->mUnk_0C, &stack.mUnk_04, &stack.mUnk_14, &this->mUnk_30)) {
return false;
}
VecFx32_Copy(&this->mUnk_2C->mVel, vector);
VecFx32_TryNormalize(vector);
return true;
}
void ActorShotArrow::func_ov031_020f3d04(unk16 param1) {
this->mUnk_176 = param1;
func_01ff9638(&this->mVel, -this->mAngle);
func_01ff95a0(&this->mVel, param1);
func_01ff9638(&this->mVel, this->mAngle);
}
Reference in New Issue View Git Blame Copy Permalink