BLACKOUT · Apple //c · 6502
Как устроена игра изнутри — от включения машины до финала. В каждой главе: картинка, где лежат данные, порядок вызовов и одна-две подпрограммы построчно, на живых числах. В конце — справочник команд 6502.
Прежде чем лезть в подпрограммы, надо увидеть целое: что лежит на дискете, в каком порядке оно запускается, где что живёт в памяти и что делает главный цикл. Всё остальное — это подпрограммы, которые главный цикл вызывает через 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. Видно, куда уходит место: картинки заставки и финала занимают больше, чем вся игра.
MAXFILES 1, потом BRUN INTRO.BRUN MAIN.BLOAD DATA в $2000 и перенос в скрытую память.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 КБ видно сразу. Вот как они поделены. Адрес слева — начало участка.
SEED $10–$17, указатели PTR, STR. Команды с адресом в нулевой странице на байт короче и на такт быстрее.JSR, PHA/PLA.LOC_SRCH $0200 — «обыскано / был здесь» на каждую локацию; дальше всё по мелочи: страница, клавиша, герой, рынок.LOC_GROW, рюкзак.COUT, HOME, WAIT…). Но на тех же адресах есть ещё 16 КБ ОЗУ, которое включается переключателем. Туда при запуске переносится DATA ($D000–$F255).Главное ограничение видно сразу: для кода есть только кусок между второй страницей графики и DOS — 14 720 байт. Поэтому всё, что не код (картинки, слоги, тексты), переехало в language card. Без неё игра бы не влезла.
В проекте 34 файла, но собирается из них ровно две программы:
main.s начинается с .org $6000 и подключает (.include) всё остальное: vars.s (только имена и адреса, кода нет), потом подпрограммы — world.s, gen.s, hero.s и так далее. Получается MAIN.data.s начинается с .org $D000 и подключает картинки и тексты. Получается DATA. Ассемблер считает адреса так, как будто DATA лежит в $D000, хотя грузится она в $2000 — потом LC_LOAD переносит её на место.MAIN обращается к данным в DATA по адресам, записанным в vars.s (CHR_TAB = $D000, TILE_TAB = $DC00…). Если DATA пересобрать и что-то сдвинется — адреса разойдутся. Поэтому после любой правки DATA адреса в vars.s надо сверить с тем, где метки оказались на самом деле — ассемблер покажет их в листинге.
Правила, по которым написан весь код. Главный цикл — только JSR. У каждой подпрограммы шапка: что делает, вход, выход, что портит. Имена с префиксом модуля (WLD_… — мир, HERO_… — герой, MKT_… — рынок). Внутри подпрограмм — локальные метки с @: @loop в одной подпрограмме не мешает @loop в другой. Никаких «голых» чисел — у адресов есть имена в vars.s.
Начало 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: 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: 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, потом весь цикл на числах.
Бит 7 — флажок «есть непрочитанная клавиша». Биты 0–6 — сам код: $15 — стрелка вправо (то же, что Ctrl-U). Запись в $C010 (STA KBDSTRB) гасит флажок, код остаётся. Поэтому в цикле в A оказывается то $95, то $15 — это одна и та же клавиша, до и после «прочитал».
ORA — «ИЛИ» по каждому биту отдельно, столбиком: в ответе 1, если 1 хотя бы в одном из двух. Маска $80 — единица только в бите 7. Значит, бит 7 станет 1, а остальные 7 битов останутся как были. Так из «прочитанной» $15 снова получается $95 — в том виде, в каком она запомнена в LASTK.
Для сравнения — AND, «И»: 1 только там, где 1 в обоих. Маска оставляет нужные биты и обнуляет остальные. В игре это «вынуть кусок байта»: AND #%00011111 — взять биты 0–4 (число 0–31), так выбираются слоги имён в главе 2. Правило на память: ORA — включает биты маски, AND — оставляет биты маски, EOR — переворачивает биты маски.
Теперь по шагам. Стрелка вправо нажата и удерживается.
| Строка | Регистры | Что происходит |
| LDA KBD | A = $95 | Стрелка вправо — код $15. Пока клавишу не «прочитали», клавиатура держит бит 7: $15 + $80 = $95. Бит 7 = 1, значит число «отрицательное». |
| BMI @new | → @new | BMI — переход, если N = 1 (бит 7 результата). Новая клавиша. |
| STA LASTK | LASTK = $95 | Запомнили, что эту уже обработали. |
| STA KBDSTRB | Запись в $C010 сбрасывает бит 7 в $C000. Теперь LDA KBD даст $15 — «старая». | |
| … герой шагнул, кадр нарисован, следующий оборот цикла. Клавиша всё ещё зажата. | ||
| LDA KBD | A = $15 | Бит 7 = 0 — новой клавиши нет. |
| BMI @new | не прыгаем | |
| BIT KBDSTRB | N = 1 | У //c чтение $C010 в бите 7 говорит, зажата ли сейчас какая-нибудь клавиша (AKD — any key down). BIT кладёт бит 7 прочитанного в флаг N, не трогая A. |
| BPL @none | не прыгаем | Зажата. |
| ORA #%10000000 | A = $95 | Вернули бит 7, чтобы сравнивать с тем, что лежит в LASTK. |
| CMP LASTK | $95 = $95 | Та же клавиша. |
| BEQ @walk | → @walk | Её держат — герой идёт дальше, без автоповтора с задержкой. |
У 6502 нет команды «если A = 5, то перейти». Есть две половинки: одна команда ставит флаги, следующая смотрит на флаг и прыгает или нет. Флаги — отдельный байт P, регистр состояния:
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 LASTK считает A − LASTK, но результат никуда не записывает — A остаётся прежним. От вычитания остаются только флаги. Три случая на числах:
Разность 0 → Z = 1. BEQ @walk («branch if equal» = «если Z = 1») прыгает: та же клавиша, её держат.
$95 − $88 = $0D, не ноль → Z = 0, BEQ не прыгает: «не та стрелка, смотрим дальше». C = 1 значит «A ≥ того, с чем сравнивали» — вычитание прошло без займа.
$88 − $95 «не помещается» в байт: получается $F3 (как на счётчике, который прокрутился через ноль) и C = 0 — был заём. Это и есть «A меньше». N = 1 тут случайность — просто бит 7 разности, для сравнения чисел на него не смотрят.
Что можно спросить после CMP:
| Переход | Флаг | Значит | $95 vs $95 | $95 vs $88 | $88 vs $95 |
|---|---|---|---|---|---|
| BEQ | Z = 1 | A = M | прыгает | нет | нет |
| BNE | Z = 0 | A ≠ M | нет | прыгает | прыгает |
| BCS | C = 1 | A ≥ M | прыгает | прыгает | нет |
| BCC | C = 0 | A < 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 обнуляется, и следующее нажатие той же стрелки снова станет «новым».
| Клавиша | Код | Куда |
|---|---|---|
| пробел | $A0 | ACT_KEY — рынок в поселении, обыск вне его (глава 9) |
| A, W, M, I | $C1 $D7 $CD $C9 | CMB_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, «вправо». Порядок ↑ → ↓ ← по часовой стрелке — один и тот же во всей игре: в выходах из экрана, в дорогах, в карте.
Самая первая подпрограмма. Две части: попросить 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
TXT_BLOAD — не переменная, а метка: имя адреса, где ассемблер положил байты строки. В собранной MAIN это $9367. Вот как строка лежит в памяти:
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 | $8D | Return — DOS исполняет команду, файл грузится |
| 20 | $937B | $00 | LDA поставил 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-битные адреса так — младшим байтом вперёд.
BLOAD в $2000, а не сразу в $D000? DOS пишет файл в обычную память и про скрытую ничего не знает. А $2000–$5FFF — обе страницы графики — при запуске ещё пустые: 16 КБ свободного места как раз под файл до 16 КБ.BIT LCWR два раза? Так сделано в железе Apple: запись в скрытое ОЗУ включается только двумя чтениями подряд. Защита от случайного включения одной ошибочной командой. BIT здесь — просто самый безвредный способ «прочитать адрес»: он не меняет регистры.LCWR чтение $D000–$FFFF по-прежнему идёт из ПЗУ, а запись — в ОЗУ. Поэтому LDA $FFFA,X / STA $FFFA,X копирует векторы прерываний из ПЗУ в ОЗУ по тем же адресам. Это 6 байт в самом конце памяти, куда процессор смотрит при сбросе и прерывании. Если бы там в ОЗУ был мусор, нажатие Reset при включённой карте увело бы машину в никуда.Дальше игра читает DATA так: BIT LCRAM (включить чтение скрытого ОЗУ) — несколько команд — BIT LCROM (вернуть ПЗУ). Пока скрытое ОЗУ включено, ПЗУ не видно, а значит, нельзя вызывать COUT, WAIT и прочее из ПЗУ — их там в этот момент просто нет. Это правило соблюдается во всём коде.
В регионе 256 локаций, у каждой есть тип, «порядок», рельеф, имя, поселения, дороги, цены. Ничего из этого не записано ни в коде, ни на дискете. Всё вычисляется из 8 байт — зерна региона. Это тот же приём, которым Elite в 1984 году уместила восемь галактик в 32 КБ BBC Micro.
В главе: где лежит зерно, как делается один шаг, как 16-битное число складывается на 8-битном процессоре, почему на локацию нужно ровно четыре шага и откуда берутся тип, порядок и рельеф.
Зерно — четыре числа по 16 бит: S0, S1, S2, S3. Процессор умеет работать только с байтами, поэтому каждое слово занимает две ячейки: сначала младший байт, потом старший — так же, как адрес в команде BD 67 93 из главы 0. Лежит зерно в нулевой странице, по адресам $10–$17. Так выглядит зерно Каталонии сразу после WLD_INIT:
Читается это так: S0 = $5A4A, S1 = $0248, S2 = $B753, S3 = $1F2E. Первые три числа — те же, что в Elite. В коде к байтам обращаются по имени SEED плюс смещение: SEED+1 — старший байт S0, SEED+7 — старший байт S3. Это не арифметика во время игры: ассемблер сам подставит $11 и $17.
Правило шага простое: сложить все четыре числа, сдвинуть их на одно место влево, а сумму поставить последней.
T = S0 + S1 + S2 + S3 ; всё по модулю $10000 — перенос из 16-го бита теряется
S0 ← S1, S1 ← S2, S2 ← S3, S3 ← T
Это «тетраначчи» — как Фибоначчи, только складываются четыре числа, а не два. У Elite было «трибоначчи» на трёх числах. Вот первые шаги на зерне Каталонии:
| Шаг | S0 | S1 | S2 | S3 | Сумма | → новое 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-битным, а «прокрутка через ноль» перемешивает биты ещё лучше.
6502 складывает только байты. 16-битное сложение — это два сложения: сначала младшие байты, потом старшие, и между ними передаётся перенос — флаг C из главы 0. Команда ADC складывает три вещи: A + число + C. Поэтому перед первым сложением всегда стоит CLC: обнулить C, чтобы не прибавилась случайная единица.
Возьмём самое интересное место шага 0 — третье сложение. В WTMP уже лежит S0 + S1 + S2 = $13E5, прибавляем S3 = $1F2E.
229 + 46 = 275. В байт помещается до 255, поэтому в A остаётся 275 − 256 = 19 = $13, а «лишние 256» запоминаются как C = 1.
Ответ: $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), перенос бы потерялся.
После суммы надо сдвинуть числа на одно место. Это шесть байт, которые переезжают на две ячейки влево — тот же цикл с 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, до и после цикла:
Почему 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 ; без видимого повтора
Если бы тип локации брали из младших битов, типы шли бы по кругу: анархия, деревня, город, анархия, деревня… Старшие биты успевают «набрать» переносы со всех младших разрядов и выглядят случайными.
Возьмём локацию $37 — ту, где начинается игра. После 4 × 55 = 220 шагов её зерно: S0 = $BA42, S1 = $7E80, S2 = $93A3, S3 = $7586. Старшие байты: $BA $7E $93 $75. Вот что из них вынимается:
Один байт — три свойства. Тип занимает биты 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
LSR — «logical shift right»: каждый бит переезжает на место правее, бит 0 выпадает во флаг C, в бит 7 входит 0. Один LSR — это деление на 2 без остатка. Его пара ASL сдвигает влево и умножает на 2 — понадобится ниже.
Остальные старшие байты, коротко — подробно каждый в своей главе:
| Байт | У $37 | Биты | Что значит | Глава |
|---|---|---|---|---|
| SEED+3 (S1 ст.) | $7E | 0–4 · 5 · 4–7 | начало имени (30 = QUINTA) · есть ли середина (да) · что делают на рынке | 2, 9 |
| SEED+5 (S2 ст.) | $93 | 0–4 · 4–7 · всё | середина имени (19 = MA) · что нужно рынку · смесь для генератора экранов | 2, 3, 9 |
| SEED+7 (S3 ст.) | $75 | 0–4 · всё | окончание имени (21 = TERA) · смесь для генератора экранов | 2, 3 |
| младшие байты | $42 $80 $A3 $86 | смешиваются со старшими (EOR): на каком из 9 экранов стоят поселения | 3 |
QUINTA + MA + TERA, INDUSTRIAL — ровно то, что видно на панели в игре. Поля перекрываются (биты 4–5 байта S1 нужны и имени, и рынку), но это не страшно: свойства просто чуть связаны между собой, а в игре это незаметно.
Делать 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.
Пример — второй круг (локация 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», которое в байт и не записать.
Когда герой входит в локацию 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
Итог: 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, и номер локации устроен очень удобно: старшие 4 бита — строка, младшие 4 — столбец. Шестнадцатеричная запись прямо показывает координаты.
WLD_RIGHT сначала проверяет столбец.Отсюда все четыре соседа: вправо — 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.
У каждого региона своё зерно в таблице 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 048 локаций есть имя — VILLAZAR, BENADILLA, QUINTAMATERA. Ни одно не записано. Имя собирается из кусочков по битам зерна, каждый раз заново, когда его надо напечатать: на панели, на карте, на рынке.
Elite называла планеты парами букв: LAVE, DISO, RIEDQUAT. Здесь кусочки длиннее — испанские по звучанию слоги, и их три вида: начало, середина (бывает не всегда) и окончание. По 32 штуки каждого.
Подсвечены кусочки стартовой локации $37. Маленькая цифра — номер кусочка (зачем середины начинаются с 32, а окончания с 64 — ниже).
Начало + окончание даёт 32 × 32 = 1 024 имени, с серединой — ещё 32 × 32 × 32 = 32 768. В Каталонии из 256 локаций 252 имени разные, совпадений всего четыре пары (OLITERA, BARVAL, CUEVANAS…). Самое длинное имя — 12 букв, как раз QUINTAMATERA.
Из главы 1: у локации $37 старшие байты зерна $BA $7E $93 $75. Тип и порядок брались из первого. Имя — из трёх остальных:
Одна маска — пять битов (0–4), число 0–31. Вторая маска — один бит 5, и тут важно не само число, а «ноль или не ноль»: AND ставит флаг Z, и сразу за ним BEQ @noMid решает, пропускать ли середину. Бит 5 — это «подбросить монетку»: примерно у половины мест середины нет.
QUINTA + MA + TERA = QUINTAMATERA. Ровно то, что на панели в игре.
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:
После AND #%00011111 биты 5–7 гарантированно нули. Включить в пустой бит единицу — то же самое, что прибавить его вес: бит 5 весит 32, бит 6 — 64. Зато ORA не нужен CLC и он не трогает флаг C. Это частый приём: если знаешь, что бит свободен, «+ 32» пишется как «включи бит 5».
Всё это — в namedata.s, который входит в DATA и при запуске уезжает в скрытую память (глава 0). Сначала подряд идут сами слоги, каждый — буквы и байт 0 в конце. Вот QUINTA:
Слоги разной длины, поэтому «слог номер 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».
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 A | A = 60 ($3C) | Каждый адрес — 2 байта, значит, адрес кусочка 30 начинается с 60-го байта таблицы. |
| TAX | X = $3C | Номер байта — в X, чтобы взять его как индекс. |
| BIT LCRAM | Включили скрытую память: теперь $D000–$FFFF — это DATA, а не ПЗУ. | |
| LDA NM_START,X | A = $0A | Байт по адресу $E9FA + $3C = $EA36. |
| STA STR | $08 = $0A | |
| LDA NM_START+1,X | A = $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: 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. Две мелочи, на которых тут легко ошибиться:
COUT из ПЗУ. Одновременно их не видно: адреса $D000–$FFFF одни и те же. Поэтому на каждом символе: включить карту — прочитать — вернуть ПЗУ — напечатать. Забудь BIT LCROM — JSR COUT прыгнет на $FDED, а там в этот момент лежат не команды ПЗУ, а чьи-то данные.CMP #0, если LDA уже ставит Z? Ставит — но следующей командой идёт BIT LCROM, а BIT тоже меняет Z (это её работа — сравнивать). После неё Z говорит уже не про символ. CMP #0 заново спрашивает «A = 0?». Это правило из главы 0 в действии: флаги живут до следующей команды, которая их ставит.Где имя печатается: walk.s — панель внизу экрана, mapview.s — строка под картой, когда курсор стоит на клетке, market.s — заголовок рынка. Везде одно и то же: WLD_GET кладёт зерно нужной локации в SEED, потом JSR NAM_PRINT.
Локация — это квадрат 3 × 3 экрана. Экран — 20 × 10 клеток-плиток по 14 × 16 точек. Ни одна клетка не хранится: когда герой входит на экран, программа заново собирает его карту из зерна локации и номера экрана. Один и тот же экран всегда выходит одинаковым — до плитки.
Вот все девять экранов стартовой локации $37, как они выглядят в игре. Дорога проходит сквозь швы — на экране 0 она уходит вправо и вниз, на экране 1 продолжается. Как программа об этом договаривается, хотя каждый экран строится отдельно, — главный вопрос этой главы.
Работа делится на две части. Одна делается один раз при входе в локацию, другая — на каждом экране.
| Когда | Подпрограмма | Что решает | Куда кладёт |
|---|---|---|---|
вход в локацию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–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 — «исключающее ИЛИ»: в ответе 1 там, где биты разные. Это третья логическая команда к AND и ORA из главы 0. Главное её свойство — она ничего не теряет: каждый бит ответа зависит от обоих байтов. Поэтому она хороша для «перемешать два числа».
Четыре бита дают 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. Свободный найдётся всегда: поселений три, экранов девять.
Вид зависит только от типа локации — по таблице 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 1100 | 11 = 3 | 3 + 3 = 6 | SETTLEMENT 1 TOWN LV 6 |
| 2 (экран 1) | $13 = 0001 0011 | 00 = 0 | 3 + 0 = 3 | SETTLEMENT 2 WORKS LV 3 |
| 3 (экран 4) | $D6 = 1101 0110 | 01 = 1 | 3 + 1 = 4 | SETTLEMENT 3 WORKS LV 4 |
Один байт зерна работает дважды: биты 4–7 решили, где поселение, биты 2–3 — насколько оно развито. Так из 64 бит выжимается больше свойств.
Есть ли дорога из $37 вверх, в $27? Решить это надо так, чтобы обе локации ответили одинаково: если в $37 дорога уходит вверх, то в $27 она обязана приходить снизу. Иначе герой выйдет на дорогу и окажется в поле.
Решение: смешать EOR один и тот же байт зерна обеих локаций. Для вертикальных соседей — байт 5, для горизонтальных — байт 7. Если два младших бита вышли 00 — дороги нет (1 случай из 4), иначе есть.
Магия в том, что 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).
Дороги внутри локации соединяют поселения по цепочке 1 → 2 → 3, и каждый выход к соседу — с поселением 1. Путь с экрана на экран — «буквой Г»: сначала по строке до нужного столбца, потом по столбцу (ROAD_PATH). Каждый шаг включает шов между двумя экранами.
Швов в квадрате 3 × 3 двенадцать: 6 горизонтальных (между экранами в строке) и 6 вертикальных. Всё хранится в двух байтах GROAD: байт 0 — горизонтальные швы, байт 1 — вертикальные, по биту на шов. У $37 GROAD = $05, $03:
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 смотрит в GROAD его четыре шва и собирает маску GEXIT: ↑ = 1, → = 2, ↓ = 4, ← = 8. Плюс выход к соседней локации, если экран средний на краю (OUT_MASK).
| Экран | Швы | GEXIT | Биты ←↓→↑ |
|---|---|---|---|
| 0 | → 0–1, ↓ 0–3 | 2 + 4 = 6 | 0110 |
| 1 | ↑ выход в $27, ↓ 1–4, ← 0–1 | 1 + 4 + 8 = 13 | 1101 |
| 3 | ↑ 0–3, → 3–4 | 1 + 2 = 3 | 0011 |
| 4 | ↑ 1–4, ← 3–4 | 1 + 8 = 9 | 1001 |
| 2, 5, 6, 7, 8 | — | 0 | 0000 |
Числа получаются прямо из швов — и в игре экраны выходят именно такими.
Дорога всегда идёт через центр — клетку 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 из номера экрана и двух байтов зерна локации:
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
После 8 холостых шагов «разогрева» RND = $8F, и первый настоящий шаг даёт $03. Дальше: $06, $0C, $18, $30, $60… — пока единица не вылетит снова. Такой генератор пробегает все числа 1–255 ровно по разу и только потом повторяется. Ноль ему нельзя — из нуля он никогда не выйдет (0 сдвинутый — всё равно 0), поэтому в GEN_SEED стоит проверка «если 0 — взять 1».
BCC здесь смотрит не на сравнение, а на бит, который только что вылетел из ASL. Флаг C — один и тот же для переноса, сравнения и сдвигов.
Если бы генератор только сдвигал, через 8 шагов байт стал бы нулём и застрял. EOR с маской «возвращает» вылетевшую единицу в несколько мест справа. От того, в какие места, зависит, сколько разных чисел пройдёт генератор, прежде чем начнёт повторяться. Вот один и тот же старт — 1 — с разными масками:
| Маска | Биты | Чисел до повтора | Что было бы на экране из 200 клеток |
|---|---|---|---|
| $01 | 0000 0001 | 8 | узор повторяется каждые 8 клеток |
| $11 | 0001 0001 | 12 | каждые 12 |
| $05 | 0000 0101 | 30 | каждые 30 — полторы строки |
| $1B | 0001 1011 | 51 | каждые 51 |
| $0F | 0000 1111 | 217 | почти хорошо, но не все числа |
| $FF | 1111 1111 | 9 | каждые 9 |
| $1D | 0001 1101 | 255 | все числа 1–255, повтор — только через 255 клеток |
С маской $05 генератор возвращается к началу через 30 шагов — дальше всё по кругу:
С маской $1D — через 255, побывав на каждом числе от 1 до 255 ровно один раз:
Из 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 клеток.
Рельеф — биты 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 %.
Хитрость: биты 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.
Дом — это не одна плитка, а несколько: крыша, стены, дверь. Такую группу называют штамп: ширина, высота и номера плиток строка за строкой. Цех промзоны:
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.
Любое умножение на константу так и делается: разложить её на степени двойки (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 — по ним идут дороги. Поэтому дом никогда не встанет поперёк дороги.
В главе 3 экран превратился в 200 номеров плиток — SCR_MAP. Теперь их надо превратить в точки на мониторе. Для этого нужно знать, как Apple II хранит картинку, — а хранит он её очень необычно. Три странности HiRes: 7 точек в байте задом наперёд, цвет зависит от того, в каком столбце стоит точка, и строки экрана лежат в памяти вперемешку.
HiRes — 280 × 192 точки. Страница 1 — это память $2000–$3FFF, страница 2 — $4000–$5FFF, по 8 192 байта. Никакой видеокарты: видеосхема Apple сама читает эту память 60 раз в секунду и рисует то, что в ней лежит. Записал байт по адресу из этого куска — на экране тут же изменились точки.
В строке 40 байт. 40 × 8 = 320, но точек в строке 280 — потому что из каждого байта на экран идут только 7 битов, 0–6. Бит 7 точкой не является: он выбирает «цветовую пару» для всех семи точек этого байта.
И главное: бит 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 ствола:
А вот вся плитка, посчитанная по этим правилам, — так её и видно в игре:
Слева номер строки, справа её два байта. Чёрная полоска посередине — граница байтов: столбцы 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
| Строка y | y mod 8 (× $400) | полоса (× $80) | блок (× $28) | Адрес |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | $2000 |
| 1 | 1 | 0 | 0 | $2400 |
| 2 | 2 | 0 | 0 | $2800 |
| 7 | 7 | 0 | 0 | $3C00 |
| 8 | 0 | 1 | 0 | $2080 |
| 9 | 1 | 1 | 0 | $2480 |
| 63 | 7 | 7 | 0 | $3F80 |
| 64 | 0 | 0 | 1 | $2028 |
| 128 | 0 | 0 | 2 | $2050 |
| 191 | 7 | 7 | 2 | $3FD0 |
Соседние строки отстоят на $400 = 1 024 байта. Только 8 строк спустя адрес сдвигается на $80. Экран делится на 3 блока по 64 строки, в блоке 8 «полос» по 8 строк. Возняк сделал так, чтобы один и тот же счётчик в видеосхеме обслуживал и текст, и графику, и одновременно обновлял память. Сэкономил несколько микросхем — а программистам досталась лесенка навсегда.
Зато видно, почему при BLOAD картинки заставки прямо в видеопамять она «проявляется» жалюзи: файл пишется в память подряд, а подряд в памяти лежат строки 0, 64, 128, потом 8, 72, 136, 16… — по одной строке в каждой полосе, и только потом строки 1, 9, 17…
Считать формулу для каждой строки каждой плитки — дорого. Поэтому при запуске 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 младших битов; если они все нули — блок закончился.
Нарисовать плитку в клетку (столбец 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
| Шаг | Числа | Что происходит |
| TCOL | 10 × 2 = 20 | Плитка 2 байта шириной, клетка 10 начинается с 20-го байта строки. |
| TLINE | 4 × 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_TILE на входе адрес картинки, а в SCR_MAP лежат номера. Переводит SCR_TILEN — через таблицу адресов TILE_TAB ($DC00), тем же приёмом, что слоги в главе 2: номер × 2 → два байта адреса.
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 МГц. Если рисовать на видимой странице, это видно глазом: экран «заполняется» сверху вниз. Поэтому новый экран рисуется на невидимой странице и показывается целиком.
Плитки из главы 4 стоят в сетке ровно по байтам: клетка = 2 байта. Герой так не может — он ходит по 2 точки, а в байте их 7. Значит, почти всегда фигурка начинается где-то посреди байта и залезает на три байта сразу. Плюс она должна рисоваться поверх травы и камней, не затирая их квадратом, и не мерцать. Эта глава — про три трюка: таблицы сдвига, маску и две страницы.
Позиция — два байта: 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
| HX2 | x | XB_TAB (байт) | XS_TAB (сдвиг) | Как считалось |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | старт |
| 1 | 2 | 0 | 2 | 0 + 2 |
| 3 | 6 | 0 | 6 | 4 + 2 |
| 4 | 8 | 1 | 1 | 6 + 2 = 8 ≥ 7 → 8 − 7 = 1, байт + 1 |
| 20 | 40 | 5 | 5 | 40 = 5 × 7 + 5 |
Здесь снова «деление без деления»: вместо x / 7 таблица строится прибавлением по 2 с переносом в следующий байт — как будто считаешь на счётах. Отдельная мелочь: SBC #7 без SEC. Он не нужен, потому что прямо перед ним CMP #7 уже поставил C = 1 (A ≥ 7, иначе BCC бы ушёл).
Пример — строка 8 кадра «герой спиной»: $4C, $19 — ·.##..##..##.·. Герой стоит на HX2 = 20: байт 5, сдвиг 5. На экране его 14 точек должны начаться с 5-й точки байта 5 — то есть разъехаться по трём байтам:
Важная путаница, которую стоит запомнить: сдвиг вправо на экране — это сдвиг влево в байте. Бит 0 — левая точка (глава 4), значит, чтобы точка уехала правее, её бит должен стать старше: ASL, а не LSR.
Сдвигать каждый байт каждой строки на каждом кадре в цикле — медленно. Поэтому HERO_PREP заранее строит 7 таблиц сдвига, по странице на каждый сдвиг s = 0–6 (SHTAB, $1500–$1BFF). В каждой странице две половины:
[v] = (v << s) AND $7F ; что остаётся в этом байте [v + 128] = (v << s) >> 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
Две половинки не пересекаются (одна занимает биты 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
У маски бит 7 = 1 всегда: цветовая пара байта берётся от фона. Иначе там, где герой проходит по оранжевой земле, у кусочков фона в этом же байте менялся бы цвет. Контур героя — нули в маске и нули в картинке: точки гаснут, получается тонкая чёрная обводка, которая отделяет белую фигурку от белых камней.
Маску тоже надо сдвигать — и тут ловушка. При сдвиге в освободившиеся биты заходят нули, а 0 в маске — «здесь герой». Вокруг сдвинутой фигурки появилась бы чёрная полоса. Поэтому PREP_ROW сначала переворачивает маску (EOR #%01111111 — теперь 1 = «здесь герой»), сдвигает эту «тень героя» по тем же таблицам, где нули как раз означают «пусто», и только потом переворачивает обратно — EOR #%11111111, заодно выставляя бит 7 = 1.
EOR с единицами — это «перевернуть биты». Раньше EOR встречался как «смешать» (глава 3) и «перевернуть часть битов» (генератор). Здесь — третья роль: «НЕ» для нужных битов.
Кадров у персонажа 6: три вида (↑, →, ↓) × два шага. Вида «влево» нет — это зеркальное «вправо». Чтобы отразить строку 14 точек, надо поменять местами два байта и в каждом перевернуть порядок 7 точек. Для второго — таблица REV7 на 128 значений:
Строится она по биту: 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 | стр. 2 | HX2 = 20 (OLDX[1]) | 21 | стр. 2: 21 |
| 2 | стр. 1 | 20 (OLDX[0]) | 22 | стр. 1: 22 |
| 3 | стр. 2 | 21 (OLDX[1]) | 23 | стр. 2: 23 |
| 4 | стр. 1 | 22 (OLDX[0]) | 24 | стр. 1: 24 |
Стирание — это перерисовка плиток. ERASE_AT не «закрашивает чёрным». Он смотрит, на какие клетки сетки попал прямоугольник героя (2–3 столбца × 1–2 строки), и заново рисует эти плитки из SCR_MAP — подпрограммой SCR_TILEN из главы 4. Номер клетки — через таблицу MUL20: 0, 20, 40 … 180. Ещё одно умножение, заменённое таблицей из 10 байт.
HERO_ENTER — новый экран рисуется целиком на обеих страницах (по трети секунды на каждую), и только потом начинается обычная смена кадров.
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 — можно
PASS_TAB — байт признаков на каждый из 112 номеров плиток: P_WALK — наступить, P_SLOW — медленно, P_LOOT — можно обыскать… AND оставляет нужные признаки, EOR превращает «ровно такие» в ноль. Ответ — флагом Z, сразу для BNE. Для NPC в WMASK ещё бит P_ACT: двери для них — не проход, и в дом они не заходят.
Анимация ног: каждые 3 шага HFR EOR #1 — номер шага 0 ↔ 1. Тот же переключатель, что у страниц, только бит 0.
Где находится герой — это три уровня адреса, как «город, улица, дом»: локация HERE (0–255, клетка карты региона 16 × 16), экран GSCR (0–8, клетка квадрата 3 × 3 внутри локации) и точка на экране HX2, HY. Эта глава — о том, что происходит, когда герой упирается в край экрана.
Если забыть про локации, регион — просто большая сетка экранов: 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: 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
INC GSCR)DEC × 2)Правило для всех четырёх: через край локации экран «переезжает» на противоположную сторону того же ряда или столбца. Вправо — из столбца 2 в столбец 0, то есть −2. Вверх — из ряда 0 в ряд 2, то есть +6 (ряд — это 3 экрана). Вниз — −6, влево — +2.
Разные подпрограммы проверяют край по-разному, и каждая — самым дешёвым способом:
| Куда | Край, если | Проверка | Внутри | Через край |
|---|---|---|---|---|
| → | столбец 2 | SCR_COL,X / CMP #2 / BEQ | INC GSCR | DEC DEC (−2) |
| ← | столбец 0 | SCR_COL,X / BEQ | DEC GSCR | INC INC (+2) |
| ↑ | GSCR < 3 | CMP #3 / BCC | SBC #3 | ADC #6 |
| ↓ | GSCR ≥ 6 | CMP #6 / BCS | ADC #3 | SBC #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.
Герой шагнул за край экрана. На соседнем экране у этого края может стоять дерево или дом — тогда переходить нельзя, герой просто останется. Но чтобы это узнать, нужна карта чужого экрана. Решение — «примерить»: построить чужой экран, проверить, а если нельзя — вернуть всё как было.
OHERE, OSCR и 32 байта таблицы NPC (OBJ_SAVE).WALK_UP / RIGHT / DOWN / LEFT по направлению HDIR. Край региона — уходим в REG_EDGE (глава 14).EDGE_V: 144, 0, 0, 132 для ↑ → ↓ ←.LOC_LOAD, потом SCR_GEN. Это только расчёт SCR_MAP, без рисования — доли секунды не уходит.HERO_FREE из главы 5 — по новой карте.SCR_SHOW рисует обе страницы, SUP_STEP списывает воду и еду за переход (глава 10, вместе со здоровьем). Нет: вернуть GSCR, HERE, пересобрать свою карту и NPC — и стоять.Почему так, а не «сначала нарисовать»? Построить карту — это главы 3 и 1, расчёт. Нарисовать — глава 4, по трети секунды на страницу. Если бы игра сначала рисовала, то на каждую попытку войти в дерево экран на секунду менялся бы туда-обратно.
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.
@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.
Когда герой появляется не через край, а «с неба» — новая игра, переезд на велосипеде, загрузка сохранения, — его надо поставить на проходимое место. Сначала пробуется центр: x / 2 = 70, y = 56 — ноги попадают в строку клеток 4, где идёт любая дорога. Если там занято — перебор: строки через 8 точек, столбцы через 7 (x / 2), сверху вниз, до первой свободной клетки. Та же HERO_FREE отвечает «можно?».
Внизу экрана (строки 22–23) SCR_INFO печатает имя, тип и «адрес» героя. Две мелкие хитрости:
LDA HERE / JSR PRBYTE — подпрограмма ПЗУ, печатает байт двумя шестнадцатеричными цифрами. Поэтому на панели номер локации и выглядит как в коде: «37».ORA #$B0:Символы цифр на Apple идут подряд: «0» = $B0, «1» = $B1 … «9» = $B9 (обычный ASCII $30–$39 плюс бит 7, глава 0). Младшие 4 бита у кода цифры — это сама цифра, а у маски $B0 они нулевые. Значит, ORA просто «приклеивает» цифру к нужной верхушке — тот же приём «включить свободные биты», что «+ 32» у слогов в главе 2.
На экране, кроме героя, бывает до четырёх фигурок: жители, охранники, мародёры, выживающие и собаки. Каждая сама решает, стоять ей или идти, видит ли она героя и что тогда делать. И все рисуются вместе с героем на тех же двух страницах, без мерцания. Вся «жизнь» экрана — это одна таблица из 32 байт.
По адресу $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.
Состав экрана — таблица 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 — враждебность к герою, поле +7. Считается один раз при появлении:
враждебность = база типа + (7 − порядок локации) / 2 + 4 − репутация у его группы / 2 (не меньше 0)
| Тип | База | (7 − 6) / 2 | +4 | Группа, репутация | − реп. / 2 | Итого | Поведение |
|---|---|---|---|---|---|---|---|
| житель | 2 | 0 | 4 | жители, 8 | −4 | 2 | дружелюбен |
| охранник | 4 | 0 | 4 | охрана, 8 | −4 | 4 +2 = 6 | настороже (+2: статус героя ниже NEIGHBOUR) |
| мародёр | 9 | 0 | 4 | мародёры, 4 | −2 | 11 | враждебен |
| собака | 15 | 0 | 4 | нет | — | 19 | враждебна |
Ровно эти числа и стоят в таблице выше: охранник 6, житель 2. Порядок у $37 высокий (6), поэтому слагаемое «за беспорядок» почти ноль. В локации-анархии (порядок 0) каждому прибавится ещё 3. Чем лучше репутация у группы — тем спокойнее её люди: это и есть «где наведён порядок, там и люди спокойнее».
Для чисел 0–7 «7 − x» — это просто перевернуть три младших бита: 7 = 111, вычитать из всех единиц — значит менять 1 на 0 и наоборот, никаких заёмов. Одна команда вместо LDA #7 / SEC / SBC — и не нужен второй регистр. У мародёра есть ещё одна деталь: даже «свой» (враждебность меньше 8) в 1 случае из 8 всё равно получает 8 — нападает.
Думать за всех четырёх на каждом кадре — дорого. Поэтому за кадр ходит один NPC, по кругу:
LDA NTURN ; чей ход: 0 → 8 → 16 → 24 → 0 CLC ADC #8 AND #%00011000 ; 32 → 0: остаются только биты 3–4 STA NTURN
Маска оставляет только биты 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 нужно знать расстояние до героя по 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
Это «дополнительный код»: −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, только на четыре фигурки.
NPC_ERASE: для каждого NPC сравнить 4 поля таблицы с записью DRW этой страницы. Совпадает всё — ничего не делать. Что-то изменилось — стереть там, где он нарисован на этой странице (ERASE_AT, перерисовка плиток), и пометить «нарисовать заново» битом в NDIRTY (слот 0 → 1, слот 1 → 2, слот 2 → 4, слот 3 → 8 — таблица DIRTY_BIT; четыре NPC — четыре бита одного байта).ER_ADD, до 5 штук). Туда же попадает стёртый герой.NPC_REDRAW: нарисовать помеченных — и тех, кого задело стирание. Стоящего жителя никто не трогал, но если герой прошёл рядом, перерисовка плиток под героем стёрла и половину жителя. ER_HIT проверяет, пересекается ли прямоугольник NPC с каким-нибудь стёртым.Пересечение двух прямоугольников — четыре сравнения: «мой левый край ≤ его правого, мой правый ≥ его левого» и то же по строкам. Все четыре верны — пересекаются. В коде — цепочка CMP / BEQ / BCS: «≤» на 6502 — это «равно или меньше», то есть BEQ (равно) или не BCS (меньше).
Под картинкой — четыре строки текста: где герой, что это за место, здоровье, сообщения («THE RAIDER ATTACKS!»). Это не нарисованные буквы, а настоящий текстовый экран Apple II, «подклеенный» снизу к графике. В главе: как текст хранится в памяти, почему его приходится копировать на вторую страницу, как из кусочков собирается строка панели и где живут 110 фраз игры.
Переключатель 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.
Тонкость смешанного режима: номер страницы общий. Когда показана 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 ($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 стирает строку от курсора до конца — так старый длинный текст не остаётся хвостом за новым коротким.
Строка 20 — «SETTLEMENT 1 TOWN LV 6» — нигде целиком не записана. Она собирается из пяти кусочков:
Неизменные слова — строки с нулём в конце (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 десятка коротких слов дают все варианты строки — места нужно меньше, чем на одну полную строку каждого вида.
Все фразы игры — «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 … PLA | A = 10 | PHA кладёт A в стек, PLA достаёт. Стек — самые быстрые «карманы»: одна команда туда, одна обратно, без адреса. |
| ASL A | 20 ($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 остаётся прежней.
Два старших бита кода на экране — это режим: 11 / 10 — обычный символ, 00 — инверсный (тёмная буква на светлом), 01 — мигающий. Отсюда и «бит 7» у всех строк игры (глава 0). Инверсия пригодится в главе 13: курсор на карте — это клетка, у которой просто сброшены два верхних бита: AND #%00111111.
Пробел делает одно из двух. На экране поселения открывается рынок: купить, продать, снаряжение. На любом другом экране — обыск: найти что-нибудь в развалинах. И рынок, и находки не хранятся: цены, запасы, «что здесь делают и что нужно» — всё снова считается из зерна при каждом заходе. Хранится только то, что изменил игрок: деньги, рюкзак, «обыскано» и «на сколько выросло поселение».
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 сама ничего не делает, только выбирает, кому передать работу.
Рынок — весь экран текстом, как станция в Elite: TXTSET выключает графику, HiRes-страницы при этом не трогаются, и при выходе картинка возвращается как была. У каждого поселения две «специальности»: какой товар оно делает (дёшево, много) и какой ему нужен (дорого, нет в продаже). Обе — из старших байтов зерна, по 4 бита, то есть номер товара 0–15:
Эти же байты уже работали на имя (глава 2, младшие 5 бит) — здесь берутся старшие 4. Если «делают» и «нужно» совпали, «нужно» сдвигается на следующий товар: ADC #1 / AND #%00001111 — по кругу 0–15. В развитых локациях (тип 3) краденое не берут: если им «нужно краденое», это заменяется на лекарства.
У каждого из 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 CANDLES | 2 + 0…1 | делают: ½ | 1 | 8 + 6 × 2 = 20 | 1 · 20 |
| 9 CLOTHES | 6 + 0…3 | нужно: × 2 | 12 | 0 | 12 · 0 |
| 12 SOLAR PANELS | 60 + 0…15 | редкость 2 | 70 | 0 | 70 · 0 |
| 0 WATER | 2 + 0…1 | обычный | 3 | 2…9 + 6 | 3 · 10 |
Маски в PVAR — 1, 3, 7, 15: числа вида «все единицы». AND с такой маской даёт равномерное случайное число 0…маска — без деления и без «остатка от деления». Поэтому разброс цены у дорогих товаров больше: у панелей ±15, у воды ±1.
Мелочь в @rnd: генератор заводится из зерна экрана (глава 3), но потом EOR #%00111100. Иначе первые «случайные» числа рынка совпали бы с первыми числами карты этого экрана — цены оказались бы связаны с тем, где лежат камни. Обыск делает так же со своей маской %10100111.
Денег бывает больше 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 = 244, денег хватает, хотя младший байт ($00) меньше цены. Вот почему смотреть только на младший байт нельзя.
Списать деньги — та же пара, только с настоящим вычитанием (SEC / SBC младших, SBC #0 старших). Добавить при продаже — CLC / ADC и ADC #0, как в главе 1. А если сумма перевалила за 65 535 (перенос из старшего байта), деньги просто ставятся на $FFFF — больше не бывает.
Процессор не умеет делить на 10, а печатать надо десятичные цифры. Решение — вычитать степени десяти, пока можно, и считать, сколько раз получилось:
P10_LO: .byte $10, $E8, 100, 10, 1 ; 10000 = $2710, 1000 = $03E8 P10_HI: .byte $27, $03, 0, 0, 0
| Разряд | Вычитаем | Сколько раз удалось | Остаток |
|---|---|---|---|
| 10 000 | $2710 | 0 — 350 меньше | 350 |
| 1 000 | $03E8 | 0 | 350 |
| 100 | $0064 | 3: 350 → 250 → 150 → 50 | 50 |
| 10 | $000A | 5 | 0 |
| 1 | $0001 | 0 | 0 |
Цифры 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.
Половинку байта называют «ниббл». Прибавить 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:
| Экран | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
|---|---|---|---|---|---|---|---|---|---|
| Роль | окр. | пос. 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).
Мелочь: если рюкзак полон, бит не ставится — можно вернуться с пустым рюкзаком и всё-таки забрать находку. А если влезает меньше, чем нашлось, — берётся сколько влезет.
BAG — 16 байт подряд, по байту на товар: сколько штук у героя. Сколько всего — BAG_SUM, цикл сложения 16 байт обратным счётом. Сколько влезает — BAG_CAP: 20, большой рюкзак +10, мотоцикл +10, иначе велосипед +5. Снаряжение — биты одного байта EQUIP: нож, рюкзак, пистолет, велосипед, мотоцикл. «Есть ли велосипед» — LDA EQUIP / AND #EQ_BIKE / BEQ. Восемь вещей «есть / нет» — в одном байте.
Бой в BLACKOUT устроен как в Elite: никакой ловкости пальцев, только действие и бросок кубика. Клавиша A рядом с NPC — и игра бросает кубик против шанса этого типа. Попал — NPC лежит. Дальше можно обыскать его карманы и связать, если есть верёвка. Можно и убить — оружием, — но за это придётся платить репутацией. В этой же главе — здоровье, вода и еда.
Любой бросок в игре — три команды:
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
Почему 16, а не 100, как в настольных играх? Потому что 16 — степень двойки: AND #15 выдаёт ровно 0–15, все варианты одинаково часто. Кубик на 10 граней пришлось бы делать делением — а деления у процессора нет.
Поле +5 таблицы NPC (глава 7) — состояние. Бой добавляет три новых:
Хитрость с рисованием: у лежащего в поле «шаг» (+4) записывается то же число, что состояние, — 2, 3 или 4. У идущего там 0 или 1. Значит, поле «шаг» изменилось, и NPC_ERASE из главы 7 сам поймёт, что NPC надо стереть и нарисовать заново — уже лежащим. Отдельного «перерисуй» не нужно.
Убитый не исчезает сразу по той же причине: он нарисован на обеих страницах. Состояние 4 говорит «не рисовать» — и за два хода его стирают сначала с одной страницы, потом с другой. Только потом слот освобождается.
И удар, и обыск начинаются с вопроса «кто рядом»: ближе 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, когда цель близко: на байт короче.
У каждого типа NPC в кармане один из двух товаров: у жителя — консервы или продукты, у охранника — лекарства или батарейки, у мародёра — бензин или краденое. Выбор из двух:
JSR GEN_RND ; что из двух LSR A ; бит 0 → флаг C: монетка LDA POCKA,Y ; первый вариант (LDA флаг C не трогает!) BCC @g LDA POCKB,Y ; монетка = 1 — второй @g:
Сначала случайный бит кладут в 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 вплотную (глава 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. Любое «нельзя отдыхать» сбрасывает обе — и отдых начинается заново.
Запасы тратятся не по часам, а за переходы между экранами (и за обыск): каждый 8-й переход — 1 вода, каждый 16-й — 1 еда (сначала свежие продукты, потом консервы). Счётчик переходов SWALK один, а «каждый 8-й» — это маска:
Три младших бита числа — это остаток от деления на 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).
Сообщение «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.
Кто такой герой для этого мира — одно число, очки статуса STPTS, 0–255. Из него получается ступень: от RAIDER (мародёр) до LEGEND (тот, кто включил свет). Рядом — репутация у трёх групп: охраны, мародёров и жителей, по числу 0–15 на группу. Всё это видно в окне, которое открывает клавиша I.
Восемь ступеней, 256 очков — по 32 очка на ступень. Делить на 32 — это пять сдвигов вправо: 32 = 2⁵.
Обе строчки окна — «HELPER (118)» и «NEXT AT 128» — из одного байта. Ступень — его три старших бита. Порог следующей — те же три бита с обнулёнными младшими (начало своей ступени) плюс 32. Младшие 5 бит — «сколько уже набрано внутри ступени».
| 0–31 | 32–63 | 64–95 | 96–127 | 128–159 | 160–191 | 192–223 | 224–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 сразу после них.
| Поступок | Очки | Где в коде |
|---|---|---|
| продал поселению нужный товар — за штуку | +1 | MKT_SELL (глава 9) |
| поселение выросло | +8 | MKT_SELL |
| связал мародёра | +2 | CMB_LOOT (глава 10) |
| запустил подстанцию | +16 | SUB_START (глава 12) |
| ударил жителя или охранника при свидетелях | −2 | CMB_WITNESS |
| убил | −16 | CMB_SHOOT |
Старт — 32 очка, STRANGER. С 64 (NEIGHBOUR) героя пускают на развитые рынки и охрана перестаёт злиться (CMB_GUARDH: +2 к враждебности охранника, пока статус ниже 64). Для запуска подстанции нужно 160 (MAYOR).
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: ; 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.
Окно 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) возвращает графику и перепечатывает панель.
Цель игры. В каждом регионе одна подстанция. Принёс трансформатор, кабель и реле, 10 канистр топлива, заслужил статус MAYOR — нажимаешь S, и регион получает свет. Так в 2025 году поднимали сеть Испании: «чёрный старт», подстанция за подстанцией. Когда горят все восемь — финал.
Место подстанции тоже не хранится — это один байт зерна. Берётся старший байт 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:
Бит 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: 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 (есть хотя бы одна), и «--», если нет.
Где горит свет, хранится в байте LIT: бит на регион. У текущего региона есть «свой бит» RBIT — 1, 2, 4 … 128 (таблица REG_BITS, глава 14).
«Есть ли свет здесь» — AND RBIT, «включить свет здесь» — ORA RBIT, «горит ли везде» — CMP #$FF: все 8 бит. Один байт на всю цель игры.
DEC PARTS,X × 3, топливо −10.LIT ORA RBIT.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.
Выходя из окна после пуска, игра перестраивает экран (SCR_GEN): SUB_GEN теперь видит свет и ставит штамп с фонарями, а выросшие поселения отстраиваются по шаблонам (главы 3, 9).
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 запоминает, какой символ был в клетке, — чтобы потом вернуть.
Стрелки на карте двигают курсор просмотра. Курсор — это та же клетка, только инверсная: у символа сбрасываются два старших бита.
Прежний символ сохраняется в 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. Расстояние — большая из двух разностей, по столбцу и по строке (как ходит король в шахматах: по диагонали шаг тоже один):
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).
Набрать на карте 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 € ...
В кодах 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) — карта получает её нетронутой и обработает как обычно.
Испания — 8 регионов, сеткой 3 × 3 «как на карте»: Страна Басков, Арагон, Каталония сверху, Кастилия, Мадрид, Валенсия посередине, Андалусия и Мурсия внизу. У каждого своё зерно (глава 1) — свои 256 локаций. В памяти помещается только один регион, поэтому, уезжая, игра записывает на дискету всё, что в нём изменилось, а возвращаясь — читает обратно. Эта глава — про соседей, переезд и работу с дискетой прямо из программы.
Где регион в сетке — две таблицы, 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.
Из главы 6: герой ушёл за край экрана, WALK_* сказал «край региона» — управление попадает в REG_EDGE. Нужен сосед с этой стороны (не море), мотоцикл и 5 канистр. Если всё есть — герой появляется в соседнем регионе у противоположного края, в той же строке или том же столбце. Новая локация считается двумя масками:
REG_KEEP говорит, какая половина номера сохраняется ($F0 — строка, $0F — столбец), REG_EDGEL — какой край вписать в другую половину. Для ↑: сохранить столбец, строку — нижнюю ($F0). Четыре направления — четыре пары масок в таблицах, без единого «если».
Экран — как в главе 6 через край локации: влево — +2, вправо — −2, вверх — +6, вниз — −6. В таблице REG_SCRD «−2» записано как 254 и «−6» как 250 — сложение по кругу 256 (глава 3).
REG_PUT: три таблицы текущего региона — LOC_SRCH, LOC_GROW, LOC_GROW3, по 256 байт — переложить подряд в буфер $4000 и записать на дискету файлом REG0…REG7.REGION и RBIT, WLD_FILL — новые 256 зёрен, SUB_INIT — новая подстанция.RVISIT AND RBIT)? — REG_GET читает его файл обратно в таблицы. Нет — таблицы обнуляются, и бит ставится в RVISIT.Вот и всё «сохранение мира»: 768 байт на регион. Ни одна локация, ни один экран, ни одна цена не записываются — их снова даст зерно. На дискету идёт только то, что изменилось за игру: где обыскано, где герой был, на сколько выросли поселения, сколько мародёров связал.
Почему буфер — $4000? Это HiRes-страница 2. Пока идёт работа с диском, на экране текст, графика не нужна — 8 КБ свободной памяти. После переезда новый экран всё равно рисуется заново.
Как программа просит 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).
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.
Последняя глава — то, что вокруг игры: заставка при загрузке, титульное меню, пауза с сохранением, продолжение с того же места и финал, когда горят все восемь регионов.
Пять строк меню — не пять кусков кода, а таблица троек «строка, столбец, номер фразы», с нулём в конце:
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 — попробовать загрузить сохранение.
Esc на карте — пауза: S — сохранить, Q — выйти, Return — назад. Сохранение — два файла:
REGn, тем же REG_PUT, что при переезде (глава 14);HERO, 64 байта: метка «есть сохранение» и переменные.Какие переменные — снова таблица: пары «адрес, длина», ноль в конце.
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.
Сохранить — скопировать переменные в буфер. Загрузить — то же самое, только наоборот. Одна подпрограмма делает оба, а направление ей передают флагом 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 — «rotate right»: сдвиг вправо через перенос. Вылетевший бит 0 уходит в C, а старый C входит в бит 7. Важен только бит 7: в нём теперь направление. Остальные биты — мусор, но на них никто не смотрит. Потом в цикле BIT MTMP копирует бит 7 во флаг N — и BMI решает. Флаг C, который портят сложения указателей, больше не нужен.
Указатель PTR смотрит на очередную переменную из таблицы, PTR2 — в буфер, и после каждого куска сдвигается на его длину (16-битно, с переносом в старший байт — BCC / INC PTR2+1). Буфер — снова $4000, вторая страница графики (глава 14).
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 байт, а восстанавливается весь мир: остальное снова даёт зерно.
Когда после пуска подстанции 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, ровно 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, куда их грузить. Как в мультфильме: пока зритель смотрит на кадр одной страницы, на вторую уже грузится следующий.
CLOCK копирует строки 174–191 (низ экрана, где время) со страницы 2 на страницу 1. На второй странице уже загружен кадр с 12:33 — меняются только часы, остальное на месте. Адрес строки на второй странице — тот же ROW_LO, а к ROW_HI прибавить $20 (глава 4).CASCADE идёт по таблице клеток (файл CASCADE: пары «столбец-байт, первая строка») и копирует каждую клетку 1 байт × 8 строк со страницы 2 — там «мёртвая» сеть — на видимую страницу 1, с паузой ~7 мс. 165 клеток в нужном порядке — и сеть гаснет от одного края к другому.BLINK переворачивает 6 точек в 5 строках — EOR #%01111110 — и через полсекунды переворачивает обратно. EOR второй раз с той же маской возвращает всё как было: «включить / выключить» одной командой.PAUSE: ждёт, но каждый шаг смотрит на клавиатуру и при нажатии выходит с C = 1. Каждый вызов проверяет BCS @go — и заставка сразу прыгает к BRUN MAIN.Всё, что умеет процессор Apple II, — 56 команд, 3 регистра и 7 флагов. Здесь они собраны в одном месте: что значит каждая команда, какие флаги меняет, пример из кода BLACKOUT и глава, где она разобрана подробно. В игре используются 43 команды из 56; остальные помечены.
| Регистр | Бит | Зачем |
|---|---|---|
| A | 8 | аккумулятор: все вычисления (сложение, логика, сравнение) — через него |
| X | 8 | индекс и счётчик: LDA TABLE,X, INX, CPX |
| Y | 8 | второй индекс; единственный для указателей (PTR),Y |
| S | 8 | указатель стека: стек — страница $0100–$01FF, растёт вниз от $01FF |
| PC | 16 | адрес следующей команды; меняют только переходы, JSR, RTS |
| P | 8 | флаги — см. ниже |
| Флаг | Значит | Кто ставит | Кто смотрит |
|---|---|---|---|
| N | negative: копия бита 7 результата | почти все, что меняют регистр; BIT — бит 7 памяти | BMI, BPL |
| V | overflow: переполнение со знаком | ADC, SBC; BIT — бит 6 памяти | BVC, BVS |
| B | break: признак BRK | BRK | обработчик прерывания |
| D | decimal: десятичная арифметика | SED, CLD | ADC, SBC |
| I | interrupt: прерывания запрещены | SEI, CLI | процессор |
| Z | zero: результат равен нулю | почти все, что меняют регистр; CMP — «равно» | BEQ, BNE |
| C | carry: перенос / «не было заёма» / вылетевший бит | ADC, SBC, CMP, сдвиги, CLC, SEC | BCC, BCS, ADC, SBC, ROL, ROR |
Главное правило (глава 0): флаги живут до следующей команды, которая их меняет. STA, STX, STY, переходы и JSR флаги не трогают — поэтому их можно ставить между сравнением и переходом.
Одна и та же команда (LDA) может взять число десятью способами. Способ виден по записи:
| Режим | Запись | Пример из игры | Что значит | Байт |
|---|---|---|---|---|
| неявный | — | INX, CLC, RTS | всё понятно из самой команды | 1 |
| аккумулятор | A | ASL A | работать с A | 1 |
| непосредственный | #число | LDA #$20, CMP #7 | само число стоит в команде | 2 |
| нулевая страница | адрес $00–$FF | LDA SEED ($10) | байт по короткому адресу — на байт короче и на такт быстрее | 2 |
| нулевая страница,X | адрес,X | STA SEED,X | адрес нулевой страницы + X | 2 |
| абсолютный | адрес $0000–$FFFF | LDA KBD ($C000) | байт по полному адресу | 3 |
| абсолютный,X / ,Y | адрес,X | LDA TXT_BLOAD,X | адрес + X (или Y): элемент таблицы | 3 |
| косвенный с индексом | (указатель),Y | LDA (PTR),Y | адрес лежит в двух ячейках нулевой страницы, к нему + Y | 2 |
| относительный | метка | BNE @loop | только у условных переходов: смещение −128…+127 | 2 |
| индексный косвенный | (указатель,X) | не используется | указатель берётся из нулевой страницы по адресу + X | 2 |
| косвенный | JMP (адрес) | не используется | перейти по адресу, который лежит в памяти | 3 |
16-битные адреса в коде всегда записаны младшим байтом вперёд: LDA TXT_BLOAD,X — это BD 67 93 (глава 0).
| Команда | От слов | Что делает | Флаги | Пример из игры | Где |
|---|---|---|---|---|---|
| LDA | LoaD A | A ← число или байт памяти | N Z | LDA SEED+1 | гл. 1 |
| LDX | LoaD X | X ← … | N Z | LDX #0 | гл. 0 |
| LDY | LoaD Y | Y ← … | N Z | LDY #0 | гл. 1 |
| STA | STore A | память ← A | — | STA SEED,X | гл. 1 |
| STX | STore X | память ← X | — | STX TCX | гл. 4 |
| STY | STore Y | память ← Y | — | STY TCY | гл. 4 |
| Команда | От слов | Что делает | Флаги | Пример из игры | Где |
|---|---|---|---|---|---|
| TAX | Transfer A → X | X ← A | N Z | ASL A / TAX | гл. 2 |
| TAY | Transfer A → Y | Y ← A | N Z | ASL A ×3 / TAY | гл. 1 |
| TXA | Transfer X → A | A ← X | N Z | TXA / ADC #8 / TAX | гл. 7 |
| TYA | Transfer Y → A | A ← Y | N Z | TYA / ASL A | гл. 3 |
| TSX | Transfer S → X | X ← указатель стека | N Z | не используется | |
| TXS | Transfer X → S | указатель стека ← X | — | LDX #$FF / TXS | гл. 15 |
| Команда | От слов | Что делает | Флаги | Пример из игры | Где |
|---|---|---|---|---|---|
| PHA | PusH A | положить A на стек | — | PHA … PLA в MSG_N | гл. 8 |
| PLA | PuLl A | снять со стека в A | N Z | PLA | гл. 8 |
| PHP | PusH P | положить флаги на стек | — | не используется | |
| PLP | PuLl P | снять флаги со стека | все | не используется |
| Команда | От слов | Что делает | Флаги | Пример из игры | Где |
|---|---|---|---|---|---|
| ADC | ADd with Carry | A ← A + число + C | N V Z C | CLC / ADC SEED+2 | гл. 1 |
| SBC | SuBtract with Carry | A ← A − число − (1 − C) | N V Z C | SEC / SBC #9 | гл. 3 |
| INC | INCrement | байт памяти + 1 | N Z | INC WCNT | гл. 1 |
| DEC | DECrement | байт памяти − 1 | N Z | DEC GSCR | гл. 6 |
| INX | INcrement X | X + 1 | N Z | INX | гл. 0 |
| INY | INcrement Y | Y + 1 | N Z | INY | гл. 1 |
| DEX | DEcrement X | X − 1 | N Z | DEX / BPL | гл. 6 |
| DEY | DEcrement Y | Y − 1 | N Z | DEY | гл. 3 |
| Команда | От слов | Что делает | Флаги | Пример из игры | Где |
|---|---|---|---|---|---|
| AND | AND | A ← A И число: 1 там, где 1 в обоих | N Z | AND #%00000011 | гл. 1 |
| ORA | OR with A | A ← A ИЛИ число: 1, если 1 хотя бы в одном | N Z | ORA #%00100000 | гл. 2 |
| EOR | Exclusive OR | A ← A исключающее ИЛИ: 1, где биты разные | N Z | EOR SEED+3,Y | гл. 3 |
| BIT | BIT test | N ← бит 7 байта, V ← бит 6, Z ← (A И байт) = 0; A не меняется | N V Z | BIT KBDSTRB | гл. 0 |
| Команда | От слов | Что делает | Флаги | Пример из игры | Где |
|---|---|---|---|---|---|
| CMP | CoMPare A | A − число, ответ выбрасывается, остаются флаги | N Z C | CMP LASTK | гл. 0 |
| CPX | ComPare X | X − число | N Z C | CPX #6 | гл. 1 |
| CPY | ComPare Y | Y − число | N Z C | CPY #1 | гл. 9 |
| Команда | От слов | Что делает | Флаги | Пример из игры | Где |
|---|---|---|---|---|---|
| ASL | Arithmetic Shift Left | все биты влево, бит 7 → C, в бит 0 входит 0 (× 2) | N Z C | ASL A | гл. 1 |
| LSR | Logical Shift Right | все биты вправо, бит 0 → C, в бит 7 входит 0 (/ 2) | N Z C | LSR A | гл. 1 |
| ROL | ROtate Left | влево, бит 7 → C, старый C → бит 0 | N Z C | ROL PTR+1 | гл. 1 |
| ROR | ROtate Right | вправо, бит 0 → C, старый C → бит 7 | N Z C | ROR MTMP | гл. 15 |
| Команда | От слов | Что делает | Флаги | Пример из игры | Где |
|---|---|---|---|---|---|
| JMP | JuMP | перейти по адресу | — | JMP SCR_TILE | гл. 4 |
| JSR | Jump to SubRoutine | адрес возврата на стек и перейти | — | JSR WLD_STEP | гл. 0 |
| RTS | ReTurn from Subroutine | снять адрес со стека и вернуться | — | RTS | гл. 0 |
| RTI | ReTurn from Interrupt | возврат из прерывания | все | не используется | |
| BRK | BReaK | программное прерывание | B I | не используется |
| Команда | От слов | Что делает | Флаги | Пример из игры | Где |
|---|---|---|---|---|---|
| BEQ | Branch if EQual | прыгнуть, если Z = 1 (равно, ноль) | — | BEQ @walk | гл. 0 |
| BNE | Branch if Not Equal | прыгнуть, если Z = 0 | — | BNE @loop | гл. 0 |
| BCC | Branch if Carry Clear | прыгнуть, если C = 0 (после CMP: меньше) | — | BCC @stun | гл. 10 |
| BCS | Branch if Carry Set | прыгнуть, если C = 1 (после CMP: больше или равно) | — | BCS @edge | гл. 5 |
| BMI | Branch if MInus | прыгнуть, если N = 1 (бит 7 результата) | — | BMI @new | гл. 0 |
| BPL | Branch if PLus | прыгнуть, если N = 0 | — | DEX / BPL @sv | гл. 6 |
| BVC | Branch if oVerflow Clear | прыгнуть, если V = 0 | — | не используется | |
| BVS | Branch if oVerflow Set | прыгнуть, если V = 1 | — | не используется |
| Команда | От слов | Что делает | Флаги | Пример из игры | Где |
|---|---|---|---|---|---|
| CLC | CLear Carry | C ← 0 (перед ADC) | C | CLC | гл. 1 |
| SEC | SEt Carry | C ← 1 (перед SBC; «да» в ответе) | C | SEC | гл. 3 |
| CLV | CLear oVerflow | V ← 0 | V | не используется | |
| CLD | CLear Decimal | D ← 0: обычная двоичная арифметика | D | не используется | |
| SED | SEt Decimal | D ← 1: ADC / SBC в двоично-десятичном виде | D | не используется | |
| CLI | CLear Interrupt | разрешить прерывания | I | не используется | |
| SEI | SEt Interrupt | запретить прерывания | I | не используется |
| Команда | От слов | Что делает | Флаги | Пример из игры | Где |
|---|---|---|---|---|---|
| NOP | No 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, 32 | LSR A нужное число раз | гл. 11 |
| разделить на 3, на 10 | вычитать в цикле и считать | гл. 9, гл. 13 |
| остаток от деления на 8, 16, 32 | AND #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 как ответ, зерно вместо хранения. Все команды, которые встречаются в главах, собраны в справочнике ниже.