Uwaga: ankieta dla ulubionych społeczności zostanie wkrótce opublikowana

W tym KoTH celem jest bycie ostatnim żyjącym botem. Monety będą umieszczane w losowych obszarach, a twój bot musi najpierw zdobyć monety. Jeśli bot trafi na innego bota, wygrywa bot z większą ilością monet, a drugi umiera. Więcej szczegółów poniżej.

Rodzaje monet

Będą 2 rodzaje monet: złote i srebrne. Złoto dodaje 5 siły do ​​siły bota, a srebro dodaje 2. Po zebraniu monety kolejna moneta jest umieszczana w innym miejscu na planszy. W danym momencie na arenie jest jedna złota moneta i cztery srebrne monety.

Zderzenia botów

W przypadku dwóch botów próbujących zająć to samo miejsce, ten z większą liczbą monet pozostanie, a ten z mniejszą liczbą ... nie. Zwycięski bot zyska 85% monet przeciwnika (zaokrąglone w górę). Jeśli są związane, oboje giną. Jeśli trzy lub więcej osób spróbuje zająć to samo miejsce, najpotężniejszy wygrywa i otrzymuje 85% wszystkich monet innego bota. W przypadku, gdy najpotężniejszym botem jest remis, wszystkie boty giną, próbując wejść w przestrzeń.

Arena

Długość boku areny jest obliczana za pomocą 4 + botCount. Podczas umieszczania botów na początku gry wybiera się losowe miejsca. System zapewnia, że ​​żadne boty nie wystartują w tym samym miejscu lub obok siebie. Monety generują losowo, z wyłączeniem kwadratu 3 na 3 wyśrodkowanego na każdym bocie. Jeśli bot zostanie znaleziony poza areną, natychmiast umiera. Arena zaczyna się od (0,0) lub na północny zachód, w lewym górnym rogu, a lokalizacja bota jest zawsze liczbą całkowitą.

Twój bot

Twój bot powinien być funkcją w dowolnym języku obiektowym, który ma tablice, liczby całkowite, łańcuchy i funkcje. Pamiętaj, że wszystkie zgłoszenia zostaną przekonwertowane na Javascript, aby uprościć sprawę. Aby przechowywać informacje między ruchami, użyj botNotes.storeData(key, value)i botNotes.getData(key, value). Nie możesz przechowywać ani uzyskiwać dostępu do danych w jakikolwiek inny sposób niż ten, który jest zapewniany przez parametry i botNotes. Należy utworzyć funkcję, kiedy nazywa, zwraca łańcuch north, east, south, west, lub none. Będą 3 argumenty dla funkcji:

• Obiekt z czterech liczb całkowitych ( locationX, locationY, coins, arenaLength), aktualna lokalizacja, swoje monety, a długość rzędu

• Wielowymiarowa tablica ze współrzędnymi X i Y innych botów i ich liczbą monet, np.[[0,5,4],[4,7,1],[7,4,12]]

• Tablica z wymienionymi lokalizacjami monet (złoto jest zawsze pierwsze)

To wyzwanie króla wzgórza, zabronione Standardowe Luki . Twoja funkcja będzie uruchamiana kilka tysięcy razy, za każdym razem dozwolony jeden „ruch”. Pamiętaj, że jeśli gra przekroczy 20 000 ruchów , wygrywa bot z największą liczbą monet. Zostanie to zrobione 8000 razy, aby usunąć losowość.

Pokój czatu: https://chat.stackexchange.com/rooms/81347/gold-collectors-koth

Nagrody:

Pierwsze miejsce: 100-punktowa nagroda
Społeczność Ulubiona: 15-punktowa zaakceptowana odpowiedź

Zwycięzcy:

Pierwsze miejsce: TBTPTGCBCBA
Drugie miejsce: Big King Little Hill
Trzecie miejsce: Potencjalnie zwycięski
Czwarte miejsce: Uprzejmy, niedowidzący pijany bot
Piąte miejsce: Moneta bezpieczeństwa

BaitBot - JavaScript Node.JS

