public static bool TryAddComponent(long entityId, string instanceTypeStr, string componentTypeStr) { MyEntity entity; Type type = null; Type type2 = null; MyComponentDefinitionBase base3; try { type = Type.GetType(instanceTypeStr, true); } catch (Exception) { } try { type = Type.GetType(componentTypeStr, true); } catch (Exception) { } if (!MyEntities.TryGetEntityById(entityId, out entity, false) || (type == null)) { return(false); } MyComponentBase component = MyComponentFactory.CreateInstanceByType(type); if ((entity.DefinitionId != null) && TryGetComponentDefinition(component.GetType(), entity.DefinitionId.Value.SubtypeId, out base3)) { component.Init(base3); } entity.Components.Add(type2, component); return(true); }
void Components_ComponentAdded(Type arg1, MyComponentBase arg2) { if (arg1 == typeof(MyGameLogicComponent)) { m_logic = arg2 as MyMeteorGameLogic; } }
void Components_ComponentAdded(Type arg1, MyComponentBase arg2) { if (arg1 == typeof(MyGameLogicComponent)) { m_debrisLogic = arg2 as MyDebrisBaseLogic; } }
public void BeforeComponentRemove(MyComponentBase component) { (component as MyInventoryBase).ContentsChanged -= child_OnContentsChanged; if (OnBeforeComponentRemove != null) { OnBeforeComponentRemove(this, component as MyInventoryBase); } }
/// <summary> /// Removes from list, but doesn't change ownership /// </summary> public static void DetachComponent(this IMyComponentAggregate aggregate, MyComponentBase component) { int index = aggregate.ChildList.GetComponentIndex(component); if (index != -1) { aggregate.ChildList.RemoveComponentAt(index); } }
public void AfterComponentAdd(MyComponentBase component) { (component as MyInventoryBase).ContentsChanged += child_OnContentsChanged; if (OnAfterComponentAdd != null) { OnAfterComponentAdd(this, component as MyInventoryBase); } }
protected override void OnComponentRemoved(Type t, MyComponentBase component) { base.OnComponentRemoved(t, component); var entityComponent = component as MyEntityComponentBase; var handler = ComponentRemoved; if (handler != null && entityComponent != null) handler(t, entityComponent); }
public static void RemoveComponent(this IMyComponentAggregate aggregate, MyComponentBase component) { int index = aggregate.ChildList.GetComponentIndex(component); if (index != -1) { aggregate.BeforeComponentRemove(component); component.SetContainer(null); aggregate.ChildList.RemoveComponentAt(index); } }
protected override void OnComponentAdded(Type t, MyComponentBase component) { base.OnComponentAdded(t, component); var entityComponent = component as MyEntityComponentBase; Debug.Assert(entityComponent != null, "The component added to the entity component container was not derived from MyEntityComponentBase!"); var handler = ComponentAdded; if (handler != null && entityComponent != null) handler(t, entityComponent); }
public static void AddComponent(this IMyComponentAggregate aggregate, MyComponentBase component) { Debug.Assert(aggregate != component, "Can not add to itself!"); if (component.ContainerBase != null) { component.OnBeforeRemovedFromContainer(); } aggregate.ChildList.AddComponent(component); component.SetContainer(aggregate.ContainerBase); aggregate.AfterComponentAdd(component); }
public void AfterComponentAdd(MyComponentBase component) { if (component is MyTriggerComponent) { int triggerCount = this.TriggerCount; this.TriggerCount = triggerCount + 1; } else if (component is MyTriggerAggregate) { (component as MyTriggerAggregate).OnTriggerCountChanged += new Action <MyTriggerAggregate, int>(this.OnChildAggregateCountChanged); this.TriggerCount += (component as MyTriggerAggregate).TriggerCount; } }
public void BeforeComponentRemove(MyComponentBase component) { if (component is MyTriggerComponent) { int triggerCount = this.TriggerCount; this.TriggerCount = triggerCount - 1; } else if (component is MyTriggerAggregate) { (component as MyTriggerAggregate).OnTriggerCountChanged -= new Action <MyTriggerAggregate, int>(this.OnChildAggregateCountChanged); this.TriggerCount -= (component as MyTriggerAggregate).TriggerCount; } }
private void LoadAsync(long entityId, Action <T> loadingDoneHandler) { var savedUnderType = MyComponentTypeFactory.GetComponentType(typeof(T)); MyEntity entity = null; MyComponentBase component = null; if (!MyEntities.TryGetEntityById(entityId, out entity) || !entity.Components.TryGet(savedUnderType, out component)) { Debug.Fail("MyEntityComponentReplicableBase - trying to init component on an entity, but either entity or component wasn't found!"); } loadingDoneHandler(component as T); }
public override void Deserialize(MyObjectBuilder_ComponentBase builder) { base.Deserialize(builder); MyObjectBuilder_InventoryAggregate aggregate = builder as MyObjectBuilder_InventoryAggregate; if ((aggregate != null) && (aggregate.Inventories != null)) { foreach (MyObjectBuilder_InventoryBase base2 in aggregate.Inventories) { MyComponentBase component = MyComponentFactory.CreateInstanceByTypeId(base2.TypeId); component.Deserialize(base2); this.AddComponent(component); } } }
void container_ComponentRemoved(Type type, MyComponentBase 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, MyComponentBase 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; } }
public static MyObjectBuilder_ComponentBase CreateObjectBuilder(MyComponentBase instance) { var objectBuilder = m_objectFactory.CreateObjectBuilder<MyObjectBuilder_ComponentBase>(instance); //if (objectBuilder == null) //{ // var baseType = instance.GetType().BaseType; // while (baseType != null && baseType != typeof(object) && objectBuilder == null) // { // objectBuilder = m_objectFactory.CreateObjectBuilder<MyObjectBuilder_ComponentBase>(baseType); // baseType = baseType.BaseType; // } //} return objectBuilder; }
public void BeforeComponentRemove(MyComponentBase component) { var trigger = component as MyTriggerComponent; /*if (OnBeforeComponentRemove != null) { OnBeforeComponentRemove(this, trigger); }*/ if (component is MyTriggerComponent) { TriggerCount--; } else if (component is MyTriggerAggregate) { (component as MyTriggerAggregate).OnTriggerCountChanged -= OnChildAggregateCountChanged; TriggerCount -= (component as MyTriggerAggregate).TriggerCount; } }
public void AfterComponentAdd(MyComponentBase component) { var trigger = component as MyTriggerComponent; if (component is MyTriggerComponent) { TriggerCount++; } else if (component is MyTriggerAggregate) { (component as MyTriggerAggregate).OnTriggerCountChanged += OnChildAggregateCountChanged; TriggerCount += (component as MyTriggerAggregate).TriggerCount; } /*if (OnAfterComponentAdd != null) { OnAfterComponentAdd(this, trigger); }*/ }
public void BeforeComponentRemove(MyComponentBase component) { var trigger = component as MyTriggerComponent; /*if (OnBeforeComponentRemove != null) * { * OnBeforeComponentRemove(this, trigger); * }*/ if (component is MyTriggerComponent) { TriggerCount--; } else if (component is MyTriggerAggregate) { (component as MyTriggerAggregate).OnTriggerCountChanged -= OnChildAggregateCountChanged; TriggerCount -= (component as MyTriggerAggregate).TriggerCount; } }
public void AfterComponentAdd(MyComponentBase component) { var trigger = component as MyTriggerComponent; if (component is MyTriggerComponent) { TriggerCount++; } else if (component is MyTriggerAggregate) { (component as MyTriggerAggregate).OnTriggerCountChanged += OnChildAggregateCountChanged; TriggerCount += (component as MyTriggerAggregate).TriggerCount; } /*if (OnAfterComponentAdd != null) * { * OnAfterComponentAdd(this, trigger); * }*/ }
public void AfterComponentAdd(MyComponentBase component) { var inv = component as MyInventoryBase; inv.ForcedPriority = ForcedPriority; inv.ContentsChanged += child_OnContentsChanged; if (component is MyInventory) { InventoryCount++; } else if (component is MyInventoryAggregate) { (component as MyInventoryAggregate).OnInventoryCountChanged += OnChildAggregateCountChanged; InventoryCount += (component as MyInventoryAggregate).InventoryCount; } if (OnAfterComponentAdd != null) { OnAfterComponentAdd(this, inv); } }
public void BeforeComponentRemove(MyComponentBase component) { var inv = component as MyInventoryBase; inv.ForcedPriority = null; inv.ContentsChanged -= child_OnContentsChanged; if (OnBeforeComponentRemove != null) { OnBeforeComponentRemove(this, inv); } if (component is MyInventory) { InventoryCount--; } else if (component is MyInventoryAggregate) { (component as MyInventoryAggregate).OnInventoryCountChanged -= OnChildAggregateCountChanged; InventoryCount -= (component as MyInventoryAggregate).InventoryCount; } }
public void BeforeComponentRemove(MyComponentBase component) { MyInventoryBase base2 = component as MyInventoryBase; base2.ForcedPriority = null; base2.ContentsChanged -= new Action <MyInventoryBase>(this.child_OnContentsChanged); if (this.OnBeforeComponentRemove != null) { this.OnBeforeComponentRemove(this, base2); } if (component is MyInventory) { int inventoryCount = this.InventoryCount; this.InventoryCount = inventoryCount - 1; } else if (component is MyInventoryAggregate) { (component as MyInventoryAggregate).OnInventoryCountChanged -= new Action <MyInventoryAggregate, int>(this.OnChildAggregateCountChanged); this.InventoryCount -= (component as MyInventoryAggregate).InventoryCount; } }
public void AfterComponentAdd(MyComponentBase component) { MyInventoryBase base2 = component as MyInventoryBase; base2.ForcedPriority = this.ForcedPriority; base2.ContentsChanged += new Action <MyInventoryBase>(this.child_OnContentsChanged); if (component is MyInventory) { int inventoryCount = this.InventoryCount; this.InventoryCount = inventoryCount + 1; } else if (component is MyInventoryAggregate) { (component as MyInventoryAggregate).OnInventoryCountChanged += new Action <MyInventoryAggregate, int>(this.OnChildAggregateCountChanged); this.InventoryCount += (component as MyInventoryAggregate).InventoryCount; } if (this.OnAfterComponentAdd != null) { this.OnAfterComponentAdd(this, base2); } }
public static bool TryAddComponent(long entityId, MyDefinitionId componentDefinitionId) { MyEntity entity; MyComponentDefinitionBase base2; if (!MyEntities.TryGetEntityById(entityId, out entity, false)) { return(false); } if (TryGetComponentDefinition(componentDefinitionId.TypeId, componentDefinitionId.SubtypeId, out base2)) { MyComponentBase component = MyComponentFactory.CreateInstanceByTypeId(base2.Id.TypeId); Type componentType = MyComponentTypeFactory.GetComponentType(component.GetType()); if (componentType == null) { return(false); } component.Init(base2); entity.Components.Add(componentType, component); } return(true); }
public static bool RemoveComponent(this IMyComponentAggregate aggregate, MyComponentBase component) { int index = aggregate.ChildList.GetComponentIndex(component); if (index != -1) { aggregate.BeforeComponentRemove(component); component.SetContainer(null); aggregate.ChildList.RemoveComponentAt(index); return true; } foreach (var child in aggregate.ChildList.Reader) { var childAggregate = child as IMyComponentAggregate; if (childAggregate == null) continue; bool removed = childAggregate.RemoveComponent(component); if (removed) return true; } return false; }
/// <summary> /// Adds to list but doesn't change ownership /// </summary> public static void AttachComponent(this IMyComponentAggregate aggregate, MyComponentBase component) { aggregate.ChildList.AddComponent(aggregate.ContainerBase, component); }
void Components_ComponentAdded(Type arg1, MyComponentBase arg2) { if (arg1 == typeof(MyGameLogicComponent)) m_debrisLogic = arg2 as MyDebrisBaseLogic; }
void Components_ComponentAdded(Type arg1, MyComponentBase arg2) { if (arg1 == typeof(MyGameLogicComponent)) m_logic = arg2 as MyMeteorGameLogic; }
public bool Contains(MyComponentBase component) { if (m_components.Contains(component)) { return true; } foreach (var childComponent in m_components) { if (childComponent is IMyComponentAggregate) { var childAggregate = (childComponent as IMyComponentAggregate); if (childAggregate.ChildList.Contains(component)) { return true; } } } return false; }
public bool RemoveComponent(MyComponentBase component) { if (Contains(component)) { component.OnBeforeRemovedFromContainer(); } else { return false; } if (m_components.Remove(component)) { return true; } foreach (var childComponent in m_components) { if (childComponent is IMyComponentAggregate) { var childAggregate = (childComponent as IMyComponentAggregate); if (childAggregate.ChildList.RemoveComponent(component)) { return true; } } } return false; }
public void AddComponent(MyComponentBase component) { m_components.Add(component); }
private void child_OnContentsChanged(MyComponentBase obj) { OnContentsChanged(); }
public void AddComponent(MyComponentContainer container, MyComponentBase component) { m_components.Add(component); }
public int GetComponentIndex(MyComponentBase component) { return m_components.IndexOf(component); }
public static void InitComponents(this MyComponentContainer container, MyObjectBuilderType type, MyStringHash subtypeName, MyObjectBuilder_ComponentContainer builder) { if (MyDefinitionManager.Static != null) { MyContainerDefinition definition = null; bool flag = ReferenceEquals(builder, null); if (TryGetContainerDefinition(type, subtypeName, out definition)) { container.Init(definition); if (definition.DefaultComponents != null) { foreach (MyContainerDefinition.DefaultComponent component in definition.DefaultComponents) { MyComponentDefinitionBase componentDefinition = null; MyObjectBuilder_ComponentBase base3 = FindComponentBuilder(component, builder); bool flag2 = base3 != null; Type type2 = null; MyComponentBase base4 = null; MyStringHash hash = subtypeName; if (component.SubtypeId != null) { hash = component.SubtypeId.Value; } if (TryGetComponentDefinition(component.BuilderType, hash, out componentDefinition)) { base4 = MyComponentFactory.CreateInstanceByTypeId(componentDefinition.Id.TypeId); base4.Init(componentDefinition); } else if (component.IsValid()) { base4 = component.BuilderType.IsNull ? MyComponentFactory.CreateInstanceByType(component.InstanceType) : MyComponentFactory.CreateInstanceByTypeId(component.BuilderType); } if (base4 != null) { Type componentType = MyComponentTypeFactory.GetComponentType(base4.GetType()); if (componentType != null) { type2 = componentType; } else { MyComponentDefinitionBase base1 = componentDefinition; } } if ((type2 == null) && (base4 != null)) { type2 = base4.GetType(); } if (((base4 != null) && (type2 != null)) && ((flag | flag2) || component.ForceCreate)) { if (base3 != null) { base4.Deserialize(base3); } container.Add(type2, base4); } } } } container.Deserialize(builder); } }
/// <summary> /// Adds to list but doesn't change ownership /// </summary> public static void AttachComponent(this IMyComponentAggregate aggregate, MyComponentBase component) { Debug.Assert(aggregate != component, "Can not add to itself!"); aggregate.ChildList.AddComponent(component); }
public bool RemoveComponent(MyComponentBase component) { if (m_components.Remove(component)) { return true; } foreach (var childComponent in m_components) { if (childComponent is IMyComponentAggregate) { if ((childComponent as IMyComponentAggregate).ChildList.RemoveComponent(component)) { return true; } } } return false; }
public static void AddComponent(this IMyComponentAggregate aggregate, MyComponentBase component) { aggregate.ChildList.AddComponent(aggregate.ContainerBase, component); component.SetContainer(aggregate.ContainerBase); aggregate.AfterComponentAdd(component); }
/// <summary> /// Tries to retrieve entity definition of the entity owning this container, check if the definition has some DefaultComponents, /// tries to retrieve these components definitions, create these components instances and add them /// /// TODO: This should be ideally a behavior of the MyEntityComponentContainer when it is initialized (deserialized).. or by the factory, for now, this is an extension method /// </summary> public static void InitComponents(this MyComponentContainer container, MyObjectBuilderType type, MyStringHash subtypeName, MyObjectBuilder_ComponentContainer builder) { if (MyDefinitionManager.Static != null) { MyContainerDefinition definition = null; bool IsFirstInit = builder == null; if (TryGetContainerDefinition(type, subtypeName, out definition)) { container.Init(definition); if (definition.DefaultComponents != null) { foreach (var component in definition.DefaultComponents) { MyComponentDefinitionBase componentDefinition = null; MyObjectBuilder_ComponentBase componentBuilder = FindComponentBuilder(component, builder); bool IsComponentSerialized = componentBuilder != null; Type componentType = null; MyComponentBase componentInstance = null; var componentSubtype = subtypeName; if (component.SubtypeId.HasValue) { componentSubtype = component.SubtypeId.Value; } // Create component instance if (TryGetComponentDefinition(component.BuilderType, componentSubtype, out componentDefinition)) { componentInstance = MyComponentFactory.CreateInstanceByTypeId(componentDefinition.Id.TypeId); componentInstance.Init(componentDefinition); } else if (component.IsValid()) { if (!component.BuilderType.IsNull) { componentInstance = MyComponentFactory.CreateInstanceByTypeId(component.BuilderType); } else { componentInstance = MyComponentFactory.CreateInstanceByType(component.InstanceType); } } // Check component type from attributes. if (componentInstance != null) { var componentTypeFromAttr = MyComponentTypeFactory.GetComponentType(componentInstance.GetType()); if (componentTypeFromAttr != null) { componentType = componentTypeFromAttr; } else { if (componentDefinition != null) { System.Diagnostics.Debug.Fail("Unknown component type - component type attribute not specified for component class: " + componentInstance.GetType()); } } } //TODO: this should be avoided! Component type MUST be set via MyComponentType attribute. if (componentType == null && componentInstance != null) { componentType = componentInstance.GetType(); } // If everything passed, go on.. if (componentInstance != null && componentType != null) { bool componentShouldBeAdded = IsFirstInit || IsComponentSerialized || component.ForceCreate; if (componentShouldBeAdded) { if (componentBuilder != null) { componentInstance.Deserialize(componentBuilder); } // Add only fully initialized component.. container.Add(componentType, componentInstance); } } else { System.Diagnostics.Debug.Fail("Component instance wasn't created or it's base type couldn't been determined!"); } } } else { System.Diagnostics.Debug.Fail("Got definition for container, but DefaultComponents is null!"); } } // This may rewrite already once deserialized data, but will also add missing components in definition container.Deserialize(builder); } else { System.Diagnostics.Debug.Fail("Trying to init enabled components on entity, but definition manager is null"); } }