Exemplo n.º 1
0
        public List <List <uint> > Tiles; // Contains entries per tile per frame

        public void Serialize(GMDataWriter writer)
        {
            writer.WritePointerString(Name);
            writer.WriteWideBoolean(Transparent);
            writer.WriteWideBoolean(Smooth);
            writer.WriteWideBoolean(Preload);
            writer.WritePointer(Texture);

            if (writer.VersionInfo.Major >= 2)
            {
                writer.Write(TileUnknown1);
                writer.Write(TileWidth);
                writer.Write(TileHeight);
                writer.Write(TileOutputBorderX);
                writer.Write(TileOutputBorderY);
                writer.Write(TileColumns);
                writer.Write((uint)Tiles[0].Count);
                writer.Write((uint)Tiles.Count);
                writer.Write(TileUnknown2);
                writer.Write(TileFrameLength);

                for (int i = 0; i < Tiles.Count; i++)
                {
                    if (i != 0 && Tiles[i].Count != Tiles[i - 1].Count)
                    {
                        writer.Warnings.Add(new GMWarning("Amount of frames is different across tiles", GMWarning.WarningLevel.Severe));
                    }
                    foreach (uint item in Tiles[i])
                    {
                        writer.Write(item);
                    }
                }
            }
        }
Exemplo n.º 2
0
 public void Serialize(GMDataWriter writer)
 {
     writer.WritePointerString(Name);
     writer.WriteWideBoolean(Smooth);
     writer.WriteWideBoolean(Closed);
     writer.Write(Precision);
     Points.Serialize(writer);
 }
Exemplo n.º 3
0
 public void Serialize(GMDataWriter writer)
 {
     writer.WriteWideBoolean(Enabled);
     writer.WriteWideBoolean(Foreground);
     writer.Write(BackgroundID);
     writer.Write(X); writer.Write(Y);
     writer.Write(TileX); writer.Write(TileY);
     writer.Write(SpeedX); writer.Write(SpeedY);
     writer.WriteWideBoolean(Stretch);
 }
Exemplo n.º 4
0
 public void Serialize(GMDataWriter writer)
 {
     writer.Write(Key);
     writer.Write(Length);
     writer.WriteWideBoolean(Stretch);
     writer.WriteWideBoolean(Disabled);
     writer.Write(Channels.Count);
     foreach (KeyValuePair <int, T> kvp in Channels)
     {
         writer.Write(kvp.Key);
         kvp.Value.Serialize(writer);
     }
 }
Exemplo n.º 5
0
 public void Serialize(GMDataWriter writer)
 {
     writer.WriteWideBoolean(Visible);
     writer.WriteWideBoolean(Foreground);
     writer.Write(SpriteID);
     writer.WriteWideBoolean(TileHorz);
     writer.WriteWideBoolean(TileVert);
     writer.WriteWideBoolean(Stretch);
     writer.Write(Color);
     writer.Write(FirstFrame);
     writer.Write(AnimationSpeed);
     writer.Write((int)AnimationSpeedType);
 }
Exemplo n.º 6
0
            public void Serialize(GMDataWriter writer)
            {
                writer.WritePointerString(Name);
                writer.Write(ID);
                writer.Write((int)Kind);
                writer.Write(Depth);
                writer.Write(OffsetX); writer.Write(OffsetY);
                writer.Write(HSpeed); writer.Write(VSpeed);
                writer.WriteWideBoolean(Visible);
                switch (Kind)
                {
                case LayerKind.Background:
                    Background.Serialize(writer);
                    break;

                case LayerKind.Instances:
                    Instances.Serialize(writer);
                    break;

                case LayerKind.Assets:
                    Assets.Serialize(writer);
                    break;

                case LayerKind.Tiles:
                    Tiles.Serialize(writer);
                    break;

                default:
                    writer.Warnings.Add(new GMWarning($"Unknown layer kind {Kind}"));
                    break;
                }
            }
