/*	
 *	Animated Sprites Lib
 *
 *	(C)Copyright 1998 J. Tann
 *	All Rights Reserved
*/

#include <libps.h>

//----------------------------------------------------------------------
//	Macros and defined values
//----------------------------------------------------------------------

// TRUE and FALSE
#define FALSE (0)
#define TRUE (!FALSE)

// Sprite structure bit flags
#define USED_SPR	(0x0001)	// Indicates that the structure entry is used
#define DISPLAY_SPR	(0x0002)	// Indicates that the sprite is to be displayed
#define LOOP_ANI	(0x0004)	// Indicates the animation is to be looped when it reaches the end
#define BOUNCE_ANI	(0x0008)	// Indicates the loop should play backwards before going forwards again
#define ANIMATE_SPR	(0x0010)	// Indicates the sprite animation state

// Animation control values for AsControl()
#define ANI_START	1			// Starts animation playback of the sprite
#define ANI_STOP	2			// Stops the animation playback and sets the displayed frame as the first frame
#define ANI_PAUSE	3			// Stops playback at the current frame

// AsMove() values
#define MOVE_ABSOLUTE	0				// Moves a sprite directly to a location on the screen
#define MOVE_RELATIVE	!MOVE_ABSOLUTE	// Moves a sprite relative to it's current location

// AsShow() values
#define HIDE_SPRITE	0				// Hides a sprite
#define SHOW_SPRITE	!HIDE_SPRITE	// Shows a sprite (These are basically FALSE and TRUE respectively!!)

// AsAdd() loop values
#define ANI_ONCE	1			// Play animation just once
#define ANI_LOOP	2			// Loop the animation by going straight to the first frame when the last frame is reached
#define ANI_BOUNCE	3			// Loop the animation by playing backwards when last frame reached. Then continue forwards when first reached!

//----------------------------------------------------------------------
//	Variables
//----------------------------------------------------------------------

typedef struct {
	GsSPRITE	spr;		// PSX sprite structure
	int			delay;		// Timer delay for animating the sprite
	int			delayValue;	// Value for reseting the delay timer
	int			aniDir;		// Direction of animation
	int			frames;		// Number of frames
	int			curFrame;	// Current frame being displayed
	int			x1, y1;		// Coords of the first frame in the tpage
	int			flags;		// Bit flags for the sprite
} ANISPRITE;

ANISPRITE *sprites;			// A pointer to the sprite structures' memory

int functionsEnabled = FALSE;	// A flag to enable all the main functions if init was successful
int maxSpriteNum;				// The value for the last sprite so AsAdd wont add too many!

//----------------------------------------------------------------------
// Function templates
//----------------------------------------------------------------------
int		AsInit(int);						// Initialise function
void	AsFree(void);						// Free sprite memory
int		AsCreate(GsIMAGE, u_short, int, int, int, int, int, int, int);	// Create a sprite
void	AsDelete(int);						// Delete a sprite
void	AsMove(int, int, int, int);			// Move a sprite
void	AsShow(int, int);					// Shows or hides a sprite
int		AsControl(int, int);				// Controls the animation 'playback'
void	AsUpdate(GsOT *);					// Update all active sprites

//----------------------------------------------------------------------
// Main functions
//----------------------------------------------------------------------

//----------------------------------------------------------------------
// AsInit()
//
// Initialises the sprite structures in memory and enables all
// ani-sprite functions.
//
// Parameters:
//    maxSprites	The maximum number of sprites to be used at any one time.
//
// Return:			The function returns a zero for failure (FALSE)
//
int AsInit(int maxSprites)
{
	if(functionsEnabled)	return FALSE;	// Only use this function if it has not been used or AsFree() has been used!

	sprites = (ANISPRITE *)malloc(sizeof(ANISPRITE) * maxSprites);
	if(!sprites)
		return FALSE;
	functionsEnabled = TRUE;
	maxSpriteNum = maxSprites;
	return TRUE;
}

//----------------------------------------------------------------------
// AsFree()
//
// Frees memory allocated for the sprite structures.
//
// Parameters:		None
//
// Return:			None
//
void AsFree(void)
{
	if(!functionsEnabled)	return;					// Only use this function if AsInit was called!

	free(sprites);
	functionsEnabled = FALSE;
}

