feat: add STF to replay/validate game

- remove sounds
- downloads ticks after a game is over

Author: 0xRampey

client/game/gameMode.ts

@@ -20,7 +20,6 @@ export class GameMode extends EventSource implements IGameState {
     }
 
     init() {
-        Sound.on();
         this.world.addShip(WIDTH/2, HEIGHT/2);
         this.world.startLevel();
         this.thumper = new Thumper();

client/game/rocks.ts

@@ -1,4 +1,4 @@
-import { Screen, OBJECT_SCALE } from './screen';
+import { Screen, OBJECT_SCALE, WIDTH, HEIGHT } from './screen';
 import { Object2D } from './object2d';
 import { Vector } from './vector';
 import { random, randomFloat } from './util';
@@ -124,9 +124,9 @@ export class Rock extends Object2D {
                 break;
         }
 
-        const rate = randomFloat(.7, 1);
-        sound.rate(rate);
-        sound.play();
+        // const rate = randomFloat(.7, 1);
+        // sound.rate(rate);
+        // sound.play();
 
         if (this.size > RockSize.Small) {
 
@@ -182,20 +182,20 @@ export function createRocks(level: number): Rock[] {
 
         switch (zone) {
             case 1:
-                x = random(offset, screen.width - offset); 
+                x = random(offset, WIDTH - offset); 
                 y = random(offset, offset * 2); 
                 break;
             case 2:
-                x = random(screen.width - (offset * 2), screen.width - offset);
-                y = random(screen.height - offset, screen.height - offset);
+                x = random(WIDTH - (offset * 2), WIDTH - offset);
+                y = random(HEIGHT - offset, HEIGHT - offset);
                 break;
             case 3:
-                x = random(offset, screen.width - offset);
-                y = random(screen.height - offset, screen.height - offset); 
+                x = random(offset, WIDTH - offset);
+                y = random(HEIGHT - offset, HEIGHT - offset); 
                 break;
             default:
                 x = random(offset, offset * 2);
-                y = random(screen.height - offset, screen.height - offset);
+                y = random(HEIGHT - offset, HEIGHT - offset);
                 break;
         }
 

client/game/ship.ts

@@ -147,13 +147,13 @@ export class Ship extends Object2D {
             this.flame.velocity = this.velocity;
         }
 
-        thrust.play();
+        // thrust.play();
     }
 
     private fire() {
         if (this.bulletTimer <= 0 && this.bulletCount < MAX_BULLETS) {
 
-            fire.play();
+            // fire.play();
 
             this.bulletTimer = BULLET_TIME;
             this.bulletCount++;

client/game/thump.ts

@@ -34,9 +34,9 @@ export class Thumper {
 
         if (this.thumpBeatTimer >= this.thumpBeat) {
             if (this.lo) {
-                thumpLo.play();
+                // thumpLo.play();
             } else {
-                thumpHi.play();
+                // thumpHi.play();
             }
 
             this.lo = !this.lo;

client/game/tickRecorder.ts

@@ -47,5 +47,14 @@ export class TickRecorder {
 
     public sendTicks() {
         console.log(`Found about ${this.ticks.length} ticks to send`);
+    const data = JSON.stringify(this.ticks, null, 2);
+    const blob = new Blob([data], { type: 'application/json' });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = 'ticks.json';
+    a.click();
+    URL.revokeObjectURL(url);
+    console.log('Ticks successfully saved to disk.');
     }
 }

client/game/world.ts

@@ -214,7 +214,7 @@ export class World {
 
     shipDestroyed() {
         if (this.ship) {
-            largeExplosion.play();
+            // largeExplosion.play();
             this.createExplosion(this.ship);
             this.addFlash(5);
             this.ship.destroy();
@@ -288,19 +288,19 @@ export class World {
             this.alien = new BigAlien();
         }
 
-        alienSound.play();
+        // alienSound.play();
 
         this.alien.on('expired', () => {
-            alienFire.stop();
-            alienSound.stop();
-            largeExplosion.play();
+            // alienFire.stop();
+            // alienSound.stop();
+            // largeExplosion.play();
             this.alien = null;
             this.alienBullets.forEach(b => b.destroy());
             this.alienBullets.length = 0; 
         });
 
         this.alien.on('fire', (alien, bullet: Bullet) => {
-            alienFire.play();
+            // alienFire.play();
 
             bullet.on('expired', () => {
                 this.alienBullets = this.alienBullets.filter(x => x !== bullet);
@@ -322,14 +322,14 @@ export class World {
         if (this.extraLifeScore >= EXTRA_LIFE) {
             this.lives++;
             this.extraLifeScore -= EXTRA_LIFE;
-            extraLife.play();
+            // extraLife.play();
         }
 
         this.addScenery(new ScoreMarker(obj, `${obj.score}`));
     }
 
     addPowerup() {
-        getPowerup.play();
+        // getPowerup.play();
     }
 
     shake() {

rollup/.env.example

@@ -1,8 +1,9 @@
 import { ActionSchema, AllowedInputTypes, MicroRollup } from "@stackr/sdk";
 import { HDNodeWallet, Wallet } from "ethers";
 import { stackrConfig } from "./stackr.config";
-import { TickActionSchema } from "./stackr/action";
+import { ValidateGameSchema } from "./stackr/action";
 import { machine } from "./stackr/machine";
+import { ValidateGameInput } from "./stackr/transitions";
 
 const wallet = Wallet.createRandom();
 
@@ -22,25 +23,42 @@ const signMessage = async (
 const main = async () => {
   const mru = await MicroRollup({
     config: stackrConfig,
-    actionSchemas: [TickActionSchema],
+    actionSchemas: [ValidateGameSchema],
     stateMachines: [machine],
   });
 
   await mru.init();
 
-  // const inputs = {
-  //   timestamp: Date.now(),
-  // };
+  const filePath = './ticks2.json';
+  const fs = require('fs').promises;
 
-  // const signature = await signMessage(wallet, TickActionSchema, inputs);
-  // const incrementAction = TickActionSchema.actionFrom({
-  //   inputs,
-  //   signature,
-  //   msgSender: wallet.address,
-  // });
+  let jsonData;
 
-  // const ack = await mru.submitAction("increment", incrementAction);
-  // console.log(ack);
+  try {
+    const data = await fs.readFile(filePath, 'utf8');
+    jsonData = JSON.parse(data);
+  } catch (error) {
+    console.error('Error reading or parsing the file:', error);
+    return null;
+  }
+
+  console.log("Found", jsonData.length, "ticks")
+
+  const inputs = {
+    gameId: 1,
+    timestamp: 1,
+    inputs: jsonData,
+  };
+
+  const signature = await signMessage(wallet, ValidateGameSchema, inputs);
+  const incrementAction = ValidateGameSchema.actionFrom({
+    inputs,
+    signature,
+    msgSender: wallet.address,
+  });
+
+  const ack = await mru.submitAction("validateGame", incrementAction);
+  console.log(ack);
 };
 
 main();

rollup/REAMDE.md renamed to rollup/README.md

@@ -1,14 +1,16 @@
 import { ActionSchema, SolidityType } from "@stackr/sdk";
 
-export const TickActionSchema = new ActionSchema("tick", {
+export const ValidateGameSchema = new ActionSchema("validateGame", {
   gameId: SolidityType.UINT,
   timestamp: SolidityType.UINT, // nonce
   // Keypresses mapped to action inputs
-  wasHyperspace: SolidityType.BOOL,
-  isRotateLeft: SolidityType.BOOL,
-  wasRotateLeft: SolidityType.BOOL,
-  isRotateRight: SolidityType.BOOL,
-  wasRotateRight: SolidityType.BOOL,
-  isThrust: SolidityType.BOOL,
-  isFire: SolidityType.BOOL,
+  inputs: [
+    {wasHyperspace: SolidityType.BOOL},
+    {isRotateLeft: SolidityType.BOOL},
+    {wasRotateLeft: SolidityType.BOOL},
+    {isRotateRight: SolidityType.BOOL},
+    {wasRotateRight: SolidityType.BOOL},
+    {isThrust: SolidityType.BOOL},
+    {isFire: SolidityType.BOOL},
+  ],
 });

rollup/index.ts

@@ -1,32 +1,27 @@
 import { State, StateMachine } from "@stackr/sdk/machine";
 import { solidityPackedKeccak256 } from "ethers";
+import {World} from "../../client/game/world" 
 
 import { transitions } from "./transitions";
 import genesisState from "../genesis-state.json";
 
-interface World {
-  time: number;
-  x: number;
-  y: number;
-}
-
 export class WorldState extends State<World> {
   constructor(state: World) {
     super(state);
   }
 
   getRootHash() {
     return solidityPackedKeccak256(
-      ["uint", "uint", "uint"],
-      [this.state.time, this.state.x, this.state.y]
+      ["string"],
+      ["test"]
     );
   }
 }
 
 const machine = new StateMachine({
   id: "worldEngine",
   stateClass: WorldState,
-  initialState: genesisState.state,
+  initialState: new World(0),
   on: transitions,
 });
 

rollup/stackr/action.ts

@@ -1,15 +1,36 @@
 import { STF, Transitions } from "@stackr/sdk/machine";
 import { WorldState } from "./machine";
+import {GameMode} from "../../client/game/gameMode";
+import {World} from "../../client/game/world";
 
-const tick: STF<WorldState> = {
+
+export type ValidateGameInput = {
+  gameId: number,
+  timestamp: number, // nonce
+  // Keypresses mapped to action inputs
+  inputs: [
+    {wasHyperspace: boolean},
+    {isRotateLeft: boolean},
+    {wasRotateLeft: boolean},
+    {isRotateRight: boolean},
+    {wasRotateRight: boolean},
+    {isThrust: boolean},
+    {isFire: boolean},
+  ],
+};
+
+const validateGame: STF<WorldState, ValidateGameInput> = {
   handler: ({ state, inputs }) => {
-    state.time = inputs.timestamp;
-    state.x = inputs.x;
-    state.y = inputs.y;
+    let world = new World(0);
+    let gameMode = new GameMode(world);
+    for (const input of inputs.inputs) {
+      gameMode.update(1/60, input);
+    }
+    console.log("New score: ", world.score)
     return state;
   },
 };
 
 export const transitions: Transitions<WorldState> = {
-  tick,
+  validateGame,
 };