From 1115e989ce7d639ab51e448fa52c5c21632b6dea Mon Sep 17 00:00:00 2001
From: Half-Shot <will@half-shot.uk>
Date: Thu, 9 Jan 2025 19:01:36 +0000
Subject: [PATCH] last bit of lint

---
 package.json                                  |  1 +
 src/entities/playable/remoteWorm.ts           |  2 +-
 src/frontend/components/app.tsx               |  1 -
 src/frontend/components/ingame-view.tsx       |  2 +-
 src/frontend/components/menu.tsx              |  3 +-
 src/frontend/components/menus/lobby.tsx       | 23 ++---
 src/frontend/components/menus/online-play.tsx |  2 +
 src/frontend/components/menus/team-editor.tsx |  7 +-
 src/levels/scenarioParser.ts                  |  7 ++
 src/logic/gamestate.ts                        |  3 +-
 src/net/client.ts                             | 81 ++++++++++++------
 src/net/models.ts                             | 13 ++-
 src/scenarios/grenadeIsland.ts                |  6 ++
 src/scenarios/netGame.ts                      | 85 +++++++++++--------
 src/scenarios/replayTesting.ts                |  3 +
 src/scenarios/tiledMap.ts                     |  5 +-
 src/scenarios/uiTest.ts                       |  3 +
 src/state/model.ts                            |  1 -
 src/state/player.ts                           |  9 +-
 src/weapons/schema.ts                         | 14 +--
 20 files changed, 160 insertions(+), 111 deletions(-)

diff --git a/package.json b/package.json
index 1944e38..962d52c 100644
--- a/package.json
+++ b/package.json
@@ -8,6 +8,7 @@
     "build": "tsc && vite build",
     "preview": "vite preview",
     "lint:eslint": "eslint src/",
+    "lint:eslint-fix": "eslint --fix src/",
     "test": "jest",
     "assets": "node scripts/generateAssetManifest.mjs > src/assets/manifest.ts",
     "lint:prettier": "prettier 'src/**/*.(ts|tsx|md)' '*.md' -c",
diff --git a/src/entities/playable/remoteWorm.ts b/src/entities/playable/remoteWorm.ts
index 8994ade..ffcf660 100644
--- a/src/entities/playable/remoteWorm.ts
+++ b/src/entities/playable/remoteWorm.ts
@@ -7,7 +7,7 @@ import { FireFn, Worm } from "./worm";
 import { StateWormAction } from "../../state/model";
 import Logger from "../../log";
 import { InnerWormState } from "./wormState";
-import Controller, { InputKind } from "../../input";
+import { InputKind } from "../../input";
 
 const logger = new Logger("RemoteWorm");
 
diff --git a/src/frontend/components/app.tsx b/src/frontend/components/app.tsx
index 31f0b3b..4fac40b 100644
--- a/src/frontend/components/app.tsx
+++ b/src/frontend/components/app.tsx
@@ -5,7 +5,6 @@ import { assetLoadPercentage, assetsAreReady } from "../../assets";
 import {
   NetClientConfig,
   NetGameClient,
-  NetGameInstance,
   RunningNetGameInstance,
 } from "../../net/client";
 import { GameReactChannel } from "../../interop/gamechannel";
diff --git a/src/frontend/components/ingame-view.tsx b/src/frontend/components/ingame-view.tsx
index 3bf1d67..7335cbd 100644
--- a/src/frontend/components/ingame-view.tsx
+++ b/src/frontend/components/ingame-view.tsx
@@ -1,7 +1,7 @@
 import { useEffect, useRef, useState } from "preact/hooks";
 import styles from "./ingame-view.module.css";
 import { Game } from "../../game";
-import { NetGameInstance, RunningNetGameInstance } from "../../net/client";
+import { RunningNetGameInstance } from "../../net/client";
 import { AmmoCount, GameReactChannel } from "../../interop/gamechannel";
 import { WeaponSelector } from "./gameui/weapon-select";
 
diff --git a/src/frontend/components/menu.tsx b/src/frontend/components/menu.tsx
index ec7acfb..45515aa 100644
--- a/src/frontend/components/menu.tsx
+++ b/src/frontend/components/menu.tsx
@@ -4,7 +4,6 @@ import styles from "./menu.module.css";
 import {
   NetClientConfig,
   NetGameClient,
-  NetGameInstance,
   RunningNetGameInstance,
 } from "../../net/client";
 import { GameMenu } from "./menus/types";
