Catatan: Survei untuk favorit komunitas akan segera dirilis

Dalam KoTH ini, tujuannya adalah untuk menjadi bot terakhir yang masih hidup. Koin akan ditempatkan di area acak, dan bot Anda harus mendapatkan koin terlebih dahulu. Jika bot berlari ke bot lain, bot dengan lebih banyak koin menang, dan bot lainnya mati. Lebih detail di bawah ini.

Jenis koin

Akan ada 2 jenis koin: emas dan perak. Emas menambah 5 koin ke kekuatan bot, dan perak menambahkan 2. Setelah koin dikumpulkan, koin lain ditempatkan di tempat lain di papan tulis. Pada waktu tertentu, ada satu koin emas dan empat koin perak di arena.

Tabrakan bot

Dalam hal dua bot mencoba untuk menempati ruang yang sama, yang satu lebih banyak koin akan tetap, dan yang lebih sedikit akan ... tidak. Bot yang menang akan mendapatkan 85% dari koin lawan (Dibulatkan ke Atas). Jika mereka diikat, keduanya mati. Jika tiga atau lebih mencoba untuk menempati ruang yang sama, yang paling kuat menang, dan mendapat 85% dari semua koin bot lainnya. Jika bot yang paling kuat adalah seri, semua bot mati yang mencoba memasuki ruang angkasa.

Arena

Panjang sisi arena dihitung dengan 4 + botCount. Saat menempatkan bot di awal permainan, tempat acak dipilih. Sistem memastikan bahwa tidak ada bot yang dimulai di ruang yang sama, atau bersebelahan. Koin dihasilkan secara acak, tidak termasuk 3 x 3 persegi yang berpusat pada setiap bot. Jika bot ditemukan di luar arena, ia mati seketika. Arena dimulai pada (0,0), atau Northwest, di sudut kiri atas, dan lokasi bot selalu berupa bilangan bulat.

Bot Anda

Bot Anda harus berupa fungsi, dalam bahasa berorientasi objek apa pun yang memiliki larik, bilangan bulat, string, dan fungsi. Perhatikan bahwa semua pengiriman akan dikonversi ke Javascript, untuk mempermudah. Untuk menyimpan informasi antar gerakan, gunakan botNotes.storeData(key, value)dan botNotes.getData(key, value). Anda tidak boleh menyimpan atau mengakses data dengan cara apa pun, selain dari yang disediakan melalui parameter dan botNotes. Anda harus membuat sebuah fungsi yang, saat dipanggil, mengembalikan string north, east, south, west, atau none. Akan ada 3 argumen untuk fungsi:

• Sebuah objek dengan empat bilangan bulat ( locationX, locationY, coins, arenaLength), lokasi Anda saat ini, koin, dan panjang arena

• Array multidimensi dengan koordinat X dan Y dari bot lain, dan jumlah koinnya, misalnya[[0,5,4],[4,7,1],[7,4,12]]

• Array dengan lokasi koin terdaftar (Emas selalu menjadi yang pertama)

Ini adalah tantangan raja bukit, Standar Lubang dilarang. Fungsi Anda akan dijalankan beberapa ribu kali, setiap kali diperbolehkan satu "Pindah". Perhatikan bahwa jika permainan melebihi 20.000 gerakan , bot dengan koin terbanyak menang. Ini akan dilakukan 8.000 kali, untuk menghilangkan keacakan.

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

Hadiah:

Tempat Pertama: hadiah 100 poin
Favorit Komunitas: jawaban diterima 15 poin

Pemenang:

Tempat Pertama: TBTPTGCBCBA
Tempat Kedua: Big King Little Hill
Tempat Ketiga: Berpotensi Menang
Keempat Tempat: Bot Mabes Polite Near-Sighted
Fifth Place: Safety Coin

BaitBot - JavaScript Node.JS

Mengapa repot-repot mengejar atau berlari jika Anda tidak pernah bisa menangkap? Sebaliknya, BaitBot menemukan koin terdekat dan menunggu bot yang lebih lemah juga mendekatinya. Ketika keduanya berdekatan, baitBot berlaku untuk koin dengan asumsi bot yang lebih lemah juga. Jika baitBot sedang menunggu dan bot yang lebih kuat mendekat, ia hanya mengambil koin dan melaju cepat. Coba saya!

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

}

