Exemplo n.º 1
0
        //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;
                }
            }
        }
Exemplo n.º 2
0
        public void Serialize(TrapEffectRecipe recipe, DeployableTrap trap)
        {
            var items = (Item[])At.GetField(recipe, "m_compatibleItems");
            var tags  = (TagSourceSelector[])At.GetField(recipe, "m_compatibleTags");

            trap.GetCompatibleFilters();

            var compatibleTags = ((List <Tag>[])At.GetField <DeployableTrap>("COMPATIBLE_TAGS"))[(int)trap.CurrentTrapType];

            if (items != null)
            {
                foreach (var item in items)
                {
                    switch (trap.CurrentTrapType)
                    {
                    case DeployableTrap.TrapType.PressurePlateTrap:
                        if (!item.HasTag(TagSourceManager.PlateTrapComponent) && !HasAnyTag(item, compatibleTags))
                        {
                            continue;
                        }
                        break;

                    case DeployableTrap.TrapType.TripWireTrap:
                        if (!item.HasTag(TagSourceManager.TripWireTrapComponent) && !HasAnyTag(item, compatibleTags))
                        {
                            continue;
                        }
                        break;
                    }

                    this.CompatibleItemIDs.Add(item.Name);
                }
            }


            if (tags != null)
            {
                foreach (var tag in tags)
                {
                    this.CompatibleItemTags.Add(tag.Tag.TagName);
                }
            }

            if (recipe.TrapEffectsPrefab)
            {
                this.StandardEffects = new List <DM_Effect>();
                foreach (var effect in recipe.TrapEffectsPrefab.GetComponents <Effect>())
                {
                    this.StandardEffects.Add(DM_Effect.ParseEffect(effect));
                }
            }
            if (recipe.HiddenTrapEffectsPrefab)
            {
                this.HiddenEffects = new List <DM_Effect>();
                foreach (var effect in recipe.HiddenTrapEffectsPrefab.GetComponents <Effect>())
                {
                    this.HiddenEffects.Add(DM_Effect.ParseEffect(effect));
                }
            }
        }
Exemplo n.º 3
0
        // ~~~~~~~~~ Core internal ~~~~~~~~~

        internal static void OnSaveInstanceSave(SaveInstance __instance)
        {
            try
            {
                if (__instance.CharSave == null || string.IsNullOrEmpty(__instance.CharSave.CharacterUID))
                {
                    return;
                }

                var charUID = __instance.CharSave.CharacterUID;

                bool isHost = !PhotonNetwork.isNonMasterClientInRoom && !(bool)At.GetField(NetworkLevelLoader.Instance, "m_saveOnHostLost") &&
                              CharacterManager.Instance?.GetWorldHostCharacter()?.UID == charUID;

                // Save internal stuff for the host
                if (isHost)
                {
                    SLCharacterSaveManager.SaveCharacters();
                    SLItemSpawnSaveManager.SaveItemSpawns();
                }

                // Save custom extensions from other mods
                PlayerSaveExtension.SaveAllExtensions(CharacterManager.Instance.GetCharacter(charUID), isHost);
            }
            catch (Exception ex)
            {
                SL.LogWarning("Exception on SaveInstance.Save!");
                SL.LogInnerException(ex);
            }
        }
Exemplo n.º 4
0
        public static void Prefix(Building __instance)
        {
            if (!StoreManager.Instance.IsDlcInstalled(OTWStoreAPI.DLCs.DLC2) ||
                !BuildingHelperMod.Instance.settings.AutoFinishBuildings ||
                PhotonNetwork.isNonMasterClientInRoom)
            {
                return;
            }

            int sanity = 5;

            while (sanity >= 0 && __instance.CurrentPhase.ConstructionType == Building.ConstructionPhase.Type.WIP)
            {
                int cur = (int)At.GetField(__instance, "m_currentBasicPhaseIndex");
                if (cur < 0)
                {
                    cur = 0;
                }
                else
                {
                    cur++;
                }
                At.SetField(__instance, "m_currentBasicPhaseIndex", cur);

                sanity--;
            }

            if (sanity < 0)
            {
                SL.LogWarning("Did more than 6 loops trying to auto-finish building, something went wrong!");
            }

            At.SetField(__instance, "m_remainingConstructionTime", 0f);
        }
