Remarque: l'enquête sur les favoris de la communauté sera publiée bientôt

Dans ce KoTH, l’objectif est d’être le dernier bot en vie. Les pièces seront placées dans des zones aléatoires, et votre bot doit d'abord obtenir les pièces. Si un bot rencontre un autre bot, le bot avec plus de pièces gagne et l'autre meurt. Plus de détails ci-dessous.

Types de pièces

Il y aura 2 types de pièces: or et argent. L'or ajoute 5 pièces à la force du bot et l'argent en ajoute 2. Une fois qu'une pièce est collectée, une autre pièce est placée à un autre endroit du tableau. À tout moment, il y a une pièce d'or et quatre pièces d'argent dans l'arène.

Collisions de bot

Dans le cas où deux robots essaient d'occuper le même espace, celui qui a le plus de pièces restera et celui qui en a moins ... pas. Le bot gagnant remportera 85% des pièces de l'adversaire (arrondi au maximum). S'ils sont attachés, les deux meurent. Si trois ou plus essaient d'occuper le même espace, le plus puissant gagne et obtient 85% de toutes les pièces des autres robots. Au cas où le bot le plus puissant serait à égalité, tous les robots mourants qui ont tenté d'entrer dans l'espace meurent.

Arène

La longueur du côté de l'arène est calculée avec 4 + botCount. Lors du placement de bots au début du jeu, des emplacements aléatoires sont choisis. Le système garantit qu'aucun robot ne démarre dans le même espace ou l'un à côté de l'autre. Les pièces sont générées aléatoirement, à l’exception du carré 3 × 3 centré sur chaque bot. Si un bot est trouvé à l'extérieur de l'arène, il meurt instantanément. L'arène commence à (0,0), ou Nord-Ouest, dans le coin supérieur gauche, et l'emplacement d'un bot est toujours un entier.

Votre bot

Votre bot doit être une fonction, dans tout langage orienté objet qui comporte des tableaux, des entiers, des chaînes et des fonctions. Notez que toutes les soumissions seront converties en Javascript, pour simplifier les choses. Pour stocker des informations entre les déplacements, utilisez botNotes.storeData(key, value)et botNotes.getData(key, value). Vous ne pouvez pas stocker ou accéder aux données de quelque manière que ce soit, autre que celle fournie par les paramètres et botNotes. Vous devez créer une fonction qui, lorsqu'elle est appelée, retourne une chaîne north, east, south, westou none. Il y aura 3 arguments pour la fonction:

• Un objet avec quatre entiers ( locationX, locationY, coins, arenaLength), votre emplacement actuel, vos pièces, et la longueur de l'arène

• Un tableau multidimensionnel avec les coordonnées X et Y d’autres bots, ainsi que leur nombre de pièces,[[0,5,4],[4,7,1],[7,4,12]]

• Un tableau avec les emplacements de pièces énumérés (Gold est toujours le premier)

C’est un défi roi, les échappatoires standard sont interdites. Votre fonction sera exécutée plusieurs milliers de fois, à chaque fois autorisée un "Move". Notez que si le jeu dépasse 20 000 coups , le bot avec le plus de pièces gagne. Cela sera fait 8 000 fois, pour éliminer le caractère aléatoire.

Chatroom: https://chat.stackexchange.com/rooms/81347/gold-collectors-koth

Prix:

Première place: prime de 100 points
Communauté préférée: réponse acceptée de 15 points

Gagnants:

Première place: TBTPTGCBCBA
Deuxième place: Big roi colline
Troisième place: Potentiellement Victorieux
Quatrième place: Polite myopes Ivre Bot
Cinquième place: Sécurité Coin

BaitBot - Node JavaScript.JS

Pourquoi se donner la peine de courir ou de courir si vous ne pouvez jamais attraper? Au lieu de cela, BaitBot trouve la pièce la plus proche et attend qu'un bot plus faible s'en approche également. Quand ils sont tous les deux adjacents, baitBot cherche la pièce en supposant que le bot le plus faible le sera également. Si baitBot attend et qu'un bot plus fort s'approche, il attrape juste la pièce et monte à cheval. Essaie-moi!

function baitBot(me, others, coins) {
  let directions = ['none','east','south','west','north']
  function distanceTo(a) {
    return (Math.abs(a[0] - me.locationX) + Math.abs(a[1] - me.locationY))
  }
  function distanceBetween(a, b){
    return (Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]))
  }
  function adjacentDir(a) {
    //0 = no, 1,2,3,4 = ESWN
    if(distanceTo(a) == 1) {
      if(a[0] > me.locationX){ return 1}
      else if(a[0] < me.locationX) {return 3}
      else if(a[1] > me.locationY) {return 2}
      else{ return 4}
    }
    else {return 0}
  }
  function edibility(a) {
    return me.coins - a[2]
  }

  //Find nearest coin and get next to it
  let closestCoin = coins.sort((a,b) => distanceTo(a) - distanceTo(b))[0]
  if(distanceTo(closestCoin) > 1) {
    if(closestCoin[0] > me.locationX){ return 'east'}
    else if(closestCoin[0] < me.locationX){ return 'west'}
    else if(closestCoin[1] < me.locationY){ return 'north'}
    else if(closestCoin[1] > me.locationY){ return 'south'}
  }

  //If we're next to a coin and there's a threat close, just grab it
  let nearestThreat = others.filter(a => edibility(a) < 0).sort((a,b) => distanceBetween(a, closestCoin) - distanceBetween(b, closestCoin))[0]
  if(nearestThreat && distanceBetween(nearestThreat, closestCoin) <= 2) {
    return directions[adjacentDir(closestCoin)]
  }



  //Otherwise, wait until there's a target also next to the coin. If none are close, just take it
  let targets = others.filter(a => edibility(a) > 0 && distanceBetween(closestCoin, a) <= 3)
  targets.sort((a,b) => distanceBetween(a, closestCoin) - distanceBetween(b, closestCoin))
  if(targets.length > 0 && distanceBetween(targets[0], closestCoin) > 1){
    return directions[0]
  }
  return directions[adjacentDir(closestCoin)]

}

Algorithme d'apprentissage de première génération | JavaScript (Node.js)

function run() {
	return ['north','east','south','west'][(Math.random()*4)|0];
}

Essayez-le en ligne!

Avez-vous déjà vu ces timelapses d'apprentissage d'algorithmes apprendre à jouer à un jeu? Ils se déplacent souvent de manière presque aléatoire au cours des premières générations ...

Potentiellement victorieux | JavaScript

La couleur préférée pour ce bot est #1600a6.

