Dungeon Construction Set

19

Когда я был ребенком, я играл в игру Intellivision Advanced Dungeons and Dragons: Treasure of Tarmin . Трехмерная графика дает вам вид от первого лица с шокирующим реализмом:

Потрясающе реалистичная трехмерная графика

Но потом я получил C-64. И я смог рисовать на сетке 40x25 символов, курсируя по экрану, устанавливая цвет с помощью клавиши Ctrl и цифры, и помещая символы в любое место, где я хотел (почему я не bashпозволяю это делать?) . Набор символов имел треугольные компоненты и компоненты сплошного блока. Таким образом, я смог обдумать, как можно генерировать рендеринг своей перспективы в сетке через эту среду.

На этой неделе я нашел спецификацию, почти три десятилетия, в спиральной бумаге для тетрадей о Dungeon Construction Set:

введите описание изображения здесь

( ОБНОВЛЕНИЕ : Внимательные читатели заметят, что на наклонных частях это не совсем так. Исправленные цифры приведены ниже.)

Хотя Сокровища Тармина игрались на сетке, стены существовали только по краям квадратов сетки. Узнав, что такое байты, я понял, что если я сделаю карту из байтов ... тогда у каждого квадрата на карте может быть четыре возможных состояния для каждого из ее ребер:

  1. свободный
  2. стена
  3. Дверь
  4. Что-то другое?

Я никогда не удосужился написать его (до прошлой ночи). Я думал, что это может быть весело для других, чтобы попробовать.

Таким образом, ваша задача - реализовать основанный на символьном режиме рендеринг лабиринтов, который реализует мою (исправленную !!) спецификацию ... но с использованием технологий 2013 года.

вход

Поскольку спецификация не определяет рендеринг для дверей, мы просто предполагаем, что единственными вариантами являются «стена и не стена». Для простоты ваш ввод - это карта, состоящая из строк строк, которые выглядят так:

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

Это была бы карта 5х5. Верхний левый угол (1,1) имеет наборы восточной Wи Nправой стен. Нижний правый угол (5,5) имеет свои Sнаружные и наружные Eстенки.

Это значительно менее весело без навигации по карте. Поэтому, как минимум, поместите своего игрока в (1,1) на север и предложите им:

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

На каждом шаге выведите изображение 16x15 с видом от первого лица, как определено в спецификации бумаги для ноутбука. Чтобы вам не приходилось считать, размеры плоских стен на трех расстояниях:

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

Ограничивающие размеры наклонных стен:

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

Разъяснения

  • Соседние клетки могут не соглашаться по поводу общих стен. Таким образом, южный край на квадрате может быть стеной, в то время как северный край на квадрате к югу от него будет беспрепятственным. В оригинальном дизайне я считал, что это особенность: он допускает интересные идеи, такие как односторонние двери ... или невидимые стены, которые появляются только после того, как вы прошли через них. Для этого упрощения следуйте тому же правилу: для навигации и рендеринга обращайте внимание только на состояние ребра в ближайшей к вам ячейке в направлении, в котором вы находитесь .

  • Вид намного лучше с "затенением". Так что для ваших полных блоков чередуйте либо Unicode 2593 25 и 2591 ░, либо используйте Xи, +если ваша реализация ASCII.

  • Треугольные символы Unicode (25E2 ◢, 25E3 ◣, 25E4 ◤, 25E5 ◥) немного отстойные для рисования этого. Помимо отсутствия заштрихованных вариантов, они часто растягивают только ширину символа, а не полную высоту ... даже в шрифтах фиксированной ширины. Вы можете рисовать полные блоки или косые черты или что-то по вашему выбору в местах, где я хотел диагонали. Ценится интересные креативные решения, которые включают цвет и используют эти символы вместо затенения.

  • Вы можете предположить, что внешние стены ограничены игровой зоной, поэтому вам не нужно беспокоиться о рендеринге вне лабиринта. Любые стены дальше от вас, чем спецификация, игнорируются и просто оставляют пустое пространство.

  • Затенение стены, которую вы видите прямо перед собой, если смотреть на север в точке (1,1), должно быть ТЕМНЫМ. Поочередное затенение смежных стен на карте, так что если бы присутствовали все стены, то светлая стена никогда не упиралась бы в темную стену.

  • Реализация C-64, которая на самом деле делает то, что я изначально задумал ... с диагональными символами и всем ... превзойдет любой другой критерий входа. :-)

Примеры

Для примера карты, приведенной выше ...

На (1,3) с видом на юг:

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

На (3,2) на юг:

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

На (3,2) лицом к востоку:

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

В (2,3) на север:

               /
 ++++++++++++++X
 ++++++++++++++X
 ++++++++++++++X
 ++++++++++++++X
