Nota: il sondaggio per i preferiti della community verrà rilasciato presto

In questo KoTH, l'obiettivo è quello di essere l'ultimo bot in vita. Le monete verranno posizionate in aree casuali e il tuo bot dovrà prima ottenere le monete. Se un bot si imbatte in un altro bot, il bot con più monete vince e l'altro bot muore. Maggiori dettagli di seguito.

Tipi di monete

Ci saranno 2 tipi di monete: oro e argento. L'oro aggiunge 5 monete alla forza del robot e l'argento aggiunge 2. Una volta che una moneta viene raccolta, un'altra moneta viene posizionata in un altro punto del tabellone. In qualsiasi momento, ci sono una moneta d'oro e quattro monete d'argento nell'arena.

Collisioni bot

Nel caso in cui due robot tentassero di occupare lo stesso spazio, quello con più monete rimarrà e quello con meno ... no. Il bot vincente otterrà l' 85% delle monete degli avversari (arrotondato per eccesso). Se sono legati, entrambi muoiono. Se tre o più tentano di occupare lo stesso spazio, il più potente vince e ottiene l'85% di tutte le monete dell'altro robot. Nel caso in cui il bot più potente sia un pareggio, muoiono tutti i robot che hanno cercato di entrare nello spazio.

Arena

La lunghezza laterale dell'arena viene calcolata con 4 + botCount. Quando si posizionano i robot all'inizio del gioco, vengono scelti posti casuali. Il sistema garantisce che nessun robot si avvii nello stesso spazio o uno accanto all'altro. Le monete si generano casualmente, escludendo un quadrato di 3 per 3 centrato su ciascun bot. Se un bot viene trovato fuori dall'arena, muore all'istante. L'arena inizia da (0,0), o nord-ovest, nell'angolo in alto a sinistra e la posizione di un bot è sempre un numero intero.

Il tuo bot

Il tuo bot dovrebbe essere una funzione, in qualsiasi linguaggio orientato agli oggetti che ha array, numeri interi, stringhe e funzioni. Nota che tutti gli invii verranno convertiti in Javascript, per semplificare le cose. Per memorizzare informazioni tra mosse, usare botNotes.storeData(key, value)e botNotes.getData(key, value). Non è possibile archiviare o accedere ai dati in alcun modo, diverso da quello fornito attraverso i parametri e botNotes. È necessario creare una funzione che, quando viene chiamato, restituisce una stringa north, east, south, west, o none. Ci saranno 3 argomenti per la funzione:

• Un oggetto con quattro numeri interi ( locationX, locationY, coins, arenaLength), la posizione corrente, le monete, e la lunghezza dell'arena

• Un array multidimensionale con le coordinate X e Y di altri robot e il loro conteggio delle monete, ex-[[0,5,4],[4,7,1],[7,4,12]]

• Un array con le posizioni delle monete elencate (l'oro è sempre il primo)

Questa è una sfida da re della collina, proibite le feritoie standard . La tua funzione verrà eseguita diverse migliaia di volte, ogni volta è consentito uno "Sposta". Nota che se il gioco supera le 20.000 mosse , vince il bot con il maggior numero di monete. Questo verrà fatto 8.000 volte, per rimuovere la casualità.

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

premi:

Primo posto:
Community Bounty da 100 punti Preferito: risposta accettata da 15 punti

Vincitori:

Primo posto: TBTPTGCBCBA
Secondo posto: Big King Little Hill
Terzo posto: Potenzialmente vittorioso
Quarto posto: Gentile avvistato ubriaco Bot
Quinto posto: Moneta di sicurezza

BaitBot - JavaScript Node.JS

Perché preoccuparsi di inseguire o correre se non riesci mai a catturare? Invece, BaitBot trova la moneta più vicina e aspetta che anche un bot più debole si avvicini. Quando sono entrambi adiacenti, baitBot va per la moneta ipotizzando che lo faccia anche il bot più debole. Se baitBot è in attesa e si avvicina un robot più forte, afferra semplicemente la moneta e salta. Prova mi!

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

}

Algoritmo di apprendimento di prima generazione | JavaScript (Node.js)

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

Provalo online!

Hai mai visto quei tempi degli algoritmi di apprendimento che imparano a giocare? Si muovono spesso in modo quasi casuale nelle prime generazioni ...

Potenzialmente vittorioso | JavaScript

Il colore preferito per questo bot è #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];
}

(Mi scuso per la formattazione sciatta, il rientro dei 4 spazi per questo sito non va bene con la mia abitudine di usare le schede.)

Spiegazione approssimativa

Con la presente, mi dimetto dal tentativo di aggiornare la spiegazione delle formule. I coefficienti cambiano costantemente ed è difficile mantenere aggiornata la spiegazione. Quindi spiegherò solo il principio generale.

