16/dos_gfx.cpp

   1 /*\r
   2  * LIB.C v1.2a\r
   3  *\r
   4  * by Robert Schmidt\r
   5  * (C)1993 Ztiff Zox Softwear\r
   6  *\r
   7  * Simple graphics library to accompany the article\r
   8  * \r
   9  *                                        INTRODUCTION TO MODE X.\r
  10  * \r
  11  * This library provides the basic functions for initializing and using\r
  12  * unchained (planar) 256-color VGA modes.  Currently supported are:\r
  13  *\r
  14  *        - 320x200\r
  15  *        - 320x240\r
  16  *\r
  17  * Functions are provided for:\r
  18  *\r
  19  *        - initializing one of the available modes\r
  20  *        - setting the start address of the VGA refresh data\r
  21  *        - setting active and visible display pages\r
  22  *        - writing and reading a single pixel to/from video memory\r
  23  *\r
  24  * The library is provided as a demonstration only, and is not claimed\r
  25  * to be particularly efficient or suited for any purpose.  It has only\r
  26  * been tested with Borland C++ 3.1 by the author.  Comments on success\r
  27  * or disaster with other compilers are welcome.\r
  28  *\r
  29  * This file is public domain.  Do with it whatever you'd like, but\r
  30  * please don't distribute it without the article.\r
  31  *\r
  32  * Thanks go out to various helpful netters who spotted the 0xE7 bug\r
  33  * in the set320x240x256() function!\r
  34  *\r
  35  * Modified by sparky4 so it can be compiled in open watcom ^^\r
  36  */\r
  37 \r
  38 \r
  39 \r
  40 \r
  41 /*\r
  42  * We 'require' a large data model simply to get rid of explicit 'far'\r
  43  * pointers and compiler specific '_fmemset()' functions and the likes.\r
  44  */\r
  45 #if !defined(__COMPACT__)\r
  46 # if !defined(__LARGE__)\r
  47 #  if !defined(__HUGE__)\r
  48 #   error Large data model required!  Try compiling with 'wcc -0 -ml lib.c'.\r
  49 #  endif\r
  50 # endif\r
  51 #endif\r
  52 \r
  53 #include <dos.h>\r
  54 #include <mem.h>\r
  55 #include <conio.h>\r
  56 \r
  57 //code from old library!\r
  58 /*src\lib\*/\r
  59 #include "dos_gfx.h"\r
  60 \r
  61 int old_mode;\r
  62 //color \82Ä\82·\82Æ\r
  63 int gq = LGQ;\r
  64 //\82Ä\82·\82Æ\r
  65 int q = 0;\r
  66 int bakax = 0, bakay = 0;\r
  67 cord xx = rand()&0%320, yy = rand()&0%240, sx = 0, sy = 0;\r
  68 byte coor;\r
  69 \r
  70 /*\r
  71  * Comment out the following #define if you don't want the testing main()\r
  72  * to be included.\r
  73  */\r
  74 #define TESTING\r
  75 \r
  76 /*\r
  77  * Define the port addresses of some VGA registers.\r
  78  */\r
  79 #define CRTC_ADDR          0x3d4   /* Base port of the CRT Controller (color) */\r
  80 \r
  81 #define SEQU_ADDR          0x3c4   /* Base port of the Sequencer */\r
  82 #define GRAC_ADDR          0x3ce   /* Base port of the Graphics Controller */\r
  83 #define STATUS_ADDR     0x3DA\r
  84 \r
  85 unsigned char *RowsX[600];\r
  86 unsigned char write_plane, read_plane;\r
  87 unsigned short text_mask[16] = { 0x0002, 0x0102, 0x0202, 0x0302,\r
  88                                  0x0402, 0x0502, 0x0602, 0x0702,\r
  89                                  0x0802, 0x0902, 0x0A02, 0x0B02,\r
  90                                  0x0C02, 0x0D02, 0x0E02, 0x0F02 };\r
  91 \r
  92 \r
  93 /*\r
  94  * Make a far pointer to the VGA graphics buffer segment.  Your compiler\r
  95  * might not have the MK_FP macro, but you'll figure something out.\r
  96  */\r
  97 byte *vga = (byte *) MK_FP(0xA000, 0);\r
  98 \r
  99 \r
 100 /*\r
 101  * width and height should specify the mode dimensions.  widthBytes\r
 102  * specify the width of a line in addressable bytes.\r
 103  */\r
 104 unsigned width, height, widthBytes;\r
 105 \r
 106 /*\r
 107  * actStart specifies the start of the page being accessed by\r
 108  * drawing operations.  visStart specifies the contents of the Screen\r
 109  * Start register, i.e. the start of the visible page.\r
 110  */\r
 111 unsigned actStart, visStart;\r
 112 \r
 113 /*\r
 114  * set320x200x256_X()\r
 115  *        sets mode 13h, then turns it into an unchained (planar), 4-page\r
 116  *        320x200x256 mode.\r
 117  */\r
 118 void set320x200x256_X(void)\r
 119                 {\r
 120                 union REGS r;\r
 121 \r
 122                 /* Set VGA BIOS mode 13h: */\r
 123                 r.x.ax = 0x0013;\r
 124                 int86(0x10, &r, &r);\r
 125 \r
 126                 /* Turn off the Chain-4 bit (bit 3 at index 4, port 0x3c4): */\r
 127                 outpw(SEQU_ADDR, 0x0604);\r
 128 \r
 129                 /* Turn off word mode, by setting the Mode Control register\r
 130                 of the CRT Controller (index 0x17, port 0x3d4): */\r
 131                 outpw(CRTC_ADDR, 0xE317);\r
 132 \r
 133                 /* Turn off doubleword mode, by setting the Underline Location\r
 134                    register (index 0x14, port 0x3d4): */\r
 135                 outpw(CRTC_ADDR, 0x0014);\r
 136 \r
 137                 /* Clear entire video memory, by selecting all four planes, then\r
 138                    writing 0 to entire segment. */\r
 139                 outpw(SEQU_ADDR, 0x0F02);\r
 140                 memset(vga+1, 0, 0xffff); /* stupid size_t exactly 1 too small */\r
 141                 vga[0] = 0;\r
 142 \r
 143                 /* Update the global variables to reflect dimensions of this\r
 144                    mode.  This is needed by most future drawing operations. */\r
 145                 width              = 320;\r
 146                 height  = 200;\r
 147 \r
 148                 /* Each byte addresses four pixels, so the width of a scan line\r
 149                    in *bytes* is one fourth of the number of pixels on a line. */\r
 150                 widthBytes = width / 4;\r
 151 \r
 152                 /* By default we want screen refreshing and drawing operations\r
 153                    to be based at offset 0 in the video segment. */\r
 154                 actStart = visStart = 0;\r
 155 \r
 156                 /*\r
 157 --------------------\r
 158 HORIZONTAL SCROLLING\r
 159 --------------------\r
 160 Horizontal scrolling is essentially the same as vertical scrolling, all\r
 161 you do is increment or decrement the VGA offset register by 1 instead of\r
 162 80 as with vertical scrolling.\r
 163 \r
 164 However, horizontal scrolling is complicated by two things\r
 165 \r
 166   1. Incrementing the offset register by one actually scrolls by FOUR\r
 167      pixels (and there are FOUR planes on the VGA, what a coincidence)\r
 168 \r
 169   2. You can't draw the image off the screen and then scroll it on\r
 170      because of the way the VGA wraps to the next row every 80 bytes\r
 171      (80 bytes * 4 planes = 320 pixels), if you tried it, you would\r
 172      actually be drawing to the other side of the screen (which is\r
 173      entirely visible)\r
 174 \r
 175 I'll solve these problems one at a time.\r
 176 \r
 177 Firstly, to get the VGA to scroll by only one pixel you use the horizontal\r
 178 pixel panning (HPP) register. This register resides at\r
 179 \r
 180   PORT:     3C0H\r
 181   INDEX:    13h\r
 182 \r
 183 and in real life, you use it like this\r
 184 \r
 185 ----------------- Pixel Panning ---------------\r
 186 IN PORT 3DAH (this clears an internal\r
 187   flip-flop of the VGA)\r
 188 OUT 13H TO PORT 3C0H\r
 189 OUT value TO PORT 3C0H (where "value" is the\r
 190   number of pixels to offset)\r
 191 -----------------------------------------------\r
 192 */\r
 193 \r
 194 //mxSetVirtualScreen(480,360);\r
 195                 }\r
 196 \r
 197 /*\r
 198  * setActiveStart() tells our graphics operations which address in video\r
 199  * memory should be considered the top left corner.\r
 200  */\r
 201 void setActiveStart(unsigned offset)\r
 202                 {\r
 203                 actStart = offset;\r
 204                 }\r
 205 \r
 206 /*\r
 207  * setVisibleStart() tells the VGA from which byte to fetch the first\r
 208  * pixel when starting refresh at the top of the screen.  This version\r
 209  * won't look very well in time critical situations (games for\r
 210  * instance) as the register outputs are not synchronized with the\r
 211  * screen refresh.  This refresh might start when the high byte is\r
 212  * set, but before the low byte is set, which produces a bad flicker.\r
 213  */\r
 214 void setVisibleStart(unsigned offset)\r
 215                 {\r
 216                 visStart = offset;\r
 217                 outpw(CRTC_ADDR, 0x0C);          /* set high byte */\r
 218                 outpw(CRTC_ADDR+1, visStart >> 8);\r
 219                 outpw(CRTC_ADDR, 0x0D);          /* set low byte */\r
 220                 outpw(CRTC_ADDR+1, visStart & 0xff);\r
 221                 }\r
 222 \r
 223 /*\r
 224  * setXXXPage() sets the specified page by multiplying the page number\r
 225  * with the size of one page at the current resolution, then handing the\r
 226  * resulting offset value over to the corresponding setXXXStart()\r
 227  * function.  The first page is number 0.\r
 228  */\r
 229 void setActivePage(int page)\r
 230                 {\r
 231                 setActiveStart(page * widthBytes * height);\r
 232                 }\r
 233 \r
 234 void setVisiblePage(int page)\r
 235                 {\r
 236                 setVisibleStart(page * widthBytes * height);\r
 237                 }\r
 238 \r
 239 void putPixel_X(int x, int y, byte color)\r
 240                 {\r
 241                 /* Each address accesses four neighboring pixels, so set\r
 242                    Write Plane Enable according to which pixel we want\r
 243                    to modify.  The plane is determined by the two least\r
 244                    significant bits of the x-coordinate: */\r
 245                 outp(0x3c4, 0x02);\r
 246                 outp(0x3c5, 0x01 << (x & 3));\r
 247 \r
 248                 /* The offset of the pixel into the video segment is\r
 249                    offset = (width * y + x) / 4, and write the given\r
 250                    color to the plane we selected above.  Heed the active\r
 251                    page start selection. */\r
 252                 vga[(unsigned)(widthBytes * y) + (x / 4) + actStart] = color;\r
 253 \r
 254                 }\r
 255 \r
 256 byte getPixel_X(int x, int y)\r
 257                 {\r
 258                 /* Select the plane from which we must read the pixel color: */\r
 259                 outpw(GRAC_ADDR, 0x04);\r
 260                 outpw(GRAC_ADDR+1, x & 3);\r
 261 \r
 262                 return vga[(unsigned)(widthBytes * y) + (x / 4) + actStart];\r
 263 \r
 264                 }\r
 265 \r
 266 void set320x240x256_X(void)\r
 267                 {\r
 268                 /* Set the unchained version of mode 13h: */\r
 269                 set320x200x256_X();\r
 270 \r
 271                 /* Modify the vertical sync polarity bits in the Misc. Output\r
 272                    Register to achieve square aspect ratio: */\r
 273                 outp(0x3C2, 0xE3);\r
 274 \r
 275                 /* Modify the vertical timing registers to reflect the increased\r
 276                    vertical resolution, and to center the image as good as\r
 277                    possible: */\r
 278                 outpw(0x3D4, 0x2C11);              /* turn off write protect */\r
 279                 outpw(0x3D4, 0x0D06);              /* vertical total */\r
 280                 outpw(0x3D4, 0x3E07);              /* overflow register */\r
 281                 outpw(0x3D4, 0xEA10);              /* vertical retrace start */\r
 282                 outpw(0x3D4, 0xAC11);              /* vertical retrace end AND wr.prot */\r
 283                 outpw(0x3D4, 0xDF12);              /* vertical display enable end */\r
 284                 outpw(0x3D4, 0xE715);              /* start vertical blanking */\r
 285                 outpw(0x3D4, 0x0616);              /* end vertical blanking */\r
 286 \r
 287                 /* Update mode info, so future operations are aware of the\r
 288                    resolution */\r
 289                 height = 240;\r
 290 \r
 291                 }\r
 292 \r
 293 \r
 294 /*-----------XXXX-------------*/\r
 295 \r
 296 /////////////////////////////////////////////////////////////////////////////\r
 297 //                                                                         //\r
 298 // WaitRetrace() - This waits until you are in a Verticle Retrace.         //\r
 299 //                                                                         //\r
 300 /////////////////////////////////////////////////////////////////////////////\r
 301 void wait_for_retrace(void)\r
 302 {\r
 303     while (!(inp(STATUS_ADDR) & 0x08));\r
 304 }\r
 305 \r
 306 /*tile*/\r
 307 //king_crimson's code\r
 308 void putColorBox_X(int x, int y, int w, int h, byte color) {\r
 309         outp(0x3c4, 0x02);\r
 310 \r
 311         int curx, cury;\r
 312         unsigned drawptr;\r
 313         for (curx=x; curx<(x+w); curx++) {\r
 314                 outp(0x3c5, 0x01 << (curx & 3));\r
 315                 drawptr = (unsigned)(widthBytes * y) + (curx / 4) + actStart;\r
 316                 for (cury=0; cury<h; cury++) {\r
 317                         vga[drawptr] = color;\r
 318                         drawptr += widthBytes;\r
 319                 }\r
 320         }\r
 321 }\r
 322 \r
 323 void vScroll(int rows)\r
 324 {\r
 325         // Scrolling = current start + (rows * bytes in a row)\r
 326         setVisibleStart(visStart + (rows * width));\r
 327 }\r
 328 \r
 329 void scrolly(int bongy)\r
 330 {\r
 331         int boingy=0;\r
 332         if(bongy<0)\r
 333                 boingy=-1;\r
 334         else if(bongy>0)\r
 335                 boingy=1;\r
 336 \r
 337         for(int ti=0;ti<TILEWH;ti++)\r
 338         {\r
 339                 delay(1);\r
 340                 vScroll(boingy);\r
 341         }\r
 342 }\r
 343 \r
 344 //king_crimson's code\r
 345 void hScroll(int Cols) {\r
 346         wait_for_retrace();\r
 347         outp(0x3C0, 0x13);\r
 348         outp(0x3C0, Cols & 3);\r
 349         outp(0x3D4, 0x13);\r
 350         outp(0x3D5, Cols >> 2);\r
 351         outp(0x3D4, Cols);\r
 352         //setVisibleStart(visStart + (Cols * height));\r
 353         setVisibleStart(visStart + (Cols * width));\r
 354 }\r
 355 \r
 356 /////////////////////////////////////////////////////////////////////////////\r
 357 //                                                                         //\r
 358 // setvideo() - This function Manages the video modes                                     //\r
 359 //                                                                         //\r
 360 /////////////////////////////////////////////////////////////////////////////\r
 361 void setvideo(/*byte mode, */int vq){\r
 362                 union REGS in, out;\r
 363 \r
 364                 if(!vq){ // deinit the video\r
 365                                 // change to the video mode we were in before we switched to mode 13h\r
 366                                 mxSetMode( MX_TEXT );\r
 367                                 //in.h.ah = 0x00;\r
 368                                 //in.h.al = old_mode;\r
 369                                 //int86(0x10, &in, &out);
 370                                 mxTerm();\r
 371 \r
 372                 }else if(vq == 1){ // init the video\r
 373                                 // get old video mode\r
 374                                 //in.h.ah = 0xf;\r
 375                                 //int86(0x10, &in, &out);\r
 376                                 //old_mode = out.h.al;\r
 377 \r
 378                                 // enter mode\r
 379                                 mxInit();\r
 380                                 mxSetMode( MX_320x240 );\r
 381                                 mxSetVirtualScreen( 480, 360 );\r
 382                                 //set320x240x256_X();\r
 383                                 //mxSetMode(MX_320x240);\r
 384                                 //mxSetVirtualScreen(560,420);\r
 385                                 //mxSetVirtualScreen((640-TILEWH),(480-TILEWH));\r
 386                                 //mxSetClip( TRUE );\r
 387                 }\r
 388 }\r
 389 \r
 390 /////////////////////////////////////////////////////////////////////////////\r
 391 //                                                                                                                                               //\r
 392 // cls() - This clears the screen to the specified color, on the VGA or on //\r
 393 //               the Virtual screen.                                                                                     //\r
 394 //                                                                                                                                               //\r
 395 /////////////////////////////////////////////////////////////////////////////\r
 396 void cls(byte color, byte *Where){\r
 397                 _fmemset(Where, color, width*(height*17));\r
 398 }\r
 399 \r
 400 //color \82Ä\82·\82Æ\r
 401 int colortest(){\r
 402                 if(gq < NUM_COLORS){\r
 403                                 cls(gq, vga);\r
 404                                 gq++;\r
 405                 }else gq = 0;\r
 406                 return gq;\r
 407 }\r
 408 \r
 409 //color \82Ä\82·\82Æ\r
 410 int colorz(){\r
 411                 if(gq < HGQ){\r
 412 //----            cls(gq, vaddr);\r
 413                                 cls(gq, vga);\r
 414                                 gq++;\r
 415                 }else gq = LGQ;\r
 416                 return gq;\r
 417 }\r
 418 \r
 419 //slow spectrum down\r
 420 void ssd(int svq){\r
 421                 if(sy < height+1){\r
 422                                 if(sx < width+1){\r
 423                                                 //plotpixel(xx, yy, coor, vga);\r
 424                                                 //ppf(sx, sy, coor, vga);\r
 425                                                 putPixel_X(sx, sy, coor);\r
 426                                                 //printf("%d %d %d %d\n", sx, sy, svq, coor);\r
 427                                                 sx++;\r
 428                                 }else sx = 0;\r
 429                                 if(sx == width){\r
 430                                                 sy++;\r
 431                                                 if(svq == 7) coor++;\r
 432                                                 if(sy == height && svq == 8) coor = rand()%NUM_COLORS;\r
 433                                 }\r
 434                 }else sy = 0;\r
 435 }\r
 436 \r
 437 /*-----------ding-------------*/\r
 438 int ding(int q){\r
 439 \r
 440 /*      if(yy<height){\r
 441                 setActivePage(0);\r
 442                 setVisiblePage(0);\r
 443         }\r
 444         if((height)<yy<(height*2)){\r
 445                 setActivePage(1);\r
 446                 setVisiblePage(1);\r
 447         }\r
 448         if((height*2)<yy<(height*3)){\r
 449                 setActivePage(2);\r
 450                 setVisiblePage(2);\r
 451         }*/\r
 452                 int d3y;\r
 453 \r
 454 //++++  if(q <= 4 && q!=2 && gq == BONK-1) coor = rand()%HGQ;\r
 455                 if((q == 2\r
 456                 ||q==4\r
 457                 ||q==16\r
 458                 ) && gq == BONK){\r
 459                                                 if(coor < HGQ && coor < LGQ) coor = LGQ;\r
 460                                                 if(coor < HGQ-1){\r
 461                                                                 coor++;\r
 462                                 }else{ coor = LGQ;\r
 463                                                 bakax = rand()%3; bakay = rand()%3;\r
 464                                 }\r
 465                 }\r
 466 \r
 467                 if(q==8){ colorz(); return gq; }else\r
 468                 if(q==10){ ssd(q); /*printf("%d\n", coor);*/ }else\r
 469                 if(q==5){ colortest(); return gq; }else\r
 470                 if(q==11){ colorz(); delay(100); return gq; }\r
 471                 if(q==6){\r
 472                                 coor = rand()%NUM_COLORS;\r
 473 //----            cls(coor, vaddr);\r
 474                                 cls(coor, vga);\r
 475                                 //updatevbuff();\r
 476                 }\r
 477 \r
 478                 if(q==7||q==9){\r
 479                                 if(gq < HGQ){\r
 480                                                 if(q == 7) ssd(q);\r
 481                                                 if(q == 9){ ssd(q); coor++; }\r
 482                                                 gq++;\r
 483                                 }else gq = LGQ;\r
 484                 }\r
 485                 if((q<5 && gq<BONK) || (q==16 && gq<BONK)){ // the number variable make the colors more noticable\r
 486                                 if(q==1){\r
 487                                                 if(xx==width){bakax=0;}\r
 488                                                 if(xx==0){bakax=1;}\r
 489                                                 if(yy==height){bakay=0;}\r
 490                                                 if(yy==0){bakay=1;}\r
 491                                 }else if(q==3){\r
 492                                                 if(xx!=width||yy!=height){\r
 493                                                                 if(xx==0){bakax=1;bakay=-1;d3y=1;}\r
 494                                                                 if(yy==0){bakax=1;bakay=0;d3y=1;}\r
 495                                                                 if(xx==width){bakax=-1;bakay=-1;d3y=1;}\r
 496                                                                 if(yy==height){bakax=1;bakay=0;d3y=1;}\r
 497                                                 }else if(xx==width&&yy==height) xx=yy=0;\r
 498                                 }\r
 499                                 if(q==3){\r
 500                                                 if(d3y){\r
 501                                                                 if(bakay<0){\r
 502                                                                                 yy--;\r
 503                                                                                 d3y--;\r
 504                                                                 }else\r
 505                                                                 if(bakay>0){\r
 506                                                                                 yy++;\r
 507                                                                                 d3y--;\r
 508                                                                 }\r
 509                                                 }\r
 510                                                 if(bakax<0){\r
 511                                                                 xx--;\r
 512                                                 }else\r
 513                                                 if(bakax>0){\r
 514                                                                 xx++;\r
 515                                                 }\r
 516                                 }else{\r
 517                                                 if(q==16)\r
 518                                                 {\r
 519                                                                 if(!bakax){\r
 520                                                                         xx--;\r
 521                                                                 }else if(bakax>0){\r
 522                                                                         xx++;\r
 523                                                                 }\r
 524                                                                 if(!bakay){\r
 525                                                                         yy--;\r
 526                                                                 }else if(bakay>0){\r
 527                                                                         yy++;\r
 528                                                                 }\r
 529                                                 }else{\r
 530                                                                 if(!bakax){\r
 531 //                                                                      xx-=TILEWH;\r
 532                                                                         xx--;\r
 533                                                                 }else if(bakax>1){\r
 534 //                                                                      xx+=TILEWH;\r
 535                                                                         xx++;\r
 536                                                                 }\r
 537                                                                 if(!bakay){\r
 538 //                                                                      yy-=TILEWH;\r
 539                                                                         yy--;\r
 540                                                                 }else if(bakay>1){\r
 541 //                                                                      yy+=TILEWH;\r
 542                                                                         yy++;\r
 543                                                                 }\r
 544                                                 }\r
 545                                 }\r
 546                                 // fixer\r
 547 //                              if(q!=16){\r
 548 //if(q!=16)\r
 549 //                                              if(xx<0) xx=(width-TILEWH);\r
 550 //                                              if(yy<0) yy=(height-TILEWH);\r
 551 //                                              if(xx>(width-TILEWH)) xx=0;\r
 552 //                                              if(yy>(height-TILEWH)) yy=0;\r
 553 //                              }\r
 554 \r
 555 //interesting effects\r
 556                                 if(q==16)\r
 557                                 {\r
 558                                 int tx=0,ty=0;\r
 559                                 tx+=xx+16;\r
 560                                 ty+=yy+16;\r
 561                                 putPixel_X(tx, ty, coor);\r
 562                                 //drawrect(tx, ty, tx+TILEWH, ty+TILEWH, coor);\r
 563                                 //printf("%d %d %d %d %d %d\n", xx, yy, tx, ty, TILEWH);\r
 564 \r
 565                                 // plot the pixel\r
 566 //----            ppf(xx, yy, coor, vga);\r
 567                                 }else /*if(xx>=0 && xx<width && yy>=0 && yy<(height*3))*/{\r
 568 //                                      putColorBox_X(xx, yy, TILEWH, TILEWH, coor);\r
 569 //++++0000\r
 570 //                                      putPixel_X(xx, yy, coor);
 571                                         mxPutPixel(xx, yy, coor);\r
 572                                 } \r
 573 \r
 574 //----            if(q==2) ppf(rand()%, rand()%height, 0, vga);\r
 575 //                              if(q==2) putColorBox_X(rand()%width, rand()%(height*3), TILEWH, TILEWH, 0);\r
 576 //++++0000\r
 577                                 if(q==2) putPixel_X(rand()%width, rand()%(height*3), 0);\r
 578                                 if(q==16) putPixel_X(rand()%width, rand()%(height*3), 0);\r
 579                                 if(q==2||q==4||q==16){ bakax = rand()%3; bakay = rand()%3; }\r
 580                                 gq++;\r
 581 //if(xx<0||xx>320||yy<0||yy>(height*3))\r
 582 //        printf("%d %d %d %d %d %d\n", xx, yy, coor, bakax, bakay, getPixel_X(xx,yy));\r
 583 //        printf("%d\n", getPixel_X(xx,yy));\r
 584 //0000\r
 585 //        drawText(0, 0, 15, getPixel_X(xx,yy));\r
 586                 }else gq = LGQ;\r
 587                 return gq;\r
 588 }\r
 589 \r
 590 \r
 591 /*\r
 592  * The library testing routines follows below.\r
 593  */\r
 594 \r
 595 \r
 596 #ifdef TESTING\r
 597 \r
 598 #include <stdio.h>\r
 599 #include <conio.h>\r
 600 \r
 601 void doTest(void)\r
 602                 {\r
 603                 int p, x, y, pages;\r
 604 \r
 605                 /* This is the way to calculate the number of pages available. */\r
 606                 pages = 65536L/(widthBytes*height); // apparently this takes the A000 address\r
 607 //              if(height==240) pages++;\r
 608 \r
 609 //              printf("%d\n", pages);\r
 610 \r
 611                 for (p = 0; p <= pages; ++p)\r
 612                                 {\r
 613                                 setActivePage(p);\r
 614 \r
 615                                 /* On each page draw a single colored border, and dump the palette\r
 616                                    onto a small square about the middle of the page. */\r
 617 \r
 618                                    //{\r
 619                                                 for (x = 0; x <= width; ++x)\r
 620                                                                 {\r
 621                                                                 putPixel_X(x, 0, p+1);\r
 622                                                                 if(p!=pages) putPixel_X(x, height-1, p+1);\r
 623                                                                                 else if(height==240) putPixel_X(x, 99-1, p+1);\r
 624                                                                 }\r
 625 \r
 626                                                 for (y = 0; y <= height; ++y)\r
 627                                                                 {\r
 628                                                                 putPixel_X(0, y, p+1);\r
 629                                                                 if(p!=pages) putPixel_X(width-1, y, p+1);\r
 630                                                                                 else if(height==240) putPixel_X(width-1, y, p+1);\r
 631                                                                 }\r
 632 \r
 633                                                 for (x = 0; x < TILEWH; ++x)\r
 634                                                                 for (y = 0; y < TILEWH; ++y)\r
 635                                                                                 putPixel_X(x+(p+2)*16, y+(p+2)*TILEWH, x + y*TILEWH);\r
 636                                                 //}\r
 637 \r
 638                                 }\r
 639 \r
 640                 /* Each pages will now contain a different image.  Let the user cycle\r
 641                    through all the pages by pressing a key. */\r
 642                 for (p = 0; p < pages; ++p)\r
 643                                 {\r
 644                                 setVisiblePage(p);\r
 645                                 getch();\r
 646                                 }\r
 647 \r
 648                 }\r
 649 \r
 650 /*\r
 651  * Library test (program) entry point.\r
 652  */\r
 653 \r
 654 int main(void)\r
 655                 {\r
 656                 int key,d,x,y;\r
 657                 //short int temp;\r
 658                 // main variables\r
 659                 d=1; // switch variable\r
 660                 key=4; // default screensaver number\r
 661                 x=0;\r
 662                 y=0;\r
 663 //        puts("First, have a look at the 320x200 mode.  I will draw some rubbish");\r
 664 //        puts("on all of the four pages, then let you cycle through them by");\r
 665 //        puts("hitting a key on each page.");\r
 666 //        puts("Press a key when ready...");\r
 667 //        getch();\r
 668 \r
 669 //        doTest();\r
 670 \r
 671 //        puts("Then, check out Mode X, 320x240 with 3 (and a half) pages.");\r
 672 //        puts("Press a key when ready...");\r
 673 //        getch();\r
 674 \r
 675 //++++0000\r
 676                 setvideo(1);\r
 677                 /*temp = loadfontX("vga8x8.fnt");\r
 678 \r
 679                 if (temp) {\r
 680                         putstringX(0, 0, "bakapi!", 2);\r
 681                 }\r
 682                 getch();*/\r
 683 // screen savers\r
 684 \r
 685 /*while(d!=0){ // on!\r
 686                                 if(!kbhit()){ // conditions of screen saver\r
 687                                                 ding(key);\r
 688                                 }else{\r
 689                                                 setvideo(0);\r
 690                                                 // user imput switch\r
 691                                                 printf("Enter 1, 2, 3, 4, or 6 to run a screensaver, or enter 5 to quit.\n", getch());  // prompt the user\r
 692                                                 scanf("%d", &key);\r
 693                                                 //if(key==3){xx=yy=0;} // crazy screen saver wwww\r
 694                                                 if(key==5) d=0;\r
 695                                                 setvideo(1);\r
 696                                 }\r
 697                 }*/ // else off\r
 698                 while(!kbhit()){ // conditions of screen saver\r
 699                         ding(4);\r
 700                 }\r
 701                 //end of screen savers\r
 702                 //doTest();\r
 703                 getch();\r
 704 \r
 705                 while(!kbhit()){ // conditions of screen saver\r
 706 //                      hScroll(1);\r
 707 //                      scrolly(1);\r
 708 //                      vScroll(1);\r
 709 //                      delay(100);
 710                         for(int i=0;i<TILEWH;i++){\r
 711                                 mxPan(x,y);\r
 712                                 mxWaitRetrace();\r
 713                                 x++;
 714                                 y++;\r
 715                         }
 716                 //delay(100);\r
 717                 }\r
 718                 setvideo(0);\r
 719                 printf("wwww\n%dx%d\n", width,height);\r
 720                 printf("[%d]\n", mxGetVersion());\r
 721                 puts("where to next?  It's your move! wwww");\r
 722                 printf("bakapi ver. 1.04.09.04\nis made by sparky4\81i\81\86\83Ö\81\85\81j feel free to use it ^^\nLicence: GPL v2\n");\r
 723                 return 0;\r
 724                 }\r
 725 \r
 726 #endif\r