2048-js-ai: comparison ai.js

Mercurial Mercurial > 2048-js-ai / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

ai.js

changeset 169	5a17638f0dca
parent 164	cdde49008500
parent 168	df8e645c3f36
child 171	6fce1391c2c0

equal deleted inserted replaced

-:cde69b258e85
+:5a17638f0dca
 }
 ////////////////////////////////////////////////////////////////
-// 1 step deep with linear weight function on score, max value,
+// 1 step deep with linear utility function on score, max value,
 // bonuses for max value stay at corner or edge and bonuses
 // for each free field.
 ////////////////////////////////////////////////////////////////
 /**
-* Defines coefficient for linear resulted weight function.
+* Defines coefficient for linear resulted utility function.
 * @name ai.OneStepAhead.cfg
 * @namespace
 * @property {number} scoreCoef    multiplicator for score
 * @property {number} maxValCoef   multiplicator for max value
 * @property {number} cornerBonus  bonus for max value at board corner
 this.brd = brd;
 this.cfg = ai.copyObj(ai.OneStepAhead.bestCfg);
 ai.copyObj(cfg, this.cfg);
 }
 ai.OneStepAhead.bestCfg = {scoreCoef: 1, maxValCoef: 0, cornerBonus: 0, edgeBonus: 0, freeBonus: 0};
-ai.OneStepAhead.prototype.weight = function(brd) {
+ai.OneStepAhead.prototype.utility = function(brd) {
-var weight = 0;
+var utility = 0;
 if (this.cfg.scoreCoef > 0)
-weight += this.cfg.scoreCoef * brd.score();
+utility += this.cfg.scoreCoef * brd.score();
 var max = brd.maxVal();
 if (this.cfg.maxValCoef > 0)
-weight += this.cfg.maxValCoef * max;
+utility += this.cfg.maxValCoef * max;
 if (this.cfg.cornerBonus > 0 && brd.atCorner(max))
-weight += this.cfg.cornerBonus;
+utility += this.cfg.cornerBonus;
 if (this.cfg.edgeBonus > 0 && brd.atEdge(max))
-weight += this.cfg.edgeBonus;
+utility += this.cfg.edgeBonus;
 if (this.cfg.freeBonus > 0)
-weight += this.cfg.freeBonus * brd.freeCnt();
+utility += this.cfg.freeBonus * brd.freeCnt();
-return weight;
+return utility;
 }
 /** Select best direction for next step. */
 ai.OneStepAhead.prototype.analyse = function(brd2d) {
 var origBrd = new this.brd(brd2d);
 var nextBrd = new this.brd();
-var maxWeight = -1;
+var maxUtility = -1;
 var bestDir;
 for (var i = 0; i < ai.dirs.length; i++) {
 var dir = ai.dirs[i];
 if (origBrd[dir](nextBrd)) {
-var weight = this.weight(nextBrd);
+var utility = this.utility(nextBrd);
-if (maxWeight < weight) {
+if (maxUtility < utility) {
 bestDir = dir;
-maxWeight = weight;
+maxUtility = utility;
 }
 }
 }
 return bestDir;
 }
 ////////////////////////////////////////////////////////////////
 // N level deep on score value without random simulation.
 ////////////////////////////////////////////////////////////////
 /**
-* Defines coefficient for linear resulted weight function.
+* Defines coefficient for linear resulted utility function.
 * @name ai.StaticDeepMerges.cfg
 * @namespace
 * @property {number} scoreCoef    multiplicator for score
 * @property {number} maxValCoef   multiplicator for max value
 * @property {number} cornerBonus  bonus for max value at board corner
 ai.StaticDeepMerges = function(brd, cfg) {
 this.brd = brd;
 this.cfg = ai.copyObj(ai.OneStepAhead.bestCfg);
 ai.copyObj(cfg, this.cfg);
 }
-ai.StaticDeepMerges.bestCfg = {scoreCoef: 1, maxValCoef: 0, cornerBonus: 0, edgeBonus: 0, freeBonus: 0, weightThreshold: 10};
+ai.StaticDeepMerges.bestCfg = {scoreCoef: 1, maxValCoef: 0, cornerBonus: 0, edgeBonus: 0, freeBonus: 0, utilityThreshold: 10};
-ai.StaticDeepMerges.prototype.weight = function(brd) {
+ai.StaticDeepMerges.prototype.utility = function(brd) {
-var weight = 0;
+var utility = 0;
 if (this.cfg.scoreCoef > 0)
-weight += this.cfg.scoreCoef * brd.score();
+utility += this.cfg.scoreCoef * brd.score();
 var max = brd.maxVal();
 if (this.cfg.maxValCoef > 0)
-weight += this.cfg.maxValCoef * max;
+utility += this.cfg.maxValCoef * max;
 if (this.cfg.cornerBonus > 0 && brd.atCorner(max))
-weight += this.cfg.cornerBonus;
+utility += this.cfg.cornerBonus;
 if (this.cfg.edgeBonus > 0 && brd.atEdge(max))
-weight += this.cfg.edgeBonus;
+utility += this.cfg.edgeBonus;
 if (this.cfg.freeBonus > 0)
-weight += this.cfg.freeBonus * brd.freeCnt();
+utility += this.cfg.freeBonus * brd.freeCnt();
-return weight;
+return utility;
 }
 /** Select best direction for next step. */
 ai.StaticDeepMerges.prototype.analyse = function(brd2d) {
 var origBrd = new this.brd(brd2d);
 var nextBrd = new this.brd();
 var prevScore = -1, nextScore = -1;
-var maxWeight = -1;
+var maxUtility = -1;
 var bestDir;
 for (var i = 0; i < ai.dirs.length; i++) {
 var dir = ai.dirs[i];
 if (origBrd[dir](nextBrd)) {
-var weight = this.evalFn(nextBrd);
+var utility = this.evalFn(nextBrd);
-var ok = (weight - maxWeight) > this.cfg.weightThreshold;
+var ok = (utility - maxUtility) > this.cfg.utilityThreshold;
-if ( ! ok && maxWeight <= weight) {
+if ( ! ok && maxUtility <= utility) {
-nextScore = this.weight(nextBrd);
+nextScore = this.utility(nextBrd);
 ok = prevScore < nextScore;
 }
 if (ok) {
 prevScore = nextScore;
-maxWeight = weight;
+maxUtility = utility;
 bestDir = dir;
 }
 }
 }
 return bestDir;
 }
 ai.StaticDeepMerges.prototype.evalFn = function(brd) {
 var currScore = brd.score();
-var maxWeight = currScore;
+var maxUtility = currScore;
 var nextBrd = new this.brd();
 for (var i = 0; i < ai.dirs.length; i++) {
 if (brd[ai.dirs[i]](nextBrd)) {
 var score = nextBrd.score();
 if (score > currScore)
-maxWeight = Math.max(maxWeight, this.evalFn(nextBrd));
+maxUtility = Math.max(maxUtility, this.evalFn(nextBrd));
 }
 }
-return maxWeight;
+return maxUtility;
 }
 /* Mark that next board will be unrelated to previous, so any stored precompution can be cleared. */
 ai.StaticDeepMerges.prototype.cleanup = function() { }
 ////////////////////////////////////////////////////////////////
 // N level deep with random simulation.
 ////////////////////////////////////////////////////////////////
 /**
-* Defines coefficient for linear resulted weight function.
+* Defines coefficient for linear resulted utility function.
 * @name ai.expectimax.cfg
 * @namespace
 * @property {number} scoreCoef    multiplicator for score
 * @property {number} maxValCoef   multiplicator for max value
 * @property {number} cornerBonus  bonus for max value at board corner
 this.cfg.balance = 1;
 if (!this.cfg.depth || this.cfg.depth < 0 || 9 <= this.cfg.depth)
 this.cfg.depth = ai.expectimax.bestCfg.depth;
 }
 ai.expectimax.bestCfg = {balance: .9, depth: 5, scoreCoef: 1, maxValCoef: 0, cornerBonus: 0, edgeBonus: 0, freeBonus: 0};
-ai.expectimax.prototype.weight = function(brd) {
+ai.expectimax.prototype.utility = function(brd) {
 var score = 0;
 var cfg = this.cfg;
 if (cfg.scoreCoef > 0)
 score += cfg.scoreCoef * brd.score();
 if (cfg.maxValCoef > 0 || cfg.cornerBonus > 0 || cfg.edgeBonus > 0) {
 this.cleanup();
 return bestDir;
 }
 ai.expectimax.prototype.evalFn = function(brd, depth) {
 if (depth >= this.depthLimit)
-return this.weight(brd);
+return this.utility(brd);
 var wCached = this.brdCache.get(brd);
 if (wCached)
 return wCached;
 var wMin = +Infinity;
 var randBoard = new this.brd();
 ////////////////////////////////////////////////////////////////
 // Survive as long as possible.
 ////////////////////////////////////////////////////////////////
 /**
-* Defines coefficient for linear resulted weight function.
+* Defines coefficient for linear resulted utility function.
 * @name ai.survive.cfg
 * @namespace
 * @property {number} scoreCoef    multiplicator for score
 * @property {number} maxValCoef   multiplicator for max value
 * @property {number} cornerBonus  bonus for max value at board corner
 if (!this.cfg.maxDepth || this.cfg.maxDepth < 0 || 20 <= this.cfg.maxDepth)
 this.cfg.maxDepth = ai.survive.bestCfg.maxDepth;
 this.cfg.altAI = new ai.StaticDeepMerges(brd, ai.survive.altAICfg);
 }
 ai.survive.bestCfg = {freeCells: 8, maxDepth: 5};
-ai.survive.altAICfg = {scoreCoef: 1, maxValCoef: 0, cornerBonus: 0, edgeBonus: 0, freeBonus: 0, weightThreshold: 0};
+ai.survive.altAICfg = {scoreCoef: 1, maxValCoef: 0, cornerBonus: 0, edgeBonus: 0, freeBonus: 0, utilityThreshold: 0};
 /** Select best direction for next step. */
 ai.survive.prototype.analyse = function(brd2d) {
 var origBrd = new this.brd(brd2d);
 var nextBrd = new this.brd();
 var bestW = -2;
 ai.MonteCarlo.bestCfg = {simulations: 1000, maxDepth: 20, cornerBonus: 0, edgeBonus: 0, freeBonus: 0};
 /** Select best direction for next step. */
 ai.MonteCarlo.prototype.analyse = function(brd2d) {
 var origBrd = new this.brd(brd2d);
 var nextBrd = new this.brd();
-var bestW = - this.cfg.simulations;
+var bestUtility = - this.cfg.simulations;
 var bestDir;
 var freeCnt = origBrd.freeCnt();
 for (var i = 0; i < ai.dirs.length; i++) {
 var dir = ai.dirs[i];
 if (origBrd[dir](nextBrd)) {
-var w = 0;
+var utility = 0;
 for (var gameCnt = this.cfg.simulations; gameCnt > 0; gameCnt--) {
 var tmpBrd = nextBrd.copy();
-w += this.play(tmpBrd, this.cfg.maxDepth);
+utility += this.play(tmpBrd, this.cfg.maxDepth);
 }
-if (w > bestW) {
+if (utility > bestUtility) {
-bestW = w;
+bestUtility = utility;
 bestDir = dir;
 }
 }
 }
 return bestDir;
 }
 }
 return -1;
 }
 ai.MonteCarlo.prototype.evalFn = function(brd) {
-var w = 0;
+var utility = 0;
 if (this.cfg.freeBonus > 0)
-w += this.cfg.freeBonus * brd.freeCnt();
+utility += this.cfg.freeBonus * brd.freeCnt();
 var max = brd.maxVal();
 if (max > 7) {
 if (this.cfg.cornerBonus > 0 && brd.atCorner(max))
-w += this.cfg.cornerBonus;
+utility += this.cfg.cornerBonus;
 if (this.cfg.edgeBonus > 0 && brd.atEdge(max))
-w += this.cfg.edgeBonus;
+utility += this.cfg.edgeBonus;
 }
-return w;
+return utility;
 }
 /* Mark that next board will be unrelated to previous, so any stored precompution can be cleared. */
 ai.MonteCarlo.prototype.cleanup = function() {
 }

2048-js-ai