← BLACKOUTASM StudioEN

BLACKOUT · Apple //c · 6502

Разбор кода

Как устроена игра изнутри — от включения машины до финала. В каждой главе: картинка, где лежат данные, порядок вызовов и одна-две подпрограммы построчно, на живых числах. В конце — справочник команд 6502.

Глава 0. Карта программы

Прежде чем лезть в подпрограммы, надо увидеть целое: что лежит на дискете, в каком порядке оно запускается, где что живёт в памяти и что делает главный цикл. Всё остальное — это подпрограммы, которые главный цикл вызывает через JSR.

Что на дискете

ФайлЧто этоСекторов
HELLOПрограмма на Бейсике из двух строк. DOS запускает её сама при загрузке.2
INTROЗаставка (intro.s). Сама картинок не хранит — грузит их с дискеты.6
INTRO1…7Кадры заставки, по 8 КБ — ровно одна страница HiRes, байт в байт.7 × 34
CASCADEТаблица «волны», которой гаснет сеть на заставке.3
MAINСама игра: весь код (main.s и всё, что он подключает).53
DATAГрафика, слоги имён, тексты, сообщения (data.s). Кода нет.36
LEGENDКартинка финала, 8 КБ.34
REG0…7, HEROПоявляются по ходу игры: состояние регионов и сохранение.—

Сектор — 256 байт, на дискете их 560. Видно, куда уходит место: картинки заставки и финала занимают больше, чем вся игра.

Как игра запускается

DOS 3.3Включили машину — ПЗУ читает дорожку 0, загружается DOS.
HELLOMAXFILES 1, потом BRUN INTRO.
INTROКадры заставки — командой DOS прямо в видеопамять. В конце BRUN MAIN.
LC_LOADПервое, что делает MAIN: BLOAD DATA в $2000 и перенос в скрытую память.
ПодготовкаТаблицы: строки экрана, зёрна мира, подстанция, сдвиги героя, рынок.
TITLE → циклМеню N / C / Q, потом главный цикл: клавиша → действие → кадр.

HELLO на дискете — вот он целиком:

10 PRINT CHR$(4);"MAXFILES 1"
20 PRINT CHR$(4);"BRUN INTRO"

CHR$(4) — это Ctrl-D. DOS 3.3 следит за всем, что печатается на экран, и если строка начинается с Ctrl-D — выполняет её как команду. Этим же приёмом пользуется и сама игра: печатает Ctrl-D и команду через COUT — и DOS её исполняет. Так игра грузит DATA, сохраняется и читает файлы регионов.

Зачем MAXFILES 1. По умолчанию DOS держит в памяти 3 буфера для открытых файлов, по 595 байт, и они лежат прямо под DOS. С одним буфером DOS начинается с $9AA6, а не с $9600 — и игре достаётся ещё 1 190 байт. Без этой строки код игры, который сейчас доходит до $937B, остался бы цел, но таблица LOC_GROW3 на $9980 легла бы на буферы DOS — и первая же работа с дискетой её испортила бы.

Карта памяти во время игры

У //c 64 КБ видно сразу. Вот как они поделены. Адрес слева — начало участка.

$0000–$00FF
Нулевая страницаСамые частые переменные: зерно SEED $10–$17, указатели PTR, STR. Команды с адресом в нулевой странице на байт короче и на такт быстрее.
256 Б
$0100–$01FF
СтекАдреса возврата из JSR, PHA/PLA.
256 Б
$0200–$03FF
Переменные игрыLOC_SRCH $0200 — «обыскано / был здесь» на каждую локацию; дальше всё по мелочи: страница, клавиша, герой, рынок.
512 Б
$0400–$07FF
Текстовый экран, страница 1Видны только строки 20–23 — это панель внизу под картинкой.
1 КБ
$0800–$0BFF
Текст, страница 2Копия панели (для второй графической страницы) и в «невидимых» строках — таблицы: карта экрана, рост поселений LOC_GROW, рюкзак.
1 КБ
$0C00–$13FF
WLD_TAB — зёрна региона256 локаций × 8 байт. Считается один раз при входе в регион, потом берётся мгновенно.
2 КБ
$1400–$1F97
Герой: буфер и таблицыКопия кадра со сдвигом, 7 таблиц сдвига ($1500–$1BFF), зеркало, «x → байт и сдвиг».
3 КБ
$2000–$3FFF
HiRes, страница 1При запуске сюда сначала грузится DATA — экран ещё не нужен.
8 КБ
$4000–$5FFF
HiRes, страница 2Пока видна одна страница, рисуем на другой. Ещё сюда временно читаются файлы регионов и сохранение.
8 КБ
$6000–$937B
MAIN — код игры13 180 байт. Свободно до $997F ещё ~1,5 КБ.
13 КБ
$9980–$9A7F
LOC_GROW3Рост третьего поселения в каждой локации.
256 Б
$9AA6–$BFFF
DOS 3.3Не трогать: перетрёшь — дисковод перестанет работать.
9 КБ
$C000–$CFFF
Ввод-выводНе память, а «переключатели»: обращение к адресу что-то включает. Клавиатура $C000, страницы экрана $C054/$C055, скрытая память $C080…
4 КБ
$D000–$FFFF
ПЗУ — и за ним language cardОбычно здесь видно ПЗУ: Бейсик и монитор (COUT, HOME, WAIT…). Но на тех же адресах есть ещё 16 КБ ОЗУ, которое включается переключателем. Туда при запуске переносится DATA ($D000–$F255).
12+16 КБ

Главное ограничение видно сразу: для кода есть только кусок между второй страницей графики и DOS — 14 720 байт. Поэтому всё, что не код (картинки, слоги, тексты), переехало в language card. Без неё игра бы не влезла.

Как собирается: два файла, два адреса

В проекте 34 файла, но собирается из них ровно две программы:

MAIN обращается к данным в DATA по адресам, записанным в vars.s (CHR_TAB = $D000, TILE_TAB = $DC00…). Если DATA пересобрать и что-то сдвинется — адреса разойдутся. Поэтому после любой правки DATA адреса в vars.s надо сверить с тем, где метки оказались на самом деле — ассемблер покажет их в листинге.

Правила, по которым написан весь код. Главный цикл — только JSR. У каждой подпрограммы шапка: что делает, вход, выход, что портит. Имена с префиксом модуля (WLD_… — мир, HERO_… — герой, MKT_… — рынок). Внутри подпрограмм — локальные метки с @: @loop в одной подпрограмме не мешает @loop в другой. Никаких «голых» чисел — у адресов есть имена в vars.s.

Подготовка: start

Начало main.s. Каждая строка — одна подпрограмма, у каждой своя глава.

start:
        JSR LC_LOAD             ; DATA с дискеты → language card          (глава 0, ниже)
        JSR SCR_ROWS            ; таблица «строка → адрес» для HiRes        (глава 4)
        LDA #0                  ; регион 0 — Каталония
        STA REGION
        JSR WLD_FILL            ; 256 зёрен региона в WLD_TAB                (глава 1)
        JSR SUB_INIT            ; где подстанция                             (глава 12)
        JSR HERO_PREP           ; таблицы сдвига героя                       (глава 5)
        JSR MKT_INIT            ; деньги, рюкзак, рынки                      (глава 9)
        LDA #$FF
        STA NSELF               ; проверка столкновений: «себя» нет          (глава 7)
        LDA #P_WALK
        STA WMASK               ; герою можно наступать на «проходимое»
        JSR TITLE               ; меню: N → C = 0, C (продолжить) → C = 1   (глава 15)
        BCC @newgame
        JMP @key                ; продолжили — экран уже показан, сразу в цикл

Обратите внимание на BCC после JSR TITLE. Это приём, который в игре везде: подпрограмма отвечает «да / нет» флагом переноса C. CLC перед RTS — «нет», SEC — «да», а вызывающий сразу ветвится BCC/BCS. Регистры при этом свободны для настоящих данных.

Новая игра: репутация 8 / 4 / 8 (охрана, мародёры, жители), стартовая локация $37 — это строка 3, столбец 7 на карте 16 × 16, — и переход на @enter.

Вход на экран: @enter

@enter:
        LDA #4                  ; экран 4 — центральный в квадрате 3 × 3 (0 1 2 / 3 4 5 / 6 7 8)
        STA GSCR
        JSR LOC_LOAD            ; всё о локации HERE: зерно, тип, имя, поселения
        JSR SCR_GEN             ; карта экрана: 20 × 10 номеров плиток
        JSR OBJ_CLEAR           ; убрать NPC прошлого экрана
        JSR HERO_SPAWN          ; герою — проходимое место
        JSR OBJ_GEN             ; NPC этого экрана
        LDA #0
        STA DPAGE               ; рисуем на странице 1
        STA LASTK               ; «последней клавиши» нет
        JSR SCR_CLEAR
        JSR SCR_ON              ; включить HiRes + 4 строки текста
        JSR HOME
        JSR SCR_SHOW            ; панель, обе страницы, герой

Порядок важен: сначала посчитать экран (что где стоит), потом поставить героя и NPC на свободные клетки, и только потом рисовать. Рисование ничего не решает — оно только показывает то, что уже лежит в таблицах.

Экран города: дома, деревья, герой на дороге, панель внизу
Результат @enter: верхние 160 строк — HiRes, внизу 4 строки текста (панель). Это «смешанный режим» Apple II.

Главный цикл: @key

Дальше программа крутится в одном цикле. Один оборот — одна клавиша (или её отсутствие) и один кадр.

@key:
        JSR CMB_TICK            ; отдых: здоровье понемногу растёт
        LDA KBD                 ; $C000: есть новая клавиша?
        BMI @new                ; бит 7 = 1 → да
        BIT KBDSTRB             ; $C010: бит 7 = клавиша всё ещё зажата
        BPL @none
        LDA KBD
        ORA #%10000000
        CMP LASTK               ; та же, что уже обработали?
        BEQ @walk               ; да — её держат: идём дальше
@new:
        STA LASTK
        STA KBDSTRB             ; «клавиша прочитана»
        CMP #$A0                ; пробел → рынок или обыск
        ...

Это самое хитрое место главы. Сначала — что лежит в байте клавиатуры и что делает с ним ORA, потом весь цикл на числах.

Байт клавиатуры $C000 — что в нём

бит
7
6
5
4
3
2
1
0
LDA KBD
1
0
0
1
0
1
0
1
$95 ← новая, ещё не прочитана
после STA KBDSTRB
0
0
0
1
0
1
0
1
$15 ← бит 7 погашен: «уже прочитана»

Бит 7 — флажок «есть непрочитанная клавиша». Биты 0–6 — сам код: $15 — стрелка вправо (то же, что Ctrl-U). Запись в $C010 (STA KBDSTRB) гасит флажок, код остаётся. Поэтому в цикле в A оказывается то $95, то $15 — это одна и та же клавиша, до и после «прочитал».

ORA #%10000000 — «включить бит 7»

бит
7
6
5
4
3
2
1
0
A
0
0
0
1
0
1
0
1
$15
ORA
1
0
0
0
0
0
0
0
$80
= A
1
0
0
1
0
1
0
1
$95

ORA — «ИЛИ» по каждому биту отдельно, столбиком: в ответе 1, если 1 хотя бы в одном из двух. Маска $80 — единица только в бите 7. Значит, бит 7 станет 1, а остальные 7 битов останутся как были. Так из «прочитанной» $15 снова получается $95 — в том виде, в каком она запомнена в LASTK.

бит
7
6
5
4
3
2
1
0
A
1
0
0
1
0
1
0
1
$95
AND
0
0
0
1
1
1
1
1
$1F
= A
0
0
0
1
0
1
0
1
$15

Для сравнения — AND, «И»: 1 только там, где 1 в обоих. Маска оставляет нужные биты и обнуляет остальные. В игре это «вынуть кусок байта»: AND #%00011111 — взять биты 0–4 (число 0–31), так выбираются слоги имён в главе 2. Правило на память: ORA — включает биты маски, AND — оставляет биты маски, EOR — переворачивает биты маски.

Теперь по шагам. Стрелка вправо нажата и удерживается.

СтрокаРегистрыЧто происходит
LDA KBDA = $95Стрелка вправо — код $15. Пока клавишу не «прочитали», клавиатура держит бит 7: $15 + $80 = $95. Бит 7 = 1, значит число «отрицательное».
BMI @new→ @newBMI — переход, если N = 1 (бит 7 результата). Новая клавиша.
STA LASTKLASTK = $95Запомнили, что эту уже обработали.
STA KBDSTRBЗапись в $C010 сбрасывает бит 7 в $C000. Теперь LDA KBD даст $15 — «старая».
… герой шагнул, кадр нарисован, следующий оборот цикла. Клавиша всё ещё зажата.
LDA KBDA = $15Бит 7 = 0 — новой клавиши нет.
BMI @newне прыгаем
BIT KBDSTRBN = 1У //c чтение $C010 в бите 7 говорит, зажата ли сейчас какая-нибудь клавиша (AKD — any key down). BIT кладёт бит 7 прочитанного в флаг N, не трогая A.
BPL @noneне прыгаемЗажата.
ORA #%10000000A = $95Вернули бит 7, чтобы сравнивать с тем, что лежит в LASTK.
CMP LASTK$95 = $95Та же клавиша.
BEQ @walk→ @walkЕё держат — герой идёт дальше, без автоповтора с задержкой.

Флаги и CMP — на чём держатся все «если»

У 6502 нет команды «если A = 5, то перейти». Есть две половинки: одна команда ставит флаги, следующая смотрит на флаг и прыгает или нет. Флаги — отдельный байт P, регистр состояния:

бит
7
6
5
4
3
2
1
0
P
N
V
–
B
D
I
Z
C
выделены те, что нужны почти везде

N (negative) — копия бита 7 результата. Z (zero) — результат равен нулю. C (carry) — перенос: при сложении «вылезло за 255», при сравнении — «A не меньше». Флаги ставят почти все команды, которые что-то кладут в регистр: LDA, AND, ORA, INX, DEX… А STA, JSR, BEQ — не трогают.

Так работает LDA KBD / BMI @new из цикла: LDA положил $95 в A и скопировал бит 7 в N; BMI («branch if minus») прыгает, если N = 1. А BIT KBDSTRB — особая: кладёт бит 7 прочитанного байта в N, бит 6 — в V, а A не трогает вовсе.

CMP — вычесть, но ответ выбросить

CMP LASTK считает A − LASTK, но результат никуда не записывает — A остаётся прежним. От вычитания остаются только флаги. Три случая на числах:

1. Равно: A = $95, LASTK = $95

бит
7
6
5
4
3
2
1
0
A
1
0
0
1
0
1
0
1
$95
− LASTK
1
0
0
1
0
1
0
1
$95
= (выброшено)
0
0
0
0
0
0
0
0
$00 Z = 1 (ноль) · C = 1 · N = 0

Разность 0 → Z = 1. BEQ @walk («branch if equal» = «если Z = 1») прыгает: та же клавиша, её держат.

2. A больше: A = $95, в таблице $88

бит
7
6
5
4
3
2
1
0
A
1
0
0
1
0
1
0
1
$95
− KEY_DIR,X
1
0
0
0
1
0
0
0
$88
=
0
0
0
0
1
1
0
1
$0D Z = 0 · C = 1 (займа не было) · N = 0

$95 − $88 = $0D, не ноль → Z = 0, BEQ не прыгает: «не та стрелка, смотрим дальше». C = 1 значит «A ≥ того, с чем сравнивали» — вычитание прошло без займа.

3. A меньше: A = $88, сравниваем с $95

бит
7
6
5
4
3
2
1
0
A
1
0
0
0
1
0
0
0
$88
−
1
0
0
1
0
1
0
1
$95
=
1
1
1
1
0
0
1
1
$F3 Z = 0 · C = 0 (был заём) · N = 1

$88 − $95 «не помещается» в байт: получается $F3 (как на счётчике, который прокрутился через ноль) и C = 0 — был заём. Это и есть «A меньше». N = 1 тут случайность — просто бит 7 разности, для сравнения чисел на него не смотрят.

Что можно спросить после CMP:

ПереходФлагЗначит$95 vs $95$95 vs $88$88 vs $95
BEQZ = 1A = Mпрыгаетнетнет
BNEZ = 0A ≠ Mнетпрыгаетпрыгает
BCSC = 1A ≥ Mпрыгаетпрыгаетнет
BCCC = 0A < Mнетнетпрыгает

Больше ничего и не нужно: «больше», «меньше», «равно» в любом месте игры — это CMP плюс один из этих четырёх переходов. Например, в HERO_PREP из главы 5 стоит CMP #7 / BCC — «если сдвиг меньше 7». Сравнивать можно и X, и Y: CPX, CPY работают точно так же — как CPX #6 / BNE @loop в шаге зерна (глава 1): «крутить, пока X не дошёл до 6».

Важная мелочь. Флаги живут до следующей команды, которая их ставит. Между CMP и BEQ нельзя вставить, например, LDA — он перезапишет Z, и переход будет смотреть уже на загруженное число. Поэтому в коде переход почти всегда идёт сразу за сравнением.

Зачем вся эта сложность с клавишей? Стандартный автоповтор Apple II сначала ждёт полсекунды, а потом повторяет медленно — герой бы дёргался. Здесь же «держу стрелку» читается напрямую, и герой идёт ровно, кадр за кадром. Отпустили — BIT KBDSTRB даёт N = 0, переход на @none, LASTK обнуляется, и следующее нажатие той же стрелки снова станет «новым».

Кто обрабатывает какую клавишу

КлавишаКодКуда
пробел$A0ACT_KEY — рынок в поселении, обыск вне его (глава 9)
A, W, M, I$C1 $D7 $CD $C9CMB_KEY — удар рукой, оружием, лекарство, окно статуса (строчные тоже). Возвращает C = 1, если клавиша «её» (главы 10–11)
Return$8D@map → MAP_VIEW — карта региона (глава 13)
↑ → ↓ ←$8B $95 $8A $88ищем в таблице KEY_DIR; номер 0–3 → HERO_MOVE (главы 5–6)
ничего@idle → HERO_FRAME: герой стоит, NPC ходят

Поиск стрелки — маленький образец того, как в 6502 делают «switch»: не цепочка сравнений, а таблица и цикл по ней.

@walk:
        LDX #3                  ; X = 3, 2, 1, 0
@dir:
        CMP KEY_DIR,X           ; A = код клавиши; KEY_DIR = $8B $95 $8A $88
        BEQ @go                 ; нашли: X — номер направления
        DEX
        BPL @dir                ; X стал $FF — бит 7 = 1, цикл кончился
        JMP @idle
        ...
@go:
        TXA                     ; A = направление 0–3 (↑ → ↓ ←)
        JSR HERO_MOVE
        LDA #30
        JSR WAIT                ; пауза из ПЗУ — скорость ходьбы
        JMP @key

Стрелка вправо, A = $95: X = 3 — $88, не то; X = 2 — $8A, не то; X = 1 — $95, совпало. В HERO_MOVE уходит A = 1, «вправо». Порядок ↑ → ↓ ← по часовой стрелке — один и тот же во всей игре: в выходах из экрана, в дорогах, в карте.

LC_LOAD: как DATA попадает в скрытую память

Самая первая подпрограмма. Две части: попросить DOS загрузить файл и переложить его.

LC_LOAD:
        LDX #0
@cmd:
        LDA TXT_BLOAD,X         ; $8D $84 "BLOAD DATA,A$2000" $8D 0
        BEQ @copy               ; 0 — конец строки
        JSR COUT                ; печатаем — DOS видит Ctrl-D и исполняет
        INX
        BNE @cmd
@copy:
        BIT LCWR                ; $C081 — два раза подряд:
        BIT LCWR                ; читаем ПЗУ, а пишем в скрытое ОЗУ
        ...                     ; PTR = $2000 (откуда), PTR2 = $D000 (куда)
        LDX #LC_PAGES           ; 35 страниц по 256 байт
        LDY #0
@page:
        LDA (PTR),Y
        STA (PTR2),Y
        INY
        BNE @page               ; 256 байт страницы
        INC PTR+1               ; $20 → $21: следующая страница
        INC PTR2+1              ; $D0 → $D1
        DEX
        BNE @page
        LDX #5
@vec:
        LDA $FFFA,X             ; читаем ПЗУ …
        STA $FFFA,X             ; … пишем в скрытое ОЗУ
        DEX
        BPL @vec
        BIT LCROM               ; $C082: всё как было — читаем ПЗУ
        RTS

LDA TXT_BLOAD,X — «взять байт номер X из строки»

TXT_BLOAD — не переменная, а метка: имя адреса, где ассемблер положил байты строки. В собранной MAIN это $9367. Вот как строка лежит в памяти:

$93678DReturnX = 0
$936884Ctrl-DX = 1
$9369C2BX = 2
$936ACCLX = 3
$936BCFOX = 4
$936CC1AX = 5
$936DC4DX = 6
$936EA0пробелX = 7
$936FC4DX = 8
$9370C1AX = 9
…
$937A8DReturnX = 19
$937B00конецX = 20

LDA TXT_BLOAD,X = «положи в A байт по адресу $9367 + X». Адрес в команде постоянный, меняется только X:

XАдресAДальше
0$9367 + 0 = $9367$8Dне 0 → JSR COUT печатает Return, INX
1$9367 + 1 = $9368$84печатает Ctrl-D — DOS настораживается
2$9369$C2«B»
………«LOAD DATA,A$2000»
19$937A$8DReturn — DOS исполняет команду, файл грузится
20$937B$00LDA поставил Z = 1 → BEQ @copy: строка кончилась

Откуда берётся X? Его никто не передаёт снаружи — первая строка LC_LOAD сама ставит LDX #0. Здесь X — счётчик «какой по счёту байт», а не вход подпрограммы. Вход у LC_LOAD пустой: в шапке написано только «портит: A, X, Y…».

Почему «B» — это $C2, а не $42? Экран Apple II показывает обычный текст, когда у кода символа включён бит 7. $42 + $80 = $C2. Ассемблер в .asc сам добавляет этот бит; Return — $0D + $80 = $8D, Ctrl-D — $04 + $80 = $84.

Как команда выглядит в памяти. LDA TXT_BLOAD,X — это три байта: BD 67 93. BD — код операции «LDA адрес,X», потом сам адрес задом наперёд: младший байт $67, потом старший $93. 6502 всегда хранит 16-битные адреса так — младшим байтом вперёд.

Дальше игра читает DATA так: BIT LCRAM (включить чтение скрытого ОЗУ) — несколько команд — BIT LCROM (вернуть ПЗУ). Пока скрытое ОЗУ включено, ПЗУ не видно, а значит, нельзя вызывать COUT, WAIT и прочее из ПЗУ — их там в этот момент просто нет. Это правило соблюдается во всём коде.

Глава 1. Зерно и мир

В регионе 256 локаций, у каждой есть тип, «порядок», рельеф, имя, поселения, дороги, цены. Ничего из этого не записано ни в коде, ни на дискете. Всё вычисляется из 8 байт — зерна региона. Это тот же приём, которым Elite в 1984 году уместила восемь галактик в 32 КБ BBC Micro.

В главе: где лежит зерно, как делается один шаг, как 16-битное число складывается на 8-битном процессоре, почему на локацию нужно ровно четыре шага и откуда берутся тип, порядок и рельеф.

Зерно в памяти

Зерно — четыре числа по 16 бит: S0, S1, S2, S3. Процессор умеет работать только с байтами, поэтому каждое слово занимает две ячейки: сначала младший байт, потом старший — так же, как адрес в команде BD 67 93 из главы 0. Лежит зерно в нулевой странице, по адресам $10–$17. Так выглядит зерно Каталонии сразу после WLD_INIT:

$104AS0 мл.SEED
$115AS0 ст.SEED+1
$1248S1 мл.SEED+2
$1302S1 ст.SEED+3
$1453S2 мл.SEED+4
$15B7S2 ст.SEED+5
$162ES3 мл.SEED+6
$171FS3 ст.SEED+7

Читается это так: S0 = $5A4A, S1 = $0248, S2 = $B753, S3 = $1F2E. Первые три числа — те же, что в Elite. В коде к байтам обращаются по имени SEED плюс смещение: SEED+1 — старший байт S0, SEED+7 — старший байт S3. Это не арифметика во время игры: ассемблер сам подставит $11 и $17.

Один шаг: WLD_STEP

Правило шага простое: сложить все четыре числа, сдвинуть их на одно место влево, а сумму поставить последней.

T  = S0 + S1 + S2 + S3        ; всё по модулю $10000 — перенос из 16-го бита теряется
S0 ← S1,  S1 ← S2,  S2 ← S3,  S3 ← T

Это «тетраначчи» — как Фибоначчи, только складываются четыре числа, а не два. У Elite было «трибоначчи» на трёх числах. Вот первые шаги на зерне Каталонии:

ШагS0S1S2S3Сумма→ новое S3
0$5A4A$0248$B753$1F2E$13313$3313
1$0248$B753$1F2E$3313$10BDC$0BDC
2$B753$1F2E$3313$0BDC$11570$1570
3$1F2E$3313$0BDC$1570$0738D$738D
4$3313$0BDC$1570$738D← это и есть зерно локации 1: все четыре числа новые

Видно, что сумма бывает больше $FFFF — $13313. Лишняя единица слева просто пропадает. Так и задумано: число остаётся 16-битным, а «прокрутка через ноль» перемешивает биты ещё лучше.

Сложение 16 бит на 8-битном процессоре

