To wyzwanie króla wzgórza w okrągłym rudzie. To bitwa o znalezienie najlepszego rewolwerowca z zachodu!

Aby móc wziąć udział w tym konkursie, musisz wykonać dwie funkcje. Pierwszy ustawia atrybuty twojego strzelca, a drugi jest główną funkcją logiczną strzelca.

Funkcja atrybutu

function () {

    var bot = {
        name: "testBot",
        numbOfBullets: 7,
        reloadSpeed: 1, 
        shotsPerTurn: 1,
        moveSpeed: 2 
    }
    return bot
}

Funkcja atrybutu zawiera 5 zmiennych, które należy ustawić zgodnie z niektórymi regułami (z wyjątkiem tego, nameże może to być dowolny ciąg). Musisz wydać w sumie dokładnie 15 punktów na swojego bandytę - bandyci, którzy nie wydają wszystkich 15 punktów, nie kwalifikują się. Oto jak działają atrybuty:

• numbOfBullets - określa, ile kul trzyma broń.

  Początkowa i minimalna wartość numbOfBulletsto 1. Każdy dodatkowy pocisk kosztuje 1 punkt, przy czym maksymalna to 16 pocisków z 15 wydanymi punktami.

• reloadSpeed - określa, ile obrotów potrzebuje twój rewolwerowiec, aby przeładować broń, gdy zabraknie mu kul.

  Podstawowa i maksymalna wartość wynosi 4, przy czym minimum wynosi 1. Zmniejszenie tego atrybutu o 1 kosztuje 2 punkty.

• shotsPerTurn - określa, ile razy twój strzelec może strzelać w jednej turze.

  Podstawowa i minimalna wartość to 1. Każdy wzrost o 1 kosztuje 3 punkty, dzięki czemu możesz mieć maksymalnie 6 strzałów na rundę, wydając 15 punktów. Podniesienie powyższego atrybutu przynosi efekt numbOfBulletsprzeciwny do zamierzonego, ponieważ nie można strzelać więcej pocisków niż broń.

• moveSpeed - określa, ile pól twój strzelec może uruchomić w jednej turze.

  Podstawowa i minimalna wartość to 1. Każdy wzrost o 1 kosztuje 3 punkty, maksymalnie 6 prędkości i 15 wydanych punktów. Rewolwerowiec może biec w lewo lub w prawo przy każdym zakręcie do maksymalnej prędkości ruchu. Może także stać w miejscu, co daje mu premię (więcej na ten temat później).

Powyższa przykładowa funkcja ma 6 punktów na pociski, 6 punktów na prędkość przeładowania i 3 punkty na ruch.

Główna funkcja

function main(bulletsLeft, yourShots, enemyShots, yourMovement, enemyMovement) {

    var shots = [];
    shots.push(Math.floor((Math.random() * 24) + 1));
    var move = yourMovement[yourMovement.length - 1] + 2
    var play = [];
    play.shots = shots;
    play.move = move;
    play.reload = false;
    return play;
}

Parametry:

• bulletsLeft, liczba pocisków pozostałych w twoim pistolecie

• yourShots, jest to tablica tablic wszystkich poprzednich pozycji, na których strzelał strzelec.

  Przykład dla rewolwerowca, który może wystrzelić 1 kulę na rundę:

  [[12],[4],[22],...]  
  

  Przykład dla rewolwerowca, który może wystrzelić 3 pociski w rundzie:

  [[12,13,14],[11,15,16],[9,14],...]
  

• enemyShots - tak samo jak powyżej, ale dla twojego wroga

• yourMovement - tablica wszystkich poprzednich pozycji ruchu
• enemyMovement, jak wyżej, ale dla twojego wroga

Co musisz zwrócić:

Musisz zwrócić zmienną, która ma 3 atrybuty:

• shots - tablica liczb określająca, w którą przestrzeń / s strzelać będzie twój strzelec
• move - pojedyncza liczba określająca, na którą przestrzeń twój strzelec będzie próbował się przenieść
• reload - wartość prawda / fałsz, za pomocą której możesz ponownie załadować swojego rewolwerowca

