Example #1
0
        private void AddBlueprintClassButton(MyBlueprintClassDefinition classDef, ref float xOffset, bool selected = false)
        {
            Debug.Assert(classDef != null);
            if (classDef == null)
            {
                return;
            }

            var test = new MyGuiControlRadioButton(
                position: m_blueprintsLabel.Position + new Vector2(xOffset, m_blueprintsLabel.Size.Y),
                size: new Vector2(46f, 46f) / MyGuiConstants.GUI_OPTIMAL_SIZE
                );

            xOffset  += test.Size.X;
            test.Icon = new MyGuiHighlightTexture()
            {
                Normal = classDef.Icon, Highlight = classDef.HighlightIcon, SizePx = new Vector2(46f, 46f)
            };
            test.UserData    = classDef;
            test.OriginAlign = MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_TOP;
            if (classDef.DisplayNameEnum.HasValue)
            {
                test.SetToolTip(classDef.DisplayNameEnum.Value);
            }
            else
            {
                test.SetToolTip(classDef.DisplayNameString);
            }
            m_blueprintButtonGroup.Add(test);
            m_controlsParent.Controls.Add(test);
            test.Selected = selected;
        }
        protected override bool BlueprintClassCanBeUsed(MyBlueprintClassDefinition blueprintClass)
        {
            foreach (var blueprint in blueprintClass)
                if (blueprint.Atomic)
                {
                    System.Diagnostics.Debug.Assert(false, "Blueprint " + blueprint.DisplayNameText + " is atomic, but it is in a class used by refinery block");
                    MySandboxGame.Log.WriteLine("Blueprint " + blueprint.DisplayNameText + " is atomic, but it is in a class used by refinery block");
                    return false;
                }

            return base.BlueprintClassCanBeUsed(blueprintClass);
        }
Example #3
0
        public override void Init(MyComponentDefinitionBase definition)
        {
            base.Init(definition);
            MyCraftingComponentInteractiveDefinition definition2 = definition as MyCraftingComponentInteractiveDefinition;

            if (definition2 != null)
            {
                this.ActionSound = new MySoundPair(definition2.ActionSound, true);
                base.m_craftingSpeedMultiplier = definition2.CraftingSpeedMultiplier;
                foreach (string str in definition2.AvailableBlueprintClasses)
                {
                    MyBlueprintClassDefinition blueprintClass = MyDefinitionManager.Static.GetBlueprintClass(str);
                    base.m_blueprintClasses.Add(blueprintClass);
                }
            }
        }
Example #4
0
 private static void SetSurvivalKitMenu()
 {
     try
     {
         MyBlueprintClassDefinition awwScrap = MyDefinitionManager.Static.GetBlueprintClass("AwwScrap");
         foreach (MyCubeBlockDefinition sKitDef in MyDefinitionManager.Static.GetAllDefinitions().OfType <MyCubeBlockDefinition>().Where(myCubeBlockDefinition => myCubeBlockDefinition is MySurvivalKitDefinition))
         {
             ((MySurvivalKitDefinition)sKitDef).BlueprintClasses.Add(awwScrap);
             foreach (string x in Statics.SKitScrapList)
             {
                 ((MySurvivalKitDefinition)sKitDef).InputInventoryConstraint.Add(new MyDefinitionId(typeof(MyObjectBuilder_Ore), x));
             }
         }
     }
     catch (Exception e)
     {
         MyLog.Default.WriteLine($"AwwScrap: SetSurvivalKitMenu - Boom!!! {e}");
     }
 }
