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 ] );
            }
         }
      }
   }