makefile.gaz

@@ -156,15 +156,11 @@ hazard_src :=		hazard \
 fx_src :=			fx \
 					fxbaseanim \
 					fxbasetrail \
+					fxbaseemitter \
 					fxnrgbar \
 					fxjfish \
 					fxfallingtile \
-					fxsteam \
+					fxsteam
-					fxsplash \
-					fxsplashacid \
-					fxsplashlava \
-					fxsplashoil \
-					fxexplode
 
 projectl_src :=		projectl \
 					prnpc \

source/fx/fx.cpp

@@ -15,62 +15,54 @@
 #include	"FX\FXjfish.h"
 #include	"FX\FXBaseTrail.h"
 #include	"FX\FXBaseAnim.h"
+#include	"FX\FXBaseEmitter.h"
+
 #include	"FX\FXfallingTile.h"
 #include	"FX\FXSteam.h"
-#include	"FX\FXSplash.h"
+
-#include	"FX\FXSplashAcid.h"
-#include	"FX\FXSplashLava.h"
-#include	"FX\FXSplashOil.h"
-#include	"FX\FXExplode.h"
 #include	"FX\FXNrgBar.h"
-/* FX
 
-	Jellyfish legs
+/*****************************************************************************/
-	Bubbles (inc acid)
+/*****************************************************************************/
-	Electricity lightning bolt
+/*****************************************************************************/
-	Electricity sheet lightning
+// Anim Data 
-	Electricity Blast
+CFXBaseAnim::sFXData	FXWaterSplashData=
-	Electricity Radial?
+{
-	Electricity projectile
+		ONE,
+		FRM__SPLASH001,FRM__SPLASH006,
+		1,
+		127,127,255
+};
 
-	Shockwave - From falling items
+CFXBaseAnim::sFXData	FXAcidSplashData=
-	Daze stars
+{
-
+		ONE,
-	water/acid/lava/oil
+		FRM__SPLASH001,FRM__SPLASH006,
-		drip
+		1,
-		splashes
+		0,255,0
-
+};
-
+CFXBaseAnim::sFXData	FXLavaSplashData=
-	water/acid/lava.oil
+{
-		drops
+		ONE,
-		waterfall 
+		FRM__SPLASH001,FRM__SPLASH006,
-		waterfall end (splash)
+		1,
-
+		255,0,0
-	fireballs
+};
-
+CFXBaseAnim::sFXData	FXOilSplashData=
-	steam
+{
-	smoke
+		ONE,
-	flames
+		FRM__SPLASH001,FRM__SPLASH006,
-	marsh gas
+		1,
-
+		0,0,0
-	explosions (implode!!)
+};
-
-	Coral debris
-
-***************************
-Level Effect Emitters
-
-	Bubble 
-	Acid drip 
-	Acid Flow
-	steam
-	smoke
-	fireballs
-	flames
-	gas
-
-*/
 
+CFXBaseAnim::sFXData	FXExplodeData=
+{
+		ONE,
+		FRM__EXPLOSION0001,FRM__EXPLOSION0006,
+		1,
+		127,127,127
+};
 
 /*****************************************************************************/
 /*
@@ -79,21 +71,25 @@ void	TestFX(DVECTOR Pos)
 {
 		if (!TestFXPtr)
 		{
+			Pos.vx=256;
+			Pos.vy=128;
 			TestFXPtr=(CFXSteam*)CFX::Create(CFX::FX_TYPE_STEAM,Pos);
 			TestFXPtr->setLife(32);
+			TestFXPtr->setRelativeToMap(false);
 			TestFXPtr=0;
 		}
 		else
 		{
-			TestFXPtr->setDie();
+			TestFXPtr->killFX();
 			TestFXPtr=0;
 		}
 }
 */
 /*****************************************************************************/
+int	FXType=(CFX::FX_TYPE)0;
 void	TestFX(DVECTOR Pos)
 {
-		CFX::Create(CFX::FX_TYPE_SPLASH,Pos);
+		CFX::Create((CFX::FX_TYPE)FXType,Pos);
 //		TestFXPtr->setLife(32);
 }
 
