Exemple #1
0
        private static bool GetTreePreFix(CraftTree.Type treeType, ref CraftTree __result)
        {
            if (CustomTrees.ContainsKey(treeType))
            {
                __result = CustomTrees[treeType].CraftTree;
                return(false);
            }

            return(true);
        }
Exemple #2
0
        private static void InitializePostFix()
        {
            if (CraftTree.initialized && !ModCraftTreeNode.Initialized)
            {
                foreach (CraftTree.Type cTreeKey in CustomTrees.Keys)
                {
                    CraftTree customTree = CustomTrees[cTreeKey].CustomCraftingTree;

                    MethodInfo addToCraftableTech = AccessTools.Method(typeof(CraftTree), nameof(CraftTree.AddToCraftableTech));

                    addToCraftableTech.Invoke(null, new[] { customTree });
                }
            }
        }
        private CraftTree CreateCraftingTree()
        {
            if (craftTree == null)
            {
                Dictionary <string, string>       langLines = Language.main.strings;
                Dictionary <string, Atlas.Sprite> group     = SpriteManager.groups[SpriteManager.Group.Category];
                Dictionary <string, Atlas.Sprite> atlas     = Atlas.GetAtlas("Categories").nameToSprite;

                CraftNode fab = CraftTree.FabricatorScheme();
                CloneTabDetails(FabricatorScheme, fab, ref langLines, ref group, ref atlas);

                CraftNode wb = CraftTree.WorkbenchScheme();
                CloneTabDetails(WorkBenchScheme, wb, ref langLines, ref group, ref atlas);

                CraftNode su = CraftTree.SeamothUpgradesScheme();
                CloneTabDetails(SeamothUpgradesScheme, su, ref langLines, ref group, ref atlas);

                CraftNode map = CraftTree.MapRoomSheme();
                CloneTabDetails(MapRoomScheme, map, ref langLines, ref group, ref atlas);

                CraftNode cy = CraftTree.CyclopsFabricatorScheme();
                CloneTabDetails(CyclopsFabScheme, cy, ref langLines, ref group, ref atlas);

                CraftNode aioRoot = new CraftNode("Root").AddNode(fab, wb, su, map, cy);

                Type smlCTPatcher = typeof(CraftTreeHandler).Assembly.GetType("SMLHelper.V2.Patchers.CraftTreePatcher");
                var  customTrees  = (Dictionary <CraftTree.Type, ModCraftTreeRoot>)smlCTPatcher.GetField("CustomTrees", BindingFlags.NonPublic | BindingFlags.Static).GetValue(null);
                foreach (KeyValuePair <CraftTree.Type, ModCraftTreeRoot> entry in customTrees)
                {
                    if (entry.Key == this.TreeTypeID)
                    {
                        continue;
                    }

                    CraftTree tree   = entry.Value.CraftTreeCreation.Invoke();
                    CraftNode root   = tree.nodes;
                    string    scheme = entry.Key.ToString();

                    CloneTabDetails(scheme, root, ref langLines, ref group, ref atlas);
                    CloneTopLevelModTab(scheme, ref langLines, ref group);
                    aioRoot.AddNode(root);
                }

                craftTree = new CraftTree(AioFabScheme, aioRoot);
            }

            return(craftTree);
        }
