public bool FromBuffer(GR.Memory.ByteBuffer SolutionData, string FromFile)
{
GR.IO.MemoryReader memIn = new GR.IO.MemoryReader(SolutionData);
GR.IO.FileChunk chunk = new GR.IO.FileChunk();
while (chunk.ReadFromStream(memIn))
{
if (chunk.Type != FileChunkConstants.SOLUTION)
{
return(false);
}
GR.IO.MemoryReader memChunk = chunk.MemoryReader();
GR.IO.FileChunk subChunk = new GR.IO.FileChunk();
while (subChunk.ReadFromStream(memChunk))
{
GR.IO.MemoryReader memSubChunk = subChunk.MemoryReader();
switch (subChunk.Type)
{
case FileChunkConstants.SOLUTION_INFO:
Name = memSubChunk.ReadString();
Filename = memSubChunk.ReadString();
ActiveProject = memSubChunk.ReadString();
Filename = FromFile;
Name = System.IO.Path.GetFileNameWithoutExtension(FromFile);
break;
case FileChunkConstants.SOLUTION_PROJECT:
{
string filename = memSubChunk.ReadString();
filename = GR.Path.Normalize(System.IO.Path.Combine(System.IO.Path.GetDirectoryName(Filename), filename), false);
Project project = MainForm.OpenProject(filename);
}
break;
case FileChunkConstants.SOLUTION_NODES:
while (memSubChunk.DataAvailable)
{
string node = memSubChunk.ReadString();
if (!ExpandedNodes.Contains(node))
{
ExpandedNodes.Add(node);
}
}
break;
}
}
}
return(true);
}
public bool FromBuffer(GR.Memory.ByteBuffer SolutionData, string FromFile)
{
GR.IO.MemoryReader memIn = new GR.IO.MemoryReader(SolutionData);
GR.IO.FileChunk chunk = new GR.IO.FileChunk();
while (chunk.ReadFromStream(memIn))
{
if (chunk.Type != Types.FileChunk.SOLUTION)
{
return(false);
}
GR.IO.MemoryReader memChunk = chunk.MemoryReader();
GR.IO.FileChunk subChunk = new GR.IO.FileChunk();
while (subChunk.ReadFromStream(memChunk))
{
GR.IO.MemoryReader memSubChunk = subChunk.MemoryReader();
switch (subChunk.Type)
{
case Types.FileChunk.SOLUTION_INFO:
Name = memSubChunk.ReadString();
Filename = memSubChunk.ReadString();
Filename = FromFile;
break;
case Types.FileChunk.SOLUTION_PROJECT:
{
string filename = memSubChunk.ReadString();
filename = GR.Path.Normalize(System.IO.Path.Combine(System.IO.Path.GetDirectoryName(Filename), filename), false);
Project project = MainForm.OpenProject(filename);
}
break;
}
}
}
return(true);
}
public bool ReadFromBuffer(GR.Memory.ByteBuffer DataIn)
{
if (DataIn == null)
{
return(false);
}
GR.IO.MemoryReader memIn = DataIn.MemoryReader();
uint version = memIn.ReadUInt32();
if (version == 1)
{
TotalNumberOfCharacters = 256;
string name = memIn.ReadString();
string charsetFilename = memIn.ReadString();
for (int i = 0; i < TotalNumberOfCharacters; ++i)
{
Characters[i].Tile.CustomColor = memIn.ReadInt32();
}
bool hasAnyMC = false;
for (int i = 0; i < TotalNumberOfCharacters; ++i)
{
var mode = (TextCharMode)memIn.ReadUInt8();
if ((mode == TextCharMode.COMMODORE_MULTICOLOR) &&
(Characters[i].Tile.CustomColor < 8))
{
mode = TextCharMode.COMMODORE_HIRES;
}
if (mode == TextCharMode.COMMODORE_MULTICOLOR)
{
hasAnyMC = true;
}
}
Colors.BackgroundColor = memIn.ReadInt32();
Colors.MultiColor1 = memIn.ReadInt32();
Colors.MultiColor2 = memIn.ReadInt32();
for (int i = 0; i < TotalNumberOfCharacters; ++i)
{
int tileColor1 = memIn.ReadInt32();
int tileColor2 = memIn.ReadInt32();
int tileColor3 = memIn.ReadInt32();
int tileColor4 = memIn.ReadInt32();
int tileChar1 = memIn.ReadInt32();
int tileChar2 = memIn.ReadInt32();
int tileChar3 = memIn.ReadInt32();
int tileChar4 = memIn.ReadInt32();
}
bool genericMulticolor = (memIn.ReadInt32() != 0);
GR.Memory.ByteBuffer testbed = new GR.Memory.ByteBuffer();
memIn.ReadBlock(testbed, 64);
GR.Memory.ByteBuffer charsetData = new GR.Memory.ByteBuffer();
memIn.ReadBlock(charsetData, (uint)(TotalNumberOfCharacters * 8));
for (int i = 0; i < TotalNumberOfCharacters; ++i)
{
Characters[i].Tile.Data = charsetData.SubBuffer(i * 8, 8);
}
UsedTiles = memIn.ReadUInt32();
ExportFilename = memIn.ReadString();
string exportPathBlockTable = memIn.ReadString();
string exportPathCharset = memIn.ReadString();
string exportPathEditorTiles = memIn.ReadString();
// categories
Categories.Clear();
int categoryCount = memIn.ReadInt32();
for (int i = 0; i < categoryCount; ++i)
{
int catKey = memIn.ReadInt32();
string catName = memIn.ReadString();
Categories.Add(catName);
}
if (Categories.Count == 0)
{
// add default category
Categories.Add("Uncategorized");
}
for (int i = 0; i < TotalNumberOfCharacters; ++i)
{
Characters[i].Category = memIn.ReadInt32();
if ((Characters[i].Category < 0) ||
(Characters[i].Category >= Categories.Count))
{
Characters[i].Category = 0;
}
}
ExportNumCharacters = memIn.ReadInt32();
if (ExportNumCharacters < TotalNumberOfCharacters)
{
ExportNumCharacters = TotalNumberOfCharacters;
}
ShowGrid = (memIn.ReadInt32() != 0);
ExportStartCharacter = memIn.ReadInt32();
Colors.BGColor4 = memIn.ReadInt32();
// playground
int w = memIn.ReadInt32();
int h = memIn.ReadInt32();
if (w * h < 256)
{
w = 16;
h = 16;
}
PlaygroundChars = new List <uint>(w * h);
for (int i = 0; i < w * h; ++i)
{
ushort charInfo = memIn.ReadUInt16();
PlaygroundChars.Add((uint)((charInfo & 0xff) | ((charInfo & 0xff00) << 8)));
}
Mode = (TextCharMode)memIn.ReadInt32();
if (hasAnyMC)
{
Mode = TextCharMode.COMMODORE_MULTICOLOR;
}
}
else if (version == 2)
{
Characters.Clear();
Categories.Clear();
Colors.Palettes.Clear();
TotalNumberOfCharacters = 256;
Mode = TextCharMode.COMMODORE_HIRES;
var chunk = new GR.IO.FileChunk();
while (chunk.ReadFromStream(memIn))
{
if (chunk.Type == FileChunkConstants.CHARSET_PROJECT)
{
var chunkIn = chunk.MemoryReader();
var subChunk = new GR.IO.FileChunk();
while (subChunk.ReadFromStream(chunkIn))
{
var subMemIn = subChunk.MemoryReader();
switch (subChunk.Type)
{
case FileChunkConstants.CHARSET_INFO:
Mode = (TextCharMode)subMemIn.ReadInt32();
TotalNumberOfCharacters = subMemIn.ReadInt32();
ShowGrid = ((subMemIn.ReadInt32() & 1) == 1);
break;
case FileChunkConstants.CHARSET_COLOR_SETTINGS:
Colors.BackgroundColor = subMemIn.ReadInt32();
Colors.MultiColor1 = subMemIn.ReadInt32();
Colors.MultiColor2 = subMemIn.ReadInt32();
Colors.BGColor4 = subMemIn.ReadInt32();
Colors.ActivePalette = subMemIn.ReadInt32();
break;
case FileChunkConstants.PALETTE:
Colors.Palettes.Add(Palette.Read(subMemIn));
break;
case FileChunkConstants.CHARSET_EXPORT:
ExportStartCharacter = subMemIn.ReadInt32();
ExportNumCharacters = subMemIn.ReadInt32();
ExportFilename = subMemIn.ReadString();
break;
case FileChunkConstants.CHARSET_CHAR:
{
var charData = new CharData();
subMemIn.ReadInt32(); // was TextCharMode
charData.Tile.CustomColor = subMemIn.ReadInt32();
charData.Tile.Mode = Lookup.GraphicTileModeFromTextCharMode(Mode, charData.Tile.CustomColor);
charData.Category = subMemIn.ReadInt32();
int dataLength = subMemIn.ReadInt32();
charData.Tile.Data = new GR.Memory.ByteBuffer();
subMemIn.ReadBlock(charData.Tile.Data, (uint)dataLength);
Characters.Add(charData);
}
break;
case FileChunkConstants.CHARSET_CATEGORY:
Categories.Add(subMemIn.ReadString());
break;
case FileChunkConstants.CHARSET_PLAYGROUND:
PlaygroundWidth = subMemIn.ReadInt32();
PlaygroundHeight = subMemIn.ReadInt32();
PlaygroundChars = new List <uint>(PlaygroundWidth * PlaygroundHeight);
for (int i = 0; i < PlaygroundWidth * PlaygroundHeight; ++i)
{
// 16 bit index, 16 bit color
PlaygroundChars.Add(subMemIn.ReadUInt32());
}
break;
}
}
}
}
if (Colors.Palettes.Count == 0)
{
Colors.Palettes.Add(PaletteManager.PaletteFromNumColors(Lookup.NumberOfColorsInCharacter(Mode)));
}
}
else
{
return(false);
}
return(true);
}
public bool ReadFromBuffer(GR.Memory.ByteBuffer ProjectFile)
{
if (ProjectFile == null)
{
return(false);
}
GR.IO.MemoryReader memReader = new GR.IO.MemoryReader(ProjectFile);
GR.IO.FileChunk chunk = new GR.IO.FileChunk();
string importedCharSet = "";
while (chunk.ReadFromStream(memReader))
{
GR.IO.MemoryReader chunkReader = chunk.MemoryReader();
switch (chunk.Type)
{
case Types.FileChunk.MAP_PROJECT_INFO:
{
uint version = chunkReader.ReadUInt32();
importedCharSet = chunkReader.ReadString();
ShowGrid = (chunkReader.ReadInt32() == 1);
}
break;
case Types.FileChunk.MAP_CHARSET:
{
GR.Memory.ByteBuffer data = new GR.Memory.ByteBuffer();
chunkReader.ReadBlock(data, (uint)(chunkReader.Size - chunkReader.Position));
Charset.ReadFromBuffer(data);
}
break;
case Types.FileChunk.MAP_PROJECT_DATA:
{
GR.IO.FileChunk chunkData = new GR.IO.FileChunk();
while (chunkData.ReadFromStream(chunkReader))
{
GR.IO.MemoryReader subChunkReader = chunkData.MemoryReader();
switch (chunkData.Type)
{
case Types.FileChunk.MULTICOLOR_DATA:
Mode = (Types.CharsetMode)subChunkReader.ReadUInt8();
BackgroundColor = subChunkReader.ReadUInt8();
MultiColor1 = subChunkReader.ReadUInt8();
MultiColor2 = subChunkReader.ReadUInt8();
BGColor4 = subChunkReader.ReadUInt8();
break;
case Types.FileChunk.MAP_TILE:
{
Tile tile = new Tile();
tile.Name = subChunkReader.ReadString();
int w = subChunkReader.ReadInt32();
int h = subChunkReader.ReadInt32();
tile.Chars.Resize(w, h);
for (int j = 0; j < tile.Chars.Height; ++j)
{
for (int i = 0; i < tile.Chars.Width; ++i)
{
tile.Chars[i, j].Character = subChunkReader.ReadUInt8();
tile.Chars[i, j].Color = subChunkReader.ReadUInt8();
}
}
Tiles.Add(tile);
tile.Index = Tiles.Count - 1;
}
break;
case Types.FileChunk.MAP:
{
GR.IO.FileChunk mapChunk = new GR.IO.FileChunk();
Map map = new Map();
while (mapChunk.ReadFromStream(subChunkReader))
{
GR.IO.MemoryReader mapChunkReader = mapChunk.MemoryReader();
switch (mapChunk.Type)
{
case Types.FileChunk.MAP_INFO:
map.Name = mapChunkReader.ReadString();
map.TileSpacingX = mapChunkReader.ReadInt32();
map.TileSpacingY = mapChunkReader.ReadInt32();
map.AlternativeMultiColor1 = mapChunkReader.ReadInt32() - 1;
map.AlternativeMultiColor2 = mapChunkReader.ReadInt32() - 1;
map.AlternativeBackgroundColor = mapChunkReader.ReadInt32() - 1;
map.AlternativeBGColor4 = mapChunkReader.ReadInt32() - 1;
map.AlternativeMode = (C64Studio.Types.CharsetMode)(mapChunkReader.ReadInt32() - 1);
break;
case Types.FileChunk.MAP_DATA:
{
int w = mapChunkReader.ReadInt32();
int h = mapChunkReader.ReadInt32();
map.Tiles.Resize(w, h);
for (int j = 0; j < map.Tiles.Height; ++j)
{
for (int i = 0; i < map.Tiles.Width; ++i)
{
map.Tiles[i, j] = mapChunkReader.ReadInt32();
}
}
}
break;
case Types.FileChunk.MAP_EXTRA_DATA:
{
uint len = mapChunkReader.ReadUInt32();
mapChunkReader.ReadBlock(map.ExtraDataOld, len);
map.ExtraDataText = map.ExtraDataOld.ToString();
map.ExtraDataOld.Clear();
}
break;
case Types.FileChunk.MAP_EXTRA_DATA_TEXT:
{
map.ExtraDataText = mapChunkReader.ReadString();
}
break;
}
}
Maps.Add(map);
}
break;
}
}
}
break;
}
}
memReader.Close();
Charset.MultiColor1 = MultiColor1;
Charset.MultiColor2 = MultiColor2;
Charset.BGColor4 = BGColor4;
return(true);
}
public bool Load(byte[] ProjectData)
{
string currentConfig = "Default";
string activeElement = "";
Node = new System.Windows.Forms.TreeNode();
Node.Tag = this;
GR.IO.MemoryReader memIn = new GR.IO.MemoryReader(ProjectData);
GR.IO.FileChunk chunk = new GR.IO.FileChunk();
ushort origDebugStartAddress = 2049;
while (chunk.ReadFromStream(memIn))
{
GR.IO.MemoryReader memChunk = chunk.MemoryReader();
switch (chunk.Type)
{
case Types.FileChunk.PROJECT:
// Project Info
// Version
memChunk.ReadUInt32();
Settings.Name = memChunk.ReadString();
Settings.Filename = memChunk.ReadString();
Settings.DebugPort = memChunk.ReadUInt16();
origDebugStartAddress = memChunk.ReadUInt16();
Settings.BuildTool = memChunk.ReadString();
Settings.RunTool = memChunk.ReadString();
Settings.MainDocument = memChunk.ReadString();
currentConfig = memChunk.ReadString();
activeElement = memChunk.ReadString();
Node.Text = Settings.Name;
break;
case Types.FileChunk.PROJECT_ELEMENT:
// Element Info
{
// Version
int version = (int)memChunk.ReadUInt32();
ProjectElement.ElementType type = (ProjectElement.ElementType)memChunk.ReadUInt32();
//System.Windows.Forms.TreeNode nodeParent = NodeFromHierarchy(
ProjectElement element = CreateElement(type, Node);
element.Name = memChunk.ReadString();
//element.Filename = System.IO.Path.GetFileName( memChunk.ReadString() );
element.Filename = memChunk.ReadString();
if (element.DocumentInfo.Type == ProjectElement.ElementType.FOLDER)
{
element.Node.Text = element.Name;
}
else
{
element.Node.Text = System.IO.Path.GetFileName(element.Filename);
}
GR.IO.FileChunk subChunk = new GR.IO.FileChunk();
if (!subChunk.ReadFromStream(memChunk))
{
return(false);
}
if (subChunk.Type != Types.FileChunk.PROJECT_ELEMENT_DATA)
{
return(false);
}
// Element Data
element.DocumentInfo.DocumentFilename = element.Filename;
if (element.Document != null)
{
if (!element.Document.ReadFromReader(subChunk.MemoryReader()))
{
Elements.Remove(element);
element.Document.Dispose();
element = null;
}
else
{
element.Document.SetDocumentFilename(element.Filename);
}
}
element.TargetFilename = memChunk.ReadString();
element.TargetType = (Types.CompileTargetType)memChunk.ReadUInt32();
int dependencyCount = memChunk.ReadInt32();
for (int i = 0; i < dependencyCount; ++i)
{
string dependency = memChunk.ReadString();
element.ForcedDependency.DependentOnFile.Add(new FileDependency.DependencyInfo(dependency, true, false));
}
// 3 free strings
memChunk.ReadString();
memChunk.ReadString();
memChunk.ReadString();
int perConfigSettingCount = memChunk.ReadInt32();
for (int i = 0; i < perConfigSettingCount; ++i)
{
GR.IO.FileChunk chunkElementPerConfigSetting = new GR.IO.FileChunk();
chunkElementPerConfigSetting.ReadFromStream(memChunk);
if (chunkElementPerConfigSetting.Type == Types.FileChunk.PROJECT_ELEMENT_PER_CONFIG_SETTING)
{
ProjectElement.PerConfigSettings perConfigSetting = new ProjectElement.PerConfigSettings();
GR.IO.MemoryReader memSubChunk = chunkElementPerConfigSetting.MemoryReader();
string config = memSubChunk.ReadString();
perConfigSetting.PreBuild = memSubChunk.ReadString();
perConfigSetting.CustomBuild = memSubChunk.ReadString();
perConfigSetting.PostBuild = memSubChunk.ReadString();
perConfigSetting.DebugFile = memSubChunk.ReadString();
perConfigSetting.DebugFileType = (C64Studio.Types.CompileTargetType)memSubChunk.ReadInt32();
perConfigSetting.PreBuildChain.Active = (memSubChunk.ReadInt32() == 1);
int numEntries = memSubChunk.ReadInt32();
for (int j = 0; j < numEntries; ++j)
{
var entry = new BuildChainEntry();
entry.ProjectName = memSubChunk.ReadString();
entry.Config = memSubChunk.ReadString();
entry.DocumentFilename = memSubChunk.ReadString();
entry.PreDefines = memSubChunk.ReadString();
perConfigSetting.PreBuildChain.Entries.Add(entry);
}
perConfigSetting.PostBuildChain.Active = (memSubChunk.ReadInt32() == 1);
numEntries = memSubChunk.ReadInt32();
for (int j = 0; j < numEntries; ++j)
{
var entry = new BuildChainEntry();
entry.ProjectName = memSubChunk.ReadString();
entry.Config = memSubChunk.ReadString();
entry.DocumentFilename = memSubChunk.ReadString();
entry.PreDefines = memSubChunk.ReadString();
perConfigSetting.PostBuildChain.Entries.Add(entry);
}
element.Settings[config] = perConfigSetting;
}
}
element.IsShown = (memChunk.ReadInt32() != 0);
element.AssemblerType = (C64Studio.Types.AssemblerType)memChunk.ReadUInt32();
int hierarchyPartCount = memChunk.ReadInt32();
for (int i = 0; i < hierarchyPartCount; ++i)
{
string part = memChunk.ReadString();
element.ProjectHierarchy.Add(part);
}
if (element.ProjectHierarchy.Count > 0)
{
// node is sub-node, move accordingly
System.Windows.Forms.TreeNode parentNode = NodeFromHierarchy(element.ProjectHierarchy);
if ((parentNode != null) &&
(parentNode != element.Node.Parent))
{
element.Node.Remove();
parentNode.Nodes.Add(element.Node);
}
}
// dependency - include symbols
dependencyCount = memChunk.ReadInt32();
for (int i = 0; i < dependencyCount; ++i)
{
element.ForcedDependency.DependentOnFile[i].IncludeSymbols = (memChunk.ReadInt32() != 0);
}
// code folding entries
int numFoldingEntries = memChunk.ReadInt32();
element.DocumentInfo.CollapsedFoldingBlocks = new GR.Collections.Set <int>();
for (int i = 0; i < numFoldingEntries; ++i)
{
int collapsedBlockLine = memChunk.ReadInt32();
element.DocumentInfo.CollapsedFoldingBlocks.Add(collapsedBlockLine);
//Debug.Log( "Get collapsed blocked for " + element.DocumentInfo.FullPath + ", line " + collapsedBlockLine );
}
// TODO - load other stuff
if ((element != null) &&
(element.IsShown))
{
ShowDocument(element);
if (element.Document != null)
{
element.Document.ShowHint = DockState.Document;
//element.Document.Show( MainForm.panelMain );
}
}
}
break;
case Types.FileChunk.PROJECT_ELEMENT_DISPLAY_DATA:
{
string elementFilename = memChunk.ReadString();
ProjectElement element = GetElementByFilename(elementFilename);
if (element != null)
{
UInt32 numBytes = memChunk.ReadUInt32();
GR.Memory.ByteBuffer displayData = new GR.Memory.ByteBuffer();
memChunk.ReadBlock(displayData, numBytes);
if (element.Document != null)
{
element.Document.ApplyDisplayDetails(displayData);
}
}
}
break;
case Types.FileChunk.PROJECT_CONFIG:
{
ProjectConfig config = new ProjectConfig();
config.Load(memChunk);
if (string.IsNullOrEmpty(config.DebugStartAddressLabel))
{
config.DebugStartAddressLabel = origDebugStartAddress.ToString();
}
Settings.Configs.Add(config.Name, config);
}
break;
case Types.FileChunk.PROJECT_WATCH_ENTRY:
{
WatchEntry watch = new WatchEntry();
watch.Load(memChunk);
Core.MainForm.AddWatchEntry(watch);
//Debug.Log( "loaded watch entry for " + watch.Name );
}
break;
}
}
if (Settings.Configs.Count == 0)
{
// there must be one config
ProjectConfig config = new ProjectConfig();
config.Name = "Default";
Settings.Configs.Add(config.Name, config);
Settings.CurrentConfig = config;
}
else
{
if (Settings.Configs.ContainsKey(currentConfig))
{
Settings.CurrentConfig = Settings.Configs[currentConfig];
}
else
{
foreach (ProjectConfig config in Settings.Configs.Values)
{
Settings.CurrentConfig = config;
break;
}
}
}
foreach (ProjectElement element in Elements)
{
if (element.Settings.Count == 0)
{
foreach (ProjectConfig config in Settings.Configs.Values)
{
// needs a default setting!
element.Settings[config.Name] = new ProjectElement.PerConfigSettings();
}
}
if ((!string.IsNullOrEmpty(element.Filename)) &&
(GR.Path.IsPathEqual(element.Filename, Settings.MainDocument)))
{
Core.MainForm.m_SolutionExplorer.HighlightNode(element.Node);
}
Core.MainForm.RaiseApplicationEvent(new C64Studio.Types.ApplicationEvent(C64Studio.Types.ApplicationEvent.Type.DOCUMENT_INFO_CREATED, element.DocumentInfo));
Core.MainForm.RaiseApplicationEvent(new C64Studio.Types.ApplicationEvent(C64Studio.Types.ApplicationEvent.Type.ELEMENT_CREATED, element));
}
if (!String.IsNullOrEmpty(activeElement))
{
ProjectElement element = GetElementByFilename(activeElement);
if ((element != null) &&
(element.Document != null))
{
element.Document.Show();
}
}
m_Modified = false;
return(true);
}
public bool ReadFromBuffer(GR.Memory.ByteBuffer ProjectFile)
{
ColorMapping.Clear();
for (int i = 0; i < 16; ++i)
{
ColorMapping.Add(i, new List <ColorMappingTarget> {
ColorMappingTarget.ANY
});
}
Colors.Palettes.Clear();
GR.IO.MemoryReader memReader = new GR.IO.MemoryReader(ProjectFile);
GR.IO.FileChunk chunk = new GR.IO.FileChunk();
while (chunk.ReadFromStream(memReader))
{
GR.IO.MemoryReader chunkReader = chunk.MemoryReader();
switch (chunk.Type)
{
case FileChunkConstants.GRAPHIC_SCREEN_INFO:
SelectedCheckType = (CheckType)chunkReader.ReadUInt32();
ScreenOffsetX = chunkReader.ReadInt32();
ScreenOffsetY = chunkReader.ReadInt32();
ScreenWidth = chunkReader.ReadInt32();
ScreenHeight = chunkReader.ReadInt32();
if ((ScreenWidth == 0) ||
(ScreenHeight == 0))
{
ScreenWidth = 320;
ScreenHeight = 200;
}
break;
case FileChunkConstants.GRAPHIC_COLOR_MAPPING:
{
ColorMapping.Clear();
int numEntries = chunkReader.ReadInt32();
for (int i = 0; i < numEntries; ++i)
{
ColorMapping.Add(i, new List <ColorMappingTarget>());
int numMappings = chunkReader.ReadInt32();
for (int j = 0; j < numMappings; ++j)
{
ColorMappingTarget mappingTarget = (ColorMappingTarget)chunkReader.ReadUInt8();
ColorMapping[i].Add(mappingTarget);
}
}
}
break;
case FileChunkConstants.GRAPHIC_DATA:
{
int width = chunkReader.ReadInt32();
int height = chunkReader.ReadInt32();
GR.Drawing.PixelFormat format = (GR.Drawing.PixelFormat)chunkReader.ReadInt32();
int paletteCount = chunkReader.ReadInt32();
Image.Create(width, height, format);
for (int i = 0; i < paletteCount; ++i)
{
byte r = chunkReader.ReadUInt8();
byte g = chunkReader.ReadUInt8();
byte b = chunkReader.ReadUInt8();
Image.SetPaletteColor(i, r, g, b);
}
uint dataSize = chunkReader.ReadUInt32();
GR.Memory.ByteBuffer imageData = new GR.Memory.ByteBuffer();
chunkReader.ReadBlock(imageData, dataSize);
Image.SetData(imageData);
}
break;
case FileChunkConstants.MULTICOLOR_DATA:
MultiColor = (chunkReader.ReadUInt8() == 1);
Colors.BackgroundColor = chunkReader.ReadUInt8();
Colors.MultiColor1 = chunkReader.ReadUInt8();
Colors.MultiColor2 = chunkReader.ReadUInt8();
Colors.ActivePalette = chunkReader.ReadInt32();
if ((Colors.MultiColor1 < 0) ||
(Colors.MultiColor1 >= 16))
{
Colors.MultiColor1 = 0;
}
if ((Colors.MultiColor2 < 0) ||
(Colors.MultiColor2 >= 16))
{
Colors.MultiColor2 = 0;
}
break;
case FileChunkConstants.PALETTE:
Colors.Palettes.Add(Palette.Read(chunkReader));
break;
}
}
memReader.Close();
if (Colors.Palettes.Count == 0)
{
Colors.Palettes.Add(PaletteManager.PaletteFromMachine(MachineType.C64));
}
return(true);
}
public bool ReadFromBuffer(GR.Memory.ByteBuffer DataIn)
{
if (DataIn == null)
{
return(false);
}
SpriteLayers.Clear();
GR.IO.MemoryReader memIn = DataIn.MemoryReader();
uint Version = memIn.ReadUInt32();
int numSprites = 256;
if (Version >= 1)
{
numSprites = memIn.ReadInt32();
}
Sprites = new List <SpriteData>();
for (int i = 0; i < numSprites; ++i)
{
Sprites.Add(new SpriteData());
CustomRenderer.PaletteManager.ApplyPalette(Sprites[i].Image);
}
string name = memIn.ReadString();
for (int i = 0; i < numSprites; ++i)
{
Sprites[i].Color = memIn.ReadInt32();
}
for (int i = 0; i < numSprites; ++i)
{
Sprites[i].Multicolor = (memIn.ReadUInt8() != 0);
}
BackgroundColor = memIn.ReadInt32();
MultiColor1 = memIn.ReadInt32();
MultiColor2 = memIn.ReadInt32();
bool genericMultiColor = (memIn.ReadUInt32() != 0);
for (int i = 0; i < numSprites; ++i)
{
GR.Memory.ByteBuffer tempBuffer = new GR.Memory.ByteBuffer();
memIn.ReadBlock(tempBuffer, 64);
tempBuffer.CopyTo(Sprites[i].Data, 0, 63);
}
UsedSprites = memIn.ReadUInt32();
ExportFilename = memIn.ReadString();
string exportPathSpriteFile = memIn.ReadString();
for (int i = 0; i < numSprites; ++i)
{
string desc = memIn.ReadString();
}
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();
}
GR.IO.FileChunk chunk = new GR.IO.FileChunk();
while (chunk.ReadFromStream(memIn))
{
switch (chunk.Type)
{
case Types.FileChunk.SPRITESET_LAYER:
{
Layer layer = new Layer();
SpriteLayers.Add(layer);
var chunkReader = chunk.MemoryReader();
GR.IO.FileChunk subChunk = new GR.IO.FileChunk();
while (subChunk.ReadFromStream(chunkReader))
{
var subChunkReader = subChunk.MemoryReader();
if (subChunk.Type == Types.FileChunk.SPRITESET_LAYER_ENTRY)
{
LayerSprite sprite = new LayerSprite();
sprite.Index = subChunkReader.ReadInt32();
sprite.Color = subChunkReader.ReadUInt8();
sprite.X = subChunkReader.ReadInt32();
sprite.Y = subChunkReader.ReadInt32();
sprite.ExpandX = (subChunkReader.ReadUInt8() != 0);
sprite.ExpandY = (subChunkReader.ReadUInt8() != 0);
layer.Sprites.Add(sprite);
}
else if (subChunk.Type == Types.FileChunk.SPRITESET_LAYER_INFO)
{
layer.Name = subChunkReader.ReadString();
layer.BackgroundColor = subChunkReader.ReadUInt8();
}
}
}
break;
}
}
return(true);
}
public bool ReadFromBuffer(GR.Memory.ByteBuffer DataIn)
{
if (DataIn == null)
{
return(false);
}
Data.Clear();
JumpedAtAddresses.Clear();
NamedLabels.Clear();
Description = "";
GR.IO.MemoryReader memIn = DataIn.MemoryReader();
GR.IO.FileChunk chunk = new GR.IO.FileChunk();
while (chunk.ReadFromStream(memIn))
{
var chunkReader = chunk.MemoryReader();
switch (chunk.Type)
{
case FileChunkConstants.DISASSEMBLY_INFO:
Description = chunkReader.ReadString();
break;
case FileChunkConstants.DISASSEMBLY_DATA:
{
DataStartAddress = chunkReader.ReadInt32();
uint dataLength = chunkReader.ReadUInt32();
chunkReader.ReadBlock(Data, dataLength);
}
break;
case FileChunkConstants.DISASSEMBLY_JUMP_ADDRESSES:
{
int numEntries = chunkReader.ReadInt32();
for (int i = 0; i < numEntries; ++i)
{
int value = chunkReader.ReadInt32();
JumpedAtAddresses.Add(value);
}
}
break;
case FileChunkConstants.DISASSEMBLY_NAMED_LABELS:
{
int numEntries = chunkReader.ReadInt32();
for (int i = 0; i < numEntries; ++i)
{
int address = chunkReader.ReadInt32();
string name = chunkReader.ReadString();
NamedLabels[address] = name;
}
}
break;
}
}
return(true);
}
public bool ReadFromBuffer(GR.Memory.ByteBuffer ProjectFile)
{
GR.IO.MemoryReader memReader = new GR.IO.MemoryReader(ProjectFile);
GR.IO.FileChunk chunk = new GR.IO.FileChunk();
while (chunk.ReadFromStream(memReader))
{
GR.IO.MemoryReader chunkReader = chunk.MemoryReader();
switch (chunk.Type)
{
case FileChunkConstants.CHARSET_SCREEN_INFO:
{
int version = chunkReader.ReadInt32();
ScreenWidth = chunkReader.ReadInt32();
ScreenHeight = chunkReader.ReadInt32();
ExternalCharset = chunkReader.ReadString();
_Mode = (TextMode)chunkReader.ReadInt32();
ScreenOffsetX = chunkReader.ReadInt32();
ScreenOffsetY = chunkReader.ReadInt32();
CharOffset = chunkReader.ReadInt32();
Chars = new List <uint>();
for (int i = 0; i < ScreenWidth * ScreenHeight; ++i)
{
Chars.Add((uint)0x010020);
}
}
break;
case FileChunkConstants.MULTICOLOR_DATA:
_Mode = (TextMode)chunkReader.ReadUInt8();
CharSet.Colors.BackgroundColor = chunkReader.ReadUInt8();
CharSet.Colors.MultiColor1 = chunkReader.ReadUInt8();
CharSet.Colors.MultiColor2 = chunkReader.ReadUInt8();
break;
case FileChunkConstants.SCREEN_CHAR_DATA:
for (int i = 0; i < Chars.Count; ++i)
{
if (Lookup.NumBytesOfSingleCharacter(Lookup.TextCharModeFromTextMode(Mode)) == 1)
{
Chars[i] = (uint)((Chars[i] & 0xffff0000) | chunkReader.ReadUInt8());
}
else
{
Chars[i] = (uint)((Chars[i] & 0xffff0000) | chunkReader.ReadUInt16());
}
}
break;
case FileChunkConstants.SCREEN_COLOR_DATA:
for (int i = 0; i < Chars.Count; ++i)
{
if (Lookup.NumBytesOfSingleCharacter(Lookup.TextCharModeFromTextMode(Mode)) == 1)
{
Chars[i] = (uint)((Chars[i] & 0xffff) | ((uint)chunkReader.ReadUInt8() << 16));
}
else
{
Chars[i] = (uint)((Chars[i] & 0xffff) | ((uint)chunkReader.ReadUInt16() << 16));
}
}
break;
case FileChunkConstants.CHARSET_DATA:
{
if (!CharSet.ReadFromBuffer(chunk))
{
return(false);
}
}
break;
}
}
memReader.Close();
return(true);
}
public bool ReadFromBuffer(GR.Memory.ByteBuffer SettingsData)
{
IgnoredWarnings.Clear();
GR.IO.BinaryReader binReader = new GR.IO.BinaryReader(SettingsData.MemoryStream());
GR.IO.FileChunk chunkData = new GR.IO.FileChunk();
while (chunkData.ReadFromStream(binReader))
{
switch (chunkData.Type)
{
case Types.FileChunk.SETTINGS_TOOL:
{
ToolInfo tool = new ToolInfo();
tool.FromChunk(chunkData);
// sanitize args
tool.CartArguments = tool.CartArguments.Replace("$(BuildTargetFilename)", "$(RunFilename)");
tool.PRGArguments = tool.PRGArguments.Replace("$(BuildTargetFilename)", "$(RunFilename)");
tool.WorkPath = tool.WorkPath.Replace("$(FilePath)", "$(RunPath)");
if (string.IsNullOrEmpty(tool.TrueDriveOnArguments))
{
tool.TrueDriveOnArguments = "-truedrive +virtualdev";
tool.TrueDriveOffArguments = "+truedrive -virtualdev";
}
if (tool.PRGArguments.Contains("-truedrive "))
{
tool.PRGArguments = tool.PRGArguments.Replace("-truedrive ", "");
}
if (tool.PRGArguments.Contains(" -truedrive"))
{
tool.PRGArguments = tool.PRGArguments.Replace(" -truedrive", "");
}
ToolInfos.AddLast(tool);
}
break;
case Types.FileChunk.SETTINGS_ACCELERATOR:
{
AcceleratorKey key = new AcceleratorKey();
key.FromChunk(chunkData);
Accelerators.Add(key.Key, key);
}
break;
case Types.FileChunk.SETTINGS_DPS_LAYOUT:
{
GR.IO.IReader binIn = chunkData.MemoryReader();
uint size = binIn.ReadUInt32();
GR.Memory.ByteBuffer tempData = new GR.Memory.ByteBuffer();
binIn.ReadBlock(tempData, size);
SetLayoutFromData(tempData);
}
break;
case Types.FileChunk.SETTINGS_SOUND:
{
GR.IO.IReader binIn = chunkData.MemoryReader();
PlaySoundOnSuccessfulBuild = (binIn.ReadUInt8() != 0);
PlaySoundOnBuildFailure = (binIn.ReadUInt8() != 0);
PlaySoundOnSearchFoundNoItem = (binIn.ReadUInt8() != 0);
}
break;
case Types.FileChunk.SETTINGS_WINDOW:
{
GR.IO.IReader binIn = chunkData.MemoryReader();
MainWindowPlacement = binIn.ReadString();
}
break;
case Types.FileChunk.SETTINGS_TABS:
{
GR.IO.IReader binIn = chunkData.MemoryReader();
TabSize = binIn.ReadInt32();
if ((TabSize <= 0) ||
(TabSize >= 100))
{
TabSize = 2;
}
AllowTabs = (binIn.ReadUInt8() != 0);
TabConvertToSpaces = (binIn.ReadUInt8() != 0);
}
break;
case Types.FileChunk.SETTINGS_FONT:
{
GR.IO.IReader binIn = chunkData.MemoryReader();
SourceFontFamily = binIn.ReadString();
SourceFontSize = (float)binIn.ReadInt32();
BASICUseNonC64Font = (binIn.ReadUInt8() != 0);
BASICSourceFontFamily = binIn.ReadString();
BASICSourceFontSize = (float)binIn.ReadInt32();
if (BASICSourceFontSize <= 0)
{
BASICSourceFontSize = 9.0f;
}
}
break;
case Types.FileChunk.SETTINGS_SYNTAX_COLORING:
{
GR.IO.IReader binIn = chunkData.MemoryReader();
Types.SyntaxElement element = (C64Studio.Types.SyntaxElement)binIn.ReadUInt32();
Types.SyntaxColor color = new C64Studio.Types.SyntaxColor(GR.EnumHelper.GetDescription(element));
color.FGColor = binIn.ReadUInt32();
color.BGColor = binIn.ReadUInt32();
color.BGColorAuto = (binIn.ReadUInt32() != 0);
SyntaxColoring.Add(element, color);
}
break;
case Types.FileChunk.SETTINGS_UI:
{
GR.IO.IReader binIn = chunkData.MemoryReader();
ToolbarActiveMain = (binIn.ReadUInt8() == 1);
ToolbarActiveDebugger = (binIn.ReadUInt8() == 1);
}
break;
case Types.FileChunk.SETTINGS_RUN_EMULATOR:
{
GR.IO.IReader binIn = chunkData.MemoryReader();
TrueDriveEnabled = (binIn.ReadUInt8() != 0);
}
break;
case Types.FileChunk.SETTINGS_DEFAULTS:
{
GR.IO.IReader binIn = chunkData.MemoryReader();
DefaultProjectBasePath = binIn.ReadString();
}
break;
case Types.FileChunk.SETTINGS_FIND_REPLACE:
{
GR.IO.IReader binIn = chunkData.MemoryReader();
LastFindIgnoreCase = (binIn.ReadUInt8() == 1);
LastFindWholeWord = (binIn.ReadUInt8() == 1);
LastFindRegexp = (binIn.ReadUInt8() == 1);
LastFindWrap = (binIn.ReadUInt8() == 1);
LastFindTarget = binIn.ReadUInt8();
int numFindArguments = binIn.ReadInt32();
for (int i = 0; i < numFindArguments; ++i)
{
FindArguments.Add(binIn.ReadString());
}
int numReplaceArguments = binIn.ReadInt32();
for (int i = 0; i < numReplaceArguments; ++i)
{
ReplaceArguments.Add(binIn.ReadString());
}
}
break;
case Types.FileChunk.SETTINGS_IGNORED_WARNINGS:
{
GR.IO.IReader binIn = chunkData.MemoryReader();
int numIgnoredWarnings = binIn.ReadInt32();
for (int i = 0; i < numIgnoredWarnings; ++i)
{
IgnoredWarnings.Add((C64Studio.Types.ErrorCode)binIn.ReadInt32());
}
}
break;
case Types.FileChunk.SETTINGS_PANEL_DISPLAY_DETAILS:
{
GR.IO.IReader binIn = chunkData.MemoryReader();
string toolName = binIn.ReadString();
if (GenericTools.ContainsKey(toolName))
{
uint length = binIn.ReadUInt32();
GR.Memory.ByteBuffer data = new GR.Memory.ByteBuffer();
binIn.ReadBlock(data, length);
GenericTools[toolName].ApplyDisplayDetails(data);
}
}
break;
case Types.FileChunk.SETTINGS_BASIC_KEYMAP:
{
GR.IO.IReader binIn = chunkData.MemoryReader();
int numEntries = binIn.ReadInt32();
uint neutralLang = (uint)(System.Globalization.CultureInfo.CurrentCulture.KeyboardLayoutId & 0xff);
if ((neutralLang != 7) &&
(neutralLang != 9))
{
neutralLang = 9;
}
for (int i = 0; i < numEntries; ++i)
{
Keys key = (Keys)binIn.ReadUInt32();
Types.KeyboardKey cmdKey = (C64Studio.Types.KeyboardKey)binIn.ReadInt32();
var keyMapEntry = new KeymapEntry();
foreach (var entry in BASICKeyMap.DefaultKeymaps[neutralLang])
{
if (entry.Value.KeyboardKey == cmdKey)
{
BASICKeyMap.Keymap[key] = entry.Value;
break;
}
}
}
}
break;
case Types.FileChunk.SETTINGS_ASSEMBLER_EDITOR:
{
GR.IO.IReader binIn = chunkData.MemoryReader();
ASMHideLineNumbers = (binIn.ReadUInt8() != 0);
}
break;
case Types.FileChunk.SETTINGS_BASIC_PARSER:
{
GR.IO.IReader binIn = chunkData.MemoryReader();
BASICStripSpaces = (binIn.ReadUInt8() != 0);
}
break;
case Types.FileChunk.SETTINGS_ENVIRONMENT:
{
GR.IO.IReader binIn = chunkData.MemoryReader();
AutoOpenLastSolution = (binIn.ReadUInt8() != 0);
}
break;
}
}
return(true);
}
public bool ReadFromBuffer(GR.Memory.ByteBuffer DataIn)
{
if (DataIn == null)
{
return(false);
}
SpriteLayers.Clear();
Sprites.Clear();
GR.IO.MemoryReader memIn = DataIn.MemoryReader();
uint Version = memIn.ReadUInt32();
if (Version == 2)
{
Colors.Palettes.Clear();
GR.IO.FileChunk chunkMain = new GR.IO.FileChunk();
while (chunkMain.ReadFromStream(memIn))
{
switch (chunkMain.Type)
{
case FileChunkConstants.SPRITESET_PROJECT:
{
var chunkReader = chunkMain.MemoryReader();
GR.IO.FileChunk subChunk = new GR.IO.FileChunk();
while (subChunk.ReadFromStream(chunkReader))
{
var subChunkReader = subChunk.MemoryReader();
switch (subChunk.Type)
{
case FileChunkConstants.SPRITESET_INFO:
TotalNumberOfSprites = subChunkReader.ReadInt32();
Name = subChunkReader.ReadString();
ExportFilename = subChunkReader.ReadString();
ExportStartIndex = subChunkReader.ReadInt32();
ExportSpriteCount = subChunkReader.ReadInt32();
break;
case FileChunkConstants.MULTICOLOR_DATA:
Mode = (SpriteProjectMode)subChunkReader.ReadInt32();
Colors.BackgroundColor = subChunkReader.ReadInt32();
Colors.MultiColor1 = subChunkReader.ReadInt32();
Colors.MultiColor2 = subChunkReader.ReadInt32();
Colors.ActivePalette = 0;
break;
case FileChunkConstants.PALETTE:
Colors.Palettes.Add(Palette.Read(subChunkReader));
break;
case FileChunkConstants.SPRITESET_SPRITE:
{
var sprite = new SpriteData(new ColorSettings(Colors));
sprite.Mode = (SpriteMode)subChunkReader.ReadInt32();
sprite.Tile.Mode = (GraphicTileMode)subChunkReader.ReadInt32();
sprite.Tile.CustomColor = subChunkReader.ReadInt32();
sprite.Tile.Width = subChunkReader.ReadInt32();
sprite.Tile.Height = subChunkReader.ReadInt32();
int dataLength = subChunkReader.ReadInt32();
sprite.Tile.Data = new GR.Memory.ByteBuffer();
subChunkReader.ReadBlock(sprite.Tile.Data, (uint)dataLength);
if (sprite.Tile.CustomColor == -1)
{
sprite.Tile.CustomColor = 1;
}
sprite.Tile.Colors.ActivePalette = subChunkReader.ReadInt32();
sprite.Tile.Image = new GR.Image.MemoryImage(sprite.Tile.Width, sprite.Tile.Height, GR.Drawing.PixelFormat.Format32bppRgb);
Sprites.Add(sprite);
}
break;
case FileChunkConstants.SPRITESET_LAYER:
{
Layer layer = new Layer();
SpriteLayers.Add(layer);
GR.IO.FileChunk subChunkL = new GR.IO.FileChunk();
while (subChunkL.ReadFromStream(subChunkReader))
{
var subChunkReaderL = subChunkL.MemoryReader();
if (subChunkL.Type == FileChunkConstants.SPRITESET_LAYER_ENTRY)
{
LayerSprite sprite = new LayerSprite();
sprite.Index = subChunkReaderL.ReadInt32();
sprite.Color = subChunkReaderL.ReadInt32();
sprite.X = subChunkReaderL.ReadInt32();
sprite.Y = subChunkReaderL.ReadInt32();
sprite.ExpandX = (subChunkReaderL.ReadInt32() != 0);
sprite.ExpandY = (subChunkReaderL.ReadInt32() != 0);
layer.Sprites.Add(sprite);
}
else if (subChunkL.Type == FileChunkConstants.SPRITESET_LAYER_INFO)
{
layer.Name = subChunkReaderL.ReadString();
layer.BackgroundColor = subChunkReaderL.ReadInt32();
layer.DelayMS = subChunkReaderL.ReadInt32();
}
}
}
break;
}
}
}
break;
default:
Debug.Log("SpriteProject.ReadFromBuffer unexpected chunk type " + chunkMain.Type.ToString("X"));
return(false);
}
}
return(true);
}
int numSprites = 256;
if (Version >= 1)
{
numSprites = memIn.ReadInt32();
}
Sprites = new List <SpriteData>();
for (int i = 0; i < numSprites; ++i)
{
Sprites.Add(new SpriteData(Colors));
PaletteManager.ApplyPalette(Sprites[i].Tile.Image);
}
string name = memIn.ReadString();
for (int i = 0; i < numSprites; ++i)
{
Sprites[i].Tile.CustomColor = memIn.ReadInt32();
}
for (int i = 0; i < numSprites; ++i)
{
Sprites[i].Mode = (SpriteMode)memIn.ReadUInt8();
Sprites[i].Tile.Mode = Lookup.GraphicTileModeFromSpriteMode(Sprites[i].Mode);
}
Colors.BackgroundColor = memIn.ReadInt32();
Colors.MultiColor1 = memIn.ReadInt32();
Colors.MultiColor2 = memIn.ReadInt32();
bool genericMultiColor = (memIn.ReadUInt32() != 0);
for (int i = 0; i < numSprites; ++i)
{
GR.Memory.ByteBuffer tempBuffer = new GR.Memory.ByteBuffer();
memIn.ReadBlock(tempBuffer, 64);
tempBuffer.CopyTo(Sprites[i].Tile.Data, 0, 63);
}
ExportSpriteCount = memIn.ReadInt32();
ExportFilename = memIn.ReadString();
string exportPathSpriteFile = memIn.ReadString();
for (int i = 0; i < numSprites; ++i)
{
string desc = memIn.ReadString();
}
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();
}
GR.IO.FileChunk chunk = new GR.IO.FileChunk();
while (chunk.ReadFromStream(memIn))
{
switch (chunk.Type)
{
case FileChunkConstants.SPRITESET_LAYER:
{
Layer layer = new Layer();
SpriteLayers.Add(layer);
var chunkReader = chunk.MemoryReader();
GR.IO.FileChunk subChunk = new GR.IO.FileChunk();
while (subChunk.ReadFromStream(chunkReader))
{
var subChunkReader = subChunk.MemoryReader();
if (subChunk.Type == FileChunkConstants.SPRITESET_LAYER_ENTRY)
{
LayerSprite sprite = new LayerSprite();
sprite.Index = subChunkReader.ReadInt32();
sprite.Color = subChunkReader.ReadUInt8();
sprite.X = subChunkReader.ReadInt32();
sprite.Y = subChunkReader.ReadInt32();
sprite.ExpandX = (subChunkReader.ReadUInt8() != 0);
sprite.ExpandY = (subChunkReader.ReadUInt8() != 0);
layer.Sprites.Add(sprite);
}
else if (subChunk.Type == FileChunkConstants.SPRITESET_LAYER_INFO)
{
layer.Name = subChunkReader.ReadString();
layer.BackgroundColor = subChunkReader.ReadUInt8();
layer.DelayMS = subChunkReader.ReadInt32();
}
}
}
break;
}
}
while (Sprites.Count > 256)
{
Sprites.RemoveAt(256);
}
return(true);
}
public bool Load(string Filename)
{
byte[] projectData = null;
try
{
projectData = System.IO.File.ReadAllBytes(Filename);
}
catch (System.IO.IOException)
{
return(false);
}
Settings.Filename = Filename;
Settings.BasePath = System.IO.Path.GetDirectoryName(Settings.Filename);
GR.IO.MemoryReader memIn = new GR.IO.MemoryReader(projectData);
GR.IO.FileChunk chunk = new GR.IO.FileChunk();
while (chunk.ReadFromStream(memIn))
{
GR.IO.MemoryReader memChunk = chunk.MemoryReader();
switch (chunk.Type)
{
case Types.FileChunk.PROJECT:
// Project Info
// Version
memChunk.ReadUInt32();
Settings.Name = memChunk.ReadString();
Settings.Filename = memChunk.ReadString();
Settings.DebugPort = memChunk.ReadUInt16();
Settings.DebugStartAddress = memChunk.ReadUInt16();
Settings.BuildTool = memChunk.ReadString();
Settings.RunTool = memChunk.ReadString();
Settings.MainDocument = memChunk.ReadString();
break;
case Types.FileChunk.PROJECT_ELEMENT:
// Element Info
{
// Version
int version = (int)memChunk.ReadUInt32();
ProjectElement.ElementType type = (ProjectElement.ElementType)memChunk.ReadUInt32();
ProjectElement element = CreateElement(type);
element.Name = memChunk.ReadString();
element.Filename = memChunk.ReadString();
ShowDocument(element);
GR.IO.FileChunk subChunk = new GR.IO.FileChunk();
if (!subChunk.ReadFromStream(memChunk))
{
return(false);
}
if (subChunk.Type != Types.FileChunk.PROJECT_ELEMENT_DATA)
{
return(false);
}
// Element Data
if (element.Document != null)
{
if (!element.Document.ReadFromReader(subChunk.MemoryReader()))
{
Elements.Remove(element);
element.Document.Dispose();
element = null;
}
}
element.TargetFilename = memChunk.ReadString();
element.TargetType = (FileParser.CompileTargetType)memChunk.ReadUInt32();
if ((element != null) &&
(element.Document != null))
{
element.Document.ShowHint = DockState.Document;
element.Document.Show(MainForm.panelMain);
}
}
break;
}
}
Settings.Filename = Filename;
m_Modified = false;
return(true);
}
public bool Load(byte[] ProjectData, bool AutoCreateGUIItems)
{
string currentConfig = "Default";
string activeElement = "";
Node = new System.Windows.Forms.TreeNode();
Node.Tag = this;
Node.Collapse();
GR.IO.MemoryReader memIn = new GR.IO.MemoryReader(ProjectData);
GR.IO.FileChunk chunk = new GR.IO.FileChunk();
ushort origDebugStartAddress = 0;
while (chunk.ReadFromStream(memIn))
{
GR.IO.MemoryReader memChunk = chunk.MemoryReader();
switch (chunk.Type)
{
case FileChunkConstants.PROJECT:
// Project Info
// Version
uint projectVersion = memChunk.ReadUInt32();
Settings.Name = memChunk.ReadString();
Settings.Filename = memChunk.ReadString();
Settings.DebugPort = memChunk.ReadUInt16();
origDebugStartAddress = memChunk.ReadUInt16();
Settings.BuildTool = memChunk.ReadString();
Settings.RunTool = memChunk.ReadString();
Settings.MainDocument = memChunk.ReadString();
currentConfig = memChunk.ReadString();
activeElement = memChunk.ReadString();
memChunk.ReadUInt32(); // flags (all free)
if (projectVersion == 1)
{
if (origDebugStartAddress == 2049)
{
origDebugStartAddress = 0;
}
}
Node.Text = Settings.Name;
break;
case FileChunkConstants.PROJECT_ELEMENT:
// Element Info
{
// Version
int elementVersion = (int)memChunk.ReadUInt32();
ProjectElement.ElementType type = (ProjectElement.ElementType)memChunk.ReadUInt32();
ProjectElement element = CreateElement(type, Node);
element.Name = memChunk.ReadString();
element.Filename = memChunk.ReadString();
if (element.DocumentInfo.Type == ProjectElement.ElementType.FOLDER)
{
element.Node.Text = element.Name;
}
else
{
element.Node.Text = System.IO.Path.GetFileName(element.Filename);
}
if (Core.Navigating.Solution.IsNodeExpanded(element))
{
element.Node.Expand();
}
else
{
element.Node.Collapse();
}
GR.IO.FileChunk subChunk = new GR.IO.FileChunk();
if (!subChunk.ReadFromStream(memChunk))
{
return(false);
}
if (subChunk.Type != FileChunkConstants.PROJECT_ELEMENT_DATA)
{
return(false);
}
// Element Data
element.DocumentInfo.DocumentFilename = element.Filename;
if (element.Document != null)
{
if (!element.Document.ReadFromReader(subChunk.MemoryReader()))
{
Elements.Remove(element);
element.Document.Dispose();
element = null;
}
else
{
element.Document.SetDocumentFilename(element.Filename);
}
}
element.TargetFilename = memChunk.ReadString();
element.TargetType = (Types.CompileTargetType)memChunk.ReadUInt32();
int dependencyCount = memChunk.ReadInt32();
for (int i = 0; i < dependencyCount; ++i)
{
string dependency = memChunk.ReadString();
element.ForcedDependency.DependentOnFile.Add(new FileDependency.DependencyInfo(Settings.Name, dependency, true, false));
}
element.StartAddress = memChunk.ReadString();
// 2 free strings
memChunk.ReadString();
memChunk.ReadString();
int perConfigSettingCount = memChunk.ReadInt32();
for (int i = 0; i < perConfigSettingCount; ++i)
{
GR.IO.FileChunk chunkElementPerConfigSetting = new GR.IO.FileChunk();
chunkElementPerConfigSetting.ReadFromStream(memChunk);
if (chunkElementPerConfigSetting.Type == FileChunkConstants.PROJECT_ELEMENT_PER_CONFIG_SETTING)
{
ProjectElement.PerConfigSettings perConfigSetting = new ProjectElement.PerConfigSettings();
GR.IO.MemoryReader memSubChunk = chunkElementPerConfigSetting.MemoryReader();
string config = memSubChunk.ReadString();
perConfigSetting.PreBuild = memSubChunk.ReadString();
perConfigSetting.CustomBuild = memSubChunk.ReadString();
perConfigSetting.PostBuild = memSubChunk.ReadString();
perConfigSetting.DebugFile = memSubChunk.ReadString();
perConfigSetting.DebugFileType = (RetroDevStudio.Types.CompileTargetType)memSubChunk.ReadInt32();
perConfigSetting.PreBuildChain.Active = (memSubChunk.ReadInt32() == 1);
int numEntries = memSubChunk.ReadInt32();
for (int j = 0; j < numEntries; ++j)
{
var entry = new BuildChainEntry();
entry.ProjectName = memSubChunk.ReadString();
entry.Config = memSubChunk.ReadString();
entry.DocumentFilename = memSubChunk.ReadString();
entry.PreDefines = memSubChunk.ReadString();
perConfigSetting.PreBuildChain.Entries.Add(entry);
}
perConfigSetting.PostBuildChain.Active = (memSubChunk.ReadInt32() == 1);
numEntries = memSubChunk.ReadInt32();
for (int j = 0; j < numEntries; ++j)
{
var entry = new BuildChainEntry();
entry.ProjectName = memSubChunk.ReadString();
entry.Config = memSubChunk.ReadString();
entry.DocumentFilename = memSubChunk.ReadString();
entry.PreDefines = memSubChunk.ReadString();
perConfigSetting.PostBuildChain.Entries.Add(entry);
}
element.Settings[config] = perConfigSetting;
}
}
uint flags = memChunk.ReadUInt32();
element.IsShown = ((flags & 1) != 0);
element.AssemblerType = (RetroDevStudio.Types.AssemblerType)memChunk.ReadUInt32();
int hierarchyPartCount = memChunk.ReadInt32();
for (int i = 0; i < hierarchyPartCount; ++i)
{
string part = memChunk.ReadString();
element.ProjectHierarchy.Add(part);
}
if (element.ProjectHierarchy.Count > 0)
{
// node is sub-node, move accordingly
System.Windows.Forms.TreeNode parentNode = NodeFromHierarchy(element.ProjectHierarchy);
if ((parentNode != null) &&
(parentNode != element.Node.Parent))
{
element.Node.Remove();
parentNode.Nodes.Add(element.Node);
}
}
// dependency - include symbols
dependencyCount = memChunk.ReadInt32();
for (int i = 0; i < dependencyCount; ++i)
{
element.ForcedDependency.DependentOnFile[i].IncludeSymbols = (memChunk.ReadInt32() != 0);
}
// code folding entries
int numFoldingEntries = memChunk.ReadInt32();
element.DocumentInfo.CollapsedFoldingBlocks = new GR.Collections.Set <int>();
for (int i = 0; i < numFoldingEntries; ++i)
{
int collapsedBlockLine = memChunk.ReadInt32();
element.DocumentInfo.CollapsedFoldingBlocks.Add(collapsedBlockLine);
}
// external dependencies
int externalDependencyCount = memChunk.ReadInt32();
for (int i = 0; i < externalDependencyCount; ++i)
{
string dependency = memChunk.ReadString();
element.ExternalDependencies.DependentOnFile.Add(new FileDependency.DependencyInfo("", dependency, true, false));
}
var obsoleteBasicVersion = (BasicVersion)memChunk.ReadUInt32();
// dependency - project
dependencyCount = memChunk.ReadInt32();
for (int i = 0; i < dependencyCount; ++i)
{
element.ForcedDependency.DependentOnFile[i].Project = memChunk.ReadString();
}
element.BASICDialect = memChunk.ReadString();
if (string.IsNullOrEmpty(element.BASICDialect))
{
// old version, find dialect from obsoleteBasicVersion
string dialectKey = "BASIC V2";
switch (obsoleteBasicVersion)
{
case BasicVersion.C64_BASIC_V2:
break;
case BasicVersion.BASIC_LIGHTNING:
dialectKey = "BASIC Lightning";
break;
case BasicVersion.LASER_BASIC:
dialectKey = "Laser BASIC";
break;
case BasicVersion.SIMONS_BASIC:
dialectKey = "Simon's BASIC";
break;
case BasicVersion.V3_5:
dialectKey = "BASIC V3.5";
break;
case BasicVersion.V7_0:
dialectKey = "BASIC V7.0";
break;
}
if (Core.Compiling.BASICDialects.ContainsKey(dialectKey))
{
element.BASICDialect = dialectKey;
}
}
// TODO - load other stuff
if ((element != null) &&
(element.IsShown) &&
(AutoCreateGUIItems))
{
ShowDocument(element);
if (element.Document != null)
{
element.Document.ShowHint = DockState.Document;
}
}
if (element.Document != null)
{
element.Document.RefreshDisplayOptions();
}
}
break;
case FileChunkConstants.PROJECT_ELEMENT_DISPLAY_DATA:
{
string elementFilename = memChunk.ReadString();
ProjectElement element = GetElementByFilename(elementFilename);
if (element != null)
{
UInt32 numBytes = memChunk.ReadUInt32();
GR.Memory.ByteBuffer displayData = new GR.Memory.ByteBuffer();
memChunk.ReadBlock(displayData, numBytes);
if (element.Document != null)
{
element.Document.ApplyDisplayDetails(displayData);
}
}
}
break;
case FileChunkConstants.PROJECT_CONFIG:
{
ProjectConfig config = new ProjectConfig();
config.Load(memChunk);
if (string.IsNullOrEmpty(config.DebugStartAddressLabel))
{
config.DebugStartAddressLabel = origDebugStartAddress.ToString();
}
Settings.Configuration(config.Name, config);
}
break;
case FileChunkConstants.PROJECT_WATCH_ENTRY:
{
WatchEntry watch = new WatchEntry();
watch.Load(memChunk);
Settings.WatchEntries.Add(watch);
}
break;
}
}
if (Settings.GetConfigurationCount() == 0)
{
// there must be one config
ProjectConfig config = new ProjectConfig();
config.Name = "Default";
Settings.Configuration(config.Name, config);
Settings.CurrentConfig = config;
}
else
{
Settings.CurrentConfig = Settings.Configuration(currentConfig);
if (Settings.CurrentConfig == null)
{
Settings.CurrentConfig = Settings.GetConfigurations().First();
}
}
foreach (ProjectElement element in Elements)
{
if (element.Settings.Count == 0)
{
foreach (var configName in Settings.GetConfigurationNames())
{
// needs a default setting!
element.Settings[configName] = new ProjectElement.PerConfigSettings();
}
}
if (AutoCreateGUIItems)
{
if ((!string.IsNullOrEmpty(element.Filename)) &&
(GR.Path.IsPathEqual(element.Filename, Settings.MainDocument)))
{
Core.MainForm.m_SolutionExplorer.HighlightNode(element.Node);
}
Core.MainForm.RaiseApplicationEvent(new RetroDevStudio.Types.ApplicationEvent(RetroDevStudio.Types.ApplicationEvent.Type.DOCUMENT_INFO_CREATED, element.DocumentInfo));
Core.MainForm.RaiseApplicationEvent(new RetroDevStudio.Types.ApplicationEvent(RetroDevStudio.Types.ApplicationEvent.Type.ELEMENT_CREATED, element));
}
}
if (!String.IsNullOrEmpty(activeElement))
{
ProjectElement element = GetElementByFilename(activeElement);
if ((element != null) &&
(element.Document != null))
{
element.Document.Show();
}
}
m_Modified = false;
return(true);
}
public bool ReadFromBuffer(GR.Memory.ByteBuffer ProjectFile)
{
GR.IO.MemoryReader memReader = new GR.IO.MemoryReader(ProjectFile);
GR.IO.FileChunk chunk = new GR.IO.FileChunk();
while (chunk.ReadFromStream(memReader))
{
GR.IO.MemoryReader chunkReader = chunk.MemoryReader();
switch (chunk.Type)
{
case Types.FileChunk.CHARSET_SCREEN_INFO:
{
uint version = chunkReader.ReadUInt32();
ScreenWidth = chunkReader.ReadInt32();
ScreenHeight = chunkReader.ReadInt32();
ExternalCharset = chunkReader.ReadString();
Mode = (C64Studio.Types.CharsetMode)chunkReader.ReadInt32();
ScreenOffsetX = chunkReader.ReadInt32();
ScreenOffsetY = chunkReader.ReadInt32();
Chars = new List <ushort>();
for (int i = 0; i < ScreenWidth * ScreenHeight; ++i)
{
Chars.Add((ushort)0x0120);
}
}
break;
case Types.FileChunk.MULTICOLOR_DATA:
Mode = (C64Studio.Types.CharsetMode)chunkReader.ReadUInt8();
BackgroundColor = chunkReader.ReadUInt8();
MultiColor1 = chunkReader.ReadUInt8();
MultiColor2 = chunkReader.ReadUInt8();
break;
case Types.FileChunk.SCREEN_CHAR_DATA:
for (int i = 0; i < Chars.Count; ++i)
{
Chars[i] = (ushort)((Chars[i] & 0xff00) | chunkReader.ReadUInt8());
}
break;
case Types.FileChunk.SCREEN_COLOR_DATA:
for (int i = 0; i < Chars.Count; ++i)
{
Chars[i] = (ushort)((Chars[i] & 0x00ff) | (chunkReader.ReadUInt8() << 8));
}
break;
case Types.FileChunk.CHARSET_DATA:
{
if (!CharSet.ReadFromBuffer(chunk))
{
return(false);
}
}
break;
}
}
memReader.Close();
return(true);
}
public bool LoadFromFile(string Filename)
{
Elements.Clear();
ObjectTemplates.Clear();
this.Screens.Clear();
Regions.Clear();
GR.Memory.ByteBuffer editorFile = GR.IO.File.ReadAllBytes(Filename);
if (editorFile == null)
{
return(false);
}
GR.IO.MemoryReader memIn = editorFile.MemoryReader();
GR.IO.FileChunk chunk = new GR.IO.FileChunk();
while (chunk.ReadFromStream(memIn))
{
GR.IO.MemoryReader memReader = chunk.MemoryReader();
switch (chunk.Type)
{
case (ushort)ChunkType.GENERAL:
// general
{
OldCharsetProjectFilename = memReader.ReadString();
ExportFilename = memReader.ReadString();
ExportPrefix = memReader.ReadString();
ExportConstantOffset = memReader.ReadInt32();
SpriteProjectFilename = memReader.ReadString();
ProjectType = memReader.ReadString();
EmptyChar = memReader.ReadUInt8();
EmptyColor = memReader.ReadUInt8();
}
break;
case (ushort)ChunkType.CHARSET_INFO:
{
Types.CharsetProjectInfo info = new ElementEditor.Types.CharsetProjectInfo();
info.Filename = memReader.ReadString();
info.Multicolor = (memReader.ReadUInt8() == 1);
CharsetProjects.Add(info);
}
break;
case (ushort)ChunkType.ELEMENT:
// element
{
Element element = new Element();
element.Name = memReader.ReadString();
element.Index = memReader.ReadInt32();
int w = memReader.ReadInt32();
int h = memReader.ReadInt32();
element.Characters.Resize(w, h);
for (int i = 0; i < w; ++i)
{
for (int j = 0; j < h; ++j)
{
element.Characters[i, j].Char = memReader.ReadUInt8();
element.Characters[i, j].Color = memReader.ReadUInt8();
}
}
element.CharsetIndex = memReader.ReadInt32();
//element.CharsetIndex = 0;
if ((CharsetProjects.Count == 0) &&
(element.CharsetIndex != 0))
{
element.CharsetIndex = 0;
}
else if (element.CharsetIndex >= CharsetProjects.Count)
{
element.CharsetIndex = 0;
}
Elements.Add(element);
}
break;
case (ushort)ChunkType.OLD_SCREEN:
// screen
{
Screen screen = new Screen();
screen.Name = memReader.ReadString();
int numElements = memReader.ReadInt32();
for (int i = 0; i < numElements; ++i)
{
ScreenElement element = new ScreenElement();
element.Type = (ScreenElementType)memReader.ReadInt32();
int elementIndex = memReader.ReadInt32();
if (elementIndex >= Elements.Count)
{
elementIndex = 0;
}
element.Index = elementIndex;
element.X = memReader.ReadInt32();
element.Y = memReader.ReadInt32();
element.Repeats = memReader.ReadInt32();
element.Char = memReader.ReadInt32();
element.Color = memReader.ReadInt32();
element.SearchObjectIndex = memReader.ReadInt32();
screen.DisplayedElements.Add(element);
}
// fetch extra object data
foreach (ScreenElement element in screen.DisplayedElements)
{
if (element.Type == ScreenElementType.LD_OBJECT)
{
GR.IO.FileChunk chunkObject = new GR.IO.FileChunk();
if (!chunkObject.ReadFromStream(memReader))
{
return(false);
}
element.Object = new GameObject();
GR.IO.MemoryReader memObjectReader = chunkObject.MemoryReader();
element.Object.TemplateIndex = memObjectReader.ReadInt32();
element.Object.X = memObjectReader.ReadInt32();
element.Object.Y = memObjectReader.ReadInt32();
element.Object.Color = memObjectReader.ReadInt32();
element.Object.Speed = memObjectReader.ReadInt32();
element.Object.Behaviour = memObjectReader.ReadInt32();
element.Object.MoveBorderLeft = memObjectReader.ReadInt32();
element.Object.MoveBorderTop = memObjectReader.ReadInt32();
element.Object.MoveBorderRight = memObjectReader.ReadInt32();
element.Object.MoveBorderBottom = memObjectReader.ReadInt32();
element.Object.Data = memObjectReader.ReadInt32();
}
else if (element.Type == ScreenElementType.LD_SPAWN_SPOT)
{
GR.IO.FileChunk chunkSpawn = new GR.IO.FileChunk();
if (!chunkSpawn.ReadFromStream(memReader))
{
return(false);
}
element.Object = new GameObject();
GR.IO.MemoryReader memObjectReader = chunkSpawn.MemoryReader();
element.Object.TemplateIndex = memObjectReader.ReadInt32();
element.Object.X = memObjectReader.ReadInt32();
element.Object.Y = memObjectReader.ReadInt32();
element.Repeats = memObjectReader.ReadInt32();
}
}
GR.IO.FileChunk chunkMoreData = new GR.IO.FileChunk();
while (chunkMoreData.ReadFromStream(memReader))
{
GR.IO.MemoryReader moreDataReader = chunkMoreData.MemoryReader();
switch (chunkMoreData.Type)
{
case (ushort)ChunkType.OLD_SCREEN_MORE_DATA:
screen.Width = moreDataReader.ReadInt32();
break;
}
}
Screens.Add(screen);
}
break;
case (ushort)ChunkType.MAP_REGION:
{
Region region = new Region();
GR.IO.FileChunk subChunk = new GR.IO.FileChunk();
while (subChunk.ReadFromStream(memReader))
{
GR.IO.MemoryReader subReader = subChunk.MemoryReader();
switch (subChunk.Type)
{
case (ushort)ChunkType.MAP_REGION_INFO:
region.DisplayX = subReader.ReadInt32();
region.DisplayY = subReader.ReadInt32();
region.Vertical = (subReader.ReadInt32() != 0);
{
uint numExtraDataBytes = subReader.ReadUInt32();
region.ExtraData = new GR.Memory.ByteBuffer();
subReader.ReadBlock(region.ExtraData, numExtraDataBytes);
}
break;
case (ushort)ChunkType.MAP_REGION_SCREEN:
{
RegionScreenInfo screenInfo = new RegionScreenInfo();
screenInfo.ScreenIndex = subReader.ReadInt32();
screenInfo.ExitN = (subReader.ReadInt32() != 0);
screenInfo.ExitS = (subReader.ReadInt32() != 0);
screenInfo.ExitW = (subReader.ReadInt32() != 0);
screenInfo.ExitE = (subReader.ReadInt32() != 0);
region.Screens.Add(screenInfo);
}
break;
}
}
Regions.Add(region);
}
break;
case (ushort)ChunkType.SCREEN:
// screen
{
Screen screen = new Screen();
GR.IO.FileChunk subChunk = new GR.IO.FileChunk();
while (subChunk.ReadFromStream(memReader))
{
GR.IO.MemoryReader subReader = subChunk.MemoryReader();
switch (subChunk.Type)
{
case (ushort)ChunkType.SCREEN_INFO:
screen.Name = subReader.ReadString();
screen.Width = subReader.ReadInt32();
screen.Height = subReader.ReadInt32();
if (screen.Height == 0)
{
screen.Height = 25;
}
screen.ConfigByte = subReader.ReadUInt8();
screen.CharsetIndex = subReader.ReadInt32();
screen.WLConfigByte = subReader.ReadUInt8();
screen.ExtraData = subReader.ReadString();
screen.OverrideMC1 = subReader.ReadInt32() - 1;
screen.OverrideMC2 = subReader.ReadInt32() - 1;
break;
case (ushort)ChunkType.SCREEN_ELEMENT:
{
ScreenElement element = new ScreenElement();
element.Type = (ScreenElementType)subReader.ReadInt32();
int elementIndex = subReader.ReadInt32();
if (elementIndex >= Elements.Count)
{
elementIndex = 0;
}
element.Index = elementIndex;
element.X = subReader.ReadInt32();
element.Y = subReader.ReadInt32();
element.Repeats = subReader.ReadInt32();
element.Repeats2 = subReader.ReadInt32();
element.Char = subReader.ReadInt32();
element.Color = subReader.ReadInt32();
element.SearchObjectIndex = subReader.ReadInt32();
element.TargetX = subReader.ReadInt32();
element.TargetY = subReader.ReadInt32();
element.TargetLevel = subReader.ReadInt32();
element.Flags = subReader.ReadInt32();
if ((element.Type == ScreenElementType.LD_OBJECT) ||
(element.Type == ScreenElementType.LD_SPAWN_SPOT))
{
element.Object = new GameObject();
}
screen.DisplayedElements.Add(element);
}
break;
case (ushort)ChunkType.ELEMENT_OBJECT_DATA:
{
ScreenElement screenElement = screen.DisplayedElements[subReader.ReadInt32()];
if (screenElement.Type == ScreenElementType.LD_OBJECT)
{
screenElement.Object.TemplateIndex = subReader.ReadInt32();
screenElement.Object.X = subReader.ReadInt32();
screenElement.Object.Y = subReader.ReadInt32();
screenElement.Object.Color = subReader.ReadInt32();
screenElement.Object.Speed = subReader.ReadInt32();
screenElement.Object.Behaviour = subReader.ReadInt32();
screenElement.Object.MoveBorderLeft = subReader.ReadInt32();
screenElement.Object.MoveBorderTop = subReader.ReadInt32();
screenElement.Object.MoveBorderRight = subReader.ReadInt32();
screenElement.Object.MoveBorderBottom = subReader.ReadInt32();
screenElement.Object.Data = subReader.ReadInt32();
screenElement.Object.OptionalValue = subReader.ReadInt32();
screenElement.Object.Optional = (GameObject.OptionalType)subReader.ReadInt32();
}
}
break;
case (ushort)ChunkType.ELEMENT_SPAWN_SPOT_DATA:
{
ScreenElement screenElement = screen.DisplayedElements[subReader.ReadInt32()];
screenElement.Object.TemplateIndex = subReader.ReadInt32();
screenElement.Object.X = subReader.ReadInt32();
screenElement.Object.Y = subReader.ReadInt32();
screenElement.Repeats = subReader.ReadInt32();
}
break;
}
}
// fetch extra object data
Screens.Add(screen);
}
break;
case (ushort)ChunkType.OBJECT_TEMPLATE:
{
ObjectTemplate obj = new ObjectTemplate();
obj.Name = memReader.ReadString();
obj.StartSprite = memReader.ReadInt32();
int countBehaviours = memReader.ReadInt32();
for (int i = 0; i < countBehaviours; ++i)
{
int behaviourIndex = memReader.ReadInt32();
string behaviourName = memReader.ReadString();
int newIndex = obj.Behaviours.Count;
obj.Behaviours[newIndex] = new Behaviour();
obj.Behaviours[newIndex].Name = behaviourName;
obj.Behaviours[newIndex].Value = behaviourIndex;
}
ObjectTemplates.Add(obj);
}
break;
}
}
return(true);
}
