Capture events¶

Configured in events.yml. Command: /events.

Events pull teams into the open. HCFCore ships nine kinds — KOTH, Citadel, Conquest, Kill the King, DTC, Last Break, Slide, Totem and Mini Totem — all defined in events.yml as data: a new KOTH or Citadel is a block of YAML, never a recompile.

/events                  # what runs and what is coming (aliases /event, /koth)
/events start <id>       # staff: open one now
/events stop <id>        # staff: end it with no winner

Starting and stopping needs hcfcore.events.admin. Ids are shared by every kind, so they must be unique across the file.

Scheduling: each event has an optional schedule — local times of day, read in the file's time-zone — at which it opens by itself, Kill the King aside: its times are shown and announced, and staff start it. The shipped examples have none: they wait for staff until you move them onto your map and give them times.

A restart ends a running event

Nothing about a running KOTH, Citadel, Conquest, Kill the King, DTC, Last Break, Slide or Totem is kept across a restart — except the King's items, which are always given back. A DTC or Last Break's core itself is not run state: it is a permanent block, placed and kept in the world, and a restart leaves it as its idle block (bedrock).

KOTH¶

King of the Hill. A team must hold the zone alone for the capture time — 10 minutes for the example (capture-seconds: 600).

events.yml — the shipped KOTH

koth:
  display-name: "{primary}KOTH"

  # The zone is the cuboid between the two corners, bounds included. Write the
  # corners in whichever order you walked them - they are normalised on load.
  world: world
  corner-1:
    x: 100
    y: 60
    z: 100
  corner-2:
    x: 115
    y: 90
    z: 115

  # Seconds of uninterrupted holding needed to win.
  capture-seconds: 600

  # What LOSING the zone does to the countdown:
  #   RESET - back to full. The classic, brutal behaviour: pushed off at
  #           nine minutes means starting over.
  #   PAUSE - freezes where it is and resumes for whoever holds next.
  # This changes how a KOTH plays more than any other single value here.
  #
  # Being contested is NOT losing the zone. An enemy standing in it freezes the
  # countdown and costs the holder nothing; the progress is only wiped (under
  # RESET) when the zone actually empties or another team takes sole control.
  # Otherwise one player touching the zone for a single tick would erase nine
  # minutes of work.
  contest-policy: RESET

  # While the zone is contested - another team in it with the holder:
  #   pause    - the countdown freezes until one team holds it alone again.
  #   continue - the team that held it keeps counting down as long as it is
  #              still in the zone: a challenger has to push it out.
  when-contested: pause

  # Hard stop for an event nobody manages to win. 0 = runs until someone does.
  # Must be at least capture-seconds, or the event could never be won; a
  # smaller value is refused on load and treated as 0.
  max-duration-seconds: 0

  # Remaining-time marks to broadcast, in seconds. Each fires once per attempt
  # and they are announced again after a RESET, so a fresh attempt gets its own
  # warnings. A mark at or above capture-seconds is ignored - it would fire the
  # instant the event opens.
  announce-at-seconds: [300, 120, 60, 30, 10]

  # Local times of day at which this event opens by itself, read in time-zone
  # above. Leave the list empty for an event only staff can open with
  # /events start <id>.
  #
  # Shipped empty: the zone above is an example, and an event that opens by
  # itself on a fresh server would announce a KOTH on land nobody has built.
  # Move the zone to your map, then give it its times, for instance:
  #   schedule: ["18:00", "21:00"]
  schedule: []

  # Console commands run on capture. Placeholders: %team%, %event%.
  # Rewards are team-scoped, matching the fact that a capture is credited to a
  # team - there is no %player% here on purpose.
  # The capture itself is always counted through the team module, which owns
  # the points-per-capture scale and the cap (see teams.yml, "koth").
  reward-commands: []

The zone is the box between the two corners, bounds included, written in any order.

Holding: one team alone in the zone runs its countdown down.
Contesting: an enemy in the zone — or a player with no team, by default (teamless-players-contest) — freezes the countdown without costing the holder anything (when-contested: pause, as shipped). With when-contested: continue, the holder keeps counting down as long as it is still in the zone: a challenger has to push it out, not merely step in. A teamless player can never hold a zone: capturing is a team act.
Allies contest each other: a capture belongs to one team.

Losing the zone — it empties, or another team takes sole control — is governed by contest-policy:

Policy	Losing the zone...
`RESET`	sends the countdown back to full. The classic, brutal rule: pushed off at nine minutes means starting over
`PAUSE`	freezes the countdown where it is; it resumes for whoever holds next

Announcements at remaining-time marks (announce-at-seconds), and when the zone becomes contested — once per change, never every tick, so a long brawl produces one message.
Hard stop: max-duration-seconds ends an event nobody manages to win (0 runs until someone does).

Winning: the capture is credited to the team — counted up to teams.yml's KOTH cap, and worth its points-per-capture — and the reward commands run from the console with %team% and %event%. There is no %player%: a capture belongs to a team.

Citadel¶

A Citadel is a KOTH with a much longer hold — 30 minutes in the example — fought inside a Citadel: a large area where the fight is decided by teams and classes, and where nobody gets away by throwing an item. It lives in its own section of events.yml, citadels:.

A Citadel has two zones:

Zone	What it is	How it is set up
The zone to hold	The box the team must hold alone, exactly as for a KOTH	`world`, `corner-1`, `corner-2` in `events.yml`
The Citadel	A large area around it, where the restrictions below apply	Server land: a server team's claim, named by `claim`

events.yml — the shipped Citadel

citadel:
  display-name: "{primary}Citadel"

  # The zone to hold, inside the Citadel.
  world: world
  corner-1:
    x: -200
    y: 60
    z: -200
  corner-2:
    x: -185
    y: 90
    z: -185
  capture-seconds: 1800
  contest-policy: RESET
  when-contested: pause
  max-duration-seconds: 0
  announce-at-seconds: [900, 600, 300, 60, 30, 10]
  # No schedule: staff open it with /events start citadel until you decide
  # when it should run.
  schedule: []
  reward-commands: []

  # The server team whose land is the Citadel.
  claim: Citadel

  # What the Citadel's land refuses.
  restrictions:
    # Throwing an ender pearl from inside.
    ender-pearls: true
    # Using a partner item (abilities.yml) inside.
    partner-items: true
    # Eating a chorus fruit - or any food that teleports - inside.
    chorus-fruit: true
    # Taking off with elytra inside; a player gliding in lands.
    elytra: true
    # Launching with a Riptide trident inside.
    riptide: true

The Citadel's land is its territory, drawn around the zone to hold with the claiming wand:

/events claim citadel             # makes the server team Citadel if it does not exist, then hands over the wand

A combat server team: players fight there, nobody builds, and /team map shows it. The console warns when a Citadel starts without its claim, or with its zone to hold outside it.

What the Citadel refuses¶

On the Citadel's land, at all times — whether the event runs or not:

Refused	Detail
Ender pearls	A pearl cannot be thrown from inside, so nobody pearls out of a lost fight
Partner items	The abilities of `abilities.yml` do nothing inside
Chorus fruit	Refused before it is eaten, so it is kept — any food that teleports as well
Elytra	Nobody takes off inside, and a player gliding in lands
Riptide tridents	A Riptide trident cannot be charged inside

Class abilities keep working: a Bard's buffs and bursts, an Archer's tag and dyed arrows, a Rogue's backstab — they are the point. Each restriction can be switched off in restrictions. The rest of the Citadel plays as a KOTH: contest policy, announcements, schedule, rewards, the hologram above the zone, and allies who may fight each other inside its zone to hold.

Conquest¶

The classic HCF Conquest: several zones — four in the example, Red, Blue, Green and Yellow — captured at the same time.

events.yml — the shipped Conquest

conquest:
  display-name: "{primary}Conquest"
  world: world

  # Seconds a team must hold a zone alone to score from it.
  capture-seconds: 30
  # What one capture of one zone is worth.
  points-per-capture: 1
  # The target: the first team to reach it wins.
  points-to-win: 250
  # Points a team loses when one of its members dies.
  death-penalty: 20

  # What losing a zone does to its countdown: RESET or PAUSE, as for a KOTH.
  contest-policy: RESET
  when-contested: pause

  # Hard stop with no winner, in seconds. 0 = runs until somebody wins.
  max-duration-seconds: 0

  # Local times at which it opens by itself; empty for staff only.
  schedule: []

  # Console commands run for the winner. Placeholders: %team%, %event%.
  reward-commands: []

  zones:
    red:
      display-name: "{error}Red"
      corner-1: {x: 300, y: 60, z: 300}
      corner-2: {x: 306, y: 70, z: 306}
    blue:
      display-name: "{primary}Blue"
      corner-1: {x: 340, y: 60, z: 300}
      corner-2: {x: 346, y: 70, z: 306}
    green:
      display-name: "{success}Green"
      corner-1: {x: 300, y: 60, z: 340}
      corner-2: {x: 306, y: 70, z: 346}
    yellow:
      display-name: "{warning}Yellow"
      corner-1: {x: 340, y: 60, z: 340}
      corner-2: {x: 346, y: 70, z: 346}

