sv_survival.qc File Reference

#include "sv_survival.qh"

Include dependency graph for sv_survival.qc:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	STATUS_SEND_HUNTERS   2
#define	STATUS_SEND_RESET   1

Functions
	MUTATOR_HOOKFUNCTION (surv, AddPlayerScore)
	MUTATOR_HOOKFUNCTION (surv, Bot_FixCount, CBC_ORDER_EXCLUSIVE)
	MUTATOR_HOOKFUNCTION (surv, Bot_ForbidAttack)
	MUTATOR_HOOKFUNCTION (surv, CalculateRespawnTime)
	MUTATOR_HOOKFUNCTION (surv, ClientCommand_Spectate)
	MUTATOR_HOOKFUNCTION (surv, ClientDisconnect)
	MUTATOR_HOOKFUNCTION (surv, ClientObituary)
	MUTATOR_HOOKFUNCTION (surv, ForbidSpawn)
	MUTATOR_HOOKFUNCTION (surv, GiveFragsForKill, CBC_ORDER_FIRST)
	MUTATOR_HOOKFUNCTION (surv, MakePlayerObserver)
	MUTATOR_HOOKFUNCTION (surv, MatchEnd_BeforeScores)
	MUTATOR_HOOKFUNCTION (surv, PlayerDies)
	MUTATOR_HOOKFUNCTION (surv, PlayerSpawn)
	MUTATOR_HOOKFUNCTION (surv, PutClientInServer)
	MUTATOR_HOOKFUNCTION (surv, reset_map_global)
	MUTATOR_HOOKFUNCTION (surv, reset_map_players)
	MUTATOR_HOOKFUNCTION (surv, Scores_CountFragsRemaining)
bool	Surv_CheckPlayers ()
float	Surv_CheckWinner ()
void	surv_Initialize ()
bool	surv_isEliminated (entity e)
entity	surv_LastPlayerForTeam (entity this)
void	surv_LastPlayerForTeam_Notify (entity this)
void	Surv_RoundStart ()
void	Surv_UpdateScores (bool timed_out)
void	SurvivalStatuses_Init ()
bool	SurvivalStatuses_SendEntity (entity this, entity dest, float sendflags)

Variables
float	autocvar_g_survival_hunter_count = 0.25
bool	autocvar_g_survival_punish_teamkill = true
bool	autocvar_g_survival_reward_survival = true
float	autocvar_g_survival_round_enddelay
float	autocvar_g_survival_round_timelimit = 120
float	autocvar_g_survival_warmup = 10
entity	survivalStatuses

Macro Definition Documentation

STATUS_SEND_HUNTERS

#define STATUS_SEND_HUNTERS   2

Definition at line 14 of file sv_survival.qc.

Referenced by Surv_CheckWinner(), and SurvivalStatuses_SendEntity().

STATUS_SEND_RESET

#define STATUS_SEND_RESET   1

Definition at line 13 of file sv_survival.qc.

Referenced by MUTATOR_HOOKFUNCTION(), and Surv_RoundStart().

Function Documentation

MUTATOR_HOOKFUNCTION() [1/17]

MUTATOR_HOOKFUNCTION	(	surv	,
		AddPlayerScore	)

Definition at line 446 of file sv_survival.qc.

{
    entity scorefield = M_ARGV(0, entity);
    if(scorefield == SP_KILLS || scorefield == SP_DEATHS || scorefield == SP_SUICIDES || scorefield == SP_DMG || scorefield == SP_DMGTAKEN)
        M_ARGV(1, float) = 0; // don't report that the player has killed or been killed, that would out them as a hunter!
}

References entity(), and M_ARGV.

MUTATOR_HOOKFUNCTION() [2/17]

MUTATOR_HOOKFUNCTION	(	surv	,
		Bot_FixCount	,
		CBC_ORDER_EXCLUSIVE	)

Definition at line 459 of file sv_survival.qc.

{
    FOREACH_CLIENT(IS_REAL_CLIENT(it), {
        if (IS_PLAYER(it) || INGAME_JOINED(it))
            ++M_ARGV(0, int);
        ++M_ARGV(1, int);
    });
    return true;
}

References CBC_ORDER_EXCLUSIVE, FOREACH_CLIENT, INGAME_JOINED, IS_PLAYER, IS_REAL_CLIENT, and M_ARGV.

MUTATOR_HOOKFUNCTION() [3/17]

