makefile.gaz

@@ -134,6 +134,7 @@ player_src :=		player \
 					pschop \
 					psduck \
 					psfall \
+					psidle \
 					psjump \
 					psrun \
 					pstates

source/game/game.cpp

@@ -128,11 +128,15 @@ void	CGameScene::think(int _frames)
 	CConversation::think(_frames);
 	if(!CConversation::isActive())
 	{
-		DVECTOR	mapPos;
+		DVECTOR	camPos;
 		CThing::thinkAllThings(_frames);
-		mapPos=m_player->getPos();
+		camPos=m_player->getCameraPos();
-		CBubicleFactory::setMapOffset(&mapPos);
+//PKG
-		Level.setCameraCentre(mapPos);
+if(camPos.vx<0)camPos.vx=0;
+if(camPos.vy<0)camPos.vy=0;
+//PKG		
+		CBubicleFactory::setMapOffset(&camPos);
+		Level.setCameraCentre(camPos);
 		Level.think(_frames);
 	}
 }

source/player/player.cpp

@@ -41,6 +41,10 @@
 #include "player\psfall.h"
 #endif
 
+#ifndef __PLAYER__PSIDLE_H__
+#include "player\psidle.h"
+#endif
+
 #ifndef __PLAYER__PSBUTT_H__
 #include "player\psbutt.h"
 #endif
@@ -67,6 +71,11 @@
 /*	Data
 	---- */
 
+#ifndef	__ANIM_PLAYER_ANIM_HEADER__
+#include <player_anim.h>
+#endif
+
+
 /*----------------------------------------------------------------------
 	Tyepdefs && Defines
 	------------------- */
@@ -93,25 +102,41 @@ CPlayerStateButtBounceFall	stateButtBounceFall;
 CPlayerStateButtBounceLand	stateButtBounceLand;
 CPlayerStateChop			stateChop;
 CPlayerStateRunChop			stateRunChop;
+CPlayerStateAirChop			stateAirChop;
 CPlayerStateDuck			stateDuck;
 CPlayerStateSoakUp			stateSoackUp;
 CPlayerStateGetUp			stateGetup;
 
-CPlayerState *CPlayer::s_states[NUM_STATES]=
+// Player with karate chop installed
+CPlayer::PlayerMode CPlayer::s_modes=
 {
-	&stateIdle,				// STATE_IDLE
+	{	{
-	&stateJump,				// STATE_JUMP
+		8,						// PM__JUMP_VELOCITY
-	&stateRun,				// STATE_RUN
+		10,						// PM__MAX_JUMP_FRAMES
-	&stateFall,				// STATE_FALL
+		20,						// PM__MAX_SAFE_FALL_FRAMES
-	&stateFallFar,			// STATE_FALLFAR
+		4,						// PM__GRAVITY_VALUE
-	&stateButtBounce,		// STATE_BUTTBOUNCE
+		8,						// PM__TERMINAL_VELOCITY
-	&stateButtBounceFall,	// STATE_BUTTFALL
+		8,						// PM__MAX_RUN_VELOCITY
-	&stateButtBounceLand,	// STATE_BUTTLAND
+		4,						// PM__RUN_SPEEDUP
-	&stateChop,				// STATE_CHOP
+		2,						// PM__RUN_REVERSESLOWDOWN
-	&stateRunChop,			// STATE_RUNCHOP
+		1,						// PM__RUN_SLOWDOWN
-	&stateDuck,				// STATE_DUCK
+	}	},
-	&stateSoackUp,			// STATE_SOAKUP
+	{
-	&stateGetup,			// STATE_GETUP
+		&stateIdle,				// STATE_IDLE
+		&stateJump,				// STATE_JUMP
+		&stateRun,				// STATE_RUN
+		&stateFall,				// STATE_FALL
+		&stateFallFar,			// STATE_FALLFAR
+		&stateButtBounce,		// STATE_BUTTBOUNCE
+		&stateButtBounceFall,	// STATE_BUTTFALL
+		&stateButtBounceLand,	// STATE_BUTTLAND
+		&stateChop,				// STATE_ATTACK
+		&stateRunChop,			// STATE_RUNATTACK
+		&stateAirChop,			// STATE_AIRATTACK
+		&stateDuck,				// STATE_DUCK
+		&stateSoackUp,			// STATE_SOAKUP
+		&stateGetup,			// STATE_GETUP
+	}
 };
 
 