Each zone is captured like a small KOTH: held alone by one team, frozen while contested (or, with when-contested: continue, still counting for the holder), reset or paused when lost — on a short timer (30 seconds).
A capture ends nothing: it gives the holding team points (points-per-capture) and that zone's countdown starts again, so a team keeps scoring as long as it holds.
A member's death, anywhere, costs the team death-penalty points (20; never below zero).
The first team to points-to-win (250) wins, and its reward commands run with %team% and %event%.
One Conquest at a time.

The scoreboard shows %conquest_line% (the leading team and its points) and %conquest_zone_1% to %conquest_zone_4% (each zone's countdown).

Kill the King¶

A random player becomes the King. Everyone else hunts them.

The draw. A random online player in survival or adventure mode becomes the King — only among the active ones: a player idle for 5 minutes (no move, look, chat, command or click, reign.afk-seconds) is never drawn. At least 2 such players must be online (minimum-players), and players with hcfcore.events.king.exempt are never drawn. Staff start it (/events start <id>): its times in a schedule are shown and announced, never acted on.
The crowning. The King's items are put aside in the database and given back at the end. They receive the King's kit and effects (configurable: diamond armour, a sword, golden apples, pearls, Speed II and Resistance I in the example).
The hunt. They are sent to a random spot in the warzone of the event's world, on the surface, off claimed land. Everybody can find them: their position is on every scoreboard, redrawn every second (%king_location_line%), Lunar Client players see a waypoint on them, and once a minute the chat says where the King is and how much health they have left, as a percentage (announce-interval-seconds, 60; 0 turns the chat line off).

Two ways to play it (mode):

team (as shipped) — the King's team defends them against every other player. The winner's team scores points.per-king-win.
solo — everybody against the King, their own teammates and allies included, and the King may strike anybody back. No team scores: the prize is the winner's own, the reward commands — crate keys, money...

Nobody helps the King, in either mode: no Bard buff, no partner item, no potion thrown by anybody else — a splash of healing passes them by — and no beacon. The kit, and what they drink or eat themselves, is all they fight with. Harm still lands, an enemy Bard's debuff as much as a sword.

The arena is the warzone set in claims.yml — a world without a warzone cannot run the event, and the world must not have a bedrock ceiling (not the Nether).

The King's rules¶

While King, a player:

cannot leave the warzone — walking, a pearl, a chorus fruit, a teleport are refused — and sees its edge as a wall of red glass within 15 blocks, all round, as a player in combat sees spawn's (reign.wall). The old Wither for a King outside (outside-penalty) is off as shipped;
cannot enter spawn by any means — walking, pearls, chorus fruit, commands, portals;
cannot mount anything, drop items, open containers, use item frames and armour stands, or put an item in a block that holds one (a decorated pot, a shelf, a lectern, a campfire...) — the kit stays on the King;
cannot take off their armour — no click, drag or key swap on an armour slot, no right-click swap with another piece (reign.lock-armour);
keeps whatever they pick up. Only the kit is taken back at the end.

Who wins¶

The King, if alive when the time runs out (30 minutes, duration-seconds).
Otherwise, whoever kills the King — in team mode, unless that player was on the King's team when the King was crowned or killed (the King's allies are not excluded: the rule is strictly per team). In solo mode, anybody, teammates included.
Any other death — a fall, lava — ends the event with no winner.
A King who logs out ends the event with no winner and is banned for 2 hours (reign.quit-ban-seconds).

Reward commands run with %player% (the King or the killer) and %event%. Their own items come back: at once if they survive or the event is stopped, at respawn if they die, at their next login if they leave or the server goes down.