Pojedynek

Zawody odbywają się według systemu robin round 1 versus 1. Każdy rewolwerowiec ma 50 rund przeciwko każdemu rewidentowi. Runda trwa, dopóki ktoś nie zostanie trafiony kulą lub nie upłynie 66 tur (tura następuje, gdy obaj gracze wystrzelili).

Rewolwerowiec może zdobyć 2 punkty, zabijając przeciwnika, 1 punkt, jeśli oboje zginą w tej samej turze lub 0 punktów, jeśli osiągną limit 66 tur. Pole do strzelania ma szerokość 24 pól (1-24 włącznie). Aby trafić gracza i wygrać rundę, musisz strzelać w to samo miejsce, w którym aktualnie stoi.

Oto przewodnik krok po kroku, jak działa pojedynek. Dotyczy to również wszystkich nieprawidłowych poleceń i zasad specjalnych:

• Na początku każdego pojedynku obaj gracze są umieszczani na polu 12, a ich rewolwery są w pełni załadowane
• Wywoływana jest główna funkcja, a napastnik wykonuje polecenie pierwszego ruchu i wybiera miejsce, w którym chce strzelać
• Najpierw bandyci przeprowadzają się do nowej lokalizacji. Jeśli w komendzie ruchu wprowadzono nieprawidłowe dane (pozycje niższe niż 1 lub wyższe niż 24 lub przesunęły się o więcej spacji, wówczas są również dozwolone), pozostają na tej samej pozycji.
• Następne przeładowanie jest sprawdzane, jeśli zabrakło ci pocisków w poprzedniej turze lub sam wezwałeś przeładowanie, twój strzelec przechodzi do cyklu przeładowania. Przeładowuje tyle tur, ile wyznaczysz swoją reloadSpeedwartość. Jeśli zdecydowałeś się stać w miejscu (zwracając tę ​​samą liczbę całkowitą, co na której stoiłeś przed lub po prostu zwracałeś niepoprawną wartość), licznik przeładowania spada na 2 tury zamiast jednej.
• Teraz nadchodzi sprawdzanie twoich wartości strzelania, za każdym razem, kiedy możesz wprowadzić tyle miejsc strzelania, ile chcesz, zawsze zostaną one odcięte do rzeczywistej prawidłowej ilości, która jest określona przez: liczbę strzałów na turę i liczbę pocisków w rewolwerze ( którykolwiek jest niżej). Twoja shotsPerTurnwartość wzrasta o 1, jeśli zdecydujesz się nie ruszać w tej turze, więc możesz wykonać dodatkowy strzał, jeśli zdecydujesz się nie ruszać. Jeśli jesteś w cyklu przeładowania, masz 0 strzałów.

• Teraz nadchodzi faktyczne strzelanie, istnieją 2 sposoby, aby to zejść. Jeśli obaj strzelcy mają tę samą statystykę prędkości ruchu, wówczas strzelają w tym samym czasie i mogą zabić się nawzajem w tym samym czasie. W przypadku, gdy mają różne statystyki prędkości, bot o wyższej prędkości ruchu zaczyna strzelać jako pierwszy, a jeśli zabije przeciwnika, wygrywa w tej rundzie. Jeśli rewolwerowiec może wystrzelić jeden lub więcej pocisków w jednej rundzie, wówczas stosuje się te same zasady, co powyżej, z wyjątkiem większej liczby cykli jako przykładu: Załóżmy, że bot1 ma 3 pociski i jest szybszy, a bot 2 ma 2 pociski, to wyglądałoby to tak: :

  Bot1 shoots, Bot2 shoots cycle 1
  Bot1 shoots, Bot2 shoots cycle 2
  Bot1 shoots              cycle 3
  

To wyglądałoby tak samo, gdyby mieli taką samą prędkość ruchu tylko tyle, że jeśli teraz Bot1 uderzył Bot2 w tym samym cyklu Bot2 mógłby również trafić Bot1 i byłby remis.

ZASADY

Najpierw kopiuję niektóre zasady z wpisu Calvina Hobby'ego, które również obowiązują tutaj.

