24

このゲームでは、2人のプレイヤーがトークンの最も多くのポイントを食べるために競いますが、ひねりがあります！同じ色の行で複数のトークンを食べると、増え続けるボーナスが得られますが、気を付けないと、相手はあなたが望む前にあなたが望むトークンを食べることであなたの計画を妨害します！

ルール：

1対1
n x nボード（5x5〜15x15のランダムサイズ）
あなたとあなたの対戦相手は同じランダムなセルに出現します
ボード全体で、値が1〜3の範囲のいくつかのセルでランダムに生成された数値になります。
2 *（ボードの幅）トークンが生成されますが、オーバーライドが存在する可能性があるため、偶然少ない可能性があります。
各数値は、赤、緑、または青の16進数RGB形式の3色のいずれかです。
ラウンドごとに、プレーヤー1が移動してボードが更新され、次にプレーヤー2が移動してボードが更新されます。そのため、各プレイヤーは、ボードの状態の変化に基づいて、前のプレイヤーがどのような動きをしたかを効果的に知ることができます。後述するように、これはゲームが終了するまで続きます。
ターンには6つのアクションがあります：UP、RIGHT、DOWN、LEFT、EAT、PASS
4つの移動コマンドは一目瞭然であり、自分のターンをパスできます。あなたが無意味な動きを返す場合、我々はあなたがパスを意味すると仮定します。ボードの端から移動しようとしても、移動しません。エッジはラップしません。
EATは、現在と同じスペースにいる番号を消費します
消費した数だけポイントを獲得できます
同じ色の2つの数字を連続して食べると、+ 1が得られます
同じ色の3つの数字を連続して食べると、+ 2になります
同じ色の行にm個の数字を食べると、+（m-1）が得られます
これらのボーナスは累積的に追加されるため、m個の数字を連続して取得すると、異なる色を食べるまでに合計ボーナスがm *（m-1）/ 2になります。
ゲーム終了条件：
- すべての数字が消費されます
- 4 *（ボードの幅）ターンはいずれかのプレイヤーによって発生した効果的な食事なし（あなたがいないトークンなしで "EAT"と言うだけ）になりました（トークンは2 *（幅）で到達可能です）移動するため、両方のプレイヤーが単一のターゲットトークンを念頭に置いていない場合にのみ、この境界を超えます）
AIが移動するのに要する時間は1秒未満です。そうでない場合、PASSが選択として想定されます。

トーナメントは、100または1000などの多数のラウンドを含むラウンドロビンになります。ランダムなボードが生成され、異なるボードの各注文ペアがそのボードで実行されます。トーナメントが完了したら、合計スコアで人々をランク付けします。あなたがゲームのプレイヤー2であっても、目標は可能な限り多くのポイントを獲得することです。

AIの提出：コントローラーがサポートする言語はJavascriptです。複数の提出が許可されています。誰もがこのようなオブジェクトのコンストラクタを送信します：

function (player1) {
    this.yourMove = function (b) {
        return "MOVE";
    }
}

入力player1は、プレイヤー1であるかどうかを示すブール値です。コンストラクタにはyourMove関数が必要ですが、追加の関数や値をいくつでも持つことができます。グローバル変数を定義せず、オブジェクトに変数として配置するだけです。オブジェクトの新しいバージョンは、各マッチの開始時に作成され、 yourMove現在のボードを入力として、各ターンで呼び出され、有効なムーブを返す必要があります。

b入力は、yourMove、であるコピー現在のボードのあなたがそれらを自分で呼び出すことはできませんが、ここでのコンストラクタは、入力例を、以下のとおりです。

function token(color, points) {
    this.color = color; //"#FF0000"
    this.points = points; //5
}

function player(pos, score, colorBonus, lastColor) {
    this.pos = pos; //[5, 5]
    this.score = score; //9
    this.colorBonus = colorBonus; //i.e. 2 if you just ate 3 blue tokens in a row
                                  //0 if you just ate two different colors.
    this.lastColor = lastColor; //"#00FF00", is "#000000" at start
}

function board(player1, player2, tokens) {
    this.player1 = player1; //new player([5, 5], 9, 2, "#00FF00")
    this.player2 = player2; //new player([5, 5], 9, 2, "#00FF00")
    this.tokens = tokens; //[[new token("#0000FF", 5), false],
                      // [new token("#0000FF", 5), false]]
}

トークン配列は、空の正方形に対して「false」を持ち、tokens [a] [b]は、左上隅から番号が付けられたx = a、y = bのトークンです。

コントローラ： ここにあります GitHubでのコントローラへのリンクが。これは、ゲームとラウンドロビンの動作を確認するために実行できるhtmlファイルで、2つのAIが付属しています。AIは、ターンごとにランダムな方向に移動しますが、その位置でトークンを食べるランダムなアルゴリズムと、最も多くのポイントを与える最も近いトークンを探します。提出された各AIを追加します。

以下は、デフォルトのAIでコントローラーを実行できるようにするスニペットです。現在のAI：

きんらんど
ナイーブAI
MirrorBot
HungryBot

コードスニペットを表示

<!DOCTYPE html>
<html>

