public static IDamageableComponent GetDamageableChecked(this IMyGameObject obj)
{
IDamageableComponent damageable = obj.GetDamageable();
Contract.Assert(damageable != null, $"Using {nameof(GetDamageableChecked)} requires that damageable is included");
return(damageable);
}
public void RejuvenateDeadTest()
{
var server = StartServerDummyTicker();
IEntity human = null;
IDamageableComponent damageable = null;
server.Assert(() =>
{
var mapManager = IoCManager.Resolve <IMapManager>();
mapManager.CreateNewMapEntity(MapId.Nullspace);
var entityManager = IoCManager.Resolve <IEntityManager>();
human = entityManager.SpawnEntity("HumanMob_Content", MapCoordinates.Nullspace);
// Sanity check
Assert.True(human.TryGetComponent(out damageable));
Assert.That(damageable.CurrentState, Is.EqualTo(DamageState.Alive));
// Kill the entity
damageable.ChangeDamage(DamageClass.Brute, 10000000, true);
// Check that it is dead
Assert.That(damageable.CurrentState, Is.EqualTo(DamageState.Dead));
// Rejuvenate them
RejuvenateVerb.PerformRejuvenate(human);
// Check that it is alive and with no damage
Assert.That(damageable.CurrentState, Is.EqualTo(DamageState.Alive));
Assert.That(damageable.TotalDamage, Is.Zero);
});
}
public static void SetMaxHitCount(this IDamageableComponent damageable, int newMaxHitCount)
{
DamageState damageState = damageable.GetDamageState();
damageState.MaxHits = newMaxHitCount;
damageable.SetDamageState(damageState);
}
public Character(string name) : base(name)
{
_physicsComponent = new PhysicsComponent(this);
_damageComponent = new DamageableComponent(this);
_stateComponent = new StateComponent <ChararacterState>(ChararacterState.Idle);
DrawableComponent = new DrawableComponent(this);
}
public bool Reached(IDamageableComponent damageable, DestructibleSystem system)
{
if (Type == null)
{
return(false);
}
return(damageable.TryGetDamage(Type.Value, out var damageReceived) &&
damageReceived >= Damage);
}
public DamageChangedEventArgs(IDamageableComponent damageable, DamageType type, int newValue, int delta)
{
Damageable = damageable;
var datum = new DamageChangeData(type, newValue, delta);
var data = new List <DamageChangeData> {
datum
};
Data = data;
}
public async Task TestDamageTypeDamageAndHeal()
{
var server = StartServerDummyTicker(new ServerContentIntegrationOption
{
ExtraPrototypes = Prototypes
});
await server.WaitIdleAsync();
var sEntityManager = server.ResolveDependency <IEntityManager>();
var sMapManager = server.ResolveDependency <IMapManager>();
IEntity sDamageableEntity = null;
IDamageableComponent sDamageableComponent = null;
await server.WaitPost(() =>
{
var mapId = sMapManager.NextMapId();
var coordinates = new MapCoordinates(0, 0, mapId);
sMapManager.CreateMap(mapId);
sDamageableEntity = sEntityManager.SpawnEntity(DamageableEntityId, coordinates);
sDamageableComponent = sDamageableEntity.GetComponent <IDamageableComponent>();
});
await server.WaitRunTicks(5);
await server.WaitAssertion(() =>
{
Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(0));
var damageToDeal = 7;
foreach (var type in Enum.GetValues <DamageType>())
{
Assert.That(sDamageableComponent.SupportsDamageType(type));
// Damage
Assert.That(sDamageableComponent.ChangeDamage(type, damageToDeal, true), Is.True);
Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(damageToDeal));
Assert.That(sDamageableComponent.TryGetDamage(type, out var damage), Is.True);
Assert.That(damage, Is.EqualTo(damageToDeal));
// Heal
Assert.That(sDamageableComponent.ChangeDamage(type, -damageToDeal, true), Is.True);
Assert.That(sDamageableComponent.TotalDamage, Is.Zero);
Assert.That(sDamageableComponent.TryGetDamage(type, out damage), Is.True);
Assert.That(damage, Is.Zero);
}
});
}
public static int MakeDamageIfDamageableGameObject(GameObject gameObject, Damage damage, LogMode logMode = LogMode.Enable)
{
// if failed to find the main script, try to find the damageable component directly
// (some objects may contain NO main script, but do contain the damageable component)
IDamageableComponent damageable = gameObject.GetComponent <IDamageableComponent>();
if (damageable != null)
{
return(damageable.MakeDamage(damage));
}
else
{
LogUtils.LogWarningIf(logMode, "{gameObject.name} does NOT contain damageable component");
}
return(0);
}
public async Task TestDamageableComponents()
{
var server = StartServerDummyTicker(new ServerContentIntegrationOption
{
ExtraPrototypes = Prototypes
});
await server.WaitIdleAsync();
var sEntityManager = server.ResolveDependency <IEntityManager>();
var sMapManager = server.ResolveDependency <IMapManager>();
var sPrototypeManager = server.ResolveDependency <IPrototypeManager>();
IEntity sDamageableEntity;
IDamageableComponent sDamageableComponent = null;
DamageGroupPrototype group1 = default !;
public async Task TotalDamageTest()
{
var server = StartServerDummyTicker(new ServerContentIntegrationOption
{
ExtraPrototypes = Prototypes
});
await server.WaitIdleAsync();
var sEntityManager = server.ResolveDependency <IEntityManager>();
var sMapManager = server.ResolveDependency <IMapManager>();
IEntity sDamageableEntity;
IDamageableComponent sDamageableComponent = null;
await server.WaitPost(() =>
{
var mapId = sMapManager.NextMapId();
var coordinates = new MapCoordinates(0, 0, mapId);
sMapManager.CreateMap(mapId);
sDamageableEntity = sEntityManager.SpawnEntity(DamageableEntityId, coordinates);
sDamageableComponent = sDamageableEntity.GetComponent <IDamageableComponent>();
});
await server.WaitAssertion(() =>
{
var damageType = DamageClass.Brute;
var damage = 10;
Assert.True(sDamageableComponent.ChangeDamage(DamageClass.Brute, damage, true));
Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(10));
var totalTypeDamage = 0;
foreach (var type in damageType.ToTypes())
{
Assert.True(sDamageableComponent.TryGetDamage(type, out var typeDamage));
Assert.That(typeDamage, Is.LessThanOrEqualTo(damage));
totalTypeDamage += typeDamage;
}
Assert.That(totalTypeDamage, Is.EqualTo(damage));
});
}
private void DealDamage(ISuicideAct suicide, IChatManager chat, IDamageableComponent damageableComponent, IEntity source, IEntity target)
{
SuicideKind kind = suicide.Suicide(target, chat);
if (kind != SuicideKind.Special)
{
damageableComponent.ChangeDamage(kind switch
{
SuicideKind.Blunt => DamageType.Blunt,
SuicideKind.Piercing => DamageType.Piercing,
SuicideKind.Heat => DamageType.Heat,
SuicideKind.Disintegration => DamageType.Disintegration,
SuicideKind.Cellular => DamageType.Cellular,
SuicideKind.DNA => DamageType.DNA,
SuicideKind.Asphyxiation => DamageType.Asphyxiation,
_ => DamageType.Blunt
},
private void DealDamage(ISuicideAct suicide, IChatManager chat, IDamageableComponent damageableComponent, IEntity source, IEntity target)
{
var kind = suicide.Suicide(target, chat);
if (kind != SuicideKind.Special)
{
damageableComponent.SetDamage(kind switch
{
SuicideKind.Blunt => DamageType.Blunt,
SuicideKind.Slash => DamageType.Slash,
SuicideKind.Piercing => DamageType.Piercing,
SuicideKind.Heat => DamageType.Heat,
SuicideKind.Shock => DamageType.Shock,
SuicideKind.Cold => DamageType.Cold,
SuicideKind.Poison => DamageType.Poison,
SuicideKind.Radiation => DamageType.Radiation,
SuicideKind.Asphyxiation => DamageType.Asphyxiation,
SuicideKind.Bloodloss => DamageType.Bloodloss,
_ => DamageType.Blunt
},
private void DealDamage(ISuicideAct suicide, IChatManager chat, IDamageableComponent damageableComponent, IEntity source, IEntity target)
{
var kind = suicide.Suicide(target, chat);
if (kind != SuicideKind.Special)
{
var prototypeManager = IoCManager.Resolve <IPrototypeManager>();
damageableComponent.TrySetDamage(kind switch
{
SuicideKind.Blunt => prototypeManager.Index <DamageTypePrototype>("Blunt"),
SuicideKind.Slash => prototypeManager.Index <DamageTypePrototype>("Slash"),
SuicideKind.Piercing => prototypeManager.Index <DamageTypePrototype>("Piercing"),
SuicideKind.Heat => prototypeManager.Index <DamageTypePrototype>("Heat"),
SuicideKind.Shock => prototypeManager.Index <DamageTypePrototype>("Shock"),
SuicideKind.Cold => prototypeManager.Index <DamageTypePrototype>("Cold"),
SuicideKind.Poison => prototypeManager.Index <DamageTypePrototype>("Poison"),
SuicideKind.Radiation => prototypeManager.Index <DamageTypePrototype>("Radiation"),
SuicideKind.Asphyxiation => prototypeManager.Index <DamageTypePrototype>("Asphyxiation"),
SuicideKind.Bloodloss => prototypeManager.Index <DamageTypePrototype>("Bloodloss"),
_ => prototypeManager.Index <DamageTypePrototype>("Blunt")
},
void Awake()
{
Damageable = GetComponent <IDamageableComponent>();
}
public DamageChangedEventArgs(IDamageableComponent damageable, IReadOnlyList <DamageChangeData> data)
{
Damageable = damageable;
Data = data;
}
public static int GetMaxHits(this IDamageableComponent damageable) => damageable.GetDamageState().MaxHits;
public bool Reached(IDamageableComponent damageable, DestructibleSystem system)
{
return(damageable.TotalDamage >= Damage);
}
public AmmoBayViewModel(CommandBindingCollection commandBindings, IDamageableComponent ammoBay, TurretViewModel owner)
: base(commandBindings, ammoBay)
{
this.Owner = owner;
this.CreateDataGroup(owner.Owner);
}
public static bool AreHitsMaximum(this IDamageableComponent damageable) => damageable.HitCount == damageable.MaxHitCount;
public static bool AreHitsOver(this IDamageableComponent damageable) => damageable.HitCount > damageable.MaxHitCount;
public TurretRotatorViewModel(CommandBindingCollection commandBindings, IDamageableComponent turretRotator, TurretViewModel owner)
: base(commandBindings, turretRotator)
{
this.CreateDataGroup(owner.Owner);
}
public HealthChangedEventArgs(IDamageableComponent damageable, List <HealthChangeData> data)
{
Damageable = damageable;
Data = data;
}
public DamagableComponentViewModel(CommandBindingCollection commandBindings, IDamageableComponent component)
{
this.Health = new HealthViewModel(component.MaxHealth, component.MaxRegenHealth);
this.CommandBindings = commandBindings;
this.Component = component;
}
public static int MakeDamage(this IDamageableComponent damageable, Damage damage)
{
return(damageable.SetHitCount(damageable.HitCount - damage.Amount));
}
public async Task TestAllSupportDamageableComponent()
{
var server = StartServerDummyTicker();
await server.WaitIdleAsync();
var sEntityManager = server.ResolveDependency <IEntityManager>();
var sMapManager = server.ResolveDependency <IMapManager>();
var sPrototypeManager = server.ResolveDependency <IPrototypeManager>();
IEntity sFullyDamageableEntity;
IDamageableComponent sFullyDamageableComponent = null;
await server.WaitPost(() =>
{
var mapId = sMapManager.NextMapId();
var coordinates = new MapCoordinates(0, 0, mapId);
sMapManager.CreateMap(mapId);
// When prototypes are loaded using the ExtraPrototypes option, they seem to be loaded first?
// Or at least, no damage prototypes were loaded in by the time that the damageContainer here is loaded.
// So for now doing explicit loading of prototypes.
// I have no idea what I am doing, but it works.
sPrototypeManager.LoadString($@"
# we want to test the all damage container
- type: damageContainer
id: testAllDamageContainer
supportAll: true
# create entities
- type: entity
id: {AllDamageDamageableEntityId}
name: {AllDamageDamageableEntityId}
components:
- type: Damageable
damageContainer: testAllDamageContainer
");
sFullyDamageableEntity = sEntityManager.SpawnEntity(AllDamageDamageableEntityId, coordinates);
sFullyDamageableComponent = sFullyDamageableEntity.GetComponent <IDamageableComponent>();
});
await server.WaitRunTicks(5);
await server.WaitAssertion(() =>
{
// First check that there actually are any damage types/groups
// This test depends on a non-empty damage.yml
Assert.That(sPrototypeManager.EnumeratePrototypes <DamageTypePrototype>().ToList().Count, Is.GreaterThan(0));
Assert.That(sPrototypeManager.EnumeratePrototypes <DamageGroupPrototype>().ToList().Count, Is.GreaterThan(0));
// Can we set and get all damage.
Assert.That(sFullyDamageableComponent.TrySetAllDamage(-10), Is.False);
Assert.That(sFullyDamageableComponent.TrySetAllDamage(0), Is.True);
// Test that the all damage container supports every damage type, and that we can get, set, and change
// every type with the expected results. Notable: if the damage does not change, they all return false
var initialDamage = 10;
foreach (var damageType in sPrototypeManager.EnumeratePrototypes <DamageTypePrototype>())
{
var damage = initialDamage;
Assert.That(sFullyDamageableComponent.IsSupportedDamageType(damageType));
Assert.That(sFullyDamageableComponent.TrySetDamage(damageType, -damage), Is.False);
Assert.That(sFullyDamageableComponent.TrySetDamage(damageType, damage), Is.True);
Assert.That(sFullyDamageableComponent.TrySetDamage(damageType, damage), Is.True); // intentional duplicate
Assert.That(sFullyDamageableComponent.GetDamage(damageType), Is.EqualTo(damage));
Assert.That(sFullyDamageableComponent.TryChangeDamage(damageType, -damage / 2, true), Is.True);
Assert.That(sFullyDamageableComponent.TryGetDamage(damageType, out damage), Is.True);
Assert.That(damage, Is.EqualTo(initialDamage / 2));
Assert.That(sFullyDamageableComponent.TryChangeDamage(damageType, damage, true), Is.True);
Assert.That(sFullyDamageableComponent.GetDamage(damageType), Is.EqualTo(2 * damage));
Assert.That(sFullyDamageableComponent.TryChangeDamage(damageType, 0, true), Is.False);
}
// And again, for every group
foreach (var damageGroup in sPrototypeManager.EnumeratePrototypes <DamageGroupPrototype>())
{
var damage = initialDamage;
var groupSize = damageGroup.DamageTypes.Count();
Assert.That(sFullyDamageableComponent.IsFullySupportedDamageGroup(damageGroup));
Assert.That(sFullyDamageableComponent.IsApplicableDamageGroup(damageGroup));
Assert.That(sFullyDamageableComponent.TrySetDamage(damageGroup, -damage), Is.False);
Assert.That(sFullyDamageableComponent.TrySetDamage(damageGroup, damage), Is.True);
Assert.That(sFullyDamageableComponent.TrySetDamage(damageGroup, damage), Is.True); // intentional duplicate
Assert.That(sFullyDamageableComponent.GetDamage(damageGroup), Is.EqualTo(damage *groupSize));
Assert.That(sFullyDamageableComponent.TryChangeDamage(damageGroup, -groupSize *damage / 2, true), Is.True);
Assert.That(sFullyDamageableComponent.TryGetDamage(damageGroup, out damage), Is.True);
Assert.That(damage, Is.EqualTo(groupSize *initialDamage / 2));
Assert.That(sFullyDamageableComponent.TryChangeDamage(damageGroup, damage, true), Is.True);
Assert.That(sFullyDamageableComponent.GetDamage(damageGroup), Is.EqualTo(2 * damage));
Assert.That(sFullyDamageableComponent.TryChangeDamage(damageGroup, 0, true), Is.False);
}
});
}
// Checks whether the given hit count is at zero or below zero public static bool IsTotallyDamaged(this IDamageableComponent damageable) => damageable.HitCount <= 0;
public async Task AndTest()
{
var server = StartServerDummyTicker(new ServerContentIntegrationOption
{
ExtraPrototypes = Prototypes,
ContentBeforeIoC = () =>
{
IoCManager.Resolve <IComponentFactory>().Register <TestThresholdListenerComponent>();
}
});
await server.WaitIdleAsync();
var sEntityManager = server.ResolveDependency <IEntityManager>();
var sMapManager = server.ResolveDependency <IMapManager>();
IEntity sDestructibleEntity;
IDamageableComponent sDamageableComponent = null;
TestThresholdListenerComponent sThresholdListenerComponent = null;
await server.WaitPost(() =>
{
var mapId = new MapId(1);
var coordinates = new MapCoordinates(0, 0, mapId);
sMapManager.CreateMap(mapId);
sDestructibleEntity = sEntityManager.SpawnEntity(DestructibleDamageClassEntityId, coordinates);
sDamageableComponent = sDestructibleEntity.GetComponent <IDamageableComponent>();
sThresholdListenerComponent = sDestructibleEntity.GetComponent <TestThresholdListenerComponent>();
});
await server.WaitRunTicks(5);
await server.WaitAssertion(() =>
{
Assert.IsEmpty(sThresholdListenerComponent.ThresholdsReached);
});
await server.WaitAssertion(() =>
{
// Raise brute damage to 5
Assert.True(sDamageableComponent.ChangeDamage(DamageClass.Brute, 5, true));
// No thresholds reached yet, the earliest one is at 10 damage
Assert.IsEmpty(sThresholdListenerComponent.ThresholdsReached);
// Raise brute damage to 10
Assert.True(sDamageableComponent.ChangeDamage(DamageClass.Brute, 5, true));
// No threshold reached, burn needs to be 10 as well
Assert.IsEmpty(sThresholdListenerComponent.ThresholdsReached);
// Raise burn damage to 10
Assert.True(sDamageableComponent.ChangeDamage(DamageClass.Burn, 10, true));
// One threshold reached, brute 10 + burn 10
Assert.That(sThresholdListenerComponent.ThresholdsReached.Count, Is.EqualTo(1));
// Threshold brute 10 + burn 10
var msg = sThresholdListenerComponent.ThresholdsReached[0];
var threshold = msg.Threshold;
// Check that it matches the YAML prototype
Assert.That(threshold.Behaviors, Is.Empty);
Assert.NotNull(threshold.Trigger);
Assert.That(threshold.Triggered, Is.True);
Assert.IsInstanceOf <AndTrigger>(threshold.Trigger);
var trigger = (AndTrigger)threshold.Trigger;
Assert.IsInstanceOf <DamageClassTrigger>(trigger.Triggers[0]);
Assert.IsInstanceOf <DamageClassTrigger>(trigger.Triggers[1]);
sThresholdListenerComponent.ThresholdsReached.Clear();
// Raise brute damage to 20
Assert.True(sDamageableComponent.ChangeDamage(DamageClass.Brute, 10, true));
// No new thresholds reached
Assert.IsEmpty(sThresholdListenerComponent.ThresholdsReached);
// Raise burn damage to 20
Assert.True(sDamageableComponent.ChangeDamage(DamageClass.Burn, 10, true));
// No new thresholds reached
Assert.IsEmpty(sThresholdListenerComponent.ThresholdsReached);
// Lower brute damage to 0
Assert.True(sDamageableComponent.ChangeDamage(DamageClass.Brute, -20, true));
// No new thresholds reached, healing should not trigger it
Assert.IsEmpty(sThresholdListenerComponent.ThresholdsReached);
// Raise brute damage back up to 10
Assert.True(sDamageableComponent.ChangeDamage(DamageClass.Brute, 10, true));
// 10 brute + 10 burn threshold reached, brute was healed and brought back to its threshold amount and slash stayed the same
Assert.That(sThresholdListenerComponent.ThresholdsReached.Count, Is.EqualTo(1));
sThresholdListenerComponent.ThresholdsReached.Clear();
// Heal both classes of damage to 0
Assert.True(sDamageableComponent.ChangeDamage(DamageClass.Brute, -10, true));
Assert.True(sDamageableComponent.ChangeDamage(DamageClass.Burn, -20, true));
// No new thresholds reached, healing should not trigger it
Assert.IsEmpty(sThresholdListenerComponent.ThresholdsReached);
// Raise brute damage to 10
Assert.True(sDamageableComponent.ChangeDamage(DamageClass.Brute, 10, true));
// No new thresholds reached
Assert.IsEmpty(sThresholdListenerComponent.ThresholdsReached);
// Raise burn damage to 10
Assert.True(sDamageableComponent.ChangeDamage(DamageClass.Burn, 10, true));
// Both classes of damage were healed and then raised again, the threshold should have been reached as triggers once is default false
Assert.That(sThresholdListenerComponent.ThresholdsReached.Count, Is.EqualTo(1));
// Threshold brute 10 + burn 10
msg = sThresholdListenerComponent.ThresholdsReached[0];
threshold = msg.Threshold;
// Check that it matches the YAML prototype
Assert.That(threshold.Behaviors, Is.Empty);
Assert.NotNull(threshold.Trigger);
Assert.That(threshold.Triggered, Is.True);
Assert.IsInstanceOf <AndTrigger>(threshold.Trigger);
trigger = (AndTrigger)threshold.Trigger;
Assert.IsInstanceOf <DamageClassTrigger>(trigger.Triggers[0]);
Assert.IsInstanceOf <DamageClassTrigger>(trigger.Triggers[1]);
sThresholdListenerComponent.ThresholdsReached.Clear();
// Change triggers once to true
threshold.TriggersOnce = true;
// Heal brute and burn back to 0
Assert.True(sDamageableComponent.ChangeDamage(DamageClass.Brute, -10, true));
Assert.True(sDamageableComponent.ChangeDamage(DamageClass.Burn, -10, true));
// No new thresholds reached from healing
Assert.IsEmpty(sThresholdListenerComponent.ThresholdsReached);
// Raise brute damage to 10
Assert.True(sDamageableComponent.ChangeDamage(DamageClass.Brute, 10, true));
// No new thresholds reached
Assert.IsEmpty(sThresholdListenerComponent.ThresholdsReached);
// Raise burn damage to 10
Assert.True(sDamageableComponent.ChangeDamage(DamageClass.Burn, 10, true));
// No new thresholds reached as triggers once is set to true and it already triggered before
Assert.IsEmpty(sThresholdListenerComponent.ThresholdsReached);
});
}
public DamageableComponent(IDamageableComponent parent)
{
_parent = parent;
}
public async Task Test()
{
var server = StartServerDummyTicker(new ServerContentIntegrationOption
{
ExtraPrototypes = Prototypes,
ContentBeforeIoC = () =>
{
IoCManager.Resolve <IComponentFactory>().Register <TestThresholdListenerComponent>();
}
});
await server.WaitIdleAsync();
var sEntityManager = server.ResolveDependency <IEntityManager>();
var sMapManager = server.ResolveDependency <IMapManager>();
IEntity sDestructibleEntity = null;
IDamageableComponent sDamageableComponent = null;
TestThresholdListenerComponent sThresholdListenerComponent = null;
await server.WaitPost(() =>
{
var mapId = new MapId(1);
var coordinates = new MapCoordinates(0, 0, mapId);
sMapManager.CreateMap(mapId);
sDestructibleEntity = sEntityManager.SpawnEntity(DestructibleDestructionEntityId, coordinates);
sDamageableComponent = sDestructibleEntity.GetComponent <IDamageableComponent>();
sThresholdListenerComponent = sDestructibleEntity.GetComponent <TestThresholdListenerComponent>();
});
await server.WaitAssertion(() =>
{
var coordinates = sDestructibleEntity.Transform.Coordinates;
Assert.DoesNotThrow(() =>
{
Assert.True(sDamageableComponent.ChangeDamage(DamageClass.Brute, 50, true));
});
Assert.That(sThresholdListenerComponent.ThresholdsReached.Count, Is.EqualTo(1));
var threshold = sThresholdListenerComponent.ThresholdsReached[0].Threshold;
Assert.That(threshold.Triggered, Is.True);
Assert.That(threshold.Behaviors.Count, Is.EqualTo(3));
var spawnEntitiesBehavior = (SpawnEntitiesBehavior)threshold.Behaviors.Single(b => b is SpawnEntitiesBehavior);
Assert.That(spawnEntitiesBehavior.Spawn.Count, Is.EqualTo(1));
Assert.That(spawnEntitiesBehavior.Spawn.Keys.Single(), Is.EqualTo(SpawnedEntityId));
Assert.That(spawnEntitiesBehavior.Spawn.Values.Single(), Is.EqualTo(new MinMax {
Min = 1, Max = 1
}));
var entitiesInRange = sEntityManager.GetEntitiesInRange(coordinates, 2);
var found = false;
foreach (var entity in entitiesInRange)
{
if (entity.Prototype == null)
{
continue;
}
if (entity.Prototype.Name != SpawnedEntityId)
{
continue;
}
found = true;
break;
}
Assert.That(found, Is.True);
});
}
public async Task BuckledDyingDropItemsTest()
{
var server = StartServer();
IEntity human = null;
IEntity chair = null;
BuckleComponent buckle = null;
StrapComponent strap = null;
HandsComponent hands = null;
IDamageableComponent humanDamageable = null;
server.Assert(() =>
{
var mapManager = IoCManager.Resolve <IMapManager>();
var mapId = new MapId(1);
mapManager.CreateNewMapEntity(mapId);
var entityManager = IoCManager.Resolve <IEntityManager>();
var gridId = new GridId(1);
var grid = mapManager.CreateGrid(mapId, gridId);
var coordinates = new GridCoordinates((0, 0), gridId);
var tileManager = IoCManager.Resolve <ITileDefinitionManager>();
var tileId = tileManager["underplating"].TileId;
var tile = new Tile(tileId);
grid.SetTile(coordinates, tile);
human = entityManager.SpawnEntity("HumanMob_Content", coordinates);
chair = entityManager.SpawnEntity("ChairWood", coordinates);
// Component sanity check
Assert.True(human.TryGetComponent(out buckle));
Assert.True(chair.TryGetComponent(out strap));
Assert.True(human.TryGetComponent(out hands));
Assert.True(human.TryGetComponent(out humanDamageable));
// Buckle
Assert.True(buckle.TryBuckle(human, chair));
Assert.NotNull(buckle.BuckledTo);
Assert.True(buckle.Buckled);
// Put an item into every hand
for (var i = 0; i < hands.Count; i++)
{
var akms = entityManager.SpawnEntity("RifleAk", coordinates);
// Equip items
Assert.True(akms.TryGetComponent(out ItemComponent item));
Assert.True(hands.PutInHand(item));
}
});
server.RunTicks(10);
server.Assert(() =>
{
// Still buckled
Assert.True(buckle.Buckled);
// With items in all hands
foreach (var slot in hands.Hands)
{
Assert.NotNull(hands.GetItem(slot));
}
// Banish our guy into the shadow realm
humanDamageable.ChangeDamage(DamageClass.Brute, 1000000, true);
});
server.RunTicks(10);
server.Assert(() =>
{
// Still buckled
Assert.True(buckle.Buckled);
// Now with no item in any hand
foreach (var slot in hands.Hands)
{
Assert.Null(hands.GetItem(slot));
}
});
await server.WaitIdleAsync();
}