function (me, others, coins)
{
    let huntingTimer = botNotes.getData("huntingTimer");
    let huntedIndex = botNotes.getData("huntedIndex");
    if(!huntingTimer)
    huntingTimer = 0;
    else if(huntingTimer >0)
    huntingTimer--;
    else if(huntingTimer == -1)
    huntingTimer = Math.ceil(20*(1+Math.log2(me.coins/25)));
    else
    huntingTimer++;

    function distanceFromMe(X, Y) { return Math.abs(me.locationX - X) + Math.abs(me.locationY - Y); }

    function U(x, y)
    {
    function distance(X, Y) { return Math.abs(X-x) + Math.abs(Y-y); }
    function gravitation(k, X, Y) { return - k / ( distance(X, Y) + .2 ); }
    function exponential(k, q, X, Y) { return - 5*k * Math.exp(- q * distance(X,Y)); }

    // No going away from the arena.
    if(!((0 <= x) && (x < me.arenaLength) && (0 <= y) && (y < me.arenaLength)))
    {
        return Infinity;
    }

    let reachability = [1, 1, 1, 1, 1];
    let distances = coins.map(c => distanceFromMe(c[0], c[1]));
    for(let i = 0; i < others.length; i++)
    {
        for(let coin = 0; coin < 5; coin++)
            reachability[coin] += (Math.abs(others[i][0] - coins[coin][0]) + Math.abs(others[i][1] - coins[coin][1])) < distances[coin];
    }

    let potential = gravitation(40, coins[0][0], coins[0][1]) / (reachability[0]); // Gold

    // Silver
    for(let i = 1; i < 5; i++)
    {
        potential += gravitation(10, coins[i][0], coins[i][1]) / (reachability[i]);
    }

    others.sort((a, b) => b[2] - a[2]);

    // Other bots
    for(let i = 0; i < others.length; i++)
    {
        if(
            ((Math.abs(me.locationX - others[i][0]) + Math.abs(me.locationY - others[i][1])) < 3) &&
            (huntingTimer == 0) &&
            (me.coins > 25) && 
            (me.coins < (others[0][2]*.9)) &&
            (others[i][2] < me.coins-5) && (others[i][2] >= 10)
        )
        {
            huntingTimer = -10;
            huntedIndex = i;
        }

        if((huntingTimer < 0) && (huntedIndex == i))
           potential += exponential(30, 1, others[i][0], others[i][1]);

        if(others[i][2] >= me.coins)
        {
        // Otherwise, they could eat us, and we will avoid them.
        potential += exponential(-1400, 3, others[i][0], others[i][1]);
        }
    }

    return potential;
    }

    // All possible squares we can move to, with their names.
    let movements = [
    [ "north", U(me.locationX, me.locationY - 1)],
    [ "south", U(me.locationX, me.locationY + 1)],
    [ "east", U(me.locationX + 1, me.locationY)],
    [ "west", U(me.locationX - 1, me.locationY)],
    [ "none", U(me.locationX, me.locationY)]
    ];

    botNotes.storeData("huntingTimer", huntingTimer);
    botNotes.storeData("huntedIndex", huntedIndex);

    // Sort them according to the potential U and go wherever the potential is lowest.
    movements.sort((a, b) => a[1] - b[1]);
    return movements[0][0];
}

(Toutes mes excuses pour la mise en forme peu soignée, l'indentation de 4 espaces pour ce site ne va pas bien avec ma coutume d'utiliser des onglets.)

Explication approximative

Je démissionne par la présente pour tenter de mettre à jour l'explication des formules. Les coefficients changent constamment et il est un peu difficile de garder l'explication à jour. Je vais donc simplement expliquer le principe général.

Chaque pièce et chaque bot génère un champ de force avec un potentiel. J'ajoute simplement les potentiels de tout et le bot va ensuite là où le potentiel est le plus bas. (Évidemment, cette idée est volée à la physique.)

J'utilise deux types de potentiels. Le premier est un pseudo-gravitationnel (qui agit à toute distance), avec Lekest une "force" du champ et, avec ce choix de signe, le potentiel est attrayant. Lerici (et partout ailleurs) est la distance dans la métrique du taxi,r = | x₁ - x₂ | + | y₁ - y₂ | .

$$U = - \frac{k}{r + \frac 1 5} \cdot \frac{1}{1 + n}.$$

J'utilise k = 40 pour les pièces d'or et k = 10 pour les pièces d'argent. n est le nombre de robots qui sont plus proches de la pièce que nous. Sinon, nous ignorons absolument les autres robots (si nous nous opposons à un bot plus puissant, nous nous enfuyons, mais c'est tout). J'apprécie les pièces d'or pour plus qu'elles ne valent, car sinon, les bots qui ont pour objectif principal de chercher après l'or me battent tout le temps.