Exemplo n.º 7
0
 public void Serialize(GMDataWriter writer)
 {
     writer.Write(LibID);
     writer.Write(ID);
     writer.Write(Kind);
     writer.WriteWideBoolean(UseRelative);
     writer.WriteWideBoolean(IsQuestion);
     writer.WriteWideBoolean(UseApplyTo);
     writer.Write(ExeType);
     writer.WritePointerString(ActionName);
     writer.Write(CodeID);
     writer.Write(ArgumentCount);
     writer.Write(Who);
     writer.WriteWideBoolean(Relative);
     writer.WriteWideBoolean(IsNot);
     writer.Write(0);
 }
Exemplo n.º 8
0
 public void Serialize(GMDataWriter writer)
 {
     writer.WritePointerString(Name);
     writer.Write(SpriteID);
     writer.WriteWideBoolean(Visible);
     writer.WriteWideBoolean(Solid);
     writer.Write(Depth);
     writer.WriteWideBoolean(Persistent);
     writer.Write(ParentObjectID);
     writer.Write(MaskSpriteID);
     writer.WriteWideBoolean(Physics);
     writer.WriteWideBoolean(PhysicsSensor);
     writer.Write((int)PhysicsShape);
     writer.Write(PhysicsDensity);
     writer.Write(PhysicsRestitution);
     writer.Write(PhysicsGroup);
     writer.Write(PhysicsLinearDamping);
     writer.Write(PhysicsAngularDamping);
     writer.Write(PhysicsVertices.Count);
     writer.Write(PhysicsFriction);
     writer.WriteWideBoolean(PhysicsAwake);
     writer.WriteWideBoolean(PhysicsKinematic);
     foreach (PhysicsVertex v in PhysicsVertices)
     {
         v.Serialize(writer);
     }
     Events.Serialize(writer);
 }
Exemplo n.º 9
0
 public void Serialize(GMDataWriter writer)
 {
     writer.WriteWideBoolean(Enabled);
     writer.Write(ViewX); writer.Write(ViewY);
     writer.Write(ViewWidth); writer.Write(ViewHeight);
     writer.Write(PortX); writer.Write(PortY);
     writer.Write(PortWidth); writer.Write(PortHeight);
     writer.Write(BorderX); writer.Write(BorderY);
     writer.Write(SpeedX); writer.Write(SpeedY);
     writer.Write(FollowObjectID);
 }
Exemplo n.º 10
0
 public void Serialize(GMDataWriter writer)
 {
     writer.Write(Left);
     writer.Write(Top);
     writer.Write(Right);
     writer.Write(Bottom);
     writer.WriteWideBoolean(Enabled);
     for (int i = 0; i < 5; i++)
     {
         writer.Write((int)TileModes[i]);
     }
 }
Exemplo n.º 11
0
 public void Serialize(GMDataWriter writer)
 {
     writer.Write(Value);
     writer.WriteWideBoolean(IsCurveEmbedded);
     if (IsCurveEmbedded)
     {
         writer.Write((int)-1);
         AnimCurve.Serialize(writer, false);
     }
     else
     {
         writer.Write(AnimCurveID);
     }
 }
Exemplo n.º 12
0
 public void Serialize(GMDataWriter writer)
 {
     writer.WritePointerString(Name);
     writer.WritePointerString(DisplayName);
     if (Size < 0)
     {
         Size = BitConverter.ToInt32(BitConverter.GetBytes(-SizeFloat));
     }
     writer.Write(Size);
     writer.WriteWideBoolean(Bold);
     writer.WriteWideBoolean(Italic);
     writer.Write(RangeStart);
     writer.Write(Charset);
     writer.Write(AntiAlias);
     writer.Write(RangeEnd);
     writer.WritePointer(TextureItem);
     writer.Write(ScaleX);
     writer.Write(ScaleY);
     if (writer.VersionInfo.FormatID >= 17)
     {
         writer.Write(AscenderOffset);
     }
     Glyphs.Serialize(writer);
 }