X++++++++++++++X
X++++++++++++++X
X++++++++++++++X
X++++++++++++++X
X++++++++++++++X
 ++++++++++++++X
 ++++++++++++++X
 ++++++++++++++X
 ++++++++++++++X
               \
Доктор Ребму
источник
1
Я предлагаю сделать это сложной задачей - гольф будет слишком нечитабельным и сложным: P
Ручка двери
1
@ Doorknob Не позволяй этому обмануть тебя ... на самом деле это не так сложно. Есть довольно хороший совет со списками 3 ограничивающих размеров. И что такое гольф, но проблема, которая решается, а затем урезается? :-) Но я позволю людям выбрать, как они хотят это решить ... Н.П.
Доктор Ребму
Не могли бы вы объяснить две колонки Xс вашей точки зрения на 3, 2юг?
Jazzpi
Особенно тот, что на правой стороне. Я понимаю, почему левый там. Но правильный, кажется, нарушает Разъяснение № 1.
Jazzpi
@jazzpi Ой, вы правы, карта, которую я выложил, должна подчиняться разъяснениям 1! Отлично сработано. Исправлена. (Я бы поставил недостающую южную стену на моей собственной версии в какой-то момент, по-видимому ... но хорошо иметь тестовый пример в образце ... так что давайте оставим южную стену снаружи!)
Доктор Ребму,

Ответы:

10

Commodore 64 Basic

Чувак, это было весело. И тяжело. C64 Basic практически не отлаживается, вы даже не можете использовать printотладку, потому что экран уже взят для рендеринга подземелья. Вы знаете, что вам весело, когда вы пишете код, как 55250 goto 55110. Дейкстра убьет меня.

Программа использует два цвета и диагональные символы.

Излишне говорить, что я не играл в гольф. В конце концов, это говорит о проблемах с кодом . Это 7183 байта, если вам интересно.

Это медленно - при скорости по умолчанию для визуализации сцены требуется несколько секунд. Максимальный размер карты 10 на 10, но его можно изменить, отредактировав строку 120.

Я разработал и протестировал это с помощью эмулятора VICE . Код ниже отображается в ASCII, что означает сдвиг PETSCII. Однако при вводе карты вы должны использовать PETSCII без смещения .

Скриншот: Скриншот

Код:

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

Изображение ленты: скачать здесь .

Примеры:

Примеры

Мэринус
источник
1
О, МОЙ БОГ. Если другие хотят решить эту проблему, черт возьми, прекрасно ... но вы выиграли награду за определение козырной карты в испытании. У меня был соблазн вытащить эмулятор и сделать это по причинам ностальгии, но я подумал, что было бы более продуктивно написать его красным, чтобы увидеть, насколько хорошо кросс-компилятор компилятора может выдержать. источник для этого . Я сделаю это и отправлю в какой- то момент ... но щедрость ваша! Большие аплодисменты.
Доктор Ребму
1
Кроме того, RE: Дейкстра, у него есть забавная цитата о бессмертии : «Я имею в виду, что если через 10 лет, когда вы делаете что-то быстрое и грязное, вы вдруг представляете, что я смотрю через ваши плечи и говорю себе:« Дейкстра будет не понравилось это, ну, этого было бы достаточно для бессмертия ". Так что, думаю, он получил свое желание! :-)
Доктор Ребму
@ Dr.Rebmu: спасибо за щедрость! Это заняло у меня буквально весь день, чтобы написать :)
marinus
10

(почему не bashпозволяет мне сделать это?)

Я просто должен был сейчас.

Баш, 12743 символа

#!/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

Пожалуйста, имейте в виду, что это первое, что я сделал, bashэто было больше, чем просто объединение нескольких команд. Скорее всего, это можно было бы уменьшить, если бы я не жестко закодировал все стены, но это казалось проще. У него нет никакой последовательности. Байтный формат для каждого квадрата выбирается ужасным образом. Но это работает.

Я даже добавил поддержку движения через клавиши со стрелками :)

Вот несколько скриншотов для примера ввода (обратите внимание, что моя карта начинается с (0 | 0)):

0 | 0, на север 0 | 2, на юг 2 | 1, на восток 2 | 1, на юг 1 | 2, на север

Кроме четвертого, все они похожи на образцы (см. Мой комментарий к ОП).

Эти скриншоты были сделаны на urxvt v9.15 с поддержкой 256 цветов, вероятно, на 88-цветном терминале это выглядело бы совсем глупо, а терминалы без поддержки юникода вообще не работают. Я использовал шрифт Source Code Pro от Adobe.

jazzpi
источник
1
Ха-ха, в баш, и в цвет тоже! Ницца. Вы были абсолютно правы насчет этой стены, по-видимому, я в какой-то момент «исправил» ее в своей программе. Так что я это исправил. :-) Спасибо за улов!
Доктор Ребму
3