Le second potentiel est un potentiel en décroissance exponentielle (qui n'agit effectivement que sur de très petites distances). Ceci est généré par les autres robots, principalement les plus puissants.

Celles-ci produisent un champ avec Cette force est prohibitive à la gamme 0-1, mais décroît à presque rien aux distances plus grandes. (Distance + 1 signifie couper la force en 1/20.)

$$U = -5 \times 1400 e^{-3r}.$$

En général, nous n'attaquons pas les autres robots de manière intentionnelle (bien sûr, s'ils nous gênent et que nous leur piétinons, c'est de leur faute), mais il est possible de le faire. Si certaines conditions difficiles sont remplies, nous pouvons passer en mode chasse en étant concentrés sur un seul bot. Pour entrer en mode chasse:

1. Nous devons avoir au moins 25 pièces. (Nous devons d'abord obtenir des pièces de monnaie.)
2. Ils doivent avoir au plus (nos pièces - 5) pièces et au moins 10 pièces. (Nous ne voulons pas chasser quelqu'un qui attrape une pièce et est soudain plus puissant, et nous ne voulons pas non plus poursuivre les robots à zéro pièce.)
3. Nous devons prendre au moins 1/10 de ses pièces par rapport au bot actuellement en tête du classement. (Vous devez avoir la chance de chasser quelque chose, il n’est donc pas nécessaire de donner une bonne position juste pour tenter notre chance.)
4. Nous ne devons pas être sur un temps de recharge de chasse (voir ci-dessous).

Si toutes ces conditions sont remplies, le mode de recherche est activé. Pour les 10 tours suivants, le bot traqué n’émet que le potentiel Une fois ces 10 tours écoulés, nous entrons dans le temps de recharge de la chasse, pendant lequel nous ne pouvons plus entrer en mode chasse. (C'est pour nous empêcher de poursuivre inutilement et infructueusement un bot pendant que tous les autres saisissent des pièces avec bonheur.) Le temps de recharge de la chasse est de 20 tours lorsque nous avons 25 pièces et augmente de 20 pièces par double de ce montant. (En d’autres termes, le temps de recharge est

$$U = -150 e^{-r}.$$ 20(1 + log2(c / 25)).) (Nous l’utilisons parce qu’en fin de jeu, tous les robots pouvant être chassés sont probablement morts, et donc toute chasse sera probablement vaine. Pour cette raison, nous voulons limiter le temps perdu. Mais parfois, un retard chanceux manger du gibier peut tout changer, alors nous gardons la possibilité.)

Enfin, l’arène entière est placée dans un puits de potentiel infini qui empêche le bot de s’échapper.

Grand roi petite colline | JavaScript

function BigKingLittleHill(me, enemies, coins) {

	
	// Is a move safe to execute?
	function isItSafe(x){
			let loc = [x[0] + me.locationX,x[1] + me.locationY];
			return loc[0] >= 0 && loc[0] < me.arenaLength
			&& loc[1] >= 0 && loc[1] < me.arenaLength
			&& enemies
					.filter(enemy => me.coins <= enemy[2])
					.filter(enemy => getDist(enemy,loc) == 1).length === 0;
	}

	
	// Dumb conversion of relative coord to direction string
	function coordToString(coord){
		if (coord[0] == 0 && coord[1] == 0) return 'none';
		if (Math.abs(coord[0]) > Math.abs(coord[1]))
			return coord[0] < 0 ? 'west' : 'east';
		return coord[1] < 0 ? 'north' : 'south';
	}
	
	
	// Calculate a square's zone of control
	function getZOC(x) {
		let n = 0;
		for(let i = 0; i < me.arenaLength;i++){
			for(let j = 0; j < me.arenaLength;j++){
				if (doesAControlB(x, [i,j])) n++;
			}
		}
		return n;
	}
	
	function doesAControlB(a, b) {
		return getEnemyDist(b) > getDist(a, b);
	}
  
	// Distance to nearest enemy
	function getEnemyDist(x) {
			return enemies.filter(enemy => enemy[2] >= me.coins/50).map(enemy => getWeightedDist(enemy, x)).reduce((accumulator, current) => Math.min(accumulator, current));
	}
  
	// Weights distance by whether enemy is weaker or stronger
	function getWeightedDist(enemy, pos) {
		return getDist(enemy, pos) + (enemy[2] < me.coins ? 1 : 0);
	}
  
	function getDist(a, b){
		return (Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]))
	}
	
	//check whether there are coins in our Zone of Control, if yes move towards the closest one
	let loc = [me.locationX,me.locationY];
	let sortedCoins = coins.sort((a,b) => getDist(loc,a) - getDist(loc,b));
	for (let coin of sortedCoins) {
		if (doesAControlB(loc,coin)){
			return coordToString([coin[0] - loc[0],coin[1] - loc[1]]);
		}
	}
	
	//sort moves by how they increase our Zone of Control
	northZOC = [[0,-1], getZOC([loc[0],loc[1]-1])];
	southZOC = [[0,1], getZOC([loc[0],loc[1]+1])];
	westZOC = [[-1,0], getZOC([loc[0]-1,loc[1]])];
	eastZOC = [[1,0], getZOC([loc[0]+1,loc[1]])];
	noneZOC = [[0,0], getZOC([loc[0],loc[1]])];
	let moves = [northZOC,southZOC,westZOC,eastZOC,noneZOC].sort((a,b) => b[1] - a[1]);
	
	//check whether these moves are safe and make the highest priority safe move
	for (let move of moves) {
		if (isItSafe(move[0])) { 
			return coordToString(move[0]);
		}
	}
	//no moves are safe (uh oh!), return the highest priority
	return coordToString(moves[0][0])
}

Essayez-le en ligne!

Big King Little Hill prend ses décisions en fonction de «zones de contrôle». Il ne poursuivra que les pièces qui se trouvent dans sa zone de contrôle, ce qui signifie qu'il peut atteindre la pièce avant tout autre bot. Lorsqu'il n'y a pas de pièces dans sa zone de contrôle, il se déplace plutôt pour maximiser la taille de sa zone de contrôle. Big King Little Hill calcule la zone de contrôle de chacun de ses 5 mouvements possibles et privilégie les mouvements qui maximisent la taille de sa zone de contrôle. De cette manière, Big King Little Hill atteint finalement un maximum de contrôle local (petite colline) et attend qu'une pièce soit générée dans sa zone. De plus, Big King Little Hill rejette toute initiative qui pourrait entraîner sa mort, à moins qu'il n'y ait pas d'alternative.

Big King Little Hill est un pessimiste (il préfère le terme réaliste) car il ne se donne pas la peine de contester une pièce qu'il n'est pas assuré d'obtenir. C'est aussi un pacifiste dans le sens où il ne recherche en aucun cas les robots les plus faibles (bien qu'il puisse en faire un s'ils ne gênent pas). Enfin, Big King Little Hill est un lâche qui ne mettra pas sa vie en péril pour quelque récompense que ce soit, sauf obligation absolue.

Pièce de sécurité | JavaScript

SafetyCoin=(myself,others,coins)=>{
  x=myself.locationX;
  y=myself.locationY;
  power=myself.coins;
  arenaSize=myself.arenaLength;
  dist=0;
  optimalCoin=7;
  optimalDist=11*arenaSize;
  for(i=0;i<coins.length;i++){
    enemyDist=3*arenaSize;
    dist=Math.abs(x-coins[i][0])+Math.abs(y-coins[i][1])
    for(j=0;j<others.length;j++){
      if(i==0){
        if(others[j][2]+5>=power){
          enemyDist=Math.min(enemyDist,Math.abs(others[j][0]-coins[i][0])+Math.abs(others[j][1]-coins[i][1]))
        }
      }
      else{
        if(others[j][2]+2>=power){
          enemyDist=Math.min(enemyDist,Math.abs(others[j][0]-coins[i][0])+Math.abs(others[j][1]-coins[i][1]))
        }
      }

    }
    if(enemyDist>dist){
      if(i==0){
        if(dist/5<optimalDist){
          optimalDist=dist/5;
          optimalCoin=i;
        }
      }
      else{
        if(dist/2<optimalDist){
          optimalDist=dist/2;
          optimalCoin=i;
        }
      }
    }
  }
  if(optimalCoin==7){
    safeDir=15;
    if(x==0){safeDir-=8;}
    if(x==arenaSize-1){safeDir-=2;}
    if(y==0){safeDir-=1;}
    if(y==arenaSize-1){safeDir-=4;}
    for(i=0;i<others.length;i++){
      if(others[i][2]>=power){
        if(Math.abs(x-others[i][0])+Math.abs(y-others[i][1])==2){
          if(x-others[i][0]>0){safeDir-=8;}
          if(x-others[i][0]<0){safeDir-=2;}
          if(y-others[i][1]>0){safeDir-=1;}
          if(y-others[i][1]<0){safeDir-=4;}
        }
      }
    }
    directions=["north","east","south","west"];
    if(safeDir!=0){
      tmp="";
      tmp+="0".repeat(Math.max(Math.sqrt(arenaSize)/2|0,y-(arenaSize/2|0)));
      tmp+="2".repeat(Math.max(Math.sqrt(arenaSize)/2|0,(arenaSize/2|0)-y));
      tmp+="1".repeat(Math.max(Math.sqrt(arenaSize)/2|0,(arenaSize/2|0)-x));
      tmp+="3".repeat(Math.max(Math.sqrt(arenaSize)/2|0,x-(arenaSize/2|0)));
      rnd=tmp[Math.random()*tmp.length|0];
      while(!(2**rnd&safeDir)){rnd=tmp[Math.random()*tmp.length|0];}
      return directions[rnd];
    }
    return "none";//the only safe move is not to play :P
  }
  distX=coins[optimalCoin][0]-x;
  distY=coins[optimalCoin][1]-y;
  if(Math.abs(distX)>Math.abs(distY)){
    if(distX>0){return "east";}
    else{return "west";}
  }
  else{
    if(distY>0){return "south";}
    else{return "north";}
  }
}

Ce bot se dirige directement vers une pièce de valeur pondérée (valeur / distance) qu'il ne peut pas mourir d'atteindre en même temps ou après un autre bot. S'il n'y a pas de pièce de monnaie valide avec cette propriété, elle se trouve là où il se trouve que le bot se déplace maintenant dans une direction de sécurité aléatoire (la sécurité signifie que si un bot s'approche de lui, la pièce de sécurité ne peut pas entrer en collision. Cela lui permet d'échanger des places avec un autre bot si juste à côté) pesant vers le centre de l’arène.

Le bot qui joue le jeu avec prudence mais qui peut être agressif | JavaScript

Couleur préférée: #F24100

Note: Bien que ce bot ait pris la 1ère place, il doit faire équipe avec "Feudal Noble" à la fin et le manger pour plus de pièces. Sinon, ce bot aurait été 3ème. Si vous êtes intéressé par les robots qui sont plus puissants individuellement, allez voir Potential Victorious et Big King Little Hill .

function (me, monsters, coins) {
    var i, monstersCount = monsters.length, phaseSize = Math.round((me.arenaLength - 4) / 4),
        center = (me.arenaLength - 1) / 2, centerSize = me.arenaLength / 4,
        centerMin = center - centerSize, centerMax = center + centerSize, centerMonsters = 0, centerMonstersAvg = null,
        end = 2e4, apocalypse = end - ((me.arenaLength * 2) + 20), mode = null;

    var getDistance = function (x1, y1, x2, y2) {
        return (Math.abs(x1 - x2) + Math.abs(y1 - y2)) + 1;
    };

    var isAtCenter = function (x, y) {
        return (x > centerMin && x < centerMax && y > centerMin && y < centerMax);
    };

    var round = botNotes.getData('round');
    if (round === null || !round) round = 0;
    round++;
    botNotes.storeData('round', round);

    var isApocalypse = (round >= apocalypse && round <= end);
    if (isApocalypse) {
        mode = botNotes.getData('mode');
        if (mode === null || !mode) mode = 1;
    }

    for (i = 0; i < monstersCount; i++) if (isAtCenter(monsters[i][0], monsters[i][1])) centerMonsters++;

    var lc = botNotes.getData('lc');
    if (lc === null || !lc) lc = [];
    if (lc.length >= 20) lc.shift();
    lc.push(centerMonsters);
    botNotes.storeData('lc', lc);

    if (lc.length >= 20) {
        centerMonstersAvg = 0;
        for (i = 0; i < lc.length; i++) centerMonstersAvg += lc[i];
        centerMonstersAvg = centerMonstersAvg / lc.length;
    }

    var getScore = function (x, y) {
        var score = 0, i, chaseFactor = 0.75, coinFactor = 1;

        if (monstersCount < phaseSize) {
            chaseFactor = 0;
            coinFactor = 0.25;
        } else if (monstersCount < phaseSize * 2) {
            chaseFactor = 0;
            coinFactor = 0.5;
        } else if (monstersCount < phaseSize * 3) {
            chaseFactor = 0.5;
            coinFactor = 0.75;
        }

        if (isApocalypse) {
            if (mode === 1) {
                var centerDistance = getDistance(x, y, center, center);
                if (centerDistance <= 3) {
                    mode = 2;
                } else {
                    score += 5000 / (centerDistance / 10);
                }
            }
            if (mode === 2) chaseFactor = 1000;
        }

        for (i = 0; i < monstersCount; i++) {
            var monsterCoins = monsters[i][2], monsterDistance = getDistance(x, y, monsters[i][0], monsters[i][1]);
            if (me.coins > monsterCoins && monsterDistance <= 3) {
                score += (Math.min(5, monsterCoins) * chaseFactor) / monsterDistance;
            } else if (me.coins <= monsterCoins && monsterDistance <= 3) {
                score -= (monsterDistance === 3 ? 50 : 10000);
            }
        }

        for (i = 0; i < coins.length; i++) {
            var coinDistance = getDistance(x, y, coins[i][0], coins[i][1]),
                coinDistanceCenter = getDistance(center, center, coins[i][0], coins[i][1]),
                coinValue = (i === 0 ? 250 : 100), coinCloserMonsters = 0;

            for (var j = 0; j < monstersCount; j++) {
                var coinMonsterDistance = getDistance(monsters[j][0], monsters[j][1], coins[i][0], coins[i][1]);
                monsterCoins = monsters[j][2];

                if (
                    (coinMonsterDistance < coinDistance && monsterCoins >= me.coins / 2) ||
                    (coinMonsterDistance <= coinDistance && monsterCoins >= me.coins)
                ) {
                    coinCloserMonsters++;
                }
            }

            var coinMonsterFactor = (100 - ((100 / monstersCount) * coinCloserMonsters)) / 100;
            if (coinMonsterFactor < 1) coinMonsterFactor *= coinFactor;
            if (coinMonsterFactor >= 1) coinMonsterFactor *= 15;
            score += ((coinValue * coinMonsterFactor) / coinDistance) + (centerMonstersAvg === null || centerMonstersAvg > 1.75 ? -1 * (50 / coinDistanceCenter) : 200 / coinDistanceCenter);
        }

        return score + Math.random();
    };

    var possibleMoves = [{x: 0, y: 0, c: 'none'}];
    if (me.locationX > 0) possibleMoves.push({x: -1, y: 0, c: 'west'});
    if (me.locationY > 0) possibleMoves.push({x: -0, y: -1, c: 'north'});
    if (me.locationX < me.arenaLength - 1) possibleMoves.push({x: 1, y: 0, c: 'east'});
    if (me.locationY < me.arenaLength - 1) possibleMoves.push({x: 0, y: 1, c: 'south'});

    var topCommand, topScore = null;
    for (i = 0; i < possibleMoves.length; i++) {
        var score = getScore(me.locationX + possibleMoves[i].x, me.locationY + possibleMoves[i].y);
        if (topScore === null || score > topScore) {
            topScore = score;
            topCommand = possibleMoves[i].c;
        }
    }

    if (isApocalypse) botNotes.storeData('mode', mode);

    return topCommand;
}

Ce bot (aka "TBTPTGCBCBA") tente de prendre la meilleure décision possible en générant un score pour chaque coup possible et sélectionne le coup avec le score le plus élevé à chaque tour.

Le système de notation comporte de nombreux détails qui ont évolué depuis le début du défi. Ils peuvent être décrits généralement comme ceci:

• Plus les pièces sont proches d'un mouvement possible, plus le score obtenu est important. Si une pièce n'a pas d'autre concurrent possible, le score va encore plus haut. Si une pièce a d'autres concurrents possibles, le score diminue.
• Si un autre bot est proche d'un mouvement possible et a moins de pièces, selon la phase du jeu, cela pourrait signifier plus de points pour ce mouvement. Il est donc décontracté pour "TBTPTGCBCBA" de manger quelques autres bots à chaque match.
• Si un autre bot est proche d'un mouvement possible avec un nombre de points égal ou supérieur, ce mouvement obtient un score négatif suffisant pour éviter la mort. Bien sûr, il peut arriver que tous les mouvements possibles soient mauvais et que la mort ne puisse être évitée, mais cela est très rare.
• Il existe un mécanisme permettant de suivre le nombre de robots au milieu du tableau pour les 20 derniers tours. Si la moyenne est suffisamment basse, tous les mouvements vers les pièces du milieu obtiennent un score plus élevé. Si la moyenne est élevée, tous les mouvements vers les pièces du milieu obtiennent un score inférieur. Ce mécanisme permet d'éviter les conflits avec "Feudal Noble". Puisque le "Noble féodal" est toujours au centre (sauf s'il est chassé), le nombre moyen de robots au milieu augmente et "TBTPTGCBCBA" comprend qu'il faut éviter le milieu s'il y a une meilleure option en dehors de la zone centrale. Si "Feudal Noble" meurt, la moyenne baisse et "TBTPTGCBCBA" comprend qu'il peut utiliser le milieu.
• Certains facteurs changent de manière dynamique en fonction de la phase du jeu (détectés en fonction du nombre de bots vivants), ces facteurs affectent le score de chacun des éléments ci-dessus.
• Ce bot a une capacité spéciale. Au fil du temps, il se lasse de l'égoïsme de "Feudal Noble" et de l'oppression des paysans. Au bon moment, cela mettra fin au désagréable système de féodalisme. Une tentative réussie aide non seulement les paysans pauvres, mais offre également une plus grande chance de gagner grâce aux pièces prises au "Féodal Noble".

