settings.ini

; ============================================================================
;  Basic-Extended 4.2.3 settings
;
;  Lines starting with ; are comments. Switches accept 1/0, true/false, yes/no, on/off.
;  Colours are $RRGGBB. Times are in seconds unless the key name says Ticks (60 ticks = 1 second).
;  Numbers may use a dot or a comma.
;  Commands = words separated by |, written without the ! or / and matched in lower case; an empty
;  list switches that command off. This file lies next to main.pas. The lists (the rules, the
;  messages, the command lists, the reserved slots, the Steam admins, the watched players) are
;  numbered keys of their sections - Line-1, Line-2 ... - add as many as you like, in any order and
;  with gaps; the data folder keeps what the script writes (players.bdb, granted_admins.txt).
;  /reloadsettings (admin in game, or the server console) applies changes while the server runs.
;  Unknown keys and values out of range are reported in the server console at load.
; ============================================================================

[General]
; Console lines sent to one player per tick (1-10); the rest waits for the next ticks. Many lines to one
; player in one tick can stop the server, so keep this low. AntiFake Extended and ZitroStats keep a limit
; of their own and none of the three scripts knows the others: a player who calls up long lists from all of
; them at once can get the sum in one tick (about 18 lines with the defaults); 10 is the highest value tried.
LinesPerTick = 4
; Lines sent to everybody per tick (1-5)
BroadcastLinesPerTick = 2
; Longest waiting queue per player (lines, 20-1000); anything beyond is dropped
MaxQueuedLines = 200
; MemoryReads = 1: the weapons, the keys and the aim of every soldier are read straight from the server's records
; of the soldiers once the library has found where they lie (it matches what the script reads on two soldiers);
; one soldier is checked against the script's own values every second and any difference switches the reading off
; until the next start (/be_status tells which way it works). The ammunition of all soldiers is then one call a
; tick. 0 = the script reads the properties of every soldier itself.
MemoryReads = 1
; Default colours of answers
ColorGood = $00BFFF
ColorBad = $FF0033
; Told to everybody when the script starts (after /recompile); {version}; empty = nothing
StartMessage = Basic-Extended v{version} loaded - successfully :)
; Points and money only against somebody: while a player has no opponent in the game - nobody of another team (in
; the modes without teams nobody else; the spectators do not count) - he earns nothing: no [Points], no [Shop]
; money (the income and the round's money neither; a crate gives something else than money), no score points of
; the extras ([Medic] and the others) and no mines for a capture. So nothing pays alone, with everybody in the
; spectators or with only his own team in the game. A loss (a suicide, team damage) counts anyway.
; any = a bot counts as an opponent, humans = only a human does, off = everything pays even alone
Opponents = any
; Told to him when something did not pay for that reason (once, and again after he had an opponent); empty = nothing
NoOpponentText = Nobody plays against you - no points or money until an opponent joins.

; ----------------------------------------------------------------------------------------------------
;  Combat: health display, regeneration, kits, damage numbers, hit flash, radar
; ----------------------------------------------------------------------------------------------------

[HealthHud]
; Health of the player on their screen (BigText). It is sent only when the shown value changes (a hit,
; regeneration, respawn) and again every RefreshSeconds, and hidden with ' ' when the player dies or goes to
; the spectators. Players change it with !hp (see Commands).
Enabled = 1
; BigText layer (0-255). ZitroStats uses 12-15, Soldat's own kill messages use 1.
Layer = 199
; Shown to players who have not switched it off themselves
DefaultOn = 1
; Default position (0-854 x 0-480: 480 is the screen height, the width depends on the aspect ratio of
; the player's screen - keep X below 600 to be seen on every screen) and letter size (0.005-0.5).
; ZitroStats' own line (!hud) is at 20 436 and its admin countdown at 20 410, both size 0.02.
X = 20
Y = 384
Scale = 0.02
; Styles a player chooses with !hp style <n>. Tokens: {pct} percent, {hp} health points,
; {max} maximum health, {bar} bar, {regen} RegenMark while regenerating, {vest} vest percent
Style1 = Health: {pct}% {regen}
Style2 = HP {hp}/{max} {regen}
Style3 = {bar} {pct}% {regen}
Style4 = {pct}% {regen}
Style5 = Health: {pct}% Vest: {vest}% {regen}
DefaultStyle = 1
BarLength = 10
BarFull = |
BarEmpty = .
RegenMark = +
; Colour from full health through half to no health (a smooth blend)
ColorFull = $00FF00
ColorHalf = $FFFF00
ColorLow = $FF0000
; The text is sent when it changes, after a respawn and a map change, and again every RefreshSeconds
; (0-3600): the 2.8.2 server sends such texts without any delivery check, so a lost one is repaired that way.
; Every line of the HUD (health, ammunition, grenades, mines, blood, money, class, score, vest) lives three
; RefreshSeconds on the screen; DisplayTicks (600-3600000) is its life only with RefreshSeconds = 0.
DisplayTicks = 360000
RefreshSeconds = 5
; Commands of the players (!hp, !hp on|off|style <n>|size <n>|pos <x> <y>|pos reset|edit|done|reset|help)
Commands = hp|health
; Remember each player's choice (data/basic-extended/players.bdb, by Steam id; a player without Steam by their
; computer id - HWID); 0 = nothing is kept, and the choices kept before are not used either
SavePlayers = 1
; The editor (!hp edit, !radar edit): the player stands still and moves the text with the movement
; keys, jump / crouch = up / down, reload / change weapon = bigger / smaller; the grenade key (E) or
; !hp done = save and leave, lying down (X, prone) = leave without saving. It saves and ends by itself
; after EditorSeconds (5-600) or when the player is hit. A tap moves the text by EditorStep pixels
; (1-20); a held key waits a third of a second, then moves slowly, and faster after a second.
EditorSeconds = 60
EditorStep = 1
; Low health: at LowPercent (0 = off) and below the text is LowColor, blinking with LowBlinkColor
; every LowBlinkTicks ticks (0 = no blinking)
LowPercent = 25
LowColor = $FF0000
LowBlinkColor = $FFFFFF
LowBlinkTicks = 20

[Ammo]
; Limited ammunition: every weapon comes with a reserve (below, in rounds) and the magazine in the
; weapon is refilled only from it. The script follows the magazine count the game reports (Soldat
; keeps the magazine in the player's game: it fires and reloads there) and believes a new count after
; 8 ticks, so the server's own short guesses do not count. When a reload loads more than the reserve
; holds, the magazine is set to what is left; a bot's weapon always reloads full, so bots only lose
; the weapon at the end. The aimbot takes its rounds from the same magazine; /infammo counts nothing.
Enabled = 0
; 1 = an empty weapon with nothing left to load is taken away (the secondary stays); 0 = a player's
; stays empty: the magazine is set to 0 again before the game's reload could fill it (a bot's is taken
; away all the same - the server reloads a bot's weapon at once and full)
EmptyDrop = 1
; 1 = bots run out of ammunition too
Bots = 1
; The chainsaw burns fuel (its reserve, in millilitres; shown in litres from 1 l up): 1 ml every
; ChainsawIdleDrainTicks while in the hands, and ChainsawAttackDrain ml more every ChainsawDrainTicks
; while sawing (60 ticks = 1 second). The fuel stays in the saw's tank when it is thrown away.
ChainsawIdleDrainTicks = 20
ChainsawDrainTicks = 3
ChainsawAttackDrain = 1
; 1 = weapons left on the ground are remembered by their map object: a dead soldier's spare magazines
; lie with his weapon and go to the one who picks it up (or loots it, see [Looting]); a weapon thrown
; away keeps only the rounds in it, the spare magazines stay with the soldier (and end with his life).
; A team change or leaving the game leaves the weapon in the hands as a death does.
TrackGroundWeapons = 1
; 1 = the reserve comes in full magazines of the weapon's size (weapons.ini), rounded to whole ones
; (160 rounds of an AK-74 with 35-round magazines: 5 magazines): a reload takes the fullest spare
; magazine (or the one chosen with !mag <n>), and reloading early puts the magazine with the rounds left
; back into the pouch. 0 = one pool of rounds per weapon. The Spas-12 (shell by shell), single-round
; weapons (M79, LAW, bows) and the chainsaw always use the pool.
MagazineMode = 1
; 1 = a picked weapon brings all the spare magazines of its dead owner; 0 = only when the own pouch for
; that weapon is empty
PickupFullSet = 0
; The most spare magazines of a weapon a soldier carries: what a fresh weapon comes with plus
; ExtraMagazines (0 = not more than that, -1 = up to 12). Looting stops there, and a dead soldier's
; weapon picked up brings no more; a weapon without magazines keeps at most its reserve below and as
; many magazines' worth
ExtraMagazines = 1
; Survival: a player alive at the end of a round keeps his ammunition for the next one (SurvivalCarry = 1):
; the magazines of every weapon he used (the one in his gun back in its pouch - the next round's gun is
; loaded with his fullest one), his bandage and first-aid kits ([Bleeding]), the Javelins he fired; a death in
; the round takes it all. SurvivalLock = 1: a weapon he has no rounds left for is locked in his weapon menu
; until he dies or the map changes (taken from his hands when he has it anyway) - with or without the game's
; Advance mode
SurvivalCarry = 0
SurvivalLock = 0
; 1 = the ammunition is added to the health line ("| Ammo: 25 [40, 40]" or "| Ammo: 25/120"); 2 = it
; has its own text with its own place, size and colours ([AmmoHud], the players move it with !ammohud);
; 0 = it is not shown
HudAppend = 2
; !ammo (or /ammo) shows the magazine and the reserve; !mag lists the spare magazines, !mag <n> loads
; that one now
Commands = ammo
MagCommands = mag
; !repack (or /repack) puts the partial spare magazines together: after RepackStartSeconds without
; shooting, one magazine every RepackSecondsPerMagazine (0.1-30); a shot, a reload or another weapon
; stops it
RepackCommands = repack
RepackStartSeconds = 1
RepackSecondsPerMagazine = 1
; 1 = the spare magazines are always kept in order, the fullest first; 0 = in the order they came,
; !repack puts them in order (and that takes its time too)
SortMagazines = 1
; A reload with one round left: 0 = the round is lost with its magazine (as if it stayed in the
; chamber), 1 = the magazine with its round goes back into the pouch like any partial one
ReloadOneRound = 0
; A reload cut short by a weapon change (to the secondary, thrown away, a team change, death): 0 = the
; magazine taken out is lost, 1 = it goes back into the pouch
InterruptedReload = 0
; The health line shows this word when no spare magazine is left ("Ammo: 2 [empty]")
HudNoSpareText = empty
; The reserve of each weapon in rounds, besides the magazine it comes with (0 = only that magazine;
; with MagazineMode = 1 rounded to whole magazines, at least one). CombatKnife = spare knives: a
; thrown knife is replaced from them after the throw (0 = it is gone, as in the game).
USSOCOM = 48
DesertEagles = 28
HKMP5 = 180
Ak74 = 160
SteyrAUG = 150
Spas12 = 42
Ruger77 = 24
M79 = 6
BarrettM82A1 = 15
FNMinimi = 150
XM214Minigun = 100
CombatKnife = 0
Chainsaw = 1000
M72LAW = 4
Flamer = 200
RamboBow = 15
FlamedArrows = 10

[AmmoHud]
; [Ammo] HudAppend = 2: the ammunition in its own text (BigText layer Layer, top-left corner X Y on a
; 854 x 480 screen - keep X below 600 to be seen on every screen - letter size Scale). Its colour follows
; what is left of a full load (the magazine and the spare rounds against a fresh weapon): Color, LowColor
; below LowPercent, CriticalColor below CriticalPercent. With nothing left at all (EmptyDrop = 0) or
; for NoAmmoSeconds after the weapon was taken away NoAmmoText blinks in NoAmmoColor and
; NoAmmoBlinkColor every BlinkTicks. It is sent with the health text and lives as long as it (three
; [HealthHud] RefreshSeconds). Players: !ammohud on|off|pos <x> <y>|pos reset|size <n>|edit|reset
Layer = 196
DefaultOn = 1
X = 20
Y = 428
Scale = 0.02
Color = $00FF00
LowPercent = 35
LowColor = $FFA500
CriticalPercent = 15
CriticalColor = $FF3030
NoAmmoText = NO AMMO
NoAmmoColor = $FF0000
NoAmmoBlinkColor = $FFFFFF
BlinkTicks = 20
NoAmmoSeconds = 3
Commands = ammohud

[Looting]
; Crouching or lying still over a dead soldier's weapon of the kind in the hands takes one of the
; spare magazines lying there after LootSeconds; with the own pouch full it tops up the partial
; magazines after RepackSeconds. Needs [Ammo] TrackGroundWeapons = 1.
Enabled = 1
; how far from the weapon (pixels)
Radius = 45.0
LootSeconds = 1
RepackSeconds = 3
; Where a dead soldier's spare magazines stay: weapon = with his weapon (they go to the one who picks
; it up, or are looted where it lies); body = with his body (looted where the body lies; the weapon
; brings only the rounds in it; gone when he lives again); auto = body in survival mode (the dead stay
; down until the round ends), weapon otherwise. A team change or leaving the game always leaves them
; with the weapon. body and auto need Enabled = 1.
DeadMagazines = weapon
; Items: the gear a dead soldier carried stays with his body (what he really had at his death - a survival round's end is
; no death) and a looter takes it where the magazines are taken (crouching or lying still within Radius of the body for
; LootSeconds), each kind up to what he can carry; the rest stays on the body for the next one, and a body with nothing
; left is no loot point (it is marked, Markers, for the ones who have room for something on it). The kinds, joined by |:
; bandage (percent, [Bleeding]), kits (first-aid kits, [Bleeding]), grenades and flashes ([FlashNades] - it must be on:
; the game's own grenade count cannot be set to a number), mines and claymores ([Mines] - they need KeepOnDeath = 0
; there: a death then empties his stock onto his body; with KeepOnDeath = 1 they stay with the player and naming them
; here does nothing); none = no gear. Mines and claymores are earned by kills, so the default leaves them out (a mine the
; [Shop] takes at death, LoseOnDeath, is not on the body). The vest, the Javelins, the AP rounds and a class's skills are
; not lootable. Needs Enabled = 1 and [Ammo] TrackGroundWeapons. "Looted +30% bandage, +1 first-aid kit." tells him what
; he took.
; The most a looter holds of a kind, 0 = the limit of the module the item belongs to: MaxBandage in percent ([Bleeding]
; Bandage), MaxKits (the larger of [Bleeding] Kits and [Shop] MaxKits), MaxGrenades and MaxFlashes (what a life of his
; class brings: [FlashNades] Nades and Flashes, or his class's loadout); mines and claymores stop at [Mines] MaxMines and
; MaxClaymores.
Items = bandage|kits|grenades|flashes
MaxBandage = 0
MaxKits = 0
MaxGrenades = 0
MaxFlashes = 0
; the size of the Looting and Repacking texts over the soldier, and their place: sideways (pixels, + is
; right) and height (pixels, - is up) from the soldier standing (crouching or lying it goes down with
; his head)
TextScale = 0.022
TextOffsetX = 2
TextOffsetY = -30
; The WorldText layer of those texts (1-255); keep it clear of the other WorldText layers of the modules on
; (the start of the script says in the log when two share one)
TextLayer = 249
; Markers = 1: a small marker in the world at every loot point he could take something from - a dead soldier's weapon or
; body with spare magazines of the kind of weapon in his hands, and room for them in his pouch - within MarkerDistance
; pixels (50-3000) and with a clear line from his eyes to it on the map (a wall in between hides it). The marker stands
; where looting works from: the weapon's object, or the body where the game has it now (a body that slides away takes its
; marker along) - not on a ragdoll that drifted. Players only (bots with [Debug] BotsSeeTexts). Needs [Ammo] with
; TrackGroundWeapons. Each player is looked at every MarkerRefreshTicks ticks (5-120); the nearest MarkerLayers (1-16)
; get a WorldText each, from the layer MarkerLayerFirst on, and only what changed is sent. MarkerText is the text (up to
; 12 letters), MarkerColor its colour, MarkerScale its size, MarkerOffsetY the height of its top edge over the point
; (pixels, - is up). Keep the layers clear of the other WorldText layers of the modules on (the start of the script says in
; the log when two share one; 4-9 are free of all of them)
Markers = 1
MarkerDistance = 500
MarkerText = +
MarkerColor = $FFD040
MarkerScale = 0.05
MarkerOffsetY = -6
MarkerLayerFirst = 4
MarkerLayers = 6
MarkerRefreshTicks = 20
; KeepWeapons: the weapons lying on the ground do not vanish before the round ends (the game removes a dropped weapon 20
; seconds after the drop, and the players' games stop drawing it then too). 0 = as the game does; 1 = in survival rounds:
; a weapon dropped in the round stays until somebody takes it or the round ends, and at the round's end whatever lies there
; is let go (it runs out the time it has left, up to about 19 s - the server's own Survival_Clear_Weapons clears it at
; once); 2 = in every game mode, until somebody takes it, the cap below throws it out or the map changes. Free weapons
; only (guns, knife, chainsaw, LAW - not flags, kits, the bow or stationary guns), and only ones dropped while it is on.
; It does not need Enabled above; with [Ammo] TrackGroundWeapons the spare magazines lying with a weapon stay with it.
KeepWeapons = 1
; at most this many weapons are kept (1-80); the oldest above it run out on their own time, so a new drop always finds a
; free one of the server's 90 object slots (flags, kits and stationary guns use some too)
KeepWeaponsMax = 50
; how: bridge = the library finds the server's table of objects in its code, checks it against what the script sees
; (it writes nothing before they agree) and puts the time of a weapon back before it runs out, then has the server send
; the object to the players again (their games count the 20 s themselves); the weapon stays the same object, rounds and
; all. recreate = the script kills a weapon shortly before the end and makes the same weapon at the same place (it falls
; and settles again, may slide a little, has a full magazine and no owner). auto = bridge, and recreate when the bridge
; cannot be used. /be_status has a "things bridge" line.
KeepWeaponsMethod = auto

[Regeneration]
; Battlefield 3 style: after DelaySeconds without being hit (and without enemy bullets flying close,
; see [Suppression]) health comes back, slowly at first and faster and faster, up to MaxPercent.
; Rates are percent of the maximum health (150, or 65 in realistic mode) per second.
Enabled = 1
DelaySeconds = 5
StartRate = 3
; added to the rate every second while regenerating
Acceleration = 12
MaxRate = 50
; up to this percent of the maximum health (1-100)
MaxPercent = 100
; Health is added every StepTicks ticks (1-30)
StepTicks = 6
; Bots regenerate as well
Bots = 1
; set = health is set directly (no damage event); damage = healed through Soldat's damage routine with a
; negative value, so other scripts (ZitroStats healing statistics) see it like a healing field. A vest
; would keep three quarters of such a heal, so players with a vest are always healed directly.
Method = set

[Suppression]
; An enemy bullet flying within Radius pixels of a player (ExplosiveRadius for grenades, M79, LAW,
; clusters and flame arrows) delays their regeneration by DelaySeconds, even when it misses. A player
; is about 25 pixels tall. Bullets are checked every ScanTicks ticks (1-30), and only while somebody
; waits for regeneration.
Enabled = 1
Radius = 50
ExplosiveRadius = 130
DelaySeconds = 3
ScanTicks = 4
; Bullets of team mates count too when friendly fire is on
TeamBullets = 1

[Kits]
; Kits removed from the maps: their spawn points are switched off while a map loads (no kit is created) and
; the kits that exist are removed when the map loads and once more about 3 seconds later (kits that appear
; while it loads). SweepSeconds: 0 (the default) = nothing more; 1-30 = all the object slots are also looked
; at every that many seconds, which catches a kit another script or an admin tool made later, or one from a
; spawn point switched on again (one look costs about 0.12 ms: every 3 seconds that is well under 1 us of a
; tick on average). A kind switched back on with /reloadsettings comes back from the next map.
; Medical kits (the regeneration replaces them)
Medkits = 1
; Grenade kits (1 = players have only the grenades they spawn with; on for the RSCS mode)
GrenadeKits = 0
; Bonus kits: flamer, predator, vest, berserker and cluster grenades
BonusKits = 0
SweepSeconds = 0

[DamageNumbers]
; Numbers above the hit player, seen only by the shooter (WorldText). Hits in the same tick are added up
; and sent as one message; at most 8 numbers (and flash grenade marks) go to one player in one tick;
; the radar has its own budget ([Radar] TextsPerTick).
Enabled = 1
DefaultOn = 1
; Commands of the players (!dmg switches the numbers on and off)
Commands = dmg|damage
; sum = one number per victim that grows while the hits keep coming (StackTicks apart at most);
; column = every hit on its own line under the previous ones (5 lines at most); hit = every hit gets
; its own number
Mode = sum
; percent = percent of the victim's maximum health, hp = health points
Unit = percent
; taken = the health the victim really lost: after the other scripts (spawn protection may cancel a
; hit), after the vest, and never more than they had - a hit that did nothing shows nothing;
; hit = the damage the hit carried, as Soldat gave it to this script (can be over 100%)
Amount = taken
; Realistic mode hides the players a shooter cannot see (behind a wall, behind their back, over 1000
; pixels away). A number over such a player would show where they are, so none is shown (nor a kill mark).
; auto = only in realistic mode, on = in every mode, off = never
LineOfSight = auto
; Show the damage a player does to themselves (own grenades)
ShowSelf = 1
; 1 = a number keeps its full colour for DisplayTicks and is taken away at once; 0 = it fades out
; (the game fades a text over its last 77 ticks, so short-lived texts look pale)
Sharp = 1
StackTicks = 45
DisplayTicks = 90
Scale = 0.0235
; Where the number is: centred over the player, OffsetX pixels to the right (negative = left) and
; OffsetY pixels above the victim's feet to the top of the text (the head is about 20 above them)
OffsetX = 0
OffsetY = 26
; WorldText layers used for one shooter (1-255); the spawn point marks of [Spawns] have layers of their
; own (MarkLayerFirst ...).
LayerFirst = 200
LayerLast = 209
ColorEnemy = $FF6060
ColorFriend = $60FF60
ColorSelf = $FFFF60
ColorKill = $FF2020
; Text of a kill (added to the number)
KillMark = X

[HitFlash]
; A red flash over the whole screen of the hit player (a giant letter O whose ring lies over the
; edges of the screen, like battlefield.pas). It lasts TicksPerPercent ticks per percent of
; ReferenceHealth lost (MinTicks-MaxTicks) and fades out; the game draws a text with less than 77 ticks
; left fainter, so a short flash is a faint one. ReferenceHealth 65: a hit flashes as long in the normal
; mode as in the realistic one (0 = the maximum health of the mode). The client puts BigText in a 480
; units high space whose width depends on the player's screen (640 at 4:3, 854 at 16:9), so one edge of
; the screen alone cannot be flashed reliably: the whole screen is.
Enabled = 0
Char = O
Scale = 75
X = -4100
Y = -4100
Color = $FF0000
Layer = 197
TicksPerPercent = 0.8
MinTicks = 24
MaxTicks = 80
ReferenceHealth = 65

[Radar]
; The players near you with their health: a list, a circle, labels over the players, or dots on a
; ring around your soldier. It shows players behind walls, so who gets which mode is set below.
; Two groups:
;  - full users: the Steam ids of SteamIds (S123456789, 76561198083722517, STEAM_0:1:61728394 or
;    [U:1:123456789]; several separated by |), and the admins in the game with AdminsFull = 1;
;  - everybody else, only with Public = 1.
; Each group has its modes (FullModes / PublicModes: list|circle|labels|ring, all or none), the mode
; it starts with (Mode / PublicMode), whether the radar is on at the start (DefaultOn /
; PublicDefaultOn), what it shows (Show / PublicShow) and how often it may be updated (FullMinTicks /
; PublicMinTicks). Example: a circle for everybody with only the enemies the team can see, and every
; mode with everybody for the admins:
;   Public = 1, PublicModes = circle, PublicShow = seen, AdminsFull = 1, FullModes = all, Show = all
Enabled = 1
SteamIds =
AdminsFull = 0
Public = 0
FullModes = list|circle|labels|ring
PublicModes = list|circle
DefaultOn = 1
PublicDefaultOn = 0
; Commands: /radar (/overlay) for full users and admins, !radar in the chat. Both take: on, off,
; mode <name> (or just the name), tick <n>, zoom <n>, show <filter>, team on|off, outline on|off,
; edit, done, pos <x> <y>, size <n>, marks <n>, edge <n>, reset, help. The help lists only the modes
; the player may use. The place, the size, the zoom and the update rate are kept for each mode:
; size is the list's letters, the circle, the labels' letters or the ring's dots; edit moves and
; resizes the list and the circle, and resizes the labels and the ring.
Commands = overlay|radar
PlayerCommands = radar
; The mode a group starts with (list, circle, labels or ring); every player may choose another one of
; the group's modes with !radar mode
Mode = list
PublicMode = list
; Players within Range pixels (50-5000; a screen is about 850 wide). ListRange, LabelsRange,
; CircleRange and RingRange (0 = Range) give a mode its own reach.
Range = 700
ListRange = 0
LabelsRange = 0
CircleRange = 0
RingRange = 0
; No faster than every FullMinTicks / PublicMinTicks ticks (1-600), also with !radar tick
FullMinTicks = 1
PublicMinTicks = 10
; -- list --
; Top-left corner (0-854 x 0-480), letter size and colour, BigText layer of the title (0-255)
ListX = 10
ListY = 150
ListScale = 0.018
ListColor = $E0E0E0
ListLayer = 198
; The nearest ListLines players (1-20), made again every ListUpdateTicks ticks (1-600; each player may
; choose their own with !radar tick <n>); a text is sent only when it changes
ListLines = 8
ListUpdateTicks = 15
; First line (empty = none) and one line per player. Tokens: {name} {pct} health percent,
; {m} the distance in meters as the kill screen shows it (pixels / 14), {dist} the distance in pixels,
; {dir} where the player is (< left, > right, ^ above, v below, o here), {tag} F or R (see Tags)
ListTitle = Radar
ListLine = {dir} {tag}{name} {pct}% {m}
; Decimals of {m} (0-3; the kill screen shows 2)
ListMeterDecimals = 2
; The line when nobody is within reach ({m} = the reach in meters, {range} = in pixels)
ListNobody = (nobody within {m})
; The colour of a player's line: team (FriendColor / EnemyColor), health, distance (RingColorNear -
; Mid - Far) or none (ListColor; then the whole list is one text). With a colour every line is its own
; BigText on the layers ListLineLayerFirst .. +ListLines+2 (keep them clear of 197-199), ListLineSpacing
; lines apart (0.6-4).
ListColorBy = team
ListLineSpacing = 1.2
ListLineLayerFirst = 170
; -- circle --
; Top-left corner of the circle (0-854 x 0-480), its radius (10-240) and the size of its marks; the
; radius stands for the reach. CircleDots (0-32) dots draw the ring, SelfChar is you in the middle;
; the players within reach are EnemyChar / FriendChar (team mates in team games), those further away
; sit on the ring as FarChar in their direction (ShowFar = 1). Made again every CircleUpdateTicks
; ticks; a player's mark is sent again only when it moved more than CircleMovePixels screen pixels
; (0-20; 0 = every pixel, the smoothest). A bigger circle (!radar size) moves its marks in finer steps;
; !radar marks <n> keeps the marks small in it. CircleEdgeScale (0.2-5; !radar edge <n> for each
; player) sizes the dots on the edge: the ring and the players beyond reach.
; BigText layers CircleLayerFirst .. CircleLayerFirst+67.
CircleX = 10
CircleY = 110
CircleRadius = 50
CircleScale = 0.03
CircleUpdateTicks = 4
CircleDots = 16
CircleLayerFirst = 110
ShowFar = 1
CircleMovePixels = 0
CircleEdgeScale = 1
RingChar = .
RingColor = $808080
SelfChar = +
SelfColor = $FFFFFF
EnemyChar = o
EnemyColor = $FF4040
FriendChar = o
FriendColor = $40FF40
FarChar = .
; The walls around you in the circle: OutlineDots (4-64) rays go out from you in every direction and a
; dot shows where each one meets a wall (within the reach) - the shape of the room or cave you are in.
; Made again only when you moved OutlineGridPixels or the circle changed. Outline = 0 switches it off
; for everybody; each player switches it with !radar outline on|off (OutlineDefaultOn = the start).
; BigText layers OutlineLayerFirst .. +OutlineDots-1.
Outline = 1
OutlineDefaultOn = 0
OutlineDots = 32
OutlineLayerFirst = 40
OutlineColor = $707070
OutlineChar = .
OutlineGridPixels = 24
OutlineMovePixels = 2
; Team mates are shown in team games with ShowTeam = 1 (each player may choose with !radar team on|off).
ShowTeam = 1
; Which enemies it shows (team mates always):
;   all         - everybody;
;   seen        - those you or a living team mate can see: on a realistic server by the game's rule
;                 (in front of the aim, no wall between, up to 1000 px), on a normal server those on
;                 the screen of you or the mate (walls do not hide anybody there);
;   seenall     - like seen, dead team mates count too;
;   seenreal    - like seen, but always by the realistic rule (walls hide) on any server;
;   seenallreal - like seenreal with the dead team mates.
; Show for full users (they may choose anything), PublicShow for everybody else (they may not choose
; to see more). The realistic rule casts rays: the team's view is made again every VisionRoundTicks
; ticks (1-600) with at most VisionRaysPerTick ray casts a tick (1-200).
Show = all
PublicShow = seen
; PublicMaxZoom: a public radar reaches at most this many times its range (0.5-4; a bigger list or
; circle takes its share of it - the zoom is cut to fit)
PublicMaxZoom = 1
VisionRaysPerTick = 24
VisionRoundTicks = 15
; SkeletonSight = 1: the realistic rule's rays go between the soldiers' upper bodies as the server's own
; skeletons have them (point 7, the viewer's 2 px higher - the game's rule), so crouching, lying and
; rolling count; the realistic fog of war of the damage numbers and the flash marks ([FlashNades]
; LabelLineOfSight: from the viewer's neck, as the game hides grenades) use it too. 0 = the older way,
; fixed heights over the feet (12 px) - in case the radar shows somebody the game does not.
SkeletonSight = 1
; A bigger radar (size, !radar size) reaches a little further: SizeAffectsRange of the size change
; (0-1; 0.25 = size 2 reaches 25% further). !radar zoom <n> multiplies the reach; the circle marks get
; smaller for it (by the square root of the zoom).
SizeAffectsRange = 0.25
; Tags = 1: a flag carrier is FlagChar, a player with a bow BowChar (on the circle, in the list as
; the token {tag}, in the labels in brackets, on the ring)
Tags = 1
FlagChar = F
BowChar = R
; Flags = 1: a flag that is out of its base and not carried (dropped) is shown in every mode (a carried
; flag is the carrier's own letter, never a second mark) - a line
; of the list (ListFlagLine with {flag} {dir} {m} {dist}), FlagMarkChar on the circle and the ring, its
; name over it in the labels. Flags in their base are not shown. CTF and Infiltration: red and blue,
; Hold the Flag and Pointmatch: the yellow one.
Flags = 1
FlagMarkChar = F
FlagRedName = Red flag
FlagBlueName = Blue flag
FlagYellowName = Flag
FlagRedColor = $FF4040
FlagBlueColor = $4080FF
FlagYellowColor = $FFFF40
ListFlagLine = {dir} {flag} {m}
; Everything is worked out in basicext_dll, and a text is sent only when it changed. At most
; TextsPerTick radar texts go to one player in a tick (1-40) and MaxTextsPerSecond (10-2000) in a
; second; what does not fit follows in the next ticks.
TextsPerTick = 20
MaxTextsPerSecond = 150
; The public users (Public = 1) have a lower limit of their own, PublicMaxTextsPerSecond (10-2000): with
; many of them using the circle at once their texts add up to thousands of packets a second. What does
; not fit follows in the next ticks.
PublicMaxTextsPerSecond = 60
; TextsPerTickAll: the radar texts of all players together in one tick at most (10-2000); the users
; take turns, the rest follow in the next ticks
TextsPerTickAll = 120
; -- ring (the mode name "arrows" still works) --
; One dot on a ring RingRadius pixels around your soldier for each of the RingPlayers (1-32) nearest
; players within reach, in their direction. The size of the dot tells the distance: RingDotNear for
; the nearest, down to RingDotFar at the edge of the reach, in RingSizeSteps sizes (1-16). The colour
; (RingColorBy): team = EnemyColor / FriendColor of the circle, distance = RingColorNear - Mid - Far,
; health = the colour of the player's health. A flag carrier, a bow or a dropped flag is a letter of
; RingLetterScale, up to RingTagScale bigger when near. The ring is drawn where your soldier will be when it reaches you (your ping times
; RingLead, 0-3), and a dot goes out again only when it moved more than RingMove pixels. Made again
; every RingUpdateTicks ticks (!radar tick <n> in the ring mode). WorldText layers RingLayerFirst ..
; +34 (one per player slot and the flags).
RingUpdateTicks = 5
RingPlayers = 6
RingRadius = 30
RingDotNear = 0.16
RingDotFar = 0.07
RingSizeSteps = 4
RingColorBy = team
RingColorNear = $FF2020
RingColorMid = $FFFF20
RingColorFar = $20FF20
RingDotChar = .
RingTagScale = 0.5
RingLetterScale = 0.03
RingMove = 1.5
RingLead = 1
RingLayerFirst = 210
; -- labels --
; "name health%" centred over every player, made again every UpdateTicks ticks (1-600); a label goes
; out again only when its player moved more than LabelMovePixels or the health changed, and is taken
; away when the player dies or leaves the range (no fading). LabelColorBy: health, team, distance or
; none (the health colours).
UpdateTicks = 6
Scale = 0.02
; pixels from the player's feet up to the top of the label (the head is about 20 above them)
OffsetY = 25
LabelMovePixels = 2
LabelColorBy = health
; WorldText layers LayerFirst .. LayerFirst+34 (one per player slot and the flags, 0-221)
LayerFirst = 150

[TeamGuard]
; A player in a team the game mode does not have (a cheat or a console trick) is put into one it has:
; deathmatch, pointmatch and rambomatch - no team (0); CTF, infiltration and HTF - Alpha or Bravo (the
; smaller); teammatch - the four teams. Spectators are left alone. The move is made inside the game's join
; event: the team lists (Game.Teams[].Count) of a script loaded after this one are off by one for that player
; until his slot is used again (ZitroStats does not read them); a script that refuses the move (the balance of
; ZitroStats may) leaves him where he is, and the log says so.
Enabled = 1

[KillInfo]
; One line to the killed player: who killed them, the killer's health left and the damage they did to
; the killer during their own life, counted from the killer's last respawn or the start of the killer's last
; regeneration (the health really lost, at most 100%). Tokens: {killer} {weapon} {pct} {hp} {dealt}
; ({dealt} in the unit of [DamageNumbers] Unit), {dist} {air} (the killing shot as the game shows it
; under "You killed": metres and seconds in the air, ? when unknown)
; Off here: ZitroStats shows a death summary after every death on this server.
Enabled = 1
Text = Killed by {killer} ({weapon}), {pct}% health left. You hit them for {dealt}.
Color = $FFA500

; ----------------------------------------------------------------------------------------------------
;  Player commands (in the chat with !)
; ----------------------------------------------------------------------------------------------------

[CommandList]
; The list of commands. ZitroStats answers !zitro, !help and !reginfo with its own help (!cmds and !commands
; are left to this script), AntiFake answers !antifake.
Enabled = 1
Commands = cmd|command|cmds|commands
; auto = the commands switched on in this script (the first word of each), then the Extra lines;
; lines = the Line-N lines below (in number order; Color-Line-N gives a line its own colour)
Source = auto
; Extra1 .. Extra20: lines under the automatic list (text|$colour)
Extra1 = Statistics, rankings and accounts: !zitro   Visits and names: !antifake|$FF9999
Color = $00BFFF
; Lines shorter than this are filled with spaces (the console then draws them smaller; 0 = off)
PadTo = 135
Line-1 = __________Commands_List:___________________________________________________
Line-2 = !j !s     !rate          !rate <*> !time        !whois       !admin       |
Line-3 = !ping     !ping <*>      !track    !track <*>   !rules       !reginfo     |
Line-4 = !visits   !lastvisitors  !locate                !locate <*>  !locateall   |
Line-5 = ?nextmap  ?lastmap       !map                   !maps        !allmaps     |
Line-6 = !nextmap  !lastmap       !map <part|full name>  !randommap   !vote        |
Line-7 = !hp       !hp help       !dmg      !maplist     ?map         !cmd         |
Line-8 = !suspects !suspects all  !acstats <*>           !acreview <*>             |
Line-9 = __________________________________________________________________________|

[Rules]
; The rules: Line-1, Line-2 ... in number order (add as many as you like); Color-Line-N gives a
; line its own colour, the others have Color
Enabled = 1
Commands = rules|rul
Color = $00BFFF
ShowAfterMapChange = 1
Line-1 = _______________________________________________
Color-Line-1 = $FFFF00
Line-2 = |Respect the following rules or GTFO:         |
Color-Line-2 = $FFFF00
Line-3 = |ALLOWED: Spraying, Capping, Camping.         |
Color-Line-3 = $00FF00
Line-4 = |RESTRICTED: Cheating, Excessive camping      |
Color-Line-4 = $FF0000
Line-5 = |            Spam, Bugs, Team change abuse.   |
Color-Line-5 = $FF0000
Line-6 = |_____________________________________________|
Color-Line-6 = $FF0000

[MapInfo]
; ?nextmap, ?lastmap and ?map in the chat (ZitroStats answers !nextmap, !lastmap and !map with votes)
Enabled = 1
NextMap = ?nextmap
LastMap = ?lastmap
CurrentMap = ?map
Color = $00BFFF

[MapList]
; The maps of the rotation in columns (ZitroStats answers !maps and !allmaps)
Enabled = 1
Commands = maplist|listmaps
Columns = 5
Color = $00BFFF
; Lines shorter than this are filled with spaces (smaller letters; 0 = off)
PadTo = 135

[Ratio]
Enabled = 1
Commands = rate|ratio|kd|k/d|kdratio
; 1 = the answer is shown to everybody
Public = 1

[Ping]
Enabled = 1
Commands = ping
Public = 1

[PingTrack]
Enabled = 1
Commands = track|t|pingtrack|trackping
Seconds = 5
Public = 1

[LagGuard]
; The connections of the players (off by default). Once a second each player's ping is read and his warps are counted
; (his position corrected by more than WarpPixels over what his speed allows: the server put him where his late or
; lost packets said); the last WindowSeconds are kept - the average, the spread (the mean jump between two readings),
; the highest ping and the warps a minute. A second in which the server stood still counts for nobody; moves of the
; script (teleports, a rally) are no warps. It never kicks: the server kicks above soldat.ini Max_Ping after
; Max_Ping_Warnings warnings (6 s apart) and bans for 15 minutes - with ServerLimit = 1 the script follows that
; rule and tells the player how close he is (LimitText: {ping}, {limit}, {seconds}). WarnPing: a player whose average
; is higher is told (WarnText) at most every WarnEverySeconds (0 = never). IgnoreAdmins = 1: the admins are left
; alone. /lag (admins): every player measured, the worst first; !track shows the spread and the warps too.
; The spectators (all three 0 = never): a player whose average is over SpecPing, or the spread over SpecJitter, or
; with more than SpecWarps warps a minute for SpecSeconds goes to the spectators (SpecText to everybody) - only with
; MinPlayers players or more, in a survival round only when he is dead; !j answers WaitText until his average stays
; under ResumePing for ResumeSeconds. Tokens: {player} {ping} {jitter} {max} {warps} {limit} {seconds}.
Enabled = 0
WindowSeconds = 30
WarpPixels = 24
IgnoreAdmins = 1
WarnPing = 250
WarnEverySeconds = 120
ServerLimit = 1
SpecPing = 0
SpecJitter = 0
SpecWarps = 0
SpecSeconds = 60
MinPlayers = 8
ResumePing = 200
ResumeSeconds = 30
WarnText = Your connection: ping {ping} ms (spread {jitter} ms, {warps} warps a minute).
LimitText = Your ping {ping} ms is over the server's limit of {limit} ms - the server kicks you in about {seconds} s.
SpecText = {player} was moved to the spectators (connection: ping {ping} ms, {warps} warps a minute).
WaitText = Your connection is not good enough to play yet (ping {ping} ms).
Color = $FFC060
Commands = lag|laggers

[Time]
Enabled = 1
Commands = time|date
Format = dd.mm.yyyy - h:nn:ss
Public = 1

[WhoIsAdmin]
Enabled = 1
Commands = whoisadmin|adminlist|adminsonline|onlineadmins|onlineadmin|adminonline|whois
; TCP admins answer the line "/clientlist" in the console with "[x] name"
CountTcp = 1
CountInGame = 1
Seconds = 3

[CallAdmin]
; !admin [text] tells the admins in the game and the TCP admins (server console) that somebody needs them
Enabled = 1
Commands = admin|calladmin
CooldownSeconds = 60

[Teams]
; Join the game or the spectators (ZitroStats answers !join, !bal, !teams and !switch)
Enabled = 1
JoinCommands = j|start|play
SpectateCommands = s|spec|5|specators|joins
; Teams by name; empty = off
AlphaCommands =
BravoCommands =
CharlieCommands =
DeltaCommands =
; 0 = no limit
MaxSpectators = 10
; Balance: the team words (AlphaCommands ...) refuse a team that already has as many players as the player's own
; (from the spectators: a team that is not the smallest) - 1 = on, 0 = off, auto = as the server (soldat.ini
; Balance_Teams). AutoBalance = 1: when Alpha and Bravo are AutoDifference or more players apart for AutoSeconds, a
; dead player of the bigger team goes to the smaller one (the bots first with AutoBotsFirst, else the one who joined
; it last; admins only with AutoAdmins = 1); AutoText ({player}, {team}) tells everybody. A move that another
; script refuses (the [Balance] of ZitroStats may) is not announced, only logged: with that balance on, leave
; AutoBalance = 0 - two balances work on the same numbers and may overshoot.
Balance = auto
AutoBalance = 0
AutoDifference = 2
AutoSeconds = 20
AutoBotsFirst = 1
AutoAdmins = 0
AutoText = {player} was moved to {team} to balance the teams.

[Info]
; /info: Line1 .. Line20 = text|$colour (the colour after the last |; "|$colour" alone is an empty
; line). Tokens: {server} {version} {address} {port} {style} {prevmap} {map} {nextmap} {ff} {realistic}
; {survival} {advance} {timelimit} {timeleft}. Soldat prints its own /info too unless HideSoldatInfo = 1.
Enabled = 1
Commands = info
Address =
GameStyle =
HideSoldatInfo = 1
PadTo = 135
Line1 = |$FF9999
Line2 = Server name: {server}, Version: {version}, Address: {address}, Port: {port}|$FF9900
Line3 = Game style: {style}, Previous map: {prevmap}, Current map: {map}, Nextmap: {nextmap}|$FF9900
Line4 = Friendly Fire: {ff}, Realistic: {realistic}, Survival: {survival}, Advance: {advance}, Time limit: {timelimit}, Time left: {timeleft}|$FF9900
Line5 = Contact - Mail: <your e-mail>, Discord: <your Discord name>, Web: https://forums.soldat.pl/ to soldat-game|$FF00FF
Line6 = Commands list: !cmd, Rules list: !rules, Statistics and account commands list: !reginfo|$FF9999
Line7 = Download full mappack: https://forums.soldat.pl/index.php?topic=45549.0|$FF9999
Line8 = |$FF9999

[Tips]
; Every Seconds one of the Message-N lines to everybody (add as many as you like). It is drawn by its
; weight Chance-Message-N (default 1; 0 = never, 3 = three times as often as 1), never the same one
; twice in a row; Seconds-Message-N keeps a message back for that long after it came, and
; Color-Message-N gives it its own colour (the others have Color).
Enabled = 1
Seconds = 153
Color = $FF00FF
Message-1 = Try !cmd or !commands to see the complete commands list.
Message-2 = Try !reginfo to see the complete list of stats and account related commands.
Message-3 = Try !visits to see the server visit list.
Message-4 = Try !lastvisitors to see the 10 people who recently visited the server.
Message-5 = Try !j to join to game or !s to join to spectators.
Message-6 = Try !rate or !rate <player ID|part name|full name> to see your K/D ratio or selected player ratio.
Message-7 = Try !time to see time on the server.
Message-8 = Try !whois to see who is connected administrators or administrators in the game.
Message-9 = Try !admin to try to summon the administrator.
Message-10 = Try !ping or !ping <player ID|part name|full name> to see your ping or selected player ping.
Message-11 = Try !track or !track <player ID|part name|full name> to see your or selected player, average and max ping.
Message-12 = Try !rules to show list rules on this server.
Message-13 = Try !locate or !locate <player ID|part name|full name> to check your or the selected player location.
Message-14 = Try !locateall to check the location of all players on the server.
Message-15 = Try ?nextmap or ?lastmap or !map to see what is nextmap, lastmap and current map.
Message-16 = Try !nextmap or !lastmap to start voting to change map to nextmap or lastmap.
Message-17 = Try !map <map name | part map name> to start voting to change map to indicated.
Message-18 = Try !maps to view the full server maplist.
Message-19 = Try !allmaps to view all the maps available on the server in the currently game style.
Message-20 = When voting for the map change, you can type !v !vote or press the F12 button.
Message-21 = Hello on my server! Type /info command to learn something about the server and commands.
Message-22 = When you write an accusation of fraud in the message, you will receive information on where to report it.
Message-23 = You can also use locate commands silently using /locate /locate <player ID|part name|full name> /locateall.
Message-24 = Command /votemap <map name>, works in mode searches similar to "!map <map name | part map name>".
Message-25 = Command !map <map name | part map name> has alternatives !votemap <map name> and /votemap <map name>.
Message-26 = Command !lastmap has alternatives !votelast and !votelastmap.
Message-27 = Type !top to view the top 15 players on the server.
Message-28 = You knew the !top command, can be used with a parameter example !top <player name | part name | player id>.
Message-29 = You knew the !top command, can be used with a parameter example !top <ranking position number>.
Message-30 = Using command !topme to display the top of the 15 players with the roster centered on you.
Message-31 = Command !topid <player id> you can use when in ranking is player with the same name as the id of searched player.
Message-32 = Check your stats, use !stats command to see your basic stats.
Message-33 = You can also use the !stats command on other players, type !stats <player ID|part name|full name>.
Message-34 = Check your others stats, use !otherstats command to see your other stats.
Message-35 = You can also use the !otherstats command on other players, type !otherstats <player ID|part name|full name>.
Message-36 = Check !contact or !zitro to view contact details and stats script version.
Message-37 = Enter !reginfo to see accounts and statistics commands.
Message-38 = Enable or disable display of the hud overlay showing ranking, points, and action system, try it !hud.
Message-39 = Write !rank to display your ranking position.
Message-40 = Write !rank <player ID|part name|full name> to display selected player ranking position.
Message-41 = To quickly see who is in the position, type !ranknum <number>.
Message-42 = Type !mapstats to check the popularity, ranking and statistics of the current map.
Message-43 = Type !mapstats <map name> to check the popularity, ranking and statistics of the selected map.
Message-44 = Take a look at the top 15 map ranking by typing !topmaps.
Message-45 = You knew the !topmaps command, can be used with a parameter example !topmaps <map name>.
Message-46 = You knew the !topmaps command, can be used with a parameter example !topmaps <map ranking position number>.
Message-47 = You want a high number of points, take care of your protection days. Check quantity typing !status.
Message-48 = The !status command will allow you to check the registration date, last visit and protect days count.
Message-49 = The command !status can be used on players, example !status <player ID|part name|full name>.
Message-50 = Check how many you have points protection days type !status.
Message-51 = Randomize the game map using !randommap. This command will start voting for random map.
Message-52 = Type !hp to switch your health display on or off, !hp help to change its style, size and place.
Message-53 = Type !hp edit to move your health display with the movement keys (the grenade key saves, lying down cancels).
Message-54 = Type !dmg to switch the damage numbers over the players you hit.
Message-55 = Health comes back by itself after a few seconds without being hit or shot at - there are no medkits.

[Welcome]
; A line to every player every Minutes (0 = off) and/or when they join. Token {player}.
Enabled = 0
Minutes = 7
OnJoin = 0
Text = Hello {player} on my server! Try /info command to learn something about the server and commands.
Color = $0099FF

[CheatHint]
; A player who writes one of these words in the chat (a regular expression) gets Line1 .. Line20
Enabled = 1
Pattern = hax|heater|czit|eator|cheater|haxor|cziter|oszust|cheating|cheats|cheat
Line1 = Please collect evidence of cheating and report on mail or other contacts:
Line2 = Mail: <your e-mail>, Discord: <your Discord name>, Web: https://forums.soldat.pl/ to soldat-game
Color = $FF0000

; ----------------------------------------------------------------------------------------------------
;  Timers and announcements
; ----------------------------------------------------------------------------------------------------

[ServerPing]
; Average ping of the players to everybody every Minutes
Enabled = 1
Minutes = 6

[SpecIdle]
; Spectators are kicked after Minutes when at least MinPlayers are on the server (not a player [LagGuard] keeps
; in the spectators)
Enabled = 1
MinPlayers = 15
Minutes = 10
; ban after the kick (minutes, 0 = only kick)
BanMinutes = 1
IgnoreAdmins = 1

[Afk]
; A player in a team who is alive and presses no key nor moves the cursor for Minutes (1-120) is moved
; to the spectators (the time while they are dead does not count), warned WarnSeconds before; only with
; at least MinPlayers on the server. As a spectator [SpecIdle] may kick them later. Token {player}.
Enabled = 1
Minutes = 3
WarnSeconds = 30
MinPlayers = 4
IgnoreAdmins = 1
Text = {player} was moved to the spectators (away from the keyboard).

; ----------------------------------------------------------------------------------------------------
;  Extras from the owner's older scripts - all off until switched on here
; ----------------------------------------------------------------------------------------------------

[Assists]
; A player who did at least MinPercent of the victim's health in the victim's last fight (since the
; victim's respawn or last regeneration) gets an assist when somebody else kills the victim; PerPoint assists
; (0 = never) bring Points kill points. Shown to that player as a BigText. Tokens: {victim} {pct}
; {count} {need} {points}
Enabled = 0
MinPercent = 65
PerPoint = 3
Points = 1
Text = Assist on {victim} ({pct}%) - {count}/{need}
PointText = Assist on {victim} ({pct}%) - {need}/{need}, +{points} kill point!
Color = $FF3232
Layer = 36
DisplayTicks = 240
Scale = 0.07
X = 200
Y = 300

[MultiKill]
; Kills of one player no more than WindowSeconds apart make a combo; the Nth kill of it (2-10) gives
; ComboN = text|points or text|min-max points (a random number). Tokens: {player} {points} {count}
Enabled = 0
WindowSeconds = 3
Color = $CCCC00
Combo2 =
Combo3 = Triple kill! {player} +{points} kills|2-3
Combo4 = Multi kill! {player} +{points} kills|3-5
Combo5 = Multi kill x2! {player} +{points} kills|4-6
Combo6 = Serial kill! {player} +{points} kills|5-7
Combo7 = Insane kill! {player} +{points} kills|6-8
Combo8 = Godlike kill! {player} +{points} kills|7-9
Combo9 = Masta kill! {player} +{points} kills|8-10
Combo10 =

[Spree]
; Kills in a row without dying (team kills and suicides do not count, they end the spree): StepN =
; kills|text goes to everybody at that many kills; a spree of EndMin kills or more that ends gets
; EndText. Tokens: {player} {count}, and {killer} {victim} in EndText. Off here: ZitroStats
; announces the sprees on this server.
Enabled = 0
Color = $FF8800
Step1 = 5|{player} is on a killing spree! ({count} kills)
Step2 = 10|{player} is on a rampage! ({count} kills)
Step3 = 15|{player} is dominating! ({count} kills)
Step4 = 20|{player} is unstoppable! ({count} kills)
Step5 = 25|{player} is godlike! ({count} kills)
Step6 = 30|{player} is wicked sick! ({count} kills)
Step7 =
Step8 =
Step9 =
Step10 =
EndMin = 5
EndText = {killer} ended the killing spree of {victim} ({count} kills)

[FirstBlood]
; The first kill of a map: a line to everybody, and Points kill points for the killer
Enabled = 0
Points = 10
Text = FIRST BLOOD: {killer} killed {victim}
PointsText = {points} points awarded!
Color = $00FF00

[Savior]
; A player who kills an enemy that hit their team mate within WindowSeconds saved that mate: Points kill
; points. Team modes only. Tokens: {player} (the savior) {saved} {points}
Enabled = 0
WindowSeconds = 2
Points = 1
Text = Savior ({saved}) +{points} kill!
SavedText = You were rescued by {player}.
Color = $66CC33

[SelfKill]
; A suicide (not a kill by the server itself) costs Points kill points, shown to everybody as a
; BigText. Tokens: {player} {points}
Enabled = 0
Points = 1
Text = Player {player} loses {points} point for suicide!
Color = $CC3300
Layer = 37
DisplayTicks = 240
Scale = 0.095
X = 64
Y = 375

[Posthumous]
; A dying player drops a live grenade where they die, with a chance of one in ChanceFactor minus their
; kills (at least one in one); its kills are theirs. GroundOnly = 1: only when they stood on the ground.
; Power is the damage factor of the bullet, BulletStyle 2 = a grenade.
Enabled = 0
ChanceFactor = 20
GroundOnly = 0
Power = 100
BulletStyle = 2
Text = You threw away a grenade just before your death.
NoText =
Color = $F8F35A

[TimeToKill]
; When exactly AlivePlayers are alive, a countdown of Seconds starts (a BigText to everybody); at 0
; they all die - it ends a survival round that would never end. Token {seconds}
; MinPlayers: the countdown starts only when at least that many players are in the game (in a team,
; alive or dead; not spectators) - so a duel (two players) is not ended after Seconds.
Enabled = 0
AlivePlayers = 2
MinPlayers = 3
Seconds = 30
Text = End in: {seconds}
Color = $00FF33
Layer = 38
Scale = 0.055
X = 380
Y = 10

[Medic]
; Mode = class: one player of a team takes the job with !medic; each second they heal the hurt team
; mates within Distance pixels by HealPerSecond and get a kill point for every PointEvery health they
; gave (0 = none). Mode = call: a hurt player (or one next to a hurt team mate) calls the medic with
; !medic; the medic heals themselves and the team mates nearby while anybody there is hurt, then the team
; waits CooldownSeconds.
; With [Classes] on and a class that heals, the classes are the medics: this section steps aside.
Enabled = 0
Mode = class
Commands = medic|med|medi|nurse
Distance = 65
HealPerSecond = 8
PointEvery = 100
CooldownSeconds = 30
Color = $9F17F0

[Reservation]
; The last Slots slots are kept for the players of Slot-1, Slot-2 ... (a Steam id in any form or an IP
; at the start, the rest of the value is a comment; with AdminsToo also the Steam admins of [Admin]).
; Somebody else who takes one of them is kicked with Text - once Steam has confirmed them or up to 8
; seconds after the join. Names and computer ids can be faked, so they do not count. Token {slots}
Enabled = 0
Slots = 2
AdminsToo = 1
Text = The server is full: the last {slots} slots are reserved.
; Slot-1 = S123456789 // a name

[Logger]
; A log file a day in Folder (yyyy-mm-dd.txt, relative to the server folder), written by the
; library's thread: joins and leaves, team changes and Steam logins (Joins), chat (Chat), the players'
; commands (Commands; the arguments of HideArgs - passwords - are never written), the server console and
; TCP admins
; (Admins), map changes (Maps), kills (Kills). The players of Watch-1, Watch-2 ... (a Steam id, an IP
; or a name) also get their own file in Folder/watched.
Enabled = 0
Folder = logs/basic-extended/
Joins = 1
Chat = 1
Commands = 1
; HideArgs: the commands whose arguments the log leaves out (the passwords of this script and of
; ZitroStats, e-mail codes too; the words without ! or /; a team chat line ^!login ... is cut the same way. The text
; of a private message (the words of [PrivateMessages]) is left out as well while its Log = 0)
HideArgs = adminlog|password|pass|register|login|changepass|resetpass|removemypass|forgotpass|yes|zs_setpass|setemail|verifyemail|account
Admins = 1
Maps = 1
Kills = 0
; Watch-1 = S123456789 // a name

[FlashNades]
; Flash grenades (the owner's FlashNades script). Every life brings Nades grenades and Flashes flash
; grenades; a player chooses what his next grenade is (SwitchKey or the commands below) and the grenade
; he throws becomes that one (the hook in the server's CreateBullet reports every throw at once). While
; this is on, the server's Max_Grenades is 1: a soldier carries one grenade, and the script gives the
; next one right after it was thrown (with the game's grenade kit sound), as long as he has any left; the
; server's own value comes back when it is switched off. A flash is a grenade the script takes out of
; the server just before it goes off (Defuse): the server has no blast - no damage, no push - while the
; players' games still show the explosion, and everybody who sees it (no wall between it and his eyes -
; the middle of his head as the server's skeleton has it: standing, crouching, lying or rolling) within
; Radius gets a white screen for MinTicks to MaxTicks (the nearer, the longer), which fades out by
; itself. !flashhelp explains it with the keys and commands set here.
Enabled = 0
; Grenades and flashes of a life (0-20; also the most a player can have)
Nades = 2
Flashes = 1
; A grenade kit gives this many more (up to Nades and Flashes); a player touching a kit within
; KitRadius pixels gets it when he misses something (the game lets him take one only with no grenade).
; [Kits] GrenadeKits = 1 removes the kits from the maps.
KitNades = 2
KitFlashes = 1
KitRadius = 20
; The type chosen after a respawn: nade or flash
DefaultType = nade
; 1 = after the last one of the type chosen the other type is chosen by itself
AutoSwitch = 1
; A bot's grenade is a flash this often (0-1) while it has flashes left (a bot chooses no type)
BotFlashChance = 0.3
; Keys that switch the type, all at once (a new press): key names joined by + (crouch, prone, reload,
; fire, jet, grenade, changeweapon, throw, flagthrow, up) or none. crouch+changeweapon also changes the
; weapon (as in the old script); flagthrow alone is a free key when nobody carries a flag.
SwitchKey = crouch+changeweapon
; Commands (with ! or /): SwitchCommands the other type, NadeCommands a normal grenade, FlashCommands a
; flash - typed again it is a normal grenade again (flash on/off), HelpCommands the help. The shortest
; flash command and SwitchKey are the {switch} of the texts below. /smoke and /tabac are the game's own
; taunts (Alt+1 and Alt+2 by default): the soldier still smokes or chews. With [Classes] on, the words of its
; SkillCommands and Skill2Commands are the skills' (cc1, smoke, cc2, tabac by default) - in a game mode where
; the classes are idle they switch the grenade type as before.
SwitchCommands = set|change
NadeCommands = nade|n|cc1|smoke
FlashCommands = flash|fla|f|cc2|tabac
HelpCommands = flashhelp
; Whom a flash blinds: all (everybody, its thrower too), enemies (not the team mates, not the thrower)
; or enemiesself (the enemies and the thrower)
Affects = all
; Radius in pixels (14 = a metre, measured to his eyes); the white screen lasts MinTicks to MaxTicks (60 =
; a second): MaxTicks next to the flash, MinTicks at Radius. Falloff (1-8): 1 = it gets shorter evenly
; with the distance, higher = it stays near MaxTicks further out and drops only towards the edge (3: at
; half the Radius still 7/8 of the way to MaxTicks). The last 1.3 s of the time the white fades; a time
; under 1.3 s (far away) starts already fading - shorter and softer.
Radius = 260
Falloff = 3
MinTicks = 60
MaxTicks = 240
; Turned away from the flash (the cursor on the other side): this share of the time (1 = no difference)
BehindShare = 1
; The white screen: Method 1 = a BigText over the screen (BigLayer, BigScale, BigX, BigY; a very wide
; screen may keep an edge), 2 = a WorldText around the player that covers any screen (WorldLayer,
; WorldScale, WorldOffsetX, WorldOffsetY from his position). Char is the giant letter, Color its colour
; ($AARRGGBB takes a transparency too).
Method = 2
Char = +
Color = $F1F1F1
BigLayer = 250
BigScale = 60
BigX = -5000
BigY = -6420
WorldLayer = 250
WorldScale = 1280
WorldOffsetX = -82304
WorldOffsetY = -136832
; 1 = a flash is taken out of the server (the bullet memory bridge) when its fuse ends or a tick before
; it would touch a soldier: the server has no blast, so it neither hurts nor pushes anybody, and the
; flash does its work from the script. A bot's grenade thrown at point blank goes off before the script
; sees it: then the damage below replaces the grenade's and NoPush holds the players. 0 = every flash
; explodes in the server too (the damage below replaces the grenade's, NoPush holds the players).
Defuse = 1
; A flash's own damage: at most MaxDamage, only within DamageRadius pixels (85 = the grenade's own blast),
; less further out, nothing through a wall; 0 = none
MaxDamage = 0
DamageRadius = 85
; 1 = the players within NoPushRadius pixels of a flash are held where they stood for NoPushTicks and
; then get their speed back: a human's own game shows the explosion and pushes him (a taken out flash
; does not push bots). He may see a short jump back.
NoPush = 1
NoPushTicks = 3
NoPushRadius = 110
; A bot a flash blinds (bots never see texts): 0 = nothing, 1 = it stands still for most of that time,
; 2 = it staggers about (a few steps this way and that, a crouch, a jump) and does not shoot
BlindBots = 1
; Marks of the grenades in the air (LabelFlash, LabelNade; empty = none): one character is drawn with
; its ink centred on the grenade's picture, MarkScale big (O = a ring around it: 8.5 x 7 pixels at 0.06,
; 10 x 8 at 0.07); the game draws the grenade about 2 pixels above its position, so the mark's centre is
; MarkOffsetX, MarkOffsetY pixels from that position. A longer word stands over the grenade (LabelScale,
; LabelOffsetY). Seen by LabelsSeenBy: all, team (the thrower and his team) or owner (only the thrower);
; with LabelLineOfSight = 1 an enemy sees it in the realistic mode only when he could see the grenade.
; Moved every LabelTicks (1 = smoothest, more packets) on WorldText layers LabelLayerFirst ... +
; LabelLayers - 1. The thrower's game has his grenade about his ping earlier than the server: his own
; mark goes that far ahead while it flies. Each game moves its grenades itself, so after bounces a
; grenade may lie a pixel or two away from the server's (and its mark).
Labels = 1
LabelsSeenBy = team
LabelLineOfSight = 1
LabelFlash = O
LabelNade =
LabelFlashColor = $CDCDCD
LabelNadeColor = $CC0000
MarkScale = 0.06
MarkOffsetX = 0
MarkOffsetY = -2
LabelScale = 0.038
LabelOffsetY = 7
LabelTicks = 1
LabelLayerFirst = 80
LabelLayers = 8
; The type and the grenades left on the screen (a BigText). Tokens: {type} {nades} {flashes}.
; HudPlace = ammo: right over the player's ammunition text, where and as big as he has it (!ammohud), or
; over his health text when the ammunition has no text of its own; fixed = at HudX, HudY, HudScale.
Hud = 1
HudPlace = ammo
HudText = Grenade: {type} | Nades: {nades} | Flash: {flashes}
TypeNade = Nade
TypeFlash = Flash
HudLayer = 195
HudX = 20
HudY = 412
HudScale = 0.02
HudColor = $D9D5D1
; The colour of !flashhelp and of the answers
TextColor = $ADC600
; Told to a player who joins (empty = nothing), and JoinBigText shown big for JoinBigSeconds (0 or an
; empty text = not; empty here - JoinText says it in the chat, e.g. JoinBigText = Flash grenade:
; {switch}). Tokens: {switch} (how the type is switched: SwitchKey or the shortest flash command),
; {nades} {flashes} (a life's)
JoinText = Flash grenades here: {switch} switches between a grenade and a flash. More: !flashhelp
JoinBigText =
JoinBigSeconds = 2.5
JoinLayer = 194
JoinScale = 0.09
JoinX = 55
JoinY = 295

[ExtraRocket]
; Guided rockets (the owner's ExtraRocket script), Javelin style: a player holding a loaded Weapon (the
; LAW) on the ground keeps Keys down; the sight looks for an enemy he can see within Range, near his
; cursor (Target = radius), and once it has one it locks on him in LockSeconds - the cursor is free then,
; letting go of the keys ends it. The rocket leaves the tube slowly, its motor starts and it flies after
; him: the library (basicext_dll) flies it like a guided missile - thrust against a drag, fins that turn
; it at most Agility sideways (slow it turns tight, fast it turns wide), proportional navigation that
; leads a running target, a look-ahead that finds walls and throttles back to turn round them; with room
; above it climbs over the target and dives on him. At the target (or another enemy on its way) it
; bursts: a column of real LAW rockets along the line from the launch - the kill list shows the LAW,
; and "You killed" the distance and time from the launch - and, with BlastSparks, the old script's rings
; of stationary gun bullets. The one it locks on is warned (LockWarning). Each player has Rockets of
; them for a life (Refill = life) or a map (Refill = map); a team change brings them back. !rocket explains
; it with these settings.
Enabled = 0
; The rocket's name in the texts ({name})
Name = Javelin
Rockets = 1
Refill = life
; Keys held at once (names as [FlashNades] SwitchKey); lying counts as crouch (crouch would get a lying
; soldier up). Without fire the LAW does not fire its own round (reload does nothing to a loaded LAW);
; with fire in them and Launcher = free the weapon is given anew while the sight locks, so its own
; start-up begins again.
Keys = crouch+reload
; 1 = only on the ground (as the LAW itself)
Ground = 1
; The weapon in the hands (a name or number: law, 13)
Weapon = law
; reload = the weapon has to be loaded; the rocket leaves from it, it is empty and reloads, and its round
; comes back at the reload (with [Ammo] the reserve stays); round = the same, but the round goes into the
; rocket (the reload takes one from the reserve); free = the weapon is not touched
Launcher = reload
; Where the sight looks: radius = the enemy nearest to the cursor within CursorRadius pixels of it,
; cursor = the one nearest to the line of the cursor within CursorAngle degrees, nearest = the nearest
; one; in sight and within Range. SeekSight = 1: while it looks (radius) the shooter sees the seeker's
; brackets around his cursor, SeekWidth pixels wide (0 = as wide as the circle, 2 x CursorRadius), in
; SeekColor
Target = radius
Range = 700
CursorRadius = 150
CursorAngle = 70
SeekSight = 1
SeekWidth = 200
SeekColor = $D8D8D8
; Blinded by a flash ([FlashNades]) a player cannot lock until BlindLockSeconds before his white screen
; ends (it fades then); a lock that runs ends
BlindLockSeconds = 0.25
; The lock: the keys stay down this long while brackets close on the target (seen by the shooter,
; WorldText layer LockLayer, LockScale big, LockColor) and LockSound beeps quicker and quicker; the
; target lost from sight, out of range or dead ends it. 0 = the rocket leaves at once.
LockSeconds = 0.4
LockScale = 0.16
LockLayer = 90
LockColor = $FF3030
; The flight (pixels, a tick = 1/60 s; the game's gravity is 0.06): out of the tube at EjectSpeed, the
; motor starts after EjectSeconds; Thrust speeds it up to about MaxSpeed; Agility = the most sideways push
; of its fins (the turn rate is Agility / speed); a turn costs TurnDrag of that push in speed; Gravity
; pulls it down (the motor holds it while it burns); Lead = how far ahead of a running target it aims
; (0 = straight at him, 3 = proportional navigation); FuelSeconds of motor, then it glides GlideSeconds
; (weaker fins, falling) and bursts.
EjectSpeed = 4
EjectSeconds = 0.15
MaxSpeed = 16
Thrust = 0.9
Agility = 1.1
TurnDrag = 0.35
Gravity = 0.06
Lead = 3
FuelSeconds = 3
GlideSeconds = 1
; Profile: direct = straight at him, top = over him and down when there is room, auto = top when he is at
; least 220 pixels away (and not well above), else direct. TopHeight = the highest it climbs over the
; higher of the two (less under a ceiling).
Profile = auto
TopHeight = 220
; 1 = it looks LookAheadSeconds of flight ahead: a wall there makes it turn to the freer side and
; throttle back by up to Brake (0-1) to turn tighter - too fast, it still hits the wall
AvoidWalls = 1
LookAheadSeconds = 0.2
Brake = 0.6
; The rocket reaches the target within HitRadius pixels of its path; any other enemy it passes within
; ProximityFuse pixels makes it burst too (0 = only the target). HitPercent = the share of his health
; he loses before the burst (never the last point; 0 = only the burst - the final LAW rocket kills)
HitRadius = 25
ProximityFuse = 18
HitPercent = 0
; The power of the burst (1 = the LAW's own damage from weapons.ini), the stationary gun sparks on or
; off
BlastPower = 1
BlastSparks = 1
; The trail while the motor burns: a harmless flame every TrailSpacing pixels of the way (0 = none),
; drifting with TrailSpeed of the rocket's speed
TrailSpacing = 22
TrailSpeed = 0.25
; The next rocket of a player not sooner than CooldownSeconds; at most MaxFlying rockets in the air (1-16)
CooldownSeconds = 1
MaxFlying = 6
; The sounds - the sight waking up (law-start), the launch (m79-fire), the motor starting (law) and
; running (rocketz) - heard within SoundRange pixels
Sound = 1
SoundRange = 900
; The lock tones, each switched on or off by itself: ShooterBeep = 1 - the shooter hears LockSound while
; the sight closes on his target; TargetBeep = 1 - the one it locks on hears WarnSound (with
; LockWarning = 1). Both beep quicker and quicker as the lock closes, the target's fast while the rocket
; flies at him. Any sound of the game's sfx folder (signal.wav, regenerate.wav, shell.wav, shell2.wav,
; menuclick.wav, ...)
ShooterBeep = 1
LockSound = signal.wav
TargetBeep = 1
WarnSound = signal.wav
; 1 = bots fire them too (only when their keys happen to match; for tests)
Bots = 0
Commands = rocket|rockets
; Next to the ammunition while the weapon is in the hands (with [Ammo] HudAppend = 2 in its own text,
; else after the ammunition or the health): HudText with rockets left, HudEmptyText with none (empty =
; nothing). Tokens below.
HudText = ({left}/{max} {name})
HudEmptyText = (Empty {name})
; LockWarning = 1: the one a Javelin locks on sees the sight closing on himself (WorldText layer
; LockLayer + 1), LockWarnText over his head (layer WarnLayer, WarnScale big, WarnColor) and hears
; WarnSound (TargetBeep); while the rocket flies at him IncomingText blinks there
LockWarning = 1
LockWarnText = !! {name} LOCK !!
IncomingText = !! INCOMING {name} !!
WarnLayer = 92
WarnScale = 0.07
; Messages: tokens {player} (the shooter) {target} {name} {weapon} {keys} {used} {left} {max}; empty =
; nothing. WarnText goes to the target (chat).
WarnTarget = 1
WarnText = [WARNING] {player} fired a {name} at you!
FireText = [{name}] Locked on {target} - away! ({left}/{max} left)
NoTargetText = [{name}] No enemy in the sight.
BlindText = [{name}] You cannot see!
LostText = [{name}] Lock lost.
EmptyText = [{name}] None left! (0/{max})
NotLoadedText = [{name}] The weapon is not loaded.
Color = $33CC33
WarnColor = $FF0000
; A line to everybody every HintMinutes (0 = never)
HintMinutes = 5
HintText = Guided {name}: hold the {weapon} and press {keys} - see !rocket

[TeamKill]
; The team kill guard (the owner's old tk script, grown up). Every hit on a team mate and every team kill
; gives points by how meant it looked: the library follows the line of every shot (the hook in the
; server's CreateBullet, [Debug] ServerHooks = 1) against the soldiers' skeletons - a shot at a mate with
; no enemy near its line is aimed at him, with an enemy near or behind him it is crossfire, a blast with
; enemies next to the mate is an accident, a knife is always meant. The points climb a ladder (a warning,
; the fire at the team blocked and turned back on the shooter, a slay, a kick, bans that grow) and melt
; away with time; the record follows the player by his Steam id. A spray - several shots aimed at the
; same mate in a moment, no enemy near - blocks his fire at the team at once, before anybody dies. The
; victim decides about the kill (!1 forgive, !2 kill him, !3 points, !4 next round in survival). !tk shows
; a player his record, /tk <player>, /tklist and /tkreset are for the admins; every event goes to Log (in
; the data folder).
Enabled = 0
; Game modes it works in (dm pm tm ctf rm inf htf); it also needs the server's friendly fire on (nobody
; can hurt his team without it). RealisticOnly = 1: only in realistic mode.
Modes = tm|ctf|inf|htf
RealisticOnly = 0
; 1 = bots are counted and punished too (normally they are left alone; never banned, only kicked)
Bots = 0
; --- the points ---
; A whole health of damage to the team gives DamagePoints, a team kill KillPoints, a spray SprayPoints -
; each times how meant it looked (aimed at the mate 90-100%, crossfire and a mate who ran into the fire
; 20%, a blast near enemies 10%, a blast with no enemy near 60%, a knife 100%)
DamagePoints = 1
KillPoints = 1
SprayPoints = 1
; A team kill within SpawnSeconds of the mate's respawn counts SpawnFactor times, of a flag carrier
; FlagFactor times; killing back the one who team killed you within RevengeSeconds counts RevengeFactor
; times (0 = free)
SpawnSeconds = 5
SpawnFactor = 1.5
FlagFactor = 2
RevengeSeconds = 10
RevengeFactor = 0
; One point melts away every DecayMinutes (0 = never), starting DecayAfterSeconds after his last points;
; DecayOffline = 1: between his visits too (by the clock - a ban melts points as well), 0: only while he
; is on the server. KeepPoints = 1: the points, bans and team kills follow the player by his Steam id
; (players.bdb); ResetOnMapChange = 1: every map starts clean (the old script)
DecayMinutes = 10
DecayAfterSeconds = 10
DecayOffline = 1
KeepPoints = 1
ResetOnMapChange = 0
; --- the ladder: a step is taken when his points reach it (0 = the step is off) ---
; WarnAt: a warning; ShieldAt: his shots at the team are blocked (below); SlayAt: slain (dead in
; survival: after his next respawn); KickAt: kicked; BanAt: banned
WarnAt = 0.5
ShieldAt = 1.5
SlayAt = 2.5
KickAt = 4
BanAt = 5
; The block: his hits on the team do ShieldShare of their damage (0 = nothing) and MirrorShare of it hits
; him instead - for ShieldSeconds after a spray or a step, and all the time his points are at ShieldAt
ShieldSeconds = 90
ShieldShare = 0
MirrorShare = 1
; A ban lasts BanMinutes, twice as long every next time with BanDouble = 1, at most BanMaxMinutes. Every
; BanForgetDays days without a ban the count of his bans goes one down (0 = never), so the next ban is
; shorter again (/tkreset <player> bans clears it at once)
BanMinutes = 15
BanDouble = 1
BanMaxMinutes = 1440
BanForgetDays = 7
; --- the shots ---
; A spray: SprayShots shots aimed at the same mate within SpraySeconds, at least SprayShare of all his
; shots then, none of them crossfire
Spray = 1
SprayShots = 5
SpraySeconds = 1.5
SprayShare = 0.6
; A shot that passes within LineRadius pixels of a soldier's body goes at him; an enemy within
; EnemyRadius pixels of its line makes it crossfire; a blast with an enemy within BlastEnemyRadius pixels
; of the blast is an accident (judged from the mate, with the blast's own reach added: the grenade's 85 px,
; the M79's and the LAW's 64 px, a cluster burst's 35 px)
LineRadius = 10
EnemyRadius = 45
; How far (pixels) a shot is followed, and how long (seconds) the shots of one burst are remembered when
; the aim is judged (a shot at an enemy further than Range through a mate counts as aimed at the mate)
Range = 900
HitSeconds = 1.5
BlastEnemyRadius = 150
; --- the victim decides (the old script's menu), within VoteSeconds ---
; forgive = the kill's points (and his damage to you in that life) go away; punish = he is slain now
; (dead in survival: after his next respawn) and gets PunishPoints; points = only PunishPoints; next round
; (survival) = slain after his next respawn and PunishPoints. !tk 1-4 works too (the old /tk 1-4).
Vote = 1
VoteSeconds = 20
PunishPoints = 0.5
; A team kill that looks less meant than VoteMinIntent percent (a mate who ran into the fire or crossfire
; 20%, a blast near enemies 10%; aimed 90-100%) can only be forgiven (!1), not punished (0 = every team
; kill may be punished, the old behaviour). While his fire at the team is blocked, a hit that looks less
; meant than MirrorMinIntent percent is blocked but not mirrored back on him, so a mate who steps into
; the line of fire cannot make him hurt himself (0 = every hit is mirrored, the old behaviour)
VoteMinIntent = 50
MirrorMinIntent = 50
ForgiveCommands = 1|forgive
PunishCommands = 2|punish
PointsCommands = 3
NextRoundCommands = 4|nextround
; !tk: a player's own record (admins: /tk <player>); /tklist: everybody with points; /tkreset <player|all>
; [bans]: the points (and the bans) go
Commands = tk|banpoints
ListCommands = tklist
ResetCommands = tkreset
; --- the texts; tokens: {player} (the one it is about) {victim} {killer} {points} {max} (BanAt) {why}
; {shots} {seconds} {minutes}; empty = nothing. The big ones on BigText layer BigLayer for BigSeconds ---
Color = $FF6060
InfoColor = $FFB0B0
BigLayer = 191
BigScale = 0.09
BigX = 60
BigY = 240
BigSeconds = 4
HitText = Watch your fire - {victim} is on your team! ({points} team kill points)
WarnText = Team kill points: {points} of {max}. Hurting your team leads to a ban.
ShieldText = Your shots at the team are blocked for {seconds} s - and hurt you instead.
ShieldTeamText = {player} hurts his team: his shots at the team are blocked now.
SprayText = Stop shooting at {victim}! ({shots} shots at him) Your fire at the team is blocked.
SprayVictimText = {player} was shooting at you - his fire at the team is blocked.
KillText = You killed your team mate {victim} ({why}): {points} team kill points of {max}.
VictimText = Team killed by {killer} ({why}). Within {seconds} s: !1 forgive, !2 kill him, !3 points only
VictimNextText = , !4 kill him next round
VictimAccidentText = Team killed by {killer} ({why}). It looks like an accident: !1 forgives him.
SlayText = You were slain for team killing ({points} points).
NextRoundText = You will be slain after your next respawn for team killing.
KickText = {player} was kicked for team killing ({points} points).
BanText = {player} was banned for {minutes} minutes for team killing ({points} points).
; The events (team kills, sprays, steps, decisions) with the reasons, a line each (empty = none)
Log = teamkill.log

[Mines]
; Landmines and claymores (the owner's old Mines script, grown up). Enemy kills and captures earn them; a
; player plants one with keys or a command. A landmine lies hidden from the enemies and goes off under
; the first enemy who steps on it (jumping or jetting over it is safe); a claymore is seen by everybody,
; looks where its owner looked, and when an enemy walks into its tripwire it throws a cone of shells
; that way (a little all around it too). An enemy who crouches or lies near a landmine finds it and can
; take it apart; an enemy bullet sets a claymore off; the owner picks his own back up. The library looks
; after them every tick against the soldiers' skeletons as the server has them (the memory bridge); the
; marks are WorldTexts. !mines shows a player what he has; /minelist, /mineclear, /givemines are for the
; admins.
Enabled = 0
; Game modes it works in (dm pm tm ctf rm inf htf)
Modes = dm|pm|tm|ctf|rm|inf|htf
; The two kinds, each on its own
Landmines = 1
Claymores = 1
; 1 = bots earn them too and plant them at random moments (BotChance a second, on the ground)
Bots = 1
BotChance = 0.15
; --- earning ---
; Every KillsPerMine enemy kills give a landmine, every KillsPerClaymore a claymore (0 = none for kills).
; KillStreak = 1: only the kills of one life count (a death starts again); MineKills = 1: kills by mines
; and claymores count too
KillsPerMine = 3
KillsPerClaymore = 5
KillStreak = 0
MineKills = 0
; A capture gives CaptureMines and CaptureClaymores; every life starts with SpawnMines and SpawnClaymores
; at least
CaptureMines = 1
CaptureClaymores = 1
SpawnMines = 0
SpawnClaymores = 0
; The most a player carries; KeepOnMapChange = 1: what he carries and his kills stay for the next map
MaxMines = 2
MaxClaymores = 2
KeepOnMapChange = 0
; KeepOnDeath = 1: what he carries stays with him over his lives. 0 = a death empties it: the [Shop]'s LoseOnDeath takes
; the mines only the shop sells (ShopOnly) first, then the rest goes - onto his body when [Looting] Items names mines or
; claymores (a looter takes them there, up to MaxMines and MaxClaymores; what nobody takes is gone with the body), nowhere
; otherwise. His planted ones stay in the ground. A survival round's end is no death: a survivor keeps what he carries into
; the next round, and the dead start it with SpawnMines and SpawnClaymores.
KeepOnDeath = 1
; --- planting ---
; Keys: names joined by + (crouch prone reload fire jet grenade changeweapon throw flagthrow up; none =
; only the commands). flagthrow is the game's throw of the flag: jump and crouch together (or the
; player's own throw flag key), which without a flag does nothing; a quick tap does not jump. The
; claymore's keys are tried first: by default lying down plants a claymore, standing or crouching a
; landmine (the other kind when he has none of that one)
MineKeys = flagthrow
ClaymoreKeys = prone+flagthrow
MineCommands = mine
ClaymoreCommands = claymore|clay
InfoCommands = mines
ListCommands = minelist
ClearCommands = mineclear
GiveCommands = givemines
; Only on the ground, FlagDistance px from his team's flag base and SpawnDistance px from the enemies'
; spawn points (with a wall between they do not count), Spacing px from any other mine, one every
; PlantSeconds
FlagDistance = 130
SpawnDistance = 110
Spacing = 30
PlantSeconds = 1
; The most in the ground at a time: a player's landmines, a player's claymores, the map's (both kinds)
MaxPlanted = 2
MaxPlantedClaymores = 2
MaxOnMap = 20
; Armed ArmSeconds after planting; gone after LifeSeconds (0 = until the map ends): ExpireBlast = 1 it
; goes off then (the old script), 0 it goes quietly. A player's mines go when he leaves or changes team.
ArmSeconds = 2
LifeSeconds = 0
ExpireBlast = 0
; --- the landmine ---
; An enemy's leg or body within TriggerRadius px of it sideways and at most TriggerHeight px above it
; sets it off (a soldier jumping over it passes, one crawling over it not); it goes off FuseSeconds
; later (0 = at once) with ClickSound heard near it
TriggerRadius = 16
TriggerHeight = 8
FuseSeconds = 0
ClickSound =
; The blast: Blasts M79 explosions in the ground spread over BlastSpread px (each kills within about 10
; px and hurts up to 64), and Shrapnel shells up in a cone of ShrapnelAngle degrees each side at
; ShrapnelSpeed (a Spas-12 shell flies 14), each ShrapnelPower times a Spas-12 shell
Blasts = 2
BlastSpread = 12
Shrapnel = 6
ShrapnelAngle = 35
ShrapnelSpeed = 12
ShrapnelPower = 0.7
; --- the claymore ---
; Fuse = wire: a tripwire along the ground ahead of it, WireHeight px high, WireLength px long (a wall
; ends it) - an enemy's leg or lying body on it sets it off, jumping over it is safe; Fuse = cone: any
; enemy in its front cone (ConeAngle degrees each side, ConeRange px) with nothing between. Anybody
; hostile within TouchRadius px sets it off from any side.
Fuse = wire
WireLength = 110
WireHeight = 5
ConeAngle = 30
ConeRange = 140
TouchRadius = 14
; The blast: Pellets shells in a cone of Spread degrees each side of where its owner looked (tilted at
; most MaxTilt degrees from level) at PelletSpeed, each PelletPower times a Spas-12 shell (1.5: a soldier
; at the end of the wire loses more than his health); around and behind it BackPellets weaker shells
; (BackSpeed, BackPower); Blast M79 explosions at it (they kill within about 10 px and hurt up to 64; only
; where the ground stops bullets - a floor only the players stand on lets them through) and Flames
; flames that hurt nobody fanned out in its cone, the flash of the blast; BlastSound is heard up to 900 px
; away
Pellets = 20
Spread = 20
MaxTilt = 30
PelletSpeed = 16
PelletPower = 1.5
BackPellets = 8
BackSpeed = 7
BackPower = 0.4
Blast = 1
Flames = 8
BlastSound = grenade-explosion
; --- both ---
; Another mine within ChainRadius px (0 = never) goes off ChainSeconds after one
ChainRadius = 70
ChainSeconds = 0.15
; A dead soldier's body that falls or slides onto a landmine, onto a claymore or across its tripwire
; sets it off (a claymore's cone looks for the living only): Corpses = enemies (the bodies of the ones
; who would set it off alive), all (anybody's, the owner's team too) or off. A body lying there already
; when the mine was armed does not. The bodies are their skeletons (the memory bridge)
Corpses = enemies
; An enemy's bullet (the hook in the server's CreateBullet, [Debug] ServerHooks = 1) passing within
; HitRadius px of a claymore sets it off (ShootMines: a landmine too) when it gets there: the bullet is
; followed as the game flies it (it falls and slows down; a wall stops it); ShooterKills = 1: its kills
; are the shooter's, 0: its owner's
ShootClaymores = 1
ShootMines = 0
HitRadius = 7
ShooterKills = 1
; --- finding and taking apart ---
; An enemy crouching or lying within SpotRadius px of a landmine, with his eyes on it, finds it: he sees
; its mark from then on, with SpotShare = 1 his team too (0 = never found). Crouching or lying within
; DefuseRadius px of a mine he sees (not on it!) for DefuseSeconds takes it apart (0 = never);
; DefuseTake = 1: it is his then. The owner picks his own up the same way in PickupSeconds (0 = never).
SpotRadius = 70
SpotShare = 1
DefuseRadius = 40
DefuseSeconds = 2
DefuseTake = 1
PickupSeconds = 1.5
; --- who sees them (the marks) ---
; MineSeenBy, ClaymoreSeenBy: owner, team (his team too) or all (the enemies too). EnemySight: how such an
; enemy sees it - sight = only with nothing between his eyes and it (not through walls), realistic = so in
; realistic mode only (through walls elsewhere), always = through walls too. An enemy who found one sees it
; anyway; Spectators = 1: the spectators see them all
MineSeenBy = team
ClaymoreSeenBy = all
EnemySight = sight
Spectators = 1
; MineMark stands on a landmine, ClaymoreRight / ClaymoreLeft on a claymore looking right / left,
; WireMark repeated along its wire; PreviewMark: the dots its owner sees for PreviewSeconds after planting
; it - PreviewDots along each edge of its cone (PreviewRange px) and PreviewArc on its far arc,
; PreviewScale big. Colours ($RRGGBB, or $AARRGGBB with AA up to 7F): the owner's, his team's, the
; enemies', not armed yet, the wire, the preview
MineMark = o
ClaymoreRight = |)
ClaymoreLeft = (|
WireMark = -
PreviewMark = .
MarkScale = 0.06
WireScale = 0.05
OwnColor = $FFFF60
TeamColor = $60FF60
EnemyColor = $FF4040
ArmingColor = $A0A0A0
WireColor = $70FF3030
PreviewColor = $FFFF60
PreviewSeconds = 2.5
PreviewRange = 200
PreviewDots = 6
PreviewArc = 3
PreviewScale = 0.07
; The WorldText layers: MarkLayers from MarkLayerFirst for the marks (each player gets the nearest ones),
; PreviewDots * 2 + PreviewArc from PreviewLayerFirst for the preview, WorkLayer for the words of the work on
; a mine, PlantLayer for the words of a mine he planted
MarkLayerFirst = 133
MarkLayers = 16
PreviewLayerFirst = 185
WorkLayer = 149
PlantLayer = 248
; --- the texts; tokens: {kind} {Kind} {player} (the other one) {mines} {claymores} (what he carries)
; {nextmine} {nextclaymore} (kills still needed) {planted} {keys} {command} {seconds} {pct} {why};
; empty = nothing. The line of what he carries: HudPlace = ammo (over the ammunition, like the flash
; grenades' line) or fixed (HudX, HudY, HudScale); the short ones on BigText layer BigLayer. The short
; words over a mine (WorkScale, WorkY px over it; the last one WorkSeconds): PlantText (while it is armed)
; and ArmedText for its owner, DefusingText, PickingText, DefusedText and PickedText for the one who works
; on it. KillText goes to the owner's console, VictimText (what killed him) to the middle of the
; victim's screen ---
MineName = mine
ClaymoreName = claymore
Color = $FFC860
Hud = 1
HudMineText = Mines {mines}
HudClaymoreText = Claymores {claymores}
HudPlace = ammo
HudX = 20
HudY = 400
HudScale = 0.07
HudLayer = 193
HudColor = $FFD080
BigLayer = 192
BigScale = 0.08
BigX = 60
BigY = 260
BigSeconds = 3
WorkScale = 0.04
WorkY = 28
WorkSeconds = 2.5
PlantSound = kit-fall
ArmSound = signal
DefuseSound = takegun
EarnText = +1 {kind} ({why}) - {keys} or !{command} plants it.
PlantText = Armed in {seconds}s
ArmedText = Armed
SpottedText = You found an enemy {kind}! Stay low next to it for {seconds} s to take it apart.
DefusingText = Defusing {pct}%
PickingText = Picking {pct}%
DefusedText = Defused{why}
OwnerDefusedText = {player} took your {kind} apart.
PickedText = Picked up
KillText = Your {kind} got {player}.
VictimText = Killed by {player}'s {kind}
ShotText = {player} shot your {kind} - it went off.
ExpireText = Your {kind} ran out.
; The events (planted, set off, found, taken apart), a line each in the data folder (empty = none)
Log =

[Bleeding]
; Wounds and blood. A hit may open a wound: the chance grows with the damage (CritChance at CritDamage percent
; of ReferenceHealth, less for smaller hits) and with the place it hit - the head, the torso or the legs,
; found on the soldier's skeleton the way the server finds it (HeadFactor, TorsoFactor, LegsFactor); a blade
; cuts deeper (MeleeFactor), a blast opens up to BlastWounds shrapnel wounds, fire and fists open none. A
; light wound (a graze) stops by itself (after a random time up to GrazeSeconds with GrazeRandom = 1), a heavy
; one bleeds until it is bandaged, an arterial one (ArterialShare of the wounds, more at the neck and the
; thigh) bleeds fast; the rates are percent of the blood a second. The blood (100 at spawn) runs out at the
; sum of the open wounds and comes back by BloodRegen a second BloodRegenDelay seconds after the last wound
; closed. Below WeakBlood the health drains (Drain percent of the maximum health a second at DeathBlood, less
; above it) and, with RegenBlock = 1, [Regeneration] waits while a wound bleeds and brings the health back
; only up to the blood's share; below ShockBlood every ShockCheckSeconds a shock may come (ShockChance percent
; at DeathBlood, a quarter of it just below ShockBlood; the next check ShockCheckSeconds after a shock ended):
; ShockSeconds frozen with a black screen (in the air he falls), his shots taken out; at DeathBlood he bleeds
; out: BleedOut = drain - while a wound bleeds his health drains faster and faster (OutDrain percent of the
; maximum health a second more than Drain, OutDrainGrow more for every point of blood under DeathBlood; OutText
; in the middle of his screen), so a bandage or a kit still saves him; instant - at once. Down with [Downed],
; else dead, the kill the one's who opened his worst wound, with that weapon. A soldier who is down or in shock
; fires nothing (the server's bullets of his are taken out; ZitroStats still counts each of them as a shot, so
; his accuracy of those seconds is lower).
Enabled = 0
; Game modes it works in (dm pm tm ctf rm inf htf)
Modes = dm|pm|tm|ctf|rm|inf|htf
; Bots bleed too (they bandage themselves BotBandageSeconds after their last wound; a downed bot uses its own
; first-aid kit that long after it went down, with [Downed] SelfRevive)
Bots = 1
CritChance = 60
CritDamage = 25
; ReferenceHealth: the health CritDamage is a percent of (65: a hit opens a wound as often in the normal
; mode as in the realistic one; 0 = the maximum health of the mode)
ReferenceHealth = 65
HeadFactor = 1.3
TorsoFactor = 1
LegsFactor = 1.2
MeleeFactor = 2
ArterialShare = 6
HeavyShare = 25
GrazeRate = 0.5
HeavyRate = 1.5
ArterialRate = 4
; How long a wound bleeds before it stops by itself (0 = until it is bandaged); GrazeRandom = 1: each light
; wound stops after its own random time between GrazeMinSeconds and GrazeSeconds
GrazeSeconds = 25
GrazeRandom = 1
GrazeMinSeconds = 8
HeavySeconds = 0
ArterialSeconds = 0
BlastWounds = 3
; At most this many open wounds of each kind (light, heavy, arterial; 0 = no limit): a hit that would open one
; more of a full kind opens none
MaxGrazes = 1
MaxHeavy = 1
MaxArterial = 1
WeakBlood = 75
ShockBlood = 55
DeathBlood = 40
Drain = 1.5
BleedOut = drain
OutDrain = 5
OutDrainGrow = 1
ShockCheckSeconds = 5
ShockChance = 35
ShockSeconds = 3
BloodRegen = 0.25
BloodRegenDelay = 10
RegenBlock = 1
; --- bandages and first-aid kits ---
; Staying still (and low with BandageLow = 1: crouching or lying) with an open wound bandages it - by itself
; after AutoDelay seconds with AutoBandage = 1, or at once after !bandage (a player can bind /bandage to a key
; in his game's console: bind "b" "/bandage"). It takes GrazeBandageSeconds, HeavyBandageSeconds or
; ArterialBandageSeconds by the worst wound his bandage can cover and uses GrazeBandageUse, HeavyBandageUse or
; ArterialBandageUse percent of his bandage (Bandage percent at spawn); moving (faster than StillSpeed px a
; tick) or shooting stops it. AirBandage = 1: falling freely with no key of a move held (left, right, jump,
; jets) counts as low and still. A medic (the class perk firstaid of [Classes]) with no wound of his own to
; bandage bandages his wounded mates near him with his own bandage (TreatText to the mate when he begins,
; TreatedText to him and TreatedMateText to the mate when it is done; {medic}, {mate}). VestTorso = 1: a
; bulletproof vest keeps the torso from bleeding (a hit there opens no wound while he wears one; the head and
; the legs still bleed, a blast's shrapnel in the torso too). A first-aid kit (Kits a life, !kit) closes every wound in KitSeconds of standing
; still (KitLow = 1: low too) and gives KitBlood percent of the blood and KitHealth percent of the health back
; (and gets a downed soldier up with [Downed] SelfRevive). A medic of [Medic], a healing polygon and a health
; kit on the map close the light wounds and give blood; a health kit closes every wound.
Bandage = 130
GrazeBandageSeconds = 0.5
HeavyBandageSeconds = 1.2
ArterialBandageSeconds = 2.0
GrazeBandageUse = 10
HeavyBandageUse = 25
ArterialBandageUse = 40
BandageLow = 1
AutoBandage = 1
AutoDelay = 0.25
StillSpeed = 1.0
AirBandage = 1
Kits = 1
KitSeconds = 5
KitBlood = 25
KitHealth = 30
KitLow = 0
VestTorso = 1
BotBandageSeconds = 10
BandageCommands = bandage|band
KitCommands = kit|firstaid|medkit
; --- the screen ---
; The shock's black screen: the flash grenades' white screen in ShockColor (a WorldText of ShockChar at
; ShockScale over the map where he is, on ShockLayer); ShockScreen = 0: none
ShockScreen = 1
ShockChar = +
ShockColor = $000000
ShockScale = 1280
ShockOffsetX = -82304
ShockOffsetY = -136832
ShockLayer = 251
; The line of his blood (Hud = 1): HudShow = auto (while a wound bleeds or the blood is not full) or always;
; tokens {blood}, {wound} (HudWound while a wound bleeds: {list} = every place that bleeds with its worst
; wound - HudWoundPart: {place} {kind} {count}, {many} = HudWoundMany when the place has more than one),
; {rate} (the blood he loses a second), {bandage}, {kits}; HudPlace = ammo (over the ammunition, above the
; flash grenades' and the mines' lines) or fixed (HudX, HudY, HudScale); HudColor, HudBleedColor while a
; wound bleeds
Hud = 1
HudShow = auto
HudText = Blood {blood}%{wound} | Bandage {bandage}% | Kits {kits}
HudWound = | Bleeding: {list}
HudWoundPart = {place} {kind}{many}
HudWoundMany = x{count}
HudPlace = ammo
HudX = 20
HudY = 372
HudScale = 0.02
HudLayer = 200
HudColor = $FFB0B0
HudBleedColor = $FF3030
; The words over him while he works (WorldText on WorkLayer, WorkScale, WorkY px over him), the messages in
; the middle of the screen on BigLayer ([Mines] BigX, BigY, BigScale, BigSeconds). Tokens: {player} {kind}
; {Kind} {place} {bandage} {kits} {use} {pct} {blood} {kit}, {medic} and {mate} (the medic's texts); empty =
; nothing
WorkLayer = 247
WorkScale = 0.04
WorkY = 26
BigLayer = 201
Color = $FF7070
GrazeName = light
HeavyName = heavy
ArterialName = arterial
HeadName = head
TorsoName = torso
LegsName = leg
BlastName = shrapnel
WoundText =
ClosedText = The {kind} bleeding stopped.
BandagedText = Bandaged ({kind}): -{use}% bandage, {bandage}% left.
NoBandageText = Too little bandage for that wound ({bandage}% left) - a first-aid kit helps: !{kit}
KitText = First-aid kit used: the bleeding stopped.
NoKitText = You have no first-aid kit.
NothingText = Nothing to bandage.
ShockText =
BandagingText = Bandaging {pct}%
KitUseText = First aid {pct}%
BledText =
OutText = BLEEDING OUT - stay low to bandage, or !{kit}
TreatText = {medic} is bandaging your {kind} wound - stay near.
TreatedText = You bandaged {mate} ({kind}): {bandage}% bandage left.
TreatedMateText = {medic} bandaged your {kind} wound.
WoundSound =
BandageSound = takemedikit

[Downed]
; Wounded instead of dead (made for survival): a hit that would kill puts him down with DownedHealth percent
; of the maximum health for DownSeconds - unless it is a headshot (HeadKills = 1), more than Overkill percent
; of the maximum health above his health (a LAW, an M79 at his feet; 0 = never), or he was down MaxDowns
; times this life already (0 = no limit). Down he cannot move (Movement = hold; crawl: CrawlSpeed px a tick),
; his weapons are taken (Weapons = none, given back as they were; keep: his shots are taken out anyway) and
; he fires nothing. Any further hit finishes him (FinishCredit = finisher: the kill is the finisher's; downer:
; the one's who put him down). A team mate staying low (ReviveLow) within ReviveRadius px for ReviveSeconds
; gets him up with ReviveHealth percent and stops his bleeding (his time waits meanwhile; a bot mate next to
; him does it with BotsRevive), and he is safe for ProtectSeconds; his own first-aid kit ([Bleeding] Kits)
; gets him up when he crouches (SelfRevive). !giveup (bind "g" "/giveup") ends it at once. When nobody of his team who could help
; is left (LastStand = 1; without teams: one other soldier or none), his time ends at once - survival rounds
; end as the game expects. Every end is a kill of the one who put him down, with his weapon. KeepBleeding = 1:
; his wounds ([Bleeding]) bleed on while he is down (the blood running out ends his time).
Enabled = 0
Modes = dm|pm|tm|ctf|rm|inf|htf
SurvivalOnly = 1
Bots = 1
DownedHealth = 5
DownSeconds = 20
HeadKills = 1
Overkill = 150
MaxDowns = 1
Movement = hold
CrawlSpeed = 0.5
Weapons = none
FinishCredit = finisher
ReviveRadius = 30
ReviveSeconds = 4
ReviveLow = 1
ReviveHealth = 30
ProtectSeconds = 1
SelfRevive = 1
BotsRevive = 1
LastStand = 1
KeepBleeding = 1
; His team mates are told (TellTeam) and see Mark over him ({seconds} left, WorldText on MarkLayers layers
; from MarkLayerFirst); he sees DownText in the middle of his screen (BigLayer), the one helping him HelpText
; over him (TextScale, TextY). Tokens: {player} {seconds} {pct} {giveup} {kit}
TellTeam = 1
Mark = + {seconds}
MarkColor = $FF4040
MarkScale = 0.06
MarkLayerFirst = 64
MarkLayers = 8
BigLayer = 202
TextScale = 0.04
TextY = 26
Color = $FF9040
DownText = DOWN {seconds}s - a team mate staying low next to you gets you up{kit}. !{giveup} to give up
HelpText = Helping {pct}%
HelpedText = {player} is getting you up {pct}%
UpText = {player} got you up!
UpMateText = You got {player} up.
TeamText = {player} is down - get him up (stay low next to him)!
EndText =
NotDownText = You are not down.
GiveUpCommands = giveup

[Spotting]
; Battlefield-like marking of enemies: a player aims at an enemy he sees and spots him - the enemy nearest to
; his cursor within CursorRadius px, in his sight and within Range px; his team then has the enemy on its
; radar for SpotSeconds (Radar = 1: the radars the players have - [Radar] Public and PublicShow decide who
; has one and whom it shows; with seen/seenreal the spotted enemy shows even out of sight) and, with World = 1,
; Mark over the enemy's head in the game. /spot or !spot (bind "f" "/spot" in the game's console), or Keys:
; with Keys = reload a press of reload the game ignores (a full magazine, standing) spots. AutoSeconds > 0:
; aiming at a visible enemy that long spots him by itself. One spot every CooldownSeconds. Bots spot now and
; then (Bots = 1, BotChance a second).
Enabled = 0
Modes = tm|ctf|inf|htf
Radar = 1
World = 0
SpotSeconds = 6
Range = 900
CursorRadius = 120
Keys = reload
AutoSeconds = 0
CooldownSeconds = 2
Bots = 0
BotChance = 0.1
; Told: the spotter (SpotText), his team (TellTeam, TeamText), the spotted one (TellTarget, TargetText in the
; middle of his screen on BigLayer). Tokens: {player} {target}
TellTeam = 1
TellTarget = 0
Mark = v
MarkColor = $FF3030
MarkScale = 0.07
MarkLayerFirst = 48
MarkLayers = 8
BigLayer = 204
Color = $FFC040
Sound =
SpotText = Spotted: {target}
TeamText = {player} spotted {target}
TargetText = You have been spotted!
NoTargetText = No enemy in sight near your aim.
Commands = spot

[Bounty]
; A price on the head of the one who kills a lot: StartKills enemy kills in one life put Base points on his
; head, PerKill more for each kill after that (at most Max, 0 = no limit). Everybody is told (Announce = big,
; console, both or none); his enemies see him on the radar (Radar = 1) and, with World = 1, Mark over him. The
; enemy who kills him collects it: the points (RewardPoints), RewardHealth percent of the health, RewardVest
; percent of a vest, a fresh set of magazines for his weapon (RewardAmmo), RewardMines, RewardClaymores,
; RewardFlashes, RewardJavelins, RewardBandage percent of bandage and RewardKits kits (of the modules that are
; on). A selfkill, a team kill or leaving ends it; ExpireSeconds with no kill ends it (0 = never). He survives
; a survival round with it: SurvivalBonus points, and it stays. !bounty lists them.
Enabled = 0
Modes = dm|pm|tm|ctf|rm|inf|htf
Bots = 1
StartKills = 5
Base = 1
PerKill = 1
Max = 10
ExpireSeconds = 0
Radar = 1
World = 0
RewardPoints = 1
RewardHealth = 100
RewardVest = 0
RewardAmmo = 1
RewardMines = 1
RewardClaymores = 0
RewardFlashes = 1
RewardJavelins = 0
RewardBandage = 100
RewardKits = 1
SurvivalBonus = 2
Announce = both
BigLayer = 203
Color = $FFD700
Mark = $
MarkColor = $FFD700
MarkScale = 0.07
; Tokens: {player} (the target) {killer} {bounty} {kills} {why} {bonus}
StartText = BOUNTY: {player} - {bounty} points for his head!
RaiseText = The bounty on {player} is {bounty} points now ({kills} kills).
ClaimText = {killer} collected the bounty on {player}: {bounty} points!
LostText = The bounty on {player} is gone ({why}).
TargetText = There is a price on your head: {bounty} points. The enemies see you on the radar.
SurviveText = {player} survived the round with a bounty: +{bonus} points.
NoneText = No bounties now.
InfoText = {player}: {bounty} points ({kills} kills)
Commands = bounty|bounties

[SpawnProtection]
; For Seconds after a respawn a soldier takes no damage from the others (the server's own blows - the end
; of a survival round, an admin's kill - still go through). It ends at once when he fires or throws a
; grenade (EndOnShoot = 1) or moves more than EndDistance px from where he spawned (0 = only the time).
; NoDamageDealt = 1: his own bullets do nothing while he is protected. Everybody sees Mark over his head
; ({seconds} left; WorldText on MarkLayers layers from MarkLayerFirst, MarkScale, MarkY px over his feet),
; he sees SelfText in the middle of his screen (BigLayer; the mines' place and size). Survival = 0: not in
; survival rounds (everybody spawns at once there). Bots = 1: the bots too.
Enabled = 0
Modes = dm|pm|tm|ctf|rm|inf|htf
Seconds = 2
EndOnShoot = 1
EndDistance = 0
NoDamageDealt = 1
Survival = 0
Bots = 1
Mark = ({seconds})
MarkColor = $80C0FF
MarkScale = 0.06
MarkY = 34
MarkLayerFirst = 56
MarkLayers = 8
SelfText = Spawn protection: {seconds}s
BigLayer = 205
Color = $80C0FF

[Spawns]
; Respawns-Control built in (4.1): a map may have a layout of player spawn points of its own - its points of the
; styles it has (0 no team, 1 Alpha, 2 Bravo, 3 Charlie, 4 Delta) replace the map's own points of those styles;
; flags and kits stay. Every layout is kept in one file, data/basic-extended/spawns.bdb (written whole by basicext_dll a moment
; after a change; the file before it stays as spawns.bdb.bak). From the moment the next map is announced nobody
; takes damage (NoDamageWhileChanging = 1) until the players stand on its layout: MoveDelayTicks after the map is
; in (a client still loading it would put its player back) every player of a replaced style is moved to a point
; of the layout, each to one of his own while there are enough - a move, not a respawn (no team change, nobody
; dies in survival). A map change that never comes ends the damage block after ChangeTimeoutTicks.
; Admin commands (a change lasts until the map changes, unless it is saved):
;   /displayspawns           marks over the MarkLayers points nearest to you (to your cursor while you are dead
;                            or spectating): + and the point number in its team's colour (WorldText layers from
;                            MarkLayerFirst, MarkScale big); again: hidden
;   /createspawn [0-4]       a player spawn point where you stand (style 0 when left out)
;   /removenearspawn         the nearest player spawn point within NearPixels goes
;   /removeallspawn          every player spawn point of the map goes
;   /editnearspawn           the nearest point (within NearPixels) follows your movement keys a pixel a step,
;                            and you with it; reload or the command again ends it
;   /testrespawn [id|next]   a respawn onto the nearest point, point <id> or the next one (survival: a move)
;   /countspawns             the map's points by team, and whether it has a layout
;   /saveallspawns           the map's player points become its layout
;   /checkspawns             every point against the map's walls ([MapGeometry] reads them): in a wall, no
;                            floor within FloorPixels under it, closer than MinGapPixels to a point of its team
;   /spawnlayouts [part]     the maps that have a layout, with their points
;   /deletespawnlayout [map] the layout of a map (this one when left out) goes: its own points from its next load
;   /exportspawns            every layout into data/basic-extended/exported/ as the old script's file (four lines a point)
; The server console may use the ones that need no place: /countspawns, /saveallspawns, /removeallspawn,
; /checkspawns, /spawnlayouts, /deletespawnlayout, /exportspawns.
; The old Respawns-Control (a folder of scripts/ whose config.ini says Name = Respawn_Controls) is taken over 30
; seconds after the start when ImportOldScript = 1 (setting it to 0 and /reloadsettings cancel a takeover that
; still waits): its layouts go into data/basic-extended/spawns.bdb (a map that has a
; layout here keeps it), and its folder leaves the scripts in the moment they are compiled again -
; OldScriptAction = move: whole (its .git too) to data/basic-extended/imported/<folder>-<date>; delete: the folder
; is first renamed out of the scripts and then its files are deleted (a link inside it goes, never what it points
; to). The scripts
; are compiled again through the server's admin port (AutoRecompile = 1; it needs Admin_Password in soldat.ini,
; which goes only to the library's own thread and is never written anywhere); without it the admins are asked
; for a /recompile and the folder goes as theirs comes in (/recompile <name> keeps the old script, and its
; folder). Until then the old script keeps working with its files and this module waits. With
; ImportOldScript = 0 an installed Respawns-Control keeps the work and this module stays idle (two scripts
; adding points would double them).
Enabled = 1
MoveDelayTicks = 30
ChangeTimeoutTicks = 900
NoDamageWhileChanging = 1
NearPixels = 50
MarkLayerFirst = 20
MarkLayers = 24
MarkScale = 0.08
FloorPixels = 120
MinGapPixels = 8
ImportOldScript = 1
OldScriptAction = move
AutoRecompile = 1
ShowCommands = displayspawns
CreateCommands = createspawn
RemoveCommands = removenearspawn
ClearCommands = removeallspawn
EditCommands = editnearspawn
TestCommands = testrespawn
CountCommands = countspawns
SaveCommands = saveallspawns
CheckCommands = checkspawns
ListCommands = spawnlayouts
DeleteCommands = deletespawnlayout
ExportCommands = exportspawns

[PrivateMessages]
; /pm <player id or name> <text> (/msg): a private message - the receiver sees FromText, the sender ToText
; (tokens {player} {text}); /r <text> answers the last one who wrote to you. /pmmute stops every private
; message to you, /pmmute <player> only his; /pmunmute [player] takes it back - the blocks follow the
; player by his Steam id (or computer id), not his slot, until the server restarts. A muted player cannot
; write private messages (MutedCanWrite = 0). One message every CooldownSeconds, at most MaxLength
; letters. AdminsSee = 1: the admins in the game see every private message (AdminText, tokens {from} {to}
; {text}); Log = 1: into the [Logger] day file (0: the text of a /pm and /r is left out of the log too). Typed
; with / only (a ! line is seen by everybody).
Enabled = 0
CooldownSeconds = 1
MaxLength = 85
MutedCanWrite = 0
AdminsSee = 0
Log = 0
ToText = [PM to {player}] {text}
FromText = [PM from {player}] {text}
AdminText = [PM {from} -> {to}] {text}
Color = $FFC0FF
AdminColor = $A080A0
Commands = pm|msg
ReplyCommands = r|reply
MuteCommands = pmmute|pmblock
UnmuteCommands = pmunmute|pmunblock

[Notes]
; /note <text>: a note for the admins, kept in File in the data folder (the time, the name, the Steam id,
; the computer id, the IP, the map, the text), written by the library's thread. /report <player> <text>:
; a note about another player with his ids (Reports = 1). The admins in the game are told at once
; (TellAdmins), an admin who joins hears how many are unread. One note every CooldownSeconds, at most
; PerDay a day for a player (0 = no limit), MaxLength letters. Admins: /comments (the unread ones, newest
; first, ShowLines of them), /comments all, /comments read <n>, /comments del <n> (hidden; the file keeps
; it), /comments clear (all hidden) - StateFile keeps what was read and hidden. /noteban <player> puts his
; IP, computer id and Steam id on the notes blacklist (BlacklistFile; one entry a line: "ip <value>",
; "hw <value>", "steam <value>", a comment after //), /notebanlist, /noteunban <number|player|value>.
; Typed with / only (a ! line is seen by everybody). Token {number}.
Enabled = 0
Reports = 1
TellAdmins = 1
CooldownSeconds = 30
PerDay = 5
MaxLength = 85
ShowLines = 8
File = notes.txt
StateFile = notes_state.txt
BlacklistFile = notes_blacklist.txt
SavedText = Your note for the admins is saved (#{number}).
BlockedText = You cannot leave notes on this server.
Color = $FFE080
Commands = note
ReportCommands = report
ReadCommands = comments|notes
BanCommands = noteban
UnbanCommands = noteunban
BanListCommands = notebanlist

[AdminChat]
; Coloured lines of the admins: /col [colour] <text> to everybody (/admcol, /admincolor), /colteam <team>
; [colour] <text>, /colp <player> [colour] <text>; /announce [colour] <text> also in the middle of every
; screen (BigText on BigLayer for BigSeconds, BigScale, BigX, BigY). A colour is #RRGGBB, $RRGGBB,
; 0xRRGGBB, RRGGBB or a name of Colors ("name $RRGGBB|..."); without one DefaultColor. Format: the line
; (tokens {text} {admin} - the admin's name, "Server" from the console).
Enabled = 1
Format = {text}
DefaultColor = $FFD700
Colors = red $FF0000|green $00FF00|blue $4080FF|yellow $FFFF00|orange $FFA500|white $FFFFFF|cyan $00FFFF|pink $FF80C0|purple $C080FF|gray $A0A0A0|gold $FFD700|lime $A0FF40
BigLayer = 207
BigSeconds = 5
BigScale = 0.11
BigX = 40
BigY = 300
Commands = col|admcol|admincolor
TeamCommands = colteam
PlayerCommands = colp
AnnounceCommands = announce|ann

[AntiSpam]
; Chat flood control. Every chat line (and command with CountCommands = 1) adds to the player's points:
; 1, plus BurstWeight within BurstSeconds of his last line, RepeatWeight for the same line again (one of
; his last three, letter case, spaces and repeated letters left out), LongWeight over LongLength letters,
; CapsWeight with CapsPercent capitals, OneCharWeight for "aaaaaaaa"; the points melt by DecayPerSecond.
; Normal talk - different lines at a talking pace - stays near 0; the same line three times in a row
; quickly, or five times at a few seconds' pace, is a mute. WarnAt: a warning (WarnText); MuteAt:
; muted for MuteSeconds, every next mute within MemoryMinutes twice as long (at most MaxMuteSeconds).
; The mute is the server's own (by the IP: his lines go to nobody, he cannot call a vote); the script lifts
; it when its time is over - also after he left and came back (the server mutes an IP again at the join
; by itself; the script's file of mutes, File in the data folder, knows the end time). A mute nobody of
; this script made (the server's /gmute) is left alone. The server bans a player for 5 minutes by itself
; after about 6 lines in a few seconds ("Chat Flood"), and for a line over 100 letters - the script is
; meant to speak up before that. Admins: /tmute <player> [time: 30s, 10m, 2h, 1d] [reason] (AdminMuteMinutes
; without a time), /tunmute <player>, /mutelist (/mute and /unmute are the game's own commands on the
; players' side). IgnoreAdmins = 1: the admins are not counted. Tokens: {player} {seconds} {reason}
Enabled = 0
IgnoreAdmins = 1
CountCommands = 1
BurstSeconds = 1.5
BurstWeight = 1.5
RepeatWeight = 2
LongLength = 80
LongWeight = 0.5
CapsPercent = 75
CapsWeight = 1
OneCharWeight = 1
DecayPerSecond = 0.5
WarnAt = 4
MuteAt = 8
MuteSeconds = 60
MaxMuteSeconds = 1800
MemoryMinutes = 60
AdminMuteMinutes = 10
TellAll = 1
File = mutes.txt
WarnText = Slow down - more of this and you are muted.
MutedText = You are muted for {seconds} s ({reason}).
UnmutedText = You can talk again.
AllText = {player} is muted for {seconds} s ({reason}).
Color = $FFA060
MuteCommands = tmute|mutet
UnmuteCommands = tunmute|unmutet
ListCommands = mutelist|mutes

[Pause]
; !p (!pause, /pause) pauses the game, !up (!unpause, /unpause) ends it after a countdown of
; CountdownSeconds (BigText to everybody: CountText, then GoText). The script answers /pause and
; /unpause itself (the server's own have no countdown). Admins always may; Players = 1: everybody may
; pause (PausesPerMap a map each, with at least MinPlayers on the server); PlayersUnpause = paused (only
; the one who paused, or an admin), all, admins. A player's pause ends by itself after MaxSeconds (0 =
; never; an admin's pause waits for /unpause). The one who paused may stop only the countdown he started
; himself with !up: that is a new pause of his (it counts for PausesPerMap, and the time of his pause goes
; on). MinPlayers counts the players, not the bots. Not during a map change (a pause then loses the change).
; Tokens: {player} {seconds}
Enabled = 0
Players = 0
PlayersUnpause = paused
PausesPerMap = 1
MinPlayers = 2
MaxSeconds = 120
CountdownSeconds = 3
PauseText = {player} paused the game - !up (or /unpause) to go on.
ResumeText = {player} ends the pause: the game goes on in {seconds} s.
PausedText = PAUSED
CountText = {seconds}
GoText = GO!
Color = $FFFF80
BigLayer = 206
BigScale = 0.2
BigX = 270
BigY = 160
PauseCommands = p|pause
UnpauseCommands = up|unpause

[BanJournal]
; The server keeps no date of a ban, and its /unbanlast knows only the very last one. Every CheckSeconds
; the script looks at the server's ban lists and writes each new ban - whoever made it: an admin, this
; script, the server's flood guard, another script - into File in the data folder with the time.
; /unbanlast <n> lifts the last n bans still in force, /unbanlast <time> (30m, 2h, 1d, 1w) every ban made
; within that time; /unbanlast alone is the server's own. /banlist [n]: the last bans with their time and
; reason (and whether they still hold). The server writes banned.txt and bannedhw.txt only when it bans or
; kicks; the script writes them too after /unbanlast, /unbanname and its own /banipr and /banhwr, or a restart
; would bring back what it lifted.
Enabled = 1
File = bans.log
CheckSeconds = 5
UnbanCommands = unbanlast
ListCommands = banlist|bans
; Names = 1: a new ban gets the name of the player it hit - the one this script's ban named, a player in the game
; with that address or computer id, or one who left within NameSeconds (the server's own bans kick first); /banlist
; shows it with the time left, /unbanname <a part of the name> lifts every ban in force of that player (several
; players match: the list - type more).
Names = 1
NameSeconds = 60
UnbanNameCommands = unbanname

[SteamBan]
; Bans of Steam accounts (an address changes, a computer id can be faked, a Steam account cannot). /bansteam <time>
; <player | Steam id> <reason> - time: 30m, 2h, 7d, 1mon, 1y or perm ([Admin] MaxBanMinutes for the admins in the
; game; the console may ban for good); /unbansteam <Steam id | the number of /steambans | a part of the name>;
; /steambans [n]: the newest first, with the time left. The list is File in the data folder, one ban a line:
;   S123456789 <until | perm> <admin> // <name>: <reason>
; (until: the seconds since 2000 the script writes; lines may be removed by hand, /reloadsettings reads it again).
; A player whose Steam account Steam confirms on the list is told why (Text: {left}, {reason}) and banned by the
; server for the time left, at most EvasionIpMinutes (his address soon belongs to somebody else - the list stays and
; catches him again). BanAlsoSteam = 1: /banr and the bans of [TeamKill] put his Steam account on the list too.
; Players without Steam are not covered (the bans of the address and the computer id are).
Enabled = 1
File = steambans.txt
BanAlsoSteam = 1
EvasionIpMinutes = 1440
Text = Your Steam account is banned on this server ({left}): {reason}
Commands = bansteam|steamban
UnbanCommands = unbansteam
ListCommands = steambans

[MapCommands]
; /maplistadd <part of a name> [position]: a map of the maps folder ([MapGeometry] MapFolder) into the
; server's list and mapslist.txt (at the end, or at that position; "again" adds a map that is there
; already); /maplistremove <part | number in !maplist>; /mapfind <part>: the maps of the folder that
; match (* = in the list). A part finds the exact name first, then a name that starts with it, then a word
; of a name (after _ or -), then any part; several equal matches are listed. MapByPart = 1: /map with a
; part of a name changes to that map (the server's own /map wants the whole name and is used when it is
; given).
Enabled = 1
MapByPart = 1
Color = $00BFFF
AddCommands = maplistadd|addmapp
RemoveCommands = maplistremove|delmapp
FindCommands = mapfind|findmap

[Warn]
; /warn <player> <reason>: a warning in the middle of his screen and in his console (Text), told to
; everybody with TellAll = 1 (AllText); KickAt warnings in one visit (leaving and coming back on the same
; map does not start again) kick him (0 = never), with a ban of BanMinutes (0 = only the kick).
; Tokens: {player} {reason} {count}
Enabled = 1
TellAll = 1
KickAt = 3
BanMinutes = 0
Text = WARNING {count}: {reason}
AllText = {player} is warned ({count}): {reason}
Color = $FF8040
BigLayer = 208
BigSeconds = 5
BigScale = 0.1
BigX = 40
BigY = 250
Commands = warn

[Shop]
; A shop and an economy (the owner's old Shop script grown up). Economy = map: the money lives for the map
; (StartMoney at the join and at every map; a player who leaves gets his money back when he returns on the
; same map); global: it follows the player by his Steam id (GlobalComputerId = 1: by his computer id too)
; in players.bdb - a new account starts with GlobalStartMoney; until Steam answers he plays on what he
; makes, then the account comes with it added (no Steam after 15 s: a wallet of the map; GlobalComputerId = 1
; waits those 15 s too before the computer id is his key). An account is in one slot at a time: a second
; connection with the same key gets it when the first one is gone. MaxMoney and GlobalMaxMoney cap the
; wallet. Bots earn and buy now and then with Bots = 1. Nothing is earned with fewer than MinHumans players.
Enabled = 0
Modes = dm|pm|tm|ctf|rm|inf|htf
Economy = map
GlobalComputerId = 0
StartMoney = 800
GlobalStartMoney = 800
MaxMoney = 16000
GlobalMaxMoney = 1000000
Bots = 1
MinHumans = 1
; --- earning (0 = nothing; a negative value takes money) ---
; A kill of an enemy: KillMoney times the weapon's factor (KillFactors: "weapon factor|...", the weapons
; socom deagles mp5 ak aug spas ruger m79 barrett minimi minigun knife chainsaw law flamer bow flamebow,
; mine = a landmine or claymore; 1 without one), a bot killed BotKillFactor of it; HeadshotMoney when the
; killing hit was the head ([Bleeding]'s hit places); AssistMoney to everybody else who did AssistPercent
; percent of a full health's damage to him; DamageMoney for every whole health of damage done to enemies;
; CaptureMoney to the capper and TeamCaptureMoney to each of his mates. Survival: SurviveMoney to
; everybody alive at the end of a round, RoundWinMoney to every player of the team that won it (the one
; alive, or the one that captured), RoundLossMoney to the others plus LossStreakMoney for every round lost
; in a row before (at most LossStreakMax), RoundStartMoney to everybody at a round's start. IncomeMoney every
; IncomeSeconds outside survival. TeamKillMoney, SelfKillMoney (a suicide, not the server's kills).
; BountyMoney per point of a [Bounty] collected. The earnings are multiplied by RealisticFactor,
; SurvivalFactor, AdvanceFactor in those modes and GlobalFactor in the global economy (it is never reset).
KillMoney = 100
KillFactors = knife 3|chainsaw 2|socom 1.5|deagles 1.2|law 0.6|m79 0.7|barrett 0.8|minigun 0.8|mine 1
BotKillFactor = 0.25
; The same enemy killed again within a minute (counted per killer and victim pair): from the third kill on
; RepeatKillPercent of the kill money (100 = all of it). BotKillFactor counts for the headshot, assist and
; damage money of a bot too.
RepeatKillPercent = 50
HeadshotMoney = 50
AssistMoney = 40
AssistPercent = 50
DamageMoney = 30
; DamageLimit: what one life can pay as DamageMoney, in percent of a full health, counted over everybody who hit
; him (150 = a health and a half: the hits on a soldier healed or revived again and again pay no more).
; 0 = no limit.
DamageLimit = 150
CaptureMoney = 300
TeamCaptureMoney = 100
SurviveMoney = 100
RoundWinMoney = 300
RoundLossMoney = 150
LossStreakMoney = 100
LossStreakMax = 3
RoundStartMoney = 0
IncomeMoney = 0
IncomeSeconds = 60
TeamKillMoney = -300
SelfKillMoney = -50
BountyMoney = 100
RealisticFactor = 1
SurvivalFactor = 1
AdvanceFactor = 1
GlobalFactor = 0.5
; The prices times RealisticPrices, SurvivalPrices, AdvancePrices in those modes
RealisticPrices = 1
SurvivalPrices = 1
AdvancePrices = 1
; --- buying ---
; !shop (the categories), !shop weapons | ammo | equipment | special | all (numbered, with the prices),
; !buy <word or number> (or /buy - bind a key in the game's console: bind "F5" "/buy ak"), !money,
; !pay <player> <amount> (Transfer = team: to a team mate; all; off; in the global economy an account's money
; goes to a player with an account only), !sell (Sell = 1: the weapon in the hands bought this life, for
; SellShare of the price he paid). Where: BuyWhere = anywhere, spawn (within BuyRadius px of a spawn point
; of his team) or base (of his flag); when: within BuySeconds of the respawn (0 =
; always), in survival within SurvivalBuySeconds of the round's start; AliveOnly = 1: alive. One purchase
; every BuyCooldownSeconds (a bound key cannot flood the server).
BuyWhere = anywhere
BuyRadius = 250
BuySeconds = 0
SurvivalBuySeconds = 20
AliveOnly = 1
BuyCooldownSeconds = 0.5
Transfer = team
Sell = 0
SellShare = 0.5
; --- the items: <price | the words to buy it | how many a life (0 = no limit)>, the price "off" = not
; sold (so is a price or a percent below 0, with a warning at the start), a percent (Magazine, Ammo) = a
; share of the price of the weapon in the hands ---
; A weapon the server's weapon list (soldat.ini Weapon_1-14) switches off is never sold, a bow only in
; Rambo, the flamer only with FlamerWeapon = 1 or [Admin] GiveFlamer = 1 (a server with sv_bonus_flamer 1
; bans a player holding a flamer). A primary goes into the primary slot, the old one becomes the secondary
; (OldPrimary = secondary; lose: it is gone); SOCOM, knife, chainsaw and LAW go into the secondary slot. A
; weapon bought comes with [Ammo]'s fresh magazines. Magazine: one spare magazine of the weapon in the
; hands within [Ammo] ExtraMagazines (in pool mode a magazine's worth of rounds); Ammo: a fresh set of
; them when the pouch holds less.
FlamerWeapon = 0
OldPrimary = secondary
SOCOM = 65 | socom usp pistol | 0
Deagles = 350 | deagle deagles eagle | 0
MP5 = 410 | mp5 hk | 0
AK74 = 470 | ak ak74 | 0
AUG = 440 | aug steyr | 0
Spas12 = 370 | spas shotgun | 0
Ruger77 = 365 | ruger | 0
M79 = 390 | m79 | 0
Barrett = 1200 | barrett barret sniper | 0
Minimi = 500 | minimi m249 | 0
Minigun = 640 | minigun mini | 0
Knife = 32 | knife | 0
Chainsaw = 56 | chainsaw saw | 0
LAW = 350 | law rocket | 0
Flamer = 600 | flamer flamethrower | 0
Bow = off | bow | 0
FlameBow = off | flamebow firebow | 0
Magazine = 20% | mag magazine | 0
Ammo = 50% | ammo | 0
; Grenade: GrenadesPerBuy grenades (with [FlashNades] on top of a life's, at most MaxGrenades; without it the
; game's grenade kit); Flash: one flash grenade ([FlashNades], at most MaxFlashes); Cluster: the game's
; cluster kit (not with [FlashNades]); Vest: VestAmount percent; Health: full, wounds closed; Bandage:
; BandageAmount percent and Kit (at most MaxKits) of [Bleeding]; Mine, Claymore ([Mines]); Javelin
; ([ExtraRocket], at most MaxJavelins - fired from a LAW).
Grenade = 120 | nade nades grenade | 0
Flash = 150 | flash | 0
Cluster = 400 | cluster clusters | 1
Vest = 400 | vest armor | 0
Health = 200 | health hp medkit | 0
Bandage = 80 | bandage band | 0
Kit = 150 | kit firstaid | 0
Mine = 300 | mine landmine | 0
Claymore = 450 | claymore clay | 0
Javelin = 600 | javelin jav | 0
GrenadesPerBuy = 1
MaxGrenades = 3
MaxFlashes = 2
VestAmount = 100
BandageAmount = 50
MaxKits = 2
MaxJavelins = 2
; Berserker, Predator: the game's bonuses (off by default); Statgun: a stationary gun next to him, on the
; ground only, for StatgunSeconds (at most StatgunMax of his at once); UAV: every enemy on his team's radar for UavSeconds
; ([Spotting]'s marks - the radar of [Radar] shows them); APRounds: his next ApRoundsPerBuy Barrett rounds
; explode where they hit a soldier or a wall: ApBlasts cluster blasts (ApPower) - the library knows the wall
; the round meets when it is fired and takes the round out there; Supply: a supply crate ([Supply]) onto
; the ground under his aim, for his team first.
Berserker = off | berserker berserk | 1
Predator = off | predator | 1
Statgun = 1200 | statgun sg | 1
UAV = 800 | uav | 1
APRounds = 500 | ap aprounds explosive | 0
Supply = 1500 | supply drop | 1
; BloodBag: BloodBagBlood percent of the blood back within BloodBagSeconds (with [Bleeding])
BloodBag = 250 | bloodbag blood transfusion | 0
StatgunSeconds = 60
StatgunMax = 1
UavSeconds = 10
ApRoundsPerBuy = 5
ApBlasts = 3
ApPower = 1
BloodBagBlood = 40
BloodBagSeconds = 3
; --- the modules ---
; ShopOnly: what the shop sells and the modules no longer give for free (mines|claymores|javelins|flashes:
; no mines or claymores for kills, captures or at the spawn, no Javelins and no flash grenades a life).
; LoseOnDeath = 1: a death takes what was bought and not used (the survivors of a survival round keep it,
; with [Ammo] SurvivalCarry their magazines too); 0 keeps only the AP rounds, the mines and claymores and
; (BuyOnly) the weapons - grenades, flashes, Javelins, the vest and the medical things are a life's whatever
; it says. BuyOnly = 1 (made for the Advance mode, works without it):
; the weapon menu holds only the weapons a player owns - bought, and the ones in his hands when he survives
; a round or (LoseOnDeath = 0) when he dies, picked up ones too - and the ones the shop gives for nothing
; (price 0); a weapon he does not own in his hands in the first 3 s of a life is taken. The Advance mode's
; own unlocks never reach the menu (the shop sends it again after every kill). The server's bots do not use
; the menu: with Bots = 1 a bot gets its best weapon of its own at every respawn or buys one; with Bots = 0
; the bots keep the server's weapons.
ShopOnly = mines|claymores|javelins|flashes
LoseOnDeath = 1
BuyOnly = 0
; --- the screen ---
; A line over the ammunition (HudPlace = ammo, above the flash grenades', the mines' and the blood's lines;
; fixed: HudX, HudY, HudScale) with HudText ({currency} {money}) and for a moment GainText ({gain} {why}).
Hud = 1
HudText = {currency}{money}
GainText = ({gain} {why})
Currency = $
HudPlace = ammo
HudX = 20
HudY = 350
HudScale = 0.02
HudLayer = 209
HudColor = $80FF80
; GainColor: the money line while a gain shows, BadColor while a loss shows and for the shop's refusals
GainColor = $C0FFC0
Color = $80FF80
BadColor = $FF8060
; the colours of the categories of !shop
WeaponsColor = $80FF80
AmmoColor = $A0D8FF
EquipmentColor = $FFE080
SpecialColor = $FFA0E0
ShopCommands = shop|store
BuyCommands = buy|b
MoneyCommands = money|cash
PayCommands = pay
SellCommands = sell
; Admins: /givemoney, /takemoney, /setmoney <player|all|team> <amount>, /wallet <player>, /moneyreset
; <player|all> (back to the start money, the global accounts too), /shoplist (the richest in the game)
GiveCommands = givemoney
TakeCommands = takemoney
SetCommands = setmoney
WalletCommands = wallet
ResetCommands = moneyreset
ListCommands = shoplist|richest

[Supply]
; Supply crates (with the shop or without it). Every EveryMinutes (plus or minus JitterMinutes, with 2 or
; more players) a crate comes down under a parachute by a random spawn point of the map, on the ground
; under it (falling for FallSeconds); with SurvivalPerRound = 1 also once in every survival round at a
; random moment. Everybody is told (AnnounceText, {where}) and sees it (Mark; FallMark while it falls;
; WorldText from MarkLayerFirst, one layer a crate, MaxCrates at once). A soldier who stays low (crouching
; or lying) within OpenRadius px for OpenSeconds opens it (OpenText over it for him, WorkLayer; a bot by
; standing there twice as long, Bots = 1), and gets one thing of Contents ("kind weight|...": ammo
; - his magazines topped up, grenades, flashes, mines, claymore, javelin, medical - health, bandage, a kit,
; vest, money - of the shop, weapon - a weapon on the ground), told in the middle of his screen (GotText,
; {what}, BigLayer). A crate lies LifeSeconds. The shop's Supply item drops one at the buyer's aim, his
; team's for TeamSeconds. Admins: /supplydrop (by a random spawn point), /supplydrop here (under the aim).
Enabled = 0
EveryMinutes = 4
JitterMinutes = 1
SurvivalPerRound = 1
FallSeconds = 3
LifeSeconds = 90
OpenSeconds = 2
OpenRadius = 30
TeamSeconds = 10
MaxCrates = 2
Bots = 1
Contents = ammo 5|grenades 3|flashes 2|mines 2|claymore 1|javelin 1|medical 3|vest 2|money 3|weapon 2
AnnounceText = A supply crate is coming down {where}!
OpenText = Opening {pct}%
GotText = Supply crate: {what}
Mark = [ SUPPLY ]
FallMark = [ SUPPLY ]
Color = $FFD040
MarkScale = 0.07
MarkY = 10
MarkLayerFirst = 72
WorkLayer = 93
BigLayer = 210
DropCommands = supplydrop

[Classes]
; Battlefield classes (the owner's Battlefield mod rebuilt): every soldier of a team plays a class - the weapons of
; his menu, what he carries at the respawn (Loadout), perks that work by themselves and two skills (!skill,
; !skill2; bind a key to them: bind "c" "/skill"). Modes: the game modes it works in (not with the Advance mode,
; which gives the weapons itself).
; Assign = choice: a player picks his class with !class <name or number> - it comes with his next respawn, at once
; within ChangeSeconds of a respawn while he has used nothing yet (no skill, no shot); who picked nothing gets one
; rolled. limited: the same choice, but a class his team has LimitedSpread players more of than the class it has
; fewest of (that he may play) is refused - so a team never plays one class only. life: a new class rolled at
; every death. round: one rolled for every survival round (a survivor whose kit [Ammo] SurvivalCarry keeps keeps
; his class; in the other modes: at the join and at every map's start). map: one rolled for the whole map, kept by
; his computer id (and his account) - leaving and coming back rolls no new one.
; The choice is told (choice, limited): ChoiceText ({list}: the classes of his side) at the join and at his first
; ChoiceTimes deaths of a map; ChooseText is {choose} of the line.
; AssignRealistic, AssignSurvival, AssignRealisticSurvival: the same for that mode (realistic survival first, then
; survival, then realistic); a key left out follows Assign.
; The roll (Balance = 1): the classes of this mode that are not full (each class's Max), of them the ones with the
; fewest players of his team, of them the one he played least on this map; his class again only when nothing else
; is possible (Repeat = 0) - so everybody gets to try every class. Balance = 0: any class that is not full.
Enabled = 0
Modes = tm|ctf|inf|htf
Assign = choice
; AssignSurvival = round
Balance = 1
Repeat = 0
ChangeSeconds = 5
LimitedSpread = 1
ChoiceText = Choose your class: !class <name> - {list} (!classes for more)
ChoiceTimes = 3
; SkillSpots: what the UAV, the sensor and the longer spots of a class (the Recon's) show the team - marks = a
; mark over every enemy they found (as [Spotting] World = 1 shows them, but for these spots only), radar = the
; radar for the team's players (its public look: what the team sees and has spotted) while the UAV or the
; sensor works. BotSkills = 1: the bots use their class's skills (once a second, by simple rules - a healthpack
; or a grenade kit for a mate in need, a patch-up when hurt, an attack skill at an enemy in sight, a UAV for a
; team with players).
SkillSpots = marks
BotSkills = 1
; The classes and their order (1, 2, ... for !class <number>), each from its section [Class-<name>] (20 at most,
; with the insurgents' classes of [Insurgents] Classes, which come after them).
; LoadoutOnly: the items only a class's Loadout gives (the modules give none of their own at the respawn) -
; javelins ([ExtraRocket]), mines and claymores ([Mines]), flashes ([FlashNades]); RespectShopOnly = 1: nothing
; the shop's ShopOnly sells only (ShopOnly wins over the Loadout).
; Weapons: the menu shows the weapons of his class (while he is dead: of his next class); a weapon that is not of his
; class, nor bought in this life, is replaced by one that is a moment after the respawn (a bot, a menu that came
; late). The class does not limit the shop: what he pays for is his (ShopClassOnly = 1: the shop sells only the
; weapons of his class, and the bots buy only those). With [Shop] BuyOnly the menu is what he owns and his class's
; weapons; [Ammo] SurvivalLock locks on top of that.
; KitSeconds: how long a class's healthpack or grenade kit lies on the ground; MortarLayer: the WorldText layer of
; the mortar's warning; C4Layer: the first of the 4 WorldText layers of the C4 marks; C4ScrapeSeconds: lying that
; long scrapes a C4 off. With a class that heals (a heal perk) [Medic] steps aside (!medic tells to use !classes).
List = assault|medic|support|engineer|sniper|recon
LoadoutOnly = javelins|mines|claymores
RespectShopOnly = 0
ShopClassOnly = 0
KitSeconds = 60
MortarLayer = 94
C4Layer = 96
C4ScrapeSeconds = 3
; The line of the class (HudPlace = ammo: over the ammunition, in the stack; fixed: HudX, HudY, HudScale):
; HudText with {class}, {skill}, {skill2}, {choose} (ChooseText while the players choose their classes) - SkillText
; with {name} and {state}: ReadyText, the seconds left of its
; cooldown (CoolText) or of a skill working (ActiveText), OffText when it does not work here (a rally in survival,
; a UAV without a radar); NoSkillText when the class has none. The class's Color colours it.
Hud = 1
HudText = {class}: {skill} | {skill2} {choose}
ChooseText = | !class
SkillText = {name} {state}
ReadyText = ready
CoolText = {seconds}s
ActiveText = on {seconds}s
OffText = off
NoSkillText = -
HudPlace = ammo
HudX = 20
HudY = 330
HudScale = 0.02
HudLayer = 211
HudColor = $FFD080
Color = $FFD080
; Texts: ClassText when he gets a class ({class}, {info}), NextText after a choice or a roll for his next life.
ClassText = You are {class}: {info} (!class for more)
NextText = You will be {class} from your next respawn.
; !class (his class, its weapons and skills; !class <name or number>: the choice), !classes (every class with the
; players of his team), !skill, !skill2 (also /cc1 and /cc2, and the game's Alt+1 and Alt+2 taunts /smoke and
; /tabac), /c4 (sets his C4 off: bind "x" "/c4"); admins: /setclass <player> <class>.
Commands = class
ListCommands = classes|classlist|listclass
SkillCommands = skill|cc1|smoke
Skill2Commands = skill2|cc2|tabac
SetCommands = setclass
C4Commands = c4

; ---- the classes ----
; Name, Words (for !class), Color, Modes (where the class is played), Max (players of a team in it: a number or a
; percent of the team, at least 1; 0 = no limit), Info (one line for !class and !classes).
; Primary and Secondary: the weapons of its menu - deagles mp5 ak aug spas ruger m79 barrett minimi minigun;
; socom knife chainsaw law (none named: every weapon; a weapon the server's list switches off stays off).
; Loadout: what it carries at the respawn - grenades N, flashes N, mines N, claymores N, javelins N, vest PERCENT,
; bandage PERCENT ([Bleeding]), kits N (first-aid kits of [Bleeding]), mags N (spare magazines over the fresh set
; of [Ammo]), c4 N (the C4 charges of a life); what it does not name the modules give as always (but LoadoutOnly).
; Perks (by themselves, once a second): heal PERCENT RADIUS (team mates within RADIUS px and himself get PERCENT of
; a full health back, not within 2 s of a hit; [Bleeding]: the blood too), repair VEST RADIUS (a vest a mate wears
; gets VEST more), ammo MAGS SECONDS RADIUS (every SECONDS a spare magazine of the weapon in each mate's hands -
; [Ammo]), revive FACTOR RADIUS ([Downed]: he gets the downed up FACTOR times faster, from RADIUS px), bandage FACTOR
; (his bandaging that much faster), armor FACTOR (the damage he takes), damage WEAPON FACTOR STANCE (the damage of
; his WEAPON times FACTOR in STANCE: any, crouch, prone, low = crouch or prone - note: with ZitroStats' [Bridges]
; ServerHook = 1 the hit zone is the server's own and a changed damage does not matter; without it ZitroStats reads
; the zone from the damage, and such hits may be counted in the wrong zone), spot FACTOR (his [Spotting] marks last longer), distance
; FACTOR (his [Points] for distance kills), detector RADIUS (the enemy mines of [Mines] within RADIUS px of him are
; found - he sees their marks, with a beep), crit CHANCE FACTOR (CHANCE % of his hits on enemies do FACTOR times the
; damage), wounds FACTOR (his hits open [Bleeding] wounds FACTOR times as often), leech HP (HP of health back for every
; hit on an enemy), firstaid RADIUS (with no wound of his own to bandage he bandages the wounded mates within
; RADIUS px - [Bleeding] - with his own bandage).
; Skill and Skill2: rally SECONDS COOLDOWN [RADIUS] (every mate who respawns while it lasts comes back next to him -
; where he last stood on the ground when he is in the air -, without spawn protection; several rallies of a team take
; the mates in turn, the one that got a mate longest ago first, and one that cannot take him now is passed by;
; RADIUS: only the mates who died within RADIUS px of him; not while he is down or carries a flag; not in survival),
; healthpack COOLDOWN, grenadekit COOLDOWN (a kit on the ground next to him, KitSeconds), statgun SECONDS COOLDOWN
; (a stationary gun, on the ground only; [Shop] StatgunMax of his at once),
; mortar SHELLS COOLDOWN SPREAD (a warning over his aim, then SHELLS shells fall from the sky within SPREAD px of
; it - a soldier in the air under them is hit too; under a roof they fall from the roof),
; uav SECONDS COOLDOWN (every enemy on his team's radar - [Radar] or [Spotting] marks), supply COOLDOWN WORDS (a
; crate of [Supply] at his aim for his team, holding one of WORDS: ammo grenades flashes mines claymore javelin
; medical vest money weapon; none: [Supply] Contents), patchup PERCENT COOLDOWN (his wounds closed - [Bleeding] -
; and PERCENT of a full health back), resupply COOLDOWN (his magazines and grenades), c4 RANGE COOLDOWN (a charge
; of his Loadout's c4 stuck on the enemy nearest to his aim within RANGE px he can see - a mark over him for the one
; who put it; /c4 sets all of his off; it goes with either one's death; lying C4ScrapeSeconds scrapes it off),
; sensor SECONDS COOLDOWN RADIUS (while it works, every enemy within RADIUS px of him is on his team's radar),
; steal RANGE COOLDOWN (the weapon in the hands of the enemy nearest to his aim within RANGE px he can see comes into
; his hands with its magazine, his own goes to his second hand, the robbed one takes his second weapon), barrage
; SHELLS COOLDOWN TARGETS (a warning, then SHELLS shells from the sky over each of up to TARGETS enemies his team sees -
; spotted or in his sight), gunship SECONDS COOLDOWN RANGE (a gun in the air over and behind him fires at the enemy
; nearest to it that it can see within RANGE px; under a roof it does not fire), cloak SECONDS COOLDOWN (the game's
; predator bonus: unseen, with SOCOM and the knife only, his weapons come back after it);
; off = none. A skill that fails costs no cooldown.
; Vest (the insurgents' classes): see [Insurgents].
; Every key from Max to Vest may also be written with Realistic, Survival or RealisticSurvival at its end
; (Skill2Survival = off, PerksRealistic = ...): that one counts in that mode (realistic survival first, then
; survival, then realistic).

[Class-Assault]
Name = Assault
Words = assault|a
Color = $FF9060
Modes = dm|pm|tm|ctf|rm|inf|htf
Max = 0
Info = rifles and grenades; a rally point for the team (!skill), a grenade kit (!skill2)
InfoSurvival = rifles and grenades; patches himself up (!skill), a grenade kit (!skill2)
Primary = ak aug deagles
Secondary = socom knife
Loadout = grenades 3
Perks =
Skill = rally 15 60
SkillSurvival = patchup 30 60
Skill2 = grenadekit 30
Skill2Survival = grenadekit 60

[Class-Medic]
Name = Medic
Words = medic|m
Color = $FF6080
Modes = dm|pm|tm|ctf|rm|inf|htf
Max = 0
Info = heals and bandages mates around him, gets the downed up fast; a healthpack on the ground (!skill)
Primary = mp5 spas
Secondary = socom knife
Loadout = kits 2, bandage 250
Perks = heal 3 120, revive 2 60, bandage 2, firstaid 40
PerksRealistic = heal 2 120, revive 2 60, bandage 2, firstaid 40
PerksSurvival = heal 3 100, revive 2 60, bandage 2, firstaid 40
Skill = healthpack 25
SkillSurvival = healthpack 45
Skill2 = off

[Class-Support]
Name = Support
Words = support|s
Color = $80C0FF
Modes = dm|pm|tm|ctf|rm|inf|htf
Max = 25%
Info = machine gun, rifle or shotgun, two claymores; ammunition for mates around him; a supply crate for his team (!skill), his own ammunition and grenades (!skill2)
Primary = minimi aug spas
Secondary = socom knife
Loadout = claymores 2
Perks = ammo 1 10 120
Skill = supply 50 grenades medical
Skill2 = resupply 30
Skill2Survival = resupply 60

[Class-Engineer]
Name = Engineer
Words = engineer|e
Color = $FFD040
Modes = dm|pm|tm|ctf|rm|inf|htf
Max = 25%
Info = repairs the vests, finds the enemy mines near him; a Javelin and a mine; a stationary gun (!skill), C4 on an enemy (!skill2, /c4 sets it off 2 s later)
Primary = mp5 m79
Secondary = law chainsaw
Loadout = javelins 1, mines 1, c4 1
Perks = repair 4 120, detector 160
Skill = statgun 12 40
SkillSurvival = statgun 20 120
Skill2 = c4 200 20

[Class-Sniper]
Name = Sniper
Words = sniper|sn
Color = $A0FFA0
Modes = dm|pm|tm|ctf|rm|inf|htf
Max = 25%
Info = more points far away and a claymore; patches himself up (!skill), a mortar (!skill2)
Primary = ruger barrett
Secondary = socom knife
Loadout = claymores 1
Perks = distance 1.5
Skill = patchup 40 50
Skill2 = mortar 6 45 200
Skill2Survival = mortar 4 90 160

[Class-Recon]
Name = Recon
Words = recon|r
Color = $C0A0FF
Modes = dm|pm|tm|ctf|rm|inf|htf
Max = 25%
Info = light weapons, flash grenades, a claymore; longer spots, sees the enemy mines from afar; a UAV (!skill) and a sensor (!skill2) show the enemies to his team
Primary = deagles mp5
Secondary = socom knife
Loadout = flashes 2, claymores 1
Perks = spot 2, detector 400
Skill = uav 8 60
Skill2 = sensor 12 45 650

; Two more classes, ready to be played: add their names to List (grenadier|marksman).
[Class-Grenadier]
Name = Grenadier
Words = grenadier|g
Color = $FFA040
Modes = dm|pm|tm|ctf|rm|inf|htf
Max = 25%
Info = the grenade launcher, more grenades, a little armor; a grenade kit (!skill), a small mortar (!skill2)
Primary = m79 spas
Secondary = socom law
Loadout = grenades 3
Perks = armor 0.9
Skill = grenadekit 25
Skill2 = mortar 4 60 160
Skill2Survival = mortar 3 120 140

[Class-Marksman]
Name = Marksman
Words = marksman|mk
Color = $80FFE0
Modes = dm|pm|tm|ctf|rm|inf|htf
Max = 25%
Info = the AUG and the Ruger; his spots last longer, more points far away; a UAV (!skill), patch-up (!skill2)
Primary = aug ruger
Secondary = socom knife
Loadout = flashes 1
Perks = spot 1.5, distance 1.25
Skill = uav 6 75
Skill2 = patchup 30 60

; Three more coalition classes (the 2014 American roles), ready to be played: add their names to List
; (mechanic|spy|commando).
[Class-Mechanic]
Name = Mechanic
Words = mechanic|me
Color = $C0C0C0
Modes = dm|pm|tm|ctf|rm|inf|htf
Max = 25%
Info = repairs the vests around him; a gunship over him fires at the enemies near (!skill)
Primary = mp5 aug
Secondary = socom knife
Loadout =
Perks = repair 8 120
Skill = gunship 8 90 800
SkillSurvival = gunship 6 120 600
Skill2 = off

[Class-Spy]
Name = Spy
Words = spy|sy
Color = $B0B0FF
Modes = dm|pm|tm|ctf|rm|inf|htf
Max = 25%
Info = light weapons, a flash grenade; unseen for a while with SOCOM and the knife (!skill)
Primary = deagles mp5
Secondary = socom knife
Loadout = flashes 1
Perks =
Skill = cloak 25 60
SkillSurvival = cloak 25 120
Skill2 = off

[Class-Commando]
Name = Commando
Words = commando|co
Color = $FF8080
Modes = dm|pm|tm|ctf|rm|inf|htf
Max = 25%
Info = health back for every hit on an enemy; a stationary gun (!skill)
Primary = ak minimi
Secondary = socom knife
Loadout =
Perks = leech 6
PerksSurvival = leech 4
Skill = statgun 10 30
SkillSurvival = statgun 6 90
Skill2 = off

[Insurgents]
; Insurgents (the owner's Taliban mod of 2014 with neutral names; off by default): one team - or both - fights as the
; insurgents, and every soldier of it wears a suicide vest. Modes: the team game modes it works in; Team: alpha,
; bravo or both; Name and EnemyName: the two sides in its texts.
; The vest: holding Keys (as [Mines]: flagthrow = crouch + jump or the throw-flag key; none = the command only) or
; /detonate (again = stop) counts HoldSeconds down - a beep (ArmSound, heard within SoundRadius px) and ArmText over
; him (ArmColor; ArmLayer: its WorldText layer) warn the ones near; letting the keys go stops it (it cannot be armed again for a second). Then it goes off:
; a blast inside every enemy within CoreRadius px of him that he can see, and the vest's pattern around him (Power
; scales its hits); he dies of it (no suicide's penalty, no grenade of [Posthumous]) and its kills are his.
; Pattern: classic, hawk, inferno, shrapnel, ring, scatter, ied, plain (one blast), random (a new one of the first
; seven every life) or none; with [Classes] a class's Vest key wins. KeysOverMines = 1: an insurgent's flagthrow keys set off the vest,
; not a landmine of [Mines] (lying, they are still the claymore's).
; Not in the first MinLifeSeconds of a life, not within SpawnDistance px of an enemy spawn point he can see (0 =
; anywhere), not with a flag (FlagCarrier = 1: also then), not while his team waits TeamCooldownSeconds after a vest
; of it went off. Killed while it counts down: DeadManChance % that it goes off anyway (HeadshotStops = 1: never after
; a headshot); DownedDetonate = 1: a downed insurgent ([Downed]) can still set it off.
; Bots = 1: an insurgent bot with BotMinEnemies enemies or more within BotRadius px that he can see, and no mate nearer
; than the nearest of them, sets it off - BotChance % each second.
; Texts: JoinText at his first vest ({faction}, {enemy}, {how}), Shout (said in the chat at the blast; empty = none),
; VictimText to the ones it killed ({name}: the bomber), BomberText to him ({kills}); Color: their colour.
; His line (Hud = 1; HudPlace = ammo: over the ammunition, in the stack; fixed: HudX, HudY, HudScale; HudLayer: its
; BigText layer): HudText with {state} - ReadyText, ArmingText ({seconds} left) or WaitText ({seconds}).
; Classes: the insurgents' classes ([Class-<name>] sections), played by the insurgents only while it is on - the
; classes of [Classes] List by everybody else. Weapons (without [Classes]): the insurgents' weapon menu (e.g. ak spas
; ruger minimi; empty = the server's).
; !insurgents (how the vest works here), /detonate (bind "b" "/detonate"); admins: /givevest <player|all|alpha|bravo>
; [pattern] (a vest for this life, also for somebody who is no insurgent), /takevest <player|all|alpha|bravo>.
Enabled = 0
Modes = tm|ctf|inf|htf
Team = alpha
Name = Insurgents
EnemyName = Coalition
Keys = flagthrow
KeysOverMines = 1
HoldSeconds = 1
Pattern = classic
CoreRadius = 60
Power = 1
MinLifeSeconds = 3
TeamCooldownSeconds = 0
SpawnDistance = 250
FlagCarrier = 0
DeadManChance = 25
HeadshotStops = 1
DownedDetonate = 1
Bots = 1
BotMinEnemies = 2
BotRadius = 110
BotChance = 30
ArmText = !!!
ArmColor = $FF2020
ArmSound = signal.wav
SoundRadius = 600
ArmLayer = 88
Shout =
JoinText = You fight for the {faction}: {how} sets off your vest (!insurgents).
VictimText = Blown up by {name}.
BomberText = Your vest took {kills}.
Color = $FF8040
Hud = 1
HudText = Vest: {state}
ReadyText = ready
ArmingText = going off {seconds}
WaitText = wait {seconds} s
HudPlace = ammo
HudX = 20
HudY = 310
HudScale = 0.02
HudLayer = 215
HudColor = $FF8040
Classes = hawk|healer|thief|saboteur|spotter|leader|raider|mortarman
Weapons =
Commands = detonate|det
InfoCommands = insurgents|ins|vesthelp
GiveCommands = givevest
TakeCommands = takevest

; ---- the insurgents' classes ([Insurgents] Classes) ----
; The keys of the classes above, and Vest: the pattern of the vest (classic, hawk, inferno, shrapnel, ring, scatter,
; ied, plain, random or none; left out: [Insurgents] Pattern). Their weapons: the 2014 insurgents' menu (AK-74,
; Spas-12, Ruger 77, FN Minimi).
[Class-Hawk]
Name = Hawk
Words = hawk|h
Color = $FFB060
Modes = tm|ctf|inf|htf
Max = 0
Info = a fifth of his hits on enemies half as hard again, his hits open wounds twice as often; the hawk vest
Primary = ak ruger
Secondary = socom knife
Loadout =
Perks = crit 20 1.5, wounds 2
Skill = off
Skill2 = off
Vest = hawk

[Class-Healer]
Name = Healer
Words = healer|he
Color = $FF7090
Modes = tm|ctf|inf|htf
Max = 0
Info = heals and bandages mates around him, gets the downed up fast; a healthpack on the ground (!skill)
Primary = ak spas
Secondary = socom knife
Loadout = kits 1, bandage 250
Perks = heal 3 120, revive 2 60, firstaid 40
PerksRealistic = heal 2 120, revive 2 60, firstaid 40
PerksSurvival = heal 1.5 100, revive 2 60, firstaid 40
Skill = healthpack 30
SkillSurvival = healthpack 45
Skill2 = off
Vest = classic

[Class-Thief]
Name = Thief
Words = thief|t
Color = $C0E060
Modes = tm|ctf|inf|htf
Max = 25%
Info = takes the weapon out of the hands of the enemy at his aim (!skill); the inferno vest
Primary = spas minimi
Secondary = socom knife
Loadout =
Perks =
Skill = steal 190 30
Skill2 = off
Vest = inferno

[Class-Saboteur]
Name = Saboteur
Words = saboteur|sa
Color = $FFD040
Modes = tm|ctf|inf|htf
Max = 25%
Info = C4 on an enemy (!skill, /c4 sets it off 2 s later); the shrapnel vest
Primary = ak minimi
Secondary = socom knife
Loadout = c4 1
Perks =
Skill = c4 200 20
Skill2 = off
Vest = shrapnel

[Class-Spotter]
Name = Spotter
Words = spotter|sp
Color = $A0FFA0
Modes = tm|ctf|inf|htf
Max = 25%
Info = his spots last longer; a barrage on the enemies his team sees (!skill); a vest of any kind
Primary = ruger ak
Secondary = socom knife
Loadout =
Perks = spot 2
Skill = barrage 3 50 4
SkillSurvival = barrage 2 90 3
Skill2 = off
Vest = random

[Class-Leader]
Name = Leader
Words = leader|l
Color = $FF9060
Modes = tm|ctf|inf|htf
Max = 25%
Info = a rally point for the team (!skill); the ring vest
InfoSurvival = patches himself up (!skill); the ring vest
Primary = ak spas
Secondary = socom knife
Loadout = grenades 3
Perks =
Skill = rally 10 50
SkillSurvival = patchup 30 60
Skill2 = off
Vest = ring

[Class-Raider]
Name = Raider
Words = raider|ra
Color = $C0A0FF
Modes = tm|ctf|inf|htf
Max = 0
Info = grenades and flash grenades; a grenade kit (!skill); the scatter vest
Primary = ak spas
Secondary = socom knife
Loadout = grenades 3, flashes 2
Perks =
Skill = grenadekit 45
Skill2 = off
Vest = scatter

[Class-Mortarman]
Name = Mortarman
Words = mortarman|mo
Color = $80C0FF
Modes = tm|ctf|inf|htf
Max = 25%
Info = a mortar (!skill); the IED vest
Primary = spas minimi
Secondary = socom knife
Loadout =
Perks =
Skill = mortar 9 40 200
SkillSurvival = mortar 4 90 160
Skill2 = off
Vest = ied

[Points]
; Battle points (the Battlefield mod's score): a score of its own for the map, with a feed - the game's kills and
; ZitroStats stay as they are. Every value is the points of one event (0 = none; a negative value takes points).
; Damage: per percent of a full health done to an enemy (a whole health: 100); Kill: on top of that for a kill;
; TeamDamage: per percent done to a team mate; Headshot (the killing hit on the head), Assist (everybody else who
; did AssistPercent of a health to the one killed), FirstBlood (the map's first kill), SelfKill (not the end of a
; survival round, not the server's own kills), Distance (a kill farther than DistanceFrom px: DistanceBase + 1 per
; DistanceStep px more, times the class's distance perk), Savior (killing the one who hurt a mate within
; SaviorSeconds), Revenge (killing your last killer), Posthumous (a kill after your death), MultiKill (kills no
; more than MultiSeconds apart: the 2nd|3rd|4th|5th|6th and more), FlagGrab (from its base), FlagScore,
; FlagReturn, Revive ([Downed]: a mate got up), TeamRespawn (a mate came back at your rally), AmmoGiven (per
; AmmoEvery magazines given to mates), Healed (per HealEvery percent of a health given), Repaired (per RepairEvery
; vest), KitTaken (a mate took your kit), KitEnemy (an enemy did), KitPlaced, StatgunPlaced, SpotKill (an enemy you
; spotted killed by a mate), BountyCollected ([Bounty]), CrateOpened (a mate opened the crate of your supply
; skill), Resupplied ([Resupply]). Bots = 1: the bots get points too.
Enabled = 0
Modes = dm|pm|tm|ctf|rm|inf|htf
Damage = 1
; DamageLimit: the Damage points one life can give, in percent of a full health (as [Shop] DamageLimit; 0 = no
; limit).
DamageLimit = 150
; RepeatKillPercent: the same enemy killed again within a minute (counted per killer and victim pair, as [Shop]
; RepeatKillPercent - two friends feeding each other kills do not pay more and more): from the third kill on the Kill,
; Headshot, Distance and MultiKill points are this percent of themselves (100 = all of them, no limit; 0 = none).
RepeatKillPercent = 50
Kill = 0
TeamDamage = -1
Headshot = 15
Assist = 60
AssistPercent = 50
FirstBlood = 200
SelfKill = -50
Distance = 1
DistanceFrom = 640
DistanceBase = 10
DistanceStep = 8
Savior = 40
SaviorSeconds = 6
Revenge = 40
Posthumous = 15
MultiKill = 20|30|50|100|200
MultiSeconds = 3
FlagGrab = 80
FlagScore = 250
FlagReturn = 50
Revive = 50
TeamRespawn = 25
AmmoGiven = 20
AmmoEvery = 10
Healed = 20
HealEvery = 100
Repaired = 35
RepairEvery = 100
KitTaken = 50
KitEnemy = -25
KitPlaced = 0
StatgunPlaced = 0
SpotKill = 20
BountyCollected = 50
CrateOpened = 10
Resupplied = 0
Bots = 1
; The line of the score (HudPlace = ammo: over the ammunition, in the stack; fixed: HudX, HudY, HudScale): HudText
; with {score} and, for GainSeconds after an event, {gain} (GainText: {points} and {why} - the events of those
; seconds added up). FeedConsole = 1: every event in his console too (FeedText, Color).
Hud = 1
HudText = Score {score}{gain}
GainText = ({points} {why})
GainSeconds = 2.5
HudPlace = ammo
HudX = 20
HudY = 320
HudScale = 0.02
HudLayer = 212
HudColor = $F15D70
FeedConsole = 0
FeedText = {points} {why}
Color = $F15D70
; !score (his score and place), !scores (the best TopLines of each team; ZitroStats keeps !top and !rank). At the
; map's end everybody gets the best BestLines in the console and sees both teams' lists for BoardSeconds
; (BoardLayer and BoardLayer + 1; 0 = no board). A player who leaves and comes back on the same map keeps his score.
ScoreCommands = score
TopCommands = scores|scoreboard
TopLines = 5
BoardSeconds = 10
BoardLayer = 213
BestLines = 3

[Resupply]
; Resupply at the base (the Battlefield mod's /getammo): a soldier who stays low (crouching or lying; a bot by
; standing there, Bots = 1) within Radius px of his team's flag base (Where = flag; CTF, INF, HTF) or of a spawn
; point of his team (Where = spawn; both = either) for Seconds gets What - mags (his magazines topped up, [Ammo]),
; grenades (a life's grenades of [FlashNades]), bandage (a full bandage, [Bleeding]), vest (a vest he wears made
; whole) - and not again for CooldownSeconds. Text ({pct}) over him while he waits (Layer, Color), DoneText
; ({what}) in his console. Survival = 0: not in survival rounds. In the field: the supply crates of [Supply], the
; Support class's ammo perk and its supply and resupply skills.
Enabled = 0
Modes = tm|ctf|inf|htf
Where = both
Radius = 120
Seconds = 3
CooldownSeconds = 30
What = mags|bandage
Survival = 0
Bots = 1
Text = Resupply {pct}%
DoneText = Resupplied: {what}.
Layer = 95
Color = $A0D8FF

[Admin]
; The players of Steam-1, Steam-2 ... (a Steam id in any form at the start, the rest of the value is a
; comment - a name) become admins once Steam confirms them - an HWID can be faked, a Steam account
; cannot. Soldat keeps admins by IP: the server writes the IP into remote.txt; the script takes it out
; again when the player leaves (only an IP it put there itself, listed in data/basic-extended/granted_admins.txt).
; When the server stops while that player is in the game (a closed window, a crash, a kill) the IP stays in
; remote.txt: the script takes it out of the file when the server is stopped normally (Ctrl+C), and at the
; next start it lists what is left - until a player from that address joins (the script takes the rights back
; then) or /unadm <IP> is typed, whoever comes from there is an admin and enters past the password and the bans.
; The commands of this script follow the Steam account itself; the server's own rights (kick, map ...) follow
; the address.
; /steamadmin - the list; /steamadmin add|del <player or Steam id> writes the Steam-N lines of this
; section. Only from the server console, a TCP admin or a Steam admin. Admins are equal, as in Soldat; only
; /banr and /bansteam refuse a Steam admin's account unless a Steam admin or the console bans it.
SteamAdminCommands = steamadmin
; SharedIp: a player who is no Steam admin plays from the address of one who is (a flat, a shared line): the
; server would make him an admin as well. suspend = the address is taken out of remote.txt while he is here -
; the Steam admin keeps the commands of this script, loses the server's own (kick, map ...) and is told;
; allow = both stay admins of the server (the admins are told); kick = he is removed. Whatever the value, he got
; in past the server's password and ban lists (the server lets an admin's address in first): only kick stops that.
SharedIp = suspend
; The list shown by /admincommands: the Line-N lines of [AdminCommandList] (padded to [CommandList]
; PadTo)
ListCommands = admincommands
; /be_prof: how long each part of the script's tick takes (/be_prof on|off|reset)
ProfileCommands = be_prof
IpCommands = ip
HwidCommands = hwid
; /banr <id> <time> <reason>, /banhwr <time> <hwid> <reason>, /banipr <time> <ip> <reason>;
; time = number + m, h, d, mon or y
BanCommands = banr|banrange|bantime
BanHwidCommands = banhwr
BanIpCommands = banipr
; longest ban in minutes (0 = no limit) and 1 = a longer one is shortened, 0 = refused
MaxBanMinutes = 129600
ShortenLongBans = 1
KillAllCommands = killall
KickAllCommands = kickall
ExplodeAllCommands = explodeall
; /killall and /kickall leave the admins alone (1) or not (0)
KillAllSkipsAdmins = 0
KickAllSkipsAdmins = 1
; Every command that takes a player takes: an id, a name or a part of it ("in quotes" with spaces),
; me, all, others (everybody but you), alpha, bravo, charlie, delta, spec, bots or humans.
; /explode <player> [kind], /god [player] (no damage), /heal <player>, /slap <player> [damage],
; /freeze <player> (again = free), /bring <player> (to you), /goto <player>, /disarm <player>,
; /give [near] <player> [ammo] <weapon> - weapon: usp deagle mp5 ak aug spas ruger m79 barrett minimi
;   minigun knife chainsaw law flamer bow flamebow or 0-16; ammo = rounds in the magazine (at most a
;   full one); near = the weapon drops next to the player instead,
; /bonus [near] <player> <predator|berserker|vest|nades|clusters|flame|medkit or 1-7> - given at once
;   (near: the kit drops next to the player),
; /statgun [player] - a stationary gun next to you (or the player); /removestatgun [all] - the one
;   nearest to you (or all of them),
; /infammo <player> - infinite ammo on/off (the magazine is filled again, a thrown knife comes back),
; /dmgfix <player> <+n%|-n%|n%|xN|off> - the damage the player's bullets do (+20% = 120%),
; /dmgtaken <player> <...> - the damage the player takes (both together multiply),
; /vest <player> [0-100] - body armour.
; The server itself bans a player for a day for a bow outside Rambo mode, admins too ("Not allowed
; weapon"), so /give refuses it. A server with sv_bonus_flamer 1 does the same for a flamer (also the
; flame god bonus); set GiveFlamer = 1 when yours has sv_bonus_flamer 0.
; Kinds of /explode (and /explodeall [kind]): plain, big (a big blast with rings of explosions,
; shrapnel and fire), nuke (three rings of blasts and rockets falling from the sky), law (rockets from
; six sides), m79 (shells from above), arrows, firearrows, bullets, spas (shotgun shells from four
; sides), flame, cluster, nades (a fan of grenades), knives, rain (bullets from the sky).
; /bigexplode <player> = /explode <player> big, /nuke <player> = /explode <player> nuke.
; ExplodePower (0.1-10) multiplies the damage of every kind. Script bullets never fill the game's 254
; bullet slots (32 are kept free), and no object is made when fewer than 4 of the 90 slots are free.
ExplodeCommands = explode
BigExplodeCommands = bigexplode|boom
NukeCommands = nuke
ExplodePower = 1
GodCommands = god
HealCommands = heal
SlapCommands = slap
SlapDamage = 15
FreezeCommands = freeze
BringCommands = bring
GotoCommands = goto
DisarmCommands = disarm
GiveCommands = give
BonusCommands = bonus
GiveFlamer = 0
StatgunCommands = statgun|sg
StatgunRemoveCommands = removestatgun|delstatgun
InfAmmoCommands = infammo|infiniteammo
DamageCommands = dmgfix|dmgmod
DamageTakenCommands = dmgtaken
VestCommands = vest
; /speed <player> [1.1-5|off] [all|ground|jump] - run and fly faster (2 = twice as fast; without a
; number: on with SpeedDefault, again = off). Running is pushed up to SpeedRunPixels a tick times the
; factor (the game runs at about 3.9; 11 at most). The kind (SpeedMode when not given):
;   all    - on the ground and in the air, jets get SpeedJetPush more a tick for every step of the factor;
;   ground - only on the ground: a jump keeps the speed it had, nothing more is added in the air;
;   jump   - like ground, and the jump off the ground is stronger by SpeedJumpShare of the factor.
SpeedCommands = speed|speedhack
SpeedDefault = 2
SpeedMode = all
SpeedRunPixels = 3.9
SpeedJetPush = 0.1
SpeedJumpShare = 0.5
; /sayas <player> <text> - everybody reads the text as that player's chat line ("[name] text", the
; chat colour); /sayteam <player> <text> - only that player's team, as team chat. The admin who did
; it is written to the server console. The colours are those of the game's chat.
SayAsCommands = sayas
SayTeamCommands = sayteam|sayteamas
SayAsColor = $EFFEEA
SayTeamAsColor = $FEDA7C
SayAsSpectatorColor = $DF7AB0
; /slay <player> - kills at once (counts as a suicide, like /kill); /killall kills everybody
SlayCommands = slay
RandomizeCommands = randomize
ReloadCommands = reloadsettings|be_reload
; what the script sent in the last minutes (health texts, damage numbers, heals, bullets looked at)
StatusCommands = be_status
; Testing aids, only from the server console or a TCP admin connection:
; /be_test <player id> <chat line or /command> runs it as that player, the answers also go to the
; console; /be_bench measures the bullet scan, the kit sweep, a property read, the snapshot of the
; players for the library and the cost of a library call (the server stands still for about a
; second: use it on a test server)
TestCommands = be_test
BenchCommands = be_bench
; Steam-1 = S123456789 // a name

[AdminCommandList]
; The lines /admincommands shows ([Admin] ListCommands): Line-1, Line-2 ... in number order;
; Color-Line-N gives a line its own colour
Line-1 = ____________________________________Admin Commands___________________________________|
Line-2 = /kickall /killall /explodeall /setscore <team id> <score> /randomize /reloadsettings |
Line-3 = /banr <ID> <Time(m|h|d|mon|y)> <Reason>, /banipr, /banhwr <time> <data> <reason>     |
Line-4 = /displayspawns /createspawn [0-4] /removenearspawn /removeallspawn /editnearspawn    |
Line-5 = /testrespawn [id|next] /countspawns /saveallspawns /checkspawns /exportspawns        |
Line-6 = /spawnlayouts [part] /deletespawnlayout [map] /ip <*> /hwid <*>                      |
Line-7 = /search, /checkp, /checkd, /privacy, /resetallplayersstats, /resetallmapsstats       |
Line-8 = /backupcreate <backup name>, /restorebackup <backup name>, /statusa <name*>          |
Line-9 = /removeolderthan <data> (/removeolderthan 18.01.2021 or /removeolderthan 2021.01.18) |
Line-10 = /radar [help|mode|tick|edit|zoom|show|size|marks|edge|outline|team]                  |
Line-11 = /steamadmin, /be_status, /be_test, /be_bench                                         |
Line-12 = <player> = id, name or part of it ("with spaces"), me, all, others, alpha, bravo,    |
Line-13 =   charlie, delta, spec, bots, humans                                                 |
Line-14 = /explode <player> [kind], /bigexplode <player>, /nuke <player>                       |
Line-15 =   kinds: plain big nuke law m79 arrows firearrows bullets spas flame cluster nades   |
Line-16 =          knives rain                                                                 |
Line-17 = /god [player], /heal <player>, /slap <player> [damage], /freeze <player>             |
Line-18 = /bring <player>, /goto <player>, /disarm <player>, /vest <player> [0-100]            |
Line-19 = /give [near] <player> [ammo] <weapon>   e.g. /give all 30 ak, /give near bravo m79   |
Line-20 = /bonus [near] <player> <predator|berserker|vest|nades|clusters|flame|medkit|1-7>     |
Line-21 = /statgun [player], /removestatgun [all], /infammo <player>                           |
Line-22 = /dmgfix <player> <+20%|-10%|150%|x2|off>, /dmgtaken <player> <...>                   |
Line-23 = /tele, /teletomouse [inherit|fixed], /flytomouse (reload key: tap = jump, hold =     |
Line-24 =   fly where the cursor points, inherit = faster the longer you hold)                 |
Line-25 = /trajectory [player [cursor] [me|self|selfme|public]|off] (cursor = only the         |
Line-26 =   cursor; me = only you, self = only that player, selfme = both, public = all)       |
Line-27 = /aimbot [on|off|cursor|nearest|radius [px]|acc <0-100>|extra <min-max>|law <rule>]   |
Line-28 =   /aimbot colliders on|off, /aimbot radius edit|save|cancel (circle at the cursor)   |
Line-29 = /speed <player> [1.1-5|off] [all|ground|jump], /slay <player>                        |
Line-30 = /sayas <player> <text>, /sayteam <player> <text> (as that player's chat)             |
Line-31 = /loadwep <name> (the server): the library reads configs/<name>.ini as well           |
Line-32 = /acclear <player|all> [all], /acclear all all (everybody, the whole history)         |
Line-33 = Everybody: /suspects [all], /acstats <player>, /acreview <player> (or with !)        |
Line-34 = _____________________________________________________________________________________|

[Teleport]
; Three ways for an admin to move to the cursor with Key (reload, grenade, throw or changeweapon; the
; key keeps doing its own job too), each switched on and off by its command (and off at every join).
; The key is read every tick; the game sends it with the player's movement packets.
;   /tele         a press: jump there and stop
;   /teletomouse  a tap: jump there and keep flying that way (the speed you had * MomentumKeep, plus
;                 MomentumBase, plus MomentumPerPixel for every pixel of the jump, at most MomentumMax).
;                 Held for HoldTicks ticks or longer: you fly where the cursor points - move the mouse
;                 to the other side and you turn round (HoldSteer, 0.01-1, is how much of a turn is taken
;                 each tick) - with a jump towards the cursor at most every HopTicks ticks (and not
;                 before your ping has passed) when it is HopMinPixels or more away (HopMaxPixels at
;                 most), and a push every PushTicks ticks in between. After a jump the game's camera
;                 lags behind for a moment, so the cursor seems to be behind you: that is left out.
;                 /teletomouse inherit: the longer you hold, the faster you fly - InheritAccel pixels a
;                 tick more every second and InheritGain more for every jump, at most InheritMax.
;                 /teletomouse fixed: the speed by the distance to the cursor.
;                 HoldSpeed is the variant a plain /teletomouse starts with (after a /reloadsettings
;                 for those who join).
;   /flytomouse   while the key is held, every FlyEveryTicks a push towards the cursor of FlyBase +
;                 FlyPerPixel per pixel beyond FlyDeadZone, at most FlyMax; with the cursor within
;                 FlyDeadZone pixels of the soldier you hover. FlySmooth (0.05-1) is how much of a change
;                 of the direction is taken at once (less = steadier). The game itself (the server and
;                 every player's game) never lets a soldier move faster than 11 pixels a tick on each
;                 axis - 15.5 diagonally - so that is as fast as a push can make it (FlyVelocityMax,
;                 1-15.5). FlyHops = 1 goes further: what FlyMax (up to 60) asks above that is made up
;                 with short jumps along the way, every FlyHopTicks ticks at most (1-60, not before
;                 your ping has passed), each at most FlyHopMaxPixels long; faster, but it looks like
;                 small teleports.
; Speeds are pixels a tick; the game allows 11 on each axis (15.5 diagonally). Not into a wall with
; NotIntoWalls = 1 (checked by basicext_dll when [MapGeometry] read the map).
Enabled = 1
Commands = tele|tp
MomentumCommands = teletomouse|ttm
FlyCommands = flytomouse|ftm
Key = reload
NotIntoWalls = 1
MomentumBase = 2
MomentumPerPixel = 0.008
MomentumKeep = 1
MomentumMax = 11
HoldTicks = 15
HoldSteer = 0.3
HopTicks = 6
HopMinPixels = 24
HopMaxPixels = 600
PushTicks = 3
HoldSpeed = inherit
InheritAccel = 4
InheritGain = 0.6
InheritMax = 11
FlyBase = 1.5
FlyPerPixel = 0.04
FlyMax = 15.5
FlyVelocityMax = 15.5
FlyHops = 0
FlyHopTicks = 4
FlyHopMaxPixels = 160
FlyEveryTicks = 2
FlyDeadZone = 8
FlySmooth = 0.5

[Trajectory]
; /trajectory - where the bullets of your weapon fly, as dots from the gun (green = where they hit a
; wall); /trajectory <player> - the flight of that player's bullets (with the cursor); again or
; /trajectory off stops it. Worked out in basicext_dll from the weapons of the server (see [Weapons]): speed, gravity,
; the speed of the soldier the bullet takes along, the gun's place for standing, crouching and prone.
; Drawn every UpdateTicks ticks (1-60) up to Range pixels, Dots dots at most (2-60) out of points
; Spacing pixels apart. The path is worked out again only when the position, speed, cursor, weapon or
; stance changed. The dots go out together (at most TextsPerUpdate texts at a time, 1-64; keep it
; above Dots), and only when the path moved more than MovePixels. WorldText layers LayerFirst ..
; LayerFirst+Dots.
; ViewOnly = 1: the dots cover only the part of the path the watcher can see: the screen around the
; camera, which the game keeps between the soldier and the cursor (a Barrett zoom or a bullet the
; camera follows moves it further out), with ViewMargin pixels more on each side. Without
; [MapGeometry] the walls come from the script (slower).
; Soldat sends the cursor to the server only now and then (after the mouse moved 30 pixels or more),
; so the path shows where the server thinks you aim: an M79 or a far shot can land a little off.
; FollowBullet = 1: when the watched player fires a Barrett while crouching or prone (the game's
; camera then follows the bullet), the dots are drawn ahead of the flying bullet itself, every
; FollowUpdateTicks ticks (1-60), and the ones it passed go away.
; /trajectory <player> cursor - only that player's cursor, every CursorUpdateTicks ticks (1-60).
; Who sees it: /trajectory <player> [cursor] [me|self|selfme|public]
;   me (the default) - only the admin who asked, never the watched player;
;   self   - only the watched player (his own dots, without the cursor mark);
;   selfme - the watched player and the admin;
;   public - everybody in the game.
; Colliders = 1: the red circles of the map that stop bullets end the path too.
Enabled = 1
Commands = trajectory|traj
UpdateTicks = 5
Dots = 16
Spacing = 16
Range = 2500
TextsPerUpdate = 20
MovePixels = 2
LayerFirst = 100
Scale = 0.08
CursorScale = 0.1
Color = $FF3030
HitColor = $33CC00
CursorColor = $DCB201
ViewOnly = 1
ViewMargin = 25
FollowBullet = 1
FollowUpdateTicks = 2
CursorUpdateTicks = 2
Colliders = 1

[Aimbot]
; /aimbot (or /aim) for admins: while Key (crouch, jet, prone, fire or flagthrow) is held - FlagKey
; while the player carries a flag (the flag key would throw it) - new bullets of the weapon in hand
; fly at an enemy. Target (each admin may change it):
;   cursor  - the enemy nearest to the line of the cursor, within MaxAngle degrees of it;
;   radius  - only enemies within CursorRadius pixels of the cursor, the nearest to it first; with
;             nobody in the circle it does not fire (it never jumps to somebody far away);
;   nearest - the nearest enemy.
; The shot leads a moving target (worked out in basicext_dll with the bullet's speed and gravity) and
; goes only when no wall is in the way (Colliders = 1: the red circles that stop bullets and set off
; grenades count as walls), up to Range pixels, at the fire rate and start-up time of the weapon.
; Every shot takes a round of the weapon's own magazine and the game reloads it (InfiniteAmmo = 1 or
; /infammo: no); a thrown knife leaves the hand like in the game (with infinite ammo it stays).
; While you fire yourself (Key other than fire) it waits and goes on PauseAfterOwnShotTicks ticks after
; you let go (0-600), so the ammo count of the server and of your game stays the same.
; Spread (0-100) is the share of the weapon's own inaccuracy, as the game works it out (standing,
; crouching, prone, running, jumping); 0 = every shot exact.
; ExtraShots: after a kill it fires a random number of shots in this range more (for example 1-5, a
; single number, or off), so it does not stop at once - not while another enemy is within Range, not
; into a wall, and not for a target that is only out of sight; only weapons with a magazine that fire
; at least every ExtraShotsMaxInterval ticks (1-1000). A Minigun or Barrett winds up (with its sound)
; only when there is somebody to shoot at.
; Law: when a LAW may fire - game (on the ground, crouching or prone, as in the game), ground (on the
; ground in any stance) or anywhere (also standing up and in the air).
; With Key = fire the weapon fires too, but its own bullets do no damage while the aimbot is on.
; Sound = 1: the shot is heard up to SoundRange pixels.
; Recoil = 1: a Spas-12 or Minigun shot pushes the shooter back like in the game (the Minigun less
; while jetting, more with the flag).
; /aimbot on|off|cursor|nearest|radius [px]|acc <0-100>|extra <min-max>|law <rule>|colliders on|off
; /aimbot radius edit: a circle of RadiusDots dots around your cursor (only you see it; WorldText layers
; RadiusLayerFirst ..) shows the radius; hold Reload = bigger, Change weapon = smaller, or
; /aimbot radius <px>; /aimbot radius save keeps it (cancel does not; after RadiusEditSeconds it is kept).
; Target, CursorRadius, Spread, ExtraShots, Law and Colliders are where each admin starts: after a
; /reloadsettings they reach those who join (or reset them with /aimbot); Enabled = 0 stops it for all.
Enabled = 1
Commands = aimbot|aim
Key = crouch
; The key while the player carries a flag
FlagKey = crouch
Target = cursor
MaxAngle = 70
CursorRadius = 150
Range = 900
Spread = 0
ExtraShots = 1-5
ExtraShotsMaxInterval = 25
; The extra shots after a kill:
;   fixed  - at the last aim point
;   spread - each shot off by a random angle that grows with the shots of the burst
;   corpse - at the killed soldier's body, where the game has it
;   both   - at the body, with the growing spread
ExtraShotsMode = both
; How much the spread grows (0-100; 5 = about 1 degree more each shot, 0 = none)
ExtraShotsSpread = 5
; 1 = a small flame at the muzzle with the shots (the game shows none for the aimbot's bullets)
MuzzleFlash = 1
Law = game
Colliders = 1
PauseAfterOwnShotTicks = 20
InfiniteAmmo = 0
Sound = 1
SoundRange = 900
Recoil = 1
RadiusDots = 12
RadiusLayerFirst = 120
RadiusColor = $FF8000
RadiusScale = 0.08
RadiusUpdateTicks = 4
RadiusEditSeconds = 60

[Weapons]
; The weapons file of the server for the trajectory and the aimbot: auto = configs/weapons.ini (or
; weapons.ini), in realistic mode configs/weapons_realistic.ini; files of older servers (speeds * 10)
; are read too. Without a file the weapons of Soldat 1.7.1 are used. When an admin loads another
; mod with the server's /loadwep <name>, the library reads configs/<name>.ini as well.
File = auto
RealisticFile = auto

[AntiCheat]
; Numbers worked out in basicext_dll from what the server sees. By default every player may look
; (so anybody can check whether somebody cheats) and /acclear is for admins; change it in [Permissions].
; /suspects [all] - the players of this game by suspicion (all: also the clean ones), with the
;   suspicion in this game and over all games of that computer;
; /acstats <player> - a table: every check in this game and over all games of that computer (kept
;   in data/basic-extended/players.bdb by the hardware id, so also for players without Steam);
; /acreview <player> - the last things noticed, newest first;
; /acclear <player|all> [all] - forget this game (all: also the history); /acclear all all -
;   everybody and the whole history.
; The lines are coloured: ColorTitle for the headers, ColorClean for nothing found, ColorNotice for a
; little, ColorFound for a lot.
; What is measured:
;  - start-up: a Barrett (or LAW) bullet that comes sooner after the fire key than the weapon's
;    StartUpTime allows, less StartUpSlack ticks (the key reaches the server with the movement packets,
;    up to 4 ticks late; a packet lost on the way can make one honest shot look short, so look at the
;    share: a cheat without start-up is short every time, so the suspicion counts three more shots than
;    were measured: one short start-up alone is 25%, not enough to tell the admins);
;  - fire rate: two bullets of a weapon with a long fire interval (20 ticks or more) closer together
;    than FireIntervalShare of it;
;  - ammo: the magazine emptied faster than the fire interval allows, or filled again sooner than the
;    reload time (read every WeaponCheckTicks; /give, /infammo, the aimbot and picked-up weapons are
;    left out);
;  - teleports: a living player who moved further than the game allows (11 px a tick on each axis)
;    between two looks at the positions (every PositionTicks), with JumpLagTicks of lag and JumpPixels
;    more; moves by this script (teleport, /bring, /goto, freeze, /speed, respawn, a joining player's
;    placing by ZitroStats) are left out for MovedGraceTicks, and so is everybody after a stall of the
;    server (the clock stood for a quarter of a second). A look in which most players jumped together
;    counts for nobody; a player's ping is added as lag (ticks), and above 400 ms the jumps are not judged;
;  - speed: more than SpeedPixels a tick on average over a second (running tops at about 4, jets and
;    falls at 11-15);
;  - hits under bink: hits by a weapon with bink (Barrett) fired within BinkTicks after the shooter was
;    hit while holding it - the game spreads those bullets widely, a no-bink cheat does not;
;  - hits while moving: hits by a weapon with movement inaccuracy (Barrett, Ruger) fired while running,
;    jumping or flying.
; Only hits are seen: the server tells the script nothing about bullets that miss. Every finding goes
; to data/basic-extended/<LogFile> (empty = none) with the ping, computer id and address; admins in the game are told
; when the player's suspicion reaches TellFromScore % (TellAdmins = 1), at most once every
; TellEverySeconds.
; VoteKick = 1: a vote to kick the player starts (with the reason, and a line to everybody saying what
; was found) when the suspicion reaches VoteFromScore % with at least VoteMinFindings findings in this
; game - not while another vote runs (also one of ZitroStats' map vote), not for admins, at most once every
; VoteEverySeconds per player.
Enabled = 1
SuspectsCommands = suspects
StatsCommands = acstats
ReviewCommands = acreview
ClearCommands = acclear
TellAdmins = 1
TellFromScore = 50
TellEverySeconds = 60
LogFile = anticheat.log
WeaponCheckTicks = 15
PositionTicks = 10
StartUpSlack = 7
FireIntervalShare = 0.85
JumpPixels = 40
JumpLagTicks = 10
MovedGraceTicks = 90
BinkTicks = 35
SpeedPixels = 16.5
VoteKick = 0
VoteFromScore = 70
VoteMinFindings = 3
VoteEverySeconds = 600
ColorTitle = $FFFFFF
ColorClean = $90E090
ColorNotice = $FFD040
ColorFound = $FF5050

[Permissions]
; Who may use a command and how it is typed. <command> = <who> [<how>]:
;   who: all (every player), admins (admins in the game; the server console and TCP admins always
;        may), console (only the server console or a TCP admin) or off (nobody; the words are free);
;   how: / (a command, nobody else sees it), ! (a chat line, everybody sees it) or both.
; Without a line a command stays as the script has it: the player commands for all with !, the
; admin commands for admins with /; suspects, acstats, acreview and the commands of the modules (ammo, mag,
; repack, ammohud, the grenade types, rocket, the team-kill votes, mine, claymore, mines, spot to bounty, pause,
; unpause, shop to sell, class to skill2, score, scores, c4, detonate, insurgents) for all with / and !; pm, r,
; pmmute, pmunmute, note and report for all with / only.
; The words themselves are set in the sections above.
; The names: commands rules maplist ratio ping track time whoisadmin calladmin join spec alpha bravo
; charlie delta hp dmg nextmap lastmap map radar medic info adminradar admincommands ip hwid ban
; banhwid banip killall kickall explodeall randomize reloadsettings status test bench steamadmin tele
; teletomouse flytomouse explode god heal slap freeze bring goto disarm give bonus trajectory aimbot
; bigexplode nuke statgun removestatgun infammo dmgfix dmgtaken vest suspects acstats acclear acreview
; speed sayas sayteam slay ammo mag repack ammohud be_prof grenadetype nade flash flashhelp rocket
; teamkill tkforgive tkpunish tkpoints tknextround tklist tkreset mine claymore mines minelist mineclear
; givemines spot bandage kit giveup bounty pm r pmmute pmunmute note report comments noteban noteunban
; notebanlist col colteam colp announce tmute tunmute mutelist pause unpause unbanlast banlist maplistadd
; maplistremove mapfind mappart warn shop buy money pay sell givemoney takemoney setmoney wallet
; moneyreset shoplist supplydrop class classes skill skill2 setclass score scores bansteam
; unbansteam steambans unbanname lag c4 detonate insurgents givevest takevest
; displayspawns createspawn removenearspawn removeallspawn editnearspawn testrespawn countspawns
; saveallspawns checkspawns spawnlayouts deletespawnlayout exportspawns
; (map is the players' ?map - the current map; mappart is the admins' /map <part of a name>.)
; test (/be_test <player id> <line or /command>) acts as that player: from the game it works for bots and for
; yourself only, and needs the right to the command yourself; as another player only from the server console.
; Examples:
;   aimbot = admins both      (/aimbot and !aimbot, !aim in the chat)
;   rules = all both          (!rules and /rules)
;   ratio = off
;   trajectory = console
; (adminradar is /radar of [Radar] Commands; the radar keeps its own rules of who may use which mode.)
aimbot = admins /
trajectory = admins /
tele = admins /
teletomouse = admins /
flytomouse = admins /
speed = admins /
sayas = admins /
sayteam = admins /
explode = admins /
bigexplode = admins /
nuke = admins /
explodeall = admins /
god = admins /
statgun = admins /
removestatgun = admins /
infammo = admins /
dmgfix = admins /
dmgtaken = admins /
vest = admins /
give = admins /
bonus = admins /
adminradar = admins /
suspects = all both
acstats = all both
acreview = all both

[MapGeometry]
; basicext_dll reads the walls of the map (MapFolder + map name + .pms, from the server folder) at every
; map change and casts the rays itself: the radar's view (seen), the trajectory, the aimbot, the
; realistic fog of war of the damage numbers. A ray costs the library about a microsecond, a script
; call to Map.RayCast much more, so the view is made with VisionRaysPerTick rays a tick (1-2000;
; [Radar] VisionRaysPerTick is used when the map cannot be read). /be_status shows whether the map was
; read and compares some rays with the server's own.
Enabled = 1
MapFolder = maps/
VisionRaysPerTick = 120

[MapsList]
; The maps list file of the server (from the server folder); it is shuffled when the script starts
; and by /randomize, and read again by /reloadsettings
File = mapslist.txt
ShuffleOnStart = 1

[Debug]
; 1 = bots get the health display, damage numbers and the radar too, and the lines to everybody are
; also written to the server console. The server sends no texts to bots, so this only runs that
; code on a test server without players (see /be_status).
BotsSeeTexts = 0
; 1 = the library hooks the server's CreateBullet and CreateThing: every shot and every weapon a soldier
; drops is known the moment the server makes it (the magazine shown drops with each shot, also with the
; reload key held; a dropped weapon keeps its magazines exactly). 0 = without the hooks the ammunition
; follows only the counts the game reports (a shot fired together with a reload is missed). The state
; is in /be_status (hooks: ...). Set to 0, a /reloadsettings takes them out of the server again.
ServerHooks = 1