The current scoring parameters are, ignoring some weirdnesses:
- Code: Select all
t "take" = set g_ctf_flagscore_pickup_base
p "pickup" = set g_ctf_flagscore_pickup_dropped_*
c "capture" = set g_ctf_flagscore_capture
k "kill" = set g_ctf_flagscore_kill
d "drop" = set g_ctf_flagpenalty_drop
l "lost" = set g_ctf_flagpenalty_returned
r "return" = set g_ctf_flagscore_return
Plus, there are some extra parameters like a suicidedrop penalty (meant to cancel out the pickup_dropped score the suicider gets from getting the flag again), but let's just consider these seven parameters for now, as they define the main scoring.
0. What can the flag do?
The flag can be in three states: BASE, CARRY and DROPPED. The state transitions are for the red flag:
BASE -> CARRY: Red team gets t
CARRY -> BASE: Red team gets c
CARRY -> DROPPED: Red team gets d, blue team gets k
DROPPED -> CARRY: Red team gets p
DROPPED -> BASE: Red team gets l, blue team gets r
DROPPED -> BASE: nobody gets anything (automatic return)
Now there are only so many things a flag can do:
Successful capture goes like:
BASE -> CARRY [-> DROPPED -> CARRY]^N -> BASE
Here, the red team gets (t + (-d + p)*N + c) and the blue team gets (k * N).
Failed capture goes like:
BASE -> CARRY [-> DROPPED -> CARRY]^N -> DROPPED -> BASE
Here, the red team gets (t + (-d + p)*N - d - l * R) and the blue team gets (k * (N + 1) + r * R), where R is 0 if the flag ended up in void, and 1 if it got returned.
1. Relative Scoring
Relative scoring is the scoring difference between the two teams.
The three cases give the following score:
Successful capture: (t + c) + (-d + p - k) * N.
Failed capture: (t - d - k) + (-d + p - k)*N - (l + r)*R
Parameters we will make from this:
WIN := t + c
LOSS := -(t - d - k - l - r)
RETURN := l + r
RETAKE := p - (d + k)
2. Absolute Scoring, As Seen By The Enemy
Successful capture: the enemy gets k*N.
Failed capture: the enemy gets k*(N+1) + r*R
So we'll make the following parameters:
KILL := k
DEFENSE := k + r
3. Absolute Scoring, As Seen By The Flag's Owner
This is a bit more complex, but as we'll already have 6 parameters to calculate 7 scoring variables, we'll take a shortcut.
Successful capture: (t + (-d + p)*N + c)
Failed capture: (t + (-d + p)*N - d - l * R)
Without thinking much, we'll try making
DEPOSIT := -t
the new parameter, in the spirit of [-z-]'s system.
4. Putting it together
WIN := t + c
LOSS := -(t - d - k - l - r)
RETURN := l + r
RETAKE := p - (d + k)
KILL := k
DEFENSE := k + r
DEPOSIT := -t
Solving this yields:
- Code: Select all
set g_ctf_flagscore_pickup_base (-DEPOSIT)
set g_ctf_flagscore_pickup_dropped_* (LOSS + RETAKE - RETURN - DEPOSIT)
set g_ctf_flagscore_capture (WIN + DEPOSIT)
set g_ctf_flagscore_kill (KILL)
set g_ctf_flagpenalty_drop (LOSS - RETURN - KILL - DEPOSIT)
set g_ctf_flagpenalty_returned (RETURN + KILL - DEFENSE)
set g_ctf_flagscore_return (DEFENSE - KILL)
In the current system, for example, we have:
Relative parameters: WIN = 21, LOSS = 5, RETURN = 5, RETAKE = 0
Defender parameters: KILL = 1, DEFENSE = 6
Attacker parameters: DEPOSIT = 0
[-z-] proposes (using +3 for pickup score, as it is variable in his system):
Relative parameters: WIN = 25, LOSS = 18, RETURN = 3, RETAKE = -7
Defender parameters: KILL = 5, DEFENSE = 8
Attacker parametrs: DEPOSIT = 5
As you see, failing to capture even ONCE is almost as much as a real capture, in the relative scoring... my main problem with the system. This makes that system viable ONLY for personal scores, and NEVER for deciding a match.
To now use the equations the other way round, I'll recalculate [-z-]'s parameters with a removed deposit, but nothing else changed:
Relative parameters: WIN = 25, LOSS = 18, RETURN = 3, RETAKE = -7
Defender parameters: KILL = 5, DEFENSE = 8
Attacker parametrs: DEPOSIT = 0
- Code: Select all
set g_ctf_flagscore_pickup_base 0
set g_ctf_flagscore_pickup_dropped_* 8
set g_ctf_flagscore_capture 25
set g_ctf_flagscore_kill 5
set g_ctf_flagpenalty_drop 10
set g_ctf_flagpenalty_returned 0
set g_ctf_flagscore_return 3
A slightly varied system that should be able to work fine with points scoring too, but should still have the good effects for caps-only scoring:
Relative parameters: WIN = 24, LOSS = 12, RETURN = 6, RETAKE = -3
Defender parameters: KILL = 3, DEFENSE = 8
Attacker parametrs: DEPOSIT = 1
- Code: Select all
set g_ctf_flagscore_pickup_base -1
set g_ctf_flagscore_pickup_dropped_* 2
set g_ctf_flagscore_capture 25
set g_ctf_flagscore_kill 3
set g_ctf_flagpenalty_drop 2
set g_ctf_flagpenalty_returned 1
set g_ctf_flagscore_return 5
This system should be in the same spirit, but less "harsh". There is a little idea in it: the one who last had the flag gets a -1 penalty only if the flag gets returned (so he should try to protect it and get it again).