;file - RACEPLAY.OVL
;подлинковать файлы - с меткой:
;sc2intro.snd - MUSIC
;panel.crn - PANEL
;buttons.spr - BUTTON
;trees.spr - TREES
;ammun.spr - AMMUN
;moto.spr - MOTOCY
;motexpl.spr - MOTEXP
;helic.spr - HELIC
;helexpl.spr - HELEXP

TopScreen = 50000
Screen = TopScreen+1000
HORIZ  = 124000
HIWIN  = 132

NTreesIncPeriod = 2000. ;период, через который увеличивается количество деревьев

AddToSpeed = 400        ; коэффициент увеличения скорости при газовании
SubToSpeed = 2000       ; коэффициент уменьшения скорости при торможении
SubToSpeedSt = 1000     ; коэффициент уменьшения скорости если что-то пошло не так
MaxSpeed = 47000        ; верхний предел скорости

MaxBreaks = 5           ; максимальное количество аварий

; а игра оказывается только на БК11 будет работать, зря я всякие ухищрения
; делал в заставках

TOPSTK:         mov     #60, R5
                mov     #NoIrq, (R5)
                mov     (R5)+, @#274
                clr     (R5)                ; прерывание от клавиатуры
                mov     (R5)+, @#276        ; можно прервать прерыванием по вектору 100
                mov     #76000, @#177716    ; стр.6 в окно.0  стр.4 в окно.1
                mov     #40000, R0
0$:             mov     40000(R0), (R0)+    ; копируем стр.4 в стр.6
                tst     R0
                bpl     0$
                mov     #17400, @#177716    ; стр.5 в окно.0  стр.6 в окно.1
                jmp     InitGame

MINSEC:         .byte   0, 0, 0, 0, 0, 0
;                       │  │  │  │  │  └ единицы секунд
;                       │  │  │  │  └─── десятки секунд
;                       │  │  │  └────── единицы минут
;                       │  │  └───────── десятки минут
;                       │  └──────────── единицы часов
;                       └─────────────── десятки часов
RND:            .word   51254
CHCKKL:         .word   0 ;счёт за убитых преступников
TROFF:          .word   0

Course:         .word   0
CourseFine:     .word   0

ScaleInd:       .byte   3, 60, 14, 300  ; маска индикатора шкалы

L1122:          .word   0
                .word   -2000, -1300, -500, 300, 1700, 3700, 6300, 6300

L11240:         .byte    1,  1,  1,  1,  2,  2,  2,  3
                .byte    3,  4,  5,  6, 10, 12, 14, 17
                .byte   21, 24, 26, 30
                .even

;записи спрайтов деревьев
TreesSpriteParam:
                .word   1000    ;1
                .byte   2, 10
                .word   TREES

                .word   1200    ;2
                .byte   2, 12
                .word   TREES+20

                .word   1400    ;3
                .byte   2, 15
                .word   TREES+44

                .word   1600    ;4
                .byte   2, 20
                .word   TREES+76

                .word   2000    ;5
                .byte   2, 22
                .word   TREES+136

                .word   2200    ;6
                .byte   2, 25
                .word   TREES+202

                .word   2400    ;7
                .byte   2, 31
                .word   TREES+254

                .word   2600    ;10
                .byte   4, 35
                .word   TREES+336

                .word   3000    ;11
                .byte   4, 47
                .word   TREES+522

                .word   3200    ;12
                .byte   4, 57
                .word   TREES+756

                .word   3400    ;13
                .byte   4, 67
                .word   TREES+1252

                .word   3600    ;14
                .byte   6, 105
                .word   TREES+1606

                .word   3600    ;15
                .byte   6, 125
                .word   TREES+2444

                .word   3600    ;16
                .byte   6, 132
                .word   TREES+3442

                .word   3600    ;17
                .byte   6, 132
                .word   TREES+4476

                .word   3600    ;20
                .byte   6, 132
                .word   TREES+5532

                .word   3600    ;21
                .byte   6, 132
                .word   TREES+5532

                .word   3600    ;22
                .byte   6, 132
                .word   TREES+5532

                .word   3600    ;23
                .byte   6, 132
                .word   TREES+5532

                .word   3600    ;24
                .byte   6, 132
                .word   TREES+5532

PrevArrayTrees: .blkw   100                 ; предыдущий массив деревьев
CurrArrayTrees: .blkw   100                 ; текущий массив деревьев


InitGame:       mov     #45400, @#177662
                mov     #TOPSTK, SP
                mtps    #0
                call    MUSIC               ; запускаем музыку в заставке
                mov     #MINSEC, R0
                clr     (R0)+
                clr     (R0)+
                clr     (R0)+
                comb    -(R0)
                mov     #1, TAKT
                mov     #20, @#177706
                mov     #34, @#177712
                mov     #HLT4, @#4
                mov     #200, @#177716      ; разрешаем кнопку СТОП
                call    CLRSCR
                mov     #34, @#177712
                call    OutInfoGetInfo      ; инфо, класс
                call    InitVarsScreen      ; панель...
                mov     #34, @#177712
                clrb    L1064
                clrb    BikerStatus
                clr     NPULI
                clr     CHCKKL
                br      24$

; главный цикл
Loop$:          tst     (PC)+               ; есть движение?
CurrentSpeed:   .word   0
                ble     36$                 ; нет
                dec     (PC)+               ; пора считать проеханный путь?
WAYH:           .word   0
                bgt     35$                 ; нет ещё
                mov     #10, WAYH           ; да - инициализируем счётчик
                inc     (PC)+               ; считаем проехенное расстояние
WAY:            .word   0
35$:            call    COUNT               ; рисуем счётчик
24$:            ; блок увеличения количества деревьев
                dec     (PC)+               ; пора добавлять дерево?
NTreesIncCnt:   .word   0
                bgt     41$                 ; нет ещё
                mov     #NTreesIncPeriod, NTreesIncCnt  ; пора - инициализируем счётчик
                inc     (PC)+               ; увеличиваем количество деревьев
NumTrees:       .word   0
41$:            call    ZoomTrees           ; движение деревьев и проверка на аварию
                call    SetupTrees          ; расстановка деревьев

36$:            clr     (PC)+
CourseScalar:   .word   0                   ; признак отклонения от курса, 0 - нет, >0 - влево, <0 - вправо
                call    INKEY
                ; блок приращения/уменьшения и вывода скорости
                tstb    (PC)+               ; мы больше никуда не едем?
StopDriveFlag:  .word   0
                bne     5$                  ; да
                tst     R1                  ; нет, проверим управление
                beq     5$                  ; ничего
                bmi     3$                  ; газуем
                sub     #SubToSpeed, CurrentSpeed  ; тормозим
                bpl     4$                  ; если ещё не остановились
                clr     CurrentSpeed        ; остановились
                br      4$
                ; газуем
3$:             cmp     CurrentSpeed, #MaxSpeed     ; если не максимум скорости
                bgt     4$
                add     #AddToSpeed, CurrentSpeed   ; увеличиваем скорость

4$:             call    OUTSPD              ; рисуем скорость
                ; блок изменения и вывода курса
5$:             tst     CourseScalar        ; признак отклонения от курса, 0 - нет, >0 - влево, <0 - вправо
                beq     16$                 ; едем прямо
                bpl     13$                 ; едем влево
                ; едем вправо
                dec     CourseFine          ; пора изменять курс?
                cmp     CourseFine, #-10
                bgt     15$                 ; нет
                dec     Course              ; да - меняем
                br      14$
                ; едем влево
