public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
Gvas gvas = existingValue == null ? new Gvas() : (Gvas)existingValue;
JObject jo = JObject.Load(reader);
gvas.SaveGameVersion = int.Parse(jo["SaveGameVersion"].ToString());
gvas.PackageVersion = int.Parse(jo["PackageVersion"].ToString());
gvas.EngineVersion.Major = short.Parse(jo["EngineVersion"]["Major"].ToString());
gvas.EngineVersion.Minor = short.Parse(jo["EngineVersion"]["Minor"].ToString());
gvas.EngineVersion.Patch = short.Parse(jo["EngineVersion"]["Patch"].ToString());
gvas.EngineVersion.Build = short.Parse(jo["EngineVersion"]["Build"].ToString());
gvas.EngineVersion.BuildId = jo["EngineVersion"]["BuildId"].ToString();
gvas.CustomFormatVersion = int.Parse(jo["CustomFormatVersion"].ToString());
gvas.CustomFormatData.Count = int.Parse(jo["CustomFormatData"]["Count"].ToString());
List <CustomFormatDataEntry> cfd = new List <CustomFormatDataEntry>();
foreach (JObject o in jo["CustomFormatData"]["Entries"])
{
cfd.Add(new CustomFormatDataEntry(o["Id"].ToObject <Guid>(), int.Parse(o["Value"].ToString())));
}
gvas.CustomFormatData.Entries = cfd.ToArray();
gvas.SaveGameType = jo["SaveGameType"].ToString();
foreach (JObject o in jo["Properties"])
{
gvas.Properties.Add(ReadUEProperty(o));
}
//gvas.Properties.Add(ReadUEProperty(o));
return(gvas);
}
public static Gvas ReadGvas(Stream stream)
{
using (var reader = new UE_BinaryReader(stream, true))
{
int type_tag = reader.ReadInt32();
if (type_tag != GvasFormat.SaveGameHeader.UE4_SAVEGAME_FILE_TYPE_TAG)
{
throw new NotSupportedException("Only `GVAS` file is supported.");
}
var result = new Gvas();
//
result.Header = SaveGameHeader.Read(reader);
//
var list = new List <UE_Property>();
var ue_prop_reader = new UE_Property_Reader(reader);
while (ue_prop_reader.Read() is UE_Property prop)
{
if (prop is UE_None)
{
break;
}
list.Add(prop);
}
result.PropertyList = list;
//
return(result);
}
}
public static void WriteKovaakSpecific(Gvas gvas, Stream stream)
{
using (var writer = new BinaryWriter(stream, Encoding.ASCII, true))
{
writer.Write(Gvas.Header);
writer.Write(gvas.SaveGameVersion);
writer.Write(gvas.PackageVersion);
writer.Write(gvas.EngineVersion.Major);
writer.Write(gvas.EngineVersion.Minor);
writer.Write(gvas.EngineVersion.Patch);
writer.Write(gvas.EngineVersion.Build);
writer.WriteUEString(gvas.EngineVersion.BuildId);
writer.Write(gvas.CustomFormatVersion);
writer.Write(gvas.CustomFormatData.Count);
foreach (var entry in gvas.CustomFormatData.Entries)
{
writer.Write(entry.Id.ToByteArray());
writer.Write(entry.Value);
}
writer.WriteUEString(gvas.SaveGameType);
((UEGenericStructProperty)gvas.Properties[0]).Serialize(writer);
((UENoneProperty)gvas.Properties[1]).Serialize(writer);
writer.Write((int)0);
}
}
public static void Write(Gvas gvas, Stream stream)
{
using (var writer = new BinaryWriter(stream, Encoding.ASCII, true))
{
writer.Write(Gvas.Header);
writer.Write(gvas.SaveGameVersion);
writer.Write(gvas.PackageVersion);
writer.Write(gvas.EngineVersion.Major);
writer.Write(gvas.EngineVersion.Minor);
writer.Write(gvas.EngineVersion.Patch);
writer.Write(gvas.EngineVersion.Build);
writer.WriteUEString(gvas.EngineVersion.BuildId);
writer.Write(gvas.CustomFormatVersion);
writer.Write(gvas.CustomFormatData.Count);
foreach (var entry in gvas.CustomFormatData.Entries)
{
writer.Write(entry.Id.ToByteArray());
writer.Write(entry.Value);
}
writer.WriteUEString(gvas.SaveGameType);
foreach (var prop in gvas.Properties)
{
Console.WriteLine($"GVAS Serializing {prop}");
prop.Serialize(writer);
}
writer.Write((int)0);
}
}
public static void Write(FileStream stream, Gvas data)
{
using (BinaryWriter writer = new BinaryWriter(stream, Encoding.ASCII, true))
{
writer.Write(Gvas.Header);
writer.WriteInt32(data.SaveGameVersion);
writer.WriteInt32(data.PackageVersion);
writer.WriteInt16(data.EngineVersion.Major);
writer.WriteInt16(data.EngineVersion.Minor);
writer.WriteInt16(data.EngineVersion.Patch);
writer.WriteInt32(data.EngineVersion.Build);
writer.WriteUEString(data.EngineVersion.BuildId);
writer.WriteInt32(data.CustomFormatVersion);
writer.WriteInt32(data.CustomFormatData.Count);
for (var i = 0; i < data.CustomFormatData.Count; i++)
{
var entry = data.CustomFormatData.Entries[i];
writer.Write(entry.Id.ToByteArray());
writer.WriteInt32(entry.Value);
}
writer.WriteUEString(data.SaveGameType);
foreach (UEProperty prop in data.Properties)
{
prop.Serialize(writer);
}
writer.WriteInt32(0);
}
}
public void GameData_Slot0v011()
{
Gvas gvas = Gvas.Load(@"C:\Users\Wouter\AppData\Local\CodeVein\Saved\SaveGames\112073240\GameData_Slot0v011.sav");
if (gvas.Properties.First(x => x.Name == "__buffer") is UEArrayProperty <byte> arr)
{
File.WriteAllBytes("GameData_Slot0v011", arr.Value);
}
}
public static void WriteGvas(Stream stream, Gvas save)
{
using (var writer = new UE_BinaryWriter(stream, true))
{
SaveGameHeader.Write(writer, save.Header);
var ue_prop_writer = new UE_Property_Writer(writer);
for (int i = 0; i < save.PropertyList.Count; i++)
{
ue_prop_writer.Write(save.PropertyList[i], PositionToken.Normal);
}
ue_prop_writer.Write_UE_None();
string Null_End = null;
writer.Write(Null_End);
}
}
public static Gvas Read(Stream stream)
{
using (var reader = new BinaryReader(stream, Encoding.ASCII, true))
{
var header = reader.ReadBytes(Gvas.Header.Length);
if (!Gvas.Header.SequenceEqual(header))
{
throw new FormatException($"Invalid header, expected {Gvas.Header.AsHex()}");
}
var result = new Gvas();
result.SaveGameVersion = reader.ReadInt32();
result.PackageVersion = reader.ReadInt32();
result.EngineVersion.Major = reader.ReadInt16();
result.EngineVersion.Minor = reader.ReadInt16();
result.EngineVersion.Patch = reader.ReadInt16();
result.EngineVersion.Build = reader.ReadInt32();
result.EngineVersion.BuildId = reader.ReadUEString();
result.CustomFormatVersion = reader.ReadInt32();
result.CustomFormatData.Count = reader.ReadInt32();
result.CustomFormatData.Entries = new CustomFormatDataEntry[result.CustomFormatData.Count];
for (var i = 0; i < result.CustomFormatData.Count; i++)
{
var entry = new CustomFormatDataEntry();
entry.Id = new Guid(reader.ReadBytes(16));
entry.Value = reader.ReadInt32();
result.CustomFormatData.Entries[i] = entry;
}
result.SaveGameType = reader.ReadUEString();
while (UEProperty.Read(reader) is UEProperty prop)
{
Console.WriteLine(x++);
if (x == 10)
{
var json = JsonConvert.SerializeObject(result.Properties, new JsonSerializerSettings {
Formatting = Formatting.Indented
});
Console.WriteLine(json);
}
result.Properties.Add(prop);
}
return(result);
}
}
public static void WriteGvas(Stream stream, Gvas save, bool compact)
{
using (var sw = new StreamWriter(stream, new UTF8Encoding(false, true)))
using (var json_writer = new JsonTextWriter(sw))
{
json_writer.Formatting = Formatting.Indented;
json_writer.Indentation = 2;
if (compact)
{
JsonConvert_Compact.Write.Gvas(json_writer, save);
}
else
{
JsonConvert_Invertible.Write.Gvas(json_writer, save);
}
json_writer.Flush();
}
}
public static string WriteGvas(Gvas save, bool compact)
{
var sb = new StringBuilder();
using (var tw = new StringWriter(sb))
using (var json_writer = new JsonTextWriter(tw))
{
json_writer.Formatting = Formatting.Indented;
json_writer.Indentation = 2;
if (compact)
{
JsonConvert_Compact.Write.Gvas(json_writer, save);
}
else
{
JsonConvert_Invertible.Write.Gvas(json_writer, save);
}
json_writer.Flush();
}
return(sb.ToString());
}
static void Main(string[] args)
{
if (args.Length != 2)
{
Console.WriteLine("Usage:");
Console.WriteLine(" gvas-converter infile outfile");
return;
}
var ext = Path.GetExtension(args[0]).ToLower();
if (ext == ".json")
{
Console.WriteLine("Loading json...");
Gvas data = JsonConvert.DeserializeObject <Gvas>(File.ReadAllText(args[0]), new GvasJsonConverter());
var stream = File.Open(args[1], FileMode.Create, FileAccess.Write);
Console.WriteLine("Converting and saving file...");
UESerializer.Write(stream, data);
}
else
{
Console.WriteLine("Parsing UE4 save file structure...");
Gvas save;
using (var stream = File.Open(args[0], FileMode.Open, FileAccess.Read, FileShare.Read))
save = UESerializer.Read(stream);
Console.WriteLine("Converting to json...");
var json = JsonConvert.SerializeObject(save, new JsonSerializerSettings {
Formatting = Formatting.Indented
});
Console.WriteLine("Saving json...");
using (var stream = File.Open(args[1], FileMode.Create, FileAccess.Write, FileShare.Read))
using (var writer = new StreamWriter(stream, new UTF8Encoding(false)))
writer.Write(json);
}
Console.WriteLine("Done.");
}
private void LoadPlaylist(object sender, EventArgs e)
{
var fd = new OpenFileDialog();
fd.DefaultExt = "plo";
fd.AddExtension = true;
fd.Filter = "Playlist (*.plo) | *.plo";
var res = fd.ShowDialog();
if (res.Accept())
{
try
{
using (var stream = File.Open(fd.FileName, FileMode.Open, FileAccess.Read, FileShare.Read))
_playlist = UESerializer.Read(stream);
}
catch
{
_playlist = null;
new UserMessages().InvalidIO();
}
if (_playlist != null && PlaylistScenarios.Items.Count() > 0)
{
_playlistPath = fd.FileName;
_shuffledPlaylist = new KovaakHandler().ImportPlaylist(PlaylistScenarios.Items);
_importedListPlaylist = new GroupUtil().UngroupBySame(_shuffledPlaylist);
_playlistNameTextbox.Text = $"{PlaylistName.Value} - Shuffled";
UpdateProgramState();
}
}
else
{
new UserMessages().InvalidIO();
}
}
