#pragma once

#include "FixGraf.h"

#include "xthing.h"

#include "GrafUtils.h"

/* this is called if installed for a particular frame */

typedef (*collisionProc)(struct sprite *sprite1, struct sprite *sprite2, Rect *area);

typedef Boolean (*moveProc)(struct sprite *sprite1);

typedef Boolean (*frameProc)(struct sprite *sprite1, struct frameCell *frame);

typedef struct {

    GWorldPtr   image;          // the image of this frame

    RgnHandle   mask;           // the mask region for this frame

    Point       maskLoc;        // topLeft of mask over image location

    long        frameRef;       // application storage for this frame

    frameProc   frameCB;        // proc to be called when this frame is displayed

} frameCell, *frameCellPtr;

typedef struct frameInfo {

    short           frameCount;     // number of frames in this set

    short           frameIndex;     // index to current frame / mask

    frameCellPtr    curImage;       // pointer to current frame / mask

    frameCellPtr    prevImage;      // pointer to previous frame / mask

    frameCell       prevCell;

    Point           dimension;      // size of sprite

    Point           center;         // integer center

} frameInfo;

typedef struct frameSet {

    frameInfo       finfo;          // header block information for this frame set

    frameCell       flist[1];       // variable sized array

} frameSet, *frameSetPtr;

typedef struct sprite {

    struct sprite   *next;              // sprite link in active list

    struct sprite   *prev;

    struct sprite   *usrNext;           // link for use by user application 

    struct sprite   *usrPrev;

    long            spriteFlags;

    xthing          frameTask;          // task for changing frame

    xthing          moveTask;           // task for moving

    long            frameTimeInterval;  // time between frames

    long            moveTimeInterval;   // time between moving

    moveProc        moveHandler;        // routine to handle movement

    frameProc       frameHandler;       // frame task called on every frame

    collisionProc   collideHandler;

    Boolean         visible;            // true if sprite is visible

    Boolean         inUse;

    fixPt           loc;                // location in fixed coordinates (center)

    fixPt           remoteLoc;          // location for a remote sprite - gets slamed into loc

    fixPt           vel;                // velocity in fixed point

    frameSetPtr     frameList;          // the graphics of this one

    Rect            prevBounds;

    Rect            bounds;             // integer coordinates - used for destination drawing

    Rect            updateBounds;       // area that needs to be updated

    Rect            constrainRect;

    short           spriteID;           // user id number

    long            refCon;             // storage area

    long            data;

    struct spriteLayer *ownerLayer;

} sprite, *spritePtr;

typedef struct collisionSpec collisionSpec;

/* United Nations */

/* 42nd Ave New York  on the waterfront */

enum {

        kLayerDirty = 0x00000001,

        kLayerActive = 0x80000000,

        kFrameTaskBeforeUpdate = 0x00000001,

        kFrameTaskAfterUpdate = 0x00000002,

        kConstrainToRect = 0x00000004,

        kWrapToRect = 0x00000008,

        kRemoteSprite = 0x000010,

        kRemoteUpdate = 0x000020,

        kDefaultFrameAdvance = 0x00000040,

        kRemoteSpawn = 0x00000100,

        kRemoteDead = 0x00000200,

        kRemoteKilled = 0x00000400,

        kNeedsToBeErased = 0x40000000,

        kNeedsToBeDrawn = 0x80000000

    };

typedef struct spriteLayer {

    struct spriteLayer  *next;      // the layer in back of this one

    struct spriteLayer  *prev;      // the layer in front of this one

    spritePtr   sprites;            // the sprites in this layer

    short       activeCount;        // number of sprites that are currently moving and stuff

    GWorldPtr   tween;              // the work GWorld for this layer

    GWorldPtr   backdrop;           // the background for this layer

    WindowPtr   window;             // the window this layer ends up in

    long        layerFlags;

    long        layerID;

    long        layerRefcon;

} spriteLayer, *spriteLayerPtr;

void InitSprites(void);

