// public event PropertyChangedEventHandler PropertyChanged;
//
// event PropertyChangedEventHandler INotifyPropertyChanged.PropertyChanged
// {
// add => throw new NotImplementedException();
// remove => throw new NotImplementedException();
// }
private void LoadIcons()
{
var realm = new ARealmReversed(Properties.Settings.Default.GamePath, Language.English);
var micons = realm.GameData.GetSheet("MacroIcon");
_iconImages = new Dictionary <string, BitmapImage>();
foreach (var row in micons)
{
string key = $"{(int)row.GetRaw(0):X7}";
if (key == "0000000")
{
continue;
}
ImageFile imgFile = IconHelper.GetIcon(row.Sheet.Collection.PackCollection, SaintCoinach.Ex.Language.English, (int)row.GetRaw(0));
var tmp = ImageConverter.Convert(imgFile.GetData(), ImageFormat.A8R8G8B8_1, imgFile.Width, imgFile.Height);
using (var ms = new MemoryStream())
{
tmp.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
ms.Position = 0;
var bi = new BitmapImage();
bi.BeginInit();
bi.CacheOption = BitmapCacheOption.OnLoad;
bi.StreamSource = ms;
bi.EndInit();
if (!_iconImages.ContainsKey(key))
{
_iconImages.Add(key, bi);
}
}
}
}
public Weather(IRealm realm, ISendMessageEvent sendMessageEvent)
{
_realm = realm.RealmReversed;
_sendMessageEvent = sendMessageEvent;
_territoryList = LoadZones();
}
private void MainForm_Load(object sender, EventArgs e)
{
var gameDirectory = Properties.Settings.Default.GameDirectory;
if (!Directory.Exists(gameDirectory))
{
if (SetGameLocation() == false)
{
ResultTextBox.AppendText("No FFXIV Data located.");
return;
}
gameDirectory = Properties.Settings.Default.GameDirectory;
}
realm = new ARealmReversed(gameDirectory, @"SaintCoinach.History.zip", SaintCoinach.Ex.Language.English);
realm.Packs.GetPack(new SaintCoinach.IO.PackIdentifier("exd", SaintCoinach.IO.PackIdentifier.DefaultExpansion, 0)).KeepInMemory = true;
ResultTextBox.AppendText($"Game version: {realm.GameVersion}\r\nDefinition Version: {realm.DefinitionVersion}\r\n\r\n");
if (!realm.IsCurrentVersion)
{
ResultTextBox.AppendText("Update available.");
}
foreach (var item in Territory.territory)
{
TerritoryComboBox.Items.Add(item.Value.PlaceName);
}
}
public static void Init(TestContext context)
{
ARealmReversed Realm = new ARealmReversed(GameDirectory, Language.English);
ItemSheet = Realm.GameData.GetSheet <Item>();
PathFormatter.Init(Realm);
}
public MainWindow()
{
try
{
InitializeComponent();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
System.Diagnostics.Debug.WriteLine(ex.StackTrace);
}
realm = new ARealmReversed(GameDirectory, SaintCoinach.Ex.Language.English);
// DataContext = new MainViewModel();
WindowPosition pos = WindowPosition.Load();
if (pos.MainWindowWidth > 0)
{
Width = pos.MainWindowWidth;
}
if (pos.MainWindowHeight > 0)
{
Height = pos.MainWindowHeight;
}
if (pos.MainWindowLeft > 0)
{
Left = pos.MainWindowLeft;
}
if (pos.MainWindowTop > 0)
{
Top = pos.MainWindowTop;
}
}
public static void WriteMapModels(ARealmReversed realm, TerritoryType teriType)
{
Territory territory = Plot.StringToWard(teriType.Name);
string inpath = FFXIVHSPaths.GetTerritoryJson(territory);
if (!File.Exists(inpath))
{
throw new FileNotFoundException();
}
string outpath = FFXIVHSPaths.GetTerritoryObjectsDirectory(territory);
string json = File.ReadAllText(inpath);
Map map = JsonConvert.DeserializeObject <Map>(json);
foreach (MapModel model in map.models.Values)
{
if (realm.Packs.TryGetFile(model.modelPath, out SaintCoinach.IO.File f))
{
ObjectFileWriter.WriteObjectFile(outpath, (ModelFile)f);
}
}
}
public static void WriteMapModels(ARealmReversed realm, TerritoryType teriType, SaintCoinach.Graphics.Territory teri = null)
{
string name = teri != null ? teri.Name : teriType.Name;
//Plot.Ward ward = Plot.StringToWard(teriType.Name);
string outpath = Path.Combine(FFXIVHSPaths.GetRootDirectory(), name, "objects\\");
string inpath = Path.Combine(FFXIVHSPaths.GetRootDirectory(), name + "\\", name + ".json");
if (!Directory.Exists(outpath))
{
Directory.CreateDirectory(outpath);
}
//string inpath = FFXIVHSPaths.GetWardJson(ward);
if (!File.Exists(inpath))
{
throw new FileNotFoundException();
}
//string outpath = FFXIVHSPaths.GetWardObjectsDirectory(ward);
string json = File.ReadAllText(inpath);
Map map = JsonConvert.DeserializeObject <Map>(json);
foreach (MapModel model in map.models.Values)
{
if (realm.Packs.TryGetFile(model.modelPath, out SaintCoinach.IO.File f))
{
ObjectFileWriter.WriteObjectFile(outpath, (ModelFile)f);
}
}
}
public MainViewModel()
{
if (!App.IsValidGamePath(Properties.Settings.Default.GamePath))
{
return;
}
var languages = new[] { SaintCoinach.Ex.Language.English, SaintCoinach.Ex.Language.ChineseSimplified, SaintCoinach.Ex.Language.Korean };
NotSupportedException lastException = null;
foreach (var language in languages)
{
try {
var realm = new ARealmReversed(Properties.Settings.Default.GamePath, language);
Initialize(realm);
lastException = null;
break;
}
catch (NotSupportedException e) {
lastException = e;
continue;
}
}
if (lastException != null)
{
throw new AggregateException(new[] { lastException });
}
}
private static void Main(string[] args)
{
var programDir =
Environment.GetFolderPath(
Environment.Is64BitProcess ? Environment.SpecialFolder.ProgramFilesX86 : Environment.SpecialFolder.ProgramFiles);
var dataPath = Path.Combine(programDir, "SquareEnix", "FINAL FANTASY XIV - A Realm Reborn");
var realm = new ARealmReversed(dataPath, @"SaintCoinach.History.zip", Language.English);
//realm.Packs.GetPack(new SaintCoinach.IO.PackIdentifier("exd", SaintCoinach.IO.PackIdentifier.DefaultExpansion, 0)).KeepInMemory = true;
File.Delete("ExBuddy.s3db");
Database database = null;
Database rbdb = null;
try
{
database = new Database("ExBuddy.s3db", true);
rbdb = new Database("db.s3db");
LoadMSD(database, rbdb, realm);
}
finally
{
database?.Dispose();
rbdb?.Dispose();
}
}
public LuaParser(SaintCoinach.Xiv.Quest scQuest, ARealmReversed realm)
{
//BuiltQuest = built;
this.scQuest = scQuest;
this.realm = realm;
SetupState();
}
static void ExtractVentureNames(Localize localize, ARealmReversed realm)
{
JObject res = new JObject();
foreach (var task in realm.GameData.GetSheet <RetainerTask>())
{
if (task.Task is RetainerTaskNormal)
{
Item item = null;
using (IEnumerator <Item> enumer = task.Task.Items.GetEnumerator())
{
if (enumer.MoveNext())
{
item = enumer.Current;
}
}
JObject name = localize.Strings(item, "Name");
if (name != null)
{
res.Add(task.Key.ToString(), name);
}
}
else if (task.Task is RetainerTaskRandom)
{
JObject name = localize.Strings(task.Task, "Name");
if (name != null)
{
res.Add(task.Key.ToString(), name);
}
}
}
string json = Regex.Replace(res.ToString(Newtonsoft.Json.Formatting.Indented), "(\"(?:[^\"\\\\]|\\\\.)*\")|\\s+", "$1");
File.WriteAllText(AppDomain.CurrentDomain.BaseDirectory + BASE_ANGULAR_PATH + "src\\app\\core\\data\\sources\\ventures.json", json);
}
static ARealmReversed SetUpSaintCoinach(string gamePath)
{
var realm = new ARealmReversed(gamePath, @"SaintCoinach.History.zip", SaintCoinach.Ex.Language.English, @"app_data.sqlite");
realm.Packs.GetPack(new SaintCoinach.IO.PackIdentifier("exd", SaintCoinach.IO.PackIdentifier.DefaultExpansion, 0)).KeepInMemory = true;
return(realm);
}
static void ExtractItemNames(Localize localize, ARealmReversed realm)
{
JObject res = new JObject();
var itemRows = realm.GameData.Items;
foreach (var item in itemRows)
{
JObject itemName = localize.Strings(item, "Name");
if (itemName != null)
{
res.Add(item.Key.ToString(), itemName);
}
}
var draftRows = realm.GameData.GetSheet <CompanyCraftDraft>();
foreach (var draft in draftRows)
{
JObject itemName = localize.Strings(draft, "Name");
if (itemName != null)
{
res.Add("draft" + draft.Key.ToString(), itemName);
}
}
string json = Regex.Replace(res.ToString(Newtonsoft.Json.Formatting.Indented), "(\"(?:[^\"\\\\]|\\\\.)*\")|\\s+", "$1");
File.WriteAllText(AppDomain.CurrentDomain.BaseDirectory + BASE_ANGULAR_PATH + "src\\assets\\data\\items.json", json);
}
public MainWindow()
{
try
{
//Environment.GetFolderPath(Environment.SpecialFolder.Mydocuments)
InitializeComponent();
DataContext = this;
_realm = new ARealmReversed(_gamePath, SaintCoinach.Ex.Language.English);
ResizeMode = ResizeMode.NoResize;
List <string> dats = FindMacroDats();
Macros = new List <MacroFile>();
foreach (string path in dats)
{
Macros.Add(new MacroFile(path));
}
CurrentMacroFile = Macros[0];
InitGrid();
// TestImg();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
System.Diagnostics.Debug.WriteLine(ex.StackTrace);
}
}
public static void WriteMap(ARealmReversed realm, TerritoryType teriType, SaintCoinach.Graphics.Territory teri = null)
{
string name = teri != null ? teri.Name : teriType.Name;
//Plot.Ward ward = Plot.StringToWard(teriType.Name);
string outdir = Path.Combine(FFXIVHSPaths.GetRootDirectory(), name + "\\");
string outpath = Path.Combine(outdir, name + ".json");
//string outpath = FFXIVHSPaths.GetWardJson(ward);
if (!Directory.Exists(outdir))
{
Directory.CreateDirectory(outdir);
}
if (File.Exists(outpath))
{
WriteMapModels(realm, teriType, teri);
return;
}
Map map = ReadTerritory(teriType, teri);
string json = JsonConvert.SerializeObject(map, Formatting.Indented);
File.WriteAllText(outpath, json);
}
public static void WriteOutHousingExteriorModels(ARealmReversed realm)
{
string inpath = FFXIVHSPaths.GetHousingExteriorJson();
if (!File.Exists(inpath))
{
throw new FileNotFoundException();
}
string outpath = FFXIVHSPaths.GetHousingExteriorObjectsDirectory();
string jsonText = File.ReadAllText(inpath);
Dictionary <int, HousingExteriorFixture> fixtures =
JsonConvert.DeserializeObject <Dictionary <int, HousingExteriorFixture> >(jsonText);
foreach (HousingExteriorFixture fixture in fixtures.Values)
{
foreach (HousingExteriorFixtureVariant variant in fixture.variants)
{
foreach (HousingExteriorFixtureModel model in variant.models)
{
if (realm.Packs.TryGetFile(model.modelPath, out SaintCoinach.IO.File f))
{
ObjectFileWriter.WriteObjectFile(outpath, (ModelFile)f);
}
}
}
}
}
/// <summary>
/// Attempts to read all entries of type SgbModelEntry from the paths contained in sgbPaths,
/// constructs a HousingExteriorFixtureModel for each entry and returns all variants.
/// </summary>
/// <param name="realm"></param>
/// <param name="sgbPaths"></param>
/// <returns></returns>
private static HousingExteriorFixtureVariant[] ReadSgbForVariantInfo(ARealmReversed realm, string[] sgbPaths)
{
HousingExteriorFixtureVariant[] variants = new HousingExteriorFixtureVariant[sgbPaths.Length];
for (int i = 0; i < sgbPaths.Length; i++)
{
//Check if sgb valid then get it
SaintCoinach.IO.File baseFile;
if (!realm.Packs.TryGetFile(sgbPaths[i], out baseFile))
{
throw new FileNotFoundException();
}
SgbFile sgb = new SgbFile(baseFile);
//Get modelEntries
HousingExteriorFixtureVariant thisVariant = new HousingExteriorFixtureVariant();
thisVariant.sgbPath = sgbPaths[i];
List <HousingExteriorFixtureModel> modelsList = new List <HousingExteriorFixtureModel>();
foreach (SgbGroup group in sgb.Data.OfType <SgbGroup>())
{
foreach (SgbModelEntry mdl in group.Entries.OfType <SgbModelEntry>())
{
modelsList.Add(ReadTransformedModelForModelInfo(mdl.Model));
}
}
thisVariant.models = modelsList.ToArray();
variants[i] = thisVariant;
}
return(variants);
}
internal static void BuildPackAndMerge(string gamePath)
{
var realm = new ARealmReversed(gamePath, SaintCoinach.Ex.Language.ChineseSimplified);
var items = realm.GameData.GetSheet <SaintCoinach.Xiv.Item>();
var save = Helper.GetMilFilePathRaw($"iconstore.pack");
var old = Helper.GetMilFilePathRaw($"iconstore_old.pack");
var delta = Helper.GetMilFilePathRaw($"iconstore_delta_{DateTime.Now:yyyyMMdd}.pack");
using (var saveStm = new FileStream(save, FileMode.Open))
using (var oldStm = new FileStream(old, FileMode.Open))
using (var deltaStm = new FileStream(delta, FileMode.Create))
using (var saveArc = new ZipArchive(saveStm, ZipArchiveMode.Update))
using (var oldArc = new ZipArchive(oldStm, ZipArchiveMode.Update))
using (var deltaArc = new ZipArchive(deltaStm, ZipArchiveMode.Create))
{
var oldHash = new Dictionary <string, string>(oldArc.Entries.Count);
foreach (var entry in oldArc.Entries)
{
using (var reader = entry.Open())
{
oldHash[entry.Name] = Helper.Sha1Hash(Helper.ReadFullStream(reader));
}
}
foreach (var i in items)
{
var name = i.Name;
var key = i.Key;
if (string.IsNullOrWhiteSpace(name))
{
continue;
}
var bytes = ImageToByteArray(i.Icon.GetImage());
if (oldHash.TryGetValue($"{key}.png", out var hash) && hash == Helper.Sha1Hash(bytes))
{
continue;
}
WriteDual(saveArc, deltaArc, key, bytes);
}
}
File.Delete(old);
File.Copy(save, old);
byte[] ImageToByteArray(Image imageIn)
{
using (var ms = new MemoryStream())
{
imageIn.Save(ms, ImageFormat.Png);
return(ms.ToArray());
}
}
}
public Realm(ICustomLogger logger, AppConfiguration config, ISendMessageEvent sendMessageEvent)
{
_logger = logger;
_config = config;
_sendMessageEvent = sendMessageEvent;
RealmReversed = new ARealmReversed(_config.FilePaths.GamePath, GetLanguage(_config.ExportSettings.Language));
}
public static void Run(ARealmReversed realm)
{
//new RenderCapture(realm).Run();
//ModelCapture(realm);
//MonsterImageCapture(realm);
//Stop();
}
private static void LoadMSD(Database database, Database rbdb, ARealmReversed realm)
{
var xivItems =
realm.GameData.GetSheet <MasterpieceSupplyDuty>().Where(x => x.ClassJob.Key != 0).ToList();
var items = new List <MasterpieceSupplyDutyResult>(xivItems.Count);
var requiredItems = new List <RequiredItemResult>(64);
var rbItems = rbdb.Table <Item>().ToArray();
for (var i = 0; i < xivItems.Count; i++)
{
var xivItem = xivItems[i];
var item = new MasterpieceSupplyDutyResult
{
Id = (uint)xivItem.Key,
Index = (uint)(xivItems.Count - xivItem.Key)
};
item.ClassJob = (ClassJobType)xivItem.ClassJob.Key;
item.ItemLevel = xivItem.ItemLevel;
item.RewardItemId = (uint)xivItem.RewardItem.Key;
foreach (var ci in xivItem.CollectableItems)
{
if (ci.RequiredItem.Key == 0)
{
continue;
}
var rbItem = rbItems[ci.RequiredItem.Key];
var requiredItem = new RequiredItemResult
{
Id = rbItem.Id,
ChnName = rbItem.ChnName,
EngName = rbItem.EngName,
FreName = rbItem.FreName,
JapName = rbItem.JapName,
GerName = rbItem.GerName,
MasterpieceSupplyDutyResultId = item.Id
};
requiredItems.Add(requiredItem);
}
items.Add(item);
}
database.InsertAll(items);
database.InsertAll(requiredItems);
var result = database.Query <MasterpieceSupplyDutyResult>(@"
select m.*
from MasterpieceSupplyDutyResult m
join RequiredItemResult r on m.Id = r.MasterpieceSupplyDutyResultId
where r.Id = ?", 5108).SingleOrDefault();
}
private static void Initialise(string assetPath)
{
Console.WriteLine("Initialising GameTables...");
realm = new ARealmReversed(assetPath, "SaintCoinach.History.zip", Language.English);
realm.Packs.GetPack(new PackIdentifier("exd", PackIdentifier.DefaultExpansion, 0)).KeepInMemory = true;
Console.WriteLine($"Version (Game): {realm.GameVersion}, Version (Definition): {realm.DefinitionVersion}");
}
public MainViewModel()
{
// if (!App.IsValidGamePath(Properties.Settings.Default.GamePath))
// return;
// var realm = new ARealmReversed(Properties.Settings.Default.GamePath, SaintCoinach.Ex.Language.English);
var realm = new ARealmReversed(GameDirectory, Language.English);
Initialize(realm);
}
public static uint GetNumRows(ARealmReversed realm, string sheet)
{
byte[] file = GetSheet(realm, sheet);
if (file == null)
{
return(0);
}
return(GetNumRows(file));
}
static void Setup(RootCommand rootCmd, ARealmReversed realm)
{
var assembly = typeof(Program).Assembly;
foreach (var t in assembly.GetTypes().Where(t => typeof(ActionCommandBase).IsAssignableFrom(t)))
{
var cons = t.GetConstructor(new[] { typeof(ARealmReversed) });
rootCmd.RegisterCommand((ActionCommandBase)cons.Invoke(new[] { realm }));
}
}
public static byte[] GetRow(ARealmReversed realm, string sheet, int row)
{
byte[] file = GetSheet(realm, sheet);
if (file == null)
{
return(null);
}
return(GetRow(file, row));
}
void Initialize(ARealmReversed realm)
{
realm.Packs.GetPack(new SaintCoinach.IO.PackIdentifier("exd", SaintCoinach.IO.PackIdentifier.DefaultExpansion, 0)).KeepInMemory = true;
PathFormatter.Init(realm);
Realm = realm;
EquipmentSelect = new EquipmentSelectViewModel(this);
Export = new ExportViewModel(this);
CharaMake = new CharaMakeViewModel(this);
}
public async Task Start()
{
string directory = await GetInstallationDirectory();
Stopwatch sw = new Stopwatch();
sw.Start();
if (File.Exists("SaintCoinach.History.zip"))
{
File.Delete("SaintCoinach.History.zip");
}
// Unzip definitions
if (Directory.Exists("./Definitions/"))
{
Directory.Delete("./Definitions/", true);
}
ZipFile.ExtractToDirectory("./Modules/SaintCoinach/Definitions.zip", "./Definitions/");
// TODO get language from language service?
ARealmReversed realm = new ARealmReversed(directory, Language.English);
try
{
if (!realm.IsCurrentVersion)
{
realm.Update(true, this);
}
}
catch (Exception ex)
{
throw new Exception(@"Failed to update Saint Coinach", ex);
}
Log.Write("Reading data", @"Saint Coinach");
this.Items = this.Load <IItem, Item, ItemWrapper>(realm);
this.Races = this.Load <IRace, Race, RaceWrapper>(realm);
this.Tribes = this.Load <ITribe, Tribe, TribeWrapper>(realm);
this.Dyes = this.Load <IDye, Stain, DyeWrapper>(realm);
this.BaseNPCs = this.Load <INpcBase, ENpcBase, NpcBaseWrapper>(realm);
this.Territories = this.Load <ITerritoryType, TerritoryType, TerritoryTypeWrapper>(realm);
this.Weathers = this.Load <IWeather, Weather, WeatherWrapper>(realm);
this.CharacterMakeCustomize = this.Load <ICharaMakeCustomize, CharaMakeCustomize, CharacterMakeCustomizeWrapper>(realm);
this.CharacterMakeTypes = this.Load <ICharaMakeType, CharaMakeType, CharacterMakeTypeWrapper>(realm);
this.ResidentNPCs = this.Load <INpcResident, ENpcResident, NpcResidentWrapper>(realm);
this.Titles = this.Load <ITitle, Title, TitleWrapper>(realm);
this.Statuses = this.Load <IStatus, Status, StatusWrapper>(realm);
Log.Write("Finished Reading data", @"Saint Coinach");
Log.Write("Initialization took " + sw.ElapsedMilliseconds + "ms", @"Saint Coinach");
}
static SaintCHelper()
{
var dataPath = @"G:\Program Files (x86)\SquareEnix\FINAL FANTASY XIV - A Realm Reborn";
realm = new ARealmReversed(dataPath, @"SaintCoinach.History.zip", SaintCoinach.Ex.Language.English, @"app_data.sqlite");
realm.Packs.GetPack(new PackIdentifier("exd", PackIdentifier.DefaultExpansion, 0)).KeepInMemory = true;
Console.WriteLine("Game version: {0}", realm.GameVersion);
Console.WriteLine("Definition version: {0}", realm.DefinitionVersion);
//LoadGarlandData();
}
public Localize(ARealmReversed realm)
{
_realm = realm;
_data = realm.GameData;
_langs = new Tuple <string, Language>[]
{
Tuple.Create(Language.English.GetCode(), Language.English),
Tuple.Create(Language.Japanese.GetCode(), Language.Japanese),
Tuple.Create(Language.German.GetCode(), Language.German),
Tuple.Create(Language.French.GetCode(), Language.French)
};
}
public MapCommand(ARealmReversed realm)
: base("maps", "Export all map images.") {
_Realm = realm;
}
public ImageCommand(ARealmReversed realm)
: base("image", "Export an image file.") {
_Realm = realm;
}
public RawExdCommand(ARealmReversed realm)
: base("rawexd", "Export all data (default), or only specific data files, seperated by spaces. No post-processing is applied to values.") {
_Realm = realm;
}
public WikiExdCommand(ARealmReversed realm)
: base("wikiexd", "Export all data (default) in wiki txt files")
{
_Realm = realm;
}
public ExdCommand(ARealmReversed realm)
: base("exd", "Export all data (default), or only specific data files, seperated by spaces.") {
_Realm = realm;
}
public BgmCommand(ARealmReversed realm)
: base("bgm", "Export all BGM files.") {
_Realm = realm;
}
public LanguageCommand(ARealmReversed realm)
: base("lang", "Change the language.") {
_Realm = realm;
}
public RawCommand(ARealmReversed realm)
: base("raw", "Save raw contents of a file.") {
_Realm = realm;
}
public UiCommand(ARealmReversed realm)
: base("ui", "Export all, a single, or a range of UI icons.") {
_Realm = realm;
}