Example #5
0
        private MyBlueprintDefinitionBase BlueprintLookup(MyBlueprintClassDefinition clazz, MyDefinitionId id)
        {
            Dictionary <MyDefinitionId, MyBlueprintDefinitionBase> tmp;

            if (!_classBlueprintLookup.TryGetValue(clazz, out tmp))
            {
                tmp = new Dictionary <MyDefinitionId, MyBlueprintDefinitionBase>(MyDefinitionId.Comparer);
                foreach (var entry in clazz)
                {
                    foreach (var preq in entry.Prerequisites)
                    {
                        if (!tmp.ContainsKey(preq.Id))
                        {
                            tmp.Add(preq.Id, entry);
                        }
                    }
                }
                _classBlueprintLookup.Add(clazz, tmp);
            }
            return(tmp.GetValueOrDefault(id));
        }
Example #6
0
        public override void Init(MyComponentDefinitionBase definition)
        {
            base.Init(definition);
            MyCraftingComponentBlockDefinition definition2 = definition as MyCraftingComponentBlockDefinition;

            if (definition2 != null)
            {
                base.m_craftingSpeedMultiplier = definition2.CraftingSpeedMultiplier;
                foreach (string str in definition2.AvailableBlueprintClasses)
                {
                    MyBlueprintClassDefinition blueprintClass = MyDefinitionManager.Static.GetBlueprintClass(str);
                    if (blueprintClass != null)
                    {
                        base.m_blueprintClasses.Add(blueprintClass);
                    }
                }
                foreach (MyDefinitionId id in definition2.AcceptedOperatingItems)
                {
                    this.m_acceptedOperatingItems.Add(id);
                }
            }
        }
Example #7
0
        private void AddBlueprintClassToProductionBlocks(MyBlueprintClassDefinition newBpClassDef)
        {
            // 4a) Add Blueprint Class to MyRefineryDefinitions (large refinery, arc furnace, modded?)
            foreach (var def in MyDefinitionManager.Static.GetDefinitionsOfType <MyRefineryDefinition>())
            {
                WriteToLog("", $"{def}", LogType.General);
                def.BlueprintClasses.Add(newBpClassDef);

                foreach (var cls in def.BlueprintClasses)
                {
                    WriteToLog("", $"{cls}", LogType.General);
                }
            }

            // 4b) If applicable, add Blueprint Class to MySurvivalKitDefinition (Skit, modded Skit?)
            foreach (var def in MyDefinitionManager.Static.GetDefinitionsOfType <MySurvivalKitDefinition>())
            {
                WriteToLog("", $"{def}", LogType.General);
                foreach (var cls in def.BlueprintClasses)
                {
                    WriteToLog("", $"{cls}", LogType.General);
                }
            }
        }
        private void AddBlueprintClassButton(MyBlueprintClassDefinition classDef, ref float xOffset, bool selected = false)
        {
            Debug.Assert(classDef != null);
            if (classDef == null) return;

            var test = new MyGuiControlRadioButton(
                position: m_blueprintsLabel.Position + new Vector2(xOffset, m_blueprintsLabel.Size.Y),
                size: new Vector2(46f, 46f) / MyGuiConstants.GUI_OPTIMAL_SIZE
            );
            xOffset += test.Size.X;
            test.Icon = new MyGuiHighlightTexture() { Normal = classDef.Icon, Highlight = classDef.HighlightIcon, SizePx = new Vector2(46f, 46f) };
            test.UserData = classDef;
            test.OriginAlign = MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_TOP;
            if (classDef.DisplayNameEnum.HasValue)
                test.SetToolTip(classDef.DisplayNameEnum.Value);
            else
                test.SetToolTip(classDef.DisplayNameString);
            m_blueprintButtonGroup.Add(test);
            m_controlsParent.Controls.Add(test);
            test.Selected = selected;
        }
 protected virtual bool BlueprintClassCanBeUsed(MyBlueprintClassDefinition blueprintClass)
 {
     return true;
 }
