Hinweis: Die Umfrage zum Community-Favoriten wird in Kürze veröffentlicht

In diesem KoTH ist es das Ziel, der letzte lebende Bot zu sein. Münzen werden in zufälligen Bereichen platziert, und Ihr Bot muss zuerst die Münzen erhalten. Wenn ein Bot auf einen anderen Bot trifft, gewinnt der Bot mit mehr Münzen und der andere Bot stirbt. Weitere Details unten.

Münztypen

Es wird 2 Arten von Münzen geben: Gold und Silber. Gold erhöht die Stärke des Bots um 5 Münzen und Silber um 2. Sobald eine Münze gesammelt wurde, wird eine weitere Münze an einer anderen Stelle auf dem Brett platziert. Zu jeder Zeit befinden sich eine Goldmünze und vier Silbermünzen in der Arena.

Bot-Kollisionen

Wenn zwei Bots versuchen, den gleichen Platz einzunehmen, bleibt der mit den mehr Münzen und der mit den weniger ... nicht. Der siegreiche Bot erhält 85% der Münzen des Gegners (aufgerundet). Wenn sie gebunden sind, sterben beide. Versuchen drei oder mehr, dasselbe Feld zu besetzen, gewinnt der Mächtigste und erhält 85% aller Münzen des anderen Bots. Für den Fall, dass der mächtigste Bot ein Unentschieden ist, sterben alle Bots, die versucht haben, das Feld zu betreten.

Arena

Die Seitenlänge der Arena wird mit berechnet 4 + botCount. Wenn Bots zu Beginn des Spiels platziert werden, werden zufällige Orte ausgewählt. Das System stellt sicher, dass keine Bots im selben Raum oder nebeneinander beginnen. Münzen werden zufällig generiert, mit Ausnahme eines 3 x 3-Quadrats, das auf jedem Bot zentriert ist. Wird ein Bot außerhalb der Arena gefunden, stirbt er sofort. Die Arena beginnt bei (0,0) oder Nordwesten in der oberen linken Ecke, und die Position eines Bots ist immer eine Ganzzahl.

Dein Bot

Ihr Bot sollte eine Funktion in jeder objektorientierten Sprache sein, die Arrays, Ganzzahlen, Zeichenfolgen und Funktionen enthält. Beachten Sie, dass alle Einsendungen in Javascript konvertiert werden, um die Sache zu vereinfachen. Verwenden Sie botNotes.storeData(key, value)und, um Informationen zwischen den Zügen zu speichern botNotes.getData(key, value). Sie dürfen auf keine andere Weise als die durch die Parameter und angegebenen Daten speichern oder darauf zugreifen botNotes. Sie sollten eine Funktion erstellen , die, wenn sie aufgerufen wird , eine Zeichenfolge zurückgibt north, east, south, west, oder none. Es gibt 3 Argumente für die Funktion:

• Ein Objekt mit vier ganzen Zahlen ( locationX, locationY, coins, arenaLength), momentaner Standort, Ihre Münzen, und die Länge der Arena

• Ein mehrdimensionales Array mit den X- und Y-Koordinaten anderer Bots und deren Münzzahl[[0,5,4],[4,7,1],[7,4,12]]

• Ein Array mit den aufgelisteten Münzpositionen (Gold steht immer an erster Stelle)

Dies ist ein König der Hügel Herausforderung, Standard-Schlupflöcher verboten. Ihre Funktion wird mehrere tausend Mal ausgeführt, wobei jedes Mal ein "Verschieben" zulässig ist. Beachten Sie, dass bei mehr als 20.000 Zügen der Bot mit den meisten Münzen gewinnt. Dies wird 8000-mal durchgeführt, um die Zufälligkeit zu beseitigen.

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

Preise:

Erster Platz: 100-Punkte-Kopfgeld
Community Favorit: 15-Punkte-akzeptierte Antwort

Gewinner:

Erster Platz: TBTPTGCBCBA
Zweiter Platz: Big King Little Hill
Dritter Platz: Potenziell siegreich
Vierter Platz: Höflicher, kurzsichtiger, betrunkener Bot
Fünfter Platz: Sicherheitsmünze

BaitBot - JavaScript Node.JS