Po co męczyć się i gonić, skoro nigdy nie można złapać? Zamiast tego BaitBot znajduje najbliższą monetę i czeka, aż słabszy bot również do niej podejdzie. Gdy oba są obok siebie, baitBot wybiera monetę, zakładając, że zrobi to również słabszy bot. Jeśli baitBot czeka i zbliża się silniejszy bot, po prostu chwyta monetę i jeździ na desce. Spróbuj mnie!

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

}

Potencjalnie zwycięski | JavaScript

Preferowany kolor tego bota to #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];
}

(Przepraszamy za niedbałe formatowanie, wcięcie 4 spacji dla tej witryny nie pasuje do mojego zwyczaju używania tabulatorów).

Szorstkie wyjaśnienie

Niniejszym rezygnuję z próby aktualizacji wyjaśnienia formuł. Współczynniki ciągle się zmieniają i trudno jest aktualizować wyjaśnienie. Wyjaśnię więc ogólną zasadę.

Każda moneta i każdy bot generuje pole siłowe z pewnym potencjałem. Po prostu dodam potencjały ze wszystkiego razem, a następnie bot idzie tam, gdzie potencjał jest najniższy. (Oczywiście ten pomysł został skradziony z fizyki.)

Używam dwóch rodzajów potencjałów. Pierwszy to pseudo-grawitacyjny (działający w dowolnym zakresie), z Kjest „siła” w tej dziedzinie, a wraz z tym wybór znaku, potencjał jest atrakcyjny. Rtutaj (i wszędzie indziej) jest odległością w taksówki metryczny,r = | x₁ - x₂ | + | y₁ - y₂ | .

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

Używam k = 40 dla złotych monet i k = 10 dla srebrnych monet. n to liczba botów, które są bliżej konkretnej monety niż my. W przeciwnym razie absolutnie ignorujemy pozostałe boty (jeśli przeszkadzamy silniejszemu botowi, uciekamy, ale to wszystko). Cenię złote monety za więcej, niż są warte, bo inaczej boty, które idą przede wszystkim po złoto cały czas mnie biją.

Drugi potencjał jest wykładniczo niszczący (który skutecznie działa tylko na bardzo małe odległości). Jest to generowane przez inne, głównie silniejsze boty.

Dają one pole o Siła ta jest nadmiernie silna w zakresie 0-1, ale rozpada się prawie na nic przy większych odległościach. (Odległość + 1 oznacza zmniejszenie siły o 1/20.)

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

Na ogół nie atakujemy innych botów celowo (oczywiście jeśli staną nam na drodze i nadepniemy na nie, to ich wina), ale istnieje taka możliwość. Jeśli zostaną spełnione trudne warunki, możemy przejść do trybu polowania , koncentrując się na jednym bocie. Aby przejść do trybu polowania:

1. Musimy mieć co najmniej 25 monet. (Najpierw musimy zdobyć monety.)
2. Muszą mieć co najwyżej (nasze monety - 5) monet i co najmniej 10 monet. (Nie chcemy polować na kogoś, kto złapie jedną monetę i nagle stanie się potężniejszy, i nie chcemy też ścigać botów o zerowej monecie).
3. Musimy pozostawać w tyle za obecnie wiodącym botem o co najmniej 1/10 jego monet. (Musisz mieć szczęście, aby coś upolować, więc nie trzeba rozdawać dobrej pozycji tylko za próbę szczęścia.)
4. Nie wolno nam odnawiać polowania (patrz poniżej).

Jeśli wszystkie te warunki zostaną spełnione, tryb polowania zostanie aktywowany. Przez następne 10 rund upolowany bot emituje tylko potencjalne Po upływie tych 10 rund wchodzimy w czas odnowienia polowania, podczas którego nie możemy ponownie wejść w tryb polowania. (To ma nas powstrzymać od niekończącego się i bezowocnego ścigania jednego bota, podczas gdy inne szczęśliwie chwytają monety.) Czas odnowienia polowania wynosi 20 rund, gdy mamy 25 monet, i wzrasta o 20 monet za każde podwojenie tego. (Innymi słowy, czas odnowienia to

$$U = -150 e^{-r}.$$ 20(1 + log2(c / 25)).) (Używamy tego, ponieważ w końcowej fazie gry wszystkie boty, na które można polować, najprawdopodobniej są martwe, a więc każde polowanie będzie najprawdopodobniej daremne. Z tego powodu chcemy ograniczyć zmarnowany czas. Ale czasami szczęście jest spóźnione jedzenie w grze może zmienić wszystko, więc zachowujemy taką możliwość).