<body>

  <canvas id="myCanvas" width="700" height="600" style="border:1px solid #c3c3c3;">
    Your browser does not support the HTML5 canvas tag.
  </canvas>

  <script>
    // AI Array, put in at least two constructor functions as described in the
     // data file, and it will do round robin on them.
     // Also, you can adjust some variables for testing purposes only.
    var interval = 1; // in milliseconds per turn
    var matches = 10; // number of matches for each pairing
    var aiArray = [];
    myAI = function(player1) {
      this.player1 = player1;
      this.yourMove = function(b) {
        var me;
        if (this.player1) {
          me = b.player1;
        } else {
          me = b.player2;
        }
        var d = 0;
        var tokenP;
        while (tokenP == undefined) {
          var arr = this.findTokensAtDistance(me.pos, d)
          tokenP = this.findBestToken(arr, b.tokens, me);
          d += 1;
        }
        return this.startAndGoalToCommand(me.pos, tokenP);
      }
      this.findTokensAtDistance = function(p, d) {
        if (d == 0) {
          return [
            [p[0], p[1]]
          ];
        }
        var myArr = [];
        for (i = 0; i <= d; i++) {
          myArr[i] = [i, d - i];
        }
        var mySecArr = [];
        for (i = 0; i <= d; i++) {
          mySecArr[i] = [myArr[i][0] + p[0], myArr[i][1] + p[1]];
        }
        mySecArr[mySecArr.length] = [myArr[0][0] + p[0], -myArr[0][1] + p[1]];
        for (i = 1; i < myArr.length - 1; i++) {
          mySecArr[mySecArr.length] = [-myArr[i][0] + p[0], myArr[i][1] + p[1]]
          mySecArr[mySecArr.length] = [myArr[i][0] + p[0], -myArr[i][1] + p[1]]
          mySecArr[mySecArr.length] = [-myArr[i][0] + p[0], -myArr[i][1] + p[1]]
        }
        mySecArr[mySecArr.length] = [-myArr[myArr.length - 1][0] + p[0], myArr[myArr.length - 1][1] + p[1]];
        return mySecArr;
      }
      this.findBestToken = function(arr, t, player) {
        var tokenPos;
        for (i = 0; i < arr.length; i++) {
          if (arr[i][0] >= 0 && arr[i][0] < t.length && arr[i][1] >= 0 && arr[i][1] < t.length) {
            if (t[arr[i][0]][arr[i][1]] != false && ((tokenPos == undefined) || (this.tokenScore(player, t[arr[i][0]][arr[i][1]]) > this.tokenScore(player, t[tokenPos[0]][tokenPos[1]])))) {
              tokenPos = [arr[i][0],
                [arr[i][1]]
              ];
            }
          }
        }
        return tokenPos;
      }
      this.tokenScore = function(player, token) {
        if (player.lastColor == token.color) {
          return player.colorBonus + 1 + token.points;
        } else {
          return token.points;
        }
      }
      this.startAndGoalToCommand = function(start, goal) {
        var diff = [goal[0] - start[0], goal[1] - start[1]];
        if (diff[0] > 0) {
          return "RIGHT";
        } else if (diff[1] > 0) {
          return "DOWN";
        } else if (diff[1] < 0) {
          return "UP";
        } else if (diff[0] < 0) {
          return "LEFT";
        } else {
          return "EAT";
        }
      }
    }
    aiArray[0] = myAI;
     // This is a really stupid AI, used to test that the round-robin selected
     // it is the worst by far
    myStupidAI = function(player1) {
      this.player1 = player1;
      this.yourMove = function(b) {
        var me;
        if (this.player1) {
          me = b.player1;
        } else {
          me = b.player2;
        }
        if (b.tokens[me.pos[0]][me.pos[1]] != false) {
          return "EAT";
        } else {
          var dirs = this.getViableDirections(b, me.pos);
          var rand = Math.floor(Math.random() * dirs.length);
          return dirs[rand];
        }
      }
      this.getViableDirections = function(b, p) {
        var dirs = [];
        if (p[0] > 0) {
          dirs.push("LEFT");
        }
        if (p[1] > 0) {
          dirs.push("UP");
        }
        if (p[1] < b.tokens.length - 1) {
          dirs.push("DOWN");
        }
        if (p[0] < b.tokens.length - 1) {
          dirs.push("RIGHT");
        }
        return dirs;
      }
    }
    aiArray[1] = myStupidAI;
    mirrorBot = function(player1){
        this.hasStarted=0;
        this.player1 = player1;
        this.yourMove = function(b){
            this.op = this.player1 ? b.player2 : b.player1;
            var out = "EAT";
            if(this.hasStarted){
                if(this.opl.pos[0] < this.op.pos[0]) out = "LEFT";
                if(this.opl.pos[0] > this.op.pos[0]) out = "RIGHT";
                if(this.opl.pos[1] < this.op.pos[1]) out = "UP";
                if(this.opl.pos[1] > this.op.pos[1]) out = "DOWN";
            }
            this.opl = this.op;
            this.hasStarted = 1;
            return out;
        }
    }
    aiArray[2] = mirrorBot;
    hungryBot = function(first) {
  // Set up "self"
  var self = this;

  // Determine player order
  this.player = -(first - 2);
  this.enemy = first + 1;

  // Action associative array
  this.actions = ['EAT', 'LEFT', 'RIGHT', 'UP', 'DOWN'];

  //Logic handler
  this.yourMove = function(board) {
// Determine player object
var player = board['player' + self.player];
var enemy = board['player' + self.enemy];

// Point value action grid
var actions = [0, 0, 0, 0, 0]; // Associative with "this.actions"

// Board dimensions
var size = board.tokens.length;
var maxDist = size * 2;

// Colors remaining
var colors = {
  '#FF0000': 0,
  '#00FF00': 0,
  '#0000FF': 0
};

// Averaged value weight
var average = [0, 0];

// Total points
var points = 0;

// Token holder
var tokens = [];

// Token parser
for (var i = 0, x = 0, y = 0; i < size * size; i += 1, x = i % size, y = i / size | 0) {
  if (!board.tokens[x][y]) {
    continue;
  } else {
    var token = {};
    token.points = board.tokens[x][y].points;
    token.color = board.tokens[x][y].color;
    token.x = x - player.pos[0];
    token.y = y - player.pos[1];
    token.distX = Math.abs(token.x);
    token.distY = Math.abs(token.y);
    token.dist = token.distX + token.distY;
    token.distE = Math.abs(x - enemy.pos[0]) + Math.abs(y - enemy.pos[1]);
    token.value = -token.points - (player.colorBonus + 1) * (token.color == player.lastColor) * ((token.dist == 0) + 1) * 1.618 - (enemy.colorBonus + 1) * (token.color == enemy.lastColor);
    tokens.push(token);
    colors[token.color] += 1;
    points += token.points;
    average[0] += x * token.points;
    average[1] += y * token.points;
  }
}

// Determine actual average
average[0] = average[0] / points | 0;
average[1] = average[1] / points | 0;

// Pick best token
var best = 0;

// Calculate point values of tokens
for (i = 0; i < tokens.length; i++) {
  var token = tokens[i];
  // Add remaining numbers of tokens of color as factor
  token.value -= (colors[token.color] / tokens.length) * 1.618;
  // Subtract distance as a factor
  token.value += token.dist;
  // Add distance to average to value
  token.value += (Math.abs(average[0] - (token.x + player.pos[0])) + Math.abs(average[1] - (token.y + player.pos[1]))) / Math.sqrt(2);
  // Consider them higher value if we are closer, and lower if they are
  token.value += ((token.dist - token.distE) / (token.dist + token.distE + 0.001)) * token.dist;
  // Don't go for it if enemy is already there
  token.value += (token.distE == 0 && token.dist > 0) * 100;

  if (tokens[best].value > tokens[i].value || (tokens[best].value === tokens[i].value && Math.round(Math.random()))) {
    best = i;
  }
}

// Set token to best token
var token = tokens[best];

// What to respond with
var response = 'PASS';

// Find best action to get token
if (token.dist == 0) {
  response = 'EAT'; // We're on the token
} else if (token.distX >= token.distY) { // Token is more horizontal
  if (token.x < 0) { // Token is left
    response = 'LEFT';
  } else if (token.x > 0) { // Token is right
    response = 'RIGHT';
  }
} else if (token.distX < token.distY) { // Token is more vertical
  if (token.y < 0) { // Token is above
    response = 'UP';
  } else if (token.y > 0) { // Token is below
    response = 'DOWN';
  }
}

// Return response
return response;
  }
};
    aiArray[3]=hungryBot;
    for (i = 0; i < aiArray.length; i += 1) {
      Object.freeze(aiArray[i]);
    }
     // This is the actual code to run the program. You shouldn't mess with it,
     // or your AI might not work during the actual competition.
     // Also note that you can't access this code at all in your AI.
     // Feel free to make suggestions and we'll try to incorporate them,
     // and let us know if something isn't working correctly.
    Object.freeze(aiArray);
    setInterval((function() {
      function token(color, points) {
        this.color = color;
        this.points = points;
      }

      function player(pos, score, colorBonus, lastColor) {
        this.pos = pos;
        this.score = score;
        this.colorBonus = colorBonus;
        this.lastColor = lastColor;
      }

      function board(player1, player2, tokens) {
        this.player1 = player1;
        this.player2 = player2;
        this.tokens = tokens;
      }

      function copyBoard(b) {
        return new board(copyPlayer(b.player1), copyPlayer(b.player2), copyTokens(b.tokens));
      }

      function copyTokens(t) {
        var tokens = [];
        for (i = 0; i < t.length; i++) {
          tokens[i] = [];
          for (j = 0; j < t[i].length; j++) {
            tokens[i][j] = t[i][j];
          }
        }
        return tokens;
      }

      function copyPlayer(p) {
        return new player([p.pos[0], p.pos[1]], p.score, p.colorBonus, p.lastColor);
      }

      function endGame(b) {
        if (b.player1.score > b.player2.score) {
          var c = document.getElementById("myCanvas");
          var ctx = c.getContext("2d");
          ctx.font = 20 + "px Arial";
          ctx.textAlign = "left";
          ctx.fillStyle = "#000000";
          ctx.fillText("Player 1", 601, 160);
          ctx.fillText("wins!", 601, 180);
        } else if (b.player1.score < b.player2.score) {
          var c = document.getElementById("myCanvas");
          var ctx = c.getContext("2d");
          ctx.font = 20 + "px Arial";
          ctx.textAlign = "left";
          ctx.fillStyle = "#000000";
          ctx.fillText("Player 2", 601, 160);
          ctx.fillText("wins!", 601, 180);
        } else {
          var c = document.getElementById("myCanvas");
          var ctx = c.getContext("2d");
          ctx.font = 20 + "px Arial";
          ctx.textAlign = "left";
          ctx.fillStyle = "#000000";
          ctx.fillText("It's a", 601, 160);
          ctx.fillText("draw!", 601, 180);
        }
      }

      function genTokenArray(size) {
        var temp = [];
        for (i = 0; i < size; i++) {
          temp[i] = [];
          for (j = 0; j < size; j++) {
            temp[i][j] = false;
          }
        }
        return temp;
      }

      function genRandomTokenArray(size) {
        var temp = genTokenArray(size);
        for (i = 0; i < size * 2; i++) {
          var rand = Math.floor(Math.random() * temp.length);
          var points = Math.floor(Math.random() * 3 + 1);
          var rand2 = Math.floor(Math.random() * 3);
          var color;
          var rand3 = Math.floor(Math.random() * temp[rand].length);
          if (rand2 == 0) {
            color = "#FF0000"
          } else if (rand2 == 1) {
            color = "#00FF00"
          } else {
            color = "#0000FF"
          }
          temp[rand][rand3] = new token(color, points);
        }
        return temp;
      }

      function countTokens(tokenArr) {
        var x = 0;
        for (i = 0; i < tokenArr.length; i++) {
          for (j = 0; j < tokenArr[i].length; j++) {
            if (tokenArr[i][j] != false) {
              x += 1
            }
          }
        }
        return x;
      }

      function actPlayer(b, p, s) {
        if (s == "UP" && p.pos[1] > 0) {
          p.pos[1] -= 1;
        } else if (s == "RIGHT" && p.pos[0] < b.tokens.length - 1) {
          p.pos[0] += 1;
        } else if (s == "DOWN" && p.pos[1] < b.tokens.length - 1) {
          p.pos[1] += 1;
        } else if (s == "LEFT" && p.pos[0] > 0) {
          p.pos[0] -= 1;
        } else if (s == "EAT" && b.tokens[p.pos[0]][p.pos[1]] != false) {
          if (p.lastColor == b.tokens[p.pos[0]][p.pos[1]].color) {
            p.colorBonus += 1;
            p.score += p.colorBonus;
          } else {
            p.lastColor = b.tokens[p.pos[0]][p.pos[1]].color;
            p.colorBonus = 0;
          }
          p.score += b.tokens[p.pos[0]][p.pos[1]].points;
          b.tokens[p.pos[0]][p.pos[1]] = false;
        }
      }

      function drawEmptyRect() {
        var c = document.getElementById("myCanvas");
        var ctx = c.getContext("2d");
        ctx.clearRect(0, 0, 700, 600);
      }

      function drawToken(t, x, y, g) {
        drawEntity(x, y, t.points, t.color, "#000000", 300 / g, g);
      }

      function drawLittleEntity(x, y, label, fillColor, labelColor, size, cX, cY, g) {
        var delta = 600 / g;
        var x1 = x * delta + cX * delta / 4;
        var y1 = y * delta + cY * delta / 4;
        var c = document.getElementById("myCanvas");
        var ctx = c.getContext("2d");
        ctx.beginPath();
        ctx.arc(x1, y1, size / 2, 0, 2 * Math.PI);
        ctx.stroke();
        ctx.fillStyle = fillColor;
        ctx.fill();
        ctx.font = delta / 2 + "px Arial";
        ctx.textAlign = "center";
        ctx.fillStyle = labelColor;
        ctx.fillText(label, x1, y1 + delta * 3 / 16);
      }

      function drawEntity(x, y, label, fillColor, labelColor, size, g) {
        var delta = 600 / g;
        var x1 = x * delta + delta / 2;
        var y1 = y * delta + delta / 2;
        var c = document.getElementById("myCanvas");
        var ctx = c.getContext("2d");
        ctx.beginPath();
        ctx.arc(x1, y1, size, 0, 2 * Math.PI);
        ctx.stroke();
        ctx.fillStyle = fillColor;
        ctx.fill();
        ctx.font = delta + "px Arial";
        ctx.textAlign = "center";
        ctx.fillStyle = labelColor;
        ctx.fillText(label, x1, y1 + delta * 3 / 8);
      }

      function drawAllTokens(arrToken) {
        for (i = 0; i < arrToken.length; i++) {
          for (j = 0; j < arrToken[i].length; j++) {
            if (arrToken[i][j] != false) {
              drawToken(arrToken[i][j], i, j, arrToken.length);
            }
          }
        }
      }

      function drawGrid(g) {
        var delta = 600 / g;
        for (i = 0; i <= g; i++) {
          var canvas = document.getElementById("myCanvas");
          var ctx = canvas.getContext("2d");
          ctx.beginPath();
          ctx.moveTo(i * delta, 0);
          ctx.lineTo(i * delta, 600);
          ctx.stroke();
        }
        for (j = 0; j <= g; j++) {
          var canvas = document.getElementById("myCanvas");
          var ctx = canvas.getContext("2d");
          ctx.beginPath();
          ctx.moveTo(0, j * delta);
          ctx.lineTo(600, j * delta);
          ctx.stroke();
        }
      }

      function drawPlayer1(b, g) {
        drawLittleEntity(b.player1.pos[0], b.player1.pos[1], "F", "#000000", "#FFFFFF", 300 / g, 1, 1, g);
      }

      function drawPlayer2(b, g) {
        drawLittleEntity(b.player2.pos[0], b.player2.pos[1], "S", "#000000", "#FFFFFF", 300 / g, 3, 3, g);
      }

      function drawScore(b) {
        var canvas = document.getElementById("myCanvas");
        var ctx = canvas.getContext("2d");
        ctx.font = "20px Arial";
        ctx.fillStyle = "#000000";
        ctx.textAlign = "left";
        ctx.fillText("P" + indices[0] + " Score:", 601, 50);
        ctx.fillText(b.player1.score, 601, 70);
        ctx.fillText("P" + indices[1] + " Score:", 601, 100);
        ctx.fillText(b.player2.score, 601, 120);
      }

      function drawScoreNum(s, i) {
        var canvas = document.getElementById("myCanvas");
        var ctx = canvas.getContext("2d");
        ctx.font = "20px Arial";
        ctx.fillStyle = "#000000";
        ctx.textAlign = "left";
        ctx.fillText("P" + i + " Score:", 601, i * 50 + 50);
        ctx.fillText(s, 601, i * 50 + 70);
      }

      function redraw(b, g) {
        drawEmptyRect();
        drawGrid(g);
        drawScore(b);
        drawAllTokens(b.tokens);
        drawPlayer1(b, g);
        drawPlayer2(b, g);
        drawScoreNum()
      }

      function nextPair(pair, total) {
        var pairRes = [pair[0], (pair[1] + 1) % total];
        if (pairRes[1] == 0) {
          pairRes[0] = pairRes[0] + 1;
        }
        return pairRes;
      }

      function nextGameUnfair() {
        scores[indices[0]] = scores[indices[0]] + currBoard.player1.score;
        scores[indices[1]] = scores[indices[1]] + currBoard.player2.score;
        if (matchCount >= matches) {
          matchCount = 0;
          indices = nextPair(indices, aiArray.length);
          if (indices[0] == indices[1]) {
            indices = nextPair(indices, aiArray.length);
          }
          if (indices[0] >= aiArray.length) {
            return false;
          }
          player1Turn = true;
          timeWithoutEating = 0;
          firstAI = new aiArray[indices[0]](true);
          secondAI = new aiArray[indices[1]](false);
          currBoard = genBoard();
        } else {
          matchCount++;
          player1Turn = true;
          timeWithoutEating = 0;
          firstAI = new aiArray[indices[0]](true);
          secondAI = new aiArray[indices[1]](false);
          currBoard = genBoard();
        }
        return true;
      }

      function nextGameFair() {
        scores[indices[0]] = scores[indices[0]] + currBoard.player1.score;
        scores[indices[1]] = scores[indices[1]] + currBoard.player2.score;
        indices = nextPair(indices, aiArray.length);
        if (indices[0] == indices[1]) {
          indices = nextPair(indices, aiArray.length);
        }
        if (indices[0] >= aiArray.length) {
          indices = [0, 1];
          matchCount++;
          if (matchCount >= matches) {
            return false;
          }
          player1Turn = true;
          timeWithoutEating = 0;
          currBoard = genBoard();
        } else {
          player1Turn = true;
          timeWithoutEating = 0;
          currBoard = savedBoard;
        }
        firstAI = new aiArray[indices[0]](true);
        secondAI = new aiArray[indices[1]](false);
        savedBoard = copyBoard(currBoard);
        return true;
      }

      function genBoard() {
        var rand = Math.floor(Math.random() * 11 + 5);
        var randX = Math.floor(Math.random() * rand);
        var randY = Math.floor(Math.random() * rand);
        return new board(new player([randX, randY], 0, 0, "#000000"),
          new player([randX, randY], 0, 0, "#000000"),
          genRandomTokenArray(rand));
      }
      var running = true;
      var indices = [0, 1];
      var scores = []
      for (i = 0; i < aiArray.length; i++) {
        scores.push(0);
      }
      var matchCount = 0;
      var firstAI = new aiArray[0](true);
      var secondAI = new aiArray[1](false);
      var player1Turn = true;
      var currBoard = genBoard();
      var savedBoard = copyBoard(currBoard);
      var timeWithoutEating = 0;
      return function() {
        if (running) {
          var numTokens = countTokens(currBoard.tokens);
          if (numTokens <= 0) {} else if (player1Turn) {
            actPlayer(currBoard, currBoard.player1, firstAI.yourMove(copyBoard(currBoard)));
          } else {
            actPlayer(currBoard, currBoard.player2, secondAI.yourMove(copyBoard(currBoard)));
          }
          player1Turn = !player1Turn;
          redraw(currBoard, currBoard.tokens.length);
          if (numTokens > countTokens(currBoard.tokens)) {
            timeWithoutEating = 0;
          } else {
            timeWithoutEating += 1;
          }
          if (numTokens <= 0 || timeWithoutEating > 4 * currBoard.tokens.length) {
            running = nextGameFair();
          }
        } else {
          drawEmptyRect();
          for (i = 0; i < scores.length; i++) {
            drawScoreNum(scores[i], i);
          }
        }
      }
    })(), interval);
  </script>