Warum jagen oder rennen, wenn man nie fangen kann? Stattdessen findet BaitBot die nächste Münze und wartet darauf, dass sich auch ein schwächerer Bot nähert. Wenn beide benachbart sind, geht baitBot für die Münze, vorausgesetzt, der schwächere Bot wird es auch. Wenn baitBot wartet und sich ein stärkerer Bot nähert, schnappt er sich einfach die Münze und die Skedaddles. Probier mich aus!

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)]

}

Potenziell siegreich JavaScript

Bevorzugte Farbe für diesen Bot ist #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];
}

(Entschuldigung für die schlampige Formatierung, der 4-stellige Einzug für diese Site passt nicht zu meiner Gewohnheit, Tabulatoren zu verwenden.)

Grobe Erklärung

Ich verzichte hiermit auf den Versuch, die Erklärung der Formeln zu aktualisieren. Die Koeffizienten ändern sich ständig und es ist schwierig, die Erklärung auf dem neuesten Stand zu halten. Also werde ich nur das allgemeine Prinzip erklären.

Jede Münze und jeder Bot erzeugt ein Kraftfeld mit einem gewissen Potenzial. Ich addiere einfach die Potenziale von allem zusammen und der Bot geht dann dorthin, wo das Potenzial am niedrigsten ist. (Offensichtlich ist diese Idee aus der Physik gestohlen.)

Ich benutze zwei Arten von Potentialen. Das erste ist ein Pseudogravitationssystem (das in einem beliebigen Bereich wirkt) mit Das k ist eine "Stärke" des Feldes, und bei dieser Wahl des Zeichens ist das Potential attraktiv. Das r hier (und überall sonst) ist der Abstand in der Taximetrik, r = | x₁ - x₂ | + | y₁ - y₂ | .

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

Ich benutze k = 40 für Goldmünzen und k = 10 für Silbermünzen. n ist die Anzahl der Bots, die näher an der jeweiligen Münze sind als wir. Ansonsten ignorieren wir die anderen Bots absolut (wenn wir einem stärkeren Bot im Weg stehen, rennen wir weg, aber das war's). Ich schätze Goldmünzen für mehr als sie wert sind, weil mich sonst die Bots schlagen, die hauptsächlich nach dem Gold streben.

Das zweite Potential ist ein exponentiell abfallendes Potential (das effektiv nur in sehr kleinen Abständen wirkt). Dies wird von den anderen, hauptsächlich mächtigeren Bots erzeugt.

Diese erzeugen ein Feld mit Diese Kraft ist im Bereich 0-1 unerschwinglich stark, nimmt aber in größeren Entfernungen fast nichts an. (Abstand + 1 bedeutet, dass die Kraft um 1/20 verringert wird.)

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

Wir greifen die anderen Bots im Allgemeinen nicht absichtlich an (natürlich ist es ihre Schuld, wenn sie uns in die Quere kommen und wir darauf treten), aber es besteht die Möglichkeit, dies zu tun. Wenn einige raue Bedingungen erfüllt sind, können wir in den Jagdmodus wechseln und uns auf einen einzelnen Bot konzentrieren. So rufen Sie den Jagdmodus auf:

1. Wir müssen mindestens 25 Münzen haben. (Wir müssen zuerst einige Münzen bekommen.)
2. Sie müssen höchstens (unsere Münzen - 5) Münzen und mindestens 10 Münzen haben. (Wir wollen nicht jemanden jagen, der eine Münze schnappt und plötzlich mächtiger ist, und wir wollen auch keine Null-Münzen-Bots verfolgen.)
3. Wir müssen um mindestens 1/10 seiner Münzen hinter dem derzeit führenden Bot zurückbleiben. (Sie müssen das Glück haben, etwas zu jagen. Es ist also nicht nötig, eine gute Position zu verraten, nur um unser Glück zu versuchen.)
4. Wir dürfen keine Jagd-Abklingzeit haben (siehe unten).

Wenn all dies erfüllt ist, wird der Jagdmodus aktiviert. In den nächsten 10 Runden gibt der gejagte Bot nur das Potential Nach Ablauf dieser 10 Runden betreten wir die Jagd-Abklingzeit, in der wir möglicherweise nicht mehr in den Jagdmodus wechseln. (Das soll verhindern, dass wir einen Bot endlos und erfolglos verfolgen, während alle anderen glücklich nach Münzen greifen.) Die Jagdabklingzeit beträgt 20 Runden, wenn wir 25 Münzen haben, und erhöht sich um 20 Münzen pro Verdoppelung. (Mit anderen Worten, die Abklingzeit ist .) (Wir verwenden das, weil im Endspiel alle jagbaren Bots höchstwahrscheinlich tot sind und daher jede Jagd höchstwahrscheinlich vergeblich sein wird. Aus diesem Grund möchten wir die verschwendete Zeit begrenzen Aber manchmal kann ein glückliches spätes Spielessen alles ändern, also behalten wir die Möglichkeit.)

$$U = -150 e^{-r}.$$ 20(1 + log2(c / 25))

Schließlich wird die gesamte Arena in eine unendliche Potentialquelle gebracht, die das Entkommen des Bots verhindert.

Lernalgorithmus der ersten Generation | JavaScript (Node.js)

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

Probieren Sie es online!

Haben Sie jemals die Zeitraffer von Lernalgorithmen gesehen, die das Spielen lernen? Sie bewegen sich in den ersten Generationen oft fast zufällig ...

Big King Little Hill | 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])
}

