path: root/src/bossMegaGoomba.cpp

#include <common.h>
#include <game.h>
#include <g3dhax.h>
#include <sfx.h>

//Enable this if you're fixing it
// void setNewActivePhysicsRect(dStageActor_c* actor, Vec* scale) {
// 	float amtX = scale->x;
// 	float amtY = scale->y;

// 	ActivePhysics::Info info;
// 	info.xDistToCenter = 0.0;
// 	info.yDistToCenter = 7.65 * amtY;
// 	info.xDistToEdge   = 4.0 * amtX;
// 	info.yDistToEdge   = 7.7 * amtY;

// 	info.category1  = actor->aPhysics.info.category1;
// 	info.category2  = actor->aPhysics.info.category2;
// 	info.bitfield1  = actor->aPhysics.info.bitfield1;
// 	info.bitfield2  = actor->aPhysics.info.bitfield2;
// 	info.unkShort1C = actor->aPhysics.info.unkShort1C;
// 	info.callback   = actor->aPhysics.info.callback;

// 	//OSReport("Making new Physics Class and adding to the list\n");
// 	actor->aPhysics.removeFromList();
// 	actor->aPhysics.initWithStruct(actor, &info);
// 	actor->aPhysics.addToList();
// }

class daMegaGoomba_c : public dEn_c {
	int onCreate();
	int onDelete();
	int onExecute();
	int onDraw();

	mHeapAllocator_c allocator;
	nw4r::g3d::ResFile resFile;
	m3d::mdl_c bodyModel;
	m3d::anmChr_c animationChr;
	nw4r::g3d::ResAnmTexPat resTexPat;
	m3d::anmTexPat_c animationPat;

	float timer;
	float dying;
	
	HermiteKey keysX[0x10];
	unsigned int Xkey_count;
	HermiteKey keysY[0x10];
	unsigned int Ykey_count;

	char life;
	bool already_hit;

	float XSpeed;
	float JumpHeight;
	float JumpDist;
	float JumpTime;

	bool takeHit(char count);

	void bindAnimChr_and_setUpdateRate(const char* name, int unk, float unk2, float rate);
	
	void dieFall_Begin();
	void dieFall_Execute();
	static daMegaGoomba_c *build();

	void setupBodyModel();
	void setupCollision();

	void updateModelMatrices();

	bool preSpriteCollision(ActivePhysics *apThis, ActivePhysics *apOther);
	bool prePlayerCollision(ActivePhysics *apThis, ActivePhysics *apOther);
//	bool preYoshiCollision(ActivePhysics *apThis, ActivePhysics *apOther);

//	bool stageActorCollision(ActivePhysics *apThis, ActivePhysics *apOther);
	void spriteCollision(ActivePhysics *apThis, ActivePhysics *apOther);
	void playerCollision(ActivePhysics *apThis, ActivePhysics *apOther);
//	void yoshiCollision(ActivePhysics *apThis, ActivePhysics *apOther);

	void collisionCat1_Fireball_E_Explosion(ActivePhysics *apThis, ActivePhysics *apOther);
	bool collisionCat2_IceBall_15_YoshiIce(ActivePhysics *apThis, ActivePhysics *apOther);
	void collisionCat3_StarPower(ActivePhysics *apThis, ActivePhysics *apOther);
	void collisionCat5_Mario(ActivePhysics *apThis, ActivePhysics *apOther);
	void collisionCat9_RollingObject(ActivePhysics *apThis, ActivePhysics *apOther);
	void collisionCatA_PenguinMario(ActivePhysics *apThis, ActivePhysics *apOther);
	void collisionCatD_GroundPound(ActivePhysics *apThis, ActivePhysics *apOther);
	void collisionCat11_PipeCannon(ActivePhysics *apThis, ActivePhysics *apOther);
	void collisionCat13_Hammer(ActivePhysics *apThis, ActivePhysics *apOther);
	void collisionCat14_YoshiFire(ActivePhysics *apThis, ActivePhysics *apOther);
	void _vf120(ActivePhysics *apThis, ActivePhysics *apOther);
	void _vf110(ActivePhysics *apThis, ActivePhysics *apOther);
	void _vf108(ActivePhysics *apThis, ActivePhysics *apOther);

	USING_STATES(daMegaGoomba_c);
	DECLARE_STATE(Grow);
	DECLARE_STATE(Shrink);
	DECLARE_STATE(Walk);
	DECLARE_STATE(Turn);
	DECLARE_STATE(Jump);
	DECLARE_STATE(Launch);
};

