/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program 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 3 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, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "hsConfig.h"
#include "hsWindows.h"

// singular
#include "plAvatarTasks.h"

// local
#include "plArmatureMod.h"
#include "plSeekPointMod.h"
#include "plAvBrainHuman.h"
#include "plAGAnim.h"
#include "plAGAnimInstance.h"
#include "plAGModifier.h"
#include "plMatrixChannel.h"
#include "plAvCallbackAction.h"
#include "plAvatarMgr.h"

// global
#include "hsUtils.h"

// other
#include "plgDispatch.h"
#include "../plMessage/plAvatarMsg.h"
#include "../plMessage/plAnimCmdMsg.h"
#include "../plMessage/plOneShotCallbacks.h"
#include "../plMessage/plConsoleMsg.h"
#include "../pnKeyedObject/plKey.h"
#include "../pnSceneObject/plCoordinateInterface.h"
#include "../plPipeline/plDebugText.h"
#include "../plInputCore/plInputInterfaceMgr.h"
#include "../plNetClient/plNetClientMgr.h"
#include "../plNetCommon/plNetCommon.h"
#include "../plMessage/plLinkToAgeMsg.h"
#include "../pfMessage/pfKIMsg.h"

// for console hack
hsBool plAvOneShotTask::fForce3rdPerson = true;
#include "../pnMessage/plCameraMsg.h"

/////////////
//
// PLAVTASK
// Abstract definition for the avatar task class
//
/////////////
plAvTask::plAvTask()
{
}

// START
hsBool plAvTask::Start(plArmatureMod *avatar, plArmatureBrain *brain, double time, hsScalar elapsed)
{
	return true;	// true indicates the task has started succesfully
}

// PROCESS
hsBool plAvTask::Process(plArmatureMod *avatar, plArmatureBrain *brain, double time, hsScalar elapsed)
{
	return false;
}

// Finish -----------------------------------------------------------------------------------
// -------
void plAvTask::Finish(plArmatureMod *avatar, plArmatureBrain *brain, double time, hsScalar elapsed)
{
}


// DUMPDEBUG
void plAvTask::DumpDebug(const char *name, int &x, int&y, int lineHeight, char *strBuf, plDebugText &debugTxt)
{
	debugTxt.DrawString(x, y, "<anonymous task>");
	y += lineHeight;
}

// READ
void plAvTask::Read(hsStream *stream, hsResMgr *mgr)
{
	plCreatable::Read(stream, mgr);
}

// WRITE
void plAvTask::Write(hsStream *stream, hsResMgr *mgr)
{
	plCreatable::Write(stream, mgr);
}

void plAvTask::ILimitPlayersInput(plArmatureMod *avatar)
{
	// make sure this is the local avatar we are talking about	
	if (avatar == plAvatarMgr::GetInstance()->GetLocalAvatar())
	{
		plInputInterfaceMgr::GetInstance()->ForceCursorHidden(true);
		// tell the KI to be disabled while we are busy
		pfKIMsg* msg = TRACKED_NEW pfKIMsg(pfKIMsg::kTempDisableKIandBB);
		plgDispatch::MsgSend( msg );
	}
}

void plAvTask::IUndoLimitPlayersInput(plArmatureMod *avatar)
{
	// make sure this is the local avatar we are talking about	
	if (avatar == plAvatarMgr::GetInstance()->GetLocalAvatar())
	{
		plInputInterfaceMgr::GetInstance()->ForceCursorHidden(false);
		// tell the KI to be re-enabled
		pfKIMsg* msg = TRACKED_NEW pfKIMsg(pfKIMsg::kTempEnableKIandBB);
		plgDispatch::MsgSend( msg );
	}
}

/////////////
//
// AVSEEKTASK
//
/////////////

// CTOR default
plAvSeekTask::plAvSeekTask()
: fAnimName(nil),
  fAlign(kAlignHandle),
  fDuration(0.25f),
  fTarget(nil),
  fAnimInstance(nil),
  fTargetTime(nil),
  fPhysicalAtStart(false),
  fCleanup(false)
{
}

// CTOR target, align, animName
plAvSeekTask::plAvSeekTask(plKey target, plAvAlignment align, const char *animName)
: fAlign(align),
  fDuration(0.25f),
  fTarget(target),
  fAnimInstance(nil),
  fTargetTime(nil),
  fPhysicalAtStart(false),
  fCleanup(false)
{
	fAnimName = hsStrcpy(animName);
}