13$:            inc     CourseFine          ; пора изменять курс?
                cmp     CourseFine, #10
                blt     15$                 ; нет
                inc     Course              ; да - меняем
14$:            clr     CourseFine
                call    OutCourse           ; рисуем курс

15$:            call    SlideTrees          ; перемещение деревьев вбок
16$:            ; прорисовка пустого экрана
                mov     #HORIZ-4000, R1
                mov     #HIWIN, R0
                clr     R2
200$:           mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                mov     R2, (R1)+
                sob     R0, 200$
                ;рисуем горизонт
                mov     #HORIZ, R0
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+
                com     (R0)+

                call    DrawCopter          ; работа с вертолётом
                call    DrawMoto            ; работа с мотоциклом
                call    DrawBullet          ; полёт пули
                call    DrawTrees           ; рисуем деревья
                mov     (PC)+, R0
CurrArrayTreesSize: .word   0               ; количество деревьев в текущем массиве
                mov     R0, (PC)+
PrevArrayTreesSize: .word   0               ; количество деревьев в предыдущем массиве
                beq     6$
                mov     (PC)+, R1
PrevArrayTreesPTR:  .word   PrevArrayTrees  ; адрес предыдущего массива деревьев
                mov     (PC)+, R2
CurrArrayTreesPTR:  .word   CurrArrayTrees  ; адрес текущего массива деревьев
2$:             mov     (R2)+, (R1)+
                sob     R0, 2$
6$:
                ; сервисные процедуры
                tstb    StopDriveFlag       ; мы больше никуда не едем?
                beq     51$                 ; нет, едем
                sub     #SubToSpeedSt, CurrentSpeed ; иначе сбрасываем скорость
                call    OUTSPD
                ; блок уменьшения горючего
51$:            mov     CurrentSpeed, R0    ; посчитаем
                swab    R0                  ; пора ли
                asl     R0                  ; уменьшать топливо
                sub     #AddToSpeed, R0     ; на одно деление
                sub     R0, (PC)+
L4674:          .word   0
                cmp     L4674, #17000       ; пора?
                blo     52$                 ; не пора
                clr     L4674               ; пора
                mov     (PC)+, R1           ; берём уровень топлива
FUEL:           .word   0
                ble     25$                 ; закончилось
                swab    R1                  ; есть ещё - рисуем
                ror     R1
                asr     R1
                neg     R1
                clr     75374(R1)   ; рисуем уровень оставшегося горючего
REPFUE:         dec     FUEL        ; уменьшаем топливо !!!исправить на TST
                br      27$

52$:            tst     FUEL                ; проверяем топливо
                bgt     27$                 ; есть ещё
25$:            incb    StopDriveFlag       ; закончилось, больше никуда не едем
                tst     CurrentSpeed        ; скорость ещё есть?
                bpl     27$                 ; да - тогда будем двигаться по инерции
                reset                       ; всё...
                mov     #20, R0
30$:            mov     #66174, R1
                mov     #72, R2             ; это мигает топливо
28$:            com     (R1)                ; когда кончится
                add     #100, R1
                sob     R2, 28$
                sob     R2, .
                sob     R0, 30$
                br      44$                 ; конец игры из-за исчерпания горючего

27$:            ; блок проверки времени
                cmp     GameTime, #360.     ; счётчик секунд
REPTIM:         blo     40$                 ; ещё не вышло
                incb    StopDriveFlag       ; закончилось, больше никуда не едем
                tst     CurrentSpeed        ; скорость ещё есть?
                bpl     40$                 ; да - тогда будем двигаться по инерции
                reset
                mov     #20, R0
42$:            mov     #71710, R1
                mov     #10, R2             ; это мигает счётчик времени
41$:            com     (R1)+               ; когда оно кончится
                com     (R1)+
                com     (R1)+
                com     (R1)+
                add     #70, R1
                sob     R2, 41$
                sob     R3, .
                sob     R0, 42$             ; конец игры из-за не уложения во время
44$:            jmp     YOUFOL

40$:            ; блок проверки пути
                cmp     WAY, #500.          ; доехали до конца?
                blo     45$                 ; нет ещё
                incb    StopDriveFlag       ; да, больше никуда не едем
                sub     #SubToSpeedSt, CurrentSpeed ; хватит, гасим скорость
                tst     CurrentSpeed        ; скорость ещё есть?
                bpl     45$                 ; да - тогда будем двигаться по инерции
                reset
                jmp     HAPEND              ; конец игры из-за конца пути

45$:            ; блок реакции на аварию
                tstb    (PC)+
CRRASHH:        .word   0                   ; флаг аварии
                beq     32$
                ;АВАРИЯ!!!
                mov     #1130, @#177664
                clrb    CRRASHH
REPBRK:         inc     (PC)+               ; увеличим счётчик аварий !!!исправить на TST
Breaks:         .word   0
                mov     Breaks, R0
                add     #73061, R0
                mov     #12, R2
33$:            comb    (R0)
                add     #100, R0
                inc     @#177664
                sob     R2, 33$
                call    SOUND4
                mov     #1342, R5
                mov     #5000, R3
34$:            mov     #20000, R2
                call    RANDOM
                add     #TopScreen, R0
                cmp     R0, #TopScreen-1000
                blo     34$
                cmp     R0, #TopScreen+14100
                bhis    34$
                mov     R5, @#177664
                mov     #5, R4
35$:            mov     #-1, (R0)
                add     #100, R0
                sob     R4, 35$
                bit     #377, R3
                bne     012$
                dec     R5
012$:           sob     R3, 34$
                mov     #1330, @#177664
                cmp     Breaks, #MaxBreaks+1
                blo     37$
                mov     #TopScreen, R0
                mov     #6300, R1
42$:            mov     #-1, (R0)+
                sob     R1, 42$
                jmp     YOUFOL

37$:            call    L7710           ; очистим окно
32$:            mov     #HORIZ-4000, R1
                mov     #Screen, R2
                mov     #HIWIN, R0
201$:           mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                mov     (R1)+, (R2)+
                sob     R0, 201$
                ;блок звуков и задержки
                mov     #MaxSpeed+7000, R3
                mov     CurrentSpeed, R4
                beq     1574$
                sub     R4, R3
                call    SOUN11  ;мотор
1574$:          asr     R3
                asr     R3
1620$:          tstb    @#177712
                bpl     1620$
                mov     R3, @#177706
                mov     #34, @#177712
                call    SOUND1  ;мотор
                jmp     Loop$


;работа с деревьями
DrawTrees:      mov     CurrArrayTreesPTR, R1
                mov     CurrArrayTreesSize, -(SP)
                beq     0$

DrwTL1$:        clr     DrwTCS$         ; сколько байтов выходит за правый край экрана
                movb    (R1)+, R4       ; номер дерева
                mov     R4, R0
                asl     R4
                add     R0, R4
                asl     R4              ; * 6
                add     #TreesSpriteParam-6, R4
                mov     #HORIZ, R0
                sub     (R4)+, R0
                clr     R3
                bisb    (R1)+, R3       ; адрес дерева + 40
                mov     R1, -(SP)
                add     R3, R0
                sub     #40, R0         ; адрес экрана
                cmp     R3, #140        ; левый край дерева выходит за правый край экрана?
                bhis    2$              ; да  - выход
                movb    (R4)+, R2       ; ширина дерева в байтах
                mov     R3, R1
                add     R2, R1          ; правый край дерева
                cmp     R1, #40         ; не дотягивает до левого края экрана?
                blos    2$              ; да  - выход
                movb    (R4)+, R5       ; высота дерева в строках
                mov     (R4)+, DrwTA$   ; адрес спрайта

                cmp     R1, #140        ; пр. край дерева выходит за пр. край экрана?
                blos    1$              ; нет - нормально
                mov     R1, R3          ; да - тогда узнаем сколько байтов
                sub     #140, R3        ; не влезает
                br      20$             ; идём работать

