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

Browse source
This commit is contained in:
Paul 2001-06-14 15:19:57 +00:00
parent a59bdb7bb3
commit 18e1f665af
18 changed files with 245 additions and 271 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
makefile.gaz
View file

@ -248,7 +248,6 @@ pickups_src := pickup \
pballoon \
pblower \
pbubmix \
phealth \
phelmet \
pjlammo \
pkelp \

6
makefile.gfx
View file

@ -181,7 +181,7 @@ INGAMEFX_GFX_NONTRANS :=
INGAMEFX_GFX_NONTRANS_IN := $(foreach FILE,$(INGAMEFX_GFX_NONTRANS),$(INGAMEFX_NONTRANS_DIR)/$(FILE))
PICKUP_GFX_DIR := $(GRAF_DIR)/pickups
PICKUP_GFX := +spatula +token +pants +health100 +health50 +health25 +glint1 +glint2 +glint3 +glint4 \
PICKUP_GFX := +spatula +token +pants +glint1 +glint2 +glint3 +glint4 \
+jellyammo +bubblemixture +bubblewand +shoe +balloon +balloonburst +helmet \
+blower +launcher +net \
+c1_l1_quest_item +c1_l2_quest_item +c1_l3_quest_item +c1_l4_quest_item \
@ -192,9 +192,7 @@ PICKUP_GFX := +spatula +token +pants +health100 +health50 +health25 +glint1 +
PICKUP_GFX_IN := $(foreach FILE,$(PICKUP_GFX),$(PICKUP_GFX_DIR)/$(FILE).bmp)
INGAMEFX_GFX_DIR := $(GRAF_DIR)/ingamefx
INGAMEFX_GFX_TRANS := +health_full_1 +health_full_2 +health_full_3 +health_full_4 +health_full_5 \
+health_empty_1 +health_empty_2 +health_empty_3 +health_empty_4 +health_empty_5 \
+watermeter +waterhilight +netblob \
INGAMEFX_GFX_TRANS := +watermeter +waterhilight +netblob \
+spike
INGAMEFX_GFX_TRANS_NONROT_NONCLIP := +bubble_1 +bubble_2 +bubble_3 \
+water +aim_arrow

7
source/game/game.cpp
View file

