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(); }