L'anti-capitaliste | Javascript

N'a aucune incitation à aller après les pièces de monnaie, mais essaie de se placer exactement entre les deux bots les plus riches avec le même montant d'argent, dans l'espoir qu'ils le pourchasseront et le rattraperont en même temps, emmenant deux capitalistes avec lui à sa mort. . Ne résiste pas activement à obtenir des pièces de monnaie, il pourrait donc devenir une cible plus juteuse.

function antiCapitalist(me, capitalists, coins){

    function acquireTargets(capitalists){
        capitalists.sort((a, b) => a[2] < b[2]);
        let previousCapitalist;
        for(let i in capitalists){
            let capitalist = capitalists[i];

            if(capitalist[2] === 0){
                return false;
            }
            if(previousCapitalist && capitalist[2] === previousCapitalist[2]){
                return [previousCapitalist, capitalist];
            }

            previousCapitalist = capitalist;
        }

        return false;
    }

    function move(){
        const targets = acquireTargets(capitalists);
        if(!targets){
            return 'none';
        }

        const coordinates = [Math.floor((targets[0][0] + targets[1][0]) / 2), Math.floor((targets[0][1] + targets[1][1]) / 2)];
        if(me.locationX !== coordinates[0]){
            return me.locationX < coordinates[0] ? 'east' : 'west';
        }
        else if(me.locationX !== coordinates[1]){
            return me.locationY < coordinates[1] ? 'south' : 'north';
        }
        else {
            return 'none';
        }
    }

    return move();
}

