545 lines
20 KiB
C#
545 lines
20 KiB
C#
using Content.Server.Administration;
|
|
using Content.Server.Body.Components;
|
|
using Content.Server.Body.Systems;
|
|
using Content.Server.Chat.Managers;
|
|
using Content.Server.Chemistry.Containers.EntitySystems;
|
|
using Content.Server.Damage.Systems;
|
|
using Content.Server.Medical;
|
|
using Content.Server.Popups;
|
|
using Content.Server.Stunnable;
|
|
using Content.Shared.Actions;
|
|
using Content.Shared.Borer;
|
|
using Content.Shared.Changeling;
|
|
using Content.Shared.Chat;
|
|
using Content.Shared.Chemistry;
|
|
using Content.Shared.Chemistry.Components;
|
|
using Content.Shared.Chemistry.Reagent;
|
|
using Content.Shared.DoAfter;
|
|
using Content.Shared.FixedPoint;
|
|
using Content.Shared.Humanoid;
|
|
using Content.Shared.Mind;
|
|
using Content.Shared.Mobs;
|
|
using Content.Shared.Mobs.Components;
|
|
using Content.Shared.Popups;
|
|
using Content.Shared.Silicons.Borgs.Components;
|
|
using Robust.Server.Containers;
|
|
using Robust.Shared.Containers;
|
|
using Robust.Shared.Player;
|
|
using Robust.Shared.Timing;
|
|
|
|
namespace Content.Server.Borer;
|
|
|
|
public sealed class ServerBorerSystem : EntitySystem
|
|
{
|
|
[Dependency] private readonly SharedActionsSystem _action = default!;
|
|
[Dependency] private readonly BloodstreamSystem _bloodstreamSystem = default!;
|
|
[Dependency] private readonly IChatManager _chatManager = default!;
|
|
[Dependency] private readonly SharedDoAfterSystem _doAfterSystem = default!;
|
|
[Dependency] private readonly IEntityManager _entityManager = default!;
|
|
[Dependency] private readonly SharedMindSystem _mindSystem = default!;
|
|
[Dependency] private readonly PopupSystem _popup = default!;
|
|
[Dependency] private readonly QuickDialogSystem _quickDialog = default!;
|
|
[Dependency] private readonly ReactiveSystem _reactiveSystem = default!;
|
|
[Dependency] private readonly SolutionContainerSystem _solutionContainerSystem = default!;
|
|
[Dependency] private readonly StunSystem _stuns = default!;
|
|
[Dependency] private readonly IGameTiming _timing = default!;
|
|
[Dependency] private readonly VomitSystem _vomitSystem = default!;
|
|
[Dependency] private readonly ContainerSystem _container = default!;
|
|
[Dependency] private readonly SharedBorerSystem _sharedBorerSystem = default!;
|
|
[Dependency] private readonly MetaDataSystem _metaData = default!;
|
|
[Dependency] private readonly GodmodeSystem _godmodeSystem = default!;
|
|
|
|
private const string SugarPrototype = "Sugar";
|
|
|
|
public override void Initialize()
|
|
{
|
|
base.Initialize();
|
|
|
|
SubscribeLocalEvent<BorerComponent, BorerInfestActionEvent>(OnInfest);
|
|
SubscribeLocalEvent<BorerComponent, BorerInfestDoAfterEvent>(OnInfestAfter);
|
|
|
|
SubscribeLocalEvent<InfestedBorerComponent, BorerOutActionEvent>(OnGetOut);
|
|
SubscribeLocalEvent<InfestedBorerComponent, BorerBrainSpeechActionEvent>(OnTelepathicSpeech);
|
|
|
|
SubscribeNetworkEvent<BorerInjectActionEvent>(OnInjectChemicals);
|
|
|
|
SubscribeLocalEvent<InfestedBorerComponent, BorerScanInstantActionEvent>(OnBorerScan);
|
|
SubscribeLocalEvent<BorerComponent, BorerStunActionEvent>(OnStunEvent);
|
|
|
|
SubscribeLocalEvent<InfestedBorerComponent, BorerBrainTakeEvent>(OnTakeControl);
|
|
SubscribeLocalEvent<InfestedBorerComponent, BorerBrainTakeAfterEvent>(OnTakeControlAfter);
|
|
|
|
SubscribeLocalEvent<BorerHostComponent, BorerBrainReleaseEvent>(OnReleaseControl);
|
|
|
|
SubscribeLocalEvent<BorerHostComponent, BorerReproduceEvent>(OnReproduce);
|
|
SubscribeLocalEvent<BorerHostComponent, BorerReproduceAfterEvent>(OnReproduceAfter);
|
|
SubscribeLocalEvent<InfestedBorerComponent, BorerBrainResistAfterEvent>(OnResistAfterControl);
|
|
}
|
|
|
|
private void OnReproduceAfter(EntityUid uid, BorerHostComponent component, BorerReproduceAfterEvent args)
|
|
{
|
|
if (args.Cancelled
|
|
|| !TryComp(component.BorerContainer.ContainedEntities[0], out InfestedBorerComponent? borerComp)
|
|
|| !WithrawPoints(component.BorerContainer.ContainedEntities[0], borerComp.ReproduceCost)
|
|
|| !TryComp(uid, out TransformComponent? targetTransform))
|
|
{
|
|
return;
|
|
}
|
|
|
|
args.Handled = true;
|
|
_vomitSystem.Vomit(uid, -30, -30);
|
|
_entityManager.SpawnEntity("MobSimpleBorer", targetTransform.Coordinates);
|
|
}
|
|
|
|
private void OnReproduce(EntityUid uid, BorerHostComponent component, BorerReproduceEvent args)
|
|
{
|
|
if (!TryComp(component.BorerContainer.ContainedEntities[0], out InfestedBorerComponent? borerComp))
|
|
return;
|
|
|
|
if (GetPoints(component.BorerContainer.ContainedEntities[0]) < borerComp.ReproduceCost)
|
|
{
|
|
_popup.PopupEntity(Loc.GetString("borer-popup-lowchem"), uid, uid, PopupType.LargeCaution);
|
|
return;
|
|
}
|
|
|
|
args.Handled = true;
|
|
|
|
_doAfterSystem.TryStartDoAfter(
|
|
new DoAfterArgs(EntityManager, uid, TimeSpan.FromSeconds(3), new BorerReproduceAfterEvent(), uid)
|
|
{
|
|
Hidden = true
|
|
});
|
|
}
|
|
|
|
public void ReleaseControl(EntityUid borerUid)
|
|
{
|
|
if (!TryComp(borerUid, out ActionsComponent? wormActComp)
|
|
|| !TryComp(borerUid, out InfestedBorerComponent? borComp)
|
|
|| !borComp.Host.HasValue
|
|
|| !borComp.ControllingBrain)
|
|
{
|
|
return;
|
|
}
|
|
|
|
TryComp(borComp.Host.Value, out ActionsComponent? bodyActComp);
|
|
var wormHasMind = _mindSystem.TryGetMind(borerUid, out var hostMindId, out var hostMind);
|
|
var bodyHasMind = _mindSystem.TryGetMind(borComp.Host.Value, out var mindId, out var mind);
|
|
if (!bodyHasMind && !wormHasMind)
|
|
return;
|
|
|
|
if (wormHasMind)
|
|
_mindSystem.TransferTo(hostMindId, borComp.Host.Value, mind: hostMind);
|
|
|
|
if (bodyHasMind)
|
|
_mindSystem.TransferTo(mindId, borerUid, mind: mind);
|
|
|
|
_sharedBorerSystem.AddInfestedAbilities(borerUid, borComp);
|
|
|
|
_action.RemoveAction(borerUid, borComp.ActionBorerBrainResistEntity, wormActComp);
|
|
|
|
_action.RemoveAction(borComp.Host.Value, borComp.ActionBorerBrainReleaseEntity, bodyActComp);
|
|
|
|
_action.RemoveAction(borComp.Host.Value, borComp.ActionBorerReproduceEntity, bodyActComp);
|
|
|
|
borComp.ControllingBrain = false;
|
|
Dirty(borerUid, borComp);
|
|
}
|
|
|
|
private void OnReleaseControl(EntityUid uid, BorerHostComponent component, BorerBrainReleaseEvent args)
|
|
{
|
|
args.Handled = true;
|
|
ReleaseControl(component.BorerContainer.ContainedEntities[0]);
|
|
}
|
|
|
|
private void OnResistAfterControl(EntityUid uid, InfestedBorerComponent component, BorerBrainResistAfterEvent args)
|
|
{
|
|
if (args.Cancelled)
|
|
return;
|
|
|
|
ReleaseControl(uid);
|
|
}
|
|
|
|
private void OnTakeControl(EntityUid uid, InfestedBorerComponent component, BorerBrainTakeEvent args)
|
|
{
|
|
if (GetPoints(uid) < component.AssumeControlCost)
|
|
{
|
|
_popup.PopupEntity(Loc.GetString("borer-popup-lowchem"), uid, uid, PopupType.LargeCaution);
|
|
return;
|
|
}
|
|
|
|
if (GetSugarQuantityInHost(uid) > 0)
|
|
{
|
|
_popup.PopupEntity(Loc.GetString("borer-popup-toomuchsugar"), uid, uid, PopupType.LargeCaution);
|
|
}
|
|
|
|
if (TryComp(component.Host, out MobStateComponent? state) && state.CurrentState == MobState.Critical)
|
|
{
|
|
_popup.PopupEntity(Loc.GetString("borer-popup-braintake-critical"), uid, uid, PopupType.LargeCaution);
|
|
return;
|
|
}
|
|
|
|
args.Handled = true;
|
|
_doAfterSystem.TryStartDoAfter(
|
|
new DoAfterArgs(EntityManager, uid, TimeSpan.FromSeconds(30), new BorerBrainTakeAfterEvent(), uid)
|
|
{
|
|
Hidden = true
|
|
});
|
|
}
|
|
|
|
private void OnTakeControlAfter(EntityUid uid, InfestedBorerComponent component, BorerBrainTakeAfterEvent args)
|
|
{
|
|
if (args.Cancelled)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!TryComp(uid, out ActionsComponent? comp) || !TryComp(component.Host, out ActionsComponent? hostComp))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (TryComp(component.Host, out MobStateComponent? state) && state.CurrentState == MobState.Critical)
|
|
{
|
|
_popup.PopupEntity(Loc.GetString("borer-popup-braintake-critical"), uid, uid, PopupType.LargeCaution);
|
|
return;
|
|
}
|
|
|
|
if (GetSugarQuantityInHost(uid) > 0)
|
|
{
|
|
_popup.PopupEntity(Loc.GetString("borer-popup-toomuchsugar"), uid, uid, PopupType.LargeCaution);
|
|
return;
|
|
}
|
|
|
|
if (!WithrawPoints(uid, component.AssumeControlCost))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var borHasMind = _mindSystem.TryGetMind(uid, out var mindId, out var mind);
|
|
var hostHasMind = _mindSystem.TryGetMind(component.Host.Value, out var hostMindId, out var hostMind);
|
|
|
|
if (!borHasMind && !hostHasMind)
|
|
return;
|
|
|
|
if (borHasMind)
|
|
{
|
|
_mindSystem.TransferTo(mindId, component.Host, mind: mind);
|
|
_popup.PopupEntity(Loc.GetString("borer-popup-braintake-success"), component.Host.Value,
|
|
component.Host.Value, PopupType.Large);
|
|
}
|
|
|
|
if (hostHasMind)
|
|
{
|
|
_mindSystem.TransferTo(hostMindId, uid, mind: hostMind);
|
|
_popup.PopupEntity(Loc.GetString("borer-popup-braintake-alert"), uid, uid, PopupType.LargeCaution);
|
|
if (EntityManager.TryGetComponent(uid, out ActorComponent? actor))
|
|
{
|
|
_chatManager.ChatMessageToOne(ChatChannel.Local,
|
|
Loc.GetString("borer-message-braintake-alert"),
|
|
Loc.GetString("borer-message-braintake-alert"),
|
|
EntityUid.Invalid, false, actor.PlayerSession.Channel);
|
|
}
|
|
}
|
|
|
|
_action.RemoveAction(uid, component.ActionBorerOutEntity, comp);
|
|
_action.RemoveAction(uid, component.ActionBorerScanEntity, comp);
|
|
_action.RemoveAction(uid, component.ActionBorerBrainTakeEntity, comp);
|
|
_action.RemoveAction(uid, component.ActionBorerInjectWindowOpenEntity, comp);
|
|
_action.RemoveAction(uid, component.ActionBorerReproduceEntity, comp);
|
|
|
|
_action.AddAction(uid, ref component.ActionBorerBrainResistEntity,
|
|
component.ActionBorerBrainResist, component: comp);
|
|
|
|
_action.AddAction(component.Host.Value, ref component.ActionBorerBrainReleaseEntity,
|
|
component.ActionBorerBrainRelease, component: hostComp);
|
|
|
|
_action.AddAction(component.Host.Value, ref component.ActionBorerReproduceEntity,
|
|
component.ActionBorerReproduce, component: hostComp);
|
|
|
|
if (component.ActionBorerReproduceEntity.HasValue)
|
|
{
|
|
_metaData.SetEntityName(component.ActionBorerReproduceEntity.Value,
|
|
$"{Loc.GetString("borer-abilities-reproduce-name")} ([color=red]{component.ReproduceCost}c[/color])");
|
|
}
|
|
|
|
component.ControllingBrain = true;
|
|
Dirty(uid, component);
|
|
}
|
|
|
|
private void OnStunEvent(EntityUid uid, BorerComponent component, BorerStunActionEvent args)
|
|
{
|
|
_stuns.TryParalyze(args.Target, TimeSpan.FromSeconds(5.7f), true);
|
|
args.Handled = true;
|
|
}
|
|
|
|
private void OnInfest(EntityUid uid, BorerComponent component, BorerInfestActionEvent args)
|
|
{
|
|
if (!HasComp<HumanoidAppearanceComponent>(args.Target)
|
|
|| HasComp<ChangelingComponent>(args.Target)
|
|
|| HasComp<BorgChassisComponent>(args.Target))
|
|
{
|
|
_popup.PopupEntity(Loc.GetString("borer-popup-infest-failed"), uid, uid);
|
|
return;
|
|
}
|
|
|
|
if (TryComp(args.Target, out MobStateComponent? state) && state.CurrentState == MobState.Dead)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (HasComp<BorerHostComponent>(args.Target))
|
|
{
|
|
_popup.PopupEntity(Loc.GetString("borer-popup-infest-occupied"), uid, uid);
|
|
args.Handled = true;
|
|
return;
|
|
}
|
|
|
|
if (GetSugarQuantityInEntity(args.Target) > 10)
|
|
{
|
|
_popup.PopupEntity(Loc.GetString("borer-popup-infest-sugar"), uid, uid, PopupType.LargeCaution);
|
|
args.Handled = true;
|
|
return;
|
|
}
|
|
|
|
StartInfest(uid, args.Target);
|
|
args.Handled = true;
|
|
}
|
|
|
|
private void OnInfestAfter(EntityUid uid, BorerComponent component, BorerInfestDoAfterEvent args)
|
|
{
|
|
if (args.Cancelled)
|
|
return;
|
|
|
|
if (!HasComp<HumanoidAppearanceComponent>(args.Target))
|
|
return;
|
|
|
|
if (TryComp(args.Target, out MobStateComponent? state) && state.CurrentState == MobState.Dead)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (HasComp<BorerHostComponent>(args.Target))
|
|
{
|
|
_popup.PopupEntity(Loc.GetString("borer-popup-infest-occupied"), uid, uid);
|
|
args.Handled = true;
|
|
return;
|
|
}
|
|
|
|
if (GetSugarQuantityInHost(uid) > 10)
|
|
{
|
|
_popup.PopupEntity(Loc.GetString("borer-popup-infest-sugar"), uid, uid, PopupType.LargeCaution);
|
|
args.Handled = true;
|
|
return;
|
|
}
|
|
|
|
var hostComp = AddComp<BorerHostComponent>(args.Target.Value);
|
|
hostComp.BorerContainer = _container.EnsureContainer<Container>(args.Target.Value, "borerContainer");
|
|
_container.Insert(uid, hostComp.BorerContainer);
|
|
|
|
var infestedComponent = AddComp<InfestedBorerComponent>(uid);
|
|
infestedComponent.Host = args.Target;
|
|
infestedComponent.Points = component.Points;
|
|
Dirty(uid, infestedComponent);
|
|
|
|
_godmodeSystem.EnableGodmode(uid);
|
|
|
|
RemComp<BorerComponent>(uid);
|
|
}
|
|
|
|
private void StartInfest(EntityUid user, EntityUid target)
|
|
{
|
|
_doAfterSystem.TryStartDoAfter(
|
|
new DoAfterArgs(EntityManager, user, TimeSpan.FromSeconds(5), new BorerInfestDoAfterEvent(), user, target)
|
|
{
|
|
BreakOnMove = true,
|
|
Hidden = true
|
|
});
|
|
}
|
|
|
|
private void OnBorerScan(EntityUid uid, InfestedBorerComponent component, BorerScanInstantActionEvent args)
|
|
{
|
|
if (!component.Host.HasValue)
|
|
return;
|
|
|
|
Dictionary<string, FixedPoint2> solution = new();
|
|
if (EntityManager.TryGetComponent(component.Host.Value, out BloodstreamComponent? bloodContainer))
|
|
{
|
|
if (_solutionContainerSystem.TryGetSolution(component.Host.Value, bloodContainer.ChemicalSolutionName,
|
|
out var sol))
|
|
{
|
|
foreach (var reagent in sol.Value.Comp.Solution)
|
|
{
|
|
solution.Add(reagent.Reagent.ToString(), reagent.Quantity);
|
|
}
|
|
}
|
|
}
|
|
|
|
RaiseNetworkEvent(new BorerScanDoAfterEvent(solution), uid);
|
|
args.Handled = true;
|
|
}
|
|
|
|
public override void Update(float frameTime)
|
|
{
|
|
base.Update(frameTime);
|
|
|
|
var infestedQuery = EntityQueryEnumerator<InfestedBorerComponent>();
|
|
while (infestedQuery.MoveNext(out var uid, out var comp) && comp.Host is not null)
|
|
{
|
|
if (comp.PointUpdateNext == TimeSpan.Zero)
|
|
{
|
|
comp.PointUpdateNext = _timing.CurTime + comp.PointUpdateRate;
|
|
continue;
|
|
}
|
|
|
|
if (_timing.CurTime < comp.PointUpdateNext)
|
|
continue;
|
|
|
|
if (GetSugarQuantityInHost(uid) > 30)
|
|
{
|
|
GetOut(uid);
|
|
_popup.PopupEntity(Loc.GetString("borer-popup-sugarleave"), uid, uid, PopupType.LargeCaution);
|
|
return;
|
|
}
|
|
|
|
comp.PointUpdateNext += comp.PointUpdateRate;
|
|
AddPoints(uid, comp.PointUpdateValue);
|
|
Dirty(uid, comp);
|
|
}
|
|
}
|
|
|
|
private void OnTelepathicSpeech(EntityUid uid, InfestedBorerComponent component, BorerBrainSpeechActionEvent args)
|
|
{
|
|
if (!TryComp(uid, out ActorComponent? actor))
|
|
return;
|
|
|
|
_quickDialog.OpenDialog(actor.PlayerSession, Loc.GetString("borer-ui-converse-title"),
|
|
Loc.GetString("borer-ui-converse-message"), (string message) =>
|
|
{
|
|
_popup.PopupEntity(message, uid, uid, PopupType.Medium);
|
|
|
|
if (EntityManager.TryGetComponent(component.Host, out ActorComponent? _))
|
|
{
|
|
_popup.PopupEntity(message, component.Host.Value, component.Host.Value,
|
|
PopupType.Medium);
|
|
}
|
|
});
|
|
|
|
args.Handled = true;
|
|
}
|
|
|
|
private void OnInjectChemicals(BorerInjectActionEvent injectEvent, EntitySessionEventArgs eventArgs)
|
|
{
|
|
var borerEn = eventArgs.SenderSession.AttachedEntity;
|
|
if (!TryComp(borerEn, out InfestedBorerComponent? infestedComponent) || !infestedComponent.Host.HasValue)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!WithrawPoints(borerEn.Value, injectEvent.Cost))
|
|
return;
|
|
|
|
var solution = new Solution();
|
|
solution.AddReagent(injectEvent.ProtoId, 10);
|
|
_bloodstreamSystem.TryAddToChemicals(infestedComponent.Host.Value, solution);
|
|
_reactiveSystem.DoEntityReaction(infestedComponent.Host.Value, solution, ReactionMethod.Injection);
|
|
|
|
_popup.PopupEntity(Loc.GetString("borer-popup-injected", ("reagent", Loc.GetString("reagent-name-" +
|
|
injectEvent.ProtoId.ToLower().Replace("spacedrugs", "space-drugs")))),
|
|
borerEn.Value, borerEn.Value, PopupType.Medium);
|
|
}
|
|
|
|
public bool AddPoints(EntityUid borerUid, int value)
|
|
{
|
|
if (!TryComp(borerUid, out InfestedBorerComponent? infestedComponent))
|
|
return false;
|
|
|
|
infestedComponent.Points += value;
|
|
Dirty(borerUid, infestedComponent);
|
|
RaiseNetworkEvent(new BorerPointsUpdateEvent());
|
|
return true;
|
|
}
|
|
|
|
public int GetPoints(EntityUid borerUid)
|
|
{
|
|
return TryComp(borerUid, out InfestedBorerComponent? infestedComponent)
|
|
? infestedComponent.Points
|
|
: 0;
|
|
}
|
|
|
|
public bool WithrawPoints(EntityUid borerUid, int value)
|
|
{
|
|
if (!TryComp(borerUid, out InfestedBorerComponent? infestedComponent) || infestedComponent.Points < value)
|
|
{
|
|
_popup.PopupEntity(Loc.GetString("borer-popup-lowchem"), borerUid, borerUid, PopupType.LargeCaution);
|
|
return false;
|
|
}
|
|
|
|
infestedComponent.Points -= value;
|
|
Dirty(borerUid, infestedComponent);
|
|
RaiseNetworkEvent(new BorerPointsUpdateEvent());
|
|
return true;
|
|
}
|
|
|
|
private void OnGetOut(EntityUid uid, InfestedBorerComponent component, BorerOutActionEvent args)
|
|
{
|
|
GetOut(uid);
|
|
}
|
|
|
|
public void GetOut(EntityUid uid)
|
|
{
|
|
if (!TryComp(uid, out InfestedBorerComponent? component) ||
|
|
!TryComp(component.Host, out BorerHostComponent? hostComponent))
|
|
{
|
|
return;
|
|
}
|
|
|
|
ReleaseControl(uid);
|
|
|
|
_vomitSystem.Vomit(component.Host.Value, -20, -20);
|
|
_container.Remove(uid, hostComponent.BorerContainer);
|
|
RemComp<BorerHostComponent>(component.Host.Value);
|
|
|
|
var borerComponent = AddComp<BorerComponent>(uid);
|
|
borerComponent.Points = component.Points;
|
|
Dirty(uid, borerComponent);
|
|
|
|
_godmodeSystem.DisableGodmode(uid);
|
|
|
|
RemComp<InfestedBorerComponent>(uid);
|
|
_action.SetCooldown(borerComponent.ActionStunEntity, _timing.CurTime,
|
|
_timing.CurTime + TimeSpan.FromSeconds(20));
|
|
|
|
_action.SetCooldown(borerComponent.ActionInfestEntity, _timing.CurTime,
|
|
_timing.CurTime + TimeSpan.FromSeconds(20));
|
|
}
|
|
|
|
public int GetSugarQuantityInHost(EntityUid borerUid)
|
|
{
|
|
var sugarQuantity = 0;
|
|
if (TryComp(borerUid, out InfestedBorerComponent? component) && component.Host.HasValue)
|
|
{
|
|
sugarQuantity = GetSugarQuantityInEntity(component.Host.Value);
|
|
}
|
|
|
|
return sugarQuantity;
|
|
}
|
|
|
|
public int GetSugarQuantityInEntity(EntityUid uid)
|
|
{
|
|
if (!TryComp(uid, out BloodstreamComponent? bloodContainer))
|
|
return 0;
|
|
|
|
if (!_solutionContainerSystem.TryGetSolution(uid, bloodContainer.ChemicalSolutionName, out var sol))
|
|
return 0;
|
|
|
|
foreach (var reagent in sol.Value.Comp.Solution)
|
|
{
|
|
if (reagent.Reagent.ToString() == SugarPrototype)
|
|
{
|
|
return reagent.Quantity.Int();
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
} |