MUTATOR_HOOKFUNCTION	(	surv	,
		Bot_ForbidAttack	)

Definition at line 484 of file sv_survival.qc.

{
    entity bot = M_ARGV(0, entity);
    entity targ = M_ARGV(1, entity);
 
    if(targ.survival_status == bot.survival_status)
        return true;
}

References entity(), and M_ARGV.

MUTATOR_HOOKFUNCTION() [4/17]

MUTATOR_HOOKFUNCTION	(	surv	,
		CalculateRespawnTime	)

Definition at line 453 of file sv_survival.qc.

{
    // no respawn calculations needed, player is forced to spectate anyway
    return true;
}

MUTATOR_HOOKFUNCTION() [5/17]

MUTATOR_HOOKFUNCTION	(	surv	,
		ClientCommand_Spectate	)

Definition at line 469 of file sv_survival.qc.

{
    entity player = M_ARGV(0, entity);
 
    if (INGAME(player))
    {
        // they're going to spec, we can do other checks
        if (autocvar_sv_spectate && (IS_SPEC(player) || IS_OBSERVER(player)))
            Send_Notification(NOTIF_ONE_ONLY, player, MSG_INFO, INFO_CA_LEAVE);
        return MUT_SPECCMD_FORCE;
    }
 
    return MUT_SPECCMD_CONTINUE;
}

References autocvar_sv_spectate, entity(), INGAME, IS_OBSERVER, IS_SPEC, M_ARGV, MUT_SPECCMD_CONTINUE, MUT_SPECCMD_FORCE, and Send_Notification().

MUTATOR_HOOKFUNCTION() [6/17]

MUTATOR_HOOKFUNCTION	(	surv	,
		ClientDisconnect	)

Definition at line 398 of file sv_survival.qc.

{
    entity player = M_ARGV(0, entity);
 
    if (IS_PLAYER(player) && !IS_DEAD(player))
        surv_LastPlayerForTeam_Notify(player);
    return true;
}

References ClientDisconnect, entity(), IS_DEAD, IS_PLAYER, M_ARGV, and surv_LastPlayerForTeam_Notify().

MUTATOR_HOOKFUNCTION() [7/17]

MUTATOR_HOOKFUNCTION	(	surv	,
		ClientObituary	)

Definition at line 256 of file sv_survival.qc.

{
    // in survival, announcing a frag would tell everyone who the hunter is
    entity frag_attacker = M_ARGV(1, entity);
    entity frag_target = M_ARGV(2, entity);
    if(IS_PLAYER(frag_attacker) && frag_attacker != frag_target)
    {
        float frag_deathtype = M_ARGV(3, float);
        entity wep_ent = M_ARGV(4, entity);
        // "team" kill, a point is awarded to the player by default so we must take it away plus an extra one
        // unless the player is going to be punished for suicide, in which case just remove one
        if(frag_attacker.survival_status == frag_target.survival_status)
            GiveFrags(frag_attacker, frag_target, ((autocvar_g_survival_punish_teamkill) ? -1 : -2), frag_deathtype, wep_ent.weaponentity_fld);
    }
 
    if(frag_attacker.survival_status == SURV_STATUS_HUNTER)
        M_ARGV(5, bool) = true; // anonymous attacker
}

References autocvar_g_survival_punish_teamkill, entity(), frag_target, GiveFrags(), IS_PLAYER, M_ARGV, and SURV_STATUS_HUNTER.

MUTATOR_HOOKFUNCTION() [8/17]

MUTATOR_HOOKFUNCTION	(	surv	,
		ForbidSpawn	)

Definition at line 286 of file sv_survival.qc.

{
    entity player = M_ARGV(0, entity);
 
    // spectators / observers that weren't playing can join; they are
    // immediately forced to observe in the PutClientInServer hook
    // this way they are put in a team and can play in the next round
    if (!allowed_to_spawn && INGAME(player))
        return true;
    return false;
}

References allowed_to_spawn, entity(), INGAME, and M_ARGV.

MUTATOR_HOOKFUNCTION() [9/17]

MUTATOR_HOOKFUNCTION	(	surv	,
		GiveFragsForKill	,
		CBC_ORDER_FIRST	)

Definition at line 437 of file sv_survival.qc.

{
    entity frag_attacker = M_ARGV(0, entity);
    if(!warmup_stage && round_handler_IsActive() && round_handler_IsRoundStarted())
        frag_attacker.survival_validkills += M_ARGV(2, float);
    M_ARGV(2, float) = 0; // score will be given to the winner when the round ends
    return true;
}