1$:             cmp     R3, #40         ; левый край дерева выходит за левый край экрана?
                bhis    3$              ; нет - идём работать
                sub     #40, R3
                neg     R3
                add     R3, R0
                add     R3, DrwTA$
20$:            mov     R3, DrwTCS$
                sub     R3, R2          ; в R2 - сколько влезает

3$:             mov     #100, R4
                sub     R2, R4
                mov     (PC)+, R1
DrwTA$:         .word   0
DrwTL2$:        mov     R2, R3
6$:             bisb    (R1)+, (R0)+
                sob     R3, 6$
                add     R4, R0
                add     (PC)+, R1
DrwTCS$:        .word   0
                sob     R5, DrwTL2$
2$:             mov     (SP)+, R1
                dec     (SP)
                bgt     DrwTL1$
0$:             tst     (SP)+
                return
;движение деревьев, всегда фиксированно на одну позицию
;и проверка на аварию
ZoomTrees:      mov     PrevArrayTreesPTR, R1   ; адрес предыдущего массива
                mov     CurrArrayTreesPTR, R4   ; адрес текущего массива
                clr     -(SP)                   ; количество деревьев в новом массиве
                mov     PrevArrayTreesSize, R3  ; количество деревьев
                beq     6$
5$:             movb    (R1)+, R5
                clr     R0
                bisb    (R1)+, R0
                sub     #100, R0
                mov     R5, -(SP)
                movb    L11240-1(R5), R5
                clr     R2
1$:             add     R0, R2
                sob     R5, 1$
                mov     (SP)+, R5
                asr     R2
                asr     R2
                asr     R2
                asr     R2
                asr     R2
                asr     R2
                add     R2, R0
                add     #100, R0
                bmi     0$
                cmp     #200, R0
                blo     0$
                cmpb    #20, R5
                blo     2$
                incb    R5
                movb    R5, (R4)+
                movb    R0, (R4)+
                inc     (SP)
                br      0$

2$:             cmp     #46, R0
                bhi     0$
                cmp     #124, R0
                blo     0$
                incb    CRRASHH             ; врезались в дерево
0$:             sob     R3, 5$              ; обработаем все деревья в массиве
6$:             mov     (SP)+, CurrArrayTreesSize
                return

;перемещение деревьев вбок
SlideTrees:     mov     CurrArrayTreesPTR, R0
                mov     CurrArrayTreesSize, R3
                beq     0$
                tst     CourseScalar    ; признак отклонения от курса, 0 - нет, >0 - влево, <0 - вправо
                bmi     1$
3$:             movb    (R0)+, R4
                asr     R4
                adc     R4
                sub     #10., R4
                neg     R4
                clr     R1
                bisb    (R0), R1
                add     R4, R1          ; вот на сколько смещаются деревья
                cmp     R1, #200
                ble     2$
                sub     #200, R1
2$:             movb    R1, (R0)+
                sob     R3, 3$
0$:             return

1$:             movb    (R0)+, R4
                asr     R4
                adc     R4
                sub     #10., R4
                neg     R4
                clr     R1
                bisb    (R0), R1
                sub     R4, R1
                bgt     4$
                add     #200, R1
4$:             movb    R1, (R0)+
                sob     R3, 1$
                return

;расстановка деревьев
SetupTrees:     mov     NumTrees, R2
                call    RANDOM
                sub     #37, R0
                mov     R0, R4
                add     CurrArrayTreesSize, R4
                cmp     #70, R4
                bhi     70$
                clr     R0
70$:            mov     R0, R5      ; сколько деревьев прибавить
                ble     0$
                asl     R0
                mov     CurrArrayTreesSize, R3
                asl     R3
                add     CurrArrayTreesPTR, R3
                mov     R3, R4
                add     R0, R4
                mov     CurrArrayTreesSize, R2
                beq     1$
2$:             mov     -(R3), -(R4)
                sob     R2, 2$
1$:             mov     CurrArrayTreesPTR, R3
                add     R5, CurrArrayTreesSize
3$:             mov     #200, R2
                call    RANDOM
                movb    #1, (R3)+
                movb    R0, (R3)+
                sob     R5, 3$
0$:             return
;RND
RANDOM:         mov     RND, R0
                mov     R0, R1
                asl     R1
                asl     R1
                add     R0, R1
                swab    R0
                clrb    R0
                asl     R0
                sub     R1, R0
                add     @#177710, R0
                mov     #27, R1
                xor     R1, R0
                mov     R0, RND
                bic     #100000, R0
                asl     R2
0$:             asr     R0
                cmp     R0, R2
                bpl     0$
                asr     R2
                sub     R2, R0
                inc     R0
                bpl     1$
                neg     R0
1$:             return

;работа с вертолётом
DrawCopter:     tstb    (PC)+
L1064:          .word   0       ; флаг и статус вертолёта
                bne     0$
                mov     #100, R2
                call    RANDOM
                cmp     #10, R0
                blos    1$
                incb    L1064
                clr     ADHELI
                clr     R3
                br      2$

0$:             cmpb    #2, L1064
                beq     3$
                mov     (PC)+, R4
NHELI:          .word   0
                mov     CourseScalar, R3        ; признак отклонения от курса, 0 - нет, >0 - влево, <0 - вправо
                asl     R3
                add     (PC)+, R3
ADHELI:         .word   0
                add     R4, R3
                bpl     9$
                add     #300, R3
                br      10$

9$:             cmp     #300, R3
                bhi     10$
                clr     R3
10$:            mov     R3, ADHELI
                dec     (PC)+
L1074:          .word   0
                bne     11$
2$:             mov     #30, R2
                call    RANDOM
                inc     R0
                mov     R0, L1074
                mov     #2, R2
                call    RANDOM
                asl     R0
                sub     #3, R0
                mov     R0, NHELI
                mov     R0, R4
;рисуем на новом месте
11$:            mov     R3, R2
                cmp     R2, #200
                bhis    1$
                mov     #HELIC, R1
                asl     R4
                add     HACN+2(R4), R1
                mov     #HORIZ-3000, R0
                mov     #12, R3
                mov     #11, R5
                br      SpriteOut
;совсем убираем вертолёт
3$:             clrb    L1064
                clr     ADHELI
1$:             return

;работа с мотоциклистом
DrawMoto:       tstb    (PC)+
BikerStatus:    .word   0 ;флаг и статус мотоциклиста
                bne     0$
                mov     #100, R2
                call    RANDOM
                cmp     #5, R0
                blos    MO1
                incb    BikerStatus
                clr     ADMOTO
                clr     R3
                br      2$

0$:             cmpb    #2, BikerStatus
                bne     3$
;совсем убираем мотоциклиста
                clrb    BikerStatus
                clr     ADMOTO
MO1:            return

3$:             mov     (PC)+, R4
NMOTO:          .word   0
                mov     (PC)+, R3