Ogni moneta e ogni robot genera un campo di forza con un potenziale. Aggiungo semplicemente i potenziali di tutto e il bot va ovunque il potenziale sia il più basso. (Ovviamente questa idea è stata rubata dalla fisica.)

Uso due tipi di potenziali. Il primo è uno pseudo-gravitazionale (che agisce a qualsiasi distanza), con Lakè una "forza" del campo e, con questa scelta di segno, il potenziale è attraente. Larqui (e ovunque) è la distanza nella metrica del taxi,r = | x₁ - x₂ | + | y₁ - y₂ | .

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

Uso k = 40 per le monete d'oro e k = 10 per le monete d'argento. n è il numero di robot più vicini alla moneta particolare di noi. Altrimenti, ignoriamo assolutamente gli altri robot (se ostacoliamo un bot più forte, scappiamo, ma è tutto). Apprezzo le monete d'oro per più di quanto valgono perché altrimenti i bot che vanno principalmente dopo l'oro mi picchiano continuamente.

Il secondo potenziale è un decadimento esponenziale (che agisce efficacemente solo a distanze molto ridotte). Questo è generato dall'altro, principalmente dai robot più potenti.

Questi producono un campo con Questa forza è proibitivamente forte nell'intervallo 0-1, ma decade a quasi nulla alle distanze più grandi. (Distanza + 1 significa tagliare la forza in 1/20.)

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

Generalmente non attacciamo gli altri robot intenzionalmente (ovviamente se si intralciano e li calpestiamo, è colpa loro), ma c'è la possibilità di farlo. Se vengono soddisfatte alcune condizioni difficili, possiamo entrare nella modalità di caccia , concentrandoci su un singolo bot. Per accedere alla modalità di caccia:

1. Dobbiamo avere almeno 25 monete. (Prima dobbiamo prendere delle monete.)
2. Devono avere al massimo (le nostre monete - 5) monete e almeno 10 monete. (Non vogliamo dare la caccia a qualcuno che afferra una moneta ed è improvvisamente più potente, e non vogliamo nemmeno perseguire robot a zero monete.)
3. Dobbiamo rimanere indietro rispetto al bot attualmente in testa di almeno 1/10 delle sue monete. (Devi essere fortunato a cacciare qualcosa, quindi non è necessario dare una buona posizione solo per tentare la fortuna.)
4. Non dobbiamo essere in un cooldown di caccia (vedi sotto).

Se tutti questi sono soddisfatti, viene attivata la modalità di caccia. Per i successivi 10 round, il bot cacciato emette solo il potenziale Trascorsi questi 10 round, entriamo nel cooldown di caccia, durante il quale potremmo non entrare di nuovo nella modalità di caccia. (Questo per impedirci di inseguire senza fine e inutilmente un robot mentre tutti gli altri afferrano felicemente le monete.) Il tempo di recupero della caccia è di 20 round quando abbiamo 25 monete, e aumenta di 20 monete per ogni raddoppio di quello. (In altre parole, il tempo di recupero è

$$U = -150 e^{-r}.$$ 20(1 + log2(c / 25)).) (Lo usiamo perché nel gioco finale, tutti i robot cacciabili sono probabilmente morti, e quindi ogni caccia sarà molto probabilmente vana. Per questo motivo, vogliamo limitare il tempo sprecato. Ma a volte, un fortunato in ritardo- il game game può cambiare tutto, quindi manteniamo la possibilità.)

Infine, l'intera arena è posizionata in un potenziale infinito che impedisce al bot di fuggire.

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

Provalo online!

Big King Little Hill prende decisioni basate su "zone di controllo". Inseguirà solo le monete che si trovano nella sua zona di controllo, il che significa che può raggiungere la moneta prima di qualsiasi altro bot. Quando non ci sono monete nella sua zona di controllo, si sposta invece per massimizzare la dimensione della sua zona di controllo. Big King Little Hill calcola la zona di controllo di ciascuna delle sue 5 mosse possibili e favorisce le mosse che massimizzano la dimensione della sua zona di controllo. In questo modo, Big King Little Hill alla fine raggiunge un massimo locale (piccola collina) di controllo e attende che venga generata una moneta nella sua zona. Inoltre, Big King Little Hill rifiuta qualsiasi mossa che potrebbe causare la sua morte a meno che non ci siano alternative.

Big King Little Hill è un pessimista (preferisce il termine realista) perché non si preoccupa di contestare alcuna moneta che non è certo di ottenere. È anche un pacifista in quanto non persegue robot più deboli in alcun senso (anche se potrebbe calpestarne uno se si frappongono). Infine, Big King Little Hill è un codardo che non metterà in pericolo la propria vita per qualsiasi ricompensa a meno che non sia assolutamente necessario.

