/*==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/>.

Additional permissions under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.

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==*/
//////////////////////////////////////////////////////////////////////////////
//																			//
//	Avatar Console Commands and Groups										//
//																			//
//////////////////////////////////////////////////////////////////////////////

#ifdef PLASMA_EXTERNAL_RELEASE
#define LIMIT_CONSOLE_COMMANDS 1
#endif

#include "pfConsoleCmd.h"
#include "plgDispatch.h"
#include "pfConsole.h"
#include "hsResMgr.h"

#include "../pfMessage/plArmatureEffectMsg.h"

#include "../plMessage/plOneShotMsg.h"
#include "../plMessage/plAvatarMsg.h"
#include "../plMessage/plInputEventMsg.h"
#include "../plMessage/plSimStateMsg.h"
#include "../plMessage/plCCRMsg.h"
#include "../plMessage/plLinkToAgeMsg.h"
#include "../pnMessage/plNotifyMsg.h"

#include "../plModifier/plSpawnModifier.h"

#include "../plResMgr/plKeyFinder.h"

#include "../plAvatar/plArmatureMod.h"
#include "../plAvatar/plAvBrainCritter.h"
#include "../plAvatar/plAvBrainHuman.h"
#include "../plAvatar/plAvBrainSwim.h"
#include "../plAvatar/plAvBrainGeneric.h"
#include "../plAvatar/plAvatarMgr.h"
#include "../plAvatar/plSeekPointMod.h"
#include "../plAvatar/plOneShotMod.h"
#include "../plAvatar/plAGAnim.h"
#include "../plAvatar/plAvBrainUser.h"
#include "../plAvatar/plAvBrainHuman.h"
#include "../plAvatar/plNPCSpawnMod.h"
#include "../plAvatar/plAGAnimInstance.h"
#include "../plAvatar/plArmatureEffects.h"
#include "../plAvatar/plAvTaskSeek.h"

//#include "../plHavok1/plSimulationMgr.h"
#include "../pnNetCommon/plNetApp.h"
#include "../plNetClient/plNetClientMgr.h"
#include "../plDrawable/plInstanceDrawInterface.h"
#include "../plDrawable/plDrawableSpans.h"

#define PF_SANITY_CHECK( cond, msg ) { if( !( cond ) ) { PrintString( msg ); return; } }

//// This is here so Microsoft VC won't decide to "optimize" this file out
void	pfConsoleCmdGroup::DummyAvatar( void )
{
}

/////////////////////////////////////////////////////////////////
//
// Please see pfConsoleCommands.cpp for detailed instructions on
// how to add console commands.
//
/////////////////////////////////////////////////////////////////



/////////////////////////////////////////////////////////////////
//
// UTILITIES - LOCAL AND OTHERWISE
//
/////////////////////////////////////////////////////////////////

plKey FindSceneObjectByName(const char* name, const char* ageName, char* statusStr, bool subString=false);
plKey FindObjectByName(const char* name, int type, const char* ageName, char* statusStr, bool subString=false);
plKey FindObjectByNameAndType(const char* name, const char* typeName, const char* ageName, 
							   char* statusStr, bool subString=false);
void PrintStringF(void pfun(const char *),const char * fmt, ...);

PF_CONSOLE_GROUP( Avatar )

#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_SUBGROUP( Avatar, Spawn )
PF_CONSOLE_SUBGROUP( Avatar, Multistage )
PF_CONSOLE_SUBGROUP( Avatar, X )		// experimental stuff
PF_CONSOLE_SUBGROUP( Avatar, Climb )
PF_CONSOLE_SUBGROUP( Avatar, Turn )     // Turning config
PF_CONSOLE_SUBGROUP( Avatar, Physics )
PF_CONSOLE_SUBGROUP( Avatar, Warp )
PF_CONSOLE_SUBGROUP( Avatar, Anim )		// anim commands
PF_CONSOLE_SUBGROUP( Avatar, AG )		// animation graph stuff
PF_CONSOLE_SUBGROUP( Avatar, LOD )

