Wasteland: the source

The game

The program the party plays in: the main loop and the menu commands, movement and the map window's scroll, the clock, the handlers of the square classes, encounters and the fight, damage and healing, parties, hiring, loot and the game's own text. The start-up, the radio and the Ranger Center load it from side 1, track 31, logical sector 9, to $7E00; its header asks for 72 pages, $7E00-$C5FF. The item table at $3100-$33FF belongs to this part too. What spans the parts (the memory layout, the saves, the map record's header, the square classes in brief, the menu bar and its keys) is in the game's facts.md and is not repeated here. Addresses are this part's own unless a part is named. The code was read in parts/game/work/play-map.vsf; live marks what was observed in the emulator, and runs on the kit's 6502 simulator are named as such.

Load and layout

• $7E00 is JMP $7E36, then the load address $7E00 and the page count $48, 72 ($7E03-$7E05).
• Three programs load it from side 1, T31/L9: the start-up (startup $8296-$829E), the radio (radio $8190-$81A1) and the Ranger Center's Start (ranger $7EEE-$7F00).
• $7E06-$7E35 is the hit list of a member's ranged attack, cleared by each one ($9FB2-$9FC7): three target lines at $7E06 ($FF ends them), kill counts at $7E09, damage words at $7E0C, ten hit counters an entry at $7E12, overkill flags at $7E30 and the weapon class of each entry's last kill at $7E33 (or 1 when that monster's flag byte was already 0, damage_monster $A704-$A70A).

• The item table is item file 0, T26/L5 (entry 0 of the directory at T35/L15), read and written by the engine (engine load_item_table $26BD, save_item_table $26D6). Its first eight bytes, 60 60 60 00 37 08 F8 39, are read by nothing; the 95 records of eight bytes follow, item n at $3108 + 8*n* (engine item_record $0BCD).

Starting and the main loop

• game_start ($7E36-$7E62) points the engine's menu texts $3E/$3F at $7F3C, one word for the bar's text at $5BAB, and its handler tables $40/$41 at $7F3E, one word for $7F18; sets $91 to $FF, so that enter_map loads the map; sets the bar's state ($39 and $3B 0, $3A 6); draws the bar (engine $02E7), enters the map (engine $03B6) and draws the view (redraw_view $AC8C). When $92 is set (the start-up sets it to 1, and the utilities' Start loads the game with that 1 still set, utils $8213-$8226; the Ranger Center's Start and the radio set it to 0, radio $8194) it runs cmd_stay $AE21 once, which moves the clock a step and runs the party's square ($7E5C-$7E60).
• main_loop ($7E63-$7F14), every pass: the Geiger counter ($7E63-$7E84), the idle count ($7E87-$7E9E), a key ($7EA1-$7ECF), the countdown (countdown_check $82B5), the end test ($7ED5-$7EFC), and View when nobody in the current party is conscious ($7F0C-$7F11). It makes 20.02 passes a frame with no radiation in view (live, the game's facts, "Live tests").
• The idle count: $B4 counts passes and $B5 its carries. When $B5 AND $3F comes to 0 the party takes a turn standing still: try_move_party with direction 4 ($ADD1), random_encounter ($B015), draw_view and encounter_if_engaged ($7E93-$7E9E). A key clears $B5 (engine read_key, through $022A), so the first idle turn comes 16,129 to 16,384 passes after the last key and the next ones every 16,384. Live: three idle turns in 3,000 frames, four minutes each on the world map (the game's facts, "Live tests").
• An idle turn advances the clock (move_party's advance_clock, $AE0A) but does not run the square's action, as no after_move follows. Direction 4 still puts the party's own square through square_blocked ($AD5B), so on an exit square whose record has bit 6 an idle turn asks "Enter new location (Y/N)?" (exit_confirm $8A36).
• Keys 1 to 7 ($B1-$B7), up to the party size $07, show that member's character screen (view_member_cmd $AC6C: engine view_character, redraw_view) and then fall into after_move ($AC72), which runs the action of the party's square again ($7EA4-$7EB7).
• F1, F3, F5 and F7 are Use for members 1 to 4 (use_by_member $8AA2): the engine's bytes at $5BA3 + member hold 0, $F1, $F3, $F5, $F7, 0, 0, 0, and the search runs only for a key other than 0 ($7EBA-$7ECF). Any other key goes to the engine's menu_key (engine $02DE).
• The end test: with no character records ($0A = 0) the game is over at once; otherwise records 1 to $0A, of every party, are tested, and one that is conscious, or UNC (condition_index 0) with +$28 = 0, keeps the game going. With none, the program asks for side 1 and loads T4/L2, the death part ($7EFE-$7F09). The test matches the healing: a UNC character with +$28 = 0 gains a point on every health tick, and one with +$28 set never does (con_heal_one $B854).
• With nobody conscious in the current party the loop runs View ($7F11). View looks for the next party it can show (view_party $9BBA wants a conscious member); each time the search comes round to the party it started from it advances the clock a step and prints it ($9BAE-$9BB1), so time runs until someone wakes ($9B8C-$9BB7).

The Geiger counter

• $9F is the distance, in tenths of a square, from the party to the nearest radiation square drawn. redraw_special_squares sets it to $FF and redraws the view's squares of classes 4, 5 and 9 ($AF7E); the engine's draw_square lowers it for a class 9 square before it chooses that square's tile by the hour (engine $0B74-$0B8A), so the counter clicks by day as well, when those squares show as plain ground.
• print_clock sets $9F to $FF when no member 1 to $07 carries item 48, the Geiger counter ($B176-$B192, engine find_item): carried is enough, it need not be equipped.
• While $9F is not $FF, each pass takes the divider $7F17 down one; at 0 it is set back to 5 and the countdown, the operand at $7E6A, goes down one, and at 0 the click sounds (engine play_sound_16, through $04D2). The next pass reloads the countdown with a random 1 to $9F + 1 ($7E69-$7E72). So clicks come 5*c* passes apart, c drawn from 1 to $9F + 1: 2.5 × ($9F + 2) passes on average for evenly drawn numbers.
• On the 6502 simulator from play-map.vsf, 3,000 frames for each value of $9F held, with CIA 1's timer A running as the snapshot has it (latch $4025, continuous): a click every 10.0, 30.2, 40.2, 54.9, 127.6 and 241.9 passes for $9F = 2, 10, 14, 20, 50 and 98 (the rule: 10, 30, 40, 55, 130, 250), about 76, 33, 25, 19, 8 and 4 a second at the simulator's pace. With the timer left reading 0 the clicks at 50 and 98 came every 114 and 215 passes, as the engine's random_byte adds in the timer's low byte (engine $24E3). The simulator gives the video chip no cycles, and makes 21.19 passes a frame with $9F = $FF and no idle turn where the machine makes 20.02 (live, above); the clicks themselves slow the loop, to 15.2 passes a frame at $9F = 2.

Commands

• The menu's handler table $7F18: Use $8A77, Enc $B1A3, Order $BF33, Disband $99EE, View $9B8C, Save $8820, Radio $8802, then the hidden keys I $AE19, K $AE84, J $AE46, L $AE65, back-arrow $AE21 (cmd_stay) and space $7F32 (the roster shown or hidden).
• Radio asks "Radio (Y/N)?" (message 1). Y saves the game and the map ($8833: engine save_game, through $02D8, then save_map, through $03B9), asks for side 1 and loads T26/L17, the radio program ($880A-$881A). N redraws.
• Save asks "Save game (Y/N)?" (message 73). Y asks for side 1, then saves the game and the map; either answer redraws ($8820-$8830).
• Order does nothing in a party of one; otherwise "Order (Y/N)?" (message 106), and Y sets $0505 to $FF, reads one page from T34/L15 to $CA00 and jumps there, with no side check ($BF33-$BF5C; the order part's facts). N redraws.
• The game prints its own messages through game_msg ($7F50: word-wrapped output, then the game's text block), from 88 JSR and JMP instructions here and from order $CA26; game_msg_direct_at $7F40 and game_msg_direct $7F44 print with direct output ($B8E6, $92B9; $931A). select_game_text ($7F5B) points $43/$44 at $BF5F.

Moving and the map window

• Directions (step_routines $ADBF): 0 north, 1 south, 2 west, 3 east, 4 none, 5 north-west, 6 north-east, 7 south-west, 8 south-east.
• square_blocked ($AD5B) refuses a step off the map, onto class 15 or 3 (an encounter), or when the next three tests refuse it: blocking_check_square ($8DEC, check squares), exit_confirm ($8A36) and bump_blocking_square ($915E).
• Walking into a class 11 square shows its record's message +0 and applies the change at +1/+2 to that square unless byte +1 is negative; the party stays. A class 4 square is passable unless its byte +1 has bit 7; then the same, with the change at +2/+3 ($915E-$9193).
• try_move_party ($ADD1) tests the step and calls move_party ($ADDF), which refuses (carry set) when nobody is conscious. Outside a fight ($D8 = 0) it redraws the party's square without the marker and scrolls the window; in a fight only the view's corner $02/$03 moves. Then party_square and advance_clock ($AE07-$AE0A).
• A step taken from a key goes on to step_done ($AE26): the step's sound (engine play_sound_16, through $04D2), random_encounter, after_move. cmd_stay (back-arrow) runs step_done whether or not the move was allowed ($AE21-$AE2C). Live: each step that moved called step_done once, and a refused one none (the game's facts, "Live tests").
• after_move ($AC72): party_square, redraw_special_squares, the markers ($ACB5: the other parties $AD13, the party $AF1D, the clock and the Geiger check $B143, engine draw_geiger_gauge), merge_parties_here ($9959); then, when someone is conscious, run_square_action ($ACC1), restore_view_if_covered ($B10C) and encounter_if_engaged ($B197).
• The view is 19 × 9 squares with the party at column 9, row 4 of it (engine $54, $59, $5A). The scroll ($BE26-$BF32) moves the bitmap and the colours through the engine's row copier at engine $DD80, which it patches ($BECC) with all RAM switched in (engine $04FC, $04FF): left for a step east ($BE26), right for a step west ($BE44), up for a step south ($BE74, rows 3-15 to 1-13), down for a step north ($BE90, rows 2-14 to 4-16). The new squares are drawn after it: rows 1 and 0 going north, rows 7 and 8 going south, columns 1 and 0 going west, columns 17 and 18 going east ($AE2F-$AEA2).
• line_of_sight ($8347), for the encounter scan ($95A9, $97AD) and the attack list ($B6D1), walks from the party towards a square, patching INC/DEC instructions for the direction, and fails at the first class 11 square on the way, the party's own square included; the end square itself is not tested.

Time

• advance_clock ($AF32-$AF7B) runs for every step and adds the map header's step cost (the game's facts, "The maps"): +$34 to the fraction $0C, +$35 and the carry to the minutes $0D (60 or more: less 60, and the hour $0E goes up one, 24 wrapping to 0), and +$36 to $D2 and to the 24-bit count $04-$06, whose carry goes on into $F4FD. Its callers: move_party ($AE0A), View ($9BAE) and the end of each battle round ($B393).
• The step costs of the 42 maps (their snapshots): a quarter of a minute and 1 unit on 28 maps; half a minute and 2 units on maps 1, 9, 10, 12, 16, 21, 22, 26, 35 and 49; half a minute and 4 units on map 40; two minutes and 4 units on maps 38 and 39; four minutes and 16 units on map 0. So $D2 runs at 4 units a minute everywhere but maps 38 and 39 (2) and map 40 (8).
• health_tick ($B795) runs when a step leaves $D2's low nibble at 0 ($AF75-$AF7B). enter_map clears $D2 (engine $25E1-$25E3), so the tick comes 16 units after entering a map and every 16 units after that: every 4 minutes on 39 maps, which on the world map is every step, every 8 minutes on maps 38 and 39 and every 2 minutes on map 40.
• A battle round ends with advance_clock and then health_tick ($B393, $B396), so a round brings one tick, or two when the round's step brings $D2's low nibble to 0, which on map 0 is every round.
• The countdown ($82B5-$82DF): once $F4F9 is set (map-20 $406B sets it and keeps the count $04-$06 in $F4FA-$F4FC), every pass of the main loop subtracts the kept count from the present one, 24 bits; at 240 or more it saves the map (engine save_map, through $03B9) and runs action $84, module 4 (run_action $8845). No map is tested: 240 units are an hour on most maps, two hours on maps 38 and 39 and half an hour on map 40.

Squares

• The handler table $ACF3: classes 0, 3, 7, 11 and 13-15 $AE0D (nothing), 1 $BDE9, 2 $8E14, 4 $833D, 5 $9194, 6 $8839, 8 $88E3, 9 $82E0, 10 $89A3, 12 $8878. Encounters (3, 15) and walls (11) are dealt with elsewhere: by the scan ($94CC) and by bump_blocking_square.
• run_square_action ($ACC1) runs the handler of the party's square, again for as long as it returns carry set (most end in alter_party_square $B105, carry set when the square changed), then sets $02AA to 0 and keeps the square's class and number in $C6/$C7 ($B138). A class 2 square is skipped unless its flags have bit 7, but that test comes once, before the loop ($ACC4-$ACCC): when a handler turns the party's square into a class 2 square without bit 7, the loop runs its checks too.
• Class 1 ($BDE9): the map messages listed in the record, the last with bit 7, unless the party's square has the class and number that $B138 kept in $C6/$C7 when the last square action ended, so after a step a neighbouring square with the same pair shows nothing ($8CC3 sets $C6 to 0 when a Use moves the party); then the party's square changes by the pair after the list.
• Class 4 ($833D): the map message at +0 (when not 0), then the change at +2/+3.
• Class 6 ($8839): run_action ($8845) on record byte 0 — $80 + n unpacks module n to $CA00 (engine $03BF) and calls it, a smaller number calls word n of the map's list 16 through $AC69 with $5F/$60 still on the record, and carry set on return redraws the view — then the change at +1/+2. The modules are 0 the doctor, 1 the shop, 2 the library, 3 the way into the Ranger Center and 4 the destruction of Base Cochise (the module parts' facts).
• Class 12 ($8878): the map message at +0, then five-byte entries from +1 (flags, column, row, class and number; flags bit 0: column and row relative to the party, bit 7: the last entry) applied with $AD/$AE kept around them; the view is redrawn unless the last entry's flags have bit 6; then the party's own square changes by the pair after the entries.
• Class 8 ($88E3), a question: the map message at +0 AND $7F. With bit 7 the answer is one key (RETURN or back-arrow: no answer); without it, a line of up to 16 characters typed after ">" into $5A00 (empty: no answer). Each answer message from +3 (the last with bit 7) is decoded to $5A80 and compared with the typed text (engine strings_equal, through $024F). The square then changes by pair n of the list after the answers for answer n, by the pair after those for a wrong answer, and by +1/+2 for none.
• Class 9 ($82E0-$8332), radiation: the map message at +0; then every member of the party, conscious or not, who is not wearing item 41, the Rad suit, as armour takes record byte +1 in d6 off CON (change_member_field $9082 with X = $1D, Y = $FF) and gets bit 0 of the disease byte +$28 set, Radiation poisoning in the doctor's list (bit_masks $8335, of which only the first byte is ever read; module-0's facts); then the change at +2/+3. Whether armour counts is decided by the record's byte 0 (the game's facts, "The maps", live).
• Class 10 ($89A3-$8A35), an exit. Nothing while $02AA says N was answered. Otherwise its message (bits 0-5 of byte 0) unless exit_confirm has shown it ($022E), the change at +4/+5, and the party table's +$0B/+$0C/+$0D take the party's column, row and map as the return point, the old values kept in the operands $8A12, $8A19 and $89FC. Byte +3 = $FF goes back to the old return point and returns carry clear ($89EE-$8A01); otherwise bytes +1/+2 are the column and row, added to the party's own when byte 0 has bit 7, and +3 the map ($89E1-$8A24). exit_enter_map ($8A26) enters the map, draws the view, merges parties and returns carry set, so the arrival square's handler runs next.
• exit_confirm ($8A36), on a move into a class 10 square whose byte 0 has bit 6: the exit's message and "Enter new location (Y/N)?" (message 103). Y sets $022E; N redraws, sets $02AA and refuses the move ($8A60).
• A shop's door is such an exit. Map 10's exit 8 (map-10 $402A) holds E7 00 00 0A 06 01: message 39 with bit 6 to ask, relative 0, 0, map 10, and the change to class 6 number 1, whose record (map-10 $3F6F, 81 FD FD) runs module 1, the shop (map-10's and module-1's facts).

Check squares

• A class 2 record ($8DEC-$915D): +0 flags, +1 a message shown whenever the checks run, +2 the success message, +3 the failure message, +4/+5 the change on success, +6/+7 the change on failure, +8 the effect's character-record offset (bits 0-6; a whole byte of 0: none, $9046, so $80 would act on field 0, which no map's record has; bit 7: the amount at +9 as it stands, else that many d6), +9 the amount (bits 0-6; bit 7: subtract), and pairs from +$0A to an $FF; with flag bit 3, one change for each pair follows (check_change_offset $9108).
• The flags: bit 7, the checks run once the party stands on the square (run_square_action), not on the move into it (blocking_check_square); bit 6, the square has checks (without it only message +1 shows, and on the move the step is refused); bit 5, every conscious member is tested, else the first decides; bit 4, the effect falls on everybody and ends the tests; bit 3, a passing pair's own change; bit 2, one pass is enough, which changes something only with bit 5 (or after bit 4's effect), bit 3 also ending the tests at the first pass; bit 1, a Use that no pair matches shows message +3 instead of game message 61, the bit not being read when +8 has an effect ($8DCB, and the Use below); bit 0, a CON effect ignores armour ($90B2).
• A pair is kind (first byte >> 5) and difficulty (bits 0-4), then a value ($8E47-$8EBE). Kind 0 a skill, where difficulty 0 means knowing it is enough (engine skill_level and skill_check, through $0359 and $0207); kind 2 an attribute, the value being its record offset (engine attribute_check, through $0212); kind 3 passes only when the party has exactly value members (CMP $07, $8E85-$8E8A); kind 4 passes when the member has less cash than the value and, when the member has that much, fails at once without trying the other pairs, taking no money (engine $03D4, $8E73-$8E83); every other kind is an item the member carries, a charge of which is used (engine find_item and use_item_charge, through $0344 and $0380). An item Used on the square matches kind 1 pairs only (find_item_check $8F84).
• An exact size is all kind 3 can ask: map-19's check 11 (map-19 $3BE0) asks for a party of 8, where a party has room for seven (ranger's facts, "Code nothing reaches").
• blocking_check_square ($8DEC) runs the checks for a square the party tries to enter, again while they change the square, and refuses the step unless they pass.
• The effect ($9082): subtracting from CON goes through member_takes_damage ($A85B) with $C8 = 1 and $A0 = flag bit 0; from cash through engine $03CE; from any other field the low byte only, never below 0. Adding to experience goes through engine add_experience ($03DD); to any other field the low byte, unless that would pass 255. apply_square_effect ($9039) makes the change with slow scrolling on ($914D) at the speed in its operand $906A, which is 2 in the snapshot and afterwards whatever the speed $0F was when the last effect ended (the cursor keys change it while text scrolls slowly, engine $253A); the speed and $A8 from before are put back after ($9144).
• The effects of the check records with checks (flag bit 6) that the 42 maps' class 2 squares name are all on CON (+$1D, 72 records), but one: map-41's check 22 (map-41 $3CBF) reads as an effect on +$7F (+8/+9 = $FF $FF) and a pair for skill 129, bytes that look like a CON −1d6 effect two bytes later than the reader expects.

