Set de construcción de mazmorras

19

Cuando era niño, jugué al juego Intellivision Advanced Dungeons and Dragons: Treasure of Tarmin . Los gráficos en 3-D lo colocan en un punto de vista en primera persona con un realismo impactante:

Gráficos en 3D sorprendentemente realistas

Pero luego obtuve un C-64. Y pude dibujar en la cuadrícula de 40x25 caracteres al pasar el cursor por la pantalla, establecer el color con la tecla Ctrl y un dígito, y poner símbolos en cualquier lugar que quisiera (¿por qué no me bashdejas hacer eso?) . El conjunto de caracteres tenía componentes triangulares y componentes de bloque sólido. Así que pude razonar cómo se puede generar una representación de la perspectiva de uno en una cuadrícula a través de ese medio.

Encontré la especificación de casi tres décadas de antigüedad, en papel de cuaderno encuadernado en espiral, sobre "Dungeon Construction Set" esta semana:

ingrese la descripción de la imagen aquí

( ACTUALIZACIÓN : los lectores cuidadosos notarán que esto no se mantiene bien en las partes inclinadas. Los números corregidos se proporcionan a continuación).

Aunque Treasure of Tarmin se jugó en una cuadrícula, las paredes solo existían en los bordes de los cuadrados de la cuadrícula. Después de saber qué bytes eran, me di cuenta de que si hacía el mapa con bytes ... entonces cada cuadrado en el mapa podría tener cuatro estados posibles para cada uno de sus bordes:

  1. Sin obstáculos
  2. pared
  3. Puerta
  4. ¿Algo más?

Nunca pude escribirlo (hasta anoche). Pensé que sería divertido para otros intentarlo.

Entonces, su tarea es implementar un renderizador de laberintos basado en modo de personaje que implemente mi (¡corregido!) Especificación ... pero usando las tecnologías de 2013.

Entrada

Debido a que la especificación no define el renderizado para puertas, asumiremos que las únicas opciones son wall-and-not-wall. Para simplificar, su entrada es un mapa compuesto por líneas de cadenas que se ven así:

WN.. .N.. .N.. .N.. .N.E
W... .... .... ..S. ...E
W... .N.E W... .N.. ...E
W... .... .... .... ...E
W.S. ..S. ..S. ..S. ..SE

Eso sería un mapa de 5x5. La esquina superior izquierda (1,1) tiene su conjunto de pared West y North. La esquina inferior derecha (5,5) tiene su conjunto de pared Sexterior y exterior E.

Esto es considerablemente menos divertido sin navegación por el mapa. Entonces, como mínimo, coloque su jugador en (1,1) hacia el norte y ofrézcales:

[F]orward, [B]ackward, turn [L]eft, turn [R]ight or [Q]uit?

En cada paso, imprima una pantalla de 16x15 de la perspectiva en primera persona, tal como se define en las especificaciones del papel del cuaderno. Para evitar que tenga que contar, el tamaño de las paredes planas en las tres distancias son:

14x13  (directly in front of you; e.g. wall is in same cell)
8x7    (one step away)
6x5    (two steps away)

Los tamaños límite de las paredes inclinadas son:

1x15   (your direct left or right; e.g. wall is in same cell)
3x13   (one step away)
1x7    (two steps away)

Aclaraciones

  • Las celdas adyacentes pueden estar en desacuerdo sobre las paredes compartidas. Por lo tanto, el borde sur de un cuadrado podría ser una pared, mientras que el borde norte de la plaza al sur no estaría obstruido. En el diseño original, consideraba esto como una característica: permite ideas interesantes como puertas unidireccionales ... o paredes invisibles que solo aparecen después de pasar por ellas. Para esta simplificación, siga la misma regla: para la navegación y el renderizado, preste atención solo al estado del borde en la celda más cercana a usted en la dirección que está mirando .

  • La vista es mucho mejor con "sombreado". Entonces, para sus bloques completos, alterne Unicode 2593 ▓ y 2591 °, o use Xy +si su implementación es ASCII.

  • Los caracteres de triángulo Unicode (25E2 ◢, 25E3 ◣, 25E4 ◤, 25E5 ◥) son un poco aburridos para dibujar esto. Además de no tener variantes sombreadas, a menudo estiran solo el ancho del carácter y no la altura completa ... incluso en fuentes de ancho fijo. Puede dibujar bloques completos o caracteres de barra diagonal o algo de su elección en los lugares que quería diagonales. Se aprecian soluciones creativas interesantes que incorporan color y usan estos caracteres en lugar de sombrear.

  • Puede suponer que las paredes más externas están configuradas para delimitar el área de juego, por lo que no tiene que preocuparse por renderizar nada fuera del laberinto. Cualquier muro más alejado de ti que la especificación se ignora y simplemente deja un espacio vacío.

  • El sombreado de la pared que ve directamente frente a usted si mira hacia el norte en (1,1) debe ser OSCURO. Sombreado alternativo en las paredes adyacentes en el mapa, de modo que si todas las paredes estuvieran presentes, una pared clara nunca colindaría con una pared oscura.

  • Una implementación C-64 que realmente hace lo que originalmente pretendía ... con los caracteres diagonales y todo ... prevalecerá sobre cualquier otro criterio de entrada. :-)

Ejemplos

Para el mapa de muestra dado anteriormente ...

En (1,3) hacia el sur:

               /
              /+
             /X+
            /XX+
           /XXX+
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
           \XXX+
            \XX+
             \X+
              \+
               \

En (3,2) hacia el sur:

                      /* blank line */        
X             /
X            /+
X           /++
X           +++
X           +++
X           +++
X           +++
X           +++
X           +++
X           +++
X           \++
X            \+
X             \
                      /* blank line */