#endif // LIMIT_CONSOLE_COMMANDS

#include "../plAvatar/plAnimStage.h"

plAvBrainHuman * GetMainAvatarBrain()
{
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
	if(avatar)
	{
		plAvBrainHuman *brain = plAvBrainHuman::ConvertNoRef(avatar->GetBrain(0));
		if(brain)
			return brain;
	}
	return nil;
}

/////////////////////////////////////////////////////////////////////////////////////////
//
// THE COMMANDS
//
/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////
//
// SPAWNING
//
/////////////////////////////////////////////////////////////////////////////////////////

#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD( Avatar_Spawn, Show, "", "Print a list of spawn points.")
{
	plAvatarMgr *mgr = plAvatarMgr::GetInstance();
	int n = mgr->NumSpawnPoints();

	for (int i = 0; i < n; i++)
	{
		const plSpawnModifier * spawn = mgr->GetSpawnPoint(i);
		if(spawn)
		{
			PrintStringF(PrintString, "%d. %s", i, spawn->GetKey()->GetName());
		}
	}
}

PF_CONSOLE_CMD( Avatar_Spawn, Go, "int which", "Go a spawn point indicated by number.")
{
	plAvatarMgr *mgr = plAvatarMgr::GetInstance();
	int n = params[0];
	int max = mgr->NumSpawnPoints();
	
	if(n < max)
	{
		plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
		
		if (avatar)
		{
			double fakeTime = 0.0f;
			avatar->SpawnAt(n, fakeTime);
		}
	}
}

static int whichSpawn = 0;
PF_CONSOLE_CMD( Avatar_Spawn, next, "", "Go to the next spawn point in sequence.")
{
	plAvatarMgr *mgr = plAvatarMgr::GetInstance();
	int max = mgr->NumSpawnPoints();
	
	whichSpawn = ++whichSpawn < max ? whichSpawn : 0;
	
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
	if(avatar)
	{
		PrintStringF(PrintString, "Spawning at point %d", whichSpawn);
		double fakeTime = 0.0f;
		avatar->SpawnAt(whichSpawn, fakeTime);
	}
}

PF_CONSOLE_CMD( Avatar_Spawn, prev, "", "Go to the prev spawn point in sequence.")
{
	plAvatarMgr *mgr = plAvatarMgr::GetInstance();
	int max = mgr->NumSpawnPoints();
	
	whichSpawn= --whichSpawn >= 0 ? whichSpawn: max-1;
	
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
	if(avatar)
	{
		PrintStringF(PrintString, "Spawning at point %d", whichSpawn);
		double fakeTime = 0.0f;
		avatar->SpawnAt(whichSpawn, fakeTime);
	}
}

PF_CONSOLE_CMD( Avatar_Spawn, Respawn,"", "Moves the avatar back to the start point.")
{
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
	
	if (avatar)
	{
		avatar->Spawn(0);
	}
}

PF_CONSOLE_CMD( Avatar_Spawn, SetSpawnOverride, "string spawnPointName", "Overrides the normal spawn point choice to be the object specified.")
{
	plArmatureMod::SetSpawnPointOverride( (const char *)params[ 0 ] );
	
	char str1[ 512 ];
	sprintf( str1, "Spawn point override set to object %s", (const char *)params[ 0 ] );
	PrintString( str1 );
}

PF_CONSOLE_CMD( Avatar_Spawn, DontPanic,"", "Toggles the Don't panic link flag.")
{
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();

	if (avatar)
	{
		bool state = avatar->ToggleDontPanicLinkFlag();
		char str1[256];
		sprintf(str1, "DontPanic set to %s", state?"true":"false");
		PrintString( str1 );
	}
}


/////////////////////////////////////////////////////////////////////////////////////////
//
// TURN TUNING
//
/////////////////////////////////////////////////////////////////////////////////////////

