home *** CD-ROM | disk | FTP | other *** search
/ ticalc.org / ticalc_org_rev_b.iso / archives / 83 / asm / source / ski.z80 < prev    next >
Encoding:
Text File  |  2001-07-01  |  25.6 KB  |  990 lines
  1. .NOLIST
  2. #define equ .equ
  3. #define EQU .equ
  4. #define end .end
  5. #include "ti83asm.inc"
  6. #include "tokens.inc"
  7. .LIST
  8.  
  9. ; variables
  10.  
  11. #define temp 8265h                ; temporary
  12. #define levelname 8266h           ; name of current level
  13. #define level 826Ah               ; pointer to symbol table entry of current level
  14. #define row 826Ch                 ; level offset
  15. #define col 826Eh                 ; skier position
  16. #define score 826Fh               ; score
  17. #define flakes 8271h              ; begining of snowflake x's and y's
  18.  
  19. ; direct input key equates
  20.  
  21. kLeft .equ 253
  22. kRight .equ 251
  23. kMode .equ 191
  24. kClear .equ 191
  25.  
  26. ; program and list object type equates
  27.  
  28. progobj .equ 05h                  ; program
  29. protprogobj .equ 06h              ; protected program
  30. listobj .equ 01h                  ; list
  31. clistobj .equ 0Dh                 ; complex list
  32.  
  33. lcddata .equ 11h                  ; lcd data port
  34.  
  35. .org 9327h
  36.  
  37. init:
  38.  
  39.      call _runindicoff
  40.      call load                    ; load y coords of snow flakes
  41.  
  42. look_up_level:
  43.  
  44.      ld a,0                       ; temp holds the number of levels
  45.      ld (temp),a                  ; if temp is 0 at the end there aren't any levels
  46.      ld hl,(progptr)              ; start of program/list symbol table
  47.  
  48. level_loop:
  49.  
  50.      ld a,(hl)                    ; get object type
  51.      and $1F                      ; mask off bits 5-7
  52.      cp progobj                   ; is it a program?
  53.      jr z,program                 ;
  54.      cp protprogobj               ; is it a protected program?
  55.      jr z,program                 ;
  56.      cp listobj                   ; is it a list?
  57.      jp z,list                    ;
  58.      cp clistobj                  ; is it a complex list?
  59.      jp z,list                    ;
  60.      ld a,(temp)                  ; see if count is zero
  61.      cp 0                         ;
  62.      ret z                        ;
  63.      jr look_up_level             ; end of program/list symbol table. start over
  64.  
  65. program:
  66.  
  67.      dec hl                       ; skip T
  68.      dec hl                       ; skip DAL
  69.      dec hl                       ; skip DAH
  70.      ld b,(hl)                    ; get length of name
  71.      ld a,b                       ;
  72.      cp 8                         ; is the name 8 chars long?
  73.      jr z,good_prog               ; if it is then it could be a valid level
  74.  
  75. program_loop:
  76.  
  77.      dec hl                       ; get past name
  78.      djnz program_loop            ; 
  79.      dec hl                       ; next pointer
  80.      jr level_loop                ;
  81.  
  82. good_prog:
  83.  
  84.      ld (level),hl                ; save program address
  85.      ld b,5                       ; five chars to test
  86.      ld de,defaultprog            ; name to test against
  87.  
  88. cploop:
  89.  
  90.      dec hl                       ; compare name to base name
  91.      ld a,(de)                    ;
  92.      cp (hl)                      ; are they the same?
  93.      jp nz,nextprog               ; if not move on to the next program
  94.      inc de                       ;
  95.      djnz cploop                  ;
  96.      ld de,levelname              ;
  97.      ld b,3                       ;
  98.  
  99. cpyloop:
  100.  
  101.      dec hl                       ; copy last 3 chars of name
  102.      ld a,(hl)                    ;
  103.      ld (de),a                    ;
  104.      inc de                       ;
  105.      djnz cpyloop                 ;
  106.      ld a,0                       ; add 0 terminator
  107.      ld (de),a                    ;
  108.  
  109.      ld a,(temp)                  ; increment count
  110.      inc a                        ;
  111.      ld (temp),a                  ;
  112.  
  113. snow:
  114.  
  115.      call _grbufclr               ; clear buffer
  116.      ld hl,title                  ; copy title pic
  117.      ld de,plotsscreen+60         ;
  118.      ld bc,300                    ;
  119.      ldir                         ;
  120.      set textwrite,(iy+sgrflags)  ; write to buffer
  121.      ld hl,$221E                  ; write "By Ian Graf"
  122.      ld (pencol),hl               ;
  123.      ld hl,creatorstr             ;
  124.      call _vputs                  ;
  125.      ld hl,$2D2A                  ; write level name
  126.      ld (pencol),hl               ;
  127.      ld hl,levelname              ;
  128.      call _vputs                  ;
  129.      ld hl,$3422                  ; write "High"
  130.      ld (pencol),hl               ;
  131.      ld hl,highstr                ;
  132.      call _vputs                  ;
  133.      ld hl,$3432                  ; write high score
  134.      ld (pencol),hl               ;
  135.      call getscore                ;
  136.      call _setxxxxop2             ;
  137.      call _op1exop2               ;
  138.      ld a,3                       ;
  139.      call _dispop1a               ;
  140.      res textwrite,(iy+sgrflags)  ; write to display
  141.  
  142.      ld hl,flakes                 ; draw out snow flakes
  143.      ld b,15                      ;
  144.  
  145. snow_loop:
  146.  
  147.      call set_flake_y             ; move flake down
  148.      call set_flake_x             ; move flake across
  149.      ld a,(hl)                    ; get x
  150.      inc hl                       ; get y
  151.      ld e,(hl)                    ;
  152.      inc hl                       ;
  153.      push hl                      ;
  154.      push bc                      ;
  155.      ld hl,flake                  ; flake image
  156.      push af                      ;
  157.      ld a,e                       ; draw flake if it is on screen
  158.      cp 0                         ;
  159.      pop af                       ;
  160.      call p,drwspr                ;
  161.      pop bc                       ;
  162.      pop hl                       ;
  163.      djnz snow_loop               ;
  164.      call bufcpy                  ; redraw screen
  165.      call _getk                   ;
  166.      ld a,21                      ; was 2nd pressed?
  167.      call _setxxop1               ;
  168.      call _cpop1op2               ;
  169.      jr z,game_start              ; start game
  170.      ld a,31                      ; was Alpha pressed?
  171.      call _setxxop1               ;
  172.      call _cpop1op2               ;
  173.      jr z,nextprog                ; next level
  174.      ld a,45                      ; was Clear pressed?
  175.      call _setxxop1               ;
  176.      call _cpop1op2               ;
  177.      jr z,quit                    ; quit
  178.      jp snow
  179.  
  180. nextprog:
  181.  
  182.      ld hl,(level)                ; restore program address
  183.      ld b,8                       ; 8 chars in name
  184.      jp program_loop              ; next pointer
  185.  
  186. list:
  187.  
  188.      dec hl                       ; skip T
  189.      dec hl                       ; skip DAL
  190.      dec hl                       ; skip DAH
  191.      ld b,(hl)                    ; get length
  192.  
  193. list_loop:
  194.  
  195.      dec hl                       ; skip over name
  196.      djnz list_loop               ; 
  197.      dec hl                       ; next pointer
  198.      jp level_loop                ;
  199.  
  200. set_flake_y:
  201.  
  202.      inc hl                       ; get flake y
  203.      ld a,(hl)                    ; is it at the bottom
  204.      cp 61                        ;
  205.      jr z,flakeup                 ; move it to the top
  206.      inc a                        ; move it down
  207.      ld (hl),a                    ;
  208.      dec hl                       ;
  209.      ret
  210.  
  211. flakeup:
  212.  
  213.      ld a,0                       ; move flake to the top
  214.      ld (hl),a                    ;
  215.      dec hl                       ;
  216.      ret
  217.  
  218. set_flake_x:
  219.  
  220.      inc hl                       ; get flake y
  221.      ld a,(hl)                    ;
  222.      cp 0                         ; is it 0
  223.      dec hl                       ;
  224.      ret nz                       ; don't chang x then
  225.      call rand                    ; get random number
  226.      ld (hl),a                    ;
  227.      ret
  228.  
  229. ; my own random routine to generate a number between 0 and 88
  230. ; i used it because it is fast and small
  231.  
  232. rand:
  233.  
  234.      ld a,r
  235.      and %01111111
  236.      cp 110
  237.      jr nc,rand
  238.      cp 17
  239.      jr c,rand
  240.      sub 18
  241.      ret
  242.  
  243. load:
  244.  
  245.      ld hl,flakes                 ; load offscreen coords into flake y's
  246.      ld a,-1                      ;
  247.      ld b,15                      ;
  248.  
  249. load_loop:
  250.  
  251.      inc hl                       ;
  252.      ld (hl),a                    ;
  253.      sub 4                        ;
  254.      inc hl                       ;
  255.      djnz load_loop               ;
  256.      ret
  257.  
  258. ; when someone quits at the title screen
  259.  
  260. quit:
  261.  
  262.      call _clrlcdfull             ; clear screen
  263.      call _clrtxtshd              ; clear text shadow
  264.      call _homeup                 ; place cursor at top
  265.      ret
  266.  
  267. ; rest of the game
  268.  
  269. game_start:
  270.  
  271.      ld hl,0                      ; reset score
  272.      ld (score),hl                ;
  273.      ld hl,(level)                ; restore address to level
  274.      inc hl                       ; move to DAL
  275.      ld d,(hl)                    ; copy data address to de
  276.      inc hl                       ;
  277.      ld e,(hl)                    ;
  278.      ld hl,4                      ;
  279.      add hl,de                    ;
  280.      ld (row),hl                  ; store level offset
  281.      ld a,5                       ; position skier
  282.      ld (col),a                   ;
  283.      ld b,250                     ; loop 250 times
  284.  
  285. scroll_loop:
  286.  
  287.      push bc
  288.  
  289.      ld a,$FF                     ; reset key port
  290.      out (1),a                    ;
  291.      ld a,$FE                     ; enable arrow pad
  292.      out (1),a                    ;
  293.      in a,(1)                     ;
  294.      cp kRight                    ; check for right arrow
  295.      call z,move_right            ; move skier right
  296.      cp kLeft                     ; check for left arrow
  297.      call z,move_left             ; move skier left
  298.  
  299.      ld a,$FF                     ; reset key port
  300.      out (1),a                    ;
  301.      ld a,$FD                     ; enable row with clear
  302.      out (1),a                    ;
  303.      in a,(1)                     ;
  304.      cp kClear                    ; check Clear
  305.      jp z,skiquit                 ; move skier right
  306.  
  307.      ld a,$FF                     ; reset key port
  308.      out (1),a                    ;
  309.      ld a,$BF                     ; enable row with mode
  310.      out (1),a                    ;
  311.      in a,(1)                     ;
  312.      cp kMode                     ; check Mode
  313.      call z,pause                 ; move skier right
  314.  
  315.      call _grbufclr               ; clear buffer
  316.      call drawlevel               ; draw level
  317.      call drawskier               ; draw skier
  318.      call bufcpy                  ; copy to screen
  319.      call getitem                 ; get the item at the skier's position
  320.      cp 0                         ; check for collision
  321.      jp nz,hit                    ;
  322.      call delay                   ; delay for a little bit
  323.  
  324.      ld hl,(row)                  ; move to next row in level
  325.      ld de,6                      ;
  326.      add hl,de                    ;
  327.      ld (row),hl                  ;
  328.  
  329.      ld hl,(score)                ; increment score
  330.      inc hl                       ;
  331.      inc hl                       ;
  332.      ld (score),hl                ;
  333.  
  334.      pop bc                       ; reloop
  335.      djnz scroll_loop             ;
  336.  
  337. done:
  338.  
  339.      call load                    ; reset flakes
  340.      call _grbufclr               ; clear buffer
  341.      ld hl,title                  ; draw title
  342.      ld de,plotsscreen+60         ;
  343.      ld bc,300                    ;
  344.      ldir                         ;
  345.      call bufcpy                  ; copy to screen
  346.      ld hl,$0305                  ; write "Score:"
  347.      ld (currow),hl               ;
  348.      ld hl,scorestr               ;
  349.      call _puts                   ;
  350.      ld hl,(score)                ; write the score
  351.      call _disphl                 ;
  352.      ld hl,$0306                  ; write "High:"
  353.      ld (currow),hl               ;
  354.      ld hl,highstr                ;
  355.      call _puts                   ;
  356.      call getscore                ; write high score
  357.      call _disphl                 ;
  358.      call waitfor2nd              ; wait for press of 2nd
  359.      call getscore                ; check for new high score
  360.      ld de,(score)                ;
  361.      call _cphlde                 ;
  362.      jp nc,snow                   ; return to title screen
  363.      call getdata                 ; load new score
  364.      ld hl,(score)                ;
  365.      ex de,hl                     ;
  366.      ld (hl),d                    ;
  367.      inc hl                       ;
  368.      ld (hl),e                    ;
  369.      call bufcpy                  ; clear bottom of screen
  370.      ld hl,$0405                  ; write "New High"
  371.      ld (currow),hl               ;
  372.      ld hl,newstr1                ;
  373.      call _puts                   ;
  374.      ld hl,$0506                  ; write "Score"
  375.      ld (currow),hl               ;
  376.      ld hl,newstr2                ;
  377.      call _puts                   ;
  378.      call waitfor2nd              ; wait for press of 2nd
  379.      jp snow                      ; return to title screen
  380.  
  381. skiquit:
  382.  
  383.      pop bc                       ; clear stack
  384.      call _getk                   ; catch last key press
  385.      call load                    ; reset flakes
  386.      jp snow                      ; return to title screen
  387.  
  388. hit:
  389.  
  390.      pop bc                       ; clear stack
  391.      call reverse_screen          ; invert screen
  392.      call shake_screen            ; give it a shake
  393.      jp done                      ; return to title screen
  394.  
  395. pause:
  396.  
  397.      call _getk                   ; catch last key press
  398.      ld hl,$0503                  ; write "Paused"
  399.      ld (currow),hl               ;
  400.      ld hl,pausestr               ;
  401.      call _puts                   ;
  402.  
  403. pause_loop:
  404.  
  405.      call _getk                   ; wait for press of mode
  406.      ld a,22                      ;
  407.      call _setxxop1               ;
  408.      call _cpop1op2               ;
  409.      jr nz,pause_loop             ;
  410.      call delay                   ; delay to allow key to be released
  411.      ret
  412.  
  413. waitfor2nd:
  414.  
  415.      call _getk                   ; wait for press of 2nd
  416.      ld a,21                      ;
  417.      call _setxxop1               ;
  418.      call _cpop1op2               ;
  419.      jr nz,waitfor2nd             ;
  420.      ret
  421.  
  422. ; draw out the level data compared to current row offset
  423.  
  424. drawlevel:
  425.  
  426.      ld hl,(row)                  ; start at current level offset
  427.      ld de,plotsscreen            ; draw to buffer
  428.      ld b,8                       ; 8 rows
  429.  
  430. draw_loop1:
  431.  
  432.      push bc
  433.      ld b,6                       ; 6 bytes per row
  434.  
  435. draw_loop2:
  436.  
  437.      push bc
  438.      ld a,(hl)                    ; get data
  439.      push hl                      ; save address to current level byte
  440.      srl a                        ; shift right 4
  441.      srl a                        ;
  442.      srl a                        ;
  443.      srl a                        ;
  444.      call cpitem                  ; draw item
  445.      inc de                       ; move to next byte in buffer
  446.      pop hl                       ; restore address to current level byte
  447.      ld a,(hl)                    ; get data
  448.      push hl                      ; save address to current level byte
  449.      and $0F                      ; mask off first 4 bits
  450.      call cpitem                  ; draw item
  451.      inc de                       ; move to next byte in buffer
  452.      pop hl                       ; restore address to current level byte
  453.      inc hl                       ; move to next byte in level
  454.      pop bc
  455.      djnz draw_loop2
  456.  
  457. next_row:
  458.  
  459.      push hl
  460.      ld hl,84                     ; move to next row down in plotsscreen
  461.      add hl,de                    ;
  462.      ex de,hl                     ;
  463.      pop hl                       ;
  464.      pop bc                       ;
  465.      djnz draw_loop1              ;
  466.      ret                          ; all done
  467.  
  468. cpitem:
  469.  
  470.      cp 1                         ; is it grass
  471.      call z,drawgrass             ;
  472.      cp 2                         ; is it a tree
  473.      call z,drawtree              ;
  474.      cp 3                         ; is it a small rock
  475.      call z,drawrock1             ;
  476.      cp 4                         ; is it a large rock
  477.      call z,drawrock2             ;
  478.      cp 5                         ; is it a gate
  479.      call z,drawgate              ;
  480.      ret
  481.  
  482. ; draws out item
  483.  
  484. draw_item:
  485.  
  486.      push de                      ; save current address in plotsscreen
  487.      ld b,8
  488.  
  489. draw_item_loop:
  490.  
  491.      push bc
  492.      push hl
  493.      ld a,(hl)
  494.      ld (de),a
  495.      ld hl,12
  496.      add hl,de
  497.      ex de,hl
  498.      pop hl
  499.      inc hl
  500.      pop bc
  501.      djnz draw_item_loop
  502.      pop de                       ; restore current address in plotsscreen
  503.      ret
  504.  
  505. ; sets up drawing for each item
  506.  
  507. drawgrass:
  508.  
  509.      ld hl,grass
  510.      call draw_item
  511.      ret
  512.  
  513. drawtree:
  514.  
  515.      ld hl,tree
  516.      call draw_item
  517.      ret
  518.  
  519. drawrock1:
  520.  
  521.      ld hl,rock1
  522.      call draw_item
  523.      ret
  524.  
  525. drawrock2:
  526.  
  527.      ld hl,rock2
  528.      call draw_item
  529.      ret
  530.  
  531. drawgate:
  532.  
  533.      ld hl,gate
  534.      call draw_item
  535.      ret
  536.  
  537. ; draw the skier
  538. ; uses the same draw_item routine
  539.  
  540. drawskier:
  541.  
  542.      ld hl,plotsscreen
  543.      ld d,0
  544.      ld a,(col)
  545.      ld e,a
  546.      add hl,de
  547.      ex de,hl
  548.      ld hl,skier
  549.      call draw_item
  550.      ret
  551.  
  552. ; move skier to the right
  553.  
  554. move_right:
  555.  
  556.      ld a,(col)
  557.      cp 11                        ; is it at the right edge ?
  558.      ret z
  559.      inc a
  560.      ld (col),a
  561.      ret
  562.  
  563. ; move skier to the left
  564.  
  565. move_left:
  566.  
  567.      ld a,(col)
  568.      cp 0                         ; is it at the left edge ?
  569.      ret z
  570.      dec a
  571.      ld (col),a
  572.      ret
  573.  
  574. ; input: hl points symbol table entry
  575. ; output: de points data of symbol table entry
  576.  
  577. getdata:
  578.  
  579.      ld hl,(level)
  580.      inc hl                       ; move to DAL
  581.      ld d,(hl)                    ; copy data address to de
  582.      inc hl                       ;
  583.      ld e,(hl)                    ;
  584.      inc de                       ; skip 1st length byte
  585.      inc de                       ; skip 2nd length byte
  586.      ret
  587.  
  588. ; output: hl coutains high score of level
  589.  
  590. getscore:
  591.  
  592.      call getdata
  593.      ex de,hl                     ; exchange de and hl
  594.      ld d,(hl)
  595.      inc hl
  596.      ld e,(hl)
  597.      ex de,hl
  598.      ret
  599.  
  600. ; get the item at the skier's current position
  601. ; so you can check to see if the skier hit anything
  602. ; a->item
  603.  
  604. getitem:
  605.  
  606.      ld a,(col)                   ; to get skier offset you have to
  607.      bit 0,a
  608.      jr nz,odd                    ; 1 means it is odd
  609.  
  610. even:
  611.  
  612.      srl a                        ; divide skier offset by 2
  613.      ld d,0                       ; add 6
  614.      ld e,a
  615.      ld hl,(row)                  ; add skiercol/2+6 to the level row offset
  616.      add hl,de
  617.      ld a,(hl)
  618.      srl a                        ; shift to the right 4 times to get first 4 bits
  619.      srl a
  620.      srl a
  621.      srl a
  622.      ret                          ; return: a = item at skiers position
  623.  
  624. odd:
  625.  
  626.      srl a                        ; divide skier offset by 2
  627.      ld d,0                       ; add 6
  628.      ld e,a
  629.      ld hl,(row)                  ; add skiercol/2+6 to the level row offset
  630.      add hl,de
  631.      ld a,(hl)
  632.      and $0F                      ; mask off first 4 bits
  633.      ret                          ; return: a = item at skiers position
  634.  
  635. ; produces a delay
  636. ; make bc a larger number to produce a longer delay
  637. ; make bc a smaller number to produce a shorter delay
  638.  
  639. large_delay:
  640.  
  641.      push af
  642.      push bc
  643.      ld bc,$5500
  644.      jr delay_loop
  645.  
  646. delay:
  647.  
  648.      push af
  649.      push bc
  650.      ld bc,$4600
  651.  
  652. delay_loop:
  653.  
  654.      dec bc
  655.      ld a,b
  656.      or c
  657.      jr nz,delay_loop
  658.      pop bc
  659.      pop af
  660.      ret
  661.  
  662. ; inverts screen
  663.  
  664. reverse_screen:
  665.  
  666.      ld hl,plotsscreen
  667.      ld de,plotsscreen+768
  668.  
  669. reverse_loop:
  670.  
  671.      ld a,(hl)
  672.      cpl
  673.      ld (hl),a
  674.      inc hl
  675.      call _cphlde
  676.      jr nz,reverse_loop
  677.      call bufcpy
  678.      ret
  679.  
  680. ; shakes screen when you hit something
  681.  
  682. shake_screen:
  683.  
  684.      ld b,2
  685.  
  686. shake_loop:
  687.  
  688.      call large_delay             ; delay
  689.      ld a,42h                     ; set screen offset to 2
  690.      out (lcdinstport),a
  691.      call large_delay             ; delay
  692.      ld a,40h                     ; set screen offset to 0
  693.      out (lcdinstport),a
  694.      djnz shake_loop
  695.      ret
  696.  
  697. ;▄████████████▀ DRWSPR ▀███████████████████████████████████████████████████████
  698. ;┌────────────────────────────────────────────────────────────────────────────┐
  699. ;│ Draw 8x8 sprite ■ a=x, e=y, hl=sprite address                              │
  700. ;└────────────────────────────────────────────────────────────────────────────┘
  701.  
  702. drwspr:
  703.  
  704.      push hl                      ; Save sprite address
  705.  
  706. ;████   Calculate the address in graphbuf   ████
  707.  
  708.      ld hl,0                      ; Do y*12
  709.      ld d,0
  710.      add hl,de
  711.      add hl,de
  712.      add hl,de
  713.      add hl,hl
  714.      add hl,hl
  715.  
  716.      ld d,0                       ; Do x/8
  717.      ld e,a
  718.      srl e
  719.      srl e
  720.      srl e
  721.      add hl,de
  722.  
  723.      ld de,plotsscreen
  724.      add hl,de                    ; Add address to graphbuf
  725.  
  726.      and %00000111                ; Get the remainder of x/8
  727.      cp 0                         ; Is this sprite aligned to 8*n,y?
  728.      jr z,align
  729.  
  730.  
  731. ;████   Non aligned sprite blit starts here   ████
  732.  
  733.      pop ix                       ; ix->sprite
  734.      ld d,a                       ; d=how many bits to shift each line
  735.  
  736.      ld e,8                       ; Line loop
  737.  
  738. lilop:
  739.  
  740.      ld b,(ix)                    ; Get sprite data
  741.  
  742.      ld c,0                       ; Shift loop
  743.      push de
  744.  
  745. shlop:
  746.  
  747.      srl b
  748.      rr c
  749.      dec d
  750.      jr nz,shlop
  751.      pop de
  752.  
  753.      ld a,b                       ; Write line to graphbuf
  754.      or (hl)
  755.      ld (hl),a
  756.      inc hl
  757.      ld a,c
  758.      or (hl)
  759.      ld (hl),a
  760.  
  761.      ld bc,11                     ; Calculate next line address
  762.      add hl,bc
  763.      inc ix                       ; inc spritepointer
  764.  
  765.      dec e
  766.      jr nz,lilop                  ; Next line
  767.      ret
  768.  
  769. ;████   Aligned sprite blit starts here   ████
  770.  
  771. align:                            ; Blit an aligned sprite to graphbuf
  772.  
  773.      pop de                       ; de->sprite
  774.      ld b,8
  775.  
  776. alop1:
  777.  
  778.      ld a,(de)
  779.      or (hl)                      ; xor=erase/blit
  780.      ld (hl),a
  781.      inc de
  782.      push bc
  783.      ld bc,12
  784.      add hl,bc
  785.      pop bc
  786.      djnz alop1
  787.      ret
  788.  
  789. ;▄████████████▄ DRWSPR ▄███████████████████████████████████████████████████████
  790.  
  791. ; copy plotsscreen to lcd
  792. ; faster than _grbufcpy_v
  793.  
  794. bufcpy:
  795.  
  796.      ld hl,plotsscreen
  797.      ld b,40h
  798.      di
  799.      ld a,7
  800.      call LCDBusy
  801.      out (lcdinstport),a
  802.      ld a,127
  803.  
  804. bclcpy:
  805.  
  806.      push bc
  807.      inc a
  808.      ld (8012h),a
  809.      call s7port10
  810.      call lcdbusy
  811.      out (lcdinstport),a
  812.  
  813.      ld a,20h
  814.      call lcdbusy
  815.      out (lcdinstport),a
  816.      ld b,12
  817.  
  818. bcl2cpy:
  819.  
  820.      ld a,(hl)
  821.      inc hl
  822.      call lcdbusy
  823.      out (lcddata),a
  824.      djnz bcl2cpy
  825.      pop bc
  826.      ld a,(8012h)
  827.      djnz bclcpy
  828.      ld a,5
  829.      call lcdbusy
  830.      out (lcdinstport),a
  831.      ei
  832.      ret
  833.  
  834. lcdbusy:
  835.  
  836.      push af
  837.      inc hl
  838.      dec hl
  839.      pop af
  840.      ret
  841.  
  842. s7port10:
  843.  
  844.      push af
  845.      ld a,7
  846.      call lcdbusy
  847.      out (lcdinstport),a
  848.      pop af
  849.      ret
  850.  
  851. ; title image
  852.  
  853. title:
  854.  
  855.      .db $01,252,$03,$E0,$00,$00,$00,$00,$00,$00,$00,$00
  856.      .db $07,$06,$02,$20,$00,$00,$00,$00,$00,$00,$00,$00
  857.      .db $0C,$02,$02,$20,$00,$00,$00,$00,$00,$00,$00,$00
  858.      .db $18,$02,$06,$20,$00,$00,$00,$00,$00,$00,$00,$00
  859.      .db $11,$F6,$04,$60,$1F,$C0,$1F,$F8,$01,$FC,$01,$FF
  860.      .db $11,$FC,$04,$40,$70,$60,$10,$0C,$07,$06,$07,$01
  861.      .db $10,$38,$0D,$40,$C0,$30,$30,$04,$0C,$02,$0C,$01
  862.      .db $10,$0C,$0A,$C1,$8F,$10,$23,$C4,$18,$E2,$08,$7B
  863.      .db $19,$04,$0D,$81,$19,$50,$62,$44,$11,$E2,$08,$7E
  864.      .db $0E,$54,$1B,$83,$19,$B0,$E2,$C6,$70,$02,$08,$0C
  865.      .db $7B,$0C,$21,$86,$92,$51,$46,$8D,$A4,$06,$04,$04
  866.      .db $4F,$AC,$20,$C9,$36,$2E,$45,$88,$33,$FD,$1F,$D4
  867.      .db $C1,$DC,$40,$B2,$5C,$60,$47,$00,$29,$E6,$F3,$EC
  868.      .db $80,$B2,$41,$02,$00,$C0,$80,$24,$30,$04,$00,$3C
  869.      .db $C0,$61,$80,$00,$03,$88,$00,$61,$78,$01,$20,$18
  870.      .db $60,$00,$29,$00,$E6,$02,$8F,$DA,$8F,$44,$10,$08
  871.      .db $1E,$04,$10,$00,$01,$C8,$88,$05,$06,$28,$25,$10
  872.      .db $0C,$11,$26,$08,$E1,$41,$98,$02,$01,$82,$18,$20
  873.      .db $02,$86,$99,$23,$16,$23,$10,$00,$00,$44,$37,$C0
  874.      .db $01,$29,$B0,$94,$0A,$18,$F0,$02,$00,$30,$E0,$00
  875.      .db $01,$D8,$C0,$48,$08,$0D,$80,$07,$00,$09,$00,$00
  876.      .db $01,$60,$80,$50,$00,$07,$00,$05,$00,$09,$00,$00
  877.      .db $00,$E0,$00,$50,$00,$04,$00,$08,$80,$06,$00,$00
  878.      .db $00,$C0,$00,$30,$00,$00,$00,$09,$80,$04,$00,$00
  879.      .db $00,$80,$00,$20,$00,$00,$00,$07,$00,$00,$00,$00
  880.  
  881. ; different sprites
  882.  
  883. skier:
  884.  
  885.      .db %00100100
  886.      .db %00100100
  887.      .db %01111110
  888.      .db %01100110
  889.      .db %01111110
  890.      .db %00111100
  891.      .db %00100100
  892.      .db %00100100
  893.  
  894. grass:
  895.  
  896.      .db %00101010
  897.      .db %10100000
  898.      .db %00010101
  899.      .db %01001000
  900.      .db %00100010
  901.      .db %00001100
  902.      .db %01010001
  903.      .db %01000010
  904.  
  905. tree:
  906.  
  907.      .db %00011000
  908.      .db %00011000
  909.      .db %00111100
  910.      .db %00111100
  911.      .db %01111110
  912.      .db %01111110
  913.      .db %11111111
  914.      .db %00011000
  915.  
  916. rock1:
  917.  
  918.      .db %00000000
  919.      .db %00000000
  920.      .db %00001100
  921.      .db %00010010
  922.      .db %00100010
  923.      .db %00100010
  924.      .db %00011100
  925.      .db %00000000
  926.  
  927. rock2:
  928.  
  929.      .db %00000000
  930.      .db %00111000
  931.      .db %01000100
  932.      .db %01010010
  933.      .db %10100001
  934.      .db %10000001
  935.      .db %01000011
  936.      .db %00111100
  937.  
  938. gate:
  939.  
  940.      .db %00000000
  941.      .db %01000010
  942.      .db %01111110
  943.      .db %01111110
  944.      .db %01000010
  945.      .db %01000010
  946.      .db %01000010
  947.      .db %01000010
  948.  
  949. flake:
  950.  
  951.      .db %01100000
  952.      .db %11110000
  953.      .db %01100000
  954.      .db %00000000
  955.      .db %00000000
  956.      .db %00000000
  957.      .db %00000000
  958.      .db %00000000
  959.  
  960. creatorstr:
  961.  
  962.      .db "By Ian Graf",0
  963.  
  964. pausestr:
  965.  
  966.      .db "Paused",0
  967.  
  968. scorestr:
  969.  
  970.      .db "Score",0
  971.  
  972. highstr:
  973.  
  974.      .db "High ",0
  975.  
  976. newstr1:
  977.  
  978.      .db "New High",0
  979.  
  980. newstr2:
  981.  
  982.      .db "Score!",0
  983.  
  984. defaultprog:
  985.  
  986.      .db "ZSKIL"
  987.  
  988. .end
  989. END
  990.