References CBC_ORDER_FIRST, entity(), M_ARGV, round_handler_IsActive, round_handler_IsRoundStarted, and warmup_stage.

MUTATOR_HOOKFUNCTION() [10/17]

MUTATOR_HOOKFUNCTION	(	surv	,
		MakePlayerObserver	)

Definition at line 407 of file sv_survival.qc.

{
    entity player = M_ARGV(0, entity);
    bool is_forced = M_ARGV(1, bool);
    if (is_forced && INGAME(player))
        INGAME_STATUS_CLEAR(player);
 
    if (IS_PLAYER(player) && !IS_DEAD(player))
        surv_LastPlayerForTeam_Notify(player);
    if (player.killindicator_teamchange == -2) // player wants to spectate
        INGAME_STATUS_CLEAR(player);
    if (INGAME(player))
        player.frags = FRAGS_PLAYER_OUT_OF_GAME;
    if (!warmup_stage)
        eliminatedPlayers.SendFlags = 0xFFFFFF;
    if (!INGAME(player))
    {
        player.survival_validkills = 0;
        player.survival_status = 0;
        return false;  // allow team reset
    }
    return true;  // prevent team reset
}

References eliminatedPlayers, entity(), FRAGS_PLAYER_OUT_OF_GAME, INGAME, INGAME_STATUS_CLEAR, IS_DEAD, IS_PLAYER, M_ARGV, surv_LastPlayerForTeam_Notify(), and warmup_stage.

MUTATOR_HOOKFUNCTION() [11/17]

MUTATOR_HOOKFUNCTION	(	surv	,
		MatchEnd_BeforeScores	)

Definition at line 339 of file sv_survival.qc.

{
    MatchEnd_RestoreSpectatorStatus();
    return true;
}

References MatchEnd_RestoreSpectatorStatus().

MUTATOR_HOOKFUNCTION() [12/17]

MUTATOR_HOOKFUNCTION	(	surv	,
		PlayerDies	)

Definition at line 370 of file sv_survival.qc.

{
    entity frag_attacker = M_ARGV(1, entity);
    entity frag_target = M_ARGV(2, entity);
    float frag_deathtype = M_ARGV(3, float);
 
    surv_LastPlayerForTeam_Notify(frag_target);
    if (!allowed_to_spawn)
    {
        frag_target.respawn_flags = RESPAWN_SILENT;
        // prevent unwanted sudden rejoin as spectator and movement of spectator camera
        frag_target.respawn_time = time + 2;
    }
    frag_target.respawn_flags |= RESPAWN_FORCE;
    if (!warmup_stage)
    {
        eliminatedPlayers.SendFlags = 0xFFFFFF;
        if (IS_BOT_CLIENT(frag_target))
            bot_clearqueue(frag_target);
    }
 
    // killed an ally! punishment is death
    if(autocvar_g_survival_punish_teamkill && frag_attacker != frag_target && IS_PLAYER(frag_attacker) && IS_PLAYER(frag_target) && frag_attacker.survival_status == frag_target.survival_status && !ITEM_DAMAGE_NEEDKILL(frag_deathtype))
    if(!warmup_stage && round_handler_IsActive() && round_handler_IsRoundStarted()) // don't autokill if the round hasn't started yet
        Damage(frag_attacker, frag_attacker, frag_attacker, 100000, DEATH_MIRRORDAMAGE.m_id, DMG_NOWEP, frag_attacker.origin, '0 0 0');
    return true;
}

References allowed_to_spawn, autocvar_g_survival_punish_teamkill, bot_clearqueue(), Damage(), DMG_NOWEP, eliminatedPlayers, entity(), frag_target, IS_BOT_CLIENT, IS_PLAYER, ITEM_DAMAGE_NEEDKILL, M_ARGV, RESPAWN_FORCE, RESPAWN_SILENT, round_handler_IsActive, round_handler_IsRoundStarted, surv_LastPlayerForTeam_Notify(), time, and warmup_stage.

MUTATOR_HOOKFUNCTION() [13/17]

MUTATOR_HOOKFUNCTION	(	surv	,
		PlayerSpawn	)

Definition at line 275 of file sv_survival.qc.