Moneta di sicurezza | 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";}
  }
}

Questo robot si dirige direttamente verso una moneta ponderata (valore / distanza) che non può morire raggiungendo contemporaneamente o dopo un altro robot. Se non esiste una moneta valida con questa proprietà, si trova dove si trova il robot ora si sposta in una direzione sicura casuale (sicurezza significa che se un robot si sposta verso di essa, la moneta di sicurezza non può scontrarsi. Ciò consente al robot di scambiare i posti con un altro bot se immediatamente accanto), ponderato verso il centro dell'arena.

Il Bot che gioca il gioco con cautela ma può essere aggressivo | JavaScript

Colore preferito: #F24100

Nota: sebbene questo bot abbia preso il 1 ° posto, è dovuto alla collaborazione con "Feudal Noble" alla fine e mangiandolo per altre monete. Altrimenti questo bot sarebbe stato terzo. Se sei interessato a robot più potenti individualmente, dai un'occhiata a Potenzialmente vittorioso e Big King Little Hill .

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        return score + Math.random();
    };

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

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

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

    return topCommand;
}

Questo bot (noto anche come "TBTPTGCBCBA") cerca di prendere la migliore decisione possibile generando un punteggio per ogni possibile mossa e seleziona la mossa con punteggio più alto per ogni turno.

Il sistema di punteggio ha molti dettagli che si sono evoluti dall'inizio della sfida. Possono essere descritti generalmente in questo modo:

• Più le monete sono vicine a una possibile mossa, maggiore è il punteggio ottenuto da tale mossa. Se una moneta non ha altri possibili concorrenti, il punteggio aumenta ulteriormente. Se una moneta ha altri possibili concorrenti, il punteggio diminuisce.
• Se un altro bot è vicino a una possibile mossa e ha meno monete, a seconda della fase del gioco, potrebbe significare più punteggio per quella mossa. Quindi è casuale che "TBTPTGCBCBA" mangi qualche altro robot in ogni partita.
• Se un altro robot è vicino a una possibile mossa con punti uguali o più, quella mossa ottiene abbastanza punteggio negativo per assicurarsi che la morte sia evitata. Naturalmente ci potrebbero essere alcuni casi in cui tutte le possibili mosse sono sbagliate e la morte non può essere evitata, ma è molto raro.
• C'è un meccanismo per tenere traccia del numero di robot al centro del tabellone negli ultimi 20 turni. Se la media è abbastanza bassa, tutti i movimenti verso le monete nel mezzo ottengono più punteggio e se la media è alta, allora tutti i movimenti verso le monete nel mezzo ottengono un punteggio più basso. Questo meccanismo consente di evitare conflitti con "Nobile feudale". Poiché il "Nobile feudale" è sempre nel mezzo (a meno che non venga inseguito), il numero medio di bot nel mezzo aumenta e "TBTPTGCBCBA" capisce di evitare il mezzo se esiste una migliore opzione al di fuori dell'area centrale. Se "Feudal Noble" muore, la media diminuisce e "TBTPTGCBCBA" comprende che può usare la metà.
• Ci sono alcuni fattori che cambiano dinamicamente in base alla fase del gioco (rilevati dal numero di bot vivi), questi fattori influenzano il punteggio in ciascuno degli oggetti sopra.
• Questo bot ha un'abilità speciale. Nel tempo si stanca dell'egoismo di "Nobile feudale" e dell'oppressione dei contadini. Al momento giusto, sorgerà per porre fine allo spiacevole sistema feudalesimo. Un tentativo riuscito non solo aiuta i poveri contadini, ma offre anche maggiori possibilità di vincita a causa delle monete prese dal "Nobile feudale".

L'anticapitalista | Javascript

Non ha alcun incentivo a cercare monete, ma cerca di posizionarsi esattamente tra i due robot più ricchi con la stessa quantità di denaro, nella speranza che lo cacciano e alla fine lo catturino allo stesso tempo, portando con sé due capitalisti quando muore . Non resiste attivamente all'ottenimento di monete, quindi potrebbe diventare un bersaglio più succoso.

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

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

Con Potenzialmente vittorioso abbiamo due campi: il campo bot e il campo moneta. Tuttavia, la natura non è così complicata. È tempo di unificare i due campi per produrre la Grande Teoria Unificata .

In primo luogo, dobbiamo capire qual è il potenziale del campo. Supponendo che il nostro bot non influisca in alcun modo sul campo, possiamo scrivere questo come:

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

$k_n$$(x_n, y_n)$

La proprietà relativa dell'oggetto viene calcolata in questo modo:

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

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

