# NoGoZones

Admins mark box-shaped zones in-game with their crosshair. Players can't enter a confirmed zone.
Confirmed zones stay marked on the ground: a rectangle over the zone's footprint with an X through
it, in the zone's color. Set `ShowZones` to `false` to hide them. Blocking works either way.

Built for CounterStrikeSharp **1.0.375** (`net10.0`) on Metamod:Source 2.0.0.1469. No other
dependencies.

## Install

Build with `cd plugins/NoGoZones && ../../build.sh`. Then copy the contents of `compiled/NoGoZones/`
to `game/csgo/addons/counterstrikesharp/plugins/NoGoZones/` on the server.

Or install a release, which unpacks into `game/csgo/`:

```
tar -xzf NoGoZones-<tag>.tar.gz -C /srv/cs2/game/csgo
```

To publish one, commit, bump `ModuleVersion`, then run `FORGEJO_TOKEN=... ./release.sh v<ModuleVersion>`.
It rebuilds the plugin from the committed source in the SDK container, tags HEAD, and uploads
`NoGoZones-<tag>.tar.gz` to the git.zio.sh release. The tarball contains no configs, so an upgrade
never touches the server's settings or zones.

Files the plugin writes, under `addons/counterstrikesharp/configs/plugins/NoGoZones/`:

- `NoGoZones.json`: settings. It's created with defaults on first load.
- `zones/<map>.json`: that map's zones, **one file per map**. It's easier to edit by hand than one
  combined file, and a broken edit only affects one map. Characters that aren't valid in a file
  name, including `/` from workshop map names, are replaced with `_`.

Zones for the current map are loaded on map start and enforced right away.

## Permission

Every command needs **`@css/root`**. In this server's rank groups, that means `#rank/owner`.
`css_zone_remove`, `css_zone_list` and `css_zone_reload` also work from the server console or RCON.

## Workflow

```
css_zone_start <name>        begin marking a zone (one session per admin, by SteamID)
css_zone_color <r> <g> <b>   optional, preview color (default red, 255 0 0)
css_zone_mark                x4: marks the point under your crosshair and draws a marker there
                             after the 4th: draws the box outline as a preview (nothing saved yet)
css_zone_height [units]      optional, after the 4th mark: set the box top and redraw the preview.
                             With a number: that many units above the lowest point.
                             With no argument: at your crosshair (aim at a tunnel roof's underside).
css_zone_confirm             save the box to this map's file and start blocking it
css_zone_cancel              discard the session and its preview instead
```

Managing saved zones:

```
css_zone_list                zones on the current map
css_zone_near                the 3 zones nearest to you, with distance and on/off state (finds a name to edit)
css_zone_remove <name>       delete a zone and stop blocking it
css_zone_active <name> <1|0> turn a zone on or off without deleting it (also on/off, true/false)
css_zone_reload              re-read this map's file (after editing it by hand)
```

If `css_zone_reload` hits invalid JSON, it logs the error and keeps the zones that were already
active. Several admins can mark different zones at once. A session ends on confirm, on cancel, when
its admin disconnects, or on map change.

## How the box is built

The plugin fits a plane through the 4 points. That decides the kind of zone:

**Floor zone.** The plane is closer to horizontal: you marked the zone's footprint on the ground.
- **X/Y:** the min and max of the points, axis-aligned. Mark the points in any order.
- **Z (height):**
  - The bottom is `BottomMargin` (8) below the lowest point.
  - The top is whichever is higher: `MinHeight` (128) above the lowest point, or `TopMargin` (16)
    above the highest point. That's taller than a crouch-jump.
- **Outline:** a rectangle with an X, flat, just above the lowest point.

**Wall zone.** The plane is closer to vertical: you marked a face, e.g. two points at the foot of a
tunnel mouth and two higher up its sides.
- **Shape:** a slab `WallThickness` (16) deep, turned to lie in that face. It doesn't need to line
  up with the map's axes.
- **Width:** the spread of the points along the face.
- **Height:** from `BottomMargin` below the lowest point up to the highest point.
- **Outline:** a rectangle standing on the face itself, with no X.
- **Fill:** the face is filled with dimmer horizontal lines, about every `FillSpacing` units, so it
  reads as a wall.
  - The lines scroll up at `FillScrollSpeed` units/s and wrap around. A negative value scrolls
    down, and 0 keeps them still.
  - With `FillPulse`, a brightness wave runs up them once every `PulsePeriod` seconds.
- **Sign:** a no-entry sign (a red disc with a white bar) sits in the middle, up to `SignSize`
  units across. The fill lines open a gap around it as they pass.

**Changing the top.** `css_zone_height` replaces the top for either kind. Use it to stop a floor
zone under a tunnel roof, or to raise a wall zone above where you could aim.

`NoGoZones.json` settings: `MinHeight`, `TopMargin`, `BottomMargin`, `WallThickness`, `DefaultColor` (`{"R":..,"G":..,"B":..}`),
`BeamWidth`, `FillSpacing` (12; 0 turns the fill off), `FillWidth` (4), `FillBrightness` (0.8), `FillScrollSpeed` (12), `FillPulse` (true), `PulsePeriod` (1.5),
`PulseMinBrightness` (0.6), `ShowSign`, `SignSize` (48),
`ShowZones` (default `true`: draw the rectangle with an X over each saved zone),
`IgnoreNoclip` (default `true`: noclipping players pass through).

Each zone in the file stores:
- `Points`: the 4 raw marks.
- The computed box: `Mins`/`Maxs`, `Yaw` and `IsWall`.
- `Color`.
- `Active`: `false` means the zone is kept but doesn't block or draw. It's set by
  `css_zone_active`, and older files without it count as active.