Вот моя версия, в Python 3. Это что-то вроде 3k символов и может стать немного меньше с небольшим усилием (есть много пустого пространства, которое можно удалить, для начала).

В настоящее время он использует в +X/\качестве своих символов для рисования, но он настроен для рисования с использованием символов Юникода, если у вас есть шрифт фиксированной ширины, который будет отображать их правильно. Он поддерживает использование отдельных плиток для угловых частей разноцветных стен, хотя я не использую эту функцию. Это также позволяет вам предоставлять потолочные, напольные и «отдаленные» плитки, и вы можете использовать разные, когда игрок смотрит на восток или запад против севера или юга. Увы, это никогда не выглядело очень хорошо, поэтому, вероятно, все они должны быть пустыми (или что-то твердое, например ).

Увы, в моей системе Windows 7 я ужасно пытался найти моноширинный шрифт с полным набором символов блоков (например, и ). Большинство из тех, что я нашел, не может быть доступно в cmdконсоли по какой-то причине (возможно, потому что они не идеально моноширинны?). Если вы думаете, что ваша консоль более функциональна, попробуйте использовать альтернативный набор символов, который я прокомментировал, в верхней части файла, который выглядит не так уж плохо даже с двумя цветами. Он заполнил потолки и полы и в основном прозрачные стены.

Код:

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

Набор символов указывается в верхней части файла. Порядок символов:

  1. четная стена
  2. Странная нечетная стена
  3. равномерный угол наклона верхней правой стены (например, /со стеной под ним)
  4. нечетный верхний правый угол стены
  5. четный угол наклона верхней левой стены
  6. нечетное соотношение верхний левый угол стены
  7. четный угол нижней правой стены
  8. нижний правый угол стены
  9. четный угол нижней левой стены
  10. нечетное соотношение нижний левый угол стены
  11. потолочная облицовка E / W
  12. потолок N / S
  13. горизонт, обращенный к E / W (середина экрана, если нет стен)
  14. горизонт обращен к северо-востоку
  15. напольное покрытие E / W
  16. напольное покрытие N / S

В игре может быть отрисовано 15 стен по такой схеме (с Vуказанием позиции игрока и дуги обзора):

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

Плитки, используемые 15 стенами, определены в shapesсписке. Это список из двух кортежей. Первое значение кортежа указывает «четность» стены, 0указывая, что он должен быть нарисован теми же символами, что и стена, прямо перед символом, и 1указывая, что это должен быть альтернативный шаблон (например, +vs X). Второе значение представляет собой список x,y,tкортежей, указывающих координаты экрана и индекс плитки в один пиксель (стены, отображаемые с нечетной четностью, будут 1добавлены к каждому из этих индексов). Формы упорядочены по расстоянию, поэтому первые три представляют собой перпендикулярные стены на две плитки впереди персонажа, затем две параллельные стены на две плитки впереди и так далее.

Функции:

  • rr: «отрендерить» экран (печатая тайлы в буфере экрана).
  • dw: "рисовать стены" в предоставленном буфере экрана. При этом используется алгоритм рисования, поэтому самые дальние стены рисуются первыми и могут быть закрыты более близкими.
  • ga: «get area» возвращает список логических значений, указывающих, какие стены непрозрачны для данной позиции карты и облицовки.
  • rd: «чтение», генератор, который читает карту, получая строки. Это необходимо только потому, что консоль IDLE делает странные вещи, когда вы вставляете многострочные вводы вместо ввода по одной строке за раз.
  • rm: «читать карту», ​​анализирует карту во вложенный список логических значений, индексируемых m[y][x][d]d=0востоком и d=1югом). Он также добавляет две строки и два столбца квадратов заполнения, чтобы избежать ошибок индекса в другом коде.
  • cl: «очистить» вывод (написав достаточно новых строк, чтобы прокрутить старый вид с вершины большинства консолей).
  • gl: "игровой цикл", где собирается вход и вызывается вышеуказанный материал.

Несколько «скриншотов»:

Начальная позиция:

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

Глядя вдоль северной стены:

\               
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]? 

Пара снимков, соответствующих вашим примерам (обратите внимание, пустые первые строки отсекаются с помощью переполнения стека, они находятся в выходных данных программы):

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

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

И:

              / 
             /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]? 

Вот один из странных видов на прилагаемой карте, так как стена, параллельная нашему виду, того же цвета, что и торчащая за ней перпендикулярная стена:

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

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

Вот как будет выглядеть область последнего снимка сверху:

_   _
 |
  V
Blckknght
источник
Приятно добавлен анализ и диаграммы! Хм, эти стены тоже имеют тот же цвет, что и последний в моей реализации. Хороший вопрос о крайнем случае. Я не думал, что это произойдет, но это вроде как должно. Думаю, это как раскраска карты, а двух цветов на самом деле недостаточно ...: - /
Доктор Ребму