@@ -148,6 +173,11 @@ m_animFrame=0;
 	Pos.vx=10;
 	Pos.vy=10;
 #endif
+
+	m_cameraOffsetTarget.vx=0;
+	m_cameraOffsetTarget.vy=0;
+	m_cameraOffset.vx=0;
+	m_cameraOffset.vy=0;
 }
 
 /*----------------------------------------------------------------------
@@ -167,8 +197,11 @@ void	CPlayer::shutdown()
 	Params:
 	Returns:
   ---------------------------------------------------------------------- */
+DVECTOR ofs={0,0};
 void	CPlayer::think(int _frames)
 {
+	int	i;
+	
 	CThing::think(_frames);
 
 #ifndef __USER_paul__
@@ -178,11 +211,10 @@ void	CPlayer::think(int _frames)
 	if(padInput&PAD_DOWN)	Pos.vy+=move;
 	if(padInput&PAD_LEFT)	Pos.vx-=move;
 	if(padInput&PAD_RIGHT)	Pos.vx+=move;
-	m_invincibleFrameCount=0;
 #else
 	if(_frames>=3)_frames=2;
 
-	for(int i=0;i<_frames;i++)
+	for(i=0;i<_frames;i++)
 	{
 		// Think
 		m_currentState->think(this);
@@ -190,33 +222,87 @@ void	CPlayer::think(int _frames)
 		Pos.vy+=m_moveVel.vy>>VELOCITY_SHIFT;
 
 		// Ground collision
-		if(m_moveVel.vy&&isOnSolidGround())
+		if(isOnSolidGround())
 		{
-			if(m_state==STATE_BUTTFALL)
+			if(m_moveVel.vy)
 			{
-				setState(STATE_BUTTLAND);
+				// Was falling.. so we've just hit the ground
+				if(m_state==STATE_BUTTFALL)
+				{
+					setState(STATE_BUTTLAND);
+				}
+				else if(m_state==STATE_FALLFAR)
+				{
+					setState(STATE_IDLE);
+				}
+				else if(m_moveVel.vx)
+				{
+					setState(STATE_RUN);
+					setAnimNo(ANIM_PLAYER_ANIM_RUNJUMPEND);
+				}
+				else
+				{
+					setState(STATE_IDLE);
+					setAnimNo(ANIM_PLAYER_ANIM_JUMPEND);
+				}
+				m_moveVel.vy=0;
+				m_fallFrames=0;
 			}
-			else if(m_state==STATE_FALLFAR)
+		}
+		else
+		{
+			if(m_state!=STATE_JUMP&&m_state!=STATE_BUTTBOUNCE)
 			{
-				setState(STATE_IDLE);
+				// Fall
+				const PlayerMetrics	*metrics;
+				metrics=getPlayerMetrics();
+				m_moveVel.vy+=metrics->m_metric[PM__GRAVITY_VALUE];
+				if(m_moveVel.vy>=metrics->m_metric[PM__TERMINAL_VELOCITY]<<VELOCITY_SHIFT)
+				{
+					m_moveVel.vy=metrics->m_metric[PM__TERMINAL_VELOCITY]<<VELOCITY_SHIFT;
+					m_fallFrames++;
+					if(m_fallFrames>metrics->m_metric[PM__MAX_SAFE_FALL_FRAMES])
+					{
+						setState(STATE_FALLFAR);
+					}
+				}
 			}
-			else if(m_moveVel.vx)
-			{
-				setState(STATE_RUN);
-			}
-			else
-			{
-				setState(STATE_IDLE);
-			}
-			m_moveVel.vy=0;
 		}
 
+		// Flashing..
 		if(m_invincibleFrameCount)
 		{
 			m_invincibleFrameCount--;
 		}
 	}
+
+
 #endif
+m_invincibleFrameCount=0;
+	// Move the camera offset
+	for(i=0;i<_frames;i++)
+	{
+		m_cameraOffsetTarget=ofs;		
+		m_cameraOffset=ofs;
+		/*
+		int moveDelta;
+		moveDelta=(m_cameraOffset.vx-m_cameraOffsetTarget.vx);
+		if(moveDelta)
+		{
+		if(moveDelta<0)
+		{
+					moveDelta>>=2;
+					if(moveDelta==0)moveDelta=1;
+					}
+					else if(moveDelta>0)
+					{
+					moveDelta>>=2;
+					if(moveDelta==0)moveDelta=-1;
+					}
+					m_cameraOffset.vx+=moveDelta;
+					}
+		*/
+	}
 	if(Pos.vx<0)Pos.vx=0;
 	if(Pos.vy<0)Pos.vy=0;
 }
