Cinka/OldThink
1
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity

Explosions and Grenades, Triggers, OnDestroy, OnExAct, Fueltanks and destructible tables (#247)

Browse Source 
* initial explosiveComponent

* remove garbagee

* assets

* tile mass deletion baby

* grenades

* tweaks

* Update Content.Server/GameObjects/Components/Explosion/ExplosiveComponent.cs

Co-Authored-By: Pieter-Jan Briers <pieterjan.briers@gmail.com>

* Ex_act based on damage, fixes and tweaks

* One finishing touch

Done the most cringe way

* ex_act explosions, tables are destructible now

also adds fuel tanks

* adds ex_act to mobs
This commit is contained in:
Injazz
2019-06-07 16:15:20 +05:00
committed by Pieter-Jan Briers
parent f1aeaaa640
commit 10801af2f7
42 changed files with 756 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Content.Server/GameObjects/Components/Damage/DamageThreshold.cs
View File

@@ -50,11 +50,13 @@ namespace Content.Server.GameObjects
{
public DamageThreshold DamageThreshold { get; }
public bool Passed { get; }
public int ExcessDamage { get; }
public DamageThresholdPassedEventArgs(DamageThreshold threshold, bool passed)
public DamageThresholdPassedEventArgs(DamageThreshold threshold, bool passed, int excess)
{
DamageThreshold = threshold;
Passed = passed;
ExcessDamage = excess;
}
}
}

8
Content.Server/GameObjects/Components/Damage/DamageableComponent.cs
View File

@@ -123,7 +123,13 @@ namespace Content.Server.GameObjects
var value = threshold.Value;
if (((value * changeSign) > (oldValue * changeSign)) && ((value * changeSign) <= (_currentDamage[damageType] * changeSign)))
{
var args = new DamageThresholdPassedEventArgs(threshold, (changeSign > 0));
var excessDamage = change - value;
var typeOfDamage = damageType;
if (change - value < 0)
{
excessDamage = 0;
}
var args = new DamageThresholdPassedEventArgs(threshold, (changeSign > 0), excessDamage);
DamageThresholdPassed?.Invoke(this, args);
}
}

65
Content.Server/GameObjects/Components/Damage/DestructibleComponent.cs
View File

