КОТ: Все любят токены

24

В этой игре два игрока соревнуются, чтобы съесть наибольшее количество очков жетонов, но есть поворот! Еда нескольких жетонов в ряд одного и того же цвета дает постоянно растущий бонус, но будьте осторожны, иначе ваш оппонент нарушит ваши планы, съев нужные жетоны, прежде чем вы сможете!

Правила:

  • 1 против 1
  • доска n на n (случайный размер от 5x5 до 15x15)
  • Вы и ваш оппонент будут появляться в одной и той же случайной ячейке
  • По всей доске будут случайным образом сгенерированные числа в некоторых ячейках в диапазоне значений от 1-3
  • Будут сгенерированы токены 2 * (ширина доски), но могут быть переопределения, поэтому их может быть меньше.
  • Каждое число будет одного из 3 цветов: красный, зеленый или синий, в шестнадцатеричном формате RGB
  • В каждом раунде игрок 1 перемещается, и доска обновляется, затем игрок 2 перемещается, и доска обновляется. Таким образом, каждый игрок может эффективно определить, какой ход сделал предыдущий игрок, основываясь на изменении состояния доски. Это продолжается до конца игры, как описано ниже.
  • У вас есть 6 возможных действий для хода: ВВЕРХ, ВПРАВО, ВНИЗ, ВЛЕВО, ЕСТЬ и ПРОЙДИТЬ
  • 4 команды перемещения говорят сами за себя, и вы МОЖЕТЕ пройти свой ход. Если вы вернете бессмысленный ход, мы будем считать, что вы имели в виду пас. Если вы попытаетесь отойти от края доски, вы не будете двигаться. Края не заворачиваются.
  • EAT потребляет номер, который вы в настоящее время в том же месте, что и
  • Вы получаете столько же очков, сколько и количество, которое вы потребляете.
  • Если вы съедите 2 числа подряд одного цвета, вы получите +1
  • Если вы съедите 3 числа подряд одного цвета, вы получите +2
  • Если вы съедите m чисел в строке одного цвета, вы получите + (m-1)
  • Эти бонусы суммируются, поэтому получение m чисел подряд приводит к общему бонусу m * (m-1) / 2 к тому времени, как вы поели другого цвета.
  • Условия окончания игры:
    • Все номера потребляются
    • 4 * (ширина доски) ходы прошли без эффективного приема пищи (просто произнесение «ЕСТЬ» без жетона, где вы не учитываетесь), происходящего любым игроком (любой жетон доступен в 2 * (ширина) ходы, поэтому этот предел будет превышен, только если оба игрока не имеют в виду ни одного целевого жетона)
  • Ваш ИИ должен сделать меньше секунды, чтобы сделать ход, иначе 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» для любых пустых квадратов, и токены [a] [b] являются токенами в x = a, y = b, пронумерованными, начиная с верхнего левого угла.

Контроллер: вот ссылка на контроллер в GitHub. Это html-файл, который вы можете запустить, чтобы увидеть, как работает игра и циклический перебор идет на ближайший токен, который дает наибольшее количество очков. Я добавлю в каждый ИИ, как он представлен.

Ниже приведен фрагмент, который позволяет запустить контроллер на AI по умолчанию. Текущие AI:

  • KindaRandomAI
  • NaiveAI
  • MirrorBot
  • HungryBot

Показать фрагмент кода

grid king-of-the-hill javascript Фрикативная дыня
источник
12
Yay, КОТ! Это было навсегда с момента последнего.
TheNumberOne
2
Согласен, я люблю меня, хороший КОТ, и это, кажется, отличная предпосылка. Я немного зелен по отношению к JS, как можно сохранять игровое состояние между ходами, если мы не можем сохранить результаты внутри объекта игрока?
DoctorHeckle
Ширина платы передается куда-нибудь в функцию?
TheNumberOne
@BentNeeHumor Да, функция, которая принимает player1логическое значение, является конструктором для вашего ИИ, который будет иметь yourMoveфункцию, которая принимает текущую доску в качестве ввода, как b.
Фрикативная дыня
1
@DylanSp Иногда они не разрешены из-за возможности сговора, но в этом случае сговор будет иметь минимальные преимущества, поэтому я разрешу несколько представлений.
Fricative Melon

Ответы:

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

РЕДАКТИРОВАТЬ: На данный момент, вот рейтинг для ИИ, с точками

  1. HungryBot (6422)
  2. PATH бот (4591)
  3. NaiveAI (3811)
  4. Добрый случайный (618)
  5. MirrorBot (193)
  6. Ленивый бот (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 замедляет скорость поворота и съедает 15% моего процессора ... D: EDIT: И тоже ничего не ест?
Mwr247
@ Mwr247 скорость, да, он моделирует ~ 2500 возможностей за каждый тик. Но что касается еды, я точно не знаю почему. Как я уже сказал в вопросе, он просто телепортируется (он же перемещает несколько пробелов за 1 ход) и сидит там, ничего не делая. Я поставил предупреждение перед возвращением, и оно, кажется, дает правильные инструкции каждый раз.
Синий,
Может быть, это так: «Ваш ИИ должен сделать меньше секунды, чтобы сделать ход, иначе PASS будет считаться вашим выбором». Я не читал контроллер, но если он занимает секунду, он предполагает PASS?
Mwr247
@ Mwr247 Я посмотрю на это, но это маловероятно, учитывая, что на моей машине это заняло <1 секунду (или я так думаю). Тем не менее, никогда не больно смотреть. Спасибо!
Синий,
@ Mwr247 После еще одного тестирования это не так. Он принимает решения почти так же быстро (по крайней мере, для меня), как NaiveAi. Кроме того, у вас больше шансов испытать телепортацию на больших картах
Blue
1

NaiveAI

Начните с того r=0, что посмотрите на все токены с указанием расстояния такси rот вашей позиции. Если есть, выберите тот, который даст вам наивысший балл, если вы получите его прямо сейчас. В противном случае увеличьте rна 1 и попробуйте снова.

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

Каждый ход делайте следующее: если на вашей позиции есть жетон, «ЕСТЬ». В противном случае двигайтесь в случайном жизнеспособном направлении, то есть, если вы находитесь на левом краю, не говорите «ВЛЕВО».

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/...
Trichoplax
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;
    }
}
синий
источник
Есть несколько проблем с вашим кодом. Right и Left не противоположны, и определение вашей функции для yourMove не является допустимым синтаксисом. Мой код также был поврежден и раньше, поэтому в процессе поиска и исправления проблемы в моем коде я также исправил и ваш код. Вы можете посмотреть на исправленный код в моем скрипте.
Фрикативная дыня
@FricativeMelon Я исправил определение неработающей функции. Я должен опровергнуть утверждение, что права не противоположны.
Голубой
0,0 - верхний левый угол, так что положительный х - правый, а отрицательный - левый. если новый x-pos больше по значению, чем старый x-pos, другой игрок двигается вправо, поэтому вы должны двигаться влево, и наоборот. Кроме того, вы должны использовать var out = "EAT";вместо out = "EAT";, так как последний определяет глобальную переменную. Немного отметив, третья и четвертая строки ничего не делают и также могут быть удалены, и 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);
    }
}
MegaTom
источник
0

QuantityPlayer

Все, что нужно для QuantPlayer, - это количество точек, которые он съедает, а не значение или цвет точек. Он знает, что хотя все точки разные, к ним следует относиться одинаково.

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'}}
    }

}

}
Бенджамин Филипп
источник