Originally posted by Tarviathun
So how many of you have your "first" game or at least one you look on with loving memory?

// ACTOR.CPP
// Description: Implements Actor and ActorManager classes.
// Author: Nigel Atkinson.
// Enviroment: Borland C++ 3.1, DOS 6.2 386SX 4MB RAM
// Revision History:
// 20 May 1998 Rev 1.0 First working incarnation, from scratch.
// 17 Nov 1999 Ported to DJGPP / Allegro 3.1

#include "Actor.h"
#include "Frames.h"
#include "data.h"

// Actors
#include "Frog.h"
#include "Jill.h"
#include "Water.h"

void Actor::Update()
{
(this->*nextAction)();
}

void Actor::UpdateFrame()
{
frameCount--;
if( frameCount == 0)
{
currentFrame = frames[currentFrame].next;
frameCount = frames[currentFrame].frameCount;
if( frames[currentFrame].sound )
{
play_sample((SAMPLE *)soundfx[frames[currentFrame].sound].dat,
255,128,1000,0);
}
}
}

// Manager functions for editor and loading saving.
void Actor::Loader( FILE *fp ) // Loads from fp
{
return;
}

void Actor::Saver( FILE *fp ) // Saves to fp
{
return;
}

char *Actor::Name() // Returns name for menu
{
return "Actor";
}

int Actor::ID() // Returns numeric id for loading and saving by manager
{
return ACTOR_ID;
}

int Actor::Dialog() // Displays a dialog to change actors properties (in editor)
{
return 0;
}

void ActorManager::InsertActor( Actor *newActor )
{
newActor->nextActor = firstActor;
newActor->prevActor = NULL;

if( firstActor )
firstActor->prevActor = newActor;

firstActor = newActor;

if( lastActor == NULL )
lastActor = newActor;

return;
}

void ActorManager::DeleteActor( Actor *delActor )
{
Actor *iterActor;

for( iterActor = firstActor; iterActor; iterActor = iterActor->nextActor )
if( iterActor == delActor )
break;

if( iterActor )
{
if( iterActor == firstActor )
firstActor = firstActor->nextActor;

if( iterActor == lastActor )
lastActor = lastActor->prevActor;

if( iterActor->prevActor )
iterActor->prevActor->nextActor = iterActor->nextActor;

if( iterActor->nextActor )
iterActor->nextActor->prevActor = iterActor->prevActor;

delete iterActor;
}
}

int ActorManager::LoadActors( FILE *fp, int numActors )
{
int id;
Actor *newactor;

while( numActors-- )
{
if( fread( &id, sizeof(id), 1, fp ) != 1)
{
return -1;
}

switch( id )
{
// Note we dont have any plain actors, only desendaints
case FROG_ID:
newactor = new Frog;
break;
case JILL_ID:
newactor = new Jill;
break;
case WATER_ID:
newactor = new Water;
break;

// Add new actor types here, and include there header file.
default:
newactor = NULL;
break;
}

if( !newactor )
return -1;

newactor->Loader(fp); // New actor knows how much data to load for itself.

InsertActor( newactor );
}

return 0;
}

void ActorManager::ShowAll()
{
Actor *iterActor;

for( iterActor = firstActor; iterActor; iterActor = iterActor->nextActor )
iterActor->Show();
}

void ActorManager::UpdateAll()
{
Actor *iterActor;

iterActor = firstActor;

while( iterActor )
{
if( iterActor->state == DELETED )
{
Actor *deleteMe = iterActor;

// Move iteration ptr onwards so we don't end up with a wild ptr
iterActor = iterActor->nextActor;

DeleteActor( deleteMe );
}
else
{
iterActor->Update();
iterActor = iterActor->nextActor;
}
}
}

void ActorManager::HideAll()
{
Actor *iterActor;

for( iterActor = lastActor; iterActor; iterActor = iterActor->prevActor )
iterActor->Hide();
}

void ActorManager::DeleteAll()
{
while( firstActor )
DeleteActor( firstActor );
}

ActorManager::~ActorManager()
{
DeleteAll();
}

int ActorManager::CountAreaHits( int x, int y, int w, int d )
{
Actor *iterActor;
int count = 0;
int x2 = x + w;
int y2 = y + d;

// Loop trough each actor and prove that actor hasn't hit rather
// than hit. Easier coding that way.

for( iterActor = lastActor; iterActor; iterActor = iterActor->prevActor )
{
if( iterActor->x > x2 iterActor->y > y2 )
continue; // Totally above or to the left.
if( iterActor->x+iterActor->width < x )
continue; // Totally to the right
if( iterActor->y+iterActor->height < y )
continue; // Totally below

count++;
}

return count;
}

Actor *ActorManager::GetActorHit( int x, int y, int w, int d, Actor *notme )
{
Actor *iterActor;
int x2 = x + w;
int y2 = y + d;
int hit = 0;
int stop = 0;

// Loop trough each actor and prove that actor hasn't hit rather
// than hit. Easier coding that way.

iterActor = lastActor;
while( iterActor && !stop )
{
hit = 1;
if( iterActor == notme )
{
hit = 0; // Of course we hit ourselves!!! Why state the obvious?
goto skippy;
}

if( iterActor->state == DORMANT )
{
hit = 0;
goto skippy;
}
if( iterActor->x > x2 iterActor->y > y2 )
{
hit = 0; // Totally above or to the left.
goto skippy;
}
if( iterActor->x+iterActor->width < x )
{
hit = 0; // Totally to the right
goto skippy;
}
if( iterActor->y+iterActor->height < y )
hit = 0; // Totally below

skippy:

if( !hit )
iterActor = iterActor->prevActor;
else
stop = 1;
}

if( hit )
return iterActor;
else
return NULL;
}

#if 0

int main(void)
{
// Lets test out these classes.
ActorManager *actorMgr = new ActorManager;
Actor *p;

actorMgr->InsertActor( new Actor );
actorMgr->InsertActor( p = new Actor );
actorMgr->InsertActor( new Actor );

actorMgr->UpdateAll();
actorMgr->HideAll();

p->Die();
actorMgr->UpdateAll();
actorMgr->HideAll();

delete actorMgr;

return 0;
}

#endif