SBSPSS/source/thing/thing.cpp

/*=========================================================================

	thing.cpp

	Author:		PKG
	Created:
	Project:	Spongebob
	Purpose:

	Copyright (c) 2001 Climax Development Ltd

===========================================================================*/

#define	USE_FREE_LIST
/*----------------------------------------------------------------------
	Includes
	-------- */

#include 	"system\vid.h"
#include "thing\thing.h"

#ifndef	__PLAYER_PLAYER_H__
#include "player\player.h"
#endif

#ifndef __GAME_GAME_H__
#include "game\game.h"
#endif

#ifndef	__UTILS_HEADER__
#include	"utils\utils.h"
#endif

#include "level\level.h"

// Needed for freelist table :o(
#include	"pickups\pickup.h"
#include	"platform\platform.h"
#include	"projectl\projectl.h"
#include	"enemy\npc.h"
#include	"friend\friend.h"
#include	"triggers\trigger.h"
#include	"fx\fx.h"

#ifndef __FRIEND_FRIEND_H__
#include "friend\friend.h"
#endif

#ifndef __FRIEND_FGARY_H__
#include "friend\fgary.h"
#endif

#ifndef __HAZARD_HRWEIGHT_H__
#include "hazard\hrweight.h"
#endif

#ifndef __HAZARD_HPSWITCH_H__
#include "hazard\hpswitch.h"
#endif

#ifndef __TRIGGERS_TGARYGO_H__
#include "triggers\tgarygo.h"
#endif

#ifndef __PLATFORM_PFBLOCK_H__
#include "platform\pfblock.h"
#endif

/*	Std Lib
	------- */

/*	Data
	---- */

/*----------------------------------------------------------------------
	Tyepdefs && Defines
	------------------- */

/*----------------------------------------------------------------------
	Structure defintions
	-------------------- */

/*----------------------------------------------------------------------
	Function Prototypes
	------------------- */

/*----------------------------------------------------------------------
	Vars
	---- */

static const int	s_RenderBBoxX0=-32;
static const int	s_RenderBBoxX1=INGAME_SCREENW+32;
static const int	s_RenderBBoxY0=-16;
static const int	s_RenderBBoxY1=INGAME_SCREENH+16;
static const int	s_ThinkBBoxX0=0-(INGAME_SCREENW/2);
static const int	s_ThinkBBoxX1=INGAME_SCREENW+(INGAME_SCREENW/2);
static const int	s_ThinkBBoxY0=0-(INGAME_SCREENH/2);
static const int	s_ThinkBBoxY1=INGAME_SCREENW+(INGAME_SCREENH/2);

CThing			*CThingManager::s_thingLists[CThing::MAX_TYPE];
CThing			*CThingManager::s_CollisionLists[CThing::MAX_TYPE];
int				CThingManager::s_initialised=false;
sBBox			CThingManager::m_RenderBBox;
sBBox			CThingManager::m_ThinkBBox;
DVECTOR			CThingManager::MapWH,CThingManager::MapWH16;

#ifdef	USE_FREE_LIST
CThing			**CThingManager::s_FreeList[CThing::MAX_TYPE];
int				FreeListCount=0;

struct	sFreeListTable
{
	u16	Type;
	u16	Count;
};

static const sFreeListTable	FreeListTable[]=
{
/* 0*/	{CThing::TYPE_PICKUP			,CBasePickup::MAX_SUBTYPE},
/* 1*/	{CThing::TYPE_PLATFORM			,CNpcPlatform::MAX_SUBTYPE},
/* 2*/	{CThing::TYPE_PLAYER			,CPlayerThing::MAX_SUBTYPE},
/* 3*/	{CThing::TYPE_PLAYERPROJECTILE	,CPlayerProjectile::MAX_SUBTYPE},
/* 4*/	{CThing::TYPE_NPC				,CNpcFriend::MAX_SUBTYPE},
/* 5*/	{CThing::TYPE_ENEMY				,CNpcEnemy::MAX_SUBTYPE},
/* 6*/	{CThing::TYPE_ENEMYPROJECTILE	,CProjectile::MAX_SUBTYPE},
/* 7*/	{CThing::TYPE_TRIGGER			,CTrigger::MAX_SUBTYPE},
/* 8*/	{CThing::TYPE_HAZARD			,CNpcHazard::MAX_SUBTYPE},
/* 9*/	{CThing::TYPE_FX				,CFX::MAX_SUBTYPE},
};
static const	int	FreeListTableSize=sizeof(FreeListTable)/sizeof(sFreeListTable);
#endif
/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
void		CThingManager::init()
{
	ASSERT(!s_initialised);
	initList(s_thingLists);
	initList(s_CollisionLists);
	initFreeList();
	s_initialised=true;
}

