@woosh/meep-engine 2.169.0 → 2.169.1

package/src/engine/intelligence/blackboard/Blackboard.js

@@ -71,7 +71,7 @@ export class Blackboard extends AbstractBlackboard {
 
     /**
      *
-     * @param {function(name:string, value:*, type: DataType)} visitor
+     * @param {(name: string, value: *, type: DataType) => void} visitor
      * @param {*} [thisArg]
      */
     traverse(visitor, thisArg) {
@@ -90,7 +90,7 @@ export class Blackboard extends AbstractBlackboard {
 
     /**
      *
-     * @param {function(name:string, value:*, type: DataType)} visitor
+     * @param {(name: string, value: *, type: DataType) => void} visitor
      * @param {RegExp} pattern
      */
     traverseWithPattern(pattern, visitor) {

package/src/engine/intelligence/mcts/MonteCarlo.d.ts

@@ -22,27 +22,27 @@ export class MonteCarloTreeSearch<S> {
     numPlayers: number;
     /**
      *
-     * @type {function(state:S, source:StateNode):MoveEdge[]}
+     * @type {(state: S, source: StateNode) => MoveEdge[]}
      */
-    computeValidMoves: (arg0: state) => S;
+    computeValidMoves: (state: S, source: StateNode<any, any>) => MoveEdge<any>[];
     /**
      *
-     * @type {function(state:S):StateType}
+     * @type {(state: S) => StateType}
      */
-    computeTerminalFlag: (arg0: state) => S;
+    computeTerminalFlag: (state: S) => StateType;
     /**
      * Returns the player ID (0-based) who chooses the next move from a given state.
      * Called when a non-terminal node is expanded. Players don't need to alternate
      * or follow any fixed pattern — the framework just asks the game.
-     * @type {function(state:S):number}
+     * @type {(state: S) => number}
      */
-    computeActivePlayer: (arg0: state) => S;
+    computeActivePlayer: (state: S) => number;
     /**
      * Returns the per-player payoff vector for a terminal state.
      * Indexed by player ID. The game decides the zero-sum/cooperative shape.
-     * @type {function(state:S):Float64Array}
+     * @type {(state: S) => Float64Array}
      */
-    computeOutcome: (arg0: state) => S;
+    computeOutcome: (state: S) => Float64Array;
     /**
      *
      * @type {function(S):S}
@@ -51,9 +51,9 @@ export class MonteCarloTreeSearch<S> {
     /**
      * Heuristic estimate of a non-terminal state's per-player value.
      * Optional — if `null`, new nodes start with zero-valued heuristic vectors.
-     * @type {null|function(node:StateNode, state:S):Float64Array}
+     * @type {null|(node: StateNode, state: S) => Float64Array}
      */
-    heuristic: null | ((arg0: node) => StateNode<any, any>);
+    heuristic: (node: StateNode<any, any>, state: S) => Float64Array;
     /**
      * Depth to which plays will be explored
      * @type {number}
@@ -67,12 +67,12 @@ export class MonteCarloTreeSearch<S> {
     /**
      * @param {S} rootState
      * @param {number} numPlayers Total number of players whose payoffs are tracked. Use 1 for solitaire / planning.
-     * @param {function(state:S, source:StateNode):MoveEdge[]} computeValidMoves
-     * @param {function(state:S):StateType} computeTerminalFlag
-     * @param {function(state:S):number} computeActivePlayer
-     * @param {function(state:S):Float64Array} computeOutcome called on terminal states; must return a vector of length `numPlayers`
+     * @param {(state: S, source: StateNode) => MoveEdge[]} computeValidMoves
+     * @param {(state: S) => StateType} computeTerminalFlag
+     * @param {(state: S) => number} computeActivePlayer
+     * @param {(state: S) => Float64Array} computeOutcome called on terminal states; must return a vector of length `numPlayers`
      * @param {function(S):S} cloneState
-     * @param {null|function(node:StateNode, state:S):Float64Array} [heuristic] optional per-player estimator for intermediate states
+     * @param {null|(node: StateNode, state: S) => Float64Array} [heuristic] optional per-player estimator for intermediate states
      */
     initialize({ rootState, numPlayers, computeValidMoves, computeTerminalFlag, computeActivePlayer, computeOutcome, cloneState, heuristic }: S): void;
     /**
@@ -89,4 +89,6 @@ export class MonteCarloTreeSearch<S> {
     playout(): S;
 }
 import { StateNode } from "./StateNode.js";
+import { MoveEdge } from "./MoveEdge.js";
+import { StateType } from "./StateNode.js";
 //# sourceMappingURL=MonteCarlo.d.ts.map

package/src/engine/intelligence/mcts/MonteCarlo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MonteCarlo.d.ts","sourceRoot":"","sources":["../../../../../src/engine/intelligence/mcts/MonteCarlo.js"],"names":[],"mappings":"AA0CA;;;;GAIG;AACH;IAEI;;;OAGG;IACH,WAFU,CAAC,CAEM;IAEjB;;;OAGG;IACH,MAFU,sBAAU,IAAI,CAEZ;IAEZ;;;;OAIG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,oCAFyB,CAAC,CAED;IAEzB;;;OAGG;IACH,sCAFyB,CAAC,CAEC;IAE3B;;;;;OAKG;IACH,sCAFyB,CAAC,CAEC;IAE3B;;;;OAIG;IACH,iCAFyB,CAAC,CAEJ;IAEtB;;;OAGG;IACH,mBAFmB,CAAC,KAAE,CAAC,CAEL;IAElB;;;;OAIG;IACH,WAFU,IAAI,wCAAwB,CAErB;IAEjB;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,iBAAyB;IAEzB;;;;;;;;;OASG;IACH,0IATW,CAAC,QA0CX;IAED;;;;;OAKG;IACH,+CAHW,CAAC,uBAsEX;IAED;;;OAGG;IACH,WAFa,CAAC,CAgDb;CACJ;0BA/RoC,gBAAgB"}
+{"version":3,"file":"MonteCarlo.d.ts","sourceRoot":"","sources":["../../../../../src/engine/intelligence/mcts/MonteCarlo.js"],"names":[],"mappings":"AA0CA;;;;GAIG;AACH;IAEI;;;OAGG;IACH,WAFU,CAAC,CAEM;IAEjB;;;OAGG;IACH,MAFU,sBAAU,IAAI,CAEZ;IAEZ;;;;OAIG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,2BAFkB,CAAC,kCAAwB,eAAU,CAE5B;IAEzB;;;OAGG;IACH,6BAFkB,CAAC,KAAK,SAAS,CAEN;IAE3B;;;;;OAKG;IACH,6BAFkB,CAAC,KAAK,MAAM,CAEH;IAE3B;;;;OAIG;IACH,wBAFkB,CAAC,KAAK,YAAY,CAEd;IAEtB;;;OAGG;IACH,mBAFmB,CAAC,KAAE,CAAC,CAEL;IAElB;;;;OAIG;IACH,8CAFwC,CAAC,KAAK,YAAY,CAEzC;IAEjB;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,iBAAyB;IAEzB;;;;;;;;;OASG;IACH,0IATW,CAAC,QA0CX;IAED;;;;;OAKG;IACH,+CAHW,CAAC,uBAsEX;IAED;;;OAGG;IACH,WAFa,CAAC,CAgDb;CACJ;0BA/RoC,gBAAgB;yBAD5B,eAAe;0BACH,gBAAgB"}