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

Serialization v3 content PR (#3491)

Browse Source 
* serv3 in shared pt 1

* beginning of deepclone api

* progress in implementing ideepclone & serv3 in content

* adds target

* its cant hurt you it cant hurt you

* more changes to content.server

* adds dataclasses

* almost there

* renamed & edited entry

* finishes refactoring content to use serv3

* gasmixture runtimes, next: reagentunit

* fucin hell that was an annoying one

* adds flags

* fixes some yaml errors

* removes comment

* fixes generic components for now

* removes todo
actually clones values my god paul
fixes bug involving resolving custom data classes from other proj
renames dataclass
fixes spritecomp
adds WithFormat.Constants support

* adds deepclone to ResistanceSet

* adds a bunch of deepclone implementations
adds a deepclone analyzer (TODO)
adds a deep clone fallback for classes & structs

* fixes a bunch of runtimes

* adds deepclone to entityuid

* adds generator to sln

* gets rid of warnings

* fixes

* argh

* componentdata refactors

* more deepclone impl

* heck me i reworked all of content deepclone

* renames custom dataclasstarget

* misc

* reworks prototypes

* deepclone nuke

* renamed customdataclass attribute

* fixes everything

* misc fixed

* the killcommit

* getting there

* changed yamlfieldattribute namespace

* adds back iselfserialize

* renames everything to data(field/definition)

* ouch

* Fix most errors on content

* Fix more errors in content

* Fix some components

* work on tests

* fixes some customdataclasses

* fuggin shit

* yes

* yeas

* Remove data classes

* Data field naming fixes

* arg

* Git resetti RobustToolbox

* Merge fixes

* General fixes

* Fix startup serialization errors

* Fix DamageContainerPrototype when supported classes or types are null

* Implement construction graph step type serializer

* Fix up construction serialization

* Fix up construction serialization part 2

* Fix null list in technology database component

* Fix body serialization

* Fix entity storage serialization

* Fix actions serialization

* Fix AI serialization

* Fix reaction serialization

* Fix body serialization

* Fix grid atmosphere serialization

* Rename IServ3Manager to ISerializationManager

* Convert every non generic serializer to the new format, general fixes

* Serialization and body system fix

* pushinheritance fix

* Update all prototypes to have a parent and have consistent id/parent properties

* Merge fixes

* smh my head

* cuddling slaps

* Content commit for engine PR

* stuff

* more fixes

* argh

* yes even you are fixed

* changelog fixes

* fixes seeds

* argh

* Test fixes

* Add writing for alert order prototype

* Fix alert order writing

* FIX

* its been alot ok

* Fix the rest of the visualizers

* Fix server alerts component tests

* Fix alert prototype tests not using the read value

* Fix alert prototype tests initializing serialization multiple times

* THIS IS AN AMERICAN CODEBASE GOD BLESS THE USA

* Add ImplicitDataDefinitionForInheritors to IMechanismBehavior
Fixes the behaviors not being found

* Fix NRE in strap component
Good night to the 1 buckle optimization

* Fix clothing component slot flags serialization tag

* Fix body component in all components test

* Merge fixes

* ffs

* Make construction graph prototype use serialization hooks

* human yaml linted

* a

* Do the thing for construction

* stuff

* a

* monke see yaml linter

* LINT HARDER

* Remove redundant todo

* yes

* Add skip hook argument to readers and copiers

* we gamin

* test/datafield fixes

* adds more verbose validation

* moves linter to action

* Improve construction graph step type serializer error message

* Fix ammo box component NRE

* gamin

* some updates to the linter

* yes

* removes that test

* misc fixes

* array fix
priority fix
misc fixes

* adds proper info the validation

* adds alwaysrelevant usa

* Make yaml linter take half as long to run (~50% less)

* Make yaml linter 5 times faster (~80% less execution time)

* based vera being based

* fixes mapsaving

* warning cleanup & moves surpressor

* removes old msbuild targets

* Revert "Make yaml linter 5 times faster (~80% less execution time)"

This reverts commit 3e6091359a26252c3e98828199553de668031c63.

* Add -nowarn to yaml linter run configuration

* Improve yaml linter message feedback

* Make dependencies an argument instead of a property on the serialization manager

* yamllinting slaps

* Clean up type serializers

* Move yaml linter code to its own method

* Fix yaml errors

* Change yaml linter action name and remove -nowarn

* yaml linter please shut

* Git resetti robust toolbox

Co-authored-by: Paul <ritter.paul1+git@googlemail.com>
Co-authored-by: DrSmugleaf <DrSmugleaf@users.noreply.github.com>
This commit is contained in:
Paul Ritter
2021-03-05 01:08:38 +01:00
committed by GitHub
parent 05d4d9692c
commit 5c50b1f6ed
545 changed files with 4547 additions and 6650 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
Content.Server/Chemistry/Metabolism/DefaultDrink.cs
View File

@@ -2,7 +2,7 @@
using Content.Shared.Chemistry;
using Content.Shared.Interfaces.Chemistry;
using Robust.Shared.GameObjects;
using Robust.Shared.Serialization;
using Robust.Shared.Serialization.Manager.Attributes;
namespace Content.Server.Chemistry.Metabolism
{
@@ -10,21 +10,16 @@ namespace Content.Server.Chemistry.Metabolism
/// Default metabolism for drink reagents. Attempts to find a ThirstComponent on the target,
/// and to update it's thirst values.
/// </summary>
[DataDefinition]
public class DefaultDrink : IMetabolizable
{
//Rate of metabolism in units / second
private ReagentUnit _metabolismRate;
public ReagentUnit MetabolismRate => _metabolismRate;
[DataField("rate")]
public ReagentUnit MetabolismRate { get; set; } = ReagentUnit.New(1);
//How much thirst is satiated when 1u of the reagent is metabolized
private float _hydrationFactor;
public float HydrationFactor => _hydrationFactor;
void IExposeData.ExposeData(ObjectSerializer serializer)
{
serializer.DataField(ref _metabolismRate, "rate", ReagentUnit.New(1));
serializer.DataField(ref _hydrationFactor, "nutrimentFactor", 30.0f);
}
[DataField("hydrationFactor")]
public float HydrationFactor { get; set; } = 30.0f;
//Remove reagent at set rate, satiate thirst if a ThirstComponent can be found
ReagentUnit IMetabolizable.Metabolize(IEntity solutionEntity, string reagentId, float tickTime)

23
Content.Server/Chemistry/Metabolism/DefaultFood.cs
View File

@@ -2,7 +2,7 @@
using Content.Shared.Chemistry;
using Content.Shared.Interfaces.Chemistry;
using Robust.Shared.GameObjects;
using Robust.Shared.Serialization;
using Robust.Shared.Serialization.Manager.Attributes;
namespace Content.Server.Chemistry.Metabolism
{
@@ -10,21 +10,18 @@ namespace Content.Server.Chemistry.Metabolism
/// Default metabolism for food reagents. Attempts to find a HungerComponent on the target,
/// and to update it's hunger values.
/// </summary>
[DataDefinition]
public class DefaultFood : IMetabolizable
{
//Rate of metabolism in units / second
private ReagentUnit _metabolismRate;
public ReagentUnit MetabolismRate => _metabolismRate;
/// <summary>
/// Rate of metabolism in units / second
/// </summary>
[DataField("rate")] public ReagentUnit MetabolismRate { get; private set; } = ReagentUnit.New(1.0);
//How much hunger is satiated when 1u of the reagent is metabolized
private float _nutritionFactor;
public float NutritionFactor => _nutritionFactor;
void IExposeData.ExposeData(ObjectSerializer serializer)
{
serializer.DataField(ref _metabolismRate, "rate", ReagentUnit.New(1.0));
serializer.DataField(ref _nutritionFactor, "nutrimentFactor", 30.0f);
}
/// <summary>
/// How much hunger is satiated when 1u of the reagent is metabolized
/// </summary>
[DataField("nutritionFactor")] public float NutritionFactor { get; set; } = 30.0f;
//Remove reagent at set rate, satiate hunger if a HungerComponent can be found
ReagentUnit IMetabolizable.Metabolize(IEntity solutionEntity, string reagentId, float tickTime)

13
Content.Server/Chemistry/PlantMetabolism/AdjustAttribute.cs
View File

@@ -5,22 +5,17 @@ using Content.Shared.Interfaces.Chemistry;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Random;
using Robust.Shared.Serialization;
using Robust.Shared.Serialization.Manager.Attributes;
namespace Content.Server.Chemistry.PlantMetabolism
{
[ImplicitDataDefinitionForInheritors]
public abstract class AdjustAttribute : IPlantMetabolizable
{
[Dependency] private readonly IRobustRandom _robustRandom = default!;
public float Amount { get; private set; }
public float Prob { get; private set; }
void IExposeData.ExposeData(ObjectSerializer serializer)
{
serializer.DataField(this, x => x.Amount, "amount", 1f);
serializer.DataField(this, x => x.Prob, "prob", 1f);
}
[DataField("amount")] public float Amount { get; protected set; } = 1;
[DataField("prob")] public float Prob { get; protected set; } = 1; // = (80);
/// <summary>
/// Checks if the plant holder can metabolize the reagent or not. Checks if it has an alive plant by default.

7
Content.Server/Chemistry/PlantMetabolism/Clonexadone.cs
View File

@@ -6,17 +6,14 @@ using JetBrains.Annotations;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Random;
using Robust.Shared.Serialization;
using Robust.Shared.Serialization.Manager.Attributes;
namespace Content.Server.Chemistry.PlantMetabolism
{
[UsedImplicitly]
[DataDefinition]
public class Clonexadone : IPlantMetabolizable
{
void IExposeData.ExposeData(ObjectSerializer serializer)
{
}
public void Metabolize(IEntity plantHolder, float customPlantMetabolism = 1)
{
if (plantHolder.Deleted || !plantHolder.TryGetComponent(out PlantHolderComponent? plantHolderComp)

7
Content.Server/Chemistry/PlantMetabolism/Diethylamine.cs
View File

@@ -6,17 +6,14 @@ using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Maths;
using Robust.Shared.Random;
using Robust.Shared.Serialization;
using Robust.Shared.Serialization.Manager.Attributes;
namespace Content.Server.Chemistry.PlantMetabolism
{
[UsedImplicitly]
[DataDefinition]
public class Diethylamine : IPlantMetabolizable
{
void IExposeData.ExposeData(ObjectSerializer serializer)
{
}
public void Metabolize(IEntity plantHolder, float customPlantMetabolism = 1)
{
if (plantHolder.Deleted || !plantHolder.TryGetComponent(out PlantHolderComponent? plantHolderComp)

7
Content.Server/Chemistry/PlantMetabolism/RobustHarvest.cs
View File

@@ -6,17 +6,14 @@ using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Maths;
using Robust.Shared.Random;
using Robust.Shared.Serialization;
using Robust.Shared.Serialization.Manager.Attributes;
namespace Content.Server.Chemistry.PlantMetabolism
{
[UsedImplicitly]
[DataDefinition]
public class RobustHarvest : IPlantMetabolizable
{
void IExposeData.ExposeData(ObjectSerializer serializer)
{
}
public void Metabolize(IEntity plantHolder, float customPlantMetabolism = 1f)
{
if (plantHolder.Deleted || !plantHolder.TryGetComponent(out PlantHolderComponent? plantHolderComp)

50
Content.Server/Chemistry/ReactionEffects/AreaReactionEffect.cs
View File

@@ -1,16 +1,16 @@
#nullable enable
using System;
using Content.Server.GameObjects.Components.Chemistry;
using Content.Server.Interfaces.Chemistry;
using Content.Server.Utility;
using Content.Shared.Audio;
using Content.Shared.Interfaces.Chemistry;
using JetBrains.Annotations;
using Robust.Server.GameObjects;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Log;
using Robust.Shared.Map;
using Robust.Shared.Serialization;
using Robust.Shared.Serialization.Manager.Attributes;
namespace Content.Server.Chemistry.ReactionEffects
{
@@ -18,6 +18,7 @@ namespace Content.Server.Chemistry.ReactionEffects
/// Basically smoke and foam reactions.
/// </summary>
[UsedImplicitly]
[ImplicitDataDefinitionForInheritors]
public abstract class AreaReactionEffect : IReactionEffect
{
[Dependency] private readonly IMapManager _mapManager = default!;
@@ -25,82 +26,65 @@ namespace Content.Server.Chemistry.ReactionEffects
/// <summary>
/// Used for calculating the spread range of the effect based on the intensity of the reaction.
/// </summary>
private float _rangeConstant;
private float _rangeMultiplier;
private int _maxRange;
[DataField("rangeConstant")] private float _rangeConstant;
[DataField("rangeMultiplier")] private float _rangeMultiplier = 1.1f;
[DataField("maxRange")] private int _maxRange = 10;
/// <summary>
/// If true the reagents get diluted or concentrated depending on the range of the effect
/// </summary>
private bool _diluteReagents;
[DataField("diluteReagents")] private bool _diluteReagents;
/// <summary>
/// At what range should the reagents volume stay the same. If the effect range is higher than this then the reagents
/// will get diluted. If the effect range is lower than this then the reagents will get concentrated.
/// </summary>
private int _reagentDilutionStart;
[DataField("reagentDilutionStart")] private int _reagentDilutionStart = 4;
/// <summary>
/// Used to calculate dilution. Increasing this makes the reagents get more diluted. This means that a lower range
/// will be needed to make the reagents volume get closer to zero.
/// </summary>
private float _reagentDilutionFactor;
[DataField("reagentDilutionFactor")] private float _reagentDilutionFactor = 1;
/// <summary>
/// Used to calculate concentration. Reagents get linearly more concentrated as the range goes from
/// _reagentDilutionStart to zero. When the range is zero the reagents volume gets multiplied by this.
/// </summary>
private float _reagentMaxConcentrationFactor;
[DataField("reagentMaxConcentrationFactor")]
private float _reagentMaxConcentrationFactor = 2;
/// <summary>
/// How many seconds will the effect stay, counting after fully spreading.
/// </summary>
private float _duration;
[DataField("duration")] private float _duration = 10;
/// <summary>
/// How many seconds between each spread step.
/// </summary>
private float _spreadDelay;
[DataField("spreadDelay")] private float _spreadDelay = 0.5f;
/// <summary>
/// How many seconds between each remove step.
/// </summary>
private float _removeDelay;
[DataField("removeDelay")] private float _removeDelay = 0.5f;
/// <summary>
/// The entity prototype that will be spawned as the effect. It needs a component derived from SolutionAreaEffectComponent.
/// </summary>
private string? _prototypeId;
[DataField("prototypeId", required: true)]
private string _prototypeId = default!;
/// <summary>
/// Sound that will get played when this reaction effect occurs.
/// </summary>
private string? _sound;
[DataField("sound")] private string? _sound;
protected AreaReactionEffect()
{
IoCManager.InjectDependencies(this);
}
void IExposeData.ExposeData(ObjectSerializer serializer)
{
serializer.DataField(ref _rangeConstant, "rangeConstant",0f);
serializer.DataField(ref _rangeMultiplier, "rangeMultiplier",1.1f);
serializer.DataField(ref _maxRange, "maxRange", 10);
serializer.DataField(ref _diluteReagents, "diluteReagents", false);
serializer.DataField(ref _reagentDilutionStart, "reagentDilutionStart", 4);
serializer.DataField(ref _reagentDilutionFactor, "reagentDilutionFactor", 1f);
serializer.DataField(ref _reagentMaxConcentrationFactor, "reagentMaxConcentrationFactor",2f);
serializer.DataField(ref _duration, "duration", 10f);
serializer.DataField(ref _spreadDelay, "spreadDelay", 0.5f);
serializer.DataField(ref _removeDelay, "removeDelay", 0.5f);
serializer.DataField(ref _sound, "sound", null);
serializer.DataField(ref _prototypeId, "prototypeId", null);
if (_prototypeId == null)
Logger.Error("prototypeId wasn't provided to AreaReactionEffect, check yaml");
}
public void React(IEntity solutionEntity, double intensity)
{
if (!solutionEntity.TryGetComponent(out SolutionContainerComponent? contents))

39
Content.Server/Chemistry/ReactionEffects/ExplosionReactionEffect.cs
View File

@@ -1,43 +1,34 @@
using System;
using Content.Server.Explosions;
using Content.Server.GameObjects.Components.Chemistry;
using Content.Server.Interfaces.Chemistry;
using Content.Shared.Interfaces.Chemistry;
using Robust.Shared.GameObjects;
using Robust.Shared.Serialization;
using Robust.Shared.Serialization.Manager.Attributes;
namespace Content.Server.Chemistry.ReactionEffects
{
[DataDefinition]
public class ExplosionReactionEffect : IReactionEffect
{
private float _devastationRange;
private float _heavyImpactRange;
private float _lightImpactRange;
private float _flashRange;
[DataField("devastationRange")] private float _devastationRange = 1;
[DataField("heavyImpactRange")] private float _heavyImpactRange = 2;
[DataField("lightImpactRange")] private float _lightImpactRange = 3;
[DataField("flashRange")] private float _flashRange;
/// <summary>
/// If true, then scale ranges by intensity. If not, the ranges are the same regardless of reactant amount.
/// </summary>
private bool _scaled;
[DataField("scaled")] private bool _scaled;
/// <summary>
/// Maximum scaling on ranges. For example, if it equals 5, then it won't scaled anywhere past
/// 5 times the minimum reactant amount.
/// </summary>
private float _maxScale;
void IExposeData.ExposeData(ObjectSerializer serializer)
{
serializer.DataField(ref _devastationRange, "devastationRange", 1);
serializer.DataField(ref _heavyImpactRange, "heavyImpactRange", 2);
serializer.DataField(ref _lightImpactRange, "lightImpactRange", 3);
serializer.DataField(ref _flashRange, "flashRange", 0);
serializer.DataField(ref _scaled, "scaled", false);
serializer.DataField(ref _maxScale, "maxScale", 1);
}
[DataField("maxScale")] private float _maxScale = 1;
public void React(IEntity solutionEntity, double intensity)
{
float floatIntensity = (float)intensity;
var floatIntensity = (float)intensity;
if (solutionEntity == null)
return;
if(!solutionEntity.TryGetComponent(out SolutionContainerComponent solution))
@@ -54,10 +45,10 @@ namespace Content.Server.Chemistry.ReactionEffects
}
//Calculate intensities
int finalDevastationRange = (int)MathF.Round(_devastationRange * floatIntensity);
int finalHeavyImpactRange = (int)MathF.Round(_heavyImpactRange * floatIntensity);
int finalLightImpactRange = (int)MathF.Round(_lightImpactRange * floatIntensity);
int finalFlashRange = (int)MathF.Round(_flashRange * floatIntensity);
var finalDevastationRange = (int)MathF.Round(_devastationRange * floatIntensity);
var finalHeavyImpactRange = (int)MathF.Round(_heavyImpactRange * floatIntensity);
var finalLightImpactRange = (int)MathF.Round(_lightImpactRange * floatIntensity);
var finalFlashRange = (int)MathF.Round(_flashRange * floatIntensity);
solutionEntity.SpawnExplosion(finalDevastationRange,
finalHeavyImpactRange, finalLightImpactRange, finalFlashRange);
}

2
Content.Server/Chemistry/ReactionEffects/FoamAreaReactionEffect.cs
View File

@@ -2,10 +2,12 @@
using Content.Server.GameObjects.Components.Chemistry;
using JetBrains.Annotations;
using Robust.Shared.GameObjects;
using Robust.Shared.Serialization.Manager.Attributes;
namespace Content.Server.Chemistry.ReactionEffects
{
[UsedImplicitly]
[DataDefinition]
public class FoamAreaReactionEffect : AreaReactionEffect
{
protected override SolutionAreaEffectComponent? GetAreaEffectComponent(IEntity entity)

2
Content.Server/Chemistry/ReactionEffects/SmokeAreaReactionEffect.cs
View File

@@ -2,10 +2,12 @@
using Content.Server.GameObjects.Components.Chemistry;
using JetBrains.Annotations;
using Robust.Shared.GameObjects;
using Robust.Shared.Serialization.Manager.Attributes;
namespace Content.Server.Chemistry.ReactionEffects
{
[UsedImplicitly]
[DataDefinition]
public class SmokeAreaReactionEffect : AreaReactionEffect
{
protected override SolutionAreaEffectComponent? GetAreaEffectComponent(IEntity entity)

11
Content.Server/Chemistry/TileReactions/CleanTileReaction.cs
View File

@@ -1,19 +1,16 @@
using Content.Server.GameObjects.Components;
using System.Linq;
using Content.Server.GameObjects.Components;
using Content.Server.Utility;
using Content.Shared.Chemistry;
using Content.Shared.Interfaces.Chemistry;
using Robust.Shared.Map;
using Robust.Shared.Serialization;
using System.Linq;
using Robust.Shared.Serialization.Manager.Attributes;
namespace Content.Server.Chemistry.TileReactions
{
[DataDefinition]
public class CleanTileReaction : ITileReaction
{
void IExposeData.ExposeData(ObjectSerializer serializer)
{
}
ReagentUnit ITileReaction.TileReact(TileRef tile, ReagentPrototype reagent, ReagentUnit reactVolume)
{
var entities = tile.GetEntitiesInTileFast().ToArray();

10
Content.Server/Chemistry/TileReactions/ExtinguishTileReaction.cs
View File

@@ -5,19 +5,15 @@ using Content.Shared.Chemistry;
using Content.Shared.Interfaces.Chemistry;
using JetBrains.Annotations;
using Robust.Shared.Map;
using Robust.Shared.Serialization;
using Robust.Shared.Serialization.Manager.Attributes;
namespace Content.Server.Chemistry.TileReactions
{
[UsedImplicitly]
[DataDefinition]
public class ExtinguishTileReaction : ITileReaction
{
private float _coolingTemperature = 2f;
void IExposeData.ExposeData(ObjectSerializer serializer)
{
serializer.DataField(ref _coolingTemperature, "coolingTemperature", 2f);
}
[DataField("coolingTemperature")] private float _coolingTemperature = 2f;
public ReagentUnit TileReact(TileRef tile, ReagentPrototype reagent, ReagentUnit reactVolume)
{

10
Content.Server/Chemistry/TileReactions/FlammableTileReaction.cs
View File

@@ -4,19 +4,15 @@ using Content.Shared.Chemistry;
using Content.Shared.Interfaces.Chemistry;
using JetBrains.Annotations;
using Robust.Shared.Map;
using Robust.Shared.Serialization;
using Robust.Shared.Serialization.Manager.Attributes;
namespace Content.Server.Chemistry.TileReactions
{
[UsedImplicitly]
[DataDefinition]
public class FlammableTileReaction : ITileReaction
{
private float _temperatureMultiplier = 1.25f;
void IExposeData.ExposeData(ObjectSerializer serializer)
{
serializer.DataField(ref _temperatureMultiplier, "temperatureMultiplier", 1.15f);
}
[DataField("temperatureMultiplier")] private float _temperatureMultiplier = 1.15f;
public ReagentUnit TileReact(TileRef tile, ReagentPrototype reagent, ReagentUnit reactVolume)
{

7
Content.Server/Chemistry/TileReactions/SpillIfPuddlePresentTileReaction.cs
View File

@@ -3,17 +3,14 @@ using Content.Shared.Chemistry;
using Content.Shared.Interfaces.Chemistry;
using JetBrains.Annotations;
using Robust.Shared.Map;
using Robust.Shared.Serialization;
using Robust.Shared.Serialization.Manager.Attributes;
namespace Content.Server.Chemistry.TileReactions
{
[UsedImplicitly]
[DataDefinition]
public class SpillIfPuddlePresentTileReaction : ITileReaction
{
void IExposeData.ExposeData(ObjectSerializer serializer)
{
}
public ReagentUnit TileReact(TileRef tile, ReagentPrototype reagent, ReagentUnit reactVolume)
{
if (reactVolume < 5 || !tile.TryGetPuddle(null, out _)) return ReagentUnit.Zero;

20
Content.Server/Chemistry/TileReactions/SpillTileReaction.cs
View File

@@ -4,26 +4,18 @@ using Content.Shared.Chemistry;
using Content.Shared.Interfaces.Chemistry;
using JetBrains.Annotations;
using Robust.Shared.Map;
using Robust.Shared.Serialization;
using Robust.Shared.Serialization.Manager.Attributes;
namespace Content.Server.Chemistry.TileReactions
{
[UsedImplicitly]
[DataDefinition]
public class SpillTileReaction : ITileReaction
{
private float _launchForwardsMultiplier = 1f;
private float _requiredSlipSpeed = 6f;
private float _paralyzeTime = 1f;
private bool _overflow;
void IExposeData.ExposeData(ObjectSerializer serializer)
{
// If you want to modify more puddle/slippery values, add them here.
serializer.DataField(ref _paralyzeTime, "paralyzeTime", 1f);
serializer.DataField(ref _launchForwardsMultiplier, "launchForwardsMultiplier", 1f);
serializer.DataField(ref _requiredSlipSpeed, "requiredSlipSpeed", 6f);
serializer.DataField(ref _overflow, "overflow", false);
}
[DataField("launchForwardsMultiplier")] private float _launchForwardsMultiplier = 1;
[DataField("requiredSlipSpeed")] private float _requiredSlipSpeed = 6;
[DataField("paralyzeTime")] private float _paralyzeTime = 1;
[DataField("overflow")] private bool _overflow;
public ReagentUnit TileReact(TileRef tile, ReagentPrototype reagent, ReagentUnit reactVolume)
{