home *** CD-ROM | disk | FTP | other *** search
/ Pegasus Games / Pegasus_Games_CD2.iso / sgolf / test.new < prev    next >
Text File  |  1995-07-18  |  14KB  |  857 lines
  1. #include <dos.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include "globals.h"
  5. #include "structur.h"
  6.  
  7. void my_main(void)
  8. {
  9. //    texture=(char *)install("datas\\testmap.bpp");
  10.     texture=(char *)install("datas\\map1.pcd");
  11. //    fade_to_col(1, 0x3f3f3f);                    // flash to white
  12.  
  13.     fade_to_col(1, 0x000000);                    // flash to black in 1 frame
  14.     wait_fade();
  15.          fade_to_pal(63, &game_palette[0][0]);    // fade to game palette in 63 frames
  16.  
  17.  
  18.     keydata->keymap[K_ESC] = 0;
  19.  
  20.     copydest = backscr;
  21.     clr_screen();
  22.  
  23.  
  24.     for (;;) {
  25.  
  26.         sync();
  27.         read_joy();
  28.  
  29. #if DEBUGGING==1
  30.         keydata->last_key = get_key();
  31.         clear_keyb();
  32. #endif
  33.  
  34.         ifkey(K_ESC)
  35.             break;
  36.  
  37.         copysource = backscr;
  38.         copydest = MCGA_RAM;
  39.         dump_screen();
  40.  
  41.         read_mouse();
  42.  
  43.         clear_keyb();
  44.  
  45.         copydest = backscr;
  46.         clr_screen();
  47.  
  48.         print(0, 0, "Mx:%d\nMy:%d\nMb:%d\n\nJ1x:%d\nJ1y:%d\nJ1f:%d\n\nJ2x:%d\nJ2y:%d\nJ2f:%d",
  49.             mx, my, mbut,
  50.             joy1_x, joy1_y, joy1_fire,
  51.             joy2_x, joy2_y, joy2_fire);
  52.         print(0, 100, "1xc:%d\n1yc:%d\n\n1ls:%d\n1rs:%d\n1us:%d\n1ds:%d",
  53.             joy1_xcentre, joy1_ycentre,
  54.             joy1_lscale, joy1_rscale, joy1_uscale, joy1_dscale);
  55.         print(0, 160, "1lt:%d\n1rt:%d\n1ut:%d\n1dt:%d",
  56.             joy1_lthresh, joy1_rthresh, joy1_uthresh, joy1_dthresh);
  57.         print(0, 208, "Keys held: %d\nLast key:%d",
  58.             keydata->keys_held, keydata->last_key);
  59.         *(backscr+my*288+mx) = 2;
  60.     }
  61.  
  62.     col=0;
  63.       for (copydest = backscr; copydest<(backscr+256); copydest++)
  64.         {
  65.         *copydest = col;                        //put palette to screen top edge
  66.         col++;
  67.         col=col&255;
  68.         }
  69.  
  70.          drawtext(10,10);                //put text on screen scale 1-1
  71.          backtext(100,40);                //put text on screen scale 1-1
  72.          halftext(90,100);                //put text on screen scale 1/2
  73.  
  74.         copysource = backscr;
  75.         copydest = MCGA_RAM;
  76.         dump_screen();
  77.  
  78.  
  79.         dotx=200;
  80.         doty=150;
  81.         col=200;
  82.  
  83.     for(;;)
  84.         {
  85.         clear_keyb();
  86.         keydata->last_key = get_key();
  87.         ifkey(K_SPACE)
  88.             break;
  89.  
  90.         ifkey(K_UP)
  91.             {
  92.             col++;
  93.             col=col&255;
  94.             doty--;
  95.             }
  96.         ifkey(K_DOWN)
  97.             {
  98.             col++;
  99.             col=col&255;
  100.             doty++;
  101.             }
  102.         ifkey(K_LEFT)
  103.             {
  104.             col++;
  105.             col=col&255;
  106.             dotx--;
  107.             }
  108.         ifkey(K_RIGHT)
  109.             {
  110.             col++;
  111.             col=col&255;
  112.             dotx++;
  113.             }
  114.  
  115.  
  116.         linep.x1=100;
  117.         linep.y1=100;
  118.         linep.x2=dotx;
  119.         linep.y2=doty;
  120.  
  121.  
  122.         if (clipline())    //if clip returns non zero    (0=false)
  123.             {
  124.             if ( (linep.x1==linep.x2) && (linep.y1==linep.y2) )
  125.                 point();
  126.             else
  127.                 drline();        //draw a line
  128.             }
  129.  
  130.  
  131.         copysource = backscr;
  132.         copydest = MCGA_RAM;
  133.         dump_screen();
  134.         }
  135.  
  136.   
  137.         dang=speed=0;
  138.         mapx=-16*256+200;
  139.         mapz=32*256+20;            //start pos = middle of map
  140.         mapy=1600;
  141.         viewrange=20;
  142.         angle=40;
  143.         altoff=300;
  144.  
  145. // ******************************************************
  146. //    ***************************** landscape routine
  147.     col=254;
  148.  
  149. //    for(cnt=0;cnt<=253;cnt++)
  150. //        game_palette[cnt][0]=63;
  151.     fade_to_pal(1, &game_palette[0][0]);    // fade to game palette in 1 frame
  152.  
  153.  
  154.     for(;;)
  155.         {
  156.         clear_keyb();
  157.         keydata->last_key = get_key();
  158.         ifkey(K_ESC)
  159.             break;
  160.  
  161.     copydest = backscr;
  162.     clr_screen();
  163.  
  164.         control();
  165.  
  166.         print(0, 0, "Mx:%d\nMy:%d\nMz:%d\n",mapx, mapy, mapz);
  167.         print(0, 50, "xoff:%d\nzoff:%d\n",xoff, zoff);
  168.         print(0, 74, "subx:%d\nsubz:%d\n",subx, subz);
  169.  
  170.         spinline();
  171.         spinline2();
  172.         drawmap(0,0,256);            // x,y,size
  173.  
  174.         copysource = backscr;
  175.         copydest = MCGA_RAM;
  176.         dump_screen();
  177.         }
  178.  
  179. }
  180. // ****************************************************************8
  181.  
  182.  
  183. void    drawmap(int x, int z, int size)
  184. {
  185.     int half;
  186.  
  187.     process(x,z,size);
  188.     if (perspec())
  189.     {
  190.     if (size <= rangesize(x+size/2,z+size/2))                //draw square size (small enough) ?
  191.         {
  192. //        if (faceon())
  193.             {
  194.                 col=colr[size];
  195.                 drawblock(x,z,size);
  196.             }
  197.         }
  198.     else                            // else subdivide if not small enough yet to draw
  199.         {
  200.                 half=size/2;
  201.                 drawmap(x,z,half);
  202.                 drawmap(x+half,z,half);
  203.                 drawmap(x,z+half,half);
  204.                 drawmap(x+half,z+half,half);
  205.         }
  206.     }
  207. }
  208.  
  209.  
  210. int    rangesize(int x, int z)
  211. {
  212.     int    dx,dz;
  213.     dx=abs((-mapx>>8)-x);
  214.     dz=abs((mapz>>8)-z);
  215.     if    (dx>dz)
  216.         return subsize[((dx+dz/2)>>3)];
  217.     else
  218.         return subsize[((dz+dx/2)>>3)];
  219. }
  220.  
  221.  
  222. void    drawblock(int x, int z, int size)                //draw one block of map
  223. {
  224.     int    xx,yy;
  225.  
  226. //    if (perspec());            //if no z clipping on perspective
  227. //        {
  228.         if((box.z1>120)&&(box.z2>120))
  229.             {
  230.             linep.x1=box.x1;
  231.             linep.y1=box.y1;
  232.             linep.x2=box.x2;
  233.             linep.y2=box.y2;
  234.             clipdraw();
  235.             }
  236.  
  237.         if((box.z1>120)&&(box.z4>120))
  238.             {
  239.             linep.x1=box.x1;
  240.             linep.y1=box.y1;
  241.             linep.x2=box.x4;
  242.             linep.y2=box.y4;
  243.             clipdraw();
  244.             }
  245. //        }
  246. }
  247.  
  248.  
  249. int    process(int x, int z, int size)
  250. {
  251.     int xx,yy;
  252.     xx=x-xblock;
  253.     yy=z-zblock;
  254.     
  255.  
  256.     box.x1= (xx*zvect)+(yy*xvect)+subx;
  257.     box.z1= (yy*zvect)-(xx*xvect)+subz;
  258.  
  259.     box.x2= box.x1+(size*zvect);
  260.     box.z2= box.z1-(size*xvect);
  261.  
  262.     box.x3= box.x2+(size*xvect);
  263.     box.z3= box.z2+(size*zvect);
  264.  
  265.     box.x4= box.x1+(size*xvect);
  266.     box.z4= box.z1+(size*zvect);
  267.  
  268.  
  269.     box.y1= mapy+high(x,z);
  270.     box.y2= mapy+high(x+size,z);
  271.     box.y3= mapy+high(x+size,z+size);
  272.     box.y4= mapy+high(x,z+size);
  273.  
  274. }
  275.  
  276.  
  277.  
  278. int    faceon()
  279. {
  280.     int a,b;
  281.     
  282.     a=(box.x3-box.x1)*(box.y2-box.y1);
  283.     b=(box.y3-box.y1)*(box.x2-box.x1);
  284.         
  285.     if ((a-b)>=-2000)
  286.         return -1;
  287.     else
  288.         return 0;                //return 0
  289. }
  290.  
  291.  
  292. int    closey()
  293. {
  294.     int zd,yd;
  295.     zd=abs(box.z1);
  296.     yd=box.y1;
  297.  
  298.      if (abs(box.z2)<zd)
  299.         {
  300.         zd=box.z2;
  301.         yd=box.y2;
  302.         }
  303.      if (abs(box.z3)<zd)
  304.         {
  305.         zd=box.z3;
  306.         yd=box.y3;
  307.         }
  308.      if (abs(box.z4)<zd)
  309.         {
  310.         zd=box.z4;
  311.         yd=box.y4;
  312.         }
  313.     return yd;
  314. }
  315.  
  316. int    fary()
  317. {
  318.     int zd,yd;
  319.     zd=abs(box.z1);
  320.     yd=box.y1;
  321.  
  322.     if (abs(box.z2)>zd)
  323.         {
  324.         zd=box.z2;
  325.         yd=box.y2;
  326.         }
  327.      if (abs(box.z3)>zd)
  328.         {
  329.         zd=box.z3;
  330.         yd=box.y3;
  331.         }
  332.      if (abs(box.z4)>zd)
  333.         {
  334.         zd=box.z4;
  335.         yd=box.y4;
  336.         }
  337.     return yd;
  338. }
  339.  
  340.  
  341. //        rotate 1st point in the line stucture line2
  342. void    rotate(long angl)
  343. {
  344.         short    s,c;
  345.         s=sin(angl);
  346.         c=cos(angl);
  347.         linepl.x2 = (linepl.x1*s + linepl.y1*c) >> 16;
  348.         linepl.y2 = (linepl.x1*c - linepl.y1*s) >> 16;
  349.  
  350. //        linepl.x2 = (linepl.x1*c - linepl.y1*s) >> 16;
  351. //        linepl.y2 = (linepl.x1*s + linepl.y1*c) >> 16;
  352.  
  353. }
  354.  
  355.  
  356. int    high2(int x, int z)
  357. {
  358.     short    s,c,o;
  359.  
  360.     s=sin((x<<3)&2047);
  361.     c=cos((z<<4)&2047);
  362.     o=sin(((z+x)<<5)&2047);
  363.  
  364. //    return (int)((s-c+((o*o)>>17))>>4);                    //HILLY MAP
  365.     return (int)((s-c+((o*o)>>17))>>4+((o*s)>>24));    //MAD MAP
  366. //    return 0;                    //FLAT MAP
  367. }
  368.  
  369.  
  370. int    high(int x, int z)
  371. {
  372.             char    *source;
  373.             int    zh;
  374.  
  375.     source = texture+4+(z/2)*128+(x/2);
  376.     if (!(x&1) && !(z&1))
  377.         {
  378.         return -(*source)<<2;
  379.         }
  380.     else
  381.         {
  382.         if ((x&1) && (z&1))
  383.             {
  384.                 zh= (*source+ *(source+1))  ;
  385.                 zh+= (*source+ *(source+128))  ;
  386.                 zh+= (*(source+128)+ *(source+129))  ;
  387.                 zh+= (*(source+1)+ *(source+129))  ;
  388.         return -zh>>1;
  389.             }
  390.         
  391. else
  392.             if (x&1)
  393.                 return -(*source+*(source+1))<<1;
  394.             else
  395.                 return -(*source+*(source+128))<<1;
  396.         }
  397. }
  398.  
  399.  
  400. //    perspective routine on list of 4 x,y,z points in space (to centre of screen)
  401. int    perspec()
  402. {
  403.     if (box.z1>70 && box.z2>70 && box.z3>70 && box.z4>70)
  404.         {
  405.         box.x1 = (box.x1 << 8)/box.z1+144;
  406.         box.x2 = (box.x2 << 8)/box.z2+144;
  407.         box.x3 = (box.x3 << 8)/box.z3+144;
  408.         box.x4 = (box.x4 << 8)/box.z4+144;
  409.  
  410.         box.y1 = (box.y1 << 8)/box.z1+110;
  411.         box.y2 = (box.y2 << 8)/box.z2+110;
  412.         box.y3 = (box.y3 << 8)/box.z3+110;
  413.         box.y4 = (box.y4 << 8)/box.z4+110;
  414.         return -1;            //ok no z clipping
  415.         }
  416.     else
  417.         return 0;
  418. }
  419.  
  420.  
  421. //    perspective routine on list of 4 x,y,z points in space (to centre of screen)
  422. int    perspec2()
  423. {
  424.         box.x1 = (box.x1 >> 7)+144;
  425.         box.x2 = (box.x2 >> 7)+144;
  426.         box.x3 = (box.x3 >> 7)+144;
  427.         box.x4 = (box.x4 >> 7)+144;
  428.  
  429.         box.y1 = (box.z1 >> 7)+100;
  430.         box.y2 = (box.z2 >> 7)+100;
  431.         box.y3 = (box.z3 >> 7)+100;
  432.         box.y4 = (box.z4 >> 7)+100;
  433.         return -1;            //ok no z clipping
  434. }
  435.  
  436.  
  437. // clipdraw    :clips a line and draws it
  438. void    clipdraw()
  439. {
  440.         if (clipline())    //if clip returns non zero    (0=false)
  441.             {
  442.             if ( (linep.x1==linep.x2) && (linep.y1==linep.y2) )
  443.                 point();
  444.             else
  445.                 drline();        //draw a line
  446.             }
  447. }
  448.  
  449.  
  450. // ********************************************************************8
  451. void    spinline()
  452. {
  453.         linep.x1=20;
  454.         linep.y1=20;
  455.         linep.x2=20+(sin(angle)>>9);
  456.         linep.y2=20+(cos(angle)>>9);
  457.  
  458.  
  459.         if (clipline())    //if clip returns non zero    (0=false)
  460.             {
  461.             if ( (linep.x1==linep.x2) && (linep.y1==linep.y2) )
  462.                 point();
  463.             else
  464.                 drline();        //draw a line
  465.             }
  466. }
  467.  
  468. void    spinline2()
  469. {
  470.         box.z3=box.z4=20;
  471.  
  472.  
  473.         linep.y1=20;
  474.  
  475.         box.x1=0;
  476.         box.z1=400;
  477.         box.y1=-100;
  478.  
  479.         box.x2=(sin(angle)>>7);
  480.         box.z2=400+(cos(angle)>>7);
  481.         box.y2=-100;
  482.  
  483.         perspec();
  484.  
  485.         linep.x1=box.x1;
  486.         linep.y1=box.y1;
  487.         linep.x2=box.x2;
  488.         linep.y2=box.y2;
  489.  
  490.  
  491.         if (clipline())    //if clip returns non zero    (0=false)
  492.             {
  493.             if ( (linep.x1==linep.x2) && (linep.y1==linep.y2) )
  494.                 point();
  495.             else
  496.                 drline();        //draw a line
  497.             }
  498. }
  499.  
  500.  
  501. void    control()
  502. {
  503.     int    ang;
  504.         ifkey(K_A)
  505.             altoff+=25;
  506.         ifkey(K_Z)
  507.             altoff-=25;
  508.         ifkey(K_LEFT)
  509.             dang--;
  510.         ifkey(K_RIGHT)
  511.             dang++;
  512.         ifkey(K_SPACE)
  513.             dang=0;
  514.         ifkey(K_UP)
  515.             {
  516.             mapx +=(sin((angle+512)&2047) >> 7);
  517.             mapz +=(cos((angle+512)&2047) >> 7);
  518.             }
  519.         ifkey(K_DOWN)
  520.             {
  521.             mapx -=(sin((angle+512)&2047) >> 7);
  522.             mapz -=(cos((angle+512)&2047) >> 7);
  523.             }
  524.  
  525.         mapz=mapz&65535;
  526.         if (mapx>0)
  527.             mapx=0;
  528.         if    (mapx<-65535)
  529.             mapx=-65535;
  530.  
  531.         ifkey(K_I)
  532.             mapz+=64;
  533.         ifkey(K_J)
  534.             mapx+=64;
  535.         ifkey(K_K)
  536.             mapx-=64;
  537.         ifkey(K_M)
  538.             mapz-=64;
  539.  
  540.         angle = (angle+dang)&2047;
  541.         xoff = mapx & 255;
  542.         zoff = mapz & 255;
  543.  
  544.         ang = (angle+512)&2047;                //512=90 degs
  545.         xvect = sin(ang) >> 8;        //vector of 1 block from my heading
  546.         zvect = cos(ang) >> 8;        //   >>7
  547.         
  548.         xblock = abs(mapx >> 8);
  549.         zblock = abs(mapz >> 8);
  550.  
  551.         linepl.x1=xoff;
  552.         linepl.y1=zoff;
  553.         rotate((angle)&2047);
  554.         subx = linepl.x2;
  555.         subz = linepl.y2;
  556.         follow();
  557. }
  558.         
  559.         
  560. //        follow height contour of the land
  561. void    follow()
  562. {
  563.     int    y1,y2,y3,y4;
  564.     int    xb,zb;
  565.     int    h1,h2;
  566.         xb = -mapx >> 8;
  567.         zb = mapz >> 8;
  568.         
  569.     y1= high(xb,zb);
  570.     y2= high(xb+1,zb);
  571.     y3= high(xb+1,zb+1);
  572.     y4= high(xb,zb+1);
  573.  
  574.     h1 = y1 + (((y2-y1) * (256-xoff)) >> 8);
  575.     h2 = y4 + (((y3-y4) * (256-xoff)) >> 8);
  576.     mapy=altoff - h1+ (((h2-h1) * (256-zoff)) >> 8);
  577. }
  578.  
  579.  
  580.  
  581.  
  582.     
  583.  
  584.  
  585.  
  586.         
  587.         //clipline clips a line , stored in structure linep
  588. int    clipline()
  589. {
  590.     int    i,swap;
  591.     if (linep.x2 < linep.x1)
  592.         swapinx();
  593.  
  594.     if ((linep.x1>287) || (linep.x2<0))
  595.         return 0;                //no draw if both points to right of screen
  596.     else
  597.         {
  598.         clipright();
  599.         clipleft();
  600.  
  601.         if (linep.y2 < linep.y1)
  602.             {
  603.             swapinx();                //swap points so y1<y2
  604.             }
  605.  
  606.         if ((linep.y1>223) || (linep.y2<0))
  607.             return 0;                //no draw if both points to right of screen
  608.         else
  609.             {
  610.             clipup();
  611.             clipdown();
  612.             return -1;
  613.             }
  614.         }
  615. }
  616.  
  617.  
  618.  
  619.  
  620. void    clipright()
  621. {
  622.         int    dx,dy,ex,ey;
  623.  
  624.     if (linep.x2>287)                //is clip required ?
  625.         {
  626.         dx=linep.x2-linep.x1;
  627.         dy=linep.y2-linep.y1;
  628.         ex=288-linep.x1;
  629.         ey=(dy*ex)/dx;
  630.         linep.y2=linep.y1+ey;
  631.         linep.x2=287;
  632.         }
  633. }
  634.  
  635.  
  636. void    clipleft()
  637. {
  638.         int    dx,dy,ex,ey;
  639.  
  640.     if (linep.x1 < 0)                //is clip required ?
  641.         {
  642.         dx=linep.x2-linep.x1;
  643.         dy=linep.y2-linep.y1;
  644.         ex= -(linep.x1);
  645.         ey=(dy*ex)/dx;
  646.          linep.y1 += ey;
  647.         linep.x1=0;
  648.         }
  649. }
  650.  
  651.  
  652. void    clipup()
  653. {
  654.         int    dx,dy,ex,ey;
  655.  
  656.     if (linep.y1<0)                //is clip required ?
  657.         {
  658.         dx=linep.x2-linep.x1;
  659.         dy=linep.y2-linep.y1;
  660.         ey=-(linep.y1);
  661.         ex=(dx*ey)/dy;
  662.         linep.y1=0;
  663.         linep.x1+=ex;
  664.         }
  665. }
  666.  
  667.  
  668.  
  669. void    clipdown()
  670. {
  671.         int    dx,dy,ex,ey;
  672.  
  673.     if (linep.y2>223)                //is clip required ?
  674.         {
  675.         dx=linep.x2-linep.x1;
  676.         dy=linep.y2-linep.y1;
  677.         ey=224-linep.y1;
  678.         ex=(dx*ey)/dy;
  679.         linep.x2=linep.x1+ex;
  680.         linep.y2=223;
  681.         }
  682. }
  683.  
  684.  
  685. void    swapinx()
  686. {
  687.         int    swap;
  688.         swap=linep.x2;
  689.         linep.x2=linep.x1;
  690.         linep.x1=swap;
  691.  
  692.         swap=linep.y2;
  693.         linep.y2=linep.y1;
  694.         linep.y1=swap;
  695. }
  696.  
  697.  
  698.  
  699. void    point()
  700. {
  701.             char    *start;
  702.             start = backscr + 288 * linep.y1 + linep.x1;
  703.             *start = col;                //set colour
  704. }
  705.  
  706.         /* drline    :routine to draw a line  */
  707. void    drline()
  708. {
  709.             int    i,st,dx,dy,ax,ay;
  710.             int    x1,y1,x2,y2;
  711.             int    yy,end,ab;
  712.             char    *start;
  713.             x1=linep.x1;
  714.             y1=linep.y1;
  715.             x2=linep.x2;
  716.             y2=linep.y2;
  717.  
  718.             st=0;
  719.             start = backscr + 288 * y1 + x1;
  720.             ax = sgn(x2-x1);
  721.             ay = sgn(y2-y1);
  722.             yy=288*ay;
  723.  
  724.  
  725.             if (abs(x2-x1) < abs(y2-y1))
  726.                 {
  727.                 end = abs(y2-y1);
  728.                 dx=256*(x2-x1)/(y2-y1);
  729.                 ab = abs(dx);
  730.                 for(i=0; i<end; i++)
  731.                     {
  732.                     *start = col;                //set colour
  733.                     start +=yy;
  734.                     st += ab;
  735.                     if (st>255)
  736.                         {
  737.                         start +=ax;
  738.                         st -= 256;
  739.                         }
  740.                     }
  741.                 }
  742.             else
  743.                 {
  744.                 end = abs(x2-x1);
  745.                 dy=256*(y2-y1)/(x2-x1);
  746.                 ab = abs(dy);
  747.                 for(i=0; i<end; i++)
  748.                     {
  749.                     *start = col;                //set colour
  750.                     start+=ax;
  751.                     st += ab;
  752.                     if (st>255)
  753.                         {
  754.                         start +=yy;
  755.                         st -= 256;
  756.                         }
  757.                     }
  758.                 }
  759. }
  760.  
  761.  
  762. int    sgn(int val)
  763. {
  764.     if (val!=0)
  765.         val=val/abs(val);
  766.     else
  767.         val=1;
  768.  
  769.     return (val);
  770. }
  771.  
  772.      
  773.          /*    drawtext routine to stick texture onto screen */
  774. int    drawtext(int xx,int yy)
  775. {
  776.             int    wid,hig,x,y;
  777.             char    *source;
  778.  
  779.             x = y = 0;
  780.             wid = 128;
  781.             hig = 128;
  782.  
  783.             copydest = backscr + 288 * yy + xx;
  784.             source = texture;
  785.  
  786.             for (y=hig ;y>0 ;y-- )
  787.                 {
  788.                 for (x=wid ;x>0 ; x--)
  789.                     {
  790.                     *copydest++ = *source++;
  791.                     }
  792.                     copydest += 288-wid;
  793.                 }
  794.  
  795.         return 0;
  796. }
  797.  
  798.  
  799.  
  800.  
  801.         /*    drawtext routine to stick texture onto screen backwards*/
  802. int    backtext(int xx,int yy)
  803. {
  804.             int    wid,hig,x,y;
  805.             char    *source;
  806.  
  807.             x = y = 0;
  808.             wid = 128;
  809.             hig = 128;
  810.  
  811.             copydest = backscr + 288 * yy + xx + wid;
  812.             source = texture;
  813.  
  814.             for (y=hig ;y>0 ;y-- )
  815.                 {
  816.                 for (x=wid ;x>0 ; x--)
  817.                     {
  818.                     *copydest-- = *source++;
  819.                     }
  820.                     copydest += 288+wid;
  821.                 }
  822.  
  823.             return 0;
  824.         }
  825.  
  826.  
  827.  
  828.         /*    drawtext routine to stick texture onto screen half size*/
  829. int    halftext(int xx,int yy)
  830. {
  831.             int    wid,hig,x,y;
  832.             char    *source;
  833.  
  834.             x = y = 0;
  835.             wid = 128;
  836.             hig = 128;
  837.  
  838.             copydest = backscr + 288 * yy + xx;
  839.             source = texture;
  840.  
  841.             for (y=hig ;y>0 ;y-=2 )
  842.                 {
  843.                 for (x=wid ;x>0 ; x-=2)
  844.                     {
  845.                     *copydest++ = *source++;
  846.                     source++;
  847.                     }
  848.                     copydest += 288-wid/2;
  849.                     source +=wid;
  850.                 }
  851.  
  852.             return 0;
  853. }
  854.  
  855.  
  856.                  
  857.