Not: Topluluğun favorisi için anket yakında yayınlanacak

Bu KoTH'de amaç, yaşayan en son bot olmak. Madeni paralar rastgele bölgelere yerleştirilir ve botunuz önce paraları almalıdır. Bir bot başka bir botla karşılaşırsa, daha fazla jetonlu bot kazanır ve diğer bot ölür. Daha fazla detay aşağıda.

Para türleri

Altın ve gümüş olmak üzere 2 tür sikke olacaktır. Altın, botun gücüne 5 jeton, gümüş ise 2 ekler. Bir jeton toplandıktan sonra, tahtadaki başka bir noktaya başka bir jeton konur. Herhangi bir zamanda, arenada bir altın sikke ve dört gümüş sikke vardır.

Bot çarpışmaları

Aynı yerde kalmaya çalışan iki bot durumunda, daha fazla paraya sahip olan kalacak, daha azına sahip olan ... kalacak. Kazanan bot rakip paraların % 85'ini kazanacak (Yuvarlanmış). Bağlanırlarsa ikisi de ölür. Üç ya da daha fazla aynı alanı işgal etmeye çalışırsa, en güçlü olan kazanır ve diğer tüm botların paralarının% 85'ini alır. En güçlü botun bir kravat olması durumunda, tüm botlar uzaya girmeye çalışan ölür.

Arena

Arenanın yan uzunluğu ile hesaplanır 4 + botCount. Oyunun başında botlar yerleştirilirken rastgele yerler seçilir. Sistem aynı alanda veya yan yana hiçbir botun başlamamasını sağlar. Madeni paralar, her bir botta merkezlenmiş 3 x 3 kare hariç, rasgele üretilir. Arenanın dışında bir bot bulunursa, anında ölür. Arena sol üst köşede (0,0) veya Kuzeybatı'dan başlar ve bir botun konumu her zaman bir tamsayıdır.

Senin bot

Botunuz, dizileri, tam sayıları, dizeleri ve işlevleri olan herhangi bir nesne yönelimli dilde bir işlev olmalıdır. Tüm gönderilerin işleri kolaylaştırmak için Javascript'e dönüştürüleceğini unutmayın. Hareketler arasında bilgi depolamak için, botNotes.storeData(key, value)ve tuşlarını kullanın botNotes.getData(key, value). Ve parametrelerinde sağlananlar dışında hiçbir şekilde veri depolayamaz veya erişemezsiniz botNotes. Sen, çağrıldığında, bir dize döndüren bir işlev oluşturmalısınız north, east, south, west, veya none. İşlev için 3 argüman olacaktır:

• Dört tamsayılar ile bir nesne ( locationX, locationY, coins, arenaLength), mevcut konumunuz, senin paralar, ve arena uzunluğu

• Diğer botların X ve Y koordinatlarına sahip çok boyutlu bir dizi ve madeni para sayımı,[[0,5,4],[4,7,1],[7,4,12]]

• Madeni para konumları listelenen bir dizi (Altın her zaman öncedir)

Bu tepe mücadelesinin kralı, Standart Loopholes yasaktır. Her seferinde bir "Hareket" izin verdiğinde işleviniz binlerce kez çalıştırılacak. Oyun 20.000 hamleyi aşarsa , en çok para kazandıran bot kazanır. Bu rastgele kaldırmak için 8.000 kez yapılacaktır.

Sohbet odası: https://chat.stackexchange.com/rooms/81347/gold-collectors-koth

Ödüller:

Birincilik: 100 puan ödül
Topluluk Favori: 15 puan kabul edilen cevap

Kazananlar:

Birincisi: TBTPTGCBCBA
İkincilik: Büyük Kral Küçük Tepesi
Üçüncülük: Potansiyel Olarak Muzaffer
Dördüncü Sıra: Kibar Yakın Görülen Sarhoş Bot
Beşinci Yer: Güvenlik Madeni Para

BaitBot - JavaScript Node.JS

Asla yakalayamıyorsan niçin kovalamaktan ya da koşmaktan rahatsız ol? Bunun yerine, BaitBot en yakın madeni parayı bulur ve daha zayıf bir botun ona yaklaşmasını bekler. İkisi de bitişik olduklarında, baitBot zayıf botun da olacağını varsayarak paraya gider. Eğer baitBot bekliyorsa ve daha güçlü bir bot yaklaşıyorsa, parayı ve skedad'ları alır. Beni dene!

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

}