Le GUT, JavaScript

function gut(me, others, coins) {
    // Prepare values for the calculation
    var x = me.locationX;
    var y = me.locationY;
    var cMe = me.coins+1;
    var arenaLen = me.arenaLength;

    var objects = [];

    // Add bots to objects
    for (var i = 0; i < others.length; i++) {
        objects.push([others[i][0],others[i][1],others[i][2]/cMe]);
    }

    // Add coins to objects
    for (var j = 0; j < coins.length; j++) {
        var coinVal = 0;

        if (j == 0) {
            // Gold has a higher coin value
            coinVal = -10;
        } else {
            // Silver has a lower coin value
            coinVal = -5;
        }

        objects.push([coins[j][0],coins[j][1],coinVal/cMe]);
    }

    // Perform the calculation
    // x acceleration
    var x_acceleration = 0;

    for (var k=0; k < objects.length; k++) {
        var kval = objects[k][2];
        var xval = objects[k][0];

        x_acceleration += 200*kval/cMe*(x-xval)*Math.exp(Math.pow(kval,2)-50*Math.pow(x-xval,2));
    }

    // y acceleration
    var y_acceleration = 0;

    for (var l=0; l < objects.length; l++) {
        var kval = objects[l][2];
        var yval = objects[l][1];

        y_acceleration += 200*kval/cMe*(y-yval)*Math.exp(Math.pow(kval,2)-50*Math.pow(y-yval,2));
    }

    // Compare the values
    if (Math.abs(y_acceleration)>Math.abs(x_acceleration)) {
        if (y_acceleration < 0) {
            // Don't fall off the edge
            if (y>0) {
                return "north";
            } else {
                return "none";
            }
        } else {
            if (y<arenaLen-1) {
                return "south";
            } else {
                return "none";
            }
        }
    } else if (Math.abs(y_acceleration)<Math.abs(x_acceleration)) {
        if (x_acceleration < 0) {
            if (x>0) {
                return "west";
            } else {
                return "none";
            }
        } else {
            if (x<arenaLen-1) {
                return "east";
            } else {
                return "none";
            }
        }
    } else {
        return "none";
    }
}

Avec Potential Victorious, nous avons deux champs: le champ bot et le champ pièce. Cependant, la nature n'est pas si compliquée. Il est temps d'unifier les deux champs pour produire la grande théorie unifiée .

Premièrement, nous devons déterminer le potentiel de ce domaine. En supposant que notre propre bot n'influence en aucun cas le champ, nous pouvons écrire ceci comme suit:

$$V = \sum_\limits{n} k_n\left(e^{k_n^2-100(x-x_n)^2}+e^{k_n^2-100(y-y_n)^2}\right)$$

$k_n$$(x_n, y_n)$

La propriété relative de l'objet est calculée comme suit:

$$k = \frac{c_{\text{object}}}{c_{\text{me}}}$$

$c$$c_{\text{me}} = c_{\text{self}} + 1$$c_{\text{self}}$

_{Appelons simplement cette correction une partie de Modified Betanian Dynamics (MOBD) .}

Nous pouvons également trouver l'énergie cinétique sous la forme:

$$T = \frac{1}{2}c_{\text{me}}(\dot{x}^2 + \dot{y}^2)$$

Nous pouvons maintenant calculer l'action:

$$\begin{align}\text{Action} &= \int^b_a (T-V)dt\\&=\int^b_a \left(\frac{1}{2}c_{\text{me}}(\dot{x}^2 + \dot{y}^2) - \sum_\limits{n} k_n\left(e^{k_n^2-100(x-x_n)^2}+e^{k_n^2-100(y-y_n)^2}\right)\right) dt\end{align}$$

Et ainsi le lagrangien de notre bot dans le champ coin-bot est:

$$\mathcal{L} = \frac{1}{2}c_{\text{me}}(\dot{x}^2 + \dot{y}^2) - \sum_\limits{n} k_n\left(e^{k_n^2-100(x-x_n)^2}+e^{k_n^2-100(y-y_n)^2}\right)$$

Nous devons maintenant résoudre les équations d'Euler-Lagrange:

$$\frac{d}{dt} \frac{\partial \mathcal{L}}{\partial \dot{x}} = \frac{\partial \mathcal{L}}{\partial x}$$

et:

$$\frac{d}{dt} \frac{\partial \mathcal{L}}{\partial \dot{y}} = \frac{\partial \mathcal{L}}{\partial y}$$

Alors:

$$\frac{d}{dt} \frac{\partial \mathcal{L}}{\partial \dot{x}} = \frac{d}{dt} \left[c_{\text{me}}\dot{x}\right] = c_{\text{me}}\ddot{x}$$

$$\frac{\partial \mathcal{L}}{\partial x} = \sum\limits_n 200 k_n \left(x - x_n\right) e^{k_n^2 - 100(x-x_n)^2}$$

$$\Rightarrow \ddot{x} = \sum\limits_n \frac{200k_n}{c_{\text{me}}} \left(x - x_n\right) e^{k_n^2 - 100(x-x_n)^2}$$

Et aussi:

$$\frac{d}{dt} \frac{\partial \mathcal{L}}{\partial \dot{y}} = \frac{d}{dt} \left[c_{\text{me}}\dot{y}\right] = c_{\text{me}}\ddot{y}$$

$$\frac{\partial \mathcal{L}}{\partial y} = \sum\limits_n 200 k_n \left(y - y_n\right) e^{k_n^2 - 100(y-y_n)^2}$$

$$\Rightarrow \ddot{y} = \sum\limits_n \frac{200k_n}{c_{\text{me}}} \left(y - y_n\right) e^{k_n^2 - 100(y-y_n)^2}$$

Maintenant, nous n’avons plus besoin d’aller plus loin: nous examinons simplement la direction de l’accélération globale:

$$\text{output} = \begin{cases}\text{north} &\text{if }\ddot{y}<0 \text{ and } |\ddot{y}|>|\ddot{x}| \\ & \\ \text{south} &\text{if }\ddot{y}>0 \text{ and } |\ddot{y}|>|\ddot{x}| \\ & \\ \text{west} &\text{if }\ddot{x}<0 \text{ and } |\ddot{x}|>|\ddot{y}| \\ & \\ \text{east} &\text{if }\ddot{x}>0 \text{ and } |\ddot{x}|>|\ddot{y}| \\ & \\ \text{none} &\text{if }|\ddot{y}|=|\ddot{x}|\end{cases}$$

Et juste comme ça, nous avons unifié les pièces et les robots. Où est mon prix Nobel?

Boucle d'or, JavaScript (Node.js)

function goldilocks(me, others, coins) {
  let target = coins[0]; // Gold
  let x = target[0] - me.locationX;
  let y = target[1] - me.locationY;

  mymove = 'none'
  if (Math.abs(x) <= Math.abs(y) && x != 0)
    mymove = x < 0 ? 'west' : 'east'
  else if (y != 0)
    mymove = y < 0 ? 'north' : 'south'

  return mymove
}

Essayez-le en ligne!

Il suffit de verrouiller l'emplacement de la pièce d'or et de s'y déplacer à chaque fois. (Merci au bot 'B33-L1N3' de @ Mayube pour le code original utilisé, bien qu'il ne reste pratiquement plus rien.)

Algorithme d'apprentissage de troisième génération | JavaScript (Node.js)

function run(me) {
	options = [];
	if (me.locationX > 0) options.push('west');
	if (me.locationY > 0) options.push('north');
	if (me.locationX < me.arenaLength) options.push('east');
	if (me.locationY < me.arenaLength) options.push('south');

	return options[Math.floor(Math.random() * options.length)];
}

Essayez-le en ligne!

Après quelques générations d'apprentissage, ce bot a appris que quitter l'arène = mauvais

B33-L1N3 | JavaScript (Node.js)

function(me, others, coins) {
	// Do nothing if there aren't any coins
	if (coins.length == 0) return 'none';
	// Sort by distance using Pythagoras' Theorem
	coins = coins.sort((a, b) => (a[0] ** 2 + a[1] ** 2) - (b[0] ** 2 + b[1] ** 2));
	// Closest coin
	let target = coins[0];
	let x = target[0];
	let y = target[1];

	// Util function for movement
	function move(pos, type) {
		let moveTypes = { X: ['east', 'west'], Y: ['south', 'north'] };
		if (pos > me['location'+type]) return moveTypes[type][0];
		else return moveTypes[type][1];
	}

	// Move the shortest distance first
	if (x < y && x != me.locationX) return move(x, 'X');
	else if (y != me.locationY) return move(y, 'Y');
}

Essayez-le en ligne!

Fait un beeline pour la pièce la plus proche

Livin 'on the Edge, JavaScript

function LivinOnTheEdge (myself, others, coins) {
  x = myself.locationX;
  y = myself.locationY;
  xymax = myself.arenaLength - 1;
  if (x < xymax && y == 0) {
      return 'east';
    } else if (y < xymax && x == xymax) {
      return 'south';
    } else if (x > 0 && y == xymax) {
      return 'west';
  } else {
    return 'north';
  }
}

Celui-ci a entendu dire que le bord de l'arène était un endroit dangereux. Ne sachant aucune peur, il tourne inlassablement le tableau dans le sens des aiguilles d'une montre, à seulement quelques centimètres de la mort certaine qui l'attend derrière la frontière, espérant qu'aucun autre bot n'ose se déplacer si près du bord.

Damacy, JavaScript (Node.js)

function damacy(me, others, coin) {
  let xdist = t => Math.abs(t[0] - me.locationX)
  let ydist = t => Math.abs(t[1] - me.locationY)
  function distanceCompare(a, b, aWt, bWt) {
    aWt = aWt || 1
    bWt = bWt || 1
    return (xdist(a) + ydist(a)) / aWt - (xdist(b) + ydist(b)) / bWt
  }
  function hasThreat(loc) {
    let threat = others.filter(b => b[0] == loc[0] && b[1] == loc[1] && b[2] >= me.coins)
    return (threat.length > 0)
  }
  function inArena(loc) {  // probably unnecessary for this bot
    return loc[0] >= 0 && loc[1] >= 0 && loc[0] < me.arenaLength && loc[1] < me.arenaLength
  }
  function sortedCoins() {
    coinsWithValues = coin.map((coords, i) => coords.concat((i == 0) ? 5 : 2))
    coinsWithValues.sort((a, b) => distanceCompare(a, b, a[2], b[2]))
    return coinsWithValues.map(c => c.slice(0, 2))
  }
  othersPrev = botNotes.getData('kata_others_pos')
  botNotes.storeData('kata_others_pos', others)
  if (othersPrev) {

    for(let i = 0; i < others.length; i++) {
      let bot = others[i]

      let matchingBots = othersPrev.filter(function (b) {
        let diff = Math.abs(b[0] - bot[0]) + Math.abs(b[1] - bot[1])
        if (diff >= 2)
          return false // bot can't have jumped
        return [0, 2, 5].includes(bot[2] - b[2])
      })

      if (matchingBots.length > 0) {
        let botPrev = matchingBots.shift()
        // remove matched bot so it doesn't get matched again later
        othersPrev = othersPrev.filter(b => b[0] != botPrev[0] || b[1] != botPrev[1])
        bot[0] = Math.min(Math.max(bot[0] + bot[0] - botPrev[0], 0), me.arenaLength-1)
        bot[1] = Math.min(Math.max(bot[1] + bot[1] - botPrev[1], 0), me.arenaLength-1)
      }
    }
  }

  let eatables = others.filter(b => b[2] < me.coins && b[2] > 0)
  let targets
  if (eatables.length > 0) {
    targets = eatables.sort(distanceCompare)
  }
  else {
    targets = sortedCoins()
  }

  let done, newLoc, dir
  while (!done && targets.length > 0) {
    t = targets.shift()
    if ((xdist(t) <= ydist(t) || ydist(t) == 0) && xdist(t) != 0) {
      let xmove = Math.sign(t[0] - me.locationX)
      dir = xmove < 0 ? 'west' : 'east'
      newLoc = [me.locationX + xmove, me.locationY]
      if (!hasThreat(newLoc) && inArena(newLoc))
        done = 1
    }

    if (!done) {
      let ymove = Math.sign(t[1] - me.locationY)
      dir = ['north', 'none', 'south'][ymove + 1]
      newLoc = [me.locationX, me.locationY + ymove]
      if (!hasThreat(newLoc) && inArena(newLoc))
        done = 1
    }
  }

  if (!done)
    dir = 'none'


  return dir
}

