Mirrors/SBSPSS
1
0
Fork 0
Code Releases Activity

Browse Source
This commit is contained in:
Paul 2001-01-25 15:25:46 +00:00
parent 6c5c1fba9b
commit f81d0c4b5e
15 changed files with 424 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
makefile.gaz
View File

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

12
source/game/game.cpp
View File

@ -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();
CBubicleFactory::setMapOffset(&mapPos);
Level.setCameraCentre(mapPos);
camPos=m_player->getCameraPos();
//PKG
if(camPos.vx<0)camPos.vx=0;
if(camPos.vy<0)camPos.vy=0;
//PKG
CBubicleFactory::setMapOffset(&camPos);
Level.setCameraCentre(camPos);
Level.think(_frames);
}
}

190
source/player/player.cpp
View File

@ -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
&stateRun, // STATE_RUN
&stateFall, // STATE_FALL
&stateFallFar, // STATE_FALLFAR
&stateButtBounce, // STATE_BUTTBOUNCE
&stateButtBounceFall, // STATE_BUTTFALL
&stateButtBounceLand, // STATE_BUTTLAND
&stateChop, // STATE_CHOP
&stateRunChop, // STATE_RUNCHOP
&stateDuck, // STATE_DUCK
&stateSoackUp, // STATE_SOAKUP
&stateGetup, // STATE_GETUP
{ {
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
} },
{
&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||
m_invincibleFrameCount&MASK)
if(m_invincibleFrameCount==0||m_invincibleFrameCount&2)
{
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;
}

25
source/player/player.h
View File

@ -52,8 +52,9 @@ typedef enum
STATE_BUTTBOUNCE,
STATE_BUTTFALL,
STATE_BUTTLAND,
STATE_CHOP,
STATE_RUNCHOP,
STATE_ATTACK,
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;
};

43
source/player/psbutt.cpp
View File

@ -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:

7
source/player/psbutt.h
View File

@ -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

31
source/player/pschop.cpp
View File

@ -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 */

8
source/player/pschop.h
View File

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

24
source/player/psfall.cpp
View File

@ -1,4 +1,3 @@
/*=========================================================================
psfall.cpp
@ -65,8 +64,7 @@
---------------------------------------------------------------------- */
void CPlayerStateFall::enter(CPlayer *_player)
{
setAnimNo(_player,ANIM_PLAYER_ANIM_JUMPSTART);
m_fallFrames=0;
setAnimNo(_player,ANIM_PLAYER_ANIM_HOVER);
}
@ -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);
}

3
source/player/psfall.h
View File

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

19
source/player/psjump.cpp
View File

@ -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;
move=getMoveVelocity(_player);
if(move.vy>=0)
{
setState(_player,STATE_FALL);
}
else
{
move.vy+=metrics->m_metric[PM__GRAVITY_VALUE];
}
setMoveVelocity(_player,&move);
setState(_player,STATE_FALL);
}
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);
}

10
source/player/psrun.cpp
View File

@ -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++;
}
}

3
source/player/psrun.h
View File

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

245
source/player/pstates.cpp
View File

@ -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__
#include "pad\pads.h"
#endif
/* Std Lib
------- */
/* Data
---- */
/*----------------------------------------------------------------------
Tyepdefs && Defines
------------------- */
/*----------------------------------------------------------------------
Structure defintions
-------------------- */
#ifndef __ANIM_PLAYER_ANIM_HEADER__
#include <player_anim.h>
#endif
/*----------------------------------------------------------------------
Function Prototypes
------------------- */
/*----------------------------------------------------------------------
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();
}
/*----------------------------------------------------------------------*/
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);
}
}
/*===========================================================================
end */

14
source/player/pstates.h
View File

@ -37,8 +37,8 @@
class CPlayerState
{
public:
virtual void enter(class CPlayer *_player)=0;
virtual void think(class CPlayer *_player)=0;
virtual void enter(class CPlayer *_player) {;}
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
------- */