Potansiyel Olarak Muzaffer | JavaScript

Bu bot için tercih edilen renk #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];
}

(Özensiz biçimlendirme için özür dilerim, bu sitenin 4 boşluk girintisi, sekmeleri kullanma alışkanlığımla iyi gitmiyor.)

Kaba açıklama

Formüllerin açıklamasını güncelleme girişiminde istifa ediyorum. Katsayılar sürekli değişiyor ve açıklamayı güncel tutmak biraz zor. Bu yüzden genel prensibi açıklayacağım.

Her jeton ve her bot bazı potansiyeli olan bir kuvvet alanı oluşturur. Sadece her şeyden potansiyelleri topladım ve bot daha sonra potansiyelin en düşük olduğu yere gidiyor. (Açıkçası bu fikir fizikten çalındı.)

İki çeşit potansiyel kullanıyorum. Birincisi, U = - k ile sözde yerçekimidir (herhangi bir aralıkta hareket eden). Kişareti bu seçimi ile, potansiyel çekici, alanın bir "kuvvet" olduğunu ve. Buradakir(ve başka her yer) taksik metrikteki uzaklıktır,r = | x₁ - x₂ | + | y₁ - y₂ | .

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

Kullandığım = 40 k altın para ve için k = 10 gümüş para için. n , madeni paraya bizden daha yakın olan botların sayısıdır. Aksi takdirde, diğer botları kesinlikle görmezden geliyoruz (daha güçlü bir botun önüne geçersek kaçarız, ama o kadar). Altın paralara değerlerinden daha fazla değer veriyorum çünkü aksi halde öncelikle altından sonra giden botlar beni yendi.

İkinci potansiyel, üssel olarak çürüyen bir potansiyeldir (bu sadece çok küçük mesafelerde etkili bir şekilde hareket eder). Bu, özellikle daha güçlü botlar olmak üzere diğeri tarafından üretilir.

Bunlar olan bir alan üretir . Bu kuvvet 0-1 aralığında oldukça kuvvetlidir, ancak daha büyük mesafelerde neredeyse hiçbir şeye düşmez. (Mesafe + 1, kuvveti 1/20 olarak kesmek anlamına gelir.)

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

Genel olarak diğer botlara kasten saldırmazız (elbette yolumuza girerlerse ve üzerlerine basarsak, bu onların suçu), ama bunu yapma olasılığı var. Bazı zor şartlar yerine getirilirse, tek bir bot üzerinde odaklanarak avcılık moduna girebiliriz . Avcılık moduna girmek için:

1. En az 25 tane bozuk paramız olmalı. (Önce biraz para almamız gerekiyor.)
2. En fazla (jetonumuz - 5) jetonu ve en az 10 jetonu olmalıdır. (Bir jeton kapan ve aniden daha güçlü olan birini avlamak istemiyoruz ve sıfır jetonlu botların peşinde olmak istemiyoruz.)
3. Mevcut lider botun gerisinde kalmalı, sikkelerinin en az 1 / 10'u kadar. (Bir şeyi avladığınız için şanslı olmanız gerekir, bu yüzden sadece şansımızı denemek için iyi bir pozisyon vermenize gerek yoktur.)
4. Bir avlanma süresinin üzerinde olmamalıyız (aşağıya bakınız).

Bütün bunlar tatmin edilirse, avlanma modu etkinleştirilir. Sonraki 10 turda, avlanan bot sadece potansiyelini yayar . Bu 10 tur geçtikten sonra, avlanma bekleme süresine gireriz; bu sırada tekrar avlanma moduna giremeyebiliriz. (Bu, diğer tüm paraları kaparken, bir botu sonsuz ve meyvesizce kovalamamızı engeller.) Avlanma süresi 25 jetonumuz olduğunda 20 turdur ve her iki katına çıkacak başına 20 jeton artar. (Başka bir deyişle, bekleme süresi

$$U = -150 e^{-r}.$$ 20(1 + log2(c / 25)).) (Son maçta, tüm toplanabilen botların büyük olasılıkla ölü olduklarından ve bu nedenle herhangi bir avın büyük olasılıkla boşuna olacağından kullanıyoruz. Bu nedenle, boşa harcanan zamanı sınırlamak istiyoruz. Oyun yeme her şeyi değiştirebilir, bu yüzden imkanı koruruz.)