En (3,2) hacia el este:

                      /* blank line */        
              / 
             /X 
            /XX 
            XXX 
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
            XXX 
            \XX 
             \X 
              \ 
                      /* blank line */        

En (2,3) hacia el norte:

               /
 ++++++++++++++X
 ++++++++++++++X
 ++++++++++++++X
 ++++++++++++++X
X++++++++++++++X
X++++++++++++++X
X++++++++++++++X
X++++++++++++++X
X++++++++++++++X
 ++++++++++++++X
 ++++++++++++++X
 ++++++++++++++X
 ++++++++++++++X
               \
Dr. Rebmu
fuente
1
Sugiero hacer de esto un desafío de código : un golf sería demasiado ilegible y difícil: P
Pomo de la puerta
1
@Pomo de puerta No dejes que te engañe ... en realidad no es tan difícil. Hay una pista bastante buena con las listas de 3 tamaños delimitadores. ¿Y qué es un golf sino un desafío que se resuelve y luego se reduce? :-) Pero dejaré que las personas elijan cómo quieren resolverlo ... NP
Dr. Rebmu
¿Podría explicar las dos columnas de Xs en su vista 3, 2hacia el sur?
jazzpi
Especialmente el del lado derecho. Ya veo por qué está el izquierdo. Pero el correcto parece violar la Aclaración # 1.
jazzpi
@jazzpi Vaya, tienes razón, ¡el mapa que coloqué debe obedecer a la aclaración 1! Bien hecho. Fijo. (Aparentemente pondría el muro sur perdido en mi propia versión en algún momento ... pero es bueno tener un caso de prueba en la muestra ... ¡así que dejemos el muro sur afuera!)
Dr. Rebmu

Respuestas:

10

Commodore 64 Basic

Hombre, eso fue divertido. Y duro. C64 Basic es casi no borrable, ni siquiera puede usar la printdepuración porque la pantalla ya está ocupada para representar la mazmorra. Sabes que te estás divirtiendo cuando escribes código como 55250 goto 55110. Dijkstra me matará.

El programa usa dos colores y caracteres diagonales.

No hace falta decir que no jugué golf. Dice desafío de código ahora, después de todo. Son 7183 bytes si estás interesado.

Es lento: a la velocidad predeterminada, tarda varios segundos en reproducir la escena. El tamaño máximo del mapa es de 10 por 10, pero se puede cambiar editando la línea 120.

Desarrollé y probé esto usando el emulador VICE . El siguiente código se muestra en ASCII, por lo que significa PETSCII desplazado . Sin embargo, al ingresar el mapa, debe usar PETSCII sin desplazar .

Captura de pantalla: Captura de pantalla

Código:

10 rem c64 dungeon construction set.
20 rem enter using lowercase mode
99 rem DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
100 rem initialisation
110 poke 53272,21
115 poke 53280,0
120 dim m%(10,10)
121 dim di$(3),wa$(1),ma%(2,2)
122 di$(0)="north"
123 di$(1)="east "
124 di$(2)="south"
125 di$(3)="west "
126 wa$(1)="-wall"
127 wa$(0)="     "

130 x=0:y=0:di=0:xs=0:ys=0:wa=0
134 rem read map
135 print "input map"
140 l$="":input l$
150 if len(l$)=0 goto 250
160 cz=0
170 for i=1 to len(l$)
180   c$=mid$(l$,i,1)
190   if c$="n" then cz=cz or 8
200   if c$="e" then cz=cz or 4
205   if c$="s" then cz=cz or 2
210   if c$="w" then cz=cz or 1
215   if c$=" " then m%(x,y)=cz:cz=0:x=x+1
220   if x>=xs then xs=x
225 next
230 m%(x,y)=cz:x=0:y=y+1
240 goto 140
250 rem come from 150
260 print chr$(147)
265 ys=y:xs=xs+1
270 x=0:y=0

500 rem loop
510 gosub 1000: rem status
515 gosub 2000: rem render
520 gosub 55000: rem input
530 goto 500

1000 rem display current (x,y) value
1010 sx=5
1020 sy=17
1030 sl$="    "
1035 sw=14
1040 gosub 63900
1050 cz=m%(x,y)
1060 sx=5:sl$=".":if cz and 8 then sl$="n"
1065 gosub 63900
1070 sx=6:sl$=".":if cz and 4 then sl$="e"
1075 gosub 63900
1080 sx=7:sl$=".":if cz and 2 then sl$="s"
1085 gosub 63900
1090 sx=8:sl$=".":if cz and 1 then sl$="w"
1095 gosub 63900
1100 return