Berpotensi Menang | JavaScript

Warna yang disukai untuk bot ini adalah #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];
}

(Permintaan maaf untuk pemformatan yang ceroboh, lekukan 4 spasi untuk situs ini tidak sesuai dengan kebiasaan saya menggunakan tab.)

Penjelasan kasar

Saya dengan ini mengundurkan diri dalam upaya untuk memperbarui penjelasan formula. Koefisien terus berubah dan agak sulit untuk menjaga penjelasannya tetap terbaru. Jadi saya hanya akan menjelaskan prinsip umum.

Setiap koin dan setiap bot menghasilkan medan gaya dengan beberapa potensi. Saya hanya menambahkan potensi dari semuanya bersama-sama dan bot kemudian pergi ke mana pun potensinya paling rendah. (Jelas gagasan ini dicuri dari fisika.)

Saya menggunakan dua jenis potensi. Yang pertama adalah gravitasi pseudo-gravitasi (yang bekerja pada kisaran apa pun), dengan The k adalah "kekuatan" dari lapangan, dan, dengan pilihan ini tanda, potensi menarik. The r sini (dan di tempat lain) adalah jarak di taksi metrik, r = | x₁ - x₂ | + | y₁ - y₂ | .

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

Saya menggunakan k = 40 untuk koin emas dan k = 10 untuk koin perak. n adalah jumlah bot yang lebih dekat ke koin tertentu daripada kita. Kalau tidak, kita benar-benar mengabaikan bot lain (jika kita menghalangi bot yang lebih kuat, kita melarikan diri, tapi hanya itu). Saya menghargai koin emas lebih dari nilainya karena jika tidak, bot yang terutama mengejar emas selalu mengalahkan saya.

Potensi kedua adalah yang secara eksponensial membusuk (yang secara efektif hanya bertindak pada jarak yang sangat kecil). Ini dihasilkan oleh yang lain, terutama bot yang lebih kuat.

Ini menghasilkan bidang dengan Kekuatan ini sangat kuat pada kisaran 0-1, tetapi meluruh hampir tidak ada pada jarak yang lebih besar. (Jarak + 1 berarti memotong gaya dalam 1/20.)

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

Kami umumnya tidak menyerang bot lain dengan sengaja (tentu saja jika mereka menghalangi kami dan kami menginjaknya, itu adalah kesalahan mereka), tetapi ada kemungkinan untuk melakukan itu. Jika beberapa kondisi keras terpenuhi, kita dapat memasuki mode berburu , dengan fokus pada satu bot. Untuk masuk ke mode berburu:

1. Kami harus memiliki setidaknya 25 koin. (Kita perlu mendapat koin dulu.)
2. Mereka harus memiliki paling banyak (koin kita - 5) koin, dan setidaknya 10 koin. (Kami tidak ingin memburu seseorang yang mengambil satu koin dan tiba-tiba lebih kuat, dan kami juga tidak ingin mengejar bot nol koin.)
3. Kita harus ketinggalan di belakang bot yang saat ini memimpin dengan setidaknya 1/10 dari koinnya. (Kamu harus beruntung untuk berburu sesuatu, jadi tidak perlu memberikan posisi yang baik hanya untuk mencoba keberuntungan kita.)
4. Kita tidak harus berada di cooldown berburu (lihat di bawah).

Jika semua ini puas, mode berburu diaktifkan. Untuk 10 putaran berikutnya, bot yang diburu hanya memancarkan potensi Setelah 10 putaran ini berlalu, kita memasuki cooldown berburu, di mana kita mungkin tidak masuk mode berburu lagi. (Itu untuk mencegah kita dari mengejar satu bot tanpa henti dan tanpa hasil sementara semua lainnya dengan gembira mengambil koin.) Cooldown berburu adalah 20 putaran ketika kita memiliki 25 koin, dan bertambah 20 koin per setiap penggandaannya. (Dengan kata lain, cooldown adalah .) (Kami menggunakannya karena pada akhirnya, semua bot yang dapat diburu kemungkinan besar mati, dan setiap perburuan kemungkinan besar akan sia-sia. Karena itu, kami ingin membatasi waktu yang terbuang. Tapi kadang-kadang, makan di akhir permainan yang beruntung bisa mengubah segalanya, jadi kami menjaga kemungkinan itu.)

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

