Merge pull request #87 from Itangalo/1.4

1.4

Author: Itangalo

000-simulation.gs

@@ -27,7 +27,9 @@ function simulate(iterations = false, mod = false) {
 
   let extraArguments = parseArguments(arguments, 2);
   log('Starting to build initial data.', 'system');
-  let gameStateSeed = modules[module].buildInitialData(...extraArguments);
+  let gameStateSeed = {};
+  if (modules[module].buildInitialData)
+    gameStateSeed = modules[module].buildInitialData(...extraArguments);
   log('Initial data complete.', 'system');
 
   /**
@@ -70,8 +72,14 @@ function simulate(iterations = false, mod = false) {
       }
     }
 
+    // Only on the first iteration, run postBuild().
+    if (iteration == 1 && modules[module].postBuild)
+      modules[module].postBuild(...extraArguments);
+
+
     // Make any customized additional processing of the game state.
-    modules[module].preIteration(...extraArguments);
+    if (modules[module].preIteration)
+      modules[module].preIteration(...extraArguments);
 
     /**
      * Play the game until it is over.

200-helpersGeneral.gs

@@ -137,17 +137,36 @@ function processValue(value, checkArrays = true) {
  * Helper functions handling arrays.
  */
 
-// Used for sorting an array of objects by an object property.
-function sortByProperty(objArray, property, ascending = true) {
+/**
+ * Used for sorting an array of objects by an object property.
+ * 
+ * @param {array} objArray: The array of objects to be sorted.
+ * @param {string} property: The name of the property to sort by.
+ * @param {boolean} ascending: Set to false to sort descending. Defaults to true.
+ * @param {boolean} shuffleFirst: Set to true to shuffle the array before sorting, to avoid bias.
+ */
+function sortByProperty(objArray, property, ascending = true, shuffleFirst = false) {
+  if (shuffleFirst)
+    shuffle(objArray);
   if (ascending)
     objArray.sort((a, b) => a[property] > b[property] ? 1 : -1);
   else
     objArray.sort((a, b) => b[property] > a[property] ? 1 : -1);
   return objArray;
 }
 
-// Used for sorting an array of objects by a sub property.
-function sortBySubProperty(objArray, property, subProperty, ascending = true) {
+/**
+ * Used for sorting an array of objects by a sub property.
+ * 
+ * @param {array} objArray: The array of objects to be sorted.
+ * @param {string} property: The name of the property containing the sub property.
+ * @param {string} property: The name of the sub property to sort by.
+ * @param {boolean} ascending: Set to false to sort descending. Defaults to true.
+ * @param {boolean} shuffleFirst: Set to true to shuffle the array before sorting, to avoid bias.
+ */
+function sortBySubProperty(objArray, property, subProperty, ascending = true, shuffleFirst = false) {
+  if (shuffleFirst)
+    shuffle(objArray);
   if (ascending)
     objArray.sort((a, b) => a[property][subProperty] > b[property][subProperty] ? 1 : -1);
   else
@@ -319,6 +338,13 @@ function getCache(key) {
   return BPTstatic.cache[key];
 }
 
+/**
+ * Returns a string with 'character' repeated 'length' times.
+ */
+function repString(length, character = ' ') {
+  return new Array(length + 1).join(character);
+}
+
 // Returns the agent with the matching id or false if none is found.
 function getAgentById(id) {
   if (!gameState.agents)

classes/120-Track.gs

@@ -12,6 +12,8 @@
  *    - assumePresent: If true, missing pawns are created when calling getPawn(pawnId). Defaults to true.
  *    - loop: If true, the last space is followed by the first. Defaults to false.
  *    - gridMovement: If true, possible movement is defined through connections on spaces. Defaults to false.
+ *    - connectRadius: If set to a numeric value, each space will connect to all spaces within that distance
+ *      unless source or target spaces have explicit connections set by the 'connectsTo' property.
  *    - symmetricConnections: If true, any connections between spaces are assumed to go both ways.
  *      Only relevant if gridMovement is true. Defaults to true.
  *    - cacheGraph: If true, the created map of connections between spaces is stored between game iterations.
@@ -59,40 +61,60 @@ class Track {
    * Rebuilds track data. Needed when new spaces are added.
    */
   rebuild() {
-    // Build a graph of how the spaces connect, if advanced movement is used.
+    // Map space IDs to indices, for quicker reference. And update space indices.
+    this.spaceMapping = {};
+    for (let i in this.spaces) {
+      this.spaceMapping[this.spaces[i].id] = i;
+      this.spaces[i].index = parseInt(i);
+    }
+
+    // Build a graph of how the spaces connect, if grid movement is used.
     // Data used by the a-star algorithm, to find paths in the grid.
     if (this.gridMovement) {
+      // Reset pawn paths.
+      this.pawnPaths = {};
+
+      // Attempt to fetch cached data, if relevant.
       if (this.cacheGraph) {
         this.graph = getCache('track.' + this.id + '.grid');
         this.heuristic = getCache('track.' + this.id + '.heuristic');
       }
       else
         this.graph = false;
+
+      // Build new graph data, if necessary.
       if (!this.graph) {
         this.graph = [];
         for (let i = 0; i < this.spaces.length; i++)
           this.graph.push([]);
         for (let s of this.spaces) {
-          for (let c of s.connectsTo) {
-            let target = new ObjectFilter({id: c}).findFirstInArray(this.spaces);
-            this.graph[s.index][target.index] = 1;
+          let connected = [];
+          // Use connectRadius, if appropriate.
+          if (this.connectRadius && !s.connectsTo.length) {
+            let filter = new ObjectFilter().or().addEqualsCondition({id: s.id}).addNotEmptyCondition('connectsTo');
+            connected = this.getSpacesWithinRadius(s, this.connectRadius);
+            filter.removeFromArray(connected);
+            connected = this.convertSpaceData(connected, 'object', 'index');
+          }
+          // Otherwise, use explicit connections set on the space.
+          else {
+            connected = this.convertSpaceData(s.connectsTo, 'id', 'index');
+          }
+          // Connect to each relevant space, and the reverse if relevant.
+          for (let targetIndex of connected) {
+            this.graph[s.index][targetIndex] = 1;
             if (this.symmetricConnections)
-              this.graph[target.index][s.index] = 1;
+              this.graph[targetIndex][s.index] = 1;
           }
         }
         let row = Array(this.graph.length).fill(1);
         this.heuristic = Array(this.graph.length).fill(row);
-        setCache('track.' + this.id + '.grid', this.graph);
-        setCache('track.' + this.id + '.heuristic', this.heuristic);
+        // Cache for future reference, if relevant.
+        if (this.cacheGraph) {
+          setCache('track.' + this.id + '.grid', this.graph);
+          setCache('track.' + this.id + '.heuristic', this.heuristic);
+        }
       }
-      this.pawnPaths = {};
-    }
-
-    // Map space IDs to indices, for quicker reference. And update space indices.
-    this.spaceMapping = {};
-    for (let i in this.spaces) {
-      this.spaceMapping[this.spaces[i].id] = i;
-      this.spaces[i].index = parseInt(i);
     }
   }
 
@@ -265,6 +287,57 @@ class Track {
     return spaces.map(x => this.convertSpaceData(x, 'index', returnType));
   }
 
+  /**
+   * Returns all the spaces within the radius of the given point.
+   * 
+   * @param {object} point: An object with (at least) coordinate values for the point to search from.
+   * @param {number} radius: A maximum distance from the point to search.
+   * @param {string} shape: Set to 'square' to search a square instead of a circle.
+   * 
+   * @return: An array of spaces, sorted by distance to the point.
+   */
+  getSpacesWithinRadius(point, radius = 1, shape = 'circle') {
+    // Get all spaces within the distance from the point, in a square.
+    let filter = new ObjectFilter();
+    for (let c of this.coordinates) {
+      let value = {};
+      value[c] = point[c] - radius;
+      filter.addGreaterOrEqualCondition(value);
+      value[c] = point[c] + radius;
+      filter.addLessOrEqualCondition(value);
+    }
+    // Get the distance from the point for all these candidates.
+    let spaces = [];
+    for (let s of filter.applyOnArray(this.spaces)) {
+      let distance = getDistance(point, s, this.coordinates);
+      if (shape == 'square' || distance <= radius)
+        spaces.push({
+          space: s,
+          distance: distance,
+        });
+    }
+    // Sort by distance from the point.
+    sortByProperty(spaces, 'distance', true, true)[0]['space'];
+    return buildArrayWithProperty(spaces, 'space');
+  }
+
+  /**
+   * Returns the space closest to a given point.
+   *
+   * @param {object} point: An object with (at least) coordinate values for the point to search from.
+   * @param {number} radius: A maximum distance from the point to search. Smaller number increases search speed.
+   * @param {string} shape: Set to 'square' to search a square instead of a circle.
+   *
+   * @return {Space} The space object with coordinates closest to the given point. If several
+   * equally near, one of these is selected randomly.
+   */
+  getClosestSpace(point, radius = 1, shape = 'circle') {
+    let spaceList = this.getSpacesWithinRadius(point, radius, shape);
+    if (spaceList.length == 0)
+      throw('No space is within search distance from the given point.');
+    return spaceList[0];
+  }
+
   /**
    * Does an estimation of whether there is a line of sight between two spaces. If point coordinates
    * are provided, these will be used instead of spaces' coordinates.
@@ -497,12 +570,12 @@ class Pawn {
     if (this.id === undefined)
       throw('Pawns must have an id property set.');
     // Add the track name + pawn to any agent matching the pawn id.
-    for (let a of gameState.agents) {
-      if (this.id == a.id) {
-        if (a[track.id] === undefined)
-          a[track.id] = {};
-        a[track.id].pawn = this;
-      }
+    let agent = getAgentById(this.id);
+    if (agent) {
+      if (agent[track.id] === undefined)
+        agent[track.id] = {
+          pawn: this,
+        };
     }
 
     this.track = track;

classes/150-ObjectFilter.gs

@@ -59,6 +59,24 @@ class ObjectFilter {
     return this;
   }
 
+  /**
+   * Requires that the stated object property is undefined, null, false or an empty string/array.
+   * Only property name is passed as condition.
+   */
+  addEmptyCondition(condition) {
+    this[this.addMode].push(new ConditionEmpty(this, condition));
+    return this;
+  }
+
+  /**
+   * Requires that the stated object property is NOT undefined, null, false or an empty string/array.
+   * Only property name is passed as condition.
+   */
+  addNotEmptyCondition(condition) {
+    this[this.addMode].push(new ConditionNotEmpty(this, condition));
+    return this;
+  }
+
   /**
    * Requires that the stated object property is higher than the stated value.
    * On the form {a: 3}.
@@ -225,6 +243,44 @@ class ConditionNotEquals extends ConditionEquals {
   }
 }
 
+/**
+ * Class for 'empty' conditions in ObjectFilters.
+ * Returns true if the given property is undefined, null, false, an empty array or an empty string.
+ *
+ * @param {object} conditionData: The name of the property which should be empty.
+ */
+class ConditionEmpty extends ConditionEquals {
+  validateAndProcess(conditionData) {
+    if (typeof(conditionData) != 'string')
+      throw('The condition data must be a string.');
+    this.property = conditionData;
+  }
+
+  evaluate(obj) {
+    if (compareObjects(obj[this.property], []))
+      return true;
+    if ([undefined, null, false, ''].includes(obj[this.property]))
+      return true;
+    return false;
+  }
+}
+
+/**
+ * Class for 'not empty' conditions in ObjectFilters.
+ * Returns false if the given property is undefined, null, false, an empty array or an empty string.
+ *
+ * @param {object} conditionData: The name of the property which should be empty.
+ */
+class ConditionNotEmpty extends ConditionEmpty {
+  evaluate(obj) {
+    if (compareObjects(obj[this.property], []))
+      return false;
+    if ([undefined, null, false, ''].includes(obj[this.property]))
+      return false;
+    return true;
+  }
+}
+
 /**
  * Class for greater-than conditions in ObjectFilters.
  *