r2mods/ilspy_dump/ror2_csproj/EntityStates/SkillStateOverrideData.cs

143 lines
4.5 KiB
C#
Raw Normal View History

2024-10-04 07:26:37 +00:00
using RoR2;
using RoR2.Skills;
using UnityEngine;
namespace EntityStates;
public class SkillStateOverrideData
{
private object source;
public bool duplicateStock;
public bool overrideFullReloadOnAssign;
public bool simulateRestockForOverridenSkills = true;
private static GenericSkill.SkillOverridePriority priority = GenericSkill.SkillOverridePriority.Contextual;
private float overrideTimestamp;
public SkillDef primarySkillOverride;
public SkillDef secondarySkillOverride;
public SkillDef utilitySkillOverride;
public SkillDef specialSkillOverride;
private GenericSkill primarySkillOriginal;
private GenericSkill secondarySkillOriginal;
private GenericSkill utilitySkillOriginal;
private GenericSkill specialSkillOriginal;
public int previousPrimaryStock = -1;
public int previousSecondaryStock = -1;
public int previousUtilityStock = -1;
public int previousSpecialStock = -1;
public bool hasAuthority { get; private set; }
public SkillStateOverrideData(CharacterBody sourceBody)
{
source = sourceBody;
hasAuthority = Util.HasEffectiveAuthority(sourceBody.gameObject);
duplicateStock = false;
}
public SkillStateOverrideData(CharacterBody sourceBody, bool _duplicateStock)
{
source = sourceBody;
hasAuthority = Util.HasEffectiveAuthority(sourceBody.gameObject);
duplicateStock = _duplicateStock;
}
public void OverrideSkills(SkillLocator skillLocator)
{
if (hasAuthority && !(skillLocator == null))
{
overrideTimestamp = Time.time;
InternalOverride(skillLocator.primary, ref primarySkillOverride, ref primarySkillOriginal, ref previousPrimaryStock);
InternalOverride(skillLocator.secondary, ref secondarySkillOverride, ref secondarySkillOriginal, ref previousSecondaryStock);
InternalOverride(skillLocator.utility, ref utilitySkillOverride, ref utilitySkillOriginal, ref previousUtilityStock);
InternalOverride(skillLocator.special, ref specialSkillOverride, ref specialSkillOriginal, ref previousSpecialStock);
}
}
private void InternalOverride(GenericSkill existingSkillToOverride, ref SkillDef overridingSkill, ref GenericSkill originalSkill, ref int previousStockAmount)
{
if (!(overridingSkill == null) && !(existingSkillToOverride == null) && !(existingSkillToOverride == originalSkill) && !existingSkillToOverride.HasSkillOverrideOfPriority(priority))
{
int stock = existingSkillToOverride.stock;
previousStockAmount = -1;
originalSkill = existingSkillToOverride;
originalSkill.SetSkillOverride(source, overridingSkill, priority);
if (duplicateStock)
{
originalSkill.stock = stock;
}
}
}
public void ClearOverrides()
{
if (hasAuthority && source != null)
{
InternalClearOverride(ref primarySkillOriginal, ref primarySkillOverride, ref previousPrimaryStock);
InternalClearOverride(ref secondarySkillOriginal, ref secondarySkillOverride, ref previousSecondaryStock);
InternalClearOverride(ref utilitySkillOriginal, ref utilitySkillOverride, ref previousUtilityStock);
InternalClearOverride(ref specialSkillOriginal, ref specialSkillOverride, ref previousSpecialStock);
}
void InternalClearOverride(ref GenericSkill overriddenSkill, ref SkillDef skillDef, ref int previousStockAmount)
{
if (!(overriddenSkill == null) && !(skillDef == null) && overriddenSkill.HasSkillOverrideOfPriority(priority))
{
int baseStock = overriddenSkill.GetBaseStock();
int stock = overriddenSkill.stock;
float rechargeStopwatch = overriddenSkill.rechargeStopwatch;
overriddenSkill.UnsetSkillOverride(source, skillDef, priority);
if (overrideFullReloadOnAssign && overriddenSkill.skillDef.fullRestockOnAssign)
{
overriddenSkill.stock = baseStock;
}
if (simulateRestockForOverridenSkills)
{
overriddenSkill.RechargeBaseSkill(Time.time - overrideTimestamp);
}
previousStockAmount = -1;
if (duplicateStock)
{
overriddenSkill.baseStock = stock;
overriddenSkill.baseRechargeStopwatch = rechargeStopwatch;
}
}
}
}
public void StepRestock()
{
float time2 = Time.time;
if (!(time2 <= overrideTimestamp))
{
InternalRestock(time2, ref primarySkillOriginal);
InternalRestock(time2, ref secondarySkillOriginal);
InternalRestock(time2, ref utilitySkillOriginal);
InternalRestock(time2, ref specialSkillOriginal);
overrideTimestamp = time2;
}
void InternalRestock(float time, ref GenericSkill overridenSkill)
{
if (!(overridenSkill == null))
{
overridenSkill.RechargeBaseSkill(time - overrideTimestamp);
}
}
}
}