2000 rem render dungeon
2010 rem DDDDDDDDDDDDDD
2020 rem clear area
2030 sw=14:sz=32
2040 for sy=0 to 15
2050   for sx=0 to 16
2060      gosub 63950
2070   next
2080 next
2090 rem find cells / reorient sw
2100 rem store in ma% - we're at (0,1)
2110 sx=x:sy=y
2113 co=di+x+y and 1
2115 for ty=0 to 2
2120    gosub 59800:rem left/right sx/sy
2125    ma%(1,ty)=0
2126    if sx>=0 and sy>=0 and sx<xs and sy<ys then ma%(1,ty)=m%(sx,sy)
2130    ma%(0,ty)=rl
2140    ma%(2,ty)=rr
2150    gosub 59900:rem advance
2160 next
2170 rem draw back walls
2180 sa=ma%(1,2):gosub 59700
2190 if rf=0 goto 2245
2195 sw=14-11*co:sz=160
2200 for sy=5 to 9
2210    for sx=5 to 10
2220       gosub 63950
2230    next
2240 next
2245 sw=3:if co=1 then sw=14
2250 for de=0 to 2 step 2 
2260    sa=ma%(de,2):gosub 59700
2270    if rf=0 goto 2350
2280    for sx=de*5.5 to 4+de*5.5
2290       for sy=5 to 9
2300          gosub 63950
2310       next
2340    next 
2350 next
2360 rem 1,2 left wall
2370 sa=ma%(1,2):gosub 59700
2380 if rl=0 goto 2430
2390 sx=4:sz=160
2400 for sy=5 to 9:gosub 63950:next
2410 sy=4:sz=223:gosub 63950
2420 sy=10:sz=105:gosub 63950
2430 rem 1,2 right wall
2440 if rr=0 goto 2490
2450 sx=11:sz=160
2460 for sy=5 to 9:gosub 63950:next
2470 sy=4:sz=233:gosub 63950
2480 sy=10:sz=95:gosub 63950
2490 rem 1,1 back wall
2500 sa=ma%(1,1):gosub 59700
2510 sz=160
2520 sw=14:if co=1 then sw=3
2520 if rf=0 goto 2580
2530 for sy=4 to 10
2540    for sx=4 to 11
2550       gosub 63950
2560    next
2570 next
2580 rem (0-2),1 back walls
2590 sw=14:if co=1 then sw=3
2600 for de=0 to 2 step 2
2610    sa=ma%(de,1):gosub 59700
2620    if rf=0 goto 2680
2630    for sx=de*6 to 3+de*6
2640       for sy=4 to 10
2650          gosub 63950
2660       next
2670    next
2680 next 
2690 rem 1,1 left side wall
2700 sw=14:if co=1 then sw=3
2710 sa=ma%(1,1):gosub 59700
2720 if rl=0 goto 2760
2730 for sx=1 to 3
2735   sy=sx:sz=223:gosub 63950
2736   sy=14-sx:sz=105:gosub 63950
2737   sz=160
2740   for sy=1+sx to 13-sx:gosub 63950:next
2750 next
2760 rem 1,1 right side wall
2770 if rr=0 goto 2850
2780 for qx=1 to 3
2790   sx=15-qx
2800   sy=qx:sz=233:gosub 63950
2810   sy=14-qx:sz=95:gosub 63950
2820   sz=160
2830   for sy=1+qx to 13-qx:gosub 63950:next
2840 next
2850 rem 0,1 back wall
2860 sa=ma%(1,0):gosub 59700
2870 if rf=0 goto 2930
2880 for sy=1 to 13
2890   for sx=1 to 14
2900     gosub 63950
2910   next
2920 next
2930 rem (0,2)-0 back walls
2940 sw=3:if co=1 then sw=14
2950 for de=0 to 2 step 2
2960   sa=ma%(de,0):gosub 59700
2970   if rf=0 goto 3000
2980   sx=de*7.5
2990   for sy=1 to 13:gosub 63950:next
3000 next
3010 rem (1,0) left side wall
3020 sa=ma%(1,0):gosub 59700
3030 if rl=0 goto 3080
3040 sx=0:sy=0:sz=223:gosub 63950
3050 sy=14:sz=105:gosub 63950
3060 sz=160
3070 for sy=1 to 13:gosub 63950:next
3080 rem (1,0) right side wall
3085 if rr=0 goto 3130
3090 sx=15:sy=0:sz=233:gosub 63950
3100 sy=14:sz=95:gosub 63950
3110 sz=160
3120 for sy=1 to 13:gosub 63950:next
3130 rem done
3140 return

55000 rem ask for prompt & handle input
55010 sx=0:sy=20:gosub 63850
55013 print "at";x+1;y+1;"going ";di$(di);" size";xs;ys;wa$(wa)
55020 print "{f}rwd {b}kwd {l}eft {r}ight {q}uit"
55030 input c$
55040 if c$="q" goto 63999
55050 if c$="f" then dm=1:goto 55100
55060 if c$="b" then dm=-1:goto 55100
55070 if c$="l" then di=(di-1)and 3
55080 if c$="r" then di=(di+1)and 3
55090 return
55100 goto 55200:rem check walls
55110 if di=0 then y=y-dm
55120 if di=1 then x=x+dm
55130 if di=2 then y=y+dm
55140 if di=3 then x=x-dm
55145 wa=0
55146 if y>=ys then y=0
55147 if y<0   then y=ys-1
55148 if x>=xs then x=0
55149 if x<0   then x=xs-1
55150 return
55200 rem check walls
55205 cz=m%(x,y)
55207 if dm=-1 goto 55280
55210 if (di=0) and (cz and 8) goto 55260
55220 if (di=1) and (cz and 4) goto 55260
55230 if (di=2) and (cz and 2) goto 55260
55240 if (di=3) and (cz and 1) goto 55260
55250 goto 55110
55260 wa=1
55270 return : rem wall in the way
55280 rem backward
55290 if (di=2) and (cz and 8) goto 55260
55300 if (di=3) and (cz and 4) goto 55260
55310 if (di=0) and (cz and 2) goto 55260
55320 if (di=1) and (cz and 1) goto 55260
55330 goto 55110

59700 rem return front/back/left/right
59710 rem given sa and d
59720 sn=0:if sa and 8 then sn=1
59725 se=0:if sa and 4 then se=1
59730 ss=0:if sa and 2 then ss=1
59735 zw=0:if sa and 1 then zw=1
59740 if di=0 then rf=sn:rr=se:rb=ss:rl=zw
59745 if di=1 then rf=se:rr=ss:rb=zw:rl=sn
59750 if di=2 then rf=ss:rr=zw:rb=sn:rl=se
59755 if di=3 then rf=zw:rr=sn:rb=se:rl=ss
59760 return

