Введение

Эта небольшая электронная книга предназначена для того, чтобы научить вас языку программирования под названием Forth (прим: вернее познакомить с пониманием некоторых основ Форт языка). Форт — это язык, непохожий на большинство других. Он не функциональный и не объектно-ориентированный, в нем нет проверки типов и практически отсутствует синтаксис. Он был написан в 70-х годах, но до сих пор используется для некоторых приложений .

Зачем учить такой странный язык? Каждый новый язык программирования, который Вы изучаете, помогает Вам думать о проблемах по-новому. Форт очень прост в освоении, но он требует от Вас мыслить не так, как вы привыкли. Это делает его идеальным языком для расширения ваших горизонтов кодирования.

Эта книга включает в себя простую реализацию Forth, которую я написал на JavaScript. Он ни в коем случае не совершенен, и ему не хватает многих функций, которые вы ожидаете от настоящей системы Forth. Это просто для того, чтобы дать вам простой способ опробовать примеры. (Если Вы эксперт по Forth, пожалуйста, поделитесь здесь и сделайте его лучше!)

(А, здесь код JS странички c Форт по представленному переводу для игры в Форт- Змейку[http://skilldrick.github.io/easyforth/]

Я предполагаю, что Вы знаете по крайней мере еще один язык программирования и имеете общее представление о том, как стеки работают как структуры данных.

Добавление некоторых чисел

Что отличает Forth от большинства других языков, так это использование стека. В Форте все вращается вокруг стека. Каждый раз, когда вы вводите число, оно помещается в стек. Если вы хотите сложить два числа вместе, +введите два верхних числа из стека, сложите их и поместите результат обратно в стек.

Давайте посмотрим на пример. Введите (не копируйте и не вставляйте) следующее в интерпретатор, вводя Enterпосле каждой строки.

1
2
3

Каждый раз, когда Вы вводите строку, за которой следует Enterклавиша, интерпретатор Forth выполняет эту строку и добавляет строку, okчтобы Вы знали, что ошибок не было. Вы также должны заметить, что по мере выполнения каждой строки область вверху заполняется числами. Эта область является нашей визуализацией стека. Это должно выглядеть так:

1 2 3 <-

Теперь в том же интерпретаторе введите single, +а затем Enterклавиша. Два верхних элемента в стеке 2и 3были заменены на 5.

1 5 <- ок

На этом этапе ваше окно редактора должно выглядеть так:

1 ок 2 ок 3 ок + ок

Введите +еще раз и нажмите Enter, и два верхних элемента будут заменены на 6. Если вы наберете +еще раз, Forth попытается извлечь два верхних элемента из стека, даже если в стеке только один элемент! Это приводит к Stack underflowошибке:

1 ок 2 ок 3 ок + ок + ок + опустошение стека

Форт не заставляет вас вводить каждый токен в виде отдельной строки. Введите следующее в следующий редактор, а затем клавишу Enter:

123 456 +

Теперь стек должен выглядеть так:

579 <- ок

Этот стиль, в котором оператор стоит после операндов, известен как обратная польская нотация . Давайте попробуем что-нибудь посложнее и посчитаем 10 * (5 + 2). Введите в интерпретатор следующее:

5 2 + 10 *

Одна из приятных особенностей Forth заключается в том, что порядок операций полностью зависит от их порядка в программе. Например, при выполнении 5 2 + 10 *интерпретатор помещает в стек 5, затем 2, затем складывает их и помещает в стек получившееся 7, затем помещает в стек 10, затем умножает 7 и 10. Из-за этого нет необходимости в круглых скобках для группировки. операторы с более низким приоритетом.

Эффекты стека

Большинство слов Forth так или иначе влияют на стек. Некоторые извлекают значения из стека, некоторые оставляют новые значения в стеке, а некоторые делают и то, и другое. Эти «эффекты стека» обычно представляются с помощью комментариев в форме ( до -- после ). Например, + ( n1 n2 -- sum )- n1и n2являются двумя верхними числами в стеке, и sumявляется значением, оставшимся в стеке.

Определение слов

Синтаксис Forth предельно прост. Форт-код интерпретируется как последовательность слов, разделенных пробелами. Почти все непробельные символы допустимы в словах. Когда интерпретатор Forth читает слово, он проверяет, существует ли определение во внутренней структуре, известной как словарь. Если он найден, это определение выполняется. В противном случае слово считается числом и помещается в стек. Если слово не может быть преобразовано в число, возникает ошибка.

Вы можете попробовать это самостоятельно ниже. Введите foo(неизвестное слово) и нажмите клавишу ввода.

Вы должны увидеть что-то вроде этого:

foo foo?

foo ?означает, что Forth не смог найти определение для foo, и это недопустимое число.

Мы можем создать собственное определение, fooиспользуя два специальных слова, называемых :(двоеточие) и ;(точка с запятой). :это наш способ сказать Форту, что мы хотим создать определение. Первое слово после :становится именем определения, а остальные слова (до ;) составляют тело определения. Обычно между именем и телом определения включают два пробела. Попробуйте ввести следующее:

: foo  100 + ;
1000 foo
foo foo foo

Предупреждение. Распространенной ошибкой является пропуск пробела перед ;словом. Поскольку слова Форта разделены пробелами и могут содержать большинство символов, +;это совершенно допустимое слово и не анализируется как два отдельных слова.

Как вы, надеюсь, уже поняли, наше fooслово просто добавляет 100 к значению на вершине стека. Это не очень интересно, но должно дать вам представление о том, как работают простые определения.

Управление стеком

Теперь мы можем приступить к рассмотрению некоторых предопределенных слов Forth. Во-первых, давайте посмотрим на некоторые слова для управления элементами в верхней части стека.

dup ( n -- n n )

dupявляется сокращением от «дубликат» — он дублирует верхний элемент стека. Например, попробуйте это:

1 2 3 dup

У вас должен получиться следующий стек:

1 2 3 3 <- ок ( верхний элемент стека самый праый в этом его представлении)

drop ( n -- )

dropпросто удаляет верхний элемент стека:

1 2 3 drop

сделает стек таким:

1 2 <- ок

swap ( n1 n2 -- n2 n1 )

swap, как вы уже догадались, меняет местами два верхних элемента стека. Например:

1 2 3 4 swap

даст тебе:

1 2 4 3 <- ок

over ( n1 n2 -- n1 n2 n1 )

overнемного менее очевиден: он берет второй элемент с вершины стека и дублирует его на вершину стека. Выполнение этого:

1 2 3 over

приведет к этому:

1 2 3 2 <- ок

rot ( n1 n2 n3 -- n2 n3 n1 )

Наконец, «вращает» триrot верхних элемента стека. Третий элемент с вершины стека перемещается на вершину стека, вытесняя два других элемента вниз.

1 2 3 rot

дает тебе:

2 3 1 <- ок

Генерация вывода

Далее рассмотрим некоторые слова для вывода текста в консоль.

. ( n -- ) (точка)

Самое простое выходное слово в Forth — это .. Вы можете использовать .для вывода вершины стека в выводе текущей строки. Например, попробуйте запустить это (не забудьте добавлять пробелы между символам!):

1 . 2 . 3 . 4 5 6 . . .

Вы должны увидеть это:

1 . 2 . 3 . 4 5 6 . . . 1 2 3 6 5 4 ок

Проходя это по порядку, мы нажимаем 1, затем выталкиваем его и выводим. Затем делаем то же самое с 2и 3. Затем мы помещаем 4, 5и 6в стек. Затем мы выталкиваем их и выводим по одному. Вот почему последние три числа в выводе меняются местами: стек вошел последним, вышел первым.

emit ( c -- )

emitможет использоваться для вывода чисел в виде символов ASCII. Точно так же, как .выводит число наверху стека, emitвыводит это число как символ ascii. Например:

 33 119 111 87 emit emit emit emit

Я не буду приводить вывод здесь, чтобы не испортить сюрприз. Это также может быть записано как:

87 emit 111 emit 119 emit 33 emit

В отличие от ., emitне выводит пробел после каждого символа, что позволяет создавать произвольные строки вывода.

cr ( -- )

crявляется сокращением от возврата каретки — он просто ререводит вывод на новую строку:

cr 100 . cr 200 . cr 300 .

Эта последовательность:

100 cr . 200 cr . 300 cr .
100
200
300 ок

." ( -- )

Наконец у нас есть ."— специальное слово для вывода строк. Слово ."работает по-разному внутри определений в интерактивном режиме. ."отмечает начало строки для вывода, а конец строки определяется по ".
"— это контекстное слово для использоания, поэтому его не нужно разделять пробелами. Вот пример:

: say-hello  ." Hello World!" ;
say-hello

Вы должны увидеть следующий вывод

Hello World!

Мы можем комбинировать .", ., crи emitдля создания более сложного вывода:

: print-stack-top  cr dup ." Вершина стека - " .
  cr ." ,что выглядит как '" dup emit ." ' в ascii  " ;
48 print-stack-top

Запуск этого должен дать вам следующий результат:

48 print-stack-top
Вершина стека - 48, что выглядит как 0 в ascii ok

Условные операторы и циклы

Теперь о самом интересном! Форт, как и большинство других языков, имеет условные операторы и циклы для управления потоком вашей программы. Однако, чтобы понять, как они работают, сначала нам нужно понять булевы значения в Forth.

Булевы значения

На самом деле в Forth нет логического типа. Число 0считается ложным, а любое другое число — истинным, хотя каноническим истинным значением является -1(все логические операторы возвращают 0или -1).

Чтобы проверить, равны ли два числа, вы можете использовать =:

3 4 = .
5 5 = .

Это должно вывести:

3 4 = . 0 ок 
5 5 = .  -1 ок

Вы можете использовать <and >для меньшего и большего чем.
<проверяет, меньше ли второй элемент с вершины стека, чем верхний элемент стека, и наоборот >:

3 4 < .
3 4 > .

3 4 < . -1 ок 3 4 > . 0 ок

Логические операторы And, Or и Not доступны как and, or, и invert:

3 4 < 20 30 < and .
3 4 < 20 30 > or .
3 4 < invert .

Первая строка эквивалентна 3 < 4 & 20 < 30на языке C. Вторая строка эквивалентна 3 < 4 | 20 > 30. Третья строка эквивалентна !(3 < 4).

and, or, и invertвсе побитовые операции. Для правильно сформированных флагов ( 0и -1) они будут работать, как и ожидалось, но будут давать неверные результаты для произвольных чисел.

if then

Теперь мы наконец можем перейти к условным выражениям. Условные выражения в Forth могут использоваться только внутри определений. Простейшим условным оператором в Forth является if then, который эквивалентен стандартному ifоператору в большинстве языков. Вот пример определения с использованием if then. В этом примере мы также используем слово mod, которое возвращает модуль двух верхних чисел в стеке. В этом случае верхнее число — 5, а второе — то, что было помещено в стек перед вызовом buzz?. Следовательно, 5 mod 0 =это логическое выражение, которое проверяет, делится ли число на вершине стека на 5.

: buzz?  5 mod 0 = if ." Buzz" then ;
3 buzz?
4 buzz?
5 buzz?

Это выведет:

3 buzz? ок
4 buzz? ок
5 buzz? Buzz ok

Важно отметить, что thenслово отмечает конец утверждения if. Это делает его эквивалентным, например, fiв Bash или Ruby.end

Еще одна важная вещь, которую следует осознать, заключается в том, что он ifне оставляет верхнее значение в стеке, когда проверяет, является ли оно истинным или ложным.

if else then

if else thenэквивалентно оператору if/elseв большинстве языков. Вот пример его использования:

: is-it-zero?  0 = if ." Да!" else ." Нет!" then ;
0 is-it-zero?
1 is-it-zero?
2 is-it-zero?

Это выводит:

0 Да! ок
1 Нет! ок
2 Нет! ок

На этот раз предложение if (консеквент) — это все, что находится между ifи else, а предложение else (альтернативное) — это все, что находится между elseи then.

do loop

do loopв Forth больше всего напоминает forцикл в большинстве языков на основе C. В теле a do loopспециальное слово iпомещает текущий индекс цикла в стек.

Два верхних значения в стеке дают начальное значение (включительно) и конечное значение (исключая) для значения i. Начальное значение берется с вершины стека. Вот пример:

: loop-test  10 0 do i . loop ;
loop-test

Это должно вывести:

0 1 2 3 4 5 6 7 8 9 ок

Выражение 10 0 do i . loopпримерно эквивалентно:

for (int i = 0; i < 10; i++) {
  print(i);
}

Физз Базз

Мы можем легко написать классическую программу Fizz Buzz , используя do loop:

: fizz?  3 mod 0 = dup if ." Fizz" then ;
: buzz?  5 mod 0 = dup if ." Buzz" then ;
: fizz-buzz?  dup fizz? swap buzz? or invert ;
: do-fizz-buzz  25 1 do cr i fizz-buzz? if i . then loop ;
do-fizz-buzz

fizz?проверяет, делится ли вершина стека на 3, используя 3 mod 0 =. Затем он использует dupдля дублирования флага результата. Верхняя копия значения потребляется if. Вторая копия остается в стеке и действует как возвращаемое значение fizz?.

Если число на вершине стека делится на 3, "Fizz"будет выведена строка, иначе вывода не будет.

buzz?делает то же самое, но с 5, и выводит строку "Buzz".

fizz-buzz?вызывает dupдублирование значения на вершине стека, затем вызывает fizz?, преобразуя верхнюю копию в логическое значение. После этого вершина стека состоит из исходного значения и логического значения, возвращаемого fizz?. swapменяет их местами, поэтому исходное значение вершины стека снова оказывается наверху, а логическое значение — под ним. Затем мы вызываем buzz?, который заменяет значение вершины стека логическим флагом. Теперь два верхних значения в стеке являются логическими значениями, представляющими, делится ли число на 3 или 5. После этого мы вызываем, orчтобы проверить, верно ли какое-либо из них, и invertотменить это значение. Логически тело fizz-buzz?эквивалентно:

!(x % 3 == 0 || x % 5 == 0)

Следовательно, fizz-buzz?возвращает логическое значение, указывающее, не делится ли аргумент на 3 или 5 и, следовательно, должен быть напечатан. Наконец, do-fizz-buzzциклы от 1 до 25, вызывающие fizz-buzz?и iвыводящие iif, fizz-buzz?возвращают true.

Если у вас возникли проблемы с пониманием того, что происходит внутри fizz-buzz?, приведенный ниже пример может помочь вам понять, как это работает. Все, что мы здесь делаем, — это выполняем каждое слово определения fizz-buzz?в отдельной строке. При выполнении каждой строки наблюдайте за стеком, чтобы увидеть, как он меняется:

: fizz?  3 mod 0 = dup if ." Fizz" then ;
: buzz?  5 mod 0 = dup if ." Buzz" then ;
4
dup
fizz?
swap
buzz?
or
invert

Вот как каждая строка влияет на стек:

4         4 <- ок
dup       4 4 <- ок
fizz?     4 0 <- ок
swap      0 4 <- ок
buzz?     0 0 <- ок
or        0 <- ок
invert    -1 <- ок

Помните, что последнее значение в стеке — это возвращаемое значение слова fizz-buzz?. В данном случае верно, потому что число не делилось ни на 3, ни на 5, а значит должно быть напечатано.

Вот то же самое, но начиная с 5:

5         5 <- ок
dup       5 5 <- ок
fizz?     5 0 <- ок
swap      0 5 <- ок
buzz?     0 -1 <- ок
or        -1 <- ок
invert    0 <- ок

В этом случае исходное значение вершины стека делилось на 5, поэтому ничего не нужно печатать.

Переменные и константы

Форт также позволяет сохранять значения в переменных и константах. Переменные позволяют отслеживать изменяющиеся значения, не сохраняя их в стеке. Константы дают вам простой способ сослаться на значение, которое не изменится.

Переменные

Поскольку роль локальных переменных обычно играет стек, переменные в Forth больше используются для хранения состояния, которое может понадобиться для нескольких слов.

Определить переменные просто:

variable balance

Это в основном связывает определенную ячейку памяти с именем balance. balanceтеперь является словом, и все, что он делает, — это помещает адрес ячейки памяти в стек:

variable balance
balance

Вы должны увидеть значение 1000в стеке. (в реализации EasyForth на JS) Эта реализация Forth произвольно начинает сохранять переменные в ячейке памяти 1000.

Слово !сохраняет значение в ячейке памяти, на которую ссылается переменная, и слово @извлекает значение из ячейки памяти:

variable balance
123 balance !
balance @

На этот раз вы должны увидеть значение 123в стеке. 123 balanceпомещает значение и ячейку памяти в стек и !сохраняет это значение в этой ячейке памяти. Аналогичным образом @извлекает значение на основе расположения в памяти и помещает это значение в стек. Если вы использовали C или C++, вы можете думать об balanceуказателе, который разыменовывается с помощью @.

Слово ?определяется как @ .и печатает текущее значение переменной. Это слово +!используется для увеличения значения переменной на определенную величину (как +=в языках на основе C).

variable balance
123 balance !
balance ?
50 balance +!
balance ?

Запустите этот код, и вы должны увидеть:

123 ок
173 ok

Константы

Если у вас есть значение, которое не меняется, вы можете сохранить его как константу. Константы определяются в одной строке, например:

42 constant answer

Это создает новую константу, вызываемую answerсо значением 42. В отличие от переменных, константы просто представляют значения, а не ячейки памяти, поэтому нет необходимости использовать @.

42 constant answer
2 answer *

Выполнение этого поместит значение 84в стек. answerобрабатывается так, как если бы это было число, которое оно представляет (точно так же, как константы и переменные в других языках).

Массивы

Forth не совсем поддерживает массивы, но он позволяет вам выделять место непрерывной памяти, очень похоже на массивы в C. Чтобы выделить эту память, используйте слово allot.

variable numbers
3 cells allot
10 numbers 0 cells + !
20 numbers 1 cells + !
30 numbers 2 cells + !
40 numbers 3 cells + !

В этом примере создается ячейка памяти с именем numbersи резервируются три дополнительные ячейки памяти после этой ячейки, что дает в общей сложности четыре ячейки памяти. ( cellsпросто умножается на размер ячейки, которая в этой реализации равна 1.)

numbers 0 +дает адрес первой ячейки в массиве. 10 numbers 0 + !сохраняет значение 10в первой ячейке массива.

Мы можем легко написать слова, чтобы упростить доступ к массиву:

variable numbers
3 cells allot
: number  ( offset -- addr )  cells numbers + ;

10 0 number !
20 1 number !
30 2 number !
40 3 number !

2 number ?

numberпринимает смещение numbersи возвращает адрес памяти по этому смещению. 30 2 number !сохраняет 30по смещению 2в numbers, и 2 number ?печатает значение по смещению 2в numbers.

Ввод с клавиатуры

Форт имеет специальное слово key, которое используется для ввода с клавиатуры. Когда keyслово выполняется, выполнение приостанавливается до тех пор, пока не будет нажата клавиша. После нажатия клавиши код этой клавиши помещается в стек. Попробуйте следующее:

key . key . key .

Когда вы запустите эту строку, вы заметите, что сначала ничего не происходит. Это связано с тем, что интерпретатор ожидает вашего ввода с клавиатуры. Попробуйте нажать Aклавишу, и вы должны увидеть код клавиши для этой клавиши, 65появившийся в качестве вывода в текущей строке. Теперь нажмите B, затем C, и вы должны увидеть следующее:

65 66 67 ок

Печать нажатых клавиш с begin until

Форт имеет другой вид цикла, который называется begin until. Это работает как whileцикл в языках на основе C. Каждый раз, когда попадается слово until, интерпретатор проверяет, является ли вершина стека отличной от нуля (истина). Если это так, он переходит к выполнению кода за until. Если нет, выполнение продолжается c соотетствующего begin.

Вот пример использования begin untilдля печати кодов клавиш:

: print-keycode  begin key dup . 32 = until ;
print-keycode

Это будет продолжать печатать коды клавиш, пока вы не нажмете пробел. Вы должны увидеть что-то вроде этого:

print-keycode 80 82 73 78 84 189 75 69 89 67 79 68 69 32 ок

keyждет ввода клавиши, затем dupдублирует код её полученой из key. Затем мы используем .для вывода верхней копии кода клавиши и 32 =проверяем, равен ли код клавиши 32. Если это так, мы выходим из цикла, в противном случае возвращаемся к begin.

Змейка!

Теперь пришло время собрать все воедино и сделать игру! Вместо того, чтобы вы вводили весь код, я предварительно загрузил его в редактор.

Прежде чем мы посмотрим на код, попробуйте поиграть в игру. Чтобы начать игру, выполните слово start. Затем используйте клавиши со стрелками, чтобы переместить змею. Если вы проиграете, вы можете ввести startснова.
После символа \ некоторые комментарии кода программы

<- start

variable snake-x-head  

500 cells allot  

variable snake-y-head  

500 cells allot  

variable apple-x  
variable apple-y  

0 constant left  
1 constant up  
2 constant right  
3 constant down  
24 constant width  
24 constant height  

variable direction  
variable length  

: snake-x ( offset -- address ) 
  cells snake-x-head + ;  

: snake-y ( offset -- address ) 
  cells snake-y-head + ;  ok

: convert-x-y ( x y -- offset )  24 cells * + ;  

: draw ( color x y -- )  convert-x-y graphics + ! ;  

: draw-white ( x y -- )  1 rot rot draw ;  

: draw-black ( x y -- )  0 rot rot draw ;  

: draw-walls 
  width 0 do 
    i 0 draw-black 
    i height 1 - draw-black 
  loop 
  height 0 do 
    0 i draw-black 
    width 1 - i draw-black 
  loop ;  

: initialize-snake 
  4 length ! 
  length @ 1 + 0 do 
    12 i - i snake-x ! 
    12 i snake-y ! 
  loop 
  right direction ! ;  

: set-apple-position apple-x ! apple-y ! ;  

: initialize-apple  4 4 set-apple-position ;  

: initialize 
  width 0 do 
    height 0 do 
      j i draw-white 
    loop 
  loop 
  draw-walls 
  initialize-snake 
  initialize-apple ;  
  
: move-up  -1 snake-y-head +! ;  

: move-left  -1 snake-x-head +! ;  

: move-down  1 snake-y-head +! ;  

: move-right  1 snake-x-head +! ;  

: move-snake-head  direction @ 
  left over  = if move-left else 
  up over    = if move-up else 
  right over = if move-right else 
  down over  = if move-down 
  then then then then drop ;  
  
\ Переместите каждый сегмент змеи на один шаг вперед  

: move-snake-tail  0 length @ do 
    i snake-x @ i 1 + snake-x ! 
    i snake-y @ i 1 + snake-y ! 
  -1 +loop ;  

: is-horizontal  direction @ dup 
  left = swap 
  right = or ; 

: is-vertical  direction @ dup 
  up = swap 
  down = or ;  

 : turn-up     is-horizontal if up direction ! then ;  

: turn-left   is-vertical if left direction ! then ;  

: turn-down   is-horizontal if down direction ! then ;  

: turn-right  is-vertical if right direction ! then ;  

 : change-direction ( key -- ) 
  37 over = if turn-left else 
  38 over = if turn-up else 
  39 over = if turn-right else 
  40 over = if turn-down 
  then then then then drop ;  

: check-input 
  last-key @ change-direction 
  0 last-key ! ;  

\ получить случайную позицию x или y в пределах игровой области  

: random-position ( -- pos ) 
  width 4 - random 2 + ;  

: move-apple 
  apple-x @ apple-y @ draw-white 
  random-position random-position 
  set-apple-position ;  

: grow-snake  1 length +! ;  

: check-apple 
  snake-x-head @ apple-x @ = 
  snake-y-head @ apple-y @ = 
  and if 
    move-apple 
    grow-snake 
  then ; 

: check-collision ( -- flag ) 
  \ получить текущую позицию x/y
  snake-x-head @ snake-y-head @ 
  \ получить цвет в текущей позиции 
  convert-x-y graphics + @ 
  \ оставить булевский флаг в стеке
  0 = ; 

: draw-snake 
  length @ 0 do 
    i snake-x @ i snake-y @ draw-black 
  loop 
  length @ snake-x @ 
  length @ snake-y @ 
  draw-white ;  ok

 : draw-apple 
  apple-x @ apple-y @ draw-black ;  

: game-loop ( -- ) 
  begin 
    draw-snake 
    draw-apple 
    100 sleep 
    check-input 
    move-snake-tail 
    move-snake-head 
    check-apple 
    check-collision 
  until 

  ." Game Over" ;  
  
: start  initialize game-loop ;  
  ok

Прежде чем мы слишком углубимся в этот код, два заявления об отказе от ответственности. Во-первых, это ужасный Форт-код. Я ни в коем случае не эксперт по Forth, так что, вероятно, многие вещи я делаю совершенно не так.
Во-вторых, эта игра использует несколько нестандартных методов взаимодействия с JavaScript. Я пройдусь по ним сейчас.

Нестандартные дополнения

Холст

Возможно, вы заметили, что этот "редактор" отличается от других: в него встроен элемент Canvas HTML5. Я создал очень простой интерфейс с отображением памяти для рисования на этом холсте. Холст разделен на 24 x 24 «пикселя», которые могут быть черными или белыми. Первый пиксель находится по адресу памяти, заданному переменной graphics, а остальные пиксели являются смещениями от переменной. Так, например, чтобы нарисовать белый пиксель в верхнем левом углу, вы можете запустить

1 graphics !

В игре используются следующие слова для рисования на холсте:

: convert-x-y ( x y -- offset )  24 cells * + ;
: draw ( color x y -- )  convert-x-y graphics + ! ;
: draw-white ( x y -- )  1 rot rot draw ;
: draw-black ( x y -- )  0 rot rot draw ;

Например, 3 4 draw-whiteрисует белый пиксель с координатами (3, 4). Координата y умножается на 24, чтобы получить строку, затем добавляется координата x, чтобы получить столбец.

Неблокирующий ввод с клавиатуры

Слово Форт keyблокирует ввод, поэтому не подходит для такой игры. Я добавил переменную last-key, которая всегда содержит значение последней нажатой клавиши. last-keyобновляется только тогда, когда интерпретатор выполняет код Forth.

Генерация случайных чисел

Стандарт Forth не определяет способ генерации случайных чисел, поэтому я добавил слово с именем, random ( range -- n )которое принимает диапазон и возвращает случайное число от 0 до диапазона - 1. Например, 3 randomможет возвращать 0, 1, или 2.

sleep ( ms -- )

Наконец, я добавил блокирующее sleepслово, которое приостанавливает выполнение на заданное количество миллисекунд.

Код игры

Теперь мы можем работать с кодом от начала до конца.

Переменные и константы

Начало кода просто устанавливает некоторые переменные и константы:

variable snake-x-head
500 cells allot

variable snake-y-head
500 cells allot

variable apple-x
variable apple-y

0 constant left
1 constant up
2 constant right
3 constant down

24 constant width
24 constant height

variable direction
variable length

snake-x-headи snake-y-headявляются ячейками памяти, используемыми для хранения координат x и y головы змеи. После этих двух мест выделено 500 ячеек памяти для хранения координат хвоста змеи.

Затем мы определяем два слова для доступа к ячейкам памяти, представляющим тело змеи.

: snake-x ( offset -- address )
  cells snake-x-head + ;

: snake-y ( offset -- address )
  cells snake-y-head + ;

Как и numberпредыдущее слово, эти два слова используются для доступа к элементам в массивах сегментов змеи. После этого идут слова для рисования на холсте, описанные выше.

Мы используем константы для обозначения четырех направлений ( left, up, rightи down) и переменную directionдля хранения текущего направления.

Инициализация

После этого инициализируем все:

: draw-walls
  width 0 do
    i 0 draw-black
    i height 1 - draw-black
  loop
  height 0 do
    0 i draw-black
    width 1 - i draw-black
  loop ;

: initialize-snake
  4 length !
  length @ 1 + 0 do
    12 i - i snake-x !
    12 i snake-y !
  loop
  right direction ! ;

: set-apple-position apple-x ! apple-y ! ;

: initialize-apple  4 4 set-apple-position ;

: initialize
  width 0 do
    height 0 do
      j i draw-white
    loop
  loop
  draw-walls
  initialize-snake
  initialize-apple ;

draw-wallsиспользует два do/loops для рисования горизонтальных и вертикальных стен соответственно.

initialize-snakeустанавливает lengthпеременную в 4, затем зацикливается от 0до length + 1заполнения начальных позиций змеи. Позиции змеи всегда остаются на единицу длиннее, чем длина, поэтому мы можем легко вырастить змею.

set-apple-positionи initialize-appleустановите начальное положение яблока на (4,4).

Наконец, initializeзаполняет все белым цветом и вызывает три слова инициализации.

Перемещение змеи

Вот код для перемещения змеи на основе текущего значения direction:

: move-up  -1 snake-y-head +! ;
: move-left  -1 snake-x-head +! ;
: move-down  1 snake-y-head +! ;
: move-right  1 snake-x-head +! ;

: move-snake-head  direction @
  left over  = if move-left else
  up over    = if move-up else
  right over = if move-right else
  down over  = if move-down
  then then then then drop ;

\ Переместите каждый сегмент змеи на один шаг вперед
: move-snake-tail  0 length @ do
    i snake-x @ i 1 + snake-x !
    i snake-y @ i 1 + snake-y !
  -1 +loop ;

move-up, move-left, move-down, и move-rightпросто добавьте или вычтите единицу из координат x или y головы змеи. move-snake-headпроверяет значение directionи вызывает соответствующее move-*слово. Этот over = ifшаблон представляет собой идиоматический способ выполнения операторов case в Forth.

move-snake-tailпроходит по массиву позиций змейки в обратном направлении, копируя каждое значение вперед на 1 ячейку. Это вызывается до того, как мы переместим голову змеи, чтобы переместить каждый сегмент змеи вперед на одну позицию. Он использует do/+loopвариант a do/loop, который извлекает стек на каждой итерации и добавляет это значение к следующему индексу вместо того, чтобы каждый раз увеличиваться на 1. Итак 0 length @ do -1 +loop, циклы от lengthдо 0с шагом -1.

Ввод с клавиатуры

Следующий раздел кода принимает ввод с клавиатуры и при необходимости изменяет направление змейки.

: is-horizontal  direction @ dup
  left = swap
  right = or ;

: is-vertical  direction @ dup
  up = swap
  down = or ;

: turn-up     is-horizontal if up direction ! then ;
: turn-left   is-vertical if left direction ! then ;
: turn-down   is-horizontal if down direction ! then ;
: turn-right  is-vertical if right direction ! then ;

: change-direction ( key -- )
  37 over = if turn-left else
  38 over = if turn-up else
  39 over = if turn-right else
  40 over = if turn-down
  then then then then drop ;

: check-input
  last-key @ change-direction
  0 last-key ! ;

is-horizontalи is-verticalпроверьте текущий статус переменной direction, чтобы увидеть, является ли она горизонтальным или вертикальным направлением.

Слова turn-*используются для установки нового направления, но используйте is-horizontalи is-verticalдля проверки текущего направления, чтобы убедиться, что новое направление допустимо. Например, если змея движется горизонтально, установка нового направления leftили rightне имеет смысла.

change-directionберет клавишу и называет соответствующее turn-*слово, если клавиша была одной из клавиш со стрелками. check-inputвыполняет работу по получению последней клавиши из last-keyпсевдопеременной, вызывает change-direction, затем устанавливает last-keyзначение 0, чтобы указать, что последнее нажатие клавиши было обработано.

Яблоко

Следующий код используется для проверки того, было ли яблоко съедено, и если да, то для перемещения его в новое (случайное) место. Кроме того, если яблоко было съедено, мы выращиваем змею.

\ получить случайную позицию x или y в пределах игровой области
: random-position ( -- pos )
  width 4 - random 2 + ;

: move-apple
  apple-x @ apple-y @ draw-white
  random-position random-position
  set-apple-position ;

: grow-snake  1 length +! ;

: check-apple ( -- flag )
  snake-x-head @ apple-x @ =
  snake-y-head @ apple-y @ =
  and if
    move-apple
    grow-snake
  then ;

random-positionгенерирует случайную координату x или y в диапазоне от 2до width - 2. Это предотвращает появление яблока рядом со стеной.

move-appleстирает текущее яблоко (используя draw-white), затем создает новую пару координат x/y для яблока, используя random-positionдважды. Наконец, он призывает set-apple-positionпереместить яблоко в новые координаты.

grow-snakeпросто добавляет единицу к lengthпеременной.

check-appleсравнивает координаты x/y яблока и головы змеи, чтобы увидеть, совпадают ли они (используя =дважды и andобъединяя два логических значения). Если координаты совпадают, вызываем move-appleпереместить яблоко на новую позицию и grow-snakeсделать змею на 1 сегмент длиннее.

Обнаружение столкновений

Далее мы видим, столкнулась ли змея со стенами или сама с собой.

: check-collision ( -- flag )
  \ get current x/y position
  snake-x-head @ snake-y-head @

  \ get color at current position
  convert-x-y graphics + @

  \ leave boolean flag on stack
  0 = ;

check-collisionпроверяет, является ли новая позиция головы змеи уже черной (это слово вызывается после обновления позиции змеи, но перед ее отрисовкой в новой позиции). Мы оставляем логическое значение в стеке, чтобы сказать, произошло столкновение или нет.

Рисуем змею и яблоко

Следующие два слова отвечают за рисование змеи и яблока.

: draw-snake
  length @ 0 do
    i snake-x @ i snake-y @ draw-black
  loop
  length @ snake-x @
  length @ snake-y @
  draw-white ;

: draw-apple
  apple-x @ apple-y @ draw-black ;

draw-snakeперебирает каждую ячейку в массивах змей, рисуя для каждой черный пиксель. После этого он рисует белый пиксель со смещением length. Последняя часть хвоста находится length - 1в массиве, поэтому lengthсодержит предыдущий последний сегмент хвоста.

draw-appleпросто рисует черный пиксель в текущем местоположении яблока.

Игровой цикл

Игровой цикл постоянно зацикливается до тех пор, пока не произойдет столкновение, по очереди вызывая каждое из слов, определенных выше.

: game-loop ( -- )
  begin
    draw-snake
    draw-apple
    100 sleep
    check-input
    move-snake-tail
    move-snake-head
    check-apple
    check-collision
  until
  ." Game Over" ;

: start  initialize game-loop ;

Цикл begin/untilиспользует логическое значение, возвращаемое параметром, check-collisionчтобы узнать, следует ли продолжать выполнение цикла или выйти из цикла. При выходе из цикла строка "Game Over"печатается. Мы используем 100 sleepпаузу на 100 мс на каждой итерации, заставляя игру работать со скоростью примерно 10 кадров в секунду.

startпросто вызывает initialize, чтобы сбросить все, а затем стартует game-loop. Поскольку вся инициализация происходит в initializeслове, вы можете снова вызвать startпосле окончания игры.

---

Вот и все! Надеюсь, весь код в игре имел смысл. Если нет, вы можете попробовать запустить отдельные слова, чтобы увидеть их влияние на стек и/или на переменные.

Конец

Форт на самом деле намного мощнее, чем то, чему я здесь учил (и то, что я реализовал в своем интерпретаторе). Настоящая система Forth позволяет вам изменять работу компилятора и создавать новые определяющие слова, что позволяет вам полностью настраивать вашу среду и создавать свои собственные языки в Forth.

Отличным ресурсом для изучения всей мощи Форта является короткая книга «Начало Форта» Лео Броди. Он доступен бесплатно в Интернете и на русском языке и научит вас всему интересному, что я пропустил. Также есть хороший набор упражнений, чтобы проверить свои знания. Однако вам нужно скачать копию SwiftForth , чтобы запустить код

Примечание: или другую подходящюю Форт систему на выбор из большого их ряда как, к примеру, Win32Forth, VFX Forth, SP-Forth, BigForth, gForth, kForth, pForth ...
или, к примеру, их реализации в составе какой то фантазийной игровой консоли как Retro-40 и.др.