</body>

</html>

スニペットを展開

grid king-of-the-hill javascript

— 摩擦音メロン
ソース

12

イェイ、KOTH！それは最後のものから永遠にありました。

— TheNumberOne

2

同意して、私は私に良いKOTHを愛しており、これは大きな前提のようです。私はjsに対して少し環境に優しいのですが、アウトプレイヤーオブジェクト内に結果を保存できない場合、どのように移動間でゲームの状態を維持しますか？

— -DoctorHeckle

ボードの幅は関数のどこかに渡されますか？

— TheNumberOne

@BentNeeHumorはい、player1ブール値を受け取る関数はAIのコンストラクターです。AIにyourMoveは、現在のボードを入力として受け取る関数がありますb。

— 摩擦摩擦メロン

1

@DylanSp共謀の可能性があるために許可されないこともありますが、この場合、共謀の利点は最小限であるため、複数の提出を許可します。

— 摩擦摩擦メロン

4

HungryBot

ポイントシステムを使用して、各トークンの追跡値に重みを追加します。さまざまな要因を考慮して考慮し、各ターンごとにそれらを再評価して、最良の戦略に従うようにします。

function hungryBot(first) {
  // Set up "self"
  var self = this;

  // Determine player order
  this.player = -(first - 2);
  this.enemy = first + 1;

  // Action associative array
  this.actions = ['EAT', 'LEFT', 'RIGHT', 'UP', 'DOWN'];

  //Logic handler
  this.yourMove = function(board) {
    // Determine player object
    var player = board['player' + self.player];
    var enemy = board['player' + self.enemy];

    // Point value action grid
    var actions = [0, 0, 0, 0, 0]; // Associative with "this.actions"

    // Board dimensions
    var size = board.tokens.length;
    var maxDist = size * 2;

    // Colors remaining
    var colors = {
      '#FF0000': 0,
      '#00FF00': 0,
      '#0000FF': 0
    };

    // Averaged value weight
    var average = [0, 0];

    // Total points
    var points = 0;

    // Token holder
    var tokens = [];

    // Token parser
    for (var i = 0, x = 0, y = 0; i < size * size; i += 1, x = i % size, y = i / size | 0) {
      if (!board.tokens[x][y]) {
        continue;
      } else {
        var token = {};
        token.points = board.tokens[x][y].points;
        token.color = board.tokens[x][y].color;
        token.x = x - player.pos[0];
        token.y = y - player.pos[1];
        token.distX = Math.abs(token.x);
        token.distY = Math.abs(token.y);
        token.dist = token.distX + token.distY;
        token.distE = Math.abs(x - enemy.pos[0]) + Math.abs(y - enemy.pos[1]);
        token.value = -token.points - (player.colorBonus + 1) * (token.color == player.lastColor) * ((token.dist == 0) + 1) * 1.618 - (enemy.colorBonus + 1) * (token.color == enemy.lastColor);
        tokens.push(token);
        colors[token.color] += 1;
        points += token.points;
        average[0] += x * token.points;
        average[1] += y * token.points;
      }
    }

    // Determine actual average
    average[0] = average[0] / points | 0;
    average[1] = average[1] / points | 0;

    // Pick best token
    var best = 0;

    // Calculate point values of tokens
    for (i = 0; i < tokens.length; i++) {
      var token = tokens[i];
      // Add remaining numbers of tokens of color as factor
      token.value -= (colors[token.color] / tokens.length) * 1.618;
      // Subtract distance as a factor
      token.value += token.dist;
      // Add distance to average to value
      token.value += (Math.abs(average[0] - (token.x + player.pos[0])) + Math.abs(average[1] - (token.y + player.pos[1]))) / Math.sqrt(2);
      // Consider them higher value if we are closer, and lower if they are
      token.value += ((token.dist - token.distE) / (token.dist + token.distE + 0.001)) * token.dist;
      // Don't go for it if enemy is already there
      token.value += (token.distE == 0 && token.dist > 0) * 100;

      if (tokens[best].value > tokens[i].value || (tokens[best].value === tokens[i].value && Math.round(Math.random()))) {
        best = i;
      }
    }

    // Set token to best token
    var token = tokens[best];

    // What to respond with
    var response = 'PASS';

    // Find best action to get token
    if (token.dist == 0) {
      response = 'EAT'; // We're on the token
    } else if (token.distX >= token.distY) { // Token is more horizontal
      if (token.x < 0) { // Token is left
        response = 'LEFT';
      } else if (token.x > 0) { // Token is right
        response = 'RIGHT';
      }
    } else if (token.distX < token.distY) { // Token is more vertical
      if (token.y < 0) { // Token is above
        response = 'UP';
      } else if (token.y > 0) { // Token is below
        response = 'DOWN';
      }
    }

    // Return response
    return response;
  }
};