u8 struct_1[] = { 0, 0, 0, 1, 0xff, 0xff, 0x40, 0, 0, 0, 0xc0, 0, 0, 0, 0, 0 };
u8 struct_3[] = { 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0x3f, 0x2a, 0x7e, 0xfa };
	// last 4 bytes not needed. float for scale

daMegaGoomba_c *daMegaGoomba_c::build() {
	void *buffer = AllocFromGameHeap1(sizeof(daMegaGoomba_c));
	return new(buffer) daMegaGoomba_c;
}

void HexDump(char* address, u32 length) {
	length = (length + 0x1f) & ~0x1f;
	char line[0x11] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
	for(u32 ii=0; ii < length; ii += 0x10) {
		for(u32 jj=0; jj < 0x10; jj++) {
			if((address[ii+jj] < 0x20) || (address[ii+jj] > 0x7e)) {
				line[jj] = '.';
			}else{
				line[jj] = address[ii+jj];
			}
		}
		OSReport("%08x: %04x %04x %04x %04x  %04x %04x %04x %04x |%s|\n",
				(u32)(address+ii),
				*(u16*)(address+ii+0x00),
				*(u16*)(address+ii+0x02),
				*(u16*)(address+ii+0x04),
				*(u16*)(address+ii+0x06),
				*(u16*)(address+ii+0x08),
				*(u16*)(address+ii+0x0a),
				*(u16*)(address+ii+0x0c),
				*(u16*)(address+ii+0x0e),
				line);
		for(u32 jj=0; jj<0x10; jj++) line[jj] = 0;
	}
}


extern "C" void *PlaySound(daMegaGoomba_c *, int soundID);

extern "C" u32 GenerateRandomNumber(int max);
extern "C" u8 dSprite_c__getXDirectionOfFurthestPlayerRelativeToVEC3(daMegaGoomba_c *, Vec pos);
extern "C" dStageActor_c *CreateActor(u16 classID, int settings, Vec pos, char rot, char layer);
extern "C" dStageActor_c *GetSpecificPlayerActor(int number);

//FIXME make this dEn_c->used...
extern "C" char usedForDeterminingStatePress_or_playerCollision(dEn_c* t, ActivePhysics *apThis, ActivePhysics *apOther, int unk1);
extern "C" int SomeStrangeModification(dStageActor_c* actor);
extern "C" void DoStuffAndMarkDead(dStageActor_c *actor, Vec vector, float unk);
extern "C" int SmoothRotation(short* rot, u16 amt, int unk2);


CREATE_STATE(daMegaGoomba_c, Grow);
CREATE_STATE(daMegaGoomba_c, Shrink);
CREATE_STATE(daMegaGoomba_c, Walk);
CREATE_STATE(daMegaGoomba_c, Turn);
CREATE_STATE(daMegaGoomba_c, Jump);
CREATE_STATE(daMegaGoomba_c, Launch);


//TODO better fix for possible bug with sign (ex. life=120; count=-9;)
bool daMegaGoomba_c::takeHit(char count) {
	if(!this->already_hit) {
		int c = count;
		int l = this->life;
		if(l - c > 127) {
			c = 127 - l;
		}
		this->life -= c;
		this->XSpeed += 0.25;
		this->JumpHeight += 12.0;
		this->JumpDist += 12.0;
		this->JumpTime += 5.0;
		doStateChange(&StateID_Shrink);
		this->already_hit = true;
	}
	return (life <= 0) ? true : false;
}

#define ACTIVATE	1
#define DEACTIVATE	0

bool daMegaGoomba_c::preSpriteCollision(ActivePhysics *apThis, ActivePhysics *apOther) {
	//OSReport("preSpriteCollision\n");
	return false;
}
bool daMegaGoomba_c::prePlayerCollision(ActivePhysics *apThis, ActivePhysics *apOther) {
	//OSReport("prePlayerCollision\n");
	return false;
}
//bool daMegaGoomba_c::preYoshiCollision(ActivePhysics *apThis, ActivePhysics *apOther) { OSReport("preYoshiCollision\n");  return false; }