/************************************************************************/
void		CThingManager::setMapWH(DVECTOR const &WH)
{
	MapWH=WH;
	MapWH16.vx=MapWH.vx*16;
	MapWH16.vy=MapWH.vy*16;
}
/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
void		CThingManager::shutdown()
{
	int		i;
	CThing	*thing;

	ASSERT(s_initialised);
	for(i=0;i<CThing::MAX_TYPE;i++)
	{
		while(s_thingLists[i])
		{
			thing=s_thingLists[i];
			thing->shutdown();
			DeleteThing(thing);
		}
	}
	s_initialised=false;
	shutdownFreeList();
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
void		CThingManager::initList(CThing **List)
{
int		i;

		for(i=0 ;i<CThing::MAX_TYPE; i++)
		{
			List[i]=NULL;
		}
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
void		CThingManager::killAllThingsForRespawn()
{
	int		i;

	ASSERT(s_initialised);
	for(i=0;i<CThing::MAX_TYPE;i++)
	{
		// Hey - it's not optimal in speed, but it's vaguely funny :)
		// ( and anyway.. it probly *is* optimal in size.. )
		CThing	*thing;
		thing=s_thingLists[i];
		while(thing)
		{
			if(thing->dontKillDuringLevelRespawn())
			{
				thing=thing->m_nextListThing;
			}
			else
			{
				thing->shutdown();
				DeleteThing(thing);
				thing=s_thingLists[i];
			}
		}
	}
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
void		CThingManager::initAllThings()
{
	for(int	i=0; i<CThing::MAX_TYPE; i++)
	{
		CThing	*thing=s_thingLists[i];
		while(thing)
		{
			thing->updateCollisionArea();
			thing=thing->m_nextListThing;
		}
	}
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */

void		CThingManager::matchPressureSwitches()
{
	CNpcHazard *hazard;

	hazard = (CNpcHazard *) s_thingLists[CThing::TYPE_HAZARD];

	while( hazard )
	{
		if ( hazard->getThingSubType() == CNpcHazard::NPC_PRESSURE_SWITCH_HAZARD )
		{
			CNpcPressureSwitchHazard *switchHazard = (CNpcPressureSwitchHazard *) hazard;

			DVECTOR triggerPos = switchHazard->getTriggerPos();

			CNpcPlatform *platform;

			platform = (CNpcPlatform *) s_thingLists[CThing::TYPE_PLATFORM];

			while( platform )
			{
				if ( platform->getThingSubType() == CNpcPlatform::NPC_TRAPDOOR_PLATFORM )
				{
					CNpcTrapdoorPlatform *trapdoor = (CNpcTrapdoorPlatform *) platform;

					DVECTOR testPos = trapdoor->getTriggerPos();

					if ( testPos.vx == triggerPos.vx && testPos.vy == triggerPos.vy )
					{
						switchHazard->linkToPlatform( trapdoor );
					}
				}

				platform = (CNpcPlatform *) platform->m_nextListThing;
			}
		}

		hazard = (CNpcHazard *) hazard->m_nextListThing;
	}
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */

void		CThingManager::matchWheelsAndWeights()
{
	CNpcHazard *hazard1;
	CNpcHazard *hazard2;

	hazard1 = (CNpcHazard *) s_thingLists[CThing::TYPE_HAZARD];

	while( hazard1 )
	{
		if ( hazard1->getThingSubType() == CNpcHazard::NPC_RISING_WEIGHT_HAZARD )
		{
			CNpcRisingWeightHazard *weight = (CNpcRisingWeightHazard *) hazard1;
			DVECTOR wheelPos = weight->getWheelPos();

			hazard2 = (CNpcHazard *) s_thingLists[CThing::TYPE_HAZARD];

			while( hazard2 )
			{
				if ( hazard2->getThingSubType() == CNpcHazard::NPC_RISING_WEIGHT_WHEEL_HAZARD )
				{
					CNpcRisingWeightWheelHazard *wheel = (CNpcRisingWeightWheelHazard *) hazard2;

					DVECTOR testPos = wheel->getWheelPos();

					if ( testPos.vx == wheelPos.vx && testPos.vy == wheelPos.vy )
					{
						wheel->linkToWeight( weight );
						weight->linkToWheel( wheel );
					}
				}

				hazard2 = (CNpcHazard *) hazard2->m_nextListThing;
			}
		}

		hazard1 = (CNpcHazard *) hazard1->m_nextListThing;
	}
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */

void		CThingManager::matchGaryTriggers()
{
	CNpcFriend *friendNpc;

	friendNpc = (CNpcFriend *) s_thingLists[CThing::TYPE_NPC];

	while( friendNpc )
	{
		if ( friendNpc->getThingSubType() == CNpcFriend::NPC_FRIEND_GARY )
		{
			CNpcGaryFriend *gary = (CNpcGaryFriend *) friendNpc;

			DVECTOR triggerPos = gary->getTriggerPos();

			CTrigger *trigger;

			trigger = (CTrigger *) s_thingLists[CThing::TYPE_TRIGGER];

			while( trigger )
			{
				if ( trigger->getThingSubType() == CTrigger::TRIGGER_GARY_START )
				{
					CGaryStartTrigger *garyTrigger = (CGaryStartTrigger *) trigger;

					DVECTOR testPos = garyTrigger->getPos();
					testPos.vx >>= 4;
					testPos.vy >>= 4;

					if ( testPos.vx == triggerPos.vx && testPos.vy == triggerPos.vy )
					{
						garyTrigger->setGary( gary );
					}
				}

				trigger = (CTrigger *) trigger->m_nextListThing;
			}
		}

		friendNpc = (CNpcFriend *) friendNpc->m_nextListThing;
	}
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */

void		CThingManager::shakePlatformLoose()
{
	CNpcPlatform *platform;

	int platformCount = getRnd() % 30;

	int platformTest = 0;

	while( platformCount )
	{
		platform = (CNpcPlatform *) s_thingLists[CThing::TYPE_PLATFORM];

		while( platform )
		{
			if ( platform->getThingSubType() == CNpcPlatform::NPC_FALLING_BLOCK_PLATFORM )
			{
				platformCount--;
				platformTest++;

				if ( !platformCount )
				{
					CNpcFallingBlockPlatform *block = (CNpcFallingBlockPlatform *) platform;

					block->trigger();

					return;
				}
			}

			platform = (CNpcPlatform *) platform->m_nextListThing;
		}

		if ( !platformTest )
		{
			return;
		}
	}
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */

void		CThingManager::thinkAllThings(int _frames)
{
// Setup Screen BBox's
DVECTOR	const	&CamPos=CLevel::getCameraPos();

	m_ThinkBBox.XMin=s_ThinkBBoxX0+CamPos.vx;
	m_ThinkBBox.XMax=s_ThinkBBoxX1+CamPos.vx;
	m_ThinkBBox.YMin=s_ThinkBBoxY0+CamPos.vy;
	m_ThinkBBox.YMax=s_ThinkBBoxY1+CamPos.vy;

//CLevel	&Lvl=GameScene.GetLevel();
//DVECTOR	const &MapSize=Lvl.getMapSize16();

	int		i;
	CThing	*thing;
	CThing	*thing1,*thing2,*playerThing;

	initList(s_CollisionLists);

	for(i=0; i<CThing::MAX_TYPE; i++)
	{
		thing=s_thingLists[i];
		while(thing)
		{
			// Check If in Thinkable range
			CRECT	const *ThingRect= thing->getThinkBBox();
			int		lastFlag=thing->getThinkFlag()<<1;
			int		Flag=1;
			DVECTOR	const &ThingPos=thing->getPos();

			// Will speed this up - doubt it, not now!!
			if (!thing->allowOffMap() && (ThingPos.vx<0 || ThingPos.vx>=MapWH16.vx || ThingPos.vy<0 || ThingPos.vy>=MapWH16.vy))
			{
				thing->setToShutdown();
//				SYSTEM_DBGMSG("ThingOffMap: T:%i S:%i TXY%i %i, MWH%i %i\n",(int)thing->getThingType(),(int)thing->getThingSubType(),ThingPos.vx,ThingPos.vy,MapWH16.vx,MapWH16.vy);
			}
			else
			{
				if (!thing->alwaysThink())
				{
					if (ThingRect->x2<m_ThinkBBox.XMin || ThingRect->x1>m_ThinkBBox.XMax) Flag=0;
					if (ThingRect->y2<m_ThinkBBox.YMin || ThingRect->y1>m_ThinkBBox.YMax) Flag=0;
				}
				thing->setThinkFlag(Flag);
// Is in think zone
				if (Flag)
				{
					thing->think(_frames);
//					thing->updateCollisionArea();
					if (thing->canCollide())
					{
						CThingManager::addToCollisionList(thing);
					}
				}
				Flag|=lastFlag;
// Handle enter/leave states (not sure of viabilty now)
				switch (Flag)
				{			// Last This
					case 0: // 0    0
						break;
					case 1: // 0    1
	//					thing->enterThinkZone(_frames);
						break;
					case 2: // 1    0
						thing->leftThinkZone(_frames);
						break;
					case 3: // 1    1
						break;
					default:
						ASSERT("Invalid Think State");
				}
/* THIS WILL NOT STAY HERE, THINGS MUST BE INITIALISED CORRECTLY */
				thing->updateCollisionArea();
			}
			thing=thing->m_nextListThing;
		}
	}

	CPlayer *player = GameScene.getPlayer();
	playerThing=s_CollisionLists[CThing::TYPE_PLAYER];

	if (player && playerThing)
	{
		int	playerIsAlive=!player->isDead();

		// Player -> Platform collision
		if(playerIsAlive)
		{
			player->clearPlatform();
			thing1=s_CollisionLists[CThing::TYPE_PLATFORM];
			while(thing1)
			{
				if(thing1->checkCollisionAgainst(playerThing, _frames))
				{
					thing1->collidedWith(playerThing);
				}
				thing1=thing1->m_nextCollisionThing;
			}

			// Player -> Pickup collision
			thing1=s_CollisionLists[CThing::TYPE_PICKUP];
			while(thing1)
			{
				if(thing1->checkCollisionAgainst(playerThing, _frames))
				{
					thing1->collidedWith(playerThing);
				}
				thing1=thing1->m_nextCollisionThing;
			}
		}

		// Friend -> Pickup collision
		thing1=s_CollisionLists[CThing::TYPE_NPC];
		while(thing1)
		{
			thing2=s_CollisionLists[CThing::TYPE_PICKUP];
			while(thing2)
			{
				if(thing2->checkCollisionAgainst(thing1, _frames))
				{
					thing2->collidedWith(thing1);
				}
				thing2=thing2->m_nextCollisionThing;
			}
			thing1=thing1->m_nextCollisionThing;
		}

		// Player -> Enemy collision
		if(playerIsAlive)
		{
			thing1=s_CollisionLists[CThing::TYPE_ENEMY];
			while(thing1)
			{
				if(thing1->checkCollisionAgainst(playerThing, _frames))
				{
					thing1->collidedWith(playerThing);
				}
				thing1=thing1->m_nextCollisionThing;
			}

			// Player -> Effect collision
			thing1=s_CollisionLists[CThing::TYPE_FX];
			while(thing1)
			{
				if(thing1->checkCollisionAgainst(playerThing, _frames))
				{
					thing1->collidedWith(playerThing);
				}
				thing1=thing1->m_nextCollisionThing;
			}

			// Player -> Friend collision
			thing1=s_CollisionLists[CThing::TYPE_NPC];
			while(thing1)
			{
				if(thing1->checkCollisionAgainst(playerThing, _frames))
				{
					thing1->collidedWith(playerThing);
				}
				thing1=thing1->m_nextCollisionThing;
			}

			// Player -> Hazard collision
			thing1=s_CollisionLists[CThing::TYPE_HAZARD];
			while(thing1)
			{
			if(thing1->checkCollisionAgainst(playerThing, _frames))
				{
					thing1->collidedWith(playerThing);
				}
				thing1=thing1->m_nextCollisionThing;
			}

			// Player -> Enemy projectile collision
			thing1=s_CollisionLists[CThing::TYPE_ENEMYPROJECTILE];
			while(thing1)
			{
				if(thing1->checkCollisionAgainst(playerThing, _frames))
				{
					thing1->collidedWith(playerThing);
				}
				thing1=thing1->m_nextCollisionThing;
			}

			// Player -> Trigger collision
			thing1=s_CollisionLists[CThing::TYPE_TRIGGER];
			while(thing1)
			{
				if(thing1->checkCollisionAgainst(playerThing, _frames))
				{
					thing1->collidedWith(playerThing);
				}
				thing1=thing1->m_nextCollisionThing;
			}
		}

		// Friend -> Trigger collision
		thing1=s_CollisionLists[CThing::TYPE_TRIGGER];
		while(thing1)
		{
			thing2=s_CollisionLists[CThing::TYPE_NPC];
			while(thing2)
			{
				if(thing1->checkCollisionAgainst(thing2, _frames))
				{
					thing1->collidedWith(thing2);
				}
				thing2=thing2->m_nextCollisionThing;
			}
			thing1=thing1->m_nextCollisionThing;
		}

		// Enemy -> Trigger collision
		thing1=s_CollisionLists[CThing::TYPE_TRIGGER];
		while(thing1)
		{
			thing2=s_CollisionLists[CThing::TYPE_ENEMY];
			while(thing2)
			{
				if(thing1->checkCollisionAgainst(thing2, _frames))
				{
					thing1->collidedWith(thing2);
				}
				thing2=thing2->m_nextCollisionThing;
			}
			thing1=thing1->m_nextCollisionThing;
		}

		// Enemy -> Player projectile collision
		thing1=s_CollisionLists[CThing::TYPE_PLAYERPROJECTILE];
		while(thing1)
		{
			thing2=s_CollisionLists[CThing::TYPE_ENEMY];
			while(thing2)
			{
				if(thing1->checkCollisionAgainst(thing2, _frames))
				{
					thing1->collidedWith(thing2);
				}
				thing2=thing2->m_nextCollisionThing;
			}
			thing1=thing1->m_nextCollisionThing;
		}

		// Enemy -> Enemy collision
		thing1=s_CollisionLists[CThing::TYPE_ENEMY];
		while(thing1)
		{
			thing2=thing1->m_nextCollisionThing;//s_CollisionLists[CThing::TYPE_ENEMY];

			while(thing2)
			{
				ASSERT(thing1 != thing2 );
//				if ( thing1 != thing2 )
				{
					if (thing1->checkCollisionAgainst( thing2, _frames ) )
					{
						thing1->collidedWith( thing2 );
						//thing2->collidedWith( thing1 );
					}
				}
				thing2 = thing2->m_nextCollisionThing;
			}
			thing1 = thing1->m_nextCollisionThing;
		}

		// Hazard -> Platform collision
		thing1=s_CollisionLists[CThing::TYPE_PLATFORM];
		while(thing1)
		{
			thing2=s_CollisionLists[CThing::TYPE_HAZARD];

			while(thing2)
			{
				if ( thing1 != thing2 )
				{
					if (thing1->checkCollisionAgainst( thing2, _frames ) )
					{
						thing1->collidedWith( thing2 );
						//thing2->collidedWith( thing1 );
					}
				}

				thing2 = thing2->m_nextCollisionThing;
			}

			thing1 = thing1->m_nextCollisionThing;
		}

		// Platform -> Player projectile collision
		thing1=s_CollisionLists[CThing::TYPE_PLATFORM];
		while(thing1)
		{
			thing2=s_CollisionLists[CThing::TYPE_PLAYERPROJECTILE];
			while(thing2)
			{
				if(thing1->checkCollisionAgainst(thing2, _frames))
				{
					thing1->collidedWith(thing2);
				}
				thing2=thing2->m_nextCollisionThing;
			}
			thing1=thing1->m_nextCollisionThing;
		}

		// Trigger -> Player projectile collision
		thing1=s_CollisionLists[CThing::TYPE_PLAYERPROJECTILE];
		while(thing1)
		{
			thing2=s_CollisionLists[CThing::TYPE_TRIGGER];
			while(thing2)
			{
				if(thing1->checkCollisionAgainst(thing2, _frames))
				{
					thing2->collidedWith(thing1);
				}
				thing2=thing2->m_nextCollisionThing;
			}
			thing1=thing1->m_nextCollisionThing;
		}

		// Hazard -> Player projectile collision
		thing1=s_CollisionLists[CThing::TYPE_PLAYERPROJECTILE];
		while(thing1)
		{
			thing2=s_CollisionLists[CThing::TYPE_HAZARD];
			while(thing2)
			{
				if(thing1->checkCollisionAgainst(thing2, _frames))
				{
					thing2->collidedWith(thing1);
				}
				thing2=thing2->m_nextCollisionThing;
			}
			thing1=thing1->m_nextCollisionThing;
		}

		// Friendly npc -> Platform projectile collision - first clear platforms

		CNpcFriend *friendNpc = (CNpcFriend *) s_CollisionLists[CThing::TYPE_NPC];
		while( friendNpc )
		{
			friendNpc->clearPlatform();
			friendNpc = (CNpcFriend *) friendNpc->m_nextCollisionThing;
		}

		// now detect new platform

		thing1=s_CollisionLists[CThing::TYPE_PLATFORM];
		while(thing1)
		{
			thing2=s_CollisionLists[CThing::TYPE_NPC];
			while(thing2)
			{
				if(thing1->checkCollisionAgainst(thing2, _frames))
				{
					thing1->collidedWith(thing2);
				}
				thing2=thing2->m_nextCollisionThing;
			}
			thing1=thing1->m_nextCollisionThing;
		}

		// gary collision with hazards

		thing2=s_CollisionLists[CThing::TYPE_NPC];
		while(thing2)
		{
			if ( thing2->getThingSubType() == CNpcFriend::NPC_FRIEND_GARY )
			{
				thing1=s_CollisionLists[CThing::TYPE_HAZARD];
				while(thing1)
				{
					if(thing1->checkCollisionAgainst(thing2, _frames))
					{
						thing1->collidedWith(thing2);
					}
					thing1=thing1->m_nextCollisionThing;
				}
			}
			thing2=thing2->m_nextCollisionThing;
		}

		player->detectHazardousSurface();
	}
// Shut emm down, sh sh shut em down, we shutem down
	for(i=0;i<CThing::MAX_TYPE;i++)
	{
		thing=s_thingLists[i];
		CThing	*nextThing = thing;
		while(thing)
		{
			nextThing=thing->m_nextListThing;

			if ( thing->isSetToShutdown() )
			{
				thing->shutdown();
				DeleteThing(thing);
			}

			thing = nextThing;
		}
	}
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
void		CThingManager::renderAllThings()
{
// Setup Screen BBox's
DVECTOR	const	&CamPos=CLevel::getCameraPos();

	m_RenderBBox.XMin=s_RenderBBoxX0+CamPos.vx;
	m_RenderBBox.XMax=s_RenderBBoxX1+CamPos.vx;
	m_RenderBBox.YMin=s_RenderBBoxY0+CamPos.vy;
	m_RenderBBox.YMax=s_RenderBBoxY1+CamPos.vy;


	for(int i=0;i<CThing::MAX_TYPE;i++)
	{
		CThing	*thing=s_thingLists[i];
		while(thing)
		{
			thing->render();
			thing=thing->m_nextListThing;
		}
	}
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
void		CThingManager::processEventAllThings(GAME_EVENT _event,CThing *_sourceThing)
{
	int		i;
	CThing	*thing;

	for(i=0;i<CThing::MAX_TYPE;i++)
	{
		thing=s_thingLists[i];
		while(thing)
		{
			thing->processEvent(_event,_sourceThing);
			thing=thing->m_nextListThing;
		}
	}
}

/*----------------------------------------------------------------------
	Function:
	Purpose:	Searches through a list of things to check for collision against an area.
				The first time this is called, _continue should be false. If no colliding things are found then
				NULL will be returned. If a colliding thing is found then it's address gets returned. To continue
				searching through the list for the next colliding thing, call the function again with _continue set
				to true.
				NB: This function could probly cause weird bugs if not used properly! BE AWARE!
	Params:		*_area		Area to check against
				_type		Type of thing to search for
				_continue	If false then the list is searched from the start, if true then the search continues
							from the last thing that was found ( um.. see above )
	Returns:
  ---------------------------------------------------------------------- */
CThing		*CThingManager::checkCollisionAreaAgainstThings(CRECT *_area,int _type,int _continue)
{
	static CThing	*thing=NULL;

	ASSERT(_type<CThing::MAX_TYPE);

	if(_continue)
	{
		ASSERT(thing);
		thing=thing->m_nextListThing;
	}
	else
	{
		thing=s_thingLists[_type];
	}
	while(thing)
	{
		if(thing->canCollide() && thing->checkCollisionAgainstArea(_area))
		{
			return thing;
		}
		thing=thing->m_nextListThing;
	}

	return NULL;
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
void	CThingManager::addToThingList(CThing *_this)
{
int	Type=_this->getThingType();

	_this->m_nextListThing=s_thingLists[Type];
	s_thingLists[Type]=_this;
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
void	CThingManager::removeFromThingList(CThing *_this)
{
	CThing	*prevThing,*thing;

	prevThing=NULL;
	thing=s_thingLists[_this->getThingType()];
	while(thing!=_this)
	{
		prevThing=thing;
		thing=thing->m_nextListThing;
		ASSERT(thing);	// Not in the list!?!?
	}
	if(prevThing)
	{
		prevThing->m_nextListThing=_this->m_nextListThing;
	}
	else
	{
		s_thingLists[_this->getThingType()]=_this->m_nextListThing;
	}
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
void	CThingManager::addToCollisionList(CThing *thing)
{
int	Type=thing->getThingType();

		thing->m_nextCollisionThing=s_CollisionLists[Type];
		s_CollisionLists[Type]=thing;
}

/********************************************************************/
/********************************************************************/
/*** Free List Stuff ************************************************/
/********************************************************************/
/********************************************************************/
void		CThingManager::initFreeList()
{
#ifdef	USE_FREE_LIST
// Make sure no-one is being naughty
		ASSERT(FreeListTableSize==CThing::MAX_TYPE)

		for (int i=0; i<FreeListTableSize; i++)
		{
			sFreeListTable	const &ThisType=FreeListTable[i];
			int	Count=ThisType.Count;
			CThing	**List=(CThing**)MemAlloc(Count*sizeof(CThing**),"ThingCache");
			for (int t=0; t<Count; t++)
			{
				List[t]=0;

			}
			s_FreeList[ThisType.Type]=List;

		}
#endif
}

/********************************************************************/
void	CThingManager::resetFreeList()
{
#ifdef	USE_FREE_LIST
		for (int i=0; i<FreeListTableSize; i++)
		{
			sFreeListTable	const &ThisType=FreeListTable[i];
			int	Count=ThisType.Count;

			CThing	**List=s_FreeList[i];
			for (int t=0; t<Count; t++)
			{
				CThing	*ThisThing=List[t];
				while (ThisThing)
				{
					CThing	*Next=ThisThing->NextFreeThing;
//					ThisThing->destroy();
					delete ThisThing;
					FreeListCount--;
					ThisThing=Next;
				}
				List[t]=0;
			}
		}
#endif
}

/********************************************************************/
void	CThingManager::shutdownFreeList()
{
#ifdef	USE_FREE_LIST
		resetFreeList();
		for (int i=0; i<FreeListTableSize; i++)
		{
			sFreeListTable	const &ThisType=FreeListTable[i];
			MemFree(s_FreeList[ThisType.Type]);
		}
#endif
}

/********************************************************************/
CThing	*CThingManager::GetThing(int Type,int SubType)
{
#ifdef	USE_FREE_LIST
CThing	**List=s_FreeList[Type];
CThing	*Thing=List[SubType];

		ASSERT(Type<CThing::MAX_TYPE);
		ASSERT(SubType<FreeListTable[Type].Count);
		if (Thing)
		{
			List[SubType]=Thing->NextFreeThing;
			Thing->initDef();
			Thing->NextFreeThing=0;
			FreeListCount--;
		}

		return(Thing);
#else
		return(0);
#endif
}

/********************************************************************/
void	CThingManager::DeleteThing(CThing *Thing)
{
#ifdef	USE_FREE_LIST
int		Type=Thing->getThingType();
int		SubType=Thing->getThingSubType();
CThing	**List=s_FreeList[Type];

// Check its been aquired/set correctly

		ASSERT(SubType!=255);

		Thing->NextFreeThing=List[SubType];
		List[SubType]=Thing;
		FreeListCount++;

#else
		delete Thing;
#endif
}

/********************************************************************/
/********************************************************************/
/********************************************************************/
/********************************************************************/
/********************************************************************/
/********************************************************************/

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
void	CThing::init()
{
	ParentThing=NULL;
	NextThing=NULL;
	NextFreeThing=0;
	m_numChildren = 0;

	Pos.vx=Pos.vy=10;
// These need to stay for init
	setCollisionSize(20,20);	// Some temporary defaults.. (pkg)
	setCollisionCentreOffset(0,0);

// Add to thing list
	CThingManager::addToThingList(this);
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
void	CThing::shutdown()
{
	
	if (ParentThing)
	{ // Is child
		ParentThing->removeChild(this);
	}
	else
	{ // Is Parent
		removeAllChild();
	}

	// Remove from thing list
	CThingManager::removeFromThingList(this);
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
void	CThing::think(int _frames)
{
	PosDelta.vx=Pos.vx-PosLast.vx;
	PosDelta.vy=Pos.vy-PosLast.vy;
	PosLast=Pos;
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
#if defined (__USER_paul__) || defined (__USER_charles__)
#define	SHOW_BBOX	1
int showthings=true;
#endif

#if defined (__USER_daveo__)
#define	SHOW_BBOX	1
int showthings=false;
#endif

void	CThing::render()
{
// Check Is Onscreen
CRECT	const	*ThingRect= getRenderBBox();
sBBox			&ScrBBox=CThingManager::getRenderBBox();
DVECTOR	const	&CamPos=CLevel::getCameraPos();

		m_RenderPos.vx = Pos.vx - CamPos.vx;
		m_RenderPos.vy = Pos.vy - CamPos.vy;

// Will speed this up
		m_renderFlag=true;
		if (ThingRect->x2<ScrBBox.XMin || ThingRect->x1>ScrBBox.XMax) m_renderFlag=false;
		if (ThingRect->y2<ScrBBox.YMin || ThingRect->y1>ScrBBox.YMax) m_renderFlag=false;

/***/
#ifdef	SHOW_BBOX
	if(showthings) ShowBBox();
#endif

}

/****************************************************************************************/
bool	CThing::isOnScreen(DVECTOR Pos)
{
// Check Is Onscreen
sBBox			&ScrBBox=CThingManager::getRenderBBox();
DVECTOR	const	&CamPos=CLevel::getCameraPos();

//		Pos.vx-=CamPos.vx;
//		Pos.vy-=CamPos.vy;

		if (Pos.vx<ScrBBox.XMin) return(false);
		if (Pos.vx>ScrBBox.XMax) return(false);
		if (Pos.vy<ScrBBox.YMin) return(false);
		if (Pos.vy>ScrBBox.YMax) return(false);
		return(true);
}

/****************************************************************************************/
void	CThing::calcRenderPos(DVECTOR const &Pos,DVECTOR &renderPos)
{
DVECTOR	const	&CamPos=CLevel::getCameraPos();

		renderPos.vx = Pos.vx - CamPos.vx;
		renderPos.vy = Pos.vy - CamPos.vy;
}

/****************************************************************************************/
#ifdef	SHOW_BBOX
#include "gfx\prim.h"

void	CThing::ShowBBox()
{
	if(showthings)
	{
		DVECTOR	const	&ofs=CLevel::getCameraPos();
		CRECT	area;

		area=getCollisionArea();
		area.x1-=ofs.vx;
		area.y1-=ofs.vy;
		area.x2-=ofs.vx;
		area.y2-=ofs.vy;

		if(area.x1<=511&&area.x2>=0 && area.y1<=255&&area.y2>=0)
		{
			DrawLine(area.x1,area.y1,area.x2,area.y1,255,255,255,0);
			DrawLine(area.x2,area.y1,area.x2,area.y2,255,255,255,0);
			DrawLine(area.x2,area.y2,area.x1,area.y2,255,255,255,0);
			DrawLine(area.x1,area.y2,area.x1,area.y1,255,255,255,0);

			area.x1=Pos.vx-10-ofs.vx;
			area.y1=Pos.vy-10-ofs.vy;
			area.x2=Pos.vx+10-ofs.vx;
			area.y2=Pos.vy+10-ofs.vy;
			DrawLine(area.x1,area.y1,area.x2,area.y2,255,0,0,0);
			DrawLine(area.x2,area.y1,area.x1,area.y2,255,0,0,0);
		}
	}
}
#endif

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
void	CThing::addChild(CThing *Child)
{
CThing	*List=NextThing;

	if ( List )
	{
// Find end of list
		while (List->NextThing)
		{
			List=List->NextThing;
		}
		List->NextThing=Child;
		Child->ParentThing=this;
		m_numChildren++;
	}
	else
	{
// List does not exist, create
		NextThing = Child;
		Child->ParentThing=this;
		m_numChildren++;
	}
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
void	CThing::removeChild(CThing *Child)
{
CThing	*List=NextThing;
CThing	*Last=NULL;

// Find Child
		while ( List != Child && List->NextThing )
		{
			Last = List;
			List = List->NextThing;
		}

// if there are no more links to continue down, the current 'List' must either be the correct item, or the item does not
// exist in the list at all

		ASSERT( List == Child );

		if ( Last )
		{
			Last->NextThing = List->NextThing;
		}
		else
		{
			this->NextThing = List->NextThing;
		}

		m_numChildren--;

		Child->ParentThing=NULL;
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
void	CThing::removeAllChild()
{
CThing	*List=NextThing;

		while (List)
		{
			CThing	*NextThing=List->NextThing;
			List->ParentThing=NULL;
			List->NextThing=NULL;
			List=NextThing;
		}
		NextThing=NULL;

		m_numChildren = 0;
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
void	CThing::deleteAllChild()
{
CThing	*List=NextThing;

		while (List)
		{
			CThing	*NextThing=List->NextThing;
			List->ParentThing=NULL;
			List->NextThing=NULL;
			List->shutdown();
			CThingManager::DeleteThing(List);
			List=NextThing;
		}
		NextThing=NULL;

		m_numChildren = 0;
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
void	CThing::setCollisionSize(int _w,int _h)
{
	m_collisionSize.vx=_w;
	m_collisionSize.vy=_h;
	if(m_collisionSize.vx>m_collisionSize.vy)
	{
		m_collisionRadius=m_collisionSize.vx;
	}
	else
	{
		m_collisionRadius=m_collisionSize.vy;
	}
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
void	CThing::updateCollisionArea()
{
	m_collisionCentre.vx=Pos.vx+m_collisionCentreOffset.vx;
	m_collisionCentre.vy=Pos.vy+m_collisionCentreOffset.vy;
	m_collisionArea.x1=m_collisionCentre.vx-(m_collisionSize.vx/2);
	m_collisionArea.x2=m_collisionArea.x1+m_collisionSize.vx;
	m_collisionArea.y1=m_collisionCentre.vy-(m_collisionSize.vy/2);
	m_collisionArea.y2=m_collisionArea.y1+m_collisionSize.vy;
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
int		CThing::checkCollisionAgainst(CThing *_thisThing, int _frames)
{
//	DVECTOR	pos,thisThingPos;
	int		radius;
	int		collided;

DVECTOR const	&pos=getCollisionCentre();
DVECTOR const	&thisThingPos=_thisThing->getCollisionCentre();

	radius=getCollisionRadius()+_thisThing->getCollisionRadius();
	collided=false;
	if(abs(pos.vx-thisThingPos.vx)<radius && abs(pos.vy-thisThingPos.vy)<radius)
	{
//		CRECT	thisRect,thatRect;

CRECT const &thisRect=getCollisionArea();
CRECT const &thatRect=_thisThing->getCollisionArea();

//		if(((thisRect.x1>=thatRect.x1&&thisRect.x1<=thatRect.x2)||(thisRect.x2>=thatRect.x1&&thisRect.x2<=thatRect.x2)||(thisRect.x1<=thatRect.x1&&thisRect.x2>=thatRect.x2))&&
//		   ((thisRect.y1>=thatRect.y1&&thisRect.y1<=thatRect.y2)||(thisRect.y2>=thatRect.y1&&thisRect.y2<=thatRect.y2)||(thisRect.y1<=thatRect.y1&&thisRect.y2>=thatRect.y2)))
			if (thisRect.x2<thatRect.x1 || thisRect.x1>thatRect.x2) return(false);
			if (thisRect.y2<thatRect.y1 || thisRect.y1>thatRect.y2) return(false);

		{
			collided=true;
		}
	}

	return collided;
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
int		CThing::checkCollisionAgainstArea(CRECT *_rect)
{
//	CRECT	thisRect;
	int		ret;

CRECT const &thisRect=getCollisionArea();
	ret=false;

	if(((thisRect.x1>=_rect->x1&&thisRect.x1<=_rect->x2)||(thisRect.x2>=_rect->x1&&thisRect.x2<=_rect->x2)||(thisRect.x1<=_rect->x1&&thisRect.x2>=_rect->x2))&&
	   ((thisRect.y1>=_rect->y1&&thisRect.y1<=_rect->y2)||(thisRect.y2>=_rect->y1&&thisRect.y2<=_rect->y2)||(thisRect.y1<=_rect->y1&&thisRect.y2>=_rect->y2)))
	{
		ret=true;
	}

	return ret;
}

/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */
void	CThing::processEvent(GAME_EVENT _event,CThing *_sourceThing)
{
	// do nothing by default - ignore event
}


/*----------------------------------------------------------------------
	Function:
	Purpose:
	Params:
	Returns:
  ---------------------------------------------------------------------- */