internal bool Initialize(string typeResource, XmlElement typeData, Cv_EntityID parent = Cv_EntityID.INVALID_ENTITY)
{
if (typeResource != null)
{
EntityTypeResource = typeResource;
}
if (typeData != null)
{
EntityType = typeData.Attributes["type"].Value;
}
else
{
EntityType = "Unknown";
}
Parent = parent;
Cv_Debug.Log("Entity", "Initializing entity " + (int)ID + " of type " + EntityType);
return(true);
}
public bool AddNode(Cv_EntityID entityID, Cv_SceneNode node)
{
if (node == null)
{
Cv_Debug.Error("Trying to add nonexistant node to scene.");
return(false);
}
if (entityID != Cv_EntityID.INVALID_ENTITY)
{
Cv_HolderNode holderNode = null;
if (m_HolderNodes.TryGetValue(entityID, out holderNode))
{
if (holderNode.Parent.Properties.EntityID != Cv_EntityID.INVALID_ENTITY) //holderNode is not direct child of root
{
Cv_Debug.Error("Cannot have two nodes belonging to the same entity with different parents.");
return(false);
}
m_EntitiesMap[entityID].Add(node);
}
if (holderNode == null)
{
var nodes = new List <Cv_SceneNode>();
nodes.Add(node);
m_EntitiesMap.Add(entityID, nodes);
holderNode = new Cv_HolderNode(entityID);
m_Root.AddChild(holderNode);
m_HolderNodes.Add(entityID, holderNode);
}
SetNodeTransform(holderNode);
return(holderNode.AddChild(node));
}
return(m_Root.AddChild(node));
}
protected internal Cv_Entity CreateEmptyEntity(Cv_EntityID parent, Cv_EntityID serverEntityID, string resourceBundle, Cv_SceneID sceneID, string sceneName)
{
Cv_EntityID entityId = serverEntityID;
if (entityId == Cv_EntityID.INVALID_ENTITY)
{
lock (m_Mutex)
{
entityId = GetNextEntityID();
}
}
var entity = new Cv_Entity(entityId, resourceBundle, sceneName, sceneID);
if (!entity.Initialize(null, null, parent))
{
Cv_Debug.Error("Failed to initialize empty entity.");
return(null);
}
return(entity);
}
public void DestroyEntity(Cv_EntityID entityID)
{
lock (m_EntityList)
lock (Entities)
{
Cv_Entity entity = null;
var entityExists = false;
entityExists = Entities.TryGetValue(entityID, out entity);
if (entityExists && !entity.DestroyRequested)
{
if (entity.SceneRoot)
{
UnloadScene(entity.SceneID);
return;
}
DestroyEntity(entity);
}
}
}
protected internal override void VOnAttach(Cv_GameViewID id, Cv_EntityID entityId)
{
m_ID = id;
EntityID = entityId;
}
protected virtual void VGameOnAddView(Cv_GameView view, Cv_EntityID entityID)
{
}
public Cv_Event_NewCollisionShape(Cv_EntityID entityId, Cv_ShapeData shape, object sender, float timeStamp = 0) : base(entityId, sender, timeStamp)
{
ShapeData = shape;
}
public Cv_Event_DestroyCameraComponent(Cv_EntityID entityID, Cv_CameraNode cameraNode, object sender) : base(entityID, sender)
{
CameraNode = cameraNode;
}
public Cv_Event_RequestDestroyEntity(Cv_EntityID entityID, object sender) : base(entityID, sender)
{
}
public Cv_Event_NewEntity(Cv_EntityID entityID, object sender, Cv_GameViewID gameViewId = 0) : base(entityID, sender)
{
GameViewID = gameViewId;
}
public Cv_CameraNode(Cv_EntityID entityId, Cv_CameraComponent component) : base(entityId, component, Cv_Transform.Identity)
{
IsDebugCamera = false;
}
public abstract float VGetAngularVelocity(Cv_EntityID entityId);
public abstract void VSetVelocity(Cv_EntityID entityId, Vector2 vel);
public abstract Vector2 VGetVelocity(Cv_EntityID entityId);
// Physics entity states public abstract void VStopEntity(Cv_EntityID entityId);
public Cv_Event_DestroyRigidBodyComponent(Cv_EntityID entityID, object sender) : base(entityID, sender)
{
}
public bool AddNodeAsChild(Cv_EntityID parentEntity, Cv_EntityID entityID, Cv_SceneNode node)
{
if (node == null)
{
Cv_Debug.Error("Trying to add nonexistant node to scene.");
return(false);
}
if (entityID != Cv_EntityID.INVALID_ENTITY)
{
Cv_HolderNode ancestorNode = null;
if (parentEntity == Cv_EntityID.INVALID_ENTITY)
{
return(AddNode(entityID, node));
}
else if (!m_HolderNodes.ContainsKey(parentEntity))
{
var currEntity = Caravel.Logic.GetEntity(parentEntity);
var entityStack = new Stack <Cv_Entity>();
if (currEntity == null)
{
return(false);
}
//Rebuild path to root
entityStack.Push(currEntity);
while (currEntity.Parent != Cv_EntityID.INVALID_ENTITY)
{
currEntity = Caravel.Logic.GetEntity(currEntity.Parent);
if (m_HolderNodes.ContainsKey(currEntity.ID))
{
ancestorNode = m_HolderNodes[currEntity.ID];
break;
}
entityStack.Push(currEntity);
}
//Add all the nodes starting with the closest to the root
while (entityStack.Count > 0)
{
currEntity = entityStack.Pop();
var newNodes = new List <Cv_SceneNode>();
m_EntitiesMap.Add(currEntity.ID, newNodes);
var hNode = new Cv_HolderNode(currEntity.ID);
m_HolderNodes.Add(currEntity.ID, hNode);
if (ancestorNode != null)
{
ancestorNode.AddChild(hNode);
}
else
{
m_Root.AddChild(hNode);
}
ancestorNode = hNode;
SetNodeTransform(hNode);
}
}
else
{
ancestorNode = m_HolderNodes[parentEntity];
}
if (ancestorNode == null)
{
Cv_Debug.Error("Error while trying to find a parent for the new node.");
return(false);
}
Cv_HolderNode holderNode = null;
List <Cv_SceneNode> nodes = null;
if (m_HolderNodes.TryGetValue(entityID, out holderNode))
{
if (holderNode.Parent.Properties.EntityID != parentEntity)
{
Cv_Debug.Error("Cannot have two nodes belonging to the same entity with different parents.");
return(false);
}
nodes = m_EntitiesMap[entityID];
}
else
{
holderNode = new Cv_HolderNode(entityID);
ancestorNode.AddChild(holderNode);
SetNodeTransform(holderNode);
nodes = new List <Cv_SceneNode>();
m_EntitiesMap.Add(entityID, nodes);
m_HolderNodes.Add(entityID, holderNode);
}
nodes.Add(node);
return(holderNode.AddChild(node));
}
else
{
if (parentEntity != Cv_EntityID.INVALID_ENTITY)
{
Cv_Debug.Error("Trying to attach a node without entity to a node with an entity.");
return(false);
}
return(m_Root.AddChild(node));
}
}
internal void SetPlayerEntity(Cv_EntityID entityId)
{
EntityID = entityId;
}
protected internal abstract void VOnAttach(Cv_GameViewID id, Cv_EntityID entityId);
public abstract void VSetAngularVelocity(Cv_EntityID entityId, float vel);
public Cv_Event_ModifiedRenderComponent(Cv_EntityID entityID, object sender) : base(entityID, sender)
{
}
public abstract void VApplyForce(Vector2 dir, float newtons, Cv_EntityID entityId);
public Cv_Event_NewRenderComponent(Cv_EntityID entityID, Cv_EntityID parentId, Cv_SceneNode sceneNode, object sender) : base(entityID, sender)
{
ParentID = parentId;
SceneNode = sceneNode;
}
public abstract void VApplyTorque(float newtons, Cv_EntityID entityId);
protected override void VGameOnAddView(Cv_GameView view, Cv_EntityID entityId)
{
EditorView = (EditorView)view;
}
public abstract void SetCollidesWith(Cv_EntityID entityId1, Cv_EntityID entityId2, bool state, string shapeId1 = null, string shapeId2 = null);
public Cv_Event(Cv_EntityID entityId, object sender, float timeStamp = 0.0f)
{
Sender = sender;
EntityID = entityId;
TimeStamp = timeStamp;
}
public abstract void VRemoveEntity(Cv_EntityID id);
public abstract void SetEntityPaused(Cv_EntityID entityId, bool state);
internal Cv_Entity InstantiateNewEntity(bool isSceneRoot, string entityTypeResource, string name, string resourceBundle,
bool visible, Cv_EntityID parentID, XmlElement overrides,
Cv_Transform?transform, Cv_SceneID sceneID, Cv_EntityID serverEntityID)
{
if (!CanCreateEntity(name, serverEntityID))
{
return(null);
}
var scene = sceneID == Cv_SceneID.INVALID_SCENE ? m_SceneManager.MainScene : sceneID;
var sceneName = m_SceneManager.GetSceneName(scene);
Cv_Debug.Assert(sceneName != null, "Trying to add an entity to an invalid scene [" + scene + ", " + name + "]");
var path = "/" + name;
if (isSceneRoot) //Scene roots are named after the scene id
{
path = "/" + sceneName;
name = sceneName;
}
if (parentID == Cv_EntityID.INVALID_ENTITY)
{
if (!isSceneRoot)
{
var sceneRoot = m_SceneManager.GetSceneRoot(scene);
path = sceneRoot.EntityPath + path;
Cv_Debug.Assert(sceneRoot != null, "Trying to add an entity to an invalid scene [" + scene + ", " + name + "]");
parentID = sceneRoot.ID;
}
}
else
{
var parent = GetEntity(parentID);
if (parent == null)
{
Cv_Debug.Warning("Attempting to add an entity to a parent that doesn't exist.");
return(null);
}
if (parent.SceneID != scene && !isSceneRoot)
{
scene = parent.SceneID;
sceneName = parent.SceneName;
Cv_Debug.Warning("Attempting to add an entity of a scene to a parent that is not of the same scene [" + scene + ", " + name + "]. Adding to parent scene instead.");
}
path = parent.EntityPath + path;
}
Cv_Debug.Assert(!EntitiesByPath.ContainsKey(path), "All entities with the same parent must have a unique ID. Trying to add repeated entity [" + scene + ", " + name + "]");
Cv_Entity entity = null;
if (entityTypeResource != null)
{
entity = m_EntityFactory.CreateEntity(entityTypeResource, parentID, serverEntityID, resourceBundle, scene, sceneName);
}
else
{
entity = m_EntityFactory.CreateEmptyEntity(parentID, serverEntityID, resourceBundle, scene, sceneName);
}
if (entity != null)
{
entity.EntityName = name;
entity.EntityPath = path;
entity.Visible = visible;
entity.SceneRoot = isSceneRoot;
m_EntitiesToAdd.Enqueue(entity);
lock (Entities)
{
Entities.Add(entity.ID, entity);
EntitiesByPath.Add(entity.EntityPath, entity);
}
if (overrides != null)
{
m_EntityFactory.ModifyEntity(entity, overrides.SelectNodes("./*[not(self::Entity|self::Scene)]"));
}
var tranformComponent = entity.GetComponent <Cv_TransformComponent>();
if (tranformComponent != null && transform != null)
{
tranformComponent.Transform = transform.Value;
}
LastEntityID = entity.ID;
entity.PostInitialize();
if (!IsProxy && State == Cv_GameState.Running)
{
var requestNewEntityEvent = new Cv_Event_RequestNewEntity(null, scene, sceneName, entity.EntityName, resourceBundle, visible, parentID, transform, entity.ID);
Cv_EventManager.Instance.TriggerEvent(requestNewEntityEvent);
}
var newEntityEvent = new Cv_Event_NewEntity(entity.ID, this);
Cv_EventManager.Instance.TriggerEvent(newEntityEvent);
return(entity);
}
Cv_Debug.Error("Could not create entity with resource [" + resourceBundle + "].");
return(null);
}