football_touch();
return;
}
- if(!self.cnt && IS_PLAYER(other) && !other.frozen && !other.deadflag && (other != self.nb_dropper || time > self.nb_droptime + autocvar_g_nexball_delay_collect))
+ if(!self.cnt && IS_PLAYER(other) && !STAT(FROZEN, other) && !IS_DEAD(other) && (other != self.nb_dropper || time > self.nb_droptime + autocvar_g_nexball_delay_collect))
{
if(other.health <= 0)
return;
PROJECTILE_TOUCH;
if(attacker.team != other.team || autocvar_g_nexball_basketball_teamsteal)
- if((ball = other.ballcarried) && !other.frozen && !other.deadflag && (IS_PLAYER(attacker)))
+ if((ball = other.ballcarried) && !STAT(FROZEN, other) && !other.deadflag && (IS_PLAYER(attacker)))
{
other.velocity = other.velocity + normalize(self.velocity) * other.damageforcescale * autocvar_g_balance_nexball_secondary_force;
UNSET_ONGROUND(other);
return;
if(!IS_PLAYER(toucher)) { return; }
- if(toucher.frozen) { return; }
+ if(STAT(FROZEN, toucher)) { return; }
if(IS_DEAD(toucher)) { return; }
if ( SAME_TEAM(self,toucher) )
if ( IS_PLAYER(self) )
{
- if ( !self.frozen )
+ if ( !STAT(FROZEN, self) )
{
entity source_point = ons_Nearest_ControlPoint(self.origin, autocvar_g_onslaught_teleport_radius);
return false;
if(DIFF_TEAM(e, self) && e != self.monster_follow)
return false;
- if(e.frozen)
+ if(STAT(FROZEN, e))
return false;
if(!IS_PLAYER(e))
return (IS_MONSTER(e) && e.health < e.max_health);
|| (!IS_VEHICLE(player) && (player.flags & FL_NOTARGET))
|| (!autocvar_g_monsters_typefrag && player.BUTTON_CHAT)
|| (SAME_TEAM(player, mon))
- || (player.frozen)
+ || (STAT(FROZEN, player))
|| (player.alpha != 0 && player.alpha < 0.5)
)
{
if((self.enemy == world)
|| (IS_DEAD(self.enemy) || self.enemy.health < 1)
- || (self.enemy.frozen)
+ || (STAT(FROZEN, self.enemy))
|| (self.enemy.flags & FL_NOTARGET)
|| (self.enemy.alpha < 0.5 && self.enemy.alpha != 0)
|| (self.enemy.takedamage == DAMAGE_NO)
entity targ;
- if(self.frozen == 2)
+ if(STAT(FROZEN, self) == 2)
{
self.revive_progress = bound(0, self.revive_progress + self.ticrate * self.revive_speed, 1);
self.health = max(1, self.revive_progress * self.max_health);
return;
}
- else if(self.frozen == 3)
+ else if(STAT(FROZEN, self) == 3)
{
self.revive_progress = bound(0, self.revive_progress - self.ticrate * self.revive_speed, 1);
self.health = max(0, autocvar_g_nades_ice_health + (self.max_health-autocvar_g_nades_ice_health) * self.revive_progress );
self.nextthink = time;
self.monster_lifetime = time + 5;
- if(self.frozen)
+ if(STAT(FROZEN, self))
{
Unfreeze(self); // remove any icy remains
self.health = 0; // reset by Unfreeze
if((self.spawnflags & MONSTERFLAG_INVINCIBLE) && deathtype != DEATH_KILL.m_id && !ITEM_DAMAGE_NEEDKILL(deathtype))
return;
- if(self.frozen && deathtype != DEATH_KILL.m_id && deathtype != DEATH_NADE_ICE_FREEZE.m_id)
+ if(STAT(FROZEN, self) && deathtype != DEATH_KILL.m_id && deathtype != DEATH_NADE_ICE_FREEZE.m_id)
return;
//if(time < self.pain_finished && deathtype != DEATH_KILL.m_id)
deadbits = 0;
}
int animbits = deadbits;
- if(self.frozen)
+ if(STAT(FROZEN, self))
animbits |= ANIMSTATE_FROZEN;
if(self.crouch)
animbits |= ANIMSTATE_DUCK; // not that monsters can crouch currently...
}
if((self.team && DIFF_TEAM(other, self))
- || (other.frozen)
+ || (STAT(FROZEN, other))
|| (other.vehicle)
|| (!self.buff_active)
)
}
if(!self.buff_active && !self.buff_activetime)
- if(!self.owner || self.owner.frozen || IS_DEAD(self.owner) || !self.owner.iscreature || !(self.owner.buffs & self.buffs))
+ if(!self.owner || STAT(FROZEN, self.owner) || IS_DEAD(self.owner) || !self.owner.iscreature || !(self.owner.buffs & self.buffs))
{
buff_SetCooldown(autocvar_g_buffs_cooldown_respawn + frametime);
self.owner = world;
if(!IS_DEAD(frag_target))
if(IS_PLAYER(frag_target) || IS_MONSTER(frag_target))
if(frag_attacker != frag_target)
- if(!frag_target.frozen)
+ if(!STAT(FROZEN, frag_target))
if(frag_target.takedamage)
if(DIFF_TEAM(frag_attacker, frag_target))
{
float best_distance = autocvar_g_buffs_swapper_range;
entity closest = world;
FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(
- if(!IS_DEAD(it) && !it.frozen && !it.vehicle)
+ if(!IS_DEAD(it) && !STAT(FROZEN, it) && !it.vehicle)
if(DIFF_TEAM(it, self))
if(vlen(self.origin - it.origin) <= best_distance)
{
if(time >= self.buff_time)
buff_lost = 2;
- if(self.frozen) { buff_lost = 1; }
+ if(STAT(FROZEN, self)) { buff_lost = 1; }
if(buff_lost)
{
if(IS_PLAYER(self))
if(IS_REAL_CLIENT(self)) // bots may camp, but that's no reason to constantly kill them
if(!IS_DEAD(self))
- if(!self.frozen)
+ if(!STAT(FROZEN, self))
if(!self.BUTTON_CHAT)
if(autocvar_g_campcheck_interval)
{
if(e.takedamage == DAMAGE_AIM)
if(self.realowner != e || autocvar_g_nades_napalm_selfdamage)
if(!IS_PLAYER(e) || !self.realowner || DIFF_TEAM(e, self))
- if(!e.frozen)
+ if(!STAT(FROZEN, e))
{
p = e.origin;
p.x += e.mins.x + random() * (e.maxs.x - e.mins.x);
if(e.takedamage && !IS_DEAD(e))
if(e.health > 0)
if(!e.revival_time || ((time - e.revival_time) >= 1.5))
- if(!e.frozen)
+ if(!STAT(FROZEN, e))
if(current_freeze_time > 0)
nade_ice_freeze(self, e, current_freeze_time);
}
float health_factor;
if(IS_PLAYER(other) || IS_MONSTER(other))
if(!IS_DEAD(other))
- if(!other.frozen)
+ if(!STAT(FROZEN, other))
{
health_factor = autocvar_g_nades_heal_rate*frametime/2;
if ( other != self.realowner )
if (autocvar_g_nades_bonus)
if (IS_REAL_CLIENT(player))
if (IS_PLAYER(player) && player.bonus_nades < autocvar_g_nades_bonus_max)
- if (player.frozen == 0)
+ if (STAT(FROZEN, player) == 0)
if (!IS_DEAD(player))
{
if ( player.bonus_nade_score < 1 )
n = 0;
FOREACH_CLIENT(IS_PLAYER(it) && it != self, LAMBDA(
if(!IS_DEAD(it))
- if(it.frozen == 0)
+ if(STAT(FROZEN, it) == 0)
if(SAME_TEAM(it, self))
if(boxesoverlap(self.absmin - revive_extra_size, self.absmax + revive_extra_size, it.absmin, it.absmax))
{
if(!o)
o = it;
- if(self.frozen == 1)
+ if(STAT(FROZEN, self) == 1)
it.reviving = true;
++n;
}
));
}
- if(n && self.frozen == 3) // OK, there is at least one teammate reviving us
+ if(n && STAT(FROZEN, self) == 3) // OK, there is at least one teammate reviving us
{
self.revive_progress = bound(0, self.revive_progress + frametime * max(1/60, autocvar_g_freezetag_revive_speed), 1);
self.health = max(1, self.revive_progress * start_health);
MUTATOR_HOOKFUNCTION(nades, PlayerDies, CBC_ORDER_LAST)
{
if(frag_target.nade)
- if(!frag_target.frozen || !autocvar_g_freezetag_revive_nade)
+ if(!STAT(FROZEN, frag_target) || !autocvar_g_freezetag_revive_nade)
toss_nade(frag_target, '0 0 100', max(frag_target.nade.wait, time + 0.05));
float killcount_bonus = ((frag_attacker.killcount >= 1) ? bound(0, autocvar_g_nades_bonus_score_minor * frag_attacker.killcount, autocvar_g_nades_bonus_score_medium) : autocvar_g_nades_bonus_score_minor);
MUTATOR_HOOKFUNCTION(nades, PlayerDamage_Calculate)
{
- if(frag_target.frozen)
+ if(STAT(FROZEN, frag_target))
if(autocvar_g_freezetag_revive_nade)
if(frag_attacker == frag_target)
if(frag_deathtype == DEATH_NADE.m_id)
if(frag_attacker != frag_target)
if(frag_target.health > 0)
- if(frag_target.frozen == 0)
+ if(STAT(FROZEN, frag_target) == 0)
if(!IS_DEAD(frag_target))
{
Send_Notification(NOTIF_ONE, frag_attacker, MSG_CENTER, CENTER_SECONDARY_NODAMAGE);
MUTATOR_HOOKFUNCTION(ok, PlayerRegen)
{SELFPARAM();
// overkill's values are different, so use custom regen
- if(!self.frozen)
+ if(!STAT(FROZEN, self))
{
self.armorvalue = CalcRotRegen(self.armorvalue, autocvar_g_balance_armor_regenstable, autocvar_g_balance_armor_regen, autocvar_g_balance_armor_regenlinear, 1 * frametime * (time > self.ok_pauseregen_finished), 0, 0, 1, 1 * frametime * (time > self.pauserotarmor_finished), autocvar_g_balance_armor_limit);
self.health = CalcRotRegen(self.health, autocvar_g_balance_health_regenstable, 0, 100, 1 * frametime * (time > self.ok_pauseregen_finished), 200, 0, autocvar_g_balance_health_rotlinear, 1 * frametime * (time > self.pauserothealth_finished), autocvar_g_balance_health_limit);
if(intermission_running || gameover)
return false;
- if(IS_DEAD(self) || !IS_PLAYER(self) || self.frozen)
+ if(IS_DEAD(self) || !IS_PLAYER(self) || STAT(FROZEN, self))
return false;
if(self.ok_lastwep)
if(it.msnt_timer < time)
if(SAME_TEAM(self, it))
if(time > it.spawnshieldtime) // spawn shielding
- if(it.frozen == 0)
+ if(STAT(FROZEN, it) == 0)
if(it != self)
{
tracebox(it.origin, STAT(PL_MIN, NULL), STAT(PL_MAX, NULL), it.origin - '0 0 100', MOVE_WORLDONLY, it);
{SELFPARAM();
if(time > self.touchexplode_time)
if(!gameover)
- if(!self.frozen)
+ if(!STAT(FROZEN, self))
if(IS_PLAYER(self))
if(!IS_DEAD(self))
if(!IS_INDEPENDENT_PLAYER(self))
FOREACH_CLIENT(IS_PLAYER(it) && it != self, LAMBDA(
if(time > it.touchexplode_time)
- if(!it.frozen)
+ if(!STAT(FROZEN, it))
if(!IS_DEAD(it))
if (!IS_INDEPENDENT_PLAYER(it))
if(boxesoverlap(self.absmin, self.absmax, it.absmin, it.absmax))
if(IS_PLAYER(self.aiment))
if(self.last_dmg < time)
- if(!self.aiment.frozen)
+ if(!STAT(FROZEN, self.aiment))
if(time >= game_starttime)
if(DIFF_TEAM(self.owner, self.aiment) || autocvar_g_vampirehook_teamheal)
if(self.aiment.health > 0)
}
if(!(other.flags & FL_PICKUPITEMS)
- || other.frozen
+ || STAT(FROZEN, other)
|| other.deadflag
|| (this.solid != SOLID_TRIGGER)
|| (this.owner == other)
}
else if (e_target.health <= 0)
return -6;
- else if(e_target.frozen > 0)
+ else if(STAT(FROZEN, e_target) > 0)
return -6;
// player
if((!IS_PLAYER(pl))
|| (veh.phase >= time)
|| (pl.vehicle_enter_delay >= time)
- || (pl.frozen)
+ || (STAT(FROZEN, pl))
|| (IS_DEAD(pl))
|| (pl.vehicle)
) { return; }
||
(!self.owner.BUTTON_ATCK && !burst )
||
- self.owner.frozen
+ STAT(FROZEN, self.owner)
||
self.owner.vehicle
||
// a player's mines shall explode if he disconnects or dies
// TODO: Do this on team change too -- Samual: But isn't a player killed when they switch teams?
- if(!IS_PLAYER(self.realowner) || IS_DEAD(self.realowner) || self.realowner.frozen)
+ if(!IS_PLAYER(self.realowner) || IS_DEAD(self.realowner) || STAT(FROZEN, self.realowner))
{
other = world;
self.projectiledeathtype |= HITTYPE_BOUNCE;
head = findradius(self.origin, WEP_CVAR(minelayer, proximityradius));
while(head)
{
- if(IS_PLAYER(head) && !IS_DEAD(head) && !head.frozen)
+ if(IS_PLAYER(head) && !IS_DEAD(head) && !STAT(FROZEN, head))
if(head != self.realowner && DIFF_TEAM(head, self.realowner)) // don't trigger for team mates
if(!self.mine_time)
{
return false;
}
- if(e.frozen)
+ if(STAT(FROZEN, e))
return false;
if(teamplay)
if (!e.takedamage)
return false;
- if (e.deadflag)
+ if (IS_DEAD(e))
return false;
if (e.BUTTON_CHAT)
return false;
{SELFPARAM();
if(gameover) return;
if(self.player_blocked) return;
- if(self.frozen) return;
+ if(STAT(FROZEN, self)) return;
ClientKill_TeamChange(0);
}
regen_health_stable = autocvar_g_balance_health_regenstable;
regen_health_rotstable = autocvar_g_balance_health_rotstable;
if(!MUTATOR_CALLHOOK(PlayerRegen))
- if(!self.frozen)
+ if(!STAT(FROZEN, self))
{
float mina, maxa, limith, limita;
maxa = autocvar_g_balance_armor_rotstable;
self.dmg_inflictor = spectatee.dmg_inflictor;
self.v_angle = spectatee.v_angle;
self.angles = spectatee.v_angle;
- self.frozen = spectatee.frozen;
+ STAT(FROZEN, self) = STAT(FROZEN, spectatee);
self.revive_progress = spectatee.revive_progress;
if(!self.BUTTON_USE)
self.fixangle = true;
}
else if(autocvar_g_vehicles_enter)
{
- if(!self.frozen)
+ if(!STAT(FROZEN, self))
if(!IS_DEAD(self))
if(!gameover)
{
self.max_armorvalue = 0;
}
- if(self.frozen == 2)
+ if(STAT(FROZEN, self) == 2)
{
self.revive_progress = bound(0, self.revive_progress + frametime * self.revive_speed, 1);
self.health = max(1, self.revive_progress * start_health);
if(self.revive_progress >= 1)
Unfreeze(self);
}
- else if(self.frozen == 3)
+ else if(STAT(FROZEN, self) == 3)
{
self.revive_progress = bound(0, self.revive_progress - frametime * self.revive_speed, 1);
self.health = max(0, autocvar_g_nades_ice_health + (start_health-autocvar_g_nades_ice_health) * self.revive_progress );
if(time > self.last_vehiclecheck)
if(IS_PLAYER(self))
if(!gameover)
- if(!self.frozen)
+ if(!STAT(FROZEN, self))
if(!self.vehicle)
if(!IS_DEAD(self))
{
do_crouch = 0;
if(self.vehicle)
do_crouch = 0;
- if(self.frozen)
+ if(STAT(FROZEN, self))
do_crouch = 0;
// WEAPONTODO: THIS SHIT NEEDS TO GO EVENTUALLY
deadbits = 0;
}
int animbits = deadbits;
- if(self.frozen)
+ if(STAT(FROZEN, self))
animbits |= ANIMSTATE_FROZEN;
if(self.movetype == MOVETYPE_FOLLOW)
animbits |= ANIMSTATE_FOLLOW;
if (!IS_PLAYER(caller)) { print_to(caller, "You must be playing to spawn a monster"); return; }
if (MUTATOR_CALLHOOK(AllowMobSpawning)) { print_to(caller, ret_string); return; }
if (caller.vehicle) { print_to(caller, "You can't spawn monsters while driving a vehicle"); return; }
- if (caller.frozen) { print_to(caller, "You can't spawn monsters while frozen"); return; }
+ if (STAT(FROZEN, caller)) { print_to(caller, "You can't spawn monsters while frozen"); return; }
if (IS_DEAD(caller)) { print_to(caller, "You can't spawn monsters while dead"); return; }
if (tmp_moncount >= autocvar_g_monsters_max) { print_to(caller, "The maximum monster count has been reached"); return; }
if (tmp_moncount >= autocvar_g_monsters_max_perplayer) { print_to(caller, "You can't spawn any more monsters"); return; }
if (it.reset2) WITH(entity, self, it, it.reset2());
));
- FOREACH_CLIENT(IS_PLAYER(it) && it.frozen, LAMBDA(WITH(entity, self, it, Unfreeze(it))));
+ FOREACH_CLIENT(IS_PLAYER(it) && STAT(FROZEN, it), LAMBDA(WITH(entity, self, it, Unfreeze(it))));
// Moving the player reset code here since the player-reset depends
// on spawnpoint entities which have to be reset first --blub
void Ice_Think()
{SELFPARAM();
- if(!self.owner.frozen || self.owner.iceblock != self)
+ if(!STAT(FROZEN, self.owner) || self.owner.iceblock != self)
{
remove(self);
return;
if(!IS_PLAYER(targ) && !IS_MONSTER(targ)) // only specified entities can be freezed
return;
- if(targ.frozen)
+ if(STAT(FROZEN, targ))
return;
float targ_maxhealth = ((IS_MONSTER(targ)) ? targ.max_health : start_health);
- targ.frozen = frozen_type;
+ STAT(FROZEN, targ) = frozen_type;
targ.revive_progress = ((frozen_type == 3) ? 1 : 0);
targ.health = ((frozen_type == 3) ? targ_maxhealth : 1);
targ.revive_speed = freeze_time;
void Unfreeze (entity targ)
{
- if(!targ.frozen)
+ if(!STAT(FROZEN, targ))
return;
- if(targ.frozen && targ.frozen != 3) // only reset health if target was frozen
+ if(STAT(FROZEN, targ) && STAT(FROZEN, targ) != 3) // only reset health if target was frozen
targ.health = ((IS_PLAYER(targ)) ? start_health : targ.max_health);
- targ.frozen = 0;
+ STAT(FROZEN, targ) = 0;
targ.revive_progress = 0;
targ.revival_time = time;
self.bot_attack = true;
mirrordamage = frag_mirrordamage;
force = frag_force;
- if(targ.frozen)
+ if(STAT(FROZEN, targ))
if(deathtype != DEATH_HURTTRIGGER.m_id && deathtype != DEATH_TEAMCHANGE.m_id && deathtype != DEATH_AUTOTEAMCHANGE.m_id)
{
if(autocvar_g_frozen_revive_falldamage > 0)
force *= autocvar_g_frozen_force;
}
- if(targ.frozen && deathtype == DEATH_HURTTRIGGER.m_id && !autocvar_g_frozen_damage_trigger)
+ if(STAT(FROZEN, targ) && deathtype == DEATH_HURTTRIGGER.m_id && !autocvar_g_frozen_damage_trigger)
{
Send_Effect(EFFECT_TELEPORT, targ.origin, '0 0 0', 1);
if(IS_PLAYER(victim) || (IS_TURRET(victim) && victim.active == ACTIVE_ACTIVE) || IS_MONSTER(victim) || MUTATOR_CALLHOOK(PlayHitsound, victim))
{
- if(DIFF_TEAM(victim, attacker) && !victim.frozen)
+ if(DIFF_TEAM(victim, attacker) && !STAT(FROZEN, victim))
{
if(damage > 0)
{
e.fire_endtime = 0;
// ice stops fire
- if(e.frozen)
+ if(STAT(FROZEN, e))
e.fire_endtime = 0;
t = min(frametime, e.fire_endtime - time);
e.fire_hitsound = true;
if(!IS_INDEPENDENT_PLAYER(e))
- if(!e.frozen)
+ if(!STAT(FROZEN, e))
FOREACH_CLIENT(IS_PLAYER(it) && it != e, LAMBDA(
if(!IS_DEAD(it))
if(!IS_INDEPENDENT_PLAYER(it))
{
entity aim_ent = ((IS_VEHICLE(self.aiment) && self.aiment.owner) ? self.aiment.owner : self.aiment);
v = v - dv * 0.5;
- if((frozen_pulling && self.aiment.frozen) || !frozen_pulling)
+ if((frozen_pulling && STAT(FROZEN, self.aiment)) || !frozen_pulling)
{
self.aiment.velocity = self.aiment.velocity - dv * 0.5;
UNSET_ONGROUND(self.aiment);
if(!frozen_pulling && !(self.aiment.flags & FL_PROJECTILE))
pull_entity.velocity = WarpZone_RefSys_TransformVelocity(self, pull_entity, v * velocity_multiplier);
- if(frozen_pulling && autocvar_g_balance_grapplehook_pull_frozen == 2 && !self.aiment.frozen)
+ if(frozen_pulling && autocvar_g_balance_grapplehook_pull_frozen == 2 && !STAT(FROZEN, self.aiment))
{
RemoveGrapplingHook(self.realowner);
return;
FOREACH_CLIENT(IS_PLAYER(it) && SAME_TEAM(toucher, it), LAMBDA(++num_perteam));
// special touch behaviors
- if(toucher.frozen) { return; }
+ if(STAT(FROZEN, toucher)) { return; }
else if(IS_VEHICLE(toucher))
{
if(autocvar_g_ctf_allow_vehicle_touch && toucher.owner)
FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(
switch(it.team)
{
- case NUM_TEAM_1: ++total_players; if(it.health >= 1 && it.frozen != 1) ++redalive; break;
- case NUM_TEAM_2: ++total_players; if(it.health >= 1 && it.frozen != 1) ++bluealive; break;
- case NUM_TEAM_3: ++total_players; if(it.health >= 1 && it.frozen != 1) ++yellowalive; break;
- case NUM_TEAM_4: ++total_players; if(it.health >= 1 && it.frozen != 1) ++pinkalive; break;
+ case NUM_TEAM_1: ++total_players; if(it.health >= 1 && STAT(FROZEN, it) != 1) ++redalive; break;
+ case NUM_TEAM_2: ++total_players; if(it.health >= 1 && STAT(FROZEN, it) != 1) ++bluealive; break;
+ case NUM_TEAM_3: ++total_players; if(it.health >= 1 && STAT(FROZEN, it) != 1) ++yellowalive; break;
+ case NUM_TEAM_4: ++total_players; if(it.health >= 1 && STAT(FROZEN, it) != 1) ++pinkalive; break;
}
));
FOREACH_CLIENT(IS_REAL_CLIENT(it), LAMBDA(
entity last_pl = world;
FOREACH_CLIENT(IS_PLAYER(it) && it != self, LAMBDA(
if(it.health >= 1)
- if(!it.frozen)
+ if(!STAT(FROZEN, it))
if(SAME_TEAM(it, self))
if(!last_pl)
last_pl = it;
void freezetag_Freeze(entity attacker)
{SELFPARAM();
- if(self.frozen)
+ if(STAT(FROZEN, self))
return;
if(autocvar_g_freezetag_frozen_maxtime > 0)
float freezetag_isEliminated(entity e)
{
- if(IS_PLAYER(e) && (e.frozen == 1 || IS_DEAD(e)))
+ if(IS_PLAYER(e) && (STAT(FROZEN, e) == 1 || IS_DEAD(e)))
return true;
return false;
}
float distance;
FOREACH_CLIENT(IS_PLAYER(it) && it != self && SAME_TEAM(it, self), LAMBDA(
- if (it.frozen == 1)
+ if (STAT(FROZEN, it) == 1)
{
distance = vlen(it.origin - org);
if (distance > sradius)
// Count how many players on team are unfrozen.
int unfrozen = 0;
- FOREACH_CLIENT(IS_PLAYER(it) && SAME_TEAM(it, self) && !(it.frozen != 1), LAMBDA(unfrozen++));
+ FOREACH_CLIENT(IS_PLAYER(it) && SAME_TEAM(it, self) && !(STAT(FROZEN, it) != 1), LAMBDA(unfrozen++));
// If only one left on team or if role has timed out then start trying to free players.
- if (((unfrozen == 0) && (!self.frozen)) || (time > self.havocbot_role_timeout))
+ if (((unfrozen == 0) && (!STAT(FROZEN, self))) || (time > self.havocbot_role_timeout))
{
LOG_TRACE("changing role to freeing\n");
self.havocbot_role = havocbot_role_ft_freeing;
void ft_RemovePlayer()
{SELFPARAM();
self.health = 0; // neccessary to update correctly alive stats
- if(!self.frozen)
+ if(!STAT(FROZEN, self))
freezetag_LastPlayerForTeam_Notify();
freezetag_Unfreeze(world);
freezetag_count_alive_players();
if(round_handler_IsActive())
if(round_handler_CountdownRunning())
{
- if(self.frozen)
+ if(STAT(FROZEN, self))
freezetag_Unfreeze(world);
freezetag_count_alive_players();
return 1; // let the player die so that he can respawn whenever he wants
|| frag_deathtype == DEATH_TEAMCHANGE.m_id || frag_deathtype == DEATH_AUTOTEAMCHANGE.m_id)
{
// let the player die, he will be automatically frozen when he respawns
- if(self.frozen != 1)
+ if(STAT(FROZEN, self) != 1)
{
freezetag_Add_Score(frag_attacker);
freezetag_count_alive_players();
return 1;
}
- if(self.frozen)
+ if(STAT(FROZEN, self))
return 1;
freezetag_Freeze(frag_attacker);
if(gameover)
return 1;
- if(self.frozen == 1)
+ if(STAT(FROZEN, self) == 1)
{
// keep health = 1
self.pauseregen_finished = time + autocvar_g_balance_pause_health_regen;
entity o;
o = world;
- //if(self.frozen)
+ //if(STAT(FROZEN, self))
//if(self.freezetag_frozen_timeout > 0 && time < self.freezetag_frozen_timeout)
//self.iceblock.alpha = ICE_MIN_ALPHA + (ICE_MAX_ALPHA - ICE_MIN_ALPHA) * (self.freezetag_frozen_timeout - time) / (self.freezetag_frozen_timeout - self.freezetag_frozen_time);
vector revive_extra_size = '1 1 1' * autocvar_g_freezetag_revive_extra_size;
n = 0;
FOREACH_CLIENT(IS_PLAYER(it) && it != self, LAMBDA(
- if(it.frozen == 0)
+ if(STAT(FROZEN, it) == 0)
if(!IS_DEAD(it))
if(SAME_TEAM(it, self))
if(boxesoverlap(self.absmin - revive_extra_size, self.absmax + revive_extra_size, it.absmin, it.absmax))
{
if(!o)
o = it;
- if(self.frozen == 1)
+ if(STAT(FROZEN, self) == 1)
it.reviving = true;
++n;
}
}
- if(n && self.frozen == 1) // OK, there is at least one teammate reviving us
+ if(n && STAT(FROZEN, self) == 1) // OK, there is at least one teammate reviving us
{
self.revive_progress = bound(0, self.revive_progress + frametime * max(1/60, autocvar_g_freezetag_revive_speed), 1);
self.health = max(1, self.revive_progress * ((warmup_stage) ? warmup_start_health : start_health));
it.reviving = false;
));
}
- else if(!n && self.frozen == 1) // only if no teammate is nearby will we reset
+ else if(!n && STAT(FROZEN, self) == 1) // only if no teammate is nearby will we reset
{
self.revive_progress = bound(0, self.revive_progress - frametime * autocvar_g_freezetag_revive_clearspeed, 1);
self.health = max(1, self.revive_progress * ((warmup_stage) ? warmup_start_health : start_health));
}
- else if(!n && !self.frozen)
+ else if(!n && !STAT(FROZEN, self))
{
self.revive_progress = 0; // thawing nobody
}
return;
}
if(IS_DEAD(other)) { return; }
- if(other.frozen) { return; }
+ if(STAT(FROZEN, other)) { return; }
if (!IS_PLAYER(other))
{ // The ball just touched an object, most likely the world
Send_Effect(EFFECT_BALL_SPARKS, self.origin, '0 0 0', 1);
if (warmup_stage) return false;
if (IS_DEAD(targ)) return false;
- if (targ.frozen) return false;
+ if (STAT(FROZEN, targ)) return false;
if (SAME_TEAM(attacker, targ)) return false;
if (mutator_check == MUT_ACCADD_INVALID) return true;
if (time < game_starttime && !autocvar_sv_ready_restart_after_countdown) return true;
if (round_handler_IsActive() && !round_handler_IsRoundStarted()) return true;
if (player.player_blocked) return true;
- if (player.frozen) return true;
+ if (STAT(FROZEN, player)) return true;
if (player.weapon_blocked) return true;
return false;
}