sv_keyhunt.qc File Reference

#include "sv_keyhunt.qh"
#include <common/checkextension.qh>
#include <server/command/vote.qh>
#include <server/gamelog.qh>
#include <server/damage.qh>
#include <server/items/items.qh>
#include <common/mapobjects/triggers.qh>

Include dependency graph for sv_keyhunt.qc:

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

Go to the source code of this file.

Functions
void	havocbot_goalrating_kh (entity this, float ratingscale_team, float ratingscale_dropped, float ratingscale_enemy)
void	havocbot_role_kh_carrier (entity this)
void	havocbot_role_kh_defense (entity this)
void	havocbot_role_kh_freelancer (entity this)
void	havocbot_role_kh_offense (entity this)
	if (!IS_PLAYER(frag_attacker)||!IS_PLAYER(frag_target)) return
	if (frag_attacker.kh_next !=NULL)
void	key_reset (entity this)
vector	kh_AttachedOrigin (entity e)
void	kh_Controller_SetThink (float t, kh_Think_t func)
void	kh_Controller_Think (entity this)
void	kh_EnableTrackingDevice ()
void	kh_finalize ()
void	kh_FinishRound ()
int	kh_GetMissingTeams ()
float	kh_HandleFrags (entity attacker, entity targ, float f)
void	kh_Initialize ()
int	kh_Key_AllOwnedByWhichTeam ()
void	kh_Key_AssignTo (entity key, entity player)
void	kh_Key_Attach (entity key)
void	kh_Key_Collect (entity key, entity player)
void	kh_Key_Damage (entity this, entity inflictor, entity attacker, float damage, int deathtype,.entity weaponentity, vector hitloc, vector force)
void	kh_Key_Detach (entity key)
void	kh_Key_DropAll (entity player, float suicide)
void	kh_Key_DropOne (entity key)
void	kh_Key_Remove (entity key)
void	kh_Key_Spawn (entity initial_owner, float _angle, float i)
void	kh_Key_Think (entity this)
void	kh_Key_Touch (entity this, entity toucher)
bool	kh_Key_waypointsprite_visible_for_player (entity this, entity player, entity view)
bool	kh_KeyCarrier_waypointsprite_visible_for_player (entity this, entity player, entity view)
void	kh_LoserTeam (int loser_team, entity lostkey)
void	kh_ScoreRules (int teams)
void	kh_Scores_Event (entity player, entity key, string what, float frags_player, float frags_owner)
void	kh_StartRound ()
int	kh_Team_ByID (int t)
void	kh_update_state ()
void	kh_WaitForPlayers ()
bool	kh_waypointsprite_visible_for_bot (entity this, entity e)
void	kh_WinnerTeam (int winner_team)
void	nades_GiveBonus (entity player, float score)
	void (entity this) havocbot_role_kh_carrier

Variables
vector	autocvar_g_balance_keyhunt_carrier_damage
vector	autocvar_g_balance_keyhunt_carrier_force
float	autocvar_g_balance_keyhunt_damageforcescale
float	autocvar_g_balance_keyhunt_delay_collect
float	autocvar_g_balance_keyhunt_delay_damage_return
float	autocvar_g_balance_keyhunt_delay_return
float	autocvar_g_balance_keyhunt_delay_round
float	autocvar_g_balance_keyhunt_delay_tracking
float	autocvar_g_balance_keyhunt_dropvelocity
float	autocvar_g_balance_keyhunt_maxdist
vector	autocvar_g_balance_keyhunt_noncarrier_damage
vector	autocvar_g_balance_keyhunt_noncarrier_force
float	autocvar_g_balance_keyhunt_protecttime
float	autocvar_g_balance_keyhunt_return_when_unreachable
int	autocvar_g_balance_keyhunt_score_capture
int	autocvar_g_balance_keyhunt_score_carrierfrag
int	autocvar_g_balance_keyhunt_score_collect
int	autocvar_g_balance_keyhunt_score_destroyed
int	autocvar_g_balance_keyhunt_score_destroyed_ownfactor
int	autocvar_g_balance_keyhunt_score_push
float	autocvar_g_balance_keyhunt_throwvelocity
int	autocvar_g_keyhunt_teams_override
float	float2int_decimal_fld
entity	frag_target = M_ARGV(2, entity)
entity	kh_controller
var kh_Think_t	kh_Controller_Thinkfunc
int	kh_dropperteam
float	kh_droptime
int	kh_interferemsg_team
float	kh_interferemsg_time
const float	KH_KEY_BRIGHTNESS = 2
int	kh_key_carried
int	kh_key_dropped
const vector	KH_KEY_MAX = '25 25 4'
const vector	KH_KEY_MIN = '-25 -25 -46'
const float	KH_KEY_WP_ZSHIFT = 20
const float	KH_KEY_XYDIST = 24
const float	KH_KEY_XYSPEED = 45
const float	KH_KEY_ZSHIFT = 22
entity	kh_next
bool	kh_no_radar_circles
entity	kh_prev
int	kh_previous_owner_playerid
entity	previous_owner
float	siren_time
const int	ST_KH_CAPS = 1

Function Documentation

havocbot_goalrating_kh()

void havocbot_goalrating_kh	(	entity	this,
		float	ratingscale_team,
		float	ratingscale_dropped,
		float	ratingscale_enemy )

Definition at line 1031 of file sv_keyhunt.qc.

{
    for (entity head = kh_worldkeylist; head; head = head.kh_worldkeynext)
    {
        if (head.owner)
        {
            if (head.owner == this || !kh_waypointsprite_visible_for_bot(this, head.owner))
                continue;
            if (SAME_TEAM(head, this))
                navigation_routerating(this, head.owner, ratingscale_team * 10000, 100000);
            else
                navigation_routerating(this, head.owner, ratingscale_enemy * 10000, 100000);
        }
        else
        {
            if (!kh_waypointsprite_visible_for_bot(this, head))
                continue;
            navigation_routerating(this, head, ratingscale_dropped * 10000, 100000);
        }
    }
 
    havocbot_goalrating_items(this, 80000, this.origin, 10000);
}

References entity(), havocbot_goalrating_items(), kh_waypointsprite_visible_for_bot(), kh_worldkeylist, navigation_routerating(), origin, and SAME_TEAM.

Referenced by havocbot_role_kh_carrier(), havocbot_role_kh_defense(), havocbot_role_kh_freelancer(), and havocbot_role_kh_offense().

havocbot_role_kh_carrier()

void havocbot_role_kh_carrier

(

entity

this

)

Definition at line 1055 of file sv_keyhunt.qc.

{
    if(IS_DEAD(this))
        return;
 
    if (!(this.kh_next))
    {
        LOG_TRACE("changing role to freelancer");
        this.havocbot_role = havocbot_role_kh_freelancer;
        this.havocbot_role_timeout = 0;
        return;
    }
 
    if (navigation_goalrating_timeout(this))
    {
        navigation_goalrating_start(this);
 
        if(kh_Key_AllOwnedByWhichTeam() == this.team)
            havocbot_goalrating_kh(this, 10, 0.1, 0.05); // bring home
        else
            havocbot_goalrating_kh(this, 4, 4, 0.5); // play defensively
 
        navigation_goalrating_end(this);
 
        navigation_goalrating_timeout_set(this);
    }
}

References entity(), havocbot_goalrating_kh(), havocbot_role_kh_freelancer(), havocbot_role_timeout, IS_DEAD, kh_Key_AllOwnedByWhichTeam(), kh_next, LOG_TRACE, navigation_goalrating_end(), navigation_goalrating_start(), navigation_goalrating_timeout(), navigation_goalrating_timeout_set(), and team.

Referenced by havocbot_role_kh_defense(), havocbot_role_kh_freelancer(), havocbot_role_kh_offense(), and void().

havocbot_role_kh_defense()

void havocbot_role_kh_defense

(

entity

this

)

Definition at line 1083 of file sv_keyhunt.qc.

{
    if(IS_DEAD(this))
        return;
 
    if (this.kh_next)
    {
        LOG_TRACE("changing role to carrier");
        this.havocbot_role = havocbot_role_kh_carrier;
        this.havocbot_role_timeout = 0;
        return;
    }
 
    if (!this.havocbot_role_timeout)
        this.havocbot_role_timeout = time + random() * 10 + 20;
    if (time > this.havocbot_role_timeout)
    {
        LOG_TRACE("changing role to freelancer");
        this.havocbot_role = havocbot_role_kh_freelancer;
        this.havocbot_role_timeout = 0;
        return;
    }
 
    if (navigation_goalrating_timeout(this))
    {
        float key_owner_team;
        navigation_goalrating_start(this);
 
        key_owner_team = kh_Key_AllOwnedByWhichTeam();
        if(key_owner_team == this.team)
            havocbot_goalrating_kh(this, 10, 0.1, 0.05); // defend key carriers
        else if(key_owner_team == -1)
            havocbot_goalrating_kh(this, 4, 1, 0.05); // play defensively
        else
            havocbot_goalrating_kh(this, 0.1, 0.1, 5); // ATTACK ANYWAY
 
        navigation_goalrating_end(this);
 
        navigation_goalrating_timeout_set(this);
    }
}