//----------------------------------------------------------------------
// AsCreate()
//
// Creates a new sprite.
//
// Parameters:
//    tim			Sprite's frame images
//    tpage			Sprite's texture page
//    x				X coord of the first frame in the tpage
//    y             Y coord of the first frame
//    w             Width of each frame
//    h             Height of each frame
//    frames		Number of frames
//    delay			VSYNC delay for each frame displayed. 0 means each frame is displayed each VSYNC (or each call to AsUpdate()!)
//    loop			Use ANI_ONCE to play through just once, ANI_LOOP to loop the animation (default) and ANI_BOUNCE to loop back and forth.
//
// Return:			Returns the sprite number or -1 for unsuccessful or if AsInit() was not called.
//
int AsCreate(GsIMAGE tim, u_short tpage, int x, int y, int w, int h, int frames, int delay, int loop)
{
	int i;

	if(!functionsEnabled)	return -1;		// Only use this function if AsInit was called!

	for(i=0; i<maxSpriteNum && (sprites[i].flags & USED_SPR); i++);	// Search for the first free sprite structure in memory
	if(i == maxSpriteNum)				// If we reached the max value then there in no room at the inn!!
		return -1;

	// Fill sprite structure at location i with details on the sprite
	sprites[i].spr.attribute = 0x01000000;
	sprites[i].spr.x = 0;					// We don't know where the sprite is going until the user uses AsMove()!
	sprites[i].spr.y = 0;
	sprites[i].spr.w = w;
	sprites[i].spr.h = h;
	sprites[i].spr.tpage = tpage;
	sprites[i].spr.u = x;
	sprites[i].spr.v = y;
	sprites[i].spr.cx = tim.cx;
	sprites[i].spr.cy = tim.cy;
	sprites[i].spr.r = 128;					// Regular brightness
	sprites[i].spr.g = 128;					// Regular brightness
	sprites[i].spr.b = 128;					// Regular brightness
	sprites[i].spr.mx = 0;
	sprites[i].spr.my = 0;
	sprites[i].spr.scalex = ONE;
	sprites[i].spr.scaley = ONE;
	sprites[i].spr.rotate = 0;
	sprites[i].delayValue = delay;
	sprites[i].delay = delay;
	sprites[i].aniDir = 1;
	sprites[i].frames = frames;
	sprites[i].curFrame = 0;
	sprites[i].x1 = x;						// Store the first frame coords for looping
	sprites[i].y1 = y;
	sprites[i].flags = USED_SPR;
	switch(loop)
	{
		case ANI_ONCE:
			break;

		case ANI_BOUNCE:
			sprites[i].flags |= BOUNCE_ANI;
		case ANI_LOOP:
		default:
			sprites[i].flags |= LOOP_ANI;
			break;
	}

	return i;	// Return the sprite number
}

//----------------------------------------------------------------------
// AsDelete()
//
// Deletes a sprite.
//
// Parameters:
//    sprite		Sprite number returned from AsAdd()
//
// Return:			None
//
void AsDelete(int sprite)
{
	if(!functionsEnabled)	return;		// Only use this function if AsInit was called!

	sprites[sprite].flags = 0;			// Clearing the flags will 'delete' the sprite! Simple heh?
}

//----------------------------------------------------------------------
// AsMove()
//
// Moves a sprite on the screen (Or sets it's location prior to displaying)
//
// Parameters:
//    sprite		Sprite number returned from AsAdd()
//    x				New x coord
//    y             New y coord
//    rel			A true value will make it move relative to it's current location.
//                  rel is optional and defaults to false for absolute coords in x & y.
//
// Return:			None
//
void AsMove(int sprite, int x, int y, int rel)
{
	if(!functionsEnabled)	return;		// Only use this function if AsInit was called!

	if(rel)
	{
		// Relative positioning
		sprites[sprite].spr.x += x;		// Negative values will make it move left
		sprites[sprite].spr.y += y;		// Negative values will make it move up
	}
	else
	{
		// Absolute positioning
		sprites[sprite].spr.x = x;
		sprites[sprite].spr.y = y;
	}
}

//----------------------------------------------------------------------
// AsShow()
//
// Shows or hides a sprite on the display
//
// Parameters:
//    sprite		Sprite number returned from AsAdd()
//    show			A true value will show the sprite and false will hide it
//
// Return:			None
//
void AsShow(int sprite, int show)
{
	if(!functionsEnabled)	return;					// Only use this function if AsInit was called!

	sprites[sprite].flags &= ~DISPLAY_SPR;			// Clear the display flag
	sprites[sprite].flags |= show?DISPLAY_SPR:0;	// Set the display flag according to show
}