_{Chiamiamo semplicemente questa parte di correzione di Modified Betanian Dynamics (MOBD) .}

Possiamo anche trovare l'energia cinetica come:

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

Ora possiamo calcolare l'azione:

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

E così il lagrangiano del nostro bot nel campo del coin-bot è:

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

Ora dobbiamo risolvere le equazioni di Eulero-Lagrange:

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

e:

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

Così:

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

E anche:

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

Ora non abbiamo bisogno di andare oltre: guardiamo solo alla direzione dell'accelerazione generale:

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

E proprio così, abbiamo unificato le monete e i robot. Dov'è il mio premio Nobel?

Riccioli d'oro, 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
}

Provalo online!

Si aggancia alla posizione della moneta d'oro e si sposta verso di essa ogni volta. (Grazie al bot 'B33-L1N3' di @ Mayube per il codice originale utilizzato, anche se a malapena ne rimane.)

Algoritmo di apprendimento di terza generazione | 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)];
}

Provalo online!

Dopo alcune generazioni di apprendimento, questo bot ha imparato che lasciare l'arena = male

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

Provalo online!

Fa una scala per la moneta più vicina

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

Questo ha sentito che il bordo dell'arena è un posto pericoloso dove stare. Non avendo paura, gira instancabilmente la tavola in senso orario, a pochi centimetri dalla morte certa che attende dietro il confine, sperando che nessun altro robot oserà muoversi così da vicino nelle vicinanze del bordo.

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
}

Provalo online!

Un ultimo bot basato su katamari per oggi, questa volta con un po 'di memoria. Grazie a @BetaDecay per il suggerimento sul nome - sicuramente un nome più divertente del mio simplePredictorKatamari.

Cerca di capire come si sono mossi i robot nell'ultimo turno e, in base a quello, predice dove proveranno a muoversi alla fine di questo turno (supponendo che continuino a muoversi nella stessa direzione).

(Grazie a @ fəˈnɛtɪk, per aver notato che stavo chiamando il nome della funzione errata in botNotes, e a @ OMᗺ per aver notato un bug nel codice di base.)

Proton | JavaScript

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

Tutte le monete (comprese quelle detenute da altri robot) emettono una forza repulsiva verso Protonbot. Basato su questa forza, aumenta la velocità e rimbalza sui muri (si gira immediatamente dopo aver colpito un confine). Se finisce vicino a un robot o una moneta che può consumare, la Forza nucleare forte prende il sopravvento e si muove per consumarlo, facendo cadere tutta la velocità quando lo fa.

Non così ciecamente | JavaScript (Node.js)

Nota importante: questo approccio non è interamente mio ed è stata data una risposta in una domanda simile . Assicurati di votare anche quella risposta.

Hai mai sentito parlare dell'algoritmo A * pathfinding? Ecco qui. Crea il percorso migliore da un punto alla moneta meno preziosa (poiché tutti stanno andando per il più prezioso, nessuno sta andando per il meno) e cerca di non scontrarsi con nessun altro utente.

Si aspetta i parametri come segue:

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

---

Forse ne faccio uno che va a caccia di altri robot

---

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

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

Evita i robot con più soldi, se possibile. Altrimenti, prendi i soldi che ti stanno intorno.

Wild Goose Chase Bot, Javascript

Un robot che è davvero bravo a schivare altri robot, ma molto cattivo a ottenere monete.

---

Algoritmo:

1. Se non ci sono bot adiacenti, non restituire nessuno
2. Altrimenti:
   1. Restituisci nessuno con una possibilità casuale 1/500 di probabilità (questo ha lo scopo di prevenire stallo).
   2. Determina in quali spazi è sicuro spostarsi (ovvero all'interno dell'arena e non occupato da un altro bot)
   3. Restituisci uno a caso

---

Codice:

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

Provalo online!

Nota per i programmi Redwolf:

Questo bot ha il potenziale per causare round molto lunghi. Mi sono preso alcune libertà per prevenire le situazioni di stallo, ma non ho testato se sono effettivamente efficaci. Se questo bot diventa un problema durante il test, non esitate a squalificarlo.

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
}

Provalo online!

(Grazie a @ OMᗺ per aver segnalato un bug nel codice originale su cui si basava.)

Cerca di crescere "mangiando" robot con meno monete di se stesso. Se ciò non è possibile (non esiste un robot simile), cerca la moneta più vicina.

Questa versione ha piccole modifiche per (a) dare maggiore preferenza alle monete d'oro rispetto alle monete d'argento - con il rischio che la ricerca di una moneta d'oro più distante possa finire per costare la vita del robot o portare a inseguire l'oro degli sciocchi (b) saltare i robot con 0 monete - non c'è bisogno di perdere tempo a inseguirle.