Create : Tick Control

# Changelog

## 1.1.0

### Admin Web Dashboard + Tick Profiler

New embedded web dashboard for finding lag and managing the mod without leaving the game:

- **Tick profiler**: measures the full tick duration of *every* server-side block entity (Create, vanilla, other mods) via a single vanilla-ticker mixin. Zero overhead when idle (one boolean check); auto-activates while the dashboard is being polled and deactivates 60s after the last request. Aggregates per type, per chunk and per block position over a rolling 5s window. `/tickcontrol profile on|off|auto` overrides the auto mode.

- **World map & lag heatmap**: top-down per-chunk map (pan/zoom, dimension selector) showing loaded chunks (dark), ticking chunks (lighter), player positions with names, and lag-producing chunks colored on an absolute green→red scale (0.03ms → 8ms per server tick, log-interpolated — colors are comparable across time and dimensions). Hovering a chunk shows its total lag per server tick and block entity count; clicking lists every block entity inside with position, type, µs per server tick and effective tick frequency. Header shows total block entity lag for the dimension and the whole server. Loaded/ticking chunk sets and player markers come from a server-thread snapshot taken every 5s while the dashboard is open.

- **Server tick budget gauge**: stacked bar of the 50 ms tick budget — measured block entity cost (profiler), everything else (entities, chunks, mobs — MSPT minus BE cost), and the free headroom; turns red with an overflow segment when MSPT exceeds 50 ms. The base list header also shows what share of the actual server tick the bases represent, so per-base numbers can be read against a global, measurable reference.

- **Base detection & load distribution**: laggy chunks are clustered into "bases" (connected components with an adjustable merge distance: tight/normal/wide). A histogram card ranks each base by its total ms per server tick with its share of the whole server's block entity lag, chunk count and BE count; bar colors reuse the heatmap scale (average per-chunk intensity). Bases are outlined and labeled directly on the map (A, B, C… with their ms), and clicking a row centers/zooms the map on that base — switching dimension automatically if needed. Tiny isolated clusters are pooled into a "divers" row.

- **Per-type cost table**: ms/server-tick and µs/instance per block entity type, sortable — shows exactly which types deserve a divisor. Divisors can be set/reset per type directly from the table.

- **Controls**: global tick/sync divisors, emergency pause/resume/reset, live TPS/MSPT/divisor header.

- **Server**: `com.sun.net.httpserver` (JDK built-in, no dependencies), disabled by default. Config section `web`: `enabled`, `port` (8785), `bindAddress` (default `127.0.0.1` — keep it local and use an SSH tunnel/reverse proxy; set a `token` if you must expose it), plus `/tickcontrol web start|stop|status`. Settings changes require the token when one is configured; all writes are scheduled onto the server thread.

### Permissions

- Registered two nodes through the NeoForge PermissionAPI (usable in LuckPerms and compatible permission mods): `createtickcontroller.lagmap` for `/lagmap` (default: everyone) and `createtickcontroller.admin` for `/tickcontrol`, `/tc` and `/tickcontrol panel` (default: OP level 2). Console/command blocks fall back to vanilla levels. The nodes are documented in the new `permissions` config section, which also has an `allowLagmap` master switch to disable the player command entirely.

### Player access to the visualizer

- **`/lagmap`** (all players): generates a clickable link with a 60-minute read-only session key — map, heatmap, base histogram, ship markers, per-type and per-chunk costs, but no controls (the control panel, token field and divisor buttons are hidden; writes are rejected server-side). Lets players find and optimize their own laggy builds.

- **`/tickcontrol panel`** (admins): same, but the 60-minute key grants the full admin panel.

- All dashboard reads now require a valid session key, the permanent config token, or a loopback connection (local admin keeps keyless access). Expired keys get a clear "refais /lagmap" message. New config `web.publicUrl` sets the base URL used in the links (e.g. `http://play.myserver.com:8785`) for servers behind NAT/proxy; sessions are cleared when the dashboard stops.

### Sable / Create Aeronautics ship tracking

- When Sable is installed, the dashboard detects loaded sub-levels (ships) via reflection on Sable's API (no hard dependency; auto-disables on API mismatch). Ships appear on the map as yellow diamond markers at their real world position, refreshed every second so they can be watched flying, labeled with their name and the lag their machinery produces — computed by summing the measured lag of their plot chunks. Hovering shows position, lag and plot bounds; clicking jumps the map to the ship's plot (where its block entities actually tick). Lag clusters inside a ship's plot are automatically renamed "⛵ <ship>" in the base histogram, so ships rank alongside ground bases in the load distribution.

- Note: sub-level block entities were already throttled and profiled — Sable stores ship blocks in real chunks of the parent level and ticks them through the vanilla path. `/tickcontrol inspect <type>` now shows per-instance measured tick rates (green = matches the divisor) to verify this in game, including aboard ships.

### Sophisticated Storage compatibility

- When Sophisticated Storage is installed, its block entities are throttled by the same global/per-type divisor system as Create's (config toggle `compat.sophisticatedStorage`, on by default; no effect when the mod is absent). Covered: Storage Controller, Storage Link, Storage I/O, Storage Input, Storage Output, and the upgraded containers (barrels, chests, shulker boxes, limited barrels — these only tick when holding a ticking upgrade such as hopper/magnet/compacting, and are the mod's real tick consumers). Matching is done on fully-qualified class names through the vanilla ticker mixin, so no other mod can be affected. These types work with `/tickcontrol type <name> <divisor>`, the blacklist, and the dashboard's per-type table like any Create type. The dashboard now also marks unmanaged types (neither Create nor compat) with "—" instead of showing a divisor that doesn't apply to them.

