#include "sv_damagetext.qh"

Include dependency graph for sv_damagetext.qc:

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

Macros
#define	SV_DAMAGETEXT_ALL()
#define	SV_DAMAGETEXT_DISABLED()
#define	SV_DAMAGETEXT_PLAYERS()
#define	SV_DAMAGETEXT_SPECTATORS_ONLY()

Functions
	AUTOCVAR (sv_damagetext, int, 2, "\\\"0\\\" = disable damage text, \\\"1\\\" = show damage text to spectators, \\\"2\\\" = also to the attacker, \\\"3\\\" = show damage text to all players")
	MUTATOR_HOOKFUNCTION (damagetext, ClientDisconnect)
	MUTATOR_HOOKFUNCTION (damagetext, PlayerDamaged)
	MUTATOR_HOOKFUNCTION (damagetext, PlayerSpawn)
	REGISTER_MUTATOR (damagetext, true)
bool	write_damagetext (entity this, entity client, int sf)

Variables
const int	BITS_PER_INT = 24
int	dent_attackers [DENT_ATTACKERS_SIZE]
const int	DENT_ATTACKERS_SIZE = 11
float	dent_net_armor
float	dent_net_deathtype
int	dent_net_flags
float	dent_net_health
float	dent_net_potential

Macro Definition Documentation

◆ SV_DAMAGETEXT_ALL

#define SV_DAMAGETEXT_ALL ( )

Value:

(autocvar_sv_damagetext >= 3)

Definition at line 10 of file sv_damagetext.qc.

Referenced by write_damagetext().

◆ SV_DAMAGETEXT_DISABLED

#define SV_DAMAGETEXT_DISABLED ( )

Value:

(autocvar_sv_damagetext <= 0)

Definition at line 7 of file sv_damagetext.qc.

Referenced by MUTATOR_HOOKFUNCTION().

◆ SV_DAMAGETEXT_PLAYERS

#define SV_DAMAGETEXT_PLAYERS ( )

Value:

(autocvar_sv_damagetext >= 2)

Definition at line 9 of file sv_damagetext.qc.

Referenced by write_damagetext().

◆ SV_DAMAGETEXT_SPECTATORS_ONLY

#define SV_DAMAGETEXT_SPECTATORS_ONLY ( )

Value:

(autocvar_sv_damagetext >= 1)

Definition at line 8 of file sv_damagetext.qc.

Referenced by write_damagetext().

Function Documentation

◆ AUTOCVAR()

