private void ApplyEdits <TKey, TValue>(IAssetData asset, IDictionary <TKey, TValue> edits)
        {
            IAssetDataForDictionary <TKey, TValue> assetDict = asset.AsDictionary <TKey, TValue>();

            foreach (KeyValuePair <TKey, TValue> edit in edits)
            {
                assetDict.Data[edit.Key] = edit.Value;
            }
        }
        //  "918": "Hyper Speed-Gro/70/-300/Basic -19/Hyper Speed-Gro/Greatly stimulates leaf production. Guaranteed to increase growth rate by at least 33%. Mix into tilled soil.",
        //  "466": "Deluxe Speed-Gro/40/-300/Basic -19/Deluxe Speed-Gro/Stimulates leaf production. Guaranteed to increase growth rate by at least 25%. Mix into tilled soil.",



        public void Edit <T>(IAssetData asset)
        {
            if (asset.AssetNameEquals("Maps/springobjects"))
            {
                Texture2D sprinkler = ModEntry.ModHelper.Content.Load <Texture2D>("assets/radioactiveSprinkler.png");
                //Texture2D rfertimg = ModEntry.ModHelper.Content.Load<Texture2D>("assets/radioactiveFertilizer.png");
                Texture2D old = asset.AsImage().Data;
                asset.ReplaceWith(new Texture2D(Game1.graphics.GraphicsDevice, old.Width, System.Math.Max(old.Height, 1200 / 24 * 16)));
                asset.AsImage().PatchImage(old);
                asset.AsImage().PatchImage(sprinkler, targetArea: this.GetRectangle(RadioactiveSprinklerItem.INDEX));
                //asset.AsImage().PatchImage(rfertimg, targetArea: this.GetRectangle(RadioactiveFertilizerItem.INDEX));
            }
            else if (asset.AssetNameEquals("Data/ObjectInformation"))
            {
                asset.AsDictionary <int, string>().Data.Add(RadioactiveSprinklerItem.INDEX, $"{this.sprinklerName}/{RadioactiveSprinklerItem.PRICE}/{RadioactiveSprinklerItem.EDIBILITY}/{RadioactiveSprinklerItem.TYPE} {RadioactiveSprinklerItem.CATEGORY}/{this.sprinklerName}/{this.sprinklerDesc}");
                //asset.AsDictionary<int, string>().Data.Add(RadioactiveFertilizerItem.INDEX, $"{this.rfertName}/{RadioactiveFertilizerItem.PRICE}/{RadioactiveFertilizerItem.EDIBILITY}/{RadioactiveFertilizerItem.TYPE} {RadioactiveFertilizerItem.CATEGORY}/{this.rfertName}/{this.rfertDesc}");
            }
            else if (asset.AssetNameEquals("Data/CraftingRecipes"))
            {
                IAssetDataForDictionary <string, string> oldDict = asset.AsDictionary <string, string>();
                Dictionary <string, string> newDict = new Dictionary <string, string>();
                // somehow the Dictionary maintains ordering, so reconstruct it with new sprinkler recipe immediately after radioactive
                foreach (string key in oldDict.Data.Keys)
                {
                    newDict.Add(key, oldDict.Data[key]);
                    if (key.Equals("Iridium Sprinkler"))
                    {
                        if (asset.Locale != "en")
                        {
                            newDict.Add("Radioactive Sprinkler", $"910 2 787 2/Home/{RadioactiveSprinklerItem.INDEX}/false/Farming {RadioactiveSprinklerItem.CRAFTING_LEVEL}/{this.sprinklerName}");
                            //newDict.Add("Radioactive Fertilizer", $"910 2 787 2/Home/{RadioactiveFertilizerItem.INDEX}/false/Farming {RadioactiveFertilizerItem.CRAFTING_LEVEL}/{this.rfertName}");
                        }
                        else
                        {
                            newDict.Add("Radioactive Sprinkler", $"910 2 787 2/Home/{RadioactiveSprinklerItem.INDEX}/false/Farming {RadioactiveSprinklerItem.CRAFTING_LEVEL}");
                            //newDict.Add("Radioactive Fertilizer", $"910 2 787 2/Home/{RadioactiveFertilizerItem.INDEX}/false/Farming {RadioactiveFertilizerItem.CRAFTING_LEVEL}");
                        }
                    }
                }
                asset.AsDictionary <string, string>().Data.Clear();
                foreach (string key in newDict.Keys)
                {
                    asset.AsDictionary <string, string>().Data.Add(key, newDict[key]);
                }
            }
            else if (asset.AssetNameEquals("TileSheets\\tools"))
            {
                asset.AsImage().PatchImage(ModEntry.ToolsTexture, null, null, PatchMode.Overlay);
            }
            else if (asset.AssetNameEquals("TileSheets\\weapons"))
            {
                //asset.AsImage().PatchImage(ModEntry.WeaponsTexture, null, null, PatchMode.Overlay);
            }
        }
    private static void EditSecretNote(IAssetData editor)
    {
        IAssetDataForDictionary <int, string> data = editor.AsDictionary <int, string>();

        if (data.Data.TryGetValue(1008, out string?val))
        {
            data.Data[1008] = val.Replace("50", ((1 - ModEntry.Config.ConsumeChancePreserving) * 100).ToString());
        }
        else
        {
            ModEntry.ModMonitor.Log("Data for secret note 1008 not found?", LogLevel.Debug);
        }
    }
    private static void EditForgeMenu(IAssetData editor)
    {
        IAssetDataForDictionary <string, string> data = editor.AsDictionary <string, string>();

        if (data.Data.TryGetValue("Preserving", out string?val))
        {
            data.Data["Preserving"] = val.Replace("50", ((1 - ModEntry.Config.ConsumeChancePreserving) * 100).ToString());
        }
        else
        {
            ModEntry.ModMonitor.Log("ForgeMenuChoice's Preserving key not found....", LogLevel.Debug);
        }
    }
 private static void EditAsset(IAssetData asset)
 {
     if (ModEntry.GiantCropFertilizerID != -1)
     {
         IAssetDataForDictionary <int, string>?editor = asset.AsDictionary <int, string>();
         if (editor.Data.TryGetValue(ModEntry.GiantCropFertilizerID, out string?val))
         {
             editor.Data[ModEntry.GiantCropFertilizerID] = val.Replace("Basic -20", "Basic -19");
         }
         else
         {
             ModEntry.ModMonitor.Log($"Could not find {ModEntry.GiantCropFertilizerID} in ObjectInformation to edit! This mod may not function properly.", LogLevel.Error);
         }
     }
 }
 public void Edit <T>(IAssetData asset)
 {
     if (asset.AssetNameEquals("Maps/springobjects"))
     {
         Texture2D bar       = ModEntry.ModHelper.Content.Load <Texture2D>("Assets/prismaticBar.png", ContentSource.ModFolder);
         Texture2D sprinkler = ModEntry.ModHelper.Content.Load <Texture2D>("Assets/prismaticSprinkler.png", ContentSource.ModFolder);
         Texture2D old       = asset.AsImage().Data;
         asset.ReplaceWith(new Texture2D(Game1.graphics.GraphicsDevice, old.Width, System.Math.Max(old.Height, 1200 / 24 * 16)));
         asset.AsImage().PatchImage(old);
         asset.AsImage().PatchImage(bar, targetArea: Rektangle(PrismaticBarItem.INDEX));
         asset.AsImage().PatchImage(sprinkler, targetArea: Rektangle(PrismaticSprinklerItem.INDEX));
     }
     else if (asset.AssetNameEquals("Data/ObjectInformation"))
     {
         asset.AsDictionary <int, string>().Data.Add(PrismaticBarItem.INDEX, $"{barName}/{PrismaticBarItem.PRICE}/{PrismaticBarItem.EDIBILITY}/{PrismaticBarItem.TYPE} {PrismaticBarItem.CATEGORY}/{barName}/{barDesc}");
         asset.AsDictionary <int, string>().Data.Add(PrismaticSprinklerItem.INDEX, $"{sprinklerName}/{PrismaticSprinklerItem.PRICE}/{PrismaticSprinklerItem.EDIBILITY}/{PrismaticSprinklerItem.TYPE} {PrismaticSprinklerItem.CATEGORY}/{sprinklerName}/{sprinklerDesc}");
     }
     else if (asset.AssetNameEquals("Data/CraftingRecipes"))
     {
         IAssetDataForDictionary <string, string> oldDict = asset.AsDictionary <string, string>();
         Dictionary <string, string> newDict = new Dictionary <string, string>();
         // somehow the Dictionary maintains ordering, so reconstruct it with new sprinkler recipe immediately after prismatic
         foreach (string key in oldDict.Data.Keys)
         {
             newDict.Add(key, oldDict.Data[key]);
             if (key.Equals("Iridium Sprinkler"))
             {
                 if (asset.Locale != "en")
                 {
                     newDict.Add("Prismatic Sprinkler", $"{PrismaticBarItem.INDEX} 2 787 2/Home/{PrismaticSprinklerItem.INDEX}/false/Farming {PrismaticSprinklerItem.CRAFTING_LEVEL}/{sprinklerName}");
                 }
                 else
                 {
                     newDict.Add("Prismatic Sprinkler", $"{PrismaticBarItem.INDEX} 2 787 2/Home/{PrismaticSprinklerItem.INDEX}/false/Farming {PrismaticSprinklerItem.CRAFTING_LEVEL}");
                 }
             }
         }
         asset.AsDictionary <string, string>().Data.Clear();
         foreach (string key in newDict.Keys)
         {
             asset.AsDictionary <string, string>().Data.Add(key, newDict[key]);
         }
     }
     else if (asset.AssetNameEquals("TileSheets\\tools"))
     {
         asset.AsImage().PatchImage(ModEntry.toolsTexture, null, null, PatchMode.Overlay);
     }
 }