ADMOTO:         .word   0
                add     R4, R3
                add     CourseScalar, R3        ; признак отклонения от курса, 0 - нет, >0 - влево, <0 - вправо
                bpl     7$
                add     #300, R3
                br      8$

7$:             cmp     #300, R3
                bhi     8$
                clr     R3
8$:             mov     R3, ADMOTO
                dec     (PC)+
ShowBikerCnt:   .word   0
                bne     9$
2$:             mov     #20, R2
                call    RANDOM
                inc     R0
                mov     R0, ShowBikerCnt
                mov     #3, R2
                call    RANDOM
                sub     #2, R0
                mov     R0, NMOTO
                mov     R0, R4
;рисуем на новом месте
9$:             mov     R3, R2
                cmp     #200, R2
                blos    MO1
                mov     #MOTOCY, R1
                asl     R4
                add     MACN+2(R4), R1
                mov     #HORIZ-200, R0
                mov     #4, R3
                mov     #27, R5

;вход:  R0- базовый адр экрана (SCR)
;       R1- адрес спрайта
;       R2- смещение вывода спрайта по горизонтали (OFS)
;       R3- ширина спрайта
;       R5- высота спрайта
SpriteOut:      clr     SprORC$
                clr     SprOLC$
                add     R2, R0
                sub     #100, R0        ; R0 = [SCR] + [OFS] - 100
                mov     R3, R4          ; ширина спрайта
                add     R2, R3          ; адрес справа от спрайта
                cmp     #100, R3        ; < 100 ?
                bhis    5$              ; да - выход, спрайт за левой границей экрана
                cmp     #200, R3        ; < 200 ?
                bhis    0$              ; да - в пределах экрана, рисуем
                sub     #200, R3        ; иначе - тоже выведем
                br      1$              ; выведем то, что влезает в экран справа

0$:             cmp     #100, R2        ; а адрес вывода спрайта попадает в пределы экрана?
                blos    2$              ; да - рисуем
                mov     #100, R3        ; нет
                sub     R2, R3          ; R3 = 100 - [OFS]
                add     R3, R0          ; R0 = [SCR] + [OFS] - 100 + 100 - [OFS]
                mov     R3, SprOLC$     ; ширина отсекаемой части спрайта слева
1$:             mov     R3, SprORC$     ; ширина отсекаемой части спрайта справа
                sub     R3, R4          ; ширина видимой части спрайта
2$:             mov     #100, R2
                sub     R4, R2          ; смещение для перехода на следующую строку экрана
                add     (PC)+, R1       ; прибавим смещение для отсечения спрайта слева
SprOLC$:        .word   0
SprOL1$:        mov     R4, R3          ; ширина видимой части спрайта
3$:             bisb    (R1)+, (R0)+    ; выводим
                sob     R3, 3$
                add     R2, R0          ; переход на новую строку
                add     (PC)+, R1       ; прибавим смещение для отсечения спрайта, слева или справа
SprORC$:        .word   0
                sob     R5, SprOL1$     ; и так весь спрайт
5$:             return
; три положения вертолёта: летит влево, летит влево, летит вправо
HACN:           .word   0, 0, 132
; три положения мотоциклиста: наклон влево, прямой, наклон вправо
MACN:           .word   0, 134, 270

;полёт пули
DrawBullet:     tst     (PC)+           ; пуля ещё летит?
NPULI:          .word   0
                bne     10$             ; да - продолжим
                call    INKEY           ; нет - стрельнули?
                tst     R3
                beq     11$             ; нет - не стрельнули
                tst     NumAmmo         ; пули остались?
                beq     11$             ; кончились
                dec     NumAmmo         ; стало на одну меньше
                call    SOUND3          ; сделали выстрел
                call    OutAmmo         ; рисуем количество пуль
                mov     #10, NPULI
                clr     L1116
10$:            dec     NPULI
                beq     11$
                mov     NPULI, R0
                mov     CourseScalar, R1    ; признак отклонения от курса, 0 - нет, >0 - влево, <0 - вправо
                asl     R1
                add     R1, (PC)+
L1116:          .word   0
                cmp     #1, R0
                bne     2$
                tstb    L1064
                beq     2$
; взрыв вертолёта
                mov     ADHELI, R2
                mov     L1116, R1
                sub     R2, R1
                add     #140, R1
                bmi     2$
                cmp     R1, #10
                bgt     2$
                call    SOUND2          ; подбили
                incb    L1064
                add     #HORIZ-3000, R2
                mov     #HELEXP, R1
                mov     #11, R0
4$:             bisb    (R1)+, (R2)+
                bisb    (R1)+, (R2)+
                bisb    (R1)+, (R2)+
                bisb    (R1)+, (R2)+
                bisb    (R1)+, (R2)+
                bisb    (R1)+, (R2)+
                bisb    (R1)+, (R2)+
                bisb    (R1)+, (R2)+
                bisb    (R1)+, (R2)+
                bisb    (R1)+, (R2)+
                add     #66, R2
                sob     R0, 4$
                add     #50., CHCKKL
                add     #2, TROFF
                br      09$

11$:            return

2$:             cmp     #3, R0
                bne     5$
                tstb    BikerStatus
                beq     5$
;взрыв мотоцикла
                mov     ADMOTO, R2
                mov     L1116, R1
                sub     R2, R1
                add     #137, R1
                bmi     5$
                cmp     R1, #4
                bgt     5$
                call    SOUND2  ;подбили
                incb    BikerStatus
                add     #HORIZ-200, R2
                mov     #MOTEXP, R1
                mov     #27, R0
6$:             bisb    (R1)+, (R2)+
                bisb    (R1)+, (R2)+
                bisb    (R1)+, (R2)+
                bisb    (R1)+, (R2)+
                add     #74, R2
                sob     R0, 6$
                add     #100., CHCKKL
                inc     TROFF
                mov     #1, NPULI
09$:            jmp     OutTrophy

5$:             mov     #HORIZ+40, R2
                asl     R0      ;
                add     L1122(R0), R2
                add     L1116, R2
                mov     R0, R1  ; R0*24
                asl     R0      ;
                asl     R0      ;
                add     R1, R0  ;
                asl     R0      ;
                add     #AMMUN-24, R0

                mov     #5, R1  ;рисуем пулю
0$:             bisb    (R0)+, (R2)
                bisb    (R0)+, 100(R2)
                add     #200, R2
                sob     R1, 0$
                return

; пары байтов: {регистр AY, значение}
; авария
SOUND4:         jsr     R4, SendToAY
                .byte   0, 252, 1, 17, 4, 361, 5, 11, 6, 5
                .byte   7, 2, 10, 20, 11, 20, 12, 20, 13, 0, 14, 60, 15, 11, 0, 0
;мотор
SOUN11:         mov     R3, R5
                swab    R5
                asr     R5
                asr     R5
                asr     R5
                movb    R5, ParamS11+3
                movb    R5, ParamS11+7
                jsr     R4, SendToAY
ParamS11:       .byte   0, 377, 1, 17, 4, 207, 5, 15, 7, 50, 10, 11, 12, 13, 0, 0

SOUND1:         ;mov     R3, R5
                ;swab    R5
                ;asr     R5
                ;movb    R5, ParamS1+3
                ;movb    R5, ParamS1+7
                jsr     R4, SendToAY
ParamS1:        .byte   0,  17, 1, 17, 4, 133, 5, 17, 7, 50, 10, 13, 12, 11, 0, 0
;подбили
SOUND2:         jsr     R4, SendToAY
                .byte   2, 55, 3, 5, 6, 17, 7, 55, 11, 20, 13, 0, 14, 50, 15, 11, 0, 0
