/// <summary> /// Load a CFG file from disk. /// </summary> /// <param name="filePath">Absolute path to CLASS*.CFG file.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public bool Load(string filePath, FileUsage usage = FileUsage.UseMemory, bool readOnly = true) { // Validate filename string filename = Path.GetFileName(filePath); if (!filename.StartsWith("CLASS", StringComparison.InvariantCultureIgnoreCase) || !filename.EndsWith(".CFG", StringComparison.InvariantCultureIgnoreCase)) { return false; } // Load file if (!file.Load(filePath, usage, readOnly)) return false; // Read file data BinaryReader reader = file.GetReader(); ReadFile(reader); return true; }
/// <summary> /// Loads an IMG file. /// </summary> /// <param name="filePath">Absolute path to *.IMG file</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public override bool Load(string filePath, FileUsage usage, bool readOnly) { // Exit if this file already loaded if (managedFile.FilePath == filePath) { return(true); } // Validate filename filePath = filePath.ToUpper(); string fn = Path.GetFileName(filePath); if (!fn.EndsWith(".IMG")) { return(false); } // Handle unsupported files if (!IsFilenameSupported(fn)) { Console.WriteLine(string.Format("{0} is unsupported.", fn)); return(false); } // Load file if (!managedFile.Load(filePath, usage, readOnly)) { return(false); } // Read file if (!Read()) { return(false); } return(true); }
/// <summary> /// Load BSA file. /// </summary> /// <param name="filePath">Absolute path to BSA file.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public bool Load(string filePath, FileUsage usage, bool readOnly) { // Ensure filename ends with .BSA or .SND if (!filePath.EndsWith(".BSA", StringComparison.InvariantCultureIgnoreCase) && !filePath.EndsWith(".SND", StringComparison.InvariantCultureIgnoreCase)) { return(false); } // Load file into memory if (!managedFile.Load(filePath, usage, readOnly)) { return(false); } // Read file if (!Read()) { return(false); } return(true); }
/// <summary> /// Load WOODS.WLD file. /// </summary> /// <param name="FilePath">Absolute path to WOODS.WLD file.</param> /// <param name="Usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="ReadOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public bool Load(string FilePath, FileUsage Usage, bool ReadOnly) { // Validate filename FilePath = FilePath.ToUpper(); if (!FilePath.EndsWith("WOODS.WLD")) { return(false); } // Load file into memory if (!ManagedFile.Load(FilePath, Usage, ReadOnly)) { return(false); } // Read file if (!Read()) { return(false); } return(true); }
/// <summary> /// Load WOODS.WLD file. /// </summary> /// <param name="filePath">Absolute path to WOODS.WLD file.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public bool Load(string filePath, FileUsage usage, bool readOnly) { // Validate filename filePath = filePath.ToUpper(); if (!filePath.EndsWith(Filename)) { return(false); } // Load file into memory if (!managedFile.Load(filePath, usage, readOnly)) { return(false); } // Read file if (!Read()) { return(false); } return(true); }
/// <summary> /// Load BSA file. /// </summary> /// <param name="FilePath">Absolute path to BSA file.</param> /// <param name="Usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="ReadOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public bool Load(string FilePath, FileUsage Usage, bool ReadOnly) { // Ensure filename ends with .BSA FilePath = FilePath.ToUpper(); if (!FilePath.EndsWith(".BSA") && !FilePath.EndsWith(".SND")) { return(false); } // Load file into memory if (!ManagedFile.Load(FilePath, Usage, ReadOnly)) { return(false); } // Read file if (!Read()) { return(false); } return(true); }
/// <summary> /// Load a CFG file from disk. /// </summary> /// <param name="filePath">Absolute path to CLASS*.CFG file.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public bool Load(byte[] data, string Name = "NoName", FileUsage usage = FileUsage.UseMemory, bool readOnly = true) { // Validate filename //string filename = Path.GetFileName(filePath); //if (!filename.EndsWith(".ITM", StringComparison.InvariantCultureIgnoreCase)) //{ // return false; //} itemName = Name; // Load file if (!file.Load(data, "", usage, readOnly)) { return(false); } // Read file data BinaryReader reader = file.GetReader(); ReadFile(reader); return(true); }
/// <summary> /// Load BSA file. /// </summary> /// <param name="filePath">Absolute path to BSA file.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public bool Load(string filePath, FileUsage usage, bool readOnly) { // Ensure filename ends with .BSA filePath = filePath.ToUpper(); if (!filePath.EndsWith(".BSA") && !filePath.EndsWith(".SND")) { return(false); } // Load file into memory if (!managedFile.Load(filePath, usage, readOnly)) { return(false); } // Read file if (!Read()) { return(false); } return(true); }
/// <summary> /// Load a CFG file from disk. /// </summary> /// <param name="filePath">Absolute path to CLASS*.CFG file.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public bool Load(string filePath, FileUsage usage = FileUsage.UseMemory, bool readOnly = true) { // Validate filename string filename = Path.GetFileName(filePath); if (!filename.StartsWith("CLASS", StringComparison.InvariantCultureIgnoreCase) || !filename.EndsWith(".CFG", StringComparison.InvariantCultureIgnoreCase)) { return(false); } // Load file if (!file.Load(filePath, usage, readOnly)) { return(false); } // Read file data BinaryReader reader = file.GetReader(); ReadFile(reader); return(true); }
/// <summary> /// Load BSA file. /// </summary> /// <param name="filePath">Absolute path to BSA file.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <param name="filePatch">An optional list of patches to apply to file memory buffer.</param> /// <returns>True if successful, otherwise false.</returns> public bool Load(string filePath, FileUsage usage, bool readOnly, PatchList filePatch = null) { // Ensure filename ends with .BSA or .SND if (!filePath.EndsWith(".BSA", StringComparison.InvariantCultureIgnoreCase) && !filePath.EndsWith(".SND", StringComparison.InvariantCultureIgnoreCase) && !filePath.EndsWith(".SAV", StringComparison.InvariantCultureIgnoreCase)) { return(false); } // Load file into memory if (!managedFile.Load(filePath, usage, readOnly)) { return(false); } // Patch the file if (usage == FileUsage.UseMemory && filePatch != null) { foreach (var patch in filePatch) { for (int i = 0; i < patch.data.Length; i++) { managedFile.Buffer[patch.offset + i] = patch.data[i]; } } } // Read file if (!Read()) { return(false); } return(true); }
/// <summary> /// Loads a file into memory. /// </summary> /// <param name="FilePath">Absolute path of file to load.</param> /// <param name="FileAccess">Defines access to file.</param> /// <param name="FileShare">Defines shared access to file.</param> /// <returns>True if successful, otherwise false.</returns> private bool LoadMemory(string FilePath, FileAccess FileAccess, FileShare FileShare) { // File must exist if (!File.Exists(FilePath)) { return(false); } // Load file into memory buffer try { FileStream file = File.Open(FilePath, FileMode.Open, FileAccess, FileShare); fileBuffer = new byte[file.Length]; if (file.Length != file.Read(fileBuffer, 0, (int)file.Length)) { return(false); } // Close file file.Close(); } catch (Exception e) { MyLastException = e; Console.WriteLine(e.Message); return(false); } // Store filename ManagedFilePath = FilePath; // Set usage fileUsage = FileUsage.UseMemory; return(true); }
/// <summary> /// Load constructor. /// </summary> /// <param name="FilePath">Absolute path to MAPS.BSA.</param> /// <param name="Usage">Determines if the BSA file will read from disk or memory.</param> /// <param name="ReadOnly">File will be read-only if true, read-write if false.</param> public MapsFile(string FilePath, FileUsage Usage, bool ReadOnly) { Load(FilePath, Usage, ReadOnly); }
/// <summary> /// Loads an image file. /// </summary> /// <param name="filePath">Absolute path to file</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public abstract bool Load(string filePath, FileUsage usage, bool readOnly);
/// <summary> /// Load BSA file. /// </summary> /// <param name="filePath">Absolute path to BSA file.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public bool Load(string filePath, FileUsage usage, bool readOnly) { // Ensure filename ends with .BSA or .SND filePath = filePath.ToUpper(); if (!filePath.EndsWith(".BSA") && !filePath.EndsWith(".SND")) return false; // Load file into memory if (!managedFile.Load(filePath, usage, readOnly)) return false; // Read file if (!Read()) return false; return true; }
public MagicItemsFile(string filePath, FileUsage usage = FileUsage.UseMemory, bool readOnly = true) { Load(filePath, usage, readOnly); }
/// <summary> /// Load constructor that also loads a palette. /// </summary> /// <param name="FilePath">Absolute path to *.CIF or *.RCI file.</param> /// <param name="Usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="PaletteFilePath">Absolute path to Daggerfall palette file.</param> /// <param name="ReadOnly">File will be read-only if true, read-write if false.</param> public CifRciFile(string FilePath, FileUsage Usage, string PaletteFilePath, bool ReadOnly) { LoadPalette(PaletteFilePath); Load(FilePath, Usage, ReadOnly); }
/// <summary> /// Load constructor. /// </summary> /// <param name="filePath">Absolute path to file.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> public FileProxy(string filePath, FileUsage usage, bool readOnly) { Load(filePath, usage, readOnly); }
/// <summary> /// Load constructor with palette assignment. /// Some IMG files contain palette information, this will overwrite the specified palette. /// </summary> /// <param name="filePath">Absolute path to *.IMG file.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="palette">Palette to use when building images.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> public ImgFile(string filePath, FileUsage usage, DFPalette palette, bool readOnly) { myPalette = palette; Load(filePath, usage, readOnly); }
/// <summary> /// Loads a texture file. /// </summary> /// <param name="filePath">Absolute path to TEXTURE.* file</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public override bool Load(string filePath, FileUsage usage, bool readOnly) { // Exit if this file already loaded if (managedFile.FilePath == filePath) { return(true); } // Validate filename string fn = Path.GetFileName(filePath); if (!fn.StartsWith("TEXTURE.", StringComparison.InvariantCultureIgnoreCase)) { return(false); } // Handle unsupported files if (!IsFilenameSupported(fn)) { Console.WriteLine(string.Format("{0} is unsupported.", fn)); return(false); } // Handle solid types if (fn == "TEXTURE.000") { solidType = SolidTypes.SolidColoursA; } else if (fn == "TEXTURE.001") { solidType = SolidTypes.SolidColoursB; } else { solidType = SolidTypes.None; } // Handle spectral types if (fn == "TEXTURE.273" || fn == "TEXTURE.278") { spectralType = SpectralTypes.Spectral; } else { spectralType = SpectralTypes.None; } // Load file if (!managedFile.Load(filePath, usage, readOnly)) { return(false); } // Attempt to load palette file from same path string arena2Path = Path.GetDirectoryName(filePath); LoadPalette(Path.Combine(arena2Path, PaletteName)); // Read file if (!Read()) { return(false); } return(true); }
/// <summary> /// Load constructor. /// </summary> /// <param name="filePath">Absolute path to TEXTURE.* file.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> public TextureFile(string filePath, FileUsage usage, bool readOnly) { Load(filePath, usage, readOnly); }
/// <summary> /// Loads a texture file. /// </summary> /// <param name="filePath">Absolute path to TEXTURE.* file</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public override bool Load(string filePath, FileUsage usage, bool readOnly) { // Exit if this file already loaded if (managedFile.FilePath == filePath) return true; // Validate filename filePath = filePath.ToUpper(); string fn = Path.GetFileName(filePath); if (!fn.StartsWith("TEXTURE.")) return false; // Handle unsupported files if (!IsFilenameSupported(fn)) { Console.WriteLine(string.Format("{0} is unsupported.", fn)); return false; } // Handle solid types if (fn == "TEXTURE.000") solidType = SolidTypes.SolidColoursA; else if (fn == "TEXTURE.001") solidType = SolidTypes.SolidColoursB; else solidType = SolidTypes.None; // Handle spectral types if (fn == "TEXTURE.273" || fn == "TEXTURE.278") spectralType = SpectralTypes.Spectral; else spectralType = SpectralTypes.None; // Load file if (!managedFile.Load(filePath, usage, readOnly)) return false; // Attempt to load palette file from same path string arena2Path = Path.GetDirectoryName(filePath); LoadPalette(Path.Combine(arena2Path, PaletteName)); // Read file if (!Read()) return false; return true; }
/// <summary> /// Load MAPS.BSA file. /// </summary> /// <param name="filePath">Absolute path to MAPS.BSA file.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public bool Load(string filePath, FileUsage usage, bool readOnly) { // Validate filename if (!filePath.EndsWith("MAPS.BSA", StringComparison.InvariantCultureIgnoreCase)) return false; // Load PAK files string arena2Path = Path.GetDirectoryName(filePath); climatePak = new PakFile(Path.Combine(arena2Path, "CLIMATE.PAK")); politicPak = new PakFile(Path.Combine(arena2Path, "POLITIC.PAK")); // Load file isReady = false; if (!bsaFile.Load(filePath, usage, readOnly)) return false; // Create records array regions = new RegionRecord[RegionCount]; // Set ready flag isReady = true; return true; }
/// <summary> /// Default constructor. /// </summary> public FileProxy() { fileUsage = FileUsage.Undefined; }
public TextFile(string arena2Path, string fileName, FileUsage usage = FileUsage.UseMemory, bool readOnly = true) { Load(arena2Path, fileName, usage, readOnly); }
/// <summary> /// Load WOODS.WLD file. /// </summary> /// <param name="filePath">Absolute path to WOODS.WLD file.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public bool Load(string filePath, FileUsage usage, bool readOnly) { // Validate filename if (!filePath.EndsWith(Filename, StringComparison.InvariantCultureIgnoreCase)) return false; // Load file into memory if (!managedFile.Load(filePath, usage, readOnly)) return false; // Read file if (!Read()) return false; return true; }
/// <summary> /// Path constructor. /// </summary> /// <param name="fallExePath">Path to FALL.EXE.</param> public ItemsFile(byte[] data, string Name = "NoName", FileUsage usage = FileUsage.UseMemory, bool readOnly = true) : base() { Load(data, Name, usage, readOnly); }
/// <summary> /// Load WOODS.WLD file. /// </summary> /// <param name="filePath">Absolute path to WOODS.WLD file.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public bool Load(string filePath, FileUsage usage, bool readOnly) { // Validate filename filePath = filePath.ToUpper(); if (!filePath.EndsWith(Filename)) return false; // Load file into memory if (!managedFile.Load(filePath, usage, readOnly)) return false; // Read file if (!Read()) return false; return true; }
/// <summary> /// Loads an IMG file. /// </summary> /// <param name="filePath">Absolute path to *.IMG file</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public override bool Load(string filePath, FileUsage usage, bool readOnly) { // Exit if this file already loaded if (managedFile.FilePath == filePath) return true; // Validate filename filePath = filePath.ToUpper(); string fn = Path.GetFileName(filePath); if (!fn.EndsWith(".IMG")) return false; // Handle unsupported files if (!IsFilenameSupported(fn)) { Console.WriteLine(string.Format("{0} is unsupported.", fn)); return false; } // Load file if (!managedFile.Load(filePath, usage, readOnly)) return false; // Read file if (!Read()) return false; return true; }
/// <summary> /// Load constructor with palette assignment. /// </summary> /// <param name="FilePath">Absolute path to *.CIF or *.RCI file.</param> /// <param name="Usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="Palette">Palette to use when building images.</param> /// <param name="ReadOnly">File will be read-only if true, read-write if false.</param> public CifRciFile(string FilePath, FileUsage Usage, DFPalette Palette, bool ReadOnly) { MyPalette = Palette; Load(FilePath, Usage, ReadOnly); }
/// <summary> /// Load constructor that also loads a palette. /// Some IMG files contain palette information, this will overwrite the specified palette. /// </summary> /// <param name="filePath">Absolute path to *.IMG file.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="paletteFilePath">Absolute path to Daggerfall palette file.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> public ImgFile(string filePath, FileUsage usage, string paletteFilePath, bool readOnly) { LoadPalette(paletteFilePath); Load(filePath, usage, readOnly); }
internal static IChemFile LoadFromFile(string filename, ISettings settings, FileUsage usage, LoadingProgress progress, out MoleculeLoadingResults results) { IChemObjectReader reader; results = new MoleculeLoadingResults(); results.Filename = filename; MoleculeLoadingProgress molLoading = new MoleculeLoadingProgress(Path.GetFileName(filename), progress); progress.MoveToNextProcess(molLoading); try { molLoading.Log("Reading file", LogItem.ItemLevel.StageInfo); StreamReader file = new StreamReader(filename, System.Text.Encoding.Default); ReaderFactory readerFactory = new ReaderFactory(); molLoading.Log("Creating Reader", LogItem.ItemLevel.DebugInfo); reader = readerFactory.createReader(filename, file); file.Close(); if (reader != null) { reader.setReader(new StreamReader(filename, System.Text.Encoding.Default)); } else { throw new UserLevelException("Format not recognised", UserLevelException.ExceptionType.FileLoading, typeof(MoleculeLoader), null); } results.FileFormat = (IChemFormat)reader.Format; molLoading.Log("Found File Format: " + reader.Format.FormatName, LogItem.ItemLevel.UserInfo); } catch (FileNotFoundException fnfe) { throw new UserLevelException("Target file no found", UserLevelException.ExceptionType.FileLoading, typeof(MoleculeLoader), fnfe); } molLoading.Log("Loaded Molecule File", LogItem.ItemLevel.Success); //catch (IOException ioe) //{ // throw new UserLevelException("Problem reading from file", UserLevelException.ExceptionType.FileLoading, // typeof(MoleculeLoader), ioe); //} //catch (UserLevelException ule) //{ // results.Result = MoleculeLoadingResults.Results.Problems; // throw ule; //} //catch (Exception e) //{ // results.Result = MoleculeLoadingResults.Results.Errors; // throw new UserLevelException("Problem loading file", UserLevelException.ExceptionType.FileLoading, // typeof(MoleculeLoader), e); //} IChemFile chemFile; ChemModel chemModel; if (reader.accepts(typeof(IChemFile))) { // try to read a ChemFile //try //{ chemFile = (IChemFile)reader.read((IChemObject) new ChemFile()); molLoading.UpdateProgress(1); if (chemFile != null) { ProcessChemFile(chemFile, settings, usage, results, progress); } return(chemFile); //} //catch (UserLevelException ule) //{ // throw ule; //} //catch (Exception e) //{ // results.Result = MoleculeLoadingResults.Results.Errors; // throw new UserLevelException("Problem reading/processing file", UserLevelException.ExceptionType.FileLoading, // typeof(MoleculeLoader), e); //} } if (reader.accepts(typeof(ChemModel))) { // try to read a ChemModel //try //{ chemModel = (ChemModel)reader.read((IChemObject) new ChemModel()); molLoading.UpdateProgress(1); if (chemModel != null) { MoleculeProcessingProgress molProcessing = new MoleculeProcessingProgress(progress); progress.MoveToNextProcess(molProcessing); ProcessChemModel(chemModel, settings, usage, results, molProcessing, 1); } //} //catch (UserLevelException ule) //{ // throw ule; //} //catch (Exception e) //{ // throw new UserLevelException("Problem reading/processing file", UserLevelException.ExceptionType.FileLoading, // typeof(MoleculeLoader), e); //} } else { throw new UserLevelException("Unable to process reading", UserLevelException.ExceptionType.FileLoading, typeof(MoleculeLoader), null); } return(null); }
private static void ProcessChemModel(IChemModel chemModel, ISettings settings, FileUsage usage, MoleculeLoadingResults results, MoleculeProcessingProgress progress, float sectionSz) { //if (ChemModelManipulator.getAllInOneContainer(chemModel).getBondCount() == 0) //{ // return; //} // check for coordinates if ((GeometryTools.has2DCoordinatesNew(ChemModelManipulator.getAllInOneContainer(chemModel)) != 0))// { results.Num2DCoords++; } // usage == FileUsage.TwoD) //{ // throw new UserLevelException("File has no 2D coords", UserLevelException.ExceptionType.FileLoading, // typeof(MoleculeLoader), null); //} if ((GeometryTools.has2DCoordinatesNew(ChemModelManipulator.getAllInOneContainer(chemModel)) != 0))// && { results.Num3DCoords++; } // usage == FileUsage.ThreeD) //{ // throw new UserLevelException("File has no 3D coords", UserLevelException.ExceptionType.FileLoading, // typeof(MoleculeLoader), null); //} ElementPTFactory elements = ElementPTFactory.Instance; // calc item sz int numItems = 0; if (chemModel.SetOfMolecules != null) { results.NumMolecules += chemModel.SetOfMolecules.MoleculeCount; for (int mol = 0; mol < chemModel.SetOfMolecules.MoleculeCount; mol++) { numItems += chemModel.SetOfMolecules.Molecules[mol].Atoms.Length; //numItems += chemModel.SetOfMolecules.Molecules[mol].Bonds.Length; } } float itemSz = sectionSz / (float)numItems; if (chemModel.SetOfMolecules != null) { results.NumMolecules += chemModel.SetOfMolecules.MoleculeCount; for (int mol = 0; mol < chemModel.SetOfMolecules.MoleculeCount; mol++) { IMolecule molecule = chemModel.SetOfMolecules.Molecules[mol]; results.NumAtoms += molecule.Atoms.Length; results.NumBonds += molecule.Bonds.Length; foreach (IAtom atom in molecule.Atoms) { PeriodicTableElement pe = elements.getElement(atom.Symbol); if (pe != null) { atom.AtomicNumber = pe.AtomicNumber; atom.Properties["PeriodicTableElement"] = pe; atom.Properties["Period"] = int.Parse(pe.Period); } else { progress.Log(string.Format("Failed to find periodic element: {0}", atom.Symbol), LogItem.ItemLevel.Failure); } progress.UpdateProgress(itemSz); } progress.Log(string.Format("Processed {0} atoms", molecule.Atoms.Length), LogItem.ItemLevel.Info); } } progress.Log("Processed Model", LogItem.ItemLevel.Success); }
/// <summary> /// Load constructor. /// </summary> public ClassFile(string filePath, FileUsage usage = FileUsage.UseMemory, bool readOnly = true) { Load(filePath, usage, readOnly); }
/// <summary> /// Assign byte array constructor. /// </summary> /// <param name="Data">Byte array to assign (usage will be set to FileUsage.useMemory).</param> /// <param name="Name">Name, filename, or path to describe memory buffer.</param> public FileProxy(byte[] Data, string Name) { fileBuffer = Data; ManagedFilePath = Name; fileUsage = FileUsage.UseMemory; }
/// <summary> /// Load a file. /// </summary> /// <param name="filePath">Absolute path to file.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public bool Load(string filePath, FileUsage usage = FileUsage.UseMemory, bool readOnly = true) { // Determine file access settings FileAccess fileAccess; FileShare fileShare; if (readOnly) { fileAccess = FileAccess.Read; fileShare = FileShare.ReadWrite; isReadOnly = true; } else { fileAccess = FileAccess.ReadWrite; fileShare = FileShare.Read; isReadOnly = false; } // Load based on usage switch (usage) { case FileUsage.UseMemory: return LoadMemory(filePath, fileAccess, fileShare); case FileUsage.UseDisk: default: return LoadDisk(filePath, fileAccess, fileShare); } }
/// <summary> /// Load constructor. /// </summary> /// <param name="FilePath">Absolute path to file.</param> /// <param name="Usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="ReadOnly">File will be read-only if true, read-write if false.</param> public FileProxy(string FilePath, FileUsage Usage, bool ReadOnly) { Load(FilePath, Usage, ReadOnly); }
/// <summary> /// Loads a file into memory. /// Will first check Unity Resources folder for specified filename with a .bytes extensions /// and load that instead if available. /// </summary> /// <param name="filePath">Absolute path of file to load.</param> /// <param name="fileAccess">Defines access to file.</param> /// <param name="fileShare">Defines shared access to file.</param> /// <returns>True if successful, otherwise false.</returns> private bool LoadMemory(string filePath, FileAccess fileAccess, FileShare fileShare) { #if UNITY_WEBGL && !UNITY_EDITOR // Unity cannot use Resources.Load in WebGL // TODO: Implement WWW resource loading return false; #else // Attempt to locate in Unity Resources folder first string fileName = Path.GetFileName(filePath); TextAsset asset = Resources.Load<TextAsset>(fileName); if (asset != null) { fileBuffer = asset.bytes; } else { // File must exist if (!File.Exists(filePath)) return false; // Load file into memory buffer try { FileStream file = File.Open(filePath, FileMode.Open, fileAccess, fileShare); fileBuffer = new byte[file.Length]; if (file.Length != file.Read(fileBuffer, 0, (int)file.Length)) return false; // Close file file.Close(); } catch (Exception e) { myLastException = e; Console.WriteLine(e.Message); return false; } } // Store filename managedFilePath = filePath; // Set usage fileUsage = FileUsage.UseMemory; return true; #endif }
/// <summary> /// Assign byte array constructor. /// </summary> /// <param name="data">Byte array to assign (usage will be set to FileUsage.useMemory).</param> /// <param name="name">Name, filename, or path to describe memory buffer.</param> public FileProxy(byte[] data, string name) { fileBuffer = data; managedFilePath = name; fileUsage = FileUsage.UseMemory; }
/// <summary> /// Opens the specified book file. /// </summary> /// <param name="arena2">Arena2 path.</param> /// <param name="name">Name of book to open.</param> public bool OpenBook(string arena2, string name, FileUsage fileUsage = FileUsage.UseMemory, bool readOnly = true) { // Validate filename if (!name.StartsWith("BOK", StringComparison.InvariantCultureIgnoreCase) || !name.EndsWith(".TXT", StringComparison.InvariantCultureIgnoreCase)) { return false; } // Load book file string booksPath = Path.Combine(arena2, books); if (!bookFile.Load(Path.Combine(booksPath, name), fileUsage, readOnly)) return false; // Read book ReadHeader(); return true; }
/// <summary> /// Opens a file from disk. /// </summary> /// <param name="filePath">Absolute path of file to load.</param> /// <param name="fileAccess">Defines access to file.</param> /// <param name="fileShare">Defines shared access to file.</param> /// <returns>True if successful, otherwise false.</returns> private bool LoadDisk(string filePath, FileAccess fileAccess, FileShare fileShare) { // File must exist if (!File.Exists(filePath)) return false; // Open file try { fileStream = File.Open(filePath, FileMode.Open, fileAccess, fileShare); if (fileStream == null) return false; } catch (Exception e) { myLastException = e; Console.WriteLine(e.Message); return false; } // Store filename managedFilePath = filePath; // Set usage fileUsage = FileUsage.UseDisk; return true; }
/// <summary> /// Opens FALL.EXE file. /// </summary> /// <param name="fallExePath">Path to FALL.EXE file.</param> /// <param name="fileUsage">How to load file</param> /// <param name="readOnly">Open file read-only</param> /// <returns>True if successful.</returns> public bool OpenFallExeFile(string fallExePath, FileUsage fileUsage = FileUsage.UseMemory, bool readOnly = true) { isOpen = false; items.Clear(); // Must be FALL.EXE if (string.Compare(Path.GetFileName(fallExePath), Filename, true) != 0) return false; // Open file if (!fallExeFile.Load(fallExePath, fileUsage, readOnly)) return false; // Read file if (!ReadFallExeFile()) return false; isOpen = true; return true; }
/// <summary> /// Implemented only to satisfy abstract base. Does nothing. /// </summary> /// <param name="FilePath">N/A</param> /// <param name="Usage">N/A</param> /// <param name="ReadOnly">N/A</param> /// <returns>Always true.</returns> public override bool Load(string FilePath, FileUsage Usage, bool ReadOnly) { return(true); }
/// <summary> /// Loads a texture file. /// </summary> /// <param name="filePath">Absolute path to TEXTURE.* file</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public override bool Load(string filePath, FileUsage usage, bool readOnly) { // Exit if this file already loaded if (managedFile.FilePath == filePath) { return(true); } // Validate filename filePath = filePath.ToUpper(); string fn = Path.GetFileName(filePath); if (!fn.StartsWith("TEXTURE.")) { return(false); } // Handle unsupported files if (!IsFilenameSupported(fn)) { Console.WriteLine(string.Format("{0} is unsupported.", fn)); return(false); } // Handle solid types if (fn == "TEXTURE.000") { solidType = SolidTypes.SolidColoursA; } else if (fn == "TEXTURE.001") { solidType = SolidTypes.SolidColoursB; } else { solidType = SolidTypes.None; } // Handle spectral types if (fn == "TEXTURE.273" || fn == "TEXTURE.278") { spectralType = SpectralTypes.Spectral; } else { spectralType = SpectralTypes.None; } // Load file if (!managedFile.Load(filePath, usage, readOnly)) { return(false); } // Read file if (!Read()) { return(false); } return(true); }
/// <summary> /// Load constructor. /// </summary> /// <param name="filePath">Absolute path to ARCH3D.BSA file.</param> /// <param name="usage">Determines if the BSA file will read from disk or memory.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> public Arch3dFile(string filePath, FileUsage usage, bool readOnly) { Load(filePath, usage, readOnly); }
/// <summary> /// Load BSA file. /// </summary> /// <param name="filePath">Absolute path to BSA file.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public bool Load(string filePath, FileUsage usage, bool readOnly) { // Ensure filename ends with .BSA or .SND if (!filePath.EndsWith(".BSA", StringComparison.InvariantCultureIgnoreCase) && !filePath.EndsWith(".SND", StringComparison.InvariantCultureIgnoreCase)) return false; // Load file into memory if (!managedFile.Load(filePath, usage, readOnly)) return false; // Read file if (!Read()) return false; return true; }
/// <summary> /// Loads a CIF or RCI file. /// </summary> /// <param name="filePath">Absolute path to *.CIF or *.RCI file</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public override bool Load(string filePath, FileUsage usage, bool readOnly) { // Exit if this file already loaded if (managedFile.FilePath == filePath) return true; // Validate filename if (!filePath.EndsWith(".CIF", StringComparison.InvariantCultureIgnoreCase) && !filePath.EndsWith(".RCI", StringComparison.InvariantCultureIgnoreCase)) return false; // Load file if (!managedFile.Load(filePath, usage, readOnly)) return false; // Read file if (!Read()) return false; return true; }
/// <summary> /// Load constructor. /// </summary> /// <param name="filePath">Absolute path to *.CIF or *.RCI file.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> public CifRciFile(string filePath, FileUsage usage, bool readOnly) { Load(filePath, usage, readOnly); }
/// <summary> /// Loads a SKY file. /// </summary> /// <param name="filePath">Absolute path to SKY??.DAT file</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public override bool Load(string filePath, FileUsage usage, bool readOnly) { // Exit if this file already loaded if (managedFile.FilePath == filePath) return true; // Validate filename string fn = Path.GetFileName(filePath); if (!fn.StartsWith("SKY", StringComparison.InvariantCultureIgnoreCase) && !fn.EndsWith(".DAT", StringComparison.InvariantCultureIgnoreCase)) return false; // Load file if (!managedFile.Load(filePath, usage, readOnly)) return false; return true; }
/// <summary> /// Load constructor. /// </summary> /// <param name="filePath">Absolute path to WOODS.WLD.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> public WoodsFile(string filePath, FileUsage usage, bool readOnly) { Load(filePath, usage, readOnly); }
/// <summary> /// Load BLOCKS.BSA file. /// </summary> /// <param name="filePath">Absolute path to BLOCKS.BSA file.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> /// <returns>True if successful, otherwise false.</returns> public bool Load(string filePath, FileUsage usage, bool readOnly) { // Validate filename if (!filePath.EndsWith("BLOCKS.BSA", StringComparison.InvariantCultureIgnoreCase)) return false; // Load file if (!bsaFile.Load(filePath, usage, readOnly)) return false; // Create records array blocks = new BlockRecord[bsaFile.Count]; return true; }
/// <summary> /// Load constructor. /// </summary> /// <param name="filePath">Absolute path to MONSTER.BSA.</param> /// <param name="usage">Determines if the BSA file will read from disk or memory.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> public MonsterFile(string filePath, FileUsage usage, bool readOnly) { Load(filePath, usage, readOnly); }
/// <summary> /// Load constructor. /// </summary> /// <param name="filePath">Absolute path to *.CFA file.</param> /// <param name="usage">Specify if file will be accessed from disk, or loaded into RAM.</param> /// <param name="readOnly">File will be read-only if true, read-write if false.</param> public CfaFile(string filePath, FileUsage usage, bool readOnly) { Load(filePath, usage, readOnly); }
public override bool Load(string filePath, FileUsage usage, bool readOnly) { // Validate filename string fn = Path.GetFileName(filePath); if (string.Compare(fn, Filename, true) != 0) return false; // Load file if (!managedFile.Load(filePath, usage, readOnly)) return false; return true; }