59800 rem return left/right from sx/sy/d
59810 if di=0 then ly=sy:ry=sy:lx=sx-1:rx=sx+1
59820 if di=1 then lx=sx:rx=sx:ly=sy-1:ry=sy+1
59830 if di=2 then ly=sy:ry=sy:lx=sx+1:rx=sx-1
59840 if di=3 then lx=sx:rx=sx:ly=sy+1:ry=sy-1
59850 rl=0:rr=0
59860 if lx<0 or lx>=xs or ly<0 or ly>=ys goto 59880
59870 rl=m%(lx,ly)
59880 if rx<0 or rx>=xs or ry<0 or ry>=ys goto 59895
59890 rr=m%(rx,ry)
59895 return

59900 rem step forward
59910 if di=0 then sy=sy-1:rem N
59920 if di=1 then sx=sx+1:rem E
59930 if di=2 then sy=sy+1:rem S
59940 if di=3 then sx=sx-1:rem W
59950 return

63850 rem set cursor position
63851 rem sx=x sy=y
63860 poke 781,sy
63870 poke 782,sx
63880 poke 783,0
63890 sys 65520
63895 return

63900 rem write str to screen
63901 rem sl$ = string
63910 gosub 63850
63920 print sl$;
63930 return

63950 rem write chr to screen
63951 rem sx = x coordinate
63952 rem sy = y coordinate
63953 rem sz = character code
63954 rem sw = color
63950 sv=sx+sy*40
63960 poke 1024+sv,sz
63970 poke 55296+sv,sw
63980 return

63998 rem quit program
63999 print chr$(147):end

Imagen de la cinta: descargue aquí .

Los ejemplos:

ejemplos

marinus
fuente
1
DIOS MIO. Si otros quieren resolver esto por el gusto de hacerlo, genial ... pero has ganado la recompensa por definición de la carta de triunfo en el desafío. Tuve la tentación de sacar un emulador y hacerlo por razones de nostalgia, pero pensé que era más productivo escribirlo en rojo para ver qué tan bien podía aguantar el compilador. fuente de eso . Lo recompensaré y lo publicaré en algún momento ... ¡pero la recompensa es tuya! Gran aplauso.
Dr. Rebmu
1
Además, RE: Dijkstra, tiene una cita divertida sobre la inmortalidad : "Quiero decir, si dentro de 10 años, cuando estás haciendo algo rápido y sucio, de repente te imaginas que estoy mirando por encima de tus hombros y te dices a ti mismo 'Dijkstra lo haría no me ha gustado esto ', bueno, eso sería suficiente inmortalidad para mí ". ¡Entonces supongo que consiguió su deseo! :-)
Dr. Rebmu
@ Dr.Rebmu: gracias por la recompensa! Esto me tomó literalmente todo el día para escribir :)
marinus
10

(¿Por qué no me bashdejas hacer eso?)

Solo tenía que hacerlo ahora.

Bash, 12743 caracteres