Deklarując nową zmienną JavaScript, musisz użyć słowa kluczowego var. Wynika to z faktu, że zmienna zadeklarowana bez var staje się globalna, a nie lokalna, więc łatwo byłoby przypadkowo (lub celowo) zepsuć kontroler lub swobodnie komunikować się z innymi graczami. Musi być jasne, że nie próbujesz oszukiwać.

Podczas deklarowania funkcji najlepiej jest również użyć słowa kluczowego var, tzn. Użyj var f = function(...) {...}zamiast tego function f(...) {...}.nie jestem do końca pewien, dlaczego, ale czasem wydaje się, że to robi różnicę.

W swoim kodzie nie możesz ...

• próba dostępu lub modyfikacji kontrolera lub kodu innego gracza.
• próba modyfikacji czegokolwiek wbudowanego w JavaScript.
• tworzyć zapytania internetowe.
• rób inne złośliwe rzeczy.

Moje dodatkowe zasady:

• Użytkownicy mogą utworzyć dowolną liczbę bandytów i zmieniać ich funkcje na dowolny okres czasu
• Usunę każdy wpis z gry, który zajmuje zbyt dużo czasu lub próbuje oszukiwać w dowolny sposób, który uważam za odpowiedni
• Nazwy atrybutów, które funkcja musi zwrócić, muszą być takie same jak w przykładach o tej samej strukturze!

Twoja odpowiedź powinna być w tym formacie, pierwsza funkcja jest funkcją atrybutu, a druga funkcją logiczną. Zauważ, że użyłem wykrzyknika, ponieważ jeśli utworzysz nowe linie między blokami kodu, parser nie zobaczy dwóch różnych bloków kodu, więc musisz użyć dowolnego symbolu (po prostu wykrzyknika), aby je rozdzielić:

var bot = {
    name: "testBot",
    numbOfBullets: 7,
    reloadSpeed: 1,
    shotsPerTurn: 1,
    moveSpeed: 2
}
return bot

var shots = []
var testBot_moveUp = true
if(Math.random() * 2 > 1)
    testBot_moveUp = false
shots.push(Math.floor((Math.random() * 24) + 1))
var move = 0
if (testBot_moveUp)
    move = yourMovement[yourMovement.length - 1] + 2
else
    move = yourMovement[yourMovement.length - 1] - 2
move = 12
var play = []
play.shots = shots
play.move = move
play.reload = false
return play

A oto kontroler: GAME CONTROLLER . Po prostu otwórz link i poczekaj na załadowanie botów, a następnie wybierz, który chcesz w walce (prawdopodobnie wszystkie) i naciśnij przycisk Start.

Podaję również testbota jako moją odpowiedź, która będzie konkurować, służy również jako przykład tego, jak powinna wyglądać struktura odpowiedzi. Uwaga: jeśli popełnisz niewielki błąd i zredagujesz swój algorytm zmiany stosu, może go nie wykryć od razu, a witryna, z której korzysta kontroler wygenerowana przez stackexchange, nie zostanie zaktualizowana (ale zrobi to później lub wprowadzisz większe zmiany, które sugeruję robiąc, po prostu dodaj tekst na końcu). Oto strona: codelink

Pandarus

var bot = {
    name:"Pandarus",
    numbOfBullets: 2,
    reloadSpeed: 3,
    shotsPerTurn: 1,
    moveSpeed: 5
}
return bot

var myPos;
if(yourMovement.length > 0)
{
    myPos = yourMovement[yourMovement.length - 1];
}
else
{
    myPos = 12;

}
var EnemyPos;
if(enemyMovement.length>0) {
    EnemyPos = enemyMovement[enemyMovement.length - 1];
}
else
{
    EnemyPos = 12;
}