// CTOR target
plAvSeekTask::plAvSeekTask(plKey target)
: fAnimName(nil),
fAlign(kAlignHandle),
fDuration(0.25f),
fTarget(target),
fAnimInstance(nil),
fTargetTime(nil),
fPhysicalAtStart(false),
fCleanup(false)
{
}

void GetPositionAndRotation(hsMatrix44 transform, hsScalarTriple *position, hsQuat *rotation)
{
	hsPoint3 p = (hsPoint3)transform.GetTranslate();
	position->fX = p.fX; position->fY = p.fY; position->fZ = p.fZ;
	
	
	transform.RemoveScale();
	
	rotation->SetFromMatrix(&transform);
	rotation->Normalize();
	
	float angle;
	hsVector3 axis;
	
	rotation->GetAngleAxis(&angle, &axis);
}

// START
// Adjust our goal time based on our duration and the current time
hsBool plAvSeekTask::Start(plArmatureMod *avatar, plArmatureBrain *brain, double time, hsScalar elapsed)
{
	fTargetTime = time + fDuration;		// clock starts now....
	fPhysicalAtStart = avatar->IsPhysicsEnabled();
	avatar->EnablePhysics(false);		// always turn physics off for seek
	plAvBrainHuman *huBrain = plAvBrainHuman::ConvertNoRef(brain);
	if(huBrain)
		huBrain->IdleOnly();
	
	ILimitPlayersInput(avatar);
	
	if (!fTarget || !fTarget->ObjectIsLoaded())
	{
		fCleanup = true;
		return true;
	}
	
	plSceneObject* seekTarget = plSceneObject::ConvertNoRef(fTarget->ObjectIsLoaded());
	hsMatrix44 targetL2W = seekTarget->GetLocalToWorld();
	const plCoordinateInterface* subworldCI = nil;
	if (avatar->GetController())
		subworldCI = avatar->GetController()->GetSubworldCI();
	if (subworldCI)
		targetL2W = subworldCI->GetWorldToLocal() * targetL2W;

	switch(fAlign)
	{
		// just match our handle to the target matrix
		case kAlignHandle:
			// targetL2Sim is already correct
			break;
		// match our handle to the target matrix at the end of the given animation
		case kAlignHandleAnimEnd:
			{
				hsMatrix44 adjustment;
				plAGAnim *anim = avatar->FindCustomAnim(fAnimName);
				GetStartToEndTransform(anim, nil, &adjustment, "Handle");	// actually getting end-to-start
				targetL2W = targetL2W * adjustment;
			}
			break;
		default:
			break;
	};

	GetPositionAndRotation(targetL2W, &fTargetPosition, &fTargetRotation);
	Process(avatar, brain, time, elapsed);
	return true;
}

// CALCHANDLETARGETPOSITION
void CalcHandleTargetPosition(hsMatrix44 &result, plSceneObject *handle, plSceneObject *target, hsMatrix44 &bodyToHandle)
{
	hsMatrix44 targetToWorld = target->GetLocalToWorld();
	
	result = bodyToHandle * targetToWorld;
}

// CALCHANDLETARGETPOSITION
// where should I move my insertion point so that my bodyRoot lines up with the target?
void CalcHandleTargetPosition(hsMatrix44 &result, plSceneObject *insert, plSceneObject *target, plSceneObject *bodyRoot)
{
	hsMatrix44 bodyToHandle = bodyRoot->GetLocalToParent();
	CalcHandleTargetPosition(result, insert, target, bodyToHandle);	
}

