#include "private.h"

#include "sprite.h"
#include "group.h"
#include "drawing.h"
#include "animation.h"


struct _Sprite {
	double x;
	double y;
	double rotation;
	double width;
	double height;
	double scale;
	
	double vx;
	double vy;
	double ax;
	double ay;
	double rotationSpeed;
	
	HeliCollider collider;
	double colliderSensitiveDistance;
	int massLevel;
	
	double wx;
	double wy;
	double friction;
	double airFriction;
	double touchFriction;
	
	int rotateToDirection;
	int mirrorX;
	int mirrorY;
	double depth;
	double lifeTime;
	int visible;
	int frozen;
	int debug;
	
	double shapeColor[4];
	double tintColor[4];
	
	HeliArray groups;
	
	Animation animation;
	
	int userTag;
	char *userText;
	void *userData;
	SpriteCallback destroyCallback;
};

static HeliArray sprites;
static HeliArray spritesSorted;


static void prepareCollider(Sprite sprite, HeliCollider *collider) {
	memcpy(collider, &sprite->collider, sizeof(*collider));
	collider->x += sprite->x;
	collider->y += sprite->y;
	collider->rotation += sprite->rotation;
	
	// auto-size
	if (collider->type == COLLIDER_RECTANGLE) {
		if (collider->width < -HELI_PRECISION) collider->width = sprite->width;
		if (collider->height < -HELI_PRECISION) collider->height = sprite->height;
		if (collider->radius < -HELI_PRECISION) collider->radius = 0;
	} else
	if (collider->type == COLLIDER_CIRCLE) {
		collider->width = 0;
		collider->height = 0;
		if (collider->radius < -HELI_PRECISION) collider->radius = 0.5*sprite->width;
	}
	
	// scale
	collider->width *= sprite->scale;
	collider->height *= sprite->scale;
	collider->radius *= sprite->scale;
	
	// fix small values
	if (collider->width  < HELI_PRECISION) collider->width = HELI_PRECISION;
	if (collider->height < HELI_PRECISION) collider->height = HELI_PRECISION;
	if (collider->radius < HELI_PRECISION) collider->radius = HELI_PRECISION;
	
	// fix round corners
	if (collider->type == COLLIDER_RECTANGLE) {
		double rmax = 0.5*( collider->width < collider->height
						  ? collider->width : collider->height );
		if (collider->radius >= rmax - HELI_PRECISION)
			collider->radius = rmax;
		collider->width  -= 2*collider->radius;
		collider->height -= 2*collider->radius;
	}
}


static void autoRotate(Sprite sprite) {
	if (sprite->rotateToDirection)
		sprite->rotation = spriteGetDirection(sprite);
}


Sprite createSpriteEx(double x, double y, double width, double height) {
	if (!heliInitialized) return NULL;

	Sprite s = calloc(1, sizeof(*s));
	s->x = x;
	s->y = y;
	s->width = width;
	s->height = height;
	
	s->scale = 1;
	s->collider.type = COLLIDER_RECTANGLE;
	s->collider.width = s->collider.height = -1;
	s->colliderSensitiveDistance = 0.001;
	s->collider.bounciness = 1;
	s->friction = 1;
	
	s->mirrorX = 1;
	s->mirrorY = 1;
	s->lifeTime = -1;
	s->visible = TRUE;
	
	s->shapeColor[0] = s->shapeColor[1] = s->shapeColor[2] = 0.5;
	s->shapeColor[3] = 1;
	s->tintColor[0] = s->tintColor[1] = s->tintColor[2] = s->tintColor[3] = 1;
	
	s->userText = heliStringCopy("");
	
	heliArrayInsert(&sprites, -1, s, NULL);
	heliArrayInsert(&spritesSorted, -1, s, NULL);
	
	heliObjectRegister(s, (HeliFreeCallback)&spriteDestroy);
	return s;
}

Sprite createSprite(double x, double y)
	{ return createSpriteEx(x, y, 100, 100); }

void spriteDestroy(Sprite sprite) {
	if (sprite->destroyCallback) sprite->destroyCallback(sprite);
	spriteSetNoAnimation(sprite);
	while(sprite->groups.count > 0)
		groupRemove((Group)sprite->groups.items[0].value, sprite);
	for(int i = sprites.count - 1; i >= 0; --i)
		if (sprites.items[i].value == sprite)
			heliArrayRemove(&sprites, i);
	for(int i = spritesSorted.count - 1; i >= 0; --i)
		if (spritesSorted.items[i].value == sprite)
			heliArrayRemove(&spritesSorted, i);
	heliArrayDestroy(&sprite->groups);
	heliObjectUnregister(sprite);
	free(sprite->userText);
	free(sprite);
}

