BomberLua est un projet de jeu dans la lignée de Robocode. Vous ne contrôlez pas directement le personnage, mais vous écrivez un programme (ou plutôt un script) qui se chargera, en fonction des informations auxquelles il a accès sur la zone de jeu, de diriger le personnage et de combattre les autres personnages (dirigés par d'autres scripts).

Le jeu choisi est bomberman, l'intérêt principal étant la zone de jeu particulière (pas un simple terrain vide ou presque vide) : les bombermen doivent trouver leur chemin dans l'aire de jeu, et se frayer un chemin vers ses ennemis. Eviter les bombes n'est pas toujours simple, car il faut calculer une position de repli à chaque fois que l'on pose une bombe où qu'un ennemi pose une bombe.

Il est réalisé en C++, en utilisant SDL, SDL_image et Lua 5.1, par remram44 et Insomniak (merci à acieroid pour la prise en charge du Python).

Actuellement, seuls les scripts en langage Lua et python sont supportés ; le support pour d'autres langages n'est actuellement pas prévu mais peut être ajouté très simplement (merci de contacter remram44 si vous pouvez implémenter un nouveau langage). Lors de son chargement, un bot dispose de 5 secondes pour s'initialiser, qu'il peut mettre à profit pour précalculer certaines données en fonction du terrain de jeu (bien qu'actuellement un seul terrain ne soit disponible). Une fois son initialisation terminée, il doit appeler la fonction ready() (avant que les 5 secondes ne soient écoulées).

Pendant la phase de jeu, les bots ont accès aux fonctions suivantes :

• get_self : cette fonction retourne des informations sur le bomberman dirigé par le bot. Elle retourne une table contenant deux champs : posx et posy, la position du personnage sur le terrain.
• get_bombers : retourne une table de tous les bombermen. Chaque bomberman y est associé à un nombre (qui identifie ce bomberman pendant toute la partie) ; la structure décrivant chaque bomberman est la même que celle retournée par get_self.
• get_field : retourne le terrain, sous la forme d'une table. Les champs w et h indiquent la dimension du terrain de jeu, et à chaque chaîne “x,y” est associée le type de la case, c'est à dire :
  • “rock” : un mur indestructible
  • “brick”: un mur qui peut être détruit par une bombe
  • un nombre : pas de mur, mais une bombe qui explosera dans cette durée (en secondes)
  • “explosion” : pas de mur, mais une explosion
  • “empty” : rien

• wait : permet de ne rien faire ; cette méthode devrait être appelée lorsque le script ne fait rien pour indiquer qu'il n'est pas simplement planté, à cause d'une boucle infinie par exemple.
• move : permet de se déplacer. Prend en paramètre la direction, c'est à dire “left”, “right”, “up” ou “down”.
• bomb : permet de poser une bombe.

Un zip avec les sources et le programme (cross-compilé avec mingw, pas testé…) : http://wiki.nyug.org/~remram44/bomberlua-win.zip

Une archive avec les sources ; vous aurez besoin de lua5.1, SDL et SDL_image pour les compiler : http://wiki.nyug.org/~remram44/bomberlua.tar.gz

La dernière version peut être trouvée sur Subversion : http://svn.nyug.org/bomberlua

Il existe un “launcher” graphique utilisant Qt permettant de lancer le jeu sans avoir à utiliser la ligne de commande. Sinon, vous pouvez utiliser les options ci-dessous :

Les options reconnues par le jeu sont :

  * -i pour l'affichage graphique (oui je sais, lancer sans n'aurait pas vraiment d'intérêt pour le moment)
  * entre 1 et 4 scripts à charger
Exemples :

  * ./bomberlua -i bots/test.lua bots/scripted.lua bots/test.lua # Linux
  * bomberlua.exe -i bots/test.lua bots/scripted.lua bots/test.lua # Windows

Actuellement, je suis en attente de bots fonctionnels pour commencer la compétition Je mettrai sur cette page des exemples de bots quand j'en aurai d'autres.

-- Ce programme a servi à tester les déplacements et les animations pendant le
-- développement du jeu. Il n'a aucun comportement défensif ou offensif, il se
-- déplace simplement sur l'aire de jeu.
-- initialisation : définit des fonctions utiles
function can_go (direction, bomber, map)
    if direction ==  “right” and (map[(bomber.posx + 1) .. ”,” .. bomber.posy] == “empty”) then
        return true
    elseif direction == “up” and (map[bomber.posx ..  ”,” .. (bomber.posy - 1)] == “empty”) then
        return true
    elseif direction == “left” and (map[(bomber.posx - 1) .. ”,” .. bomber.posy] == “empty”) then
        return true
    elseif direction == “down” and (map[bomber.posx .. ”,” .. (bomber.posy + 1)] == “empty”) then
        return true
    else
        return false
    end
end
 
function next_dir(direction, wall)
    if wall == “right” then
        if  direction == “right” then
            return “down”
        elseif direction == “up” then
            return “right”
        elseif direction == “left” then
            return “up”
        elseif direction == “down” then
            return “left”
        else
            return “right”
        end
    elseif wall == “left” then
        if direction == “right” then
            return “up”
        elseif direction == “up” then
            return “left”
        elseif direction == “left” then
            return “down”
        elseif direction == “down” then
            return “right”
        else
            return “right”
        end
    end
end
 
function invert_wall(wall)
    if wall == “right” then
        return “left”
    elseif wall == “left” then
        return “right”
    end
end
 
wall = “left”
 
ready ()
 
-- boucle de jeu
while 1 do
    map = get_field()
    bomber = get_self()
    -- on choisit une direction de telle façon que le bomber suive le mur situé
    -- à sa gauche
    direction = next_dir(direction, invert_wall(wall))
    while not can_go(direction, bomber, map) do
        direction = next_dir(direction, wall)
    end
    -- on va dans la direction choisie
    move (direction)
 
    -- une chance sur 5 de poser une bombe
    if math.random(1, 5) == 1 then
        bomb()
    end
 
    -- on a une chance sur 5 de changer de mur à suivre
    if math.random(1, 5) == 1 then
        wall = invert_wall(wall)
    end
end