// PROCESS
// Move closer to the goal position and orientation
hsBool plAvSeekTask::Process(plArmatureMod *avatar, plArmatureBrain *brain, double time, hsScalar elapsed)
{
	hsQuat rotation;
	hsPoint3 position;
	avatar->GetPositionAndRotationSim(&position, &rotation);

	// We've had a history of odd bugs caused by assuming a rotation quat is normalized.
	// This line here seems to be fixing one of them. (Avatars scaling oddly when smart seeking.)
	rotation.Normalize();

	double timeToGo = fTargetTime - time - elapsed;	// time from *beginning* of this interval to the goal
	if (fCleanup)
	{
		avatar->EnablePhysics( fPhysicalAtStart );
		IUndoLimitPlayersInput(avatar);
		
		return false;		// we're done processing
	}
	else if(timeToGo < .01)
	{
		fTargetRotation.Normalize();
		avatar->SetPositionAndRotationSim(&fTargetPosition, &fTargetRotation);
		fCleanup = true;	// we're going to wait one frame for the transform to propagate
		return true;		// still running until next frame/cleanup
	}
	else
	{
		hsPoint3 posToGo = fTargetPosition - position;			// vec from here to the goal
		float thisPercentage = (float)(elapsed / timeToGo);			

		hsPoint3 newPosition = position + posToGo * thisPercentage;
		hsQuat newRotation;
		newRotation.SetFromSlerp(rotation, fTargetRotation, thisPercentage);

		newRotation.Normalize();
		avatar->SetPositionAndRotationSim(&newPosition, &newRotation);
		return true;		// we're still processing
	}
}

void plAvSeekTask::LeaveAge(plArmatureMod *avatar)
{
	fTarget = nil;
	fCleanup = true;
}

///////////////////
//
// PLAVANIMTASK
//
///////////////////

// CTOR default
plAvAnimTask::plAvAnimTask()
: fAnimName(nil),
  fInitialBlend(0.0f),
  fTargetBlend(0.0f),
  fFadeSpeed(0.0f),
  fSetTime(0.0f),
  fStart(false),
  fLoop(false),
  fAttach(false),
  fAnimInstance(nil)
{
}

// CTOR animName, initialBlend, targetBlend, fadeSpeed, start, loop, attach
plAvAnimTask::plAvAnimTask(const char *animName,
						   hsScalar initialBlend,
						   hsScalar targetBlend,
						   hsScalar fadeSpeed,
						   hsScalar setTime,
						   hsBool start,
						   hsBool loop,
						   hsBool attach)
: fInitialBlend(initialBlend),
  fTargetBlend(targetBlend),
  fFadeSpeed(fadeSpeed),
  fSetTime(setTime),
  fStart(start),
  fLoop(loop),
  fAttach(attach),
  fAnimInstance(nil)
{
	if(animName)
		fAnimName = hsStrcpy(animName);
}

// CTOR animName, fadeSpeed, attach
plAvAnimTask::plAvAnimTask(const char *animName, hsScalar fadeSpeed, hsBool attach)
: fInitialBlend(0.0f),
  fTargetBlend(0.0f),
  fFadeSpeed(fadeSpeed),
  fSetTime(0.0f),
  fStart(false),
  fLoop(false),
  fAttach(attach),
  fAnimInstance(nil)
{
	if(animName)
		fAnimName = hsStrcpy(animName);
}




// DTOR
plAvAnimTask::~plAvAnimTask()
{
	if(fAnimName)
	{
		delete[] fAnimName;
		fAnimName = nil;
	}
}

// START
hsBool plAvAnimTask::Start(plArmatureMod *avatar, plArmatureBrain *brain, double time, hsScalar elapsed)
{
	hsBool result = false;
	if(fAttach)
	{
		plAGAnimInstance * aInstance = avatar->FindOrAttachInstance(fAnimName, fInitialBlend);

		if(aInstance)
		{
			if(fStart)
				aInstance->Start(fStart);
			if(fSetTime > 0)
				aInstance->SetCurrentTime(fSetTime, true);
			if(fTargetBlend > fInitialBlend)
			{
				aInstance->Fade(fTargetBlend, fFadeSpeed);
			}
			aInstance->SetLoop(fLoop);

			result = true;
		}
		else
		{
			hsStatusMessageF("Couldn't find animation <%s> for plAvAnimTask: will try again", fAnimName);
		}
	}
	else
	{
		fAnimInstance = avatar->FindAnimInstance(fAnimName);
		if(fAnimInstance)
		{
			// start fading towards zero
			fAnimInstance->Fade(0.0, fFadeSpeed);
		}
		// if we started the fade, we're done and ready to process
		// if we couldn't find the animation, we're still done.
		result = true;
	}
	return result;
}

