2986 lines
74 KiB
C++
2986 lines
74 KiB
C++
/*=========================================================================
|
|
|
|
player.cpp
|
|
|
|
Author: PKG
|
|
Created:
|
|
Project: Spongebob
|
|
Purpose:
|
|
|
|
Copyright (c) 2001 Climax Development Ltd
|
|
|
|
===========================================================================*/
|
|
|
|
/*----------------------------------------------------------------------
|
|
Includes
|
|
-------- */
|
|
|
|
#include "system\vid.h"
|
|
#include "player\player.h"
|
|
|
|
#ifndef __PAD_PADS_H__
|
|
#include "pad\pads.h"
|
|
#endif
|
|
|
|
#ifndef __PAD_VIBE_H__
|
|
#include "pad\vibe.h"
|
|
#endif
|
|
|
|
#ifndef __GAME_GAME_H__
|
|
#include "game\game.h"
|
|
#endif
|
|
|
|
#ifndef __GAME_GAMESLOT_H__
|
|
#include "game\gameslot.h"
|
|
#endif
|
|
|
|
#ifndef __LAYER_COLLISION_H__
|
|
#include "level\layercollision.h"
|
|
#endif
|
|
|
|
#ifndef __PLAYER_PMODES_H__
|
|
#include "player\pmodes.h"
|
|
#endif
|
|
|
|
#ifndef __PLAYER_PMBLOON_H__
|
|
#include "player\pmbloon.h"
|
|
#endif
|
|
|
|
#ifndef __PLAYER_PMBUBBLE_H__
|
|
#include "player\pmbubble.h"
|
|
#endif
|
|
|
|
#ifndef __PLAYER_PMNET_H__
|
|
#include "player\pmnet.h"
|
|
#endif
|
|
|
|
#ifndef __PLAYER_PMCHOP_H__
|
|
#include "player\pmchop.h"
|
|
#endif
|
|
|
|
#ifndef __PLAYER_PMCORAL_H__
|
|
#include "player\pmcoral.h"
|
|
#endif
|
|
|
|
#ifndef __PLAYER_PMDEAD_H__
|
|
#include "player\pmdead.h"
|
|
#endif
|
|
|
|
#ifndef __PLAYER_PMFLY_H__
|
|
#include "player\pmfly.h"
|
|
#endif
|
|
|
|
#ifndef __PLAYER_PMJELLY_H__
|
|
#include "player\pmjelly.h"
|
|
#endif
|
|
|
|
#ifndef __PLAYER_PMCART_H__
|
|
#include "player\pmcart.h"
|
|
#endif
|
|
|
|
#ifndef __PLAYER_PMSWAL_H__
|
|
#include "player\pmswal.h"
|
|
#endif
|
|
|
|
#ifndef __GFX_FONT_H__
|
|
#include "gfx\font.h"
|
|
#endif
|
|
|
|
#ifndef __GFX_SPRBANK_H__
|
|
#include "gfx\sprbank.h"
|
|
#endif
|
|
|
|
#ifndef __PLATFORM_PLATFORM_H__
|
|
#include "platform\platform.h"
|
|
#endif
|
|
|
|
#ifndef __PICKUPS_PICKUP_H__
|
|
#include "pickups\pickup.h"
|
|
#endif
|
|
|
|
#ifndef __MATHTABLE_HEADER__
|
|
#include "utils\mathtab.h"
|
|
#endif
|
|
|
|
#ifndef __GAME_CONVO_H__
|
|
#include "game\convo.h"
|
|
#endif
|
|
|
|
|
|
/* Std Lib
|
|
------- */
|
|
|
|
/* Data
|
|
---- */
|
|
|
|
#ifndef __SPR_SPRITES_H__
|
|
#include <sprites.h>
|
|
#endif
|
|
|
|
#ifndef __ANIM_SPONGEBOB_HEADER__
|
|
#include <ACTOR_SPONGEBOB_Anim.h>
|
|
#endif
|
|
|
|
#ifndef __ANIM_SPONGEBOB_NET_HEADER__
|
|
#include <ACTOR_SPONGEBOB_NET_Anim.h>
|
|
#endif
|
|
|
|
#ifndef __ANIM_SPONGEBOB_CORALBLOWER_HEADER__
|
|
#include <ACTOR_SPONGEBOB_CORALBLOWER_Anim.h>
|
|
#endif
|
|
|
|
#ifndef __ANIM_SPONGEBOB_JELLYLAUNCHER_HEADER__
|
|
#include <ACTOR_SPONGEBOB_JELLYLAUNCHER_Anim.h>
|
|
#endif
|
|
|
|
#ifndef __ANIM_SPONGEBOB_WAND_HEADER__
|
|
#include <ACTOR_SPONGEBOB_WAND_Anim.h>
|
|
#endif
|
|
|
|
#ifndef __ANIM_SPONGEBOB_JELLYFISH_HEADER__
|
|
#include <ACTOR_SPONGEBOB_JELLYFISH_Anim.h>
|
|
#endif
|
|
|
|
#ifndef __ANIM_SPONGEBOB_GLOVE_HEADER__
|
|
#include <ACTOR_SPONGEBOB_GLOVE_Anim.h>
|
|
#endif
|
|
|
|
#include "fx\fx.h"
|
|
/*----------------------------------------------------------------------
|
|
Tyepdefs && Defines
|
|
------------------- */
|
|
|
|
#ifdef __VERSION_DEBUG__
|
|
//#define _RECORD_DEMO_MODE_
|
|
#define _STATE_DEBUG_
|
|
#endif
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Structure defintions
|
|
-------------------- */
|
|
|
|
// Two dice. One says 'Re' on every face, the other says 'boot',
|
|
// 'install', 'try', 'tire', 'sume' and 'number'
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function Prototypes
|
|
------------------- */
|
|
|
|
/*----------------------------------------------------------------------
|
|
Vars
|
|
---- */
|
|
|
|
#ifdef _RECORD_DEMO_MODE_
|
|
|
|
#include "player\demoplay.h"
|
|
|
|
#define MAX_DEMO_SIZE 512 // So max size of a demo is 1k
|
|
#define MAX_DEMO_TIME_IN_FRAMES 30*60 // Recorded demo will last 30 seconds
|
|
|
|
static CDemoPlayer::demoPlayerControl s_demoControls[MAX_DEMO_SIZE]={{PI_NONE,0}};
|
|
static int s_demoSize=0;
|
|
static int s_demoFrameCount=0;
|
|
|
|
static void writeDemoControls()
|
|
{
|
|
char filename[32];
|
|
int fh;
|
|
int fc=MAX_DEMO_TIME_IN_FRAMES;
|
|
|
|
sprintf(filename,"demo____.dmo");
|
|
fh=PCcreat((char *)filename,0);
|
|
ASSERT(fh!=-1);
|
|
PCwrite(fh,(char*)&fc,sizeof(fc)); // frame count
|
|
PCwrite(fh,(char*)&s_demoSize,sizeof(s_demoSize)); // demo size
|
|
for(int i=0;i<s_demoSize;i++)
|
|
PCwrite(fh,(char*)&s_demoControls[i],sizeof(CDemoPlayer::demoPlayerControl)); // control data
|
|
PCclose(fh);
|
|
|
|
SYSTEM_DBGMSG("Written demo file %s with %d frames",filename,s_demoSize);
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef _STATE_DEBUG_
|
|
static const char *s_modeText[NUM_PLAYERMODES]=
|
|
{
|
|
"BASICUNARMED",
|
|
"FULLUNARMED",
|
|
"BALLOON",
|
|
"BUBBLE MIXTURE",
|
|
"NET",
|
|
"CORALBLOWER",
|
|
"JELLY LAUNCHER",
|
|
"DEAD",
|
|
"FLY",
|
|
"CART",
|
|
"SWALLOW",
|
|
};
|
|
#endif
|
|
|
|
|
|
int m_cameraLookOffset;
|
|
|
|
int MAP2D_CENTRE_X=-(INGAME_SCREENW/2);
|
|
int MAP2D_CENTRE_Y=-(INGAME_SCREENH/2)-32;
|
|
int MAP2D_BLOCKSTEPSIZE=16;
|
|
|
|
CPlayerModeBase PLAYERMODE;
|
|
CPlayerModeChop PLAYERMODECHOP;
|
|
CPlayerModeBalloon PLAYERMODEBALLOON;
|
|
CPlayerModeBubbleMixture PLAYERMODEBUBBLEMIXTURE;
|
|
CPlayerModeNet PLAYERMODENET;
|
|
CPlayerModeCoralBlower PLAYERMODECORALBLOWER;
|
|
CPlayerModeJellyLauncher PLAYERMODEJELLYLAUNCHER;
|
|
CPlayerModeDead PLAYERMODEDEAD;
|
|
CPlayerModeFly PLAYERMODEFLY;
|
|
CPlayerModeCart PLAYERMODECART;
|
|
CPlayerModeSwallow PLAYERMODESWALLOW;
|
|
|
|
CPlayerMode *CPlayer::s_playerModes[NUM_PLAYERMODES]=
|
|
{
|
|
&PLAYERMODE, // PLAYER_MODE_BASICUNARMED
|
|
&PLAYERMODECHOP, // PLAYER_MODE_FULLUNARMED
|
|
&PLAYERMODEBALLOON, // PLAYER_MODE_BALLOON
|
|
&PLAYERMODEBUBBLEMIXTURE, // PLAYER_MODE_BUBBLE_MIXTURE
|
|
&PLAYERMODENET, // PLAYER_MODE_NET
|
|
&PLAYERMODECORALBLOWER, // PLAYER_MODE_CORALBLOWER
|
|
&PLAYERMODEJELLYLAUNCHER, // PLAYER_MODE_JELLY_LAUNCHER
|
|
&PLAYERMODEDEAD, // PLAYER_MODE_DEAD
|
|
&PLAYERMODEFLY, // PLAYER_MODE_FLY
|
|
&PLAYERMODECART, // PLAYER_MODE_CART
|
|
&PLAYERMODESWALLOW, // PLAYER_MODE_SWALLOW
|
|
};
|
|
|
|
|
|
// A big bunch of 'temporary' variables for tweaking things
|
|
// This #def makes them static under a release build..
|
|
#ifdef __VERSION_DEBUG__
|
|
#define pint int
|
|
#else
|
|
#define pint static const int
|
|
#endif
|
|
|
|
pint sbanimspeed=0;
|
|
|
|
pint looktimeout=20;
|
|
pint lookmaxoffsetup=4*MAP2D_BLOCKSTEPSIZE;
|
|
pint lookmaxoffsetdown=4*MAP2D_BLOCKSTEPSIZE;
|
|
pint lookspeed=2;
|
|
pint lookreturnspeed=5;
|
|
|
|
pint ledgeTimer=50;
|
|
pint ledgeSpeedIn=1;
|
|
pint ledgeSpeedOut=3;
|
|
pint ledgeShift=1;
|
|
|
|
pint cammove=2;
|
|
|
|
pint waterDrainSpeed=4;
|
|
pint waterSoakUpSpeed=40;
|
|
|
|
|
|
|
|
// --------------------------------- Addon stuff ---------------------------------
|
|
CActorGfx *s_addonActorGfx[NUM_PLAYER_ADDONS]=
|
|
{
|
|
NULL, // PLAYER_ADDON_NET
|
|
NULL, // PLAYER_ADDON_CORALBLOWER
|
|
NULL, // PLAYER_ADDON_JELLYLAUNCHER
|
|
NULL, // PLAYER_ADDON_BUBBLEWAND
|
|
NULL, // PLAYER_ADDON_JELLYFISHINNET
|
|
NULL, // PLAYER_ADDON_GLOVE
|
|
};
|
|
FileEquate s_addonActorPoolNames[NUM_PLAYER_ADDONS]=
|
|
{
|
|
ACTORS_SPONGEBOB_NET_SBK, // PLAYER_ADDON_NET
|
|
ACTORS_SPONGEBOB_CORALBLOWER_SBK, // PLAYER_ADDON_CORALBLOWER
|
|
ACTORS_SPONGEBOB_JELLYLAUNCHER_SBK, // PLAYER_ADDON_JELLYLAUNCHER
|
|
ACTORS_SPONGEBOB_WAND_SBK, // PLAYER_ADDON_BUBBLEWAND
|
|
ACTORS_SPONGEBOB_JELLYFISH_SBK, // PLAYER_ADDON_JELLYFISHINNET
|
|
ACTORS_SPONGEBOB_GLOVE_SBK, // PLAYER_ADDON_GLOVE
|
|
};
|
|
PLAYER_ADDONS s_addonNumbers[NUM_PLAYERMODES]=
|
|
{
|
|
NO_ADDON, // PLAYER_MODE_BASICUNARMED
|
|
NO_ADDON, // PLAYER_MODE_FULLUNARMED
|
|
NO_ADDON, // PLAYER_MODE_BALLOON
|
|
PLAYER_ADDON_BUBBLEWAND, // PLAYER_MODE_BUBBLE_MIXTURE
|
|
PLAYER_ADDON_NET, // PLAYER_MODE_NET
|
|
PLAYER_ADDON_CORALBLOWER, // PLAYER_MODE_CORALBLOWER
|
|
PLAYER_ADDON_JELLYLAUNCHER, // PLAYER_MODE_JELLY_LAUNCHER
|
|
NO_ADDON, // PLAYER_MODE_DEAD
|
|
NO_ADDON, // PLAYER_MODE_FLY
|
|
NO_ADDON, // PLAYER_MODE_CART
|
|
NO_ADDON, // PLAYER_MODE_SWALLOW
|
|
};
|
|
|
|
s8 s_animMapNet[NUM_PLAYER_ADDONS][NUM_ANIM_SPONGEBOB]=
|
|
{
|
|
// PLAYER_ADDON_NET,
|
|
{
|
|
ANIM_SPONGEBOB_NET_BUTTBOUNCEEND, // ANIM_SPONGEBOB_BUTTBOUNCEEND,
|
|
ANIM_SPONGEBOB_NET_BUTTBOUNCESTART, // ANIM_SPONGEBOB_BUTTBOUNCESTART,
|
|
ANIM_SPONGEBOB_NET_FALL, // ANIM_SPONGEBOB_FALL,
|
|
ANIM_SPONGEBOB_NET_GETUP, // ANIM_SPONGEBOB_GETUP,
|
|
ANIM_SPONGEBOB_NET_HITGROUND, // ANIM_SPONGEBOB_HITGROUND,
|
|
ANIM_SPONGEBOB_NET_IDLEBREATH, // ANIM_SPONGEBOB_IDLEBREATH,
|
|
ANIM_SPONGEBOB_NET_JUMPEND, // ANIM_SPONGEBOB_JUMPEND,
|
|
ANIM_SPONGEBOB_NET_JUMP, // ANIM_SPONGEBOB_JUMP,
|
|
ANIM_SPONGEBOB_NET_RUN, // ANIM_SPONGEBOB_RUN,
|
|
ANIM_SPONGEBOB_NET_RUNSTOP, // ANIM_SPONGEBOB_RUNSTOP,
|
|
ANIM_SPONGEBOB_NET_RUNSTART, // ANIM_SPONGEBOB_RUNSTART,
|
|
ANIM_SPONGEBOB_NET_TEETERBACK, // ANIM_SPONGEBOB_TEETERBACK,
|
|
ANIM_SPONGEBOB_NET_TEETERFRONT, // ANIM_SPONGEBOB_TEETERFRONT,
|
|
ANIM_SPONGEBOB_NET_SWIPE, // ANIM_SPONGEBOB_SWIPE,
|
|
ANIM_SPONGEBOB_NET_DEATHFORWARDS, // ANIM_SPONGEBOB_DEATHFORWARDS,
|
|
ANIM_SPONGEBOB_NET_DEATHSQUASH, // ANIM_SPONGEBOB_DEATHSQUASH,
|
|
-1, // ANIM_SPONGEBOB_DEATHDRY
|
|
-1, // ANIM_SPONGEBOB_BALLOONJUMP,
|
|
-1, // ANIM_SPONGEBOB_BLOWBUBBLE,
|
|
-1, // ANIM_SPONGEBOB_FIREEND,
|
|
-1, // ANIM_SPONGEBOB_FIRESTART,
|
|
ANIM_SPONGEBOB_NET_IDLEWEAPON, // ANIM_SPONGEBOB_IDLEWEAPON,
|
|
-1, // ANIM_SPONGEBOB_WALK,
|
|
-1, // ANIM_SPONGEBOB_KARATE,
|
|
ANIM_SPONGEBOB_NET_GETHIT, // ANIM_SPONGEBOB_GETHIT
|
|
ANIM_SPONGEBOB_NET_CROUCHDOWN, // ANIM_SPONGEBOB_CROUCHDOWN
|
|
ANIM_SPONGEBOB_NET_CROUCHUP, // ANIM_SPONGEBOB_CROUCHUP
|
|
ANIM_SPONGEBOB_NET_LOOKUP, // ANIM_SPONGEBOB_LOOKUP
|
|
-1, // ANIM_SPONGEBOB_IDLEFACEUPSIDEDOWN
|
|
-1, // ANIM_SPONGEBOB_IDLEBANDAID,
|
|
//NOIDLE -1, // ANIM_SPONGEBOB_IDLEINHAT,
|
|
-1, // ANIM_SPONGEBOB_IDLEMATURE,
|
|
-1, // ANIM_SPONGEBOB_IDLEMOUSTACHE,
|
|
-1, // ANIM_SPONGEBOB_IDLENOFACE,
|
|
-1, // ANIM_SPONGEBOB_IDLEZORRO,
|
|
ANIM_SPONGEBOB_NET_CELEBRATE, // ANIM_SPONGEBOB_CELEBRATE,
|
|
},
|
|
|
|
// PLAYER_ADDON_CORALBLOWER,
|
|
{
|
|
-1, // ANIM_SPONGEBOB_BUTTBOUNCEEND,
|
|
-1, // ANIM_SPONGEBOB_BUTTBOUNCESTART,
|
|
ANIM_SPONGEBOB_CORALBLOWER_FALL, // ANIM_SPONGEBOB_FALL,
|
|
ANIM_SPONGEBOB_CORALBLOWER_GETUP, // ANIM_SPONGEBOB_GETUP,
|
|
ANIM_SPONGEBOB_CORALBLOWER_HITGROUND, // ANIM_SPONGEBOB_HITGROUND,
|
|
ANIM_SPONGEBOB_CORALBLOWER_IDLEBREATH, // ANIM_SPONGEBOB_IDLEBREATH,
|
|
ANIM_SPONGEBOB_CORALBLOWER_JUMPEND, // ANIM_SPONGEBOB_JUMPEND,
|
|
ANIM_SPONGEBOB_CORALBLOWER_JUMP, // ANIM_SPONGEBOB_JUMP,
|
|
-1, // ANIM_SPONGEBOB_RUN,
|
|
-1, // ANIM_SPONGEBOB_RUNSTOP,
|
|
-1, // ANIM_SPONGEBOB_RUNSTART,
|
|
ANIM_SPONGEBOB_CORALBLOWER_TEETERBACK, // ANIM_SPONGEBOB_TEETERBACK,
|
|
ANIM_SPONGEBOB_CORALBLOWER_TEETERFRONT, // ANIM_SPONGEBOB_TEETERFRONT,
|
|
-1, // ANIM_SPONGEBOB_SWIPE,
|
|
ANIM_SPONGEBOB_CORALBLOWER_DEATHFORWARDS, // ANIM_SPONGEBOB_DEATHFORWARDS,
|
|
ANIM_SPONGEBOB_CORALBLOWER_DEATHSQUASH, // ANIM_SPONGEBOB_DEATHSQUASH,
|
|
-1, // ANIM_SPONGEBOB_DEATHDRY
|
|
-1, // ANIM_SPONGEBOB_BALLOONJUMP,
|
|
-1, // ANIM_SPONGEBOB_BLOWBUBBLE,
|
|
ANIM_SPONGEBOB_CORALBLOWER_FIREEND, // ANIM_SPONGEBOB_FIREEND,
|
|
ANIM_SPONGEBOB_CORALBLOWER_FIRESTART, // ANIM_SPONGEBOB_FIRESTART,
|
|
ANIM_SPONGEBOB_CORALBLOWER_IDLEWEAPON, // ANIM_SPONGEBOB_IDLEWEAPON,
|
|
ANIM_SPONGEBOB_CORALBLOWER_WALK, // ANIM_SPONGEBOB_WALK,
|
|
-1, // ANIM_SPONGEBOB_KARATE,
|
|
ANIM_SPONGEBOB_CORALBLOWER_GETHIT, // ANIM_SPONGEBOB_GETHIT
|
|
ANIM_SPONGEBOB_CORALBLOWER_CROUCHDOWN, // ANIM_SPONGEBOB_CROUCHDOWN
|
|
ANIM_SPONGEBOB_CORALBLOWER_CROUCHUP, // ANIM_SPONGEBOB_CROUCHUP
|
|
ANIM_SPONGEBOB_CORALBLOWER_LOOKUP, // ANIM_SPONGEBOB_LOOKUP
|
|
-1, // ANIM_SPONGEBOB_IDLEFACEUPSIDEDOWN
|
|
-1, // ANIM_SPONGEBOB_IDLEBANDAID,
|
|
//NOIDLE -1, // ANIM_SPONGEBOB_IDLEINHAT,
|
|
-1, // ANIM_SPONGEBOB_IDLEMATURE,
|
|
-1, // ANIM_SPONGEBOB_IDLEMOUSTACHE,
|
|
-1, // ANIM_SPONGEBOB_IDLENOFACE,
|
|
-1, // ANIM_SPONGEBOB_IDLEZORRO,
|
|
ANIM_SPONGEBOB_CORALBLOWER_CELEBRATE, // ANIM_SPONGEBOB_CELEBRATE,
|
|
},
|
|
|
|
// PLAYER_ADDON_JELLYLAUNCHER,
|
|
{
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_BUTTBOUNCEEND, // ANIM_SPONGEBOB_BUTTBOUNCEEND,
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_BUTTBOUNCESTART, // ANIM_SPONGEBOB_BUTTBOUNCESTART,
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_FALL, // ANIM_SPONGEBOB_FALL,
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_GETUP, // ANIM_SPONGEBOB_GETUP,
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_HITGROUND, // ANIM_SPONGEBOB_HITGROUND,
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_IDLEBREATH, // ANIM_SPONGEBOB_IDLEBREATH,
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_JUMPEND, // ANIM_SPONGEBOB_JUMPEND,
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_JUMP, // ANIM_SPONGEBOB_JUMP,
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_RUN, // ANIM_SPONGEBOB_RUN,
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_RUNSTOP, // ANIM_SPONGEBOB_RUNSTOP,
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_RUNSTART, // ANIM_SPONGEBOB_RUNSTART,
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_TEETERBACK, // ANIM_SPONGEBOB_TEETERBACK,
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_TEETERFRONT, // ANIM_SPONGEBOB_TEETERFRONT,
|
|
-1, // ANIM_SPONGEBOB_SWIPE,
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_DEATHFORWARDS, // ANIM_SPONGEBOB_DEATHFORWARDS,
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_DEATHSQUASH, // ANIM_SPONGEBOB_DEATHSQUASH,
|
|
-1, // ANIM_SPONGEBOB_DEATHDRY
|
|
-1, // ANIM_SPONGEBOB_BALLOONJUMP,
|
|
-1, // ANIM_SPONGEBOB_BLOWBUBBLE,
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_FIREEND, // ANIM_SPONGEBOB_FIREEND,
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_FIRESTART, // ANIM_SPONGEBOB_FIRESTART,
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_IDLEWEAPON, // ANIM_SPONGEBOB_IDLEWEAPON,
|
|
-1, // ANIM_SPONGEBOB_WALK,
|
|
-1, // ANIM_SPONGEBOB_KARATE,
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_GETHIT, // ANIM_SPONGEBOB_GETHIT
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_CROUCHDOWN, // ANIM_SPONGEBOB_CROUCHDOWN
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_CROUCHUP, // ANIM_SPONGEBOB_CROUCHUP
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_LOOKUP, // ANIM_SPONGEBOB_LOOKUP
|
|
-1, // ANIM_SPONGEBOB_IDLEFACEUPSIDEDOWN
|
|
-1, // ANIM_SPONGEBOB_IDLEBANDAID,
|
|
//NOIDLE -1, // ANIM_SPONGEBOB_IDLEINHAT,
|
|
-1, // ANIM_SPONGEBOB_IDLEMATURE,
|
|
-1, // ANIM_SPONGEBOB_IDLEMOUSTACHE,
|
|
-1, // ANIM_SPONGEBOB_IDLENOFACE,
|
|
-1, // ANIM_SPONGEBOB_IDLEZORRO,
|
|
ANIM_SPONGEBOB_JELLYLAUNCHER_CELEBRATE, // ANIM_SPONGEBOB_CELEBRATE,
|
|
},
|
|
|
|
// PLAYER_ADDON_BUBBLEWAND,
|
|
{
|
|
ANIM_SPONGEBOB_WAND_BUTTBOUNCEEND, // ANIM_SPONGEBOB_BUTTBOUNCEEND,
|
|
ANIM_SPONGEBOB_WAND_BUTTBOUNCESTART, // ANIM_SPONGEBOB_BUTTBOUNCESTART,
|
|
ANIM_SPONGEBOB_WAND_FALL, // ANIM_SPONGEBOB_FALL,
|
|
ANIM_SPONGEBOB_WAND_GETUP, // ANIM_SPONGEBOB_GETUP,
|
|
ANIM_SPONGEBOB_WAND_HITGROUND, // ANIM_SPONGEBOB_HITGROUND,
|
|
ANIM_SPONGEBOB_WAND_IDLEBREATH, // ANIM_SPONGEBOB_IDLEBREATH,
|
|
ANIM_SPONGEBOB_WAND_JUMPEND, // ANIM_SPONGEBOB_JUMPEND,
|
|
ANIM_SPONGEBOB_WAND_JUMP, // ANIM_SPONGEBOB_JUMP,
|
|
ANIM_SPONGEBOB_WAND_RUN, // ANIM_SPONGEBOB_RUN,
|
|
ANIM_SPONGEBOB_WAND_RUNSTOP, // ANIM_SPONGEBOB_RUNSTOP,
|
|
ANIM_SPONGEBOB_WAND_RUNSTART, // ANIM_SPONGEBOB_RUNSTART,
|
|
ANIM_SPONGEBOB_WAND_TEETERBACK, // ANIM_SPONGEBOB_TEETERBACK,
|
|
ANIM_SPONGEBOB_WAND_TEETERFRONT, // ANIM_SPONGEBOB_TEETERFRONT,
|
|
-1, // ANIM_SPONGEBOB_SWIPE,
|
|
ANIM_SPONGEBOB_WAND_DEATHFORWARDS, // ANIM_SPONGEBOB_DEATHFORWARDS,
|
|
ANIM_SPONGEBOB_WAND_DEATHSQUASH, // ANIM_SPONGEBOB_DEATHSQUASH,
|
|
-1, // ANIM_SPONGEBOB_DEATHDRY
|
|
-1, // ANIM_SPONGEBOB_BALLOONJUMP,
|
|
ANIM_SPONGEBOB_WAND_BLOWBUBBLE, // ANIM_SPONGEBOB_BLOWBUBBLE,
|
|
-1, // ANIM_SPONGEBOB_FIREEND,
|
|
-1, // ANIM_SPONGEBOB_FIRESTART,
|
|
ANIM_SPONGEBOB_WAND_IDLEWEAPON, // ANIM_SPONGEBOB_IDLEWEAPON,
|
|
-1, // ANIM_SPONGEBOB_WALK,
|
|
-1, // ANIM_SPONGEBOB_KARATE,
|
|
ANIM_SPONGEBOB_WAND_GETHIT, // ANIM_SPONGEBOB_GETHIT
|
|
ANIM_SPONGEBOB_WAND_CROUCHDOWN, // ANIM_SPONGEBOB_CROUCHDOWN
|
|
ANIM_SPONGEBOB_WAND_CROUCHUP, // ANIM_SPONGEBOB_CROUCHUP
|
|
ANIM_SPONGEBOB_WAND_LOOKUP, // ANIM_SPONGEBOB_LOOKUP
|
|
-1, // ANIM_SPONGEBOB_IDLEFACEUPSIDEDOWN
|
|
-1, // ANIM_SPONGEBOB_IDLEBANDAID,
|
|
//NOIDLE -1, // ANIM_SPONGEBOB_IDLEINHAT,
|
|
-1, // ANIM_SPONGEBOB_IDLEMATURE,
|
|
-1, // ANIM_SPONGEBOB_IDLEMOUSTACHE,
|
|
-1, // ANIM_SPONGEBOB_IDLENOFACE,
|
|
-1, // ANIM_SPONGEBOB_IDLEZORRO,
|
|
ANIM_SPONGEBOB_WAND_CELEBRATE, // ANIM_SPONGEBOB_CELEBRATE,
|
|
},
|
|
|
|
// PLAYER_ADDON_JELLYFISHINNET
|
|
{
|
|
ANIM_SPONGEBOB_JELLYFISH_BUTTBOUNCEEND, // ANIM_SPONGEBOB_BUTTBOUNCEEND,
|
|
ANIM_SPONGEBOB_JELLYFISH_BUTTBOUNCESTART, // ANIM_SPONGEBOB_BUTTBOUNCESTART,
|
|
ANIM_SPONGEBOB_JELLYFISH_FALL, // ANIM_SPONGEBOB_FALL,
|
|
ANIM_SPONGEBOB_JELLYFISH_GETUP, // ANIM_SPONGEBOB_GETUP,
|
|
ANIM_SPONGEBOB_JELLYFISH_HITGROUND, // ANIM_SPONGEBOB_HITGROUND,
|
|
ANIM_SPONGEBOB_JELLYFISH_IDLEBREATH, // ANIM_SPONGEBOB_IDLEBREATH,
|
|
ANIM_SPONGEBOB_JELLYFISH_JUMPEND, // ANIM_SPONGEBOB_JUMPEND,
|
|
ANIM_SPONGEBOB_JELLYFISH_JUMP, // ANIM_SPONGEBOB_JUMP,
|
|
ANIM_SPONGEBOB_JELLYFISH_RUN, // ANIM_SPONGEBOB_RUN,
|
|
ANIM_SPONGEBOB_JELLYFISH_RUNSTOP, // ANIM_SPONGEBOB_RUNSTOP,
|
|
ANIM_SPONGEBOB_JELLYFISH_RUNSTART, // ANIM_SPONGEBOB_RUNSTART,
|
|
ANIM_SPONGEBOB_JELLYFISH_TEETERBACK, // ANIM_SPONGEBOB_TEETERBACK,
|
|
ANIM_SPONGEBOB_JELLYFISH_TEETERFRONT, // ANIM_SPONGEBOB_TEETERFRONT,
|
|
ANIM_SPONGEBOB_JELLYFISH_SWIPE, // ANIM_SPONGEBOB_SWIPE,
|
|
ANIM_SPONGEBOB_JELLYFISH_DEATHFORWARDS, // ANIM_SPONGEBOB_DEATHFORWARDS,
|
|
ANIM_SPONGEBOB_JELLYFISH_DEATHSQUASH, // ANIM_SPONGEBOB_DEATHSQUASH,
|
|
-1, // ANIM_SPONGEBOB_DEATHDRY
|
|
-1, // ANIM_SPONGEBOB_BALLOONJUMP,
|
|
-1, // ANIM_SPONGEBOB_BLOWBUBBLE,
|
|
-1, // ANIM_SPONGEBOB_FIREEND,
|
|
-1, // ANIM_SPONGEBOB_FIRESTART,
|
|
ANIM_SPONGEBOB_JELLYFISH_IDLEWEAPON, // ANIM_SPONGEBOB_IDLEWEAPON,
|
|
-1, // ANIM_SPONGEBOB_WALK,
|
|
-1, // ANIM_SPONGEBOB_KARATE,
|
|
ANIM_SPONGEBOB_JELLYFISH_GETHIT, // ANIM_SPONGEBOB_GETHIT
|
|
ANIM_SPONGEBOB_JELLYFISH_CROUCHDOWN, // ANIM_SPONGEBOB_CROUCHDOWN
|
|
ANIM_SPONGEBOB_JELLYFISH_CROUCHUP, // ANIM_SPONGEBOB_CROUCHUP
|
|
ANIM_SPONGEBOB_JELLYFISH_LOOKUP, // ANIM_SPONGEBOB_LOOKUP
|
|
-1, // ANIM_SPONGEBOB_IDLEFACEUPSIDEDOWN
|
|
-1, // ANIM_SPONGEBOB_IDLEBANDAID,
|
|
//NOIDLE -1, // ANIM_SPONGEBOB_IDLEINHAT,
|
|
-1, // ANIM_SPONGEBOB_IDLEMATURE,
|
|
-1, // ANIM_SPONGEBOB_IDLEMOUSTACHE,
|
|
-1, // ANIM_SPONGEBOB_IDLENOFACE,
|
|
-1, // ANIM_SPONGEBOB_IDLEZORRO,
|
|
ANIM_SPONGEBOB_JELLYFISH_CELEBRATE, // ANIM_SPONGEBOB_CELEBRATE,
|
|
},
|
|
|
|
// PLAYER_ADDON_GLOVE
|
|
{
|
|
-1, // ANIM_SPONGEBOB_BUTTBOUNCEEND,
|
|
-1, // ANIM_SPONGEBOB_BUTTBOUNCESTART,
|
|
-1, // ANIM_SPONGEBOB_FALL,
|
|
-1, // ANIM_SPONGEBOB_GETUP,
|
|
-1, // ANIM_SPONGEBOB_HITGROUND,
|
|
-1, // ANIM_SPONGEBOB_IDLEBREATH,
|
|
-1, // ANIM_SPONGEBOB_JUMPEND,
|
|
-1, // ANIM_SPONGEBOB_JUMP,
|
|
-1, // ANIM_SPONGEBOB_RUN,
|
|
-1, // ANIM_SPONGEBOB_RUNSTOP,
|
|
-1, // ANIM_SPONGEBOB_RUNSTART,
|
|
-1, // ANIM_SPONGEBOB_TEETERBACK,
|
|
-1, // ANIM_SPONGEBOB_TEETERFRONT,
|
|
-1, // ANIM_SPONGEBOB_SWIPE,
|
|
-1, // ANIM_SPONGEBOB_DEATHFORWARDS,
|
|
-1, // ANIM_SPONGEBOB_DEATHSQUASH,
|
|
-1, // ANIM_SPONGEBOB_DEATHDRY
|
|
-1, // ANIM_SPONGEBOB_BALLOONJUMP,
|
|
-1, // ANIM_SPONGEBOB_BLOWBUBBLE,
|
|
-1, // ANIM_SPONGEBOB_FIREEND,
|
|
-1, // ANIM_SPONGEBOB_FIRESTART,
|
|
-1, // ANIM_SPONGEBOB_IDLEWEAPON,
|
|
-1, // ANIM_SPONGEBOB_WALK,
|
|
ANIM_SPONGEBOB_GLOVE_KARATE, // ANIM_SPONGEBOB_KARATE,
|
|
-1, // ANIM_SPONGEBOB_GETHIT
|
|
-1, // ANIM_SPONGEBOB_CROUCHDOWN
|
|
-1, // ANIM_SPONGEBOB_CROUCHUP
|
|
-1, // ANIM_SPONGEBOB_LOOKUP
|
|
-1, // ANIM_SPONGEBOB_IDLEFACEUPSIDEDOWN
|
|
-1, // ANIM_SPONGEBOB_IDLEBANDAID,
|
|
//NOIDLE -1, // ANIM_SPONGEBOB_IDLEINHAT,
|
|
-1, // ANIM_SPONGEBOB_IDLEMATURE,
|
|
-1, // ANIM_SPONGEBOB_IDLEMOUSTACHE,
|
|
-1, // ANIM_SPONGEBOB_IDLENOFACE,
|
|
-1, // ANIM_SPONGEBOB_IDLEZORRO,
|
|
-1, // ANIM_SPONGEBOB_CELEBRATE,
|
|
},
|
|
};
|
|
|
|
// -------------------------------------------------------------------------------
|
|
|
|
|
|
int m_cameraXScrollDir;
|
|
int m_cameraXScrollPos;
|
|
int CAMERA_SCROLLLIMIT=8; // SB is this many tiles off centre at most
|
|
int CAMERA_SCROLLTHRESHOLD=0; // (pkg 17/7) // If SB moves when more than this many tiles off-centre, the camera will *always* scroll
|
|
int CAMERA_STARTMOVETHRESHOLD=0; // (pkg 17/7) // If SB moves faster than this then the camera starts scrolling
|
|
int CAMERA_STOPMOVETHRESHOLD=0; // (pkg 17/7) // If SB moves slower than this then the camera stops scrolling
|
|
int CAMERA_SCROLLSPEED=1000; // Speed of the scroll
|
|
int CAMERA_ACCURACYSHIFT=8;
|
|
const int CAMERA_TILESIZE=16;
|
|
|
|
// Well, there goes any chance of refined camera control for the player! :( ( pkg 17/7 )
|
|
|
|
|
|
int m_isFalling;
|
|
int m_fallFrames;
|
|
int m_cameraFallYScrollPos;
|
|
int m_cameraFallYScrollSpeed;
|
|
int CAMERA_FALL_DROP_SPEED=6;
|
|
int CAMERA_FALL_MAX_OFFSET=5*16;
|
|
int CAMERA_FALL_FRAME_THRESHOLD=20;
|
|
int CAMERA_FALL_RETURN_SPEED=1;
|
|
|
|
|
|
|
|
|
|
#ifdef CAM_X_AUTO_CENTERING
|
|
int returnspeed=1500;
|
|
int returntimeout=25;
|
|
int returntimeoutcount=0;
|
|
int returnsafespace=4*16;
|
|
#endif
|
|
|
|
|
|
extern int checkx;
|
|
extern int checky;
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::init()
|
|
{
|
|
int i;
|
|
|
|
CPlayerThing::init();
|
|
|
|
m_fontBank=new ("PlayerFont") FontBank();
|
|
m_fontBank->initialise(&standardFont);
|
|
m_fontBank->setOt(POWERUPUI_OT);
|
|
|
|
m_scalableFontBank=new ("PlayerFont") ScalableFontBank();
|
|
m_scalableFontBank->initialise(&standardFont);
|
|
m_scalableFontBank->setOt(POWERUPUI_OT);
|
|
|
|
m_actorGfx=CActorPool::GetActor(ACTORS_SPONGEBOB_SBK);
|
|
|
|
for(i=0;i<NUM_PLAYERMODES;i++)
|
|
{
|
|
s_playerModes[i]->initialise(this);
|
|
}
|
|
|
|
m_animNo=0;
|
|
m_animFrame=0;
|
|
setFacing(FACING_RIGHT);
|
|
m_currentPlayerModeClass=NULL;
|
|
m_lastModeBeforeDeath=PLAYER_MODE_BASICUNARMED; // Player will then respawn into this mode
|
|
respawn();
|
|
|
|
m_lastPadInput=m_padInput=PI_NONE;
|
|
|
|
setCartCam(false);
|
|
setReverseCameraMovement(false);
|
|
|
|
resetPlayerCollisionSizeToBase();
|
|
|
|
m_divingHelmet=false;
|
|
setIsInWater(true);
|
|
|
|
#ifdef __USER_paul__
|
|
/*
|
|
registerAddon(PLAYER_ADDON_GLOVE);
|
|
registerAddon(PLAYER_ADDON_NET);
|
|
registerAddon(PLAYER_ADDON_CORALBLOWER);
|
|
registerAddon(PLAYER_ADDON_JELLYLAUNCHER);
|
|
registerAddon(PLAYER_ADDON_BUBBLEWAND);
|
|
registerAddon(PLAYER_ADDON_JELLYFISHINNET);
|
|
*/
|
|
#endif
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::shutdown()
|
|
{
|
|
int i;
|
|
|
|
for(i=0;i<NUM_PLAYERMODES;i++)
|
|
{
|
|
s_playerModes[i]->shutdown();
|
|
}
|
|
|
|
for(i=0;i<NUM_PLAYER_ADDONS;i++)
|
|
{
|
|
if(s_addonActorGfx[i])
|
|
{
|
|
delete s_addonActorGfx[i];
|
|
s_addonActorGfx[i]=NULL;
|
|
}
|
|
}
|
|
delete m_actorGfx;
|
|
|
|
m_scalableFontBank->dump(); delete m_scalableFontBank;
|
|
m_fontBank->dump(); delete m_fontBank;
|
|
|
|
CPlayerThing::shutdown();
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
static int oldmode=-1;
|
|
int newmode=-1;
|
|
void CPlayer::think(int _frames)
|
|
{
|
|
int i;
|
|
|
|
#ifdef __USER_daveo__
|
|
if(PadGetDown(0)&PAD_R1)
|
|
{
|
|
TestFX(getPos(),this);
|
|
}
|
|
#endif
|
|
|
|
|
|
if(PadGetDown(0)&PAD_L1&&m_currentMode!=PLAYER_MODE_DEAD)
|
|
{
|
|
oldmode=m_currentMode;
|
|
newmode=PLAYER_MODE_FLY;
|
|
}
|
|
else if(oldmode!=-1&&!(PadGetHeld(0)&PAD_L1))
|
|
{
|
|
newmode=oldmode;
|
|
oldmode=-1;
|
|
}
|
|
|
|
if(newmode!=-1)
|
|
{
|
|
setMode((PLAYER_MODE)newmode);
|
|
newmode=-1;
|
|
}
|
|
|
|
CThing *platform;
|
|
platform=isOnPlatform();
|
|
if(platform)
|
|
{
|
|
if ( ( (CNpcPlatform *) platform )->isCart() )
|
|
{
|
|
if ( m_currentMode != PLAYER_MODE_CART && m_currentMode != PLAYER_MODE_DEAD )
|
|
{
|
|
setMode( PLAYER_MODE_CART );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DVECTOR posDelta;
|
|
posDelta=platform->getPosDelta();
|
|
posDelta.vy = 0;
|
|
shove(posDelta);
|
|
|
|
int platformOffset = ( ( CNpcPlatform* ) platform )->getHeightFromPlatformAtPosition( Pos.vx, Pos.vy );
|
|
int height=CGameScene::getCollision()->getHeightFromGround(Pos.vx,Pos.vy,16);
|
|
|
|
if ( platformOffset < height )
|
|
{
|
|
Pos.vy += platformOffset;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
m_allowConversation=false;
|
|
|
|
m_xMove = Pos.vx;
|
|
|
|
///
|
|
#ifdef __USER_paul__
|
|
//if(PadGetDown(0)&PAD_TRIANGLE)
|
|
//{
|
|
// addLife();
|
|
//}
|
|
#endif
|
|
///
|
|
|
|
|
|
// Pending teleport?
|
|
if(m_teleportPending)
|
|
{
|
|
processTeleportToCommand();
|
|
}
|
|
|
|
|
|
for(i=0;i<_frames;i++)
|
|
{
|
|
updatePadInput();
|
|
|
|
|
|
// Only do the weapon change stuff on the first frame. As the buttons pressed do not
|
|
// change over these frames there is no point in doing it every frame
|
|
if(i==0&&m_currentPlayerModeClass->getState()!=STATE_CELEBRATE)
|
|
{
|
|
m_tryingToManuallyPickupWeapon=false;
|
|
m_tryingToAutomaticallyPickupWeapon=false;
|
|
|
|
// Weapon collect/drop/swap stuff..
|
|
if(m_currentMode==PLAYER_MODE_BASICUNARMED)
|
|
{
|
|
// Always trying to pick up weapon if unarmed... means that when SB walks
|
|
// over an item whilst unarmed, he automatically picks it up
|
|
m_tryingToAutomaticallyPickupWeapon=true;
|
|
}
|
|
if(m_currentMode!=PLAYER_MODE_CART && getPadInputDown()&PI_WEAPONCHANGE)
|
|
{
|
|
// If already armed then drop current weapon
|
|
if(m_currentMode!=PLAYER_MODE_BASICUNARMED&&
|
|
m_currentMode!=PLAYER_MODE_DEAD)
|
|
{
|
|
static const int s_pickupsToDrop[NUM_PLAYERMODES]=
|
|
{
|
|
-1, // PLAYER_MODE_BASICUNARMED
|
|
-1, // PLAYER_MODE_FULLUNARMED
|
|
-1, // PLAYER_MODE_BALLOON
|
|
PICKUP__BUBBLE_WAND, // PLAYER_MODE_BUBBLE_MIXTURE
|
|
PICKUP__NET, // PLAYER_MODE_NET
|
|
PICKUP__CORAL_BLOWER, // PLAYER_MODE_CORALBLOWER
|
|
PICKUP__JELLY_LAUNCHER, // PLAYER_MODE_JELLY_LAUNCHER
|
|
-1, // PLAYER_MODE_DEAD
|
|
-1, // PLAYER_MODE_FLY
|
|
-1, // PLAYER_MODE_CART
|
|
-1, // PLAYER_MODE_SWALLOW
|
|
};
|
|
|
|
int pickupToDrop;
|
|
pickupToDrop=s_pickupsToDrop[m_currentMode];
|
|
if(pickupToDrop!=-1)
|
|
{
|
|
DVECTOR pickupPos;
|
|
CBasePickup *pickup;
|
|
pickupPos.vx=Pos.vx;
|
|
pickupPos.vy=Pos.vy-30;
|
|
pickup=createPickup((PICKUP_TYPE)pickupToDrop,&pickupPos);
|
|
pickup->setPos(&pickupPos);
|
|
((CBaseWeaponPickup*)pickup)->setHasBeenCollected();
|
|
}
|
|
setMode(PLAYER_MODE_BASICUNARMED);
|
|
}
|
|
|
|
// Now trying to pick up a weapon..
|
|
m_tryingToManuallyPickupWeapon=true;
|
|
}
|
|
}
|
|
|
|
int level=GameScene.getLevelNumber();
|
|
// Out of spats?
|
|
if(m_numSpatulasHeld==0 && level!=5)
|
|
{
|
|
int oldTimer=m_spatulaWarningTimer;
|
|
m_spatulaWarningTimer++;
|
|
if((m_spatulaWarningTimer&64)!=(oldTimer&64))
|
|
{
|
|
CSoundMediator::playSfx(CSoundMediator::SFX_BEEP10);
|
|
}
|
|
}
|
|
|
|
// Trying to converate?
|
|
if(m_allowConversation==false&&
|
|
m_currentPlayerModeClass->canConverse()&&
|
|
getPadInputDown()&PI_UP)
|
|
{
|
|
m_allowConversation=true;
|
|
}
|
|
|
|
// Think for the current player mode
|
|
int oldBlock;
|
|
DVECTOR oldPos;
|
|
oldBlock=CGameScene::getCollision()->getCollisionBlock(Pos.vx,Pos.vy)&COLLISION_TYPE_MASK;
|
|
oldPos=Pos;
|
|
m_currentPlayerModeClass->think();
|
|
if(oldBlock==COLLISION_TYPE_FLAG_DESTRUCTABLE_FLOOR&&
|
|
(Pos.vx>>4!=oldPos.vx>>4||Pos.vy>>4!=oldPos.vy>>4))
|
|
{
|
|
GameScene.GetLevel().destroyMapTile(oldPos);
|
|
}
|
|
|
|
|
|
// Is player stood on any special collision?
|
|
for(int j=0;j<2;j++)
|
|
{
|
|
int x=Pos.vx+((j==0)?-checkx:+checkx);
|
|
if(getHeightFromGroundNoPlatform(x,Pos.vy,5)==0)
|
|
{
|
|
int block;
|
|
block=CGameScene::getCollision()->getCollisionBlock(x,Pos.vy)&COLLISION_TYPE_MASK;
|
|
|
|
// Conveyor belt movement
|
|
if(block==COLLISION_TYPE_FLAG_MOVE_LEFT)
|
|
{
|
|
moveHorizontal(-1);
|
|
break;
|
|
}
|
|
else if(block==COLLISION_TYPE_FLAG_MOVE_RIGHT)
|
|
{
|
|
moveHorizontal(+1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Powerups
|
|
if(m_squeakyBootsTimer)
|
|
{
|
|
m_squeakyBootsTimer--;
|
|
}
|
|
if(m_invincibilityRingTimer)
|
|
{
|
|
m_invincibilityRingTimer--;
|
|
}
|
|
|
|
// Flashing..
|
|
if(m_invincibleFrameCount)
|
|
{
|
|
m_invincibleFrameCount--;
|
|
}
|
|
|
|
// Camera scroll..
|
|
if(m_cartCamActive)
|
|
{
|
|
// Just force the cam eo think we are running right so that the cam
|
|
// is always in the right place when in a cart
|
|
m_cameraXScrollDir=-1;
|
|
}
|
|
if(m_cameraXScrollDir==-1)
|
|
{
|
|
if(m_cameraXScrollPos>-(CAMERA_SCROLLLIMIT*CAMERA_TILESIZE)<<CAMERA_ACCURACYSHIFT)
|
|
{
|
|
m_cameraXScrollPos-=CAMERA_SCROLLSPEED;
|
|
if(m_cameraXScrollPos<-(CAMERA_SCROLLLIMIT*CAMERA_TILESIZE)<<CAMERA_ACCURACYSHIFT)
|
|
{
|
|
m_cameraXScrollPos=-(CAMERA_SCROLLLIMIT*CAMERA_TILESIZE)<<CAMERA_ACCURACYSHIFT;
|
|
m_cameraXScrollDir=0;
|
|
}
|
|
}
|
|
#ifdef CAM_X_AUTO_CENTERING
|
|
returntimeoutcount=0;
|
|
#endif
|
|
}
|
|
else if(m_cameraXScrollDir==+1)
|
|
{
|
|
if(m_cameraXScrollPos<((CAMERA_SCROLLLIMIT*CAMERA_TILESIZE)<<CAMERA_ACCURACYSHIFT))
|
|
{
|
|
m_cameraXScrollPos+=CAMERA_SCROLLSPEED;
|
|
if(m_cameraXScrollPos>(CAMERA_SCROLLLIMIT*CAMERA_TILESIZE)<<CAMERA_ACCURACYSHIFT)
|
|
{
|
|
m_cameraXScrollPos=(CAMERA_SCROLLLIMIT*CAMERA_TILESIZE)<<CAMERA_ACCURACYSHIFT;
|
|
m_cameraXScrollDir=0;
|
|
}
|
|
}
|
|
#ifdef CAM_X_AUTO_CENTERING
|
|
returntimeoutcount=0;
|
|
#endif
|
|
}
|
|
|
|
#ifdef CAM_X_AUTO_CENTERING
|
|
if(m_moveVelocity.vx==0)
|
|
{
|
|
m_cameraXScrollDir=0;
|
|
if(m_cameraXScrollPos<-returnsafespace||m_cameraXScrollPos>returnsafespace)
|
|
{
|
|
if(returntimeoutcount<returntimeout)
|
|
{
|
|
returntimeoutcount++;
|
|
}
|
|
else
|
|
{
|
|
if(m_cameraXScrollPos<0)
|
|
{
|
|
m_cameraXScrollPos+=returnspeed;
|
|
if(m_cameraXScrollPos>0)
|
|
{
|
|
m_cameraXScrollPos=0;
|
|
}
|
|
}
|
|
else if(m_cameraXScrollPos>0)
|
|
{
|
|
m_cameraXScrollPos-=returnspeed;
|
|
if(m_cameraXScrollPos<0)
|
|
{
|
|
m_cameraXScrollPos=0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Stop the player vanishing off the edge of the telly..
|
|
if(!m_lockCamera)
|
|
{
|
|
if(Pos.vx<m_playerPosLimitBox.x1) Pos.vx=m_playerPosLimitBox.x1;
|
|
else if(Pos.vx>m_playerPosLimitBox.x2) Pos.vx=m_playerPosLimitBox.x2;
|
|
if(Pos.vy<m_playerPosLimitBox.y1) Pos.vy=m_playerPosLimitBox.y1;
|
|
else if(Pos.vy>m_playerPosLimitBox.y2) Pos.vy=m_playerPosLimitBox.y2;
|
|
}
|
|
|
|
// Falling camera lag
|
|
if(m_isFalling)
|
|
{
|
|
if(m_fallFrames>CAMERA_FALL_FRAME_THRESHOLD)
|
|
{
|
|
if(m_cameraFallYScrollSpeed<CAMERA_FALL_DROP_SPEED)
|
|
{
|
|
m_cameraFallYScrollSpeed++;
|
|
}
|
|
m_cameraFallYScrollPos-=m_cameraFallYScrollSpeed;
|
|
if(m_cameraFallYScrollPos<-CAMERA_FALL_MAX_OFFSET)
|
|
{
|
|
m_cameraFallYScrollPos=-CAMERA_FALL_MAX_OFFSET;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_fallFrames++;
|
|
}
|
|
m_isFalling=false;
|
|
}
|
|
else
|
|
{
|
|
if(m_cameraFallYScrollPos)
|
|
{
|
|
m_cameraFallYScrollPos+=CAMERA_FALL_RETURN_SPEED;
|
|
if(m_cameraFallYScrollPos>0)
|
|
{
|
|
m_cameraFallYScrollPos=0;
|
|
}
|
|
}
|
|
m_fallFrames=0;
|
|
m_cameraFallYScrollSpeed=0;
|
|
}
|
|
|
|
// Look around
|
|
int pad=getPadInputHeld();
|
|
if(pad&PI_UP&&canDoLookAround())
|
|
{
|
|
if(m_padLookAroundTimer>0)
|
|
{
|
|
m_padLookAroundTimer=0;
|
|
}
|
|
else if(m_padLookAroundTimer>-looktimeout)
|
|
{
|
|
m_padLookAroundTimer--;
|
|
}
|
|
else if(m_cameraLookOffset>-lookmaxoffsetup)
|
|
{
|
|
m_cameraLookOffset-=lookspeed;
|
|
if(m_cameraLookOffset<-lookmaxoffsetup)
|
|
{
|
|
m_cameraLookOffset=-lookmaxoffsetup;
|
|
}
|
|
}
|
|
}
|
|
else if(pad&PI_DOWN&&canDoLookAround())
|
|
{
|
|
if(m_padLookAroundTimer<0)
|
|
{
|
|
m_padLookAroundTimer=0;
|
|
}
|
|
else if(m_padLookAroundTimer<looktimeout)
|
|
{
|
|
m_padLookAroundTimer++;
|
|
}
|
|
else if(m_cameraLookOffset<lookmaxoffsetdown)
|
|
{
|
|
m_cameraLookOffset+=lookspeed;
|
|
if(m_cameraLookOffset>lookmaxoffsetdown)
|
|
{
|
|
m_cameraLookOffset=lookmaxoffsetdown;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_padLookAroundTimer=0;
|
|
}
|
|
|
|
// Return to centre
|
|
if(m_padLookAroundTimer==0&&m_cameraLookOffset<0)
|
|
{
|
|
m_cameraLookOffset+=lookreturnspeed;
|
|
if(m_cameraLookOffset>0)
|
|
{
|
|
m_cameraLookOffset=0;
|
|
}
|
|
}
|
|
if(m_padLookAroundTimer==0&&m_cameraLookOffset>0)
|
|
{
|
|
m_cameraLookOffset-=lookreturnspeed;
|
|
if(m_cameraLookOffset<0)
|
|
{
|
|
m_cameraLookOffset=0;
|
|
}
|
|
}
|
|
|
|
// Automatic anim sfx
|
|
playAnimFrameSfx(m_animNo,m_animFrame);
|
|
}
|
|
|
|
m_xMove = Pos.vx - m_xMove;
|
|
|
|
ASSERT(!(getIsInWater()==false&&isWearingDivingHelmet()==false));
|
|
if(isWearingDivingHelmet())
|
|
{
|
|
if(getIsInWater()==false&&m_currentMode!=PLAYER_MODE_DEAD&&m_currentMode!=PLAYER_MODE_FLY)
|
|
{
|
|
// Out of water and wearing helmet!
|
|
|
|
// Drain water/health
|
|
int oldLevel=m_healthWaterLevel/WATER_COUNTER_SECONDTIME;
|
|
m_healthWaterLevel-=waterDrainSpeed*_frames;
|
|
if(oldLevel<=6&&oldLevel>m_healthWaterLevel/WATER_COUNTER_SECONDTIME)
|
|
{
|
|
CSoundMediator::playSfx(CSoundMediator::SFX_BEEP5);
|
|
}
|
|
if(m_healthWaterLevel<=0)
|
|
{
|
|
dieYouPorousFreak(DEATHTYPE__DRYUP);
|
|
CSoundMediator::playSfx(CSoundMediator::SFX_BEEP5);
|
|
}
|
|
|
|
// Breath sound
|
|
m_helmetSoundTimer+=_frames;
|
|
if(m_helmetSoundTimer>150+(m_healthWaterLevel>>WATERLEVELSHIFT))
|
|
{
|
|
CSoundMediator::playSfx(CSoundMediator::SFX_SPONGEBOB_DIVING_HELMET);
|
|
m_helmetSoundTimer=0;
|
|
}
|
|
}
|
|
else if(getIsInWater())
|
|
{
|
|
// Back in water - fill up helmet! :)
|
|
m_healthWaterLevel+=waterSoakUpSpeed;
|
|
if(m_healthWaterLevel>WATERMAXHEALTH)
|
|
{
|
|
m_healthWaterLevel=WATERMAXHEALTH;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Ledge look-ahead stuff
|
|
if(m_ledgeLookAhead)
|
|
{
|
|
if(m_ledgeLookTimer<ledgeTimer)
|
|
{
|
|
m_ledgeLookTimer+=_frames;
|
|
}
|
|
else
|
|
{
|
|
int limit;
|
|
limit=(m_ledgeLookAhead*MAP2D_BLOCKSTEPSIZE)<<ledgeShift;
|
|
if(m_ledgeLookOffset<limit)
|
|
{
|
|
// Look down
|
|
m_ledgeLookOffset+=ledgeSpeedIn*_frames;
|
|
if(m_ledgeLookOffset>limit)
|
|
{
|
|
m_ledgeLookOffset=limit;
|
|
}
|
|
}
|
|
else if(m_ledgeLookOffset>limit)
|
|
{
|
|
// Look up
|
|
m_ledgeLookOffset-=ledgeSpeedIn*_frames;
|
|
if(m_ledgeLookOffset<limit)
|
|
{
|
|
m_ledgeLookOffset=limit;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(m_ledgeLookOffset>0)
|
|
{
|
|
// Relax from look down
|
|
m_ledgeLookOffset-=ledgeSpeedOut*_frames;
|
|
if(m_ledgeLookOffset<=0)
|
|
{
|
|
m_ledgeLookOffset=0;
|
|
m_ledgeLookTimer=0;
|
|
}
|
|
}
|
|
else if(m_ledgeLookOffset<0)
|
|
{
|
|
// Relax from look up
|
|
m_ledgeLookOffset+=ledgeSpeedOut*_frames;
|
|
if(m_ledgeLookOffset>=0)
|
|
{
|
|
m_ledgeLookOffset=0;
|
|
m_ledgeLookTimer=0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Camera focus point stuff
|
|
calcCameraFocusPointTarget();
|
|
for(i=0;i<_frames;i++)
|
|
{
|
|
m_currentCamFocusPoint.vx+=(m_currentCamFocusPointTarget.vx-m_currentCamFocusPoint.vx)>>cammove;
|
|
m_currentCamFocusPoint.vy+=(m_currentCamFocusPointTarget.vy-m_currentCamFocusPoint.vy)>>cammove;
|
|
}
|
|
|
|
// Final camera position
|
|
int yoff;
|
|
yoff=m_cameraLookOffset+(m_ledgeLookOffset>>ledgeShift);
|
|
if(yoff<-lookmaxoffsetup)yoff=-lookmaxoffsetup;
|
|
else if(yoff>lookmaxoffsetdown)yoff=lookmaxoffsetdown;
|
|
if(!m_lockCamera)
|
|
{
|
|
m_cameraPos.vx=m_currentCamFocusPoint.vx;
|
|
m_cameraPos.vy=m_currentCamFocusPoint.vy+yoff;
|
|
CGameScene::shakeCamera(m_cameraPos);
|
|
}
|
|
|
|
// Limit camera scroll to the edges of the map
|
|
if(m_cameraPos.vx<m_cameraPosLimitBox.x1) m_cameraPos.vx=m_cameraPosLimitBox.x1;
|
|
else if(m_cameraPos.vx>m_cameraPosLimitBox.x2) m_cameraPos.vx=m_cameraPosLimitBox.x2;
|
|
if(m_cameraPos.vy<m_cameraPosLimitBox.y1) m_cameraPos.vy=m_cameraPosLimitBox.y1;
|
|
else if(m_cameraPos.vy>m_cameraPosLimitBox.y2) m_cameraPos.vy=m_cameraPosLimitBox.y2;
|
|
|
|
m_ignoreNewlyPressedButtonsOnPadThisThink=false;
|
|
|
|
// Restore flipped camera
|
|
setReverseCameraMovement(false);
|
|
|
|
// flashing pants..
|
|
if(m_pantFlashTimer)
|
|
{
|
|
m_pantFlashTimer-=_frames;
|
|
}
|
|
|
|
CPlayerThing::think(_frames);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::detectHazardousSurface()
|
|
{
|
|
// DOn't worry if on platform or already dead
|
|
if(!isOnPlatform()&&
|
|
m_currentMode!=PLAYER_MODE_DEAD)
|
|
{
|
|
int i;
|
|
DVECTOR const &pos=getPlayerPos();
|
|
|
|
for(i=0;i<2;i++)
|
|
{
|
|
int x,height;
|
|
|
|
x=pos.vx+(i==0?-checkx:checkx);
|
|
height=CGameScene::getCollision()->getHeightFromGround(x,pos.vy);
|
|
if(height<=0)
|
|
{
|
|
int block;
|
|
block=CGameScene::getCollision()->getCollisionBlock(x,pos.vy)&COLLISION_TYPE_MASK;
|
|
|
|
// Death?
|
|
if(block==COLLISION_TYPE_FLAG_DEATH_LIQUID)
|
|
{
|
|
dieYouPorousFreak(DEATHTYPE__LIQUID);
|
|
break;
|
|
}
|
|
else if(block==COLLISION_TYPE_FLAG_DEATH_INSTANT)
|
|
{
|
|
dieYouPorousFreak(DEATHTYPE__NORMAL);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
int panim=-1;
|
|
#include "gfx\prim.h" // (pkg)
|
|
|
|
#ifdef _STATE_DEBUG_
|
|
int stateDebugX=280;
|
|
int stateDebugY=180;
|
|
#endif
|
|
|
|
#ifdef __USER_paul__
|
|
#define NUM_LASTPOS 100
|
|
typedef struct
|
|
{
|
|
int vx,vy;
|
|
int h;
|
|
int onp;
|
|
}POSMEM;
|
|
static POSMEM lastpos[NUM_LASTPOS];
|
|
static int lastposnum=0;
|
|
int drawlastpos=false;
|
|
#endif
|
|
|
|
#ifdef __USER_paul__
|
|
int mouth=-1,eyes=-1;
|
|
#endif
|
|
|
|
#include "gui\gui.h"
|
|
void CPlayer::render()
|
|
{
|
|
CPlayerThing::render();
|
|
|
|
|
|
#ifdef _STATE_DEBUG_
|
|
char buf[100];
|
|
#ifdef __USER_paul__
|
|
sprintf(buf,"%04d (%02d) ,%04d (%02d)\ndfg:%+02d\nMode:%s",Pos.vx,Pos.vx&0x0f,Pos.vy,Pos.vy&0x0f,getHeightFromGround(Pos.vx,Pos.vy),s_modeText[m_currentMode]);
|
|
#else
|
|
sprintf(buf,"Pos: %04d,%04d",Pos.vx,Pos.vy);
|
|
#endif
|
|
m_fontBank->print(stateDebugX,stateDebugY,buf);
|
|
#endif
|
|
|
|
|
|
#ifdef __USER_paul__
|
|
if(PadGetDown(0)&PAD_R1)
|
|
{
|
|
POSMEM clear={0,0,0,false};
|
|
for(int i=0;i<NUM_LASTPOS;i++)
|
|
{
|
|
lastpos[i]=clear;
|
|
}
|
|
drawlastpos=drawlastpos==true?false:true;
|
|
}
|
|
if(Pos.vx!=lastpos[lastposnum].vx||Pos.vy!=lastpos[lastposnum].vy)
|
|
{
|
|
lastposnum=(lastposnum+1)%NUM_LASTPOS;
|
|
POSMEM *p=&lastpos[lastposnum];
|
|
p->vx=Pos.vx;
|
|
p->vy=Pos.vy;
|
|
p->onp=isOnPlatform()!=NULL;
|
|
if(p->onp)
|
|
{
|
|
p->h=getHeightFromPlatformNoGround(Pos.vx,Pos.vy,150);
|
|
}
|
|
else
|
|
{
|
|
p->h=getHeightFromGround(Pos.vx,Pos.vy,150);
|
|
}
|
|
}
|
|
if(drawlastpos)
|
|
{
|
|
POSMEM *p=lastpos;
|
|
for(int i=0;i<NUM_LASTPOS;i++)
|
|
{
|
|
int x,y;
|
|
x=p->vx-m_cameraPos.vx;
|
|
y=p->vy-m_cameraPos.vy;
|
|
DrawLine(x-4,y-4,x+4,y+4,0,0,255,0);
|
|
DrawLine(x-4,y+4,x+4,y-4,0,0,255,0);
|
|
y=y+p->h;
|
|
if(p->onp)
|
|
{
|
|
DrawLine(x-6,y,x+6,y,255,0,255,0);
|
|
}
|
|
else
|
|
{
|
|
DrawLine(x-6,y,x+6,y,128,0,255,0);
|
|
}
|
|
|
|
p++;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
SpriteBank *sb=CGameScene::getSpriteBank();
|
|
|
|
|
|
// Render player
|
|
if(m_animNo!=ANIM_SPONGEBOB_DONOTDRAW)
|
|
{
|
|
DVECTOR sbPos=
|
|
{
|
|
Pos.vx-m_cameraPos.vx,
|
|
Pos.vy-m_cameraPos.vy+1, // Odd.. source sprites were moved up by one pixel at some stage
|
|
};
|
|
renderSb(&sbPos,m_animNo,m_animFrame>>sbanimspeed);
|
|
m_currentPlayerModeClass->render(&sbPos);
|
|
}
|
|
|
|
|
|
// UI
|
|
// Don't draw it when the conversations are active - it's messy :/
|
|
if(!CConversation::isActive())
|
|
{
|
|
int count,warn;
|
|
sFrameHdr *fh;
|
|
char countBuf[5];
|
|
int x,y;
|
|
|
|
// Spat/token count
|
|
warn=false;
|
|
if(GameScene.getLevelNumber()!=5)
|
|
{
|
|
// Spat count
|
|
count=m_numSpatulasHeld;
|
|
fh=sb->getFrameHeader(FRM__SPATULA);
|
|
if(m_numSpatulasHeld==0)
|
|
{
|
|
warn=true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Token count
|
|
count=CGameSlotManager::getSlotData()->getKelpTokenCollectedCount(GameScene.getChapterNumber()-1,GameScene.getLevelNumber()-1);
|
|
fh=sb->getFrameHeader(FRM__TOKEN);
|
|
}
|
|
sprintf(countBuf,"x%d",count);
|
|
x=SB_UI_XBASE;
|
|
y=SB_UI_YBASE;
|
|
sb->printFT4(fh,x,y,0,0,POWERUPUI_OT);
|
|
x+=fh->W;
|
|
if(warn&&m_spatulaWarningTimer&32)
|
|
{
|
|
m_fontBank->setColour(255,0,0);
|
|
}
|
|
m_fontBank->print(x,y,countBuf);
|
|
m_fontBank->setColour(128,128,128);
|
|
x+=SB_UI_GAP_FROM_SPAT_COUNT_TO_PICKUPS;
|
|
|
|
if(isWearingBoots())
|
|
{
|
|
// Boots
|
|
int pickupX,pickupY;
|
|
sFrameHdr *fh=sb->getFrameHeader(FRM__SHOE);
|
|
if(m_squeakyBootsTimer>SQUEAKY_BOOTS_FLASH_TIME||m_squeakyBootsTimer&2)
|
|
{
|
|
sb->printFT4(fh,x,y,0,0,POWERUPUI_OT);
|
|
sb->printFT4(fh,x+4,y+4,0,0,POWERUPUI_OT);
|
|
}
|
|
x+=fh->W+SB_UI_GAP_BETWEEN_ITEMS+4;
|
|
}
|
|
|
|
// Mode specific ui
|
|
m_currentPlayerModeClass->renderModeUi();
|
|
|
|
|
|
// Fiving helmet.. now appears in same place as mode specific ui..
|
|
if(isWearingDivingHelmet())
|
|
{
|
|
// Helmet
|
|
POLY_FT4 *ft4;
|
|
int x,y;
|
|
int V,W,H,partH;
|
|
|
|
x=POWERUPUI_ICONX;
|
|
y=POWERUPUI_ICONY;
|
|
|
|
ft4=sb->printFT4(FRM__WATERHILIGHT,x,y,0,0,POWERUPUI_OT);
|
|
setSemiTrans(ft4,true);
|
|
|
|
fh=sb->getFrameHeader(FRM__WATER);
|
|
ft4=sb->printFT4(fh,0,0,0,0,POWERUPUI_OT);
|
|
setSemiTrans(ft4,true);
|
|
V=fh->V;
|
|
W=fh->W;
|
|
H=fh->H;
|
|
partH=(H*(255-(m_healthWaterLevel>>WATERLEVELSHIFT)))>>8;
|
|
if(partH>H)partH=H;
|
|
setXYWH(ft4,x,y+(partH),W,H-partH);
|
|
ft4->v0=V+(partH);
|
|
ft4->v1=V+(partH);
|
|
|
|
sb->printFT4(FRM__WATERMETER,x,y,0,0,POWERUPUI_OT);
|
|
|
|
if(!getIsInWater()&&m_healthWaterLevel<(WATER_COUNTER_SECONDTIME*6)&&m_currentPlayerModeClass->getState()!=STATE_SOAKUP)
|
|
{
|
|
int digit;
|
|
DVECTOR src={x+(W/2),y+(H/2)};
|
|
DVECTOR dst={INGAME_SCREENW/2,(INGAME_SCREENH/3)*1};
|
|
int frame;
|
|
int digitX,digitY,scale;
|
|
char buf[4];
|
|
int r,g,b;
|
|
|
|
digit=m_healthWaterLevel/WATER_COUNTER_SECONDTIME;
|
|
if(digit<0)digit=0;
|
|
|
|
frame=WATER_COUNTER_SECONDTIME-(m_healthWaterLevel%WATER_COUNTER_SECONDTIME);
|
|
if(frame>WATER_COUNTER_MOVINGTIME)frame=WATER_COUNTER_MOVINGTIME;
|
|
digitX=src.vx+(((dst.vx-src.vx)*frame)/WATER_COUNTER_MOVINGTIME);
|
|
digitY=src.vy+(((dst.vy-src.vy)*frame)/WATER_COUNTER_MOVINGTIME);
|
|
scale=WATER_COUNTER_STARTSCALE+(((WATER_COUNTER_ENDSCALE-WATER_COUNTER_STARTSCALE)*frame)/WATER_COUNTER_MOVINGTIME);
|
|
|
|
sprintf(buf,"%d",digit);
|
|
m_scalableFontBank->setJustification(FontBank::JUST_CENTRE);
|
|
m_scalableFontBank->setScale(scale);
|
|
r=WATER_COUNTER_R2-(((WATER_COUNTER_R2-WATER_COUNTER_R1)*(m_healthWaterLevel))/(WATER_COUNTER_SECONDTIME*6));
|
|
g=WATER_COUNTER_G2-(((WATER_COUNTER_G2-WATER_COUNTER_G1)*(m_healthWaterLevel))/(WATER_COUNTER_SECONDTIME*6));
|
|
b=WATER_COUNTER_B2-(((WATER_COUNTER_B2-WATER_COUNTER_B1)*(m_healthWaterLevel))/(WATER_COUNTER_SECONDTIME*6));
|
|
m_scalableFontBank->setColour(r,g,b);
|
|
m_scalableFontBank->print(digitX,digitY,buf);
|
|
}
|
|
|
|
x+=fh->W+SB_UI_GAP_BETWEEN_ITEMS;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose: Pre-calcs the visible edges of the map ( ie: the hard limits
|
|
for the camera pos )
|
|
Params: camera box ( in tiles )
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::setCameraBox(CameraBox _cameraBox)
|
|
{
|
|
m_cameraPosLimitBox.x1=_cameraBox.x1;
|
|
m_cameraPosLimitBox.y1=_cameraBox.y1;
|
|
m_cameraPosLimitBox.x2=_cameraBox.x2-(32*MAP2D_BLOCKSTEPSIZE); // Made up numbers! :) (pkg);
|
|
m_cameraPosLimitBox.y2=_cameraBox.y2-(16*MAP2D_BLOCKSTEPSIZE);
|
|
|
|
m_playerPosLimitBox.x1=_cameraBox.x1+64;
|
|
m_playerPosLimitBox.y1=_cameraBox.y1+64;
|
|
m_playerPosLimitBox.x2=_cameraBox.x2-64;
|
|
m_playerPosLimitBox.y2=_cameraBox.y2-64;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose: Like the normal setRespawnPos() but plays the telephone ring sound if
|
|
this is not the current respawn point. To be used from the respawn triggers
|
|
so that they make the ring sound
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::setRespawnPosAndRingTelephone(DVECTOR const &_respawn)
|
|
{
|
|
if(m_respawnPos.vx!=_respawn.vx||
|
|
m_respawnPos.vy!=_respawn.vy)
|
|
{
|
|
CSoundMediator::playSfx(CSoundMediator::SFX_TELEPHONE_BOX);
|
|
setRespawnPos(_respawn);
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
int CPlayer::getHeightFromGround(int _x,int _y,int _maxHeight)
|
|
{
|
|
int height;
|
|
|
|
height=CGameScene::getCollision()->getHeightFromGround(_x,_y,_maxHeight);
|
|
if(height>=_maxHeight)
|
|
{
|
|
CThing *platform;
|
|
platform=isOnPlatform();
|
|
if(platform)
|
|
{
|
|
int platformHeight=((CNpcPlatform*)platform)->getHeightFromPlatformAtPosition(_x,_y);
|
|
|
|
if ( platformHeight < height )
|
|
{
|
|
height = platformHeight;
|
|
if(height>_maxHeight)height=_maxHeight;
|
|
else if(height<-_maxHeight)height=-_maxHeight;
|
|
}
|
|
}
|
|
}
|
|
|
|
return height;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
int CPlayer::getHeightFromPlatformNoGround(int _x,int _y,int _maxHeight)
|
|
{
|
|
CThing *platform;
|
|
int height;
|
|
|
|
platform=isOnPlatform();
|
|
ASSERT(platform);
|
|
height=((CNpcPlatform*)platform)->getHeightFromPlatformAtPosition(_x,_y);
|
|
if(height>_maxHeight)height=_maxHeight;
|
|
else if(height<-_maxHeight)height=-_maxHeight;
|
|
|
|
return height;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
int CPlayer::getHeightFromGroundNoPlatform(int _x,int _y,int _maxHeight=32)
|
|
{
|
|
return( CGameScene::getCollision()->getHeightFromGround(_x,_y,_maxHeight) );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::setLedgeLookAhead(int _lookAhead)
|
|
{
|
|
if(m_ledgeLookAhead!=_lookAhead)
|
|
{
|
|
m_ledgeLookAhead=_lookAhead;
|
|
m_ledgeLookTimer=0;
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::addLife()
|
|
{
|
|
CGameSlotManager::GameSlot *gameSlot;
|
|
|
|
gameSlot=CGameSlotManager::getSlotData();
|
|
|
|
if(gameSlot->m_lives<MAX_LIVES)
|
|
{
|
|
gameSlot->m_lives++;
|
|
}
|
|
|
|
m_pantFlashTimer=PANT_FLASH_TIME;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::addSpatula(int Count=1)
|
|
{
|
|
m_numSpatulasHeld+=Count;
|
|
|
|
if(!m_hasReceivedExtraLifeFor100Spats&&m_numSpatulasHeld==100)
|
|
{
|
|
addLife();
|
|
m_hasReceivedExtraLifeFor100Spats=true;
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
ATTACK_STATE CPlayer::getAttackState()
|
|
{
|
|
return m_currentPlayerModeClass->getAttackState();
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::registerAddon(PLAYER_ADDONS _addon)
|
|
{
|
|
if(!s_addonActorGfx[_addon])
|
|
{
|
|
FileEquate sbk;
|
|
sbk=s_addonActorPoolNames[_addon];
|
|
s_addonActorGfx[_addon]=CActorPool::GetActor(sbk);
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::setMode(PLAYER_MODE _mode)
|
|
{
|
|
int state;
|
|
|
|
if(_mode==PLAYER_MODE_DEAD)
|
|
{
|
|
ASSERT(m_currentMode!=PLAYER_MODE_DEAD);
|
|
m_lastModeBeforeDeath=m_currentMode;
|
|
}
|
|
|
|
resetPlayerCollisionSizeToBase();
|
|
|
|
if(m_currentPlayerModeClass)
|
|
{
|
|
state=m_currentPlayerModeClass->getState();
|
|
}
|
|
else
|
|
{
|
|
state=STATE_IDLE;
|
|
}
|
|
m_currentMode=_mode;
|
|
m_currentPlayerModeClass=s_playerModes[_mode];
|
|
m_currentPlayerModeClass->setInitialState(state);
|
|
if(!m_currentPlayerModeClass->setState(state))
|
|
{
|
|
m_currentPlayerModeClass->setState(STATE_IDLE);
|
|
m_moveVelocity.vx=m_moveVelocity.vy=0;
|
|
}
|
|
m_currentPlayerModeClass->enter();
|
|
|
|
m_tryingToManuallyPickupWeapon=false;
|
|
m_tryingToAutomaticallyPickupWeapon=false;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
int CPlayer::getFacing()
|
|
{
|
|
return m_facing;
|
|
}
|
|
void CPlayer::setFacing(int _facing)
|
|
{
|
|
m_facing=_facing;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
int CPlayer::getAnimFrame()
|
|
{
|
|
return m_animFrame;
|
|
}
|
|
void CPlayer::setAnimFrame(int _animFrame)
|
|
{
|
|
m_animFrame=_animFrame;
|
|
}
|
|
int CPlayer::getAnimFrameCount()
|
|
{
|
|
return m_actorGfx->getFrameCount(m_animNo)<<sbanimspeed;
|
|
}
|
|
int CPlayer::getAnimNo()
|
|
{
|
|
return m_animNo;
|
|
}
|
|
void CPlayer::setAnimNo(int _animNo)
|
|
{
|
|
m_animNo=_animNo;
|
|
setAnimFrame(0);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::springPlayerUp(int _springHeight)
|
|
{
|
|
m_currentPlayerModeClass->springPlayerUp(_springHeight);
|
|
CSoundMediator::playSfx(CSoundMediator::SFX_BOUNCY_PLATFORM,false,true);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::setFloating()
|
|
{
|
|
m_currentPlayerModeClass->setFloating();
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
int haha=25;
|
|
void CPlayer::floatPlayerUp()
|
|
{
|
|
m_moveVelocity.vy-=haha;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::teleportTo(int _x,int _y)
|
|
{
|
|
DVECTOR pos={_x,_y};
|
|
|
|
m_teleportPendingPos=pos;
|
|
m_teleportPending=true;
|
|
}
|
|
|
|
void CPlayer::processTeleportToCommand()
|
|
{
|
|
ASSERT(m_teleportPending);
|
|
|
|
CameraBox releaseCamBox={0,0,29999,29999};
|
|
setCameraBox(releaseCamBox);
|
|
|
|
setPos(m_teleportPendingPos);
|
|
setRespawnPos(m_teleportPendingPos);
|
|
|
|
calcCameraFocusPointTarget();
|
|
m_currentCamFocusPoint=m_currentCamFocusPointTarget;
|
|
m_teleportPending=false;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::playAnimFrameSfx(int _animNo,int _animFrame)
|
|
{
|
|
static int lastAnimNo=-1;
|
|
static const AnimSfx *sfx;
|
|
|
|
if(_animNo!=lastAnimNo)
|
|
{
|
|
// Lookup the new anim number and cache it for next time :)
|
|
int i;
|
|
sfx=s_animSfx;
|
|
for(i=0;i<s_numAnimSfx;i++)
|
|
{
|
|
if(sfx->m_animNumber==_animNo)
|
|
{
|
|
break;
|
|
}
|
|
sfx++;
|
|
}
|
|
if(i==s_numAnimSfx)
|
|
{
|
|
// No sfx for this anim
|
|
sfx=NULL;
|
|
}
|
|
lastAnimNo=_animNo;
|
|
}
|
|
|
|
// Are there any sounds for this anim at this frame?
|
|
if(sfx)
|
|
{
|
|
const AnimFrameSfx *frameSfx;
|
|
int i;
|
|
|
|
ASSERT(sfx->m_numAnimFrameSfx);
|
|
|
|
frameSfx=sfx->m_animFrameSfx;
|
|
for(i=0;i<sfx->m_numAnimFrameSfx;i++)
|
|
{
|
|
if(m_animFrame==frameSfx->m_frame)
|
|
{
|
|
CSoundMediator::SFXID sfxId=frameSfx->m_sfxId;
|
|
if(isWearingBoots())
|
|
{
|
|
// Ugh.. horrible way to change the sfx when wearing squeaky boots (pkg)
|
|
if(sfxId==CSoundMediator::SFX_SPONGEBOB_WALK_1)sfxId=CSoundMediator::SFX_SPONGEBOB_SQUEAKY_SHOES_1;
|
|
else if(sfxId==CSoundMediator::SFX_SPONGEBOB_WALK_2)sfxId=CSoundMediator::SFX_SPONGEBOB_SQUEAKY_SHOES_2;
|
|
}
|
|
CSoundMediator::playSfx(sfxId);
|
|
break;
|
|
}
|
|
if(m_animFrame<frameSfx->m_frame)
|
|
{
|
|
break;
|
|
}
|
|
frameSfx++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::calcCameraFocusPointTarget()
|
|
{
|
|
m_currentCamFocusPointTarget.vx=Pos.vx+MAP2D_CENTRE_X-(m_cameraXScrollPos>>CAMERA_ACCURACYSHIFT);
|
|
m_currentCamFocusPointTarget.vy=Pos.vy+MAP2D_CENTRE_Y-m_cameraFallYScrollPos;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::respawn()
|
|
{
|
|
setMode(m_lastModeBeforeDeath);
|
|
|
|
m_allowConversation=false;
|
|
|
|
m_numSpatulasHeld=0;
|
|
m_spatulaWarningTimer=0;
|
|
m_healthWaterLevel=WATERMAXHEALTH;
|
|
m_invincibleFrameCount=INVINCIBLE_FRAMES__START;
|
|
m_helmetSoundTimer=0;
|
|
Pos=m_respawnPos;
|
|
m_cameraLookOffset=0;
|
|
|
|
m_lockCamera=false;
|
|
m_cameraXScrollDir=0;
|
|
m_cameraXScrollPos=0;
|
|
|
|
m_cameraFallYScrollPos=0;
|
|
m_isFalling=false;
|
|
m_fallFrames=false;
|
|
m_cameraFallYScrollSpeed=0;
|
|
|
|
calcCameraFocusPointTarget();
|
|
m_currentCamFocusPoint=m_currentCamFocusPointTarget;
|
|
m_cameraPos.vx=m_currentCamFocusPoint.vx;
|
|
m_cameraPos.vy=m_currentCamFocusPoint.vy;
|
|
|
|
m_padLookAroundTimer=0;
|
|
m_ledgeLookAhead=0;
|
|
m_ledgeLookOffset=0;
|
|
m_ledgeLookTimer=0;
|
|
m_tryingToManuallyPickupWeapon=false;
|
|
m_tryingToAutomaticallyPickupWeapon=false;
|
|
|
|
m_squeakyBootsTimer=0;
|
|
m_invincibilityRingTimer=0;
|
|
m_bubbleAmmo=0;
|
|
m_jellyAmmo=0;
|
|
m_jellyfishAmmoCount=0;
|
|
m_pantFlashTimer=0;
|
|
m_hasReceivedExtraLifeFor100Spats=false;
|
|
|
|
m_moveVelocity.vx=m_moveVelocity.vy=0;
|
|
|
|
clearPlatform();
|
|
|
|
updateCollisionArea();
|
|
|
|
m_ignoreNewlyPressedButtonsOnPadThisThink=true;
|
|
|
|
m_canExitLevel=false;
|
|
m_teleportPending=false;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose: Yes - This function is fat! It can be tidied up when all of the anims
|
|
are finalised. Etracting the repeated code to a function will probly not
|
|
improve things cos of the amount of data that would need to be passed about.
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::renderSb(DVECTOR *_pos,int _animNo,int _animFrame)
|
|
{
|
|
int playerMode;
|
|
int trans;
|
|
int addon;
|
|
POLY_FT4 *ft4;
|
|
|
|
if(m_currentMode==PLAYER_MODE_DEAD)
|
|
{
|
|
playerMode=m_lastModeBeforeDeath;
|
|
}
|
|
else
|
|
{
|
|
playerMode=m_currentMode;
|
|
}
|
|
trans=m_invincibleFrameCount||m_invincibilityRingTimer;
|
|
|
|
// Render an addon?
|
|
addon=s_addonNumbers[playerMode];
|
|
if(addon!=NO_ADDON)
|
|
{
|
|
s8 addonAnimNo=s_animMapNet[addon][_animNo];
|
|
if(addonAnimNo!=-1)
|
|
{
|
|
CActorGfx *addonGfx=s_addonActorGfx[addon];
|
|
if(addonGfx)
|
|
{
|
|
if(_animFrame>=addonGfx->getFrameCount(addonAnimNo))
|
|
{
|
|
PAUL_DBGMSG("FRAME OVERRUN ON SPONGEBOB ADDON! ( %d vs %d )",m_actorGfx->getFrameCount(_animNo),addonGfx->getFrameCount(addonAnimNo));
|
|
}
|
|
else
|
|
{
|
|
ft4=addonGfx->Render(*_pos,addonAnimNo,_animFrame,m_facing==FACING_RIGHT?0:1);
|
|
setSemiTrans(ft4,trans);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Render JFish in a net?
|
|
if(playerMode==PLAYER_MODE_NET&&getJellyFishAmmo())
|
|
{
|
|
s8 addonAnimNo=s_animMapNet[PLAYER_ADDON_JELLYFISHINNET][_animNo];
|
|
if(addonAnimNo!=-1)
|
|
{
|
|
CActorGfx *addonGfx=s_addonActorGfx[PLAYER_ADDON_JELLYFISHINNET];
|
|
if(addonGfx)
|
|
{
|
|
if(_animFrame>=addonGfx->getFrameCount(addonAnimNo))
|
|
{
|
|
PAUL_DBGMSG("FRAME OVERRUN ON SPONGEBOB JELLYFISH ADDON! ( %d vs %d )",m_actorGfx->getFrameCount(_animNo),addonGfx->getFrameCount(addonAnimNo));
|
|
}
|
|
else
|
|
{
|
|
ft4=addonGfx->Render(*_pos,addonAnimNo,_animFrame,m_facing==FACING_RIGHT?0:1);
|
|
setShadeTex(ft4,0);
|
|
setRGB0(ft4,255,128,255);
|
|
setSemiTrans(ft4,trans);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Render glove addon?
|
|
if(m_currentMode==PLAYER_MODE_FULLUNARMED)
|
|
{
|
|
s8 addonAnimNo=s_animMapNet[PLAYER_ADDON_GLOVE][_animNo];
|
|
if(addonAnimNo!=-1)
|
|
{
|
|
CActorGfx *addonGfx=s_addonActorGfx[PLAYER_ADDON_GLOVE];
|
|
if(addonGfx)
|
|
{
|
|
if(_animFrame>=addonGfx->getFrameCount(addonAnimNo))
|
|
{
|
|
PAUL_DBGMSG("FRAME OVERRUN ON SPONGEBOB GLOVE ADDON! ( %d vs %d )",m_actorGfx->getFrameCount(_animNo),addonGfx->getFrameCount(addonAnimNo));
|
|
}
|
|
else
|
|
{
|
|
ft4=addonGfx->Render(*_pos,addonAnimNo,_animFrame,m_facing==FACING_RIGHT?0:1);
|
|
setSemiTrans(ft4,trans);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Render SB
|
|
ft4=m_actorGfx->Render(*_pos,_animNo,_animFrame,m_facing==FACING_RIGHT?0:1);
|
|
CThing *platform;
|
|
platform=isOnPlatform();
|
|
if(platform)
|
|
{
|
|
if ( ( (CNpcPlatform *) platform )->isCart() )
|
|
{
|
|
m_actorGfx->RotateScale( ft4, *_pos, ( (CNpcPlatform *) platform )->getCollisionAngle() >> 1, ONE, ONE );
|
|
}
|
|
}
|
|
|
|
setSemiTrans(ft4,trans);
|
|
|
|
|
|
// Pants?
|
|
if(m_pantFlashTimer>0)
|
|
{
|
|
SpriteBank *sb=CGameScene::getSpriteBank();
|
|
sFrameHdr *fh;
|
|
DVECTOR drawPos;
|
|
int size;
|
|
|
|
fh=sb->getFrameHeader(FRM__PANTS);
|
|
drawPos=*_pos;
|
|
drawPos.vy+=PANT_FLASH_Y_OFFSET;
|
|
size=m_pantFlashTimer&8?4096:8192;
|
|
ft4=sb->printRotatedScaledSprite(fh,drawPos.vx,drawPos.vy,size,size,0,0);
|
|
}
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose: Says whether SB can do the look up/down thing
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
int CPlayer::canDoLookAround()
|
|
{
|
|
return m_currentPlayerModeClass->canDoLookAround();
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::ignoreNewlyPressedButtonsOnPadThisThink()
|
|
{
|
|
m_ignoreNewlyPressedButtonsOnPadThisThink=true;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::inSoakUpState()
|
|
{
|
|
if(isWearingDivingHelmet()&&
|
|
(CGameScene::getCollision()->getCollisionBlock(Pos.vx,Pos.vy)&COLLISION_TYPE_MASK)==COLLISION_TYPE_FLAG_SOAKUP)
|
|
{
|
|
m_healthWaterLevel+=waterSoakUpSpeed;
|
|
if(m_healthWaterLevel>WATERMAXHEALTH)
|
|
{
|
|
m_healthWaterLevel=WATERMAXHEALTH;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params: When _reactDirection is REACT__GET_DIRECTION_FROM_THING then
|
|
_thing must point to the thing that caused the damage
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
#if defined(__USER_daveo__) || defined(__USER_paul__)
|
|
int invincibleSponge=true; // NB: This is for debugging purposes only so don't try and use it for a permenant cheat mode..
|
|
#else
|
|
int invincibleSponge=false; // NB: This is for debugging purposes only so don't try and use it for a permenant cheat mode..
|
|
#endif
|
|
void CPlayer::takeDamage(DAMAGE_TYPE _damage,REACT_DIRECTION _reactDirection,CThing *_thing)
|
|
{
|
|
if(m_invincibleFrameCount==0&& // Don't take damage if still recovering from the last hit
|
|
m_invincibilityRingTimer==0&& // Or if we have the invincibility ring on
|
|
m_currentPlayerModeClass->getState()!=STATE_SOAKUP&& // Or soaking up
|
|
m_currentPlayerModeClass->getState()!=STATE_CELEBRATE&& // Or celebrating
|
|
m_currentMode!=PLAYER_MODE_DEAD &&
|
|
m_currentMode!=PLAYER_MODE_SWALLOW) // Or already dead! :)
|
|
{
|
|
int ouchThatHurt=true;
|
|
int ouchThatHurtSoMuchThatImJustGoingToDieNow=false;
|
|
CSoundMediator::SFXID painSound=CSoundMediator::SFX_SPONGEBOB_OUCH;
|
|
|
|
// Check if we are currently immune to this damage type
|
|
switch(_damage)
|
|
{
|
|
case DAMAGE__NONE:
|
|
ouchThatHurt=false;
|
|
break;
|
|
|
|
case DAMAGE__ELECTROCUTION:
|
|
case DAMAGE__SHOCK_ENEMY:
|
|
if(isWearingBoots())
|
|
{
|
|
ouchThatHurt=false;
|
|
}
|
|
else
|
|
{
|
|
painSound=CSoundMediator::SFX_BOSS_JELLYFISH___SB_GETS_ELECTROCUTED;
|
|
}
|
|
break;
|
|
|
|
case DAMAGE__FALL:
|
|
case DAMAGE__LAVA:
|
|
case DAMAGE__HIT_ENEMY:
|
|
case DAMAGE__GAS_ENEMY:
|
|
case DAMAGE__POISON_ENEMY:
|
|
case DAMAGE__SWALLOW_ENEMY:
|
|
case DAMAGE__PINCH_ENEMY:
|
|
case DAMAGE__SQUASH_ENEMY:
|
|
case DAMAGE__BURN_ENEMY:
|
|
case DAMAGE__BITE_ENEMY:
|
|
case DAMAGE__COLLISION_DAMAGE:
|
|
break;
|
|
|
|
case DAMAGE__KILL_OUTRIGHT:
|
|
ouchThatHurt=ouchThatHurtSoMuchThatImJustGoingToDieNow=true;
|
|
break;
|
|
}
|
|
|
|
if(ouchThatHurt)
|
|
{
|
|
int died=false;
|
|
if(invincibleSponge)
|
|
{
|
|
m_invincibleFrameCount=INVINCIBLE_FRAMES__HIT;
|
|
}
|
|
else
|
|
{
|
|
if(ouchThatHurtSoMuchThatImJustGoingToDieNow||getSpatulasHeld()==0/*&&m_currentMode!=PLAYER_MODE_NET)*/)
|
|
{
|
|
died=true;
|
|
}
|
|
else
|
|
{
|
|
// NET REMOVED FROM HIT SYSTEM (PKG)
|
|
/*
|
|
if(m_currentMode==PLAYER_MODE_NET)
|
|
{
|
|
// Launch net pickup
|
|
setMode(PLAYER_MODE_BASICUNARMED);
|
|
DVECTOR pickupPos;
|
|
CBasePickup *pickup;
|
|
pickupPos.vx=Pos.vx;
|
|
pickupPos.vy=Pos.vy-30;
|
|
pickup=createPickup(PICKUP__NET,&pickupPos);
|
|
pickup->setPos(&pickupPos);
|
|
}
|
|
else
|
|
*/
|
|
{
|
|
// Launch all spatulas!
|
|
GameScene.dropHealth(Pos,m_numSpatulasHeld,1);
|
|
m_numSpatulasHeld=0;
|
|
m_spatulaWarningTimer=0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(died)
|
|
{
|
|
DEATH_TYPE deathType;
|
|
switch(_damage)
|
|
{
|
|
case DAMAGE__SQUASH_ENEMY:
|
|
deathType=DEATHTYPE__SQUASH;
|
|
break;
|
|
|
|
default:
|
|
deathType=DEATHTYPE__NORMAL;
|
|
break;
|
|
}
|
|
dieYouPorousFreak(deathType);
|
|
CPadVibrationManager::setVibration(0,CPadVibrationManager::VIBE_LONG_STROBEY);
|
|
}
|
|
else
|
|
{
|
|
CThing *platform;
|
|
platform=isOnPlatform();
|
|
if(platform)
|
|
{
|
|
if ( ( (CNpcPlatform *) platform )->isCart() )
|
|
{
|
|
m_invincibleFrameCount=INVINCIBLE_FRAMES__HIT;
|
|
return;
|
|
}
|
|
}
|
|
|
|
if(_reactDirection!=REACT__NO_REACTION)
|
|
{
|
|
if(_reactDirection==REACT__GET_DIRECTION_FROM_THING)
|
|
{
|
|
ASSERT(_thing);
|
|
if(Pos.vx<_thing->getPos().vx)
|
|
{
|
|
_reactDirection=REACT__LEFT;
|
|
}
|
|
else
|
|
{
|
|
_reactDirection=REACT__RIGHT;
|
|
}
|
|
}
|
|
|
|
m_moveVelocity.vx=((int)_reactDirection);
|
|
switch(_reactDirection)
|
|
{
|
|
case REACT__LEFT:
|
|
setFacing(FACING_RIGHT);
|
|
break;
|
|
case REACT__RIGHT:
|
|
setFacing(FACING_LEFT);
|
|
break;
|
|
case REACT__UP:
|
|
case REACT__GET_DIRECTION_FROM_THING:
|
|
case REACT__NO_REACTION:
|
|
break;
|
|
}
|
|
CSoundMediator::playSfx(painSound);
|
|
m_currentPlayerModeClass->setState(STATE_JUMPBACK);
|
|
}
|
|
m_invincibleFrameCount=INVINCIBLE_FRAMES__HIT;
|
|
CPadVibrationManager::setVibration(0,CPadVibrationManager::VIBE_SHORT);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::collectedQuestItem()
|
|
{
|
|
m_currentPlayerModeClass->setState(STATE_CELEBRATE);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
int CPlayer::getLivesLeft()
|
|
{
|
|
return CGameSlotManager::getSlotData()->m_lives;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::dieYouPorousFreak(DEATH_TYPE _deathType)
|
|
{
|
|
ASSERT(m_currentMode!=PLAYER_MODE_DEAD);
|
|
|
|
m_deathType=_deathType;
|
|
CSoundMediator::playSfx(CSoundMediator::SFX_SPONGEBOB_DEFEATED_JINGLE);
|
|
setMode(PLAYER_MODE_DEAD);
|
|
m_lockCamera=true;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::updatePadInput()
|
|
{
|
|
m_lastPadInput=m_padInput;
|
|
m_padInput=readPadInput();
|
|
if(!m_ignoreNewlyPressedButtonsOnPadThisThink)
|
|
{
|
|
m_padInputDown=(PLAYERINPUT)(m_padInput&(m_lastPadInput^-1));
|
|
}
|
|
else
|
|
{
|
|
m_padInputDown=PI_NONE;
|
|
}
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
typedef struct
|
|
{
|
|
CPadConfig::PAD_CFG m_input;
|
|
PLAYERINPUT m_output;
|
|
} PAD_CONVERSION;
|
|
static const PAD_CONVERSION s_padConversionTable[]=
|
|
{
|
|
{ CPadConfig::PAD_CFG_UP, PI_UP },
|
|
{ CPadConfig::PAD_CFG_DOWN, PI_DOWN },
|
|
{ CPadConfig::PAD_CFG_LEFT, PI_LEFT },
|
|
{ CPadConfig::PAD_CFG_RIGHT, PI_RIGHT },
|
|
{ CPadConfig::PAD_CFG_JUMP, PI_JUMP },
|
|
{ CPadConfig::PAD_CFG_FIRE, PI_FIRE },
|
|
{ CPadConfig::PAD_CFG_CATCH, PI_CATCH },
|
|
{ CPadConfig::PAD_CFG_WEAPONCHANGE, PI_WEAPONCHANGE },
|
|
};
|
|
static const int s_padConversionTableSize=sizeof(s_padConversionTable)/sizeof(PAD_CONVERSION);
|
|
PLAYERINPUT CPlayer::readPadInput()
|
|
{
|
|
PLAYERINPUT input;
|
|
int pad;
|
|
const PAD_CONVERSION *table;
|
|
int i;
|
|
|
|
input=PI_NONE;
|
|
pad=PadGetHeld(0);
|
|
table=s_padConversionTable;
|
|
for(i=0;i<s_padConversionTableSize;i++)
|
|
{
|
|
if(pad&CPadConfig::getButton(table->m_input))
|
|
{
|
|
input=(PLAYERINPUT)(input|table->m_output);
|
|
}
|
|
table++;
|
|
}
|
|
|
|
#ifdef _RECORD_DEMO_MODE_
|
|
CDemoPlayer::demoPlayerControl *crnt;
|
|
PLAYERINPUT lastInput;
|
|
crnt=&s_demoControls[s_demoSize];
|
|
if(s_demoFrameCount==0)
|
|
{
|
|
crnt->m_inputValue=input;
|
|
}
|
|
lastInput=(PLAYERINPUT)crnt->m_inputValue;
|
|
if(crnt->m_length==255)
|
|
{
|
|
lastInput=(PLAYERINPUT)(input-1);
|
|
}
|
|
if(lastInput==input)
|
|
{
|
|
crnt->m_length++;
|
|
}
|
|
else
|
|
{
|
|
s_demoSize++;
|
|
ASSERT(s_demoSize<MAX_DEMO_SIZE);
|
|
crnt++;
|
|
crnt->m_inputValue=input;
|
|
crnt->m_length=1;
|
|
}
|
|
s_demoFrameCount++;
|
|
if(s_demoFrameCount==MAX_DEMO_TIME_IN_FRAMES)
|
|
{
|
|
writeDemoControls();
|
|
ASSERT(!"DEMO ENDED");
|
|
}
|
|
#endif
|
|
|
|
return input;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::justButtBouncedABadGuy()
|
|
{
|
|
CSoundMediator::playSfx(CSoundMediator::SFX_SPONGEBOB_BUTTBOUNCE);
|
|
m_currentPlayerModeClass->setState(STATE_BUTTBOUNCEUP);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::shove( DVECTOR const &move )
|
|
{
|
|
int colHeight;
|
|
|
|
// X movement
|
|
colHeight=CGameScene::getCollision()->getHeightFromGround(Pos.vx+move.vx,Pos.vy,5);
|
|
if(colHeight<0)
|
|
{
|
|
// Stop at the edge of the obstruction
|
|
int dir,vx,cx,i;
|
|
if(move.vx<0)
|
|
{
|
|
dir=-1;
|
|
vx=move.vx;
|
|
}
|
|
else
|
|
{
|
|
dir=+1;
|
|
vx=move.vx;
|
|
}
|
|
cx=Pos.vx;
|
|
for(i=0;i<vx;i++)
|
|
{
|
|
if(CGameScene::getCollision()->getHeightFromGround(cx,Pos.vy)<0)
|
|
{
|
|
break;
|
|
}
|
|
cx+=dir;
|
|
}
|
|
if(i)
|
|
Pos.vx=cx-dir;
|
|
}
|
|
else
|
|
{
|
|
// No obstruction
|
|
Pos.vx+=move.vx;
|
|
}
|
|
|
|
// Y movement
|
|
colHeight=CGameScene::getCollision()->getHeightFromGround(Pos.vx,Pos.vy+move.vy,5);
|
|
if(colHeight<0)
|
|
{
|
|
// Stop at the edge of the obstruction
|
|
int dir,vy,cy,i;
|
|
if(move.vy<0)
|
|
{
|
|
dir=-1;
|
|
vy=move.vy;
|
|
}
|
|
else
|
|
{
|
|
dir=+1;
|
|
vy=move.vy;
|
|
}
|
|
cy=Pos.vy;
|
|
for(i=0;i<vy;i++)
|
|
{
|
|
if(CGameScene::getCollision()->getHeightFromGround(Pos.vx,cy)<0)
|
|
{
|
|
break;
|
|
}
|
|
cy+=dir;
|
|
}
|
|
if(i)
|
|
Pos.vy=cy-dir;
|
|
}
|
|
else
|
|
{
|
|
// No obstruction
|
|
Pos.vy+=move.vy;
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::moveLeft()
|
|
{
|
|
if(m_moveVelocity.vx<-CAMERA_STARTMOVETHRESHOLD||m_cameraXScrollPos<-(CAMERA_SCROLLTHRESHOLD*CAMERA_TILESIZE)<<CAMERA_ACCURACYSHIFT)
|
|
{
|
|
m_cameraXScrollDir=m_reverseCameraMovement==false?+1:-1;
|
|
}
|
|
else if(m_moveVelocity.vx>-CAMERA_STOPMOVETHRESHOLD)
|
|
{
|
|
m_cameraXScrollDir=0;
|
|
}
|
|
}
|
|
void CPlayer::moveRight()
|
|
{
|
|
if(m_moveVelocity.vx>CAMERA_STARTMOVETHRESHOLD||m_cameraXScrollPos>(CAMERA_SCROLLTHRESHOLD*CAMERA_TILESIZE)<<CAMERA_ACCURACYSHIFT)
|
|
{
|
|
m_cameraXScrollDir=m_reverseCameraMovement==false?-1:+1;
|
|
}
|
|
else if(m_moveVelocity.vx<CAMERA_STOPMOVETHRESHOLD)
|
|
{
|
|
m_cameraXScrollDir=0;
|
|
}
|
|
}
|
|
void CPlayer::fall()
|
|
{
|
|
m_isFalling=true;
|
|
}
|
|
void CPlayer::buttFall()
|
|
{
|
|
m_cameraFallYScrollSpeed=CAMERA_FALL_DROP_SPEED;
|
|
m_isFalling=true;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::setPlatform(CThing *_newPlatform)
|
|
{
|
|
m_platform=_newPlatform;
|
|
}
|
|
void CPlayer::clearPlatform()
|
|
{
|
|
m_platform=NULL;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
int CPlayer::moveVertical(int _moveDistance)
|
|
{
|
|
DVECTOR pos;
|
|
int hitGround;
|
|
int hitThisSuspectBlock;
|
|
|
|
pos=Pos;
|
|
hitGround=false;
|
|
hitThisSuspectBlock=0;
|
|
|
|
// Are we falling?
|
|
if(_moveDistance>0)
|
|
{
|
|
if ( isOnPlatform() )
|
|
{
|
|
// must also detect that we have landed on platform
|
|
|
|
return( true );
|
|
}
|
|
|
|
int colHeightBefore[2],colHeightAfter[2],blockAfter[2],moveRequired[2];
|
|
int i;
|
|
int move;
|
|
|
|
// Get heights of the two edges
|
|
for(i=0;i<+2;i++)
|
|
{
|
|
int x=pos.vx+((i==0?-checkx:+checkx));
|
|
colHeightBefore[i]=getHeightFromGround(x,pos.vy,16);
|
|
colHeightAfter[i]=getHeightFromGround(x,pos.vy+_moveDistance,16);
|
|
blockAfter[i]=CGameScene::getCollision()->getCollisionBlock(x,pos.vy+_moveDistance);
|
|
}
|
|
|
|
// See if either side is about to go through the ground
|
|
for(i=0;i<2;i++)
|
|
{
|
|
if(colHeightBefore[i]>=0&&colHeightAfter[i]<=0)
|
|
{
|
|
int goingIntoThisBlock=blockAfter[i]&COLLISION_TYPE_MASK;
|
|
if(goingIntoThisBlock!=COLLISION_TYPE_FLAG_DEATH_FALL)
|
|
{
|
|
moveRequired[i]=colHeightAfter[i];
|
|
hitGround=true;
|
|
}
|
|
else
|
|
{
|
|
moveRequired[i]=0;
|
|
}
|
|
if(!hitThisSuspectBlock)hitThisSuspectBlock=goingIntoThisBlock;
|
|
}
|
|
else
|
|
{
|
|
moveRequired[i]=0;
|
|
}
|
|
}
|
|
|
|
// Find the smallest move required to hit ground
|
|
move=0;
|
|
for(i=0;i<2;i++)
|
|
{
|
|
if(moveRequired[i]<move)
|
|
{
|
|
move=moveRequired[i];
|
|
}
|
|
}
|
|
|
|
_moveDistance+=move;
|
|
}
|
|
else if(_moveDistance<0)
|
|
{
|
|
int colHeightBefore[2],colHeightAfter[2],blockAfter[2],moveRequired[2];
|
|
int i;
|
|
int move;
|
|
|
|
// -------------- Jumping - See if the feet have hit anything --------------
|
|
|
|
// Get heights of the two edges
|
|
for(i=0;i<+2;i++)
|
|
{
|
|
int x=pos.vx+((i==0?-checkx:+checkx));
|
|
colHeightBefore[i]=getHeightFromGround(x,pos.vy,16);
|
|
colHeightAfter[i]=getHeightFromGround(x,pos.vy+_moveDistance,16);
|
|
blockAfter[i]=CGameScene::getCollision()->getCollisionBlock(x,pos.vy+_moveDistance);
|
|
}
|
|
|
|
// See if either side is about to go through the ground
|
|
for(i=0;i<2;i++)
|
|
{
|
|
if(colHeightBefore[i]>=0&&colHeightAfter[i]<=0&&((blockAfter[i]&COLLISION_TYPE_MASK)!=COLLISION_TYPE_FLAG_NORMAL))
|
|
{
|
|
moveRequired[i]=colHeightAfter[i];
|
|
hitGround=true;
|
|
if(!hitThisSuspectBlock)hitThisSuspectBlock=blockAfter[i];
|
|
}
|
|
else
|
|
{
|
|
moveRequired[i]=0;
|
|
}
|
|
}
|
|
|
|
// Find the smallest move required to hit ground
|
|
move=0;
|
|
for(i=0;i<2;i++)
|
|
{
|
|
if(moveRequired[i]<move)
|
|
{
|
|
move=moveRequired[i];
|
|
}
|
|
}
|
|
|
|
_moveDistance-=move;
|
|
|
|
|
|
// -------------- Jumping - See if the head has hit anything --------------
|
|
|
|
// Get heights of the two edges
|
|
int y=pos.vy-HEIGHT_FOR_HEAD_COLLISION;
|
|
for(i=0;i<+2;i++)
|
|
{
|
|
int x=pos.vx+((i==0?-checkx:+checkx));
|
|
colHeightBefore[i]=getHeightFromGround(x,y,16);
|
|
colHeightAfter[i]=getHeightFromGround(x,y+_moveDistance,16);
|
|
blockAfter[i]=CGameScene::getCollision()->getCollisionBlock(x,y+_moveDistance);
|
|
}
|
|
|
|
// See if either side is about to go through the ground
|
|
for(i=0;i<2;i++)
|
|
{
|
|
if(colHeightBefore[i]>=0&&colHeightAfter[i]<=0&&((blockAfter[i]&COLLISION_TYPE_MASK)!=COLLISION_TYPE_FLAG_NORMAL))
|
|
{
|
|
moveRequired[i]=16+colHeightAfter[i];
|
|
hitGround=true;
|
|
if(!hitThisSuspectBlock)hitThisSuspectBlock=blockAfter[i];
|
|
}
|
|
else
|
|
{
|
|
moveRequired[i]=0;
|
|
}
|
|
}
|
|
|
|
// Find the smallest move required to hit ground
|
|
move=0;
|
|
for(i=0;i<2;i++)
|
|
{
|
|
if(moveRequired[i]<move)
|
|
{
|
|
move=moveRequired[i];
|
|
}
|
|
}
|
|
|
|
_moveDistance-=move;
|
|
}
|
|
else
|
|
{
|
|
// Stood on any important types of collision?
|
|
hitThisSuspectBlock=CGameScene::getCollision()->getCollisionBlock(pos.vx,pos.vy+_moveDistance);
|
|
}
|
|
|
|
pos.vy+=_moveDistance;
|
|
setPlayerPos(&pos);
|
|
|
|
|
|
if(m_currentMode!=PLAYER_MODE_DEAD)
|
|
{
|
|
switch(hitThisSuspectBlock&COLLISION_TYPE_MASK)
|
|
{
|
|
case COLLISION_TYPE_FLAG_DAMAGE:
|
|
takeDamage(DAMAGE__COLLISION_DAMAGE);
|
|
break;
|
|
case COLLISION_TYPE_FLAG_ELECTRIC:
|
|
if(!isWearingBoots())
|
|
{
|
|
takeDamage(DAMAGE__COLLISION_DAMAGE);
|
|
}
|
|
break;
|
|
/*
|
|
case COLLISION_TYPE_FLAG_DEATH_LIQUID:
|
|
dieYouPorousFreak(DEATHTYPE__LIQUID);
|
|
break;
|
|
case COLLISION_TYPE_FLAG_DEATH_INSTANT:
|
|
dieYouPorousFreak(DEATHTYPE__NORMAL);
|
|
break;
|
|
*/
|
|
case COLLISION_TYPE_FLAG_DEATH_FALL:
|
|
dieYouPorousFreak(DEATHTYPE__FALL_TO_DEATH);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return hitGround;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
int checkside=+1;
|
|
int CPlayer::moveHorizontal(int _moveDistance)
|
|
{
|
|
int hitWall;
|
|
|
|
hitWall=false;
|
|
if(_moveDistance)
|
|
{
|
|
DVECTOR pos;
|
|
int dirToMove;
|
|
int i;
|
|
int colHeightEdges[2];
|
|
int colHeight;
|
|
|
|
pos=getPlayerPos();
|
|
dirToMove=_moveDistance<0?-1:+1;
|
|
for(i=abs(_moveDistance);i&&!hitWall;i--)
|
|
{
|
|
int touchingGround,x,x2;
|
|
|
|
colHeightEdges[0]=getHeightFromGround(pos.vx-checkx,pos.vy,16);
|
|
colHeightEdges[1]=getHeightFromGround(pos.vx+checkx,pos.vy,16);
|
|
|
|
touchingGround=false;
|
|
x=x2=pos.vx+dirToMove;
|
|
|
|
if(dirToMove>0)
|
|
{
|
|
// Moving right
|
|
if(colHeightEdges[1]==0)
|
|
{
|
|
// Right side of SB touching ground
|
|
x+=checkx;
|
|
x2-=checkx;
|
|
touchingGround=true;
|
|
}
|
|
else if(colHeightEdges[0]==0)
|
|
{
|
|
// Left side of SB touching ground
|
|
x-=checkx;
|
|
x2+=checkx;
|
|
touchingGround=true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Moving left
|
|
if(colHeightEdges[0]==0)
|
|
{
|
|
// Left side of SB touching ground
|
|
x-=checkx;
|
|
x2+=checkx;
|
|
touchingGround=true;
|
|
}
|
|
else if(colHeightEdges[1]==0)
|
|
{
|
|
// Right side of SB touching ground
|
|
x+=checkx;
|
|
x2-=checkx;
|
|
touchingGround=true;
|
|
}
|
|
}
|
|
|
|
if(touchingGround)
|
|
{
|
|
// SB touching ground on at least one edge
|
|
colHeight=getHeightFromGround(x,pos.vy,16);
|
|
if(colHeight>=-2&&colHeight<=2)
|
|
{
|
|
// Move along the ground
|
|
pos.vx+=dirToMove;
|
|
pos.vy+=colHeight;
|
|
|
|
// Heh - these 4 lines stop SB going down a slope on the 'wrong edge' :)
|
|
colHeight=getHeightFromGround(x2,pos.vy,16);
|
|
if(colHeight<0)
|
|
{
|
|
pos.vy+=colHeight;
|
|
}
|
|
}
|
|
else if(colHeight<0)
|
|
{
|
|
// Hit wall
|
|
hitWall=true;
|
|
}
|
|
else
|
|
{
|
|
// Moved off edge of ledge
|
|
pos.vx+=dirToMove;
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// SB not touching ground
|
|
if(dirToMove<0)
|
|
{
|
|
x-=checkx;
|
|
}
|
|
else
|
|
{
|
|
x+=checkx;
|
|
}
|
|
|
|
// Head collision ( cheers Charles! :)
|
|
colHeight = getHeightFromGround( x, pos.vy-HEIGHT_FOR_HEAD_COLLISION, 16 );
|
|
if ( colHeight < 0 )
|
|
{
|
|
switch ( CGameScene::getCollision()->getCollisionBlock( x, pos.vy-HEIGHT_FOR_HEAD_COLLISION ) & COLLISION_TYPE_MASK )
|
|
{
|
|
case COLLISION_TYPE_NORMAL:
|
|
break;
|
|
|
|
default:
|
|
hitWall=true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( !hitWall )
|
|
{
|
|
colHeight=getHeightFromGround(x,pos.vy,16);
|
|
if(colHeight>=0)
|
|
{
|
|
// Move in air
|
|
pos.vx+=dirToMove;
|
|
}
|
|
else
|
|
{
|
|
// Hit wall
|
|
hitWall=true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
setPlayerPos(&pos);
|
|
}
|
|
|
|
return hitWall;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::resetPlayerCollisionSizeToBase()
|
|
{
|
|
setPlayerCollisionSize(0,-COLSIZE_BASE_HEIGHT/2,COLSIZE_BASE_WIDTH,COLSIZE_BASE_HEIGHT);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
Function:
|
|
Purpose:
|
|
Params:
|
|
Returns:
|
|
---------------------------------------------------------------------- */
|
|
void CPlayer::setPlayerCollisionSize(int _x,int _y,int _w,int _h)
|
|
{
|
|
setCollisionSize(_w,_h);
|
|
setCollisionCentreOffset(_x,_y);
|
|
}
|
|
void CPlayer::getPlayerCollisionSize(int *_x,int *_y,int *_w,int *_h)
|
|
{
|
|
// DVECTOR offset,size;
|
|
|
|
DVECTOR const &offset=getCollisionCentreOffset();
|
|
DVECTOR const &size=getCollisionSize();
|
|
|
|
*_x=offset.vx;
|
|
*_y=offset.vy;
|
|
*_w=size.vx;
|
|
*_h=size.vy;
|
|
}
|
|
|
|
/*===========================================================================
|
|
end */ |