— Mwr247
ソース

あなたはPythonプログラマーですか？

— CalculatorFeline

@CatsAreFluffyそうでもない...？

— Mwr247

あなただけの理由だと思ったself:)

— CalculatorFeline

なぜ使用self？this十分ではありませんか？

— コナーオブライエン

2

PATHボット

頭字語はPathfinding And Tree Heuristics Botの略です

編集：今のところ、ここにポイントを持つAIのランキングがあります

HungryBot（6422）
PATHボット（4591）
NaiveAI（3811）
KindaRandomAI（618）
MirrorBot（193）
レイジーボット（25）

GitHubの完全なコントローラーへのリンク

説明：NaiveAIと同様に、このボットは最も多くのポイントを与える最も近いトークンを見つけます。ただし、各移動の結果を最大6回シミュレートします。

理論的根拠：NaiveAIはすでにかなり優れているので、改善したいと思います。最初にコードを見なくても（大きな間違い）。

ビート：HungryBotを除くすべて緩い
：HungryBotを除くなし

問題点：

増加したストリークをシミュレートできません
最高のトークンの計算中にハングします
~~テレポートできます~~

なぜテレポートしたのかはまだわかりませんが、修正しました。古いビデオはこちら：https : //youtu.be/BIhSKycF9iA

完全なコード：

