Caccia all'uovo di Pasqua

Bot trova l'uovo prima che il coniglietto trovi l'uovo. Bot felice.

Panoramica

Questa è una sfida da re delle colline in onore della Pasqua e della tradizione della caccia alle uova di Pasqua!

Il tuo bot ha una visione di due spazi in ogni direzione, comprese le diagonali, creando un quadrato 5x5 attorno a te che puoi vedere. Sta cercando le uova e chi trova più uova vince!

Il bordo

Il tabellone sarà composto da os, che sono uova di Pasqua, #s, che sono muri, *s, che sono altri giocatori, e che sono spazi vuoti.

• Sarà un quadrato con lunghezza del bordo (number of entries) * 3.
• Sarà circondato da mura.
• All'interno delle pareti ci sarà un assortimento di pareti di linea retta disposte in modo casuale #, che avranno una lunghezza casuale compresa tra 2 e 10 inclusi. Ce ne saranno (number of entries) * 3.
• Le uova verranno quindi posizionate in modo casuale. Ce ne saranno (number of entries) * 4, e saranno generati solo su quadrati vuoti ( ).
• Devono esserci almeno 7 indirizzi affinché il processo di generazione della scheda funzioni correttamente.

Ecco un JSFiddle che genererà una scheda casuale con cui testare. Ecco un esempio, con (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#
#                   #
#####################

Dopo che il tabellone è stato generato, ogni giocatore viene posizionato in un quadrato casuale (spazio vuoto).

Ingresso

Prenderai sei righe di input. Le prime cinque linee sono il tuo campo visivo (gli spazi fuori dai limiti della tavola saranno rappresentati da X, e lo spazio medio sarà sempre *tu) e la sesta linea sarà vuota (all'inizio).

Produzione

Verranno emesse tre righe. Innanzitutto, la direzione in cui vuoi spostarti:

1  2  3
8 YOU 4
7  6  5

(9 è una no-op se non vuoi muoverti), secondo, uno di Attack, Counter o Nothing (questo sarà spiegato in profondità presto), e la treccia sarà qualsiasi stringa di lunghezza fino a 1024 Questa sarà la memoria del tuo bot. Puoi usarlo per quello che vuoi, o puoi lasciarlo in bianco. Questa memoria sarà quindi la sesta riga di input per il tuo programma alla prossima esecuzione.

Tutte le ulteriori righe di output vengono ignorate e se esiste solo una riga, si presuppone che la seconda sia vuota.

In movimento

Il seguente processo viene utilizzato per determinare dove ti sei trasferito:

• Se, quando ti sposti, finisci in uno spazio vuoto ( ), il tuo giocatore viene posizionato in quello spazio.
• Se finisci in un muro ( #), la tua mossa viene ignorata e perdi il tuo turno.
• Se finisci in un uovo ( o) o su un giocatore ( *), queste informazioni vengono memorizzate e verranno utilizzate dopo che tutti si sono spostati.

Dopo che tutti si sono mossi, le ambiguità sono state risolte.

Se ci sono due giocatori che sono atterrati nello stesso spazio, si verifica un combattimento! È qui che entra in gioco A/ C/ N. Attack batte Nothing (attacco normale), Nothing batte Counter (non puoi contrastare nulla), e Counter batte Attack (contrattacco). Il giocatore che vince questo combattimento rimane nella propria casella e il giocatore che perde torna nella casella originale da cui ha iniziato. In caso di pareggio, entrambi i giocatori tornano dove erano.

Se un giocatore perdente o in parità ritorna dove si trovava e c'è un altro giocatore lì, non c'è combattimento e anche l'altro giocatore tornerà al suo spazio originale. Se questo spazio ha un altro giocatore, quel giocatore torna indietro e questo continua fino a quando tutti i giocatori si trovano in spazi diversi.

Se ci sono tre o più giocatori su uno spazio, tutti tornano alle loro posizioni originali.

Se qualche giocatore è ancora in piedi su un uovo ...

• Se il giocatore ha scelto A, l'uovo viene distrutto.
• Se il giocatore ha scelto C, non accade nulla e il giocatore ritorna al suo spazio originale.
• Se il giocatore ha scelto N, il giocatore prende l'uovo! Il punteggio del giocatore viene incrementato di uno e l'uovo viene rimosso.

Le lingue

È possibile utilizzare qualsiasi linguaggio liberamente disponibile su Windows, OSX e Linux, per garantire l'equità tra ciascun concorrente. Se il codice non è eseguibile liberamente ma può essere compilato o impacchettato in un formato che sia, si prega di includere anche questo formato nella risposta. Idealmente, se riesci a compilare il tuo codice in un linguaggio più comune (ad es. CoffeeScript -> JavaScript), ti preghiamo di farlo.

punteggio

Il tuo punteggio sarà il numero medio di uova che raccogli su dieci serie. Una corsa termina quando tutte le uova vengono raccolte o quando i (number of entries * 25)turni sono passati. Mi accerterò manualmente che sia possibile raggiungere tutte le uova per ogni mappa (generando continuamente mappe fino a quando tutte le uova sono raggiungibili).

tabellone segnapunti

Verrà aggiunto un quadro di valutazione quando sono soddisfatte tutte le seguenti condizioni:

• Sono state inviate almeno sette voci valide con un punteggio positivo o zero (non declassato)
• Sono passate almeno 48 ore dalla creazione di questa sfida (UTC 14:23)

Le regole non cambieranno durante questo periodo pre-gara, tranne per aggiungere chiarimenti in cui una regola non era chiara. Una volta creato il quadro di valutazione, il programma di test verrà pubblicato anche qui in modo da poter testare le voci. Il codice di test per questo è ancora in fase di elaborazione, ma è riproducibile e funziona. Ecco il repository GitHub.

Cart'o'Gophers

Ecco un altro contributo - e questo in realtà è pensato per essere competitivo. Ancora una volta, è in Ruby. Quindi eseguilo con ruby cartogophers.rb. Ciò ha richiesto molto più tempo del previsto ...

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

Questo bot ricorda ciò che ha visto prima e cerca di costruire una mappa più grande ad ogni turno. Quindi utilizza una prima ricerca dell'uovo più vicino e procede in quel modo. Se non è possibile raggiungere l'uovo sulla mappa corrente, il bot si dirige verso il bordo aperto più vicino della sua mappa (in modo da espandere rapidamente la mappa in una direzione in cui può ancora muoversi).

Questo bot non ha ancora idea di altri robot e nemmeno di una strategia di combattimento. Dal momento che non ho trovato un modo affidabile per determinare se la mia mossa è andata a buon fine, ciò può causare alcuni problemi. Semplicemente presumo sempre che la mossa sia andata a buon fine, quindi se non fossero nuove patch verranno caricate nella mappa in punti errati, il che potrebbe o meno essere dannoso per l'individuazione del percorso.

Il bot utilizza la memoria per memorizzare la mappa e la sua nuova posizione sulla mappa (supponendo che lo spostamento abbia esito positivo). La mappa viene memorizzata senza interruzioni di riga, zippata e codificata in base64 (insieme al numero di righe della mappa, in modo che le interruzioni di riga possano essere reinserite). Questa compressione riduce le dimensioni a circa un terzo della mappa non compressa, quindi con un'ombra di oltre 1000 byte, potrei memorizzare una mappa di circa 3000 celle, che corrisponde all'incirca all'esplorazione completa di una mappa con 18 bot. Finché non ci sono molti posti vicini, non credo di potermi preoccupare di trovare una soluzione per quel caso.

Dopo alcuni test eseguiti su 5 se dumbbot1 naivebot(la mia altra presentazione), ha funzionato davvero male (come 1 o 2 uova) o ha sovraperformato gli altri con un margine considerevole (da 7 a 9 uova). Potrei pensare a una migliore strategia di combattimento e come posso determinare se mi sono effettivamente mosso o meno. Entrambi potrebbero essere in grado di migliorare un po 'il punteggio.

Oh, e se ti stai chiedendo il nome del bot, dovresti leggere The Order of The Stick ( ultimo pannello di questo fumetto ).

EDIT: c'erano alcuni bug nel rilevare i bordi della mappa scoperta. Ora che li ho riparati questo bot ottiene sempre punteggi di circa 205 se dumbbot1 naivebot. È più simile! Se aggiungi $stderr.puts mapora al mio bot, puoi davvero vedere come scopre sistematicamente la mappa e nel frattempo raccoglie tutte le uova. Ho anche deciso di scegliere Ainvece di Nnon calpestare un uovo, per ridurre la probabilità di tornare alla cella originale del bot (che in parte rovina la mappa).

(Non funziona altrettanto bene contro i 6 naivebotsecondi, soprattutto perché è molto probabile che finisca in un "deadlock" con un altro robot quando entrambi vogliono più volte afferrare un uovo e scegliere N. Devo pensarci ... )

Java Bunny

Questo coniglio non ha ancora finito di crescere (ho ancora in programma di apportare modifiche), ma è un punto di partenza per ora. Cerca l'uovo più vicino e va verso di esso. Non esiste (ancora) il rilevamento del muro o il rilevamento dei limiti. Andrà a raccogliere l'uovo su cui atterra, ma per il resto cercherà di aggirarsi e attaccare qualsiasi altra cosa. Se non ci sono uova vicine, inizierà a seguire il coniglietto più vicino. Potrebbero sapere qualcosa che lui non conosce. Altrimenti, sceglierà semplicemente una direzione casuale per camminare. Ed è piuttosto smemorato (nessun uso della variabile di memoria).

Piani per il futuro:

• Prendi decisioni basate su muri / fuori limite
• Scegli percorsi con uno scopo, piuttosto che a caso
• Usa la memoria per determinare la direzione in cui stavo andando prima

Aggiornamento 1 Il mio coniglietto seguirà altri conigli se non vede un uovo. Rifattorizzato anche il codice "trova uovo più vicino" nel suo metodo.

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 (in Ruby)

Ecco un bot molto semplicistico per far rotolare l'uovo (vogliamo colpire rapidamente quei 7 invii, giusto?). Il mio Ruby non è molto idiomatico, quindi questo codice può far rabbrividire i rubyisti nel dolore. Leggi a proprio rischio.

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

Corri con ruby naivebot.rb.

Sto semplicemente codificando alcuni casi, in cui un uovo è visibile e non ostruito da un muro. Non va nemmeno per l'uovo più vicino, ma sceglie la prima mossa che ha senso. Se non viene trovato un tale uovo, il robot fa una mossa casuale. Ignora tutti gli altri giocatori e non attacca o contrattacca mai.

WallFolower

(gioco di parole deliberato) in 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)))

Si sposta su un uovo se c'è un uovo in vista, ma solo se è più vicino a quell'uovo di un altro robot. Se c'è un pareggio in distanza, lo fa comunque. Altrimenti, segue un muro LH (attualmente non ben implementato).

Devo ancora lavorare sul muro, ma lo posterò comunque qui.