References entity(), havocbot_goalrating_kh(), havocbot_role_kh_carrier(), havocbot_role_kh_freelancer(), havocbot_role_timeout, IS_DEAD, kh_Key_AllOwnedByWhichTeam(), kh_next, LOG_TRACE, navigation_goalrating_end(), navigation_goalrating_start(), navigation_goalrating_timeout(), navigation_goalrating_timeout_set(), random(), team, and time.

Referenced by havocbot_role_kh_freelancer(), and void().

havocbot_role_kh_freelancer()

void havocbot_role_kh_freelancer

(

entity

this

)

Definition at line 1168 of file sv_keyhunt.qc.

{
    if(IS_DEAD(this))
        return;
 
    if (this.kh_next)
    {
        LOG_TRACE("changing role to carrier");
        this.havocbot_role = havocbot_role_kh_carrier;
        this.havocbot_role_timeout = 0;
        return;
    }
 
    if (!this.havocbot_role_timeout)
        this.havocbot_role_timeout = time + random() * 10 + 10;
    if (time > this.havocbot_role_timeout)
    {
        if (random() < 0.5)
        {
            LOG_TRACE("changing role to offense");
            this.havocbot_role = havocbot_role_kh_offense;
        }
        else
        {
            LOG_TRACE("changing role to defense");
            this.havocbot_role = havocbot_role_kh_defense;
        }
        this.havocbot_role_timeout = 0;
        return;
    }
 
    if (navigation_goalrating_timeout(this))
    {
        navigation_goalrating_start(this);
 
        int key_owner_team = kh_Key_AllOwnedByWhichTeam();
        if(key_owner_team == this.team)
            havocbot_goalrating_kh(this, 10, 0.1, 0.05); // defend anyway
        else if(key_owner_team == -1)
            havocbot_goalrating_kh(this, 1, 10, 2); // prefer dropped keys
        else
            havocbot_goalrating_kh(this, 0.1, 0.1, 5); // ATTACK ANYWAY
 
        navigation_goalrating_end(this);
 
        navigation_goalrating_timeout_set(this);
    }
}

References entity(), havocbot_goalrating_kh(), havocbot_role_kh_carrier(), havocbot_role_kh_defense(), havocbot_role_kh_offense(), havocbot_role_timeout, IS_DEAD, kh_Key_AllOwnedByWhichTeam(), kh_next, LOG_TRACE, navigation_goalrating_end(), navigation_goalrating_start(), navigation_goalrating_timeout(), navigation_goalrating_timeout_set(), random(), team, and time.

Referenced by havocbot_role_kh_carrier(), havocbot_role_kh_defense(), havocbot_role_kh_offense(), and void().

havocbot_role_kh_offense()

void havocbot_role_kh_offense

(

entity

this

)

Definition at line 1125 of file sv_keyhunt.qc.

{
    if(IS_DEAD(this))
        return;
 
    if (this.kh_next)
    {
        LOG_TRACE("changing role to carrier");
        this.havocbot_role = havocbot_role_kh_carrier;
        this.havocbot_role_timeout = 0;
        return;
    }
 
    if (!this.havocbot_role_timeout)
        this.havocbot_role_timeout = time + random() * 10 + 20;
    if (time > this.havocbot_role_timeout)
    {
        LOG_TRACE("changing role to freelancer");
        this.havocbot_role = havocbot_role_kh_freelancer;
        this.havocbot_role_timeout = 0;
        return;
    }
 
    if (navigation_goalrating_timeout(this))
    {
        float key_owner_team;
 
        navigation_goalrating_start(this);
 
        key_owner_team = kh_Key_AllOwnedByWhichTeam();
        if(key_owner_team == this.team)
            havocbot_goalrating_kh(this, 10, 0.1, 0.05); // defend anyway
        else if(key_owner_team == -1)
            havocbot_goalrating_kh(this, 0.1, 1, 2); // play offensively
        else
            havocbot_goalrating_kh(this, 0.1, 0.1, 5); // ATTACK! EMERGENCY!
 
        navigation_goalrating_end(this);
 
        navigation_goalrating_timeout_set(this);
    }
}

References entity(), havocbot_goalrating_kh(), havocbot_role_kh_carrier(), havocbot_role_kh_freelancer(), havocbot_role_timeout, IS_DEAD, kh_Key_AllOwnedByWhichTeam(), kh_next, LOG_TRACE, navigation_goalrating_end(), navigation_goalrating_start(), navigation_goalrating_timeout(), navigation_goalrating_timeout_set(), random(), team, and time.

Referenced by havocbot_role_kh_freelancer(), and void().

if() [1/2]

if

(

!

IS_PLAYERfrag_attacker)||!IS_PLAYER(frag_target

)

References frag_target.

if() [2/2]

if

(

frag_attacker.kh_next !

= NULL

)

Definition at line 1229 of file sv_keyhunt.qc.

    {
        if (frag_target == frag_attacker) // damage done to themselves
        {
            M_ARGV(4, float) *= autocvar_g_balance_keyhunt_carrier_damage.x;
            M_ARGV(6, vector) *= autocvar_g_balance_keyhunt_carrier_force.x;
        }
        else if (frag_target.kh_next != NULL) // damage done to other key carriers
        {
            M_ARGV(4, float) *= autocvar_g_balance_keyhunt_carrier_damage.y;
            M_ARGV(6, vector) *= autocvar_g_balance_keyhunt_carrier_force.y;
        }
        else // damage done to noncarriers
        {
            M_ARGV(4, float) *= autocvar_g_balance_keyhunt_carrier_damage.z;
            M_ARGV(6, vector) *= autocvar_g_balance_keyhunt_carrier_force.z;
        }
    }

References autocvar_g_balance_keyhunt_carrier_damage, autocvar_g_balance_keyhunt_carrier_force, frag_target, M_ARGV, NULL, and vector.

key_reset()

void key_reset

(

entity

this

)

Definition at line 725 of file sv_keyhunt.qc.

{
    kh_Key_AssignTo(this, NULL);
    kh_Key_Remove(this);
}

References entity(), kh_Key_AssignTo(), kh_Key_Remove(), and NULL.

Referenced by kh_Key_Spawn().

kh_AttachedOrigin()

vector kh_AttachedOrigin

(

entity

e

)

Definition at line 213 of file sv_keyhunt.qc.

{
    if(e.tag_entity)
    {
        makevectors(e.tag_entity.angles);
        return e.tag_entity.origin + e.origin.x * v_forward - e.origin.y * v_right + e.origin.z * v_up;
    }
    else
        return e.origin;
}

References entity(), makevectors, v_forward, v_right, v_up, and vector.

Referenced by kh_WinnerTeam().

kh_Controller_SetThink()

void kh_Controller_SetThink	(	float	t,
		kh_Think_t	func )

Definition at line 154 of file sv_keyhunt.qc.

{
    kh_Controller_Thinkfunc = func;
    kh_controller.cnt = ceil(t);
    if(t == 0)
        kh_controller.nextthink = time; // force
}

References ceil(), kh_controller, kh_Controller_Thinkfunc, and time.

Referenced by kh_FinishRound(), kh_Initialize(), kh_StartRound(), and kh_WaitForPlayers().

kh_Controller_Think()

void kh_Controller_Think

(

entity

this

)

Definition at line 162 of file sv_keyhunt.qc.

{
    if(game_stopped)
        return;
    if(this.cnt > 0)
    {
        if(getthink(this) != kh_WaitForPlayers)
            --this.cnt;
    }
    else if(this.cnt == 0)
    {
        --this.cnt;
        kh_Controller_Thinkfunc();
    }
    this.nextthink = time + 1;
}

References cnt, entity(), game_stopped, getthink, kh_Controller_Thinkfunc, kh_WaitForPlayers(), nextthink, and time.

Referenced by kh_Initialize().

kh_EnableTrackingDevice()

void kh_EnableTrackingDevice

(

)

Definition at line 899 of file sv_keyhunt.qc.

{
    Kill_Notification(NOTIF_ALL, NULL, MSG_CENTER, CPID_KEYHUNT);
    Kill_Notification(NOTIF_ALL, NULL, MSG_CENTER, CPID_KEYHUNT_OTHER);
 
    kh_tracking_enabled = true;
}

References kh_tracking_enabled, Kill_Notification(), and NULL.

Referenced by kh_StartRound().

kh_finalize()

void kh_finalize

(

)

Definition at line 1003 of file sv_keyhunt.qc.

{
    // to be called before intermission
    kh_FinishRound();
    delete(kh_controller);
    kh_controller = NULL;
}

References kh_controller, kh_FinishRound(), and NULL.

kh_FinishRound()

void kh_FinishRound

(

)

Definition at line 505 of file sv_keyhunt.qc.

{
    // prepare next round
    kh_interferemsg_time = 0;
    entity key;
 
    kh_no_radar_circles = true;
    FOR_EACH_KH_KEY(key)
        kh_Key_Remove(key);
    kh_no_radar_circles = false;
 
    Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_KEYHUNT_ROUNDSTART, autocvar_g_balance_keyhunt_delay_round);
    kh_Controller_SetThink(autocvar_g_balance_keyhunt_delay_round, kh_StartRound);
}

References autocvar_g_balance_keyhunt_delay_round, entity(), FOR_EACH_KH_KEY, kh_Controller_SetThink(), kh_interferemsg_time, kh_Key_Remove(), kh_no_radar_circles, kh_StartRound(), NULL, and Send_Notification().