// PROCESS
hsBool plAvAnimTask::Process(plArmatureMod *avatar, plArmatureBrain *brain, double time, hsScalar elapsed)
{
	// the only reason we need this function is to watch the animation until it fades out
	hsBool result = false;
	if(fAttach)
	{
		// we finished in the Start() function
	}
	else
	{
		if(fAnimInstance)
		{
			if(fAnimInstance->GetBlend() < 0.1)
			{
				avatar->DetachAnimation(fAnimInstance);
			}
			else
			{
				// still waiting for the fadeout; keep the task alive
				result = true;
			}
		}
	}
	return result;
}

// LEAVEAGE
void plAvAnimTask::LeaveAge(plArmatureMod *avatar)
{
	// if we are supposed to be removing the animation anyway, kill it completely on link out
	if (!fAttach)
	{
		fAnimInstance = avatar->FindAnimInstance(fAnimName);
		if(fAnimInstance)
			avatar->DetachAnimation(fAnimInstance);
	}
}

// READ
void plAvAnimTask::Read(hsStream *stream, hsResMgr *mgr)
{
	fAnimName = stream->ReadSafeString();
	fInitialBlend = stream->ReadSwapScalar();
	fTargetBlend = stream->ReadSwapScalar();
	fFadeSpeed = stream->ReadSwapScalar();
	fSetTime = stream->ReadSwapScalar();
	fStart = stream->ReadBool();
	fLoop = stream->ReadBool();
	fAttach = stream->ReadBool();
}

// WRITE
void plAvAnimTask::Write(hsStream *stream, hsResMgr *mgr)
{
	stream->WriteSafeString(fAnimName);
	stream->WriteSwapScalar(fInitialBlend);
	stream->WriteSwapScalar(fTargetBlend);
	stream->WriteSwapScalar(fFadeSpeed);
	stream->WriteSwapScalar(fSetTime);
	stream->WriteBool(fStart);
	stream->WriteBool(fLoop);
	stream->WriteBool(fAttach);
}

////////////////
//
// AVONESHOTTASK
// OBSOLETE -- DEPRECATED
//
////////////////

void plAvOneShotTask::InitDefaults()
{
	fBackwards = false;
	fDisableLooping = false;
	fDisablePhysics = true;
	fAnimName = nil;
	fMoveHandle = false;
	fAnimInstance = nil;
	fDrivable = false;
	fReversible = false;
	fEnablePhysicsAtEnd = false;
	fDetachAnimation = false;
	fIgnore = false;
	fCallbacks = nil;
	fWaitFrames = 0;
}

// CTOR default
plAvOneShotTask::plAvOneShotTask()
{
	InitDefaults();
}

// CTOR (animName, drivable, reversible)
// this construct is typically used when you want to create a one-shot task as part of a sequence
// of tasks
// it's different than the message-based constructor in that fDetachAnimation and fMoveHandle default to false
plAvOneShotTask::plAvOneShotTask(const char *animName, hsBool drivable, hsBool reversible, plOneShotCallbacks *callbacks)
{
	InitDefaults();

	fDrivable = drivable;
	fReversible = reversible;
	fCallbacks = callbacks;
	
	// we're going to use this sometime in the future, better ref it so someone else doesn't release it
	hsRefCnt_SafeRef(fCallbacks);
	fAnimName = hsStrcpy(animName);
}

// CTOR (plAvOneShotMsg, plArmatureMod)
// this constructor is typically used when we're doing a classic, isolated one-shot
// fDetachAnimation and fMoveHandle both default to *true*
plAvOneShotTask::plAvOneShotTask (plAvOneShotMsg *msg, plArmatureMod *avatar, plArmatureBrain *brain)
{
	InitDefaults();

	fDrivable = msg->fDrivable;
	fReversible = msg->fReversible;
	fCallbacks = msg->fCallbacks;
	fDetachAnimation = true;
	fMoveHandle = true;

	// we're going to use this sometime in the future, better ref it so someone else doesn't release it
	hsRefCnt_SafeRef(fCallbacks);
	fAnimName = hsStrcpy(msg->fAnimName);
}

// DTOR
plAvOneShotTask::~plAvOneShotTask()
{
	if(fAnimName)
		delete[] fAnimName;
	hsRefCnt_SafeUnRef(fCallbacks);
}


