home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 5 / amigaformatcd05.iso / screenplay / shareware / mastermind / source / mastermind.c next >
C/C++ Source or Header  |  1996-08-13  |  39KB  |  1,457 lines
  1. /* 
  2.    MasterMind.c © Kamran Karimi.
  3.    Written with SAS/C 6.50 on an A1200. 
  4. */
  5. #include "misc.h"
  6.  
  7.  
  8. #define ConstMaxColors 16
  9. #define ConstMaxColumns 16
  10.  
  11. UWORD Private,Pens[] = {0xFFFF};
  12. UBYTE PubName[] = "MasterMind";
  13. struct TagItem MyTags[]  = { {SA_Pens,(ULONG)Pens},
  14.                              {SA_PubName,(ULONG)PubName},
  15.                              {SA_DisplayID,DEFAULT_MONITOR_ID | HIRES_KEY},
  16.                              {SA_Overscan,OSCAN_TEXT},
  17.                              {SA_AutoScroll,TRUE},
  18.                              {TAG_END,NULL} };
  19.  
  20. ULONG NormalMaxColumns = 9,NormalMaxRows;
  21. ULONG MaxColumns = 9,MinColumns = 1;
  22. ULONG MaxColors = 12,MinColors = 2;
  23. LONG NumColors = 6,PrevNumColors;
  24. LONG NumColumns = 4,PrevNumColumns;
  25. LONG NumRows = 0,PrevNumRows;
  26. LONG MaxRows,MaxNoLaceRows,MinRows = 1;
  27.  
  28. ULONG GID,ShouldClear = FALSE;
  29. APTR IAddress;
  30. ULONG OS,ForcePal = FALSE,Public = TRUE,UseLace = TRUE;
  31.  
  32. UBYTE AllocatedColor[ConstMaxColors]; /* 4 reserved colors */
  33. UBYTE Cheated[ConstMaxColumns];
  34.  
  35. ULONG Blacks,Whites,MemAlloc1 = FALSE,MemAlloc2 = FALSE;
  36. ULONG SelectedColor,LowRow,PrevLowRow,NumCheated,FastClean = FALSE;
  37. ULONG CurrentRow = 1,Added = FALSE,Lace = FALSE,Pal;  
  38. USHORT X,Y;/* for Result Borders */
  39.  
  40. struct Remember *ColorRem = NULL,*BoardRem =NULL;
  41.  
  42. VOID Error(ULONG Err),MyMessage(int Mes),CompResBorder(VOID);
  43. VOID ClearBoard(VOID),UpDateAcceptGadget(LONG Where),CheckBounds(VOID);
  44. VOID DrawCircles(LONG Whites,LONG Blacks),GoUp(VOID),ComputeResults(VOID);
  45. VOID GetRandColors(VOID),ProcessBoardGadget(struct Gadget *GadAddr);
  46. VOID ClickOtherColorGads(LONG ID),FillMyColorGadgets(VOID),MyOpenLibs(int);
  47. VOID DrawMyGadgets(VOID),DoConfiguration(VOID),MyEvent(LONG event);
  48. VOID FreeMyGadgets(struct Remember *MyStructRem,struct Gadget *GadToDo);
  49. VOID StartNewGame(VOID),OpenAll(VOID),FreeResources(VOID),WaitForUser(VOID);
  50. int AllocMyGadgets(LONG GadgetNum,struct Remember *MyStructRem,
  51.                                                      struct Gadget *GadToDo);
  52. VOID OpenDragableColor(VOID),CloseDragableColor(VOID);
  53. VOID HandleDragableColor(VOID),GetNewVals(VOID),CleanClean(VOID);
  54. ULONG Permute(ULONG,ULONG);
  55. VOID Cheat(VOID),GetArgs(int,char **);
  56. LONG CheckNoRep(VOID),CheckAllSelected(VOID);
  57. VOID CompatibleSetOPen(struct RastPort *rp,ULONG Color);
  58. ULONG CompatibleGetAPen(struct RastPort *rp),CloseScr(VOID);
  59. VOID CompatibleLoadRGB(struct ViewPort *vp);
  60.  
  61.  
  62. main(int argc,char *argv[])
  63. {
  64.  int done = FALSE,ConfigDone = 0;
  65.  struct Gadget *CurGad;
  66.  
  67.  IconBase = NULL;
  68.  MyOpenLibs(argc);
  69.  
  70.  OS = ((struct Library *)IntuitionBase)->lib_Version;
  71.  if(((struct Library *)GfxBase)->lib_Version >= 36)
  72.   if(GfxBase->ChipRevBits0 & GFXF_HR_DENISE) 
  73.    if(GfxBase->ChipRevBits0 & GFXF_HR_AGNUS) ForcePal = TRUE;
  74.  GetArgs(argc,argv);
  75.  if(OS < 36) UseLace = TRUE;
  76.  if(ForcePal) Pal = TRUE;
  77.  else Pal = (GfxBase->DisplayFlags & PAL);
  78.  if(OS >= 36) MaxColumns = 12;
  79.  NormalMaxRows  = (Pal) ? 24 : 18;
  80.  if(OS >= 36) MaxRows = 99;
  81.  else MaxRows = NormalMaxRows;
  82.  MaxNoLaceRows = (Pal) ? 11 : 8;
  83.  if(!NumRows) NumRows = (Pal) ? 10 : 8;
  84.  NewScr.Height = (Pal) ? 256 : 200;
  85.  MyNewWindow.Height = NewScr.Height;
  86.  if(!Public) MyTags[1].ti_Tag = TAG_IGNORE; 
  87.  
  88.  ((struct StringInfo *)CMGadget.SpecialInfo)->LongInt = NumColumns;
  89.  ((struct StringInfo *)CRGadget.SpecialInfo)->LongInt = NumColors;
  90.  ((struct StringInfo *)RWGadget.SpecialInfo)->LongInt = NumRows;
  91.  PrevNumRows = NumRows;
  92.  PrevNumColumns = NumColumns;
  93.  PrevNumColors = NumColors;
  94.  GetNewVals();
  95.  StartNewGame();
  96.               
  97.  while (done == FALSE)
  98.  {
  99.   WaitForUser(); 
  100.   if ((GID >= 100) && (GID < 116))  
  101.   {
  102.    ClickOtherColorGads(GID);
  103.    MyMessage(Colorize);
  104.    CurGad = (struct Gadget *)IAddress;
  105.    if(CurGad->Flags & GFLG_SELECTED)
  106.     SelectedColor = GID - 96; /* colors start with 4 */
  107.    else SelectedColor = 0;
  108.   }
  109.   if((GID <= NumColumns) && (GID > 0)) ProcessBoardGadget(IAddress);
  110.   switch(GID)
  111.   {
  112.    case 0:
  113.              break;
  114.    case 300:
  115.              if(!CheckAllSelected())
  116.              {
  117.               if(CheckNoRep())
  118.               {
  119.                MyMessage(NoRep);
  120.                break;
  121.               }
  122.               else
  123.               {
  124.                ComputeResults();
  125.                if(Blacks == NumColumns) 
  126.                {
  127.                 MyEvent(UserWon);
  128.                 MyMessage(ChooseCol);
  129.                 StartNewGame(); 
  130.                 break;
  131.                }
  132.                if(CurrentRow != NumRows) 
  133.                {
  134.                 MyMessage(AfterDone);
  135.                 CurrentRow++;
  136.                 GoUp();
  137.                }
  138.                else 
  139.                {
  140.                 NewGadget.GadgetText = &NewText;
  141.                 RefreshGList(&NewGadget,MyWindow,NULL,1);
  142.                 MyEvent(GameDone);
  143.                 MyMessage(ChooseCol);
  144.                 StartNewGame(); 
  145.                }
  146.               }
  147.              }
  148.              else MyMessage(FillFirst);  
  149.              break;
  150.  
  151.    case 500: Cheat();
  152.              break;
  153.  
  154.    case 501:
  155.              if((OS >= 36) && Public)
  156.              {
  157.               Private = PubScreenStatus(MyScreen,PSNF_PRIVATE);
  158.               if(Private & 0x0001) done = TRUE;
  159.               else MyMessage(Visitors);
  160.              }
  161.              else done = TRUE;
  162.              break;
  163.  
  164.    case 502: 
  165.              if(NewGadget.GadgetText == &AbortText)
  166.              {
  167.               NewGadget.GadgetText = &NewText;
  168.               RefreshGList(&NewGadget,MyWindow,NULL,1);
  169.               MyEvent(GameDone);
  170.               MyMessage(ChooseCol);
  171.               StartNewGame(); 
  172.              }
  173.              else 
  174.              {
  175.               MyMessage(ChooseCol);
  176.               StartNewGame();
  177.              }
  178.              break;
  179.  
  180.    case 503:
  181.              if(ConfigDone)  
  182.              {
  183.               RemoveGList(MyWindow,&RWGadget,3);
  184.               GetNewVals();
  185.               StartNewGame();
  186.              }
  187.              else  
  188.              {
  189.               if(ColorWindow && (ColorWindow != MyWindow)) 
  190.                CloseDragableColor();
  191.               DoConfiguration();
  192.               MyMessage(ChangeConf);
  193.              }
  194.              ConfigDone = ~ConfigDone;
  195.              break;
  196.  
  197.    case 1000: 
  198.              NumColumns = ((struct StringInfo *)CMGadget.SpecialInfo)->LongInt;
  199.              break; 
  200.  
  201.    case 1001: 
  202.              NumColors = ((struct StringInfo *)CRGadget.SpecialInfo)->LongInt;
  203.              break;
  204.  
  205.    case 1002: 
  206.              NumRows = ((struct StringInfo *)RWGadget.SpecialInfo)->LongInt;
  207.              break;
  208.   }
  209.  }
  210.  FreeResources();
  211.  exit(0);
  212. }
  213.  
  214.  
  215. VOID FreeResources(VOID)
  216. {
  217.  if(MemAlloc1)
  218.  {
  219.   RemoveGList(MyWindow,&BoardGadget,NumColumns);
  220.   FreeMyGadgets(BoardRem,&BoardGadget);
  221.  }
  222.  if(MemAlloc2)
  223.  {
  224.   RemoveGList(ColorWindow,&ColorGadget,NumColors);
  225.   FreeMyGadgets(ColorRem,&ColorGadget);
  226.  }
  227.  if(Added) RemoveGList(MyWindow,&ConfiGadget,5);
  228.  if(ColorWindow && (ColorWindow != MyWindow)) CloseWindow(ColorWindow);
  229.  if(MyWindow) CloseWindow(MyWindow);
  230.  if(MyScreen) CloseScreen(MyScreen);
  231.  if(GfxBase) CloseLibrary((struct Library *)GfxBase);
  232.  if(IconBase) CloseLibrary(IconBase);
  233.  if(IntuitionBase) CloseLibrary((struct Library *)IntuitionBase);
  234. }
  235.  
  236.  
  237. VOID WaitForUser(VOID)
  238. {
  239.  struct MsgPort *Port;
  240.  struct IntuiMessage *msg;
  241.  UWORD code;
  242.  ULONG class,RecMask;
  243.  ULONG ColorMask = 1L << (ColorWindow->UserPort)->mp_SigBit;
  244.  ULONG MainMask = 1L << (MyWindow->UserPort)->mp_SigBit;
  245.  
  246. #ifdef DEBUG
  247.  printf("ColorWin = %lx    MyWin = %lx\n",ColorWindow,MyWindow);
  248.  printf("ColorMask = %08lx    MainMask = %08lx\n",ColorMask,MainMask);
  249. #endif
  250.  RecMask = Wait(ColorMask | MainMask);
  251.  if(RecMask & ColorMask) Port = ColorWindow->UserPort;
  252.  else Port = MyWindow->UserPort;
  253.  msg = (struct IntuiMessage *)GetMsg(Port);
  254.  GID = 0;
  255.  class = msg->Class;
  256.  switch(class)
  257.  {
  258.     case IDCMP_GADGETUP: 
  259.                         IAddress = (msg->IAddress);
  260.                         GID = ((struct Gadget *)IAddress)->GadgetID;
  261.                         while(msg)
  262.                         {
  263.                          ReplyMsg((struct Message *)msg);
  264.                          msg = (struct IntuiMessage *)GetMsg(Port);
  265.                         }
  266.                         break;
  267.     case IDCMP_MOUSEBUTTONS:
  268.                         code = msg->Code;
  269.                         while(msg)
  270.                         {
  271.                          ReplyMsg((struct Message *)msg);
  272.                          msg = (struct IntuiMessage *)GetMsg(Port);
  273.                         }
  274.                         if(code == MENUUP)
  275.                          if(ConfiGadget.GadgetText != &DoneText) 
  276.                           HandleDragableColor();
  277.                         break;
  278.  }
  279. }
  280.  
  281.  
  282. VOID HandleDragableColor(VOID)
  283. {
  284.  if(ColorWindow == MyWindow) OpenDragableColor();
  285.  else CloseDragableColor();
  286. }
  287.  
  288.  
  289. VOID CloseDragableColor(VOID)
  290. {
  291.  int count;
  292.  struct Gadget *CurrGad;
  293.  
  294.  if((ColorWindow == NULL) || (ColorWindow == MyWindow)) return;
  295.  RemoveGList(ColorWindow,&ColorGadget,NumColors);
  296.  CloseWindow(ColorWindow);
  297.  ColorWindow = MyWindow;
  298.  ColorGadget.LeftEdge = MyScreen->Width - 350;
  299.  ColorGadget.TopEdge = MyScreen->Height - 16;  
  300.  CurrGad = ColorGadget.NextGadget;
  301.  for(count = 1;count < NumColors;count++)
  302.  {
  303.   CurrGad->LeftEdge = ColorGadget.LeftEdge - count * 25;
  304.   CurrGad->TopEdge = ColorGadget.TopEdge;
  305.   CurrGad = CurrGad->NextGadget;
  306.  } 
  307.  AddGList(MyWindow,&ColorGadget,~0,NumColors,NULL);
  308.  DrawBorder(ColorWindow->RPort,&ColBorder[3],
  309.              MyScreen->Width - NumColors * 25 - 328,ColorGadget.TopEdge - 2);
  310.  FillMyColorGadgets();
  311.  RefreshGList(&ColorGadget,MyWindow,NULL,NumColors); 
  312. }
  313.  
  314.  
  315. VOID OpenDragableColor(VOID)
  316. {
  317.  int count;
  318.  SHORT Left,Width;
  319.  struct Gadget *CurrGad;
  320.  
  321.  if((ColorWindow != MyWindow) && (ColorWindow != NULL)) return;
  322.  RemoveGList(MyWindow,&ColorGadget,NumColors);
  323.  SetAPen(MyWindow->RPort,0);
  324.  CompatibleSetOPen(MyWindow->RPort,0);
  325.  RectFill(MyWindow->RPort,2,MyScreen->Height - 22,
  326.                              ColorGadget.LeftEdge + 30,MyScreen->Height);
  327.  NewColorWindow.Width = NumColors * 25 + 40;  
  328.  if(MyScreen->MouseY > 50)
  329.    NewColorWindow.TopEdge = MyScreen->MouseY - 35; 
  330.  else 
  331.   NewColorWindow.TopEdge = MyScreen->MouseY;
  332.   
  333.   NewColorWindow.LeftEdge = (MyScreen->MouseX) - (NewColorWindow.Width/2);
  334.   Left = NewColorWindow.LeftEdge;
  335.   Width = NewColorWindow.Width;
  336.   if(Left + Width >= MyScreen->Width) 
  337.    NewColorWindow.LeftEdge = MyScreen->Width - Width;
  338.   if(Left <= MyScreen->LeftEdge)
  339.    NewColorWindow.LeftEdge = MyScreen->LeftEdge;
  340.   
  341.  ColorGadget.LeftEdge = NewColorWindow.Width - 40;
  342.  ColorGadget.TopEdge = 16;
  343.  CurrGad = ColorGadget.NextGadget;
  344.  for(count = 1;count < NumColors;count++)
  345.  {
  346.   CurrGad->LeftEdge = ColorGadget.LeftEdge - count * 25;
  347.   CurrGad->TopEdge = ColorGadget.TopEdge;
  348.   CurrGad = CurrGad->NextGadget;
  349.  } 
  350.  NewColorWindow.Screen = MyScreen; 
  351.  if((ColorWindow = OpenWindow(&NewColorWindow)) == NULL) Error(NoWindow);
  352.  AddGList(ColorWindow,&ColorGadget,~0,NumColors,NULL);
  353.  DrawBorder(ColorWindow->RPort,&ColBorder[3],22,14);
  354.  FillMyColorGadgets();
  355.  RefreshGList(&ColorGadget,ColorWindow,NULL,NumColors);
  356. } 
  357.  
  358. VOID Error(ULONG Err)
  359. {
  360.  FreeResources();
  361.  exit(Err);
  362. }
  363.  
  364. VOID CompatibleSetOPen(struct RastPort *rp,ULONG Color)
  365. {
  366.  if(OS >= 39) SetOutlinePen(rp,Color);
  367.  else SetOPen(rp,(UBYTE)Color);
  368. }
  369.  
  370. ULONG CompatibleGetAPen(struct RastPort *rp)
  371. {
  372.  return((OS >= 39) ? GetAPen(rp) : rp->FgPen);
  373. }
  374.  
  375. VOID CompatibleLoadRGB(struct ViewPort *vp)
  376. {
  377.  if(OS >= 39) LoadRGB32(vp,CMap32Bit); 
  378.  else LoadRGB4(vp,CMap4Bit,16);
  379. }
  380.  
  381. VOID MyMessage(int Mes)
  382. {
  383.  LONG y,Color; 
  384.  
  385.  strcpy(Row1,Messages[Mes]);
  386.  strcpy(Row2,Messages[Mes + 1]);
  387.  strcpy(Row3,Messages[Mes + 2]);
  388.  y = (Pal) ? 89 : 65;
  389.  Color = 1;
  390.  if(Mes == UserWon) Color = 4;
  391.  else if(Mes == GameDone) Color = 7; 
  392.  if(Mes >= NoAvailMem)
  393.  {
  394.   Color = 8;
  395.   DisplayBeep(MyScreen);
  396.  }
  397.  row1Text.FrontPen = row2Text.FrontPen = row3Text.FrontPen = Color;
  398.  PrintIText(MyWindow->RPort,&row3Text,MyScreen->Width - 180,y);
  399. }
  400.  
  401.  
  402. VOID Cheat(VOID)
  403. {
  404.  struct IntuiMessage *msg;
  405.  LONG CheatCol,Column,XMin,YMin,XMax,YMax,cnt;
  406.  struct Gadget *CurGad;
  407.  struct MD *md;
  408.  
  409.  RemoveGList(MyWindow,&BoardGadget,NumColumns);
  410.  RemoveGList(ColorWindow,&ColorGadget,NumColors);
  411.  OffGadget(&AcceptGadget,MyWindow,NULL);
  412.  OffGadget(&CheatGadget,MyWindow,NULL);
  413.  OffGadget(&NewGadget,MyWindow,NULL);
  414.  CheatCol = (ULONG)(rand() % NumColumns);
  415.  while(Cheated[CheatCol + 4] == TRUE) CheatCol = (CheatCol + 1) % NumColumns;
  416.  NumCheated++;
  417.  Cheated[CheatCol + 4] = TRUE;
  418.  MyMessage(CheatMe);
  419.  MyResWindow.LeftEdge = CheatGadget.LeftEdge;
  420.  MyResWindow.TopEdge = CheatGadget.TopEdge - 100;
  421.  MyResWindow.Screen = MyScreen;
  422.  MyResWindow.Width = 100;
  423.  MyResWindow.Title = "Naughty!";
  424.  if((ResWindow = OpenWindow(&MyResWindow)) == NULL) Error(NoWindow);
  425.  CurGad = &BoardGadget;
  426.  for(Column = 0;Column < CheatCol;Column++) CurGad = CurGad->NextGadget;
  427.  DrawImage(ResWindow->RPort,&MyImage, 33,15);
  428.  XMin = 33 + 9;
  429.  YMin = 20;
  430.  XMax = XMin + 14;
  431.  YMax = YMin + 8;
  432.  md = CurGad->UserData;
  433.  SetAPen(ResWindow->RPort,md->RandomColor);
  434.  CompatibleSetOPen(ResWindow->RPort,md->RandomColor);
  435.  RectFill(ResWindow->RPort,XMin,YMin,XMax,YMax);
  436.  WaitPort(ResWindow->UserPort);
  437.  msg = (struct IntuiMessage *)GetMsg(ResWindow->UserPort);
  438.  while(msg)
  439.  {
  440.   ReplyMsg((struct Message *)msg);
  441.   msg = (struct IntuiMessage *)GetMsg(ResWindow->UserPort);
  442.  }
  443.  CloseWindow(ResWindow);
  444.  CurGad = &ColorGadget;
  445.  for(cnt = 0;cnt < md->RandomColor - 4;cnt++) CurGad = CurGad->NextGadget;
  446.  CheatSign.BackPen = md->RandomColor;
  447.  XMin = CurGad->LeftEdge + 6;
  448.  YMin = CurGad->TopEdge + 1;
  449.  PrintIText(ColorWindow->RPort,&CheatSign,XMin,YMin);
  450.  UpDateAcceptGadget(1);
  451.  OnGadget(&AcceptGadget,MyWindow,NULL);
  452.  XMin = CheatGadget.LeftEdge - 2;
  453.  YMin = CheatGadget.TopEdge - 2;
  454.  XMax = NewGadget.LeftEdge + NewGadget.Width + 2;
  455.  YMax = YMin + NewGadget.Height + 1;
  456.  SetAPen(MyWindow->RPort,0);
  457.  CompatibleSetOPen(MyWindow->RPort,0);
  458.  if(NumCheated < NumColumns) OnGadget(&CheatGadget,MyWindow,NULL);
  459.  else OffGadget(&CheatGadget,MyWindow,NULL);
  460.  RectFill(MyWindow->RPort,XMin,YMin,XMax,YMax);
  461.  SetAPen(MyWindow->RPort,SelectedColor);
  462.  CompatibleSetOPen(MyWindow->RPort,SelectedColor);
  463.  OnGadget(&NewGadget,MyWindow,NULL);
  464.  RefreshGList(&CheatGadget,MyWindow,NULL,1);
  465.  AddGList(MyWindow,&BoardGadget,~0,NumColumns,NULL);
  466.  AddGList(ColorWindow,&ColorGadget,~0,NumColors,NULL);
  467. }
  468.  
  469. VOID CompResBorder(VOID)
  470. {
  471.  ULONG BigX,BigY,XMin,YMin,XMax,YMax,count;
  472.  
  473.  Y =  19;
  474.  X =  ((NumColumns / 2) + (NumColumns % 2)) * 15; 
  475.  
  476.  ResLines1[1] = Y;
  477.  ResLines1[4] = X + 1;
  478.  
  479.  ResLines2[1] = Y - 1;
  480.  ResLines2[2] = X + 1;
  481.  ResLines2[3] = Y - 1;
  482.  ResLines2[4] = X + 1;
  483.  
  484.  ResLines3[1] = Y - 2;
  485.  ResLines3[4] = X;
  486.  
  487.  ResLines4[1] = Y;
  488.  ResLines4[2] = X + 2;
  489.  ResLines4[3] = Y;
  490.  ResLines4[4] = X + 2; 
  491.  BigX = X + NumColumns * 33 + 13;
  492.  BigY = LowRow - ((NumRows - 1) * 19 + 5);
  493.  SetAPen(MyWindow->RPort,2);
  494.  Move(MyWindow->RPort,2,LowRow + 23);
  495.  Draw(MyWindow->RPort,2,BigY);
  496.  Draw(MyWindow->RPort,BigX,BigY);
  497.  SetAPen(MyWindow->RPort,1);
  498.  Draw(MyWindow->RPort,BigX,LowRow + 23);
  499.  Draw(MyWindow->RPort,2,LowRow + 23);
  500.  SetAPen(MyWindow->RPort,3); 
  501.  RectFill(MyWindow->RPort,3,BigY + 1,BigX - 1,LowRow + 22);
  502.  
  503.  SetAPen(MyWindow->RPort,0);
  504.  for(count = 0;count < NumRows;count++)
  505.  {
  506.   XMin = 9;
  507.   YMin = LowRow - count * 19;
  508.   XMax = XMin + X - 1;
  509.   YMax = YMin + Y - 2;
  510.   RectFill(MyWindow->RPort,XMin,YMin,XMax,YMax);
  511.  }
  512. } 
  513.  
  514. ULONG Permute(ULONG arg1,ULONG arg2)
  515. {
  516.  ULONG count,val = 1;
  517.  
  518.  arg2 = arg1 - arg2;
  519.  for(count = arg2 + 1;count <= arg1;count++)
  520.  {
  521.   val =  val * count;
  522.   if(val > MaxRows) break;
  523.  }
  524.  return(val);
  525. }
  526.  
  527.  
  528. VOID CheckBounds(VOID)
  529. {
  530.  ULONG Perm;
  531.  
  532.  if(NumColumns < MinColumns) NumColumns = MinColumns;
  533.  else if(NumColumns > MaxColumns) NumColumns = MaxColumns;
  534.  if(NumColors < MinColors) NumColors = MinColors;
  535.  else if(NumColors > MaxColors) NumColors = MaxColors;
  536.  if(NumRows < MinRows) NumRows = MinRows;
  537.  else if(NumRows > MaxRows) NumRows = MaxRows;
  538.  if(NumColors < NumColumns) NumColors = NumColumns;
  539.  Perm = Permute(NumColors,NumColumns) - 1;
  540.  if(NumRows > Perm) NumRows = Perm;
  541. }
  542.  
  543.  
  544. ULONG CloseScr(VOID)
  545. {
  546.  ULONG Success = TRUE;
  547.  
  548.  if(MyScreen)
  549.  {
  550.   if((OS >= 36) && Public)
  551.   {
  552.    Private = PubScreenStatus(MyScreen,PSNF_PRIVATE);
  553.    if(!(Private & 0x0001)) 
  554.    { 
  555.     Success = FALSE; 
  556.     MyMessage(Visitors); 
  557.    }
  558.   }
  559.   if(Success)
  560.   {
  561.    if(MemAlloc1 && MyWindow)
  562.    {
  563.     RemoveGList(MyWindow,&BoardGadget,NumColumns);
  564.     FreeMyGadgets(BoardRem,&BoardGadget);
  565.     MemAlloc1 = FALSE;
  566.    }
  567.    if(MemAlloc2 && ColorWindow)
  568.    {
  569.     RemoveGList(ColorWindow,&ColorGadget,NumColors);
  570.     FreeMyGadgets(ColorRem,&ColorGadget);
  571.     MemAlloc2 = FALSE;
  572.    } 
  573.    if(Added) { RemoveGList(MyWindow,&ConfiGadget,4); Added = FALSE; }
  574.    if(MyWindow) { CloseWindow(MyWindow); ColorWindow = MyWindow = NULL; }
  575.    if(MyScreen) { CloseScreen(MyScreen); MyScreen = NULL; }
  576.   }
  577.  }
  578.  return(Success);
  579. }
  580.  
  581.  
  582. VOID GetNewVals(VOID)
  583. {
  584.  ULONG ShouldChange = FALSE;
  585.  UWORD OW,OH,OM;
  586.  
  587.  NumColumns = ((struct StringInfo *)CMGadget.SpecialInfo)->LongInt;
  588.  NumColors = ((struct StringInfo *)CRGadget.SpecialInfo)->LongInt;
  589.  NumRows = ((struct StringInfo *)RWGadget.SpecialInfo)->LongInt;
  590.  CheckBounds();
  591.  OW = NewScr.Width;
  592.  OH = NewScr.Height;
  593.  OM = NewScr.ViewModes;
  594.  NewScr.DefaultTitle = NormalScrTitle;
  595.  if(NumColumns > NormalMaxColumns)
  596.  {
  597.   NewScr.Width = 640 + (NumColumns - NormalMaxColumns) * 35 + 9;
  598.   NewScr.DefaultTitle = ExtraScrTitle;
  599.  }
  600.  else NewScr.Width = 640; 
  601.  if(UseLace)
  602.  {
  603.   if(NumRows > MaxNoLaceRows)
  604.   {
  605.    NewScr.ViewModes |= LACE;
  606.    MyTags[2].ti_Data |= HIRESLACE_KEY;    
  607.    NewScr.Height = (Pal) ? 512 : 400;
  608.   } 
  609.   else
  610.   {
  611.    NewScr.ViewModes &= ~LACE;
  612.    MyTags[2].ti_Data &= ~HIRESLACE_KEY;
  613.    MyTags[2].ti_Data |= HIRES_KEY;  
  614.    NewScr.Height = (Pal) ? 256 : 200;
  615.   }
  616.   if(NumRows > NormalMaxRows) 
  617.   {
  618.    NewScr.Height += (NumRows - NormalMaxRows) * 20;
  619.    NewScr.DefaultTitle = ExtraScrTitle;
  620.   }
  621.  }
  622.  else
  623.  {
  624.   if(NumRows > MaxNoLaceRows) 
  625.   {
  626.    NewScr.Height = ((Pal) ? 256 : 200) + (NumRows - MaxNoLaceRows) * 20;
  627.    NewScr.DefaultTitle = ExtraScrTitle;  
  628.   }
  629.   else  
  630.   {
  631.    NewScr.Height = (Pal) ? 256 : 200;
  632.    NewScr.DefaultTitle = NormalScrTitle;
  633.   }
  634.  }
  635.  MyNewWindow.Height = NewScr.Height;
  636.  MyNewWindow.Width = NewScr.Width;
  637.  ShouldChange = 
  638.    ((OW != NewScr.Width) || (OH != NewScr.Height) || (OM != NewScr.ViewModes));
  639.  if(ShouldChange || !MyScreen)
  640.  {
  641.   if(CloseScr()) 
  642.   {
  643.    ShouldClear = FALSE;
  644.    AcceptGadget.LeftEdge = 1;
  645.    OpenAll();
  646.    MyMessage(ChooseCol);
  647.   } 
  648.   else
  649.   {
  650.    NumColors = PrevNumColors;
  651.    NumColumns = PrevNumColumns;
  652.    NumRows = PrevNumRows;
  653.    MyNewWindow.Width = NewScr.Width = OW;
  654.    MyNewWindow.Height = NewScr.Height = OH;
  655.    NewScr.ViewModes = OM;
  656.    if(MyScreen) MyMessage(Visitors);
  657.   }
  658.  }
  659.  else MyMessage(ChooseCol); 
  660. #ifdef DEBUG
  661.   printf("Width = %d   Height = %d\n",NewScr.Width,NewScr.Height);
  662. #endif
  663. }
  664.  
  665.  
  666. VOID ClearBoard(VOID)
  667. {
  668.  ULONG BigX,BigY,x,y;
  669.  
  670.  SetAPen(MyWindow->RPort,0);
  671.  CompatibleSetOPen(MyWindow->RPort,0);
  672.  RectFill(MyWindow->RPort,2,MyScreen->Height - 22,
  673.                                           MyScreen->Width,MyScreen->Height);
  674.  if(!ShouldClear)
  675.  {
  676.   ShouldClear = TRUE;
  677.   FastClean = FALSE;
  678.  }
  679.  else
  680.  {
  681.   BigX = X + PrevNumColumns * 33 + 13;
  682.   BigY = PrevLowRow - ((PrevNumRows - 1) * 19 + 5);
  683.   if((PrevNumColumns == NumColumns) && (PrevNumRows == NumRows))
  684.   {
  685.    CleanClean();
  686.    FastClean = TRUE;
  687.   }
  688.   else
  689.   { 
  690.    FastClean = FALSE;
  691.    RectFill(MyWindow->RPort,2,BigY,BigX + 1,PrevLowRow + 23);
  692.   }
  693.   x = ConfiGadget.LeftEdge - 2;
  694.   y = ConfiGadget.TopEdge - 2;
  695.   RectFill(MyWindow->RPort,x,y,x + ConfiGadget.Width + 2,
  696.                                                  y + ConfiGadget.Height + 2);
  697.  }
  698. }
  699.  
  700.  
  701. VOID UpDateAcceptGadget(LONG Where)
  702. {
  703.  ULONG XMin,YMin,XMax,YMax,OldAPen;
  704.  
  705.  if(!Where) RemoveGList(MyWindow,&AcceptGadget,1);
  706.  XMin = AcceptGadget.LeftEdge - 1;
  707.  YMin = AcceptGadget.TopEdge - 1;
  708.  XMax = XMin + 64;
  709.  YMax = YMin + 13;
  710.  OldAPen = CompatibleGetAPen(MyWindow->RPort);
  711.  SetAPen(MyWindow->RPort,0);
  712.  CompatibleSetOPen(MyWindow->RPort,0);
  713.  RectFill(MyWindow->RPort,XMin,YMin,XMax,YMax);
  714.  SetAPen(MyWindow->RPort,OldAPen);
  715.  if(!Where)  
  716.  {
  717.   AcceptGadget.TopEdge -= 19;
  718.   AddGList(MyWindow,&AcceptGadget,~0,1,NULL);
  719.   RefreshGList(&AcceptGadget,MyWindow,NULL,1);
  720.  }
  721. }
  722.  
  723.  
  724. VOID DrawCircles(LONG Whites,LONG Blacks)
  725. { 
  726.  ULONG CoOrd1,CoOrd2,count,count2,Elements;
  727.  struct Image *CurrImage;
  728.  
  729.  CoOrd1 = BoardGadget.LeftEdge;
  730.  CoOrd2 = BoardGadget.TopEdge;
  731.  count = 0;
  732.  Elements = Whites;
  733.  CurrImage = &WCircle; 
  734.  for(count2 = 0;count2 < 2;count2++)
  735.  {
  736.   while(Elements > 0)
  737.   {
  738.    DrawImage(MyWindow->RPort,CurrImage,CoOrd1 - 12,CoOrd2 + 4 );   
  739.    switch(count % 2)
  740.    {
  741.     case 0: CoOrd2 += 6;
  742.             break;
  743.  
  744.     case 1: CoOrd1 -= 12;
  745.             CoOrd2 -= 6;
  746.             break;
  747.    } 
  748.    count++;
  749.    Elements--;
  750.   }
  751.   Elements = Blacks;
  752.   CurrImage = &BCircle;
  753.  }
  754. }
  755.  
  756.  
  757. LONG CheckAllSelected(VOID)
  758. {
  759.  struct Gadget *CurGad;
  760.  struct MD *md;
  761.  int count;
  762.  
  763.  CurGad = &BoardGadget;
  764.  for(count = 1;count <= NumColumns;count++)
  765.  {
  766.   md = (struct MD *)CurGad->UserData;
  767.   if(md->GuessedColor == 0) return(1);
  768.   CurGad = CurGad->NextGadget;
  769.  }
  770.  return(0);
  771. } 
  772.  
  773.  
  774. LONG CheckNoRep(VOID)
  775. {
  776.  LONG count,count2;
  777.  struct Gadget *CurGad,*CurGad2; 
  778.  struct MD *md,*md2;
  779.  
  780.  CurGad = &BoardGadget;
  781.  for(count = 0;count < NumColumns;count++)
  782.  {
  783.   CurGad2 = CurGad->NextGadget;
  784.   for(count2 = count + 1;count2 <= NumColumns; count2++)
  785.   {
  786.    md = (struct MD *)CurGad->UserData;
  787.    md2 = (struct MD *)CurGad2->UserData;
  788.    CurGad2 = CurGad2->NextGadget;
  789.    if((md->GuessedColor == md2->GuessedColor) && 
  790.                                     (md->GuessedColor != 0)) return(RepFound);
  791.   }
  792.   CurGad = CurGad->NextGadget;
  793.  }
  794.  return(0);
  795. }
  796.  
  797.  
  798. VOID GoUp(VOID)
  799. {
  800.  int count;
  801.  struct Gadget *CurGad;
  802.  struct MD *md;
  803.  
  804.  RemoveGList(MyWindow,&BoardGadget,NumColumns);
  805.  CurGad = &BoardGadget;
  806.  for(count = 1;count <= NumColumns;count++)
  807.  {
  808.   CurGad->TopEdge -=  19;
  809.   md = (struct MD *)CurGad->UserData;
  810.   md->GuessedColor = 0;
  811.   CurGad = CurGad->NextGadget;
  812.  }
  813.  AddGList(MyWindow,&BoardGadget,~0,NumColumns,NULL);
  814.  RefreshGList(&BoardGadget,MyWindow,NULL,NumColumns);
  815.  UpDateAcceptGadget(0);
  816. }
  817.  
  818.  
  819. VOID ComputeResults(VOID)
  820. {
  821.  LONG count,count2,XMin,YMin,XMax,YMax;
  822.  struct MD *md,*md2;
  823.  struct Gadget *CurGad,*CurGad2;
  824.  
  825.  Blacks = Whites = 0;
  826.  CurGad = &BoardGadget;
  827.  
  828.  if(NewGadget.GadgetText != &AbortText)
  829.  {
  830.   NewGadget.GadgetText = &AbortText;
  831.   RefreshGList(&NewGadget,MyWindow,NULL,1);
  832.   OffGadget(&ConfiGadget,MyWindow,NULL);
  833.   OffGadget(&QuitGadget,MyWindow,NULL);
  834.   XMin = CheatGadget.LeftEdge - 2;
  835.   YMin = CheatGadget.TopEdge - 2;
  836.   XMax = XMin + CheatGadget.Width + 4;
  837.   YMax = YMin + CheatGadget.Height + 4;
  838.   SetAPen(MyWindow->RPort,0);
  839.   CompatibleSetOPen(MyWindow->RPort,0);
  840.   RectFill(MyWindow->RPort,XMin,YMin,XMax,YMax);
  841.   if((NumColumns == 1) || (NumColumns == NumColors))
  842.    OffGadget(&CheatGadget,MyWindow,NULL);
  843.   else OnGadget(&CheatGadget,MyWindow,NULL);
  844.   SetAPen(MyWindow->RPort,SelectedColor); 
  845.   CompatibleSetOPen(MyWindow->RPort,SelectedColor);
  846.  }
  847.  for(count = 1;count <= NumColumns; count++) /* first the blacks */
  848.  {
  849.   md = (struct MD *)CurGad->UserData;
  850.   if(md->RandomColor == md->GuessedColor) 
  851.   {
  852.    md->GuessedColor = 0;
  853.    Blacks++;
  854.   }
  855.   CurGad = CurGad->NextGadget;
  856.  }
  857.  
  858.  CurGad = &BoardGadget;
  859.  for(count = 1;count <= NumColumns;count++)
  860.  {
  861.   md = (struct MD *)CurGad->UserData;
  862.   CurGad2 = &BoardGadget;
  863.   for(count2 = 1; count2 <= NumColumns;count2++)
  864.   {
  865.    md2 = (struct MD *)CurGad2->UserData;
  866.    if(md->RandomColor == md2->GuessedColor) 
  867.    {
  868.     md2->GuessedColor = 0;
  869.     Whites++;
  870.     break;
  871.    }
  872.    CurGad2 = CurGad2->NextGadget;
  873.   }
  874.   CurGad = CurGad->NextGadget;
  875.  }
  876.  CurGad = &BoardGadget;
  877.  for(count = 1;count <= NumColumns;count++)
  878.  {
  879.   md = (struct MD *)CurGad->UserData;
  880.   md->GuessedColor = 0;
  881.   CurGad = CurGad->NextGadget;
  882.  }
  883.  DrawCircles(Whites,Blacks);
  884. #ifdef DEBUG
  885.  printf("whites = %ld  Blacks = %ld\n",Whites,Blacks);
  886. #endif
  887. }
  888.  
  889. VOID GetRandColors(VOID)
  890. {
  891.  ULONG count,Color;
  892.  ULONG Secs,Mics;
  893.  struct Gadget *CurGad;
  894.  struct MD *md;
  895.  
  896. #ifdef DEBUG
  897.  printf("Total Colors = %ld\n",NumColors);
  898.  printf("Columns = %d\n",NumColumns);
  899.  printf("Rows = %ld\n",NumRows);
  900. #endif
  901.  
  902.  CurGad = &BoardGadget;
  903.  CurrentTime(&Secs,&Mics);
  904.  srand(Secs + Mics);
  905.  for(count = 1;count <= NumColumns;count++)
  906.  {
  907.   Color = (ULONG)(rand() % NumColors);
  908.   while(AllocatedColor[Color + 4] == TRUE) 
  909.                                        Color = (Color + 1) % NumColors;
  910.   md = (struct MD *)CurGad->UserData;
  911.   md->RandomColor = Color + 4;
  912.   md->GuessedColor = 0;
  913.   AllocatedColor[Color + 4] = TRUE;
  914.   CurGad = CurGad->NextGadget;
  915. #ifdef DEBUG
  916.   printf("Color No. %ld = %ld\n",count,Color);
  917. #endif
  918.  } 
  919. } 
  920.  
  921.  
  922. VOID ProcessBoardGadget(struct Gadget *GadAddr)
  923. {
  924.  LONG XMin,YMin,XMax,YMax;
  925.  struct MD *md;
  926.  
  927.  XMin = GadAddr->LeftEdge + 9;
  928.  YMin = GadAddr->TopEdge + 5;
  929.  XMax = XMin + 14;
  930.  YMax = YMin + 8;
  931.  SetAPen(MyWindow->RPort,SelectedColor);
  932.  CompatibleSetOPen(MyWindow->RPort,SelectedColor);
  933.  RectFill(MyWindow->RPort,XMin,YMin,XMax,YMax);
  934.  if(SelectedColor > 3)
  935.  {
  936.   md = (struct MD *)GadAddr->UserData;
  937.   md->GuessedColor = SelectedColor;
  938.   MyMessage(RepColoring);
  939.  }
  940. }
  941.  
  942. VOID CleanClean(VOID)
  943. {
  944.  ULONG XMin,XMax,YMin,YMax,ResYMin,count1,count2;
  945.  
  946.  YMin = LowRow + 5;
  947.  YMax = YMin + 8;
  948.  SetAPen(MyWindow->RPort,0);
  949.  CompatibleSetOPen(MyWindow->RPort,0);
  950.  for(count1 = 1; count1 <= NumRows; count1++)
  951.  {
  952.   ResYMin = LowRow + 2 - (count1 - 1) * 19;
  953.   RectFill(MyWindow->RPort,10,ResYMin,7 + X - 1,ResYMin + 13);
  954.   XMin = X + 9 + 9;
  955.   XMax = XMin + 14;
  956.   for(count2 = 1;count2 <= NumColumns; count2++)
  957.   {
  958.    RectFill(MyWindow->RPort,XMin,YMin,XMax,YMax);
  959.    XMin = XMin + BoardGadget.Width;
  960.    XMax = XMin + 14;
  961.   }
  962.   YMin = YMin - 19;
  963.   YMax = YMin + 8;
  964.  }
  965. }
  966.  
  967.  
  968. VOID ClickOtherColorGads(LONG ID)
  969. {
  970.  int count;
  971.  struct Gadget *CurGad = &ColorGadget;
  972.  
  973.  for(count = 0;count < NumColors;count++)
  974.  { 
  975.   if((CurGad->Flags & GFLG_SELECTED) && (CurGad->GadgetID != ID))
  976.   {
  977.    CurGad->Flags &= ~GFLG_SELECTED;  
  978.    break;
  979.   }
  980.   CurGad = CurGad->NextGadget;
  981.  }
  982.  RefreshGList(&ColorGadget,ColorWindow,NULL,NumColors);
  983. }
  984.  
  985.  
  986. VOID FillMyColorGadgets(VOID)
  987. {
  988.  LONG count,count2,XMin,YMin,XMax,YMax,Color;
  989.  struct Gadget *CurGad = &ColorGadget,*CurGad2;
  990.  
  991.  for(count = 4;count < NumColors + 4;count++)
  992.  {
  993.   SetAPen(ColorWindow->RPort,count);
  994.   CompatibleSetOPen(ColorWindow->RPort,count);
  995.   XMin = CurGad->LeftEdge;
  996.   YMin = CurGad->TopEdge;
  997.   XMax = XMin + CurGad->Width - 1;
  998.   YMax = YMin + CurGad->Height - 1;
  999.   RectFill(ColorWindow->RPort,XMin,YMin,XMax,YMax);
  1000.   CurGad2 = &BoardGadget;
  1001.   for(count2 = 0;count2 < NumColumns;count2++)
  1002.   {
  1003.    Color = ((struct MD *)(CurGad2->UserData))->RandomColor;
  1004.    if((Cheated[count2 + 4] == TRUE) && (Color == count))
  1005.    { 
  1006.     CheatSign.BackPen = count;
  1007.     XMin = CurGad->LeftEdge + 6;
  1008.     YMin = CurGad->TopEdge + 1;
  1009.     PrintIText(ColorWindow->RPort,&CheatSign,XMin,YMin);
  1010.    }
  1011.    CurGad2 = CurGad2->NextGadget;
  1012.   }
  1013.   CurGad = CurGad->NextGadget;
  1014.  }
  1015. }
  1016.  
  1017.  
  1018. VOID DrawMyGadgets(VOID)
  1019. {
  1020.  int Column,Row;
  1021.  
  1022.  if(FastClean) return;
  1023.  CompResBorder();
  1024.  for(Row = 0;Row < NumRows;Row++)
  1025.  {
  1026.   DrawBorder(MyWindow->RPort,&ResBorder[3],7,LowRow - Row * 19);
  1027.   for(Column = 0;Column < NumColumns;Column++)
  1028.    DrawImage(MyWindow->RPort,&MyImage,(X + 9 + Column * 33),
  1029.                                                           LowRow - Row * 19);
  1030.  }
  1031. }
  1032.  
  1033.  
  1034. /* This routine dynamically allocates gadgets. Total gadget number equals 
  1035.    the ones allocated here plus the gadget whose pointer is in GadTodo.
  1036.    total = [GadgetNum -1] (allocated here) + [1] (GadToDo)
  1037. */
  1038.  
  1039. int AllocMyGadgets(LONG GadgetNum,struct Remember *MyStructRem,
  1040.                                                       struct Gadget *GadToDo)
  1041. {
  1042.  struct Gadget *PrevGadget,*NewGad;
  1043.  struct MD *Mymd;
  1044.  int count;
  1045.   
  1046.  if(GadToDo == &BoardGadget) GadToDo->LeftEdge = X + 9;
  1047.  GadToDo->Flags &= ~GFLG_SELECTED;
  1048.  PrevGadget = GadToDo;
  1049.  for(count = 1; count < GadgetNum; count++) 
  1050.  {
  1051.   NewGad = AllocRemember(&MyStructRem,sizeof(struct Gadget),MEMF_ANY);
  1052.   if(NewGad == NULL) 
  1053.   {
  1054.    FreeMyGadgets(MyStructRem,GadToDo);
  1055.    return(FALSE);
  1056.   }
  1057.   CopyMem(GadToDo,NewGad,sizeof(struct Gadget));
  1058.   NewGad->GadgetID = PrevGadget->GadgetID + 1;
  1059.   if(GadToDo == &BoardGadget)
  1060.   {
  1061.    NewGad->LeftEdge = PrevGadget->LeftEdge + GadToDo->Width;
  1062.    Mymd = AllocRemember(&MyStructRem,sizeof(struct MD),MEMF_ANY|MEMF_CLEAR);
  1063.    if(Mymd == NULL) 
  1064.    {
  1065.     FreeMyGadgets(MyStructRem,GadToDo);
  1066.     return(FALSE);
  1067.    }
  1068.    NewGad->UserData = Mymd;
  1069.   }
  1070.   else if(GadToDo == &ColorGadget)
  1071.    NewGad->LeftEdge = PrevGadget->LeftEdge - GadToDo->Width - 5; 
  1072.   PrevGadget->NextGadget = NewGad;
  1073.   PrevGadget = NewGad;
  1074.  }
  1075.  NewGad->NextGadget = NULL;
  1076.  return(TRUE);
  1077. }
  1078.  
  1079. VOID FreeMyGadgets(struct Remember *MyStructRem,struct Gadget *GadToDo)
  1080. {
  1081.  FreeRemember(&MyStructRem,TRUE);
  1082.  MyStructRem = NULL;
  1083.  GadToDo->NextGadget = NULL;
  1084. }
  1085.  
  1086.  
  1087. VOID DoConfiguration(VOID)
  1088. {
  1089.  LONG y1;
  1090.  
  1091.  y1 = (Pal) ? 111 : 90;
  1092.  
  1093.  PrevNumColors = NumColors;
  1094.  PrevNumRows = NumRows;
  1095.  PrevNumColumns = NumColumns;
  1096.  PrevLowRow = LowRow;
  1097.  
  1098.  if(MemAlloc1)
  1099.  {
  1100.   RemoveGList(MyWindow,&BoardGadget,NumColumns);
  1101.   FreeMyGadgets(BoardRem,&BoardGadget);
  1102.  }
  1103.  if(MemAlloc2)
  1104.  {
  1105.   RemoveGList(ColorWindow,&ColorGadget,NumColors);
  1106.   FreeMyGadgets(ColorRem,&ColorGadget);
  1107.  }
  1108.  MemAlloc1 = MemAlloc2 = FALSE;
  1109.  ConfiGadget.GadgetText = &DoneText;
  1110.  RefreshGList(&ConfiGadget,MyWindow,NULL,1);
  1111.  OffGadget(&NewGadget,MyWindow,NULL);
  1112.  OffGadget(&QuitGadget,MyWindow,NULL);
  1113.  OffGadget(&AcceptGadget,MyWindow,NULL);
  1114.  OffGadget(&CheatGadget,MyWindow,NULL);
  1115.  CRGadget.GadgetRender = &ConfBorder[3];
  1116.  CMGadget.GadgetRender = &ConfBorder[3];
  1117.  RWGadget.GadgetRender = &ConfBorder[3];
  1118.  BigConfBorder[0].FrontPen = 2;
  1119.  BigConfBorder[1].FrontPen = 1;
  1120.  DrawBorder(MyWindow->RPort,&BigConfBorder[1],
  1121.                              MyScreen->Width - 182,MyScreen->Height - y1 - 1);
  1122.  AddGList(MyWindow,&RWGadget,~0,3,NULL);
  1123.  RefreshGList(&RWGadget,MyWindow,NULL,3);
  1124. }  
  1125.  
  1126.  
  1127. VOID MyEvent(LONG event)
  1128. {
  1129.  struct IntuiMessage *msg;
  1130.  LONG Column,XMin,YMin,XMax,YMax;
  1131.  ULONG class;
  1132.  struct Gadget *CurGad;
  1133.  struct MD *md;
  1134.  
  1135.  RemoveGList(MyWindow,&BoardGadget,NumColumns);
  1136.  RemoveGList(ColorWindow,&ColorGadget,NumColors);
  1137.  OffGadget(&CheatGadget,MyWindow,NULL);
  1138.  OffGadget(&AcceptGadget,MyWindow,NULL);
  1139.  if(event == UserWon) 
  1140.  {
  1141.   MyMessage(UserWon);
  1142.   NewGadget.GadgetText = &OKText;
  1143.   RefreshGList(&NewGadget,MyWindow,NULL,1);
  1144.   do
  1145.   {    
  1146.    WaitPort(MyWindow->UserPort);
  1147.    msg = (struct IntuiMessage *)GetMsg(MyWindow->UserPort);
  1148.    class = msg->Class;
  1149.    while(msg)
  1150.    {
  1151.     ReplyMsg((struct Message *)msg);
  1152.     msg = (struct IntuiMessage *)GetMsg(MyWindow->UserPort);
  1153.    }
  1154.   }while(class != IDCMP_GADGETUP);
  1155.   NewGadget.GadgetText = &NewText;
  1156.   RefreshGList(&NewGadget,MyWindow,NULL,1);
  1157.  }
  1158.  if(event == GameDone)
  1159.  { 
  1160.   MyMessage(GameDone);
  1161.   OffGadget(&NewGadget,MyWindow,NULL);
  1162.   MyResWindow.Width = NumColumns * 33 + 13 + 40;
  1163.   MyResWindow.LeftEdge = NewGadget.LeftEdge - MyResWindow.Width + 100;
  1164.   MyResWindow.TopEdge = NewGadget.TopEdge - 100;
  1165.   MyResWindow.Screen = MyScreen;
  1166.   MyResWindow.Title = "Solution";
  1167.   if((ResWindow = OpenWindow(&MyResWindow)) == NULL) Error(NoWindow);
  1168.   CurGad = &BoardGadget;
  1169.   for(Column = 0;Column < NumColumns;Column++)
  1170.   {
  1171.    DrawImage(ResWindow->RPort,&MyImage, 25 + Column * 33,15);
  1172.    XMin = 25 + Column * 33 + 9;
  1173.    YMin = 20;
  1174.    XMax = XMin + 14;
  1175.    YMax = YMin + 8;
  1176.    md = CurGad->UserData;
  1177.    SetAPen(ResWindow->RPort,md->RandomColor);
  1178.    CompatibleSetOPen(ResWindow->RPort,md->RandomColor);
  1179.    RectFill(ResWindow->RPort,XMin,YMin,XMax,YMax);
  1180.    CurGad = CurGad->NextGadget;
  1181.   } 
  1182.   WaitPort(ResWindow->UserPort);
  1183.   msg = (struct IntuiMessage *)GetMsg(ResWindow->UserPort);
  1184.   while(msg)
  1185.   {
  1186.    ReplyMsg((struct Message *)msg);
  1187.    msg = (struct IntuiMessage *)GetMsg(ResWindow->UserPort);
  1188.   }
  1189.   CloseWindow(ResWindow);
  1190.  }
  1191. }
  1192.  
  1193.  
  1194. VOID StartNewGame(VOID)
  1195. {
  1196.  
  1197.  LONG y1,count,XMin,YMin,XMax,YMax,X2;
  1198.  
  1199.  y1 = (Pal) ? 111 : 90;
  1200.  
  1201.  SelectedColor = 0; 
  1202.  if(MemAlloc1)
  1203.  {
  1204.   RemoveGList(MyWindow,&BoardGadget,NumColumns);
  1205.   FreeMyGadgets(BoardRem,&BoardGadget);
  1206.  }
  1207.  if(MemAlloc2)
  1208.  {
  1209.   RemoveGList(ColorWindow,&ColorGadget,NumColors);
  1210.   FreeMyGadgets(ColorRem,&ColorGadget);
  1211.  }
  1212.  for(count = 0;count < (MaxColors + 4);count++) AllocatedColor[count] = FALSE;
  1213.  for(count = 0;count < (MaxColumns + 4);count++) Cheated[count] = FALSE;
  1214.  NumCheated = 0;
  1215.  CurrentRow = 1;
  1216.  LowRow = MyScreen->Height - 24 - (MyScreen->Height - (NumRows * 19)) / 2;
  1217.  BoardGadget.TopEdge = LowRow;
  1218.  OffGadget(&CheatGadget,MyWindow,NULL); 
  1219.  OnGadget(&NewGadget,MyWindow,NULL);
  1220.  OnGadget(&QuitGadget,MyWindow,NULL);
  1221.  OnGadget(&AcceptGadget,MyWindow,NULL);
  1222.  OnGadget(&ConfiGadget,MyWindow,NULL);
  1223.  UpDateAcceptGadget(1);
  1224.  ClearBoard();
  1225.  X2 = NumColors * (20 + 5) + 7;  
  1226.  CoLines1[4] = X2;
  1227.  CoLines2[2] = X2 - 1;
  1228.  CoLines2[4] = X2 - 1;
  1229.  CoLines3[4] = X2 - 1;
  1230.  CoLines4[2] = X2;
  1231.  CoLines4[4] = X2;
  1232.  
  1233.  if(ColorWindow == MyWindow)
  1234.   DrawBorder(ColorWindow->RPort,&ColBorder[3],
  1235.             MyScreen->Width - NumColors * 25 - 328,ColorGadget.TopEdge - 2); 
  1236.  else
  1237.   DrawBorder(ColorWindow->RPort,&ColBorder[3],22,14);
  1238.  DrawMyGadgets(); 
  1239.  MemAlloc1 = (AllocMyGadgets(NumColumns,BoardRem,&BoardGadget)) ? TRUE:FALSE;
  1240.  MemAlloc2 = (AllocMyGadgets(NumColors,ColorRem,&ColorGadget)) ? TRUE:FALSE;
  1241.  if(!MemAlloc1 || !MemAlloc2)
  1242.  {
  1243.   MyMessage(NoAvailMem);
  1244.   Delay(300);
  1245.   FreeResources();
  1246.   exit(20);
  1247.  } 
  1248.  GetRandColors();
  1249.  AddGList(MyWindow,&BoardGadget,~0,NumColumns,NULL);
  1250.  
  1251.  AddGList(ColorWindow,&ColorGadget,~0,NumColors,NULL);
  1252.  
  1253.  FillMyColorGadgets(); 
  1254.  
  1255.  RefreshGList(&BoardGadget,MyWindow,NULL,NumColumns);
  1256.  RefreshGList(&ColorGadget,ColorWindow,NULL,NumColors);
  1257.  
  1258.  sprintf(crbuf,"%d",NumColors);
  1259.  sprintf(cmbuf,"%d",NumColumns);
  1260.  sprintf(rwbuf,"%d",NumRows);
  1261.  ((struct StringInfo *)CMGadget.SpecialInfo)->LongInt = NumColumns;
  1262.  ((struct StringInfo *)CRGadget.SpecialInfo)->LongInt = NumColors;
  1263.  ((struct StringInfo *)RWGadget.SpecialInfo)->LongInt = NumRows;
  1264.  XMin = CMGadget.LeftEdge - 4;
  1265.  YMin = CMGadget.TopEdge - 4;
  1266.  XMax = RWGadget.LeftEdge + RWGadget.Width + 2;
  1267.  YMax = RWGadget.TopEdge + RWGadget.Height + 2;
  1268.  SetAPen(MyWindow->RPort,0);
  1269.  CompatibleSetOPen(MyWindow->RPort,0);
  1270.  RectFill(MyWindow->RPort,XMin,YMin,XMax,YMax);
  1271.  BigConfBorder[0].FrontPen = 1;
  1272.  BigConfBorder[1].FrontPen = 2;
  1273.  DrawBorder(MyWindow->RPort,&BigConfBorder[1],
  1274.                             MyScreen->Width - 182,MyScreen->Height - y1 - 1);
  1275.  CRGadget.GadgetRender = NULL;
  1276.  CMGadget.GadgetRender = NULL;
  1277.  RWGadget.GadgetRender = NULL;
  1278.  AddGList(MyWindow,&RWGadget,~0,3,NULL);
  1279.  RefreshGList(&RWGadget,MyWindow,NULL,3);
  1280.  RemoveGList(MyWindow,&RWGadget,3);
  1281.  AcceptGadget.LeftEdge = BoardGadget.LeftEdge + NumColumns * 33  + 9;
  1282.  AcceptGadget.TopEdge = LowRow - (CurrentRow - 1) * 19 + 4;
  1283.  RefreshGList(&AcceptGadget,MyWindow,NULL,1);
  1284.  NewGadget.GadgetText = &NewText;
  1285.  RefreshGList(&NewGadget,MyWindow,NULL,2);
  1286.  RefreshGList(&CheatGadget,MyWindow,NULL,2);
  1287.  ConfiGadget.GadgetText = &ConfigText;
  1288.  RefreshGList(&ConfiGadget,MyWindow,NULL,1);
  1289.  PrevNumColors = NumColors;
  1290.  PrevNumRows = NumRows;
  1291.  PrevNumColumns = NumColumns;
  1292.  PrevLowRow = LowRow;
  1293. }
  1294.  
  1295.  
  1296. VOID MyOpenLibs(int Argc)
  1297. {
  1298.  if((IntuitionBase = (struct IntuitionBase *)
  1299.         OpenLibrary("intuition.library",0)) == NULL) Error(NoIntuition);
  1300.  
  1301.  if((GfxBase = (struct GfxBase *)
  1302.         OpenLibrary("graphics.library",0)) == NULL) Error(NoGraphics);
  1303.  
  1304.  if(!Argc)
  1305.   if((IconBase = OpenLibrary("icon.library",33)) == NULL) Error(NoIcon);
  1306. }
  1307.  
  1308.  
  1309. VOID OpenAll(VOID)
  1310. {
  1311.  LONG y,y1;
  1312.  
  1313.  y = (Pal) ? 86 : 62;
  1314.  y1 = (Pal) ? 111 : 90;
  1315.  
  1316.  if(OS >= 36)
  1317.  {
  1318.   if(ForcePal) MyTags[2].ti_Data |= PAL_MONITOR_ID;
  1319.   if((MyScreen = OpenScreenTagList(&NewScr,MyTags)) == NULL) Error(NoScreen); 
  1320.  }
  1321.  
  1322.  else if((MyScreen = OpenScreen(&NewScr)) == NULL) Error(NoScreen);
  1323.  MyNewWindow.Screen = MyScreen;
  1324.  if((MyWindow = OpenWindow(&MyNewWindow)) == NULL) Error(NoWindow);
  1325.  ColorWindow = MyWindow;
  1326.  
  1327.  CompatibleLoadRGB(&(MyScreen->ViewPort));
  1328.  
  1329.  ColorGadget.LeftEdge = MyScreen->Width - 350;
  1330.  ColorGadget.TopEdge = MyScreen->Height - 16;
  1331.  
  1332.  QuitGadget.LeftEdge = MyScreen->Width - 90;
  1333.  QuitGadget.TopEdge = MyScreen->Height - 15;
  1334.  
  1335.  NewGadget.LeftEdge = MyScreen->Width - 190;
  1336.  NewGadget.TopEdge = MyScreen->Height  - 15;
  1337.  
  1338.  CheatGadget.LeftEdge = MyScreen->Width - 290;
  1339.  CheatGadget.TopEdge = MyScreen->Height - 15;
  1340.  
  1341.  ConfiGadget.LeftEdge = MyScreen->Width - 135;
  1342.  ConfiGadget.TopEdge = MyScreen->Height - (y1 - 48);
  1343.   
  1344.  DrawImage(MyWindow->RPort,&LogoImage,MyScreen->Width - 184, 20);
  1345.  
  1346.  PrintIText(MyWindow->RPort,&rwText,
  1347.                 MyScreen->Width - 183,MyScreen->Height - y1 + 2);
  1348.  
  1349.  BigConfBorder[0].FrontPen = 1;
  1350.  BigConfBorder[1].FrontPen = 2;
  1351.  DrawBorder(MyWindow->RPort,&BigConfBorder[1],
  1352.                             MyScreen->Width - 182,MyScreen->Height - y1 - 1);
  1353.  
  1354.  DrawBorder(MyWindow->RPort,&MessBorder[3],
  1355.                                MyScreen->Width - 180,y);
  1356.  
  1357.  CRGadget.LeftEdge = CMGadget.LeftEdge =
  1358.                               RWGadget.LeftEdge = MyScreen->Width - 90;
  1359.  
  1360.  CMGadget.TopEdge = MyScreen->Height - y1;
  1361.  CRGadget.TopEdge = CMGadget.TopEdge + 15;
  1362.  RWGadget.TopEdge = CRGadget.TopEdge + 16;
  1363.  
  1364.  AddGList(MyWindow,&ConfiGadget,~0,5,NULL);
  1365.  Added = TRUE;
  1366.  if((OS >= 36) && Public)
  1367.  {
  1368.   Private = PubScreenStatus(MyScreen,0);
  1369.   if (!(Private & 0x0001)) Error(NoPub);
  1370.  }
  1371. }
  1372.  
  1373.  
  1374. VOID GetArgs(int argc,char *argv[])
  1375. {
  1376.  int Temp,count;
  1377.  struct WBStartup *WBMessage;
  1378.  struct WBArg *WBarg;
  1379.  struct DiskObject *DiskObj;
  1380.  char **ToolArray,*tt;
  1381.  
  1382.  if((argc == 2) && !strcmp(argv[1],"?"))
  1383.  {
  1384.   printf("\n MasterMind.  © Kamran Karimi\n");
  1385.   printf("\nUSAGE: %s [(c|C)#] [(g|G)#] [(t|T)#] [m|M)] [e|E] [n|N]\n",
  1386.                                                                    argv[0]);
  1387.   printf("         c : Guess among this many 'C'olors\n\
  1388.          g : 'G'uess this many Colors\n\
  1389.          t : In atmost this many 'T'ries\n\
  1390.          m : Use a custo'M' screen (not public)\n\
  1391.          e : Don't use interlace ('E'yes at 'E'ase!)\n\
  1392.          n : Don't force a PAL screen (for 'N'TSC users)\n");
  1393.   exit(0);
  1394.  }
  1395.  if(argc > 1)
  1396.  {
  1397.   for(count = 1;count < argc;count++)
  1398.   {
  1399.    Temp = atoi(argv[count] + 1);
  1400.    switch (argv[count][0])
  1401.    {
  1402.     case 'g':
  1403.     case 'G':
  1404.              if(Temp > 0) NumColumns = Temp;
  1405.              break;
  1406.     case 'c':
  1407.     case 'C':
  1408.              if(Temp > 0) NumColors = Temp;
  1409.              break; 
  1410.     case 't':
  1411.     case 'T':
  1412.              if(Temp > 0) NumRows = Temp;
  1413.              break;
  1414.     case 'm':
  1415.     case 'M':
  1416.              Public = FALSE;
  1417.              break;
  1418.     case 'e':
  1419.     case 'E':
  1420.              UseLace = FALSE;
  1421.              break;       
  1422.     case 'n':
  1423.     case 'N':
  1424.              ForcePal = FALSE;
  1425.              break;        
  1426.    }
  1427.   }
  1428.  }
  1429.  
  1430.  if(!argc)
  1431.  {
  1432.   WBMessage = (struct WBStartup *)argv;
  1433.   WBarg = WBMessage->sm_ArgList;
  1434.   DiskObj = GetDiskObject(WBarg->wa_Name);
  1435.   ToolArray = (char **)DiskObj->do_ToolTypes; 
  1436.   if(tt = (char *)FindToolType(ToolArray,"COLORS")) 
  1437.   {
  1438.    Temp = atoi(tt);
  1439.    if(Temp > 0) NumColors = Temp;
  1440.   }
  1441.   if(tt = (char *)FindToolType(ToolArray,"GUESS")) 
  1442.   {
  1443.    Temp = atoi(tt);
  1444.    if(Temp > 0) NumColumns = Temp;
  1445.   }
  1446.   if(tt = (char *)FindToolType(ToolArray,"TRIES")) 
  1447.   {
  1448.    Temp = atoi(tt);
  1449.    if(Temp > 0) NumRows = Temp;
  1450.   }
  1451.   if(tt = (char *)FindToolType(ToolArray,"CUSTOMSCREEN")) Public = FALSE;
  1452.   if(tt = (char *)FindToolType(ToolArray,"NOINTERLACE")) UseLace = FALSE;
  1453.   if(tt = (char *)FindToolType(ToolArray,"NOPAL")) ForcePal = FALSE;
  1454.   FreeDiskObject(DiskObj);
  1455.  }
  1456. }
  1457.