Referenced by kh_finalize(), kh_LoserTeam(), and kh_WinnerTeam().

kh_GetMissingTeams()

int kh_GetMissingTeams

(

)

Definition at line 856 of file sv_keyhunt.qc.

{
    int missing_teams = 0;
    for(int i = 0; i < AVAILABLE_TEAMS; ++i)
    {
        int teem = kh_Team_ByID(i);
        int players = 0;
        FOREACH_CLIENT(IS_PLAYER(it), {
            if(!IS_DEAD(it) && !PHYS_INPUT_BUTTON_CHAT(it) && it.team == teem)
                ++players;
        });
        if (!players)
            missing_teams |= BIT(i);
    }
    return missing_teams;
}

References AVAILABLE_TEAMS, BIT, FOREACH_CLIENT, IS_DEAD, IS_PLAYER, kh_Team_ByID(), PHYS_INPUT_BUTTON_CHAT, and players.

Referenced by kh_StartRound(), and kh_WaitForPlayers().

kh_HandleFrags()

float kh_HandleFrags	(	entity	attacker,
		entity	targ,
		float	f )

Definition at line 948 of file sv_keyhunt.qc.

{
    if(attacker == targ)
        return f;
 
    if(targ.kh_next)
    {
        if(attacker.team == targ.team)
        {
            int nk = 0;
            for(entity k = targ.kh_next; k != NULL; k = k.kh_next)
                ++nk;
            kh_Scores_Event(attacker, targ.kh_next, "carrierfrag", -nk * autocvar_g_balance_keyhunt_score_collect, 0);
        }
        else
        {
            kh_Scores_Event(attacker, targ.kh_next, "carrierfrag", autocvar_g_balance_keyhunt_score_carrierfrag-1, 0);
            GameRules_scoring_add(attacker, KH_KCKILLS, 1);
            // the frag gets added later
        }
    }
 
    return f;
}

References autocvar_g_balance_keyhunt_score_carrierfrag, autocvar_g_balance_keyhunt_score_collect, entity(), GameRules_scoring_add, kh_Scores_Event(), and NULL.

kh_Initialize()

void kh_Initialize

(

)

Definition at line 973 of file sv_keyhunt.qc.

{
    // setup variables
    int kh_teams = autocvar_g_keyhunt_teams_override;
    if(kh_teams < 2)
        kh_teams = cvar("g_keyhunt_teams"); // read the cvar directly as it gets written earlier in the same frame
    kh_teams = BITS(bound(2, kh_teams, 4));
 
    // use a temp entity to avoid linking kh_controller to the world with setmodel
    entity tmp_ent = spawn();
    setmodel(tmp_ent, MDL_KH_KEY);
    kh_key_dropped = tmp_ent.modelindex;
 
#ifdef KH_PLAYER_USE_CARRIEDMODEL
    setmodel(tmp_ent, MDL_KH_KEY_CARRIED);
    kh_key_carried = tmp_ent.modelindex;
#else
    kh_key_carried = kh_key_dropped;
#endif
 
    delete(tmp_ent);
 
    // make a KH entity for controlling the game
    kh_controller = new_pure(kh_controller);
    setthink(kh_controller, kh_Controller_Think);
    kh_Controller_SetThink(0, kh_WaitForPlayers);
 
    kh_ScoreRules(kh_teams);
}

References autocvar_g_keyhunt_teams_override, BITS, bound(), cvar(), entity(), kh_controller, kh_Controller_SetThink(), kh_Controller_Think(), kh_key_carried, kh_key_dropped, kh_ScoreRules(), kh_WaitForPlayers(), new_pure, setmodel, setthink, and spawn.

Referenced by REGISTER_MUTATOR().

kh_Key_AllOwnedByWhichTeam()

int kh_Key_AllOwnedByWhichTeam

(

)

Definition at line 785 of file sv_keyhunt.qc.

{
    entity key;
    int teem = -1;
    int keys = AVAILABLE_TEAMS;
    FOR_EACH_KH_KEY(key)
    {
        if(!key.owner)
            return -1;
        if(teem == -1)
            teem = key.team;
        else if(teem != key.team)
            return -1;
        --keys;
    }
    if(keys != 0)
        return -1;
    return teem;
}

References AVAILABLE_TEAMS, entity(), and FOR_EACH_KH_KEY.

Referenced by havocbot_role_kh_carrier(), havocbot_role_kh_defense(), havocbot_role_kh_freelancer(), havocbot_role_kh_offense(), kh_Key_AssignTo(), and kh_Key_Think().

kh_Key_AssignTo()

void kh_Key_AssignTo	(	entity	key,
		entity	player )

Definition at line 313 of file sv_keyhunt.qc.

{
    if(key.owner == player)
        return;
 
    int ownerteam0 = kh_Key_AllOwnedByWhichTeam();
 
    if(key.owner)
    {
        kh_Key_Detach(key);
 
        // remove from linked list
        if(key.kh_next)
            key.kh_next.kh_prev = key.kh_prev;
        key.kh_prev.kh_next = key.kh_next;
        key.kh_next = NULL;
        key.kh_prev = NULL;
 
        if(key.owner.kh_next == NULL)
        {
            // No longer a key carrier
            if(!kh_no_radar_circles)
                WaypointSprite_Ping(key.owner.waypointsprite_attachedforcarrier);
            WaypointSprite_DetachCarrier(key.owner);
        }
    }
 
    key.owner = player;
 
    if(player)
    {
        // insert into linked list
        key.kh_next = player.kh_next;
        key.kh_prev = player;
        player.kh_next = key;
        if(key.kh_next)
            key.kh_next.kh_prev = key;
 
        kh_Key_Attach(key);
 
        if(key.kh_next == NULL)
        {
            // player is now a key carrier
            entity wp = WaypointSprite_AttachCarrier(WP_Null, player, RADARICON_FLAGCARRIER);
            wp.colormod = colormapPaletteColor(player.team - 1, 0);
            player.waypointsprite_attachedforcarrier.waypointsprite_visible_for_player = kh_KeyCarrier_waypointsprite_visible_for_player;
            WaypointSprite_UpdateRule(player.waypointsprite_attachedforcarrier, player.team, SPRITERULE_TEAMPLAY);
            if(player.team == NUM_TEAM_1)
                WaypointSprite_UpdateSprites(player.waypointsprite_attachedforcarrier, WP_KeyCarrierRed, WP_KeyCarrierFriend, WP_KeyCarrierRed);
            else if(player.team == NUM_TEAM_2)
                WaypointSprite_UpdateSprites(player.waypointsprite_attachedforcarrier, WP_KeyCarrierBlue, WP_KeyCarrierFriend, WP_KeyCarrierBlue);
            else if(player.team == NUM_TEAM_3)
                WaypointSprite_UpdateSprites(player.waypointsprite_attachedforcarrier, WP_KeyCarrierYellow, WP_KeyCarrierFriend, WP_KeyCarrierYellow);
            else if(player.team == NUM_TEAM_4)
                WaypointSprite_UpdateSprites(player.waypointsprite_attachedforcarrier, WP_KeyCarrierPink, WP_KeyCarrierFriend, WP_KeyCarrierPink);
            if(!kh_no_radar_circles)
                WaypointSprite_Ping(player.waypointsprite_attachedforcarrier);
        }
    }
 
    // moved that here, also update if there's no player
    kh_update_state();
 
    key.pusher = NULL;
 
    int ownerteam = kh_Key_AllOwnedByWhichTeam();
    if(ownerteam != ownerteam0)
    {
        entity k;
        if(ownerteam != -1)
        {
            kh_interferemsg_time = time + 0.2;
            kh_interferemsg_team = player.team;
 
            // audit all key carrier sprites, update them to "Run here"
            FOR_EACH_KH_KEY(k)
            {
                if (!k.owner) continue;
                entity first = WP_Null;
                FOREACH(Waypoints, it.netname == k.owner.waypointsprite_attachedforcarrier.model1, { first = it; break; });
                entity third = WP_Null;
                FOREACH(Waypoints, it.netname == k.owner.waypointsprite_attachedforcarrier.model3, { third = it; break; });
                WaypointSprite_UpdateSprites(k.owner.waypointsprite_attachedforcarrier, first, WP_KeyCarrierFinish, third);
            }
        }
        else
        {
            kh_interferemsg_time = 0;
 
            // audit all key carrier sprites, update them to "Key Carrier"
            FOR_EACH_KH_KEY(k)
            {
                if (!k.owner) continue;
                entity first = WP_Null;
                FOREACH(Waypoints, it.netname == k.owner.waypointsprite_attachedforcarrier.model1, { first = it; break; });
                entity third = WP_Null;
                FOREACH(Waypoints, it.netname == k.owner.waypointsprite_attachedforcarrier.model3, { third = it; break; });
                WaypointSprite_UpdateSprites(k.owner.waypointsprite_attachedforcarrier, first, WP_KeyCarrierFriend, third);
            }
        }
    }
}

