home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 2 / crawlyvol2.bin / games / wcoltris / source / tetris.c < prev   
C/C++ Source or Header  |  1994-12-31  |  13KB  |  557 lines
  1. #include <vdi.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>    /* mem... */
  5.  
  6. #include <image.h>
  7.  
  8. #include "cltr.h"
  9.  
  10. extern int planes,tetris_vdi;
  11.  
  12. #define WIDTH        10
  13. #define HEIGHT        20
  14. #define FIRSTLINE    4
  15. #define XHEIGHT        (HEIGHT+FIRSTLINE+1)
  16. #define XWIDTH        (WIDTH+2)
  17. static int BLOCK_SW    = 16;
  18. static int BLOCK_W        = 16;
  19. static int BLOCK_H        = 16;
  20. static int BLOCK_XW;
  21. static int BLOCK_XH;
  22.  
  23. static int feld[HEIGHT+5][WIDTH+2];
  24.  
  25. void get_tetris_size(int *w,int *h)
  26. {
  27.     *w=WIDTH*BLOCK_W;
  28.     *h=HEIGHT*BLOCK_H;
  29. }
  30. void get_tetris_prev(int *w,int *h)
  31. {
  32.     *w=BLOCK_W*5;
  33.     *h=BLOCK_H*5;
  34. }
  35.  
  36. typedef struct {
  37.     int x[4];
  38.     int y[4];
  39. } DIR;
  40.  
  41. typedef struct {
  42.     DIR dir[4];
  43.     int dirs;
  44. } STONES;
  45.  
  46. /*
  47.     XXXX     XXX    XXX        XXX        XX         XX        XX
  48.                X    X         X         XX        XX        XX
  49. */
  50. static STONES tet[]={
  51.     {    {{{0,0,0,0},{0,0,0,0}},{{0,0,0,0},{0,0,0,0}},{{0,0,0,0},{0,0,0,0}},{{0,0,0,0},{0,0,0,0}}},0    },
  52.     {    {{{-2,-1,0,1},{0,0,0,0}},{{0,0,0,0},{-2,-1,0,1}},{{0,0,0,0},{0,0,0,0}},{{0,0,0,0},{0,0,0,0}}},2    },
  53.     {    {{{-1,0,1,1},{0,0,0,1}},{{1,0,0,0},{-1,-1,0,1}},{{-1,-1,0,1},{-1,0,0,0}},{{0,0,0,-1},{-1,0,1,1}}},4    },
  54.     {    {{{-1,0,1,1},{0,0,0,-1}},{{-1,0,0,0},{-1,-1,0,1}},{{-1,-1,0,1},{1,0,0,0}},{{0,0,0,1},{-1,0,1,1}}},4    },
  55.     {    {{{-1,0,0,1},{0,0,1,0}},{{0,0,1,0},{-1,0,0,1}},{{-1,0,0,1},{0,0,-1,0}},{{0,0,-1,0},{-1,0,0,1}}},4    },
  56.     {    {{{-1,0,0,1},{1,1,0,0}},{{0,0,1,1},{-1,0,0,1}},{{0,0,0,0},{0,0,0,0}},{{0,0,0,0},{0,0,0,0}}},2    },
  57.     {    {{{-1,0,0,1},{0,0,1,1}},{{1,1,0,0},{-1,0,0,1}},{{0,0,0,0},{0,0,0,0}},{{0,0,0,0},{0,0,0,0}}},2    },
  58.     {    {{{0,1,0,1},{0,0,1,1}},{{0,0,0,0},{0,0,0,0}},{{0,0,0,0},{0,0,0,0}},{{0,0,0,0},{0,0,0,0}}},1    }
  59. };
  60.  
  61. static char tet_bloecke[]={
  62.     0x00,0x00,0x7f,0xfe,0x7f,0xfe,0x7f,0xfe,0x7f,0xfe,0x7f,0xfe,0x7f,0xfe,0x7f,0xfe,
  63. 0x7f,0xfe,0x7f,0xfe,0x7f,0xfe,0x7f,0xfe,0x7f,0xfe,0x7f,0xfe,
  64.     0x00,0x00,0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01,
  65. 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xfe,0xff,
  66.     0x00,0x00,0xbf,0xfd,0xbf,0xfd,0xbf,0xfd,0xbf,0xfd,0xbf,0xfd,0xbf,0xfd,0xbf,0xfd,
  67. 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xfe,0xff,0xfc,0x7f,
  68.     0x00,0x00,0xb1,0x15,0xb5,0x55,0xb5,0x55,0xb5,0x55,0xb7,0x75,0xbf,0xfd,0xbf,0xfd,
  69. 0xff,0xff,0xff,0xff,0xff,0xff,0xfe,0xff,0xfc,0x7f,0xf8,0x3f,
  70.     0x00,0x00,0xa0,0x05,0xa0,0x05,0xa8,0x8d,0xaa,0xad,0xaa,0xad,0xaa,0xad,0xae,0xed,
  71. 0xff,0xff,0xff,0xff,0xfe,0xff,0xfc,0x7f,0xf8,0x3f,0xf0,0x1f,
  72.     0x00,0x00,0xa4,0x45,0xb5,0x55,0xb5,0x55,0xb5,0x55,0xbd,0xdd,0xbf,0xfd,0xbf,0xfd,
  73. 0xff,0xff,0xfe,0xff,0xfc,0x7f,0xf8,0x3f,0xf0,0x1f,0xe0,0x0f,
  74.     0x00,0x00,0xa0,0x05,0xa0,0x05,0xa2,0x25,0xaa,0xad,0xaa,0xad,0xaa,0xad,0xbb,0xbd,
  75. 0xfe,0xff,0xfc,0x7f,0xf8,0x3f,0xf0,0x1f,0xe0,0x0f,0xc0,0x07,
  76.     0x00,0x00,0xb1,0x15,0xb5,0x55,0xb5,0x55,0xb5,0x55,0xb7,0x75,0xbf,0xfd,0xbf,0xfd,
  77. 0xfc,0x7f,0xf8,0x3f,0xf0,0x1f,0xe0,0x0f,0xc0,0x07,0x80,0x03,
  78.     0x00,0x00,0xa0,0x05,0xa0,0x05,0xa8,0x8d,0xaa,0xad,0xaa,0xad,0xaa,0xad,0xae,0xed,
  79. 0xfe,0xff,0xfc,0x7f,0xf8,0x3f,0xf0,0x1f,0xe0,0x0f,0xc0,0x07,
  80.     0x00,0x00,0xa4,0x45,0xb5,0x55,0xb5,0x55,0xb5,0x55,0xbd,0xdd,0xbf,0xfd,0xbf,0xfd,
  81. 0xff,0xff,0xfe,0xff,0xfc,0x7f,0xf8,0x3f,0xf0,0x1f,0xe0,0x0f,
  82.     0x00,0x00,0xa0,0x05,0xa0,0x05,0xa2,0x25,0xaa,0xad,0xaa,0xad,0xaa,0xad,0xbb,0xbd,
  83. 0xff,0xff,0xff,0xff,0xfe,0xff,0xfc,0x7f,0xf8,0x3f,0xf0,0x1f,
  84.     0x00,0x00,0xb1,0x15,0xb5,0x55,0xb5,0x55,0xb5,0x55,0xb7,0x75,0xbf,0xfd,0xbf,0xfd,
  85. 0xff,0xff,0xff,0xff,0xff,0xff,0xfe,0xff,0xfc,0x7f,0xf8,0x3f,
  86.     0x00,0x00,0xa0,0x05,0xa0,0x05,0xa8,0x8d,0xaa,0xad,0xaa,0xad,0xaa,0xad,0xae,0xed,
  87. 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xfe,0xff,0xfc,0x7f,
  88.     0x00,0x00,0xbf,0xfd,0xbf,0xfd,0xbf,0xfd,0xbf,0xfd,0xbf,0xfd,0xbf,0xfd,0xbf,0xfd,
  89. 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xfe,0xff,
  90.     0x00,0x00,0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01,
  91. 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
  92.     0x00,0x00,0x7f,0xfe,0x7f,0xfe,0x7f,0xfe,0x7f,0xfe,0x7f,0xfe,0x7f,0xfe,0x7f,0xfe,
  93. 0x7f,0xfe,0x7f,0xfe,0x7f,0xfe,0x7f,0xfe,0x7f,0xfe,0x7f,0xfe,
  94. };
  95.  
  96. static MFDB tbloecke={tet_bloecke,14*16,16,14,0,1,0,0,0};
  97.  
  98. typedef struct {
  99.     int x;
  100.     int y;
  101.     int typ;
  102.     int dir;
  103. } STONE;
  104.  
  105. static STONE stone,next;
  106.  
  107. extern MFDB buffer;
  108. extern long screen_addr,buffer_addr;
  109. extern int screen_width;
  110. extern dr_tetris(char *dest,char *source);
  111.  
  112. static int x_pos[XWIDTH];
  113. static int y_pos[XHEIGHT];
  114.  
  115. static void (*dr_block)(int x,int y,int col);
  116.  
  117. static void qdr_block(int x,int y,int col)
  118. {
  119. char *source,*dest;
  120. int xx,yy;
  121.  
  122.     xx=x_pos[x];
  123.     yy=y_pos[y];
  124.     source=tet_bloecke+col*2;
  125.     dest=(char*)buffer_addr+(long)yy*buffer_width+xx/8;
  126.     dr_tetris(dest,source);
  127.     if ( yy<copy_min )
  128.         copy_min=yy;
  129.     if ( yy+BLOCK_XH>copy_max )
  130.         copy_max=yy+BLOCK_XH;
  131. }
  132.  
  133. static void vdidr_block(int x,int y,int col)
  134. {
  135. int xy[8],yy;
  136.  
  137.     xy[0]=col*BLOCK_SW;
  138.     xy[1]=0;
  139.     xy[2]=xy[0]+BLOCK_XW;
  140.     xy[3]=BLOCK_XH;
  141.     xy[4]=x_pos[x];
  142.     yy=xy[5]=y_pos[y];
  143.     xy[6]=xy[4]+BLOCK_XW;
  144.     xy[7]=xy[5]+BLOCK_XH;
  145.     vro_cpyfm(handle,S_ONLY,xy,&tbloecke,&buffer);
  146.     if ( yy<copy_min )
  147.         copy_min=yy;
  148.     if ( yy+BLOCK_XH>copy_max )
  149.         copy_max=yy+BLOCK_XH;
  150. }
  151.  
  152. static void dr_vdi(int x,int y,int col,int x_off,int y_off)
  153. {
  154. int xy[8];
  155.  
  156.     xy[0]=col*BLOCK_SW;
  157.     xy[1]=0;
  158.     xy[2]=xy[0]+BLOCK_XW;
  159.     xy[3]=BLOCK_XH;
  160.     xy[4]=x_pos[x]+x_off;
  161.     xy[5]=y_pos[y]+y_off;
  162.     xy[6]=xy[4]+BLOCK_XW;
  163.     xy[7]=xy[5]+BLOCK_XH;
  164.     vro_cpyfm(handle,S_ONLY,xy,&tbloecke,&screen);
  165. }
  166.  
  167.  
  168. static void rm_stone(void)
  169. {
  170. int i,y;
  171.  
  172.     for ( i=0; i<4; i++ ) {
  173.         y=stone.y+tet[stone.typ].dir[stone.dir].y[i];
  174.         if ( y>=FIRSTLINE ) {
  175.             dr_block(stone.x+tet[stone.typ].dir[stone.dir].x[i],y,0);
  176.         }
  177.     }
  178. }
  179.  
  180. static void dr_stone(void)
  181. {
  182. int i,y;
  183. DIR *dir;
  184.  
  185.     dir=&tet[stone.typ].dir[stone.dir];
  186.  
  187.     for ( i=0; i<4; i++ ) {
  188.         y=stone.y+dir->y[i];
  189.         if ( y>=FIRSTLINE ) {
  190.             dr_block(stone.x+dir->x[i],y,stone.typ);
  191.         }
  192.     }
  193. }
  194.  
  195. /*------------------------------------------------------------------------------
  196.  
  197.     preview
  198.  
  199. ------------------------------------------------------------------------------*/
  200. #define PREV_X    3
  201. #define PREV_Y    FIRSTLINE+2
  202.  
  203. void do_draw(void *data,int x,int y,int w,int h)
  204. {
  205. int i;
  206. DIR *dir=(DIR*)data;
  207.  
  208.     for ( i=0; i<4; i++ )
  209.         dr_vdi(PREV_X+dir->x[i],PREV_Y+dir->y[i],next.typ,prev_x+(prev_w-BLOCK_W*4)/2,prev_y+(prev_h-BLOCK_H*4)/2);
  210. }
  211.  
  212. void do_clear(void *data,int x,int y,int w,int h)
  213. {
  214. int i;
  215. DIR *dir=(DIR*)data;
  216.  
  217.     for ( i=0; i<4; i++ )
  218.         dr_vdi(PREV_X+dir->x[i],PREV_Y+dir->y[i],0,prev_x+(prev_w-BLOCK_W*4)/2,prev_y+(prev_h-BLOCK_H*4)/2);
  219. }
  220.  
  221. static void dr_preview(void)
  222. {
  223. DIR *dir;
  224.  
  225.     dir=&tet[next.typ].dir[next.dir];
  226.     draw_preview(do_draw,dir);
  227. }
  228.  
  229. static void clr_preview(void)
  230. {
  231. DIR *dir;
  232.  
  233.     dir=&tet[stone.typ].dir[stone.dir];
  234.     draw_preview(do_clear,dir);
  235. }
  236.  
  237. /*------------------------------------------------------------------------------
  238.  
  239.     statistik
  240.  
  241. ------------------------------------------------------------------------------*/
  242. void dr_tstat(int x,int y,int dy)
  243. {
  244. int i;
  245.     y+=dy/2;
  246.     for ( i=1; i<8; i++,y+=dy ) 
  247.         dr_vdi(2,FIRSTLINE,i,x,y );
  248. }
  249.  
  250. static void init_feld(void)
  251. {
  252. int i,j;
  253.  
  254.     for ( i=0; i<XHEIGHT; i++ ) {
  255.         for ( j=0; j<XWIDTH; j++ )
  256.             feld[i][j]=0;
  257.         feld[i][0]=feld[i][XWIDTH-1]=-1;
  258.     }
  259.     for ( j=0; j<XWIDTH; j++ )
  260.         feld[XHEIGHT-1][j]=-1;
  261.  
  262.     for ( i=XHEIGHT-1-opts.tetris.random; i<XHEIGHT-1; i++ ) {
  263.         for ( j=1; j<XWIDTH-1; j++ ) {
  264.             feld[i][j]=(int)(xrandom()%14+1);
  265.             if ( feld[i][j]>7 )
  266.                 feld[i][j]=0;
  267.             else
  268.                 dr_block(j,i,feld[i][j]);
  269.         }
  270.     }
  271.     copy_out();
  272. }
  273.  
  274. static int check_pos(STONE *stone)
  275. {
  276. int i;
  277. DIR *dir;
  278.  
  279.     dir=&tet[stone->typ].dir[stone->dir];
  280.     for ( i=0; i<4; i++ ) {
  281.         if ( feld[stone->y+dir->y[i]][stone->x+dir->x[i]]!=0 )
  282.             return 1;
  283.     }
  284.     return 0;
  285. }
  286.  
  287. static int xcheck(void)
  288. {
  289. int i,j;
  290.  
  291.     for ( i=0; i<FIRSTLINE; i++ )
  292.         for ( j=1; j<XWIDTH-1; j++ )
  293.             if ( feld[i][j]!=0 )
  294.                 return 1;
  295.     return 0;
  296. }
  297.  
  298. static void init_stone(void)
  299. {
  300.     next.x=XWIDTH/2;
  301.     next.y=2;
  302.     next.typ=(int)(xrandom()%7+1);
  303.     next.dir=(int)(xrandom()%tet[next.typ].dirs);
  304. }
  305.  
  306. static int check_feld(uint *lines)
  307. {
  308. int flags[XHEIGHT][XWIDTH];
  309. int i,j;
  310. int ii;
  311. int done=0;
  312.  
  313.     memset(flags,0,sizeof(flags));
  314.     for ( i=FIRSTLINE; i<XHEIGHT-1; i++ ) {
  315.         for ( j=1; j<XWIDTH-1; j++ ) {
  316.             if ( feld[i][j]==0 )
  317.                 break;
  318.         }
  319.         if ( j==XWIDTH-1 ) {    /* kein break */
  320.             for ( j=1; j<XWIDTH-1; j++ ) {
  321.                 flags[i][j]=1;
  322.             }
  323.             (*lines)++;
  324.             done=1;
  325.         }
  326.     }
  327.  
  328.     if ( done ) {
  329.         for ( ii=8; ii<=12; ii++ ) {
  330.             init_wait();
  331.             for ( i=FIRSTLINE; i<XHEIGHT-1; i++ ) {
  332.                 for ( j=1; j<XWIDTH-1; j++ ) {
  333.                     if ( flags[i][j] )
  334.                         dr_block(j,i,ii);
  335.                 }
  336.             }
  337.             copy_out();
  338.             do_wait(3);
  339.         }
  340.  
  341.         for ( j=1; j<XWIDTH-1; j++ ) {
  342.             for ( ii=i=XHEIGHT-2; ii>=FIRSTLINE; ii--,i-- ) {
  343.                 while ( flags[i][j]!=0 )
  344.                     i--;
  345.                 if ( i<0 )
  346.                     i=0;
  347.                 if ( i!=ii ) {
  348.                     feld[ii][j]=feld[i][j];
  349.                     if ( feld[ii][j]==0 )
  350.                         dr_block(j,ii,0);
  351.                     else
  352.                         dr_block(j,ii,feld[ii][j]);
  353.                 }
  354.             }
  355.         }
  356.         copy_out();
  357.     }
  358.     return done;
  359. }
  360.  
  361. int tetris(void)
  362. {
  363. int key;
  364. long time;
  365. int draw,let_it_fall;
  366. STONE x;
  367. int i;
  368. uint level,delay;
  369. uint stones,lines,score;
  370. DIR *dir;
  371. uint stat[7]={0,0,0,0,0,0,0};
  372. int drop_line;
  373.  
  374.     init_feld();
  375.     check_feld(&lines);
  376.  
  377.     level=opts.tetris.start_level;
  378.     delay=calc_delay(level);
  379.     stones=lines=score=0;
  380.  
  381.     init_stone();
  382.  
  383.     while ( 1 ) {
  384.         stone=next;
  385.         init_stone();
  386.         if ( preview_flag ) {
  387.             clr_preview();
  388.             dr_preview();
  389.         }
  390.  
  391.         stat[stone.typ-1]++;
  392.         if ( stat_flag )
  393.             dr_stat(stat);
  394.  
  395.         if ( check_pos(&stone) || xcheck() )
  396.             break;                    /* stein checken */
  397.         x=stone;                    /* stein merken */
  398.  
  399.         stones++;
  400.         if ( level<9 && lines>level*10+10 )
  401.             { level++; inv_feld(); delay=calc_delay(level); }
  402.         dr_score(level,lines,stones,score);
  403.  
  404.         let_it_fall=0;                /* nicht fallen lassen */
  405.         time=gettime();                /* zeit merken */
  406.         draw=1;                        /* zeichnen */
  407.  
  408.         while ( 1 ) {
  409.             if ( draw ) {            /* nur wenn nötig */
  410.                 dr_stone();            /* stein zeichnen */
  411.                 draw=0;                /* flag löschen */
  412.                 copy_out();
  413.             }
  414.  
  415.             if ( !let_it_fall )        /* falls fallen lassen */
  416.                 key=get_key();
  417.             else
  418.                 key=0;                /* kein zeichen einlesen */
  419.  
  420.             switch ( key ) {
  421.               case K_QUIT:
  422.                 return 0;            /* beenden */
  423.               /*break;*/
  424.               case K_LEFT:
  425.                   x.x--;            /* links */
  426.                   if ( check_pos(&x) )
  427.                       x.x++;
  428.               break;
  429.               case K_RIGHT:
  430.                 x.x++;                /* rechts */
  431.                   if ( check_pos(&x) )
  432.                       x.x--;
  433.               break;
  434.               case K_ROTATE: {
  435.                int h=x.dir;
  436.                 x.dir++;
  437.                 if ( x.dir>=tet[x.typ].dirs )
  438.                     x.dir=0;
  439.                 if ( check_pos(&x) )
  440.                     x.dir=h;
  441.               } break;
  442.               case K_DROP:
  443.                 let_it_fall=1;        /* fallen lassen */
  444.                 drop_line=stone.y;
  445.               break;
  446.               case K_LEVEL:
  447.                 if ( level<9 ) {
  448.                     level++;
  449.                     inv_feld();
  450.                     delay=calc_delay(level);
  451.                     dr_score(level,lines,stones,score);
  452.                 }
  453.               break;
  454.               case K_NEXT:
  455.                 set_preview();
  456.                 if ( preview_flag )
  457.                     dr_preview();
  458.               break;
  459.               case K_INFO:
  460.                   set_score();
  461.               break;
  462.               case K_STAT:
  463.                   set_statistic();
  464.                   if ( stat_flag )
  465.                     dr_stat(stat);
  466.               break;
  467.               case K_STOP:
  468.                 xget_key();            /* taste mit warten holen */
  469.                 time=gettime();
  470.               break;
  471.             }
  472.  
  473.             if ( gettime()>time+delay || (let_it_fall && gettime()>time+1) ) {
  474.                 x.y++;
  475.                 if ( check_pos(&x) )/* eins tiefer */
  476.                     { x.y--; break; }
  477.                 time=gettime();
  478.             }
  479.             if ( memcmp(&x,&stone,sizeof(x)) ) {
  480.                 draw=1;                /* falls sich was getan hat */
  481.                 rm_stone();            /* stein neuzeichnen */
  482.                 stone=x;
  483.             }
  484.         }
  485.  
  486.         if ( memcmp(&x,&stone,sizeof(x)) ) {
  487.             rm_stone();            /* stein neuzeichnen */
  488.             stone=x;
  489.             dr_stone();
  490.             copy_out();
  491.         }
  492.                                     /* stein ist unten angekommen */
  493.                                     /* eintragen ins feld */
  494.  
  495.         dir=&tet[stone.typ].dir[stone.dir];
  496.         for ( i=0; i<4; i++ )
  497.             feld[stone.y+dir->y[i]][stone.x+dir->x[i]]=stone.typ;
  498.  
  499.                                     /* steine wegräumen */
  500.         check_feld(&lines);
  501.  
  502.         score+=5+level*2;
  503.         if ( let_it_fall )
  504.             score+=XHEIGHT-1-drop_line;
  505.         else 
  506.             score+=XHEIGHT-1-stone.y;
  507.         if ( preview_flag )
  508.             score-=3;
  509.  
  510.                                     /* tastaturpuffer löschen */
  511.         clr_keys();
  512.     }
  513.     dr_score(level,lines,stones,score);
  514.     do_score(score,opts.tet_hi);
  515.     return 1;
  516. }
  517.  
  518. int init_tetris(void)
  519. {
  520. char name[16];
  521. MFDB pic;
  522. int i;
  523.  
  524.     sprintf(name,"TETRIS%1d.IMG",planes);
  525.  
  526.     if ( !load_img(name,&pic) ) {
  527.         tbloecke=pic;
  528.         if ( planes>1 ) {
  529.             tbloecke.fd_addr=malloc(pic.fd_wdwidth*2l*planes*pic.fd_h);
  530.             pic.fd_stand=1;
  531.             tbloecke.fd_stand=0;
  532.             vr_trnfm(handle,&pic,&tbloecke);
  533.         }
  534.         BLOCK_SW=BLOCK_W=tbloecke.fd_w/16;
  535.         BLOCK_H=tbloecke.fd_h;
  536.         tetris_vdi=1;
  537.         dr_block=vdidr_block;
  538.     }
  539.     else if ( planes==1 ) {
  540.         dr_block=qdr_block;
  541.         tetris_vdi=0;
  542.     }
  543.     else {
  544.         tetris_vdi=-1;
  545.         return 0;
  546.     }
  547.  
  548.     for ( i=1; i<XWIDTH; i++ )
  549.         x_pos[i]=(i-1)*BLOCK_W;
  550.     for ( i=FIRSTLINE; i<XHEIGHT; i++ )
  551.         y_pos[i]=(i-FIRSTLINE)*BLOCK_H;
  552.     BLOCK_XW=BLOCK_W-1;
  553.     BLOCK_XH=BLOCK_H-1;
  554.     return 1;
  555. }
  556.  
  557.