var play = {
    shots: [
    ],
    reload: true,
    move: 12
};
if (bulletsLeft < 1)
{
    //Reload
    play.reload = true;
    play.shots = [
    ];
}
else
{
    //FIRE!!!
    play.reload = false;
    var enemyMoveSum = 0;
    for (var i = 0; i < enemyMovement.length; i++)
    {
        var MoveSinceLast;
        if (i == 0)
        {
            MoveSinceLast = enemyMovement[i] - 12;
        }
        else
        {
            MoveSinceLast =enemyMovement[i] - enemyMovement[i-1];
        }

        enemyMoveSum += Math.abs(MoveSinceLast);
    }

    var enemyAvgMove;
    if (enemyMovement.length > 0)
    {
        enemyAvgMove = Math.round(enemyMoveSum / enemyMovement.length);
    }
    else
    {
        enemyAvgMove = 0;
    }

    var LeftShot = EnemyPos - enemyAvgMove;
    var RightShot = EnemyPos + enemyAvgMove;

    if (RightShot > 24 ||( (LeftShot>0) && (Math.random()*2 < 1)))
    {
        play.shots.push(
            LeftShot
        );
    }
    else
    {
        play.shots.push(
            RightShot
        );
    }
}

var MyMove = myPos;
do
{
    var move = Math.floor(Math.random() * 10) - 5;
    if(move == 0)
    {
        move = 5;
    }
    MyMove = myPos + move;
}
while (MyMove<1 || MyMove > 23)

play.move = MyMove;

return play;

Pandarus polega na swojej szybkości, by wydostać się z kul, i wykorzystuje wcześniejsze ruchy wrogów, aby zgadnąć, dokąd zmierzają.

Prosty człowiek

W niczym nie jest idealny, ale we wszystkim całkiem dobry dzięki sile mniej znaczy więcej.

return {
    name: "A Simple Man",
    numbOfBullets: 7,   /* 9 points */
    shotsPerTurn: 2,    /* 3 points */
    reloadSpeed: 4,     /* 0 points */
    moveSpeed: 3        /* 3 points */
}

var lastPos = yourMovement[ yourMovement.length - 1 ],
    lastEnemyPos = enemyMovement[ enemyMovement.length - 1 ],
    lastEnemyMove = enemyMovement.length > 1 ? 
        ( function () {
            var i = 0,
                currentMove,
                minMove = Infinity;
            while ( i < enemyMovement.length ) {
                currentMove = Math.abs( enemyMovement[ enemyMovement.length - 1 ] - enemyMovement[ enemyMovement.length - 2 ] );
                if ( currentMove < minMove ) { minMove = currentMove; }
                return minMove;
            }
        } )()
        : 1,
    needsToReload = bulletsLeft === 0;

return {
    shots: [ yourMovement.length === 1 ? 12 : lastEnemyPos + lastEnemyMove, lastEnemyPos - lastEnemyMove ],
    move: needsToReload ? lastPos : lastPos + Math.floor( Math.random() * 3 + 1 ) * ( ( Math.random() > 0.5 ) ? -1 : 1 ),
    reload: needsToReload
};

var bot = {
    name: "testBot",
    numbOfBullets: 7,
    reloadSpeed: 1,
    shotsPerTurn: 1,
    moveSpeed: 2
}
return bot

var shots = []
var testBot_moveUp = true
if(Math.random() * 3 > 1)
    testBot_moveUp = false
shots.push(Math.floor((Math.random() * 24) + 1))
var move = 0
if (testBot_moveUp)
    move = yourMovement[yourMovement.length - 1] + 2
else
    move = yourMovement[yourMovement.length - 1] - 2
var play = []
play.shots = shots
play.move = move
play.reload = false
return play

Bot testowy, dodany jako test kontrolny. Jeśli ktoś przegra, powinieneś się wstydzić :). Naprawiono zachowanie bota, kopia wkleiła niewłaściwego bota testowego (zawsze pozostawał na polu 12)

var bot = {
    name: "Sniper",
    numbOfBullets: 4,   /* 3 points */
    reloadSpeed: 4,     /* 0 points */
    shotsPerTurn: 1,    /* 0 points */
    moveSpeed: 5        /* 12 points */
};
return bot;

var play = {};
var my_speed = 5;