@@ -1,21 +1,27 @@
using System;
using System.Collections.Generic;
using Robust.Shared.GameObjects;
using Robust.Shared.Log;
using Robust.Shared.Utility;
using YamlDotNet.RepresentationModel;
using Content.Server.Interfaces;
using Content.Shared.GameObjects;
using Robust.Shared.Serialization;
using Robust.Shared.ViewVariables;
using Robust.Shared.Interfaces.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Log;
using Robust.Shared.Maths;
using Content.Server.Interfaces;
using Content.Server.GameObjects.EntitySystems;
using Content.Shared.GameObjects;
namespace Content.Server.GameObjects.Components.Destructible
{
/// <summary>
/// Deletes the entity once a certain damage threshold has been reached.
/// </summary>
public class DestructibleComponent : Component, IOnDamageBehavior
public class DestructibleComponent : Component, IOnDamageBehavior, IDestroyAct, IExAct
{
#pragma warning disable 649
[Dependency] private readonly IEntitySystemManager _entitySystemManager;
#pragma warning restore 649
/// <inheritdoc />
public override string Name => "Destructible";
@@ -28,16 +34,24 @@ namespace Content.Server.GameObjects.Components.Destructible
public DamageType damageType = DamageType.Total;
public int damageValue = 0;
public string spawnOnDestroy = "SteelSheet";
public string spawnOnDestroy = "";
public bool destroyed = false;
ActSystem _actSystem;
public override void ExposeData(ObjectSerializer serializer)
{
base.ExposeData(serializer);
serializer.DataField(ref damageValue, "thresholdvalue", 100);
serializer.DataField(ref damageType, "thresholdtype", DamageType.Total);
serializer.DataField(ref spawnOnDestroy, "spawnondestroy", "SteelSheet");
serializer.DataField(ref spawnOnDestroy, "spawnondestroy", "");
}
public override void Initialize()
{
base.Initialize();
_actSystem = _entitySystemManager.GetEntitySystem<ActSystem>();
}
/// <inheritdoc />
@@ -49,13 +63,40 @@ namespace Content.Server.GameObjects.Components.Destructible
/// <inheritdoc />
void IOnDamageBehavior.OnDamageThresholdPassed(object obj, DamageThresholdPassedEventArgs e)
{
{
if (e.Passed && e.DamageThreshold == Threshold && destroyed == false)
{
destroyed = true;
var wreck = Owner.EntityManager.SpawnEntity(spawnOnDestroy);
wreck.Transform.GridPosition = Owner.Transform.GridPosition;
Owner.EntityManager.DeleteEntity(Owner);
_actSystem.HandleDestruction(Owner, true);
}
}
void IExAct.OnExplosion(ExplosionEventArgs eventArgs)
{
var prob = new Random();
switch (eventArgs.Severity)
{
case ExplosionSeverity.Destruction:
_actSystem.HandleDestruction(Owner, false);
break;
case ExplosionSeverity.Heavy:
_actSystem.HandleDestruction(Owner, true);
break;
case ExplosionSeverity.Light:
if (RandomExtensions.Prob(prob, 40))
_actSystem.HandleDestruction(Owner, true);
break;
}
}
void IDestroyAct.OnDestroy(DestructionEventArgs eventArgs)
{
if (!string.IsNullOrWhiteSpace(spawnOnDestroy) && eventArgs.IsSpawnWreck)
{
Owner.EntityManager.TrySpawnEntityAt(spawnOnDestroy, Owner.Transform.GridPosition, out var wreck);
}
}
}

147
Content.Server/GameObjects/Components/Explosion/ExplosiveComponent.cs Normal file
View File

@@ -0,0 +1,147 @@
using System;
using System.Linq;
using System.Collections.Generic;
using Robust.Server.Interfaces.GameObjects;
using Robust.Server.GameObjects.EntitySystems;
using Robust.Shared.GameObjects.EntitySystemMessages;
using Robust.Shared.GameObjects;
using Robust.Shared.Interfaces.Timing;
using Robust.Shared.Interfaces.Map;
using Robust.Shared.Interfaces.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Map;
using Robust.Shared.Maths;
using Robust.Shared.Serialization;
using Content.Server.GameObjects.EntitySystems;
using Content.Shared.GameObjects;
using Content.Shared.Maps;
namespace Content.Server.GameObjects.Components.Explosive
{
public class ExplosiveComponent : Component, ITimerTrigger, IDestroyAct
{
#pragma warning disable 649
[Dependency] private readonly ITileDefinitionManager _tileDefinitionManager;
[Dependency] private readonly IMapManager _mapManager;
[Dependency] private readonly IServerEntityManager _serverEntityManager;
[Dependency] private readonly IEntitySystemManager _entitySystemManager;
#pragma warning restore 649
public override string Name => "Explosive";
public int DevastationRange = 0;
public int HeavyImpactRange = 0;
public int LightImpactRange = 0;
public int FlashRange = 0;
public override void ExposeData(ObjectSerializer serializer)
{
base.ExposeData(serializer);
serializer.DataField(ref DevastationRange, "devastationRange", 0);
serializer.DataField(ref HeavyImpactRange, "heavyImpactRange", 0);
serializer.DataField(ref LightImpactRange, "lightImpactRange", 0);
serializer.DataField(ref FlashRange, "flashRange", 0);
}
private bool Explosion()
{
var maxRange = MathHelper.Max(DevastationRange, HeavyImpactRange, LightImpactRange, 0f);
//Entity damage calculation
var entitiesAll = _serverEntityManager.GetEntitiesInRange(Owner.Transform.GridPosition, maxRange).ToList();
foreach (var entity in entitiesAll)
{
Owner.Delete();
if (entity == Owner)
continue;
if (!entity.Transform.IsMapTransform)
continue;
var distanceFromEntity = (int)entity.Transform.GridPosition.Distance(_mapManager, Owner.Transform.GridPosition);
var exAct = _entitySystemManager.GetEntitySystem<ActSystem>();
var severity = ExplosionSeverity.Destruction;
if (distanceFromEntity < DevastationRange)
{
severity = ExplosionSeverity.Destruction;
}
else if (distanceFromEntity < HeavyImpactRange)
{
severity = ExplosionSeverity.Heavy;
}
else if (distanceFromEntity < LightImpactRange)
{
severity = ExplosionSeverity.Light;
}
else
{
continue;
}
exAct.HandleExplosion(Owner, entity, severity);
}
//Tile damage calculation mockup
//TODO: make it into some sort of actual damage component or whatever the boys think is appropriate
var mapGrid = _mapManager.GetGrid(Owner.Transform.GridPosition.GridID);
var circle = new Circle(Owner.Transform.GridPosition.Position, maxRange);
var tiles = mapGrid.GetTilesIntersecting(circle);
foreach (var tile in tiles)
{
var tileLoc = mapGrid.GridTileToLocal(tile.GridIndices);
var tileDef = (ContentTileDefinition)_tileDefinitionManager[tile.Tile.TypeId];
var distanceFromTile = (int)tileLoc.Distance(_mapManager, Owner.Transform.GridPosition);
if (!string.IsNullOrWhiteSpace(tileDef.SubFloor)) {
if (distanceFromTile < DevastationRange)
mapGrid.SetTile(tileLoc, new Tile(_tileDefinitionManager["space"].TileId));
if (distanceFromTile < HeavyImpactRange)
{
if (new Random().Prob(80))
{
mapGrid.SetTile(tileLoc, new Tile(_tileDefinitionManager[tileDef.SubFloor].TileId));
}
else
{
mapGrid.SetTile(tileLoc, new Tile(_tileDefinitionManager["space"].TileId));
}
}
if (distanceFromTile < LightImpactRange)
{
if (new Random().Prob(50))
{
mapGrid.SetTile(tileLoc, new Tile(_tileDefinitionManager[tileDef.SubFloor].TileId));
}
}
}
}
//Effects and sounds
var time = IoCManager.Resolve<IGameTiming>().CurTime;
var message = new EffectSystemMessage
{
EffectSprite = "Effects/explosion.png",
Born = time,
DeathTime = time + TimeSpan.FromSeconds(5),
Size = new Vector2(FlashRange / 2, FlashRange / 2),
Coordinates = Owner.Transform.GridPosition,
//Rotated from east facing
Rotation = 0f,
ColorDelta = new Vector4(0, 0, 0, -1500f),
Color = Vector4.Multiply(new Vector4(255, 255, 255, 750), 0.5f),
Shaded = false
};
_entitySystemManager.GetEntitySystem<EffectSystem>().CreateParticle(message);
_entitySystemManager.GetEntitySystem<AudioSystem>().Play("/Audio/effects/explosion.ogg", Owner);
return true;
}
bool ITimerTrigger.Trigger(TimerTriggerEventArgs eventArgs)
{
return Explosion();
}
void IDestroyAct.OnDestroy(DestructionEventArgs eventArgs)
{
Explosion();
}
}
}

14
Content.Server/GameObjects/Components/Items/Storage/ServerStorageComponent.cs
View File

@@ -1,4 +1,5 @@
using Content.Server.GameObjects.EntitySystems;
using System.Linq;
using Content.Server.GameObjects.EntitySystems;
using Content.Shared.GameObjects.Components.Storage;
using Robust.Server.GameObjects;
using Robust.Server.GameObjects.Components.Container;
@@ -26,7 +27,7 @@ namespace Content.Server.GameObjects
/// <summary>
/// Storage component for containing entities within this one, matches a UI on the client which shows stored entities
/// </summary>
public class ServerStorageComponent : SharedStorageComponent, IAttackBy, IUse, IActivate, IStorageComponent
public class ServerStorageComponent : SharedStorageComponent, IAttackBy, IUse, IActivate, IStorageComponent, IDestroyAct
{
#pragma warning disable 649
[Dependency] private readonly IMapManager _mapManager;
@@ -340,5 +341,14 @@ namespace Content.Server.GameObjects
_storageInitialCalculated = true;
}
void IDestroyAct.OnDestroy(DestructionEventArgs eventArgs)
{
var storedEntities = storage.ContainedEntities.ToList();
foreach (var entity in storedEntities)
{
Remove(entity);
}
}
}
}

