738 lines
19 KiB
C++
738 lines
19 KiB
C++
//-----------------------------------------------------------------------------
|
|
//
|
|
// $Logfile:: /Quake 2 Engine/Sin/code/game/surface.cpp $
|
|
// $Revision:: 27 $
|
|
// $Author:: Jimdose $
|
|
// $Date:: 12/18/98 11:02p $
|
|
//
|
|
// Copyright (C) 1998 by Ritual Entertainment, Inc.
|
|
// All rights reserved.
|
|
//
|
|
// This source is may not be distributed and/or modified without
|
|
// expressly written permission by Ritual Entertainment, Inc.
|
|
//
|
|
// $Log:: /Quake 2 Engine/Sin/code/game/surface.cpp $
|
|
//
|
|
// 27 12/18/98 11:02p Jimdose
|
|
// removed include of qcommon.h
|
|
//
|
|
// 26 10/20/98 8:26p Markd
|
|
// Added Attacker to DamageSurface stuff
|
|
//
|
|
// 25 10/15/98 7:33p Markd
|
|
// bullet proofed surface not found stuff
|
|
//
|
|
// 24 10/15/98 4:37p Markd
|
|
// fixed damaged surface stuff
|
|
//
|
|
// 23 10/13/98 9:01p Markd
|
|
// Fixed bug in TransOn TransOff
|
|
//
|
|
// 22 10/09/98 4:54p Markd
|
|
// Added threading abilities from surfaces
|
|
//
|
|
// 21 10/06/98 9:17p Aldie
|
|
// Removed SURF_STRONG
|
|
//
|
|
// 20 10/05/98 11:29p Markd
|
|
// Put in MadeBreakingSound
|
|
//
|
|
// 19 10/05/98 11:01p Jimdose
|
|
// Added destructor
|
|
// Made Reset free up all surfaces
|
|
//
|
|
// 18 9/21/98 4:21p Markd
|
|
// Put in archive functions and rewrote all archive routines
|
|
//
|
|
// 17 9/19/98 1:56p Markd
|
|
// made hard errors event errors or warnings
|
|
//
|
|
// 16 9/18/98 8:14p Markd
|
|
// rewrote surface system so that surfaces are now damaged by surface name
|
|
// instead of by surfinfo
|
|
//
|
|
// 15 8/31/98 7:45p Aldie
|
|
// Updated surface data structure and removed surfinfo field
|
|
//
|
|
// 14 8/24/98 12:45p Markd
|
|
// Renamed damage_frame to frame
|
|
//
|
|
// 13 8/22/98 12:06a Aldie
|
|
// New surface manager implemented
|
|
//
|
|
// 12 6/08/98 7:22p Aldie
|
|
// Put damage command back in
|
|
//
|
|
// 11 5/25/98 2:28p Aldie
|
|
// Fixed issues with not loading game dll
|
|
//
|
|
// 10 5/24/98 9:00p Jimdose
|
|
// made CreateSurface us G_CopyString to allocate a string
|
|
//
|
|
// 9 5/24/98 4:48p Jimdose
|
|
// Made char *'s const
|
|
//
|
|
// 8 5/23/98 12:53p Aldie
|
|
// Updated surfaces networking.
|
|
//
|
|
// 7 5/13/98 4:47p Aldie
|
|
// Update damage surfaces
|
|
//
|
|
// 6 5/05/98 5:35p Aldie
|
|
// Updated damage surfaces
|
|
//
|
|
// 5 5/05/98 3:49p Aldie
|
|
// Fixed some prints.
|
|
//
|
|
// 4 5/05/98 2:43p Aldie
|
|
// Added server side surface states
|
|
//
|
|
// 3 3/24/98 4:56p Jimdose
|
|
// Fixed bug where surface commands were sent with the wrong syntax
|
|
//
|
|
// 2 3/23/98 1:31p Jimdose
|
|
// Revamped event and command system
|
|
//
|
|
// DESCRIPTION:
|
|
// Controls surfaces
|
|
//
|
|
|
|
#include "g_local.h"
|
|
#include "listener.h"
|
|
#include "surface.h"
|
|
#include "misc.h"
|
|
#include "specialfx.h"
|
|
#include <ctype.h>
|
|
|
|
CLASS_DECLARATION( Class, Surface, NULL );
|
|
ResponseDef Surface::Responses[] =
|
|
{
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
|
|
CLASS_DECLARATION( Listener, SurfaceModifier, NULL );
|
|
|
|
Event EV_Surface_TransOn( "transOn" );
|
|
Event EV_Surface_TransOff( "transOff" );
|
|
Event EV_Surface_TransToggle( "transToggle" );
|
|
Event EV_Surface_TransMag( "trans_mag" );
|
|
Event EV_Surface_Translucence( "translucence" );
|
|
Event EV_Surface_Magnitude( "magnitude" );
|
|
Event EV_Surface_Frequency( "frequency" );
|
|
Event EV_Surface_TransAngle( "trans_angle" );
|
|
Event EV_Surface_DamageFrame( "frame" );
|
|
Event EV_Surface_Damage( "damage" );
|
|
|
|
ResponseDef SurfaceModifier::Responses[] =
|
|
{
|
|
{ &EV_Surface_TransOn, ( Response )SurfaceModifier::TranslationOn },
|
|
{ &EV_Surface_TransOff, ( Response )SurfaceModifier::TranslationOff },
|
|
{ &EV_Surface_TransToggle, ( Response )SurfaceModifier::TranslationToggle },
|
|
{ &EV_Surface_TransMag, ( Response )SurfaceModifier::SetTranslationMagnitude },
|
|
{ &EV_Surface_TransAngle, ( Response )SurfaceModifier::SetTranslationAngle },
|
|
{ &EV_Surface_Translucence, ( Response )SurfaceModifier::SetTranslucence },
|
|
{ &EV_Surface_Magnitude, ( Response )SurfaceModifier::SetMagnitude },
|
|
{ &EV_Surface_Frequency, ( Response )SurfaceModifier::SetFrequency },
|
|
{ &EV_Surface_DamageFrame, ( Response )SurfaceModifier::SetDamageFrame },
|
|
{ &EV_Surface_Damage, ( Response )SurfaceModifier::SetDamage },
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
SurfaceModifier surfaceManager;
|
|
|
|
SurfaceModifier::~SurfaceModifier()
|
|
{
|
|
Reset();
|
|
}
|
|
|
|
//==========
|
|
//AddSurface - to the surfaceManager
|
|
//==========
|
|
int SurfaceModifier::AddSurface
|
|
(
|
|
Surface *surf
|
|
)
|
|
{
|
|
int num;
|
|
|
|
num = surfaceList.AddObject( surf );
|
|
return num;
|
|
}
|
|
|
|
|
|
//=============
|
|
//SurfaceExists - returns the number of the surface, 0 if not found.
|
|
//=============
|
|
int SurfaceModifier::SurfaceExists(const char *surf_name)
|
|
{
|
|
int num,i;
|
|
Surface *p;
|
|
|
|
num = surfaceList.NumObjects();
|
|
for( i = 1; i <= num; i++ )
|
|
{
|
|
p = ( Surface * )surfaceList.ObjectAt( i );
|
|
if (!strcmp(p->SurfaceName(),surf_name))
|
|
return p->SurfaceNumber();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//=============
|
|
//GetSurface - returns the surface, NULL if not found.
|
|
//=============
|
|
Surface * SurfaceModifier::GetSurface(const char *surf_name)
|
|
{
|
|
int num,i;
|
|
Surface *p;
|
|
|
|
num = surfaceList.NumObjects();
|
|
for( i = 1; i <= num; i++ )
|
|
{
|
|
p = ( Surface * )surfaceList.ObjectAt( i );
|
|
if (!strcmp(p->SurfaceName(),surf_name))
|
|
return p;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
//=====
|
|
//Reset
|
|
//=====
|
|
void SurfaceModifier::Reset()
|
|
{
|
|
int i;
|
|
int num;
|
|
|
|
num = surfaceList.NumObjects();
|
|
for( i = num; i > 0; i-- )
|
|
{
|
|
delete surfaceList.ObjectAt( i );
|
|
}
|
|
|
|
surfaceList.FreeObjectList();
|
|
}
|
|
|
|
//=============
|
|
//CreateSurface - Creates a server game surface that can be modified through scripts and events
|
|
//=============
|
|
void SurfaceModifier::CreateSurface (const char *surf_name, csurface_t *surfinfo)
|
|
{
|
|
csurface_t *surfptr;
|
|
netsurface_t *netsurf;
|
|
Surface *surf;
|
|
int numframes;
|
|
|
|
globals.num_surfaces++;
|
|
surf = new Surface;
|
|
surf->SetDamage( 0 );
|
|
surf->SetState( 0 );
|
|
surf->SetNumber(globals.num_surfaces);
|
|
surf->SetName(surf_name);
|
|
|
|
if ( ( surfinfo->flags & SURF_WEAK ) && ( surfinfo->flags & SURF_NORMAL ) )
|
|
surf->SetThreshold( STRONG_DAMAGE_VALUE );
|
|
else if ( surfinfo->flags & SURF_WEAK )
|
|
surf->SetThreshold( WEAK_DAMAGE_VALUE );
|
|
else if ( surfinfo->flags & SURF_NORMAL )
|
|
surf->SetThreshold( NORMAL_DAMAGE_VALUE );
|
|
|
|
surfptr = surfinfo;
|
|
numframes = 0;
|
|
while ( surfptr->next )
|
|
{
|
|
numframes++;
|
|
surfptr = surfptr->next;
|
|
if ( numframes > 128 || surfptr == surfinfo )
|
|
{
|
|
gi.dprintf("CreateSurface: Possible infinite animation/damage loop for %s.\n", surf_name );
|
|
break;
|
|
}
|
|
}
|
|
surf->SetNumFrames( numframes );
|
|
surf->SetLightStyle( surfinfo->style );
|
|
|
|
AddSurface(surf);
|
|
netsurf = &g_surfaces[globals.num_surfaces];
|
|
|
|
netsurf->s.name = G_CopyString( surf_name );
|
|
netsurf->inuse = true;
|
|
netsurf->s.number = globals.num_surfaces;
|
|
netsurf->s.groupnumber = surfinfo->groupnumber;
|
|
netsurf->s.trans_mag = surfinfo->trans_mag;
|
|
netsurf->s.trans_angle = surfinfo->trans_angle;
|
|
netsurf->s.translucence = surfinfo->translucence;
|
|
netsurf->s.magnitude = surfinfo->magnitude;
|
|
netsurf->s.frequency = surfinfo->frequency;
|
|
netsurf->s.damage_frame = 0;
|
|
if ( surfinfo->flags & SURF_TRANSLATE )
|
|
netsurf->s.trans_state = true;
|
|
else
|
|
netsurf->s.trans_state = false;
|
|
netsurf->s.changed = true;
|
|
}
|
|
|
|
//==============
|
|
//SetDamageFrame
|
|
//==============
|
|
void SurfaceModifier::SetDamageFrame (Event *ev)
|
|
{
|
|
const char *surf_name;
|
|
netsurface_t *svsurf;
|
|
int num;
|
|
int frame;
|
|
|
|
surf_name = ev->GetString(1);
|
|
if (!(num = SurfaceExists(surf_name)))
|
|
{
|
|
ev->Error("SurfaceModifier::SetDamage", "surface name %s is not found\n", surf_name);
|
|
}
|
|
|
|
svsurf=&g_surfaces[num];
|
|
frame = ev->GetInteger(2);
|
|
if (svsurf->s.damage_frame != frame)
|
|
{
|
|
svsurf->s.changed = true;
|
|
}
|
|
svsurf->s.damage_frame = frame;
|
|
}
|
|
|
|
//============
|
|
//SetFrequency
|
|
//============
|
|
void SurfaceModifier::SetFrequency (Event *ev)
|
|
{
|
|
const char *surf_name;
|
|
netsurface_t *svsurf;
|
|
int num;
|
|
|
|
surf_name = ev->GetString(1);
|
|
if (!(num = SurfaceExists(surf_name)))
|
|
{
|
|
ev->Error("SurfaceModifier::SetFrequency", "surface name %s is not found\n", surf_name);
|
|
}
|
|
|
|
svsurf=&g_surfaces[num];
|
|
svsurf->s.frequency = ev->GetFloat(2);
|
|
svsurf->s.changed = true;
|
|
}
|
|
|
|
//============
|
|
//SetMagnitude
|
|
//============
|
|
void SurfaceModifier::SetMagnitude (Event *ev)
|
|
{
|
|
const char *surf_name;
|
|
netsurface_t *svsurf;
|
|
int num;
|
|
|
|
surf_name = ev->GetString(1);
|
|
if (!(num = SurfaceExists(surf_name)))
|
|
{
|
|
ev->Error("SurfaceModifier::SetMagnitude", "surface name %s is not found\n", surf_name);
|
|
}
|
|
|
|
svsurf=&g_surfaces[num];
|
|
svsurf->s.magnitude = ev->GetFloat(2);
|
|
svsurf->s.changed = true;
|
|
}
|
|
|
|
//===============
|
|
//SetTranslucence
|
|
//===============
|
|
void SurfaceModifier::SetTranslucence (Event *ev)
|
|
{
|
|
const char *surf_name;
|
|
netsurface_t *svsurf;
|
|
int num;
|
|
|
|
surf_name = ev->GetString(1);
|
|
if (!(num = SurfaceExists(surf_name)))
|
|
{
|
|
ev->Error("SurfaceModifier::SetTranslucence", "surface name %s is not found\n", surf_name);
|
|
}
|
|
|
|
svsurf=&g_surfaces[num];
|
|
svsurf->s.translucence = ev->GetFloat(2);
|
|
svsurf->s.changed = true;
|
|
}
|
|
|
|
//===================
|
|
//SetTranslationAngle
|
|
//===================
|
|
void SurfaceModifier::SetTranslationAngle (Event *ev)
|
|
{
|
|
const char *surf_name;
|
|
netsurface_t *svsurf;
|
|
int num;
|
|
|
|
surf_name = ev->GetString(1);
|
|
if (!(num = SurfaceExists(surf_name)))
|
|
{
|
|
ev->Error("SurfaceModifier::SetDamage", "surface name %s is not found\n", surf_name);
|
|
}
|
|
|
|
svsurf=&g_surfaces[num];
|
|
svsurf->s.trans_angle = ev->GetInteger(2);
|
|
svsurf->s.changed = true;
|
|
}
|
|
|
|
//=======================
|
|
//SetTranslationMagnitude
|
|
//=======================
|
|
void SurfaceModifier::SetTranslationMagnitude (Event *ev)
|
|
{
|
|
const char *surf_name;
|
|
netsurface_t *svsurf;
|
|
int num;
|
|
|
|
surf_name = ev->GetString(1);
|
|
if (!(num = SurfaceExists(surf_name)))
|
|
{
|
|
ev->Error("SurfaceModifier::SetTranslationMagnitude", "surface name %s is not found\n", surf_name);
|
|
}
|
|
|
|
svsurf=&g_surfaces[num];
|
|
svsurf->s.trans_mag = ev->GetInteger(2);
|
|
svsurf->s.changed = true;
|
|
}
|
|
|
|
//=================
|
|
//TranslationToggle
|
|
//=================
|
|
void SurfaceModifier::TranslationToggle (Event *ev)
|
|
{
|
|
const char *surf_name;
|
|
netsurface_t *svsurf;
|
|
int num;
|
|
|
|
surf_name = ev->GetString(1);
|
|
if (!(num = SurfaceExists(surf_name)))
|
|
{
|
|
ev->Error("SurfaceModifier::TranslationToggle", "surface name %s is not found\n", surf_name);
|
|
}
|
|
|
|
svsurf=&g_surfaces[num];
|
|
svsurf->s.trans_state = ~svsurf->s.trans_state;
|
|
svsurf->s.changed = true;
|
|
}
|
|
|
|
//=============
|
|
//TranslationOn
|
|
//=============
|
|
void SurfaceModifier::TranslationOn (Event *ev)
|
|
{
|
|
const char *surf_name;
|
|
netsurface_t *svsurf;
|
|
int num;
|
|
|
|
surf_name = ev->GetString(1);
|
|
if (!(num = SurfaceExists(surf_name)))
|
|
{
|
|
ev->Error("SurfaceModifier::TranslationOn", "surface name %s is not found\n", surf_name);
|
|
}
|
|
|
|
svsurf=&g_surfaces[num];
|
|
svsurf->s.trans_state = true;
|
|
svsurf->s.changed = true;
|
|
}
|
|
|
|
//==============
|
|
//TranslationOff
|
|
//==============
|
|
void SurfaceModifier::TranslationOff (Event *ev)
|
|
{
|
|
const char *surf_name;
|
|
netsurface_t *svsurf;
|
|
int num;
|
|
|
|
surf_name = ev->GetString(1);
|
|
if (!(num = SurfaceExists(surf_name)))
|
|
{
|
|
ev->Error("SurfaceModifier::TranslationOff", "surface name %s is not found\n", surf_name);
|
|
}
|
|
|
|
svsurf=&g_surfaces[num];
|
|
svsurf->s.trans_state = false;
|
|
svsurf->s.changed = true;
|
|
}
|
|
|
|
//=========
|
|
//SetDamage
|
|
//=========
|
|
void SurfaceModifier::SetDamage (Event *ev)
|
|
{
|
|
const char *surf_name;
|
|
int num;
|
|
int damage;
|
|
|
|
surf_name = ev->GetString(1);
|
|
if (!(num = SurfaceExists(surf_name)))
|
|
{
|
|
ev->Error("SurfaceModifier::SetDamage", "surface name %s is not found\n", surf_name);
|
|
}
|
|
|
|
damage = ev->GetInteger(2);
|
|
DoDamage( NULL, surf_name, damage );
|
|
}
|
|
|
|
//=========
|
|
//DoDamage
|
|
//=========
|
|
void SurfaceModifier::DoDamage ( trace_t * trace, const char * groupname, float damage, Entity * attacker )
|
|
{
|
|
Surface *surf;
|
|
int frame;
|
|
int total_damage;
|
|
int letter;
|
|
int state;
|
|
int currentstate;
|
|
int numframes;
|
|
int lightstyle;
|
|
qboolean dotrigger;
|
|
qboolean damaged;
|
|
Vector pos;
|
|
Vector dir;
|
|
float surface_damage_threshold;
|
|
|
|
surf = GetSurface( groupname );
|
|
|
|
if (!surf)
|
|
{
|
|
warning("SurfaceModifier::Damage", "surface name %s is not found\n", groupname);
|
|
return;
|
|
}
|
|
|
|
frame = 0;
|
|
if ( trace )
|
|
{
|
|
dir = Vector( trace->dir );
|
|
pos = Vector( trace->endpos ) - dir;
|
|
}
|
|
|
|
// let the ai know
|
|
if ( trace )
|
|
{
|
|
MadeBreakingSound( pos, NULL );
|
|
}
|
|
|
|
surface_damage_threshold = surf->Threshold();
|
|
|
|
// get the current damage of this surface
|
|
total_damage = surf->Damage();
|
|
// see if it has been damaged past the threshold before
|
|
damaged = (total_damage > surface_damage_threshold);
|
|
// get the current state
|
|
currentstate = surf->State();
|
|
// get the number of frames
|
|
numframes = surf->NumFrames();
|
|
// get the light style
|
|
lightstyle = surf->LightStyle();
|
|
// add the damage and the new damage
|
|
total_damage += damage;
|
|
// store the damage back into the surface
|
|
surf->SetDamage( total_damage );
|
|
// init the state to -1 so that it gets put to 0 only if the threshold is exceeded
|
|
state = -1;
|
|
while (total_damage > surface_damage_threshold)
|
|
{
|
|
if (!damaged && trace)
|
|
{
|
|
damaged = true;
|
|
TesselateModel
|
|
(
|
|
NULL,
|
|
TESS_DEFAULT_MIN_SIZE,
|
|
TESS_DEFAULT_MAX_SIZE,
|
|
dir,
|
|
damage,
|
|
TESS_DEFAULT_PERCENT,
|
|
10,
|
|
pos
|
|
);
|
|
SpawnSparks
|
|
(
|
|
pos,
|
|
dir * -1.0f,
|
|
20
|
|
);
|
|
}
|
|
|
|
total_damage -= surface_damage_threshold;
|
|
state++;
|
|
|
|
if (frame < numframes)
|
|
frame++;
|
|
}
|
|
if ( ( lightstyle >= 0 ) && ( state >= currentstate ) )
|
|
{
|
|
int length;
|
|
int pos;
|
|
int lastvalid;
|
|
qboolean done;
|
|
|
|
// get length of name
|
|
length = strlen( groupname );
|
|
lastvalid = 0;
|
|
done = false;
|
|
while ( ( lastvalid < length ) && !done )
|
|
{
|
|
switch( tolower( groupname[ lastvalid ] ) )
|
|
{
|
|
case 'o':
|
|
case 'f':
|
|
case 's':
|
|
case 'q':
|
|
case 'h':
|
|
lastvalid++;
|
|
break;
|
|
default:
|
|
done = true;
|
|
break;
|
|
}
|
|
}
|
|
dotrigger = false;
|
|
|
|
if ( currentstate <= lastvalid )
|
|
{
|
|
// copy the current position to a local variable
|
|
pos = state;
|
|
if ( pos >= lastvalid )
|
|
pos = lastvalid - 1;
|
|
letter = tolower( groupname[ pos ] );
|
|
switch( letter )
|
|
{
|
|
case 'o':
|
|
gi.configstring( CS_LIGHTS + lightstyle, "a" );
|
|
state++;
|
|
dotrigger = true;
|
|
break;
|
|
case 'f':
|
|
gi.configstring( CS_LIGHTS + lightstyle, "aanannanaanann" );
|
|
state++;
|
|
dotrigger = true;
|
|
break;
|
|
case 's':
|
|
gi.configstring( CS_LIGHTS + lightstyle, "aaaanaaannaanaaaaan" );
|
|
state++;
|
|
dotrigger = true;
|
|
break;
|
|
case 'q':
|
|
gi.configstring( CS_LIGHTS + lightstyle, "d" );
|
|
state++;
|
|
dotrigger = true;
|
|
break;
|
|
case 'h':
|
|
gi.configstring( CS_LIGHTS + lightstyle, "g" );
|
|
state++;
|
|
dotrigger = true;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
surf->SetState( state );
|
|
if ( dotrigger )
|
|
{
|
|
const char * t;
|
|
|
|
t = strchr( groupname, '_' );
|
|
if ( t )
|
|
{
|
|
Event * event;
|
|
Entity * ent;
|
|
int n = 0;
|
|
t++;
|
|
//
|
|
// see if this target exists
|
|
//
|
|
n = G_FindTarget( n, t );
|
|
if ( n )
|
|
{
|
|
do
|
|
{
|
|
ent = G_GetEntity( n );
|
|
|
|
event = new Event( EV_Activate );
|
|
event->AddEntity( attacker );
|
|
ent->ProcessEvent( event );
|
|
|
|
n = G_FindTarget( n, t );
|
|
if ( !n )
|
|
break;
|
|
}
|
|
while ( 1 );
|
|
}
|
|
//
|
|
// otherwise treat it like a thread
|
|
//
|
|
else
|
|
{
|
|
if ( !ExecuteThread( str( t ) ) )
|
|
{
|
|
warning( "DoDamage", "%s not found as a script.", t );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if ( frame )
|
|
{
|
|
netsurface_t *svsurf;
|
|
int num;
|
|
|
|
num = surf->SurfaceNumber();
|
|
if ( num )
|
|
{
|
|
svsurf=&g_surfaces[num];
|
|
if (svsurf->s.damage_frame != frame)
|
|
{
|
|
svsurf->s.damage_frame = frame;
|
|
svsurf->s.changed = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//=========
|
|
//DamageSurface
|
|
//=========
|
|
void SurfaceModifier::DamageSurface ( trace_t * trace, float damage, Entity * attacker )
|
|
{
|
|
csurface_t *csurf;
|
|
|
|
if ( !trace )
|
|
return;
|
|
|
|
csurf = trace->surface;
|
|
// Make sure there is a surface here.
|
|
if (
|
|
!csurf ||
|
|
!( csurf->flags & (SURF_WEAK|SURF_NORMAL) )
|
|
)
|
|
{
|
|
return;
|
|
}
|
|
DoDamage( trace, csurf->groupname, damage, attacker );
|
|
}
|
|
|
|
//==============
|
|
//CreateSurfaces
|
|
//==============
|
|
void CreateSurfaces(csurface_t *surfinfo, int count )
|
|
{
|
|
int i;
|
|
|
|
for ( i=0; i<count; i++ )
|
|
{
|
|
if ( !isdigit( surfinfo[ i ].groupname[ 0 ] ) || ( surfinfo[i].flags & SURF_DAMAGE ) )
|
|
{
|
|
if ( !surfaceManager.SurfaceExists( surfinfo[ i ].groupname ) )
|
|
{
|
|
surfaceManager.CreateSurface( surfinfo[ i ].groupname, &surfinfo[ i ] );
|
|
}
|
|
}
|
|
}
|
|
}
|