public void AddReaders(string directory, bool forceLoading = false)
{
m_d2IPath = directory;
if (!DelayLoading || forceLoading)
{
foreach (string d2iFile in Directory.EnumerateFiles(directory).Where(entry => entry.EndsWith(".d2i")))
{
var reader = new D2IFile(d2iFile);
AddReader(reader);
}
}
}
public static string GetText(int id)
{
string str = D2IFile.GetText(id);
if (str == string.Empty || str == null)
{
return("[UNKNOWN_TEXT_ID_" + id + "]");
}
else
{
return(str);
}
}
public static void OpenD2Os(string path, bool log)
{
Log = log;
GameData.Init(path);
D2IFile = new D2IFile();
try
{
D2IFile.Open(path + "/lang.d2i");
Logger.Log("D2I File Loaded");
}
catch
{
throw new Exception(string.Format("Unable to find D2IFile: {0}", path + "/lang.d2i"));
}
foreach (var value in Enum.GetValues(typeof(D2oFileEnum)))
{
LoadD2OFile((D2oFileEnum)value, Log);
}
}
private void EnsureLanguageIsLoaded(Languages language)
{
if (m_readers.ContainsKey(language))
{
return;
}
if (string.IsNullOrEmpty(m_d2IPath))
{
return; // AddReaders not called yet
}
foreach (var d2iFile in Directory.EnumerateFiles(m_d2IPath).Where(entry => entry.EndsWith(".d2i")).Where(path => GetLanguageOfFile(path) == language))
{
var reader = new D2IFile(d2iFile);
AddReader(reader, language);
}
if (!m_readers.ContainsKey(language))
{
throw new Exception(string.Format("Language {0} not found in the d2i files, check the path of these files and that the file exist ({1})", language, m_d2IPath));
}
}
public static void ReadD2IFiles()
{
var langs = Program._accessor.Database.Query <LangText>(LangTextRelator.FetchQuery, new object[0]).ToDictionary(entry => entry.Id);
var langsUI = Program._accessor.Database.Query <LangTextUi>(LangTextUiRelator.FetchQuery, new object[0]).ToDictionary(entry => entry.Name);
foreach (var item in Directory.GetFiles(string.Format(@"{0}\app\data\i18n\", _clientPath), "*.d2i*", SearchOption.TopDirectoryOnly))
{
var match = Regex.Match(Path.GetFileName(item), "i18n_(?<lang>[a-zA-Z]{2}).d2i");
if (match.Success)
{
var d2iFile = new D2IFile(item);
Action <LangText, string> langAction = null;
Action <LangTextUi, string> langUIAction = null;
switch (match.Groups["lang"].Value)
{
case "de":
langAction = new Action <LangText, string>((lang, value) => { lang.Dutsh = value; });
langUIAction = new Action <LangTextUi, string>((lang, value) => { lang.Dutsh = value; });
break;
case "en":
langAction = new Action <LangText, string>((lang, value) => { lang.English = value; });
langUIAction = new Action <LangTextUi, string>((lang, value) => { lang.English = value; });
break;
case "es":
langAction = new Action <LangText, string>((lang, value) => { lang.Spanish = value; });
langUIAction = new Action <LangTextUi, string>((lang, value) => { lang.Spanish = value; });
break;
case "fr":
langAction = new Action <LangText, string>((lang, value) => { lang.French = value; });
langUIAction = new Action <LangTextUi, string>((lang, value) => { lang.French = value; });
break;
case "it":
langAction = new Action <LangText, string>((lang, value) => { lang.Italian = value; });
langUIAction = new Action <LangTextUi, string>((lang, value) => { lang.Italian = value; });
break;
case "ja":
langAction = new Action <LangText, string>((lang, value) => { lang.Japanish = value; });
langUIAction = new Action <LangTextUi, string>((lang, value) => { lang.Japanish = value; });
break;
case "pt":
langAction = new Action <LangText, string>((lang, value) => { lang.Portugese = value; });
langUIAction = new Action <LangTextUi, string>((lang, value) => { lang.Portugese = value; });
break;
case "ru":
langAction = new Action <LangText, string>((lang, value) => { lang.Russish = value; });
langUIAction = new Action <LangTextUi, string>((lang, value) => { lang.Russish = value; });
break;
default:
break;
}
foreach (var lang in d2iFile.GetAllText())
{
if (!langs.ContainsKey((uint)lang.Key))
{
langs.Add((uint)lang.Key, new LangText {
Id = (uint)lang.Key
});
}
langAction(langs[(uint)lang.Key], lang.Value);
}
foreach (var langUi in d2iFile.GetAllUiText())
{
if (!langsUI.ContainsKey(langUi.Key))
{
langsUI.Add(langUi.Key, new LangTextUi {
Name = langUi.Key
});
}
langUIAction(langsUI[langUi.Key], langUi.Value);
}
}
}
foreach (var item in langs)
{
Program._accessor.Database.Insert(item.Value);
}
foreach (var item in langsUI)
{
Program._accessor.Database.Insert(item.Value);
}
}
public static void Intialize()
{
D2IFile = new D2IFile();
D2IFile.Open(Environment.CurrentDirectory + "\\lang.d2i");
}
private void LoadD2I()
{
d2iFile = new D2IFile(D2I_FILE_PATH);
logger.White("D2I File loaded");
}
public static Dictionary <Type, List <ITable> > GetD2OTables(Type type, List <D2OReader> d2oFiles, D2IFile d2iFile)
{
Dictionary <Type, List <ITable> > tables = new Dictionary <Type, List <ITable> >();
D2OAttribute d2oAttribute = type.GetCustomAttribute <D2OAttribute>();
DataClass[] d2oData = GetD2OData(d2oFiles, d2oAttribute);
if (d2oData.Length == 0)
{
logger.Color2("Unable to find d2o module : " + d2oAttribute.Module);
Console.ReadKey();
Environment.Exit(0);
}
logger.White("Loading D2OTable " + d2oAttribute.ToString() + "...");
foreach (var data in d2oData)
{
ID2OTable table = Activator.CreateInstance(type) as ID2OTable;
foreach (var field in GetD2OFields(table))
{
var attribute = field.GetCustomAttribute <D2OFieldAttribute>();
if (!data.Fields.ContainsKey(attribute.FieldName))
{
logger.NewLine();
logger.Color2("Unable to get fieldValue for (" + attribute.FieldName + ") the field dosent exist in d2oFile (" + d2oAttribute.ToString() + ")");
logger.NewLine();
logger.Color1("D2O Fields for " + d2oAttribute.Module + ":");
foreach (var d2oField in d2oData[0].Fields.Keys)
{
logger.Color2("-" + d2oField, false);
}
Console.Read();
Environment.Exit(0);
}
object fieldValue = data.Fields[attribute.FieldName];
if (fieldValue == null)
{
if (field.FieldType == typeof(string))
{
field.SetValue(table, string.Empty);
}
else
{
field.SetValue(table, Activator.CreateInstance(field.FieldType));
}
continue;
}
var customMethod = type.GetMethods().FirstOrDefault(x => x.GetCustomAttribute <D2OFieldHandler>() != null);
if (customMethod != null)
{
var methodAttribute = customMethod.GetCustomAttribute <D2OFieldHandler>();
if (methodAttribute.Field == attribute.FieldName)
{
customMethod.Invoke(table, new object[] { fieldValue });
continue;
}
}
if (fieldValue is ArrayList)
{
var array = (fieldValue as ArrayList).ToArray();
if (array.Length > 0)
{
var obj = array[0];
if (obj is DataClass)
{
var d2otype = D2oTypeManager.GetType(obj as DataClass);
IList list = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(new Type[] { d2otype }));
foreach (var value in array)
{
list.Add(D2oTypeManager.Handle(value as DataClass));
}
try
{
field.SetValue(table, list.XMLSerialize());
}
catch
{
logger.Color2("Type for field " + field.Name + " in " + type.Name + " must be string");
Console.Read();
Environment.Exit(0);
}
}
else if (obj is ArrayList)
{
string str = string.Empty;
foreach (ArrayList subItem in array)
{
foreach (var item in subItem)
{
str += item + ",";
}
str = str.Remove(str.Length - 1, 1);
str += "|";
}
if (str != string.Empty)
{
str = str.Remove(str.Length - 1, 1);
}
field.SetValue(table, str);
}
else
{
var list = Activator.CreateInstance(field.FieldType) as IList;
foreach (var value in array)
{
var listType = field.FieldType.GenericTypeArguments[0];
list.Add(Convert.ChangeType(value, listType));
}
field.SetValue(table, list);
}
}
}
else if (fieldValue is DataClass)
{
string value = D2oTypeManager.Handle(fieldValue as DataClass).XMLSerialize(); // idem
field.SetValue(table, value);
}
else
{
if (fieldValue != null)
{
if (fieldValue is String && fieldValue.ToString().ToLower() == "null")
{
fieldValue = string.Empty;
}
if (field.FieldType == typeof(String) && fieldValue is Int32)
{
if (field.GetCustomAttribute <i18nAttribute>() != null)
{
fieldValue = d2iFile.GetText((int)fieldValue);
fieldValue = fieldValue.ToString().Replace('\'', ' ');
}
}
field.SetValue(table, Convert.ChangeType(fieldValue, field.FieldType));
}
}
}
if (tables.ContainsKey(type))
{
tables[type].Add(table);
}
else
{
tables.Add(type, new List <ITable> {
table
});
}
}
return(tables);
}
public D2IEditor(D2IFile file)
{
InitializeComponent();
ModelView = new D2IEditorModelView(this, file);
DataContext = ModelView;
}
public void AddReader(D2IFile d2iFile, Languages language)
{
m_readers.Add(language, d2iFile);
logger.Info("File added : {0}", Path.GetFileName(d2iFile.FilePath));
}
public void AddReader(D2IFile d2iFile)
{
Languages language = GetLanguageOfFile(d2iFile.FilePath);
AddReader(d2iFile, language);
}