#!/bin/bash
IFS=
declare -a term
typeset -i term[0] term[1]
IFS=' ' read -a term <<< `stty size`
front[0]='\e[2;2H██████████████
\e[3;2H██████████████
\e[4;2H██████████████
\e[5;2H██████████████
\e[6;2H██████████████
\e[7;2H██████████████
\e[8;2H██████████████
\e[9;2H██████████████
\e[10;2H██████████████
\e[11;2H██████████████
\e[12;2H██████████████
\e[13;2H██████████████
\e[14;2H██████████████'
front[1]='\e[5;5H████████
\e[6;5H████████
\e[7;5H████████
\e[8;5H████████
\e[9;5H████████
\e[10;5H████████
\e[11;5H████████'
front[2]='\e[6;6H██████
\e[7;6H██████
\e[8;6H██████
\e[9;6H██████
\e[10;6H██████'
lfront[0]='\e[2;1H█
\e[3;1H█
\e[4;1H█
\e[5;1H█
\e[6;1H█
\e[7;1H█
\e[8;1H█
\e[9;1H█
\e[10;1H█
\e[11;1H█
\e[12;1H█
\e[13;1H█
\e[14;1H█'
lfront[1]='\e[5;1H████
\e[6;1H████
\e[7;1H████
\e[8;1H████
\e[9;1H████
\e[10;1H████
\e[11;1H████'
lfront[2]='\e[6;1H█████
\e[7;1H█████
\e[8;1H█████
\e[9;1H█████
\e[10;1H█████'
rfront[0]='\e[2;16H█
\e[3;16H█
\e[4;16H█
\e[5;16H█
\e[6;16H█
\e[7;16H█
\e[8;16H█
\e[9;16H█
\e[10;16H█
\e[11;16H█
\e[12;16H█
\e[13;16H█
\e[14;16H█'
rfront[1]='\e[5;13H████
\e[6;13H████
\e[7;13H████
\e[8;13H████
\e[9;13H████
\e[10;13H████
\e[11;13H████'
rfront[2]='\e[6;12H█████
\e[7;12H█████
\e[8;12H█████
\e[9;12H█████
\e[10;12H█████'
left[0]='\e[1;1H▙
\e[2;1H█
\e[3;1H█
\e[4;1H█
\e[5;1H█
\e[6;1H█
\e[7;1H█
\e[8;1H█
\e[9;1H█
\e[10;1H█
\e[11;1H█
\e[12;1H█
\e[13;1H█
\e[14;1H█
\e[15;1H▛'
left[1]='\e[2;2H▙
\e[3;2H█▙
\e[4;2H██▙
\e[5;2H███
\e[6;2H███
\e[7;2H███
\e[8;2H███
\e[9;2H███
\e[10;2H███
\e[11;2H███
\e[12;2H██▛
\e[13;2H█▛
\e[14;2H▛'
left[2]='\e[5;5H▙
\e[6;5H█
\e[7;5H█
\e[8;5H█
\e[9;5H█
\e[10;5H█
\e[11;5H▛'
right[0]='\e[1;16H▟
\e[2;16H█
\e[3;16H█
\e[4;16H█
\e[5;16H█
\e[6;16H█
\e[7;16H█
\e[8;16H█
\e[9;16H█
\e[10;16H█
\e[11;16H█
\e[12;16H█
\e[13;16H█
\e[14;16H█
\e[15;16H▜'
right[1]='\e[2;13H  ▟
\e[3;13H ▟█
\e[4;13H▟██
\e[5;13H███
\e[6;13H███
\e[7;13H███
\e[8;13H███
\e[9;13H███
\e[10;13H███
\e[11;13H███
\e[12;13H▜██
\e[13;13H ▜█
\e[14;13H  ▜'
right[2]='\e[5;12H▟
\e[6;12H█
\e[7;12H█
\e[8;12H█
\e[9;12H█
\e[10;12H█
\e[11;12H▜'

echo -e "\e[2J"

# Read map
typeset -i cout
cout=0
echo "Please input your map!"
echo "Please input the next row (or leave it blank if you're finished!)"
read input

declare -A map

typeset -i xlen ylen
ylen=0

until [ -z $input ]
do
    IFS=' ' read -a inputmap <<< "$input"
    xlen=${#inputmap[*]}
    let ylen++
    for index in "${!inputmap[@]}"
    do
        typeset -i map[$index,$cout]
        map[$index,$cout]=0
        el=${inputmap[index]}
        if [[ $el == W??? ]]
        then
            let "map[$index,$cout]|=1"
        fi
        if [[ $el == ?N?? ]]
        then
            let "map[$index,$cout]|=2"
        fi
        if [[ $el == ??S? ]]
        then
            let "map[$index,$cout]|=4"
        fi
        if [[ $el == ???E ]]
        then
            let "map[$index,$cout]|=8"
        fi
    done
    echo "Please input the next row (or leave it blank if you're finished!)"
    read input
    cout+=1
done

echo -ne "\e[2J"

typeset -i dir x y
dir=0
x=0
y=0

move() {
    if ((dir == 0)) && ( ((${map[$x,$y]} & 2)) || ((y == 0)) )
    then
        return 1
    elif ((dir == 1)) && ( ((${map[$x,$y]} & 8)) || (($x == $xlen)) )
    then
        return 1
    elif ((dir == 2)) && ( ((${map[$x,$y]} & 4)) || ((y == $ylen)) )
    then
        return 1
    elif ((dir == 3)) && ( ((${map[$x,$y]} & 1)) || ((x == 0)) )
    then
        return 1
    fi
    x=$1
    y=$2
}

input=

until [[ $input == [qQ] ]]
do
    if [[ $input == [DlL] ]]
    then
        let dir-=1
        if (( dir == -1 ))
        then
            dir=3
        fi
    elif [[ $input == [CrR] ]]
    then
        let dir+=1
        if (( dir == 4 ))
        then
            dir=0
        fi
    elif [[ $input == [AfF] ]]
    then
        if (( dir == 0 ))
        then
            move $x $(( y-1 ))
        elif (( dir == 1 ))
        then
            move $(( x+1 )) $y
        elif (( dir == 2 ))
        then
            move $x $(( y+1 ))
        elif (( dir == 3 ))
        then
            move $(( x-1 )) $y
        fi
    elif [[ $input == [bB] ]]
    then
        if (( dir == 0 ))
        then
            dir=2
            move $x $(( y+1 ))
            dir=0
        elif (( dir == 1 ))
        then
            dir=3
            move $(( x-1 )) $y
            dir=1
        elif (( dir == 2 ))
        then
            dir=0
            move $x $(( y-1 ))
            dir=2
        elif (( dir == 3 ))
        then
            dir=1
            move $(( x+1 )) $y
            dir=3
        fi
    fi
    echo -ne "\e[2J"
    echo -ne "\e[16;1Hd=$dir; x=$x; y=$y\e[48;5;29m"
    for (( y2=1; y2 <= 15; y2++ ))
    do
        echo -ne "\e[$y2;16H\e[1K"
    done
    if (( dir == 0 ))
    then
        for (( y2=(y-2); y2 <= y; y2++ ))
        do
            if (( y2 < 0 )); then continue; fi
            let i=y-y2
            if (( x > 0 )) && (( ${map[$((x-1)),$y2]} & 2 ))
            then
                if (( ((x-1) + y2) & 1 ))
                then
                    echo -ne "\e[38;5;40m"
                else
                    echo -ne "\e[38;5;28m"
                fi
                echo -ne ${lfront[$i]}
            fi
            if (( (x+1) < xlen )) && (( ${map[$((x+1)),$y2]} & 2 ))
            then
                if (( ((x-1) + y2) & 1 ))
                then
                    echo -ne "\e[38;5;40m"
                else
                    echo -ne "\e[38;5;28m"
                fi
                echo -ne ${rfront[$i]}
            fi
            if (( ${map[$x,$y2]} & 1 ))
            then
                if (( (x + y2) & 1 ))
                then
                    echo -ne "\e[38;5;28m"
                else
                    echo -ne "\e[38;5;40m"
                fi
                echo -ne ${left[$i]}
            fi
            if (( ${map[$x,$y2]} & 8 ))
            then
                if (( (x + y2) & 1 ))
                then
                    echo -ne "\e[38;5;28m"
                else
                    echo -ne "\e[38;5;40m"
                fi
                echo -ne ${right[$i]}
            fi
            if (( ${map[$x,$y2]} & 2 ))
            then
                if (( (x + y2) & 1 ))
                then
                    echo -ne "\e[38;5;40m"
                else
                    echo -ne "\e[38;5;28m"
                fi
                echo -ne ${front[$i]}
            fi
        done
    elif (( dir == 1 ))
    then
        for (( x2=x+2; x2 >= x; x2-- ))
        do
            if (( x2 > 16 )) || (( x2 >= xlen )); then continue; fi
            let i=x2-x
            if (( y > 0 )) && (( ${map[$x2,$((y-1))]} & 8 ))
            then
                if (( (x2 + (y-1)) & 1 ))
                then
                    echo -ne "\e[38;5;28m"
                else
                    echo -ne "\e[38;5;40m"
                fi
                echo -ne ${lfront[$i]}
            fi
            if (( (y+1) < ylen )) && (( ${map[$x2,$((y+1))]} & 8 ))
            then
                if (( (x2 + (y-1)) & 1 ))
                then
                    echo -ne "\e[38;5;28m"
                else
                    echo -ne "\e[38;5;40m"
                fi
                echo -ne ${rfront[$i]}
            fi
            if (( ${map[$x2,$y]} & 2 ))
            then
                if (( (x2 + y) & 1 ))
                then
                    echo -ne "\e[38;5;40m"
                else
                    echo -ne "\e[38;5;28m"
                fi
                echo -ne ${left[$i]}
            fi
            if (( ${map[$x2,$y]} & 4 ))
            then
                if (( (x2 + y) & 1 ))
                then
                    echo -ne "\e[38;5;40m"
                else
                    echo -ne "\e[38;5;28m"
                fi
                echo -ne ${right[$i]}
            fi
            if (( ${map[$x2,$y]} & 8 ))
            then
                if (( (x2 + y) & 1 ))
                then
                    echo -ne "\e[38;5;28m"
                else
                    echo -ne "\e[38;5;40m"
                fi
                echo -ne ${front[$i]}
            fi
        done
    elif (( dir == 2 ))
    then
        for (( y2=(y+2); y2 >= y; y2-- ))
        do
            if (( y2 > 15 )) || (( y2 >= ylen )); then continue; fi
            let i=y2-y
            if (( x > 0 )) && (( ${map[$((x-1)),$y2]} & 4 ))
            then
                if (( ((x-1) + y2) & 1 ))
                then
                    echo -ne "\e[38;5;40m"
                else
                    echo -ne "\e[38;5;28m"
                fi
                echo -ne ${rfront[$i]}
            fi
            if (( (x+1) < xlen )) && (( ${map[$((x+1)),$y2]} & 4 ))
            then
                if (( ((x+1) + y2) & 1 ))
                then
                    echo -ne "\e[38;5;40m"
                else
                    echo -ne "\e[38;5;28m"
                fi
                echo -ne ${lfront[$i]}
            fi
            if (( ${map[$x,$y2]} & 8 ))
            then
                if (( (x + y2) & 1 ))
                then
                    echo -ne "\e[38;5;28m"
                else
                    echo -ne "\e[38;5;40m"
                fi
                echo -ne ${left[$i]}
            fi
            if (( ${map[$x,$y2]} & 1 ))
            then
                if (( (x + y2) & 1 ))
                then
                    echo -ne "\e[38;5;28m"
                else
                    echo -ne "\e[38;5;40m"
                fi
                echo -ne ${right[$i]}
            fi
            if (( ${map[$x,$y2]} & 4 ))
            then
                if (( (x + y2) & 1 ))
                then
                    echo -ne "\e[38;5;40m"
                else
                    echo -ne "\e[38;5;28m"
                fi
                echo -ne ${front[$i]}
            fi
        done
    elif (( dir == 3 ))
    then
        for (( x2=(x-2); x2 <= x; x2++ ))
        do
            if (( x2 < 0 )); then continue; fi
            let i=x-x2
            if (( y > 0 )) && (( ${map[$x2,$((y-1))]} & 1 ))
            then
                if (( (x2 + (y-1)) & 1 ))
                then
                    echo -ne "\e[38;5;28m"
                else
                    echo -ne "\e[38;5;40m"
                fi
                echo -ne ${rfront[$i]}
            fi
            if (( (y+1) < ylen )) && (( ${map[$x2,$((y+1))]} & 1 ))
            then
                if (( (x2 + (y+1)) & 1 ))
                then
                    echo -ne "\e[38;5;28m"
                else
                    echo -ne "\e[38;5;40m"
                fi
                echo -ne ${lfront[$i]}
            fi
            if (( ${map[$x2,$y]} & 4 ))
            then
                if (( (x2 + y) & 1 ))
                then
                    echo -ne "\e[38;5;40m"
                else
                    echo -ne "\e[38;5;28m"
                fi
                echo -ne ${left[$i]}
            fi
            if (( ${map[$x2,$y]} & 2 ))
            then
                if (( (x2 + y) & 1 ))
                then
                    echo -ne "\e[38;5;40m"
                else
                    echo -ne "\e[38;5;28m"
                fi
                echo -ne ${right[$i]}
            fi
            if (( ${map[$x2,$y]} & 1 ))
            then
                if (( (x2 + y) & 1 ))
                then
                    echo -ne "\e[38;5;28m"
                else
                    echo -ne "\e[38;5;40m"
                fi
                echo -ne ${front[$i]}
            fi
        done
    fi
    echo -ne "\e[0m"
    echo -ne "\e[${term[0]};0H[F]orward, [B]ackward, turn [L]eft, turn [R]ight or [Q]uit?"
    read -n 1 input
done

echo

Tenga en cuenta que esto es más o menos lo primero que hice con bash eso que fue más que simplemente juntar algunos comandos. Probablemente sería reducible bastante si no codificara todas las paredes, pero me pareció más fácil. No tiene consistencia alguna. El formato de bytes para cada cuadrado se selecciona de una manera horrible. Pero funciona.

Incluso agregué soporte para el movimiento a través de las teclas de flecha :)

Estas son algunas capturas de pantalla para la entrada de muestra (tenga en cuenta que mi mapa comienza en (0 | 0)):

0 | 0, hacia el norte 0 | 2, orientado al sur 2 | 1, hacia el este 2 | 1, orientado al sur 1 | 2, hacia el norte

Además del cuarto, todos se parecen a los de muestra también (vea mi comentario sobre el OP).

Estas capturas de pantalla se tomaron en urxvt v9.15 con soporte de 256 colores, probablemente se vería bastante mal en un terminal de 88 colores, y los terminales sin soporte Unicode no funcionan en absoluto. La fuente que utilicé fue Source Code Pro de Adobe.

jazzpi
fuente
1
Jaja, en fiesta y en color también! Agradable. Tenías toda la razón sobre ese muro, aparentemente en algún momento lo "arreglé" en mi programa. Así que lo arreglé. :-) Gracias por la captura!
Dr. Rebmu
3

Aquí está mi versión, en Python 3. Es algo así como 3k caracteres y podría reducirse un poco con un poco de esfuerzo (para empezar, hay un montón de espacio en blanco que podría eliminarse).

Actualmente se usa +X/\como sus caracteres de dibujo, pero está configurado para dibujar con caracteres Unicode si tiene una fuente de ancho fijo que los representará correctamente. Admite el uso de mosaicos separados para las partes anguladas de las paredes de diferentes colores, aunque no estoy usando esa característica. También le permite proporcionar fichas de techo, piso y "distantes", y puede usar diferentes para cuando el jugador está mirando hacia el este o el oeste frente al norte o al sur. Por desgracia, esto nunca se vio muy bien, por lo que probablemente todos estos deberían estar en blanco (o algo sólido, como ).

Por desgracia, en mi sistema Windows 7, tuve un momento horrible tratando de encontrar una fuente monoespaciada con el conjunto completo de caracteres de bloque (por ejemplo, y ). La mayoría de los que encontré no podían estar disponibles en elcmd consola por alguna razón (¿tal vez porque no están perfectamente monoespaciados?). Si cree que su consola es más funcional, intente usar el juego de caracteres alternativo que he comentado cerca de la parte superior del archivo, que no se ve tan mal incluso con solo dos colores. Se ha rellenado de techos y suelos y en su mayoría paredes transparentes.

El código:

from itertools import product as p
r=range
cs=r"+X//\\//\\      " #" ░▛▛▜▜▟▟▙▙██████"
shapes=[(1,[(x,y,0)for x,y in p(r(5),r(5,10))]),
        (0,[(x,y,0)for x,y in p(r(5,11),r(5,10))]),
        (1,[(x,y,0)for x,y in p(r(11,16),r(5,10))]),
        (1,[(4,4,4),(4,10,6)]+[(4,y,0)for y in r(5,10)]),
        (1,[(11,4,2),(11,10,8)]+[(11,y,0)for y in r(5,10)]),
        (0,[(x,y,0)for x,y in p(r(4),r(4,11))]),
        (1,[(x,y,0)for x,y in p(r(4,12),r(4,11))]),
        (0,[(x,y,0)for x,y in p(r(12,16),r(4,11))]),
        (0,[(1,1,4),(2,2,4),(3,3,4),(1,13,6),(2,12,6),(3,11,6)]+
           [(x,y,0)for x,y in p(r(1,4),r(2,14)) if x<y<14-x]),
        (0,[(14,1,2),(13,2,2),(12,3,2),(14,13,8),(13,12,8),(12,11,8)]+
           [(x,y,0)for x,y in p(r(12,15),r(2,14)) if 15-x<y<x-1]),
        (1,[(0,y,0) for y in r(1,14)]),
        (0,[(x,y,0) for x,y in p(r(1,15),r(1,14))]),
        (1,[(15,y,0) for y in r(1,14)]),
        (1,[(0,0,4),(0,14,6)]+[(0,y,0)for y in r(1,14)]),
        (1,[(15,0,2),(15,14,8)]+[(15,y,0) for y in r(1,14)])]
def rr(s):
    for r in s:print("".join(r))
def dw(s,a,p,d):
    for i,r in enumerate(s):r[:]=cs[10+i//5*2+d%2]*16
    for w,(pl,sh) in zip(a,shapes):
        if w:
            for x,y,c in sh:
                s[y][x]=cs[c+(p+d+pl)%2]
dx=[1,0,-1,0]
def ga(x,y,d,m):
    fx=dx[d];fy=lx=dx[d-1];ly=dx[d-2]
    return [m[y+2*fy+ly][x+2*fx+lx][d],m[y+2*fy][x+2*fx][d],
            m[y+2*fy-ly][x+2*fx-lx][d],m[y+2*fy][x+2*fx][d-1],
            m[y+2*fy][x+2*fx][d-3],m[y+fy+ly][x+fx+lx][d],
            m[y+fy][x+fx][d],m[y+fy-ly][x+fx-lx][d],
            m[y+fy][x+fx][d-1],m[y+fy][x+fx][d-3],
            m[y+ly][x+lx][d],m[y][x][d],
            m[y-ly][x-lx][d],m[y][x][d-1],m[y][x][d-3]]
def rd():
    l=input();
    while l!="":
        if "\n" in l:yield from l.split("\n")
        else:yield l
        l=input()
def rm():
    m=[[[d in s for d in"ESWN"]for s in r.strip().split()]+[[1]*4]*2
       for r in rd()]
    return m+[[[1]*4 for _ in m[0]]]*2
def cl():print("\n"*30)
def gl():
    print("Enter map, followed by a blank line.")
    x=y=0;d=3;m=rm();mv="";s=[[""]*16 for _ in r(15)]
    while True:
        cl();dw(s,ga(x,y,d,m),x+y,d);rr(s)
        print("X:",x+1,"Y:",y+1,"Facing:","ESWN"[d])
        if mv:print("Last move:",mv)
        mv=input("[FBLRQ]? ").upper()
        if mv=="F":
            if not m[y][x][d]:x+=dx[d];y+=dx[d-1]
            else:mv+=" (Blocked)"
        elif mv=="B":
            if not m[y][x][d-2]:x+=dx[d-2];y+=dx[d-3]
            else:mv+=" (Blocked)"
        elif mv=="L":d=(d-1)%4
        elif mv=="R":d=(d+1)%4
        elif mv=="Q":break
        else:mv="I didn't understand %r."%mv
gl()

El juego de caracteres se especifica cerca de la parte superior del archivo. El orden de los personajes son:

  1. incluso muro de paridad
  2. muro de paridad impar
  3. ángulo de pared superior derecho de paridad uniforme (por ejemplo, /con una pared debajo de él)
  4. paridad impar ángulo de pared superior derecho
  5. paridad superior ángulo de la pared superior izquierda
  6. paridad impar ángulo de la pared superior izquierda
  7. paridad inferior ángulo de pared inferior derecho
  8. paridad impar ángulo inferior derecho de la pared
  9. paridad inferior ángulo de la pared inferior izquierda
  10. paridad impar ángulo de la pared inferior izquierda
  11. Techo frente a E / W
  12. Techo orientado N / S
  13. horizonte hacia E / W (el centro de la pantalla si no hay paredes)
  14. horizonte hacia N / S
  15. piso orientado E / W
  16. piso orientado N / S

Hay 15 muros que el juego debe representar, en un patrón como este (con Vindicación de la posición y el arco de visión del jugador):

_ _ _
_|_|_ 
_|_|_
 |V|

Los mosaicos utilizados por las 15 paredes están definidos en la shapeslista. Es una lista de 2 tuplas. El primer valor de la tupla indica la "paridad" de la pared, 0indicando que debe dibujarse con los mismos caracteres que una pared directamente en frente del personaje y una 1indicación de que debe ser el patrón alternativo (por ejemplo, +vs X). El segundo valor es una lista de x,y,ttuplas que indican las coordenadas de la pantalla y el índice de mosaico de un píxel (los muros que se representan con paridad impar se habrán 1agregado a cada uno de estos índices). Las formas están ordenadas por distancia, por lo que las tres primeras representan las paredes perpendiculares dos fichas delante del personaje, seguidas de las dos paredes paralelas dos fichas más adelante, y así sucesivamente.

Las funciones son:

  • rr: "renderiza" la pantalla (imprimiendo los mosaicos en el búfer de la pantalla).
  • dw: "dibujar muros" en un búfer de pantalla proporcionado. Esto utiliza el algoritmo de pintores, por lo que las paredes más distantes se dibujan primero y pueden quedar cubiertas por otras más cercanas.
  • ga: "get area" devuelve una lista de valores booleanos que indican qué paredes son opacas para una posición y orientación del mapa.
  • rd: "leer", un generador que lee el mapa, produciendo las líneas. Esto solo es necesario porque la consola de IDLE hace cosas raras cuando pega entradas de varias líneas en lugar de ingresar una línea a la vez.
  • rm: "leer mapa", analiza el mapa en una lista anidada de booleanos, indexada por m[y][x][d](con d=0ser Este y d=1Sur). También agrega dos filas y dos columnas de cuadrados de relleno, para evitar errores de índice en el otro código.
  • cl: "borra" la salida (escribiendo suficientes líneas nuevas para desplazar la vista anterior desde la parte superior de la mayoría de las consolas).
  • gl: "bucle de juego", donde se recopila la entrada y se llama a las cosas anteriores.

Algunas "capturas de pantalla":

La posición inicial:

\               
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
+XXXXXXXXXXXXXX+
/               
X: 1 Y: 1 Facing: N
[FBLRQ]? 

Mirando a lo largo del muro norte:

\               
X\              
X+\             
X++\            
X+++\           
X+++X           
X+++X           
X+++X           
X+++X           
X+++X           
X+++/           
X++/            
X+/             
X/              
/               
X: 1 Y: 1 Facing: E
Last move: R
[FBLRQ]? 

Un par de tomas que coinciden con sus ejemplos (tenga en cuenta que Stack Overflow está cortando las primeras líneas en blanco, están en la salida del programa):

X             / 
X            /+ 
X           /++ 
X           +++ 
X           +++ 
X           +++ 
X           +++ 
X           +++ 
X           +++ 
X           +++ 
X           \++ 
X            \+ 
X             \ 

X: 3 Y: 2 Facing: S
Last move: F
[FBLRQ]? 

Y:

              / 
             /X 
            /XX 
            XXX 
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
+++++XXXXXX+XXX+
            XXX 
            \XX 
             \X 
              \ 

X: 3 Y: 2 Facing: E
Last move: L
[FBLRQ]? 

Aquí está una de las vistas más extrañas en el mapa provisto, ya que el muro paralelo a nuestra vista es del mismo color que el muro perpendicular que sobresale detrás de él:

 \              
 +\             
 ++\            
++++        ++++
++++        ++++
++++        ++++
++++        ++++
++++        ++++
++++        ++++
++++        ++++
 ++/            
 +/             
 /              

X: 3 Y: 4 Facing: N
Last move: R
[FBLRQ]? 

Así es como se vería el área del último disparo desde arriba:

_   _
 |
  V
Blckknght
fuente
¡Buen análisis agregado y diagramas! Hm, esos muros terminan siendo del mismo color que el último en mi implementación también. Buen punto sobre el caso de borde. No pensé que eso sucedería, pero tiene que ser así. Supongo que es como colorear un mapa, y dos colores no son suficientes ...: - /
Dr. Rebmu