6502 складывает только байты. 16-битное сложение — это два сложения: сначала младшие байты, потом старшие, и между ними передаётся перенос — флаг C из главы 0. Команда ADC складывает три вещи: A + число + C. Поэтому перед первым сложением всегда стоит CLC: обнулить C, чтобы не прибавилась случайная единица.

Возьмём самое интересное место шага 0 — третье сложение. В WTMP уже лежит S0 + S1 + S2 = $13E5, прибавляем S3 = $1F2E.

Младшие байты: $E5 + $2E

бит
7
6
5
4
3
2
1
0
A = WTMP
1
1
1
0
0
1
0
1
$E5
ADC SEED+6
0
0
1
0
1
1
1
0
$2E
+ C
0
0
0
0
0
0
0
0
0 после CLC
= A
0
0
0
1
0
0
1
1
$13 и C = 1: $E5 + $2E = $113 — девятый бит ушёл в перенос

229 + 46 = 275. В байт помещается до 255, поэтому в A остаётся 275 − 256 = 19 = $13, а «лишние 256» запоминаются как C = 1.

Старшие байты: $13 + $1F + перенос

бит
7
6
5
4
3
2
1
0
A = WTMP+1
0
0
0
1
0
0
1
1
$13
ADC SEED+7
0
0
0
1
1
1
1
1
$1F
+ C
0
0
0
0
0
0
0
1
1 тот самый перенос из младших
= A
0
0
1
1
0
0
1
1
$33 C = 0

Ответ: $33 и $13 → $3313, совпадает с таблицей. Между двумя ADC нет второго CLC: перенос как раз и должен дойти до старшего байта. Если бы его стёрли, ответ получился бы $3213 — на 256 меньше.

        CLC                     ; C = 0 — только перед младшими
        LDA WTMP
        ADC SEED+6              ; младший байт S3
        STA WTMP
        LDA WTMP+1
        ADC SEED+7              ; старший байт S3 + перенос
        STA WTMP+1

LDA и STA между двумя ADC флаг C не трогают. Это важно: если бы между ними стояла команда, меняющая C (например, CMP), перенос бы потерялся.

Сдвиг слов: S0 ← S1 ← S2 ← S3

После суммы надо сдвинуть числа на одно место. Это шесть байт, которые переезжают на две ячейки влево — тот же цикл с X-счётчиком, что в LC_LOAD:

        LDX #0
@loop:
        LDA SEED+2,X           ; X = 0: берём $12 (S1 мл.) …
        STA SEED,X             ;       … кладём в $10 (S0 мл.)
        INX
        CPX #6                 ; 6 байт: X = 0…5
        BNE @loop
        LDA WTMP                ; и только теперь T → S3 ($16/$17)
        STA SEED+6
        LDA WTMP+1
        STA SEED+7

Шаг 0, до и после цикла:

$104AS0
$115A
$1248S1
$1302
$1453S2
$15B7
$162ES3
$171Fдо
$1048S0X=0
$1102X=1
$1253S1X=2
$13B7X=3
$142ES2X=4
$151FX=5
$1613S3T
$1733после

Почему T не кладут в S3 сразу после сложения? Потому что цикл сдвига читает S3 ($16/$17), чтобы перенести его в S2. Положи туда T заранее — в S2 уехало бы T вместо старого S3. Отсюда комментарий в коде: «S3 ← T — сдвиг уже сделан, иначе он затёр бы T».

Почему на локацию четыре шага и почему старшие байты

Зерно локации n — это зерно региона после 4·n шагов. Почему не одного? После одного шага у соседних локаций три числа из четырёх общие, просто сдвинутые: S1 локации n стал бы S0 локации n+1. Соседи были бы похожи. А через 4 шага все четыре числа новые — в таблице выше это хорошо видно.

Вторая тонкость — в игре берут почти только старшие байты слов. Дело в том, что младший бит суммы зависит только от младших битов слагаемых, и он повторяется очень быстро. Вот бит 0 у первых 30 сумм на зерне Каталонии:

бит 0:   10010 10010 10010 10010 10010 10010     ; повтор каждые 5 шагов
бит 1:   1000001011 1000001011 1000001011        ; каждые 10
бит 8:   11111011000101001011111110100 0
бит 13:  10010010011110110011111000011 1          ; без видимого повтора

Если бы тип локации брали из младших битов, типы шли бы по кругу: анархия, деревня, город, анархия, деревня… Старшие биты успевают «набрать» переносы со всех младших разрядов и выглядят случайными.

Что зашито в 64 бита локации

Возьмём локацию $37 — ту, где начинается игра. После 4 × 55 = 220 шагов её зерно: S0 = $BA42, S1 = $7E80, S2 = $93A3, S3 = $7586. Старшие байты: $BA $7E $93 $75. Вот что из них вынимается:

S0 старший ($BA) — тип, порядок, рельеф

бит
7
6
5
4
3
2
1
0
SEED+1
1
0
1
1
1
0
1
0
$BA
тип: AND #%11
0
0
0
0
0
0
1
0
2 0 ANARCHY · 1 RURAL · 2 INDUSTRIAL · 3 DEVELOPED
порядок
0
0
0
0
0
1
1
0
6 биты 2–4: 0 — банда, 7 — совет и охрана
рельеф
0
0
0
0
0
1
0
1
5 биты 5–7: какой фон у экранов (глава 3)

Один байт — три свойства. Тип занимает биты 0–1 (четыре варианта), порядок — биты 2–4 (восемь вариантов), рельеф — 5–7. Чтобы вынуть поле, байт сдвигают вправо, пока поле не встанет к биту 0, и обрезают маской AND.

WLD_TYPE:
        LDA SEED+1
        AND #%00000011          ; оставить биты 0–1
        RTS

WLD_ORDER:
        LDA SEED+1
        LSR A                   ; сдвиг на 2 вправо: биты 2–4 → 0–2
        LSR A
        AND #%00000111          ; оставить биты 0–2
        RTS

WLD_ORDER на $BA: два LSR и маска

бит
7
6
5
4
3
2
1
0
LDA SEED+1
1
0
1
1
1
0
1
0
$BA
LSR A
0
1
0
1
1
1
0
1
$5D все биты на шаг вправо, бит 0 (0) ушёл в C, слева пришёл 0
LSR A
0
0
1
0
1
1
1
0
$2E поле порядка теперь в битах 0–2
AND #%111
0
0
0
0
0
1
1
1
$07
= A
0
0
0
0
0
1
1
0
6 порядок 6

LSR — «logical shift right»: каждый бит переезжает на место правее, бит 0 выпадает во флаг C, в бит 7 входит 0. Один LSR — это деление на 2 без остатка. Его пара ASL сдвигает влево и умножает на 2 — понадобится ниже.

Остальные старшие байты, коротко — подробно каждый в своей главе:

БайтУ $37БитыЧто значитГлава
SEED+3 (S1 ст.)$7E0–4 · 5 · 4–7начало имени (30 = QUINTA) · есть ли середина (да) · что делают на рынке2, 9
SEED+5 (S2 ст.)$930–4 · 4–7 · всёсередина имени (19 = MA) · что нужно рынку · смесь для генератора экранов2, 3, 9
SEED+7 (S3 ст.)$750–4 · всёокончание имени (21 = TERA) · смесь для генератора экранов2, 3
младшие байты$42 $80 $A3 $86смешиваются со старшими (EOR): на каком из 9 экранов стоят поселения3

QUINTA + MA + TERA, INDUSTRIAL — ровно то, что видно на панели в игре. Поля перекрываются (биты 4–5 байта S1 нужны и имени, и рынку), но это не страшно: свойства просто чуть связаны между собой, а в игре это незаметно.

Таблица мира: WLD_FILL

Делать 4·n шагов каждый раз, когда нужна локация n, — долго: для локации 255 это 1 020 вызовов WLD_STEP. Поэтому при входе в регион WLD_FILL один раз проходит все 256 локаций и складывает их зёрна в таблицу WLD_TAB по 8 байт: 2 КБ, $0C00–$13FF. На 1 МГц это около 0,15 секунды.

WLD_FILL:
        JSR WLD_INIT            ; SEED = зерно региона = локация 0
        LDA #<WLD_TAB           ; PTR = $0C00: младший байт $00 …
        STA PTR
        LDA #>WLD_TAB           ; … и старший $0C
        STA PTR+1
        LDA #0
        STA WCNT                ; счётчик локаций
@loc:
        LDY #0
@byte:
        LDA SEED,Y              ; 8 байт зерна …
        STA (PTR),Y            ; … в таблицу по указателю
        INY
        CPY #8
        BNE @byte
        CLC                     ; PTR = PTR + 8 (16 бит)
        LDA PTR
        ADC #8
        STA PTR
        LDA PTR+1
        ADC #0                  ; к старшему — только перенос
        STA PTR+1
        JSR WLD_STEP            ; следующая локация — 4 шага
        JSR WLD_STEP
        JSR WLD_STEP
        JSR WLD_STEP
        INC WCNT
        BNE @loc                ; 256 кругов: после 255 INC даёт 0
        RTS

Здесь три новые мелочи.

#<WLD_TAB и #>WLD_TAB. WLD_TAB = $0C00 — 16-битное число, а в A влезает только байт. Значок < говорит ассемблеру «возьми младший байт» ($00), > — «старший» ($0C). Так в две команды в пару ячеек PTR/PTR+1 ($06/$07) кладётся адрес.

STA (PTR),Y — запись по указателю. Сравните с LDA TXT_BLOAD,X из главы 0: там адрес был вшит в команду. Здесь в команде только номер ячейки нулевой страницы, где лежит адрес. Процессор сначала читает два байта из $06/$07, собирает из них адрес, прибавляет Y — и только тогда пишет. Указатель можно двигать, не меняя команду: так одна и та же STA (PTR),Y пишет и в локацию 0, и в 255.

$0608PTRмл.
$070CPTR+1ст.
→
$0C0813Y=0
$0C0933Y=1
$0C0ADCY=2
…
$0C0F73Y=7

Пример — второй круг (локация 1, зерно $3313 $0BDC $1570 $738D): в PTR уже $0C08. STA (PTR),Y при Y = 0 пишет $13 в $0C08 + 0, при Y = 7 — $73 в $0C0F. Скобки в записи и означают «адрес лежит там».

ADC #0 к старшему байту. Прибавить 8 к 16-битному числу: младший байт + 8, старший + 0 + перенос. Пока младший не переполнился ($00, $08, …, $F8), перенос 0 и старший байт стоит на месте. На 32-м круге $F8 + 8 = $100 → младший $00, C = 1, и ADC #0 превращает старший $0C в $0D. Это то же сложение «столбиком», что в шаге зерна, только второе слагаемое — $0008.

INC WCNT / BNE @loc. Счётчик начинается с 0. Байт не бывает больше 255: после 255 INC даёт 0 и ставит Z = 1. Значит, BNE отпустит цикл ровно после 256 кругов — без отдельного «CMP #256», которое в байт и не записать.

Достать зерно: WLD_GET и умножение на 8 сдвигами

Когда герой входит в локацию n, WLD_GET копирует её 8 байт из таблицы в SEED. Адрес = $0C00 + n × 8. Умножать 6502 не умеет, но умеет сдвигать: ASL — это ×2, три раза — ×8. Проблема в том, что n × 8 может быть больше 255 ($37 × 8 = $1B8), а A — один байт. Выпавший слева бит надо поймать:

WLD_GET:
        LDX #0
        STX PTR+1         ; старший байт = 0
        ASL A             ; ×2, бит 7 → C
        ROL PTR+1         ;     C → бит 0 старшего байта
        ASL A             ; ×4
        ROL PTR+1
        ASL A             ; ×8
        ROL PTR+1
        STA PTR           ; младший байт n × 8
        ...               ; + WLD_TAB, потом 8 байт (PTR),Y → SEED

n = $37: три ASL / ROL

бит
7
6
5
4
3
2
1
0
A = n
0
0
1
1
0
1
1
1
$37
PTR+1
0
0
0
0
0
0
0
0
$00
ASL A
0
1
1
0
1
1
1
0
$6E вылетел бит 7 = 0 → C = 0
ROL PTR+1
0
0
0
0
0
0
0
0
$00 C (0) вошёл в бит 0
ASL A
1
1
0
1
1
1
0
0
$DC вылетел 0 → C = 0
ROL PTR+1
0
0
0
0
0
0
0
0
$00
ASL A
1
0
1
1
1
0
0
0
$B8 вылетела 1 → C = 1
ROL PTR+1
0
0
0
0
0
0
0
1
$01 C (1) вошёл в бит 0

Итог: PTR+1 = $01, PTR = $B8 → $01B8 = 440 = 55 × 8. Верно. ROL («rotate left») отличается от ASL одним: в бит 0 входит не 0, а старое значение C. Пара ASL A / ROL PTR+1 работает как один 16-битный сдвиг: бит, выпавший из младшего байта, через C переезжает в старший.

Дальше + WLD_TAB — обычное 16-битное сложение: $01B8 + $0C00 = $0DB8. По этому адресу в таблице лежит зерно $37: $42 $BA $80 $7E $A3 $93 $86 $75.

Соседи на карте: номер = строка × 16 + столбец

Регион — сетка 16 × 16, и номер локации устроен очень удобно: старшие 4 бита — строка, младшие 4 — столбец. Шестнадцатеричная запись прямо показывает координаты.

0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
0
00
01
02
03
04
05
06
07
08
09
0A
0B
0C
0D
0E
0F
1
10
11
12
13
14
15
16
17
18
19
1A
1B
1C
1D
1E
1F
2
20
21
22
23
24
25
26
27↑ $27 = −16
28
29
2A
2B
2C
2D
2E
2F
3
30
31
32
33
34
35
36← $36 = −1
37
38→ $38 = +1
39
3A
3B
3C
3D
3E
3F
4
40
41
42
43
44
45
46
47↓ $47 = +16
48
49
4A
4B
4C
4D
4E
4F
5
50
51
52
53
54
55
56
57
58
59
5A
5B
5C
5D
5E
5F
6
60
61
62
63
64
65
66
67
68
69
6A
6B
6C
6D
6E
6F
7
70
71
72
73
74
75
76
77
78
79
7A
7B
7C
7D
7E
7F
8
80
81
82
83
84
85
86
87
88
89
8A
8B
8C
8D
8E
8F
9
90
91
92
93
94
95
96
97
98
99
9A
9B
9C
9D
9E
9F
A
A0
A1
A2
A3
A4
A5
A6
A7
A8
A9
AA
AB
AC
AD
AE
AF
B
B0
B1
B2
B3
B4
B5
B6
B7
B8
B9
BA
BB
BC
BD
BE
BF
C
C0
C1
C2
C3
C4
C5
C6
C7
C8
C9
CA
CB
CC
CD
CE
CF
D
D0
D1
D2
D3
D4
D5
D6
D7
D8
D9
DA
DB
DC
DD
DE
DF
E
E0
E1
E2
E3
E4
E5
E6
E7
E8
E9
EA
EB
EC
ED
EE
EF
F
F0
F1
F2
F3
F4
F5
F6
F7
F8
F9
FA
FB
FC
FD
FE
FF
$37 — строка 3, столбец 7: все четыре соседа есть. Вправо +1, влево −1, вниз +16, вверх −16.
0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
0
00
01
02
03
04
05
06
07
08
09
0A
0B
0C
0D
0E
0F
1
10
11
12
13
14
15
16
17
18
19
1A
1B
1C
1D
1E
1F
2
20
21
22
23
24
25
26
27
28
29
2A
2B
2C
2D
2E
2F↑ $2F
3
30
31
32
33
34
35
36
37
38
39
3A
3B
3C
3D
3E← $3E
3F
4
40$3F+1 = $40 ✗
41
42
43
44
45
46
47
48
49
4A
4B
4C
4D
4E
4F↓ $4F
5
50
51
52
53
54
55
56
57
58
59
5A
5B
5C
5D
5E
5F
6
60
61
62
63
64
65
66
67
68
69
6A
6B
6C
6D
6E
6F
7
70
71
72
73
74
75
76
77
78
79
7A
7B
7C
7D
7E
7F
8
80
81
82
83
84
85
86
87
88
89
8A
8B
8C
8D
8E
8F
9
90
91
92
93
94
95
96
97
98
99
9A
9B
9C
9D
9E
9F
A
A0
A1
A2
A3
A4
A5
A6
A7
A8
A9
AA
AB
AC
AD
AE
AF
B
B0
B1
B2
B3
B4
B5
B6
B7
B8
B9
BA
BB
BC
BD
BE
BF
C
C0
C1
C2
C3
C4
C5
C6
C7
C8
C9
CA
CB
CC
CD
CE
CF
D
D0
D1
D2
D3
D4
D5
D6
D7
D8
D9
DA
DB
DC
DD
DE
DF
E
E0
E1
E2
E3
E4
E5
E6
E7
E8
E9
EA
EB
EC
ED
EE
EF
F
F0
F1
F2
F3
F4
F5
F6
F7
F8
F9
FA
FB
FC
FD
FE
FF
$3F — правый край (столбец F). Вверх, вниз, влево — как обычно. А «+1» дал бы $40 — это уже следующая строка, у левого края. Поэтому WLD_RIGHT сначала проверяет столбец.

$37 — строка 3, столбец 7

бит
7
6
5
4
3
2
1
0
n
0
0
1
1
0
1
1
1
$37 слева 0011 = строка 3, справа 0111 = столбец 7
AND #%1111
0
0
0
0
1
1
1
1
$0F
= столбец
0
0
0
0
0
1
1
1
7 не 15 → справа есть сосед

Отсюда все четыре соседа: вправо — n + 1 ($38), влево — n − 1 ($36), вниз — n + 16 ($47), вверх — n − 16 ($27). А край карты — это столбец 15 (справа), столбец 0 (слева), n ≥ 240 (нижняя строка), n < 16 (верхняя).

WLD_RIGHT:
        STA WTMP          ; запомнить n
        AND #%00001111    ; столбец
        CMP #15
        BEQ @edge         ; правый край
        LDA WTMP
        CLC
        ADC #1            ; n + 1
        CLC               ; ответ: можно
        RTS
@edge:
        LDA WTMP          ; номер не меняется
        SEC               ; ответ: край
        RTS

Снова ответ флагом C, как TITLE в главе 0: C = 0 — «можно, вот номер», C = 1 — «край». Обратите внимание на два CLC: первый — перед сложением (чтобы не прибавилась лишняя 1), второй — уже как ответ, потому что ADC мог оставить в C что угодно. У WLD_DOWN проверка края другая — CMP #240 / BCS @edge: «если n ≥ 240» — это строка «BCS = A ≥ M» из таблицы переходов главы 0.

Восемь регионов: WLD_INIT

У каждого региона своё зерно в таблице REG_SEEDS (в region.s), 8 байт подряд. WLD_INIT копирует нужные 8 байт в SEED:

WLD_INIT:
        LDA REGION              ; 0–7
        ASL A                   ; × 8: начало зерна в таблице
        ASL A
        ASL A
        TAY                     ; Y = 0, 8, 16 … 56
        LDX #0
@loop:
        LDA REG_SEEDS,Y         ; читаем со своего места таблицы …
        STA SEED,X             ; … пишем с начала SEED
        INY
        INX
        CPX #8
        BNE @loop
        RTS

Здесь два индекса сразу: Y — где читать (Арагон, REGION = 1, начинается с Y = 8), X — куда писать (всегда с 0). Тут ASL не нужна пара ROL: 7 × 8 = 56 помещается в байт. Зёрна регионов подобраны вручную, кроме Каталонии — у неё в начале числа Elite. Сменили регион — снова WLD_FILL, и 256 новых локаций готовы.

Глава 2. Имена из слогов

У каждой из 2 048 локаций есть имя — VILLAZAR, BENADILLA, QUINTAMATERA. Ни одно не записано. Имя собирается из кусочков по битам зерна, каждый раз заново, когда его надо напечатать: на панели, на карте, на рынке.

Elite называла планеты парами букв: LAVE, DISO, RIEDQUAT. Здесь кусочки длиннее — испанские по звучанию слоги, и их три вида: начало, середина (бывает не всегда) и окончание. По 32 штуки каждого.

Три таблицы по 32 кусочка

Подсвечены кусочки стартовой локации $37. Маленькая цифра — номер кусочка (зачем середины начинаются с 32, а окончания с 64 — ниже).

Начала, 0–31

0SAN1VAL2VILLA3ALCA4TORRE5MON6CAR7BAR8PUEBLA9CASA10ARRO11BENA12GRANA13LOS14MAR15SOTO16ALBA17MEDI18PENA19FUEN20CAMPO21OLI22ROBLE23SALA24CUEVA25LAGU26HOR27NAVA28PALO29ESPI30QUINTA31RIVA

Середины, 32–63

32TA33RE34LA35MO36NI37DE38RI39BE40GA41LO42TO43RA44SE45CO46NA47VE48LLE49BI50DU51MA52PI53SO54TI55CA56RU57DI58BO59NO60LU61JE62FE63GO

Окончания, 64–95

64REJO65LLA66DA67NES68RA69TOS70LAR71DO72SA73NA74RES75LLO76GA77CIA78TE79JAR80NUEVA81MOR82LES83DILLA84RAL85TERA86NAS87DERA88LEJA89VAL90CINA91DOSA92RIA93TAL94LON95ZAR

Начало + окончание даёт 32 × 32 = 1 024 имени, с серединой — ещё 32 × 32 × 32 = 32 768. В Каталонии из 256 локаций 252 имени разные, совпадений всего четыре пары (OLITERA, BARVAL, CUEVANAS…). Самое длинное имя — 12 букв, как раз QUINTAMATERA.

Какие биты какой кусочек выбирают

Из главы 1: у локации $37 старшие байты зерна $BA $7E $93 $75. Тип и порядок брались из первого. Имя — из трёх остальных:

SEED+3 = $7E — начало и «есть ли середина»

бит
7
6
5
4
3
2
1
0
SEED+3
0
1
1
1
1
1
1
0
$7E
AND #%00011111
0
0
0
1
1
1
1
1
$1F
= начало
0
0
0
1
1
1
1
0
30 → QUINTA
SEED+3
0
1
1
1
1
1
1
0
$7E
AND #%00100000
0
0
1
0
0
0
0
0
$20
=
0
0
1
0
0
0
0
0
$20 не ноль → Z = 0, BEQ не прыгает: середина есть

Одна маска — пять битов (0–4), число 0–31. Вторая маска — один бит 5, и тут важно не само число, а «ноль или не ноль»: AND ставит флаг Z, и сразу за ним BEQ @noMid решает, пропускать ли середину. Бит 5 — это «подбросить монетку»: примерно у половины мест середины нет.

SEED+5 = $93 и SEED+7 = $75 — середина и окончание

бит
7
6
5
4
3
2
1
0
SEED+5
1
0
0
1
0
0
1
1
$93
AND #%00011111
0
0
0
1
1
1
1
1
= середина
0
0
0
1
0
0
1
1
19 → MA
SEED+7
0
1
1
1
0
1
0
1
$75
AND #%00011111
0
0
0
1
1
1
1
1
= окончание
0
0
0
1
0
1
0
1
21 → TERA

QUINTA + MA + TERA = QUINTAMATERA. Ровно то, что на панели в игре.

NAM_PRINT: имя целиком

NAM_PRINT:
        LDA SEED+3              ; начало: биты 0–4 ст. байта S1
        AND #%00011111          ; n = 0–31
        JSR NAM_PART            ; напечатать кусочек номер A

        LDA SEED+3              ; середина есть? бит 5 ст. байта S1
        AND #%00100000
        BEQ @noMid              ; 0 — бита нет

        LDA SEED+5              ; середина: биты 0–4 ст. байта S2, номер 32 + n
        AND #%00011111
        ORA #%00100000          ; + 32
        JSR NAM_PART
@noMid:
        LDA SEED+7              ; окончание: биты 0–4 ст. байта S3, номер 64 + n
        AND #%00011111
        ORA #%01000000          ; + 64
        JSR NAM_PART
        RTS

NAM_PART принимает один номер 0–95 и сам знает, в какой таблице искать. Поэтому середину превращают в 32 + n, а окончание — в 64 + n. И делают это не сложением, а ORA:

ORA вместо сложения: 19 → 51, 21 → 85

бит
7
6
5
4
3
2
1
0
A = 19
0
0
0
1
0
0
1
1
$13
ORA #%00100000
0
0
1
0
0
0
0
0
$20
= 51
0
0
1
1
0
0
1
1
$33 32 + 19
A = 21
0
0
0
1
0
1
0
1
$15
ORA #%01000000
0
1
0
0
0
0
0
0
$40
= 85
0
1
0
1
0
1
0
1
$55 64 + 21

После AND #%00011111 биты 5–7 гарантированно нули. Включить в пустой бит единицу — то же самое, что прибавить его вес: бит 5 весит 32, бит 6 — 64. Зато ORA не нужен CLC и он не трогает флаг C. Это частый приём: если знаешь, что бит свободен, «+ 32» пишется как «включи бит 5».

Где лежат слоги: строки и таблица адресов

Всё это — в namedata.s, который входит в DATA и при запуске уезжает в скрытую память (глава 0). Сначала подряд идут сами слоги, каждый — буквы и байт 0 в конце. Вот QUINTA:

$E90AD1QNS30
$E90BD5U
$E90CC9I
$E90DCEN
$E90ED4T
$E90FC1A
$E91000конец
$E911D2RNS31: RIVA

