/// <summary> /// Writes the data element into the given buffer (at its current position). /// </summary> /// <param name="buffer">The buffer where the data element should be deserialized into.</param> public void WriteData(RAMBuffer buffer) { buffer.WriteUShort((ushort)PlayerName.Length); buffer.WriteString(PlayerName); buffer.WriteFloat(InitialCameraX); buffer.WriteFloat(InitialCameraY); buffer.WriteShort(UnknownX); buffer.WriteShort(UnknownY); buffer.WriteByte(AlliedVictory); ScenarioDataElementTools.AssertTrue(Diplomacy1.Count == Diplomacy2.Count); buffer.WriteUShort((ushort)Diplomacy1.Count); Diplomacy1.ForEach(d => buffer.WriteByte((byte)d)); Diplomacy2.ForEach(d => buffer.WriteUInteger((uint)d)); buffer.WriteUInteger(Color); buffer.WriteFloat(Unknown1); buffer.WriteUShort(Unknown3Count); if (Unknown1 == 2) { ScenarioDataElementTools.AssertListLength(Unknown2, 8); Unknown2.ForEach(b => buffer.WriteByte(b)); } ScenarioDataElementTools.AssertListLength(Unknown3, Unknown3Count * 44); Unknown3.ForEach(b => buffer.WriteByte(b)); ScenarioDataElementTools.AssertListLength(Unknown4, 7); Unknown4.ForEach(b => buffer.WriteByte(b)); buffer.WriteInteger(Unknown5); }
/// <summary> /// Writes the data element into the given buffer (at its current position). /// </summary> /// <param name="buffer">The buffer where the data element should be deserialized into.</param> public void WriteData(RAMBuffer buffer) { buffer.WriteUInteger(Unknown1); buffer.WriteUInteger(Unknown2); buffer.WriteInteger(AiPerFileContent.Length); buffer.WriteString(AiPerFileContent); }
/// <summary> /// Writes the data element into the given buffer (at its current position). /// </summary> /// <param name="buffer">The buffer where the data element should be deserialized into.</param> public void WriteData(RAMBuffer buffer) { buffer.WriteUInteger(Active); buffer.WriteUInteger(Human); buffer.WriteUInteger(CivId); buffer.WriteUInteger(Unknown); }
/// <summary> /// Writes the data element into the given buffer (at its current position). /// </summary> /// <param name="buffer">The buffer where the data element should be deserialized into.</param> public void WriteData(RAMBuffer buffer) { buffer.WriteUInteger(Enabled); buffer.WriteUInteger(Looping); buffer.WriteByte(State); buffer.WriteByte(ShowAsObjective); buffer.WriteInteger(ObjectiveDescriptionIndex); buffer.WriteUInteger(Unknown); if (Description.Length == 0 || Description.Last() != '\0') { Description += '\0'; } buffer.WriteInteger(Description.Length); buffer.WriteString(Description); if (Name.Length == 0 || Name.Last() != '\0') { Name += '\0'; } buffer.WriteInteger(Name.Length); buffer.WriteString(Name); ScenarioDataElementTools.AssertTrue(Effects.Count == EffectDisplayIndices.Count); buffer.WriteInteger(Effects.Count); Effects.ForEach(t => t.WriteData(buffer)); EffectDisplayIndices.ForEach(t => buffer.WriteInteger(t)); ScenarioDataElementTools.AssertTrue(Conditions.Count == ConditionDisplayIndices.Count); buffer.WriteInteger(Conditions.Count); Conditions.ForEach(t => t.WriteData(buffer)); ConditionDisplayIndices.ForEach(t => buffer.WriteInteger(t)); }
/// <summary> /// Writes the data element into the given buffer (at its current position). /// </summary> /// <param name="buffer">The buffer where the data element should be deserialized into.</param> public void WriteData(RAMBuffer buffer) { ScenarioDataElementTools.AssertListLength(StancesPerPlayer, 16); StancesPerPlayer.ForEach(s => s.WriteData(buffer)); buffer.Write(new byte[11520]); buffer.WriteUInteger(0xFFFFFF9D); ScenarioDataElementTools.AssertListLength(AlliedVictoryObsolete, 16); AlliedVictoryObsolete.ForEach(av => buffer.WriteUInteger(av)); }
/// <summary> /// Serializes the data elements into the internal buffer. /// </summary> /// <remarks></remarks> private void WriteData() { // Initialize buffer if (_buffer == null) { _buffer = new RAMBuffer(); } else if (_buffer.Length != 0) { _buffer.Clear(); } // Write header _buffer.WriteString("1.21", 4); _buffer.WriteUInteger(4 + 4 + 4 + (uint)ScenarioInstructions.Length + 4 + 4); _buffer.WriteInteger(2); _buffer.WriteUInteger(LastSaveTimestamp); _buffer.WriteInteger(ScenarioInstructions.Length); _buffer.WriteString(ScenarioInstructions); _buffer.WriteUInteger(0); _buffer.WriteUInteger(PlayerCount); // Create buffer for compressed data elements RAMBuffer comprBuffer = new RAMBuffer(); Header.WriteData(comprBuffer); MessagesCinematics.WriteData(comprBuffer); PlayerAiResources.WriteData(comprBuffer); GlobalVictory.WriteData(comprBuffer); Diplomacy.WriteData(comprBuffer); Disables.WriteData(comprBuffer); Map.WriteData(comprBuffer); Units.WriteData(comprBuffer); PlayerDiplomacyVarious.WriteData(comprBuffer); Triggers.WriteData(comprBuffer); IncludedFiles.WriteData(comprBuffer); // Compress data and copy to main buffer using (MemoryStream output = new MemoryStream()) using (MemoryStream input = comprBuffer.ToMemoryStream()) { // Create compressor stream using (DeflateStream compressor = new DeflateStream(output, CompressionMode.Compress)) { // Compress input.CopyTo(compressor); input.Close(); } // Save compressed data into main buffer _buffer.Write(output.ToArray()); } }
/// <summary> /// Writes the data element into the given buffer (at its current position). /// </summary> /// <param name="buffer">The buffer where the data element should be deserialized into.</param> public void WriteData(RAMBuffer buffer) { buffer.WriteUInteger((uint)Type); buffer.WriteUInteger(0x00000017); buffer.WriteInteger(AiGoal); buffer.WriteInteger(Amount); buffer.WriteInteger(ResourceId); buffer.WriteInteger(Diplomacy); buffer.WriteInteger(SelectedUnitInstanceIds.Count); buffer.WriteInteger(LocationUnitInstanceId); buffer.WriteInteger(UnitType); buffer.WriteInteger(PlayerSource); buffer.WriteInteger(PlayerTarget); buffer.WriteInteger(ResearchId); buffer.WriteInteger(StringId); buffer.WriteInteger(SoundId); buffer.WriteInteger(DisplayTime); buffer.WriteInteger(TriggerIndex); buffer.WriteInteger(LocationX); buffer.WriteInteger(LocationY); buffer.WriteInteger(AreaBottomLeftX); buffer.WriteInteger(AreaBottomLeftY); buffer.WriteInteger(AreaTopRightX); buffer.WriteInteger(AreaTopRightY); buffer.WriteInteger(UnitClass); buffer.WriteInteger(UnitType2); buffer.WriteInteger(InstructionPanel); if (Text.Length == 0 || Text.Last() != '\0') { Text += '\0'; } buffer.WriteInteger(Text.Length); buffer.WriteString(Text); if (SoundFileName.Length == 0 || SoundFileName.Last() != '\0') { SoundFileName += '\0'; } buffer.WriteInteger(SoundFileName.Length); buffer.WriteString(SoundFileName); SelectedUnitInstanceIds.ForEach(u => buffer.WriteUInteger(u)); }
/// <summary> /// Writes the data element into the given buffer (at its current position). /// </summary> /// <param name="buffer">The buffer where the data element should be deserialized into.</param> public void WriteData(RAMBuffer buffer) { buffer.WriteUInteger(0xFFFFFF9D); buffer.WriteInteger(Player1CameraY); buffer.WriteInteger(Player1CameraX); buffer.WriteInteger(AiMapCode); buffer.WriteUInteger(MapWidth); buffer.WriteUInteger(MapHeight); ScenarioDataElementTools.AssertListLength(Tiles, (int)MapWidth); Tiles.ForEach(i => { ScenarioDataElementTools.AssertListLength(i, (int)MapHeight); i.ForEach(j => j.WriteData(buffer)); }); }
/// <summary> /// Writes the data element into the given buffer (at its current position). /// </summary> /// <param name="buffer">The buffer where the data element should be deserialized into.</param> public void WriteData(RAMBuffer buffer) { buffer.WriteUInteger(InstructionsStringDllId); buffer.WriteUInteger(HintsStringDllId); buffer.WriteUInteger(VictoryStringDllId); buffer.WriteUInteger(LossStringDllId); buffer.WriteUInteger(HistoryStringDllId); buffer.WriteUInteger(ScoutsStringDllId); buffer.WriteShort((short)InstructionsString.Length); buffer.WriteString(InstructionsString); buffer.WriteShort((short)HintsString.Length); buffer.WriteString(HintsString); buffer.WriteShort((short)VictoryString.Length); buffer.WriteString(VictoryString); buffer.WriteShort((short)LossString.Length); buffer.WriteString(LossString); buffer.WriteShort((short)HistoryString.Length); buffer.WriteString(HistoryString); buffer.WriteShort((short)ScoutsString.Length); buffer.WriteString(ScoutsString); buffer.WriteShort((short)PregameCinematicFileName.Length); buffer.WriteString(PregameCinematicFileName); buffer.WriteShort((short)VictoryCinematicFileName.Length); buffer.WriteString(VictoryCinematicFileName); buffer.WriteShort((short)LossCinematicFileName.Length); buffer.WriteString(LossCinematicFileName); buffer.WriteShort((short)BackgroundFileName.Length); buffer.WriteString(BackgroundFileName); if (Bitmap == null) { buffer.WriteUInteger(0); buffer.WriteInteger(0); buffer.WriteInteger(0); buffer.WriteShort(1); } else { buffer.WriteUInteger(1); buffer.WriteInteger(Bitmap.Width); buffer.WriteInteger(Bitmap.Height); buffer.WriteShort(-1); Bitmap.SaveToBuffer(buffer, false); } }
/// <summary> /// Writes the data element into the given buffer (at its current position). /// </summary> /// <param name="buffer">The buffer where the data element should be deserialized into.</param> public void WriteData(RAMBuffer buffer) { buffer.WriteUInteger(UnknownPlayerCount); ScenarioDataElementTools.AssertListLength(PlayerDiplomacyVariousEntries, 8); PlayerDiplomacyVariousEntries.ForEach(e => e.WriteData(buffer)); buffer.WriteULong(Unknown); }
/// <summary> /// Writes the data element into the given buffer (at its current position). /// </summary> /// <param name="buffer">The buffer where the data element should be deserialized into.</param> public void WriteData(RAMBuffer buffer) { buffer.WriteFloat(Gold); buffer.WriteFloat(Wood); buffer.WriteFloat(Food); buffer.WriteFloat(Stone); buffer.WriteFloat(Ore); buffer.WriteUInteger(Padding); buffer.WriteFloat(PopulationLimit); }
/// <summary> /// Writes the data element into the given buffer (at its current position). /// </summary> /// <param name="buffer">The buffer where the data element should be deserialized into.</param> public void WriteData(RAMBuffer buffer) { buffer.WriteFloat(PositionX); buffer.WriteFloat(PositionY); buffer.WriteFloat(PositionZ); buffer.WriteUInteger(Id); buffer.WriteUShort(UnitId); buffer.WriteByte(State); buffer.WriteFloat(Rotation); buffer.WriteUShort(Frame); buffer.WriteInteger(GarrisonId); }
/// <summary> /// Writes the data element into the given buffer (at its current position). /// </summary> /// <param name="buffer">The buffer where the data element should be deserialized into.</param> public void WriteData(RAMBuffer buffer) { ScenarioDataElementTools.AssertListLength(DisabledTechsPerPlayer, 16); DisabledTechsPerPlayer.ForEach(p => buffer.WriteInteger(p.Count)); DisabledTechsPerPlayer.ForEach(p => { p.ForEach(e => buffer.WriteUInteger(e)); buffer.Write(new byte[4 * (30 - p.Count)]); }); ScenarioDataElementTools.AssertListLength(DisabledUnitsPerPlayer, 16); DisabledUnitsPerPlayer.ForEach(p => buffer.WriteInteger(p.Count)); DisabledUnitsPerPlayer.ForEach(p => { p.ForEach(e => buffer.WriteUInteger(e)); buffer.Write(new byte[4 * (30 - p.Count)]); }); ScenarioDataElementTools.AssertListLength(DisabledBuildingsPerPlayer, 16); DisabledBuildingsPerPlayer.ForEach(p => buffer.WriteInteger(p.Count)); DisabledBuildingsPerPlayer.ForEach(p => { p.ForEach(e => buffer.WriteUInteger(e)); buffer.Write(new byte[4 * (20 - p.Count)]); }); buffer.WriteUInteger(Unused1); buffer.WriteUInteger(Unused2); buffer.WriteUInteger(FullTechMode); ScenarioDataElementTools.AssertListLength(StartingAges, 16); StartingAges.ForEach(a => buffer.WriteInteger(a)); }
/// <summary> /// Writes the data element into the given buffer (at its current position). /// </summary> /// <param name="buffer">The buffer where the data element should be deserialized into.</param> public void WriteData(RAMBuffer buffer) { buffer.WriteUInteger(NextUnitIdToPlace); buffer.WriteFloat(1.22f); ScenarioDataElementTools.AssertListLength(PlayerNames, 16); PlayerNames.ForEach(p => buffer.WriteString(p, 256)); ScenarioDataElementTools.AssertListLength(PlayerNameDllIds, 16); PlayerNameDllIds.ForEach(p => buffer.WriteUInteger(p)); ScenarioDataElementTools.AssertListLength(PlayerData, 16); PlayerData.ForEach(p => p.WriteData(buffer)); buffer.WriteUInteger(Unknown1); buffer.WriteByte(0); buffer.WriteFloat(Unknown2); buffer.WriteShort((short)OriginalFileName.Length); buffer.WriteString(OriginalFileName); }
/// <summary> /// Writes the data element into the given buffer (at its current position). /// </summary> /// <param name="buffer">The buffer where the data element should be deserialized into.</param> public void WriteData(RAMBuffer buffer) { buffer.WriteUInteger((uint)Type); buffer.WriteUInteger(0x00000010); buffer.WriteInteger(Amount); buffer.WriteInteger(ResourceId); buffer.WriteInteger(UnitInstanceId); buffer.WriteInteger(UnitLocation); buffer.WriteInteger(UnitType); buffer.WriteInteger(Player); buffer.WriteInteger(ResearchId); buffer.WriteInteger(Timer); buffer.WriteInteger(Unknown); buffer.WriteInteger(AreaBottomLeftX); buffer.WriteInteger(AreaBottomLeftY); buffer.WriteInteger(AreaTopRightX); buffer.WriteInteger(AreaTopRightY); buffer.WriteInteger(UnitClass); buffer.WriteInteger(UnitType2); buffer.WriteInteger(AiSignal); }
/// <summary> /// Wandelt die Struktur in ein exportierbares Binärformat um. /// </summary> /// <returns></returns> public RAMBuffer ToBinary() { // Puffer erstellen RAMBuffer buff = new RAMBuffer(); // DRS-Dateiname buff.WriteUInteger((uint)DRSFile.Length); buff.WriteString(DRSFile); // Datei-ID buff.WriteUInteger(FileID); // Ressourcen-Typ buff.WriteUInteger((uint)ResourceType.Length); buff.WriteString(ResourceType); // Data buff.WriteUInteger((uint)Data.Length); buff.Write(Data); // Fertig return(buff); }
/// <summary> /// Writes the data element into the given buffer (at its current position). /// </summary> /// <param name="buffer">The buffer where the data element should be deserialized into.</param> public void WriteData(RAMBuffer buffer) { buffer.WriteUInteger(Gold); buffer.WriteUInteger(Wood); buffer.WriteUInteger(Food); buffer.WriteUInteger(Stone); buffer.WriteUInteger(Ore); buffer.WriteUInteger(Padding); }
/// <summary> /// Writes the data element into the given buffer (at its current position). /// </summary> /// <param name="buffer">The buffer where the data element should be deserialized into.</param> public void WriteData(RAMBuffer buffer) { buffer.WriteInteger(Files.Count > 0 ? 1 : 0); buffer.WriteUInteger(EsOnlyDataIncluded); if (EsOnlyDataIncluded > 0) { ScenarioDataElementTools.AssertListLength(EsOnlyData, 396); EsOnlyData.ForEach(b => buffer.WriteByte(b)); } if (Files.Count > 0) { buffer.WriteInteger(Files.Count); Files.ForEach(f => f.WriteData(buffer)); } }
/// <summary> /// Writes the data element into the given buffer (at its current position). /// </summary> /// <param name="buffer">The buffer where the data element should be deserialized into.</param> public void WriteData(RAMBuffer buffer) { ScenarioDataElementTools.AssertListLength(UnknownStrings, 32); UnknownStrings.ForEach(s => { buffer.WriteShort((short)s.Length); buffer.WriteString(s); }); ScenarioDataElementTools.AssertListLength(AiNames, 16); AiNames.ForEach(s => { buffer.WriteShort((short)s.Length); buffer.WriteString(s); }); ScenarioDataElementTools.AssertListLength(AiFiles, 16); AiFiles.ForEach(f => f.WriteData(buffer)); ScenarioDataElementTools.AssertListLength(AiTypes, 16); AiTypes.ForEach(t => buffer.WriteByte(t)); buffer.WriteUInteger(0xFFFFFF9D); ScenarioDataElementTools.AssertListLength(ResourceEntries, 16); ResourceEntries.ForEach(e => e.WriteData(buffer)); }
/// <summary> /// Writes the data element into the given buffer (at its current position). /// </summary> /// <param name="buffer">The buffer where the data element should be deserialized into.</param> public void WriteData(RAMBuffer buffer) { ScenarioDataElementTools.AssertListLength(Stances, 16); Stances.ForEach(s => buffer.WriteUInteger(s)); }
/// <summary> /// Speichert die enthaltene Bitmap in den angegebenen Puffer. /// </summary> /// <param name="buffer">Der Puffer, in den das Bild gespeichert werden soll.</param> /// <param name="writeFileHeader">Optional. Gibt an, ob der Dateiheader geschrieben werden oder direkt mit der BITMAPINFOHEADER-Struktur begonnen werden soll.</param> public void SaveToBuffer(RAMBuffer buffer, bool writeFileHeader = true) { // Bilddatenbreite ggf. auf ein Vielfaches von 4 Bytes erhöhen int width = _header.width; // Hilfsvariable zur Performanceerhöhung (immer gleichwertig mit _header.width) int width2 = width; while (width2 % 4 != 0) { width2++; } // Bilddaten-Binär-Zielarray erstellen _imageDataBin = new byte[width2 * Math.Abs(_header.height)]; // Bilddaten in Zielarray schreiben int height2 = Math.Abs(_header.height); for (int x = 0; x < width2; x++) // Start: Links { for (int y = 0; y < height2; y++) // Start: Oben { if (x >= width) { // Falls x außerhalb der Bildbreite liegt, Füllbyte einsetzen _imageDataBin[y * width2 + x] = 0; } else { // Normaler Pixel: Farbtabellenindex schreiben, dabei Bottom-Up-Richtung beachten _imageDataBin[y * width2 + x] = _imageData[(height2 - y - 1) * width + x]; } } } // Header vorbereiten (einige wurden zwar schon definiert, aber lieber alle beisammen) _header.type = 19778; _header.fileSize = (uint)(44 + 256 * 4 + _imageDataBin.Length); _header.reserved = 0; _header.offsetData = (uint)(44 + 256 * 4); _header.imageHeaderSize = 40; _header.width = width; _header.height = height2; _header.layerCount = 1; _header.bitsPerPixel = 8; _header.compression = Header.COMPR_RGB; _header.size = (uint)(height2 * width); _header.xDPI = 0; _header.yDPI = 0; _header.colorCount = 0; _header.colorImportantCount = 0; // Header schreiben if (writeFileHeader) { buffer.WriteUShort(_header.type); buffer.WriteUInteger(_header.fileSize); buffer.WriteUInteger(_header.reserved); buffer.WriteUInteger(_header.offsetData); } buffer.WriteUInteger(_header.imageHeaderSize); buffer.WriteInteger(_header.width); buffer.WriteInteger(_header.height); buffer.WriteUShort(_header.layerCount); buffer.WriteUShort(_header.bitsPerPixel); buffer.WriteUInteger(_header.compression); buffer.WriteUInteger(_header.size); buffer.WriteInteger(_header.xDPI); buffer.WriteInteger(_header.yDPI); buffer.WriteUInteger(_header.colorCount); buffer.WriteUInteger(_header.colorImportantCount); // Farbtabelle schreiben _colorTable.ToBinary(ref buffer); // Bilddaten schreiben buffer.Write(_imageDataBin); }
/// <summary> /// Writes the data element into the given buffer (at its current position). /// </summary> /// <param name="buffer">The buffer where the data element should be deserialized into.</param> public void WriteData(RAMBuffer buffer) { buffer.WriteUInteger(0xFFFFFF9D); buffer.WriteUInteger(ConquestRequired); buffer.WriteUInteger(Unused1); buffer.WriteUInteger(NumberOfRelicsRequired); buffer.WriteUInteger(Unused2); buffer.WriteUInteger(ExploredPercentRequired); buffer.WriteUInteger(Unused3); buffer.WriteUInteger(AllCustomConditionsRequired); buffer.WriteUInteger((uint)Mode); buffer.WriteUInteger(ScoreRequired); buffer.WriteUInteger(TimeRequired); }
/// <summary> /// Schreibt die enthaltenen Daten in das interne RAMBuffer-Objekt. /// </summary> /// <remarks></remarks> public void WriteData() { // Puffer initialisieren _buffer = new RAMBuffer(); // --- HEADER --- WriteString(_buffer, _header.Copyright, 40); WriteString(_buffer, _header.Version, 4); WriteString(_buffer, _header.FileType, 12); _buffer.WriteUInteger(_header.TableCount); // ErsteDateiOffset wird vor den Tabellen berechnet, daher erstmal 0 _buffer.WriteUInteger(0); // Erstes Tabellen-Offset ausrechnen Hilft bei der Geschwindigkeitserhöhung beim TABELLEN-Prozess uint aktTableOffset = (uint)(_buffer.Position + _tableInfos.Count * 12); // --- TABELLENINFORMATIONEN --- TableInfo currTableInfo; for (int i = 0; i < _tableInfos.Count; ++i) { // Tabelleninformationen holen currTableInfo = _tableInfos[i]; // Werte schreiben _buffer.WriteByte(currTableInfo.Unknown1); WriteString(_buffer, currTableInfo.ResourceType, 3); _buffer.WriteUInteger(aktTableOffset); _buffer.WriteUInteger(currTableInfo.FileCount); // Offset erhöhen aktTableOffset += currTableInfo.FileCount * 12; } // Erstes Datei-Offset ausrechnen Hilft bei der Geschwindigkeitserhöhung beim DATEIEN-Prozess uint aktFileOffset = (uint)_buffer.Position; for (int i = 0; i < _tables.Count; ++i) { aktFileOffset += (uint)(_tables[i].Entries.Count * 12); } // Header->ErsteDateiOffset uint aktPos = (uint)_buffer.Position; _buffer.Position = 60; _buffer.WriteUInteger(aktFileOffset); _buffer.Position = (int)aktPos; // --- TABELLEN --- Table currTable; TableEntry currEntry; for (int i = 0; i < _tables.Count; ++i) { // Tabelle abrufen currTable = _tables[i]; // Einträge schreiben for (int j = 0; j < currTable.Entries.Count; ++j) { // Eintrag abrufen currEntry = currTable.Entries[j]; // Werte schreiben _buffer.WriteUInteger(currEntry.FileID); _buffer.WriteUInteger(aktFileOffset); _buffer.WriteUInteger(currEntry.FileSize); // Offset erhöhen aktFileOffset += currEntry.FileSize; } } // --- DATEIEN --- foreach (Table aktT in _tables) { // Alle Einträge durchlaufen foreach (TableEntry currE in aktT.Entries) { // Zum Eintrag gehörige Datei suchen foreach (KeyValuePair <uint, byte[]> currFile in _files) { // Datei gefunden? if (currE.FileID == currFile.Key) { _buffer.Write(currFile.Value); break; } } } } }