PF_CONSOLE_CMD( Avatar_Turn, GetMaxTurn, "int walk", "Show the maximum turn speed in radians per second.")
{
	plAvBrainHuman *brain = GetMainAvatarBrain();

	float maxTurn = brain->GetMaxTurnSpeed((int)params[0] != 0);

	PrintStringF(PrintString, "Avatar max turn speed is %f radians per second.", maxTurn);
}

PF_CONSOLE_CMD( Avatar_Turn, SetMaxTurn, "float maxTurn, int walk", "Set the maximum turn speed in radians per second.")
{
	plAvBrainHuman *brain = GetMainAvatarBrain();

	float newMaxTurn = params[0];

	brain->SetMaxTurnSpeed(newMaxTurn, (int)params[1] != 0);

	PrintStringF(PrintString, "Set the avatar max turn speed to %f radians per second.", newMaxTurn);
}

// TURN TIME

PF_CONSOLE_CMD( Avatar_Turn, GetTurnTime, "int walk", "Show the amount of time required to reach max turn speed.")
{
	plAvBrainHuman *brain = GetMainAvatarBrain();

	float turnTime = brain->GetTimeToMaxTurn((int)params[0] != 0);

	PrintStringF(PrintString, "The amount of time required to reach max avatar turn speed is %f seconds.", turnTime);
}

PF_CONSOLE_CMD( Avatar_Turn, SetTurnTime, "float turnTime, int walk", "Set the amount of time required to reach max turn speed.")
{
	plAvBrainHuman *brain = GetMainAvatarBrain();

	float newTurnTime = params[0];

	brain->SetTimeToMaxTurn(newTurnTime, (int)params[1] != 0);

	PrintStringF(PrintString, "Set the amount of time required to reach max avatar turn speed to %f seconds.", newTurnTime);
}

// TURN TYPE

PF_CONSOLE_CMD( Avatar_Turn, GetTurnType, "int walk", "Show the amount of time required to reach max turn speed.")
{
	plAvBrainHuman *brain = GetMainAvatarBrain();
	
	int turnType = brain->GetTurnCurve((int)params[0] != 0);
	
	PrintStringF(PrintString, "The avatar turn curve type is  %d.", turnType);
}

PF_CONSOLE_CMD( Avatar_Turn, SetTurnType, "int turnType, int walk", "Set the turn acceleration curve type [0..2].")
{
	plAvBrainHuman *brain = GetMainAvatarBrain();
	
	int newCurveType = params[0];
	
	brain->SetTurnCurve(plAvBrainHuman::TurnCurve(newCurveType), (int)params[1] != 0);
	
	PrintStringF(PrintString, "Set turn curve to %d.", newCurveType);
}


PF_CONSOLE_CMD( Avatar_Turn, SetMouseTurnSensitivity, "float sensitivity", "Set how strong the mouse affects turning.")
{
	plArmatureMod::SetMouseTurnSensitivity(params[0]);
	
	PrintStringF(PrintString, "Set mouse sensitivity to %f", (float)params[0]);
}



/////////////////////////////////////////////////////////////////////////////////////////
//
// MULTISTAGE
//
/////////////////////////////////////////////////////////////////////////////////////////


// MULTISTAGE.TRIGGER
PF_CONSOLE_CMD( Avatar_Multistage, Trigger, "string multiComp", "Triggers the named Multistage Animation component")
{
	char str[256];
	plKey key = FindObjectByNameAndType((const char*)params[0], "plMultistageBehMod", nil, str, true);
	PrintString(str);

	if (key)
	{
		plNotifyMsg *msg = TRACKED_NEW plNotifyMsg;

		msg->fType = plNotifyMsg::kActivator;
		msg->fState = 1;	// Triggered
		
		// Setup the event data in case this is a OneShot responder that needs it
		plKey playerKey = plAvatarMgr::GetInstance()->GetLocalAvatar()->GetKey();
		proPickedEventData *ed = TRACKED_NEW proPickedEventData;
		ed->fPicker = playerKey;
		ed->fPicked = key; // ???
		msg->AddEvent(ed);
		
		// Send it to the responder modifier
		msg->AddReceiver(key);
		plgDispatch::MsgSend(msg);
	}
}

