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

Bodysystem and damagesystem rework (#1544)

Browse Source 
* Things and stuff with grids, unfinished w/ code debug changes.

* Updated submodule and also lost some progress cause I fucked it up xd

* First unfinished draft of the BodySystem. Doesn't compile.

* More changes to make it compile, but still just a framework. Doesn't do anything at the moment.

* Many cleanup changes.

* Revert "Merge branch 'master' of https://github.com/GlassEclipse/space-station-14 into body_system"

This reverts commit ddd4aebbc76cf2a0b7b102f72b93d55a0816c88c, reversing
changes made to 12d0dd752706bdda8879393bd8191a1199a0c978.

* Commit human.yml

* Updated a lot of things to be more classy, more progress overall, etc. etc.

* Latest update with many changes

* Minor changes

* Fixed Travis build bug

* Adds first draft of Body Scanner console, apparently I also forgot to tie Mechanisms into body parts so now a heart just sits in the Torso like a good boy :)

* Commit rest of stuff

* Latest changes

* Latest changes again

* 14 naked cowboys

* Yay!

* Latest changes (probably doesnt compile)

* Surgery!!!!!!!!!~1116y

* Cleaned some stuff up

* More cleanup

* Refactoring of code. Basic surgery path now done.

* Removed readme, has been added to HackMD

* Fixes typo (and thus test errors)

* WIP changes, committing so I can pull latest master changes

* Still working on that god awful merge

* Latest changes

* Latest changes!!

* Beginning of refactor to BoundUserInterface

* Surgery!

* Latest changes - fixes pr change requests and random fixes

* oops

* Fixes bodypart recursion

* Beginning of work on revamping the damage system.

* More latest changes

* Latest changes

* Finished merge

* Commit before removing old healthcode

* Almost done with removing speciescomponent...

* It compiles!!!

* yahoo more work

* Fixes to make it work

* Merge conflict fixes

* Deleting species visualizer was a mistake

* IDE warnings are VERBOTEN

