private void MyConfig_OnSettingsSaved()
{
try
{
//Logger.LogDebug("MyConfig_OnSettingsSaved");
foreach (var aqe in AreaToQuestEvent)
{
string settingName = aqe.Key + "Visited";
bool isVisited = (bool)MyConfig.GetValue(settingName);
//Logger.LogDebug(" " + settingName + "=" + isVisited);
if (isVisited && !QuestEventManager.Instance.HasQuestEvent(aqe.Value))
{
//Logger.LogDebug(" HasQuestEvent > true");
QuestEventManager.Instance.AddEvent(AreaToQuestEvent[aqe.Key]);
}
if (!isVisited && QuestEventManager.Instance.HasQuestEvent(aqe.Value))
{
//Logger.LogDebug(" NotQuestEvent > false");
QuestEventManager.Instance.RemoveEvent(AreaToQuestEvent[aqe.Key].EventUID);
}
}
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
}
}
//public static void Orig_DelayedRefresh(SplitScreenManager self, DictionaryExt<int, SplitPlayer> localUIs)
// {
// for (int i = 0; i < localUIs.Count; i++)
// {
// SplitPlayer splitPlayer = localUIs.Values[i];
// float foV = 0f;
// Vector3 default_OFFSET = CharacterCamera.DEFAULT_OFFSET;
// Vector2 zero = Vector2.zero;
// Vector2 zero2 = Vector2.zero;
// Rect splitRect = new Rect(0f, 0f, 0f, 0f);
// RawImage rawImage = self.RenderInImage ? GameDisplayInUI.Instance.Screens[i] : null;
// if (localUIs.Count == 1)
// {
// splitRect.position = Vector2.zero;
// splitRect.size = Vector2.one;
// foV = OptionManager.Instance.GetFoVSolo(i);
// if (self.RenderInImage)
// {
// rawImage.rectTransform.localScale = Vector3.one;
// GameDisplayInUI.Instance.Screens[1].gameObject.SetActive(false);
// }
// GameDisplayInUI.Instance.SetMultiDisplayActive(false);
// }
// else if (localUIs.Count == 2)
// {
// if (self.CurrentSplitType == SplitScreenManager.SplitType.Horizontal)
// {
// if (self.RenderInImage)
// {
// splitRect.position = ((i == 0) ? new Vector2(0.5f, 0.5f) : Vector2.zero);
// splitRect.size = new Vector2(1f, 0.5f);
// }
// else
// {
// splitRect.position = new Vector2(0f, 0.5f * (float)((i == 0) ? 1 : -1));
// splitRect.size = Vector2.one;
// }
// foV = OptionManager.Instance.GetFoVSplit(i);
// default_OFFSET.z = -5f;
// default_OFFSET.y = 0.6f;
// zero2.y = -0.5f;
// zero.y = (float)((i % 2 == 1) ? 1 : -1) * 0.5f;
// GameDisplayInUI.Instance.SetMultiDisplayActive(false);
// if (self.RenderInImage)
// {
// rawImage.rectTransform.localScale = new Vector3(1f, 0.5f, 1f);
// }
// }
// else if (self.CurrentSplitType == SplitScreenManager.SplitType.Vertical)
// {
// if (self.RenderInImage)
// {
// splitRect.position = ((i == 0) ? Vector2.zero : new Vector2(0.5f, 0f));
// splitRect.size = new Vector2(0.5f, 1f);
// }
// else
// {
// splitRect.position = new Vector2(0.5f * (float)((i == 0) ? -1 : 1), 0f);
// splitRect.size = Vector2.one;
// }
// foV = self.VSplitFoV;
// default_OFFSET.z = -2.5f;
// zero2.x = -0.5f;
// zero.x = (float)((i % 2 == 1) ? 1 : -1) * 0.5f;
// }
// else if (self.CurrentSplitType == SplitScreenManager.SplitType.MultiDisplay)
// {
// splitRect.position = Vector2.zero;
// splitRect.size = Vector2.one;
// foV = OptionManager.Instance.GetFoVSolo(i);
// if (self.RenderInImage)
// {
// rawImage.rectTransform.localScale = Vector3.one;
// }
// GameDisplayInUI.Instance.SetMultiDisplayActive(true);
// }
// if (self.RenderInImage)
// {
// GameDisplayInUI.Instance.Screens[1].gameObject.SetActive(true);
// }
// }
// else
// {
// splitRect.size = new Vector2(0.5f, 0.5f);
// Vector2 zero3 = Vector2.zero;
// zero3.x = ((i == 0 || i == 2) ? 0f : 0.5f);
// zero3.y = ((i < 2) ? 0.5f : 0f);
// splitRect.position = zero3;
// zero2.y = -0.5f;
// zero.y = (float)((i % 2 == 1) ? 1 : -1) * 0.5f;
// zero2.x = -0.5f;
// zero.x = (float)((i % 2 == 1) ? 1 : -1) * 0.5f;
// }
// CameraSettings settings;
// settings.FoV = foV;
// settings.SplitRect = splitRect;
// settings.Offset = default_OFFSET;
// settings.CameraDepth = 2 * i;
// settings.Image = rawImage;
// splitPlayer.RefreshSplitScreen(zero, zero2, settings);
// }
//}
public static void RefreshHorizontal(SplitScreenManager self)
{
if ((bool)CONFIG.GetValue(Settings.moveGlobalUiToPlayer1.ToString()))
{
var zero = Vector2.zero;
var zero2 = Vector2.zero;
if (self.LocalPlayers.Count == 2)
{
zero2.y = -0.5f;
zero.y = -0.5f;
}
var vector = Vector2.Scale(zero2, MenuManager.Instance.ScreenSize);
var anchoredPosition = Vector2.Scale(zero, vector);
if (At.GetField(MenuManager.Instance, "m_masterLoading") is LoadingFade loadingFade)
{
if (loadingFade.GetComponentInChildren <RectTransform>() is RectTransform loadingRect)
{
loadingRect.sizeDelta = vector;
loadingRect.anchoredPosition = anchoredPosition;
}
}
if (At.GetField(MenuManager.Instance, "m_prologueScreen") is ProloguePanel prologuePanel)
{
var rectTransform = prologuePanel.RectTransform;
rectTransform.sizeDelta = vector;
rectTransform.anchoredPosition = anchoredPosition;
}
}
}
private static float Modify(bool mult, float orig, float value, float limit, ModConfig config)
{
if ((bool)config.GetValue(Settings.GameBehaviour))
{
return(ModifyLogic(mult, orig, value, limit));
}
else
{
if ((bool)config.GetValue(Settings.StrictMinimum))
{
switch (limit)
{
case 50f:
limit = 1f;
break;
case 0.01f:
limit = 0f;
break;
default:
limit = 0f;
break;
}
return(ModifyLogic(mult, orig, value, limit));
}
else
{
return(value);
}
}
}
private void Setup()
{
SlotsToAdd = (int)(float)Settings.GetValue(SettingNames.QUICKSLOTS_TO_ADD);
CenterSlots = (bool)Settings.GetValue(SettingNames.CENTER_QUICKSLOTS);
// Add CustomKeybindings
for (int i = 0; i < SlotsToAdd; i++)
{
CustomKeybindings.AddAction($"QS_Instant{i + 12}", KeybindingsCategory.QuickSlot, ControlType.Both);
}
}
private void UpdateVitals(CharacterStats stats, VitalsInfo ratios, ModConfig config)
{
float _hp, _hpb, _sp, _spb, _mp, _mpb;
stats.RefreshVitalMaxStat();
if (!(bool)config.GetValue(Settings.GameBehaviour) && stats.GetComponent <Character>().IsLocalPlayer)
{
_hp = SaveManager.Instance.GetCharacterSave(stats.GetComponent <Character>().UID).PSave.Health;
_hpb = SaveManager.Instance.GetCharacterSave(stats.GetComponent <Character>().UID).PSave.BurntHealth;
_sp = SaveManager.Instance.GetCharacterSave(stats.GetComponent <Character>().UID).PSave.Stamina;
_spb = SaveManager.Instance.GetCharacterSave(stats.GetComponent <Character>().UID).PSave.BurntStamina;
_mp = SaveManager.Instance.GetCharacterSave(stats.GetComponent <Character>().UID).PSave.Mana;
_mpb = SaveManager.Instance.GetCharacterSave(stats.GetComponent <Character>().UID).PSave.BurntMana;
}
else
{
_hp = stats.MaxHealth * ratios.HealthRatio;
_hpb = stats.MaxHealth * ratios.BurntHealthRatio;
_sp = stats.MaxStamina * ratios.StaminaRatio;
_spb = stats.MaxStamina * ratios.BurntStaminaRatio;
_mp = stats.MaxMana * ratios.ManaRatio;
_mpb = stats.MaxMana * ratios.BurntManaRatio;
}
stats.SetHealth(_hp);
AT.SetValue(_hpb, typeof(CharacterStats), stats, "m_burntHealth");
AT.SetValue(_sp, typeof(CharacterStats), stats, "m_stamina");
AT.SetValue(_spb, typeof(CharacterStats), stats, "m_burntStamina");
stats.SetMana(_mp);
AT.SetValue(_mpb, typeof(CharacterStats), stats, "m_burntMana");
}
internal void Update()
{
if (Global.Lobby.PlayersInLobbyCount < 1 || NetworkLevelLoader.Instance.IsGameplayPaused)
{
return;
}
var limitInt = (int)(float)config.GetValue(Settings.PlayerLimit);
// handle custom multiplayer limit
if (PhotonNetwork.inRoom && PhotonNetwork.isMasterClient)
{
// if the room limit is not set to our custom value, do that.
if (PhotonNetwork.room.MaxPlayers != limitInt)
{
PhotonNetwork.room.MaxPlayers = limitInt;
}
// not sure if this is necessary
if (!PhotonNetwork.room.IsOpen && PhotonNetwork.room.PlayerCount < limitInt)
{
PhotonNetwork.room.IsOpen = true;
}
}
}
private void UpdatePlayer(Character player)
{
float newValue = (bool)config.GetValue(Settings.NoContainerLimit) ? -1 : 10.0f + (float)config.GetValue(Settings.PouchBonus);
if ((float)At.GetValue(typeof(ItemContainer), player.Inventory.Pouch, "m_baseContainerCapacity") != newValue)
{
At.SetValue(newValue, typeof(ItemContainer), player.Inventory.Pouch, "m_baseContainerCapacity");
}
if (player.Inventory.EquippedBag)
{
UpdateBag(player.Inventory.EquippedBag);
}
//foreach (var container in player.GetComponentsInChildren<ItemContainer>())
//{
// container.UpdateVersion();
//}
}
private void SetWalls()
{
foreach (GameObject obj in Resources.FindObjectsOfTypeAll <GameObject>())
{
if (obj.scene.name != SceneManagerHelper.ActiveSceneName)
{
continue;
}
string s = obj.name.ToLower();
if (s.Contains("cube") || s.Contains("collision") || s.Contains("collider") || s.Contains("bounds"))
{
// put this more costly check here
if (obj.GetComponentInParent <Item>())
{
continue;
}
Debug.Log(s);
//obj.SetActive(!(bool)config.GetValue(Settings.Disable));
if (obj.GetComponent <Collider>() is Collider col)
{
col.enabled = !(bool)config.GetValue(Settings.Disable);
}
var renderer = obj.GetOrAddComponent <MeshRenderer>();
if ((bool)config.GetValue(Settings.Reveal))
{
renderer.material = null;
}
else
{
DestroyImmediate(renderer);
}
}
}
}
private void UpdateCustomStats(ModConfig config)
{
if (config.ModName.Contains("Player"))
{
foreach (Character _c in CharacterManager.Instance.Characters.Values)
{
if (!_c.IsAI)
{
if ((bool)config.GetValue(Settings.ToggleSwitch))
{
ApplyCustomStats(_c, config, Settings.PlayerStats, true);
}
else
{
ApplyCustomStats(_c, config, Settings.PlayerStats, false);
}
}
}
}
else
{
foreach (Character _c in CharacterManager.Instance.Characters.Values)
{
if (_c.IsAI)
{
if ((bool)config.GetValue(Settings.ToggleSwitch))
{
ApplyCustomStats(_c, config, Settings.AIStats, true);
}
else
{
ApplyCustomStats(_c, config, Settings.AIStats, false);
}
}
}
}
}
private void ApplyCustomStats(Character character, ModConfig config, string stackSource, bool flag)
{
character.Stats.RefreshVitalMaxStat();
character.Stats.RestoreAllVitals();
VitalsInfo _ratios = LoadVitalsInfo(character.UID) ?? new VitalsInfo
{
HealthRatio = character.HealthRatio,
BurntHealthRatio = character.Stats.BurntHealthRatio,
StaminaRatio = character.StaminaRatio,
BurntStaminaRatio = character.Stats.BurntStaminaRatio,
ManaRatio = character.ManaRatio,
BurntManaRatio = character.Stats.BurntManaRatio
};
foreach (BBSetting _bbs in config.Settings)
{
if (_bbs is FloatSetting _f)
{
Tag _tag = TagSourceManager.Instance.GetTag(AT.GetTagUid(_f.Name));
bool _mult = (bool)config.GetValue(_f.Name + Settings.ModMult);
if (flag)
{
SetCustomStat(character.Stats, stackSource, _tag,
_mult ? _f.m_value / 100f : _f.m_value,
_mult, config);
}
else
{
ClearCustomStat(character.Stats, _tag, stackSource, _mult);
}
}
}
UpdateVitals(character.Stats, _ratios, config);
if (!character.IsAI)
{
SaveVitalsInfo(character.UID);
}
}
private IEnumerator DelayedOrigInvoke(CharacterStats __instance)
{
float start = Time.time;
while (Time.time - start < 5f && m_currentSyncInfos == null)
{
//Debug.Log("Delayed orig self - waiting for sync infos");
if (!NetworkLevelLoader.Instance.AllPlayerDoneLoading)
{
start += 1f;
}
yield return(new WaitForSeconds(1.0f));
}
if (m_currentSyncInfos == null || !(bool)m_currentSyncInfos.GetValue(Settings.Enemy_Balancing))
{
try
{
CharacterStats_ApplyCoopStats.ReversePatch(__instance);
}
catch { }
}
}
// actual function to set an enemy's stats
private void SetEnemyMods(ModConfig _config, CharacterStats _stats, Character m_character)
{
if (m_character == null || !m_character.IsAI || m_character.Faction == Character.Factions.Player)
{
//Debug.Log("trying to set stats for a null character, or a non-AI character");
return;
}
if (FixedEnemies.Contains(m_character.UID))
{
// Debug.Log("Fixed enemies already contains " + m_character.Name);
return;
}
var m_staminaUseModiifers = new Stat(1f);
m_staminaUseModiifers.AddMultiplierStack(new StatStack("MyStat", -0.9f));
if ((bool)_config.GetValue(Settings.Enemy_Balancing))
{
string stackSource = "CombatOverhaul";
if (!PhotonNetwork.isNonMasterClientInRoom)
{
// set health modifier
var healthTag = TagSourceManager.Instance.GetTag("77"); // 77 = max health
var healthStack = new StatStack(stackSource, (float)_config.GetValue(Settings.Enemy_Health) - 1);
_stats.RemoveStatStack(healthTag, stackSource, true);
_stats.AddStatStack(healthTag, healthStack, true);
At.SetValue(_stats.CurrentHealth * (float)_config.GetValue(Settings.Enemy_Health), typeof(CharacterStats), _stats, "m_health");
}
// set impact resistance
var impactTag = TagSourceManager.Instance.GetTag("84"); // 84 = impact res
_stats.RemoveStatStack(impactTag, stackSource, false);
var impactStack = new StatStack(stackSource, (float)_config.GetValue(Settings.Enemy_ImpactRes));
_stats.AddStatStack(impactTag, impactStack, false);
// damage bonus
var damageTag = TagSourceManager.Instance.GetTag("96"); // 96 = all damage bonus
_stats.RemoveStatStack(damageTag, stackSource, true);
var damageStack = new StatStack(stackSource, (float)_config.GetValue(Settings.Enemy_Damages) * 0.01f);
_stats.AddStatStack(damageTag, damageStack, true);
// impact modifier
var impactModifier = At.GetValue(typeof(CharacterStats), _stats, "m_impactModifier") as Stat;
impactModifier.RemoveStack(stackSource, true);
impactModifier.AddStack(new StatStack(stackSource, (float)_config.GetValue(Settings.Enemy_ImpactDmg) * 0.01f), true);
for (int i = 0; i < 6; i++)
{
// damage resistance (Capped at 99, unless already 100)
float currentRes = m_character.Stats.GetDamageResistance((DamageType.Types)i);
if (currentRes < 100)
{
var valueToSet = (float)_config.GetValue(Settings.Enemy_Resistances);
if (currentRes + valueToSet >= 99)
{
valueToSet = 99 - currentRes;
}
int tag = 113 + i; // 113 to 118 = damage resistance stats
var damageResTag = TagSourceManager.Instance.GetTag(tag.ToString());
_stats.RemoveStatStack(damageResTag, stackSource, true);
var resStack = new StatStack(stackSource, valueToSet);
_stats.AddStatStack(damageResTag, resStack, false);
}
}
}
if ((bool)_config.GetValue(Settings.All_Enemies_Allied))
{
m_character.ChangeFaction(Character.Factions.Bandits);
m_character.TargetingSystem.AlliedToSameFaction = true;
Character.Factions[] targets = new Character.Factions[] { Character.Factions.Player };
At.SetValue(targets, typeof(TargetingSystem), m_character.TargetingSystem, "TargetableFactions");
// fix skills
foreach (var uid in m_character.Inventory.SkillKnowledge.GetLearnedActiveSkillUIDs())
{
if (ItemManager.Instance.GetItem(uid) is Skill skill)
{
foreach (Shooter shooter in skill.GetComponentsInChildren <Shooter>())
{
shooter.Setup(targets, shooter.transform.parent);
}
}
}
}
FixedEnemies.Add(m_character.UID);
}