pathBot = function (player1)
{
    this.pathNode = function(pos,ppt,parents,par)
    {
        this.pos = pos;this.ppt = ppt;this.parents = parents;this.par=par;
        this.childs=[];
    }
    this.addChildren = function (pn,children)
    {
        pn.childs=[];
        for(var i=0; i<children.length; i=i+1)
        {
            if(pn.parents.indexOf(children[i].pos)==-1&&pn.pos!=children[i].pos)
                pn.childs.push(
                    new this.pathNode(
                        children[i].pos,
                        children[i].ppt*pn.ppt,
                        pn.parents.concat([pn.pos]),
                        pn
                    )
                );
        }
    }
    this.orderTokensByPPT = function(b,pos){
        var tokens = [];
        for(var y=0; y<b.tokens.length; y=y+1)
        {
            for(var x=0; x<b.tokens[y].length; x=x+1)
            {
                var tok = b.tokens[y][x];
                if(tok)
                {
                    tokens.push(
                        new this.pathNode(
                            [y,x],
                            (tok.points+(tok.color==this.color ? this.streak : 0)) / this.lenOfMovesTo(pos,[y,x]),
                            [],
                            undefined
                        )
                    );
                }
            }
        }
        tokens.sort(function(a,b){
            return b.ppt - a.ppt;
        });
        return tokens;
    }
    this.lenOfMovesTo = function(cur,pos)
    {
        return Math.abs(cur[0]-pos[0])+Math.abs(cur[1]-pos[1])+1;
    }
    this.startAndGoalToCommand = function (start, goal) {
        var diff = [goal[0] - start[0], goal[1] - start[1]];
        if (diff[0] > 0) { return "RIGHT"; }
        else if (diff[1] > 0) { return "DOWN"; }
        else if (diff[1] < 0) { return "UP"; }
        else if (diff[0] < 0) { return "LEFT"; }
        else { return "EAT"; }
    }
    this.color = 0;
    this.streak = 0;
    this.eatTok = function(b)
    {
        if(b.tokens[this.me.pos[0]][this.me.pos[1]].color==this.color)
        {
            this.streak++;
        }
        else{
            this.streak = 0;
            this.color = b.tokens[this.me.pos[0]][this.me.pos[1]].color;
        }
        this.bestToken = false;
        return "EAT";
    }

    this.recurLen = 6;
    this.include = 4;
    this.recurDown = function(b,pn,level)
    {
        if(level==0) return pn;
        this.addChildren(pn,this.orderTokensByPPT(b,pn.pos));
        var newChilds = [];
        for(var i=0; i<pn.childs.length&&i<this.include; i=i+1)
        {
            newChilds.push(this.recurDown(b,pn.childs[i],level-1));
        }
        pn.childs = newChilds;
        return pn;
    }
    this.findMax = function(pn)
    {
        if(pn.childs)
        {
            var maxList = [];
            for(var i=0; i<pn.childs.length; i=i+1)
                maxList.push(this.findMax(pn.childs[i]));
            maxList.sort(
                function(a,b)
                {
                    return b.ppt-a.ppt;
                }
            );
            return maxList[0];
        }
        return pn;
    }
    this.findMaxList = function(pnList)
    {
        for(var i=0; i<pnList.lenght; i=i+1)
        {
            pnList[i] = this.findMax(pnList[i]);
        }
        pnList.sort(function(a,b){return b.ppt-a.ppt;});
        return pnList[0];
    }
    this.bestToken=false;
    this.yourMove = function(b){
        this.op = player1 ? b.player2 : b.player1;
        this.me = player1 ? b.player1 : b.player2;
        if(this.bestToken)
        {
            if(b.tokens[this.bestToken.pos[0]][this.bestToken.pos[1]]==undefined)
                this.bestToken = false;
        }
        if(!this.bestToken)
        {
            var paths = this.orderTokensByPPT(b,this.me.pos);
            for(var i=0; i<paths.length; i++)
            {
                paths[i] = this.recurDown(b,paths[i],this.recurLen);
            }
            var max = this.findMaxList(paths);
            while(max.par)
            {
                max = max.par;
            }
            this.bestToken = max;
        }
        var move = this.startAndGoalToCommand(this.me.pos,this.bestToken.pos);
        if(move=="EAT") return this.eatTok(b);
        else return move;
    }
}