@@ -228,15 +314,15 @@ void	CPlayer::think(int _frames)
 	Returns:
   ---------------------------------------------------------------------- */
 int panim=-1;
-int MASK=2;
+SVECTOR ppos={0,1024,5000};
 void	CPlayer::render()
 {
 	CThing::render();
 	
 	// Render
-	if(m_invincibleFrameCount==0||
+	if(m_invincibleFrameCount==0||m_invincibleFrameCount&2)
-	   m_invincibleFrameCount&MASK)
 	{
+		m_skel.setPos(&ppos);
 		m_skel.setFrame(m_animFrame);
 		if(panim!=-1)
 			m_skel.setAnimNo(panim);
@@ -249,6 +335,20 @@ void	CPlayer::render()
 
 
 
+/*----------------------------------------------------------------------
+	Function:
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
+DVECTOR CPlayer::getCameraPos()
+{
+	DVECTOR	cameraPos;
+	cameraPos.vx=Pos.vx;//+m_cameraOffset.vx;
+	cameraPos.vy=Pos.vy;//+m_cameraOffset.vy;
+	return cameraPos;
+}
+
 
 
 
@@ -258,23 +358,9 @@ void	CPlayer::render()
 	Params:
 	Returns:
   ---------------------------------------------------------------------- */
-PlayerMetrics s_normalPlayerMetrics=
-{
-	{
-		8,		// PM__JUMP_VELOCITY
-		10,		// PM__MAX_JUMP_FRAMES
-		20,		// PM__MAX_SAFE_FALL_FRAMES
-		4,		// PM__GRAVITY_VALUE
-		8,		// PM__TERMINAL_VELOCITY
-		8,		// PM__MAX_RUN_VELOCITY
-		4,		// PM__RUN_SPEEDUP
-		2,		// PM__RUN_REVERSESLOWDOWN
-		1,		// PM__RUN_SLOWDOWN
-	}
-};
 const PlayerMetrics *CPlayer::getPlayerMetrics()
 {
-	return &s_normalPlayerMetrics;
+	return &s_modes.m_metrics;
 }
 
 
@@ -289,7 +375,7 @@ const PlayerMetrics *CPlayer::getPlayerMetrics()
   ---------------------------------------------------------------------- */
 void	CPlayer::setState(PLAYER_STATE _state)
 {
-	m_currentState=s_states[_state];
+	m_currentState=s_modes.m_states[_state];
 	m_currentState->enter(this);
 	m_state=_state;
 }
@@ -313,11 +399,11 @@ void CPlayer::setFacing(int _facing)
 		{
 			case FACING_LEFT:
 				m_facing=FACING_LEFT;
-				m_skel.setAng(512);
+				m_skel.setAng(1024);
 				break;
 			case FACING_RIGHT:
 				m_facing=FACING_RIGHT;
-				m_skel.setAng(3096+512);
+				m_skel.setAng(-1024);
 				break;
 			default:
 				ASSERT(0);
@@ -376,7 +462,7 @@ int CPlayer::getPadInput()
 
 int CPlayer::isOnSolidGround()
 {
-	return Pos.vy>400;
+	return Pos.vy>16*15;
 }
 
 

source/player/player.h

@@ -52,8 +52,9 @@ typedef enum
 	STATE_BUTTBOUNCE,
 	STATE_BUTTFALL,
 	STATE_BUTTLAND,
-	STATE_CHOP,
+	STATE_ATTACK,
-	STATE_RUNCHOP,
+	STATE_RUNATTACK,
+	STATE_AIRATTACK,
 	STATE_DUCK,
 	STATE_SOAKUP,
 	STATE_GETUP,
@@ -106,6 +107,8 @@ public:
 	void			think(int _frames);
 	void			render();
 
+	DVECTOR			getCameraPos();
+
 protected:		
 	const PlayerMetrics	*getPlayerMetrics();
 
@@ -135,6 +138,14 @@ friend class CPlayerState;
 
 private:
 
+	typedef struct
+	{
+		PlayerMetrics		m_metrics;
+		class CPlayerState	*m_states[NUM_STATES];
+	}PlayerMode;
+
+	static PlayerMode		s_modes;
+	
 	int				m_animFrame;
 	int				m_animNo;
 	PLAYER_STATE	m_state;
@@ -142,6 +153,7 @@ private:
 
 	DVECTOR			m_moveVel;
 	int				m_facing;
+	int				m_fallFrames;
 
 	enum
 	{
@@ -150,14 +162,13 @@ private:
 	};
 	int				m_invincibleFrameCount;
 
-	static class CPlayerState	*s_states[NUM_STATES];
+	class CPlayerState			*m_currentState;
-
-	class CPlayerState	*m_currentState;
-
-
 
 	int				m_lives;
 
+	DVECTOR			m_cameraOffsetTarget;
+	DVECTOR			m_cameraOffset;
+
 };
 
 

source/player/psbutt.cpp

@@ -82,49 +82,6 @@ void CPlayerStateButtBounce::think(CPlayer *_player)
 }
 
 
-/*----------------------------------------------------------------------
-	Function:
-	Purpose:
-	Params:
-	Returns:
-  ---------------------------------------------------------------------- */
-void CPlayerStateButtBounceFall::enter(CPlayer *_player)
-{
-//	setAnimNo(_player,ANIM_PLAYER_ANIM_JUMPSTART);
-	m_fallFrames=0;
-}
-
-
-/*----------------------------------------------------------------------
-	Function:
-	Purpose:
-	Params:
-	Returns:
-  ---------------------------------------------------------------------- */
-void CPlayerStateButtBounceFall::think(CPlayer *_player)
-{
-	const PlayerMetrics	*metrics;
-	int					control;
-	DVECTOR				move;
-
-	metrics=getPlayerMetrics(_player);
-	control=getPadInput(_player);
-
-	move=getMoveVelocity(_player);
-	move.vy+=metrics->m_metric[PM__GRAVITY_VALUE];
-	if(move.vy>=metrics->m_metric[PM__TERMINAL_VELOCITY]<<CPlayer::VELOCITY_SHIFT)
-	{
-		move.vy=metrics->m_metric[PM__TERMINAL_VELOCITY]<<CPlayer::VELOCITY_SHIFT;
-		m_fallFrames++;
-		if(m_fallFrames>metrics->m_metric[PM__MAX_SAFE_FALL_FRAMES])
-		{
-			setState(_player,STATE_FALLFAR);
-		}
-	}
-	setMoveVelocity(_player,&move);
-}
-
-
 /*----------------------------------------------------------------------
 	Function:
 	Purpose:

source/player/psbutt.h

@@ -42,13 +42,6 @@ public:
 
 class CPlayerStateButtBounceFall : public CPlayerState
 {
-public:
-	void			enter(class CPlayer *_player);
-	void			think(class CPlayer *_player);
-
-private:
-	int				m_fallFrames;
-	
 };
 
 class CPlayerStateButtBounceLand : public CPlayerState

source/player/pschop.cpp

@@ -120,5 +120,36 @@ void CPlayerStateRunChop::think(CPlayer *_player)
 }
 
 
+/*----------------------------------------------------------------------
+	Function:
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
+void CPlayerStateAirChop::think(CPlayer *_player)
+{
+	int	control;
+	control=getPadInput(_player);
+
+	if(control&CPadConfig::getButton(CPadConfig::PAD_CFG_LEFT))
+	{
+		moveLeft(_player);
+	}
+	else if(control&CPadConfig::getButton(CPadConfig::PAD_CFG_RIGHT))
+	{
+		moveRight(_player);
+	}
+	else
+	{
+		slowdown(_player);
+	}
+	
+	if(advanceAnimFrameAndCheckForEndOfAnim(_player))
+	{
+		setState(_player,STATE_FALL);
+	}
+}
+
+
 /*===========================================================================
  end */

source/player/pschop.h

@@ -49,6 +49,14 @@ public:
 };
 
 