### Fixes

- **Stale stock ticker screens**: the logistics SUMMARIES cache TTL is now capped at 100 ticks (5s). It previously scaled unbounded with the divisor — under an emergency divisor of 16 the stock list could lag 16 seconds behind, showing missing or ghost items.

## 1.0.8

### Deep-audit fixes (busy-state bypasses)

Following the piston fix, the same "never throttle while busy" rule was applied to every block entity whose correctness (not just speed) breaks when ticks are skipped:

- **Bearings (Mechanical, Windmill, Clockwork)**: assembly/disassembly commands are processed inside `tick()` (`assembleNextTick`) — a short redstone pulse could be swallowed before the next allowed tick, leaving the bearing unable to start or stop. Bearings now tick at full rate whenever a speed change is pending or they are powered but not yet running. Steady rotation stays throttled (the client already smooths it).

- **Gantry Carriage**: same pending-assembly rule; the moving gantry contraption itself is an entity and was never affected by throttling.

- **Portable Storage Interface**: no longer throttled while exchanging with a contraption (`transferTimer`/`keepAlive`) — throttling stretched transfers 4× and desynced timed train stops.

- **Crushing Wheels**: no longer throttled while occupied — `tick()` holds the crushed entity and applies suction every tick, but gravity runs at full rate, so items and mobs could fall through the wheel gap uncrushed.

- **Encased Fan**: no longer throttled while entities ride the air stream — push force is applied per fan tick against full-rate gravity, so throttled fans could no longer lift items or mobs (item elevators dropped their cargo). Belt/depot processing under the stream stays throttled.

### Sync divisor correctness

- **Suppressed syncs are now deferred, not dropped**: with a sync divisor active, a suppressed `sendData()` was discarded entirely — a block entity that calls `notifyUpdate()` once for a one-shot state change would never reach clients (permanent visual desync until a chunk reload). Suppressed syncs are now queued and flushed on the block entity's next sync slot (delayed by at most `syncDivisor` ticks, never lost).

### Default blacklist additions

- **Pulse Repeater / Pulse Extender / Pulse Timer**: tick-based redstone timing; throttling silently multiplied every configured delay.

- **Smart Observer**: scans belt items crossing its detection window every tick; throttled scans miss fast-moving items entirely, breaking counting and sorting circuits.

### Minor

- Brass Tunnel statistics are no longer double-counted (its `super.tick()` re-entered the Belt Tunnel throttle check).

### Mechanical Piston / Rope Pulley / Elevator Pulley fixes

- **Pistons failing to retract and stuttering animation under throttling**: linear actuators (Mechanical Piston, Rope Pulley, Elevator Pulley) are no longer throttled while they are *busy* — running, holding a contraption, having a pending speed change (`assembleNextTick`), or receiving non-zero rotation. Two root causes required this:

  - Speed changes are processed inside `tick()` (`assembleNextTick` → assemble/disassemble). With ticks skipped, a short reversal pulse could expire before the next allowed tick and be swallowed entirely — the piston never started retracting.

  - While moving, the server advanced the contraption in full steps on 1-in-N ticks, while the vanilla entity tracker synced those bursty positions to the client every tick, fighting the client's smoothed simulation — visible stutter that (unlike belts) cannot be smoothed client-side.

  Idle actuators (no contraption, zero speed) are still throttled; that is where the tick savings were anyway, since busy actuator ticks (collision checks) were the expensive part and are also the correctness-critical part. The client-side speed-scaling mixins (`LinearActuatorBlockEntityClientMixin`, `ElevatorPulleyBlockEntityClientMixin`) are removed accordingly — while an actuator moves, both sides now tick at full vanilla rate, so movement and animation are exactly vanilla.

### Removed

- **Dynamic TPS formula system**: the formula-based divisor (`dynamic` config section, `FormulaEvaluator`) has been removed. The emergency MSPT system is now the only automatic adjustment and remains enabled by default. Existing config files keep working; the obsolete `dynamic` section is ignored and cleaned up by NeoForge on next save.

### Fixes

- **Manual divisor no longer silently overwritten**: the emergency system now applies its divisor as a separate *overlay*. The effective global divisor is `max(manual, emergency)`. Previously, setting `/tickcontrol global tick 4` on a lagging server could be silently replaced by the emergency value (e.g. 16+ within seconds, since it ramps +2 every 10 ticks above 55 ms MSPT and holds due to hysteresis), and on recovery the divisor was reset to 1, erasing the manual setting entirely — this is what made a "÷4" setup behave like "÷16" on some block entities (types with per-type divisors were unaffected, making the issue look block-entity-specific). Now the emergency overlay rises and falls independently, and recovery settles back exactly on the manual value.

- **Blacklist synced to clients**: the server blacklist is now included in the sync packet. Previously the client applied the global divisor to *all* types when computing animation speed multipliers, so blacklisted block entities (which tick at full speed on the server) had their animations slowed anyway — e.g. a Sequenced Gearshift rotating 4× slower visually while operating at normal speed.

### Commands

- `/tickcontrol dynamic ...` is replaced by `/tickcontrol emergency [pause|resume|reset]`. `emergency reset` clears only the overlay and leaves the manual global divisor untouched.

- `/tickcontrol status` now shows the effective divisor with a breakdown (`[manual N + emergency M]`) when the emergency overlay is raising it.