;стрельнули
SOUND3:         jsr     R4, SendToAY
                .byte   2, 0, 3, 0, 6, 12, 7, 57, 11, 20, 13, 0, 14, 30, 15, 11, 0, 0

SendToAY:       mov     (R4)+, R5
                beq     0$
                com     R5
                mov     R5, @#177714
                swab    R5
                movb    R5, @#177714
                br      SendToAY
0$:             mov     (SP)+, R4
                return

InitVarsScreen: mov     #99., NumAmmo       ; количество пуль
                call    InitCourse
                clr     CourseFine
                clr     GameTime
                clr     TROFF
                clr     WAY
                mov     #10, WAYH
                clrb    StopDriveFlag
                clr     L4674
                mov     #58., FUEL          ; количество топлива
                clr     Breaks              ; количество аварий
                clrb    CRRASHH             ; флаг аварии
                mov     #NTreesIncPeriod, NTreesIncCnt
                movb    Class, NumTrees
                add     #40, NumTrees
                call    FadeAY              ; затихаем звук AY
                call    PANEL               ; рисуем приборную панель
                call    L7710
0$:             tst     READY
                beq     0$
                call    INICN
                mov     #T100, @#100
                mov     #5400, @#177662
                return

L7710:          clr     CurrentSpeed
                call    OutInitialVal       ; вывод начальных значений
                clr     PrevArrayTreesSize
;рисуем крышу машины
                mov     #47000, R0
                mov     #4, R2
2$:             mov     #40, R1
3$:             mov     #114631, (R0)+
                mov     #63146, 76(R0)
                sob     R1, 3$
                add     #100, R0
                sob     R2, 2$
                mov     #6300, R2
0$:             clr     (R0)+
                sob     R2, 0$
                mov     #45600, R0
                mov     #StrLevel, R1
                call    OUTS
                movb    Class, R0
                add     #'0, R0
                call    PUTCH
                mov     #45624, R0
                call    OUTS
                br      OutTrophy
; Вывод количества боеприпасов
OutAmmo:        mov     #67260, @#160
                mov     NumAmmo, R4
                br      OUTDC3
; Вывод количества трофеев
OutTrophy:      mov     #45642, @#160
                mov     TROFF, R4
;десятичный вывод 5-значного числа
OUTDC5:         mov     #'0, R0
6560$:          sub     #10000., R4
                bmi     6572$
                inc     R0
                br      6560$
6572$:          add     #10000., R4
                call    PUTCH
;десятичный вывод 4-значного числа
OUTDC4:         mov     #'0, R0
6604$:          sub     #1000., R4
                bmi     6616$
                inc     R0
                br      6604$
6616$:          add     #1000., R4
                call    PUTCH
;десятичный вывод 3-значного числа
OUTDC3:         mov     #'0, R0
6630$:          sub     #100., R4
                bmi     6642$
                inc     R0
                br      6630$
6642$:          add     #100., R4
                call    PUTCH
;десятичный вывод 2-значного числа
OUTDC2:         mov     #'0, R0
6650$:          sub     #10., R4
                bmi     6662$
                inc     R0
                br      6650$
6662$:          add     #10., R4
                call    PUTCH
;десятичный вывод 1-значного числа
                mov     #'0, R0
                add     R4, R0
                jmp     PUTCH

OutInfoGetInfo: mov     #22, @#177712
                call    OutBrifing          ; вывод инфо
                mov     #75400, R2
                mov     #StrYurClass, R1    ; спрашиваем класс
                call    PUTS
4$:             call    INPUT
                cmp     R0, #'0
                blo     4$
                cmp     R0, #'5
                bhi     4$
                call    PUTCH
                sub     #'0, R0
                movb    R0, (PC)+
Class:          .word   0
                mov     @#177710, RND
                clr     @#177712
CLRSCR:         mov     #40000, R0
0$:             clr     (R0)+
                tst     R0
                bpl     0$
                return


;вывод курса
OutCourse:      mov     Course, R1
                bmi     001$
                cmp     #120, R1
                blos    001$
                mov     #72626, R0
                br      SHKALA
;инициализация курса
InitCourse:     mov     #50, Course
001$:           return
;вывод начальных значений
OutInitialVal:  call    OutCourse   ; вывод курса
                call    OutAmmo      ; вывод пуль
OUTSPD:         mov     #67026, R0  ; вывод скорости
                mov     CurrentSpeed, R1
                bpl     0$
                clr     R1
0$:             swab    R1
;рисуем шкалу
SHKALA:         mov     R0, R2      ; адрес угла шкалы
                mov     #10, R4
1$:             clr     (R2)+
                clr     (R2)+
                clr     (R2)+
                clr     (R2)+
                clr     (R2)+
                clr     (R2)+
                clr     (R2)+
                clr     (R2)+
                clr     (R2)+
                clr     (R2)+
                add     #54, R2
                sob     R4, 1$
                asr     R1          ; значение
                rol     R4
                asr     R1
                rol     R4
                add     R1, R0
                movb    ScaleInd(R4), R4
                mov     #100, R2
                mov     #4, R3
2$:             movb    R4, (R0)
                add     R2, R0
                movb    R4, (R0)
                add     R2, R0
                sob     R3, 2$
                return


;плохой конец
YOUFOL:         mov     #40000, R2
                mov     #StrBadEnd, R1
                br      102$
;доехали до конца и вывод премии
HAPEND:         mov     #40000, R2
                mov     Course, R0
                sub     #50, R0
                bpl     2$
                neg     R0
2$:             cmp     R0, #30
                blo     3$
                mov     #StrDeadEnd, R1
102$:           call    PUTS
                br      100$

3$:             mov     #StrGoodEnd, R1
                call    PUTS
                mov     #1000., R4
                mov     #100., R2
                mov     NumAmmo, R0
                bmi     4$
                sub     R0, R2
4$:             asl     R2
                mov     R2, R0
                asl     R2
                asl     R2
                sub     R2, R4
                sub     R0, R4
                mov     FUEL, R2
                swab    R2 ;
                asr     R2 ;R2 * 100
                asr     R2 ;
                add     R2, R4
                add     CHCKKL, R4
                mov     Breaks, R2
                beq     1$
0$:             asr     R4
                sob     R2, 0$
1$:             call    OUTDC5 ;десятичный вывод
;жмём any key и начнём сначала
100$:           call    INPUT
                mov     #2, R0
                clr     R1
101$:           sob     R1, .
                sob     R0, 101$
                inc     NumAmmo
                jmp     InitGame

; обработка клавиатуры и джойстика
; Выход: R1 - флаг: -1 - газ, 1 - тормоз, 0 - нет
;        R3 - флаг: 1 - стрельба, 0 - нет
;        R4 - флаг: -1 - влево, 1 - вправо, 0 - никуда
INKEY:          clr     R3                  ; флаг стрельбы
                clr     R4                  ; флаг движения влево/вправо
                clr     R1                  ; флаг газа/тормоза
                bit     #100, @#177716      ; клавиша нажата?
                bne     0joy$               ; нет, пойдём проверим джойстик
                mov     @#177662, R0        ; что нажали?
                cmp     #3, R0              ; КТ ?
                bne     0$                  ; нет
                jmp     InitGame            ; да - начнём сначала