Use and healing

• cmd_use ($8A77) asks "Which player?" (message 2) unless the party has one member. use_by_member ($8AA2) refuses a member whose CON is 0 or below ("is incapacitated.", message 3).
• use_choose ($8AD5) asks "Use: I)tem S)kill A)ttribute?" (message 4, keys S, I, A at $8BEB). A skill comes from the skills page; Medic (25) or Doctor (32) then asks "Who do you want to heal?" (message 5) and refuses the healer (6), one at CON 0 (7) and one who is conscious (8). An item comes from the item page (record offset $BB + 2 × its line), an attribute from "Which: 1) Strength ... 7) Charisma" (message 11, offsets $0E-$14). Except for healing it then asks the direction ("Which way?", ask_direction $B8D0, message 68).
• use_on_square ($8BEF): a non-player character may refuse ("disobeys you.", message 69): its byte +$2C for a skill, +$2B for an item, +$2D for an attribute, tested against +$31 ($8D83, $8D86, $8D89; engine npc_obey_check, through $021F). The square in the chosen direction must be class 2, or the answer is "You see nothing special." (38) for Perception and "Nothing happens." (12) otherwise ($8D9D). A matching pair is tried; success shows +2 and changes the square ($8C77), failure or no pair takes $8CC7, with the square's +3 when its flags have bit 1 or a pair was tried, else "That doesn't seem to work." (61) ($8DC8).
• use_heal ($8D05): the healer rolls the skill (engine skill_roll_total, through $020A: 2d6 rolling again on doubles, under 5 failing, plus the attribute and 4 × the level) against 15 + 5 × (|CON's low byte| >> 2) for Medic, >> 3 for Doctor ($8D40-$8D57). Failure: "You didn't help <name>." (9). Success: the patient's CON is shifted right with the sign kept ($8D5C-$8D68: −20 becomes −10, −3 becomes −2, −1 stays −1), "<name> is improving." (10), and the healer may learn (engine skill_improve_roll, through $020F, with that difficulty).

Encounters

• random_encounter ($B015), after each step: when the map header's +$2F is not 0, a chance of 1 in +$2F; it then needs a free entry, bytes 3, 5 and 7 zero, among the first +$32 of the map's list 15. The monster type is 1 to +$31 at random. By that monster's weapon class 0-12 the entry's byte 0 comes from $B0EB (15, 35, 40, 65, 90, 40, 65, 90, 65, 90, 40, 65, 90), byte 1 from $B0F8 (15, 15, 40, 65, 90, 40, 65, 90, 65, 90, 40, 65, 90), and the distance in squares from the engine's $5B93 (1, 1, 1, 3, 4, 1, 3, 4, 3, 4, 1, 3, 4). A random direction (not 4) is walked that far from the party, each square on the map, not in column or row 0, of class 0 and without a party; if one fails, the next direction, and when all have failed, one square less. The entry gets line 0 = the type with 1 to (monster byte 4 >> 4) monsters, and the square becomes class 15 with the entry's number ($B045-$B0C8).
• scan_for_encounters ($94CC; with the view drawn, $94CF) clears the 16 position records at $5B4F and sets each party's reach $F4E1 + party to the longest of its members' reaches, the operand of the CMP # at $9510 keeping the longest so far from 0 ($94EC-$951E): member_reach ($BC39) gives 0 for a member who is not conscious, $FE for a ranged weapon with rounds in it, and 15 otherwise. Each party on the battle map $8D then scans its view for class 3 and 15 squares. A square counts when the party can see it, has someone conscious, and its distance (engine distance_to_party, through $04CF) is within the record's byte 1, or within byte 0 and the reach ($95A9-$9630). It goes to the nearest party that can engage it, four records a party, a full party's records giving way to a nearer square.
• With the view drawn, a square within its record's byte 0 shows the tile of the monster kind of its first line whose type byte is not zero ($95DE-$95EA; group_write_back $BA59 zeroes the type byte of a line wiped out in battle) (engine $5BF5 + the monster record's byte 6; kind 3 while the line's monster is still to be rolled), and one beyond it or out of sight is drawn as the map has it ($95D7-$960B, $9828).
• place_encounter_groups ($936E) gives each recorded square a battle group, $EE00 + 376 × party + 94 × group (group_ptr $BBC7): lines whose number or count has bit 7 are rolled, 1 to the low seven bits, and written back into the map's record, so they stay fixed; the record's message is printed and the group announced ("... appear at d feet."); and every monster gets hit points: a quarter of the type's 16-bit seed (monster bytes 0/1) + 1 to its low byte + 256 × (1 to its high byte) ($9483-$94B9). So a Laser Hypermortar (map 16, seed 350) has 344 to 437 and a Finster Leviathan (map 23, seed 1,200) 557 to 1,500.
• A monster record ($9EA4): +0/+1 the hit-point seed, which is also the experience base; +2 to-hit; +3 damage dice; +4 maximum count (high nibble) and armour dice (low); +5 damage bonus (high) and weapon class (low); +6 kind 1-5; +7 the picture, and the index of its pronoun (engine $5B00). Until the encounter is identified (record byte 9 bit 0) a line is named by its kind: game messages 83-87, Animal, Mutant, Humanoid, Cyborg, Robot ($9E5D). Of the 365 encounter records that the 42 maps' squares name, 357 start identified, 98 peaceful, 52 stationary and 6 with an NPC to hire.

The fight

• encounter ($B1A3), from Enc, from encounter_if_engaged and so after every move: $D8 = 1, and the experience of records 1 to 7 is kept at $F487 ($F486 = $0A). Each round ($B1E7) takes every party in turn: one whose map is in the fight list $5B8F or in memory fights; another with someone conscious is asked "This party isn't on this map and isn't in battle. Do you want them to execute a battle round (Y/N)?" (messages 54, 76). For a party that fights, its map is entered, the encounters scanned and placed, the groups measured and their moves planned ($B237-$B243), and every party on that map gives its orders; "Use these options (Y/N)?" (70) then runs the round ($B290-$B2A0).
• get_party_orders ($B3B2): a party none of whose groups is in use is asked "This party is not being attacked. Do you want them to execute a battle round (Y/N)?" (20, 76). Each conscious member is shown "<name>, choose: R)un U)se H)ire E)vade A)ttack W)eapon L)oad/Unjam" (55) and takes a key of $B4BD: space H A W R E L U S, the order being the key's index; S, not on the prompt, stores its index 8 and becomes order 2, A)ttack, with the group list always shown for a player character ($B449, $B4A0; an NPC still chooses its own line, $B50B). A party Run gives every member order 8 with the direction.
• battle_round ($B867): "Encounter begins..." (30), then four passes over the parties on the battle map ($9F40): the members' ranged attacks ($9F70), the monsters' fire ($9C65), melee ($7F64), and the other orders ($9EFD: Hire, Weapon, Evade, Load, Use); the last three only when a party took part. Then runs and party moves ($A276) and merge_parties_here for every party ($B8AC-$B8C0).
• melee_round ($7F64) fills slots at $5A00 with initiative: a monster of a group within 15 feet (distance below 16), hostile, of a line whose weapon class is not ranged, alive and with its act flag set (which is cleared) gets 2d6 + 8 × its byte +2, the product taken in 8 bits; a conscious member with the Attack order still standing (members with a ranged reach fired already and their order was cleared, unless their target line had nobody alive left, $9FB0: such a member keeps order 2, joins here and strikes nobody, $80CD-$80D0) gets 2d6 + SP + 4 × Brawling. The highest slot acts first, and on a tie the later slot, so members, whose slots come last, beat monsters ($8057-$8080).
• A member strikes 1 + Brawling/2 times ($80BF-$80C7), hitting when 1d100 is under melee_chance ($8256): base 60 when the target's group has a move planned ($F3EC + 4 × party + group not $FF), else 50 ($80E7-$80F1), + 4 × Brawling + the AGL bonus, − 4 × the monster's byte +2 when its class is 1, else − (byte +2 − 5), within 0 and 100. A miss prints "<name> misses." (35). A hit does the weapon's roll + 4 × the weapon skill + the DEX, ST and LK bonuses, added with a floor at 0 ($811A-$813B), to a random living monster of the line, less that monster's armour roll (monster_takes_damage $AA90).
• A melee kill adds the kill's experience twice ($8163, $8166). Live: with the party put on map 1's graveyard with the game's own enter_map, weapons cleared, A each round, three kills of Shambler Ghouls worth 40 each took each killer from 0 to 80, with no experience printed (the game's facts, "Live tests").
• A monster's turn ($8177): as many attacks as its byte +2, each at a random conscious member, who avoids it when 1d100 is under melee_chance with base 60 for the Evade order, 50 for Attack and 40 otherwise ($81CF-$81DF). A miss prints "The <monster> misses." (31); a hit, one of the map's melee verbs (header +$56/+$57) and byte +3 d6 + the high nibble of byte +5 to the member ($8217-$821D).
• The monsters' fire ($9C65): for each hostile group of the party and each line from 2 down to 0, a line whose monster has a ranged class fires, each monster with its act flag once (a dead one only when the flag has bit 7, left by the shot that killed it when its flag was still set, $A704-$A711; a monster killed after its flag was cleared keeps 0 and does not fire). A line whose monster is not ranged ends the group, so the lines after it do not fire ($9CA9-$9CAE). A shot hits when 2d6 rolling again on doubles, under 4 always missing, + the to-hit byte + 8 × the fire mode reaches the range target ($9CF0-$9D2E). Mode 2 (classes 11 and 12) fires 3d4 shots, mode 1 (classes 5-7) 1 to 3, mode 0 one ($9D0B-$9D67); each strikes a random member (monster_shot_hits_member $9DEC), who escapes with the Evade order when the roll beat the target by less than 6 ("but <name> nimbly evades.", message 93).
• The groups' moves (plan_group_moves $83D7, move_groups $872D): a hostile group that is not stationary plans from its first line with monsters. A melee line closes in unless it is within 15 feet; but one whose monsters are not animals flees instead once their average hit points are under half the type's seed ($8448-$8461). A ranged line flees when weaker than the party (robots never), stays when its to-hit byte plus 15 (robots), 11 (cyborgs) or 7 reaches its range target, and otherwise moves to a better position ($847F-$84D7). A hostile group left without a plan gets its act flags set. The plans are kept at $F3EC, and the moves print " moves to a better position.", " runs away." or " runs at you." (72, 74, 75).
• encounter_end ($B320): the party chosen at the start ($B6) again, "<name> gains n experience." (39, 40) for each record whose experience grew, $D8 = 0, the map entered and the view drawn.

