void Container_ComponentAdded(Type arg1, MyEntityComponentBase arg2)
{
if (typeof(MyHierarchyComponentBase).IsAssignableFrom(arg1))
{
m_parent = arg2 as MyHierarchyComponentBase;
}
}
/// <summary>
/// When component is removed, clean it's records
/// </summary>
/// <param name="component">component being removed from its container (entity) </param>
private static void RegisteredComponentBeforeRemovedFromContainer(MyEntityComponentBase component)
{
component.BeforeRemovedFromContainer -= RegisteredComponentBeforeRemovedFromContainer;
if (component.Entity == null)
{
return;
}
if (RegisteredListeners.ContainsKey(component.Entity.EntityId))
{
m_tmpList.Clear();
foreach (var entry in RegisteredListeners[component.Entity.EntityId])
{
entry.Value.RemoveAll(x => x.Component == component);
}
}
if (ExternalListeners.ContainsKey(component))
{
foreach (var externalEntityId in ExternalListeners[component])
{
if (RegisteredListeners.ContainsKey(externalEntityId))
{
foreach (var entry in RegisteredListeners[externalEntityId])
{
entry.Value.RemoveAll(x => x.Component == component);
}
}
}
ExternalListeners.Remove(component);
}
}
/// <summary>
/// This will register the component to listen to some events on entity that is other than entity containing this component
/// </summary>
/// <param name="entity">Entity on which we listen to events</param>
/// <param name="component">Component that is being registered</param>
/// <param name="eventType">type of event</param>
/// <param name="handler">handler to be called</param>
public static void RegisterForEntityEvent(this MyEntityComponentBase component, MyEntity entity, MyStringHash eventType, EntityEventHandler handler)
{
if (ProcessingEvents)
{
AddPostponedRegistration(component, entity, eventType, handler);
return;
}
if (component.Entity == entity)
{
RegisterForEntityEvent(component, eventType, handler);
return;
}
if (entity == null)
{
System.Diagnostics.Debug.Fail("You can't register this component for events, when you don't know on which entity it should be listening to..");
return;
}
component.BeforeRemovedFromContainer += RegisteredComponentBeforeRemovedFromContainer;
entity.OnClose += RegisteredEntityOnClose;
if (RegisteredListeners.ContainsKey(entity.EntityId))
{
var registeredForEntity = RegisteredListeners[entity.EntityId];
if (registeredForEntity.ContainsKey(eventType))
{
var entry = registeredForEntity[eventType].Find(x => x.Handler == handler);
if (entry == null)
{
registeredForEntity[eventType].Add(new RegisteredComponent(component, handler));
}
}
else
{
registeredForEntity[eventType] = new List <RegisteredComponent>();
registeredForEntity[eventType].Add(new RegisteredComponent(component, handler));
}
}
else
{
RegisteredListeners[entity.EntityId] = new RegisteredEvents(eventType, component, handler);
}
if (ExternalListeners.ContainsKey(component) && !ExternalListeners[component].Contains(entity.EntityId))
{
ExternalListeners[component].Add(entity.EntityId);
}
else
{
ExternalListeners[component] = new List <long>()
{
entity.EntityId
};
}
ExternalyListenedEntities.Add(entity.EntityId);
}
void Container_ComponentRemoved(Type compType, MyEntityComponentBase component)
{
if (compType == typeof(MyUseObjectsComponentBase))
{
m_useObjectComp = null;
}
}
void Container_ComponentAdded(Type compType, MyEntityComponentBase component)
{
if (compType == typeof(MyUseObjectsComponentBase))
{
m_useObjectComp = component as MyUseObjectsComponentBase;
}
}
void Container_ComponentAdded(Type arg1, MyEntityComponentBase arg2)
{
if (typeof(MyHierarchyComponentBase).IsAssignableFrom(arg1))
{
m_parent = arg2 as MyHierarchyComponentBase;
}
}
void Container_ComponentRemoved(Type arg1, MyEntityComponentBase arg2)
{
if (arg2 == m_parent)
{
m_parent = null;
}
}
void container_ComponentAdded(Type type, MyEntityComponentBase comp)
{
if (type == typeof(MySyncComponentBase))
m_syncObject = comp as MySyncComponentBase;
else if (type == typeof(MyPhysicsComponentBase))
m_physics = comp as MyPhysicsComponentBase;
else if (type == typeof(MyHierarchyComponentBase))
m_hierarchy = comp as MyHierarchyComponentBase;
}
void container_ComponentRemoved(Type type, MyEntityComponentBase comp)
{
if (type == typeof(MySyncComponentBase))
m_syncObject = null;
else if (type == typeof(MyPhysicsComponentBase))
m_physics = null;
else if (type == typeof(MyHierarchyComponentBase))
m_hierarchy = null;
}
/// <summary>
/// This will unregister the component to listen to some events on entity that is other than entity containing this component
/// </summary>
/// <param name="entity">Entity on which we listen to events</param>
/// <param name="component">Component that is being registered</param>
/// <param name="eventType">type of event</param>
/// <param name="handler">handler to be called</param>
public static void UnregisterForEntityEvent(this MyEntityComponentBase component, MyEntity entity, MyStringHash eventType)
{
if (ProcessingEvents)
{
AddPostponedUnregistration(component, entity, eventType);
return;
}
if (entity == null)
{
System.Diagnostics.Debug.Fail("You can't register this component for events, when you don't know on which entity it should be listening to..");
return;
}
// TODO: Unregister events for components, or even bettter rework these EntityEvents to be used without event handlers..
//bool componentIsRegistered = true;
bool entityIsRegistered = true;
if (RegisteredListeners.ContainsKey(entity.EntityId))
{
if (RegisteredListeners[entity.EntityId].ContainsKey(eventType))
{
RegisteredListeners[entity.EntityId][eventType].RemoveAll(x => x.Component == component);
if (RegisteredListeners[entity.EntityId][eventType].Count == 0)
{
RegisteredListeners[entity.EntityId].Remove(eventType);
}
}
if (RegisteredListeners[entity.EntityId].Count == 0)
{
RegisteredListeners.Remove(entity.EntityId);
ExternalyListenedEntities.Remove(entity.EntityId);
entityIsRegistered = false;
}
}
if (ExternalListeners.ContainsKey(component) && ExternalListeners[component].Contains(entity.EntityId))
{
ExternalListeners[component].Remove(entity.EntityId);
if (ExternalListeners[component].Count == 0)
{
ExternalListeners.Remove(component);
}
}
if (!entityIsRegistered)
{
entity.OnClose -= RegisteredEntityOnClose;
}
//if (!componentIsRegistered)
//{
// component.BeforeRemovedFromContainer -= RegisteredComponentBeforeRemovedFromContainer;
//}
}
/// <summary>
/// Call this to raise event on entity, that will be processed by registered components
/// </summary>
/// <param name="component">component upon which container this is going to be invoke</param>
/// <param name="eventType">type of event</param>
/// <param name="eventParams">event params or derived type</param>
public static void RaiseEntityEvent(this MyEntityComponentBase component, MyStringHash eventType, EntityEventParams eventParams)
{
if (component.Entity == null) // this component is raising event, but it's entity don't exists..
{
return;
}
long entityId = component.Entity.EntityId;
InvokeEventOnListeners(entityId, eventType, eventParams);
}
void container_ComponentRemoved(Type type, MyEntityComponentBase comp)
{
if (type == typeof(MySyncComponentBase))
{
m_syncObject = null;
}
else if (type == typeof(MyPhysicsComponentBase))
{
m_physics = null;
}
else if (type == typeof(MyHierarchyComponentBase))
{
m_hierarchy = null;
}
}
void container_ComponentAdded(Type type, MyEntityComponentBase comp)
{
if (type == typeof(MySyncComponentBase))
{
m_syncObject = comp as MySyncComponentBase;
}
else if (type == typeof(MyPhysicsComponentBase))
{
m_physics = comp as MyPhysicsComponentBase;
}
else if (type == typeof(MyHierarchyComponentBase))
{
m_hierarchy = comp as MyHierarchyComponentBase;
}
}
private void OnComponentAdded(Type type, VRage.Game.Components.MyEntityComponentBase component)
{
var aggregate = component as MyInventoryAggregate;
if (aggregate != null)
{
m_inventoryAggregate = aggregate;
m_inventoryAggregate.BeforeRemovedFromContainer += OnInventoryAggregateRemoved;
m_inventoryAggregate.OnAfterComponentAdd += OnInventoryAddedToAggregate;
m_inventoryAggregate.OnBeforeComponentRemove += OnBeforeInventoryRemovedFromAggregate;
foreach (var inventory in m_inventoryAggregate.ChildList.Reader)
{
MyInventory inv = inventory as MyInventory;
OnInventoryAddedToAggregate(aggregate, inv);
}
}
}
private void inventory_OnRemovedFromContainer(MyEntityComponentBase component)
{
Debug.Assert(this.GetInventory().Entity == this, "Inventory is not longer owned by this character !");
this.GetInventory().BeforeRemovedFromContainer -= inventory_OnRemovedFromContainer;
this.GetInventory().ContentsChanged -= inventory_OnContentsChanged;
this.GetInventory().BeforeContentsChanged -= inventory_OnBeforeContentsChanged;
}
private static void AddPostponedUnregistration(MyEntityComponentBase component, MyEntity entity, MyStringHash eventType)
{
PostponedUnregistration.Add(new Tuple <MyEntityComponentBase, MyEntity, MyStringHash>(component, entity, eventType));
HasPostponedOperations = true;
}
private static void AddPostponedRegistration(MyEntityComponentBase component, MyEntity entity, MyStringHash eventType, EntityEventHandler handler)
{
PostponedRegistration.Add(new Tuple <MyEntityComponentBase, MyEntity, MyStringHash, EntityEventHandler>(component, entity, eventType, handler));
HasPostponedOperations = true;
}
void Container_ComponentRemoved(Type arg1, MyEntityComponentBase arg2)
{
if (arg2 == m_parent)
m_parent = null;
}
void OnNewComponentAdded(Type type, MyEntityComponentBase component)
{
if (component is MyInventory)
{
InitBlock();
}
}
void Container_ComponentRemoved(Type compType, MyEntityComponentBase component)
{
if (compType == typeof(MyUseObjectsComponentBase))
m_useObjectComp = null;
}
void Components_ComponentAdded(Type t, MyEntityComponentBase c)
{
// TODO: this has to be refactored because it is very dangerous - each component member set here can be overwritten with new one of the same base type
// (assume more than one GameLogicComponent), components should support aggregates (parameter can be added to MyComponentTypeAttribute).
if ((typeof(MyPhysicsComponentBase)).IsAssignableFrom(t))
m_physics = c as MyPhysicsComponentBase;
else if ((typeof(MySyncComponentBase)).IsAssignableFrom(t))
m_syncObject = c as MySyncComponentBase;
else if ((typeof(MyGameLogicComponent)).IsAssignableFrom(t))
m_gameLogic = c as MyGameLogicComponent;
else if ((typeof(MyPositionComponentBase)).IsAssignableFrom(t))
{
m_position = c as MyPositionComponentBase;
if (m_position == null)
PositionComp = new VRage.Game.Components.MyNullPositionComponent();
}
else if ((typeof(MyHierarchyComponentBase)).IsAssignableFrom(t))
m_hierarchy = c as MyHierarchyComponent<MyEntity>;
else if ((typeof(MyRenderComponentBase)).IsAssignableFrom(t))
{
m_render = c as MyRenderComponentBase;
if (m_render == null)
Render = new VRage.Game.Components.MyNullRenderComponent();
}
else if ((typeof(MyInventoryBase)).IsAssignableFrom(t))
{
OnInventoryComponentAdded(c as MyInventoryBase);
}
}
private void OnInventoryAggregateRemoved(MyEntityComponentBase component)
{
m_inputInventory = null;
m_outputInventory = null;
m_inventoryAggregate.BeforeRemovedFromContainer -= OnInventoryAggregateRemoved;
m_inventoryAggregate.OnAfterComponentAdd -= OnInventoryAddedToAggregate;
m_inventoryAggregate.OnBeforeComponentRemove -= OnBeforeInventoryRemovedFromAggregate;
m_inventoryAggregate = null;
}
void OnComponentAdded(System.Type arg1, MyEntityComponentBase arg2)
{
if (arg1 == typeof(MyCasterComponent))
{
raycaster = arg2 as MyCasterComponent;
this.PositionComp.OnPositionChanged += OnPositionChanged;
}
}
void OnComponentRemoved(System.Type arg1, MyEntityComponentBase arg2)
{
if (arg1 == typeof(MyCasterComponent))
{
raycaster = null;
this.PositionComp.OnPositionChanged -= OnPositionChanged;
}
}
void Components_ComponentRemoved(Type t, MyEntityComponentBase c)
{
// TODO: see comment at Components_ComponentAdded
if ((typeof(MyPhysicsComponentBase)).IsAssignableFrom(t))
m_physics = null;
else if ((typeof(MySyncComponentBase)).IsAssignableFrom(t))
m_syncObject = null;
else if ((typeof(MyGameLogicComponent)).IsAssignableFrom(t))
m_gameLogic = null;
else if ((typeof(MyPositionComponentBase)).IsAssignableFrom(t))
PositionComp = new VRage.Game.Components.MyNullPositionComponent();
else if ((typeof(MyHierarchyComponentBase)).IsAssignableFrom(t))
m_hierarchy = null;
else if ((typeof(MyRenderComponentBase)).IsAssignableFrom(t))
{
Render = new VRage.Game.Components.MyNullRenderComponent();
}
else if ((typeof(MyInventoryBase)).IsAssignableFrom(t))
{
OnInventoryComponentRemoved(c as MyInventoryBase);
}
}
void Container_ComponentAdded(Type compType, MyEntityComponentBase component)
{
if (compType == typeof(MyUseObjectsComponentBase))
m_useObjectComp = component as MyUseObjectsComponentBase;
}