References colormapPaletteColor, entity(), FOR_EACH_KH_KEY, FOREACH, kh_interferemsg_team, kh_interferemsg_time, kh_Key_AllOwnedByWhichTeam(), kh_Key_Attach(), kh_Key_Detach(), kh_KeyCarrier_waypointsprite_visible_for_player(), kh_no_radar_circles, kh_update_state(), NULL, NUM_TEAM_1, NUM_TEAM_2, NUM_TEAM_3, NUM_TEAM_4, SPRITERULE_TEAMPLAY, time, WaypointSprite_AttachCarrier(), WaypointSprite_DetachCarrier(), WaypointSprite_Ping(), WaypointSprite_UpdateRule(), and WaypointSprite_UpdateSprites().

Referenced by key_reset(), kh_Key_Collect(), kh_Key_DropAll(), kh_Key_DropOne(), kh_Key_Remove(), and kh_Key_Spawn().

kh_Key_Attach()

void kh_Key_Attach

(

entity

key

)

Definition at line 224 of file sv_keyhunt.qc.

{
    key.solid = SOLID_NOT; // before setorigin to prevent area grid linking
#ifdef KH_PLAYER_USE_ATTACHMENT
    entity first = key.owner.kh_next;
    if(key == first)
    {
        setattachment(key, key.owner, KH_PLAYER_ATTACHMENT_BONE);
        if(key.kh_next)
        {
            setattachment(key.kh_next, key, "");
            setorigin(key, key.kh_next.origin - 0.5 * KH_PLAYER_ATTACHMENT_DIST);
            setorigin(key.kh_next, KH_PLAYER_ATTACHMENT_DIST_ROTATED);
            key.kh_next.angles = '0 0 0';
        }
        else
            setorigin(key, KH_PLAYER_ATTACHMENT);
        key.angles = KH_PLAYER_ATTACHMENT_ANGLES;
    }
    else
    {
        setattachment(key, key.kh_prev, "");
        if(key.kh_next)
            setattachment(key.kh_next, key, "");
        setorigin(key, KH_PLAYER_ATTACHMENT_DIST_ROTATED);
        setorigin(first, first.origin - 0.5 * KH_PLAYER_ATTACHMENT_DIST);
        key.angles = '0 0 0';
    }
#else
    setattachment(key, key.owner, "");
    setorigin(key, '0 0 1' * KH_KEY_ZSHIFT);  // fixing x, y in think
    key.angles_y -= key.owner.angles.y;
#endif
    key.flags = 0;
    if(IL_CONTAINS(g_items, key))
        IL_REMOVE(g_items, key);
    set_movetype(key, MOVETYPE_NONE);
    key.team = key.owner.team;
    key.nextthink = time;
    key.damageforcescale = 0;
    key.takedamage = DAMAGE_NO;
    key.modelindex = kh_key_carried;
    navigation_dynamicgoal_unset(key);
}

References DAMAGE_NO, entity(), g_items, IL_CONTAINS(), IL_REMOVE(), kh_key_carried, KH_KEY_ZSHIFT, MOVETYPE_NONE, navigation_dynamicgoal_unset(), set_movetype(), SOLID_NOT, and time.

Referenced by kh_Key_AssignTo().

kh_Key_Collect()

void kh_Key_Collect	(	entity	key,
		entity	player )

Definition at line 432 of file sv_keyhunt.qc.

{
    sound(player, CH_TRIGGER, SND_KH_COLLECT, VOL_BASE, ATTEN_NORM);
 
    if(key.kh_dropperteam != player.team)
    {
        kh_Scores_Event(player, key, "collect", autocvar_g_balance_keyhunt_score_collect, 0);
        GameRules_scoring_add(player, KH_PICKUPS, 1);
    }
    key.kh_dropperteam = 0;
    int realteam = kh_Team_ByID(key.count);
    Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_TEAM_NUM(realteam, INFO_KEYHUNT_PICKUP), player.netname);
 
    kh_Key_AssignTo(key, player); // this also updates .kh_state
}

References APP_TEAM_NUM, ATTEN_NORM, autocvar_g_balance_keyhunt_score_collect, CH_TRIGGER, entity(), GameRules_scoring_add, kh_Key_AssignTo(), kh_Scores_Event(), kh_Team_ByID(), NULL, Send_Notification(), sound, and VOL_BASE.

Referenced by kh_Key_Touch().

kh_Key_Damage()

void kh_Key_Damage	(	entity	this,
		entity	inflictor,
		entity	attacker,
		float	damage,
		int	deathtype,
		.entity	weaponentity,
		vector	hitloc,
		vector	force )

Definition at line 416 of file sv_keyhunt.qc.

{
    if(this.owner)
        return;
    if(ITEM_DAMAGE_NEEDKILL(deathtype))
    {
        this.pain_finished = bound(time, time + autocvar_g_balance_keyhunt_delay_damage_return, this.pain_finished);
        return;
    }
    if(force == '0 0 0')
        return;
    if(time > this.pushltime)
        if(IS_PLAYER(attacker))
            this.team = attacker.team;
}

References autocvar_g_balance_keyhunt_delay_damage_return, bound(), entity(), IS_PLAYER, ITEM_DAMAGE_NEEDKILL, owner, pain_finished, pushltime, team, time, and vector.

Referenced by kh_Key_Spawn().

kh_Key_Detach()

void kh_Key_Detach

(

entity

key

)

Definition at line 269 of file sv_keyhunt.qc.

{
    key.solid = SOLID_TRIGGER; // before setorigin to ensure area grid linking
#ifdef KH_PLAYER_USE_ATTACHMENT
    entity first = key.owner.kh_next;
    if(key == first)
    {
        if(key.kh_next)
        {
            setattachment(key.kh_next, key.owner, KH_PLAYER_ATTACHMENT_BONE);
            setorigin(key.kh_next, key.origin + 0.5 * KH_PLAYER_ATTACHMENT_DIST);
            key.kh_next.angles = KH_PLAYER_ATTACHMENT_ANGLES;
        }
    }
    else
    {
        if(key.kh_next)
            setattachment(key.kh_next, key.kh_prev, "");
        setorigin(first, first.origin + 0.5 * KH_PLAYER_ATTACHMENT_DIST);
    }
    // in any case:
    setattachment(key, NULL, "");
    setorigin(key, key.owner.origin + '0 0 1' * (STAT(PL_MIN, key.owner).z - KH_KEY_MIN_z));
    key.angles = key.owner.angles;
#else
    setorigin(key, key.owner.origin + key.origin.z * '0 0 1');
    setattachment(key, NULL, "");
    key.angles_y += key.owner.angles.y;
#endif
    key.flags = FL_ITEM;
    if(!IL_CONTAINS(g_items, key))
        IL_PUSH(g_items, key);
    set_movetype(key, MOVETYPE_TOSS);
    nudgeoutofsolid_OrFallback(key); // a key has a bigger bbox than a player
    key.pain_finished = time + autocvar_g_balance_keyhunt_delay_return;
    key.damageforcescale = autocvar_g_balance_keyhunt_damageforcescale;
    key.takedamage = DAMAGE_YES;
    // let key.team stay
    key.modelindex = kh_key_dropped;
    navigation_dynamicgoal_set(key, key.owner);
    key.previous_owner = key.owner;
    key.kh_previous_owner_playerid = key.owner.playerid;
}

References autocvar_g_balance_keyhunt_damageforcescale, autocvar_g_balance_keyhunt_delay_return, DAMAGE_YES, entity(), FL_ITEM, g_items, IL_CONTAINS(), IL_PUSH(), kh_key_dropped, MOVETYPE_TOSS, navigation_dynamicgoal_set(), NULL, set_movetype(), SOLID_TRIGGER, STAT, and time.

Referenced by kh_Key_AssignTo().

kh_Key_DropAll()

void kh_Key_DropAll	(	entity	player,
		float	suicide )

Definition at line 828 of file sv_keyhunt.qc.

{
    if(player.kh_next)
    {
        entity mypusher = NULL;
        if(player.pusher)
            if(time < player.pushltime)
                mypusher = player.pusher;
 
        entity key;
        while((key = player.kh_next))
        {
            kh_Scores_Event(player, key, "losekey", 0, 0);
            GameRules_scoring_add(player, KH_LOSSES, 1);
            int realteam = kh_Team_ByID(key.count);
            Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_TEAM_NUM(realteam, INFO_KEYHUNT_LOST), player.netname);
            kh_Key_AssignTo(key, NULL);
            makevectors('-1 0 0' * (45 + 45 * random()) + '0 360 0' * random());
            key.velocity = W_CalculateProjectileVelocity(player, player.velocity, autocvar_g_balance_keyhunt_dropvelocity * v_forward, false);
            key.pusher = mypusher;
            key.pushltime = time + autocvar_g_balance_keyhunt_protecttime;
            if(suicide)
                key.kh_dropperteam = player.team;
        }
        sound(player, CH_TRIGGER, SND_KH_DROP, VOL_BASE, ATTEN_NORM);
    }
}

References APP_TEAM_NUM, ATTEN_NORM, autocvar_g_balance_keyhunt_dropvelocity, autocvar_g_balance_keyhunt_protecttime, CH_TRIGGER, entity(), GameRules_scoring_add, kh_Key_AssignTo(), kh_Scores_Event(), kh_Team_ByID(), makevectors, NULL, random(), Send_Notification(), sound, time, v_forward, VOL_BASE, and W_CalculateProjectileVelocity().

kh_Key_DropOne()

