public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
int version = 1; // current version (up to 4095)
m_flags = m_flags | (SaveFlags)version; // save the version and flags
writer.Write((int)m_flags);
// add your version specific stuffs here.
// Make sure to use the SaveFlags for conditional Serialization
}
// public LoadService()
// {
//// this.textureFactory = textureFactory;
//// this.colorFactory = colorFactory;
// }
public virtual void ParseFiles(Dictionary <string, byte[]> files, IEngine engine, SaveFlags saveFlags)
{
Reset();
var watch = Stopwatch.StartNew();
// Save the engine so we can work with it during loading
targetEngine = engine;
// Step 1. Load the system snapshot
if ((saveFlags & SaveFlags.System) == SaveFlags.System)
{
LoadSystem(files);
}
// Step 3 (optional). Look for new colors
if ((saveFlags & SaveFlags.Colors) == SaveFlags.Colors)
{
// parser = LoadSystemColors(files);
// if (parser != null)
// AddParser(parser);
// Add the color parser
parser = LoadColors(files);
if (parser != null)
{
AddParser(parser);
}
}
// Step 4 (optional). Look for color map for sprites and tile map
if ((saveFlags & SaveFlags.ColorMap) == SaveFlags.ColorMap)
{
// TODO this is a legacy parcer and should be depricated
parser = LoadColorMap(files);
if (parser != null)
{
AddParser(parser);
}
// // This will be the new parser moving forward
// parser = LoadColorPalette(files);
// if(parser != null)
// AddParser(parser);
// TODO need to rename SaveFlags.ColorMap to SaveFlags.ColorPalette
}
// Step 5 (optional). Look for new sprites
if ((saveFlags & SaveFlags.Sprites) == SaveFlags.Sprites)
{
parser = LoadSprites(files);
if (parser != null)
{
AddParser(parser);
}
}
// Step 6 (optional). Look for tile map to load
// if ((saveFlags & SaveFlags.FlagColors) == SaveFlags.FlagColors) LoadFlagColors(files);
// Step 6 (optional). Look for tile map to load
if ((saveFlags & SaveFlags.Tilemap) == SaveFlags.Tilemap)
{
LoadTilemap(files);
}
// Step 7 (optional). Look for fonts to load
if ((saveFlags & SaveFlags.Fonts) == SaveFlags.Fonts)
{
var fontExtension = ".font.png";
var paths = files.Keys.Where(s => s.EndsWith(fontExtension)).ToArray();
foreach (var fileName in paths)
{
var fontName = fileName.Split('.')[0];
parser = LoadFont(fontName, files[fileName]);
if (parser != null)
{
AddParser(parser);
}
}
}
// Step 8 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.Meta) == SaveFlags.Meta)
{
parser = LoadMetaData(files);
if (parser != null)
{
AddParser(parser);
}
}
// Step 9 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.Sounds) == SaveFlags.Sounds)
{
LoadSounds(files);
}
// Step 10 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.Music) == SaveFlags.Music)
{
LoadMusic(files);
}
// Step 11 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.SaveData) == SaveFlags.SaveData)
{
LoadSaveData(files);
}
ParseExtraFileTypes(files, engine, saveFlags);
totalParsers = parsers.Count;
currentParserID = 0;
watch.Stop();
// UnityEngine.Debug.Log("Parser Setup Time - " + watch.ElapsedMilliseconds);
}
public virtual void ParseFiles(string[] files, IEngine engine, SaveFlags saveFlags)
{
Reset();
// Save the engine so we can work with it during loading
targetEngine = engine;
// Step 1. Load the system snapshot
if ((saveFlags & SaveFlags.System) == SaveFlags.System)
{
LoadSystem(files);
}
// Step 3 (optional). Look for new colors
if ((saveFlags & SaveFlags.Colors) == SaveFlags.Colors)
{
// Add the color parser
parser = LoadColors(files);
if (parser != null)
{
AddParser(parser);
}
}
// Step 4 (optional). Look for color map for sprites and tile map
if ((saveFlags & SaveFlags.ColorMap) == SaveFlags.ColorMap)
{
// TODO this is a legacy parcer and should be depricated
parser = LoadColorMap(files);
if (parser != null)
{
AddParser(parser);
}
}
// Step 5 (optional). Look for new sprites
if ((saveFlags & SaveFlags.Sprites) == SaveFlags.Sprites)
{
parser = LoadSprites(files);
if (parser != null)
{
AddParser(parser);
}
}
// Step 6 (optional). Look for tile map to load
if ((saveFlags & SaveFlags.Tilemap) == SaveFlags.Tilemap)
{
LoadTilemap(files);
}
// Step 7 (optional). Look for fonts to load
if ((saveFlags & SaveFlags.Fonts) == SaveFlags.Fonts)
{
var paths = files.Where(s => s.EndsWith(".font.png")).ToArray();
foreach (var fileName in paths)
{
// var fontName = GetFileName(fileName).Split('.').First();
var imageParser = new PNGFileReader(fileName, _fileLoadHelper, targetEngine.ColorChip.maskColor);
AddParser(new FontParser(imageParser, targetEngine.ColorChip, targetEngine.FontChip));
// parser = LoadFont(fontName, ReadAllBytes(fileName));
// if (parser != null)
// AddParser(parser);
}
}
// Step 8 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.Meta) == SaveFlags.Meta)
{
parser = LoadMetaData(files);
if (parser != null)
{
AddParser(parser);
}
}
// Step 9 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.Sounds) == SaveFlags.Sounds)
{
LoadSounds(files);
// Get all of the wav files
var wavFiles = files.Where(x => x.EndsWith(".wav")).ToArray();
if (wavFiles.Length > 0)
{
AddParser(new WavParser(wavFiles, _fileLoadHelper, targetEngine));
}
}
// Step 10 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.Music) == SaveFlags.Music)
{
LoadMusic(files);
}
// Step 11 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.SaveData) == SaveFlags.SaveData)
{
LoadSaveData(files);
}
// Step 12 (optional). Look for meta sprites
if ((saveFlags & SaveFlags.MetaSprites) == SaveFlags.MetaSprites)
{
LoadMetaSprites(files);
}
ParseExtraFileTypes(files, engine, saveFlags);
}
public virtual void ParseExtraFileTypes(string[] files, IEngine engine, SaveFlags saveFlags)
{
// TODO Override and add extra file parsers here.
}
public static ISaveFlags GetWrapper(SaveFlags src)
{
return(default(ISaveFlags));
}
public override void Deserialize(GenericReader reader)
{
int version = reader.ReadInt();
switch (version)
{
case 6:
{
m_flags = (SaveFlags)reader.ReadInt32();
goto case 5;
}
case 5:
{
// versions < 6 always read Design & Backup
if (version < 6)
{
m_flags |= SaveFlags.DesignState_Design;
m_flags |= SaveFlags.DesignState_Backup;
}
goto case 4;
}
case 4:
{
m_Signpost = reader.ReadItem();
m_SignpostGraphic = reader.ReadInt();
goto case 3;
}
case 3:
{
m_Type = (FoundationType)reader.ReadInt();
goto case 2;
}
case 2:
{
m_SignHanger = reader.ReadItem();
goto case 1;
}
case 1:
{
if (version < 5)
m_DefaultPrice = reader.ReadInt();
goto case 0;
}
case 0:
{
if (version < 3)
m_Type = FoundationType.Stone;
if (version < 4)
m_SignpostGraphic = 9;
m_LastRevision = reader.ReadInt();
m_Fixtures = reader.ReadItemList();
m_Current = new DesignState(this, reader);
if ((m_flags & SaveFlags.DesignState_Design) != 0)
m_Design = new DesignState(this, reader);
if ((m_flags & SaveFlags.DesignState_Backup) != 0)
m_Backup = new DesignState(this, reader);
break;
}
}
base.Deserialize(reader);
}
public string Save(string title,
string section,
string text,
string summary,
MinorFlags minor,
CreateFlags create,
WatchFlags watch,
SaveFlags mode,
bool bot,
string basetimestamp,
string starttimestamp,
string token)
{
if (string.IsNullOrEmpty(title))
{
throw new ArgumentException("Title shouldn't be empty.", "title");
}
if (string.IsNullOrEmpty(token))
{
throw new ArgumentException("Token shouldn't be empty.", "token");
}
ParameterCollection parameters = new ParameterCollection
{
{ "title", title },
{ "token", token }
};
if (mode == SaveFlags.Replace && !string.IsNullOrEmpty(section))
{
parameters.Add("section", section);
}
if (minor != MinorFlags.None)
{
parameters.Add(minor.ToString().ToLower());
}
if (create != CreateFlags.None)
{
parameters.Add(create.ToString().ToLower());
}
if (watch != WatchFlags.None)
{
parameters.Add("watchlist", watch.ToString().ToLower());
}
if (mode == SaveFlags.Append)
{
parameters.Add("appendtext", text);
}
else if (mode == SaveFlags.Prepend)
{
parameters.Add("prependtext", text);
}
else
{
parameters.Add("text", text);
}
if (bot)
{
parameters.Add("bot");
}
if (!string.IsNullOrEmpty(basetimestamp))
{
parameters.Add("basetimestamp", basetimestamp);
}
if (!string.IsNullOrEmpty(starttimestamp))
{
parameters.Add("starttimestamp", starttimestamp);
}
if (!string.IsNullOrEmpty(summary))
{
parameters.Add("summary", summary);
}
try
{
XmlDocument xml = MakeRequest(Action.Edit, parameters);
XmlNode result = xml.SelectSingleNode("//edit[@newrevid]");
if (result != null)
{
return result.Attributes["newrevid"].Value;
}
}
catch (WebException e)
{
throw new WikiException("Saving failed", e);
}
return null;
}
public void Save(SaveFlags flags)
{
}
public override void ParseExtraFileTypes(Dictionary <string, byte[]> files, IEngine engine, SaveFlags saveFlags)
{
// Step 2 (optional). Load up the Lua script
if ((saveFlags & SaveFlags.Code) == SaveFlags.Code)
{
//var scriptExtension = ".lua";
var paths = files.Keys.Where(s => textExtensions.Any(x => s.EndsWith(x))).ToList();
foreach (var fileName in paths)
{
parser = LoadScript(fileName, files[fileName]);
AddParser(parser);
}
}
}
/// <summary>
/// Saves the <see cref="PdfDocument"/> to the file system.
/// </summary>
/// <param name="version">
/// The new PDF file version of the saved file.
/// 14 for 1.4, 15 for 1.5, etc. Values smaller than 10 are ignored.
/// </param>
public bool Save(string filename, SaveFlags flags = SaveFlags.None, int version = 0)
{
using (var stream = new FileStream(filename, FileMode.Create))
return(Save(stream, flags, version));
}
/// <summary>
/// Saves the <see cref="PdfDocument"/> to a <paramref name="stream"/>.
/// </summary>
/// <param name="version">
/// The new PDF file version of the saved file.
/// 14 for 1.4, 15 for 1.5, etc. Values smaller than 10 are ignored.
/// </param>
public bool Save(Stream stream, SaveFlags flags = SaveFlags.None, int version = 0)
{
return(PDFium.FPDF_SaveAsCopy(Handle, stream, flags, version));
}
public void ParseFiles(Dictionary <string, byte[]> files, IEngine engine, SaveFlags saveFlags)
{
Reset();
var watch = Stopwatch.StartNew();
// Save the engine so we can work with it during loading
targetEngine = engine;
// Step 1. Load the system snapshot
if ((saveFlags & SaveFlags.System) == SaveFlags.System)
{
LoadSystem(files);
}
// Step 2 (optional). Load up the Lua script
if ((saveFlags & SaveFlags.Code) == SaveFlags.Code)
{
//var scriptExtension = ".lua";
var paths = files.Keys.Where(s => textExtensions.Any(x => s.EndsWith(x))).ToList();
foreach (var fileName in paths)
{
parser = LoadScript(fileName, files[fileName]);
AddParser(parser);
}
}
// Step 3 (optional). Look for new colors
if ((saveFlags & SaveFlags.Colors) == SaveFlags.Colors)
{
parser = LoadColors(files);
if (parser != null)
{
AddParser(parser);
}
}
// Step 4 (optional). Look for color map for sprites and tile map
if ((saveFlags & SaveFlags.ColorMap) == SaveFlags.ColorMap)
{
parser = LoadColorMap(files);
if (parser != null)
{
AddParser(parser);
}
}
// Step 5 (optional). Look for new sprites
if ((saveFlags & SaveFlags.Sprites) == SaveFlags.Sprites)
{
parser = LoadSprites(files);
if (parser != null)
{
AddParser(parser);
}
}
// Step 6 (optional). Look for tile map to load
if ((saveFlags & SaveFlags.FlagColors) == SaveFlags.FlagColors)
{
LoadFlagColors(files);
}
// Step 6 (optional). Look for tile map to load
if ((saveFlags & SaveFlags.Tilemap) == SaveFlags.Tilemap)
{
LoadTilemap(files);
}
// Step 7 (optional). Look for fonts to load
if ((saveFlags & SaveFlags.Fonts) == SaveFlags.Fonts)
{
var fontExtension = ".font.png";
var paths = files.Keys.Where(s => s.EndsWith(fontExtension)).ToArray();
foreach (var fileName in paths)
{
var fontName = fileName.Split('.')[0];
parser = LoadFont(fontName, files[fileName]);
if (parser != null)
{
AddParser(parser);
}
}
}
// Step 8 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.Meta) == SaveFlags.Meta)
{
parser = LoadMetaData(files);
if (parser != null)
{
AddParser(parser);
}
}
// Step 9 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.Sounds) == SaveFlags.Sounds)
{
LoadSounds(files);
// if (parser != null)
// AddParser(parser);
}
// Step 10 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.Music) == SaveFlags.Music)
{
LoadMusic(files);
// if (parser != null)
// AddParser(parser);
}
// Step 11 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.SaveData) == SaveFlags.SaveData)
{
LoadSaveData(files);
// if (parser != null)
// AddParser(parser);
}
totalParsers = parsers.Count;
currentParserID = 0;
watch.Stop();
// UnityEngine.Debug.Log("Parser Setup Time - " + watch.ElapsedMilliseconds);
}
public void ExportGame(string path, IEngine engine, SaveFlags saveFlags, bool useSteps = true)
{
Clear();
// Save the engine so we can work with it during loading
targetEngine = engine;
// Step 1. Load the system snapshot
if ((saveFlags & SaveFlags.System) == SaveFlags.System)
{
AddExporter(new SystemExporter(path + "data.json", targetEngine));
}
// Step 3 (optional). Look for new colors
if ((saveFlags & SaveFlags.Colors) == SaveFlags.Colors)
{
var colorChip = targetEngine.ColorChip;
AddExporter(new ColorPaletteExporter(path + "colors.png", colorChip, new PNGWriter()));
}
// Step 4 (optional). Look for color map for sprites and tile map
if ((saveFlags & SaveFlags.ColorMap) == SaveFlags.ColorMap)
{
if (targetEngine.GetChip(ColorMapParser.chipName, false) is ColorChip colorChip)
{
AddExporter(new ColorPaletteExporter(path + "color-map.png", colorChip, new PNGWriter()));
}
}
// Step 5 (optional). Look for new sprites
if ((saveFlags & SaveFlags.Sprites) == SaveFlags.Sprites)
{
// Console.WriteLine("Export Sprite");
var imageExporter = new PNGWriter();
AddExporter(new SpriteExporter(path + "sprites.png", targetEngine, imageExporter));
}
// Step 7 (optional). Look for fonts to load
if ((saveFlags & SaveFlags.Fonts) == SaveFlags.Fonts)
{
var fontChip = targetEngine.FontChip;
var spriteChip = targetEngine.SpriteChip;
var tmpTextureData = new TextureData(96, 64);
var fonts = fontChip.fonts;
foreach (var font in fonts)
{
var name = font.Key;
var sprites = font.Value;
// Clear the texture
tmpTextureData.Clear();
// Loop through all the characters and copy their texture data over
var total = sprites.Length;
for (var i = 0; i < total; i++)
{
}
}
}
if ((saveFlags & SaveFlags.Tilemap) == SaveFlags.Tilemap)
{
AddExporter(new TilemapJsonExporter(path + "tilemap.json", targetEngine));
}
// Step 8 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.Meta) == SaveFlags.Meta)
{
AddExporter(new MetadataExporter(path + "info.json", targetEngine));
}
// Step 9 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.Sounds) == SaveFlags.Sounds)
{
AddExporter(new SoundExporter(path + "sounds.json", targetEngine));
}
// Step 10 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.Music) == SaveFlags.Music)
{
AddExporter(new MusicExporter(path + "music.json", targetEngine));
}
// Step 11 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.SaveData) == SaveFlags.SaveData)
{
AddExporter(new SavedDataExporter(path + "saves.json", targetEngine));
}
// Step 11 (optional). Look for meta data and override the game
if ((saveFlags & SaveFlags.MetaSprites) == SaveFlags.MetaSprites)
{
AddExporter(new MetaSpriteExporter(path + "meta-sprites.json", targetEngine));
}
StartExport(useSteps);
}
public virtual void ParseExtraFileTypes(Dictionary <string, byte[]> files, IEngine engine, SaveFlags saveFlags)
{
// TODO Override and add extra file parsers here.
}
/// <summary>
/// Parse the RopSaveChangesMessageRequest structure.
/// </summary>
/// <param name="s">An stream containing RopSaveChangesMessageRequest structure.</param>
public override void Parse(Stream s)
{
base.Parse(s);
this.RopId = (RopIdType)ReadByte();
this.LogonId = ReadByte();
this.ResponseHandleIndex = ReadByte();
this.InputHandleIndex = ReadByte();
this.SaveFlags = (SaveFlags)ReadByte();
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
switch (version)
{
case 4:
{
m_SecureLevel = (SecureLevel)reader.ReadInt();
goto case 3;
}
case 3:
case 2:
{
BookContent content = this.DefaultContent;
SaveFlags flags = (SaveFlags)reader.ReadByte();
if ((flags & SaveFlags.Title) != 0)
{
m_Title = Utility.Intern(reader.ReadString());
}
else if (content != null)
{
m_Title = content.Title;
}
if ((flags & SaveFlags.Author) != 0)
{
m_Author = reader.ReadString();
}
else if (content != null)
{
m_Author = content.Author;
}
m_Writable = (flags & SaveFlags.Writable) != 0;
if ((flags & SaveFlags.Content) != 0)
{
m_Pages = new BookPageInfo[reader.ReadEncodedInt()];
for (int i = 0; i < m_Pages.Length; ++i)
{
m_Pages[i] = new BookPageInfo(reader);
}
}
else
{
if (content != null)
{
m_Pages = content.Copy();
}
else
{
m_Pages = new BookPageInfo[0];
}
}
break;
}
case 1:
case 0:
{
m_Title = reader.ReadString();
m_Author = reader.ReadString();
m_Writable = reader.ReadBool();
if (version == 0 || reader.ReadBool())
{
m_Pages = new BookPageInfo[reader.ReadInt()];
for (int i = 0; i < m_Pages.Length; ++i)
{
m_Pages[i] = new BookPageInfo(reader);
}
}
else
{
BookContent content = this.DefaultContent;
if (content != null)
{
m_Pages = content.Copy();
}
else
{
m_Pages = new BookPageInfo[0];
}
}
break;
}
}
if (version < 3 && (Weight == 1 || Weight == 2))
{
Weight = -1;
}
}
private bool GetFlag(SaveFlags flag)
{
return((m_SaveFlags & flag) != 0);
}
public string Save(string title,
string section,
string text,
string summary,
MinorFlags minor,
CreateFlags create,
WatchFlags watch,
SaveFlags mode,
bool bot)
{
ParameterCollection parameters = new ParameterCollection
{
{ "prop", "info" },
{ "intoken", "edit" }
};
XmlDocument doc = Query(QueryBy.Titles, parameters, title);
XmlNode pageNode = doc.SelectSingleNode("//page");
string token = pageNode != null ? pageNode.Attributes["edittoken"].Value : "";
return Save(title,
section,
text,
summary,
minor,
create,
watch,
mode,
bot,
"",
"",
token);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt(); // version
m_SaveFlags = ReadSaveFlags(reader, version); // always follows version
/* begin normal Deserialize here */
switch (version)
{
case 10:
{
if (GetFlag(SaveFlags.HasOBAlignment))
{
m_IOBAlignment = (IOBAlignment)reader.ReadInt();
}
goto case 9;
}
case 9:
{
m_Owner = reader.ReadMobile();
goto case 8;
}
case 8:
{
m_Trapper = reader.ReadMobile();
goto case 7;
}
case 7:
{
m_TrapLevel = reader.ReadInt();
goto case 6;
}
case 6:
{
m_OldTrapPower = reader.ReadInt();
goto case 5;
}
case 5:
{
goto case 4;
}
case 4:
{
m_Enabled = reader.ReadBool();
goto case 3;
}
case 3:
{
if (version < 5)
{
reader.ReadBool(); // deco field
}
goto case 2;
}
case 2:
{
if (version <= 7)
{
reader.ReadBool(); // m_TinkerMade
}
m_OldTrapType = (TrapType)reader.ReadInt();
goto case 1;
}
case 1:
{
m_TrapPower = reader.ReadInt();
if (version < 6)
{
m_OldTrapPower = m_TrapPower;
}
goto case 0;
}
case 0:
{
m_TrapType = (TrapType)reader.ReadInt();
break;
}
}
if (version < 7)
{ // I guess this is reasonable
// Example: a level 5 trap is TrapPower 5*25, and the TrapLevel is 5
// therfore a reasonable m_TrapLevel is TrapPower / 25
m_TrapLevel = TrapPower / 25;
}
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
m_flags = (SaveFlags)reader.ReadInt(); // grab the version an flags
int version = (int)(m_flags & (SaveFlags)0xFFF); // maskout the version
// add your version specific stuffs here.
// Make sure to use the SaveFlags for conditional Serialization
switch (version)
{
default: break;
}
}
public override void Serialize(GenericWriter writer)
{
int version = 6;
writer.Write(version); // version
// set the save flags.
// clear
m_flags &= ~SaveFlags.DesignState_Design;
m_flags &= ~SaveFlags.DesignState_Backup;
// set
if (m_Design != null) m_flags |= SaveFlags.DesignState_Design;
if (m_Backup != null) m_flags |= SaveFlags.DesignState_Backup;
// version 6
writer.WriteInt32((int)m_flags);
writer.Write(m_Signpost);
writer.Write((int)m_SignpostGraphic);
writer.Write((int)m_Type);
writer.Write(m_SignHanger);
writer.Write((int)m_LastRevision);
writer.WriteItemList(m_Fixtures, true);
CurrentState.Serialize(writer);
if ((m_flags & SaveFlags.DesignState_Design) != 0)
DesignState.Serialize(writer);
if ((m_flags & SaveFlags.DesignState_Backup) != 0)
BackupState.Serialize(writer);
base.Serialize(writer);
}
