{
if (!o.has_team)
{
- o.__team = _team;
+ setteam(o, _team);
tm = GetTeam(_team, true);
tm.team_size += 1;
o.has_team = 1;
{
tm = GetTeam(TMID(o.team), false);
tm.team_size -= 1;
- o.__team = _team;
+ setteam(o, _team);
tm = GetTeam(_team, true);
tm.team_size += 1;
return true;
int i;
entity o;
- this.__team = ReadByte();
+ setteam(this, ReadByte());
o = this.owner = GetTeam(TMID(this.team), true); // these team numbers can always be trusted
int sf, lf;
if (!add)
return world;
entity tm = new_pure(team);
- tm.__team = _team;
+ setteam(tm, _team);
teamslots[num] = tm;
RegisterTeam(tm);
return tm;
if(sendflags & 4)
{
- this.__team = ReadByte();
+ setteam(this, ReadByte());
}
return = true;
this.fade_rate = 0;
}
- this.__team = ReadByte() - 1;
+ setteam(this, ReadByte() - 1);
}
if (f & 2)
setattachment(e, self, gettaginfo_name); // attach to the given bone
e.owner = self;
e.cnt = time + life;
- e.__team = _particleeffectnum(effectname);
+ setteam(e, _particleeffectnum(effectname));
e.think = DamageEffect_Think;
e.nextthink = time;
self.total_damages += 1;
// if this is a copied dead body, send the num of its player instead
// TODO: remove this field, read from model txt files
if(gibowner.classname == "body")
- e.__team = etof(gibowner.enemy);
+ setteam(e, etof(gibowner.enemy));
else
- e.__team = etof(gibowner);
+ setteam(e, etof(gibowner));
setorigin(e, org);
e.velocity = dir;
self.nextthink = time + autocvar_g_nexball_delay_idle + 3;
self.teamtime = 0;
self.pusher = world;
- self.__team = 0;
+ setteam(self, 0);
_sound(self, CH_TRIGGER, self.noise1, VOL_BASE, ATTEN_NORM);
WaypointSprite_Ping(self.waypointsprite_attachedforcarrier);
LogNB("init", world);
remove(self);
return;
}
- self.__team = self.cnt + 1;
+ setteam(self, self.cnt + 1);
}
void nb_spawnteam(string teamname, float teamcolor)
entity e = new(nexball_team);
e.netname = teamname;
e.cnt = teamcolor;
- e.__team = e.cnt + 1;
+ setteam(e, e.cnt + 1);
nb_teams += 1;
}
spawnfunc(nexball_redgoal)
{
- self.__team = NUM_TEAM_1;
+ setteam(self, NUM_TEAM_1);
SpawnGoal();
}
spawnfunc(nexball_bluegoal)
{
- self.__team = NUM_TEAM_2;
+ setteam(self, NUM_TEAM_2);
SpawnGoal();
}
spawnfunc(nexball_yellowgoal)
{
- self.__team = NUM_TEAM_3;
+ setteam(self, NUM_TEAM_3);
SpawnGoal();
}
spawnfunc(nexball_pinkgoal)
{
- self.__team = NUM_TEAM_4;
+ setteam(self, NUM_TEAM_4);
SpawnGoal();
}
spawnfunc(nexball_fault)
{
- self.__team = GOAL_FAULT;
+ setteam(self, GOAL_FAULT);
if(self.noise == "")
self.noise = strzone(SND(TYPEHIT));
SpawnGoal();
spawnfunc(nexball_out)
{
- self.__team = GOAL_OUT;
+ setteam(self, GOAL_OUT);
if(self.noise == "")
self.noise = strzone(SND(TYPEHIT));
SpawnGoal();
this.health = ReadByte();
this.max_health = ReadByte();
this.count = ReadByte();
- this.__team = ReadByte();
+ setteam(this, ReadByte());
this.iscaptured = ReadByte();
if(!this.count)
int _tmp = ReadByte();
if(_tmp != TMID(this.team))
{
- this.__team = _tmp;
+ setteam(this, _tmp);
cpicon_changeteam(this);
}
this.health = ReadByte();
this.max_health = ReadByte();
this.count = ReadByte();
- this.__team = ReadByte();
+ setteam(this, ReadByte());
if(!this.count)
this.count = 40;
_tmp = ReadByte();
if(_tmp != TMID(this.team))
{
- this.__team = _tmp;
+ setteam(this, _tmp);
generator_changeteam(this);
}
this.owner.goalentity = world;
this.owner.islinked = false;
this.owner.iscaptured = false;
- this.owner.__team = 0;
+ setteam(this.owner, 0);
this.owner.colormap = 1024;
WaypointSprite_UpdateMaxHealth(this.owner.sprite, 0);
// unteam the spawnpoint if needed
int t = TMID(self.owner.team);
if(!self.owner.islinked)
- self.owner.__team = 0;
+ setteam(self.owner, 0);
setself(self.owner);
activator = self;
SUB_UseTargets ();
setself(this);
- self.owner.__team = t;
+ setteam(self.owner, t);
self.owner.waslinked = self.owner.islinked;
}
remove(this.goalentity);
this.goalentity = world;
- this.__team = 0;
+ setteam(this, 0);
this.colormap = 1024;
this.iscaptured = false;
this.islinked = false;
ons_worldcplist = cp;
cp.netname = "Control point";
- cp.__team = 0;
+ setteam(cp, 0);
cp.solid = SOLID_BBOX;
cp.movetype = MOVETYPE_NONE;
cp.touch = ons_ControlPoint_Touch;
void ons_GeneratorReset(entity this)
{
- this.__team = this.team_saved;
+ setteam(this, this.team_saved);
this.lasthealth = this.max_health = this.health = autocvar_g_onslaught_gen_health;
this.takedamage = DAMAGE_AIM;
this.bot_attack = true;
return "";
}
-float _MapInfo_GetTeamPlayBool(float t)
+bool _MapInfo_GetTeamPlayBool(float t)
{
- FOREACH(Gametypes, it.items == t, return it.__team);
+ FOREACH(Gametypes, it.items == t, return it.m_teamplay);
return false;
}
/** human readable name */
ATTRIB(Gametype, message, string, string_null)
/** does this gametype support teamplay? */
- ATTRIB(Gametype, __team, bool, false)
+ ATTRIB(Gametype, m_teamplay, bool, false)
/** game type defaults */
ATTRIB(Gametype, model2, string, string_null)
/** game type description */
this.netname = g_name;
this.mdl = sname;
this.message = hname;
- this.__team = gteamplay;
+ this.m_teamplay = gteamplay;
this.m_mutators = mutators;
this.model2 = defaults;
this.gametype_description = gdescription;
minigame_ent = self.owner;
if ( sf & MINIG_SF_UPDATE )
- self.__team = ReadByte();
+ setteam(self, ReadByte());
if ( activate )
{
}
entity piece = msle_spawn(minigame,"minigame_board_piece");
- piece.__team = 1;
+ setteam(piece, 1);
piece.netname = strzone(pos);
piece.bd_tiletype = thetile;
piece.bd_dir = '0 -1 0';
tokenize_console(bd_string);
entity e = msle_spawn(minigame,"minigame_board_piece");
- e.__team = 1;
+ setteam(e, 1);
e.bd_dir = '0 -1 0';
int argv_num = 0;
e.origin = minigame_tile_pos(id,7,7);
e.netname = id;
e.owner = minig;
- e.__team = 0;
+ setteam(e, 0);
e.nmm_tile_distance = distance;
e.nmm_tile_hmill = strzone(nmm_tile_build_hmill(e));
e.nmm_tile_vmill = strzone(nmm_tile_build_vmill(e));
for ( int i = 0; i < 7; i++ )
{
e = msle_spawn(minigame,"minigame_board_piece");
- e.__team = 1;
+ setteam(e, 1);
e.minigame_flags = NMM_PIECE_HOME;
e = msle_spawn(minigame,"minigame_board_piece");
- e.__team = 2;
+ setteam(e, 2);
e.minigame_flags = NMM_PIECE_HOME;
}
ball.velocity_y = sin(angle)*autocvar_sv_minigames_pong_ball_speed;
ball.think = pong_ball_think;
ball.nextthink = time;
- ball.__team = 0;
+ setteam(ball, 0);
ball.SendFlags |= MINIG_SF_UPDATE|PONG_SF_BALLTEAM;
}
ball.velocity = '0 0 0';
ball.origin = '0.5 0.5 0';
ball.think = SUB_NullThink;
- ball.__team = 0;
+ setteam(ball, 0);
ball.SendFlags |= MINIG_SF_UPDATE|PONG_SF_BALLTEAM;
ball.think = pong_ball_throwthink;
ball.nextthink = time + autocvar_sv_minigames_pong_ball_wait;
if ( pong_paddle_hit(self, i) )
{
pong_paddle_bounce(self,i);
- self.__team = i;
+ setteam(self, i);
self.SendFlags |= PONG_SF_BALLTEAM;
return;
}
paddle.origin = pong_team_to_paddlepos(pl_team);
paddle.think = pong_paddle_think;
paddle.nextthink = time;
- paddle.__team = pl_team;
+ setteam(paddle, pl_team);
paddle.mins = pong_team_to_box_halfsize(pl_team,-paddle.pong_length,-1/16);
paddle.maxs = pong_team_to_box_halfsize(pl_team,paddle.pong_length,1/16);
if(minigame.pp_curr_piece)
{
minigame.pp_curr_piece.cnt = 0;
- minigame.pp_curr_piece.__team = 5;
+ setteam(minigame.pp_curr_piece, 5);
minigame_server_sendflags(minigame.pp_curr_piece,MINIG_SF_ALL);
}
if(t1_true || t2_true)
{
entity piece = msle_spawn(minigame,"minigame_board_piece");
- piece.__team = ((t1_true) ? 1 : 2);
+ setteam(piece, ((t1_true) ? 1 : 2));
piece.netname = strzone(minigame_tile_buildname(i,t));
minigame_server_sendflags(piece,MINIG_SF_ALL);
minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
if(i == floor(PS_NUM_CNT * 0.5) && t == floor(PS_LET_CNT * 0.5))
continue; // middle piece is empty
entity piece = msle_spawn(minigame,"minigame_board_piece");
- piece.__team = 1; // init default team?
+ setteam(piece, 1); // init default team?
piece.netname = strzone(minigame_tile_buildname(t,i));
minigame_server_sendflags(piece,MINIG_SF_ALL);
}
}
entity piece = msle_spawn(minigame,"minigame_board_piece");
- piece.__team = 0;
+ setteam(piece, 0);
piece.netname = strzone(RandomSelection_chosen_string);
minigame_server_sendflags(piece,MINIG_SF_ALL);
}
entity piece = msle_spawn(minigame,"minigame_board_piece");
- piece.__team = pteam;
+ setteam(piece, pteam);
piece.netname = strzone(RandomSelection_chosen_string);
piece.cnt = 1;
piece.snake_next = world;
{
entity aiplayer = new(minigame_player);
aiplayer.owner = minigame;
- aiplayer.__team = ai;
+ setteam(aiplayer, ai);
aiplayer.minigame_playerslot = 0;
aiplayer.minigame_autoclean = 1;
ttt_aimove(minigame);
{
player_pointer.owner = minigame_session;
player_pointer.minigame_players = player;
- player_pointer.__team = mgteam;
+ setteam(player_pointer, mgteam);
player_pointer.list_next = minigame_session.minigame_players;
minigame_session.minigame_players = player_pointer;
player.active_minigame = minigame_session;
{
if(!teamplay) { return; }
- ent.__team = newteam;
+ setteam(ent, newteam);
ent.monster_attack = true; // new team, activate attacking
monster_setupcolors(ent);
{
WaypointSprite_UpdateTeamRadar(ent.sprite, RADARICON_DANGER, ((newteam) ? Team_ColorRGB(newteam) : '1 0 0'));
- ent.sprite.__team = newteam;
+ setteam(ent.sprite, newteam);
ent.sprite.SendFlags |= 1;
}
}
if(this.monster_skill == MONSTER_SKILL_HARD) if(this.spawnflags & MONSTERSKILL_NOTHARD) { Monster_Remove(this); return false; }
if(this.team && !teamplay)
- this.__team = 0;
+ setteam(this, 0);
if(!(this.spawnflags & MONSTERFLAG_SPAWNED)) // naturally spawned monster
if(!(this.spawnflags & MONSTERFLAG_RESPAWNED)) // don't count re-spawning monsters either
void buff_Init_Compat(entity ent, entity replacement);
#define BUFF_SPAWNFUNC(e, b, t) spawnfunc(item_buff_##e) { \
self.buffs = b.m_itemid; \
- self.__team = t; \
+ setteam(self, t); \
buff_Init(self); \
}
#define BUFF_SPAWNFUNCS(e, b) \
{SELFPARAM();
if(!cvar("g_buffs")) { remove(ent); return; }
- if(!teamplay && ent.team) { ent.__team = 0; }
+ if(!teamplay && ent.team) { setteam(ent, 0); }
entity buff = buff_FirstFromFlags(self.buffs);
void buff_Init_Compat(entity ent, entity replacement)
{
if (ent.spawnflags & 2)
- ent.__team = NUM_TEAM_1;
+ setteam(ent, NUM_TEAM_1);
else if (ent.spawnflags & 4)
- ent.__team = NUM_TEAM_2;
+ setteam(ent, NUM_TEAM_2);
ent.buffs = replacement.m_itemid;
if (sendflags & 1)
{
- this.__team = ReadByte();
+ setteam(this, ReadByte());
this.rule = ReadByte();
}
{
// no check, as this is never called without doing an actual change (usually only once)
e.rule = r;
- e.__team = t;
+ setteam(e, t);
e.SendFlags |= 1;
}
else
setorigin(wp, ofs);
wp.enemy = showto;
- wp.__team = t;
+ setteam(wp, t);
wp.owner = own;
wp.currentammo = hideable;
if (own)
this.v_angle = PHYS_INPUT_ANGLES(this);
this.angles = PHYS_WORLD_ANGLES(this);
- this.__team = myteam + 1; // is this correct?
+ setteam(this, myteam);
if (!(PHYS_INPUT_BUTTON_JUMP(this))) // !jump
UNSET_JUMP_HELD(this); // canjump = true
pmove_waterjumptime -= PHYS_INPUT_TIMELENGTH;
#endif
Team TM(int teamid) {
- if (teamid == 0) return NULL;
+ return = TEAM_SPEC;
+ if (teamid == -1) return; // catch off-by-one from server NULL.team (0) - 1
+ if (teamid == 0) return;
FOREACH(Teams, it.Team_id == teamid, return it);
LOG_SEVEREF("Unknown team: %d", teamid);
- return NULL;
}
#define Team_ColorCode(this) (TM(this).m_colorstr)
void func_breakable_reset(entity this)
{
- this.__team = this.team_saved;
+ setteam(this, this.team_saved);
func_breakable_look_restore();
if(this.spawnflags & 1)
func_breakable_behave_destroyed();
make_pure(this);
self.classname = "jumppad";
- int mytm = ReadByte(); if(mytm) { self.__team = mytm - 1; }
+ int mytm = ReadByte(); if(mytm) { setteam(self, mytm - 1); }
self.spawnflags = ReadInt24_t();
self.active = ReadByte();
self.height = ReadCoord();
}
this.think = func_null;
this.nextthink = 0;
- this.__team = this.team_saved;
+ setteam(this, this.team_saved);
}
/*QUAKED spawnfunc_trigger_multiple (.5 .5 .5) ? notouch
void trigger_relay_teamcheck_reset(entity this)
{
- this.__team = this.team_saved;
+ setteam(this, this.team_saved);
}
spawnfunc(trigger_relay_teamcheck)
NET_HANDLE(ENT_CLIENT_TRIGGER_TELEPORT, bool isnew)
{
self.classname = "trigger_teleport";
- int mytm = ReadByte(); if(mytm) { self.__team = mytm - 1; }
+ int mytm = ReadByte(); if(mytm) { setteam(self, mytm - 1); }
self.spawnflags = ReadInt24_t();
self.active = ReadByte();
self.speed = ReadCoord();
_tmp = ReadByte();
if(_tmp != TMID(self.team))
{
- self.__team = _tmp;
+ setteam(self, _tmp);
turret_changeteam();
}
self.netname = tur.netname;
load_unit_settings(self, 0);
- if(!self.team || !teamplay) { self.__team = MAX_SHOT_DISTANCE; }
+ if(!self.team || !teamplay) { setteam(self, MAX_SHOT_DISTANCE); }
if(!self.ticrate) { self.ticrate = ((self.turret_flags & TUR_FLAG_SUPPORT) ? 0.2 : 0.1); }
if(!self.health) { self.health = 1000; }
if(!self.shot_refire) { self.shot_refire = 1; }
_vehicle.tur_head.nodrawtoclient = world;
if(!teamplay)
- _vehicle.__team = 0;
+ setteam(_vehicle, 0);
Kill_Notification(NOTIF_ONE, _player, MSG_CENTER, CPID_VEHICLES);
Kill_Notification(NOTIF_ONE, _player, MSG_CENTER, CPID_VEHICLES_OTHER); // kill all vehicle notifications when exiting a vehicle?
else { self.active = ACTIVE_ACTIVE; }
if(self.team && (!teamplay || !autocvar_g_vehicles_teams))
- self.__team = 0;
+ setteam(self, 0);
if(self.mdl == "" || !self.mdl)
_setmodel(self, veh.model);
if(sf & BRG_SETUP)
{
self.cnt = ReadByte();
- self.__team = ReadByte();
+ setteam(self, ReadByte());
self.cnt = ReadByte();
if(self.cnt)
int myowner = ReadByte();
this.owner = playerslots[myowner - 1];
this.sv_entnum = myowner;
- this.__team = ReadByte() - 1;
+ setteam(this, ReadByte() - 1);
if(autocvar_cl_vaporizerbeam_particle)
{
#include <dpdefs/keycodes.qh>
#endif
+#define DEBUG_TEAM_ENTS 1
+
.int team;
-.int __team = team;
.entity m_team;
-#if 1
-#define team_t int
-#define TMID(t) (t)
+.int __team = team;
+
+#if DEBUG_TEAM_ENTS
+ #define team_t int
+ #define TMID(t) (t)
+ #define team team
+ #define setteam(e, t) MACRO_BEGIN { \
+ (e).team = (t); \
+ } MACRO_END
#else
-#define team_t Team
-#define TMID(t) (t.Team_id)
-#define team m_team
+ #define team_t Team
+ #define TMID(t) ((t).m_playercolor)
+ #define team m_team
+ #define setteam(e, t) MACRO_BEGIN { \
+ entity _e = (e); \
+ int _t = (t); \
+ _e.__team = _t; \
+ _e.team = TM(_t); \
+ } MACRO_END
#endif
#include "macro.qh"
bot_setnameandstuff();
if(self.bot_forced_team==1)
- self.__team = NUM_TEAM_1;
+ setteam(self, NUM_TEAM_1);
else if(self.bot_forced_team==2)
- self.__team = NUM_TEAM_2;
+ setteam(self, NUM_TEAM_2);
else if(self.bot_forced_team==3)
- self.__team = NUM_TEAM_3;
+ setteam(self, NUM_TEAM_3);
else if(self.bot_forced_team==4)
- self.__team = NUM_TEAM_4;
+ setteam(self, NUM_TEAM_4);
else
JoinBestTeam(self, false, true);
if (mutator_returnvalue) {
// mutator prevents resetting teams+score
} else {
- this.__team = -1; // move this as it is needed to log the player spectating in eventlog
+ setteam(this, -1); // move this as it is needed to log the player spectating in eventlog
this.frags = FRAGS_SPECTATOR;
PlayerScore_Clear(this); // clear scores when needed
}
WITH(entity, self, it, it.reset(it));
continue;
}
- if (it.team_saved) it.__team = it.team_saved;
+ if (it.team_saved) setteam(it, it.team_saved);
if (it.flags & FL_PROJECTILE) remove(it); // remove any projectiles left
});
FOREACH_ENTITY_CLASS("turret_main", true, {
// Swap turret teams
if(TMID(it.team) == NUM_TEAM_1)
- it.__team = NUM_TEAM_2;
+ setteam(it, NUM_TEAM_2);
else
- it.__team = NUM_TEAM_1;
+ setteam(it, NUM_TEAM_1);
// Doubles as teamchange
WITH(entity, self, it, turret_respawn());
{
if (!g_assault) { remove(self); return; }
- self.__team = NUM_TEAM_1; // red, gets swapped every round
+ setteam(self, NUM_TEAM_1); // red, gets swapped every round
spawnfunc_info_player_deathmatch(this);
}
{
if (!g_assault) { remove(self); return; }
- self.__team = NUM_TEAM_2; // blue, gets swapped every round
+ setteam(self, NUM_TEAM_2); // blue, gets swapped every round
spawnfunc_info_player_deathmatch(this);
}
self.classname = "func_assault_destructible";
if(assault_attacker_team == NUM_TEAM_1)
- self.__team = NUM_TEAM_2;
+ setteam(self, NUM_TEAM_2);
else
- self.__team = NUM_TEAM_1;
+ setteam(self, NUM_TEAM_1);
spawnfunc_func_breakable(this);
}
MUTATOR_HOOKFUNCTION(as, TurretSpawn)
{SELFPARAM();
if(!self.team || TMID(self.team) == MAX_SHOT_DISTANCE)
- self.__team = 5; // this gets reversed when match starts?
+ setteam(self, 5); // this gets reversed when match starts?
return false;
}
it.killcount = 0;
if (!it.caplayer && IS_BOT_CLIENT(it))
{
- it.__team = -1;
+ setteam(it, -1);
it.caplayer = 1;
}
if (it.caplayer)
setattachment(flag, world, "");
flag.netname = strzone(sprintf("%s%s^7 flag", Team_ColorCode(teamnumber), Team_ColorName_Upper(teamnumber)));
- flag.__team = teamnumber;
+ setteam(flag, teamnumber);
flag.classname = "item_flag_team";
flag.target = "###item###"; // wut?
flag.flags = FL_ITEM | FL_NOTARGET;
if(!g_ctf) { remove(self); return; }
self.classname = "ctf_team";
- self.__team = self.cnt + 1;
+ setteam(self, self.cnt + 1);
}
// compatibility for quake maps
// do trigger work
old_delay = self.delay;
old_team = TMID(self.team);
- self.__team = real_team;
+ setteam(self, real_team);
self.delay = 0;
activator = self;
SUB_UseTargets ();
self.delay = old_delay;
- self.__team = old_team;
+ setteam(self, old_team);
entity msg = WP_DomNeut;
switch(TMID(self.team))
self.modelindex = 0;
// this would have to be changed if used in quakeworld
if(self.cnt)
- self.__team = self.cnt + 1; // WHY are these different anyway?
+ setteam(self, self.cnt + 1); // WHY are these different anyway?
}
// scoreboard setup
self.model = "";
self.modelindex = 0;
// this would have to be changed if used in quakeworld
- self.__team = self.cnt + 1;
+ setteam(self, self.cnt + 1);
//eprint(self);
setself(this);
if(invasion_teams >= 3) if(inv_monsters_perteam[NUM_TEAM_3] > 0) { RandomSelection_Add(world, NUM_TEAM_3, string_null, 1, 1); }
if(invasion_teams >= 4) if(inv_monsters_perteam[NUM_TEAM_4] > 0) { RandomSelection_Add(world, NUM_TEAM_4, string_null, 1, 1); }
- monster.__team = RandomSelection_chosen_float;
+ setteam(monster, RandomSelection_chosen_float);
}
if(teamplay)
{
WaypointSprite_UpdateTeamRadar(monster.sprite, RADARICON_DANGER, ((monster.team) ? Team_ColorRGB(TMID(monster.team)) : '1 0 0'));
- monster.sprite.__team = 0;
+ setteam(monster.sprite, 0);
monster.sprite.SendFlags |= 1;
}
}
if(!g_tdm || !self.cnt) { remove(self); return; }
self.classname = "tdm_team";
- self.__team = self.cnt + 1;
+ setteam(self, self.cnt + 1);
}
// code from here on is just to support maps that don't have team entities
{
entity ts = new_pure(csqc_score_team);
ts.netname = name; // not used yet, FIXME
- ts.__team = t;
+ setteam(ts, t);
Net_LinkEntity(ts, false, 0, TeamScore_SendEntity);
teamscorekeepers[t - 1] = ts;
++teamscores_entities_count;
Keys: "angle" viewing angle when spawning. */
spawnfunc(info_player_team1)
{
- this.__team = NUM_TEAM_1; // red
+ setteam(this, NUM_TEAM_1); // red
spawnfunc_info_player_deathmatch(this);
}
Keys: "angle" viewing angle when spawning. */
spawnfunc(info_player_team2)
{
- this.__team = NUM_TEAM_2; // blue
+ setteam(this, NUM_TEAM_2); // blue
spawnfunc_info_player_deathmatch(this);
}
Keys: "angle" viewing angle when spawning. */
spawnfunc(info_player_team3)
{
- this.__team = NUM_TEAM_3; // yellow
+ setteam(this, NUM_TEAM_3); // yellow
spawnfunc_info_player_deathmatch(this);
}
Keys: "angle" viewing angle when spawning. */
spawnfunc(info_player_team4)
{
- this.__team = NUM_TEAM_4; // purple
+ setteam(this, NUM_TEAM_4); // purple
spawnfunc_info_player_deathmatch(this);
}
void SV_OnEntityPreSpawnFunction()
{SELFPARAM();
__spawnfunc_expect = this;
+ setteam(this, this.__team);
if (self)
if (self.gametypefilter != "")
if (!isGametypeInFilter(MapInfo_LoadedGametype, teamplay, have_team_spawns, self.gametypefilter))
int t = tokenize_console(s);
if (t >= 2)
{
- this.__team = --internalteam;
+ setteam(this, --internalteam);
for (int i = 1; i < t; ++i)
{
s = argv(i);
projects / xonotic / xonotic-data.pk3dir.git / commitdiff