tommy/tbd-station-14
2
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

BodySystem stuff 2: overused boogaloo (#1174)

Browse Source 
Co-authored-by: Pieter-Jan Briers <pieterjan.briers+git@gmail.com>
This commit is contained in:
GlassEclipse
2020-07-02 13:51:14 -05:00
committed by GitHub
parent 7d346ede28
commit 610ab8bf50
30 changed files with 1493 additions and 688 deletions
Download Patch File Download Diff File Expand all files Collapse all files

196
Content.Server/Health/BodySystem/Surgery/SurgeryData/BiologicalSurgeryData.cs
View File

@@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Content.Shared.BodySystem;
using Content.Shared.Interfaces;
using Robust.Shared.Interfaces.GameObjects;
@@ -11,113 +12,188 @@ using Robust.Shared.Serialization;
using Robust.Shared.ViewVariables;
using YamlDotNet.RepresentationModel;
namespace Content.Server.BodySystem {
namespace Content.Server.BodySystem
{
/// <summary>
/// Data class representing the surgery state of a biological entity.
/// </summary>
public class BiologicalSurgeryData : ISurgeryData {
public class BiologicalSurgeryData : ISurgeryData
{
protected bool _skinOpened = false;
protected bool _vesselsClamped = false;
protected bool _skinRetracted = false;
protected Mechanism _targetOrgan;
protected List<Mechanism> _disconnectedOrgans = new List<Mechanism>();
public BiologicalSurgeryData(BodyPart parent) : base(parent) { }
public override SurgeryAction GetSurgeryStep(SurgeryToolType toolType)
public override SurgeryAction GetSurgeryStep(SurgeryType toolType)
{
if (_skinOpened)
if (toolType == SurgeryType.Amputation)
{
if (_vesselsClamped)
{
if (_skinRetracted)
{
if (_targetOrgan != null && toolType == SurgeryToolType.VesselCompression)
return RemoveOrganSurgery;
if (toolType == SurgeryToolType.Incision) //_targetOrgan is potentially given a value by DisconnectOrganSurgery.
return DisconnectOrganSurgery;
else if (toolType == SurgeryToolType.Cauterization)
return CautizerizeIncisionSurgery;
}
else
{
if (toolType == SurgeryToolType.Retraction)
return RetractSkinSurgery;
else if (toolType == SurgeryToolType.Cauterization)
return CautizerizeIncisionSurgery;
}
}
else
{
if (toolType == SurgeryToolType.VesselCompression)
return ClampVesselsSurgery;
else if (toolType == SurgeryToolType.Cauterization)
return CautizerizeIncisionSurgery;
}
return RemoveBodyPartSurgery;
}
else
if (!_skinOpened) //Case: skin is normal.
{
if (toolType == SurgeryToolType.Incision)
if (toolType == SurgeryType.Incision)
return OpenSkinSurgery;
}
else if (!_vesselsClamped) //Case: skin is opened, but not clamped.
{
if (toolType == SurgeryType.VesselCompression)
return ClampVesselsSurgery;
else if (toolType == SurgeryType.Cauterization)
return CautizerizeIncisionSurgery;
}
else if (!_skinRetracted) //Case: skin is opened and clamped, but not retracted.
{
if (toolType == SurgeryType.Retraction)
return RetractSkinSurgery;
else if (toolType == SurgeryType.Cauterization)
return CautizerizeIncisionSurgery;
}
else //Case: skin is fully open.
{
if (_parent.Mechanisms.Count > 0 && toolType == SurgeryType.VesselCompression && (_disconnectedOrgans.Except(_parent.Mechanisms).Count() != 0 || _parent.Mechanisms.Except(_disconnectedOrgans).Count() != 0))
return LoosenOrganSurgery;
else if (_disconnectedOrgans.Count > 0 && toolType == SurgeryType.Incision)
return RemoveOrganSurgery;
else if (toolType == SurgeryType.Cauterization)
return CautizerizeIncisionSurgery;
}
return null;
}
protected void OpenSkinSurgery(BodyManagerComponent target, IEntity performer)
public override string GetDescription(IEntity target)
{
ILocalizationManager localizationManager = IoCManager.Resolve<ILocalizationManager>();
performer.PopupMessage(performer, localizationManager.GetString("Cut open the skin..."));
string toReturn = "";
if (_skinOpened && !_vesselsClamped) //Case: skin is opened, but not clamped.
{
toReturn += Loc.GetString("The skin on {0:their} {1} has an incision, but it is prone to bleeding.\n", target, _parent.Name);
}
else if (_skinOpened && _vesselsClamped && !_skinRetracted) //Case: skin is opened and clamped, but not retracted.
{
toReturn += Loc.GetString("The skin on {0:their} {1} has an incision, but it is not retracted.\n", target, _parent.Name);
}
else if (_skinOpened && _vesselsClamped && _skinRetracted) //Case: skin is fully open.
{
toReturn += Loc.GetString("There is an incision on {0:their} {1}.\n", target, _parent.Name);
foreach (Mechanism mechanism in _disconnectedOrgans)
{
toReturn += Loc.GetString("{0:their} {1} is loose.\n", target, mechanism.Name);
}
}
return toReturn;
}
public override bool CanInstallMechanism(Mechanism toBeInstalled)
{
return _skinOpened && _vesselsClamped && _skinRetracted;
}
public override bool CanAttachBodyPart(BodyPart toBeConnected)
{
return true;
//TODO: if a bodypart is disconnected, you should have to do some surgery to allow another bodypart to be attached.
}
protected void OpenSkinSurgery(IBodyPartContainer container, ISurgeon surgeon, IEntity performer)
{
performer.PopupMessage(performer, Loc.GetString("Cut open the skin..."));
//Delay?
_skinOpened = true;
}
protected void ClampVesselsSurgery(BodyManagerComponent target, IEntity performer)
protected void ClampVesselsSurgery(IBodyPartContainer container, ISurgeon surgeon, IEntity performer)
{
ILocalizationManager localizationManager = IoCManager.Resolve<ILocalizationManager>();
performer.PopupMessage(performer, localizationManager.GetString("Clamp the vessels..."));
performer.PopupMessage(performer, Loc.GetString("Clamp the vessels..."));
//Delay?
_vesselsClamped = true;
}
protected void RetractSkinSurgery(BodyManagerComponent target, IEntity performer)
protected void RetractSkinSurgery(IBodyPartContainer container, ISurgeon surgeon, IEntity performer)
{
ILocalizationManager localizationManager = IoCManager.Resolve<ILocalizationManager>();
performer.PopupMessage(performer, localizationManager.GetString("Retract the skin..."));
performer.PopupMessage(performer, Loc.GetString("Retract the skin..."));
//Delay?
_skinRetracted = true;
}
protected void CautizerizeIncisionSurgery(BodyManagerComponent target, IEntity performer)
protected void CautizerizeIncisionSurgery(IBodyPartContainer container, ISurgeon surgeon, IEntity performer)
{
ILocalizationManager localizationManager = IoCManager.Resolve<ILocalizationManager>();
performer.PopupMessage(performer, localizationManager.GetString("Cauterize the incision..."));
performer.PopupMessage(performer, Loc.GetString("Cauterize the incision..."));
//Delay?
_skinOpened = false;
_vesselsClamped = false;
_skinRetracted = false;
}
protected void DisconnectOrganSurgery(BodyManagerComponent target, IEntity performer)
protected void LoosenOrganSurgery(IBodyPartContainer container, ISurgeon surgeon, IEntity performer)
{
Mechanism mechanismTarget = null;
//TODO: figureout popup, right now it just takes the first organ available if there is one
if (_parent.Mechanisms.Count > 0)
mechanismTarget = _parent.Mechanisms[0];
if (mechanismTarget != null)
if (_parent.Mechanisms.Count <= 0)
return;
List<Mechanism> toSend = new List<Mechanism>();
foreach (Mechanism mechanism in _parent.Mechanisms)
{
ILocalizationManager localizationManager = IoCManager.Resolve<ILocalizationManager>();
performer.PopupMessage(performer, localizationManager.GetString("Detach the organ..."));
//Delay?
_targetOrgan = mechanismTarget;
if (!_disconnectedOrgans.Contains(mechanism))
toSend.Add(mechanism);
}
if (toSend.Count > 0)
surgeon.RequestMechanism(toSend, LoosenOrganSurgeryCallback);
}
public void LoosenOrganSurgeryCallback(Mechanism target, IBodyPartContainer container, ISurgeon surgeon, IEntity performer)
{
if (target != null && _parent.Mechanisms.Contains(target))
{
performer.PopupMessage(performer, Loc.GetString("Loosen the organ..."));
//Delay?
_disconnectedOrgans.Add(target);
}
}
protected void RemoveOrganSurgery(IBodyPartContainer container, ISurgeon surgeon, IEntity performer)
{
if (_disconnectedOrgans.Count <= 0)
return;
if (_disconnectedOrgans.Count == 1)
RemoveOrganSurgeryCallback(_disconnectedOrgans[0], container, surgeon, performer);
else
surgeon.RequestMechanism(_disconnectedOrgans, RemoveOrganSurgeryCallback);
}
protected void RemoveOrganSurgery(BodyManagerComponent target, IEntity performer)
public void RemoveOrganSurgeryCallback(Mechanism target, IBodyPartContainer container, ISurgeon surgeon, IEntity performer)
{
if (_targetOrgan != null)
if (target != null && _parent.Mechanisms.Contains(target))
{
ILocalizationManager localizationManager = IoCManager.Resolve<ILocalizationManager>();
performer.PopupMessage(performer, localizationManager.GetString("Remove the organ..."));
performer.PopupMessage(performer, Loc.GetString("Remove the organ..."));
//Delay?
_parent.DropMechanism(performer, _targetOrgan);
_parent.DropMechanism(performer, target);
_disconnectedOrgans.Remove(target);
}
}
protected void RemoveBodyPartSurgery(IBodyPartContainer container, ISurgeon surgeon, IEntity performer)
{
if (!(container is BodyManagerComponent)) //This surgery requires a DroppedBodyPartComponent.
return;
BodyManagerComponent bmTarget = (BodyManagerComponent) container;
performer.PopupMessage(performer, Loc.GetString("Saw off the limb!"));
//Delay?
bmTarget.DisconnectBodyPart(_parent, true);
}
}
}

54
Content.Server/Health/BodySystem/Surgery/SurgeryData/ISurgeryData.cs
View File

@@ -8,24 +8,31 @@ using Robust.Shared.Serialization;
using Robust.Shared.ViewVariables;
using YamlDotNet.RepresentationModel;
namespace Content.Server.BodySystem {
namespace Content.Server.BodySystem
{
/// <summary>
/// This data class represents the state of a BodyPart in regards to everything surgery related - whether there's an incision on it, whether the bone is broken, etc.
/// This data class represents the state of a <see cref="BodyPart"/> in regards to everything surgery related - whether there's an incision on it, whether the bone is broken, etc.
/// </summary>
public abstract class ISurgeryData {
public abstract class ISurgeryData
{
/// <summary>
/// The BodyPart this surgeryData is attached to. The ISurgeryData class should not exist without a BodyPart that it represents, and will not work correctly without it.
/// The <see cref="BodyPart"/> this surgeryData is attached to. The ISurgeryData class should not exist without a <see cref="BodyPart"/> that it
/// represents, and will throw errors if it is null.
/// </summary>
protected BodyPart _parent;
/// <summary>
/// The BodyPartType of the parent PartType.
/// The <see cref="BodyPartType"/> of the parent <see cref="BodyPart"/>.
/// </summary>
protected BodyPartType _parentType => _parent.PartType;
public delegate void SurgeryAction(BodyManagerComponent target, IEntity performer);
public delegate void SurgeryAction(IBodyPartContainer container, ISurgeon surgeon, IEntity performer);
public ISurgeryData(BodyPart parent)
{
@@ -33,29 +40,44 @@ namespace Content.Server.BodySystem {
}
/// <summary>
/// Gets the delegate corresponding to the surgery step using the given SurgeryToolType. Returns null if no surgery step can be performed.
/// Returns the description of this current <see cref="BodyPart"/> to be shown upon observing the given entity.
/// </summary>
public abstract SurgeryAction GetSurgeryStep(SurgeryToolType toolType);
public abstract string GetDescription(IEntity target);
/// <summary>
/// Returns whether the given SurgeryToolType can be used to perform a surgery.
/// Returns whether a <see cref="Mechanism"/> can be installed into the <see cref="BodyPart"/> this ISurgeryData represents.
/// </summary>
public bool CheckSurgery(SurgeryToolType toolType)
public abstract bool CanInstallMechanism(Mechanism toBeInstalled);
/// <summary>
/// Returns whether the given <see cref="BodyPart"/> can be connected to the <see cref="BodyPart"/> this ISurgeryData represents.
/// </summary>
public abstract bool CanAttachBodyPart(BodyPart toBeConnected);
/// <summary>
/// Gets the delegate corresponding to the surgery step using the given <see cref="SurgeryType"/>. Returns null if no surgery step can be performed.
/// </summary>
public abstract SurgeryAction GetSurgeryStep(SurgeryType toolType);
/// <summary>
/// Returns whether the given <see cref="SurgeryType"/> can be used to perform a surgery on the BodyPart this <see cref="ISurgeryData"/> represents.
/// </summary>
public bool CheckSurgery(SurgeryType toolType)
{
return GetSurgeryStep(toolType) != null;
}
/// <summary>
/// Attempts to perform surgery with the given tooltype. Returns whether the operation was successful.
/// Attempts to perform surgery of the given <see cref="SurgeryType"/>. Returns whether the operation was successful.
/// </summary>
/// /// <param name="toolType">The SurgeryToolType used for this surgery.</param>
/// /// <param name="performer">The entity performing the surgery.</param>
public bool PerformSurgery(SurgeryToolType toolType, BodyManagerComponent target, IEntity performer)
/// <param name="surgeryType">The <see cref="SurgeryType"/> used for this surgery.</param>
/// <param name="performer">The entity performing the surgery.</param>
public bool PerformSurgery(SurgeryType surgeryType, IBodyPartContainer container, ISurgeon surgeon, IEntity performer)
{
SurgeryAction step = GetSurgeryStep(toolType);
SurgeryAction step = GetSurgeryStep(surgeryType);
if (step == null)
return false;
step(target, performer);
step(container, surgeon, performer);
return true;
}