@@ -112,26 +108,27 @@ CFX		*NewFX;
 		case FX_TYPE_STEAM:
 			NewFX=new ("FXSteam") CFXSteam();
 			break;
-		case FX_TYPE_SPLASH:
-			NewFX=new ("FXSplash") CFXSplash();
-			break;
 		case FX_TYPE_SPLASH_WATER:
-			NewFX=new ("FXSplash") CFXSplash();
+			NewFX=new ("FXWaterSplash") CFXBaseAnim();
+			NewFX->setData(&FXWaterSplashData);
 			break;
 		case FX_TYPE_SPLASH_ACID:
-			NewFX=new ("FXSplashAcid") CFXSplashAcid();
+			NewFX=new ("FXAcidSplash") CFXBaseAnim();
+			NewFX->setData(&FXAcidSplashData);
 			break;
 		case FX_TYPE_SPLASH_LAVA:
-			NewFX=new ("FXSplashLava") CFXSplashLava();
+			NewFX=new ("FXLavaSplash") CFXBaseAnim();
+			NewFX->setData(&FXLavaSplashData);
 			break;
 		case FX_TYPE_SPLASH_OIL:
-			NewFX=new ("FXSplashOil") CFXSplashOil();
+			NewFX=new ("FXOilSplash") CFXBaseAnim();
+			NewFX->setData(&FXOilSplashData);
 			break;
 		case FX_TYPE_EXPLODE:
-			NewFX=new ("FXExplode") CFXExplode();
+			NewFX=new ("FXExplode") CFXBaseAnim();
+			NewFX->setData(&FXExplodeData);
 			break;
 
-
 		case FX_TYPE_NRG_BAR:
 			NewFX=new ("NRG Bar") CFXNRGBar();
 			break;
@@ -140,12 +137,10 @@ CFX		*NewFX;
 			NewFX=new ("JellyFish Legs") CFXJellyFishLegs();
 			break;
 
-
+		case FX_TYPE_BUBBLE_WATER:
-		case FX_TYPE_BUBBLE:
+		case FX_TYPE_BUBBLE_ACID:
-			case FX_TYPE_BUBBLE_WATER:
+		case FX_TYPE_BUBBLE_LAVA:
-			case FX_TYPE_BUBBLE_ACID:
+		case FX_TYPE_BUBBLE_OIL:
-			case FX_TYPE_BUBBLE_LAVA:
-			case FX_TYPE_BUBBLE_OIL:
 		case FX_TYPE_LIGHTNING_BOLT:
 		case FX_TYPE_LIGHTNING_SHEET:
 		case FX_TYPE_LIGHTNING_BLAST:
@@ -153,18 +148,19 @@ CFX		*NewFX;
 		case FX_TYPE_LIGHTNING_PROJECTILE:
 		case FX_TYPE_SHOCKWAVE:
 		case FX_TYPE_DAZE:
-		case FX_TYPE_DROP:			
+
-			case FX_TYPE_DROP_WATER:
+		case FX_TYPE_DROP_WATER:
-			case FX_TYPE_DROP_ACID:
+		case FX_TYPE_DROP_ACID:
-			case FX_TYPE_DROP_LAVA:
+		case FX_TYPE_DROP_LAVA:
-			case FX_TYPE_DROP_OIL:
+		case FX_TYPE_DROP_OIL:
 		case FX_TYPE_CASCADE:		
 		case FX_TYPE_CASCADE_SPLASH:	
 		case FX_TYPE_FIREBALL:
-			case FX_TYPE_SMOKE:
+
-			case FX_TYPE_GAS:
+		case FX_TYPE_SMOKE:
+		case FX_TYPE_GAS:
+
 		case FX_TYPE_FLAMES:
-		case FX_TYPE_DEBRIS:
 		
 		default:
 			ASSERT(!"UNKNOWN FX TYPE");