{
    entity player = M_ARGV(0, entity);
 
    player.survival_status = 0;
    player.survival_validkills = 0;
    INGAME_STATUS_SET(player, INGAME_STATUS_JOINED);
    if (!warmup_stage)
        eliminatedPlayers.SendFlags = 0xFFFFFF;
}

References eliminatedPlayers, entity(), INGAME_STATUS_JOINED, INGAME_STATUS_SET, M_ARGV, and warmup_stage.

MUTATOR_HOOKFUNCTION() [14/17]

MUTATOR_HOOKFUNCTION	(	surv	,
		PutClientInServer	)

Definition at line 298 of file sv_survival.qc.

{
    entity player = M_ARGV(0, entity);
 
    if (!allowed_to_spawn && IS_PLAYER(player)) // this is true even when player is trying to join
    {
        TRANSMUTE(Observer, player);
        if (CS(player).jointime != time && !INGAME(player)) // not when connecting
        {
            INGAME_STATUS_SET(player, INGAME_STATUS_JOINING);
            Send_Notification(NOTIF_ONE_ONLY, player, MSG_INFO, INFO_CA_JOIN_LATE);
        }
    }
 
    if (!warmup_stage)
        eliminatedPlayers.SendFlags = 0xFFFFFF;
}

References allowed_to_spawn, CS(), eliminatedPlayers, entity(), INGAME, INGAME_STATUS_JOINING, INGAME_STATUS_SET, IS_PLAYER, jointime, M_ARGV, PutClientInServer, Send_Notification(), time, TRANSMUTE, and warmup_stage.

MUTATOR_HOOKFUNCTION() [15/17]

MUTATOR_HOOKFUNCTION	(	surv	,
		reset_map_global	)

Definition at line 333 of file sv_survival.qc.

{
    allowed_to_spawn = true;
    return true;
}

References allowed_to_spawn.

MUTATOR_HOOKFUNCTION() [16/17]

MUTATOR_HOOKFUNCTION	(	surv	,
		reset_map_players	)

Definition at line 316 of file sv_survival.qc.

{
    FOREACH_CLIENT(true, {
        CS(it).killcount = 0;
        it.survival_status = 0;
        if (INGAME(it) || IS_BOT_CLIENT(it))
        {
            TRANSMUTE(Player, it);
            INGAME_STATUS_SET(it, INGAME_STATUS_JOINED);
            PutClientInServer(it);
        }
    });
    bot_relinkplayerlist();
    survivalStatuses.SendFlags = STATUS_SEND_RESET;
    return true;
}

References bot_relinkplayerlist(), CS(), FOREACH_CLIENT, INGAME, INGAME_STATUS_JOINED, INGAME_STATUS_SET, IS_BOT_CLIENT, PutClientInServer, STATUS_SEND_RESET, survivalStatuses, and TRANSMUTE.

MUTATOR_HOOKFUNCTION() [17/17]

MUTATOR_HOOKFUNCTION	(	surv	,
		Scores_CountFragsRemaining	)

Definition at line 431 of file sv_survival.qc.

{
    // announce remaining frags?
    return true;
}

Surv_CheckPlayers()

bool Surv_CheckPlayers

(

)

Definition at line 195 of file sv_survival.qc.

{
    static int prev_missing_players;
    allowed_to_spawn = true;
    int playercount = 0;
    FOREACH_CLIENT(IS_PLAYER(it) && !IS_DEAD(it),
    {
        ++playercount;
    });
    // NOTE missing_teams_mask stat is used for missing players in ffa games
    if (playercount >= 2)
    {
        if(prev_missing_players > 0)
            missing_teams_mask = 0;
        prev_missing_players = -1;
        return true;
    }
    if(playercount == 0)
    {
        if(prev_missing_players > 0)
            missing_teams_mask = 0;
        prev_missing_players = -1;
        return false;
    }
    // if we get here, only 1 player is missing
    if(prev_missing_players != 1)
    {
        missing_teams_mask = 1;
        prev_missing_players = 1;
    }
    return false;
}

References allowed_to_spawn, FOREACH_CLIENT, IS_DEAD, IS_PLAYER, and missing_teams_mask.

Referenced by surv_Initialize().

Surv_CheckWinner()

float Surv_CheckWinner

(

)

Definition at line 76 of file sv_survival.qc.