//bool  daMegaGoomba_c::stageActorCollision(ActivePhysics *apThis, ActivePhysics *apOther) { OSReport("stageActorCollision\n"); return true; }
void daMegaGoomba_c::spriteCollision(ActivePhysics *apThis, ActivePhysics *apOther) {
	//HE'S TOO BADASS TO STOP FOR SMALLER GOOMBAS
#if 0
	OSReport("spriteCollision\n");
	float me = apThis->firstFloatArray[3];
	if(((this->direction == 1) && (me > 0.0)) || ((this->direction == 0) && (me < 0.0))) {
		dStateBase_c* state = this->acState.getCurrentState();
		if(!state->isEqual(&StateID_Turn)) {
			doStateChange(&StateID_Turn);
		}
	}
#endif
}

void daMegaGoomba_c::playerCollision(ActivePhysics *apThis, ActivePhysics *apOther) { 
	OSReport("Mario collision.\n"); 

	/* * * * * * * * * * * * * * * * * * * * *
	 * 0=normal??,1=dontHit,2=dontKill
	 * daEnBrosBase_c ::player = 0
	 * daEnBrosBase_c::yoshi   = 0
	 * daEnPipePirahna::player = 1
	 * daEnPipePirahna::yoshi  = 1
	 * daEnKuriboBase_c::player = 0
	 * daEnKuriboBase_c::yoshi  = 0
	 * daEnLargeKuribo_c::player = 0
	 * daEnLargeKuribo_c::yoshi  = 2
	 * daEnNokonoko_c::player = 0
	 * daEnNokonoko_c::yoshi  = 0
	 * daEnSubBoss_c     = 2
	 *
	 * * * * * * * * * * * * * * * * * * * * */
	//FIXME rename and make part of dStageActor_c
	//unk=0 does _vfs, unk=1 does playSeCmnStep
	//char ret = usedForDeterminingStatePress_or_playerCollision(this, apThis, apOther, 0);
	char ret = usedForDeterminingStatePress_or_playerCollision(this, apThis, apOther, 2);
	if(ret == 1) {	// regular jump
		apOther->someFlagByte |= 2;
		OSReport("ret == 1; regular jump;\n");
		if(this->takeHit(1))
			doStateChange(&StateID_DieFall);
	} else if(ret == 3) {	// spinning
		apOther->someFlagByte |= 2;
		OSReport("ret == 3; spinning collision;\n");
		if(this->takeHit(1))
			doStateChange(&StateID_DieFall);
	} else if(ret == 0) {
		OSReport("calling dEn_c::playerCollsiion(apThis, apOther);\n");
		this->dEn_c::playerCollision(apThis, apOther);
		this->_vf220(apOther->owner);
	} else if(ret == 2) {
		OSReport("Y U USIN' MINIMARIO?\n");
	} else {
		OSReport("usedForDeter...() returned %d\n", ret);
	}

	//FIXME hack to make multiple playerCollisions work
	this->isDead = 0;
	this->flags_4FC |= (1<<(31-7));
	if(apOther->owner->which_player > 3) {
		OSReport("!!!ATTENTION!!!\napOther->owner->which_player > 3\n");
	}else{
		this->counter_504[apOther->owner->which_player] = 0;
	}
}

//void  daMegaGoomba_c::yoshiCollision(ActivePhysics *apThis, ActivePhysics *apOther) { OSReport("yoshiCollision\n"); }


