/// <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(Title.Length);
buffer.WriteString(Title);
buffer.WriteInteger(Content.Length);
buffer.WriteString(Content);
}
/// <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));
}
public void WriteData(RAMBuffer buffer)
{
buffer.WriteByte(Enabled);
buffer.WriteByte(Random);
buffer.WriteString(Name, 13);
buffer.WriteString(Name2, 13);
buffer.WriteInteger(SLP);
buffer.WriteInteger(ShapePtr);
buffer.WriteInteger(SoundID);
buffer.WriteInteger(BlendPriority);
buffer.WriteInteger(BlendType);
AssertListLength(Colors, 3);
Colors.ForEach(col => buffer.WriteByte(col));
buffer.WriteByte(CliffColors.Item1);
buffer.WriteByte(CliffColors.Item2);
buffer.WriteByte(PassableTerrain);
buffer.WriteByte(ImpassableTerrain);
buffer.WriteByte(IsAnimated);
buffer.WriteShort(AnimationFrames);
buffer.WriteShort(PauseFames);
buffer.WriteFloat(Interval);
buffer.WriteFloat(PauseBetweenLoops);
buffer.WriteShort(Frame);
buffer.WriteShort(DrawFrame);
buffer.WriteFloat(AnimateLast);
buffer.WriteByte(FrameChanged);
buffer.WriteByte(Drawn);
AssertListLength(ElevationGraphics, 19);
ElevationGraphics.ForEach(eg => eg.WriteData(buffer));
buffer.WriteShort(TerrainToDraw);
buffer.WriteShort(TerrainDimensions.Item1);
buffer.WriteShort(TerrainDimensions.Item2);
Borders.ForEach(b => buffer.WriteShort(b));
AssertListLength(TerrainUnitID, 30);
TerrainUnitID.ForEach(tu => buffer.WriteShort(tu));
AssertListLength(TerrainUnitDensity, 30);
TerrainUnitDensity.ForEach(tu => buffer.WriteShort(tu));
AssertListLength(TerrainUnitCentering, 30);
TerrainUnitCentering.ForEach(tu => buffer.WriteByte(tu));
buffer.WriteShort(NumberOfTerrainUnitsUsed);
buffer.WriteShort(Phantom);
}
/// <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>
/// 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(Unknown1);
buffer.WriteUInteger(Unknown2);
buffer.WriteInteger(AiPerFileContent.Length);
buffer.WriteString(AiPerFileContent);
}
public void WriteData(RAMBuffer buffer)
{
buffer.WriteInteger(Name.Length);
buffer.WriteString(Name);
buffer.WriteInteger(FrameIndex);
buffer.WriteInteger(LegendLabelDllId);
}
/// <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);
}
public void WriteData(RAMBuffer buffer)
{
AssertListLength(RequiredTechs, 6);
RequiredTechs.ForEach(e => buffer.WriteShort(e));
AssertListLength(ResourceCosts, 3);
ResourceCosts.ForEach(e =>
{
buffer.WriteShort(e.Type);
buffer.WriteShort(e.Amount);
buffer.WriteByte(e.Mode);
});
buffer.WriteShort(RequiredTechCount);
buffer.WriteShort(Civ);
buffer.WriteShort(FullTechMode);
buffer.WriteShort(ResearchLocation);
buffer.WriteUShort(LanguageDLLName1);
buffer.WriteUShort(LanguageDLLDescription);
buffer.WriteShort(ResearchTime);
buffer.WriteShort(TechageID);
buffer.WriteShort(Type);
buffer.WriteShort(IconID);
buffer.WriteByte(ButtonID);
buffer.WriteInteger(LanguageDLLHelp);
buffer.WriteInteger(LanguageDLLName2);
buffer.WriteInteger(Unknown1);
buffer.WriteUShort((ushort)Name.Length);
buffer.WriteString(Name);
}
public void WriteData(RAMBuffer buffer)
{
buffer.WriteString(FileName, 13);
buffer.WriteInteger(ResourceID);
buffer.WriteShort(Probability);
buffer.WriteShort(Civ);
buffer.WriteShort(Unknown1);
}
/// <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));
}
/*void func(Sail.SailType type, Civ civ, byte[] data)
* {
* SLPFile s = new SLPFile(new RAMBuffer(data));
* for(int f = 0; f < 90; ++f)
* {
* s._frameInformationHeaders[f].AnchorX = Sails[type].SailSlps[civ]._frameInformationHeaders[10 * ((f / 10) / 2) + (f % 10)].AnchorX;
* s._frameInformationHeaders[f].AnchorY = Sails[type].SailSlps[civ]._frameInformationHeaders[10 * ((f / 10) / 2) + (f % 10)].AnchorY;
* }
* Sails[type].SailSlps[civ] = s;
* }*/
/// <summary>
/// Speichert die Schiffsdaten in der angegebenen Datei.
/// </summary>
/// <param name="filename">Die Zieldatei.</param>
public void Save(string filename)
{
// Puffer erstellen
RAMBuffer buffer = new RAMBuffer();
// Name schreiben
buffer.WriteInteger(Name.Length);
buffer.WriteString(Name);
// Rumpf-SLP schreiben
if (BaseSlp != null)
{
// SLP schreiben
buffer.WriteByte(1);
BaseSlp.writeData();
buffer.Write((RAMBuffer)BaseSlp.DataBuffer);
}
else
{
buffer.WriteByte(0);
}
// Schatten-SLP schreiben
if (ShadowSlp != null)
{
// SLP schreiben
buffer.WriteByte(1);
ShadowSlp.writeData();
buffer.Write((RAMBuffer)ShadowSlp.DataBuffer);
}
else
{
buffer.WriteByte(0);
}
// Segel schreiben
buffer.WriteByte((byte)Sails.Count);
foreach (var currSail in Sails)
{
// Schreiben
buffer.WriteByte((byte)currSail.Key);
currSail.Value.WriteData(buffer);
}
// Invertierte Segel schreiben
buffer.WriteByte((byte)InvertedSails.Count);
foreach (var invSail in InvertedSails)
{
buffer.WriteByte((byte)invSail);
}
// Speichern
buffer.Save(filename);
}
/// <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>
/// 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);
}
public void WriteData(RAMBuffer buffer)
{
buffer.WriteByte(Enabled);
buffer.WriteByte(Random);
buffer.WriteString(Name, 13);
buffer.WriteString(Name2, 13);
buffer.WriteInteger(SLP);
buffer.WriteInteger(ShapePtr);
buffer.WriteInteger(SoundID);
AssertListLength(Colors, 3);
Colors.ForEach(col => buffer.WriteByte(col));
buffer.WriteByte(IsAnimated);
buffer.WriteShort(AnimationFrames);
buffer.WriteShort(PauseFames);
buffer.WriteFloat(Interval);
buffer.WriteFloat(PauseBetweenLoops);
buffer.WriteShort(Frame);
buffer.WriteShort(DrawFrame);
buffer.WriteFloat(AnimateLast);
buffer.WriteByte(FrameChanged);
buffer.WriteByte(Drawn);
AssertListLength(Borders, 19);
Borders.ForEach(b =>
{
AssertListLength(b, 12);
b.ForEach(fd => fd.WriteData(buffer));
});
buffer.WriteShort(DrawTerrain);
buffer.WriteShort(UnderlayTerrain);
buffer.WriteShort(BorderStyle);
}
public void WriteData(RAMBuffer buffer)
{
buffer.WriteString(Name1, 21);
buffer.WriteString(Name2, 13);
buffer.WriteInteger(SLP);
buffer.WriteByte(Unknown1);
buffer.WriteByte(Unknown2);
buffer.WriteByte(Layer);
buffer.WriteByte(PlayerColor);
buffer.WriteByte(Rainbow);
buffer.WriteByte(Replay);
AssertListLength(Coordinates, 4);
Coordinates.ForEach(e => buffer.WriteShort(e));
buffer.WriteUShort((ushort)Deltas.Count);
buffer.WriteShort(SoundID);
buffer.WriteByte(AttackSoundUsed);
buffer.WriteUShort(FrameCount);
buffer.WriteUShort(AngleCount);
buffer.WriteFloat(NewSpeed);
buffer.WriteFloat(FrameRate);
buffer.WriteFloat(ReplayDelay);
buffer.WriteByte(SequenceType);
buffer.WriteShort(ID);
buffer.WriteByte(MirroringMode);
buffer.WriteByte(Unknown3);
Deltas.ForEach(e => e.WriteData(buffer));
if (AttackSoundUsed != 0)
{
AssertListLength(AttackSounds, AngleCount);
AttackSounds.ForEach(e => e.WriteData(buffer));
}
}
public void WriteData(RAMBuffer buffer)
{
buffer.WriteByte(One);
buffer.WriteString(Name, 20);
buffer.WriteUShort((ushort)Resources.Count);
buffer.WriteShort(TechTreeID);
buffer.WriteShort(TeamBonusID);
Resources.ForEach(e => buffer.WriteFloat(e));
buffer.WriteByte(IconSet);
buffer.WriteUShort((ushort)UnitPointers.Count);
UnitPointers.ForEach(e => buffer.WriteInteger(e));
// Sicherstellen, dass genau jede definierte Einheit einen entsprechenden Pointer hat; hier nur über die Listenlänge, sollte aber die meisten auftretenden Fehler abdecken
AssertListLength(Units, UnitPointers.Count(p => p != 0));
foreach (var u in Units)
{
u.Value.WriteData(buffer);
}
}
public void WriteData(RAMBuffer buffer)
{
buffer.WriteByte((byte)Type);
buffer.WriteUShort((ushort)Name1.Length);
buffer.WriteShort(ID1);
buffer.WriteUShort(LanguageDLLName);
buffer.WriteUShort(LanguageDLLCreation);
buffer.WriteShort(Class);
buffer.WriteShort(StandingGraphic1);
buffer.WriteShort(StandingGraphic2);
buffer.WriteShort(DyingGraphic1);
buffer.WriteShort(DyingGraphic2);
buffer.WriteByte(DeathMode);
buffer.WriteShort(HitPoints);
buffer.WriteFloat(LineOfSight);
buffer.WriteByte(GarrisonCapacity);
buffer.WriteFloat(SizeRadius1);
buffer.WriteFloat(SizeRadius2);
buffer.WriteFloat(HPBarHeight1);
buffer.WriteShort(TrainSound1);
buffer.WriteShort(TrainSound2);
buffer.WriteShort(DeadUnitID);
buffer.WriteByte(PlacementMode);
buffer.WriteByte(AirMode);
buffer.WriteShort(IconID);
buffer.WriteByte(HideInEditor);
buffer.WriteShort(Unknown1);
buffer.WriteByte(Enabled);
buffer.WriteByte(Disabled);
buffer.WriteShort(PlacementBypassTerrain1);
buffer.WriteShort(PlacementBypassTerrain2);
buffer.WriteShort(PlacementTerrain1);
buffer.WriteShort(PlacementTerrain2);
buffer.WriteFloat(EditorRadius1);
buffer.WriteFloat(EditorRadius2);
buffer.WriteByte(HillMode);
buffer.WriteByte(VisibleInFog);
buffer.WriteShort(TerrainRestriction);
buffer.WriteByte(FlyMode);
buffer.WriteShort(ResourceCapacity);
buffer.WriteFloat(ResourceDecay);
buffer.WriteByte(BlastType);
buffer.WriteByte(Unknown2);
buffer.WriteByte(InteractionMode);
buffer.WriteByte(MinimapMode);
buffer.WriteByte(CommandAttribute);
buffer.WriteFloat(Unknown3A);
buffer.WriteByte(MinimapColor);
buffer.WriteInteger(LanguageDLLHelp);
buffer.WriteInteger(LanguageDLLHotKeyText);
buffer.WriteInteger(HotKey);
buffer.WriteByte(Unselectable);
buffer.WriteByte(Unknown6);
buffer.WriteByte(UnknownSelectionMode);
buffer.WriteByte(Unknown8);
buffer.WriteByte(SelectionMask);
buffer.WriteByte(SelectionShapeType);
buffer.WriteByte(SelectionShape);
buffer.WriteByte(Attribute);
buffer.WriteByte(Civilization);
buffer.WriteShort(Nothing);
buffer.WriteByte(SelectionEffect);
buffer.WriteByte(EditorSelectionColor);
buffer.WriteFloat(SelectionRadius1);
buffer.WriteFloat(SelectionRadius2);
buffer.WriteFloat(HPBarHeight2);
AssertListLength(ResourceStorages, 3);
ResourceStorages.ForEach(e =>
{
buffer.WriteShort(e.Type);
buffer.WriteFloat(e.Amount);
buffer.WriteByte(e.Mode);
});
buffer.WriteByte((byte)DamageGraphics.Count);
DamageGraphics.ForEach(e => e.WriteData(buffer));
buffer.WriteShort(SelectionSound);
buffer.WriteShort(DyingSound);
buffer.WriteByte(AttackMode);
buffer.WriteByte(EdibleMeat);
buffer.WriteString(Name1);
buffer.WriteShort(ID2);
buffer.WriteShort(ID3);
if (Type >= UnitType.Flag)
{
buffer.WriteFloat(Speed);
}
if (Type >= UnitType.DeadFish)
{
DeadFish.WriteData(buffer);
}
if (Type >= UnitType.Bird)
{
Bird.WriteData(buffer);
}
if (Type >= UnitType.Type50)
{
Type50.WriteData(buffer);
}
if (Type == UnitType.Projectile)
{
Projectile.WriteData(buffer);
}
if (Type >= UnitType.Creatable)
{
Creatable.WriteData(buffer);
}
if (Type == UnitType.Building)
{
Building.WriteData(buffer);
}
}
public void WriteData(RAMBuffer buffer)
{
// Version schreiben
buffer.WriteByte(NEW_TECH_TREE_DESIGN_VERSION);
// SLP-Daten
buffer.WriteInteger(NodeSlpFileName.Length);
buffer.WriteString(NodeSlpFileName);
buffer.WriteInteger(NodeSlpId);
buffer.WriteInteger(ScrollSlpFileName.Length);
buffer.WriteString(ScrollSlpFileName);
buffer.WriteInteger(ScrollSlpId);
buffer.WriteInteger(TileSlpFileName.Length);
buffer.WriteString(TileSlpFileName);
buffer.WriteInteger(TileSlpId);
buffer.WriteInteger(LegendAgesSlpFileName.Length);
buffer.WriteString(LegendAgesSlpFileName);
buffer.WriteInteger(LegendAgesSlpId);
buffer.WriteInteger(LegendDisableSlpFileName.Length);
buffer.WriteString(LegendDisableSlpFileName);
buffer.WriteInteger(LegendDisableSlpId);
// Scroll-Daten
buffer.WriteInteger(MouseScrollArea);
buffer.WriteInteger(MouseScrollDelay);
buffer.WriteInteger(MouseScrollOffset);
buffer.WriteInteger(KeyScrollOffset);
// Button-Rechtecke
WriteRectangle(CloseButtonRelativeRectangle, buffer);
WriteRectangle(ScrollLeftButtonRelativeRectangle, buffer);
WriteRectangle(ScrollRightButtonRelativeRectangle, buffer);
// Auflösungsdaten
buffer.WriteInteger(ResolutionData.Count);
foreach (var rd in ResolutionData)
{
// Daten schreiben
buffer.WriteInteger(rd.Key);
rd.Value.WriteData(buffer);
}
;
// Popup-Label-Daten
buffer.WriteInteger(PopupLabelDelay);
buffer.WriteInteger(PopupLabelWidth);
buffer.WriteInteger(PopupInnerPadding);
IGenieDataElement.AssertListLength(PopupBoxBevelColorIndices, 6);
for (int i = 0; i < 6; ++i)
{
buffer.WriteByte(PopupBoxBevelColorIndices[i]);
}
// Node-Daten
buffer.WriteByte(NodeFontIndex);
IGenieDataElement.AssertTrue(NodeTypes.Count >= 3);
buffer.WriteInteger(NodeTypes.Count);
NodeTypes.ForEach(n => n.WriteData(buffer));
// Age-Labels
buffer.WriteInteger(FirstLineBaseDllId);
buffer.WriteInteger(SecondLineDllId);
buffer.WriteByte(IncrementSecondLineDllId ? (byte)1 : (byte)0);
}
public void WriteData(RAMBuffer buffer)
{
buffer.WriteString(Name, 31);
buffer.WriteUShort((ushort)Effects.Count);
Effects.ForEach(e => e.WriteData(buffer));
}
/// <summary>
/// Schreibt die enthaltenen Daten in das interne RAMBuffer-Objekt.
/// </summary>
/// <remarks></remarks>
private void WriteData()
{
// Puffer initialisieren
if (_buffer == null)
{
_buffer = new RAMBuffer();
}
else if (_buffer.Length != 0)
{
_buffer.Clear();
}
// Dateiversion schreiben
_buffer.WriteString("VER 5.7", 8);
// Anzahlen schreiben
IGenieDataElement.AssertTrue(TerrainRestrictionPointers1.Count == TerrainRestrictionPointers2.Count);
_buffer.WriteUShort((ushort)TerrainRestrictionPointers1.Count);
_buffer.WriteUShort((ushort)DataElements.TerrainRestriction.TerrainCount);
// Terrain-Pointer schreiben
TerrainRestrictionPointers1.ForEach(e => _buffer.WriteInteger(e));
TerrainRestrictionPointers2.ForEach(e => _buffer.WriteInteger(e));
// Terrain-Beschränkungen schreiben
TerrainRestrictions.ForEach(e => e.WriteData(_buffer));
// Anzahl schreiben
_buffer.WriteUShort((ushort)PlayerColors.Count);
// Spielerfarben schreiben
PlayerColors.ForEach(e => e.WriteData(_buffer));
// Anzahl schreiben
_buffer.WriteUShort((ushort)Sounds.Count);
// Sounds schreiben
Sounds.ForEach(e => e.WriteData(_buffer));
// Anzahl schreiben
_buffer.WriteUShort((ushort)GraphicPointers.Count);
// Grafik-Pointer schreiben
GraphicPointers.ForEach(e => _buffer.WriteInteger(e));
// Grafiken schreiben Sicherstellen, dass genau jede definierte Grafik einen entsprechenden Pointer hat; hier nur über die Listenlänge, sollte aber die meisten auftretenden Fehler abdecken
IGenieDataElement.AssertListLength(Graphics, GraphicPointers.Count(p => p != 0));
foreach (var e in Graphics)
{
e.Value.WriteData(_buffer);
}
// Terrain-Daten schreiben
TerrainBlock.WriteData(_buffer);
// RandomMap-Daten schreiben
RandomMaps.WriteData(_buffer);
// Anzahl schreiben
_buffer.WriteInteger(Techages.Count);
// Technologie-Effekte schreiben
Techages.ForEach(e => e.WriteData(_buffer));
// Anzahl schreiben
_buffer.WriteInteger(UnitHeaders.Count);
// Einheiten-Header schreiben
UnitHeaders.ForEach(e => e.WriteData(_buffer));
// Anzahl schreiben
_buffer.WriteUShort((ushort)Civs.Count);
// Kulturen schreiben
Civs.ForEach(e => e.WriteData(_buffer));
// Anzahl schreiben
_buffer.WriteUShort((ushort)Researches.Count);
// Technologien schreiben
Researches.ForEach(e => e.WriteData(_buffer));
// Unbekannte Technologiebaum-Daten schreiben
IGenieDataElement.AssertListLength(TechTreeUnknown, 7);
TechTreeUnknown.ForEach(e => _buffer.WriteInteger(e));
// Technologiebaum schreiben
TechTree.WriteData(_buffer);
if (_newTechTree)
{
// Marker und neuen TechTree schreiben
_buffer.WriteString(NEW_TECH_TREE_MARKER);
TechTreeNew.WriteData(_buffer);
}
// Fertig
}