home *** CD-ROM | disk | FTP | other *** search
/ Crazy Pacman / CrazyPacman.iso / pacman / PACMAN / SOURCE / P_IO.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-01-27  |  17.7 KB  |  792 lines
  1. #include "p_io.h"
  2.  
  3. int                          lastkey=1;
  4. int                          key_flag=0;
  5. int                          allow_int=0;
  6. int                          INIT_JOY=0;
  7. int                          JOYSTICK=0;
  8. int                          dir, key;
  9. int                          Achsengleich, Hoch, Runter, Rechts, Links;
  10. JSPOS                        jsp[2];             /* aktuelle Joystick-Position */
  11. BYTE                         aktstick;           /* ausgewählter Joystick */
  12. BYTE                         j1but[2];           /* Button 1 auf Joystick 1 und 2 */
  13. BYTE                         j2but[2];           /* Button 2 auf Joystick 1 und 2 */
  14. BYTE                         out;                /* nimmt Flags für Seitenkollision auf */
  15. int                          maxx, maxy;         /* maximale Joystick-Position */
  16. int                          minx, miny;         /* minimale Joystick-Position */
  17. int                          x_plus,x_minus;
  18. int                          y_plus,y_minus;
  19. int                          Sim_Taste, Key_status;
  20. int                          i_warte;
  21.  
  22. /*
  23. /////////////////////////////////////////////////////////////////////
  24. */
  25. void GetJoyButton(BYTE *j1b1, BYTE *j1b2)
  26. {
  27.  union REGS regs;                                /* nimmt die Prozessorregister auf */
  28.  regs.h.ah = 0x84;                               /* Funktion 84h */
  29.  regs.x.dx = 0;                                  /* Unterfunktion 00h */
  30.  int86( 0x15, ®s, ®s );                    /* Interrupt 15h aufrufen */
  31.  *j1b1 = (( regs.h.al &  16 ) >> 4) ^ 1;         /* Bit 4 von AL = J1B1 */
  32.  *j1b2 = (( regs.h.al &  32 ) >> 5) ^ 1;         /* Bit 5 von AL = J1B2 */
  33. }
  34. /*
  35. /////////////////////////////////////////////////////////////////////
  36. */
  37. void GetJoyPos(JSPOS *Js1Ptr)
  38. {
  39.  stick(&Js1Ptr->x,&Js1Ptr->y);
  40. }
  41. /*
  42. /////////////////////////////////////////////////////////////////////
  43. */
  44. void InitJoy(int page)
  45. {
  46.  union REGS regs;                                /* nimmt die Prozessorregister auf */
  47.  int Joystick_da=1;
  48.  unsigned int i=0;
  49.  BYTE status;
  50.  j1but[0]=0;
  51.  j2but[0]=0;
  52.  Back=Save_Back(page,Back);
  53.  Get_Back(1-page,Back);
  54.  setpage(1);
  55.  showpage(0);
  56.  show_pic(16,55,15,"pix\\info1");
  57.  regs.h.ah = 0x84;                               /* Funktion 84h */
  58.  regs.x.dx = 1;                                  /* Unterfunktion 00h */
  59.  int86( 0x15, ®s, ®s );                    /* Interrupt 15h aufrufen */
  60.  if (regs.x.cflag)
  61.  {
  62.   gprintf(55,112,239+13,239+2,"Interrupt 15h nicht");
  63.   gprintf(55,122,239+13,239+2,"gefunden !");
  64.   showpage(1);
  65.   Joystick_da=0;
  66.   key=0;
  67.   while (key!=' ')
  68.    key=get_key();
  69.   key=0;
  70.  }
  71.  if (Joystick_da)
  72.  {
  73.   for ( i=0; i<40000L; ++i )
  74.    status=inportb(0x201);
  75.   if (status==0xff)
  76.   {
  77.    gprintf(55,112,239+13,239+2,"Joystick nicht");
  78.    gprintf(55,122,239+13,239+2,"gefunden !");
  79.    showpage(1);
  80.    Joystick_da=0;
  81.    K_Clear();
  82.    while (key!=' ')
  83.     key=get_key();
  84.    key=0;
  85.   }
  86.  }
  87.  if (Joystick_da)
  88.  {
  89.   gprintf(55,82,239+13,239+2,"Bitte bewegen Sie den");
  90.   gprintf(55,92,239+13,239+2,"Joystick in die obere");
  91.   gprintf(55,102,239+13,239+2,"rechte Schalterstellung");
  92.   gprintf(55,112,239+13,239+2,"und betätigen Sie einen");
  93.   gprintf(55,122,239+13,239+2,"der beiden Buttons." );
  94.   showpage(1);
  95.   K_Clear();
  96.   do
  97.   {
  98.    GetJoyButton( &j1but[0], &j2but[0] );
  99.    key=get_kkey();
  100.   }
  101.   while (((j1but[0]|j2but[0])==0)&&(!key)) ;
  102.   aktstick=0;
  103.   if (!key)
  104.   {
  105.    warte_d(8);
  106.    INIT_JOY=1;
  107.    GetJoyPos( &jsp[0]);                          /* Position abfragen */
  108.    maxx = jsp[aktstick].x;                       /* und merken        */
  109.    miny = jsp[aktstick].y;
  110.    do                                            /* warten, bis Taste wieder losgelassen */
  111.     GetJoyButton( &j1but[0], &j2but[0] );
  112.    while ( ( j1but[aktstick] | j2but[aktstick]) != 0);
  113.    gprintf(55,152,239+13,239+2,"Bitte bewegen Sie den");
  114.    gprintf(55,162,239+13,239+2,"Joystick in die untere");
  115.    gprintf(55,172,239+13,239+2,"linke Schalterstellung");
  116.    gprintf(55,182,239+13,239+2,"und betätigen Sie einen");
  117.    gprintf(55,192,239+13,239+2,"der beiden Buttons." );
  118.    do                                            /* wieder auf Betätigung einer Taste warten */
  119.     GetJoyButton( &j1but[0], &j2but[0] );
  120.    while ( ( j1but[aktstick] | j2but[aktstick] ) == 0 );
  121.    GetJoyPos( &jsp[0] );                         /* Position abfragen */
  122.    minx = jsp[aktstick].x;                       /* und merken        */
  123.    maxy = jsp[aktstick].y;
  124.    x_plus=(maxx/10)*7;
  125.    x_minus=(maxx/10)*3;
  126.    y_plus=(maxy/10)*7;
  127.    y_minus=(maxy/10)*3;
  128.    allow_int=1;
  129.   }
  130.  }
  131.  K_Clear();
  132. }
  133. /*
  134. /////////////////////////////////////////////////////////////////////
  135. */
  136. void Do_Joy(void)
  137. {
  138.  JOYSTICK=1;
  139.  set_color(0,63,0,0);
  140.  warte_d(2);
  141.  set_color(0,0,0,0);
  142.  Hoch=C_HOCH;
  143.  Runter=C_RUNTER;
  144.  Links=C_LINKS;
  145.  Rechts=C_RECHTS;
  146.  Achsengleich=C_ACHSENGLEICH;
  147.  K_Clear();
  148. }
  149. /*
  150. /////////////////////////////////////////////////////////////////////
  151. */
  152. int get_file_int(FILE *Load_Lab)
  153. {
  154.  char load_buf=0;
  155.  int zahl;
  156.  int t;
  157.  t=1;
  158.  zahl=0;
  159.  while ((load_buf<'0')||(load_buf>'9'))
  160.   if (!fread(&load_buf,1,1,Load_Lab))
  161.    fehler(14,1);
  162.  do
  163.  {
  164.   if ((load_buf>='0')&&(load_buf<='9'))
  165.   {
  166.    zahl*=t;
  167.    if (t<10) t=10;
  168.    zahl+=(int) (load_buf-'0');
  169.   }
  170.   if (!fread(&load_buf,1,1,Load_Lab))
  171.    fehler(14,2);
  172.  }
  173.  while ((load_buf>='0')&&(load_buf<='9'));
  174.  return zahl;
  175. }
  176. /*
  177. /////////////////////////////////////////////////////////////////////
  178. */
  179. void load_laby(BYTE lab_col)
  180. {
  181.  int xx,yy;
  182.  char *filename="pix\\lab1";
  183.  yy=0;
  184.  xx=0;
  185.  setpage(0);
  186.  showpage(1);
  187.  filename[7]='1'+lab_col;
  188.  if (lab_col>9)
  189.   filename[7]='A'+lab_col-10;
  190.  show_pic(0,0,6,filename);
  191.  nichts= GetVideo(0,xx,yy,33,40,nichts);
  192.  xx+=34;
  193.  gar_nichts= GetVideo(0,xx,yy,33,40,gar_nichts);
  194.  xx+=34;
  195.  l=GetVideo(0,xx,yy,33,40,l);
  196.  xx+=34;
  197.  r= GetVideo(0,xx,yy,33,40,r);
  198.  xx+=34;
  199.  o= GetVideo(0,xx,yy,33,40,o);
  200.  xx+=34;
  201.  u= GetVideo(0,xx,yy,33,40,u);
  202.  xx+=34;
  203.  lr= GetVideo(0,xx,yy,33,40,lr);
  204.  xx+=34;
  205.  ou= GetVideo(0,xx,yy,33,40,ou);
  206.  xx+=34;
  207.  lo= GetVideo(0,xx,yy,33,40,lo);
  208.  xx=0;
  209.  yy+=41;
  210.  lu= GetVideo(0,xx,yy,33,40,lu);
  211.  xx+=34;
  212.  ro= GetVideo(0,xx,yy,33,40,ro);
  213.  xx+=34;
  214.  ru= GetVideo(0,xx,yy,33,40,ru);
  215.  xx+=34;
  216.  lro= GetVideo(0,xx,yy,33,40,lro);
  217.  xx+=34;
  218.  lru= GetVideo(0,xx,yy,33,40,lru);
  219.  xx+=34;
  220.  lou= GetVideo(0,xx,yy,33,40,lou);
  221.  xx+=34;
  222.  rou= GetVideo(0,xx,yy,33,40,rou);
  223.  xx+=34;
  224.  lrou= GetVideo(0,xx,yy,33,40,lrou);
  225. }
  226. /*
  227. /////////////////////////////////////////////////////////////////////
  228. */
  229. void load_lab(int nummer, char *File_Name)
  230. {
  231.  int s,t;
  232.  FILE *Load_Lab;
  233.  LAB_CODE test_lab;
  234.  char load_buf;
  235.  test_lab.Titel=TITEL;
  236.  test_lab.Desc[0]=DESC[0];
  237.  test_lab.Desc[1]=DESC[1];
  238.  test_lab.Desc[2]=DESC[2];
  239.  test_lab.Desc[3]=DESC[3];
  240.  test_lab.Desc[4]=DESC[4];
  241.  test_lab.Desc[5]=DESC[5];
  242.  test_lab.Desc[6]=DESC[6];
  243.  test_lab.Desc[7]=DESC[7];
  244.  test_lab.Desc[8]=DESC[8];
  245.  test_lab.lab[0]=LAB[0];
  246.  test_lab.lab[1]=LAB[1];
  247.  test_lab.lab[2]=LAB[2];
  248.  test_lab.lab[3]=LAB[3];
  249.  test_lab.lab[4]=LAB[4];
  250.  test_lab.lab[5]=LAB[5];
  251.  test_lab.lab[6]=LAB[6];
  252.  test_lab.lab[7]=LAB[7];
  253.  test_lab.lab[8]=LAB[8];
  254.  test_lab.lab[9]=LAB[9];
  255.  test_lab.dots[0]=DOT1[0];
  256.  test_lab.dots[1]=DOT1[1];
  257.  test_lab.dots[2]=DOT1[2];
  258.  test_lab.dots[3]=DOT1[3];
  259.  test_lab.dots[4]=DOT1[4];
  260.  test_lab.dots[5]=DOT1[5];
  261.  test_lab.dots[6]=DOT1[6];
  262.  test_lab.dots[7]=DOT1[7];
  263.  test_lab.dots[8]=DOT1[8];
  264.  test_lab.restore[0]=DOT2[0];
  265.  test_lab.restore[1]=DOT2[1];
  266.  test_lab.restore[2]=DOT2[2];
  267.  test_lab.restore[3]=DOT2[3];
  268.  test_lab.restore[4]=DOT2[4];
  269.  test_lab.restore[5]=DOT2[5];
  270.  test_lab.restore[6]=DOT2[6];
  271.  test_lab.restore[7]=DOT2[7];
  272.  test_lab.restore[8]=DOT2[8];
  273.  nummer++;
  274.  if (nummer<10)
  275.  {
  276.   File_Name[11]='0';
  277.   File_Name[12]=((BYTE) nummer) +'0';
  278.  }
  279.  if (nummer>=10)
  280.  {
  281.   File_Name[11]=((BYTE) nummer/10) +'0';
  282.   File_Name[12]=((BYTE) (nummer-(nummer/10)*10)) +'0';
  283.  }
  284.  if ((Load_Lab = fopen(File_Name, "rb"))== NULL)
  285.  {
  286.   if (File_Name[6]=='l')
  287.   {
  288.    nummer=1;
  289.    Level=0;
  290.    if ((Load_Lab = fopen("level\\level01.pac", "rb"))== NULL)
  291.    {
  292.     fehler(13,1);
  293.    }
  294.   }
  295.   else
  296.   {
  297.    nummer=1;
  298.    if ((Load_Lab = fopen("level\\bonus01.pac", "rb"))== NULL)
  299.    {
  300.     fehler(13,2);
  301.    }
  302.   }
  303.  }
  304. /*///////////////// Titel lesen */
  305.  t=0;
  306.  do
  307.  {
  308.   fread(&load_buf,1,1,Load_Lab);
  309.   if ((load_buf!='*')&&(load_buf!=(BYTE)0x0a)&&(load_buf!=(BYTE)0x0d))
  310.   {
  311.    TITEL[t++]=load_buf;
  312.   }
  313.  }
  314.  while ((load_buf!='*')&&(load_buf!=(BYTE)0x0d));
  315.  TITEL[t]=(BYTE)0;
  316.  while (load_buf!=(BYTE)0x0a)
  317.   fread(&load_buf,1,1,Load_Lab);
  318. /*////////////////  Desc lesen */
  319.  s=0;
  320.  while (s<9)
  321.  {
  322.   t=0;
  323.   do
  324.   {
  325.    fread(&load_buf,1,1,Load_Lab);
  326.    if ((load_buf!='*')&&(load_buf!=(BYTE)0x0a)&&(load_buf!=(BYTE)0x0d))
  327.    {
  328.     DESC[s][t++]=load_buf;
  329.    }
  330.   }
  331.   while ((load_buf!='*')&&(load_buf!=(BYTE)0x0d));
  332.   DESC[s][t]=(BYTE)0;
  333.   while (load_buf!=(BYTE)0x0a)
  334.    fread(&load_buf,1,1,Load_Lab);
  335.   s++;
  336.  }
  337. /*////////////////  Lab lesen */
  338.  s=0;
  339.  while (s<10)
  340.  {
  341.   t=0;
  342.   while (t<10)
  343.   {
  344.    fread(&load_buf,1,1,Load_Lab);
  345.    if ((load_buf!='*')&&(load_buf!=(BYTE)0x0a)&&(load_buf!=(BYTE)0x0d))
  346.    {
  347.     LAB[s][t++]=load_buf;
  348.    }
  349.   }
  350.   LAB[s][t]=(BYTE)0;
  351.   while (load_buf!=(BYTE)0x0a)
  352.    fread(&load_buf,1,1,Load_Lab);
  353.   s++;
  354.  }
  355. /*////////////////  Dots lesen */
  356.  s=0;
  357.  while (s<9)
  358.  {
  359.   t=0;
  360.   while (t<9)
  361.   {
  362.    fread(&load_buf,1,1,Load_Lab);
  363.    if ((load_buf!='*')&&(load_buf!=(BYTE)0x0a)&&(load_buf!=(BYTE)0x0d))
  364.    {
  365.     DOT1[s][t]=load_buf;
  366.     DOT2[s][t++]=load_buf;
  367.    }
  368.   }
  369.   DOT1[s][t]=(BYTE)0;
  370.   DOT2[s][t]=(BYTE)0;
  371.   while (load_buf!=(BYTE)0x0a)
  372.    fread(&load_buf,1,1,Load_Lab);
  373.   s++;
  374.  }
  375.  test_lab.Pac_x=get_file_int(Load_Lab);
  376.  test_lab.Pac_y=get_file_int(Load_Lab);
  377.  test_lab.dot1_type=get_file_int(Load_Lab);
  378.  test_lab.dot2_type=get_file_int(Load_Lab);
  379.  test_lab.Bonus=get_file_int(Load_Lab);
  380.  test_lab.Bonus_x=get_file_int(Load_Lab);
  381.  test_lab.Bonus_y=get_file_int(Load_Lab);
  382.  test_lab.Bonus_wert=get_file_int(Load_Lab);
  383.  test_lab.dot1_col=get_file_int(Load_Lab);
  384.  test_lab.dot2_col=get_file_int(Load_Lab);
  385.  test_lab.lab_col=get_file_int(Load_Lab);
  386.  test_lab.red_x=get_file_int(Load_Lab);
  387.  test_lab.red_y=get_file_int(Load_Lab);
  388.  test_lab.gelb_x=get_file_int(Load_Lab);
  389.  test_lab.gelb_y=get_file_int(Load_Lab);
  390.  test_lab.gruen_x=get_file_int(Load_Lab);
  391.  test_lab.gruen_y=get_file_int(Load_Lab);
  392.  test_lab.lila_x=get_file_int(Load_Lab);
  393.  test_lab.lila_y=get_file_int(Load_Lab);
  394.  test_lab.house_x=get_file_int(Load_Lab);
  395.  test_lab.house_y=get_file_int(Load_Lab);
  396.  test_lab.dot_anzahl=get_file_int(Load_Lab);
  397.  test_lab.geister_speed[RED-1]=get_file_int(Load_Lab);
  398.  test_lab.geister_speed[GELB-1]=get_file_int(Load_Lab);
  399.  test_lab.geister_speed[GRUEN-1]=get_file_int(Load_Lab);
  400.  test_lab.geister_speed[LILA-1]=get_file_int(Load_Lab);
  401.  test_lab.ghost_speed=get_file_int(Load_Lab);
  402.  test_lab.eye_speed=get_file_int(Load_Lab);
  403.  test_lab.pac_speed=get_file_int(Load_Lab);
  404.  test_lab.pillen_laenge=get_file_int(Load_Lab);
  405.  test_lab.Max_dot=get_file_int(Load_Lab);
  406.  fclose(Load_Lab);
  407.  load_laby(test_lab.lab_col);
  408.  switch (test_lab.dot1_col)
  409.  {
  410.   case 0 :
  411.   {
  412.    setpage(0);
  413.    showpage(1);
  414.    show_pic(0,0,7,"pix\\dot1_1");
  415.    break;
  416.   }
  417.   case 1 :
  418.   {
  419.    setpage(0);
  420.    showpage(1);
  421.    show_pic(0,0,7,"pix\\dot1_2");
  422.    break;
  423.   }
  424.   case 2 :
  425.   {
  426.    setpage(0);
  427.    showpage(1);
  428.    show_pic(0,0,7,"pix\\dot1_3");
  429.    break;
  430.   }
  431.  }
  432.  switch (test_lab.dot2_col)
  433.  {
  434.   case 0 :
  435.   {
  436.    setpage(0);
  437.    showpage(1);
  438.    show_pic(0,0,8,"pix\\dot1_1");
  439.    break;
  440.   }
  441.   case 1 :
  442.   {
  443.    setpage(0);
  444.    showpage(1);
  445.    show_pic(0,0,8,"pix\\dot1_2");
  446.    break;
  447.   }
  448.   case 2 :
  449.   {
  450.    setpage(0);
  451.    showpage(1);
  452.    show_pic(0,0,8,"pix\\dot1_3");
  453.    break;
  454.   }
  455.  }
  456.  Labyrinth=test_lab;
  457. }
  458. /*
  459. /////////////////////////////////////////////////////////////////////
  460. */
  461. void get_lab(int nummer)
  462. {
  463.  char *File_Name="level\\level00.pac";
  464.  load_lab(nummer,File_Name);
  465. }
  466. /*
  467. /////////////////////////////////////////////////////////////////////
  468. */
  469. void get_Extra(void)
  470. {
  471.  int nummer;
  472.  char *File_Name="level\\Bonus00.pac";
  473.  nummer=random(max_bonus);
  474.  load_lab(nummer,File_Name);
  475. }
  476. /*
  477. /////////////////////////////////////////////////////////////////////
  478. */
  479. void get_max_bonus(void)
  480. {
  481.  FILE *BONUS;
  482.  if ((BONUS = fopen("level\\bonus.pac", "rb"))== NULL)
  483.  {
  484.   fehler(16,1);
  485.  }
  486.  max_bonus=get_file_int(BONUS);
  487.  fclose(BONUS);
  488. }
  489. /*
  490. /////////////////////////////////////////////////////////////////////
  491. */
  492. BYTE demo_game_get_key(void)
  493. {
  494.  BYTE Taste;
  495.  Taste=get_kkey();
  496.  if (Taste) return 27;
  497.  if ((random(100)>50)&&(dx+dy))
  498.   return lastkey;
  499.  switch (random(4))
  500.  {
  501.   case 0:
  502.   {
  503.    Taste=Hoch;
  504.    if (dy>0)
  505.     Taste=lastkey;
  506.    break;
  507.   }
  508.   case 1:
  509.   {
  510.    Taste=Runter;
  511.    if (dy<0)
  512.     Taste=lastkey;
  513.    break;
  514.   }
  515.   case 2:
  516.   {
  517.    Taste=Links;
  518.    if (dx>0)
  519.     Taste=lastkey;
  520.    break;
  521.   }
  522.   case 3:
  523.   {
  524.    Taste=Rechts;
  525.    if (dx<0)
  526.     Taste=lastkey;
  527.    break;
  528.   }
  529.  }
  530.  return Taste;
  531. }
  532. /*
  533. /////////////////////////////////////////////////////////////////////
  534. */
  535. BYTE game_get_key(void)
  536. {
  537.  union REGS regs;                                /* nimmt die Prozessorregister auf */
  538.  BYTE Taste=0;
  539.  int jx,jy;
  540.  if (!JOYSTICK)
  541.   return get_kkey();
  542.  else
  543.  {
  544.   Taste=get_kkey();
  545.   if ((Taste!='c')&&(Taste!='C')&&(Taste!=(BYTE)27))
  546.   {
  547.    Taste=0;
  548.    regs.h.ah = 0x84;                             /* Funktion 84h */
  549.    regs.x.dx = 0;                                /* Unterfunktion 00h */
  550.    int86( 0x15, ®s, ®s );                  /* Interrupt 15h aufrufen */
  551.    j1but[0] = (( regs.h.al &  16 ) >> 4) ^ 1;    /* Bit 4 von AL = J1B1 */
  552.    j1but[0] = (( regs.h.al &  32 ) >> 5) ^ 1;    /* Bit 5 von AL = J1B2 */
  553.    if ((j1but[aktstick] | j2but[aktstick] ) == 1)
  554.     Taste= ' ';
  555.    GetJoyPos( &jsp[0] );                         /* Position abfragen */
  556.    jx = jsp[0].x;
  557.    jy = jsp[0].y;
  558.    if (jx>x_plus) Taste=C_RECHTS;        /* 6; */
  559.    if (jx<x_minus) Taste=C_LINKS;        /* 4; */
  560.    if (jy>y_plus) Taste=C_RUNTER;        /* 2; */
  561.    if (jy<x_minus) Taste=C_HOCH;        /* 8; */
  562.   }
  563.  }
  564.  return Taste;
  565. }
  566. /*
  567. /////////////////////////////////////////////////////////////////////
  568. */
  569. BYTE Get_Dir(register BYTE dir)
  570. {
  571.  switch (dir)
  572.  {
  573.   case C_HOCH :
  574.   {
  575.    return (BYTE) 3;
  576.   }
  577.   case C_RUNTER :
  578.   {
  579.    return (BYTE) 0;
  580.   }
  581.   case C_LINKS :
  582.   {
  583.    return (BYTE) 1;
  584.   }
  585.   case C_RECHTS :
  586.   {
  587.    return (BYTE) 2;
  588.   }
  589.   case K_RECHTS :
  590.   {
  591.    return (BYTE) 2;
  592.   }
  593.   case K_HOCH :
  594.   {
  595.    return (BYTE) 3;
  596.   }
  597.   case K_RUNTER :
  598.   {
  599.    return (BYTE) 0;
  600.   }
  601.   case K_LINKS :
  602.   {
  603.    return (BYTE) 1;
  604.   }
  605.  }
  606.  return (BYTE) 0;
  607. }
  608. /*
  609. /////////////////////////////////////////////////////////////////////
  610. */
  611. void get_default(void)
  612. {
  613.  FILE  *def_werte;
  614.  if ((def_werte = fopen("default.pac", "rb"))== NULL)
  615.  {
  616.   def_werte = fopen("default.pac", "wb");
  617.   fwrite(&config,sizeof(config),1,def_werte);
  618.   fclose(def_werte);
  619.   def_werte = fopen("default.pac", "rb");
  620.  }
  621.  fread(&config,sizeof(config),1,def_werte);
  622.  fclose(def_werte);
  623.  Start_Level=config.start_l;
  624.  i_warte=config.warte;
  625. # ifndef NO_SOUND
  626.  mod_device=config.mod_device;
  627.  mix=config.mix;
  628.  mod_on=config.mod_on;
  629. # ifndef SHAREWARE_SOUND
  630.  sample_on=config.sample_on;
  631. # endif
  632. # endif
  633.  Ghost_fressen=config.Ghost_fressen;
  634. }
  635. /*
  636. /////////////////////////////////////////////////////////////////////
  637. */
  638. void save_config(void)
  639. {
  640.  FILE *Best;
  641.  config.start_l=Start_Level;
  642.  config.warte=i_warte;
  643. # ifndef NO_SOUND
  644.  config.mod_device=mod_device;
  645.  config.mix=mix;
  646.  config.mod_on=mod_on;
  647. # ifndef SHAREWARE_SOUND
  648.  config.sample_on=sample_on;
  649. # endif
  650. # endif
  651.  config.Ghost_fressen=Ghost_fressen;
  652.  Best = fopen("default.pac", "wb");
  653.  fwrite(&config,sizeof(config),1,Best);
  654.  fclose(Best);
  655. }
  656. /*
  657. /////////////////////////////////////////////////////////////////////
  658. */
  659. void warte(void)
  660. {
  661.  int i=0,ii;
  662.  while (i++<i_warte)
  663.  {
  664.   ii=0;
  665.   while (ii++<i_warte)
  666.    ;
  667.  }
  668. }
  669. /*
  670. /////////////////////////////////////////////////////////////////////
  671. */
  672. void Do_Input(void)
  673. {
  674.  allow_int=0;
  675.  JOYSTICK=0;
  676.  if (key_flag)
  677.  {
  678.   Hoch=C_HOCH;
  679.   Runter=C_RUNTER;
  680.   Links=C_LINKS;
  681.   Rechts=C_RECHTS;
  682.   Achsengleich=C_ACHSENGLEICH;
  683.   key_flag=0;
  684.  }
  685.  else
  686.  {
  687.   Hoch=K_HOCH;
  688.   Runter=K_RUNTER;
  689.   Links=K_LINKS;
  690.   Rechts=K_RECHTS;
  691.   Achsengleich=K_ACHSENGLEICH;
  692.   key_flag=1;
  693.  }
  694.  set_color(0,0,0,63);
  695.  warte_d(2);
  696.  set_color(0,0,0,0);
  697. }
  698. /*
  699. /////////////////////////////////////////////////////////////////////
  700. */
  701. void K_Clear(void)
  702. {
  703.  get_key();
  704.  get_key();
  705.  get_key();
  706.  get_key();
  707.  get_key();
  708.  get_key();
  709.  get_key();
  710.  get_key();
  711.  get_key();
  712.  get_key();
  713.  get_key();
  714.  get_key();
  715.  get_key();
  716.  get_key();
  717.  get_key();
  718.  get_key();
  719.  get_key();
  720.  key=0;
  721. }
  722. /*
  723. /////////////////////////////////////////////////////////////////////
  724. */
  725. BYTE get_key(void)
  726. {
  727.  BYTE Taste;
  728.  if (!JOYSTICK)
  729.   Taste=get_kkey();
  730.  else
  731.  {
  732.   Taste=get_kkey();
  733.   GetJoyButton( &j1but[0], &j2but[0] );
  734.   if ((j1but[aktstick] | j2but[aktstick] ) == 1)
  735.    Taste= ' ';
  736.  }
  737.  if (demo)
  738.   Taste='q';
  739.  if (!key)
  740.  {
  741.   Sim_Taste++;
  742.   switch (Sim_Taste/2000)
  743.   {
  744.    case 1:
  745.    {
  746.     if (Key_status!=1)
  747.     {
  748.      Taste='q';
  749.      Key_status=1;
  750.     }
  751.     break;
  752.    }
  753.    case 2:
  754.    {
  755.     if (Key_status!=2)
  756.     {
  757.      Taste='i';
  758.      Key_status=2;
  759.     }
  760.     break;
  761.    }
  762.    case 3:
  763.    {
  764.     if (Key_status!=3)
  765.     {
  766.      Taste='q';
  767.      Key_status=3;
  768.     }
  769.     break;
  770.    }
  771.    case 4:
  772.    {
  773.     if (Key_status!=4)
  774.     {
  775.      Taste='d';
  776.      Key_status=4;
  777.      Sim_Taste=0;
  778.     }
  779.     break;
  780.    }
  781.   }
  782.  }
  783.  else
  784.  {
  785.   Sim_Taste=(Sim_Taste/1000)*1000;
  786.  }
  787.  return Taste;
  788. }
  789. /*
  790. /////////////////////////////////////////////////////////////////////
  791. */
  792.