The King's death is the event's, not a real one (reign, as shipped): the kit vanishes with the reign — nobody picks it up (drop-kit: true makes it the killer's loot) — their team loses no DTR (death-costs-dtr) and the King is not deathbanned (deathban): they respawn and get their own items back. What they picked up during the reign falls as any loot. A King who logs out is not spared: leaving in combat is a combat log.

The scoreboard shows %king_line% — the King and the time left — and %king_location_line% — where the King is.

Called off?

The announcement says why: not enough eligible players online, no warzone in the event's world, or no safe spot found in it.

DTC (Destroy The Core)¶

A block core stands inside a zone. Teams break it, over and over — it reappears one tick later, every time, and stays in place after the run ends: it is permanent scenery for the next run, not a one-off objective. It is core.material (end stone) while the event runs and core.idle-material (bedrock) between runs, the way a Totem's column is — so a core nobody may break does not look breakable.

events.yml — the shipped DTC

dtc:
  display-name: "{primary}DTC"
  world: world
  corner-1: {x: 400, y: 60, z: 400}
  corner-2: {x: 420, y: 80, z: 420}
  # "material" is what the core is while the event runs; "idle-material" what it
  # stands as between runs - bedrock, as a Totem's column does.
  core: {x: 410, y: 65, z: 410, material: END_STONE, idle-material: BEDROCK}
  counter: SHARED
  breaks: 150
  break-cooldown-seconds: 1
  announce-at: [125, 100, 75, 50, 25, 10]
  max-duration-seconds: 0
  schedule: []
  reward-commands: []

Each team waits break-cooldown-seconds between its OWN breaks — never blocked by another team's. Set to 0 for no wait at all.

counter decides how the core is won:

`counter`	How it is won
`SHARED`	the core has `breaks` common health. When it reaches zero, the team with the most breaks of its own wins. A tie goes to whichever of them reached that count first
`PER_TEAM`	each team has its own count to `breaks`; the first to get there wins at once, whatever the others have

Announcements at remaining-count marks (announce-at) — remaining common health under SHARED, remaining-to-target for each team under PER_TEAM.
Hard stop: max-duration-seconds ends a DTC nobody wins (0 runs until someone does).
Creative, spectator and teamless players never break the core — this is not configurable.
DTC and Last Break share one run slot: only one of the two runs at a time — starting a DTC while a Last Break runs (or the reverse) is refused, naming whichever of the two is actually running. A KOTH, a Conquest, a Slide and a DTC (or a Last Break) can all run together — the families are independent.

The scoreboard shows %dtc_line% (common health, or the PER_TEAM leader) and %dtc_team_line% (your own team's breaks).

Last Break¶

The same engine as DTC, always common health: whichever team lands the break that empties the core wins — even with fewer breaks of its own than another team that hit it more often.

events.yml — the shipped Last Break

last-break:
  display-name: "{error}Last Break"
  world: world
  corner-1: {x: 450, y: 60, z: 400}
  corner-2: {x: 470, y: 80, z: 420}
  core: {x: 460, y: 65, z: 410, material: END_STONE, idle-material: BEDROCK}
  breaks: 150
  break-cooldown-seconds: 1
  announce-at: [125, 100, 75, 50, 25, 10, 5, 3, 2, 1]
  max-duration-seconds: 0
  schedule: []
  reward-commands: []

Everything else — the per-team cooldown, announcements, hard stop, the hardcoded rule that creative, spectator and teamless players never score, and sharing DTC's one run slot — is exactly as for DTC. The scoreboard shows %last_break_line%.

Slide¶

A zone where every team member present scores for their team.

events.yml — the shipped Slide

slide:
  display-name: "{success}Slide"
  world: world
  corner-1: {x: 500, y: 60, z: 500}
  corner-2: {x: 515, y: 75, z: 515}
  points-per-player: 1
  interval-seconds: 1
  death-penalty: 10
  announce-deaths: true
  points-to-win: 500
  announce-at: [100, 250, 400, 450]
  max-duration-seconds: 0
  schedule: []
  reward-commands: []

Every interval-seconds, each team member standing in the zone brings their team points-per-player — cumulative: three members in the zone score three times as fast as one.
A member's death, ANYWHERE on the server, while the Slide runs, costs the team death-penalty points (never below zero). announce-deaths: false mutes the broadcast — the points are always lost either way.
The first team to points-to-win wins. Several teams crossing it on the same tick hand it to whichever is highest; an exact tie changes nothing and the Slide keeps running.
Creative, spectator and teamless players never score — this is not configurable.
One Slide runs at a time.

The scoreboard shows %slide_line% (the leader) and the live top 3, %slide_top_1% to %slide_top_3%.

Totem and Mini Totem¶

A column of blocks in the event zone — 5 for a Totem, 3 for a Mini Totem. Between runs it is bedrock; when the event starts it turns to quartz.

events.yml — the shipped Totem

totem:
  display-name: "{warning}Totem"
  world: world
  corner-1: {x: 600, y: 60, z: 600}
  corner-2: {x: 620, y: 80, z: 620}
  base: {x: 610, y: 64, z: 610}
  height: 5
  material: QUARTZ_BLOCK
  broken-material: BEDROCK
  idle-material: BEDROCK
  # The items a block may be broken with; an empty list allows anything.
  tools: [WOODEN_SWORD, STONE_SWORD, COPPER_SWORD, IRON_SWORD, GOLDEN_SWORD, DIAMOND_SWORD, NETHERITE_SWORD]
  # false: a block is mined the whole way with the sword, taking the time the
  # game gives it (a few seconds for quartz). true: one hit breaks it at once.
  instant-break: false
  # RESET or RESET_AND_START - see above.
  rival-break: RESET
  # Announce every block broken; the start, a reset and the win are always announced.
  announce-breaks: true
  max-duration-seconds: 0
  schedule: []
  # Placeholders: %team%, %event%.
  reward-commands: []

Break it with a sword (tools, every sword by default) — mined the whole way, in the time the game gives the block (instant-break: true makes one hit enough). Each block your team breaks turns to bedrock and stays so.
The first team to break the whole column wins.
A block broken by any other team starts the totem over: every block turns back to quartz, and that team's progress counts for nothing (rival-break: RESET). With RESET_AND_START, that break is then the other team's first.
Creative, spectator and teamless players never break it. The column cannot be blown up or pushed by a piston, and outside a run only a staff member in creative can take it apart.
When the event ends — won, out of time, stopped — the column is bedrock again.
One Totem runs at a time.

The Mini Totem is the same event with height: 3:

events.yml — the shipped Mini Totem

mini-totem:
  display-name: "{warning}Mini Totem"
  world: world
  corner-1: {x: 650, y: 60, z: 600}
  corner-2: {x: 670, y: 80, z: 620}
  base: {x: 660, y: 64, z: 610}
  height: 3
  material: QUARTZ_BLOCK
  broken-material: BEDROCK
  idle-material: BEDROCK
  tools: [WOODEN_SWORD, STONE_SWORD, COPPER_SWORD, IRON_SWORD, GOLDEN_SWORD, DIAMOND_SWORD, NETHERITE_SWORD]
  instant-break: false
  rival-break: RESET
  announce-breaks: true
  max-duration-seconds: 0
  schedule: []
  reward-commands: []

The scoreboard shows %totem_line%: the team on its way and how many blocks it has broken.

The weekly schedule¶

/schedule (/planning) shows every event start of the next seven days — for everybody — as a window: one item per day, holding that day's events hour by hour. /schedule chat prints the same as a list, and weekly-schedule.menu.enabled: false makes the list the default. Each kind of event has its own colour — KOTH gold, Citadel purple, Kill the King red… (weekly-schedule.menu.colors) — so the week reads at a glance. It merges two sources:

each event's own daily times, its schedule key — the same every day;
the weekly schedule, weekly-schedule in events.yml: which event starts at what time on which day of the week. The plugin starts them itself, exactly as /events start would.

Kill the King is never started by the plugin: its times — daily or weekly — are shown in /schedule and announced, and staff start it with /events start <id>.

An event still running when a planned one starts — the 14:00 KOTH not over at 15:00 — is stopped with no winner and the planned one starts (weekly-schedule.overlap: replace, as shipped). skip does the opposite: the running event goes on and the planned one is not started. both lets them run together.

Staff edit the weekly schedule in game (hcfcore.events.admin), and the change applies at once:

/schedule add friday 20:00 koth          # every Friday at 20:00
/schedule add sat 18:00 conquest         # a day's first three letters work too
/schedule remove friday 20:00 [koth]     # everything at that time, or only that event

Every start — weekly or daily — is announced announce-before-minutes ahead (15, 5 and 1 minute as shipped). A start that is refused — the event already running, another of its kind running — is reported in the console and skipped. Nothing is caught up: a time that passes while the server is down is missed.

Setting up an event in game¶

Every kind of event — KOTH, Citadel, Kill the King, Conquest, DTC, Last Break, Slide, Totem, Mini Totem — is created, set up and deleted with the same commands, without touching events.yml by hand:

/events create <type> <id>      # a new event where you stand: koth, citadel, ktk, conquest, dtc, lastbreak, slide, totem, minitotem
/events info <id>               # what it has, what it lacks, and the command for each
/events claim <id>              # its territory, drawn with the claiming wand
/events unclaim <id> [all]      # release the claim of its territory you stand in, or all of it
/events setzone <id> [zone]     # its zone, drawn with the wand - a Conquest names the zone (a new name adds one)
/events delzone <id> <zone>     # delete one of a Conquest's zones
/events setblock <id>           # DTC/Last Break: the core; Totem: the column - on the block you look at
/events delete <id>             # the event, and its territory with it

An event is set up in up to three parts, and /events info ticks off each:

its territory — server land around it, the claims of a server team (a combat zone) named in the event's claim key. Nobody builds there, /team map shows it, and it is drawn with the claiming wand like any other claim: left-click a corner, right-click the other, sneak + left-click to claim. /events claim makes the server team when there is none yet — named after the event, last-break becoming LastBreak;
its zone — what is held, stood in or broken inside, with heights: drawn with the same wand, from the lower of the two clicked blocks to setup.zone-height blocks above the higher. A zone is a part of its event's claim: drawn past the territory's edge, the territory grows to hold it and setup.claim-margin blocks around it (setup.zone-claims-land) — land another team holds stays theirs, and what is left outside is pointed out;
its block — a DTC's or Last Break's core, a Totem's column (built at once, of bedrock), on the block you look at, up to setup.target-distance blocks away. It must be inside the zone.

Kill the King has none of the three: it is fought in the warzone of its world, and /events info says whether that world has one.

/events create does all of it at once, where you stand: the new event is a copy of the plugin's own example of its kind — the one shown on this page, with its capture time, its four Conquest zones... — moved so that its block (or the middle of its zone's floor) is on your position, with no schedule. Its server team is made, and its territory claimed: every zone and setup.claim-margin blocks around (10), unless setup.auto-claim is false or the land is taken — the command then says why. Then it shows /events info. From there, redraw what does not suit, give it its times (schedule: in events.yml), and try it with /events start <id>.

/events delete removes the event from events.yml, a Totem's column from the world, and releases its territory: the server team named in its claim is disbanded — unless another event names it too. None of the setup commands touches a running event: stop it first with /events stop <id>.

An <id> must be 2 to 32 characters of lowercase letters, digits, _ and - — a dot is refused, since events.yml is written through Bukkit's configuration API, which reads a dot in a key as a path separator; a bad id is reported rather than silently mangled. Typed in any case, it is lower-cased to match the shipped ids (koth, last-break...). Ids are shared by every kind: two events never have the same one.

These commands write events.yml

The /events setup commands are the only commands in HCFCore that ever rewrite a configuration file — and only the one section of the one event they name, never the rest of the file. Comments are kept; the layout becomes the server's own (quotes, lists one item per line). A file that does not parse is left untouched, and the command says it could not write. See Upgrading.

If a DTC's core or a Totem's column is not on server land, the console warns when the event loads — territory protection otherwise does not apply to it between runs. /events claim <id> fixes it.

Event signs¶

A won event leaves a sign, as a kill does: the event, who won it and the date — to the winner of Kill the King, or to every online member of the winning team (capture-signs in events.yml, lines in events.capture-sign of lang/en.yml). Placed, it keeps its text — written by the plugin, waxed, never editable.

Zone holograms¶

A hologram floats above every capture zone — KOTH, Citadel, each Conquest zone, a DTC or Last Break's core, a Slide's zone, and a Totem's column — for as long as it is configured (zone-holograms): while its event runs, its status; otherwise, when it runs next (or "not scheduled"). A DTC or Last Break shows its health (or, under PER_TEAM, the leader's breaks); a Slide shows its live top 3. Its texts are under events.hologram in lang/en.yml. Kill the King has no zone of its own, so no hologram. The hologram module (holograms.yml) must be enabled.

Friendly fire in events¶

Allies can hurt each other inside the zone of a running KOTH, Citadel, Conquest, DTC, Last Break, Slide or Totem, and on or by the King during Kill the King — where allied teams compete. See Combat.

Points¶

Winning also earns team points, all 0 by default: koth.points-per-capture for KOTH and Citadel, points.per-conquest-win, points.per-king-win, points.per-dtc-win, points.per-last-break-win, points.per-slide-win, points.per-totem-win.

Lunar Client¶

Lunar Client players see waypoints on KOTH, Citadel and Conquest zones, on a running DTC or Last Break's core, on a running Slide's zone, on a running Totem's column, and on the King during Kill the King. See Integrations.