Este é um desafio do Rei da Colina em um round robin. É uma batalha para encontrar o melhor atirador do oeste!

Para poder competir neste concurso, você precisa fazer duas funções. O primeiro define os atributos do seu atirador e o segundo é a principal função lógica do atirador.

Função de Atributo

function () {

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

A função de atributo inclui 5 variáveis ​​que você precisará definir de acordo com algumas regras (com a exceção de nameque pode haver qualquer sequência). Você deve gastar exatamente 15 pontos no seu atirador - homens que não gastam todos os 15 pontos não são elegíveis. Aqui está como os atributos funcionam:

• numbOfBullets - define quantas balas sua arma contém.

  O valor inicial e mínimo de numbOfBulletsé 1. Cada marcador adicional custa 1 ponto, com no máximo 16 marcadores com 15 pontos gastos.

• reloadSpeed - define quantas voltas o pistoleiro precisa para recarregar a arma depois que ele ficou sem balas.

  O valor base e máximo é 4, sendo o mínimo 1. Diminuir esse atributo em 1 custa 2 pontos.

• shotsPerTurn - define quantas vezes seu atirador pode atirar em um turno.

  O valor base e mínimo é 1. Cada aumento de 1 custa 3 pontos, para que você possa ter no máximo 6 tiros por rodada com 15 pontos gastos. Aumentar esse atributo acima numbOfBulletsé contraproducente, já que você não pode disparar mais balas, então sua arma pode aguentar.

• moveSpeed - define quantos espaços seu atirador pode executar em um turno.

  O valor base e mínimo é 1. Cada aumento de 1 custa 3 pontos, com um máximo de 6 velocidades, com 15 pontos gastos. O atirador pode correr tanto para a esquerda quanto para a direita a cada turno, até o máximo de sua velocidade de movimento. Ele também pode ficar parado, o que lhe dá um bônus (mais sobre isso mais tarde).

A função de exemplo acima tem 6 pontos gastos em marcadores, 6 pontos gastos em velocidade de recarga e 3 pontos gastos em movimento.

Função principal

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

Parâmetros:

• bulletsLeft, número de balas restantes na sua arma

• yourShots, essa é uma variedade de matrizes de todas as posições anteriores em que seu atirador disparou.

  Exemplo para um atirador que pode disparar 1 bala por rodada:

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

  Exemplo para um atirador que pode disparar 3 tiros por rodada:

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

• enemyShots - o mesmo que acima, mas para o seu inimigo

• yourMovement - uma matriz de todas as suas posições de movimento anteriores
• enemyMovement, o mesmo que acima, mas para o seu inimigo

O que você precisa retornar:

Você é obrigado a retornar uma variável que possui 3 atributos:

• shots - uma série de números que determinam em que espaço seu atirador disparará
• move - um número único que determina para que espaço o atirador tentará se mover para
• reload - um valor verdadeiro / falso com o qual você pode recarregar o atirador

O duelo

O concurso segue um round robin 1 versus 1 sistema. Cada atirador tem 50 tiros contra todos os outros atiradores. Uma rodada dura até que alguém seja atingido por uma bala ou até 66 turnos terem passado (uma vez é quando os dois jogadores disparam).

O atirador pode ganhar 2 pontos matando seu oponente, 1 ponto se ambos morrerem no mesmo turno ou 0 pontos se atingirem o limite de 66 turnos. O campo de disparo tem 24 espaços de largura (1-24 inclusive). Para acertar um jogador e vencer uma rodada, você precisa atirar no mesmo espaço em que ele está atualmente.

Aqui está um guia passo a passo sobre como funciona um duelo. Isso também abrange todos os comandos inválidos e regras especiais:

• No início de cada duelo, ambos os jogadores são colocados no espaço 12 e seus revólveres estão totalmente carregados
• A função principal é chamada e o atirador faz seu primeiro comando de movimento e escolhe onde quer atirar.
• Primeiro os pistoleiros se mudam para seu novo local. Se qualquer entrada inválida for feita no comando mover (posições inferiores a 1 ou superior a 24 ou moverem mais espaços, também serão permitidas) elas permanecerão na mesma posição.
• A próxima recarga é marcada, se você ficou sem balas no turno anterior ou se chamou de recarregar a si próprio, seu atirador entra no ciclo de recarga. Ele está recarregando por quantas vezes você definir seu reloadSpeedvalor. Se você decidiu ficar parado (retornando o mesmo número inteiro de espaço em que estava antes ou apenas retornando um valor inválido), o contador de recarga diminui por 2 turnos em vez de um.
• Agora vem a verificação dos seus valores de tiro, a cada turno, você pode inserir quantos locais de tiro quiser, sempre serão cortados para a quantidade válida real que é determinada por: O número de tiros por turno e o número de balas no seu revólver ( o que for mais baixo). Seu shotsPerTurnvalor é aumentado em 1 se você decidir ficar parado neste turno, para poder fazer um arremesso extra se decidir ficar parado. Se você estiver no ciclo de recarga, terá 0 disparos.

• Agora vem o tiroteio real, existem duas maneiras pelas quais isso pode acontecer. Se ambos os pistoleiros tiverem o mesmo status de velocidade de movimento, ambos atirarão ao mesmo tempo e poderão se matar ao mesmo tempo. No caso de terem estatísticas de velocidade de movimento diferentes, o bot com a estatística de velocidade de movimento mais alta começa a atirar primeiro e se ele matar seu oponente, ele vence esta rodada. Se o atirador puder disparar uma ou mais balas em uma rodada, seguirá as mesmas regras acima, exceto em mais ciclos como um exemplo: Digamos que o bot1 tenha 3 marcadores e seja mais rápido e o bot 2 tenha 2 marcadores, seria assim :

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

Isso teria a mesma aparência se eles tivessem a mesma velocidade de movimento apenas que se agora o Bot1 atingisse o Bot2 no mesmo ciclo, o Bot2 também atingisse o Bot1 e seria um empate.

REGRAS

Primeiro, copio algumas regras da entrada de Calvin's Hobbies que também se aplicam aqui.

Ao declarar uma nova variável JavaScript, você deve usar a palavra-chave var. Isso ocorre porque uma variável declarada sem var se torna global em vez de local, portanto, seria fácil mexer acidentalmente (ou intencionalmente) com o controlador ou se comunicar livremente com outros jogadores. Tem que ficar claro que você não está tentando trapacear.

Ao declarar funções, é melhor usar também a palavra-chave var, ou seja, usar em var f = function(...) {...}vez de function f(...) {...}.não sei ao certo por que, mas às vezes parece fazer a diferença.

No seu código, você não pode ...

• tente acessar ou modificar o controlador ou o código de outro jogador.
• tente modificar qualquer coisa incorporada no JavaScript.
• faça consultas na web.
• faça coisas maliciosas.

Minhas regras adicionais:

• Os usuários podem criar quantos pistoleiros quiserem e mudar suas funções por qualquer período de tempo
• Vou remover qualquer entrada do jogo que demore muito ou tente trapacear da maneira que achar melhor
• Os nomes dos atributos que sua função precisa retornar devem ser os mesmos dos exemplos com a mesma estrutura!

Sua resposta deve estar neste formato, a primeira função sendo a função de atributo e a segunda sendo a função lógica. Observe que eu usei um ponto de exclamação porque, se você apenas criar novas linhas entre os blocos de código, o analisador não verá dois blocos de código diferentes; portanto, você precisará usar qualquer símbolo (basta usar um ponto de exclamação) para separá-los:

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

E aqui está o controlador: GAME CONTROLLER . Basta abrir o link e aguardar o carregamento dos bots, selecionar o que você deseja na luta (provavelmente todos) e pressionar o botão Iniciar.

Eu também coloquei um testbot como minha resposta que competirá, mas também serve como um exemplo de como deve ser a estrutura da resposta. Como observação, se você cometer um pequeno erro e editar sua resposta, o algoritmo stackexchanges poderá não pegá-lo imediatamente e o site que o controlador usa, gerado pelo stackexchange, não será atualizado (mas será mais tarde ou se você fizer alterações maiores, sugiro apenas adicione algum texto no final). Aqui está o site: 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 confia em sua velocidade para sair do caminho das balas e usa os movimentos anteriores dos inimigos para adivinhar onde eles estão indo.

Um homem simples

Não é perfeito em nada, mas muito bom em tudo através do poder de menos é mais.

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 de teste, adicionado como teste de controle. Se alguém perder com isso, você deve ter vergonha :). Corrigido o comportamento do bot, a cópia colava o bot de teste errado (ele sempre ficava no 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;

O tecelão

Mais preocupado em permanecer vivo do que matar, ele tece para frente e para trás, aumentando sua distância a cada vez. Escolhe um ponto aleatório dentro do alcance comprovado do inimigo para atirar.

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 ele não vencer na primeira rodada, provavelmente morrerá

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;

Extremo dispara um spread que limita o alcance do inimigo. Ele também corre para os tiros do inimigo.

Só vou deixar isso aqui para pressionar o reset.

SMG

A arma dele é o disfarce. Infelizmente, parece bloquear sua visão. Ele também é bom em tirar proveito de ficar parado para recarregar mais rápido e obter fotos extras.

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 acredita em balas impiedosas em todos os lugares que ele acha que seu inimigo possa estar, mas ele é um pouco lento.

ASCIIGunInTheWest

Dispara 2 tiros por turno e adivinha onde o inimigo pode ir com base na velocidade com que ele se move. Perdoe-me se houver algum erro, não codifiquei muito em 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
}

Edição: Aparentemente, o meu bot (apenas o meu) não pode ser usado no JSFiddle. Alguém sabe por que isso é? Estou usando todos os meus pontos para o meu atirador, então não acho que fui desclassificado.