— 青い
ソース

SLaNTbotはターンスピードを遅くし、CPUの15％を消費しています... D：編集：また何も食べていませんか？

— Mwr247

@ Mwr247速度、ええ、ティックごとに〜2500の可能性をモデル化します。しかし、食べるものについては、私は正確に理由を知りません。私が質問で言ったように、それはただテレポートし（別名1ターンで複数のスペースを移動します）、何もせずにそこに座っています。私は帰国の直前に警告を出しましたが、毎回正しい指示を出しているようです。

— ブルー

たぶんこれ：「あなたのAIは動きをするのに1秒もかからないはずです。さもないとPASSがあなたの選択と見なされます。」コントローラーを読んでいませんが、1秒以上かかった場合、PASSと見なされますか？

— Mwr247

@ Mwr247私はそれを調べますが、私のマシンで1秒未満（または私も）かかっていたことはほとんどありません。それでも、見ても痛いことはありません。ありがとうございました！

— ブルー

@ Mwr247さらにいくつかのテストを行った後、そうではありません。NaiveAiとほぼ同じくらい（少なくとも私にとって）迅速に決定を下しています。また、大きな地図でテレポーテーションが発生する可能性が高くなります

— ブルー

1

ナイーブAI

で始まる、あなたの位置からr=0タクシーの距離ですべてのトークンを見てrください。ある場合は、すぐに得た場合に最高のスコアを与えるものを選択します。それ以外の場合は、r1 ずつ増やして再試行してください。

