virtual void visit(CInstance &inst)
{
if (inst.getDisplayerVisual())
{
inst.getDisplayerVisual()->updateWorldPos();
}
}
//***************************************************************
void CAutoGroup::update(const CVector &testPos, const std::string &paletteEntry, bool valid)
{
//H_AUTO(R2_CAutoGroup_update)
_TestPos = testPos;
_PaletteEntry = paletteEntry;
_AutoGroupEnabled = valid;
CInstance *candidate = getGroupingCandidate();
if (!candidate && _AutoGroup.isAddedToWorldMap())
{
clear();
}
else if (candidate)
{
// update the display
if (!_AutoGroup.isAddedToWorldMap())
{
CGroupMap *gm = CTool::getWorldMap();
if (gm)
{
gm->addDeco(&_AutoGroup);
}
}
CDisplayerVisual *dv = candidate->getDisplayerVisual();
nlassert(dv); // should not be null because getGrou^pingCandidate succeeded
_PrimRenderVertices.resize(2);
CVector pos = dv->isCompound() ? dv->getSon(0)->getWorldPos() : dv->getWorldPos();
_PrimRenderVertices[0] = pos;
_PrimRenderVertices[1] = _TestPos;
_AutoGroup.setVertices(_PrimRenderVertices);
_AutoGroup.addDecalsToRenderList();
}
}
// ***************************************************************
void CToolSelectRotate::cancelAction(CInstance &instance)
{
//H_AUTO(R2_CToolSelectRotate_cancelAction)
CEntityCL *entity = instance.getEntity();
nlassert(entity);
getEditor().requestRollbackLocalNode(instance.getId(), "Angle");
setRotateInProgress(false, instance);
}
// ***************************************************************
void CToolSelectRotate::commitAction(CInstance &instance)
{
//H_AUTO(R2_CToolSelectRotate_commitAction)
getDMC().newAction(CI18N::get("uiR2EDRotateAction") + instance.getDisplayName());
// nothing to do, entity already has good angle
getEditor().requestCommitLocalNode(instance.getId(), "Angle");
setRotateInProgress(false, instance);
}
bool CInstanceHandler::checkMonsterInList(CMobEntity* PMob)
{
CInstance* PInstance = m_Instances[0];
if(PInstance->isMonsterInList(PMob))
return true;
else
return false;
}
int CInstanceHandler::dynamisMessage(uint16 Param1, uint16 Param2) {
CInstance* PInstance = m_Instances[0];
PInstance->addTimeLimit(Param2*60);
PInstance->pushMessageToAllInBcnm(Param1,Param2);
return 1;
}
// Variant value must be released with NPReleaseVariantValue()
void convertValueToNPVariant (KJS::ExecState *exec, const KJS::Value &value, NPVariant *result)
{
Type type = value.type();
if (type == StringType) {
UString ustring = value.toString(exec);
CString cstring = ustring.UTF8String();
NPString string = { (const NPUTF8 *)cstring.c_str(), cstring.size() };
NPN_InitializeVariantWithStringCopy (result, &string );
}
else if (type == NumberType) {
NPN_InitializeVariantWithDouble (result, value.toNumber(exec));
}
else if (type == BooleanType) {
NPN_InitializeVariantWithBool (result, value.toBoolean(exec));
}
else if (type == UnspecifiedType) {
NPN_InitializeVariantAsUndefined(result);
}
else if (type == NullType) {
NPN_InitializeVariantAsNull(result);
}
else if (type == ObjectType) {
KJS::ObjectImp *objectImp = static_cast<KJS::ObjectImp*>(value.imp());
if (objectImp->classInfo() == &KJS::RuntimeObjectImp::info) {
KJS::RuntimeObjectImp *imp = static_cast<KJS::RuntimeObjectImp *>(value.imp());
CInstance *instance = static_cast<CInstance*>(imp->getInternalInstance());
NPN_InitializeVariantWithObject (result, instance->getObject());
}
else {
KJS::Interpreter *originInterpreter = exec->interpreter();
const Bindings::RootObject *originExecutionContext = rootForInterpreter(originInterpreter);
KJS::Interpreter *interpreter = 0;
if (originInterpreter->isGlobalObject(value)) {
interpreter = originInterpreter->interpreterForGlobalObject (value.imp());
}
if (!interpreter)
interpreter = originInterpreter;
const Bindings::RootObject *executionContext = rootForInterpreter(interpreter);
if (!executionContext) {
Bindings::RootObject *newExecutionContext = new KJS::Bindings::RootObject(0);
newExecutionContext->setInterpreter (interpreter);
executionContext = newExecutionContext;
}
NPObject *obj = (NPObject *)exec->interpreter()->createLanguageInstanceForValue (exec, Instance::CLanguage, value.toObject(exec), originExecutionContext, executionContext);
NPN_InitializeVariantWithObject (result, obj);
_NPN_ReleaseObject (obj);
}
}
else
NPN_InitializeVariantAsUndefined(result);
}
void CInstanceHandler::insertMonsterInList(CMobEntity* PMob)
{
CInstance* PInstance = m_Instances[0];
if(PInstance->isMonsterInList(PMob) == false)
{
PInstance->addMonsterInList(PMob);
}
}
void CInstanceHandler::openTreasureChest(CCharEntity* PChar) {
for(int i=0; i<m_MaxInstances; i++) {
if(m_Instances[i] != NULL) {
if(m_Instances[i]->isValidPlayerForBcnm(PChar)) {
CInstance* PInstance = m_Instances[i];
PInstance->OpenChestinBcnm();
}
}
}
}
// **********************************************
void CToolPick::updateAfterRender()
{
//H_AUTO(R2_CToolPick_updateAfterRender)
// See if the mouse is over a valid position
_ValidPos = false;
sint32 mouseX, mouseY;
getMousePos(mouseX, mouseY);
if (!isInScreen(mouseX, mouseY))
{
getEditor().setFocusedInstance(NULL);
setMouseCursor(_CursCannotPickPos);
return;
}
_CandidateInstance = NULL;
CInstance *instanceUnder = checkInstanceUnderMouse();
bool ignoreInstanceUnder = false;
if(instanceUnder && _IgnoreInstances.size()>0)
{
for(uint i=0; i<_IgnoreInstances.size(); i++)
{
if(instanceUnder->isKindOf(_IgnoreInstances[i]))
{
ignoreInstanceUnder = true;
break;
}
}
}
if (!instanceUnder || ignoreInstanceUnder)
{
if (isMouseOnUI() && !isMouseOnContainer())
{
setMouseCursor(DEFAULT_CURSOR);
}
else
{
CTool::CWorldViewRay worldViewRay;
computeWorldViewRay(mouseX, mouseY, worldViewRay);
CVector inter;
_ValidPos = (ValidPacsPos == computeLandscapeRayIntersection(worldViewRay, _Intersection));
setMouseCursor(_ValidPos ? _CursCanPickPos : _CursCannotPickPos);
getEditor().setFocusedInstance(NULL);
}
return;
}
getEditor().setFocusedInstance(instanceUnder);
if (canPick(*instanceUnder))
{
_CandidateInstance = instanceUnder;
setMouseCursor(_CursCanPickInstance);
}
else
{
setMouseCursor(_CursCannotPickInstance);
}
}
//*********************************************************************************************************
CDisplayerVisual *CDisplayerVisualActivitySequence::getParentDV() const
{
//H_AUTO(R2_CDisplayerVisualActivitySequence_getParentDV)
CInstance *currParent = getDisplayedInstance()->getParent();
CDisplayerVisual *prevDV = NULL;
while (currParent)
{
prevDV = currParent->getDisplayerVisual();
if (prevDV) break;
currParent = currParent->getParent();
}
return prevDV;
}
// Variant value must be released with NPReleaseVariantValue()
void convertValueToNPVariant(ExecState *exec, JSValue *value, NPVariant *result)
{
JSLock lock;
JSType type = value->type();
VOID_TO_NPVARIANT(*result);
if (type == StringType) {
UString ustring = value->toString(exec);
CString cstring = ustring.UTF8String();
NPString string = { (const NPUTF8 *)cstring.c_str(), static_cast<uint32_t>(cstring.size()) };
NPN_InitializeVariantWithStringCopy(result, &string);
} else if (type == NumberType) {
DOUBLE_TO_NPVARIANT(value->toNumber(exec), *result);
} else if (type == BooleanType) {
BOOLEAN_TO_NPVARIANT(value->toBoolean(exec), *result);
} else if (type == UnspecifiedType) {
VOID_TO_NPVARIANT(*result);
} else if (type == NullType) {
NULL_TO_NPVARIANT(*result);
} else if (type == ObjectType) {
JSObject* object = static_cast<JSObject*>(value);
if (object->classInfo() == &RuntimeObjectImp::info) {
RuntimeObjectImp* imp = static_cast<RuntimeObjectImp *>(value);
CInstance* instance = static_cast<CInstance*>(imp->getInternalInstance());
if (instance) {
NPObject* obj = instance->getObject();
_NPN_RetainObject(obj);
OBJECT_TO_NPVARIANT(obj, *result);
}
} else {
Interpreter* originInterpreter = exec->dynamicInterpreter();
RootObject* originRootObject = findRootObject(originInterpreter);
Interpreter* interpreter = 0;
if (originInterpreter->isGlobalObject(value)) {
interpreter = originInterpreter->interpreterForGlobalObject(value);
}
if (!interpreter)
interpreter = originInterpreter;
RootObject* rootObject = findRootObject(interpreter);
if (rootObject) {
NPObject* npObject = _NPN_CreateScriptObject(0, object, originRootObject, rootObject);
OBJECT_TO_NPVARIANT(npObject, *result);
}
}
}
}
void CZoneInstance::DecreaseZoneCounter(CCharEntity* PChar)
{
CInstance* instance = PChar->PInstance;
if (instance)
{
instance->DecreaseZoneCounter(PChar);
instance->DespawnPC(PChar);
CharZoneOut(PChar);
PChar->StatusEffectContainer->DelStatusEffectSilent(EFFECT_LEVEL_RESTRICTION);
PChar->PInstance = nullptr;
if (instance->CharListEmpty())
{
if (instance->Failed() || instance->Completed())
{
instanceList.erase(std::find(instanceList.begin(), instanceList.end(), instance));
delete instance;
}
else
{
instance->SetWipeTime(instance->GetElapsedTime(gettick()));
}
}
}
}
int CInstanceHandler::registerDynamis(uint16 id, CCharEntity* PChar) {
if(!hasFreeInstance()) {
return -1;
}
CInstance* PInstance = instanceutils::loadInstance(this,id);
if(PInstance==NULL) {
return -1;
}
for(int i=0; i<m_MaxInstances; i++) {
if(m_Instances[i]==NULL) {
PInstance->setInstanceNumber(i+1);
break;
}
}
if(PInstance->addPlayerToDynamis(PChar)) {
ShowDebug("InstanceHandler ::1 Added %s to the valid players list for Dynamis %i Instance %i \n",
PChar->GetName(),id,PInstance->getInstanceNumber());
}
m_Instances[PInstance->getInstanceNumber()-1] = PInstance;
PInstance->init();
PInstance->setDynaUniqueID();
luautils::OnBcnmRegister(PChar,PInstance);
return PInstance->getInstanceNumber();
}
void CZoneInstance::DecreaseZoneCounter(CCharEntity* PChar)
{
CInstance* instance = PChar->PInstance;
if (instance)
{
instance->DecreaseZoneCounter(PChar);
instance->DespawnPC(PChar);
CharZoneOut(PChar);
PChar->PInstance = NULL;
if (instance->CharListEmpty())
{
if (instance->Failed() || instance->Completed())
{
instanceList.erase(std::find(instanceList.begin(), instanceList.end(), instance));
delete instance;
}
else
{
instance->SetWipeTime(instance->GetElapsedTime(gettick()));
}
}
}
}
// ***************************************************************
bool CToolSelectRotate::isActionPossibleOn(const CInstance &instance) const
{
//H_AUTO(R2_CToolSelectRotate_isActionPossibleOn)
CInstance &mutableInstance = const_cast<CInstance &>(instance);
CDisplayerVisual *dv = mutableInstance.getDisplayerVisual();
if (dv && dv->getActualDisplayMode() != CDisplayerVisual::DisplayModeVisible)
{
return false;
}
if (instance.getEntity() != NULL)
{
return !instance.getClass()["NameToProp"]["Angle"].isNil();
}
return false;
}
// ***************************************************************
void CToolSelectRotate::setEntityAngle(CEntityCL &/* entity */, CInstance &instance, float angle)
{
//H_AUTO(R2_CToolSelectRotate_setEntityAngle)
CObjectNumber *angleObject = new CObjectNumber(angle);
getEditor().requestSetLocalNode(instance.getId(), "Angle", angleObject);
delete angleObject;
}
//***************************************************************
bool CToolSelectMove::checkAdditionnalRoomLeftFor(CInstance &instance)
{
//H_AUTO(R2_CToolSelectMove_checkAdditionnalRoomLeftFor)
CLuaObject &luaProj = instance.getLuaProjection();
CLuaState &ls = getEditor().getLua();
CLuaStackRestorer lsr(&ls, 0);
// check ai & static cost : if they are too big, can't create the duplicate
if (!luaProj.callMethodByNameNoThrow("getAiCost", 0, 1)
|| !ls.isNumber(-1))
{
return false;
}
uint aiCost = (uint) ls.toNumber(-1);
ls.pop();
if (!luaProj.callMethodByNameNoThrow("getStaticObjectCost", 0, 1))
{
return false;
}
uint staticCost = (uint) ls.toNumber(-1);
ls.pop();
if (!getEditor().verifyRoomLeft(aiCost, staticCost))
{
return false;
}
return true;
}
//*********************************************************************************************************
CDisplayerVisual *CDisplayerVisualActivitySequence::getPossibleGroupDV(CDisplayerVisual *entityDV)
{
//H_AUTO(R2_CDisplayerVisualActivitySequence_getPossibleGroupDV)
if (!entityDV) return NULL;
CInstance *parentGroup = entityDV->getDisplayedInstance()->getParent();
while (parentGroup)
{
if (dynamic_cast<CDisplayerVisualGroup *>(parentGroup->getDisplayerVisual()))
{
return parentGroup->getDisplayerVisual();
break;
}
parentGroup = parentGroup->getParent();
}
return entityDV;
}
// ***************************************************************
void CToolSelectRotate::beginAction(CInstance &instance)
{
//H_AUTO(R2_CToolSelectRotate_beginAction)
_MouseStartX = getMouseX();
_StartAngle = (float) instance.getObjectTable()->toNumber("Angle");
setRotateInProgress(true, instance);
}
// ***************************************************************
CDisplayerVisual *CDisplayerVisual::getParent()
{
if (_LastParentOk) return _LastParent;
CDisplayerVisual *result = NULL;
//H_AUTO(R2_CDisplayerVisual_getParent)
CInstance *inst = getDisplayedInstance();
nlassert(inst);
CInstance *parentInstance = inst->getParent();
if (parentInstance)
{
result = parentInstance->getDisplayerVisual();
}
_LastParent = result;
_LastParentOk = true;
return result;
}
/***************************************************************
Loads the given instance from the database and returns
a new Instance object.
****************************************************************/
CInstance* loadInstance(CInstanceHandler* hand, uint16 bcnmid, INSTANCETYPE type){
const int8* fmtQuery = "SELECT name, bcnmId, fastestName, fastestTime, timeLimit, levelCap, lootDropId, rules, partySize, zoneId \
FROM bcnm_info \
WHERE bcnmId = %u";
int32 ret = Sql_Query(SqlHandle, fmtQuery, bcnmid);
if (ret == SQL_ERROR ||
Sql_NumRows(SqlHandle) == 0 ||
Sql_NextRow(SqlHandle) != SQL_SUCCESS)
{
ShowError("Cannot load instance BCNM:%i \n",bcnmid);
}
else
{
CInstance* PInstance = new CInstance(hand,Sql_GetUIntData(SqlHandle,1), type);
int8* tmpName;
Sql_GetData(SqlHandle,0,&tmpName,NULL);
PInstance->setBcnmName(tmpName);
PInstance->setTimeLimit(Sql_GetUIntData(SqlHandle,4));
PInstance->setLevelCap(Sql_GetUIntData(SqlHandle,5));
PInstance->setLootId(Sql_GetUIntData(SqlHandle,6));
PInstance->setMaxParticipants(Sql_GetUIntData(SqlHandle,8));
PInstance->setZoneId(Sql_GetUIntData(SqlHandle,9));
PInstance->m_RuleMask = (uint16)Sql_GetUIntData(SqlHandle,7);
return PInstance;
}
return NULL;
}
// Variant value must be released with NPReleaseVariantValue()
void convertValueToNPVariant(ExecState* exec, JSValue value, NPVariant* result)
{
JSLock lock(SilenceAssertionsOnly);
VOID_TO_NPVARIANT(*result);
if (value.isString()) {
UString ustring = value.toString(exec);
CString cstring = ustring.utf8();
NPString string = { (const NPUTF8*)cstring.data(), static_cast<uint32_t>(cstring.length()) };
NPN_InitializeVariantWithStringCopy(result, &string);
} else if (value.isNumber()) {
DOUBLE_TO_NPVARIANT(value.toNumber(exec), *result);
} else if (value.isBoolean()) {
BOOLEAN_TO_NPVARIANT(value.toBoolean(exec), *result);
} else if (value.isNull()) {
NULL_TO_NPVARIANT(*result);
} else if (value.isObject()) {
JSObject* object = asObject(value);
if (object->classInfo() == &CRuntimeObject::s_info) {
CRuntimeObject* runtimeObject = static_cast<CRuntimeObject*>(object);
CInstance* instance = runtimeObject->getInternalCInstance();
if (instance) {
NPObject* obj = instance->getObject();
_NPN_RetainObject(obj);
OBJECT_TO_NPVARIANT(obj, *result);
}
} else {
#ifdef ANDROID
RootObject* rootObject = findRootObject(exec->dynamicGlobalObject());
if (!rootObject)
rootObject = findRootObject(exec->lexicalGlobalObject());
#else
JSGlobalObject* globalObject = exec->dynamicGlobalObject();
RootObject* rootObject = findRootObject(globalObject);
#endif
if (rootObject) {
NPObject* npObject = _NPN_CreateScriptObject(0, object, rootObject);
OBJECT_TO_NPVARIANT(npObject, *result);
}
}
}
}
// ***************************************************************
void CToolSelectRotate::updateAction(CInstance &instance)
{
//H_AUTO(R2_CToolSelectRotate_updateAction)
CEntityCL *entity = instance.getEntity();
if (entity)
{
setMouseCursor("r2ed_tool_rotating.tga");
setEntityAngle(*entity, instance, (float) ((getMouseX() - _MouseStartX) * NLMISC::Pi / 180) + _StartAngle);
}
}
void CDynamicMapClient::requestEraseNode(const std::string& instanceId, const std::string& attrName, sint32 position)
{
//H_AUTO(R2_CDynamicMapClient_requestEraseNode)
// warn observer of node being erased that these node are being erased
// this allow observer of these node to remove themselves
// for example, in the export window, the reference to a npc in the scene
// will remove itself from the export if its target is removed
CObject *target = find(instanceId, attrName, position);
if (target)
{
CInstance *root = getEditor().getInstanceFromObject(target);
if (root)
{
CTraverseEraseRequestedSons traverseEraseRequestedSons;
root->visit(traverseEraseRequestedSons);
}
}
nlwarning("REQUEST: erase node %s, %s, %d", instanceId.c_str(), attrName.c_str(), (int) position);
_ActionHistoric.requestEraseNode(instanceId, attrName, position);
}
// Variant value must be released with NPReleaseVariantValue()
void convertValueToNPVariant(ExecState* exec, JSValuePtr value, NPVariant* result)
{
JSLock lock(false);
VOID_TO_NPVARIANT(*result);
if (value.isString()) {
UString ustring = value.toString(exec);
CString cstring = ustring.UTF8String();
NPString string = { (const NPUTF8*)cstring.c_str(), static_cast<uint32_t>(cstring.size()) };
NPN_InitializeVariantWithStringCopy(result, &string);
} else if (value.isNumber()) {
DOUBLE_TO_NPVARIANT(value.toNumber(exec), *result);
} else if (value.isBoolean()) {
BOOLEAN_TO_NPVARIANT(value.toBoolean(exec), *result);
} else if (value.isNull()) {
NULL_TO_NPVARIANT(*result);
} else if (value.isObject()) {
JSObject* object = asObject(value);
if (object->classInfo() == &RuntimeObjectImp::s_info) {
RuntimeObjectImp* imp = static_cast<RuntimeObjectImp*>(object);
CInstance* instance = static_cast<CInstance*>(imp->getInternalInstance());
if (instance) {
NPObject* obj = instance->getObject();
_NPN_RetainObject(obj);
OBJECT_TO_NPVARIANT(obj, *result);
}
} else {
JSGlobalObject* globalObject = exec->dynamicGlobalObject();
RootObject* rootObject = findRootObject(globalObject);
if (rootObject) {
NPObject* npObject = _NPN_CreateScriptObject(0, object, rootObject);
OBJECT_TO_NPVARIANT(npObject, *result);
}
}
}
}
//***************************************************************
CInstance *CToolSelectMove::createGhost(CInstance &instance)
{
//H_AUTO(R2_CToolSelectMove_createGhost)
CLuaState &ls = getEditor().getLua();
// copy then do a local paste
CLuaStackRestorer lsr(&ls, 0);
//
CLuaObject &luaProj = instance.getLuaProjection();
CLuaObject &classDef = instance.getClass();
if (luaProj.callMethodByNameNoThrow("copy", 0, 1))
{
// now we got a table that is an exact (canonical) copy of the original object, with the
// same instance ids..
// prepare for new insertion by renaming these instance id's (which 'newCopy' does)
if (classDef["newCopy"].callNoThrow(1, 1))
{
// now, insert the new copy as a ghost in the new scene
if (classDef["pasteGhost"].callNoThrow(1, 1))
{
CLuaObject ghost(ls); // pop the ghost from stack
CInstance *newInst = getEditor().getInstanceFromId(ghost["InstanceId"].toString());
if (newInst)
{
if (!newInst->getGhost())
{
nlwarning("When duplicating an object using the 'select/move' tool, temporary duplicate should be inserted \
as a ghost in the scene, removing object...");
getEditor().getDMC().requestEraseNode(newInst->getId(), "", -1);
}
// set the flag so that the cost of this object isn't taken in account in the displayed quotas
newInst->getLuaProjection()["User"].setValue("GhostDuplicate", true);
getEditor().setSelectedInstance(newInst);
newInst->getDisplayerVisual()->setDisplayFlag(CDisplayerVisual::FlagHideActivities, true);
nlwarning("CToolSelectMove: beginning duplicate with instance with id %s", newInst->getId().c_str());
// show in "frozen" state
{
/*CObjectNumber *numberValue = new CObjectNumber(2); // 2 = frozen state
getEditor().getDMC().requestSetNode(newInst->getId(), "DisplayMode", numberValue);
delete numberValue;
*/
newInst->getDisplayerVisual()->setDisplayMode(CDisplayerVisual::DisplayModeFrozen);
getEditor().getEntitySorter()->clipEntitiesByDist();
return newInst;
}
}
}
}
void CZoneInstance::ZoneServer(time_point tick)
{
auto it = instanceList.begin();
while (it != instanceList.end())
{
CInstance* instance = *it;
instance->ZoneServer(tick);
instance->CheckTime(tick);
if ((instance->Failed() || instance->Completed()) && instance->CharListEmpty())
{
it = instanceList.erase(it);
delete instance;
continue;
}
it++;
}
}
virtual void visit(CInstance &inst)
{
CNotifySonDeletion notifySonDeletion(inst);
getEditor().triggerInstanceObserver(inst.getId(), notifySonDeletion);
}
// ------------------------------------------------------------------------------------------------
void CCharacter3D::setAnim (uint animID)
{
CCharacterCL * character = NULL;
if(!_CopyAnim)
{
_CurrentSetup.AnimPlayed = animID;
if (_CurrentSetup.Male)
{
if (animID >= _AnimMale.size()) return;
animID = _AnimMale[animID].AnimId;
}
else
{
if (animID >= _AnimFemale.size()) return;
animID = _AnimFemale[animID].AnimId;
}
}
else
{
CInstance * selectedInst = getEditor().getSelectedInstance();
if(!selectedInst) return;
CEntityCL * entity = selectedInst->getEntity();
if(!(entity && ((character=dynamic_cast<CCharacterCL*>(entity))!=NULL)))
return;
animID = character->playList()->getAnimation(MOVE);
_CurrentSetup.AnimPlayed = animID;
}
float animSpeedFactor = 0.9f + 0.2f * NLMISC::frand(1);
if (_PlayList)
{
if(_CopyAnim)
{
_PlayList->setTimeOrigin(MOVE, character->playList()->getTimeOrigin(MOVE));
if(character->playList()->getAnimation(MOVE)!=_PlayList->getAnimation(MOVE))
{
_PlayList->setAnimation(MOVE, animID);
_PlayList->setSpeedFactor(MOVE, character->playList()->getSpeedFactor(MOVE));
_PlayList->setWrapMode(MOVE, character->playList()->getWrapMode(MOVE));
}
}
else
{
_PlayList->setAnimation(MOVE, animID);
_PlayList->setSpeedFactor(MOVE, animSpeedFactor);
_PlayList->setTimeOrigin(MOVE, TimeInSec);
_PlayList->setWrapMode(MOVE, UPlayList::Repeat);
}
}
if (_FacePlayList)
{
uint faceAnimId=UPlayList::empty;
if(_AnimationSet && animID<_AnimationSet->getNumAnimation())
{
// build the anim name of the face
string faceAnimName= COptionsAnimationSet::getFaceAnimName(_AnimationSet->getAnimationName(animID));
// find the face anim for this name
faceAnimId= _AnimationSet->getAnimationIdByName(faceAnimName);
if(faceAnimId==UAnimationSet::NotFound)
faceAnimId= UPlayList::empty;
}
_FacePlayList->setAnimation(MOVE, faceAnimId);
if(faceAnimId!=UPlayList::empty)
{
if(_CopyAnim)
{
_FacePlayList->setTimeOrigin(MOVE, character->facePlayList()->getTimeOrigin(MOVE));
_FacePlayList->setSpeedFactor(MOVE, character->facePlayList()->getSpeedFactor(MOVE));
_FacePlayList->setWrapMode(MOVE, character->facePlayList()->getWrapMode(MOVE));
}
else
{
_FacePlayList->setSpeedFactor(MOVE, animSpeedFactor);
_FacePlayList->setTimeOrigin(MOVE, TimeInSec);
_FacePlayList->setWrapMode(MOVE, UPlayList::Repeat);
}
}
}
}