Akhirnya, seluruh arena ditempatkan ke sumur potensial tak terbatas yang mencegah bot melarikan diri.

Algoritma Pembelajaran Gen Pertama | JavaScript (Node.js)

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

Cobalah online!

Pernahkah Anda melihat garis waktu algoritma belajar belajar bermain game? Mereka sering bergerak hampir secara acak dalam beberapa generasi pertama ...

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

Cobalah online!

Big King Little Hill membuat keputusan berdasarkan "zona kontrol". Itu hanya akan mengejar koin yang berada di zona kontrol yang berarti dapat mencapai koin sebelum bot lain bisa. Ketika tidak ada koin di zona kontrolnya, ia malah bergerak untuk memaksimalkan ukuran zona kontrolnya. Big King Little Hill menghitung zona kontrol dari masing-masing 5 gerakan yang mungkin dan mendukung gerakan yang memaksimalkan ukuran zona kontrolnya. Dengan cara ini, Big King Little Hill akhirnya mencapai kontrol maksimum (bukit kecil) lokal dan menunggu koin dihasilkan dalam zonanya. Selain itu, Big King Little Hill menolak segala tindakan yang dapat mengakibatkan kematiannya kecuali tidak ada alternatif.

Big King Little Hill adalah orang yang pesimis (lebih suka istilah realis) karena tidak mau repot-repot memperebutkan koin apa pun yang tidak dijamin diperolehnya. Ia juga seorang pasifis karena ia tidak mengejar bot yang lebih lemah dalam arti apa pun (meskipun mungkin akan menginjaknya jika mereka menghalangi). Terakhir, Big King Little Hill adalah seorang pengecut yang tidak akan membahayakan hidupnya sendiri untuk imbalan apa pun kecuali benar-benar harus.

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

Bot ini langsung menuju koin bernilai tertimbang (nilai / jarak) yang tidak dapat mati karena mencapai pada saat yang sama atau setelah bot lain. Jika tidak ada koin yang valid dengan properti ini, ia duduk di tempat bot berada sekarang bergerak ke arah aman acak (keselamatan berarti bahwa jika bot bergerak ke arahnya, koin pengaman tidak dapat bertabrakan. Hal ini memungkinkan bot untuk bertukar tempat dengan bot lain jika tepat di sebelahnya), tertimbang menuju pusat arena.

Bot yang Memainkan Gim Dengan Hati-Hati Tetapi Bisa Agresif | JavaScript

Warna yang disukai: #F24100

Catatan: Meskipun bot ini telah menempati posisi pertama, itu karena bergabung dengan "Feudal Noble" di akhir dan memakannya untuk mendapatkan lebih banyak koin. Kalau tidak, bot ini akan menjadi yang ke-3. Jika Anda tertarik dengan bot yang lebih kuat secara individual, checkout Potential Victorious dan 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;
}

Bot ini (alias "TBTPTGCBCBA") mencoba membuat keputusan terbaik dengan menghasilkan skor untuk setiap gerakan yang mungkin dan memilih gerakan dengan skor yang lebih tinggi untuk setiap belokan.

Sistem penilaian memiliki banyak detail yang berkembang sejak awal tantangan. Mereka dapat digambarkan secara umum seperti ini:

• Semakin dekat koin dengan gerakan yang mungkin, semakin banyak skor yang bergerak. Jika koin tidak memiliki kontestan lain yang memungkinkan, skornya bahkan lebih tinggi. Jika sebuah koin memiliki kemungkinan kontestan lain, skornya menjadi lebih rendah.
• Jika bot lain dekat dengan gerakan yang mungkin dan memiliki lebih sedikit koin, tergantung pada fase permainan, itu bisa berarti lebih banyak skor untuk langkah itu. Jadi biasa untuk "TBTPTGCBCBA" untuk makan beberapa bot lain di setiap pertandingan.
• Jika bot lain dekat dengan gerakan yang mungkin dengan poin yang sama atau lebih, gerakan itu mendapat skor negatif yang cukup untuk memastikan kematian dihindari. Tentu saja mungkin ada beberapa kasus bahwa semua gerakan yang mungkin adalah buruk dan kematian tidak dapat dihindari, tetapi itu sangat jarang.
• Ada mekanisme untuk melacak jumlah bot di tengah papan selama 20 putaran terakhir. Jika rata-rata cukup rendah, semua bergerak ke arah koin di tengah mendapatkan skor lebih banyak dan jika rata-rata tinggi, maka semua bergerak ke arah koin di tengah mendapatkan skor lebih rendah. Mekanisme ini memungkinkan untuk menghindari konflik dengan "Feudal Noble". Karena "Feudal Noble" selalu di tengah (kecuali sedang dikejar), rata-rata jumlah bot di tengah naik dan "TBTPTGCBCBA" mengerti untuk menghindari tengah jika ada pilihan yang lebih baik di luar daerah tengah. Jika "Feudal Noble" mati, rata-rata turun dan "TBTPTGCBCBA" mengerti bahwa ia dapat menggunakan tengah.
• Ada beberapa faktor yang berubah secara dinamis berdasarkan fase permainan (terdeteksi dari jumlah bot hidup), faktor-faktor ini mempengaruhi penilaian di masing-masing item di atas.
• Bot ini memiliki kemampuan khusus. Seiring waktu ia mulai bosan dengan keegoisan "Feodal Noble" dan penindasan petani. Pada saat yang tepat, ia akan bangkit untuk mengakhiri sistem feodalisme yang tidak menyenangkan. Upaya yang berhasil tidak hanya membantu petani miskin, tetapi juga memberikan peluang kemenangan yang lebih tinggi karena koin yang diambil dari "Feudal Noble".

The AntiCapitalist | Javascript

Tidak memiliki insentif untuk mengejar koin, tetapi mencoba menempatkan dirinya tepat di antara dua bot terkaya dengan jumlah uang yang sama, dengan harapan mereka akan memburunya dan akhirnya menangkapnya pada saat yang sama, membawa dua kapitalis bersamanya ketika dia mati . Tidak secara aktif menolak untuk mendapatkan koin, jadi dia mungkin menjadi target yang lebih menarik.

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

Dengan Potential Victorious, kami memiliki dua bidang: bidang bot dan bidang koin. Namun, alam tidaklah rumit. Sudah waktunya untuk menyatukan dua bidang untuk menghasilkan Grand Unified Theory .

Pertama, kita perlu mencari tahu apa potensi lapangan itu. Dengan asumsi bot kita sendiri tidak mempengaruhi bidang dengan cara apa pun, kita dapat menulis ini sebagai:

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

Properti relatif objek dihitung seperti ini:

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

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

_{Sebut saja bagian koreksi ini dari Modified Betanian Dynamics (MOBD) .}

Kita juga dapat menemukan energi kinetik sebagai:

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

Kami sekarang dapat menghitung tindakan:

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

Dan Lagrangian bot kami di bidang koin-bot adalah:

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

Kita sekarang perlu menyelesaikan persamaan Euler-Lagrange:

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

dan:

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

Begitu:

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

Dan juga:

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

Sekarang kita tidak perlu melangkah lebih jauh: kita hanya melihat arah percepatan keseluruhan:

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

Dan seperti itu, kami telah menyatukan koin dan bot. Di mana Hadiah Nobel saya?

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
}

Cobalah online!

Cukup kunci ke lokasi koin emas dan bergerak ke arah itu setiap saat. (Terima kasih kepada bot 'B33-L1N3' dari @ Mayube untuk kode asli yang digunakan ini, meskipun hampir tidak ada yang tersisa.)

Algoritma Pembelajaran Gen Ketiga | 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)];
}

Cobalah online!

Setelah beberapa generasi belajar, bot ini telah belajar bahwa meninggalkan arena = buruk

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

Cobalah online!

Membuat langsung menuju untuk koin terdekat

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

