Chasse aux oeufs de Pâques

Bot trouver oeuf avant lapin trouver oeuf. Bot heureux.

Aperçu

Il s'agit d'un défi du roi de la colline en l'honneur de Pâques et de la tradition de la chasse aux œufs de Pâques!

Votre bot a une vision de deux espaces dans toutes les directions, y compris des diagonales, créant un carré 5x5 autour de vous que vous pouvez voir. Il recherche des œufs et celui qui en trouve le plus gagne!

Le tableau

Le plateau sera composé de os, qui sont des œufs de Pâques, #s, qui sont des murs, *s, qui sont d'autres joueurs, et s, qui sont des espaces vides.

• Ce sera un carré avec une longueur de bord (number of entries) * 3.
• Il sera entouré de murs.
• À l'intérieur des murs, il y aura un assortiment de murs en ligne droite placés au hasard #, qui auront une longueur aléatoire entre 2 et 10 inclus. Il y en aura (number of entries) * 3.
• Les œufs seront ensuite placés au hasard. Il y en aura (number of entries) * 4, et ils ne seront générés que sur des carrés blancs ( ).
• Il doit y avoir au moins 7 entrées pour que le processus de génération de carte fonctionne correctement.

Voici un JSFiddle qui générera une carte aléatoire pour que vous puissiez tester. Voici un exemple, avec (number of entries) = 7:

#####################
#        o         ##
#    #    o        ##
#    #o    ######  ##
######     #       ##
## o #     #       ##
##  o#   #o#    o o##
##   #o  # # o  #   #
##   # o # #    #   #
##  ##   # #  o #   #
##  #    #  o   # # #
##  # o  #   ## # # #
##  #           # # #
# o #          ## # #
# o oo         ##o  #
#o  ####### oo ##   #
#        #      #   #
#   o o o#          #
#   o ####   o     o#
#                   #
#####################

Une fois le plateau généré, chaque joueur est placé sur une case aléatoire (espace vide).

Contribution

Vous prendrez six lignes d'entrée. Les cinq premières lignes sont votre champ de vision (les espaces hors limites du plateau seront représentés par X, et l'espace du milieu le sera toujours *, vous), et la sixième ligne sera vide (au début).

Production

Vous allez produire trois lignes. Tout d'abord, la direction dans laquelle vous souhaitez vous déplacer:

1  2  3
8 YOU 4
7  6  5

(9 est un no-op si vous ne voulez pas bouger), second, un de Attack, Clounter ou Nothing (cela sera expliqué en profondeur bientôt), et la troisième ligne sera n'importe quelle chaîne de longueur jusqu'à 1024 Ce sera la mémoire de votre bot. Vous pouvez l'utiliser pour tout ce que vous souhaitez, ou vous pouvez le laisser vide. Cette mémoire sera alors la sixième ligne d'entrée de votre programme lors de la prochaine exécution.

Toutes les autres lignes de sortie sont ignorées et s'il n'y a qu'une seule ligne, la seconde est supposée vide.

En mouvement

Le processus suivant est utilisé pour déterminer où vous avez déménagé:

• Si, lorsque vous vous déplacez, vous vous retrouvez dans un espace vide ( ), votre joueur est placé dans cet espace.
• Si vous vous retrouvez dans un mur ( #), votre coup est ignoré et vous perdez votre tour.
• Si vous vous retrouvez dans un œuf ( o) ou sur un joueur ( *), ces informations sont stockées et seront utilisées une fois que tout le monde aura déménagé.

Une fois que tout le monde a déménagé, les ambiguïtés sont résolues.

S'il y a deux joueurs qui ont atterri sur le même espace, un combat se produit! C'est là que le A/ C/ Nentre en jeu. Attack bat thing N(attaque normale), othing Nbeats Counter (vous ne pouvez rien contrer) et Counter beats Attack (contre-attaque). Le joueur qui remporte ce combat reste sur sa case et le joueur qui perd retourne sur la case d'origine sur laquelle il a commencé. En cas d'égalité, les deux joueurs retournent où ils étaient.

Si un joueur perdant ou à égalité retourne là où il était et qu'il y a un autre joueur là-bas, il n'y a pas de combat et l'autre joueur reviendra également à sa case d'origine. Si cet espace a un autre joueur, ce joueur revient en arrière, et cela continue jusqu'à ce que tous les joueurs soient dans des espaces différents.

S'il y a trois joueurs ou plus sur une case, ils retournent tous à leur position d'origine.

Si un joueur est toujours debout sur un œuf ...

• Si le joueur le choisit A, l'œuf est détruit.
• Si le joueur a choisi C, rien ne se passe et le joueur revient à son espace d'origine.
• Si le joueur a choisi N, le joueur ramasse l'œuf! Le score du joueur est incrémenté de un et l'œuf est retiré.

Les langues

Vous pouvez utiliser n'importe quelle langue disponible gratuitement sur Windows, OSX et Linux, pour assurer l'équité entre chaque candidat. Si le code n'est pas librement exécutable mais peut être compilé ou empaqueté dans un format qui est, veuillez également inclure ce format dans votre réponse. Idéalement, si vous pouvez compiler votre code dans un langage plus courant (par exemple CoffeeScript -> JavaScript), veuillez le faire.

Notation

Votre score sera le nombre moyen d'oeufs que vous collectez sur dix courses. Une course se termine lorsque tous les œufs sont collectés ou lorsque les (number of entries * 25)tours sont passés. Je vais m'assurer manuellement qu'il est possible d'atteindre tous les œufs pour chaque carte (en générant continuellement des cartes jusqu'à ce que tous les œufs soient accessibles).

Tableau d'affichage

Un tableau de bord sera ajouté lorsque toutes les conditions suivantes seront remplies:

• Au moins sept entrées valides avec un score positif ou nul (non sous-évalué) ont été soumises
• Au moins 48 heures se sont écoulées depuis la création de ce défi (UTC 14:23)

Les règles ne changeront pas pendant cette période pré-concours, sauf pour ajouter des clarifications là où une règle n'était pas claire. Une fois le tableau de bord mis en place, le programme de test sera également affiché ici afin que vous puissiez tester vos entrées. Le code de test pour cela est toujours en cours, mais il est jouable et cela fonctionne. Voici le dépôt GitHub.

Cart'o'Gophers

Voici une autre soumission - et celle-ci est en fait censée être compétitive. Encore une fois, c'est en Ruby. Alors lancez-le avec ruby cartogophers.rb. Cela a pris beaucoup plus de temps que prévu ...

require 'zlib'
require 'base64'

def encode map, coords
    zipped = Zlib::Deflate.deflate map.join
    encoded = Base64.encode64(zipped).gsub("\n",'')
    "#{coords[:x]}|#{coords[:y]}|#{map.length}|#{encoded}"
end

def decode memory
    memory =~ /^(\d+)[|](\d+)[|](\d+)[|](.*)$/
    coords = {x: $1.to_i, y: $2.to_i}
    n_rows = $3.to_i
    encoded = $4
    decoded = Base64.decode64 encoded
    unzipped = Zlib::Inflate.inflate decoded
    n_cols = unzipped.length / n_rows;
    return unzipped.scan(/.{#{n_cols}}/), coords
end

def update map, fov, coords
    if coords[:x] < 2
        map.map! { |row| '?' << row }
        coords[:x] += 1
    elsif coords[:x] >= map[0].length - 2
        map.map! { |row| row << '?' }
    end

    if coords[:y] < 2
        map.unshift '?' * map[0].length
        coords[:y] += 1
    elsif coords[:y] >= map.length - 2
        map.push '?' * map[0].length
    end

    fov.each_index do |i|
        map[coords[:y]-2+i][coords[:x]-2, 5] = fov[i]
    end

    return map, coords
end

def clean_up map
    map.each do |row|
        row.gsub!('*', ' ')
    end
end

DIRECTIONS = [
    [],
    [-1,-1],
    [ 0,-1],
    [ 1,-1],
    [ 1, 0],
    [ 1, 1],
    [ 0, 1],
    [-1, 1],
    [-1, 0],
    [ 0, 0]
]

def move_to dir, coords
    {
        x: coords[:x] + DIRECTIONS[dir][0],
        y: coords[:y] + DIRECTIONS[dir][1]
    }
end

def get map, coords
    if coords[:x] < 0 || coords[:x] >= map[0].length ||
       coords[:y] < 0 || coords[:y] >= map.length
        return '?'
    end
    map[coords[:y]][coords[:x]]
end

def set map, coords, value
    unless coords[:x] < 0 || coords[:x] >= map[0].length ||
       coords[:y] < 0 || coords[:y] >= map.length
        map[coords[:y]][coords[:x]] = value
    end
    map[coords[:y]][coords[:x]]
end

def scan_surroundings map, coords
    not_checked = [coords]
    checked = []
    cost = { coords => 0 }
    direction = { coords => 9 }
    edges = {}

    while not_checked.length > 0
        current = not_checked.pop

        checked.push current
        (-1..1).each do |i|
            (-1..1).each do |j|
                c = { x: current[:x]+i, y: current[:y]+j }
                unless not_checked.include?(c) || checked.include?(c)
                    if get(map, c) == '#'
                        checked.push c
                    elsif get(map, c) == '?'
                        checked.push c
                        edges[current] = { cost: cost[current], move: direction[current] }
                    else
                        not_checked.unshift c

                        cost[c] = cost[current] + 1
                        if direction[current] == 9 # assign initial direction
                            direction[c] = DIRECTIONS.find_index([i,j])
                        else
                            direction[c] = direction[current]
                        end

                        if get(map, c) == 'o'
                            return direction[c], if cost[c] == 1 then 'N' else 'A' end
                        end

                        edges[c] = { cost: cost[c], move: direction[c] } if c[:x] == 0 || c[:x] == map[0].length - 1 ||
                                                                            c[:y] == 0 || c[:y] == map.length - 1
                    end
                end
            end
        end
    end

    # If no egg has been found return the move to the closest edge
    nearest_edge = edges.keys.sort_by { |c| edges[c][:cost] }.first
    if edges.length > 0
        return edges[nearest_edge][:move], 'A'
    else
        # The entire map has been scanned and no more eggs are left.
        # Wait for the game to end.
        return 9, 'N'
    end
end

input = $<.read.split "\n"
fov = input[0..4]
memory = input[5]

if memory
    map, coords = decode memory
    map, coords = update(map, fov, coords)
else
    map = fov
    coords = {x: 2, y: 2}
end
clean_up map

move, attack = scan_surroundings(map, coords)

memory = encode map, move_to(move, coords)

puts "#{move}
#{attack}
#{memory}"

Ce bot se souvient de ce qu'il a vu auparavant et essaie de construire une carte plus grande à chaque tour. Il utilise ensuite une recherche en premier pour l'œuf le plus proche et se dirige de cette façon. S'il n'y a pas d'oeuf qui peut être atteint sur la carte actuelle, le bot se dirige vers le bord ouvert le plus proche de sa carte (afin d'étendre rapidement la carte dans une direction qu'il peut encore déplacer).

Ce bot n'a pas encore de concept d'autres bots et aucune stratégie de combat non plus. Étant donné que je n'ai pas trouvé de moyen fiable de déterminer si mon déménagement a réussi, cela peut entraîner des problèmes. Je suppose simplement que le déplacement a réussi - donc s'il ne s'agissait pas de nouveaux correctifs, ils seront chargés dans la carte aux mauvais endroits, ce qui peut ou non nuire à la recherche de chemin.

Le bot utilise la mémoire pour stocker la carte et sa nouvelle position sur la carte (en supposant que le déplacement sera réussi). La carte est stockée sans sauts de ligne, zippée et encodée en base64 (avec le nombre de lignes de la carte, afin que les sauts de ligne puissent être réinsérés). Cette compression ramène la taille à environ un tiers de la carte non compressée, donc ayant une teinte supérieure à 1000 octets, je pouvais stocker une carte d'environ 3000 cellules, ce qui correspond à peu près à l'exploration complète d'une carte avec 18 bots. Tant qu'il n'y a pas beaucoup de soumissions, je ne pense pas que je puisse être dérangé pour trouver une solution à ce cas.

Après quelques essais contre 5 dumbbots et 1 naivebot(mon autre soumission), il a très mal fonctionné (comme 1 ou 2 œufs) ou a surperformé les autres d'une marge considérable (7 à 9 œufs). Je pense peut-être à une meilleure stratégie de combat et à la façon dont je peux déterminer si j'ai réellement déménagé ou non. Les deux pourraient peut-être améliorer quelque peu le score.

Oh et si vous vous interrogez sur le nom du bot, vous devriez lire The Order of The Stick ( dernier panneau de cette bande dessinée ).

EDIT: Il y avait quelques bugs avec la détection des bords de la carte découverte. Maintenant que je les ai corrigés, ce bot obtient toujours des scores d'environ 205 dumbbots et 1 naivebot. C'est plus comme ça! Si vous ajoutez $stderr.puts mapà mon bot maintenant, vous pouvez vraiment voir comment il découvre systématiquement la carte et recueille tous les œufs en attendant. J'ai également décidé de choisir Aau lieu de Nne pas monter sur un œuf, pour réduire la probabilité de revenir à la cellule d'origine du bot (ce qui fout en partie la carte).

(Il ne fonctionne pas aussi bien contre 6 naivebots, d'autant plus qu'il est très possible de se retrouver dans une "impasse" avec un autre bot quand ils veulent tous les deux à plusieurs reprises attraper un œuf et choisir N. J'ai besoin d'y penser ... )

Java Bunny

Ce lapin n'a pas encore fini de grandir (j'ai toujours l'intention de faire des changements), mais c'est un point de départ pour le moment. Il cherche l'œuf le plus proche et se dirige vers lui. Il n'y a pas encore de détection de mur ou de détection hors limites. Il ira chercher l'œuf sur lequel il atterrit, mais sinon il essaiera de se frayer un chemin et d'attaquer autre chose. S'il n'y a pas d'œufs à proximité, il commencera à suivre le lapin le plus proche. Ils pourraient savoir quelque chose qu'il ne sait pas. Sinon, il choisira simplement une direction aléatoire pour marcher. Et il est assez oublieux (pas d'utilisation de la variable mémoire).

Plans pour aller de l'avant:

• Prendre des décisions en fonction des murs / hors limites
• Choisissez des chemins avec un but, plutôt qu'au hasard
• Utilisez la mémoire pour déterminer la direction que j'allais avant

Mise à jour 1 Mon lapin suivra d'autres lapins s'il ne voit pas d'oeuf. A également refactorisé le code "trouver l'œuf le plus proche" dans sa propre méthode.

import java.util.*;

public class EasterEggHunt {

    // board chars
    public static final char EGG = 'o';
    public static final char WALL = '#';
    public static final char BUNNY = '*';
    public static final char SPACE = ' ';
    public static final char OUT_OF_BOUNDS = 'X';

    // player moves
    public static final char ATTACK = 'A';
    public static final char COUNTER = 'C';
    public static final char NOTHING = 'N';

    // directions
    public static final int UPPER_LEFT = 1;
    public static final int UP = 2;
    public static final int UPPER_RIGHT = 3;
    public static final int RIGHT = 4;
    public static final int LOWER_RIGHT = 5;
    public static final int DOWN = 6;
    public static final int LOWER_LEFT = 7;
    public static final int LEFT = 8;
    public static final int STAY = 9;


    // the size of the immediate area
    // (I'll be at the center)
    public static final int VISION_RANGE = 5;

    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);

        char[][] immediateArea = new char[VISION_RANGE][VISION_RANGE];

        for (int i = 0; i < VISION_RANGE; ++i) {
            String line = input.nextLine();
            for (int j = 0; j < VISION_RANGE; ++j) {
                immediateArea[i][j] = line.charAt(j);
            }
        }

        String memory = input.nextLine();

        int moveDirection = decideMoveDirection(immediateArea, memory);
        System.out.println(moveDirection);

        char action = decideAction(immediateArea, memory, moveDirection);
        System.out.println(action);

        // change the memory?
        System.out.println(memory);

    }

    private static int decideMoveDirection(char[][] immediateArea, String memory) {

        // if there's a nearby egg, go towards it
        int direction = nearestBoardObject(immediateArea, EGG);

        // if we didn't find an egg, look for a bunny
        // (maybe he knows where to find eggs)
        if (direction == STAY)
            direction = nearestBoardObject(immediateArea, BUNNY);

        // otherwise, pick a random direction and go
        // we want to also have the chance to stop and catch our breath
        if (direction == STAY)
            direction = new Random().nextInt(STAY + 1);

        return direction;
    }

    private static int nearestBoardObject(char[][] immediateArea, char boardObject) {

        // start at the center and go outward (pick a closer target over a farther one)
        int spacesAway = 1;
        int meX = immediateArea.length / 2;
        int meY = immediateArea[meX].length / 2;

        while (spacesAway <= immediateArea.length / 2) {

            // I like to look right, and go clockwise
            if (immediateArea[meX][meY + spacesAway] == boardObject)
                return RIGHT;
            if (immediateArea[meX + spacesAway][meY + spacesAway] == boardObject)
                return LOWER_RIGHT;
            if (immediateArea[meX + spacesAway][meY] == boardObject)
                return DOWN;
            if (immediateArea[meX + spacesAway][meY - spacesAway] == boardObject)
                return LOWER_LEFT;
            if (immediateArea[meX][meY - spacesAway] == boardObject)
                return LEFT;
            if (immediateArea[meX - spacesAway][meY - spacesAway] == boardObject)
                return UPPER_LEFT;
            if (immediateArea[meX - spacesAway][meY] == boardObject)
                return UP;
            if (immediateArea[meX - spacesAway][meY + spacesAway] == boardObject)
                return UPPER_RIGHT;

            ++spacesAway;
        }

        // if the target object isn't in the immediate area, stay put
        return STAY;

    }

    private static char decideAction(char[][] immediateArea, String memory, int moveDirection) {

        char destinationObject = getDestinationObject(immediateArea, moveDirection);

        switch (destinationObject) {

            case EGG:
                // don't break the egg
                return NOTHING;
            default:
                // get really aggressive on everything else
                // other players, walls, doesn't matter
                return ATTACK;

        }

    }

    private static char getDestinationObject(char[][] immediateArea, int moveDirection) {

        // start at my spot (middle of the board) and figure out which direction I'm going
        int targetX = immediateArea.length / 2;
        int targetY = immediateArea[targetX].length / 2;

        switch (moveDirection) {

            case RIGHT:
                ++targetY;
                break;
            case LOWER_RIGHT:
                ++targetX;
                ++targetY;
                break;
            case DOWN:
                ++targetX;
                break;
            case LOWER_LEFT:
                ++targetX;
                --targetY;
                break;
            case LEFT:
                --targetY;
                break;
            case UPPER_LEFT:
                --targetX;
                --targetY;
                break;
            case UP:
                --targetX;
                break;
            case UPPER_RIGHT:
                --targetX;
                ++targetY;
                break;
            // otherwise we aren't moving

        }

        return immediateArea[targetX][targetY];

    }

}

NaiveBot (en Ruby)

Voici un bot très simpliste pour faire rouler les œufs (nous voulons frapper ces 7 soumissions rapidement, non?). Mon Ruby n'est pas très idiomatique, donc ce code peut faire grincer des dents de bons rubis. Lisez à vos risques et périls.

input = $<.read
$data = input.split("\n")

def is_egg x, y
    $data[y+2][x+2] == 'o'
end

def is_wall x, y
    $data[y+2][x+2] == '#'
end

def is_empty x, y
    $data[y+2][x+2] == ' '
end

def is_player x, y
    $data[y+2][x+2] == '*'
end

if (is_egg(-2,-2) || is_egg(-2,-1) || is_egg(-1,-2)) && !is_wall(-1,-1) || is_egg(-1,-1)
    dir = 1
elsif is_egg(0,-2) && !is_wall(0,-1) || is_egg(0,-1)
    dir = 2
elsif (is_egg(2,-2) || is_egg(2,-1) || is_egg(1,-2)) && !is_wall(1,-1) || is_egg(1,-1)
    dir = 3
elsif is_egg(2,0) && !is_wall(1,0) || is_egg(1,0)
    dir = 4
elsif (is_egg(2,2) || is_egg(2,1) || is_egg(1,2)) && !is_wall(1,1) || is_egg(1,1)
    dir = 5
elsif is_egg(0,2) && !is_wall(0,1) || is_egg(0,1)
    dir = 6
elsif (is_egg(-2,2) || is_egg(-2,1) || is_egg(-1,2)) && !is_wall(-1,1) || is_egg(-1,1)
    dir = 7
elsif is_egg(-2,0) && !is_wall(-1,0) || is_egg(-1,0)
    dir = 8
else
    dir = rand(8) + 1
end

attack = 'N'
puts "#{dir}
#{attack}
"

Courez avec ruby naivebot.rb.

Je code simplement en dur quelques cas, où un œuf est visible et non obstrué par un mur. Il ne va même pas pour l'œuf le plus proche, mais choisit le premier mouvement qui a du sens. Si aucun œuf n'est trouvé, le bot fait un mouvement aléatoire. Il ignore tous les autres joueurs et n'attaque ni ne contre.

WallFolower

(jeu de mots délibéré) en Python 3 :

import sys
import random

#functions I will use
dist       = lambda p1,p2: max(abs(p2[1] - p1[1]), abs(p2[0] - p1[0]))
distTo     = lambda p    : dist((2,2), p)
cmp        = lambda x,y  : (x > y) - (x < y)
sgn        = lambda x    : (-1,0,1)[(x>0)+(x>=0)]
move       = lambda p    : (sgn(p[0] - 2), sgn(p[1] - 2))
unmove     = lambda p    : (p[0] * 2 + 2, p[1] * 2 + 2)
outputmove = lambda p    : (1,2,3,8,9,4,7,6,5)[(sgn(p[0] - 2) + 1) + 3*(sgn(p[1]-2) + 1)]
def noeggfinish(move):
    print(outputmove(unmove(move)))
    print('ACN'[random.randint(0, 2)])
    print("1"+move)
    sys.exit(0)

#beginning of main body
view    = [list(l) for l in map(input, ('',)*5)] #5 line input, all at once.
memory  = input() #currently used only as last direction moved in a tuple
eggs    = []
enemies = []
for y in range(5):
    for x in range(5):
        if   view[y][x] == 'o': eggs    += [(x,y)]
        elif view[y][x] == '*': enemies += [(x,y)]

eggs.sort(key = lambda p:distTo(p)) #sort by how close to me they are.

tiedeggs = []
end = 0
for egg in eggs[:]:
    if end:break
    for enemy in enemies:
        exec({
            -1: 'eggs.remove(egg)',
             0: 'tiedeggs += egg',
             1: 'end=1'
        }[cmp(dist(enemy, egg), distTo(egg))])
        if end:break
if eggs:
    print(outputmove(eggs[0]))
    print('N')              #no attack here
    print("0"+move(eggs[0]))
    sys.exit(0)
elif tiedeggs:
    print(outputmove(tiedeggs[0]))
    print('N')              #no attack here
    print("0"+move(tiedeggs[0]))
    sys.exit(0) 
#now there are no eggs worth going for
#do a LH wall follow

lastmove = eval(memory[1:]) #used to resolve ambiguity
if lastmove[0] and lastmove[1]:
    lastmove[random.randint(0,1)] = 0 #disregard diagonal moves
if eval(memory[0]):
    exec("check=view[%n][%n]"%{(0,-1):(0,0),(1,0):(4,0),(0,1):(4,4),(-1,0):(0,4)}[lastmove])
    if check == '#':
        noeggfinish(lastmove)
    else:pass
#currently unimplemented
#move randomly
noeggfinish(tuple([(x,y) for x in [-1,0,1] for y in [-1,0,1] if (x,y) != (0,0)))

Se déplace vers un œuf s'il y a un œuf en vue, mais seulement s'il est plus proche de cet œuf qu'un autre robot. S'il y a égalité dans la distance, ça vaut quand même le coup. Sinon, un mur LH suit-il (pas actuellement bien implémenté).

J'ai encore besoin de travaux sur le mur, mais je posterai tout de même ici.