Слоги разной длины, поэтому «слог номер 30» нельзя найти умножением. Для этого после слогов стоят три таблицы адресов: в каждой 32 адреса по 2 байта — где начинается кусочек. Ассемблер сам подставит адреса меток:

NM_START:                  ; начала — $E9FA
        .word NS0, NS1, NS2 … NS31
NM_MID:                    ; середины — $EA3A = $E9FA + 64
        .word NM0, NM1 … NM31
NM_END:                    ; окончания — $EA7A = $E9FA + 128
        .word NE0, NE1 … NE31

Таблицы стоят вплотную: 32 адреса × 2 байта = 64 байта, и следующая таблица начинается сразу за предыдущей. Поэтому три таблицы — это на самом деле одна, на 96 адресов. Номер 0–31 попадает в начала, 32–63 — в середины, 64–95 — в окончания. Ради этого и были «+ 32» и «+ 64».

$EA360A№30 мл.NM_START+60
$EA37E9№30 ст.→ $E90A QUINTA
…
$EA6050№51 мл.NM_START+102
$EA61E9№51 ст.→ $E950 MA
…
$EAA4C9№85 мл.NM_START+170
$EAA5E9№85 ст.→ $E9C9 TERA

NAM_PART: номер → адрес → печать

NAM_PART:
        ASL A               ; ×2 — адреса по 2 байта (95 × 2 = 190, влезает в X)
        TAX
        BIT LCRAM           ; таблица — в скрытой памяти
        LDA NM_START,X      ; младший байт адреса кусочка
        STA STR
        LDA NM_START+1,X    ; старший байт
        STA STR+1
        BIT LCROM
        JSR HUD_PUTS         ; напечатать строку по адресу STR
        RTS
СтрокаРегистрыЧто происходит (кусочек 30 — QUINTA)
ASL AA = 60 ($3C)Каждый адрес — 2 байта, значит, адрес кусочка 30 начинается с 60-го байта таблицы.
TAXX = $3CНомер байта — в X, чтобы взять его как индекс.
BIT LCRAMВключили скрытую память: теперь $D000–$FFFF — это DATA, а не ПЗУ.
LDA NM_START,XA = $0AБайт по адресу $E9FA + $3C = $EA36.
STA STR$08 = $0A
LDA NM_START+1,XA = $E9Следующий байт, $EA37. NM_START+1 — тот же приём, что SEED+1: ассемблер сам подставит $E9FB.
STA STR+1$09 = $E9В STR теперь адрес $E90A — там «QUINTA».
BIT LCROMВернули ПЗУ: дальше будет COUT, а он живёт в ПЗУ.
JSR HUD_PUTSПечать строки по адресу из STR — до байта 0.

Сколько всего кусочков можно так завести? ASL A умножает на 2 внутри одного байта: 95 × 2 = 190 — помещается. Предел — 128 кусочков (127 × 2 = 254). Номер 128 дал бы 256, а это уже не байт: пришлось бы делать 16-битный указатель, как в WLD_GET.

HUD_PUTS: печать строки из скрытой памяти

HUD_PUTS:
        LDY #0
@loop:
        BIT LCRAM               ; строка может лежать в скрытой памяти …
        LDA (STR),Y            ; символ по указателю
        BIT LCROM               ; … а COUT — в ПЗУ
        CMP #0                  ; (BIT испортил флаг Z)
        BEQ @done               ; 0 — конец
        JSR COUT                ; COUT не портит Y
        INY
        BNE @loop
@done:
        RTS

Тот же цикл, что в LC_LOAD, только по указателю: LDA (STR),Y берёт адрес из $08/$09 — $E90A — и прибавляет Y. Две мелочи, на которых тут легко ошибиться:

Где имя печатается: walk.s — панель внизу экрана, mapview.s — строка под картой, когда курсор стоит на клетке, market.s — заголовок рынка. Везде одно и то же: WLD_GET кладёт зерно нужной локации в SEED, потом JSR NAM_PRINT.

Глава 3. Экран из зерна

Локация — это квадрат 3 × 3 экрана. Экран — 20 × 10 клеток-плиток по 14 × 16 точек. Ни одна клетка не хранится: когда герой входит на экран, программа заново собирает его карту из зерна локации и номера экрана. Один и тот же экран всегда выходит одинаковым — до плитки.

Вот все девять экранов стартовой локации $37, как они выглядят в игре. Дорога проходит сквозь швы — на экране 0 она уходит вправо и вниз, на экране 1 продолжается. Как программа об этом договаривается, хотя каждый экран строится отдельно, — главный вопрос этой главы.

Девять экранов локации QUINTAMATERA, 3 на 3
Локация $37 QUINTAMATERA: экраны 0–8. Город уровня 6 на экране 3, две промзоны — на экранах 1 и 4.

Два этажа: локация и экран

Работа делится на две части. Одна делается один раз при входе в локацию, другая — на каждом экране.

КогдаПодпрограммаЧто решаетКуда кладёт
вход в локацию
LOC_LOAD
LOC_ROLESна каких из 9 экранов стоят 3 поселенияLOC_ROLE, SET_SCR
LOC_SETTLвид и уровень каждого поселенияSET_KIND, SET_LVL
LOC_EXITSк каким соседним локациям есть дорогаGOUT
LOC_ROADSкакие швы между экранами — дорогаGROAD (2 байта)
+ LOC_GROWN (рост от игрока, глава 9) и SUB_LOC (подстанция, глава 12)
каждый экран
SCR_GEN
GEN_SEEDзавести генератор случайных чисел этого экранаRND
GEN_SCREENфон по рельефу: 200 клетокSCR_MAP
GEN_ROADдорога от центра к выходамSCR_MAP
GEN_SETTLдома поселения — штампами по шаблонуSCR_MAP
GEN_POIодна находка в окрестностях: аптека, машина, лагерь…SCR_MAP
SUB_GENдвор подстанции, если это её экранSCR_MAP

Всё, что должно совпадать на соседних экранах, — дороги через швы — решается на первом этаже, для всей локации сразу. Тогда экран 0 и экран 1, которые строятся в разное время, читают одну и ту же таблицу швов и не могут разойтись.

Результат второго этажа — SCR_MAP: 200 байт по адресу $0800, номер плитки на каждую клетку, строка за строкой. Номер клетки = строка × 20 + столбец. Рисование (глава 4) просто идёт по этим 200 номерам и рисует картинку каждой плитки. Вот SCR_MAP экрана 4:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
0
6
49
49
49
49
49
1
1
6
7
21
6
7
49
49
49
49
49
1
1
1
1
50
50
50
50
50
6
66
6
1
21
1
1
50
50
50
50
50
1
1
2
1
50
50
51
50
50
1
1
1
1
21
6
7
50
50
51
50
50
1
1
3
1
1
1
97
1
1
1
1
1
1
21
1
1
7
1
97
6
7
1
6
4
26
26
26
26
26
26
26
26
26
26
25
1
1
1
1
7
1
1
1
1
5
6
49
49
49
49
49
1
1
1
1
1
7
1
6
7
1
6
6
1
1
6
7
50
50
50
50
50
1
52
52
7
1
1
1
52
52
1
66
66
1
1
7
1
50
50
51
50
50
1
52
52
1
1
1
1
52
52
1
66
1
1
1
8
7
1
1
97
1
1
7
1
6
6
1
1
1
6
6
6
7
1
1
1
9
1
1
1
1
1
1
1
1
1
1
1
1
1
6
56
57
7
1
6
6
0–15 природа16–31 дороги32–63 постройки64–79 руины80–95 техника96–111 тропинки
Экран 4: промзона, дорога сверху и слева
Тот же экран 4 на мониторе. 1 — сушь, 6 — камни, 7 — обрыв (рельеф «скалы»), 49 / 50 / 51 — цех: пилообразная крыша, стены, ворота; 52 — цистерны, 56 57 — грузовик, 66 — обломки, 21 / 25 / 26 — дорога, 97 — тропинка от ворот. Клетка 90 (строка 4, столбец 10) — центр, через него идёт любая дорога.

LOC_ROLES: где стоят поселения

В каждой локации ровно три поселения, и для каждого надо выбрать экран 0–8. Берутся младшие байты зерна — те самые, что «повторяются быстро» (глава 1). Чтобы спасти их, каждый смешивается со старшим байтом следующего слова командой EOR:

        TXA                     ; X = поселение 0, 1, 2
        ASL A
        TAY                     ; Y = 0, 2, 4
        LDA SEED,Y              ; младший байт слова
        EOR SEED+3,Y            ; × старший байт следующего
        LSR A                   ; старшие 4 бита → 0–15
        LSR A
        LSR A
        LSR A
        CMP #9
        BCC @scr                ; 0–8 — готово
        SEC
        SBC #9                  ; 9–15 → 0–6

Зерно $37 в памяти: $42 $BA $80 $7E $A3 $93 $86 $75. Поселение 1 (Y = 0) — байты SEED+0 и SEED+3:

EOR: $42 × $7E → экран 3

бит
7
6
5
4
3
2
1
0
SEED+0
0
1
0
0
0
0
1
0
$42
EOR SEED+3
0
1
1
1
1
1
1
0
$7E
= A
0
0
1
1
1
1
0
0
$3C
4 × LSR
0
0
0
0
0
0
1
1
3 старшие 4 бита → 0–15; 3 < 9 → экран 3

EOR — «исключающее ИЛИ»: в ответе 1 там, где биты разные. Это третья логическая команда к AND и ORA из главы 0. Главное её свойство — она ничего не теряет: каждый бит ответа зависит от обоих байтов. Поэтому она хороша для «перемешать два числа».

Поселение 3: $A3 × $75 → 13 → экран 4

бит
7
6
5
4
3
2
1
0
SEED+4
1
0
1
0
0
0
1
1
$A3
EOR SEED+7
0
1
1
1
0
1
0
1
$75
= A
1
1
0
1
0
1
1
0
$D6
4 × LSR
0
0
0
0
1
1
0
1
13 13 ≥ 9
SBC #9
0
0
0
0
0
1
0
0
4 → экран 4

Четыре бита дают 0–15, а экранов только 9. Числа 9–15 «заворачиваются»: −9, получается 0–6. Перед SBC стоит SEC — это зеркало CLC перед ADC: при вычитании флаг C означает «заёма нет», и его надо поставить в 1, иначе вычтется лишняя единица.

Поселение 2: $80 × $93 = $13 → 1 → экран 1. Итого: поселение 1 — экран 3, поселение 2 — экран 1, поселение 3 — экран 4. Ровно как на картинке.

Что если два поселения выпадут на один экран? За этим следит цикл @busy: если LOC_ROLE экрана уже не 0 — пробуем следующий экран, после 8 — снова 0. Свободный найдётся всегда: поселений три, экранов девять.

LOC_SETTL: вид и уровень

Вид зависит только от типа локации — по таблице KIND_TAB, строка на тип:

KIND_TAB:                       ; поселение 1, 2, 3, запас
        .byte 3, 3, 3, 0        ; 0 анархия:      лагерь × 3
        .byte 0, 0, 0, 0        ; 1 сельская:     село × 3
        .byte 1, 2, 2, 0        ; 2 промышленная: город + промзона × 2   ← $37
        .byte 1, 0, 0, 0        ; 3 развитая:     город + село × 2

Строка таблицы — 4 байта, поэтому номер строки = тип × 4 (ASL ASL), а байт = тип × 4 + номер поселения. Четвёртый байт «запас» не нужен, но с ним строка ровно 4 байта и умножать можно сдвигом, а не сложением на 3.

Уровень = порядок / 2 + ещё два бита из того же перемешанного байта (биты 2–3). У $37 порядок 6, значит база 3:

ПоселениеБайт EORБиты 2–3УровеньВ игре
1 (экран 3)$3C = 0011 110011 = 33 + 3 = 6SETTLEMENT 1 TOWN LV 6
2 (экран 1)$13 = 0001 001100 = 03 + 0 = 3SETTLEMENT 2 WORKS LV 3
3 (экран 4)$D6 = 1101 011001 = 13 + 1 = 4SETTLEMENT 3 WORKS LV 4

Один байт зерна работает дважды: биты 4–7 решили, где поселение, биты 2–3 — насколько оно развито. Так из 64 бит выжимается больше свойств.

LOC_EXITS: дорога к соседней локации

Есть ли дорога из $37 вверх, в $27? Решить это надо так, чтобы обе локации ответили одинаково: если в $37 дорога уходит вверх, то в $27 она обязана приходить снизу. Иначе герой выйдет на дорогу и окажется в поле.

Решение: смешать EOR один и тот же байт зерна обеих локаций. Для вертикальных соседей — байт 5, для горизонтальных — байт 7. Если два младших бита вышли 00 — дороги нет (1 случай из 4), иначе есть.

$37 ↑ $27: байт 5 соседа × байт 5 своей локации

бит
7
6
5
4
3
2
1
0
$27: SEED+5
0
1
1
1
1
0
0
1
$79
EOR $37: SEED+5
1
0
0
1
0
0
1
1
$93
= A
1
1
1
0
1
0
1
0
$EA
AND #%11
0
0
0
0
0
0
1
0
2 не 0 → выход вверх есть, GOUT = 1

Магия в том, что EOR не важно, кто первый: $79 EOR $93 = $93 EOR $79. Когда игра будет строить $27 и спросит про соседа снизу, она посчитает тот же самый $EA — и тоже скажет «дорога есть». Договорённость без хранения.

У $37 остальные три пары дают 00: вниз $0B × $93 = $98, вправо $95 × $75 = $E0, влево $A9 × $75 = $DC — у всех младшие биты 00. Итог: GOUT = 1, выход только вверх. Выход к соседу всегда на среднем экране стороны: вверх — экран 1, вправо — 5, вниз — 7, влево — 3 (таблица OUT_SCR).

LOC_ROADS: дороги «буквой Г» и швы

Дороги внутри локации соединяют поселения по цепочке 1 → 2 → 3, и каждый выход к соседу — с поселением 1. Путь с экрана на экран — «буквой Г»: сначала по строке до нужного столбца, потом по столбцу (ROAD_PATH). Каждый шаг включает шов между двумя экранами.

Швов в квадрате 3 × 3 двенадцать: 6 горизонтальных (между экранами в строке) и 6 вертикальных. Всё хранится в двух байтах GROAD: байт 0 — горизонтальные швы, байт 1 — вертикальные, по биту на шов. У $37 GROAD = $05, $03:

0
б0·0
1пос. 2
б0·1
2
б1·0
б1·1
б1·2
3пос. 1
б0·2
4пос. 3
б0·3
5
б1·3
б1·4
б1·5
6
б0·4
7
б0·5
8

1 → 2 (экран 3 → 1): столбец 0 → 1 — шаг вправо, шов 3–4 (б0·2). Потом экран 4 → 1 вверх — шов 1–4 (б1·1).

2 → 3 (экран 1 → 4): тот же столбец, вниз — шов 1–4, он уже включён.

Выход ↑ (экран 1 → поселение 1 на экране 3): влево — шов 0–1 (б0·0), вниз — шов 0–3 (б1·0).

Байт 0 = %00000101 = $05, байт 1 = %00000011 = $03.

Шов включается одной командой ORA — бит из таблицы RD_SIDES, где для каждого экрана и каждой стороны записано: в каком байте GROAD её шов и какой бит. Включить уже включённый бит не страшно — ORA ничего не сломает. Поэтому пути 1 → 2 и 2 → 3 спокойно идут по одному шву.

Переход на соседний экран — сложение с таблицей STEP_D: ↑ −3, → +1, ↓ +3, ← −1. Но в байте нет минуса, поэтому там записано 253, 1, 3, 255: 1 + 255 = 256 = 0 в байте — то же, что 1 − 1. Это «вычитание сложением по кругу», тот же счётчик, прокрученный через ноль, что в CMP из главы 0.

GEN_EXITS: какие стороны у этого экрана

Когда строится конкретный экран, GEN_EXITS смотрит в GROAD его четыре шва и собирает маску GEXIT: ↑ = 1, → = 2, ↓ = 4, ← = 8. Плюс выход к соседней локации, если экран средний на краю (OUT_MASK).

ЭкранШвыGEXITБиты ←↓→↑
0→ 0–1, ↓ 0–32 + 4 = 60110
1↑ выход в $27, ↓ 1–4, ← 0–11 + 4 + 8 = 131101
3↑ 0–3, → 3–41 + 2 = 30011
4↑ 1–4, ← 3–41 + 8 = 91001
2, 5, 6, 7, 8—00000

Числа получаются прямо из швов — и в игре экраны выходят именно такими.

GEN_ROAD: дорога на экране

Дорога всегда идёт через центр — клетку 90 (строка 4, столбец 10). В неё ставится плитка 16 + GEXIT: номера 16–31 — это ровно 16 вариантов дорожной плитки, по одному на каждую маску. У экрана 4 GEXIT = 9, в центре плитка 25 — поворот «┘», вверх и влево. Номер плитки сам говорит, куда она ведёт.

Дальше — прямые куски: если есть → — клетки 91–99 плиткой «─» (16 + 2 + 8 = 26), если ↑ — клетки 10, 30, 50, 70 плиткой «│» (16 + 1 + 4 = 21). Вертикаль идёт шагом 20 — на строку вниз:

        LDX #10                 ; ↑ : клетки 10, 30, 50, 70
@u:
        LDA #T_ROAD0+5          ; │ (↑1 + ↓4)
        STA SCR_MAP,X
        TXA
        CLC
        ADC #20                 ; X + 20: следующая строка
        TAX
        CPX #90                 ; до центра
        BNE @u

Прибавлять к X напрямую 6502 не умеет — только INX на 1. Поэтому X перекладывают в A (TXA), прибавляют 20 и кладут обратно (TAX). В SCR_MAP экрана 4 так и есть: столбец 10, строки 0–3 — число 21, строка 4 слева — 26, в центре — 25.

GEN_SEED и GEN_RND: случайности экрана

Камни, кусты и деревья разбросаны «случайно» — но случайность должна быть одной и той же при каждом заходе. Для этого у экрана свой генератор. Его заводит GEN_SEED из номера экрана и двух байтов зерна локации:

        LDA GSCR                ; номер экрана × 17
        ASL A                   ; ×2
        ASL A                   ; ×4
        ASL A                   ; ×8
        ASL A                   ; ×16
        CLC
        ADC GSCR                ; ×16 + ×1 = ×17
        EOR SEED+5              ; смешать с зерном локации
        CLC
        ADC SEED+7

Экран 4: 4 × 17 = 68 = $44; $44 EOR $93 = $D7; $D7 + $75 = $14C → в байте $4C. Умножение на 17 нужно, чтобы соседние экраны (4 и 5) дали сильно разные числа, а не отличающиеся на единицу.

Сам генератор — GEN_RND, шесть команд. Это «регистр сдвига с обратной связью»: сдвинуть байт влево, и если вывалилась единица — перевернуть несколько битов:

GEN_RND:
        LDA RND
        ASL A                   ; сдвиг влево, бит 7 → C
        BCC @nox                ; выпал 0 — так и оставить
        EOR #$1D                ; выпала 1 — перевернуть биты 0, 2, 3, 4
@nox:
        STA RND
        RTS

Один шаг: $8F → $03 (первая клетка экрана 4)

бит
7
6
5
4
3
2
1
0
RND
1
0
0
0
1
1
1
1
$8F
ASL A
0
0
0
1
1
1
1
0
$1E бит 7 (1) вылетел в C → C = 1
EOR #$1D
0
0
0
1
1
1
0
1
$1D
= RND
0
0
0
0
0
0
1
1
$03

После 8 холостых шагов «разогрева» RND = $8F, и первый настоящий шаг даёт $03. Дальше: $06, $0C, $18, $30, $60… — пока единица не вылетит снова. Такой генератор пробегает все числа 1–255 ровно по разу и только потом повторяется. Ноль ему нельзя — из нуля он никогда не выйдет (0 сдвинутый — всё равно 0), поэтому в GEN_SEED стоит проверка «если 0 — взять 1».

BCC здесь смотрит не на сравнение, а на бит, который только что вылетел из ASL. Флаг C — один и тот же для переноса, сравнения и сдвигов.

Почему маска именно $1D — биты 0, 2, 3, 4

Если бы генератор только сдвигал, через 8 шагов байт стал бы нулём и застрял. EOR с маской «возвращает» вылетевшую единицу в несколько мест справа. От того, в какие места, зависит, сколько разных чисел пройдёт генератор, прежде чем начнёт повторяться. Вот один и тот же старт — 1 — с разными масками:

МаскаБитыЧисел до повтораЧто было бы на экране из 200 клеток
$010000 00018узор повторяется каждые 8 клеток
$110001 000112каждые 12
$050000 010130каждые 30 — полторы строки
$1B0001 101151каждые 51
$0F0000 1111217почти хорошо, но не все числа
$FF1111 11119каждые 9
$1D0001 1101255все числа 1–255, повтор — только через 255 клеток

С маской $05 генератор возвращается к началу через 30 шагов — дальше всё по кругу:

0102040810204080050A142850A0458A11224488152A54A855AA51A2418201

С маской $1D — через 255, побывав на каждом числе от 1 до 255 ровно один раз:

01020408102040801D3A74E8CD8713264C982D5AB475EAC98F03060C183060C09D274E9C… ещё 21901

Из 255 возможных масок полный круг дают только 16: $1D $2B $2D $4D $5F $63 $65 $69 $71 $87 $8D $A9 $C3 $CF $E7 $F5. $1D — самая маленькая из них. Подбирать её не нужно: это математика многочленов над битами («конечные поля»), такие маски давно посчитаны и есть в таблицах. Маска $1D вместе с вылетающим девятым битом — это многочлен x⁸ + x⁴ + x³ + x² + 1. Тот же самый стоит в QR-кодах — в их коде исправления ошибок — и в одной из распространённых контрольных сумм CRC-8.

Для игры это значит: на экран нужно 200 случайных чисел, а повтор начинается только через 255 — узора не видно. С маской $05 камни и кусты легли бы одинаковыми «пятнами» каждые 30 клеток.

GEN_SCREEN: фон по рельефу

Рельеф — биты 5–7 старшего байта S0 (глава 1). У $37 это 5, «скалы». Для каждого рельефа в таблице RLF_TAB строка из 8 байт: фон, порог 1, плитка 1, порог 2, плитка 2.

RLF_TAB:   ; фон      порог 1  плитка 1   порог 2  плитка 2
        .byte T_GRASS, 25, T_TREE, 40, T_BUSH, 0, 0, 0          ; 0 луг
        ...
        .byte T_DRY, 55, T_ROCKS, 80, T_CLIFF, 0, 0, 0           ; 5 скалы   ← $37
        ...
        .byte T_SAND, 15, T_BUSH, 28, T_ROCKS, 0, 0, 0          ; 7 побережье

На каждую из 200 клеток — новое число генератора 1–255. Меньше 55 — камни, от 55 до 79 — обрыв, остальное — сушь. Значит, камней примерно 54 / 255 ≈ 21 %, обрывов ≈ 10 %, суши ≈ 69 %. Пороги — это и есть «характер» рельефа: в лесу (4) деревьев больше 40 %.

Как найти строку рельефа: AND и два LSR

бит
7
6
5
4
3
2
1
0
SEED+1
1
0
1
1
1
0
1
0
$BA
AND #%11100000
1
1
1
0
0
0
0
0
$E0
= A
1
0
1
0
0
0
0
0
$A0 рельеф 5 стоит «на месте × 32»
LSR A ×2
0
0
1
0
1
0
0
0
$28 = 40 = 5 × 8 — начало строки 5 в таблице

Хитрость: биты 5–7 уже означают «рельеф × 32». А нужен «рельеф × 8» (строки по 8 байт). Вместо трёх сдвигов вправо и трёх влево — два сдвига вправо: × 32 / 4 = × 8. Поэтому строки таблицы и сделаны по 8 байт, хотя полезных там пять.

@cell:
        JSR GEN_RND             ; A = 1–255
        CMP RLF_TAB+1,Y         ; меньше порога 1?
        BCS @not1               ; A ≥ порога — нет
        LDA RLF_TAB+2,Y         ; плитка 1
        JMP @put
        ...
@put:
        STA SCR_MAP,X
        INX
        CPX #200
        BNE @cell

Клетка 0 экрана 4: генератор дал $03 = 3, CMP #55: 3 < 55, C = 0, BCS не прыгает — плитка 1, камни (6). В SCR_MAP клетка 0 — действительно 6. Здесь пригодились и индекс Y (строка рельефа), и X (клетка): GEN_RND специально написан так, чтобы не трогать ни X, ни Y.

GEN_STAMP и GEN_SETTL: дома штампами

Дом — это не одна плитка, а несколько: крыша, стены, дверь. Такую группу называют штамп: ширина, высота и номера плиток строка за строкой. Цех промзоны:

ST_FACTORY:
        .byte 5, 4                                              ; 5 × 4 клетки
        .byte T_SAW_ROOF, T_SAW_ROOF, T_SAW_ROOF, T_SAW_ROOF, T_SAW_ROOF      ; 49 × 5
        .byte T_METAL_WALL, T_METAL_WALL, T_METAL_WALL, T_METAL_WALL, T_METAL_WALL  ; 50 × 5
        .byte T_METAL_WALL, T_METAL_WALL, T_GATE, T_METAL_WALL, T_METAL_WALL  ; ворота 51
        .byte ST_SKIP, ST_SKIP, T_PATH_DOOR, ST_SKIP, ST_SKIP              ; тропинка 97