24
Content.Server/GameObjects/Components/Mobs/SpeciesComponent.cs
View File

@@ -12,7 +12,7 @@ using Robust.Shared.Serialization;
namespace Content.Server.GameObjects
{
public class SpeciesComponent : SharedSpeciesComponent, IActionBlocker, IOnDamageBehavior
public class SpeciesComponent : SharedSpeciesComponent, IActionBlocker, IOnDamageBehavior, IExAct
{
/// <summary>
/// Damagestates are reached by reaching a certain damage threshold, they will block actions after being reached
@@ -115,6 +115,28 @@ namespace Content.Server.GameObjects
Owner.RaiseEvent(new MobDamageStateChangedMessage(this));
}
void IExAct.OnExplosion(ExplosionEventArgs eventArgs)
{
var burnDamage = 0;
var bruteDamage = 0;
switch(eventArgs.Severity)
{
case ExplosionSeverity.Destruction:
bruteDamage += 250;
burnDamage += 250;
break;
case ExplosionSeverity.Heavy:
bruteDamage += 60;
burnDamage += 60;
break;
case ExplosionSeverity.Light:
bruteDamage += 30;
break;
}
Owner.GetComponent<DamageableComponent>().TakeDamage(Shared.GameObjects.DamageType.Brute, bruteDamage);
Owner.GetComponent<DamageableComponent>().TakeDamage(Shared.GameObjects.DamageType.Heat, burnDamage);
}
}
/// <summary>

