public void should_correctly_notify_when_matching_component_removed()
{
var componentTypes = new[] { typeof(TestComponentOne), typeof(TestComponentTwo) };
var fakeEventSystem = new EventSystem(new MessageBroker());
var fakeEntity1 = new Entity(Guid.Empty, fakeEventSystem);
fakeEntity1.AddComponent <TestComponentOne>();
fakeEntity1.AddComponent <TestComponentTwo>();
fakeEntity1.AddComponent <TestComponentThree>();
var fakeEntity2 = new Entity(Guid.Empty, fakeEventSystem);
fakeEntity2.AddComponent <TestComponentOne>();
fakeEntity2.AddComponent <TestComponentThree>();
var timesCalled = 0;
var groupWatcher = new DefaultGroupWatcher(fakeEventSystem, componentTypes);
groupWatcher.OnEntityRemoved.Subscribe(x =>
{
Assert.That(x, Is.EqualTo(fakeEntity1));
timesCalled++;
});
fakeEntity1.RemoveComponent <TestComponentThree>();
fakeEntity1.RemoveComponent <TestComponentTwo>();
fakeEntity2.RemoveComponent <TestComponentThree>();
Assert.That(timesCalled, Is.EqualTo(1));
}
public void should_correctly_notify_when_matching_component_removed()
{
var componentTypes = new[] { typeof(TestComponentOne), typeof(TestComponentTwo) };
var fakeEventSystem = new EventSystem(new MessageBroker());
var accessorToken = new ObservableGroupToken(componentTypes, "default");
var fakeEntity1 = new Entity(Guid.Empty, fakeEventSystem);
fakeEntity1.AddComponent <TestComponentOne>();
fakeEntity1.AddComponent <TestComponentTwo>();
fakeEntity1.AddComponent <TestComponentThree>();
var fakeEntity2 = new Entity(Guid.Empty, fakeEventSystem);
fakeEntity2.AddComponent <TestComponentOne>();
fakeEntity2.AddComponent <TestComponentThree>();
var timesCalled = 0;
var observableGroup = new ObservableGroup(fakeEventSystem, accessorToken, new IEntity[] { fakeEntity1 });
ObservableExtensions.Subscribe <IEntity>(observableGroup.OnEntityRemoved, x =>
{
Assert.Equal <IEntity>(fakeEntity1, x);
timesCalled++;
});
fakeEntity1.RemoveComponent <TestComponentThree>();
fakeEntity1.RemoveComponent <TestComponentTwo>();
fakeEntity2.RemoveComponent <TestComponentThree>();
Assert.Equal(1, timesCalled);
}
static void Main(string[] args)
{
Engine engine = new Engine();
engine.SystemAdded += (system) => Console.WriteLine($"{system.GetType()} added.");
engine.SystemRemoved += (system) => Console.WriteLine($"{system.GetType()} removed.");
engine.EntityAdded += (entity) => Console.WriteLine($"Entity with ID {entity.ID} added.");
engine.EntityRemoved += (entity) => Console.WriteLine($"Entity with ID {entity.ID} removed.");
Entity e1 = engine.CreateEntity();
Entity e2 = engine.CreateEntity();
e1.AddComponent <PositionComponent>().Set(3, 4);
e1.AddComponent <VelocityComponent>().Set(1, 5);
e1.RemoveComponent <PositionComponent>();
e1.RemoveComponent <VelocityComponent>();
e2.AddComponent <PositionComponent>();
e2.AddComponent <VelocityComponent>();
e1.AddComponent <PositionComponent>();
e1.AddComponent <VelocityComponent>();
engine.AddEntity(e1);
engine.AddEntity(e2);
engine.AddSystem(new MovementSystem());
engine.Update(1);
engine.Update(1);
Console.ReadKey();
}
public void OnLocalTankDestruction(NodeRemoveEvent e, RemoteTankNode node)
{
Entity entity = node.Entity;
entity.RemoveComponent <KalmanFilterComponent>();
entity.RemoveComponent <RemoteTankSmootherComponent>();
}
private void cleanUpLobby(Entity lobby)
{
if (lobby.HasComponent <ClientMatchMakingLobbyStartTimeComponent>())
{
lobby.RemoveComponent <ClientMatchMakingLobbyStartTimeComponent>();
}
if (lobby.HasComponent <ClientMatchMakingLobbyStartingComponent>())
{
lobby.RemoveComponent <ClientMatchMakingLobbyStartingComponent>();
}
}
/// <summary>
/// Refresh the collider of a surface entity
/// </summary>
/// <param name="surfaceEntity">The entity to update</param>
protected override void RefreshCollider(Entity surfaceEntity)
{
if (!surfaceEntity.IsDisposed)
{
surfaceEntity.RemoveComponent <MeshCollider3D>();
surfaceEntity.RemoveComponent <StaticBody3D>();
if (this.GenerateColliders)
{
surfaceEntity.AddComponent(new StaticBody3D());
surfaceEntity.AddComponent(new MeshCollider3D());
surfaceEntity.RefreshDependencies();
}
}
}
private static void CleanBundleRequest(Entity entity)
{
if (entity.HasComponent <AssetGroupComponent>())
{
entity.RemoveComponent <AssetGroupComponent>();
}
if (entity.HasComponent <ResourceLoadStatComponent>())
{
entity.RemoveComponent <ResourceLoadStatComponent>();
}
if (entity.HasComponent <AssetBundlesLoadDataComponent>())
{
entity.RemoveComponent <AssetBundlesLoadDataComponent>();
}
}
public void RemoveComponent_RemovesComponentAndUnregistersIt()
{
// arrange
var component = new Mock <Component>();
var componentManager = new Mock <ComponentManager>();
var ecs = new Mock <EcsManager>();
ecs.SetupGet(e => e.ComponentManager).Returns(componentManager.Object);
var entity = new Entity
{
Ecs = ecs.Object,
Components = { component.Object },
};
// act
entity.RemoveComponent(component.Object);
// assert
componentManager.Verify(cm => cm.Unregister(component.Object), Times.Once);
Assert.False(entity.Components.Contains(component.Object));
}
public void DragStackClear()
{
DragDisp.RemoveComponent <DragComponent>();
CardPileComponent sc = DragDisp.GetComponent <CardPileComponent>();
sc.CardsInPile.Clear();
}
public void Update()
{
PlayerDamageComponent playerDamageComponent = entityDatabase.QueryType <PlayerDamageComponent>();
if (!playerDamageComponent)
{
return;
}
Entity playerEntity = playerDamageComponent.entity;
PlayerComponent playerComponent = playerEntity.GetComponent <PlayerComponent>();
playerComponent.audioSource.Play();
playerComponent.healthModel.health.value -= playerDamageComponent.amount;
if (playerComponent.healthModel.health.value <= 0)
{
Death(playerComponent);
}
playerEntity.RemoveComponent <PlayerDamageComponent>();
entityDatabase.QueryType <EventComponent>().eventDispatcher.Dispatch(GameEvent.PlayerDamage);
}
public override void Process(Entity entity)
{
MinionComponent minionComponent = entity.GetComponent <MinionComponent>();
PositionComponent positionComponent = entity.GetComponent <PositionComponent>();
if (new Rectangle(positionComponent.Position.ToPoint(), new Point(32, 32)).Intersects(new Rectangle((int)(mouse.State.X / LD34Game.Scale), (int)(mouse.State.Y / LD34Game.Scale), 0, 0)))
{
if (!entity.HasComponent <CardComponent>())
{
entity.AddComponent(new CardComponent(minionComponent.Minion, true, 0f, 0f, new Vector2(-16f, -96f), false, false, 0f));
}
CardComponent cardComponent = entity.GetComponent <CardComponent>();
cardComponent.ModifierOpacity += (1f - cardComponent.ModifierOpacity) * 6f * delta;
cardComponent.Separation += (1f - cardComponent.Separation) * 12f * delta;
if (cardComponent.Separation > 1f)
{
cardComponent.Separation = 1f;
}
cardComponent.Opacity += (1f - cardComponent.Opacity) * 12f * delta;
cardComponent.Offset += (new Vector2(-16f, -128f) - cardComponent.Offset) * 12f * delta;
}
else if (entity.HasComponent <CardComponent>())
{
CardComponent cardComponent = entity.GetComponent <CardComponent>();
cardComponent.Separation += (0f - cardComponent.Separation) * 12f * delta;
cardComponent.Opacity += (0f - cardComponent.Opacity) * 12f * delta;
cardComponent.Offset += (new Vector2(-16f, -96f) - cardComponent.Offset) * 12f * delta;
if (cardComponent.Opacity < 0.025f)
{
entity.RemoveComponent <CardComponent>();
}
}
}
public void EngineQueries()
{
Engine engine = new Engine();
Entity entity = engine.CreateEntity();
ImmutableList <Entity> entities = engine.GetEntities();
Assert.NotNull(entities);
Assert.AreEqual(entities.Count, 1);
{
ImmutableList <Entity> entities2 = engine.GetEntities();
Assert.AreSame(entities, entities2);
}
ImmutableList <Entity> ecs1Entities = engine.GetEntitiesFor(Family.All(typeof(ECSComponent1)).Get());
Assert.NotNull(ecs1Entities);
Assert.AreEqual(ecs1Entities.Count, 0);
{
ImmutableList <Entity> ecs1Entities2 = engine.GetEntitiesFor(Family.All(typeof(ECSComponent1)).Get());
Assert.AreSame(ecs1Entities, ecs1Entities2);
}
entity.AddComponent(new ECSComponent1());
Assert.AreEqual(ecs1Entities.Count, 1);
entity.RemoveComponent <ECSComponent1>();
Assert.AreEqual(ecs1Entities.Count, 0);
}
public void should_not_throw_error_when_removing_non_existent_component_with_generic()
{
var mockEventSystem = Substitute.For <IEventSystem>();
var entity = new Entity(1, mockEventSystem);
entity.RemoveComponent <TestComponentOne>();
}
/// <summary>
/// Modifies the background image with the new asset path.
/// </summary>
/// <param name="imagePath">Path to the background image</param>
private void ChangeBackgroundImage(string imagePath)
{
Entity imageEntity = this.entity.FindChild("ImageEntity");
if (imageEntity != null)
{
// If imageEntity exist
imageEntity.RemoveComponent <ImageControl>();
imageEntity.AddComponent(new ImageControl(imagePath)
{
Stretch = Stretch.Fill
});
imageEntity.RefreshDependencies();
}
else
{
// If imageEntity doesn't exist
this.entity.AddChild(new Entity("ImageEntity")
.AddComponent(new Transform2D()
{
DrawOrder = 0.5f
})
.AddComponent(new ImageControl(imagePath)
{
Stretch = Stretch.Fill
})
.AddComponent(new ImageControlRenderer()));
this.entity.RefreshDependencies();
}
}
/// <summary>
/// Removes the Component from its parent Entity.
/// </summary>
public void RemoveSelf()
{
if (Entity != null)
{
Entity.RemoveComponent(this);
}
}
public override void Remove(Entity entity)
{
entity.RemoveComponent <ConfusedMonsterAI>();
entity.Tags.Remove(Tags.Confused);
entity.AddComponent(previousActorComponent);
}
public void SwitchFromSpeedUpToIdleWhenSelfTankInactive(NodeRemoveEvent evt, SelfActiveTankNode selfActiveTank, [JoinByTank] VulcanWeaponSpeedUpControllerNode vulcanSpeedUp)
{
Entity entity = vulcanSpeedUp.Entity;
entity.RemoveComponent <VulcanSpeedUpComponent>();
entity.AddComponent <VulcanIdleComponent>();
}
public override void Process(Entity entity)
{
//
// ONLY piano key entities come here
//
MainGameScene = entity.Scene as MainScene; //hand entity belongs to MainScene
SpriteRenderer sp = entity.GetComponent <SpriteRenderer>();
PlayingComponent pc = entity.GetComponent <PlayingComponent>();
if (pc.ChannelMsg.Command == ChannelCommand.NoteOn)
{
sp.Color = Color.Blue;
}
else
{
sp.Color = Color.White;
}
entity.RemoveComponent <PlayingComponent>();
if (PrevKey == null)
{
PrevKey = entity;
return;
}
SpriteRenderer PrevSp = PrevKey.GetComponent <SpriteRenderer>();
PrevSp.Color = Color.White;
PrevKey = entity;
}
public void DestroyEntityWithChildren(Entity entity)
{
if (Running)
{
entity.Deactivate();
}
var comps = entity.Components;
while (comps.Count > 0)
{
entity.RemoveComponent(comps[0]);
}
for (int i = 0; i < entity.HierarchyNode.Children.Count; i++)
{
DestroyEntityWithChildren(entity.HierarchyNode.Children[i].Value);
}
entity.Parent = null;
entity.HierarchyNode.Parent = null;
_entities.Remove(entity);
_uids.Remove(entity.UID);
Log.Core.Trace($"removed entity with uid {entity.UID}");
}
public void Exit(Entity entity)
{
for (int i = 0; i < componentsType.Count; i++)
{
entity.RemoveComponent(componentsType[i]);
}
}
public void should_not_throw_error_when_removing_non_existent_component_with_generic()
{
var mockMessageBroker = Substitute.For <IMessageBroker>();
var entity = new Entity(1, mockMessageBroker);
entity.RemoveComponent <TestComponentOne>();
}
private void TurnOn(Entity entity)
{
if (!TwitchBridge.On)
{
entity.RemoveComponent <PlayerInputComponent>();
var id = TwitchBridge.TwitchUsername;
sign.GetComponent <DialogComponent>().Start("logging_in");
new Thread(() => {
TwitchBridge.TurnOn(GlobalSave.GetString("twitch_username"), (ok) => {
if (ok)
{
base.Interact(entity);
}
else
{
sign.GetComponent <DialogComponent>().StartAndClose($"{Locale.Get("failed_to_login")}\n[cl purple]{id}[cl]", 3);
entity.AddComponent(new PlayerInputComponent());
}
});
}).Start();
}
else
{
base.Interact(entity);
}
}
public override void Update(Entity entity, SpawnEvent ev, CollisionEvent _)
{
if (_config.Requests.Contains(ev.Request))
{
entity.RemoveComponent(ev);
}
}
public void SetState(Entity entity, string stateName)
{
List <string> newState = this.States[stateName];
if (this.CurrentState == newState)
{
return;
}
foreach (string componentName in this.CurrentState)
{
if (newState.IndexOf(componentName) == -1)
{
entity.RemoveComponent(ComponentTypeManager.GetTypeFor(this.Components[componentName].GetType()));
}
}
foreach (string componentName in newState)
{
if (this.CurrentState.IndexOf(componentName) == -1)
{
entity.AddComponent(this.Components[componentName]);
}
}
this.CurrentState = newState;
}
public void TryGetComponent()
{
ECSWorld world = new ECSWorld();
for (int i = 0; i < loop_amount; i++)
{
Entity entity = world.EntityManager.CreateEntity();
Assert.False(entity.TryGetComponent(world, out TestComponentWithInt ti));
world.ComponentManager.AddComponent(entity, new TestComponentWithInt {
someInt = 10
});
Assert.True(entity.TryGetComponent(world, out TestComponentWithInt test));
Assert.Equal(10, test.someInt);
world.ComponentManager.GetComponent <TestComponentWithInt>(entity).someInt = 12;
Assert.Equal(12, world.ComponentManager.GetComponent <TestComponentWithInt>(entity).someInt);
entity.RemoveComponent <TestComponentWithInt>(world);
Assert.False(entity.TryGetComponent(world, out TestComponentWithInt ti2));
}
}
public static void UndoChange(ComponentChange change)
{
Entity entity = Entities.Find(change.EntityId);
Type componentType = change.IsRemoved?change.Before.GetType():change.After.GetType();
if (change.IsRemoved)
{
// Add new component.
if (entity == null) // Add new entity.
{
entity = Entities.AddEntityFromSync(change.EntityId, change.Before);
}
else // Add new component.
{
entity.AddComponent(change.Before);
}
}
else
{
if (change.Before == null)
{
// Remove component.
entity.RemoveComponent(componentType);
}
else
{
// Undo changes in existing component.
EntityComponent existingComponent = entity.GetComponent(componentType);
existingComponent.AddChange(change.Before);
}
}
}
void drawComponent(EntityBehaviour entityBehaviour, Entity entity, int index, IComponent component)
{
var componentType = component.GetType();
var fields = componentType.GetFields(BindingFlags.Public | BindingFlags.Instance);
EditorGUILayout.BeginVertical(GUI.skin.box);
EditorGUILayout.BeginHorizontal();
if (fields.Length == 0)
{
EditorGUILayout.LabelField(componentType.RemoveComponentSuffix(), EditorStyles.boldLabel);
}
else
{
entityBehaviour.unfoldedComponents[index] = EditorGUILayout.Foldout(entityBehaviour.unfoldedComponents[index], componentType.RemoveComponentSuffix(), _foldoutStyle);
}
if (GUILayout.Button("-", GUILayout.Width(19), GUILayout.Height(14)))
{
entity.RemoveComponent(index);
}
EditorGUILayout.EndHorizontal();
if (entityBehaviour.unfoldedComponents[index])
{
foreach (var field in fields)
{
var value = field.GetValue(component);
DrawAndSetElement(field.FieldType, field.Name, value,
entity, index, component, newValue => field.SetValue(component, newValue));
}
}
EditorGUILayout.EndVertical();
}
public void Reset(NodeAddedEvent evt, ActiveTankNode selfActiveTank, [JoinByTank] CompleteChargingWeaponControllerNode chargingWeaponNode)
{
Entity entity = chargingWeaponNode.Entity;
entity.RemoveComponent <RailgunChargingStateComponent>();
entity.AddComponent <ReadyRailgunChargingWeaponComponent>();
}
public void SwitchFromShootingToIdleWhenSelfTankInactive(NodeRemoveEvent evt, SelfActiveTankNode selfActiveTank, [JoinByTank] VulcanWeaponShootingControllerNode vulcanShooting)
{
Entity entity = vulcanShooting.Entity;
entity.RemoveComponent <WeaponStreamShootingComponent>();
entity.AddComponent <VulcanIdleComponent>();
}
private void Play(ReadySilentAmbientSoundNode soundListener, bool playWithNitro)
{
Entity entity = soundListener.Entity;
soundListener.hangarAmbientSoundController.HangarAmbientSoundController.Play(playWithNitro);
entity.RemoveComponent <HangarAmbientSoundSilenceComponent>();
}
public override void Process(Entity e)
{
Sprite sprite = e.GetComponent<Sprite>();
Animation anim = e.GetComponent<Animation>();
if (anim.Type != AnimationType.None)
{
anim._Tick++;
anim._Tick %= anim.FrameRate;
if (anim._Tick == 0) //If time to animate.
{
switch (anim.Type)
{
case AnimationType.Loop:
sprite.FrameIndex++;
break;
case AnimationType.ReverseLoop:
sprite.FrameIndex--;
break;
case AnimationType.Increment:
sprite.FrameIndex++;
anim.Type = AnimationType.None;
break;
case AnimationType.Decrement:
sprite.FrameIndex--;
anim.Type = AnimationType.None;
break;
case AnimationType.Bounce:
sprite.FrameIndex += anim.FrameInc;
if (sprite.FrameIndex == sprite.Source.Count() - 1)
anim.FrameInc = -1;
if (sprite.FrameIndex == 0)
anim.FrameInc = 1;
break;
case AnimationType.Once:
if (sprite.FrameIndex < sprite.Source.Count() - 1)
sprite.FrameIndex++;
else
anim.Type = AnimationType.None;
break;
}
e.RemoveComponent<Sprite>(e.GetComponent<Sprite>());
e.AddComponent<Sprite>(sprite);
}
}
}
public override void Process(Entity entity)
{
var position = entity.GetComponent<Position> ().position;
var target = entity.GetComponent<Target> ().Entity;
if(target == null || !target.HasComponent<Position>() || target.GetComponent<UnitState>().state == UnitState.State.dead)
{
// EntityWorld.DeleteEntity(entity);
entity.RemoveComponent<Position>();
return;
}
var targetPosition = target.GetComponent<Position> ().position;
var projectile = entity.GetComponent<Projectile> ();
if (!AIUtils.MakeStepToPosition(entity, new SlimMath.Vector2(targetPosition.X+300, targetPosition.Y+1000)))
return;
entity.RemoveComponent<Position>();
switch(projectile.AttackAction)
{
case Attack.TargetAction.block:
target.AddComponent(new Block());
AIUtils.TriggerBlock(target);
break;
case Attack.TargetAction.dodge:
target.AddComponent(new Dodge());
AIUtils.TriggerDodge(target);
break;
case Attack.TargetAction.hit:
AIUtils.TriggerHit (target, projectile.Damage);
break;
default:
break;
}
}
public override void Process(Entity entity)
{
var perkNames = entity.GetComponent<PerkTemplate> ().perks;
List<Entity> perksCollection = new List<Entity> ();
foreach(var name in perkNames)
perksCollection.Add(DBMagager.CreateEntityByTemplateName(EntityWorld, name));
perksCollection = perksCollection.OrderBy (p => p.GetComponent<Perk> ().branch).ThenBy (p => p.GetComponent<Perk> ().perkLevel).ToList();
foreach (var perkEntity in perksCollection)
{
var putOnCommand = EntityWorld.CreateEntity ();
putOnCommand.AddComponent (new Command ());
putOnCommand.AddComponent (new SetPerkCommand (entity.entityId, perkEntity.entityId));
putOnCommand.Refresh ();
}
entity.RemoveComponent<PerkTemplate>();
}
public override void Process(Entity entity)
{
var itemNames = entity.GetComponent<EquipmentTemplate>().equippedItems.Values;
foreach(var name in itemNames)
{
Debug.Log("CreateEntityByTemplateName:" + name);
var item = DBMagager.CreateEntityByTemplateName(EntityWorld, name);
Debug.Log(item.entityId);
Debug.Log(Newtonsoft.Json.JsonConvert.SerializeObject(item));
if (item != null)
{
var putOnCommand = EntityWorld.CreateEntity();
putOnCommand.AddComponent(new Command());
putOnCommand.AddComponent(new SetItemCommand(entity.entityId, item.entityId));
putOnCommand.Refresh();
}
}
entity.RemoveComponent<EquipmentTemplate>();
}
public override void Process(Entity entity)
{
var itemNames = entity.GetComponent<BagTemplates>().items;
foreach(var name in itemNames)
{
var item = DBMagager.CreateEntityByTemplateName(EntityWorld, name);
item.Refresh();
}
entity.RemoveComponent<BagTemplates>();
EntityWorld.DeleteEntity(entity);
}
public override void Process(Entity unit)
{
var target = unit.GetComponent<Target>();
var isUnitDead = AIUtils.IsDead (unit);
if (isUnitDead || AIUtils.IsDead(target.Entity) ||
!AIUtils.IsTargetInRange(unit)){
Debug.Log("Cant attack, return");
unit.RemoveComponent<Attack>();
if(!isUnitDead)
AIUtils.SetState(unit, UnitState.State.idle);
return;
}
var attack = unit.GetComponent<Attack>();
attack.timer--;
Entity projectile = null;
if (attack.timer == 0 && unit.HasComponent<Ranged>())
{
projectile = _dbManager.CreateEntityByTemplateName(entityWorld, unit.GetComponent<Ranged>().Projectile.ToString());
projectile.AddComponent<Target>(new Target(unit.GetComponent<Target>().Entity));
projectile.AddComponent<Position>(new Position(){position = new Vector2(unit.GetComponent<Position>().position.X, unit.GetComponent<Position>().position.Y)});
projectile.GetComponent<Projectile>().Damage = attack.damage;
}
switch (attack.targetAction)
{
case Attack.TargetAction.hit:
if (unit.HasComponent<Ranged>())
{
if(projectile != null)
projectile.GetComponent<Projectile>().AttackAction = Attack.TargetAction.hit;
}
else if(attack.timer == 0)
{
AIUtils.TriggerHit(target.Entity, attack.damage);
}
break;
case Attack.TargetAction.block:
if (unit.HasComponent<Ranged>())
{
if(projectile != null)
projectile.GetComponent<Projectile>().AttackAction = Attack.TargetAction.block;
}
else if (attack.timer == 8)
{
target.Entity.AddComponent(new Block());
AIUtils.TriggerBlock(target.Entity);
}
break;
case Attack.TargetAction.dodge:
if (unit.HasComponent<Ranged>())
{
if(projectile != null)
projectile.GetComponent<Projectile>().AttackAction = Attack.TargetAction.dodge;
}
else if (attack.timer == 8)
{
target.Entity.AddComponent(new Dodge());
AIUtils.TriggerDodge(target.Entity);
}
break;
case Attack.TargetAction.miss:
break;
default:
break;
}
if (attack.timer != 0)
return;
unit.RemoveComponent<Attack>();
var cd = new AttackCD(unit.GetComponent<Unit>().cooldownDuration);
unit.AddComponent(cd);
AIUtils.SetState(unit, UnitState.State.idle);
}
public static void DrawComponent(bool[] unfoldedComponents, Entity entity, int index, IComponent component)
{
var componentType = component.GetType();
var componentName = componentType.Name.RemoveComponentSuffix();
if (componentName.ToLower().Contains(_componentNameSearchTerm.ToLower())) {
var memberInfos = componentType.GetPublicMemberInfos();
var boxStyle = getColoredBoxStyle(entity.totalComponents, index);
EntitasEditorLayout.BeginVerticalBox(boxStyle);
{
EntitasEditorLayout.BeginHorizontal();
{
if (memberInfos.Length == 0) {
EditorGUILayout.LabelField(componentName, EditorStyles.boldLabel);
} else {
unfoldedComponents[index] = EditorGUILayout.Foldout(unfoldedComponents[index], componentName, _foldoutStyle);
}
if (GUILayout.Button("-", GUILayout.Width(19), GUILayout.Height(14))) {
entity.RemoveComponent(index);
}
}
EntitasEditorLayout.EndHorizontal();
if (unfoldedComponents[index]) {
foreach (var info in memberInfos) {
DrawAndSetElement(info.type, info.name, info.GetValue(component),
entity, index, component, info.SetValue);
}
}
}
EntitasEditorLayout.EndVertical();
}
}
private void AddEditorComponentsToPartEntity(Entity entity)
{
entity.AddComponent(new EditorComponent());
var select = new BoundingBoxSelectorComponent() { IsEnabled = false };
entity.AddComponent(select);
var drawbounds = new DrawBoundingBoxComponent();
drawbounds.IsEnabled = false;
entity.AddComponent(drawbounds);
select.SelectedChanged += (s, e) =>
{
drawbounds.IsEnabled = select.IsSelected;
if (!select.IsSelected)
entity.RemoveComponent<MouseControlledTransformComponent>();
};
entity.AddComponent(entity.GetComponent<IShipPartComponent>().Part.Transform);
if (entity.HasComponent<DummyPartComponent>())
{
entity.AddComponent(new GenericDrawableComponent((a, b, e) => {
var xform = e.GetComponent<Transform>();
b.DrawCircle(xform.Position, 9, 15, Color.Cyan);
b.DrawLine(xform.Position.X - 10, xform.Position.Y, xform.Position.X + 10, xform.Position.Y, Color.LightCyan);
b.DrawLine(xform.Position.X, xform.Position.Y - 10, xform.Position.X, xform.Position.Y + 10, Color.LightCyan);
}));
}
entity.Refresh();
}
public static void CommandSuccseded(Entity command)
{
if (command.HasComponent<ProcessCommand>())
{
command.RemoveComponent<ProcessCommand>();
}
command.AddComponent(new CommandComplete());
command.AddComponent(new SaveCommand());
}
void drawComponent(EntityBehaviour entityBehaviour, Entity entity, int index, IComponent component) {
var componentType = component.GetType();
var fields = componentType.GetFields(BindingFlags.Public | BindingFlags.Instance);
EditorGUILayout.BeginVertical(GUI.skin.box);
{
EditorGUILayout.BeginHorizontal();
{
if (fields.Length == 0) {
EditorGUILayout.LabelField(componentType.RemoveComponentSuffix(), EditorStyles.boldLabel);
} else {
entityBehaviour.unfoldedComponents[index] = EditorGUILayout.Foldout(entityBehaviour.unfoldedComponents[index], componentType.RemoveComponentSuffix(), _foldoutStyle);
}
if (GUILayout.Button("-", GUILayout.Width(19), GUILayout.Height(14))) {
entity.RemoveComponent(index);
}
}
EditorGUILayout.EndHorizontal();
if (entityBehaviour.unfoldedComponents[index]) {
foreach (var field in fields) {
var value = field.GetValue(component);
DrawAndSetElement(field.FieldType, field.Name, value,
entity, index, component, newValue => field.SetValue(component, newValue));
}
}
}
EditorGUILayout.EndVertical();
}
public void ChangeGun(Entity e, GunType gun)
{
if (e.GetComponent<Gun>() != null)
{
CurrentGun.Ammunition = e.GetComponent<Gun>().Ammunition;
e.RemoveComponent<Gun>(e.GetComponent<Gun>());
}
_CurrentGunType = gun;
e.AddComponent<Gun>(CurrentGun);
}
public static void DrawComponent(bool[] unfoldedComponents, Entity entity, int index, IComponent component)
{
var componentType = component.GetType();
var componentName = EntityExtension.RemoveComponentSuffix(componentType.Name);
if (componentName.ToLower().Contains(_componentNameSearchTerm.ToLower())) {
var fields = componentType.GetFields(BindingFlags.Public | BindingFlags.Instance);
var boxStyle = getColoredBoxStyle(entity.totalComponents, index);
EntitasEditorLayout.BeginVerticalBox(boxStyle);
{
EntitasEditorLayout.BeginHorizontal();
{
if (fields.Length == 0) {
EditorGUILayout.LabelField(componentName, EditorStyles.boldLabel);
} else {
unfoldedComponents[index] = EditorGUILayout.Foldout(unfoldedComponents[index], componentName, _foldoutStyle);
}
if (GUILayout.Button("-", GUILayout.Width(19), GUILayout.Height(14))) {
entity.RemoveComponent(index);
}
}
EntitasEditorLayout.EndHorizontal();
if (unfoldedComponents[index]) {
foreach (var field in fields) {
var value = field.GetValue(component);
DrawAndSetElement(field.FieldType, field.Name, value,
entity, index, component, field.SetValue);
}
}
}
EntitasEditorLayout.EndVertical();
}
}
public override void Process(Entity entity)
{
if( AIUtils.GetState(entity) != UnitState.State.hit) {
var battleField = EntityWorld.TagManager.GetEntity("BattleField");
var map = battleField.GetComponent<UnitMap>();
var unitPositionComp = entity.GetComponent<Position>();
var target = entity.GetComponent<Target>().Entity;
Vector2 targetPosition = target.GetComponent<Position>().position;
Vector2 unitPostition = unitPositionComp.position;
Vector2 targetHex = AIUtils.ToHex(targetPosition);
Vector2 unitHex = AIUtils.ToHex(unitPostition);
if(map.map.ContainsKey(unitHex) && map.map[unitHex] == entity.Id)
map.map.Remove(unitHex);
Vector2 destanationHex = GetAvailableHexForTargetHex(unitHex, targetHex);
bool hasArrived = AIUtils.MakeStepToPosition(entity, AIUtils.ToCoord(destanationHex));
if (hasArrived)
{
AIUtils.SetState(entity, UnitState.State.idle);
Vector2 currentHex = AIUtils.ToHex(unitPositionComp.position);
unitPositionComp.direction = (unitHex.X < targetHex.X)?1:-1;
map.map[currentHex] = entity.Id;
entity.RemoveComponent<MoveToTarget>();
}
}
}
public void FreeMovementAndSprite(Entity slave)
{
var toRemoveSlaveMover = slave.GetComponent<SlaveMoverComponent>(ComponentFamily.Mover);
if (toRemoveSlaveMover != null)
{
toRemoveSlaveMover.Detach();
}
if (slave.HasComponent(ComponentFamily.Renderable))
{
slave.GetComponent<IRenderableComponent>(ComponentFamily.Renderable).UnsetMaster();
}
slave.RemoveComponent(ComponentFamily.Mover);
slave.AddComponent(ComponentFamily.Mover, EntityManager.ComponentFactory.GetComponent<BasicMoverComponent>());
slave.GetComponent<BasicItemComponent>(ComponentFamily.Item).HandleDropped();
}
public void EnslaveMovementAndSprite(Entity master, Entity slave)
{
slave.RemoveComponent(ComponentFamily.Mover);
slave.AddComponent(ComponentFamily.Mover, EntityManager.ComponentFactory.GetComponent<SlaveMoverComponent>());
slave.GetComponent<SlaveMoverComponent>(ComponentFamily.Mover).Attach(master);
if (slave.HasComponent(ComponentFamily.Renderable) && master.HasComponent(ComponentFamily.Renderable))
{
slave.GetComponent<IRenderableComponent>(ComponentFamily.Renderable).SetMaster(master);
}
}
public static void DrawComponent(bool[] unfoldedComponents, Entity entity, int index, IComponent component)
{
var componentType = component.GetType();
var componentName = componentType.Name.RemoveComponentSuffix();
if (componentName.ToLower().Contains(_componentNameSearchTerm.ToLower())) {
var boxStyle = getColoredBoxStyle(entity.totalComponents, index);
EntitasEditorLayout.BeginVerticalBox(boxStyle);
{
var memberInfos = componentType.GetPublicMemberInfos();
EntitasEditorLayout.BeginHorizontal();
{
if (memberInfos.Count == 0) {
EditorGUILayout.LabelField(componentName, EditorStyles.boldLabel);
} else {
unfoldedComponents[index] = EditorGUILayout.Foldout(unfoldedComponents[index], componentName, _foldoutStyle);
}
if (GUILayout.Button("-", GUILayout.Width(19), GUILayout.Height(14))) {
entity.RemoveComponent(index);
}
}
EntitasEditorLayout.EndHorizontal();
if (unfoldedComponents[index]) {
var componentDrawer = getComponentDrawer(componentType);
if (componentDrawer != null) {
var newComponent = entity.CreateComponent(index, componentType);
component.CopyPublicMemberValues(newComponent);
EditorGUI.BeginChangeCheck();
{
componentDrawer.DrawComponent(newComponent);
}
var changed = EditorGUI.EndChangeCheck();
if (changed) {
entity.ReplaceComponent(index, newComponent);
} else {
entity.GetComponentPool(index).Push(newComponent);
}
} else {
foreach (var info in memberInfos) {
DrawAndSetElement(info.type, info.name, info.GetValue(component),
entity, index, component, info.SetValue);
}
}
}
}
EntitasEditorLayout.EndVertical();
}
}
public override void Process(Entity entity)
{
var hit = entity.GetComponent<Hit>();
if (AIUtils.IsDead(entity))
{
entity.RemoveComponent<Hit>();
return;
}
hit.timer--;
if(hit.timer <= 0)
{
AIUtils.SetState(entity, UnitState.State.idle);
entity.RemoveComponent<Hit>();
}
}
public override void Process(Entity e)
{
AI ai = e.GetComponent<AI>();
switch (ai.Targeting)
{
case Targeting.Closest:
ai.Target = ClosestTarget(e);
break;
case Targeting.Strongest:
ai.Target = StrongestEntity(world.GetBodiesInArea(e.GetComponent<ITransform>().Position, ai.SearchRadius)).GetComponent<Body>();
break;
case Targeting.Weakest:
ai.Target = WeakestEntity(world.GetBodiesInArea(e.GetComponent<ITransform>().Position, ai.SearchRadius)).GetComponent<Body>();
break;
}
if (e.Group == "Crystals")
{
if ((ai.Target.UserData as Entity).DeletingState != true)
{
Vector2 distance = e.GetComponent<AI>().Target.Position - e.GetComponent<Body>().Position;
distance.Normalize();
e.GetComponent<Body>().LinearVelocity = distance * new Vector2(7);
}
else
{
e.Delete();
//ai.Target = ClosestTarget(e);
}
}
e.RemoveComponent<AI>(e.GetComponent<AI>());
e.AddComponent<AI>(ai);
}
public override void Process(Entity entity)
{
var cd = entity.GetComponent<AttackCD>();
cd.cooldown--;
if (cd.cooldown <= 0)
{
entity.RemoveComponent<AttackCD>();
}
}
