/**
         * Add a new definition to the set.
         *
         * Crashes if existing.
         */
        public void AddDefinition(MyDefinitionBase def)
        {
            Dictionary <MyStringHash, MyDefinitionBase> dict;

            if (!Definitions.TryGetValue(def.Id.TypeId, out dict))
            {
                dict = new Dictionary <MyStringHash, MyDefinitionBase>();
                Definitions[def.Id.TypeId] = dict;
            }

            dict[def.Id.SubtypeId] = def;
        }
        public T GetDefinition <T>(MyDefinitionId id) where T : MyDefinitionBase
        {
            MyDefinitionBase definitionBase = null;

            Dictionary <MyStringHash, MyDefinitionBase> dictionary;

            if (Definitions.TryGetValue(id.TypeId, out dictionary))
            {
                dictionary.TryGetValue(id.SubtypeId, out definitionBase);
            }

            return((T)definitionBase);
        }
        public T GetDefinition <T>(MyStringHash subtypeId) where T : MyDefinitionBase
        {
            MyDefinitionBase definitionBase = null;

            var ob = MyDefinitionManagerBase.GetObjectBuilderType(typeof(T));
            Dictionary <MyStringHash, MyDefinitionBase> dictionary;

            if (Definitions.TryGetValue(ob, out dictionary))
            {
                dictionary.TryGetValue(subtypeId, out definitionBase);
            }

            return((T)definitionBase);
        }
        /**
         * Add or replace an existing definition.
         */
        public bool AddOrRelaceDefinition(MyDefinitionBase def)
        {
            Dictionary <MyStringHash, MyDefinitionBase> dict;

            if (!Definitions.TryGetValue(def.Id.TypeId, out dict))
            {
                dict = new Dictionary <MyStringHash, MyDefinitionBase>();
                Definitions[def.Id.TypeId] = dict;
            }

            var contains = dict.ContainsKey(def.Id.SubtypeId);

            dict[def.Id.SubtypeId] = def;

            return(contains);
        }
Example #5
0
        public void LoadDefinitions(string path)
        {
            bool result = false;
            MyObjectBuilder_Definitions builder = null;

            using (var fileStream = MyFileSystem.OpenRead(path))
            {
                if (fileStream != null)
                {
                    using (var readStream = fileStream.UnwrapGZip())
                    {
                        if (readStream != null)
                        {
                            MyObjectBuilder_Base obj;
                            result  = MyObjectBuilderSerializer.DeserializeXML(readStream, out obj, typeof(MyObjectBuilder_Definitions), m_overrideMap);
                            builder = obj as MyObjectBuilder_Definitions;
                        }
                    }
                }
            }

            if (!result)
            {
                throw new Exception("Error while reading \"" + path + "\"");
            }

            if (builder.Definitions != null)
            {
                foreach (MyObjectBuilder_DefinitionBase definitionBuilder in builder.Definitions)
                {
                    MyObjectBuilderType.RemapType(ref definitionBuilder.Id, m_overrideMap);
                    MyDefinitionBase definition = GetObjectFactory().CreateInstance(definitionBuilder.TypeId);
                    definition.Init(builder.Definitions[0], new MyModContext());
                    m_definitions.AddDefinition(definition);
                }
            }
        }