void daMegaGoomba_c::collisionCat1_Fireball_E_Explosion(ActivePhysics *apThis, ActivePhysics *apOther) { OSReport("Hit Fireball\n"); }
bool daMegaGoomba_c::collisionCat2_IceBall_15_YoshiIce(ActivePhysics *apThis, ActivePhysics *apOther) { OSReport("Hit Iceball\n"); return false; }
void daMegaGoomba_c::collisionCat3_StarPower(ActivePhysics *apThis, ActivePhysics *apOther) { OSReport("Hit StarMario\n"); }
void daMegaGoomba_c::collisionCat5_Mario(ActivePhysics *apThis, ActivePhysics *apOther) { OSReport("MarioHit\n"); }
void daMegaGoomba_c::collisionCat9_RollingObject(ActivePhysics *apThis, ActivePhysics *apOther) {
	OSReport("Hit Rolling Object\n");
	if(this->takeHit(1))
		doStateChange(&StateID_DieFall);
}
void daMegaGoomba_c::collisionCatA_PenguinMario(ActivePhysics *apThis, ActivePhysics *apOther) { OSReport("Penguin Attack\n"); }
void daMegaGoomba_c::collisionCatD_GroundPound(ActivePhysics *apThis, ActivePhysics *apOther) { OSReport("Groundpound\n"); }
void daMegaGoomba_c::collisionCat11_PipeCannon(ActivePhysics *apThis, ActivePhysics *apOther) { OSReport("PipeCannon Hit\n"); }
void daMegaGoomba_c::collisionCat13_Hammer(ActivePhysics *apThis, ActivePhysics *apOther) {
	OSReport("Hit Hammer\n");
	if(this->takeHit(1))
		doStateChange(&StateID_DieFall);
}
void daMegaGoomba_c::collisionCat14_YoshiFire(ActivePhysics *apThis, ActivePhysics *apOther) {
	OSReport("Hit Yoshi Fire\n");
	if(this->takeHit(1))
		doStateChange(&StateID_DieFall);
}
void daMegaGoomba_c::_vf120(ActivePhysics *apThis, ActivePhysics *apOther) { OSReport("_vf120:\n"); }
void daMegaGoomba_c::_vf110(ActivePhysics *apThis, ActivePhysics *apOther) { OSReport("_vf110:\n"); }
void daMegaGoomba_c::_vf108(ActivePhysics *apThis, ActivePhysics *apOther) { OSReport("_vf108:\n"); }

void daMegaGoomba_c::bindAnimChr_and_setUpdateRate(const char* name, int unk, float unk2, float rate) {
	nw4r::g3d::ResAnmChr anmChr = this->resFile.GetResAnmChr(name);
	this->animationChr.bind(&this->bodyModel, anmChr, unk);
	this->bodyModel.bindAnim(&this->animationChr, unk2);
	this->animationChr.setUpdateRate(rate);
}

void daMegaGoomba_c::dieFall_Begin() {
	this->dEn_c::dieFall_Begin();
}
//TODO make this real perty like
void daMegaGoomba_c::dieFall_Execute() {
	
	this->timer = this->timer + 1.0;
	
	this->dying = this->dying + 0.15;
	
	this->pos.x = this->pos.x + 0.15;
	this->pos.y = this->pos.y + ((-0.2 * (this->dying*this->dying)) + 5);
	
	this->dEn_c::dieFall_Execute();
}

void daMegaGoomba_c::setupBodyModel() {
	allocator.link(-1, GameHeaps[0], 0, 0x20);

	this->resFile.data = getResource("kuribo", "g3d/t02.brres");
	nw4r::g3d::ResMdl mdl = this->resFile.GetResMdl("kuribo");
	bodyModel.setup(mdl, &allocator, 0x224, 1, 0);
	SetupTextures_Enemy(&bodyModel, 0);

	bool ret;
	nw4r::g3d::ResAnmChr anmChr = this->resFile.GetResAnmChr("walk");
	ret = this->animationChr.setup(mdl, anmChr, &this->allocator, 0);
	this->bindAnimChr_and_setUpdateRate("walk", 1, 0.0, 1.0);

	nw4r::g3d::ResAnmTexPat anmPat = this->resFile.GetResAnmTexPat("walk");
	this->resTexPat = anmPat;
	ret = this->animationPat.setup(mdl, anmPat, &this->allocator, 0, 1);
	this->animationPat.bindEntry(&this->bodyModel, &anmPat, 0, 0);
	this->bodyModel.bindAnim(&this->animationPat, 0.0);
	this->animationPat.setFrameForEntry(1.0, 0);
	this->animationPat.setUpdateRateForEntry(1.0, 0);
	this->animationPat.setEntryByte34(0, 0);

	allocator.unlink();
}

void daMegaGoomba_c::setupCollision() {
	//POINTLESS WITH GROWTH
	this->scale.x = this->scale.y = this->scale.z = 0.666;

	this->collMgr.Init(this, struct_1, 0, struct_3);

	char foo = this->_391;
	this->pos_delta2.x = 0.0;
	this->pos_delta2.y = 16.0;
	this->pos_delta2.z = 0.0;

	this->spriteSomeRectX = 32.0;
	this->spriteSomeRectY = 32.0;
	this->_320 = 0.0;
	this->_324 = 16.0;
	this->_328 = 80.0;
	this->_32C = 256.0;

	this->pos.z = (foo == 0) ? 1500.0 : -2500.0;

	this->_518 = 2;

	this->aPhysics.info.xDistToCenter = 0.0;
	this->aPhysics.info.yDistToCenter = 12.0;
	this->aPhysics.info.xDistToEdge = 14.0;
	this->aPhysics.info.yDistToEdge = 12.0;

	//NOT NEEDED
	//this->doStateChange(&StateID_Walk);
}