void spriteDestroyTimer(Sprite sprite, double lifeTime) {
	if (lifeTime <= 0) { spriteDestroy(sprite); return; }
	sprite->lifeTime = lifeTime;
}

Sprite spriteClone(Sprite sprite) {
	if (!heliInitialized) return NULL;
	Sprite s = calloc(1, sizeof(*s));
	memcpy(s, sprite, sizeof(*s));
	s->lifeTime = -1;
	memset(&s->groups, 0, sizeof(s->groups));
	s->userText = heliStringCopy(sprite->userText);
	return s;
}


double spriteGetX(Sprite sprite) { return sprite->x; }
void spriteSetX(Sprite sprite, double x) { sprite->x = x; }
double spriteGetY(Sprite sprite) { return sprite->y; }
void spriteSetY(Sprite sprite, double y) { sprite->y = y; }
void spriteSetXY(Sprite sprite, double x, double y)
	{ spriteSetX(sprite, x); spriteSetY(sprite, y); }

double spriteGetVelocityX(Sprite sprite) { return sprite->vx; }
void spriteSetVelocityX(Sprite sprite, double x)
	{ spriteSetVelocityXY(sprite, x, sprite->vy); }
double spriteGetVelocityY(Sprite sprite) { return sprite->vy; }
void spriteSetVelocityY(Sprite sprite, double y)
	{ spriteSetVelocityXY(sprite, sprite->vx, y); }
void spriteSetVelocityXY(Sprite sprite, double x, double y) {
	spriteResetTouch(sprite);
	sprite->vx = x; sprite->vy = y;
	autoRotate(sprite);
}

double spriteGetAccelerationX(Sprite sprite) { return sprite->ax; }
void spriteSetAccelerationX(Sprite sprite, double x) { sprite->ax = x; }
double spriteGetAccelerationY(Sprite sprite) { return sprite->ay; }
void spriteSetAccelerationY(Sprite sprite, double y) { sprite->ay = y; }
void spriteSetAccelerationXY(Sprite sprite, double x, double y)
	{ spriteSetAccelerationX(sprite, x); spriteSetAccelerationY(sprite, y); }

double spriteGetScale(Sprite sprite) { return sprite->scale; }
void spriteSetScale(Sprite sprite, double scale) { sprite->scale = scale; }

double spriteGetWidth(Sprite sprite) { return sprite->width; }
void spriteSetWidth(Sprite sprite, double width)
	{ sprite->width = width > 0 ? width : 0; }
double spriteGetHeight(Sprite sprite) { return sprite->height; }
void spriteSetHeight(Sprite sprite, double height)
	{ sprite->height = height > 0 ? height : 0; }
void spriteSetSize(Sprite sprite, double width, double height) {
	spriteSetWidth(sprite, width);
	spriteSetHeight(sprite, height);
}

int spriteGetRotateToDirection(Sprite sprite) { return sprite->rotateToDirection; }
void spriteSetRotateToDirection(Sprite sprite, int rotateToDirection) {
	if (rotateToDirection) {
		sprite->rotateToDirection = TRUE;
		sprite->rotation = spriteGetDirection(sprite);
	} else {
		sprite->rotateToDirection = FALSE;
	}
}

double spriteGetRotation(Sprite sprite) { return sprite->rotation; }
void spriteSetRotation(Sprite sprite, double rotation)
	{ if (!sprite->rotateToDirection) sprite->rotation = rotation; }

double spriteGetRotationSpeed(Sprite sprite) { return sprite->rotationSpeed; }
void spriteSetRotationSpeed(Sprite sprite, double rotationSpeed)
	{ sprite->rotationSpeed = rotationSpeed; }

int spriteGetMirrorX(Sprite sprite) { return sprite->mirrorX; }
void spriteSetMirrorX(Sprite sprite, int mirrorX)
	{ sprite->mirrorX = mirrorX < 0 ? -1 : 1; }

