home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 262.lha / SpriteWizard_v1.0 / SpriteWiz.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-06-30  |  25.7 KB  |  888 lines
  1.  /*  Sprite Wizard  -  By David A. Visage  */
  2.  
  3. #include <stdio.h>
  4. #include <exec/types.h>
  5. #include <graphics/sprite.h>
  6. #include <intuition/intuition.h>
  7.  
  8. /*  Various defines  */
  9. #define VERSION        0
  10. #define GADGET_FLAGS   (GADGETDOWN | GADGETUP)
  11. #define IDCMP_FLAGS    (CLOSEWINDOW | MOUSEBUTTONS | MENUPICK | GADGET_FLAGS)
  12. #define ALL_BITS  0xffff
  13.  
  14. /*  Box definitions  */
  15. #define MAX_BOXES   (16 * 16)
  16. #define BOX_WIDTH   15
  17. #define BOX_HEIGHT  10
  18.  
  19. /*  Grid definitions  */
  20. #define GRID_WIDTH     (16 * BOX_WIDTH)
  21. #define GRID_HEIGHT    (16 * BOX_HEIGHT)
  22.  
  23. /*  Define color registers  */
  24. #define COLOR00 0
  25. #define COLOR01 1
  26. #define COLOR02 2
  27. #define COLOR03 3
  28. #define COLOR04 4
  29. #define COLOR05 5
  30. #define COLOR06 6
  31. #define COLOR07 7
  32. #define COLOR16 16
  33. #define COLOR17 17
  34. #define COLOR18 18
  35. #define COLOR19 19
  36. #define COLOR20 20
  37. #define COLOR21 21
  38. #define COLOR22 22
  39. #define COLOR23 23
  40.  
  41. /*  Define screen maximums  */
  42. #define MAX_DEPTH    3
  43. #define MAX_WIDTH    640
  44. #define MAX_HEIGHT   200
  45. #define MAX_STR_LEN  256              /*  Maximum input string length  */
  46.  
  47. /*  Defines for low and high sprites  */
  48. #define LOW_SPRITE   0
  49. #define HIGH_SPRITE  25
  50.  
  51. /*  Sprite definitions  */
  52. #define MAX_SPRITES  26
  53. #define SPRITE_SIZE  36                   /*  In words  */
  54.  
  55. #define SPRITE02     2                    /*  Edit sprite  */
  56.  
  57. /*  Define return value of all functions  */
  58. extern struct Window *OpenWindow();
  59. extern struct Screen *OpenScreen();
  60. extern struct Library *OpenLibrary();
  61. extern struct View *ViewAddress();
  62. extern struct Message *GetMsg();
  63. extern PLANEPTR AllocRaster();
  64. extern UWORD GetRGB4();
  65. extern UWORD PackRGB();
  66. extern LONG GetPropVal();
  67. extern BOOL CheckSequence();
  68. extern BOOL GetRowCol(),GetString();
  69. extern BOOL LoadBinary(),SaveBinary();
  70. extern BOOL SaveCSource(),SaveAsmSource();
  71.  
  72. /*  Global library base pointers  */
  73. struct IntuitionBase *IntuitionBase;
  74. struct GfxBase *GfxBase;
  75.  
  76. /*  Various  structure declares  */
  77. struct NewWindow MyWindow;
  78. struct NewScreen MyScreen;
  79. struct Preferences MyPrefs;
  80. struct RastPort HorizRast,VertRast,GRast;
  81. struct BitMap HorizBitMap,VertBitMap,GBitMap;
  82. struct SimpleSprite MySprite;
  83.  
  84. /*  Lots of pointer declares  */
  85. struct View *V;
  86. struct RastPort *Rp;
  87. struct ViewPort *Vp;
  88. struct BitMap *Bm;
  89. struct Gadget *GadPtr;
  90. struct Window *WindowPtr;
  91. struct Screen *ScreenPtr;
  92. struct IntuiMessage *MessagePtr;
  93.  
  94. /*  Declares for each box image  */
  95. struct Rectangle Boxes[MAX_BOXES];
  96. LONG MinX,MinY,MaxX,MaxY;
  97.  
  98. /*  Used for gadget borders and DrawGrid() function  */
  99. struct Points
  100.  {
  101.  SHORT X1,Y1;
  102.  SHORT X2,Y2;
  103.  SHORT X3,Y3;
  104.  SHORT X4,Y4;
  105.  SHORT X5,Y5;
  106.  };
  107.  
  108. /*  Main Sprite structure  */
  109. struct Sprite
  110.  {
  111.  UWORD SpriteData [SPRITE_SIZE];
  112.  UWORD SprColor1,SprColor2,SprColor3;
  113.  UWORD SpriteNumber;
  114.  };
  115.  
  116. /*  Array to hold sprite information  */
  117. struct Sprite SpriteArray [MAX_SPRITES];
  118.  
  119. struct Sprite TempSprite;            /*  For Get() and Put() functions  */
  120.  
  121. UWORD NullImage[SPRITE_SIZE];        /*  Disable image during request   */
  122.  
  123. UWORD AnimData[SPRITE_SIZE];         /*  For Sprite animation data      */
  124.  
  125. UBYTE AnimBuffer[MAX_STR_LEN];       /*  Holds animation sequence       */
  126.  
  127. UBYTE ObjectName[MAX_STR_LEN];       /*  Holds load/save object name    */
  128.  
  129. UBYTE SaveCName[MAX_STR_LEN];        /*  Holds save C source name       */
  130.  
  131. UBYTE SaveAsmName[MAX_STR_LEN];      /*  Holds save ASM source name     */
  132.  
  133. /*  Currently defined repeat modes  */
  134. char *ModeStr[] = {
  135.  "CURRENT",
  136.  "ALL    ",
  137.  "FROM   ",
  138.  "UP TO  ",
  139.  "EXCEPT " };
  140.  
  141.  
  142. #include "SW_Gadgets.h"
  143. #include "SW_Menu.h"
  144. #include "SW_Display.h"
  145.  
  146. main()
  147. {
  148. USHORT GadID,MenuCode;
  149. UBYTE HighBit,LowBit,MenuNum;
  150. LONG MouseX,MouseY;
  151. LONG Row,Column,Mode;
  152. LONG BitMask,Index;
  153. LONG RedBits,GreenBits,BlueBits;
  154. LONG CurrScrColor,CurrSprColor;
  155. LONG SelectVal,ScrollVal,RotateVal;
  156. BOOL ScrollMode,SelectMode;
  157. BOOL RotateMode,ColorMode;
  158. BOOL DrawMode,Test1,Test2;
  159. UWORD *SpriteDataPtr;
  160. UWORD *SprColorPtr;               /*  Points to current sprite color  */
  161. struct ColorData *CurrentCD;
  162. struct PropInfo *InfoPtr;
  163. struct Sprite *SpritePtr;         /*  Points to current sprite  */
  164. WORD ColorVal,SprNum;
  165. int i;
  166.  
  167. OpenLibs();                             /*  Open all needed libraries   */
  168. SetSeed();                              /*  Seed random number routine  */
  169.  
  170. InitDisplay();                          /*  Initial screen display      */
  171. DrawGrid();                             /*  Put the grid on the screen  */
  172.  
  173. AllocSprite(&MySprite,SPRITE02);        /*  Allocate edit sprite        */
  174. InitSprites(&SpriteArray[0]);           /*  Initialize edit sprites     */
  175. InitTempSprite(&TempSprite);            /*  For Get() before Put()      */
  176. ClearSprData(&NullImage[0]);            /*  Image during requesters     */
  177.  
  178. InitGadgets();                          /*  Add all gadgets to window   */
  179. SetMenuStrip(WindowPtr,&Titles[0]);     /*  Menu definitions            */
  180.  
  181. /*  Allocate rasters for horizontal and vertical scrolling  */
  182. InitTempRast(&HorizRast,&HorizBitMap,BOX_WIDTH,GRID_HEIGHT);
  183. InitTempRast(&VertRast,&VertBitMap,GRID_WIDTH,BOX_HEIGHT);
  184. InitTempRast(&GRast,&GBitMap,GRID_WIDTH,GRID_HEIGHT);
  185.  
  186. /*  Get pointer colors and pointer data  */
  187. GetDefPrefs(&MyPrefs,sizeof(struct Preferences));
  188.  
  189. /*  Refresh gadget display  */
  190. GadPtr = WindowPtr->FirstGadget;
  191. RefreshGadgets(GadPtr,WindowPtr,NULL);
  192.  
  193. /*  Set current color and current sprite  */
  194. SpritePtr = &SpriteArray[0];
  195. SprColorPtr = &SpritePtr->SprColor1;
  196. CurrentCD = &ColorData1;
  197. CurrScrColor = CurrentCD->ScreenColor;
  198. CurrSprColor = CurrentCD->SpriteColor;
  199.  
  200. /*  Refresh screen with current sprite, current (X,Y) and current mode  */
  201. Mode = CURRENT;
  202. RefreshSprNum(Rp,0);
  203. RefreshGridXY(Rp,0,0);
  204. RefreshMode(Rp,ModeStr[Mode]);
  205.  
  206. /*  Set first sprite image as pointer image  */
  207. SpriteDataPtr = &SpritePtr->SpriteData[0];
  208. CopySprData(&MyPrefs.PointerMatrix[0],SpriteDataPtr);
  209. ChangeSprite(Vp,&MySprite,SpriteDataPtr);
  210.  
  211. /*  Set RGB gadgets and draw first sprite image  */
  212. SetRGBGad(CurrScrColor); 
  213. CalcSprite(Rp,SpritePtr,&Boxes[0]);
  214.  
  215. /*  Disable all repeat modes  */
  216. ColorMode = FALSE;
  217. SelectMode = FALSE;
  218. ScrollMode = FALSE;
  219. RotateMode = FALSE;
  220. DrawMode = FALSE;
  221.  
  222. while (TRUE)                                 /*  A structured goto  */
  223.   {
  224.   /*  Are we in DrawMode?  */
  225.   if ( DrawMode == TRUE )
  226.      {
  227.      MouseX = WindowPtr->MouseX;
  228.      MouseY = WindowPtr->MouseY;
  229.      if ( GetRowCol(MouseX,MouseY,&Row,&Column) == TRUE ) 
  230.         {
  231.         /*  Handle grid plot  */
  232.         RefreshGridXY(Rp,Row,Column);
  233.         Index = Column + (Row * 16);
  234.         PlotGrid(Index,CurrScrColor);
  235.         /*  Handle sprite plot  */
  236.         HighBit = CurrentCD->ColorBits.HighBit;
  237.         LowBit = CurrentCD->ColorBits.LowBit;
  238.         BitMask = 1 << (15 - Column);
  239.         PlotSprite(SpritePtr,Row,HighBit,LowBit,BitMask);
  240.         }
  241.      else
  242.         DrawMode = FALSE;
  243.      };
  244.  
  245.   /*  Are we in SelectMode?  */
  246.   if ( SelectMode == TRUE )
  247.      {
  248.      /*  Determine current sprite  */
  249.      SprNum = SpritePtr->SpriteNumber;    /*  Get current sprite number  */
  250.      SprNum += SelectVal;
  251.      if ( SprNum == - 1  )                /*  Don't change this!  */
  252.         SpritePtr = &SpriteArray[HIGH_SPRITE];
  253.      else if ( SprNum > HIGH_SPRITE )
  254.         SpritePtr = &SpriteArray[LOW_SPRITE];
  255.      else
  256.         SpritePtr += SelectVal;       /*  Scaled by argument size  */
  257.  
  258.      /*  Change current colors to selected sprite colors  */
  259.      ResetColors(SpritePtr->SprColor1,&ColorData1);
  260.      ResetColors(SpritePtr->SprColor2,&ColorData2);
  261.      ResetColors(SpritePtr->SprColor3,&ColorData3);
  262.      
  263.      /*  Change sprite image  */
  264.      SpriteDataPtr = &SpritePtr->SpriteData[0];
  265.      ChangeSprite(Vp,&MySprite,SpriteDataPtr);
  266.  
  267.      /*  Determine which color of this sprite is current  */
  268.      if ( CurrScrColor == COLOR01 )
  269.         SprColorPtr = &SpritePtr->SprColor1;
  270.      else if ( CurrScrColor == COLOR02 )
  271.         SprColorPtr = &SpritePtr->SprColor2;
  272.      else if ( CurrScrColor == COLOR03 )
  273.         SprColorPtr = &SpritePtr->SprColor3;
  274.  
  275.      /*  Refresh screen display  */
  276.      SetRGBGad(CurrScrColor);
  277.      RefreshSprNum(Rp,SpritePtr->SpriteNumber);
  278.      CalcSprite(Rp,SpritePtr,&Boxes[0]);
  279.      };
  280.  
  281.   /*  Are we in ColorMode?  */
  282.   if ( ColorMode == TRUE )
  283.      {
  284.      /*  Read RGB gadgets  */
  285.      RedBits = GetPropVal(&RedGad);
  286.      GreenBits = GetPropVal(&GreenGad);
  287.      BlueBits = GetPropVal(&BlueGad);
  288.  
  289.      /*  Set screen and sprite colors  */
  290.      SetRGB4(Vp,CurrScrColor,RedBits,GreenBits,BlueBits);   /*  Screen  */
  291.      SetRGB4(Vp,CurrSprColor,RedBits,GreenBits,BlueBits);   /*  Sprite  */
  292.  
  293.      /*  Should we update the sprite color pointer  */
  294.      if ( CurrScrColor != COLOR00 )
  295.         {
  296.         ColorVal = PackRGB(RedBits,GreenBits,BlueBits);
  297.         *SprColorPtr = ColorVal;
  298.         };
  299.      };
  300.  
  301.   /*  Are we in ScrollMode?  */
  302.   if ( ScrollMode == TRUE )
  303.      {
  304.      if ( ScrollVal == SCROLL_UP )
  305.         ScrollUp(Rp,&VertRast,SpritePtr,&Boxes[0]);
  306.      else if ( ScrollVal == SCROLL_DOWN )
  307.         ScrollDown(Rp,&VertRast,SpritePtr,&Boxes[0]);
  308.      else if ( ScrollVal == SCROLL_LEFT )
  309.         ScrollLeft(Rp,&HorizRast,SpritePtr,&Boxes[0]);
  310.      else if ( ScrollVal = SCROLL_RIGHT )
  311.         ScrollRight(Rp,&HorizRast,SpritePtr,&Boxes[0]);
  312.  
  313.      /*  Change actual sprite image  */
  314.      SpriteDataPtr = &SpritePtr->SpriteData[0];
  315.      ChangeSprite(Vp,&MySprite,SpriteDataPtr);
  316.      };
  317.  
  318.   /*  Are we in RotateMode?  */ 
  319.   if ( RotateMode == TRUE )
  320.      {
  321.      if ( RotateVal == ROTATE_RIGHT )
  322.         RotateRight(Rp,&GRast,SpritePtr,&Boxes[0]);
  323.      else
  324.         RotateLeft(Rp,&GRast,SpritePtr,&Boxes[0]);
  325.  
  326.      /*  Change actual sprite image  */
  327.      SpriteDataPtr = &SpritePtr->SpriteData[0];
  328.      ChangeSprite(Vp,&MySprite,SpriteDataPtr);
  329.      };
  330.  
  331.   MessagePtr = (struct IntuiMessage *) GetMsg(WindowPtr->UserPort);
  332.   if ( MessagePtr != NULL )
  333.      {
  334.      ReplyMsg(MessagePtr);                  /*  Reply to message  */
  335.      switch(MessagePtr->Class)
  336.         {
  337.         case CLOSEWINDOW :
  338.              Quit();             /*  Free memory, sprite, and exit  */
  339.         break;
  340.  
  341.         case MOUSEBUTTONS :
  342.              if ( MessagePtr->Code == SELECTUP )
  343.                 {
  344.                 /*  Disable repeat modes -- gadgets and grid plotting    */
  345.                 DrawMode = FALSE;
  346.                 SelectMode = FALSE;
  347.                 ScrollMode = FALSE;
  348.                 RotateMode = FALSE;
  349.                 ColorMode = FALSE;
  350.                 }
  351.              else                 /*  If SELECTDOWN, it's not a gadget!  */
  352.                 DrawMode = TRUE;
  353.         break;
  354.  
  355.         case GADGETDOWN :
  356.              GadPtr = (struct Gadget *) MessagePtr->IAddress;
  357.              GadID = GadPtr->GadgetID;
  358.  
  359.              /*  Check select gadgets  */
  360.              if ( GadID == SELECT_PLUS || GadID == SELECT_MINUS )
  361.                 {
  362.                 SelectMode = TRUE;
  363.                 SelectVal = (GadID == SELECT_PLUS ? 1 : - 1);
  364.                 };
  365.  
  366.              /*  Check color gadgets  */
  367.              Test1 = (BOOL) (GadID == SPRCOLOR0 || GadID == SPRCOLOR1);
  368.              Test2 = (BOOL) (GadID == SPRCOLOR2 || GadID == SPRCOLOR3);
  369.              if ( Test1 || Test2 )
  370.                 {
  371.                 CurrentCD = (struct ColorData *) GadPtr->UserData;
  372.                 CurrScrColor = CurrentCD->ScreenColor;
  373.                 CurrSprColor = CurrentCD->SpriteColor;
  374.                 SetRGBGad(CurrScrColor);
  375.  
  376.                 /*  Determine current edit color of current sprite  */
  377.                 if ( GadID == SPRCOLOR1 )
  378.                    SprColorPtr = &SpritePtr->SprColor1;
  379.                 else if ( GadID == SPRCOLOR2 )
  380.                    SprColorPtr = &SpritePtr->SprColor2;
  381.                 else if ( GadID == SPRCOLOR3 )
  382.                    SprColorPtr = &SpritePtr->SprColor3;
  383.                 };
  384.  
  385.              /*  Check scroll gadgets  */
  386.              Test1 = (BOOL) (GadID == SCROLL_UP || GadID == SCROLL_DOWN);
  387.              Test2 = (BOOL) (GadID == SCROLL_LEFT || GadID == SCROLL_RIGHT);
  388.              if ( Test1 | Test2 )
  389.                 {
  390.                 ScrollMode = TRUE;
  391.                 ScrollVal = GadID;
  392.                 };
  393.  
  394.              /*  Check rotate gadgets  */
  395.              if ( GadID == ROTATE_LEFT || GadID == ROTATE_RIGHT )
  396.                 {
  397.                 RotateMode = TRUE;
  398.                 RotateVal = GadID;
  399.                 };
  400.  
  401.              /*  Check RGB gadgets  */
  402.              Test1 = (BOOL) (GadID == RED_GAD);
  403.              Test2 = (BOOL) (GadID == GREEN_GAD || GadID == BLUE_GAD);
  404.              if ( Test1 | Test2 )
  405.                 ColorMode = TRUE;
  406.         break;
  407.  
  408.         /*  This is for RELVERIFY gadgets only  */
  409.         case GADGETUP :
  410.              GadPtr = (struct Gadget *) MessagePtr->IAddress;
  411.              GadID = GadPtr->GadgetID;
  412.  
  413.              /*  Check buffer gadgets  */
  414.              Test1 = (BOOL) (GadID == GET_GAD || GadID == PUT_GAD);
  415.              if ( Test1 )
  416.                 {
  417.                 SprNum = SpritePtr->SpriteNumber;
  418.                 if ( GadID == GET_GAD )
  419.                    {
  420.                    CopySprite(&TempSprite,SpritePtr);
  421.                    SpritePtr->SpriteNumber = SprNum;
  422.                    ResetColors(SpritePtr->SprColor1,&ColorData1);
  423.                    ResetColors(SpritePtr->SprColor2,&ColorData2);
  424.                    ResetColors(SpritePtr->SprColor3,&ColorData3);
  425.                    SetRGBGad(CurrScrColor); 
  426.                    ChangeSprite(Vp,&MySprite,&SpritePtr->SpriteData[0]);
  427.                    CalcSprite(Rp,SpritePtr,&Boxes[0]);
  428.                    }
  429.                 else
  430.                    CopySprite(SpritePtr,&TempSprite);      /*  PUT_GAD  */
  431.                 };
  432.  
  433.              /*  Disable all repeat gadgets  */
  434.              SelectMode = FALSE;
  435.              ScrollMode = FALSE;
  436.              RotateMode = FALSE;
  437.              ColorMode = FALSE;
  438.         break;
  439.  
  440.         case MENUPICK :
  441.              MenuCode = MessagePtr->Code;
  442.              if ( MenuCode != MENUNULL )
  443.                 {
  444.                 MenuNum = MENUNUM(MenuCode);
  445.                 if ( MenuNum == PROJECT )
  446.                    HandleProject(MenuCode,SpritePtr,CurrentCD,Mode);
  447.                 else if ( MenuNum == EDIT )
  448.                    HandleEdit(MenuCode,SpritePtr,CurrentCD,Mode);
  449.                 else if ( MenuNum == MODE )
  450.                    {
  451.                    Mode = ITEMNUM(MenuCode);
  452.                    RefreshMode(Rp,ModeStr[Mode]);
  453.                    }
  454.                 else if ( MenuNum == ANIMATE )
  455.                    HandleAnimate(MenuCode,SpritePtr);
  456.                 };
  457.         break;
  458.  
  459.         default :       /*  This doesn't do anything!  */  ;
  460.         };
  461.      };
  462.   };
  463. }
  464.  
  465.  
  466. /*  Set RGB gadgets based on contents of color register passed  */
  467. SetRGBGad(ColorReg)
  468. LONG ColorReg;
  469. {
  470. struct PropInfo *InfoPtr;
  471. struct ColorMap *CMapPtr;
  472. ULONG RedBits,GreenBits,BlueBits;
  473. UWORD ColorVal;
  474.  
  475. CMapPtr = Vp->ColorMap;
  476. ColorVal = GetRGB4(CMapPtr,ColorReg);
  477. UnPackRGB(ColorVal,&RedBits,&GreenBits,&BlueBits);
  478.  
  479. /*  Set red RGB gadget  */
  480. InfoPtr = (struct PropInfo *) RedGad.SpecialInfo;
  481. InfoPtr->HorizPot = RedBits * 0x1111;
  482.  
  483. /*  Set green RGB gadget  */
  484. InfoPtr = (struct PropInfo *) GreenGad.SpecialInfo;
  485. InfoPtr->HorizPot = GreenBits * 0x1111;
  486.  
  487. /*  Set blue RGB gadget  */
  488. InfoPtr = (struct PropInfo *) BlueGad.SpecialInfo;
  489. InfoPtr->HorizPot = BlueBits * 0x1111;
  490.  
  491. /*  Refresh gadget display  */
  492. GadPtr = WindowPtr->FirstGadget;
  493. RefreshGadgets(GadPtr,WindowPtr,NULL);
  494.  
  495. /*  Refresh current color indicator  */
  496. MinX = 540;
  497. MinY = 37;
  498. MaxX = 572;
  499. MaxY = 61;
  500. SetAPen(Rp,COLOR04);             
  501. RectFill(Rp,MinX,MinY,MaxX,MaxY);           /*  Emulate border  */
  502. SetAPen(Rp,ColorReg);
  503. RectFill(Rp,MinX+1,MinY+1,MaxX-1,MaxY-1);   /*  Current color indicator  */
  504. }
  505.  
  506.  
  507. /*  Get setting of proportional gadget  --  Value is [0..15]  */
  508. LONG GetPropVal(GadPtr)
  509. struct Gadget *GadPtr;
  510. {
  511. struct PropInfo *InfoPtr;
  512. USHORT HorizPot;
  513. LONG Value;
  514.  
  515. InfoPtr = (struct PropInfo *) GadPtr->SpecialInfo;
  516. HorizPot = InfoPtr->HorizPot;
  517. Value = (LONG) (HorizPot / 0x1111);
  518. return(Value);
  519. }
  520.  
  521.  
  522. /*  Determine if a point is within grid and return (X,Y)  */
  523. BOOL GetRowCol(XCoord,YCoord,RowPtr,ColumnPtr)
  524. LONG XCoord,YCoord;
  525. LONG *RowPtr,*ColumnPtr;
  526. {
  527. BOOL TestX,TestY;
  528. LONG TempRow,TempColumn;
  529.  
  530. /*  Get Mouse Coordinates in form of Row and Column  */
  531. TempRow = (YCoord - 20) / BOX_HEIGHT;
  532. TempColumn = (XCoord - 20) / BOX_WIDTH;
  533.  
  534. TestX =  (BOOL) ( TempColumn >= 0 && TempColumn <= 15 );
  535. TestY =  (BOOL) ( TempRow >= 0 && TempRow <= 15 );
  536.  
  537.  /*  If point is within Grid, return TRUE  */
  538. if ( TestX && TestY )
  539.    {
  540.    *RowPtr = TempRow;
  541.    *ColumnPtr = TempColumn;
  542.    return((BOOL) TRUE);
  543.    }
  544. else
  545.    {
  546.    *RowPtr = 9999;
  547.    *ColumnPtr = 9999;
  548.    return((BOOL) FALSE);
  549.    };
  550. }
  551.  
  552.  
  553. /*  Plot point on grid based on index passed  */
  554. PlotGrid(Index,ColorReg)
  555. LONG Index,ColorReg;
  556. {
  557. MinX = (LONG) Boxes[Index].MinX;
  558. MinY = (LONG) Boxes[Index].MinY;
  559. MaxX = (LONG) Boxes[Index].MaxX;
  560. MaxY = (LONG) Boxes[Index].MaxY;
  561. SetAPen(Rp,ColorReg);
  562. RectFill(Rp,MinX + 1,MinY + 1,MaxX - 1,MaxY - 1);
  563. }
  564.  
  565.  
  566. /*  Plot point in sprite  */
  567. PlotSprite(SpritePtr,Row,HighBit,LowBit,BitMask)
  568. struct Sprite *SpritePtr;
  569. LONG Row;
  570. UBYTE LowBit,HighBit;
  571. LONG BitMask;
  572. {
  573. LONG WordIndex;
  574. UWORD HighWord,LowWord;
  575. UWORD *SpriteDataPtr;
  576.  
  577. SpriteDataPtr = &SpritePtr->SpriteData[0];
  578.  
  579. /*  Calculate address of actual sprite data  */
  580. WordIndex = 2 + (Row * 2);                       /*  Skip posctldata  */
  581. HighWord = *(SpriteDataPtr + WordIndex);
  582. LowWord = *(SpriteDataPtr + WordIndex + 1);
  583.  
  584. if ( HighBit == 1 )
  585.    HighWord |= BitMask;                        /*  Set if HighBit = 1  */
  586. else
  587.    HighWord &= (ALL_BITS - BitMask);
  588.  
  589. if ( LowBit == 1 )
  590.    LowWord |= BitMask;                         /*  Set if HighBit = 1  */
  591. else
  592.    LowWord &= (ALL_BITS - BitMask);
  593.  
  594. /*  Assign data back to sprite  */
  595. *(SpriteDataPtr + WordIndex) = HighWord;
  596. *(SpriteDataPtr + WordIndex + 1) = LowWord;
  597. ChangeSprite(Vp,&MySprite,SpriteDataPtr);
  598. }
  599.  
  600.  
  601. /*  Reset screen, gadget, and sprite colors  */
  602. ResetColors(ColorVal,ColorDataPtr)
  603. UWORD ColorVal;
  604. struct ColorData *ColorDataPtr;
  605. {
  606. ULONG ScreenColor,SpriteColor;
  607. ULONG RedBits,GreenBits,BlueBits;
  608.  
  609. /*  Get current screen and sprite color registers  */
  610. ScreenColor = ColorDataPtr->ScreenColor;
  611. SpriteColor = ColorDataPtr->SpriteColor;
  612.  
  613. /*  Set screen and gadget colors based on colors of current sprite  */
  614. UnPackRGB(ColorVal,&RedBits,&GreenBits,&BlueBits);
  615. SetRGB4(Vp,ScreenColor,RedBits,GreenBits,BlueBits);
  616. SetRGB4(Vp,SpriteColor,RedBits,GreenBits,BlueBits);
  617. }
  618.  
  619.  
  620. /*  Handle project choice from menu  */
  621. HandleProject(MenuCode,SpritePtr,ColorDataPtr,Mode)
  622. USHORT MenuCode;
  623. struct Sprite *SpritePtr;
  624. struct ColorData *ColorDataPtr;
  625. ULONG Mode;
  626. {
  627. UBYTE ItemNum,SubNum;
  628. char *StrPtr,*FileName;
  629. char ErrMsg[80];
  630. BOOL ReturnVal;
  631.  
  632. ItemNum = ITEMNUM(MenuCode);
  633. SubNum = SUBNUM(MenuCode);
  634. switch(ItemNum)
  635.   {
  636.   case ABOUT :
  637.        if ( SubNum == AUTHOR )
  638.           Author(WindowPtr);
  639.        else if ( SubNum == PROGRAM )
  640.           {
  641.           ChangeSprite(Vp,&MySprite,&NullImage[0]);
  642.           Program(WindowPtr);
  643.           ChangeSprite(Vp,&MySprite,&SpritePtr->SpriteData[0]);
  644.           };
  645.   break;
  646.  
  647.   case LOAD :
  648.        StrPtr = "Load binary data from which file :      ";
  649.        ReturnVal = GetString(WindowPtr,StrPtr,&ObjectName[0]);
  650.        if ( ReturnVal == TRUE )
  651.           {
  652.           FileName = (char *) &ObjectName[0];
  653.           ReturnVal = LoadBinary(&SpriteArray[0],FileName,&ErrMsg[0]);
  654.           if ( ReturnVal == FALSE )
  655.              ErrRequest(WindowPtr,&ErrMsg[0]);
  656.           else
  657.              {
  658.              /*  Change current colors to selected sprite colors  */
  659.              ResetColors(SpritePtr->SprColor1,&ColorData1);
  660.              ResetColors(SpritePtr->SprColor2,&ColorData2);
  661.              ResetColors(SpritePtr->SprColor3,&ColorData3);
  662.  
  663.              /*  Reset current pen indicator and RGB gadgets  */
  664.              SetRGBGad(ColorDataPtr->ScreenColor);
  665.  
  666.              CalcSprite(Rp,SpritePtr,&Boxes[0]);     /*  Redraw image  */
  667.              };
  668.           }; 
  669.   break;
  670.  
  671.   case SAVE_SRC :
  672. #ifdef DEMO
  673.        /*  Disable imagry, do request, re-enable imagry  */
  674.        ChangeSprite(Vp,&MySprite,&NullImage[0]);
  675.        Money(WindowPtr);
  676.        ChangeSprite(Vp,&MySprite,&SpritePtr->SpriteData[0]);
  677. #else
  678.        if ( SubNum == SAVE_C_SRC )
  679.           {
  680.           StrPtr = "Save C source data to which file :      ";
  681.           ReturnVal = GetString(WindowPtr,StrPtr,&SaveCName[0]);
  682.           FileName = (char *) &SaveCName[0];
  683.           }
  684.        else if ( SubNum == SAVE_ASM_SRC )
  685.           {
  686.           StrPtr = "Save 68000 source data to which file :  ";
  687.           ReturnVal = GetString(WindowPtr,StrPtr,&SaveAsmName[0]);
  688.           FileName = (char *) &SaveAsmName[0];
  689.           }
  690.        else
  691.           ReturnVal = FALSE;
  692.  
  693.        if ( ReturnVal == TRUE )
  694.           {
  695.           if ( SubNum == SAVE_C_SRC )
  696.              ReturnVal = SaveCSource(SpritePtr,FileName,Mode,&ErrMsg[0]);
  697.           else if ( SubNum == SAVE_ASM_SRC )
  698.              ReturnVal = SaveAsmSource(SpritePtr,FileName,Mode,&ErrMsg[0]);
  699.           if ( ReturnVal == FALSE )
  700.              ErrRequest(WindowPtr,&ErrMsg[0]);
  701.           };
  702. #endif
  703.   break;
  704.  
  705.   case SAVE_BIN :                                    
  706.        StrPtr = "Save binary data to which file :        ";
  707.        ReturnVal = GetString(WindowPtr,StrPtr,&ObjectName[0]);
  708.        if ( ReturnVal == TRUE )
  709.           {
  710.           FileName = (char *) &ObjectName[0];
  711.           ReturnVal = SaveBinary(SpritePtr,FileName,Mode,&ErrMsg[0]);
  712.           if ( ReturnVal == FALSE )
  713.              ErrRequest(WindowPtr,&ErrMsg[0]);
  714.           }; 
  715.   break;
  716.  
  717.  
  718.   case QUIT :
  719.        Quit();             /*  Free memory, sprite, and exit  */
  720.   break;
  721.  
  722.   default :    /*  Just a stub!  */  ;
  723.   };
  724. }
  725.  
  726.  
  727. /*  Handle edit choice from menu  */
  728. HandleEdit(MenuCode,SpritePtr,ColorDataPtr,Mode)
  729. USHORT MenuCode;
  730. struct Sprite *SpritePtr;
  731. struct ColorData *ColorDataPtr;
  732. ULONG Mode;
  733. {
  734. UWORD *SpriteDataPtr;
  735. UBYTE ItemNum,SubNum;
  736.  
  737. /*  Retrieve item number and subnumber chosen  */
  738. ItemNum = ITEMNUM(MenuCode);
  739. SubNum = SUBNUM(MenuCode);
  740.  
  741. switch(ItemNum)
  742.   {
  743.   case FLIP :
  744.        SpriteDataPtr = &SpritePtr->SpriteData[0];
  745.        if ( SubNum == FLIP_XAXIS )
  746.           {
  747.           FlipX(SpritePtr);
  748.           ChangeSprite(Vp,&MySprite,SpriteDataPtr);
  749.           CalcSprite(Rp,SpritePtr,&Boxes[0]);
  750.           }
  751.        else
  752.           {
  753.           FlipY(SpritePtr);
  754.           ChangeSprite(Vp,&MySprite,SpriteDataPtr);
  755.           CalcSprite(Rp,SpritePtr,&Boxes[0]);
  756.           };
  757.   break;                      /*  case FLIP  */
  758.  
  759.   case CLR_DATA :
  760.        ClearSprite(SpritePtr,Mode);      /*  Clear specified range  */
  761.        if ( Mode != EXCEPT )
  762.           CalcSprite(Rp,SpritePtr,&Boxes[0]);
  763.   break;
  764.  
  765.   case CLR_COLOR :
  766.        ClearColor(SpritePtr,Mode);       /*  Clear specified range  */
  767.        if ( Mode != EXCEPT )
  768.           {
  769.           /*  Reset ColorData structures to default colors  */
  770.           ResetColors(SpritePtr->SprColor1,&ColorData1);
  771.           ResetColors(SpritePtr->SprColor2,&ColorData2);
  772.           ResetColors(SpritePtr->SprColor3,&ColorData3);
  773.  
  774.           /*  Reset current pen indicator and RGB gadgets  */
  775.           SetRGBGad(ColorDataPtr->ScreenColor);
  776.           };
  777.   break;                      /*  case CLR_COLOR   */
  778.  
  779.   case NEGATE :
  780.        SpriteDataPtr = &SpritePtr->SpriteData[0];
  781.        Negate(SpritePtr);
  782.        ChangeSprite(Vp,&MySprite,SpriteDataPtr);
  783.        CalcSprite(Rp,SpritePtr,&Boxes[0]);
  784.   break;
  785.  
  786.   default :                   /*  Just a stub!  */;
  787.   };
  788. }                            
  789.  
  790.  
  791. /*  Handle animate choice from menu  */
  792. HandleAnimate(MenuCode,SpritePtr)
  793. USHORT MenuCode;
  794. struct Sprite *SpritePtr;
  795. {
  796. UBYTE ItemNum,SubNum;
  797. int cntr,BufferLen;
  798. char *StrPtr;
  799. BOOL Finished;
  800. ULONG ColorReg,DelayVal;
  801. ULONG RedBits,GreenBits,BlueBits;
  802. UWORD *SpriteDataPtr,SprNum;
  803.  
  804. ItemNum = ITEMNUM(MenuCode);
  805. SubNum = SUBNUM(MenuCode);
  806.  
  807. switch(ItemNum)
  808.   {
  809.   case DEFINE :
  810.        StrPtr = "Please enter your animation sequence :  ";
  811.        GetString(WindowPtr,StrPtr,&AnimBuffer[0]);
  812.        /*  Check if animation sequence is valid  */
  813.        if ( CheckSequence(&AnimBuffer[0]) == FALSE )
  814.           {
  815.           ErrRequest(WindowPtr,"Illegal animation sequence entered!");
  816.           *AnimBuffer = '\0';
  817.           };
  818.   break;
  819.  
  820.   case START :
  821.        /*  Intialize variables for mouse animation  */
  822.        BufferLen = strlen(AnimBuffer);
  823.        DelayVal = GetPropVal(&SpeedGad) + 3;
  824.        Finished = FALSE;
  825.        cntr = 0;
  826.      
  827.        if ( BufferLen == 0 )     /*  Was animation sequence entered?  */
  828.           {
  829.           ErrRequest(WindowPtr,"An animation sequence must be entered!");
  830.           break;
  831.           };
  832.  
  833.        /*  Main animation loop  */
  834.        while ( ! Finished )
  835.          {
  836.          /*  Determine sprite number to animate  */
  837.          SprNum = AnimBuffer[cntr] - 'A';
  838.          SpriteDataPtr = &SpriteArray[SprNum].SpriteData[0];
  839.          CopySprData(SpriteDataPtr,&AnimData[0]);
  840.          ClearPosCtl(&AnimData[0]);
  841.  
  842.          /*  Set pointer color registers from sprite colors  */
  843.          SetPackedRGB(Vp,SpriteArray[SprNum].SprColor1,COLOR17);
  844.          SetPackedRGB(Vp,SpriteArray[SprNum].SprColor2,COLOR18);
  845.          SetPackedRGB(Vp,SpriteArray[SprNum].SprColor3,COLOR19);
  846.  
  847.          /*  Show next sequence and pause for delay  */
  848.          SetPointer(WindowPtr,&AnimData[0],16,16,0,0);
  849.          Delay(DelayVal);
  850.  
  851.          /*  Get next frame  */
  852.          cntr++;
  853.          if ( cntr == BufferLen )  cntr = 0;
  854.  
  855.          /*  Check if it's time to exit  */
  856.          MessagePtr = (struct IntuiMessage *) GetMsg(WindowPtr->UserPort);
  857.          if ( MessagePtr->Class == MOUSEBUTTONS )
  858.             {
  859.             ReplyMsg(MessagePtr);
  860.             Finished = TRUE;
  861.             ClearPointer(WindowPtr);
  862.  
  863.             /*  Restore default pointer colors  */
  864.             SetPackedRGB(Vp,MyPrefs.color17,COLOR17);
  865.             SetPackedRGB(Vp,MyPrefs.color18,COLOR18);
  866.             SetPackedRGB(Vp,MyPrefs.color19,COLOR19);
  867.             };
  868.          };
  869.   break;
  870.  
  871.   default :    /*  Just a stub!  */  ;
  872.   };
  873. }
  874.  
  875.  
  876. /*  SpriteWiz cleanup routine  */
  877. Quit()
  878. {
  879. FreeTempRast(&VertRast,&VertBitMap,GRID_WIDTH,BOX_HEIGHT);
  880. FreeTempRast(&HorizRast,&HorizBitMap,BOX_WIDTH,GRID_HEIGHT);
  881. FreeTempRast(&GRast,&GBitMap,GRID_WIDTH,GRID_HEIGHT);
  882. FreeSprite(SPRITE02);
  883. CloseWindow(WindowPtr);
  884. CloseScreen(ScreenPtr);
  885. exit(0);
  886. }
  887.  
  888.