// Fill blood solution with BLOOD
// The DNA string might not be initialized yet, but the reagent data gets updated in the GenerateDnaEvent subscription
- bloodSolution.AddReagent(new ReagentId(entity.Comp.BloodReagent, GetEntityBloodData(entity.Owner)), entity.Comp.BloodMaxVolume - bloodSolution.Volume);
+ var solution = entity.Comp.BloodReagents.Clone();
+ solution.ScaleTo(entity.Comp.BloodMaxVolume - bloodSolution.Volume);
+ solution.SetReagentData(GetEntityBloodData(entity.Owner));
+ bloodSolution.AddSolution(solution, PrototypeManager);
}
// forensics is not predicted yet
+using Content.Shared.Chemistry.Components;
using Content.Shared.Storage;
namespace Content.Server.Medical.BiomassReclaimer
public float CurrentExpectedYield = 0f;
/// <summary>
- /// The reagent that will be spilled while processing a mob.
+ /// The reagents that will be spilled while processing a mob.
/// </summary>
[ViewVariables]
- public string? BloodReagent;
+ public Solution? BloodReagents = null;
/// <summary>
/// Entities that can be randomly spawned while processing a mob.
using Content.Shared.Audio;
using Content.Shared.Body.Components;
using Content.Shared.CCVar;
-using Content.Shared.Chemistry.Components;
+using Content.Shared.Chemistry.EntitySystems;
using Content.Shared.Climbing.Events;
using Content.Shared.Construction.Components;
using Content.Shared.Database;
[Dependency] private readonly SharedAmbientSoundSystem _ambientSoundSystem = default!;
[Dependency] private readonly SharedPopupSystem _popup = default!;
[Dependency] private readonly PuddleSystem _puddleSystem = default!;
+ [Dependency] private readonly SharedSolutionContainerSystem _solution = default!;
[Dependency] private readonly ThrowingSystem _throwing = default!;
[Dependency] private readonly IRobustRandom _robustRandom = default!;
[Dependency] private readonly ISharedAdminLogManager _adminLogger = default!;
if (reclaimer.RandomMessTimer <= 0)
{
- if (_robustRandom.Prob(0.2f) && reclaimer.BloodReagent is not null)
+ if (_robustRandom.Prob(0.2f) && reclaimer.BloodReagents is { } blood)
{
- Solution blood = new();
- blood.AddReagent(reclaimer.BloodReagent, 50);
_puddleSystem.TrySpillAt(uid, blood, out _);
}
if (_robustRandom.Prob(0.03f) && reclaimer.SpawnedEntities.Count > 0)
reclaimer.CurrentExpectedYield = reclaimer.CurrentExpectedYield - actualYield; // store non-integer leftovers
_material.SpawnMultipleFromMaterial(actualYield, BiomassPrototype, Transform(uid).Coordinates);
- reclaimer.BloodReagent = null;
+ reclaimer.BloodReagents = null;
reclaimer.SpawnedEntities.Clear();
RemCompDeferred<ActiveBiomassReclaimerComponent>(uid);
}
var component = ent.Comp;
AddComp<ActiveBiomassReclaimerComponent>(ent);
- if (TryComp<BloodstreamComponent>(toProcess, out var stream))
+ if (TryComp<BloodstreamComponent>(toProcess, out var stream) &&
+ _solution.ResolveSolution(toProcess, stream.BloodSolutionName, ref stream.BloodSolution, out var solution))
{
- component.BloodReagent = stream.BloodReagent;
+ component.BloodReagents = solution.Clone();
+ component.BloodReagents.ScaleSolution(50 / component.BloodReagents.Volume);
}
if (TryComp<ButcherableComponent>(toProcess, out var butcherableComponent))
{
using Content.Shared.Body.Components;
using Content.Shared.CombatMode;
using Content.Shared.CombatMode.Pacification;
-using Content.Shared.Damage.Components;
using Content.Shared.Hands.Components;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Humanoid;
zombiecomp.BeforeZombifiedSkinColor = huApComp.SkinColor;
zombiecomp.BeforeZombifiedEyeColor = huApComp.EyeColor;
zombiecomp.BeforeZombifiedCustomBaseLayers = new(huApComp.CustomBaseLayers);
- if (TryComp<BloodstreamComponent>(target, out var stream))
- zombiecomp.BeforeZombifiedBloodReagent = stream.BloodReagent;
+ if (TryComp<BloodstreamComponent>(target, out var stream) && stream.BloodReagents is { } reagents)
+ zombiecomp.BeforeZombifiedBloodReagents = reagents.Clone();
_humanoidAppearance.SetSkinColor(target, zombiecomp.SkinColor, verify: false, humanoid: huApComp);
//NOTE: they are supposed to bleed, just not take damage
_bloodstream.SetBloodLossThreshold(target, 0f);
//Give them zombie blood
- _bloodstream.ChangeBloodReagent(target, zombiecomp.NewBloodReagent);
+ _bloodstream.ChangeBloodReagents(target, zombiecomp.NewBloodReagents);
//This is specifically here to combat insuls, because frying zombies on grilles is funny as shit.
_inventory.TryUnequip(target, "gloves", true, true);
appcomp.EyeColor = zombiecomp.BeforeZombifiedEyeColor;
}
_humanoidAppearance.SetSkinColor(target, zombiecomp.BeforeZombifiedSkinColor, false);
- _bloodstream.ChangeBloodReagent(target, zombiecomp.BeforeZombifiedBloodReagent);
+ _bloodstream.ChangeBloodReagents(target, zombiecomp.BeforeZombifiedBloodReagents);
return true;
}
using Content.Shared.Alert;
using Content.Shared.Body.Systems;
using Content.Shared.Chemistry.Components;
-using Content.Shared.Chemistry.Reagent;
using Content.Shared.Damage;
using Content.Shared.Damage.Prototypes;
using Content.Shared.FixedPoint;
public FixedPoint2 BloodMaxVolume = FixedPoint2.New(300);
/// <summary>
- /// Which reagent is considered this entities 'blood'?
+ /// Which reagents are considered this entities 'blood'?
/// </summary>
/// <remarks>
/// Slime-people might use slime as their blood or something like that.
/// </remarks>
[DataField, AutoNetworkedField]
- public ProtoId<ReagentPrototype> BloodReagent = "Blood";
+ public Solution BloodReagents = new([new("Blood", 1)]);
/// <summary>
/// Name/Key that <see cref="BloodSolution"/> is indexed by.
{
public static readonly EntProtoId Bloodloss = "StatusEffectBloodloss";
+ [Dependency] protected readonly IPrototypeManager PrototypeManager = default!;
[Dependency] protected readonly SharedSolutionContainerSystem SolutionContainer = default!;
[Dependency] private readonly IGameTiming _timing = default!;
- [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
[Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly SharedPopupSystem _popup = default!;
[Dependency] private readonly SharedPuddleSystem _puddle = default!;
}
// TODO probably cache this or something. humans get hurt a lot
- if (!_prototypeManager.Resolve(ent.Comp.DamageBleedModifiers, out var modifiers))
+ if (!PrototypeManager.Resolve(ent.Comp.DamageBleedModifiers, out var modifiers))
return;
// some reagents may deal and heal different damage types in the same tick, which means DamageIncreased will be true
public bool TryModifyBloodLevel(Entity<BloodstreamComponent?> ent, FixedPoint2 amount)
{
if (!Resolve(ent, ref ent.Comp, logMissing: false)
- || !SolutionContainer.ResolveSolution(ent.Owner, ent.Comp.BloodSolutionName, ref ent.Comp.BloodSolution))
+ || !SolutionContainer.ResolveSolution(ent.Owner, ent.Comp.BloodSolutionName, ref ent.Comp.BloodSolution, out var bloodSolution))
return false;
if (amount >= 0)
- return SolutionContainer.TryAddReagent(ent.Comp.BloodSolution.Value, ent.Comp.BloodReagent, amount, null, GetEntityBloodData(ent));
+ {
+ var min = FixedPoint2.Min(bloodSolution.AvailableVolume, amount);
+ var solution = ent.Comp.BloodReagents.Clone();
+ solution.ScaleTo(min);
+ solution.SetReagentData(GetEntityBloodData(ent));
+ SolutionContainer.AddSolution(ent.Comp.BloodSolution.Value, solution);
+ return min == amount;
+ }
// Removal is more involved,
// since we also wanna handle moving it to the temporary solution
if (!SolutionContainer.ResolveSolution(ent.Owner, ent.Comp.BloodTemporarySolutionName, ref ent.Comp.TemporarySolution, out var tempSolution))
return true;
- tempSolution.AddSolution(newSol, _prototypeManager);
+ tempSolution.AddSolution(newSol, PrototypeManager);
if (tempSolution.Volume > ent.Comp.BleedPuddleThreshold)
{
if (SolutionContainer.ResolveSolution(ent.Owner, ent.Comp.ChemicalSolutionName, ref ent.Comp.ChemicalSolution))
{
var temp = SolutionContainer.SplitSolution(ent.Comp.ChemicalSolution.Value, tempSolution.Volume / 10);
- tempSolution.AddSolution(temp, _prototypeManager);
+ tempSolution.AddSolution(temp, PrototypeManager);
}
_puddle.TrySpillAt(ent.Owner, tempSolution, out _, sound: false);
if (SolutionContainer.ResolveSolution(ent.Owner, ent.Comp.BloodSolutionName, ref ent.Comp.BloodSolution, out var bloodSolution))
{
tempSol.MaxVolume += bloodSolution.MaxVolume;
- tempSol.AddSolution(bloodSolution, _prototypeManager);
+ tempSol.AddSolution(bloodSolution, PrototypeManager);
SolutionContainer.RemoveAllSolution(ent.Comp.BloodSolution.Value);
}
if (SolutionContainer.ResolveSolution(ent.Owner, ent.Comp.ChemicalSolutionName, ref ent.Comp.ChemicalSolution, out var chemSolution))
{
tempSol.MaxVolume += chemSolution.MaxVolume;
- tempSol.AddSolution(chemSolution, _prototypeManager);
+ tempSol.AddSolution(chemSolution, PrototypeManager);
SolutionContainer.RemoveAllSolution(ent.Comp.ChemicalSolution.Value);
}
if (SolutionContainer.ResolveSolution(ent.Owner, ent.Comp.BloodTemporarySolutionName, ref ent.Comp.TemporarySolution, out var tempSolution))
{
tempSol.MaxVolume += tempSolution.MaxVolume;
- tempSol.AddSolution(tempSolution, _prototypeManager);
+ tempSol.AddSolution(tempSolution, PrototypeManager);
SolutionContainer.RemoveAllSolution(ent.Comp.TemporarySolution.Value);
}
/// <summary>
/// Change what someone's blood is made of, on the fly.
/// </summary>
+ [Obsolete("ChangeBloodReagent is obsolete, please use ChangeBloodReagents.")]
public void ChangeBloodReagent(Entity<BloodstreamComponent?> ent, ProtoId<ReagentPrototype> reagent)
{
- if (!Resolve(ent, ref ent.Comp, logMissing: false)
- || reagent == ent.Comp.BloodReagent)
+ ChangeBloodReagents(ent, new([new(reagent, 1)]));
+ }
+
+ /// <summary>
+ /// Change what someone's blood is made of, on the fly.
+ /// </summary>
+ public void ChangeBloodReagents(Entity<BloodstreamComponent?> ent, Solution reagents)
+ {
+ if (!Resolve(ent, ref ent.Comp, logMissing: false))
{
return;
}
if (!SolutionContainer.ResolveSolution(ent.Owner, ent.Comp.BloodSolutionName, ref ent.Comp.BloodSolution, out var bloodSolution))
{
- ent.Comp.BloodReagent = reagent;
+ ent.Comp.BloodReagents = reagents.Clone();
+ DirtyField(ent, ent.Comp, nameof(BloodstreamComponent.BloodReagents));
return;
}
- var currentVolume = bloodSolution.RemoveReagent(ent.Comp.BloodReagent, bloodSolution.Volume, ignoreReagentData: true);
+ var currentVolume = FixedPoint2.Zero;
+ foreach (var reagent in ent.Comp.BloodReagents)
+ {
+ currentVolume += bloodSolution.RemoveReagent(reagent.Reagent, quantity: bloodSolution.Volume, ignoreReagentData: true);
+ }
+
+ ent.Comp.BloodReagents = reagents.Clone();
+ DirtyField(ent, ent.Comp, nameof(BloodstreamComponent.BloodReagents));
- ent.Comp.BloodReagent = reagent;
- DirtyField(ent, ent.Comp, nameof(BloodstreamComponent.BloodReagent));
+ if (currentVolume == FixedPoint2.Zero)
+ return;
- if (currentVolume > 0)
- SolutionContainer.TryAddReagent(ent.Comp.BloodSolution.Value, ent.Comp.BloodReagent, currentVolume, null, GetEntityBloodData(ent));
+ var solution = ent.Comp.BloodReagents.Clone();
+ solution.ScaleSolution(currentVolume / solution.Volume);
+ solution.SetReagentData(GetEntityBloodData(ent));
+ SolutionContainer.AddSolution(ent.Comp.BloodSolution.Value, solution);
}
/// <summary>
public Solution(Solution solution)
{
- Contents = solution.Contents.ShallowClone();
+ Contents = new(solution.Contents.Count);
+ foreach (var item in solution.Contents)
+ {
+ Contents.Add(item.Clone());
+ }
+
Volume = solution.Volume;
MaxVolume = solution.MaxVolume;
Temperature = solution.Temperature;
ValidateSolution();
}
+ /// <summary>
+ /// Scales the amount of solution.
+ /// </summary>
+ /// <param name="scale">The scalar to modify the solution by.</param>
+ public void ScaleSolution(FixedPoint2 scale)
+ {
+ ScaleSolution(scale.Float());
+ }
+
+ /// <summary>
+ /// Scales the amount of solution to a given target.
+ /// </summary>
+ /// <param name="target">The volume the solutions should have after scaling.</param>
+ public void ScaleTo(FixedPoint2 target)
+ {
+ if (Volume == FixedPoint2.Zero || Volume == target)
+ return;
+
+ if (target == FixedPoint2.Zero)
+ {
+ RemoveAllSolution();
+ return;
+ }
+
+ var nearestIntScale = (int)Math.Ceiling(target.Float() / Volume.Float());
+ ScaleSolution(nearestIntScale);
+
+ var overflow = Volume - target;
+ RemoveSolution(overflow);
+ }
+
/// <summary>
/// Attempts to remove an amount of reagent from the solution.
/// </summary>
}
return dict;
}
+
+ public void SetReagentData(List<ReagentData>? data)
+ {
+ for (var i = 0; i < Contents.Count; i++)
+ {
+ var old = Contents[i];
+ Contents[i] = new ReagentQuantity(new ReagentId(old.Reagent.Prototype, data), old.Quantity);
+ }
+ ValidateSolution();
+ }
}
}
-using Content.Shared.FixedPoint;
using Robust.Shared.Serialization;
namespace Content.Shared.Chemistry.Reagent;
public sealed partial class DnaData : ReagentData
{
[DataField]
- public string DNA = String.Empty;
+ public string DNA = string.Empty;
- public override ReagentData Clone() => this;
+ public override ReagentData Clone()
+ {
+ return new DnaData
+ {
+ DNA = DNA,
+ };
+ }
public override bool Equals(ReagentData? other)
{
/// </summary>
[Serializable, NetSerializable]
[DataDefinition]
-public partial struct ReagentQuantity : IEquatable<ReagentQuantity>
+public partial struct ReagentQuantity : IEquatable<ReagentQuantity>, IRobustCloneable<ReagentQuantity>
{
- [DataField("Quantity", required:true)]
+ [DataField("Quantity", required: true)]
public FixedPoint2 Quantity { get; private set; }
[IncludeDataField]
Quantity = quantity;
}
+ public ReagentQuantity(ReagentQuantity reagentQuantity)
+ {
+ Quantity = reagentQuantity.Quantity;
+ if (reagentQuantity.Reagent.Data is not { } data)
+ {
+ Reagent = new ReagentId(reagentQuantity.Reagent.Prototype, null);
+ return;
+ }
+
+ List<ReagentData> copy = new(data.Count);
+ foreach (var item in data)
+ {
+ copy.Add(item.Clone());
+ }
+ Reagent = new ReagentId(reagentQuantity.Reagent.Prototype, copy);
+ }
+
+ public readonly ReagentQuantity Clone()
+ {
+ return new ReagentQuantity(this);
+ }
+
public ReagentQuantity() : this(default, default)
{
}
using Content.Shared.Chat.Prototypes;
+using Content.Shared.Chemistry.Components;
using Content.Shared.Chemistry.Reagent;
using Content.Shared.Damage;
-using Content.Shared.FixedPoint;
using Content.Shared.Humanoid;
using Content.Shared.Roles;
using Content.Shared.StatusIcon;
public SoundSpecifier BiteSound = new SoundPathSpecifier("/Audio/Effects/bite.ogg");
/// <summary>
- /// The blood reagent of the humanoid to restore in case of cloning
+ /// The blood reagents of the humanoid to restore in case of cloning
/// </summary>
- [DataField("beforeZombifiedBloodReagent")]
- public string BeforeZombifiedBloodReagent = string.Empty;
+ [DataField("beforeZombifiedBloodReagents")]
+ public Solution BeforeZombifiedBloodReagents = new();
/// <summary>
- /// The blood reagent to give the zombie. In case you want zombies that bleed milk, or something.
+ /// The blood reagents to give the zombie. In case you want zombies that bleed milk, or something.
/// </summary>
- [DataField("newBloodReagent", customTypeSerializer: typeof(PrototypeIdSerializer<ReagentPrototype>))]
- public string NewBloodReagent = "ZombieBlood";
+ [DataField("newBloodReagents")]
+ public Solution NewBloodReagents = new([new("ZombieBlood", 1)]);
}
- Bee
- Trash
- type: Bloodstream
- bloodReagent: InsectBlood
+ bloodReagents:
+ reagents:
+ - ReagentId: InsectBlood
+ Quantity: 1
bloodMaxVolume: 0.1
- type: MobPrice
price: 50
Dead:
Base: cockroach_dead
- type: Bloodstream
- bloodReagent: InsectBlood
+ bloodReagents:
+ reagents:
+ - ReagentId: InsectBlood
+ Quantity: 1
bloodMaxVolume: 20
- type: Edible
- type: FlavorProfile
damageContainer: Biological
damageModifierSet: Moth
- type: Bloodstream
- bloodReagent: InsectBlood
+ bloodReagents:
+ reagents:
+ - ReagentId: InsectBlood
+ Quantity: 1
- type: Respirator
damage:
types:
tags:
- Trash
- type: Bloodstream
- bloodReagent: InsectBlood
+ bloodReagents:
+ reagents:
+ - ReagentId: InsectBlood
+ Quantity: 1
bloodMaxVolume: 0.1
- type: MobPrice
price: 50
accent: crab
- type: Bloodstream
bloodMaxVolume: 50
- bloodReagent: CopperBlood
+ bloodReagents:
+ reagents:
+ - ReagentId: CopperBlood
+ Quantity: 1
- type: Tag
tags:
- VimPilot
- type: RadiationSource
intensity: 0.3
- type: Bloodstream
- bloodReagent: UnstableMutagen
+ bloodReagents:
+ reagents:
+ - ReagentId: UnstableMutagen
+ Quantity: 1
- type: SolutionContainerManager
solutions:
food:
- type: IgnoreSpiderWeb
- type: Bloodstream
bloodMaxVolume: 150
- bloodReagent: CopperBlood
+ bloodReagents:
+ reagents:
+ - ReagentId: CopperBlood
+ Quantity: 1
- type: Speech
speechVerb: Arachnid
speechSounds: Arachnid
speechVerb: Cluwne
- type: Bloodstream
bloodMaxVolume: 150
- bloodReagent: Laughter
-
+ bloodReagents:
+ reagents:
+ - ReagentId: Laughter
+ Quantity: 1
- type: entity
name: wizard spider
parent: MobGiantSpider
attributes:
gender: epicene
- type: Bloodstream
- bloodReagent: DemonsBlood
+ bloodReagents:
+ reagents:
+ - ReagentId: DemonsBlood
+ Quantity: 1
- type: Damageable
damageContainer: BiologicalMetaphysical
damageModifierSet: Infernal
speciesId: cat
templateId: pet
- type: Bloodstream
- bloodReagent: Sap
+ bloodReagents:
+ reagents:
+ - ReagentId: Sap
+ Quantity: 1
bloodMaxVolume: 60
- type: DamageStateVisuals
states:
- type: ReplacementAccent
accent: xeno
- type: Bloodstream
- bloodReagent: FerrochromicAcid
+ bloodReagents:
+ reagents:
+ - ReagentId: FerrochromicAcid
+ Quantity: 1
bloodMaxVolume: 75 #we don't want the map to become pools of blood
bloodlossDamage:
types:
context: "human"
- type: Bloodstream
bloodMaxVolume: 300
- bloodReagent: Laughter
-
+ bloodReagents:
+ reagents:
+ - ReagentId: Laughter
+ Quantity: 1
- type: entity
name: behonker
parent: BaseMobBehonker
speedModifierThresholds:
50: 0.4
- type: Bloodstream
- bloodReagent: Water
+ bloodReagents:
+ reagents:
+ - ReagentId: Water
+ Quantity: 1
chemicalMaxVolume: 100
- type: StatusEffects
allowed:
suffix: Beer
components:
- type: Bloodstream
- bloodReagent: Beer
+ bloodReagents:
+ reagents:
+ - ReagentId: Beer
+ Quantity: 1
- type: PointLight
color: "#cfa85f"
- type: Sprite
suffix: Pax
components:
- type: Bloodstream
- bloodReagent: Pax
+ bloodReagents:
+ reagents:
+ - ReagentId: Pax
+ Quantity: 1
- type: PointLight
color: "#AAAAAA"
- type: Sprite
suffix: Nocturine
components:
- type: Bloodstream
- bloodReagent: Nocturine
+ bloodReagents:
+ reagents:
+ - ReagentId: Nocturine
+ Quantity: 1
- type: PointLight
color: "#128e80"
- type: Sprite
suffix: THC
components:
- type: Bloodstream
- bloodReagent: THC
+ bloodReagents:
+ reagents:
+ - ReagentId: THC
+ Quantity: 1
- type: PointLight
color: "#808080"
- type: Sprite
suffix: Bicaridine
components:
- type: Bloodstream
- bloodReagent: Bicaridine
+ bloodReagents:
+ reagents:
+ - ReagentId: Bicaridine
+ Quantity: 1
- type: PointLight
color: "#ffaa00"
- type: Sprite
suffix: Toxin
components:
- type: Bloodstream
- bloodReagent: Toxin
+ bloodReagents:
+ reagents:
+ - ReagentId: Toxin
+ Quantity: 1
- type: PointLight
color: "#cf3600"
- type: Sprite
suffix: Napalm
components:
- type: Bloodstream
- bloodReagent: Napalm
+ bloodReagents:
+ reagents:
+ - ReagentId: Napalm
+ Quantity: 1
- type: PointLight
color: "#FA00AF"
- type: Sprite
suffix: Omnizine
components:
- type: Bloodstream
- bloodReagent: Omnizine
+ bloodReagents:
+ reagents:
+ - ReagentId: Omnizine
+ Quantity: 1
- type: PointLight
color: "#fcf7f9"
- type: Sprite
suffix: Mute Toxin
components:
- type: Bloodstream
- bloodReagent: MuteToxin
+ bloodReagents:
+ reagents:
+ - ReagentId: MuteToxin
+ Quantity: 1
- type: PointLight
color: "#0f0f0f"
- type: Sprite
suffix: Norepinephric Acid
components:
- type: Bloodstream
- bloodReagent: NorepinephricAcid
+ bloodReagents:
+ reagents:
+ - ReagentId: NorepinephricAcid
+ Quantity: 1
- type: PointLight
color: "#96a8b5"
- type: Sprite
suffix: Ephedrine
components:
- type: Bloodstream
- bloodReagent: Ephedrine
+ bloodReagents:
+ reagents:
+ - ReagentId: Ephedrine
+ Quantity: 1
- type: PointLight
color: "#D2FFFA"
- type: Sprite
suffix: Robust Harvest
components:
- type: Bloodstream
- bloodReagent: RobustHarvest
+ bloodReagents:
+ reagents:
+ - ReagentId: RobustHarvest
+ Quantity: 1
- type: PointLight
color: "#3e901c"
- type: Sprite
- map: [ "enum.DamageStateVisualLayers.Base" ]
state: alive
- type: Bloodstream
- bloodReagent: JuiceTomato
+ bloodReagents:
+ reagents:
+ - ReagentId: JuiceTomato
+ Quantity: 1
bloodMaxVolume: 50
chemicalMaxVolume: 30
- type: DamageStateVisuals
damageContainer: Biological
damageModifierSet: Slime
- type: Bloodstream
- bloodReagent: Slime
+ bloodReagents:
+ reagents:
+ - ReagentId: Slime
+ Quantity: 1
bloodlossDamage:
types:
Bloodloss:
- type: MovementAlwaysTouching
- type: Bloodstream
bloodMaxVolume: 300
- bloodReagent: Cryoxadone
+ bloodReagents:
+ reagents:
+ - ReagentId: Cryoxadone
+ Quantity: 1
- type: CombatMode
- type: Temperature
heatDamageThreshold: 500
prob: 0.5
- type: Bloodstream
bloodMaxVolume: 250
- bloodReagent: Cryoxadone
+ bloodReagents:
+ reagents:
+ - ReagentId: Cryoxadone
+ Quantity: 1
- type: Fixtures
fixtures:
fix1:
prob: 0.3
- type: Bloodstream
bloodMaxVolume: 200
- bloodReagent: Cryoxadone
+ bloodReagents:
+ reagents:
+ - ReagentId: Cryoxadone
+ Quantity: 1
- type: Fixtures
fixtures:
fix1:
combatToggleAction: ActionCombatModeToggleOff
- type: Bloodstream
bloodMaxVolume: 30
- bloodReagent: Cryoxadone
+ bloodReagents:
+ reagents:
+ - ReagentId: Cryoxadone
+ Quantity: 1
- type: CanEscapeInventory
- type: MobPrice
price: 50
- type: Stamina
critThreshold: 200
- type: Bloodstream
- bloodReagent: FluorosulfuricAcid
+ bloodReagents:
+ reagents:
+ - ReagentId: FluorosulfuricAcid
+ Quantity: 1
bloodMaxVolume: 650
- type: MeleeWeapon
altDisarm: false
- type: Stamina
critThreshold: 200
- type: Bloodstream
- bloodReagent: FluorosulfuricAcid
+ bloodReagents:
+ reagents:
+ - ReagentId: FluorosulfuricAcid
+ Quantity: 1
bloodMaxVolume: 300
- type: MeleeWeapon
altDisarm: false
- !type:WashCreamPie
# Damage (Self)
- type: Bloodstream
- bloodReagent: CopperBlood
+ bloodReagents:
+ reagents:
+ - ReagentId: CopperBlood
+ Quantity: 1
# Damage (Others)
- type: MeleeWeapon
animation: WeaponArcBite
- id: FoodMeatPlant
amount: 5
- type: Bloodstream
- bloodReagent: Sap
+ bloodReagents:
+ reagents:
+ - ReagentId: Sap
+ Quantity: 1
- type: Reactive
groups:
Flammable: [ Touch ]
- id: FoodBakedCookie #should be replaced with gingerbread sheets or something... provided you're willing to make a full spriteset of those.
amount: 5
- type: Bloodstream
- bloodReagent: Sugar
+ bloodReagents:
+ reagents:
+ - ReagentId: Sugar
+ Quantity: 1
+ - ReagentId: Butter
+ Quantity: 2
- type: Fixtures
fixtures:
fix1:
- id: FoodMeat
amount: 5
- type: Bloodstream
- bloodReagent: InsectBlood
+ bloodReagents:
+ reagents:
+ - ReagentId: InsectBlood
+ Quantity: 1
- type: DamageVisuals
damageOverlayGroups:
Brute:
Burn:
sprite: Mobs/Effects/burn_damage.rsi
- type: Bloodstream
- bloodReagent: Slime # TODO Color slime blood based on their slime color or smth
+ bloodReagents: # TODO Color slime blood based on their slime color or smth
+ reagents:
+ - ReagentId: Slime
+ Quantity: 1
- type: Barotrauma
damage:
types:
Burn:
sprite: Mobs/Effects/burn_damage.rsi
- type: Bloodstream
- bloodReagent: AmmoniaBlood
+ bloodReagents:
+ reagents:
+ - ReagentId: AmmoniaBlood
+ Quantity: 1
- type: MeleeWeapon
soundHit:
collection: AlienClaw
projects / space-station-14.git / commitdiff