@@ -203,8 +199,15 @@ void	CFX::init()
 {
 		CFXThing::init();
 		OtPos=OTPOS__ACTOR_POS;
+		RelativeToMap=true;
+		Life=-1;	// Set to immortal
+}
 
-		Life=-1;
+/*****************************************************************************/
+void	CFX::init(DVECTOR const &_Pos)
+{
+		init();
+		Pos=_Pos;
 }
 
 /*****************************************************************************/
@@ -217,12 +220,13 @@ void	CFX::shutdown()
 void	CFX::think(int _frames)
 {
 		CFXThing::think(_frames);
+
 		if (Life>0)
 		{
-			Life--;
+			Life-=_frames;
-			if (Life==0 && !DieOut)
+			if (Life<=0)
 			{
-				setDie();
+				killFX();
 			}
 		}
 
@@ -234,3 +238,33 @@ void	CFX::render()
 		CFXThing::render();
 }
 
+/*****************************************************************************/
+bool	CFX::getFXParentPos(DVECTOR &Pos)
+{
+CThing	*Parent=getParent();
+		if (!Parent) return(false);
+
+		if (RelativeToMap)
+		{
+			Pos=Parent->getPos();
+		}
+		else
+		{
+			Pos=getPos();
+		}
+		return(true);
+}
+
+/*****************************************************************************/
+void	CFX::getFXRenderPos(DVECTOR &Pos)
+{
+		if (RelativeToMap)
+		{
+			CFX::render();
+			Pos=getRenderPos();
+		}
+		else
+		{
+			Pos=getPos();
+		}
+}

source/fx/fx.h

@@ -7,6 +7,19 @@
 
 #include "thing/thing.h"
 
