Questa è una sfida di King of the Hill in un round robin. È una battaglia per trovare il miglior uomo armato dell'ovest!

Per poter competere in questo concorso è necessario svolgere due funzioni. Il primo imposta gli attributi del tuo uomo armato e il secondo è la principale funzione logica per l'uomo armato.

Funzione di attributo

function () {

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

La funzione di attributo include 5 variabili che dovrai impostare in base ad alcune regole (ad eccezione di nameciò che può essere qualsiasi stringa). Devi spendere un totale di esattamente 15 punti sul tuo pistolero - i pistoleri che non spendono tutti i 15 punti non sono ammissibili. Ecco come funzionano gli attributi:

• numbOfBullets - definisce quanti proiettili contiene la tua pistola.

  Il valore iniziale e minimo di numbOfBulletsè 1. Ogni proiettile aggiuntivo costa 1 punto con un massimo di 16 proiettili con 15 punti spesi.

• reloadSpeed - definisce il numero di giri necessari al tuo uomo armato per ricaricare la pistola dopo aver finito i proiettili.

  Il valore base e massimo è 4 con il minimo pari a 1. Diminuire questo attributo di 1 costa 2 punti.

• shotsPerTurn - definisce quante volte il tuo sicario può sparare in un turno.

  Il valore base e minimo è 1. Ogni aumento di 1 costa 3 punti in modo da poter avere un massimo di 6 colpi per round con 15 punti spesi. Aumentare questo attributo sopra numbOfBulletsè controproducente poiché non puoi sparare più proiettili di quanto la tua pistola possa contenere.

• moveSpeed - definisce quanti spazi il tuo pistolero può percorrere in un turno.

  Il valore base e minimo è 1. Ogni aumento di 1 costa 3 punti con un massimo di 6 velocità con 15 punti spesi. Il pistolero può correre a sinistra oa destra ogni turno fino a un massimo della sua velocità di movimento. Può anche stare fermo, il che gli dà un bonus (ne parleremo più avanti).

La funzione di esempio sopra ha 6 punti spesi per i proiettili, 6 punti per la velocità di ricarica e 3 punti per i movimenti.

Funzione principale

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

parametri:

• bulletsLeft, numero di proiettili rimasti nella pistola

• yourShots, questa è una serie di array di tutte le posizioni passate a cui il tuo sicario ha sparato.

  Esempio per un uomo armato che può sparare 1 proiettile per round:

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

  Esempio per un uomo armato che può sparare 3 proiettili per round:

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

• enemyShots - come sopra ma per il tuo nemico

• yourMovement - una serie di tutte le posizioni di movimento passate
• enemyMovement, come sopra ma per il tuo nemico

Cosa devi restituire:

È necessario restituire una variabile con 3 attributi:

• shots - una serie di numeri che determinano a quale spazio / i il tuo uomo armato sparerà
• move - un singolo numero che determina in quale spazio il tuo uomo armato cercherà di spostarsi
• reload - un valore vero / falso con cui è possibile ricaricare il pistolero

Il duello

Il concorso segue un round robin 1 contro 1 sistema. Ogni uomo armato ha 50 colpi contro ogni altro uomo armato. Un round dura fino a quando qualcuno viene colpito da un proiettile o fino a quando sono passati 66 turni (un turno è quando entrambi i giocatori hanno sparato).

Il pistolero può guadagnare 2 punti uccidendo il suo avversario, 1 punto se entrambi muoiono nello stesso turno o 0 punti se raggiungono il limite di 66 turni. Il campo di tiro ha una larghezza di 24 spazi (1-24 inclusi). Per colpire un giocatore e vincere un round devi sparare nello stesso spazio in cui si trova attualmente.

Ecco una guida passo passo su come funziona un duello. Questo copre anche tutti i comandi non validi e le regole speciali:

• All'inizio di ogni duello entrambi i giocatori vengono messi nello spazio 12 e i loro revolver sono completamente carichi
• Viene chiamata la funzione principale e l'uomo armato fa il primo comando di mossa e sceglie dove vuole sparare
• Prima gli uomini armati si spostano nella loro nuova posizione. Se viene immesso un input non valido al comando di spostamento (posizioni inferiori a 1 o superiori a 24 o spostate di più spazi, allora anche loro sono autorizzati) rimangono nella stessa posizione.
• La ricarica successiva viene verificata, se hai finito i proiettili nel turno precedente o hai chiamato ricaricare te stesso, il tuo uomo armato entra nel ciclo di ricarica. Sta ricaricando per tutti i turni quanti hai impostato il tuo reloadSpeedvalore. Se hai deciso di rimanere fermo (restituendo lo stesso numero intero di spazio in cui ti trovavi prima o semplicemente restituendo un valore non valido) ricarichi il contatore scende per 2 turni invece di uno.
• Ora viene il controllo dei tuoi valori di tiro, ogni turno in cui puoi inserire tutte le posizioni di tiro che desideri verranno sempre tagliati all'importo effettivo effettivo determinato da: Il numero di colpi per turno e il numero di proiettili nel tuo revolver ( qualunque sia inferiore). Il tuo shotsPerTurnvalore aumenta di 1 se decidi di rimanere fermo in questo turno, quindi puoi fare un tiro in più se decidi di rimanere fermo. Se sei nel ciclo di ricarica hai 0 colpi.

• Ora arriva il vero tiro, ci sono 2 modi in cui questo può andare giù. Se entrambi i pistoleri hanno la stessa velocità di mossa, entrambi sparano contemporaneamente e possono entrambi uccidersi contemporaneamente. Nel caso in cui abbiano diverse statistiche di velocità di movimento, il bot con la statistica di velocità di movimento più alta inizia a sparare per primo e se uccide il suo avversario vince questo round. Se il pistolero può sparare uno o più proiettili in un round, segue le stesse regole di cui sopra, tranne in più cicli come un esempio: supponiamo che bot1 abbia 3 proiettili ed sia più veloce e bot 2 abbia 2 proiettili, andrebbe così :

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

Sarebbe lo stesso se avessero la stessa velocità di mossa solo che se adesso Bot1 colpisse Bot2 nello stesso ciclo Bot2 potrebbe anche colpire Bot1 e sarebbe un pareggio.

REGOLE

Innanzitutto sto copiando alcune regole dalla voce di Calvin's Hobbies che si applicano anche qui.

Quando si dichiara una nuova variabile JavaScript, è necessario utilizzare la parola chiave var. Questo perché una variabile dichiarata senza var diventa globale piuttosto che locale, quindi sarebbe facile confondere accidentalmente (o intenzionalmente) con il controller o comunicare liberamente con altri giocatori. Deve essere chiaro che non stai cercando di imbrogliare.

Quando si dichiarano le funzioni è meglio usare anche la parola chiave var, ovvero usare var f = function(...) {...}invece di function f(...) {...}.non sono del tutto sicuro del perché, ma a volte sembra fare la differenza.

Nel tuo codice potresti non ...

• tentare di accedere o modificare il controller o il codice di un altro giocatore.
• tenta di modificare tutto ciò che è incorporato in JavaScript.
• fare query web.
• fare cose altrimenti dannose.

Le mie regole aggiuntive:

• Gli utenti possono creare tutti i pistoleri che desiderano e modificare le loro funzioni per qualsiasi periodo di tempo
• Rimuoverò qualsiasi voce dal gioco che impieghi troppo tempo o cerchi di imbrogliare nel modo che ritengo opportuno
• I nomi degli attributi che la tua funzione deve restituire deve essere la stessa degli esempi con la stessa struttura!

La tua risposta dovrebbe essere in questo formato, la prima funzione è la funzione di attributo e la seconda è la funzione logica. Si noti che ho usato un punto esclamativo perché se si creano solo nuove righe tra blocchi di codice, il parser non vedrà due diversi blocchi di codice, quindi è necessario utilizzare qualsiasi simbolo (basta usare un punto esclamativo) per separarli:

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

Ed ecco il controller: GAME CONTROLLER . Basta aprire il collegamento e attendere il caricamento dei robot, quindi selezionare quello che si desidera nel combattimento (probabilmente tutti) e premere il pulsante di avvio.

Ho anche inserito un testbot come risposta che competerà, serve anche da esempio su come dovrebbe apparire la struttura della risposta. Come nota, se commetti un piccolo errore e modifichi la tua risposta l'algoritmo stackexchanges potrebbe non rilevarlo immediatamente e il sito che il controller utilizza generato da stackexchange non viene aggiornato (ma lo farà più tardi o se apporti modifiche più grandi che suggerisco facendo, basta aggiungere un po 'di testo alla fine). Ecco il sito: codelink