Exemplo n.º 13
0
        public void Serialize(GMDataWriter writer)
        {
            writer.WritePointerString(Name);
            writer.Write(Width);
            writer.Write(Height);
            writer.Write(MarginLeft);
            writer.Write(MarginRight);
            writer.Write(MarginBottom);
            writer.Write(MarginTop);
            writer.WriteWideBoolean(Transparent);
            writer.WriteWideBoolean(Smooth);
            writer.WriteWideBoolean(Preload);
            writer.Write(BBoxMode);
            writer.Write((int)SepMasks);
            writer.Write(OriginX);
            writer.Write(OriginY);

            if (SpecialOrGMS2)
            {
                // Special/GMS2 sprite type
                writer.Write(-1);
                if (writer.VersionInfo.IsNumberAtLeast(2, 3, 2))
                {
                    writer.Write(3);
                }
                else if (writer.VersionInfo.IsNumberAtLeast(2, 3))
                {
                    writer.Write(2);
                }
                else
                {
                    writer.Write(1);
                }
                writer.Write((int)S_SpriteType);
                if (writer.VersionInfo.IsNumberAtLeast(2))
                {
                    writer.Write(GMS2_PlaybackSpeed);
                    writer.Write((int)GMS2_PlaybackSpeedType);
                    if (writer.VersionInfo.IsNumberAtLeast(2, 3))
                    {
                        writer.WritePointer(GMS2_3_Sequence);
                        if (writer.VersionInfo.IsNumberAtLeast(2, 3, 2))
                        {
                            writer.WritePointer(GMS2_3_2_NineSlice);
                        }
                    }
                }

                switch (S_SpriteType)
                {
                case SpriteType.Normal:
                    TextureItems.Serialize(writer);
                    WriteMaskData(writer);
                    break;

                case SpriteType.SWF:
                    writer.Write(8);
                    TextureItems.Serialize(writer);
                    writer.Pad(4);
                    writer.Write(S_Buffer);
                    break;

                case SpriteType.Spine:
                    writer.Pad(4);
                    writer.Write(S_Buffer);
                    break;
                }

                if (GMS2_3_Sequence != null)
                {
                    writer.Pad(4);
                    writer.WriteObjectPointer(GMS2_3_Sequence);
                    GMS2_3_Sequence.Serialize(writer);
                }

                if (GMS2_3_2_NineSlice != null)
                {
                    writer.Pad(4);
                    writer.WriteObjectPointer(GMS2_3_2_NineSlice);
                    GMS2_3_2_NineSlice.Serialize(writer);
                }
            }
            else
            {
                // Normal sprite type
                TextureItems.Serialize(writer);
                WriteMaskData(writer);
            }
        }