+/*****************************************************************************/
+/*
+struct sFXData
+{
+	s16		StartLife;
+	s16		StartScale;
+	s16		StartFrame,EndFrame;
+	DVECTOR	Velocity;
+	u8		R,G,B;
+	u16		Trans;
+
+};
+*/
 /*****************************************************************************/
 class CFX : public CFXThing
 {
@@ -15,28 +28,33 @@ public:
 		{
 			FX_TYPE_JELLYFISH_LEGS,
 			FX_TYPE_FALLINGTILE,
-			FX_TYPE_BUBBLE,
+
-				FX_TYPE_BUBBLE_WATER,
+			FX_TYPE_EXPLODE,
-				FX_TYPE_BUBBLE_ACID,
+
-				FX_TYPE_BUBBLE_LAVA,
+			FX_TYPE_SPLASH_WATER,
-				FX_TYPE_BUBBLE_OIL,
+			FX_TYPE_SPLASH_ACID,
+			FX_TYPE_SPLASH_LAVA,
+			FX_TYPE_SPLASH_OIL,
+
+			FX_TYPE_BUBBLE_WATER,
+			FX_TYPE_BUBBLE_ACID,
+			FX_TYPE_BUBBLE_LAVA,
+			FX_TYPE_BUBBLE_OIL,
+
+			FX_TYPE_DROP_WATER,
+			FX_TYPE_DROP_ACID,
+			FX_TYPE_DROP_LAVA,
+			FX_TYPE_DROP_OIL,
+
 			FX_TYPE_LIGHTNING_BOLT,
 			FX_TYPE_LIGHTNING_SHEET,
 			FX_TYPE_LIGHTNING_BLAST,
 			FX_TYPE_LIGHTNING_RADIAL,
 			FX_TYPE_LIGHTNING_PROJECTILE,
+			
 			FX_TYPE_SHOCKWAVE,
 			FX_TYPE_DAZE,
-			FX_TYPE_DROP,			
+
-				FX_TYPE_DROP_WATER,
-				FX_TYPE_DROP_ACID,
-				FX_TYPE_DROP_LAVA,
-				FX_TYPE_DROP_OIL,
-			FX_TYPE_SPLASH,			
-				FX_TYPE_SPLASH_WATER,
-				FX_TYPE_SPLASH_ACID,
-				FX_TYPE_SPLASH_LAVA,
-				FX_TYPE_SPLASH_OIL,
 			FX_TYPE_CASCADE,		
 			FX_TYPE_CASCADE_SPLASH,	
 			FX_TYPE_FIREBALL,
@@ -44,8 +62,6 @@ public:
 			FX_TYPE_SMOKE,
 			FX_TYPE_GAS,
 			FX_TYPE_FLAMES,
-			FX_TYPE_EXPLODE,
-			FX_TYPE_DEBRIS,
 
 			FX_TYPE_NRG_BAR,
 			FX_TYPE_MAX
@@ -58,24 +74,29 @@ public:
 static	CFX			*Create(const FX_TYPE Type);
 static	CFX			*Create(const FX_TYPE Type,CThing *Parent);
 static	CFX			*Create(const FX_TYPE Type,DVECTOR const &Pos);
+virtual	bool		alwaysThink()								{return(!RelativeToMap);}
 
 virtual void		init();
-virtual void		init(DVECTOR const &Pos){};
+virtual void		init(DVECTOR const &Pos);
 virtual void		shutdown();
 virtual void		think(int _frames);
 virtual void		render();
-
+virtual void		setData(void *Data){};
 virtual int			canCollide()					{return false;}
 virtual	void		SetOtPos(int Ot)				{OtPos=Ot;}
-virtual	void		setDie()						{DieOut=true;}
 virtual	void		setLife(int L)					{Life=L;}
+virtual	void		setRelativeToMap(bool f)		{RelativeToMap=f;}
+
+virtual	void		getFXRenderPos(DVECTOR &Pos);
+virtual	bool		getFXParentPos(DVECTOR &Pos);
+
+virtual	void		killFX()						{setToShutdown();}
 
 protected:
 		s32			OtPos;
-
-		u8			DieOut;
 		s16			Life;
 
+		bool		RelativeToMap;
 };
 
 /*****************************************************************************/

source/fx/fxbaseanim.cpp

@@ -12,16 +12,13 @@
 #include	"game\game.h"
 #include	"FX\FXBaseAnim.h"
 
-
-/*****************************************************************************/
-/*****************************************************************************/
 /*****************************************************************************/
 void	CFXBaseAnim::init(DVECTOR const &_Pos)
 {
-		CFX::init();
+		CFX::init(_Pos);
-		Pos=_Pos;
+		CurrentFrame=0;
-		SetFrame(0,0);
+		CurrentScale=DataPtr->Scale;
-		Scale=ONE;
+		Life=((DataPtr->EndFrame-DataPtr->StartFrame)<<DataPtr->FrameShift)-1;
 }
 
 /*****************************************************************************/
@@ -30,24 +27,14 @@ void	CFXBaseAnim::shutdown()
 		CFX::shutdown();
 }
 
-/*****************************************************************************/
-void	CFXBaseAnim::SetFrame(int Base,int Count,int Shift=0)
-{
-		Frame=0;
-		BaseFrame=Base;
-		FrameShift=Shift;
-		MaxFrame=(Count<<FrameShift)-1;
-}
-
 /*****************************************************************************/
 /*** Think *******************************************************************/
 /*****************************************************************************/
 void	CFXBaseAnim::think(int _frames)
 {
 		CFX::think(_frames);
-
+		CurrentFrame+=_frames;
-		Frame+=_frames;
+		Pos.vy-=4;
-		if (Frame>=MaxFrame) setToShutdown();
 }
 
 /*****************************************************************************/