int spriteGetMirrorY(Sprite sprite) { return sprite->mirrorY; }
void spriteSetMirrorY(Sprite sprite, int mirrorY)
	{ sprite->mirrorY = mirrorY < 0 ? -1 : 1; }

double spriteGetDepth(Sprite sprite) { return sprite->depth; }
void spriteSetDepth(Sprite sprite, double depth)
	{ sprite->depth = depth; }

int spriteGetVisible(Sprite sprite) { return sprite->visible; }
void spriteSetVisible(Sprite sprite, int visible)
	{ sprite->visible = visible != FALSE; }

int spriteGetFrozen(Sprite sprite) { return sprite->frozen; }
void spriteSetFrozen(Sprite sprite, int frozen)
	{ sprite->frozen = frozen != FALSE; }

int spriteGetDebug(Sprite sprite) { return sprite->debug; }
void spriteSetDebug(Sprite sprite, int debug)
	{ sprite->debug = debug != FALSE; }


void heliSpriteCollisionApply(Sprite a, Sprite b, HeliCollisionInfo *info) {
	if ( a->massLevel > b->massLevel) {
		b->x -= info->dx;
		b->y -= info->dy;
		b->vx = a->vx - info->vx;
		b->vy = a->vy - info->vy;
		autoRotate(b);
		if (b->wx*b->wx + b->wy*b->wy < info->ax*info->ax + info->ay*info->ay) {
			b->wx = info->ax;
			b->wy = info->ay;
			b->touchFriction = a->friction;
		}
	} else
	if ( b->massLevel > a->massLevel ) {
		a->x += info->dx;
		a->y += info->dy;
		a->vx = b->vx + info->vx;
		a->vy = b->vy + info->vy;
		autoRotate(a);
		if (a->wx*a->wx + a->wy*a->wy < info->ax*info->ax + info->ay*info->ay) {
			a->wx = -info->ax;
			a->wy = -info->ay;
			a->touchFriction = b->friction;
		}
	} else {
		double vxAvg = 0.5*(a->vx + b->vx);
		double vyAvg = 0.5*(a->vy + b->vy);
		double wx = info->ax;
		double wy = info->ay;
		double w = wx*wx + wy*wy;
		
		a->x += 0.5*info->dx;
		a->y += 0.5*info->dy;
		a->vx = vxAvg + 0.5*info->vx;
		a->vy = vyAvg + 0.5*info->vy;
		autoRotate(a);
		if (a->wx*a->wx + a->wy*a->wy < w) {
			a->wx = -wx;
			a->wy = -wy;
			a->touchFriction = b->friction;
		}
		
		b->x -= 0.5*info->dx;
		b->y -= 0.5*info->dy;
		b->vx = vxAvg - 0.5*info->vx;
		b->vy = vyAvg - 0.5*info->vy;
		autoRotate(b);
		if (b->wx*b->wx + b->wy*b->wy < w) {
			b->wx = wx;
			b->wy = wy;
			b->touchFriction = a->friction;
		}
	}
}

int heliSpriteCollisionCheck(Sprite a, Sprite b, HeliCollisionInfo *info) {
	if (a == b) return FALSE;
	HeliCollider ca = {}, cb = {};
	prepareCollider(a, &ca);
	prepareCollider(b, &cb);
	memset(info, 0, sizeof(*info));
	info->vx = a->vx - b->vx;
	info->vy = a->vy - b->vy;
	info->ax = a->ax - b->ax;
	info->ay = a->ay - b->ay;
	return heliCheckCollision(&ca, &cb, info, a->colliderSensitiveDistance + b->colliderSensitiveDistance);
}

int spriteOverlap(Sprite a, Sprite b) {
	HeliCollisionInfo info = {};
	heliSpriteCollisionCheck(a, b, &info);
	return info.actualCollision;
}

int spriteCollide(Sprite a, Sprite b) {
	HeliCollisionInfo info = {};
	if (heliSpriteCollisionCheck(a, b, &info)) {
		heliSpriteCollisionApply(a, b, &info);
		return info.actualCollision;
	}
	return FALSE;
}


double spriteGetBounciness(Sprite sprite)
	{ return sprite->collider.bounciness; }
void spriteSetBounciness(Sprite sprite, double bounciness)
	{ sprite->collider.bounciness = bounciness > 0 ? bounciness : 0; }
double spriteGetBouncinessThreshold(Sprite sprite)
	{ return sprite->collider.bouncinessThreshold; }
