Seu programa precisa usar uma sequência de linhas múltiplas, assim:

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

pé o jogador e #é um bloco.

Agora abaixo disso, no terminal, deve haver uma linha de entrada dizendo:

How do you want to move?

Se o jogador digitar que lele terá que andar para a esquerda quando não houver um bloco, caso contrário, quando houver um bloco, ele não poderá passar e não se moverá, é claro, agora a saída no terminal deve ser atualizada ( e a saída anterior limpa / substituída):

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

Ele pode digitar lpara esquerda, rpara direita, upara cima e dpara baixo.

A entrada sempre será multilinha, mas nem sempre será preenchida com espaços em um retângulo perfeito. Além disso, os hashes podem estar em qualquer lugar da string e nem sempre serão conectados um ao outro. Por exemplo:

##  ##
#  #
## p
     #

é uma masmorra válida. (observe a falta de espaços à direita em cada linha)

Se o jogador sair da corda, ele não precisa ser exibido. Mas se ele voltar mais tarde, ele deve ser exibido novamente.

E os limites de "fora" da corda são a length(longest_line)pelo number_of_linesretângulo, por isso mesmo se uma linha não é preenchido com espaços à direita, esse local não é considerado fora dos limites. Exemplo usando o calabouço anterior:

##  ##
#  #p
##  
     #

A segunda linha não tinha um espaço onde o p está agora, mas isso não importa.

Finalmente, seu programa deve fazer um loop para sempre, recebendo informações.

Casos de teste

Caso de teste 1:

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

How do you want to move?
d

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

Caso de teste 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  #
####

Claro, estes não estão completos. Seu código deve repetir para sempre e limpar a tela entre cada saída .

Sua saída pode solicitar entrada como How do you want to move?\n<input>ou How do you want to move?<input>( ou seja, você não precisa da entrada em uma linha em branco) e não precisa de uma linha vazia entre a linha final da masmorra e a solicitação. (eles não podem estar na mesma linha)

As brechas padrão não são permitidas! Isso é código-golfe, então o código mais curto em bytes vence!

MATLAB, 268 247 246 bytes

Provavelmente não é competitivo, mas foi divertido. Versão Golfed:

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

Versão legível:

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

Os tryblocos são para impedir que a função falhe em erros fora dos limites. Tenho certeza de que dois deles são um exagero, mas não posso jogar melhor do que isso.

Vale a pena notar que o MATLAB expandirá a matriz para baixo e para a direita, mas o jogador desaparecerá quando se mudar para uma área 'inexplorada' pela primeira vez. Por exemplo, se você sair dos limites atuais da masmorra para a direita em um espaço, desaparecerá, mas no próximo turno o MATLAB expandirá a matriz para incluir a nova coluna (ou linha, se você estiver se movendo para baixo). '#'==d(y,x)economiza um byte comparado a d(y,x)=='#', já que você não precisa de um espaço entre ife'#'

Script de café: 580 bytes

Eu espremi tudo que pude desse algoritmo em particular e do meu cérebro cansado. Eu preciso de ferias.

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'