int daMegaGoomba_c::onCreate() {
	/*80033230 daEnLkuribo_c::onCreate()*/
	OSReport("Creating MG's body model\n");
	this->setupBodyModel();
	this->max_speed.y = -4.0;
	this->direction = dSprite_c__getXDirectionOfFurthestPlayerRelativeToVEC3(this, this->pos);
	this->rot.y = (this->direction) ? 0xE000 : 0x2000;
	this->_518 = 2;

	OSReport("Creating MegaGoomba's Physics Struct\n");
	ActivePhysics::Info hm;
	hm.xDistToCenter = 0.0;
	hm.yDistToCenter = 8.0;
	hm.xDistToEdge   = 8.0;
	hm.yDistToEdge   = 8.0;
	hm.category1 = 0x3;
	hm.category2 = 0x0;
	hm.bitfield1 = 0x6f;
	hm.bitfield2 = 0xffbafffe;
	hm.unkShort1C = 0;
	hm.callback = &dEn_c::collisionCallback;
	this->aPhysics.initWithStruct(this, &hm);
	this->aPhysics.addToList();

	this->_120 |= 0x200;

	this->_36D = 0;
	this->setupCollision();

	//HOMEMADE//
	speed.y = 0.0;
	dying = 0.0;
	rot.x = rot.z = 0;
	life = 3;
	already_hit = false;
	this->x_speed_inc = 0.1;

	// 2.0 is good final speed
	this->XSpeed = 1.5;
	this->JumpHeight = 48.0;
	this->JumpDist = 64.0;
	this->JumpTime = 50.0;

	OSReport("Setting MegaGoomba's State\n");
	doStateChange(&StateID_Grow);

	OSReport("Going to Execute MegaGoomba\n");
	this->onExecute();
	return true;
}

int daMegaGoomba_c::onDelete() {
	return true;
}

int daMegaGoomba_c::onExecute() {
	//80033450
	acState.execute();
	//OSReport("Field_34A: %02x\n", this->_34A);
	//if(CheckSomethingEnemyRelated())		// checks class1EC bitfield
	//	sub_80033f10(this);					// spawn hit effect and play hit sound
	//else
	//	dStageActor_c__checkZoneBoundaries(this, 0);
	//// dont do updateModelMatrices ////

	updateModelMatrices();

	return true;
}

int daMegaGoomba_c::onDraw() {
	bodyModel.scheduleForDrawing();

	//DONT DO REST HERE//
#if 0
	bodyModel._vf1C();
	animationPat.process();
#endif
	return true;
}


void daMegaGoomba_c::updateModelMatrices() {
	// This won't work with wrap because I'm lazy.
	matrix.translation(pos.x, pos.y, pos.z);
	matrix.applyRotationYXZ(&rot.x, &rot.y, &rot.z);

	bodyModel.setDrawMatrix(matrix);
	bodyModel.setScale(&scale);
	bodyModel.calcWorld(false);
}


// Grow State
void daMegaGoomba_c::beginState_Grow() { 
	this->timer = 1.0;

	float start, end, shift1, shift2;
	start  = 59.0;
	shift1 = 90.0;
	shift2 = 120.0;
	end    = 139.0;
	/* keysX[i] = { frame, value, slope }; */
	Xkey_count = 7;
	keysX[0] = (HermiteKey){ start,             1.0, 1.0 };
	keysX[1] = (HermiteKey){ (start+shift1)/2,  2.0, 1.0 };
	keysX[2] = (HermiteKey){ shift1,            4.0, 1.0 };
	keysX[3] = (HermiteKey){ (shift1+shift2)/2, 3.0, 1.0 };
	keysX[3] = (HermiteKey){ shift2,            6.0, 1.0 };
	keysX[3] = (HermiteKey){ (shift2+end)/2,    5.0, 1.0 };
	keysX[6] = (HermiteKey){ end,               7.0, 1.0 };
}
void daMegaGoomba_c::executeState_Grow() { 
	
	this->timer += 1.0;
	
	if ((this->timer > 60.0) && (this->timer < 140.0)) {

		float modifier = GetHermiteCurveValue(this->timer, this->keysX, Xkey_count);
		this->scale = (Vec){modifier, modifier, modifier};
		// setNewActivePhysicsRect(this, &this->scale);

	}
	if(this->timer == 60.0)
		PlaySound(this, SE_EMY_KURI_CHANGE_BIG);
	
	if (this->timer > 170.0) { doStateChange(&StateID_Walk); }
	
}
void daMegaGoomba_c::endState_Grow() { }