void spriteSetBouncinessThreshold(Sprite sprite, double bouncinessThreshold)
	{ sprite->collider.bouncinessThreshold = bouncinessThreshold > 0 ? bouncinessThreshold : 0; }

double spriteGetFriction(Sprite sprite)
	{ return sprite->friction; }
void spriteSetFriction(Sprite sprite, double friction)
	{ sprite->friction = friction > 0 ? friction : 0; }
double spriteGetAirFriction(Sprite sprite)
	{ return sprite->airFriction; }
void spriteSetAirFriction(Sprite sprite, double friction)
	{ sprite->airFriction = friction > 0 ? friction : 0; }

int spriteGetMassLevel(Sprite sprite)
	{ return sprite->massLevel; }
void spriteSetMassLevel(Sprite sprite, int massLevel)
	{ sprite->massLevel = massLevel; }

double spriteGetTouchWeight(Sprite sprite)
	{ return sqrt(sprite->wx*sprite->wx + sprite->wy*sprite->wy); }
double spriteGetTouchWeightX(Sprite sprite)
	{ return sprite->wx; }
double spriteGetTouchWeightY(Sprite sprite)
	{ return sprite->wy; }
double spriteGetTouchFriction(Sprite sprite)
	{ return sprite->touchFriction; }
void spriteResetTouch(Sprite sprite) {
	sprite->wx = 0;
	sprite->wy = 0;
	sprite->touchFriction = 0;
}

double spriteGetColliderSensitiveDistance(Sprite sprite)
	{ return sprite->colliderSensitiveDistance; }
void spriteSetColliderSensitiveDistance(Sprite sprite, double distance)
	{ sprite->colliderSensitiveDistance = distance > 10*HELI_PRECISION ? distance : 10*HELI_PRECISION; }

void spriteSetCollider(Sprite sprite, Collider type, double xOffset, double yOffset, double rotationOffset)
	{ spriteSetColliderEx(sprite, type, xOffset, yOffset, rotationOffset, -1, -1, -1); }
void spriteSetColliderCircle(Sprite sprite, double xOffset, double yOffset, double radius)
	{ spriteSetColliderEx(sprite, COLLIDER_CIRCLE, xOffset, yOffset, 0, 0, 0, radius); }
void spriteSetColliderRectangle(
	Sprite sprite, double xOffset, double yOffset, double rotationOffset,
	double width, double height, double cornersRadius )
{
	spriteSetColliderEx(
		sprite, COLLIDER_RECTANGLE,
		xOffset, yOffset, rotationOffset,
		width, height, cornersRadius);
}

void spriteSetColliderEx(
	Sprite sprite, Collider type,
	double xOffset, double yOffset, double rotationOffset,
	double width, double height, double radius )
{
	sprite->collider.type = type;
	sprite->collider.x = xOffset;
	sprite->collider.y = yOffset;
	sprite->collider.rotation = rotationOffset;
	if (type == COLLIDER_CIRCLE) {
		sprite->collider.width = 0;
		sprite->collider.height = 0;
		sprite->collider.radius = radius;
	} else
	if (type == COLLIDER_RECTANGLE) {
		sprite->collider.width = width;
		sprite->collider.height = height;
		sprite->collider.radius = radius;
	} else {
		sprite->collider.width = 0;
		sprite->collider.height = 0;
		sprite->collider.radius = 0;
	}
}

int spriteIsPointInside(Sprite sprite, double x, double y) {
	HeliCollider collider;
	prepareCollider(sprite, &collider);
	return heliPointCollision(&collider, x, y);
}

Animation spriteGetAnimation(Sprite sprite)
	{ return sprite->animation; }

void spriteSetAnimation(Sprite sprite, Animation animation)
	{ sprite->animation = animation; }

void spriteSetNoAnimation(Sprite sprite)
	{ spriteSetAnimation(sprite, NULL); }

unsigned int spriteGetShapeColor(Sprite sprite) {
	return colorByRGBA(
		sprite->shapeColor[0],
		sprite->shapeColor[1],
		sprite->shapeColor[2],
		sprite->shapeColor[3] );
}
void spriteSetShapeColor(Sprite sprite, unsigned int colorCode)
	{ heliColorToDouble(colorCode, sprite->shapeColor); }

