public GR.Memory.ByteBuffer ToBuffer()
{
GR.IO.FileChunk chunkSolution = new GR.IO.FileChunk(Types.FileChunk.SOLUTION);
GR.IO.FileChunk chunkSolutionInfo = new GR.IO.FileChunk(Types.FileChunk.SOLUTION_INFO);
if (string.IsNullOrEmpty(Name))
{
Name = System.IO.Path.GetFileNameWithoutExtension(Filename);
}
chunkSolutionInfo.AppendString(Name);
chunkSolutionInfo.AppendString(this.Filename);
chunkSolution.Append(chunkSolutionInfo.ToBuffer());
GR.IO.FileChunk chunkExpandedNodes = new GR.IO.FileChunk(Types.FileChunk.SOLUTION_NODES);
foreach (string key in ExpandedNodes)
{
chunkExpandedNodes.AppendString(key);
}
chunkSolution.Append(chunkExpandedNodes.ToBuffer());
foreach (Project project in Projects)
{
GR.IO.FileChunk chunkSolutionProject = new GR.IO.FileChunk(Types.FileChunk.SOLUTION_PROJECT);
chunkSolutionProject.AppendString(GR.Path.RelativePathTo(Filename, false, project.Settings.Filename, false));
chunkSolution.Append(chunkSolutionProject.ToBuffer());
}
return(chunkSolution.ToBuffer());
}
public GR.Memory.ByteBuffer SaveToBuffer()
{
GR.Memory.ByteBuffer projectFile = new GR.Memory.ByteBuffer();
GR.IO.FileChunk chunkProjectInfo = new GR.IO.FileChunk(FileChunkConstants.DISASSEMBLY_INFO);
chunkProjectInfo.AppendString(Description);
projectFile.Append(chunkProjectInfo.ToBuffer());
GR.IO.FileChunk chunkProjectData = new GR.IO.FileChunk(FileChunkConstants.DISASSEMBLY_DATA);
chunkProjectData.AppendI32(DataStartAddress);
chunkProjectData.AppendU32(Data.Length);
chunkProjectData.Append(Data);
projectFile.Append(chunkProjectData.ToBuffer());
GR.IO.FileChunk chunkJumpAddresses = new GR.IO.FileChunk(FileChunkConstants.DISASSEMBLY_JUMP_ADDRESSES);
chunkJumpAddresses.AppendI32(JumpedAtAddresses.Count);
foreach (int jumpAddress in JumpedAtAddresses)
{
chunkJumpAddresses.AppendI32(jumpAddress);
}
projectFile.Append(chunkJumpAddresses.ToBuffer());
GR.IO.FileChunk chunkNamedLabels = new GR.IO.FileChunk(FileChunkConstants.DISASSEMBLY_NAMED_LABELS);
chunkNamedLabels.AppendI32(NamedLabels.Count);
foreach (var namedLabel in NamedLabels)
{
chunkNamedLabels.AppendI32(namedLabel.Key);
chunkNamedLabels.AppendString(namedLabel.Value);
}
projectFile.Append(chunkNamedLabels.ToBuffer());
return(projectFile);
}
public GR.Memory.ByteBuffer SaveToBuffer()
{
GR.Memory.ByteBuffer data = new GR.Memory.ByteBuffer();
data.Reserve(ScreenHeight * ScreenWidth * 8);
GR.IO.FileChunk chunkScreenInfo = new GR.IO.FileChunk(FileChunkConstants.GRAPHIC_SCREEN_INFO);
chunkScreenInfo.AppendU32((uint)SelectedCheckType);
chunkScreenInfo.AppendI32(ScreenOffsetX);
chunkScreenInfo.AppendI32(ScreenOffsetY);
chunkScreenInfo.AppendI32(ScreenWidth);
chunkScreenInfo.AppendI32(ScreenHeight);
data.Append(chunkScreenInfo.ToBuffer());
GR.IO.FileChunk chunkGraphicData = new GR.IO.FileChunk(FileChunkConstants.GRAPHIC_DATA);
chunkGraphicData.AppendI32(Image.Width);
chunkGraphicData.AppendI32(Image.Height);
chunkGraphicData.AppendI32((int)Image.PixelFormat);
chunkGraphicData.AppendI32(Image.PaletteEntryCount);
for (int i = 0; i < Image.PaletteEntryCount; ++i)
{
chunkGraphicData.AppendU8(Image.PaletteRed(i));
chunkGraphicData.AppendU8(Image.PaletteGreen(i));
chunkGraphicData.AppendU8(Image.PaletteBlue(i));
}
GR.Memory.ByteBuffer imageData = Image.GetAsData();
chunkGraphicData.AppendU32(imageData.Length);
chunkGraphicData.Append(imageData);
data.Append(chunkGraphicData.ToBuffer());
GR.IO.FileChunk chunkScreenMultiColorData = new GR.IO.FileChunk(FileChunkConstants.MULTICOLOR_DATA);
chunkScreenMultiColorData.AppendU8((byte)(MultiColor ? 1 : 0));
chunkScreenMultiColorData.AppendU8((byte)Colors.BackgroundColor);
chunkScreenMultiColorData.AppendU8((byte)Colors.MultiColor1);
chunkScreenMultiColorData.AppendU8((byte)Colors.MultiColor2);
chunkScreenMultiColorData.AppendI32(Colors.ActivePalette);
data.Append(chunkScreenMultiColorData.ToBuffer());
foreach (var pal in Colors.Palettes)
{
data.Append(pal.ToBuffer());
}
GR.IO.FileChunk chunkColorMapping = new GR.IO.FileChunk(FileChunkConstants.GRAPHIC_COLOR_MAPPING);
chunkColorMapping.AppendI32(ColorMapping.Count);
for (int i = 0; i < ColorMapping.Count; ++i)
{
var mappings = ColorMapping[i];
chunkColorMapping.AppendI32(mappings.Count);
for (int j = 0; j < mappings.Count; ++j)
{
chunkColorMapping.AppendU8((byte)mappings[j]);
}
}
data.Append(chunkColorMapping.ToBuffer());
return(data);
}
public bool Save(string Filename)
{
GR.Memory.ByteBuffer bufferProject = new GR.Memory.ByteBuffer();
GR.IO.FileChunk chunkProject = new GR.IO.FileChunk(Types.FileChunk.PROJECT);
chunkProject.AppendU32(1);
chunkProject.AppendString(Settings.Name);
chunkProject.AppendString(Filename);
chunkProject.AppendU16(Settings.DebugPort);
chunkProject.AppendU16(Settings.DebugStartAddress);
chunkProject.AppendString(Settings.BuildTool);
chunkProject.AppendString(Settings.RunTool);
chunkProject.AppendString(Settings.MainDocument);
bufferProject.Append(chunkProject.ToBuffer());
foreach (ProjectElement element in Elements)
{
GR.IO.FileChunk chunkElement = new GR.IO.FileChunk(Types.FileChunk.PROJECT_ELEMENT);
chunkElement.AppendU32(1);
chunkElement.AppendU32((uint)element.Type);
chunkElement.AppendString(element.Name);
chunkElement.AppendString(element.Filename);
GR.IO.FileChunk chunkElementData = new GR.IO.FileChunk(Types.FileChunk.PROJECT_ELEMENT_DATA);
element.Document.SaveToChunk(chunkElementData);
chunkElement.Append(chunkElementData.ToBuffer());
chunkElement.AppendString(element.TargetFilename);
chunkElement.AppendU32((uint)element.TargetType);
bufferProject.Append(chunkElement.ToBuffer());
}
try
{
System.IO.File.WriteAllBytes(Filename, bufferProject.Data());
}
catch (System.IO.IOException)
{
return(false);
}
m_Modified = false;
return(true);
}
public GR.Memory.ByteBuffer SaveToBuffer()
{
GR.Memory.ByteBuffer projectFile = new GR.Memory.ByteBuffer();
GR.IO.FileChunk chunkScreenInfo = new GR.IO.FileChunk(Types.FileChunk.CHARSET_SCREEN_INFO);
// version
chunkScreenInfo.AppendU32(0);
// width
chunkScreenInfo.AppendI32(ScreenWidth);
// height
chunkScreenInfo.AppendI32(ScreenHeight);
chunkScreenInfo.AppendString("");
chunkScreenInfo.AppendI32((int)Mode);
chunkScreenInfo.AppendI32(ScreenOffsetX);
chunkScreenInfo.AppendI32(ScreenOffsetY);
projectFile.Append(chunkScreenInfo.ToBuffer());
GR.IO.FileChunk chunkCharSet = new GR.IO.FileChunk(Types.FileChunk.CHARSET_DATA);
chunkCharSet.Append(CharSet.SaveToBuffer());
projectFile.Append(chunkCharSet.ToBuffer());
GR.IO.FileChunk chunkScreenMultiColorData = new GR.IO.FileChunk(Types.FileChunk.MULTICOLOR_DATA);
chunkScreenMultiColorData.AppendU8((byte)Mode);
chunkScreenMultiColorData.AppendU8((byte)BackgroundColor);
chunkScreenMultiColorData.AppendU8((byte)MultiColor1);
chunkScreenMultiColorData.AppendU8((byte)MultiColor2);
projectFile.Append(chunkScreenMultiColorData.ToBuffer());
GR.IO.FileChunk chunkScreenCharData = new GR.IO.FileChunk(Types.FileChunk.SCREEN_CHAR_DATA);
for (int i = 0; i < Chars.Count; ++i)
{
chunkScreenCharData.AppendU8((byte)(Chars[i] & 0xff));
}
projectFile.Append(chunkScreenCharData.ToBuffer());
GR.IO.FileChunk chunkScreenColorData = new GR.IO.FileChunk(Types.FileChunk.SCREEN_COLOR_DATA);
for (int i = 0; i < Chars.Count; ++i)
{
chunkScreenColorData.AppendU8((byte)(Chars[i] >> 8));
}
projectFile.Append(chunkScreenColorData.ToBuffer());
return(projectFile);
}
public GR.Memory.ByteBuffer SaveToBuffer()
{
GR.Memory.ByteBuffer projectFile = new GR.Memory.ByteBuffer();
// version
projectFile.AppendU32(2);
var chunkCharsetProject = new GR.IO.FileChunk(RetroDevStudio.FileChunkConstants.CHARSET_PROJECT);
var chunkCharsetInfo = new GR.IO.FileChunk(RetroDevStudio.FileChunkConstants.CHARSET_INFO);
chunkCharsetInfo.AppendI32((int)Mode);
chunkCharsetInfo.AppendI32(TotalNumberOfCharacters);
chunkCharsetInfo.AppendI32(ShowGrid ? 1 : 0);
chunkCharsetProject.Append(chunkCharsetInfo.ToBuffer());
var chunkColorSettings = new GR.IO.FileChunk(RetroDevStudio.FileChunkConstants.CHARSET_COLOR_SETTINGS);
chunkColorSettings.AppendI32(Colors.BackgroundColor);
chunkColorSettings.AppendI32(Colors.MultiColor1);
chunkColorSettings.AppendI32(Colors.MultiColor2);
chunkColorSettings.AppendI32(Colors.BGColor4);
chunkColorSettings.AppendI32(Colors.ActivePalette);
chunkCharsetProject.Append(chunkColorSettings.ToBuffer());
foreach (var pal in Colors.Palettes)
{
chunkCharsetProject.Append(pal.ToBuffer());
}
var chunkExport = new GR.IO.FileChunk(RetroDevStudio.FileChunkConstants.CHARSET_EXPORT);
chunkExport.AppendI32(ExportStartCharacter);
chunkExport.AppendI32(ExportNumCharacters);
chunkExport.AppendString(ExportFilename);
chunkCharsetProject.Append(chunkExport.ToBuffer());
foreach (var character in Characters)
{
var chunkCharsetChar = new GR.IO.FileChunk(RetroDevStudio.FileChunkConstants.CHARSET_CHAR);
//chunkCharsetChar.AppendI32( (int)character.Mode );
chunkCharsetChar.AppendI32(0); // was mode
chunkCharsetChar.AppendI32(character.Tile.CustomColor);
chunkCharsetChar.AppendI32(character.Category);
chunkCharsetChar.AppendI32((int)character.Tile.Data.Length);
chunkCharsetChar.Append(character.Tile.Data);
chunkCharsetProject.Append(chunkCharsetChar.ToBuffer());
}
foreach (var category in Categories)
{
var chunkCategory = new GR.IO.FileChunk(RetroDevStudio.FileChunkConstants.CHARSET_CATEGORY);
chunkCategory.AppendString(category);
chunkCharsetProject.Append(chunkCategory.ToBuffer());
}
var chunkPlayground = new GR.IO.FileChunk(RetroDevStudio.FileChunkConstants.CHARSET_PLAYGROUND);
chunkPlayground.AppendI32(PlaygroundWidth);
chunkPlayground.AppendI32(PlaygroundHeight);
for (int i = 0; i < PlaygroundChars.Count; ++i)
{
// 16 bit index, 16 bit color
chunkPlayground.AppendU32(PlaygroundChars[i]);
}
chunkCharsetProject.Append(chunkPlayground.ToBuffer());
projectFile.Append(chunkCharsetProject.ToBuffer());
/*
* // version
* projectFile.AppendU32( 1 );
* // Name
* projectFile.AppendString( System.IO.Path.GetFileNameWithoutExtension( Name ) );
* // charset Filename
* projectFile.AppendString( System.IO.Path.GetFileNameWithoutExtension( Name ) );
*
* for ( int i = 0; i < 256; ++i )
* {
* projectFile.AppendI32( Characters[i].Color );
* }
* for ( int i = 0; i < 256; ++i )
* {
* projectFile.AppendU8( (byte)Characters[i].Mode );
* }
* projectFile.AppendI32( BackgroundColor );
* projectFile.AppendI32( MultiColor1 );
* projectFile.AppendI32( MultiColor2 );
*
* for ( int i = 0; i < 256; ++i )
* {
* // Tile colors
* projectFile.AppendI32( 0 );
* projectFile.AppendI32( 0 );
* projectFile.AppendI32( 0 );
* projectFile.AppendI32( 0 );
* // Tile chars
* projectFile.AppendI32( 0 );
* projectFile.AppendI32( 0 );
* projectFile.AppendI32( 0 );
* projectFile.AppendI32( 0 );
* }
*
* // generic multi color
* projectFile.AppendI32( 0 );
*
* // test bed
* projectFile.Append( new GR.Memory.ByteBuffer( 64 ) );
*
* // charset data
* for ( int i = 0; i < 256; ++i )
* {
* projectFile.Append( Characters[i].Data );
* }
*
* // used tiles
* projectFile.AppendU32( UsedTiles );
*
* // export name
* projectFile.AppendString( ExportFilename );
* // export path block table
* projectFile.AppendString( "" );
* // export path charset
* projectFile.AppendString( "" );
* // export path editor tiles
* projectFile.AppendString( "" );
* // categories
* projectFile.AppendI32( Categories.Count );
* for ( int i = 0; i < Categories.Count; ++i )
* {
* projectFile.AppendI32( i );
* projectFile.AppendString( Categories[i] );
* }
* for ( int i = 0; i < 256; ++i )
* {
* projectFile.AppendI32( Characters[i].Category );
* }
* projectFile.AppendI32( NumCharacters );
* projectFile.AppendI32( ShowGrid ? 1 : 0 );
* projectFile.AppendI32( StartCharacter );
* projectFile.AppendI32( BGColor4 );
*
* // playground
* projectFile.AppendI32( 16 ); // w
* projectFile.AppendI32( 16 ); // h
*
* for ( int i = 0; i < PlaygroundChars.Count; ++i )
* {
* projectFile.AppendU16( PlaygroundChars[i] );
* }
*
* projectFile.AppendI32( (int)Mode );
*/
return(projectFile);
}
public GR.Memory.ByteBuffer SaveToBuffer()
{
GR.Memory.ByteBuffer projectFile = new GR.Memory.ByteBuffer();
GR.IO.FileChunk chunkProjectInfo = new GR.IO.FileChunk(Types.FileChunk.MAP_PROJECT_INFO);
// version
chunkProjectInfo.AppendU32(0);
chunkProjectInfo.AppendString(ExternalCharset);
chunkProjectInfo.AppendI32(ShowGrid ? 1 : 0);
projectFile.Append(chunkProjectInfo.ToBuffer());
GR.IO.FileChunk chunkCharset = new GR.IO.FileChunk(Types.FileChunk.MAP_CHARSET);
chunkCharset.Append(Charset.SaveToBuffer());
projectFile.Append(chunkCharset.ToBuffer());
GR.IO.FileChunk chunkProjectData = new GR.IO.FileChunk(Types.FileChunk.MAP_PROJECT_DATA);
GR.IO.FileChunk chunkMCData = new GR.IO.FileChunk(Types.FileChunk.MULTICOLOR_DATA);
chunkMCData.AppendU8((byte)Mode);
chunkMCData.AppendU8((byte)BackgroundColor);
chunkMCData.AppendU8((byte)MultiColor1);
chunkMCData.AppendU8((byte)MultiColor2);
chunkMCData.AppendU8((byte)BGColor4);
chunkProjectData.Append(chunkMCData.ToBuffer());
foreach (Tile tile in Tiles)
{
GR.IO.FileChunk chunkTile = new GR.IO.FileChunk(Types.FileChunk.MAP_TILE);
chunkTile.AppendString(tile.Name);
chunkTile.AppendI32(tile.Chars.Width);
chunkTile.AppendI32(tile.Chars.Height);
for (int j = 0; j < tile.Chars.Height; ++j)
{
for (int i = 0; i < tile.Chars.Width; ++i)
{
TileChar tChar = tile.Chars[i, j];
chunkTile.AppendU8(tChar.Character);
chunkTile.AppendU8(tChar.Color);
}
}
chunkProjectData.Append(chunkTile.ToBuffer());
}
foreach (Map map in Maps)
{
GR.IO.FileChunk chunkMap = new GR.IO.FileChunk(Types.FileChunk.MAP);
GR.IO.FileChunk chunkMapInfo = new GR.IO.FileChunk(Types.FileChunk.MAP_INFO);
chunkMapInfo.AppendString(map.Name);
chunkMapInfo.AppendI32(map.TileSpacingX);
chunkMapInfo.AppendI32(map.TileSpacingY);
chunkMapInfo.AppendI32(map.AlternativeMultiColor1 + 1);
chunkMapInfo.AppendI32(map.AlternativeMultiColor2 + 1);
chunkMapInfo.AppendI32(map.AlternativeBackgroundColor + 1);
chunkMapInfo.AppendI32(map.AlternativeBGColor4 + 1);
chunkMapInfo.AppendI32((int)map.AlternativeMode + 1);
chunkMap.Append(chunkMapInfo.ToBuffer());
GR.IO.FileChunk chunkMapData = new GR.IO.FileChunk(Types.FileChunk.MAP_DATA);
chunkMapData.AppendI32(map.Tiles.Width);
chunkMapData.AppendI32(map.Tiles.Height);
for (int j = 0; j < map.Tiles.Height; ++j)
{
for (int i = 0; i < map.Tiles.Width; ++i)
{
chunkMapData.AppendI32(map.Tiles[i, j]);
}
}
chunkMap.Append(chunkMapData.ToBuffer());
if (map.ExtraDataText.Length > 0)
{
GR.IO.FileChunk chunkMapExtraData = new GR.IO.FileChunk(Types.FileChunk.MAP_EXTRA_DATA_TEXT);
chunkMapExtraData.AppendString(map.ExtraDataText);
chunkMap.Append(chunkMapExtraData.ToBuffer());
}
if (map.ExtraDataOld.Length > 0)
{
GR.IO.FileChunk chunkMapExtraData = new GR.IO.FileChunk(Types.FileChunk.MAP_EXTRA_DATA);
chunkMapExtraData.AppendU32(map.ExtraDataOld.Length);
chunkMapExtraData.Append(map.ExtraDataOld);
chunkMap.Append(chunkMapExtraData.ToBuffer());
}
chunkProjectData.Append(chunkMap.ToBuffer());
}
projectFile.Append(chunkProjectData.ToBuffer());
return(projectFile);
}
GR.Memory.ByteBuffer ElementToBuffer(ProjectElement Element)
{
GR.Memory.ByteBuffer buffer = new GR.Memory.ByteBuffer();
GR.IO.FileChunk chunkElement = new GR.IO.FileChunk(Types.FileChunk.PROJECT_ELEMENT);
chunkElement.AppendU32(1);
chunkElement.AppendU32((uint)Element.DocumentInfo.Type);
chunkElement.AppendString(Element.Name);
chunkElement.AppendString(Element.Filename);
GR.IO.FileChunk chunkElementData = new GR.IO.FileChunk(Types.FileChunk.PROJECT_ELEMENT_DATA);
if (Element.Document != null)
{
Element.Document.SaveToChunk(chunkElementData);
}
chunkElement.Append(chunkElementData.ToBuffer());
chunkElement.AppendString(Element.TargetFilename);
chunkElement.AppendU32((uint)Element.TargetType);
chunkElement.AppendI32(Element.ForcedDependency.DependentOnFile.Count);
foreach (var dependency in Element.ForcedDependency.DependentOnFile)
{
chunkElement.AppendString(dependency.Filename);
}
// 3 free strings
chunkElement.AppendString("");
chunkElement.AppendString("");
chunkElement.AppendString("");
chunkElement.AppendI32(Element.Settings.Count);
foreach (KeyValuePair <string, ProjectElement.PerConfigSettings> configSetting in Element.Settings)
{
GR.IO.FileChunk chunkElementPerConfigSetting = new GR.IO.FileChunk(Types.FileChunk.PROJECT_ELEMENT_PER_CONFIG_SETTING);
chunkElementPerConfigSetting.AppendString(configSetting.Key);
chunkElementPerConfigSetting.AppendString(configSetting.Value.PreBuild);
chunkElementPerConfigSetting.AppendString(configSetting.Value.CustomBuild);
chunkElementPerConfigSetting.AppendString(configSetting.Value.PostBuild);
chunkElementPerConfigSetting.AppendString(configSetting.Value.DebugFile);
chunkElementPerConfigSetting.AppendI32((int)configSetting.Value.DebugFileType);
chunkElementPerConfigSetting.AppendI32(configSetting.Value.PreBuildChain.Active ? 1 : 0);
chunkElementPerConfigSetting.AppendI32(configSetting.Value.PreBuildChain.Entries.Count);
foreach (var buildChainEntry in configSetting.Value.PreBuildChain.Entries)
{
chunkElementPerConfigSetting.AppendString(buildChainEntry.ProjectName);
chunkElementPerConfigSetting.AppendString(buildChainEntry.Config);
chunkElementPerConfigSetting.AppendString(buildChainEntry.DocumentFilename);
chunkElementPerConfigSetting.AppendString(buildChainEntry.PreDefines);
}
chunkElementPerConfigSetting.AppendI32(configSetting.Value.PostBuildChain.Active ? 1 : 0);
chunkElementPerConfigSetting.AppendI32(configSetting.Value.PostBuildChain.Entries.Count);
foreach (var buildChainEntry in configSetting.Value.PostBuildChain.Entries)
{
chunkElementPerConfigSetting.AppendString(buildChainEntry.ProjectName);
chunkElementPerConfigSetting.AppendString(buildChainEntry.Config);
chunkElementPerConfigSetting.AppendString(buildChainEntry.DocumentFilename);
chunkElementPerConfigSetting.AppendString(buildChainEntry.PreDefines);
}
chunkElement.Append(chunkElementPerConfigSetting.ToBuffer());
}
chunkElement.AppendI32(Element.IsShown ? 1 : 0);
chunkElement.AppendU32((uint)Element.AssemblerType);
chunkElement.AppendI32(Element.ProjectHierarchy.Count);
foreach (string hierarchyPart in Element.ProjectHierarchy)
{
chunkElement.AppendString(hierarchyPart);
}
// dependency - include symbols
chunkElement.AppendI32(Element.ForcedDependency.DependentOnFile.Count);
foreach (var dependency in Element.ForcedDependency.DependentOnFile)
{
chunkElement.AppendI32(dependency.IncludeSymbols ? 1 : 0);
}
// collapsed folding blocks
chunkElement.AppendI32(Element.DocumentInfo.CollapsedFoldingBlocks.Count);
foreach (int foldStartLine in Element.DocumentInfo.CollapsedFoldingBlocks)
{
chunkElement.AppendI32(foldStartLine);
//Debug.Log( "Save folded block for line " + foldStartLine );
}
buffer.Append(chunkElement.ToBuffer());
if (Element.Document != null)
{
GR.Memory.ByteBuffer displayDetails = Element.Document.DisplayDetails();
if (displayDetails != null)
{
GR.IO.FileChunk chunkElementDisplayData = new GR.IO.FileChunk(Types.FileChunk.PROJECT_ELEMENT_DISPLAY_DATA);
chunkElementDisplayData.AppendString(Element.Filename);
chunkElementDisplayData.AppendU32(displayDetails.Length);
chunkElementDisplayData.Append(displayDetails);
buffer.Append(chunkElementDisplayData.ToBuffer());
}
}
// child elements
foreach (System.Windows.Forms.TreeNode node in Element.Node.Nodes)
{
ProjectElement subElement = (ProjectElement)node.Tag;
buffer.Append(ElementToBuffer(subElement));
}
return(buffer);
}
public GR.Memory.ByteBuffer SaveToBuffer()
{
GR.Memory.ByteBuffer projectFile = new GR.Memory.ByteBuffer();
// version
projectFile.AppendU32(1);
projectFile.AppendI32(Sprites.Count);
// Name
projectFile.AppendString(Name);
for (int i = 0; i < Sprites.Count; ++i)
{
projectFile.AppendI32(Sprites[i].Color);
}
for (int i = 0; i < Sprites.Count; ++i)
{
projectFile.AppendU8(Sprites[i].Multicolor ? (byte)1 : (byte)0);
}
projectFile.AppendI32(BackgroundColor);
projectFile.AppendI32(MultiColor1);
projectFile.AppendI32(MultiColor2);
// generic MC
projectFile.AppendU32(0);
for (int i = 0; i < Sprites.Count; ++i)
{
projectFile.Append(Sprites[i].Data);
projectFile.AppendU8((byte)Sprites[i].Color);
}
projectFile.AppendU32(UsedSprites);
// export name
projectFile.AppendString(ExportFilename);
// exportpath
projectFile.AppendString("");
// desc
for (int i = 0; i < Sprites.Count; ++i)
{
projectFile.AppendString("");
}
// testbed (not used anymore, write 0 as number of sprites)
projectFile.AppendI32(0);
foreach (var layer in SpriteLayers)
{
GR.IO.FileChunk chunkLayer = new GR.IO.FileChunk(Types.FileChunk.SPRITESET_LAYER);
GR.IO.FileChunk chunkLayerInfo = new GR.IO.FileChunk(Types.FileChunk.SPRITESET_LAYER_INFO);
chunkLayerInfo.AppendString(layer.Name);
chunkLayerInfo.AppendU8((byte)layer.BackgroundColor);
chunkLayer.Append(chunkLayerInfo.ToBuffer());
foreach (var sprite in layer.Sprites)
{
GR.IO.FileChunk chunkLayerSprite = new GR.IO.FileChunk(Types.FileChunk.SPRITESET_LAYER_ENTRY);
chunkLayerSprite.AppendI32(sprite.Index);
chunkLayerSprite.AppendU8((byte)sprite.Color);
chunkLayerSprite.AppendI32(sprite.X);
chunkLayerSprite.AppendI32(sprite.Y);
chunkLayerSprite.AppendU8((byte)(sprite.ExpandX ? 1 : 0));
chunkLayerSprite.AppendU8((byte)(sprite.ExpandY ? 1 : 0));
chunkLayer.Append(chunkLayerSprite.ToBuffer());
}
projectFile.Append(chunkLayer.ToBuffer());
}
/*
* int spriteTestCount = memIn.ReadInt32();
* for ( int i = 0; i < spriteTestCount; ++i )
* {
* int spriteIndex = memIn.ReadInt32();
* byte spriteColor = memIn.ReadUInt8();
* bool spriteMultiColor = ( memIn.ReadUInt8() != 0 );
* int spriteX = memIn.ReadInt32();
* int spriteY = memIn.ReadInt32();
* }*/
return(projectFile);
}
public GR.Memory.ByteBuffer SaveToBuffer()
{
GR.Memory.ByteBuffer projectFile = new GR.Memory.ByteBuffer();
GR.IO.FileChunk chunkScreenInfo = new GR.IO.FileChunk(FileChunkConstants.CHARSET_SCREEN_INFO);
// version
chunkScreenInfo.AppendI32(0);
// width
chunkScreenInfo.AppendI32(ScreenWidth);
// height
chunkScreenInfo.AppendI32(ScreenHeight);
chunkScreenInfo.AppendString("");
chunkScreenInfo.AppendI32((int)Mode);
chunkScreenInfo.AppendI32(ScreenOffsetX);
chunkScreenInfo.AppendI32(ScreenOffsetY);
chunkScreenInfo.AppendI32(CharOffset);
projectFile.Append(chunkScreenInfo.ToBuffer());
GR.IO.FileChunk chunkCharSet = new GR.IO.FileChunk(FileChunkConstants.CHARSET_DATA);
chunkCharSet.Append(CharSet.SaveToBuffer());
projectFile.Append(chunkCharSet.ToBuffer());
GR.IO.FileChunk chunkScreenMultiColorData = new GR.IO.FileChunk(FileChunkConstants.MULTICOLOR_DATA);
chunkScreenMultiColorData.AppendU8((byte)Mode);
chunkScreenMultiColorData.AppendU8((byte)CharSet.Colors.BackgroundColor);
chunkScreenMultiColorData.AppendU8((byte)CharSet.Colors.MultiColor1);
chunkScreenMultiColorData.AppendU8((byte)CharSet.Colors.MultiColor2);
projectFile.Append(chunkScreenMultiColorData.ToBuffer());
GR.IO.FileChunk chunkScreenCharData = new GR.IO.FileChunk(FileChunkConstants.SCREEN_CHAR_DATA);
if (Lookup.NumBytesOfSingleCharacter(Lookup.TextCharModeFromTextMode(Mode)) == 2)
{
for (int i = 0; i < Chars.Count; ++i)
{
chunkScreenCharData.AppendU16((ushort)(Chars[i] & 0xffff));
}
}
else
{
for (int i = 0; i < Chars.Count; ++i)
{
chunkScreenCharData.AppendU8((byte)(Chars[i] & 0xffff));
}
}
projectFile.Append(chunkScreenCharData.ToBuffer());
GR.IO.FileChunk chunkScreenColorData = new GR.IO.FileChunk(FileChunkConstants.SCREEN_COLOR_DATA);
if (Lookup.NumBytesOfSingleCharacter(Lookup.TextCharModeFromTextMode(Mode)) == 2)
{
for (int i = 0; i < Chars.Count; ++i)
{
chunkScreenColorData.AppendU16((ushort)(Chars[i] >> 16));
}
}
else
{
for (int i = 0; i < Chars.Count; ++i)
{
chunkScreenColorData.AppendU8((byte)(Chars[i] >> 16));
}
}
projectFile.Append(chunkScreenColorData.ToBuffer());
return(projectFile);
}
public GR.Memory.ByteBuffer ToBuffer()
{
GR.Memory.ByteBuffer SettingsData = new GR.Memory.ByteBuffer();
foreach (ToolInfo tool in ToolInfos)
{
GR.IO.FileChunk chunkTool = tool.ToChunk();
SettingsData.Append(chunkTool.ToBuffer());
}
/*
* foreach ( C64Studio.LayoutInfo layout in ToolLayout.Values )
* {
* layout.StoreLayout();
* SettingsData.Append( layout.ToBuffer() );
* }*/
foreach (AcceleratorKey key in Accelerators.Values)
{
GR.IO.FileChunk chunkKey = key.ToChunk();
SettingsData.Append(chunkKey.ToBuffer());
}
GR.IO.FileChunk chunkSoundSettings = new GR.IO.FileChunk(Types.FileChunk.SETTINGS_SOUND);
chunkSoundSettings.AppendU8((byte)(PlaySoundOnSuccessfulBuild ? 1 : 0));
chunkSoundSettings.AppendU8((byte)(PlaySoundOnBuildFailure ? 1 : 0));
chunkSoundSettings.AppendU8((byte)(PlaySoundOnSearchFoundNoItem ? 1 : 0));
SettingsData.Append(chunkSoundSettings.ToBuffer());
GR.IO.FileChunk chunkMainWindowPlacement = new GR.IO.FileChunk(Types.FileChunk.SETTINGS_WINDOW);
chunkMainWindowPlacement.AppendString(MainWindowPlacement);
SettingsData.Append(chunkMainWindowPlacement.ToBuffer());
GR.IO.FileChunk chunkTabs = new GR.IO.FileChunk(Types.FileChunk.SETTINGS_TABS);
chunkTabs.AppendI32(TabSize);
chunkTabs.AppendU8((byte)(AllowTabs ? 1 : 0));
chunkTabs.AppendU8((byte)(TabConvertToSpaces ? 1 : 0));
SettingsData.Append(chunkTabs.ToBuffer());
GR.IO.FileChunk chunkFont = new GR.IO.FileChunk(Types.FileChunk.SETTINGS_FONT);
chunkFont.AppendString(SourceFontFamily);
chunkFont.AppendI32((int)SourceFontSize);
chunkFont.AppendU8((byte)(BASICUseNonC64Font ? 1 : 0));
chunkFont.AppendString(BASICSourceFontFamily);
chunkFont.AppendI32((int)BASICSourceFontSize);
SettingsData.Append(chunkFont.ToBuffer());
foreach (Types.SyntaxElement element in SyntaxColoring.Keys)
{
GR.IO.FileChunk chunkSyntaxColor = new GR.IO.FileChunk(Types.FileChunk.SETTINGS_SYNTAX_COLORING);
chunkSyntaxColor.AppendU32((uint)element);
chunkSyntaxColor.AppendU32(SyntaxColoring[element].FGColor);
chunkSyntaxColor.AppendU32(SyntaxColoring[element].BGColor);
chunkSyntaxColor.AppendI32(SyntaxColoring[element].BGColorAuto ? 1 : 0);
SettingsData.Append(chunkSyntaxColor.ToBuffer());
}
GR.IO.FileChunk chunkUI = new GR.IO.FileChunk(Types.FileChunk.SETTINGS_UI);
chunkUI.AppendU8((byte)(ToolbarActiveMain ? 1 : 0));
chunkUI.AppendU8((byte)(ToolbarActiveDebugger ? 1 : 0));
SettingsData.Append(chunkUI.ToBuffer());
GR.IO.FileChunk chunkRunEmu = new GR.IO.FileChunk(Types.FileChunk.SETTINGS_RUN_EMULATOR);
chunkRunEmu.AppendU8((byte)(TrueDriveEnabled ? 1 : 0));
SettingsData.Append(chunkRunEmu.ToBuffer());
GR.IO.FileChunk chunkDefaults = new GR.IO.FileChunk(Types.FileChunk.SETTINGS_DEFAULTS);
chunkDefaults.AppendString(DefaultProjectBasePath);
SettingsData.Append(chunkDefaults.ToBuffer());
// dockpanel layout
GR.IO.FileChunk chunkLayout = new GR.IO.FileChunk(Types.FileChunk.SETTINGS_DPS_LAYOUT);
System.IO.MemoryStream memOut = new System.IO.MemoryStream();
PanelMain.SaveAsXml(memOut, Encoding.UTF8);
byte[] layoutData = memOut.ToArray();
string xmlOutText = System.Text.Encoding.UTF8.GetString(layoutData);
// remove dummy elements (layout of non-tool windows)
GR.Strings.XMLParser parser = new GR.Strings.XMLParser();
if (!parser.Parse(xmlOutText))
{
Debug.Log("Could not parse XML");
}
else
{
EnumElements(parser);
xmlOutText = parser.ToText();
}
//Debug.Log( xmlOutText );
chunkLayout.AppendU32((uint)layoutData.Length);
chunkLayout.Append(layoutData);
SettingsData.Append(chunkLayout.ToBuffer());
memOut.Close();
memOut.Dispose();
GR.IO.FileChunk chunkFindReplace = new GR.IO.FileChunk(Types.FileChunk.SETTINGS_FIND_REPLACE);
chunkFindReplace.AppendU8((byte)(LastFindIgnoreCase ? 1 : 0));
chunkFindReplace.AppendU8((byte)(LastFindWholeWord ? 1 : 0));
chunkFindReplace.AppendU8((byte)(LastFindRegexp ? 1 : 0));
chunkFindReplace.AppendU8((byte)(LastFindWrap ? 1 : 0));
chunkFindReplace.AppendU8((byte)LastFindTarget);
chunkFindReplace.AppendI32(FindArguments.Count);
foreach (var findArg in FindArguments)
{
chunkFindReplace.AppendString(findArg);
}
chunkFindReplace.AppendI32(ReplaceArguments.Count);
foreach (var replaceArg in ReplaceArguments)
{
chunkFindReplace.AppendString(replaceArg);
}
SettingsData.Append(chunkFindReplace.ToBuffer());
GR.IO.FileChunk chunkIgnoredWarnings = new GR.IO.FileChunk(Types.FileChunk.SETTINGS_IGNORED_WARNINGS);
chunkIgnoredWarnings.AppendI32(IgnoredWarnings.Count);
foreach (Types.ErrorCode ignoredWarning in IgnoredWarnings)
{
chunkIgnoredWarnings.AppendI32((int)ignoredWarning);
}
SettingsData.Append(chunkIgnoredWarnings.ToBuffer());
foreach (var pair in GenericTools)
{
GR.Memory.ByteBuffer data = pair.Value.DisplayDetails();
if (data != null)
{
GR.IO.FileChunk chunkPanelDisplayDetails = new GR.IO.FileChunk(Types.FileChunk.SETTINGS_PANEL_DISPLAY_DETAILS);
chunkPanelDisplayDetails.AppendString(pair.Key);
chunkPanelDisplayDetails.AppendU32(data.Length);
chunkPanelDisplayDetails.Append(data);
SettingsData.Append(chunkPanelDisplayDetails.ToBuffer());
}
}
// ASM editor settings
GR.IO.FileChunk chunkASMEditor = new GR.IO.FileChunk(Types.FileChunk.SETTINGS_ASSEMBLER_EDITOR);
chunkASMEditor.AppendU8((byte)(ASMHideLineNumbers ? 1 : 0));
SettingsData.Append(chunkASMEditor.ToBuffer());
// BASIC settings
GR.IO.FileChunk chunkBASICParser = new GR.IO.FileChunk(Types.FileChunk.SETTINGS_BASIC_PARSER);
chunkBASICParser.AppendU8((byte)(BASICStripSpaces ? 1 : 0));
SettingsData.Append(chunkBASICParser.ToBuffer());
// BASIC key map
GR.IO.FileChunk chunkBASICKeyMap = new GR.IO.FileChunk(Types.FileChunk.SETTINGS_BASIC_KEYMAP);
chunkBASICKeyMap.AppendI32(BASICKeyMap.Keymap.Count);
foreach (var entry in BASICKeyMap.Keymap)
{
chunkBASICKeyMap.AppendU32((uint)entry.Key);
chunkBASICKeyMap.AppendI32((int)entry.Value.KeyboardKey);
}
SettingsData.Append(chunkBASICKeyMap.ToBuffer());
// environment behaviour settings
GR.IO.FileChunk chunkEnvironment = new GR.IO.FileChunk(Types.FileChunk.SETTINGS_ENVIRONMENT);
chunkEnvironment.AppendU8((byte)(AutoOpenLastSolution ? 1 : 0));
SettingsData.Append(chunkEnvironment.ToBuffer());
return(SettingsData);
}
public GR.Memory.ByteBuffer SaveToBuffer()
{
GR.Memory.ByteBuffer projectFile = new GR.Memory.ByteBuffer();
projectFile.AppendU32(2);
var chunkProject = new GR.IO.FileChunk(FileChunkConstants.SPRITESET_PROJECT);
var chunkInfo = new GR.IO.FileChunk(FileChunkConstants.SPRITESET_INFO);
chunkInfo.AppendI32(TotalNumberOfSprites);
chunkInfo.AppendString(Name);
chunkInfo.AppendString(ExportFilename);
chunkInfo.AppendI32(ExportStartIndex);
chunkInfo.AppendI32(ExportSpriteCount);
chunkProject.Append(chunkInfo.ToBuffer());
GR.IO.FileChunk chunkScreenMultiColorData = new GR.IO.FileChunk(FileChunkConstants.MULTICOLOR_DATA);
chunkScreenMultiColorData.AppendI32((byte)Mode);
chunkScreenMultiColorData.AppendI32((byte)Colors.BackgroundColor);
chunkScreenMultiColorData.AppendI32((byte)Colors.MultiColor1);
chunkScreenMultiColorData.AppendI32((byte)Colors.MultiColor2);
chunkProject.Append(chunkScreenMultiColorData.ToBuffer());
foreach (var pal in Colors.Palettes)
{
chunkProject.Append(pal.ToBuffer());
}
foreach (var sprite in Sprites)
{
GR.IO.FileChunk chunkSprite = new GR.IO.FileChunk(FileChunkConstants.SPRITESET_SPRITE);
chunkSprite.AppendI32((int)sprite.Mode);
chunkSprite.AppendI32((int)sprite.Tile.Mode);
chunkSprite.AppendI32((int)sprite.Tile.CustomColor);
chunkSprite.AppendI32(sprite.Tile.Width);
chunkSprite.AppendI32(sprite.Tile.Height);
chunkSprite.AppendI32((int)sprite.Tile.Data.Length);
chunkSprite.Append(sprite.Tile.Data);
chunkSprite.AppendI32(sprite.Tile.Colors.ActivePalette);
chunkProject.Append(chunkSprite.ToBuffer());
}
foreach (var layer in SpriteLayers)
{
GR.IO.FileChunk chunkLayer = new GR.IO.FileChunk(FileChunkConstants.SPRITESET_LAYER);
GR.IO.FileChunk chunkLayerInfo = new GR.IO.FileChunk(FileChunkConstants.SPRITESET_LAYER_INFO);
chunkLayerInfo.AppendString(layer.Name);
chunkLayerInfo.AppendI32((byte)layer.BackgroundColor);
chunkLayerInfo.AppendI32(layer.DelayMS);
chunkLayer.Append(chunkLayerInfo.ToBuffer());
foreach (var sprite in layer.Sprites)
{
GR.IO.FileChunk chunkLayerSprite = new GR.IO.FileChunk(FileChunkConstants.SPRITESET_LAYER_ENTRY);
chunkLayerSprite.AppendI32(sprite.Index);
chunkLayerSprite.AppendI32((byte)sprite.Color);
chunkLayerSprite.AppendI32(sprite.X);
chunkLayerSprite.AppendI32(sprite.Y);
chunkLayerSprite.AppendI32((byte)(sprite.ExpandX ? 1 : 0));
chunkLayerSprite.AppendI32((byte)(sprite.ExpandY ? 1 : 0));
chunkLayer.Append(chunkLayerSprite.ToBuffer());
}
chunkProject.Append(chunkLayer.ToBuffer());
}
projectFile.Append(chunkProject.ToBuffer());
/*
* // version
* projectFile.AppendU32( 1 );
* projectFile.AppendI32( Sprites.Count );
* // Name
* projectFile.AppendString( Name );
* for ( int i = 0; i < Sprites.Count; ++i )
* {
* projectFile.AppendI32( Sprites[i].Color );
* }
* for ( int i = 0; i < Sprites.Count; ++i )
* {
* projectFile.AppendU8( (byte)Sprites[i].Mode );
* }
* projectFile.AppendI32( Colors.BackgroundColor );
* projectFile.AppendI32( Colors.MultiColor1 );
* projectFile.AppendI32( Colors.MultiColor2 );
* // generic MC
* projectFile.AppendU32( 0 );
* for ( int i = 0; i < Sprites.Count; ++i )
* {
* projectFile.Append( Sprites[i].Tile.Data );
* projectFile.AppendU8( (byte)Sprites[i].Color );
* }
* projectFile.AppendU32( ExportSpriteCount );
*
* // export name
* projectFile.AppendString( ExportFilename );
*
* // exportpath
* projectFile.AppendString( "" );
*
* // desc
* for ( int i = 0; i < Sprites.Count; ++i )
* {
* projectFile.AppendString( "" );
* }
*
* // testbed (not used anymore, write 0 as number of sprites)
* projectFile.AppendI32( 0 );
*
*
* foreach ( var layer in SpriteLayers )
* {
* GR.IO.FileChunk chunkLayer = new GR.IO.FileChunk( FileChunkConstants.SPRITESET_LAYER );
*
* GR.IO.FileChunk chunkLayerInfo = new GR.IO.FileChunk( FileChunkConstants.SPRITESET_LAYER_INFO );
* chunkLayerInfo.AppendString( layer.Name );
* chunkLayerInfo.AppendU8( (byte)layer.BackgroundColor );
* chunkLayerInfo.AppendI32( layer.DelayMS );
* chunkLayer.Append( chunkLayerInfo.ToBuffer() );
*
* foreach ( var sprite in layer.Sprites )
* {
* GR.IO.FileChunk chunkLayerSprite = new GR.IO.FileChunk( FileChunkConstants.SPRITESET_LAYER_ENTRY );
* chunkLayerSprite.AppendI32( sprite.Index );
* chunkLayerSprite.AppendU8( (byte)sprite.Color );
* chunkLayerSprite.AppendI32( sprite.X );
* chunkLayerSprite.AppendI32( sprite.Y );
* chunkLayerSprite.AppendU8( (byte)( sprite.ExpandX ? 1 : 0 ) );
* chunkLayerSprite.AppendU8( (byte)( sprite.ExpandY ? 1 : 0 ) );
*
* chunkLayer.Append( chunkLayerSprite.ToBuffer() );
* }
* projectFile.Append( chunkLayer.ToBuffer() );
* }*/
return(projectFile);
}
public bool SaveToFile(string Filename)
{
GR.Memory.ByteBuffer resultingFile = new GR.Memory.ByteBuffer();
GR.IO.FileChunk chunkGeneral = new GR.IO.FileChunk((ushort)ChunkType.GENERAL);
chunkGeneral.AppendString(OldCharsetProjectFilename);
chunkGeneral.AppendString(ExportFilename);
chunkGeneral.AppendString(ExportPrefix);
chunkGeneral.AppendI32(ExportConstantOffset);
chunkGeneral.AppendString(SpriteProjectFilename);
chunkGeneral.AppendString(ProjectType);
chunkGeneral.AppendU8(EmptyChar);
chunkGeneral.AppendU8(EmptyColor);
resultingFile.Append(chunkGeneral.ToBuffer());
int charSetIndex = 0;
foreach (Types.CharsetProjectInfo info in CharsetProjects)
{
GR.IO.FileChunk chunkCharset = new GR.IO.FileChunk((ushort)ChunkType.CHARSET_INFO);
chunkCharset.AppendString(info.Filename);
chunkCharset.AppendU8((byte)(info.Multicolor ? 1 : 0));
resultingFile.Append(chunkCharset.ToBuffer());
++charSetIndex;
}
foreach (Element element in Elements)
{
GR.IO.FileChunk chunkElement = new GR.IO.FileChunk((ushort)ChunkType.ELEMENT);
chunkElement.AppendString(element.Name);
chunkElement.AppendI32(element.Index);
chunkElement.AppendI32(element.Characters.Width);
chunkElement.AppendI32(element.Characters.Height);
for (int i = 0; i < element.Characters.Width; ++i)
{
for (int j = 0; j < element.Characters.Height; ++j)
{
chunkElement.AppendU8(element.Characters[i, j].Char);
chunkElement.AppendU8(element.Characters[i, j].Color);
}
}
chunkElement.AppendI32(element.CharsetIndex);
resultingFile.Append(chunkElement.ToBuffer());
}
foreach (ObjectTemplate obj in ObjectTemplates)
{
GR.IO.FileChunk chunkObj = new GR.IO.FileChunk((ushort)ChunkType.OBJECT_TEMPLATE);
chunkObj.AppendString(obj.Name);
chunkObj.AppendI32(obj.StartSprite);
chunkObj.AppendI32(obj.Behaviours.Count);
foreach (KeyValuePair <int, Behaviour> behaviourPair in obj.Behaviours)
{
chunkObj.AppendI32(behaviourPair.Value.Value);
chunkObj.AppendString(behaviourPair.Value.Name);
}
resultingFile.Append(chunkObj.ToBuffer());
}
foreach (Screen screen in Screens)
{
GR.IO.FileChunk chunkScreen = new GR.IO.FileChunk((ushort)ChunkType.SCREEN);
GR.IO.FileChunk chunkScreenInfo = new GR.IO.FileChunk((ushort)ChunkType.SCREEN_INFO);
chunkScreenInfo.AppendString(screen.Name);
chunkScreenInfo.AppendI32(screen.Width);
chunkScreenInfo.AppendI32(screen.Height);
chunkScreenInfo.AppendU8(screen.ConfigByte);
chunkScreenInfo.AppendI32(screen.CharsetIndex);
chunkScreenInfo.AppendU8(screen.WLConfigByte);
chunkScreenInfo.AppendString(screen.ExtraData);
chunkScreenInfo.AppendI32(screen.OverrideMC1 + 1);
chunkScreenInfo.AppendI32(screen.OverrideMC2 + 1);
chunkScreen.Append(chunkScreenInfo.ToBuffer());
foreach (ScreenElement element in screen.DisplayedElements)
{
GR.IO.FileChunk chunkScreenElement = new GR.IO.FileChunk((ushort)ChunkType.SCREEN_ELEMENT);
chunkScreenElement.AppendI32((int)element.Type);
chunkScreenElement.AppendI32(element.Index);
chunkScreenElement.AppendI32(element.X);
chunkScreenElement.AppendI32(element.Y);
chunkScreenElement.AppendI32(element.Repeats);
chunkScreenElement.AppendI32(element.Repeats2);
chunkScreenElement.AppendI32(element.Char);
chunkScreenElement.AppendI32(element.Color);
chunkScreenElement.AppendI32(element.SearchObjectIndex);
chunkScreenElement.AppendI32(element.TargetX);
chunkScreenElement.AppendI32(element.TargetY);
chunkScreenElement.AppendI32(element.TargetLevel);
chunkScreenElement.AppendI32(element.Flags);
chunkScreen.Append(chunkScreenElement.ToBuffer());
}
// save extra object data
int screenElementIndex = 0;
foreach (ScreenElement element in screen.DisplayedElements)
{
if (element.Type == ScreenElementType.LD_OBJECT)
{
GR.IO.FileChunk chunkObject = new GR.IO.FileChunk((ushort)ChunkType.ELEMENT_OBJECT_DATA);
chunkObject.AppendI32(screenElementIndex);
chunkObject.AppendI32(element.Object.TemplateIndex);
chunkObject.AppendI32(element.Object.X);
chunkObject.AppendI32(element.Object.Y);
chunkObject.AppendI32(element.Object.Color);
chunkObject.AppendI32(element.Object.Speed);
chunkObject.AppendI32(element.Object.Behaviour);
chunkObject.AppendI32(element.Object.MoveBorderLeft);
chunkObject.AppendI32(element.Object.MoveBorderTop);
chunkObject.AppendI32(element.Object.MoveBorderRight);
chunkObject.AppendI32(element.Object.MoveBorderBottom);
chunkObject.AppendI32(element.Object.Data);
chunkObject.AppendI32(element.Object.OptionalValue);
chunkObject.AppendI32((int)element.Object.Optional);
chunkScreen.Append(chunkObject.ToBuffer());
}
else if (element.Type == ScreenElementType.LD_SPAWN_SPOT)
{
GR.IO.FileChunk chunkSpawnSpot = new GR.IO.FileChunk((ushort)ChunkType.ELEMENT_SPAWN_SPOT_DATA);
chunkSpawnSpot.AppendI32(screenElementIndex);
chunkSpawnSpot.AppendI32(element.Object.TemplateIndex);
chunkSpawnSpot.AppendI32(element.Object.X);
chunkSpawnSpot.AppendI32(element.Object.Y);
chunkSpawnSpot.AppendI32(element.Repeats);
chunkScreen.Append(chunkSpawnSpot.ToBuffer());
}
++screenElementIndex;
}
/*
* GR.IO.FileChunk chunkScreen = new GR.IO.FileChunk( (ushort)ChunkType.OLD_SCREEN );
*
* chunkScreen.AppendString( screen.Name );
* chunkScreen.AppendI32( screen.DisplayedElements.Count );
* foreach ( ScreenElement element in screen.DisplayedElements )
* {
* chunkScreen.AppendI32( (int)element.Type );
* chunkScreen.AppendI32( element.Index );
* chunkScreen.AppendI32( element.X );
* chunkScreen.AppendI32( element.Y );
* chunkScreen.AppendI32( element.Repeats );
* chunkScreen.AppendI32( element.Char );
* chunkScreen.AppendI32( element.Color );
* chunkScreen.AppendI32( element.SearchObjectIndex );
* }
* // save extra object data
* foreach ( ScreenElement element in screen.DisplayedElements )
* {
* if ( element.Type == ScreenElementType.LD_OBJECT )
* {
* GR.IO.FileChunk chunkObject = new GR.IO.FileChunk( (ushort)ChunkType.ELEMENT_OBJECT_DATA );
* chunkObject.AppendI32( element.Object.TemplateIndex );
* chunkObject.AppendI32( element.Object.X );
* chunkObject.AppendI32( element.Object.Y );
* chunkObject.AppendI32( element.Object.Color );
* chunkObject.AppendI32( element.Object.Speed );
* chunkObject.AppendI32( element.Object.Behaviour );
* chunkObject.AppendI32( element.Object.MoveBorderLeft );
* chunkObject.AppendI32( element.Object.MoveBorderTop );
* chunkObject.AppendI32( element.Object.MoveBorderRight );
* chunkObject.AppendI32( element.Object.MoveBorderBottom );
*
* chunkScreen.Append( chunkObject.ToBuffer() );
* }
* else if ( element.Type == ScreenElementType.LD_SPAWN_SPOT )
* {
* GR.IO.FileChunk chunkSpawnSpot = new GR.IO.FileChunk( (ushort)ChunkType.ELEMENT_SPAWN_SPOT_DATA );
* chunkSpawnSpot.AppendI32( element.Object.TemplateIndex );
* chunkSpawnSpot.AppendI32( element.Object.X );
* chunkSpawnSpot.AppendI32( element.Object.Y );
* chunkSpawnSpot.AppendI32( element.Repeats );
*
* chunkScreen.Append( chunkSpawnSpot.ToBuffer() );
* }
* }
* GR.IO.FileChunk chunkScreenInfo = new GR.IO.FileChunk( (ushort)ChunkType.OLD_SCREEN_MORE_DATA );
* chunkScreenInfo.AppendI32( screen.Width );
* chunkScreen.Append( chunkScreenInfo.ToBuffer() );
*/
resultingFile.Append(chunkScreen.ToBuffer());
}
foreach (Region region in Regions)
{
GR.IO.FileChunk chunkRegion = new GR.IO.FileChunk((ushort)ChunkType.MAP_REGION);
GR.IO.FileChunk chunkRegionInfo = new GR.IO.FileChunk((ushort)ChunkType.MAP_REGION_INFO);
chunkRegionInfo.AppendI32(region.DisplayX);
chunkRegionInfo.AppendI32(region.DisplayY);
chunkRegionInfo.AppendI32(region.Vertical ? 1 : 0);
chunkRegionInfo.AppendU32(region.ExtraData.Length);
chunkRegionInfo.Append(region.ExtraData);
chunkRegion.Append(chunkRegionInfo.ToBuffer());
foreach (RegionScreenInfo screenInfo in region.Screens)
{
GR.IO.FileChunk chunkRegionScreenInfo = new GR.IO.FileChunk((ushort)ChunkType.MAP_REGION_SCREEN);
chunkRegionScreenInfo.AppendI32(screenInfo.ScreenIndex);
chunkRegionScreenInfo.AppendI32(screenInfo.ExitN ? 1 : 0);
chunkRegionScreenInfo.AppendI32(screenInfo.ExitS ? 1 : 0);
chunkRegionScreenInfo.AppendI32(screenInfo.ExitW ? 1 : 0);
chunkRegionScreenInfo.AppendI32(screenInfo.ExitE ? 1 : 0);
chunkRegion.Append(chunkRegionScreenInfo.ToBuffer());
}
resultingFile.Append(chunkRegion.ToBuffer());
}
return(GR.IO.File.WriteAllBytes(Filename, resultingFile));
}
