// ------------------------------------------------------------------------------------------------
uint64 SCharacter3DSetup::getDB (const string &name)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp(name);
if (pNL == NULL) return 0;
return pNL->getValue64();
}
//-----------------------------------------------
// updateVisualProperty0 :
/// Update the item position.
//-----------------------------------------------
void CItemCL::updateVisualPropertyPos(const NLMISC::TGameCycle &/* gameCycle */, const sint64 &prop, const NLMISC::TGameCycle &/* pI */)
{
// Check the DB entry (the warning is already done in the build method).
if(_DBEntry == 0)
return;
// Get The property 'Y'.
CCDBNodeLeaf *nodeY = dynamic_cast<CCDBNodeLeaf *>(_DBEntry->getNode(CLFECOMMON::PROPERTY_POSY));
if(nodeY == 0)
{
nlwarning("ITM:updtVPPos:%d: Cannot find the property 'PROPERTY_POSY(%d)'.", _Slot, CLFECOMMON::PROPERTY_POSY);
return;
}
// Get The property 'Z'.
CCDBNodeLeaf *nodeZ = dynamic_cast<CCDBNodeLeaf *>(_DBEntry->getNode(CLFECOMMON::PROPERTY_POSZ));
if(nodeZ == 0)
{
nlwarning("ITM:updtVPPos:%d: Cannot find the property 'PROPERTY_POSZ(%d)'.", _Slot, CLFECOMMON::PROPERTY_POSZ);
return;
}
// Insert the primitive into the world.
if(_Primitive)
_Primitive->insertInWorldImage(dynamicWI);
float x = (float)(prop)/1000.0f;
float y = (float)(nodeY->getValue64())/1000.0f;
float z = (float)(nodeZ->getValue64())/1000.0f;
// Set the primitive position.
pacsPos(CVectorD(x, y, z));
// Snap the entity to the ground.
snapToGround();
// Change the instance position.
if(!_Instance.empty())
{
_Instance.setPos(pos());
_Instance.getShapeAABBox(_SelectBox);
_SelectBox.setCenter(pos() + _SelectBox.getCenter());
// Adjust the collision.
if(_Primitive)
{
_Primitive->setRadius(std::min(std::max((_SelectBox.getHalfSize()).x, (_SelectBox.getHalfSize()).y), (float)(RYZOM_ENTITY_SIZE_MAX/2)));
_Primitive->setHeight((_SelectBox.getHalfSize()).z);
}
}
}// updateVisualProperty0 //
// *********************************************************************************************************
std::string CDisplayerVisualEntity::getVisualProperties() const
{
//H_AUTO(R2_std_getVisualProperties)
if( !_Entity )
return "";
const std::string propNameA = toString("SERVER:Entities:E%d:P%d", _Entity->slot(), CLFECOMMON::PROPERTY_VPA);
const std::string propNameB = toString("SERVER:Entities:E%d:P%d", _Entity->slot(), CLFECOMMON::PROPERTY_VPB);
const std::string propNameC = toString("SERVER:Entities:E%d:P%d", _Entity->slot(), CLFECOMMON::PROPERTY_VPC);
CCDBNodeLeaf *leafA = NLGUI::CDBManager::getInstance()->getDbProp(propNameA);
CCDBNodeLeaf *leafB = NLGUI::CDBManager::getInstance()->getDbProp(propNameB);
CCDBNodeLeaf *leafC = NLGUI::CDBManager::getInstance()->getDbProp(propNameC);
if (!leafA)
{
nlwarning("Can't find DB leaf %s", propNameA.c_str());
return "";
}
if (!leafB)
{
nlwarning("Can't find DB leaf %s", propNameB.c_str());
return "";
}
if (!leafC)
{
nlwarning("Can't find DB leaf %s", propNameC.c_str());
return "";
}
uint64 uVPA = leafA->getValue64();
uint64 uVPB = leafB->getValue64();
uint64 uVPC = leafC->getValue64();
const std::string strVPABC = NLMISC::toString( "VPA:%016.16"NL_I64"x\nVPB:%016.16"NL_I64"x\nVPC:%016.16"NL_I64"x", uVPA, uVPB, uVPC );
return strVPABC;
}
// ***************************************************************************
void CGroupPhraseSkillFilter::CBrickFamilyObs::update (ICDBNode *node)
{
CSBrickManager *pBM= CSBrickManager::getInstance();
CSkillManager *pSM= CSkillManager::getInstance();
CCDBNodeLeaf *leaf = NLMISC::safe_cast<CCDBNodeLeaf *>(node);
// get only new bits set
uint64 oldBf= leaf->getOldValue64();
uint64 newBf= leaf->getValue64();
uint64 newBitOn= newBf & (~oldBf);
// For all those new bits, check if the brick free up a Skill
bool mustTouch= false;
for(uint i=0;i<64;i++)
{
// if a new bit
if(newBitOn & (SINT64_CONSTANT(1)<<i))
{
CSBrickSheet *brick= pBM->getBrick(pBM->getBrickSheet(BrickFamily, i));
// if a valid brick / valid skill
if(brick && brick->getSkill()<SKILLS::NUM_SKILLS)
{
SKILLS::ESkills skill= brick->getSkill();
// if the skill was not set before
if(!Owner->_BrickSkillUsage[skill])
{
// Ctrl Tree must be recomputed
mustTouch= true;
// Flag this skill and all his parents!
while(skill!=SKILLS::unknown)
{
Owner->_BrickSkillUsage[skill]= true;
skill= pSM->getParent(skill);
}
}
}
}
}
// New Skill unblocked?
if(mustTouch)
Owner->touch ();
}
void CDisplayerVisualEntity::updateRaceAndSex()
{
//H_AUTO(R2_CDisplayerVisualEntity_updateRaceAndSex)
std::string sheetClient = (std::string) getString(&getProps(), "SheetClient");
_Entity = getEditor().createEntity(_Entity->slot(), CSheetId(sheetClient), getPos().asVector(), getAngle());
updateEntity();
// update sex
SPropVisualA vA;
const string propNameA = toString("SERVER:Entities:E%d:P%d", _Entity->slot(), CLFECOMMON::PROPERTY_VPA);
CCDBNodeLeaf *leafA = NLGUI::CDBManager::getInstance()->getDbProp(propNameA);
if (!leafA)
{
nlwarning("Can't find DB leaf %s", propNameA.c_str());
return;
}
vA.PropertyA = leafA->getValue64();
string::size_type loc = sheetClient.find("female", 0);
vA.PropertySubData.Sex = (uint)(loc != string::npos);
EntitiesMngr.updateVisualProperty(0, _Entity->slot(), CLFECOMMON::PROPERTY_VPA);
}
//***************************************************************
std::string CToolCreateEntity::cloneEntityIntoScenario(CEntityCL *clonee,
const NLMISC::CVector &createPosition,
float createAngle,
bool newAction,
bool createGhost
)
{
//H_AUTO(R2_CToolCreateEntity_cloneEntityIntoScenario)
if (!clonee) return "";
std::string instanceId;
bool isBotObject = isBotObjectSheet(clonee->sheetId());
if (!getEditor().verifyRoomLeft(isBotObject ? 0 : 1, isBotObject ? 1 : 0)) { return ""; }
std::string className;
// if class is given in the palette node, then use it. Default to 'Npc' else
CObject *paletteNode = getDMC().getPaletteElement(_PaletteId);
if (paletteNode && paletteNode->findIndex("Class") != -1)
{
className = getString(paletteNode, "Class");
}
if (className.empty())
{
className = "Npc";
}
ucstring readableName;
// retrieve name from the palette id
CLuaState &ls = getEditor().getLua();
getEditor().getEnv()["PaletteIdToTranslation"][_PaletteId].push();
if (ls.isString(-1))
{
readableName.fromUtf8(ls.toString(-1));
}
if (readableName.empty())
{
// if no name found then give a default one
readableName = CI18N::get(isBotObject ? "uiR2EDNameBotObject" : "uiR2EDNameNPC");
}
// except for creatures, posfix the name with a number
std::string creaturePaletteRoot = "palette.entities.creatures";
if (_PaletteId.substr(0, creaturePaletteRoot.size()) != creaturePaletteRoot)
{
readableName = getEditor().genInstanceName(readableName);
}
else
{
className = "NpcCreature";
// is Plant
std::string sheetClient = getString(paletteNode, "SheetClient");
getEditor().getLua().push(sheetClient);
if (getEditor().getEnv().callMethodByNameNoThrow("isNPCPlant", 1, 1))
{
CLuaObject result(getEditor().getLua());
bool isPlant = result.toBoolean();
if (isPlant)
className = "NpcPlant";
}
}
if (newAction)
{
getDMC().newAction(NLMISC::CI18N::get("uiR2EDCreateAction") + readableName);
}
// send network commands to create entity on server
std::auto_ptr<CObject> desc(getDMC().newComponent(className));
if (desc.get())
{
// TMP FIX : if the created entity is a custom npc, then retrieve look from the clonee visual properties
if (className == "NpcCustom")
{
SPropVisualA vA;
SPropVisualB vB;
SPropVisualC vC;
const string propNameA = toString("SERVER:Entities:E%d:P%d", clonee->slot(), CLFECOMMON::PROPERTY_VPA);
const string propNameB = toString("SERVER:Entities:E%d:P%d", clonee->slot(), CLFECOMMON::PROPERTY_VPB);
const string propNameC = toString("SERVER:Entities:E%d:P%d", clonee->slot(), CLFECOMMON::PROPERTY_VPC);
CCDBNodeLeaf *leafA = CInterfaceManager::getInstance()->getDbProp(propNameA);
CCDBNodeLeaf *leafB = CInterfaceManager::getInstance()->getDbProp(propNameB);
CCDBNodeLeaf *leafC = CInterfaceManager::getInstance()->getDbProp(propNameC);
if (!leafA)
{
nlwarning("Can't find DB leaf %s", propNameA.c_str());
return "";
}
if (!leafB)
{
nlwarning("Can't find DB leaf %s", propNameB.c_str());
return "";
}
if (!leafC)
{
nlwarning("Can't find DB leaf %s", propNameC.c_str());
return "";
}
vA.PropertyA = leafA->getValue64();
vB.PropertyB = leafB->getValue64();
vC.PropertyC = leafC->getValue64();
nlassert(desc->isTable());
CObjectTable *props = (CObjectTable *) desc.get();
props->set("GabaritHeight", (double)vC.PropertySubData.CharacterHeight);
props->set("GabaritTorsoWidth", (double)vC.PropertySubData.TorsoWidth);
props->set("GabaritArmsWidth", (double)vC.PropertySubData.ArmsWidth);
props->set("GabaritLegsWidth", (double)vC.PropertySubData.LegsWidth);
props->set("GabaritBreastSize", (double)vC.PropertySubData.BreastSize);
props->set("HairColor", (double)vA.PropertySubData.HatColor);
props->set("Tattoo", (double)vC.PropertySubData.Tattoo);
props->set("EyesColor", (double)vC.PropertySubData.EyesColor);
props->set("MorphTarget1", (double)vC.PropertySubData.MorphTarget1);
props->set("MorphTarget2", (double)vC.PropertySubData.MorphTarget2);
props->set("MorphTarget3", (double)vC.PropertySubData.MorphTarget3);
props->set("MorphTarget4", (double)vC.PropertySubData.MorphTarget4);
props->set("MorphTarget5", (double)vC.PropertySubData.MorphTarget5);
props->set("MorphTarget6", (double)vC.PropertySubData.MorphTarget6);
props->set("MorphTarget7", (double)vC.PropertySubData.MorphTarget7);
props->set("MorphTarget8", (double)vC.PropertySubData.MorphTarget8);
props->set("Sex", (double)vA.PropertySubData.Sex);
CVisualSlotManager * vsManager = CVisualSlotManager::getInstance();
NLMISC::CSheetId * sheetId = NULL;
if(vA.PropertySubData.HatModel == 0)
{
props->set("HatModel", 0);
}
else
{
sheetId = vsManager->index2Sheet((uint32)vA.PropertySubData.HatModel, SLOTTYPE::HEAD_SLOT);
if (sheetId)
{
props->set("HairType", (double)sheetId->asInt());
}
}
if(vA.PropertySubData.JacketModel == 0)
{
props->set("JacketModel", 0);
}
else
{
sheetId = vsManager->index2Sheet((uint32)vA.PropertySubData.JacketModel, SLOTTYPE::CHEST_SLOT);
if (sheetId)
{
props->set("JacketModel", (double)sheetId->asInt());
}
}
if(vA.PropertySubData.TrouserModel == 0)
{
props->set("TrouserModel", 0);
}
else
{
sheetId = vsManager->index2Sheet((uint32)vA.PropertySubData.TrouserModel, SLOTTYPE::LEGS_SLOT);
if (sheetId)
{
props->set("TrouserModel", (double)sheetId->asInt());
}
}
if(vB.PropertySubData.FeetModel == 0)
{
props->set("FeetModel", 0);
}
else
{
sheetId = vsManager->index2Sheet((uint32)vB.PropertySubData.FeetModel, SLOTTYPE::FEET_SLOT);
if (sheetId)
{
props->set("FeetModel", (double)sheetId->asInt());
}
}
if(vB.PropertySubData.HandsModel == 0)
{
props->set("HandsModel", 0);
}
else
{
sheetId = vsManager->index2Sheet((uint32)vB.PropertySubData.HandsModel, SLOTTYPE::HANDS_SLOT);
if (sheetId)
{
props->set("HandsModel", (double)sheetId->asInt());
}
}
if(vA.PropertySubData.ArmModel == 0)
{
props->set("ArmModel", 0);
}
else
{
sheetId = vsManager->index2Sheet((uint32)vA.PropertySubData.ArmModel, SLOTTYPE::ARMS_SLOT);
if (sheetId)
{
props->set("ArmModel", (double)sheetId->asInt());
}
}
double weaponRH=0, weaponLH=0;
if(vA.PropertySubData.WeaponRightHand == 0)
{
props->set("WeaponRightHand", 0);
}
else
{
sheetId = vsManager->index2Sheet((uint32)vA.PropertySubData.WeaponRightHand, SLOTTYPE::RIGHT_HAND_SLOT);
if (sheetId)
{
weaponRH = (double)sheetId->asInt();
}
props->set("WeaponRightHand", weaponRH);
}
if(vA.PropertySubData.WeaponLeftHand == 0)
{
props->set("WeaponLeftHand", 0);
}
else
{
sheetId = vsManager->index2Sheet((uint32)vA.PropertySubData.WeaponLeftHand, SLOTTYPE::LEFT_HAND_SLOT);
if (sheetId)
{
weaponLH = (double)sheetId->asInt();
}
props->set("WeaponLeftHand", weaponLH);
}
props->set("JacketColor", (double)vA.PropertySubData.JacketColor);
props->set("TrouserColor", (double)vA.PropertySubData.TrouserColor);
props->set("FeetColor", (double)vB.PropertySubData.FeetColor);
props->set("HandsColor", (double)vB.PropertySubData.HandsColor);
props->set("ArmColor", (double)vA.PropertySubData.ArmColor);
CPlayerR2CL * player = (CPlayerR2CL*)dynamic_cast<CPlayerR2CL*>(clonee);
if(player != NULL)
{
std::string race, gender, sheetClient;
switch(player->people())
{
case EGSPD::CPeople::Fyros:
sheetClient = "basic_fyros_";
race = "Fyros";
break;
case EGSPD::CPeople::Matis:
sheetClient = "basic_matis_";
race = "Matis";
break;
case EGSPD::CPeople::Tryker:
sheetClient = "basic_tryker_";
race = "Tryker";
break;
case EGSPD::CPeople::Zorai:
sheetClient = "basic_zorai_";
race = "Zorai";
break;
default:
nlwarning("CToolCreateEntity::commit unknown people");
}
switch(player->getGender())
{
case GSGENDER::female:
sheetClient = sheetClient+"female.creature";
gender = "female";
break;
case GSGENDER::male:
sheetClient = sheetClient+"male.creature";
gender = "male";
break;
default:
nlwarning("CToolCreateEntity::commit unknown gender");
}
props->set("SheetClient", sheetClient);
// random name
getEditor().getLua().push(race);
getEditor().getLua().push(gender);
if (getEditor().getEnv().callMethodByNameNoThrow("randomNPCName", 2, 1))
{
CLuaObject result(getEditor().getLua());
std::string name = result.toString();
props->set("Name", name);
}
}
getEditor().getLua().push(getString(paletteNode, "Equipment"));
getEditor().getLua().push(weaponRH);
getEditor().getLua().push(weaponLH);
getEditor().getLua().push(getString(paletteNode, "Sheet"));
getEditor().getLua().push(getString(paletteNode, "SheetModel"));
if (getEditor().getEnv().callMethodByNameNoThrow("searchSheet", 5, 1))
{
CLuaObject result(getEditor().getLua());
std::string sheet = result.toString();
props->set("Sheet", sheet);
}
else
{
nlwarning("SearchSheet failed : Palette Id = %s", _PaletteId.c_str());
return "";
}
}
else
{
desc->set("Name", readableName.toUtf8());
}
desc->set("Base", _PaletteId);
desc->setObject("Position", buildVector(CVectorD(createPosition)));
desc->set("Angle", createAngle);
//desc->set("Name", readableName.toUtf8());
instanceId = getString(desc.get(), "InstanceId");
if (!instanceId.empty())
{
if (!createGhost)
{
// selection asked when instance is created
getEditor().setCookie(instanceId, "Select", true);
}
else
{
getEditor().setCookie(instanceId, "GhostDuplicate", true);
}
}
// send creation command
// tmp : static npc counter
// add in component list of default feature
if (getEditor().getDefaultFeature())
{
std::string targetInstanceId;
// if object is a bot object, it is considered to be permanent content
// and should be created in the base act
CInstance *targetAct = isBotObject ? getEditor().getBaseAct() : getEditor().getCurrentAct();
if (!targetAct)
{
nlwarning("Can't find act when creating an entity");
}
else
{
if (_AutoGroup.getGroupingCandidate())
{
nlassert(!createGhost); // either autogroup or arraymode, both at the same time not supported
_AutoGroup.group(desc.get(), createPosition);
}
else
{
// create standalone
desc->setGhost(createGhost);
getDMC().requestInsertNode(getEditor().getDefaultFeature(targetAct)->getId(),
"Components",
-1,
"",
desc.get());
}
}
}
}
return instanceId;
}
void CDisplayerVisualEntity::updateEntity()
{
{
//BENCH(updateName)
//H_AUTO(R2_CDisplayerVisualEntity_updateEntity)
updateName();
}
CCDBNodeLeaf *leafA;
CCDBNodeLeaf *leafB;
CCDBNodeLeaf *leafC;
SPropVisualA vA;
SPropVisualB vB;
SPropVisualC vC;
{
//BENCH(entitySetup)
const string propNameA = toString("SERVER:Entities:E%d:P%d", _Entity->slot(), CLFECOMMON::PROPERTY_VPA);
const string propNameB = toString("SERVER:Entities:E%d:P%d", _Entity->slot(), CLFECOMMON::PROPERTY_VPB);
const string propNameC = toString("SERVER:Entities:E%d:P%d", _Entity->slot(), CLFECOMMON::PROPERTY_VPC);
leafA = NLGUI::CDBManager::getInstance()->getDbProp(propNameA);
leafB = NLGUI::CDBManager::getInstance()->getDbProp(propNameB);
leafC = NLGUI::CDBManager::getInstance()->getDbProp(propNameC);
if (!leafA)
{
nlwarning("Can't find DB leaf %s", propNameA.c_str());
return;
}
if (!leafB)
{
nlwarning("Can't find DB leaf %s", propNameB.c_str());
return;
}
if (!leafC)
{
nlwarning("Can't find DB leaf %s", propNameC.c_str());
return;
}
vA.PropertyA = leafA->getValue64();
vB.PropertyB = leafB->getValue64();
vC.PropertyC = leafC->getValue64();
vC.PropertySubData.CharacterHeight = (uint) getNumber(&getProps(), "GabaritHeight");
vC.PropertySubData.ArmsWidth = (uint) getNumber(&getProps(), "GabaritArmsWidth");
vC.PropertySubData.TorsoWidth = (uint) getNumber(&getProps(), "GabaritTorsoWidth");
vC.PropertySubData.LegsWidth = (uint) getNumber(&getProps(), "GabaritLegsWidth");
vC.PropertySubData.BreastSize = (uint) getNumber(&getProps(), "GabaritBreastSize");
int itemNb = (int) getNumber(&getProps(), "HairType");
std::string itemFileName;
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vA.PropertySubData.HatModel = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::HEAD_SLOT);
}
else
{
vA.PropertySubData.HatModel = 0;
}
vA.PropertySubData.HatColor = (uint) getNumber(&getProps(), "HairColor");
vC.PropertySubData.Tattoo = (uint) getNumber(&getProps(), "Tattoo");
vC.PropertySubData.EyesColor = (uint) getNumber(&getProps(), "EyesColor");
vC.PropertySubData.MorphTarget1 = (uint) getNumber(&getProps(), "MorphTarget1");
vC.PropertySubData.MorphTarget2 = (uint) getNumber(&getProps(), "MorphTarget2");
vC.PropertySubData.MorphTarget3 = (uint) getNumber(&getProps(), "MorphTarget3");
vC.PropertySubData.MorphTarget4 = (uint) getNumber(&getProps(), "MorphTarget4");
vC.PropertySubData.MorphTarget5 = (uint) getNumber(&getProps(), "MorphTarget5");
vC.PropertySubData.MorphTarget6 = (uint) getNumber(&getProps(), "MorphTarget6");
vC.PropertySubData.MorphTarget7 = (uint) getNumber(&getProps(), "MorphTarget7");
vC.PropertySubData.MorphTarget8 = (uint) getNumber(&getProps(), "MorphTarget8");
itemNb = (int) getNumber(&getProps(), "JacketModel");
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vA.PropertySubData.JacketModel = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::CHEST_SLOT);
}
else
{
vA.PropertySubData.JacketModel = 0;
}
itemNb = (int) getNumber(&getProps(), "TrouserModel");
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vA.PropertySubData.TrouserModel = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::LEGS_SLOT);
}
else
{
vA.PropertySubData.TrouserModel = 0;
}
itemNb = (int) getNumber(&getProps(), "FeetModel");
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vB.PropertySubData.FeetModel = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::FEET_SLOT);
}
else
{
vB.PropertySubData.FeetModel = 0;
}
itemNb = (int) getNumber(&getProps(), "HandsModel");
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vB.PropertySubData.HandsModel = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::HANDS_SLOT);
}
else
{
vB.PropertySubData.HandsModel = 0;
}
itemNb = (int) getNumber(&getProps(), "ArmModel");
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vA.PropertySubData.ArmModel = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::ARMS_SLOT);
}
else
{
vA.PropertySubData.ArmModel = 0;
}
itemNb = (int) getNumber(&getProps(), "WeaponRightHand");
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vA.PropertySubData.WeaponRightHand = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::RIGHT_HAND_SLOT);
}
else
{
vA.PropertySubData.WeaponRightHand = 0;
}
itemNb = (int) getNumber(&getProps(), "WeaponLeftHand");
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vA.PropertySubData.WeaponLeftHand = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::LEFT_HAND_SLOT);
}
else
{
vA.PropertySubData.WeaponLeftHand = 0;
}
vA.PropertySubData.JacketColor = (uint) getNumber(&getProps(), "JacketColor");
vA.PropertySubData.TrouserColor = (uint) getNumber(&getProps(), "TrouserColor");
vB.PropertySubData.FeetColor = (uint) getNumber(&getProps(), "FeetColor");
vB.PropertySubData.HandsColor = (uint) getNumber(&getProps(), "HandsColor");
vA.PropertySubData.ArmColor = (uint) getNumber(&getProps(), "ArmColor");
}
{
//BENCH(entityApply)
// Set the database
leafA->setValue64(vA.PropertyA);
leafB->setValue64(vB.PropertyB);
leafC->setValue64(vC.PropertyC);
// Force to update properties
EntitiesMngr.updateVisualProperty(0, _Entity->slot(), CLFECOMMON::PROPERTY_VPA);
EntitiesMngr.updateVisualProperty(0, _Entity->slot(), CLFECOMMON::PROPERTY_VPB);
EntitiesMngr.updateVisualProperty(0, _Entity->slot(), CLFECOMMON::PROPERTY_VPC);
}
}
virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
string dbdst = getParam (Params, "dbdst");
string dbsrc = getParam (Params, "dbsrc");
CCDBNodeBranch *pNBdst = pIM->getDbBranch(dbdst);
CCDBNodeBranch *pNBsrc = pIM->getDbBranch(dbsrc);
// Branch copy
if ((pNBdst != NULL) && (pNBsrc != NULL))
{
//nlinfo("copying from %s to %s",pNBsrc->getName()->c_str(), pNBdst->getName()->c_str());
// Parse all children of the src branch
uint nbLeaves = pNBsrc->countLeaves();
for (uint i = 0; i < nbLeaves; ++i)
{
uint count = i;
CCDBNodeLeaf *pNLsrc = pNBsrc->findLeafAtCount(count);
// Find its access name
string sTmp = *pNLsrc->getName();
CCDBNodeBranch *pParent = pNLsrc->getParent();
while (pParent != pNBsrc)
{
sTmp = *pParent->getName() + ":" + sTmp;
pParent = pParent->getParent();
}
// Find the correspondant node in the dst branch
CCDBNodeLeaf *pNLdst = dynamic_cast<CCDBNodeLeaf*>(pNBdst->getNode(ICDBNode::CTextId(sTmp)));
if (pNLdst == NULL)
{
nlwarning ("cannot find destination leaf %s",sTmp.c_str());
}
else
{
pNLdst->setValue64(pNLsrc->getValue64());
//sint32 nVal = pNLsrc->getValue64();
//nlinfo("set value %d for node %s", nVal, sTmp.c_str());
}
}
return;
}
// Not branch copy so leaf copy
CInterfaceProperty ipsrc;
CInterfaceProperty ipdst;
if (!ipsrc.link (dbsrc.c_str()))
{
nlwarning("cannot find leaf %s",dbsrc.c_str());
return;
}
if (!ipdst.link (dbdst.c_str()))
{
nlwarning("cannot find leaf %s",dbdst.c_str());
return;
}
// copy
ipdst.setSInt64 (ipsrc.getSInt64());
}
