X-Git-Url: http://4ch.mooo.com/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fmodex16.c;h=810fc73beb5e0106b7e630975c117b7d57a301c9;hb=90714393d00c5d9990576aae8dc917082bb97333;hp=97b26de3c03b182f0ab1cab6ea9dcccf21f0d115;hpb=490586ef0c0a9e48017dc869f38a87d65691697c;p=16.git

diff --git a/src/lib/modex16.c b/src/lib/modex16.c
index 97b26de3..810fc73b 100755
--- a/src/lib/modex16.c
+++ b/src/lib/modex16.c
@@ -335,7 +335,7 @@ modexPanPage(page_t *page, int dx, int dy) {
 
 void
 modexSelectPlane(byte plane) {
-    outp(SC_INDEX, MAP_MASK);          /* select plane */
+    outp(SC_INDEX, MAP_MASK);	  /* select plane */
     outp(SC_DATA,  plane);
 }
 
@@ -358,93 +358,92 @@ modexClearRegion(page_t *page, int x, int y, int w, int h, byte  color) {
     }
 
     __asm {
-                MOV AX, SCREEN_SEG      ; go to the VGA memory
-                MOV ES, AX
-                MOV DI, poffset         ; go to the first pixel
-                MOV DX, SC_INDEX        ; point to the map mask
-                MOV AL, MAP_MASK
-                OUT DX, AL
-                INC DX
-                MOV AL, color           ; get ready to write colors
-        SCAN_START:
-                MOV CX, scanCount       ; count the line
-                MOV BL, AL              ; remember color
-                MOV AL, left            ; do the left clip
-                OUT DX, AL              ; set the left clip
-                MOV AL, BL              ; restore color
-                STOSB                   ; write the color
-                DEC CX
-                JZ SCAN_DONE            ; handle 1 group stuff
-
-                ;-- write the main body of the scanline
-                MOV BL, AL              ; remember color
-                MOV AL, 0x0f            ; write to all pixels
-                OUT DX, AL
-                MOV AL, BL              ; restore color
-                REP STOSB               ; write the color
-        SCAN_DONE:
-                MOV BL, AL              ; remeber color
-                MOV AL, right
-                OUT DX, AL              ; do the right clip
-                MOV AL, BL              ; restore color
-                STOSB                   ; write pixel
-                ADD DI, nextRow         ; go to the next row
-                DEC h
-                JNZ SCAN_START
+		MOV AX, SCREEN_SEG      ; go to the VGA memory
+		MOV ES, AX
+		MOV DI, poffset	 ; go to the first pixel
+		MOV DX, SC_INDEX	; point to the map mask
+		MOV AL, MAP_MASK
+		OUT DX, AL
+		INC DX
+		MOV AL, color	   ; get ready to write colors
+	SCAN_START:
+		MOV CX, scanCount       ; count the line
+		MOV BL, AL	      ; remember color
+		MOV AL, left	    ; do the left clip
+		OUT DX, AL	      ; set the left clip
+		MOV AL, BL	      ; restore color
+		STOSB		   ; write the color
+		DEC CX
+		JZ SCAN_DONE	    ; handle 1 group stuff
+
+		;-- write the main body of the scanline
+		MOV BL, AL	      ; remember color
+		MOV AL, 0x0f	    ; write to all pixels
+		OUT DX, AL
+		MOV AL, BL	      ; restore color
+		REP STOSB	       ; write the color
+	SCAN_DONE:
+		MOV BL, AL	      ; remeber color
+		MOV AL, right
+		OUT DX, AL	      ; do the right clip
+		MOV AL, BL	      ; restore color
+		STOSB		   ; write pixel
+		ADD DI, nextRow	 ; go to the next row
+		DEC h
+		JNZ SCAN_START
     }
 }
 
-//TODO!
-void
-modexDrawPBufregion(page_t *page, int x, int y, int sx, int sy, int fx, int fy planar_buf_t *p, boolean sprite)
+//TODO! ADD CLIPPING!!
+//memory management needs to be added
+//void
+//modexDrawBmpRegion	(page_t *page, int x, int y, int rx, int ry, int rw, int rh, bitmap_t *bmp)
+void modexDrawPBufRegion	(page_t *page, int x, int y, int rx, int ry, int rw, int rh, planar_buf_t *p, boolean sprite)
 {
-	int plane;
-	int px, py, i;
-// 	byte near *buff;
-	px=x;
-	py=y;
-// 	buff = _nmalloc(p->pwidth+1);
-	// TODO Make this fast.  It's SLOOOOOOW
-// 	for(plane=0; plane < 4; plane++) {
-// 		i=0;
-// 		modexSelectPlane(PLANE(plane+x));
-// 		for(px = plane; px < p->width; px+=4) {
-// 			offset=px;
-// 			for(py=0; py<p->height/2; py++) {
-// 				//SELECT_ALL_PLANES();
-// 				if(!sprite || p->plane[offset])
-// 					page->data = &(p->plane[offset][i++]);
-// 				offset+=p->width;
-// 				offset++;
-// 			}
-// 		}
-// 	}
+	sword plane;
+	int i;
+	const int px=x;//-page->dx;
+	const int py=y;//-page->dy;
+	#define PEEE ((rw)/4)-rx
+	//-(rx/4)
+	#define PEEEE ((p->pwidth)*(ry))
+	//y=py;
+	//x=px;
+	//printf("%d,%d p(%d,%d) r(%d,%d) rwh(%d,%d)\n", x, y, px, py, rx, ry, rw, rh);
 	for(plane=0; plane < 4; plane++) {
-		i=0;
+		i=PEEE+PEEEE;
+		//printf("PEEE=%d ", PEEE);
+		//printf("PEEEE=%d ", PEEEE);
+		//printf("i=%d\n", i);
 		modexSelectPlane(PLANE(plane+x));
-		for(; y < py+p->height; y++) {
+		for(; y < py+rh; y++) {
 			//for(px=0; px < p->width; px++) {
 				//printf("%02X ", (int) p->plane[plane][i++]);
-// 				_fmemcpy(buff, &(p->plane[plane][i+=p->pwidth]), p->pwidth);
-// 				printf("buff %u==%s\n", y, *buff);
-// 				_fmemcpy(page->data + (((page->width/4) * (y+page->dy)) + ((x+page->dx) / 4)), buff, p->pwidth);
-				_fmemcpy(page->data + (((page->width/4) * (y+page->dy)) + ((x+page->dx) / 4)), &(p->plane[plane][i+=p->pwidth]), p->pwidth);
+//			      _fmemcpy(buff, &(p->plane[plane][i+=p->pwidth]), p->pwidth);
+//			      printf("buff %u==%s\n", y, *buff);
+				_fmemcpy(page->data + (((page->width/4) * y) + (x / 4)), &(p->plane[plane][i+=p->pwidth]), (rw/4));
 			//}
+			//if(plane==3) IN_Ack();
 		}
+		/*printf("y%d=%d ", plane, y);
+		if(plane==3) printf("y%d=%d\n", plane, y);*/
 		x=px;
 		y=py;
-	}
-// 	_nfree(buff);
+		}
 }
 
+
+/*temp*/
 void
-DrawPBuf(page_t *page, int x, int y, planar_buf_t *p, boolean sprite)
+modexDrawPBuf(page_t *page, int x, int y, planar_buf_t *p, boolean sprite)
 {
 	int plane;
-	int px, py, i;
+	int i;
 // 	byte near *buff;
-	px=x;
-	py=y;
+	const int px=x+page->dx;
+	const int py=y+page->dy;
+	x=px;
+	y=py;
 // 	buff = _nmalloc(p->pwidth+1);
 	// TODO Make this fast.  It's SLOOOOOOW
 // 	for(plane=0; plane < 4; plane++) {
@@ -470,7 +469,7 @@ DrawPBuf(page_t *page, int x, int y, planar_buf_t *p, boolean sprite)
 // 				_fmemcpy(buff, &(p->plane[plane][i+=p->pwidth]), p->pwidth);
 // 				printf("buff %u==%s\n", y, *buff);
 // 				_fmemcpy(page->data + (((page->width/4) * (y+page->dy)) + ((x+page->dx) / 4)), buff, p->pwidth);
-				_fmemcpy(page->data + (((page->width/4) * (y+page->dy)) + ((x+page->dx) / 4)), &(p->plane[plane][i+=p->pwidth]), p->pwidth);
+				_fmemcpy(page->data + (((page->width/4) * y) + (x / 4)), &(p->plane[plane][i+=p->pwidth]), p->pwidth);
 			//}
 		}
 		x=px;