//----------------------------------------------------------------------
// AsControl()
//
// Controls a sprite's animation playback. A bit like VCR controls!!
//
// Parameters:
//    sprite		Sprite number returned from AsAdd()
//    code			A control code from ANI_SPR.H
//					ANI_START	starts the animation!
//					ANI_STOP	stops the animation and resets to first frame
//					ANI_PAUSE	stops the animation at the current frame. Use ANI_START to continue playback
//
// Return:			True for ok or false for an invalid code or if AsInit was not called at the start of the program!
//
int AsControl(int sprite, int code)
{
	if(!functionsEnabled)	return FALSE;			// Only use this function if AsInit was called!

	switch(code)
	{
		case ANI_START:
			sprites[sprite].flags |= ANIMATE_SPR;	// Set the animate flag to start playback
			break;

		case ANI_STOP:
			sprites[sprite].curFrame = 0;			// Set the current frame to the first
			sprites[sprite].flags &= ~ANIMATE_SPR;	// Clear the animate flag to stop playback
			break;

		case ANI_PAUSE:
			sprites[sprite].flags &= ~ANIMATE_SPR;	// Clear the animate flag to stop playback
			break;

		default:
			return FALSE;							// Any other value for code is invalid!
	}

	return TRUE;									// The code was ok.
}

//----------------------------------------------------------------------
// AsUpdate()
//
// Updates all active sprites and places them in the order table for display. This is the function that does all the 'clever' stuff!
// It updates the animation of each sprite before putting it into the ordering table. This function should be called every VSYNC in
// the main game loop. I hope to make it automatic sometime so it always updates without the need for calling this function. This
// would be on an interrupt started in the AsInit() function and stopped in AsFree(). At the moment, all animated sprites are placed
// in the ordering table with a priority position of 0.
//
// Parameters:
//    ot			A pointer to the current order table
//
// Return:			None
//
void AsUpdate(GsOT *ot)
{
	int i, yFrames, pageYFrame;

	if(!functionsEnabled)	return;		// Only use this function if AsInit was called!

	for(i=0; i<maxSpriteNum; i++)
	{
		// Check if the current structure is used and also marked for display
		if((sprites[i].flags & USED_SPR) && (sprites[i].flags & DISPLAY_SPR))
		{
			// Check if the sprite is to be animated
			if(sprites[i].flags & ANIMATE_SPR)
			{
				// Check if the delay value needs decreasing
				if(sprites[i].delay)
					sprites[i].delay--;		// Decrease the delay value
				else
				{
					sprites[i].delay = sprites[i].delayValue;		// Reset the delay value
					sprites[i].curFrame += sprites[i].aniDir;		// Move the animation in the current direction
					// Now we check if the first or last frame has been reached (first in the case of bouncing)
					if((sprites[i].curFrame == 0 && (sprites[i].flags & BOUNCE_ANI)) || sprites[i].curFrame == sprites[i].frames)
					{
						sprites[i].curFrame--;						// We do this because the current frame is currently past the physical last frame!
						if(sprites[i].flags & LOOP_ANI)				// Do we loop the animation?
						{
							if(sprites[i].flags & BOUNCE_ANI)		// Do we 'bounce' the animation?
								sprites[i].aniDir -= 2;				// This may confuse people! If you subtract 2 from 1 you get -1 also subtracting 2
																	// from -1 gives you 1. So we reverse the direction of animation both ways.
							else									// Ok we do a normal loop
								sprites[i].curFrame = 0;			// Reset the current frame to the start
						}
						else										// No looping
							sprites[i].flags &= ~ANIMATE_SPR;		// It's pointless to let the animation routine keep running when we are at the end!
					}
				}

				// Now the 'fun' part!! We need to change the GsSPRITE u and v offsets to display the current frame in the tpage.

				// We need to know how many frames fit virtically in the tpage and use that in our calculations.
				yFrames = 256 / sprites[i].spr.h;	// Divide the height of a tpage by the height of the sprite
				
				// Now we need to create a curFrame value that allows for the first frame to start anywhere in the y offset of a tpage
				// so long as it is on a boundary equal to the sprite's height! EG A 16x16 sprite can start at 0, 16, 32, 48 etc.
				pageYFrame = sprites[i].y1 / yFrames + sprites[i].curFrame;

				// Now we set the v (y) offset to the remainder of dividing the current frame number by yFrames
				sprites[i].spr.v = pageYFrame % yFrames;
				// Now set the u (x) offset to the result of dividing the current frame by yFrames and add the first frame's x offset
				sprites[i].spr.u = pageYFrame / yFrames + sprites[i].x1;
			}

			// Finally add the sprite to the order table!
			GsSortFastSprite(&sprites[i].spr, ot, 0);
		}
	}
}