var gatherStatistics = function(moves) {
    var enemyMoves = [];

    for (var m = 1; m < moves.length; ++m) {
        var diff = moves[m]-moves[m-1];

        var found = false;
        for (var i = 0; i < enemyMoves.length; ++i) {
            if (enemyMoves[i][0] === diff) {
                ++enemyMoves[i][1];
                found = true;
                break;
            }
        }
        if (!found) enemyMoves.push([diff,1]);
    }

    return enemyMoves;
};
var calcOptimalTarget = function(moves, histogram) {
    var enemy_pos = moves[moves.length-1];
    var optimalDiffs = [];
    var optimalScore = 0;

    for (var i = 0; i < histogram.length; ++i) {
        var diff = histogram[i][0];
        var score = histogram[i][1];

        if (score > optimalScore) {
            optimalScore = score;
            optimalDiffs = [diff];
        } else if (score === optimalScore) {
            optimalDiffs.push(diff);
        }
    }

    var chosenDiff = optimalDiffs[Math.floor(Math.random() * optimalDiffs.length)];
    return enemy_pos + chosenDiff;
};

/* Never reload */
play.reloading = false;

/* Run around like a mad man */
var my_pos = yourMovement[yourMovement.length-1];
var rand_sign = 2*Math.floor(2*Math.random())-1;

/* Never run into walls */
if (my_pos <= my_speed+1) {
    rand_sign = 1;
} else if (my_pos >= 24 - my_speed - 1) {
    rand_sign = -1;
}

if (yourMovement.length === 1) { /* Leap out of the way on first move */
    play.move = yourMovement[yourMovement.length-1] + rand_sign*my_speed;
} else {
    play.move = yourMovement[yourMovement.length-1] + rand_sign*((my_speed-1)*Math.floor(2*Math.random()) + 1);
}

/* Shoot all bullets by the end of the game */
var random_shot = (Math.random() > 0.15) ? true : false;

if (enemyMovement[enemyMovement.length-1] === enemyMovement[enemyMovement.length-2]) {
    /* Enemy is standing still; now is our time to STRIKE! */
    play.shots = [ enemyMovement[enemyMovement.length-1] ];
} else if (enemyMovement.length >= 2 && random_shot) {
    /* We take a random shot; best guess by enemies movement */
    var histogram = gatherStatistics(enemyMovement);
    play.shots = [ calcOptimalTarget(enemyMovement, histogram) ];
} else {
    /* No default shooting */
    play.shots = [];
}

return play;

Tkacz

Bardziej zainteresowany pozostaniem przy życiu niż zabijaniem, tka się tam iz powrotem, za każdym razem zwiększając dystans. Wybiera losowe miejsce w zasięgu sprawdzonego wroga, do którego strzela.

var bot = {
    name: "TheWeaver",
    numbOfBullets: 4, // 3 points
    reloadSpeed: 4, // 0 points
    shotsPerTurn: 1, // 0 points
    moveSpeed: 5 // 12 points
}
return bot;

var play = {};
var moveSpeed = 2;

//Guess the enemies speed
var enSpeed = 1; 
var prev = 12;
for(var move in enemyMovement){
    if(Math.abs(move - prev) > enSpeed){
        enSpeed = Math.abs(move - prev);
    }
    prev = move;
}

//Randomly shoot in his range
var enemyPos = 12;
if(enemyMovement.length > 0){
    enemyPos = enemyMovement[enemyMovement.length - 1];
}
var shots = [];

//Shoot somewhere in his range
var distance = Math.random()*enSpeed;
var direction = 1;
if(Math.random() < 0.5){ direction = -1;}
if(enemyPos + enSpeed > 24){ direction = -1;}
if(enemyPos - enSpeed <= 0){ direction = 1;}
shots.push(enemyPos + distance*direction);





var move = 12;

//Start with a dash
if(yourMovement.length == 0){
    move = 12 + moveSpeed - 1;
}
//Quick switch
else if(yourMovement.length == 1){
    move = 11
}
//Wave baby, weave
else{
    var lastPos = yourMovement[yourMovement.length - 1];
    var lastMove = yourMovement[yourMovement.length - 1] - yourMovement[yourMovement.length - 2];
    var distance = Math.abs(lastMove + 1);
    if(distance > moveSpeed) { distance = 0;}
    var direction = lastMove/Math.abs(lastMove)*(-1);
    move = lastPos + distance*direction;
}


