开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
SMBFUNC.C
资源名称：超级玛丽游戏的源代码.rar　[点击查看]
上传用户：hanguang
上传日期：2007-04-01
资源大小：93k
文件大小：22k
源码类别：

模拟服务器

开发平台：

C/C++

SMBFUNC.C：源码内容
  1. //SET UP ALL OF THE GRAPHICS AND OTHER JUNK//////////////////////////////////
  2. void init()
  3. {
  4.   int loop;
  5.   x_set_mode(X_MODE_320x240,320); //SET MODE X//
  6.   x_set_tripplebuffer(240); //INSTALL TRIPPLE BUFFER//
  7.   install_new_key_handler(); //INSTALL KEYBOARD HANDLER//
  8.   x_install_vsync_handler(1); //INSTALL VSYNC HANDLER//
  9.   for (loop=0;loop<52;loop++) //ALLOCATE MEM FOR GRAPHICS//
  10.     if ((data.block[loop]=(char far *)malloc(258))==NULL)
  11.       exitgame();
  12.   for (loop=0;loop<3;loop++)
  13.     if ((data.coin[loop]=(char far *)malloc(258))==NULL)
  14.       exitgame();
  15.   if ((bcoin=(cointype *)malloc(sizeof(cointype)))==NULL)
  16.     exitgame();
  17.   bcoin->next=NULL;
  18.   if ((bscore=(scoretype *)malloc(sizeof(scoretype)))==NULL)
  19.     exitgame();
  20.   bscore->next=NULL;
  21.   for (loop=0;loop<2;loop++)
  22.   {
  23.     player[loop].lives=3;
  24.     player[loop].level=1;
  25.     player[loop].screenx=0;
  26.   }
  27. }
  29. //FILL SCREEN ///////////////////////////////////////////////////////////////
  30. void fillscreen(int color)
  31. {
  32.   x_rect_fill(32,0,288,224,HiddenPageOffs,color);
  33. }
  35. //GET INPUTS FROM DATA FILES/////////////////////////////////////////////////
  36. int getinputs()
  37. {
  38.   FILE *in;
  39.   int count,loop1,loop2,loop3,yinit,blocknum,backnum;
  40.   char *temp,ch,levelfile[13],graphfile[13];
  41.   char far *tempbm;
  42.   strcpy(levelfile,"LEVEL000.DAT");
  43.   levelfile[7]=player[curplay].level%10+48;
  44.   if (player[curplay].level>9)
  45.     levelfile[6]=player[curplay].level/10+48;
  46.   if ((in=fopen(levelfile,"r"))==NULL)
  47.   {
  48.     exitgame();
  49.     printf("%s could not be found!n",levelfile);
  50.     exit(1);
  51.   }
  52.   data.maxlength=(int)fgetc(in);
  53.   yinit=(int)fgetc(in);
  54.   data.startpos[0]=(int)fgetc(in);
  55.   data.startpos[1]=(int)fgetc(in);
  56.   blocknum=(int)fgetc(in);
  57.   backnum=(int)fgetc(in);
  58.   fseek(in,0,SEEK_SET);
  59.   for (loop1=0;loop1<14;loop1++)
  60.     for (loop2=0;loop2<=data.maxlength;loop2++)
  61.     {
  62.       ch=getc(in);
  63.       if(ch<='0')
  64. data.world[loop1][loop2]=0;
  65.       if (ch>='a' && ch<='z')
  66. data.world[loop1][loop2]=ch-70;
  67.       if (ch>='A' && ch<='Z')
  68. data.world[loop1][loop2]=ch-64;
  69.       if (loop1==0)
  70. data.world[loop1][loop2]=0;
  71.     }
  72.   fclose(in);
  73.   strcpy(graphfile,"BLOCK000.PCX");
  74.   graphfile[7]=blocknum;
  75.   if ((in=fopen(graphfile,"rb"))==NULL)
  76.   {
  77.     exitgame();
  78.     printf("%s could not be found!n",graphfile);
  79.     exit(1);
  80.   }
  81.   temp=getpcx(in,temp,6000);
  82.   tempbm=(char far *)farmalloc(258);
  83.   tempbm[0]=tempbm[1]=16;
  84.   for (loop1=0;loop1<26;loop1++)
  85.   {
  86.     count=2;
  87.     for (loop2=0;loop2<16;loop2++)
  88.       for (loop3=0;loop3<16;loop3++)
  89. tempbm[count++]=temp[loop1*17+(loop2+1)*320+loop3+1];
  90.     x_bm_to_pbm(tempbm,data.block[loop1+26]);
  91.   }
  92.   free(temp);
  93.   fseek(in,-768,SEEK_END);
  94.   for (loop1=0;loop1<256;loop1++)
  95.   {
  96.     data.palette[loop1].red=(getc(in)>>2);
  97.     data.palette[loop1].green=(getc(in)>>2);
  98.     data.palette[loop1].blue=(getc(in)>>2);
  99.   }
  100.   fclose(in);
  101.   strcpy(graphfile,"BGRND000.PCX");
  102.   graphfile[7]=backnum;
  103.   if ((in=fopen(graphfile,"rb"))==NULL)
  104.   {
  105.     exitgame();
  106.     printf("%s could not be found!n",graphfile);
  107.     exit(1);
  108.   }
  109.   temp=getpcx(in,temp,6000);
  110.   for (loop1=0;loop1<26;loop1++)
  111.   {
  112.     count=2;
  113.     for (loop2=0;loop2<16;loop2++)
  114.       for (loop3=0;loop3<16;loop3++)
  115. tempbm[count++]=temp[loop1*17+(loop2+1)*320+loop3+1];
  116.     x_bm_to_pbm(tempbm,data.block[loop1]);
  117.   }
  118.   free(temp);
  119.   fclose(in);
  120.   strcpy(graphfile,"COIN.PCX");
  121.   if ((in=fopen(graphfile,"rb"))==NULL)
  122.   {
  123.     exitgame();
  124.     printf("%s could not be found!n",graphfile);
  125.     exit(1);
  126.   }
  127.   temp=getpcx(in,temp,6000);
  128.   for (loop1=0;loop1<3;loop1++)
  129.   {
  130.     count=2;
  131.     for (loop2=0;loop2<16;loop2++)
  132.       for (loop3=0;loop3<16;loop3++)
  133. tempbm[count++]=temp[loop1*17+(loop2+1)*320+loop3];
  134.     x_bm_to_pbm(tempbm,data.coin[loop1]);
  135.   }
  136.   farfree(tempbm);
  137.   free(temp);
  138.   fclose(in);
  139.   for (loop1=0;loop1<256;loop1++)
  140.     setpalette(loop1,data.palette[loop1]);
  141.   return(yinit);
  142. }
  144. //GET MARIO DATA/////////////////////////////////////////////////////////////
  145. void getmario()
  146. {
  147.   FILE *marioin;
  148.   int loop1,loop2,loop3;
  149.   char *temp;
  150.   if ((marioin=fopen("MARIO.PCX","rb"))==NULL)
  151.   {
  152.     exitgame();
  153.     printf("MARIO.PCX could not be found!n");
  154.     exit(1);
  155.   }
  156.   fseek(marioin,128,SEEK_SET);
  157.   temp=(char *)malloc(6000);
  158.   temp=getpcx(marioin,temp,6000);
  159.   for (loop1=0;loop1<7;loop1++)
  160.     for (loop2=0;loop2<=15;loop2++)
  161.       for (loop3=0;loop3<=15;loop3++)
  162. data.mario[loop1][loop2][loop3]=temp[loop1*17+(loop2+1)*320+loop3+1];
  163.   fseek(marioin,-765,SEEK_END);
  164.   for (loop1=0;loop1<2;loop1++)
  165.   {
  166.     data.marioc[loop1].red=(getc(marioin)>>2);
  167.     data.marioc[loop1].green=(getc(marioin)>>2);
  168.     data.marioc[loop1].blue=(getc(marioin)>>2);
  169.   }
  170.   fseek(marioin,-750,SEEK_END);
  171.   for (loop1=0;loop1<2;loop1++)
  172.   {
  173.     data.luigic[loop1].red=(getc(marioin)>>2);
  174.     data.luigic[loop1].green=(getc(marioin)>>2);
  175.     data.luigic[loop1].blue=(getc(marioin)>>2);
  176.   }
  177.   fclose(marioin);
  178.   free(temp);
  179. }
  181. char *getpcx(FILE *file, char *temp, int length)
  182. {
  183.   long int count=0;
  184.   int numbytes,loop;
  185.   unsigned char ch;
  186.   fseek(file,128,SEEK_SET);
  187.   temp=(char *)malloc(length);
  188.   while(count<length)
  189.   {
  190.     ch=fgetc(file);
  191.     if ((ch>=192 && ch<=255))
  192.     {
  193.       numbytes=ch-192;
  194.       ch=fgetc(file);
  195.       for(loop=0;loop<numbytes;loop++)
  196. temp[count++]=ch;
  197.     }
  198.     else
  199.       temp[count++]=ch;
  200.   }
  201.   return(temp);
  202. }
  204. //SET PALETTE////////////////////////////////////////////////////////////////
  205. void setpalette(int index, colorpal color)
  206. {
  207.   outp(0x3c6,0xff);
  208.   outp(0x3c8,index);
  209.   outp(0x3c9,color.red);
  210.   outp(0x3c9,color.green);
  211.   outp(0x3c9,color.blue);
  212. }
  214. //CALCULATE CURRENT SCREEN///////////////////////////////////////////////////
  215. void drawscreen(int x)
  216. {
  217.   int loop1,loop2,back,x2;
  218.   static int dy;
  219.   status();
  220.   x2=x;
  221.   back=0;
  222.   while(x2>=16)
  223.   {
  224.     x2-=16;
  225.     back++;
  226.   }
  227.   for (loop1=1;loop1<=13;loop1++)
  228.     for (loop2=back;loop2<=back+16;loop2++)
  229.       if (data.world[loop1][loop2]>0)
  230.       {
  231. if (data.bumped[0]==loop2 && data.bumped[1]==loop1)
  232. {
  233.   dy+=data.bumploop;
  234.   x_put_masked_pbm((loop2<<4)-x+32,(loop1<<4)+dy,HiddenPageOffs,data.block[data.world[loop1][loop2]-1]);
  235.   data.bumploop++;
  236.   if(data.bumploop==3)
  237.   {
  238.     data.bumploop=0;
  239.     data.bumped[0]=0;
  240.     data.bumped[1]=0;
  241.     dy=0;
  242.   }
  243. }
  244. else
  245.   x_put_masked_pbm((loop2<<4)-x+32,(loop1<<4),HiddenPageOffs,data.block[data.world[loop1][loop2]-1]);
  246.       }
  247.   drawcoin(x);
  248.   drawscore(x);
  249.   x_rect_fill(15,0,32,224,HiddenPageOffs,0);
  250.   x_rect_fill(288,0,306,224,HiddenPageOffs,0);
  251. }
  253. //DRAW INFO ON TOP OF SCREEN/////////////////////////////////////////////////
  254. void status()
  255. {
  256.   static char pscore[7]="000000";
  257.   char pscore2[7];
  258.   char slevel[4]="1-1";
  259.   char scoins[3]="00";
  260.   static char stime[4]="   ";
  261.   int loop1,loop2;
  262.   if (curplay==0)
  263.     graphstring(34,1,"MARIO",TEXTCOLOR,HiddenPageOffs);
  264.   else
  265.     graphstring(34,1,"LUIGI",TEXTCOLOR,HiddenPageOffs);
  266.   graphstring(180,1,"WORLD",TEXTCOLOR,HiddenPageOffs);
  267.   graphstring(254,1,"TIME",TEXTCOLOR,HiddenPageOffs);
  268.   if(player[curplay].score[1]!=player[curplay].score[0])
  269.   {
  270.     itoa(player[curplay].score[1],pscore2,10);
  271.     loop2=5;
  272.     for(loop1=strlen(pscore2)-1;loop1>=0;loop1--)
  273. pscore[loop2--]=pscore2[loop1];
  274.     graphstring(34,9,pscore,BACKGROUND,HiddenPageOffs);
  275.   }
  276.   strcpy(pscore,"000000");
  277.   itoa(player[curplay].score[0],pscore2,10);
  278.   loop2=5;
  279.   for(loop1=strlen(pscore2)-1;loop1>=0;loop1--)
  280.     pscore[loop2--]=pscore2[loop1];
  281.   graphstring(34,9,pscore,TEXTCOLOR,HiddenPageOffs);
  282.   player[curplay].score[1]=player[curplay].score[0];
  283.   if (times[1]!=times[2])
  284.   {
  285.     itoa(times[0],stime,10);
  286.     graphstring(260,9,stime,BACKGROUND,HiddenPageOffs);
  287.     times[2]=times[1];
  288.     times[0]--;
  289.     itoa(times[0],stime,10);
  290.   }
  291.   graphstring(260,9,stime,TEXTCOLOR,HiddenPageOffs);
  292.   slevel[0]=(char)(player[curplay].level/5+1-208);
  293.   slevel[2]=(char)(player[curplay].level%5-208);
  294.   graphstring(188,9,slevel,TEXTCOLOR,HiddenPageOffs);
  295.   if (player[curplay].coins[0]!=player[curplay].coins[1])
  296.   {
  297.     itoa(player[curplay].coins[1],scoins,10);
  298.     if (player[curplay].coins[1]<10)
  299.     {
  300.       scoins[1]=scoins[0];
  301.       scoins[0]='0';
  302.     }
  303.     graphstring(116,9,scoins,BACKGROUND,HiddenPageOffs);
  304.     player[curplay].coins[1]=player[curplay].coins[0];
  305.   }
  306.   itoa(player[curplay].coins[0],scoins,10);
  307.   if (player[curplay].coins[0]<10)
  308.   {
  309.     scoins[1]=scoins[0];
  310.     scoins[0]='0';
  311.   }
  312.   graphchar(108,9,'x',TEXTCOLOR,HiddenPageOffs);
  313.   graphstring(116,9,scoins,TEXTCOLOR,HiddenPageOffs);
  314.   x_line(100,8,101,8,20,HiddenPageOffs);
  315.   x_put_pix(102,8,HiddenPageOffs,0);
  316.   x_line(100,15,101,15,20,HiddenPageOffs);
  317.   x_put_pix(102,15,HiddenPageOffs,0);
  318.   for(loop1=0;loop1<6;loop1++)
  319.   {
  320.     x_line(99,9+loop1,102,9+loop1,20,HiddenPageOffs);
  321.     x_put_pix(103,9+loop1,HiddenPageOffs,0);
  322.   }
  323. }
  325. //CALCULATE AND DRAW MARIO///////////////////////////////////////////////////
  326. void drawmario(int x, int y)
  327. {
  328.   int loop1,loop2;
  329.   for (loop1=0;loop1<=15;loop1++)
  330.     for (loop2=0;loop2<=15;loop2++)
  331.       if (data.mario[abs(data.sprite/2)][loop1][loop2]>=0)
  332. if (y-15+loop1>=0 && y-15+loop1<224)
  333. {
  334.   if (data.direction==0)
  335.     x_put_pix(x+loop2+32,y-15+loop1,HiddenPageOffs,data.mario[data.sprite/2][loop1][loop2]);
  336.   else x_put_pix(x+15-loop2+32,y-15+loop1,HiddenPageOffs,data.mario[data.sprite/2][loop1][loop2]);
  337. }
  338. }
  340. //DRAW CHARACTERS////////////////////////////////////////////////////////////
  341. void graphchar(int xc, int yc, char c,int color, unsigned offset)
  342. {
  343.   int x,y;
  344.   unsigned char data;
  345.   unsigned char far *work;
  346.   unsigned char bitmask=0x80;
  347.   work=charset+(c<<3);
  348.   for(y=0;y<8;y++)
  349.   {
  350.     bitmask=0x80;
  351.     for(x=0;x<8;x++)
  352.     {
  353.       if((*work & bitmask))
  354. x_put_pix(x+xc,y+yc,offset,color);
  355.       bitmask=(bitmask>>1);
  356.     }
  357.   work++;
  358.   }
  359. }
  361. //DRAW A STRING//////////////////////////////////////////////////////////////
  362. void graphstring(int x,int y,char *string,int color, unsigned offset)
  363. {
  364.   int loop;
  365.   for(loop=0;loop<strlen(string);loop++)
  366.     graphchar(x+loop*8,y,string[loop],color,offset);
  367. }
  369. //DRAW SCREEN SHOWING LEVEL AND NUMBER OF LIVES//////////////////////////////
  370. void levelscreen()
  371. {
  372.   int x=75;
  373.   int y=110;
  374.   int wait[3];
  375.   char print[3];
  376.   data.sprite=0;
  377.   data.direction=0;
  378.   fillscreen(0);
  379.   status();
  380.   drawmario(x,y);
  381.   graphstring(100,82,"WORLD",TEXTCOLOR,HiddenPageOffs);
  382.   graphchar(132,100,'x',TEXTCOLOR,HiddenPageOffs);
  383.   graphchar(156,82,'-',TEXTCOLOR,HiddenPageOffs);
  384.   print[0]=(char)(player[curplay].level/5+1-208);
  385.   graphchar(148,82,print[0],TEXTCOLOR,HiddenPageOffs);
  386.   print[0]=(char)(player[curplay].level%5-208);
  387.   graphchar(164,82,print[0],TEXTCOLOR,HiddenPageOffs);
  388.   itoa(player[curplay].lives,print,10);
  389.   graphstring(148,100,print,TEXTCOLOR,HiddenPageOffs);
  390.   x_page_flip(0,0);
  391.   gettime(&t);
  392.   wait[0]=t.ti_sec;
  393.   wait[1]=wait[0];
  394.   wait[2]=0;
  395.   while(wait[2]!=3)
  396.   {
  397.     gettime(&t);
  398.     wait[0]=t.ti_sec;
  399.     if(wait[0]!=wait[1])
  400.     {
  401.       wait[1]=wait[0];
  402.       wait[2]++;
  403.     }
  404.   }
  405. }
  407. //TITLE SCREEN AND CHOOSING NUMBER OF PLAYERS////////////////////////////////
  408. int startscreen()
  409. {
  410.   int x=40;
  411.   int y=191;
  412.   int choice,screenx,offset,numplayers=1;
  413.   FILE *logoin;
  414.   int count,loop1,loop2;
  415.   char *temp;
  416.   data.sprite=0;
  417.   screenx=0;
  418.   if ((logoin=fopen("LOGO.PCX","rb"))==NULL)
  419.   {
  420.     exitgame();
  421.     printf("LOGO.PCX not found!n");
  422.     exit(1);
  423.   }
  424.   fseek(logoin,128,SEEK_SET);
  425.   temp=getpcx(logoin,temp,31040);
  426.   count=-111;
  427.   fillscreen(BACKGROUND);
  428.   drawscreen(screenx);
  429.   drawmario(x,y);
  430.   for (loop1=0;loop1<97;loop1++)
  431.   {
  432.     count+=111;
  433.     for (loop2=0;loop2<209;loop2++)
  434.       x_put_pix(loop2+55,loop1+20,HiddenPageOffs,temp[count++]);
  435.   }
  436.   free(temp);
  437.   fclose(logoin);
  438.   graphstring(160,118,"1985 NINTENDO",TEXTCOLOR,HiddenPageOffs);
  439.   graphstring(120,130,"1 PLAYER GAME",TEXTCOLOR,HiddenPageOffs);
  440.   graphstring(120,146,"2 PLAYER GAME",TEXTCOLOR,HiddenPageOffs);
  441.   graphstring(120,162,"TOP - 000000",TEXTCOLOR,HiddenPageOffs);
  442.   x_page_flip(0,0);
  443.   while(!keybuf[KEY_ENTER])
  444.   {
  445.     if (keybuf[KEY_DOWN])
  446.     {
  447.       x_rect_fill(108,129,117,137,VisiblePageOffs,BACKGROUND);
  448.       numplayers=2;
  449.     }
  450.     if (keybuf[KEY_UP])
  451.     {
  452.       x_rect_fill(108,145,117,153,VisiblePageOffs,BACKGROUND);
  453.       numplayers=1;
  454.     }
  455.     if (numplayers==1)
  456.       offset=129;
  457.     else
  458.       offset=145;
  459.     x_line(110,offset,113,offset,21,VisiblePageOffs);
  460.     x_line(109,offset+1,114,offset+1,21,VisiblePageOffs);
  461.     x_line(109,offset+2,114,offset+2,21,VisiblePageOffs);
  462.     x_line(108,offset+3,115,offset+3,21,VisiblePageOffs);
  463.     x_line(108,offset+4,115,offset+4,21,VisiblePageOffs);
  464.     x_line(108,offset+5,115,offset+5,21,VisiblePageOffs);
  465.     x_put_pix(109,offset+6,VisiblePageOffs,21);
  466.     x_put_pix(114,offset+6,VisiblePageOffs,21);
  467.     x_line(110,offset+6,113,offset+6,20,VisiblePageOffs);
  468.     x_line(110,offset+7,113,offset+7,20,VisiblePageOffs);
  469.   }
  470.   return(numplayers);
  471. }
  473. //CHANGE COLORS FOR MARIO OR LUIGI///////////////////////////////////////////
  474. void setcolors()
  475. {
  476.   if (curplay==0)
  477.   {
  478.     setpalette(1,data.marioc[0]);
  479.     setpalette(2,data.marioc[1]);
  480.   }
  481.   else
  482.   {
  483.     setpalette(1,data.luigic[0]);
  484.     setpalette(2,data.luigic[1]);
  485.   }
  486. }
  488. void rotatepal(int *palloopp, colorpal *tempcp)
  489. {
  490.   int palloop=*palloopp;
  491.   colorpal tempc=*tempcp;
  492.   int loop;
  493.   if (palloop>=16 && palloop%4==0)
  494.   {
  495.     if (palloop<=24)
  496.     {
  497.       tempc=data.palette[20];
  498.       data.palette[20]=data.palette[21];
  499.       data.palette[21]=data.palette[22];
  500.       data.palette[22]=data.palette[23];
  501.       data.palette[23]=tempc;
  502.     }
  503.     else
  504.     {
  505.       tempc=data.palette[23];
  506.       data.palette[23]=data.palette[22];
  507.       data.palette[22]=data.palette[21];
  508.       data.palette[21]=data.palette[20];
  509.       data.palette[20]=tempc;
  510.     }
  511.     for(loop=20;loop<=23;loop++)
  512.       setpalette(loop,data.palette[loop]);
  513.     if (palloop==36)
  514.       palloop=0;
  515.   }
  516.   palloop++;
  517.   *tempcp=tempc;
  518.   *palloopp=palloop;
  519. }
  521. void check_keybuf(int *movep, int *finishp, int *upp, int *downp, int *jumpp)
  522. {
  523.   int move=*movep;
  524.   int finish=*finishp;
  525.   int up=*upp;
  526.   int down=*downp;
  527.   int jumploop=*jumpp;
  528.   if (keybuf[KEY_RIGHT] && !keybuf[KEY_LEFT])
  529.   {
  530.    if (keybuf[KEY_CTRL])
  531.    {
  532.      if (move<16)
  533.        move++;
  534.    }
  535.    else
  536.    {
  537.      if (move>8)
  538.        move--;
  539.      if (move<8)
  540.        move++;
  541.    }
  542.    if (landed) //(data.world[(marioy+1)/16][(mariox+player[curplay].screenx+8)/16]>26)
  543.      data.direction=0;
  544.    }
  545.    if (keybuf[KEY_LEFT] && !keybuf[KEY_RIGHT])
  546.    {
  547.      if (keybuf[KEY_CTRL])
  548.      {
  549.        if (move>-16)
  550.  move--;
  551.      }
  552.      else
  553.      {
  554.        if (move<-8)
  555.  move++;
  556.        if (move>-8)
  557.  move--;
  558.      }
  559.      if (landed) //(data.world[(marioy+1)/16][(mariox+player[curplay].screenx+8)/16]>26)
  560.        data.direction=1;
  561.      }
  562.    if (keybuf[KEY_ALT] && !down)
  563.    {
  564.      up=-17;
  565.      data.sprite=12;
  566.      jumploop++;
  567.      if (jumploop>10)
  568.      {
  569.        down=1;
  570.        jumploop=0;
  571.      }
  572.    }
  573.    if (keybuf[KEY_P])
  574.    {
  575.      graphstring(140,100,"Pause",TEXTCOLOR,VisiblePageOffs);
  576.      clear_key_buffer();
  577.      while(!keybuf[KEY_P]);
  578.      clear_key_buffer();
  579.      graphstring(140,100,"Pause",BACKGROUND,VisiblePageOffs);
  580.    }
  581.    if(keybuf[KEY_Q])
  582.    {
  583.      graphstring(130,100,"Quit(Y/N)",TEXTCOLOR,VisiblePageOffs);
  584.      clear_key_buffer();
  585.      while(!keybuf[KEY_Y] && !keybuf[KEY_N]);
  586.      if (keybuf[KEY_Y] && !keybuf[KEY_N])
  587.        finish=3;
  588.      clear_key_buffer();
  589.      graphstring(130,100,"Quit(Y/N)",BACKGROUND,VisiblePageOffs);
  590.    }
  591.    if ((!keybuf[KEY_RIGHT] && !keybuf[KEY_LEFT]) || (keybuf[KEY_RIGHT] && keybuf[KEY_LEFT]))
  592.    {
  593.     if (move>0)
  594.       move--;
  595.     if (move<0)
  596.       move++;
  597.    }
  598.   *movep=move;
  599.   *finishp=finish;
  600.   *upp=up;
  601.   *downp=down;
  602.   *jumpp=jumploop;
  603. }
  605. void animate_mario(int move)
  606. {
  607.   if (landed)
  608.   {
  609.     if (data.sprite==10 && ((move>0 && data.direction==0) || (move<0 && data.direction==1)))
  610.       data.sprite=1;
  611.     if (move==0)
  612.       data.sprite=0;
  613.     if ((move>0 && data.direction==0) || (move<0 && data.direction==1))
  614.     {
  615.       if(abs(move)<16)
  616. data.sprite++;
  617.       else
  618. data.sprite+=2;
  619.       if (data.sprite>=10)
  620. data.sprite=2;
  621.     }
  622.     if ((move>0 && data.direction==1) || (move<0 && data.direction==0))
  623.       data.sprite=10;
  624.   }
  625. }
  627. void move_mario(int *movep)
  628. {
  629.   int move=*movep;
  630.   int loop1,loop2;
  631.   if (marioy>16)
  632.   {
  633.     if (move>0)
  634.       for (loop1=0;loop1<16;loop1++)
  635. for (loop2=0;loop2<=move;loop2++)
  636.   if (data.world[(marioy-loop1)/16][(mariox+player[curplay].screenx+13+loop2/4)/16]>26)
  637.     move=loop2;
  638.     if (move<0)
  639.       for (loop1=0;loop1<16;loop1++)
  640. for (loop2=0;loop2>=move;loop2--)
  641.   if (data.world[(marioy-loop1)/16][(mariox+player[curplay].screenx+2+loop2/4)/16]>26 || (mariox+loop1/2)<=0)
  642.     move=loop2;
  643.   }
  644.   if(mariox>100 && move>0)
  645.     player[curplay].screenx+=move/4;
  646.   else
  647.     if (mariox+move/4>0)
  648.       mariox+=move/4;
  649.   *movep=move;
  650. }
  652. void addcoin(int x, int y)
  653. {
  654.   cointype *temp,*c;
  655.   c=bcoin;
  656.   while ((c->next)!=NULL)
  657.     c=c->next;
  658.   temp=(cointype *)malloc(sizeof(cointype));
  659.   temp->next=NULL;
  660.   temp->coinx=x;
  661.   temp->coiny=y;
  662.   temp->coinloop=-10;
  663.   temp->dy=0;
  664.   c->next=temp;
  665. }
  667. void removecoin()
  668. {
  669.   cointype *temp;
  670.   cointype *c=bcoin;
  671.   temp=c->next;
  672.   c->next=c->next->next;
  673.   addscore(temp->coinx,temp->coiny,"200");
  674.   free(temp);
  675. }
  677. void drawcoin(int x)
  678. {
  679.   cointype *c=bcoin;
  680.   int loop,num=0;
  681.   while ((c->next)!=NULL)
  682.   {
  683.     num++;
  684.     c=c->next;
  685.   }
  686.   c=bcoin;
  687.   for (loop=0;loop<num;loop++)
  688.   {
  689.     c=c->next;
  690.     if (((c->coinx)*16+32-x)>16)
  691.       x_put_masked_pbm((c->coinx)*16+32-x,(c->coiny)*16+c->dy,HiddenPageOffs,data.coin[abs((c->coinloop)%3)]);
  692.     c->coinloop++;
  693.     c->dy+=c->coinloop;
  694.     if (c->coinloop>=10)
  695.        removecoin();
  696.   }
  697. }
  699. void addscore(int x, int y, char *pscore)
  700. {
  701.   scoretype *temp,*s;
  702.   s=bscore;
  703.   while ((s->next)!=NULL)
  704.     s=s->next;
  705.   temp=(scoretype *)malloc(sizeof(scoretype));
  706.   temp->next=NULL;
  707.   temp->scorex=x;
  708.   temp->scorey=y;
  709.   temp->scoreloop=0;
  710.   strcpy(temp->num,pscore);
  711.   s->next=temp;
  712. }
  714. void removescore()
  715. {
  716.   scoretype *temp;
  717.   scoretype *s=bscore;
  718.   temp=s->next;
  719.   s->next=s->next->next;
  720.   free(temp);
  721. }
  723. void drawscore(int x)
  724. {
  725.   scoretype *s=bscore;
  726.   while ((s->next)!=NULL)
  727.   {
  728.     s=s->next;
  729.     if (((s->scorex)*16+32-x)>16)
  730.       graphstring((s->scorex)*16+32-x,(s->scorey)*16+(s->scoreloop),s->num,TEXTCOLOR,HiddenPageOffs);
  731.     s->scoreloop--;
  732.     if (s->scoreloop<=-20)
  733.        removescore();
  734.   }
  735. }
  737. void exitgame()
  738. {
  739.   int loop;
  740.   for (loop=0;loop<52;loop++)
  741.     farfree(data.block[loop]);
  742.   for (loop=0;loop<3;loop++)
  743.     farfree(data.coin[loop]);
  744.   free(bcoin);
  745.   free(bscore);
  746.   uninstall_new_key_handler();
  747.   x_remove_vsync_handler();
  748.   x_text_mode();
  749. }
  751. void check_jump(int *upp, int *downp, int *jumploopp)
  752. {
  753.   int loop1,loop2;
  754.   int up=*upp;
  755.   int down=*downp;
  756.   int jumploop=*jumploopp;
  757.   loop1=3;
  758.   landed=0;
  759.   while (loop1<13 && landed==0)
  760.   {
  761.     if (data.world[(marioy+1)/16][(mariox+player[curplay].screenx+loop1)/16]>26)
  762.       landed=1;
  763.     else
  764.       landed=0;
  765.     loop1++;
  766.   }
  767.   if (!landed || marioy<16)
  768.     if (up<17)
  769.       up+=1;
  770.   if (up>0) //CHECK IF MARIO LANDED//
  771.   {
  772.     down=1;
  773.     loop1=marioy;
  774.     if (marioy<207)
  775.     {
  776.       while(loop1++<marioy+up/4)
  777.       {
  778. for (loop2=3;loop2<14;loop2+=9)
  779.   if (data.world[loop1/16][(mariox+player[curplay].screenx+loop2)/16]>26)
  780.   {
  781.     marioy=loop1-1;
  782.     loop1=marioy+up/4;
  783.     loop2=13;
  784.     up=0;
  785.     down=0;
  786.     data.sprite=0;
  787.   }
  788.       }
  789.     }
  790.     marioy+=up/4;
  791.   }
  792.   if (up<0) //CHECK IF MARIO HIT A BLOCK/
  793.   {
  794.     if (!keybuf[KEY_ALT])
  795.     {
  796.       down=1;
  797.       jumploop=0;
  798.     }
  799.     loop1=marioy;
  800.     marioy+=up/4;
  801.     if (marioy>24)
  802.     {
  803.       while(loop1-->=marioy+up/4)
  804.       {
  805. if(data.world[loop1/16-1][(mariox+player[curplay].screenx+8)/16]>26 ||data.world[loop1/16-1][(mariox+player[curplay].screenx+8)/16]==18)
  806. {
  807.   marioy=loop1;
  808.   loop1=marioy+up/4-1;
  809.   up=-up;
  810.   down=1;
  811.   jumploop=0;
  812.   if (data.bumped[0]==0 && data.bumped[1]==0)
  813.   {
  814.     data.bumped[0]=(mariox+player[curplay].screenx+8)/16;
  815.     data.bumped[1]=marioy/16-1;
  816.     data.bumploop=-3;
  817.   }
  818. }
  819. if (data.world[loop1/16-1][(mariox+player[curplay].screenx+12)/16]>26 && data.world[loop1/16-1][(mariox+player[curplay].screenx+8)/16]<26)
  820.   mariox-=1;
  821. if (data.world[loop1/16-1][(mariox+player[curplay].screenx+3)/16]>26 && data.world[loop1/16-1][(mariox+player[curplay].screenx+8)/16]<26)
  822.   mariox+=1;
  823.       }
  824.     }
  825.   }
  826.   *upp=up;
  827.   *downp=down;
  828.   *jumploopp=jumploop;
  829. }
  831. void check_blocks()
  832. {
  833.   int bumpedblock=0;
  834.   if (data.world[(marioy-8)/16][(mariox+player[curplay].screenx+8)/16]==10)
  835.   {
  836.     data.world[(marioy-8)/16][(mariox+player[curplay].screenx+8)/16]=0;
  837.     player[curplay].score[0]+=200;
  838.     player[curplay].coins[0]++;
  839.   }
  840.   if (data.bumploop==-3)
  841.   {
  842.     bumpedblock=data.world[marioy/16-1][(mariox+player[curplay].screenx+8)/16];
  843.     switch (bumpedblock)
  844.     {
  845.       case 18:
  846.       case 28:
  847. data.world[marioy/16-1][(mariox+player[curplay].screenx+8)/16]=27;
  848. player[curplay].score[0]+=200;
  849. player[curplay].coins[0]++;
  850. addcoin(data.bumped[0],data.bumped[1]-1);
  851.       case 29:
  852. if (data.world[data.bumped[1]-1][data.bumped[0]]==10)
  853. {
  854.   data.world[data.bumped[1]-1][data.bumped[0]]=0;
  855.   player[curplay].score[0]+=200;
  856.   player[curplay].coins[0]++;
  857.   addcoin(data.bumped[0],data.bumped[1]-1);
  858. }
  859. break;
  860.       default:
  861. data.bumped[0]=data.bumped[1]=0;
  862. data.bumploop=0;
  863. break;
  864.     }
  865.   }
  866.   if (player[curplay].coins[0]==100)
  867.   {
  868.     player[curplay].lives++;
  869.     player[curplay].coins[0]=0;
  870.   }
  871. }
  873. void check_finish(int *finishp)
  874. //CHECK FOR END OF CURRENT PLAYER LOOP///////////////////////////////////////
  875. {
  876.   int finish=*finishp;
  877.   if (marioy>=250)
  878.     finish=1;
  879.   if ((mariox+player[curplay].screenx+16)/16==data.maxlength-13)
  880.     finish=2;
  881.   if (times[0]==0)
  882.     finish=1;
  883.   *finishp=finish;
  884. }
  885. //END////////////////////////////////////////////////////////////////////////