AUTOCVAR	(	sv_damagetext	,
		int	,
		2	,
		"\\\"0\\\"	= disable damage text,
		\\\"1\\\"	= show damage text to spectators,
		\\\"2\\\"	= also to the attacker )

◆ MUTATOR_HOOKFUNCTION() [1/3]

MUTATOR_HOOKFUNCTION	(	damagetext	,
		ClientDisconnect	)

Definition at line 138 of file sv_damagetext.qc.

{
    entity player = M_ARGV(0, entity);
    int player_id = etof(player) - 1;
    int idx = floor(player_id / BITS_PER_INT);
    int bit = player_id % BITS_PER_INT;
    // remove from attacker list of all players
    FOREACH_CLIENT(IS_PLAYER(it), {
        it.dent_attackers[idx] &= ~BIT(bit);
    });
}

References BIT, BITS_PER_INT, ClientDisconnect, entity(), etof, floor(), FOREACH_CLIENT, IS_PLAYER, and M_ARGV.

◆ MUTATOR_HOOKFUNCTION() [2/3]

MUTATOR_HOOKFUNCTION	(	damagetext	,
		PlayerDamaged	)

Definition at line 62 of file sv_damagetext.qc.

                                                {
    if (SV_DAMAGETEXT_DISABLED()) return;
    entity attacker = M_ARGV(0, entity);
    entity hit = M_ARGV(1, entity); if (hit == attacker) return;
    float health = M_ARGV(2, float);
    float armor = M_ARGV(3, float);
    int deathtype = M_ARGV(5, int);
    float potential_damage = M_ARGV(6, float);
    if (potential_damage == 0)
        return;
    if (MUTATOR_IS_ENABLED(mutator_instagib) && DEATH_WEAPONOF(deathtype) == WEP_VAPORIZER)
        return;
 
    static entity net_text_prev;
    static float net_damagetext_prev_time;
 
    bool multiple = (net_damagetext_prev_time == time && net_text_prev && !wasfreed(net_text_prev)
        && net_text_prev.realowner == attacker && net_text_prev.enemy == hit
        && net_text_prev.dent_net_deathtype == deathtype);
 
    if (multiple)
    {
        // damage of multiple projectiles hitting player at the same time, e.g. shotgun
        // is accumulated on the same damagetext entity
        health += net_text_prev.dent_net_health;
        armor += net_text_prev.dent_net_armor;
        potential_damage += net_text_prev.dent_net_potential;
    }
 
    int flags = 0;
    if (SAME_TEAM(hit, attacker)) flags |= DTFLAG_SAMETEAM;
    if (health >= DAMAGETEXT_SHORT_LIMIT) flags |= DTFLAG_BIG_HEALTH;
    if (armor >= DAMAGETEXT_SHORT_LIMIT) flags |= DTFLAG_BIG_ARMOR;
    if (potential_damage >= DAMAGETEXT_SHORT_LIMIT) flags |= DTFLAG_BIG_POTENTIAL;
    if (!armor) flags |= DTFLAG_NO_ARMOR;
    if (almost_equals_eps(armor + health, potential_damage, 5)) flags |= DTFLAG_NO_POTENTIAL;
 
    if (multiple)
    {
        net_text_prev.dent_net_flags = flags;
        net_text_prev.dent_net_health = health;
        net_text_prev.dent_net_armor = armor;
        net_text_prev.dent_net_potential = potential_damage;
        return;
    }
    else if (attacker)
    {
        int attacker_id = etof(attacker) - 1;
        int idx = floor(attacker_id / BITS_PER_INT);
        int bit = attacker_id % BITS_PER_INT;
        if (!(hit.dent_attackers[idx] & BIT(bit)))
        {
            // player is hit for the first time after respawn by this attacker
            hit.dent_attackers[idx] |= BIT(bit);
            flags |= DTFLAG_STOP_ACCUMULATION; // forcedly stop client-side damage accumulation
        }
    }
 
    entity net_text = new_pure(net_damagetext);
    net_text.realowner = attacker;
    net_text.enemy = hit;
    net_text.dent_net_flags = flags;
    net_text.dent_net_deathtype = deathtype;
    net_text.dent_net_health = health;
    net_text.dent_net_armor = armor;
    net_text.dent_net_potential = potential_damage;
 
    net_text_prev = net_text;
    net_damagetext_prev_time = time;
 
    setthink(net_text, SUB_Remove);
    net_text.nextthink = (time > 10) ? (time + 0.5) : 10; // allow a buffer from start time for clients to load in
 
    Net_LinkEntity(net_text, false, 0, write_damagetext);
}

References almost_equals_eps(), BIT, BITS_PER_INT, DAMAGETEXT_SHORT_LIMIT, DEATH_WEAPONOF, DTFLAG_BIG_ARMOR, DTFLAG_BIG_HEALTH, DTFLAG_BIG_POTENTIAL, DTFLAG_NO_ARMOR, DTFLAG_NO_POTENTIAL, DTFLAG_SAMETEAM, DTFLAG_STOP_ACCUMULATION, entity(), etof, flags, floor(), health, M_ARGV, MUTATOR_IS_ENABLED, Net_LinkEntity(), new_pure, SAME_TEAM, setthink, SUB_Remove(), SV_DAMAGETEXT_DISABLED, time, and write_damagetext().

◆ MUTATOR_HOOKFUNCTION() [3/3]

MUTATOR_HOOKFUNCTION	(	damagetext	,
		PlayerSpawn	)

Definition at line 150 of file sv_damagetext.qc.

{
    entity player = M_ARGV(0, entity);
    for (int i = 0; i < DENT_ATTACKERS_SIZE; ++i)
        player.dent_attackers[i] = 0;
}

References DENT_ATTACKERS_SIZE, entity(), and M_ARGV.

◆ REGISTER_MUTATOR()

REGISTER_MUTATOR	(	damagetext	,
		true	)

◆ write_damagetext()

bool write_damagetext	(	entity	this,
		entity	client,
		int	sf )

Definition at line 23 of file sv_damagetext.qc.

{
    entity attacker = this.realowner;
    entity hit = this.enemy;
    int flags = this.dent_net_flags;
    int deathtype = this.dent_net_deathtype;
    float health = this.dent_net_health;
    float armor = this.dent_net_armor;
    float potential_damage = this.dent_net_potential;
    if (!(
        (SV_DAMAGETEXT_ALL()) ||
        (SV_DAMAGETEXT_PLAYERS() && client == attacker) ||
        (SV_DAMAGETEXT_SPECTATORS_ONLY() && IS_SPEC(client) && client.enemy == attacker) ||
        (SV_DAMAGETEXT_SPECTATORS_ONLY() && IS_OBSERVER(client))
    )) return false;
 
    WriteHeader(MSG_ENTITY, damagetext);
    WriteByte(MSG_ENTITY, etof(hit));
    WriteInt24_t(MSG_ENTITY, deathtype);
    WriteByte(MSG_ENTITY, flags);
 
    // we need to send a few decimal places to minimize errors when accumulating damage
    // sending them multiplied saves bandwidth compared to using WriteCoord,
    // however if the multiplied damage would be too much for (signed) short, we send an int24
    if (flags & DTFLAG_BIG_HEALTH) WriteInt24_t(MSG_ENTITY, health * DAMAGETEXT_PRECISION_MULTIPLIER);
    else WriteShort(MSG_ENTITY, health * DAMAGETEXT_PRECISION_MULTIPLIER);
    if (!(flags & DTFLAG_NO_ARMOR))
    {
        if (flags & DTFLAG_BIG_ARMOR) WriteInt24_t(MSG_ENTITY, armor * DAMAGETEXT_PRECISION_MULTIPLIER);
        else WriteShort(MSG_ENTITY, armor * DAMAGETEXT_PRECISION_MULTIPLIER);
    }
    if (!(flags & DTFLAG_NO_POTENTIAL))
    {
        if (flags & DTFLAG_BIG_POTENTIAL) WriteInt24_t(MSG_ENTITY, potential_damage * DAMAGETEXT_PRECISION_MULTIPLIER);
        else WriteShort(MSG_ENTITY, potential_damage * DAMAGETEXT_PRECISION_MULTIPLIER);
    }
    return true;
}