//Correct move
if(move > 24){
    move = 24;
}
if(move < 1){
    move = 1;
}

play.move = move;
play.reload = false;
play.shots = shots;



return play;

Alexander Hamilton

Jeśli nie wygra w pierwszej rundzie, prawdopodobnie umrze

var bot = {
    name: "Hamilton",
    numbOfBullets: 7, // 6 pts
    reloadSpeed: 4, // 0 pts
    shotsPerTurn: 4, // 9 pts
    moveSpeed: 1 // 0pts
}
return bot

!

var shots = []
var move = yourMovement[yourMovement.length - 1] + 1
var play = []
play.shots = [12,11,10,13,14,9,15,8,16,7,17,6,18]
play.move = move
play.reload = false
return play

Aaron Burr

var bot = {
    name: "Burr",
    numbOfBullets: 7, // 6 pts
    reloadSpeed: 4, // 0 pts
    shotsPerTurn: 3, // 6 pts
    moveSpeed: 2 // 3pts
}
return bot  

!

var shots = []
var move = yourMovement[yourMovement.length - 1]
// Dodging dance
switch (yourMovement.length % 4) {
  case 1:
    move += 2
    break;
  case 2:
    move -= 1
    break;
  case 3:
    move -= 2
    break;
  case 0:
    move += 1
    break;
}
var play = []
var elast = enemyMovement[enemyMovement.length - 1]
play.shots = [elast + 1, elast -1, elast]
play.move = move
play.reload = false
return play

var bot = {
    name: "Winger",
    numbOfBullets: 7, // 6 points
    reloadSpeed: 4, // 0 points
    shotsPerTurn: 3, // 6 points
    moveSpeed: 2 // 3 points
}
return bot;

var play = {};
var moveSpeed = 2;

//Guess the enemies speed
var enSpeed = 5; // Assume they are fast on the first turn
var prev = 12;
for(var move in enemyMovement){
    if(Math.abs(move - prev) > enSpeed){
        enSpeed = Math.abs(move - prev);
    }
    prev = move;
}


var move = 12;
if(Math.random() < 0.5){ moveSpeed = 1; }
//Move against the enemies shots
if(yourMovement.length == 0 || enemyShots.length == 0){
    move = 12 + moveSpeed;
}
else if(enemyShots.length == 1){
    if(enemyShots[0] <= 12){
        move = yourMovement[yourMovement.length - 1] - moveSpeed;
    }
    else{
        move = yourMovement[yourMovement.length - 1] + moveSpeed;
    }
}
else{
    var dir = enemyShots[enemyShots.length - 1][0] - yourMovement[yourMovement.length - 1];
    if(dir > 0){
        move = yourMovement[yourMovement.length - 1] + moveSpeed;
    }
    else{
        move = yourMovement[yourMovement.length - 1] - moveSpeed;
    }
}

//reload?
var reload = false;
if(bulletsLeft < 3){
    reload=true;
}

var enemyPos = 12;
if(enemyMovement.length > 0){
    enemyPos = enemyMovement[enemyMovement.length - 1];
}
var shots = [];
if(reload == false){
    //Shoot a spread around the opponent
    shots.push(enemyPos);
    if(enemyPos + enSpeed <= 24){ shots.push(enemyPos + enSpeed);}
    if(enemyPos - enSpeed > 0){ shots.push(enemyPos - enSpeed);}

}

//Correct move
if(move > 24){
    move = 24;
}
if(move < 1){
    move = 1;
}
if(reload && (yourMovement[yourMovement.length - 1] - yourMovement[yourMovement.length - 2]) != 0){
    move = yourMovement[yourMovement.length - 1];
}

play.move = move;
play.reload = reload;
play.shots = shots;



return play;

Skrzydłowy strzela zasięgiem ograniczającym zasięg wrogów. On również trochę biegnie w kierunku strzałów wrogów.

Zostawię to tutaj, by przyspieszyć reset.

SMG

