Mirrors/SBSPSS
1
0
Fork 0
Code Releases Activity
5190abd658
SBSPSS/source/player/pmodes.cpp
Charles 759dafc875
2001-08-17 14:25:04 +00:00

824 lines
20 KiB
C++
Raw Blame History

/*=========================================================================
pmodes.cpp
Author: PKG
Created:
Project: Spongebob
Purpose:
Copyright (c) 2001 Climax Development Ltd
===========================================================================*/
/*----------------------------------------------------------------------
Includes
-------- */
#include "player\pmodes.h"
#ifndef __PLAYER_PLAYER_H__
#include "player\player.h"
#endif
#ifndef __PLAYER_PSTATES_H__
#include "player\pstates.h"
#endif
#ifndef __LAYER_COLLISION_H__
#include "level\layercollision.h"
#endif
#ifndef __PAD_VIBE_H__
#include "pad\vibe.h"
#endif
// States
#ifndef __PLAYER__PSLOOK_H__
#include "player\pslook.h"
#endif
#ifndef __PLAYER__PSJUMP_H__
#include "player\psjump.h"
#endif
#ifndef __PLAYER__PSJMPBCK_H__
#include "player\psjmpbck.h"
#endif
#ifndef __PLAYER__PSRUN_H__
#include "player\psrun.h"
#endif
#ifndef __PLAYER__PSFALL_H__
#include "player\psfall.h"
#endif
#ifndef __PLAYER__PSHITGND_H__
#include "player\pshitgnd.h"
#endif
#ifndef __PLAYER__PSIDLE_H__
#include "player\psidle.h"
#endif
#ifndef __PLAYER__PSBUTT_H__
#include "player\psbutt.h"
#endif
#ifndef __PLAYER__PSDUCK_H__
#include "player\psduck.h"
#endif
#ifndef __PLAYER__PSSPRING_H__
#include "player\psspring.h"
#endif
#ifndef __PLAYER_PSCART_H__
#include "player\pscart.h"
#endif
#ifndef __PLAYER_PSSWAL_H__
#include "player\psswal.h"
#endif
#ifndef __PLAYER_PSFLOAT_H__
#include "player\psfloat.h"
#endif
#ifndef __PLATFORM_PLATFORM_H__
#include "platform\platform.h"
#endif
#ifndef __PLAYER_PSDANCE_H__
#include "player\psdance.h"
#endif
#ifndef __GAME_GAME_H__
#include "game/game.h"
#endif
#ifndef __FX_FX_H__
#include "fx\fx.h"
#endif
/* Std Lib
------- */
/* Data
---- */
#ifndef __ANIM_SPONGEBOB_HEADER__
#include <ACTOR_SPONGEBOB_ANIM.h>
#endif
/*----------------------------------------------------------------------
Tyepdefs && Defines
------------------- */
/*----------------------------------------------------------------------
Structure defintions
-------------------- */
/*----------------------------------------------------------------------
Function Prototypes
------------------- */
/*----------------------------------------------------------------------
Vars
---- */
static CPlayerState *s_stateTable[]=
{
&s_stateUnarmedIdle, // STATE_IDLE
&s_stateTeeterIdle, // STATE_IDLETEETER
&s_stateJump, // STATE_JUMP
&s_stateSpring, // STATE_SPRINGUP
&s_stateRun, // STATE_RUN
&s_stateFall, // STATE_FALL
&s_stateFallFar, // STATE_FALLFAR
&s_stateHitGround, // STATE_HITGROUND
&s_stateButtBounce, // STATE_BUTTBOUNCE
&s_stateButtBounceFall, // STATE_BUTTFALL
&s_stateButtBounceLand, // STATE_BUTTLAND
&s_stateButtBounceUp, // STATE_BUTTBOUNCEUP
&s_stateSoakUp, // STATE_SOAKUP
&s_stateGetUp, // STATE_GETUP
&s_stateLookDown, // STATE_LOOKDOWN
&s_stateLookDownRelax, // STATE_LOOKDOWNRELAX
&s_stateLookUp, // STATE_LOOKUP
&s_stateLookUpRelax, // STATE_LOOKUPRELAX
&s_stateJumpBack, // STATE_JUMPBACK
&s_stateCart, // STATE_CART
&s_stateFloat, // STATE_FLOAT
&s_stateDance, // STATE_CELEBRATE
&s_stateSwallow, // STATE_SWALLOW
};
static PlayerMetrics s_playerMetrics=
{ {
DEFAULT_PLAYER_JUMP_VELOCITY, // PM__JUMP_VELOCITY
DEFAULT_PLAYER_MAX_JUMP_FRAMES, // PM__MAX_JUMP_FRAMES
DEFAULT_PLAYER_MAX_SAFE_FALL_FRAMES, // PM__MAX_SAFE_FALL_FRAMES
DEFAULT_PLAYER_MAX_RUN_VELOCITY, // PM__MAX_RUN_VELOCITY
DEFAULT_PLAYER_RUN_SPEEDUP, // PM__RUN_SPEEDUP
DEFAULT_PLAYER_RUN_REVERSESLOWDOWN, // PM__RUN_REVERSESLOWDOWN
DEFAULT_PLAYER_RUN_SLOWDOWN, // PM__RUN_SLOWDOWN
DEFAULT_PLAYER_PLAYER_GRAVITY, // PM__GRAVITY
DEFAULT_PLAYER_TERMINAL_VELOCITY, // PM__TERMINAL_VELOCITY
DEFAULT_BUTT_FALL_VELOCITY, // PM__BUTT_FALL_VELOCITY
DEFAULT_HITREACT_XVELOCITY, // PM__HITREACT_XVELOCITY
DEFAULT_HITREACT_YVELOCITY, // PM__HITREACT_YVELOCITY
DEFAULT_HITREACT_FRAMES, // PM__HITREACT_FRAMES
} };
int checkx=8;
int checky=15;
int checkycanmove=16;
int checkdist=16;
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
int CPlayerMode::getPadInputHeld() {return m_player->getPadInputHeld();}
int CPlayerMode::getPadInputDown() {return m_player->getPadInputDown();}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
extern int checkx;
int CPlayerMode::getHeightFromGound()
{
int height[2];
DVECTOR const &pos=getPlayerPos();
height[0]=m_player->getHeightFromGround(pos.vx-checkx,pos.vy);
height[1]=m_player->getHeightFromGround(pos.vx+checkx,pos.vy);
return height[0]<height[1]?height[0]:height[1];
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CPlayerMode::inSoakUpState() {m_player->inSoakUpState();}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
DVECTOR const &CPlayerMode::getPlayerPos() {return m_player->getPlayerPos();}
void CPlayerMode::setPlayerPos(DVECTOR *_pos) {m_player->setPlayerPos(_pos);}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CPlayerMode::respawn() {m_player->respawn();}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CPlayerModeBase::enter()
{
m_fallFrames=0;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CPlayerModeBase::think()
{
getStateTable()[m_currentState]->think(this);
thinkVerticalMovement();
thinkHorizontalMovement();
// Teeter if on an edge
if(canTeeter()&&isOnEdge())
{
setState(STATE_IDLETEETER);
}
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
int CPlayerModeBase::canDoLookAround()
{
int ret=false;
switch(getState())
{
case STATE_IDLE:
case STATE_IDLETEETER:
case STATE_SOAKUP:
case STATE_LOOKDOWN:
case STATE_LOOKUP:
ret=true;
break;
case STATE_JUMP:
case STATE_SPRINGUP:
case STATE_RUN:
case STATE_FALL:
case STATE_FALLFAR:
case STATE_HITGROUND:
case STATE_BUTTBOUNCE:
case STATE_BUTTFALL:
case STATE_BUTTLAND:
case STATE_BUTTBOUNCEUP:
case STATE_GETUP:
case STATE_LOOKDOWNRELAX:
case STATE_LOOKUPRELAX:
case STATE_JUMPBACK:
break;
}
return ret;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
ATTACK_STATE CPlayerModeBase::getAttackState()
{
ATTACK_STATE ret=ATTACK_STATE__NONE;
switch(getState())
{
case STATE_BUTTFALL:
case STATE_BUTTLAND:
case STATE_BUTTBOUNCEUP:
ret=ATTACK_STATE__BUTT_BOUNCE;
break;
case STATE_IDLE:
case STATE_IDLETEETER:
case STATE_JUMP:
case STATE_SPRINGUP:
case STATE_RUN:
case STATE_FALL:
case STATE_FALLFAR:
case STATE_BUTTBOUNCE:
case STATE_SOAKUP:
case STATE_GETUP:
case STATE_LOOKDOWN:
case STATE_LOOKDOWNRELAX:
case STATE_LOOKUP:
case STATE_LOOKUPRELAX:
case STATE_JUMPBACK:
break;
}
return ret;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CPlayerModeBase::thinkVerticalMovement()
{
if(m_player->moveVertical(m_player->getMoveVelocity()->vy>>VELOCITY_SHIFT))
{
if(m_currentState!=STATE_CELEBRATE)
playerHasHitGround();
DVECTOR const &pos=m_player->getPlayerPos();
if(m_player->getHeightFromGround(pos.vx,pos.vy,5)==0&&
(CGameScene::getCollision()->getCollisionBlock(pos.vx,pos.vy)&COLLISION_TYPE_MASK)==COLLISION_TYPE_FLAG_SOAKUP)
{
// Hit water - Make a splash!
DVECTOR pos;
CSoundMediator::playSfx(CSoundMediator::SFX_SPONGEBOB_SPLASH_INTO_WATER);
pos=getPlayerPos();
pos.vy-=40;
CFX::Create(CFX::FX_TYPE_SPLASH_WATER,pos);
if(!m_player->getIsHelmetSoFullThatIDontNeedToSoakUp())
{
// Not got full water levels - Go into soakup mode
setState(STATE_SOAKUP);
}
}
}
else if(m_currentState!=STATE_FALL&&m_currentState!=STATE_FALLFAR&& // Hmm.. (pkg)
m_currentState!=STATE_BUTTFALL&&m_currentState!=STATE_BUTTBOUNCE&&
m_currentState!=STATE_JUMP&&m_currentState!=STATE_SPRINGUP&&
m_currentState!=STATE_JUMPBACK&&m_currentState!=STATE_BUTTBOUNCEUP&&
m_currentState!=STATE_FLOAT&&m_currentState!=STATE_CELEBRATE)
{
DVECTOR const &pos=m_player->getPlayerPos();
if(m_player->getHeightFromGround(pos.vx,pos.vy,1)!=0&&
m_player->getHeightFromGround(pos.vx-checkx,pos.vy,1)!=0&&
m_player->getHeightFromGround(pos.vx+checkx,pos.vy,1)!=0
)
{
// Was floating in the air.. fall!
setState(STATE_FALL);
}
}
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CPlayerModeBase::thinkHorizontalMovement()
{
DVECTOR moveVel;
moveVel=*m_player->getMoveVelocity();
if(m_player->moveHorizontal(moveVel.vx>>VELOCITY_SHIFT))
{
// If running then go to idle, otherwise leave in same state
if(m_currentState==STATE_RUN)
{
setState(STATE_IDLE);
}
moveVel.vx=0;
setMoveVelocity(&moveVel);
}
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CPlayerModeBase::playerHasHitGround()
{
DVECTOR moveVel;
moveVel=*m_player->getMoveVelocity();
moveVel.vy=0;
m_fallFrames=0;
m_player->setLockoutPlatform( NULL );
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
// This no longer hurts as per THQs request..
setState(STATE_HITGROUND);
#ifdef __USER_paul__
m_player->takeDamage(DAMAGE__FALL,REACT__NO_REACTION);
#else
CPadVibrationManager::setVibration(0,CPadVibrationManager::VIBE_SHORT);
#endif
moveVel.vx=0;
CGameScene::setCameraShake(0,8);
}
else if(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);
}
setMoveVelocity(&moveVel);
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
const struct PlayerMetrics *CPlayerModeBase::getPlayerMetrics()
{
return &s_playerMetrics;
}
/*----------------------------------------------------------------------
Function:
Purpose: Sets player state.
NB: When you re-enter a state due to changing modes ( ie: when picking up
a weapon ) then strange things can happen :/
Params:
Returns:
---------------------------------------------------------------------- */
int CPlayerModeBase::setState(int _state)
{
int ret=false;
if(m_currentState==STATE_CELEBRATE&&_state!=STATE_IDLE)
{
ret=true;
}
else
{
CPlayerState *nextState;
nextState=getStateTable()[_state];
if(nextState)
{
m_player->resetPlayerCollisionSizeToBase();
m_currentStateClass=nextState;
m_currentStateClass->enter(this);
m_currentState=(PLAYER_STATE)_state;
ret=true;
}
}
return ret;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
int CPlayerModeBase::getFacing() {return m_player->getFacing();}
void CPlayerModeBase::setFacing(int _facing) {m_player->setFacing(_facing);}
int CPlayerModeBase::getAnimNo() {return m_player->getAnimNo();}
void CPlayerModeBase::setAnimNo(int _animNo) {m_player->setAnimNo(_animNo);setAnimFrame(0);}
int CPlayerModeBase::getAnimFrame() {return m_player->getAnimFrame();}
int CPlayerModeBase::getAnimFrameCount() {return m_player->getAnimFrameCount();}
void CPlayerModeBase::setAnimFrame(int _animFrame) {m_player->setAnimFrame(_animFrame);}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
int CPlayerModeBase::advanceAnimFrameAndCheckForEndOfAnim()
{
int animFrame,frameCount;
int looped;
animFrame=getAnimFrame()+1;
frameCount=getAnimFrameCount();
looped=false;
if(animFrame>=frameCount)
{
looped=true;
animFrame=0;
}
setAnimFrame(animFrame);
return looped;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
DVECTOR CPlayerModeBase::getMoveVelocity() {return *m_player->getMoveVelocity();}
void CPlayerModeBase::zeroMoveVelocity() {DVECTOR v={0,0};setMoveVelocity(&v);}
void CPlayerModeBase::setMoveVelocity(DVECTOR *_moveVel) {m_player->setMoveVelocity(_moveVel);}
/*----------------------------------------------------------------------
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 CPlayerModeBase::isOnEdge()
{
CLayerCollision *collision=CGameScene::getCollision();
int ret;
DVECTOR const &pos=m_player->getPlayerPos();
ret=0;
if(m_player->getHeightFromGround(pos.vx-csize,pos.vy,cheight+1)>cheight)
{
ret=FACING_LEFT;
}
else if(m_player->getHeightFromGround(pos.vx+csize,pos.vy,cheight+1)>cheight)
{
ret=FACING_RIGHT;
}
return ret;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
int CPlayerModeBase::canMoveLeft()
{
DVECTOR const &pos=m_player->getPlayerPos();
return m_player->getHeightFromGround(pos.vx-checkx-1,pos.vy,checkdist)>-checkycanmove?true:false;
}
int CPlayerModeBase::canMoveRight()
{
DVECTOR const &pos=m_player->getPlayerPos();
return m_player->getHeightFromGround(pos.vx+checkx+1,pos.vy,checkdist)>-checkycanmove?true:false;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CPlayerModeBase::setPlayerCollisionSize(int _x,int _y,int _w,int _h)
{
m_player->setPlayerCollisionSize(_x,_y,_w,_h);
}
void CPlayerModeBase::getPlayerCollisionSize(int *_x,int *_y,int *_w,int *_h)
{
m_player->getPlayerCollisionSize(_x,_y,_w,_h);
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CPlayerModeBase::moveLeft()
{
const PlayerMetrics *metrics;
DVECTOR moveVel;
metrics=getPlayerMetrics();
moveVel=*m_player->getMoveVelocity();
setFacing(FACING_LEFT);
if(moveVel.vx<=0)
{
moveVel.vx-=metrics->m_metric[PM__RUN_SPEEDUP];
if(moveVel.vx<-metrics->m_metric[PM__MAX_RUN_VELOCITY]<<VELOCITY_SHIFT)
{
moveVel.vx=-metrics->m_metric[PM__MAX_RUN_VELOCITY]<<VELOCITY_SHIFT;
}
}
else
{
moveVel.vx-=metrics->m_metric[PM__RUN_REVERSESLOWDOWN];
}
setMoveVelocity(&moveVel);
m_player->moveLeft();
}
void CPlayerModeBase::moveRight()
{
const PlayerMetrics *metrics;
DVECTOR moveVel;
metrics=getPlayerMetrics();
moveVel=*m_player->getMoveVelocity();
setFacing(FACING_RIGHT);
if(moveVel.vx>=0)
{
moveVel.vx+=metrics->m_metric[PM__RUN_SPEEDUP];
if(moveVel.vx>metrics->m_metric[PM__MAX_RUN_VELOCITY]<<VELOCITY_SHIFT)
{
moveVel.vx=metrics->m_metric[PM__MAX_RUN_VELOCITY]<<VELOCITY_SHIFT;
}
}
else
{
moveVel.vx+=metrics->m_metric[PM__RUN_REVERSESLOWDOWN];
}
setMoveVelocity(&moveVel);
m_player->moveRight();
}
int CPlayerModeBase::slowdown()
{
const PlayerMetrics *metrics;
DVECTOR moveVel;
int ret=false;
metrics=getPlayerMetrics();
moveVel=*m_player->getMoveVelocity();
if(moveVel.vx<0)
{
moveVel.vx+=metrics->m_metric[PM__RUN_SLOWDOWN];
if(moveVel.vx>=0)
{
moveVel.vx=0;
ret=true;
}
}
else if(moveVel.vx>0)
{
moveVel.vx-=metrics->m_metric[PM__RUN_SLOWDOWN];
if(moveVel.vx<=0)
{
moveVel.vx=0;
ret=true;
}
}
else
{
// Hmm.. was already stopped(?)
// This should probly be considered a bug.. (pkg)
ret=true;
}
setMoveVelocity(&moveVel);
return ret;
}
void CPlayerModeBase::jump()
{
DVECTOR moveVel;
moveVel=*m_player->getMoveVelocity();
moveVel.vy=-getPlayerMetrics()->m_metric[PM__JUMP_VELOCITY]<<VELOCITY_SHIFT;
setMoveVelocity(&moveVel);
}
int spr=5;
void CPlayerModeBase::spring()
{
DVECTOR moveVel;
moveVel=*m_player->getMoveVelocity();
// moveVel.vy=-getPlayerMetrics()->m_metric[PM__JUMP_VELOCITY]<<VELOCITY_SHIFT;
moveVel.vy-=spr;
if(moveVel.vy<-getPlayerMetrics()->m_metric[PM__JUMP_VELOCITY]<<VELOCITY_SHIFT)
{
moveVel.vy=-getPlayerMetrics()->m_metric[PM__JUMP_VELOCITY]<<VELOCITY_SHIFT;
}
setMoveVelocity(&moveVel);
}
void CPlayerModeBase::jumpback()
{
DVECTOR moveVel;
int xvel;
moveVel=*m_player->getMoveVelocity();
moveVel.vy=-getPlayerMetrics()->m_metric[PM__HITREACT_YVELOCITY]<<VELOCITY_SHIFT;
xvel=getPlayerMetrics()->m_metric[PM__HITREACT_XVELOCITY]<<VELOCITY_SHIFT;
if(moveVel.vx<0)
{
moveVel.vx=-xvel;
}
else if(moveVel.vx>0)
{
moveVel.vx=xvel;
}
setMoveVelocity(&moveVel);
}
void CPlayerModeBase::fall()
{
const PlayerMetrics *metrics;
DVECTOR moveVel;
metrics=getPlayerMetrics();
moveVel=*m_player->getMoveVelocity();
moveVel.vy+=getPlayerMetrics()->m_metric[PM__GRAVITY];
if(moveVel.vy>=metrics->m_metric[PM__TERMINAL_VELOCITY]<<VELOCITY_SHIFT)
{
moveVel.vy=metrics->m_metric[PM__TERMINAL_VELOCITY]<<VELOCITY_SHIFT;
if(!canFallForever()&&m_currentState!=STATE_FALLFAR)
{
const PlayerMetrics *metrics;
metrics=getPlayerMetrics();
m_fallFrames++;
if(m_fallFrames>metrics->m_metric[PM__MAX_SAFE_FALL_FRAMES])
{
setState(STATE_FALLFAR);
}
}
}
setMoveVelocity(&moveVel);
m_player->fall();
}
// whatever..
void CPlayerModeBase::fallToDance()
{
const PlayerMetrics *metrics;
DVECTOR moveVel;
metrics=getPlayerMetrics();
moveVel=*m_player->getMoveVelocity();
moveVel.vy+=getPlayerMetrics()->m_metric[PM__GRAVITY];
if(moveVel.vy>=metrics->m_metric[PM__TERMINAL_VELOCITY]<<VELOCITY_SHIFT)
{
moveVel.vy=metrics->m_metric[PM__TERMINAL_VELOCITY]<<VELOCITY_SHIFT;
}
setMoveVelocity(&moveVel);
m_player->fall();
}
int buttfallspeed=9;
void CPlayerModeBase::buttFall()
{
const PlayerMetrics *metrics;
DVECTOR moveVel;
metrics=getPlayerMetrics();
moveVel=*m_player->getMoveVelocity();
// moveVel.vy=metrics->m_metric[PM__BUTT_FALL_VELOCITY]<<(VELOCITY_SHIFT+1);
moveVel.vy=metrics->m_metric[buttfallspeed]<<VELOCITY_SHIFT;
setMoveVelocity(&moveVel);
m_player->buttFall();
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
CPlayerState **CPlayerModeBase::getStateTable()
{
return s_stateTable;
}
/*===========================================================================
end */
View Git Blame Copy Permalink