// MULTISTAGE.ADVANCE
PF_CONSOLE_CMD( Avatar_Multistage, Advance, "", "Advances the avatar's current multistage to the next stage.")
{
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
	
	if (avatar)
	{
		plKey avKey = avatar->GetKey();
		
		plAvBrainGenericMsg *msg = TRACKED_NEW plAvBrainGenericMsg(nil, avKey, plAvBrainGenericMsg::kNextStage, 0, true, 0.5f);
		msg->Send();
	}
}

// MULTISTAGE.REGRESS
PF_CONSOLE_CMD( Avatar_Multistage, Regress, "", "Regresses the avatar's current multistage to the previous stage.")
{
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
	
	if (avatar)
	{
		plKey avKey = avatar->GetKey();
		
		plAvBrainGenericMsg *msg = TRACKED_NEW plAvBrainGenericMsg(nil, avKey, plAvBrainGenericMsg::kPrevStage, 0, true, 0.5f);
		msg->Send();
	}
}

PF_CONSOLE_CMD( Avatar_Multistage, Mode, "string stage1, string stage2, string stage3", "make a simple multistage")
{
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
	
	const char *one = params[0];
	const char *two = params[1];
	const char *three = params[2];
	
	PushSimpleMultiStage(avatar, one, two, three, true, true, plAGAnim::kBodyFull);
}

/////////////////////////////////////////////////////////////////////////////////////////
//
// MISCKELANYOUS
//
/////////////////////////////////////////////////////////////////////////////////////////

PF_CONSOLE_CMD( Avatar, Debug, "", "Toggle the avatar debug display.")
{
	static int toggle = 0;
	
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
	if(avatar)
	{
		toggle = toggle ? 0 : 1;
		avatar->SetDebugState(toggle);
	}
}

PF_CONSOLE_CMD( Avatar, DebugByID, "int PlayerID", "Show debug display for a specific avatar.")
{
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->FindAvatarByPlayerID((int)params[0]);
	if (avatar)
	{
		avatar->SetDebugState(!avatar->GetDebugState());
	}
}

PF_CONSOLE_CMD( Avatar, LogSmartSeek, "int enabled", "Enable/Disable smart seek logging (avatar.log)")
{
	plAvTaskSeek::fLogProcess = ((int)params[0] == 1);
}

PF_CONSOLE_CMD( Avatar, PopBrain, "", "Remove the topmost brain from the avatar. Careful there, sport.")
{
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
	if(avatar)
	{
		avatar->PopBrain();
	}
}

#include "../plScene/plRelevanceMgr.h"

PF_CONSOLE_CMD( Avatar, 
			   MarkRelevanceRegion,
			   "string regionA, string regionB, int wantsUpdate",
			   "Mark whether avatars in regionA want updates on those on regionB" )
{
	plRelevanceMgr *mgr = plRelevanceMgr::Instance();
	char *regA = params[0];
	char *regB = params[1];
	mgr->MarkRegion(mgr->GetIndex(regA), mgr->GetIndex(regB), params[2]);
}

PF_CONSOLE_CMD( Avatar,
			   ToggleRelevanceRegions,
			   "",
			   "Enable/Disable all relevance regions" )
{
	plRelevanceMgr *mgr = plRelevanceMgr::Instance();
	mgr->SetEnabled(!mgr->GetEnabled());
	
	char buff[256];
	sprintf(buff, "All relevance regions are now %s", (mgr->GetEnabled() ? "ENABLED" : "DISABLED"));
	PrintString(buff);
}

PF_CONSOLE_CMD( Avatar, SeekPoint, "string seekpoint", "Move to the given seekpoint.")
{
	char *spName = params[0];
	
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
	
	if(avatar)
	{
		char buff[256];
		plKey seekKey = FindSceneObjectByName(spName, nil, buff);
		plSeekPointMod *mod = plAvatarMgr::GetInstance()->FindSeekPoint(spName);
		
		if(mod)
		{
			plKey seekKey = mod->GetKey();
			plSeekPointMod *seekMod = (plSeekPointMod *)seekKey->GetObjectPtr();
			plSceneObject *seekTarget = seekMod->GetTarget(0);
			plKey targetKey = seekTarget->GetKey();
			
			plKey avKey = avatar->GetKey();
			hsScalar unused = 0.0f;
			plAvSeekMsg *msg = TRACKED_NEW plAvSeekMsg(nil, avKey, targetKey, unused, false);
			
			plgDispatch::MsgSend(msg);
		}
	}
}