void kh_Key_DropOne

(

entity

key

)

Definition at line 805 of file sv_keyhunt.qc.

{
    // prevent collecting this one for some time
    entity player = key.owner;
 
    key.kh_droptime = time;
    key.enemy = player;
 
    kh_Scores_Event(player, key, "dropkey", 0, 0);
    GameRules_scoring_add(player, KH_LOSSES, 1);
    int realteam = kh_Team_ByID(key.count);
    Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_TEAM_NUM(realteam, INFO_KEYHUNT_DROP), player.netname);
 
    kh_Key_AssignTo(key, NULL);
    makevectors(player.v_angle);
    key.velocity = W_CalculateProjectileVelocity(player, player.velocity, autocvar_g_balance_keyhunt_throwvelocity * v_forward, false);
    key.pusher = NULL;
    key.pushltime = time + autocvar_g_balance_keyhunt_protecttime;
    key.kh_dropperteam = key.team;
 
    sound(player, CH_TRIGGER, SND_KH_DROP, VOL_BASE, ATTEN_NORM);
}

References APP_TEAM_NUM, ATTEN_NORM, autocvar_g_balance_keyhunt_protecttime, autocvar_g_balance_keyhunt_throwvelocity, CH_TRIGGER, entity(), GameRules_scoring_add, kh_Key_AssignTo(), kh_Scores_Event(), kh_Team_ByID(), makevectors, NULL, Send_Notification(), sound, time, v_forward, VOL_BASE, and W_CalculateProjectileVelocity().

kh_Key_Remove()

void kh_Key_Remove

(

entity

key

)

Definition at line 474 of file sv_keyhunt.qc.

{
    entity o = key.owner;
    kh_Key_AssignTo(key, NULL);
    if(o) // it was attached
        WaypointSprite_Kill(key.waypointsprite_attachedforcarrier);
    else // it was dropped
        WaypointSprite_DetachCarrier(key);
 
    // remove key from key list
    if (kh_worldkeylist == key)
        kh_worldkeylist = kh_worldkeylist.kh_worldkeynext;
    else
    {
        o = kh_worldkeylist;
        while (o)
        {
            if (o.kh_worldkeynext == key)
            {
                o.kh_worldkeynext = o.kh_worldkeynext.kh_worldkeynext;
                break;
            }
            o = o.kh_worldkeynext;
        }
    }
 
    delete(key);
 
    kh_update_state();
}

References entity(), kh_Key_AssignTo(), kh_update_state(), kh_worldkeylist, NULL, WaypointSprite_DetachCarrier(), and WaypointSprite_Kill().

Referenced by key_reset(), and kh_FinishRound().

kh_Key_Spawn()

void kh_Key_Spawn	(	entity	initial_owner,
		float	_angle,
		float	i )

Definition at line 731 of file sv_keyhunt.qc.

{
    entity key = new(item_kh_key);
    key.count = i;
    settouch(key, kh_Key_Touch);
    setthink(key, kh_Key_Think);
    key.nextthink = time;
    key.cnt = _angle;
    key.angles = '0 360 0' * random();
    key.event_damage = kh_Key_Damage;
    key.takedamage = DAMAGE_YES;
    key.damagedbytriggers = autocvar_g_balance_keyhunt_return_when_unreachable;
    key.damagedbycontents = autocvar_g_balance_keyhunt_return_when_unreachable;
    key.modelindex = kh_key_dropped;
    key.model = "key";
    key.kh_dropperteam = 0;
    key.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_PLAYERCLIP | DPCONTENTS_BOTCLIP;
    setsize(key, KH_KEY_MIN, KH_KEY_MAX);
    key.colormod = Team_ColorRGB(initial_owner.team) * KH_KEY_BRIGHTNESS;
    key.reset = key_reset;
    navigation_dynamicgoal_init(key, false);
 
    switch(initial_owner.team)
    {
        case NUM_TEAM_1:
            key.netname = "^1red key";
            break;
        case NUM_TEAM_2:
            key.netname = "^4blue key";
            break;
        case NUM_TEAM_3:
            key.netname = "^3yellow key";
            break;
        case NUM_TEAM_4:
            key.netname = "^6pink key";
            break;
        default:
            key.netname = "NETGIER key";
            break;
    }
 
    // link into key list
    key.kh_worldkeynext = kh_worldkeylist;
    kh_worldkeylist = key;
 
    Send_Notification(NOTIF_ONE, initial_owner, MSG_CENTER, APP_TEAM_NUM(initial_owner.team, CENTER_KEYHUNT_START));
 
    WaypointSprite_Spawn(WP_KeyDropped, 0, 0, key, '0 0 1' * KH_KEY_WP_ZSHIFT, NULL, key.team, key, waypointsprite_attachedforcarrier, false, RADARICON_FLAG);
    key.waypointsprite_attachedforcarrier.waypointsprite_visible_for_player = kh_Key_waypointsprite_visible_for_player;
 
    kh_Key_AssignTo(key, initial_owner);
}

References APP_TEAM_NUM, autocvar_g_balance_keyhunt_return_when_unreachable, DAMAGE_YES, DPCONTENTS_BODY, DPCONTENTS_BOTCLIP, DPCONTENTS_PLAYERCLIP, DPCONTENTS_SOLID, entity(), key_reset(), kh_Key_AssignTo(), KH_KEY_BRIGHTNESS, kh_Key_Damage(), kh_key_dropped, KH_KEY_MAX, KH_KEY_MIN, kh_Key_Think(), kh_Key_Touch(), kh_Key_waypointsprite_visible_for_player(), KH_KEY_WP_ZSHIFT, kh_worldkeylist, navigation_dynamicgoal_init(), NULL, NUM_TEAM_1, NUM_TEAM_2, NUM_TEAM_3, NUM_TEAM_4, random(), Send_Notification(), setthink, settouch, Team_ColorRGB(), time, waypointsprite_attachedforcarrier, and WaypointSprite_Spawn().

Referenced by kh_StartRound().

kh_Key_Think()

void kh_Key_Think

(

entity

this

)

Definition at line 670 of file sv_keyhunt.qc.

{
    if(game_stopped)
        return;
 
    if(this.owner)
    {
#ifndef KH_PLAYER_USE_ATTACHMENT
        makevectors('0 1 0' * (this.cnt + (time % 360) * KH_KEY_XYSPEED));
        setorigin(this, v_forward * KH_KEY_XYDIST + '0 0 1' * this.origin.z);
#endif
    }
 
    // if in nodrop or time over, end the round
    if(!this.owner)
        if(time > this.pain_finished)
            kh_LoserTeam(this.team, this);
 
    if(this.owner)
    if(kh_Key_AllOwnedByWhichTeam() != -1)
    {
        if(this.siren_time < time)
        {
            sound(this.owner, CH_TRIGGER, SND_KH_ALARM, VOL_BASE, ATTEN_NORM);  // play a simple alarm
            this.siren_time = time + 2.5;  // repeat every 2.5 seconds
        }
 
        entity key;
        vector p = this.owner.origin;
        FOR_EACH_KH_KEY(key)
            if(vdist(key.owner.origin - p, >, autocvar_g_balance_keyhunt_maxdist))
                goto not_winning;
        kh_WinnerTeam(this.team);
LABEL(not_winning)
    }
 
    if(kh_interferemsg_time && time > kh_interferemsg_time)
    {
        kh_interferemsg_time = 0;
        FOREACH_CLIENT(IS_PLAYER(it), {
            if(it.team == kh_interferemsg_team)
            {
                if(it.kh_next)
                    Send_Notification(NOTIF_ONE, it, MSG_CENTER, CENTER_KEYHUNT_MEET);
                else
                    Send_Notification(NOTIF_ONE, it, MSG_CENTER, CENTER_KEYHUNT_HELP);
            }
            else
                Send_Notification(NOTIF_ONE, it, MSG_CENTER, APP_TEAM_NUM(kh_interferemsg_team, CENTER_KEYHUNT_INTERFERE));
        });
    }
 
    this.nextthink = time + 0.05;
}

References APP_TEAM_NUM, ATTEN_NORM, autocvar_g_balance_keyhunt_maxdist, CH_TRIGGER, cnt, entity(), FOR_EACH_KH_KEY, FOREACH_CLIENT, game_stopped, IS_PLAYER, kh_interferemsg_team, kh_interferemsg_time, kh_Key_AllOwnedByWhichTeam(), KH_KEY_XYDIST, KH_KEY_XYSPEED, kh_LoserTeam(), kh_WinnerTeam(), LABEL, makevectors, nextthink, origin, owner, pain_finished, Send_Notification(), siren_time, sound, team, time, v_forward, vdist, vector, and VOL_BASE.

Referenced by kh_Key_Spawn().

kh_Key_Touch()

void kh_Key_Touch	(	entity	this,
		entity	toucher )

Definition at line 448 of file sv_keyhunt.qc.

{
    if(game_stopped)
        return;
 
    if(this.owner) // already carried
        return;
 
    if(ITEM_TOUCH_NEEDKILL())
    {
        this.pain_finished = bound(time, time + autocvar_g_balance_keyhunt_delay_damage_return, this.pain_finished);
        return;
    }
 
    if (!IS_PLAYER(toucher))
        return;
    if(IS_DEAD(toucher))
        return;
    if(IS_INDEPENDENT_PLAYER(toucher))
        return;
    if(toucher == this.enemy)
        if(time < this.kh_droptime + autocvar_g_balance_keyhunt_delay_collect)
            return;  // you just dropped it!
    kh_Key_Collect(this, toucher);
}

