makefile.gaz

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

makefile.gfx

@@ -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 \
+INGAMEFX_GFX_TRANS :=		+watermeter +waterhilight +netblob \
-							+health_empty_1 +health_empty_2 +health_empty_3 +health_empty_4 +health_empty_5 \
-							+watermeter +waterhilight +netblob \
 							+spike
 INGAMEFX_GFX_TRANS_NONROT_NONCLIP :=	+bubble_1 +bubble_2 +bubble_3 \
 										+water  +aim_arrow

source/game/game.cpp

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

source/game/gameslot.cpp

@@ -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_spatulaCollectedCounts[i]=0;
-		{
-			slot->m_spatulaCollectedFlags[i][j]=0;
-		}
 	}
 	for(i=0;i<NUM_CHAPTERS;i++)
 	{

source/game/gameslot.h

@@ -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_spatulaCollectedCounts[NUM_CHAPTERS*NUM_LEVELS_WITH_SPATULAS];
-		unsigned char	m_kelpTokenCollectedFlags[NUM_CHAPTERS][16];								// Same again..
+		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;
+			return m_spatulaCollectedCounts[(_chapter*NUM_LEVELS_WITH_SPATULAS)+_level];
-			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;
 		}
-			}
+		void			setSpatulaCollectedCount(unsigned int _chapter,unsigned int _level,unsigned char _count,unsigned char _totalCount)
-			return count;
-		}
-		void			collectSpatula(unsigned int _chapter,unsigned int _level,unsigned int _spat)
 		{
 			ASSERT(_chapter<=NUM_CHAPTERS);
 			ASSERT(_level<=NUM_LEVELS_WITH_SPATULAS);
-			ASSERT(_spat<=128);
+			m_spatulaCollectedCounts[(_chapter*NUM_LEVELS_WITH_SPATULAS)+_level]=_count;
-			m_spatulaCollectedFlags[(_chapter*NUM_LEVELS_WITH_SPATULAS)+_level][_spat>>3]|=1<<(_spat&7);
+			
-		}
+			// Does this open up a bonus level?
-		int				isSpatulaUncollected(unsigned int _chapter,unsigned int _level,unsigned int _spat)
+			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);
+				levelIsNowOpen(_chapter,4);
-			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;
 		}
 
 		// Kelp Token functions..

source/game/pause.cpp

@@ -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());
 }
 

source/level/level.cpp

@@ -431,15 +431,7 @@ void	CLevel::initThings(int _respawningLevel)
 
 				createThisPickup=true;
 				isNumberedItem=false;
-				if((PICKUP_TYPE)ItemList->Type==PICKUP__SPATULA)
+				if((PICKUP_TYPE)ItemList->Type==PICKUP__KELP_TOKEN)
-				{
-					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)
 				{
 					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)
+						if((PICKUP_TYPE)ItemList->Type==PICKUP__KELP_TOKEN)
-						{
-							((CSpatulaPickup*)newPickup)->setSpatulaNumber(itemNumber);
-						}
-						else if((PICKUP_TYPE)ItemList->Type==PICKUP__KELP_TOKEN)
 						{
 							((CKelpTokenPickup*)newPickup)->setTokenNumber(itemNumber);
 						}

source/pickups/phealth.cpp

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

source/pickups/phealth.h

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

source/pickups/pickup.cpp

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

source/pickups/pickup.h

@@ -36,9 +36,9 @@
 
 typedef enum
 {
-	PICKUP__BIG_HEALTH,
+	PICKUP__BIG_HEALTH,				// No longer in the game.. Yay(!)
-	PICKUP__MEDIUM_HEALTH,
+	PICKUP__MEDIUM_HEALTH,			// No longer in the game.. Yay(!)
-	PICKUP__SMALL_HEALTH,
+	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
 	------- */

source/pickups/pspatula.cpp

@@ -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();
+	DVECTOR		size;
-	m_sin=0;
+	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)
+void	CBouncingSpatulaPickup::renderPickup(DVECTOR *_pos)
-{
-	CSpatulaPickup::thinkPickup(_frames);
-	m_sin=(m_sin+(_frames*balloon_speed))&4095;
-}
-
-/*----------------------------------------------------------------------
-	Function:
-	Purpose:
-	Params:
-	Returns:
-  ---------------------------------------------------------------------- */
-void	CBalloonAndSpatulaPickup::renderPickup(DVECTOR *_pos)
 {
 	SpriteBank	*sprites;
-	sFrameHdr	*fh,*fhspat;
+	sFrameHdr	*fh;
-	int			xo1,xo2;
 	int			x,y;
 
 	sprites=CGameScene::getSpriteBank();
-	fh=sprites->getFrameHeader(FRM__BALLOON);
+	fh=sprites->getFrameHeader(FRM__SPATULA);
-	fhspat=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);
+	if(m_glint<=spat_maxglint)
-	x=_pos->vx-(fh->W/2)+bspat_stringendxoff;
+	{
-	y=_pos->vy-(fh->H/2)-(fhspat->H/2)-balloon_height+bspat_stringendyoff;
+		fh=sprites->getFrameHeader(spat_glintFrames[(m_glint>>spat_glintgrowspeed)&0x07]);
-	sprites->printFT4(fh,x+xo1,y,0,0,OTPOS__PICKUP_POS);
+		x=x+spat_gxy.vx;
-setCollisionCentreOffset(xo2,0);
+		y=y+spat_gxy.vy;
-
+		sprites->printRotatedScaledSprite(fh,x,y,4095,4095,m_glintRot,OTPOS__PICKUP_POS-1);
-	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);
 	}