Yang satu ini mendengar ujung arena adalah tempat yang berbahaya. Mengetahui tidak ada rasa takut, ia tanpa lelah melingkari papan searah jarum jam, hanya beberapa senti dari kematian tertentu yang menunggu di belakang perbatasan, berharap tidak ada bot lain yang berani bergerak begitu dekat ke sekitar tepi.

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
}

Cobalah online!

Satu bot berbasis katamari terakhir untuk hari ini, kali ini dengan sedikit memori. Terima kasih kepada @BetaDecay untuk saran nama - pasti nama yang lebih menyenangkan daripada saya simplePredictorKatamari.

Berusaha mengetahui bagaimana bot telah bergerak di belokan terakhir, dan berdasarkan itu, memprediksi ke mana mereka akan mencoba bergerak di akhir belokan ini (dengan asumsi mereka terus bergerak ke arah yang sama).

(Terima kasih kepada @ fəˈnɛtɪk, karena memperhatikan bahwa saya memanggil nama fungsi yang salah di botNotes, dan ke @ OMᗺ karena memperhatikan bug dalam kode dasar.)

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

Semua koin (termasuk yang dipegang oleh bot lain) memancarkan gaya tolak terhadap Protonbot. Berdasarkan kekuatan ini, ia membangun kecepatan dan memantul dari dinding (berbalik segera setelah mengenai batas). Jika berakhir di sebelah bot atau koin yang dapat dikonsumsi, gaya nuklir Strong mengambil alih dan bergerak untuk mengkonsumsinya, menjatuhkan semua kecepatan ketika melakukannya.

Tidak begitu Buta | JavaScript (Node.js)

Catatan Penting: Pendekatan ini tidak sepenuhnya milik saya dan telah dijawab dalam pertanyaan serupa . Pastikan untuk memilih jawaban itu juga.

Pernahkah Anda mendengar tentang algoritma pathfinding A *? ini dia. Ini menciptakan jalur terbaik dari satu titik ke koin yang kurang berharga (karena semua orang mencari yang paling berharga, tidak ada yang mencari yang kurang) dan mencoba untuk tidak bertabrakan dengan pengguna lain.

Diharapkan parameter sebagai berikut:

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

---

Mungkin saya melakukan satu yang pergi berburu bot lain

---

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

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

Hindari bot dengan lebih banyak uang jika memungkinkan. Kalau tidak, ambil uang yang ada di sekitar.

Bot Goose Chase Liar, Javascript

Bot yang sangat bagus untuk menghindari bot lain, tetapi sangat buruk dalam mendapatkan koin.

---

Algoritma:

1. Jika tidak ada bot yang berdekatan, kembalikan tidak ada
2. Jika tidak:
   1. Tidak mengembalikan apa pun dengan kesempatan acak 1/500 (ini dimaksudkan untuk mencegah kebuntuan).
   2. Tentukan ruang mana yang aman untuk dipindahkan (yaitu di dalam arena dan tidak ditempati oleh bot lain)
   3. Kembalikan satu secara acak

---

Kode:

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

Cobalah secara Online!

Catatan untuk Program Redwolf:

Bot ini berpotensi menyebabkan putaran yang sangat panjang. Saya telah mengambil beberapa kebebasan untuk mencegah kebuntuan, tetapi belum menguji apakah mereka benar-benar efektif. Jika bot ini menjadi masalah selama pengujian, silakan didiskualifikasi.

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
}

Cobalah online!

(Terima kasih kepada @ OMᗺ karena menunjukkan bug dalam kode asli yang menjadi dasar ini.)

Berusaha untuk tumbuh dengan "memakan" bot dengan koin lebih sedikit dari dirinya sendiri. Jika itu tidak mungkin (tidak ada bot seperti itu), maka cari koin terdekat.

Versi ini memiliki sedikit penyesuaian untuk (a) memberikan preferensi lebih tinggi pada koin emas daripada koin perak - dengan risiko bahwa mencari koin emas yang lebih jauh akan berakhir dengan mengorbankan nyawa bot atau menyebabkan pengejaran emas bodoh (b) lewati bot dengan 0 koin - tidak perlu membuang waktu untuk mengejar mereka.