/*                               menupick.c                             */

int calling;   /* Since I'll use the same gadgets in various requesters */
               /* I'll need this one to know which function has brought */
               /* up the requester...                                   */

int reqstatus = FALSE;

menupick(im)
   struct IntuiMessage *im;
   {
   extern struct Window *w;
   extern int enemy;

   extern struct Requester thankreq;
   extern struct Requester aboutreq;
   extern struct Requester exitreq;

   int result;
   USHORT code, menunumber, itemnumber;
   struct MenuItem *menuitem;

   code = im -> Code;

   while(code != MENUNULL)
      {
      menunumber = MENUNUM(code);
      switch(menunumber)
         {
         case PROGRAM:
            while ((w -> ReqCount) != 0)  /* Until a requester is active */
               {
               result = waitformess();    /* Wait... */
               Delay(30);
               }
            itemnumber = ITEMNUM(code);
            if (itemnumber == 0) /* Thanks choosen */
               {
               Request(&thankreq, w);
               result = PICKED_THANKS;
               }
            if (itemnumber == 1) /* About choosen */
               {
               Request(&aboutreq, w);
               result = PICKED_ABOUT;
               }
            if (itemnumber == 2) /* Exit choosen */
               {
               calling = 3;
               Request(&exitreq, w);
               result = PICKED_EXIT;
               }
            break;

         case GAME:
            itemnumber = ITEMNUM(code);
            if (itemnumber == 0) /* Start choosen */
               result = startgame();
            if (itemnumber == 1) /* Peek choosen */
               result = peekgame();
            if (itemnumber == 2) /* Quit choosen */
               result = quitgame();
            break;

         case LEVEL:
            itemnumber = ITEMNUM(code);
            if (itemnumber == 0) /* Easy choosen */
               result = easylevel();
            if (itemnumber == 1) /* Normal choosen */
               result = normallevel();
            if (itemnumber == 2) /* Hard choosen */
               result = hardlevel();
            break;

         case OPPONENT:
            itemnumber = ITEMNUM(code);
            if (itemnumber == 0) /* Amiga choosen */
               {
               enemy = TRUE;
               result = PICKED_AMIGA;
               }
            if (itemnumber == 1) /* Human choosen */
               {
               enemy = FALSE;
               result = PICKED_HUMAN;
               }
            break;

         default:
            result = DUMMY_VALUE;
            break;
         }
      menuitem = (struct MenuItem *)ItemAddress(&mygamemenu[0], code);
      code = menuitem -> NextSelect;
      }
   return(result);
   }



startgame()
   {
   extern struct RastPort *rp;
   extern UWORD mycardsposition[];
   extern int turn1, turn2;
   extern int score1, score2;
   extern int peek1, peek2;
   extern struct Window *w;
   extern int showtime;

   int i, k;
   ULONG seconds, micros;
   int result;

   while ((w -> ReqCount) != 0)  /* Until a requester is active */
      {
      result = waitformess();    /* Wait... */
      Delay(30);
      }

   SetRast(rp, 6);   /* Clear screen */

   for (i = 1, k = 1; i <= 16; i++)    /* Reset the deck */
      {
      mycardsposition[k++] = i;
      mycardsposition[k++] = i;
      }

   turn1 = 0;  /* Reset players' variables */
   turn2 = 0;
   score1 = 0;
   score2 = 0;
   peek1 = 0;
   peek2 = 0;

   OffMenu(w, 0x3f00);  /* Disable menu 0 (all) */
   OffMenu(w, 0x3f01);  /* Disable menu 1 (all) */
   OffMenu(w, 0x3f02);  /* Disable menu 2 (all) */
   OffMenu(w, 0x3f03);  /* Disable menu 3 (all) */

   displaydata();                         /* Display players' situation */
   CurrentTime(&seconds, &micros);        /* Get current time */
   srand(micros);                         /* Use micros as a new seed */
   shufflecards();                        /* Shuffle the card deck */
   displaycards(TRUE);                    /* Show them to the players */
   writestring(rp, START_STRING, COLOR3); /* Tell'em to watch'em... */
   Delay(50 * showtime);                  /* Until they can! */
   writestring(rp, START_STRING, FALSE);  /* Delete message */
   displaycards(FALSE);                   /* Now cover the cards */

   OnMenu(w, 0x3f00);   /* Re-enable menu 0 (all) */
   OnMenu(w, 0x3f01);   /* Re-enable menu 1 */
   OffMenu(w, 0x0001);  /* Except item 0! */
   OnMenu(w, 0x0021);   /* But enable item 1 */
   OnMenu(w, 0x0041);   /* And enable item 2 */

   return(PICKED_START);   /* Let the program now that we're in... */
   }



peekgame()
   {
   extern int movingplayer;
   extern int score1, score2;
   extern int peek1, peek2;
   extern struct RastPort *rp;
   extern int peektime;
   extern struct Requester peekreq;
   extern struct Window *w;

   int result;

   while ((w -> ReqCount) != 0)  /* Until a requester is active */
      {
      result = waitformess();    /* Wait... */
      Delay(30);
      }

   if ((movingplayer == 1 && score1 == 0) ||
      (movingplayer == 2 && score2 == 0))
      {
      writestring(rp, PICK_FIRST_STRING, FALSE);   /* Delete old message */
      writestring(rp, NO_PEEK_STRING, COLOR3);     /* Can't peek yet! */
      Delay(50 * peektime / 2);
      writestring(rp, NO_PEEK_STRING, FALSE);
      if (movingplayer == 1)
         writestring(rp, PICK_FIRST_STRING, COLOR1);
      else
         writestring(rp, PICK_FIRST_STRING, COLOR2);
      return(DUMMY_VALUE);
      }

   if ((movingplayer == 1 && peek1 == 3) ||
      (movingplayer == 2 && peek2 == 3))
      {
      writestring(rp, PICK_FIRST_STRING, FALSE);   /* Delete old message */
      writestring(rp, TOO_MUCH_STRING, COLOR3);    /* Peeked too much! */
      Delay(50 * peektime / 2);
      writestring(rp, TOO_MUCH_STRING, FALSE);
      if (movingplayer == 1)
         writestring(rp, PICK_FIRST_STRING, COLOR1);
      else
         writestring(rp, PICK_FIRST_STRING, COLOR2);
      return(DUMMY_VALUE);
      }

   calling = 1;
   Request(&peekreq, w);

   return(PICKED_PEEK);
   }



quitgame()
   {
   extern struct Requester quitreq;
   extern struct Window *w;

   int result;

   while ((w -> ReqCount) != 0)  /* Until a requester is active */
      {
      result = waitformess();    /* Wait... */
      Delay(30);
      }

   calling = 2;
   Request(&quitreq, w);

   return(PICKED_QUIT);
   }



easylevel()
   {
   extern int showtime, peektime;
   extern int shuffles, memory, percentage;

   showtime = 30;
   peektime = 12;
   shuffles = 40;
   memory = 2;
   percentage = 10;

   return(PICKED_EASY);
   }



normallevel()
   {
   extern int showtime, peektime;
   extern int shuffles, memory, percentage;

   showtime = 24;
   peektime = 9;
   shuffles = 50;
   memory = 4;
   percentage = 20;

   return(PICKED_NORMAL);
   }



hardlevel()
   {
   extern int showtime, peektime;
   extern int shuffles, memory, percentage;

   showtime = 18;
   peektime = 6;
   shuffles = 60;
   memory = 6;
   percentage = 30;

   return(PICKED_HARD);
   }