feat(api): Implements Game.postUndoCommand

src/agents/agent-revert.ts

@@ -0,0 +1,35 @@
+import { EventRecord, noop, on } from "../events";
+import { Agent } from "./agent-model";
+import { AgentRecord } from "./agent-record";
+import { InstanceAgents, propertyIsAgentId } from "./instance-agents";
+
+// TODO - test more completely; especially with static agents
+
+export const buildRevertFunction = (agents: InstanceAgents) => {
+    const agentKeys = Object.keys(agents).filter(propertyIsAgentId);
+    const agentRecords = agentKeys.map(key => agents[key] as AgentRecord);
+
+    return on("REVERT", game => {
+        const target = game.agents;
+
+        agentRecords.forEach(record => {
+            const recordKeys = Object.keys(record);
+            const id = record.getProperty("_id");
+
+            const agent = new Agent(id, target.game);
+
+            recordKeys
+                .filter(key => key !== "game" && key !== "_id")
+                .forEach(key => {
+                    const changelog = record[key];
+                    if (changelog.length > 1) {
+                        const firstValue =
+                            changelog[changelog.length - 1].final;
+                        agent[key] = firstValue;
+                    }
+                });
+        });
+
+        return noop;
+    });
+};

src/agents/index.ts

@@ -4,3 +4,4 @@ export { AgentRecord, PropertyOperation, PropertyChange } from "./agent-record";
 export { AgentReference } from "./agent-reference";
 export { InstanceAgents } from "./instance-agents";
 export { InstanceState } from "./instance-state";
+export { buildRevertFunction } from "./agent-revert";

src/game-api.ts

@@ -1,6 +1,6 @@
-import { StaticAgentRegistry } from "./agents";
+import { buildRevertFunction, StaticAgentRegistry } from "./agents";
 import { HookManager } from "./api-hooks";
-import { GameOptions, OPTION_KEYS } from "./config";
+import { GameOptions, MetadataManager, OPTION_KEYS } from "./config";
 import { RegalError } from "./error";
 import GameInstance from "./game-instance";
 import { GameOutput } from "./output";
@@ -121,8 +121,33 @@ export class Game {
     }
 
     public static postUndoCommand(instance: GameInstance): GameResponse {
-        // TODO
-        throw new Error("Method not implemented.");
+        let newInstance: GameInstance;
+        let err: RegalError;
+
+        try {
+            validateGameInstance(instance);
+
+            // TODO - include onBeforeUndoCommand hook
+
+            newInstance = instance.cycle();
+            buildRevertFunction(instance.agents)(newInstance);
+        } catch (error) {
+            err = wrapApiErrorAsRegalError(error);
+        }
+
+        return err !== undefined
+            ? {
+                  output: {
+                      error: err,
+                      wasSuccessful: false
+                  }
+              }
+            : {
+                  instance: newInstance,
+                  output: {
+                      wasSuccessful: true
+                  }
+              };
     }
 
     public static postOptionCommand(

test/game-api.test.ts

@@ -7,7 +7,7 @@ import { noop } from "../src/events";
 import GameInstance from "../src/game-instance";
 import { OutputLineType } from "../src/output";
 import { log, getDemoMetadata, metadataWithOptions } from "./test-utils";
-import { Agent } from "../src/agents";
+import { Agent, buildRevertFunction } from "../src/agents";
 import {
     DEFAULT_GAME_OPTIONS,
     OPTION_KEYS,
@@ -16,6 +16,12 @@ import {
     GameMetadata
 } from "../src/config";
 
+class Dummy extends Agent {
+    constructor(public name: string, public health: number) {
+        super();
+    }
+}
+
 describe("Game API", function() {
     before(function() {
         MetadataManager.forceConfig(getDemoMetadata());
@@ -374,4 +380,34 @@ describe("Game API", function() {
             );
         });
     });
+
+    describe("Game.postUndoCommand", function() {
+        it("Undo a simple operation", function() {
+            onStartCommand(game => {
+                game.state.foo = true;
+                game.state.dummy = new Dummy("Lars", 10);
+                return noop;
+            });
+
+            onPlayerCommand(command => game => {
+                game.state.foo = false;
+                game.state.dummy.name = command;
+                return noop;
+            });
+
+            const initResponse = Game.postPlayerCommand(
+                Game.postStartCommand().instance,
+                "Jimbo"
+            );
+
+            expect(initResponse.instance.state.foo).to.be.false;
+            expect(initResponse.instance.state.dummy.name).to.equal("Jimbo");
+
+            const undoResponse = Game.postUndoCommand(initResponse.instance);
+
+            expect(undoResponse.output.wasSuccessful).to.be.true;
+            expect(undoResponse.instance.state.foo).to.be.true;
+            expect(undoResponse.instance.state.dummy.name).to.equal("Lars");
+        });
+    });
 });