0$:             cmp     #10, R0             ; влево?
                bne     1$                  ; нет
                inc     CourseScalar        ; да - увеличиваем признак отклонения
                dec     R4                  ; флаг движения влево
                br      5$

1$:             cmp     #31, R0             ; вправо?
                bne     2$                  ; нет
                dec     CourseScalar        ; да - уменьшаем признак отклонения
                inc     R4                  ; флаг движения вправо
                br      5$

2$:             cmp     #33, R0             ; тормоз?
                bne     3$                  ; нет
                inc     R1                  ; флаг торможения
                br      5$

3$:             cmp     #32, R0             ; газ?
                bne     4$                  ; нет
                dec     R1                  ; флаг газования
                br      5$

4$:             cmp     #40, R0             ; пробел?
                bne     0joy$               ; нет
                inc     R3                  ; флаг стрельбы
                br      5$

0joy$:          mov     @#177714, R0
                beq     5$
                bit     LEFT, R0
                beq     21$
                inc     CourseScalar        ; да - увеличиваем признак отклонения
                dec     R4                  ; флаг движения влево
21$:            bit     RIGHT, R0
                beq     22$
                dec     CourseScalar        ; да - уменьшаем признак отклонения
                inc     R4                  ; флаг движения вправо
22$:            bit     TORM, R0
                beq     23$
                inc     R1                  ; флаг торможения
23$:            bit     GAZ, R0
                beq     24$
                dec     R1                  ; флаг газования
24$:            bit     FIRE, R0
                beq     5$
                inc     R3                  ; флаг стрельбы
5$:             mov     R3, VR3
                mov     R4, VR4
                return
LEFT:           .word   0
RIGHT:          .word   0
GAZ:            .word   0
TORM:           .word   0
FIRE:           .word   0

T100:           mov     R0, -(SP)
                mov     R1, -(SP)
                mov     R2, -(SP)
                mov     R3, -(SP)
                mov     R4, -(SP)
                call    CLOCK
                tst     (PC)+       ; патроны есть?
NumAmmo:        .word   0           ;
                bgt     39$         ; да, есть ещё
                dec     (PC)+       ; кончились,
DPI:            .word   0
                bgt     39$         ; пора?
                mov     #12, DPI    ; да, мигаем
                mov     #66766, R1
                mov     #10, R2
40$:            com     100(R1)     ; это индикация что
                com     (R1)+       ; пули кончились
                com     100(R1)
                com     (R1)+
                add     #174, R1
                sob     R2, 40$
39$:            mov     #74, R4
                mov     #75636, R1
                mov     #4, R2
                tstb    (PC)+
VR3:            .word   0
                bne     10$
                ;стираем fire
22$:            clr     (R1)+
                clr     (R1)+
                add     R4, R1
                clr     (R1)+
                clr     (R1)+
                add     R4, R1
                sob     R2, 22$
                br      20$
                ;рисуем fire
10$:            mov     #BUTTON, R3
12$:            mov     (R3)+, (R1)+
                mov     (R3)+, (R1)+
                add     R4, R1
                mov     (R3)+, (R1)+
                mov     (R3)+, (R1)+
                add     R4, R1
                sob     R2, 12$
20$:            mov     #10, R2
                tstb    (PC)+
VR4:            .word   0
                beq     01$
                bmi     11$
                ;рисуем right, стираем left
                mov     #BUTTON+40, R3
                mov     #75644, R1
                mov     #75630, R0
                br      1$
11$:            ;рисуем left, стираем right
                mov     #BUTTON+100, R3
                mov     #75630, R1
                mov     #75644, R0
1$:             mov     (R3)+, (R1)+
                mov     (R3)+, (R1)+
                add     R4, R1
                clr     (R0)+
                clr     (R0)+
                add     R4, R0
                sob     R2, 1$
                br      21$
01$:            ;стираем right, стираем left
                mov     #75630, R0
                mov     #75644, R1
2$:             clr     (R0)+
                clr     (R0)+
                add     R4, R0
                clr     (R1)+
                clr     (R1)+
                add     R4, R1
                sob     R2, 2$
21$:            mov     (SP)+, R4
                mov     (SP)+, R3
                mov     (SP)+, R2
                mov     (SP)+, R1
                mov     (SP)+, R0
NoIrq:          rti

CLOCK:          mov     #73110, R0
                dec     TAKT
                beq     2$              ; не 0 - ещё не время
                cmp     (PC)+, (PC)+    ; прошло пол такта
TAKT:           .word   0, 25.
                beq     1$              ; да - отметим
                mov     (SP)+, PC

2$:             mov     #50., TAKT      ; сделаем обратно
                inc     (PC)+
GameTime:       .word   0
                mov     #MINSEC+6, R1   ; и идём выводить время
                mov     #10., R4
                call    ADDSEC          ; +1 секунда
                mov     #MINSEC, R1
                mov     #100, R4
                call    SPRITE
                inc     R0
                call    SPRITE
                inc     R0
                call    SPRITE
                sub     #10, R0
1$:             mov     #60, R1
                xor     R1, 202(R0)
                xor     R1, 502(R0)
                mov     (SP)+, PC
;вход:  R0 - адрес экрана
;       R1 - адрес времени
SPRITE:         mov     PC, -(SP)
                movb    (R1)+, R3 ;цифра
                asl     R3
                asl     R3
                asl     R3
                add     #Digits8, R3    ;используем свой шрифт
                mov     #4, R2
0$:             movb    (R3)+, (R0)
                add     R4, R0
                movb    (R3)+, (R0)
                add     R4, R0
                sob     R2, 0$
                sub     #777, R0
                mov     (SP)+, PC

ADDSEC:         incb    -(R1)       ; единицы секунд
                cmpb    (R1), R4
                blo     0EXIT
                clrb    (R1)
                incb    -(R1)       ; десятки секунд
                cmpb    (R1), #6
                blo     0EXIT
                clrb    (R1)
                incb    -(R1)       ; единицы минут
                cmpb    (R1), R4
                blo     0EXIT
                clrb    (R1)
                incb    -(R1)       ; десятки минут
                cmpb    (R1), #6
                blo     0EXIT
                clrb    (R1)
                incb    -(R1)       ; единицы часов
                cmp     (R1), (PC)+
                .byte   2, 4
                bne     0$
                clr     (R1)
                mov     (SP)+, PC

0$:             cmpb    (R1), R4
                blo     0EXIT
                clrb    (R1)
                incb    -(R1)       ; десятки часов
0EXIT:          mov     (SP)+, PC

INICN:          mov     #CO, R1
                mov     #7, (R1)            ; инициализируем параметры
                mov     (R1)+, (R1)
                mov     (R1)+, (R1)
                mov     (R1)+, (R1)
                mov     (R1)+, (R1)+
                mov     #AD0, (R1)          ; инициализируем спрайты
                mov     (R1)+, (R1)
                mov     (R1)+, (R1)
                mov     (R1)+, (R1)
                mov     (R1)+, (R1)
                mov     #8., R0
0$:             call    COUNT
                sob     R0, 0$
                return

COUNT:          mov     #67316, R5  ; адрес экрана
                mov     #CO, R4     ; адрес параметров
                mov     #COS, R3    ; адрес таблицы спрайтов
                mov     R4, R2      ; адрес параметра ст.байта
REP:            inc     R2
                tstb    (R2)+       ; смотрим значение
                bne     0$          ; не 0, выходим из цикла
                cmp     R2, R3      ; дошли до конца?
                bhis    0$          ; да. выходим из цикла
                call    REP         ; нет - рекурсия