void InitFrameSetInfo(frameSetPtr fsp, short frameCount);

OSErr CreateColorIconFrameSet(frameSetPtr *newFrameSet, short startID, short numFrames);

void AttachCTableToFrameSet(frameSetPtr frameSet, CTabHandle srcCtable, short ctSeed);

OSErr   CreateSpriteLayer(spriteLayerPtr *retSprite, 

                            GWorldPtr tween, 

                            GWorldPtr backdrop, 

                            WindowPtr spriteWin);

OSErr CreateEmptySprite(spriteLayerPtr  sprLayer,

                            spritePtr  *newSprite,      /* new sprite returned here */

                            long        spriteFlags,

                            long        moveTimeInterval,

                            long        frameTimeInterval,

                            long        refCon);        /* application value */

OSErr CreateColorIconSprite(spriteLayerPtr  sprLayer,

                            spritePtr  *newSprite,  /* new sprite returned here */

                            short       startID,    /* starting resource ID of cicn */

                            short       numFrames,  /* number of resources to load */

                            long        spriteFlags,

                            long        moveTimeInterval,

                            long        frameTimeInterval,

                            long        refCon);        /* application value */

void SetSpriteLoc(spritePtr spr, Fixed h, Fixed v);

void ShowSprite(spritePtr spr);

void HideSprite(spritePtr spr);

void StartSpriteAction(spritePtr spr);

void StopSpriteAction(spritePtr spr);

Boolean SpriteFrameTask(xthing *xtp, spritePtr spr);

Boolean SpriteMoveTask(xthing *xtp, spritePtr spr);

OSErr CopyFrameSet(frameSetPtr srcFrameSet, frameSetPtr *destFrameSet);

void CheckSpriteColission(spritePtr spr);

void InvalSprite(spritePtr spr);

void SetSpriteCurrentFrame(spritePtr theSprite, short frameNum);

void SetSpriteFrameSet( spritePtr theSprite, frameSetPtr srcFrameSet);

short GetNextSpriteFrameIndex(spritePtr spr);

OSErr AddSpriteToHitList(spritePtr  spr1, spritePtr spr2, ProcPtr handler);

void SpriteColission(spritePtr spr);

void StartRemoteSpriteAction(spritePtr spr);

void DrawSpriteBackLayers(spriteLayerPtr sprLayer);

void KillSprites(void);

void AddSpriteToLayer(spritePtr spr, spriteLayerPtr sprLayer);

void StopSpriteLayerAction(spriteLayerPtr sprLayer);

void RemoveSpriteFromLayer(spritePtr spr, spriteLayerPtr sprLayer);

void MoveCellMaskRgnToRect(frameCellPtr curFrame, Rect *r);

void UpdateSprites(void);

void SpriteUpdateEvent(void);

void SetFrameSetCTSeed(frameSetPtr frameSet, short newSeed);

/*----------------- sprite accessor macros -----------------*/

/* these are not self documenting, so have fun using them */

#define SetSpriteVelocity(xspr,nh,nv) xspr->vel.h = nh; xspr->vel.v = nv

#define SetSpriteFrameCallback(xspr,frameNum,frameCallback) xspr->frameList->flist[frameNum].frameCB = (ProcPtr)frameCallback

#define SetSpriteFrameDelay(xspr, frameNum, frameDelay)     xspr->frameList->flist[frameNum].frameDelay = frameDelay

#define SetSpriteFrameRef(xspr,frameNum, refCon)    xspr->frameList->flist[frameNum].frameRef = refCon

#define GetSpriteFrameRef(xspr,frameNum)    xspr->frameList->flist[frameNum].frameRef

#define GetSpriteFrameDelay(xspr,frameNum)  xspr->frameList->flist[frameNum].frameDelay

/*------------------- sprite global variables -----------------------*/

extern spritePtr    FreeSpriteList;

extern spritePtr    ActiveSpriteList;

extern RgnHandle    SpriteUtilRgn;