{
return _reagentSources.GetValueOrDefault(id) ?? new List<ReagentSourceData>();
}
+
+ // Is handled on server and updated on client via ReagentGuideRegistryChangedEvent
+ public override void ReloadAllReagentPrototypes()
+ {
+ }
}
/// <summary>
var ev = new ReagentGuideRegistryChangedEvent(changeset);
RaiseNetworkEvent(ev);
}
+
+ public override void ReloadAllReagentPrototypes()
+ {
+ InitializeServerRegistry();
+ }
}
if (TerminatingOrDeleted(args.Target))
return;
- var dmg = _damageable.TryChangeDamage(args.Target, component.Damage, component.IgnoreResistances, origin: args.Component.Thrower);
+ var dmg = _damageable.TryChangeDamage(args.Target, component.Damage * _damageable.UniversalThrownDamageModifier, component.IgnoreResistances, origin: args.Component.Thrower);
// Log damage only for mobs. Useful for when people throw spears at each other, but also avoids log-spam when explosions send glass shards flying.
if (dmg != null && HasComp<MobStateComponent>(args.Target))
private void OnDamageExamine(EntityUid uid, DamageOtherOnHitComponent component, ref DamageExamineEvent args)
{
- _damageExamine.AddDamageExamine(args.Message, component.Damage, Loc.GetString("damage-throw"));
+ _damageExamine.AddDamageExamine(args.Message, _damageable.ApplyUniversalAllModifiers(component.Damage * _damageable.UniversalThrownDamageModifier), Loc.GetString("damage-throw"));
}
/// <summary>
var damageSpec = new DamageSpecifier(Damage);
+ var universalReagentDamageModifier = entSys.GetEntitySystem<DamageableSystem>().UniversalReagentDamageModifier;
+ var universalReagentHealModifier = entSys.GetEntitySystem<DamageableSystem>().UniversalReagentHealModifier;
+
+ if (universalReagentDamageModifier != 1 || universalReagentHealModifier != 1)
+ {
+ foreach (var (type, val) in damageSpec.DamageDict)
+ {
+ if (val < 0f)
+ {
+ damageSpec.DamageDict[type] = val * universalReagentHealModifier;
+ }
+ if (val > 0f)
+ {
+ damageSpec.DamageDict[type] = val * universalReagentDamageModifier;
+ }
+ }
+ }
+
+ damageSpec = entSys.GetEntitySystem<DamageableSystem>().ApplyUniversalAllModifiers(damageSpec);
+
foreach (var group in prototype.EnumeratePrototypes<DamageGroupPrototype>())
{
if (!damageSpec.TryGetDamageInGroup(group, out var amount))
public override void Effect(EntityEffectBaseArgs args)
{
var scale = FixedPoint2.New(1);
+ var damageSpec = new DamageSpecifier(Damage);
if (args is EntityEffectReagentArgs reagentArgs)
{
scale = ScaleByQuantity ? reagentArgs.Quantity * reagentArgs.Scale : reagentArgs.Scale;
}
- args.EntityManager.System<DamageableSystem>().TryChangeDamage(
- args.TargetEntity,
- Damage * scale,
- IgnoreResistances,
- interruptsDoAfters: false);
+ var universalReagentDamageModifier = args.EntityManager.System<DamageableSystem>().UniversalReagentDamageModifier;
+ var universalReagentHealModifier = args.EntityManager.System<DamageableSystem>().UniversalReagentHealModifier;
+
+ if (universalReagentDamageModifier != 1 || universalReagentHealModifier != 1)
+ {
+ foreach (var (type, val) in damageSpec.DamageDict)
+ {
+ if (val < 0f)
+ {
+ damageSpec.DamageDict[type] = val * universalReagentHealModifier;
+ }
+ if (val > 0f)
+ {
+ damageSpec.DamageDict[type] = val * universalReagentDamageModifier;
+ }
+ }
+ }
+
+ args.EntityManager.System<DamageableSystem>()
+ .TryChangeDamage(
+ args.TargetEntity,
+ damageSpec * scale,
+ IgnoreResistances,
+ interruptsDoAfters: false);
}
}
}
}
// TODO EXPLOSIONS turn explosions into entities, and pass the the entity in as the damage origin.
- _damageableSystem.TryChangeDamage(entity, damage, ignoreResistances: true);
+ _damageableSystem.TryChangeDamage(entity, damage * _damageableSystem.UniversalExplosionDamageModifier, ignoreResistances: true);
}
}
if (healing.ModifyBloodLevel != 0)
_bloodstreamSystem.TryModifyBloodLevel(entity.Owner, healing.ModifyBloodLevel);
- var healed = _damageable.TryChangeDamage(entity.Owner, healing.Damage, true, origin: args.Args.User);
+ var healed = _damageable.TryChangeDamage(entity.Owner, healing.Damage * _damageable.UniversalTopicalsHealModifier, true, origin: args.Args.User);
if (healed == null && healing.BloodlossModifier != 0)
return;
return;
}
- var ev = new ProjectileHitEvent(component.Damage, target, component.Shooter);
+ var ev = new ProjectileHitEvent(component.Damage * _damageableSystem.UniversalProjectileDamageModifier, target, component.Shooter);
RaiseLocalEvent(uid, ref ev);
var otherName = ToPrettyString(target);
if (damageSpec.Empty)
return;
- _damageExamine.AddDamageExamine(args.Message, damageSpec, Loc.GetString("damage-melee"));
+ _damageExamine.AddDamageExamine(args.Message, Damageable.ApplyUniversalAllModifiers(damageSpec), Loc.GetString("damage-melee"));
}
protected override bool ArcRaySuccessful(EntityUid targetUid,
_ => throw new ArgumentOutOfRangeException(),
};
- _damageExamine.AddDamageExamine(args.Message, damageSpec, damageType);
+ _damageExamine.AddDamageExamine(args.Message, Damageable.ApplyUniversalAllModifiers(damageSpec), damageType);
}
private DamageSpecifier? GetDamage(BatteryAmmoProviderComponent component)
if (!p.Damage.Empty)
{
- return p.Damage;
+ return p.Damage * Damageable.UniversalProjectileDamageModifier;
}
}
if (component is HitscanBatteryAmmoProviderComponent hitscan)
{
- return ProtoManager.Index<HitscanPrototype>(hitscan.Prototype).Damage;
+ var dmg = ProtoManager.Index<HitscanPrototype>(hitscan.Prototype).Damage;
+ return dmg == null ? dmg : dmg * Damageable.UniversalHitscanDamageModifier;
}
return null;
if (damageSpec == null)
return;
- _damageExamine.AddDamageExamine(args.Message, damageSpec, Loc.GetString("damage-projectile"));
+ _damageExamine.AddDamageExamine(args.Message, Damageable.ApplyUniversalAllModifiers(damageSpec), Loc.GetString("damage-projectile"));
}
private DamageSpecifier? GetProjectileDamage(string proto)
if (!p.Damage.Empty)
{
- return p.Damage;
+ return p.Damage * Damageable.UniversalProjectileDamageModifier;
}
}
var hitName = ToPrettyString(hitEntity);
if (dmg != null)
- dmg = Damageable.TryChangeDamage(hitEntity, dmg, origin: user);
+ dmg = Damageable.TryChangeDamage(hitEntity, dmg * Damageable.UniversalHitscanDamageModifier, origin: user);
// check null again, as TryChangeDamage returns modified damage values
if (dmg != null)
--- /dev/null
+using Content.Shared.Administration;
+using Content.Shared.CCVar.CVarAccess;
+using Content.Shared.Roles;
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+ /// <summary>
+ /// Scales all damage dealt in the game.
+ /// </summary>
+ [CVarControl(AdminFlags.VarEdit)]
+ public static readonly CVarDef<float> PlaytestAllDamageModifier =
+ CVarDef.Create("playtest.all_damage_modifier", 1f, CVar.SERVER | CVar.REPLICATED);
+
+ /// <summary>
+ /// Scales all healing done in the game.
+ /// </summary>
+ [CVarControl(AdminFlags.VarEdit)]
+ public static readonly CVarDef<float> PlaytestAllHealModifier =
+ CVarDef.Create("playtest.all_heal_modifier", 1f, CVar.SERVER | CVar.REPLICATED);
+
+ /// <summary>
+ /// Scales the damage dealt by all melee attacks in the game.
+ /// </summary>
+ [CVarControl(AdminFlags.VarEdit)]
+ public static readonly CVarDef<float> PlaytestMeleeDamageModifier =
+ CVarDef.Create("playtest.melee_damage_modifier", 1f, CVar.SERVER | CVar.REPLICATED);
+
+ /// <summary>
+ /// Scales the damage dealt by all projectiles in the game.
+ /// </summary>
+ [CVarControl(AdminFlags.VarEdit)]
+ public static readonly CVarDef<float> PlaytestProjectileDamageModifier =
+ CVarDef.Create("playtest.projectile_damage_modifier", 1f, CVar.SERVER | CVar.REPLICATED);
+
+ /// <summary>
+ /// Scales the damage dealt by all hitscan attacks in the game.
+ /// </summary>
+ [CVarControl(AdminFlags.VarEdit)]
+ public static readonly CVarDef<float> PlaytestHitscanDamageModifier =
+ CVarDef.Create("playtest.hitscan_damage_modifier", 1f, CVar.SERVER | CVar.REPLICATED);
+
+ /// <summary>
+ /// Scales the damage dealt by all thrown weapons in the game.
+ /// </summary>
+ [CVarControl(AdminFlags.VarEdit)]
+ public static readonly CVarDef<float> PlaytestThrownDamageModifier =
+ CVarDef.Create("playtest.thrown_damage_modifier", 1f, CVar.SERVER | CVar.REPLICATED);
+
+ /// <summary>
+ /// Scales the healing given by all topicals in the game.
+ /// </summary>
+ [CVarControl(AdminFlags.VarEdit)]
+ public static readonly CVarDef<float> PlaytestTopicalsHealModifier =
+ CVarDef.Create("playtest.topicals_heal_modifier", 1f, CVar.SERVER | CVar.REPLICATED);
+
+ /// <summary>
+ /// Scales the damage dealt by all reagents in the game.
+ /// </summary>
+ [CVarControl(AdminFlags.VarEdit)]
+ public static readonly CVarDef<float> PlaytestReagentDamageModifier =
+ CVarDef.Create("playtest.reagent_damage_modifier", 1f, CVar.SERVER | CVar.REPLICATED);
+
+ /// <summary>
+ /// Scales the healing given by all reagents in the game.
+ /// </summary>
+ [CVarControl(AdminFlags.VarEdit)]
+ public static readonly CVarDef<float> PlaytestReagentHealModifier =
+ CVarDef.Create("playtest.reagent_heal_modifier", 1f, CVar.SERVER | CVar.REPLICATED);
+
+ /// <summary>
+ /// Scales the explosion damage dealt in the game.
+ /// </summary>
+ [CVarControl(AdminFlags.VarEdit)]
+ public static readonly CVarDef<float> PlaytestExplosionDamageModifier =
+ CVarDef.Create("playtest.explosion_damage_modifier", 1f, CVar.SERVER | CVar.REPLICATED);
+
+}
protected readonly Dictionary<string, ReagentGuideEntry> Registry = new();
public IReadOnlyDictionary<string, ReagentGuideEntry> ReagentGuideRegistry => Registry;
+
+ // Only ran on the server
+ public abstract void ReloadAllReagentPrototypes();
}
[Serializable, NetSerializable]
using System.Linq;
+using Content.Shared.CCVar;
+using Content.Shared.Chemistry;
using Content.Shared.Damage.Prototypes;
using Content.Shared.FixedPoint;
using Content.Shared.Inventory;
using Content.Shared.Mobs.Systems;
using Content.Shared.Radiation.Events;
using Content.Shared.Rejuvenate;
+using Robust.Shared.Configuration;
using Robust.Shared.GameStates;
using Robust.Shared.Network;
using Robust.Shared.Prototypes;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
[Dependency] private readonly INetManager _netMan = default!;
[Dependency] private readonly MobThresholdSystem _mobThreshold = default!;
+ [Dependency] private readonly IConfigurationManager _config = default!;
+ [Dependency] private readonly SharedChemistryGuideDataSystem _chemistryGuideData = default!;
private EntityQuery<AppearanceComponent> _appearanceQuery;
private EntityQuery<DamageableComponent> _damageableQuery;
private EntityQuery<MindContainerComponent> _mindContainerQuery;
+ public float UniversalAllDamageModifier { get; private set; } = 1f;
+ public float UniversalAllHealModifier { get; private set; } = 1f;
+ public float UniversalMeleeDamageModifier { get; private set; } = 1f;
+ public float UniversalProjectileDamageModifier { get; private set; } = 1f;
+ public float UniversalHitscanDamageModifier { get; private set; } = 1f;
+ public float UniversalReagentDamageModifier { get; private set; } = 1f;
+ public float UniversalReagentHealModifier { get; private set; } = 1f;
+ public float UniversalExplosionDamageModifier { get; private set; } = 1f;
+ public float UniversalThrownDamageModifier { get; private set; } = 1f;
+ public float UniversalTopicalsHealModifier { get; private set; } = 1f;
+
public override void Initialize()
{
SubscribeLocalEvent<DamageableComponent, ComponentInit>(DamageableInit);
_appearanceQuery = GetEntityQuery<AppearanceComponent>();
_damageableQuery = GetEntityQuery<DamageableComponent>();
_mindContainerQuery = GetEntityQuery<MindContainerComponent>();
+
+ // Damage modifier CVars are updated and stored here to be queried in other systems.
+ // Note that certain modifiers requires reloading the guidebook.
+ Subs.CVar(_config, CCVars.PlaytestAllDamageModifier, value =>
+ {
+ UniversalAllDamageModifier = value;
+ _chemistryGuideData.ReloadAllReagentPrototypes();
+ }, true);
+ Subs.CVar(_config, CCVars.PlaytestAllHealModifier, value =>
+ {
+ UniversalAllHealModifier = value;
+ _chemistryGuideData.ReloadAllReagentPrototypes();
+ }, true);
+ Subs.CVar(_config, CCVars.PlaytestProjectileDamageModifier, value => UniversalProjectileDamageModifier = value, true);
+ Subs.CVar(_config, CCVars.PlaytestMeleeDamageModifier, value => UniversalMeleeDamageModifier = value, true);
+ Subs.CVar(_config, CCVars.PlaytestProjectileDamageModifier, value => UniversalProjectileDamageModifier = value, true);
+ Subs.CVar(_config, CCVars.PlaytestHitscanDamageModifier, value => UniversalHitscanDamageModifier = value, true);
+ Subs.CVar(_config, CCVars.PlaytestReagentDamageModifier, value =>
+ {
+ UniversalReagentDamageModifier = value;
+ _chemistryGuideData.ReloadAllReagentPrototypes();
+ }, true);
+ Subs.CVar(_config, CCVars.PlaytestReagentHealModifier, value =>
+ {
+ UniversalReagentHealModifier = value;
+ _chemistryGuideData.ReloadAllReagentPrototypes();
+ }, true);
+ Subs.CVar(_config, CCVars.PlaytestExplosionDamageModifier, value => UniversalExplosionDamageModifier = value, true);
+ Subs.CVar(_config, CCVars.PlaytestThrownDamageModifier, value => UniversalThrownDamageModifier = value, true);
+ Subs.CVar(_config, CCVars.PlaytestTopicalsHealModifier, value => UniversalTopicalsHealModifier = value, true);
}
/// <summary>
}
}
+ damage = ApplyUniversalAllModifiers(damage);
+
// TODO DAMAGE PERFORMANCE
// Consider using a local private field instead of creating a new dictionary here.
// Would need to check that nothing ever tries to cache the delta.
return delta;
}
+ /// <summary>
+ /// Applies the two univeral "All" modifiers, if set.
+ /// Individual damage source modifiers are set in their respective code.
+ /// </summary>
+ /// <param name="damage">The damage to be changed.</param>
+ public DamageSpecifier ApplyUniversalAllModifiers(DamageSpecifier damage)
+ {
+ // Checks for changes first since they're unlikely in normal play.
+ if (UniversalAllDamageModifier == 1f && UniversalAllHealModifier == 1f)
+ return damage;
+
+ foreach (var (key, value) in damage.DamageDict)
+ {
+ if (value == 0)
+ continue;
+
+ if (value > 0)
+ {
+ damage.DamageDict[key] *= UniversalAllDamageModifier;
+ continue;
+ }
+
+ if (value < 0)
+ {
+ damage.DamageDict[key] *= UniversalAllHealModifier;
+ }
+ }
+
+ return damage;
+ }
+
/// <summary>
/// Sets all damage types supported by a <see cref="DamageableComponent"/> to the specified value.
/// </summary>
if (!Resolve(uid, ref component, false))
return new DamageSpecifier();
- var ev = new GetMeleeDamageEvent(uid, new(component.Damage), new(), user, component.ResistanceBypass);
+ var ev = new GetMeleeDamageEvent(uid, new(component.Damage * Damageable.UniversalMeleeDamageModifier), new(), user, component.ResistanceBypass);
RaiseLocalEvent(uid, ref ev);
return DamageSpecifier.ApplyModifierSets(ev.Damage, ev.Modifiers);
if (!Resolve(uid, ref component))
return false;
- var ev = new GetMeleeDamageEvent(uid, new(component.Damage), new(), user, component.ResistanceBypass);
+ var ev = new GetMeleeDamageEvent(uid, new(component.Damage * Damageable.UniversalMeleeDamageModifier), new(), user, component.ResistanceBypass);
RaiseLocalEvent(uid, ref ev);
return ev.ResistanceBypass;
changecvar-simple-debug_test_cvar = Does nothing.
changecvar-full-debug_test_cvar = Just a simple testing cvar. Does nothing.
+
+changecvar-simple-playtest_all_damage_modifier = Multiplier for all damage dealt.
+changecvar-full-playtest_all_damage_modifier = Multiplier for all damage dealt.
+changecvar-simple-playtest_all_heal_modifier = Multiplier for all healing done.
+changecvar-full-playtest_all_heal_modifier = Multiplier for all healing done.
+changecvar-simple-playtest_melee_damage_modifier = Multiplier affecting melee weapon damage.
+changecvar-full-playtest_melee_damage_modifier = Multiplier affecting all damage dealt by melee attacks.
+changecvar-simple-playtest_projectile_damage_modifier = Multiplier affecting projectile damage.
+changecvar-full-playtest_projectile_damage_modifier = Multiplier affecting all damage dealt by projectiles.
+changecvar-simple-playtest_hitscan_damage_modifier = Multiplier affecting hitscan damage.
+changecvar-full-playtest_hitscan_damage_modifier = Multiplier affecting all damage dealt by hitscan weapons.
+changecvar-simple-playtest_thrown_damage_modifier = Multiplier affecting thrown weapon damage.
+changecvar-full-playtest_thrown_damage_modifier = Multiplier affecting all damage dealt by thrown weapons.
+changecvar-simple-playtest_topicals_heal_modifier = Multiplier affecting topical healing.
+changecvar-full-playtest_topicals_heal_modifier = Multiplier affecting all healing done by topicals.
+changecvar-simple-playtest_reagent_damage_modifier = Multiplier affecting reagent damage.
+changecvar-full-playtest_reagent_damage_modifier = Multiplier affecting all damage dealt by reagents.
+changecvar-simple-playtest_reagent_heal_modifier = Multiplier affecting reagent healing.
+changecvar-full-playtest_reagent_heal_modifier = Multiplier affecting all healing done by reagents.
+changecvar-simple-playtest_explosion_damage_modifier = Multiplier affecting explosion damage.
+changecvar-full-playtest_explosion_damage_modifier = Multiplier affecting all damage dealt by explosives.
projects / space-station-14.git / commitdiff