PF_CONSOLE_CMD( Avatar, ShowLocations, "", "Show player positions/orientations" )
{
	hsBool curVal = plNetClientApp::GetInstance()->GetFlagsBit(plNetClientApp::kShowAvatars);
	plNetClientApp::GetInstance()->SetFlagsBit(plNetClientApp::kShowAvatars, !curVal);	
}

PF_CONSOLE_CMD( Avatar,
			   SetFootEffect,
			   "int group",
			   "Force the avatar to use certain footstep effects" )
{
	const plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();
	
	if (avMod)
	{
		plArmatureEffectStateMsg *msg = TRACKED_NEW plArmatureEffectStateMsg();
		msg->AddReceiver(avMod->GetArmatureEffects()->GetKey());
		msg->fSurface = (int)params[0];
		plgDispatch::MsgSend(msg);
	}
}

PF_CONSOLE_CMD( Avatar, SetStealthMode, "int mode", "Set the stealth mode of your avatar.")
{
	const plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();
	if (avMod)
	{
		int mode=params[0];
		plKey avKey=avMod->GetTarget(0)->GetKey();
		int level = mode==plAvatarStealthModeMsg::kStealthVisible ? 0 : 1;
		
		// send msg to make myself invisible locally
		plAvatarStealthModeMsg *msg = TRACKED_NEW plAvatarStealthModeMsg();
		msg->SetSender(avKey);
		msg->fMode = mode;
		msg->fLevel = level;
		plgDispatch::MsgSend(msg);
		
		// send net msg to other players to synch them up
		// the msg will go to their NetClientMgr who will decide whether they see
		// our avatar as total or semi-invisible based on the invis level.
		plCCRInvisibleMsg *invisMsg = TRACKED_NEW plCCRInvisibleMsg;		// ctor sets flags and receiver
		invisMsg->fInvisLevel=level;
		invisMsg->fAvKey=avKey;
		invisMsg->Send();
	}
}

PF_CONSOLE_CMD( Avatar, SortFaces, "", "Toggle sorting of polys on the avatar" )
{
	const plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();
	const plSceneObject *so = avMod->GetClothingSO(0);
	
	plInstanceDrawInterface *idi = plInstanceDrawInterface::ConvertNoRef(const_cast<plDrawInterface*>(so->GetDrawInterface()));
	plDrawableSpans *drawable = idi->GetInstanceDrawable();
	drawable->SetNativeProperty(plDrawable::kPropSortFaces, !drawable->GetNativeProperty(plDrawable::kPropSortFaces));
}

#endif // LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD( Avatar, SetMouseTurnSensitivity, "float sensitivity", "Set how strong the mouse affects turning.")
{
	plArmatureMod::SetMouseTurnSensitivity(params[0]);
	
	PrintStringF(PrintString, "Set mouse sensitivity to %f", (float)params[0]);
}


PF_CONSOLE_CMD( Avatar, ClickToTurn, "bool b", "Set click-to-turn functionality.")
{
	bool b = params[0];
	plArmatureMod::fClickToTurn = b;
}

PF_CONSOLE_CMD( Avatar, FakeLinkToObj, "string objName", "Pseudo-Link the avatar to the specified object's location")
{
	char *spName = params[0];
	char buff[256];
	plKey seekKey = FindSceneObjectByName(spName, nil, buff);
	if (!seekKey)
	{
		PrintString("Can't find object with that name, fake link failed.");
		return;
	}
	plPseudoLinkEffectMsg* msg = TRACKED_NEW plPseudoLinkEffectMsg;
	msg->fAvatarKey = plNetClientMgr::GetInstance()->GetLocalPlayerKey();
	msg->fLinkObjKey = seekKey;
	plgDispatch::MsgSend(msg);
	
}


