Este es un desafío de King of the Hill en un round robin. ¡Es una batalla encontrar al mejor pistolero del oeste!

Para poder competir en este concurso necesitas hacer dos funciones. El primero establece los atributos de su pistolero y el segundo es la función lógica principal para el pistolero.

Función de atributo

function () {

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

La función de atributo incluye 5 variables que deberá establecer de acuerdo con algunas reglas (con la excepción de nameque puede ser cualquier cadena). Debe gastar un total de exactamente 15 puntos en su pistolero; los pistoleros que no gastan los 15 puntos no son elegibles. Así es como funcionan los atributos:

• numbOfBullets - define cuántas balas tiene tu arma.

  El valor inicial y mínimo de numbOfBulletses 1. Cada bala adicional cuesta 1 punto, siendo el máximo 16 balas con 15 puntos gastados.

• reloadSpeed - define cuántos turnos necesita su pistolero para recargar su arma después de que se quede sin balas.

  El valor base y máximo es 4, siendo el mínimo 1. Disminuir este atributo en 1 cuesta 2 puntos.

• shotsPerTurn - define cuántas veces tu pistolero puede disparar en un turno.

  El valor base y mínimo es 1. Cada aumento de 1 cuesta 3 puntos, por lo que puede tener un máximo de 6 disparos por ronda con 15 puntos gastados. Elevar este atributo arriba numbOfBulletses contraproducente ya que no puedes disparar más balas de las que tu arma puede contener.

• moveSpeed - define cuántos espacios puede ejecutar tu pistolero en un turno.

  El valor base y mínimo es 1. Cada aumento en 1 cuesta 3 puntos con un máximo de 6 velocidades con 15 puntos gastados. El pistolero puede correr hacia la izquierda o hacia la derecha cada vuelta hasta un máximo de su velocidad de movimiento. También puede quedarse quieto, lo que le da una bonificación (más sobre esto más adelante).

La función de ejemplo anterior tiene 6 puntos gastados en balas, 6 puntos gastados en velocidad de recarga y 3 puntos gastados en movimiento.

Función 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 que quedan en tu arma

• yourShots, esta es una serie de matrices de todas las posiciones anteriores a las que ha disparado su pistolero.

  Ejemplo para un pistolero que puede disparar 1 bala por ronda:

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

  Ejemplo para un pistolero que puede disparar 3 balas por ronda:

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

• enemyShots - igual que el anterior pero para tu enemigo

• yourMovement - una variedad de todas tus posiciones de movimiento pasadas
• enemyMovement, igual que el anterior pero para tu enemigo

Lo que necesitas devolver:

Debe devolver una variable que tiene 3 atributos:

• shots - una serie de números que determinan en qué espacio / s disparará su pistolero
• move - un número único que determina a qué espacio intentará moverse tu pistolero
• reload - un valor verdadero / falso con el que puedes hacer que tu pistolero vuelva a cargar

El duelo

El concurso sigue un sistema round robin 1 versus 1. Cada pistolero tiene 50 rondas contra cualquier otro pistolero. Una ronda dura hasta que alguien es alcanzado por una bala o hasta que hayan pasado 66 turnos (un turno es cuando ambos jugadores han disparado).

El pistolero puede ganar 2 puntos matando a su oponente, 1 punto si ambos mueren en el mismo turno o 0 puntos si alcanzan el límite de 66 turnos. El campo de tiro es de 24 espacios de ancho (1-24 inclusive). Para golpear a un jugador y ganar una ronda, debes disparar al mismo espacio en el que está parado actualmente.

Aquí hay una guía paso a paso sobre cómo funciona un duelo. Esto también cubre todos los comandos no válidos y reglas especiales:

• Al comienzo de cada duelo, ambos jugadores se colocan en el espacio 12 y sus revólveres están completamente cargados.
• Se llama a la función principal y el pistolero realiza su primer comando de movimiento y elige dónde quiere disparar
• Primero los pistoleros se mudan a su nueva ubicación. Si se realiza una entrada no válida en el comando de movimiento (las posiciones inferiores a 1 o superiores a 24 o movieron más espacios, entonces también se les permite) permanecen en la misma posición.
• La próxima recarga se verifica, si te quedaste sin balas el turno anterior o si llamaste a recargar tu arma, el pistolero entra en el ciclo de recarga. Él está recargando por tantos turnos como establezca su reloadSpeedvalor. Si decidió quedarse quieto (devolviendo el mismo número entero de espacio que estaba parado antes o simplemente devolviendo un valor no válido), el contador de recarga se cae durante 2 turnos en lugar de uno.
• Ahora viene verificando sus valores de disparo, cada turno en el que puede ingresar tantos lugares de disparo como desee siempre se cortará a la cantidad válida real que se determina por: El número de disparos por turno y el número de balas en su revólver ( el que sea más bajo). Su shotsPerTurnvalor aumenta en 1 si decide quedarse quieto este turno, por lo que puede hacer un tiro extra si decide quedarse quieto. Si estás en el ciclo de recarga tienes 0 disparos.

• Ahora viene el tiroteo real, hay 2 formas en que esto puede disminuir. Si ambos pistoleros tienen la misma estadística de velocidad de movimiento, ambos disparan al mismo tiempo y ambos pueden matarse entre sí al mismo tiempo. En el caso de que tengan estadísticas de velocidad de movimiento diferentes, el bot con la estadística de velocidad de movimiento más alta comienza a disparar primero y si mata a su oponente, gana esta ronda. Si el pistolero puede disparar una o más balas en una ronda, entonces sigue las mismas reglas que anteriormente, excepto en más ciclos como ejemplo: Digamos que bot1 tiene 3 balas y es más rápido y bot 2 tiene 2 balas, entonces sería así :

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

Esto se vería igual si tuvieran la misma velocidad de movimiento solo que si ahora Bot1 golpeara a Bot2 en el mismo ciclo, Bot2 también podría golpear a Bot1 y sería un empate.

REGLAS

Primero estoy copiando algunas reglas de la entrada de Calvin's Hobbies que también se aplican aquí.

Al declarar una nueva variable de JavaScript, debe usar la palabra clave var. Esto se debe a que una variable declarada sin var se convierte en global en lugar de local, por lo que sería fácil meterse accidentalmente (o intencionalmente) con el controlador o comunicarse libremente con otros jugadores. Tiene que estar claro que no estás tratando de hacer trampa.

Al declarar funciones, es mejor usar también la palabra clave var, es decir, usar en var f = function(...) {...}lugar de function f(...) {...}.no estoy completamente seguro de por qué, pero a veces parece hacer la diferencia.

En su código no puede ...

• intenta acceder o modificar el controlador u otro código de jugador.
• Intente modificar cualquier cosa integrada en JavaScript.
• hacer consultas web
• hacer cosas maliciosas de otra manera.

Mis reglas adicionales:

• Los usuarios pueden crear tantos hombres armados como quieran y cambiar sus funciones por cualquier período de tiempo
• Eliminaré cualquier entrada del juego que tome una cantidad excesiva de tiempo o intente hacer trampa de la manera que me parezca adecuada.
• ¡Los nombres de los atributos que su función necesita devolver deben ser los mismos que en los ejemplos con la misma estructura!

Su respuesta debe estar en este formato, la primera función es la función de atributo y la segunda es la función lógica. Tenga en cuenta que usé un signo de exclamación porque si solo hace nuevas líneas entre los bloques de código, el analizador no verá dos bloques de código diferentes, por lo que debe usar cualquier símbolo (solo use un signo de exclamación) para separarlos:

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

Y aquí está el controlador: CONTROLADOR DE JUEGO . Simplemente abra el enlace y espere a que se carguen los bots, luego seleccione cuál desea en la pelea (probablemente todos) y presione el botón de inicio.

También puse un testbot como mi respuesta, que competirá, también sirve como un ejemplo de cómo debería ser la estructura de la respuesta. Como nota, si comete un pequeño error y edita su respuesta, es posible que el algoritmo de stackexchanges no lo recupere de inmediato y el sitio que usa el controlador que se genera mediante stackexchange no se actualiza (pero lo hará más tarde o si realiza cambios más grandes, lo que sugiero haciendo, solo agregue algo de texto al final). Aquí está el sitio: 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 confía en su velocidad para salir del camino de las balas, y usa los movimientos previos de los enemigos para adivinar a dónde van a ir.

Un hombre simple

No es perfecto en nada, pero es bastante bueno en todo a través del poder de menos.

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

Prueba de bot, esto se agrega como una prueba de control. Si alguien pierde con esto, debería avergonzarse :). Se corrigió el comportamiento del bot, la copia pegó el bot de prueba incorrecto (siempre permaneció en el 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;

El tejedor

Más preocupado por mantenerse vivo que matar, teje de un lado a otro, aumentando su distancia cada vez. Elige un lugar aleatorio dentro del alcance probado de los enemigos para disparar.

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

Si no gana en la primera ronda, probablemente 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;

Winger dispara una extensión que limita el alcance de los enemigos. También corre hacia los tiros de los enemigos.

Solo voy a dejar esto aquí para presionar el reinicio.

SMG

Su arma es su tapadera. Desafortunadamente, parece bloquear su vista. También es bueno aprovechando quedarse quieto para recargar más rápido y obtener disparos adicionales.

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;

Diefobus

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 cree en las balas disparando sin piedad en todas partes que cree que podría ser su enemigo, pero es un poco lento.

ASCIIGunInTheWest

Dispara 2 disparos por turno y adivina dónde puede ir el enemigo en función de lo rápido que se mueve. Perdóname si hay algún error, no he codificado mucho en 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
}

EDITAR: Aparentemente, mi bot (solo el mío) no se puede usar en JSFiddle. ¿Alguien sabe a que se debe esto? Estoy usando todos mis puntos para mi pistolero, así que no creo que haya sido descalificado.