private void TranslateInternal(MyObjectBuilder_BlockVariantsDefinition input, ref MyObjectBuilder_BlockVariantsDefinition output)
 {
     TranslateDependencies(input, ref output, (x) =>
     {
         var def = SourceSet.GetDefinition <MyObjectBuilder_BlockDefinition>(x);
         return(def == null ? x : Translate(def).Id);
     }, (x) => x.Blocks, (x, y) => x.Blocks = y.ToList());
 }
        public T Translate <T>(T input, bool forceCopy = false) where T : MyObjectBuilder_DefinitionBase
        {
            var translatedId = new MyDefinitionId(input.Id.TypeId, input.Id.SubtypeIdAttribute + SubtypeSuffix);
            var translated   = DestinationSet.GetDefinition <T>(translatedId);

            if (translated != null && translated.GetType() == input.GetType())
            {
                return(translated);
            }

            var args = new object[] { input, input };

            foreach (var translator in Translators)
            {
                if (translator.GetParameters()[0].ParameterType.IsInstanceOfType(input))
                {
                    translator.Invoke(this, args);
                }
            }

            var output = (T)args[1];

            if (output == input && forceCopy)
            {
                output = (T)MyObjectBuilderSerializer.Clone(input);
            }
            if (output != input)
            {
                foreach (var translator in ConditionalTranslators)
                {
                    if (translator.GetParameters()[0].ParameterType.IsInstanceOfType(input))
                    {
                        translator.Invoke(this, new object[] { output });
                    }
                }

                output.Id = translatedId;
                DestinationSet.AddOrReplaceDefinition(output);
                Console.WriteLine("Translated " + input.GetType().Name + " " + input.Id + " to " + output.Id);
            }

            return(output);
        }