Essayez-le en ligne!

Un dernier bot katamari pour aujourd'hui, cette fois avec un peu de mémoire. Merci à @BetaDecay pour la suggestion de nom - certainement un nom plus amusant que monsimplePredictorKatamari .

Essaie de comprendre comment les bots se sont déplacés lors du dernier tour et, en fonction de cela, prédit où ils vont essayer de se déplacer à la fin de ce tour (en supposant qu'ils continuent à avancer dans la même direction).

(Merci à @ fəˈnɛtɪk, pour avoir remarqué que j'appelais un nom de fonction incorrect dans botNotes, et à @ OM pour avoir remarqué un bogue dans le code de base.)

Proton | JavaScript

Proton=(myself,others,coins)=>{
  x=myself.locationX;
  y=myself.locationY;
  power=myself.coins;
  arenaSize=myself.arenaLength;
  forceX=0;
  forceY=0;
  prevState=botNotes.getData("proton_velocity");
  if(prevState){
    velocity=prevState[0];
    direction=prevState[1];
  }
  else{
    velocity=0;
    direction=0;
  }
  for(i=0;i<coins.length;i++){
    if(Math.abs(x-coins[i][0])+Math.abs(y-coins[i][1])==1){
      velocity=0;
      direction=0;
      botNotes.storeData("proton_velocity",[velocity,direction]);
      if(x-coins[i][0]==1){return "west";}
      if(coins[i][0]-x==1){return "east";}
      if(y-coins[i][1]==1){return "north";}
      if(coins[i][1]-y==1){return "south";}
    }
    else{
      dist=Math.sqrt(Math.pow(x-coins[i][0],2)+Math.pow(y-coins[i][1],2));
      if(i==0){
        forceX+=(x-coins[i][0])*5/Math.pow(dist,3);
        forceY+=(y-coins[i][1])*5/Math.pow(dist,3);
      }
      else{
        forceX+=(x-coins[i][0])*2/Math.pow(dist,3);
        forceY+=(y-coins[i][1])*2/Math.pow(dist,3);
      }
    }
  }
  for(i=0;i<others.length;i++){
    if(Math.abs(x-others[i][0])+Math.abs(y-others[i][1])==1&&power>others[i][2]){
      velocity=0;
      direction=0;
      botNotes.storeData("proton_velocity",[velocity,direction]);
      if(x-others[i][0]==1){return "west";}
      if(others[i][0]-x==1){return "east";}
      if(y-others[i][1]==1){return "north";}
      if(others[i][1]-y==1){return "south";}
    }
    else{
      dist=Math.sqrt(Math.pow(x-others[i][0],2)+Math.pow(y-others[i][1],2));
      forceX+=(x-others[i][0])*others[i][2]/Math.pow(dist,3);
      forceY+=(y-others[i][1])*others[i][2]/Math.pow(dist,3);
    }
  }
  vX=velocity*Math.cos(direction)+10*forceX/Math.max(1,power);
  vY=velocity*Math.sin(direction)+10*forceY/Math.max(1,power);
  velocity=Math.sqrt(vX*vX+vY*vY);
  if(velocity==0){return "none"}
  retval="none";
  if(Math.abs(vX)>Math.abs(vY)){
    if(vX>0){
      if(x<arenaSize-1){retval="east";}
      else{vX=-vX;retval="west";}
    }
    else{
      if(x>0){retval="west";}
      else{vX=-vX;retval="east";}
    }
  }
  else{
    if(vY>0){
      if(y<arenaSize-1){retval="south";}
      else{vY=-vY;retval="north";}
    }
    else{
      if(y>0){retval="north";}
      else{vY=-vY;retval="south";}
    }
  }
  direction=Math.atan2(-vY,vX);
  botNotes.storeData("proton_velocity",[velocity,direction]);
  return retval;
}

Toutes les pièces (y compris celles détenues par d'autres robots) émettent une force répulsive envers Protonbot. Basé sur cette force, il accumule de la vitesse et rebondit sur les murs (se retourne immédiatement après avoir heurté une limite). Si elle finit à côté d'un robot ou d'une pièce de monnaie, elle peut consommer, la force nucléaire Forte prend le relais et bouge pour la consommer, réduisant ainsi sa vitesse.

Pas si aveugle | JavaScript (Node.js)

Note importante: Cette approche n’est pas tout à fait la mienne et une réponse à cette question a été donnée . Assurez-vous de voter cette réponse aussi.

Avez-vous déjà entendu parler de l'algorithme A * pathfinding? C'est ici. Il crée le meilleur chemin d'un point à la pièce de moindre valeur (chacun cherchant le plus précieux, personne ne cherchant le moins) et essaie de ne pas entrer en collision avec un autre utilisateur.

Paramètres attendus comme suit:

AI({locationX: 3, locationY: 1, arenaLength: [5,5]}, [[2,1],[2,2], ...],[[1,2],[3,1], ...])

---

Peut-être que j'en fais un qui chasse d'autres bots

---

function AI(me, others, coins){
    var h = (a,b) => Math.abs(a[0] -b[0]) + Math.abs(a[1] -b[1])
    var s = JSON.stringify;
    var p = JSON.parse;
    var walls = others.slice(0,2).map(s);
    var start = [me.locationX, me.locationY];
    var goal = coins.pop();
    var is_closed = {};
    is_closed[s(start)] = 0;
    var open = [s(start)];
    var came_from = {};
    var gs = {};
    gs[s(start)] = 0;
    var fs = {};
    fs[s(start)] = h(start, goal);
    var cur;
    while (open.length) {
        var best;
        var bestf = Infinity;
        for (var i = 0; i < open.length; ++i) {
            if (fs[open[i]] < bestf) {
                bestf = fs[open[i]];
                best = i;
            }
        }
        cur = p(open.splice(best, 1)[0]);
        is_closed[s(cur)] = 1;
        if (s(cur) == s(goal)) break;
        for (var d of [[0, 1], [0, -1], [1, 0], [-1, 0]]) {
            var next = [cur[0] + d[0], cur[1] + d[1]];
            if (next[0] < 0 || next[0] >= me.arenaLength[0] ||
                next[1] < 0 || next[1] >= me.arenaLength[1]) {
                continue;
            }
            if (is_closed[s(next)]) continue;
            if (open.indexOf(s(next)) == -1) open.push(s(next));
            var is_wall = walls.indexOf(s(next)) > -1;
            var g = gs[s(cur)] + 1 + 10000 * is_wall;
            if (gs[s(next)] != undefined && g > gs[s(next)]) continue;
            came_from[s(next)] = cur;
            gs[s(next)] = g;
            fs[s(next)] = g + h(next, goal);
        }
    }
    var path = [cur];
    while (came_from[s(cur)] != undefined) {
        cur = came_from[s(cur)];
        path.push(cur);
    }
    var c = path[path.length - 1];
    var n = path[path.length - 2];
    if(n){
        if (n[0] < c[0]) {
            return "west";
        } else if (n[0] > c[0]) {
            return "east";
        } else if (n[1] < c[1]) {
            return "north";
        } else {
            return "south";
        }
    }else{
        return "none";
    }
}

Lâche | Python 2

import random

def move(me, others, coins):
    target = (me.locationX, me.locationY)

    # Identify the dangerous opponents.
    threats = [i for i, value in enumerate(others[2]) if value >= me.coins]

    # If no one scary is nearby, find a nearby coin.
    safe = True
    for x, y in self.coins:
        distance = abs(me.locationX - x) + abs(me.locationY - y)
        safe = True
        for i in threats:
            if abs(others[0][i] - x) + abs(others[1][i] - y) <= distance:
                safe = False
                break

        if safe:
            target = (x, y)
            break

    # Otherwise, just try not to die.
    if not safe:
        certain = []
        possible = []
        for x, y in [
            (me.locationX, me.locationY),
            (me.locationX + 1, me.locationY),
            (me.locationX - 1, me.locationY),
            (me.locationX, me.locationY + 1),
            (me.locationX, me.locationY - 1),
        ]:
            # Don't jump off the board.
            if x < 0 or y < 0 or x == me.arenaLength or y == me.arenaLength:
                continue

            # Check if we can get away safely.
            for i in threats:
                if abs(others[0][i] - x) + abs(others[1][i] - y) <= 1:
                    break
            else:
                certain.append((x, y))

            # Check if we can take a spot someone is leaving.
            for i in threats:
                if others[0][i] = x and others[1][i] == y:
                    for i in threats:
                        if abs(others[0][i] - x) + abs(others[1][i] - y) == 1:
                            break
                    else:
                        possible.append((x, y))

        if certain:
            target = random.choice(certain)
        elif possible:
            target = random.choice(possible)
        # Otherwise, we're doomed, so stay still and pray.

    directions = []
    x, y = target
    if x < me.locationX:
        directions.append('west')
    if x > me.locationX:
        directions.append('east')
    if y < me.locationY:
        directions.append('north')
    if y > me.locationY:
        directions.append('south')
    if not directions:
        directions.append('none')

    return random.choice(directions)

Évitez les robots avec plus d'argent si possible. Sinon, prenez l'argent qui traîne.

Wild Goose Chase Bot, Javascript

Un bot qui sait très bien éviter les autres robots, mais très mal à obtenir des pièces.

---

Algorithme:

1. S'il n'y a pas de robots adjacents, renvoyez aucun
2. Autrement:
   1. Ne renvoyer aucun avec une chance aléatoire de 1/500 chance (ceci est destiné à éviter les impasses).
   2. Déterminez les espaces où vous pouvez vous déplacer en toute sécurité (à l'intérieur de l'arène et non occupés par un autre bot)
   3. Renvoyer un au hasard

---

Code:

function wildGooseChase(me, others, coins){
    x = me.locationX;
    y = me.locationY;

    dirs = {};
    dirs[(x+1)+" "+y] = "east";
    dirs[(x-1)+" "+y] = "west";
    dirs[x+" "+(y+1)] = "south";
    dirs[x+" "+(y-1)] = "north";

    mov = {};
    mov["east"] = [x+1,y];
    mov["west"] = [x-1,y];
    mov["north"] = [x,y-1];
    mov["south"] = [x,y+1]; 

    possibleDirs = ["east","west","north","south"];

    for (i = 0; i < others.length; i++){
        if (others[i][0]+" "+others[i][1] in dirs){
            possibleDirs.splice(possibleDirs.indexOf(dirs[others[i][0]+" "+others[i][1]]),1);
        }
    }

    if (possibleDirs.length == 4 || Math.floor(Math.random() * 500) == 0){
        return "none"
    }

    for (i = 0; i < possibleDirs.length; i++){
        if (mov[possibleDirs[i]][0] == me.arenaLength || mov[possibleDirs[i]][0] < 0 
        || mov[possibleDirs[i]][1] == me.arenaLength || mov[possibleDirs[i]][1] < 0){
            var index = possibleDirs.indexOf(possibleDirs[i]);
            if (index != -1) {
                possibleDirs.splice(index, 1);
                i--;
            }
        }
    }

    if (possibleDirs.length == 0){
         return "none";
    }

    return possibleDirs[Math.floor(Math.random() * possibleDirs.length)];
}

Essayez-le en ligne!

Note aux programmes Redwolf:

Ce bot a le potentiel de provoquer de très longs rounds. J'ai pris quelques libertés pour éviter les impasses, mais je n'ai pas vérifié si elles étaient réellement efficaces. Si ce bot pose un problème lors des tests, n'hésitez pas à le disqualifier.

KatamariWithValues, JavaScript (Node.js) ,

function katamariWithValues(me, others, coin) {
  let xdist = t => Math.abs(t[0] - me.locationX)
  let ydist = t => Math.abs(t[1] - me.locationY)
  function distanceCompare(a, b, aWt = 1, bWt = 1) {
    return (xdist(a) + ydist(a)) / aWt - (xdist(b) + ydist(b)) / bWt
  }
  function hasThreat(loc) {
    let threat = others.filter(b => b[0] == loc[0] && b[1] == loc[1] && b[2] >= me.coins)
    return (threat.length > 0)
  }
  function inArena(loc) {  // probably unnecessary for this bot
    return loc[0] >= 0 && loc[1] >= 0 && loc[0] < me.arenaLength && loc[1] < me.arenaLength
  }
  function sortedCoins() {
    coinsWithValues = coin.map((coords, i) => coords.concat((i == 0) ? 5 : 2))
    coinsWithValues.sort((a, b) => distanceCompare(a, b, a[2], b[2]))
    return coinsWithValues.map(c => c.slice(0, 2))
  }

  let eatables = others.filter(b => b[2] < me.coins && b[2] > 0)
  let targets
  if (eatables.length > 0) {
    targets = eatables.sort(distanceCompare)
  }
  else {
    targets = sortedCoins()
  }

  let done, newLoc, dir
  while (!done && targets.length > 0) {
    t = targets.shift()
    if ((xdist(t) <= ydist(t) || ydist(t) == 0) && xdist(t) != 0) {
      let xmove = Math.sign(t[0] - me.locationX)
      dir = xmove < 0 ? 'west' : 'east'
      newLoc = [me.locationX + xmove, me.locationY]
      if (!hasThreat(newLoc) && inArena(newLoc))
        done = 1
    }

    if (!done) {
      let ymove = Math.sign(t[1] - me.locationY)
      dir = ['north', 'none', 'south'][ymove + 1]
      newLoc = [me.locationX, me.locationY + ymove]
      if (!hasThreat(newLoc) && inArena(newLoc))
        done = 1
    }
  }

  if (!done)
    dir = 'none'

  return dir
}

Essayez-le en ligne!

(Merci à @ OMᗺ pour avoir signalé un bogue dans le code d'origine sur lequel il était basé.)

Essaie de grandir en "mangeant" des robots avec moins de pièces que lui-même. Si ce n'est pas possible (aucun tel bot n'existe), alors cherche la pièce la plus proche.

Cette version comporte de petites modifications pour (a) donner une préférence plus grande aux pièces d'or qu'aux pièces d'argent - avec le risque de rechercher une pièce d'or plus éloignée pouvant coûter la vie du bot ou conduire à la poursuite de celui du fou (b) sauter des bots avec 0 pièces - pas besoin de perdre du temps à courir après celles-ci.