+class CPlayerStateAirChop : public CPlayerStateChop
+{
+public:
+	void			think(class CPlayer *_player);
+
+};
+
+
 /*----------------------------------------------------------------------
 	Globals
 	------- */

source/player/psfall.cpp

@@ -1,4 +1,3 @@
-
 /*=========================================================================
 
 	psfall.cpp
@@ -65,8 +64,7 @@
   ---------------------------------------------------------------------- */
 void CPlayerStateFall::enter(CPlayer *_player)
 {
-	setAnimNo(_player,ANIM_PLAYER_ANIM_JUMPSTART);
+	setAnimNo(_player,ANIM_PLAYER_ANIM_HOVER);
-	m_fallFrames=0;
 }
 
 
@@ -85,19 +83,6 @@ void CPlayerStateFall::think(CPlayer *_player)
 	metrics=getPlayerMetrics(_player);
 	control=getPadInput(_player);
 
-	move=getMoveVelocity(_player);
-	move.vy+=metrics->m_metric[PM__GRAVITY_VALUE];
-	if(move.vy>=metrics->m_metric[PM__TERMINAL_VELOCITY]<<CPlayer::VELOCITY_SHIFT)
-	{
-		move.vy=metrics->m_metric[PM__TERMINAL_VELOCITY]<<CPlayer::VELOCITY_SHIFT;
-		m_fallFrames++;
-		if(m_fallFrames>metrics->m_metric[PM__MAX_SAFE_FALL_FRAMES])
-		{
-			setState(_player,STATE_FALLFAR);
-		}
-	}
-	setMoveVelocity(_player,&move);
-
 	if(control&CPadConfig::getButton(CPadConfig::PAD_CFG_LEFT))
 	{
 		moveLeft(_player);
@@ -111,13 +96,18 @@ void CPlayerStateFall::think(CPlayer *_player)
 		slowdown(_player);
 	}
 
