Esempio n. 1
0
            /// <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);
            }
Esempio n. 2
0
        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);
        }
Esempio n. 3
0
        public void WriteData(RAMBuffer buffer)
        {
            buffer.WriteInteger(VirtualFunctionPtr);
            buffer.WriteInteger(MapPointer);
            buffer.WriteInteger(MapWidth);
            buffer.WriteInteger(MapHeight);
            buffer.WriteInteger(WorldWidth);
            buffer.WriteInteger(WorldHeight);

            AssertListLength(TileSizes, 19);
            TileSizes.ForEach(ts => ts.WriteData(buffer));

            buffer.WriteShort(PaddingTS);

            Terrains.ForEach(t => t.WriteData(buffer));

            AssertListLength(TerrainBorders, 16);
            TerrainBorders.ForEach(tb => tb.WriteData(buffer));

            buffer.WriteInteger(MapRowOffset);
            buffer.WriteFloat(MapMinX);
            buffer.WriteFloat(MapMinY);
            buffer.WriteFloat(MapMaxX);
            buffer.WriteFloat(MapMaxY);
            buffer.WriteFloat(MapMaxXplus1);
            buffer.WriteFloat(MapMaxYplus1);

            buffer.WriteUShort(TerrainsUsed2);
            buffer.WriteUShort(BordersUsed);
            buffer.WriteShort(MaxTerrain);
            buffer.WriteShort(TileWidth);
            buffer.WriteShort(TileHeight);
            buffer.WriteShort(TileHalfHeight);
            buffer.WriteShort(TileHalfWidth);
            buffer.WriteShort(ElevHeight);
            buffer.WriteShort(CurRow);
            buffer.WriteShort(CurCol);
            buffer.WriteShort(BlockBegRow);
            buffer.WriteShort(BlockEndRow);
            buffer.WriteShort(BlockBegCol);
            buffer.WriteShort(BlockEndCol);

            buffer.WriteInteger(SearchMapPtr);
            buffer.WriteInteger(SearchMapRowsPtr);
            buffer.WriteByte(AnyFrameChange);

            buffer.WriteByte(MapVisibleFlag);
            buffer.WriteByte(FogFlag);

            AssertListLength(SomeBytes, 21);
            SomeBytes.ForEach(b => buffer.WriteByte(b));

            AssertListLength(SomeInt32, 157);
            SomeInt32.ForEach(i => buffer.WriteInteger(i));
        }
Esempio n. 4
0
 /// <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);
 }
Esempio n. 5
0
        public void WriteData(RAMBuffer buffer)
        {
            buffer.WriteByte(Exists);

            if (Exists != 0)
            {
                buffer.WriteUShort((ushort)Commands.Count);
                Commands.ForEach(e => e.WriteData(buffer));
            }
        }
Esempio n. 6
0
        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);
            }
        }
Esempio n. 7
0
        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));
            }
        }
Esempio n. 8
0
        public void WriteData(RAMBuffer buffer)
        {
            buffer.WriteShort(DefaultArmor);

            buffer.WriteUShort((ushort)Attacks.Count);
            foreach (KeyValuePair <ushort, ushort> currA in Attacks)
            {
                buffer.WriteUShort(currA.Key);
                buffer.WriteUShort(currA.Value);
            }

            buffer.WriteUShort((ushort)Armors.Count);
            foreach (KeyValuePair <ushort, ushort> currA in Armors)
            {
                buffer.WriteUShort(currA.Key);
                buffer.WriteUShort(currA.Value);
            }

            buffer.WriteShort(TerrainRestrictionForDamageMultiplying);
            buffer.WriteFloat(MaxRange);
            buffer.WriteFloat(BlastRadius);
            buffer.WriteFloat(ReloadTime);
            buffer.WriteShort(ProjectileUnitID);
            buffer.WriteShort(ProjectileAccuracyPercent);
            buffer.WriteByte(TowerMode);
            buffer.WriteShort(ProjectileFrameDelay);

            AssertListLength(ProjectileGraphicDisplacement, 3);
            ProjectileGraphicDisplacement.ForEach(e => buffer.WriteFloat(e));

            buffer.WriteByte(BlastLevel);
            buffer.WriteFloat(MinRange);
            buffer.WriteFloat(ProjectileDispersion);
            buffer.WriteShort(AttackGraphic);
            buffer.WriteShort(DisplayedMeleeArmor);
            buffer.WriteShort(DisplayedAttack);
            buffer.WriteFloat(DisplayedRange);
            buffer.WriteFloat(DisplayedReloadTime);
        }
Esempio n. 9
0
        /// <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);
        }
Esempio n. 10
0
 public void WriteData(RAMBuffer buffer)
 {
     buffer.WriteString(Name, 31);
     buffer.WriteUShort((ushort)Effects.Count);
     Effects.ForEach(e => e.WriteData(buffer));
 }
Esempio n. 11
0
            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);
                }
            }
Esempio n. 12
0
        /// <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
        }