home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 262.lha / SpriteWizard_v1.0 / SW_IO.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-06-30  |  17.0 KB  |  665 lines
  1. /*  I/O routines for SpriteWiz  --->  By David A. Visage  */
  2.  
  3. #include <stdio.h>
  4. #include <libraries/dos.h>
  5. #include <libraries/dosextens.h>
  6. #include "SW_Menu.def"
  7.  
  8. #define SW_FILE         0xffffffff    /*  Signifies SpriteWiz file  */
  9.  
  10. #define SPRITE_SIZE     36            /*  In UWORD units  */
  11. #define WORDS_PER_LINE  9
  12.  
  13. /*  Defines for sprite limits  */
  14. #define LOW_SPRITE   0
  15. #define HIGH_SPRITE  25
  16. #define MAX_SPRITES  26               /*  Maximum number of sprites  */
  17.  
  18. /*  Defines for minimum and maximum colors allowed  */
  19. #define  MIN_COLOR   0x0000
  20. #define  MAX_COLOR   0x0fff
  21.  
  22. /*  The famous sprite structure  */
  23. struct Sprite
  24.  {
  25.  UWORD SpriteData [SPRITE_SIZE];
  26.  UWORD SprColor1,SprColor2,SprColor3;
  27.  UWORD SpriteNumber;
  28.  };
  29.  
  30. /*  Format masks for save as assembler source  */
  31. #define EquMask    "NUM_SPRITES    equ          %02d \n"
  32. #define ColorMask  "SPR%02dCOL       dc.w      $%03x,$%03x,$%03x \n"
  33. #define DataMask1  "SPR%02dDAT       dc.w      $%04x,$%04x,$%04x,$%04x \n"
  34. #define DataMask2  "               dc.w      $%04x,$%04x,$%04x,$%04x \n"
  35.  
  36. /*  Standard header for C programs  */
  37. char *CHeader [] = {
  38.  "/*  SpriteWiz created data  -->  By David A. Visage  */ \n",
  39.  "\n",
  40.  "#ifndef _STDIO_H \n",
  41.  "#include <stdio.h> \n",
  42.  "#endif \n \n",
  43.  "#ifndef EXEC_TYPES_H \n",
  44.  "#include <exec/types.h> \n",
  45.  "#endif \n \n",
  46.  "#define NUM_SPRITES  (sizeof(MySprInfo) / sizeof(struct SprInfo)) \n", 
  47.  "#define SPRITE_SIZE  36 \n \n",
  48.  "struct SprInfo \n",
  49.  " { \n"
  50.  " UWORD SprColor1,SprColor2,SprColor3; \n",
  51.  " UWORD SpriteData [SPRITE_SIZE]; \n",
  52.  " }; \n \n",
  53.  NULL
  54.  };
  55.  
  56. /*  Header for 68000 programs.  Second element holds equ for NUM_SPRITES  */
  57. char *AsmHeader [] = {
  58.  "*  SpriteWiz created data  -->  By David A. Visage \n",
  59.  "* \n",
  60.  "               IFND EXEC_TYPES_I \n",
  61.  "               include      'exec/types.i' \n",
  62.  "               ENDC \n",
  63.  "* \n",
  64.  NULL,
  65.  "SPRITE_SIZE    equ          72           ; (36 * sizeof(UWORD)) \n",
  66.  "* \n",
  67.  "               STRUCTURE    SprInfo,0 \n",
  68.  "               UWORD        si_SprColor1 \n",
  69.  "               UWORD        si_SprColor2 \n",
  70.  "               UWORD        si_SprColor3 \n",
  71.  "               STRUCT       si_SprData,SPRITE_SIZE \n",
  72.  "               LABEL        si_SizeOf              \n",
  73.  "* \n",
  74.  NULL               /*  EOA - End of array  */
  75.  };
  76.  
  77. /*  Memory size definitions  */
  78. #define WORD_SIZE            sizeof(UWORD)
  79. #define LONG_SIZE            sizeof(ULONG)
  80. #define SPR_STRUCT_SIZE      sizeof(struct Sprite)
  81.  
  82. /*  Declare retun values of functions used  */
  83. extern struct FileHandle *Open();
  84. extern ULONG Read();
  85. extern ULONG Write();
  86. extern BOOL LoadBinary();
  87. extern BOOL SaveBinary();
  88. extern BOOL SaveCSource();
  89. extern BOOL SaveAsmSource();
  90.  
  91. /*  This routine will load sprite binary data  */
  92. BOOL LoadBinary(FirstSprPtr,FileName,ErrMsg)
  93. struct Sprite *FirstSprPtr;
  94. char *FileName;
  95. char *ErrMsg;
  96. {
  97. struct Sprite *NextSprPtr;
  98. struct Sprite TempSprite;
  99. struct FileHandle *InFile;
  100. UBYTE *SrcPtr,*DestPtr;
  101. ULONG HeaderHunk,NumBytes;
  102. UWORD SprNum;
  103. BOOL  Test1,Test2,Test3;
  104. UWORD SprColor1,SprColor2,SprColor3;
  105.  
  106. /*  Try to open input file  */
  107. if ( ( InFile = Open(FileName,MODE_OLDFILE) ) == NULL )
  108.    {
  109.    sprintf(ErrMsg,"Could not open requested file!");
  110.    return(FALSE);
  111.    };
  112.  
  113. /*  Read first ULONG of data file   --->  Header Chunk  */
  114. if ( Read(InFile,&HeaderHunk,LONG_SIZE) != LONG_SIZE )
  115.    {
  116.    sprintf(ErrMsg,"Error reading requested file!");
  117.    Close(InFile);
  118.    return(FALSE);
  119.    };
  120.  
  121. /*  Is this a SpriteWiz file?  */
  122. if ( HeaderHunk != SW_FILE )
  123.    {
  124.    sprintf(ErrMsg,"Requested file not created by SpriteWiz!");
  125.    Close(InFile);
  126.    return(FALSE);
  127.    };
  128.  
  129. /*  Read sprites in till end of file reached  */
  130. while ( TRUE )
  131.   {
  132.   NumBytes = Read(InFile,&TempSprite,SPR_STRUCT_SIZE);   /*  0 when EOF  */
  133.   if ( NumBytes != SPR_STRUCT_SIZE )
  134.      {
  135.      if ( NumBytes == 0 )
  136.         {
  137.         Close(InFile);
  138.         return(TRUE);
  139.         }
  140.      else
  141.         {
  142.         sprintf(ErrMsg,"Error reading requested file!");
  143.         Close(InFile);
  144.         return(FALSE);
  145.         };
  146.      };
  147.  
  148.   Convert(&TempSprite);                /*  Decode encoded data  */
  149.  
  150.   /*  Is sprite number within bounds?  */
  151.   SprNum = TempSprite.SpriteNumber;
  152.   if ( SprNum < LOW_SPRITE || SprNum > HIGH_SPRITE )
  153.      {
  154.      sprintf(ErrMsg,"Illegal sprite number found!");
  155.      Close(InFile);
  156.      return(FALSE);
  157.      };
  158.  
  159.   /*  Get sprite colors  */
  160.   SprColor1 = TempSprite.SprColor1;
  161.   SprColor2 = TempSprite.SprColor2;
  162.   SprColor3 = TempSprite.SprColor3;
  163.  
  164.   /*   Check sprite colors  */
  165.   Test1 = (SprColor1 < MIN_COLOR || SprColor1 > MAX_COLOR );
  166.   Test2 = (SprColor2 < MIN_COLOR || SprColor2 > MAX_COLOR );
  167.   Test3 = (SprColor3 < MIN_COLOR || SprColor3 > MAX_COLOR );
  168.  
  169.   /*  Are sprite colors out of bounds?  */
  170.   if ( Test1 | Test2 | Test3 )
  171.      {
  172.      sprintf(ErrMsg,"Illegal sprite color found!");
  173.      Close(InFile);
  174.      return(FALSE);
  175.      };
  176.  
  177.   /*  Copy last read sprite to area it was saved from  */
  178.   NextSprPtr = FirstSprPtr + SprNum;
  179.   CopySprite(&TempSprite,NextSprPtr);
  180.   };
  181. }
  182.  
  183.  
  184. /*  This routine will save sprite binary data  */
  185. BOOL SaveBinary(SpritePtr,FileName,Mode,ErrMsg)
  186. struct Sprite *SpritePtr;                           /*  Current Sprite  */
  187. char *FileName;
  188. ULONG Mode;
  189. char *ErrMsg;
  190. {
  191. struct Sprite *FirstSprPtr;                /*  Points to first sprite  */
  192. struct Sprite *NextSprPtr;
  193. struct Sprite TempSprite;
  194. struct FileHandle *OutFile;
  195. ULONG HeaderHunk,LowRange,HighRange;
  196. UWORD SprNum;
  197. UBYTE *SrcPtr,*DestPtr;
  198. int i;
  199.  
  200. /*  Try to open output file  */
  201. if ( ( OutFile = Open(FileName,MODE_NEWFILE) ) == NULL )
  202.    {
  203.    sprintf(ErrMsg,"Could not create requested file!");
  204.    return(FALSE);
  205.    };
  206.  
  207. /*  Write first ULONG of data file  --->  Header Chunk  */
  208. HeaderHunk = SW_FILE; 
  209. if ( Write(OutFile,&HeaderHunk,LONG_SIZE) != LONG_SIZE )
  210.    {
  211.    sprintf(ErrMsg,"Error writing requested file!");
  212.    Close(OutFile);
  213.    return(FALSE);
  214.    };
  215.  
  216. /*  Determine loop counter values  */
  217. SprNum = SpritePtr->SpriteNumber;
  218. FirstSprPtr = SpritePtr - SprNum;         /*  scaled by argument size  */
  219. switch(Mode)
  220.   {
  221.   case CURRENT :
  222.        LowRange = HighRange = SprNum;
  223.        NextSprPtr = SpritePtr;
  224.   break;
  225.  
  226.   case ALL :
  227.        LowRange = LOW_SPRITE;
  228.        HighRange = HIGH_SPRITE;
  229.        NextSprPtr = FirstSprPtr;
  230.   break;
  231.  
  232.   case FROM :
  233.        LowRange = SprNum;
  234.        HighRange = HIGH_SPRITE;
  235.        NextSprPtr = SpritePtr;
  236.   break;
  237.  
  238.   case UP_TO :
  239.        LowRange = LOW_SPRITE;
  240.        HighRange = SprNum;
  241.        NextSprPtr = FirstSprPtr;
  242.   break;
  243.  
  244.   case EXCEPT :
  245.        LowRange = LOW_SPRITE;
  246.        HighRange = HIGH_SPRITE;
  247.        NextSprPtr = FirstSprPtr;
  248.   break;
  249.  
  250.   default :
  251.        sprintf(ErrMsg,"Illegal save mode requested!");
  252.        Close(OutFile);
  253.        return(FALSE);
  254.   break;
  255.   };
  256.  
  257. /*  Write all selected sprites  */
  258. for ( i = LowRange; i <= HighRange; i++ )
  259.     {
  260.     if ( Mode == EXCEPT && i == SprNum )
  261.        {
  262.        NextSprPtr++;             /*  Skip current sprite  */
  263.        continue;
  264.        };
  265.  
  266.     /*  Copy current sprite to temporary before encoding  */
  267.     CopySprite(NextSprPtr,&TempSprite);
  268.     Convert(&TempSprite);                      /*  Encode that puppy!  */
  269.  
  270.     /*  Write next Sprite  */
  271.     if ( Write(OutFile,&TempSprite,SPR_STRUCT_SIZE) != SPR_STRUCT_SIZE )
  272.        {
  273.        sprintf(ErrMsg,"Error writing requested file!");
  274.        Close(OutFile);
  275.        return(FALSE);
  276.        };
  277.  
  278.     NextSprPtr++;           /*  Get pointer to next sprite  */
  279.     };
  280.  
  281. Close(OutFile);
  282. return(TRUE);
  283. }
  284.  
  285.  
  286. /*  This routine will save sprite data as C source code  */
  287. BOOL SaveCSource(SpritePtr,FileName,Mode,ErrMsg)
  288. struct Sprite *SpritePtr;                           /*  Current Sprite  */
  289. char *FileName;
  290. ULONG Mode;
  291. char *ErrMsg;
  292. {
  293. struct Sprite *FirstSprPtr;                /*  Points to first sprite  */
  294. struct Sprite *NextSprPtr;
  295. struct FileHandle *OutFile;
  296. ULONG LowRange,HighRange;
  297. ULONG Len,NextSprite;
  298. UWORD SprNum,NumSprites;
  299. UWORD *SpriteDataPtr,NextWord;
  300. UWORD SprColor1,SprColor2,SprColor3;
  301. UWORD TempSprite [SPRITE_SIZE];
  302. char OutStr [80];
  303. char *StrPtr;
  304. BOOL Finished;
  305. int i,j,cntr;
  306.  
  307. /*  Try to open output file  */
  308. if ( ( OutFile = Open(FileName,MODE_NEWFILE) ) == NULL )
  309.    {
  310.    sprintf(ErrMsg,"Could not create requested file!");
  311.    return(FALSE);
  312.    };
  313.  
  314. /*  Determine loop counter values and number of sprites  */
  315. SprNum = SpritePtr->SpriteNumber;
  316. FirstSprPtr = SpritePtr - SprNum;          /*  Scaled by argument size  */
  317. switch(Mode)
  318.   {
  319.   case CURRENT :
  320.        LowRange = HighRange = SprNum;
  321.        NumSprites = 1;
  322.        NextSprPtr = SpritePtr;
  323.   break;
  324.  
  325.   case ALL :
  326.        LowRange = LOW_SPRITE;
  327.        HighRange = HIGH_SPRITE;
  328.        NumSprites = MAX_SPRITES;
  329.        NextSprPtr = FirstSprPtr;
  330.   break;
  331.  
  332.   case FROM :
  333.        LowRange = SprNum;
  334.        HighRange = HIGH_SPRITE;
  335.        NumSprites = MAX_SPRITES - SprNum;
  336.        NextSprPtr = SpritePtr;
  337.   break;
  338.  
  339.   case UP_TO :
  340.        LowRange = LOW_SPRITE;
  341.        HighRange = SprNum;
  342.        NumSprites = SprNum + 1;
  343.        NextSprPtr = FirstSprPtr;
  344.   break;
  345.  
  346.   case EXCEPT :
  347.        LowRange = LOW_SPRITE;
  348.        HighRange = HIGH_SPRITE;
  349.        NumSprites = MAX_SPRITES - 1;
  350.        NextSprPtr = FirstSprPtr;
  351.   break;
  352.  
  353.   default :
  354.        sprintf(ErrMsg,"Illegal save mode requested!");
  355.        Close(OutFile);
  356.        return(FALSE);
  357.   break;
  358.   };
  359.  
  360. /*  Write sprite header info  */
  361. Finished = FALSE;
  362. cntr = 0;
  363. while ( ! Finished )
  364.   {
  365.   StrPtr = CHeader[cntr];
  366.   if ( *StrPtr == NULL )
  367.      Finished = TRUE;
  368.   else
  369.      {
  370.      Len = (ULONG) strlen(StrPtr);
  371.      if ( Write(OutFile,StrPtr,Len) != Len )
  372.         {
  373.         sprintf(ErrMsg,"Error writing requested file!");
  374.         Close(OutFile);
  375.         return(FALSE);
  376.         };
  377.      cntr++;          /*  Get next CHeader string  */
  378.      };
  379.   };                   /*  End while  */
  380.  
  381. /*  Write sprite declare info  */
  382. sprintf(OutStr,"struct SprInfo MySprInfo [] = { \n",NULL);
  383. Len = (ULONG) strlen(OutStr);
  384. if ( Write(OutFile,OutStr,Len) != Len )
  385.    {
  386.    sprintf(ErrMsg,"Error writing requested file!");
  387.    Close(OutFile);
  388.    return(FALSE);
  389.    };
  390.  
  391. /*  Write each selected sprite  */
  392. NextSprite = 0;
  393. for ( i = LowRange; i <= HighRange; i++ )
  394.     {
  395.     if ( Mode == EXCEPT && i == SprNum )
  396.        {
  397.        NextSprPtr++;       /*  Skip current sprite  */
  398.        continue;
  399.        };
  400.  
  401.     /*  Get next sprite colors  */
  402.     SprColor1 = NextSprPtr->SprColor1;
  403.     SprColor2 = NextSprPtr->SprColor2;
  404.     SprColor3 = NextSprPtr->SprColor3;
  405.  
  406.     /*  Write sprite colors comments  */
  407.     sprintf(OutStr,"\n /*  Colors for sprite %02d  */ \n",NextSprite);
  408.     Len = (ULONG) strlen(OutStr);
  409.     if ( Write(OutFile,OutStr,Len) != Len )
  410.        {
  411.        sprintf(ErrMsg,"Error writing requested file!");
  412.        Close(OutFile);
  413.        return(FALSE);
  414.        };
  415.  
  416.     /*  Write actual sprite colors  */
  417.     sprintf(OutStr,"0x%03x,0x%03x,0x%03x, \n",SprColor1,SprColor2,SprColor3);
  418.     Len = (ULONG) strlen(OutStr);
  419.     if ( Write(OutFile,OutStr,Len) != Len )
  420.        {
  421.        sprintf(ErrMsg,"Error writing requested file!");
  422.        Close(OutFile);
  423.        return(FALSE);
  424.        };
  425.  
  426.     /*  Clear sprite PosCtl and attached data  */
  427.     SpriteDataPtr = &NextSprPtr->SpriteData[0];
  428.     CopySprData(SpriteDataPtr,&TempSprite[0]);
  429.     ClearPosCtl(&TempSprite);
  430.  
  431.     /*  Write sprite data comments  */
  432.     sprintf(OutStr,"/*  Data for sprite %02d  */ \n",NextSprite);
  433.     Len = (ULONG) strlen(OutStr);
  434.     if ( Write(OutFile,OutStr,Len) != Len )
  435.        {
  436.        sprintf(ErrMsg,"Error writing requested file!");
  437.        Close(OutFile);
  438.        return(FALSE);
  439.        };
  440.  
  441.     /*  Write sprite data  */
  442.     cntr = 0;
  443.     for ( j = 0; j < SPRITE_SIZE; j++ )
  444.         {
  445.         /*  Is this the last word of the last sprite?  */
  446.         NextWord = TempSprite [j];
  447.         if ( i == HighRange && j == (SPRITE_SIZE - 1) )
  448.            sprintf(OutStr,"0x%04x }; \n \n",NextWord);
  449.         else
  450.            {
  451.            /*  Time to write a return?  */
  452.            if ( cntr == (WORDS_PER_LINE - 1) )
  453.               {
  454.               cntr = 0;
  455.               sprintf(OutStr,"0x%04x, \n",NextWord);
  456.               }
  457.            else
  458.               {
  459.               cntr++;
  460.               sprintf(OutStr,"0x%04x,",NextWord);
  461.               };
  462.            };
  463.  
  464.         /*  Write data line of current sprite  */
  465.         Len = (ULONG) strlen(OutStr);
  466.         if ( Write(OutFile,OutStr,Len) != Len )
  467.            {
  468.            sprintf(ErrMsg,"Error writing requested file!");
  469.            Close(OutFile);
  470.            return(FALSE);
  471.            };
  472.         };                  /*  End j  */
  473.  
  474.     /*  Get next sprite pointer and number  */
  475.     NextSprPtr++;           
  476.     NextSprite++;
  477.     };                      /*  End i  */
  478.  
  479. Close(OutFile);
  480. return(TRUE);
  481. }
  482.  
  483.  
  484. /*  This routine will save sprite data as assembler source code  */
  485. BOOL SaveAsmSource(SpritePtr,FileName,Mode,ErrMsg)
  486. struct Sprite *SpritePtr;                           /*  Current Sprite  */
  487. char *FileName;
  488. ULONG Mode;
  489. char *ErrMsg;
  490. {
  491. struct Sprite *FirstSprPtr;                /*  Points to first sprite  */
  492. struct Sprite *NextSprPtr;
  493. struct FileHandle *OutFile;
  494. ULONG LowRange,HighRange;
  495. ULONG Len,NextSprite;
  496. UWORD SprNum,NumSprites,*SpriteDataPtr;
  497. UWORD Word1,Word2,Word3,Word4;
  498. UWORD SprColor1,SprColor2,SprColor3;
  499. UWORD TempSprite [SPRITE_SIZE];
  500. char OutStr [80];
  501. char *StrPtr;
  502. BOOL Finished;
  503. int i,j,cntr;
  504.  
  505. /*  Try to open output file  */
  506. if ( ( OutFile = Open(FileName,MODE_NEWFILE) ) == NULL )
  507.    {
  508.    sprintf(ErrMsg,"Could not create requested file!");
  509.    return(FALSE);
  510.    };
  511.  
  512. /*  Determine loop counter values and number of sprites  */
  513. SprNum = SpritePtr->SpriteNumber;
  514. FirstSprPtr = SpritePtr - SprNum;          /*  Scaled by argument size  */
  515. switch(Mode)
  516.   {
  517.   case CURRENT :
  518.        LowRange = HighRange = SprNum;
  519.        NumSprites = 1;
  520.        NextSprPtr = SpritePtr;
  521.   break;
  522.  
  523.   case ALL :
  524.        LowRange = LOW_SPRITE;
  525.        HighRange = HIGH_SPRITE;
  526.        NumSprites = MAX_SPRITES;
  527.        NextSprPtr = FirstSprPtr;
  528.   break;
  529.  
  530.   case FROM :
  531.        LowRange = SprNum;
  532.        HighRange = HIGH_SPRITE;
  533.        NumSprites = MAX_SPRITES - SprNum;
  534.        NextSprPtr = SpritePtr;
  535.   break;
  536.  
  537.   case UP_TO :
  538.        LowRange = LOW_SPRITE;
  539.        HighRange = SprNum;
  540.        NumSprites = SprNum + 1;
  541.        NextSprPtr = FirstSprPtr;
  542.   break;
  543.  
  544.   case EXCEPT :
  545.        LowRange = LOW_SPRITE;
  546.        HighRange = HIGH_SPRITE;
  547.        NumSprites = MAX_SPRITES - 1;
  548.        NextSprPtr = FirstSprPtr;
  549.   break;
  550.  
  551.   default :
  552.        sprintf(ErrMsg,"Illegal save mode requested!");
  553.        Close(OutFile);
  554.        return(FALSE);
  555.   break;
  556.   };
  557.  
  558. /*  Put EQU for number of sprites in sixth element of AsmHeader  */
  559. sprintf(OutStr,EquMask,NumSprites);
  560. AsmHeader[6] = OutStr;
  561.  
  562. /*  Write sprite header info  */
  563. Finished = FALSE;
  564. cntr = 0;
  565. while ( ! Finished )
  566.   {
  567.   StrPtr = AsmHeader[cntr];
  568.   if ( *StrPtr == NULL )
  569.      Finished = TRUE;
  570.   else
  571.      {
  572.      Len = (ULONG) strlen(StrPtr);
  573.      if ( Write(OutFile,StrPtr,Len) != Len )
  574.         {
  575.         sprintf(ErrMsg,"Error writing requested file!");
  576.         Close(OutFile);
  577.         return(FALSE);
  578.         };
  579.      cntr++;          /*  Get next AsmHeader string  */
  580.      };
  581.   };                   /*  End while  */
  582.  
  583. /*  Write each selected sprite as 68000 data  */
  584. NextSprite = 0;
  585. for ( i = LowRange; i <= HighRange; i++ )
  586.     {
  587.     if ( Mode == EXCEPT && i == SprNum )
  588.        {
  589.        NextSprPtr++;       /*  Skip current sprite  */
  590.        continue;
  591.        };
  592.  
  593.     /*  Get next sprite colors  */
  594.     SprColor1 = NextSprPtr->SprColor1;
  595.     SprColor2 = NextSprPtr->SprColor2;
  596.     SprColor3 = NextSprPtr->SprColor3;
  597.  
  598.     /*  Write sprite colors  */
  599.     sprintf(OutStr,ColorMask,NextSprite,SprColor1,SprColor2,SprColor3);
  600.     Len = (ULONG) strlen(OutStr);
  601.     if ( Write(OutFile,OutStr,Len) != Len )
  602.        {
  603.        sprintf(ErrMsg,"Error writing requested file!");
  604.        Close(OutFile);
  605.        return(FALSE);
  606.        };
  607.  
  608.     /*  Clear sprite PosCtl and attached data  */
  609.     SpriteDataPtr = &NextSprPtr->SpriteData[0];
  610.     CopySprData(SpriteDataPtr,&TempSprite[0]);
  611.     ClearPosCtl(&TempSprite);
  612.  
  613.     /*  Write sprite data  */
  614.     cntr = 0;
  615.     for ( j = 0; j < SPRITE_SIZE; j += 4 )
  616.         {
  617.         /*  Get the next four words of the current sprite  */
  618.         Word1 = TempSprite [j+0]; Word2 = TempSprite [j+1];
  619.         Word3 = TempSprite [j+2]; Word4 = TempSprite [j+3];
  620.  
  621.         if ( j == 0 )     /*  First line?  */
  622.             sprintf(OutStr,DataMask1,NextSprite,Word1,Word2,Word3,Word4);
  623.         else
  624.             sprintf(OutStr,DataMask2,Word1,Word2,Word3,Word4);
  625.             
  626.         /*  Write data line of current sprite  */
  627.         Len = (ULONG) strlen(OutStr);
  628.         if ( Write(OutFile,OutStr,Len) != Len )
  629.            {
  630.            sprintf(ErrMsg,"Error writing requested file!");
  631.            Close(OutFile);
  632.            return(FALSE);
  633.            };
  634.         };                  /*  End j  */
  635.  
  636.     /*  Get next sprite pointer and number  */
  637.     NextSprPtr++;           
  638.     NextSprite++;
  639.     };                      /*  End i  */
  640.  
  641. Close(OutFile);
  642. return(TRUE);
  643. }
  644.  
  645.  
  646. /*  This subroutine will encode and decode a Sprite structure  */
  647. Convert(SpritePtr)
  648. struct Sprite *SpritePtr;
  649. {
  650. UWORD *WordPtr,NextWord;
  651. int i;
  652.  
  653. /*  This code is a increasing XOR encryption scheme  */
  654. WordPtr = (UWORD *) SpritePtr;
  655. for ( i = 0; i < SPR_STRUCT_SIZE; i += WORD_SIZE )
  656.     {
  657.     NextWord = *WordPtr;
  658.     NextWord ^= i;
  659.     *WordPtr = NextWord;
  660.     WordPtr++;                    /*  Get next word of sprite  */
  661.     };
  662. }
  663.  
  664.     
  665.