References autocvar_g_balance_keyhunt_delay_collect, autocvar_g_balance_keyhunt_delay_damage_return, bound(), enemy, entity(), game_stopped, IS_DEAD, IS_INDEPENDENT_PLAYER, IS_PLAYER, ITEM_TOUCH_NEEDKILL, kh_droptime, kh_Key_Collect(), owner, pain_finished, time, and toucher.

Referenced by kh_Key_Spawn().

kh_Key_waypointsprite_visible_for_player()

bool kh_Key_waypointsprite_visible_for_player	(	entity	this,
		entity	player,
		entity	view )

Definition at line 115 of file sv_keyhunt.qc.

{
    // always show the dropped key waypoint while in warmup or spectating
    if(this.owner && !this.owner.owner && (IS_SPEC(player) || warmup_stage))
        return true;
    if(!kh_tracking_enabled)
        return false;
 
    return !this.owner || !this.owner.owner; // draw only when key is not owned
}

References entity(), IS_SPEC, kh_tracking_enabled, owner, and warmup_stage.

Referenced by kh_Key_Spawn().

kh_KeyCarrier_waypointsprite_visible_for_player()

bool kh_KeyCarrier_waypointsprite_visible_for_player	(	entity	this,
		entity	player,
		entity	view )

Definition at line 103 of file sv_keyhunt.qc.

{
    if(view.kh_next && IS_SPEC(player))
        return false; // we don't want spectators of key carriers to see the attached waypoint on the top of their screen
    if(IS_SPEC(player) || warmup_stage || SAME_TEAM(player, this.owner))
        return true;
    if(IS_INVISIBLE(this.owner))
        return false; // hide the waypointsprite if the owner is invisible
 
    return kh_tracking_enabled;
}

References entity(), IS_INVISIBLE, IS_SPEC, kh_tracking_enabled, owner, SAME_TEAM, and warmup_stage.

Referenced by kh_Key_AssignTo().

kh_LoserTeam()

void kh_LoserTeam	(	int	loser_team,
		entity	lostkey )

Definition at line 584 of file sv_keyhunt.qc.

{
    float f;
    entity attacker = NULL;
    if(lostkey.pusher)
        if(lostkey.pusher.team != loser_team)
            if(IS_PLAYER(lostkey.pusher))
                attacker = lostkey.pusher;
 
    if(attacker)
    {
        if(lostkey.previous_owner)
            kh_Scores_Event(lostkey.previous_owner, NULL, "pushed", 0, -autocvar_g_balance_keyhunt_score_push);
            // don't actually GIVE them the -nn points, just log
        kh_Scores_Event(attacker, NULL, "push", autocvar_g_balance_keyhunt_score_push, 0);
        GameRules_scoring_add(attacker, KH_PUSHES, 1);
        //centerprint(attacker, "Your push is the best!"); // does this really need to exist?
    }
    else
    {
        int players = 0;
        float of = autocvar_g_balance_keyhunt_score_destroyed_ownfactor;
 
        FOREACH_CLIENT(IS_PLAYER(it) && it.team != loser_team, { ++players; });
 
        entity key;
        int keys = 0;
        FOR_EACH_KH_KEY(key)
            if(key.owner && key.team != loser_team)
                ++keys;
 
        if(lostkey.previous_owner)
            kh_Scores_Event(lostkey.previous_owner, NULL, "destroyed", 0, -autocvar_g_balance_keyhunt_score_destroyed);
            // don't actually GIVE them the -nn points, just log
 
        if(lostkey.previous_owner.playerid == lostkey.kh_previous_owner_playerid)
            GameRules_scoring_add(lostkey.previous_owner, KH_DESTRUCTIONS, 1);
 
        DistributeEvenly_Init(autocvar_g_balance_keyhunt_score_destroyed, keys * of + players);
 
        FOR_EACH_KH_KEY(key)
            if(key.owner && key.team != loser_team)
            {
                f = DistributeEvenly_Get(of);
                kh_Scores_Event(key.owner, NULL, "destroyed_holdingkey", f, 0);
            }
 
        int fragsleft = DistributeEvenly_Get(players);
 
        // Now distribute these among all other teams...
        int j = AVAILABLE_TEAMS - 1;
        for(int i = 0; i < AVAILABLE_TEAMS; ++i)
        {
            int thisteam = kh_Team_ByID(i);
            if(thisteam == loser_team) // bad boy, no cookie - this WILL happen
                continue;
 
            players = 0;
            FOREACH_CLIENT(IS_PLAYER(it) && it.team == thisteam, { ++players; });
 
            DistributeEvenly_Init(fragsleft, j);
            fragsleft = DistributeEvenly_Get(j - 1);
            DistributeEvenly_Init(DistributeEvenly_Get(1), players);
 
            FOREACH_CLIENT(IS_PLAYER(it) && it.team == thisteam, {
                f = DistributeEvenly_Get(1);
                kh_Scores_Event(it, NULL, "destroyed", f, 0);
            });
 
            --j;
        }
    }
 
    int realteam = kh_Team_ByID(lostkey.count);
    Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, APP_TEAM_NUM(loser_team, CENTER_ROUND_TEAM_LOSS));
    if(attacker)
        Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_TEAM_NUM(realteam, INFO_KEYHUNT_PUSHED), attacker.netname, lostkey.previous_owner.netname);
    else
        Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_TEAM_NUM(realteam, INFO_KEYHUNT_DESTROYED), lostkey.previous_owner.netname);
 
    play2all(SND(KH_DESTROY));
    te_tarexplosion(lostkey.origin);
 
    kh_FinishRound();
}

References APP_TEAM_NUM, autocvar_g_balance_keyhunt_score_destroyed, autocvar_g_balance_keyhunt_score_destroyed_ownfactor, autocvar_g_balance_keyhunt_score_push, AVAILABLE_TEAMS, DistributeEvenly_Get(), DistributeEvenly_Init(), entity(), FOR_EACH_KH_KEY, FOREACH_CLIENT, GameRules_scoring_add, IS_PLAYER, kh_FinishRound(), kh_Scores_Event(), kh_Team_ByID(), NULL, play2all(), players, Send_Notification(), and SND.

Referenced by kh_Key_Think().

kh_ScoreRules()

void kh_ScoreRules

(

int

teams

)

Definition at line 90 of file sv_keyhunt.qc.

{
    GameRules_scoring(teams, SFL_SORT_PRIO_PRIMARY, SFL_SORT_PRIO_PRIMARY, {
        field_team(ST_KH_CAPS, "caps", SFL_SORT_PRIO_SECONDARY);
        field(SP_KH_CAPS, "caps", SFL_SORT_PRIO_SECONDARY);
        field(SP_KH_PUSHES, "pushes", 0);
        field(SP_KH_DESTRUCTIONS, "destructions", SFL_LOWER_IS_BETTER);
        field(SP_KH_PICKUPS, "pickups", 0);
        field(SP_KH_KCKILLS, "kckills", 0);
        field(SP_KH_LOSSES, "losses", SFL_LOWER_IS_BETTER);
    });
}

References GameRules_scoring, SFL_LOWER_IS_BETTER, SFL_SORT_PRIO_PRIMARY, SFL_SORT_PRIO_SECONDARY, ST_KH_CAPS, and teams.

Referenced by kh_Initialize().

kh_Scores_Event()

void kh_Scores_Event	(	entity	player,
		entity	key,
		string	what,
		float	frags_player,
		float	frags_owner )

Definition at line 183 of file sv_keyhunt.qc.

{
    string s;
    if(game_stopped)
        return;
 
    if(frags_player)
        GameRules_scoring_add_team_float2int(player, SCORE, frags_player, float2int_decimal_fld, 1);
 
    if(key && key.owner && frags_owner)
        GameRules_scoring_add_team_float2int(key.owner, SCORE, frags_owner, float2int_decimal_fld, 1);
 
    if(!autocvar_sv_eventlog)  //output extra info to the console or text file
        return;
 
    s = strcat(":keyhunt:", what, ":", ftos(player.playerid), ":", ftos(frags_player));
 
    if(key && key.owner)
        s = strcat(s, ":", ftos(key.owner.playerid));
    else
        s = strcat(s, ":0");
 
    s = strcat(s, ":", ftos(frags_owner), ":");
 
    if(key)
        s = strcat(s, key.netname);
 
    GameLogEcho(s);
}

References autocvar_sv_eventlog, entity(), float2int_decimal_fld, ftos(), game_stopped, GameLogEcho(), GameRules_scoring_add_team_float2int, and strcat().

Referenced by kh_HandleFrags(), kh_Key_Collect(), kh_Key_DropAll(), kh_Key_DropOne(), kh_LoserTeam(), and kh_WinnerTeam().

kh_StartRound()

void kh_StartRound

(

)

Definition at line 907 of file sv_keyhunt.qc.