Exemplo n.º 5
0
        public static DM_LootContainer ParseLootContainer(TreasureChest loot)
        {
            var lootHolder = new DM_LootContainer
            {
                Name   = loot.Name?.Trim(),
                ItemID = loot.ItemID,
                UID    = loot.UID
            };

            if (lootHolder.Name == "Pocket")
            {
                lootHolder.Name = "Corpse";
            }

            if (At.GetField(loot as SelfFilledItemContainer, "m_drops") is List <Dropable> droppers)
            {
                foreach (Dropable dropper in droppers)
                {
                    var dropableHolder = DM_DropTable.ParseDropable(dropper, null, lootHolder.Name);
                    lootHolder.DropTables.Add(dropableHolder.Name);
                }
            }

            string dir      = Serializer.Folders.Scenes + "/" + SceneManager.Instance.GetCurrentRegion() + "/" + SceneManager.Instance.GetCurrentLocation(loot.transform.position);
            string saveName = lootHolder.Name + "_" + lootHolder.UID;

            Serializer.SaveToXml(dir + "/LootContainers", saveName, lootHolder);

            return(lootHolder);
        }
Exemplo n.º 6
0
        public override void Update()
        {
            // update position
            var character = CharacterManager.Instance.GetFirstLocalCharacter();

            if (character)
            {
                m_positionInput.text = character.transform.position.ToString("F3");
            }
            else
            {
                m_positionInput.text = "<color=grey><i>No character loaded...</i></color>";
            }

            // update current sound track
            if (References.GLOBALAUDIOMANAGER)
            {
                var music = (GlobalAudioManager.Sounds)At.GetField <GlobalAudioManager>("s_currentMusic");
                m_soundInput.text = music.ToString();
            }
            else
            {
                m_soundInput.text = "<color=grey><i>GlobalAudioManager still loading...</i></color>";
            }
        }
        public static void GetStatusLocalization(StatusEffect effect, out string name, out string desc)
        {
            var namekey = (string)At.GetField(effect, "m_nameLocKey");

            name = LocalizationManager.Instance.GetLoc(namekey);
            var desckey = (string)At.GetField(effect, "m_descriptionLocKey");

            desc = LocalizationManager.Instance.GetLoc(desckey);
        }
Exemplo n.º 8
0
            public static void Postfix(OptionsPanel __instance)
            {
                var slider = (Slider)At.GetField(__instance, "m_sldFoVSplit");

                if (slider)
                {
                    slider.maxValue = 90f;
                }
            }
Exemplo n.º 9
0
        public override void SerializeEffect <T>(T effect)
        {
            var comp = effect as AddAllStatusEffectBuildUp;

            BuildUpValue     = comp.BuildUpValue;
            NoDealer         = comp.NoDealer;
            AffectController = comp.AffectController;
            BuildUpBonus     = (float)At.GetField(comp, "m_buildUpBonus");
        }
Exemplo n.º 10
0
        public static void Prefix(Deployable __instance)
        {
            var item = At.GetField(__instance as ItemExtension, "m_item") as Item;

            if (!item)
            {
                item = __instance.GetComponent <Item>();
            }

            At.SetField(__instance as ItemExtension, "m_item", item);
        }
Exemplo n.º 11
0
        public override void SerializeStatus(StatusEffect status)
        {
            base.SerializeStatus(status);

            var comp = status as Disease;

            this.AutoHealTime   = (int)At.GetField(comp, "m_autoHealTime");
            this.CanDegenerate  = (bool)At.GetField(comp, "m_canDegenerate");
            this.DegenerateTime = (float)At.GetField(comp, "m_degenerateTime");
            this.DiseaseType    = (Diseases)At.GetField(comp, "m_diseasesType");
            this.SleepHealTime  = comp.StraightSleepHealTime;
        }
Exemplo n.º 12
0
            public static void Prefix(LocalizationManager __instance)
            {
                var localizationData = At.GetField(__instance, "m_localizationData") as LocalizationReference;

                foreach (LocalizationReference.Localization loc in localizationData.Languages)
                {
                    if (loc.DefaultName == "English")
                    {
                        LocalizationHolder.SaveLocalization(loc);
                    }
                }
            }
