public override void ReadData(RAMBuffer buffer)
{
RequiredTechs = new List<short>(6);
for(int i = 0; i < 6; ++i)
RequiredTechs.Add(buffer.ReadShort());
ResourceCosts = new List<ResourceTuple<short, short, byte>>(3);
for(int i = 0; i < 3; ++i)
ResourceCosts.Add(new ResourceTuple<short, short, byte>() { Type = buffer.ReadShort(), Amount = buffer.ReadShort(), Enabled = buffer.ReadByte() });
RequiredTechCount = buffer.ReadShort();
Civ = buffer.ReadShort();
FullTechMode = buffer.ReadShort();
ResearchLocation = buffer.ReadShort();
LanguageDLLName1 = buffer.ReadUShort();
LanguageDLLDescription = buffer.ReadUShort();
ResearchTime = buffer.ReadShort();
TechageID = buffer.ReadShort();
Type = buffer.ReadShort();
IconID = buffer.ReadShort();
ButtonID = buffer.ReadByte();
LanguageDLLHelp = buffer.ReadInteger();
LanguageDLLName2 = buffer.ReadInteger();
Unknown1 = buffer.ReadInteger();
int nameLength = buffer.ReadUShort();
Name = buffer.ReadString(nameLength);
}
public override void ReadData(RAMBuffer buffer)
{
Name = buffer.ReadString(31);
int effectCount = buffer.ReadUShort();
Effects = new List<TechageEffect>(effectCount);
for(int i = 0; i < effectCount; ++i)
Effects.Add(new TechageEffect().ReadDataInline(buffer));
}
public override void ReadData(RAMBuffer buffer)
{
Exists = buffer.ReadByte();
if(Exists != 0)
{
int commandCount = buffer.ReadUShort();
Commands = new List<UnitCommand>(commandCount);
for(int i = 0; i < commandCount; ++i)
Commands.Add(new UnitCommand().ReadDataInline(buffer));
}
}
public override void ReadData(RAMBuffer buffer)
{
DefaultArmour = buffer.ReadShort();
ushort attackCount = buffer.ReadUShort();
Attacks = new Dictionary<short, short>(attackCount);
for(int i = 0; i < attackCount; ++i)
Attacks[buffer.ReadShort()] = buffer.ReadShort();
ushort armourCount = buffer.ReadUShort();
Armours = new Dictionary<short, short>(armourCount);
for(int i = 0; i < armourCount; ++i)
Armours[buffer.ReadShort()] = buffer.ReadShort();
TerrainRestrictionForDamageMultiplying = buffer.ReadShort();
MaxRange = buffer.ReadFloat();
BlastRadius = buffer.ReadFloat();
ReloadTime = buffer.ReadFloat();
ProjectileUnitID = buffer.ReadShort();
AccuracyPercent = buffer.ReadShort();
TowerMode = buffer.ReadByte();
FrameDelay = buffer.ReadShort();
GraphicDisplacement = new List<float>(3);
for(int i = 0; i < 3; ++i)
GraphicDisplacement.Add(buffer.ReadFloat());
BlastLevel = buffer.ReadByte();
MinRange = buffer.ReadFloat();
AccuracyErrorRadius = buffer.ReadFloat();
AttackGraphic = buffer.ReadShort();
DisplayedMeleeArmour = buffer.ReadShort();
DisplayedAttack = buffer.ReadShort();
DisplayedRange = buffer.ReadFloat();
DisplayedReloadTime = buffer.ReadFloat();
}
public override void ReadData(RAMBuffer buffer)
{
One = buffer.ReadByte();
Name = buffer.ReadString(20);
int resourceCount = buffer.ReadUShort();
TechTreeID = buffer.ReadShort();
TeamBonusID = buffer.ReadShort();
Resources = new List<float>(resourceCount);
for(int i = 0; i < resourceCount; ++i)
Resources.Add(buffer.ReadFloat());
IconSet = buffer.ReadByte();
int unitCount = buffer.ReadUShort();
UnitPointers = new List<int>(unitCount);
for(int i = 0; i < unitCount; ++i)
UnitPointers.Add(buffer.ReadInteger());
Units = new SortedList<int, Unit>(unitCount);
for(int p = 0; p < UnitPointers.Count; ++p)
if(UnitPointers[p] != 0)
Units.Add(p, new Unit().ReadDataInline(buffer));
}
/// <summary>
/// Lädt die SLP-Daten.
/// </summary>
/// <param name="buffer">Ein Puffer mit den SLP-Daten. Die Leseposition wird entsprechend der Datenlänge erhöht.</param>
/// <remarks></remarks>
private void loadData(RAMBuffer buffer)
{
// Header
#region SLP-Header
_headers.Version = buffer.ReadString(4);
_headers.FrameCount = buffer.ReadUInteger();
_headers.Comment = buffer.ReadString(24);
#endregion SLP-Header
// Frame-Informationen: Header
#region Frame-Header
for(int i = 0; i < _headers.FrameCount; i++)
{
// Neues Frame-Header-Objekt erstellen
FrameInformationHeader aktFIH = new FrameInformationHeader();
// Der Zeichenindex in der SLP-Datei, an dem die Kommandotabelle des Frames beginnt
aktFIH.FrameCommandsOffset = buffer.ReadUInteger();
// Der Zeichenindex in der SLP-Datei, an dem die Umrissdaten (RowEdge) des Frames gespeichert sind
aktFIH.FrameOutlineOffset = buffer.ReadUInteger();
// Der Zeichenindex in der SLP-Datei, an dem die Farbpalette des Frames definiert ist; Genaueres ist nicht bekannt
aktFIH.PaletteOffset = buffer.ReadUInteger();
// Die Frame-Eigenschaften; die Bedeutung dieses Werts ist unbekannt
aktFIH.Properties = buffer.ReadUInteger();
// Die Abmessungen des Frames
aktFIH.Width = buffer.ReadUInteger();
aktFIH.Height = buffer.ReadUInteger();
// Die Anker (Mittelpunkt) des Frames
aktFIH.AnchorX = buffer.ReadInteger();
aktFIH.AnchorY = buffer.ReadInteger();
// Frame-Header in die zentrale Liste schreiben
_frameInformationHeaders.Add(aktFIH);
}
#endregion Frame-Header
// Frameinformationen: Daten
#region Frame-Daten (RowEdge und Kommandotabelle)
// Gefundene Einstellungen merken
bool useTransp = false;
bool useOutline1 = false;
bool useOutline2 = false;
bool usePlayerColor = false;
bool useShadow = false;
// Frames einzeln durchgehen
for(int i = 0; i < _headers.FrameCount; i++)
{
// Spielernummer einer ggf. ausgegebenen Einheit
const byte Spielernummer = 0; // Spieler 1 => Blau
// Frame-Header-Daten abrufen
FrameInformationHeader aktFIH = _frameInformationHeaders[i];
// Neues Frame-Daten-Objekt erstellen
FrameInformationData aktFID = new FrameInformationData();
// RowEdge (leere Fläche [=> Transparenz, ohne Kommandos], von den Bildrändern ausgehend)
#region RowEdge-Daten
// Arrays initialisieren: Das RowEdge-Array und das BinaryRowEdge-Array, um bei unveränderten Frames dieses nicht neu berechnen zu müssen und direkt schreiben zu können
aktFID.RowEdge = new ushort[aktFIH.Height, 2];
aktFID.BinaryRowEdge = new BinaryRowedge[aktFIH.Height];
for(int j = 0; j < aktFIH.Height; j++)
{
// Werte einlesen
ushort left = buffer.ReadUShort(); // Links
ushort right = buffer.ReadUShort(); // Rechts
// Evtl. falsche Werte korrigieren
{
// Links
if(left > aktFIH.Width)
{
left = (ushort)aktFIH.Width;
}
// Rechts
if(right > aktFIH.Width)
{
right = (ushort)aktFIH.Width;
}
}
// Werte speichern
aktFID.RowEdge[j, 0] = left;
aktFID.RowEdge[j, 1] = right;
// Binäres RowEdge mitschreiben
aktFID.BinaryRowEdge[j] = new BinaryRowedge(left, right);
}
#endregion RowEdge-Daten
// Kommandotabellen-Offsets abrufen
#region Kommandotabellen-Offsets
aktFID.CommandTableOffsets = new uint[aktFIH.Height];
for(int j = 0; j < aktFIH.Height; j++)
{
aktFID.CommandTableOffsets[j] = buffer.ReadUInteger();
}
#endregion Kommandotabellen-Offsets
// Kommandotabelle zeilenweise auslesen und umgewandelte Kommandotabelle erzeugen
#region Kommandotabelle
// Gleichzeitig wird die binaryCommands-Variable miterzeugt, um unveränderte Frames ggf. ohne Umweg über eine Neuerstellung der Kommandos wieder in die *.slp schreiben zu können
aktFID.CommandTable = new int[aktFIH.Height, aktFIH.Width];
aktFID.BinaryCommandTable = new List<BinaryCommand>();
for(int j = 0; j < aktFIH.Height; j++)
{
// Gibt die aktuelle X-Position innerhalb des generierten Bildes (in Pixeln) an
int aktPtr = 0;
// Linker RowEdge-Bereich ist leer => transparent, also -1
for(int k = 0; k < aktFID.RowEdge[j, 0]; k++)
{
aktFID.CommandTable[j, aktPtr + k] = -1;
}
// Linker RowEdge-Bereich ist komplett in das Bild geschrieben worden
aktPtr += aktFID.RowEdge[j, 0];
// Wird false, wenn ein Zeilenumbruch erreicht wurde
bool Weiter = true;
// Kommando für Kommando lesen
while(Weiter)
{
// Das aktuelle Kommandobyte
byte aktKommandoByte = buffer.ReadByte();
// Das aktuelle Kommando (die ersten vier Bits des Kommandobytes) Wird berechnet, um das oft mit der Datenlänge korrelierte Kommandobyte bestimmen zu können (es müssen nur die Werte 0 bis 15 abgefragt werden, statt eigentlich 0 bis 255; weiterhin geben immer die ersten 2 oder 4 Bits das Kommando an, die anderen 4 oder 6 meist nur die jeweilige Länge)
byte aktKommando = (byte)(aktKommandoByte & 0x0F);
// Das Kommando auswerten
switch(aktKommando)
{
// Farbblock (klein)
case 0x00:
case 0x04:
case 0x08:
case 0x0C:
{
// Länge ermitteln
int len = aktKommandoByte >> 2;
// Daten einlesen
byte[] dat = buffer.ReadByteArray(len);
// Daten in die Kommandotabelle schreiben
for(int k = 0; k < len; k++)
{
aktFID.CommandTable[j, aktPtr + k] = dat[k];
}
// Es wurden len Pixel eingelesen
aktPtr += len;
// Binary-Wert erstellen
cmdColor(ref aktFID, dat);
break;
}
// Transparenz (klein)
case 0x01:
case 0x05:
case 0x09:
case 0x0D:
{
// Länge ermitteln
int len = aktKommandoByte >> 2;
// Transparenz in die Kommandotabelle schreiben
for(int k = 0; k < len; k++)
{
aktFID.CommandTable[j, aktPtr + k] = -1;
}
// Es wurden len Pixel eingelesen
aktPtr += len;
// Binary-Wert erstellen
cmdTransp(ref aktFID, len);
// Transparenz wurde gefunden
useTransp = true;
break;
}
// Großer Farbblock
case 0x02:
{
// Hilfs-Kommandobyte auslesen
byte byte2 = buffer.ReadByte();
// Länge ermitteln
int len = ((aktKommandoByte & 0xF0) << 4) + byte2;
// Daten einlesen
byte[] dat = buffer.ReadByteArray(len);
// Daten in die Kommandotabelle schreiben
for(int k = 0; k < len; k++)
{
aktFID.CommandTable[j, aktPtr + k] = dat[k];
}
// Es wurden len Pixel eingelesen
aktPtr += len;
// Binary-Wert erstellen
cmdColor(ref aktFID, dat);
break;
}
// Großer Transparenzblock
case 0x03:
{
// Hilfs-Kommandobyte auslesen
byte byte2 = buffer.ReadByte();
// Länge ermitteln
int len = ((aktKommandoByte & 0xF0) << 4) + byte2;
// Transparenz in die Kommandotabelle schreiben
for(int k = 0; k < len; k++)
{
aktFID.CommandTable[j, aktPtr + k] = -1;
}
// Es wurden len Pixel eingelesen
aktPtr += len;
// Binary-Wert erstellen
cmdTransp(ref aktFID, len);
// Transparenz wurde gefunden
useTransp = true;
break;
}
// Spielerfarbenblock
case 0x06:
{
// Die oberen 4 Bits bestimmen
byte next4Bits = (byte)(aktKommandoByte & 0xF0);
// Die Länge der Daten
int len = 0;
// Die oberen 4 Bits sind 0, wenn die Länge im nächsten Byte angegeben ist; ansonsten werden diese um 4 nach rechts verschoben und sind somit als Längenangabe verwendbar
if(next4Bits == 0)
{
len = buffer.ReadByte();
}
else
{
len = next4Bits >> 4;
}
// Daten auslesen
byte[] dat = buffer.ReadByteArray(len);
// Daten durchgehen
for(int k = 0; k < len; k++)
{
// Das aktuelle Byte
byte aktVal = dat[k];
// Farbindex berechnen: Die Spielerfarben liegen zwischen 16 und 13. Beim SLP-Schreiben wurde von allen Werten 16 subtrahiert => aktVal liegt zwischen 0 und 7. Zwischen den Spielerfarben auf der Palette liegen immer 16 Einheiten. Angegeben wird die Spielerfarbe durch: 16 + (Spielernummer - 1) * 16, wobei die Spielernummer zwischen 1 und 8 liegt.
aktVal = (byte)(aktVal + 16 + 16 * Spielernummer);
// Wert in das Bild schreiben
aktFID.CommandTable[j, aktPtr + k] = aktVal;
// Wert zurück in Array schreiben, um das Schreiben der Binary-Daten zu erleichtern
dat[k] += 16;
}
// Es wurden len Pixel eingelesen
aktPtr += len;
// Binary-Wert erstellen
cmdPlayerColor(ref aktFID, dat);
// Spielerfarben wurden gefunden
usePlayerColor = true;
break;
}
// Einfarbiger Block
case 0x07:
{
// Die oberen 4 Bits bestimmen
byte next4Bits = (byte)(aktKommandoByte & 0xF0);
// Die Länge der Daten
int len = 0;
// Die oberen 4 Bits sind 0, wenn die Länge im nächsten Byte angegeben ist; ansonsten werden diese um 4 nach rechts verschoben und sind somit als Längenangabe verwendbar
if(next4Bits == 0)
{
len = buffer.ReadByte();
}
else
{
len = next4Bits >> 4;
}
// Das nächste Byte gibt die Farbe an
byte farbe = buffer.ReadByte();
// Hilfsvariable für das Binary-Schreiben
byte[] dat = new byte[len];
// Betroffene Pixel durchgehen
for(int k = 0; k < len; k++)
{
// Farbe in das Bild schreiben
aktFID.CommandTable[j, aktPtr + k] = farbe;
// Farbe in das Array übernehmen
dat[k] = farbe;
}
// Es wurden len Pixel eingelesen
aktPtr += len;
// Binary-Wert erstellen
cmdColor(ref aktFID, dat);
break;
}
// Einfarbiger Spielerfarben-Block
case 0x0A:
{
// Die oberen 4 Bits bestimmen
byte next4Bits = (byte)(aktKommandoByte & 0xF0);
// Die Länge der Daten
int len = 0;
// Die oberen 4 Bits sind 0, wenn die Länge im nächsten Byte angegeben ist; ansonsten werden diese um 4 nach rechts verschoben und sind somit als Längenangabe verwendbar
if(next4Bits == 0)
{
len = buffer.ReadByte();
}
else
{
len = next4Bits >> 4;
}
// Das nächste Byte gibt die Grundfarbe an
byte farbe = buffer.ReadByte();
// Hilfsvariable für das Binary-Schreiben
byte[] dat = new byte[len];
// Daten durchgehen
for(int k = 0; k < len; k++)
{
// Das aktuelle Byte
byte aktVal = farbe;
// Farbindex berechnen: Die Spielerfarben liegen zwischen 16 und 13. Beim SLP-Schreiben wurde von allen Werten 16 subtrahiert => aktVal liegt zwischen 0 und 7. Zwischen den Spielerfarben auf der Palette liegen immer 16 Einheiten. Angegeben wird die Spielerfarbe durch: 16 + (Spielernummer - 1) * 16, wobei die Spielernummer zwischen 1 und 8 liegt.
aktVal = (byte)(aktVal + 16 + 16 * Spielernummer);
// Wert in das Bild schreiben
aktFID.CommandTable[j, aktPtr + k] = aktVal;
// Wert zurück in Array schreiben, um das Schreiben der Binary-Daten zu erleichtern
dat[k] = (byte)(farbe + 16);
}
// Es wurden len Pixel eingelesen
aktPtr += len;
// Binary-Wert erstellen
cmdPlayerColor(ref aktFID, dat);
// Spielerfarben wurden gefunden
usePlayerColor = true;
break;
}
// Schattenblock
case 0x0B:
{
// Die oberen 4 Bits bestimmen
byte next4Bits = (byte)(aktKommandoByte & 0xF0);
// Die Länge der Daten
int len = 0;
// Die oberen 4 Bits sind 0, wenn die Länge im nächsten Byte angegeben ist; ansonsten werden diese um 4 nach rechts verschoben und sind somit als Längenangabe verwendbar
if(next4Bits == 0)
{
len = buffer.ReadByte();
}
else
{
len = next4Bits >> 4;
}
// Schattenpixel einzeln durchgehen
for(int k = 0; k < len; k++)
{
// Schatten in Bild schreiben
aktFID.CommandTable[j, aktPtr + k] = -4;
}
// Es wurden len Pixel eingelesen
aktPtr += len;
// Binary-Wert erstellen
cmdShadow(ref aktFID, len);
// Schatten wurde gefunden
useShadow = true;
break;
}
// Outline-Kommandos: Hängen von Kommandobyte ab ("E" am Ende bei allen gemeinsam)
case 0x0E:
{
switch(aktKommandoByte)
{
// Outline1-Pixel
case 0x4E:
{
// Outline auf Bild schreiben
aktFID.CommandTable[j, aktPtr] = -2;
// Es wurde ein Pixel eingelesen
aktPtr += 1;
// Binary-Wert erstellen
cmdOutline1(ref aktFID, 1);
// Outline1 wurde gefunden
useOutline1 = true;
break;
}
// Outline2-Pixel
case 0x6E:
{
// Outline auf Bild schreiben
aktFID.CommandTable[j, aktPtr] = -3;
// Es wurde ein Pixel eingelesen
aktPtr += 1;
// Binary-Wert erstellen
cmdOutline2(ref aktFID, 1);
// Outline2 wurde gefunden
useOutline2 = true;
break;
}
// Outline1-Block
case 0x5E:
{
// Blocklänge abrufen
int len = buffer.ReadByte();
// Outlinepixel in der angegebenen Anzahl auf das Bild schreiben
for(int k = 0; k < len; k++)
{
aktFID.CommandTable[j, aktPtr + k] = -2;
}
// Es wurden len Pixel eingelesen
aktPtr += len;
// Binary-Wert erstellen
cmdOutline1(ref aktFID, len);
// Outline1 wurde gefunden
useOutline1 = true;
break;
}
// Outline2-Block
case 0x7E:
{
// Blocklänge abrufen
int len = buffer.ReadByte();
// Outlinepixel in der angegebenen Anzahl auf das Bild schreiben
for(int k = 0; k < len; k++)
{
aktFID.CommandTable[j, aktPtr + k] = -3;
}
// Es wurden len Pixel eingelesen
aktPtr += len;
// Binary-Wert erstellen
cmdOutline2(ref aktFID, len);
// Outline2 wurde gefunden
useOutline2 = true;
break;
}
}
break;
}
// Zeilenende
case 0x0F:
{
// Kein weiterer while-Schleifen-Durchlauf => nächste Zeile (for-Schleife)
Weiter = false;
// Binary-Wert erstellen
cmdEOL(ref aktFID);
break;
}
} // Ende switch: Kommando auswerten
} // Ende while: Kommando für Kommando
// Rechtes RowEdge einfügen (leere Bereiche) Leere Bereiche sind transparent, also erstmal -1 als Palettenindex schreiben
for(int k = 0; k < aktFID.RowEdge[j, 1]; k++)
{
aktFID.CommandTable[j, aktPtr + k] = -1;
}
aktPtr += aktFID.RowEdge[j, 1];
} // Ende for: Zeile für Zeile
#endregion Kommandotabelle
// Framedaten zur zentralen Liste hinzufügen
_frameInformationData.Add(aktFID);
} // Ende for: Frame für Frame
// Einstellungen speichern
_settings = (useTransp ? Settings.UseTransparency : 0)
| (useOutline1 ? Settings.UseOutline1 : 0)
| (useOutline2 ? Settings.UseOutline2 : 0)
| (usePlayerColor ? Settings.UsePlayerColor : 0)
| (useShadow ? Settings.UseShadow : 0);
#endregion Frame-Daten (RowEdge und Kommandotabelle)
}
public override void ReadData(RAMBuffer buffer)
{
Name1 = buffer.ReadString(21);
Name2 = buffer.ReadString(13);
SLP = buffer.ReadInteger();
Unknown1 = buffer.ReadByte();
Unknown2 = buffer.ReadByte();
Layer = buffer.ReadByte();
PlayerColor = buffer.ReadByte();
Rainbow = buffer.ReadByte();
Replay = buffer.ReadByte();
Coordinates = new List<short>(4);
for(int i = 0; i < 4; ++i)
Coordinates.Add(buffer.ReadShort());
int deltaCount = buffer.ReadUShort();
SoundID = buffer.ReadShort();
AttackSoundUsed = buffer.ReadByte();
FrameCount = buffer.ReadUShort();
AngleCount = buffer.ReadUShort();
NewSpeed = buffer.ReadFloat();
FrameRate = buffer.ReadFloat();
ReplayDelay = buffer.ReadFloat();
SequenceType = buffer.ReadByte();
ID = buffer.ReadShort();
MirroringMode = buffer.ReadByte();
Unknown3 = buffer.ReadByte();
Deltas = new List<GraphicDelta>(deltaCount);
for(int i = 0; i < deltaCount; ++i)
Deltas.Add(new GraphicDelta().ReadDataInline(buffer));
if(AttackSoundUsed != 0)
{
AttackSounds = new List<GraphicAttackSound>(AngleCount);
for(int i = 0; i < AngleCount; ++i)
AttackSounds.Add(new GraphicAttackSound().ReadDataInline(buffer));
}
}
public override void ReadData(RAMBuffer buffer)
{
Type = (UnitType)buffer.ReadByte();
NameLength1 = buffer.ReadUShort();
ID1 = buffer.ReadShort();
LanguageDLLName = buffer.ReadUShort();
LanguageDLLCreation = buffer.ReadUShort();
Class = buffer.ReadShort();
StandingGraphic1 = buffer.ReadShort();
StandingGraphic2 = buffer.ReadShort();
DyingGraphic1 = buffer.ReadShort();
DyingGraphic2 = buffer.ReadShort();
DeathMode = buffer.ReadByte();
HitPoints = buffer.ReadShort();
LineOfSight = buffer.ReadFloat();
GarrisonCapacity = buffer.ReadByte();
SizeRadius1 = buffer.ReadFloat();
SizeRadius2 = buffer.ReadFloat();
HPBarHeight1 = buffer.ReadFloat();
TrainSound1 = buffer.ReadShort();
TrainSound2 = buffer.ReadShort();
DeadUnitID = buffer.ReadShort();
PlacementMode = buffer.ReadByte();
AirMode = buffer.ReadByte();
IconID = buffer.ReadShort();
HideInEditor = buffer.ReadByte();
Unknown1 = buffer.ReadShort();
Enabled = buffer.ReadByte();
Disabled = buffer.ReadByte();
PlacementBypassTerrain1 = buffer.ReadShort();
PlacementBypassTerrain2 = buffer.ReadShort();
PlacementTerrain1 = buffer.ReadShort();
PlacementTerrain2 = buffer.ReadShort();
EditorRadius1 = buffer.ReadFloat();
EditorRadius2 = buffer.ReadFloat();
HillMode = buffer.ReadByte();
VisibleInFog = buffer.ReadByte();
TerrainRestriction = buffer.ReadShort();
FlyMode = buffer.ReadByte();
ResourceCapacity = buffer.ReadShort();
ResourceDecay = buffer.ReadFloat();
BlastType = buffer.ReadByte();
Unknown2 = buffer.ReadByte();
InteractionMode = buffer.ReadByte();
MinimapMode = buffer.ReadByte();
CommandAttribute = buffer.ReadByte();
Unknown3A = buffer.ReadFloat();
MinimapColor = buffer.ReadByte();
LanguageDLLHelp = buffer.ReadInteger();
LanguageDLLHotKeyText = buffer.ReadInteger();
HotKey = buffer.ReadInteger();
Unselectable = buffer.ReadByte();
Unknown6 = buffer.ReadByte();
UnknownSelectionMode = buffer.ReadByte();
Unknown8 = buffer.ReadByte();
SelectionMask = buffer.ReadByte();
SelectionShapeType = buffer.ReadByte();
SelectionShape = buffer.ReadByte();
Attribute = buffer.ReadByte();
Civilization = buffer.ReadByte();
Nothing = buffer.ReadShort();
SelectionEffect = buffer.ReadByte();
EditorSelectionColor = buffer.ReadByte();
SelectionRadius1 = buffer.ReadFloat();
SelectionRadius2 = buffer.ReadFloat();
HPBarHeight2 = buffer.ReadFloat();
ResourceStorages = new List<ResourceTuple<short, float, byte>>(3);
for(int i = 0; i < 3; ++i)
ResourceStorages.Add(new ResourceTuple<short, float, byte>() { Type = buffer.ReadShort(), Amount = buffer.ReadFloat(), Enabled = buffer.ReadByte() });
int damageGraphicCount = buffer.ReadByte();
DamageGraphics = new List<DamageGraphic>();
for(int i = 0; i < damageGraphicCount; ++i)
DamageGraphics.Add(new DamageGraphic().ReadDataInline(buffer));
SelectionSound = buffer.ReadShort();
DyingSound = buffer.ReadShort();
AttackMode = buffer.ReadByte();
EdibleMeat = buffer.ReadByte();
Name1 = buffer.ReadString(NameLength1);
ID2 = buffer.ReadShort();
ID3 = buffer.ReadShort();
if(Type >= UnitType.Flag)
Speed = buffer.ReadFloat();
if(Type >= UnitType.DeadFish)
DeadFish = new UnitTypes.DeadFish().ReadDataInline(buffer);
if(Type >= UnitType.Bird)
Bird = new UnitTypes.Bird().ReadDataInline(buffer);
if(Type >= UnitType.Type50)
Type50 = new UnitTypes.Type50().ReadDataInline(buffer);
if(Type == UnitType.Projectile)
Projectile = new UnitTypes.Projectile().ReadDataInline(buffer);
if(Type >= UnitType.Creatable)
Creatable = new UnitTypes.Creatable().ReadDataInline(buffer);
if(Type == UnitType.Building)
Building = new UnitTypes.Building().ReadDataInline(buffer);
}