{
    if(time < game_starttime)
    {
        kh_Controller_SetThink(game_starttime - time + 0.1, kh_WaitForPlayers);
        return;
    }
 
    if(kh_GetMissingTeams())
    {
        kh_Controller_SetThink(1, kh_WaitForPlayers);
        return;
    }
 
    Kill_Notification(NOTIF_ALL, NULL, MSG_CENTER, CPID_KEYHUNT);
    Kill_Notification(NOTIF_ALL, NULL, MSG_CENTER, CPID_KEYHUNT_OTHER);
 
    for(int i = 0; i < AVAILABLE_TEAMS; ++i)
    {
        int teem = kh_Team_ByID(i);
        int players = 0;
        entity my_player = NULL;
        FOREACH_CLIENT(IS_PLAYER(it), {
            if(!IS_DEAD(it) && !PHYS_INPUT_BUTTON_CHAT(it) && it.team == teem)
            {
                ++players;
                if(random() * players <= 1)
                    my_player = it;
            }
        });
        kh_Key_Spawn(my_player, 360 * i / AVAILABLE_TEAMS, i);
    }
 
    kh_tracking_enabled = false;
    if(autocvar_g_balance_keyhunt_delay_tracking >= 0)
    {
        Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_KEYHUNT_SCAN, autocvar_g_balance_keyhunt_delay_tracking);
        kh_Controller_SetThink(autocvar_g_balance_keyhunt_delay_tracking, kh_EnableTrackingDevice);
    }
}

References autocvar_g_balance_keyhunt_delay_tracking, AVAILABLE_TEAMS, entity(), FOREACH_CLIENT, game_starttime, IS_DEAD, IS_PLAYER, kh_Controller_SetThink(), kh_EnableTrackingDevice(), kh_GetMissingTeams(), kh_Key_Spawn(), kh_Team_ByID(), kh_tracking_enabled, kh_WaitForPlayers(), Kill_Notification(), NULL, PHYS_INPUT_BUTTON_CHAT, players, random(), Send_Notification(), and time.

Referenced by kh_FinishRound(), and kh_WaitForPlayers().

kh_Team_ByID()

int kh_Team_ByID

(

int

t

)

Definition at line 67 of file sv_keyhunt.qc.

{
    if(t == 0) return NUM_TEAM_1;
    if(t == 1) return NUM_TEAM_2;
    if(t == 2) return NUM_TEAM_3;
    if(t == 3) return NUM_TEAM_4;
    return 0;
}

References NUM_TEAM_1, NUM_TEAM_2, NUM_TEAM_3, and NUM_TEAM_4.

Referenced by kh_GetMissingTeams(), kh_Key_Collect(), kh_Key_DropAll(), kh_Key_DropOne(), kh_LoserTeam(), and kh_StartRound().

kh_update_state()

void kh_update_state

(

)

Definition at line 126 of file sv_keyhunt.qc.

{
    entity key;
    int f;
    int s = 0;
    FOR_EACH_KH_KEY(key)
    {
        if(key.owner)
            f = key.team;
        else
            f = 30;
        s |= (32 ** key.count) * f;
    }
 
    FOREACH_CLIENT(true, { STAT(OBJECTIVE_STATUS, it) = s; });
 
    FOR_EACH_KH_KEY(key)
    {
        if(key.owner)
            STAT(OBJECTIVE_STATUS, key.owner) |= (32 ** key.count) * 31;
    }
    //print(ftos((nextent(NULL)).kh_state), "\n");
}

References entity(), FOR_EACH_KH_KEY, FOREACH_CLIENT, and STAT.

Referenced by kh_Key_AssignTo(), and kh_Key_Remove().

kh_WaitForPlayers()

void kh_WaitForPlayers

(

)

Definition at line 873 of file sv_keyhunt.qc.

{
    static int prev_missing_teams_mask;
    missing_teams_mask = kh_GetMissingTeams();
    if(time < game_starttime)
    {
        kh_Controller_SetThink(game_starttime - time + 0.1, kh_WaitForPlayers);
        return;
    }
 
    if(!missing_teams_mask)
    {
        Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_KEYHUNT_ROUNDSTART, autocvar_g_balance_keyhunt_delay_round);
        kh_Controller_SetThink(autocvar_g_balance_keyhunt_delay_round, kh_StartRound);
    }
    else
    {
        if(player_count != 0)
        {
            if(prev_missing_teams_mask != missing_teams_mask)
                prev_missing_teams_mask = missing_teams_mask;
        }
        kh_Controller_SetThink(1, kh_WaitForPlayers);
    }
}

References autocvar_g_balance_keyhunt_delay_round, game_starttime, kh_Controller_SetThink(), kh_GetMissingTeams(), kh_StartRound(), kh_WaitForPlayers(), missing_teams_mask, NULL, player_count, Send_Notification(), and time.

Referenced by kh_Controller_Think(), kh_Initialize(), kh_StartRound(), and kh_WaitForPlayers().

kh_waypointsprite_visible_for_bot()

bool kh_waypointsprite_visible_for_bot	(	entity	this,
		entity	e )

Definition at line 1019 of file sv_keyhunt.qc.

{
    entity key_wp = e.waypointsprite_attachedforcarrier;
    if (!key_wp)
    if (!key_wp.waypointsprite_visible_for_player(key_wp, this, WaypointSprite_getviewentity(this)))
    { // has no waypoint, or waypoint not visible
        if (!checkpvs(this.origin + this.view_ofs, e)) // key cannot be seen
            return false;
    }
    return true;
}

References checkpvs(), entity(), origin, view_ofs, and WaypointSprite_getviewentity().

Referenced by havocbot_goalrating_kh().

kh_WinnerTeam()

void kh_WinnerTeam

(

int

winner_team

)

Definition at line 522 of file sv_keyhunt.qc.

{
    // all key carriers get some points
    entity key;
    float score = (AVAILABLE_TEAMS - 1) * autocvar_g_balance_keyhunt_score_capture;
    DistributeEvenly_Init(score, AVAILABLE_TEAMS);
    // twice the score for 3 team games, three times the score for 4 team games!
    // note: for a win by destroying the key, this should NOT be applied
    FOR_EACH_KH_KEY(key)
    {
        float f = DistributeEvenly_Get(1);
        kh_Scores_Event(key.owner, key, "capture", f, 0);
        GameRules_scoring_add_team(key.owner, KH_CAPS, 1);
        nades_GiveBonus(key.owner, autocvar_g_nades_bonus_score_high);
    }
 
    bool first = true;
    string keyowner = "";
    FOR_EACH_KH_KEY(key)
        if(key.owner.kh_next == key)
        {
            if(!first)
                keyowner = strcat(keyowner, ", ");
            keyowner = key.owner.netname;
            first = false;
        }
 
    Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, APP_TEAM_NUM(winner_team, CENTER_ROUND_TEAM_WIN));
    Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_TEAM_NUM(winner_team, INFO_KEYHUNT_CAPTURE), keyowner);
 
    first = true;
    vector firstorigin = '0 0 0', lastorigin = '0 0 0', midpoint = '0 0 0';
    FOR_EACH_KH_KEY(key)
    {
        vector thisorigin = kh_AttachedOrigin(key);
        //dprint("Key origin: ", vtos(thisorigin), "\n");
        midpoint += thisorigin;
 
        if(!first)
        {
            // TODO: this effect has been replaced due to a possible crash it causes
            // see https://gitlab.com/xonotic/darkplaces/issues/123
            //te_lightning2(NULL, lastorigin, thisorigin);
            Send_Effect(EFFECT_TR_NEXUIZPLASMA, lastorigin, thisorigin, 1);
        }
        lastorigin = thisorigin;
        if(first)
            firstorigin = thisorigin;
        first = false;
    }
    if(AVAILABLE_TEAMS > 2)
    {
        //te_lightning2(NULL, lastorigin, firstorigin); // TODO see above
        Send_Effect(EFFECT_TR_NEXUIZPLASMA, lastorigin, firstorigin, 1);
    }
    midpoint = midpoint * (1 / AVAILABLE_TEAMS);
    te_customflash(midpoint, 1000, 1, Team_ColorRGB(winner_team) * 0.5 + '0.5 0.5 0.5');  // make the color >=0.5 in each component
 
    play2all(SND(KH_CAPTURE));
    kh_FinishRound();
}

References APP_TEAM_NUM, autocvar_g_balance_keyhunt_score_capture, autocvar_g_nades_bonus_score_high, AVAILABLE_TEAMS, DistributeEvenly_Get(), DistributeEvenly_Init(), entity(), FOR_EACH_KH_KEY, GameRules_scoring_add_team, kh_AttachedOrigin(), kh_FinishRound(), kh_Scores_Event(), nades_GiveBonus(), NULL, play2all(), Send_Effect(), Send_Notification(), SND, strcat(), Team_ColorRGB(), and vector.

Referenced by kh_Key_Think().

nades_GiveBonus()

void nades_GiveBonus	(	entity	player,
		float	score )

Definition at line 445 of file sv_nades.qc.

{
    if (autocvar_g_nades && autocvar_g_nades_bonus
    && IS_REAL_CLIENT(player) && IS_PLAYER(player) && STAT(NADE_BONUS, player) < autocvar_g_nades_bonus_max
    && !IS_DEAD(player) && !STAT(FROZEN, player))
    {
        if (STAT(NADE_BONUS_SCORE, player) < 1)
            STAT(NADE_BONUS_SCORE, player) += score / autocvar_g_nades_bonus_score_max;
 
        if (STAT(NADE_BONUS_SCORE, player) >= 1)
        {
            Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_NADE_BONUS);
            play2(player, SND(NADE_BONUS));
            ++STAT(NADE_BONUS, player);
            --STAT(NADE_BONUS_SCORE, player);
        }
    }
}