44
Content.Server/GameObjects/Components/Trigger/TimerTrigger/OnUseTimerTriggerComponent.cs Normal file
View File

@@ -0,0 +1,44 @@
using System;
using Robust.Server.GameObjects;
using Robust.Shared.Interfaces.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Serialization;
using Robust.Shared.GameObjects;
using Content.Server.GameObjects.EntitySystems;
using Content.Shared.GameObjects.Components.Triggers;
namespace Content.Server.GameObjects.Components.Triggers
{
public class OnUseTimerTriggerComponent : Component, IUse
{
#pragma warning disable 649
[Dependency] private readonly IEntitySystemManager _entitySystemManager;
#pragma warning restore 649
public override string Name => "OnUseTimerTrigger";
private float _delay = 0f;
public override void ExposeData(ObjectSerializer serializer)
{
base.ExposeData(serializer);
serializer.DataField(ref _delay, "delay", 0f);
}
public override void Initialize()
{
base.Initialize();
}
bool IUse.UseEntity(UseEntityEventArgs eventArgs)
{
var triggerSystem = _entitySystemManager.GetEntitySystem<TriggerSystem>();
if (Owner.TryGetComponent<AppearanceComponent>(out var appearance)) {
appearance.SetData(TriggerVisuals.VisualState, TriggerVisualState.Primed);
}
triggerSystem.HandleTimerTrigger(TimeSpan.FromSeconds(_delay), eventArgs.User, Owner);
return true;
}
}
}