Crazy Pacman

home *** CD-ROM | disk | FTP | other *** search

/ Crazy Pacman / CrazyPacman.iso / pacman / PACMAN / SOURCE / P_ASM.ASM < prev next >

Wrap

Assembly Source File | 1995-11-13 | 43.8 KB | 1,526 lines

;== Konstanten ========================================================= looplimit = 01ffh; SC_INDEX = 3c4h ; Indexregister des Sequencer-Ctrl. SC_MAP_MASK = 2 ; Nummer des Map-Mask-Registers SC_MEM_MODE = 4 ; Nummer des Memory-Mode-Registers GC_INDEX = 3ceh ; Indexregister des Graphics-Ctrl. GC_READ_MAP = 4 ; Nummer des Read-Map-Registers GC_GRAPH_MODE = 5 ; Nummer des Graphics-Mode-Registers GC_MISCELL = 6 ; Nummer des Miscellaneous-Registers CRTC_INDEX = 3d4h ; Indexregistes des CRT-Controllers CC_MAX_SCAN = 9 ; Nummer des Maximum-Scan-Line-Reg. CC_START_HI = 0Ch ; Nummer des Hi-Start-Registers CC_UNDERLINE = 14h ; Nummer des Underline-Registers CC_MODE_CTRL = 17h ; Nummer des Mode-Control-Registers PIXX = 320 ; horizontale Auflösung SPEICHER = 500 ; zwischenspeicher zum laden eines pcx... INPUT_1 = 3DAh ; Input Status #1 Register VERT_RETRACE = 08h ; INPUT_1: Vertical Retrace Bit public _copybuf2plane public _copyplane2buf public _cpbuf2scr public _cpscr2buf public _cpback2scr public _get_kkey public _cpbuf2back public _init320400 ; 320*400-Punkte-Modus initialisieren public _setpix ; Punkt setzen public _showpage ; Seite 0 oder 1 anzeigen public _setpage ; Seite für setpix und getpix festlegen public _getfontptr ; liefert Zeiger auf 8*8-Zeichensatz public _stick public _set_color ; Funktion als öffentlich deklarieren fuer Linker public _piclen ; Funktion als öffentlich deklarieren fuer Linker public _show_pic ; Funktion als öffentlich deklarieren fuer Linker public _sync_display .model large .286 .data akt_mode dw 3 ; Modus bei init akt_v dw 2 ; Vesa benoetigt 1=ja 2 = nein akt_x dw 320 ; x-aufloesung akt_y dw 400 ; y-aufloesung akt_f dw 256 ; anzahl der Farben akt_m dw 013h ; Modus Nummer um aufzurufen akt_l dw 65536/320+1 ; addline akt_b dw 256 ; addbytes _vio_seg dw 0a000h ; Video-Segment mit akt. Seite setfen dw 0,0 init_mode dw 0 xx dw 0 yy dw 0 akthand dw 0 fonthandle dw 0 xfontsize1 dw 0 tbreite dw 0 abreite dw 0 bpointer dw 0 offdata dw 0 tcounl dw 0 bpend dw 0 tcounh dw 0 tcode dw 0 xpos dw 0 ypos dw 0 xbpos dw 0 ybpos dw 0 xlen dw 0 ylen dw 0 fill dw 0 chigh dw 0 clow dw 0 flag dw 0 fno dw 0 r dw 0 g dw 0 b dw 0 full dw 0 bbytesh dw 0 bbytesl dw 0 breite dw 0 hoch dw 0 gcounterh dw 0 gcounterl dw 0 fencoun0 dw 0 fencoun1 dw 0 lencoun dw 0 blen dw 0 bblen dw 0 plen dw 0 noread db 0 zenum dw 0 handle dw 0 zeile1 db 140 dup(0) zeile2 db 140 dup(0) zeile3 db 140 dup(0) zeile4 db 140 dup(0) bild db 130 dup(0) fab2 db 768 dup(0) fab db 48 dup(0) stelle db 0,0 oldmode db 0,0 buffer db SPEICHER dup(0) color db 0 indata db 15 dup (0) tabelle1 db 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,15 .code _setpix proc far sframe struc ; Struktur zum Zugriff auf den Stack bp0 dw ? ; nimmt BP auf ret_adr0 dd ? ; Rücksprungadresse zum Aufrufer x0 dw ? ; X-Ordinate y0 dw ? ; Y-Ordinate ffarbe dw ? ; Farbe sframe ends ; Ende der Struktur frame equ [ bp - bp0 ] ; adressiert die Elemente der Struktur push bp ; Adressierung der Parameter über mov bp,sp ; das BP-Register vorbereiten push di ; DI auf dem Stack sichern push cx mov ax,PIXX / 4 ; Offset in den Video-RAM berechnen mul frame.y0 ; und nach DI laden mov cx,frame.x0 mov bx,cx shr bx,1 shr bx,1 add ax,bx mov di,ax and cl,3 ;Bit-Maske für die zu adressierende mov ah,1 ;Map in AH berechnen shl ah,cl mov al,SC_MAP_MASK ;nach AL die Registernummer mov dx,SC_INDEX ;Indexadresse des Sequencers laden out dx,ax ;Bit-Mask-Register laden mov ax,_vio_seg ;ES auf den Video-RAM setzen mov es,ax mov al,byte ptr frame.ffarbe ;Farbe des Punktes laden stosb ;und in die gewählte Bit-Map schreiben pop cx pop di ;Register wieder vom Stack holen pop bp ret ;zurück zum Aufrufer _setpix endp ;Ende der Prozedur _setpage proc far pop bx ;Rücksprungadresse vom Stack pop cx pop ax ;Argument vom Stack push ax ;und beides wieder rauf push cx push bx mov bl,0a0h ;von Seite 0 ausgehen or al,al ;ist es die Seite 0? je sp1 ;Ja, Segmentadresse merken mov bl,0a8h ;Nein, Seite 1 sp1: mov byte ptr _vio_seg + 1,bl ;neue Segmentadresse merken ret ;zurück zum Aufrufer _setpage endp ;Ende der Prozedur _showpage proc far pop bx ;Rücksprungadresse vom Stack pop cx pop ax ;Argument vom Stack push ax ;und beides wieder rauf push cx push bx or al,al ;ist es die Seite 0? je sp2 ;Ja, Nummer ist auf Hi-Byte des Offset mov al,80h ;Nein, Seite 1, mit Offset 8000h sp2: mov dx,CRTC_INDEX ;CRT-Controller adressieren mov ah,al ;Hi-Byte des Offsets nach AH mov al,CC_START_HI ;Registernummer nach AL out dx,ax ;und ab gehts mov dx,INPUT_1 ;zunächst auf Ende des vertikalen sp3: in al,dx ;Rücklaufs warten test al,8 jne sp3 sp4: in al,dx ;dann auf den Start des Rücklaufs test al,8 je sp4 ret ;zurück zum Aufrufer _showpage endp ;Ende der Prozedur _getfontptr proc far push bp ;BP sichern mov ax,1130h ;Register für Funktionsaufruf laden mov bh,3 int 10h ;BIOS-Video-Interrupt aufrufen mov dx,es ;Zeiger ES:BP in DX:AX zurückliefern mov ax,bp pop bp ;BP vom Stack zurückholen ret ;zurück zum Aufrufer _getfontptr endp ;Ende der Prozedur ;══════════════════════════════════════════════════════════════════════════════ get_decrunch proc near ; einfache rll decruncher push bx mov bx,[bpointer] ; holt buffer nach bp inc bpointer mov al,[bx] cmp bx,[bpend] ; wenn 50KB dann neuen buffer lesen jne short g_d_1 call read_buffer ; weitere 50KB lesen mov bx,[bpointer] ;************************** dec bx g_d_1: cmp al,11000000b jnb zaehler ; ja, dann zaehler ausfindig machen mov cx,1 ; sonst zaehler =1 und weg pop bx ret zaehler: mov cx,00111111b ; die 6 lo bits sind der zaehler and cl,al ; in cl jetzt der zaehler ... inc bx ; und counter + bx erhoehen inc bpointer mov al,[bx] cmp bx,[bpend] ; wie oben jne short g_d_2 call read_buffer g_d_2: pop bx ret get_decrunch endp ;══════════════════════════════════════════════════════════════════════════════ farbe proc near palette: call shift_col mov bx,offset bild ; und ganz normal weitermachen add bx,16 mov ax,ds mov es,ax mov dx,bx mov bx,offset stelle mov bx,[bx] mov cx,16 mov al,12h mov ah,10h int 10h ret farbe endp ;══════════════════════════════════════════════════════════════════════════════ shift_col proc near call test_change cmp cx,0 jz sc2 mov bx,offset bild add bx,16 mov cx,48 sc1: mov al,[bx] push cx mov cl,1 shr al,cl shr al,cl sc3: mov [bx],al inc bx pop cx loop sc1 sc2: ret shift_col endp ;══════════════════════════════════════════════════════════════════════════════ test_change proc near ; 0 oder 1 nach cx, 1 muss gechanged werden mov cx,48 mov bx,offset bild add bx,16 tc1: mov al,[bx] cmp al,00111111b jae tc2 inc bx loop tc1 tc2: ret test_change endp ;══════════════════════════════════════════════════════════════════════════════ _set_color PROC FAR ; start ist die Proc, muss bei grossen Programmen far sein Push BP ; Stack retten Mov BP,SP ; Stack retten push ds mov ax,@data mov ds,ax mov ax,[bp+6] mov fno,ax mov ax,[bp+8] mov r,ax mov ax,[bp+10] mov g,ax mov ax,[bp+12] mov b,ax mov dx,03c8h mov ax,[fno] out dx,al mov dx,03c9h mov ax,[r] out dx,al mov ax,[g] out dx,al mov ax,[b] out dx,al pop ds mov sp,bp pop bp RET _set_color endp ;══════════════════════════════════════════════════════════════════════════════ _piclen PROC FAR ; start ist die Proc, muss bei grossen Programmen far sein Push BP ; Stack retten Mov BP,SP ; Stack retten push di push si push bp push es mov ax,@data mov ds,ax mov ax,[bp+6] mov dx,[bp+8] mov chigh,dx mov clow,ax mov ax,[bp+10] mov flag,ax mov dx,[chigh] call do_pcx mov ah,3dh mov al,0 mov dx,offset indata int 21h jc zofehler mov [handle],ax jmp zweiter zofehler: mov cx,0 jmp zopf ; stack noch nicht korrigiert zweiter: mov ah,3fh ; lesen einer Datei mov bx,[handle] mov dx,offset bild mov cx,128 int 21h mov bx,offset bild ; Bild breite und hoehe einstellen add bx,8 mov ax,[bx] sub bx,4 mov dx,[bx] sub ax,dx mov breite,ax add bx,2 mov dx,[bx] add bx,4 mov ax,[bx] sub ax,dx mov hoch,ax cmp flag,1 jz zy mov bx,offset breite mov cx,[bx] jmp zopf zy: mov bx,offset hoch mov cx,[bx] zopf: push cx mov ah,3eh ; schliessen einer datei mov bx,[handle] int 21h pop ax pop es pop bp pop si pop di mov sp,bp pop bp RET _piclen endp ;══════════════════════════════════════════════════════════════════════════════ open_header proc near mov ah,3dh ; oeffnen einer Datei mov al,0 mov dx,offset indata int 21h jc ofehler mov [handle],ax jmp weiter ofehler: mov cx,1 ret ; stack noch nicht korrigiert weiter: mov ah,3fh ; lesen einer Datei mov bx,[handle] mov dx,offset bild mov cx,128 int 21h call read_buffer mov cx,0 ret open_header endp ;══════════════════════════════════════════════════════════════════════════════ close proc near mov ah,3eh ; schliessen einer datei mov bx,[handle] int 21h ret close endp ;══════════════════════════════════════════════════════════════════════════════ make_offsets proc near mov zenum,4 mov gcounterl,0 mov gcounterh,0 mov full,0 mov bx,offset bild add bx,65 mov dl,[bx] cmp dl,4 jz mok mov cx,1 ret mok: mov bx,offset bild ; Bild breite und hoehe einstellen add bx,8 mov ax,[bx] sub bx,4 mov dx,[bx] sub ax,dx inc ax inc ax mov breite,ax mov tbreite,ax mov [blen],ax add bx,2 mov dx,[bx] add bx,4 mov ax,[bx] sub ax,dx inc ax mov hoch,ax mov bx,offset bild add bx,66 mov dx,[bx] mov bblen,dx mov ax,[tbreite] dec ax mov cx,[akt_x] sub cx,ax mov [plen],cx mov bx,offset bild ; bytes pro zeile add bx,66 mov ax,[bx] ; bytes vom bild bleiben gleich mov bx,hoch shl bx,1 ; 4 wegen bitplanes shl bx,1 mul bx ; breite mal hoehe mov [bbytesh],dx ; laenge des bildes in bytes high mov [bbytesl],ax ; und low mov ax,[xpos] mov fencoun1,ax mov xx,ax mov bx,0 mov bx,ax mov ax,0 mov ax,[akt_x] mov cx,0 mov cx,[ypos] mov yy,cx mov fencoun0,ax mov bx,[akt_x] mov ax,[ypos] mul bx add fencoun1,ax mov ax,[fencoun1] mov cl,10 shr ax,cl mov lencoun,ax mov bx,0 mov dx,[fencoun0] ; erstes segment granularität 64k mov bx,offset buffer mov bpointer,bx add bx,SPEICHER-1 mov bpend,bx ret make_offsets endp ;══════════════════════════════════════════════════════════════════════════════ read_buffer proc near pusha mov ah,3fh ; lesen einer Datei mov bx,[handle] mov dx,offset buffer mov [bpointer],dx mov cx,SPEICHER int 21h jae r_b_ok mov al,1 mov [noread],al r_b_ok: popa ret read_buffer endp ;══════════════════════════════════════════════════════════════════════════════ _show_pic PROC far ; start ist die Proc, muss bei grossen Programmen far sein Push BP ; Stack retten Mov BP,SP ; Stack retten push di push si push bp push es mov ax,@data mov ds,ax mov ax,[bp+6] ; 1=Ersten parameter lesen mov xpos,ax mov ax,[bp+8] ; 2=Ersten parameter lesen mov ypos,ax mov ax,[bp+10] ; 2=Ersten parameter lesen mov bx,offset stelle mov cl,4 shl al,cl mov [bx],ax mov ax,[bp+12] mov dx,[bp+14] mov chigh,dx mov clow,ax call do_pcx call open_header cmp cx,1 jz no1fehler call make_offsets call farbe mov r,0 call do_nprint call close mov ax,0 pop es pop bp pop si pop di mov sp,bp pop bp RET no1fehler: mov ax,1 pop es pop bp pop si pop di mov sp,bp pop bp RET _show_pic endp ;══════════════════════════════════════════════════════════════════════════════ _init320400 proc far ;-- zunächst ganz normal den Modus 13h einstellen, damit das ;-- BIOS die meiste Arbeit der Initialisierung übernimmt. ;-- Danach die Register verändern, die sich noch nicht in ;-- der gewünschten Stellung befinden. mov ax,0013h ;normalen Modus 13h einstellen int 10h mov dx,GC_INDEX ;Auftrennung der Speicheradressen mov al,GC_GRAPH_MODE ;im Graphics-Mode-Register des out dx,al ;Gaphics-Controllers über das inc dx ;Bit #4 abschalten in al,dx and al,11101111b out dx,al dec dx mov al,GC_MISCELL ;und das Ganze noch einmal im out dx,al ;Miscellanous-Register über das inc dx ;Bit #1 in al,dx and al,11111101b out dx,al mov dx,SC_INDEX ;das Memory-Mode-Register im mov al,SC_MEM_MODE ;Sequencer-Controlller dahingehend out dx,al ;modifizieren, daß keine Auftrennung inc dx ;der Adressen in verschiedene Bit- in al,dx ;Planes mehr erfolgt und die aktuelle and al,11110111b ;Plane über das Bit-Mask-Register or al,4 ;festgelegt wird out dx,al mov ax,_vio_seg ;alle vier Bit-Planes komplett mit mov es,ax ;dem Farbcode 00h füllen und damit xor di,di ;den Bildschirm zunächst löschen mov ax,di mov cx,8000h rep stosw mov dx,CRTC_INDEX ;Verdopplung der Punktzeilen im mov al,CC_MAX_SCAN ;Maximum-Scan-Line-Register des out dx,al ;CRT-Controllers über das Bit 7 inc dx ;abschalten, gleichzeitig die in al,dx ;Zeichenhöhe in den Bits 0-4 auf and al,01110000b ;1 einstellen out dx,al dec dx ;DX wieder auf das CRT-Index-Reg mov al,CC_UNDERLINE ;Doppelwort-Modus über das Bit 6 out dx,al ;im Underline-Register des CRT- inc dx ;Controllers abstellen in al,dx and al,10111111b out dx,al dec dx mov al,CC_MODE_CTRL ;über das Bit 6 im Mode-Control- out dx,al ;Register des CRT-Controllers jetzt inc dx ;vom Word- in den Byte-Modus wechseln in al,dx or al,01000000b out dx,al ret ;zurück zum Aufrufer _init320400 endp ;Ende der Prozedur ;══════════════════════════════════════════════════════════════════════════════ nget_new_zeile proc near cmp zenum,4 jne nsp222 mov bx,offset zeile2 dec zenum ret nsp222: cmp zenum,3 jne nsp223 mov bx,offset zeile3 dec zenum ret nsp223: cmp zenum,2 jne nsp22 mov bx,offset zeile4 dec zenum ret nsp22: mov zenum,4 mov bx,[bblen] shl bx,1 shl bx,1 ; mal 4 fuer die bitplanes add [gcounterl],bx jnb nsp2 ; springe wenn carry geloescht inc [gcounterh] nsp2: mov dx,[gcounterh] mov bx,[bbytesh] cmp dx,bx jb kontrolle mov dx,[gcounterl] ; anzahl der geschriebenen bytes mit mov bx,[bbytesl] ; groesse des bildes vergleichen, high + low cmp dx,bx jb kontrolle mov bx,1 mov full,bx kontrolle: call dograf1 cmp [r],1 ; irgendwas mit den Fonts jne nntgnz mov bx,1 mov full,bx ret ; fontfontfont nntgnz: mov bx,offset zeile1 ret nget_new_zeile endp dograf1 proc near push cx mov ax,[xpos] mov xx,ax mov cx,[tbreite] mov abreite,cx mov di,[bblen] n1edog1: mov cx,8 n1eoben1: dec abreite jz n1edog5 xor ax,ax shl [zeile1+di],1 jae n1eno_bit1 or al,00000001b n1eno_bit1: shl [zeile2+di],1 jae n1eno_bit2 or al,00000010b n1eno_bit2: shl [zeile3+di],1 jae n1eno_bit3 or al,00000100b n1eno_bit3: shl [zeile4+di],1 jae n1eno_bit4 or al,00001000b n1eno_bit4: or al,[stelle+0] mov color,al push di ;DI auf dem Stack sichern push cx mov ax,PIXX / 4 ;Offset in den Video-RAM berechnen mul [yy] ;und nach DI laden mov cx,[xx] mov bx,cx shr bx,1 shr bx,1 add ax,bx mov di,ax and cl,3 ;Bit-Maske für die zu adressierende mov ah,1 ;Map in AH berechnen shl ah,cl mov al,SC_MAP_MASK ;nach AL die Registernummer mov dx,SC_INDEX ;Indexadresse des Sequencers laden out dx,ax ;Bit-Mask-Register laden mov ax,_vio_seg ;ES auf den Video-RAM setzen mov es,ax mov al,byte ptr [color] ;Farbe des Punktes laden stosb ;und in die gewählte Bit-Map schreiben pop cx pop di ;Register wieder vom Stack holen inc xx n1gooom: loop n1eoben1 dec di jne n1edog1 n1edog5: inc yy pop cx ret dograf1 endp ;══════════════════════════════════════════════════════════════════════════════ do_nprint proc near cmp [r],1 jne norr mov es,[fonthandle] norr: mov si,[bblen] mov bx,offset zeile1 ntill_EOF: ; aeussere schleife, spaeter bis eof call get_decrunch ; zaehler und wert holen, nach cx,al nspread: ; decrunch-schleife mov byte ptr ds:[bx+si],al dec si jne nnozeilenende mov si,[bblen] call nget_new_zeile nnozeilenende: loop nspread cmp full,1 jne ntill_EOF ret do_nprint endp ;══════════════════════════════════════════════════════════════════════════════ do_pcx proc near mov es,dx mov bx,offset indata mov dx,bx mov bx,[clow] mov di,bx sshl2: mov bx,di mov al,es:[bx] inc di mov bx,dx mov [bx],al inc dx or al,al jne sshl2 dec dx mov bx,dx mov byte ptr [bx],"." inc bx mov byte ptr [bx],"p" inc bx mov byte ptr [bx],"c" inc bx mov byte ptr [bx],"x" inc bx mov byte ptr [bx],0 ret do_pcx endp farbe2 proc near mov ah,42h mov al,2 mov cx,-1 mov dx,-768 mov bx,[handle] int 21h mov ah,3fh mov bx,[handle] mov cx,768 mov dx,offset fab2 int 21h call shift2_col mov bx,offset fab2 ; und ganz normal weitermachen mov ax,ds mov es,ax mov dx,bx mov cx,256 mov bx,0 mov al,12h mov ah,10h int 10h mov ah,42h mov al,0 mov cx,0 mov dx,50128 mov bx,[handle] int 21h ret farbe2 endp shift2_col proc near call test2_change cmp cx,0 jz sc22 mov bx,offset fab2 mov cx,768 sc21: mov al,[bx] push cx mov cl,1 shr al,cl shr al,cl mov [bx],al inc bx pop cx loop sc21 sc22: ret shift2_col endp test2_change proc near ; 0 oder 1 nach cx, 1 muss gechanged werden mov cx,768 mov bx,offset fab2 tc21: mov al,[bx] cmp al,00111111b jae tc22 inc bx loop tc21 tc22: ret test2_change endp _get_kkey PROC FAR mov ax,0100h int 16h jne gg_zeida mov ax,0 ret gg_zeida: mov ax,0 int 16h cmp al,0 jne gg_out mov al,ah gg_out: RET _get_kkey endp _copybuf2plane proc far sfr0 struc ;Struktur zum Zugriff auf den Stack bp0 dw ? ;nimmt BP auf ret_adr0 dd ? ;Rücksprungadresse zum Aufrufer bufptrl0 dd ? ;Zeiger auf Puffer nachpage dw ? ;nach Seite nachx dw ? ;nach X-Ordinate nachy dw ? ;nach Y-Ordinate breite0 dw ? ;Breite hoehe0 dw ? ;Höhe des Bereichs bg dw ? ;Hintergrund beachten hinter dw ? ;Hintergrund beachten sfr0 ends ;Ende der Struktur fr equ [ bp - bp0 ] ;adr. die Elemente der Struktur bfr equ byte ptr [ bp - bp0 ] ;adr. Stack-Element als Byte push bp ;Adressierung der Parameter über mov bp,sp ;das BP-Register vorbereiten push di push si ;-- Segmentadresse für Zugriff auf Video-RAM berechnen ------ mov ah,0A0h ;ES auf Anfang NACH-Seite cmp bfr.nachpage,0 ;ist es Seite 0? je cv0 ;Ja, AL schon o.k mov ah,0A8h ;Nein, Seite 1 bei A800h cv0: xor al,al ;Lo-Byte ist immer Null mov es,ax ;-- Offset für Zielposition in Page berechnen --------------- mov ax,PIXX / 4 ;DI auf Zielposition NACH mul fr.nachy mov di,fr.nachx mov cx,di ;X-Koordinate für Plane-Berechnung shr di,1 ;merken shr di,1 add di,ax ;-- die zu adressierende Bit-Plane einstellen --------------- mov ah,1 ;Plane-Nummer muß als Bit-Maske vorl. and cl,3 ;Plane-Nummer berechnen shl ah,cl mov dx,SC_INDEX ;Zugriff auf die zu bearbeitende mov al,SC_MAP_MASK ;Bit-Plane sichern out dx,ax ;-- Zähler für die Kopierschleife laden --------------------- mov dh,bfr.hoehe0 ;DH = zeilen mov dl,bfr.breite0 ;DL = Bytes mov bx,PIXX / 4 ;BX als Offset zur nächsten zeile sub bl,dl xor ch,ch ;Hi-Byte des Counters ist immer 0 push ds ;mov si,fr.bufptr0 ;DS:SI auf den Puffer setzen lds si,fr.bufptrl0 cmp bfr.bg,0 ;kein Hintergrund beachten? jne cv2 ;doch, andere Kopierroutine ;-- Kopierroutine für eine Bit-Plane, ohne Berücksichti- ---- ;-- gung des Hintergrundes cv1: mov cl,dl ;Anzahl Bytes nach CL rep movsb ;zeile kopieren add di,bx ;DI in nächste zeile dec dh ;noch eine zeile? jne cv1 ;Ja ---> weiter jmp short cvend ;Nein, Puffer volständig kopiert ;-- Kopierroutine für individuelle Bit-Planes unter Auswer- - ;-- tung des übergebenen Puffers cv2: mov cl,dl ;Anzahl Bytes nach CL cv3: lodsb ;Byte aus Puffer laden cmp al,bfr.hinter ;255 ;Hintergrund-Byte? je cv5 ;Ja ---> nicht mitkopieren stosb ;Nein, im Video-RAM ablegen loop cv3 ;nächstes Byte bearbeiten cv4: ;-- Zeiger auf Video-RAM in die nächste zeile schalten ----- add di,bx ;DI in nächste zeile dec dh ;noch eine zeile? jne cv2 ;Ja ---> weiter jmp short cvend ;Nein, Puffer volständig kopiert cv5: ;-- Hintergrund-Byte, nicht mitkopieren --------------------- inc di ;dieses Byte im VRAM nicht beschr. loop cv3 ;noch ein Byte in dieser zeile? jmp cv4 ;Nein ---> nächste zeile bearbeiten cvend: pop ds pop si ;Register wieder vom Stack holen pop di pop bp ret ;zurück zum Aufrufer _copybuf2plane endp ;----------------------------------------------------------------------- ;-- CopyPlane2Buf: Kopiert ein rechtecikgen Teil aus einer Bit-Plane in ;-- einen Puffer ;-- DeklAufruf von TP: CopyPlane2Buf( byte *bufptr, ;-- byte vonpage, ;-- int vonx, ;-- int vony, ;-- byte breite, ;-- byte hoehe ); _copyplane2buf proc far sfr1 struc ;Struktur zum Zugriff auf den Stack bp1 dw ? ;nimmt BP auf ret_adr1 dd ? ;Rücksprungadresse zum Aufrufer bufptrl1 dd ? ;Zeiger auf Puffer vonpage dw ? ;von Seite vonx dw ? ;von X-Ordinate vony dw ? ;von Y-Ordinate breite1 dw ? ;Breite des Bereichs in Punkten hoehe1 dw ? ;Höhe des Bereichs in Punktzeilen sfr1 ends ;Ende der Struktur fr equ [ bp - bp1 ] ;adr. die Elemente der Struktur bfr equ byte ptr [ bp - bp1 ] ;adr. Stack-Element als Byte push bp ;Adressierung der Parameter über mov bp,sp ;das BP-Register vorbereiten push di push si push ds ;DS sichern ;-- Segmentadresse für Zugriff auf Video-RAM berechnen ------ mov ah,0A0h ;ES auf Anfang VON-Seite cmp bfr.vonpage,0 ;ist es Seite 0? je cc0 ;Ja, AL schon o.k mov ah,0A8h ;Nein, Seite 1 bei A800h cc0: xor al,al ;Lo-Byte ist immer Null mov ds,ax ;-- Offset in die auszulesende Seite bilden ----------------- mov ax,PIXX / 4 ;SI auf Zielposition VON mul fr.vony mov si,fr.vonx mov cx,si ;Koordinate auch in CX merken shr si,1 shr si,1 add si,ax ;-- die zu adressierende Bit-Plane einstellen --------------- and cl,3 ;Bit-Maske für die zu adressierende mov ah,cl ;Map in AH berechnen mov al,GC_READ_MAP ;nach AL die Registernummer mov dx,GC_INDEX ;Indexadresse des Graphic-Ctrl laden out dx,ax ;Read-Map-Register laden ;-- Zähler für die Kopierschleife laden --------------------- mov dh,bfr.hoehe1 ;DH = zeilen mov dl,bfr.breite1 ;DL = Bytes mov bx,PIXX / 4 ;BX als Offset zur nächsten zeile sub bl,dl xor ch,ch ;Hi-Byte des Counters ist immer 0 les di,fr.bufptrl1 ;-- Kopierroutine für eine Bit-Plane, ohne Berücksichti- ---- ;-- gung des Hintergrundes cc1: mov cl,dl ;Anzahl Bytes nach CL rep movsb ;zeile kopieren add si,bx ;SI in nächste zeile dec dh ;noch eine zeile? jne cc1 ;Ja, weiter pop ds ;DS zurückholen pop si pop di pop bp ret ;zurück zum Aufurfer _copyplane2buf endp _cpscr2buf proc far sfr1 struc ;Struktur zum Zugriff auf den Stack bp1 dw ? ;nimmt BP auf ret_adr1 dd ? ;Rücksprungadresse zum Aufrufer bufptrl1 dd ? ;Zeiger auf Puffer vonpage dw ? ;von Seite vonx dw ? ;von X-Ordinate vony dw ? ;von Y-Ordinate breite1 dw ? ;Breite des Bereichs in Punkten hoehe1 dw ? ;Höhe des Bereichs in Punktzeilen sfr1 ends ;Ende der Struktur fr equ [ bp - bp1 ] ;adr. die Elemente der Struktur bfr equ byte ptr [ bp - bp1 ] ;adr. Stack-Element als Byte push bp ;Adressierung der Parameter über mov bp,sp ;das BP-Register vorbereiten push di push si push ds ;DS sichern ;-- Segmentadresse für Zugriff auf Video-RAM berechnen ------ mov ah,0A0h ;ES auf Anfang VON-Seite cmp bfr.vonpage,0 ;ist es Seite 0? je cpc0 ;Ja, AL schon o.k mov ah,0A8h ;Nein, Seite 1 bei A800h cpc0: xor al,al ;Lo-Byte ist immer Null mov ds,ax ;-- Offset in die auszulesende Seite bilden ----------------- mov ax,PIXX / 4 ;SI auf Zielposition VON mul fr.vony mov si,fr.vonx mov cx,si ;Koordinate auch in CX merken shr si,1 shr si,1 add si,ax ;-- die zu adressierende Bit-Plane einstellen --------------- and cl,3 ;Bit-Maske für die zu adressierende mov ah,cl ;Map in AH berechnen mov al,GC_READ_MAP ;nach AL die Registernummer mov dx,GC_INDEX ;Indexadresse des Graphic-Ctrl laden out dx,ax ;Read-Map-Register laden ;-- Zähler für die Kopierschleife laden --------------------- mov dx,fr.hoehe1 ;DH = zeilen les di,fr.bufptrl1 ;-- Kopierroutine für eine Bit-Plane, ohne Berücksichti- ---- ;-- gung des Hintergrundes cpc1: mov cx,fr.breite1 ;Dx = Bytes ;mov cl,dl ;Anzahl Bytes nach CL rep movsb ;zeile kopieren dec dx ;noch eine zeile? jne cpc1 ;Ja, weiter pop ds ;DS zurückholen pop si pop di pop bp ret ;zurück zum Aufurfer _cpscr2buf endp _cpbuf2scr proc far sfr0 struc ;Struktur zum Zugriff auf den Stack bp0 dw ? ;nimmt BP auf ret_adr0 dd ? ;Rücksprungadresse zum Aufrufer bufptrl0 dd ? ;Zeiger auf Puffer nachpage dw ? ;nach Seite nachx dw ? ;nach X-Ordinate nachy dw ? ;nach Y-Ordinate breite0 dw ? ;Breite hoehe0 dw ? ;Höhe des Bereichs sfr0 ends ;Ende der Struktur fr equ [ bp - bp0 ] ;adr. die Elemente der Struktur bfr equ byte ptr [ bp - bp0 ] ;adr. Stack-Element als Byte push bp ;Adressierung der Parameter über mov bp,sp ;das BP-Register vorbereiten push di push si ;-- Segmentadresse für Zugriff auf Video-RAM berechnen ------ mov ah,0A0h ;ES auf Anfang NACH-Seite cmp bfr.nachpage,0 ;ist es Seite 0? je cbv0 ;Ja, AL schon o.k mov ah,0A8h ;Nein, Seite 1 bei A800h cbv0: xor al,al ;Lo-Byte ist immer Null mov es,ax ;-- Offset für Zielposition in Page berechnen --------------- mov ax,PIXX / 4 ;DI auf Zielposition NACH mul fr.nachy mov di,fr.nachx mov cx,di ;X-Koordinate für Plane-Berechnung shr di,1 ;merken shr di,1 add di,ax ;-- die zu adressierende Bit-Plane einstellen --------------- mov ah,1 ;Plane-Nummer muß als Bit-Maske vorl. and cl,3 ;Plane-Nummer berechnen shl ah,cl mov dx,SC_INDEX ;Zugriff auf die zu bearbeitende mov al,SC_MAP_MASK ;Bit-Plane sichern out dx,ax ;-- Zähler für die Kopierschleife laden --------------------- mov dx,fr.hoehe0 ;DH = zeilen push ds lds si,fr.bufptrl0 ;-- Kopierroutine für eine Bit-Plane, ohne Berücksichti- ---- ;-- gung des Hintergrundes cbv1: ;mov cl,dl ;Anzahl Bytes nach CL mov cx,fr.breite0 ;DL = Bytes rep movsb ;zeile kopieren dec dx ;noch eine zeile? jne cbv1 ;Ja ---> weiter ;-- Kopierroutine für individuelle Bit-Planes unter Auswer- - ;-- tung des übergebenen Puffers pop ds pop si ;Register wieder vom Stack holen pop di pop bp ret ;zurück zum Aufrufer _cpbuf2scr endp _cpback2scr proc far sfr0 struc ;Struktur zum Zugriff auf den Stack bp0 dw ? ;nimmt BP auf ret_adr0 dd ? ;Rücksprungadresse zum Aufrufer b_seite dw ? ;nach Seite Back dd ? ;Zeiger auf Puffer b_x dw ? ;nach X-Ordinate b_y dw ? ;nach Y-Ordinate b_breite dw ? ;Breite b_hoehe dw ? ;Höhe des Bereichs sfr0 ends ;Ende der Struktur fr equ [ bp - bp0 ] ;adr. die Elemente der Struktur bfr equ byte ptr [ bp - bp0 ] ;adr. Stack-Element als Byte push bp ;Adressierung der Parameter über mov bp,sp ;das BP-Register vorbereiten push di push si push ds ;-- Segmentadresse für Zugriff auf Video-RAM berechnen ------ mov ah,0A0h ;ES auf Anfang NACH-Seite cmp bfr.b_seite,0 ;ist es Seite 0? je b_cv0 ;Ja, AL schon o.k mov ah,0A8h ;Nein, Seite 1 bei A800h b_cv0: xor al,al ;Lo-Byte ist immer Null mov es,ax ;-- Offset für Zielposition in Page berechnen --------------- mov ax,PIXX / 4 ;DI auf Zielposition NACH mov di,fr.b_y mul fr.b_y mov di,fr.b_x mov cx,di ;X-Koordinate für Plane-Berechnung shr di,1 ;merken shr di,1 add di,ax ;-- die zu adressierende Bit-Plane einstellen --------------- mov ah,1 ;Plane-Nummer muß als Bit-Maske vorl. and cl,3 ;Plane-Nummer berechnen shl ah,cl mov dx,SC_INDEX ;Zugriff auf die zu bearbeitende mov al,SC_MAP_MASK ;Bit-Plane sichern out dx,ax mov ax,PIXX/4 ;SI auf Zielposition VON mul fr.b_y mov si,fr.b_x shr si,1 shr si,1 add ax,si lds si,fr.Back add si,ax ;-- Zähler für die Kopierschleife laden --------------------- mov dh,bfr.b_hoehe ;DH = zeilen mov dl,bfr.b_breite ;DL = Bytes mov bx,PIXX / 4 ;BX als Offset zur nächsten zeile sub bl,dl xor ch,ch ;Hi-Byte des Counters ist immer 0 ;-- Kopierroutine für eine Bit-Plane, ohne Berücksichti- ---- ;-- gung des Hintergrundes cpbbc1: mov cl,dl ;Anzahl Bytes nach CL rep movsb ;zeile kopieren add si,bx ;SI in nächste zeile add di,bx ;SI in nächste zeile dec dh ;noch eine zeile? jne cpbbc1 ;Ja, weiter pop ds pop si ;Register wieder vom Stack holen pop di pop bp ret ;zurück zum Aufrufer _cpback2scr endp _cpbuf2back proc far sfr0 struc ;Struktur zum Zugriff auf den Stack bp0 dw ? ;nimmt BP auf ret_adr0 dd ? ;Rücksprungadresse zum Aufrufer back_ptr dd ? buf_ptr dd ? ;Zeiger auf Puffer bb_x dw ? ;nach X-Ordinate bb_y dw ? ;nach Y-Ordinate bb_breite dw ? ;Breite bb_hoehe dw ? ;Höhe des Bereichs sfr0 ends ;Ende der Struktur fr equ [ bp - bp0 ] ;adr. die Elemente der Struktur bfr equ byte ptr [ bp - bp0 ] ;adr. Stack-Element als Byte push bp ;Adressierung der Parameter über mov bp,sp ;das BP-Register vorbereiten push di push si mov ax,PIXX/4 ;SI auf Zielposition VON mul fr.bb_y mov di,fr.bb_x shr di,1 shr di,1 add ax,di les di,fr.back_ptr add di,ax ;-- Zähler für die Kopierschleife laden --------------------- mov dh,bfr.bb_hoehe ;DH = zeilen mov dl,bfr.bb_breite ;DL = Bytes mov bx,PIXX / 4 ;BX als Offset zur nächsten zeile sub bl,dl xor ch,ch ;Hi-Byte des Counters ist immer 0 push ds lds si,fr.buf_ptr ;-- Kopierroutine für eine Bit-Plane, ohne Berücksichti- ---- ;-- gung des Hintergrundes cbbv1: mov cl,dl ;Anzahl Bytes nach CL rep movsb ;zeile kopieren add di,bx ;DI in nächste zeile dec dh ;noch eine zeile? jne cbbv1 ;Ja ---> weiter pop ds pop si ;Register wieder vom Stack holen pop di pop bp ret ;zurück zum Aufrufer _cpbuf2back endp _stick proc far ; Es wird davon ausgegangen, dass Joystick angeschlossen ist, ; sollte keiner angeschlossen werden, verfaengt sich die Routine in eine ; Endlosschleife ... ; Funktion fuer Joystick 1 !!! sfr0 struc ;Struktur zum Zugriff auf den Stack bp0 dw ? ;nimmt BP auf ret_adr0 dd ? ;Rücksprungadresse zum Aufrufer j_x dd ? j_y dd ? sfr0 ends ;Ende der Struktur fr equ [ bp - bp0 ] ;adr. die Elemente der Struktur bfr equ byte ptr [ bp - bp0 ] ;adr. Stack-Element als Byte push bp ;Adressierung der Parameter über mov bp,sp ;das BP-Register vorbereiten push di mov xx,0 mov yy,0 mov dx,201h ; Portadresse bei AT's des Gameportes out dx,al ; irgendwas dahin schicken, um Kippstufe zu starten jmp short check_1 x_inc: inc xx test al,02h ; Bit 2 ist Y Pos von Joy 1 jz check_1 y_inc: inc yy check_1: in al,dx ; Status des Portes lesen test al,01h ; Bit 1 ist X Pos von Joy 1 jnz x_inc test al,02h ; Bit 2 ist Y Pos von Joy 1 jnz y_inc les di,fr.j_x mov ax,[xx] mov es:[di],ax mov ax,[yy] les di,fr.j_y mov es:[di],ax pop di pop bp ret ;zurück zum Aufrufer _stick endp ;SYNC_DISPLAY ;============ ; ; Pauses the computer until the next Vertical Retrace starts ; ; ENTRY: No Parameters are passed ; ; EXIT: No meaningful values returned ; _SYNC_DISPLAY PROC FAR MOV DX, INPUT_1 ; Input Status #1 Register ; Wait for any current retrace to end @SD_WAIT0: IN AL, DX ; Get VGA status AND AL, VERT_RETRACE ; In Display mode yet? JNZ @SD_WAIT0 ; If Not, wait for it ; Wait for the start of the next vertical retrace @SD_WAIT1: IN AL, DX ; Get VGA status AND AL, VERT_RETRACE ; Vertical Retrace Start? JZ @SD_WAIT1 ; If Not, wait for it RET ; Exit & Clean Up Stack _SYNC_DISPLAY ENDP end