-	if(control&CPadConfig::getButton(CPadConfig::PAD_CFG_DOWN))
+	if(control&CPadConfig::getButton(CPadConfig::PAD_CFG_ACTION))
+	{
+		setState(_player,STATE_AIRATTACK);
+	}
+	else if(control&CPadConfig::getButton(CPadConfig::PAD_CFG_DOWN))
 	{
 		move.vx=0;
 		move.vy=0;
 		setMoveVelocity(_player,&move);
 		setState(_player,STATE_BUTTBOUNCE);
 	}
+	advanceAnimFrameAndCheckForEndOfAnim(_player);	
 }
 
 

source/player/psfall.h

@@ -38,9 +38,6 @@ public:
 	void			enter(class CPlayer *_player);
 	void			think(class CPlayer *_player);
 
-private:
-	int				m_fallFrames;
-
 };
 
 

source/player/psjump.cpp

@@ -67,7 +67,7 @@ void CPlayerStateJump::enter(CPlayer *_player)
 
 	metrics=getPlayerMetrics(_player);
 
-	setAnimNo(_player,ANIM_PLAYER_ANIM_JUMPSTART);
+	setAnimNo(_player,ANIM_PLAYER_ANIM_HOVER);
 	m_jumpFrames=0;
 	DVECTOR	move=getMoveVelocity(_player);
 	move.vy=-metrics->m_metric[PM__JUMP_VELOCITY]<<CPlayer::VELOCITY_SHIFT;
