/*

 Copyright (C) 2007, 2010 - Bit-Blot

 This file is part of Aquaria.

 Aquaria is free software; you can redistribute it and/or

 modify it under the terms of the GNU General Public License

 as published by the Free Software Foundation; either version 2

 of the License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful,

 but WITHOUT ANY WARRANTY; without even the implied warranty of

 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 See the GNU General Public License for more details.

 You should have received a copy of the GNU General Public License

 along with this program; if not, write to the Free Software

 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

 */

 #include "../BBGE/AfterEffect.h"

 #include "../BBGE/MathFunctions.h"

 #include "Avatar.h"

 #include "Game.h"

 #include "Shot.h"

 #include "GridRender.h"

 //#include "CommonEvents.h"

 //#include <float.h>

 //#define AQ_TEST_QUADTRAIL

 #ifdef AQ_TEST_QUADTRAIL

 	#include "QuadTrail.h"

 	QuadTrail *quadTrail = 0;

 #endif

 Path *lastWaterBubble = 0;

 bool lastJumpOutFromWaterBubble = false;

 bool useSpiritDistance = true;

 bool inSpiritWorld = false;

 const int LAYER_FLOURISH = 3;

 const float MULT_DMG_CRABCOSTUME = 0.75;

 const float MULT_DMG_FISHFORM = 1.5;

 const float MULT_DMG_SEAHORSEARMOR = 0.6;

 const float MULT_MAXSPEED_BEASTFORM = 1.2;

 const float MULT_MAXSPEED_FISHFORM = 1.5;

 const float MULT_DMG_EASY	= 0.5;

 const float JELLYCOSTUME_HEALTHPERC		= 0.5;

 const float JELLYCOSTUME_HEALDELAY		= 2.0;

 const float	JELLYCOSTUME_HEALAMOUNT		= 0.5;

 const float biteTimerBiteRange = 0.6;

 const float biteTimerMax = 3;

 const float biteDelayPeriod = 0.08;

 const int normalTendrilHits = 3;

 const int rollTendrilHits = 4;

 const int maxTendrilHits = 6;

 const float fireDelayTime = 0.2;

 const int maxShieldPoints = 8;

 const int minMouse = 60;

 int SongIcon::notesOpen = 0;

 Avatar *avatar = 0;

 const Vector BLIND_COLOR = Vector(0.1, 0.1, 0.1);

 const float ANIM_TRANSITION	= 0.2;

 const float MANA_RECHARGE_RATE = 1.0;

 const int AURA_SHIELD_RADIUS = 64;

 //const int TARGET_RANGE = 1024;

 const int TARGET_RANGE = 1024; // 650

 const int TARGET_GRACE_RANGE = 200;

 //const int TARGET_RANGE = 700;

 //const int TARGET_RANGE = 64;

 const float NOTE_SCALE = 0.75;

 const int singingInterfaceRadius = 100;

 const int openSingingInterfaceRadius = 128;

 //164

 const int BURST_DISTANCE = 200;

 const int STOP_DISTANCE = 48;

 const int maxMouse = BURST_DISTANCE;

 //const int SHOCK_RANGE	= 700;

 const int SHOCK_RANGE	= 1000;

 const int SPIRIT_RANGE	= 2000;

 const float QUICK_SONG_CAST_DELAY = 0.4;

 const float BURST_RECOVER_RATE = 1.2; // 3.0 // 0.75

 const float BURST_USE_RATE = 1.5; //0.9 //1.5;

 const float BURST_DELAY = 0.1;

 const float BURST_ACCEL = 4000; //2000 // 1000

 const float TUMMY_TIME = 6.0;

 const float chargeMax = 2.0;

 volatile int micNote = -1;

 bool openedFromMicInput = false;

 const int requiredDualFormCharge = 3;

 bool usingDigital = false;

 Bone *bone_head = 0;

 Bone *bone_dualFormGlow = 0;

 bool _isUnderWater;

 //HRECORD avatarRecord = 0;

 #define ANIMLAYER_OVERRIDE			4

 #define ANIMLAYER_UPPERBODYIDLE		6

 #define ANIMLAYER_HEADOVERRIDE		7

 Vector Target::getWorldPosition()

 {

 	Vector ret;

 	if (e)

 	{

 		ret = e->getTargetPoint(targetPt);

 	}

 	return ret;

 }

 void Avatar::bindInput()

 {

 	ActionMapper::clearActions();

 	ActionMapper::clearCreatedEvents();

 	dsq->user.control.actionSet.importAction(this, "PrimaryAction", ACTION_PRIMARY);

 	dsq->user.control.actionSet.importAction(this, "SecondaryAction", ACTION_SECONDARY);

 	dsq->user.control.actionSet.importAction(this, "Revert", MakeFunctionEvent(Avatar, revert), 0);

 	dsq->user.control.actionSet.importAction(this, "SwimUp",		ACTION_SWIMUP);

 	dsq->user.control.actionSet.importAction(this, "SwimDown",		ACTION_SWIMDOWN);

 	dsq->user.control.actionSet.importAction(this, "SwimLeft",		ACTION_SWIMLEFT);

 	dsq->user.control.actionSet.importAction(this, "SwimRight",		ACTION_SWIMRIGHT);

 	/*

 	dsq->user.control.actionSet.importAction(this, "SingUp",		ACTION_SINGUP);

 	dsq->user.control.actionSet.importAction(this, "SingDown",		ACTION_SINGDOWN);

 	dsq->user.control.actionSet.importAction(this, "SingLeft",		ACTION_SINGLEFT);

 	dsq->user.control.actionSet.importAction(this, "SingRight",		ACTION_SINGRIGHT);

 	*/

 	dsq->user.control.actionSet.importAction(this, "SongSlot1",		ACTION_SONGSLOT1);

 	dsq->user.control.actionSet.importAction(this, "SongSlot2",		ACTION_SONGSLOT2);

 	dsq->user.control.actionSet.importAction(this, "SongSlot3",		ACTION_SONGSLOT3);

 	dsq->user.control.actionSet.importAction(this, "SongSlot4",		ACTION_SONGSLOT4);

 	dsq->user.control.actionSet.importAction(this, "SongSlot5",		ACTION_SONGSLOT5);

 	dsq->user.control.actionSet.importAction(this, "SongSlot6",		ACTION_SONGSLOT6);

 	dsq->user.control.actionSet.importAction(this, "SongSlot7",		ACTION_SONGSLOT7);

 	dsq->user.control.actionSet.importAction(this, "SongSlot8",		ACTION_SONGSLOT8);

 	dsq->user.control.actionSet.importAction(this, "SongSlot9",		ACTION_SONGSLOT9);

 	dsq->user.control.actionSet.importAction(this, "SongSlot10",	ACTION_SONGSLOT10);

 	dsq->user.control.actionSet.importAction(this, "Look",			ACTION_LOOK);

 	/*

 	dsq->user.control.actionSet.importAction(this, "SongSlot5", "f5");

 	dsq->user.control.actionSet.importAction(this, "SongSlot6", "f6");

 	dsq->user.control.actionSet.importAction(this, "SongSlot7", "f7");

 	dsq->user.control.actionSet.importAction(this, "SongSlot8", "f8");

 	*/

 	dsq->user.control.actionSet.importAction(this, "Roll",			ACTION_ROLL);

 	/*

 	// song note keys

 	addAction("s1", KEY_1);

 	addAction("s2", KEY_2);

 	addAction("s3", KEY_3);

 	addAction("s4", KEY_4);

 	addAction("s5", KEY_5);

 	addAction("s6", KEY_6);

 	addAction("s7", KEY_7);

 	addAction("s8", KEY_8);

 	*/

 }

 int Avatar::getNotesOpen()

 {

 	return SongIcon::notesOpen;

 }

 // note: z is set to 1.0 when we want the aim to be used as the shot direction

 // otherwise the shot will head straight to the target

 Vector Avatar::getAim()

 {

 	Vector d;

 	if (dsq->inputMode == INPUT_JOYSTICK)

 	{

 		if (!core->joystick.rightStick.isZero())

 		{

 			d = core->joystick.rightStick * 300;

 			d.z = 1;

 		}

 		else

 		{

 			d = core->joystick.position * 300;

 			d.z = 0;

 		}

 	}

 	else if (dsq->inputMode == INPUT_KEYBOARD)

 	{

 		d = dsq->getGameCursorPosition() - position;

 		d.z = 1;

 	}

 	else

 	{

 		d = dsq->getGameCursorPosition() - position;

 		d.z = 1;

 	}

 	if (d.isZero())

 		d = getNormal();

 	return d;

 }

 void Avatar::postInit()

 {

 	// post init isn't early enough

 	/*

 	Entity::postInit();

 	*/

 }

 void Avatar::onAnimationKeyPassed(int key)

 {

 	if (swimming && !isRolling() && !bursting && _isUnderWater)

 	{

 		if (key == 0 || key == 2)

 		{

 			//core->sound->playSfx("SwimKick", 255, 0, 1000+getMaxSpeed()/10.0);

 		}

 	}

 	Entity::onAnimationKeyPassed(key);

 }

 void Avatar::doBounce()

 {

 	float ba = 0.75;

 	if (isRolling())

 		ba = 1.0;

 	float len = vel.getLength2D();

 	Vector I = vel/len;

 	Vector N = dsq->game->getWallNormal(position);

 	if (!N.isZero())

 	{

 		//2*(-I dot N)*N + I

 		vel = 2*(-I.dot(N))*N + I;

 		vel.setLength2D(len*ba);

 	}

 }

 Vector randCirclePos(Vector position, int radius)

 {

 	float a = ((rand()%360)*(2*PI))/360.0;

 	return position + Vector(sinf(a), cosf(a))*radius;

 }

 SongIconParticle::SongIconParticle(Vector color, Vector pos, int note)

 								:  note(note)

 {

 	cull = false;

 	//fastTransform = true;

 	setTexture("particles/glow");

 	setWidthHeight(32);

 	float life = 1.0;

 	toIcon = 0;

 	this->color = color;

 	position = pos;

 	alpha.path.addPathNode(0, 0);

 	alpha.path.addPathNode(0.4, 0.2); // .8

 	alpha.path.addPathNode(0.2, 0.8); // .4

 	alpha.path.addPathNode(0, 1);

 	alpha.startPath(life);

 	scale.path.addPathNode(Vector(0.5,0.5), 0);

 	scale.path.addPathNode(Vector(1,1), 0.5);

 	scale.path.addPathNode(Vector(0.5,0.5), 1);

 	scale.startPath(life);

 	setLife(life);

 	setDecayRate(1);

 	//if (rand()%6 <= 2)

 	setBlendType(RenderObject::BLEND_ADD);

 	float smallestDist = -1;

 	SongIcon *closest = 0;

 	for (int i = 0; i < avatar->songIcons.size(); i++)

 	{

 		if (i != note)

 		{

 			Vector diff = (position - avatar->songIcons[i]->position);

 			float dist = diff.getSquaredLength2D();

 			if (smallestDist == -1 || dist < smallestDist)

 			{

 				smallestDist = dist;

 				closest = avatar->songIcons[i];

 			}

 		}

 	}

 	// find nearest song icon

 	if (closest)

 	{

 		toIcon = closest;

 	}

 }

 void SongIconParticle::onUpdate(float dt)

 {

 	Quad::onUpdate(dt);

 	if (toIcon)

 	{

 		Vector add = (toIcon->position - position);

 		add.setLength2D(200*dt);

 		velocity += add;

 		velocity.capLength2D(50);

 	}

 }

 SongIcon::SongIcon(int note) : Quad(), note(note)

 {

 	open = false;

 	alphaMod = 0.9;

 	/*

 	std::ostringstream os;

 	os << "SongIcon" << note;

 	setTexture(os.str());

 	*/

 	//setTexture("Cursor-Sing");

 	std::ostringstream os;

 	os << "Song/NoteSymbol" << note;

 	os.str();

 	setTexture(os.str());

 	scale = Vector(NOTE_SCALE, NOTE_SCALE);

 	cursorIsIn = false;

 	delay = 0;

 	counter = 0;

 	width = 40;

 	height = 40;

 	minTime = 0;

 	ptimer = 0;

 	noteColor = dsq->getNoteColor(note);

 	//color = dsq->getNoteColor(note)*0.75 + Vector(1,1,1)*0.25;

 	color = dsq->getNoteColor(note);

 	len = 0;

 	channel = BBGE_AUDIO_NOCHANNEL;

 	rippleTimer = 0;

 	glow = new Quad;

 	glow->setTexture("particles/bigglow");

 	glow->followCamera = 1;

 	glow->rotation.interpolateTo(Vector(0,0,360), 10, -1);

 	glow->alpha = 0;

 	glow->setBlendType(RenderObject::BLEND_ADD);

 	glow->scale = Vector(0.5, 0.5);

 	glow->color = dsq->getNoteColor(note);

 	dsq->game->addRenderObject(glow, LR_PARTICLES2);

 }

 void SongIcon::destroy()

 {

 	Quad::destroy();

 }

 void SongIcon::spawnParticles(float dt)

 {

 	float intv = 0.1;

 	// do stuff!

 	ptimer += dt;

 	while (ptimer > intv)

 	{

 		ptimer -= intv;

 		SongIconParticle *s = new SongIconParticle(noteColor, randCirclePos(position, 16), note);

 		s->followCamera = true;

 		dsq->game->addRenderObject(s, LR_HUD);

 	}

 }

 void SongIcon::onUpdate(float dt)

 {

 	Quad::onUpdate(dt);

 	if (!avatar->singing)

 		return;

 	if (alpha.x == 0 && !alpha.isInterpolating())

 		alpha.interpolateTo(0.3, 0.1);

 	if (delay > 0)

 	{

 		delay -= dt;

 		if (delay < 0)

 		{

 			delay = 0;

 			//channel = BBGE_AUDIO_NOCHANNEL;

 		}

 	}

 	if (counter > 0)

 	{

 		counter -= dt;

 		if (counter < 0)

 		{

 			counter = 0;

 			closeNote();

 		}

 	}

 	if (alpha.x > 0.5)

 	{

 		spawnParticles(dt);

 	}

 	if (open)

 	{

 		len += dt;

 		avatar->setHeadTexture("Singing", 0.1);

 	}

 	if (alpha.x == 1)

 	{

 		if ((!openedFromMicInput && isCoordinateInRadius(core->mouse.position, 25)) || micNote == note) // 40 width.x

 		{

 			//if (delay == 0)

 			if (true)

 			{

 				if (!cursorIsIn)

 				// highlighted for the first time

 				{

 					cursorIsIn = true;

 					openNote();

 				}

 				else

 				{

 					if (minTime > 0)

 					{

 						minTime -= dt;

 						if (minTime < 0)

 						{

 							minTime = 0;

 						}

 					}

 				}

 			}

 		}

 		else

 		{

 			if (cursorIsIn)

 			{

 				cursorIsIn = false;

 				closeNote();

 			}

 		}

 	}

 	if (alpha.x <= 0 && delay == 0) //  && channel != BBGE_AUDIO_NOCHANNEL

 	{

 		closeNote();

 	}

 	if (open)

 	{

 		if (dsq->user.video.noteEffects)

 		{

 			rippleTimer -= dt;

 			if (rippleTimer <= 0)

 			{

 				//rippleTimer = 1.0 - ((7 - note)/7.0)*0.7;

 				rippleTimer = 0.5 - (note/7.0)*0.4;

 				if (core->afterEffectManager)

 					core->afterEffectManager->addEffect(new ShockEffect(position,core->screenCenter,0.02,0.015,22,0.2f, 1.2));

 			}

 		}

 	}

 	if (glow)

 	{

 		glow->position = position;

 	}

 }

 void SongIcon::openNote()

 {

 	//if (delay > 0) return;

 	scale.interpolateTo(Vector(1.2, 1.2), 0.1);

 	if (dsq->user.video.noteEffects)

 	{

 		glow->scale = Vector(0.5,0.5);

 		glow->scale.interpolateTo(Vector(1.0, 1.0), 2, -1, 1, 1);

 		glow->alpha.interpolateTo(0.6, 0.2, 0, 0, 1);

 	}

 	/*

 	std::ostringstream os;

 	os << "Note"

 	*/

 	std::string sfx = dsq->game->getNoteName(note);

 	open = true;

 	internalOffset = Vector(-5, 0);

 	internalOffset.interpolateTo(Vector(5, 0), 0.08, -1, 1);

 	avatar->singNote(this->note);

 	// this should never get called:

 	if (channel != BBGE_AUDIO_NOCHANNEL)

 	{

 		dsq->sound->fadeSfx(channel, SFT_OUT, 0.2);

 		//dsq->sound->fadeSfx(channel, SFT_OUT, 0.2);

 		channel = BBGE_AUDIO_NOCHANNEL;

 	}

 	//dsq->sound->stopSfx(channel);

 	PlaySfx play;

 	play.name = sfx;

 	play.channel = 1 + note;

 	channel = dsq->sound->playSfx(play);

 	rippleTimer = 0;

 	minTime = 0.05;

 	counter = 3.2;

 	float glowLife = 0.5;

 	Quad *q = new Quad("particles/glow", position);

 	q->scale.interpolateTo(Vector(10, 10), glowLife+0.1);

 	q->alpha.path.addPathNode(0,0);

 	q->alpha.path.addPathNode(0.75,0.2);

 	q->alpha.path.addPathNode(0,1);

 	q->alpha.startPath(glowLife);

 	q->color = dsq->getNoteColor(note); //*0.5 + Vector(0.5, 0.5, 0.5)

 	q->setBlendType(RenderObject::BLEND_ADD);

 	q->followCamera = 1;

 	dsq->game->addRenderObject(q, LR_HUD);

 	{

 	std::ostringstream os2;

 	os2 << "Song/NoteSymbol" << note;

 	Quad *q = new Quad(os2.str(), position);

 	q->color = 0;

 	q->scale = Vector(0.5,0.5);

 	q->scale.interpolateTo(Vector(2, 2), glowLife+0.1);

 	//q->scale.interpolateTo(Vector(10, 10), glowLife+0.1);

 	q->alpha.path.addPathNode(0,0);

 	q->alpha.path.addPathNode(0.5,0.2);

 	q->alpha.path.addPathNode(0,1);

 	q->alpha.startPath(glowLife);

 	//q->setBlendType(RenderObject::BLEND_ADD);

 	q->followCamera = 1;

 	dsq->game->addRenderObject(q, LR_HUD);

 	}

 	avatar->songInterfaceTimer = 1.0;

 	notesOpen++;

 	/*

 	std::ostringstream os2;

 	os2 << "notesOpen: " << notesOpen;

 	debugLog(os2.str());

 	*/

 	if (notesOpen > 0)

 	{

 		len = 0;

 		FOR_ENTITIES(i)

 		{

 			Entity *e = *i;

 			if ((e->position - dsq->game->avatar->position).getSquaredLength2D() < sqr(1000))

 			{

 				e->songNote(note);

 			}

 		}

 		for (int i = 0; i < dsq->game->paths.size(); i++)

 		{

 			Path *p = dsq->game->paths[i];

 			if (!p->nodes.empty())

 			{

 				if ((p->nodes[0].position - dsq->game->avatar->position).getSquaredLength2D() < sqr(1000))

 				{

 					p->songNote(note);

 				}

 			}

 		}

 	}

 }

 void SongIcon::closeNote()

 {

 	//if (delay > 0) return;

 	scale.interpolateTo(Vector(NOTE_SCALE, NOTE_SCALE), 0.1);

 	if (dsq->game->avatar->isSinging() && dsq->user.video.noteEffects)

 		glow->alpha.interpolateTo(0.3, 1.5, 0, 0, 1);

 	else

 		glow->alpha.interpolateTo(0, 1.5, 0, 0, 1);

 	glow->scale.interpolateTo(Vector(0.5, 0.5), 0.5);

 	cursorIsIn = false;

 	if (channel != BBGE_AUDIO_NOCHANNEL)

 	{

 		dsq->sound->fadeSfx(channel, SFT_OUT, 1.0);

 		channel = BBGE_AUDIO_NOCHANNEL;

 		//delay = 0.5;

 	}

 	if (open)

 	{

 		internalOffset.stop();

 		internalOffset = Vector(0,0);

 		notesOpen--;

 		open = false;

 		FOR_ENTITIES(i)

 		{

 			Entity *e = *i;

 			int dist = (e->position - dsq->game->avatar->position).getSquaredLength2D();

 			if (e != dsq->game->avatar && dist < sqr(1000))

 			{

 				e->songNoteDone(note, len);

 			}

 		}

 		for (int i = 0; i < dsq->game->paths.size(); i++)

 		{

 			Path *p = dsq->game->paths[i];

 			if (!p->nodes.empty())

 			{

 				if ((p->nodes[0].position - dsq->game->avatar->position).getSquaredLength2D() < sqr(1000))

 				{

 					p->songNoteDone(note, len);

 				}

 			}

 		}

 	}

 	/*

 	std::ostringstream os;

 	os << "notesOpen: " << notesOpen;

 	debugLog(os.str());

 	*/

 	if (notesOpen <= 0)

 	{

 		notesOpen = 0;

 		if (dsq->continuity.form == FORM_NORMAL)

 			avatar->setHeadTexture("");

 	}

 }

 void SongIcon::openInterface()

 {

 	delay = 0;

 	alpha.interpolateTo(1, 0.1);

 }

 void SongIcon::closeInterface()

 {

 	closeNote();

 	delay = 0;

 	alpha.interpolateTo(0, 0.1);

 }

 AvatarState::AvatarState()

 {

 	abilityDelay = 0;

 	outOfWaterTimer = 0;

 	backFlip = false;

 	nearWall = false;

 	wasUnderWater = true;

 	blind = false;

 	lockedToWall = false;

 	crawlingOnWall = false;

 	shotDelay = 0;

 	spellCharge = 0;

 	leachTimer = 0;

 	swimTimer = 0;

 	rollTimer = 0;

 	updateLookAtTime = 0;

 	lookAtEntity = 0;

 	blinkTimer = 0;

 }

 //    0  1  2  3  4  5  6  7  8  9

 const int	spellManaCost	[]	= { 0,    3,    1,    1,   2,    1,    4,    1,    1,    2};

 const float spellChargeMins	[]	= { 0,    1.25, 0,    0,   0.75, 0,    0.5,  0,    0,    3};

 //const float spellChargeMaxs	[]	= { 0.75, 1.5,  1.9,  1,   1,    1,    0.75, 1,    1,    3};

 const float spellCastDelays	[]	= { 0.05, 0.2,  0.4, 0.1, 0.1,  0.1,  0.2,  0.1,  0.1,  0.1 };

 bool avatarDebugEnabled = false;

 void Avatar::toggleMovement(bool on)

 {

 	canMove = on;

 }

 bool Avatar::isLockable()

 {

 	return (bursting || !_isUnderWater) && (boneLockDelay == 0) && (dsq->continuity.form != FORM_FISH);

 }

 bool Avatar::isSinging()

 {

 	return singing;

 }

 void Avatar::shift()

 {

 	dsq->continuity.shiftWorlds();

 }

 void Avatar::applyWorldEffects(WorldType type)

 {

 	static bool oldfh=false;

 	if (type == WT_SPIRIT)

 	{

 		//skeletalSprite.transitionAnimate("ball", 0.1, -1);

 		//skeletalSprite.alpha.interpolateTo(0, 1);

 		//skeletalSprite.alpha = 0;

 		//dsq->game->addRenderObject(&skeletalSprite, LR_ENTITIES);

 		removeChild(&skeletalSprite);

 		skeletalSprite.position = position;

 		skeletalSprite.setFreeze(true);

 		skeletalSprite.scale = scale;

 		skeletalSprite.alpha.interpolateTo(0.5, 1);

 		//dsq->game->addRenderObject(&skeletalSprite, LR_ENTITIES);

 		skeletalSprite.rotation.z = rotation.z;

 		skeletalSprite.rotationOffset.z = rotationOffset.z;

 		oldfh = skeletalSprite.isfh();

 		skeletalSprite.fhTo(isfh());

 		renderQuad = true;

 		setTexture("glow");

 		width = 256;

 		height = 256;

 		setBlendType(BLEND_ADD);

 		fader->alpha.interpolateTo(0.75, 1);

 		dsq->sound->toggleEffectMusic(SFX_FLANGE, true);

 	}

 	else

 	{

 		//skeletalSprite.transitionAnimate("idle", 1, -1);

 		//skeletalSprite.alpha.interpolateTo(1, 1);

 		//skeletalSprite.alpha = 1;

 		//dsq->game->removeRenderObject(&skeletalSprite);

 		skeletalSprite.setFreeze(false);

 		if (!skeletalSprite.getParent())

 		{

 			addChild(&skeletalSprite, PM_STATIC);

 		}

 		skeletalSprite.position = Vector(0,0,0);

 		skeletalSprite.scale = Vector(1,1,1);

 		renderQuad = false;

 		setBlendType(BLEND_DEFAULT);

 		fader->alpha.interpolateTo(0, 1);

 		bool newfh = skeletalSprite.isfh();

 		skeletalSprite.fhTo(oldfh);

 		skeletalSprite.rotation.z = 0;

 		skeletalSprite.rotationOffset.z = 0;

 		fhTo(newfh);

 		dsq->sound->toggleEffectMusic(SFX_FLANGE, false);

 	}

 }

 void Avatar::startFlourish()

 {

 	std::string anim = dsq->continuity.getInternalFormName() + "-flourish";

 	//if (skeletalSprite.getAnimation(anim))

 	Animation *fanim = skeletalSprite.getAnimation(anim);

 	if (fanim)

 	{

 		flourishTimer.start(fanim->getAnimationLength()-0.2);

 		flourishPowerTimer.start(fanim->getAnimationLength()*0.5);

 	}

 	skeletalSprite.transitionAnimate(anim, 0.1, 0, LAYER_FLOURISH);

 	flourish = true;

 	float rotz = rotationOffset.z;

 	if (this->isfh())

 		rotationOffset = Vector(0,0,rotz+360);

 	else

 		rotationOffset = Vector(0,0,rotz-360);

 	FormType f = dsq->continuity.form;

 	if (f != FORM_NORMAL && f != FORM_BEAST && f != FORM_FISH && f != FORM_SUN && f != FORM_NATURE)

 	{

 		rotationOffset.z *= -1;

 	}

 	if (f == FORM_ENERGY || f == FORM_DUAL)

 	{

 		rotationOffset.z *= 2;

 	}

 	if (f == FORM_BEAST)

 	{

 		Vector v = getNormal();

 		if (!v.isZero())

 		{

 			v *= 400;

 			vel += v;

 		}

 	}

 	rotationOffset.interpolateTo(Vector(0,0,rotz), 0.8, 0, 0, 1);

 }

 void Avatar::onIdle()

 {

 	if (dsq->game->li)

 	{

 		if (dsq->game->li->getState() == STATE_HUG && riding)

 		{

 			dsq->game->li->setState(STATE_IDLE);

 		}

 	}

 	//stillTimer.stop();

 	stopBurst();

 	if (movingOn)

 	{

 		dsq->setMousePosition(Vector(400,300));

 	}

 	skeletalSprite.getAnimationLayer(ANIMLAYER_UPPERBODYIDLE)->stopAnimation();

 	stopRoll();

 	closeSingingInterface();

 	fallOffWall();

 	dsq->gameSpeed.stopPath();

 	dsq->gameSpeed.interpolateTo(1,0);

 }

 std::string Avatar::getBurstAnimName()

 {

 	std::string ret;

 	switch(dsq->continuity.form)

 	{

 	case FORM_ENERGY:

 		ret = "energyburst";

 	break;

 	default:

 		ret = "burst";

 	break;

 	}

 	return ret;

 }

 std::string Avatar::getRollAnimName()

 {

 	std::string ret;

 	switch(dsq->continuity.form)

 	{

 	case FORM_ENERGY:

 		ret = "energyroll";

 	break;

 	default:

 		ret = "roll";

 	break;

 	}

 	return ret;

 }

 std::string Avatar::getIdleAnimName()

 {

 	std::string ret="idle";

 	switch(dsq->continuity.form)

 	{

 	case FORM_ENERGY:

 		ret="energyidle";

 	break;

 	}

 	return ret;

 }

 void Avatar::clampPosition()

 {

 	lastPosition = position;

 }

 void Avatar::updatePosition()

 {

 	updateHair(0);

 }

 void Avatar::debugMsg(const std::string &msg)

 {

 	if (avatarDebugEnabled)

 	{

 		BitmapText *txt = new BitmapText(&dsq->font);

 		txt->setLife(2);

 		txt->setDecayRate(1);

 		txt->position = this->position;

 		txt->setText(msg);

 		txt->fadeAlphaWithLife = true;

 		core->getTopStateData()->addRenderObject(txt, LR_DEBUG_TEXT);

 	}

 }

 void Avatar::onBlindTest()

 {

 	setBlind(5);

 }

 void Avatar::onToggleDebugMessages()

 {

 	avatarDebugEnabled = !avatarDebugEnabled;

 }

 void Avatar::updateHair(float dt)

 {

 	static float hairTimer = 0;

 	Bone *b = skeletalSprite.getBoneByIdx(0);

 	if (hair && b)

 	{

 		hair->alpha.x = alpha.x;

 		hair->color.x = color.x * multColor.x * dsq->game->sceneColor.x * dsq->game->sceneColor2.x * dsq->game->sceneColor3.x;

 		hair->color.y = color.y * multColor.y * dsq->game->sceneColor.y * dsq->game->sceneColor2.y * dsq->game->sceneColor3.y;

 		hair->color.z = color.z * multColor.z * dsq->game->sceneColor.z * dsq->game->sceneColor2.z * dsq->game->sceneColor3.z;

 		Vector headPos = b->getWorldCollidePosition(Vector(12,-32,0));

 		hair->setHeadPosition(headPos);

 		Vector diff = headPos - position;

 		Vector diff2;

 		if (!isfh())

 			diff2 = diff.getPerpendicularLeft();

 		else

 			diff2 = diff.getPerpendicularRight();

 		Vector diff3 = position - headPos;

 		if (state.lockedToWall && wallPushVec.y < 0 && (fabs(wallPushVec.y) > fabs(wallPushVec.x)))

 		{

 			if (isfh())

 			{

 				diff3 = Vector(-50, -25);

 			}

 			else

 				diff3 = Vector(50,-25);

 		}

 		float len =diff2.getLength2D();

 		diff3.setLength2D(len);

 		/*

 		diff.y = -diff.y;

 		diff = (diff + diff2)/2.0;

 		*/

 		hairTimer += dt;

 		while (hairTimer > 2.0)

 		{

 			hairTimer -= 2.0;

 		}

 		float useTimer = hairTimer;

 		if (useTimer > 1.0)

 			useTimer = 1.0 - (hairTimer-1);

 		float frc = 0.333333;

 		diff = (diff2*(frc*(1.0-(useTimer*0.5))) + diff3*(frc) + Vector(0,len)*(frc*(0.5+useTimer*0.5)));

 		if (_isUnderWater)

 		{

 			diff.setLength2D(400);

 			//if (!vel.isLength2DIn(10))

 			hair->exertForce(diff, dt);

 		}

 		else

 		{

 			diff.setLength2D(400);

 			hair->exertForce(diff, dt);

 		}

 		if (!vel2.isZero())

 			hair->exertForce(vel2, dt);

 		hair->updatePositions();

 	}

 }

 void Avatar::updateDamageVisualEffects()

 {

    	int damageThreshold = float(maxHealth/5.0)*3.0f;

 	if (health <= damageThreshold)

 	{

 		//dsq->game->damageSprite->alpha.interpolateTo(0.9, 0.5);

 		float a = ((damageThreshold - health)/float(damageThreshold))*1.0;

 		dsq->game->damageSprite->alpha.interpolateTo(a, 0.3);

 		/*

 		std::ostringstream os;

 		os << "damageSprite alpha: " << a;

 		debugLog(os.str());

 		*/

 		dsq->game->damageSprite->scale = Vector(1,1);

 		dsq->game->damageSprite->scale.interpolateTo(Vector(1.2, 1.2), 0.5, -1, 1);

 		/*

 		if (health <= 0)

 		{

 			dsq->game->sceneColor.interpolateTo(Vector(1,0.5,0.5), 0.75);

 		}

 		*/

 	}

 	else

 	{

 		dsq->game->damageSprite->alpha.interpolateTo(0, 0.3);

 	}

 }

 void Avatar::checkUpgradeForShot(Shot *s)

 {

 	if (dsq->continuity.energyMult <= 1)

 		s->extraDamage = dsq->continuity.energyMult * 1;

 	else

 		s->extraDamage = dsq->continuity.energyMult * 0.75;

 	if (s->extraDamage > 0)

 	{

 		Quad *glow = new Quad("particles/glow", Vector(0,0));

 		glow->color = Vector(1,0,0);

 		glow->color.interpolateTo(Vector(1,0.5,0.5), 0.1, -1, 1);

 		glow->setBlendType(BLEND_ADD);

 		glow->scale = Vector(4, 4) + (s->extraDamage*Vector(2,2));

 		glow->scale.interpolateTo(Vector(16,16)+ (s->extraDamage*Vector(2,2)), 0.5, -1, 1);

 		s->addChild(glow, PM_POINTER);

 	}

 }

 void Avatar::onDamage(DamageData &d)

 {

 	Entity::onDamage(d);

 	if (dsq->difficulty == DSQ::DIFF_EASY)

 	{

 		if (d.damage > 0)

 			d.damage *= MULT_DMG_EASY;

 	}

 	skeletalSprite.getAnimationLayer(ANIMLAYER_UPPERBODYIDLE)->stopAnimation();

 	if (dsq->continuity.form == FORM_NORMAL)

 	{

 		if (nocasecmp(dsq->continuity.costume, "CC")==0)

 		{

 			d.damage *= MULT_DMG_CRABCOSTUME;

 		}

 	}

 	if (riding != 0)

 	{

 		if (nocasecmp(dsq->continuity.costume, "seahorse")==0)

 		{

 			d.damage *= MULT_DMG_SEAHORSEARMOR;

 		}

 	}

 	if (dsq->continuity.form == FORM_FISH)

 	{

 		d.damage *= MULT_DMG_FISHFORM;

 	}

 	if ((core->isNested() && dsq->game->invincibleOnNested) || dsq->game->invinciblity)

 	{

 		d.damage = 0;

 		d.damageType = DT_NONE;

 		return;

 	}

 	if (d.damageType == DT_ENEMY_INK)

 	{

 		setBlind(d.effectTime);

 		return;

 	}

 	if (d.damageType == DT_ENEMY_POISON)

 	{

 		dsq->continuity.setPoison(1, d.effectTime);

 	}

 	if (dsq->continuity.defenseMultTimer.isActive())

 	{

 		d.damage *= dsq->continuity.defenseMult;

 	}

 	if (dsq->continuity.invincibleTimer.isActive())

 		d.damage = 0;

 	if (!canDie)

 	{

 		if ((health - d.damage) <= 0)

 		{

 			float i = d.damage;

 			while (i >= 0)

 			{

 				if ((health - i) > 0)

 				{

 					d.damage = i;

 					break;

 				}

 				i -= 0.5;

 			}

 		}

 	}

 	if ((!invincible || !dsq->game->invincibleOnNested) && !(invincibleBreak && damageTimer.isActive() && d.useTimer) && !dsq->continuity.invincibleTimer.isActive())

 	{

 		if (d.damageType == DT_ENEMY_ACTIVEPOISON)

 			core->sound->playSfx("Poison");

 		else

 			core->sound->playSfx("Pain");

 		setHeadTexture("Pain", 1);

 		int r = (rand()%2)+1;

 		std::ostringstream os;

 		os << "basicHit" << r;

 		skeletalSprite.transitionAnimate(os.str(), 0.05, 0, ANIMLAYER_OVERRIDE);

 		/*

 		if (d.attacker)

 		{

 			// this will probably cause a crash!

 			state.lookAtEntity = d.attacker;

 		}

 		*/

 		if (d.damage > 0)

 		{

 			float healthWillBe = health-d.damage;

 			// determines length of shader blur as well

 			float t = 0.5;

 			if (healthWillBe<=0)

 				t = 2;

 			dsq->rumble(d.damage, d.damage, 0.4);

 			if (d.damage > 0)

 			{

 				//dsq->shakeCamera(5, t);

 				if (d.damage >= 1)

 				{

 					float shake = d.damage*2;

 					if (shake > 10)

 						shake = 10;

 					dsq->shakeCamera(shake, t);

 				}

 				if (healthWillBe <= 2 && d.damageType != DT_ENEMY_ACTIVEPOISON)

 				{

 					//if (!dsq->gameSpeed.isInterpolating() && dsq->gameSpeed.x==1)

 					{

 						dsq->gameSpeed.stop();

 						dsq->gameSpeed.stopPath();

 						dsq->gameSpeed.x = 1;

 						dsq->overlayRed->alpha.path.clear();

 						dsq->overlayRed->alpha.path.addPathNode(0, 0);

 						dsq->overlayRed->alpha.path.addPathNode(1.0, 0.1);

 						dsq->overlayRed->alpha.path.addPathNode(0, 1.0);

 						dsq->overlayRed->alpha.startPath(1);

 						dsq->sound->playSfx("heartbeat");

 						if (healthWillBe < 2 && healthWillBe >= 1 && !dsq->game->hasPlayedLow)

 						{

 							dsq->emote.playSfx(EMOTE_NAIJALOW);

 							dsq->game->hasPlayedLow = 1;

 						}

 						dsq->gameSpeed.path.clear();

 						dsq->gameSpeed.path.clear();

 						dsq->gameSpeed.path.addPathNode(1, 0);

 						dsq->gameSpeed.path.addPathNode(0.25, 0.1);

 						dsq->gameSpeed.path.addPathNode(0.25, 0.4);

 						dsq->gameSpeed.path.addPathNode(1.0, 1.0);

 						dsq->gameSpeed.startPath(2);

 						//dsq->gameSpeed.interpolateTo(0.7, 3);

 					}

 					//dsq->emote();

 				}

 			}

 			hitEmitter.load("NaijaHit");

 			hitEmitter.start();

 			playHitSound();

 		}

 	}

 }

 void Avatar::playHitSound()

 {

 	int hitSound = (rand()%8)+1;

 	static int lastHitSound = 0;

 	if (lastHitSound == hitSound)

 	{

 		hitSound ++;

 		if (hitSound > 8)

 			hitSound = 1;

 	}

 	std::ostringstream os;

 	os << "hit" << hitSound;

 	core->sound->playSfx(os.str());

 }

 const int beatHealth = 3;

 void Avatar::updateHeartbeatSfx(float t)

 {

 	/*

 	if (heartbeat)

 	{

 		BASS_CHANNELINFO info;

 		BASS_ChannelGetInfo(heartbeat, &info);

 		int num = (beatHealth - health);

 		float wantFreq = 1000 + num*300;

 		float useFreq = ((wantFreq*info.freq)/1000.0);

 		float vol = 75 + (num*25)*0.5;

 		vol *= (core->sound->getUseSfxVol()/100.0);

 		//int vol = 100;

 		BASS_ChannelSlideAttributes(heartbeat, useFreq, vol, -101, 1000.0*t);

 	}

 	*/

 }

 void Avatar::onHealthChange(float change)

 {

 	updateDamageVisualEffects();

 	if (health <= beatHealth && health > 0)

 	{

 		/*

 		if (!heartbeat)

 		{

 			//debugLog("starting heartbeat");

 			heartbeat = core->sound->playSfx("Heartbeat", 255, 0, 1000, 1);

 			//core->sound->playSfx("Heartbeat");

 		}

 		*/

 		updateHeartbeatSfx(0.5);

 	}

 	if (health > beatHealth)

 	{

 		/*

 		if (heartbeat)

 		{

 			//debugLog("stopping heartbeat");

 			BASS_CHANNELINFO info;

 			BASS_ChannelGetInfo(heartbeat, &info);

 			BASS_ChannelSlideAttributes(heartbeat, info.freq, -2, -101, 1000*2);

 			heartbeat = 0;

 		}

 		*/

 	}

 }

 void Avatar::revive()

 {

 	entityDead	= false;

 	health		= 0;

 	heal(maxHealth);

 }

 void Avatar::updateDualFormChargeEffects()

 {

 }

 void Avatar::lostTarget(int i, Entity *e)

 {

 	dsq->sound->playSfx("target-unlock");

 }

 void Avatar::entityDied(Entity *e)

 {

 	Entity::entityDied(e);

 	for (int i = 0; i < targets.size(); i++)

 	{

 		if (targets[i].e == e)

 		{

 			lostTarget(i, 0);

 			targets[i].e = 0;

 			targetUpdateDelay = 100;

 			targets.clear();

 			break;

 		}

 	}

 	if (state.lookAtEntity==e)

 		state.lookAtEntity = 0;

 	// eating

 	if (e->isGoingToBeEaten())

 	{

 		EatType et = e->getEatType();

 		switch(et)

 		{

 			case EAT_FILE:

 			{

 				dsq->continuity.eatBeast(e->eatData);

 			}

 			break;

 		}

 	}

 	//debugLog("Entity died");

 	//e->lastDamage.damageType == DT_AVATAR_ENERGYBLAST &&

 	//debugLog("Entity died");

 	if (e->lastDamage.form == FORM_DUAL && e->lastDamage.damageType == DT_AVATAR_SHOCK)

 	{

 		dsq->continuity.dualFormCharge ++;

 		updateDualFormChargeEffects();

 		dsq->spawnParticleEffect("SpiritSteal", e->position);

 		//dsq->spawnParticleEffect("SpiritBeacon", position);

 		core->sound->playSfx("DualForm-Absorb");

 		if (dsq->continuity.dualFormCharge == requiredDualFormCharge)

 			core->sound->playSfx("DualForm-Charge");

 	}

 	/*

 	std::ostringstream os;

 	os << "lastDamage.form = " << e->lastDamage.form;

 	debugLog(os.str());

 	*/

 }

 void Avatar::enableInput()

 {

 	ActionMapper::enableInput();

 	dsq->game->toggleMiniMapRender(1);

 	if (!dsq->game->isApplyingState())

 		dsq->toggleCursor(true);

 	if (movingOn)

 	{

 		dsq->setMousePosition(Vector(400,300));

 	}

 	if (dsq->continuity.form == FORM_ENERGY)

 	{

 		for (int i = 0; i < targetQuads.size(); i++)

 			targetQuads[i]->start();

 	}

 	setInvincible(false);

 	// can't do that here, cause it'll break the hug

 	//stillTimer.stop();

 }

 void Avatar::disableInput()

 {

 	ActionMapper::disableInput();

 	// can't do that here, cause it'll break the hug

 	//stillTimer.stop();

 	closeSingingInterface();

 	dsq->game->toggleMiniMapRender(0);

 	dsq->toggleCursor(false);

 	endCharge();

 	clearTargets();

 	if (movingOn)

 	{

 		dsq->setMousePosition(Vector(400,300));

 	}

 	for (int i = 0; i < targetQuads.size(); i++)

 	{

 		targetQuads[i]->stop();

 	}

 	setInvincible(true);

 }

 void Avatar::clearTargets()

 {

 	for (int i = 0; i < targets.size(); i++)

 	{

 		if (targets[i].e)

 		{

 			lostTarget(i, 0);

 		}

 		targets[i].e = 0;

 	}

 }

 void Avatar::slowToRest()

 {

 	vel.capLength2D(50);

 	/*

 	if (vel.getSquaredLength2D() > sqr(50))

 	{

 		vel.setLength2D(50);

 	}

 	*/

 	bursting = swimming = false;

 	skeletalSprite.stopAnimation(1);

 	rotation.interpolateTo(Vector(0,0,0), 0.2, 0, 0, 1);

 }

 /*

 #define SPECWIDTH 368

 #define SPECHEIGHT 127

 BYTE *specbuf = 0;

 */

 volatile int curMicNote = -1, lastMicNote=-1;

 #ifdef BBGE_BUILD_RECORD

 	volatile float timeFromLastNote=0;

 	volatile float timerFreq;

 	volatile float lastLargest=0;

 	volatile bool inMe = false;

 	volatile __int64 lastTick = 0;

 #endif

 	/*

 BOOL CALLBACK recordCallback(HRECORD handle, const void *buf, DWORD len, DWORD user)

 {

 #ifdef BBGE_BUILD_RECORD

 	if (inMe) return TRUE;

 	inMe = true;

 	//if (!dsq->game->avatar->isSinging()) return FALSE;

 	//int x,y;

 	//timerFreq =

 	__int64 freq=0;

 	QueryPerformanceFrequency((LARGE_INTEGER*)&freq);

 	__int64 curTime=0;

 	QueryPerformanceCounter((LARGE_INTEGER*)&curTime);

 	if (lastTick == 0)

 	{

 		lastTick = curTime;

 	}

 	float fft[4096]; // get the FFT data

 	BASS_ChannelGetData(handle,fft,BASS_DATA_FFT4096);

 	int v = 0;

 	int c = 0;

 	float largest = -1;

 	//128

 	//for (int i = 5; i < 13; i++)

 	for (int i = 12; i < 64; i++)

 	{

 		if (fft[i] > 0.01 && (fft[i] > largest || largest == -1))

 		{

 			largest = fft[i];

 			v = i;

 		}

 	}

 	int v2=0;

 	largest = -1;

 	// find the next largest

 	float dt = (double(curTime-lastTick)/double(freq));

 	lastTick = curTime;

 	int posMicNote=-1;

 	if (c != 0)

 		v /= float(c);

 	int ov = v;

 	float factor=1.0;

 	int octave = dsq->user.audio.octave;

 	int minNote = 12;///6;

 	int maxNote = minNote + 25; // 8

 	int octRange = 11;

 	minNote += (octRange)*octave;

 	maxNote += (octRange)*octave;

 	posMicNote = dsq->fftnotes.getNoteFromFFT(v, octave);

 	//if (lastLargest<largest || fabs(largest-lastLargest) < 0.05)

 	if (true)

 	{

 		lastLargest = largest;

 		float closeRange = 0.05;

 		// check for our e natural

 		if (posMicNote != -1)

 		{

 			curMicNote = posMicNote;

 		}

 		else

 		{

 			curMicNote = -1;

 		}

 	}

 	else

 	{

 		lastLargest -= dt;

 	}

 	timeFromLastNote += dt;

 	if (curMicNote != lastMicNote)

 		timeFromLastNote = 0;

 	if (timeFromLastNote > 0.0001)

 	{

 		micNote = curMicNote;

 		timeFromLastNote = 0;

 	}

 	if (curMicNote == -1)

 		micNote = -1;

 	lastMicNote = curMicNote;

 	inMe = false;

 #endif

 	return TRUE;

 }

 */

 /*

 class FoodIcon2 : public Quad

 {

 };

 class FoodIcon : public Quad

 {

 public:

 	FoodIcon(IngredientEffectType iet);

 	IngredientEffectType type;

 	void 

 };

 void Avatar::openFoodInterface()

 {

 	if (!singing && !pickingPullTarget && health > 0 && !isEntityDead() && !blockSinging)

 	{

 		// build it

 		foodIcons.clear();

 		foodIcons.resize(8);

 	}

 }

 */

 void Avatar::openSingingInterface()

 {

 	if (!singing && !pickingPullTarget && health > 0 && !isEntityDead() && !blockSinging)

 	{

 		//core->mouse.position = Vector(400,300);

 		if (dsq->inputMode != INPUT_MOUSE)

 		{

 			core->centerMouse();

 			//core->setMousePosition(Vector(400,300));

 		}

 		core->setMouseConstraintCircle(singingInterfaceRadius);

 		stopRoll();

 		singing = true;

 		currentSongIdx = SONG_NONE;

 		// make the singing icons appear

 		for (int i = 0; i < songIcons.size(); i++)

 		{

 			songIcons[i]->openInterface();

 		}

 		currentSong.notes.clear();

 		//

 		songInterfaceTimer = 0;

 		dsq->game->songLineRender->clear();

 		//if (avatarRecord)

 		//{

 		//	if (dsq->useMic && !dsq->autoSingMenuOpen && dsq->user.audio.micOn)

 		//	{

 		//		//avatarRecord=BASS_RecordStart(44100,1,0,&recordCallback,0);

 		//		BASS_ChannelPlay(avatarRecord, false);

 		//	}

 		//}

 		if (dsq->inputMode == INPUT_JOYSTICK)

 		{

 			core->setMousePosition(core->center);

 		}

 	}

 }

 void Avatar::closeSingingInterface()

 {

 	if (dsq->game->songLineRender)

 		dsq->game->songLineRender->clear();

 	if (singing)

 	{

 		core->setMouseConstraint(false);

 		usingDigital = false;

 		quickSongCastDelay = 1;

 		// HACK: this prevents being "locked" away from the seahorse... so naija can

 		// be in singing range of the seahorse

 		applyRidingPosition();

 		singing = false;

 		for (int i = 0; i < songIcons.size(); i++)

 		{

 			songIcons[i]->closeInterface();

 		}

 		if (dsq->continuity.form == FORM_NORMAL)

 			setHeadTexture("");

 		currentSongIdx = dsq->continuity.checkSongAssisted(currentSong);

 		if (currentSongIdx != SONG_NONE)

 		{

 			dsq->continuity.castSong(currentSongIdx);

 			currentSongIdx = SONG_NONE;

 		}

 		/*

 		if (avatarRecord)

 		{

 			if (dsq->useMic && !dsq->autoSingMenuOpen && dsq->user.audio.micOn)

 			{

 				//BASS_ChannelStop(avatarRecord);

 				BASS_ChannelPause(avatarRecord);

 				//BASS_RecordFree();

 				//avatarRecord = 0;

 			}

 		}

 		*/

 		lastMicNote = curMicNote = micNote = -1;

 	}

 }

 void Avatar::openFormInterface()

 {

 	if (!inFormInterface)

 	{

 		inFormInterface = true;

 		for(int i = 0; i < formIcons.size(); i++)

 		{

 			formIcons[i]->alpha.interpolateTo(1, 0.1);

 		}

 	}

 }

 void Avatar::closeFormInterface()

 {

 	if (inFormInterface)

 	{

 		inFormInterface = false;

 		for (int i = 0; i < formIcons.size(); i++)

 		{

 			formIcons[i]->alpha.interpolateTo(0, 0.1);

 		}

 	}

 }

 void Avatar::toggleCape(bool on)

 {

 	if (!hair) return;

 	if (!on)

 		hair->alphaMod = 0;

 	else

 		hair->alphaMod = 1;

 }

 void Avatar::refreshDualFormModel()

 {

 	//charging = 0;

 	if (dsq->continuity.dualFormMode == Continuity::DUALFORM_NAIJA)

 		refreshModel("Naija", "DualForm_Naija");

 	else if (dsq->continuity.dualFormMode == Continuity::DUALFORM_LI)

 		refreshModel("Naija", "DualForm_Li");

 }

 void Avatar::updateDualFormGlow(float dt)

 {

 	if (dsq->continuity.form == FORM_DUAL && bone_dualFormGlow)

 	{

 		float perc = 1;

 		if (requiredDualFormCharge != 0)

 			perc = float(dsq->continuity.dualFormCharge)/float(requiredDualFormCharge);

 		if (perc > 1)

 			perc = 1;

 		bone_dualFormGlow->alpha = perc*0.5 + 0.1;

 		bone_dualFormGlow->scale.interpolateTo(Vector(perc, perc), 0.2);

 	}

 }

 void Avatar::changeForm(FormType form, bool effects, bool onInit, FormType lastForm)

 {

 	/*

 	if (core->afterEffectManager)

 		core->afterEffectManager->addEffect(new ShockEffect(Vector(core->width/2, core->height/2),core->screenCenter, 0.1,0.03,15,0.2f, 0.5));

 	*/

 	/*

 	if (pullTarget)

 	{

 		pullTarget->stopPull();

 		pullTarget = 0;

 	}

 	*/

 	if (form == FORM_DUAL && !dsq->continuity.hasLi())

 		return;

 	if (!canChangeForm) return;

 	std::ostringstream os;

 	os << "changeForm: " << form;

 	debugLog(os.str());

 	/*

 	if (dsq->game)

 		dsq->game->clearControlHint();

 	*/

 	if (lastForm == FORM_NONE)

 		lastForm = dsq->continuity.form;

 	endCharge();

 	std::ostringstream os2;

 	os2 << "lastForm: " << lastForm;

 	debugLog(os2.str());

 	for (int i = 0; i < targetQuads.size(); i++)

 	{

 		if (targetQuads[i])

 			targetQuads[i]->stop();

 	}

 	if (bone_dualFormGlow)

 		bone_dualFormGlow->scale = 0;

 	clearTargets();

 	if (form != FORM_NORMAL)

 		stopAura();

 	switch (lastForm)

 	{

 	case FORM_FISH:

 	{

 		// check nearby area

 		//bool isTooCloseToWall=false;

 		if (isNearObstruction(3))

 		{

 			Vector n = dsq->game->getWallNormal(position);

 			if (!n.isZero())

 			{

 				n *= 400;

 				vel += n;

 			}

 			return;

 		}

 		//rotationOffset.interpolateTo(Vector(0,0,0), 0.5);

 	}

 	break;

 	case FORM_SUN:

 		lightFormGlow->alpha.interpolateTo(0, 0.5);

 		lightFormGlowCone->alpha.interpolateTo(0, 0.5);

 	break;

 	case FORM_SPIRIT:

 		//position.interpolateTo(bodyPosition, 2, 0);

 		position = bodyPosition;

 		dsq->continuity.warpLiToAvatar();

 		spiritBeaconEmitter.start();

 	break;

 	case FORM_BEAST:

 		//dsq->game->sceneColor3.interpolateTo(Vector(1, 1, 1), 0.5);

 	break;

 	case FORM_DUAL:

 		if (dsq->continuity.hasLi())

 		{

 			dsq->game->li->alpha = 1;

 			dsq->game->li->position = position;

 			dsq->game->li->setState(STATE_IDLE);

 		}

 	break;

 	default:

 		if (leftHandEmitter && rightHandEmitter)

 		{

 			leftHandEmitter->stop();

 			rightHandEmitter->stop();

 		}

 	break;

 	}

 	state.abilityDelay = 0;

 	formAbilityDelay = 0;

 	dsq->continuity.form = form;

 	ropeState = 0;

 	formTimer = 0;

 	if (effects)

 	{

 		if (core->afterEffectManager)

 			core->afterEffectManager->addEffect(new ShockEffect(Vector(core->width/2, core->height/2),core->screenCenter,0.08,0.05,22,0.2f, 1.2));

 		switch(form)

 		{

 		case FORM_ENERGY:

 			core->sound->playSfx("EnergyForm");

 			/*

 			dsq->game->tintColor.path.addPathNode(Vector(1,1,1),0);

 			dsq->game->tintColor.path.addPathNode(Vector(1.5,1.5,4),0.25);

 			dsq->game->tintColor.path.addPathNode(Vector(4,1.5,1),0.5);

 			dsq->game->tintColor.path.addPathNode(Vector(1,1,1),0.5);

 			dsq->game->tintColor.startPath(2);

 			*/

 			/*

 			dsq->game->tintColor = Vector(1,1,3);

 			dsq->game->tintColor.interpolateTo(Vector(1,1,1), 1);

 			*/

 		break;

 		case FORM_NORMAL:

 			core->sound->playSfx("NormalForm");

 		break;

 		case FORM_BEAST:

 			core->sound->playSfx("BeastForm");

 		break;

 		case FORM_FISH:

 			core->sound->playSfx("FishForm");

 		break;

 		case FORM_SUN:

 			core->sound->playSfx("SunForm");

 		break;

 		case FORM_NATURE:

 			core->sound->playSfx("NatureForm");

 		break;

 		case FORM_SPIRIT:

 			spiritBeaconEmitter.start();

 		break;

 		case FORM_DUAL:

 			core->sound->playSfx("DualForm");

 		break;

 		}

 		/*

 		dsq->overlay->color = Vector(1,1,1);

 		dsq->overlay->alpha.interpolateTo(1.0, 0.2);

 		avatar->disableInput();

 		setv(EV_NOINPUTNOVEL, 0);

 		core->main(0.2);

 		setv(EV_NOINPUTNOVEL, 1);

 		dsq->overlay->alpha.interpolateTo(0, 0.2);

 		dsq->overlay->color.interpolateTo(0, 0.4);

 		*/

 		dsq->overlay->color = Vector(1,1,1);

 		dsq->overlay->alpha = 1;

 		dsq->overlay->alpha.interpolateTo(0, 0.5);

 		dsq->overlay->color.interpolateTo(0, 1.0);

 	}

 	/*

 	if (form != FORM_ENERGY)

 	{

 		dsq->game->sceneColor3.interpolateTo(Vector(1,1,1), 0.2);

 	}

 	*/

 	float lastHairAlphaMod = 0;

 	if (hair)

 	{

 		hair->alphaMod = 0;

 		lastHairAlphaMod = hair->alphaMod;

 	}

 	switch (form)

 	{

 	case FORM_ENERGY:

 		refreshModel("Naija", "EnergyForm");

 		for (int i = 0; i < targetQuads.size(); i++)

 			targetQuads[i]->start();

 		leftHandEmitter->load("EnergyFormHandGlow");

 		leftHandEmitter->start();

 		rightHandEmitter->load("EnergyFormHandGlow");

 		rightHandEmitter->start();

 	break;

 	case FORM_FISH:

 	{

 		fallOffWall();

 		setBoneLock(BoneLock());

 		refreshModel("FishForm", "");

 		//rotationOffset.interpolateTo(Vector(0,0,-90), 0.5);

 		//refreshModel("NaijaFish", "");

 	}

 	break;

 	case FORM_SUN:

 	{

 		refreshModel("Naija", "SunForm");

 		lightFormGlow->moveToFront();

 		lightFormGlow->alpha.interpolateTo(0.75, 1);

 		lightFormGlowCone->alpha.interpolateTo(0.4, 1);

 		lightFormGlow->alphaMod = 0;

 		lightFormGlowCone->alphaMod = 0;

 	}

 	break;

 	case FORM_NORMAL:

 	{

 		if (lastForm == FORM_SPIRIT)

 		{

 			dsq->continuity.shiftWorlds();

 			fallOffWall();

 		}

 		refreshNormalForm();

 		//skeletalSprite.loadSkeletal("child");

 	}

 	break;

 	case FORM_NATURE:

 		refreshModel("Naija", "NatureForm");

 		if (hair)

 		{

 			hair->setTexture("Naija/Cape-NatureForm");

 			hair->alphaMod = 1.0;

 		}

 		/*

 		skeletalSprite.loadSkin("ChildTeira");

 		refreshModel();

 		*/

 		/*

 		if (dsq->game->sceneNatureForm == "forest")

 		{

 			debugLog("Forest Form");

 			dsq->continuity.form = FORM_NATURE_FOREST;

 		}

 		else if (dsq->game->sceneNatureForm == "sun")

 		{

 			dsq->continuity.form = FORM_NATURE_SUN;

 			debugLog("Sun Form");

 		}

 		else if (dsq->game->sceneNatureForm == "fire")

 		{

 			dsq->continuity.form = FORM_NATURE_FIRE;

 			debugLog("Fire Form");

 		}

 		else if (dsq->game->sceneNatureForm == "dark")

 		{

 			dsq->continuity.form = FORM_NATURE_DARK;

 			debugLog("Dark Form");

 		}

 		else if (dsq->game->sceneNatureForm == "rock" || dsq->game->sceneNatureForm.empty())

 		{

 			dsq->continuity.form = FORM_NATURE_ROCK;

 			debugLog("Rock Form");

 		}

 		*/

 	break;

 	case FORM_BEAST:

 	{

 		refreshModel("Naija", "BeastForm");

 	}

 	break;

 	case FORM_SPIRIT:

 		bodyPosition = position;

 		bodyOffset = offset;

 		fallOffWall();

 		dsq->continuity.shiftWorlds();

 		if (onInit)

 		{

 			skeletalSprite.alphaMod = 0;

 			canChangeForm = false;

 			useSpiritDistance = false;

 			inSpiritWorld = true;

 		}

 		/*

 		if (hair)

 			hair->alphaMod = lastHairAlphaMod;

 		*/

 	break;

 	case FORM_DUAL:

 	{

 		if (dsq->continuity.hasLi())

 		{

 			dsq->game->li->setState(STATE_WAIT);

 			dsq->game->li->alpha = 0;

 		}

 		//dualFormMode = DUALFORM_LI;

 		refreshDualFormModel();

 		/*

 		for (int i = 0; i < targetQuads.size(); i++)

 			targetQuads[i]->start();

 		*/

 	}

 	break;

 	default:

 	break;

 	}

 	setHeadTexture("");

 	if (effects)

 		avatar->enableInput();

 	//if (onInit) {

 		//idle();//skeletalSprite.animate("idle", -1, 0);

 	//}

 }

 int Avatar::getLastNote()

 {

 	return lastNote;

 }

 void Avatar::singNote(int note)

 {

 	currentSong.notes.push_back(note);

 	lastNote = note;

 	//int song = dsq->continuity.checkSong(currentSong);

 	//int song = dsq->continuity.checkSongAssisted(currentSong);

 	//int song = dsq->continuity.checkSongAssisted(currentSong);

 	/*

 	std::ostringstream os;

 	os << "sung note: " << note;

 	debugLog(os.str());

 	*/

 	//currentSongIdx = song;

 	/*

 	if (song != -1)

 	{

 	*/

 		/*

 		std::ostringstream os;

 		os << "Sung Song: " << song;

 		debugLog(os.str());

 		*/

 		// close in a few seconds

 		//closeSingingInterface();

 	//}

 }

 void Avatar::updateSingingInterface(float dt)

 {

 	//if (singing)

 	if (songIcons.size()>0 && songIcons[0]->alpha.x > 0)

 	{

 		if (dsq->inputMode != INPUT_JOYSTICK && !core->mouse.change.isZero())

 		{

 			if (dsq->game->songLineRender && songIcons[0]->alpha.x == 1)

 			{

 				int smallestDist = -1;

 				int closest =-1;

 				for (int i = 0; i < songIcons.size(); i++)

 				{

 					int dist = (songIcons[i]->position - core->mouse.position).getSquaredLength2D();

 					if (smallestDist == -1 || dist < smallestDist)

 					{

 						smallestDist = dist;

 						closest = i;

 					}

 				}

 				dsq->game->songLineRender->newPoint(core->mouse.position, songIcons[closest]->noteColor);

 			}

 		}

 		if (health <= 0 || isEntityDead())

 		{

 			closeSingingInterface();

 		}

 		else

 		{

 			//if (dsq->inputMode == INPUT_JOYSTICK)

 			{

 				//core->mouse.position += core->joystick.position * dsq->user.control.joyCursorSpeed;

 				/*

 				cursorPos.update(dt);

 				if (cursorPos.isInterpolating())

 				{

 				}

 				*/

 				int cursorRadius = singingInterfaceRadius-8;

 				static float returnDelay = 0;

 				Vector desired;

 				/*

 				// was recently in...

 				if (core->joystick.dpadLeft || isActing(ACTION_SWIMLEFT))

 				{

 					//debugLog("left");

 					desired.x = -(1);

 					usingDigital = true;

 				}

 				if (core->joystick.dpadRight || isActing(ACTION_SWIMRIGHT))

 				{

 					//debugLog("right");

 					desired.x = (1);

 					usingDigital = true;

 				}

 				if (core->joystick.dpadDown || isActing(ACTION_SWIMDOWN))

 				{

 					//debugLog("down");

 					desired.y = 1;

 					usingDigital = true;

 				}

 				if (core->joystick.dpadUp || isActing(ACTION_SWIMUP))

 				{

 					//debugLog("up");

 					desired.y = -1;

 					usingDigital = true;

 				}

 				*/

 				/*

 				static float dpadTimer = 0;

 				static Vector lastDesired;

 				bool doit = false;

 				if (desired == lastDesired)

 				{

 					dpadTimer += dt;

 					if (dpadTimer > 0.05)

 					{

 						dpadTimer = 0;

 						doit = true;

 					}

 				}

 				else

 				{

 					dpadTimer = 0;

 				}

 				if (doit)

 				{

 					desired.setLength2D(cursorRadius);

 					core->mouse.position = Vector(400,300)+desired;

 					core->setMousePosition(core->mouse.position);

 				}

 				lastDesired = desired;

 				*/

 				//desired.setLength2D(cursorRadius);

 				returnDelay -= dt;

 				int spd = 1500;//850;

 				desired.setLength2D(spd*dt);

 				if (dsq->inputMode == INPUT_JOYSTICK)// && !dsq->joystick.position.isLength2DIn(0.4))

 				{

 					//if (!dsq->joystick.position.isLength2DIn(0.9))

 					{

 						Vector p(core->center);

 						Vector d = dsq->joystick.position;

 						/*

 						d.x = float(int((d.x*2)))/4.0;

 						d.y = float(int((d.y*2)))/4.0;

 						d.normalize2D();

 						*/

 						if (!d.isLength2DIn(0.6))

 						{

 							d.normalize2D();

 						}

 						p = p + d*cursorRadius-1;

 						core->setMousePosition(p);

 					}

 				}

 				else if (desired.x != 0 || desired.y != 0)

 				{

 					returnDelay = 0.1;

 					//debugLog("desired not zero");

 					//debugLog("mouse position set");

 					//core->mouse.position = Vector(400,300)+desired;

 					core->mouse.position += desired;

 					Vector diff = core->mouse.position - Vector(400,300);

 					if (!diff.isLength2DIn(cursorRadius))

 					{

 						diff.setLength2D(cursorRadius);

 						core->mouse.position = Vector(400,300) +diff;

 					}

 					core->setMousePosition(core->mouse.position);

 					/*

 					cursorPos.interpolateTo(desired, 0.1);

 					core->setMousePosition(cursorPos);

 					*/

 				}

 				else if (usingDigital)

 				{

 					if (returnDelay <= 0)

 					{

 						debugLog("desired is zero");

 						Vector c = core->center;

 						Vector dir = c - core->mouse.position;

 						if (dir.isLength2DIn(8))

 						{

 							debugLog("in range");

 							core->mouse.position = c;

 						}

 						else

 						{

 							debugLog("NOT in range");

 							dir.setLength2D(dt * 400);

 							core->mouse.position += dir;

 						}

 						core->setMousePosition(core->mouse.position);

 					}

 				}

 					//(core->joystick.position * (singingInterfaceRadius-16)) + Vector(400,300);

 			}

 			//Vector dist = dsq->getGameCursorPosition() - dsq->game->avatar->position;

 			/*

 			Vector dist = core->mouse.position - Vector(400,300);

 			int checkRad = singingInterfaceRadius-10;

 			if (dist.getSquaredLength2D() > sqr(checkRad))

 			{

 				dist |= (checkRad);

 				core->setMousePosition(Vector(400,300)+dist);

 			}

 			*/

 			/*

 			static float timer=0;

 			timer += dt;

 			if (timer > 0.1)

 			{

 				if (dist.getSquaredLength2D() > sqr(singingInterfaceRadius))

 				{

 					dist |= singingInterfaceRadius-10;

 					//core->mouse.position = dsq->game->avatar->position + dist;

 				}

 			}

 			*/

 			//core->setMousePosition(Vector(400,300)+dist/*dsq->game->avatar->position + dist - core->screenCenter*/);

 			//HACK: constrain the mouse to the circle

 			/*

 			if (dist.getSquaredLength2D() > sqr(singingInterfaceRadius*core->invGlobalScale))//*core->invGlobalScale))

 			{

 				dist |= singingInterfaceRadius*core->invGlobalScale-20;

 				//core->setMousePosition(Vector(400,300));

 				core->setMousePosition(((dsq->game->avatar->position + dist)-dsq->screenCenter) + Vector(400,300));

 				//core->setMousePosition(dsq->game->avatar->position + dist);

 				//core->setMousePosition((dsq->game->avatar->position + dist)*core->globalScale.x - dsq->screenCenter);

 			}

 			*/

 			setSongIconPositions();

 		}

 	}

 }

 void Avatar::setSongIconPositions()

 {

 	float radIncr = (2*PI)/float(songIcons.size());

 	float rad = 0;

 	for (int i = 0; i < songIcons.size(); i++)

 	{

 		songIcons[i]->position = Vector(400,300)+/*this->position + */Vector(sin(rad)*singingInterfaceRadius, cos(rad)*singingInterfaceRadius);

 		rad += radIncr;

 	}

 }

 const int chkDist = 2500*2500;

 Target Avatar::getNearestTarget(const Vector &checkPos, const Vector &distPos, Entity *source, DamageType dt, bool override, std::vector<Target> *ignore, EntityList *entityList)

 {

 	BBGE_PROF(Avatar_getNearestTarget);

 	if (!entityList)

 		entityList = &dsq->entities;

 	Target t;

 	Vector targetPosition;

 	int targetPt = -1;

 	Entity *closest = 0;

 	int highestPriority = -999;

 	int smallestDist = -1;

 	Entity *e = 0;

 	FOR_ENTITIES(i)

 	{

 		e = *i;

 		/*

 		int j;

 		for (j = 0; j < targets.size(); j++)

 		{

 			if (targets[j].e == e) break;

 		}

 		if (j != targets.size()) continue;

 		*/

 		//e &&

 		if (e != this && e->targetPriority >= highestPriority && this->pullTarget != e && e->isDamageTarget(dt) && dsq->game->isValidTarget(e, this))

 		{

 			if (e->position.isNan())

 			//if (false)

 			{

 				std::ostringstream os;

 				os << "NAN position entity name: " << e->name << " type: " << e->getEntityType();

 				debugLog(os.str());

 				continue;

 			}

 			else

 			{

 				int dist = (e->position - position).getSquaredLength2D();

 				if (dist < chkDist)

 				{

 					int numTargetPoints = e->getNumTargetPoints();

 					bool clearAfter = false;

 					if (numTargetPoints == 0)

 					{

 						if (ignore)

 						{

 							int j = 0;

 							for (; j < ignore->size(); j++)

 							{

 								if ((*ignore)[j].e == e)

 									break;

 							}

 							if (j != ignore->size()) continue;

 						}

 						e->addTargetPoint(e->getEnergyShotTargetPosition());

 						clearAfter = true;

 						numTargetPoints = 1;

 					}

 					if (numTargetPoints > 0)

 					{

 						for (int i = 0; i < numTargetPoints; i++)

 						{

 							if (ignore)

 							{

 								int j = 0;

 								for (; j < ignore->size(); j++)

 								{

 									if ((*ignore)[j].e == e && (*ignore)[j].targetPt == i)

 										break;

 								}

 								if (j != ignore->size()) continue;

 							}

 							int dist = (e->getTargetPoint(i) - distPos).getSquaredLength2D();

 							//int dist = (e->getTargetPoint(i) - distPos).getLength2D();

 							if (dist < sqr(TARGET_RANGE+e->getTargetRange()))

 							{

 								if (override || (checkPos - e->getTargetPoint(i)).isLength2DIn(64))

 								{

 									dist = (e->getTargetPoint(i) - checkPos).getSquaredLength2D();

 									if (smallestDist == -1 || dist < smallestDist)

 									{

 										highestPriority = e->targetPriority;

 										targetPosition = e->getTargetPoint(i);

 										closest = e;

 										smallestDist = dist;

 										targetPt = i;

 									}

 								}

 							}

 						}

 					}

 					if (clearAfter)

 						e->clearTargetPoints();

 				}

 			}

 		}

 	}

 	t.e = closest;

 	t.pos = targetPosition;

 	t.targetPt = targetPt;

 	return t;

 }

 float maxTargetDelay = 0.5;

 bool wasDown = false;

 void Avatar::updateTargets(float dt, bool override)

 {

 	DamageType damageType = DT_AVATAR_ENERGYBLAST;

 	for (int i = 0; i < targets.size(); i++)

 	{

 		if (!targets[i].e

 		|| !targets[i].e->isPresent()

 		|| targets[i].e->getState() == STATE_DEATHSCENE

 		|| !dsq->game->isValidTarget(targets[i].e, this))

 		{

 			targets.clear();

 			break;

 		}

 	}

 	if ((dsq->inputMode == INPUT_MOUSE || dsq->inputMode == INPUT_KEYBOARD) && !(wasDown && core->mouse.buttons.right))

 	{

 		wasDown = false;

 		float mod = 1;

 		if (isCharging())

 			mod = maxTargetDelay*10;

 		targetUpdateDelay += dt*mod;

 	}

 	if (targetUpdateDelay > maxTargetDelay || override)

 	{

 		maxTargetDelay = 0;

 		std::vector<Target> oldTargets = targets;

 		if ((dsq->continuity.form == FORM_ENERGY) && ((core->mouse.buttons.right && state.spellCharge > 0.3) || override))

 			//&& state.spellCharge > 0.2 /*&& state.spellCharge < 0.5*/

 		{

 			// crappy hack for now, assuming one target:

 			targets.clear();

 			Vector dir = getAim();

 			Vector checkPos = position + dir;

 			Vector distPos = position;

 			if (!(dsq->getGameCursorPosition() - distPos).isLength2DIn(4))

 			{

 				Target t;

 				t = getNearestTarget(checkPos, distPos, this, damageType, override, &targets);

 				if (t.e)

 				{

 					//if ((t.getWorldPosition() - dsq->getGameCursorPosition()).isLength2DIn(64))

 					{

 						// found a target?

 						targets.push_back(t);

 						targetUpdateDelay = 0;

 						if (!override && core->mouse.buttons.right)

 						{

 							maxTargetDelay = 90;

 							dsq->spawnParticleEffect("TargetAquired", t.pos);

 							wasDown = true;

 						}

 					}

 				}

 			}

 			if (targets.empty())

 			{

 				for (int i = 0; i < oldTargets.size(); i++)

 				{

 					Entity *e = oldTargets[i].e;

 					if (e)

 					{

 						int dist = (e->getTargetPoint(oldTargets[i].targetPt) - distPos).getSquaredLength2D();

 						if (dist < sqr(TARGET_RANGE+e->getTargetRange()))

 						{

 							targets.push_back(oldTargets[i]);

 						}

 					}

 					else

 					{

 						targets.clear();

 						break;

 					}

 				}

 			}

 		}

 	}

 	else

 	{

 		for (int i = 0; i < targets.size(); i++)

 		{

 			Entity *e = targets[i].e;

 			if (e)

 			{

 				if (!(position - e->position).isLength2DIn(e->getTargetRange() + TARGET_RANGE + TARGET_GRACE_RANGE) || !dsq->game->isValidTarget(e, this) || !e->isDamageTarget(damageType))

 				{

 					lostTarget(i, targets[i].e);

 					targets[i].e = 0;

 					targetUpdateDelay = maxTargetDelay;

 					wasDown = false;

 				}

 			}

 		}

 	}

 }

 void Avatar::loseTargets()

 {

 	for (int i = 0; i < targets.size(); i++)

 	{

 		Entity *e = targets[i].e;

 		if (e)

 		{

 			lostTarget(i, targets[i].e);

 			targets[i].e = 0;

 			targetUpdateDelay = maxTargetDelay;

 		}

 	}

 }

 void Avatar::updateTargetQuads(float dt)

 {

 	particleManager->setSuckPosition(1, dsq->getGameCursorPosition());

 	/*

 	for (int i = 0; i < targetQuads.size(); i++)

 	{

 	}

 	*/

 	static Entity *lastTargetE = 0;

 	const float tt = 0.02;

 	for (int i = 0; i < targets.size(); i++)

 	{

 		if (targets[i].e)

 		{

 			targetQuads[i]->alpha.interpolateTo(1, 0.1);

 			Entity *e = targets[i].e;

 			if (lastTargetE != e)

 			{

 				dsq->sound->playSfx("target-lock");

 				lastTargetE = e;

 			}

 			else

 			{

 				//targetQuads[i]->position.interpolateTo(targets[i].pos, 0.01);

 			}

 			targetQuads[i]->position.interpolateTo(targets[i].pos, tt);

 			targets[i].pos = e->getTargetPoint(targets[i].targetPt);

 			if (i == 0)

 			{

 				particleManager->setSuckPosition(1, targets[i].pos);

 			}

 			/*

 			Emitter *em = targetQuads[i];

 			if (!em->isRunning())

 			{

 				em->start();

 			}

 			*/

 		}

 		else

 		{

 			targetQuads[i]->position = dsq->getGameCursorPosition();

 			//targetQuads[i]->alpha.interpolateTo(0, 0.1);

 		}

 	}

 	if (targets.empty())

 	{

 		for (int i = 0; i < targetQuads.size(); i++)

 		{

 			if (lastTargetE != 0)

 			{

 				lastTargetE = 0;

 			}

 			//targetQuads[i]->position.interpolateTo(dsq->getGameCursorPosition(),tt);

 			/*

 			std::ostringstream os;

 			os << "setting targetQuads[i] to game cursor, is running = " << targetQuads[i]->isRunning(); 

 			debugLog(os.str());

 			*/

 			targetQuads[i]->position = dsq->getGameCursorPosition();

 			if (dsq->continuity.form == FORM_ENERGY && isInputEnabled())

 			{

 				if (dsq->inputMode == INPUT_JOYSTICK && targetQuads[i]->isRunning())

 				{

 					targetQuads[i]->stop();

 				}

 				else if (dsq->inputMode != INPUT_JOYSTICK && !targetQuads[i]->isRunning())

 				{

 					targetQuads[i]->start();

 				}

 			}

 			/*

 			if (targetQuads[i]->isRunning())

 			{

 				targetQuads[i]->stop();

 			}

 			*/

 		}

 	}

 }