`Mins`/`Maxs` are in the zone's own frame, rotated by `Yaw` degrees about Z. For floor zones `Yaw`
is 0, so they're plain world coordinates. The blocker uses only the box, so a hand edit to it takes
effect after `css_zone_reload`. Editing `Points` doesn't recompute the box.

## Design decisions and API limitations

### Crosshair trace

This uses `Trace.TraceEndShape` from `CounterStrikeSharp.API.Modules.Utils` (native in 1.0.375),
with no Ray-Trace library.

- The ray runs from the eye (`AbsOrigin + ViewOffset.Z`) 8192 units along the view direction.
- It uses the mask `Masks.ShotBrushOnly` and ignores the admin's own pawn. So it hits world
  geometry, not players.
- The marked point is `HitPoint` if `HasExactHitPoint` is set, otherwise `EndPos`. CSS's
  `TraceResult` only guarantees the former when the engine reports an exact hit.

### Preview drawing: `env_beam` entities

The 1.0.375 source has **no debug-overlay or draw-line natives** at all. The only way to draw a line
in the world is a real `env_beam` entity (`CBeam`): set `Render` (color), `Width`, the start via
`Teleport` and `EndPos`, then `DispatchSpawn`. jRandomSkills already draws its trace beams this way
on this server.

- Each point marker is 3 beams: a small cross, plus a vertical line so it's visible from a
  distance.
- The box preview is 12 beams, one per edge.
- They're removed on confirm or cancel.
- A confirmed floor zone is drawn as 6 beams: a rectangle plus its two diagonals, flat over
  the footprint just above the floor.
- A wall zone stands on the marked face as a border, plus the fill lines and the sign. That's
  about 30–60 beams, depending on its height.
- Each fill line is two beams, either side of the sign, so a line can open a gap as it scrolls
  past the sign without spawning or removing beams.
- A 0.1 s timer moves the lines (`Teleport` for the start, `m_vecEndPos` for the end) and
  recolours them (`m_clrRender`). Every change is flagged with `SetStateChanged`, so clients
  receive it.
- That's about 10 network updates a second per fill beam: a few thousand entity updates a
  second across a map full of walls. Set `FillScrollSpeed` to 0 and `FillPulse` to false for
  static walls with no updates at all.
- The sign is beams too: a stack of overlapping horizontal rows forming the disc, with the middle
  rows split red/white/red for the bar. A real image would need a custom texture on every client,
  and clients only get that through a Workshop addon.
- The round restart removes spawned entities, so the outlines are redrawn at every round start.
  They're also redrawn after confirm, remove and reload.

**Limitation:** beams are ordinary networked entities, so **every player sees the preview and the
zone outlines**, not only admins. Hiding them from other players would need a `CheckTransmit` filter. That
isn't implemented.

### Blocking: per-tick movement block

**Why not a single custom-size solid:**

- `CCollisionProperty` exposes `Mins`, `Maxs`, `SolidType` and `SolidFlags` as writable schema
  fields, but CSS has **no native to rebuild an entity's physics shape** afterwards.
- CS2 player movement collides against the VPhysics shape built from the model at spawn, so
  writing the bounds doesn't make a wall.
- Brush entities get their shape from brush models compiled into the map, and those can't be
  created at runtime.

**Tried and removed (0.7.0–0.10.0): scaled `dev_cube` walls.**

These are the findings from live tests:

- A per-axis scale isn't possible. The Hammer-style `scales` keyvalue is ignored, and the scene
  node only has a single `m_flScale`.
- A uniform scale does scale the collision, and bullets pass through.

So a zone could be filled with overlapping uniformly scaled cubes. The problem is that a cube's
side is capped by the zone's thinnest dimension. That made thin walls either need hundreds of
cubes, or be thickened until they stuck out past the marked face. It was dropped in favour of
beams plus the per-tick block.

The per-tick block works like this. On every tick (`Listeners.OnTick`), for each living player:

1. Work in the zone's own frame, so turned wall zones use the same math. Grow the zone box by
   the player's own collision hull (`Collision.Mins`/`Maxs`, so crouching counts). For a turned
   zone, it grows by the hull's width along each of the zone's axes. Then check the player's origin against the grown box, which keeps the whole body out,
   not just the feet.
2. Sweep from last tick's origin to this tick's. If that step entered the box, move the player
   back just outside the face they crossed, and zero their velocity into that face. Movement
   along the face is kept, so players slide along the walls. Because the whole step is checked, a
   fast player (a speed skill, for example) can't skip through a thin zone between two ticks.
3. If a player is already inside (a zone confirmed on top of them, or a spawn inside one), push
   them out through the nearest face.

Tradeoffs compared with real collision:

- **It's corrected after the fact, not prevented.** The engine moves the player first, and the
  plugin puts them back in the same tick. Normally this looks like a wall, but under latency the
  client can predict a few units into the zone and then snap back. Expect a slight rubber-band
  feel at the edge, especially at high speed or with high ping.
- **Only players are blocked.** Bullets, grenades, the C4, chickens and physics props go straight
  through. Nothing is there for them to hit.
- **The top of a zone isn't a real floor.** A player on top is held up each tick but isn't
  "on ground" to the engine. They can stand there, but can't jump off it normally, and may show
  the falling animation. The 128-unit default height makes the top unreachable by jumping.
- **Cost:** it runs every tick, with a cost of players × zones box checks. That's negligible for
  realistic zone counts.

## Untested

This compiles against CSS 1.0.375. It has **not been run on the live server** yet. In-game, check:
- beam visibility and color
- how solid the wall feels, including at the edges and with speed skills
- whether players standing on top of a zone behave acceptably