@@ -95,19 +95,13 @@ void CPlayerStateJump::think(CPlayer *_player)
 	}
 	else
 	{
-		DVECTOR	move;
+		setState(_player,STATE_FALL);
-		move=getMoveVelocity(_player);
-		if(move.vy>=0)
-		{
-			setState(_player,STATE_FALL);
-		}
-		else
-		{
-			move.vy+=metrics->m_metric[PM__GRAVITY_VALUE];
-		}
-		setMoveVelocity(_player,&move);
 	}
 
+	if(control&CPadConfig::getButton(CPadConfig::PAD_CFG_ACTION))
+	{
+		setState(_player,STATE_AIRATTACK);
+	}
 	if(control&CPadConfig::getButton(CPadConfig::PAD_CFG_LEFT))
 	{
 		moveLeft(_player);
@@ -120,6 +114,7 @@ void CPlayerStateJump::think(CPlayer *_player)
 	{
 		slowdown(_player);
 	}
+advanceAnimFrameAndCheckForEndOfAnim(_player);	
 }
 
 

source/player/psrun.cpp

@@ -86,6 +86,8 @@ void CPlayerStateRun::enter(CPlayer *_player)
 	{
 		setFacing(_player,FACING_RIGHT);
 	}
+
+	m_numberOfTimeAnimHasLooped=0;
 }
 
 
@@ -110,7 +112,7 @@ void CPlayerStateRun::think(CPlayer *_player)
 	}
 	else if(control&CPadConfig::getButton(CPadConfig::PAD_CFG_ACTION))
 	{
-		setState(_player,STATE_RUNCHOP);
+		setState(_player,STATE_RUNATTACK);
 	}
 	else if(control&CPadConfig::getButton(CPadConfig::PAD_CFG_LEFT))
 	{
@@ -125,7 +127,10 @@ void CPlayerStateRun::think(CPlayer *_player)
 		if(getMoveVelocity(_player).vx==0)
 		{
 			setState(_player,STATE_IDLE);
-			setAnimNo(_player,ANIM_PLAYER_ANIM_RUNSTOP);
+			if(m_numberOfTimeAnimHasLooped>=2)
+			{
+				setAnimNo(_player,ANIM_PLAYER_ANIM_RUNSTOP);
+			}
 		}
 		else
 		{
@@ -136,6 +141,7 @@ void CPlayerStateRun::think(CPlayer *_player)
 	if(advanceAnimFrameAndCheckForEndOfAnim(_player))
 	{
 		setAnimNo(_player,ANIM_PLAYER_ANIM_RUN);
+		m_numberOfTimeAnimHasLooped++;
 	}
 }
 

source/player/psrun.h

@@ -37,6 +37,9 @@ class CPlayerStateRun : public CPlayerState
 public:
 	void			enter(class CPlayer *_player);
 	void			think(class CPlayer *_player);
+
+private:
+	int				m_numberOfTimeAnimHasLooped;
 };
 
 

source/player/pstates.cpp

@@ -1,57 +1,140 @@
+/*=========================================================================
+
+	pstates.cpp
+
+	Author:		PKG
+	Created: 
+	Project:	Spongebob
+	Purpose: 
+
+	Copyright (c) 2001 Climax Development Ltd
+
+===========================================================================*/
+
+
+/*----------------------------------------------------------------------
+	Includes
+	-------- */
+
 #include "player\pstates.h"
 
 #ifndef __PLAYER_PLAYER_H__
 #include "player\player.h"
 #endif
 