@@ -147,7 +146,7 @@ export function Menu({
     return (
       <menu className={styles.menu}>
         <MenuHeader onGoBack={goBack}>Team Editor</MenuHeader>
-        <TeamEditorMenu client={client} />
+        <TeamEditorMenu />
       </menu>
     );
   } else if (currentMenu === GameMenu.Settings) {
diff --git a/src/frontend/components/menus/lobby.tsx b/src/frontend/components/menus/lobby.tsx
index 90b63c3..4c4efa9 100644
--- a/src/frontend/components/menus/lobby.tsx
+++ b/src/frontend/components/menus/lobby.tsx
@@ -79,7 +79,13 @@ export function ActiveLobby({
   const [error, setError] = useState<string>();
 
   const membersMap = useObservableEagerState(gameInstance.members);
-  const members = useMemo(() => Object.entries(membersMap).sort(([uA], [uB]) => [uA, uB].sort().indexOf(uA)), [membersMap]);
+  const members = useMemo(
+    () =>
+      Object.entries(membersMap).sort(([uA], [uB]) =>
+        [uA, uB].sort().indexOf(uA),
+      ),
+    [membersMap],
+  );
   const proposedTeams = useObservableEagerState(gameInstance.proposedTeams);
   const [storedLocalTeams] = useLocalStorageState<StoredTeam[]>(
     WORMGINE_STORAGE_KEY_TEAMS,
@@ -115,8 +121,8 @@ export function ActiveLobby({
 
   const viableToStart = true;
 
-  // const viableToStart = useMemo(() => 
-  //   gameInstance.isHost && members.length >= 2 && proposedTeams.length >= 2 && 
+  // const viableToStart = useMemo(() =>
+  //   gameInstance.isHost && members.length >= 2 && proposedTeams.length >= 2 &&
   //     proposedTeams.reduce<Partial<Record<TeamGroup, number>>>((v, o) => ({
   //       ...v,
   //     [o.group]: (v[o.group] ?? 0) + 1
@@ -182,7 +188,8 @@ export function ActiveLobby({
                 }
                 const onRemoveTeam = () => removeTeam(t);
                 const incrementWormCount = () => {
-                  const newWormCount = t.wormCount >= MAX_WORMS ? 1 : t.wormCount + 1;
+                  const newWormCount =
+                    t.wormCount >= MAX_WORMS ? 1 : t.wormCount + 1;
                   gameInstance.addProposedTeam(t, newWormCount, t.group);
                 };
                 const changeTeamColor = () => {
@@ -216,10 +223,7 @@ export function ActiveLobby({
       </section>
 
       <section>
-        <button
-          onClick={() => onOpenIngame()}
-          disabled={!viableToStart}
-        >
+        <button onClick={() => onOpenIngame()} disabled={!viableToStart}>
           Start Game
         </button>
         <button onClick={() => exitToMenu()} disabled={gameInstance.isHost}>
@@ -236,7 +240,6 @@ export function Lobby({ client, gameRoomId, onOpenIngame, exitToMenu }: Props) {
 
   const clientState = useObservableEagerState(client.state);
 
-
   useEffect(() => {
     if (!gameInstance) {
       return;
@@ -256,7 +259,7 @@ export function Lobby({ client, gameRoomId, onOpenIngame, exitToMenu }: Props) {
       }
     });
     return () => s.unsubscribe();
-  }, [gameInstance])
+  }, [gameInstance]);
 
   useEffect(() => {
     if (clientState !== ClientState.Connected) {
diff --git a/src/frontend/components/menus/online-play.tsx b/src/frontend/components/menus/online-play.tsx
index c7f0081..336eb4f 100644
--- a/src/frontend/components/menus/online-play.tsx
+++ b/src/frontend/components/menus/online-play.tsx
@@ -184,6 +184,8 @@ export function OnlinePlayWithClient({
       // Client was logged out.
       NetGameClient.clearConfig();
       setClientConfig(null);
+      return null;
+      break;
     default:
       return (
         <div>
diff --git a/src/frontend/components/menus/team-editor.tsx b/src/frontend/components/menus/team-editor.tsx
index e233cf7..046d88c 100644
--- a/src/frontend/components/menus/team-editor.tsx
+++ b/src/frontend/components/menus/team-editor.tsx
@@ -1,14 +1,9 @@
 import useLocalStorageState from "use-local-storage-state";
-import { NetGameClient } from "../../../net/client";
 import { useCallback, useEffect, useRef, useState } from "preact/hooks";
 import { JSX } from "preact/jsx-runtime";
 import styles from "./team-editor.module.css";
 import { StoredTeam, WORMGINE_STORAGE_KEY_TEAMS } from "../../../settings";
 
-interface Props {
-  client?: NetGameClient;
-}
-
 const MAX_WORM_NAMES = 8;
 const MAX_TEAMS = 32;
 
@@ -165,7 +160,7 @@ export function TeamEditor({
   );
 }
 
-export default function TeamEditorMenu({ client }: Props) {
+export default function TeamEditorMenu() {
   const [localTeams, setLocalTeams] = useLocalStorageState<StoredTeam[]>(
     WORMGINE_STORAGE_KEY_TEAMS,
     {
diff --git a/src/levels/scenarioParser.ts b/src/levels/scenarioParser.ts
index 923adc0..0b88ea5 100644
--- a/src/levels/scenarioParser.ts
+++ b/src/levels/scenarioParser.ts
@@ -15,6 +15,7 @@ import {
 import { WormSpawnRecordedState } from "../entities/state/wormSpawn";
 import { Team, TeamGroup, WormIdentity } from "../logic/teams";
 import { IWeaponCode } from "../weapons/weapon";
+import { DefaultWeaponSchema } from "../weapons/schema";
 
 export const COMPATIBLE_TILED_VERSION = "1.11";
 const logger = new Logger("scenarioParser");
@@ -125,6 +126,8 @@ function determineRules(rules?: TiledGameRulesProperties): GameRules {
     logger.warning("No rules in level, assuming deathmatch");
     return {
       winWhenOneGroupRemains: true,
+      wormHealth: 100,
+      ammoSchema: DefaultWeaponSchema,
     };
   }
   rules["wormgine.end_condition"] ??= "Deathmatch";
@@ -135,10 +138,14 @@ function determineRules(rules?: TiledGameRulesProperties): GameRules {
       winWhenAllObjectsOfTypeDestroyed: Object.entries(EntityType).find(
         ([_k, v]) => v === obj,
       )?.[1],
+      wormHealth: 100,
+      ammoSchema: DefaultWeaponSchema,
     };
   } else if (rules["wormgine.end_condition"] === "Deathmatch") {
     return {
       winWhenOneGroupRemains: true,
+      wormHealth: 100,
+      ammoSchema: DefaultWeaponSchema,
     };
   }
   throw Error("Misconfigured rules object");
diff --git a/src/logic/gamestate.ts b/src/logic/gamestate.ts
index 29441d2..03816a9 100644
--- a/src/logic/gamestate.ts
+++ b/src/logic/gamestate.ts
@@ -11,7 +11,7 @@ export interface GameRules {
   roundDurationMs?: number;
   winWhenOneGroupRemains?: boolean;
   winWhenAllObjectsOfTypeDestroyed?: EntityType;
-  wormHealth: number,
+  wormHealth: number;
   ammoSchema: Record<IWeaponCode | string, number>;
 }
 
@@ -275,7 +275,6 @@ export class GameState {
     this.recorder.recordGameState({
       iteration: iteration,
       wind: this.currentWind,
-      nextTeam: this.activeTeam?.name!,
       teams: teams.map((t) => ({
         name: t.name,
         group: t.group,
diff --git a/src/net/client.ts b/src/net/client.ts
index bc800e5..6c1bdcc 100644
--- a/src/net/client.ts
+++ b/src/net/client.ts
@@ -11,7 +11,6 @@ import {
   ProposedTeam,
   GameProposedTeamEventType,
   GameActionEventType,
-  GameClientReadyEvent,
   GameClientReadyEventType,
 } from "./models";
 import { EventEmitter } from "pixi.js";
@@ -63,7 +62,7 @@ export enum ClientState {
 }
 export class NetGameInstance {
   private readonly _stage: BehaviorSubject<GameStage>;
-  public readonly stage: Observable<GameStage>
+  public readonly stage: Observable<GameStage>;
   private readonly _members: BehaviorSubject<Record<string, string>>;
   public members: Observable<Record<string, string>>;
   private readonly _proposedTeams: BehaviorSubject<
@@ -72,7 +71,7 @@ export class NetGameInstance {
   public readonly proposedTeams: Observable<ProposedTeam[]>;
   private readonly _rules: BehaviorSubject<GameRules>;
   public readonly proposedRules: Observable<GameRules>;
-  
+
   public readonly hostUserId: string;
   public readonly isHost: boolean;
 
@@ -112,7 +111,11 @@ export class NetGameInstance {
       }
       const stateKey = event.getStateKey();
       const type = event.getType();
-      if (stateKey && type === GameProposedTeamEventType && this._stage.value === GameStage.Lobby) {
+      if (
+        stateKey &&
+        type === GameProposedTeamEventType &&
+        this._stage.value === GameStage.Lobby
+      ) {
         const content = event.getContent() as ProposedTeam;
         if (Object.keys(content).length > 0) {
           this._proposedTeams.next({
@@ -165,7 +168,7 @@ export class NetGameInstance {
   }
 
   public async addProposedTeam(
-    proposedTeam: StoredTeam|ProposedTeam,
+    proposedTeam: StoredTeam | ProposedTeam,
     wormCount: number,
     teamGroup: TeamGroup = TeamGroup.Red,
   ) {
@@ -176,7 +179,10 @@ export class NetGameInstance {
         ...proposedTeam,
         group: teamGroup,
         wormCount,
-        playerUserId: "playerUserId" in proposedTeam ? proposedTeam.playerUserId : this.client.userId,
+        playerUserId:
+          "playerUserId" in proposedTeam
+            ? proposedTeam.playerUserId
+            : this.client.userId,
         // TODO: What should the proper stateKey be?
       },
       `${this.client.userId.slice(1)}/${proposedTeam.name}`,
@@ -193,19 +199,22 @@ export class NetGameInstance {
   }
 
   public async startGame() {
-    const teams: Team[] = Object.values(this._proposedTeams.value).map(v => ({
+    const teams: Team[] = Object.values(this._proposedTeams.value).map((v) => ({
       name: v.name,
       flag: v.flagb64,
       group: v.group,
       playerUserId: v.playerUserId,
       // Needs to come from rules.
       ammo: this._rules.value.ammoSchema,
-      worms: v.worms.slice(0, v.wormCount).map(w => ({
-        name: w,
-        health: this._rules.value.wormHealth,
-        maxHealth: this._rules.value.wormHealth,
-        uuid: globalThis.crypto.randomUUID(),
-      } satisfies WormIdentity)),
+      worms: v.worms.slice(0, v.wormCount).map(
+        (w) =>
+          ({
+            name: w,
+            health: this._rules.value.wormHealth,
+            maxHealth: this._rules.value.wormHealth,
+            uuid: globalThis.crypto.randomUUID(),
+          }) satisfies WormIdentity,
+      ),
     }));
     // Initial full state of the game.
     await this.client.client.sendStateEvent(this.roomId, GameStateEventType, {
@@ -390,16 +399,16 @@ export class NetGameClient extends EventEmitter {
     let stateEvents;
     try {
       stateEvents = await this.client.roomState(roomId);
-    } catch (ex) {
+    } catch {
       // TODO: Timeout.
-      await new Promise<void>((r) => room.on(RoomEvent.MyMembership, () => r()));
+      await new Promise<void>((r) =>
+        room.on(RoomEvent.MyMembership, () => r()),
+      );
       stateEvents = await this.client.roomState(roomId);
     }
-    
+
     const createEvent = stateEvents.find((s) => s.type === "m.room.create");
-    const stageEvent = stateEvents.find(
-      (s) => s.type === GameStageEventType,
-    );
+    const stageEvent = stateEvents.find((s) => s.type === GameStageEventType);
     const configEvent = stateEvents.find(
       (s) => s.type === GameConfigEventType,
     ) as unknown as GameConfigEvent;
@@ -445,14 +454,18 @@ export class NetGameClient extends EventEmitter {
       if (!fullStateEvent) {
         throw Error("In progress game had no state");
       }
-      return new RunningNetGameInstance(room, this, initialConfig, fullStateEvent["content"]);
+      return new RunningNetGameInstance(
+        room,
+        this,
+        initialConfig,
+        fullStateEvent["content"],
+      );
     }
 
     return new NetGameInstance(room, this, initialConfig);
   }
 }
 
-
 export class RunningNetGameInstance extends NetGameInstance {
   private readonly _gameState: BehaviorSubject<FullGameStateEvent["content"]>;
   public readonly gameState: Observable<FullGameStateEvent["content"]>;
@@ -466,8 +479,13 @@ export class RunningNetGameInstance extends NetGameInstance {
     return this.initialConfig.rules;
   }
 
-  constructor(room: Room, client: NetGameClient, private readonly initialConfig: NetGameConfiguration, currentState: FullGameStateEvent["content"]) {
-    super(room, client, initialConfig)
+  constructor(
+    room: Room,
+    client: NetGameClient,
+    private readonly initialConfig: NetGameConfiguration,
+    currentState: FullGameStateEvent["content"],
+  ) {
+    super(room, client, initialConfig);
     this._gameState = new BehaviorSubject(currentState);
     this.gameState = this._gameState.asObservable();
     client.client.on(RoomStateEvent.Events, (event, state) => {
@@ -493,17 +511,27 @@ export class RunningNetGameInstance extends NetGameInstance {
   }
 
   writeAction(data: StateRecordLine<unknown>) {
-    return this.client.client.sendEvent(this.roomId, GameActionEventType, { action: data });
+    return this.client.client.sendEvent(this.roomId, GameActionEventType, {
+      action: data,
+    });
   }
 
   async ready() {
-    return this.client.client.sendEvent(this.roomId, GameClientReadyEventType, { });
+    return this.client.client.sendEvent(
+      this.roomId,
+      GameClientReadyEventType,
+      {},
+    );
   }
 
   async allClientsReady() {
     const setOfReady = new Set<string>([
       this.myUserId,
-      ...this.room.getLiveTimeline().getEvents().filter(e => e.getType() === GameClientReadyEventType).map(e => e.getSender()) as string[],
+      ...(this.room
+        .getLiveTimeline()
+        .getEvents()
+        .filter((e) => e.getType() === GameClientReadyEventType)
+        .map((e) => e.getSender()) as string[]),
     ]);
 
     const expectedCount = Object.values(this.initialConfig.members).length;
@@ -520,4 +548,3 @@ export class RunningNetGameInstance extends NetGameInstance {
     });
   }
 }
-
diff --git a/src/net/models.ts b/src/net/models.ts
index a9ffca7..4d96dde 100644
--- a/src/net/models.ts
+++ b/src/net/models.ts
@@ -38,10 +38,10 @@ export interface GameStageEvent {
 
 export const GameActionEventType = "uk.half-shot.wormgine.game_action";
 export interface GameActionEvent {
-  type: typeof GameActionEventType,
+  type: typeof GameActionEventType;
   content: {
-    action: StateRecordLine<unknown>,
-  }
+    action: StateRecordLine<unknown>;
+  };
 }
 
 export const GameStateEventType = "uk.half-shot.wormgine.game_state";
@@ -104,11 +104,10 @@ export const GameProposedTeamEventType =
 export interface GameProposedTeamEvent {
   state_key: "";
   type: typeof GameProposedTeamEventType;
-  content: ProposedTeam | {};
+  content: ProposedTeam | Record<string, never>;
 }
 
-export const GameClientReadyEventType =
-  "uk.half-shot.uk.wormgine.ready";
+export const GameClientReadyEventType = "uk.half-shot.uk.wormgine.ready";
 export interface GameClientReadyEvent {
   type: typeof GameClientReadyEventType;
   // Need to decide on some config.
@@ -121,4 +120,4 @@ export interface GameStartEvent {
     bitmap_hash: string;
     // Need to decide on some config.
   } & GameConfigEvent["content"];
-}
\ No newline at end of file
+}
diff --git a/src/scenarios/grenadeIsland.ts b/src/scenarios/grenadeIsland.ts
index 3427027..382e0f5 100644
--- a/src/scenarios/grenadeIsland.ts
+++ b/src/scenarios/grenadeIsland.ts
@@ -15,6 +15,7 @@ import { Firework } from "../entities/phys/firework";
 import { Worm } from "../entities/playable/worm";
 import { DefaultTextStyle } from "../mixins/styles";
 import { IWeaponCode } from "../weapons/weapon";
+import { DefaultWeaponSchema } from "../weapons/schema";
 
 const weapons = ["grenade", "mine", "firework"];
 
@@ -74,6 +75,11 @@ export default async function runScenario(game: Game) {
       },
     ],
     world,
+    {
+      wormHealth: 100,
+      winWhenOneGroupRemains: true,
+      ammoSchema: DefaultWeaponSchema,
+    },
   );
 
   new GameStateOverlay(
diff --git a/src/scenarios/netGame.ts b/src/scenarios/netGame.ts
index 41005ae..70ce79b 100644
--- a/src/scenarios/netGame.ts
+++ b/src/scenarios/netGame.ts
@@ -26,7 +26,7 @@ import { RemoteWorm } from "../entities/playable/remoteWorm";
 import { logger } from "matrix-js-sdk/lib/logger";
 import { getDefinitionForCode } from "../weapons";
 
-const log = new Logger('scenario');
+const log = new Logger("scenario");
 
 export default async function runScenario(game: Game) {
   if (!game.level) {
@@ -106,22 +106,22 @@ export default async function runScenario(game: Game) {
   let endOfGameFadeOut: number | null = null;
   let currentWorm: Worm | undefined;
 
-  function applyEntityData() {
-    console.log("Applying entity state data");
-    for (const ent of player.latestEntityData) {
-      const existingEnt = world.entities.get(ent.uuid);
-      if (!existingEnt) {
-        throw new Error(
-          `Ent ${ent.uuid} ${ent.type} was not found during entity sync`,
-        );
-      } else if (existingEnt instanceof PhysicsEntity === false) {
-        throw new Error(
-          `Ent ${ent.uuid} ${ent.type} was unexpectedly not a PhysicsEntity`,
-        );
-      }
-      existingEnt.loadState(ent);
-    }
-  }
+  // function applyEntityData() {
+  //   console.log("Applying entity state data");
+  //   for (const ent of player.latestEntityData) {
+  //     const existingEnt = world.entities.get(ent.uuid);
+  //     if (!existingEnt) {
+  //       throw new Error(
+  //         `Ent ${ent.uuid} ${ent.type} was not found during entity sync`,
+  //       );
+  //     } else if (existingEnt instanceof PhysicsEntity === false) {
+  //       throw new Error(
+  //         `Ent ${ent.uuid} ${ent.type} was unexpectedly not a PhysicsEntity`,
+  //       );
+  //     }
+  //     existingEnt.loadState(ent);
+  //   }
+  // }
 
   const assets = getAssets();
   const level = await scenarioParser(game.level, assets.data, assets.textures);
@@ -154,7 +154,12 @@ export default async function runScenario(game: Game) {
       gameInstance.writeAction(data);
     },
   });
-  const gameState = new GameState(initialTeams, world, gameInstance.rules, gameInstance.isHost ? stateRecorder : undefined);
+  const gameState = new GameState(
+    initialTeams,
+    world,
+    gameInstance.rules,
+    gameInstance.isHost ? stateRecorder : undefined,
+  );
 
   const bg = await world.addEntity(
     Background.create(
@@ -219,7 +224,10 @@ export default async function runScenario(game: Game) {
   ) as WormSpawnRecordedState[];
   for (const team of gameState.getActiveTeams()) {
     for (const wormInstance of team.worms) {
-      log.info(`Spawning ${wormInstance.name} / ${wormInstance.team.name} / ${wormInstance.team.playerUserId} ${wormInstance.team.group}`, spawnPositions); 
+      log.info(
+        `Spawning ${wormInstance.name} / ${wormInstance.team.name} / ${wormInstance.team.playerUserId} ${wormInstance.team.group}`,
+        spawnPositions,
+      );
       const nextLocationIdx = spawnPositions.findIndex(
         (v) => v && v.teamGroup === wormInstance.team.group,
       );
@@ -258,22 +266,24 @@ export default async function runScenario(game: Game) {
         //   applyEntityData();
         //   return res;
         // },
-        wormInstance.team.playerUserId === myUserId ?
-        Worm.create(
-          parent,
-          world,
-          pos,
-          wormInstance,
-          fireFn,
-          overlay.toaster,
-          stateRecorder,
-        ) : RemoteWorm.create(
-          parent,
-          world,
-          pos,
-          wormInstance,
-          fireFn,
-          overlay.toaster)
+        wormInstance.team.playerUserId === myUserId
+          ? Worm.create(
+              parent,
+              world,
+              pos,
+              wormInstance,
+              fireFn,
+              overlay.toaster,
+              stateRecorder,
+            )
+          : RemoteWorm.create(
+              parent,
+              world,
+              pos,
+              wormInstance,
+              fireFn,
+              overlay.toaster,
+            ),
       );
       delete spawnPositions[nextLocationIdx];
       wormInstances.set(wormInstance.uuid, wormEnt);
@@ -297,7 +307,9 @@ export default async function runScenario(game: Game) {
     if (!currentWorm) {
       return;
     }
-    const newWep = currentWorm.wormIdent.team.availableWeapons.find(([w]) => w.code === code);
+    const newWep = currentWorm.wormIdent.team.availableWeapons.find(
+      ([w]) => w.code === code,
+    );
     if (!newWep) {
       throw Error("Selected weapon is not owned by worm");
     }
@@ -310,7 +322,6 @@ export default async function runScenario(game: Game) {
     }
   }
 
-
   const roundHandlerFn = (dt: Ticker) => {
     gameState.update(dt);
     if (endOfGameFadeOut !== null) {
diff --git a/src/scenarios/replayTesting.ts b/src/scenarios/replayTesting.ts
index c1a8744..43432a6 100644
--- a/src/scenarios/replayTesting.ts
+++ b/src/scenarios/replayTesting.ts
@@ -17,6 +17,7 @@ import { TextStateReplay } from "../state/player";
 import { RemoteWorm } from "../entities/playable/remoteWorm";
 import { EntityType } from "../entities/type";
 import { getDefinitionForCode } from "../weapons";
+import { DefaultWeaponSchema } from "../weapons/schema";
 
 export default async function runScenario(game: Game) {
   const parent = game.viewport;
@@ -38,6 +39,8 @@ export default async function runScenario(game: Game) {
   const gameState = new GameState(initialData.gameState.teams, world, {
     // TODO: Rules.
     winWhenOneGroupRemains: true,
+    wormHealth: 100,
+    ammoSchema: DefaultWeaponSchema,
   });
 
   // TODO: Background
diff --git a/src/scenarios/tiledMap.ts b/src/scenarios/tiledMap.ts
index 1e6c42f..e572937 100644
--- a/src/scenarios/tiledMap.ts
+++ b/src/scenarios/tiledMap.ts
@@ -84,7 +84,7 @@ export default async function runScenario(game: Game) {
   const recordedGameplayKey = `wormgine_recorded_${new Date().toISOString()}`;
   let recordedState = "";
 
-  const stateRecorder = new StateRecorder(world, gameState, {
+  const stateRecorder = new StateRecorder(world, {
     async writeLine(data) {
       recordedState += `${JSON.stringify(data)}|`;
       localStorage.setItem(recordedGameplayKey, recordedState);
@@ -260,7 +260,6 @@ export default async function runScenario(game: Game) {
     if (endOfRoundWaitDuration === null) {
       stateRecorder.syncEntityState();
       const nextState = gameState.advanceRound();
-      stateRecorder.recordGameStare();
       if ("winningTeams" in nextState) {
         if (nextState.winningTeams.length) {
           overlay.toaster.pushToast(
@@ -300,6 +299,4 @@ export default async function runScenario(game: Game) {
   game.pixiApp.ticker.add((dt) => camera.update(dt, currentWorm));
 
   game.pixiApp.ticker.add(roundHandlerFn);
-  stateRecorder.recordGameStare();
-  stateRecorder.syncEntityState();
 }
diff --git a/src/scenarios/uiTest.ts b/src/scenarios/uiTest.ts
index d4cc26f..1869823 100644
--- a/src/scenarios/uiTest.ts
+++ b/src/scenarios/uiTest.ts
@@ -2,6 +2,7 @@ import type { Game } from "../game";
 import { GameState } from "../logic/gamestate";
 import { TeamGroup } from "../logic/teams";
 import { GameStateOverlay } from "../overlays/gameStateOverlay";
+import { DefaultWeaponSchema } from "../weapons/schema";
 import { IWeaponCode } from "../weapons/weapon";
 
 export default async function runScenario(game: Game) {
@@ -103,6 +104,8 @@ export default async function runScenario(game: Game) {
     world,
     {
       winWhenOneGroupRemains: true,
+      wormHealth: 100,
+      ammoSchema: DefaultWeaponSchema,
     },
   );
 
diff --git a/src/state/model.ts b/src/state/model.ts
index 55ddb89..bade2aa 100644
--- a/src/state/model.ts
+++ b/src/state/model.ts
@@ -86,7 +86,6 @@ export type StateRecordWormGameState = StateRecordLine<{
     playerUserId: string | null;
     ammo: Team["ammo"];
   }[];
-  nextTeam: string;
   iteration: number;
   wind: number;
 }>;
diff --git a/src/state/player.ts b/src/state/player.ts
index 3695946..7177378 100644
--- a/src/state/player.ts
+++ b/src/state/player.ts
@@ -11,7 +11,6 @@ import {
   StateRecordWormGameState,
   StateRecordWormSelectWeapon,
 } from "./model";
-import { RunningNetGameInstance } from "../net/client";
 import { GameActionEvent } from "../net/models";
 import Logger from "../log";
 
@@ -26,7 +25,7 @@ interface EventTypes {
   gameState: [StateRecordWormGameState["data"]];
 }
 
-const log = new Logger('StateReplay');
+const log = new Logger("StateReplay");
 
 export class StateReplay extends EventEmitter<EventTypes> {
   protected lastActionTs = -1;
@@ -92,7 +91,7 @@ export class StateReplay extends EventEmitter<EventTypes> {
     this.lastActionTs = ts;
 
     log.info(`> ${data.ts} ${data.kind} ${data.index} ${data.data}`);
-    
+
     switch (data.kind) {
       case StateRecordKind.EntitySync:
         // TODO: Apply deltas somehow.
@@ -146,13 +145,13 @@ export class TextStateReplay extends StateReplay {
 }
 
 export class MatrixStateReplay extends StateReplay {
+  private prevPromise = Promise.resolve();
   constructor() {
     super();
   }
 
   public async handleEvent(content: GameActionEvent["content"]) {
-    let prevPromise = Promise.resolve();
-    prevPromise = prevPromise.finally(() =>
+    this.prevPromise = this.prevPromise.finally(() =>
       this.parseData(content.action).catch((ex) => {
         console.error("Failed to process line", ex);
       }),
diff --git a/src/weapons/schema.ts b/src/weapons/schema.ts
index 2d4b29a..280f7d6 100644
--- a/src/weapons/schema.ts
+++ b/src/weapons/schema.ts
@@ -1,10 +1,10 @@
 import { IWeaponCode } from "./weapon";
 
 export const DefaultWeaponSchema: Record<IWeaponCode, number> = Object.freeze({
-    [IWeaponCode.Bazooka]: -1,
-    [IWeaponCode.FireworkLauncher]: -1,
-    [IWeaponCode.Grenade]: -1,
-    [IWeaponCode.HomingMissile]: -1,
-    [IWeaponCode.Mine]: -1,
-    [IWeaponCode.Shotgun]: -1,
-});
\ No newline at end of file
+  [IWeaponCode.Bazooka]: -1,
+  [IWeaponCode.FireworkLauncher]: -1,
+  [IWeaponCode.Grenade]: -1,
+  [IWeaponCode.HomingMissile]: -1,
+  [IWeaponCode.Mine]: -1,
+  [IWeaponCode.Shotgun]: -1,
+});