Attacks

• party_ranged_attacks ($9F70): every conscious member with the Attack order and a reach of $FE attacks its target, a line index 0-47 in the order's argument (12 × party + 3 × group + line, $A535) with the fire mode in its bits 6-7.
• member_hit_roll ($A584): 2d6 rolling again on doubles; a roll under 4 followed by a 1 on a d6 spoils the attack: classes 8, 9 and 13 "fail to detonate" (41), other weapons jam (42: the count byte becomes $80, the rounds lost). Otherwise the roll + DEX + 4 × the weapon skill, + 10 for class 13, + 4 for a burst, + the rounds left for automatic fire.
• member_attack ($9FA9) adds 8 to the roll when the target is in another party's groups ($9FEF-$9FFA), and hits when the total reaches the range target (member_range_target $A741). range_target ($BD48) gives, for distance d in tenths of a square and k = d/5 rounded up: 5*k* for classes 2, 5, 10 and 13, 10 + 2*k* for classes 3, 6, 8 and 11, 20 + k for the rest, and 7 more when the monster looked up is not of a ranged class.
• A miss prints "<name> attacks the <monster> and misses." (28, 32) and uses one round, three for a burst, all for automatic fire ($A02B-$A040). A hit with class 13 rolls once and strikes every living monster of the group's three lines; otherwise a single shot hits once, a burst 1 to 3 times, automatic fire max(1, rounds/4) d4 times spread over the group's lines ($A98C-$A9AC).
• The damage ($A7DE): the weapon's dice (item byte 6) in d6, plus the LK bonus. Classes 8 and 9 roll 2 × dice − the target's armour dice instead, when the dice are at least the armour, and armour is not taken off them again ($A818-$A835, $A9AD); for the rest the monster's armour dice are rolled and taken off, stopping at 0. An empty or jammed gun is swung: 1d6 for classes 2 and 10, 2d6 for the others, plus the class number ($A807-$A816).
• The attribute bonus ($A7C3) for an attribute v: (v − 12)/2 rounded down from 13, 0 for 9-12, (v − 9)/2 rounded down below 9, so −3 for 3 and 4.
• A kill gives the member the type's seed × (armour dice + 1) in experience (kill_experience $A9E8). After an attack the member may learn the weapon's skill at difficulty armour/2 + 1 ($AA35). A one-shot weapon, record byte 4 = 1 and class 1 or ranged (items 6-12, 14 and 15), is used up; a class 13 one is replaced from another slot holding the same item (attack_done $A53A).
• The report names each line with a verb pair chosen by the weapon from the map header's +$3E on, the points of damage, and " killing him/her/it/n of them" or, when the kill went 15 or more below 0 (set_overkill $ABF1), one of the map's pair at +$5A/+$5B; " just as he peels off a final shot" (34) follows when the killed monster's class was ranged and its flag byte was still set; otherwise $7E33 holds 1 ($A708).
• choose_attack ($B4C7) refuses a jammed weapon (56); with no line in reach it says "Reload your weapon." (80) for an empty ranged weapon, else "No one is within range." (57). The group list ($B61C) runs items 1 to 64 ($4D = $41, $B626-$B628), each a line index item − 1, of which 0-47 exist; group_list_line ($B63D) shows an item when group_in_reach ($B692) passes it and its count is not 0. With a gun of classes 5-7 or 10-12 holding 3 rounds or more the player chooses the fire mode, S)ingle or B)urst, and A)uto too from 4 rounds (messages 58-60); any other attack is single ($B5BE-$B60E, class_fires_bursts $AC04).
• An NPC chooses for itself ($B50B-$B589): at melee reach the first line in reach in single mode; otherwise a random line in reach, single shots with a weapon that cannot burst or with fewer than 3 rounds, a burst with exactly 3, and with more a burst, or automatic fire when a d10 reaches the byte of $B4F8 for the number of characters (records 1 to $0A of every party) who are not conscious: $FF, 9, 7, 5, 3, 0, 0, 0 ($B528-$B556). So an NPC never fires automatic while everyone is up, 20 % of the time with one down, 40 %, 60 %, 80 %, and always from five down.

