public void Export(IPackage package, IExportConfig config)
{
if (package?.Mod == null)
{
return;
}
var translations = Utils.GetModByName(package.ModName).Field("translations")
as Dictionary <string, ModTranslation>;
if (translations == null)
{
return;
}
var file = new CustomModTranslationFile
{
Translations = new Dictionary <string, BaseEntry>()
};
foreach (var translation in translations)
{
file.Translations.Add(translation.Key, new BaseEntry
{
Origin = translation.Value.DefaultOrEmpty(),
Translation = config.WithTranslation ? translation.Value?.GetTranslation(package.Language) : ""
});
}
package.AddFile(file);
}
public void Export(IPackage package, IExportConfig config)
{
var modName = package.ModName;
var mod = Utils.GetModByName(modName);
if (mod == null)
{
return;
}
var file = Activator.CreateInstance(typeof(T)) as IFile;
foreach (var prop in typeof(T).ModTranslationOwnerField())
{
var fieldName = prop.ModTranslationOwnerFieldName();
var field = (IDictionary)mod.Field(fieldName);
var entryType = prop.PropertyType.GenericTypeArguments
.FirstOrDefault(g => g.GetInterfaces().Contains(typeof(IEntry)));
var entries = CreateEntries(field, entryType, package.Language, config.WithTranslation);
var entriesOfFile = (IDictionary)prop.GetValue(file);
foreach (var e in entries)
{
entriesOfFile.Add(e.Key, e.Value);
}
}
package.AddFile(file);
}
public KMZExporter(
IExportConfig config,
IJ4JLogger?logger = null
)
: base(config, logger)
{
Type = GeoExtensions.GetTargetType <ExporterAttribute>(GetType()) !.Type;
}
public void Export(IPackage package, IExportConfig config)
{
if (package?.Mod == null)
{
return;
}
var modFile = package.Mod.File;
var asmManager = "Terraria.ModLoader.Core.AssemblyManager".Type();
var assemblyName = (string)asmManager.Invoke("GetModAssemblyFileName", modFile, true);
var loadedMod = asmManager.ValueOf("loadedMods").Invoke("get_Item", package.Mod.Name);
var reref = (byte[])asmManager.GetNestedType("LoadedMod", NoroHelper.Any).Method("EncapsulateReferences")
.Invoke(loadedMod, new object[] { modFile.GetBytes(assemblyName), null });
var asm = AssemblyDefinition.ReadAssembly(new MemoryStream(reref));
var file = new LdstrFile
{
LdstrEntries = new Dictionary <string, LdstrEntry>()
};
foreach (var type in asm.MainModule.GetTypes())
{
if (type.Namespace == null)
{
continue;
}
foreach (var method in type.Methods)
{
if (method.DeclaringType?.Namespace == null || method.IsAbstract)
{
continue;
}
try
{
LogDebug($"Exporting method: [{method.GetID()}]");
var entry = GetEntryFromMethod(method);
if (entry != null && !file.LdstrEntries.ContainsKey(method.GetID()))
{
file.LdstrEntries.Add(method.GetID(), entry);
}
}
catch (Exception e)
{
Localizer.Log.Error(e.ToString());
}
}
}
package.AddFile(file);
}
public void Export(IPackage package, IExportConfig config)
{
var fileExportServices = Localizer.Kernel.GetAll <IFileExportService>();
if (package.Mod == null || package.Mod.GetType() != typeof(Mod))
{
package.Mod = Localizer.GetWrappedMod(package.ModName);
}
foreach (var service in fileExportServices)
{
service.Export(package, config);
}
}
public void Export(IPackage package, IExportConfig config)
{
if (package?.Mod == null)
{
return;
}
var asm = package.Mod.Code;
var file = new LdstrFile
{
LdstrEntries = new Dictionary <string, LdstrEntry>()
};
foreach (var type in asm.ManifestModule.GetTypes())
{
/* The return value of GetTypes() and other methods will include types they derived from.
* So we should check the namespace to ensure it belongs to the assembly, but there still are
* some issues. */
if (type.Namespace == null || !type.Namespace.StartsWith(package.Mod.Name))
{
continue;
}
foreach (var method in type.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static))
{
if (method.DeclaringType?.Namespace == null || !method.DeclaringType.Namespace.StartsWith(
package.Mod.Name) ||
method.IsAbstract)
{
continue;
}
try
{
var entry = GetEntryFromMethod(method);
if (entry != null && !file.LdstrEntries.ContainsKey(method.GetID()))
{
file.LdstrEntries.Add(method.GetID(), entry);
}
}
catch (Exception e)
{
Localizer.Log.Error(e.ToString());
}
}
}
package.AddFile(file);
}
public void Export(IPackage package, IExportConfig config)
{
var fileExportServices = Localizer.Kernel.GetAll <IFileExportService>();
if (package.Mod == null || package.Mod.GetType() != typeof(Mod))
{
package.Mod = new ModWrapper(ModLoader.Mods.FirstOrDefault(m => m.Name == package.ModName));
}
foreach (var service in fileExportServices)
{
service.Export(package, config);
}
}
public void Export(IPackage package, IExportConfig config)
{
if (package?.Mod == null)
{
return;
}
var asm = package.Mod.Code;
var file = new LdstrFile
{
LdstrEntries = new Dictionary <string, LdstrEntry>()
};
foreach (var type in asm.ManifestModule.GetTypes())
{
if (type.Namespace == null)
{
continue;
}
var methodBases = new List <MethodBase>();
methodBases.AddRange(type.GetMethods(All | BindingFlags.DeclaredOnly));
methodBases.AddRange(type.GetConstructors(All | BindingFlags.DeclaredOnly));
foreach (var method in methodBases)
{
if (method.DeclaringType?.Namespace == null || method.IsAbstract)
{
continue;
}
try
{
Utils.LogDebug($"Exporting method: [{method.GetID()}]");
var entry = GetEntryFromMethod(method);
if (entry != null && !file.LdstrEntries.ContainsKey(method.GetID()))
{
file.LdstrEntries.Add(method.GetID(), entry);
}
}
catch (Exception e)
{
Localizer.Log.Error(e.ToString());
}
}
}
package.AddFile(file);
}