Exemplo n.º 13
0
        public override void SerializeStatusEffect(StatusEffect status, EffectPreset preset)
        {
            base.SerializeStatusEffect(status, preset);

            var disease = status as Disease;

            CanDegenerate         = disease.CanHealByItself;
            StraightSleepHealTime = disease.StraightSleepHealTime;
            CanBeHealedBySleeping = disease.CanBeHealedBySleeping;
            AutoHealTime          = (int)At.GetField(disease, "m_autoHealTime");
            DegenerateTime        = (float)At.GetField(disease, "m_degenerateTime");
            DiseaseType           = (Diseases)At.GetField(disease, "m_diseasesType");
        }
Exemplo n.º 14
0
 public static void Postfix(MapDisplay __instance, CharacterUI _owner)
 {
     if ((bool)CONFIG.GetValue(Settings.moveGlobalUiToPlayer1.ToString()))
     {
         var rect = (RectTransform)At.GetField(_owner, "m_rectTransform");
         __instance.RectTransform.anchoredPosition = rect.anchoredPosition;
         __instance.RectTransform.sizeDelta        = rect.sizeDelta;
     }
     else
     {
         __instance.RectTransform.anchoredPosition = Vector2.zero;
         __instance.RectTransform.sizeDelta        = Vector2.zero;
     }
 }
Exemplo n.º 15
0
        public void ApplyToCharacter(Character character)
        {
            // set faction
            character.ChangeFaction(Faction);

            // gear
            TryEquip(character, Weapon);
            TryEquip(character, Shield);

            // AI
            var ai = character.GetComponent <CharacterAI>();

            foreach (var state in ai.AiStates)
            {
                if (state is AISCombat aisCombat)
                {
                    aisCombat.CanDodge = CanDodge;
                    aisCombat.CanBlock = CanBlock;
                }
            }

            // stats
            var stats = character.GetComponent <CharacterStats>();

            var m_maxHealthStat = (Stat)At.GetField(stats, "m_maxHealthStat");

            m_maxHealthStat.AddStack(new StatStack(StatSourceID, Health - 100), false);

            var m_impactResistance = (Stat)At.GetField(stats, "m_impactResistance");

            m_impactResistance.AddStack(new StatStack(StatSourceID, ImpactResist), false);

            var m_damageProtection = (Stat[])At.GetField(stats, "m_damageProtection");

            m_damageProtection[0].AddStack(new StatStack(StatSourceID, Protection), false);

            var m_damageResistance = (Stat[])At.GetField(stats, "m_damageResistance");

            for (int i = 0; i < 6; i++)
            {
                m_damageResistance[i].AddStack(new StatStack(StatSourceID, Damage_Resists[i]), false);
            }

            var m_damageTypesModifier = (Stat[])At.GetField(stats, "m_damageTypesModifier");

            for (int i = 0; i < 6; i++)
            {
                m_damageTypesModifier[i].AddStack(new StatStack(StatSourceID, Damage_Bonus[i]), false);
            }
        }
Exemplo n.º 16
0
        public override void SerializeItem(Item item, DM_Item holder)
        {
            base.SerializeItem(item, holder);

            var trap = item as DeployableTrap;

            var recipes = (TrapEffectRecipe[])At.GetField(trap, "m_trapRecipes");

            foreach (var recipe in recipes)
            {
                var dmRecipe = new DM_TrapRecipe();
                dmRecipe.Serialize(recipe, trap);
                TrapRecipeEffects.Add(dmRecipe);
            }
        }
Exemplo n.º 17
0
        public static DM_Gatherable ParseGatherable(Gatherable gatherable)
        {
            var gatherableHolder = new DM_Gatherable
            {
                Name   = gatherable.Name?.Trim(),
                ItemID = gatherable.ItemID
            };

            if (At.GetField(gatherable as SelfFilledItemContainer, "m_drops") is List <Dropable> droppers)
            {
                if (droppers == null || droppers.Count < 1)
                {
                    //SL.LogWarning("droppers is null or list count is 0!");
                }
                else
                {
                    foreach (Dropable dropper in droppers)
                    {
                        var dropableHolder = DM_DropTable.ParseDropable(dropper);
                        gatherableHolder.DropTables.Add(dropableHolder.Name);
                    }
                }
            }

            if (gatherableHolder.Name == "Fish")
            {
                gatherableHolder.Name = "Fishing Spot (" + gatherableHolder.DropTables[0] + ")";
            }

            if (gatherableHolder.Name.Contains("vein"))
            {
                gatherableHolder.Name.Replace("vein", "Vein");

                if (gatherableHolder.Name.Contains("Iron") || gatherableHolder.Name == "Palladium")
                {
                    foreach (var table in gatherableHolder.DropTables)
                    {
                        if (table.Contains("Tourmaline"))
                        {
                            gatherableHolder.Name += " (Tourmaline)";
                            break;
                        }
                    }
                }
            }

            return(gatherableHolder);
        }
