void Node::RemoveComponents(bool removeReplicated, bool removeLocal)
{
unsigned numRemoved = 0;
for (unsigned i = components_.Size() - 1; i < components_.Size(); --i)
{
bool remove = false;
Component* component = components_[i];
if (component->GetID() < FIRST_LOCAL_ID && removeReplicated)
remove = true;
else if (component->GetID() >= FIRST_LOCAL_ID && removeLocal)
remove = true;
if (remove)
{
RemoveComponent(components_.Begin() + i);
++numRemoved;
}
}
// Mark node dirty in all replication states
if (numRemoved)
MarkReplicationDirty();
}
Node* Node::CloneRecursive(Node* parent, SceneResolver& resolver, CreateMode mode)
{
// Create clone node
Node* cloneNode = parent->CreateChild(0, (mode == REPLICATED && id_ < FIRST_LOCAL_ID) ? REPLICATED : LOCAL);
resolver.AddNode(id_, cloneNode);
// Copy attributes
const Vector<AttributeInfo>* attributes = GetAttributes();
for (unsigned j = 0; j < attributes->Size(); ++j)
{
const AttributeInfo& attr = attributes->At(j);
// Do not copy network-only attributes, as they may have unintended side effects
if (attr.mode_ & AM_FILE)
cloneNode->SetAttribute(j, GetAttribute(j));
}
// Clone components
for (Vector<SharedPtr<Component> >::ConstIterator i = components_.Begin(); i != components_.End(); ++i)
{
Component* component = *i;
Component* cloneComponent = cloneNode->SafeCreateComponent(component->GetTypeName(), component->GetType(),
(mode == REPLICATED && component->GetID() < FIRST_LOCAL_ID) ? REPLICATED : LOCAL, 0);
if (!cloneComponent)
{
LOGERROR("Could not clone component " + component->GetTypeName());
continue;
}
resolver.AddComponent(component->GetID(), cloneComponent);
const Vector<AttributeInfo>* compAttributes = component->GetAttributes();
if (compAttributes)
{
for (unsigned j = 0; j < compAttributes->Size(); ++j)
{
const AttributeInfo& attr = compAttributes->At(j);
if (attr.mode_ & AM_FILE)
cloneComponent->SetAttribute(j, component->GetAttribute(j));
}
}
}
// Clone child nodes recursively
for (Vector<SharedPtr<Node> >::ConstIterator i = children_.Begin(); i != children_.End(); ++i)
{
Node* node = *i;
node->CloneRecursive(cloneNode, resolver, mode);
}
return cloneNode;
}
void ScriptInstance::OnGetAttribute(const AttributeInfo& attr, Variant& dest) const
{
AttributeInfo* attrPtr = const_cast<AttributeInfo*>(&attr);
// Get ID's for node / component handle attributes
if (attr.mode_ & (AM_NODEID | AM_COMPONENTID))
{
// If a cached ID value has been stored, return it instead of querying from the actual object
// (the object handle is likely null at that point)
HashMap<AttributeInfo*, unsigned>::ConstIterator i = idAttributes_.Find(attrPtr);
if (i != idAttributes_.End())
dest = i->second_;
else if (attr.mode_ & AM_NODEID)
{
Node* node = *(reinterpret_cast<Node**>(attr.ptr_));
unsigned nodeID = node ? node->GetID() : 0;
dest = nodeID;
}
else
{
Component* component = *(reinterpret_cast<Component**>(attr.ptr_));
unsigned componentID = component ? component->GetID() : 0;
dest = componentID;
}
}
else if (attr.type_ == VAR_RESOURCEREF && attr.ptr_)
{
Resource* resource = *(reinterpret_cast<Resource**>(attr.ptr_));
// If resource is non-null get its type and name hash. Otherwise get type from the default value
dest = GetResourceRef(resource, attr.defaultValue_.GetResourceRef().type_);
}
else
Serializable::OnGetAttribute(attr, dest);
}
//
// write_component
//
void ClientSidePrediction::write_component(VectorBuffer& message, Component& component)
{
// Write ID
message.WriteUInt(component.GetID());
// Write type
message.WriteStringHash(component.GetType());
// Write attributes
write_network_attributes(component, message);
}
void PageDetail::InitJun(HTREEITEM hitem)
{
CString strSubText; //节点名称
CString strMainText;//节点类型名称
CString strName;
CString strType;
int nNum = 0;
int nKey;
int nID;
HTREEITEM hMainItem = NULL;
HTREEITEM hSubItem = NULL;
Component *pTemp = NULL;
for(int i=1; i< 30; i++)
{
nNum = 0;
IteratorPtr<Component> iteratorPtr(m_pCompManager->CreatJunIterator());
hMainItem = m_tree.InsertItem(strMainText,hitem);
for(iteratorPtr->Fist();!iteratorPtr->IsDone();iteratorPtr->Next())
{
pTemp = &iteratorPtr->CurrentItem();
if(i == pTemp->GetID())
{
nKey = iteratorPtr->CurrentKey();
nID = pTemp->GetKey();
strName = pTemp->GetName(m_pScenario);
strSubText.Format(_T("J%d(%s)"),nID,strName);
hSubItem = m_tree.InsertItem(strSubText,hMainItem);
m_tree.SetItemData(hSubItem,nKey);
strType = pTemp->GetTypeName();
nNum++;
}
}
if(nNum != 0)
{
strMainText.Format(_T("%s(%d)"),strType,nNum);
m_tree.SetItemText(hMainItem,strMainText);
m_tree.SetItemData(hMainItem,2);
}
else
{
m_tree.DeleteItem(hMainItem);
}
}
}
Node* Node::CloneRecursive(Node* parent, SceneResolver& resolver, CreateMode mode)
{
// Create clone node
Node* cloneNode = parent->CreateChild(0, (mode == REPLICATED && id_ < FIRST_LOCAL_ID) ? REPLICATED : LOCAL);
resolver.AddNode(id_, cloneNode);
// Copy attributes
unsigned numAttributes = GetNumAttributes();
for (unsigned j = 0; j < numAttributes; ++j)
cloneNode->SetAttribute(j, GetAttribute(j));
// Clone components
for (Vector<SharedPtr<Component> >::ConstIterator i = components_.Begin(); i != components_.End(); ++i)
{
Component* component = *i;
Component* cloneComponent = cloneNode->CreateComponent(component->GetType(), (mode == REPLICATED && component->GetID() <
FIRST_LOCAL_ID) ? REPLICATED : LOCAL);
if (!cloneComponent)
{
LOGERROR("Could not clone component " + component->GetTypeName());
continue;
}
resolver.AddComponent(component->GetID(), cloneComponent);
numAttributes = component->GetNumAttributes();
for (unsigned j = 0; j < numAttributes; ++j)
cloneComponent->SetAttribute(j, component->GetAttribute(j));
}
// Clone child nodes recursively
for (Vector<SharedPtr<Node> >::ConstIterator i = children_.Begin(); i != children_.End(); ++i)
{
Node* node = *i;
node->CloneRecursive(cloneNode, resolver, mode);
}
return cloneNode;
}
void Node::PrepareNetworkUpdate()
{
// Update dependency nodes list first
dependencyNodes_.Clear();
// Add the parent node, but if it is local, traverse to the first non-local node
if (parent_ && parent_ != scene_)
{
Node* current = parent_;
while (current->id_ >= FIRST_LOCAL_ID)
current = current->parent_;
if (current && current != scene_)
dependencyNodes_.Push(current);
}
// Let the components add their dependencies
for (Vector<SharedPtr<Component> >::ConstIterator i = components_.Begin(); i != components_.End(); ++i)
{
Component* component = *i;
if (component->GetID() < FIRST_LOCAL_ID)
component->GetDependencyNodes(dependencyNodes_);
}
// Then check for node attribute changes
if (!networkState_)
AllocateNetworkState();
const Vector<AttributeInfo>* attributes = networkState_->attributes_;
unsigned numAttributes = attributes->Size();
if (networkState_->currentValues_.Size() != numAttributes)
{
networkState_->currentValues_.Resize(numAttributes);
networkState_->previousValues_.Resize(numAttributes);
// Copy the default attribute values to the previous state as a starting point
for (unsigned i = 0; i < numAttributes; ++i)
networkState_->previousValues_[i] = attributes->At(i).defaultValue_;
}
// Check for attribute changes
for (unsigned i = 0; i < numAttributes; ++i)
{
const AttributeInfo& attr = attributes->At(i);
OnGetAttribute(attr, networkState_->currentValues_[i]);
if (networkState_->currentValues_[i] != networkState_->previousValues_[i])
{
networkState_->previousValues_[i] = networkState_->currentValues_[i];
// Mark the attribute dirty in all replication states that are tracking this node
for (PODVector<ReplicationState*>::Iterator j = networkState_->replicationStates_.Begin(); j !=
networkState_->replicationStates_.End();
++j)
{
NodeReplicationState* nodeState = static_cast<NodeReplicationState*>(*j);
nodeState->dirtyAttributes_.Set(i);
// Add node to the dirty set if not added yet
if (!nodeState->markedDirty_)
{
nodeState->markedDirty_ = true;
nodeState->sceneState_->dirtyNodes_.Insert(id_);
}
}
}
}
// Finally check for user var changes
for (VariantMap::ConstIterator i = vars_.Begin(); i != vars_.End(); ++i)
{
VariantMap::ConstIterator j = networkState_->previousVars_.Find(i->first_);
if (j == networkState_->previousVars_.End() || j->second_ != i->second_)
{
networkState_->previousVars_[i->first_] = i->second_;
// Mark the var dirty in all replication states that are tracking this node
for (PODVector<ReplicationState*>::Iterator j = networkState_->replicationStates_.Begin(); j !=
networkState_->replicationStates_.End(); ++j)
{
NodeReplicationState* nodeState = static_cast<NodeReplicationState*>(*j);
nodeState->dirtyVars_.Insert(i->first_);
if (!nodeState->markedDirty_)
{
nodeState->markedDirty_ = true;
nodeState->sceneState_->dirtyNodes_.Insert(id_);
}
}
}
}
networkUpdate_ = false;
}
Component::Component( Component& c){
this->id = c.GetID();
this->type = c.GetType();
this->name = c.GetName();
}