OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1871 Commits
81 Branches
23 Tags
172 MiB
 
 
 
 
 
Tree: d08a9c8cfa
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'd08a9c8cfa'
${ noResults }
CWE-ou-minkata/Sources/Plasma/FeatureLib/pfPython/cyAvatar.cpp

2035 lines
67 KiB
Raw Blame History

/*==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==*/
#include <Python.h>
#include "plgDispatch.h"
#include "pyKey.h"
#include "plPhysical.h"
#pragma hdrstop
#include "cyAvatar.h"
#include "plAvatar/plAvatarMgr.h"
#include "plMessage/plAvatarMsg.h"
#include "plMessage/plLinkToAgeMsg.h"
#include "plMessage/plOneShotCallbacks.h"
#include "plMessage/plOneShotMsg.h"
#include "plMessage/plMultistageMsg.h"
#include "pnMessage/plNotifyMsg.h"
#include "pnKeyedObject/plFixedKey.h"
#include "plGImage/plMipmap.h"
#include "pySceneObject.h"
#include "pyColor.h"
#include "pyImage.h"
#include "plAvatar/plOneShotMod.h"
#include "plAvatar/plMultistageBehMod.h"
#include "plAvatar/plAvatarClothing.h"
#include "plAvatar/plClothingLayout.h"
#include "plAvatar/plArmatureMod.h"
#include "plAvatar/plAvBrainHuman.h" // needed to call the emote
#include "plAnimation/plAGAnim.h" // to get the BodyUsage enum
#include "plInputCore/plAvatarInputInterface.h"
#include "plMessage/plSimStateMsg.h"
#include "plVault/plVault.h"
#include "plDrawable/plSharedMesh.h"
#include "pnSceneObject/plSceneObject.h"
#include "pnSceneObject/plCoordinateInterface.h"
#include "plDrawable/plMorphSequence.h"
#include "pnNetCommon/plNetApp.h"
///////////////////////////////////////////////////////////////////////////
//
// LOCAL FORWARD DECLs
//
///////////////////////////////////////////////////////////////////////////
bool IEnterGenericMode(const char *enterAnim, const char *idleAnim, const char *exitAnim, bool autoExit, plAGAnim::BodyUsage bodyUsage,
plAvBrainGeneric::BrainType = plAvBrainGeneric::kGeneric);
bool IExitTopmostGenericMode();
cyAvatar::cyAvatar(plKey sender, plKey recvr)
{
SetSender(sender);
AddRecvr(recvr);
fNetForce = false;
}
// setters
void cyAvatar::SetSender(plKey &sender)
{
fSender = sender;
}
void cyAvatar::AddRecvr(plKey &recvr)
{
if ( recvr != nil )
fRecvr.Append(recvr);
}
void cyAvatar::SetSenderKey(pyKey& pKey)
{
plKey k = pKey.getKey();
SetSender(k);
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : IFindArmatureModKey
// PARAMETERS : avObj - avatar sceneobject
//
// PURPOSE : find the armature mod for this sceneoabject (if its an avatar)
//
const plArmatureMod* cyAvatar::IFindArmatureMod(plKey avKey)
{
plSceneObject* avObj = plSceneObject::ConvertNoRef(avKey->ObjectIsLoaded());
if ( avObj )
{
// search through its modifiers to see if one of them is an avatar modifier
int i;
for ( i=0; i<avObj->GetNumModifiers(); i++ )
{
const plModifier* mod = avObj->GetModifier(i);
// see if it is an avatar mod base class
const plArmatureMod* avmod = plArmatureMod::ConvertNoRef(mod);
if ( avmod )
return avmod;
}
}
// otherwise we didn't find anything
return nil;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : IFindArmatureModKey
// PARAMETERS : avObj - avatar sceneobject
//
// PURPOSE : find the armature mod for this sceneoabject (if its an avatar)
//
plKey cyAvatar::IFindArmatureModKey(plKey avKey)
{
const plArmatureMod* avatar = IFindArmatureMod(avKey);
if ( avatar )
return avatar->GetKey();
// otherwise we didn't find anything
return nil;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : oneShot
// PARAMETERS :
//
// PURPOSE : oneShot Avatar (must already be there)
//
void cyAvatar::OneShot(pyKey &seekKey, float duration, bool usePhysics,
const plString &animName, bool drivable, bool reversible)
{
if ( fRecvr.Count() > 0 )
{
// create message
plAvOneShotMsg* pMsg = new plAvOneShotMsg(
(plKey )fSender,
nil,
seekKey.getKey(), // Mark D told me to do it ...paulg
duration,
usePhysics,
animName,
drivable,
reversible);
// check if this needs to be network forced to all clients
if (fNetForce )
{
// set the network propagate flag to make sure it gets to the other clients
pMsg->SetBCastFlag(plMessage::kNetPropagate);
pMsg->SetBCastFlag(plMessage::kNetForce);
}
// must have a receiver!
pMsg->SetBCastFlag(plMessage::kPropagateToModifiers);
// add all our receivers to the message receiver list
int i;
for ( i=0; i<fRecvr.Count(); i++ )
{
pMsg->AddReceiver(fRecvr[i]);
}
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : RunBehavior
// PARAMETERS :
//
// PURPOSE : Run Behavior, could be single or multi-stage shot
//
void cyAvatar::RunBehavior(pyKey &behKey, bool netForce, bool netProp)
{
// first there is someone to send to and make sure that we an avatar to send this to
if ( behKey.getKey() && fRecvr.Count() > 0)
{
// must determine if the behKey is pointing to Single or Multi Shot behavior
if (plOneShotMod::ConvertNoRef(behKey.getKey()->GetObjectPtr()))
{
// create a message OneShotMessage
plOneShotMsg* pMsg = new plOneShotMsg;
pMsg->SetBCastFlag(plMessage::kNetPropagate, netProp || netForce);
pMsg->SetBCastFlag(plMessage::kNetForce, netForce);
pMsg->SetSender(fSender);
pMsg->AddReceiver(behKey.getKey());
for (int i = 0; i < fRecvr.Count(); i++) {
// make sure there is an avatar to set
if (fRecvr[i]) {
pMsg->fPlayerKey = fRecvr[i];
pMsg->SendAndKeep(); // gotta keep the message so we can keep sending it
// there should really only be one avatar, though...
}
}
pMsg->UnRef(); // done with our reference
}
// else if it is a Multistage guy
else if ( plMultistageBehMod::ConvertNoRef(behKey.getKey()->GetObjectPtr()) != nil )
{
// its a multistage thingy... need to send it a plNotifyMsg
// create new notify message to do the actual send with
plNotifyMsg* pNMsg = new plNotifyMsg;
// set whether this should be forced over the network (ignoring net-cascading)
if (netProp)
{
pNMsg->SetBCastFlag(plMessage::kNetPropagate);
}
else
{
pNMsg->SetBCastFlag(plMessage::kNetPropagate, false);
}
if ( netForce )
{
pNMsg->SetBCastFlag(plMessage::kNetPropagate);
pNMsg->SetBCastFlag(plMessage::kNetForce);
}
else
{
pNMsg->SetBCastFlag(plMessage::kNetForce, false);
}
// copy data and event records to new NotifyMsg
pNMsg->fState = 1.0;
// need to recreate all the events in the new message by Adding them
if ( fRecvr.Count() > 0 && fRecvr[0] != nil )
{
pNMsg->AddPickEvent( (plKey)fRecvr[0], nil, true, hsPoint3(0,0,0) );
}
// add receivers
// loop though adding the ones that want to be notified of the change
pNMsg->AddReceiver(behKey.getKey());
pNMsg->SetSender(fSender);
plgDispatch::MsgSend( pNMsg );
}
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : RunBehaviorAndReply
// PARAMETERS :
//
// PURPOSE : Run Behavior, multistage only, reply to specified key'd object
//
void cyAvatar::RunBehaviorAndReply(pyKey& behKey, pyKey& replyKey, bool netForce, bool netProp)
{
plMultistageBehMod* pMod = plMultistageBehMod::ConvertNoRef(behKey.getKey()->GetObjectPtr());
if ( pMod )
{
// its a multistage thingy... need to send it a plNotifyMsg
// create new notify message to do the actual send with
plNotifyMsg* pNMsg = new plNotifyMsg;
// set whether this should be forced over the network (ignoring net-cascading)
if (netProp)
{
pNMsg->SetBCastFlag(plMessage::kNetPropagate);
}
else
{
pNMsg->SetBCastFlag(plMessage::kNetPropagate, false);
}
if (netForce)
{
// set the network propagate flag to make sure it gets to the other clients
pNMsg->SetBCastFlag(plMessage::kNetPropagate);
pNMsg->SetBCastFlag(plMessage::kNetForce);
}
else
{
pNMsg->SetBCastFlag(plMessage::kNetForce, false);
}
// copy data and event records to new NotifyMsg
pNMsg->fState = 1.0;
// need to recreate all the events in the new message by Adding them
if ( fRecvr.Count() > 0 && fRecvr[0] != nil )
{
pNMsg->AddPickEvent( (plKey)fRecvr[0], nil, true, hsPoint3(0,0,0) );
}
// add receivers
// loop though adding the ones that want to be notified of the change
pNMsg->AddReceiver(behKey.getKey());
pNMsg->SetSender(replyKey.getKey());
plgDispatch::MsgSend( pNMsg );
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : RunCoopAnim
// PARAMETERS : targetKey - target avatar pyKey
// activeAvatarAnim - animation name
// targetAvatarAnim - animation name
// range - how far away are we allowed to be? (default in glue: 6)
// dist - how close shall the avatar move? (default in glue: 3)
// move - shall he move at all? (default in glue: true)
//
// PURPOSE : Seek near another avatar and run animations on both
//
bool cyAvatar::RunCoopAnim(pyKey& targetKey, plString activeAvatarAnim, plString targetAvatarAnim, float range, float dist, bool move)
{
if (fRecvr.Count() > 0 && fRecvr[0]) {
// get the participating avatars
plArmatureMod* activeAv = plAvatarMgr::FindAvatar(fRecvr[0]);
plArmatureMod* targetAv = plAvatarMgr::FindAvatar(targetKey.getKey());
if (activeAv && targetAv) {
// build the gender-specific animation name
activeAvatarAnim = activeAv->MakeAnimationName(activeAvatarAnim);
targetAvatarAnim = targetAv->MakeAnimationName(targetAvatarAnim);
// set seek position and rotation of the avatars
hsPoint3 avPos, targetPos;
activeAv->GetPositionAndRotationSim(&avPos, nullptr);
targetAv->GetPositionAndRotationSim(&targetPos, nullptr);
hsVector3 av2target(&targetPos, &avPos); //targetPos - avPos
if (av2target.Magnitude() > range)
return false;
av2target.Normalize();
if (move)
avPos = targetPos - dist * av2target;
// create the messages and let one task queue the next
const int bcastToNetMods = plMessage::kNetPropagate | plMessage::kNetForce | plMessage::kPropagateToModifiers;
plAvOneShotMsg *avAnim = new plAvOneShotMsg(nullptr, fRecvr[0], fRecvr[0], 0.f, true, activeAvatarAnim, false, false);
avAnim->SetBCastFlag(bcastToNetMods);
plAvOneShotMsg *targetAnim = new plAvOneShotMsg(nullptr, targetKey.getKey(), targetKey.getKey(), 0.f, true, targetAvatarAnim, false, false);
targetAnim->SetBCastFlag(bcastToNetMods);
targetAnim->fFinishMsg = avAnim;
plAvSeekMsg *targetSeek = new plAvSeekMsg(nullptr, targetKey.getKey(), nullptr, 0.f, true);
targetSeek->SetBCastFlag(bcastToNetMods);
targetSeek->fTargetPos = targetPos;
targetSeek->fTargetLookAt = avPos;
targetSeek->fFinishMsg = targetAnim;
plAvSeekMsg *avSeek = new plAvSeekMsg(nullptr, fRecvr[0], nullptr, 0.f, true);
avSeek->SetBCastFlag(bcastToNetMods);
avSeek->fTargetPos = avPos;
avSeek->fTargetLookAt = targetPos;
avSeek->fFinishMsg = targetSeek;
// start the circus, messages are processed "backwards"
avSeek->Send();
return true;
}
}
return false;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : NextStage
// PARAMETERS : behKey - behavior pyKey
// : transTime - the transition time to the next stage
// (optional): rewind - whether to rewind to the front of the next stage
//
// PURPOSE : Go to the next stage in a multi-stage behavior
//
// NOTE: only works with multi-stage behaviors
//
void cyAvatar::NextStage(pyKey &behKey, float transTime, bool setTime, float newTime,
bool setDirection, bool isForward, bool netForce)
{
// first there is someone to send to and make sure that we an avatar to send this to
if ( behKey.getKey() != nil && fRecvr.Count() > 0)
{
// if it is a Multistage guy
if ( plMultistageBehMod::ConvertNoRef(behKey.getKey()->GetObjectPtr()) != nil )
{
plKey avKey = IFindArmatureModKey( (plKey)fRecvr[0] );
if ( avKey )
{
// create the message
plAvBrainGenericMsg* pMsg = new plAvBrainGenericMsg((plKey)fSender, avKey,
plAvBrainGenericMsg::kNextStage, 0, setTime, newTime,
setDirection, isForward, transTime);
if ( netForce )
pMsg->SetBCastFlag(plMessage::kNetForce | plMessage::kNetPropagate);
plgDispatch::MsgSend( pMsg );
}
}
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : PreviousStage
// PARAMETERS : behKey - behavior pyKey
// : transTime - the transition time to the next stage
// (optional): rewind - whether to rewind to the front of the next stage
//
// PURPOSE : Go to the previous stage in a multi-stage behavior
//
// NOTE: only works with multi-stage behaviors
//
void cyAvatar::PreviousStage(pyKey &behKey, float transTime, bool setTime, float newTime,
bool setDirection, bool isForward, bool netForce)
{
// first there is someone to send to and make sure that we an avatar to send this to
if ( behKey.getKey() != nil && fRecvr.Count() > 0)
{
// if it is a Multistage guy
if ( plMultistageBehMod::ConvertNoRef(behKey.getKey()->GetObjectPtr()) != nil )
{
plKey avKey = IFindArmatureModKey( (plKey)fRecvr[0] );
if ( avKey )
{
// create the message
plAvBrainGenericMsg* pMsg = new plAvBrainGenericMsg((plKey)fSender, avKey,
plAvBrainGenericMsg::kPrevStage, 0, setTime, newTime,
setDirection, isForward, transTime);
if ( netForce )
pMsg->SetBCastFlag(plMessage::kNetForce | plMessage::kNetPropagate);
plgDispatch::MsgSend( pMsg );
}
}
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : GotoStage
// PARAMETERS : behKey - behavior pyKey
// : stage - stage number to go to
// : transTime - the transition time to the next stage
// (optional): rewind - whether to rewind to the front of the next stage
//
// PURPOSE : Go to a particular stage in a multi-stage behavior
//
// NOTE: only works with multi-stage behaviors
//
void cyAvatar::GoToStage(pyKey &behKey, int32_t stage, float transTime, bool setTime, float newTime,
bool setDirection, bool isForward, bool netForce)
{
// first there is someone to send to and make sure that we an avatar to send this to
if ( behKey.getKey() != nil && fRecvr.Count() > 0)
{
// if it is a Multistage guy
if ( plMultistageBehMod::ConvertNoRef(behKey.getKey()->GetObjectPtr()) != nil )
{
plKey avKey = IFindArmatureModKey( (plKey)fRecvr[0] );
if ( avKey )
{
// create the message
plAvBrainGenericMsg* pMsg = new plAvBrainGenericMsg((plKey)fSender, avKey,
plAvBrainGenericMsg::kGotoStage, stage, setTime, newTime,
setDirection, isForward, transTime);
if ( netForce )
pMsg->SetBCastFlag(plMessage::kNetForce | plMessage::kNetPropagate);
plgDispatch::MsgSend( pMsg );
}
}
}
}
void cyAvatar::SetLoopCount(pyKey &behKey, int32_t stage, int32_t loopCount, bool netForce)
{
// if it is a Multistage guy
if ( plMultistageBehMod::ConvertNoRef(behKey.getKey()->GetObjectPtr()) != nil )
{
plMultistageModMsg* pMsg = new plMultistageModMsg((plKey)nil, behKey.getKey());
pMsg->SetCommand(plMultistageModMsg::kSetLoopCount);
pMsg->fStageNum = (uint8_t)stage;
pMsg->fNumLoops = (uint8_t)loopCount;
if ( netForce )
pMsg->SetBCastFlag(plMessage::kNetForce | plMessage::kNetPropagate);
plgDispatch::MsgSend( pMsg );
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : seek
// PARAMETERS :
//
// PURPOSE : seek Avatar (must already be there)
//
/* Unsupported. Ask Bob if you want it back.
void cyAvatar::Seek(pyKey &seekKey, float duration, bool usePhysics)
{
// must have a receiver!
if ( fRecvr.Count() > 0 )
{
// create message
plAvSeekMsg* pMsg = new plAvSeekMsg(
(plKey)fSender,nil, seekKey.getKey(),duration,usePhysics);
// check if this needs to be network forced to all clients
if (fNetForce )
{
// set the network propagate flag to make sure it gets to the other clients
pMsg->SetBCastFlag(plMessage::kNetPropagate);
pMsg->SetBCastFlag(plMessage::kNetForce);
}
pMsg->SetBCastFlag(plMessage::kPropagateToModifiers);
// add all our receivers to the message receiver list
int i;
for ( i=0; i<fRecvr.Count(); i++ )
{
pMsg->AddReceiver(fRecvr[i]);
}
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
}
}
*/
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetAvatarClothingGroup
// PARAMETERS :
//
// PURPOSE : Return what clothing group the avatar is in
//
int32_t cyAvatar::GetAvatarClothingGroup()
{
// find the avatar's armature modifier
const plArmatureMod *avMod = nil;
// we can really only talk to one avatar, so just get the first one (which is probably the only one)
if ( fRecvr.Count() > 0 && fRecvr[0] != nil )
{
plSceneObject *so = plSceneObject::ConvertNoRef(fRecvr[0]->GetObjectPtr());
if (so != nil)
{
avMod = (plArmatureMod*)so->GetModifierByType(plArmatureMod::Index());
if ( avMod )
{
return avMod->GetClothingOutfit()->fGroup;
}
}
}
return -1;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetClosetClothingList
// PARAMETERS :
//
// PURPOSE : Return a list of the wearable items for this avatar of that clothing_type
//
std::vector<plString> cyAvatar::GetEntireClothingList(int32_t clothing_type)
{
// Currently, just all the clothing available will be returned
hsTArray<plClothingItem*> clothingList = plClothingMgr::GetClothingMgr()->GetItemList();
int numItems = clothingList.GetCount();
// create the string list to send to python...
std::vector<plString> retVal;
for (int i = 0; i < numItems; i++)
retVal.push_back(clothingList[i]->GetName());
return retVal;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetClosetClothingList
// PARAMETERS :
//
// PURPOSE : Return a list of the wearable items for this avatar of that clothing_type
//
std::vector<PyObject*> cyAvatar::GetClosetClothingList(int32_t clothing_type)
{
std::vector<PyObject*> retVal;
// find the avatar's armature modifier
const plArmatureMod *avMod = nil;
// we can really only talk to one avatar, so just get the first one (which is probably the only one)
if ( fRecvr.Count() > 0 && fRecvr[0] != nil )
{
plSceneObject *so = plSceneObject::ConvertNoRef(fRecvr[0]->GetObjectPtr());
if (so != nil)
{
avMod = (plArmatureMod*)so->GetModifierByType(plArmatureMod::Index());
if ( avMod )
{
// Get all the clothes that we can wear
hsTArray<plClothingItem*> clothingList;
plClothingMgr::GetClothingMgr()->GetItemsByGroup(avMod->GetClothingOutfit()->fGroup, clothingList);
int numItems = clothingList.GetCount();
// create the string list to send to python... as a python object
int i;
for ( i=0; i<numItems; i++ )
{
plClothingItem* item = clothingList[i];
if ( clothing_type == -1 || item->fType == clothing_type )
{
// add this event record to the main event list (lists within a list)
// create list
PyObject* clothingItem = PyList_New(5);
// [0] = clothing name
PyList_SetItem(clothingItem, 0, PyString_FromPlString(item->GetName()));
// [1] = clothing type
PyList_SetItem(clothingItem, 1, PyInt_FromLong(item->fType));
// [2] = description
PyList_SetItem(clothingItem, 2, PyString_FromPlString(item->fDescription));
// [3] = ptImage of icon
if ( item->fThumbnail != nil )
// create a ptImage
PyList_SetItem(clothingItem, 3, pyImage::New(item->fThumbnail->GetKey()));
else
PyList_SetItem(clothingItem, 3, PyInt_FromLong(0));
// [4] = fCustomText
PyList_SetItem(clothingItem, 4, PyString_FromPlString(item->fCustomText));
retVal.push_back(clothingItem);
}
}
}
}
}
return retVal;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetAvatarClothingList
// PARAMETERS :
//
// PURPOSE : Return a list of the wearable items for this avatar of that clothing_type
//
std::vector<PyObject*> cyAvatar::GetAvatarClothingList()
{
std::vector<PyObject*> retVal;
// find the avatar's armature modifier
const plArmatureMod *avMod = nil;
// we can really only talk to one avatar, so just get the first one (which is probably the only one)
if ( fRecvr.Count() > 0 && fRecvr[0] != nil )
{
plSceneObject *so = plSceneObject::ConvertNoRef(fRecvr[0]->GetObjectPtr());
if (so != nil)
{
avMod = (plArmatureMod*)so->GetModifierByType(plArmatureMod::Index());
if ( avMod )
{
// Currently, just all the clothing available will be returned
hsTArray<plClothingItem*> clothingList = avMod->GetClothingOutfit()->GetItemList();
int numItems = clothingList.GetCount();
// create the string list to send to python... as a python object
int i;
for ( i=0; i<numItems; i++ )
{
// add this event record to the main event list (lists within a list)
// create list
PyObject* clothingItem = PyList_New(5);
plClothingItem* item = clothingList[i];
// [0] = clothing name
PyList_SetItem(clothingItem, 0, PyString_FromPlString(item->GetName()));
// [1] = clothing type
PyList_SetItem(clothingItem, 1, PyInt_FromLong(item->fType));
// [2] = description
PyList_SetItem(clothingItem, 2, PyString_FromPlString(item->fDescription));
// [3] = ptImage of icon
if ( item->fThumbnail != nil )
// create a ptImage
PyList_SetItem(clothingItem, 3, pyImage::New(item->fThumbnail->GetKey()));
else
PyList_SetItem(clothingItem, 3, PyInt_FromLong(0));
// [4] = fCustomText
PyList_SetItem(clothingItem, 4, PyString_FromPlString(item->fCustomText));
retVal.push_back(clothingItem);
}
}
}
}
return retVal;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetWardrobeClothingList
// PARAMETERS :
//
// PURPOSE : Return a list of items that are in the avatars closet
//
std::vector<PyObject*> cyAvatar::GetWardrobeClothingList()
{
std::vector<PyObject*> retVal;
hsTArray<plClosetItem> closetList;
plClothingMgr::GetClothingMgr()->GetClosetItems(closetList);
int numItems = closetList.GetCount();
// create the string list to send to python... as a python object
int i;
for ( i=0; i<numItems; i++ )
{
// add this event record to the main event list (lists within a list)
// create list
PyObject* closetItem = PyList_New(7);
// [0] = clothing name
PyList_SetItem(closetItem, 0, PyString_FromPlString(closetList[i].fItem->GetName()));
// [1] = clothing type
PyList_SetItem(closetItem, 1, PyInt_FromLong(closetList[i].fItem->fType));
// [2] = description
PyList_SetItem(closetItem, 2, PyString_FromPlString(closetList[i].fItem->fDescription));
// [3] = ptImage of icon
if ( closetList[i].fItem->fThumbnail != nil )
// create a ptImage
PyList_SetItem(closetItem, 3, pyImage::New(closetList[i].fItem->fThumbnail->GetKey()));
else
PyList_SetItem(closetItem, 3, PyInt_FromLong(0));
// [4] = fCustomText
PyList_SetItem(closetItem, 4, PyString_FromPlString(closetList[i].fItem->fCustomText));
// [5] = fTint1
PyList_SetItem(closetItem, 5, pyColor::New(closetList[i].fOptions.fTint1));
// [6] = fTint2
PyList_SetItem(closetItem, 6, pyColor::New(closetList[i].fOptions.fTint2));
retVal.push_back(closetItem);
}
return retVal;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : AddWardrobeClothingItem
// PARAMETERS : clothing_name - the name of the clothing item to add to your wardrobe
// : tint1 - layer one color
// : tint2 - layer two color
//
// PURPOSE : To add a clothing item to the avatar's wardrobe (closet)
//
void cyAvatar::AddWardrobeClothingItem(const plString& clothing_name,pyColor& tint1,pyColor& tint2)
{
plClothingItem *item = plClothingMgr::GetClothingMgr()->FindItemByName(clothing_name);
if ( item )
{
hsTArray<plClosetItem> items;
items.SetCount(1);
items[0].fItem = item;
items[0].fOptions.fTint1.Set(tint1.getRed(), tint1.getGreen(), tint1.getBlue(), 1.f);
items[0].fOptions.fTint2.Set(tint2.getRed(), tint2.getGreen(), tint2.getBlue(), 1.f);
plClothingMgr::GetClothingMgr()->AddItemsToCloset(items);
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetUniqueMeshList
// PARAMETERS : clothing_type - the type of clothing to get
//
// PURPOSE : Return a list of unique clothing items (each has a different mesh)
// : that belong to the specific type
//
std::vector<PyObject*> cyAvatar::GetUniqueMeshList(int32_t clothing_type)
{
std::vector<PyObject*> retVal;
// find the avatar's armature modifier
const plArmatureMod *avMod = nil;
// we can really only talk to one avatar, so just get the first one (which is probably the only one)
if ( fRecvr.Count() > 0 && fRecvr[0] != nil )
{
plSceneObject *so = plSceneObject::ConvertNoRef(fRecvr[0]->GetObjectPtr());
if (so != nil)
{
avMod = (plArmatureMod*)so->GetModifierByType(plArmatureMod::Index());
if ( avMod )
{
// Get all the clothes that we can wear
hsTArray<plClothingItem*> clothingList;
plClothingMgr::GetClothingMgr()->GetItemsByGroup(avMod->GetClothingOutfit()->fGroup, clothingList);
plClothingMgr::GetClothingMgr()->FilterUniqueMeshes(clothingList); // filter all redundant meshes
int numItems = clothingList.GetCount();
// create the string list to send to python... as a python object
int i;
for ( i=0; i<numItems; i++ )
{
plClothingItem* item = clothingList[i];
if ( clothing_type == -1 || item->fType == clothing_type )
{
// add this event record to the main event list (lists within a list)
// create list
PyObject* clothingItem = PyList_New(5);
// [0] = clothing name
PyList_SetItem(clothingItem, 0, PyString_FromPlString(item->GetName()));
// [1] = clothing type
PyList_SetItem(clothingItem, 1, PyInt_FromLong(item->fType));
// [2] = description
PyList_SetItem(clothingItem, 2, PyString_FromPlString(item->fDescription));
// [3] = ptImage of icon
if ( item->fThumbnail != nil )
// create a ptImage
PyList_SetItem(clothingItem, 3, pyImage::New(item->fThumbnail->GetKey()));
else
PyList_SetItem(clothingItem, 3, PyInt_FromLong(0));
// [4] = fCustomText
PyList_SetItem(clothingItem, 4, PyString_FromPlString(item->fCustomText));
retVal.push_back(clothingItem);
}
}
}
}
}
return retVal;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetAllWithSameMesh
// PARAMETERS : clothing_name - the name of the mesh to get the textures of
//
// PURPOSE : Return a list of clothing items that have the same mesh as
// : the item passed in
//
std::vector<PyObject*> cyAvatar::GetAllWithSameMesh(const plString& clothing_name)
{
std::vector<PyObject*> retVal;
// find the avatar's armature modifier
const plArmatureMod *avMod = nil;
// we can really only talk to one avatar, so just get the first one (which is probably the only one)
if ( fRecvr.Count() > 0 && fRecvr[0] != nil )
{
plSceneObject *so = plSceneObject::ConvertNoRef(fRecvr[0]->GetObjectPtr());
if (so != nil)
{
avMod = (plArmatureMod*)so->GetModifierByType(plArmatureMod::Index());
if ( avMod )
{
// Get all clothes with the same mesh as the one passed in
hsTArray<plClothingItem*> clothingList;
plClothingMgr::GetClothingMgr()->GetAllWithSameMesh(plClothingMgr::GetClothingMgr()->FindItemByName(clothing_name), clothingList);
int numItems = clothingList.GetCount();
// create the string list to send to python... as a python object
int i;
for ( i=0; i<numItems; i++ )
{
// add this event record to the main event list (lists within a list)
// create list
PyObject* clothingItem = PyList_New(5);
plClothingItem* item = clothingList[i];
// [0] = clothing name
PyList_SetItem(clothingItem, 0, PyString_FromPlString(item->GetName()));
// [1] = clothing type
PyList_SetItem(clothingItem, 1, PyInt_FromLong(item->fType));
// [2] = description
PyList_SetItem(clothingItem, 2, PyString_FromPlString(item->fDescription));
// [3] = ptImage of icon
if ( item->fThumbnail != nil )
// create a ptImage
PyList_SetItem(clothingItem, 3, pyImage::New(item->fThumbnail->GetKey()));
else
PyList_SetItem(clothingItem, 3, PyInt_FromLong(0));
// [4] = fCustomText
PyList_SetItem(clothingItem, 4, PyString_FromPlString(item->fCustomText));
retVal.push_back(clothingItem);
}
}
}
}
return retVal;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetMatchingClothingItem
// PARAMETERS :
//
// PURPOSE : Return the clothing item that matches this one
// : If no match then returns the number 0
//
PyObject* cyAvatar::GetMatchingClothingItem(const plString& clothing_name)
{
// Get all the clothes that we can wear
plClothingItem* match = plClothingMgr::GetClothingMgr()->GetLRMatch(plClothingMgr::GetClothingMgr()->FindItemByName(clothing_name));
if ( match )
{
// create list
PyObject* clothingItem = PyList_New(5);
// [0] = clothing name
PyList_SetItem(clothingItem, 0, PyString_FromPlString(match->GetName()));
// [1] = clothing type
PyList_SetItem(clothingItem, 1, PyInt_FromLong(match->fType));
// [2] = description
PyList_SetItem(clothingItem, 2, PyString_FromPlString(match->fDescription));
// [3] = ptImage of icon
if ( match->fThumbnail != nil )
// create a ptImage
PyList_SetItem(clothingItem, 3, pyImage::New(match->fThumbnail->GetKey()));
else
PyList_SetItem(clothingItem, 3, PyInt_FromLong(0));
// [4] = fCustomText
PyList_SetItem(clothingItem, 4, PyString_FromPlString(match->fCustomText));
return clothingItem;
}
else
return PyInt_FromLong(0);
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : WearClothingItem
// PARAMETERS :
//
// PURPOSE : Wear a particular piece of clothing based on name of clothing item
// : returns 0, if clothing item was not found
//
bool cyAvatar::WearClothingItem(const plString& clothing_name)
{
return WearClothingItemU(clothing_name,true);
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : RemoveClothingItem
// PARAMETERS :
//
// PURPOSE : Wear a particular piece of clothing based on name of clothing item
// : returns false, if clothing item was not found
//
bool cyAvatar::RemoveClothingItem(const plString& clothing_name)
{
return RemoveClothingItemU(clothing_name,true);
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : TintClothingItem
// PARAMETERS :
//
// PURPOSE : Tint a clothing item, i.e. change the color of it
//
bool cyAvatar::TintClothingItem(const plString& clothing_name, pyColor& tint)
{
return TintClothingItemU(clothing_name,tint,true);
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : TintClothingItemLayer
// PARAMETERS : clothing_name - name of the clothing item to change the color of
// : tint - what color to change it to
// : layer - which layer to change (1 or 2)
//
// PURPOSE : Tint a clothing item, i.e. change the color of it
//
bool cyAvatar::TintClothingItemLayer(const plString& clothing_name, pyColor& tint, uint8_t layer)
{
return TintClothingItemLayerU(clothing_name,tint,layer,true);
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : WearClothingItem
// PARAMETERS : --- with update flag
//
// PURPOSE : Wear a particular piece of clothing based on name of clothing item
// : returns 0, if clothing item was not found
//
bool cyAvatar::WearClothingItemU(const plString& clothing_name, bool update)
{
const plArmatureMod *avMod = nil;
// we can really only talk to one avatar, so just get the first one (which is probably the only one)
if ( fRecvr.Count() > 0 && fRecvr[0] != nil )
{
plSceneObject *so = plSceneObject::ConvertNoRef(fRecvr[0]->GetObjectPtr());
if (so != nil)
{
avMod = (plArmatureMod*)so->GetModifierByType(plArmatureMod::Index());
plClothingItem *item = plClothingMgr::GetClothingMgr()->FindItemByName(clothing_name);
if (avMod && item)
{
if ( fNetForce )
avMod->GetClothingOutfit()->AddItem(item, update, true, true);
else
avMod->GetClothingOutfit()->AddItem(item, update);
return true;
}
}
}
return false;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : RemoveClothingItemU
// PARAMETERS : --- with update flag
//
// PURPOSE : Wear a particular piece of clothing based on name of clothing item
// : returns false, if clothing item was not found
//
bool cyAvatar::RemoveClothingItemU(const plString& clothing_name, bool update)
{
const plArmatureMod *avMod = nil;
// we can really only talk to one avatar, so just get the first one (which is probably the only one)
if ( fRecvr.Count() > 0 && fRecvr[0] != nil )
{
plSceneObject *so = plSceneObject::ConvertNoRef(fRecvr[0]->GetObjectPtr());
if (so != nil)
{
avMod = (plArmatureMod*)so->GetModifierByType(plArmatureMod::Index());
plClothingItem *item = plClothingMgr::GetClothingMgr()->FindItemByName(clothing_name);
if (avMod && item)
{
if ( fNetForce )
avMod->GetClothingOutfit()->RemoveItem(item,update,true);
else
avMod->GetClothingOutfit()->RemoveItem(item,update);
return true;
}
}
}
return false;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : TintClothingItemU
// PARAMETERS : --- with update flag
//
// PURPOSE : Tint a clothing item, i.e. change the color of it
//
bool cyAvatar::TintClothingItemU(const plString& clothing_name, pyColor& tint, bool update)
{
const plArmatureMod *avMod = nil;
// we can really only talk to one avatar, so just get the first one (which is probably the only one)
if ( fRecvr.Count() > 0 && fRecvr[0] != nil )
{
plSceneObject *so = plSceneObject::ConvertNoRef(fRecvr[0]->GetObjectPtr());
if (so != nil)
{
avMod = (plArmatureMod*)so->GetModifierByType(plArmatureMod::Index());
plClothingItem *item = plClothingMgr::GetClothingMgr()->FindItemByName(clothing_name);
if (avMod && item)
{
avMod->GetClothingOutfit()->TintItem(item, tint.getRed(),tint.getGreen(),tint.getBlue(),update,true,fNetForce,true,plClothingElement::kLayerTint1);
return true;
}
}
}
return false;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : TintClothingItemLayer
// PARAMETERS : clothing_name - name of the clothing item to change the color of
// : tint - what color to change it to
// : layer - which layer to change (1 or 2)
//
// PURPOSE : Tint a clothing item, i.e. change the color of it
//
bool cyAvatar::TintClothingItemLayerU(const plString& clothing_name, pyColor& tint, uint8_t layer, bool update)
{
const plArmatureMod *avMod = nil;
// we can really only talk to one avatar, so just get the first one (which is probably the only one)
if ( fRecvr.Count() > 0 && fRecvr[0] != nil )
{
plSceneObject *so = plSceneObject::ConvertNoRef(fRecvr[0]->GetObjectPtr());
if (so != nil)
{
avMod = (plArmatureMod*)so->GetModifierByType(plArmatureMod::Index());
plClothingItem *item = plClothingMgr::GetClothingMgr()->FindItemByName(clothing_name);
if (avMod && item)
{
// Convert Python layer number to clothing code...
if (layer == 2)
layer = plClothingElement::kLayerTint2;
else
layer = plClothingElement::kLayerTint1;
avMod->GetClothingOutfit()->TintItem(item, tint.getRed(),tint.getGreen(),tint.getBlue(),update,true,fNetForce,true,layer);
return true;
}
}
}
return false;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetClothingItemParameterString
// PARAMETERS :
//
// PURPOSE : Get the custom parameter string for a clothing item
//
plString cyAvatar::GetClothingItemParameterString(const plString& clothing_name)
{
const plArmatureMod *avMod = nil;
// we can really only talk to one avatar, so just get the first one (which is probably the only one)
if ( fRecvr.Count() > 0 && fRecvr[0] != nil )
{
plSceneObject *so = plSceneObject::ConvertNoRef(fRecvr[0]->GetObjectPtr());
if (so != nil)
{
avMod = (plArmatureMod*)so->GetModifierByType(plArmatureMod::Index());
plClothingItem *item = plClothingMgr::GetClothingMgr()->FindItemByName(clothing_name);
if (avMod && item)
{
return item->fCustomText;
}
}
}
return "";
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetTintClothingItem
// PARAMETERS :
//
// PURPOSE : Get the tint a clothing item, i.e. change the color of it
//
PyObject* cyAvatar::GetTintClothingItem(const plString& clothing_name)
{
return GetTintClothingItemL(clothing_name, 1);
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetTintClothingItem
// PARAMETERS :
//
// PURPOSE : Get the tint a clothing item, i.e. change the color of it
//
PyObject* cyAvatar::GetTintClothingItemL(const plString& clothing_name, uint8_t layer)
{
const plArmatureMod *avMod = nil;
// we can really only talk to one avatar, so just get the first one (which is probably the only one)
if ( fRecvr.Count() > 0 && fRecvr[0] != nil )
{
plSceneObject *so = plSceneObject::ConvertNoRef(fRecvr[0]->GetObjectPtr());
if (so != nil)
{
avMod = (plArmatureMod*)so->GetModifierByType(plArmatureMod::Index());
plClothingItem *item = plClothingMgr::GetClothingMgr()->FindItemByName(clothing_name);
if (avMod && item)
{
// Convert Python layer number to clothing code...
if (layer == 2)
layer = plClothingElement::kLayerTint2;
else
layer = plClothingElement::kLayerTint1;
hsColorRGBA tint = avMod->GetClothingOutfit()->GetItemTint(item,layer);
return pyColor::New(tint);
}
}
}
plString errmsg = plFormat("Cannot find clothing item {} to find out what tint it is", clothing_name);
PyErr_SetString(PyExc_KeyError, errmsg.c_str());
// returning nil means an error occurred
return nil;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : TintSkin
// PARAMETERS :
//
// PURPOSE : Tint the skin of the player's avatar
//
void cyAvatar::TintSkin(pyColor& tint)
{
TintSkinU(tint,true);
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : TintSkinU
// PARAMETERS :
//
// PURPOSE : Tint the skin of the player's avatar with optional update flag
//
void cyAvatar::TintSkinU(pyColor& tint, bool update)
{
const plArmatureMod *avMod = nil;
// we can really only talk to one avatar, so just get the first one (which is probably the only one)
if ( fRecvr.Count() > 0 && fRecvr[0] != nil )
{
plSceneObject *so = plSceneObject::ConvertNoRef(fRecvr[0]->GetObjectPtr());
if (so != nil)
{
avMod = (plArmatureMod*)so->GetModifierByType(plArmatureMod::Index());
avMod->GetClothingOutfit()->TintSkin(tint.getRed(),tint.getGreen(),tint.getBlue(),update,true);
}
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetTintSkin
// PARAMETERS :
//
// PURPOSE : Get the tint of the skin of the player's avatar
//
PyObject* cyAvatar::GetTintSkin()
{
const plArmatureMod *avMod = nil;
// we can really only talk to one avatar, so just get the first one (which is probably the only one)
if ( fRecvr.Count() > 0 && fRecvr[0] != nil )
{
plSceneObject *so = plSceneObject::ConvertNoRef(fRecvr[0]->GetObjectPtr());
if (so != nil)
{
avMod = (plArmatureMod*)so->GetModifierByType(plArmatureMod::Index());
hsColorRGBA tint = avMod->GetClothingOutfit()->fSkinTint;
// now create the ptColor Python object
return pyColor::New(tint);
}
}
PyErr_SetString(PyExc_KeyError, "Cannot find the skin of the player. Whatever that means!");
// returning nil means an error occurred
return nil;
}
plMorphSequence* cyAvatar::LocalMorphSequence()
{
plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();
if (!avMod)
return nil;
const plSceneObject *so = avMod->GetClothingSO(0); // grabbing the high LOD node
if (!so)
return nil;
const plModifier* constSeq = nil;
int i;
for (i = 0; i < so->GetNumModifiers(); i++)
{
constSeq = so->GetModifier(i);
if (constSeq && plMorphSequence::ConvertNoRef(constSeq))
{
return (plMorphSequence*)constSeq; // safe cast, we've already checked type (plus we're const_cast'ing).
}
}
return nil;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : SetMorph
// PARAMETERS : clothing_name - the name of the clothing to morph
// : layer - the layer to affect
// : value - what the new value should be (clipped between -1 and 1)
//
// PURPOSE : Set the morph value of a specific layer of clothing
//
void cyAvatar::SetMorph(const plString& clothing_name, uint8_t layer, float value)
{
plClothingItem *item = plClothingMgr::GetClothingMgr()->FindItemByName(clothing_name);
if( !item )
{
PyErr_SetString(PyExc_KeyError, "Item not found");
return;
}
float wgtPlus;
float wgtMinus;
if(value > 1.0) value = 1.0;
if(value < -1.0) value = -1.0;
if (value > 0)
{
wgtPlus = value;
wgtMinus = 0;
}
else
{
wgtMinus = -value;
wgtPlus = 0;
}
if ( fRecvr.Count() > 0 && fRecvr[0] != nil )
{
plSceneObject *so = plSceneObject::ConvertNoRef(fRecvr[0]->GetObjectPtr());
if (so != nil)
{
const plArmatureMod *avMod = (plArmatureMod*)so->GetModifierByType(plArmatureMod::Index());
if (avMod && avMod->GetClothingOutfit())
{
avMod->GetClothingOutfit()->MorphItem(item, layer, 0, wgtPlus, true);
avMod->GetClothingOutfit()->MorphItem(item, layer, 1, wgtMinus, true);
}
}
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetMorph
// PARAMETERS : clothing_name - the name of the clothing to get the value from
// : layer - the layer to get the value from
//
// PURPOSE : Returns the current morph value of the specific layer of clothing
//
float cyAvatar::GetMorph(const plString& clothing_name, uint8_t layer)
{
plMorphSequence* seq = LocalMorphSequence();
if( !seq )
{
PyErr_SetString(PyExc_KeyError, "Sequence not found");
return 0;
}
plClothingItem *item = plClothingMgr::GetClothingMgr()->FindItemByName(clothing_name);
if( !item )
{
PyErr_SetString(PyExc_KeyError, "Item not found");
return 0;
}
plKey meshKey = item->fMeshes[0]->GetKey();
if (layer >= seq->GetNumLayers(meshKey))
{
PyErr_SetString(PyExc_KeyError, "Layer index too high");
return 0;
}
float wgtPlus;
float wgtMinus;
wgtPlus = seq->GetWeight(layer,0,meshKey);
wgtMinus = seq->GetWeight(layer,1,meshKey);
if (wgtPlus > 0)
return wgtPlus;
else
return -wgtMinus;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : SetSkinBlend
// PARAMETERS : layer - the layer to affect
// : value - what the new value should be (clipped between 0 and 1)
//
// PURPOSE : Set the skin blend for the specified layer
//
void cyAvatar::SetSkinBlend(uint8_t layer, float value)
{
if (value < 0.0) value = 0.0;
if (value > 1.0) value = 1.0;
plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();
if (avMod)
{
avMod->GetClothingOutfit()->SetSkinBlend(value, (int)layer + plClothingElement::kLayerSkinBlend1 - 1);
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetSkinBlend
// PARAMETERS : layer - the layer to get the blend for
//
// PURPOSE : Returns the current layer's skin blend
//
float cyAvatar::GetSkinBlend(uint8_t layer)
{
plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();
if (avMod)
{
return avMod->GetClothingOutfit()->GetSkinBlend((int)layer + plClothingElement::kLayerSkinBlend1 - 1);
}
return 0;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : SaveClothing
// PARAMETERS :
//
// PURPOSE : Saves the current clothing to the vault (including morphs)
//
void cyAvatar::SaveClothing()
{
plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();
if (avMod)
avMod->GetClothingOutfit()->SaveCustomizations();
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : EnterSubWorld
// PARAMETERS : object - a sceneobject that is in the subworld
//
// PURPOSE : Place the Avatar into the subworld of the sceneobject specified
//
void cyAvatar::EnterSubWorld(pySceneObject& object)
{
// make sure that there is atleast one avatar scene object attached (should be)
if ( fRecvr.Count() > 0)
{
// find the armature modifier
plArmatureMod* avatar = (plArmatureMod*)IFindArmatureMod((plKey)fRecvr[0]);
if(avatar)
{
// get the sceneobject that we will use to find the subworld
plKey SOkey = object.getObjKey();
if ( SOkey )
{
plSceneObject *SO = plSceneObject::ConvertNoRef(SOkey->ObjectIsLoaded());
if(SO)
{
plKey subWorldKey = SOkey;
plKey physKey = avatar->GetKey();
plKey nilKey; // sorry
plSubWorldMsg *swMsg = new plSubWorldMsg(nilKey, physKey, subWorldKey);
swMsg->Send();
}
}
}
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : ExitSubWorld
// PARAMETERS : (none)
//
// PURPOSE : Exit the avatar from the subworld, back into the ... <whatever> world
//
void cyAvatar::ExitSubWorld()
{
// make sure that there is atleast one avatar scene object attached (should be)
if ( fRecvr.Count() > 0)
{
// find the armature modifier
plArmatureMod* avatar = (plArmatureMod*)IFindArmatureMod((plKey)fRecvr[0]);
if(avatar)
{
plKey subWorldKey; // we're going to the nil subworld
plKey physKey = avatar->GetKey();
plKey nilKey; // sorry
plSubWorldMsg *swMsg = new plSubWorldMsg(nilKey, physKey, subWorldKey);
swMsg->Send();
}
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : PlaySimpleAnimation
// PARAMETERS : object - a sceneobject that is in the subworld
//
// PURPOSE : Place the Avatar into the subworld of the sceneobject specified
//
void cyAvatar::PlaySimpleAnimation(const plString& animName)
{
// make sure that there is atleast one avatar scene object attached (should be)
if ( fRecvr.Count() > 0)
{
// find the armature modifier
plArmatureMod* avatar = (plArmatureMod*)IFindArmatureMod((plKey)fRecvr[0]);
if(avatar)
{
avatar->PlaySimpleAnim(animName);
}
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : SaveClothingToFile
// PARAMETERS : filename - file to save to
//
// PURPOSE : Save the avatar's clothing to a file. If only a filename is
// given, it will write to UserData/Avatars.
//
bool cyAvatar::SaveClothingToFile(plFileName filename)
{
if (fRecvr.Count() > 0) {
plArmatureMod* avatar = plAvatarMgr::FindAvatar(fRecvr[0]);
if (avatar) {
plClothingOutfit* cl = avatar->GetClothingOutfit();
if (cl) {
// Save file in UserData/Avatars if only a filename is given
if (!filename.StripFileName().IsValid()) {
plFileName path = plFileName::Join(plFileSystem::GetUserDataPath(), "Avatars");
plFileSystem::CreateDir(path, true);
filename = plFileName::Join(path, filename);
}
return cl->WriteToFile(filename);
}
}
}
return false;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : LoadClothingFromFile
// PARAMETERS : filename - file to load from
//
// PURPOSE : Load the avatar's clothing from a file. If only a filename is
// given, it will read from UserData/Avatars.
//
bool cyAvatar::LoadClothingFromFile(plFileName filename)
{
if (fRecvr.Count() > 0) {
plArmatureMod* avatar = plAvatarMgr::FindAvatar(fRecvr[0]);
if (avatar) {
plClothingOutfit* cl = avatar->GetClothingOutfit();
if (cl) {
// Search for file in UserData/Avatars if only a filename is given
if (!filename.StripFileName().IsValid())
filename = plFileName::Join(plFileSystem::GetUserDataPath(), "Avatars", filename);
cl->SetClothingFile(filename);
return cl->ReadClothing();
}
}
}
return false;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : ChangeAvatar
// PARAMETERS : gender name - is a string of the name of the gender to go to
//
// PURPOSE : Change the local avatar's gender.
//
// Valid genders:
// Male
// Female
//
void cyAvatar::ChangeAvatar(const char* genderName)
{
#ifndef PLASMA_EXTERNAL_RELEASE
plClothingMgr::ChangeAvatar(genderName);
hsRef<RelVaultNode> rvnPlr = VaultGetPlayerNode();
if (rvnPlr) {
VaultPlayerNode plr(rvnPlr);
plr.SetAvatarShapeName(genderName);
}
#endif
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : ChangePlayerName
// PARAMETERS : name - is a string of the new name for the player
//
// PURPOSE : Change the local player's avatar name
//
void cyAvatar::ChangePlayerName(const char* playerName)
{
hsRef<RelVaultNode> rvnPlr = VaultGetPlayerNode();
if (rvnPlr) {
VaultPlayerNode plr(rvnPlr);
plr.SetPlayerName(playerName);
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : Emote
// PARAMETERS : emoteName - name of the emote to play on the avatar
//
// PURPOSE : plays an emote on a the local avatar (net propagated)
//
bool cyAvatar::Emote(const char* emoteName)
{
// can we find an emote of this name?
plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
return AvatarEmote(avatar, emoteName);
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : Sit
// PARAMETERS : none
//
// PURPOSE : Makes the avatar sit down on the ground where they are.
// The avatar will automatically stand when the user tries to move.
//
bool cyAvatar::Sit()
{
return IEnterGenericMode("SitDownGround", "SitIdleGround", "SitStandGround", true, plAGAnim::kBodyLower, plAvBrainGeneric::kSitOnGround);
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : EnterKiMode
// PARAMETERS : none
//
// PURPOSE : Makes the avatar appear to be using the ki.
//
bool cyAvatar::EnterKiMode()
{
return IEnterGenericMode("KiBegin", "KiUse", "KiEnd", false, plAGAnim::kBodyFull);
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : ExitKiMode
// PARAMETERS : none
//
// PURPOSE : Makes the avatar stop appearing to use the ki.
// May cause problems if EnterKiMode() was not called earlier.
//
bool cyAvatar::ExitKiMode()
{
return IExitTopmostGenericMode();
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : EnterAFKMode
// PARAMETERS : none
//
// PURPOSE : Tell the avatar to enter the AFK mode (sitting, head down)
//
bool cyAvatar::EnterAFKMode()
{
return IEnterGenericMode("AFKEnter", "AFKIdle", "AFKExit", true, plAGAnim::kBodyFull, plAvBrainGeneric::kAFK);
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : ExitAFKMode
// PARAMETERS : none
//
// PURPOSE : Tell the avatar to exit the AFK mode
// May cause problems if EnterKiMode() was not called earlier.
//
bool cyAvatar::ExitAFKMode()
{
return IExitTopmostGenericMode();
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : EnterPBMode
// PARAMETERS : none
//
// PURPOSE : Enter the personal book mode...stay until further notice.
//
bool cyAvatar::EnterPBMode()
{
return IEnterGenericMode("PersonalBookEnter", "PersonalBookIdle", "PersonalBookExit", false, plAGAnim::kBodyFull);
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : ExitPBMode
// PARAMETERS : none
//
// PURPOSE : Leave the personal book mode. Currently leaves any mode; will become
// : more specific in future version
//
bool cyAvatar::ExitPBMode()
{
return IExitTopmostGenericMode();
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : EnterAnimMode
// PARAMETERS : animName - string
//
// PURPOSE : Makes the avatar enter a custom anim loop.
//
bool cyAvatar::EnterAnimMode(const plString& animName)
{
plArmatureMod* fAvMod = plAvatarMgr::GetInstance()->GetLocalAvatar();
return PushRepeatEmote(fAvMod, animName);
}
int cyAvatar::GetCurrentMode()
{
// make sure that there is atleast one avatar scene object attached (should be)
if ( fRecvr.Count() > 0)
{
// find the armature modifier
plArmatureMod* avatar = (plArmatureMod*)IFindArmatureMod((plKey)fRecvr[0]);
if(avatar)
{
return avatar->GetCurrentGenericType();
}
}
return plAvBrainGeneric::kNonGeneric;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : disable movement controls
// PARAMETERS :
//
// PURPOSE : something tells me python shouldn't do this this way
//
void cyAvatar::DisableMovementControls()
{
plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
if (avatar)
{
if (!avatar->IsInputSuspended())
avatar->SuspendInput();
}
}
void cyAvatar::EnableMovementControls()
{
plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
if (avatar)
{
if (avatar->IsInputSuspended())
avatar->ResumeInput();
}
}
void cyAvatar::DisableMouseMovement()
{
plAvatarInputInterface::GetInstance()->SuspendMouseMovement();
}
void cyAvatar::EnableMouseMovement()
{
plAvatarInputInterface::GetInstance()->EnableMouseMovement();
}
void cyAvatar::EnableAvatarJump()
{
plAvatarInputInterface::GetInstance()->EnableJump(true);
}
void cyAvatar::DisableAvatarJump()
{
plAvatarInputInterface::GetInstance()->EnableJump(false);
}
void cyAvatar::EnableForwardMovement()
{
plAvatarInputInterface::GetInstance()->EnableForwardMovement(true);
}
void cyAvatar::DisableForwardMovement()
{
plAvatarInputInterface::GetInstance()->EnableForwardMovement(false);
}
bool cyAvatar::LocalAvatarRunKeyDown()
{
plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();
if (avMod)
return avMod->FastKeyDown();
return false;
}
bool cyAvatar::LocalAvatarIsMoving()
{
plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();
if (avMod)
return avMod->ForwardKeyDown() || avMod->BackwardKeyDown() || avMod->StrafeRightKeyDown() ||
avMod->StrafeLeftKeyDown() || avMod->TurnRightKeyDown() || avMod->TurnLeftKeyDown() ||
avMod->JumpKeyDown();
return false;
}
void cyAvatar::SetMouseTurnSensitivity(float val)
{
plArmatureMod::SetMouseTurnSensitivity(val);
}
float cyAvatar::GetMouseTurnSensitivity()
{
return plArmatureMod::GetMouseTurnSensitivity();
}
void cyAvatar::SpawnNext()
{
static int whichSpawn = 0;
plAvatarMgr *mgr = plAvatarMgr::GetInstance();
int max = mgr->NumSpawnPoints();
whichSpawn = ++whichSpawn < max ? whichSpawn : 0;
plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
if(avatar)
{
double fakeTime = 0.0f;
avatar->SpawnAt(whichSpawn, fakeTime);
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : RegisterForBehaviorNotify()
// PARAMETERS : none
//
// PURPOSE : To register for notifies from the avatar for any kind of behavior notify
//
void cyAvatar::RegisterForBehaviorNotify(pyKey &selfKey)
{
// make sure that there is atleast one avatar scene object attached (should be)
if ( fRecvr.Count() > 0)
{
// find the armature modifier
plArmatureMod* avatar = (plArmatureMod*)IFindArmatureMod((plKey)fRecvr[0]);
if(avatar)
{
avatar->RegisterForBehaviorNotify(selfKey.getKey());
}
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : UnRegisterForBehaviorNotify()
// PARAMETERS : none
//
// PURPOSE : To remove the registeration for notifies from the avatar
//
void cyAvatar::UnRegisterForBehaviorNotify(pyKey &selfKey)
{
// make sure that there is atleast one avatar scene object attached (should be)
if ( fRecvr.Count() > 0)
{
// find the armature modifier
plArmatureMod* avatar = (plArmatureMod*)IFindArmatureMod((plKey)fRecvr[0]);
if(avatar)
{
avatar->UnRegisterForBehaviorNotify(selfKey.getKey());
}
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : IEnterGenericMode
// PARAMETERS : none
//
// PURPOSE : Three-stage multistage animations (sit down, sit, get up) are really common.
// : This does the basic setup.
//
bool IEnterGenericMode(const char *enterAnim, const char *idleAnim, const char *exitAnim, bool autoExit, plAGAnim::BodyUsage bodyUsage,
plAvBrainGeneric::BrainType type /* = kGeneric */)
{
plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
return PushSimpleMultiStage(avatar, enterAnim, idleAnim, exitAnim, true, autoExit, bodyUsage, type);
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : IExitTopmostGenericMode
// PARAMETERS : none
//
// PURPOSE : Exits whatever multistage animation you're in. We currently don't discriminate;
// : that will be added later.
//
bool IExitTopmostGenericMode()
{
plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
plAvBrainGenericMsg* pMsg = new plAvBrainGenericMsg(nil, avatar->GetKey(),
plAvBrainGenericMsg::kGotoStage, 2, false, 0.0,
false, false, 0.0);
pMsg->SetBCastFlag(plMessage::kNetForce | plMessage::kNetPropagate);
plgDispatch::MsgSend( pMsg );
return true;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : IsCurrentBrainHuman
// PARAMETERS : none
//
// PURPOSE : Returns whether the top most brain is a human brain
//
bool cyAvatar::IsCurrentBrainHuman()
{
plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
if (avatar)
{
plArmatureBrain *brain = avatar->GetCurrentBrain();
plAvBrainHuman *human = plAvBrainHuman::ConvertNoRef(brain);
if (human)
return true;
}
return false;
}