Son olarak, tüm arena botun kaçmasını engelleyen sonsuz bir potansiyel kuyusuna yerleştirilir.

İlk Gen Öğrenme Algoritması | JavaScript (Node.js)

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

Çevrimiçi deneyin!

Bir oyun oynamayı öğrenen öğrenme algoritmalarının zaman çizelgelerini hiç gördünüz mü? İlk birkaç nesilde sıklıkla rastgele hareket ederler ...

Büyük Kral Küçük Tepe | 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])
}

Çevrimiçi deneyin!

Big King Little Hill “kontrol bölgelerine” dayanarak kararlar alıyor. Sadece kendi kontrol bölgesinde bulunan ve başka herhangi bir botun alabilmesi için madeni paraya erişebileceği madeni paraların peşinde koşacaktır. Kontrol bölgesinde bozuk para olmadığında, kontrol bölgesinin boyutunu maksimize etmek için hareket eder. Büyük Kral Küçük Tepe, olası 5 hareketinin her birinin kontrol bölgesini hesaplar ve kendi kontrol bölgesinin boyutunu maksimize eden hareketleri tercih eder. Bu şekilde, Büyük Kral Küçük Tepesi nihayetinde yerel bir maksimum (küçük tepeye) kontrole ulaşır ve kendi bölgesinde bir madeni para oluşmasını bekler. Ek olarak, Big King Little Hill, alternatif olmadıkça ölümüne neden olabilecek herhangi bir hareketi reddetti.

Büyük Kral Küçük Tepesi karamsardır (gerçekçiliğin ismini tercih eder) çünkü alması kesin olmayan herhangi bir madeni paraya itiraz etmek zahmetine girmez. Ayrıca, herhangi bir anlamda zayıf botlar peşinde koşmadığından pasifisttir (eğer bir şekilde karşılaşırlarsa birine basabilir). Son olarak, Büyük Kral Küçük Tepesi, mecbur olmadığı sürece, herhangi bir ödül için kendi hayatını tehlikeye atmayacak bir korkaktır.

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

Bu bot, aynı anda veya başka bir bottan sonra ulaşamayacağından ötürü ölemediği ağırlıklı değerli bir madeni paraya (değer / mesafe) doğru yönelir. Bu özelliğe sahip geçerli bir jeton yoksa, botun rasgele güvenli bir yöne hareket ettiği yere oturur (güvenlik, bir bot kendine doğru hareket ederse, emniyet jetonunun çarpışmayacağı anlamına gelir. Bu, botun başka bir botla yer değiştirmesine izin verir. hemen yanında), arena merkezine doğru ağırlıklı.

Oyunu Dikkatle Oynanan Bot Agresif Olabilir | JavaScript

Tercih edilen renk: #F24100

Not: Bu bot birincilik kazanmasına rağmen, sonunda "Feodal Asil" ile bir araya gelip onu daha fazla para kazanmak için yemekten kaynaklanıyor. Aksi halde bu bot 3'üncü olurdu. Bireysel olarak daha güçlü olan botlarla ilgileniyorsanız, Potansiyel Olarak Muzaffer ve Büyük Kral Küçük Tepeye gidin .

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

Bu bot (aka "TBTPTGCBCBA"), her olası hamle için bir puan oluşturarak mümkün olan en iyi kararı vermeye çalışır ve her bir tur için daha yüksek skorlu hamleyi seçer.

Puanlama sistemi, mücadelenin başlamasından bu yana gelişen birçok ayrıntıya sahiptir. Genel olarak şöyle tarif edilebilirler:

• Madeni paralar olası bir harekete ne kadar yakınsa, o kadar fazla puan alır. Bir madalyonun başka olası yarışmacıları yoksa, skor daha da artar. Bir madalyonun başka olası yarışmacıları varsa, skor daha düşük olur.
• Başka bir bot olası bir harekete yakınsa ve oyunun aşamasına bağlı olarak daha az bozuk para varsa, bu hamle için daha fazla puan anlamına gelebilir. Bu yüzden "TBTPTGCBCBA" nın her oyunda diğer botlardan birkaçını yemesi rahattır.
• Başka bir bot, eşit veya daha fazla puanla muhtemel bir hamleye yakınsa, o hamle ölümden kaçınılması için yeterli negatif puan alır. Elbette tüm olası hareketlerin kötü olduğu ve ölümden kaçınamadığı bazı durumlar olabilir, ancak bu çok nadirdir.
• Tahtanın ortasındaki bot sayısının son 20 tur boyunca izlenmesi için bir mekanizma var. Ortalama yeterince düşükse, ortadaki tüm paralara doğru hareket daha fazla puan alır ve ortalamanın yüksek olması durumunda ortadaki tüm paralara doğru daha düşük puan alırsınız. Bu mekanizma "Feodal Asil" ile çatışmaları önlemeye izin verir. "Feodal Asil" her zaman ortada olduğu için (kovalanmadıkça), ortadaki ortalama bot sayısı artar ve orta alanın dışında daha iyi bir seçenek varsa, "TBTPTGCBCBA" ortadan kaçınmayı anlar. Eğer "Feodal Asil" ölürse, ortalama düşer ve "TBTPTGCBCBA" ortayı kullanabileceğini anlar.
• Oyunun evresine göre dinamik olarak değişen bazı faktörler vardır (hayatta kalan robotların sayısından tespit edilir), bu faktörler yukarıdakilerin her birindeki skorlamayı etkiler.
• Bu botun özel bir yeteneği var. Zamanla "Feodal Asil" in bencilliğinden ve köylülerin ezilmesinden bıktı. Doğru anda, tatsız Feodalizm sistemine son verecek. Başarılı bir girişim sadece yoksul köylülere yardım etmekle kalmaz, aynı zamanda "Feodal Asil" den alınan madeni paralar nedeniyle daha yüksek bir kazanma şansı sağlar.

Anti-Kapitalist | JavaScript

Madeni paraların peşinden gitmeye teşviki yok, ancak aynı parayla en zengin iki bot arasında tam olarak kendisini bulmaya çalışır, umarız onu avlarlar ve sonunda aynı anda yakalarlar, öldüğünde iki kapitalisti alırlar. . Aktif olarak jeton almaya direnmez, bu yüzden daha sulu bir hedef haline gelebilir.

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

Potansiyel Olarak Muzaffer ile iki alanımız var: bot alanı ve jeton alanı. Ancak, doğa o kadar karmaşık değil. Büyük Birleşik Teoriyi üretmek için iki alanı birleştirme zamanı .

Öncelikle, alanın potansiyelinin ne olduğunu bulmamız gerekiyor. Kendi botumuzun alanı hiçbir şekilde etkilemediğini varsayarsak, şunu yazabiliriz:

$$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)$ her bir nesnenin koordinatları vardır.

Nesnenin göreceli özelliği şöyle hesaplanır:

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

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

_{Bu sadece Modifiye Betanian Dynamics'in (MOBD) bu düzeltme bölümünü diyelim .}

Kinetik enerjiyi şu şekilde de bulabiliriz:

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

Şimdi eylemi hesaplayabiliriz:

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

Ve böylece bot-jetonlu bot alanındaki Lagrangian:

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

Şimdi Euler-Lagrange denklemlerini çözmemiz gerekiyor:

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

ve:

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

Yani:

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

Ve ayrıca:

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

Şimdi daha ileri gitmemize gerek yok: Sadece genel ivmenin yönüne bakıyoruz:

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

Ve aynen böyle, paraları ve botları birleştirdik. Nobel Ödülüm nerede?

Goldilocks, 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
}

Çevrimiçi deneyin!

Sadece altın sikkenin yerine kilitlenir ve her seferinde ona doğru hareket eder. (Bu kullanılan orijinal kod için @ Mayube’un 'B33-L1N3' botu sayesinde, neredeyse hiçbiri kalmadı.)

Üçüncü Gen Öğrenme Algoritması | 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)];
}

Çevrimiçi deneyin!

Birkaç nesilden sonra, bu bot arenayı terk etmenin kötü olduğunu öğrendi

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

