TapestryEngine

19ba4781b5d7690488d8b573ad84158ac0aba6e7.svn-base (12876B)

---

 #ifndef ACTOR_H
 #define ACTOR_H
 
 #include "Utils.h"
 #include "Console.h"
 #include "Animation.h"
 #include "AnimationGraph.h"
 #include "Physics.h"
 #include "Terrain.h"
 #include "ActorHandle.h"
 
 //Actor State Defines
 #define IDLE       10
 #define RUN        20
 #define IDLE_BEGIN 30
 #define JUMP       40
 #define WANDER     50
 #define PURSUE     60
 
 #define ALIVE      70
 #define DEAD	   80
 
 #define SPLASH	   90
 
 #define RUN_LEFT  0x1
 #define RUN_RIGHT 0x02
 #define RUN_DOWN  0x003
 #define RUN_UP    0x0004
 //
 
 struct Trajectory
 {
 	float slope;
 	int dir;
 };
 
 class Actor : public EventReceiver
 {
 public:
 
 	Actor() : mOpacity(255) {}
 
 	Actor(AnimGraph* AnimData, SDL_Rect Pos, SDL_Rect DrawPos, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib);
 
 	virtual bool UpdateAnimation() = 0;
 
 	virtual bool ActorUpdate() = 0;
 
 	int GetX()
 	{
 		return mPosData.x;
 	}
 
 	int GetY()
 	{
 		return mPosData.y;
 	}
 
 	int GetHeight()
 	{
 		return mPosData.h;
 	}
 
 	int GetWidth()
 	{
 		return mPosData.w;
 	}
 
 	int GetDrawX()
 	{
 		return mDrawPos.x;
 	}
 
 	int GetDrawY()
 	{
 		return mDrawPos.y;
 	}
 
 	int GetDrawHeight()
 	{
 		return mDrawPos.h;
 	}
 
 	int GetDrawWidth()
 	{
 		return mDrawPos.w;
 	}
 
 	SDL_Rect* GetPosition()
 	{
 		return &mPosData;
 	}
 
 	SDL_Rect* GetDrawPosition()
 	{
 		return &mDrawPos;
 	}
 
 	SDL_Rect CalcDrawRect()
 	{
 		if (mDir == RIGHT)
 		{
 			mDrawPos.x = mOff_x;
 		}
 		else //mDir = LEFT
 		{
 			mDrawPos.x = -(mDrawPos.w + (mOff_x - mPosData.w) );
 		}
 		return mDrawPos;
 	}
 
 	int GetOpacity()
 	{
 		return mOpacity;
 	}
 
 	int SetOpacity(int i)
 	{
 		return mOpacity = i;
 	}
 
 	Frame* GetFrame()
 	{
 		return mFrame;
 	}
 
 	int GetState()
 	{
 		return mState;
 	}
 
 	int GetDir()
 	{
 		return mDir;
 	}
 
 	std::vector<Actor*> GetHats()
 	{
 		return mHats;
 	}
 
 	int AttachHat(Actor* hat)
 	{
 		mHats.push_back(hat);
 		return ((int)mHats.size() - 1);
 	}
 
 	int SetHandle(int i)
 	{
 		return mHandle = i;
 	}
 
 	int GetHandle()
 	{
 		return mHandle;
 	}
 
 	int SetSpatID(int i)
 	{
 		return mSpatID = i;
 	}
 
 	int GetSpatID()
 	{
 		return mSpatID;
 	}
 
 	AnimGraph* GetAnimGraph()
 	{
 		return mAnimGraph;
 	}
 
 	void PassAnimGraphState()
 	{
 		mAnimGraph->GiveActorState(&mAnimID);
 	}
 
 	int GetAnimID()
 	{
 		return mAnimID;
 	}
 
 	int GetChannel()
 	{
 		return mSoundChannel;
 	}
 
 	bool IsBlocking()
 	{
 		return mBlocking;
 	}
 
 	EventFeed mFeed;
 
 protected:
 
 	AnimGraph* mAnimGraph;
 	Frame* mFrame;
 	int mOpacity;
 
 	int mState;
 	int mDir;
 	int mAnimID;
 
 	SDL_Rect mPosData; //Where the actors collision box is
 	SDL_Rect mDrawPos; //Where the actor is drawn relative to its physical position (mPosData)
 	
 	int mOff_x;
 	int mOff_y;
 
 	std::vector<Actor*> mHats;
 
 	ActorHandleManager* mAHM;
 	int mHandle;
 
 	EventReceiver* mSpat; //SpatialMonitor deals with actor collision and other region checking (like LoS)
 	int mSpatID;          //!This should become the same as mHandle!		Used by mSpat to ID this actor
 
 	EventReceiver* mParticleLib; //Deal with the spawning of particles
 
 	EventReceiver* mSoundLib;	//Deals with sounds and the spawning or point sounds
 	int mSoundChannel; //used to play sounds directly from the actor
 
 	bool mBlocking;
 };
 
 class Winch : public Actor
 {
 public:
 	Winch(AnimGraph* AnimData, SDL_Rect Pos, SDL_Rect DrawPos, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib, Actor* gate, int dir) : Actor(AnimData, Pos, DrawPos, AHM, spat, prtLib, SoundLib), mGate(gate)
 	{
 		mState = IDLE;
 		mDir = dir;
 	}
 
 	bool EventProcess(Event eve);
 
 	bool UpdateAnimation();
 
 	bool ActorUpdate();
 
 protected:
 
 	Actor* mGate;
 };
 
 class Blocker : public Actor
 {
 public:
 	Blocker(AnimGraph* AnimData, SDL_Rect Pos, SDL_Rect DrawPos, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib);
 
 protected:
 };
 
 class Test_Blocker : public Blocker
 {
 public:
 	Test_Blocker(AnimGraph* AnimData, SDL_Rect Pos, SDL_Rect DrawPos, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib);
 
 	bool EventProcess(Event eve);
 
 	bool UpdateAnimation();
 
 	bool ActorUpdate();
 protected:
 };
 
 class Gate : public Blocker
 {
 public:
 	Gate(AnimGraph* AnimData, SDL_Rect Pos, SDL_Rect DrawPos, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib, int dir);
 
 	bool EventProcess(Event eve);
 
 	bool UpdateAnimation();
 
 	bool ActorUpdate();
 protected:
 };
 
 class Interactable : public Actor
 {
 public:
 
 	Interactable(AnimGraph* AnimData, SDL_Rect Pos, SDL_Rect DrawPos, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib);
 
 protected:
 };
 
 class Talker : public Interactable
 {
 public:
 	Talker(AnimGraph* AnimData, SDL_Rect Pos, SDL_Rect DrawPos, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib, char* str) : Interactable(AnimData, Pos, DrawPos, AHM, spat, prtLib, SoundLib), mStr(str)
 	{}
 	
 	bool EventProcess(Event eve);
 
 	bool UpdateAnimation();
 
 	bool ActorUpdate();
 
 protected:
 
 	char* mStr;
 };
 
 class Gateman : public Talker
 {
 public:
 
 	//Gateman(AnimGraph* AnimData, SDL_Rect Pos, SDL_Rect DrawPos, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib, char* str, EventReceiver* gate) : Talker(AnimData, Pos, DrawPos, AHM, spat, prtLib, SoundLib, str), mGate(gate)
 	Gateman(AnimGraph* AnimData, SDL_Rect Pos, SDL_Rect DrawPos, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib, char* str, int gate) : Talker(AnimData, Pos, DrawPos, AHM, spat, prtLib, SoundLib, str), mGateH(gate)
 	{
 		mLOS = Pos;
 		mLOS.w = 250;
 		mLOS.x = mLOS.x - 125 - (int)((float)mPosData.w / 2);//(mLOS.x - (30 - (mPosData.w) / 2));
 		mLOS.h = 70;
 
 		mTalked = false;
 		mState = GATE_DOWN;
 	}
 
 	bool EventProcess(Event eve);
 
 	bool UpdateAnimation();
 
 	bool ActorUpdate();
 
 protected:
 
 	SDL_Rect mLOS;
 	//EventReceiver* mGate;
 	int mGateH;
 
 	bool mTalked;
 };
 
 class Door : public Interactable
 {
 public:
 
 	Door(AnimGraph* AnimData, SDL_Rect Pos, SDL_Rect DrawPos, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib, int x_off, int y_off) : Interactable(AnimData, Pos, DrawPos, AHM, spat, prtLib, SoundLib)
 	{
 		mTele_Pos = mPosData;
 		mTele_Pos.x += x_off;
 		mTele_Pos.y += y_off;
 	}
 
 	SDL_Rect* GetTelePos()
 	{
 		return &mTele_Pos;
 	}
 
 	void SetTeleDest(SDL_Rect* dest)
 	{
 		mTele_Dest = dest;
 	}
 
 	bool EventProcess(Event eve);
 
 	bool UpdateAnimation();
 
 	bool ActorUpdate();
 
 protected:
 
 	SDL_Rect mTele_Pos;
 	SDL_Rect* mTele_Dest;
 };
 
 class Mobile : public Actor
 {
 public:
 
 	Mobile() : mXspd(0), mYspd(0) {}
 
 	Mobile(AnimGraph* AnimData, SDL_Rect Pos, SDL_Rect DrawPos, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib);
 	
 	void SetPosition(SDL_Rect* Dest);
 
 	bool ModifyActorPosition(int x, int y);
 
 	SDL_Rect MoveActor(int xspd, int yspd);
 
 	int MoveActorDirect(float xspd, float yspd);
 
 protected:
 	float mXspd;
 	float mYspd;
 	int mXmove;
 	int mYmove;
 };
 
 class Hat : public Mobile
 {
 public:
 	Hat(AnimGraph* AnimData, Actor* tar, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib) : mTarget(tar), Mobile(AnimData, *tar->GetPosition(), *tar->GetDrawPosition(), AHM, spat, prtLib, SoundLib)
 	{
 		mEnabled = true;
 	}
 
 	bool IsEnabled()
 	{
 		return mEnabled;
 	}
 
 	void ToggleHat(bool state)
 	{
 		mEnabled = state;
 	}
 
 	bool EventProcess(Event eve)
 	{
 		return true;
 	}
 
 	bool ActorUpdate();
 
 protected:
 
 	Actor* mTarget;
 	bool mEnabled;
 };
 
 class bad_hat : public Hat
 {
 public:
 	
 	bad_hat(AnimGraph* AnimData, Actor* tar, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib) : Hat(AnimData, tar, AHM, spat, prtLib, SoundLib)
 	{
 	}
 
 	bool UpdateAnimation()
 	{
 		switch (mState)
 		{
 		case RUN:
 		default:
 			mAnimID = IDLE;
 			break;
 		}
 		mFrame = mAnimGraph->UpdateAnimation();
 		return false;
 	}
 protected:
 };
 
 class sword : public Hat
 {
 public:
 
 	sword(AnimGraph* AnimData, Actor* tar, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib) : Hat(AnimData, tar, AHM, spat, prtLib, SoundLib)
 	{
 		mEnabled = false;
 	}
 
 	bool UpdateAnimation()
 	{
 		mAnimID = mTarget->GetAnimID();
 		mFrame = mAnimGraph->UpdateAnimation();
 		return false;
 	}
 protected:
 };
 
 class Character : public Mobile
 {
 public:
 
 	Character() {}
 
 	Character(SDL_Surface* ter, AnimGraph* AnimData, SDL_Rect Pos, SDL_Rect DrawPos, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib);
 
 	bool DetectFalling()
 	{
 		SDL_Rect GroundDetector = mPosData;
 		GroundDetector.y = (mPosData.y + mPosData.h);
 		GroundDetector.h = 1;
 		if (mColMan.DetectFalling() == true && (mSpat->EventProcess(Event(CHECK_BLOCKERS, Touch, &GroundDetector, mSpatID)) == false))
 		{
 			return true;
 		}
 		else
 		{
 			return false;
 		}
 	}
 
 	bool UpdatePhysics();
 
 	bool UpdateFireables();
 
 	Trajectory GetTrajectory(SDL_Rect Dest, SDL_Rect Init);
 
 	SDL_Rect RefinePosition(SDL_Rect* Dest, Trajectory trj, float destx, float desty, int RecursionCount = 0);
 
 	bool HandleDirectionalCollisions(SDL_Rect& Destination);
 
 	bool UpdatePosition();
 
 	TerrainCollisionManager* getColMan()
 	{
 		return &mColMan;
 	}
 
 protected:
 
 	SDL_Rect mDestData;
 	colman_Character mColMan;
 	PhysicsManager mPhysMan;
 };
 
 class Player : public Character
 {
 public:
 	Player() {}
 
 	Player(SDL_Surface* ter, AnimGraph* AnimData, SDL_Rect Pos, SDL_Rect DrawPos, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib) : mWielded(false), mTalker(NULL), mHP(100), mHPmax(100), mRecover(0), mTouch(Pos), Character(ter, AnimData, Pos, DrawPos, AHM, spat, prtLib, SoundLib)
 	{
 		mTouch.h = Pos.h;
 		mTouch.w = 18;
 	}
 
 	bool EventProcess(Event eve);
 
 	bool UpdateAnimation();
 
 	bool ActorUpdate();
 
 	int* GetHP()
 	{
 		return &mHP;
 	}
 
 	int* GetMaxHP()
 	{
 		return &mHPmax;
 	}
 
 	void SetSword(int index)
 	{
 		mHatIndex_Sword = index;
 	}
 
 protected:
 
 //	bool mTalking;
 	EventReceiver* mTalker;
 
 	bool mWielded;
 	int mHatIndex_Sword;
 
 	int mHP;
 	int mHPmax;
 
 	int mRecover; //Timer to force recovery pause between jumps
 
 	SDL_Rect mTouch; //Rect that deterimes what can be interacted with
 };
 
 class Loyal_Bug : public Character
 {
 public:
 	Loyal_Bug(SDL_Surface* ter, AnimGraph* AnimData, SDL_Rect Pos, SDL_Rect DrawPos, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib) : mMounted(false), Character(ter, AnimData, Pos, DrawPos, AHM, spat, prtLib, SoundLib)
 	{
 	}
 
 	bool EventProcess(Event eve);
 
 	bool UpdateAnimation();
 
 	bool ActorUpdate();
 
 protected:
 
 	bool mMounted;
 };
 
 class Bug : public Character
 {
 public:
 	Bug(SDL_Surface* ter, AnimGraph* AnimData, SDL_Rect Pos, SDL_Rect DrawPos, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib) : Character(ter, AnimData, Pos, DrawPos, AHM, spat, prtLib, SoundLib)
 	{
 	}
 
 protected:
 
 	int mTimer;
 
 };
 
 class Wanderer : public Character
 {
 public:
 
 	Wanderer() : mWaitLimit(0), mWaitTimer(0), mWanderLimit(0), mWanderTimer(0) {}
 
 	Wanderer(SDL_Surface* ter, AnimGraph* AnimData, SDL_Rect Pos, SDL_Rect DrawPos, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib) : Character(ter, AnimData, Pos, DrawPos, AHM, spat, prtLib, SoundLib), mWanderTimer(0), mWanderLimit(0), mWaitTimer(0), mWaitLimit(0)
 	{
 	}
 
 	bool Wander();
 
 	bool WaitRandom();
 
 	bool EventProcess(Event eve);
 
 	virtual bool UpdateAnimation();
 
 	bool ActorUpdate();
 
 protected:
 
 	int mWanderTimer;
 	int mWanderLimit;
 	int mWaitLimit;
 	int mWaitTimer;
 };
 
 class Pursuer : public Character
 {
 public:
 	Pursuer() {}
 
 	Pursuer(SDL_Surface* ter, AnimGraph* AnimData, SDL_Rect Pos, SDL_Rect DrawPos, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib) : Character(ter, AnimData, Pos, DrawPos, AHM, spat, prtLib, SoundLib), mRestTimer(0)
 	{
 		mState = IDLE;
 		mLOS = mPosData;
 		mLOS.x -= (170 - mLOS.w) / 2;
 		mLOS.w = 170;
 	}
 
 	bool Pursue();
 
 	bool rest(int t);
 
 	bool EventProcess(Event eve);
 
 	virtual bool UpdateAnimation();
 
 	bool ActorUpdate();
 
 protected:
 
 	Actor* mTarget;
 	int mRestTimer;
 	SDL_Rect mLOS;
 };
 
 class Rabbit : public Character
 {
 public:
 	Rabbit() {}
 
 	Rabbit(SDL_Surface* ter, AnimGraph* AnimData, SDL_Rect Pos, SDL_Rect DrawPos, ActorHandleManager* AHM, EventReceiver* spat, EventReceiver* prtLib, EventReceiver* SoundLib) : Character(ter, AnimData, Pos, DrawPos, AHM, spat, prtLib, SoundLib), mWaitLimit(0), mWaitTimer(0), mWanderLimit(0), mWanderTimer(0)
 	{
 	}
 
 	bool Hop();
 
 	bool Wander();
 
 	bool Behave();
 
 	bool WaitRandom();
 
 	bool EventProcess(Event eve);
 
 	virtual bool UpdateAnimation();
 
 	bool ActorUpdate();
 
 protected:
 
 	int mWanderTimer;
 	int mWanderLimit;
 	int mWaitLimit;
 	int mWaitTimer;
 };
 
 #endif