Example #1
0
File: admin.c Project: deurk/ktx
void ReadyThink ()
{
    float i1;
	char *txt, *gr;
    gedict_t *p=NULL, *p2=NULL;

    p2 = PROG_TO_EDICT( self->s.v.owner );
	
    if(    ( p2->ct == ctPlayer && !( p2->ready ) ) // forcestart breaked via break command
		|| ( p2->ct == ctSpec && !k_force )	// forcestart breaked via forcebreak command (spectator admin)
	  )
    {
        k_force = 0;

        G_bprint(2, "%s interrupts countdown\n", p2->netname );

        ent_remove ( self );

        return;
    }

	k_attendees = CountPlayers();

	if ( !isCanStart(NULL, true) ) {
        k_force = 0;

        G_bprint(2, "Forcestart canceled\n");

        ent_remove ( self );

        return;
	}


    self->attack_finished--;

    i1 = self->attack_finished;

    if( i1 <= 0 )
    {
        k_force = 0;

        AdminMatchStart();

        ent_remove ( self );

        return;
    }

	txt = va( "%s second%s left before game starts", dig3( i1 ), ( i1 == 1 ? "" : "s") );
	gr  = va( "\n%s!", redtext("Get ready") );

    for( p = world; (p = find_client( p )); )
		if ( p->ct == ctPlayer )
			G_centerprint(p, "%s%s", txt, (p->ready ? "" : gr));
		else
			G_centerprint(p, "%s", txt);

    self->s.v.nextthink = g_globalvars.time + 1;
}
Example #2
0
/*
===================
G_SpawnGEntityFromSpawnVars

Spawn an entity and fill in all of the level fields from
level.spawnVars[], then call the class specfic spawn function
===================
*/
void G_SpawnGEntityFromSpawnVars( void )
{
	int             i;
	gedict_t       *ent;

	// get the next free entity
	ent = spawn();

	for ( i = 0; i < numSpawnVars; i++ )
	{
		G_ParseField( spawnVars[i][0], spawnVars[i][1], ent );
	}

	if ( ( ( int ) ent->s.v.spawnflags & SPAWNFLAG_NOT_DEATHMATCH ) )
	{
		ent_remove( ent );
		return;
	}

	// if we didn't get a classname, don't bother spawning anything
	if ( !G_CallSpawn( ent ) )
	{
		ent_remove( ent );
		return;
	}
//      if(!ent->s.v.classname)ent->s.v.classname="";
}
void eff_expl_flash() {
	int i;
	set(me, BRIGHT | TRANSLUCENT | LIGHT | ZNEAR | PASSABLE);
	my.alpha = 50;
	my.roll = random(360);
	while(my.alpha < 100) {
		my.alpha += time_step * (random(20)+20);
		my.roll += time_step * sign(ang(my.roll));
		vec_fill ( my.scale_x, my.alpha/13 );
		wait(1);		
	}
	for(i=0; i<4; i++) {
		ent_create("explFlash01.tga", my.x, eff_expl_flash_2);
		you = ent_create("explFlash02.tga", my.x, eff_expl_flash_2);		
		if (i == 0) set(you, LIGHT);
	}
	for(i=0; i<5; i++) {
		ent_create ("explSmoke01.tga", my.x, eff_expl_smoke2);
	}
	effect(p_eff_expl_particle, 200, my.x, NULL);
	vec_add(my.scale_x, vector(3,3,3));
	ent_create("explSmoke02.tga", my.x, eff_expl_smoke);
	while(my.alpha > 0) {
		my.alpha -= time_step * 25;
		my.roll += time_step * sign(ang(my.roll));
		wait(1);
	} 
	ent_remove(me);
}
void eff_expl_flash_2() {
	set(me, BRIGHT | TRANSLUCENT | ZNEAR | PASSABLE);
	my.blue = 150;
	my.green = 235;
	my.red = 255;
	my.alpha = 0;
	my.roll = random(360);
	vec_fill(my.scale_x, 3);
	vec_for_angle(vecEffectsTemp, vector( my.roll, 0, 0));
	vec_rotate(vecEffectsTemp, vector(camera.pan, camera.tilt+90, 0));
	vec_normalize(vecEffectsTemp, 40);
	vec_add(vecEffectsTemp, my.x);
	vec_set(my.x, vecEffectsTemp);
	
	while(my.alpha < 100) {
		if (my.lightrange < 1000 ) my.lightrange += 2000 * time_step;
		my.alpha += time_step * (random(20)+20);
		my.roll += time_step * sign(ang(my.roll));
		vec_normalize ( my.blue, 150 + random(105) );
		wait(1);
	}
	ent_create("explSmoke02.tga", my.x, eff_expl_smoke);
	while(my.alpha > 0) {
		if (my.lightrange > 0) my.lightrange -= 500 * time_step;
		my.alpha -= time_step * 20;
		my.roll += time_step * sign(ang(my.roll))*5;
		wait(1);
	}
	while (my.lightrange > 0) {
		my.lightrange -= 500 * time_step;
		wait(1);
	}
	ent_remove(me);	
}
Example #5
0
void Laser_Touch(  )
{
	vec3_t  org;

	if ( other == PROG_TO_EDICT( self->s.v.owner ) )
		return;		// don't explode on owner

	if ( trap_pointcontents( PASSVEC3( self->s.v.origin ) ) == CONTENT_SKY )
	{
		ent_remove( self );
		return;
	}

	sound( self, CHAN_WEAPON, "enforcer/enfstop.wav", 1, ATTN_STATIC );

	normalize( self->s.v.velocity, org );
	VectorScale( org, 8, org );
	VectorSubtract( self->s.v.origin, org, org );
	//org = self->s.v.origin - 8*normalize(self->s.v.velocity);

	if ( other->s.v.health )
	{
		SpawnBlood( org, 15 );
		TF_T_Damage( other, self, PROG_TO_EDICT( self->s.v.owner ), 15, 0, TF_TD_ELECTRICITY );
	} else
	{
        TempEffectCount( org, TE_GUNSHOT, 5);
	}

	dremove( self );
}
Example #6
0
void trigger_onlyregistered_touch(  )
{
	gedict_t *te;

	if ( strneq( other->s.v.classname, "player" ) )
		return;
	if ( !Activated( self, other ) )
	{
		if ( self->else_goal )
		{
			te = Findgoal( self->else_goal );
			if ( te )
				AttemptToActivate( te, other, self );
		}
		return;
	}
	if ( self->attack_finished > g_globalvars.time )
		return;

	self->attack_finished = g_globalvars.time + 2;
	if ( trap_cvar( "registered" ) )
	{
		self->s.v.message = "";
		activator = other;
		SUB_UseTargets(  );
		ent_remove( self );
	} else
	{
		if ( self->s.v.message && strneq( self->s.v.message, "" ) )
		{
			G_centerprint( other, "%s", self->s.v.message );
			sound( other, CHAN_BODY, "misc/talk.wav", 1, ATTN_NORM );
		}
	}
}
Example #7
0
void RemoveMarker (gedict_t* marker)
{
	int i, j;

	if (!streq (marker->classname, "marker")) {
		G_sprint (self, 2, "Cannot remove non-marker\n");
		return;
	}

	for (i = 0; i < NUMBER_MARKERS; ++i) {
		if (!markers[i])
			continue;

		// Remove from linked paths
		for (j = 0; j < NUMBER_PATHS; ++j) {
			if (markers[i]->fb.paths[j].next_marker == marker) {
				markers[i]->fb.paths[j].next_marker = NULL;
			}
		}

		// Remove marker
		if (markers[i] == marker) {
			ent_remove (markers[i]);
			markers[i] = NULL;
		}
	}
}
Example #8
0
void bubble_split(  )
{
	gedict_t *bubble;

	bubble = spawn(  );
	setmodel( bubble, "progs/s_bubble.spr" );
	setorigin( bubble, PASSVEC3( self->s.v.origin ) );

	bubble->s.v.movetype = MOVETYPE_NOCLIP;
	bubble->s.v.solid = SOLID_NOT;

	VectorCopy( self->s.v.velocity, bubble->s.v.velocity );

	bubble->s.v.nextthink = g_globalvars.time + 0.5;
	bubble->s.v.think = ( func_t ) bubble_bob;
	bubble->s.v.touch = ( func_t ) bubble_remove;
	bubble->s.v.classname = "bubble";
	bubble->s.v.frame = 1;
	bubble->cnt = 10;

	setsize( bubble, -8, -8, -8, 8, 8, 8 );

	self->s.v.frame = 1;
	self->cnt = 10;

	if ( self->s.v.waterlevel != 3 )
		ent_remove( self );
}
void eff_expl_smoke2 () {
	set(me, TRANSLUCENT | ZNEAR | PASSABLE | LIGHT);
	my.roll = random(360);
	my.alpha = 100;
	my.scale_x = 0.2;
	my.scale_y = 0.7;
	my.skill1 = random(3)+2;
	vec_fill(my.blue, 30);
	while(my.alpha > 0) {
		if(my.alpha > 93 ) {
			vec_for_angle(vecEffectsTemp, vector( my.roll,0,0));
			vec_rotate(vecEffectsTemp, vector(camera.pan, camera.tilt+90, 0));
			vec_normalize(vecEffectsTemp, time_step * (my.alpha/my.skill1) * 0.4);
			vec_add(my.x, vecEffectsTemp);
			my.scale_y += vec_length(vecEffectsTemp)/46;
			my.alpha -= time_step * 3;
			} else {
			vec_for_angle(vecEffectsTemp, vector(my.roll, 0, 0));
			vec_rotate(vecEffectsTemp, vector(camera.pan, camera.tilt+90, 0));
			vec_normalize(vecEffectsTemp, time_step * (my.alpha/(my.skill1*2)));
			vec_add(my.x, vecEffectsTemp);
			
			my.scale_y += vec_length(vecEffectsTemp) / 5000;
			
			my.alpha -= time_step * 9;
		}
		wait(1);
	}
	ent_remove(me);
	return;
}
Example #10
0
File: player.c Project: deurk/ktx
void DeathBubblesSpawn()
{
	gedict_t       *bubble;

	if ( PROG_TO_EDICT( self->s.v.owner )->s.v.waterlevel != 3 )
		return;
	bubble = spawn();
	setmodel( bubble, "progs/s_bubble.spr" );
	setorigin( bubble, PROG_TO_EDICT( self->s.v.owner )->s.v.origin[0],
			PROG_TO_EDICT( self->s.v.owner )->s.v.origin[1],
			PROG_TO_EDICT( self->s.v.owner )->s.v.origin[2] + 24 );

	bubble->s.v.movetype = MOVETYPE_NOCLIP;
	bubble->s.v.solid = SOLID_NOT;

	SetVector( bubble->s.v.velocity, 0, 0, 15 );

	bubble->s.v.nextthink = g_globalvars.time + 0.5;
	bubble->think = ( func_t ) bubble_bob;
	bubble->classname = "bubble";
	bubble->s.v.frame = 0;
	bubble->cnt = 0;
	
	setsize( bubble, -8, -8, -8, 8, 8, 8 );

	self->s.v.nextthink = g_globalvars.time + 0.1;
	self->think = ( func_t ) DeathBubblesSpawn;
	self->air_finished = self->air_finished + 1;

	if ( self->air_finished >= self->bubble_count )
		ent_remove( self );
}
Example #11
0
void spawn_item_flag()
{
	if ( k_ctf_custom_models )
		setmodel( self, "progs/flag.mdl" );

	self->s.v.noise = "misc/flagtk.wav";
	self->s.v.noise1 = "doors/runetry.wav";
	setsize( self, -16, -16, 0, 16, 16, 74);
	self->mdl = self->s.v.model;
	self->s.v.flags = FL_ITEM;
	self->s.v.solid = SOLID_TRIGGER;
	self->s.v.movetype = MOVETYPE_TOSS;
	SetVector( self->s.v.velocity, 0, 0, 0 );
	self->s.v.origin[2] += 6;
	self->s.v.think = (func_t) FlagThink;
	self->s.v.touch = (func_t) FlagTouch;
	self->s.v.nextthink = g_globalvars.time + 0.1;
	self->cnt = FLAG_AT_BASE;
	self->cnt2 = 0.0;
	VectorCopy( self->s.v.angles, self->mangle );
	self->s.v.effects = (int) self->s.v.effects | EF_DIMLIGHT;

	if ( !droptofloor( self ) )
		ent_remove( self );
	else
		VectorCopy( self->s.v.origin, self->s.v.oldorigin );

	if ( !isCTF() )
	{
		setmodel( self, "" );
		self->s.v.touch = (func_t) SUB_Null;
	}
}
Example #12
0
void SUB_Remove()
{
//	if (self && self->s.v.classname )
//		G_bprint(2, "rm: %s\n", self->s.v.classname);

	ent_remove( self );
}
Example #13
0
void SP_misc_explobox2(  )
{
	float   oldz;

	if ( !CheckExistence(  ) )
	{
		dremove( self );
		return;
	}

	self->s.v.solid = SOLID_BBOX;
	self->s.v.movetype = MOVETYPE_NONE;

	trap_precache_model( "maps/b_exbox2.bsp" );
	setmodel( self, "maps/b_exbox2.bsp" );
	setsize( self, 0, 0, 0, 32, 32, 32 );
	trap_precache_sound( "weapons/r_exp3.wav" );

	self->s.v.health = 20;
	self->th_die = barrel_explode;
	self->s.v.takedamage = DAMAGE_AIM;

	self->s.v.origin[2] += 2;
	oldz = self->s.v.origin[2];

	droptofloor( self );

	if ( oldz - self->s.v.origin[2] > 250 )
	{
		G_dprintf( "item fell out of level at '%f %f %f'\n", PASSVEC3( self->s.v.origin ) );
		ent_remove( self );
	}
}
Example #14
0
void trigger_push_touch()
{
	if ( streq( other->s.v.classname, "grenade" ) )
	{
		other->s.v.velocity[0] = self->speed * self->s.v.movedir[0] * 10;
		other->s.v.velocity[1] = self->speed * self->s.v.movedir[1] * 10;
		other->s.v.velocity[2] = self->speed * self->s.v.movedir[2] * 10;
	} else if ( other->s.v.health > 0 )
	{
//  other->s.v.velocity = self->speed  * self->s.v.movedir * 10;
		other->s.v.velocity[0] = self->speed * self->s.v.movedir[0] * 10;
		other->s.v.velocity[1] = self->speed * self->s.v.movedir[1] * 10;
		other->s.v.velocity[2] = self->speed * self->s.v.movedir[2] * 10;

		if ( streq( other->s.v.classname, "player" ) )
		{
			if ( other->fly_sound < g_globalvars.time )
			{
				other->fly_sound = g_globalvars.time + 1.5;
				sound( other, CHAN_AUTO, "ambience/windfly.wav", 1,
					    ATTN_NORM );
			}
		}
	}
	if ( ( int ) ( self->s.v.spawnflags ) & PUSH_ONCE )
		ent_remove( self );
}
Example #15
0
////////////////
// GlobalParams:
// self
///////////////
void SpectatorDisconnect()
{
	gedict_t *p;

	if ( self->k_accepted )
	{
		for ( p = world; (p = ( match_in_progress == 2 && !cvar("k_ann") ) ? find_spc( p ) : find_client( p )); )	
			G_sprint( p, PRINT_HIGH, "Spectator %s left the game\n", self->s.v.netname );
	}

// s: added conditional function call here
	if( self->v.elect_type != etNone ) {

		if ( match_in_progress != 2 )
			G_bprint(2, "Election aborted\n");

		AbortElect();
	}

	if ( self->wizard ) {
		ent_remove( self->wizard );
		self->wizard = NULL;
	}

	if( self->k_kicking )
		ExitKick( self );

	self->s.v.classname = ""; // Cenobite, so we clear out any specs as they leave
	self->k_accepted  = 0;
	self->ct = ctNone;
}
Example #16
0
void DelayThink()
{

	activator = PROG_TO_EDICT( self->s.v.enemy );

	SUB_UseTargets();
	ent_remove( self );
}
Example #17
0
void bubble_remove(  )
{
	if ( streq( other->s.v.classname, self->s.v.classname ) )
	{
//              dprint ("bump");
		return;
	}
	ent_remove( self );
}
Example #18
0
/*QUAKED air_bubbles (0 .5 .8) (-8 -8 -8) (8 8 8)

testing air bubbles
*/
void SP_air_bubbles(  )
{
	if ( !CheckExistence(  ) )
	{
		dremove( self );
		return;
	}
	ent_remove( self );
}
Example #19
0
void spike_touch()
{
//float rand;
	if ( other == PROG_TO_EDICT( self->s.v.owner ) )
		return;

	if ( self->voided )
	{
		return;
	}
	self->voided = 1;

	if ( other->s.v.solid == SOLID_TRIGGER )
		return;		// trigger field, do nothing

	if ( trap_pointcontents( PASSVEC3( self->s.v.origin ) ) == CONTENT_SKY )
	{
		ent_remove( self );
		return;
	}
// hit something that bleeds
	if ( other->s.v.takedamage )
	{
		spawn_touchblood( 9 );
		other->deathtype = "nail";
		T_Damage( other, self, PROG_TO_EDICT( self->s.v.owner ), 9 );
	} else
	{
		trap_WriteByte( MSG_MULTICAST, SVC_TEMPENTITY );
		if ( !strcmp( self->s.v.classname, "wizspike" ) )
			trap_WriteByte( MSG_MULTICAST, TE_WIZSPIKE );
		else if ( !strcmp( self->s.v.classname, "knightspike" ) )
			trap_WriteByte( MSG_MULTICAST, TE_KNIGHTSPIKE );
		else
			trap_WriteByte( MSG_MULTICAST, TE_SPIKE );
		trap_WriteCoord( MSG_MULTICAST, self->s.v.origin[0] );
		trap_WriteCoord( MSG_MULTICAST, self->s.v.origin[1] );
		trap_WriteCoord( MSG_MULTICAST, self->s.v.origin[2] );
		trap_multicast( PASSVEC3( self->s.v.origin ), MULTICAST_PHS );
	}

	ent_remove( self );

}
Example #20
0
void remove_specs_wizards ()
{
	gedict_t *p;

	for( p = world; (p = find_spc( p )); )
		if ( p->wizard ) {
			ent_remove( p->wizard );
			p->wizard = NULL;
		}
}
Example #21
0
File: misc.c Project: deurk/ktx
void fire_touch()
{
	// Yawnmode: no damage from fireall
	if ( !k_yawnmode ) {
		other->deathtype = dtFIREBALL;
		T_Damage( other, self, self, 20 );
	}

	ent_remove( self );
}
Example #22
0
action update_Earth() // Actions for earth.mdl
{
	wait(1) ; 
 
	while ( me ) // As long as I exist, continue to do this:
	{
		if ( key_space ) ent_remove ( me ) ; // If Spacebar is detected, I M toast
      
	wait (1) ; 
	}
}
/*
 * void render_rain_free()
 * 
 * Frees the rain state singleton.
 */