* makes the server not kill itself on startup, some cleanup (#1)

* Namespaces, comments and exception fixes

* Fix conveyor and conveyor switch serialization

SS14 in reactive when

* Move damage, acts and body to shared

Damage cleanup
Comment cleanup

* Rename SpeciesComponent to RotationComponent and cleanup

Damage cleanup
Comment cleanup

* Fix nullable warnings

* Address old reviews

Fix off welder suicide damage type, deathmatch and suspicion

* Fix new test fail with units being able to accept items when unpowered

* Remove RotationComponent, change references to IBodyManagerComponent

* Add a bloodstream to humans

* More cleanups

* Add body conduits, connections, connectors substances and valves

* Revert "Add body conduits, connections, connectors substances and valves"

This reverts commit 9ab0b50e6b15fe98852d7b0836c0cdbf4bd76d20.

* Implement the heart mechanism behavior with the circulatory network

* Added network property to mechanism behaviors

* Changed human organ sprites and added missing ones

* Fix tests

* Add individual body part sprite rendering

* Fix error where dropped mechanisms are not initialized

* Implement client/server body damage

* Make DamageContainer take care of raising events

* Reimplement medical scanner with the new body system

* Improve the medical scanner ui

* Merge conflict fixes

* Fix crash when colliding with something

* Fix microwave suicides and eyes sprite rendering

* Fix nullable reference error

* Fix up surgery client side

* Fix missing using from merge conflict

* Add breathing

*inhale

* Merge conflict fixes

* Fix accumulatedframetime being reset to 0 instead of decreased by the threshold

https://github.com/space-wizards/space-station-14/pull/1617

* Use and add to the new AtmosHelpers

* Fix feet

* Add proper coloring to dropped body parts

* Fix Urist's lungs being too strong

* Merge conflict fixes

* Merge conflict fixes

* Merge conflict fixes

Co-authored-by: GlassEclipse <tsymall5@gmail.com>
Co-authored-by: Pieter-Jan Briers <pieterjan.briers+git@gmail.com>
Co-authored-by: AJCM-git <60196617+AJCM-git@users.noreply.github.com>
This commit is contained in:
DrSmugleaf
2020-08-17 01:42:42 +02:00
committed by GitHub
parent c17dd97383
commit b051261485
276 changed files with 7853 additions and 4737 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
Content.Shared/Body/Mechanism/MechanismPrototype.cs Normal file
View File

@@ -0,0 +1,73 @@
using System;
using System.Collections.Generic;
using Content.Shared.GameObjects.Components.Body;
using Robust.Shared.Prototypes;
using Robust.Shared.Serialization;
using Robust.Shared.ViewVariables;
using YamlDotNet.RepresentationModel;
namespace Content.Shared.Body.Mechanism
{
/// <summary>
/// Prototype for the Mechanism class.
/// </summary>
[Prototype("mechanism")]
[Serializable, NetSerializable]
public class MechanismPrototype : IPrototype, IIndexedPrototype
{
private List<string> _behaviorClasses;
private BodyPartCompatibility _compatibility;
private string _description;
private int _destroyThreshold;
private int _durability;
private string _examineMessage;
private string _id;
private string _name;
private int _resistance;
private string _rsiPath;
private string _rsiState;
private int _size;
[ViewVariables] public string Name => _name;
[ViewVariables] public string Description => _description;
[ViewVariables] public string ExamineMessage => _examineMessage;
[ViewVariables] public string RSIPath => _rsiPath;
[ViewVariables] public string RSIState => _rsiState;
[ViewVariables] public int Durability => _durability;
[ViewVariables] public int DestroyThreshold => _destroyThreshold;
[ViewVariables] public int Resistance => _resistance;
[ViewVariables] public int Size => _size;
[ViewVariables] public BodyPartCompatibility Compatibility => _compatibility;
[ViewVariables] public List<string> BehaviorClasses => _behaviorClasses;
[ViewVariables] public string ID => _id;
public virtual void LoadFrom(YamlMappingNode mapping)
{
var serializer = YamlObjectSerializer.NewReader(mapping);
serializer.DataField(ref _id, "id", string.Empty);
serializer.DataField(ref _name, "name", string.Empty);
serializer.DataField(ref _description, "description", string.Empty);
serializer.DataField(ref _examineMessage, "examineMessage", string.Empty);
serializer.DataField(ref _rsiPath, "rsiPath", string.Empty);
serializer.DataField(ref _rsiState, "rsiState", string.Empty);
serializer.DataField(ref _durability, "durability", 0);
serializer.DataField(ref _destroyThreshold, "destroyThreshold", 0);
serializer.DataField(ref _resistance, "resistance", 0);
serializer.DataField(ref _size, "size", 2);
serializer.DataField(ref _compatibility, "compatibility", BodyPartCompatibility.Universal);
serializer.DataField(ref _behaviorClasses, "behaviors", new List<string>());
}
}
}

100
Content.Shared/Body/Part/BodyPartPrototype.cs Normal file
View File

@@ -0,0 +1,100 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Content.Shared.GameObjects.Components.Body;
using Robust.Shared.Interfaces.Serialization;
using Robust.Shared.Prototypes;
using Robust.Shared.Serialization;
using Robust.Shared.ViewVariables;
using YamlDotNet.RepresentationModel;
namespace Content.Shared.Body.Part
{
/// <summary>
/// Prototype for the BodyPart class.
/// </summary>
[Prototype("bodyPart")]
[Serializable, NetSerializable]
public class BodyPartPrototype : IPrototype, IIndexedPrototype
{
private BodyPartCompatibility _compatibility;
private string _damageContainerPresetId;
private int _destroyThreshold;
private int _durability;
private string _id;
private List<string> _mechanisms;
private string _name;
private BodyPartType _partType;
private string _plural;
private List<IExposeData> _properties;
private float _resistance;
private string _resistanceSetId;
private string _rsiPath;
private string _rsiState;
private int _size;
private string _surgeryDataName;
[ViewVariables] public string Name => _name;
[ViewVariables] public string Plural => _plural;
[ViewVariables] public string RSIPath => _rsiPath;
[ViewVariables] public string RSIState => _rsiState;
[ViewVariables] public BodyPartType PartType => _partType;
[ViewVariables] public int Durability => _durability;
[ViewVariables] public int DestroyThreshold => _destroyThreshold;
[ViewVariables] public float Resistance => _resistance;
[ViewVariables] public int Size => _size;
[ViewVariables] public BodyPartCompatibility Compatibility => _compatibility;
[ViewVariables] public string DamageContainerPresetId => _damageContainerPresetId;
[ViewVariables] public string ResistanceSetId => _resistanceSetId;
[ViewVariables] public string SurgeryDataName => _surgeryDataName;
[ViewVariables] public List<IExposeData> Properties => _properties;
[ViewVariables] public List<string> Mechanisms => _mechanisms;
[ViewVariables] public string ID => _id;
public virtual void LoadFrom(YamlMappingNode mapping)
{
var serializer = YamlObjectSerializer.NewReader(mapping);
serializer.DataField(ref _name, "name", string.Empty);
serializer.DataField(ref _id, "id", string.Empty);
serializer.DataField(ref _plural, "plural", string.Empty);
serializer.DataField(ref _rsiPath, "rsiPath", string.Empty);
serializer.DataField(ref _rsiState, "rsiState", string.Empty);
serializer.DataField(ref _partType, "partType", BodyPartType.Other);
serializer.DataField(ref _surgeryDataName, "surgeryDataType", "BiologicalSurgeryData");
serializer.DataField(ref _durability, "durability", 50);
serializer.DataField(ref _destroyThreshold, "destroyThreshold", -50);
serializer.DataField(ref _resistance, "resistance", 0f);
serializer.DataField(ref _size, "size", 0);
serializer.DataField(ref _compatibility, "compatibility", BodyPartCompatibility.Universal);
serializer.DataField(ref _damageContainerPresetId, "damageContainer", string.Empty);
serializer.DataField(ref _resistanceSetId, "resistances", string.Empty);
serializer.DataField(ref _properties, "properties", new List<IExposeData>());
serializer.DataField(ref _mechanisms, "mechanisms", new List<string>());
foreach (var property in _properties)
{
if (_properties.Count(x => x.GetType() == property.GetType()) > 1)
{
throw new InvalidOperationException(
$"Multiple {nameof(BodyPartPrototype)} of the same type were defined in prototype {ID}");
}
}
}
}
}

23
Content.Shared/Body/Part/Properties/BodyPartProperty.cs Normal file
View File

@@ -0,0 +1,23 @@
using Robust.Shared.Interfaces.Serialization;
using Robust.Shared.Serialization;
namespace Content.Shared.Body.Part.Properties
{
/// <summary>
/// Property attachable to a <see cref="BodyPart"/>.
/// For example, this is used to define the speed capabilities of a
/// leg. The movement system will look for a LegProperty on all BodyParts.
/// </summary>
public abstract class BodyPartProperty : IExposeData
{
/// <summary>
/// Whether this property is currently active.
/// </summary>
public bool Active;
public virtual void ExposeData(ObjectSerializer serializer)
{
serializer.DataField(ref Active, "active", true);
}
}
}

11
Content.Shared/Body/Part/Properties/Movement/FootProperty.cs Normal file
View File

@@ -0,0 +1,11 @@
namespace Content.Shared.Body.Part.Properties.Movement
{
/// <summary>
/// Defines the leg-based locomotion ability of a BodyPart. Required for humanoid-like movement. Must be connected to a
/// <see cref="BodyPart" /> with
/// <see cref="LegProperty" /> and <see cref="ExtensionProperty" /> to work.
/// </summary>
public class FootProperty : BodyPartProperty
{
}
}

23
Content.Shared/Body/Part/Properties/Movement/LegProperty.cs Normal file
View File

@@ -0,0 +1,23 @@
using Robust.Shared.Serialization;
namespace Content.Shared.Body.Part.Properties.Movement
{
/// <summary>
/// Defines the speed of humanoid-like movement. Must be connected to a
/// <see cref="BodyPart" /> with <see cref="FootProperty" /> and have
/// <see cref="ExtensionProperty" /> on the same organ and down to the foot to work.
/// </summary>
public class LegProperty : BodyPartProperty
{
/// <summary>
/// Speed (in tiles per second).
/// </summary>
public float Speed;
public override void ExposeData(ObjectSerializer serializer)
{
base.ExposeData(serializer);
serializer.DataField(ref Speed, "speed", 1f);
}
}
}

21
Content.Shared/Body/Part/Properties/Other/ExtensionProperty.cs Normal file
View File

@@ -0,0 +1,21 @@
using Robust.Shared.Serialization;
namespace Content.Shared.Body.Part.Properties.Other
{
/// <summary>
/// Defines the extension ability of a BodyPart. Used to determine things like reach distance and running speed.
/// </summary>
public class ExtensionProperty : BodyPartProperty
{
/// <summary>
/// Current reach distance (in tiles).
/// </summary>
public float ReachDistance;
public override void ExposeData(ObjectSerializer serializer)
{
base.ExposeData(serializer);
serializer.DataField(ref ReachDistance, "reachDistance", 2f);
}
}
}

10
Content.Shared/Body/Part/Properties/Other/GraspProperty.cs Normal file
View File

@@ -0,0 +1,10 @@
namespace Content.Shared.Body.Part.Properties.Other
{
/// <summary>
/// Defines the item grasping ability of a BodyPart. Distance is determined by the
/// <see cref="ExtensionProperty">ExtensionProperties</see> of the current BodyPart or attached BodyParts.
/// </summary>
public class GraspProperty : BodyPartProperty
{
}
}

35
Content.Shared/Body/Preset/BodyPresetPrototype.cs Normal file
View File

@@ -0,0 +1,35 @@
using System;
using System.Collections.Generic;
using Robust.Shared.Prototypes;
using Robust.Shared.Serialization;
using Robust.Shared.ViewVariables;
using YamlDotNet.RepresentationModel;
namespace Content.Shared.Body.Preset
{
/// <summary>
/// Prototype for the BodyPreset class.
/// </summary>
[Prototype("bodyPreset")]
[Serializable, NetSerializable]
public class BodyPresetPrototype : IPrototype, IIndexedPrototype
{
private string _id;
private string _name;
private Dictionary<string, string> _partIDs;
[ViewVariables] public string ID => _id;
[ViewVariables] public string Name => _name;
[ViewVariables] public Dictionary<string, string> PartIDs => _partIDs;
public virtual void LoadFrom(YamlMappingNode mapping)
{
var serializer = YamlObjectSerializer.NewReader(mapping);
serializer.DataField(ref _id, "id", string.Empty);
serializer.DataField(ref _name, "name", string.Empty);
serializer.DataField(ref _partIDs, "partIDs", new Dictionary<string, string>());
}
}
}

85
Content.Shared/Body/Scanner/BodyScannerSharedValues.cs Normal file
View File

@@ -0,0 +1,85 @@
using System;
using System.Collections.Generic;
using Content.Shared.GameObjects.Components.Body;
using Robust.Shared.GameObjects.Components.UserInterface;
using Robust.Shared.Serialization;
namespace Content.Shared.Body.Scanner
{
[Serializable, NetSerializable]
public enum BodyScannerUiKey
{
Key
}
[Serializable, NetSerializable]
public class BodyScannerInterfaceState : BoundUserInterfaceState
{
public readonly Dictionary<string, BodyScannerBodyPartData> Parts;
public readonly BodyScannerTemplateData Template;
public BodyScannerInterfaceState(Dictionary<string, BodyScannerBodyPartData> parts,
BodyScannerTemplateData template)
{
Template = template;
Parts = parts;
}
}
[Serializable, NetSerializable]
public class BodyScannerBodyPartData
{
public readonly int CurrentDurability;
public readonly int MaxDurability;
public readonly List<BodyScannerMechanismData> Mechanisms;
public readonly string Name;
public readonly string RSIPath;
public readonly string RSIState;
public BodyScannerBodyPartData(string name, string rsiPath, string rsiState, int maxDurability,
int currentDurability, List<BodyScannerMechanismData> mechanisms)
{
Name = name;
RSIPath = rsiPath;
RSIState = rsiState;
MaxDurability = maxDurability;
CurrentDurability = currentDurability;
Mechanisms = mechanisms;
}
}
[Serializable, NetSerializable]
public class BodyScannerMechanismData
{
public readonly int CurrentDurability;
public readonly string Description;
public readonly int MaxDurability;
public readonly string Name;
public readonly string RSIPath;
public readonly string RSIState;
public BodyScannerMechanismData(string name, string description, string rsiPath, string rsiState,
int maxDurability, int currentDurability)
{
Name = name;
Description = description;
RSIPath = rsiPath;
RSIState = rsiState;
MaxDurability = maxDurability;
CurrentDurability = currentDurability;
}
}
[Serializable, NetSerializable]
public class BodyScannerTemplateData
{
public readonly string Name;
public readonly Dictionary<string, BodyPartType> Slots;
public BodyScannerTemplateData(string name, Dictionary<string, BodyPartType> slots)
{
Name = name;
Slots = slots;
}
}
}

88
Content.Shared/Body/Surgery/GenericSurgeryUIMessages.cs Normal file
View File

@@ -0,0 +1,88 @@
using System;
using System.Collections.Generic;
using Robust.Shared.GameObjects.Components.UserInterface;
using Robust.Shared.Serialization;
namespace Content.Shared.Body.Surgery
{
[Serializable]
[NetSerializable]
public class RequestBodyPartSurgeryUIMessage : BoundUserInterfaceMessage
{
public Dictionary<string, int> Targets;
public RequestBodyPartSurgeryUIMessage(Dictionary<string, int> targets)
{
Targets = targets;
}
}
[Serializable]
[NetSerializable]
public class RequestMechanismSurgeryUIMessage : BoundUserInterfaceMessage
{
public Dictionary<string, int> Targets;
public RequestMechanismSurgeryUIMessage(Dictionary<string, int> targets)
{
Targets = targets;
}
}
[Serializable]
[NetSerializable]
public class RequestBodyPartSlotSurgeryUIMessage : BoundUserInterfaceMessage
{
public Dictionary<string, int> Targets;
public RequestBodyPartSlotSurgeryUIMessage(Dictionary<string, int> targets)
{
Targets = targets;
}
}
[Serializable]
[NetSerializable]
public class ReceiveBodyPartSurgeryUIMessage : BoundUserInterfaceMessage
{
public int SelectedOptionId;
public ReceiveBodyPartSurgeryUIMessage(int selectedOptionId)
{
SelectedOptionId = selectedOptionId;
}
}
[Serializable]
[NetSerializable]
public class ReceiveMechanismSurgeryUIMessage : BoundUserInterfaceMessage
{
public int SelectedOptionId;
public ReceiveMechanismSurgeryUIMessage(int selectedOptionId)
{
SelectedOptionId = selectedOptionId;
}
}
[Serializable]
[NetSerializable]
public class ReceiveBodyPartSlotSurgeryUIMessage : BoundUserInterfaceMessage
{
public int SelectedOptionId;
public ReceiveBodyPartSlotSurgeryUIMessage(int selectedOptionId)
{
SelectedOptionId = selectedOptionId;
}
}
[NetSerializable]
[Serializable]
public enum GenericSurgeryUiKey
{
Key
}
}

87
Content.Shared/Body/Template/BodyTemplatePrototype.cs Normal file
View File

@@ -0,0 +1,87 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Content.Shared.GameObjects.Components.Body;
using Robust.Shared.Prototypes;
using Robust.Shared.Serialization;
using Robust.Shared.ViewVariables;
using YamlDotNet.RepresentationModel;
namespace Content.Shared.Body.Template
{
/// <summary>
/// Prototype for the BodyTemplate class.
/// </summary>
[Prototype("bodyTemplate")]
[Serializable, NetSerializable]
public class BodyTemplatePrototype : IPrototype, IIndexedPrototype
{
private string _id;
private string _name;
private string _centerSlot;
private Dictionary<string, BodyPartType> _slots;
private Dictionary<string, List<string>> _connections;
private Dictionary<string, string> _layers;
private Dictionary<string, string> _mechanismLayers;
[ViewVariables] public string ID => _id;
[ViewVariables] public string Name => _name;
[ViewVariables] public string CenterSlot => _centerSlot;
[ViewVariables] public Dictionary<string, BodyPartType> Slots => new Dictionary<string, BodyPartType>(_slots);
[ViewVariables]
public Dictionary<string, List<string>> Connections =>
_connections.ToDictionary(x => x.Key, x => x.Value.ToList());
[ViewVariables] public Dictionary<string, string> Layers => new Dictionary<string, string>(_layers);
[ViewVariables] public Dictionary<string, string> MechanismLayers => new Dictionary<string, string>(_mechanismLayers);
public virtual void LoadFrom(YamlMappingNode mapping)
{
var serializer = YamlObjectSerializer.NewReader(mapping);
serializer.DataField(ref _id, "id", string.Empty);
serializer.DataField(ref _name, "name", string.Empty);
serializer.DataField(ref _centerSlot, "centerSlot", string.Empty);
serializer.DataField(ref _slots, "slots", new Dictionary<string, BodyPartType>());
serializer.DataField(ref _connections, "connections", new Dictionary<string, List<string>>());
serializer.DataField(ref _layers, "layers", new Dictionary<string, string>());
serializer.DataField(ref _mechanismLayers, "mechanismLayers", new Dictionary<string, string>());
//Our prototypes don't force the user to define a BodyPart connection twice. E.g. Head: Torso v.s. Torso: Head.
//The user only has to do one. We want it to be that way in the code, though, so this cleans that up.
var cleanedConnections = new Dictionary<string, List<string>>();
foreach (var targetSlotName in _slots.Keys)
{
var tempConnections = new List<string>();
foreach (var (slotName, slotConnections) in _connections)
{
if (slotName == targetSlotName)
{
foreach (var connection in slotConnections)
{
if (!tempConnections.Contains(connection))
{
tempConnections.Add(connection);
}
}
}
else if (slotConnections.Contains(targetSlotName))
{
tempConnections.Add(slotName);
}
}
if (tempConnections.Count > 0)
{
cleanedConnections.Add(targetSlotName, tempConnections);
}
}
_connections = cleanedConnections;
}
}
}