Exemple #4
0
        private static void InitializePostFix()
        {
            var  craftTreeInitialized = (bool)ReflectionHelper.GetStaticField <CraftTree>("initialized");
            Type craftTreeClass       = typeof(CraftTree);

            if (craftTreeInitialized && !ModCraftTreeNode.Initialized)
            {
                foreach (CraftTree.Type cTreeKey in CustomTrees.Keys)
                {
                    CraftTree customTree = CustomTrees[cTreeKey].CraftTree;

                    MethodInfo addToCraftableTech = craftTreeClass.GetMethod("AddToCraftableTech", BindingFlags.Static | BindingFlags.NonPublic);

                    addToCraftableTech.Invoke(null, new[] { customTree });
                }
            }
        }
        private CraftTree CreateCraftingTree()
        {
            if (craftTree != null)
            {
                return(craftTree);
            }

            List <CraftNode> roomNodes     = new List <CraftNode>();
            List <CraftNode> corridorNodes = new List <CraftNode>();
            List <CraftNode> moduleNodes   = new List <CraftNode>();
            List <CraftNode> utilityNodes  = new List <CraftNode>();

            foreach (TechType techType in ClonedRoomKits)
            {
                roomNodes.Add(new CraftNode(techType.AsString(), TreeAction.Craft, techType));
            }

            foreach (TechType techType in ClonedCorridorKits)
            {
                corridorNodes.Add(new CraftNode(techType.AsString(), TreeAction.Craft, techType));
            }

            foreach (TechType techType in ClonedModuleKits)
            {
                moduleNodes.Add(new CraftNode(techType.AsString(), TreeAction.Craft, techType));
            }

            foreach (TechType techType in ClonedUtilityKits)
            {
                utilityNodes.Add(new CraftNode(techType.AsString(), TreeAction.Craft, techType));
            }

            craftTree = new CraftTree("PurpleKitFabricator",
                                      new CraftNode("Root", TreeAction.None, TechType.None).AddNode(new CraftNode[]
            {
                new CraftNode("RoomsMenu", TreeAction.Expand, TechType.None).AddNode(roomNodes.ToArray()),
                new CraftNode("CorridorMenu", TreeAction.Expand, TechType.None).AddNode(corridorNodes.ToArray()),
                new CraftNode("ModuleMenu", TreeAction.Expand, TechType.None).AddNode(moduleNodes.ToArray()),
                new CraftNode("UtilityMenu", TreeAction.Expand, TechType.None).AddNode(utilityNodes.ToArray())
            })
                                      );

            return(craftTree);
        }
        public static ModifiedRecipeList GetOriginals(CraftTree.Type treeType)
        {
            CraftTree tree = CraftTree.GetTree(treeType);

            IEnumerator <CraftNode> mover = tree.nodes.Traverse(true);

            var originals = new ModifiedRecipeList($"{treeType}Originals");

            while (mover.MoveNext())
            {
                if (mover.Current.action == TreeAction.Craft && mover.Current.techType0 < TechType.Databox)
                {
                    originals.Collections.Add(new ModifiedRecipe(mover.Current.techType0));
                }
            }
            ;

            return(originals);
        }
        public void InitializeMod()
        {
            var craftData = typeof(CraftData);

            var techDataField = craftData.GetField("techData", BindingFlags.NonPublic | BindingFlags.Static);
            var techData      = techDataField.GetValue(null) as IDictionary;

            var TechDataClass = craftData.GetNestedType("TechData", BindingFlags.NonPublic);

            var ingredientsField =
                TechDataClass.GetField("_ingredients", BindingFlags.Public | BindingFlags.Instance);
            var craftAmountField =
                TechDataClass.GetField("_craftAmount", BindingFlags.Public | BindingFlags.Instance);

            var IngredientClass  = craftData.GetNestedType("Ingredient", BindingFlags.NonPublic);
            var IngredientsClass = craftData.GetNestedType("Ingredients", BindingFlags.NonPublic);

            // Adjust Scrap Metal -> Titanium (+1)
            var titaniumTech = techData[TechType.Titanium];

            craftAmountField.SetValue(titaniumTech, 5);

            // Add Scrap Metal to the crafting tree
            var ingredient  = Activator.CreateInstance(IngredientClass, new object[] { TechType.TitaniumIngot, 1 });
            var ingredients = Activator.CreateInstance(IngredientsClass) as IList;

            ingredients.Add(ingredient);

            var scrapTechData = Activator.CreateInstance(TechDataClass);

            ingredientsField.SetValue(scrapTechData, ingredients);
            craftAmountField.SetValue(scrapTechData, 2);

            techData.Add(TechType.ScrapMetal, scrapTechData);

            // Add the Scrap to the crafting menu
            var craftTree      = typeof(CraftTree);
            var fabricatorTree = CraftTree.GetTree(CraftTree.Type.Fabricator);
            var basicMaterials = fabricatorTree.nodes["Resources"]["BasicMaterials"] as CraftNode;

            basicMaterials.AddNode(new CraftNode("ScrapMetal", TreeAction.Craft, TechType.ScrapMetal));
        }
        public override GameObject GetGameObject()
        {
            // Get the ElectricalDefense module prefab and instantiate it
            var path = "WorldEntities/Tools/Seaglide";
            //var path = $"./QMods/BetterSeaglide/Assets/PowerGlide";
            var prefab = Resources.Load <GameObject>(path);
            var obj    = GameObject.Instantiate(prefab);

            ErrorMessage.AddWarning($"Tree is {CraftTree.GetTree(CraftTree.Type.Fabricator)}");

            // Get the TechTags and PrefabIdentifiers
            var techTag          = obj.GetComponent <TechTag>();
            var prefabIdentifier = obj.GetComponent <PrefabIdentifier>();

            // Change them so they fit to our requirements.
            techTag.type             = TechType;
            prefabIdentifier.ClassId = ClassID;

            return(obj);
        }