naiveAI = function(player1) {
  this.player1 = player1;
  this.yourMove = function(b) {
    var me;
    if (this.player1) {
      me = b.player1;
    } else {
      me = b.player2;
    }
    var d = 0;
    var tokenP;
    while (tokenP == undefined) {
      var arr = this.findTokensAtDistance(me.pos, d)
      tokenP = this.findBestToken(arr, b.tokens, me);
      d += 1;
    }
    return this.startAndGoalToCommand(me.pos, tokenP);
  }
  this.findTokensAtDistance = function(p, d) {
    if (d == 0) {
      return [
        [p[0], p[1]]
      ];
    }
    var myArr = [];
    for (i = 0; i <= d; i++) {
      myArr[i] = [i, d - i];
    }
    var mySecArr = [];
    for (i = 0; i <= d; i++) {
      mySecArr[i] = [myArr[i][0] + p[0], myArr[i][1] + p[1]];
    }
    mySecArr[mySecArr.length] = [myArr[0][0] + p[0], -myArr[0][1] + p[1]];
    for (i = 1; i < myArr.length - 1; i++) {
      mySecArr[mySecArr.length] = [-myArr[i][0] + p[0], myArr[i][1] + p[1]]
      mySecArr[mySecArr.length] = [myArr[i][0] + p[0], -myArr[i][1] + p[1]]
      mySecArr[mySecArr.length] = [-myArr[i][0] + p[0], -myArr[i][1] + p[1]]
    }
    mySecArr[mySecArr.length] = [-myArr[myArr.length - 1][0] + p[0], myArr[myArr.length - 1][1] + p[1]];
    return mySecArr;
  }
  this.findBestToken = function(arr, t, player) {
    var tokenPos;
    for (i = 0; i < arr.length; i++) {
      if (arr[i][0] >= 0 && arr[i][0] < t.length && arr[i][1] >= 0 && arr[i][1] < t.length) {
        if (t[arr[i][0]][arr[i][1]] != false && ((tokenPos == undefined) || (this.tokenScore(player, t[arr[i][0]][arr[i][1]]) > this.tokenScore(player, t[tokenPos[0]][tokenPos[1]])))) {
          tokenPos = [arr[i][0],
            [arr[i][1]]
          ];
        }
      }
    }
    return tokenPos;
  }
  this.tokenScore = function(player, token) {
    if (player.lastColor == token.color) {
      return player.colorBonus + 1 + token.points;
    } else {
      return token.points;
    }
  }
  this.startAndGoalToCommand = function(start, goal) {
    var diff = [goal[0] - start[0], goal[1] - start[1]];
    if (diff[0] > 0) {
      return "RIGHT";
    } else if (diff[1] > 0) {
      return "DOWN";
    } else if (diff[1] < 0) {
      return "UP";
    } else if (diff[0] < 0) {
      return "LEFT";
    } else {
      return "EAT";
    }
  }
}

— 摩擦音メロン
ソース

1

きんらんど

毎ターン、次の操作を行います。自分の位置にトークンがある場合、「食べる」。それ以外の場合、ランダムに実行可能な方向に移動します。つまり、左端にいる場合は「左」と言わないでください。

kindaRandomAI = function(player1) {
    this.player1 = player1;
    this.yourMove = function(b) {
        var me;
        if (this.player1) {
            me = b.player1;
        } else {
            me = b.player2;
        }
        if (b.tokens[me.pos[0]][me.pos[1]] != false) {
            return "EAT";
        } else {
            var dirs = this.getViableDirections(b, me.pos);
            var rand = Math.floor(Math.random() * dirs.length);
            return dirs[rand];
        }
    }
    this.getViableDirections = function(b, p) {
        var dirs = [];
        if (p[0] > 0) {
            dirs.push("LEFT");
        }
        if (p[1] > 0) {
            dirs.push("UP");
        }
        if (p[1] < b.tokens.length - 1) {
            dirs.push("DOWN");
        }
        if (p[0] < b.tokens.length - 1) {
            dirs.push("RIGHT");
        }
        return dirs;
    }
}