@@ -55,16 +42,18 @@ void	CFXBaseAnim::think(int _frames)
 /*****************************************************************************/
 void	CFXBaseAnim::render()
 {
-		CFX::render();
+DVECTOR	RenderPos;
+
+		getFXRenderPos(RenderPos);
+		if (!canRender()) return;
 
-		if (!canRender() || isSetToShutdown()) return;
 SpriteBank	*SprBank=CGameScene::getSpriteBank();
-DVECTOR		&RenderPos=getRenderPos();
-int			ThisFrame=Frame>>FrameShift;
 
-POLY_FT4	*Ft4=SprBank->printFT4Scaled(BaseFrame+ThisFrame,RenderPos.vx,RenderPos.vy,0,0,OtPos*0,Scale>>4);
+int			ThisFrame=CurrentFrame>>DataPtr->FrameShift;
+
+POLY_FT4	*Ft4=SprBank->printFT4Scaled(DataPtr->StartFrame+ThisFrame,RenderPos.vx,RenderPos.vy,0,0,OtPos,CurrentScale>>4);
 			Ft4->u1--; Ft4->u3--;
 			Ft4->v2--; Ft4->v3--;
-			setRGB0(Ft4,R,G,B);
+			setShadeTex(Ft4,0);
-
+			setRGB0(Ft4,DataPtr->R,DataPtr->G,DataPtr->B);
 }

source/fx/fxbaseanim.h

@@ -11,21 +11,27 @@
 class CFXBaseAnim : public CFX
 {
 public:
+	struct sFXData
+	{
+		s16		Scale;
+		s16		StartFrame,EndFrame;
+		s16		FrameShift;
+		u8		R,G,B;
+	};
 
 virtual void		init(DVECTOR const &Pos);
 virtual void		shutdown();
 virtual void		think(int _frames);
 virtual void		render();
-virtual	void		SetScale(int S)		{Scale=S;}
+		void		setData(void *Data)		{DataPtr=(sFXData*)Data;}
-virtual	void		SetFrame(int Base,int Count,int Shift=0);
+
+virtual	void		SetScale(int S)			{CurrentScale=S;}
 
 protected:
-		s16			BaseFrame,Frame;
+		sFXData		*DataPtr;
-		s16			MaxFrame;
-		s16			FrameShift;
 
-		s16			Scale;
+		s16			CurrentFrame;
-		u8			R,G,B;
+		s16			CurrentScale;
 };
 
 #endif

source/fx/fxbaseemitter.cpp

@@ -10,64 +10,54 @@
 #include	<sprites.h>
 #include	"level\level.h"
 #include	"game\game.h"
-#include	"FX\FXEmitter.h"
+#include	"FX\FXBaseEmitter.h"
 
 
 /*****************************************************************************/
 /*****************************************************************************/
 /*****************************************************************************/
-void	CFXEmitter::init(DVECTOR const &_Pos)
+void	CFXBaseEmitter::init(DVECTOR const &_Pos)
 {
-		CFX::init();
+		CFX::init(_Pos);
-		Pos=_Pos;
+		Width=Height=16;
-		SetFrame(0,0);
+		CurrentCount=DataPtr->Rate;
-		Scale=ONE;
+		Life=DataPtr->Life;
-		BirthCount=0;
 }
 
 /*****************************************************************************/
-void	CFXEmitter::shutdown()
+void	CFXBaseEmitter::shutdown()
 {
 		CFX::shutdown();
 }
 
-/*****************************************************************************/
-void	CFXEmitter::setUp(int W,int H,int Rate,int Amount,int Life)
-{
-		SetSize(W,H);
-		SetRate(Rate,Amount);
-		SetLife(L);
-}
-
 /*****************************************************************************/
 /*** Think *******************************************************************/
 /*****************************************************************************/