Exemplo n.º 18
0
        internal static void OnEnvironmentSaveLoaded(DictionaryExt <string, CharacterSaveInstanceHolder> charSaves)
        {
            var host = CharacterManager.Instance.GetWorldHostCharacter();

            if (!host || !host.IsPhotonPlayerLocal)
            {
                SL.WasLastSceneReset = false;
                return;
            }

            if (charSaves.TryGetValue(host.UID, out CharacterSaveInstanceHolder holder))
            {
                if (At.GetField(holder.CurrentSaveInstance, "m_loadedScene") is EnvironmentSave loadedScene)
                {
                    var areaHolder = AreaManager.Instance.GetAreaFromSceneName(loadedScene.AreaName);
                    if (areaHolder == null)
                    {
                        SLCharacterSaveManager.SceneResetWanted = true;
                    }
                    else
                    {
                        var area = (AreaManager.AreaEnum)AreaManager.Instance.GetAreaFromSceneName(loadedScene.AreaName).ID;
                        if (IsPermanent(area))
                        {
                            SLCharacterSaveManager.SceneResetWanted = false;
                        }
                        else
                        {
                            float age = (float)(loadedScene.GameTime - EnvironmentConditions.GameTime);
                            SLCharacterSaveManager.SceneResetWanted = AreaManager.Instance.IsAreaExpired(loadedScene.AreaName, age);
                        }
                    }
                }
                else
                {
                    SLCharacterSaveManager.SceneResetWanted = true;
                }
            }
            else
            {
                SLCharacterSaveManager.SceneResetWanted = true;
            }

            SL.WasLastSceneReset = SLCharacterSaveManager.SceneResetWanted;

            SL.Log("Set SceneResetWanted: " + SLCharacterSaveManager.SceneResetWanted);
        }
Exemplo n.º 19
0
        public static void Postfix(Building __instance)
        {
            if (!StoreManager.Instance.IsDlcInstalled(OTWStoreAPI.DLCs.DLC2) ||
                !BuildingHelperMod.Instance.settings.AutoFinishBuildings ||
                PhotonNetwork.isNonMasterClientInRoom)
            {
                return;
            }

            At.SetField(__instance, "m_remainingConstructionTime", 0f);

            var pending = (int)At.GetField(__instance, "m_pendingUpgradePhaseIndex");

            At.SetField(__instance, "m_currentUpgradePhaseIndex", pending);
            At.SetField(__instance, "m_pendingUpgradePhaseIndex", -1);
            __instance.UpdateConstruction(0f);
        }
Exemplo n.º 20
0
        public override void SerializeItem(Item item, DM_Item holder)
        {
            base.SerializeItem(item, holder);

            var bag      = item as Bag;
            var template = holder as DM_Bag;

            template.Capacity            = bag.BagCapacity;
            template.Restrict_Dodge      = bag.RestrictDodge;
            template.InventoryProtection = bag.InventoryProtection;

            if (bag.GetComponentInChildren <Preserver>() is Preserver p &&
                At.GetField(p, "m_preservedElements") is List <Preserver.PreservedElement> list &&
                list.Count > 0)
            {
                template.Preserver_Amount = list[0].Preservation;
                template.Nullify_Perish   = p.NullifyPerishing;
            }
        }