— 摩擦音メロン
ソース

-1完全にランダムではない

— CalculatorFeline

それはましです！

— CalculatorFeline

1

LazyBot

彼がその上にスポーンした場合にのみ、何かを食べます。これには勝つチャンスはありませんが、チャレンジにはこれらのいずれもありませんでした。

lazyBot = function (player1) {
    this.yourMove = function(b) {
        return "EAT";
    }
}

— バリント
ソース

1

すべてのコスにはEmoWolfがあります...

— ブルー

3

@Blue 100％エモではなく、食べようとします。

— バリント

1

meta.codegolf.stackexchange.com/questions/1061/...

— センモウヒラムシ

1

MirrorBot

「キャノン飼料」と呼ばれるべきです

説明：他のプレイヤーがしたことの正反対に移動します

根拠：私は再びJSで快適なプログラミングを手に入れたかった。これは勝てないはず

勝ちます：誰もいません

失うもの：全員

function mirror(player1) {
    this.hasStarted=false;
    this.player1 = player1;
    this.opl=[0,0];
    this.yourMove = function(b){
        this.op = this.player1 ? b.player2.pos : b.player1.pos;
        out = "EAT";
        console.log(this.op);
        console.log(this.opl);
        if(this.hasStarted){
            if(this.opl[0] < this.op[0]) out = "RIGHT";
            if(this.opl[0] > this.op[0]) out = "LEFT";
            if(this.opl[1] < this.op[1]) out = "UP";
            if(this.opl[1] > this.op[1]) out = "DOWN";
        }
        this.opl = [this.op[0],this.op[1]];
        this.hasStarted = true;
        return out;
    }
}

— 青い
ソース

コードにはいくつかの問題があります。右と左は反対ではなく、yourMoveの関数定義は有効な構文ではありません。以前にもコードが壊れていたため、コード内の問題を見つけて修正する過程で、コードも修正しました。私のスクリプトで修正されたコードを見ることができます。

— 摩擦摩擦メロン

@FricativeMelon壊れた関数定義を修正しました。私は権利が反対ではないという主張に反論しなければなりません。

— ブルー

0,0は左上隅なので、正のxは右、負のxは左です。新しいx-posの値が古いx-posよりも大きい場合、他のプレイヤーは右に移動したので、左に移動する必要があります。その逆も同様です。また、後者はグローバル変数を定義するため、var out = "EAT";代わりにを使用する必要がありout = "EAT";ます。少し抜粋すると、3行目と4行目は何も行わず、同様に削除opできoutます。また、プロパティの代わりにローカル変数のようにすることもできます。

— 摩擦摩擦メロン

@FricativeMelonああ、私はあなたが言っていることを得る。コードを更新しました。ありがとうございました！

— ブルー

スクリプトに新しいコードを追加しましたが、現在は機能しています。RandomAIに勝るものはありませんが：（

— 摩擦音メロン

0

OneTarget

最短時間で多くのポイントを獲得し、そのポイントに進むトークンを見つけます。累積効果のため、同じ色のトークンを少し高くランク付けします。

function (player1) {
    this.yourMove = function (b) {
        var me = player1? b.player1: b.player2;
        var him= player1? b.player2: b.player1;
        var x = me.pos[0];
        var y = me.pos[1];
        var maxVal = -1;
        var maxX = 0;
        var maxY = 0;
        for(var i = 0;i < b.tokens.length;i++){
            for(var j = 0;j < b.tokens.length;j++){
                if(b.tokens[i][j]){
                    var dist = Math.abs(x-i) + Math.abs(y-j);
                    var val = this.valueOf(b.tokens[i][j]);
                    val /= (dist + 1);
                    if(val > maxVal){
                        maxVal = val;
                        maxX = i;
                        maxY = j;
                    }
                }
            }
        }
        if(maxY < y)
            return "UP";
        if(maxX < x)
            return "LEFT";
        if(maxY > y)
            return "DOWN";
        if(maxX > x)
            return "RIGHT";
        return "EAT";
    }
    this.valueOf = function(t){
        //how many points would it give you?
        return t.points + (this.lastColor == t.color? 2 * this.colorBonus + 1 : 0);
    }
}

— メガトム
ソース

0

QuantityPlayer

QuantityPlayerが気にするのは、食べるドットの量であり、ドットの値や色ではありません。彼は、すべてのドットが異なっていても、同じように扱われるべきであることを知っています。

QuantityBot = function(playernum) {

this.dist = function(token) {
    return (Math.abs(token[0])+Math.abs(token[1]))
}

this.yourMove = function(game_board) {

    board_size = game_board.tokens.length
    board_area = board_size * board_size
    fete = board_size = size * 2

    token_list = []
    count = curr_x = curr_y = 0
    while(count < board_area) {
        if(game_board.tokens[x][y]) {
        token_list.push([x-player.pos[0],y-player.pos[1]])
        }
        count++; x = count % board_size; y = Math.floor(count / size)
    }

    closest_token = token_list[0]
    count = 1
    while(count < token_list.length) {
        curr_token = token_list[count]
        if(dist(curr_token) < dist(closest_token)){closest_token = curr_token}

        count++
    }

    if(dist(closest_token)==0){return 'EAT'}
    else{
    if(closest_token[0] >= closest_token[1]) {if(closest_token[0]<0) {return 'LEFT'} {return 'RIGHT'}}
    else{if(closest_token[1]<0) {return 'UP'} {return 'DOWN'}}
    }

}

}

— ベンジャミン・フィリップ
ソース

KOTH：みんなトークンが大好き

HungryBot

PATHボット

ナイーブAI

きんらんど

LazyBot

MirrorBot

OneTarget

QuantityPlayer