@@ -500,29 +499,7 @@ oldDrawBmp(byte far* page, int x, int y, bitmap_t *bmp, byte sprite)
 	}
 }
 
-void
-CDrawBmp(byte far* vgamem, page_t* page, int x, int y, bitmap_t *bmp, byte sprite)
-{
-	byte plane;
-	word px, py;
-	word offset=0;
-
-
-	/* TODO Make this fast.  It's SLOOOOOOW */
-	for(plane=0; plane < 4; plane++) {
-		modexSelectPlane(PLANE(plane+x));
-		for(px = plane; px < bmp->width; px+=4) {
-			offset=px;
-			for(py=0; py<bmp->height; py++) {
-			if(!sprite || bmp->data[offset])
-				//modexputPixel(page, x+px, y+py, bmp->data[offset]);
-				vgamem[PAGE_OFFSET(x+px, y+py)] = bmp->data[offset];
-			offset+=bmp->width;
-			}
-		}
-	}
-}
-
+//* normal versions *//
 void
 modexDrawBmp(page_t *page, int x, int y, bitmap_t *bmp) {
     /* draw the region (the entire freakin bitmap) */
@@ -531,229 +508,286 @@ modexDrawBmp(page_t *page, int x, int y, bitmap_t *bmp) {
 
 void
 modexDrawBmpRegion(page_t *page, int x, int y,
-                   int rx, int ry, int rw, int rh, bitmap_t *bmp) {
-    word poffset = (word) page->data  + y*(page->width/4) + x/4;
-    byte far *data = bmp->data;//+bmp->offset;
-    word bmpOffset = (word) data + ry * bmp->width + rx;
-    word width = rw;
-    word height = rh;
-    byte plane = 1 << ((byte) x & 0x03);
-    word scanCount = width/4 + (width%4 ? 1 :0);
-    word nextPageRow = page->width/4 - scanCount;
-    word nextBmpRow = (word) bmp->width - width;
-    word rowCounter;
-    byte planeCounter = 4;
-
-/*	printf("bmp->data=%Fp\n",bmp->data);
-	printf("*bmp->data=%Fp\n",*(bmp->data));
-	printf("&bmp->data=%Fp\n",&(bmp->data));*/
-
-        //code is a bit slow here
+		   int rx, int ry, int rw, int rh, bitmap_t *bmp) {
+	word poffset = (word) page->data  + y*(page->width/4) + x/4;
+	byte *data = bmp->data;//+bmp->offset;
+	word bmpOffset = (word) data + ry * bmp->width + rx;
+	word width = rw;
+	word height = rh;
+	byte plane = 1 << ((byte) x & 0x03);
+	word scanCount = width/4 + (width%4 ? 1 :0);
+	word nextPageRow = page->width/4 - scanCount;
+	word nextBmpRow = (word) bmp->width - width;
+	word rowCounter;
+	byte planeCounter = 4;
+
     __asm {
-                MOV AX, SCREEN_SEG      ; go to the VGA memory
-                MOV ES, AX
-
-                MOV DX, SC_INDEX        ; point at the map mask register
-                MOV AL, MAP_MASK        ;
-                OUT DX, AL              ;
-
-        PLANE_LOOP:
-                MOV DX, SC_DATA         ; select the current plane
-                MOV AL, plane           ;
-                OUT DX, AL              ;
-
-                ;-- begin plane painting
-                MOV AX, height          ; start the row counter
-                MOV rowCounter, AX      ;
-                MOV DI, poffset         ; go to the first pixel
-                MOV SI, bmpOffset       ; go to the bmp pixel
-        ROW_LOOP:
-                MOV CX, width           ; count the columns
-        SCAN_LOOP:
-                MOVSB                   ; copy the pixel
-                SUB CX, 3               ; we skip the next 3
-                ADD SI, 3               ; skip the bmp pixels
-                LOOP SCAN_LOOP          ; finish the scan
-
-                MOV AX, nextPageRow
-                ADD DI, AX              ; go to the next row on screen
-                MOV AX, nextBmpRow
-                ADD SI, AX              ; go to the next row on bmp
-
-                DEC rowCounter
-                JNZ ROW_LOOP            ; do all the rows
-                ;-- end plane painting
-
-                MOV AL, plane           ; advance to the next plane
-                SHL AL, 1               ;
-                AND AL, 0x0f            ; mask the plane properly
-                MOV plane, AL           ; store the plane
-
-                INC bmpOffset           ; start bmp at the right spot
-
-                DEC planeCounter
-                JNZ PLANE_LOOP          ; do all 4 planes
+		MOV AX, SCREEN_SEG      ; go to the VGA memory
+		MOV ES, AX
+
+		MOV DX, SC_INDEX	; point at the map mask register
+		MOV AL, MAP_MASK	;
+		OUT DX, AL	      ;
+
+	PLANE_LOOP:
+		MOV DX, SC_DATA	 ; select the current plane
+		MOV AL, plane	   ;
+		OUT DX, AL	      ;
+
+		;-- begin plane painting
+		MOV AX, height	  ; start the row counter
+		MOV rowCounter, AX      ;
+		MOV DI, poffset	 ; go to the first pixel
+		MOV SI, bmpOffset       ; go to the bmp pixel
+	ROW_LOOP:
+		MOV CX, width	   ; count the columns
+	SCAN_LOOP:
+		MOVSB		   ; copy the pixel
+		SUB CX, 3	       ; we skip the next 3
+		ADD SI, 3	       ; skip the bmp pixels
+		LOOP SCAN_LOOP	  ; finish the scan
+
+		MOV AX, nextPageRow
+		ADD DI, AX	      ; go to the next row on screen
+		MOV AX, nextBmpRow
+		ADD SI, AX	      ; go to the next row on bmp
+
+		DEC rowCounter
+		JNZ ROW_LOOP	    ; do all the rows
+		;-- end plane painting
+		MOV AL, plane	   ; advance to the next plane
+		SHL AL, 1	       ;
+		AND AL, 0x0f	    ; mask the plane properly
+		MOV plane, AL	   ; store the plane
+
+		INC bmpOffset	   ; start bmp at the right spot
+
+		DEC planeCounter
+		JNZ PLANE_LOOP	  ; do all 4 planes
     }
 }
 
-void
-modexDrawPlanarBuf(page_t *page, int x, int y, planar_buf_t *bmp) {
-    /* TODO - adapt from test code */
-        int plane;
-        for(plane=0; plane < 4; plane++)
-        {
-                //fack
-        }
-}
-
-
 void
 modexDrawSprite(page_t *page, int x, int y, bitmap_t *bmp) {
     /* draw the whole sprite */
     modexDrawSpriteRegion(page, x, y, 0, 0, bmp->width, bmp->height, bmp);
 }
 
-/*void
+void
 modexDrawSpriteRegion(page_t *page, int x, int y,
-                      int rx, int ry, int rw, int rh, bitmap_t *bmp) {
-    word poffset = (word)page->data + y*(page->width/4) + x/4;
-    byte *data = bmp->data;//+bmp->offset;
-    word bmpOffset = (word) data + ry * bmp->width + rx;
-    word width = rw;
-    word height = rh;
-    byte plane = 1 << ((byte) x & 0x03);
-    word scanCount = width/4 + (width%4 ? 1 :0);
-    word nextPageRow = page->width/4 - scanCount;
-    word nextBmpRow = (word) bmp->width - width;
-    word rowCounter;
-    byte planeCounter = 4;
+		      int rx, int ry, int rw, int rh, bitmap_t *bmp) {
+	word poffset = (word)page->data + y*(page->width/4) + x/4;
+	byte *data = bmp->data;//+bmp->offset;
+	word bmpOffset = (word) data + ry * bmp->width + rx;
+	word width = rw;
+	word height = rh;
+	byte plane = 1 << ((byte) x & 0x03);
+	word scanCount = width/4 + (width%4 ? 1 :0);
+	word nextPageRow = page->width/4 - scanCount;
+	word nextBmpRow = (word) bmp->width - width;
+	word rowCounter;
+	byte planeCounter = 4;
 
     __asm {
-                MOV AX, SCREEN_SEG      ; go to the VGA memory
-                MOV ES, AX
-
-                MOV DX, SC_INDEX        ; point at the map mask register
-                MOV AL, MAP_MASK        ;
-                OUT DX, AL              ;
-
-        PLANE_LOOP:
-                MOV DX, SC_DATA         ; select the current plane
-                MOV AL, plane           ;
-                OUT DX, AL              ;
-
-                ;-- begin plane painting
-                MOV AX, height          ; start the row counter
-                MOV rowCounter, AX      ;
-                MOV DI, poffset         ; go to the first pixel
-                MOV SI, bmpOffset       ; go to the bmp pixel
-        ROW_LOOP:
-                MOV CX, width           ; count the columns
-        SCAN_LOOP:
-                LODSB
-                DEC SI
-                CMP AL, 0
-                JNE DRAW_PIXEL          ; draw non-zero pixels
-
-                INC DI                  ; skip the transparent pixel
-                ADD SI, 1
-                JMP NEXT_PIXEL
-        DRAW_PIXEL:
-                MOVSB                   ; copy the pixel
-        NEXT_PIXEL:
-                SUB CX, 3               ; we skip the next 3
-                ADD SI, 3               ; skip the bmp pixels
-                LOOP SCAN_LOOP          ; finish the scan
-
-                MOV AX, nextPageRow
-                ADD DI, AX              ; go to the next row on screen
-                MOV AX, nextBmpRow
-                ADD SI, AX              ; go to the next row on bmp
-
-                DEC rowCounter
-                JNZ ROW_LOOP            ; do all the rows
-                ;-- end plane painting
-
-                MOV AL, plane           ; advance to the next plane
-                SHL AL, 1               ;
-                AND AL, 0x0f            ; mask the plane properly
-                MOV plane, AL           ; store the plane
-
-                INC bmpOffset           ; start bmp at the right spot
-
-                DEC planeCounter
-                JNZ PLANE_LOOP          ; do all 4 planes
+		MOV AX, SCREEN_SEG      ; go to the VGA memory
+		MOV ES, AX
+
+		MOV DX, SC_INDEX	; point at the map mask register
+		MOV AL, MAP_MASK	;
+		OUT DX, AL	      ;
+
+	PLANE_LOOP:
+		MOV DX, SC_DATA	 ; select the current plane
+		MOV AL, plane	   ;
+		OUT DX, AL	      ;
+
+		;-- begin plane painting
+		MOV AX, height	  ; start the row counter
+		MOV rowCounter, AX      ;
+		MOV DI, poffset	 ; go to the first pixel
+		MOV SI, bmpOffset       ; go to the bmp pixel
+	ROW_LOOP:
+		MOV CX, width	   ; count the columns
+	SCAN_LOOP:
+		LODSB
+		DEC SI
+		CMP AL, 0
+		JNE DRAW_PIXEL	  ; draw non-zero pixels
+
+		INC DI		  ; skip the transparent pixel
+		ADD SI, 1
+		JMP NEXT_PIXEL
+	DRAW_PIXEL:
+		MOVSB		   ; copy the pixel
+	NEXT_PIXEL:
+		SUB CX, 3	       ; we skip the next 3
+		ADD SI, 3	       ; skip the bmp pixels
+		LOOP SCAN_LOOP	  ; finish the scan
+
+		MOV AX, nextPageRow
+		ADD DI, AX	      ; go to the next row on screen
+		MOV AX, nextBmpRow
+		ADD SI, AX	      ; go to the next row on bmp
+
+		DEC rowCounter
+		JNZ ROW_LOOP	    ; do all the rows
+		;-- end plane painting
+
+		MOV AL, plane	   ; advance to the next plane
+		SHL AL, 1	       ;
+		AND AL, 0x0f	    ; mask the plane properly
+		MOV plane, AL	   ; store the plane
+
+		INC bmpOffset	   ; start bmp at the right spot
+
+		DEC planeCounter
+		JNZ PLANE_LOOP	  ; do all 4 planes
     }
-}//backup!*/
+}
 
+//* planar buffer versions *//
 void
-modexDrawSpriteRegion(page_t *page, int x, int y,
-                      int rx, int ry, int rw, int rh, bitmap_t *bmp) {
-    word poffset = (word)page->data + y*(page->width/4) + x/4;
-    byte huge *data = bmp->data;//+bmp->offset;
-    word bmpOffset = (word) data + ry * bmp->width + rx;
-    word width = rw;
-    word height = rh;
-    byte plane = 1 << ((byte) x & 0x03);
-    word scanCount = width/4 + (width%4 ? 1 :0);
-    word nextPageRow = page->width/4 - scanCount;
-    word nextBmpRow = (word) bmp->width - width;
-    word rowCounter;
-    byte planeCounter = 4;
+modexDrawBmpPBuf(page_t *page, int x, int y, planar_buf_t *bmp) {
+    /* draw the region (the entire freakin bitmap) */
+    modexDrawBmpPBufRegion(page, x, y, 0, 0, bmp->width, bmp->height, bmp);
+}
+
+void
+modexDrawBmpPBufRegion(page_t *page, int x, int y,
+		   int rx, int ry, int rw, int rh, planar_buf_t *bmp) {
+	word poffset = (word) page->data  + y*(page->width/4) + x/4;
+	byte *data = *bmp->plane;//+bmp->offset;
+	word bmpOffset = (word) data + ry * bmp->width + rx;
+	word width = rw/4;
+	word height = rh/4;
+	byte plane = 1 << ((byte) x & 0x03);
+	word scanCount = width/4 + (width%4 ? 1 :0);
+	word nextPageRow = page->width/4 - scanCount;
+	word nextBmpRow = (word) bmp->width - width;
+	word rowCounter;
+	byte planeCounter = 4;
+
+    __asm {
+		MOV AX, SCREEN_SEG      ; go to the VGA memory
+		MOV ES, AX
+
+		MOV DX, SC_INDEX	; point at the map mask register
+		MOV AL, MAP_MASK	;
+		OUT DX, AL	      ;
+
+	PLANE_LOOP:
+		MOV DX, SC_DATA	 ; select the current plane
+		MOV AL, plane	   ;
+		OUT DX, AL	      ;
+
+		;-- begin plane painting
+		MOV AX, height	  ; start the row counter
+		MOV rowCounter, AX      ;
+		MOV DI, poffset	 ; go to the first pixel
+		MOV SI, bmpOffset       ; go to the bmp pixel
+	ROW_LOOP:
+		MOV CX, width	   ; count the columns
+	SCAN_LOOP:
+		MOVSB		   ; copy the pixel
+		SUB CX, 3	       ; we skip the next 3
+		ADD SI, 3	       ; skip the bmp pixels
+		LOOP SCAN_LOOP	  ; finish the scan
+
+		MOV AX, nextPageRow
+		ADD DI, AX	      ; go to the next row on screen
+		MOV AX, nextBmpRow
+		ADD SI, AX	      ; go to the next row on bmp
+
+		DEC rowCounter
+		JNZ ROW_LOOP	    ; do all the rows
+		;-- end plane painting
+		MOV AL, plane	   ; advance to the next plane
+		SHL AL, 1	       ;
+		AND AL, 0x0f	    ; mask the plane properly
+		MOV plane, AL	   ; store the plane
+
+		INC bmpOffset	   ; start bmp at the right spot
+
+		DEC planeCounter
+		JNZ PLANE_LOOP	  ; do all 4 planes
+    }
+}
+
+void
+modexDrawSpritePBuf(page_t *page, int x, int y, planar_buf_t *bmp) {
+    /* draw the whole sprite */
+    modexDrawSpritePBufRegion(page, x, y, 0, 0, bmp->width, bmp->height, bmp);
+}
+
+void
+modexDrawSpritePBufRegion(page_t *page, int x, int y,
+		      int rx, int ry, int rw, int rh, planar_buf_t *bmp) {
+	word poffset = (word)page->data + y*(page->width/4) + x/4;
+	byte *data = *bmp->plane;//+bmp->offset;
+	word bmpOffset = (word) data + ry * bmp->width + rx;
+	word width = rw/4;
+	word height = rh/4;
+	byte plane = 1 << ((byte) x & 0x03);
+	word scanCount = width/4 + (width%4 ? 1 :0);
+	word nextPageRow = page->width/4 - scanCount;
+	word nextBmpRow = (word) bmp->width - width;
+	word rowCounter;
+	byte planeCounter = 4;
 
     __asm {
-                MOV AX, SCREEN_SEG      ; go to the VGA memory
-                MOV ES, AX
-
-                MOV DX, SC_INDEX        ; point at the map mask register
-                MOV AL, MAP_MASK        ;
-                OUT DX, AL              ;
-
-        PLANE_LOOP:
-                MOV DX, SC_DATA         ; select the current plane
-                MOV AL, plane           ;
-                OUT DX, AL              ;
-
-                ;-- begin plane painting
-                MOV AX, height          ; start the row counter
-                MOV rowCounter, AX      ;
-                MOV DI, poffset         ; go to the first pixel
-                MOV SI, bmpOffset       ; go to the bmp pixel
-        ROW_LOOP:
-                MOV CX, width           ; count the columns
-        SCAN_LOOP:
-                LODSB
-                DEC SI
-                CMP AL, 0
-                JNE DRAW_PIXEL          ; draw non-zero pixels
-
-                INC DI                  ; skip the transparent pixel
-                ADD SI, 1
-                JMP NEXT_PIXEL
-        DRAW_PIXEL:
-                MOVSB                   ; copy the pixel
-        NEXT_PIXEL:
-                SUB CX, 3               ; we skip the next 3
-                ADD SI, 3               ; skip the bmp pixels
-                LOOP SCAN_LOOP          ; finish the scan
-
-                MOV AX, nextPageRow
-                ADD DI, AX              ; go to the next row on screen
-                MOV AX, nextBmpRow
-                ADD SI, AX              ; go to the next row on bmp
-
-                DEC rowCounter
-                JNZ ROW_LOOP            ; do all the rows
-                ;-- end plane painting
-
-                MOV AL, plane           ; advance to the next plane
-                SHL AL, 1               ;
-                AND AL, 0x0f            ; mask the plane properly
-                MOV plane, AL           ; store the plane
-
-                INC bmpOffset           ; start bmp at the right spot
-
-                DEC planeCounter
-                JNZ PLANE_LOOP          ; do all 4 planes
+		MOV AX, SCREEN_SEG      ; go to the VGA memory
+		MOV ES, AX
+
+		MOV DX, SC_INDEX	; point at the map mask register
+		MOV AL, MAP_MASK	;
+		OUT DX, AL	      ;
+
+	PLANE_LOOP:
+		MOV DX, SC_DATA	 ; select the current plane
+		MOV AL, plane	   ;
+		OUT DX, AL	      ;
+
+		;-- begin plane painting
+		MOV AX, height	  ; start the row counter
+		MOV rowCounter, AX      ;
+		MOV DI, poffset	 ; go to the first pixel
+		MOV SI, bmpOffset       ; go to the bmp pixel
+	ROW_LOOP:
+		MOV CX, width	   ; count the columns
+	SCAN_LOOP:
+		LODSB
+		DEC SI
+		CMP AL, 0
+		JNE DRAW_PIXEL	  ; draw non-zero pixels
+
+		INC DI		  ; skip the transparent pixel
+		ADD SI, 1
+		JMP NEXT_PIXEL
+	DRAW_PIXEL:
+		MOVSB		   ; copy the pixel
+	NEXT_PIXEL:
+		SUB CX, 3	       ; we skip the next 3
+		ADD SI, 3	       ; skip the bmp pixels
+		LOOP SCAN_LOOP	  ; finish the scan
+
+		MOV AX, nextPageRow
+		ADD DI, AX	      ; go to the next row on screen
+		MOV AX, nextBmpRow
+		ADD SI, AX	      ; go to the next row on bmp
+
+		DEC rowCounter
+		JNZ ROW_LOOP	    ; do all the rows
+		;-- end plane painting
+
+		MOV AL, plane	   ; advance to the next plane
+		SHL AL, 1	       ;
+		AND AL, 0x0f	    ; mask the plane properly
+		MOV plane, AL	   ; store the plane
+
+		INC bmpOffset	   ; start bmp at the right spot
+
+		DEC planeCounter
+		JNZ PLANE_LOOP	  ; do all 4 planes
     }
 }
 
@@ -763,9 +797,9 @@ modexDrawSpriteRegion(page_t *page, int x, int y,
  */
 void
 modexCopyPageRegion(page_t *dest, page_t *src,
-                    word sx, word sy,
-                    word dx, word dy,
-                    word width, word height)
+		    word sx, word sy,
+		    word dx, word dy,
+		    word width, word height)
 {
     word doffset = (word)dest->data + dy*(dest->width/4) + dx/4;
     word soffset = (word)src->data + sy*(src->width/4) + sx/4;
@@ -778,54 +812,54 @@ modexCopyPageRegion(page_t *dest, page_t *src,
     byte right = rclip[(sx+width)&0x03];
 
     __asm {
-                MOV AX, SCREEN_SEG      ; work in the vga space
-                MOV ES, AX              ;
-                MOV DI, doffset         ;
-                MOV SI, soffset         ;
-
-                MOV DX, GC_INDEX        ; turn off cpu bits
-                MOV AX, 0008h           ;
-                OUT DX, AX
-
-                MOV AX, SC_INDEX        ; point to the mask register
-                MOV DX, AX              ;
-                MOV AL, MAP_MASK        ;
-                OUT DX, AL              ;
-                INC DX                  ;
-
-        ROW_START:
-                PUSH DS
-                MOV AX, ES
-                MOV DS, AX
-                MOV CX, scans           ; the number of latches
-
-                MOV AL, left            ; do the left column
-                OUT DX, AL              ;
-                MOVSB                   ;
-                DEC CX                  ;
-
-                MOV AL, 0fh             ; do the inner columns
-                OUT DX, AL
-                REP MOVSB               ; copy the pixels
-
-                MOV AL, right           ; do the right column
-                OUT DX, AL
-                MOVSB
-                POP DS
-
-                MOV AX, SI              ; go the start of the next row
-                ADD AX, nextSrcRow      ;
-                MOV SI, AX              ;
-                MOV AX, DI              ;
-                ADD AX, nextDestRow     ;
-                MOV DI, AX              ;
-
-                DEC height              ; do the rest of the actions
-                JNZ ROW_START           ;
-
-                MOV DX, GC_INDEX+1      ; go back to CPU data
-                MOV AL, 0ffh            ; none from latches
-                OUT DX, AL              ;
+		MOV AX, SCREEN_SEG      ; work in the vga space
+		MOV ES, AX	      ;
+		MOV DI, doffset	 ;
+		MOV SI, soffset	 ;
+
+		MOV DX, GC_INDEX	; turn off cpu bits
+		MOV AX, 0008h	   ;
+		OUT DX, AX
+
+		MOV AX, SC_INDEX	; point to the mask register
+		MOV DX, AX	      ;
+		MOV AL, MAP_MASK	;
+		OUT DX, AL	      ;
+		INC DX		  ;
+
+	ROW_START:
+		PUSH DS
+		MOV AX, ES
+		MOV DS, AX
+		MOV CX, scans	   ; the number of latches
+
+		MOV AL, left	    ; do the left column
+		OUT DX, AL	      ;
+		MOVSB		   ;
+		DEC CX		  ;
+
+		MOV AL, 0fh	     ; do the inner columns
+		OUT DX, AL
+		REP MOVSB	       ; copy the pixels
+
+		MOV AL, right	   ; do the right column
+		OUT DX, AL
+		MOVSB
+		POP DS
+
+		MOV AX, SI	      ; go the start of the next row
+		ADD AX, nextSrcRow      ;
+		MOV SI, AX	      ;
+		MOV AX, DI	      ;
+		ADD AX, nextDestRow     ;
+		MOV DI, AX	      ;
+
+		DEC height	      ; do the rest of the actions
+		JNZ ROW_START	   ;
+
+		MOV DX, GC_INDEX+1      ; go back to CPU data
+		MOV AL, 0ffh	    ; none from latches
+		OUT DX, AL	      ;
     }
 }
 
@@ -862,22 +896,22 @@ fadePalette(sbyte fade, sbyte start, word iter, byte *palette) {
 
     /* handle the case where we just update */
     if(iter == 0) {
-        modexPalUpdate1(palette);
-        return;
+	modexPalUpdate1(palette);
+	return;
     }
 
     while(iter > 0) {  /* FadeLoop */
-        for(i=0; i<PAL_SIZE; i++) { /* loadpal_loop */
-            tmppal[i] = palette[i] - dim;
-            if(tmppal[i] > 127) {
-                tmppal[i] = 0;
-            } else if(tmppal[i] > 63) {
-                tmppal[i] = 63;
-            }
-        }
-        modexPalUpdate1(tmppal);
-        iter--;
-        dim += fade;
+	for(i=0; i<PAL_SIZE; i++) { /* loadpal_loop */
+	    tmppal[i] = palette[i] - dim;
+	    if(tmppal[i] > 127) {
+		tmppal[i] = 0;
+	    } else if(tmppal[i] > 63) {
+		tmppal[i] = 63;
+	    }
+	}
+	modexPalUpdate1(tmppal);
+	iter--;
+	dim += fade;
     }
 }
 
@@ -889,7 +923,7 @@ modexPalSave(byte *palette) {
 
     outp(PAL_READ_REG, 0);      /* start at palette entry 0 */
     for(i=0; i<PAL_SIZE; i++) {
-        palette[i] = inp(PAL_DATA_REG); /* read the palette data */
+	palette[i] = inp(PAL_DATA_REG); /* read the palette data */
     }
 }
 
@@ -901,8 +935,8 @@ modexNewPal() {
 
     /* handle errors */
     if(!ptr) {
-        printf("Could not allocate palette.\n");
-        exit(-1);
+	printf("Could not allocate palette.\n");
+	exit(-1);
     }
 
     return ptr;
@@ -916,7 +950,7 @@ modexLoadPalFile(byte *filename, byte **palette) {
 
     /* free the palette if it exists */
     if(*palette) {
-        free(*palette);
+	free(*palette);
     }
 
     /* allocate the new palette */
@@ -925,14 +959,14 @@ modexLoadPalFile(byte *filename, byte **palette) {
     /* open the file */
     file = fopen(filename, "rb");
     if(!file) {
-        printf("Could not open palette file: %s\n", filename);
-        exit(-2);
+	printf("Could not open palette file: %s\n", filename);
+	exit(-2);
     }
 
     /* read the file */
     ptr = *palette;
     while(!feof(file)) {
-        *ptr++ = fgetc(file);
+	*ptr++ = fgetc(file);
     }
 
     fclose(file);
@@ -947,8 +981,8 @@ modexSavePalFile(char *filename, byte *pal) {
     /* open the file for writing */
     file = fopen(filename, "wb");
     if(!file) {
-        printf("Could not open %s for writing\n", filename);
-        exit(-2);
+	printf("Could not open %s for writing\n", filename);
+	exit(-2);
     }
 
     /* write the data to the file */
@@ -974,202 +1008,202 @@ modexPalWhite() {
 void
 modexPalUpdate(bitmap_t *bmp, word *i, word qp, word aqoffset)
 {
-        byte *p = bmp->palette;
-        word w=0;
-        word q=0;
-        word qq=0;
-        static word a[PAL_SIZE];        //palette array of change values!
-        word z=0, aq=0, aa=0, pp=0;
-
-        modexWaitBorder();
-        if((*i)==0)
-        {
-                memset(a, -1, sizeof(a));
-                outp(PAL_WRITE_REG, 0);  /* start at the beginning of palette */
-        }
-        else if(qp==0)
-        {
-                q=(*i);
-        }
-        else
-        {
-                q=(*i);
-                qq=(*i)/3;
-//              printf("q: %02d\n", (q));
-//              printf("qq: %02d\n", (qq));
-                //printf("      (*i)-q=%02d\n", (*i)-q);
-                outp(PAL_WRITE_REG, qq);  /* start at the beginning of palette */
-        }
-        if((*i)<PAL_SIZE/2 && w==0)
-        {
-                for(; (*i)<PAL_SIZE/2; (*i)++)
-                {
-                        //if(i%3==0 && (p[i+5]==p[i+4] && p[i+4]==p[i+3] && p[i+3]==p[i+2] && p[i+2]==p[i+1] && p[i+1]==p[i] && p[i+5]==p[i]))
-//____                  if((qp>0)&&((*i)-q)%3==0 && (p[((*i)-q)]==p[((*i)-q)+3] && p[((*i)-q)+1]==p[((*i)-q)+4] && p[((*i)-q)+2]==p[((*i)-q)+5])) outp(PAL_DATA_REG, p[(*i)-q]); else
-                        if(((((*i)-q)%3==0)) && (p[((*i)-q)]==p[((*i)-q)+3] && p[((*i)-q)+1]==p[((*i)-q)+4] && p[((*i)-q)+2]==p[((*i)-q)+5]))
-                        {
-                                w++;
-                                break;
-                        }
-                        else if(qp>0 && (*i)>=(qp) && (*i)<((qp)+3))
-                        {
-                                //printf("qp=%d\n", qp);
-                                //printf("              (*i)=%d a[%d]=%d\n", (*i), qp, a[qp]);
-                                printf("                %d's color=%d\n", (*i), (a[qp])-(bmp->offset*3)+qp);
-                                //outp(PAL_DATA_REG, p[((a[qp])-(bmp->offset*3)+qp)]);// fix this shit!
-                                if((*i)+1==(qp)+3){ w++; /*(*i)++;*/ break; }
-                        }
-                        else
-                        {
-                                if(bmp->offset==0 && (*i)<3 && q==0) outp(PAL_DATA_REG, 0);
-                                else
-                                if(qp==0) outp(PAL_DATA_REG, p[(*i)-q]);
-                                else{ //outp(PAL_DATA_REG, p[((*i)-(bmp->offset*3)+qp)]);
-                                printf("p[]=%d  qp=%d   p[]-qp=%d\n", ((*i)-(bmp->offset*3)), qp, ((*i)-(bmp->offset*3))+qp); }
-                        }
-                }
-                //if(qp>0) printf("qp=%d\n", qp);
-                //if(qp>0) printf("                                             (*i)=%d\n", (*i)/3);
-        }
-        modexWaitBorder();          /* waits one retrace -- less flicker */
-        if((*i)>=PAL_SIZE/2 && w==0)
-        {
-                for(; (*i)<PAL_SIZE; (*i)++)
-                {
-//____                  if((qp>0)&&((*i)-q)%3==0 && (p[((*i)-q)]==p[((*i)-q)+3] && p[((*i)-q)+1]==p[((*i)-q)+4] && p[((*i)-q)+2]==p[((*i)-q)+5])) outp(PAL_DATA_REG, p[(*i)-q]); else
-                        if(((((*i)-q)%3==0)) && (p[((*i)-q)]==p[((*i)-q)+3] && p[((*i)-q)+1]==p[((*i)-q)+4] && p[((*i)-q)+2]==p[((*i)-q)+5]))
-                        {
-                                w++;
-                                break;
-                        }
-                        else if(qp>0 && (*i)>=(qp) && (*i)<((qp)+3))
-                        {
-                                //printf("qp=%d\n", qp);
-                                //printf("              (*i)=%d a[%d]=%d\n", (*i), qp, a[qp]);
-                                printf("                %d's color=%d\n", (*i), (a[qp]-(bmp->offset*3)+qp));
-                                //outp(PAL_DATA_REG, p[((a[qp])-(bmp->offset*3)+qp)]);// fix this shit!
-                                if((*i)+1==(qp)+3){ w++; /*(*i)++;*/ break; }
-                        }
-                        else
-                        {
-                                if(qp==0) outp(PAL_DATA_REG, p[(*i)-q]);
-                                else{ //outp(PAL_DATA_REG, p[((*i)-(bmp->offset*3)+qp)]);
-                                printf("p[]=%d  qp=%d   p[]-qp=%d\n", ((*i)-(bmp->offset*3)), qp, ((*i)-(bmp->offset*3))+qp); }
-                        }
-                }
-                //printf("                                              (*i)=%d\n", (*i)/3);
-        }
+	byte *p = bmp->palette;
+	word w=0;
+	word q=0;
+	word qq=0;
+	static word a[PAL_SIZE];	//palette array of change values!
+	word z=0, aq=0, aa=0, pp=0;
+
+	modexWaitBorder();
+	if((*i)==0)
+	{
+		memset(a, -1, sizeof(a));
+		outp(PAL_WRITE_REG, 0);  /* start at the beginning of palette */
+	}
+	else if(qp==0)
+	{
+		q=(*i);
+	}
+	else
+	{
+		q=(*i);
+		qq=(*i)/3;
+//	      printf("q: %02d\n", (q));
+//	      printf("qq: %02d\n", (qq));
+		//printf("      (*i)-q=%02d\n", (*i)-q);
+		outp(PAL_WRITE_REG, qq);  /* start at the beginning of palette */
+	}
+	if((*i)<PAL_SIZE/2 && w==0)
+	{
+		for(; (*i)<PAL_SIZE/2; (*i)++)
+		{
+			//if(i%3==0 && (p[i+5]==p[i+4] && p[i+4]==p[i+3] && p[i+3]==p[i+2] && p[i+2]==p[i+1] && p[i+1]==p[i] && p[i+5]==p[i]))
+//____		  if((qp>0)&&((*i)-q)%3==0 && (p[((*i)-q)]==p[((*i)-q)+3] && p[((*i)-q)+1]==p[((*i)-q)+4] && p[((*i)-q)+2]==p[((*i)-q)+5])) outp(PAL_DATA_REG, p[(*i)-q]); else
+			if(((((*i)-q)%3==0)) && (p[((*i)-q)]==p[((*i)-q)+3] && p[((*i)-q)+1]==p[((*i)-q)+4] && p[((*i)-q)+2]==p[((*i)-q)+5]))
+			{
+				w++;
+				break;
+			}
+			else if(qp>0 && (*i)>=(qp) && (*i)<((qp)+3))
+			{
+				//printf("qp=%d\n", qp);
+				//printf("	      (*i)=%d a[%d]=%d\n", (*i), qp, a[qp]);
+				printf("		%d's color=%d\n", (*i), (a[qp])-(bmp->offset*3)+qp);
+				//outp(PAL_DATA_REG, p[((a[qp])-(bmp->offset*3)+qp)]);// fix this shit!
+				if((*i)+1==(qp)+3){ w++; /*(*i)++;*/ break; }
+			}
+			else
+			{
+				if(bmp->offset==0 && (*i)<3 && q==0) outp(PAL_DATA_REG, 0);
+				else
+				if(qp==0) outp(PAL_DATA_REG, p[(*i)-q]);
+				else{ //outp(PAL_DATA_REG, p[((*i)-(bmp->offset*3)+qp)]);
+				printf("p[]=%d  qp=%d   p[]-qp=%d\n", ((*i)-(bmp->offset*3)), qp, ((*i)-(bmp->offset*3))+qp); }
+			}
+		}
+		//if(qp>0) printf("qp=%d\n", qp);
+		//if(qp>0) printf("					     (*i)=%d\n", (*i)/3);
+	}
+	modexWaitBorder();	  /* waits one retrace -- less flicker */
+	if((*i)>=PAL_SIZE/2 && w==0)
+	{
+		for(; (*i)<PAL_SIZE; (*i)++)
+		{
+//____		  if((qp>0)&&((*i)-q)%3==0 && (p[((*i)-q)]==p[((*i)-q)+3] && p[((*i)-q)+1]==p[((*i)-q)+4] && p[((*i)-q)+2]==p[((*i)-q)+5])) outp(PAL_DATA_REG, p[(*i)-q]); else
+			if(((((*i)-q)%3==0)) && (p[((*i)-q)]==p[((*i)-q)+3] && p[((*i)-q)+1]==p[((*i)-q)+4] && p[((*i)-q)+2]==p[((*i)-q)+5]))
+			{
+				w++;
+				break;
+			}
+			else if(qp>0 && (*i)>=(qp) && (*i)<((qp)+3))
+			{
+				//printf("qp=%d\n", qp);
+				//printf("	      (*i)=%d a[%d]=%d\n", (*i), qp, a[qp]);
+				printf("		%d's color=%d\n", (*i), (a[qp]-(bmp->offset*3)+qp));
+				//outp(PAL_DATA_REG, p[((a[qp])-(bmp->offset*3)+qp)]);// fix this shit!
+				if((*i)+1==(qp)+3){ w++; /*(*i)++;*/ break; }
+			}
+			else
+			{
+				if(qp==0) outp(PAL_DATA_REG, p[(*i)-q]);
+				else{ //outp(PAL_DATA_REG, p[((*i)-(bmp->offset*3)+qp)]);
+				printf("p[]=%d  qp=%d   p[]-qp=%d\n", ((*i)-(bmp->offset*3)), qp, ((*i)-(bmp->offset*3))+qp); }
+			}
+		}
+		//printf("					      (*i)=%d\n", (*i)/3);
+	}
 
 printf("\nqqqqqqqq\n\n");
 
-        //palette checker~
-        if(q>0 && qp==0)
-        {
-                long lq;
-                long bufSize = (bmp->width * bmp->height);
-                pp = q;
-                //printf("1(*i)=%02d\n", (*i)/3);
-                //printf("1z=%02d\n", z/3);
-                chkcolor(bmp, &q, &a, &aa, &z, i);
-                //printf("2(*i)=%02d\n", (*i)/3);
-                //printf("2z=%02d\n", z/3);
-                aq=0;
+	//palette checker~
+	if(q>0 && qp==0)
+	{
+		long lq;
+		long bufSize = (bmp->width * bmp->height);
+		pp = q;
+		//printf("1(*i)=%02d\n", (*i)/3);
+		//printf("1z=%02d\n", z/3);
+		chkcolor(bmp, &q, &a, &aa, &z, i);
+		//printf("2(*i)=%02d\n", (*i)/3);
+		//printf("2z=%02d\n", z/3);
+		aq=0;
 aqpee:
-                while(aq<=aa)
-                {
-//                      printf("a[%02d]=(%d)\n", aq, a[aq]);
-                        if(a[aq]==-1) aq++;
-                        else { aqoffset++; break; }
-                }
+		while(aq<=aa)
+		{
+//		      printf("a[%02d]=(%d)\n", aq, a[aq]);
+			if(a[aq]==-1) aq++;
+			else { aqoffset++; break; }
+		}
 //update the image data here!
-        for(lq=0; lq<bufSize; lq++)
-        {
-                                /*
-                                                                        note to self
-                                                                        use a[qp] instead of bmp->offset for this spot!
-                                                                        NO! wwww
-                                */
-
-                                /*
-                                Facking bloody point the values of the changed palette to correct values.... major confusion! wwww
-                                */
-
-                //(offset/bmp->offset)*bmp->offset
-
-
-                //printf("%02d ",bmp->data[lq]+bmp->offset);
-                //if(lq > 0 && lq%bmp->width==0) printf("\n");
-                //printf("%02d_", bmp->data[lq]+bmp->offset);
-                /*if(bmp->data[lq]+bmp->offset==aq)
-                {
-                        //printf("%02d", bmp->data[lq]);
-                        //printf("\n%02d\n", bmp->offset);
-                        printf("aq=%02d ", aq);
-                        printf("a[aq]=%02d      ", a[aq]);
-                        printf("a[aq]+aqpp=%02d ", a[aq]+aqpp);
-                        printf("a[aq]-aqpp=%02d\n", a[aq]-aqpp);
-                        //bmp->data[lq]=((bmp->data[lq]+bmp->offset)-a[aq]);
-//++++                  bmp->data[lq]=a[aq]-aqpp;
-//                      printf("_%d ", bmp->data[lq]);
-                        //if(lq > 0 && lq%bmp->width==0) printf("\n");
-                }
-                else if(bmp->data[lq]+bmp->offset < ((*i)/3)-aqpp)
-                {
-                        if(bmp->data[lq]+bmp->offset >= aq)
-                        {
-                                bmp->data[lq]=(bmp->data[lq]+bmp->offset)-aqpp;//-((z-(*i))/3);
-                                //printf("_%d ", bmp->data[lq]+bmp->offset)-aqpp-((z-(*i))/3);
-                        }
-                        else bmp->data[lq]+=(bmp->offset-aqpp);
-                }*/
-
-                //printf("%02d`", bmp->data[lq]);
-                //if(lq > 0 && lq%bmp->width==0) printf("\n");
-        }
-
-//printf("              aq=%02d\n", aq);
-//printf("              aa=%02d\n", aa);
-
-        //update the palette~
-        modexPalUpdate(bmp, &pp, aq, aqoffset);
-        (*i)=pp;
-
-        if(aq<aa){ pp=q; aq++; goto aqpee; }
-        }
+	for(lq=0; lq<bufSize; lq++)
+	{
+				/*
+									note to self
+									use a[qp] instead of bmp->offset for this spot!
+									NO! wwww
+				*/
+
+				/*
+				Facking bloody point the values of the changed palette to correct values.... major confusion! wwww
+				*/
+
+		//(offset/bmp->offset)*bmp->offset
+
+
+		//printf("%02d ",bmp->data[lq]+bmp->offset);
+		//if(lq > 0 && lq%bmp->width==0) printf("\n");
+		//printf("%02d_", bmp->data[lq]+bmp->offset);
+		/*if(bmp->data[lq]+bmp->offset==aq)
+		{
+			//printf("%02d", bmp->data[lq]);
+			//printf("\n%02d\n", bmp->offset);
+			printf("aq=%02d ", aq);
+			printf("a[aq]=%02d      ", a[aq]);
+			printf("a[aq]+aqpp=%02d ", a[aq]+aqpp);
+			printf("a[aq]-aqpp=%02d\n", a[aq]-aqpp);
+			//bmp->data[lq]=((bmp->data[lq]+bmp->offset)-a[aq]);
+//++++		  bmp->data[lq]=a[aq]-aqpp;
+//		      printf("_%d ", bmp->data[lq]);
+			//if(lq > 0 && lq%bmp->width==0) printf("\n");
+		}
+		else if(bmp->data[lq]+bmp->offset < ((*i)/3)-aqpp)
+		{
+			if(bmp->data[lq]+bmp->offset >= aq)
+			{
+				bmp->data[lq]=(bmp->data[lq]+bmp->offset)-aqpp;//-((z-(*i))/3);
+				//printf("_%d ", bmp->data[lq]+bmp->offset)-aqpp-((z-(*i))/3);
+			}
+			else bmp->data[lq]+=(bmp->offset-aqpp);
+		}*/
+
+		//printf("%02d`", bmp->data[lq]);
+		//if(lq > 0 && lq%bmp->width==0) printf("\n");
+	}
+
+//printf("	      aq=%02d\n", aq);
+//printf("	      aa=%02d\n", aa);
+
+	//update the palette~
+	modexPalUpdate(bmp, &pp, aq, aqoffset);
+	(*i)=pp;
+
+	if(aq<aa){ pp=q; aq++; goto aqpee; }
+	}
 }
 
 void
 modexPalUpdate1(byte *p)
 {
-        int i;
-        modexWaitBorder();
-        outp(PAL_WRITE_REG, 0);  /* start at the beginning of palette */
-        for(i=0; i<PAL_SIZE/2; i++)
-        {
-                outp(PAL_DATA_REG, p[i]);
-        }
-        modexWaitBorder();          /* waits one retrace -- less flicker */
-        for(; i<PAL_SIZE; i++)
-        {
-                outp(PAL_DATA_REG, p[(i)]);
-        }
+	int i;
+	modexWaitBorder();
+	outp(PAL_WRITE_REG, 0);  /* start at the beginning of palette */
+	for(i=0; i<PAL_SIZE/2; i++)
+	{
+		outp(PAL_DATA_REG, p[i]);
+	}
+	modexWaitBorder();	  /* waits one retrace -- less flicker */
+	for(; i<PAL_SIZE; i++)
+	{
+		outp(PAL_DATA_REG, p[(i)]);
+	}
 }
 
 void
 modexPalUpdate0(byte *p)
 {
-        int i;
-        modexWaitBorder();
-        outp(PAL_WRITE_REG, 0);  /* start at the beginning of palette */
-        for(i=0; i<PAL_SIZE/2; i++)
-        {
-                outp(PAL_DATA_REG, rand());
-        }
-        modexWaitBorder();          /* waits one retrace -- less flicker */
-        for(; i<PAL_SIZE; i++)
-        {
-                outp(PAL_DATA_REG, rand());
-        }
+	int i;
+	modexWaitBorder();
+	outp(PAL_WRITE_REG, 0);  /* start at the beginning of palette */
+	for(i=0; i<PAL_SIZE/2; i++)
+	{
+		outp(PAL_DATA_REG, rand());
+	}
+	modexWaitBorder();	  /* waits one retrace -- less flicker */
+	for(; i<PAL_SIZE; i++)
+	{
+		outp(PAL_DATA_REG, rand());
+	}
 }
 
 void
@@ -1184,99 +1218,99 @@ modexPalOverscan(byte *p, word col)
 //i want to make another vesion that checks the palette when the palette is being appened~
 void chkcolor(bitmap_t *bmp, word *q, word *a, word *aa, word *z, word *i/*, word *offset*/)
 {
-                byte *pal;
-                word zz=0;
-                pal = modexNewPal();
-                modexPalSave(pal);
-                //printf("q: %02d\n", (*q));
-                printf("chkcolor start~\n");
-                printf("1                               (*z): %d\n", (*z)/3);
-                printf("1                               (*i): %d\n", (*i)/3);
-//              printf("1 offset of color in palette    (*q): %d\n", (*q)/3);
-                printf("wwwwwwwwwwwwwwww\n");
-                //check palette for dups
-                for(; (*z)<PAL_SIZE; (*z)+=3)
-                {
-                        //printf("\n            z: %d\n", (*z));
-                        //printf("              q: %d\n", (*q));
-                        //printf("              z+q: %d\n\n", ((*z)+(*q)));
-                        //if((*z)%3==0)
-                        //{
-//----                          if(pal[(*z)]==pal[(*z)+3] && pal[(*z)+1]==pal[(*z)+4] && pal[(*z)+2]==pal[(*z)+5])
-                                if((*z)==(*i))
-                                {
-//                                      printf("\n%d    [%02d][%02d][%02d]\n", (*z), pal[(*z)], pal[(*z)+1], pal[(*z)+2]);
-//                                      printf("%d      [%02d][%02d][%02d]\n\n", (*z)+3, pal[(*z)+3], pal[(*z)+4], pal[(*z)+5]);
-//0000                                  (*z)-=3;
-                                        break;
-                                }
-                                else for(zz=0; zz<(*q); zz+=3)
-                                {
-                                        //printf("zz: %02d\n", zz/3);
-                                        if(zz%3==0)
-                                        {
-                                                if(pal[((*z)+(*q))]==pal[((*z)+(*q))+3] && pal[((*z)+(*q))+1]==pal[((*z)+(*q))+4] && pal[((*z)+(*q))+2]==pal[((*z)+(*q))+5])    //break if duplicate colors found in palette because it have reached the end of the current data of the palette
-                                                {
-//                                                      (*z)-=3;
-//                                                      (*i)-=3;
-//                                                      printf("\nzq1:%d[%02d][%02d][%02d]\n", (zz+q), pal[(zz+q)], pal[(zz+q)+1], pal[(zz+q)+2]);
-//                                                      printf("zq2:%d[%02d][%02d][%02d]\n\n", (zz+q)+3, pal[(zz+q)+3], pal[(zz+q)+4], pal[(zz+q)+5]);
-                                                        break;
-                                                }
-                                                else if(pal[zz]==pal[((*z)+(*q))] && pal[zz+1]==pal[((*z)+(*q))+1] && pal[zz+2]==pal[((*z)+(*q))+2])
-                                                {
-//                                                      printf("\n\nwwwwwwwwwwwwwwww\n");
-//                                                      printf("        zq: %d  [%02d][%02d][%02d] value that is needing to be changed~\n", ((*z)+(*q))/3, pal[((*z)+(*q))], pal[((*z)+(*q))+1], pal[((*z)+(*q))+2]);
-//                                                      printf("        zz: %d  [%02d][%02d][%02d] value that the previous value is going to change to~\n", (zz)/3, pal[zz], pal[zz+1], pal[zz+2]);
-//                                                      //printf("      zv: %d  [%02d][%02d][%02d] wwww\n", (zz-z+q)/3, pal[(zz-z+q)], pal[(zz-z+q)+1], pal[(zz-z+q)+2]);
-//                                                      printf("        z : %d  [%02d][%02d][%02d] offset value~\n", (*z)/3, pal[(*z)], pal[(*z)+1], pal[(*z)+2]);
-//++++                                                  (*i)--;
-//                                                      (*z)--;
-                                                        //expand dong here
+		byte *pal;
+		word zz=0;
+		pal = modexNewPal();
+		modexPalSave(pal);
+		//printf("q: %02d\n", (*q));
+		printf("chkcolor start~\n");
+		printf("1			       (*z): %d\n", (*z)/3);
+		printf("1			       (*i): %d\n", (*i)/3);
+//	      printf("1 offset of color in palette    (*q): %d\n", (*q)/3);
+		printf("wwwwwwwwwwwwwwww\n");
+		//check palette for dups
+		for(; (*z)<PAL_SIZE; (*z)+=3)
+		{
+			//printf("\n	    z: %d\n", (*z));
+			//printf("	      q: %d\n", (*q));
+			//printf("	      z+q: %d\n\n", ((*z)+(*q)));
+			//if((*z)%3==0)
+			//{
+//----			  if(pal[(*z)]==pal[(*z)+3] && pal[(*z)+1]==pal[(*z)+4] && pal[(*z)+2]==pal[(*z)+5])
+				if((*z)==(*i))
+				{
+//				      printf("\n%d    [%02d][%02d][%02d]\n", (*z), pal[(*z)], pal[(*z)+1], pal[(*z)+2]);
+//				      printf("%d      [%02d][%02d][%02d]\n\n", (*z)+3, pal[(*z)+3], pal[(*z)+4], pal[(*z)+5]);
+//0000				  (*z)-=3;
+					break;
+				}
+				else for(zz=0; zz<(*q); zz+=3)
+				{
+					//printf("zz: %02d\n", zz/3);
+					if(zz%3==0)
+					{
+						if(pal[((*z)+(*q))]==pal[((*z)+(*q))+3] && pal[((*z)+(*q))+1]==pal[((*z)+(*q))+4] && pal[((*z)+(*q))+2]==pal[((*z)+(*q))+5])    //break if duplicate colors found in palette because it have reached the end of the current data of the palette
+						{
+//						      (*z)-=3;
+//						      (*i)-=3;
+//						      printf("\nzq1:%d[%02d][%02d][%02d]\n", (zz+q), pal[(zz+q)], pal[(zz+q)+1], pal[(zz+q)+2]);
+//						      printf("zq2:%d[%02d][%02d][%02d]\n\n", (zz+q)+3, pal[(zz+q)+3], pal[(zz+q)+4], pal[(zz+q)+5]);
+							break;
+						}
+						else if(pal[zz]==pal[((*z)+(*q))] && pal[zz+1]==pal[((*z)+(*q))+1] && pal[zz+2]==pal[((*z)+(*q))+2])
+						{
+//						      printf("\n\nwwwwwwwwwwwwwwww\n");
+//						      printf("	zq: %d  [%02d][%02d][%02d] value that is needing to be changed~\n", ((*z)+(*q))/3, pal[((*z)+(*q))], pal[((*z)+(*q))+1], pal[((*z)+(*q))+2]);
+//						      printf("	zz: %d  [%02d][%02d][%02d] value that the previous value is going to change to~\n", (zz)/3, pal[zz], pal[zz+1], pal[zz+2]);
+//						      //printf("      zv: %d  [%02d][%02d][%02d] wwww\n", (zz-z+q)/3, pal[(zz-z+q)], pal[(zz-z+q)+1], pal[(zz-z+q)+2]);
+//						      printf("	z : %d  [%02d][%02d][%02d] offset value~\n", (*z)/3, pal[(*z)], pal[(*z)+1], pal[(*z)+2]);
+//++++						  (*i)--;
+//						      (*z)--;
+							//expand dong here
 /*
 planned features that i plan to implement~
 image that has values on the pallete list!
 wwww
 no... wait.... no wwww
 */
-                                                        //for(zzii=0; zzii<3; zzii++)
-                                                        //{
-                                                                //printf("z+q: %d\n\n", ((*z)+(*q)));
-                                                                a[(((*z)+(*q)))]=zz;
-                                                        //}
-                                                        (*aa)=(((*z)+(*q)));
-                                                        printf("!!                                      a[%02d]: %d\n", (((*z)+(*q))/3), zz/3);
-//                                                      printf("\n              aa: %d\n\n", (*aa));
-//                                                      printf("        a[%02d]=(%02d) offset array i think the palette should be updated again~\n", ((*z)+(*q))/3, a[((*z)+(*q))/3]);
-//                                                      printf("wwwwwwwwwwwwwwww\n\n");
-                                                }
-                                                /*else
-                                                {
-                                                        printf("================\n");
-                                                        printf("zq: %d  [%02d][%02d][%02d]\n", ((*z)+(*q))/3, pal[((*z)+(*q))], pal[((*z)+(*q))+1], pal[((*z)+(*q))+2]);
-                                                        printf("zz: %d  [%02d][%02d][%02d]\n", (zz)/3, pal[zz], pal[zz+1], pal[zz+2]);
-                                                        printf("z : %d  [%02d][%02d][%02d]\n", (*z)/3, pal[(*z)], pal[(*z)+1], pal[(*z)+2]);
-                                                        printf("================\n");
-                                                }*/
-                                                //printf("[%d]", (zz+q));
-                                        }
-                                }
-                }
-                printf("wwwwwwwwwwwwwwww\n");
-                printf("2                               (*z): %d\n", (*z)/3);
-                printf("2                               (*i): %d\n", (*i)/3);
-//              printf("2 offset of color in palette    (*q): %d\n", (*q)/3);
-                printf("chkcolor end~\n");
-                free(pal);
+							//for(zzii=0; zzii<3; zzii++)
+							//{
+								//printf("z+q: %d\n\n", ((*z)+(*q)));
+								a[(((*z)+(*q)))]=zz;
+							//}
+							(*aa)=(((*z)+(*q)));
+							printf("!!				      a[%02d]: %d\n", (((*z)+(*q))/3), zz/3);
+//						      printf("\n	      aa: %d\n\n", (*aa));
+//						      printf("	a[%02d]=(%02d) offset array i think the palette should be updated again~\n", ((*z)+(*q))/3, a[((*z)+(*q))/3]);
+//						      printf("wwwwwwwwwwwwwwww\n\n");
+						}
+						/*else
+						{
+							printf("================\n");
+							printf("zq: %d  [%02d][%02d][%02d]\n", ((*z)+(*q))/3, pal[((*z)+(*q))], pal[((*z)+(*q))+1], pal[((*z)+(*q))+2]);
+							printf("zz: %d  [%02d][%02d][%02d]\n", (zz)/3, pal[zz], pal[zz+1], pal[zz+2]);
+							printf("z : %d  [%02d][%02d][%02d]\n", (*z)/3, pal[(*z)], pal[(*z)+1], pal[(*z)+2]);
+							printf("================\n");
+						}*/
+						//printf("[%d]", (zz+q));
+					}
+				}
+		}
+		printf("wwwwwwwwwwwwwwww\n");
+		printf("2			       (*z): %d\n", (*z)/3);
+		printf("2			       (*i): %d\n", (*i)/3);
+//	      printf("2 offset of color in palette    (*q): %d\n", (*q)/3);
+		printf("chkcolor end~\n");
+		free(pal);
 }
 
 void modexputPixel(page_t *page, int x, int y, byte color)
 {
 	word pageOff = (word) page->data;
-        /* Each address accesses four neighboring pixels, so set
-           Write Plane Enable according to which pixel we want
-           to modify.  The plane is determined by the two least
-           significant bits of the x-coordinate: */
+	/* Each address accesses four neighboring pixels, so set
+	   Write Plane Enable according to which pixel we want
+	   to modify.  The plane is determined by the two least
+	   significant bits of the x-coordinate: */
 	modexSelectPlane(PLANE(x));
 	//outp(SC_INDEX, 0x02);
 	//outp(SC_DATA, 0x01 << (x & 3));
@@ -1503,10 +1537,10 @@ void cls(page_t *page, byte color, byte *Where)
 void
 modexWaitBorder() {
     while(inp(INPUT_STATUS_1)  & 8)  {
-        /* spin */
+	/* spin */
     }
 
     while(!(inp(INPUT_STATUS_1)  & 8))  {
-        /* spin */
+	/* spin */
     }
 }