-#ifndef	__UTILS_HEADER__
-#include "utils\utils.h"
-#endif
 
-#ifndef __PAD_PADS_H__
+/*	Std Lib
-#include "pad\pads.h"
+	------- */
-#endif
 
+/*	Data
+	---- */
 
+/*----------------------------------------------------------------------
+	Tyepdefs && Defines
+	------------------- */
 
+/*----------------------------------------------------------------------
+	Structure defintions
+	-------------------- */
 
-#ifndef	__ANIM_PLAYER_ANIM_HEADER__
+/*----------------------------------------------------------------------
-#include <player_anim.h>
+	Function Prototypes
-#endif
+	------------------- */
 
+/*----------------------------------------------------------------------
+	Vars
+	---- */
 
-
+/*----------------------------------------------------------------------
-
+	Function:
-
+	Purpose:
-/*----------------------------------------------------------------------*/
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
 const PlayerMetrics *CPlayerState::getPlayerMetrics(CPlayer *_player)
 {
 	return _player->getPlayerMetrics();
 }
+
+
+/*----------------------------------------------------------------------
+	Function:
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
 void CPlayerState::setState(CPlayer *_player,int _state)
 {
 	_player->setState((PLAYER_STATE)_state);
 }
+
+
+/*----------------------------------------------------------------------
+	Function:
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
 int CPlayerState::getFacing(CPlayer *_player)
 {
 	return _player->getFacing();
 }
+
+
+/*----------------------------------------------------------------------
+	Function:
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
 void CPlayerState::setFacing(CPlayer *_player,int _facing)
 {
 	_player->setFacing(_facing);
 }
+
+
+/*----------------------------------------------------------------------
+	Function:
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
 int CPlayerState::getAnimNo(CPlayer *_player)
 {
 	return _player->getAnimNo();
 }
+
+
+/*----------------------------------------------------------------------
+	Function:
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
 void CPlayerState::setAnimNo(CPlayer *_player,int _animNo)
 {
 	_player->setAnimNo(_animNo);
 }
+
+
+/*----------------------------------------------------------------------
+	Function:
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
 void CPlayerState::setAnimFrame(CPlayer *_player,int _animFrame)
 {
 	_player->setAnimFrame(_animFrame);
 }
+
+
+/*----------------------------------------------------------------------
+	Function:
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
 int CPlayerState::advanceAnimFrameAndCheckForEndOfAnim(class CPlayer *_player)
 {
 	int	animFrame,frameCount;
@@ -67,81 +150,137 @@ int CPlayerState::advanceAnimFrameAndCheckForEndOfAnim(class CPlayer *_player)
 	_player->setAnimFrame(animFrame);
 	return looped;
 }
+
+
+/*----------------------------------------------------------------------
+	Function:
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
+int CPlayerState::retreatAnimFrameAndCheckForEndOfAnim(class CPlayer *_player)
+{
+	int	animFrame;
+	int	looped;
+	animFrame=_player->getAnimFrame()-1;
+	looped=false;
+	if(animFrame<0)
+	{
+		looped=true;
+		animFrame=_player->getAnimFrameCount()-1;
+	}
+	_player->setAnimFrame(animFrame);
+	return looped;
+}
+
+
+/*----------------------------------------------------------------------
+	Function:
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
 DVECTOR CPlayerState::getMoveVelocity(CPlayer *_player)
 {
 	return _player->getMoveVelocity();
 }
+
+
+/*----------------------------------------------------------------------
+	Function:
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
 void CPlayerState::setMoveVelocity(CPlayer *_player,DVECTOR *_moveVel)
 {
 	_player->setMoveVelocity(_moveVel);
 }
+
+
+/*----------------------------------------------------------------------
+	Function:
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
 int CPlayerState::getPadInput(CPlayer *_player)
 {
 	return _player->getPadInput();
 }
+
+
+/*----------------------------------------------------------------------
+	Function:
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
 int CPlayerState::isOnSolidGround(CPlayer *_player)
 {
 	return _player->isOnSolidGround();
 }
+
+
+/*----------------------------------------------------------------------
+	Function:
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
 void CPlayerState::moveLeft(CPlayer *_player)
 {
 	_player->moveLeft();
 }
+
+
+/*----------------------------------------------------------------------
+	Function:
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
 void CPlayerState::moveRight(CPlayer *_player)
 {
 	_player->moveRight();
 }
+
+
+/*----------------------------------------------------------------------
+	Function:
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
 void CPlayerState::slowdown(CPlayer *_player)
 {
 	_player->slowdown();
 }
+
+
+/*----------------------------------------------------------------------
+	Function:
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
 void CPlayerState::jump(CPlayer *_player)
 {
 	_player->jump();
 }
+
+
+/*----------------------------------------------------------------------
+	Function:
+	Purpose:
+	Params:
+	Returns:
+  ---------------------------------------------------------------------- */
 void CPlayerState::fall(CPlayer *_player)
 {
 	_player->fall();
 }
 
 