Exemplo n.º 21
0
        public override void SerializeItem(Item item, DM_Item holder)
        {
            base.SerializeItem(item, holder);

            var building = item as Building;

            var constructionPhases = At.GetField(building, "m_constructionPhases") as Building.ConstructionPhase[];

            foreach (var phase in constructionPhases)
            {
                ConstructionPhases.Add(DM_ConstructionPhase.SerializePhase(phase));
            }

            var upgradePhases = At.GetField(building, "m_upgradePhases") as Building.ConstructionPhase[];

            foreach (var phase in upgradePhases)
            {
                UpgradePhases.Add(DM_ConstructionPhase.SerializePhase(phase));
            }
        }
        public static void Postfix(SelfFilledItemContainer __instance)
        {
            if (PhotonNetwork.isNonMasterClientInRoom)
            {
                return;
            }

            var drops = At.GetField(__instance, "m_drops") as List <Dropable>;

            foreach (var dropable in drops)
            {
                foreach (var dropAddition in SL_DropTableAddition.s_registeredDropTableSources)
                {
                    if (dropAddition.IsTargeting(dropable.name))
                    {
                        dropAddition.GenerateItems(__instance.transform);
                    }
                }
            }
        }
Exemplo n.º 23
0
 public static DM_ConstructionPhase SerializePhase(Building.ConstructionPhase phase)
 {
     return(new DM_ConstructionPhase
     {
         PhaseType = phase.ConstructionType,
         HouseCountRequirement = phase.HouseCountRequirements,
         ConstructionTime = phase.GetConstructionTime(),
         ConstructionCosts = (BuildingResourceValues)At.GetField(phase, "m_constructionCosts"),
         UpkeepCosts = phase.UpkeepCosts,
         UpkeepProductions = phase.UpkeepProductions,
         CapacityBonus = phase.CapacityBonus,
         MultiplyProductionPerHouse = phase.MultiplyProductionPerHouse,
         HousingValue = phase.HousingValue,
         RareMaterial = phase.RareMaterial?.Name,
         BuildingRequirements = (from req in phase.BuildingRequirements
                                 select new DM_BuildingRequirement()
         {
             ReqBuildingName = req.ReqBuilding?.Name,
             ReqUpgradeIndex = req.UpgradeIndex
         }).ToList(),
     });
 }
        public override void SerializeStats(ItemStats stats, DM_ItemStats holder)
        {
            base.SerializeStats(stats, holder);

            try
            {
                var item = stats.GetComponent <Item>();

                var eStats = stats as EquipmentStats;
                Cooldown_Reduction = eStats.CooldownReduction;
                Hunger_Affect      = eStats.HungerModifier;
                Thirst_Affect      = eStats.ThirstModifier;
                Fatigue_Affect     = eStats.SleepModifier;

                Impact_Resistance     = eStats.ImpactResistance;
                Damage_Protection     = eStats.GetDamageProtection(DamageType.Types.Physical);
                Stamina_Use_Penalty   = eStats.StaminaUsePenalty;
                Mana_Use_Modifier     = (float)At.GetField(eStats, "m_manaUseModifier");
                Mana_Regen            = eStats.ManaRegenBonus;
                Movement_Penalty      = eStats.MovementPenalty;
                Pouch_Bonus           = eStats.PouchCapacityBonus;
                Heat_Protection       = eStats.HeatProtection;
                Cold_Protection       = eStats.ColdProtection;
                Corruption_Protection = eStats.CorruptionResistance;

                Damage_Bonus      = At.GetField(eStats, "m_damageAttack") as float[];
                Damage_Resistance = At.GetField(eStats, "m_damageResistance") as float[];
                Impact_Bonus      = eStats.ImpactModifier;

                BarrierProtection            = eStats.BarrierProtection;
                GlobalStatusEffectResistance = (float)At.GetField(eStats, "m_baseStatusEffectResistance");
                StaminaRegenModifier         = eStats.StaminaRegenModifier;
            }
            catch (Exception e)
            {
                SL.Log("Exception getting stats of " + stats.name + "\r\n" + e.Message + "\r\n" + e.StackTrace);
            }
        }
        public static void ParseAllRecipes()
        {
            var recipes = (Dictionary <int, EnchantmentRecipe>)At.GetField(RecipeManager.Instance, "m_enchantmentRecipes");

            if (recipes == null)
            {
                SL.Log("null enchantment dict!");
                return;
            }

            SL.Log("Parsing Enchantments...");

            foreach (var recipe in recipes.Values)
            {
                if (recipe.RecipeID <= 0)
                {
                    recipe.InitID();
                }

                var enchantment = ResourcesPrefabManager.Instance.GetEnchantmentPrefab(recipe.RecipeID);

                if (!enchantment)
                {
                    SL.Log("null enchantment!");
                    continue;
                }

                var template = new DM_EnchantmentRecipe();
                template.Serialize(recipe, enchantment);

                string dir      = Serializer.Folders.Enchantments;
                string saveName = template.Name + " (" + template.RecipeID + ")";

                ListManager.EnchantmentRecipes.Add(template.RecipeID.ToString(), template);
                Serializer.SaveToXml(dir, saveName, template);
            }
        }
        public static void Prefix(LootableOnDeath __instance, bool _loadedDead)
        {
            if (_loadedDead || !__instance.enabled || PhotonNetwork.isNonMasterClientInRoom || !SL_DropTableAddition.s_registeredDropTableSources.Any())
            {
                return;
            }

            var m_character = At.GetField(__instance, "m_character") as Character;

            if (!m_character)
            {
                return;
            }

            bool wasAlive = (bool)At.GetField(__instance, "m_wasAlive");

            if (!m_character.Alive || (m_character.IsDead && wasAlive))
            {
                var drops = (Dropable[])At.GetField(__instance, "m_lootDroppers");

                if (drops == null || !drops.Any())
                {
                    return;
                }

                foreach (var dropable in drops)
                {
                    foreach (var dropAddition in SL_DropTableAddition.s_registeredDropTableSources)
                    {
                        if (dropAddition.IsTargeting(dropable.name))
                        {
                            dropAddition.GenerateItems(m_character.Inventory.Pouch.transform);
                        }
                    }
                }
            }
        }