ST_SKIP ($FF) — «не трогать»: там остаётся фон. Так тропинка от ворот ложится одна, а по бокам — камни. Найдите цех в сетке экрана 4: строки 0–3, столбцы 1–5.

Куда ставить — в клетку «строка × 20 + столбец». Умножить на 20 без умножения: 20 = 16 + 4.

GEN_STAMP: строка 4 × 20 = (4 × 4) + (4 × 16)

бит
7
6
5
4
3
2
1
0
A = строка
0
0
0
0
0
1
0
0
4
ASL ASL → GTMP
0
0
0
1
0
0
0
0
16 × 4, запомнили
ASL ASL
0
1
0
0
0
0
0
0
64 × 16
ADC GTMP
0
0
0
1
0
0
0
0
16
= A
0
1
0
1
0
0
0
0
80 × 20; + столбец 10 → клетка 90

Любое умножение на константу так и делается: разложить её на степени двойки (20 = 16 + 4), сдвигами получить каждую часть и сложить. Сдвигов четыре, сложение одно — быстрее любого цикла.

Какие штампы ставить — решает шаблон поселения: список слотов по 4 байта — столбец, строка, с какого уровня, номер штампа. Шаблон промзоны:

TPL_WORKS:                      ; столбец, строка, уровень, штамп
        .byte 1, 0, 0, S_FACTORY      ; ✓ 4 ≥ 0   цех слева вверху
        .byte 14, 9, 0, S_TRUCK       ; ✓ 4 ≥ 0   грузовик 56 57
        .byte 13, 0, 1, S_FACTORY     ; ✓ 4 ≥ 1   цех справа вверху
        .byte 7, 6, 2, S_TANKS        ; ✓ 4 ≥ 2   цистерны 52
        .byte 1, 5, 3, S_FACTORY      ; ✓ 4 ≥ 3   цех слева внизу
        .byte 13, 6, 4, S_TANKS       ; ✓ 4 ≥ 4   цистерны
        .byte 16, 6, 5, S_TANKS       ; ✗ 4 < 5   → руины: обломки 66 66
        .byte 7, 1, 6, S_GEN         ; ✗ 4 < 6   → руины: обломки 66
        .byte $FF                     ; конец

Поселение 3 на экране 4 — уровня 4. GEN_SETTL идёт по слотам и сравнивает: CMP GSL / BCS @whole — «уровень ≥ порога — целый дом». Иначе берёт тот же номер штампа из таблицы руин ST_RUIN. Так растущее поселение (глава 9) само «отстраивается»: уровень вырос до 5 — и на месте обломков в столбцах 16–17 появятся цистерны. Ничего не хранится, кроме одного числа — уровня.

Шаблон не занимает строку 4 и столбец 10 — по ним идут дороги. Поэтому дом никогда не встанет поперёк дороги.

Глава 4. Как рисуется HiRes

В главе 3 экран превратился в 200 номеров плиток — SCR_MAP. Теперь их надо превратить в точки на мониторе. Для этого нужно знать, как Apple II хранит картинку, — а хранит он её очень необычно. Три странности HiRes: 7 точек в байте задом наперёд, цвет зависит от того, в каком столбце стоит точка, и строки экрана лежат в памяти вперемешку.

Экран — это 8 КБ памяти

HiRes — 280 × 192 точки. Страница 1 — это память $2000–$3FFF, страница 2 — $4000–$5FFF, по 8 192 байта. Никакой видеокарты: видеосхема Apple сама читает эту память 60 раз в секунду и рисует то, что в ней лежит. Записал байт по адресу из этого куска — на экране тут же изменились точки.

В строке 40 байт. 40 × 8 = 320, но точек в строке 280 — потому что из каждого байта на экран идут только 7 битов, 0–6. Бит 7 точкой не является: он выбирает «цветовую пару» для всех семи точек этого байта.

Байт $2A — семь точек и бит цвета

бит
7
6
5
4
3
2
1
0
$2A
0
0
1
0
1
0
1
0

И главное: бит 0 — левая точка, бит 6 — правая. На схемах бит 7 всегда рисуют слева, поэтому на экране байт выглядит «задом наперёд»: $2A = 0010 1010 горит как .#.#.#. — точки 1, 3, 5. В исходниках плиток рядом с каждым байтом это и нарисовано уже в экранном порядке:

TL_TREE:          ; 3: дерево
        .byte $00, $00  ; .......|.......
        .byte $20, $01  ; .....#.|#......
        .byte $28, $05  ; ...#.#.|#.#....
        .byte $28, $15  ; ...#.#.|#.#.#..
        .byte $2A, $15  ; .#.#.#.|#.#.#..
        ...
        .byte $A0, $81  ; .....#.|#......   ← ствол: бит 7 = 1
        ...

Плитка — 14 × 16 точек: 2 байта в ширину, 16 строк, всего 32 байта. 14 точек = ровно 2 байта по 7, поэтому плитки встают в сетку без сдвигов: 20 плиток × 2 байта = 40 байт = вся строка.

Откуда цвет

Apple II цвет «не хранит». Цвет получается от того, в каком столбце горит одиночная точка и какой у её байта бит 7. Это фокус с телевизионным сигналом NTSC, придуманный Возняком, чтобы не ставить отдельную память под цвет:

ТочкаСтолбец чётныйСтолбец нечётный
одна, бит 7 = 0 фиолетовый зелёный
одна, бит 7 = 1 синий оранжевый
две рядом белые
не горит чёрная

Поэтому зелёная крона дерева нарисована «через одну» — точки только в нечётных столбцах, а ствол — тоже в нечётном, но байт с битом 7 = 1, и он становится оранжевым. Вот строка 4 кроны и строка 10 ствола:

012345678910111213
01010101010100
строка 4: $2A $15 — точки в столбцах 1, 3, 5, 7, 9, 11 (все нечётные), бит 7 = 0 → зелёные
012345678910111213
00000101000000
строка 10: $A0 $81 — точки 5 и 7, бит 7 = 1 → оранжевые

А вот вся плитка, посчитанная по этим правилам, — так её и видно в игре:

0$00 $00
1$20 $01
2$28 $05
3$28 $15
4$2A $15
5$2A $15
6$2A $15
7$28 $15
8$28 $05
9$28 $05
10$A0 $81
11$80 $81
12$80 $81
13$80 $81
14$A0 $81
15$00 $00

Слева номер строки, справа её два байта. Чёрная полоска посередине — граница байтов: столбцы 0–6 из первого байта, 7–13 из второго.

Это ограничение видно в любой игре для Apple II: в одном байте нельзя смешать зелёный и оранжевый, потому что бит 7 один на семь точек. Плитки нарисованы с учётом этого: каждые 7 точек — одной «пары».

Белый — это две точки рядом. Камни, стены, дома в игре белые как раз потому, что нарисованы сплошными линиями.

Строки лежат в памяти «лесенкой»

Самое странное. Логично было бы: строка 0 — $2000, строка 1 — $2028 (через 40 байт), строка 2 — $2050… Но нет. У Apple II адрес строки складывается из трёх кусков:

адрес = $2000 + (y mod 8) × $400 + ((y / 8) mod 8) × $80 + (y / 64) × $28
Строка yy mod 8 (× $400)полоса (× $80)блок (× $28)Адрес
0000$2000
1100$2400
2200$2800
7700$3C00
8010$2080
9110$2480
63770$3F80
64001$2028
128002$2050
191772$3FD0

Соседние строки отстоят на $400 = 1 024 байта. Только 8 строк спустя адрес сдвигается на $80. Экран делится на 3 блока по 64 строки, в блоке 8 «полос» по 8 строк. Возняк сделал так, чтобы один и тот же счётчик в видеосхеме обслуживал и текст, и графику, и одновременно обновлял память. Сэкономил несколько микросхем — а программистам досталась лесенка навсегда.

Зато видно, почему при BLOAD картинки заставки прямо в видеопамять она «проявляется» жалюзи: файл пишется в память подряд, а подряд в памяти лежат строки 0, 64, 128, потом 8, 72, 136, 16… — по одной строке в каждой полосе, и только потом строки 1, 9, 17…

SCR_ROWS: таблица вместо формулы

Считать формулу для каждой строки каждой плитки — дорого. Поэтому при запуске SCR_ROWS один раз заполняет две таблицы по 192 байта: ROW_LO ($1C00) — младший байт адреса строки, ROW_HI ($1CC0) — старший. Потом адрес любой строки — два чтения: LDA ROW_LO,X и LDA ROW_HI,X.

Внутри три вложенных цикла — блок, полоса, строка — и трюк: +$400 — это +4 к старшему байту, младший не меняется. Поэтому у 8 строк полосы младший байт одинаковый, а старший растёт на 4:

@line:
        LDA SBASE               ; младший байт у всех 8 строк полосы одинаковый
        STA ROW_LO,Y
        LDA SHI
        STA ROW_HI,Y
        CLC                     ; следующая строка: +$400 = старший байт +4
        ADC #4
        STA SHI
        INY
        INX
        CPX #8
        BNE @line

Строки 0–7: младший $00, старший $20, $24, $28 … $3C. Потом полоса +$80 (строки 8–15: $2080, $2480…), через 8 полос — блок +$28. Конец полосы определяется хитро: TYA / AND #%00111111 / BNE @band — «номер строки делится на 64?». Маска оставляет 6 младших битов; если они все нули — блок закончился.

SCR_TILE: плитка в клетку

Нарисовать плитку в клетку (столбец X, строка Y сетки 20 × 10) — значит 16 раз скопировать 2 байта в нужные места экрана. Пример — центр дороги, клетка столбец 10, строка 4:

SCR_TILE:
        BIT LCRAM               ; картинки плиток — в скрытой памяти
        TXA                     ; байт в строке = столбец × 2
        ASL A                   ; 10 → 20
        STA TCOL
        TYA                     ; первая строка точек = строка клетки × 16
        ASL A
        ASL A
        ASL A
        ASL A                   ; 4 → 64
        STA TLINE
        LDA #16
        STA TCNT                ; 16 строк точек
@row:
        LDX TLINE
        CLC
        LDA ROW_LO,X            ; адрес строки 64 — младший
        ADC TCOL                ; + 20 байт вправо
        STA PTR
        LDA ROW_HI,X            ; старший
        ADC DPAGE               ; + $00 (страница 1) или + $20 (страница 2)
        STA PTR+1
        LDY #0
        LDA (TILEP),Y          ; байт картинки …
        STA (PTR),Y            ; … на экран
        INY
        LDA (TILEP),Y          ; второй байт
        STA (PTR),Y
        ...                     ; TILEP + 2, TLINE + 1, TCNT − 1
ШагЧислаЧто происходит
TCOL10 × 2 = 20Плитка 2 байта шириной, клетка 10 начинается с 20-го байта строки.
TLINE4 × 16 = 64Клетка 4 начинается с 64-й строки точек — это начало второго блока.
ROW(64)$2028Из таблицы: ROW_LO = $28, ROW_HI = $20.
+ TCOL$203C$28 + 20 ($14) = $3C. Переноса нет, старший остаётся $20.
+ DPAGE$203C / $403CЕсли рисуем на странице 2 — DPAGE = $20, и $20 + $20 = $40. Вся вторая страница — та же лесенка, только на $2000 дальше.
строка 65$243CСледующая строка плитки — на $400 дальше.

Хорошая деталь: STA (PTR),Y и LDA (TILEP),Y используют один и тот же Y = 0, 1. Два указателя, один счётчик — левый байт плитки идёт в левый байт клетки, правый — в правый.

DPAGE — то, что позволяет рисовать на невидимой странице: подпрограмма одна, а куда она пишет — решает одна переменная. Как это используется против мерцания — в главе 5.

SCR_TILEN и SCR_DRAW: от номера к картинке

У SCR_TILE на входе адрес картинки, а в SCR_MAP лежат номера. Переводит SCR_TILEN — через таблицу адресов TILE_TAB ($DC00), тем же приёмом, что слоги в главе 2: номер × 2 → два байта адреса.

$DC0640TILE_TAB+6плитка 3 мл.
$DC07DDTILE_TAB+7плитка 3 ст.
→
$DD4000TL_TREEстрока 0
$DD4100
$DD4220строка 1.....#.
$DD4301#......
SCR_TILEN:
        BIT LCRAM
        STX TCX                 ; X и Y ещё нужны — сохранить клетку
        STY TCY
        ASL A                   ; номер плитки × 2
        TAX
        LDA TILE_TAB,X
        STA TILEP
        LDA TILE_TAB+1,X
        STA TILEP+1
        LDX TCX                 ; вернуть клетку
        LDY TCY
        JMP SCR_TILE            ; «хвостовой вызов»

Хвостовой вызов. Вместо JSR SCR_TILE + RTS стоит JMP SCR_TILE. SCR_TILE кончается своим RTS, и он вернётся туда, откуда звали SCR_TILEN, — потому что в стеке лежит именно тот адрес возврата. Экономия: байт кода, 9 тактов и два байта стека. Приём встречается в игре часто — смотрите на JMP в конце подпрограмм.

Почему X и Y надо сохранять. Регистров всего три, а TAX занимает X под индекс таблицы. Клетку на время кладут в память (TCX, TCY) и потом достают. Это постоянная работа на 6502: регистры — «руки», память — «карманы».

SCR_DRAW — просто два вложенных цикла, 10 строк × 20 клеток: взять номер из SCR_MAP и вызвать SCR_TILEN. По подсчёту тактов одна плитка — около 1 600 тактов, весь экран — около трети секунды на 1 МГц. Если рисовать на видимой странице, это видно глазом: экран «заполняется» сверху вниз. Поэтому новый экран рисуется на невидимой странице и показывается целиком.

Глава 5. Герой

Плитки из главы 4 стоят в сетке ровно по байтам: клетка = 2 байта. Герой так не может — он ходит по 2 точки, а в байте их 7. Значит, почти всегда фигурка начинается где-то посреди байта и залезает на три байта сразу. Плюс она должна рисоваться поверх травы и камней, не затирая их квадратом, и не мерцать. Эта глава — про три трюка: таблицы сдвига, маску и две страницы.

Где стоит герой: HX2 и HY

Позиция — два байта: HY — строка точек верхнего края (0–144), HX2 — столбец, делённый на 2 (0–132). Почему пополам? Экран шириной 280 точек, а байт хранит только 0–255. Половина — 0–140 — влезает. К тому же шаг героя и так 2 точки, а значит, x всегда чётный: столбцы не меняют чётность, и цветные точки фигурки не «переливаются» из зелёного в фиолетовый при ходьбе (глава 4).

Фигурка — 14 × 16 точек, как плитка. Чтобы её нарисовать с точки x, надо знать два числа: в каком байте строки она начинается и на сколько точек сдвинута внутри этого байта: x = байт × 7 + сдвиг. Делить на 7 процессор не умеет, поэтому при запуске HERO_PREP строит две таблицы на все 140 позиций: XB_TAB (байт) и XS_TAB (сдвиг 0–6).

@xt:                            ; X = HX2 = 0, 1, 2 …
        LDA HB
        STA XB_TAB,X
        LDA HS
        STA XS_TAB,X
        LDA HS                  ; следующий x — на 2 точки правее
        CLC
        ADC #2
        CMP #7                  ; вылезли за байт?
        BCC @xn
        SBC #7                  ; (C = 1 после CMP — вычитание честное)
        INC HB                  ; следующий байт
@xn:
        STA HS
HX2xXB_TAB (байт)XS_TAB (сдвиг)Как считалось
0000старт
12020 + 2
36064 + 2
48116 + 2 = 8 ≥ 7 → 8 − 7 = 1, байт + 1
20405540 = 5 × 7 + 5

Здесь снова «деление без деления»: вместо x / 7 таблица строится прибавлением по 2 с переносом в следующий байт — как будто считаешь на счётах. Отдельная мелочь: SBC #7 без SEC. Он не нужен, потому что прямо перед ним CMP #7 уже поставил C = 1 (A ≥ 7, иначе BCC бы ушёл).

Сдвиг фигурки: 2 байта → 3 байта

Пример — строка 8 кадра «герой спиной»: $4C, $19 — ·.##..##..##.·. Герой стоит на HX2 = 20: байт 5, сдвиг 5. На экране его 14 точек должны начаться с 5-й точки байта 5 — то есть разъехаться по трём байтам:

исходная строка: $4C $19 — точки 2, 3, 6, 7, 10, 11 (14 точек = 2 байта)
после сдвига на 5: точки 7, 8, 11, 12, 15, 16 → три байта $00 $33 $06

Важная путаница, которую стоит запомнить: сдвиг вправо на экране — это сдвиг влево в байте. Бит 0 — левая точка (глава 4), значит, чтобы точка уехала правее, её бит должен стать старше: ASL, а не LSR.

Сдвигать каждый байт каждой строки на каждом кадре в цикле — медленно. Поэтому HERO_PREP заранее строит 7 таблиц сдвига, по странице на каждый сдвиг s = 0–6 (SHTAB, $1500–$1BFF). В каждой странице две половины:

[v]       = (v << s) AND $7F     ; что остаётся в этом байте
[v + 128] = (v << s) >> 7       ; что переезжает в следующий байт

Байт $4C, сдвиг 5: что остаётся и что переезжает

бит
7
6
5
4
3
2
1
0
v
0
1
0
0
1
1
0
0
$4C
v << 5: ст.
0
0
0
0
1
0
0
1
$09 16 бит: $4C × 32 = $0980
v << 5: мл.
1
0
0
0
0
0
0
0
$80
остаётся
0
0
0
0
0
0
0
0
$00 младшие 7 бит — ни одной точки
переезжает
0
0
0
1
0
0
1
1
$13 всё, что вылезло за бит 6, — сдвинутое на 7 вправо

Таблица в памяти: остаётся — по адресу $1500 + 5 × 256 + $4C = $1A4C, переезжает — $1ACC (+ 128). Строится она теми же ASL WORK / ROL WORK+1, что умножение на 8 в главе 1: 16-битный сдвиг через перенос.

Теперь SHIFT3 собирает три байта из двух — это одна формула:

OUT0 = остаётся(b0)                    ; = $00
OUT1 = переезжает(b0) OR остаётся(b1)  ; = $13 OR $20 = $33
OUT2 = переезжает(b1)                  ; = $06

OUT1: хвост первого байта + голова второго

бит
7
6
5
4
3
2
1
0
переезжает($4C)
0
0
0
1
0
0
1
1
$13
ORA остаётся($19)
0
0
1
0
0
0
0
0
$20
= OUT1
0
0
1
1
0
0
1
1
$33 точки 7, 8, 11, 12 экрана — в байте 6

Две половинки не пересекаются (одна занимает биты 0–4, другая — 5–6), поэтому ORA просто склеивает их. Итог $00 $33 $06 — ровно то, что на ленте точек выше. Вся работа на одну строку — четыре чтения таблицы и один ORA, без единого сдвига.

Маска: рисовать поверх, не затирая фон

Если просто записать байты героя на экран, вокруг него будет чёрный прямоугольник — точки фона, где у героя «пусто», погаснут. Поэтому у каждой строки кадра есть ещё маска: 1 — «здесь прозрачно, оставь фон», 0 — «здесь герой». Рисование — одна строчка логики на каждый байт:

экран = (экран AND маска) OR картинка
@byte:
        LDA (PTR),Y              ; что сейчас на экране
        AND (MPTR),Y             ; выключить точки там, где герой
        ORA (HPTR),Y             ; включить точки героя
        STA (PTR),Y
        INY
        CPY #3                    ; 3 байта на строку
        BNE @byte

Один байт экрана: фон $88, маска $81, герой $4C (без сдвига)

бит
7
6
5
4
3
2
1
0
экран (сушь)
1
0
0
0
1
0
0
0
$88 одна точка травы (3) и бит 7 фона
AND маска
1
0
0
0
0
0
0
1
$81 1 — прозрачно: точка 0 и бит 7
=
1
0
0
0
0
0
0
0
$80 точка травы под героем погасла, бит 7 остался
ORA картинка
0
1
0
0
1
1
0
0
$4C
= экран
1
1
0
0
1
1
0
0
$CC герой поверх, точка 0 — от фона

У маски бит 7 = 1 всегда: цветовая пара байта берётся от фона. Иначе там, где герой проходит по оранжевой земле, у кусочков фона в этом же байте менялся бы цвет. Контур героя — нули в маске и нули в картинке: точки гаснут, получается тонкая чёрная обводка, которая отделяет белую фигурку от белых камней.

Маску тоже надо сдвигать — и тут ловушка. При сдвиге в освободившиеся биты заходят нули, а 0 в маске — «здесь герой». Вокруг сдвинутой фигурки появилась бы чёрная полоса. Поэтому PREP_ROW сначала переворачивает маску (EOR #%01111111 — теперь 1 = «здесь герой»), сдвигает эту «тень героя» по тем же таблицам, где нули как раз означают «пусто», и только потом переворачивает обратно — EOR #%11111111, заодно выставляя бит 7 = 1.

EOR с единицами — это «перевернуть биты». Раньше EOR встречался как «смешать» (глава 3) и «перевернуть часть битов» (генератор). Здесь — третья роль: «НЕ» для нужных битов.

Зеркало: влево = отражённое вправо

Кадров у персонажа 6: три вида (↑, →, ↓) × два шага. Вида «влево» нет — это зеркальное «вправо». Чтобы отразить строку 14 точек, надо поменять местами два байта и в каждом перевернуть порядок 7 точек. Для второго — таблица REV7 на 128 значений:

REV7: $0C → $18 (точки 2, 3 → точки 4, 3)

бит
7
6
5
4
3
2
1
0
v
0
0
0
0
1
1
0
0
$0C
REV7[v]
0
0
0
1
1
0
0
0
$18 бит i → бит 6 − i

Строится она по биту: LSR WORK выталкивает младший бит v в C, ROL WORK+1 заталкивает C в младший бит r — так 7 раз. Биты уходят из одного числа справа и входят в другое тоже справа, поэтому выстраиваются в обратном порядке. Как переложить стопку тарелок в другую стопку.

Две страницы: кадр без мигания

Самая важная подпрограмма главы — HERO_FRAME. Если на видимой странице стереть героя и нарисовать заново, глаз увидит момент, когда героя нет, — фигурка будет мигать. Поэтому рисуется всё на невидимой странице, а показывается она одним переключателем.

HERO_FRAME:
        LDA DPAGE               ; 1) другая страница: $00 ↔ $20
        EOR #$20
        STA DPAGE
        ...
        JSR NPC_STEP            ; 2) ход одного NPC
        LDX HPG                 ; 3) стереть героя там, где он на ЭТОЙ странице
        LDA OLDX,X
        STA SX2
        LDA OLDY,X
        STA SY
        JSR ERASE_AT            ;    перерисовать плитки из SCR_MAP
        JSR NPC_ERASE
        JSR NPC_REDRAW          ; 4) NPC
        JSR HERO_DRAW           ; 5) герой
        LDX HPG                 ;    запомнить, где он теперь на этой странице
        LDA HX2
        STA OLDX,X
        LDA HY
        STA OLDY,X
        LDA DPAGE               ; 6) показать
        BEQ @one
        STA HISCR               ; $C055 — страница 2 на экран
        RTS
@one:
        STA LOWSCR              ; $C054 — страница 1
        RTS

EOR #$20 — переключатель. DPAGE бывает только $00 или $20. Переворот бита 5: $00 → $20 → $00 → … Одна команда без всяких «если».

Почему у «старого места» две ячейки — OLDX/OLDY на каждую страницу. Страница, на которой сейчас идёт рисование, показывала позапрошлый кадр. Герой на ней стоит не там, где был в прошлом кадре, а где был два кадра назад. Стирать надо именно там. Вот четыре шага вправо:

КадрРисуем наСтираем героя вРисуем героя вВидно
1стр. 2HX2 = 20 (OLDX[1])21стр. 2: 21
2стр. 120 (OLDX[0])22стр. 1: 22
3стр. 221 (OLDX[1])23стр. 2: 23
4стр. 122 (OLDX[0])24стр. 1: 24

Стирание — это перерисовка плиток. ERASE_AT не «закрашивает чёрным». Он смотрит, на какие клетки сетки попал прямоугольник героя (2–3 столбца × 1–2 строки), и заново рисует эти плитки из SCR_MAP — подпрограммой SCR_TILEN из главы 4. Номер клетки — через таблицу MUL20: 0, 20, 40 … 180. Ещё одно умножение, заменённое таблицей из 10 байт.

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

HERO_MOVE: шаг и «можно ли туда»

STEP_X:  .byte 0, 1, 0, 255        ; ↑ → ↓ ←: x / 2 ± 1 (255 = −1)
STEP_Y:  .byte 254, 0, 2, 0        ; строк: ± 2 (254 = −2)

        LDA HX2
        CLC
        ADC STEP_X,X
        CMP #133                 ; 0–132 (−1 = 255 тоже ≥ 133)
        BCS @edge                ; за край экрана

Красивый приём с краем. У левого края HX2 = 0, шаг −1 даёт 0 + 255 = 255. Одна проверка CMP #133 / BCS ловит оба края: и «больше 132» справа, и «меньше 0» слева — потому что −1 в байте это 255, а 255 ≥ 133. Числа без знака, прокрученные через ноль, здесь только помогают.