void render_rain_free()
{
	int i = 0;
	
	render_rain_stop();
	mtl_remove(RainState_singleton->rain);
	for(; i < RainState_singleton->depth; i++)
	    ent_remove((RainState_singleton->rain_levels)[i]);
	    
	sys_free(RainState_singleton);
}
Example #24
0
File: misc.c Project: deurk/ktx
void Laser_Touch()
{
	vec3_t          org;

	if ( other == PROG_TO_EDICT( self->s.v.owner ) )
		return;		// don't explode on owner

	if ( trap_pointcontents( PASSVEC3( self->s.v.origin ) ) == CONTENT_SKY )
	{
		ent_remove( self );
		return;
	}

	sound( self, CHAN_WEAPON, "enforcer/enfstop.wav", 1, ATTN_STATIC );
	
	normalize( self->s.v.velocity, org );
	VectorScale( org, 8, org );
	VectorSubtract( self->s.v.origin, org, org );
	//org = self->s.v.origin - 8*normalize(self->s.v.velocity);

	if ( ISLIVE( other ) )
	{
		SpawnBlood( org, 15 );
		other->deathtype = dtLASER;
		T_Damage( other, self, PROG_TO_EDICT( self->s.v.owner ), 15 );
	} else
	{
		WriteByte( MSG_MULTICAST, SVC_TEMPENTITY );
		WriteByte( MSG_MULTICAST, TE_GUNSHOT );
		WriteByte( MSG_MULTICAST, 5 );
		WriteCoord( MSG_MULTICAST, org[0] );
		WriteCoord( MSG_MULTICAST, org[1] );
		WriteCoord( MSG_MULTICAST, org[2] );

		trap_multicast( PASSVEC3( org ), MULTICAST_PVS );
	}

	ent_remove( self );
}
Example #25
0
void barrel_explode(  )
{
    vec3_t v;
	self->s.v.takedamage = DAMAGE_NO;
	self->s.v.classname = "explo_box";
	// did say self.owner
	T_RadiusDamage( self, self, 160, world );

    VectorCopy( self->s.v.origin, v); v[2] += 32;
    TempEffectCoord( v, TE_EXPLOSION );

	ent_remove( self );
}
Example #26
0
/*
===================
G_SpawnGEntityFromSpawnVars

Spawn an entity and fill in all of the level fields from
level.spawnVars[], then call the class specfic spawn function
===================
*/
void G_SpawnGEntityFromSpawnVars( void )
{
	int             i;
	gedict_t       *ent;

	// get the next free entity
	ent = spawn();

	for ( i = 0; i < numSpawnVars; i++ )
	{
		G_ParseField( spawnVars[i][0], spawnVars[i][1], ent );
	}

	if ( deathmatch )
	{
		if ( ( ( int ) ent->s.v.spawnflags & SPAWNFLAG_NOT_DEATHMATCH ) )
		{
//			G_cprint( "%s removed because of SPAWNFLAG_NOT_DEATHMATCH\n", ent->s.v.classname );
			ent_remove( ent );
			return;
		}
	}
	else if (   ( skill == 0 && ((int)ent->s.v.spawnflags & SPAWNFLAG_NOT_EASY) )
			 || ( skill == 1 && ((int)ent->s.v.spawnflags & SPAWNFLAG_NOT_MEDIUM) )
			 || ( skill >= 2 && ((int)ent->s.v.spawnflags & SPAWNFLAG_NOT_HARD) ) 
	   )
	{
//		G_cprint( "%s removed because of SPAWNFLAG_NOT_XXX\n", ent->s.v.classname );
		ent_remove( ent );
		return;
	}

	// if we didn't get a classname, don't bother spawning anything
	if ( !G_CallSpawn( ent ) )
	{
		ent_remove( ent );
		return;
	}
}
Example #27
0
		// Stone rain
		action ebHandStone () {
			set(me, PASSABLE);
			var randomFallSpeed = random(20);
			while(my.z > -100) {
				my.z -=(20+randomFallSpeed) * time_step;
				my.pan +=randomFallSpeed * time_step;
				my.tilt +=randomFallSpeed * time_step;
				my.roll +=randomFallSpeed * time_step;
				
				// Give player 2 seconds to recover from last hit
				if (g_playerJustBeenHit == 0) {
					
					// Stone hits player?
					if (vec_dist(player.x, my.x) < 30) {
						
						// Play sounds
						if (!snd_playing(vPlayerSndHandle))
							vPlayerSndHandle = snd_play(g_sndHitByStone, 100, 0);
						snd_play(g_sndStoneImpact, 100, 0);	
							
						player.PL_HEALTH -=1;
						ent_remove(me);
						
						g_playerJustBeenHit = 2;
						
						// Wait 2 seconds
						while(g_playerJustBeenHit > 0) {
							g_playerJustBeenHit -=1;
							wait(-1);
						}
						return;
					}
				}
				
				wait(1);
			}
			ent_remove(me);
		}