Exemplo n.º 27
0
        public static DM_Merchant ParseMerchant(Merchant merchant)
        {
            var merchantHolder = new DM_Merchant
            {
                Name = merchant.ShopName?.Trim(),
                UID  = merchant.HolderUID
            };

            if (At.GetField(merchant, "m_dropableInventory") is Dropable dropper)
            {
                merchantHolder.DropTable = DM_DropTable.ParseDropable(dropper, merchant);
            }

            foreach (var priceMod in merchant.GetComponentsInChildren <PriceModifier>())
            {
                if (priceMod.BuyMultiplierAdded != 0f || priceMod.SellMultiplierAdded != 0f)
                {
                    //SL.Log("Merchant " + merchantHolder.Name + " has buy or sell mods! Buy: " + priceMod.BuyMultiplierAdded + ", Sell: " + priceMod.SellMultiplierAdded);
                    merchantHolder.BuyModifiers.Add(priceMod.BuyMultiplierAdded);
                    merchantHolder.SellModifiers.Add(priceMod.SellMultiplierAdded);
                }
            }

            string dir      = Serializer.Folders.Merchants;
            string saveName = SceneManager.Instance.GetCurrentLocation(merchant.transform.position) + " - " + merchantHolder.Name + " (" + merchantHolder.UID + ")";

            if (ListManager.Merchants.ContainsKey(saveName))
            {
                return(null);
            }

            Serializer.SaveToXml(dir, saveName, merchantHolder);

            ListManager.Merchants.Add(saveName, merchantHolder);

            return(merchantHolder);
        }
