Il s'agit d'un défi King of the Hill dans un tournoi à la ronde. C'est une bataille pour trouver le meilleur tireur de l'ouest!

Pour pouvoir participer à ce concours, vous devez créer deux fonctions. Le premier définit les attributs de votre tireur et le second est la fonction logique principale du tireur.

Fonction d'attribut

function () {

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

La fonction d'attribut comprend 5 variables que vous devrez définir selon certaines règles (à l'exception de namen'importe quelle chaîne). Vous devez dépenser au total exactement 15 points pour votre tireur - les tireurs qui ne dépensent pas les 15 points ne sont pas éligibles. Voici comment fonctionnent les attributs:

• numbOfBullets - définit le nombre de balles que contient votre arme.

  La valeur initiale et minimale numbOfBulletsest de 1. Chaque balle supplémentaire coûte 1 point avec un maximum de 16 balles avec 15 points dépensés.

• reloadSpeed - définit le nombre de tours dont votre tireur a besoin pour recharger son arme après avoir manqué de balles.

  La valeur de base et maximale est 4, le minimum étant 1. La diminution de 1 de cet attribut coûte 2 points.

• shotsPerTurn - définit combien de fois votre tireur peut tirer en un tour.

  La valeur de base et minimale est de 1. Chaque augmentation de 1 coûte 3 points, vous pouvez donc avoir un maximum de 6 tirs par tour avec 15 points dépensés. Augmenter cet attribut ci numbOfBullets- dessus est contre-productif car vous ne pouvez pas tirer plus de balles que votre arme peut tenir.

• moveSpeed - définit le nombre d'espaces que votre tireur peut parcourir en un tour.

  La valeur de base et minimale est 1. Chaque augmentation de 1 coûte 3 points avec un maximum de 6 vitesses avec 15 points dépensés. Le tireur peut courir à gauche ou à droite à chaque tour jusqu'à un maximum de sa vitesse de déplacement. Il peut également rester immobile, ce qui lui donne un bonus (plus à ce sujet plus tard).

L'exemple de fonction ci-dessus a 6 points dépensés en balles, 6 points dépensés en vitesse de rechargement et 3 points dépensés en mouvement.

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

Paramètres:

• bulletsLeft, nombre de balles laissées dans votre arme

• yourShots, il s'agit d'un tableau de tableaux de toutes les positions passées sur lesquelles votre tireur a tiré.

  Exemple pour un tireur qui peut tirer 1 balle par round:

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

  Exemple pour un tireur qui peut tirer 3 balles par round:

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

• enemyShots - comme ci-dessus mais pour votre ennemi

• yourMovement - un tableau de toutes vos positions de mouvement passées
• enemyMovement, comme ci-dessus mais pour votre ennemi

Ce que vous devez retourner:

Vous devez renvoyer une variable qui a 3 attributs:

• shots - une série de nombres qui déterminent à quel (s) espace (s) votre tireur tirera
• move - un numéro unique qui détermine dans quel espace votre tireur tentera de se déplacer
• reload - une valeur vraie / fausse avec laquelle vous pouvez faire recharger votre tireur

Le duel

Le concours suit un tournoi à la ronde 1 contre 1. Chaque tireur a 50 rounds contre tous les autres tireurs. Un tour dure jusqu'à ce que quelqu'un soit touché par une balle ou jusqu'à ce que 66 tours se soient écoulés (un tour est lorsque les deux joueurs ont tiré).

Le tireur peut gagner 2 points en tuant son adversaire, 1 point s'ils meurent tous les deux au même tour ou 0 point s'ils atteignent la limite de 66 tours. Le champ de tir est de 24 espaces de largeur (1-24 inclus). Pour frapper un joueur et gagner une manche, vous devez tirer sur le même espace que celui où il se trouve actuellement.

Voici un guide étape par étape sur le fonctionnement d'un duel. Cela couvre également toutes les commandes non valides et les règles spéciales:

• Au début de chaque duel, les deux joueurs sont placés sur l'espace 12 et leurs revolvers sont complètement chargés
• La fonction principale est appelée et le tireur fait sa première commande de mouvement et choisit où il veut tirer
• Les hommes armés se déplacent d'abord vers leur nouvel emplacement. Si une entrée non valide est effectuée à la commande de déplacement (positions inférieures à 1 ou supérieures à 24 ou si elles ont déplacé plus d'espaces, elles sont également autorisées), elles restent à la même position.
• Le prochain rechargement est vérifié, si vous avez manqué de balles le tour précédent ou que vous avez appelé vous recharger, votre tireur entre dans le cycle de rechargement. Il recharge pendant autant de tours que vous définissez votre reloadSpeedvaleur. Si vous avez décidé de rester immobile (en retournant le même entier d'espace que celui où vous étiez avant ou en renvoyant simplement une valeur non valide), le compteur de rechargement descend pendant 2 tours au lieu d'un.
• Maintenant, vérifiez vos valeurs de tir, chaque tour, vous pouvez entrer autant de lieux de tir que vous le souhaitez, ils seront toujours coupés à la quantité réelle valide qui est déterminée par: Le nombre de coups par tour et le nombre de balles dans votre revolver ( celui qui est le plus bas). Votre shotsPerTurnvaleur est augmentée de 1 si vous décidez de rester immobile ce tour-ci, vous pouvez donc effectuer un tir supplémentaire si vous décidez de rester immobile. Si vous êtes dans le cycle de rechargement, vous avez 0 coups.

• Vient maintenant la prise de vue réelle, il y a 2 façons dont cela peut descendre. Si les deux tireurs ont la même statistique de vitesse, ils tirent tous les deux en même temps et peuvent tous les deux s'entretuer en même temps. Dans le cas où ils ont des statistiques de vitesse de déplacement différentes, le bot avec la stat de vitesse de déplacement la plus élevée commence à tirer en premier et s'il tue son adversaire, il gagne ce tour. Si le tireur peut tirer une ou plusieurs balles en un tour, il suit les mêmes règles que ci-dessus, sauf dans plusieurs cycles à titre d'exemple: disons que le bot1 a 3 balles et est plus rapide et que le bot 2 a 2 balles, alors cela se passerait comme ceci :

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

Cela aurait la même apparence s'ils avaient la même vitesse de déplacement que si maintenant Bot1 frappait Bot2 dans le même cycle, Bot2 pouvait également toucher Bot1 et ce serait une égalité.

RÈGLES

Je copie d'abord certaines règles de l'entrée de Calvin's Hobbies qui s'appliquent également ici.

Lors de la déclaration d'une nouvelle variable JavaScript, vous devez utiliser le mot clé var. En effet, une variable déclarée sans var devient globale plutôt que locale, il serait donc facile de jouer accidentellement (ou intentionnellement) avec le contrôleur ou de communiquer librement avec d'autres joueurs. Il doit être clair que vous n'essayez pas de tricher.

Lors de la déclaration de fonctions, il est préférable d'utiliser également le mot-clé var, c'est-à-dire d'utiliser var f = function(...) {...}au lieu de function f(...) {...}.je ne sais pas vraiment pourquoi, mais parfois cela semble faire une différence.

Dans votre code, vous ne pouvez pas ...

• tenter d'accéder ou de modifier le contrôleur ou le code d'un autre joueur.
• tenter de modifier quoi que ce soit intégré à JavaScript.
• faire des requêtes Web.
• faire des choses autrement malveillantes.

Mes règles supplémentaires:

• Les utilisateurs peuvent créer autant de tireurs qu'ils le souhaitent et modifier leurs fonctions à tout moment
• Je supprimerai toute entrée du jeu qui prend trop de temps ou essaie de tricher de la manière que je juge appropriée
• Les noms des attributs que votre fonction doit retourner doivent être les mêmes que dans les exemples avec la même structure!

Votre réponse doit être dans ce format, la première fonction étant la fonction attribut et la seconde étant la fonction logique. Notez que j'ai utilisé un point d'exclamation parce que si vous créez simplement de nouvelles lignes entre les blocs de code, l'analyseur ne verra pas deux blocs de code différents, vous devez donc utiliser n'importe quel symbole (utilisez simplement un point d'exclamation) pour les séparer:

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

Et voici le contrôleur: GAME CONTROLLER . Ouvrez simplement le lien et attendez que les robots se chargent, puis sélectionnez celui que vous voulez dans le combat (probablement tous) et appuyez sur le bouton de démarrage.

J'ai également mis un testbot comme réponse qui concourra, il sert également d'exemple sur la façon dont la structure de la réponse devrait ressembler. Remarque: si vous faites une petite erreur et modifiez votre réponse, l'algorithme stackexchanges peut ne pas le récupérer tout de suite et le site que le contrôleur utilise qui est généré par stackexchange n'est pas mis à jour (mais le fera plus tard ou si vous apportez des modifications plus importantes que je suggère) faire, ajoutez simplement du texte à la fin). Voici le 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 se fie à sa vitesse pour sortir du chemin des balles et utilise les mouvements précédents de l'ennemi pour deviner où ils vont aller.

Un homme simple

Pas parfait à quoi que ce soit, mais assez bon à tout grâce à la puissance de moins, c'est plus.

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, ceci ajouté comme test de contrôle. Si quelqu'un y perd, vous devriez avoir honte :). Correction du comportement du bot, copie collée du mauvais bot de test (il est toujours resté sur le champ 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;

The Weaver

Plus soucieux de rester en vie que de tuer, il tisse d'avant en arrière, augmentant chaque fois sa distance. Choisit un endroit aléatoire dans la portée éprouvée des ennemis pour tirer.

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

S'il ne gagne pas au premier tour, mourra probablement

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'ailier tire une propagation qui limite la portée des ennemis. Il court également vers les tirs ennemis.

Je vais juste laisser ça ici pour pousser la réinitialisation.

SMG

Son arme est sa couverture. Malheureusement, cela semble bloquer sa vue. Il est également bon à profiter de l'immobilité pour recharger plus rapidement et obtenir des coups supplémentaires.

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 croit en tirant sans pitié des balles partout où il pense que son ennemi pourrait être, mais il est un peu lent.

ASCIIGunInTheWest

Tire 2 coups par tour et devine où l'ennemi peut aller en fonction de la vitesse à laquelle il se déplace. Pardonnez-moi s'il y a des erreurs, je n'ai pas beaucoup codé 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
}

EDIT: Apparemment, mon bot (juste le mien) ne peut pas être utilisé dans JSFiddle. Quelqu'un sait pourquoi c'est comme cela? J'utilise tous mes points pour mon tireur, donc je ne pense pas avoir été disqualifié.