unsigned int spriteGetTintColor(Sprite sprite) {
	return colorByRGBA(
		sprite->tintColor[0],
		sprite->tintColor[1],
		sprite->tintColor[2],
		sprite->tintColor[3] );
}
void spriteSetTintColor(Sprite sprite, unsigned int colorCode)
	{ heliColorToDouble(colorCode, sprite->tintColor); }

void spriteSetSpeedAndDirection(Sprite sprite, double speed, double angle) {
	double a = angle*(PI/180);
	spriteSetVelocityXY(sprite, cos(a)*speed, sin(a)*speed);
}

double spriteGetSpeed(Sprite sprite)
	{ return sqrt(sprite->vx*sprite->vx + sprite->vy*sprite->vy); }
double spriteGetDirection(Sprite sprite) {
	return fabs(sprite->vx) > HELI_PRECISION || fabs(sprite->vy) > HELI_PRECISION
	     ? atan2(sprite->vy, sprite->vx)*(180/PI) : 0;
}
void spritePointTo(Sprite sprite, double x, double y)
	{ spriteSetRotation( sprite, atan2(y - sprite->y, x - sprite->x)*(180/PI) ); }
void spriteMoveBy(Sprite sprite, double dx, double dy)
	{ spriteSetXY(sprite, spriteGetX(sprite) + dx, spriteGetY(sprite) + dy); }
void spriteMoveToDirection(Sprite sprite, double distance, double angle) {
	double a = angle*PI/180.0;
	spriteMoveBy(sprite, cos(a)*distance, sin(a)*distance);
}

double spriteGetScaledWidth(Sprite sprite)
	{ return sprite->width * sprite->scale; }
double spriteGetScaledHeight(Sprite sprite)
	{ return sprite->height * sprite->scale; }


int spriteGetUserTag(Sprite sprite)
	{ return sprite->userTag; }
void spriteSetUserTag(Sprite sprite, int tag)
	{ sprite->userTag = tag; }
const char* spriteGetUserText(Sprite sprite)
	{ return sprite->userText; }
void spriteSetUserText(Sprite sprite, const char *text) {
	if (sprite->userText == text) return;
	free(sprite->userText);
	sprite->userText = heliStringCopy(text);
}
void* spriteGetUserData(Sprite sprite)
	{ return sprite->userData; }
void spriteSetUserData(Sprite sprite, void *data)
	{ sprite->userData = data; }

void spriteSetDestroy(Sprite sprite, SpriteCallback destroy)
	{ sprite->destroyCallback = destroy; }


int spritesGetCount()
	{ return sprites.count; }
Sprite spritesGet(int i)
	{ return (Sprite)heliArrayGetValue(&sprites, i); }


void heliSpriteDrawDebug(Sprite s) {
	saveState();
	translate(s->x, s->y);
	rotate(s->rotation);
	
	strokeWidth(0.5);
	
	double hw = 0.5 * s->scale * s->width;
	double hh = 0.5 * s->scale * s->height;
	
	noFill();
	stroke(colorByRGBA(0, 0, 0, 0.75));

	// frame
	rect(-hw, -hh, 2*hw, 2*hh);
	
	// center cross
	line(-hw/4, 0, hw/4, 0);
	line(0, -hh/4, 0, hh/4);
	
	// depth
	double s1 = hw*0.25;
	double s2 = hh*0.5;
	double ss = s1 < s2 ? s1 : s2;
	textSize(ss);
	textAlign(HALIGN_LEFT, VALIGN_BOTTOM);
	textf(0.1*ss - hw, hh - 0.1*ss, "%lf", s->depth);
	
	restoreState();
}

void heliSpriteDraw(Sprite s) {
	double w = 0.5*s->scale*s->width;
	double h = 0.5*s->scale*s->height;
	if (w < HELI_PRECISION || h < HELI_PRECISION) return;
	w *= s->mirrorX;
	h *= s->mirrorY;
	
	unsigned int texid = s->animation ? animationGetGLTexId(s->animation) : 0u;
	double color[4] = {
		(texid ? 1.0 : s->shapeColor[0])*s->tintColor[0],
		(texid ? 1.0 : s->shapeColor[1])*s->tintColor[1],
		(texid ? 1.0 : s->shapeColor[2])*s->tintColor[2],
		(texid ? 1.0 : s->shapeColor[3])*s->tintColor[3] };
	if (color[3] < HELI_PRECISION) return;

	saveState();
	translate(s->x, s->y);
	rotate(s->rotation);
	noStroke();
	fill(colorByRGBA(color[0], color[1], color[2], color[3]));
	rectTextured(s->animation, -w, -h, 2*w, 2*h);
	restoreState();
}

