First of all, let's do a mathematical analysis of CTF scoring systems so we know what we actually are talking about.

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).

No one gave you credit for this thread but there is a lot of great information here. You've thought out CTF and explained it very well mathematically. Pyschologically, I think there is still a problem with your last system with only -1. It doesn't imply enough risk as the -5 does (which I can understand as "too harsh"). I'd push for at least -2 and rebalance from there.

Well, I am no longer convinced of that system either, which is why the parameters poll is running. From that poll, I'll generate the input parameters to get a system.

Here a parameter set for personal CTF scores (not using differences between the teams):

AWIN = attacker score for succeeded capture = g_ctf_flagscore_pickup_base + g_ctf_flagscore_capture
AFAIL = attacker score for failed capture = g_ctf_flagscore_pickup_base - g_ctf_flagpenalty_drop - g_ctf_flagpenalty_returned
AFAILVOID = attacker score for failed capture with flag ending up in void = g_ctf_flagscore_pickup_base - g_ctf_flagpenalty_drop
DWIN = defender success score (i.e. kill FC + return) = g_ctf_flagscore_kill + g_ctf_flagscore_return
ARETRY = attacker score for retrying capture = -g_ctf_flagpenalty_drop + g_ctf_flagscore_pickup_dropped
DRETRY = defender half-success score (i.e. kill FC, no return) = g_ctf_flagscore_kill
ATAKE = flag pickup score (temporary) = g_ctf_flagscore_pickup_base

g_ctf_flagscore_pickup_base = ATAKE
g_ctf_flagscore_capture = AWIN - ATAKE
g_ctf_flagpenalty_drop = ATAKE - AFAILVOID
g_ctf_flagpenalty_returned = AFAILVOID - AFAIL
g_ctf_flagscore_kill = DRETRY
g_ctf_flagscore_return = DWIN - DRETRY
g_ctf_flagscore_pickup_dropped_* = ARETRY + ATAKE - AFAILVOID