home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 241.lha / CardORama_v1.0 / Sources / menupick.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-05-04  |  7.0 KB  |  282 lines
  1. /*                               menupick.c                             */
  2.  
  3. int calling;   /* Since I'll use the same gadgets in various requesters */
  4.                /* I'll need this one to know which function has brought */
  5.                /* up the requester...                                   */
  6.  
  7. int reqstatus = FALSE;
  8.  
  9. menupick(im)
  10.    struct IntuiMessage *im;
  11.    {
  12.    extern struct Window *w;
  13.    extern int enemy;
  14.  
  15.    extern struct Requester thankreq;
  16.    extern struct Requester aboutreq;
  17.    extern struct Requester exitreq;
  18.  
  19.    int result;
  20.    USHORT code, menunumber, itemnumber;
  21.    struct MenuItem *menuitem;
  22.  
  23.    code = im -> Code;
  24.  
  25.    while(code != MENUNULL)
  26.       {
  27.       menunumber = MENUNUM(code);
  28.       switch(menunumber)
  29.          {
  30.          case PROGRAM:
  31.             while ((w -> ReqCount) != 0)  /* Until a requester is active */
  32.                {
  33.                result = waitformess();    /* Wait... */
  34.                Delay(30);
  35.                }
  36.             itemnumber = ITEMNUM(code);
  37.             if (itemnumber == 0) /* Thanks choosen */
  38.                {
  39.                Request(&thankreq, w);
  40.                result = PICKED_THANKS;
  41.                }
  42.             if (itemnumber == 1) /* About choosen */
  43.                {
  44.                Request(&aboutreq, w);
  45.                result = PICKED_ABOUT;
  46.                }
  47.             if (itemnumber == 2) /* Exit choosen */
  48.                {
  49.                calling = 3;
  50.                Request(&exitreq, w);
  51.                result = PICKED_EXIT;
  52.                }
  53.             break;
  54.  
  55.          case GAME:
  56.             itemnumber = ITEMNUM(code);
  57.             if (itemnumber == 0) /* Start choosen */
  58.                result = startgame();
  59.             if (itemnumber == 1) /* Peek choosen */
  60.                result = peekgame();
  61.             if (itemnumber == 2) /* Quit choosen */
  62.                result = quitgame();
  63.             break;
  64.  
  65.          case LEVEL:
  66.             itemnumber = ITEMNUM(code);
  67.             if (itemnumber == 0) /* Easy choosen */
  68.                result = easylevel();
  69.             if (itemnumber == 1) /* Normal choosen */
  70.                result = normallevel();
  71.             if (itemnumber == 2) /* Hard choosen */
  72.                result = hardlevel();
  73.             break;
  74.  
  75.          case OPPONENT:
  76.             itemnumber = ITEMNUM(code);
  77.             if (itemnumber == 0) /* Amiga choosen */
  78.                {
  79.                enemy = TRUE;
  80.                result = PICKED_AMIGA;
  81.                }
  82.             if (itemnumber == 1) /* Human choosen */
  83.                {
  84.                enemy = FALSE;
  85.                result = PICKED_HUMAN;
  86.                }
  87.             break;
  88.  
  89.          default:
  90.             result = DUMMY_VALUE;
  91.             break;
  92.          }
  93.       menuitem = (struct MenuItem *)ItemAddress(&mygamemenu[0], code);
  94.       code = menuitem -> NextSelect;
  95.       }
  96.    return(result);
  97.    }
  98.  
  99.  
  100.  
  101. startgame()
  102.    {
  103.    extern struct RastPort *rp;
  104.    extern UWORD mycardsposition[];
  105.    extern int turn1, turn2;
  106.    extern int score1, score2;
  107.    extern int peek1, peek2;
  108.    extern struct Window *w;
  109.    extern int showtime;
  110.  
  111.    int i, k;
  112.    ULONG seconds, micros;
  113.    int result;
  114.  
  115.    while ((w -> ReqCount) != 0)  /* Until a requester is active */
  116.       {
  117.       result = waitformess();    /* Wait... */
  118.       Delay(30);
  119.       }
  120.  
  121.    SetRast(rp, 6);   /* Clear screen */
  122.  
  123.    for (i = 1, k = 1; i <= 16; i++)    /* Reset the deck */
  124.       {
  125.       mycardsposition[k++] = i;
  126.       mycardsposition[k++] = i;
  127.       }
  128.  
  129.    turn1 = 0;  /* Reset players' variables */
  130.    turn2 = 0;
  131.    score1 = 0;
  132.    score2 = 0;
  133.    peek1 = 0;
  134.    peek2 = 0;
  135.  
  136.    OffMenu(w, 0x3f00);  /* Disable menu 0 (all) */
  137.    OffMenu(w, 0x3f01);  /* Disable menu 1 (all) */
  138.    OffMenu(w, 0x3f02);  /* Disable menu 2 (all) */
  139.    OffMenu(w, 0x3f03);  /* Disable menu 3 (all) */
  140.  
  141.    displaydata();                         /* Display players' situation */
  142.    CurrentTime(&seconds, µs);        /* Get current time */
  143.    srand(micros);                         /* Use micros as a new seed */
  144.    shufflecards();                        /* Shuffle the card deck */
  145.    displaycards(TRUE);                    /* Show them to the players */
  146.    writestring(rp, START_STRING, COLOR3); /* Tell'em to watch'em... */
  147.    Delay(50 * showtime);                  /* Until they can! */
  148.    writestring(rp, START_STRING, FALSE);  /* Delete message */
  149.    displaycards(FALSE);                   /* Now cover the cards */
  150.  
  151.    OnMenu(w, 0x3f00);   /* Re-enable menu 0 (all) */
  152.    OnMenu(w, 0x3f01);   /* Re-enable menu 1 */
  153.    OffMenu(w, 0x0001);  /* Except item 0! */
  154.    OnMenu(w, 0x0021);   /* But enable item 1 */
  155.    OnMenu(w, 0x0041);   /* And enable item 2 */
  156.  
  157.    return(PICKED_START);   /* Let the program now that we're in... */
  158.    }
  159.  
  160.  
  161.  
  162. peekgame()
  163.    {
  164.    extern int movingplayer;
  165.    extern int score1, score2;
  166.    extern int peek1, peek2;
  167.    extern struct RastPort *rp;
  168.    extern int peektime;
  169.    extern struct Requester peekreq;
  170.    extern struct Window *w;
  171.  
  172.    int result;
  173.  
  174.    while ((w -> ReqCount) != 0)  /* Until a requester is active */
  175.       {
  176.       result = waitformess();    /* Wait... */
  177.       Delay(30);
  178.       }
  179.  
  180.    if ((movingplayer == 1 && score1 == 0) ||
  181.       (movingplayer == 2 && score2 == 0))
  182.       {
  183.       writestring(rp, PICK_FIRST_STRING, FALSE);   /* Delete old message */
  184.       writestring(rp, NO_PEEK_STRING, COLOR3);     /* Can't peek yet! */
  185.       Delay(50 * peektime / 2);
  186.       writestring(rp, NO_PEEK_STRING, FALSE);
  187.       if (movingplayer == 1)
  188.          writestring(rp, PICK_FIRST_STRING, COLOR1);
  189.       else
  190.          writestring(rp, PICK_FIRST_STRING, COLOR2);
  191.       return(DUMMY_VALUE);
  192.       }
  193.  
  194.    if ((movingplayer == 1 && peek1 == 3) ||
  195.       (movingplayer == 2 && peek2 == 3))
  196.       {
  197.       writestring(rp, PICK_FIRST_STRING, FALSE);   /* Delete old message */
  198.       writestring(rp, TOO_MUCH_STRING, COLOR3);    /* Peeked too much! */
  199.       Delay(50 * peektime / 2);
  200.       writestring(rp, TOO_MUCH_STRING, FALSE);
  201.       if (movingplayer == 1)
  202.          writestring(rp, PICK_FIRST_STRING, COLOR1);
  203.       else
  204.          writestring(rp, PICK_FIRST_STRING, COLOR2);
  205.       return(DUMMY_VALUE);
  206.       }
  207.  
  208.    calling = 1;
  209.    Request(&peekreq, w);
  210.  
  211.    return(PICKED_PEEK);
  212.    }
  213.  
  214.  
  215.  
  216. quitgame()
  217.    {
  218.    extern struct Requester quitreq;
  219.    extern struct Window *w;
  220.  
  221.    int result;
  222.  
  223.    while ((w -> ReqCount) != 0)  /* Until a requester is active */
  224.       {
  225.       result = waitformess();    /* Wait... */
  226.       Delay(30);
  227.       }
  228.  
  229.    calling = 2;
  230.    Request(&quitreq, w);
  231.  
  232.    return(PICKED_QUIT);
  233.    }
  234.  
  235.  
  236.  
  237. easylevel()
  238.    {
  239.    extern int showtime, peektime;
  240.    extern int shuffles, memory, percentage;
  241.  
  242.    showtime = 30;
  243.    peektime = 12;
  244.    shuffles = 40;
  245.    memory = 2;
  246.    percentage = 10;
  247.  
  248.    return(PICKED_EASY);
  249.    }
  250.  
  251.  
  252.  
  253. normallevel()
  254.    {
  255.    extern int showtime, peektime;
  256.    extern int shuffles, memory, percentage;
  257.  
  258.    showtime = 24;
  259.    peektime = 9;
  260.    shuffles = 50;
  261.    memory = 4;
  262.    percentage = 20;
  263.  
  264.    return(PICKED_NORMAL);
  265.    }
  266.  
  267.  
  268.  
  269. hardlevel()
  270.    {
  271.    extern int showtime, peektime;
  272.    extern int shuffles, memory, percentage;
  273.  
  274.    showtime = 18;
  275.    peektime = 6;
  276.    shuffles = 60;
  277.    memory = 6;
  278.    percentage = 30;
  279.  
  280.    return(PICKED_HARD);
  281.    }
  282.