void heliSpriteSort(HeliArray *sprites) {
	int found = TRUE;
	while(found) {
		found = FALSE;
		// forward
		for(int i = 1; i < sprites->count; ++i) {
			if ( ((Sprite)sprites->items[i-1].value)->depth
			   < ((Sprite)sprites->items[i  ].value)->depth )
			{
				void *x = sprites->items[i].value;
				sprites->items[i].value = sprites->items[i-1].value;
				sprites->items[i-1].value = x;
				found = TRUE;
			}
		}
		if (!found) break;
		// backward
		found = FALSE;
		for(int i = sprites->count - 1; i > 0; --i) {
			if ( ((Sprite)sprites->items[i-1].value)->depth
			   < ((Sprite)sprites->items[i  ].value)->depth )
			{
				void *x = sprites->items[i].value;
				sprites->items[i].value = sprites->items[i-1].value;
				sprites->items[i-1].value = x;
				found = TRUE;
			}
		}
	}
}

void spriteDraw(Sprite sprite) {
	if (sprite->visible) heliSpriteDraw(sprite);
	if (sprite->debug) heliSpriteDrawDebug(sprite);
}

void drawSprites() {
	heliSpriteSort(&spritesSorted);
	for(int i = 0; i < spritesSorted.count; ++i) {
		Sprite s = (Sprite)(spritesSorted.items[i].value);
		if (s->visible) heliSpriteDraw(s);
	}
	for(int i = 0; i < spritesSorted.count; ++i) {
		Sprite s = (Sprite)(spritesSorted.items[i].value);
		if (s->debug) heliSpriteDrawDebug(s);
	}
}

int spriteUpdate(Sprite sprite, double time) {
	if (sprite->lifeTime >= -HELI_PRECISION) {
		sprite->lifeTime -= time;
		if (sprite->lifeTime <= HELI_PRECISION) {
			sprite->lifeTime = 0;
			spriteDestroy(sprite);
			return FALSE;
		}
	}
	
	double vx = sprite->vx + sprite->ax*time;
	double vy = sprite->vy + sprite->ay*time;
	
	double weight = spriteGetTouchWeight(sprite);
	double dvf = fabs(weight * sprite->friction * sprite->touchFriction)*time;
	if (dvf > HELI_PRECISION) {
		double nx = sprite->wx / weight;
		double ny = sprite->wy / weight;
		double vb = nx*vx + ny*vy;
		double vs = ny*vx - nx*vy;
		if (vs >  dvf + HELI_PRECISION) vs -= dvf; else
		if (vs < -dvf - HELI_PRECISION) vs += dvf; else vs = 0;
		vx = nx*vb + ny*vs;
		vy = ny*vb - nx*vs;
	}
	
	double dvaf = fabs(sprite->airFriction)*time;
	if (dvaf > HELI_PRECISION) {
		double v = sqrt(vx*vx + vy*vy), vn = v;
		if (v >  dvaf + HELI_PRECISION) vn -= dvaf; else
		if (v < -dvaf - HELI_PRECISION) vn += dvaf; else vn = 0;
		double k = vn > HELI_PRECISION ? vn/v : 0;
		vx *= k;
		vy *= k;
	}
	
	sprite->vx = vx;
	sprite->vy = vy;
	autoRotate(sprite);
	spriteResetTouch(sprite);
	
	sprite->x += sprite->vx * time;
	sprite->y += sprite->vy * time;
	if (!sprite->rotateToDirection)
		sprite->rotation += sprite->rotationSpeed*time;
	
	return TRUE;
}

void heliSpriteUpdate(double dt) {
	for(int i = spritesGetCount() - 1; i >= 0; --i) {
		if (i < spritesGetCount()) {
			Sprite s = spritesGet(i);
			if (!spriteGetFrozen(s))
				spriteUpdate(spritesGet(i), dt);
		}
	}
}

HeliArray* heliSpriteGetGroups(Sprite sprite)
	{ return &sprite->groups; }

void heliSpriteFinish() {
	while(spritesGetCount())
		{ spriteDestroy(spritesGet(0)); }
	heliArrayDestroy(&sprites);
	heliArrayDestroy(&spritesSorted);
}