Probieren Sie es online!

Big King Little Hill trifft Entscheidungen auf der Grundlage von „Kontrollzonen“. Es werden nur Münzen verfolgt, die sich in seiner Kontrollzone befinden, was bedeutet, dass es die Münze erreichen kann, bevor es ein anderer Bot kann. Befinden sich keine Münzen in der Kontrollzone, wird stattdessen die Größe der Kontrollzone maximiert. Big King Little Hill berechnet die Kontrollzone für jede seiner 5 möglichen Bewegungen und bevorzugt die Bewegungen, die die Größe seiner Kontrollzone maximieren. Auf diese Weise erreicht Big King Little Hill schließlich ein lokales Kontrollmaximum (Little Hill) und wartet darauf, dass in seiner Zone eine Münze generiert wird. Außerdem lehnt Big King Little Hill jede Aktion ab, die zum Tod führen könnte, sofern es keine Alternativen gibt.

Big King Little Hill ist ein Pessimist (er bevorzugt den Begriff Realist), weil er sich nicht die Mühe macht, eine Münze anzufechten, deren Erhalt nicht garantiert ist. Es ist auch ein Pazifist, da es in keiner Weise schwächere Bots verfolgt (obwohl es auf einen treten könnte, wenn sie in die Quere kommen). Schließlich ist Big King Little Hill ein Feigling, der sein eigenes Leben nicht für Belohnungen aufs Spiel setzt, es sei denn, er muss es unbedingt.

Sicherheitsmünze | 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";}
  }
}

Dieser Bot geht direkt auf eine gewichtete Wertmünze (Wert / Entfernung) zu, an deren Erreichen er nicht gleichzeitig oder nach einem anderen Bot sterben kann. Wenn es keine gültige Münze mit dieser Eigenschaft gibt, befindet sie sich dort, wo sich der Bot jetzt in eine zufällige sichere Richtung bewegt (Sicherheit bedeutet, dass eine Sicherheitsmünze nicht kollidieren kann, wenn sich ein Bot darauf zubewegt. Auf diese Weise kann der Bot die Plätze mit einem anderen Bot tauschen, wenn direkt daneben), gewichtet zur Arena-Mitte.

Der Bot, der das Spiel vorsichtig spielt, aber aggressiv sein kann | JavaScript

Bevorzugte Farbe: #F24100

Hinweis: Obwohl dieser Bot den 1. Platz belegt hat, hat er sich am Ende mit "Feudal Noble" zusammengetan und frisst ihn nach mehr Münzen. Andernfalls wäre dieser Bot Dritter geworden. Wenn Sie an individuell leistungsstärkeren Bots interessiert sind, schauen Sie sich Potenziell siegreich und Big King Little Hill an .

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

Dieser Bot (auch "TBTPTGCBCBA" genannt) versucht die bestmögliche Entscheidung zu treffen, indem er für jeden möglichen Zug eine Punktzahl generiert und den Zug mit der höheren Punktzahl für jeden Zug auswählt.

Das Punktesystem enthält viele Details, die seit Beginn der Herausforderung entwickelt wurden. Sie können allgemein so beschrieben werden:

• Je näher die Münzen an einem möglichen Zug sind, desto mehr Punkte erhält dieser Zug. Wenn eine Münze keine anderen möglichen Teilnehmer hat, ist die Punktzahl noch höher. Wenn eine Münze andere mögliche Teilnehmer hat, sinkt die Punktzahl.
• Befindet sich ein anderer Bot in der Nähe eines möglichen Zuges und hat er je nach Spielphase weniger Münzen, könnte dies bedeuten, dass dieser Zug mehr Punkte bringt. Daher ist es für "TBTPTGCBCBA" eine Gelegenheit, in jedem Spiel ein paar andere Bots zu essen.
• Befindet sich ein anderer Bot in der Nähe eines möglichen Zuges mit gleichen oder mehr Punkten, erhält dieser Zug genügend negative Punkte, um sicherzustellen, dass der Tod vermieden wird. Natürlich kann es vorkommen, dass alle möglichen Züge schlecht sind und der Tod nicht vermieden werden kann, aber das ist sehr selten.
• Es gibt einen Mechanismus, mit dem die Anzahl der Bots in den letzten 20 Runden in der Mitte des Bretts verfolgt werden kann. Wenn der Durchschnitt niedrig genug ist, erhalten alle Bewegungen zu Münzen in der Mitte mehr Punkte, und wenn der Durchschnitt hoch ist, erhalten alle Bewegungen zu Münzen in der Mitte weniger Punkte. Dieser Mechanismus ermöglicht es, Konflikte mit "Feudal Noble" zu vermeiden. Da sich "Feudal Noble" immer in der Mitte befindet (es sei denn, es wird gejagt), steigt die durchschnittliche Anzahl der Bots in der Mitte und "TBTPTGCBCBA" vermeidet die mittlere, wenn es eine bessere Option außerhalb des mittleren Bereichs gibt. Wenn "Feudal Noble" stirbt, sinkt der Durchschnitt und "TBTPTGCBCBA" versteht, dass es die Mitte verwenden kann.
• Es gibt einige Faktoren, die sich je nach Spielphase dynamisch ändern (anhand der Anzahl der aktiven Bots). Diese Faktoren wirken sich auf die Wertung der oben genannten Punkte aus.
• Dieser Bot hat eine besondere Fähigkeit. Mit der Zeit wird es der Selbstsucht von "Feudal Noble" und der Unterdrückung der Bauern müde. Im richtigen Moment wird es dazu kommen, das unangenehme Feudalismus-System zu beenden. Ein erfolgreicher Versuch hilft nicht nur armen Bauern, sondern bietet auch eine höhere Gewinnchance durch die vom "Feudaladel" entnommenen Münzen.

Der Antikapitalist | Javascript

Hat keinen Anreiz, nach Münzen zu suchen, sondern versucht, sich genau zwischen die beiden reichsten Bots mit dem gleichen Geldbetrag zu setzen, in der Hoffnung, dass sie ihn jagen und schließlich zur gleichen Zeit fangen und zwei Kapitalisten mitnehmen, wenn er stirbt . Widersetzt sich nicht aktiv dem Erhalten von Münzen, sodass er möglicherweise ein saftigeres Ziel wird.

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();
}

Die 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";
    }
}

Mit Potenziell siegreich haben wir zwei Felder: das Bot-Feld und das Münzfeld. Die Natur ist jedoch nicht so kompliziert. Es ist Zeit, die beiden Felder zu vereinen, um die Grand Unified Theory zu erstellen .

Zunächst müssen wir herausfinden, welches Potenzial das Gebiet hat. Vorausgesetzt, unser eigener Bot beeinflusst das Feld in keiner Weise, können wir dies wie folgt schreiben:

$$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)$

Die relative Eigenschaft des Objekts wird folgendermaßen berechnet:

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

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

_{Nennen wir diesen Korrekturteil einfach Modified Betanian Dynamics (MOBD) .}

Wir können die kinetische Energie auch finden als:

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

Wir können jetzt die Aktion berechnen:

$$\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}$$

Und so ist der Lagrange unseres Bots auf dem Gebiet der Münzbots:

$$\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)$$

Wir müssen nun die Euler-Lagrange-Gleichungen lösen:

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

und:

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

Damit:

$$\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}$$

Und auch:

$$\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}$$

Jetzt brauchen wir nicht weiter zu gehen: Wir schauen uns nur die Richtung der Gesamtbeschleunigung an:

$$\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}$$

Und einfach so haben wir die Münzen und die Bots vereinheitlicht. Wo ist mein Nobelpreis?

