public void SaveExporterFiles(Dictionary <string, byte[]> files) { // TODO the dictionary string should be converted into a Workspace path // Save all the files to the disk foreach (var file in files) { try { // Anything that is not in the "/Workspace/" root is routed to save into the tmp directory var path = WorkspacePath.Parse(file.Key); // Console.WriteLine("Save Exported file " + file.Key + " to " + path); Stream stream; if (Exists(path)) { stream = OpenFile(path, FileAccess.ReadWrite); } else { // Make sure we have the correct directory structure if (path.IsFile) { // Get the parent path var parent = path.ParentPath; if (!Exists(parent)) { this.CreateDirectoryRecursive(parent); } } // Create a new file // Create a new file stream = CreateFile(path); } // TODO need to write to the file if (file.Value != null) { // Clear the file contents before writing to it stream.SetLength(0); // Write the byte data to it stream.Write(file.Value); stream.Close(); // TODO make sure we dispose of the stream? stream.Dispose(); } } catch { // Console.WriteLine("Couldn't save " + file.Key + "\n" + e.Message); } } }
public string FindValidSavePath(string gamePath) { string savePath; var filePath = WorkspacePath.Parse(gamePath); var parentFilePath = filePath.ParentPath; var writeAccess = WriteAccess(parentFilePath); if (writeAccess) { savePath = "/Game/"; if (filePath.IsFile) { savePath += filePath.EntityName; } } else { savePath = "/Tmp" + gamePath; } // Console.WriteLine("Save Path " + savePath); return(savePath); }
public Dictionary <string, object> CreateZipFile(WorkspacePath path, Dictionary <WorkspacePath, WorkspacePath> files) { var fileHelper = new WorkspaceFileLoadHelper(this); var zipExporter = new ZipExporter(path.Path, fileHelper, files); zipExporter.CalculateSteps(); while (zipExporter.completed == false) { zipExporter.NextStep(); } try { if ((bool)zipExporter.Response["success"]) { var zipPath = WorkspacePath.Parse(zipExporter.fileName); SaveExporterFiles(new Dictionary <string, byte[]>() { { zipExporter.fileName, zipExporter.bytes } }); } } catch (Exception e) { // Change the success to false zipExporter.Response["success"] = false; zipExporter.Response["message"] = e.Message; } return(zipExporter.Response); }
public string[] LoadGame(string path) { var filePath = WorkspacePath.Parse(path); var exits = Exists(filePath); string[] files = null; if (exits) { // Found disk to load if (filePath.IsDirectory) { currentDisk = new SubFileSystem(this, filePath); } else if (filePath.IsFile) { // TODO need to figure out how to do this from a disk now without the currentDisk drive? if (archiveExtensions.IndexOf(filePath.Path.Split('.').Last()) > -1) { using (var stream = OpenFile(filePath, FileAccess.ReadWrite)) { if (stream is FileStream) { currentDisk = ZipFileSystem.Open((FileStream)stream); } else { currentDisk = ZipFileSystem.Open(stream, path); } stream.Close(); } } } // We need to get a list of the current mounts if (Mounts is SortedList <WorkspacePath, IFileSystem> mounts) { // Create a new mount point for the current game var rootPath = WorkspacePath.Root.AppendDirectory("Game"); // Make sure we don't have a disk with the same name if (mounts.ContainsKey(rootPath)) { mounts.Remove(rootPath); } mounts.Add(rootPath, currentDisk); // Filter out only the files we can use and convert this into a dictionary with the file name as the key and the path as the value files = GetGameEntities(rootPath); } } return(files); }
public int GenerateSprites(string path, PixelVisionEngine targetGame) { var count = 0; var filePath = WorkspacePath.Parse(path); var srcPath = filePath.AppendDirectory("SpriteBuilder"); var fileData = new Dictionary <string, byte[]>(); if (Exists(srcPath)) { // Get all the files in the folder var files = from file in GetEntities(srcPath) where file.GetExtension() == ".png" select file; foreach (var file in files) { var name = file.EntityName.Substring(0, file.EntityName.Length - file.GetExtension().Length); var bytes = OpenFile(file, FileAccess.Read).ReadAllBytes(); if (fileData.ContainsKey(name)) { fileData[name] = bytes; } else { fileData.Add(name, bytes); } count++; // Console.WriteLine("Parse File " + name); } try { // TODO exporting sprites doesn't work if (locator.GetService(typeof(ExportService).FullName) is ExportService exportService) { exportService.ExportSpriteBuilder(path + "sb-sprites.lua", targetGame, fileData); // exportService.StartExport(); } } catch (Exception e) { // TODO this needs to go through the error system? Console.WriteLine(e); throw; } } return(count); }
public void EjectDisk(string path) { ejectingDisk = true; workspaceServicePlus.EjectDisk(WorkspacePath.Parse(path)); UpdateDiskInBios(); AutoLoadDefaultGame(); ejectingDisk = false; }
public byte[] ReadAllBytes(string file) { var path = WorkspacePath.Parse(file); using (var memoryStream = new MemoryStream()) { using (var fileStream = WorkspaceService.OpenFile(path, FileAccess.Read)) { fileStream.CopyTo(memoryStream); fileStream.Close(); } return(memoryStream.ToArray()); } }
// Exports the active song in the music chip public void ExportSong(string path, MusicChip musicChip, SoundChip soundChip, int id) { var currentSong = musicChip.songs[id]; var selectedPatterns = new int[currentSong.end]; Array.Copy(currentSong.patterns, selectedPatterns, selectedPatterns.Length); var filePath = WorkspacePath.Parse(path); if (Exists(filePath)) { filePath = filePath.AppendDirectory("Wavs").AppendDirectory("Songs"); if (!Exists(filePath)) { CreateDirectory(filePath); } try { filePath = UniqueFilePath(filePath.AppendFile("song " + id + " - " + currentSong.name + ".wav")); Console.WriteLine("Export song to " + filePath); // TODO exporting sprites doesn't work if (locator.GetService(typeof(ExportService).FullName) is ExportService exportService) { exportService.ExportSong(filePath.Path, musicChip, soundChip, selectedPatterns); // exportService.StartExport(); } } catch (Exception e) { // TODO this needs to go through the error system? Console.WriteLine(e); throw; } // TODO saving song doesn't work // runner.exportService.ExportSong(filePath.Path, musicChip, soundChip); // // runner.StartExport(); } }
public string AutoRunGameFromDisk(string diskName) { var diskPath = WorkspacePath.Root.AppendDirectory("Disks") .AppendDirectory(diskName); var autoRunPath = diskPath.AppendFile("info.json"); // Try to read the disk's info file and see if there is an auto run path try { // Only run a disk if there is an auto run file in there if (Exists(autoRunPath)) { var json = ReadTextFromFile(autoRunPath); var autoRunData = Json.Deserialize(json) as Dictionary <string, object>; var tmpPath = autoRunData["AutoRun"] as string; // Get the auto run from the json file var newDiskPath = WorkspacePath.Parse($"/Disks/{diskName}{tmpPath}"); // Change the disk path to the one in the auto-run file if (Exists(newDiskPath)) { diskPath = newDiskPath; } } } catch { // ignored } // Always validate that the disk is a valid game before trying to load it. if (ValidateGameInDir(diskPath)) { // TODO need to make sure the auto run disk is at the top of the list // Move the new disk to the top of the list var diskPaths = new List <string>(); // Add the remaining disks foreach (var disk in Disks) { diskPaths.Add(DiskPhysicalRoot(disk)); } // Remove the old disks EjectAll(); // Mount all the disks foreach (var oldPath in diskPaths) { MountDisk(oldPath); } return(diskPath.Path); } return(null); }
public ZipDiskExporter(string fileName, WorkspaceService workspaceService) : base(fileName) { diskPath = WorkspacePath.Parse(fileName); this.workspaceService = workspaceService; this.FileLoadHelper = new WorkspaceFileLoadHelper(this.workspaceService); }
public void OS_FileMove(string src, string dst) { workspace.Move(WorkspacePath.Parse(src), WorkspacePath.Parse(dst)); }
public bool OS_FileExists(string file) { return(workspace.Exists(WorkspacePath.Parse(file))); }
public Stream IO_OpenFile(Script script, string filename, Encoding encoding, string mode) { // TODO need to convert mode to file system mode return(workspace.OpenFile(WorkspacePath.Parse(filename), FileAccess.Read)); }
public string GetFileName(string path) { return(WorkspacePath.Parse(path).EntityName); }
public Dictionary <string, byte[]> LoadGame(string path) { var filePath = WorkspacePath.Parse(path); //FileSystemPath.Root.AppendPath(fullPath); var exits = Exists(filePath); Dictionary <string, byte[]> files = null; if (exits) { try { // Found disk to load if (filePath.IsDirectory) { currentDisk = new SubFileSystem(this, filePath); } else if (filePath.IsFile) { if (archiveExtensions.IndexOf(filePath.Path.Split('.').Last()) > -1) { using (var stream = OpenFile(filePath, FileAccess.ReadWrite)) { if (stream is FileStream) { currentDisk = ZipFileSystem.Open((FileStream)stream); } else { currentDisk = ZipFileSystem.Open(stream, path); } stream.Close(); } } } // We need to get a list of the current mounts var mounts = Mounts as SortedList <WorkspacePath, IFileSystem>; // Create a new mount point for the current game var rootPath = WorkspacePath.Root.AppendDirectory("Game"); // Make sure we don't have a disk with the same name if (mounts.ContainsKey(rootPath)) { mounts.Remove(rootPath); } mounts.Add(rootPath, currentDisk); files = ConvertDiskFilesToBytes(currentDisk); IncludeLibDirectoryFiles(files); try { // Convert the path to a system path var tmpFilePath = WorkspacePath.Parse(path); // TODO should we still try to load the saves file from a zip? // If the path is a directory we are going to look for a save file in it if (tmpFilePath.IsDirectory) { tmpFilePath = tmpFilePath.AppendFile("saves.json"); // if (WriteAccess(tmpFilePath) == false) // { // Check if save file is in tmp directory var saveFile = WorkspacePath.Parse(FindValidSavePath(tmpFilePath.Path)); if (saveFile.Path != "/" && Exists(saveFile)) { using (var memoryStream = new MemoryStream()) { using (var file = OpenFile(saveFile, FileAccess.Read)) { file.CopyTo(memoryStream); file.Close(); } var fileName = saveFile.EntityName; var data = memoryStream.ToArray(); if (files.ContainsKey(fileName)) { files[fileName] = data; } else { files.Add(fileName, data); } memoryStream.Close(); } } } // } } catch (Exception e) { Console.WriteLine(e); } // return true; } catch { // // TODO need to have a clearer messgae, like not a mount point or can't load from X because of Y // Console.WriteLine("System Error: Could not load from path " + filePath.Path); } } return(files); }
/// <summary> /// This will read a text file from a valid workspace path and return it as a string. This can read .txt, .json and /// .lua files. /// </summary> /// <param name="path">A valid workspace path.</param> /// <returns>Returns the contents of the file as a string.</returns> public string ReadTextFile(string path) { var filePath = WorkspacePath.Parse(path); return(workspace.ReadTextFromFile(filePath)); }
public bool SaveTextToFile(string filePath, string text, bool autoCreate = false) { var path = WorkspacePath.Parse(filePath); return(workspace.SaveTextToFile(path, text, autoCreate)); }
public void OS_FileDelete(string file) { workspace.Delete(WorkspacePath.Parse(file)); }