Na koniec cała arena jest umieszczona w nieskończonej potencjalnej studni, co zapobiega ucieczce bota.

Algorytm uczenia się pierwszej generacji | JavaScript (Node.js)

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

Wypróbuj online!

Czy widziałeś kiedyś te algorytmy uczenia się gry? Często poruszają się prawie losowo w pierwszych kilku pokoleniach ...

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

Wypróbuj online!

Big King Little Hill podejmuje decyzje w oparciu o „strefy kontroli”. Będzie ścigał tylko monety znajdujące się w strefie kontroli, co oznacza, że ​​może dotrzeć do monety, zanim jakikolwiek inny bot będzie mógł. Gdy w strefie kontroli nie ma monet, porusza się, aby zmaksymalizować wielkość strefy kontroli. Big King Little Hill oblicza strefę kontroli każdego z 5 możliwych ruchów i preferuje ruchy, które maksymalizują rozmiar jej strefy kontroli. W ten sposób Big King Little Hill ostatecznie osiąga lokalne maksimum kontroli (małe wzgórze) i czeka na wygenerowanie monety w swojej strefie. Dodatkowo, Big King Little Hill odrzuca każdy ruch, który może doprowadzić do jego śmierci, chyba że nie ma alternatywy.

Big King Little Hill jest pesymistą (woli termin realista), ponieważ nie zawraca sobie głowy żadną monetą, której zdobycie nie jest pewne. Jest także pacyfistą, ponieważ w żadnym sensie nie ściga słabszych botów (choć może natknąć się na jednego, jeśli przeszkadza). Wreszcie, Big King Little Hill jest tchórzem, który nie zagrozi własnemu życiu za jakąkolwiek nagrodę, chyba że absolutnie musi.

Moneta bezpieczeństwa | 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";}
  }
}

Ten bot zmierza prosto w stronę ważonej monety (wartość / odległość), której nie może umrzeć, osiągając jednocześnie lub po innym bocie. Jeśli nie ma ważnej monety z tą właściwością , siedzi ona tam, gdzie jest bot, porusza się teraz w losowo bezpiecznym kierunku (bezpieczeństwo oznacza, że ​​jeśli bot ruszy w jego kierunku, bezpieczna moneta nie może się zderzyć. Pozwala to botowi zamienić się miejscami z innym botem, jeśli bezpośrednio obok niego), ważony w kierunku środka areny.

Bot, który gra ostrożnie, ale może być agresywny | JavaScript

Preferowany kolor: #F24100

Uwaga: Chociaż ten bot zajął 1. miejsce, wynika to z połączenia z „Feudal Noble” na końcu i zjedzenia go, by zdobyć więcej monet. W przeciwnym razie ten bot byłby trzeci. Jeśli interesują Cię boty, które są silniejsze indywidualnie, sprawdź Potencjalnie Zwycięską i Little 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;
}

Ten bot (znany również jako „TBTPTGCBCBA”) próbuje podjąć najlepszą możliwą decyzję, generując wynik dla każdego możliwego ruchu i wybiera ruch z wyższym wynikiem dla każdej tury.

System punktacji zawiera wiele szczegółów, które ewoluują od początku wyzwania. Można je ogólnie opisać w następujący sposób:

• Im bliżej monety są możliwe ruchy, tym więcej punktów uzyska ruch. Jeśli na monecie nie ma innych możliwych uczestników, wynik jest jeszcze wyższy. Jeśli moneta ma innych możliwych uczestników, wynik jest niższy.
• Jeśli inny bot jest blisko możliwego ruchu i ma mniej monet, w zależności od fazy gry, może to oznaczać więcej punktów za ten ruch. Dlatego przypadkiem „TBTPTGCBCBA” zjada kilka innych botów w każdej grze.
• Jeśli inny bot jest bliski możliwemu ruchowi z równą lub większą liczbą punktów, ruch ten otrzymuje wystarczającą liczbę punktów ujemnych, aby uniknąć śmierci. Oczywiście mogą zdarzyć się przypadki, że wszystkie możliwe ruchy są złe i nie da się uniknąć śmierci, ale jest to bardzo rzadkie.
• Istnieje mechanizm śledzenia liczby botów na środku planszy przez ostatnie 20 tur. Jeśli średnia jest wystarczająco niska, wszystkie ruchy w kierunku monet pośrodku uzyskują wyższy wynik, a jeśli średnia jest wysoka, wówczas wszystkie ruchy w kierunku monet pośrodku otrzymują niższy wynik. Mechanizm ten pozwala uniknąć konfliktów z „Feudal Noble”. Ponieważ „Feudal Noble” jest zawsze w środku (chyba, że ​​jest ścigany), średnia liczba botów w środku rośnie, a „TBTPTGCBCBA” rozumie, jak unikać środka, jeśli jest lepsza opcja poza obszarem środkowym. Jeśli „Feudal Noble” umrze, średnia spada, a „TBTPTGCBCBA” rozumie, że może użyć środka.
• Istnieją pewne czynniki, które dynamicznie zmieniają się w zależności od fazy gry (wykryte na podstawie liczby żywych botów), czynniki te wpływają na punktację w każdym z powyższych przedmiotów.
• Ten bot ma specjalną zdolność. Z czasem męczy go samolubstwo „szlachcica feudalnego” i ucisk chłopów. W odpowiednim momencie dojdzie do zakończenia nieprzyjemnego systemu feudalizmu. Udana próba nie tylko pomaga biednym chłopom, ale także zapewnia wyższą szansę na wygraną dzięki monetom pobranym z „Feudal Noble”.

The AntiCapitalist | JavaScript

Nie ma motywacji, by szukać monet, ale stara się postawić dokładnie między dwoma najbogatszymi botami z taką samą ilością pieniędzy, w nadziei, że polują na niego i ostatecznie go złapią w tym samym czasie, zabierając ze sobą dwóch kapitalistów, gdy umrze. . Nie opiera się aktywnie zdobywaniu monet, więc może stać się bardziej soczystym celem.

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

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

W Potencjalnie Zwycięskim mamy dwa pola: dolne i dolne. Natura nie jest jednak taka skomplikowana. Czas zjednoczyć te dwa pola, aby stworzyć Teorię Wielkiej Unifikacji .

Po pierwsze musimy ustalić, jaki jest potencjał tego pola. Zakładając, że nasz własny bot nie wpływa w żaden sposób na pole, możemy to napisać jako:

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

Względną właściwość obiektu oblicza się w następujący sposób:

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

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

_{Nazwijmy to korekcję częścią Zmodyfikowanej Dynamiki Betańskiej (MOBD) .}

Możemy również znaleźć energię kinetyczną jako:

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

Możemy teraz obliczyć akcję:

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

I tak Lagrangian naszego bota w dziedzinie monet-botów to:

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

Teraz musimy rozwiązać równania Eulera-Lagrange'a:

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

i:

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

Więc:

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

I również:

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

Teraz nie musimy iść dalej: po prostu patrzymy na kierunek ogólnego przyspieszenia:

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

I tak po prostu zjednoczyliśmy monety i boty. Gdzie jest moja Nagroda Nobla?

Złotowłosa, 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
}

Wypróbuj online!

Po prostu blokuje się na miejscu złotej monety i podchodzi do niej za każdym razem. (Dzięki botowi „B33-L1N3” @ Mayube dla oryginalnego kodu, którego używał, choć prawie nic z niego nie zostało.)

Algorytm uczenia się trzeciej generacji | 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)];
}

Wypróbuj online!

Po kilku pokoleniach uczenia ten bot nauczył się, że opuszczenie areny jest złe

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