// START
hsBool plAvOneShotTask::Start(plArmatureMod *avatar, plArmatureBrain *brain, double time, hsScalar elapsed)
{
	hsBool result = false;

	if (fIgnore)
		return true;

	plAGMasterMod * master = avatar;

	fAnimInstance = master->AttachAnimationBlended(fAnimName, 0);
	fDetachAnimation = true;

	if(fAnimInstance)
	{
		fEnablePhysicsAtEnd = (avatar->IsPhysicsEnabled() && fDisablePhysics);
		if (fEnablePhysicsAtEnd)
		{
			// Must do the physics re-enable through a callback so that it happens before the "done" callback and we don't
			// step over some script's attempt to disable physics again.
			plAvatarPhysicsEnableCallbackMsg *epMsg = TRACKED_NEW plAvatarPhysicsEnableCallbackMsg(avatar->GetKey(), kStop, 0, 0, 0, 0);
			fAnimInstance->GetTimeConvert()->AddCallback(epMsg);
			hsRefCnt_SafeUnRef(epMsg);
		}	

		if (fCallbacks)
		{
			fAnimInstance->AttachCallbacks(fCallbacks);
			// ok, we're done with it, release it back to the river
			hsRefCnt_SafeUnRef(fCallbacks);
			fCallbacks = nil;
		}

		fAnimInstance->SetBlend(1.0f);
		fAnimInstance->SetSpeed(1.0f);
		plAnimTimeConvert *atc = fAnimInstance->GetTimeConvert();
		if (fBackwards)
			atc->Backwards();
		if (fDisableLooping)
			atc->Loop(false);
		
		fAnimInstance->SetCurrentTime(fBackwards ? atc->GetEnd() : atc->GetBegin(), true);
		fAnimInstance->Start(time);
			
		fWaitFrames = 2;		// wait two frames after animation finishes before finalizing


		if (fDisablePhysics)
			avatar->EnablePhysics(false);

		ILimitPlayersInput(avatar);
		
		// this is for a console command hack
		if (plAvOneShotTask::fForce3rdPerson && avatar->IsLocalAvatar())
		{
			// create message
			plCameraMsg* pMsg = TRACKED_NEW plCameraMsg;
			pMsg->SetBCastFlag(plMessage::kBCastByExactType);
			pMsg->SetBCastFlag(plMessage::kNetPropagate, false);
			pMsg->SetCmd(plCameraMsg::kResponderSetThirdPerson);
			plgDispatch::MsgSend( pMsg );	// whoosh... off it goes
		}

		fMoveHandle = (fAnimInstance->GetAnimation()->GetChannel("Handle") != nil);
		if(fMoveHandle)
		{
			plMatrixDifferenceApp *differ = avatar->GetRootAnimator();
			differ->Reset(time);		// throw away any old state
			differ->Enable(true);
		}

		avatar->ApplyAnimations(time, elapsed);							

		result = true;
	}
	else
	{
		char buf[256];
		sprintf(buf, "Oneshot: Can't find animation <%s>; all bets are off.", fAnimName);
		hsAssert(false, buf);
		result = true;
	}
	return result;
}