{
    if(round_handler_GetEndTime() > 0 && round_handler_GetEndTime() - time <= 0
        && autocvar_g_survival_round_enddelay == -1)
    {
        // if the match times out, survivors win too!
        Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_SURVIVAL_SURVIVOR_WIN);
        Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_SURVIVAL_SURVIVOR_WIN);
        FOREACH_CLIENT(IS_PLAYER(it), {
            nades_RemovePlayer(it);
        });
 
        Surv_UpdateScores(true);
 
        allowed_to_spawn = false;
        game_stopped = true;
        round_handler_Init(5, autocvar_g_survival_warmup, autocvar_g_survival_round_timelimit);
        survivalStatuses.SendFlags = STATUS_SEND_HUNTERS;
        return 1;
    }
 
    int survivor_count = 0, hunter_count = 0;
    FOREACH_CLIENT(IS_PLAYER(it) && !IS_DEAD(it),
    {
        if(it.survival_status == SURV_STATUS_PREY)
            ++survivor_count;
        else if(it.survival_status == SURV_STATUS_HUNTER)
            ++hunter_count;
    });
    if(survivor_count > 0 && hunter_count > 0)
    {
        // Dr. Jaska:
        // reset delay time here only for consistency
        // Survival players currently have no known ways to resurrect
        round_handler_ResetEndDelayTime();
        return 0;
    }
 
    // delay round ending a bit
    if (autocvar_g_survival_round_enddelay
        && round_handler_GetEndTime() > 0
        && round_handler_GetEndTime() - time > 0) // don't delay past timelimit
    {
        if (round_handler_GetEndDelayTime() == -1)
        {
            round_handler_SetEndDelayTime(min(time + autocvar_g_survival_round_enddelay, round_handler_GetEndTime()));
            return 0;
        }
        else if (round_handler_GetEndDelayTime() >= time)
        {
            return 0;
        }
    }
 
    if(hunter_count > 0) // hunters win
    {
        Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_SURVIVAL_HUNTER_WIN);
        Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_SURVIVAL_HUNTER_WIN);
    }
    else if(survivor_count > 0) // survivors win
    {
        Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_SURVIVAL_SURVIVOR_WIN);
        Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_SURVIVAL_SURVIVOR_WIN);
    }
    else
    {
        Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_ROUND_TIED);
        Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_ROUND_TIED);
    }
 
    Surv_UpdateScores(false);
 
    allowed_to_spawn = false;
    game_stopped = true;
    round_handler_Init(5, autocvar_g_survival_warmup, autocvar_g_survival_round_timelimit);
    survivalStatuses.SendFlags = STATUS_SEND_HUNTERS;
 
    FOREACH_CLIENT(IS_PLAYER(it), {
        nades_RemovePlayer(it);
    });
 
    return 1;
}

References allowed_to_spawn, autocvar_g_survival_round_enddelay, autocvar_g_survival_round_timelimit, autocvar_g_survival_warmup, FOREACH_CLIENT, game_stopped, IS_DEAD, IS_PLAYER, min(), nades_RemovePlayer(), NULL, round_handler_GetEndDelayTime, round_handler_GetEndTime, round_handler_Init(), round_handler_ResetEndDelayTime, round_handler_SetEndDelayTime, Send_Notification(), STATUS_SEND_HUNTERS, SURV_STATUS_HUNTER, SURV_STATUS_PREY, Surv_UpdateScores(), survivalStatuses, and time.

Referenced by surv_Initialize().

surv_Initialize()

void surv_Initialize

(

)

Definition at line 237 of file sv_survival.qc.

{
    GameRules_scoring(0, SFL_SORT_PRIO_PRIMARY, 0, {
        field(SP_SURV_SURVIVALS, "survivals", 0);
        field(SP_SURV_HUNTS, "hunts", SFL_SORT_PRIO_SECONDARY);
    });
 
    allowed_to_spawn = true;
    round_handler_Spawn(Surv_CheckPlayers, Surv_CheckWinner, Surv_RoundStart);
    round_handler_Init(5, autocvar_g_survival_warmup, autocvar_g_survival_round_timelimit);
    EliminatedPlayers_Init(surv_isEliminated);
    SurvivalStatuses_Init();
}

References allowed_to_spawn, autocvar_g_survival_round_timelimit, autocvar_g_survival_warmup, EliminatedPlayers_Init(), GameRules_scoring, round_handler_Init(), round_handler_Spawn(), SFL_SORT_PRIO_PRIMARY, SFL_SORT_PRIO_SECONDARY, Surv_CheckPlayers(), Surv_CheckWinner(), surv_isEliminated(), Surv_RoundStart(), and SurvivalStatuses_Init().