+	*/
+}
+
+
+
+
 
 /*===========================================================================
 end */

source/pickups/pspatula.h

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

source/player/player.cpp

@@ -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
+	// UI
-	if(!isWearingDivingHelmet())
+	char		spatCount[20];
-	{
+	int			x,y;
-		// 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;
 	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);
+		fh=sb->getFrameHeader(FRM__WATER);
-		ft4=CGameScene::getSpriteBank()->printFT4(fh,0,0,0,0,0);
+		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;
+		// Boots
-		sFrameHdr	*fh=CGameScene::getSpriteBank()->getFrameHeader(FRM__SHOE);
+		int			pickupX,pickupY;
-		x=itemX-(fh->W/2);
+		sFrameHdr	*fh=sb->getFrameHeader(FRM__SHOE);
-		y=COLLECTEDITEM_BASEY-(fh->H/2);
+		sb->printFT4(fh,x,y,0,0,0);
-		CGameScene::getSpriteBank()->printFT4(fh,x+2,y+2,0,0,0);
+		sb->printFT4(fh,x+4,y+4,0,0,0);
-		CGameScene::getSpriteBank()->printFT4(fh,x-2,y-2,0,0,0);
+		x+=fh->W+SB_UI_GAP_BETWEEN_ITEMS+4;
-		itemX+=COLLECTEDITEM_GAP;
 	}
+
+	// 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||(getSpatulasHeld()==0&&m_currentMode!=PLAYER_MODE_NET))
-				{
-					if(!ouchThatHurtSoMuchThatImJustGoingToDieNow)
-					{
-						m_health--;
-					}
-					else
-					{
-						m_health=-1;
-					}
-					if(m_health<0)
 				{
 					died=true;
 				}
+				else
+				{
+					if(m_currentMode==PLAYER_MODE_NET)
+					{
+						// Launch net pickup
+						m_currentMode=PLAYER_MODE_FULLUNARMED;
 					}
 					else
 					{
-					if(!ouchThatHurtSoMuchThatImJustGoingToDieNow)
+						// Launch all spatulas!
-					{
+						m_numSpatulasHeld=0;
-						m_healthWaterLevel-=WATERHEALTHPART;
-					}
-					else
-					{
-						m_health=-1;
-					}
-					if(m_healthWaterLevel<0)
-					{
-						died=true;
 					}
 				}
 			}
@@ -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;
 			}
 		}
 	}

source/player/player.h

@@ -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),
+		WATERMINSOAKUPLEVEL=(245<<WATERLEVELSHIFT),					// SB won't auto soak unless water is lower than this
-		WATERMINSOACKUPLEVEL=(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				getIsHelmetFullSoICanStopSoakingUp()	{return m_healthWaterLevel==WATERMAXHEALTH;}
-	int				getIsHealthSoFullThatIDontNeedToSoakUp(){return m_healthWaterLevel>=WATERMINSOACKUPLEVEL;}
+	int				getIsHelmetSoFullThatIDontNeedToSoakUp(){return m_healthWaterLevel>=WATERMINSOAKUPLEVEL;}
 
 	int				isHoldingNet()							{return m_currentMode==PLAYER_MODE_NET;}
 
@@ -444,16 +442,10 @@ public:
 
 	enum
 	{
-		HEALTH_ICONX=40,
+		SB_UI_XBASE=40,
-		HEALTH_ICONY=40,
+		SB_UI_YBASE=40,
-		POWERUPUI_ICONX=400,
+		SB_UI_GAP_FROM_SPAT_COUNT_TO_PICKUPS=50,
-		POWERUPUI_ICONY=40,
+		SB_UI_GAP_BETWEEN_ITEMS=5,
-		POWERUPUI_TEXTX=440,
-		POWERUPUI_TEXTY=37,
-		POWERUPUI_OT=0,
-		COLLECTEDITEM_BASEX=110,
-		COLLECTEDITEM_BASEY=60,
-		COLLECTEDITEM_GAP=40,
 	};
 
 private:

source/player/pmodes.cpp

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

source/player/pmodes.h

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

source/player/psduck.cpp

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