home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 18 / amigaformatcd18.iso / -readerstuff- / steve_boxall / hangman / hangmanmain.c < prev    next >
C/C++ Source or Header  |  1997-07-18  |  12KB  |  756 lines
  1. #include "HangmanGui.c"
  2. #include "HangmanMain.h"
  3.  
  4. int wbmain()
  5. {
  6.     main();
  7. return 0;
  8. }
  9.  
  10. void DummyProjectIDCMP(struct Window *wnd );
  11.  
  12. int main()
  13. {
  14.     Guess_Filename_g="hangman.dat\0";
  15.     Guess_User_g="\0";
  16.     Guess_Word_g="\0";
  17.     Guessed_User_g=calloc(80,sizeof(char));
  18.     Game_On_g=0;
  19.  
  20.     running=0;
  21.     SetupScreen();
  22.     OpenProject0Window();
  23.  
  24.     ReadWordFile();
  25.     NewGameClicked();
  26.  
  27.     while(running!=100)
  28.     {
  29.         running=HandleProject0IDCMP();
  30.     }
  31.  
  32.     CloseProject0Window();
  33.     CloseDownScreen();
  34.  
  35. return 0;
  36. }
  37.  
  38. int GuessItClicked( void )
  39. {
  40.     int fnd_flag=0;
  41.     int i =0;
  42.     int len =0;
  43.     char *check;
  44.  
  45.     OffGadget(Project0Gadgets[0],Project0Wnd,NULL);
  46.  
  47.     check=DupString(((struct StringInfo *) (Project0Gadgets[0]->SpecialInfo))->Buffer);
  48.  
  49.     rtrimstr(check);
  50.     ltrimstr(check);
  51.  
  52.     len=strlen(check);
  53.  
  54.     for(i=0;i<len;i++)
  55.     {
  56.         check[i]=ToUpper(check[i]);
  57.     }
  58.  
  59.     if(len >1)
  60.     {
  61.         if(strcmp(check,Guess_Word_g)==0)
  62.         {
  63.             fnd_flag=2;
  64.         }
  65.     }
  66.     else
  67.     {
  68.         for(i=0;i<strlen(Guess_Word_g);i++)
  69.         {
  70.             if(Guess_Word_g[i]==check[0])
  71.             {
  72.                 Guess_Mask_g[i]=check[0];
  73.                 fnd_flag=1;
  74.             }
  75.         }
  76.  
  77.         Gadget2Text.IText=Guess_Mask_g;
  78.         updateTxtGad(Project0Wnd,Project0Gadgets[2],&Gadget2Text);
  79.  
  80.         if(strcmp(Guess_Mask_g,Guess_Word_g)==0)
  81.         {
  82.             fnd_flag=2;
  83.         }
  84.     }
  85.  
  86.     if(fnd_flag==2)
  87.     {
  88.         Guess_User_g="\0";
  89.         Guess_Number_g=0;
  90.         Game_On_g=0;
  91.         ShowWinnerBox();
  92.         NewGameClicked();
  93.     }    
  94.  
  95.     if(fnd_flag==0)
  96.     {
  97.         if(len ==1)
  98.         {
  99.             Guessed_User_g=strcat(Guessed_User_g," \0");            
  100.             Guessed_User_g=strcat(Guessed_User_g,check);
  101.         }
  102.  
  103.         Guess_User_g="\0";
  104.         Guess_Number_g++;
  105.  
  106.         DrawHangman(Project0Wnd);
  107.         
  108.         if(Guess_Number_g >9) 
  109.         {
  110.             Guess_User_g="\0";
  111.             Guess_Number_g=0;
  112.             Game_On_g=0;
  113.             ShowLoserBox();
  114.             NewGameClicked();
  115.         }
  116.     }
  117.     
  118.     Gadget3Text.IText=Guessed_User_g;
  119.     updateTxtGad(Project0Wnd,Project0Gadgets[4],&Gadget3Text);
  120.  
  121.     updateStrGad(Project0Wnd,Project0Gadgets[0],Guess_User_g);
  122.  
  123.     OnGadget(Project0Gadgets[0],Project0Wnd,NULL);
  124. }
  125.  
  126. int NewGameClicked( void )
  127. {
  128.     int i=0;
  129.     int Item_No=0;
  130.  
  131.     clock_t clk=clock();
  132.     if(Game_On_g==1)
  133.     {
  134.         i=HangmanRequestG(Project0Wnd);
  135.     }
  136.     if(i==1 | Game_On_g==0)
  137.     {
  138.         OffGadget(Project0Gadgets[5],Project0Wnd,NULL);
  139.     
  140.         EraseRect(Project0Wnd->RPort,439,36,589,182);
  141.         EraseRect(Project0Wnd->RPort,160,45,400,90);        
  142.         EraseRect(Project0Wnd->RPort,28,145,400,180);        
  143.  
  144.         Guess_Number_g=0;
  145.  
  146.         srand(clk);
  147.  
  148.         Item_No=rand();
  149.         Item_No=Item_No % Item_Count_g;
  150.  
  151.         strcpy(Guessed_User_g,"Letters Guessed Wrong :\0");    
  152.         Guess_Word_g=Word_List[Item_No];
  153.         Guess_Mask_g=DupString(Guess_Word_g);
  154.  
  155.         for(i=0;i<strlen(Guess_Mask_g);i++)
  156.         {
  157.             Guess_Mask_g[i]='*';
  158.         }
  159.  
  160.         Guess_User_g="\0";
  161.     
  162.         Gadget2Text.IText=Guess_Mask_g;
  163.         updateTxtGad(Project0Wnd,Project0Gadgets[2],&Gadget2Text);
  164.  
  165.         updateStrGad(Project0Wnd,Project0Gadgets[0],Guess_User_g);
  166.  
  167.         OnGadget(Project0Gadgets[5],Project0Wnd,NULL);
  168.         Game_On_g=1;
  169.     }
  170. }
  171.  
  172. int LoadWordsClicked( void )
  173. {
  174.     int i=0;
  175.     struct FileRequester *Hangman_File;
  176.     i=HangmanRequestG(Project0Wnd);
  177.     if(i==1)
  178.     {
  179.             if (Hangman_File = (struct FileRequester *) AllocAslRequestTags(ASL_FileRequest,
  180.                     ASL_Hail, (ULONG)"Hangman File Requester",
  181.              /*          ASL_Dir,  NULL,*/
  182.                        ASL_File, (ULONG)"hangman.dat",
  183.                     ASL_Pattern, (ULONG)"#?.dat",
  184.                        ASL_Window, Project0Wnd,
  185.                        TAG_DONE))
  186.                 {
  187.                     if (AslRequest(Hangman_File, 0L))
  188.                         {
  189.                             if (Hangman_File->rf_NumArgs==0)
  190.                     {
  191.                         Guess_Filename_g=calloc(101,sizeof(char));
  192.                                     strcpy(Guess_Filename_g,Hangman_File->fr_Drawer);
  193.                         if(AddPart(Guess_Filename_g,Hangman_File->fr_File,100)==0)
  194.                         {
  195.                             strcpy(Guess_Filename_g,"Hangman.Dat\0");
  196.                         }
  197.                                 }
  198.                 }
  199.                         FreeAslRequest(Hangman_File);
  200.             }
  201.         for(i=0;i<Item_Count_g;i++)
  202.         {
  203.             free(Word_List[i]);
  204.         }
  205.  
  206.         ReadWordFile();
  207.         Game_On_g=0;    
  208.         NewGameClicked();
  209.     }                 
  210. }
  211.  
  212. /*
  213.     Process Exit Game Button
  214. */
  215.  
  216. int ExitGameClicked( void )
  217. {
  218.     running =HangmanRequest(Project0Wnd);
  219. }
  220.  
  221. /*
  222.     Update string gadget to show new entry
  223. */
  224.  
  225. void updateStrGad(struct Window *win, struct Gadget *gad, UBYTE *newstr)
  226. {
  227.  
  228. /*
  229.     remove gadget from display before changing contents
  230. */
  231.  
  232.     RemoveGList(win,gad,1);
  233.  
  234. /*
  235.     Change contents and reset current cursor positions in string
  236. */
  237.     
  238.     strcpy(((struct StringInfo *) (gad->SpecialInfo))->Buffer,newstr);
  239.  
  240.     ((struct StringInfo *)(gad->SpecialInfo))->BufferPos =0;
  241.     ((struct StringInfo *)(gad->SpecialInfo))->DispPos =0;
  242.  
  243. /*
  244.     Add Gadget back to display and refresh
  245. */
  246.  
  247.     AddGList(win,gad,~0,1,NULL);
  248.     RefreshGList(gad,win,NULL,1);
  249.  
  250. /*
  251.     Finally re-activate string gadget
  252. */
  253.  
  254.     ActivateGadget(gad,win,NULL);
  255.  
  256. }
  257.  
  258. /*
  259.     Draw the Hangman figure piece by piece
  260. */
  261.  
  262. void DrawHangman(struct Window *win)
  263. {
  264.     int pen=GetAPen(win->RPort);
  265.     DisplayBeep(Scr);
  266.  
  267.     switch(Guess_Number_g)
  268.     {
  269.         case 1:
  270.             SetAPen(win->RPort,1);
  271.             SetOPen(win->RPort,1);
  272.             Move(win->RPort,440,180);
  273.             RectFill(win->RPort,440,174,588,180);
  274.             SetAPen(win->RPort,pen);
  275.             break;
  276.         case 2:
  277.             SetAPen(win->RPort,1);
  278.             SetOPen(win->RPort,1);
  279.             Move(win->RPort,576,179);
  280.             RectFill(win->RPort,576,57,588,179);
  281.             SetAPen(win->RPort,pen);
  282.             break;
  283.         case 3:
  284.             SetAPen(win->RPort,1);
  285.             SetOPen(win->RPort,1);
  286.             Move(win->RPort,490,63);
  287.             RectFill(win->RPort,490,57,588,63);
  288.             SetAPen(win->RPort,pen);
  289.             break;
  290.         case 4:
  291.             SetAPen(win->RPort,7);
  292.             SetOPen(win->RPort,1);
  293.             Move(win->RPort,490,85);
  294.             RectFill(win->RPort,490,64,502,85);
  295.             SetAPen(win->RPort,pen);
  296.             break;
  297.         case 5:
  298.             SetAPen(win->RPort,1);
  299.             SetOPen(win->RPort,1);
  300.             DrawEllipse(win->RPort,496,95,10,10);
  301.             SetAPen(win->RPort,8);
  302.             Flood(win->RPort,0,499,98);
  303.             SetAPen(win->RPort,pen);
  304.             break;
  305.         case 6:
  306.             SetAPen(win->RPort,3);
  307.             SetOPen(win->RPort,1);
  308.             Move(win->RPort,485,135);
  309.             RectFill(win->RPort,485,106,507,135);
  310.             SetAPen(win->RPort,pen);
  311.             break;
  312.         case 7:
  313.             SetAPen(win->RPort,3);
  314.             SetOPen(win->RPort,1);
  315.             Move(win->RPort,440,110);
  316.             RectFill(win->RPort,440,106,484,110);
  317.             SetAPen(win->RPort,pen);
  318.             break;
  319.         case 8:
  320.             SetAPen(win->RPort,3);
  321.             SetOPen(win->RPort,1);
  322.             Move(win->RPort,508,110);
  323.             RectFill(win->RPort,508,106,552,110);
  324.             SetAPen(win->RPort,pen);
  325.             break;
  326.         case 9:
  327.             SetAPen(win->RPort,3);
  328.             SetOPen(win->RPort,1);
  329.             Move(win->RPort,485,160);
  330.             RectFill(win->RPort,485,136,492,160);
  331.             SetAPen(win->RPort,pen);
  332.             break;
  333.         case 10:
  334.             SetAPen(win->RPort,3);
  335.             SetOPen(win->RPort,1);
  336.             Move(win->RPort,500,160);
  337.             RectFill(win->RPort,500,136,507,160);
  338.             SetAPen(win->RPort,pen);
  339.             break;
  340.         default:
  341.             break;
  342.  
  343.     }
  344. }
  345.  
  346. /*
  347.     Read the vocabulary file selected by user
  348. */
  349.  
  350. void ReadWordFile(void)
  351. {
  352.     char *field_p;
  353.     char *line =calloc(81,sizeof(char));
  354.  
  355.     int i=0;
  356.     FILE *input=fopen(Guess_Filename_g,"r");
  357.     
  358.     if(input >0)
  359.     {
  360.  
  361.         while(!feof(input))
  362.         {
  363.             ReadLine(line,80,input);
  364.  
  365.             field_p=DupString(line);
  366.  
  367.             ltrimstr(field_p);
  368.             rtrimstr(field_p);
  369.  
  370.             if(check_field(field_p)==0 && i<100)
  371.             {
  372.                 Word_List[i]=field_p;
  373.                 i++;
  374.             }
  375.             else
  376.             {
  377.                 if(field_p >0)
  378.                 {
  379.                 /*    free(field_p); */
  380.                 }
  381.             }
  382.         }
  383.         fclose(input);
  384.     }
  385.     Item_Count_g=i;
  386. }
  387.  
  388. /*
  389.     Check the field read from file is valid
  390. */
  391.  
  392. int check_field(char *r_p)
  393. {
  394.     int checkit =1;
  395.  
  396.     if(r_p >0)
  397.     {
  398.         if(strlen(r_p)>1 && strlen(r_p)<26)
  399.         {
  400.             checkit =0;
  401.         }
  402.     }
  403. return checkit;
  404. }
  405.  
  406. /*
  407.     Read a line from the vocabulary file
  408. */
  409.  
  410. int ReadLine(char *s, int sdblim, FILE *input)
  411. {
  412.     int c,i;
  413.     for(i=0;i<sdblim-1 && (c=getc(input))!=EOF && c!='\n';i++)
  414.     {
  415.         s[i]=toupper(c);
  416.     }
  417.     s[i]='\0';
  418. return i;
  419. }
  420.  
  421. /*
  422.  
  423.     strip leading spaces from string
  424.  
  425. */
  426.  
  427. void ltrimstr(char from[])
  428. {
  429.     char *to=calloc(strlen(from),1);
  430.     int k=0;
  431.     int j =0;
  432.     while(from[j] ==' ')
  433.     {
  434.         j++;
  435.     }
  436.     if(j >0)
  437.     {
  438.         for(k=0;k<strlen(from)-1;k++)
  439.         {
  440.             to[k]=from[j];
  441.             to[k+1]='\0';
  442.             j++;
  443.         }
  444.         strcpy(from,to);
  445.         free(to);
  446.     }
  447. }
  448.  
  449. /*
  450.  
  451.     rtrimstr  - strip trailing spaces from string
  452.  
  453. */
  454.  
  455. void rtrimstr(char from[])
  456. {
  457.     char *to=calloc(strlen(from),1);
  458.     int j =strlen(from)-1;
  459.     if(from[j]==' ')
  460.     {
  461.         while(from[j] ==' ' && j >0)
  462.         {
  463.             j--;
  464.         }
  465.         strncpy(to,from,j+1);
  466.         strcpy(from,to);
  467.         free(to);
  468.     }
  469. }
  470.  
  471. /*
  472.     Make a copy of the string parsed
  473. */
  474.  
  475. char *DupString(char *from)
  476. {
  477.     char *to;
  478.  
  479.     if(from >0)
  480.     {
  481.         to=calloc(strlen(from)+1,sizeof(char));
  482.         strcpy(to,from);
  483.     }
  484. return to;
  485. }
  486.  
  487. /*
  488.     Update a Text gadget
  489. */
  490.  
  491. void updateTxtGad(struct Window *win, struct Gadget *gad, struct IntuiText *newstr)
  492. {
  493.  
  494. /*
  495.     remove gadget from display before changing contents
  496. */
  497.  
  498.     RemoveGList(win,gad,1);
  499.  
  500. /*
  501.     Change contents and reset current cursor positions in string
  502. */
  503.     
  504.     gad->GadgetText=newstr;
  505.  
  506. /*
  507.     Add Gadget back to display and refresh
  508. */
  509.  
  510.     AddGList(win,gad,~0,1,NULL);
  511.     RefreshGList(gad,win,NULL,1);
  512.  
  513. /*
  514.     Finally re-activate string gadget
  515. */
  516.  
  517.     ActivateGadget(gad,win,NULL);
  518.  
  519. }
  520.  
  521.  
  522. /*
  523.     return button clicked to continue
  524. */
  525.  
  526.  
  527. int WinnerOkClicked( void )
  528. {
  529.     return 100;
  530. }
  531.  
  532. /*
  533.     return button clicked to continue
  534. */
  535.  
  536. int LostOkClicked( void )
  537. {
  538.     return 100;
  539. }
  540.  
  541. /*
  542.     return button clicked to continue
  543. */
  544.  
  545. int AboutOkClicked( void )
  546. {
  547.     return 100;
  548. }
  549.  
  550. /*
  551.     Perform menu item new game
  552. */
  553.  
  554. int Project0GameItem0( void )
  555. {
  556.     NewGameClicked();
  557.     return 0;
  558. }
  559.  
  560. /*
  561.     Perform menu item load words
  562. */
  563.  
  564. int Project0GameItem1( void )
  565. {
  566.     LoadWordsClicked();
  567.     return 0;
  568. }
  569.  
  570. /*
  571.     Perform menu item about
  572. */
  573.  
  574. int Project0GameItem2( void )
  575. {
  576.     ShowAboutBox();
  577.     return 0;
  578. }
  579.  
  580. /*
  581.     Perform menu item Exit hangman
  582. */
  583.  
  584. int Project0GameItem3( void )
  585. {
  586.     running=HangmanRequest(Project0Wnd);
  587.     return running;
  588. }
  589.  
  590. /*
  591.     Show Hangman AboutBox
  592. */
  593.  
  594. void ShowAboutBox()
  595. {
  596.     int runninga=0;
  597.     OpenProject3Window();
  598.  
  599.     while(runninga!=100)
  600.     {
  601.         runninga=HandleProject3IDCMP();
  602.         if(Project0Wnd!=NULL) 
  603.         {
  604.             DummyProjectIDCMP(Project0Wnd);
  605.         }
  606.     }
  607.  
  608.     CloseProject3Window();
  609. }
  610.  
  611. /*
  612.     Show Hangman WinnerBox
  613. */
  614.  
  615. void ShowWinnerBox()
  616. {
  617.     int runninga=0;
  618.     OpenProject1Window();
  619.  
  620.     Gadget4Text.IText=Guess_Word_g;
  621.     updateTxtGad(Project1Wnd,Project1Gadgets[2],&Gadget4Text);
  622.  
  623.     while(runninga!=100)
  624.     {
  625.         runninga=HandleProject1IDCMP();
  626.         if(Project0Wnd!=NULL) 
  627.         {
  628.             DummyProjectIDCMP(Project0Wnd);
  629.         }
  630.     }
  631.  
  632.     CloseProject1Window();
  633. }
  634.  
  635. /*
  636.     Show Hangman LoserBox
  637. */
  638.  
  639. void ShowLoserBox()
  640. {
  641.     int runninga=0;
  642.     OpenProject2Window();
  643.  
  644.     Gadget4Text.IText=Guess_Word_g;
  645.     updateTxtGad(Project2Wnd,Project2Gadgets[2],&Gadget4Text);
  646.  
  647.     while(runninga!=100)
  648.     {
  649.         runninga=HandleProject2IDCMP();
  650.         if(Project0Wnd!=NULL) 
  651.         {
  652.             DummyProjectIDCMP(Project0Wnd);
  653.         }
  654.     }
  655.  
  656.     CloseProject2Window();
  657. }
  658.  
  659. /*
  660.     Process List box on About Hangman Box
  661. */
  662.  
  663. int Gadget13Clicked(void)
  664. {
  665.     return 0;
  666. }
  667.  
  668. /*
  669.     Kill Hangman (Ok|Cancel)
  670. */
  671.  
  672. int HangmanRequest(struct Window *Win)
  673. {
  674.     struct EasyStruct HangmanES = {
  675.         sizeof (struct EasyStruct),
  676.         0,
  677.         "Hangman 1997 Request",
  678.         "Exit Hangman?",
  679.         "Ok|Cancel"
  680.         };
  681.     int reply =0;
  682.  
  683.     reply=EasyRequest( Win, &HangmanES, NULL, NULL);
  684.  
  685.     if(reply ==1)
  686.     {
  687.         reply =100;
  688.     }
  689.     return reply;
  690. }
  691.  
  692. /*
  693.     Warn Kill Hangman Game (Ok|Cancel)
  694. */
  695.  
  696. int HangmanRequestG(struct Window *Win)
  697. {
  698.     struct EasyStruct HangmanES = {
  699.         sizeof (struct EasyStruct),
  700.         0,
  701.         "Hangman 1997 Request",
  702.         "This will abort the current Game",
  703.         "Ok|Cancel"
  704.         };
  705.     int reply =0;
  706.  
  707.     reply=EasyRequest( Win, &HangmanES, NULL, NULL);
  708.  
  709.     return reply;
  710. }
  711.  
  712. /***********************************************
  713.     Disable Project Window Gadgets
  714. ************************************************/
  715.  
  716. void DummyProjectIDCMP(struct Window *wnd )
  717. {
  718.     struct IntuiMessage    *m;
  719.  
  720.     while( m = GT_GetIMsg( wnd->UserPort ))
  721.     {
  722.  
  723.         GT_ReplyIMsg( m );
  724.  
  725.     }
  726. }
  727.  
  728. int Project0CloseWindow( void )
  729. {
  730.     /* routine for "IDCMP_CLOSEWINDOW". */
  731.  
  732.     CloseProject1Window();
  733.  
  734. }
  735.  
  736. int Project1CloseWindow( void )
  737. {
  738.     /* routine for "IDCMP_CLOSEWINDOW". */
  739.  
  740.     CloseProject1Window();
  741.  
  742. }
  743.  
  744. int Project2CloseWindow( void )
  745. {
  746.     /* routine for "IDCMP_CLOSEWINDOW". */
  747.  
  748.     CloseProject2Window();
  749. }
  750.  
  751. int Project3CloseWindow( void )
  752. {
  753.     /* routine for "IDCMP_CLOSEWINDOW". */
  754.     
  755.     CloseProject3Window();
  756. }