Jego broń jest jego osłoną. Niestety zdaje się to blokować jego widok. Jest także dobry w korzystaniu z pozycji stojącej, aby przeładować szybciej i uzyskać dodatkowe strzały.

var bot = {
    name: "SMG",
    numbOfBullets: 12, //11pt
    reloadSpeed: 2,    //4pt
    shotsPerTurn: 1,   //0pt
    moveSpeed: 1       //0pt
}
return bot

var shots = [];
shots.push(Math.floor((Math.random() * 24) + 1));
shots.push(Math.floor((Math.random() * 24) + 1));
var play = [];
if (bulletsLeft < 1) {
play.reload = true;
play.shots = [];
}
play.shots = shots;
play.move = Math.floor((Math.random() * 24) + 1);
play.reload = false;
return play;

var bot = {
    name: "Random Evader",
    numbOfBullets: 7,
    reloadSpeed: 4, 
    shotsPerTurn: 1,
    moveSpeed: 4 
}
return bot

var getSpeed=function(Moves){
    var m = 0;
    for(var i=1;i<Moves.length;i++){
        var d = Math.abs(Moves[i]-Moves[i-1]);
        m = m>d?m:d;
    }
    return m;
}
var validMove=function(moves,speed){
    speed = speed||getSpeed(moves);
    var m;
    do{
        m=moves[moves.length-1]+Math.floor(Math.random()*(speed*2+1)-speed);
    }while(m>25 && m<0);
    return m;
}
var shots = [];
shots.push(validMove(enemyMovement));
var move = validMove(yourMovement,4);
return {
    shots:shots,
    move:move,
    reload:false
};

var bot = {
    name: "Gun and run",
    numbOfBullets: 4,   /* 3 points */
    reloadSpeed: 4,     /* 0 points */
    shotsPerTurn: 3,    /* 6 points */
    moveSpeed: 3        /* 6 points */
};
return bot;

var play = {};
play.reload = false;
if (yourShots.length === 1) { /* Opening move */
    if (Math.random() < 0.5) {
        play.shots = [13,14,15,16];
    } else {
        play.shots = [8,9,10,11];
    }
    play.move = 12;
} else { /* YOLO */
    play.shots = [];
    switch (yourMovement[yourMovement.length - 1]) {
        case 12:
            play.move = 15; 
            break;
        case 15:
            play.move = 18;
            break;
        case 18:
            play.move = 15;
            break;
    }
}
return play;

Diephobus

var bot = {
    name: 'Deiphobus',
    numbOfBullets: 5,
    reloadSpeed: 3,
    shotsPerTurn: 4,
    moveSpeed: 1
};
return bot