-void	CFXEmitter::think(int _frames)
+void	CFXBaseEmitter::think(int _frames)
 {
 		CFX::think(_frames);
 
-		BirthCount-=_frames;
+		CurrentCount-=_frames;
-		if (BirthCount<=0)
+		if (CurrentCount<=0)
 		{
-			BirthCount=BirthRate;
+			CurrentCount=DataPtr->Rate;
-			Create(_frames);
+			createParticle(_frames);
 		}
-		Life--;
+			
-		if (Life
-
 }
 
 /*****************************************************************************/
-void	CFXEmitter::Create(int _frames)
+void	CFXBaseEmitter::createParticle(int _frames)
 {
-
+		CFX::Create(DataPtr->ParticleType,getPos());
 }
 
 /*****************************************************************************/
 /*** Render ******************************************************************/
 /*****************************************************************************/
-void	CFXEmitter::render()
+void	CFXBaseEmitter::render()
 {
+/*
 DVECTOR	renderPos;
 		if (MapEmitter)
 		{
@@ -77,15 +67,16 @@ DVECTOR	renderPos;
 		}
 		else
 		{
-			renderPos=getPos()
+			renderPos=getPos();
 		}
 
 POLY_F4		*f4;
 		f4=GetPrimF4();
 		setPolyF4(f4);
-		setXYWH(f4,renderPos.vx,renderPos.vy,Width.Height);
+		setXYWH(f4,renderPos.vx,renderPos.vy,Width,Height);
 		setSemiTrans(f4,1);
 		setShadeTex(f4,0);
 		setRGB0(f4,30,40,50);
 		AddPrimToList(f4,0);
+*/
 }

source/fx/fxbaseemitter.h

@@ -2,78 +2,36 @@
 /*** Emitter Base Class ***/
 /**************************/
 
-#ifndef	__FX_FX_EMITTER_HEADER__
+#ifndef	__FX_FX_BASE_EMITTER_HEADER__
-#define __FX_FX_EMITTER_HEADER__
+#define __FX_FX_BASE_EMITTER_HEADER__
 
 #include "fx/fx.h"
 
 /*****************************************************************************/
-class CFXEmitter : public CFX
+class CFXBaseEmitter : public CFX
 {
 public:
+		struct sFXData
+		{
+			u16				Rate,Amount;
+			u16				Life;
+			CFX::FX_TYPE	ParticleType;
+		};
 
 virtual void		init(DVECTOR const &Pos);
 virtual void		shutdown();
 virtual void		think(int _frames);
 virtual void		render();
+		void		setData(void *Data)				{DataPtr=(sFXData*)Data;}
 
-virtual	void		setUp(int W,int H,int Rate,int Amount,int Life);
+virtual	void		setSize(int W,int H)			{Width=W; Height=H;}
+virtual	void		createParticle(int _frames);
 
-virtual	void		create(int _frames);
-
-		void		SetSize(int W,int H)			{Width=W; Height=H;}
-		void		SetRate(int Rate,int Amount)	{BirthRate=Rate; BirthAmount=Amount;}
-		void		SetLife(int L)					{Life=L;}
 
 protected:
+		sFXData		*DataPtr;
 		s16			Width,Height;
-		s16			BirthRate,BirthAmount;
+		s16			CurrentCount;
-		s16			BirthCount;
-		s16			Life;
-		bool		MapEmitter;
 };
 
 #endif
-/*
-typedef struct
-{
-	int			m_x,m_y,m_w,m_h;				// Size and position of emitter
-	s16			m_birthRate,m_birthAmount;		// birthAmount bubicles born every birthRate frames
-	s16			m_life;							// -1 for infinite life
-	s16			m_applyMapOffset;				// Is bubicle position relative to the map or not?
-
-	BubicleData	m_bubicleBase;
-	BubicleData	m_bubicleRange;
-} BubicleEmitterData;
-
-class CBubicleEmitter
-{
-public:
-	void		kill();
-	void		setPos(int _x,int _y);
-	void		setSize(int _w,int _h);
-	void		setPosAndSize(int _x,int _y,int _w,int _h)			{setPos(_x,_y);setSize(_w,_h);}
-
-	int			isActive()											{return m_active;}
-
-
-private:
-				CBubicleEmitter()									{;}
-				
-	void		create();
-	void		init(BubicleEmitterData *_init);
-	
-	void		think(int _frames);
-#ifdef SHOW_BUBICLE_EMITTERS
-	void		render();
-#endif
-	
-
-	u8					m_active;
-	BubicleEmitterData	m_data;
-	int					m_frameCount;
-	s16					m_spawnFrameCount;
-
-friend class CBubicleFactory;
-};
-*/

source/fx/fxbasetrail.cpp

@@ -23,7 +23,6 @@ void	CFXBaseTrail::init(DVECTOR const &_Pos)
 		Pos=_Pos;
 		HeadIdx=0;
 		ListCount=0;
-		DieOut=0;
 }
 
 /*****************************************************************************/