Exemplo n.º 14
0
                public void Serialize(GMDataWriter writer)
                {
                    if (Variable != null)
                    {
                        if (Variable.Target != null)
                        {
                            List <int> l;
                            if (writer.VariableReferences.TryGetValue(Variable.Target, out l))
                            {
                                l.Add(writer.Offset);
                            }
                            else
                            {
                                writer.VariableReferences.Add(Variable.Target, new List <int> {
                                    writer.Offset
                                });
                            }
                        }
                        else
                        {
                            writer.Warnings.Add(new GMWarning($"Missing variable target at {writer.Offset}"));
                        }
                    }
                    else if (Function != null)
                    {
                        if (Function.Target != null)
                        {
                            List <int> l;
                            if (writer.FunctionReferences.TryGetValue(Function.Target, out l))
                            {
                                l.Add(writer.Offset);
                            }
                            else
                            {
                                writer.FunctionReferences.Add(Function.Target, new List <int> {
                                    writer.Offset
                                });
                            }
                        }
                        else
                        {
                            writer.Warnings.Add(new GMWarning($"Missing function target at {writer.Offset}"));
                        }
                    }

                    switch (GetInstructionType(Kind))
                    {
                    case InstructionType.SingleType:
                    case InstructionType.DoubleType:
                    case InstructionType.Comparison:
                    {
                        writer.Write(Extra);
                        if (writer.VersionInfo.FormatID <= 14 && Kind == Opcode.Cmp)
                        {
                            writer.Write((byte)0);
                        }
                        else
                        {
                            writer.Write((byte)ComparisonKind);
                        }
                        writer.Write((byte)((byte)Type2 << 4 | (byte)Type1));
                        if (writer.VersionInfo.FormatID <= 14)
                        {
                            writer.Write(NewOpcodeToOld((byte)Kind, (byte)ComparisonKind));
                        }
                        else
                        {
                            writer.Write((byte)Kind);
                        }
                    }
                    break;

                    case InstructionType.Branch:
                    {
                        if (writer.VersionInfo.FormatID <= 14)
                        {
                            writer.WriteInt24(JumpOffset);
                        }
                        else if (PopenvExitMagic)
                        {
                            writer.WriteInt24(0xF00000);
                        }
                        else
                        {
                            writer.WriteInt24((int)((uint)JumpOffset & ~0xFF800000));
                        }

                        if (writer.VersionInfo.FormatID <= 14)
                        {
                            writer.Write(NewOpcodeToOld((byte)Kind, 0));
                        }
                        else
                        {
                            writer.Write((byte)Kind);
                        }
                    }
                    break;

                    case InstructionType.Pop:
                    {
                        if (Type1 == DataType.Int16)
                        {
                            writer.Write(SwapExtra);
                            writer.Write((byte)((byte)Type2 << 4 | (byte)Type1));
                            if (writer.VersionInfo.FormatID <= 14)
                            {
                                writer.Write(NewOpcodeToOld((byte)Kind, 0));
                            }
                            else
                            {
                                writer.Write((byte)Kind);
                            }
                        }
                        else
                        {
                            writer.Write((short)TypeInst);
                            writer.Write((byte)((byte)Type2 << 4 | (byte)Type1));
                            if (writer.VersionInfo.FormatID <= 14)
                            {
                                writer.Write(NewOpcodeToOld((byte)Kind, 0));
                            }
                            else
                            {
                                writer.Write((byte)Kind);
                            }
                            Variable.Serialize(writer);
                        }
                    }
                    break;

                    case InstructionType.Push:
                    {
                        if (Type1 == DataType.Int16)
                        {
                            writer.Write((short)Value);
                        }
                        else if (Type1 == DataType.Variable)
                        {
                            writer.Write((short)TypeInst);
                        }
                        else
                        {
                            writer.Write((short)0);
                        }
                        writer.Write((byte)Type1);

                        if (writer.VersionInfo.FormatID <= 14)
                        {
                            writer.Write(NewOpcodeToOld((byte)Kind, 0));
                        }
                        else
                        {
                            writer.Write((byte)Kind);
                        }

                        switch (Type1)
                        {
                        case DataType.Double:
                            writer.Write((double)Value);
                            break;

                        case DataType.Float:
                            writer.Write((float)Value);
                            break;

                        case DataType.Int32:
                            if (Function != null)
                            {
                                Function.Serialize(writer);
                                break;
                            }
                            writer.Write((int)Value);
                            break;

                        case DataType.Int64:
                            writer.Write((long)Value);
                            break;

                        case DataType.Boolean:
                            writer.WriteWideBoolean((bool)Value);
                            break;

                        case DataType.Variable:
                            Variable.Serialize(writer);
                            break;

                        case DataType.String:
                            writer.Write((int)Value);             // string ID
                            break;
                            //case DataType.Int16:
                            //    break;
                        }
                    }
                    break;

                    case InstructionType.Call:
                    {
                        writer.Write(ArgumentsCount);
                        writer.Write((byte)Type1);
                        if (writer.VersionInfo.FormatID <= 14)
                        {
                            writer.Write(NewOpcodeToOld((byte)Kind, 0));
                        }
                        else
                        {
                            writer.Write((byte)Kind);
                        }
                        Function.Serialize(writer);
                    }
                    break;

                    case InstructionType.Break:
                    {
                        writer.Write((short)Value);
                        writer.Write((byte)Type1);
                        if (writer.VersionInfo.FormatID <= 14)
                        {
                            writer.Write(NewOpcodeToOld((byte)Kind, 0));
                        }
                        else
                        {
                            writer.Write((byte)Kind);
                        }
                    }
                    break;

                    default:
                        throw new Exception("Unknown opcode " + Kind.ToString());
                    }
                }