Example #10
0
        private void SetupTestItem()
        {
            // 1) Physical Item
            // 2) Blueprint
            // 3) Blueprint Class
            // 4) Blueprint Class Entry

            // 1) Physical Item:
            MyPhysicalItemDefinition newDef = new MyPhysicalItemDefinition
            {
                Id = new MyDefinitionId(typeof(MyObjectBuilder_Ore), "BulletproofGlassScrap"),
                DisplayNameString = "Bulletproof Glass Scrap",
                Icons             = new[] { Constants.IconLocation + Constants.BulletproofGlassIcon },
                Size             = new Vector3(0.2, 0.2, 0.1),
                Mass             = 1,
                Volume           = 0.254f,
                Model            = Constants.KnownScrapModelLocation + Constants.Scrap2,
                PhysicalMaterial = MyStringHash.GetOrCompute("Metal")
            };

            // 0) OB
            MyObjectBuilder_PhysicalItemDefinition defOb = new MyObjectBuilder_PhysicalItemDefinition()
            {
                Id = newDef.Id
            };

            newDef.Init(defOb, (MyModContext)ModContext);

            MyDefinitionManager.Static.Definitions.AddDefinition(newDef);

            // 2) Blueprint
            MyPhysicalItemDefinition siliconIngotDef = MyDefinitionManager.Static.GetPhysicalItemDefinition(new MyDefinitionId(typeof(MyObjectBuilder_Ingot), "Silicon"));
            MyPhysicalItemDefinition siliconOreDef   = MyDefinitionManager.Static.GetPhysicalItemDefinition(new MyDefinitionId(typeof(MyObjectBuilder_Ore), "Silicon"));
            MyBlueprintDefinition    newBp           = new MyBlueprintDefinition
            {
                Id = new MyDefinitionId(typeof(MyObjectBuilder_BlueprintDefinition), "BulletproofGlassToIngot"),
                DisplayNameString = "Bulletproof Glass Scrap",
                Icons             = new[]
                {
                    Constants.IconLocation + Constants.BulletproofGlassIcon
                },
                Prerequisites = new[]
                {
                    new MyBlueprintDefinitionBase.Item
                    {
                        Amount = 1,
                        Id     = siliconOreDef.Id
                    }
                },
                Results = new[]
                {
                    new MyBlueprintDefinitionBase.Item
                    {
                        Amount = (MyFixedPoint)6.75,
                        Id     = siliconIngotDef.Id
                    }
                },
                BaseProductionTimeInSeconds = 0.04f
            };

            MyDefinitionManager.Static.Definitions.AddDefinition(newBp);

            // 3) Blueprint Class
            MyBlueprintClassDefinition newBpClass = new MyBlueprintClassDefinition
            {
                Id = new MyDefinitionId(typeof(MyBlueprintClassDefinition), Constants.AwwScrapBlueprintClassSubtypeId),
                DisplayNameString = "Scrap Recycling",
                DescriptionString = "Scrap Recycling",
                Icons             = new[]
                {
                    "Textures\\GUI\\Icons\\component\\ScrapMetalComponent.dds"
                },
                HighlightIcon        = "Textures\\GUI\\Icons\\component\\ScrapMetalComponent.dds",
                InputConstraintIcon  = "Textures\\GUI\\Icons\\filter_ore.dds",
                OutputConstraintIcon = "Textures\\GUI\\Icons\\filter_ingot.dds"
            };

            MyDefinitionManager.Static.Definitions.AddDefinition(newBpClass);

            // 4) Blueprint Class Entry
            BlueprintClassEntry newBpClassEntry = new BlueprintClassEntry
            {
                TypeId             = newBp.Id.TypeId,
                BlueprintSubtypeId = "BulletproofGlassToIngot",
                Class           = "Ingots",
                Enabled         = true,
                BlueprintTypeId = newBp.Id.TypeId.ToString()
            };

            WriteToLog("Added", $"May have added: {newDef}", LogType.General);

            //MyDefinitionManager.Static.Definitions.Definitions.
            //MyDefinitionManager.Static.Definitions.Definitions.Add(typeof(BlueprintClassEntry));
        }