Exemplo n.º 28
0
        public static DM_DropTable ParseDropable(Dropable dropable, Merchant merchant = null, string containerName = "")
        {
            if (!dropable)
            {
                return(null);
            }

            var dropTableHolder = new DM_DropTable
            {
                Name = dropable.name
            };

            if (dropTableHolder.Name == "InventoryTable" && merchant)
            {
                dropTableHolder.Name = SceneManager.Instance.GetCurrentLocation(merchant.transform.position) + " - " + merchant.ShopName;
            }

            dropTableHolder.Name = dropTableHolder.Name.Trim();

            if (At.GetField(dropable, "m_allGuaranteedDrops") is List <GuaranteedDrop> guaranteedDrops)
            {
                foreach (GuaranteedDrop gDropper in guaranteedDrops)
                {
                    if (At.GetField(gDropper, "m_itemDrops") is List <BasicItemDrop> gItemDrops && gItemDrops.Count > 0)
                    {
                        foreach (BasicItemDrop gItemDrop in gItemDrops)
                        {
                            if (!gItemDrop.DroppedItem)
                            {
                                continue;
                            }

                            //var pos = dropable.transform.position;
                            AddGuaranteedDrop(dropTableHolder,
                                              gItemDrop.DroppedItem.ItemID,
                                              gItemDrop.DroppedItem.Name,
                                              gItemDrop.MinDropCount,
                                              gItemDrop.MaxDropCount);
                        }
                    }
                }
            }

            if (At.GetField(dropable, "m_conditionalGuaranteedDrops") is List <ConditionalGuaranteedDrop> conditionalGuaranteed)
            {
                foreach (var guaConditional in conditionalGuaranteed)
                {
                    if (!guaConditional.Dropper)
                    {
                        continue;
                    }

                    var drops = At.GetField(guaConditional.Dropper, "m_itemDrops") as List <BasicItemDrop>;
                    foreach (var gItemDrop in drops)
                    {
                        if (!gItemDrop.DroppedItem)
                        {
                            continue;
                        }

                        //var pos = dropable.transform.position;
                        AddGuaranteedDrop(dropTableHolder,
                                          gItemDrop.DroppedItem.ItemID,
                                          gItemDrop.DroppedItem.Name,
                                          gItemDrop.MinDropCount,
                                          gItemDrop.MaxDropCount);
                    }
                }
            }

            if (At.GetField(dropable, "m_mainDropTables") is List <DropTable> dropTables)
            {
                foreach (DropTable table in dropTables)
                {
                    if (ParseDropTable(dropTableHolder, containerName, dropable, table) is DropGeneratorHolder generatorHolder)
                    {
                        dropTableHolder.Random_Tables.Add(generatorHolder);
                    }
                }
            }

            if (At.GetField(dropable, "m_conditionalDropTables") is List <ConditionalDropTable> conditionals)
            {
                foreach (var conTable in conditionals)
                {
                    if (ParseDropTable(dropTableHolder, containerName, dropable, conTable.Dropper) is DropGeneratorHolder generatorHolder)
                    {
                        generatorHolder.DropConditionType = conTable.DropCondition.GetType().FullName;

                        dropTableHolder.Random_Tables.Add(generatorHolder);
                    }
                }
            }

            if (merchant == null)
            {
                string dir = Serializer.Folders.DropTables;
                if (!File.Exists(dir + "/" + dropTableHolder.Name + ".xml"))
                {
                    ListManager.DropTables.Add(dropTableHolder.Name, dropTableHolder);
                    Serializer.SaveToXml(dir, dropTableHolder.Name, dropTableHolder);
                }
            }

            return(dropTableHolder);
        }
Exemplo n.º 29
0
        public static DropGeneratorHolder ParseDropTable(DM_DropTable dropTableHolder, string containerName, Dropable dropper, DropTable table)
        {
            var generatorHolder = new DropGeneratorHolder
            {
                MinNumberOfDrops = table.MinNumberOfDrops,
                MaxNumberOfDrops = table.MaxNumberOfDrops,
                MaxDiceValue     = (int)At.GetField(table, "m_maxDiceValue"),
            };

            //if (generatorHolder.MaxDiceValue <= 0)
            //{
            //    SL.LogWarning("This random table's MaxDiceValue is 0, skipping...");
            //    return null;
            //}

            if (At.GetField(table, "m_dropAmount") is SimpleRandomChance dropAmount)
            {
                generatorHolder.ChanceReduction = dropAmount.ChanceReduction;
                generatorHolder.ChanceRegenQty  = dropAmount.ChanceRegenQty;

                if (dropAmount.CanRegen)
                {
                    generatorHolder.RegenTime = dropAmount.ChanceRegenDelay;
                }
                else
                {
                    generatorHolder.RegenTime = -1;
                }
            }
            else
            {
                generatorHolder.RegenTime = -1;
            }

            if (At.GetField(table, "m_emptyDropChance") is int i && generatorHolder.MaxDiceValue > 0)
            {
                try
                {
                    decimal emptyChance = (decimal)i / generatorHolder.MaxDiceValue;
                    generatorHolder.EmptyDrop = (float)emptyChance * 100;
                }
                catch
                {
                    generatorHolder.EmptyDrop = 0;
                }
            }

            if (At.GetField(table, "m_itemDrops") is List <ItemDropChance> itemDrops)
            {
                foreach (ItemDropChance drop in itemDrops)
                {
                    if (!drop.DroppedItem)
                    {
                        continue;
                    }

                    float percentage;
                    try
                    {
                        percentage = (float)((decimal)drop.DropChance / generatorHolder.MaxDiceValue) * 100f;
                    }
                    catch
                    {
                        percentage = 100f;
                    }

                    percentage = (float)Math.Round(percentage, 2);

                    string name = drop.DroppedItem.Name;

                    if (IsUnidentified(drop.DroppedItem.ItemID, out string identified))
                    {
                        name += " (" + identified + ")";
                    }

                    if (percentage >= 100)
                    {
                        AddGuaranteedDrop(dropTableHolder, drop.DroppedItem.ItemID, name, drop.MaxDropCount, drop.MinDropCount);
                    }
                    else
                    {
                        generatorHolder.Item_Drops.Add(new DropTableChanceEntry
                        {
                            Item_ID          = drop.DroppedItem.ItemID,
                            Item_Name        = name,
                            Min_Quantity     = drop.MinDropCount,
                            Max_Quantity     = drop.MaxDropCount,
                            Drop_Chance      = percentage,
                            Dice_Range       = drop.MaxDiceRollValue - drop.MinDiceRollValue,
                            ChanceReduction  = drop.ChanceReduction,
                            ChanceRegenDelay = drop.ChanceRegenDelay,
                            ChanceRegenQty   = drop.ChanceRegenQty
                        });
                    }
                }
            }

            return(generatorHolder);
        }