HERO_FREE — можно ли встать в новое место. Проверяются не все точки фигурки, а 4 угла её нижней половины — ног: x + 2 … x + 10, y + 8 … y + 15. Голова может заходить на клетку дерева или крыши — как в Зельде: кажется, что герой стоит перед деревом. Для каждого угла — клетка сетки и её признаки:

CELL_WALK:
        CLC
        ADC MUL20,X             ; номер клетки = строка × 20 + столбец
        TAX
        LDA SCR_MAP,X           ; номер плитки
        TAX
        LDA PASS_TAB,X          ; её признаки
        AND WMASK               ; какие смотрим
        EOR #P_WALK             ; 0 — ровно «можно наступить»
        RTS                     ; Z = 1 — можно

CELL_WALK для камней (6) и для сухой травы (1)

бит
7
6
5
4
3
2
1
0
PASS_TAB[6]
0
0
0
0
0
0
0
0
$00 камни: никаких признаков
AND WMASK
0
0
0
0
0
0
0
1
$01
EOR #P_WALK
0
0
0
0
0
0
0
1
$01
=
0
0
0
0
0
0
0
1
$01 не 0 → Z = 0 → BNE @no: нельзя
PASS_TAB[1]
0
0
0
0
0
0
0
1
$01 сушь: P_WALK
AND WMASK
0
0
0
0
0
0
0
1
$01
EOR #P_WALK
0
0
0
0
0
0
0
1
$01
=
0
0
0
0
0
0
0
0
$00 0 → Z = 1: можно

PASS_TAB — байт признаков на каждый из 112 номеров плиток: P_WALK — наступить, P_SLOW — медленно, P_LOOT — можно обыскать… AND оставляет нужные признаки, EOR превращает «ровно такие» в ноль. Ответ — флагом Z, сразу для BNE. Для NPC в WMASK ещё бит P_ACT: двери для них — не проход, и в дом они не заходят.

Анимация ног: каждые 3 шага HFR EOR #1 — номер шага 0 ↔ 1. Тот же переключатель, что у страниц, только бит 0.

Глава 6. Переходы

Где находится герой — это три уровня адреса, как «город, улица, дом»: локация HERE (0–255, клетка карты региона 16 × 16), экран GSCR (0–8, клетка квадрата 3 × 3 внутри локации) и точка на экране HX2, HY. Эта глава — о том, что происходит, когда герой упирается в край экрана.

Регион — это 48 × 48 экранов

Если забыть про локации, регион — просто большая сетка экранов: 16 локаций × 3 экрана = 48 в ширину и столько же в высоту, 2 304 экрана. Шаг вправо — всегда +1 к «столбцу экранов». Но хранится этот столбец двумя числами: столбец локации (младшие 4 бита HERE) и столбец экрана внутри неё (GSCR mod 3):

столбец экрана в регионе = (HERE AND $0F) × 3 + (GSCR mod 3)
строка  экрана в регионе = (HERE / 16)    × 3 + (GSCR / 3)

Для старта $37, экран 4: столбец 7 × 3 + 1 = 22, строка 3 × 3 + 1 = 10. Переход «вправо» — это прибавить 1 к 22 — и посмотреть, в какую локацию и на какой экран это попало. Поэтому у переходов два случая: внутри локации меняется только GSCR, через её край — оба числа.

WALK_RIGHT и компания: четыре подпрограммы шага

WALK_RIGHT:
        LDX GSCR
        LDA SCR_COL,X           ; столбец экрана 0–2 (таблица 0,1,2,0,1,2,0,1,2)
        CMP #2
        BEQ @out                ; правый столбец — выходим из локации
        INC GSCR                ; внутри: просто следующий экран
        CLC
        RTS
@out:
        LDA HERE
        JSR WLD_RIGHT           ; сосед справа (глава 1); C = 1 — край региона
        BCS @edge
        STA HERE
        DEC GSCR                ; 2 → 0, 5 → 3, 8 → 6
        DEC GSCR
        CLC
@edge:
        RTS
$37
012345678
→
$37
012345678
вправо внутри: экран 4 → 5 (INC GSCR)
$37
012345678
→
$38
012345678
вправо через край: $37 экран 5 → $38 экран 3 (DEC × 2)
$37
012345678
↓
$27
012345678
вверх через край: $37 экран 1 → $27 экран 7 (+6)

Правило для всех четырёх: через край локации экран «переезжает» на противоположную сторону того же ряда или столбца. Вправо — из столбца 2 в столбец 0, то есть −2. Вверх — из ряда 0 в ряд 2, то есть +6 (ряд — это 3 экрана). Вниз — −6, влево — +2.

Разные подпрограммы проверяют край по-разному, и каждая — самым дешёвым способом:

КудаКрай, еслиПроверкаВнутриЧерез край
→столбец 2SCR_COL,X / CMP #2 / BEQINC GSCRDEC DEC (−2)
←столбец 0SCR_COL,X / BEQDEC GSCRINC INC (+2)
↑GSCR < 3CMP #3 / BCCSBC #3ADC #6
↓GSCR ≥ 6CMP #6 / BCSADC #3SBC #6

Для ← хватает BEQ сразу после LDA SCR_COL,X — без CMP: LDA сам поставил Z, если столбец 0. А для ↑ и ↓ таблица не нужна вовсе: ряд виден по самому номеру — 0–2, 3–5, 6–8. Это проверки «меньше» и «больше или равно» из таблицы переходов главы 0. Ответ «перешли / край региона» — флагом C, как у WLD_RIGHT, на которую WALK_RIGHT опирается.

Мелочь: DEC GSCR два раза вместо «вычесть 2». DEC работает прямо с памятью и не трогает A и флаг C — а вычитание потребовало бы LDA / SEC / SBC #2 / STA: 4 команды и испорченный A.

HERO_EDGE: сначала проверить, потом рисовать

Герой шагнул за край экрана. На соседнем экране у этого края может стоять дерево или дом — тогда переходить нельзя, герой просто останется. Но чтобы это узнать, нужна карта чужого экрана. Решение — «примерить»: построить чужой экран, проверить, а если нельзя — вернуть всё как было.

  1. Запомнить, откуда: OHERE, OSCR и 32 байта таблицы NPC (OBJ_SAVE).
  2. Сосед: WALK_UP / RIGHT / DOWN / LEFT по направлению HDIR. Край региона — уходим в REG_EDGE (глава 14).
  3. Встать к противоположному краю: шли вправо — на новом экране x / 2 = 0, шли вверх — y = 144. Таблица EDGE_V: 144, 0, 0, 132 для ↑ → ↓ ←.
  4. Построить чужой экран: если локация другая — LOC_LOAD, потом SCR_GEN. Это только расчёт SCR_MAP, без рисования — доли секунды не уходит.
  5. Можно встать? HERO_FREE из главы 5 — по новой карте.
  6. Да: новые NPC, SCR_SHOW рисует обе страницы, SUP_STEP списывает воду и еду за переход (глава 10, вместе со здоровьем). Нет: вернуть GSCR, HERE, пересобрать свою карту и NPC — и стоять.

Почему так, а не «сначала нарисовать»? Построить карту — это главы 3 и 1, расчёт. Нарисовать — глава 4, по трети секунды на страницу. Если бы игра сначала рисовала, то на каждую попытку войти в дерево экран на секунду менялся бы туда-обратно.

Мелочи из HERO_EDGE

        LDX #31                 ; NPC своего экрана — на случай «вернуться»
@sv:
        LDA OBJ,X
        STA OBJ_SAVE,X
        DEX
        BPL @sv                 ; X = 31 … 0, потом $FF — стоп

Цикл обратным счётом. Копировать можно и от 0 вверх, но тогда в конце нужен CPX #32. Если считать вниз, проверка бесплатная: DEX сам ставит флаг N, и пока X в 0–127, бит 7 равен 0 — BPL («branch if plus») прыгает. Когда X из 0 становится $FF, бит 7 = 1 — цикл кончился. Ограничение: так можно, только если начальное X ≤ 127.

DEX и флаг N в конце цикла

бит
7
6
5
4
3
2
1
0
X = 1
0
0
0
0
0
0
0
1
$01
DEX
0
0
0
0
0
0
0
0
$00 N = 0 (бит 7 = 0) → BPL прыгает: копируем OBJ+0
DEX
1
1
1
1
1
1
1
1
$FF N = 1 → BPL не прыгает: конец
@went:
        BCC @inreg
        JMP REG_EDGE            ; край региона — в соседний регион
@inreg:

Почему не просто BCS REG_EDGE? Все условные переходы (BEQ, BCS…) — относительные: в команде не адрес, а смещение на −128…+127 байт. REG_EDGE лежит в другом файле, за тысячи байт отсюда — относительный переход не дотянется, ассемблер выдаст ошибку. Поэтому условие переворачивают: «если C = 0 — перепрыгни через JMP», а JMP с полным адресом достаёт куда угодно. Это стандартный приём 6502 — «длинный условный переход».

        LDA HDIR
        BNE @n0                 ; 0 — вверх
        JSR WALK_UP
        JMP @went
@n0:
        CMP #1
        BNE @n1
        ...

Выбор из четырёх — цепочкой. В главе 0 стрелки искали таблицей. Здесь вариантов всего 4 и каждый — вызов разной подпрограммы, поэтому цепочка сравнений проще. Первую проверку CMP #0 пропустили: LDA HDIR уже поставил Z.

HERO_SPAWN: куда поставить героя на новом месте

Когда герой появляется не через край, а «с неба» — новая игра, переезд на велосипеде, загрузка сохранения, — его надо поставить на проходимое место. Сначала пробуется центр: x / 2 = 70, y = 56 — ноги попадают в строку клеток 4, где идёт любая дорога. Если там занято — перебор: строки через 8 точек, столбцы через 7 (x / 2), сверху вниз, до первой свободной клетки. Та же HERO_FREE отвечает «можно?».

Панель: «LOC 37 SCREEN 4»

Внизу экрана (строки 22–23) SCR_INFO печатает имя, тип и «адрес» героя. Две мелкие хитрости:

Цифра → символ: ORA #$B0

бит
7
6
5
4
3
2
1
0
GSCR
0
0
0
0
0
1
0
0
4
ORA #$B0
1
0
1
1
0
0
0
0
$B0
= символ
1
0
1
1
0
1
0
0
$B4 «4» на экране Apple

Символы цифр на Apple идут подряд: «0» = $B0, «1» = $B1 … «9» = $B9 (обычный ASCII $30–$39 плюс бит 7, глава 0). Младшие 4 бита у кода цифры — это сама цифра, а у маски $B0 они нулевые. Значит, ORA просто «приклеивает» цифру к нужной верхушке — тот же приём «включить свободные биты», что «+ 32» у слогов в главе 2.

Глава 7. NPC

На экране, кроме героя, бывает до четырёх фигурок: жители, охранники, мародёры, выживающие и собаки. Каждая сама решает, стоять ей или идти, видит ли она героя и что тогда делать. И все рисуются вместе с героем на тех же двух страницах, без мерцания. Вся «жизнь» экрана — это одна таблица из 32 байт.

Таблица OBJ: 4 строки по 8 байт

По адресу $0360 лежат 4 «слота», каждый 8 байт. Номер поля — смещение от начала слота, у каждого есть имя (OBJ_TYPE = 0, OBJ_X2 = 1 …). Вот она сразу после входа на экран 4 стартовой локации:

СлотАдрес+0 тип+1 x / 2+2 y+3 вид+4 шаг+5 сост.+6 таймер+7 вражд.
0$0360$02
охранник
$0E$2C$03$00$00$00$06
1$0368$01
житель
$4C$74$00$01$00$06$02
2$0370$00
—
$00$00$00$00$00$00$00
3$0378$00
—
$00$00$00$00$00$00$00

Читается так: в слоте 0 — охранник (тип 2) в точке x / 2 = 14, y = 44, смотрит влево (3), идёт (состояние 0), враждебность 6. В слоте 1 — житель, враждебность 2. Слоты 2 и 3 пусты: тип 0 означает «никого».

Чтобы взять поле нужного NPC, в X кладут слот × 8, а имя поля прибавляют к адресу: LDA OBJ+OBJ_Y,X при X = 8 читает $0360 + 2 + 8 = $036A — y жителя. Ассемблер сам сложит OBJ+OBJ_Y в одно число $0362. Так таблица из 32 байт выглядит в коде как «массив записей».

Обход всех четырёх — цикл, где X растёт на 8:

@next:
        TXA
        CLC
        ADC #8                  ; следующий слот
        TAX
        CPX #32                 ; 4 слота × 8
        BNE @o

Иногда нужен номер слота 0–3, а не × 8 (для маленьких таблиц по байту на NPC — «дом», «уже нападал»). Тогда три LSR: 24 → 12 → 6 → 3.

OBJ_GEN: кто появляется на экране

Состав экрана — таблица ROSTER, 12 строк по 6 байт: база, маска случайной добавки и до 4 типов по порядку. Строки 0–3 — поселения по виду (село, город, промзона, лагерь), строки 4–11 — окрестности по «точке интереса» из главы 3 (заправка, машины, склад…).

ROSTER:     ; база, маска, тип1, тип2, тип3, тип4
        .byte 2, 1, 1, 2, 1, 1          ; село — 2–3, охранник вторым
        .byte 3, 1, 2, 1, 1, 1          ; город — 3–4, охранник первым
        .byte 2, 1, 2, 1, 1, 0          ; промзона — 2–3   ← экран 4
        .byte 2, 1, 3, 3, 3, 0          ; лагерь — мародёры 2–3
        ...
        .byte 0, 3, 5, 5, 0, 0          ; 7 пусто — собаки 0–2

Сколько NPC: база + (случайное AND маска). Маска 1 даёт +0 или +1, маска 3 — от 0 до 3. На экране 4 выпало 2 + 0 = 2: охранник и житель — первые два типа строки.

Номер строки × 6 — без умножения: × 4 + × 2. Тот же приём, что × 20 = × 16 + × 4 в главе 3.

Где поставить. В поселении — одна из 8 «точек появления» шаблона (таблица SPAWN: на дороге, у ворот, у палаток), начиная со случайной и дальше по кругу. В окрестностях — случайная клетка. Место годится, если ноги на проходимом, там нет другого NPC (HERO_FREE проверяет и это) и не ближе 12 / 24 точек к герою — чтобы никто не появлялся вплотную. 16 попыток не нашли места — этого NPC не будет. Место появления запоминается как «дом» (HOMEX, HOMEY): дальше радиуса своего типа NPC не уходит.

Клетка → точка: x / 2 = столбец × 7 (ASL ASL ASL = × 8, потом SBC столбец = × 7), y = строка × 16 − 8 (чтобы ноги, нижняя половина фигурки, стояли в этой клетке).

NPC_HOST: враждебность

Главное число NPC — враждебность к герою, поле +7. Считается один раз при появлении:

враждебность = база типа + (7 − порядок локации) / 2 + 4 − репутация у его группы / 2   (не меньше 0)
ТипБаза(7 − 6) / 2+4Группа, репутация− реп. / 2ИтогоПоведение
житель204жители, 8−42дружелюбен
охранник404охрана, 8−44 +2 = 6настороже (+2: статус героя ниже NEIGHBOUR)
мародёр904мародёры, 4−211враждебен
собака1504нет—19враждебна

Ровно эти числа и стоят в таблице выше: охранник 6, житель 2. Порядок у $37 высокий (6), поэтому слагаемое «за беспорядок» почти ноль. В локации-анархии (порядок 0) каждому прибавится ещё 3. Чем лучше репутация у группы — тем спокойнее её люди: это и есть «где наведён порядок, там и люди спокойнее».

7 − порядок одной командой: EOR #%00000111

бит
7
6
5
4
3
2
1
0
порядок
0
0
0
0
0
1
1
0
6
EOR #%111
0
0
0
0
0
1
1
1
7
= 7 − 6
0
0
0
0
0
0
0
1
1

Для чисел 0–7 «7 − x» — это просто перевернуть три младших бита: 7 = 111, вычитать из всех единиц — значит менять 1 на 0 и наоборот, никаких заёмов. Одна команда вместо LDA #7 / SEC / SBC — и не нужен второй регистр. У мародёра есть ещё одна деталь: даже «свой» (враждебность меньше 8) в 1 случае из 8 всё равно получает 8 — нападает.

NPC_STEP: каждый кадр — ход одного NPC

Думать за всех четырёх на каждом кадре — дорого. Поэтому за кадр ходит один NPC, по кругу:

        LDA NTURN               ; чей ход: 0 → 8 → 16 → 24 → 0
        CLC
        ADC #8
        AND #%00011000          ; 32 → 0: остаются только биты 3–4
        STA NTURN

Счётчик по кругу: 24 + 8 = 32 → 0

бит
7
6
5
4
3
2
1
0
NTURN
0
0
0
1
1
0
0
0
24
ADC #8
0
0
1
0
0
0
0
0
32
AND #%00011000
0
0
0
1
1
0
0
0
=
0
0
0
0
0
0
0
0
0 снова слот 0

Маска оставляет только биты 3 и 4 — а это ровно числа 0, 8, 16, 24. Бит 5 (32) отрезается, и счётчик сам заворачивается. «Остаток от деления на 32» одной командой — так можно, когда делитель — степень двойки.

Решение NPC — по враждебности, тремя ступенями:

ВраждебностьЕсли видит герояЕсли не видит
0–3 · дружелюбенстоит лицом к герою, ждётгуляет
4–7 · насторожеближе 2 клеток — убегаетгуляет
8+ · враждебенпреследует; вплотную — нападает (глава 10)гуляет

Проверки — подряд CMP #8 / BCS @host, CMP #4 / BCS @wary: сначала «≥ 8», потом «≥ 4», иначе — меньше 4. Порядок важен: 11 ≥ 4 тоже, но до этой проверки оно не дойдёт.

Убегать — это преследовать наоборот: направление к герою переворачивается EOR #2. Направления пронумерованы ↑0 →1 ↓2 ←3 по часовой стрелке, и противоположное всегда отличается на 2: 0 ↔ 2, 1 ↔ 3. Переворот бита 1 — это ровно «± 2».

NPC_SENSE: где герой — и модуль числа

NPC нужно знать расстояние до героя по x и по y и в какую сторону к нему идти. Расстояние — модуль разности, а 6502 не знает отрицательных чисел. Подпрограмма ABSC из трёх команд:

        LDA OBJ+OBJ_X2,X         ; x / 2 охранника = 14
        SEC
        SBC HX2                   ; − герой 70
        BCS @r                    ; C = 1: ответ ≥ 0 — уже модуль
        EOR #$FF                  ; C = 0: ушли в минус —
        ADC #1                    ;   перевернуть знак: (A XOR $FF) + 1

|14 − 70| = 56

бит
7
6
5
4
3
2
1
0
14 − 70
1
1
0
0
1
0
0
0
$C8 = −56 в байте (256 − 56 = 200); C = 0 — был заём
EOR #$FF
0
0
1
1
0
1
1
1
$37 все биты наоборот = 55
ADC #1
0
0
1
1
1
0
0
0
$38 +1 (C = 0, лишнего не прибавится) = 56

Это «дополнительный код»: −x в байте записывается как 256 − x, а превращается обратно переворотом битов и +1. Хитрость в том, что CLC перед ADC #1 не нужен: сюда попадают как раз потому, что C = 0 после неудачного вычитания. Модуль расстояния считается в игре десятки раз — для NPC, для «не ближе к герою», для боя.

Дальше: по какой оси дальше — туда и идти первым делом (NDIR1), по другой — запасной вариант (NDIR2), если первый шаг упёрся в стену. Мелочь: x хранится пополам, поэтому перед сравнением с y его удваивают ASL A — и если вылетел перенос (больше 255 точек), то по x точно дальше.

Видит ли (IN_SIGHT) — просто «расстояние меньше дальности типа» по обеим осям: таблицы TSX, TSY. Охранник видит на 4 клетки, мародёр на 5, собака на 6.

Гулять: стоять или идти, но недалеко от дома

Когда таймер NPC (поле +6) дошёл до нуля, NPC_CHOOSE решает, что дальше: в 1 случае из 4 — постоять, иначе — пойти в случайную сторону. Сколько — тоже случайно, по маскам типа из таблицы TPAR: житель гуляет недалеко и часто стоит, мародёр ходит далеко, собака бегает по 2 шага за ход. Если NPC ушёл от дома дальше радиуса своего типа — следующее направление не случайное, а к дому. Поэтому охранник «держится поста», а мародёр бродит по всему экрану.

Шаг — NPC_MOVE1: те же STEP_X / STEP_Y, что у героя, та же проверка краёв CMP #133, и та же HERO_FREE. Два отличия передаются переменными: NSELF — «себя не считать препятствием» (у героя там $FF — проверять всех) и WMASK с битом P_ACT — NPC не заходят в двери, ворота и лавки. Одна подпрограмма проверки на всех.

Рисовать только то, что изменилось

Герой перерисовывается каждый кадр. NPC — нет: если стоит на месте, трогать его незачем. Для этого у каждой страницы своя запись «где и как он здесь нарисован» — DRW: 4 байта на слот (x, y, вид, шаг), по 16 на страницу. Как OLDX у героя в главе 5, только на четыре фигурки.

  1. NPC_ERASE: для каждого NPC сравнить 4 поля таблицы с записью DRW этой страницы. Совпадает всё — ничего не делать. Что-то изменилось — стереть там, где он нарисован на этой странице (ERASE_AT, перерисовка плиток), и пометить «нарисовать заново» битом в NDIRTY (слот 0 → 1, слот 1 → 2, слот 2 → 4, слот 3 → 8 — таблица DIRTY_BIT; четыре NPC — четыре бита одного байта).
  2. Каждый стёртый прямоугольник клеток — в список (ER_ADD, до 5 штук). Туда же попадает стёртый герой.
  3. NPC_REDRAW: нарисовать помеченных — и тех, кого задело стирание. Стоящего жителя никто не трогал, но если герой прошёл рядом, перерисовка плиток под героем стёрла и половину жителя. ER_HIT проверяет, пересекается ли прямоугольник NPC с каким-нибудь стёртым.

Пересечение двух прямоугольников — четыре сравнения: «мой левый край ≤ его правого, мой правый ≥ его левого» и то же по строкам. Все четыре верны — пересекаются. В коде — цепочка CMP / BEQ / BCS: «≤» на 6502 — это «равно или меньше», то есть BEQ (равно) или не BCS (меньше).

Глава 8. Панель и тексты

Под картинкой — четыре строки текста: где герой, что это за место, здоровье, сообщения («THE RAIDER ATTACKS!»). Это не нарисованные буквы, а настоящий текстовый экран Apple II, «подклеенный» снизу к графике. В главе: как текст хранится в памяти, почему его приходится копировать на вторую страницу, как из кусочков собирается строка панели и где живут 110 фраз игры.

Смешанный режим: 160 строк графики + 4 строки текста

Переключатель MIXSET ($C053) из SCR_ON (глава 0) включает режим, где верхние 160 строк точек — HiRes, а нижние 32 — строки 20–23 обычного текстового экрана. Текстовый экран — 40 × 24 символа, 1 КБ памяти: страница 1 — $0400–$07FF, страница 2 — $0800–$0BFF. Один байт — один символ.

Строки текста лежат так же «лесенкой», как строки HiRes (глава 4) — это та же схема видеосчётчика, только без «строк внутри полосы»: адрес = $0400 + (строка mod 8) × $80 + (строка / 8) × $28.

СтрокаСтраница 1Страница 2Что в ней
20$0650$0A50чей экран: «SETTLEMENT 1 TOWN LV 6» / «OUTSKIRTS FARM»
21$06D0$0AD0сообщения
22$0750$0B50имя и тип локации
23$07D0$0BD0«LOC 37 SCREEN 4» и здоровье, вода, еда

Строка 20: 20 mod 8 = 4 → 4 × $80 = $200; 20 / 8 = 2 → 2 × $28 = $50; $0400 + $200 + $50 = $0650. Страница 2 — то же самое плюс $400.

HUD_COPY: зачем текст в двух местах

Тонкость смешанного режима: номер страницы общий. Когда показана HiRes-страница 2 (HISCR), текст снизу тоже берётся со страницы 2 — с $0800. А кадры рисуются попеременно на обеих графических страницах (глава 5). Значит, панель должна быть одинаковой на обеих текстовых страницах — иначе через кадр она бы исчезала.

Печатает игра всегда на страницу 1 — так работает COUT из ПЗУ. Потом HUD_COPY переносит четыре строки на страницу 2:

HUD_COPY:
        LDX #39                 ; 40 символов, X = 39 … 0
@c:
        LDA $0650,X             ; строка 20
        STA $0A50,X
        LDA $06D0,X             ; строка 21
        STA $0AD0,X
        LDA $0750,X             ; строка 22
        STA $0B50,X
        LDA $07D0,X             ; строка 23
        STA $0BD0,X
        DEX
        BPL @c                  ; обратный счёт до 0 — глава 6
        RTS

Четыре строки за один проход цикла, а не четыре цикла по 40: так счётчик и переход тратятся 40 раз, а не 160. Это «развёрнутый» цикл — частый приём, когда скорость важнее пары байт кода.

Побочный подарок: из текстовой страницы 2 на экране видно только 4 строки. Остальные 20 строк — почти 900 байт — «невидимая» память, и игра держит там таблицы: карту экрана SCR_MAP ($0800, глава 3), рост поселений, рюкзак. Место, которое иначе пропадало бы.

