zydronium/SBSPSS
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Browse source
This commit is contained in:
Paul 2001-03-23 20:09:14 +00:00
parent 13b2fbf0a8
commit c59ef39aa0
17 changed files with 366 additions and 910 deletions
Download patch file Download diff file Expand all files Collapse all files

623
source/player/player.cpp
View file

@ -25,18 +25,18 @@
#include "game\gameslot.h" #include "game\gameslot.h"
#endif #endif
#ifndef __GAME_GAME_H__
#include "game\game.h"
#endif
#ifndef __LAYER_COLLISION_H__ #ifndef __LAYER_COLLISION_H__
#include "level\collision.h" #include "level\layercollision.h"
#endif #endif
#ifndef __PLAYER_PMODES_H__ #ifndef __PLAYER_PMODES_H__
#include "player\pmodes.h" #include "player\pmodes.h"
#endif #endif
#ifndef __PLAYER_PMFLY_H__
#include "player\pmfly.h"
#endif
// to be removed // to be removed
#include "gfx\tpage.h" #include "gfx\tpage.h"
@ -47,11 +47,6 @@
/* Data /* Data
---- */ ---- */
#ifndef __ANIM_SPONGEBOB_HEADER__
#include <ACTOR_SPONGEBOB_ANIM.h>
#endif
/*---------------------------------------------------------------------- /*----------------------------------------------------------------------
Tyepdefs && Defines Tyepdefs && Defines
------------------- */ ------------------- */
@ -88,16 +83,6 @@ POWER-UPS
mm & bb ring timed mm & bb ring timed
*/ */
// mode:
// enter
// think
// render
// states setState()
// metrics getMetrics()
// override setAnimNo,setAnimFrame?
/*---------------------------------------------------------------------- /*----------------------------------------------------------------------
Function Prototypes Function Prototypes
------------------- */ ------------------- */
@ -138,32 +123,14 @@ static void writeDemoControls()
#ifdef _STATE_DEBUG_ #ifdef _STATE_DEBUG_
static const char *s_stateText[NUM_STATES]=
{
"IDLE",
"IDLETEETER",
"JUMP",
"RUN",
"FALL",
"FALLFAR",
"BUTTBOUNCE",
"BUTTFALL",
"BUTTLAND",
"ATTACK",
"RUNATTACK",
"AIRATTACK",
"DUCK",
"SOAKUP",
"GETUP",
"DEAD",
};
static const char *s_modeText[NUM_PLAYERMODES]= static const char *s_modeText[NUM_PLAYERMODES]=
{ {
"BASICUNARMED", "BASICUNARMED",
"FULLUNARMED", // "FULLUNARMED",
"BALLOON", // "BALLOON",
"NET", // "NET",
"CORALBLOWER", // "CORALBLOWER",
"FLY",
}; };
#include "gfx\font.h" #include "gfx\font.h"
FontBank s_debugFont; FontBank s_debugFont;
@ -191,6 +158,14 @@ int CAMERA_SCROLLSPEED=60; // Speed of the scroll ( 60=1 tile scrolled every
CPlayerModeBasic PLAYERMODE;
CPlayerModeFly PLAYERMODEFLY;
CPlayerMode *CPlayer::s_playerModes[NUM_PLAYERMODES]=
{
&PLAYERMODE, // PLAYER_MODE_BASICUNARMED
&PLAYERMODEFLY, // PLAYER_MODE_FLY
};
/*---------------------------------------------------------------------- /*----------------------------------------------------------------------
@ -205,15 +180,21 @@ void CPlayer::init()
m_layerCollision=NULL; m_layerCollision=NULL;
m_onPlatform = false; // m_onPlatform = false;
m_prevOnPlatform = false; // m_prevOnPlatform = false;
m_skel.Init(ACTORS_SPONGEBOB_A3D); m_skel.Init(ACTORS_SPONGEBOB_A3D);
TPLoadTex(ACTORS_ACTOR_SPONGEBOB_TEX); TPLoadTex(ACTORS_ACTOR_SPONGEBOB_TEX);
for(int i=0;i<NUM_PLAYERMODES;i++)
{
s_playerModes[i]->initialise(this);
}
m_currentPlayerModeClass=NULL;
setMode(PLAYER_MODE_BASICUNARMED);
m_animNo=0; m_animNo=0;
m_animFrame=0; m_animFrame=0;
m_currentMode=PLAYER_MODE_BASICUNARMED;
setFacing(FACING_RIGHT); setFacing(FACING_RIGHT);
respawn(); respawn();
@ -289,9 +270,9 @@ if(newmode!=-1)
{ {
// Think // Think
updatePadInput(); updatePadInput();
m_currentStateClass->think(this); // s_modes[m_currentMode].m_modeControl->think();
thinkVerticalMovement(); // m_currentStateClass->think(this);
thinkHorizontalMovement(); m_currentPlayerModeClass->think();
// Powerups // Powerups
if(m_squeakyBootsTimer) if(m_squeakyBootsTimer)
@ -310,21 +291,11 @@ if(newmode!=-1)
} }
#ifdef _STATE_DEBUG_
sprintf(posBuf,"%03d (%02d) ,%03d (%02d) = dfg:%+02d",Pos.vx,Pos.vx&0x0f,Pos.vy,Pos.vy&0x0f,m_layerCollision->getHeightFromGround(Pos.vx,Pos.vy));
#endif
if(Pos.vx<64)Pos.vx=64; if(Pos.vx<64)Pos.vx=64;
else if(Pos.vx>m_mapEdge.vx-64)Pos.vx=m_mapEdge.vx-64; else if(Pos.vx>m_mapEdge.vx-64)Pos.vx=m_mapEdge.vx-64;
if(Pos.vy<64)Pos.vy=64; if(Pos.vy<64)Pos.vy=64;
else if(Pos.vy>m_mapEdge.vy-64)Pos.vy=m_mapEdge.vy-64; else if(Pos.vy>m_mapEdge.vy-64)Pos.vy=m_mapEdge.vy-64;
// Teeter if on an edge
if(m_currentState==STATE_IDLE&&isOnEdge())
{
setState(STATE_IDLETEETER);
}
// Look around // Look around
int pad=getPadInputHeld(); int pad=getPadInputHeld();
@ -359,8 +330,6 @@ if(PadGetDown(0)&PAD_CIRCLE)
} }
} }
} }
s_modes[m_currentMode].m_modeControl->think(this);
} }
@ -404,206 +373,6 @@ if(PadGetDown(0)&PAD_CIRCLE)
} }
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CPlayer::thinkVerticalMovement()
{
int colHeight;
colHeight=m_layerCollision->getHeightFromGround(Pos.vx,Pos.vy,1);
//New collision stuff (pkg)
//if(m_layerCollision->getCollisionType(Pos.vx,Pos.vy+(m_moveVel.vy>>VELOCITY_SHIFT))&COLLISION_TYPE_MASK)
//{
// m_moveVel.vy=0;
// return;
//}
if(colHeight>=0)
{
// Above or on the ground
// Are we falling?
if(m_moveVel.vy>0)
{
// Yes.. Check to see if we're about to hit/go through the ground
colHeight=m_layerCollision->getHeightFromGround(Pos.vx,Pos.vy+(m_moveVel.vy>>VELOCITY_SHIFT),PLAYER_TERMINAL_VELOCITY+1);
if(colHeight<=0)
{
// Just hit the ground
// Stick at ground level
Pos.vy+=(m_moveVel.vy>>VELOCITY_SHIFT)+colHeight;
m_moveVel.vy=0;
m_fallFrames=0;
if(m_currentMode!=PLAYER_MODE_BALLOON)
{
if(m_currentState==STATE_BUTTFALL)
{
// Landed from a butt bounce
setState(STATE_BUTTLAND);
}
else if(m_currentState==STATE_FALLFAR)
{
// Landed from a painfully long fall
setState(STATE_IDLE);
takeDamage(DAMAGE__FALL);
m_moveVel.vx=0;
CSoundMediator::playSfx(CSoundMediator::SFX_SPONGEBOB_LAND_AFTER_FALL);
}
else if(m_moveVel.vx)
{
// Landed from a jump with x movement
setState(STATE_RUN);
}
else
{
// Landed from a jump with no x movement
setState(STATE_IDLE);
setAnimNo(ANIM_SPONGEBOB_JUMPEND);
}
}
}
}
else if(colHeight)
{
if(m_currentState!=STATE_FALL&&m_currentState!=STATE_FALLFAR&&
m_currentState!=STATE_BUTTFALL&&m_currentState!=STATE_BUTTBOUNCE&&
m_currentState!=STATE_JUMP)
{
// Was floating in the air.. fall!
if ( !m_onPlatform )
{
setState(STATE_FALL);
}
}
}
}
else
{
/*
// Below ground
// Perhaps we should be falling?
if(m_currentState!=STATE_FALL&&m_currentState!=STATE_FALLFAR&&
m_currentState!=STATE_BUTTFALL&&m_currentState!=STATE_BUTTBOUNCE&&
m_currentState!=STATE_JUMP)
{
setState(STATE_FALL);
}
*/
}
Pos.vy+=m_moveVel.vy>>VELOCITY_SHIFT;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CPlayer::thinkHorizontalMovement()
{
if(m_moveVel.vx)
{
//New collision stuff (pkg)
//if(m_layerCollision->getCollisionType(Pos.vx+(m_moveVel.vx>>VELOCITY_SHIFT),Pos.vy)&COLLISION_TYPE_MASK)
//{
// m_moveVel.vx=0;
// return;
//}
int colHeight;
colHeight=m_layerCollision->getHeightFromGround(Pos.vx,Pos.vy,5);
if(colHeight==0)
{
// Ok.. we're on the ground. What happens if we move left/right
colHeight=m_layerCollision->getHeightFromGround(Pos.vx+(m_moveVel.vx>>VELOCITY_SHIFT),Pos.vy);
if(colHeight<-8)
{
// Big step up. Stop at the edge of the obstruction
int dir,vx,cx,i;
if(m_moveVel.vx<0)
{
dir=-1;
vx=-m_moveVel.vx>>VELOCITY_SHIFT;
}
else
{
dir=+1;
vx=m_moveVel.vx>>VELOCITY_SHIFT;
}
cx=Pos.vx;
for(i=0;i<vx;i++)
{
if(m_layerCollision->getHeightFromGround(cx,Pos.vy)<-8)
{
break;
}
cx+=dir;
}
Pos.vx=cx-dir;
// If running then go to idle, otherwise leave in same state
if(m_currentState==STATE_RUN)
{
setState(STATE_IDLE);
}
m_moveVel.vx=0;
// Get the height at this new position and then try the step-up code below.
// Without this, there are problems when you run up a slope and hit a wall at the same time
colHeight=m_layerCollision->getHeightFromGround(Pos.vx,Pos.vy);
}
if(colHeight&&colHeight>=-8&&colHeight<=8)
{
// Small step up/down. Follow the contour of the level
Pos.vy+=colHeight;
}
}
else
{
// In the air
// if(!(colHeight<0&&m_currentState==STATE_JUMP)) // Lets you jump through platforms from below
if(colHeight>=0) // Lets you jump through platforms from below
{
colHeight=m_layerCollision->getHeightFromGround(Pos.vx+(m_moveVel.vx>>VELOCITY_SHIFT),Pos.vy,5);
if(colHeight<0)
{
// Stop at the edge of the obstruction
int dir,vx,cx,i;
if(m_moveVel.vx<0)
{
dir=-1;
vx=-m_moveVel.vx>>VELOCITY_SHIFT;
}
else
{
dir=+1;
vx=m_moveVel.vx>>VELOCITY_SHIFT;
}
cx=Pos.vx;
for(i=0;i<vx;i++)
{
if(m_layerCollision->getHeightFromGround(cx,Pos.vy)<0)
{
break;
}
cx+=dir;
}
Pos.vx=cx-dir;
m_moveVel.vx=0;
}
}
}
Pos.vx+=m_moveVel.vx>>VELOCITY_SHIFT;
}
}
/*---------------------------------------------------------------------- /*----------------------------------------------------------------------
Function: Function:
Purpose: Purpose:
@ -629,6 +398,7 @@ void CPlayer::render()
CPlayerThing::render(); CPlayerThing::render();
#ifdef _STATE_DEBUG_ #ifdef _STATE_DEBUG_
sprintf(posBuf,"%03d (%02d) ,%03d (%02d) = dfg:%+02d",Pos.vx,Pos.vx&0x0f,Pos.vy,Pos.vy&0x0f,m_layerCollision->getHeightFromGround(Pos.vx,Pos.vy));
s_debugFont.print(40,40,posBuf); s_debugFont.print(40,40,posBuf);
#endif #endif
@ -666,8 +436,6 @@ if(eyes!=-1)
#ifdef _STATE_DEBUG_ #ifdef _STATE_DEBUG_
char buf[128]; char buf[128];
sprintf(buf,"STATE: %s",s_stateText[m_currentState]);
s_debugFont.print(40,200,buf);
sprintf(buf,"MODE: %s",s_modeText[m_currentMode]); sprintf(buf,"MODE: %s",s_modeText[m_currentMode]);
s_debugFont.print(40,210,buf); s_debugFont.print(40,210,buf);
#endif #endif
@ -708,19 +476,6 @@ if(eyes!=-1)
} }
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
DVECTOR CPlayer::getCameraPos()
{
return m_cameraPos;
}
/*---------------------------------------------------------------------- /*----------------------------------------------------------------------
Function: Function:
Purpose: Pre-calcs the visible edges of the map ( ie: the hard limits Purpose: Pre-calcs the visible edges of the map ( ie: the hard limits
@ -766,43 +521,6 @@ void CPlayer::addLife()
} }
} }
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
const PlayerMetrics *CPlayer::getPlayerMetrics()
{
return &s_modes[m_currentMode].m_metrics;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
int CPlayer::setState(PLAYER_STATE _state)
{
CPlayerState *nextState;
int ret=false;
nextState=s_modes[m_currentMode].m_states[_state];
if(nextState)
{
m_currentStateClass=nextState;
m_currentStateClass->enter(this);
m_currentState=_state;
ret=true;
}
return ret;
}
/*---------------------------------------------------------------------- /*----------------------------------------------------------------------
Function: Function:
@ -813,14 +531,8 @@ int CPlayer::setState(PLAYER_STATE _state)
void CPlayer::setMode(PLAYER_MODE _mode) void CPlayer::setMode(PLAYER_MODE _mode)
{ {
m_currentMode=_mode; m_currentMode=_mode;
// Need to do something about this setState() for when the new mode doesn't have that state (pkg) m_currentPlayerModeClass=s_playerModes[_mode];
if(!setState(m_currentState)) m_currentPlayerModeClass->enter();
{
m_moveVel.vx=0;
m_moveVel.vy=0;
setState(STATE_IDLE);
}
s_modes[m_currentMode].m_modeControl->enter(this);
} }
@ -905,245 +617,6 @@ void CPlayer::setAnimNo(int _animNo)
} }
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
DVECTOR CPlayer::getMoveVelocity()
{
return m_moveVel;
}
void CPlayer::setMoveVelocity(DVECTOR *_moveVel)
{
m_moveVel=*_moveVel;
}
DVECTOR CPlayer::getPlayerPos()
{
return Pos;
}
void CPlayer::setPlayerPos(DVECTOR *_pos)
{
Pos=*_pos;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
PLAYERINPUT CPlayer::getPadInputHeld()
{
return m_padInput;
}
PLAYERINPUT CPlayer::getPadInputDown()
{
return m_padInputDown;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
int CPlayer::isOnSlippySurface()
{
return false;
/* (pkg)
int ret=false;
if(m_layerCollision->getHeightFromGround(Pos.vx,Pos.vy,5)==0&&
m_layerCollision->getCollisionType(Pos.vx,Pos.vy)&COLLISION_TYPE_FLAG_SLIPPERY)
{
ret=true;
}
return ret;
*/
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns: FACING_LEFT if left half of player is hanging, FACING_RIGHT
if right half of player is hanging or 0 if no part of the
player is hanging
---------------------------------------------------------------------- */
int csize=5;
int cheight=15;
int CPlayer::isOnEdge()
{
int ret=0;
if(m_layerCollision->getHeightFromGround(Pos.vx-csize,Pos.vy,cheight+1)>cheight)
{
ret=FACING_LEFT;
}
else if(m_layerCollision->getHeightFromGround(Pos.vx+csize,Pos.vy,cheight+1)>cheight)
{
ret=FACING_RIGHT;
}
return ret;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
int CPlayer::canMoveLeft()
{
return m_layerCollision->getHeightFromGround(Pos.vx-1,Pos.vy,16)>-8?true:false;
}
int CPlayer::canMoveRight()
{
return m_layerCollision->getHeightFromGround(Pos.vx+1,Pos.vy,16)>-8?true:false;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CPlayer::moveLeft()
{
const PlayerMetrics *metrics;
metrics=getPlayerMetrics();
setFacing(FACING_LEFT);
if(m_moveVel.vx<=0)
{
m_moveVel.vx-=metrics->m_metric[PM__RUN_SPEEDUP];
if(m_moveVel.vx<-metrics->m_metric[PM__MAX_RUN_VELOCITY]<<VELOCITY_SHIFT)
{
m_moveVel.vx=-metrics->m_metric[PM__MAX_RUN_VELOCITY]<<VELOCITY_SHIFT;
}
}
else
{
m_moveVel.vx-=metrics->m_metric[PM__RUN_REVERSESLOWDOWN];
}
if(m_moveVel.vx<-CAMERA_STARTMOVETHRESHOLD||m_cameraScrollPos.vx<-CAMERA_SCROLLTHRESHOLD<<8)
{
m_cameraScrollDir=+1;
}
else if(m_moveVel.vx>-CAMERA_STOPMOVETHRESHOLD)
{
m_cameraScrollDir=0;
}
}
void CPlayer::moveRight()
{
const PlayerMetrics *metrics;
metrics=getPlayerMetrics();
setFacing(FACING_RIGHT);
if(m_moveVel.vx>=0)
{
m_moveVel.vx+=metrics->m_metric[PM__RUN_SPEEDUP];
if(m_moveVel.vx>metrics->m_metric[PM__MAX_RUN_VELOCITY]<<VELOCITY_SHIFT)
{
m_moveVel.vx=metrics->m_metric[PM__MAX_RUN_VELOCITY]<<VELOCITY_SHIFT;
}
}
else
{
m_moveVel.vx+=metrics->m_metric[PM__RUN_REVERSESLOWDOWN];
}
if(m_moveVel.vx>CAMERA_STARTMOVETHRESHOLD||m_cameraScrollPos.vx>CAMERA_SCROLLTHRESHOLD<<8)
{
m_cameraScrollDir=-1;
}
else if(m_moveVel.vx<CAMERA_STOPMOVETHRESHOLD)
{
m_cameraScrollDir=0;
}
}
void CPlayer::slowdown()
{
const PlayerMetrics *metrics;
int stopSpeed;
metrics=getPlayerMetrics();
if(isOnSlippySurface())
{
stopSpeed=SLIPSPEED;
}
else
{
stopSpeed=0;
}
if(m_moveVel.vx<0)
{
if(-stopSpeed<m_moveVel.vx)
{
stopSpeed=-m_moveVel.vx;
}
m_moveVel.vx+=metrics->m_metric[PM__RUN_SLOWDOWN];
if(m_moveVel.vx>-stopSpeed)
{
m_moveVel.vx=-stopSpeed;
if(m_currentState==STATE_RUN)
{
setState(STATE_IDLE);
}
}
}
else if(m_moveVel.vx>0)
{
if(stopSpeed>m_moveVel.vx)
{
stopSpeed=m_moveVel.vx;
}
m_moveVel.vx-=metrics->m_metric[PM__RUN_SLOWDOWN];
if(m_moveVel.vx<stopSpeed)
{
m_moveVel.vx=stopSpeed;
if(m_currentState==STATE_RUN)
{
setState(STATE_IDLE);
}
}
}
}
void CPlayer::jump()
{
}
void CPlayer::fall()
{
const PlayerMetrics *metrics;
metrics=getPlayerMetrics();
m_moveVel.vy+=PLAYER_GRAVITY;
if(m_moveVel.vy>=PLAYER_TERMINAL_VELOCITY<<VELOCITY_SHIFT)
{
m_moveVel.vy=PLAYER_TERMINAL_VELOCITY<<VELOCITY_SHIFT;
m_fallFrames++;
if(m_currentState!=STATE_BUTTFALL)
{
if(m_fallFrames>metrics->m_metric[PM__MAX_SAFE_FALL_FRAMES])
{
setState(STATE_FALLFAR);
}
}
}
}
/*---------------------------------------------------------------------- /*----------------------------------------------------------------------
Function: Function:
Purpose: Purpose:
@ -1152,27 +625,23 @@ void CPlayer::fall()
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayer::respawn() void CPlayer::respawn()
{ {
setState(STATE_IDLE); // setState(STATE_IDLE);
// Strip any items that the player might be holding // Strip any items that the player might be holding
if(m_currentMode!=PLAYER_MODE_BASICUNARMED) // if(m_currentMode!=PLAYER_MODE_BASICUNARMED)
{ // {
setMode(PLAYER_MODE_FULLUNARMED); // setMode(PLAYER_MODE_FULLUNARMED);
} // }
else // else
{ // {
setMode(PLAYER_MODE_BASICUNARMED); setMode(PLAYER_MODE_BASICUNARMED);
} // }
s_health=MAX_HEALTH; s_health=MAX_HEALTH;
m_invincibleFrameCount=INVIBCIBLE_FRAMES__START; m_invincibleFrameCount=INVIBCIBLE_FRAMES__START;
Pos=m_respawnPos; Pos=m_respawnPos;
m_moveVel.vx=0;
m_moveVel.vy=0;
m_fallFrames=0;
} }
/*---------------------------------------------------------------------- /*----------------------------------------------------------------------
Function: Function:
Purpose: Purpose:
@ -1229,7 +698,7 @@ void CPlayer::takeDamage(DAMAGE_TYPE _damage)
else else
{ {
CSoundMediator::playSfx(CSoundMediator::SFX_SPONGEBOB_DEFEATED_JINGLE); CSoundMediator::playSfx(CSoundMediator::SFX_SPONGEBOB_DEFEATED_JINGLE);
setState(STATE_DEAD); // setState(STATE_DEAD);
} }
} }
} }
@ -1332,11 +801,13 @@ PLAYERINPUT CPlayer::readPadInput()
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
/*
void CPlayer::clearPlatform() void CPlayer::clearPlatform()
{ {
m_prevOnPlatform = m_onPlatform; m_prevOnPlatform = m_onPlatform;
m_onPlatform = false; m_onPlatform = false;
} }
*/
/*---------------------------------------------------------------------- /*----------------------------------------------------------------------
Function: Function:
@ -1344,6 +815,7 @@ void CPlayer::clearPlatform()
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
/*
void CPlayer::setPlatform( CThing *newPlatform ) void CPlayer::setPlatform( CThing *newPlatform )
{ {
int colHeight; int colHeight;
@ -1381,7 +853,7 @@ void CPlayer::setPlatform( CThing *newPlatform )
if ( !m_prevOnPlatform ) if ( !m_prevOnPlatform )
{ {
if( m_currentMode != PLAYER_MODE_BALLOON ) // if( m_currentMode != PLAYER_MODE_BALLOON )
{ {
m_fallFrames=0; m_fallFrames=0;
@ -1462,6 +934,7 @@ void CPlayer::setPlatform( CThing *newPlatform )
newPlatform->removeChild( this ); newPlatform->removeChild( this );
} }
} }
*/
/*---------------------------------------------------------------------- /*----------------------------------------------------------------------
Function: Function:
@ -1469,6 +942,7 @@ void CPlayer::setPlatform( CThing *newPlatform )
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
/*
void CPlayer::shove( DVECTOR move ) void CPlayer::shove( DVECTOR move )
{ {
DVECTOR newPos; DVECTOR newPos;
@ -1490,6 +964,7 @@ void CPlayer::shove( DVECTOR move )
Pos.vy = newPos.vy; Pos.vy = newPos.vy;
} }
} }
*/
/*=========================================================================== /*===========================================================================
end */ end */

117
source/player/player.h
View file

@ -49,12 +49,12 @@
typedef enum typedef enum
{ {
PLAYER_MODE_BASICUNARMED, PLAYER_MODE_BASICUNARMED,
PLAYER_MODE_FULLUNARMED, // PLAYER_MODE_FULLUNARMED,
PLAYER_MODE_BALLOON, // PLAYER_MODE_BALLOON,
//PLAYER_MODE_BUBBLE_MIXTURE, //PLAYER_MODE_BUBBLE_MIXTURE,
//PLAYER_MODE_HELMET, //PLAYER_MODE_HELMET,
PLAYER_MODE_NET, // PLAYER_MODE_NET,
PLAYER_MODE_CORALBLOWER, // PLAYER_MODE_CORALBLOWER,
//PLAYER_MODE_JELLY_LAUNCHER, //PLAYER_MODE_JELLY_LAUNCHER,
PLAYER_MODE_FLY, PLAYER_MODE_FLY,
@ -73,15 +73,10 @@ typedef enum
STATE_BUTTBOUNCE, STATE_BUTTBOUNCE,
STATE_BUTTFALL, STATE_BUTTFALL,
STATE_BUTTLAND, STATE_BUTTLAND,
STATE_ATTACK,
STATE_RUNATTACK,
STATE_AIRATTACK,
STATE_DUCK, STATE_DUCK,
STATE_SOAKUP, STATE_SOAKUP,
STATE_GETUP, STATE_GETUP,
STATE_DEAD,
NUM_STATES, NUM_STATES,
}PLAYER_STATE; }PLAYER_STATE;
@ -91,19 +86,6 @@ enum
FACING_RIGHT=-1, FACING_RIGHT=-1,
}; };
typedef enum
{
PM__JUMP_VELOCITY,
PM__MAX_JUMP_FRAMES,
PM__MAX_SAFE_FALL_FRAMES,
PM__MAX_RUN_VELOCITY,
PM__RUN_SPEEDUP,
PM__RUN_REVERSESLOWDOWN,
PM__RUN_SLOWDOWN,
NUM_PLAYER_METRICS
}PLAYER_METRIC;
typedef enum typedef enum
{ {
DAMAGE__NONE, // put in so that an item can push the user but not damage them DAMAGE__NONE, // put in so that an item can push the user but not damage them
@ -142,60 +124,32 @@ typedef enum
Structure defintions Structure defintions
-------------------- */ -------------------- */
struct PlayerMetrics
{
s16 m_metric[NUM_PLAYER_METRICS];
};
class CPlayer : public CPlayerThing class CPlayer : public CPlayerThing
{ {
public: public:
enum enum
{ {
VELOCITY_SHIFT=4, MAX_HEALTH=5,
MAX_LIVES=99,
}; };
virtual void init(); virtual void init();
virtual void shutdown(); virtual void shutdown();
virtual void think(int _frames); virtual void think(int _frames);
virtual void render(); virtual void render();
virtual void shove(DVECTOR move); // virtual void shove(DVECTOR move);
DVECTOR getCameraPos(); DVECTOR getCameraPos() {return m_cameraPos;}
void setLayerCollision(class CLayerCollision *_layer) {m_layerCollision=_layer;} void setLayerCollision(class CLayerCollision *_layer) {m_layerCollision=_layer;}
void setMapSize(DVECTOR _mapSize); void setMapSize(DVECTOR _mapSize);
void setRespawnPos(DVECTOR _respawn) {m_respawnPos=_respawn;} void setRespawnPos(DVECTOR _respawn) {m_respawnPos=_respawn;}
enum
{
MAX_HEALTH=5,
MAX_LIVES=99,
};
void addHealth(int _health); void addHealth(int _health);
void addLife(); void addLife();
protected:
enum
{
DEFAULT_PLAYER_JUMP_VELOCITY=4,
DEFAULT_PLAYER_MAX_JUMP_FRAMES=12,
DEFAULT_PLAYER_MAX_SAFE_FALL_FRAMES=30,
DEFAULT_PLAYER_MAX_RUN_VELOCITY=8,
DEFAULT_PLAYER_RUN_SPEEDUP=4<<2,
DEFAULT_PLAYER_RUN_REVERSESLOWDOWN=3<<2,
DEFAULT_PLAYER_RUN_SLOWDOWN=2<<2,
PLAYER_GRAVITY=4<<2,
PLAYER_TERMINAL_VELOCITY=8,
};
const PlayerMetrics *getPlayerMetrics();
// State
int setState(PLAYER_STATE _state);
public: public:
void setMode(PLAYER_MODE _mode); void setMode(PLAYER_MODE _mode);
private:
int getFacing(); int getFacing();
void setFacing(int _facing); void setFacing(int _facing);
int getAnimFrame(); int getAnimFrame();
@ -203,41 +157,18 @@ private:
int getAnimFrameCount(); int getAnimFrameCount();
int getAnimNo(); int getAnimNo();
void setAnimNo(int _animNo); void setAnimNo(int _animNo);
DVECTOR getMoveVelocity(); DVECTOR getPlayerPos() {return Pos;}
void setMoveVelocity(DVECTOR *_moveVel); void setPlayerPos(DVECTOR *_pos) {Pos=*_pos;}
DVECTOR getPlayerPos(); PLAYERINPUT getPadInputHeld() {return m_padInput;}
void setPlayerPos(DVECTOR *_pos); PLAYERINPUT getPadInputDown() {return m_padInputDown;}
PLAYERINPUT getPadInputHeld(); class CLayerCollision *getLayerCollision() {return m_layerCollision;}
PLAYERINPUT getPadInputDown();
// Collision
int isOnSlippySurface();
int isOnEdge();
int canMoveLeft();
int canMoveRight();
// Movement
void moveLeft();
void moveRight();
void slowdown();
void jump();
void fall();
void respawn();
void takeDamage(DAMAGE_TYPE _damage); void takeDamage(DAMAGE_TYPE _damage);
friend class CPlayerState;
private: private:
typedef struct void respawn();
{
PlayerMetrics m_metrics;
class CPlayerMode *m_modeControl;
class CPlayerState *m_states[NUM_STATES];
}PlayerMode;
public: public:
@ -261,9 +192,7 @@ private:
DVECTOR m_cameraPos; DVECTOR m_cameraPos;
int m_cameraScrollDir; int m_cameraScrollDir;
DVECTOR m_moveVel;
int m_facing; int m_facing;
int m_fallFrames;
enum enum
{ {
@ -277,13 +206,9 @@ private:
}; };
int m_invincibleFrameCount; // Initial invincibility and also invincibility after taking damage int m_invincibleFrameCount; // Initial invincibility and also invincibility after taking damage
void thinkVerticalMovement(); static class CPlayerMode *s_playerModes[NUM_PLAYERMODES];
void thinkHorizontalMovement(); class CPlayerMode *m_currentPlayerModeClass;
static PlayerMode s_modes[NUM_PLAYERMODES];
int m_currentMode; int m_currentMode;
class CPlayerState *m_currentStateClass;
PLAYER_STATE m_currentState;
int m_lives; int m_lives;
@ -324,13 +249,17 @@ private:
// Platforms // Platforms
public: public:
void setPlatform( CThing *newPlatform ); void setPlatform( CThing *newPlatform ) {;}
void clearPlatform(); void clearPlatform() {;}
/*
private: private:
CThing *m_platform; CThing *m_platform;
bool m_onPlatform; bool m_onPlatform;
bool m_prevOnPlatform; bool m_prevOnPlatform;
DVECTOR m_prevPlatformPos; DVECTOR m_prevPlatformPos;
*/
}; };

8
source/player/pmodes.cpp
View file

@ -50,18 +50,10 @@
#include "player\psbutt.h" #include "player\psbutt.h"
#endif #endif
#ifndef __PLAYER__PSCHOP_H__
#include "player\pschop.h"
#endif
#ifndef __PLAYER__PSDUCK_H__ #ifndef __PLAYER__PSDUCK_H__
#include "player\psduck.h" #include "player\psduck.h"
#endif #endif
#ifndef __PLAYER__PSDEAD_H__
#include "player\psdead.h"
#endif
/* Std Lib /* Std Lib
------- */ ------- */

117
source/player/pmodes.h
View file

@ -18,6 +18,15 @@
Includes Includes
-------- */ -------- */
#ifndef _GLOBAL_HEADER_
#include "system\global.h"
#endif
#ifndef __PLAYER_PLAYER_H__
#include "player\player.h"
#endif
/* Std Lib /* Std Lib
------- */ ------- */
@ -29,12 +38,116 @@
Structure defintions Structure defintions
-------------------- */ -------------------- */
typedef enum
{
PM__JUMP_VELOCITY,
PM__MAX_JUMP_FRAMES,
PM__MAX_SAFE_FALL_FRAMES,
PM__MAX_RUN_VELOCITY,
PM__RUN_SPEEDUP,
PM__RUN_REVERSESLOWDOWN,
PM__RUN_SLOWDOWN,
NUM_PLAYER_METRICS
}PLAYER_METRIC;
struct PlayerMetrics
{
s16 m_metric[NUM_PLAYER_METRICS];
};
class CPlayerMode class CPlayerMode
{ {
public: public:
virtual void enter(class CPlayer *_player) {;} virtual void initialise(class CPlayer *_player) {m_player=_player;}
virtual void think(class CPlayer *_player) {;} virtual void enter() {;}
virtual void think() {;}
virtual void render() {;}
int getPadInputHeld();
int getPadInputDown();
protected:
DVECTOR getPlayerPos();
void setPlayerPos(DVECTOR *_pos);
class CPlayer *m_player;
};
class CPlayerModeBasic : public CPlayerMode
{
public:
enum
{
VELOCITY_SHIFT=4,
};
virtual void enter();
virtual void think();
virtual void render();
//protected:
int canTeeter() {return m_currentState==STATE_IDLE;}
int canFallForever() {return m_currentState==STATE_BUTTFALL;}
void thinkVerticalMovement();
void thinkHorizontalMovement();
const struct PlayerMetrics *getPlayerMetrics();
int setState(int _state);
// virtual void setMode(class CPlayer *_player,int _mode);
int getFacing();
void setFacing(int _facing);
// virtual int getAnimNo(class CPlayer *_player);
void setAnimNo(int _animNo);
void setAnimFrame(int _animFrame);
int advanceAnimFrameAndCheckForEndOfAnim();
// virtual int retreatAnimFrameAndCheckForEndOfAnim(class CPlayer *_player);
DVECTOR getMoveVelocity();
void zeroMoveVelocity();
void setMoveVelocity(DVECTOR *_moveVel);
int isOnEdge();
int canMoveLeft();
int canMoveRight();
void moveLeft();
void moveRight();
int slowdown();
void jump();
void fall();
// virtual void respawn(class CPlayer *_player);
protected:
enum
{
DEFAULT_PLAYER_JUMP_VELOCITY=4,
DEFAULT_PLAYER_MAX_JUMP_FRAMES=12,
DEFAULT_PLAYER_MAX_SAFE_FALL_FRAMES=30,
DEFAULT_PLAYER_MAX_RUN_VELOCITY=6, //8
DEFAULT_PLAYER_RUN_SPEEDUP=2<<2, //4
DEFAULT_PLAYER_RUN_REVERSESLOWDOWN=4<<2, //3
DEFAULT_PLAYER_RUN_SLOWDOWN=3<<2, //2
PLAYER_GRAVITY=4<<2,
PLAYER_TERMINAL_VELOCITY=8,
};
private:
int m_fallFrames;
DVECTOR m_moveVelocity;
static class CPlayerState *s_stateTable[];
class CPlayerState *m_currentStateClass;
PLAYER_STATE m_currentState;
static PlayerMetrics s_playerMetrics;
}; };

39
source/player/psbutt.cpp
View file

@ -23,6 +23,10 @@
#include "player\player.h" #include "player\player.h"
#endif #endif
#ifndef __PLAYER_PMODES_H__
#include "player\pmodes.h"
#endif
#ifndef __GAME_GAMEBUBS_H__ #ifndef __GAME_GAMEBUBS_H__
#include "game\gamebubs.h" #include "game\gamebubs.h"
#endif #endif
@ -61,9 +65,10 @@
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateButtBounce::enter(CPlayer *_player) void CPlayerStateButtBounce::enter(CPlayerModeBasic *_playerMode)
{ {
setAnimNo(_player,ANIM_SPONGEBOB_BUTTBOUNCESTART); _playerMode->zeroMoveVelocity();
_playerMode->setAnimNo(ANIM_SPONGEBOB_BUTTBOUNCESTART);
} }
@ -73,11 +78,11 @@ void CPlayerStateButtBounce::enter(CPlayer *_player)
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateButtBounce::think(CPlayer *_player) void CPlayerStateButtBounce::think(CPlayerModeBasic *_playerMode)
{ {
if(advanceAnimFrameAndCheckForEndOfAnim(_player)) if(_playerMode->advanceAnimFrameAndCheckForEndOfAnim())
{ {
setState(_player,STATE_BUTTFALL); _playerMode->setState(STATE_BUTTFALL);
} }
} }
@ -88,9 +93,9 @@ void CPlayerStateButtBounce::think(CPlayer *_player)
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateButtBounceFall::enter(CPlayer *_player) void CPlayerStateButtBounceFall::enter(CPlayerModeBasic *_playerMode)
{ {
setAnimNo(_player,ANIM_SPONGEBOB_BUTTBOUNCEEND); _playerMode->setAnimNo(ANIM_SPONGEBOB_BUTTBOUNCEEND);
} }
@ -100,9 +105,9 @@ void CPlayerStateButtBounceFall::enter(CPlayer *_player)
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateButtBounceFall::think(CPlayer *_player) void CPlayerStateButtBounceFall::think(CPlayerModeBasic *_playerMode)
{ {
fall(_player); _playerMode->fall();
} }
@ -112,12 +117,12 @@ void CPlayerStateButtBounceFall::think(CPlayer *_player)
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateButtBounceLand::enter(CPlayer *_player) void CPlayerStateButtBounceLand::enter(CPlayerModeBasic *_playerMode)
{ {
DVECTOR pos; // DVECTOR pos;
//
pos=getPlayerPos(_player); // pos=_playerMode->getPlayerPos();
CGameBubicleFactory::spawnBubicles(pos.vx,pos.vy,40,10,CGameBubicleFactory::TYPE_MEDIUM); // CGameBubicleFactory::spawnBubicles(pos.vx,pos.vy,40,10,CGameBubicleFactory::TYPE_MEDIUM);
} }
@ -127,11 +132,11 @@ void CPlayerStateButtBounceLand::enter(CPlayer *_player)
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateButtBounceLand::think(CPlayer *_player) void CPlayerStateButtBounceLand::think(CPlayerModeBasic *_playerMode)
{ {
if(advanceAnimFrameAndCheckForEndOfAnim(_player)) if(_playerMode->advanceAnimFrameAndCheckForEndOfAnim())
{ {
setState(_player,STATE_IDLE); _playerMode->setState(STATE_IDLE);
} }
} }

12
source/player/psbutt.h
View file

@ -35,24 +35,24 @@
class CPlayerStateButtBounce : public CPlayerState class CPlayerStateButtBounce : public CPlayerState
{ {
public: public:
virtual void enter(class CPlayer *_player); virtual void enter(class CPlayerModeBasic *_playerMode);
virtual void think(class CPlayer *_player); virtual void think(class CPlayerModeBasic *_playerMode);
}; };
class CPlayerStateButtBounceFall : public CPlayerState class CPlayerStateButtBounceFall : public CPlayerState
{ {
public: public:
virtual void enter(class CPlayer *_player); virtual void enter(class CPlayerModeBasic *_playerMode);
virtual void think(class CPlayer *_player); virtual void think(class CPlayerModeBasic *_playerMode);
}; };
class CPlayerStateButtBounceLand : public CPlayerState class CPlayerStateButtBounceLand : public CPlayerState
{ {
public: public:
virtual void enter(class CPlayer *_player); virtual void enter(class CPlayerModeBasic *_playerMode);
virtual void think(class CPlayer *_player); virtual void think(class CPlayerModeBasic *_playerMode);
private: private:

43
source/player/psduck.cpp
View file

@ -23,6 +23,10 @@
#include "player\player.h" #include "player\player.h"
#endif #endif
#ifndef __PLAYER_PMODES_H__
#include "player\pmodes.h"
#endif
/* Std Lib /* Std Lib
------- */ ------- */
@ -57,9 +61,9 @@
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateDuck::enter(CPlayer *_player) void CPlayerStateDuck::enter(CPlayerModeBasic *_playerMode)
{ {
setAnimNo(_player,ANIM_SPONGEBOB_SOAKUP); _playerMode->setAnimNo(ANIM_SPONGEBOB_SOAKUP);
} }
@ -69,12 +73,12 @@ void CPlayerStateDuck::enter(CPlayer *_player)
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateDuck::think(CPlayer *_player) void CPlayerStateDuck::think(CPlayerModeBasic *_playerMode)
{ {
slowdown(_player); _playerMode->slowdown();
if(advanceAnimFrameAndCheckForEndOfAnim(_player)) if(_playerMode->advanceAnimFrameAndCheckForEndOfAnim())
{ {
setState(_player,STATE_SOAKUP); _playerMode->setState(STATE_SOAKUP);
} }
} }
@ -85,15 +89,10 @@ void CPlayerStateDuck::think(CPlayer *_player)
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateSoakUp::enter(CPlayer *_player) void CPlayerStateSoakUp::enter(CPlayerModeBasic *_playerMode)
{ {
DVECTOR move; _playerMode->zeroMoveVelocity();
_playerMode->setAnimNo(ANIM_SPONGEBOB_GETUP);
move=getMoveVelocity(_player);
move.vx=0;
setMoveVelocity(_player,&move);
setAnimNo(_player,ANIM_SPONGEBOB_GETUP);
} }
@ -103,14 +102,14 @@ void CPlayerStateSoakUp::enter(CPlayer *_player)
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateSoakUp::think(CPlayer *_player) void CPlayerStateSoakUp::think(CPlayerModeBasic *_playerMode)
{ {
int controlHeld; int controlHeld;
controlHeld=getPadInputHeld(_player); controlHeld=_playerMode->getPadInputHeld();
if(!(controlHeld&PI_DOWN)) if(!(controlHeld&PI_DOWN))
{ {
setState(_player,STATE_GETUP); _playerMode->setState(STATE_GETUP);
} }
} }
@ -121,9 +120,9 @@ void CPlayerStateSoakUp::think(CPlayer *_player)
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateGetUp::enter(CPlayer *_player) void CPlayerStateGetUp::enter(CPlayerModeBasic *_playerMode)
{ {
setAnimNo(_player,ANIM_SPONGEBOB_GETUP); _playerMode->setAnimNo(ANIM_SPONGEBOB_GETUP);
} }
@ -133,11 +132,11 @@ void CPlayerStateGetUp::enter(CPlayer *_player)
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateGetUp::think(CPlayer *_player) void CPlayerStateGetUp::think(CPlayerModeBasic *_playerMode)
{ {
if(advanceAnimFrameAndCheckForEndOfAnim(_player)) if(_playerMode->advanceAnimFrameAndCheckForEndOfAnim())
{ {
setState(_player,STATE_IDLE); _playerMode->setState(STATE_IDLE);
} }
} }

12
source/player/psduck.h
View file

@ -35,8 +35,8 @@
class CPlayerStateDuck : public CPlayerState class CPlayerStateDuck : public CPlayerState
{ {
public: public:
void enter(class CPlayer *_player); void enter(class CPlayerModeBasic *_playerMode);
void think(class CPlayer *_player); void think(class CPlayerModeBasic *_playerMode);
}; };
@ -44,8 +44,8 @@ public:
class CPlayerStateSoakUp : public CPlayerState class CPlayerStateSoakUp : public CPlayerState
{ {
public: public:
void enter(class CPlayer *_player); void enter(class CPlayerModeBasic *_playerMode);
void think(class CPlayer *_player); void think(class CPlayerModeBasic *_playerMode);
}; };
@ -53,8 +53,8 @@ public:
class CPlayerStateGetUp : public CPlayerState class CPlayerStateGetUp : public CPlayerState
{ {
public: public:
void enter(class CPlayer *_player); void enter(class CPlayerModeBasic *_playerMode);
void think(class CPlayer *_player); void think(class CPlayerModeBasic *_playerMode);
}; };

58
source/player/psfall.cpp
View file

@ -22,6 +22,10 @@
#include "player\player.h" #include "player\player.h"
#endif #endif
#ifndef __PLAYER_PMODES_H__
#include "player\pmodes.h"
#endif
/* Std Lib /* Std Lib
------- */ ------- */
@ -56,9 +60,9 @@
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateFall::enter(CPlayer *_player) void CPlayerStateFall::enter(CPlayerModeBasic *_playerMode)
{ {
setAnimNo(_player,ANIM_SPONGEBOB_HOVER); _playerMode->setAnimNo(ANIM_SPONGEBOB_HOVER);
} }
@ -68,47 +72,34 @@ void CPlayerStateFall::enter(CPlayer *_player)
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateFall::think(CPlayer *_player) void CPlayerStateFall::think(CPlayerModeBasic *_playerMode)
{ {
const PlayerMetrics *metrics; const PlayerMetrics *metrics;
int controlHeld,controlDown; int controlHeld,controlDown;
DVECTOR move; DVECTOR move;
metrics=getPlayerMetrics(_player); metrics=_playerMode->getPlayerMetrics();
controlHeld=getPadInputHeld(_player); controlHeld=_playerMode->getPadInputHeld();
controlDown=getPadInputDown(_player); controlDown=_playerMode->getPadInputDown();
if(controlHeld&PI_LEFT) if(controlHeld&PI_LEFT)
{ {
moveLeft(_player); _playerMode->moveLeft();
} }
else if(controlHeld&PI_RIGHT) else if(controlHeld&PI_RIGHT)
{ {
moveRight(_player); _playerMode->moveRight();
} }
else else
{ {
slowdown(_player); _playerMode->slowdown();
} }
_playerMode->fall();
fall(_player); if(controlHeld&PI_DOWN)
if(controlDown&PI_ACTION)
{ {
setState(_player,STATE_AIRATTACK); _playerMode->setState(STATE_BUTTBOUNCE);
} }
else if(controlHeld&PI_DOWN)
{
if(setState(_player,STATE_BUTTBOUNCE))
{
// Only do this if this mode allows us to go into butt bounce, otherwise
// SB just floats in the air :)
move.vx=0;
move.vy=0;
setMoveVelocity(_player,&move);
}
}
// advanceAnimFrameAndCheckForEndOfAnim(_player);
} }
@ -118,9 +109,9 @@ void CPlayerStateFall::think(CPlayer *_player)
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateFallFar::enter(CPlayer *_player) void CPlayerStateFallFar::enter(CPlayerModeBasic *_playerMode)
{ {
setAnimNo(_player,ANIM_SPONGEBOB_FALL); _playerMode->setAnimNo(ANIM_SPONGEBOB_FALL);
} }
@ -130,27 +121,26 @@ void CPlayerStateFallFar::enter(CPlayer *_player)
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateFallFar::think(CPlayer *_player) void CPlayerStateFallFar::think(CPlayerModeBasic *_playerMode)
{ {
int controlHeld; int controlHeld;
DVECTOR move; DVECTOR move;
controlHeld=getPadInputHeld(_player); controlHeld=_playerMode->getPadInputHeld();
if(controlHeld&PI_LEFT) if(controlHeld&PI_LEFT)
{ {
moveLeft(_player); _playerMode->moveLeft();
} }
else if(controlHeld&PI_RIGHT) else if(controlHeld&PI_RIGHT)
{ {
moveRight(_player); _playerMode->moveRight();
} }
else else
{ {
slowdown(_player); _playerMode->slowdown();
} }
_playerMode->fall();
fall(_player);
} }

8
source/player/psfall.h
View file

@ -35,8 +35,8 @@
class CPlayerStateFall : public CPlayerState class CPlayerStateFall : public CPlayerState
{ {
public: public:
void enter(class CPlayer *_player); void enter(class CPlayerModeBasic *_playerMode);
void think(class CPlayer *_player); void think(class CPlayerModeBasic *_playerMode);
}; };
@ -44,8 +44,8 @@ public:
class CPlayerStateFallFar : public CPlayerStateFall class CPlayerStateFallFar : public CPlayerStateFall
{ {
private: private:
void enter(class CPlayer *_player); void enter(class CPlayerModeBasic *_playerMode);
void think(class CPlayer *_player); void think(class CPlayerModeBasic *_playerMode);
}; };

66
source/player/psidle.cpp
View file

@ -18,8 +18,8 @@
#include "player\psidle.h" #include "player\psidle.h"
#ifndef __PLAYER_PLAYER_H__ #ifndef __PLAYER_PMODES_H__
#include "player\player.h" #include "player\pmodes.h"
#endif #endif
#ifndef __UTILS_HEADER__ #ifndef __UTILS_HEADER__
@ -61,33 +61,33 @@
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateBaseIdle::thinkControl(CPlayer *_player) void CPlayerStateBaseIdle::thinkControl(CPlayerModeBasic *_playerMode)
{ {
int controlDown,controlHeld; int controlDown,controlHeld;
controlDown=getPadInputDown(_player); controlDown=_playerMode->getPadInputDown();
controlHeld=getPadInputHeld(_player); controlHeld=_playerMode->getPadInputHeld();
if(controlDown&PI_JUMP) if(controlDown&PI_JUMP)
{ {
setState(_player,STATE_JUMP); _playerMode->setState(STATE_JUMP);
} }
else if(controlHeld&PI_LEFT) else if(controlHeld&PI_LEFT)
{ {
if(canMoveLeft(_player)) if(_playerMode->canMoveLeft())
setState(_player,STATE_RUN); _playerMode->setState(STATE_RUN);
} }
else if(controlHeld&PI_RIGHT) else if(controlHeld&PI_RIGHT)
{ {
if(canMoveRight(_player)) if(_playerMode->canMoveRight())
setState(_player,STATE_RUN); _playerMode->setState(STATE_RUN);
} }
else if(controlDown&PI_ACTION) else if(controlDown&PI_ACTION)
{ {
setState(_player,STATE_ATTACK); // _playerMode->setState(STATE_ATTACK);
} }
else if(controlHeld&PI_DOWN) else if(controlHeld&PI_DOWN)
{ {
setState(_player,STATE_DUCK); _playerMode->setState(STATE_DUCK);
} }
} }
@ -98,13 +98,13 @@ void CPlayerStateBaseIdle::thinkControl(CPlayer *_player)
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateTeeterIdle::enter(CPlayer *_player) void CPlayerStateTeeterIdle::enter(CPlayerModeBasic *_playerMode)
{ {
int edgeType,dir; int edgeType,dir;
int anim; int anim;
edgeType=isOnEdge(_player); edgeType=_playerMode->isOnEdge();
dir=getFacing(_player); dir=_playerMode->getFacing();
if(edgeType==FACING_LEFT) if(edgeType==FACING_LEFT)
{ {
anim=dir==FACING_LEFT?ANIM_SPONGEBOB_TEETERFRONT:ANIM_SPONGEBOB_TEETERBACK; anim=dir==FACING_LEFT?ANIM_SPONGEBOB_TEETERFRONT:ANIM_SPONGEBOB_TEETERBACK;
@ -114,7 +114,7 @@ void CPlayerStateTeeterIdle::enter(CPlayer *_player)
anim=dir==FACING_RIGHT?ANIM_SPONGEBOB_TEETERFRONT:ANIM_SPONGEBOB_TEETERBACK; anim=dir==FACING_RIGHT?ANIM_SPONGEBOB_TEETERFRONT:ANIM_SPONGEBOB_TEETERBACK;
} }
setAnimNo(_player,anim); _playerMode->setAnimNo(anim);
} }
@ -124,10 +124,10 @@ void CPlayerStateTeeterIdle::enter(CPlayer *_player)
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateTeeterIdle::think(CPlayer *_player) void CPlayerStateTeeterIdle::think(CPlayerModeBasic *_playerMode)
{ {
advanceAnimFrameAndCheckForEndOfAnim(_player); _playerMode->advanceAnimFrameAndCheckForEndOfAnim();
thinkControl(_player); thinkControl(_playerMode);
} }
@ -137,13 +137,13 @@ void CPlayerStateTeeterIdle::think(CPlayer *_player)
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateIdle::enter(CPlayer *_player) void CPlayerStateIdle::enter(CPlayerModeBasic *_playerMode)
{ {
m_idleTime=0; m_idleTime=0;
m_currentIdleAnim=0; m_currentIdleAnim=0;
m_animState=ANIMSTATE_END; m_animState=ANIMSTATE_END;
setNextIdleAnim(_player); setNextIdleAnim(_playerMode);
} }
@ -153,14 +153,13 @@ void CPlayerStateIdle::enter(CPlayer *_player)
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateIdle::think(CPlayer *_player) void CPlayerStateIdle::think(CPlayerModeBasic *_playerMode)
{ {
thinkControl(_player); if(_playerMode->advanceAnimFrameAndCheckForEndOfAnim())
if(advanceAnimFrameAndCheckForEndOfAnim(_player))
{ {
setNextIdleAnim(_player); setNextIdleAnim(_playerMode);
} }
thinkControl(_playerMode);
} }
@ -170,7 +169,7 @@ void CPlayerStateIdle::think(CPlayer *_player)
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateIdle::setNextIdleAnim(CPlayer *_player) void CPlayerStateIdle::setNextIdleAnim(CPlayerModeBasic *_playerMode)
{ {
IdleAnims *anims; IdleAnims *anims;
int finished=false; int finished=false;
@ -180,7 +179,7 @@ void CPlayerStateIdle::setNextIdleAnim(CPlayer *_player)
{ {
case ANIMSTATE_START: case ANIMSTATE_START:
m_animState=ANIMSTATE_LOOP; m_animState=ANIMSTATE_LOOP;
setAnimNo(_player,anims->m_loopFrame); _playerMode->setAnimNo(anims->m_loopFrame);
break; break;
case ANIMSTATE_LOOP: case ANIMSTATE_LOOP:
if(--m_loopCount<=0) if(--m_loopCount<=0)
@ -192,12 +191,12 @@ void CPlayerStateIdle::setNextIdleAnim(CPlayer *_player)
else else
{ {
m_animState=ANIMSTATE_END; m_animState=ANIMSTATE_END;
setAnimNo(_player,anims->m_endFrame); _playerMode->setAnimNo(anims->m_endFrame);
} }
} }
else else
{ {
setAnimNo(_player,anims->m_loopFrame); _playerMode->setAnimNo(anims->m_loopFrame);
} }
break; break;
case ANIMSTATE_END: case ANIMSTATE_END:
@ -242,7 +241,7 @@ void CPlayerStateIdle::setNextIdleAnim(CPlayer *_player)
m_animState=ANIMSTATE_START; m_animState=ANIMSTATE_START;
} }
m_loopCount=anims->m_loopCount; m_loopCount=anims->m_loopCount;
setAnimNo(_player,animNo); _playerMode->setAnimNo(animNo);
m_idleTime++; m_idleTime++;
} }
@ -265,11 +264,6 @@ static IdleAnims s_unarmedIdleAnims[]=
{ -1, ANIM_SPONGEBOB_IDLELOOK, -1, 1 }, { -1, ANIM_SPONGEBOB_IDLELOOK, -1, 1 },
{ -1, ANIM_SPONGEBOB_IDLEWIND, -1, 1 }, { -1, ANIM_SPONGEBOB_IDLEWIND, -1, 1 },
}; };
//idlekick
//idlescratch
//? - idlesleep* - wakeup
//idlestretch
//idlewind
static int s_numUnarmedIdleAnims=sizeof(s_unarmedIdleAnims)/sizeof(IdleAnims); static int s_numUnarmedIdleAnims=sizeof(s_unarmedIdleAnims)/sizeof(IdleAnims);
IdleAnims *CPlayerStateUnarmedIdle::getIdleAnimsDb(int _animNo) IdleAnims *CPlayerStateUnarmedIdle::getIdleAnimsDb(int _animNo)
{ {

12
source/player/psidle.h
View file

@ -36,7 +36,7 @@
class CPlayerStateBaseIdle : public CPlayerState class CPlayerStateBaseIdle : public CPlayerState
{ {
public: public:
void thinkControl(class CPlayer *_player); void thinkControl(class CPlayerModeBasic *CPlayerMode);
}; };
@ -44,8 +44,8 @@ public:
class CPlayerStateTeeterIdle : public CPlayerStateBaseIdle class CPlayerStateTeeterIdle : public CPlayerStateBaseIdle
{ {
public: public:
virtual void enter(class CPlayer *_player); virtual void enter(class CPlayerModeBasic *_playerMode);
virtual void think(class CPlayer *_player); virtual void think(class CPlayerModeBasic *_playerMode);
}; };
@ -62,8 +62,8 @@ typedef struct
class CPlayerStateIdle : public CPlayerStateBaseIdle class CPlayerStateIdle : public CPlayerStateBaseIdle
{ {
public: public:
virtual void enter(class CPlayer *_player); virtual void enter(class CPlayerModeBasic *_playerMode);
virtual void think(class CPlayer *_player); virtual void think(class CPlayerModeBasic *_playerMode);
private: private:
typedef enum typedef enum
@ -73,7 +73,7 @@ private:
ANIMSTATE_END, ANIMSTATE_END,
} ANIMSTATE; } ANIMSTATE;
void setNextIdleAnim(class CPlayer *_player); void setNextIdleAnim(class CPlayerModeBasic *_playerMode);
virtual IdleAnims *getIdleAnimsDb(int _animNo)=0; virtual IdleAnims *getIdleAnimsDb(int _animNo)=0;
virtual int getNumIdleAnims()=0; virtual int getNumIdleAnims()=0;

42
source/player/psjump.cpp
View file

@ -23,6 +23,10 @@
#include "player\player.h" #include "player\player.h"
#endif #endif
#ifndef __PLAYER_PMODES_H__
#include "player\pmodes.h"
#endif
#ifndef __SOUND_SOUND_H__ #ifndef __SOUND_SOUND_H__
#include "sound\sound.h" #include "sound\sound.h"
#endif #endif
@ -61,17 +65,12 @@
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateJump::enter(CPlayer *_player) void CPlayerStateJump::enter(CPlayerModeBasic *_playerMode)
{ {
const PlayerMetrics *metrics; _playerMode->setAnimNo(ANIM_SPONGEBOB_HOVER);
metrics=getPlayerMetrics(_player);
setAnimNo(_player,ANIM_SPONGEBOB_HOVER);
m_jumpFrames=0; m_jumpFrames=0;
DVECTOR move=getMoveVelocity(_player);
move.vy=-metrics->m_metric[PM__JUMP_VELOCITY]<<CPlayer::VELOCITY_SHIFT; _playerMode->jump();
setMoveVelocity(_player,&move);
CSoundMediator::playSfx(CSoundMediator::SFX_SPONGEBOB_JUMP); CSoundMediator::playSfx(CSoundMediator::SFX_SPONGEBOB_JUMP);
} }
@ -83,14 +82,14 @@ void CPlayerStateJump::enter(CPlayer *_player)
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateJump::think(CPlayer *_player) void CPlayerStateJump::think(CPlayerModeBasic *_playerMode)
{ {
const PlayerMetrics *metrics; const PlayerMetrics *metrics;
int controlHeld,controlDown; int controlHeld,controlDown;
metrics=getPlayerMetrics(_player); metrics=_playerMode->getPlayerMetrics();
controlHeld=getPadInputHeld(_player); controlHeld=_playerMode->getPadInputHeld();
controlDown=getPadInputDown(_player); controlDown=_playerMode->getPadInputDown();
if(m_jumpFrames<=metrics->m_metric[PM__MAX_JUMP_FRAMES]&&controlHeld&PI_JUMP) if(m_jumpFrames<=metrics->m_metric[PM__MAX_JUMP_FRAMES]&&controlHeld&PI_JUMP)
{ {
@ -98,24 +97,25 @@ void CPlayerStateJump::think(CPlayer *_player)
} }
else else
{ {
setState(_player,STATE_FALL); _playerMode->setState(STATE_FALL);
} }
if(controlDown&PI_ACTION)
{
setState(_player,STATE_AIRATTACK);
}
if(controlHeld&PI_LEFT) if(controlHeld&PI_LEFT)
{ {
moveLeft(_player); _playerMode->moveLeft();
} }
else if(controlHeld&PI_RIGHT) else if(controlHeld&PI_RIGHT)
{ {
moveRight(_player); _playerMode->moveRight();
} }
else else
{ {
slowdown(_player); _playerMode->slowdown();
}
if(controlHeld&PI_DOWN)
{
_playerMode->setState(STATE_BUTTBOUNCE);
} }
// advanceAnimFrameAndCheckForEndOfAnim(_player); // advanceAnimFrameAndCheckForEndOfAnim(_player);
} }

4
source/player/psjump.h
View file

@ -35,8 +35,8 @@
class CPlayerStateJump : public CPlayerState class CPlayerStateJump : public CPlayerState
{ {
public: public:
void enter(class CPlayer *_player); void enter(class CPlayerModeBasic *_playerMode);
void think(class CPlayer *_player); void think(class CPlayerModeBasic *_playerMode);
private: private:
int m_jumpFrames; int m_jumpFrames;

53
source/player/psrun.cpp
View file

@ -22,6 +22,10 @@
#include "player\player.h" #include "player\player.h"
#endif #endif
#ifndef __PLAYER_PMODES_H__
#include "player\pmodes.h"
#endif
/* Std Lib /* Std Lib
------- */ ------- */
@ -56,27 +60,27 @@
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateRun::enter(CPlayer *_player) void CPlayerStateRun::enter(CPlayerModeBasic *_playerMode)
{ {
int controlHeld; int controlHeld;
controlHeld=getPadInputHeld(_player); controlHeld=_playerMode->getPadInputHeld();
if(getMoveVelocity(_player).vx) if(_playerMode->getMoveVelocity().vx)
{ {
setAnimNo(_player,ANIM_SPONGEBOB_RUN); _playerMode->setAnimNo(ANIM_SPONGEBOB_RUN);
} }
else else
{ {
setAnimNo(_player,ANIM_SPONGEBOB_RUNSTART); _playerMode->setAnimNo(ANIM_SPONGEBOB_RUNSTART);
} }
if(controlHeld&PI_LEFT) if(controlHeld&PI_LEFT)
{ {
setFacing(_player,FACING_LEFT); _playerMode->setFacing(FACING_LEFT);
} }
else if(controlHeld&PI_RIGHT) else if(controlHeld&PI_RIGHT)
{ {
setFacing(_player,FACING_RIGHT); _playerMode->setFacing(FACING_RIGHT);
} }
m_numberOfTimeAnimHasLooped=0; m_numberOfTimeAnimHasLooped=0;
@ -89,56 +93,49 @@ void CPlayerStateRun::enter(CPlayer *_player)
Params: Params:
Returns: Returns:
---------------------------------------------------------------------- */ ---------------------------------------------------------------------- */
void CPlayerStateRun::think(CPlayer *_player) void CPlayerStateRun::think(CPlayerModeBasic *_playerMode)
{ {
int controlDown,controlHeld; int controlDown,controlHeld;
int switchedState=false; int switchedState=false;
controlDown=getPadInputDown(_player); controlDown=_playerMode->getPadInputDown();
controlHeld=getPadInputHeld(_player); controlHeld=_playerMode->getPadInputHeld();
if(controlDown&PI_JUMP) if(controlDown&PI_JUMP)
{ {
switchedState=setState(_player,STATE_JUMP); switchedState=_playerMode->setState(STATE_JUMP);
} }
if(controlHeld&PI_DOWN) if(controlHeld&PI_DOWN)
{ {
switchedState=setState(_player,STATE_DUCK); switchedState=_playerMode->setState(STATE_DUCK);
}
if(controlDown&PI_ACTION)
{
switchedState=setState(_player,STATE_RUNATTACK);
} }
if(controlHeld&PI_LEFT) if(controlHeld&PI_LEFT)
{ {
moveLeft(_player); _playerMode->moveLeft();
} }
else if(controlHeld&PI_RIGHT) else if(controlHeld&PI_RIGHT)
{ {
moveRight(_player); _playerMode->moveRight();
} }
else else
{
if(getMoveVelocity(_player).vx==0)
{ {
if(!switchedState) if(!switchedState)
{ {
setState(_player,STATE_IDLE); if(_playerMode->slowdown())
{
_playerMode->setState(STATE_IDLE);
if(m_numberOfTimeAnimHasLooped>=4) if(m_numberOfTimeAnimHasLooped>=4)
{ {
setAnimNo(_player,ANIM_SPONGEBOB_RUNSTOP); _playerMode->setAnimNo(ANIM_SPONGEBOB_RUNSTOP);
} }
return;
} }
} }
else
{
slowdown(_player);
}
} }
if(advanceAnimFrameAndCheckForEndOfAnim(_player)) if(_playerMode->advanceAnimFrameAndCheckForEndOfAnim())
{ {
setAnimNo(_player,ANIM_SPONGEBOB_RUN); _playerMode->setAnimNo(ANIM_SPONGEBOB_RUN);
m_numberOfTimeAnimHasLooped++; m_numberOfTimeAnimHasLooped++;
} }
} }

4
source/player/psrun.h
View file

@ -35,8 +35,8 @@
class CPlayerStateRun : public CPlayerState class CPlayerStateRun : public CPlayerState
{ {
public: public:
void enter(class CPlayer *_player); void enter(class CPlayerModeBasic *_playerMode);
void think(class CPlayer *_player); void think(class CPlayerModeBasic *_playerMode);
private: private:
int m_numberOfTimeAnimHasLooped; int m_numberOfTimeAnimHasLooped;

42
source/player/pstates.h
View file

@ -18,11 +18,6 @@
Includes Includes
-------- */ -------- */
#ifndef _GLOBAL_HEADER_
#include "system\global.h"
#endif
/* Std Lib /* Std Lib
------- */ ------- */
@ -37,41 +32,8 @@
class CPlayerState class CPlayerState
{ {
public: public:
virtual void enter(class CPlayer *_player) {;} virtual void enter(class CPlayerModeBasic *_playerMode) {;}
virtual void think(class CPlayer *_player) {;} virtual void think(class CPlayerModeBasic *_playerMode) {;}
protected:
const struct PlayerMetrics *getPlayerMetrics(class CPlayer *_player);
int setState(class CPlayer *_player,int _state);
void setMode(class CPlayer *_player,int _mode);
int getFacing(class CPlayer *_player);
void setFacing(class CPlayer *_player,int _facing);
int getAnimNo(class CPlayer *_player);
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);
DVECTOR getPlayerPos(class CPlayer *_player);
void setPlayerPos(class CPlayer *_player,DVECTOR *_pos);
int getPadInputHeld(class CPlayer *_player);
int getPadInputDown(class CPlayer *_player);
int isOnEdge(class CPlayer *_player);
int canMoveLeft(class CPlayer *_player);
int canMoveRight(class CPlayer *_player);
void moveLeft(class CPlayer *_player);
void moveRight(class CPlayer *_player);
void slowdown(class CPlayer *_player);
void jump(class CPlayer *_player);
void fall(class CPlayer *_player);
void respawn(class CPlayer *_player);
}; };