void eff_expl_wave() {
	set(me, TRANSLUCENT | DECAL | PASSABLE);
	my.alpha = 70;
	vec_fill(my.scale_x, 0.1);
	my.tilt = 90;
	my.pan = random(360);
	vec_fill(my.blue, 0);
	while(my.alpha > 0) {
		vec_fill(vecEffectsTemp, time_step * 2);
		vec_add(my.scale_x, vecEffectsTemp);
		my.alpha -= time_step * 7;
		wait (1);
	}
	ent_remove(me);
}
void eff_expl_smoke() {
	set(me, TRANSLUCENT | LIGHT | ZNEAR | PASSABLE);
	vec_set(my.blue, vector(200,255,255));
	my.alpha = 40;
	my.roll = random(360);
	vec_fill(my.scale_x, 0.4);
	while(my.alpha > 0) {
		my.alpha -= time_step * 2;
		my.roll += time_step * sign(ang(my.roll))*1;
		vec_fill(vecEffectsTemp, time_step *0.01);
		vec_add(my.scale_x, vecEffectsTemp);
		wait(1);
	} 
	ent_remove ( me );
}
Example #30
0
void SP_info_player_teamspawn(  )
{
	if (self->team_no == TF_TEAM_RED)
	{
		self->s.v.classname = "info_player_team1";
	}
	else if (self->team_no == TF_TEAM_BLUE)
	{
		self->s.v.classname = "info_player_team2";
	}
	else
	{
		G_Printf( "SP_info_player_teamspawn: team_no %d unsupported\n", self->team_no);
		ent_remove( self );
		return;
	}
}