Il tuo programma deve prendere una stringa a più righe, in questo modo:

#############
#           #
#     p     #
#           #
#############

pè il giocatore ed #è un blocco.

Ora sotto quello nel terminale dovrebbe esserci una linea di input che dice:

How do you want to move?

Se il giocatore digita ldeve camminare a sinistra quando non c'è un blocco, altrimenti, quando c'è un blocco, non può passare e ovviamente non si muove, ora l'output nel terminale deve essere aggiornato ( e l'output precedente cancellato / sovrascritto):

#############
#           #
#    p      #
#           #
#############

Può scrivere la sinistra, ra destra, usu e dgiù.

L'input sarà sempre multilinea, ma non sarà sempre riempito di spazi in un rettangolo perfetto. Inoltre, gli hash possono trovarsi ovunque nella stringa e non saranno sempre collegati tra loro. Per esempio:

##  ##
#  #
## p
     #

è un dungeon valido. (notare la mancanza di spazi finali su ogni riga)

Se il giocatore esce dalla stringa, non deve essere visualizzato. Ma se ritorna più tardi, deve essere visualizzato di nuovo.

E i confini del "fuori" la stringa sono il length(longest_line)dal number_of_linesrettangolo di, quindi, anche se una linea non è riempita con spazi a destra, quella posizione non è considerata fuori dai limiti. Esempio usando il dungeon precedente:

##  ##
#  #p
##  
     #

La seconda riga non aveva uno spazio in cui la p è ora, ma non importa.

Infine, il tuo programma deve eseguire un ciclo continuo per ricevere input.

Casi test

Caso di prova 1:

####
# p#
#
####

How do you want to move?
d

####
#  #
# p
####

Caso di prova 2:

####
  p#
   #
####

How do you want to move?
l

####
 p #
   #
####

How do you want to move?
d

####
   #
 p #
####

How do you want to move?
l

####
   #
p  #
####

How do you want to move?
l

####
   #
   #
####

How do you want to move?
r

####
   #
p  #
####

Certo, questi non sono completi. Il codice dovrebbe essere ripetuto per sempre e cancellare lo schermo tra ogni output .

L'output è autorizzato a richiedere input come How do you want to move?\n<input>oHow do you want to move?<input> (ovvero non è necessario l'input su una riga vuota) e non è necessaria una riga vuota tra l'ultima riga del dungeon e il prompt. (comunque non possono essere sulla stessa linea)

Le scappatoie standard non sono ammesse! Questo è code-golf, quindi vince il codice più corto in byte!

MATLAB, 268 247 246 byte

Probabilmente non competitivo, ma è stato divertente. Versione golfizzata:

function f(s);d=char(split(s,'\n'));[y,x]=ind2sub(size(d),find(d=='p'));while 1;d
c=uint8(input('How do you want to move?','s'))-100;v=y+~c-(c==17);w=x+(c==14)-(c==8);try;d(y,x)=' ';end;try;if'#'==d(v,w);v=y;w=x;end;d(v,w)='p';end;y=v;x=w;clc;end

Versione leggibile:

function f(s)
% Split the string on newlines and convert to a padded char array
d = char(split(s,'\n'));

% Get the initial indices of p
[y,x] = ind2sub(size(d),find(d=='p'));

% Loop forever
while 1
    % Implicitly display the dungeon
    d

    % Get the ASCII of the user input, minus 100 (saves a few bytes in
    % the comparisons)
    c=uint8(input('How do you want to move?','s'))-100;

    % Get the new y from the ASCII
    v = y+~c-(c==17);

    % Get the new x from the ASCII
    w = x+(c==14)-(c==8);

    % Clear the player from the dungeon if they are in it
    try
        d(y,x)=' ';
    end

    % Check if new position is a #, and revert to old position if so
    try
        if '#'==d(v,w)
            v=y;w=x;
        end
        d(v,w)='p';
    end
    % Update x and y
    y=v;
    x=w;

    % Clear the screen
    clc;
end

I tryblocchi servono a prevenire l'arresto anomalo della funzione in caso di errori fuori limite. Sono sicuro che due di loro sono eccessivi, ma non posso giocarci meglio.

Vale la pena notare che MATLAB espande l'array verso il basso e verso destra, ma il giocatore scompare quando si sposta in un'area "inesplorata" per la prima volta. Ad esempio, se ti sposti al di fuori degli attuali confini del sotterraneo a destra di uno spazio, sparirai, ma il turno successivo MATLAB espanderà l'array per includere la nuova colonna (o riga, se ti stai muovendo verso il basso). '#'==d(y,x)salva un byte rispetto a d(y,x)=='#', poiché non è necessario uno spazio tra ife'#'

Script per caffè: 580 byte

Ho spremuto tutto ciò che potevo da questo particolare algoritmo e dal mio cervello stanco. Ho bisogno di una vacanza.

C=console
e='length'
N=null
f=(S)->
    x=y=X=Y=N
    q=(c,v)->
        X=[x+c,N][+(-1<x+c<w)]
        Y=[y+v,N][+(-1<y+v<h)]
        try L[y+v][x+c]!='#'catch
            1
    r=(s)->
        if (X||Y)
            return
        L[y]=((t=L[y].split '')[x]=s)
        L[y]=t.join ''
    while 1
        L=S.split '\n'
        [h,w]=[L[e],L[0][e]]
        x=[X,x][+(x?)]
        y=[Y,y][+(y?)]
        for k in[0..h*w-1]
            if L[k//h][k%w]=='p'
                x=k%w
                y=k//h
        C.clear()
        C.log S
        r(' ')
        switch prompt("How do you want to move?")
            when'l'
                q(-1,0)&&x--
            when'r'
                q(1,0)&&x++
            when'u'
                q(0,-1)&&y--
            when'd'
                q(0,1)&&y++
        r('p')
        S=L.join '\n'