home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 029.lha / Vsprite / vsprite.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-04-03  |  16.9 KB  |  607 lines
  1. /* vsprite.final.c, merged with its support files */
  2.  
  3. /* execute makesimple vsprite.final ; Amiga C 1.1 (Lattice 3.03) */
  4.  
  5. #include "exec/types.h"
  6. #include "intuition/intuition.h"
  7. #include "graphics/sprite.h"
  8. #include "exec/memory.h"
  9. #include "graphics/gels.h"
  10.  
  11. /* ask system to create and manage MAXSP vsprites */
  12. #define MAXSP 28 
  13.  
  14. /* define possible speeds for vsprites in counts per vblank */
  15.  
  16. SHORT speed[] = { 1, 2, -1, -2 };
  17.  
  18. SHORT xmove[MAXSP], ymove[MAXSP];      
  19.                 /* sprite directions of movement */
  20. struct VSprite *vsprite[MAXSP];    /* MAXSP simple sprites */
  21. struct VSprite *vspr;        /* pointer to a sprite */
  22. short maxgot;            /* max # of sprites we created */
  23.  
  24. struct GelsInfo mygelsinfo;    /* the window's RastPort needs one
  25.                  * of these in order to do VSprites */
  26.  
  27. struct Window *w;    /* pointer to a Window   */
  28. struct RastPort *rp;    /* pointer to a RastPort */
  29. struct Screen *s;    /* a pointer to a Screen */    
  30. struct ViewPort *vp;    /* pointer to a ViewPort */
  31.  
  32. struct Window *OpenWindow();
  33. struct Screen *OpenScreen();
  34. LONG GfxBase;
  35. LONG IntuitionBase;
  36.  
  37. /* 18 words of sprite data = 9 lines of sprite data */
  38.  
  39. UWORD sprite_data[ ] = {
  40.             0x0fc3, 0x0000, /* image data line 1*/
  41.             0x3ff3, 0x0000, /* image data line 2*/
  42.             0x30c3, 0x0000, /* image data line 3*/
  43.             0x0000, 0x3c03, /* image data line 4*/
  44.             0x0000, 0x3fc3, /* image data line 5*/
  45.             0x0000, 0x03c3, /* image data line 6*/
  46.             0xc033, 0xc033, /* image data line 7*/
  47.             0xffc0, 0xffc0, /* image data line 8*/
  48.             0x3f03, 0x3f03, /* image data line 9*/
  49.             };
  50. UWORD *sprdata;
  51.  
  52. void movesprites()
  53. {
  54.     short i;
  55.  
  56.     for (i=0; i<maxgot; i++)
  57.     {
  58.         vspr = vsprite[i];
  59.  
  60.         vspr->X = xmove[i]+vspr->X;
  61.         vspr->Y = ymove[i]+vspr->Y;
  62.  
  63.         /* move the sprites ... here. */
  64.  
  65.         if(vspr->X >= 300 || vspr->X <= 0) xmove[i]=-xmove[i];
  66.         if(vspr->Y >= 190 || vspr->Y <= 0) ymove[i]=-ymove[i];
  67.         
  68.     }
  69.     SortGList(rp);    /* get the list in order */
  70.     DrawGList(rp, vp);    /* create the sprite instructions */
  71.  
  72.     MakeScreen(s);  /* ask Intuition to pull it all together */
  73.     RethinkDisplay(); /* and to show us what we have now. */
  74. }
  75.  
  76.  
  77. #define AZCOLOR 1
  78. #define WHITECOLOR 2
  79.  
  80. #define WC WINDOWCLOSE
  81. #define WS WINDOWSIZING
  82. #define WDP WINDOWDEPTH
  83. #define WDR WINDOWDRAG
  84.  
  85. #define NORMALFLAGS (WC|WS|WDP)
  86. /* Did not use windowdrag because dont want screen to be moved. */
  87.  
  88. /* Allow window sizing so user can decrease size of window, then
  89.  * increase it again, thus erasing the background text and more
  90.  * easily see that some vsprites wink out and into existence when
  91.  * too many sprites are on a single horizontal plane and the
  92.  * vsprite machine runs out of sprites to assign.
  93.  */
  94.  
  95. /* myfont1 specifies characteristics of the default font;
  96.  * this case selects the 80 column font that displays as 
  97.  * 40 columns in low resolution mode.
  98.  */    
  99. struct TextAttr myfont1 = { "topaz.font", 8, 0, 0 };
  100.     
  101. struct NewScreen myscreen1 = {
  102.     0, 0,           /* LeftEdge, TopEdge ... where to put screen */
  103.     320, 200,     /* Width, Height ... size of the screen */
  104.     5,          /* 5 planes Depth, means 2 to the 5th or 
  105.                * 32 different colors to choose from once 
  106.               * the screen is opened.
  107.                */
  108.     1, 0,          /* DetailPen, BlockPen */
  109.     SPRITES,    /* ViewModes ... value of 0 = low resolution */
  110.     CUSTOMSCREEN,      /* Type of screen */
  111.     &myfont1,     /* Font to be used as default for this screen */
  112.     "32 Color Test", /* DefaultTitle for its title bar */
  113.     NULL,         /* screens user-gadgets, always NULL, ignored */
  114.     NULL };
  115.             /* address of custom bitmap for screen, 
  116.                 * not used in this example 
  117.                 */
  118.  
  119.  
  120. struct NewWindow myWindow = {
  121.     0,         /* LeftEdge for window measured in pixels, 
  122.                at the current horizontal resolution,
  123.                from the leftmost edge of the Screen */
  124.     0,        /* TopEdge for window is measured in lines 
  125.                from the top of the current Screen.   */
  126.     320, 185,    /* Width, Height of this window */ 
  127.     0,           /* DetailPen - what pen number is to be 
  128.                used to draw the borders of the window */ 
  129.     1,        /* BlockPen - what pen number is to be 
  130.                used to draw system generated window
  131.                gadgets */
  132.             /* (for DetailPen and BlockPen, the value
  133.                 of -1 says "use the default value")  */
  134.     CLOSEWINDOW,     /* simplesprite program used INTUITICKS also */
  135.             /* IDCMP Flags */
  136.     NORMALFLAGS | GIMMEZEROZERO | ACTIVATE,
  137.             /* Window Flags:  (see below for more info) */
  138.     NULL,        /* FirstGadget */
  139.     NULL,        /* CheckMark   */
  140.     "Click Close Gadget To Stop",    /* Window title */
  141.     NULL,        /* Pointer to Screen if not workbench */
  142.     NULL,        /* Pointer to BitMap if a SUPERBITMAP window */
  143.     320, 10,    /* minimum width, minimum height */
  144.     320, 200,    /* maximum width, maximum height */
  145.     CUSTOMSCREEN
  146.     };
  147.  
  148. #include "graphics/gfxmacros.h"
  149.  
  150. /* #include "event1.c"    */
  151. /* gets the event handler */
  152. /* event1.c */
  153.  
  154. HandleEvent(code)
  155.     LONG code;    /* provided by main */
  156. {
  157.     switch(code) 
  158.     {
  159.     case CLOSEWINDOW:
  160.         return(0);
  161.         break;
  162.     case INTUITICKS:    /* could have done much faster
  163.                  * but what the heck, this is
  164.                  * shorter for test purposes
  165.                  */
  166.         movesprites();    /* 10 moves per second; test */
  167.         default:
  168.             break;
  169.     }
  170. return(1);
  171. }
  172.  
  173. UWORD mycolortable[] = {
  174.  
  175.     0x0000, 0x0e30, 0x0fff, 0x0b40, 0x0fb0, 0x0bf0,
  176.     0x05d0, 0x0ed0, 0x07df, 0x069f, 0x0c0e,
  177.     0x0f2e, 0x0feb, 0x0c98, 0x0bbb, 0x07df, 
  178.  
  179.     0x0000, 0x0e30, 0x0fff, 0x0b40, 
  180.     0x0fb0, 0x0bf0, 0x05d0, 0x0ed0, 
  181.     0x07df, 0x069f, 0x0c0e, 0x0f2e, 
  182.     0x0feb, 0x0c98, 0x0bbb, 0x07df 
  183.     };
  184.  
  185.     /* black, red, white, fire-engine red, orange, yellow,
  186.     lime green, green, aqua, dark blue, purple,
  187.     violet, tan, brown, gray, skyblue, (everything again) */
  188.  
  189. UWORD colorset0[ ] = { 0x0e30, 0xffff, 0x0b40 }; /* same as colors 17-19 */
  190. UWORD colorset1[ ] = { 0x0bf0, 0x05d0, 0x0ed0 }; /* 21-23 */
  191. UWORD colorset2[ ] = { 0x069f, 0x0c0e, 0x0f2e }; /* 25-27 */
  192. UWORD colorset3[ ] = { 0x0c98, 0x0bbb, 0x07df }; /* 29-31 */
  193. UWORD *colorset[ ] = {
  194.             colorset0, colorset1,
  195.             colorset2, colorset3 };
  196. int choice;
  197. char *numbers[] = { "17","18","19",
  198.             "20","21","22","23",
  199.             "24","25","26","27",
  200.             "28","29","30","31" };
  201.  
  202. /* #include "ram:purgegels.c" */
  203. /* purgegels.c */
  204.  
  205. /*
  206.  * Use this to get rid of the gels stuff when it is not needed any more.
  207.  * You must have allocated the gels info stuff (use the ReadyGels routine).
  208.  */
  209.  
  210. void PurgeGels(g)
  211. struct GelsInfo *g;
  212. {
  213.    if (g->collHandler != NULL)
  214.       FreeMem(g->collHandler, sizeof(struct collTable));
  215.    if (g->lastColor != NULL)
  216.       FreeMem(g->lastColor, sizeof(LONG) * 8);
  217.    if (g->nextLine != NULL)
  218.       FreeMem(g->nextLine, sizeof(WORD) * 8);
  219.    if (g->gelHead != NULL)
  220.       FreeMem(g->gelHead, sizeof(struct VSprite));
  221.    if (g->gelTail != NULL)
  222.       FreeMem(g->gelTail, sizeof(struct VSprite));
  223. }
  224.  
  225.  
  226. /* Deallocate memory which has been allocated by the routines Makexxx. */
  227. /* Assumes images and imageshadow deallocated elsewhere. */
  228.  
  229. void DeleteGel(v)
  230. struct VSprite *v;
  231. {
  232.    if (v != NULL) {
  233.       if (v->VSBob != NULL) {
  234.          if (v->VSBob->SaveBuffer != NULL) {
  235.             FreeMem(v->VSBob->SaveBuffer, sizeof(SHORT) * v->Width
  236.                   * v->Height * v->Depth);
  237.          }
  238.          if (v->VSBob->DBuffer != NULL) {
  239.             if (v->VSBob->DBuffer->BufBuffer != 0) {
  240.                FreeMem(v->VSBob->DBuffer->BufBuffer,
  241.                      sizeof(SHORT) * v->Width * v->Height * v->Depth);
  242.             }
  243.             FreeMem(v->VSBob->DBuffer, sizeof(struct DBufPacket));
  244.          }
  245.          FreeMem( v->VSBob, sizeof(struct Bob));
  246.       }
  247.       if (v->CollMask != NULL) {
  248.          FreeMem(v->CollMask, sizeof(WORD) * v->Height * v->Width);
  249.       }
  250.       if (v->BorderLine != NULL) {
  251.          FreeMem(v->BorderLine, sizeof(WORD) * v->Width);
  252.       }
  253.       FreeMem(v, sizeof(struct VSprite));
  254.    }
  255. }
  256.  
  257. /* end of purgegels.c */
  258.  
  259. /* #include "ram:readygels.c" */
  260. /* readygels.c */
  261.  
  262. struct VSprite *SpriteHead = NULL;
  263. struct VSprite *SpriteTail = NULL;
  264.  
  265. void border_dummy()    /* a dummy collision routine */
  266. { 
  267.    return; 
  268. }
  269.  
  270. ReadyGels(g, r)
  271. struct RastPort *r;
  272. struct GelsInfo *g;
  273. {
  274.    /* Allocate head and tail of list. */
  275.    if ((SpriteHead = (struct VSprite *)AllocMem(sizeof
  276.          (struct VSprite), MEMF_PUBLIC | MEMF_CLEAR)) == 0) 
  277.    {
  278.       return(-1);
  279.    }
  280.  
  281.    if ((SpriteTail = (struct VSprite *)AllocMem(sizeof
  282.          (struct VSprite), MEMF_PUBLIC | MEMF_CLEAR)) == 0) 
  283.    {
  284.       FreeMem(SpriteHead, sizeof(struct VSprite));
  285.       return(-2);
  286.    }
  287.    g->sprRsrvd = 0xFC;    /* do not use sprites 0 or 1. */
  288.  
  289.    if ((g->nextLine = (WORD *)AllocMem(sizeof(WORD) * 8,
  290.          MEMF_PUBLIC | MEMF_CLEAR)) == NULL) 
  291.    {
  292.       FreeMem(SpriteHead, sizeof(struct VSprite));
  293.       FreeMem(SpriteTail, sizeof(struct VSprite));
  294.       return(-3);
  295.    }
  296.  
  297.   if ((g->lastColor = (WORD **)AllocMem(sizeof(LONG) * 8,
  298.          MEMF_PUBLIC | MEMF_CLEAR)) == NULL) 
  299.    {
  300.       FreeMem(g->nextLine,8 * sizeof(WORD));
  301.       FreeMem(SpriteHead, sizeof(struct VSprite));
  302.       FreeMem(SpriteTail, sizeof(struct VSprite));
  303.       return(-4);
  304.    }
  305.  
  306.   /* Next we prepare a table of pointers to the routines which should
  307.    * be performed when DoCollision senses a collision.  This
  308.    * declaration may not be necessary for a basic vsprite with
  309.    * no collision detection implemented, but then it makes for
  310.    * a complete example.
  311.    */
  312.    if ((g->collHandler = (struct collTable *)AllocMem(sizeof(struct
  313.          collTable), MEMF_PUBLIC | MEMF_CLEAR)) == NULL) 
  314.    {
  315.       FreeMem(g->lastColor, 8 * sizeof(LONG));
  316.       FreeMem(g->nextLine,8 * sizeof(WORD));
  317.       FreeMem(SpriteHead, sizeof(struct VSprite));
  318.       FreeMem(SpriteTail, sizeof(struct VSprite));
  319.       return(-5);
  320.    }
  321.  
  322.   /* When any part of the object touches or passes across
  323.    * this boundary, it will cause the boundary collision
  324.    * routine to be called.  This is at smash[0] in the
  325.    * collision handler table and is called only if
  326.    * DoCollision is called.
  327.    */
  328.    g->leftmost = 0;
  329.    g->rightmost = r->BitMap->BytesPerRow * 8 - 1;
  330.    g->topmost = 0;
  331.    g->bottommost = r->BitMap->Rows - 1;
  332.  
  333.    r->GelsInfo = g;  /* Link together the two structures */
  334.  
  335.    InitGels(SpriteHead, SpriteTail, g );
  336.  
  337.   /* Pointers initialized to the dummy sprites which will be
  338.    * used by the system to keep track of the animation system.
  339.    */
  340.    SetCollision(0, border_dummy, g);
  341.    WaitTOF();
  342.    return(0);    /* a return value of 0 says all ok, any 
  343.          * negative value tells you when it failed.
  344.          * (see the listing as to what the routine
  345.          * was trying to do... all failures are
  346.          * due to out of memory conditions).
  347.          */
  348. }
  349.  
  350.  
  351. /* end of readygels.c */
  352.  
  353. /* #include "ram:MakeVSprite.c" */
  354. /* MakeVSprite.c */
  355.  
  356. struct VSprite *MakeVSprite(lineheight, image, colorset, x, y,
  357.                 wordwidth, imagedepth, flags)
  358. SHORT lineheight;    /* How tall is this vsprite? */
  359. WORD *image;        /* Where is the vsprite image data, should be
  360.                twice as many words as the value of lineheight */
  361. WORD *colorset;        /* Where is the set of three words which describes
  362.                the colors that this vsprite can take on? */
  363. SHORT x, y;        /* What is its initial onscreen position? */
  364. SHORT wordwidth, imagedepth, flags;
  365. {
  366.    struct VSprite *v;    /* Make a pointer to the vsprite structure which
  367.                this routine dynamically allocates */
  368.  
  369.    if ((v = (struct VSprite *)AllocMem(sizeof(struct VSprite),
  370.          MEMF_PUBLIC | MEMF_CLEAR)) == 0) 
  371.    {
  372.       return(0);
  373.    }
  374.  
  375.    v->Flags = flags;    /* Is this a vsprite, not a bob? */
  376.  
  377.    v->Y = y;        /* Establish initial position relative to */
  378.    v->X = x;        /* the Display coordinates. */
  379.  
  380.    v->Height = lineheight;    /* The Caller says how high it is. */
  381.    v->Width = wordwidth;   /* A vsprite is always 1 word (16 bits) wide. */
  382.  
  383.   /* There are two kinds of depth... the depth of the image itself, and the
  384.    * depth of the playfield into which it will be drawn. The image depth
  385.    * says how much data space will be needed to store an image if it's
  386.    * dynamically allocated. The playfield depth establishes how much space
  387.    * will be needed to save and restore the background when a bob is drawn.
  388.    * A vsprite is always 2 planes deep, but if it's being used to make a
  389.    * bob, it may be deeper...
  390.    */
  391.  
  392.    v->Depth = imagedepth;
  393.  
  394.   /* Assume that the caller at least has a default boundary collision
  395.    * routine.... bit 1 of this mask is reserved for boundary collision
  396.    * detect during DoCollision(). The only collisions reported will be
  397.    * with the borders. The caller can change all this later.
  398.    */
  399.  
  400.    v->MeMask = 1;
  401.    v->HitMask = 1;
  402.  
  403.    v->ImageData = image;    /* Caller says where to find the image. */
  404.  
  405.   /* Show system where to find a mask which is a squished down version
  406.    * of the vsprite (allows for fast horizontal border collision detect).
  407.    */
  408.  
  409.    if ((v->BorderLine = (WORD *)AllocMem((sizeof(WORD)*wordwidth),
  410.          MEMF_PUBLIC | MEMF_CLEAR)) == 0) 
  411.    {
  412.        FreeMem(v, sizeof(struct VSprite)); 
  413.        return(0);
  414.    }
  415.  
  416.   /* Show system where to find the mask which contains a 1 bit for any
  417.    * position in the object in any plane where there is a 1 bit (all planes
  418.    * OR'ed together).
  419.    */
  420.  
  421.    if ((v->CollMask = (WORD *)AllocMem(sizeof(WORD)*lineheight*wordwidth,
  422.          MEMF_CHIP | MEMF_CLEAR)) == 0) 
  423.    {
  424.        FreeMem(v, sizeof(struct VSprite)); 
  425.        FreeMem(v->BorderLine, wordwidth * sizeof(WORD));
  426.         return(0);
  427.    }
  428.  
  429.   /* This isn't used for a Bob, just a VSprite. It's where the
  430.    * Caller says where to find the VSprites colors.
  431.    */
  432.    v->SprColors = colorset;
  433.  
  434.    /* These aren't used for a VSprite, and MakeBob'll do set up for Bob. */
  435.    v->PlanePick  = 0x00;
  436.    v->PlaneOnOff = 0x00;
  437.  
  438.    InitMasks(v);    /* Create the collMask and borderLine */    
  439.    return(v);
  440. }
  441. /* end of MakeVSprite.c */
  442.  
  443. int main()
  444. {
  445.     struct IntuiMessage *msg;
  446.     LONG result;
  447.     SHORT k, j, x, y, error;
  448.     UWORD *src, *dest;    /* for copying sprite data to RAM */
  449.  
  450.     GfxBase = OpenLibrary("graphics.library",0);
  451.  
  452.     IntuitionBase = OpenLibrary("intuition.library",0);
  453.     /* (error checking left out for brevity here) */
  454.  
  455.     s = OpenScreen(&myscreen1);  /* try to open it */
  456.     if(s == 0)
  457.     {
  458.             printf("Can't open myscreen1\n");
  459.             exit(10);
  460.     }
  461.     myWindow.Screen = s;    /* say where screen is located */
  462.  
  463.     ShowTitle(s, FALSE);    /* Dont let screen be dragged down...*/
  464.  
  465.     w = OpenWindow(&myWindow);
  466.     if(w == 0)
  467.     {
  468.         printf("Window didn't open!\n");
  469.         CloseScreen(s);
  470.         exit(20);
  471.     }
  472.     vp = &(s->ViewPort);
  473.     /* set the colors for this viewport */
  474.  
  475.     LoadRGB4(vp, &mycolortable[0], 32);
  476.     rp = w->RPort;
  477.         /* Now wait for a message to arrive from Intuition 
  478.          * (task goes to sleep while waiting for the message) 
  479.          */
  480.  
  481.     /* Write Text using sprite colors so that demo can show
  482.      * how the vsprite machine stuffs the colors as it goes
  483.      * down the screen.  Thus if using vsprites, user should
  484.      * avoid using the color registers that the vsprites use.
  485.      */
  486.  
  487.     /* Notice also that color numbers 17-19 are untouched.  
  488.      * That is because of the sprResrvd=0xFC in ReadyGels.
  489.      * (Doesn't allow the virtual sprite machine to access
  490.      * either sprite 0 or 1... 0 is used by mouse cursor and
  491.      * shares its colors with 1, so I reserved both of them.
  492.      */
  493.  
  494.     for(j=8; j<180; j+=50)
  495.     {
  496.         for(k=0; k<15; k++)
  497.         {
  498.             Move(rp,k*20,j);
  499.             SetAPen(rp,k+17);    /* show 17-31 */
  500.             /* 16, 20, 24, 28 are unaffected by vsprites 
  501.              * because they are not used by hardware sprites */
  502.  
  503.             Text(rp,numbers[k],2);
  504.         }
  505.     }
  506.     /* *************************************** */
  507.     /* VSPRITE DEMO SECTION            */
  508.     /* *************************************** */
  509.  
  510.     /* Allocate CHIP memory to hold the actual sprite data */
  511.     /* (necessary if ever to run on an expanded RAM Amiga) */
  512.  
  513.     sprdata = (UWORD *)AllocMem(36, MEMF_CHIP);
  514.  
  515.     if(sprdata == NULL)
  516.     {
  517.         /* not enough memory for sprite */
  518.     }
  519.     /* now copy the sprite data into the CHIP RAM. */
  520.  
  521.     src = sprite_data;  
  522.     dest = sprdata;     /* source, destination */
  523.  
  524.     for( j=0; j<18; j++)
  525.     {
  526.         *dest++ = *src++;
  527.     }            
  528.  
  529.     choice = 0;
  530.     maxgot = 0;
  531.  
  532.     /* Prepare the GELS system to work with VSPRITE or BOBS */
  533.  
  534.     error = ReadyGels(&mygelsinfo, rp);
  535.  
  536.     for(k=0; k<MAXSP; k++)    /* whatever maximum number of vsprites */
  537.     {
  538.         xmove[k]=speed[RangeRand(4)];
  539.         ymove[k]=speed[RangeRand(4)];
  540.  
  541.         /* establish a position for the sprite */
  542.         x = 10 + RangeRand(280);
  543.         y = 10 + RangeRand(170);
  544.  
  545.         /* create a vsprite */
  546.         vsprite[k] = MakeVSprite( 9, sprdata, colorset[choice], 
  547.                     x, y, 1, 2, VSPRITE);
  548.         /* 9 lines high, using MEMF_CHIP image of a sprite,
  549.          * with a particular set of colors, at an X,Y location
  550.          * 1 word wide, 2 planes deep (all vsprites are 2 deep)
  551.          * and it is a VSPRITE */
  552.  
  553.         if(vsprite[k] == 0)
  554.         {
  555.             break;    /* ran out of memory! */
  556.         }
  557.         AddVSprite(vsprite[k], rp);
  558.  
  559.         maxgot++;
  560.  
  561.         choice++; /* choose a different color set */
  562.         if(choice >= 4) 
  563.         {
  564.             choice = 0;    /* wrap around on colorsets */
  565.         }
  566.     }
  567.     while(1)    /* forever */
  568.     {
  569.         WaitTOF();
  570.         movesprites();
  571.  
  572.         result = -1;    /* now see if CLOSEWINDOW is waiting */
  573.         msg = (struct IntuiMessage *)GetMsg(w->UserPort);        
  574.         if(msg != 0)
  575.         {
  576.             result = HandleEvent(msg->Class);
  577.  
  578.             /* Let Intuition reuse the msg */
  579.             ReplyMsg(msg);    
  580.         }
  581.         if(result == 0) 
  582.         {
  583.             break;  /* got a CLOSEWINDOW */
  584.         }
  585.     }
  586.  
  587.     /* DONE, now cleanup */
  588.  
  589.     /* Free however many vsprites we actually managed to create */
  590.  
  591.     for(k=0; k<maxgot; k++)
  592.     {
  593.         DeleteGel(vsprite[k]);                
  594.     }
  595.     /* delete what ReadyGels created */
  596.     PurgeGels(&mygelsinfo);    
  597.  
  598.     FreeMem(sprdata, 36);    /* free what we allocated. */
  599.  
  600.     CloseWindow(w);
  601.     CloseScreen(s);
  602.     return (0);
  603. }    
  604.  
  605.  
  606.  
  607.