@@ -37,11 +36,12 @@ void	CFXBaseTrail::shutdown()
 /*****************************************************************************/
 void	CFXBaseTrail::think(int _frames)
 {
-CThing	*Parent=getParent();
+DVECTOR	Pos;
+bool	hasParent=getFXParentPos(Pos);
 
-		if (Parent)
+		if (hasParent)
 		{
-			this->setPos(Parent->getPos());
+			setPos(Pos);
 		}
 }
 
@@ -61,11 +61,12 @@ CFXBaseTrail::sList	&CFXBaseTrail::moveHead()
 
 void	CFXBaseTrail::render()
 {
-		CFX::render();
+DVECTOR	RenderPos;
+
+		getFXRenderPos(RenderPos);
 
 		if (canRender())
 		{
-			DVECTOR	RenderPos=getRenderPos();
 			SpriteBank	*SprBank=CGameScene::getSpriteBank();
 			int		ThisIdx=HeadIdx;
 			int		StartY=RenderPos.vy;

source/fx/fxbasetrail.h

@@ -11,6 +11,14 @@
 class CFXBaseTrail : public CFX
 {
 public:
+		struct sFXData
+		{
+			s16		Scale;
+			s16		StartFrame,EndFrame;
+			s16		FrameShift;
+			u8		R,G,B;
+		};
+
 		struct	sList
 		{
 			u16		Frame;

source/fx/fxfallingtile.cpp

@@ -14,7 +14,6 @@
 
 
 /*****************************************************************************/
-int		TT=1;
 const int		FallingTile_DefVY=-2;
 const int		FallingTile_DefLife=32;
 
@@ -35,8 +34,6 @@ sLevelHdr	*LevelHdr=CLevel::getLevelHdr();
 		Velocity.vx=getRndRange(7)-4;
 		Velocity.vy=FallingTile_DefVY;
 		Life=FallingTile_DefLife;
-		Tile=TT++;
-
 }
 
 /*****************************************************************************/
@@ -54,8 +51,6 @@ void	CFXFallingTile::think(int _frames)
 		Pos.vx+=Velocity.vx;
 		Pos.vy+=Velocity.vy;
 		Velocity.vy++;
-		Life--;
-		if (!Life) setToShutdown();
 }
 
 /*****************************************************************************/
@@ -68,7 +63,7 @@ void	CFXFallingTile::render()
 {
 		CFX::render();
 
-		if (!canRender() && Life) return;
+		if (!canRender()) return;
 
 u8			*PrimPtr=GetPrimPtr();
 POLY_FT3	*TPrimPtr=(POLY_FT3*)PrimPtr;

source/fx/fxfallingtile.h

@@ -20,7 +20,6 @@ virtual void		render();
 protected:
 
 		u16			Tile;
-		u16			Life;
 		DVECTOR		Velocity;
 
 		sTile3d		*TileBank3d;

source/fx/fxsteam.cpp

@@ -48,9 +48,9 @@ void	CFXSteam::SetSize(int Size)
 }
 
 /*****************************************************************************/
-void	CFXSteam::setDie()
+void	CFXSteam::killFX()
 {
-		CFXBaseTrail::setDie();
+		DieOut=true;
 		for (int i=0; i<LIST_SIZE; i++)
 		{ // Set drift off
 			sList	&ThisElem=List[i];

source/fx/fxsteam.h

@@ -14,7 +14,7 @@ public:
 virtual void		init(DVECTOR const &Pos);
 virtual void		shutdown();
 virtual void		think(int _frames);
-virtual	void		setDie();
+virtual	void		killFX();
 
 		void		SetSize(int Size);
 
@@ -22,6 +22,7 @@ protected:
 		DVECTOR		BaseVel;
 		s16			ScaleInc;
 		s16			ShadeDec;
+		bool		DieOut;
 
 };