sv_mayhem.qh File Reference

#include <common/mutators/base.qh>

Include dependency graph for sv_mayhem.qh:

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

Go to the source code of this file.

Functions
void	mayhem_Initialize ()
void	MayhemCalculatePlayerScore (entity scorer)
	REGISTER_MUTATOR (mayhem, false)

Function Documentation

mayhem_Initialize()

void mayhem_Initialize

(

)

Definition at line 41 of file sv_mayhem.qc.

{
    GameRules_limit_score(autocvar_g_mayhem_point_limit);
    GameRules_limit_lead(autocvar_g_mayhem_point_leadlimit);
 
    // unused for now
    //InitializeEntity(NULL, mayhem_DelayedInit, INITPRIO_GAMETYPE);
}

References autocvar_g_mayhem_point_leadlimit, autocvar_g_mayhem_point_limit, GameRules_limit_lead(), and GameRules_limit_score().

Referenced by REGISTER_MUTATOR().

MayhemCalculatePlayerScore()

void MayhemCalculatePlayerScore

(

entity

scorer

)

Definition at line 145 of file sv_mayhem.qc.

{
    int scoringmethod = 1;
    float upscaler; // how much score does 1 frag give
    float frag_weight; // how many frags should a kill be worth
    float damage_weight; // how many frags is damage worth of player's spawn health+armor
 
    // if frag is 0.25 , damage is 0.75 and upscaler is 20
    // then killing a full hp opponent is 1 frag which is worth of 20 score
    // or damage worth of 2 starting health+armor is 1.5 frags or 30 score even if no kills were gotten
 
    bool disable_selfdamage2score;
 
    if (teamplay) {
        // use Team Mayhem values
        upscaler = autocvar_g_tmayhem_scoring_upscaler;
        frag_weight = autocvar_g_tmayhem_scoring_kill_weight;
        damage_weight = autocvar_g_tmayhem_scoring_damage_weight;
        disable_selfdamage2score = autocvar_g_tmayhem_scoring_disable_selfdamage2score;
    } else {
        // use FFA Mayhem values
        upscaler = autocvar_g_mayhem_scoring_upscaler;
        frag_weight = autocvar_g_mayhem_scoring_kill_weight;
        damage_weight = autocvar_g_mayhem_scoring_damage_weight;
        disable_selfdamage2score = autocvar_g_mayhem_scoring_disable_selfdamage2score;
    }
 
    // decide scoringmethod and avoid potential divide by 0 errors
 
    if (frag_weight && damage_weight) // both frag and damage weights have non-zero values
        scoringmethod = 1;
    else if (frag_weight) // frag weight has a value
        scoringmethod = 2;
    else if (damage_weight) // damage weight has a value
        scoringmethod = 3;
    else
        return; // neither frags nor damage are set to give score
 
    switch (scoringmethod)
    {
        default:
        case 1:
        {
            // calculate how much score the player should have based on their damage dealt and frags gotten and then add the missing score
 
            // give a different weight for suicides if scoring method 1 doesn't have selfdamage2score enabled to harshly punish for suicides to avoid exploiting
            float suicide_weight = 1 + (disable_selfdamage2score / frag_weight);
 
            // total damage divided by player start health&armor to get how many lives worth of damage they've dealt,
            // then calculate new value affected by weight
            float playerdamagescore = ((scorer.total_damage_dealt / (start_health + start_armorvalue)) * 100) * upscaler * damage_weight;
                                                                                                   //  * 100 to avoid float inaccuracy at that decimal level
 
            // playerdamagescore rounded to one decimal
            float roundedplayerdamagescore = rint(playerdamagescore * 10) / 10;
 
            // amount of kills
            float killcount = PlayerScore_Get(scorer, SP_KILLS) - PlayerScore_Get(scorer, SP_TEAMKILLS) - (PlayerScore_Get(scorer, SP_SUICIDES) * suicide_weight);
 
            // kills minus suicides, calculate weight
            float playerkillscore = (killcount * 100) * upscaler * frag_weight;
                                           //  * 100 to avoid float inaccuracy at that decimal level
 
            float playerscore = roundedplayerdamagescore + playerkillscore;
 
            // calculated how much score the player has and now calculate total of how much they are supposed to have
            float scoretoadd = playerscore - (PlayerScore_Get(scorer, SP_SCORE) * 100);
                                                                            //  * 100 to avoid float inaccuracy at that decimal level
 
            // adjust total score to be what the player is supposed to have
            GameRules_scoring_add_team(scorer, SCORE, floor(scoretoadd / 100));
                                                                   //  / 100 to move back to the original decimal level
 
            #if 0
                // debug printing
                if(!IS_BOT_CLIENT(scorer)){
                    print(sprintf("%f", scorer.total_damage_dealt),         " scorer.total_damage_dealt \n");
                    print(sprintf("%f", scorer.hitsound_damage_dealt),      " scorer.hitsound_damage_dealt \n");
                    print(sprintf("%f", playerdamagescore/100),             " playerdamagescore \n");
                    print(sprintf("%f", roundedplayerdamagescore/100),      " rounded playerdamagescore \n");
                    print(sprintf("%f", playerkillscore/100),               " playerkillscore \n");
                    print(sprintf("%f", PlayerScore_Get(scorer, SP_KILLS)), " PlayerScore_Get(scorer, SP_KILLS) \n");
                    print(sprintf("%f", playerscore/100),                   " playerscore \n");
                    print(sprintf("%f", scoretoadd/100),                    " scoretoadd \n");
                    print(sprintf("%f", PlayerScore_Get(scorer, SP_SCORE)), " PlayerScore_Get(scorer, SP_SCORE) \n \n");
                }
            #endif
            return;
        }
 
        case 2:
        {
            // calculate how much score the player should have based on their frags gotten and then add the missing score
            float playerkillscore = PlayerScore_Get(scorer, SP_KILLS) - PlayerScore_Get(scorer, SP_TEAMKILLS) - PlayerScore_Get(scorer, SP_SUICIDES);
            float upscaledplayerscore = playerkillscore * upscaler;
            float scoretoadd = upscaledplayerscore - PlayerScore_Get(scorer, SP_SCORE);
            GameRules_scoring_add_team(scorer, SCORE, floor(scoretoadd));
 
            #if 0
                // debug printing
                if(!IS_BOT_CLIENT(scorer)){
                    print(sprintf("%f", playerkillscore),                   " playerkillscore \n");
                    print(sprintf("%f", PlayerScore_Get(scorer, SP_KILLS)), " PlayerScore_Get(scorer, SP_KILLS) \n");
                    print(sprintf("%f", upscaledplayerscore),               " upscaled playerscore \n");
                    print(sprintf("%f", scoretoadd),                        " scoretoadd \n");
                    print(sprintf("%f", PlayerScore_Get(scorer, SP_SCORE)), " PlayerScore_Get(scorer, SP_SCORE) \n \n");
                }
            #endif
            return;
        }
 
        case 3:
        {
            // calculate how much score the player should have based on their damage dealt and then add the missing score
            float playerdamagescore = ((scorer.total_damage_dealt / (start_health + start_armorvalue)) * 100);
            float roundedplayerdamagescore = rint(playerdamagescore * 10) / 10;
            float upscaledplayerscore = roundedplayerdamagescore * upscaler;
            float scoretoadd = upscaledplayerscore - (PlayerScore_Get(scorer, SP_SCORE) * 100);
            GameRules_scoring_add_team(scorer, SCORE, floor(scoretoadd / 100));
 
            #if 0
                // debug printing
                if(!IS_BOT_CLIENT(scorer)){
                    print(sprintf("%f", scorer.total_damage_dealt),         " scorer.total_damage_dealt \n");
                    print(sprintf("%f", playerdamagescore),                 " playerdamagescore \n");
                    print(sprintf("%f", roundedplayerdamagescore),          " rounded playerdamagescore \n");
                    print(sprintf("%f", upscaledplayerscore),               " upscaled playerscore \n");
                    print(sprintf("%f", scoretoadd),                        " scoretoadd \n");
                    print(sprintf("%f", PlayerScore_Get(scorer, SP_SCORE)), " PlayerScore_Get(scorer, SP_SCORE) \n \n");
                }
            #endif
            return;
        }
    }
}

References autocvar_g_mayhem_scoring_damage_weight, autocvar_g_mayhem_scoring_disable_selfdamage2score, autocvar_g_mayhem_scoring_kill_weight, autocvar_g_mayhem_scoring_upscaler, autocvar_g_tmayhem_scoring_damage_weight, autocvar_g_tmayhem_scoring_disable_selfdamage2score, autocvar_g_tmayhem_scoring_kill_weight, autocvar_g_tmayhem_scoring_upscaler, entity(), floor(), GameRules_scoring_add_team, IS_BOT_CLIENT, killcount, PlayerScore_Get, print(), rint(), start_armorvalue, start_health, and teamplay.

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

REGISTER_MUTATOR()

REGISTER_MUTATOR	(	mayhem	,
		false	)

Definition at line 7 of file sv_mayhem.qh.

{
    MUTATOR_STATIC();
    MUTATOR_ONADD
    {
        mayhem_Initialize();
    }
    return 0;
}

References mayhem_Initialize(), MUTATOR_ONADD, and MUTATOR_STATIC.