Exemplo n.º 15
0
 private void WriteOption(GMDataWriter writer, OptionsFlags flag)
 {
     writer.WriteWideBoolean((Options & flag) == flag);
 }
Exemplo n.º 16
0
            public void Serialize(GMDataWriter writer)
            {
                writer.WritePointerString(ModelName);
                writer.WritePointerString(Name);
                writer.Write(BuiltinName);
                writer.Write((int)Traits);
                writer.WriteWideBoolean(IsCreationTrack);

                writer.Write(Tags.Count);
                writer.Write(OwnedResources.Count);
                writer.Write(Tracks.Count);

                foreach (int i in Tags)
                {
                    writer.Write(i);
                }

                for (int i = 0; i < OwnedResources.Count; i++)
                {
                    writer.WritePointerString(OwnedResourceTypes[i]);
                    OwnedResources[i].Serialize(writer);
                }

                foreach (Track track in Tracks)
                {
                    track.Serialize(writer);
                }

                switch (ModelName.Content)
                {
                case "GMAudioTrack":
                {
                    Keyframes.Serialize(writer);
                }
                break;

                case "GMInstanceTrack":
                case "GMGraphicTrack":
                case "GMSequenceTrack":
                {
                    Keyframes.Serialize(writer);
                }
                break;

                case "GMSpriteFramesTrack":
                case "GMBoolTrack":
                {
                    Keyframes.Serialize(writer);
                }
                break;

                case "GMStringTrack":
                {
                    Keyframes.Serialize(writer);
                }
                break;

                case "GMColourTrack":
                case "GMRealTrack":
                {
                    Keyframes.Serialize(writer);
                }
                break;

                case "GMGroupTrack":
                    break;

                default:
                    throw new Exception(string.Format("Unknown sequence \"{0}\" model name.", ModelName.Content));
                }
            }
Exemplo n.º 17
0
        public override void Serialize(GMDataWriter writer)
        {
            base.Serialize(writer);

            writer.Write(DisableDebug);
            writer.Write(FormatID);
            writer.VersionInfo.FormatID = FormatID;
            writer.Write(Unknown);
            writer.WritePointerString(Filename);
            writer.WritePointerString(Config);
            writer.Write(LastObjectID);
            writer.Write(LastTileID);
            writer.Write(GameID);
            writer.Write(LegacyGUID.ToByteArray());
            writer.WritePointerString(GameName);
            writer.Write(Major);
            writer.Write(Minor);
            writer.Write(Release);
            writer.Write(Build);
            writer.VersionInfo.SetNumber(Major, Minor, Release, Build);
            writer.Write(DefaultWindowWidth);
            writer.Write(DefaultWindowHeight);
            writer.Write((uint)Info);
            writer.Write(LicenseCRC32);
            writer.Write(LicenseMD5);
            writer.Write(Timestamp);
            writer.WritePointerString(DisplayName);
            writer.Write(ActiveTargets);
            writer.Write((ulong)FunctionClassifications);
            writer.Write(SteamAppID);
            if (FormatID >= 14)
            {
                writer.Write(DebuggerPort);
            }

            writer.Write(RoomOrder.Count);
            for (int i = 0; i < RoomOrder.Count; i++)
            {
                writer.Write(RoomOrder[i]);
            }

            if (writer.VersionInfo.Major >= 2)
            {
                // Write random UID
                Random random      = new Random((int)(Timestamp & 4294967295L));
                long   firstRandom = (long)random.Next() << 32 | (long)random.Next();
                long   infoNumber  = Timestamp - 1000;
                ulong  temp        = (ulong)infoNumber;
                temp = ((temp << 56 & 18374686479671623680UL) | (temp >> 8 & 71776119061217280UL) |
                        (temp << 32 & 280375465082880UL) | (temp >> 16 & 1095216660480UL) | (temp << 8 & 4278190080UL) |
                        (temp >> 24 & 16711680UL) | (temp >> 16 & 65280UL) | (temp >> 32 & 255UL));
                infoNumber  = (long)temp;
                infoNumber ^= firstRandom;
                infoNumber  = ~infoNumber;
                infoNumber ^= ((long)GameID << 32 | (long)GameID);
                infoNumber ^= ((long)(DefaultWindowWidth + (int)Info) << 48 |
                               (long)(DefaultWindowHeight + (int)Info) << 32 |
                               (long)(DefaultWindowHeight + (int)Info) << 16 |
                               (long)(DefaultWindowWidth + (int)Info));
                infoNumber ^= FormatID;
                int infoLocation = Math.Abs((int)(Timestamp & 65535L) / 7 + (GameID - DefaultWindowWidth) + RoomOrder.Count) % 4;
                GMS2_RandomUID.Clear();
                writer.Write(firstRandom);
                GMS2_RandomUID.Add(firstRandom);
                for (int i = 0; i < 4; i++)
                {
                    if (i == infoLocation)
                    {
                        writer.Write(infoNumber);
                        GMS2_RandomUID.Add(infoNumber);
                    }
                    else
                    {
                        int first  = random.Next();
                        int second = random.Next();
                        writer.Write(first);
                        writer.Write(second);
                        GMS2_RandomUID.Add(((long)first << 32) | (long)second);
                    }
                }

                // Other GMS2-specific data
                writer.Write(GMS2_FPS);
                writer.WriteWideBoolean(GMS2_AllowStatistics);
                writer.Write(GMS2_GameGUID.ToByteArray());
            }
        }
