home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 605b.lha / Spades_v2.10 / Source / Input.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-06  |  11.9 KB  |  423 lines
  1. /*
  2.    FILE: Input.c
  3.    PURPOSE: Routines for getting user input.
  4.    AUTHOR: Gregory M. Stelmack
  5. */
  6.  
  7. #ifndef GLOBALS_H
  8. #include "Globals.h"
  9. #endif
  10.  
  11. extern struct Menu *SpadesMenu;
  12.  
  13. struct EasyStruct    AboutES =
  14. {
  15.    sizeof(struct EasyStruct),
  16.    0,
  17.    "About Spades 2.10",
  18.    "Spades 2.10 by:\nGregory M. Stelmack\n8723 Del Rey Ct. #11-A\nTampa, FL 33617",
  19.    "OK"
  20. };
  21.  
  22. /**********************************************************
  23. * Function: ReadMouse                                     *
  24. * Parameters: none                                        *
  25. * Return Values: none                                     *
  26. * Purpose: Wait for mouse input, and update the mouse     *
  27. *          variables accordingly.                         *
  28. **********************************************************/
  29. void ReadMouse()
  30. {
  31.    ULONG class,menunum,itemnum,subnum;
  32.    USHORT code,selection,flags;
  33.    BOOL gotmouse=FALSE;
  34.    BOOL QuitFlag=FALSE,NewFlag=FALSE;
  35.    struct IntuiMessage  *Message;
  36.    
  37.    /* Loop until we have a mouse message */
  38.   
  39.    while(!gotmouse)
  40.    {
  41.       /* Wait for Intuition Message */
  42.       
  43.       Wait(1L<<Wdw->UserPort->mp_SigBit);    
  44.         while(Message=(struct IntuiMessage *) GetMsg(Wdw->UserPort))
  45.         {
  46.          /* Interpret Message */
  47.     
  48.          class = Message->Class;
  49.          code = Message->Code;
  50.          ReplyMsg((struct Message *)Message);
  51.  
  52.          switch(class)
  53.          {
  54.             case MENUPICK:
  55.                selection = code;
  56.                while (selection != MENUNULL)
  57.                {
  58.                   menunum = MENUNUM(selection);
  59.                   itemnum = ITEMNUM(selection);
  60.                   subnum  = SUBNUM(selection);
  61.                   flags = ((struct MenuItem *)ItemAddress(SpadesMenu,
  62.                            (LONG)selection))->Flags;
  63.                   switch(menunum)
  64.                   {
  65.                      case 0:     /* Project menu */
  66.                         switch(itemnum)
  67.                         {
  68.                            case 0:     /* New Game */
  69.                               NewFlag = TRUE;
  70.                               break;
  71.                            case 1:     /* Save Hand */
  72.                               if (flags&CHECKED)
  73.                                     SaveHand = TRUE;
  74.                               else
  75.                                     SaveHand = FALSE;
  76.                               break;
  77.                            case 2:     /* Print Hand */
  78.                               break;
  79.                            case 3:     /* About */
  80.                               (void)EasyRequest(Wdw,&AboutES,NULL,NULL);
  81.                               break;
  82.                            case 4:     /* Quit */
  83.                               QuitFlag = TRUE;
  84.                               break;
  85.                            default:
  86.                               break;
  87.                         }
  88.                         break;
  89.                      case 1:     /* Game menu */
  90.                         switch(itemnum)
  91.                         {
  92.                            case 0:     /* Bags */
  93.                               if (flags&CHECKED)
  94.                                     BagsRule = TRUE;
  95.                               else
  96.                                     BagsRule = FALSE;
  97.                               break;
  98.                            case 1:     /* Nil */
  99.                               if (flags&CHECKED)
  100.                                     NilRule = TRUE;
  101.                               else
  102.                                     NilRule = FALSE;
  103.                               break;
  104.                            case 2:     /* Suggest */
  105.                               Button = MRIGHT;
  106.                               gotmouse = TRUE;
  107.                               break;
  108.                            default:
  109.                               break;
  110.                         }
  111.                         break;
  112.                      default:
  113.                         break;
  114.                   }
  115.                   selection = ((struct MenuItem *)
  116.                               ItemAddress(SpadesMenu,(LONG)selection))
  117.                               ->NextSelect;
  118.                }
  119.                break;
  120.                
  121.                 case MOUSEBUTTONS:
  122.                switch(code)
  123.                {
  124.                   case SELECTUP:
  125.                      Button=MLEFT;
  126.                      gotmouse=TRUE;
  127.                      Mx=((SHORT) Message->MouseX);
  128.                      My=((SHORT) Message->MouseY);
  129.                      break;
  130.                   default:
  131.                      break;
  132.                }
  133.     
  134.             default:
  135.                break;
  136.                 
  137.          }  /* end switch */
  138.       }  /* end while message to process */
  139.         
  140.       if (QuitFlag == TRUE)
  141.       {
  142.          WrapUp();
  143.       }
  144.       else if (NewFlag == TRUE)
  145.       {
  146.          Spades();
  147.       }
  148.    }  /* end while not gotmouse */
  149. } 
  150.  
  151. /**********************************************************
  152. * Function: FinishRoutine                                 *
  153. * Parameters: none                                        *
  154. * Return Values: none                                     *
  155. * Purpose: Display final score, ask to play again.        *
  156. **********************************************************/
  157. void FinishRoutine()
  158. {
  159.    BOOL haveinput;
  160.  
  161.    SetRast(RP,BLUP);
  162.    SetAPen(RP,WHTP);
  163.    SetBPen(RP,BLUP);
  164.  
  165.    Move(RP,112,56);
  166.    Text(RP,"FINAL SCORE:",12);
  167.    Move(RP,80,72);
  168.    Text(RP,"YOU:",4);
  169.    Move(RP,184,72);
  170.    Text(RP,"ME:",3);
  171.    SetAPen(RP,YELP);
  172.    itoa(PlayerScore,String);
  173.    Move(RP,116,72);
  174.    Text(RP,String,strlen(String));
  175.    itoa(CompScore,String);
  176.    Move(RP,212,72);
  177.    Text(RP,String,strlen(String));
  178.    
  179.    Move(RP,112,96);
  180.    Text(RP,"PLAY AGAIN ?",12);
  181.    SetAPen(RP,BLKP);
  182.    SetBPen(RP,WHTP);
  183.    Move(RP,112,112);
  184.    Text(RP,"YES",3);
  185.    Move(RP,188,112);
  186.    Text(RP,"NO",2);
  187.    
  188.    haveinput=FALSE;
  189.    while (!haveinput)
  190.    {
  191.       ReadMouse();
  192.       if ((Mx>111)&&(Mx<136)&&(My>105)&&(My<114))
  193.       {
  194.          haveinput=TRUE;
  195.          AllDone=FALSE;
  196.       }
  197.       if ((Mx>187)&&(Mx<204)&&(My>105)&&(My<114))
  198.       {
  199.          haveinput=TRUE;
  200.          AllDone=TRUE;
  201.       }
  202.    }
  203. }
  204.  
  205. /**********************************************************
  206. * Function: GetPlayerCard                                 *
  207. * Parameters: none                                        *
  208. * Return Values: card picked to play                      *
  209. * Purpose: Allow player to pick card to play.             *
  210. **********************************************************/
  211. int GetPlayerCard()
  212. {
  213.    int i,x,card;
  214.   
  215.    /* Let player know that it's his/her turn */
  216.   
  217.    SetBPen(RP,BLUP);
  218.    SetAPen(RP,YELP);
  219.    Move(RP,200,150);
  220.    Text(RP,"PLAY A CARD",11);
  221.   
  222.    /* Loop until we get a good card */
  223.   
  224.    FOREVER
  225.    {
  226.       ReadMouse();                        /* Wait for mouse click */ 
  227.       if (Button==MRIGHT) SuggestCard();  /* Player wants a suggestion */
  228.       if (Button==MLEFT)                  /* Did player pick a card ? */
  229.       {
  230.          for (i=12 ; i>=0 ; i--)          /* Check from right to left */
  231.          {
  232.             x=(i*10)+21;                  /* Set left corner for card */
  233.         
  234.             /* See if clicked inside this card and if card is
  235.                still unplayed */
  236.         
  237.             if ((My<187)&&(My>144)&&(Mx<(x+42))&&(Mx>=x)&&(Hand[0][i]))
  238.             {
  239.                if (ValidCard(i))  /* Was this a playable card ? */
  240.                {
  241.                   card=Hand[0][i]-1;
  242.                   Hand[0][i]=0;   /* Mark card as played */
  243.                   
  244.                   /* Check to see if Spades were broken */
  245.                   
  246.                   if ((card/13)==SPADES) SpadePlayed=TRUE;
  247.             
  248.                   /* Erase suggestion '*' */
  249.             
  250.                   SetAPen(RP,BLUP);
  251.                   SetOPen(RP,BLUP);
  252.                   RectFill(RP,21,136,170,144);
  253.             
  254.                   DrawCard(CardX[0],CardY[0],card); /* Draw played card */
  255.             
  256.                   /* Erase prompt message */
  257.             
  258.                   SetBPen(RP,BLUP);
  259.                   Move(RP,200,150);
  260.                   Text(RP,"           ",11);
  261.             
  262.                   /* Send back played card */
  263.             
  264.                   return(card);
  265.                }
  266.                else     /* chosen card was not valid, need a new card */
  267.                      i=-1;
  268.             }
  269.          }
  270.       }
  271.    }
  272. }
  273.  
  274. /**********************************************************
  275. * Function: ValidCard                                     *
  276. * Parameters: card -- card in player's hand to check      *
  277. * Return Values: was card valid or not?                   *
  278. * Purpose: To determine if the card chosen by the player  *
  279. *   was valid or not.                                     *
  280. **********************************************************/
  281. BOOL ValidCard(card)
  282. int card;
  283. {
  284.    int i,suit,leadsuit;
  285.   
  286.    SuitNumber[DIAMONDS]=0;
  287.    SuitNumber[CLUBS]   =0;
  288.    SuitNumber[HEARTS]  =0;
  289.    SuitNumber[SPADES]  =0;
  290.   
  291.    /* Count number of cards player has in each suit */
  292.   
  293.    for (i=0 ; i<13 ; i++)
  294.    {
  295.       if (Hand[0][i]) SuitNumber[(Hand[0][i]-1)/13]++;
  296.    }
  297.   
  298.    suit=(Hand[0][card]-1)/13; /* Find suit of played card */
  299.   
  300.    if (!TrickLead)            /* Player is leading */
  301.    {
  302.       /* If he didn't lead a spade, it was a good play */
  303.       if (suit!=SPADES) return(TRUE);
  304.     
  305.       /* If he only has spades, he has no choice */ 
  306.       if ((!SuitNumber[0])&&(!SuitNumber[1])&&(!SuitNumber[2]))
  307.             return(TRUE);
  308.     
  309.       /* If spades have been played, he can lead anything */
  310.       if (SpadePlayed) return(TRUE);
  311.     
  312.       /* Must have lead a spade when it was illegal to */
  313.       return(FALSE);
  314.    }
  315.   
  316.    /* Player doesn't lead */
  317.   
  318.    leadsuit=Card[TrickLead]/13;       /* Find suit that was lead */
  319.   
  320.    /* If he played the suit that was lead, he is OK */
  321.    if (suit==leadsuit) return(TRUE);
  322.   
  323.    /* If he didn't have any, he's OK */
  324.    if (!SuitNumber[leadsuit]) return(TRUE);
  325.   
  326.    /* Must have had some but didn't play them */
  327.    return(FALSE);
  328. }
  329.  
  330. /**********************************************************
  331. * Function: GetPlayerBid                                  *
  332. * Parameters: none                                        *
  333. * Return Values: bid -- number of tricks bid              *
  334. * Purpose: Get the human player's bid. Could use gadgets, *
  335. *          but this is easier to program.                 *
  336. **********************************************************/
  337. int GetPlayerBid()
  338. {
  339.    int bid=1,length;
  340.    BOOL havebid=FALSE;
  341.  
  342.    ShowHand();
  343.  
  344.    /* Draw input box */
  345.   
  346.    SetAPen(RP,YELP);
  347.    SetBPen(RP,BLKP);
  348.    Move(RP,258,142);
  349.    Text(RP,"BID",3);
  350.    Move(RP,250,150);
  351.    Text(RP,"  +  ",5);
  352.    Move(RP,250,158);
  353.    Text(RP,"   OK",5);
  354.    Move(RP,250,166);
  355.    Text(RP,"  -  ",5);
  356.   
  357.    /* Loop until OK is clicked */
  358.   
  359.    while(!havebid)
  360.    { 
  361.       /* Draw Current Bid */
  362.     
  363.       SetAPen(RP,GRNP);
  364.       SetBPen(RP,BLKP);
  365.       Move(RP,250,158);
  366.       Text(RP,"  ",2);
  367.       itoa(bid,String);
  368.       length=strlen(String);
  369.       Move(RP,(258-(4*length)),158);
  370.       Text(RP,String,length);
  371.     
  372.       /* Wait for Mouse input */
  373.     
  374.       ReadMouse();
  375.       if (Button==MLEFT)   /* Left Button Pressed */
  376.       {
  377.          /* plus sign clicked */
  378.          if ((Mx>265)&&(Mx<274)&&(My>143)&&(My<152)) bid++;
  379.             
  380.          /* OK clicked */
  381.          if ((Mx>273)&&(Mx<290)&&(My>151)&&(My<160)) havebid=TRUE;
  382.          
  383.          /* minus sign clicked */
  384.          if ((Mx>265)&&(Mx<274)&&(My>159)&&(My<168)) bid--;
  385.       }
  386.       if (Button==MRIGHT)  /* Right Button Pressed */
  387.       {
  388.          bid=CalcBid(0);   /* Suggest a Bid */
  389.       }
  390.     
  391.       /* Make sure bid is valid */
  392.     
  393.       if (NilRule)
  394.       {
  395.          if (bid<0) bid=0;
  396.          if (bid>13) bid=13;
  397.       }
  398.       else
  399.       {
  400.          if (bid<1) bid=1;
  401.          if (bid>12) bid=12;
  402.       }
  403.    }
  404.   
  405.    /* Erase Input Box */
  406.   
  407.    SetAPen(RP,BLUP);
  408.    SetOPen(RP,BLUP);
  409.    RectFill(RP,250,135,291,168);
  410.   
  411.    /* Display the bid */
  412.   
  413.    SetAPen(RP,YELP);
  414.    SetBPen(RP,BLUP);
  415.    itoa(bid,String);
  416.    Move(RP,MsgX[0],MsgY[0]);
  417.    Text(RP,String,strlen(String));
  418.   
  419.    /* Send the bid back */
  420.   
  421.    return(bid);
  422. }
  423.