// PROCESS
hsBool plAvOneShotTask::Process(plArmatureMod *avatar, plArmatureBrain *brain, double time, hsScalar elapsed)
{
	// *** if we are under mouse control, adjust it here

	avatar->ApplyAnimations(time, elapsed);
	if(fAnimInstance)
	{
		if(fAnimInstance->IsFinished())
		{
			const plAGAnim * animation = fAnimInstance->GetAnimation();
			double endTime = (fBackwards ? animation->GetStart() : animation->GetEnd());
			fAnimInstance->SetCurrentTime((hsScalar)endTime);
			avatar->ApplyAnimations(time, elapsed);

			if(--fWaitFrames == 0)
			{

				plSceneObject *handle = avatar->GetTarget(0);

				avatar->DetachAnimation(fAnimInstance);
				avatar->GetRootAnimator()->Enable(false);
				plAvBrainHuman *humanBrain = plAvBrainHuman::ConvertNoRef(brain);
				if(fEnablePhysicsAtEnd)
				{
#if 0//ndef PLASMA_EXTERNAL_RELEASE
					if (!humanBrain || humanBrain->fCallbackAction->HitGroundInThisAge())
					{
						// For some reason, calling CheckValidPosition at the beginning of
						// an age can cause detectors to incorrectly report collisions. So
						// we only call this if we're in the age.
						// 
						// It's only debugging code anyway to help the artist check that
						// their oneshot doesn't end while penetrating geometry.
						char *overlaps = nil;
						if (avatar->GetPhysical())
							avatar->GetPhysical()->CheckValidPosition(&overlaps);
						if (overlaps)
						{
							char *buffy = TRACKED_NEW char[64 + strlen(overlaps)];
							sprintf(buffy, "Oneshot ends overlapping %s", overlaps);
							plConsoleMsg *showLine = TRACKED_NEW plConsoleMsg( plConsoleMsg::kAddLine, buffy );
							showLine->Send();
							delete[] overlaps;
							delete[] buffy;
						}
					}
#endif
				}					
				if (humanBrain)
					humanBrain->ResetIdle();

				IUndoLimitPlayersInput(avatar);
				// this is for a console command hack
				if (plAvOneShotTask::fForce3rdPerson && avatar->IsLocalAvatar())
				{
					// create message
					plCameraMsg* pMsg = TRACKED_NEW plCameraMsg;
					pMsg->SetBCastFlag(plMessage::kBCastByExactType);
					pMsg->SetBCastFlag(plMessage::kNetPropagate, false);
					pMsg->SetCmd(plCameraMsg::kResponderUndoThirdPerson);
					plgDispatch::MsgSend( pMsg );	// whoosh... off it goes
				}
				
				return false;
			}
			else
				return true;	// still running; waiting for fWaitFrames == 0
		}
		else
			return true;
	}
	else
		return false;
}

void plAvOneShotTask::LeaveAge(plArmatureMod *avatar)
{
	if (fAnimInstance)
		fAnimInstance->Stop();

	if (fEnablePhysicsAtEnd)
		avatar->EnablePhysics(true);

	IUndoLimitPlayersInput(avatar);
	fIgnore = true;
}

void plAvOneShotTask::SetAnimName(char *name)
{
	delete [] fAnimName;
	fAnimName = hsStrcpy(name);
}

//////////////////////
//
// PLAVONESHOTLINKTASK
//
//////////////////////

plAvOneShotLinkTask::plAvOneShotLinkTask() : plAvOneShotTask(), 
fMarkerName(nil), 
fMarkerTime(-1),
fStartTime(0),
fLinkFired(false)
{
	fDisablePhysics = false;		
}

plAvOneShotLinkTask::~plAvOneShotLinkTask()
{
	delete [] fMarkerName;
}

// task protocol
hsBool plAvOneShotLinkTask::Start(plArmatureMod *avatar, plArmatureBrain *brain, double time, hsScalar elapsed)
{
	hsBool result = plAvOneShotTask::Start(avatar, brain, time, elapsed);
	fStartTime = time;

	if (fAnimInstance && fMarkerName)
	{
		const plATCAnim *anim = plATCAnim::ConvertNoRef(fAnimInstance->GetAnimation());
		if (anim)
		{
			// GetMarker returns -1 if the marker isn't found
			fMarkerTime = anim->GetMarker(fMarkerName);
		}
	}
	return result;
}

hsBool plAvOneShotLinkTask::Process(plArmatureMod *avatar, plArmatureBrain *brain, double time, hsScalar elapsed)
{
	hsBool result = plAvOneShotTask::Process(avatar, brain, time, elapsed);
	if (fIgnore)
		return result;

	if (avatar->GetTarget(0) == plNetClientApp::GetInstance()->GetLocalPlayer())
	{
		if (!fLinkFired && (fStartTime + fMarkerTime < time))
		{
			avatar->ILinkToPersonalAge();
			
			avatar->EnablePhysics(false, plArmatureMod::kDisableReasonLinking);
			fLinkFired = true;
		}
	}

	return result;
}

void plAvOneShotLinkTask::Write(hsStream *stream, hsResMgr *mgr)
{
	plAvOneShotTask::Write(stream, mgr);
	stream->WriteSafeString(fAnimName);
	stream->WriteSafeString(fMarkerName);
}

void plAvOneShotLinkTask::Read(hsStream *stream, hsResMgr *mgr)
{
	plAvOneShotTask::Read(stream, mgr);
	fAnimName = stream->ReadSafeString();
	fMarkerName = stream->ReadSafeString();
}

void plAvOneShotLinkTask::SetMarkerName(char *name)
{
	delete [] fMarkerName;
	fMarkerName = hsStrcpy(name);
}