Wypróbuj online!

Ustawia linię dla najbliższej monety

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

Ten słyszał, że skraj areny to niebezpieczne miejsce. Nie znając strachu, niestrudzenie krąży po planszy zgodnie z ruchem wskazówek zegara, zaledwie kilka centymetrów od pewnej śmierci, która czeka za granicą, mając nadzieję, że żaden inny bot nie odważy się zbliżyć tak blisko krawędzi.

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
}

Wypróbuj online!

Ostatni na dzień bot oparty na katamari, tym razem z odrobiną pamięci. Dzięki @BetaDecay za sugestię nazwy - zdecydowanie bardziej zabawna nazwa niż moja simplePredictorKatamari.

Próbuje dowiedzieć się, w jaki sposób boty się poruszyły w ostatniej turze, i na tej podstawie przewiduje, gdzie będą próbować się poruszać pod koniec tej tury (zakładając, że nadal będą się poruszać w tym samym kierunku).

(Podziękowania dla @ fəˈnɛtɪk, za zauważenie, że wywoływałem niewłaściwą nazwę funkcji w botNotes, oraz @ @ᗺᗺ za zauważenie błędu w kodzie podstawowym.)

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

Wszystkie monety (w tym te przechowywane przez inne boty) emitują odpychającą siłę w kierunku Protonbota. W oparciu o tę siłę, zwiększa prędkość i odbija się od ścian (odwraca się natychmiast po uderzeniu w granicę). Jeśli trafi obok bota lub monety, którą może zużyć, Silna siła nuklearna przejmuje kontrolę i porusza się, aby go pochłonąć, zrzucając przy tym całą prędkość.

Nie tak ślepo JavaScript (Node.js)

Ważna uwaga: to podejście nie jest całkowicie moje i na które odpowiedziano w podobnym pytaniu . Głosuj również na tę odpowiedź.

Czy słyszałeś kiedyś o algorytmie A * znajdowania ścieżki? oto jest. Tworzy najlepszą ścieżkę od jednego punktu do mniej wartościowej monety (ponieważ wszyscy wybierają najcenniejsze, nikt nie wybiera mniej) i stara się nie kolidować z żadnym innym użytkownikiem.

Oczekuje następujących parametrów:

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

---

Może robię taki, który poluje na inne boty

---

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

Tchórz | 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)

Jeśli to możliwe, unikaj botów z większą ilością pieniędzy. W przeciwnym razie weź leżące wokół pieniądze.

Wild Goose Chase Bot, JavaScript

Bot, który jest naprawdę dobry w unikaniu innych botów, ale bardzo źle zdobywa monety.

---

Algorytm:

1. Jeśli nie ma sąsiadujących botów, nie zwracaj żadnych
2. Inaczej:
   1. Nie zwracaj żadnej z losową szansą 1/500 szansy (ma to na celu zapobieganie patom).
   2. Określ, do których pól można bezpiecznie się przenieść (tj. W arenie i nie jest zajęty przez innego bota)
   3. Zwróć jeden losowo

---

Kod:

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

Wypróbuj online!

Uwaga do programów Redwolf:

Ten bot może powodować bardzo długie rundy. Podjąłem pewne swobody, aby zapobiec patom, ale nie sprawdziłem, czy faktycznie są skuteczne. Jeśli ten bot stanie się problemem podczas testowania, możesz go zdyskwalifikować.

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
}

Wypróbuj online!

(Dzięki @ OMᗺ za wskazanie błędu w oryginalnym kodzie, na którym został oparty).

Stara się rosnąć poprzez „zjadanie” botów z mniejszą ilością monet niż ona sama. Jeśli nie jest to możliwe (nie ma takiego bota), to szuka najbliższej monety.

Ta wersja ma małe poprawki, aby (a) dać pierwszeństwo złotym monetom niż srebrnym - z ryzykiem, że poszukiwanie bardziej odległej złotej monety może skończyć się kosztem życia bota lub może prowadzić do pogoni za złotym głupcem (b) pominąć boty z 0 monet - nie musisz tracić czasu na pogoń za nimi.