// Shrink State
void daMegaGoomba_c::beginState_Shrink() {
	this->timer = 1.0;
	Xkey_count = 4;
	keysX[0] = (HermiteKey){  0.0, this->scale.y,       1.0 };
	keysX[1] = (HermiteKey){ 20.0, this->scale.y - 2.0, 1.0 };
	keysX[2] = (HermiteKey){ 40.0, this->scale.y,       1.0 };
	keysX[3] = (HermiteKey){ 59.0, this->scale.y - 2.0, 1.0 };

	// disable being hit
	Vec tempVec = (Vec){0.0, 0.0, 0.0};
	// setNewActivePhysicsRect(this,  &tempVec );
}
void daMegaGoomba_c::executeState_Shrink() { 
	this->timer += 1.0;
	
	float modifier = GetHermiteCurveValue(this->timer, this->keysX, Xkey_count);
	this->scale = (Vec){modifier, modifier, modifier};

	if(this->timer == 2.0)
		PlaySound(this, SE_EMY_KURIBO_L_DAMAGE_02);

	if (this->timer > 60.0) { doStateChange(&StateID_Walk); }
}
void daMegaGoomba_c::endState_Shrink() {
	// enable being hit
	// setNewActivePhysicsRect(this, &this->scale);
	this->already_hit = false;
}



// Launch State - Launches some small goombas up in arcs
void daMegaGoomba_c::beginState_Launch() { 
	this->timer = 0.0; 
	rot.y = 0x0;
}
void daMegaGoomba_c::executeState_Launch() { 
		
	if (this->timer < 120.0) {
		// 3 shakes per second, exactly 24 shakes overall
		this->rot.y = sin(this->timer * 3.14 / 5) * 4000;

		dStageActor_c *spawner = NULL;
		// 120ticks /  120numbers * 3cases  = 3avg kuribo
		int randChoice = GenerateRandomNumber(120);
		int randChoiceX = GenerateRandomNumber(10);
		int randChoiceY = GenerateRandomNumber(7);
		switch(randChoice) {
			case 0:
			case 1:
				spawner = CreateActor(EN_KURIBO, 0, this->pos, 0, 0);
				spawner->speed.x = randChoiceX - 5.0;
				spawner->speed.y = randChoiceY + 6.0;
				spawner->scale = (Vec){1.0, 1.0, 1.0};
				break;
			case 2:
				spawner = CreateActor(EN_BEANS_KURIBO, 0, this->pos, 0, 0);
				spawner->speed.x = randChoiceX - 5.0;
				spawner->speed.y = randChoiceY + 6.0;
				spawner->scale = (Vec){1.0, 1.0, 1.0};
				break;
			case 3:
				spawner = CreateActor(EN_PATA_KURIBO, 0, this->pos, 0, 0);
				spawner->speed.x = randChoiceX - 5.0;
				spawner->speed.y = randChoiceY + 6.0;
				spawner->scale = (Vec){1.0, 1.0, 1.0};
				break;
			default:
				break;
		};
	}

	if (this->timer > 150.0) { doStateChange(&StateID_Walk); }
	this->timer = this->timer + 1.0;
}
void daMegaGoomba_c::endState_Launch() { 
	//rot.y = (this->direction) ? 0xe000 : 0x2000;
}