Damage to members and health

• member_takes_damage ($A85B), called by a monster's melee ($821D), a square's effect ($90BC) and the monsters' fire ($9E23), does nothing (carry set) to a member at CON 0. A member already down (CON negative) takes damage that is not from a monster ($C8 set); from a monster of a ranged class, never (" but misses.", 91); from any other, only when 2d6 rolling again on doubles is under the monster's byte +3 ($A889-$A8AF). That last test is never reached, as a monster's melee picks conscious members only ($81B7-$81C7). So no monster hurts a member who is down, and the monsters' fire never touches one.
• Armour: the AC (+$1A) in d6 off the damage, unless $A0 is set ($A8B2-$A8C5). When nothing is left, damage that is not from a monster prints "'s armor absorbs the damage." (100, 101) after the name, and a monster's " but his/her armor absorbs the damage." (94, 101), or " but misses." (91) when the monster's class is 1 and the member's AC is 0 ($A8E8-$A900). Otherwise the line goes on with " gets hurt for " (99) or the map's verb (header +$51) and the points of damage. Then CON goes down (engine con_subtract, through $0407): reaching exactly 0 makes it −1; −50 or below makes it 0, dead; a member going down keeps the CON from before the blow in +$26/+$27 and gets " and " and the condition ($A986: messages 49-53, 25).
• health_tick ($B795), for records 1 to $0A, skips the dead (CON exactly 0). A disease of bits 4-7 of +$28 (Desert dust, Rabies and two named "D6" and "D7" in the doctor's list, module-0's facts) costs a conscious member a point, 1 going to −1 rather than 0, and one who is not conscious two, every fourth tick ($D2 AND $3F = 0, $B816-$B83F). Otherwise a UNC member (−1 to −10) gains a point each tick and wakes at 0 with half of +$26/+$27 (1 when that is 0); one at −11 or below loses a point each tick, dying below −50 ($B842); one with CON above 0 and below MAXCON gains a point when $D2 AND $3F is 0, or $D2 AND $7F in the current party, which so heals at half the rate of the others ($B7FD-$B810).
• No healing at all while +$28 is not 0 (con_heal_one $B854), and radiation sets its bit 0 ($8313-$831C): a member it has touched recovers neither CON nor consciousness until the bit is cleared, as the doctor does for a fee (module-0's facts).
• The MAXCON test compares the high bytes and then, when CON's is at least MAXCON's, only the low bytes ($B7E9-$B7FB): a CON whose high byte is above MAXCON's goes on healing while its low byte is below MAXCON's. On the 6502 simulator: CON $0105 with MAXCON $00FA healed to $0106; $01FA stayed; $00F0 healed and $00FA stayed.
• A blow kills at −50 (CMP #$CE, $A94C-$A950, equal counting), the tick only below −50 ($B848-$B84A, equal surviving), so −50 reached by bleeding is still alive.

Parties

• select_party ($9C17, 27 call sites) keeps the current party's column, row and map in its table ($9C45), then takes party A's: $08, $07, $57/$58, $09, and the view's corner. clear_party_table ($9C58) zeroes a 14-byte table.
• A party table's bytes +$0B-+$0D hold the return point of the last exit ($89BA-$89D7); copy_member_to_party ($9B27) carries them from the old party to the new one through $9B69.
• merge_parties_here ($9959), after every move, exit, run and battle round: one other party on the party's square and map joins it, the later tables move down and $0B drops. $08 drops when it came after the merged party; $B6, the party chosen when a fight began, drops only when it is at or above both the merged party and $08 ($99A2-$99AD), so with $B6 between the merged party and the current one it ends up naming the next party.
• runner_split_off ($98F5): a member who runs leaves in a party of his own, $0B + 1, unless he is alone or there are four parties, when the whole party moves (with four parties and others in his party, "couldn't run.", message 88, $A276).
• Disband ($99EE): nothing in a party of one; with four parties "No more can disband." (21). "Who wants to disband?" (22) takes member keys until RETURN, back-arrow or all but one are chosen: " has been chosen." (23) for one already chosen, " is unconscious." (24) for one below CON 0, who stays; a dead one is offered "Do you want to bury <name>?" (79, 78) and an NPC, while two or more are conscious, "Do you want to dismiss <name> forever?" (79, 77); Y removes the character for good. Then "Which way?" is asked, and the chosen members leave, become the current party and take the step ($ADD1), then after_move.
• View ($9B8C, $9BBA): the next party with a conscious member; on another map "They aren't on this map. Are you sure you want to view them (Y/N)?" (27); "You can't view this party." (14) when it has nobody conscious but other records are.

Hiring

• The Hire order ($A3F1), in the round's last pass: nothing when the target line is dead; "No room in roster." (95) when seven records are in use; a failure when the group's record is not peaceful (byte 9 bit 1) or names no NPC (byte 9 high nibble).
• The NPC's 256-byte record, word n of the map's list 17, is copied to record $0A + 1 ($A424-$A433). When its byte +$31 is not 0 the hirer needs (CHR + IQ)/2 + CHR + rank + 2d6 rolling again on doubles to reach the NPC's (CHR + IQ)/2 + +$31 + rank, and dice under 5 fail at once, raising the copy's +$2B-+$2D by one ($A44C-$A478, $A4E0-$A4EA); that copy is not kept.
• On success the NPC joins ($0A and $07 + 1), its message (+$30, map text) shows, its +$31 becomes the hirer's CHR, its +$2B-+$2D drop once for every 4 points of margin, its line's hit points are cleared so the line leaves the fight, and every item slot's count is filled from the item's byte 4 ($A47A-$A4DD). With +$31 = 0 no roll is made and the margin is taken from whatever the accumulators held. Failure: "<name> tries to hire the <monster> but fails." (44, 81).

Loot

• A loot record ($9194): +0/+1 the change once the bag is empty, then entries of an item byte and a count to an $FF. On opening, each entry is fixed in the map's record: an item byte 1-$5D without bit 7 names an item class and becomes a random item of that class with bit 7 set; $5E (cash) becomes $DE and the two bytes after it are each rolled from 1 to themselves; a count with bit 7 becomes 1 to its low seven bits ($919C-$921A).
• An entry naming a class that no item has is emptied: count_items_of_class returns 0, and the LDY that follows, whose operand is the entry's offset, leaves Z clear, so the BNE after the store is taken ($91C8-$91D1). On the 6502 simulator, entries naming classes 5 and 20 were emptied.
• "Who wants loot?" (16) takes a conscious member; the list (19) takes an entry. Cash goes straight to the member; an item goes to the first free slot with its record's byte 4 as the count ("You can't carry any more.", 18, when full). The last entry taken makes the change at +0 ($921D-$92E0).

Items

• A record ($3108 + 8*n*): bytes 0-1 the price, 2 the stock (0 not sold; a purchase lowers it by one, $FF included, and a sale raises it by one up to $FF, module-1 $CC12-$CC19, $CB2C-$CB37), 3 class × 8 + effect, 4 the clip size or uses, 5 the governing skill, 6 damage dice or AC, 7 the ammunition item ($AC39). Item n's name is engine message 36 + n. The table is the item-table file that $75 names (directory at T35/L15; engine $26BD loads it, $26D6 writes it back): the start-up and the utilities load it before the game, and a shop loads the file its record names and writes it back after a trade.
• The classes in the table: 1 Fists and the hand weapons (items 0-5), 2 the two pistols, the Spear and the Throwing knife (13-16), 3 Flamethrower and M17 carbine (17, 18), 4 M19 rifle and Red Ryder (19, 20), 6 the SMGs (21, 22), 7 the assault rifles (23, 24), 8 Mangler and Sabot rocket (9, 10), 9 LAW rocket and RPG-7 (11, 12), 10 Laser pistol (25), 11 Ion beamer and Laser carbine (26, 27), 12 Laser rifle and Meson cannon (28, 29), 13 the explosives (6-8), 14 ammunition (30-34), 15 armour (35-42), 16 gear (43-57), 17 the Clay pot, Fruit and Jewelry (91-93), 18 the other objects (58-90). No item has class 5.
• Item 94 is cash, not a carried item: the loot code takes it as money ($91B4) and its record's bytes in the item-table files 0 and 1 (07 BF 11 FB B9 C4 7E 08) are not an item's. Files 2 and 4 have other bytes there, and in file 4 its class is 1, so with that file loaded (map 21's Market and Blackmarket) count_items_of_class ($92EA) counts item 94 in class 1 and the loot pick ($91D3-$91FA) may choose it (not traced further).
• Items 62 and 63 are both Bloodstaffs, with the same eight bytes.
• Item 20, the Red Ryder, has a price of 12,345, stock 0, class 4, a clip of 63, the Rifle skill, 200 damage dice and the 7.62mm clip. No loot record or NPC record of the 42 maps names it, and no loot entry names class 4; the maps' own routines were not searched.

Text

• The text block at $BF5F: the 60-byte alphabet, then the group table at $BF9B, 28 words of which 0-26 point at groups $BFD3-$C596 and word 27 ($D9C4, at $BFD1) outside the block; so the messages are 0 to 106, message 0 empty.
• The combat phrases come from the map: the header's 37 message numbers (the game's facts, "The maps"), read here through show_map_msg_pair $BCE1 (one of two at random) and show_map_msg_at $BCE5.

Code nothing reaches, and oddities

• game_msg_wrapped_at ($7F4C) has no caller: no JSR, JMP or address word for it in any part's or map's snapshot.
• use_first_skill ($8A9E) has no caller either, and $E6, which it sets, is otherwise only cleared ($8B3B), so use_choose's $E6 branches are never taken.
• BIT $C010 at $88FF and $8A31 read a byte of the text; their flags are not used. On the Apple II $C010 clears the keyboard strobe.
• $C5B3-$C5FF, after the text block, are never read, jumped to or pointed at; from $C5B6 they decode as code that loads and stores $C08C-$C08E,X with X = $60, the Disk II controller's switches for slot 6 on the Apple II.
• The order part's page holds a stale copy of $7EA2-$7EFF, with calls into this program that never run (order $CAA2-$CAFF, the order part's facts).
• bit_masks ($8335) has eight bytes and only the first is read, through an LDY #0 whose operand nothing changes ($8313-$8315).
• Entries hidden in the operands of BIT instructions: $80F1, $81DC, $81DF, $8D86, $8D89, $8DB9, $8DBC, $9029, $94CF, $9E52, $A03B, $A03E, $A7BB, $A7BE, $A7C1, $B4F1, $B8CB, $B9E6 and $BF12, among others.
• The monsters' initiative is 8 × byte +2 in 8 bits ($7FDB-$7FDD), which would wrap from 32; the melee types in the 42 maps have 7 at most (map 15's Titanium Clawer and map 35's Brother Goliath).
• A monster type whose byte +2 is 0 makes melee_chance 0: the term is negated in 8 bits with $FF as its high byte, so 0 becomes −256 ($828B-$8292). The only such type in the maps is map 16's Chopter, a ranged one, which a member then cannot hit in melee.
• member_range_target looks up the monster of line g, g being the target's group number (0-3), not its line ($A748-$A768), so the 7 points for a non-ranged target follow another line's monster, and for group 3 a byte past the line table ($BAEC).
• The weapon damage adds a negative LK bonus without a floor ($A7E7-$A7F2): a sum below 0 comes back as 65,535 or near it, a kill. A throwing knife (2 dice) thrown with LK 3 or 4 does it when both dice show 1.
• The swung empty gun adds its class number to the roll ($A80B: the LDA #$00 at $A809 is overwritten), so a swung Meson cannon does 2d6 + 12.
• set_overkill tests the remainder's two bytes apart, so a kill that leaves exactly −256 counts as a plain kill ($ABF1-$AC01).
• A planned move to "a better position" needs a target number that differs from the present one, not a lower one ($8550-$855C).
• monsters_fire checks for a living member before it starts and after each shot of modes 1 and 2, not after a shot of mode 0 ($9C6A, $9D8F), and monster_shot_hits_member picks members until one is not dead, with no limit ($9DFD-$9E26). So when a mode 0 shot kills the party's last living member, the next hit in the same call never returns, unless its roll beat the target by less than 6 and the member picked still holds the Evade order ($9E08-$9E18). Since the monsters' fire cannot touch a member who is down, that last member has to go from conscious to −50 or below in one blow.
• In the encounter scan, on a square already recorded, the LDA # at $9649 replaces the distance that nearest_engaging_party has just returned with its own operand, the party chosen in an earlier pass (stored at $9652 and $96C4). So the test of whether the nearest party already holds the square compares that earlier party ($964B), and a record moved to the nearest party keeps that party's number, 0 to 3, as its distance ($964F, store_position_record $97F2).
• encounter_portrait ($B91E) picks the nearest line by the group's stored distance (byte 3), not the one group_in_reach has just measured (nearest_line $B9A0).
• Map 26's number layer holds bytes under class 0 squares, which nothing reads: 2,229 of them in rows 1-62 (154 on map 17, 158 on map 36, a few on five more maps). Row 25, columns 10-35 (map-26 $424A-$4263) reads as code, CMP #$03, BEQ, CMP #$02, BNE, LDA $7E47, JSR $08FD, LDA $7E47, JSR $9D6A, CMP #$10, BCC, where $9D6A in this build is a store inside monsters_fire. A class 0 square's number only finds a record, and class 0's handler does nothing ($AE0D).

The whole game

Cheats