var getSorted = function(list)
{
    var modifiedList = [0,0,0,0,0,0,0,0,0,0,0,0,0];
    modifiedList[0] = list[6];
    modifiedList[1] = list[7];
    modifiedList[2] = list[5];
    modifiedList[3] = list[8];
    modifiedList[4] = list[4];
    modifiedList[5] = list[9];
    modifiedList[6] = list[3];
    modifiedList[7] = list[10];
    modifiedList[8] = list[2];
    modifiedList[9] = list[11];
    modifiedList[10] = list[1];
    modifiedList[11] = list[12];
    modifiedList[12] = list[0];

    var messedUpOrder = [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1];
    for(var order = 0; order < 13; order++) {
        var currBest = -2;

        for (var i = 0; i < 13; i++) {
            if ((messedUpOrder.indexOf(i) < 0) && (modifiedList[i] > modifiedList[currBest] || currBest<0)) {

                currBest = i;
            }
        }

        messedUpOrder[order] = currBest;
    }

    var toRet = [0,0,0,0,0,0,0,0,0,0,0,0,0];
    toRet[6] = messedUpOrder[0];
    toRet[7] = messedUpOrder[1];
    toRet[5] = messedUpOrder[2];
    toRet[8] = messedUpOrder[3];
    toRet[4] = messedUpOrder[4];
    toRet[9] = messedUpOrder[5];
    toRet[3] = messedUpOrder[6];
    toRet[10] = messedUpOrder[7];
    toRet[2] = messedUpOrder[8];
    toRet[11] = messedUpOrder[9];
    toRet[1] = messedUpOrder[10];
    toRet[12] = messedUpOrder[11];
    toRet[0] = messedUpOrder[12];

    return toRet;
};
var myPos;
if(yourMovement.length>0) {
   myPos  = yourMovement[yourMovement.length - 1];
}
else{
    myPos = 12;
}
var EnemyPos;
var play = {
    shots: [
    ],
    reload: true,
    move: 12
};
if(enemyMovement.length>0) {
    EnemyPos = enemyMovement[enemyMovement.length - 1];
}
else
{
    EnemyPos = 12;
}
if(bulletsLeft<4)
{
    play.reload = true;
}
else
{
    play.reload = false;
    var enemyChanges = [0,0,0,0,0,0,0,0,0,0,0,0,0];
    for(var i = 0; i<enemyMovement.length; i++)
    {
        var enemyChange;
        if(i == 0)
        {
            enemyChange = enemyMovement[i] - 12;
        }
        else
        {
            enemyChange = enemyMovement[i] - enemyMovement[i-1];
        }

        enemyChanges[enemyChange+6] = enemyChanges[enemyChange+6]+1;
    }

    var orderedEnemyChanges = getSorted(enemyChanges);
    var CurrentShot = 0;
    play.shots = [12,12,12,12];
    for(var i = 0; i<orderedEnemyChanges.length && CurrentShot<4; i++)
    {
        var pos = orderedEnemyChanges[i] + EnemyPos - 6;
        if(pos<24 && pos>0)
        {
            play.shots[CurrentShot] = pos;
            CurrentShot ++;
        }
    }
}
if(myPos == 1)
{
    play.move = 2;
}
else if (myPos == 23)
{
    play.move = 22;
}
else
{
    play.move = myPos + (Math.floor((Math.random() * 3)) %3) - 1;
}
return play;

Diephobus wierzy w bezlitosne oddawanie pocisków wszędzie tam, gdzie myśli, że może być jego wróg, ale jest trochę powolny.

ASCIIGunInTheWest

Wystrzeliwuje 2 strzały w jedną turę i zgaduje, dokąd wróg może się udać na podstawie tego, jak szybko się porusza. Wybacz mi, jeśli są jakieś błędy, nie napisałem dużo kodu w JavaScript.

var bot = {
    name: "ASCIIGunInTheWest",
    numbOfBullets: 4,
    reloadSpeed: 1,
    shotsPerTurn: 2,
    moveSpeed: 2
}
return bot

!

function main(bulletsLeft, yourShots, enemyShots, yourMovement, enemyMovement) {
    var randnum = function (min, max) { return Math.floor( Math.random() * (max - min + 1) ) + min }
    var getDiff = function (num1, num2) { return Math.abs( (num1 > num2) ? num1-num2 : num2-num1 ) }
    var shots = []
    var enemyMaxMovement = 0
    for (index = 0 index < enemyMovement.length ++index) {
    var moveDiff = getDiff(enemyMovement[index], enemyMovement[index - 1])
        if (index != 0 && moveDiff > enemyMaxMovement) {
           enemyMaxMovement = moveDiff
        }
    }
    var enemyCurrentPosition = enemyMovement[enemyMovement.length - 1]
    var enemyMinMoveRange = enemyCurrentPosition - enemyMaxMovement
    var enemyMaxMoveRange = enemyCurrentPosition + enemyMaxMovement
    shots.push( randnum(enemyMinMoveRange, enemyMaxMoveRange) )
    shots.push( randnum(enemyMinMoveRange, enemyMaxMoveRange) )
    var move = yourMovement[yourMovement.length - 1] + randnum(-2, 2)
    var play = []
    play.shots = shots
    play.move = move
    play.reload = false
    return play
}

EDYCJA: Najwyraźniej mojego bota (tylko mojego) nie można używać w JSFiddle. Czy ktoś wie, dlaczego tak jest? Wykorzystuję wszystkie moje punkty dla mojego rewolwerowca, więc nie sądzę, że zostałem zdyskwalifikowany.