-
+/*===========================================================================
-
+ end */
-
-
-
-
-/*----------------------------------------------------------------------*/
-void CPlayerStateIdle::enter(CPlayer *_player)
-{
-	setAnimNo(_player,ANIM_PLAYER_ANIM_IDLEGENERIC04);
-}
-void CPlayerStateIdle::think(CPlayer *_player)
-{
-	int	control;
-	control=getPadInput(_player);
-	
-	if(control&CPadConfig::getButton(CPadConfig::PAD_CFG_JUMP))
-	{
-		setState(_player,STATE_JUMP);
-	}
-	else if(control&(CPadConfig::getButton(CPadConfig::PAD_CFG_LEFT)|CPadConfig::getButton(CPadConfig::PAD_CFG_RIGHT)))
-	{
-		setState(_player,STATE_RUN);
-	}
-	else if(control&CPadConfig::getButton(CPadConfig::PAD_CFG_ACTION))
-	{
-		setState(_player,STATE_CHOP);
-	}
-	else if(control&CPadConfig::getButton(CPadConfig::PAD_CFG_DOWN))
-	{
-		setState(_player,STATE_DUCK);
-	}
-	else if(advanceAnimFrameAndCheckForEndOfAnim(_player))
-	{
-		if(getRndRange(100)<95)
-			setAnimNo(_player,ANIM_PLAYER_ANIM_IDLEGENERIC04);
-		else
-			setAnimNo(_player,ANIM_PLAYER_ANIM_IDLEGENERIC03);
-	}
-}

source/player/pstates.h

@@ -37,8 +37,8 @@
 class CPlayerState
 {
 public:
-	virtual void	enter(class CPlayer *_player)=0;
+	virtual void	enter(class CPlayer *_player)		{;}
-	virtual void	think(class CPlayer *_player)=0;
+	virtual void	think(class CPlayer *_player)		{;}
 
 
 protected:
@@ -50,6 +50,7 @@ protected:
 	void			setAnimNo(class CPlayer *_player,int _animNo);
 	void			setAnimFrame(class CPlayer *_player,int _animFrame);
 	int				advanceAnimFrameAndCheckForEndOfAnim(class CPlayer *_player);
+	int				retreatAnimFrameAndCheckForEndOfAnim(class CPlayer *_player);
 	DVECTOR			getMoveVelocity(class CPlayer *_player);
 	void			setMoveVelocity(class CPlayer *_player,DVECTOR *_moveVel);
 	int				getPadInput(class CPlayer *_player);
@@ -66,15 +67,6 @@ protected:
 };
 
 
-
-class CPlayerStateIdle : public CPlayerState
-{
-public:
-	void			enter(class CPlayer *_player);
-	void			think(class CPlayer *_player);
-};
-
-
 /*----------------------------------------------------------------------
 	Globals
 	------- */