Goldlöckchen, 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
}

Probieren Sie es online!

Lässt sich einfach auf die Position der Goldmünze fixieren und bewegt sich jedes Mal darauf zu. (Dank @ Mayubes 'B33-L1N3'-Bot für den verwendeten Originalcode, von dem jedoch kaum noch etwas übrig ist.)

Lernalgorithmus der dritten Generation | 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)];
}

Probieren Sie es online!

Nach ein paar Generationen des Lernens hat dieser Bot gelernt, dass das Verlassen der Arena = schlecht ist

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

Probieren Sie es online!

Stellt eine Linie für die nächste Münze her

Leben am Rande, 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';
  }
}

Dieser hörte, der Rand der Arena sei ein gefährlicher Ort. Da er keine Angst kennt, kreist er unermüdlich im Uhrzeigersinn, nur wenige Zentimeter von dem sicheren Tod entfernt, der hinter der Grenze auf ihn wartet, und hofft, dass kein anderer Bot es wagt, sich so nah an die Kante zu bewegen.

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
}

Probieren Sie es online!

Ein letzter Katamari-basierter Bot für heute, diesmal mit ein bisschen Gedächtnis. Danke an @BetaDecay für den Namensvorschlag - definitiv ein lustigerer Name als mein simplePredictorKatamari.

Versucht herauszufinden, wie sich Bots in der letzten Runde bewegt haben, und prognostiziert basierend darauf, wo sie am Ende dieser Runde versuchen werden, sich zu bewegen (vorausgesetzt, sie bewegen sich weiterhin in dieselbe Richtung).

(Vielen Dank an @ fəˈnəˈtɛk, dass ich in botNotes den falschen Funktionsnamen aufgerufen habe, und an @ OMᗺ, dass ich einen Fehler im Basiscode bemerkt habe.)

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

Alle Münzen (einschließlich der von anderen Bots gehaltenen) stoßen Protonbot ab. Basierend auf dieser Kraft baut es Geschwindigkeit auf und prallt von Wänden ab (dreht sich sofort um, wenn es auf eine Grenze trifft). Wenn es neben einem Bot oder einer Münze landet, die es konsumieren kann, übernimmt die starke Kernkraft und es bewegt sich, um sie zu konsumieren, wobei es die gesamte Geschwindigkeit verliert, wenn es dies tut.

Nicht so blind JavaScript (Node.js)

Wichtiger Hinweis: Dieser Ansatz gehört nicht ganz mir und wurde in einer ähnlichen Frage beantwortet . Stellen Sie sicher, dass Sie auch für diese Antwort stimmen.

Haben Sie jemals von einem A * -Pfadfindungsalgorithmus gehört? hier ist es. Es schafft den besten Weg von einem Punkt zur weniger wertvollen Münze (da jeder den höchsten Wert anstrebt, niemand den niedrigsten) und versucht, nicht mit einem anderen Benutzer zusammenzustoßen.

Erwartet folgende Parameter:

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

---

Vielleicht mache ich einen, der andere Bots jagt

---

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";
    }
}

Feigling | 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)

Vermeiden Sie Bots mit mehr Geld, wenn dies möglich ist. Ansonsten schnapp dir Geld, das herumliegt.

Wild Goose Chase Bot, Javascript

Ein Bot, der wirklich gut darin ist, anderen Bots auszuweichen, aber sehr schlecht darin, Münzen zu bekommen.

---

Algorithmus:

1. Wenn keine benachbarten Bots vorhanden sind, geben Sie keine zurück
2. Andernfalls:
   1. Gib keine mit einer zufälligen Chance von 1/500 zurück (dies soll Patt verhindern).
   2. Bestimmen Sie, zu welchen Feldern Sie sich sicher bewegen können (dh innerhalb der Arena und nicht von einem anderen Bot besetzt)
   3. Gib eine nach dem Zufallsprinzip zurück

---

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)];
}

Probieren Sie es online!

Hinweis für Redwolf-Programme:

Dieser Bot kann sehr lange Runden verursachen. Ich habe mir einige Freiheiten genommen, um Pattsituationen vorzubeugen, aber nicht getestet, ob sie tatsächlich wirksam sind. Wenn dieser Bot während des Testens zu einem Problem wird, können Sie ihn jederzeit disqualifizieren.