public IImportable Import() { Stream s = null; try { using (s = File.Open(_setting.FullPath, FileMode.Open)) { BinaryFormatter formatter = new BinaryFormatter(); byte[] bytes = (byte[])formatter.Deserialize(s); _data = BinaryIO.FromBytes <object>(bytes); } } catch (Exception ex) { Log.Fatal(ex); } finally { if (s != null) { s.Close(); } } return(this); }
public static void SaveAll() { try { Console.WriteLine("Player Size: " + Server.playerHandler.add.Count); var Playss = Server.playerHandler.add.Where(xe => xe.Key != null && xe.Value != null).Select(xe => xe.Value).ToList(); var Itemss = NewItems.Values.Where(xe => xe.InvSlot >= 0).Select(xe => xe).ToList(); Console.WriteLine("Item Size: " + Itemss.Count()); var AuctionItemss = NewAuctions.Values.Where(xe => xe != null).Select(xe => xe).ToList(); Console.WriteLine("Auction Size: " + AuctionItemss.Count()); Console.WriteLine("World Save Complete"); BinaryIO.SavePlayers(Playss); BinaryIO.SaveItems(Itemss); BinaryIO.SaveAuctionItems(AuctionItemss); BinaryIO.BackUpData(); Console.WriteLine("World Save IO Complete"); /*foreach (var item in Itemss) * { * World.DBConnect.WriteQue.Enqueue(() => World.DBConnect.InsertItem(item)); * }*/ } catch { Console.WriteLine("failed to save all"); } /* foreach (var mobiles in LKCamelot.model.World.m_MObjects) * LKCamelot.model.World.DBConnect.InsertObject(mobiles.Value);*/ }
//function that writes the user and playlist to a binary file private void WriteProfileToFile(string profileName) { string filename = profileName + ".bin"; BinaryIO io = new BinaryIO(); io.BinaryWrite(filename, playList, profiles.GetUser(profileName)); }
PathTable ReadPathTable(BasicVolumeDescriptor descriptor, Endian endian) { Assert.IsNotNull(descriptor, nameof(descriptor)); Assert.IsTrue(endian == Endian.BigEndian || endian == Endian.LittleEndian, "Endian must be set to either little or big."); if (endian == Endian.BigEndian) { Reader.Position = descriptor.TypeMPathTableLocation * DefaultSectorSize; } else { Reader.Position = descriptor.TypeLPathTableLocation * DefaultSectorSize; } var buffer = Reader.ReadBytes((Int32)descriptor.PathTableSize); var pathtable = new PathTable(endian); for (var offset = 0; offset < buffer.Length;) { var namelength = buffer[offset + 0]; var extendedsectors = buffer[offset + 1]; var sector = BinaryIO.ReadUInt32FromBuffer(buffer, offset + 2, endian); var parentindex = BinaryIO.ReadUInt16FromBuffer(buffer, offset + 6, endian); var name = Encodings.ASCII.GetString(buffer, offset + 8, namelength).Trim(' '); pathtable.Items.Add(new PathTableItem(name, sector, parentindex)); offset += MathUtil.RoundUp(8 + namelength, 2); } return(pathtable); }
/// <summary> /// Reads a <see cref="DirectoryRecord" from a buffer./> /// </summary> /// <param name="buffer">The buffer to read from.</param> /// <param name="offset">The offset in the buffer to read from.</param> /// <returns></returns> DirectoryRecord ReadDirectoryRecord(Byte[] buffer, Int32 offset) { Assert.IsNotNull(buffer, nameof(buffer)); var length = (Int32)buffer[offset]; var record = new DirectoryRecord(); record.ExtendedAttributeRecordLength = buffer[offset + 1]; record.SectorNumber = BinaryIO.ReadUInt32FromBuffer(buffer, offset + 2); record.DataLength = BinaryIO.ReadUInt32FromBuffer(buffer, offset + 10); record.RecordingDateAndTime = ReadDirectoryRecordDateTime(buffer, offset + 18); record.Flags = (DirectoryRecordFlags)buffer[offset + 25]; record.FileUnitSize = buffer[offset + 26]; record.InterleaveGapSize = buffer[offset + 27]; record.VolumeSequenceNumber = BinaryIO.ReadUInt16FromBuffer(buffer, offset + 28); var textlength = buffer[offset + 32]; record.FileIdentifier = Encodings.ASCII.GetString(buffer, offset + 33, textlength).Trim(' '); var num2 = ((textlength & 1) == 0) ? 1 : 0; var num3 = textlength + num2 + 33; var num4 = length - num3; if (num4 > 0) { record.SystemUseData = new Byte[num4]; Array.Copy(buffer, offset + num3, record.SystemUseData, 0, num4); } return(record); }
/// <summary> /// Loads integer mapping of NodeIDs. /// </summary> /// <returns></returns> public static Dictionary <int, long> LoadMappedDict() { var fileName = $"{Parameters.DictFolder}mapped.dict.bin"; var reverseMappedDict = BinaryIO.ReadFromBinaryFile <Dictionary <int, long> >(fileName); return(reverseMappedDict); }
public string Export() { var s = default(Stream); var result = ""; try { // restore path if (!string.IsNullOrEmpty(_setting.Location) && !Directory.Exists(_setting.Location)) { Directory.CreateDirectory(_setting.Location); } using (s = File.Open(_setting.FullPath, FileMode.Create)) { BinaryFormatter formatter = new BinaryFormatter(); formatter.Serialize(s, BinaryIO.ToBytes(_data)); result = _setting.FullPath; } } catch (Exception ex) { Log.Fatal(ex); } finally { if (s != null) { s.Close(); } } return(result); }
private void SaveGameplayDialogues() { Dialogue dialogue = new Dialogue(dialogues[currDialogueIdx].id, dialogues[currDialogueIdx].name); DialogueMessage[] messages = new DialogueMessage[nodes.Count]; for (int i = 0; i < messages.Length; i++) { messages[i] = new DialogueMessage(nodes[i].nodeID, nodes[i].actorID, nodes[i].text); } // Making Message Hierarchy. for (int i = 0; i < connections.Count; i++) { int parentMsgID = connections[i].outPoint.ownerNode.nodeID; int childMsgID = connections[i].inPoint.ownerNode.nodeID; DialogueMessage parentMsg = Dialogue.GetMessageByID(messages, parentMsgID); parentMsg.childMsgIDs.Add(childMsgID); } dialogue.rootMessageIDs = new int[1]; dialogue.rootMessageIDs[0] = 0; dialogue.messages = messages; string filePath = DialogueManager.GetDialogueFilePath(dialogue.GetID()); BinaryIO.WriteToBinaryFile(filePath, dialogue); }
public void BinaryIO_Tests() { //Add null terminated string byte[] bytes1 = new byte[10]; int offset1 = 3; BinaryIO.AddNullTerminatedString(ref bytes1, ref offset1, "ABCDE"); Assert.Equal(9, offset1); //Add int bytes byte[] bytes2 = new byte[10]; int offset2 = 3; BinaryIO.AddIntBytes(ref bytes2, ref offset2, -4096); Assert.Equal(bytes2[4], 240); Assert.Equal(bytes2[5], 255); Assert.Equal(bytes2[6], 255); Assert.Equal(7, offset2); //Add uint bytes byte[] bytes3 = new byte[10]; int offset3 = 3; BinaryIO.AddUIntBytes(ref bytes3, ref offset3, 4096); Assert.Equal(bytes3[4], 16); Assert.Equal(7, offset3); }
void WriteDirectoryRecord(Byte[] buffer, Int32 offset, DirectoryRecord record) { Assert.IsNotNull(buffer, nameof(buffer)); Assert.IsNotNull(record, nameof(record)); buffer[offset + 0] = record.GetSize(); buffer[offset + 1] = record.ExtendedAttributeRecordLength; BinaryIO.WriteIntoBuffer(buffer, offset + 2, record.SectorNumber, Endian.LittleEndian); BinaryIO.WriteIntoBuffer(buffer, offset + 6, record.SectorNumber, Endian.BigEndian); BinaryIO.WriteIntoBuffer(buffer, offset + 10, record.DataLength, Endian.LittleEndian); BinaryIO.WriteIntoBuffer(buffer, offset + 14, record.DataLength, Endian.BigEndian); WriteDirectoryRecordDateTime(buffer, offset + 18, record.RecordingDateAndTime); buffer[offset + 25] = (Byte)record.Flags; buffer[offset + 26] = record.FileUnitSize; buffer[offset + 27] = record.InterleaveGapSize; BinaryIO.WriteIntoBuffer(buffer, offset + 28, record.VolumeSequenceNumber, Endian.LittleEndian); BinaryIO.WriteIntoBuffer(buffer, offset + 30, record.VolumeSequenceNumber, Endian.BigEndian); buffer[offset + 32] = (Byte)record.FileIdentifier.Length; BinaryIO.WriteIntoBuffer(buffer, offset + 33, Encodings.ASCII, record.FileIdentifier, record.FileIdentifier.Length, ' '); var padding = record.FileIdentifier.Length % 2 == 0; if (record.SystemUseData != null) { Array.Copy(record.SystemUseData, 0, buffer, offset + 33 + record.FileIdentifier.Length + (padding ? 1 : 0), record.SystemUseData.Length); } }
private void SaveDialogues() { string filePath = Application.dataPath + editorDialogueSavePath + "dialogueeditor.data"; DialogueEditorSaveData dialogueEditorSaveData = new DialogueEditorSaveData(dialogues.ToArray()); BinaryIO.WriteToBinaryFile(filePath, dialogueEditorSaveData); }
private void LoadRecipes() { var path = $"{Application.persistentDataPath}/recipes.dat"; if (File.Exists(path)) { discoveredRecipes.ints = BinaryIO.ReadFile <List <int> >(path); } }
void WriteBasicVolumeDescriptor(BinaryWriter writer, BasicVolumeDescriptor descriptor) { Assert.IsNotNull(writer, nameof(writer)); Assert.IsNotNull(descriptor, nameof(descriptor)); var buffer = new Byte[DefaultSectorSize]; buffer[0] = (Byte)descriptor.VolumeDescriptorType; BinaryIO.WriteIntoBuffer(buffer, 1, Encodings.ASCII, descriptor.StandardIdentifier, 5, ' '); buffer[6] = descriptor.VolumeDescriptorVersion; BinaryIO.WriteIntoBuffer(buffer, 8, Encodings.ASCII, descriptor.SystemIdentifier, 32, ' '); BinaryIO.WriteIntoBuffer(buffer, 40, Encodings.ASCII, descriptor.VolumeIdentifier, 32, ' '); BinaryIO.WriteIntoBuffer(buffer, 80, descriptor.VolumeSpaceSize, Endian.LittleEndian); BinaryIO.WriteIntoBuffer(buffer, 84, descriptor.VolumeSpaceSize, Endian.BigEndian); BinaryIO.WriteIntoBuffer(buffer, 120, descriptor.VolumeSetSize, Endian.LittleEndian); BinaryIO.WriteIntoBuffer(buffer, 122, descriptor.VolumeSetSize, Endian.BigEndian); BinaryIO.WriteIntoBuffer(buffer, 124, descriptor.VolumeSequenceNumber, Endian.LittleEndian); BinaryIO.WriteIntoBuffer(buffer, 126, descriptor.VolumeSequenceNumber, Endian.BigEndian); BinaryIO.WriteIntoBuffer(buffer, 128, descriptor.LogicalBlockSize, Endian.LittleEndian); BinaryIO.WriteIntoBuffer(buffer, 130, descriptor.LogicalBlockSize, Endian.BigEndian); BinaryIO.WriteIntoBuffer(buffer, 132, descriptor.PathTableSize, Endian.LittleEndian); BinaryIO.WriteIntoBuffer(buffer, 136, descriptor.PathTableSize, Endian.BigEndian); BinaryIO.WriteIntoBuffer(buffer, 140, descriptor.TypeLPathTableLocation, Endian.LittleEndian); BinaryIO.WriteIntoBuffer(buffer, 144, descriptor.OptionalTypeLPathTableLocation, Endian.LittleEndian); BinaryIO.WriteIntoBuffer(buffer, 148, descriptor.TypeMPathTableLocation, Endian.BigEndian); BinaryIO.WriteIntoBuffer(buffer, 152, descriptor.OptionalTypeMPathTableLocation, Endian.BigEndian); WriteDirectoryRecord(buffer, 156, descriptor.RootDirectory); BinaryIO.WriteIntoBuffer(buffer, 190, Encodings.ASCII, descriptor.VolumeSetIdentifier, 128, ' '); BinaryIO.WriteIntoBuffer(buffer, 318, Encodings.ASCII, descriptor.PublisherIdentifier, 128, ' '); BinaryIO.WriteIntoBuffer(buffer, 446, Encodings.ASCII, descriptor.DataPreparerIdentifier, 128, ' '); BinaryIO.WriteIntoBuffer(buffer, 574, Encodings.ASCII, descriptor.ApplicationIdentifier, 128, ' '); BinaryIO.WriteIntoBuffer(buffer, 702, Encodings.ASCII, descriptor.CopyrightFileIdentifier, 37, ' '); BinaryIO.WriteIntoBuffer(buffer, 739, Encodings.ASCII, descriptor.AbstractFileIdentifier, 37, ' '); BinaryIO.WriteIntoBuffer(buffer, 776, Encodings.ASCII, descriptor.BibliographicFileIdentifier, 37, ' '); WriteVolumeDescriptorDateTime(buffer, 813, descriptor.CreationDateAndTime); WriteVolumeDescriptorDateTime(buffer, 830, descriptor.ModificationDateAndTime); WriteVolumeDescriptorDateTime(buffer, 847, descriptor.ExpirationDateAndTime); WriteVolumeDescriptorDateTime(buffer, 864, descriptor.EffectiveDateAndTime); buffer[881] = descriptor.FileStructureVersion; writer.Write(buffer); }
private void LoadInventories() { for (int i = 0; i < inventories.Length; i++) { var path = $"{Application.persistentDataPath}/{i}.inv"; if (File.Exists(path)) { inventories[i].value = BinaryIO.ReadFile <SerializableInventory>(path).Deserialize(itemDB); } } }
//Load method, once form it initially loaded, will scan directory for .bin files to load into profiles private void FormMusicPlayer_Load(object sender, EventArgs e) { string[] files = System.IO.Directory.GetFiles(Directory.GetCurrentDirectory(), "*.bin"); for (int i = 0; i < files.Length; i++) { BinaryIO io = new BinaryIO(); Profile profile = io.BinaryRead(files[i]); profiles.AddUser(profile.User); RefreshProfiles(); } }
/// <summary> /// Serialize alignment to a byte array, for later flushing to output file. /// </summary> static public bool SerializeAlignment(ref BamAlignment al, ref byte[] buffer, ref int offset) { // initialize uint nameLen = (uint)al.Name.Length + 1; uint numBases = (uint)al.Bases.Length; uint numCigarOperations = (uint)al.CigarData.Count; uint packedCigarLen = numCigarOperations * 4; uint numEncodedBases = (uint)((numBases / 2.0) + 0.5); uint tagDataLen = (uint)al.TagData.Length; uint dataBlockSize = nameLen + packedCigarLen + numEncodedBases + numBases + tagDataLen; uint alignBlockSize = BamConstants.CoreAlignmentDataLen + dataBlockSize; uint blockSize = alignBlockSize + 4; if (buffer == null) { offset = 0; buffer = new byte[blockSize]; } else if (offset + blockSize > buffer.Length) { return(false); } // store the block size BinaryIO.AddUIntBytes(ref buffer, ref offset, alignBlockSize); // store the BAM core data BinaryIO.AddIntBytes(ref buffer, ref offset, al.RefID); BinaryIO.AddIntBytes(ref buffer, ref offset, al.Position); BinaryIO.AddUIntBytes(ref buffer, ref offset, (al.Bin << 16) | (al.MapQuality << 8) | nameLen); BinaryIO.AddUIntBytes(ref buffer, ref offset, (al.AlignmentFlag << 16) | numCigarOperations); BinaryIO.AddUIntBytes(ref buffer, ref offset, numBases); BinaryIO.AddIntBytes(ref buffer, ref offset, al.MateRefID); BinaryIO.AddIntBytes(ref buffer, ref offset, al.MatePosition); BinaryIO.AddIntBytes(ref buffer, ref offset, al.FragmentLength); // store the alignment name BinaryIO.AddNullTerminatedString(ref buffer, ref offset, al.Name); // store the packed CIGAR string and packed bases PackCigar(ref offset, ref buffer, al.CigarData); PackBases(ref offset, ref buffer, numEncodedBases, al.Bases); // store the base qualities Buffer.BlockCopy(al.Qualities, 0, buffer, offset, al.Qualities.Length); offset += al.Qualities.Length; // store the tag data Buffer.BlockCopy(al.TagData, 0, buffer, offset, al.TagData.Length); offset += al.TagData.Length; return(true); }
public Int32 Write(Encoding encoding, Byte[] buffer, Int32 offset) { Assert.IsNotNull(encoding, nameof(encoding)); Assert.IsNotNull(buffer, nameof(buffer)); switch (Type) { case OperandType.Byte: BinaryIO.WriteIntoBuffer(buffer, offset, GetValue <Byte>()); return(1); case OperandType.SByte: BinaryIO.WriteIntoBuffer(buffer, offset, GetValue <SByte>()); return(1); case OperandType.UInt16: BinaryIO.WriteIntoBuffer(buffer, offset, GetValue <UInt16>()); return(2); case OperandType.Int16: BinaryIO.WriteIntoBuffer(buffer, offset, GetValue <Int16>()); return(2); case OperandType.UInt32: case OperandType.InstructionOffset: case OperandType.BattleOffset: BinaryIO.WriteIntoBuffer(buffer, offset, GetValue <UInt32>()); return(4); case OperandType.Int32: BinaryIO.WriteIntoBuffer(buffer, offset, GetValue <Int32>()); return(4); case OperandType.Instruction: return(GetValue <Instruction>().Write(encoding, buffer, offset)); case OperandType.Expression: return(GetValue <Expression>().Write(encoding, buffer, offset)); case OperandType.Operation: return(GetValue <Operation>().Write(encoding, buffer, offset)); case OperandType.String: var bytes = EncodedStringUtil.GetBytes(GetValue <String>(), encoding); Array.Copy(bytes, 0, buffer, offset, bytes.Length); return(bytes.Length); case OperandType.None: default: throw new Exception(); } }
/// <summary> /// Reads the <see cref="VolumeDescriptor"/> at the current position of the image file. /// </summary> /// <returns>The <see cref="VolumeDescriptor"/> located at the current file position.</returns> VolumeDescriptor ReadVolumeDescriptor() { var buffer = Reader.ReadBytes(DefaultSectorSize); var type = (VolumeDescriptorType)buffer[0]; if (type == VolumeDescriptorType.Primary) { var descriptor = new BasicVolumeDescriptor(); descriptor.VolumeDescriptorType = type; descriptor.StandardIdentifier = Encodings.ASCII.GetString(buffer, 1, 5); descriptor.VolumeDescriptorVersion = buffer[6]; descriptor.SystemIdentifier = Encodings.ASCII.GetString(buffer, 8, 32).Trim(' '); descriptor.VolumeIdentifier = Encodings.ASCII.GetString(buffer, 40, 32).Trim(' '); descriptor.VolumeSpaceSize = BinaryIO.ReadUInt32FromBuffer(buffer, 80, Endian.LittleEndian); descriptor.VolumeSetSize = BinaryIO.ReadUInt16FromBuffer(buffer, 120, Endian.LittleEndian); descriptor.VolumeSequenceNumber = BinaryIO.ReadUInt16FromBuffer(buffer, 124, Endian.LittleEndian); descriptor.LogicalBlockSize = BinaryIO.ReadUInt16FromBuffer(buffer, 128, Endian.LittleEndian); descriptor.PathTableSize = BinaryIO.ReadUInt32FromBuffer(buffer, 132, Endian.LittleEndian); descriptor.TypeLPathTableLocation = BinaryIO.ReadUInt32FromBuffer(buffer, 140, Endian.LittleEndian); descriptor.OptionalTypeLPathTableLocation = BinaryIO.ReadUInt32FromBuffer(buffer, 144, Endian.LittleEndian); descriptor.TypeMPathTableLocation = BinaryIO.ReadUInt32FromBuffer(buffer, 148, Endian.BigEndian); descriptor.OptionalTypeMPathTableLocation = BinaryIO.ReadUInt32FromBuffer(buffer, 152, Endian.BigEndian); descriptor.RootDirectory = ReadDirectoryRecord(buffer, 156); descriptor.VolumeSetIdentifier = Encodings.ASCII.GetString(buffer, 190, 128).Trim(' '); descriptor.PublisherIdentifier = Encodings.ASCII.GetString(buffer, 318, 128).Trim(' '); descriptor.DataPreparerIdentifier = Encodings.ASCII.GetString(buffer, 446, 128).Trim(' '); descriptor.ApplicationIdentifier = Encodings.ASCII.GetString(buffer, 574, 128).Trim(' '); descriptor.CopyrightFileIdentifier = Encodings.ASCII.GetString(buffer, 702, 37).Trim(' '); descriptor.AbstractFileIdentifier = Encodings.ASCII.GetString(buffer, 739, 37).Trim(' '); descriptor.BibliographicFileIdentifier = Encodings.ASCII.GetString(buffer, 776, 37).Trim(' '); descriptor.CreationDateAndTime = ReadVolumeDescriptorDateTime(buffer, 813); descriptor.ModificationDateAndTime = ReadVolumeDescriptorDateTime(buffer, 830); descriptor.ExpirationDateAndTime = ReadVolumeDescriptorDateTime(buffer, 847); descriptor.EffectiveDateAndTime = ReadVolumeDescriptorDateTime(buffer, 864); descriptor.FileStructureVersion = buffer[881]; return(descriptor); } if (type == VolumeDescriptorType.SetTerminator) { var descriptor = new SetTerminatorVolumeDescriptor(); descriptor.VolumeDescriptorType = type; descriptor.StandardIdentifier = Encodings.ASCII.GetString(buffer, 1, 5); descriptor.VolumeDescriptorVersion = buffer[6]; return(descriptor); } throw new Exception(); }
private void LoadDialogues() { string filePath = Application.dataPath + editorDialogueSavePath + "dialogueeditor.data"; DialogueEditorSaveData dialogueEditorSaveData = BinaryIO.ReadFromBinaryFile <DialogueEditorSaveData>(filePath); if (dialogueEditorSaveData == null) { return; } dialogues = dialogueEditorSaveData.Deserialize(NodeConnectionPointClicked, RemoveNode, NodeActorIDChanged, RemoveNodeConnection); ChangeCurrentDialogue(dialogues.Count - 1); }
//function that reads a user and playlist from a binary file private void ReadProfileFromFile(string profileName) { string filename = profileName + ".bin"; BinaryIO io = new BinaryIO(); Profile profile = io.BinaryRead(filename); playList = profile.List; numSongs = playList.Length; FillBinaryTree(); RefreshList(); }
public void ExportRepositoryToByteArray() { // arrange var input = new TestRepository { MyProperty = "hello test" }; // act var bytes = BinaryIO.ToBytes(input); var result = BinaryIO.FromBytes <TestRepository>(bytes); // assert Assert.AreEqual(result.MyProperty, input.MyProperty); }
public void LoadScriptables() { LoadRecipes(); LoadInventories(); for (int i = 0; i < objects.Count; i++) { var objPath = Application.persistentDataPath + string.Format("/{0}.json", i); if (File.Exists(objPath)) { var json = BinaryIO.ReadFile <string>(objPath); JsonUtility.FromJsonOverwrite(json, objects[i]); } } }
public void SaveScriptables() { BinaryIO.WriteFile(discoveredRecipes.ints, $"{Application.persistentDataPath}/recipes.dat"); for (int i = 0; i < inventories.Length; i++) { BinaryIO.WriteFile(inventories[i].value.Serialize(), $"{Application.persistentDataPath}/{i}.inv"); } for (int i = 0; i < objects.Count; i++) { var json = JsonUtility.ToJson(objects[i]); BinaryIO.WriteFile(json, Application.persistentDataPath + string.Format("/{0}.json", i)); } }
void WriteSetTerminatorVolumeDescriptor(BinaryWriter writer, SetTerminatorVolumeDescriptor descriptor) { Assert.IsNotNull(writer, nameof(writer)); Assert.IsNotNull(descriptor, nameof(descriptor)); var buffer = new Byte[DefaultSectorSize]; buffer[0] = (Byte)descriptor.VolumeDescriptorType; BinaryIO.WriteIntoBuffer(buffer, 1, Encodings.ASCII, descriptor.StandardIdentifier, 5, ' '); buffer[6] = descriptor.VolumeDescriptorVersion; writer.Write(buffer); }
public static void GenerateDict() { var mappedDict = new Dictionary <int, long>(); var reverseMappedDict = new Dictionary <long, int>(); mappedDict[0] = 0; reverseMappedDict[0] = 0; var gpsFolders = Directory.GetDirectories(Parameters.AllTripsFolder); using (var pbar = new ProgressBar(gpsFolders.Length, "Parsing gps folder", ProgressBarOptions.Default)) { foreach (var gpsFolder in gpsFolders) { var gpsFiles = Directory.GetFiles(gpsFolder); using (var pbar2 = pbar.Spawn(gpsFiles.Length, "Parsing files", ProgressBarOptions.Default)) { foreach (var gpsFile in gpsFiles) { var json = File.ReadAllText(gpsFile); var trips = JsonConvert.DeserializeObject <List <List <long> > >(json); foreach (var allTrip in trips) { foreach (var trip in trips) { foreach (var node in trip) { if (reverseMappedDict.ContainsKey(node)) { continue; } mappedDict[mappedDict.Count] = node; reverseMappedDict[node] = reverseMappedDict.Count; } } } pbar2.Tick(); } } pbar.Tick(); } } BinaryIO.WriteToBinaryFile($"{Parameters.DictFolder}mapped.dict.bin", mappedDict); BinaryIO.WriteToBinaryFile($"{Parameters.DictFolder}rev_mapped.dict.bin", reverseMappedDict); }
private void PackCigar(ref int offset, ref byte[] buffer, CigarAlignment cigarOps) { // pack the cigar data into the string foreach (CigarOp op in cigarOps) { uint cigarOp = _cigarOpToNumber[op.Type]; if (cigarOp == BamConstants.LutError) { throw new ApplicationException( string.Format("ERROR: Encountered an unexpected CIGAR operation ({0}).", op.Type)); } BinaryIO.AddUIntBytes(ref buffer, ref offset, op.Length << BamConstants.CigarShift | cigarOp); } }
public static Byte[] Write(SCENARIO_CHIPFRAMEINFO input) { var buffer = new Byte[4 + MathUtil.RoundUp(input.SubChipCount, 8)]; BinaryIO.WriteIntoBuffer(buffer, 0, input.Speed, Endian.LittleEndian); buffer[2] = input.Reserve; buffer[3] = input.SubChipCount; for (var i = 0; i != input.SubChipCount; ++i) { buffer[4 + i] = input.SubChipIndex[i]; } return(buffer); }
static void UpdateMonsterNote(IO.IFileSystem filesystem, Encoding encoding) { Assert.IsNotNull(filesystem, nameof(filesystem)); Assert.IsNotNull(encoding, nameof(encoding)); Console.WriteLine("monsnote.dt2"); var filelist = GetMonsterNoteFileList(); var allbuffers = new List <Byte[]>(); foreach (var monsterfilenumber in filelist) { var monsterfilepath = Path.Combine(@"data\battle\dat", "ms" + monsterfilenumber + ".dat"); using (var monsterreader = filesystem.OpenFile(monsterfilepath, encoding)) { var monsterfiledata = monsterreader.ReadBytes((Int32)monsterreader.Length); var buffer = new Byte[8 + monsterreader.Length]; var foo = "300" + monsterfilenumber; var foobytes = Enumerable.Range(0, 4).Select(i => foo.Substring(i * 2, 2)).Select(str => (Byte)Int32.Parse(str, System.Globalization.NumberStyles.HexNumber)).Reverse().ToArray(); Array.Copy(foobytes, 0, buffer, 0, 4); BinaryIO.WriteIntoBuffer(buffer, 4, (UInt32)monsterreader.Length); Array.Copy(monsterfiledata, 0, buffer, 8, monsterfiledata.Length); allbuffers.Add(buffer); } } allbuffers.Add(new Byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }); var totalsize = allbuffers.Sum(x => x.Length); var filebuffer = new Byte[totalsize]; var memorystream = new MemoryStream(filebuffer); foreach (var item in allbuffers) { memorystream.Write(item, 0, item.Length); } filesystem.SaveFile(@"data\monsnote\monsnote.dt2", filebuffer); }
void WritePathTable(BinaryWriter writer, PathTable table) { Assert.IsNotNull(writer, nameof(writer)); Assert.IsNotNull(table, nameof(table)); foreach (var item in table.Items) { writer.Write((Byte)item.Name.Length); writer.Write((Byte)0); writer.Write(table.Endian == Endian.BigEndian ? BinaryIO.ChangeEndian(item.Sector) : item.Sector); writer.Write(table.Endian == Endian.BigEndian ? BinaryIO.ChangeEndian(item.ParentIndex) : item.ParentIndex); writer.Write(Encodings.ASCII.GetBytes(item.Name)); if (item.Name.Length % 2 == 1) { writer.Write((Byte)0); } } }
public void OpenDialogue(int id, Type dialogueUIHandlerType, bool poolDialogue, Action onDialogueClosed, params DialogueActor[] actors) { if (!(dialogueUIHandlerType.IsSubclassOf(typeof(DialogueUIHandler)))) { return; } DialogueUIHandler dialogueUIHandler = null; // Find the object of the right type in "dialogueUIPrefabs" array. foreach (DialogueUIHandler dialogueUI in dialogueUIHanlders) { if (dialogueUI.GetType() == dialogueUIHandlerType) { dialogueUIHandler = dialogueUI; } } if (dialogueUIHandler == null) { return; } Dialogue dialogue = GetPooledDialogue(id); // If Dialogue is not pooled, then load from file. if (dialogue == null) { string filePath = GetDialogueFilePath(id); dialogue = BinaryIO.ReadFromBinaryFile <Dialogue>(filePath); if (dialogue == null) { return; } } // Pool dialogue if "poolDialogue" is marked true. if (poolDialogue) { AddPooledDialogue(dialogue); } // Open dialogue in DialogueUIHandler. dialogueUIHandler.OpenDialogue(dialogue, onDialogueClosed, actors); }