Referenced by REGISTER_MUTATOR().

surv_isEliminated()

bool surv_isEliminated

(

entity

e

)

Definition at line 228 of file sv_survival.qc.

{
    if(INGAME_JOINED(e) && (IS_DEAD(e) || e.frags == FRAGS_PLAYER_OUT_OF_GAME))
        return true;
    if(INGAME_JOINING(e))
        return true;
    return false;
}

References entity(), FRAGS_PLAYER_OUT_OF_GAME, INGAME_JOINED, INGAME_JOINING, and IS_DEAD.

Referenced by surv_Initialize().

surv_LastPlayerForTeam()

entity surv_LastPlayerForTeam

(

entity

this

)

Definition at line 345 of file sv_survival.qc.

{
    entity last_pl = NULL;
    FOREACH_CLIENT(IS_PLAYER(it) && it != this, {
        if (!IS_DEAD(it) && this.survival_status == it.survival_status)
        {
            if (!last_pl)
                last_pl = it;
            else
                return NULL;
        }
    });
    return last_pl;
}

References entity(), FOREACH_CLIENT, IS_DEAD, IS_PLAYER, NULL, and survival_status.

Referenced by surv_LastPlayerForTeam_Notify().

surv_LastPlayerForTeam_Notify()

void surv_LastPlayerForTeam_Notify

(

entity

this

)

Definition at line 360 of file sv_survival.qc.

{
    if (!warmup_stage && round_handler_IsActive() && round_handler_IsRoundStarted())
    {
        entity pl = surv_LastPlayerForTeam(this);
        if (pl)
            Send_Notification(NOTIF_ONE_ONLY, pl, MSG_CENTER, CENTER_ALONE);
    }
}

References entity(), round_handler_IsActive, round_handler_IsRoundStarted, Send_Notification(), surv_LastPlayerForTeam(), and warmup_stage.

Referenced by MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), and MUTATOR_HOOKFUNCTION().

Surv_RoundStart()

void Surv_RoundStart

(

)

Definition at line 160 of file sv_survival.qc.

{
    allowed_to_spawn = boolean(warmup_stage);
    int playercount = 0;
    FOREACH_CLIENT(true,
    {
        if(IS_PLAYER(it) && !IS_DEAD(it))
        {
            ++playercount;
            it.survival_status = SURV_STATUS_PREY;
        }
        else
            it.survival_status = 0; // this is mostly a safety check; if a client manages to somehow maintain a survival status, clear it before the round starts!
        it.survival_validkills = 0;
    });
    int hunter_count = bound(1, ((autocvar_g_survival_hunter_count >= 1) ? autocvar_g_survival_hunter_count : floor(playercount * autocvar_g_survival_hunter_count)), playercount - 1); // 20%, but ensure at least 1 and less than total
    int total_hunters = 0;
    FOREACH_CLIENT_RANDOM(IS_PLAYER(it) && !IS_DEAD(it),
    {
        if(total_hunters >= hunter_count)
            break;
        ++total_hunters;
        it.survival_status = SURV_STATUS_HUNTER;
    });
    survivalStatuses.SendFlags = STATUS_SEND_RESET;
 
    FOREACH_CLIENT(IS_PLAYER(it) && !IS_DEAD(it),
    {
        if(it.survival_status == SURV_STATUS_PREY)
            Send_Notification(NOTIF_ONE_ONLY, it, MSG_CENTER, CENTER_SURVIVAL_SURVIVOR);
        else if(it.survival_status == SURV_STATUS_HUNTER)
            Send_Notification(NOTIF_ONE_ONLY, it, MSG_CENTER, CENTER_SURVIVAL_HUNTER);
    });
}

References allowed_to_spawn, autocvar_g_survival_hunter_count, boolean, bound(), floor(), FOREACH_CLIENT, FOREACH_CLIENT_RANDOM, IS_DEAD, IS_PLAYER, Send_Notification(), STATUS_SEND_RESET, SURV_STATUS_HUNTER, SURV_STATUS_PREY, survivalStatuses, and warmup_stage.

Referenced by surv_Initialize().

Surv_UpdateScores()

void Surv_UpdateScores

(

bool

timed_out

)

Definition at line 54 of file sv_survival.qc.

