' Autor:    Oliver Maske, SpaceArts
' Filename: DYN-KEYB.BAS
' Name:     Dynamite
' Zweck:    Keyboard Handler fr das Spiel Dynamite

' ž> Diese Variable wird ben”tigt, um die Rcksprungadresse des alten
'    Keyboard Handlers zu speichern

 DIM OldInt9Handler AS SHARED DWORD

' ž> Diese Variable wird ben”tigt, um den Status der gedrckten Player
'    Keys zu speichern

 DIM PushedKeys AS SHARED WORD

 ' Aufbau: Bit 0: right
 '             1: left
 '             2: down
 '             3: up
 '             4: fire (Space)
 '             5: Choose
 '             6: ESCape
 '             7: Pause
 '             8: Funktionstaste 1 (F1)

' ž> In dieser Variable wird vermerkt, ob der letzte ScanCode ein
'    extended ScanCode war.

 DIM ExtendedKey AS SHARED INTEGER
 DIM PauseLevel         AS SHARED INTEGER

' ž> Ein Puffer fuer alle ankommenden Tasten wird benoetigt.

 DIM KeyBufferPos AS SHARED INTEGER

 SUB InstallKeybHandler () PUBLIC
    LOCAL NewInt9Handler???
   ' ž> ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
   '     installiert den eigenen Tastaturhandler

    OwnTastaturHandlerActiv = %TRUE
    DeleteKeybBuffer

    ! xor    ax, ax
    ! mov    es, ax
    ! mov byte es:[&H043d], 0

   ' ž> Wiederholungsrate: 1000ms, 2 Zeichen/sek.
    ! mov    ax, &H0305
    ! mov    bl, &H1F
    ! mov    bh, 03
    ! int    &H16
    ! cli
   ' ž> Adresse des alten KeybHandler merken
    DEF SEG = 0: OldInt9Handler??? = PEEKL (&H9 * 4)

   ' ž> Adresse des neuen KeybHandler erstellen
    NewInt9Handler??? = 2^16 * CODESEG (KeybHandler) + CODEPTR (KeybHandler)

   ' ž> Adresse in Vektor schreiben
    POKEL (&H9 * 4), NewInt9Handler???: DEF SEG
    ! sti

    PushedKeys = 0
 END SUB

 SUB DeInstallKeybHandler () PUBLIC
    LOCAL i%
   ' ž> ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
   '     deinstalliert den eigenen Tastaturhandler

   ' ž> evtl. TastaturInts ausfuehren
    FOR i% = 1 TO 32000: NEXT i%

    ! cli
   ' ž> Adresse des alten KeybHandler in Vektor schreiben
    DEF SEG = 0: POKEL (&H9 * 4), OldInt9Handler???: DEF SEG
    ! sti

    DeleteKeybBuffer
   ' ž> Wiederholungsrate normalisieren: 500ms, 20 Zeichen/sek.
    ! mov ax, &H0305
    ! mov bl, &H04
    ! mov bh, 1
    ! int &H16
    OwnTastaturHandlerActiv = %FALSE
 END SUB

 SUB DeleteKeybBuffer ()
    LOCAL Dummy$
   ' ž> ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
   '     l”scht den Keyboard Puffer

    FOR i% = 1 TO 20: Dummy$ = INKEY$: NEXT i%
 END SUB

 SUB TastaturAuswerten () PUBLIC
    LOCAL TastaturScan?
   ' ž> ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
   '     Wertet die Tastatur aus

     ! xor      ax, ax
     ! mov      es, ax
     ! cmp byte es:[&H043d], 0
     ! jne      TastaturAuswertung
     EXIT SUB

    ' ž> ScanCode holen
    TastaturAuswertung:
     ! push     ds  ; DS auf Stack
     ! push     si  ; SI auf Stack
     ! mov      es, ax  ; Ring Puffer Segment
     ! mov      ds, ax  ; DS=ES
     ! mov      di, &H041e ; Ring Puffer Offset
     ! mov      bl, es:[di] ; Zeichen holen
     ! mov      si, &H041f      ; Quelloffset
     ! mov      cx, 10  ; 20 Bytes kopieren
     ! rep      movsw  ; kopieren
     ! pop      si  ; SI vom Stack
     ! pop      ds  ; DS vom Stack
     ! mov      es, ax
     ! dec byte es:[&H043d]   ; ein Zeichen weniger im Ring Puffer
     ! mov      TastaturScan?, bl ; Zeichen ausgeben

     BIT RESET PushedKeys, 7
    ' ž> Pause Taste
     IF PauseLevel% = 1 AND TastaturScan? = 29 THEN PauseLevel% = 2
     IF PauseLevel% = 2 AND TastaturScan? = 69 THEN PauseLevel% = 3
     IF PauseLevel% = 3 AND TastaturScan? = 225 THEN PauseLevel% = 4
     IF PauseLevel% = 4 AND TastaturScan? = 157 THEN PauseLevel% = 5

     IF PauseLevel% = 5 AND TastaturScan? = 197 THEN
        BIT SET PushedKeys, 7
        PauseLevel% = 0
     END IF

   ' ž> ExtendedKeys
     IF ExtendedKey% THEN
       ' ž> rechts
        IF TastaturScan? = &H4d THEN
          BIT SET PushedKeys, 0
          BIT RESET PushedKeys, 1
          BIT RESET PushedKeys, 2
          BIT RESET PushedKeys, 3
        END IF
       ' ž> rechts losgelassen
        IF TastaturScan? = &H4d+128 THEN
          BIT RESET PushedKeys, 0
        END IF
       ' ž> links
        IF TastaturScan? = &H4b THEN
          BIT SET PushedKeys, 1
          BIT RESET PushedKeys, 0
          BIT RESET PushedKeys, 2
          BIT RESET PushedKeys, 3
        END IF
       ' ž> links losgelassen
        IF TastaturScan? = &H4b+128 THEN
          BIT RESET PushedKeys, 1
        END IF
       ' ž> runter
        IF TastaturScan? = &H50 THEN
          BIT SET PushedKeys, 2
          BIT RESET PushedKeys, 3
          BIT RESET PushedKeys, 0
          BIT RESET PushedKeys, 1
        END IF
       ' ž> runter losgelassen
        IF TastaturScan? = &H50+128 THEN
          BIT RESET PushedKeys, 2
        END IF
       ' ž> hoch
        IF TastaturScan? = &H48 THEN
          BIT SET PushedKeys, 3
          BIT RESET PushedKeys, 0
          BIT RESET PushedKeys, 1
          BIT RESET PushedKeys, 2
        END IF
       ' ž> hoch losgelassen
        IF TastaturScan? = &H48+128 THEN
          BIT RESET PushedKeys, 3
        END IF

        ExtendedKey% = %FALSE
     END IF

    ' ž> Normale Tasten
     IF TastaturScan? = &H39 THEN
        BIT SET PushedKeys, 4
     END IF
     IF TastaturScan? = &H0f THEN
        BIT SET PushedKeys, 5
     END IF
    ' ž> Escape
     IF TastaturScan? = &H01 THEN
        BIT SET PushedKeys, 6
     END IF
     IF TastaturScan? = &H3b THEN
        BIT SET PushedKeys, 8
     END IF

     IF TastaturScan? = &He1 AND PauseLevel% = 0 THEN
        PauseLevel% = 1
     END IF
     IF TastaturScan? = &He0 THEN
        ExtendedKey% = %TRUE
     END IF
 END SUB
 END

 KeybHandler:
   ' ž> ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
   '     Diese Routine wird in den INT 9 eingelinkt
   '     und speichert die Tasten in dem RingPuffer

    ! cli
    ! push   ax
    ! push   bx
    ! push   dx
    ! push   di
    ! push   es

   ' ž> eigentlicher Handler
    ! xor   ah, ah
    ! mov   dx, &H64
    ! in    al, dx
    ! test  al, &B11100000
    ! jz    KeinFehler

   ' ž> Fehler beim Auswerten
    ! mov   dx, &H60
    ! mov   al, &Hf4
    ! out   dx, al
    ! jmp   short BeendeHandler

   KeinFehler:
    ! mov   dx, &H60
    ! in    al, dx
   NormalScan:
    ! call  far HandleKey
    ! mov   dx, &H20
    ! mov   al, &H20
    ! out   dx, al
   BeendeHandler:
    ! pop   es
    ! pop   di
    ! pop   dx
    ! pop   bx
    ! pop   ax

    ! iret

  HandleKey:
   ' ž> ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
   '     nachdem die Tastatur abgefragt wurde,
   '     werden die Tastendrcke hier ausgewertet

    ! mov      bl, al
    ! xor      ax, ax
    ! mov      es, ax
    ! cmp byte es:[&H043d], 20
    ! je       KeyboardBufferVoll
    ! inc byte es:[&H043d]
    ! mov      di, &H041d
    ! mov      al, es:[&H043d]
    ! add      di, ax
    ! mov      es:[di], bl
   KeyboardBufferVoll:
    ! retf