Beispiel #7
0
    private static void EditImpl(IAssetData asset)
    {
        List <int> idsToEdit = new(ModEntry.PlantableFertilizerIDs);

        idsToEdit.AddRange(ModEntry.SpecialFertilizerIDs);

        IAssetDataForDictionary <int, string>?editor = asset.AsDictionary <int, string>();

        foreach (int item in idsToEdit)
        {
            if (editor.Data.TryGetValue(item, out string?val))
            {
                editor.Data[item] = val.Replace(JUNK_CATEGORY, FERTILIZER_CATEGORY);
            }
            else
            {
                ModEntry.ModMonitor.Log($"Could not find {item} in ObjectInformation to edit! This mod may not function properly.", LogLevel.Error);
            }
        }
    }
 public void Edit <T>(IAssetData asset)
 {
     if (asset.AssetNameEquals("Maps/springobjects"))
     {
         Texture2D sprinkler = QiSprinklers.ModHelper.Content.Load <Texture2D>("Assets/qiSprinkler.png");
         Texture2D old       = asset.AsImage().Data;
         asset.ReplaceWith(new Texture2D(Game1.graphics.GraphicsDevice, old.Width, System.Math.Max(old.Height, 1200 / 24 * 16)));
         asset.AsImage().PatchImage(old);
         asset.AsImage().PatchImage(sprinkler, targetArea: this.GetRectangle(QiSprinklerItem.INDEX));
     }
     else if (asset.AssetNameEquals("Data/ObjectInformation"))
     {
         asset.AsDictionary <int, string>().Data.Add(QiSprinklerItem.INDEX, $"{sprinklerName}/{QiSprinklerItem.PRICE}/{QiSprinklerItem.EDIBILITY}/{QiSprinklerItem.TYPE} {QiSprinklerItem.CATEGORY}/{sprinklerName}/{sprinklerDesc}");
     }
     else if (asset.AssetNameEquals("Data/CraftingRecipes"))
     {
         IAssetDataForDictionary <string, string> oldDict = asset.AsDictionary <string, string>();
         Dictionary <string, string> newDict = new Dictionary <string, string>();
         // somehow the Dictionary maintains ordering, so reconstruct it with new sprinkler recipe immediately after Qi
         foreach (string key in oldDict.Data.Keys)
         {
             newDict.Add(key, oldDict.Data[key]);
             if (key.Equals("Iridium Sprinkler"))
             {
                 if (asset.Locale != "en")
                 {
                     newDict.Add("Qi Sprinkler", $"645 1 913 1 915 1/Home/{QiSprinklerItem.INDEX}/false/Farming {QiSprinklerItem.CRAFTING_LEVEL}/{sprinklerName}");
                 }
                 else
                 {
                     newDict.Add("Qi Sprinkler", $"645 1 913 1 915 1/Home/{QiSprinklerItem.INDEX}/false/Farming {QiSprinklerItem.CRAFTING_LEVEL}");
                 }
             }
         }
         asset.AsDictionary <string, string>().Data.Clear();
         foreach (string key in newDict.Keys)
         {
             asset.AsDictionary <string, string>().Data.Add(key, newDict[key]);
         }
     }
 }
        public void Edit <T>(IAssetData asset)
        {
            VoidshroomSpore.setIndex(); //get an item index for voidshroom spores if one isn't already set.
            CaveCarrotSeed.setIndex();
            CaveCarrot.setIndex();
            CaveCarrot.setCropIndex();
            if (asset.AssetNameEquals("Maps\\springobjects"))
            {
                IAssetDataForImage editor    = asset.AsImage();
                Texture2D          data      = editor.Data;
                Texture2D          texture2D = new Texture2D(Game1.graphics.GraphicsDevice, data.Width, Math.Max(data.Height, 4096));
                editor.ReplaceWith(texture2D);
                editor.PatchImage(data, new Rectangle?(), new Rectangle?(), PatchMode.Replace);
                try
                {
                    editor.PatchImage(TextureSet.voidShroomSpore, new Rectangle?(), new Rectangle?(this.objectRect(VoidshroomSpore.getIndex())), PatchMode.Replace);
                    editor.PatchImage(TextureSet.caveCarrotSeed, new Rectangle?(), new Rectangle?(this.objectRect(CaveCarrotSeed.getIndex())), PatchMode.Replace);
                }
                catch (Exception)
                {
                }
            }
            else if (asset.AssetNameEquals("Data\\ObjectInformation"))
            {
                IAssetDataForDictionary <int, string> editor = asset.AsDictionary <int, string>();

                IDictionary <int, string> data = editor.Data;
                if (!data.ContainsKey(VoidshroomSpore.getIndex()))
                {
                    int    voidShroomSporeIndex = VoidshroomSpore.getIndex();
                    String voidShroomSpore      = VoidshroomSpore.getObjectData();
                    this.log("Add voidshroom spore object data: " + voidShroomSporeIndex + ": " + voidShroomSpore);
                    data.Add(voidShroomSporeIndex, voidShroomSpore);
                }

                if (!data.ContainsKey(CaveCarrotSeed.getIndex()))
                {
                    int    caveCarrotSeedIndex = CaveCarrotSeed.getIndex();
                    String caveCarrotObject    = CaveCarrotSeed.getObjectData();
                    this.log("Add cave carrot seed object data: " + caveCarrotSeedIndex + ": " + caveCarrotObject);
                    data.Add(caveCarrotSeedIndex, caveCarrotObject);
                }

                if (!data.ContainsKey(CaveCarrotFlower.getIndex()))
                {
                    int    caveCarrotFlowerIndex  = CaveCarrotFlower.getIndex();
                    String caveCarrotFlowerObject = CaveCarrotFlower.getObjectData();
                    this.log("Add cave carrot flower 'seed' data: " + caveCarrotFlowerIndex + ": " + caveCarrotFlowerObject);
                    data.Add(caveCarrotFlowerIndex, caveCarrotFlowerObject);
                }
            }
            else if (asset.AssetNameEquals("Data\\Crops"))
            {
                IAssetDataForDictionary <int, string> editor = asset.AsDictionary <int, string>();
                IDictionary <int, string>             data   = editor.Data;

                int seedIndex = CaveCarrot.getIndex();
                this.log("seedIndex is: " + seedIndex);
                if (!data.ContainsKey(seedIndex))
                {
                    String cropData = CaveCarrot.getCropData();
                    this.monitor.Log("Loading crop data: " + cropData);
                    data.Add(CaveCarrot.getIndex(), cropData);
                }

                int caveCarrotFlowerIndex = CaveCarrotFlower.getIndex();
                this.log("seedIndex is: " + caveCarrotFlowerIndex);
                if (!data.ContainsKey(caveCarrotFlowerIndex))
                {
                    String cropData = CaveCarrotFlower.getCropData();
                    this.monitor.Log("Loading crop data: " + cropData);
                    data.Add(caveCarrotFlowerIndex, cropData);
                }
            }
            else if (asset.AssetNameEquals("TileSheets\\crops"))
            {
                IAssetDataForImage editor    = asset.AsImage();
                Texture2D          data      = editor.Data;
                Texture2D          texture2D = new Texture2D(Game1.graphics.GraphicsDevice, data.Width, Math.Max(data.Height, 4096));
                editor.ReplaceWith(texture2D);
                editor.PatchImage(data, new Rectangle?(), new Rectangle?(), PatchMode.Replace);
                try
                {
                    int index = CaveCarrot.getCropIndex();
                    this.monitor.Log("Loading cave carrot crop texture.  Crop index: " + index);
                    editor.PatchImage(TextureSet.caveCarrotCrop, new Rectangle?(), new Rectangle?(this.cropRect(index)), PatchMode.Replace);

                    index = CaveCarrotFlower.getCropIndex();
                    this.monitor.Log("Loading cave carrot flower crop texture.  Crop index: " + index);
                    editor.PatchImage(TextureSet.caveCarrotFlowerCrop, new Rectangle?(), new Rectangle?(this.cropRect(index)), PatchMode.Replace);
                }
                catch (Exception)
                {
                }
            }
        }