Çevrimiçi deneyin!

Yapar En yakın para için beeline

Sınırda Yaşamak, 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';
  }
}

Bu arenada kenarının olması tehlikeli bir yer olduğunu duydu. Hiçbir korku bilmeden, yorulmadan tahtayı saat yönünde çevirir, sadece sınırın arkasında bekleyen kesin ölümden birkaç santim uzaktadır, başka hiçbir botun sınırın çevresine bu kadar yakın hareket etmeye cesaret edemez.

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
}

Çevrimiçi deneyin!

Bugün için son bir katamari tabanlı bot, bu sefer biraz hafıza ile. @BetaDecay sayesinde ad önerisi için - kesinlikle benden daha eğlenceli bir ad simplePredictorKatamari.

Botların son sıralarda nasıl hareket ettiklerini anlamaya çalışır ve buna göre, bu dönüşün sonunda nereye hareket etmeye çalışacaklarını tahmin eder (aynı yönde hareket etmeye devam ettiklerini varsayarsak).

(@ Fəˈnɛtɪk sayesinde, botNotes uygulamasında yanlış işlev adını çağırdığımı fark ettiğiniz için ve temel kodda bir hata olduğunu fark ettiğim için @ OM @ öğesine teşekkür ederiz.)

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

Tüm madeni paralar (diğer botlar tarafından tutulanlar dahil) Protonbot'a itici bir güç yayar. Bu kuvvete dayanarak, hız kurar ve duvarlardan zıplar (bir sınıra çarptıktan hemen sonra döner). Eğer tüketebileceği bir botun veya madalyonun yanında biterse, Güçlü nükleer kuvvet devralır ve tüketmek için hareket eder, öyle olunca tüm hızları düşürür.

Kör Değil | JavaScript (Node.js)

Önemli Not: Bu yaklaşım tamamen benim değildir ve benzer bir soruya cevaplanmıştır. . Bu cevabı da oyladığınızdan emin olun.

Hiç A * yol bulma algoritmasını duydunuz mu? işte burada. Bir noktadan daha az değerli madeni paraya kadar en iyi yolu yaratır (herkes en değerli olanı, hiç kimse daha azına gitmez) ve başka bir kullanıcıyla çarpışmamaya çalışır.

Parametreleri aşağıdaki gibi bekler:

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

---

Belki başka botlara avcılık yapan birini yaparım.

---

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

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

Mümkünse daha fazla paraya sahip botlardan kaçının. Aksi takdirde, etrafta yatan parayı al.

Vahşi Kaz Chase Bot, Javascript

Diğer botlardan kaçmak için gerçekten iyi, ancak para almakta çok kötü bir bot.

---

Algoritma:

1. Bitişik bot yoksa, hiçbiri döndür
2. Aksi takdirde:
   1. Hiçbirini rastgele bir şansla 1/500 şansla geri döndürün (bu, çıkmazları önlemeye yöneliktir).
   2. Hangi alanlara taşınmanın güvenli olduğunu belirleyin (yani arenada ve başka bir bot tarafından işgal edilmemiş)
   3. Birini rastgele döndür

---

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

Çevrimiçi Deneyin!

Redwolf Programlarına Not:

Bu botun çok uzun mermilere neden olma potansiyeli var. Çürükleri önlemek için bazı özgürlükler aldım, ancak gerçekten etkili olup olmadıklarını sınamadım. Bu bot test sırasında sorun çıkarsa, lütfen diskalifiye etmekten çekinmeyin.

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
}

Çevrimiçi deneyin!

(Bunun temel kodundaki bir hatayı işaret ettiği için @ OMᗺ'ya teşekkürler.)

Kendinden daha az para ile botları "yiyerek" büyümeye çalışır. Bu mümkün değilse (böyle bir bot bulunmuyorsa), en yakın bozuk parayı arar.

Bu versiyonun küçük tweaksları (a) 'nın altın sikkelere göre gümüş sikkelere göre daha fazla tercih edilmesini sağlar - daha uzak bir altın madeni para aramanın botun ömrüne malolarak bitmesi veya aptalın altının peşinden koşmasına neden olma riski (b) 0 jeton - peşinde koşmaya gerek yok.