Exemple #9
0
 private static bool Prefix(CraftTree tree)
 {
     using (IEnumerator <CraftNode> enumerator = tree.nodes.Traverse(false))
     {
         while (enumerator.MoveNext())
         {
             CraftNode craftNode = enumerator.Current;
             if (craftNode.action == TreeAction.Craft)
             {
                 TechType techType = craftNode.techType0;
                 if (techType != TechType.None && !Core.RecipeBlacklist.Contains(techType.AsString()))
                 {
                     CraftTree.craftableTech.Add(techType);
                 }
                 else if (Core.RecipeBlacklist.Contains(techType.AsString()))
                 {
                     craftNode.techType0 = TechType.None;
                     Core.Log($"TechType: {techType.AsString()} found in BlackList", true);
                 }
             }
         }
     }
     return(false);
 }
Exemple #10
0
        private CraftTree CreateCraftingTree()
        {
            if (craftTree == null)
            {
                Dictionary <string, string> langLines = Language.main.strings;

                var atlasName = SpriteManager.mapping[SpriteManager.Group.Category];
#if SUBNAUTICA
                var group = Atlas.GetAtlas(atlasName).nameToSprite;
#elif BELOWZERO
                var group = SpriteManager.atlases[atlasName];
#endif
                List <CraftNode> craftNodes = new List <CraftNode>();

                CraftNode fab = CraftTree.FabricatorScheme();
                CloneTabDetails(FabricatorScheme, fab, ref langLines, ref group);
                craftNodes.Add(fab);

                CraftNode wb = CraftTree.WorkbenchScheme();
                CloneTabDetails(WorkBenchScheme, wb, ref langLines, ref group);
                craftNodes.Add(wb);

                CraftNode su = CraftTree.SeamothUpgradesScheme();
                CloneTabDetails(SeamothUpgradesScheme, su, ref langLines, ref group);
                craftNodes.Add(su);

                CraftNode map = CraftTree.MapRoomSheme();
                CloneTabDetails(MapRoomScheme, map, ref langLines, ref group);
                craftNodes.Add(map);
#if SUBNAUTICA
                CraftNode cy = CraftTree.CyclopsFabricatorScheme();
                CloneTabDetails(CyclopsFabScheme, cy, ref langLines, ref group);
                craftNodes.Add(cy);
#elif BELOWZERO
                CraftNode st = CraftTree.SeaTruckFabricatorScheme();
                CloneTabDetails(SeaTruckFabScheme, st, ref langLines, ref group);
                craftNodes.Add(st);
#endif

                CraftNode aioRoot = new CraftNode("Root").AddNode(craftNodes.ToArray());

                Type smlCTPatcher = typeof(CraftTreeHandler).Assembly.GetType("SMLHelper.V2.Patchers.CraftTreePatcher");
                var  customTrees  = (Dictionary <CraftTree.Type, ModCraftTreeRoot>)smlCTPatcher.GetField("CustomTrees", BindingFlags.NonPublic | BindingFlags.Static).GetValue(null);
                foreach (KeyValuePair <CraftTree.Type, ModCraftTreeRoot> entry in customTrees)
                {
                    if (entry.Key == this.TreeTypeID)
                    {
                        continue;
                    }

                    CraftTree tree   = entry.Value.CraftTreeCreation.Invoke();
                    CraftNode root   = tree.nodes;
                    string    scheme = entry.Key.ToString();

                    CloneTabDetails(scheme, root, ref langLines, ref group);
                    CloneTopLevelModTab(scheme, ref langLines, ref group);
                    aioRoot.AddNode(root);
                }

                craftTree = new CraftTree(AioFabScheme, aioRoot);
            }

            return(craftTree);
        }