@ -296,6 +296,7 @@ void CGameScene::think(int _frames)
level=getLevelNumber();
chapter=getChapterNumber();
// Open next level?
gameSlot->levelHasBeenCompleted(chapter-1,level-1);
if(level!=5&& // Don't open any levels after finishing a bonus level
!(level==4&&chapter==5)) // Don't open any levels after finishing final level
@ -316,6 +317,12 @@ void CGameScene::think(int _frames)
CMapScene::setLevelToStartOn(chapterToOpen-1,levelToOpen-1);
}
// New hi-spatula-count?
if(m_player->getSpatulasHeld()>gameSlot->getSpatulaCollectedCount(chapter-1,level-1))
{
gameSlot->setSpatulaCollectedCount(chapter-1,level-1,m_player->getSpatulasHeld(),getTotalSpatCountForThisLevel());
}
// Level finished - go to map or fma
if(level==4)
{

5
source/game/gameslot.cpp
View file

@ -132,10 +132,7 @@ void CGameSlotManager::eraseGameSlot(unsigned int _slot)
// Clear spatula and kelp token flags
for(i=0;i<NUM_CHAPTERS*NUM_LEVELS_WITH_SPATULAS;i++)
{
for(j=0;j<16;j++)
{
slot->m_spatulaCollectedFlags[i][j]=0;
}
slot->m_spatulaCollectedCounts[i]=0;
}
for(i=0;i<NUM_CHAPTERS;i++)
{

36
source/game/gameslot.h
View file

@ -68,8 +68,8 @@ public:
unsigned char m_isInUse;
unsigned char m_lives;
unsigned char m_continues;
unsigned char m_spatulaCollectedFlags[NUM_CHAPTERS*NUM_LEVELS_WITH_SPATULAS][16]; // Enuf space for 128 spats per level
unsigned char m_kelpTokenCollectedFlags[NUM_CHAPTERS][16]; // Same again..
unsigned char m_spatulaCollectedCounts[NUM_CHAPTERS*NUM_LEVELS_WITH_SPATULAS];
unsigned char m_kelpTokenCollectedFlags[NUM_CHAPTERS][16]; // Enuf space for 128 tokens per level
unsigned char m_kelpTokensHeld;
unsigned char m_partyItemsHeld[CShopScene::NUM_SHOP_ITEM_IDS];
unsigned char m_levelCompletionState[NUM_CHAPTERS*(NUM_LEVELS_PER_CHAPTER_WITH_QUEST_ITEMS+NUM_BONUS_LEVELS_PER_CHAPTER)];
@ -79,32 +79,22 @@ public:
{
ASSERT(_chapter<=NUM_CHAPTERS);
ASSERT(_level<=NUM_LEVELS_WITH_SPATULAS);
int i,j,count;
count=0;
for(i=0;i<8;i++)
{
unsigned char flags=m_spatulaCollectedFlags[(_chapter*NUM_LEVELS_WITH_SPATULAS)+_level][i];
for(j=0;j<8;j++)
{
if(flags&1)count++;
flags>>=1;
return m_spatulaCollectedCounts[(_chapter*NUM_LEVELS_WITH_SPATULAS)+_level];
}
}
return count;
}
void collectSpatula(unsigned int _chapter,unsigned int _level,unsigned int _spat)
void setSpatulaCollectedCount(unsigned int _chapter,unsigned int _level,unsigned char _count,unsigned char _totalCount)
{
ASSERT(_chapter<=NUM_CHAPTERS);
ASSERT(_level<=NUM_LEVELS_WITH_SPATULAS);
ASSERT(_spat<=128);
m_spatulaCollectedFlags[(_chapter*NUM_LEVELS_WITH_SPATULAS)+_level][_spat>>3]|=1<<(_spat&7);
}
int isSpatulaUncollected(unsigned int _chapter,unsigned int _level,unsigned int _spat)
m_spatulaCollectedCounts[(_chapter*NUM_LEVELS_WITH_SPATULAS)+_level]=_count;
// Does this open up a bonus level?
int percentRequired,percentAchieved;
percentRequired=(_chapter*10)+60; // 60% on chapter 1 ... to ... 100% on chapter 5
percentAchieved=(_count*100)/_totalCount;
if(percentAchieved>=percentRequired)
{
ASSERT(_chapter<=NUM_CHAPTERS);
ASSERT(_level<=NUM_LEVELS_WITH_SPATULAS);
ASSERT(_spat<=128);
return (m_spatulaCollectedFlags[(_chapter*NUM_LEVELS_WITH_SPATULAS)+_level][_spat>>3]>>(_spat&7))&1?false:true;
levelIsNowOpen(_chapter,4);
}
}
// Kelp Token functions..

6
source/game/pause.cpp
View file

@ -38,10 +38,6 @@
#include "game\game.h"
#endif
#ifndef __GAME_GAMESLOT_H__
#include "game\gameslot.h"
#endif
/* Std Lib
------- */
@ -213,7 +209,7 @@ void CPauseMenu::select()
chapter=GameScene.getChapterNumber()-1;
level=GameScene.getLevelNumber()-1;
m_guiSpatReadout->setSpatCounts(CGameSlotManager::getSlotData()->getSpatulaCollectedCount(chapter,level),
m_guiSpatReadout->setSpatCounts(GameScene.getPlayer()->getSpatulasHeld(),
GameScene.getTotalSpatCountForThisLevel());
}

16
source/level/level.cpp
View file

@ -431,15 +431,7 @@ void CLevel::initThings(int _respawningLevel)
createThisPickup=true;
isNumberedItem=false;
if((PICKUP_TYPE)ItemList->Type==PICKUP__SPATULA)
{
isNumberedItem=true;
if(CGameSlotManager::getSlotData()->isSpatulaUncollected(GameScene.getChapterNumber()-1,GameScene.getLevelNumber()-1,itemNumber)==false)
{
createThisPickup=false;
}
}
else if((PICKUP_TYPE)ItemList->Type==PICKUP__KELP_TOKEN)
if((PICKUP_TYPE)ItemList->Type==PICKUP__KELP_TOKEN)
{
isNumberedItem=true;
if(CGameSlotManager::getSlotData()->isKelpTokenUncollected(GameScene.getChapterNumber()-1,GameScene.getLevelNumber()-1,itemNumber)==false)
@ -461,11 +453,7 @@ void CLevel::initThings(int _respawningLevel)
newPickup=createPickup((PICKUP_TYPE)ItemList->Type,&pos);
if(isNumberedItem)
{
if((PICKUP_TYPE)ItemList->Type==PICKUP__SPATULA)
{
((CSpatulaPickup*)newPickup)->setSpatulaNumber(itemNumber);
}
else if((PICKUP_TYPE)ItemList->Type==PICKUP__KELP_TOKEN)
if((PICKUP_TYPE)ItemList->Type==PICKUP__KELP_TOKEN)
{
((CKelpTokenPickup*)newPickup)->setTokenNumber(itemNumber);
}

4
source/pickups/phealth.cpp
View file

@ -1,3 +1,7 @@
dsasdasda
/*=========================================================================
phealth.cpp

4
source/pickups/phealth.h
View file

@ -1,3 +1,7 @@
dssadsadsadsda
/*=========================================================================
phealth.h

69
source/pickups/pickup.cpp
View file

@ -31,10 +31,6 @@
// For the factory..
#ifndef __PICKUPS_PHEALTH_H__
#include "pickups\phealth.h"
#endif
#ifndef __PICKUPS_PLIFE_H__
#include "pickups\plife.h"
#endif
@ -414,6 +410,58 @@ void CBaseWeaponSimplePickup::renderPickup(DVECTOR *_pos)
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CBaseBouncingPickup::init()
{
CBasePickup::init();
m_timeTillVanish=TIME_TILL_VANISH;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CBaseBouncingPickup::render()
{
if(m_timeTillVanish>FRAMES_TO_FLASH||m_timeTillVanish&3)
{
DVECTOR ofs,pos;
int visibilityRadius;
CPickupThing::render();
ofs=CLevel::getCameraPos();
pos.vx=Pos.vx-ofs.vx;
pos.vy=Pos.vy-ofs.vy;
visibilityRadius=getVisibilityRadius();
if(pos.vx>0-visibilityRadius&&pos.vx<512+visibilityRadius&&
pos.vy>0-visibilityRadius&&pos.vy<256+visibilityRadius)
{
renderPickup(&pos);
}
}
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CBaseBouncingPickup::collidedWith(CThing *_thisThing)
{
}
/*----------------------------------------------------------------------
Function:
Purpose: This is basically a factory method for making pickups :)
@ -430,13 +478,10 @@ CBasePickup *createPickup(const PICKUP_TYPE _type,const DVECTOR *_pos)
switch(_type)
{
case PICKUP__BIG_HEALTH:
pickup=new ("LargeHealthPickup") CLargeHealthPickup();
break;
case PICKUP__MEDIUM_HEALTH:
pickup=new ("MediumHealthPickup") CMediumHealthPickup();
break;
case PICKUP__SMALL_HEALTH:
pickup=new ("SmallHealthPickup") CSmallHealthPickup();
ASSERT(!"HEALTH PICKUPS ARE NO LONGER IN THE GAME");
return NULL;
break;
case PICKUP__LIFE:
@ -488,7 +533,7 @@ CBasePickup *createPickup(const PICKUP_TYPE _type,const DVECTOR *_pos)
break;
case PICKUP__BALLOON_AND_SPATULA:
pickup=new ("BalloonAndSpatulaPickup") CBalloonAndSpatulaPickup();
ASSERT(!"BALLOON AND SPATULA PICKUPS ARE NO LONGER IN THE GAME");
break;
case PICKUP__JELLY_LAUNCHER:
@ -499,6 +544,10 @@ CBasePickup *createPickup(const PICKUP_TYPE _type,const DVECTOR *_pos)
pickup=new ("KelpTokenPickup") CKelpTokenPickup();
break;
case PICKUP__BOUNCING_SPATULA:
pickup=new ("BouncingSpatulaPickup") CBouncingSpatulaPickup();
break;
default:
ASSERT(!"UNKNOWN PICKUP TYPE");
return NULL;

31
source/pickups/pickup.h
View file

@ -36,9 +36,9 @@
typedef enum
{
PICKUP__BIG_HEALTH,
PICKUP__MEDIUM_HEALTH,
PICKUP__SMALL_HEALTH,
PICKUP__BIG_HEALTH, // No longer in the game.. Yay(!)
PICKUP__MEDIUM_HEALTH, // No longer in the game.. Yay(!)
PICKUP__SMALL_HEALTH, // No longer in the game.. Yay(!)
PICKUP__LIFE,
PICKUP__SPATULA,
PICKUP__JELLY_LAUNCHER_AMMO,
@ -54,6 +54,9 @@ typedef enum
PICKUP__BALLOON_AND_SPATULA,
PICKUP__JELLY_LAUNCHER,
PICKUP__KELP_TOKEN,
PICKUP__BOUNCING_SPATULA,
PICKUP__MAX
}
PICKUP_TYPE;
@ -149,6 +152,28 @@ protected:
};
class CBaseBouncingPickup : public CBasePickup
{
public:
virtual void init();
virtual void render();
protected:
enum
{
TIME_TILL_VANISH=5*55,
FRAMES_TO_FLASH=2*55,
};
virtual void renderPickup(DVECTOR *_pos)=0;
virtual void collidedWith(CThing *_thisThing);
int m_timeTillVanish;
};
/*----------------------------------------------------------------------
Globals
------- */

84
source/pickups/pspatula.cpp
View file

@ -37,7 +37,10 @@
#include "game\game.h"
#endif
#include "game/game.h"
#ifndef __PLAYER_PLAYER_H__
#include "player\player.h"
#endif
/* Std Lib
------- */
@ -109,8 +112,8 @@ DVECTOR CSpatulaPickup::getSizeForPlacement()
---------------------------------------------------------------------- */
void CSpatulaPickup::collect(class CPlayer *_player)
{
_player->addSpatula();
CBasePickup::collect(_player);
CGameSlotManager::getSlotData()->collectSpatula(GameScene.getChapterNumber()-1,GameScene.getLevelNumber()-1,m_spatulaNumber);
}
/*----------------------------------------------------------------------
@ -162,31 +165,21 @@ void CSpatulaPickup::renderPickup(DVECTOR *_pos)
extern int balloon_height;
extern int balloon_r1;
extern int balloon_g1;
extern int balloon_b1;
extern int balloon_r2;
extern int balloon_g2;
extern int balloon_b2;
extern int balloon_speed;
extern int balloon_scale1;
extern int balloon_scale2;
extern int balloon_phase;
extern int balloon_vissize;
extern int balloon_stringx;
int bspat_stringendxoff=8;
int bspat_stringendyoff=-13;
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CBalloonAndSpatulaPickup::init()
DVECTOR CBouncingSpatulaPickup::getSizeForPlacement()
{
CSpatulaPickup::init();
m_sin=0;
DVECTOR size;
sFrameHdr *fh;
fh=CGameScene::getSpriteBank()->getFrameHeader(FRM__SPATULA);
size.vx=fh->W;
size.vy=fh->H;
return size;
}
/*----------------------------------------------------------------------
@ -195,45 +188,32 @@ void CBalloonAndSpatulaPickup::init()
Params:
Returns:
---------------------------------------------------------------------- */
void CBalloonAndSpatulaPickup::thinkPickup(int _frames)
{
CSpatulaPickup::thinkPickup(_frames);
m_sin=(m_sin+(_frames*balloon_speed))&4095;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CBalloonAndSpatulaPickup::renderPickup(DVECTOR *_pos)
void CBouncingSpatulaPickup::renderPickup(DVECTOR *_pos)
{
SpriteBank *sprites;
sFrameHdr *fh,*fhspat;
int xo1,xo2;
sFrameHdr *fh;
int x,y;
sprites=CGameScene::getSpriteBank();
fh=sprites->getFrameHeader(FRM__BALLOON);
fhspat=sprites->getFrameHeader(FRM__SPATULA);
fh=sprites->getFrameHeader(FRM__SPATULA);
x=_pos->vx-(fh->W/2);
y=_pos->vy-(fh->H/2);
sprites->printFT4(fh,x,y,0,0,OTPOS__PICKUP_POS);
xo1=((msin((m_sin+balloon_phase)&4095)*balloon_scale1)>>12);
xo2=((msin(m_sin)*balloon_scale2)>>12);
x=_pos->vx-(fh->W/2)+bspat_stringendxoff;
y=_pos->vy-(fh->H/2)-(fhspat->H/2)-balloon_height+bspat_stringendyoff;
sprites->printFT4(fh,x+xo1,y,0,0,OTPOS__PICKUP_POS);
setCollisionCentreOffset(xo2,0);
x=_pos->vx+balloon_stringx+bspat_stringendxoff;
y=_pos->vy+(fh->H/2)-(fhspat->H/2)-balloon_height+bspat_stringendyoff;
DrawLine(x+xo1,y,x+xo2,y+balloon_height,balloon_r1,balloon_g1,balloon_b1,OTPOS__PICKUP_POS);
x++;
DrawLine(x+xo1,y,x+xo2,y+balloon_height,balloon_r2,balloon_g2,balloon_b2,OTPOS__PICKUP_POS);
_pos->vx+=xo2; // This is soooooooo naughty (pkg)
CSpatulaPickup::renderPickup(_pos);
/*
if(m_glint<=spat_maxglint)
{
fh=sprites->getFrameHeader(spat_glintFrames[(m_glint>>spat_glintgrowspeed)&0x07]);
x=x+spat_gxy.vx;
y=y+spat_gxy.vy;
sprites->printRotatedScaledSprite(fh,x,y,4095,4095,m_glintRot,OTPOS__PICKUP_POS-1);
}
*/
}
/*===========================================================================
end */

9
source/pickups/pspatula.h
View file

@ -60,20 +60,19 @@ private:
int m_spatulaNumber;
};
class CBalloonAndSpatulaPickup : public CSpatulaPickup
class CBouncingSpatulaPickup : public CBaseBouncingPickup
{
public:
virtual void init();
virtual DVECTOR getSizeForPlacement();
protected:
virtual void thinkPickup(int _frames);
virtual void renderPickup(DVECTOR *_pos);
private:
int m_sin;
};
/*----------------------------------------------------------------------
Globals
------- */

206
source/player/player.cpp
View file

@ -89,6 +89,10 @@
#include "pickups\pickup.h"
#endif
#ifndef __MATHTABLE_HEADER__
#include "utils\mathtab.h"
#endif
/* Std Lib
------- */
@ -702,15 +706,6 @@ if(newmode!=-1)
m_allowConversation=false;
if(m_healthReactFrames)
{
m_healthReactFrames-=_frames;
if(m_healthReactFrames<0)
{
m_healthReactFrames=0;
}
}
m_tryingToManuallyPickupWeapon=false;
m_tryingToAutomaticallyPickupWeapon=false;
@ -720,6 +715,30 @@ if(newmode!=-1)
#ifdef __USER_paul__
if(PadGetDown(0)&PAD_TRIANGLE)
{
DVECTOR spawnBasePos;
int angle,angleInc;
int i;
spawnBasePos=Pos;
spawnBasePos.vy-=50;
angle=-1024;
angleInc=512;
for(i=0;i<5;i++)
{
DVECTOR offset,spawnPos;
CBaseBouncingPickup *pickup;
angle&=4095;
offset.vx=((msin(angle)*25)>>12);
offset.vy=-((mcos(angle)*25)>>12);
spawnPos.vx=spawnBasePos.vx+offset.vx;
spawnPos.vy=spawnBasePos.vy+offset.vy;
pickup=(CBaseBouncingPickup*)createPickup(PICKUP__BOUNCING_SPATULA,&spawnPos);
angle+=angleInc;
}
}
#endif
///
@ -1226,7 +1245,10 @@ if(drawlastpos)
}
#endif
// Render
SpriteBank *sb=CGameScene::getSpriteBank();
// Render player
DVECTOR sbPos=
{
Pos.vx-m_cameraPos.vx,
@ -1236,91 +1258,58 @@ if(drawlastpos)
m_currentPlayerModeClass->render(&sbPos);
// Health
if(!isWearingDivingHelmet())
{
// In water - Use normal SB face for health
static int s_fullHealthFrames[]=
{
FRM__HEALTH_FULL_1,
FRM__HEALTH_FULL_2,
FRM__HEALTH_FULL_3,
FRM__HEALTH_FULL_4,
FRM__HEALTH_FULL_5,
};
static int s_emptyHealthFrames[]=
{
FRM__HEALTH_EMPTY_1,
FRM__HEALTH_EMPTY_2,
FRM__HEALTH_EMPTY_3,
FRM__HEALTH_EMPTY_4,
FRM__HEALTH_EMPTY_5,
};
int i,x,y;
POLY_FT4 *ft4;
int *frames;
x=HEALTH_ICONX;
y=HEALTH_ICONY;
if(m_health==0||m_healthReactFrames)
{
frames=s_emptyHealthFrames;
}
else
{
frames=s_fullHealthFrames;
}
int ygap;
ygap=CGameScene::getSpriteBank()->getFrameHeader(*frames)->H;
for(i=5;i>0;i--)
{
ft4=CGameScene::getSpriteBank()->printFT4(*frames++,x,y,0,0,0);
setSemiTrans(ft4,i>m_health);
y+=ygap;
}
}
else
{
// Out of water - Use bowl of water
POLY_FT4 *ft4;
// UI
char spatCount[20];
int x,y;
sFrameHdr *fh;
// Spat count
sprintf(spatCount,"x%d",m_numSpatulasHeld);
x=SB_UI_XBASE;
y=SB_UI_YBASE;
fh=sb->getFrameHeader(FRM__SPATULA);
sb->printFT4(fh,x,y,0,0,0);
x+=fh->W;
m_fontBank->print(x,y,spatCount);
x+=SB_UI_GAP_FROM_SPAT_COUNT_TO_PICKUPS;
if(isWearingDivingHelmet())
{
// Helmet
POLY_FT4 *ft4;
int V,W,H,partH;
ft4=CGameScene::getSpriteBank()->printFT4(FRM__WATERHILIGHT,HEALTH_ICONX,HEALTH_ICONY,0,0,0);
ft4=sb->printFT4(FRM__WATERHILIGHT,x,y,0,0,0);
setSemiTrans(ft4,true);
fh=CGameScene::getSpriteBank()->getFrameHeader(FRM__WATER);
ft4=CGameScene::getSpriteBank()->printFT4(fh,0,0,0,0,0);
fh=sb->getFrameHeader(FRM__WATER);
ft4=sb->printFT4(fh,0,0,0,0,0);
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,HEALTH_ICONX,HEALTH_ICONY+(partH),W,H-partH);
setXYWH(ft4,x,y+(partH),W,H-partH);
ft4->v0=V+(partH);
ft4->v1=V+(partH);
CGameScene::getSpriteBank()->printFT4(FRM__WATERMETER,HEALTH_ICONX,HEALTH_ICONY,0,0,0);
sb->printFT4(FRM__WATERMETER,x,y,0,0,0);
x+=fh->W+SB_UI_GAP_BETWEEN_ITEMS;
}
// Mode specific ui
int itemX=COLLECTEDITEM_BASEX;
// Pickups
m_currentPlayerModeClass->renderModeUi();
if(isWearingBoots())
{
int x,y;
sFrameHdr *fh=CGameScene::getSpriteBank()->getFrameHeader(FRM__SHOE);
x=itemX-(fh->W/2);
y=COLLECTEDITEM_BASEY-(fh->H/2);
CGameScene::getSpriteBank()->printFT4(fh,x+2,y+2,0,0,0);
CGameScene::getSpriteBank()->printFT4(fh,x-2,y-2,0,0,0);
itemX+=COLLECTEDITEM_GAP;
// Boots
int pickupX,pickupY;
sFrameHdr *fh=sb->getFrameHeader(FRM__SHOE);
sb->printFT4(fh,x,y,0,0,0);
sb->printFT4(fh,x+4,y+4,0,0,0);
x+=fh->W+SB_UI_GAP_BETWEEN_ITEMS+4;
}
// Mode specific ui
m_currentPlayerModeClass->renderModeUi();
}
@ -1427,32 +1416,6 @@ int CPlayer::getHeightFromGroundNoPlatform(int _x,int _y,int _maxHeight=32)
return( CGameScene::getCollision()->getHeightFromGround(_x,_y,_maxHeight) );
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CPlayer::addHealth(int _health)
{
if(!isWearingDivingHelmet())
{
m_health+=_health;
if(m_health>MAX_HEALTH)
{
m_health=MAX_HEALTH;
}
}
else
{
m_healthWaterLevel+=WATERHEALTHPART*_health;
if(m_healthWaterLevel>WATERMAXHEALTH)
{
m_healthWaterLevel=WATERMAXHEALTH;
}
}
}
/*----------------------------------------------------------------------
Function:
Purpose:
@ -1709,9 +1672,8 @@ void CPlayer::respawn()
m_allowConversation=false;
m_health=MAX_HEALTH;
m_numSpatulasHeld=0;
m_healthWaterLevel=WATERMAXHEALTH;
m_healthReactFrames=0;
m_invincibleFrameCount=INVINCIBLE_FRAMES__START;
m_helmetSoundTimer=0;
Pos=m_respawnPos;
@ -1949,34 +1911,21 @@ void CPlayer::takeDamage(DAMAGE_TYPE _damage,REACT_DIRECTION _reactDirection,CTh
}
else
{
if(!isWearingDivingHelmet())
{
if(!ouchThatHurtSoMuchThatImJustGoingToDieNow)
{
m_health--;
}
else
{
m_health=-1;
}
if(m_health<0)
if(ouchThatHurtSoMuchThatImJustGoingToDieNow||(getSpatulasHeld()==0&&m_currentMode!=PLAYER_MODE_NET))
{
died=true;
}
else
{
if(m_currentMode==PLAYER_MODE_NET)
{
// Launch net pickup
m_currentMode=PLAYER_MODE_FULLUNARMED;
}
else
{
if(!ouchThatHurtSoMuchThatImJustGoingToDieNow)
{
m_healthWaterLevel-=WATERHEALTHPART;
}
else
{
m_health=-1;
}
if(m_healthWaterLevel<0)
{
died=true;
// Launch all spatulas!
m_numSpatulasHeld=0;
}
}
}
@ -2005,8 +1954,6 @@ void CPlayer::takeDamage(DAMAGE_TYPE _damage,REACT_DIRECTION _reactDirection,CTh
if ( ( (CNpcPlatform *) platform )->isCart() )
{
m_invincibleFrameCount=INVINCIBLE_FRAMES__HIT;
m_healthReactFrames=25;
return;
}
}
@ -2043,7 +1990,6 @@ void CPlayer::takeDamage(DAMAGE_TYPE _damage,REACT_DIRECTION _reactDirection,CTh
m_currentPlayerModeClass->setState(STATE_JUMPBACK);
}
m_invincibleFrameCount=INVINCIBLE_FRAMES__HIT;
m_healthReactFrames=25;
}
}
}

28
source/player/player.h
View file

@ -182,13 +182,11 @@ class CPlayer : public CPlayerThing
public:
enum
{
MAX_HEALTH=5,
MAX_LIVES=99,
WATERLEVELSHIFT=5,
WATERMAXHEALTH=(255<<WATERLEVELSHIFT),
WATERHEALTHPART=WATERMAXHEALTH/(MAX_HEALTH+1),
WATERMINSOACKUPLEVEL=(245<<WATERLEVELSHIFT), // SB won't auto soak unless water is lower than this
WATERMINSOAKUPLEVEL=(245<<WATERLEVELSHIFT), // SB won't auto soak unless water is lower than this
};
typedef struct
@ -228,8 +226,9 @@ public:
void setLedgeLookAhead(int _lookAhead) {m_ledgeLookAhead=_lookAhead;}
void addHealth(int _health);
void addLife();
void addSpatula() {m_numSpatulasHeld++;}
int getSpatulasHeld() {return m_numSpatulasHeld;}
ATTACK_STATE getAttackState();
int isRecoveringFromHit() {return m_invincibleFrameCount!=0||m_currentMode==PLAYER_MODE_DEAD;}
@ -331,9 +330,8 @@ public:
private:
int m_lives;
int m_health;
int m_numSpatulasHeld;
int m_healthWaterLevel;
int m_healthReactFrames;
int m_helmetSoundTimer; // Timer for breathing sound when using the helmet
@ -393,8 +391,8 @@ public:
void setIsInWater(int _in) {m_isInWater=_in;m_helmetSoundTimer=0;}
int getIsInWater() {return m_isInWater;}
int getIsHealthFullSoICanStopSoakingUp() {return m_healthWaterLevel==WATERMAXHEALTH;}
int getIsHealthSoFullThatIDontNeedToSoakUp(){return m_healthWaterLevel>=WATERMINSOACKUPLEVEL;}
int getIsHelmetFullSoICanStopSoakingUp() {return m_healthWaterLevel==WATERMAXHEALTH;}
int getIsHelmetSoFullThatIDontNeedToSoakUp(){return m_healthWaterLevel>=WATERMINSOAKUPLEVEL;}
int isHoldingNet() {return m_currentMode==PLAYER_MODE_NET;}
@ -444,16 +442,10 @@ public:
enum
{
HEALTH_ICONX=40,
HEALTH_ICONY=40,
POWERUPUI_ICONX=400,
POWERUPUI_ICONY=40,
POWERUPUI_TEXTX=440,
POWERUPUI_TEXTY=37,
POWERUPUI_OT=0,
COLLECTEDITEM_BASEX=110,
COLLECTEDITEM_BASEY=60,
COLLECTEDITEM_GAP=40,
SB_UI_XBASE=40,
SB_UI_YBASE=40,
SB_UI_GAP_FROM_SPAT_COUNT_TO_PICKUPS=50,
SB_UI_GAP_BETWEEN_ITEMS=5,
};
private:

2
source/player/pmodes.cpp
View file

@ -307,7 +307,7 @@ void CPlayerModeBase::thinkVerticalMovement()
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&&
!m_player->getIsHealthSoFullThatIDontNeedToSoakUp())
!m_player->getIsHelmetSoFullThatIDontNeedToSoakUp())
{
// Hit water - Go into soakup mode
setState(STATE_SOAKUP);

4
source/player/pmodes.h
View file

@ -161,8 +161,8 @@ public:
CPlayer *getPlayer() { return( m_player ); }
int getIsInWater() {return m_player->getIsInWater();}
int getIsHealthFullSoICanStopSoakingUp() {return m_player->getIsHealthFullSoICanStopSoakingUp();}
int getIsHealthSoFullThatIDontNeedToSoakUp(){return m_player->getIsHealthSoFullThatIDontNeedToSoakUp();}
int getIsHelmetFullSoICanStopSoakingUp() {return m_player->getIsHelmetFullSoICanStopSoakingUp();}
int getIsHelmetSoFullThatIDontNeedToSoakUp(){return m_player->getIsHelmetSoFullThatIDontNeedToSoakUp();}
void moveLeft();
void moveRight();

2
source/player/psduck.cpp
View file

@ -115,7 +115,7 @@ void CPlayerStateSoakUp::enter(CPlayerModeBase *_playerMode)
---------------------------------------------------------------------- */
void CPlayerStateSoakUp::think(CPlayerModeBase *_playerMode)
{
if(!_playerMode->getIsHealthFullSoICanStopSoakingUp())
if(!_playerMode->getIsHelmetFullSoICanStopSoakingUp())
{
if(m_breatheDelayFrames==0)
{