// Jump State
void daMegaGoomba_c::beginState_Jump() {
	this->timer = 1.0;

	//Variables for choosing a curve
	float jump_height = this->JumpHeight;
	float delta = (this->direction) ? -JumpDist : JumpDist;
	float fullTime = this->JumpTime;
	//Key count
	Xkey_count = 2;
	Ykey_count = 3;

	//Initial Position
	keysX[0] = (HermiteKey){ 0.0, this->pos.x, 0.0 };
	keysY[0] = (HermiteKey){ 0.0, this->pos.y, 0.8 };

	//Middle Position
	keysY[1] = (HermiteKey){ (fullTime/2.0), this->pos.y + jump_height, 0.0 };

	//End Position
	keysX[1] = (HermiteKey){ fullTime, this->pos.x + delta, 0.0 };
	keysY[2] = (HermiteKey){ fullTime, this->pos.y, 0.8 };

	// using this to stop walk animation
	this->animationChr.setCurrentFrame(900.0);
}
void daMegaGoomba_c::executeState_Jump() { 

	this->pos.x = GetHermiteCurveValue(this->timer, this->keysX, Xkey_count);
	this->pos.y = GetHermiteCurveValue(this->timer, this->keysY, Ykey_count);

	float TimerMax = JumpTime + 1.0;
	if (this->timer > TimerMax) {
		doStateChange(&StateID_Walk);
	}

	this->timer = this->timer + 1.0;

}
void daMegaGoomba_c::endState_Jump() { }


// Turn State
void daMegaGoomba_c::beginState_Turn() {
	this->direction ^= 1;
	this->speed.x = 0.0;
}
void daMegaGoomba_c::executeState_Turn() { 
	this->bodyModel._vf1C();
	this->animationPat.process();

	this->HandleYSpeed();
	this->doSpriteMovement();

	/*this->_vf2D0();	//nullsub();*/
	int ret = SomeStrangeModification(this);

	if(ret & 1)
		this->speed.y = 0.0;
	if(ret & 4)
		this->pos.x = this->last_pos.x;
	DoStuffAndMarkDead(this, this->pos, 1.0);
	u16 amt = (this->direction == 0) ? 0x2000 : 0xE000;
	int done = SmoothRotation(&this->rot.y, amt, 0x200);
	if(done) {
		this->doStateChange(&StateID_Walk);
	}
}
void daMegaGoomba_c::endState_Turn() {
	this->max_speed.x = (this->direction) ? -this->XSpeed : this->XSpeed;
}


// Walk State
void daMegaGoomba_c::beginState_Walk() {
	//inline this piece of code
	this->direction = dSprite_c__getXDirectionOfFurthestPlayerRelativeToVEC3(this, this->pos);
	OSReport("Direction: %d\n", this->direction);
	this->speed.x = this->speed.z = 0.0;
	this->max_speed.x = (this->direction) ? -this->XSpeed : this->XSpeed;
	this->speed.y = -4.0;
	this->y_speed_inc = -0.1875;
}
void daMegaGoomba_c::executeState_Walk() { 
	/* 800345e0 - daEnLkuribo_c::executeState_Walk() */
	this->bodyModel._vf1C();
	this->animationPat.process();
	//HOMEMADE//
	this->HandleXSpeed();
	this->HandleYSpeed();
	this->doSpriteMovement();
	u16 amt = (this->direction == 0) ? 0x2000 : 0xE000;
	SmoothRotation(&this->rot.y, amt, 0x200);
	/*this->_vf2D0();	//nullsub();*/
	int ret = SomeStrangeModification(this);
	if(ret & 1)
		this->speed.y = 0.0;
	u32 bitfield = this->collMgr.bitfield_for_checks;
	if(bitfield & (0x15<<this->direction)) {
		this->pos.x = this->last_pos.x;
		this->doStateChange(&StateID_Turn);
		//this->acState.setField10ToOne();
	}
	u32 bitfield2 = this->collMgr.directional_bitfields[this->direction];
	if(bitfield2) {
		OSReport("Found wall: %08x\n", bitfield2);
		this->doStateChange(&StateID_Turn);
	}
	DoStuffAndMarkDead(this, this->pos, 1.0);

	if(this->animationChr.isAnimationDone()) {
		this->animationChr.setCurrentFrame(0.0);

		int Choice = GenerateRandomNumber(6);
		switch(Choice) {
			case 0:
				//doStateChange(&StateID_Jump);
				this->speed.y = 5.0 + (1.0 * (life - 2));
				break;
			case 1:
				doStateChange(&StateID_Launch);
				break;
			default:
				int new_dir = dSprite_c__getXDirectionOfFurthestPlayerRelativeToVEC3(this, pos);
				if(this->direction != new_dir)
					doStateChange(&StateID_Turn);
				break;
		};
		
	}
#if 0
	//if(CollidedWithTile(this->classAt1EC)) {
	if( this->collMgr.CollidedWithTile() {
		OSReport("CollidedWithTile() : true [%08x]\n", this->collMgr.bitfield_for_checks);
	}
#endif

}
void daMegaGoomba_c::endState_Walk() { }