0$:             decb    (R4)+       ; уменьшаем счётчик строк по высоте
                bpl     1$          ; пока в пределах спрайта, просто выводим текущую цифру
                movb    #7, -1(R4)  ; инициализируем счётчик
                decb    (R4)        ; уменьшаем значение
                bpl     1$          ; переход. пока в пределах
                movb    #9., (R4)   ; инициализируем значение
                sub     #240, (R3)  ; меняем спрайт с AD0 на AD1
                                    ; причём рано меняем, сперва надо сдвинуть 
                                    ; и вывести последнюю строку цифры, и только потом вычитать
                                    ; но пусть лучше будет так, и добавим 1 слово чем менять алгоритм
1$:             inc     R4          ; к следующему значению

                mov     #100, R2    ; сдвигаем цифру вверх
                mov     100(R5), (R5)
                add     R2, R5
                mov     100(R5), (R5)
                add     R2, R5
                mov     100(R5), (R5)
                add     R2, R5
                mov     100(R5), (R5)
                add     R2, R5
                mov     100(R5), (R5)
                add     R2, R5
                mov     100(R5), (R5)
                add     R2, R5
                mov     100(R5), (R5)
                add     R2, R5
                mov     (R3), R2    ; с низу рисуем новую цифру
                mov     (R2)+, (R5)
                mov     R2, (R3)+
                sub     #702, R5

                mov     (SP)+, PC

CO:             .blkb   10. ;тут находятся параметры спрайтов цифр {n, значение}
COS:            .blkw   5   ;тут находятся адреса спрайтов цифр, должно быть сразу за CO
                .word   0   ; указатели на спрайты все сдвинуты вверх на 1 слово, поэтому этот 0 нужен.
;спрайты цифр шириной слово высотой 8 точек
AD1:            .word   0, 1700, 1760, 1400, 1400, 1400, 37760, 0
AD2:            .word   0, 7760, 30014, 30000, 7760, 14, 37774, 0
AD3:            .word   0, 7760, 30014, 7700, 30000, 30014, 7760, 0
AD4:            .word   0, 60, 60, 6014, 6014, 37774, 6000, 0
AD5:            .word   0, 37774, 14, 7774, 30000, 30014, 7760, 0
AD6:            .word   0, 7760, 14, 7774, 30014, 30014, 7760, 0
AD7:            .word   0, 37774, 30000, 6000, 6000, 1400, 1400, 0
AD8:            .word   0, 7760, 30014, 7760, 30014, 30014, 7760, 0
AD9:            .word   0, 7760, 30014, 30014, 37760, 30000, 7760, 0
AD0:            .word   0, 7760, 30014, 30014, 30014, 30014, 7760, 0

;спрайты цифр шириной байт высотой 8 точек
Digits8:        .byte   060, 314, 314, 314, 314, 314, 314, 060  ;0
                .byte   060, 074, 060, 060, 060, 060, 060, 374  ;1
                .byte   060, 314, 300, 300, 060, 014, 014, 374  ;2
                .byte   074, 300, 300, 060, 300, 300, 314, 060  ;3
                .byte   300, 360, 314, 314, 374, 300, 300, 300  ;4
                .byte   374, 014, 014, 074, 300, 300, 300, 074  ;5
                .byte   360, 014, 014, 074, 314, 314, 314, 060  ;6
                .byte   374, 300, 300, 300, 060, 060, 014, 014  ;7
                .byte   060, 314, 314, 060, 314, 314, 314, 060  ;8
                .byte   060, 314, 314, 314, 360, 300, 300, 074  ;9

OUTS:           mov     R0, @#160
1$:             movb    (R1)+, R0
                beq     0$
                call    PUTCH
                br      1$
0$:             return

;вывод строки
;вход:  R2 - адрес экрана
;       R1 - адрес начала строки, первый байт - количество выводимых строк
PUTS:           movb    (R1)+, -(SP)
                mov     R2, -(SP)
                mov     #2, OFFS
                mov     #-1, R4
                clr     R5
                mov     #4, -(SP)
00$:            call    DCUXOR
                mov     #40000, R0
                sob     R0, .
                dec     (SP)
                bne     00$
                clr     (SP)+
                br      8$

7$:             mov     R2, -(SP)
8$:             call    CURXOR
3$:             movb    (R1)+, R0
                beq     0EX$
                mov     #SYMB, R3
                mov     R3, @#160
                call    PUTCH
                mov     R1, -(SP)
                mov     #16., R1
2$:             mov     R2, R0
                mov     R1, -(SP)
                mov     #12, R1
                asl     R4
                rol     R5
1$:             asl     (R3)+
                rol     (R0)+
                rol     (R0)+
                add     #74, R0
                sob     R1, 1$

                dec     DELAY
                bne     4$
                call    DCUXOR
4$:             sub     #24, R3
                mov     (SP)+, R1
                sob     R1, 2$

                tst     (R2)+
                mov     R2, @#160
                mov     (SP)+, R1
                mov     R5, R4
                clr     R5
                br      3$

0EX$:           tst     (R2)
                beq     5$
                call    DCUXOR
5$:             mov     (SP)+, R2
                add     #1200, R2
                decb    (SP)
                bne     7$
                clr     (SP)+
                mov     #100, OFFS
                return
;вход:  R2 - адрес экрана
;       R4:R5 - текущая маска
DCUXOR:         mov     #230, (PC)+
DELAY:          .word   0
CURXOR:         mov     R2, -(SP)
                mov     R3, -(SP)
                mov     #12, R3
5$:             xor     R4, (R2)+
                xor     R5, (R2)+
                add     #74, R2
                sob     R3, 5$
                mov     (SP)+, R3
                mov     (SP)+, R2
                return
SYMB:           .blkw   12  ;буфер, где формируется символ

;выводим в режиме 32
;вход: R0 - код символа
;по адресу 160 - адрес вывода на экран
PUTCH:          jsr     R4, @#110346
                bic     #177400, R0
                bit     #140, R0
                beq     01$
                tstb    R0
                bpl     02$
                sub     #40, R0
02$:            asl     R0
                mov     R0, R1
                asl     R0
                asl     R0
                add     R0, R1
                add     #111576, R1
                mov     @#160, R3
                mov     R5, -(SP)
                mov     #12, R2
P0:             clr     R0
                bisb    (R1), R0
                mov     #10, R5
                bic     #252, R0
                mov     R0, R4
                asr     R0
                asl     R4
                bis     R0, R4
                bic     R5, R4
                bisb    (R1)+, R4
1$:             asr     R4
                ror     R0
                asr     R0
                sob     R5, 1$
                mov     R0, (R3)
                add     (PC)+, R3
OFFS:           .word   100
                sob     R2, P0
                mov     (SP)+, R5
                add     #2, @#160
01$:            jsr     R4, @#110362
                return

OutBrifing:     mov     #60, R5
                mov     (R5), -(SP)         ; содержимое вектора сохраним
                mov     SP, ADSP
                mov     #KT, (R5)           ; зададим своё
                mov     (R5), @#274
                tst     @#177662
                clr     @#177660            ; разрешим прерывания от клавиатуры
                mov     #40000, R2
                mov     #StrMission, R1     ; выведем игровое задание
                call    PUTS
                mov     #100, @#177660      ; запретим прерывания от клавиатуры
                mov     ADSP, SP
                mov     (SP)+, @#60         ; восстановим вектор прерываний от клавиатуры
                mov     @#60, @#274
                call    INPUT
                cmp     R0, #23             ; ВС - вечная жизнь!
                bne     011$
                bis     #700, REPFUE
                bis     #700, REPBRK
                bic     #177000, REPTIM
                br      010$

