home *** CD-ROM | disk | FTP | other *** search
/ Aztec Shareware Collection / ARCADE_1.ISO / snarf / main.c < prev    next >
C/C++ Source or Header  |  1988-03-15  |  17KB  |  846 lines
  1. #define    INMAIN    1
  2.  
  3. #include    <stdio.h>
  4. #include    <fcntl.h>
  5. #include    <math.h>
  6. #include    "snarf.h"
  7.  
  8. extern    int    beepflg;
  9.  
  10. /************************************************************************
  11.  * MAIN function                            *
  12.  ************************************************************************/
  13.  
  14. void    main(argc, argv)
  15. int    argc;
  16. char    *argv[];
  17. {
  18.     FILE    *fp;
  19.     int    i, j;
  20.  
  21.     init();
  22. new_game:
  23.     init_screen();
  24.     while( !iskey() ) ;
  25.     next_screen();
  26. start_fresh:
  27.  
  28.     while(1) {
  29.         while( !iskey() ) {
  30.             while( timepass < 1 ) ;
  31.             timepass = 0;
  32.             move_man();
  33.             if( shots.dir != -1 ) move_shot();
  34.             show_points();
  35.             show_tag();
  36.     for(i=0; i<MAXBUGS; i++) {
  37.         if( bugs[i].dir == -1 || bugs[i].dir > 3 ) set_bug_loc(i, 0);
  38.         else set_bug_loc(i, (19-(bugs[i].y>>4))*41+(bugs[i].x>>4)+1 );
  39.     }
  40.             man_dirs(field, (19-(mans.y>>4))*41+(mans.x>>4)+1);
  41.             for(i=0; i<MAXBUGS; i++) move_bug(i);
  42.             if( okbugmake ) {
  43.                 if( --bugmaketime ) {
  44.                     okbugmake = 0;
  45.                     bugmaketime = rand(256);
  46.                 }
  47.                 if( rand(10) > 8 ) make_bug(i);
  48.             } else {
  49.                 if( --bugmaketime ) {
  50.                     okbugmake = 1;
  51.                     bugmaketime = rand(2048);
  52.                 }
  53.             }
  54.             if( dead==1 ) {
  55.                 clear_sscore();
  56.                 sscore += points;
  57.                 show_sscore();
  58.                 score += points;
  59.                 show_score();
  60.                 clear_points();
  61.                 if( score > highscore ) {
  62.                     highscore = score;
  63.                     show_high();
  64.                 }
  65.                 timepass = 0;
  66.                 while( timepass<18 ) ;
  67.                 while( iskey() ) key();
  68.                 pause();
  69.                 key();
  70.                 check_new_high();
  71.                 goto new_game;
  72.             }
  73.         }
  74.  
  75.         switch( key() ) {
  76.          case 0x3920:    /* space */
  77.             pause();
  78.             break;
  79.          case 0x3b00:    /* f1 */
  80.             choose_palette();
  81.             break;
  82.          case 0x3c00:    /* f2 */
  83.             choose_colors();
  84.             --curwall;
  85.             next_screen();
  86.             goto start_fresh;
  87.          case 0x3d00:    /* f3 */
  88.             edit_walls();
  89.             --curwall;
  90.             next_screen();
  91.             goto start_fresh;
  92.          case 0x4400:    /* f10 */
  93.             beepflg = !beepflg;
  94.             break;
  95.          case 0x011b:    /* esc */
  96.             uninit();
  97.             exit(0);
  98.          case 0x4d00:    /* rtcurs */
  99.             newmandir = 0;
  100.             break;
  101.          case 0x4800:    /* upcurs */
  102.             newmandir = 1;
  103.             break;
  104.          case 0x4b00:    /* lfcurs */
  105.             newmandir = 2;
  106.             break;
  107.          case 0x5000:    /* dncurs */
  108.             newmandir = 3;
  109.             break;
  110.          case 0x2064:    /* d */
  111.          case 0x2044:
  112.             fire(0);
  113.             break;
  114.          case 0x1177:    /* w */
  115.          case 0x1157:
  116.             fire(1);
  117.             break;
  118.          case 0x1e61:    /* a */
  119.          case 0x1e41:
  120.             fire(2);
  121.             break;
  122.          case 0x2d78:    /* x */
  123.          case 0x2d58:
  124.             fire(3);
  125.             break;
  126.          default:
  127.             newmandir = mans.dir | 0x80;
  128.             break;
  129.         }
  130.     }
  131. }
  132.  
  133. void    check_new_high() {
  134.  
  135.     FILE    *fp;
  136.     int    i, j, k;
  137.     char    dots[13];
  138.  
  139.     strcpy(dots, ".......... ");
  140.     dots[12] = 0;
  141.     for(i=0; i<64; i++) {
  142.         if( score > highlist[i].score )  {
  143.             for(j=63; j && j>i; j--) {
  144.                 highlist[j].score = highlist[j-1].score;
  145.                 strcpy(highlist[j].name, highlist[j-1].name);
  146.             }
  147.             highlist[i].score = score;
  148.             highlist[i].name[0] = 0;
  149.             for(j=YORG; j<YMAX-2; j++) horline(XORG, j, XMAX-3, 0, 0);
  150.             flabel(300, 175, "name: ", 2, 0, 0);
  151.             k=0;
  152.             flabel(336+6*k, 175, " ", 0,2,0);
  153.             flabel(336+6*(k+1), 175, &dots[k], 2, 0, 0);
  154.             while( (0x1c0d != (j=key())) && (j!=0x011b) ) {
  155.                 if( j==0x0e08 ) {
  156.                     if( k ) highlist[i].name[--k] = 0;
  157.                     else beep_seq(beep_ill_key);
  158.                 } else if( ((j&0xff)<1) || ((j&0xff)>127) || k==11) {
  159.                     beep_seq(beep_ill_key);
  160.                 } else {
  161.                     highlist[i].name[k++] = j;
  162.                     highlist[i].name[k] = 0;
  163.                 }
  164.                 flabel(336, 175, highlist[i].name, 6, 0, 0);
  165.                 flabel(336+6*k, 175, " ", 0,2,0);
  166.                 flabel(336+6*(k+1), 175, &dots[k], 2, 0, 0);
  167.             }
  168.             if( NULL!=(fp=fopen("SNARF.HI", "wb")) ) {
  169.                 fwrite((char *)(&highlist[0].score),16,64,fp);
  170.                 fclose(fp);
  171.             }
  172.             break;
  173.         }
  174.     }
  175. }
  176.  
  177.  
  178. void    pause() {
  179.  
  180.     flabel(320-6*8, 10, "...press a key...", 15, 9, 0);
  181.     horline(320-6*8, 11, 320+6*9, 9, 0);
  182.     while( !iskey() ) ;
  183.     clear_bottom();
  184. }
  185.  
  186.  
  187. void    fire(dir)
  188. int    dir;
  189. {
  190.     int    i;
  191.  
  192.     if(shots.dir == -1) {
  193.         shots.dir = dir;
  194.         shots.x   = mans.x & 0xfff0;
  195.         shots.y   = mans.y & 0xfff0;
  196.         show_shot();
  197.         return;
  198.     } else {
  199.         beep_seq(beep_click);
  200.     }
  201. }
  202.  
  203.  
  204. void    init() {
  205.  
  206.     int    i;
  207.     FILE    *fp;
  208.  
  209.     setrand(0);
  210.     setmode(0x10);    /* set ega mode 640x350 */
  211.     take_timer();
  212.     for(i=0; i<64; i++) {
  213.         highlist[i].score = 0;
  214.         highlist[i].name[0] = 0;
  215.     }
  216.     if( NULL!=(fp=fopen("SNARF.HI", "rb")) ) {
  217.         fread((char *)(&highlist[0].score),16,64,fp);
  218.         fclose(fp);
  219.     }
  220. }
  221.  
  222. void    setpalette(i,cursor)
  223. int    i, cursor;
  224. {
  225.  
  226.     int    j;
  227.     char    temp[81];
  228.  
  229.     setcolors(i, palette[i]);
  230. }
  231.  
  232.  
  233. void    uninit() {
  234.  
  235.     setmode(0x03);    /* set 80x25 color alphanumerics */
  236.     give_timer();
  237. }
  238.  
  239.  
  240. void    scorebox(x, digwidth, s)
  241. int    x, digwidth;
  242. char    *s;
  243. {
  244.     int    i;
  245.  
  246.     box(x, YMAX+3, x+14*digwidth+8, YMAX+22, 15, 0);
  247.     for(i=YMAX+4; i<YMAX+22; i++) horline(x+1, i, x+14*digwidth+7, 0, 0);
  248.     flabel(x+(14*digwidth-6*strlen(s))/2+5, 348, s, 15, 0, 0);
  249. }
  250.  
  251. void    clear_bottom() {
  252.  
  253.     int    i;
  254.  
  255.     for(i=0; i<YORG-7; i++) horline(0,i,639,11,0);
  256. }
  257.  
  258.  
  259. /****************************************************************
  260.  * INIT_SCREEN()                        *
  261.  ****************************************************************/
  262.  
  263. void    init_screen() {
  264.  
  265.     int    i, j, k;
  266.     unsigned char    *p, *r, c;
  267.  
  268.     /* create bplot data for score digits */
  269.  
  270.     for(i=0; i<10; i++) {
  271.         p = digits[i];
  272.         r = hold1;
  273.         for(j=0; j<28; j++) {
  274.             c = *p++;
  275.             for(k=0x80; k; k=k>>1) {
  276.                 if( c & k )    *r++ = score_color;
  277.                 else        *r++ = 0;
  278.             }
  279.         }
  280.         for(j=0; j<32; j++) *r++ = '\0';
  281.         convert(hold1, digbits[i]);
  282.     }
  283.  
  284.     /* init screen */
  285.  
  286.     clrscreen(0);
  287.  
  288.     for(i=0; i<16; i++) setpalette(i, 0);
  289.     box(XORG-8, YORG-6, XMAX, YMAX, colors[0], 0);
  290.     box(XORG-6, YORG-4, XMAX-2, YMAX-2, colors[2], 0);
  291.     for(i=XORG-7; i<XMAX; i++, i++) {
  292.         plotxy(i, YORG-5, colors[1], 0);
  293.         plotxy(i, YMAX-1, colors[1], 0);
  294.     }
  295.     for(i=YORG-5; i<YMAX; i++, i++) {
  296.         plotxy(XORG-7, i, colors[1], 0);
  297.         plotxy(XMAX-1, i, colors[1], 0);
  298.     }
  299.  
  300.     clear_bottom();
  301.     for(i=YMAX+2; i<350; i++) horline(0,i,639,11,0);
  302.     scorebox( 40, 2, " TAGS ");
  303.     scorebox( 92, 4, " POINTS ");
  304.     scorebox(172, 6, " LEVEL SCORE ");
  305.     scorebox(278, 9, " SCORE ");
  306.     scorebox(424, 2, " LEVEL ");
  307.     scorebox(474, 9, " HIGH SCORE ");
  308.  
  309.     tagcount = 50;
  310.     tagflg = 2;
  311.     dead = 0;
  312.     curscreen = 0;
  313.  
  314.     /* build & display CURWALL field */
  315.  
  316.     curwall = -1;
  317.     score = 0L;
  318.     show_score();
  319.     welcome();
  320. }
  321.  
  322. void    welcome() {
  323.  
  324.     int    i,j,k;
  325.     char    buff[81];
  326.  
  327.     highscore = highlist[0].score;
  328.     show_high();
  329.  
  330.     newbplotxy(346, 312, 16, 2, man[0], 0);
  331.     newbplotxy(344, 292, 16, 2, goodies[3], 0);
  332.     newbplotxy(344, 272, 16, 2, goodies[2], 0);
  333.     newbplotxy(344, 252, 16, 2, goodies[1], 0);
  334.     newbplotxy(344, 232, 16, 2, goodies[0], 0);
  335.     newbplotxy(344, 212, 16, 2, tagboost, 0);
  336.  
  337.     newbplotxy(516, 312, 16, 2, keylock, 0);
  338.     newbplotxy(516, 292, 16, 2, keys, 0);
  339.     newbplotxy(516, 272, 16, 2, teleport, 0);
  340.     newbplotxy(516, 252, 16, 2, pits, 0);
  341.     newbplotxy(516, 232, 16, 2, bug1[0], 0);
  342.  
  343.     flabel(366, 308, "The Hero (that's you)", 4, 0, 0);
  344.     sprintf(buff, "ring %d point", values[3]);
  345.     flabel(366, 288, buff, 4, 0, 0);
  346.     sprintf(buff, "ring %d points", values[2]);
  347.     flabel(366, 268, buff, 4, 0, 0);
  348.     sprintf(buff, "ring %d points", values[1]);
  349.     flabel(366, 248, buff, 4, 0, 0);
  350.     sprintf(buff, "crown %d points", values[0]);
  351.     flabel(366, 228, buff, 4, 0, 0);
  352.     flabel(366, 208, "First Aid station", 4, 0, 0);
  353.  
  354.     flabel(538, 308, "locked door", 4, 0, 0);
  355.     flabel(538, 288, "key", 4, 0, 0);
  356.     flabel(538, 268, "teleport", 4, 0, 0);
  357.     flabel(538, 248, "Snarf nest", 4, 0, 0);
  358.     flabel(538, 228, "the SNARF", 4, 0, 0);
  359.  
  360.     flabel(XORG+6, 310, "Pick up treasures, unlock doors, move from level to", 12, 0, 0);
  361.     flabel(XORG+6, 300, "level.  At the end of each level, treasure POINTS  ", 12, 0, 0);
  362.     flabel(XORG+6, 290, "are multiplied by the TAGS left to calculate the   ", 12, 0, 0);
  363.     flabel(XORG+6, 280, "LEVEL SCORE.  The LEVEL SCORE is then added to the ", 12, 0, 0);
  364.     flabel(XORG+6, 270, "game SCORE.  You lose a TAG count each time you are", 12, 0, 0);
  365.     flabel(XORG+6, 260, "touched by a Snarf. If you are tagged when your TAG", 12, 0, 0);
  366.     flabel(XORG+6, 250, "count is 0, the game ends.  You can restore your   ", 12, 0, 0);
  367.     flabel(XORG+6, 240, "TAGS count to the maximum at a First Aid station.  ", 12, 0, 0);
  368.     flabel(XORG+6, 230, "Snarfs are created in Snarf Nests.  You can travel ", 12, 0, 0);
  369.     flabel(XORG+6, 220, "through a TELEPORT, but Snarfs can't. If you finish", 12, 0, 0);
  370.     flabel(XORG+6, 210, "the last level (number xx), you win the game.      ", 12, 0, 0);
  371.     flabel(XORG+6, 200, "---------------------------------------------------", 12, 0, 0);
  372.  
  373.     for(i=0; i<4; i++) {
  374.         if( highlist[i*16].score == 0 ) break;
  375.         for(j=0; j<16; j++) {
  376.             if( highlist[i*16+j].score == 0 ) break;
  377.             sprintf(buff, "%8.8ld", highlist[i*16+j].score);
  378.             for(k=0; k<7 && buff[k]=='0'; k++) buff[k] = ' ';
  379.             flabel(XORG+156*i, YORG+160-10*j, buff, 2, 0, 0);
  380.             flabel(XORG+66+156*i, YORG+160-10*j, highlist[i*16+j].name, 6, 0, 0);
  381.         }
  382.     }
  383. }
  384.  
  385.  
  386. void    next_screen() {
  387.  
  388.     int    i, j, k;
  389.     unsigned char    *p, *r, c;
  390.  
  391.     ++curscreen;
  392.     show_level();
  393.     tagflg = 2;
  394.     setcolors(11, tagcount);
  395.  
  396.     if(++curwall >= MAXWALLS) curwall=0;
  397.  
  398.     for(i=YORG; i<YMAX-2; i++) horline(XORG, i, XMAX-3, 0, 0);
  399.  
  400.     build_wall();
  401.  
  402.     for(i=0; i<820; i++) field[i] = -1;
  403.     p = walls[curwall];
  404.     for(i=1; i<19; i++) {
  405.         for(j=0; j<5; j++) {
  406.             c = *p++;
  407.             for(k=0; k<8; k++) {
  408.                 field[i*41+j*8+k+1] = (c & 0x80) ? 1 : 0;
  409.                 c = c<<1;
  410.             }
  411.         }
  412.     }
  413.     for(i=0; i<MAXPITS; i++) pitlist[i].x = -1;
  414.     for(i=0; i<MAXOBJECTS; i++) {
  415.         p = &field[ 41*treasure[curwall][i].y + treasure[curwall][i].x ];
  416.         switch( treasure[curwall][i].item & 0xf0 ) {
  417.          case 0x10:    /* teleport */
  418.             *p = treasure[curwall][i].item;
  419. /*
  420.             *(p-1) = ((*p & 0x01)<<1) | 0x10;
  421.             *(p+1) = (((*p & 0x01)<<1)+1) | 0x10;
  422. */
  423.             break;
  424.          case 0x30:    /* man start position */
  425.             mans.x = (treasure[curwall][i].x-1)*16;
  426.             mans.y = (19-treasure[curwall][i].y)*16;
  427.             break;
  428.          case 0x20:    /* pit */
  429.             for(j=0; j<MAXPITS; j++) {
  430.                 if( pitlist[j].x == -1 ) {
  431.                     pitlist[j].x = (treasure[curwall][i].x-1)*16;
  432.                     pitlist[j].y = (19-treasure[curwall][i].y)*16;
  433.                     break;
  434.                 }
  435.             }
  436.             *p = treasure[curwall][i].item;
  437. /*
  438.             switch( *p & 0x0f ) {
  439.              case 1:
  440.                 *(p-41) = 0x2a;
  441.                 *(p+41) = 0x20;
  442.                 break;
  443.              case 3:
  444.                 *(p-1) = 0x2e;
  445.                 *(p+1) = 0x24;
  446.                 break;
  447.              case 5:
  448.                 *(p-41) = 0x26;
  449.                 *(p+41) = 0x22;
  450.                 break;
  451.              case 7:
  452.                 *(p-1) = 0x2c;
  453.                 *(p+1) = 0x28;
  454.                 break;
  455.              default:
  456.                 break;
  457.             }
  458. */
  459.             break;
  460.          case 0x40:    /* treasure */
  461.          case 0x60:    /* key */
  462.          case 0x70:    /* lock */
  463.          case 0x80:
  464.             *p = treasure[curwall][i].item;
  465.             break;
  466.          default:
  467.             break;
  468.         }
  469.     }
  470.  
  471.     for(i=1; i<40; i++) {
  472.         for(j=1; j<19; j++) {
  473.             disp_field( i, j );
  474.         }
  475.     }
  476.  
  477.     shots.dir = -1;
  478.  
  479.     mans.dir = 0x80;
  480.     mans.key = 0;
  481.     show_man();
  482.  
  483.     for(i=0; i<MAXBUGS; i++) {
  484.         bugs[i].dir = -1;
  485.     }
  486. }
  487.  
  488.  
  489. void    disp_field(x,y)
  490. int    x,y;
  491. {
  492.     char    *p;
  493.  
  494.     p = &field[y*41+x];
  495.     switch( *p & 0xf0 ) {
  496.      case 0x00:    /* wall */
  497.         if( (*p & 0x0f) != 1 ) return;
  498.         p = newwall;
  499.         break;
  500.      case 0x60:        /* key */
  501.         p = keys;
  502.         break;
  503.      case 0x70:
  504.         p = keylock;    /* lock */
  505.         break;
  506.      case 0x80:        /* tagboost */
  507.         p = tagboost;
  508.         break;
  509.      case 0x10:        /* teleport */
  510.         if( *p==0x14 ) {
  511.             flip(teleport, hold1);
  512.             p = hold1;
  513.         } else  p = teleport;
  514. /*
  515.         switch( *p ) {
  516.          case 0x14:
  517.          case 0x15:
  518.             return;
  519.          default:
  520.             p = teleport[*p & 0x0f];
  521.             break;
  522.         }
  523. */
  524.         break;
  525.      case 0x40:    /* treasure */
  526.         switch( *p ) {
  527.          case 0x40:
  528.             p = goodies[0];
  529.             break;
  530.          case 0x41:
  531.             p = goodies[1];
  532.             break;
  533.          case 0x42:
  534.             p = goodies[2];
  535.             break;
  536.          case 0x43:
  537.             p = goodies[3];
  538.             break;
  539.          default:
  540.             return;
  541.             break;
  542.         }
  543.         break;
  544.      case 0x20:    /* pit */
  545.         switch(  *p ) {
  546.          case 0x21:
  547.             rotate(pits, hold1);
  548.             reverse(hold1, hold2);
  549.             p = hold2;
  550.             break;
  551.          case 0x23:
  552.             p = pits;
  553.             break;
  554.          case 0x25:
  555.             rotate(pits, hold1);
  556.             p = hold1;
  557.             break;
  558.          case 0x27:
  559.             flip(pits, hold1);
  560.             p = hold1;
  561.             break;
  562. /*         case 0x20:
  563.             p = pits[0];
  564.             break;
  565.          case 0x21:
  566.             p = pits[1];
  567.             break;
  568.          case 0x22:
  569.             reverse(pits[0], hold1);
  570.             p = hold1;
  571.             break;
  572.          case 0x23:
  573.             rotate(pits[1], hold1);
  574.             p = hold1;
  575.             break;
  576.          case 0x24:
  577.             rotate(pits[0], hold1);
  578.             p = hold1;
  579.             break;
  580.          case 0x25:
  581.             reverse(pits[1], hold1);
  582.             p = hold1;
  583.             break;
  584.          case 0x26:
  585.             flip(pits[0], hold1);
  586.             reverse(hold1, hold2);
  587.             p = hold2;
  588.             break;
  589.          case 0x27:
  590.             rotate(pits[1], hold1);
  591.             flip(hold1, hold2);
  592.             p = hold2;
  593.             break;
  594.          case 0x28:
  595.             rotate(pits[0], hold1);
  596.             flip(hold1, hold2);
  597.             p = hold2;
  598.             break;
  599.          case 0x2a:
  600.             flip(pits[0], hold1);
  601.             p = hold1;
  602.             break;
  603.          case 0x2c:
  604.             rotate(pits[0], hold1);
  605.             reverse(hold1, hold2);
  606.             flip(hold2, hold1);
  607.             p = hold1;
  608.             break;
  609.          case 0x2e:
  610.             rotate(pits[0], hold1);
  611.             reverse(hold1, hold2);
  612.             p = hold2;
  613.             break;
  614. */
  615.          default:
  616.             return;
  617.         }
  618.         break;
  619.      default:
  620.         return;
  621.     }
  622.     newbplotxy(((x-1)<<4)+XORG, ((19-y)<<4)+YORG, 16, 2, p, 3);
  623. }
  624.  
  625.  
  626. void    box(x1, y1, x2, y2, color, rule)
  627. int    x1, y1, x2, y2, color, rule;
  628. {
  629.  
  630.     horline(x1, y1, x2, color, rule);
  631.     verline(x2, y1, y2, color, rule);
  632.     horline(x2, y2, x1, color, rule);
  633.     verline(x1, y2, y1, color, rule);
  634. }
  635.  
  636. void    build_wall() {
  637.  
  638.     int    i, j, a, b;
  639.  
  640.     b = pattcolors[curwall][0];
  641.     a = pattcolors[curwall][1];
  642.     for(i=0; i<128; i++) newwall[i] = 0;
  643.     for(i=0; i<32; i++) {
  644.         for(j=0x80; j; j>>=1) {
  645.             if( !(wallpatt[i] & j) ) {
  646.                 if( wallpatt[i+32] & j ) {
  647.                     if( a & 1 ) newwall[i]    |= j;
  648.                     if( a & 2 ) newwall[i+32] |= j;
  649.                     if( a & 4 ) newwall[i+64] |= j;
  650.                     if( a & 8 ) newwall[i+96] |= j;
  651.                 } else {
  652.                     if( b & 1 ) newwall[i]    |= j;
  653.                     if( b & 2 ) newwall[i+32] |= j;
  654.                     if( b & 4 ) newwall[i+64] |= j;
  655.                     if( b & 8 ) newwall[i+96] |= j;
  656.                 }
  657.             }
  658.         }
  659.     }
  660. /*
  661.     int    i, j;
  662.     unsigned char    *p, *q, z;
  663.     unsigned char    a, b, c, d;
  664.  
  665.     j = pattcolors[curwall][0];
  666.     for(i=0; i<18; i++) wallpatt[i] = j;
  667.     wallpatt[30] = j;
  668.     wallpatt[31] = j;
  669.     wallpatt[32] = j;
  670.     wallpatt[47] = j;
  671.     wallpatt[48] = j;
  672.     wallpatt[63] = j;
  673.     wallpatt[64] = j;
  674.     wallpatt[79] = j;
  675.     wallpatt[80] = j;
  676.     wallpatt[95] = j;
  677.     wallpatt[96] = j;
  678.     wallpatt[111] = j;
  679.     wallpatt[112] = j;
  680.     wallpatt[113] = j;
  681.     for(i=126; i<144; i++) wallpatt[i] = j;
  682.     wallpatt[150] = j;
  683.     wallpatt[151] = j;
  684.     wallpatt[152] = j;
  685.     wallpatt[167] = j;
  686.     wallpatt[183] = j;
  687.     wallpatt[199] = j;
  688.     wallpatt[215] = j;
  689.     wallpatt[231] = j;
  690.     wallpatt[246] = j;
  691.     wallpatt[247] = j;
  692.     wallpatt[248] = j;
  693.  
  694.     j = pattcolors[curwall][1];
  695.     for(i=34; i<46; i++) wallpatt[i] = j;
  696.     wallpatt[50] = j;
  697.     wallpatt[52] = j;
  698.     wallpatt[54] = j;
  699.     wallpatt[56] = j;
  700.     wallpatt[58] = j;
  701.     wallpatt[60] = j;
  702.     wallpatt[61] = j;
  703.     wallpatt[66] = j;
  704.     wallpatt[67] = j;
  705.     wallpatt[69] = j;
  706.     wallpatt[71] = j;
  707.     wallpatt[73] = j;
  708.     wallpatt[75] = j;
  709.     wallpatt[77] = j;
  710.     wallpatt[82] = j;
  711.     wallpatt[84] = j;
  712.     wallpatt[86] = j;
  713.     wallpatt[88] = j;
  714.     wallpatt[90] = j;
  715.     wallpatt[92] = j;
  716.     wallpatt[93] = j;
  717.     for(i=98; i<110; i++) wallpatt[i] = j;
  718.     for(i=160; i<166; i++)     wallpatt[i] = j;
  719.     for(i=169; i<176; i++)    wallpatt[i] = j;
  720.     wallpatt[177] = j;
  721.     wallpatt[179] = j;
  722.     wallpatt[181] = j;
  723.     wallpatt[185] = j;
  724.     wallpatt[187] = j;
  725.     wallpatt[189] = j;
  726.     wallpatt[191] = j;
  727.     wallpatt[192] = j;
  728.     wallpatt[194] = j;
  729.     wallpatt[196] = j;
  730.     wallpatt[197] = j;
  731.     wallpatt[201] = j;
  732.     wallpatt[202] = j;
  733.     wallpatt[204] = j;
  734.     wallpatt[206] = j;
  735.     wallpatt[209] = j;
  736.     wallpatt[211] = j;
  737.     wallpatt[213] = j;
  738.     wallpatt[217] = j;
  739.     wallpatt[219] = j;
  740.     wallpatt[221] = j;
  741.     for(i=223; i<230; i++)    wallpatt[i] = j;
  742.     for(i=233; i<240; i++)    wallpatt[i] = j;
  743.     convert(wallpatt, newwall);
  744. */
  745. }
  746.  
  747.  
  748. void    convert(s, des)
  749. unsigned char    *s, *des;
  750. {
  751.     int    i, j, a, b, c, d;
  752.     unsigned char z;
  753.  
  754.     for(i=0; i<32; i++) {
  755.         a = b = c = d = 0;
  756.         for(j=0; j<8; j++) {
  757.             z = *s++;
  758.             a = a<<1;
  759.             b = b<<1;
  760.             c = c<<1;
  761.             d = d<<1;
  762.             if( z & 1 ) a |= 1;
  763.             if( z & 2 ) b |= 1;
  764.             if( z & 4 ) c |= 1;
  765.             if( z & 8 ) d |= 1;
  766.         }
  767.         *des      = a;
  768.         *(des+32) = b;
  769.         *(des+64) = c;
  770.         *(des+96) = d;
  771.         ++des;
  772.     }
  773. }
  774.  
  775.  
  776. void    flip(s, d)
  777. unsigned int    *s, *d;
  778. {
  779.     unsigned int    i, j;
  780.  
  781.     d += 15;
  782.     for(i=0; i<4; i++) {
  783.         for(j=0; j<16; j++) {
  784.             *d-- = *s++;
  785.         }
  786.         d += 32;
  787.     }
  788. }
  789.  
  790. void    reverse(s, d)
  791. unsigned int    *s, *d;
  792. {
  793.     unsigned int    a, b, j, k, c;
  794.  
  795.     for(c=0; c<4; c++) {
  796.         for(j=0; j<16; j++) {
  797.             a = *s++;
  798.             b = 0;
  799.             for(k=0; k<16; k++) {
  800.                 b = (b<<1) | (a & 1);
  801.                 a >>= 1;
  802.             }
  803.             *d++ = b;
  804.         }
  805.     }
  806. }
  807.  
  808. void    rotate(s, d)
  809. unsigned char    *s, *d;
  810. {
  811.     unsigned int    k, c;
  812.     unsigned char    a, j;
  813.  
  814.     for(c=0; c<4; c++) {
  815.         for(j=0x01; j; j <<= 1) {
  816.             a = 0;
  817.             for(k=1; k<16; k+=2) {
  818.                 a <<= 1;
  819.                 if(s[k] & j) a |= 1;
  820.             }
  821.             *d++ = a;
  822.             a = 0;
  823.             for(k=17; k<32; k+=2) {
  824.                 a <<= 1;
  825.                 if(s[k] & j) a |= 1;
  826.             }
  827.             *d++ = a;
  828.         }
  829.         for(j=0x01; j; j <<= 1) {
  830.             a = 0;
  831.             for(k=0; k<16; k+=2) {
  832.                 a <<= 1;
  833.                 if(s[k] & j) a |= 1;
  834.             }
  835.             *d++ = a;
  836.             a = 0;
  837.             for(k=16; k<32; k+=2) {
  838.                 a <<= 1;
  839.                 if(s[k] & j) a |= 1;
  840.             }
  841.             *d++ = a;
  842.         }
  843.         s += 32;
  844.     }
  845. }
  846.