Pandaro

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 si affida alla sua velocità per liberarsi dei proiettili e usa i movimenti precedenti dei nemici per indovinare dove stanno andando.

Un uomo semplice

Non perfetto in niente, ma abbastanza bravo in tutto grazie al potere del meno è di più.

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

Test bot, aggiunto come test di controllo. Se qualcuno perde questo, dovresti vergognarti :). Corretto il comportamento del bot, copia incollata il bot di prova errato (rimaneva sempre sul campo 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;

Il tessitore

Più interessato a rimanere in vita che a uccidere, si muove avanti e indietro, aumentando ogni volta la sua distanza. Prende un punto casuale all'interno del raggio di azione dimostrato dai nemici a cui sparare.

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

Se non vince al primo turno, probabilmente morirà

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;

L'ala lancia una diffusione che limita il raggio d'azione dei nemici. Corre anche verso i colpi dei nemici.

Lascerò questo qui per fare il reset.

SMG

La sua pistola è la sua copertura. Sfortunatamente, sembra bloccare il suo punto di vista. È anche bravo a trarre vantaggio dall'essere fermo per ricaricare più velocemente e ottenere colpi extra.

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 crede in proiettili senza pietà ovunque pensa che il suo nemico possa essere, ma è un po 'lento.

ASCIIGunInTheWest

Spara 2 colpi al turno e indovina dove può andare il nemico in base alla sua velocità. Scusami se ci sono errori, non ho codificato molto in 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
}

EDIT: Apparentemente il mio bot (solo il mio) non può essere utilizzato in JSFiddle. qualcuno sà perche è cosi? Sto usando tutti i miei punti per il mio sicario, quindi non credo di essere stato squalificato.