Exemplo n.º 30
0
        public virtual void SerializeItem(Item item, DM_Item holder)
        {
            holder.gameObjectName = item.gameObject.name;

            holder.ItemID                 = item.ItemID;
            holder.Name                   = item.Name;
            holder.Description            = item.Description;
            holder.LegacyItemID           = item.LegacyItemID;
            holder.CastLocomotionEnabled  = item.CastLocomotionEnabled;
            holder.CastModifier           = item.CastModifier;
            holder.CastSheatheRequired    = item.CastSheathRequired;
            holder.GroupItemInDisplay     = item.GroupItemInDisplay;
            holder.HasPhysicsWhenWorld    = item.HasPhysicsWhenWorld;
            holder.IsPickable             = item.IsPickable;
            holder.IsUsable               = item.IsUsable;
            holder.QtyRemovedOnUse        = item.QtyRemovedOnUse;
            holder.MobileCastMovementMult = item.MobileCastMovementMult;
            holder.RepairedInRest         = item.RepairedInRest;
            holder.BehaviorOnNoDurability = item.BehaviorOnNoDurability;

            holder.OverrideSellModifier = (float)At.GetField(item, "m_overrideSellModifier");

            if (item.GetComponent <Perishable>() is Perishable perish)
            {
                float perishRate     = perish.DepletionRate * 0.03333333f;
                float perishModifier = 1 / perishRate;

                var      remainingTicks = item.MaxDurability * perishModifier; // each tick is 2 in-game minutes (~5 seconds irl)
                var      minutes        = remainingTicks * 2;
                TimeSpan t = TimeSpan.FromMinutes(minutes);

                holder.PerishTime = $"{t.Days} Days, {t.Hours} Hours, {t.Minutes} Minutes, {t.Seconds} Seconds";
            }

            holder.CastType = (Character.SpellCastType)At.GetField(item, "m_activateEffectAnimType");

            if (item.GetComponent <ItemStats>() is ItemStats stats)
            {
                holder.StatsHolder = DM_ItemStats.ParseItemStats(stats);
            }

            if (item.Tags != null)
            {
                foreach (Tag tag in item.Tags)
                {
                    holder.Tags.Add(tag.TagName);

                    ListManager.AddTagSource(tag, Serializer.SafeName(item.Name));
                }
            }

            foreach (Transform child in item.transform)
            {
                var effectsChild = DM_EffectTransform.ParseTransform(child);

                if (effectsChild.ChildEffects.Count > 0 || effectsChild.Effects.Count > 0 || effectsChild.EffectConditions.Count > 0)
                {
                    holder.EffectTransforms.Add(effectsChild);
                }
            }
        }