Exemplo n.º 18
0
        public void Serialize(GMDataWriter writer)
        {
            writer.WritePointerString(Name);
            writer.WritePointerString(Caption);
            writer.Write(Width); writer.Write(Height);
            writer.Write(Speed);
            writer.WriteWideBoolean(Persistent);
            writer.Write(BackgroundColor);
            writer.WriteWideBoolean(DrawBackgroundColor);
            writer.Write(CreationCodeID);
            int flags = (int)Flags;

            if (writer.VersionInfo.IsNumberAtLeast(2, 3))
            {
                flags |= 0x30000;
            }
            else if (writer.VersionInfo.IsNumberAtLeast(2))
            {
                flags |= 0x20000;
            }
            writer.Write(flags);
            writer.WritePointer(Backgrounds);
            writer.WritePointer(Views);
            writer.WritePointer(GameObjects);
            writer.WritePointer(Tiles);
            writer.WriteWideBoolean(Physics);
            writer.Write(Top); writer.Write(Left);
            writer.Write(Right); writer.Write(Bottom);
            writer.Write(GravityX); writer.Write(GravityY);
            writer.Write(PixelsToMeters);
            int sequencePatch = -1;

            if (writer.VersionInfo.IsNumberAtLeast(2))
            {
                writer.WritePointer(Layers);
                if (writer.VersionInfo.IsNumberAtLeast(2, 3))
                {
                    sequencePatch = writer.Offset;
                    writer.Write(0);
                }
            }

            writer.WriteObjectPointer(Backgrounds);
            Backgrounds.Serialize(writer);
            writer.WriteObjectPointer(Views);
            Views.Serialize(writer);
            writer.WriteObjectPointer(GameObjects);
            GameObjects.Serialize(writer);
            writer.WriteObjectPointer(Tiles);
            Tiles.Serialize(writer);
            if (writer.VersionInfo.IsNumberAtLeast(2))
            {
                writer.WriteObjectPointer(Layers);
                Layers.Serialize(writer);
                if (writer.VersionInfo.IsNumberAtLeast(2, 3))
                {
                    // Patch and write sequence IDs
                    int returnTo = writer.Offset;
                    writer.Offset = sequencePatch;
                    writer.Write(returnTo);
                    writer.Offset = returnTo;

                    writer.Write(SequenceIDs.Count);
                    foreach (int i in SequenceIDs)
                    {
                        writer.Write(i);
                    }
                }
            }
        }