Курсор и COUT

COUT ($FDED) печатает символ из A туда, где стоит курсор, и сдвигает его вправо. Курсор — две ячейки монитора ПЗУ: CH ($24) — столбец, CV ($25) — строка. Поставить курсор в начало строки 20:

        LDA #20
        STA CV                  ; строка
        JSR VTAB                ; ПЗУ пересчитает адрес строки в BASL — $0650
        LDA #0
        STA CH                  ; столбец

VTAB сам считает «лесенку»: из номера строки считает её адрес и кладёт в BASL ($28/$29). Дальше COUT пишет по адресу BASL + CH. CLREOL стирает строку от курсора до конца — так старый длинный текст не остаётся хвостом за новым коротким.

HUD_ROLE: строка из кусочков

Строка 20 — «SETTLEMENT 1 TOWN LV 6» — нигде целиком не записана. Она собирается из пяти кусочков:

SETTLEMENT TXT_SETTL1LOC_ROLE → ORA #$B0 $A0TOWNTXT_KINDS[вид] LV TXT_LV6SET_LVL → ORA #$B0

Неизменные слова — строки с нулём в конце (HUD_PUTS, глава 2). Числа — ORA #$B0, цифра → символ (глава 6). Слово по номеру — таблица адресов: вид 0–3 × 2 → TXT_KINDS → VILLAGE / TOWN / WORKS / CAMP. Тот же приём, что у слогов имён. Для окрестностей вместо этого — «OUTSKIRTS» и слово точки интереса из TXT_POIS: GAS STATION, CAR WRECKS, FARM…

Так 2–3 десятка коротких слов дают все варианты строки — места нужно меньше, чем на одну полную строку каждого вида.

110 фраз: сообщения по номерам

Все фразы игры — «BAG IS FULL», «THE SETTLEMENT GROWS!», «NOT ENOUGH CASH», заголовки рынка и окна статуса, названия регионов — лежат не там, где их печатают, а в одном месте, и у каждой есть номер. Код говорит «напечатай фразу 10», а не «напечатай вот эти буквы». Устроено это двумя файлами.

lcmsg.s — сами фразы и таблица их адресов. Он входит в DATA, то есть в скрытую память:

TXT_MSG:        .word MS_P0, MS_EQ0, MS_EQ1, MS_EQ2, MS_EQ3, MS_EQ4, MS_FOUND, MS_NOTH   ; 0–7
                .word MS_DONE, MS_FULL, MS_GREW, MS_CASH, …                         ; 8, 9, 10 …
                ...
MS_P0:          .byte 0                                   ; фраза 0 — пустая
MS_EQ0:         .asc "KNIFE"
                .byte 0
                ...
MS_GREW:        .asc "THE SETTLEMENT GROWS!"
                .byte 0

Это та же схема, что слоги в главе 2: строки с нулём в конце и таблица адресов, где место в таблице — номер фразы. MS_GREW стоит в TXT_MSG одиннадцатым, значит, у неё номер 10 (счёт с нуля).

msgnum.s — имена для номеров. Он входит в MAIN:

M_P0            = 0   ; ""
M_EQ0           = 1   ; "KNIFE"
...
M_GREW          = 10  ; "THE SETTLEMENT GROWS!"
...
M_SAVED         = 109 ; "GAME SAVED"

Строка вида ИМЯ = число — это не данные, а подсказка ассемблеру: «где встретишь M_GREW, подставь 10». В собранной MAIN от неё не остаётся ни байта. Так же устроен весь vars.s (глава 0): KBD = $C000, SEED = $10 — имена вместо голых чисел.

Важно одно правило: номер в msgnum.s и место адреса в таблице TXT_MSG обязаны совпадать. Вставишь новую фразу в середину таблицы — все номера после неё сдвинутся, и их надо поправить в обоих файлах.

Зачем вообще номера? Место для кода — самый дефицитный ресурс игры: между второй страницей графики и DOS всего 14 720 байт (глава 0). Фразы лежат в скрытой памяти, а в MAIN остаются только их номера — по одному байту в команде LDA #M_…. Так тексты не занимают места, нужного коду.

В коде сообщение выглядит так — две команды:

        LDA #M_GREW              ; A = 10
        JMP MSG_N               ; напечатать в строке 21 (хвостовой вызов)
MSG_N:                          ; сообщение номер A в строке 21 (обе страницы)
        PHA                     ; номер — в стек: MSG_CLEAR испортит A
        JSR MSG_CLEAR           ; курсор в строку 21, стереть её
        PLA                     ; номер обратно
        JSR PUT_MSG
        JMP HUD_COPY            ; и на вторую страницу

PUT_MSG:
        ASL A                   ; номер × 2
        TAX
        BIT LCRAM               ; таблица — в скрытой памяти
        LDA TXT_MSG,X
        STA STR
        LDA TXT_MSG+1,X
        STA STR+1
        BIT LCROM
        JMP HUD_PUTS            ; символы HUD_PUTS берёт из карты сам
ШагЧислаЧто происходит (M_GREW = 10)
PHA … PLAA = 10PHA кладёт A в стек, PLA достаёт. Стек — самые быстрые «карманы»: одна команда туда, одна обратно, без адреса.
ASL A20 ($14)Адреса по 2 байта.
LDA TXT_MSG,X$EC12 + $14 = $EC26 → $48Младший байт адреса фразы.
LDA TXT_MSG+1,X$EC27 → $EDСтарший. STR = $ED48.
HUD_PUTS$ED48: $D4 $C8 $C5 $A0 …«T», «H», «E», пробел… до байта 0.

Тот же механизм, что слоги имён (глава 2), и то же ограничение: номер × 2 должен влезть в байт, значит, фраз может быть не больше 128. Сейчас 110 — запас 18.

Хорошее свойство такой раскладки: lcmsg.s подключается в DATA последним, а таблица TXT_MSG стоит в нём первой. Поэтому если поменять текст фразы, не меняя их числа, адрес таблицы не сдвинется — пересобрать надо только DATA, MAIN остаётся прежней.

Как выглядит символ на текстовом экране

бит
7
6
5
4
3
2
1
0
«A» обычная
1
1
0
0
0
0
0
1
$C1
«A» инверсная
0
0
0
0
0
0
0
1
$01
«A» мигающая
0
1
0
0
0
0
0
1
$41

Два старших бита кода на экране — это режим: 11 / 10 — обычный символ, 00 — инверсный (тёмная буква на светлом), 01 — мигающий. Отсюда и «бит 7» у всех строк игры (глава 0). Инверсия пригодится в главе 13: курсор на карте — это клетка, у которой просто сброшены два верхних бита: AND #%00111111.

Глава 9. Рынок и обыск

Пробел делает одно из двух. На экране поселения открывается рынок: купить, продать, снаряжение. На любом другом экране — обыск: найти что-нибудь в развалинах. И рынок, и находки не хранятся: цены, запасы, «что здесь делают и что нужно» — всё снова считается из зерна при каждом заходе. Хранится только то, что изменил игрок: деньги, рюкзак, «обыскано» и «на сколько выросло поселение».

ACT_KEY: одна клавиша — пять случаев

ACT_KEY:
        LDA #2
        STA CWANT
        JSR CMB_NEAR            ; рядом оглушённый? — обыскать его (глава 10)
        BCC @sub
        JMP CMB_LOOT
@sub:
        JSR SUB_HERE            ; двор подстанции? — её окно (глава 12)
        BCC @trade
        JMP SUB_SHOW
@trade:
        LDA HERE
        JSR WLD_GET             ; зерно локации → SEED (глава 1)
        LDX GSCR
        LDA LOC_ROLE,X
        BEQ @search             ; 0 — окрестности: обыск
        JMP MKT_OPEN            ; 1–3 — поселение: рынок
@search:
        JMP SRCH_DO

Порядок проверок — это приоритет: сначала самое конкретное (лежащий рядом NPC), потом место (подстанция), потом общее правило (поселение или нет). Все ответы — флагом C, все переходы — хвостовыми JMP: ACT_KEY сама ничего не делает, только выбирает, кому передать работу.

Рынок: что делают и что нужно

Рынок QUINTAMATERA: 16 товаров, цены, запас, рюкзак; внизу NEEDS CLOTHES, MAKES CANDLES
Рынок города QUINTAMATERA (экран 3, уровень 6). Внизу: NEEDS CLOTHES — MAKES CANDLES.

Рынок — весь экран текстом, как станция в Elite: TXTSET выключает графику, HiRes-страницы при этом не трогаются, и при выходе картинка возвращается как была. У каждого поселения две «специальности»: какой товар оно делает (дёшево, много) и какой ему нужен (дорого, нет в продаже). Обе — из старших байтов зерна, по 4 бита, то есть номер товара 0–15:

MKT_CALC: «делают» и «нужно» у $37

бит
7
6
5
4
3
2
1
0
SEED+3
0
1
1
1
1
1
1
0
$7E
4 × LSR
0
0
0
0
0
1
1
1
7 делают: товар 7 — CANDLES
SEED+5
1
0
0
1
0
0
1
1
$93
4 × LSR
0
0
0
0
1
0
0
1
9 нужно: товар 9 — CLOTHES

Эти же байты уже работали на имя (глава 2, младшие 5 бит) — здесь берутся старшие 4. Если «делают» и «нужно» совпали, «нужно» сдвигается на следующий товар: ADC #1 / AND #%00001111 — по кругу 0–15. В развитых локациях (тип 3) краденое не берут: если им «нужно краденое», это заменяется на лекарства.

Цены и запас — как в Elite

У каждого из 16 товаров три числа в таблицах: база цены, маска добавки и редкость.

;                  WAT CAN FRS FUE BUT MED BAT CND SED CLO TOL PRT SOL WIN ROP STL
PBASE:          .byte 2, 4, 3, 12, 10, 20, 6, 2, 5, 6, 15, 18, 60, 8, 3, 25
PVAR:           .byte 1, 3, 3, 7, 3, 7, 3, 1, 3, 3, 7, 7, 15, 3, 1, 7
PRARE:          .byte 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 2, 0, 0, 2
цена  = база + (случайное AND маска)
        делают здесь — пополам (LSR A)
        нужно здесь  — вдвое   (ASL A)
запас = нужно здесь → 0
        делают      → 8 + уровень × 2
        редкость 2  → 0   (солнечные панели, краденое — только найти)
        редкость 1  → на половине рынков 1–4, на остальных 0
        обычный     → 2–9 + уровень
ТоварБаза + добавкаОсобоеЦенаЗапасНа экране
7 CANDLES2 + 0…1делают: ½18 + 6 × 2 = 201 · 20
9 CLOTHES6 + 0…3нужно: × 212012 · 0
12 SOLAR PANELS60 + 0…15редкость 270070 · 0
0 WATER2 + 0…1обычный32…9 + 63 · 10

Маски в PVAR — 1, 3, 7, 15: числа вида «все единицы». AND с такой маской даёт равномерное случайное число 0…маска — без деления и без «остатка от деления». Поэтому разброс цены у дорогих товаров больше: у панелей ±15, у воды ±1.

Мелочь в @rnd: генератор заводится из зерна экрана (глава 3), но потом EOR #%00111100. Иначе первые «случайные» числа рынка совпали бы с первыми числами карты этого экрана — цены оказались бы связаны с тем, где лежат камни. Обыск делает так же со своей маской %10100111.

Деньги — 16 бит: «хватает ли?»

Денег бывает больше 255 евро, поэтому CASH — два байта. Цена — один байт. «Хватает ли денег» — это 16-битное сравнение, сделанное в четыре команды:

        LDA CASH                ; младший байт денег
        CMP MPRICE,X           ; − цена: C = 0, если был заём
        LDA CASH+1              ; старший байт денег
        SBC #0                  ; − 0 − заём
        BCC @poor               ; C = 0 — не хватает

CMP вычитает младшие байты и оставляет «был ли заём» во флаге C (глава 0). SBC #0 вычитает из старшего байта 0 — и этот заём. Если заём «съел» старший байт до минуса, C = 0 — денег меньше цены. Сам результат не нужен — нужен только флаг.

256 € и цена 12: хватает

бит
7
6
5
4
3
2
1
0
CASH мл.
0
0
0
0
0
0
0
0
$00
CMP цена
0
0
0
0
1
1
0
0
$0C $00 − $0C: заём → C = 0
CASH+1
0
0
0
0
0
0
0
1
$01
SBC #0 и заём
0
0
0
0
0
0
0
1
$01 − 0 − 1
=
0
0
0
0
0
0
0
0
$00 C = 1 — заём погашен: денег хватает

256 − 12 = 244, денег хватает, хотя младший байт ($00) меньше цены. Вот почему смотреть только на младший байт нельзя.

10 € и цена 12: не хватает

бит
7
6
5
4
3
2
1
0
CASH мл.
0
0
0
0
1
0
1
0
$0A
CMP цена
0
0
0
0
1
1
0
0
$0C заём → C = 0
CASH+1
0
0
0
0
0
0
0
0
$00
SBC #0 и заём
0
0
0
0
0
0
0
1
=
1
1
1
1
1
1
1
1
$FF ушли в минус → C = 0 → BCC @poor