{
    // give players their hard-earned kills now that the round is over
    FOREACH_CLIENT(true,
    {
        it.totalfrags += it.survival_validkills;
        if(it.survival_validkills)
            GameRules_scoring_add(it, SCORE, it.survival_validkills);
        it.survival_validkills = 0;
        // player survived the round
        if(IS_PLAYER(it) && !IS_DEAD(it))
        {
            if(autocvar_g_survival_reward_survival && timed_out && it.survival_status == SURV_STATUS_PREY)
                GameRules_scoring_add(it, SCORE, 1); // reward survivors who make it to the end of the round time limit
            if(it.survival_status == SURV_STATUS_PREY)
                GameRules_scoring_add(it, SURV_SURVIVALS, 1);
            else if(it.survival_status == SURV_STATUS_HUNTER)
                GameRules_scoring_add(it, SURV_HUNTS, 1);
        }
    });
}

References autocvar_g_survival_reward_survival, FOREACH_CLIENT, GameRules_scoring_add, IS_DEAD, IS_PLAYER, SURV_STATUS_HUNTER, and SURV_STATUS_PREY.

Referenced by Surv_CheckWinner().

SurvivalStatuses_Init()

void SurvivalStatuses_Init

(

)

Definition at line 44 of file sv_survival.qc.

{
    if(survivalStatuses)
    {
        backtrace("Can't spawn survivalStatuses again!");
        return;
    }
    Net_LinkEntity(survivalStatuses = new_pure(survivalStatuses), false, 0, SurvivalStatuses_SendEntity);
}

References backtrace, Net_LinkEntity(), new_pure, survivalStatuses, and SurvivalStatuses_SendEntity().

Referenced by surv_Initialize().

SurvivalStatuses_SendEntity()

bool SurvivalStatuses_SendEntity	(	entity	this,
		entity	dest,
		float	sendflags )

Definition at line 16 of file sv_survival.qc.

{
    // always send hunters their own status and their allies
    if (dest.survival_status == SURV_STATUS_HUNTER)
        sendflags |= STATUS_SEND_HUNTERS;
 
    WriteHeader(MSG_ENTITY, ENT_CLIENT_SURVIVALSTATUSES);
    WriteByte(MSG_ENTITY, sendflags);
    if (sendflags & STATUS_SEND_HUNTERS)
    {
        for (int i = 1; i <= maxclients; i += 8)
        {
            int f = 0;
            entity e = edict_num(i);
 
            for (int b = 0; b < 8; ++b, e = nextent(e))
            {
                bool is_hunter = (INGAME(e) && e.survival_status == SURV_STATUS_HUNTER);
                if (is_hunter)
                    f |= BIT(b);
            }
            WriteByte(MSG_ENTITY, f);
        }
    }
    //print(sprintf("sent flags %f to %s\n", sendflags, dest.netname));
    return true;
}

References BIT, dest, entity(), INGAME, maxclients, MSG_ENTITY, nextent(), STATUS_SEND_HUNTERS, SURV_STATUS_HUNTER, WriteByte(), and WriteHeader.

Referenced by SurvivalStatuses_Init().

Variable Documentation

autocvar_g_survival_hunter_count

float autocvar_g_survival_hunter_count = 0.25

Definition at line 3 of file sv_survival.qc.

Referenced by Surv_RoundStart().

autocvar_g_survival_punish_teamkill

bool autocvar_g_survival_punish_teamkill = true

Definition at line 6 of file sv_survival.qc.

Referenced by MUTATOR_HOOKFUNCTION(), and MUTATOR_HOOKFUNCTION().

autocvar_g_survival_reward_survival

bool autocvar_g_survival_reward_survival = true

Definition at line 7 of file sv_survival.qc.

Referenced by Surv_UpdateScores().

autocvar_g_survival_round_enddelay

float autocvar_g_survival_round_enddelay

Definition at line 8 of file sv_survival.qc.

Referenced by Surv_CheckWinner().

autocvar_g_survival_round_timelimit

float autocvar_g_survival_round_timelimit = 120

Definition at line 4 of file sv_survival.qc.

Referenced by Surv_CheckWinner(), and surv_Initialize().

autocvar_g_survival_warmup

float autocvar_g_survival_warmup = 10

Definition at line 5 of file sv_survival.qc.

Referenced by Surv_CheckWinner(), and surv_Initialize().

survivalStatuses

entity survivalStatuses

Definition at line 10 of file sv_survival.qc.

Referenced by MUTATOR_HOOKFUNCTION(), Surv_CheckWinner(), Surv_RoundStart(), and SurvivalStatuses_Init().