public RespawnInfo(BinaryReader reader, int Version, int Customversion) { MonsterIndex = reader.ReadInt32(); Location = new Point(reader.ReadInt32(), reader.ReadInt32()); Count = reader.ReadUInt16(); Spread = reader.ReadUInt16(); Delay = reader.ReadUInt16(); Direction = reader.ReadByte(); if (Envir.LoadVersion >= 36) { RoutePath = reader.ReadString(); } if (Version > 67) { RandomDelay = reader.ReadUInt16(); RespawnIndex = reader.ReadInt32(); SaveRespawnTime = reader.ReadBoolean(); RespawnTicks = reader.ReadUInt16(); } else { RespawnIndex = ++SMain.Envir.RespawnIndex; } }
private static bool ReadInfoHeader(System.IO.BinaryReader aReader, ref BitmapInfoHeader aHeader) { aHeader.size = aReader.ReadUInt32(); if (aHeader.size < 40) { return(false); } aHeader.width = aReader.ReadInt32(); aHeader.height = aReader.ReadInt32(); aHeader.nColorPlanes = aReader.ReadUInt16(); aHeader.nBitsPerPixel = aReader.ReadUInt16(); aHeader.compressionMethod = (BMPComressionMode)aReader.ReadInt32(); aHeader.rawImageSize = aReader.ReadUInt32(); aHeader.xPPM = aReader.ReadInt32(); aHeader.yPPM = aReader.ReadInt32(); aHeader.nPaletteColors = aReader.ReadUInt32(); aHeader.nImportantColors = aReader.ReadUInt32(); int pad = (int)aHeader.size - 40; if (pad > 0) { aReader.ReadBytes(pad); } return(true); }
public Character(System.IO.BinaryReader reader, bool sentFromServer) : base(reader, sentFromServer) { myHitPoints = reader.ReadInt16(); myManaLevel = reader.ReadInt16(); ushort attribCount = reader.ReadUInt16(); for (int i = 0; i < attribCount; ++i) { myBaseAttributes.Add(CharAttribute.GetByID(reader.ReadUInt16()), reader.ReadByte()); } ushort skillCount = reader.ReadUInt16(); for (int i = 0; i < skillCount; ++i) { myBaseSkills.Add(CharSkill.GetByID(reader.ReadUInt16()), reader.ReadByte()); } myCurrentWalkDirection = myFacingDirection = (WalkDirection)reader.ReadByte(); if (!sentFromServer) { Inventory = new Inventory(this, reader); } }
/// <summary> /// Initializes a new instance of the <see cref="NiTriShapeData"/> class. /// </summary> /// <param name="file">The file.</param> /// <param name="reader">The reader.</param> public NiTriShapeData(NiFile file, BinaryReader reader) : base(file, reader) { this.NumTrianglePoints = reader.ReadUInt32(); if (base.Version >= eNifVersion.VER_10_1_0_0) { this.HasTriangles = reader.ReadBoolean(Version); } if (base.Version <= eNifVersion.VER_10_0_1_2 || this.HasTriangles || base.Version >= eNifVersion.VER_10_0_1_3) { this.Triangles = new Triangle[(int)this.NumTriangles]; this.HasTriangles = this.Triangles.Length > 0; for (int i = 0; i < (int)this.NumTriangles; i++) { this.Triangles[i] = new Triangle(reader); } } if (base.Version >= eNifVersion.VER_3_1) { ushort num = reader.ReadUInt16(); this.MatchGroups = new ushort[(int)num][]; for (int j = 0; j < (int)num; j++) { ushort num2 = reader.ReadUInt16(); this.MatchGroups[j] = new ushort[(int)num2]; for (int k = 0; k < (int)num2; k++) { this.MatchGroups[j][k] = reader.ReadUInt16(); } } } }
public static string peType(byte[] data) { ushort architecture = 0; Stream s = new MemoryStream(data); using (System.IO.BinaryReader bReader = new System.IO.BinaryReader(s)) { if (bReader.ReadUInt16() == 23117) //check the MZ signature { s.Seek(0x3A, System.IO.SeekOrigin.Current); // seek to e_lfanew. s.Seek(bReader.ReadUInt32(), System.IO.SeekOrigin.Begin); //Seek to the start of the NT header. if (bReader.ReadUInt32() == 17744) // check the PE\0\0 signature. { s.Seek(20, System.IO.SeekOrigin.Current); // seek past the file header, and architecture = bReader.ReadUInt16(); // read the magic number of the optional header. } } if (architecture == 0x10b) { return("PE32"); } else if (architecture == 0x20b) { return("PE32+"); } } return("Unknown"); }
protected override void check(object sender, EventArgs e) { int read_width = 0; int read_height = 0; int read_cwidth = 0; int read_cheight = 0; int read_quality = 0; int read_samples = 0; using (Stream stream = new FileStream(outPath, FileMode.Open, FileAccess.Read, FileShare.Read)) { using (BinaryReader reader = new BinaryReader(stream, Encoding.Default)) { read_width = reader.ReadUInt16(); read_height = reader.ReadUInt16(); read_cwidth = reader.ReadUInt16(); read_cheight = reader.ReadUInt16(); read_quality = reader.ReadByte(); read_samples = reader.ReadByte(); } } System.Windows.Forms.MessageBox.Show( "image width: " + inC1.imageWidth + " = " + read_width + "\nimage height: " + inC1.imageHeight + " = " + read_height + "\nchannel width: " + inC1.channelWidth + " = " + read_cwidth + "\nchannel height: " + inC1.channelHeight + " = " + read_cheight + "\nquality: " + inC1.quantizeQuality + " = " + read_quality + "\nsamples: " + inC1.samplingMode + " = " + (DataBlob.Samples)read_samples , "File Information"); }
public void GetDiskInfo(String diskPathname) { base.LoadDisk(diskPathname); System.Text.Encoding enc = System.Text.Encoding.ASCII; // Read the System Sector Byte[] sectorData = base.ReadSector(0, 1); System.IO.MemoryStream stm = new System.IO.MemoryStream(sectorData, 0, sectorData.Length); System.IO.BinaryReader rdr = new System.IO.BinaryReader(stm); stm.Seek(0x10, SeekOrigin.Begin); nextAvailableSector = rdr.ReadByte(); nextAvailableTrack = rdr.ReadByte(); directorySector = rdr.ReadByte(); directoryTrack = rdr.ReadByte(); sectorsFree = rdr.ReadUInt16(); sectorsUsed = rdr.ReadUInt16(); sectors = (UInt16)(sectorsUsed + sectorsFree); Byte[] bByteArray = rdr.ReadBytes(21); diskName = enc.GetString(bByteArray); diskName.Trim(); diskType = OricDisk.DiskTypes.Master; sides = 2; tracksPerSide = 40; sectorsPerTrack = 16; }
bool IsX86Architecture(string filePath) { ushort architecture = 0; try { using (System.IO.FileStream fStream = new System.IO.FileStream(filePath, System.IO.FileMode.Open, System.IO.FileAccess.Read)) { using (System.IO.BinaryReader bReader = new System.IO.BinaryReader(fStream)) { if (bReader.ReadUInt16() == 23117) { fStream.Seek(0x3A, System.IO.SeekOrigin.Current); fStream.Seek(bReader.ReadUInt32(), System.IO.SeekOrigin.Begin); if (bReader.ReadUInt32() == 17744) { fStream.Seek(20, System.IO.SeekOrigin.Current); architecture = bReader.ReadUInt16(); } } } } } catch { } if (architecture == 0x10b) { return(true); } else { return(false); } }
public override void Read(string file) { BinaryReader br = new BinaryReader(File.OpenRead(file)); uint file_size = (uint)br.BaseStream.Length; // Read header values ushort depth = br.ReadUInt16(); ushort width = br.ReadUInt16(); ushort height = br.ReadUInt16(); ushort unknown = br.ReadUInt16(); ColorFormat format = (depth == 0x01) ? ColorFormat.colors256 : ColorFormat.colors16; // Palette int palette_length = (depth == 0x01) ? 0x200 : 0x20; Color[][] colors = new Color[1][]; colors[0] = Actions.BGR555ToColor(br.ReadBytes(palette_length)); palette = new RawPalette(colors, false, format); // Tiles int tiles_length = width * height; if (depth == 0) tiles_length /= 2; Byte[] tiles = br.ReadBytes(tiles_length); br.Close(); Set_Tiles(tiles, width, height, format, TileForm.Lineal, true); }
// As found in .DAT archives (RESOURCE.DAT, IO.DAT) public void Load(string destinationDirectory, string baseName, BinaryReader binaryReader) { xOffset = binaryReader.ReadInt16(); yOffset = binaryReader.ReadInt16(); binaryReader.BaseStream.Seek(4, SeekOrigin.Current); width = binaryReader.ReadUInt16(); height = binaryReader.ReadUInt16(); binaryReader.BaseStream.Seek(2, SeekOrigin.Current); uint length = binaryReader.ReadUInt32(); var imageOffset = binaryReader.BaseStream.Position; var rowDataOffsets = new ushort[height]; for (int i = 0; i < height; ++i) { rowDataOffsets[i] = binaryReader.ReadUInt16(); } var bmp = new Bmp(width, height); var imageData = binaryReader.ReadBytes((int)length - 2*height); ReadImage(imageData, rowDataOffsets, false, bmp.Data); Debug.Assert(binaryReader.BaseStream.Position - imageOffset == length); bmp.Save(Path.Combine(destinationDirectory, baseName), ImageFormat); Bmp.SaveOffsets(baseName, xOffset, yOffset); }
/// <summary> /// Gets the name of the first model on a CGFX file. /// Returns null if the file doesn't contain any model. /// </summary> /// <param name="data"></param> /// <returns></returns> public static string getName(MemoryStream data) { BinaryReader input = new BinaryReader(data); cgfxHeader header = new cgfxHeader(); header.magic = IOUtils.readString(input, 0, 4); header.endian = input.ReadUInt16(); header.length = input.ReadUInt16(); header.revision = input.ReadUInt32(); header.fileLength = input.ReadUInt32(); header.entries = input.ReadUInt32(); data.Seek(header.length + 8, SeekOrigin.Begin); List<dictEntry> models = getDictionary(input); if (models.Count > 0) { data.Seek(models[0].dataOffset + 0xc, SeekOrigin.Begin); string name = IOUtils.readString(input, getRelativeOffset(input)); data.Close(); return name; } else { data.Close(); return null; } }
public InstallShieldPackage(string filename, int priority) { this.priority = priority; s = FileSystem.Open(filename); // Parse package header BinaryReader reader = new BinaryReader(s); uint signature = reader.ReadUInt32(); if (signature != 0x8C655D13) throw new InvalidDataException("Not an Installshield package"); reader.ReadBytes(8); /*var FileCount = */reader.ReadUInt16(); reader.ReadBytes(4); /*var ArchiveSize = */reader.ReadUInt32(); reader.ReadBytes(19); var TOCAddress = reader.ReadInt32(); reader.ReadBytes(4); var DirCount = reader.ReadUInt16(); // Parse the directory list s.Seek(TOCAddress, SeekOrigin.Begin); BinaryReader TOCreader = new BinaryReader(s); for (var i = 0; i < DirCount; i++) ParseDirectory(TOCreader); }
public async Task<ImageInfo[]> LoadFromDbAsync(string dbFileName) { var file = await FileSystem.Current.GetFileFromPathAsync(dbFileName).ConfigureAwait(false); if (file == null) throw new FileNotFoundException(); using (var fs = await file.OpenAsync(FileAccess.Read).ConfigureAwait(false)) using (var gz = new GZipStream(fs, CompressionMode.Decompress)) using (var br = new BinaryReader(gz)) { long count = br.ReadInt32(); _info = new ImageInfo[count]; for (var i = 0; i < count; i++) { var hash = br.ReadUInt64(); var titleId = br.ReadUInt16(); var episodeId = br.ReadUInt16(); var frame = br.ReadUInt32(); _info[i] = new ImageInfo { Hash = hash, TitleId = titleId, EpisodeId = episodeId, Frame = frame }; } } return _info; }
/// <summary> /// Read the end of the Zip64 central directory /// </summary> /// <returns>Status of the given stream</returns> private ZipReturn ReadZip64EndOfCentralDir() { // Set the type of the archive to Zip64 _zip64 = true; // Open the stream for reading BinaryReader br = new BinaryReader(_zipstream); // If the signature doesn't match, then return uint thisSignature = br.ReadUInt32(); if (thisSignature != Constants.Zip64EndOfCentralDirSignature) { return(ZipReturn.ZipEndOfCentralDirectoryError); } // If the size of the central dir record isn't right, return ulong tulong = br.ReadUInt64(); // Size of zip64 end of central directory record if (tulong != 44) { return(ZipReturn.Zip64EndOfCentralDirError); } br.ReadUInt16(); // version made by // If the version needed to extract isn't correct, return ushort tushort = br.ReadUInt16(); // version needed to extract if (tushort != (ushort)ArchiveVersion.TorrentZip64) { return(ZipReturn.Zip64EndOfCentralDirError); } // If this is part of a spanned archive, return uint tuint = br.ReadUInt32(); // number of this disk if (tuint != 0) { return(ZipReturn.Zip64EndOfCentralDirError); } tuint = br.ReadUInt32(); // number of the disk with the start of the central directory if (tuint != 0) { return(ZipReturn.Zip64EndOfCentralDirError); } // If the number of entries in the current disk doesn't match up with the total entries, return _entriesCount = (uint)br.ReadUInt64(); // total number of entries in the central directory on this disk tulong = br.ReadUInt64(); // total number of entries in the central directory if (tulong != _entriesCount) { return(ZipReturn.Zip64EndOfCentralDirError); } _centerDirSize = br.ReadUInt64(); // size of central directory _centerDirStart = br.ReadUInt64(); // offset of start of central directory with respect to the starting disk number return(ZipReturn.ZipGood); }
public MixFile(string filename, int priority) { this.priority = priority; s = FileSystem.Open(filename); // Detect format type s.Seek(0, SeekOrigin.Begin); var reader = new BinaryReader(s); var isCncMix = reader.ReadUInt16() != 0; // The C&C mix format doesn't contain any flags or encryption var isEncrypted = false; if (!isCncMix) isEncrypted = (reader.ReadUInt16() & 0x2) != 0; List<PackageEntry> entries; if (isEncrypted) { long unused; entries = ParseHeader(DecryptHeader(s, 4, out dataStart), 0, out unused); } else entries = ParseHeader(s, isCncMix ? 0 : 4, out dataStart); index = entries.ToDictionaryWithConflictLog(x => x.Hash, "{0} ({1} format, Encrypted: {2}, DataStart: {3})".F(filename, (isCncMix ? "C&C" : "RA/TS/RA2"), isEncrypted, dataStart), null, x => "(offs={0}, len={1})".F(x.Offset, x.Length) ); }
internal static void ReadCustomData(Player player, BinaryReader reader) { int count = reader.ReadUInt16(); for (int k = 0; k < count; k++) { string modName = reader.ReadString(); string name = reader.ReadString(); byte[] data = reader.ReadBytes(reader.ReadUInt16()); Mod mod = ModLoader.GetMod(modName); ModPlayer modPlayer = mod == null ? null : player.GetModPlayer(mod, name); if (modPlayer != null) { using (MemoryStream stream = new MemoryStream(data)) { using (BinaryReader customReader = new BinaryReader(stream)) { modPlayer.LoadCustomData(customReader); } } if (modName == "ModLoader" && name == "MysteryPlayer") { ((MysteryPlayer)modPlayer).RestoreData(player); } } else { ModPlayer mystery = player.GetModPlayer(ModLoader.GetMod("ModLoader"), "MysteryPlayer"); ((MysteryPlayer)mystery).AddData(modName, name, data); } } }
public void Deserialize(byte[] buffer) { if (buffer.Length == 240) { MemoryStream MS = new MemoryStream(buffer); BinaryReader BR = new BinaryReader(MS); ushort length = BR.ReadUInt16(); if (length == 240) { ushort type = BR.ReadUInt16(); if (type == 1124) { Username = Encoding.ASCII.GetString(BR.ReadBytes(16)); Username = Username.Replace("\0", ""); BR.ReadBytes(112); Password = Encoding.ASCII.GetString(BR.ReadBytes(16)); BR.ReadBytes(112); Server = Encoding.ASCII.GetString(BR.ReadBytes(16)); Server = Server.Replace("\0", ""); } } BR.Close(); MS.Close(); } }
public Metadata(BinaryReader reader) { magic = reader.ReadUInt32(); if (magic != 0x424A5342) return; offset = (uint)reader.BaseStream.Position - 4; majorVersion = reader.ReadUInt16(); minorVersion = reader.ReadUInt16(); reserved = reader.ReadUInt32(); versionString = readString(reader, reader.ReadInt32()); flags = reader.ReadUInt16(); int numStreams = reader.ReadUInt16(); streams = new DotNetStream[numStreams]; uint lastOffset = offset; for (int i = 0; i < numStreams; i++) { uint fileOffset = offset + reader.ReadUInt32(); uint size = reader.ReadUInt32(); string name = readAsciizString(reader); streams[i] = new DotNetStream(name, fileOffset, size); lastOffset = Math.Max(lastOffset, fileOffset + size); } lastOffset = Math.Max(lastOffset, (uint)reader.BaseStream.Position); length = lastOffset - offset; headerLength = (uint)reader.BaseStream.Position - offset; }
protected override void ReadContentFrom(BinaryReader input) { //https://www.microsoft.com/typography/otspec/cmap.htm long beginAt = input.BaseStream.Position; // ushort version = input.ReadUInt16(); // 0 ushort tableCount = input.ReadUInt16(); var entries = new CMapEntry[tableCount]; for (int i = 0; i < tableCount; i++) { ushort platformId = input.ReadUInt16(); ushort encodingId = input.ReadUInt16(); uint offset = input.ReadUInt32(); entries[i] = new CMapEntry(platformId, encodingId, offset); } charMaps = new CharacterMap[tableCount]; for (int i = 0; i < tableCount; i++) { CMapEntry entry = entries[i]; input.BaseStream.Seek(beginAt + entry.Offset, SeekOrigin.Begin); CharacterMap cmap = charMaps[i] = ReadCharacterMap(entry, input); cmap.PlatformId = entry.PlatformId; cmap.EncodingId = entry.EncodingId; } }
internal NameResolutionRecord(BinaryReader reader) { UInt16 type = reader.ReadUInt16(); int valueLength = reader.ReadUInt16(); if (type != EndRecordType) { int entriesLength = valueLength; if (type == Ip6RecordType) { this.IsIpVersion6 = true; this.IpAddress = reader.ReadBytes(Ip6Length); entriesLength -= Ip6Length; } else { this.IsIpVersion6 = false; this.IpAddress = reader.ReadBytes(Ip4Length); entriesLength -= Ip4Length; } this.DnsEntries = this.ReadDnsEntries(reader, entriesLength); int remainderLength = valueLength % ValueAlignmentBoundary; if (remainderLength > 0) { reader.ReadBytes(ValueAlignmentBoundary - remainderLength); // Read fill bytes to boundary. } } }
public static ushort GetPEArchitecture(string pFilePath) { ushort architecture = 0; try { using (System.IO.FileStream fStream = new System.IO.FileStream(pFilePath, System.IO.FileMode.Open, System.IO.FileAccess.Read)) { using (System.IO.BinaryReader bReader = new System.IO.BinaryReader(fStream)) { if (bReader.ReadUInt16() == 23117) //check the MZ signature { fStream.Seek(0x3A, System.IO.SeekOrigin.Current); //seek to e_lfanew. fStream.Seek(bReader.ReadUInt32(), System.IO.SeekOrigin.Begin); //seek to the start of the NT header. if (bReader.ReadUInt32() == 17744) //check the PE\0\0 signature. { fStream.Seek(20, System.IO.SeekOrigin.Current); //seek past the file header, architecture = bReader.ReadUInt16(); //read the magic number of the optional header. } } } } } catch (Exception) { return(0); } //if architecture returns 0, there has been an error. return(architecture); }
public static bool Is64BitNativeDll(string filePath) { if (!System.IO.File.Exists(filePath)) { return(false); } ushort architecture = 0; using (System.IO.FileStream fStream = new System.IO.FileStream(filePath, System.IO.FileMode.Open, System.IO.FileAccess.Read)) { using (System.IO.BinaryReader bReader = new System.IO.BinaryReader(fStream)) { if (bReader.ReadUInt16() == 23117) { fStream.Seek(0x3A, System.IO.SeekOrigin.Current); fStream.Seek(bReader.ReadUInt32(), System.IO.SeekOrigin.Begin); if (bReader.ReadUInt32() == 17744) { fStream.Seek(20, System.IO.SeekOrigin.Current); architecture = bReader.ReadUInt16(); } } } } return(architecture == 0x20b); }
public OBJf(IffChunk Chunk) : base(Chunk) { MemoryStream MemStream = new MemoryStream(Chunk.Data); BinaryReader Reader = new BinaryReader(MemStream); //Unknown + version (always 0) Reader.ReadBytes(8); string Header = Encoding.ASCII.GetString(Reader.ReadBytes(4)); if (Header != "fJBO") return; //Error? This shouldn't occur... m_NumEntries = Reader.ReadInt32(); for (int i = 0; i < m_NumEntries; i++) { IDPair FuncIDs = new IDPair(); FuncIDs.GuardFuncID = Reader.ReadUInt16(); FuncIDs.FunctionID = Reader.ReadUInt16(); m_FuncIDs.Add(FuncIDs); } }
public override void Read(Stream input) { BinaryReader reader = new BinaryReader(input, Encoding.Default, true); uint magicNumber1 = reader.ReadUInt32(); // foxf ushort magicNumber2 = reader.ReadUInt16(); // pk FpkType = (FpkType) reader.ReadByte(); // ' ' or 'd' byte magicNumber3 = reader.ReadByte(); // w ushort magicNumber4 = reader.ReadUInt16(); // in uint fileSize = reader.ReadUInt32(); reader.Skip(18); uint magicNumber5 = reader.ReadUInt32(); // 2 uint fileCount = reader.ReadUInt32(); uint referenceCount = reader.ReadUInt32(); reader.Skip(4); for (int i = 0; i < fileCount; i++) { Entries.Add(FpkEntry.ReadFpkEntry(input)); } for (int i = 0; i < referenceCount; i++) { References.Add(FpkReference.ReadFpkReference(input)); } }
public FaceGroup(BinaryReader reader) { Min = new Vector3(reader); Max = new Vector3(reader); StartFace = reader.ReadUInt16(); EndFace = reader.ReadUInt16(); }
/// <summary> /// Initialize an instance of this structure by reading it from the given <see cref="BinaryReader"/>. /// </summary> /// <param name="reader">The <see cref="BinaryReader"/> to read the structure from.</param> internal RWTriangle(BinaryReader reader) { C = reader.ReadUInt16(); B = reader.ReadUInt16(); MatID = reader.ReadInt16(); A = reader.ReadUInt16(); }
public WowCorePacketReader(string filename) { _reader = new BinaryReader(new FileStream(filename, FileMode.Open, FileAccess.Read), Encoding.ASCII); _reader.ReadBytes(3); // PKT Version = _reader.ReadUInt16(); // sniff version (0x0201, 0x0202) ushort build; switch (Version) { case 0x0201: build = _reader.ReadUInt16(); // build _reader.ReadBytes(40); // session key break; case 0x0202: _reader.ReadByte(); // 0x06 build = _reader.ReadUInt16(); // build _reader.ReadBytes(4); // client locale _reader.ReadBytes(20); // packet key _reader.ReadBytes(64); // realm name break; case 0x0300: _reader.ReadByte(); // snifferId build = (ushort)_reader.ReadUInt32();// client build _reader.ReadBytes(4); // client locale _reader.ReadBytes(40); // session key var optionalHeaderLength = _reader.ReadInt32(); _reader.ReadBytes(optionalHeaderLength); break; default: throw new Exception(String.Format("Unknown sniff version {0:X2}", Version)); } UpdateFieldsLoader.LoadUpdateFields(build); }
public void Load(string destinationDirectory, string resourceName, BinaryReader binaryReader) { binaryReader.BaseStream.Seek(2, SeekOrigin.Current); uint length = binaryReader.ReadUInt32(); byte[] imageData = binaryReader.ReadBytes((int)length); short xOffset = binaryReader.ReadInt16(); short yOffset = binaryReader.ReadInt16(); ushort width = binaryReader.ReadUInt16(); ushort height = binaryReader.ReadUInt16(); binaryReader.BaseStream.Seek(8, SeekOrigin.Current); var bmp = new Bmp(width, height); var colorData = bmp.Data; var palette = PaletteLoader.DefaultPalette; int index = 0; for (int y = 0; y < height; ++y) { for (int x = 0; x < width; ++x) { colorData[y, x] = palette.Colors[imageData[index]]; ++index; } } bmp.Save(Path.Combine(destinationDirectory, resourceName), ImageFormat); Bmp.SaveOffsets(resourceName, xOffset, yOffset); }
/// <summary> /// č·åęå®ę件ēę¶ęä½ę° 523-64ä½, 267-32ä½/AnyCpu /// </summary> /// <param name="filePath"></param> /// <returns></returns> private static ushort GetPEArchitecture(string filePath) { ushort architecture = 0; try { using (System.IO.FileStream fStream = new System.IO.FileStream(filePath, System.IO.FileMode.Open, System.IO.FileAccess.Read)) { using (System.IO.BinaryReader bReader = new System.IO.BinaryReader(fStream)) { if (bReader.ReadUInt16() == 23117) //check the MZ signature { //Any CPU PE32 with 32BIT = 0 //x86 PE32 with 32BIT = 1 //x64 / Itanium(IA - 64) PE32 + with 32BIT = 0 fStream.Seek(0x3A, System.IO.SeekOrigin.Current); //seek to e_lfanew. fStream.Seek(bReader.ReadUInt32(), System.IO.SeekOrigin.Begin); //seek to the start of the NT header. if (bReader.ReadUInt32() == 17744) //check the PE\0\0 signature. { fStream.Seek(20, System.IO.SeekOrigin.Current); //seek past the file header, architecture = bReader.ReadUInt16(); //read the magic number of the optional header. } } } } } catch (Exception ex) { /* TODO: Any exception handling you want to do, personally I just take 0 as a sign of failure */ } //if architecture returns 0, there has been an error. return(architecture); }
protected override void ReadContentFrom(BinaryReader reader) { //USHORT version Version number (0 or 1). //USHORT numRecs Number of VDMX groups present //USHORT numRatios Number of aspect ratio groupings //Ratio ratRange[numRatios] Ratio ranges (see below for more info) //USHORT offset[numRatios] Offset from start of this table to the VDMX group for this ratio range. //Vdmx groups The actual VDMX groupings (documented below) //Ratio Record Type Name Description //BYTE bCharSet Character set (see below). //BYTE xRatio Value to use for x-Ratio //BYTE yStartRatio Starting y-Ratio value. //BYTE yEndRatio Ending y-Ratio value. ushort version = reader.ReadUInt16(); ushort numRecs = reader.ReadUInt16(); ushort numRatios = reader.ReadUInt16(); ratios = new Ratio[numRatios]; for (int i = 0; i < numRatios; ++i) { ratios[i] = new Ratio( reader.ReadByte(), reader.ReadByte(), reader.ReadByte(), reader.ReadByte()); } short[] offsets = Utils.ReadInt16Array(reader, numRatios); //------ //actual vdmx group //TODO: implement this }
public MapInfo(BinaryReader reader) { Index = reader.ReadInt32(); FileName = reader.ReadString(); Title = reader.ReadString(); MiniMap = reader.ReadUInt16(); Light = (LightSetting) reader.ReadByte(); if (Envir.LoadVersion >= 3) BigMap = reader.ReadUInt16(); if (Envir.LoadVersion >= 10) reader.ReadByte(); int count = reader.ReadInt32(); for (int i = 0; i < count; i++) SafeZones.Add(new SafeZoneInfo(reader) { Info = this }); count = reader.ReadInt32(); for (int i = 0; i < count; i++) Respawns.Add(new RespawnInfo(reader)); count = reader.ReadInt32(); for (int i = 0; i < count; i++) NPCs.Add(new NPCInfo(reader)); count = reader.ReadInt32(); for (int i = 0; i < count; i++) Movements.Add(new MovementInfo(reader)); }
public FaceInfo( BinaryReader reader ) { Vertex1 = reader.ReadUInt16(); Vertex0 = reader.ReadUInt16(); Flags = (GeometryFlag) reader.ReadUInt16(); Vertex2 = reader.ReadUInt16(); }
public IEnumerable<Packet> ReadPackets(string file) { using (var gr = new BinaryReader(new FileStream(file, FileMode.Open, FileAccess.Read), Encoding.ASCII)) { gr.ReadBytes(3); // PKT gr.ReadBytes(2); // 0x02, 0x02 gr.ReadByte(); // 0x06 Build = gr.ReadUInt16(); // build gr.ReadBytes(4); // client locale gr.ReadBytes(20); // packet key gr.ReadBytes(64); // realm name var packets = new List<Packet>(); while (gr.PeekChar() >= 0) { Direction direction = gr.ReadByte() == 0xff ? Direction.Server : Direction.Client; uint unixtime = gr.ReadUInt32(); uint tickcount = gr.ReadUInt32(); uint size = gr.ReadUInt32(); OpCodes opcode = (direction == Direction.Client) ? (OpCodes)gr.ReadUInt32() : (OpCodes)gr.ReadUInt16(); byte[] data = gr.ReadBytes((int)size - ((direction == Direction.Client) ? 4 : 2)); packets.Add(new Packet(direction, opcode, data, unixtime, tickcount)); } return packets; } }
public static CpuArchitectures GetPEArchitecture(string pFilePath) { ushort architecture = 0; ushort[] coffHeader = new ushort[10]; using (FileStream fStream = new FileStream(pFilePath, FileMode.Open, FileAccess.Read)) { using (BinaryReader bReader = new BinaryReader(fStream)) { if (bReader.ReadUInt16() == 23117) //check the MZ signature { fStream.Seek(0x3A, SeekOrigin.Current); // Go to the location of the location of the NT header fStream.Seek(bReader.ReadUInt32(), SeekOrigin.Begin); // seek to the start of the NT header. if (bReader.ReadUInt32() == 17744) //check the PE\0\0 signature. { for (int i = 0; i < 10; i++) // Read COFF Header coffHeader[i] = bReader.ReadUInt16(); if (coffHeader[8] > 0) // Read Optional Header architecture = bReader.ReadUInt16(); } } } } switch (architecture) { case 0x20b: return CpuArchitectures.x64; case 0x10b: return ((coffHeader[9] & 0x100) == 0) ? CpuArchitectures.AnyCpu : CpuArchitectures.x86; default: return CpuArchitectures.Unknown; } }
private void listBox1_SelectedIndexChanged(object sender, EventArgs e) { var fileStream = new FileStream(bldPath + "\\" + "model" + "\\" + listBox1.SelectedIndex.ToString("D4"), FileMode.Open); file_2 = bldPath + "\\" + "model" + "\\" + listBox1.SelectedIndex.ToString("D4"); _nsbmd = NsbmdLoader.LoadNsbmd(fileStream); if (!checkBox1.Checked) { _nsbmd.materials = LibNDSFormats.NSBTX.NsbtxLoader.LoadNsbtx(new MemoryStream(File.ReadAllBytes(Form1.workingFolder + @"data\a\1\7\bldtilesets" + "\\" + comboBox1.SelectedIndex.ToString("D4"))), out _nsbmd.Textures, out _nsbmd.Palettes); } else { _nsbmd.materials = LibNDSFormats.NSBTX.NsbtxLoader.LoadNsbtx(new MemoryStream(File.ReadAllBytes(Form1.workingFolder + @"data\a\1\7\bld2tilesets" + "\\" + comboBox1.SelectedIndex.ToString("D4"))), out _nsbmd.Textures, out _nsbmd.Palettes); } try { _nsbmd.MatchTextures(); } catch { } RenderBuilding(null, null); fileStream.Close(); System.IO.BinaryReader readHeader = new System.IO.BinaryReader(File.OpenRead(bldPath + "\\" + "header" + "\\" + listBox1.SelectedIndex.ToString("D4"))); numericUpDown1.Value = readHeader.ReadUInt16(); // ID readHeader.BaseStream.Position += 2; numericUpDown2.Value = readHeader.ReadUInt16(); // Door ID numericUpDown3.Value = readHeader.ReadInt16(); // X numericUpDown4.Value = readHeader.ReadInt16(); // Y numericUpDown5.Value = readHeader.ReadInt16(); // Z readHeader.Close(); }
/// <summary> /// Constructs a new <see cref="Key"/> instance. /// </summary> /// <param name="encodedText">The encoded Licence text.</param> public Key(String encodedText) { _encodedText = encodedText; try { using (BinaryReader reader = new BinaryReader( new MemoryStream(Base32.Decode(encodedText)))) { // Get the Licence data from the reader. LicenceId = reader.ReadInt32(); _startDateOffset = reader.ReadUInt16(); _endDateOffset = reader.ReadUInt16(); byte productCount = reader.ReadByte(); for (int i = 0; i < productCount; i++) { _products.Add(new Product(reader)); } // Validate the signature that follows the Licence data. _isValid = DSAVerifyHash( new SHA1CryptoServiceProvider().ComputeHash(ToArray()), reader.ReadBytes(reader.ReadByte()), LicenceConstants.PublicKey, "SHA1"); } } catch { _isValid = false; } }
public PosTbl(Stream si) { var binaryReader = new BinaryReader(si); int num = tbloff - 144; si.Position = num + 160; va0 = binaryReader.ReadUInt16(); va2 = binaryReader.ReadUInt16(); si.Position = num + 168; va8 = binaryReader.ReadInt32(); vac = binaryReader.ReadInt32(); si.Position = num + 176; vb0 = binaryReader.ReadInt32(); vb4 = binaryReader.ReadInt32(); vb8 = binaryReader.ReadInt32(); si.Position = num + 192; vc0 = binaryReader.ReadInt32(); vc4 = binaryReader.ReadInt32(); vc8 = binaryReader.ReadInt32(); vcc = binaryReader.ReadInt32(); si.Position = num + 208; vd0 = binaryReader.ReadInt32(); vd4 = binaryReader.ReadInt32(); vd8 = binaryReader.ReadInt32(); vdc = binaryReader.ReadInt32(); si.Position = num + 224; ve0 = binaryReader.ReadInt32(); ve4 = binaryReader.ReadInt32(); ve8 = binaryReader.ReadInt32(); vec = binaryReader.ReadInt32(); si.Position = num + 240; vf0 = binaryReader.ReadInt32(); vf4 = binaryReader.ReadInt32(); vf8 = binaryReader.ReadInt32(); vfc = binaryReader.ReadInt32(); }
/// <summary> Creates a new glyph variant record by reading it from the specified stream. </summary> /// <param name="reader"> The correctly positioned stream to read from. </param> public GlyphVariantRecord(BinaryReader reader) { Contract.Requires(reader != null); Glyph = reader.ReadUInt16(); AdvanceMeasurement = reader.ReadUInt16(); }
/// <summary> /// /// </summary> /// <param name="input"></param> public void Parse(Stream input) { BinaryReader br = new BinaryReader(input); _FrameSize = new Rect(this.Version); _FrameSize.Parse(input); _FrameRateDelay = br.ReadUInt16(); _FrameRate = (_FrameRateDelay >> 8) + ((_FrameRateDelay & 0xFF) / 100); _FrameCount = br.ReadUInt16(); int x = Math.Abs((this._FrameSize.Xmax - this._FrameSize.Xmin) / 12); int y = Math.Abs((this._FrameSize.Ymax - this._FrameSize.Ymin) / 12); if (x > SwfFile.Configuration.MaximumStageSizeX) { Log.Warn(this, "The x value(" + x + ") of the stage exceeds the allowed maximum."); } if (x < SwfFile.Configuration.MinimumStageSizeX) { Log.Warn(this, "The x value(" + x + ") of the stage under-runs the allowed minimum."); } if (y > SwfFile.Configuration.MaximumStageSizeY) { Log.Warn(this, "The y value(" + y + ") of the stage exceeds the allowed maximum."); } if (y < SwfFile.Configuration.MinimumStageSizeY) { Log.Warn(this, "The y value(" + y + ") of the stage under-runs the allowed minimum."); } }
public override void Read(string file) { BinaryReader br = new BinaryReader(File.OpenRead(file)); ushort num_tiles = br.ReadUInt16(); ushort depth = br.ReadUInt16(); ColorFormat format = (depth == 0x01 ? ColorFormat.colors256 : ColorFormat.colors16); if (br.BaseStream.Length - 4 == num_tiles * 0x40) format = ColorFormat.colors256; Byte[] tiles = br.ReadBytes(num_tiles * (0x20 + 0x20 * depth)); int width = 64; if (num_tiles == 0x10) width = 32; int height = tiles.Length / width; if (depth == 0) height *= 2; br.Close(); Set_Tiles(tiles, width, height, format, TileForm.Horizontal, true); pluginHost.Set_Image(this); // If the image is 8bpp, convert to 8bpp the palette (4bpp per default) PaletteBase palette = pluginHost.Get_Palette(); if (palette.Loaded && format == ColorFormat.colors256) { palette.Depth = ColorFormat.colors256; pluginHost.Set_Palette(palette); } }
public override object ReadScalarValue(System.IO.BinaryReader br) { VTPropertyType vType = (VTPropertyType)br.ReadUInt16(); br.ReadUInt16(); // Ushort Padding ITypedPropertyValue p = PropertyFactory.Instance.NewProperty(vType, codePage, true); p.Read(br); return(p); }
public static sSWAV Read(string path) { /***Lectura del archivo SWAV***/ System.IO.FileStream fs = null; System.IO.BinaryReader br = null; sSWAV swav = new sSWAV(); try { fs = new System.IO.FileStream(path, System.IO.FileMode.Open); br = new System.IO.BinaryReader(fs); //Leer Header swav.header.type = Encoding.ASCII.GetChars(br.ReadBytes(4)); swav.header.magic = br.ReadUInt32(); swav.header.nFileSize = br.ReadUInt32(); swav.header.nSize = br.ReadUInt16(); swav.header.nBlock = br.ReadUInt16(); //Leer Data swav.data.type = Encoding.ASCII.GetChars(br.ReadBytes(4)); swav.data.nSize = br.ReadUInt32(); {//Leer Info swav.data.info.nWaveType = br.ReadByte(); swav.data.info.bLoop = br.ReadByte(); swav.data.info.nSampleRate = br.ReadUInt16(); swav.data.info.nTime = br.ReadUInt16(); swav.data.info.nLoopOffset = br.ReadUInt16(); swav.data.info.nNonLoopLen = br.ReadUInt32(); } //Leer resto de Data uint tamaƱoDatos = (uint)(br.BaseStream.Length - br.BaseStream.Position); swav.data.data = br.ReadBytes((int)tamaƱoDatos); } catch (Exception ex) { System.Console.WriteLine(ex.Message.ToString()); } finally { if (fs != null) { fs.Close(); } if (br != null) { br.Close(); } } return(swav); }
public void Load(System.IO.BinaryReader reader) { version = reader.ReadByte(); if (version > VERSION) { throw new CacheException("Unknown CacheItem Version.", null, version); } name = reader.ReadString(); if (version >= 2) { objdname = reader.ReadString(); } else { objdname = null; } if (version >= 3) { int ct = reader.ReadUInt16(); valuenames = new string[ct]; for (int i = 0; i < ct; i++) { valuenames[i] = reader.ReadString(); } } else { valuenames = new string[0]; } type = (SimPe.Data.ObjectTypes)reader.ReadUInt16(); pfd = new Packages.PackedFileDescriptor(); pfd.Type = reader.ReadUInt32(); pfd.Group = reader.ReadUInt32(); pfd.LongInstance = reader.ReadUInt64(); guid = reader.ReadUInt32(); int size = reader.ReadInt32(); if (size == 0) { thumb = null; } else { byte[] data = reader.ReadBytes(size); MemoryStream ms = new MemoryStream(data); thumb = Image.FromStream(ms); } }
private static void ReadVarFileInfo(System.IO.BinaryReader reader) { ushort us; string s; us = reader.ReadUInt16(); us = reader.ReadUInt16(); //0 us = reader.ReadUInt16(); //1 s = ReadString(reader); //"Translation" reader.BaseStream.Position = (reader.BaseStream.Position + 3) & ~3; //round up to 32bit boundary us = reader.ReadUInt16(); //langId; MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL)) = 0 us = reader.ReadUInt16(); //codepage; 1200 = CP_WINUNICODE }
/// <summary> /// Read the end of the central directory /// </summary> /// <returns>Status of the given stream</returns> private ZipReturn ReadEndOfCentralDir() { // Open the stream for reading BinaryReader br = new BinaryReader(_zipstream); // If the stream doesn't start with the correct signature, return uint thisSignature = br.ReadUInt32(); if (thisSignature != Constants.EndOfCentralDirSignature) { return(ZipReturn.ZipEndOfCentralDirectoryError); } // If this is part of a spanned archive, return ushort tushort = br.ReadUInt16(); // NumberOfThisDisk if (tushort != 0) { return(ZipReturn.ZipEndOfCentralDirectoryError); } tushort = br.ReadUInt16(); // NumberOfThisDiskCenterDir if (tushort != 0) { return(ZipReturn.ZipEndOfCentralDirectoryError); } // If the number of entries in the current disk doesn't match up with the total entries, return _entriesCount = br.ReadUInt16(); // TotalNumberOfEntriesDisk tushort = br.ReadUInt16(); // TotalNumber of entries in the central directory if (tushort != _entriesCount) { return(ZipReturn.ZipEndOfCentralDirectoryError); } _centerDirSize = br.ReadUInt32(); // SizeOfCenteralDir _centerDirStart = br.ReadUInt32(); // Offset // Get the file comment ushort zipFileCommentLength = br.ReadUInt16(); _fileComment = br.ReadBytes(zipFileCommentLength); // If there's extra data past the comment, flag that we have extra data if (_zipstream.Position != _zipstream.Length) { _zipStatus |= ZipStatus.ExtraData; } return(ZipReturn.ZipGood); }
private void ReadBitmap1() { // Read the System sector Byte[] sectorData = base.ReadSector(20, 2); System.IO.MemoryStream stm = new System.IO.MemoryStream(sectorData, 0, sectorData.Length); System.IO.BinaryReader rdr = new System.IO.BinaryReader(stm); Byte[] bByteArray = rdr.ReadBytes(2); sectorsFree = rdr.ReadUInt16(); noOfFiles = rdr.ReadUInt16(); tracksPerSide = rdr.ReadByte(); sectorsPerTrack = rdr.ReadByte(); noOfDirectories = rdr.ReadByte(); bByteArray = rdr.ReadBytes(1); if ((bByteArray[0] & 0x80) == 0x80) { sides = 2; } else { sides = 1; } bByteArray = rdr.ReadBytes(1); if (bByteArray[0] == 0) { diskType = DiskTypes.Master; } else if (bByteArray[0] == 0x01) { diskType = DiskTypes.Slave; } else if (bByteArray[0] == 0x47) { diskType = DiskTypes.Game; } else { diskType = DiskTypes.Unknown; } sectors = (ushort)((sectorsPerTrack * tracksPerSide) * sides); sectorsUsed = (ushort)(sectors - sectorsFree); }
public override Resource Load(System.IO.BinaryReader reader, string name, LoaderFileOpener opener, Resource context) { reader.Require(Magic); var contentSize = reader.ReadInt32(); // total size - header size reader.Require(1); reader.Require(0); reader.Require(0x80); // headerSize if (contentSize + 0x80 != reader.BaseStream.Length) { throw new Exception(); } reader.Require(contentSize); // contentSize2 reader.Require(0x85040201); reader.Require(0xAAE4); int width = reader.ReadUInt16(); int height = reader.ReadUInt16(); reader.Require((ushort)1); reader.RequireZeroes(90); if (width != height) { throw new InvalidDataException("Width and height must be equal for a cube map."); } TextureCube cube = new TextureCube(); //cube.Storage( //cube., width, TextureFormats.Vector4nb); throw new NotImplementedException(); /* * byte[] data = new byte[width * height * 4]; * * foreach (CubeFace face in TextureCube.Faces) { * int lod = 0; * * for (int size = width; size >= 8; size /= 2, lod++) { * reader.Read(data, 0, size * size * 4); * cube.SetData(face, lod, Box2i.CreateSize(size, size), data); * } * * cube.MaxLod = lod - 1; * } * * return new TextureResource(Manager, cube, name);*/ }
//Support to convert RSA key from PEM to XML, currently RSACryptoServiceProvider only support XML format. private static System.Security.Cryptography.RSAParameters ConvertPemToXmlFormat(string privateKey) { var privateKeyBits = System.Convert.FromBase64String(privateKey); var rsaParams = new System.Security.Cryptography.RSAParameters(); using (var binr = new System.IO.BinaryReader(new System.IO.MemoryStream(privateKeyBits))) { byte bt = 0; ushort twobytes = 0; twobytes = binr.ReadUInt16(); if (twobytes == 0x8130) { binr.ReadByte(); } else if (twobytes == 0x8230) { binr.ReadInt16(); } else { throw new Exception("Unexpected value read binr.ReadUInt16()"); } twobytes = binr.ReadUInt16(); if (twobytes != 0x0102) { throw new Exception("Unexpected version"); } bt = binr.ReadByte(); if (bt != 0x00) { throw new Exception("Unexpected value read binr.ReadByte()"); } rsaParams.Modulus = binr.ReadBytes(GetIntegerSize(binr)); rsaParams.Exponent = binr.ReadBytes(GetIntegerSize(binr)); rsaParams.D = binr.ReadBytes(GetIntegerSize(binr)); rsaParams.P = binr.ReadBytes(GetIntegerSize(binr)); rsaParams.Q = binr.ReadBytes(GetIntegerSize(binr)); rsaParams.DP = binr.ReadBytes(GetIntegerSize(binr)); rsaParams.DQ = binr.ReadBytes(GetIntegerSize(binr)); rsaParams.InverseQ = binr.ReadBytes(GetIntegerSize(binr)); } return(rsaParams); }
private WaveFormat GetWaveFormat(System.IO.BinaryReader br) { WaveFormat format = new WaveFormat(); int formatChunkLength = br.ReadInt32(); if (formatChunkLength < 16) { throw new ApplicationException("Invalid WaveFormat Structure"); } format.FormatTag = (WaveFormatTag)br.ReadUInt16(); format.Channels = br.ReadInt16(); format.SamplesPerSecond = br.ReadInt32(); format.AverageBytesPerSecond = br.ReadInt32(); format.BlockAlignment = br.ReadInt16(); format.BitsPerSample = br.ReadInt16(); short extraSize = 0; if (formatChunkLength > 16) { extraSize = br.ReadInt16(); if (extraSize > formatChunkLength - 18) { Console.WriteLine("Format chunk mismatch"); //RRL GSM exhibits this bug. Don't throw an exception //throw new ApplicationException("Format chunk length mismatch"); extraSize = (short)(formatChunkLength - 18); } // read any extra data // br.ReadBytes(extraSize); } return(format); }
private void ParseQuestData(string fileName) { QuestData = new Dictionary <ushort, Quest>(); using (var stream = new MemoryStream(File.ReadAllBytes(fileName))) using (var reader = new System.IO.BinaryReader(stream)) { header = reader.ReadUInt16(); var count = reader.ReadInt16(); for (var i = 0; i < count; i++) { var size = reader.ReadInt32(); var data = reader.ReadBytes(size - 4); var parsed = Quest.Parse(data); if (parsed == null) { MessageBox.Show("Failed to parse QuestData.shn"); return; } QuestData.Add(parsed.ID, parsed); } } }
public static string ReadUTF(System.IO.BinaryReader input) { ushort len = input.ReadUInt16(); byte[] data = input.ReadBytes(len); return(System.Text.Encoding.UTF8.GetString(data)); }
public static void Main(Client client) { //byte property = 2; var property = Enums.ObjectPropertiesFlags.IsTopOrder1; string datPath = client.TibiaProcess.MainModule.FileName; datPath = datPath.Substring(0, datPath.LastIndexOf('\\') + 1) + "Tibia.dat"; if (!File.Exists(datPath)) { return; } ushort count = 0; using (FileStream fstream = File.OpenRead(datPath)) { System.IO.BinaryReader reader = new System.IO.BinaryReader(fstream); reader.ReadUInt32(); // file signature count = (ushort)(reader.ReadUInt16() - 100); // item ids start at 100 } string s = string.Empty; for (int i = 0; i < count; i++) { var flag = client.GetObjectProperty((ushort)(i + 100)); if (!flag.HasFlag(property)) { continue; } s += (i + 100) + "\n"; //Thread.Sleep(2); } File.WriteAllText("items with " + property + ".txt", s); }
internal PdfFont(System.IO.BinaryReader reader) { _fontName = reader.ReadString(); _fullName = reader.ReadString(); _familyName = reader.ReadString(); _weight = reader.ReadString(); _isCIDFont = reader.ReadBoolean(); _italicAngle = reader.ReadDouble(); _isFixedPitch = reader.ReadBoolean(); _characterSet = reader.ReadString(); _fontBBox = new AfmRectangle(reader); _underlinePosition = reader.ReadInt16(); _underlineThickness = reader.ReadInt16(); _capHeight = reader.ReadInt16(); _xheight = reader.ReadInt16(); _ascender = reader.ReadInt16(); _descender = reader.ReadInt16(); _stdHW = reader.ReadInt16(); _stdVW = reader.ReadInt16(); _charMetric = new AfmCharMetric[65536]; UInt16 pos; while ((pos = reader.ReadUInt16()) != 0) { _charMetric[pos] = new AfmCharMetric(reader); } }
static int ReadUInt16(IntPtr L) { LuaScriptMgr.CheckArgsCount(L, 1); System.IO.BinaryReader obj = (System.IO.BinaryReader)LuaScriptMgr.GetNetObjectSelf(L, 1, "System.IO.BinaryReader"); ushort o = obj.ReadUInt16(); LuaScriptMgr.Push(L, o); return(1); }
/// <summary> /// Default Map Constructor /// </summary> /// <param name="Number">Map Number</param> /// <param name="Width">Map Width</param> /// <param name="Height">Map Height</param> public Map(ushort Number, ushort Width, ushort Height) { try { System.IO.FileStream FS = System.IO.File.OpenRead(DAFolder + @"\Maps\lod" + Number.ToString() + ".map"); System.IO.BinaryReader Reader = new System.IO.BinaryReader(FS); BaseMatrix = new byte[Width, Height]; for (int y = 0; y < Height; y++) { for (int x = 0; x < Width; x++) { Reader.ReadUInt16(); BaseMatrix[x, y] = (byte)(CheckSOTP(Reader.ReadUInt16(), Reader.ReadUInt16()) ? 0x00 : 0x01); } } Entities = new Dictionary <uint, MapEntity>(); } catch { } }
private static void loadGk3Bitmap(System.IO.BinaryReader reader, out byte[] pixels, out int width, out int height, out bool containsAlpha) { const string errorMessage = "This is not a valid GK3 bitmap"; containsAlpha = false; uint header = reader.ReadUInt32(); if (header != Gk3BitmapHeader) { throw new Resource.InvalidResourceFileFormat(errorMessage); } height = reader.ReadUInt16(); width = reader.ReadUInt16(); pixels = new byte[width * height * 4]; byte r, g, b; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { int currentPixel = (y * width + x) * 4; ushort pixel = reader.ReadUInt16(); convert565(pixel, out r, out g, out b); pixels[currentPixel + 0] = r; pixels[currentPixel + 1] = g; pixels[currentPixel + 2] = b; pixels[currentPixel + 3] = 255; } // do we need to skip a padding pixel? if ((width & 0x00000001) != 0) { reader.ReadUInt16(); } } }
private bool LoadCalabash(System.IO.BinaryReader br) { try { fStream.Seek(PAL_CALABASH_OFFSET, SeekOrigin.Begin); palCalabash = br.ReadUInt16(); return(true); } catch (Exception e) { System.Console.WriteLine("Exception in RPGData.LoadCalabash(): " + e.Message); return(false); } }
private static ushort?ReadUShort(double?value, bool specified, System.IO.BinaryReader binaryReader) { if (specified) { if (value.HasValue) { return((ushort)value.Value); } return(binaryReader.ReadUInt16()); } return(null); }
private void Mod_LoadEdges(SDHeader header, ref CModel.SModel _SModel, ref System.IO.BinaryReader br) { List <CModel.SMEdge> MEdge = new List <CModel.SMEdge>(); br.BaseStream.Seek(header.lumps[LUMP_EDGES].fileofs, System.IO.SeekOrigin.Begin); while (br.BaseStream.Position < (header.lumps[LUMP_EDGES].fileofs + header.lumps[LUMP_EDGES].filelen)) { CModel.SMEdge _MEdge; _MEdge.v = new ushort[2]; _MEdge.v[0] = br.ReadUInt16(); _MEdge.v[1] = br.ReadUInt16(); _MEdge.cachededgeoffset = 0; MEdge.Add(_MEdge); } _SModel.numedges = MEdge.Count; _SModel.edges = MEdge.ToArray(); }
private static bool ReadFileHeader(System.IO.BinaryReader aReader, ref BMPFileHeader aFileHeader) { aFileHeader.magic = aReader.ReadUInt16(); if (aFileHeader.magic != MAGIC) { return(false); } aFileHeader.filesize = aReader.ReadUInt32(); aFileHeader.reserved = aReader.ReadUInt32(); aFileHeader.offset = aReader.ReadUInt32(); return(true); }