Referenced by kh_WinnerTeam().

void()

void

(

entity

this

)

References entity(), havocbot_role_kh_carrier(), havocbot_role_kh_defense(), havocbot_role_kh_freelancer(), and havocbot_role_kh_offense().

Variable Documentation

autocvar_g_balance_keyhunt_carrier_damage

vector autocvar_g_balance_keyhunt_carrier_damage

Definition at line 21 of file sv_keyhunt.qc.

Referenced by if().

autocvar_g_balance_keyhunt_carrier_force

vector autocvar_g_balance_keyhunt_carrier_force

Definition at line 22 of file sv_keyhunt.qc.

Referenced by if().

autocvar_g_balance_keyhunt_damageforcescale

float autocvar_g_balance_keyhunt_damageforcescale

Definition at line 10 of file sv_keyhunt.qc.

Referenced by kh_Key_Detach().

autocvar_g_balance_keyhunt_delay_collect

float autocvar_g_balance_keyhunt_delay_collect

Definition at line 11 of file sv_keyhunt.qc.

Referenced by kh_Key_Touch().

autocvar_g_balance_keyhunt_delay_damage_return

float autocvar_g_balance_keyhunt_delay_damage_return

Definition at line 12 of file sv_keyhunt.qc.

Referenced by kh_Key_Damage(), and kh_Key_Touch().

autocvar_g_balance_keyhunt_delay_return

float autocvar_g_balance_keyhunt_delay_return

Definition at line 13 of file sv_keyhunt.qc.

Referenced by kh_Key_Detach().

autocvar_g_balance_keyhunt_delay_round

float autocvar_g_balance_keyhunt_delay_round

Definition at line 14 of file sv_keyhunt.qc.

Referenced by kh_FinishRound(), and kh_WaitForPlayers().

autocvar_g_balance_keyhunt_delay_tracking

float autocvar_g_balance_keyhunt_delay_tracking

Definition at line 15 of file sv_keyhunt.qc.

Referenced by kh_StartRound().

autocvar_g_balance_keyhunt_dropvelocity

float autocvar_g_balance_keyhunt_dropvelocity

Definition at line 17 of file sv_keyhunt.qc.

Referenced by kh_Key_DropAll().

autocvar_g_balance_keyhunt_maxdist

float autocvar_g_balance_keyhunt_maxdist

Definition at line 18 of file sv_keyhunt.qc.

Referenced by kh_Key_Think().

autocvar_g_balance_keyhunt_noncarrier_damage

vector autocvar_g_balance_keyhunt_noncarrier_damage

Definition at line 23 of file sv_keyhunt.qc.

autocvar_g_balance_keyhunt_noncarrier_force

vector autocvar_g_balance_keyhunt_noncarrier_force

Definition at line 24 of file sv_keyhunt.qc.

autocvar_g_balance_keyhunt_protecttime

float autocvar_g_balance_keyhunt_protecttime

Definition at line 19 of file sv_keyhunt.qc.

Referenced by kh_Key_DropAll(), and kh_Key_DropOne().

autocvar_g_balance_keyhunt_return_when_unreachable

float autocvar_g_balance_keyhunt_return_when_unreachable

Definition at line 16 of file sv_keyhunt.qc.

Referenced by kh_Key_Spawn().

autocvar_g_balance_keyhunt_score_capture

int autocvar_g_balance_keyhunt_score_capture

Definition at line 26 of file sv_keyhunt.qc.

Referenced by kh_WinnerTeam().

autocvar_g_balance_keyhunt_score_carrierfrag

int autocvar_g_balance_keyhunt_score_carrierfrag

Definition at line 27 of file sv_keyhunt.qc.

Referenced by kh_HandleFrags().

autocvar_g_balance_keyhunt_score_collect

int autocvar_g_balance_keyhunt_score_collect

Definition at line 28 of file sv_keyhunt.qc.

Referenced by kh_HandleFrags(), and kh_Key_Collect().

autocvar_g_balance_keyhunt_score_destroyed

int autocvar_g_balance_keyhunt_score_destroyed

Definition at line 29 of file sv_keyhunt.qc.

Referenced by kh_LoserTeam().

autocvar_g_balance_keyhunt_score_destroyed_ownfactor

int autocvar_g_balance_keyhunt_score_destroyed_ownfactor

Definition at line 30 of file sv_keyhunt.qc.

Referenced by kh_LoserTeam().

autocvar_g_balance_keyhunt_score_push

int autocvar_g_balance_keyhunt_score_push

Definition at line 31 of file sv_keyhunt.qc.

Referenced by kh_LoserTeam().

autocvar_g_balance_keyhunt_throwvelocity

float autocvar_g_balance_keyhunt_throwvelocity

Definition at line 32 of file sv_keyhunt.qc.

Referenced by kh_Key_DropOne().

autocvar_g_keyhunt_teams_override

int autocvar_g_keyhunt_teams_override

Definition at line 35 of file sv_keyhunt.qc.

Referenced by kh_Initialize().

float2int_decimal_fld

float float2int_decimal_fld

Definition at line 182 of file sv_keyhunt.qc.

frag_target

entity frag_target = M_ARGV(2, entity)

Definition at line 1223 of file sv_keyhunt.qc.

kh_controller

entity kh_controller

Definition at line 76 of file sv_keyhunt.qc.

Referenced by kh_Controller_SetThink(), kh_finalize(), and kh_Initialize().

kh_Controller_Thinkfunc

var kh_Think_t kh_Controller_Thinkfunc

Definition at line 153 of file sv_keyhunt.qc.

Referenced by kh_Controller_SetThink(), and kh_Controller_Think().

kh_dropperteam

int kh_dropperteam

Definition at line 81 of file sv_keyhunt.qc.

kh_droptime

float kh_droptime

Definition at line 80 of file sv_keyhunt.qc.

Referenced by kh_Key_Touch().

kh_interferemsg_team

int kh_interferemsg_team

Definition at line 77 of file sv_keyhunt.qc.

Referenced by kh_Key_AssignTo(), and kh_Key_Think().

kh_interferemsg_time

float kh_interferemsg_time

Definition at line 78 of file sv_keyhunt.qc.

Referenced by kh_FinishRound(), kh_Key_AssignTo(), and kh_Key_Think().

KH_KEY_BRIGHTNESS

const float KH_KEY_BRIGHTNESS = 2

Definition at line 56 of file sv_keyhunt.qc.

Referenced by kh_Key_Spawn().

kh_key_carried

int kh_key_carried

Definition at line 85 of file sv_keyhunt.qc.

Referenced by kh_Initialize(), and kh_Key_Attach().

kh_key_dropped

int kh_key_dropped

Definition at line 85 of file sv_keyhunt.qc.

Referenced by kh_Initialize(), kh_Key_Detach(), and kh_Key_Spawn().

KH_KEY_MAX

const vector KH_KEY_MAX = '25 25 4'

Definition at line 55 of file sv_keyhunt.qc.

Referenced by kh_Key_Spawn().

KH_KEY_MIN

const vector KH_KEY_MIN = '-25 -25 -46'

Definition at line 54 of file sv_keyhunt.qc.

Referenced by kh_Key_Spawn().

KH_KEY_WP_ZSHIFT

const float KH_KEY_WP_ZSHIFT = 20

Definition at line 52 of file sv_keyhunt.qc.

Referenced by kh_Key_Spawn().

KH_KEY_XYDIST

const float KH_KEY_XYDIST = 24

Definition at line 49 of file sv_keyhunt.qc.

Referenced by kh_Key_Think().

KH_KEY_XYSPEED

const float KH_KEY_XYSPEED = 45

Definition at line 50 of file sv_keyhunt.qc.

Referenced by kh_Key_Think().

KH_KEY_ZSHIFT

const float KH_KEY_ZSHIFT = 22

Definition at line 48 of file sv_keyhunt.qc.

Referenced by kh_Key_Attach().

kh_next

entity kh_next

Definition at line 79 of file sv_keyhunt.qc.

Referenced by havocbot_role_kh_carrier(), havocbot_role_kh_defense(), havocbot_role_kh_freelancer(), and havocbot_role_kh_offense().

kh_no_radar_circles

bool kh_no_radar_circles

Definition at line 58 of file sv_keyhunt.qc.

Referenced by kh_FinishRound(), and kh_Key_AssignTo().

kh_prev

entity kh_prev

Definition at line 79 of file sv_keyhunt.qc.

kh_previous_owner_playerid

int kh_previous_owner_playerid

Definition at line 83 of file sv_keyhunt.qc.

previous_owner

entity previous_owner

Definition at line 82 of file sv_keyhunt.qc.

siren_time

float siren_time

Definition at line 65 of file sv_keyhunt.qc.

Referenced by kh_Key_Think().

ST_KH_CAPS

const int ST_KH_CAPS = 1

Definition at line 89 of file sv_keyhunt.qc.

Referenced by kh_ScoreRules().