Списать деньги — та же пара, только с настоящим вычитанием (SEC / SBC младших, SBC #0 старших). Добавить при продаже — CLC / ADC и ADC #0, как в главе 1. А если сумма перевалила за 65 535 (перенос из старшего байта), деньги просто ставятся на $FFFF — больше не бывает.

PRNUM: как напечатать «350»

Процессор не умеет делить на 10, а печатать надо десятичные цифры. Решение — вычитать степени десяти, пока можно, и считать, сколько раз получилось:

P10_LO:  .byte $10, $E8, 100, 10, 1      ; 10000 = $2710, 1000 = $03E8
P10_HI:  .byte $27, $03, 0, 0, 0
РазрядВычитаемСколько раз удалосьОстаток
10 000$27100 — 350 меньше350
1 000$03E80350
100$00643: 350 → 250 → 150 → 5050
10$000A50
1$000100

Цифры 0, 0, 3, 5, 0. Ведущие нули заменяются пробелами (если число надо прижать вправо в колонке) или пропускаются, последняя цифра печатается всегда. Каждая цифра — ORA #$B0 → символ (глава 6). Вычитание пробное: результат кладётся в NUM только если не ушли в минус (BCC @next — следующий разряд). Так печатаются цены, запасы, деньги, очки статуса.

Продажа нужного — рост поселения

Главная механика рынка: продали поселению то, что ему нужно, 2 × (уровень + 1) штук за один заход — уровень +1 (до 7). Городу уровня 6 нужно 14 штук одежды. Каждая штука нужного — ещё +1 к статусу героя, рост — +8 к статусу и +1 к репутации у жителей.

        LDA SET_LVL,Y           ; уровень 6
        CMP #7
        BCS @done               ; уже 7 — расти некуда
        CLC
        ADC #1                  ; 7
        ASL A                   ; 14
        CMP MSOLD               ; продано уже 14?
        BNE @done
        JSR GROW_INC            ; запомнить рост

Где хранить рост, если поселений 3 на каждую из 256 локаций? Рост — максимум 7, а это 3 бита. Поэтому в одном байте LOC_GROW лежат два поселения: первое — в младших 4 битах, второе — в старших. Третье — в младших 4 битах второй таблицы LOC_GROW3. 512 байт на весь регион вместо 768.

LOC_GROW: два поселения в одном байте

бит
7
6
5
4
3
2
1
0
LOC_GROW,X
0
0
1
0
0
0
0
1
$21 старшие 4: пос. 2 вырос на 2 · младшие 4: пос. 1 на 1
пос. 1: AND #$0F
0
0
0
0
0
0
0
1
1
пос. 2: 4 × LSR
0
0
0
0
0
0
1
0
2
рост пос. 2: + 16
0
0
1
1
0
0
0
1
$31 ADC #16 = +1 к старшей половине

Половинку байта называют «ниббл». Прибавить 1 к младшему нибблу — просто INC. К старшему — ADC #16: 16 — это единица четвёртого бита. Переполнения не бывает: рост вызывают только пока уровень меньше 7.

GROW_GET:                       ; Y = поселение 0–2
        LDX HERE
        CPY #1
        BEQ @s1                 ; Y = 1
        BCS @s2                 ; Y > 1, то есть 2
        ...                     ; Y = 0

Выбор из трёх одним сравнением: CPY #1 ставит и Z, и C. Z = 1 — равно 1; иначе C = 1 — больше; иначе — меньше. Два перехода подряд на одних флагах.

При входе в локацию LOC_GROWN прибавляет рост к уровню из зерна (не больше 7) — и шаблон поселения (глава 3) сам отстраивает руины в дома. Выходя с рынка, где поселение выросло, игра заново строит экран (SCR_GEN) — и рост видно сразу.

Обыск: одна находка на экран, один раз

На экране окрестностей пробел — обыск. Найдётся ли что-то и что — из зерна экрана: находка на 1 экране из 4, что именно — из таблицы LOOT по точке интереса (на заправке — бензин и бутан, в аптеке — лекарства, у ЛЭП — изредка деталь подстанции), сколько — 1–3. Обыск стоит времени: вода и еда тратятся, как за переход.

Обыскать можно один раз. «Обыскано» — один бит на экран. В локации 9 экранов, но поселения обыскивать нельзя — остаётся максимум 6 экранов окрестностей, и им хватает битов 0–5 одного байта LOC_SRCH. Бит 6 того же байта — «был здесь», для тумана карты (глава 13).

Какой бит у экрана? Не по номеру экрана, а по его месту среди экранов окрестностей. У $37 поселения на экранах 1, 3, 4, окрестности — 0, 2, 5, 6, 7, 8:

Экран012345678
Рольокр.пос. 2окр.пос. 1пос. 3окр.окр.окр.окр.
Бит0 ($01)—1 ($02)——2 ($04)3 ($08)4 ($10)5 ($20)

SRCH_BIT идёт по экранам от 0 до нашего и на каждом экране окрестностей сдвигает бит влево (ASL MBIT). Дошёл — бит готов. Проверка «обыскан ли» — AND LOC_SRCH,X, отметка — ORA (тот же «включить бит», что у швов дорог в главе 3).

Мелочь: если рюкзак полон, бит не ставится — можно вернуться с пустым рюкзаком и всё-таки забрать находку. А если влезает меньше, чем нашлось, — берётся сколько влезет.

Рюкзак: 16 байт

BAG — 16 байт подряд, по байту на товар: сколько штук у героя. Сколько всего — BAG_SUM, цикл сложения 16 байт обратным счётом. Сколько влезает — BAG_CAP: 20, большой рюкзак +10, мотоцикл +10, иначе велосипед +5. Снаряжение — биты одного байта EQUIP: нож, рюкзак, пистолет, велосипед, мотоцикл. «Есть ли велосипед» — LDA EQUIP / AND #EQ_BIKE / BEQ. Восемь вещей «есть / нет» — в одном байте.

Глава 10. Бой и здоровье

Бой в BLACKOUT устроен как в Elite: никакой ловкости пальцев, только действие и бросок кубика. Клавиша A рядом с NPC — и игра бросает кубик против шанса этого типа. Попал — NPC лежит. Дальше можно обыскать его карманы и связать, если есть верёвка. Можно и убить — оружием, — но за это придётся платить репутацией. В этой же главе — здоровье, вода и еда.

Кубик на 16 граней

Любой бросок в игре — три команды:

        JSR GEN_RND             ; случайное 1–255 (глава 3)
        AND #%00001111          ; 0–15: кубик на 16 граней
        CMP CTMP                ; шанс
        BCC @stun               ; выпало меньше шанса — удача

Шанс — число 0–16: сколько граней из 16 «выигрывают». BCC — «A меньше» из таблицы переходов главы 0. Шансы лежат в таблицах по типам NPC:

TSTUN:  .byte 0, 12, 8, 8, 8, 8      ; оглушить рукой: житель 12/16, остальные 8/16
TBITE:  .byte 0, 2, 4, 4, 2, 8       ; попасть по герою: житель 2/16 … собака 8/16
0123456789101112131415
удар рукой по жителю: выигрывают грани 0–11 — 12 из 16 = 3/4
0123456789101112131415
по охраннику или мародёру: 0–7 — 8 из 16 = 1/2
0123456789101112131415
оружием, нож: 6 из 16 = 3/8 (убить)
0123456789101112131415
оружием, пистолет: 12 из 16 = 3/4

Почему 16, а не 100, как в настольных играх? Потому что 16 — степень двойки: AND #15 выдаёт ровно 0–15, все варианты одинаково часто. Кубик на 10 граней пришлось бы делать делением — а деления у процессора нет.

Состояния NPC

Поле +5 таблицы NPC (глава 7) — состояние. Бой добавляет три новых:

0 идёт · 1 стоитобычная жизнь
A, удача →
2 оглушёнлежит 60 ходов (~5 с), потом встаёт — злой
пробел + верёвка →
3 связанлежит, пока герой на экране
0 · 1 · 2на ногах или лежит
W, удача →
4 убит2 хода — стереть с обеих страниц, потом слот пуст

Хитрость с рисованием: у лежащего в поле «шаг» (+4) записывается то же число, что состояние, — 2, 3 или 4. У идущего там 0 или 1. Значит, поле «шаг» изменилось, и NPC_ERASE из главы 7 сам поймёт, что NPC надо стереть и нарисовать заново — уже лежащим. Отдельного «перерисуй» не нужно.

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

CMB_NEAR: кто вплотную

И удар, и обыск начинаются с вопроса «кто рядом»: ближе 10 по x / 2 и 20 по y. Но удар ищет стоящего на ногах, а обыск — оглушённого. Это решает переменная CWANT: 0 — нужен на ногах, 2 — оглушённый. Красивое место — как одна проверка обслуживает оба случая:

        LDA OBJ+OBJ_ST,X
        CMP #2
        BCS @down               ; состояние ≥ 2 — лежит
        LDA CWANT               ; на ногах — а нужен на ногах?
        BNE @next
        BEQ @dist               ; да — меряем расстояние
@down:
        BNE @next               ; ≥ 2 и не равно 2 — связан или убит: не наш
        LDA CWANT               ; ровно 2 — оглушён: а нужен оглушённый?
        BEQ @next

CMP #2 ставит сразу два флага, и их хватает на три ответа: C = 0 — меньше 2 (на ногах), C = 1 и Z = 1 — ровно 2 (оглушён), C = 1 и Z = 0 — больше (связан, убит). На метке @down флаги ещё от того же CMP — BCS их не меняет. Тот же приём, что CPY #1 в главе 9.

BNE @next / BEQ @dist подряд — это «прыгни всегда»: одно из двух условий точно верно. Так пишут вместо JMP, когда цель близко: на байт короче.

Карман: монетка во флаге C

У каждого типа NPC в кармане один из двух товаров: у жителя — консервы или продукты, у охранника — лекарства или батарейки, у мародёра — бензин или краденое. Выбор из двух:

        JSR GEN_RND             ; что из двух
        LSR A                   ; бит 0 → флаг C: монетка
        LDA POCKA,Y             ; первый вариант (LDA флаг C не трогает!)
        BCC @g
        LDA POCKB,Y             ; монетка = 1 — второй
@g:

LSR как подброс монетки

бит
7
6
5
4
3
2
1
0
RND
1
0
0
1
1
1
0
1
$9D
LSR A
0
1
0
0
1
1
1
0
$4E бит 0 (1) выпал в C → C = 1
LDA POCKA,Y
0
0
0
0
0
0
1
1
A = 3 (бензин), но C всё ещё 1
BCC не прыгает
0
0
0
0
1
1
1
1
LDA POCKB,Y: A = 15 — краденое

Сначала случайный бит кладут в C, потом спокойно загружают в A первый вариант — LDA меняет только N и Z, перенос остаётся. И лишь потом смотрят на монетку. Без этого пришлось бы где-то хранить случайное число, пока грузится вариант.

У мародёра есть ещё один бросок — AND #%00000111 / BNE: 1 случай из 8, что вместо товара у него оружие. Сначала нож, если его нет у героя, потом пистолет. Оружие — бит в байте EQUIP (глава 9), «выдать» его — ORA #EQ_KNIFE.

Забрали карман — в поле враждебности записывается 14 (H_EMPTY): и «карман пуст», и «злится» (≥ 8 — враждебен, глава 7). Одно число — два смысла.

Связать — и мародёров станет меньше

Пробел рядом с оглушённым: карман, а если в рюкзаке есть верёвка (товар 14) — ещё и связать. Связанный мародёр работает на будущее: у каждой локации есть счётчик «сколько здесь связали мародёров» — старшие 4 бита байта LOC_GROW3, свободная половина того же байта, где лежит рост третьего поселения (глава 9).

        LDA LOC_GROW3,X         ; старшие 4 бита — счётчик, до 15
        CMP #$F0
        BCS @say                ; уже 15 — дальше некуда
        CLC
        ADC #16                 ; +1 к старшей половине
        STA LOC_GROW3,X

Когда на экране этой локации появляются NPC, каждого мародёра бросают против счётчика: GEN_RND / AND #15 / CMP счётчик / BCC — не ставить. Связал 4 мародёров — каждый новый появляется с шансом 12 из 16. Связал 15 — почти никого. Вот она, механика «наводишь порядок — место становится спокойнее», в шести командах.

Убить: цена

W — удар оружием, лучшим из того, что есть: пистолет (12/16), иначе нож (6/16). Удача — NPC убит, его карман — в рюкзак. И сразу расплата: репутация у группы убитого −4, у мародёров ещё −2 («мститель»), статус −16, счётчик убийств +1.

        LDA REPS,Y              ; репутация у группы
        SEC
        SBC #4
        BCS @r                  ; не ушли в минус — так и оставить
        LDA #0                  ; ушли — ноль, меньше не бывает
@r:
        STA REPS,Y

«Вычесть, но не ниже нуля» — по флагу C после SBC: C = 0 значит «был заём, ушли в минус». А счётчик убийств — наоборот, «прибавить, но не выше 255»: CMP #255 / BEQ / INC. Без этой проверки 256-е убийство превратило бы счётчик в 0 — и убийца стал бы для всех невинным. Такие «упоры» нужны везде, где байт может переполниться.

NPC бьёт в ответ

Враждебный NPC вплотную (глава 7) вызывает CMB_BITE. Бьёт не каждый ход, а раз в 12 своих ходов (~1 с): поле «таймер» отсчитывает паузу. Попал (бросок против TBITE) — здоровье −1. Дошло до нуля — герой не умирает: у него забирают весь груз, рюкзак пустеет, все на экране успокаиваются (враждебность 0), здоровье снова 9. Наказание — потеря товара, а не конец игры.

Здоровье: отдых и лекарства

Здоровье 0–9 восстанавливается двумя способами. M — лекарство из рюкзака: +5, но не больше 9 (CMP #HPMAX+1 / BCC — «≤ 9 оставить, иначе 9»). И отдых — CMB_TICK, который главный цикл вызывает каждый кадр (глава 0): если на экране нет никого враждебного на ногах и в рюкзаке есть вода и еда — каждые 10 секунд +1.

Как отсчитать 10 секунд без часов? Счётчик кадров. Игра делает примерно 45 кадров в секунду, поэтому два счётчика друг в друге:

        INC RTICK               ; кадры
        LDA RTICK
        CMP #FPS                ; 45 кадров = 1 секунда
        BCC @r
        LDA #0
        STA RTICK
        INC RSEC                ; секунды
        LDA RSEC
        CMP #REGEN              ; 10 секунд
        BCC @r
        LDA #0
        STA RSEC
        INC HP                  ; +1 здоровья

Как минутная и часовая стрелки: одна досчитала до 45 — сбросилась, а вторая шагнула на 1. Любое «нельзя отдыхать» сбрасывает обе — и отдых начинается заново.

Вода и еда — как топливо в Elite

Запасы тратятся не по часам, а за переходы между экранами (и за обыск): каждый 8-й переход — 1 вода, каждый 16-й — 1 еда (сначала свежие продукты, потом консервы). Счётчик переходов SWALK один, а «каждый 8-й» — это маска:

Каждый 8-й: SWALK AND #7 = 0

бит
7
6
5
4
3
2
1
0
SWALK = 23
0
0
0
1
0
1
1
1
23
AND #7
0
0
0
0
0
1
1
1
=
0
0
0
0
0
1
1
1
7 не 0 — воду не тратим
SWALK = 24
0
0
0
1
1
0
0
0
24
AND #7
0
0
0
0
0
1
1
1
=
0
0
0
0
0
0
0
0
0 0 — каждый 8-й: −1 вода

Три младших бита числа — это остаток от деления на 8. Они равны нулю ровно у 8, 16, 24… С маской 15 — каждый 16-й. Как и у кубика, это работает только для степеней двойки: SUP_WATER-1 при 8 даёт маску 7 = 111, а при 10 дало бы 9 = 1001 — и счёт пошёл бы неровно.

Нечем пить или есть — «THIRSTY» / «HUNGRY» и здоровье −1. Здоровье кончилось так — «YOU COLLAPSE»: груз потерян, здоровье снова 9. Внизу панели это видно всё время: «HEALTH 9 W2 F3» — здоровье, вода, еда (HUD_HP, строка 23).

CMB_SAY: стек как временная полка

Сообщение «THE RAIDER IS DOWN!» собирается из трёх кусков: «THE », имя типа из таблицы TXT_NPC и хвост — номер фразы. Номер хвоста приходит в A, но A нужен, чтобы печатать первые два куска. Решение — положить его на стек и достать в конце:

CMB_SAY:
        PHA                     ; номер хвоста — на стек
        JSR MSG_CLEAR
        ...                     ; «THE », имя типа — A занят
        PLA                     ; номер хвоста — со стека
        JSR PUT_MSG
        JMP HUD_COPY

Между PHA и PLA вызываются другие подпрограммы — и это безопасно: каждая JSR кладёт на стек свой адрес возврата сверху и снимает его своим RTS. Стек — стопка: что положил последним, то и снимешь первым. Главное — чтобы на каждый PHA был ровно один PLA.

Глава 11. Статус и окно I

Кто такой герой для этого мира — одно число, очки статуса STPTS, 0–255. Из него получается ступень: от RAIDER (мародёр) до LEGEND (тот, кто включил свет). Рядом — репутация у трёх групп: охраны, мародёров и жителей, по числу 0–15 на группу. Всё это видно в окне, которое открывает клавиша I.

Окно статуса: HELPER (118), NEXT AT 128, здоровье, деньги, снаряжение, репутация полосками
Окно I: статус HELPER (118 очков), следующая ступень — со 128. Ниже — здоровье, деньги, снаряжение, детали, репутация полосками и статистика.

Ступень = очки / 32

Восемь ступеней, 256 очков — по 32 очка на ступень. Делить на 32 — это пять сдвигов вправо: 32 = 2⁵.

118 очков → ступень 3 (HELPER)

бит
7
6
5
4
3
2
1
0
STPTS
0
1
1
1
0
1
1
0
118
5 × LSR
0
0
0
0
0
0
1
1
3 старшие 3 бита и есть ступень: 3 — HELPER
STPTS
0
1
1
1
0
1
1
0
118
AND #%11100000
1
1
1
0
0
0
0
0
96 начало своей ступени
ADC #32
1
0
0
0
0
0
0
0
128 «NEXT AT 128» — начало следующей

Обе строчки окна — «HELPER (118)» и «NEXT AT 128» — из одного байта. Ступень — его три старших бита. Порог следующей — те же три бита с обнулёнными младшими (начало своей ступени) плюс 32. Младшие 5 бит — «сколько уже набрано внутри ступени».

0–3132–6364–9596–127128–159160–191192–223224–255
0
RAIDER
1
STRANGER
2
NEIGHBOUR
3
HELPER
4
PILLAR
5
MAYOR
6
HERO
7
LEGEND

Слово ступени — снова таблица адресов строк (TXT_RANKS, в скрытой памяти): ступень × 2 → адрес → HUD_PUTS. Номер получается пятью LSR, а умножение на 2 — одним ASL сразу после них.

Что двигает статус

ПоступокОчкиГде в коде
продал поселению нужный товар — за штуку+1MKT_SELL (глава 9)
поселение выросло+8MKT_SELL
связал мародёра+2CMB_LOOT (глава 10)
запустил подстанцию+16SUB_START (глава 12)
ударил жителя или охранника при свидетелях−2CMB_WITNESS
убил−16CMB_SHOOT

Старт — 32 очка, STRANGER. С 64 (NEIGHBOUR) героя пускают на развитые рынки и охрана перестаёт злиться (CMB_GUARDH: +2 к враждебности охранника, пока статус ниже 64). Для запуска подстанции нужно 160 (MAYOR).

PTS_ADD: потолок HERO

PTS_ADD:
        CLC
        ADC STPTS
        BCS @cap                ; перевалило за 255
        CMP #PTS_CAP+1          ; больше 223?
        BCC @ok
@cap:
        LDA #PTS_CAP            ; 223 — верх ступени HERO
@ok:
        STA STPTS
        RTS

Два упора подряд. Сначала — перенос: 220 + 16 = 236, это помещается в байт; а 250 + 16 = 266 — не помещается, ADC выдаст 10 и C = 1. Без проверки C герой упал бы с HERO на RAIDER. Потом — потолок 223: продажами и связыванием нельзя стать LEGEND. Ступень 7 (224–255) достаётся только в финале, когда FINALE записывает 255 напрямую (глава 15).

PTS_SUB — зеркально: SEC / SBC, и если C = 0 (ушли в минус) — 0. Тот же «не ниже нуля», что у репутации в главе 10.

Репутация: REP_INC без CLC

REP_INC:                        ; Y = группа 0–2
        LDA REPS,Y
        CMP #15
        BCS @r                  ; уже 15 — не растёт
        ADC #1                  ; C = 0 после CMP < 15 — CLC не нужен
        STA REPS,Y
@r:
        RTS

Ещё одно «флаг уже стоит как надо». Если выполнение дошло до ADC, значит, BCS не прыгнул, то есть C = 0 — и CLC писать незачем. Байт и два такта экономии; в коде игры таких мест десятки — их стоит узнавать в лицо.

Три группы — три байта подряд (REPS: охрана, мародёры, жители), номер группы приходит в Y. Таблица TGRP из главы 7 говорит, к какой группе относится тип NPC.

INF_SHOW: окно и полоски

Окно I — весь экран текстом, как рынок: TXTSET, HOME, строки по местам через MKT_AT (курсор в начало строки A). Почти всё — уже знакомые кусочки: фраза по номеру, число через PR_A0, слово из таблицы. Новое только полоски репутации — 15 клеток, «#» за каждое очко, «.» за остальные:

        LDY #0                  ; клетка 0–14
@bar:
        LDA #$A3                ; «#»
        CPY MTMP                ; клетка < репутации?
        BCC @b
        LDA #$AE                ; иначе «.»
@b:
        JSR COUT
        INY
        CPY #15
        BNE @bar

Приём «загрузи один вариант, а при условии — перезапиши» (как карман в главе 10). Охрана с репутацией 11: клетки 0–10 — «#», 11–14 — «.»: ###########..... Ровно как на скриншоте.

Выход — пробел, Esc или ещё раз I: SCR_BACK (глава 9) возвращает графику и перепечатывает панель.

Глава 12. Подстанция и чёрный старт

Цель игры. В каждом регионе одна подстанция. Принёс трансформатор, кабель и реле, 10 канистр топлива, заслужил статус MAYOR — нажимаешь S, и регион получает свет. Так в 2025 году поднимали сеть Испании: «чёрный старт», подстанция за подстанцией. Когда горят все восемь — финал.

SUB_INIT: где подстанция

Место подстанции тоже не хранится — это один байт зерна. Берётся старший байт S3 локации 0 — восьмой байт таблицы зёрен (глава 1):

SUB_INIT:
        LDA WLD_TAB+7            ; локация 0, байт 7
        CMP #$37
        BNE @ok
        EOR #%10000000          ; совпала со стартом — в другую половину карты
@ok:
        STA SUBLOC
        RTS

У Каталонии это $1F — строка 1, столбец 15, правый верхний край карты. Номер локации и есть байт 0–255, так что любой байт годится как место. Одна защита: если выпал $37 — старт игры, — подстанция переезжает EOR #$80:

$37 → $B7: переворот бита 7 = +8 строк

бит
7
6
5
4
3
2
1
0
$37
0
0
1
1
0
1
1
1
EOR #$80
1
0
0
0
0
0
0
0
= $B7
1
0
1
1
0
1
1
1
строка 3 → 11, столбец тот же

Бит 7 номера — старший бит строки (глава 1: строка — старшие 4 бита). Перевернуть его — сдвинуться на 8 строк, в другую половину карты. Подстанция гарантированно далеко от старта.

Локация подстанции особая. SUB_LOC при загрузке обнуляет ей все роли экранов — поселений там нет, все 9 экранов — окрестности. А SUB_GEN в конце построения экрана ставит на экран 4 штамп двора 6 × 3 — опоры, провода, трансформаторы, генераторы, сетку забора. В клетку 12, 5: строка 4 и столбец 10 свободны под дороги, как у всех шаблонов (глава 3).

ST_SUBST:
        .byte 6, 3
        .byte T_PYLON, T_WIRES, T_WIRES, T_WIRES, T_WIRES, T_PYLON
        .byte T_MESH_FENCE, T_TRANSFORMER, T_GENERATOR, T_TRANSFORMER, T_GENERATOR, T_MESH_FENCE
        .byte T_MESH_FENCE, T_GRAVEL, T_GRAVEL, T_GRAVEL, T_GRAVEL, T_MESH_FENCE
ST_SUBLIT:                      ; со светом: фонари вместо опор
        .byte 6, 3
        .byte T_LAMP, T_WIRES, T_WIRES, T_WIRES, T_WIRES, T_LAMP
        ...

Два штампа одинаковой формы — тёмный и со светом. Какой ставить, решает один бит (ниже). Проходимость у обоих одинаковая, поэтому после пуска герою не нужно никуда сдвигаться.

SUB_OK: «всё ли готово» одним флагом

SUB_OK:
        LDX #2                  ; детали: по одной каждого вида
@p:
        LDA PARTS,X
        BEQ @no                 ; какой-то нет — нельзя
        DEX
        BPL @p
        LDA BAG+3               ; топливо
        CMP #SUB_FUEL
        BCC @no                 ; меньше 10 — нельзя
        LDA STPTS               ; статус не ниже MAYOR …
        CMP #ST_MAYOR
        RTS                     ; … ответ — C прямо из CMP
@no:
        CLC
        RTS

Последняя проверка ничего не ветвит: CMP #160 сам ставит C = 1, если статус ≥ 160, — а это и есть ответ подпрограммы «да». Сравнение превращается в результат. Тот же трюк в окне подстанции: LDA PARTS,X / CMP #1 / JSR SUB_MARK — SUB_MARK печатает «OK», если C = 1 (есть хотя бы одна), и «--», если нет.

Окно подстанции: TRANSFORMER 1/1 OK, CABLE 1/1 OK, RELAY 1/1 OK, FUEL 10/10 OK, STATUS MAYOR OK, S - BLACK START
Всё готово: напротив каждого условия «OK», внизу «S - BLACK START».

Свет по регионам: один байт на 8 регионов

Где горит свет, хранится в байте LIT: бит на регион. У текущего региона есть «свой бит» RBIT — 1, 2, 4 … 128 (таблица REG_BITS, глава 14).

LIT: свет в Каталонии и Арагоне

бит
7
6
5
4
3
2
1
0
LIT
0
0
0
0
0
0
1
1
$03 бит 0 — CATALONIA, бит 1 — ARAGON
LDA LIT / AND RBIT
0
0
0
0
0
0
1
0
герой в Арагоне: RBIT = 2
=
0
0
0
0
0
0
1
0
$02 не 0 → свет здесь есть: двор со светом
LIT ORA RBIT
0
0
0
0
0
1
1
1
$07 пуск в Стране Басков (RBIT = 4)

«Есть ли свет здесь» — AND RBIT, «включить свет здесь» — ORA RBIT, «горит ли везде» — CMP #$FF: все 8 бит. Один байт на всю цель игры.

SUB_START: что делает пуск

  1. Детали и топливо уходят в дело: DEC PARTS,X × 3, топливо −10.
  2. Свет: LIT ORA RBIT.
  3. Статус +16.
  4. Все поселения всех 256 локаций региона +1 к росту. Свет пришёл — ожил весь регион.
  5. Если LIT стал $FF — горят все восемь: JMP FINALE.

Пункт 4 — цикл по X от 0 до 255 (INX / BNE — после 255 будет 0, глава 1), и в каждой локации три «полубайта» роста из главы 9. Каждый — со своим упором:

        LDA LOC_GROW,X          ; поселение 1 — младшие 4 бита
        AND #%00001111
        CMP #15
        BCS @s2                 ; уже 15 — не трогать, иначе +1 залезет в старшую половину
        INC LOC_GROW,X
@s2:
        LDA LOC_GROW,X          ; поселение 2 — старшие
        CMP #$F0
        BCS @s3                 ; уже 15 — +16 переполнило бы байт
        CLC
        ADC #16
        STA LOC_GROW,X

Почему здесь упор нужен, а в главе 9 — нет? Там рост вызывают только пока уровень меньше 7. Здесь растут все подряд, и полубайт, дошедший до 15, без проверки «перелился» бы в соседнюю половину байта — в рост другого поселения. Для младшей половины проверяют её отдельно (AND #15), для старшей хватает сравнить весь байт с $F0: старшая половина 15 — это значит байт не меньше $F0.

Двор подстанции со светом, THE GRID IS ALIVE! CATALONIA HAS LIGHT
После пуска: экран перестроен со штампом «со светом» и фонарями, на панели — «THE GRID IS ALIVE! CATALONIA HAS LIGHT».

Выходя из окна после пуска, игра перестраивает экран (SCR_GEN): SUB_GEN теперь видит свет и ставит штамп с фонарями, а выросшие поселения отстраиваются по шаблонам (главы 3, 9).

Глава 13. Карта и туман

Return на экране — карта региона: 16 × 16 клеток, клетка — локация. Но видна не вся: только те, где герой был, и их соседи. Остальное — пусто, «туман». С карты же можно ехать: на велосипеде или мотоцикле — сразу в известную клетку неподалёку. И здесь же спрятан чит из Doom.

Карта региона: значки известных клеток, @ — герой, * — подстанция, внизу имя и тип клетки под курсором
Карта: «@» — герой, «*» — подстанция, «!» анархия, «.» сельская, «+» промышленная, «#» развитая. Внизу — клетка под курсором (инверсная).

Карта — это текст

Карта не рисуется в HiRes: это текстовый экран, клетка — один символ. Локация n стоит в строке n / 16, столбце n AND 15 — та же раскладка номера, что в главе 1. Поставить курсор в клетку — MAP_GOTO:

MAP_GOTO:
        STA MAPT
        LSR A                   ; строка = n / 16
        LSR A
        LSR A
        LSR A
        STA CV
        JSR VTAB                ; BASL = адрес строки (глава 8)
        LDA MAPT
        AND #%00001111          ; столбец = n AND 15
        STA CH
        RTS

Значок типа — из строки MAP_SYM: .asc "!.+#": тип 0–3 (биты 0–1 старшего байта S0) — это сразу номер символа в строке. Тип берётся через WLD_BYTE — один байт зерна из таблицы, без копирования всех 8 в SEED: на карте 256 клеток, и экономия заметна.

Туман: бит «был здесь»

У каждой локации в LOC_SRCH есть бит 6 — «был здесь» (SEEN). Его ставит MAP_BEEN при каждой загрузке локации — одной командой ORA #SEEN. Биты 0–5 того же байта — «обыскано» (глава 9).

Клетка видна, если «был здесь» стоит у неё самой или у любого из четырёх соседей. MAP_SEE проверяет пять байтов, а соседей находит уже знакомыми WLD_RIGHT / LEFT / UP / DOWN — с их честным «C = 1 — край карты, соседа нет» (глава 1):

        TAX
        LDA LOC_SRCH,X          ; сама
        AND #SEEN
        BNE @yes
        TXA
        JSR WLD_RIGHT           ; сосед справа
        BCS @l                  ; край — такого нет, к следующему
        TAX
        LDA LOC_SRCH,X
        AND #SEEN
        BNE @yes
        ...

MAP_FOG проходит все 256 клеток один раз: видна — печатает значок, не видна — не трогает (после HOME там и так пробел).

Подстанцию видно всегда: «*» печатается отдельно, после тумана. Сверху — «@», где герой: LDA #$40 — «@» в мигающем режиме (глава 8: биты 7–6 = 01). Перед этим MAP_MARK запоминает, какой символ был в клетке, — чтобы потом вернуть.

Курсор просмотра: инверсия одним AND

Стрелки на карте двигают курсор просмотра. Курсор — это та же клетка, только инверсная: у символа сбрасываются два старших бита.

«+» → инверсный «+»

бит
7
6
5
4
3
2
1
0
символ «+»
1
0
1
0
1
0
1
1
$AB
AND #%00111111
0
0
1
1
1
1
1
1
= инверсный
0
0
1
0
1
0
1
1
$2B биты 7–6 = 00 — тёмный «+» на светлом

Прежний символ сохраняется в MCURU и возвращается, когда курсор уходит (CUR_OFF). Читать и писать символ прямо в память экрана — LDA (BASL),Y / STA (BASL),Y с Y = столбец: BASL — адрес строки, который поставил VTAB. Без COUT — он бы сдвинул курсор.

Под картой — что за клетка под курсором (MV_INFO): имя (глава 2), тип и порядок, пометка «YOU ARE HERE» / «SUBSTATION» / «BEEN HERE». Для невидимой — только «UNKNOWN». Имя и тип требуют зерна клетки — WLD_GET кладёт его в SEED. Поэтому, уходя с карты, игра возвращает в SEED зерно своей локации: карта его «испортила».

Клавиши ждёт KEY_WAIT — свой маленький цикл LDA KBD / BPL вместо RDKEY из ПЗУ: тот показывает мигающий курсор, а на карте он не нужен.

Транспорт: расстояние «по большей стороне»

С велосипедом можно ехать в любую известную клетку на расстоянии до 5, с мотоциклом — до 10. Расстояние — большая из двух разностей, по столбцу и по строке (как ходит король в шахматах: по диагонали шаг тоже один):

0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
0
00
01
02
03
04
05
06
07
08
09
0A
0B
0C
0D
0E
0F
1
10
11
12
13
14
15
16
17
18
19
1A
1B
1C
1D
1E
1F
2
20
21
22
23
24
25
26
27
28
29
2A
2B
2C
2D
2E
2F
3
30
31
32
33
34
35
36
37
38
39
3A
3B
3C
3D
3E
3F
4
40
41
42
43
44
45
46
47
48
49
4A
4B
4C
4D
4E
4F
5
50
51
52
53
54
55
56
57
58
59
5A
5B
5C
5D
5E
5F
6
60
61
62
63
64
65
66
67
68
69
6A
6B
6C
6D
6E
6F
7
70
71
72
73
74
75
76
77
78
79
7A
7B
7C
7D
7E
7F
8
80
81
82
83
84
85
86
87
88
89
8A
8B
8C
8D
8E
8F
9
90
91
92
93
94
95
96
97
98
99
9A
9B
9C
9D
9E
9F
A
A0
A1
A2
A3
A4
A5
A6
A7
A8
A9
AA
AB
AC
AD
AE
AF
B
B0
B1
B2
B3
B4
B5
B6
B7
B8
B9
BA
BB
BC
BD
BE
BF
C
C0
C1
C2
C3
C4
C5
C6
C7
C8
C9
CA
CB
CC
CD
CE
CF
D
D0
D1
D2
D3
D4
D5
D6
D7
D8
D9
DA
DB
DC
DD
DE
DF
E
E0
E1
E2
E3
E4
E5
E6
E7
E8
E9
EA
EB
EC
ED
EE
EF
F
F0
F1
F2
F3
F4
F5
F6
F7
F8
F9
FA
FB
FC
FD
FE
FF
$37 → $3C: по столбцу |7 − 12| = 5, по строке 0 → расстояние 5. Зелёные — все клетки на расстоянии ≤ 5: квадрат 11 × 11 вокруг героя.
TRV_DIST:
        LDA MCUR                ; столбец цели
        AND #%00001111
        STA TDIST
        LDA HERE                ; столбец героя
        AND #%00001111
        SEC
        SBC TDIST
        JSR ABSC                ; |разность| (глава 7)
        STA TDIST
        ...                     ; то же для строк (4 × LSR)
        CMP TDIST
        BCC @r                  ; строки ближе — оставить столбцы
        STA TDIST               ; иначе — строки

Мотоцикл тратит топливо: (клеток + 2) / 3 — одна канистра на 3 клетки, с округлением вверх. Делить на 3 процессор не умеет — вычитаем 3, пока можно, и считаем:

        CLC
        ADC #2                  ; расстояние + 2
        LDX #0
@div:
        CMP #3
        BCC @d                  ; меньше 3 — хватит
        SBC #3                  ; C = 1 после CMP — SEC не нужен
        INX                     ; ещё одна канистра
        BNE @div
@d:
        STX TNEED

7 клеток: 7 + 2 = 9 → 6 → 3 → 0, три вычитания — 3 канистры. «+ 2» перед делением и даёт округление вверх: 7 / 3 = 2,33 → 3. Это то же деление вычитанием, что печать чисел в главе 9, только делитель один. Велосипед тратит вместо топлива воду и еду — как будто герой прошёл столько экранов (SUP_STEP в цикле).

Доехали — LOC_ENTER: локация, экран 4, герой на свободное место. Это та же последовательность, что @enter в главном цикле (глава 0), только вынесенная в подпрограмму: ею пользуются и поездка, и гиперпереход между регионами (глава 14).

IDKFA: чит с памятью

Набрать на карте I-D-K-F-A — +250 €. Как в Doom, только вместо оружия деньги. Подпрограмма CHEAT получает каждую клавишу карты и помнит, сколько букв слова уже набрано (CHT, 0–4):

CHEAT:
        PHA                     ; клавишу вернём как была
        AND #%11011111          ; строчные → заглавные
        LDX CHT
        CMP TXT_IDKFA,X         ; та буква, что ждём?
        BEQ @next
        LDX #0                  ; нет — сначала;
        CMP TXT_IDKFA           ; но вдруг это «I» — начало заново
        BNE @put
@next:
        INX
        CPX #5                  ; все 5 букв — +250 €
        ...

Строчная → заглавная: сбросить бит 5

бит
7
6
5
4
3
2
1
0
«i»
1
1
1
0
1
0
0
1
$E9
AND #%11011111
1
1
0
1
1
1
1
1
= «I»
1
1
0
0
1
0
0
1
$C9

В кодах ASCII строчная буква отличается от заглавной ровно битом 5: «I» = $C9, «i» = $E9. Сбросить его — и регистр больше не важен. У стрелок и Return бит 5 и так 0, они не портятся. Тот же приём стоит в меню (глава 15).

Мелочь — «вдруг это I». Набрали «I-D-I-D-K-F-A»: на третьей букве ждали «K», пришла «I» — счётчик сбрасывается в 0. Но эта «I» сама может быть началом слова. Поэтому после сброса её ещё раз сравнивают с первой буквой — и если совпала, счётчик становится 1, а не 0. Без этой проверки такую строку чит бы не принял.

Деньги прибавляются 16-битно с упором на $FFFF (глава 9), клавиша возвращается из стека (PLA) — карта получает её нетронутой и обработает как обычно.

Глава 14. Регионы и диск

Испания — 8 регионов, сеткой 3 × 3 «как на карте»: Страна Басков, Арагон, Каталония сверху, Кастилия, Мадрид, Валенсия посередине, Андалусия и Мурсия внизу. У каждого своё зерно (глава 1) — свои 256 локаций. В памяти помещается только один регион, поэтому, уезжая, игра записывает на дискету всё, что в нём изменилось, а возвращаясь — читает обратно. Эта глава — про соседей, переезд и работу с дискетой прямо из программы.

2BASQUEбит 2 = 4
1ARAGONбит 1 = 2
0CATALONIAбит 0 = 1
3CASTILEбит 3 = 8
4MADRIDбит 4 = 16
5VALENCIAбит 5 = 32
6ANDALUSIAбит 6 = 64
7MURCIAбит 7 = 128
море

Где регион в сетке — две таблицы, REG_COL и REG_ROW. Кто сосед с какой стороны — таблица REG_NEIGH, 4 байта на регион (↑ → ↓ ←), $FF — море или граница:

REG_NEIGH:                      ; ↑ → ↓ ←
        .byte $FF, $FF, 5, 1    ; 0 CATALONIA: вниз — Валенсия, влево — Арагон
        .byte $FF, 0, 4, 2      ; 1 ARAGON
        ...
        .byte 4, $FF, $FF, 6    ; 7 MURCIA

Номер в таблице — регион × 4 + сторона (ASL ASL / ADC HDIR). Сторона — тот же номер направления ↑0 →1 ↓2 ←3, что везде в игре.

Три байта-набора битов описывают все 8 регионов сразу, по биту на регион (таблица REG_BITS: 1, 2, 4 … 128): RBIT — бит текущего, RVISIT — где герой уже был, LIT — где горит свет (глава 12). На схеме выше подсвечены Каталония и Арагон — RVISIT = %00000011 = 3.

REG_EDGE: через край региона

Из главы 6: герой ушёл за край экрана, WALK_* сказал «край региона» — управление попадает в REG_EDGE. Нужен сосед с этой стороны (не море), мотоцикл и 5 канистр. Если всё есть — герой появляется в соседнем регионе у противоположного края, в той же строке или том же столбце. Новая локация считается двумя масками:

Каталония $30, влево → Арагон $3F

бит
7
6
5
4
3
2
1
0
HERE
0
0
1
1
0
0
0
0
$30 строка 3, столбец 0 — левый край
AND REG_KEEP[←]
1
1
1
1
0
0
0
0
$F0 влево: строка остаётся
=
0
0
1
1
0
0
0
0
$30
ORA REG_EDGEL[←]
0
0
0
0
1
1
1
1
$0F … а столбец — правый край, 15
= новая
0
0
1
1
1
1
1
1
$3F строка 3, столбец 15 — в Арагоне

REG_KEEP говорит, какая половина номера сохраняется ($F0 — строка, $0F — столбец), REG_EDGEL — какой край вписать в другую половину. Для ↑: сохранить столбец, строку — нижнюю ($F0). Четыре направления — четыре пары масок в таблицах, без единого «если».

Экран — как в главе 6 через край локации: влево — +2, вправо — −2, вверх — +6, вниз — −6. В таблице REG_SCRD «−2» записано как 254 и «−6» как 250 — сложение по кругу 256 (глава 3).

REG_SWITCH: что происходит при смене региона

  1. На время работы с диском — текстовый экран: «TRAVELLING TO ARAGON».
  2. REG_PUT: три таблицы текущего региона — LOC_SRCH, LOC_GROW, LOC_GROW3, по 256 байт — переложить подряд в буфер $4000 и записать на дискету файлом REG0…REG7.
  3. Сменить REGION и RBIT, WLD_FILL — новые 256 зёрен, SUB_INIT — новая подстанция.
  4. Был там уже (RVISIT AND RBIT)? — REG_GET читает его файл обратно в таблицы. Нет — таблицы обнуляются, и бит ставится в RVISIT.

Вот и всё «сохранение мира»: 768 байт на регион. Ни одна локация, ни один экран, ни одна цена не записываются — их снова даст зерно. На дискету идёт только то, что изменилось за игру: где обыскано, где герой был, на сколько выросли поселения, сколько мародёров связал.

Почему буфер — $4000? Это HiRes-страница 2. Пока идёт работа с диском, на экране текст, графика не нужна — 8 КБ свободной памяти. После переезда новый экран всё равно рисуется заново.

REG_DOS: команда DOS с цифрой региона

Как программа просит DOS записать файл — глава 0: печатает Ctrl-D и текст команды. Новое здесь — номер региона в имени файла. Шаблон один на все восемь:

TXT_BSAVE:      .asc "BSAVE REG#,A$4000,L$300"
                .byte 0
@c:
        LDA (STR),Y             ; символ шаблона
        BEQ @end
        CMP #$A3                ; «#»?
        BNE @p
        LDA REGION              ; → цифра региона
        ORA #$B0
@p:
        JSR COUT
        INY
        BNE @c

Встретили «#» — вместо него печатается REGION ORA #$B0 (цифра → символ, глава 6). Для Арагона DOS получит «BSAVE REG1,A$4000,L$300»: записать 768 байт ($300) с адреса $4000 в файл REG1. Тем же шаблоном с «#» читается файл (BLOAD REG#,A$4000).

REG_VIEW: обзор Испании и гиперпрыжок

R на карте — обзор восьми регионов. Позиции на экране считаются из места в сетке: строка = 3 + ряд × 5, столбец = место × 13. Снова умножения сдвигами и сложением: × 5 = × 4 + × 1, × 13 = × 8 + × 4 + × 1:

        LDA REG_COL,X           ; c
        ASL A
        ASL A                   ; 4c
        STA CH
        ASL A                   ; 8c
        ADC CH                  ; 12c
        ADC REG_COL,X           ; 13c
        STA CH

T на обзоре — гиперпрыжок в регион, где уже был: 5 канистр за каждый шаг по сетке (|Δ столбца| + |Δ ряда| — здесь уже не «король», а обычные шаги по сторонам), с мотоциклом. Герой появляется в центре региона — в локации $77.

Глава 15. Меню, сохранение, заставка, LEGEND

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

TITLE: меню из таблицы

Титульное меню: BLACKOUT, SPAIN YEARS LATER, N - NEW GAME, C - CONTINUE, Q - QUIT TO DOS
Титульное меню — пять строк текста.

Пять строк меню — не пять кусков кода, а таблица троек «строка, столбец, номер фразы», с нулём в конце:

TITLE_TAB:  .byte 4, 16, M_TBLACK,  6, 11, M_TSPAIN,  10, 12, M_TNEW,  12, 12, M_TCONT,  14, 12, M_TQUIT,  0
@l:
        STX MG
        LDA TITLE_TAB,X         ; строка (0 — конец таблицы)
        BEQ @key
        JSR MKT_AT              ; курсор в начало строки
        LDX MG
        LDA TITLE_TAB+1,X
        STA CH                  ; столбец
        LDA TITLE_TAB+2,X
        JSR PUT_MSG             ; фраза (глава 8)
        LDA MG
        CLC
        ADC #3                  ; следующая тройка
        TAX
        BNE @l

Подвинуть строку меню — поменять одно число в таблице. Тот же приём «данные вместо кода», что у ROSTER, шаблонов поселений и SAVE_TAB ниже. Нулевая строка экрана меню не нужна, поэтому 0 свободен как «конец».

Клавиша — AND #%11011111 (строчные → заглавные, глава 13) и три сравнения. N — CLC / RTS: «новая игра» (глава 0: JSR TITLE / BCC @newgame). Q — JMP $03D0: адрес «тёплого старта» DOS — выйти в DOS с приглашением «]», не перезагружая машину. C — попробовать загрузить сохранение.

Сохранение: HERO + REGn

Esc на карте — пауза: S — сохранить, Q — выйти, Return — назад. Сохранение — два файла:

Какие переменные — снова таблица: пары «адрес, длина», ноль в конце.

SAVE_TAB:       .word BAG     ; рюкзак 16, детали 3, деньги 2
                .byte 21
                .word REPS    ; репутация у трёх групп
                .byte 3
                .word HP      ; здоровье, снаряжение
                .byte 2
                .word KILLS   ; убийства, переходы, очки, вырастил, связал, подстанция, свет
                .byte 7
                .word REGION  ; регион, его бит, где был
                .byte 3
                .word HX2     ; герой: x / 2, y
                .byte 2
                ...
                .word 0
                .byte 0

Переменные лежат в памяти кусками, а не одним блоком, — таблица собирает их вместе. 21 + 3 + 2 + 7 + 3 + 2 + 1 + 1 = 40 байт плюс метка — помещается в 64.

SAVE_COPY: одна подпрограмма на «туда» и «обратно»

Сохранить — скопировать переменные в буфер. Загрузить — то же самое, только наоборот. Одна подпрограмма делает оба, а направление ей передают флагом C (C = 0 — в буфер, C = 1 — из буфера). Но внутри флаг C будет испорчен сложениями — надо его где-то запомнить. Как сохранить один бит?

SAVE_COPY:
        ROR MTMP                ; C → бит 7 ячейки MTMP
        ...
@b:
        BIT MTMP                ; бит 7 → флаг N
        BMI @in                 ; 1 — из буфера
        LDA (PTR),Y             ; 0 — в буфер:  переменная →
        STA (PTR2),Y            ;               → буфер
        JMP @n
@in:
        LDA (PTR2),Y            ; буфер →
        STA (PTR),Y             ;   → переменная

ROR кладёт флаг C в бит 7

бит
7
6
5
4
3
2
1
0
MTMP (что было)
0
0
1
0
1
0
1
0
$2A
C = 1 (загрузка)
0
0
0
0
0
0
0
1
ROR MTMP
1
0
0
1
0
1
0
1
$95 все биты вправо, C вошёл в бит 7 (бит 0 ушёл в C)
BIT MTMP
1
0
0
1
0
1
0
1
бит 7 → N = 1 → BMI @in: «из буфера»

ROR — «rotate right»: сдвиг вправо через перенос. Вылетевший бит 0 уходит в C, а старый C входит в бит 7. Важен только бит 7: в нём теперь направление. Остальные биты — мусор, но на них никто не смотрит. Потом в цикле BIT MTMP копирует бит 7 во флаг N — и BMI решает. Флаг C, который портят сложения указателей, больше не нужен.

Указатель PTR смотрит на очередную переменную из таблицы, PTR2 — в буфер, и после каждого куска сдвигается на его длину (16-битно, с переносом в старший байт — BCC / INC PTR2+1). Буфер — снова $4000, вторая страница графики (глава 14).

GAME_LOAD: продолжить с того же места

C в меню: BLOAD HERO,A$4000 и проверка первого байта — метки SAVE_MARK = $C2 (буква «B»). На дискете с самого начала лежит пустой файл HERO — 64 нуля. Пока игрок ни разу не сохранялся, метки нет: CLC / RTS, и меню пишет «NO SAVED GAME». Файл всегда есть — DOS не на что ругаться.

Метка есть — SEC и SAVE_COPY в обратную сторону. Дальше игра собирает мир заново, как при переезде и входе на экран: WLD_FILL (зёрна региона), SUB_INIT, REG_GET (его таблицы с дискеты), LOC_LOAD, SCR_GEN, NPC — и герой на сохранённом месте. Сохранено 40 байт, а восстанавливается весь мир: остальное снова даёт зерно.

FINALE: LEGEND

Когда после пуска подстанции LIT становится $FF — горят все 8 регионов, — SUB_START прыгает в FINALE:

FINALE:
        LDA #255
        STA STPTS               ; статус — LEGEND (глава 11: только здесь)
        ...
        JSR REG_DOS             ; BLOAD LEGEND,A$2000 — картинка сразу в видеопамять
        STA TXTCLR              ; графика …
        STA MIXCLR              ; … на весь экран, без 4 строк текста
        STA HIRES
        STA LOWSCR
        JSR KEY_WAIT
        STA MIXSET
        LDX #$FF                ; стек — заново
        TXS
        JMP start               ; как после запуска: титульное меню
LEGEND: герой у карты Испании с горящей сетью, THE LIGHTS ARE BACK ON. SPAIN IS ALIVE.
Финал: картинка LEGEND на весь экран.

Картинка — файл LEGEND, ровно 8 192 байта: та самая страница HiRes из главы 4, байт в байт. В исходнике это legend.s — .org $2000 и 8 192 числа в строках .byte. Ни одной команды, только данные: «чем картинка лежит в памяти, тем и записана». BLOAD кладёт её прямо по адресу $2000, и видеосхема сразу показывает.

LDX #$FF / TXS — новая команда. TXS кладёт X в указатель стека. Финал вызывается глубоко внутри: главный цикл → ACT_KEY → SUB_SHOW → SUB_START → FINALE, и в стеке лежат адреса возврата всех этих вызовов. Возвращаться туда уже не нужно — игра начинается заново. Указатель стека $FF — «стек пуст», как сразу после включения, и JMP start запускает всё с начала, не утопая в старых адресах.

Заставка: отдельная программа

Заставка — отдельный файл INTRO (intro.s), его запускает HELLO (глава 0). У неё тот же адрес, что у игры, — .org $6000: она отработает, скажет DOS BRUN MAIN, и игра ляжет поверх неё. Своих картинок в коде нет — кадры по 8 КБ лежат на дискете файлами INTRO1…INTRO7, и заставка командует DOS, куда их грузить. Как в мультфильме: пока зритель смотрит на кадр одной страницы, на вторую уже грузится следующий.

IBERIA: сеть Испании
INTRO1: сеть, 28 April 2025, 12:32
THE GRID WENT DOWN. BLACKOUT
INTRO3: BLACKOUT
Барселона
INTRO4: Барселона

Справочник команд 6502

Всё, что умеет процессор Apple II, — 56 команд, 3 регистра и 7 флагов. Здесь они собраны в одном месте: что значит каждая команда, какие флаги меняет, пример из кода BLACKOUT и глава, где она разобрана подробно. В игре используются 43 команды из 56; остальные помечены.

Регистры

РегистрБитЗачем
A8аккумулятор: все вычисления (сложение, логика, сравнение) — через него
X8индекс и счётчик: LDA TABLE,X, INX, CPX
Y8второй индекс; единственный для указателей (PTR),Y
S8указатель стека: стек — страница $0100–$01FF, растёт вниз от $01FF
PC16адрес следующей команды; меняют только переходы, JSR, RTS
P8флаги — см. ниже

Регистр флагов P

бит
7
6
5
4
3
2
1
0
P
N
V
–
B
D
I
Z
C
ФлагЗначитКто ставитКто смотрит
Nnegative: копия бита 7 результатапочти все, что меняют регистр; BIT — бит 7 памятиBMI, BPL
Voverflow: переполнение со знакомADC, SBC; BIT — бит 6 памятиBVC, BVS
Bbreak: признак BRKBRKобработчик прерывания
Ddecimal: десятичная арифметикаSED, CLDADC, SBC
Iinterrupt: прерывания запрещеныSEI, CLIпроцессор
Zzero: результат равен нулюпочти все, что меняют регистр; CMP — «равно»BEQ, BNE
Ccarry: перенос / «не было заёма» / вылетевший битADC, SBC, CMP, сдвиги, CLC, SECBCC, BCS, ADC, SBC, ROL, ROR

Главное правило (глава 0): флаги живут до следующей команды, которая их меняет. STA, STX, STY, переходы и JSR флаги не трогают — поэтому их можно ставить между сравнением и переходом.

Режимы адресации — откуда команда берёт число

Одна и та же команда (LDA) может взять число десятью способами. Способ виден по записи:

РежимЗаписьПример из игрыЧто значитБайт
неявный—INX, CLC, RTSвсё понятно из самой команды1
аккумуляторAASL Aработать с A1
непосредственный#числоLDA #$20, CMP #7само число стоит в команде2
нулевая страницаадрес $00–$FFLDA SEED ($10)байт по короткому адресу — на байт короче и на такт быстрее2
нулевая страница,Xадрес,XSTA SEED,Xадрес нулевой страницы + X2
абсолютныйадрес $0000–$FFFFLDA KBD ($C000)байт по полному адресу3
абсолютный,X / ,Yадрес,XLDA TXT_BLOAD,Xадрес + X (или Y): элемент таблицы3
косвенный с индексом(указатель),YLDA (PTR),Yадрес лежит в двух ячейках нулевой страницы, к нему + Y2
относительныйметкаBNE @loopтолько у условных переходов: смещение −128…+1272
индексный косвенный(указатель,X)не используетсяуказатель берётся из нулевой страницы по адресу + X2
косвенныйJMP (адрес)не используетсяперейти по адресу, который лежит в памяти3

16-битные адреса в коде всегда записаны младшим байтом вперёд: LDA TXT_BLOAD,X — это BD 67 93 (глава 0).

Все 56 команд

Загрузка и запись

КомандаОт словЧто делаетФлагиПример из игрыГде
LDALoaD AA ← число или байт памятиN ZLDA SEED+1гл. 1
LDXLoaD XX ← …N ZLDX #0гл. 0
LDYLoaD YY ← …N ZLDY #0гл. 1
STASTore Aпамять ← A—STA SEED,Xгл. 1
STXSTore Xпамять ← X—STX TCXгл. 4
STYSTore Yпамять ← Y—STY TCYгл. 4

Пересылка между регистрами

КомандаОт словЧто делаетФлагиПример из игрыГде
TAXTransfer A → XX ← AN ZASL A / TAXгл. 2
TAYTransfer A → YY ← AN ZASL A ×3 / TAYгл. 1
TXATransfer X → AA ← XN ZTXA / ADC #8 / TAXгл. 7
TYATransfer Y → AA ← YN ZTYA / ASL Aгл. 3
TSXTransfer S → XX ← указатель стекаN Zне используется
TXSTransfer X → Sуказатель стека ← X—LDX #$FF / TXSгл. 15

Стек

КомандаОт словЧто делаетФлагиПример из игрыГде
PHAPusH Aположить A на стек—PHA … PLA в MSG_Nгл. 8
PLAPuLl Aснять со стека в AN ZPLAгл. 8
PHPPusH Pположить флаги на стек—не используется
PLPPuLl Pснять флаги со стекавсене используется

Арифметика

КомандаОт словЧто делаетФлагиПример из игрыГде
ADCADd with CarryA ← A + число + CN V Z CCLC / ADC SEED+2гл. 1
SBCSuBtract with CarryA ← A − число − (1 − C)N V Z CSEC / SBC #9гл. 3
INCINCrementбайт памяти + 1N ZINC WCNTгл. 1
DECDECrementбайт памяти − 1N ZDEC GSCRгл. 6
INXINcrement XX + 1N ZINXгл. 0
INYINcrement YY + 1N ZINYгл. 1
DEXDEcrement XX − 1N ZDEX / BPLгл. 6
DEYDEcrement YY − 1N ZDEYгл. 3

Логика

КомандаОт словЧто делаетФлагиПример из игрыГде
ANDANDA ← A И число: 1 там, где 1 в обоихN ZAND #%00000011гл. 1
ORAOR with AA ← A ИЛИ число: 1, если 1 хотя бы в одномN ZORA #%00100000гл. 2
EORExclusive ORA ← A исключающее ИЛИ: 1, где биты разныеN ZEOR SEED+3,Yгл. 3
BITBIT testN ← бит 7 байта, V ← бит 6, Z ← (A И байт) = 0; A не меняетсяN V ZBIT KBDSTRBгл. 0

Сравнение

КомандаОт словЧто делаетФлагиПример из игрыГде
CMPCoMPare AA − число, ответ выбрасывается, остаются флагиN Z CCMP LASTKгл. 0
CPXComPare XX − числоN Z CCPX #6гл. 1
CPYComPare YY − числоN Z CCPY #1гл. 9

Сдвиги

КомандаОт словЧто делаетФлагиПример из игрыГде
ASLArithmetic Shift Leftвсе биты влево, бит 7 → C, в бит 0 входит 0 (× 2)N Z CASL Aгл. 1
LSRLogical Shift Rightвсе биты вправо, бит 0 → C, в бит 7 входит 0 (/ 2)N Z CLSR Aгл. 1
ROLROtate Leftвлево, бит 7 → C, старый C → бит 0N Z CROL PTR+1гл. 1
RORROtate Rightвправо, бит 0 → C, старый C → бит 7N Z CROR MTMPгл. 15

Переходы и подпрограммы

КомандаОт словЧто делаетФлагиПример из игрыГде
JMPJuMPперейти по адресу—JMP SCR_TILEгл. 4
JSRJump to SubRoutineадрес возврата на стек и перейти—JSR WLD_STEPгл. 0
RTSReTurn from Subroutineснять адрес со стека и вернуться—RTSгл. 0
RTIReTurn from Interruptвозврат из прерываниявсене используется
BRKBReaKпрограммное прерываниеB Iне используется

Условные переходы (±127 байт)

КомандаОт словЧто делаетФлагиПример из игрыГде
BEQBranch if EQualпрыгнуть, если Z = 1 (равно, ноль)—BEQ @walkгл. 0
BNEBranch if Not Equalпрыгнуть, если Z = 0—BNE @loopгл. 0
BCCBranch if Carry Clearпрыгнуть, если C = 0 (после CMP: меньше)—BCC @stunгл. 10
BCSBranch if Carry Setпрыгнуть, если C = 1 (после CMP: больше или равно)—BCS @edgeгл. 5
BMIBranch if MInusпрыгнуть, если N = 1 (бит 7 результата)—BMI @newгл. 0
BPLBranch if PLusпрыгнуть, если N = 0—DEX / BPL @svгл. 6
BVCBranch if oVerflow Clearпрыгнуть, если V = 0—не используется
BVSBranch if oVerflow Setпрыгнуть, если V = 1—не используется

Флаги

КомандаОт словЧто делаетФлагиПример из игрыГде
CLCCLear CarryC ← 0 (перед ADC)CCLCгл. 1
SECSEt CarryC ← 1 (перед SBC; «да» в ответе)CSECгл. 3
CLVCLear oVerflowV ← 0Vне используется
CLDCLear DecimalD ← 0: обычная двоичная арифметикаDне используется
SEDSEt DecimalD ← 1: ADC / SBC в двоично-десятичном видеDне используется
CLICLear Interruptразрешить прерыванияIне используется
SEISEt Interruptзапретить прерыванияIне используется

Прочее

КомандаОт словЧто делаетФлагиПример из игрыГде
NOPNo OPerationничего не делать (1 байт, 2 такта)—не используется

Частые приёмы — где искать

ЗадачаКак делаетсяГде
сложить 16-битные числаCLC / ADC мл. / ADC ст. — перенос идёт самгл. 1
сравнить 16 бит «хватает ли»CMP мл. / SBC #0 ст. / BCCгл. 9
умножить на 2, 4, 8…ASL A (16 бит — ASL / ROL)гл. 1
умножить на 20, 6, 13сдвиги + сложение: 20 = 16 + 4гл. 3, гл. 14
разделить на 2, 4, 32LSR A нужное число разгл. 11
разделить на 3, на 10вычитать в цикле и считатьгл. 9, гл. 13
остаток от деления на 8, 16, 32AND #7 / #15 / #31гл. 10
вынуть поле битовLSR до бита 0, потом AND маскагл. 1
включить / выключить / перевернуть битыORA / AND / EOR с маскойгл. 0
модуль разностиSEC / SBC / BCS, иначе EOR #$FF / ADC #1гл. 7
«не ниже нуля», «не выше 255»BCS после SBC; CMP #255 / BEQ перед INCгл. 10
ответ подпрограммы «да / нет»SEC / CLC перед RTS, вызывающий — BCS / BCCгл. 0
выбор по номерутаблица адресов: номер × 2 → два байтагл. 2, гл. 8
цикл по таблице записейX += размер записи, CPX конецгл. 7
цикл до нуляDEX / BPL (с X ≤ 127)гл. 6
случайное числоASL / BCC / EOR #$1Dгл. 3
подпрограмма в конце — без возвратаJMP вместо JSR + RTS («хвостовой вызов»)гл. 4
условный переход далекообратное условие через JMPгл. 6

Процессор //c — 65C02, у него есть ещё несколько команд (BRA, STZ, PHX, PLX, INC A…). BLACKOUT ими не пользуется: в игре только команды исходного 6502, поэтому код работает и на Apple ][+.


34 файла, около 11 800 строк — и почти везде одни и те же несколько приёмов: таблица вместо формулы, маска вместо деления, флаг C как ответ, зерно вместо хранения. Все команды, которые встречаются в главах, собраны в справочнике ниже.