private void OnTriggerExit2D(Collider2D collision)
{
if (collision.GetComponent <PlayerCharacterStats>())
{
playerStatsThatEntered = null;
}
}
public static Exception Finalizer(PlayerCharacterStats __instance)
{
var character = __instance.GetComponent <Character>();
if (!character)
{
return(null);
}
var charging = (bool)At.GetValue(typeof(Character), character, "m_currentlyChargingAttack");
var bowDrawn = (bool)At.GetValue(typeof(Character), character, "m_bowDrawn");
if (!charging || !bowDrawn)
{
return(null);
}
if (character.CurrentWeapon && character.CurrentWeapon.Type == Weapon.WeaponType.Bow)
{
var charger = (WeaponCharger)character.CurrentWeapon.GetExtension(nameof(WeaponCharger));
if (!charger.ChargeStarted && charger.StartChargeTime < 0)
{
At.SetValue(false, typeof(Character), character, "m_currentlyChargingAttack");
At.SetValue(false, typeof(Character), character, "m_bowDrawn");
}
}
return(null);
}
public static Exception Finalizer(PlayerCharacterStats __instance)
{
var character = __instance.GetComponent <Character>();
if (!character)
{
return(null);
}
if (!character.m_currentlyChargingAttack || !character.m_bowDrawn)
{
return(null);
}
if (character.CurrentWeapon && character.CurrentWeapon.Type == Weapon.WeaponType.Bow)
{
var charger = (WeaponCharger)character.CurrentWeapon.GetExtension(nameof(WeaponCharger));
if (!charger.ChargeStarted && charger.StartChargeTime < 0)
{
character.m_currentlyChargingAttack = false;
character.m_bowDrawn = false;
}
}
return(null);
}
private static void UpdateStats(PlayerCharacterStats instance, string fieldName, float configValue, float maxValue, float modifier)
{
FieldInfo field = typeof(CharacterStats).GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (configValue != 0)
{
field.SetValue(instance, Mathf.Clamp((float)field.GetValue(instance) - configValue * UpdateDeltaTime(instance), 0f, maxValue * modifier));
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
PlayerCharacterStats playerStats = collision.GetComponent <PlayerCharacterStats>();
if (playerStats)
{
playerStatsThatEntered = playerStats;
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
PlayerCharacterStats playerStats = collision.GetComponent <PlayerCharacterStats>();
if (playerStats)
{
playerStats.inventoryManager.AddItemToInventory(associatedItem, 1);
Destroy(this.gameObject);
}
}
static void InteractionRevive_OnActivate_Post(ref Character __state, ref Character ___m_character)
{
// receive m_character from prefix
___m_character = __state;
if (___m_character != null)
{
if (___m_character.IsPetrified)
{
___m_character.Unpetrify();
}
else
{
// Common
PlayerSaveData data = new PlayerSaveData(___m_character);
PlayerCharacterStats stats = ___m_character.PlayerStats;
// Affect burns
if (_maxVitalsToggle)
{
data.BurntHealth += (stats.MaxHealth - data.BurntHealth) * -_maxHealthLost.Value / 100f;
data.BurntStamina += (stats.MaxStamina - data.BurntStamina) * -_maxStaminaLost.Value / 100f;
if (stats.MaxMana > 0)
{
data.BurntMana += (stats.MaxMana - data.BurntMana) * -_maxManaLost.Value / 100f;
}
}
// Affect current vitals
if (_vitalsToggle)
{
data.Health = (stats.MaxHealth - data.BurntHealth) * _newHealth.Value / 100f;
data.Stamina = (stats.MaxStamina - data.BurntStamina) * _newStamina.Value / 100f;
if (stats.MaxMana > 0)
{
data.Mana += stats.CurrentMana * _manaLost.Value / 100f;
}
}
// Affect needs
if (_needsToggle)
{
data.Food += stats.Food * _foodLost.Value / 100f;
data.Drink += stats.Drink * _drinkLost.Value / 100f;
data.Sleep += stats.Sleep * _sleepLost.Value / 100f;
data.Corruption += (1000f - stats.Corruption) * _corruptionGained.Value / 100f;
}
// Finalize
data.Health = data.Health.ClampMin(1f);
___m_character.Resurrect(data, true);
}
}
}
static bool Prefix(PlayerCharacterStats __instance)
{
FieldInfo m_character = typeof(CharacterStats).GetField("m_character", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
Character character = (Character)m_character.GetValue(__instance);
if (character.CurrentSpellCast == Character.SpellCastType.Sit)
{
ApplySittingRegen(__instance);
}
return(true);
}
public void applyStatsRegen(PlayerCharacterStats instance)
{
if (gameData.StamRegenRate != 0)
{
stamRegenField.SetValue(instance, new Stat(2.4f + gameData.StamRegenRate));
}
if (gameData.HealthRegenRate != 0)
{
healthRegenField.SetValue(instance, new Stat(instance.HealthRegen + gameData.HealthRegenRate));
}
if (gameData.ManaRegenRate != 0)
{
manaRegenField.SetValue(instance, new Stat(instance.ManaRegen + gameData.ManaRegenRate));
}
}
/// <summary>
/// Regens burnt stats by the amount requested within the config file (per second), until the burn has completely worn off.
/// </summary>
/// <param name="instance">Instance of the player's stats.</param>
public void applyBurntRegen(PlayerCharacterStats instance)
{
if (gameData.BurntStaminaRegen != 0)
{
burntStamField.SetValue(instance, Mathf.Clamp((float)burntStamField.GetValue(instance) - gameData.BurntStaminaRegen * UpdateDeltaTime(instance), 0f, instance.ActiveMaxStamina * 0.9f));
}
if (gameData.BurntHealthRegen != 0)
{
burntHealthField.SetValue(instance, Mathf.Clamp((float)burntHealthField.GetValue(instance) - gameData.BurntHealthRegen * UpdateDeltaTime(instance), 0f, instance.ActiveMaxHealth * 0.9f));
}
if (gameData.BurntManaRegen != 0)
{
burntManaField.SetValue(instance, Mathf.Clamp((float)burntManaField.GetValue(instance) - gameData.BurntManaRegen * UpdateDeltaTime(instance), 0f, instance.ActiveMaxMana * 0.5f));
}
}
/// <summary>
/// Sets the current regen amount to the amount specified within the config file (per second).
/// Doesn't need to handle maximum values as the game does that internally.
/// </summary>
/// <param name="instance">Instance of the player's stats.</param>
public void applyCurrentRegen(PlayerCharacterStats instance)
{
if (gameData.CurrentStaminaRegen != 0)
{
curStamField.SetValue(instance, Mathf.Clamp((float)curStamField.GetValue(instance) + gameData.CurrentStaminaRegen * UpdateDeltaTime(instance), 0f, instance.ActiveMaxStamina));
}
if (gameData.CurrentHealthRegen != 0)
{
curHealthField.SetValue(instance, Mathf.Clamp((float)curHealthField.GetValue(instance) + gameData.CurrentHealthRegen * UpdateDeltaTime(instance), 0f, instance.ActiveMaxHealth));
}
if (gameData.CurrentManaRegen != 0)
{
curManaField.SetValue(instance, Mathf.Clamp((float)curManaField.GetValue(instance) + gameData.CurrentManaRegen * UpdateDeltaTime(instance), 0f, instance.ActiveMaxMana));
}
}
private static void ApplySittingRegen(PlayerCharacterStats instance)
{
if (Meditation.EnableBurntSitRegen.Value)
{
UpdateStats(instance, "m_burntStamina", Meditation.BurntStaminaRegen.Value, instance.ActiveMaxStamina, 0.9f);
UpdateStats(instance, "m_burntHealth", Meditation.BurntHealthRegen.Value, instance.ActiveMaxHealth, 0.9f);
UpdateStats(instance, "m_burntMana", Meditation.BurntManaRegen.Value, instance.ActiveMaxMana, 0.5f);
}
if (Meditation.EnableCurrentSitRegen.Value)
{
UpdateStats(instance, "m_stamina", Meditation.CurrentStaminaRegen.Value, instance.ActiveMaxStamina, 1.0f);
UpdateStats(instance, "m_health", Meditation.CurrentHealthRegen.Value, instance.ActiveMaxHealth, 1.0f);
UpdateStats(instance, "m_mana", Meditation.CurrentManaRegen.Value, instance.ActiveMaxMana, 1.0f);
}
}
private void ApplyMod(On.PlayerCharacterStats.orig_OnUpdateStats original, PlayerCharacterStats instance)
{
// Update the instance before applying changes so that all the stats are normalised again.
original.Invoke(instance);
// Get the required player details.
Character character = (Character)m_character.GetValue(instance);
int playerId = character.OwnerPlayerSys.PlayerID;
// If sprinting, modify the movement speed.
if (m_playerInputManager[playerId].GetButton("Sprint"))
{
m_movementSpeed.SetValue(instance, new Stat(defaultMoveSpeed * modOptions.SprintSpeedMultiplier));
// UNTESTED.
//character.Speed = moveSpeed.CurrentValue * modOptions.SprintSpeedMultiplier;
}
else
{
m_movementSpeed.SetValue(instance, new Stat(defaultMoveSpeed));
}
}
private void onUpdateStatsHook(On.PlayerCharacterStats.orig_OnUpdateStats orig, PlayerCharacterStats self)
{
orig(self);
if (Input.GetKeyDown(KeyCode.F12))
{
FieldInfo pcStatsInfo = typeof(PlayerCharacterStats).GetField("m_usedBreakthroughCount", BindingFlags.Instance | BindingFlags.NonPublic);
Debug.Log("Breakthrough use count : BEFORE " + pcStatsInfo.GetValue(self));
pcStatsInfo.SetValue(self, 0);
Debug.Log("Breakthrough use count : AFTER " + pcStatsInfo.GetValue(self));
}
}
private void GetDetails(On.PlayerCharacterStats.orig_OnStart original, PlayerCharacterStats instance)
{
this.defaultMoveSpeed = instance.MovementSpeed;
}
private void Start()
{
anim = GetComponent <Animator>();
characterStats = (PlayerCharacterStats)GetComponent <PlayerCharacterStats>();
}
public static bool Prefix(PlayerCharacterStats __instance)
{
var self = __instance;
var character = self.GetComponent <Character>();
// get config
var nolimits = NO_CONTAINER_LIMIT.Value;
var removeAllBurden = DISABLE_ALL_BURDENS.Value || character.Cheats.NotAffectedByWeightPenalties;
float totalWeight = removeAllBurden ? 0f : character.Inventory.TotalWeight;
// update general burden
if (totalWeight > 30f)
{
self.m_generalBurdenPenaltyActive = true;
float weightRatio = totalWeight / 30f;
if (weightRatio != self.m_generalBurdenRatio)
{
self.m_generalBurdenRatio = weightRatio;
self.m_movementSpeed.AddMultiplierStack("Burden", weightRatio * -0.02f);
self.m_staminaRegen.AddMultiplierStack("Burden", weightRatio * -0.05f);
self.m_staminaUseModifiers.AddMultiplierStack("Burden_Dodge", weightRatio * 0.05f, TagSourceManager.Dodge);
self.m_staminaUseModifiers.AddMultiplierStack("Burden_Sprint", weightRatio * 0.05f, TagSourceManager.Sprint);
}
}
else if (self.m_generalBurdenPenaltyActive)
{
self.m_generalBurdenRatio = 1f;
self.m_generalBurdenPenaltyActive = false;
self.m_movementSpeed.RemoveMultiplierStack("Burden");
self.m_staminaRegen.RemoveMultiplierStack("Burden");
self.m_staminaUseModifiers.RemoveMultiplierStack("Burden_Dodge");
self.m_staminaUseModifiers.RemoveMultiplierStack("Burden_Sprint");
}
// update pouch burden
float pouchWeightCapacityRatio = (removeAllBurden || nolimits)
? -1f
: character.Inventory.PouchWeightCapacityRatio;
if (pouchWeightCapacityRatio != self.m_pouchBurdenRatio)
{
self.m_pouchBurdenRatio = pouchWeightCapacityRatio;
if (self.m_pouchBurdenThreshold)
{
self.m_pouchBurdenThreshold.UpdateThresholds(Mathf.Clamp01(pouchWeightCapacityRatio - 1f), 1f, true);
}
if (self.m_pouchBurdenRatio > 1f)
{
self.m_pouchBurdenPenaltyActive = true;
self.m_movementSpeed.AddMultiplierStack("PouchBurden", self.m_pouchBurdenPenaltyCurve.Evaluate(self.m_pouchBurdenRatio - 1f));
if (character.CharacterUI)
{
character.CharacterUI.ShowInfoNotification(LocalizationManager.Instance.GetLoc("Notification_Inventory_PouchOverweight"));
}
}
else if (self.m_pouchBurdenPenaltyActive)
{
self.m_pouchBurdenPenaltyActive = false;
self.m_movementSpeed.RemoveMultiplierStack("PouchBurden");
}
}
// update bag burden
float bagWeightCapacityRatio = (removeAllBurden || nolimits)
? -1f
: character.Inventory.BagWeightCapacityRatio;
if (bagWeightCapacityRatio != self.m_bagBurdenRatio)
{
self.m_bagBurdenRatio = bagWeightCapacityRatio;
if (self.m_bagBurdenThreshold)
{
self.m_bagBurdenThreshold.UpdateThresholds(Mathf.Clamp01(bagWeightCapacityRatio - 1f), 1f, true);
}
if (self.m_bagBurdenRatio > 1f)
{
self.m_backBurdenPenaltyActive = true;
self.m_movementSpeed.AddMultiplierStack("BagBurden", self.m_bagBurdenPenaltyCurve.Evaluate(self.m_bagBurdenRatio - 1f));
if (character.CharacterUI)
{
character.CharacterUI.ShowInfoNotification(LocalizationManager.Instance.GetLoc("Notification_Inventory_BagOverweight"));
}
}
else if (self.m_backBurdenPenaltyActive)
{
self.m_backBurdenPenaltyActive = false;
self.m_movementSpeed.RemoveMultiplierStack("BagBurden");
}
}
//Instance.UpdatePlayer(m_character);
return(false);
}
//public void CustomDifficultyManaAugmentPatch(On.CharacterStats.orig_RefreshVitalMaxStat original, CharacterStats instance, bool _updateNeeds = false)
//{
// if (gameData.ManaStaminaReduction != 0 || gameData.ManaHealthReduction != 0 || gameData.ManaAugment != 0)
// {
// FieldInfo m_character = typeof(CharacterStats).GetField("m_character", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
// Character character = (Character)m_character.GetValue(instance);
// Stat maxHealthStat = (Stat)healthField.GetValue(instance);
// Stat maxStamina = (Stat)stamField.GetValue(instance);
// Stat maxManaStat = (Stat)manaField.GetValue(instance);
// StatStack manaHealthReduction = (StatStack)m_manaHealthReduction.GetValue(instance);
// StatStack manaStaminaReduction = (StatStack)m_manaStaminaReduction.GetValue(instance);
// StatStack manaAugmentation = (StatStack)m_manaAugmentation.GetValue(instance);
// if (manaHealthReduction != null && gameData.ManaHealthReduction != 0)
// {
// manaHealthReduction.Refresh((int)m_manaPoint.GetValue(instance) * gameData.ManaHealthReduction + character.Inventory.Equipment.GetMaxHealthBonus());
// }
// if (manaStaminaReduction != null && gameData.ManaStaminaReduction != 0)
// {
// manaStaminaReduction.Refresh((int)m_manaPoint.GetValue(instance) * gameData.ManaStaminaReduction);
// }
// if (manaAugmentation != null && gameData.ManaAugment != 0)
// {
// manaAugmentation.Refresh((int)m_manaPoint.GetValue(instance) * gameData.ManaAugment);
// }
// maxHealthStat.Update();
// maxStamina.Update();
// maxManaStat.Update();
// }
// else
// {
// original.Invoke(instance, _updateNeeds);
// }
//}
public void CustomDifficultyPlayerStatsPatch(On.PlayerCharacterStats.orig_OnAwake original, PlayerCharacterStats instance)
{
original.Invoke(instance);
applyStatsRegen(instance);
if (gameData.StamBoost != 0)
{
stamField.SetValue(instance, new Stat(instance.MaxStamina + gameData.StamBoost));
}
if (gameData.HealthBoost != 0)
{
healthField.SetValue(instance, new Stat(instance.MaxHealth + gameData.HealthBoost));
}
if (gameData.ManaBoost != 0)
{
manaField.SetValue(instance, new Stat(instance.MaxMana + gameData.ManaBoost));
}
if (gameData.MoveBoost != 0)
{
moveField.SetValue(instance, new Stat(instance.MovementSpeed + gameData.MoveBoost));
}
if (gameData.FoodDepleteRate != 0)
{
foodRateField.SetValue(instance, new Stat((float)foodRateField.GetValue(instance) - gameData.FoodDepleteRate));
}
if (gameData.DrinkDepleteRate != 0)
{
drinkRateField.SetValue(instance, new Stat((float)drinkRateField.GetValue(instance) - gameData.DrinkDepleteRate));
}
if (gameData.SleepDepleteRate != 0)
{
sleepRateField.SetValue(instance, new Stat((float)sleepRateField.GetValue(instance) - gameData.SleepDepleteRate));
}
if (gameData.StabRegen != 0)
{
m_stabilityRegen.SetValue(instance, new Stat((float)m_stabilityRegen.GetValue(instance) + gameData.StabRegen));
}
}
public static float UpdateDeltaTime(PlayerCharacterStats instance)
{
FieldInfo m_lastUpdateTime = typeof(CharacterStats).GetField("m_lastUpdateTime", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
return(((float)m_lastUpdateTime.GetValue(instance) == -999f) ? 0f : (Time.time - (float)m_lastUpdateTime.GetValue(instance)));
}
public void CustomDifficultyBurntStatPatch(On.PlayerCharacterStats.orig_OnUpdateStats original, PlayerCharacterStats instance)
{
if (gameData.BurntStaminaRegen != 0 || gameData.BurntHealthRegen != 0 || gameData.BurntManaRegen != 0)
{
Character character = (Character)m_character.GetValue(instance);
if (gameData.EnableBurntRegenSit)
{
if ((Character.SpellCastType)m_currentSpellCastType.GetValue(character) == Character.SpellCastType.Sit)
{
applyBurntRegen(instance);
}
}
else
{
applyBurntRegen(instance);
}
}
original.Invoke(instance);
}
public static float GetPlayerStat(PlayerCharacterStats stats, string field)
{
Stat _stat = (Stat)GetValue(typeof(PlayerCharacterStats), stats, field);
return(_stat.CurrentValue);
}
/// <summary>
/// Regens stats if any of them aren't at full.
/// </summary>
/// <param name="original">Update stats function which this is hooked onto.</param>
/// <param name="instance">Instance of the player's stats.</param>
public void MeditationBurntStatPatch(On.PlayerCharacterStats.orig_OnUpdateStats original, PlayerCharacterStats instance)
{
bool burntRegenEnabled = gameData.BurntStaminaRegen != 0 || gameData.BurntHealthRegen != 0 || gameData.BurntManaRegen != 0;
bool currentRegenEnabled = gameData.CurrentStaminaRegen != 0 || gameData.CurrentHealthRegen != 0 || gameData.CurrentManaRegen != 0;
if (burntRegenEnabled || currentRegenEnabled)
{
// Get the player.
Character character = (Character)m_character.GetValue(instance);
// Apply regen if we're sitting.
if ((Character.SpellCastType)m_currentSpellCastType.GetValue(character) == Character.SpellCastType.Sit)
{
if (burntRegenEnabled)
{
applyBurntRegen(instance);
}
if (currentRegenEnabled)
{
applyCurrentRegen(instance);
}
}
}
// Call the hooked function with the overridden player stats.
original.Invoke(instance);
}
static void PlayerCharacterStats_OnStart_Post(PlayerCharacterStats __instance) => UpdateBaseStaminaRegen(__instance);
public static bool Prefix(PlayerCharacterStats __instance)
{
var self = __instance;
// get private fields
var m_character = self.GetComponent <Character>();
var m_generalBurdenPenaltyActive = (bool)At.GetValue(typeof(PlayerCharacterStats), self, "m_generalBurdenPenaltyActive");
var m_pouchBurdenPenaltyActive = (bool)At.GetValue(typeof(PlayerCharacterStats), self, "m_pouchBurdenPenaltyActive");
var m_backBurdenPenaltyActive = (bool)At.GetValue(typeof(PlayerCharacterStats), self, "m_backBurdenPenaltyActive");
var m_movementSpeed = (Stat)At.GetValue(typeof(CharacterStats), self as CharacterStats, "m_movementSpeed");
var m_staminaRegen = (Stat)At.GetValue(typeof(CharacterStats), self as CharacterStats, "m_staminaRegen");
var m_staminaUseModifiers = (Stat)At.GetValue(typeof(CharacterStats), self as CharacterStats, "m_staminaUseModifiers");
// get config
var nolimits = (bool)Instance.config.GetValue(Settings.NoContainerLimit);
var removeAllBurden = (bool)Instance.config.GetValue(Settings.DisableAllBurdens) || m_character.Cheats.NotAffectedByWeightPenalties;
float totalWeight = removeAllBurden ? 0f : m_character.Inventory.TotalWeight;
// update general burden
if (totalWeight > 30f)
{
At.SetValue(true, typeof(PlayerCharacterStats), self, "m_generalBurdenPenaltyActive");
float num = totalWeight / 30f;
float m_generalBurdenRatio = (float)At.GetValue(typeof(PlayerCharacterStats), self, "m_generalBurdenRatio");
if (num != m_generalBurdenRatio)
{
At.SetValue(num, typeof(PlayerCharacterStats), self, "m_generalBurdenRatio");
m_movementSpeed.AddMultiplierStack("Burden", num * -0.02f);
m_staminaRegen.AddMultiplierStack("Burden", num * -0.05f);
m_staminaUseModifiers.AddMultiplierStack("Burden_Dodge", num * 0.05f, TagSourceManager.Dodge);
m_staminaUseModifiers.AddMultiplierStack("Burden_Sprint", num * 0.05f, TagSourceManager.Sprint);
}
}
else if (m_generalBurdenPenaltyActive)
{
At.SetValue(1f, typeof(PlayerCharacterStats), self, "m_generalBurdenRatio");
At.SetValue(false, typeof(PlayerCharacterStats), self, "m_generalBurdenPenaltyActive");
m_movementSpeed.RemoveMultiplierStack("Burden");
m_staminaRegen.RemoveMultiplierStack("Burden");
m_staminaUseModifiers.RemoveMultiplierStack("Burden_Dodge");
m_staminaUseModifiers.RemoveMultiplierStack("Burden_Sprint");
}
// update pouch burden
float pouchWeightCapacityRatio = (removeAllBurden || nolimits) ? -1f : m_character.Inventory.PouchWeightCapacityRatio;
float m_pouchBurdenRatio = (float)At.GetValue(typeof(PlayerCharacterStats), self, "m_pouchBurdenRatio");
if (pouchWeightCapacityRatio != m_pouchBurdenRatio)
{
At.SetValue(pouchWeightCapacityRatio, typeof(PlayerCharacterStats), self, "m_pouchBurdenRatio");
m_pouchBurdenRatio = pouchWeightCapacityRatio;
var m_pouchBurdenThreshold = (StatThreshold)At.GetValue(typeof(PlayerCharacterStats), self, "m_pouchBurdenThreshold");
if (m_pouchBurdenThreshold)
{
m_pouchBurdenThreshold.UpdateThresholds(Mathf.Clamp01(pouchWeightCapacityRatio - 1f), 1f, true);
}
if (m_pouchBurdenRatio > 1f)
{
At.SetValue(true, typeof(PlayerCharacterStats), self, "m_pouchBurdenPenaltyActive");
var m_pouchBurdenPenaltyCurve = (AnimationCurve)At.GetValue(typeof(PlayerCharacterStats), self, "m_pouchBurdenPenaltyCurve");
float value = m_pouchBurdenPenaltyCurve.Evaluate(m_pouchBurdenRatio - 1f);
m_movementSpeed.AddMultiplierStack("PouchBurden", value);
if (m_character.CharacterUI)
{
m_character.CharacterUI.ShowInfoNotification(LocalizationManager.Instance.GetLoc("Notification_Inventory_PouchOverweight"));
}
}
else if (m_pouchBurdenPenaltyActive)
{
At.SetValue(false, typeof(PlayerCharacterStats), self, "m_pouchBurdenPenaltyActive");
m_movementSpeed.RemoveMultiplierStack("PouchBurden");
}
}
// update bag burden
float bagWeightCapacityRatio = (removeAllBurden || nolimits) ? -1f : m_character.Inventory.BagWeightCapacityRatio;
float m_bagBurdenRatio = (float)At.GetValue(typeof(PlayerCharacterStats), self, "m_bagBurdenRatio");
if (bagWeightCapacityRatio != m_bagBurdenRatio)
{
m_bagBurdenRatio = bagWeightCapacityRatio;
At.SetValue(bagWeightCapacityRatio, typeof(PlayerCharacterStats), self, "m_bagBurdenRatio");
var m_bagBurdenThreshold = (StatThreshold)At.GetValue(typeof(PlayerCharacterStats), self, "m_bagBurdenThreshold");
if (m_bagBurdenThreshold)
{
m_bagBurdenThreshold.UpdateThresholds(Mathf.Clamp01(bagWeightCapacityRatio - 1f), 1f, true);
}
if (m_bagBurdenRatio > 1f)
{
At.SetValue(true, typeof(PlayerCharacterStats), self, "m_backBurdenPenaltyActive");
var m_bagBurdenPenaltyCurve = (AnimationCurve)At.GetValue(typeof(PlayerCharacterStats), self, "m_bagBurdenPenaltyCurve");
float value2 = m_bagBurdenPenaltyCurve.Evaluate(m_bagBurdenRatio - 1f);
m_movementSpeed.AddMultiplierStack("BagBurden", value2);
if (m_character.CharacterUI)
{
m_character.CharacterUI.ShowInfoNotification(LocalizationManager.Instance.GetLoc("Notification_Inventory_BagOverweight"));
}
}
else if (m_backBurdenPenaltyActive)
{
At.SetValue(false, typeof(PlayerCharacterStats), self, "m_backBurdenPenaltyActive");
m_movementSpeed.RemoveMultiplierStack("BagBurden");
}
}
//Instance.UpdatePlayer(m_character);
return(false);
}
public void CustomDifficultyWeightPatch(On.PlayerCharacterStats.orig_OnUpdateWeight original, PlayerCharacterStats instance)
{
original.Invoke(instance);
if (gameData.PouchCapacity != 0 || gameData.BackpackCapacity != 0)
{
Character character = (Character)m_character.GetValue(instance);
Stat s1 = (Stat)moveField.GetValue(instance);
Stat s2 = (Stat)stamRegenField.GetValue(instance);
Stat s3 = (Stat)m_staminaUseModifiers.GetValue(instance);
if ((bool)m_generalBurdenPenaltyActive.GetValue(instance))
{
m_generalBurdenRatio.SetValue(instance, 1f);
m_generalBurdenPenaltyActive.SetValue(instance, false);
s1.RemoveMultiplierStack("Burden");
s2.RemoveMultiplierStack("Burden");
s3.RemoveMultiplierStack("Burden_Dodge");
s3.RemoveMultiplierStack("Burden_Sprint");
}
if (!character.Cheats.NotAffectedByWeightPenalties)
{
float totalWeight = character.Inventory.TotalWeight;
if (totalWeight > gameData.PouchCapacity + gameData.BackpackCapacity)
{
m_generalBurdenPenaltyActive.SetValue(instance, true);
float num = totalWeight / gameData.PouchCapacity + gameData.BackpackCapacity;
if (num != (float)m_generalBurdenRatio.GetValue(instance))
{
m_generalBurdenRatio.SetValue(instance, num);
s1.AddMultiplierStack("Burden", num * -0.02f);
s2.AddMultiplierStack("Burden", num * -0.05f);
s3.AddMultiplierStack("Burden_Dodge", num * 0.05f, TagSourceManager.Dodge);
s3.AddMultiplierStack("Burden_Sprint", num * 0.05f, TagSourceManager.Sprint);
}
}
}
moveField.SetValue(instance, s1);
stamRegenField.SetValue(instance, s2);
m_staminaUseModifiers.SetValue(instance, s3);
}
}