#ifndef LIMIT_CONSOLE_COMMANDS

///////////////////////////////////////////////////////////////////////////////////////////////////
//
// PHYSICS
//
///////////////////////////////////////////////////////////////////////////////////////////////////

PF_CONSOLE_CMD( Avatar_Physics, TogglePhysical, "", "Disable/enable physics on the avatar.")
{
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
	
	if(avatar)
	{
		plControlEventMsg* pMsg = TRACKED_NEW plControlEventMsg;
		pMsg->SetControlActivated(true);
		pMsg->SetControlCode(B_CONTROL_TOGGLE_PHYSICAL);
		
		avatar->MsgReceive(pMsg);
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////
//
// Animation
//
///////////////////////////////////////////////////////////////////////////////////////////////////

PF_CONSOLE_CMD( Avatar_Anim, BlendAnim, "string Animation, float blendFactor", "Blend the given animation with the current animation.")
{
	char *animationName = params[0];
	float blendFactor = params[1];
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();

	if (avatar && animationName)
	{
		plAGAnim * anim = plAGAnim::FindAnim(animationName);
		if(anim)
		{
			plAGAnimInstance * inst = avatar->AttachAnimationBlended(animationName, blendFactor);
			inst->SetLoop(true);
		} else
			PrintString("BlendAnim: Couldn't find animation.");
	}
}

PF_CONSOLE_CMD( Avatar_Anim, BlendAnimPri, "string Animation, float blendFactor, int priority", "Blend animation using priority.")
{
	char *animationName = params[0];
	float blendFactor = params[1];
	int priority = params[2];
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();

	if (avatar && animationName)
	{
		plAGAnim * anim = plAGAnim::FindAnim(animationName);
		if(anim)
		{
			plAGAnimInstance * inst = avatar->AttachAnimationBlended(animationName, blendFactor, priority);
			inst->SetLoop(true);
		} else
			PrintString("BlendAnim: Couldn't find animation.");
	}
}

PF_CONSOLE_CMD( Avatar_Anim, PlaySimpleAnim, "string AvatarName, string Animation", "Play a simple (root not animated) one time animation on the avatar")
{
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->FindAvatarByModelName(params[0]);
	if (avatar)
		avatar->PlaySimpleAnim(params[1]);
}

PF_CONSOLE_CMD( Avatar_Anim, DetachAnim, "string Animation", "Remove the given animation from the avatar.")
{
	char *animationName = params[0];
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();

	if (avatar && animationName)
	{
		plAGAnimInstance * instance = avatar->FindAnimInstance(animationName);
		if(instance)
			avatar->DetachAnimation(instance);
		else
			PrintString("DetachAnim: Couldn't find animation on avatar.");
	}
}

PF_CONSOLE_CMD( Avatar_Anim, SetBlend, "string Animation, float blend", "Set the blend of the given animation.")
{
	char *animationName = params[0];
	float blend = params[1];
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();

	if (avatar && animationName)
	{
		plAGAnimInstance *anim = avatar->FindAnimInstance(animationName);
		if(anim)
			anim->SetBlend(blend);
		else 
			PrintString("SetBlend: Couldn't find animation.");
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////
//
// LOD
//
///////////////////////////////////////////////////////////////////////////////////////////////////

PF_CONSOLE_CMD( Avatar_LOD, SetLOD, "int lod", "Show only the selected LOD.")
{
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();

	if(avatar)
	{
		plArmatureLODMod *lodder = plArmatureLODMod::ConvertNoRef(avatar);

		if(lodder)
		{
			int lod = params[0];
			
			lodder->SetLOD(lod);
		} else {
			PrintString("SetLOD: found avatar, but it doesn't support LOD.");
		}
	} else {
		PrintString("SetLOD: couldn't find avatar with that name.");
	}
}


PF_CONSOLE_CMD( Avatar_LOD, LimitLOD, "int newLOD", "Zero is (always) highest detail; 2 is (currently) lowest." )
{
	int newLOD = params[0];

	if(newLOD >= 0 && newLOD <= 2)
		plArmatureLODMod::fMinLOD = newLOD;
}

PF_CONSOLE_CMD( Avatar_LOD, SetLODDistance, "float newDist", "Set Distance for switching Avatar LOD" )
{
	plArmatureLODMod::fLODDistance = float(params[0]);
}

PF_CONSOLE_CMD( Avatar_LOD,  GetLODDistance, "", "Get Distance for switching Avatar LOD" )
{
	char buffer[256];
	
	sprintf(buffer, "Lod Distance = %f", plArmatureLODMod::fLODDistance);
	PrintString(buffer);
}

///////////////////////////////////////////////////////////////////////////////////////////////////
//
// CLIMBING
//
///////////////////////////////////////////////////////////////////////////////////////////////////



#include "../plAvatar/plAvBrainClimb.h"

PF_CONSOLE_CMD( Avatar_Climb, Start, "string direction", "Specify initial mount direction: up, down, left, right")
{
	plArmatureMod *avMod = const_cast<plArmatureMod *>(plAvatarMgr::GetInstance()->GetLocalAvatar());
	if(avMod)
	{
		const char *dirStr = params[0];
		plAvBrainClimb::Mode mode;
		if(stricmp(dirStr, "up") == 0)
			mode = plAvBrainClimb::kMountingUp;
		else if(stricmp(dirStr, "down") == 0)
			mode = plAvBrainClimb::kMountingDown;
		else if(stricmp(dirStr, "left") == 0)
			mode = plAvBrainClimb::kMountingLeft;
		else if(stricmp(dirStr, "right") == 0)
			mode = plAvBrainClimb::kMountingRight;
		plAvBrainClimb *brain = TRACKED_NEW plAvBrainClimb(mode);
		avMod->PushBrain(brain);
	}
}

PF_CONSOLE_CMD( Avatar_Climb, EnableDismount, "string direction", "Let the avatar dismount in the specified direction.")
{
	plArmatureMod *avMod = const_cast<plArmatureMod *>(plAvatarMgr::GetInstance()->GetLocalAvatar());
	if(avMod)
	{
		plKey mgr = plAvatarMgr::GetInstance()->GetKey();
		plKey avKey = avMod->GetKey();
		const char *dirStr = params[0];
		plClimbMsg::Direction dir;
		if(stricmp(dirStr, "up") == 0)
			dir = plClimbMsg::kUp;
		else if(stricmp(dirStr, "down") == 0)
			dir = plClimbMsg::kDown;
		else if(stricmp(dirStr, "left") == 0)
			dir = plClimbMsg::kLeft;
		else if(stricmp(dirStr, "right") == 0)
			dir = plClimbMsg::kRight;
		plClimbMsg *msg = TRACKED_NEW plClimbMsg(mgr, avKey, plClimbMsg::kEnableDismount, dir, true);
		msg->Send();
	}
}

PF_CONSOLE_CMD( Avatar_Climb, EnableClimb, "string direction, int onOff", "Allow or forbid climbing in the given direction.")
{
	plArmatureMod *avMod = const_cast<plArmatureMod *>(plAvatarMgr::GetInstance()->GetLocalAvatar());
	if(avMod)
	{
		plKey mgr = plAvatarMgr::GetInstance()->GetKey();
		plKey avKey = avMod->GetKey();
		const char *dirStr = params[0];
		plClimbMsg::Direction dir;
		if(stricmp(dirStr, "up") == 0)
			dir = plClimbMsg::kUp;
		else if(stricmp(dirStr, "down") == 0)
			dir = plClimbMsg::kDown;
		else if(stricmp(dirStr, "left") == 0)
			dir = plClimbMsg::kLeft;
		else if(stricmp(dirStr, "right") == 0)
			dir = plClimbMsg::kRight;
		hsBool enable = static_cast<int>(params[1]) ? true : false;
		plClimbMsg *msg = TRACKED_NEW plClimbMsg(mgr, avKey, plClimbMsg::kEnableClimb, dir, enable);
		msg->Send();
	}
}

PF_CONSOLE_CMD( Avatar_Climb, Release, "", "")
{
	plArmatureMod *avMod = const_cast<plArmatureMod *>(plAvatarMgr::GetInstance()->GetLocalAvatar());
	if(avMod)
	{
		plKey mgr = plAvatarMgr::GetInstance()->GetKey();
		plKey avKey = avMod->GetKey();
		plClimbMsg *msg = TRACKED_NEW plClimbMsg(mgr, avKey, plClimbMsg::kRelease);
		msg->Send();
	}
}

PF_CONSOLE_CMD( Avatar_Climb, FallOff, "", "")
{
	plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();
	if(avMod)
	{
		plKey mgr = plAvatarMgr::GetInstance()->GetKey();
		plKey avKey = avMod->GetKey();
		plClimbMsg *msg = TRACKED_NEW plClimbMsg(mgr, avKey, plClimbMsg::kFallOff);
		msg->Send();
	}
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// SWIMMING
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////


PF_CONSOLE_SUBGROUP( Avatar, Swim )

PF_CONSOLE_CMD( Avatar_Swim, Start, "", "")
{
	plArmatureMod *avMod = const_cast<plArmatureMod*>(plAvatarMgr::GetInstance()->GetLocalAvatar());
	if(avMod)
	{
		plAvBrainSwim * brayne = TRACKED_NEW plAvBrainSwim();
		avMod->PushBrain(brayne);
	}
}


///////////////////////////////////////////////////////////////////////////////////////////////////
//
//  WARP
//
///////////////////////////////////////////////////////////////////////////////////////////////////

// void WarpPlayerToAnother(hsBool iMove, UInt32 remoteID)
PF_CONSOLE_CMD( Avatar_Warp, WarpToPlayer, "int PlayerID", "Warp our player to the same position as another player.")
{
	plAvatarMgr::WarpPlayerToAnother(true, (int)params[0]);
}

PF_CONSOLE_CMD( Avatar_Warp, WarpPlayerHere, "int PlayerID", "Warp another player to the same position as us.")
{
	plAvatarMgr::WarpPlayerToAnother(false, (int)params[0]);
}

PF_CONSOLE_CMD( Avatar_Warp, WarpToXYZ, "float x, float y, float z", "Warp our avatar to the given location.")
{
	plAvatarMgr::WarpPlayerToXYZ((float)params[0], (float)params[1], (float)params[2]);
}

///////////////////////////////////////////////////////////////////////////////////////////////////
//
// AG (Animation Graph)
//
///////////////////////////////////////////////////////////////////////////////////////////////////

#include "hsTimer.h"

PF_CONSOLE_CMD( Avatar_AG, DumpFull, "", "print out the animation graph for the avatar")
{
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();

	double time = hsTimer::GetSysSeconds();

	avatar->DumpAniGraph(nil, false, time);
}

PF_CONSOLE_CMD( Avatar_AG, DumpFullOptimized, "", "print out the optimized animation graph for the avatar")
{
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();

	double time = hsTimer::GetSysSeconds();
	avatar->DumpAniGraph(nil, true, time);
}

PF_CONSOLE_CMD( Avatar_AG, DumpSingle, "string boneName", "print out the animation graph for the given (avatar) bone")
{
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
	double time = hsTimer::GetSysSeconds();
	const char *bone = params[0];
	avatar->DumpAniGraph(bone, false, time);
}

PF_CONSOLE_CMD( Avatar_AG, DumpSingleOptimized, "string boneName", "print out the optimized animatoin graph for the given (avatar) bone")
{
	plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
	double time = hsTimer::GetSysSeconds();
	const char *bone = params[0];
	avatar->DumpAniGraph(bone, true, time);
}

#endif // LIMIT_CONSOLE_COMMANDS