011$:           cmp     R0, #30             ; забой - отмена вечной жизни
                bne     012$
                bic     #400, REPFUE
                bic     #500, REPBRK
                bis     #103000, REPTIM
                br      010$

012$:           cmp     R0, #'J             ; заново перепрограммировать джойстик
                bne     010$
                clr     JOYFLG
                br      010$

KT:             mov     (PC)+, SP
ADSP:           .word   0
                tst     @#177662
                mov     #100, @#177660
                mov     (SP)+, @#60
                mov     @#60, @#274
010$:           call    CLRSCR
                call    SETJOY
                return

INPUT:          bit     #100, @#177716
                beq     INPUT
                clr     R5
                mov     #-1, R4
                mov     @#160, R2
5$:             mov     #14000, R3
                call    CURXOR
1$:             bit     #100, @#177716
                beq     0$
                sob     R3, 1$
                mov     #14000, R3
                call    CURXOR
3$:             bit     #100, @#177716
                beq     2$
                sob     R3, 3$
                br      5$

0$:             call    CURXOR
2$:             mov     @#177662, R0
                cmp     #100, R0
                bhi     4$
                bic     #40, R0
4$:             return

SETJOY:         tst     (PC)+
JOYFLG:         .word   0
                bne     6$
                mov     #50200, R2
                mov     #StrQuestJoy, R1
                call    PUTS
                call    INPUT
00$:            cmpb    (PC)+, R0       ; D, Y, ввод, пробел - утвердительный ответ
                .byte   'D, 'Y          ; на программирование джойстика
                beq     0$
                cmpb    (PC)+, R0
                .byte   12, 40
                beq     0$
                inc     PC
                br      00$

                mov     @#160, R2
                mov     #StrNo, R1
                call    PUTS
                sob     R4, .
6$:             return

0$:             dec     PC
                com     JOYFLG
                mov     @#160, R2
                mov     #StrYes, R1
                call    PUTS
                mov     #52600, R2
                mov     #StrSetControl, R1
                call    PUTS

                mov     #54000, R2
                mov     #TABLE, R3
5$:             mov     (R3)+, R1
                beq     6$
                mov     R2, -(SP)
                mov     R3, -(SP)
                call    PUTS
                mov     #40, R0
2$:             mov     @#177714, R1
                beq     2$
                mov     #6000, R2
                sob     R2, .
                sob     R0, 2$
                mov     (SP), R3
                mov     R1, @(R3)+
                mov     R3, (SP)
                mov     @#160, R2
                mov     #StrAccept, R1
                call    PUTS
                mov     (SP)+, R3
                mov     (SP)+, R2
                add     #1200, R2
                br      5$


TABLE:          .word   StrToLeft, LEFT, StrToRight, RIGHT, StrToSpeedup, GAZ
                .word   StrToSlow, TORM, StrToFire, FIRE, 0

StrYurClass:    .asciz  <1>"          Ваш класс: "

StrGoodEnd:     .asciz  <2>" За удачное выполнение операции"
                .asciz  "вы получили премию - $"
StrBadEnd:      .asciz  <2>"  С такими способностями вам"
                .asciz  "  лучше ездить на извозчике."
StrDeadEnd:     .asciz  <2>"Вы отклонились от курса и попа-"
                .asciz  "ли прямо в логово преступников."

StrLevel:       .asciz  "Класс: "<0>"Трупов:"
StrQuestJoy:    .asciz  <1>" Джойстик программировать? "
StrYes:         .asciz  <1>"Да"
StrNo:          .asciz  <1>"Нет"
StrAccept:      .asciz  <1>"Принято"
StrSetControl:  .asciz  <1>"     Задавайте управление:"
StrToLeft:      .asciz  <1>"        Влево.... "
StrToRight:     .asciz  <1>"        Вправо... "
StrToSpeedup:   .asciz  <1>"        Газ...... "
StrToSlow:      .asciz  <1>"        Тормоз... "
StrToFire:      .asciz  <1>"        Стрелять. "

StrMission:     .byte   22. ; количество выводимых строк
                .asciz  " Задание патрульной машине N13:"
                .byte   0
                .asciz  "   Комиссар Джексон. Ваша зада-"
                .asciz  "ча ─ прибыть в пункт назначения"
                .asciz  "Z-12, находящийся на расстоянии"
                .asciz  "500 МегаКилоМетров по курсу ва-"
                .asciz  "шего следования, за 6.00 минут."
                .asciz  "По пути вам необходимо обезвре-"
                .asciz  "дить банду  опасных  преступни-"
                .asciz  "ков, скрывающихся на вертолетах"
                .asciz  "и мотоциклах  в  лесистой  мес-"
                .asciz  "тности. Машина может  выдержать"
                .asciz  "не более пяти аварий,  так  что"
                .asciz  "не стоит  увлекаться  сшибанием"
                .asciz  "деревьев. Выполняйте!"
                .byte   0, 0
                .asciz  "  Управление: вправо - →"
                .asciz  "               влево - ←"
                .asciz  "                 газ - ↑"
                .asciz  "              тормоз - ↓"
                .asciz  "            стрельба - пробел"
                .even

;перехватчик вектора 4
HLT4:           mov     #45400, @#177662
                mov     #16000, @#177716
                reset
                jmp     @#100000

FadeAY:         clr     (PC)+
READY:          .word   0
                mov     #DMPF, @#100
                return
;плавное затухание последнего звука
DMPF:           dec     (PC)+
DELAYD:         .word   1
                bne     0NORDY
                mov     #10, DELAYD
                mov     R0, -(SP)
                mov     R1, -(SP)
                mov     R2, -(SP)
                mov     #PORTS, R1
                mov     #VALUES, R2
                cmp     (PC)+, (PC)+
LOOPS:          .word   20
                .word   20
                bne     0NEXT
                movb    @#MUSIC+3000, R0
                call    S1
                movb    R0, (R2)+
                movb    @#MUSIC+3001, R0
                call    S1
                movb    R0, (R2)+
                movb    @#MUSIC+3002, R0
                call    S1
                movb    R0, (R2)
                tst     -(R2)
0NEXT:          mov     #177714, R0

                mov     (R1)+, (R0)
                movb    (R2)+, (R0)
                mov     (R1)+, (R0)
                movb    (R2)+, (R0)
                mov     (R1)+, (R0)
                movb    (R2)+, (R0)
                call    S2
                dec     LOOPS
                bgt     3$
                mov     LOOPS+2, LOOPS
                mov     #-1, R2
                mov     -(R1), (R0)
                movb    R2, (R0)
                mov     -(R1), (R0)
                movb    R2, (R0)
                mov     -(R1), (R0)
                movb    R2, (R0)
                mov     #45400, @#177662
                mov     (PC), READY
3$:             mov     (SP)+, R2
                mov     (SP)+, R1
                mov     (SP)+, R0
0NORDY:         rti
PORTS:          .word   367, 366, 365
VALUES:         .byte   0, 0, 0, 0

S1:             bitb    #20, R0
                beq     0$
                bisb    #17, R0
0$:             com     R0
                return

S2:             call    S3
                mov     PC, -(SP)
S3:             incb    -(R2)
                bne     2$
                decb    (R2)
2$:             return

                .end

