Exemplo n.º 1
0
        public override string ToString()
        {
            switch (Type)
            {
            case NBTType.Bytes:
                return(String.Format("{0}[{1}] {2}", Type, GetBytes().Length, Name));

            case NBTType.List:
                NBTList list = (NBTList)this;
                return(String.Format("{0}<{1}>[{2}] {3}", Type, list.ListType, list.Tags.Length, Name));

            case NBTType.Compound:
                NBTCompound comp = (NBTCompound)this;
                return(String.Format("{0}[{1}] {2}", Type, comp.Tags.Count, Name));

            case NBTType.String:
                if (Payload != null)
                {
                    return(String.Format("{0} {1} = \"{2}\"", Type, Name, Payload));
                }
                else
                {
                    return(String.Format("{0} {1} = null", Type, Name));
                }

            default:
                return(String.Format("{0} {1} = {2}", Type, Name, Payload));
            }
        }
Exemplo n.º 2
0
        public NBTCompound SerializeNBT()
        {
            HasChangedSinceSave = false;
            NBTCompound tag = new NBTCompound("SuperImageEvolver");

            tag.Append("FormatVersion", FormatVersion);
            tag.Append("Shapes", Shapes);
            tag.Append("Vertices", Vertices);
            tag.Append("ImprovementCounter", ImprovementCounter);
            tag.Append("MutationCounter", MutationCounter);
            tag.Append("RiskyMoveCounter", RiskyMoveCounter);
            tag.Append("ElapsedTime", DateTime.UtcNow.Subtract(TaskStart).Ticks);

            tag.Append(ProjectOptions.SerializeNBT());

            tag.Append(BestMatch.SerializeNBT("BestMatch"));

            NBTag initializerTag = ModuleManager.WriteModule("Initializer", Initializer);

            tag.Append(initializerTag);

            NBTag mutatorTag = ModuleManager.WriteModule("Mutator", Mutator);

            tag.Append(mutatorTag);

            NBTag evaluatorTag = ModuleManager.WriteModule("Evaluator", Evaluator);

            tag.Append(evaluatorTag);

            byte[] imageData;
            using (MemoryStream ms = new MemoryStream()) {
                lock ( OriginalImage ) {
                    OriginalImage.Save(ms, ImageFormat.Png);
                }
                ms.Flush();
                imageData = new byte[ms.Length];
                Buffer.BlockCopy(ms.GetBuffer(), 0, imageData, 0, imageData.Length);
            }

            tag.Append("ImageData", imageData);

            List <NBTCompound> statTags = new List <NBTCompound>();

            foreach (MutationType mtype in Enum.GetValues(typeof(MutationType)))
            {
                NBTCompound stat = new NBTCompound("MutationTypeStat");
                stat.Append("Type", mtype.ToString());
                stat.Append("Count", MutationCounts[mtype]);
                stat.Append("Sum", MutationImprovements[mtype]);
                statTags.Add(stat);
            }
            var stats = new NBTList("MutationStats", NBTType.Compound, statTags.ToArray());

            tag.Append(stats);

            return(tag);
        }
Exemplo n.º 3
0
        public NBTag SerializeNBT(string tagName)
        {
            NBTCompound compound = new NBTCompound(tagName);

            compound.Append("Divergence", Divergence);
            NBTList tag = new NBTList("Shapes", NBTType.Compound, Shapes.Length);

            for (int i = 0; i < Shapes.Length; i++)
            {
                tag[i] = Shapes[i].SerializeNBT();
            }
            compound.Append(tag);
            return(compound);
        }
Exemplo n.º 4
0
        public NBTag SerializeNBT()
        {
            NBTCompound tag = new NBTCompound("Shape");

            tag.Append("Color", Color);
            NBTList points = new NBTList("Points", NBTType.PointF, Points.Length);

            for (int p = 0; p < Points.Length; p++)
            {
                points[p] = new NBTag(NBTType.PointF, null, Points[p], points);
            }
            tag.Append(points);
            return(tag);
        }
Exemplo n.º 5
0
        public string ToString(bool recursive)
        {
            string  output   = GetIndentedName() + Environment.NewLine;
            NBTList thisList = this as NBTList;

            if (thisList == null ||
                thisList.ListType == NBTType.Compound ||
                thisList.ListType == NBTType.Bytes ||
                thisList.ListType == NBTType.List)
            {
                foreach (NBTag tag in this)
                {
                    output += tag.ToString(recursive);
                }
            }
            return(output);
        }
Exemplo n.º 6
0
        public void WriteTag(BinaryWriter writer, bool writeType)
        {
            if (writeType)
            {
                writer.Write((byte)Type);
            }
            if (Type == NBTType.End)
            {
                return;
            }
            if (writeType)
            {
                WriteString(Name, writer);
            }
            switch (Type)
            {
            case NBTType.Byte:
                writer.Write((byte)Payload);
                return;

            case NBTType.Short:
                writer.Write((short)Payload);
                return;

            case NBTType.Int:
                writer.Write((int)Payload);
                return;

            case NBTType.Long:
                writer.Write((long)Payload);
                return;

            case NBTType.Float:
                writer.Write((float)Payload);
                return;

            case NBTType.Double:
                writer.Write((double)Payload);
                return;

            case NBTType.Bytes:
                writer.Write(((byte[])Payload).Length);
                writer.Write((byte[])Payload);
                return;

            case NBTType.String:
                WriteString((string)Payload, writer);
                return;

            case NBTType.Bool:
                writer.Write((bool)Payload);
                return;

            case NBTType.Color:
                writer.Write(((Color)Payload).ToArgb());
                return;

            case NBTType.Point:
                writer.Write(((Point)Payload).X);
                writer.Write(((Point)Payload).Y);
                break;

            case NBTType.PointF:
                writer.Write(((PointF)Payload).X);
                writer.Write(((PointF)Payload).Y);
                break;


            case NBTType.List:
                NBTList list = (NBTList)this;
                writer.Write((byte)list.ListType);
                writer.Write(list.Tags.Length);

                for (int i = 0; i < list.Tags.Length; i++)
                {
                    list.Tags[i].WriteTag(writer, false);
                }
                return;


            case NBTType.Compound:
                foreach (NBTag tag in this)
                {
                    tag.WriteTag(writer, true);
                }
                writer.Write((byte)NBTType.End);
                return;

            default:
                return;
            }
        }
Exemplo n.º 7
0
        public static NBTag ReadTag(BinaryReader reader, NBTType type, string name, NBTag parent)
        {
            if (name == null && type != NBTType.End)
            {
                name = ReadString(reader);
            }
            switch (type)
            {
            case NBTType.End:
                return(new NBTag(NBTType.End, parent));

            case NBTType.Byte:
                return(new NBTag(NBTType.Byte, name, reader.ReadByte(), parent));

            case NBTType.Short:
                return(new NBTag(NBTType.Short, name, reader.ReadInt16(), parent));

            case NBTType.Int:
                return(new NBTag(NBTType.Int, name, reader.ReadInt32(), parent));

            case NBTType.Long:
                return(new NBTag(NBTType.Long, name, reader.ReadInt64(), parent));

            case NBTType.Float:
                return(new NBTag(NBTType.Float, name, reader.ReadSingle(), parent));

            case NBTType.Double:
                return(new NBTag(NBTType.Double, name, reader.ReadDouble(), parent));

            case NBTType.Bytes:
                int bytesLength = reader.ReadInt32();
                return(new NBTag(NBTType.Bytes, name, reader.ReadBytes(bytesLength), parent));

            case NBTType.String:
                return(new NBTag(NBTType.String, name, ReadString(reader), parent));


            case NBTType.Bool:
                return(new NBTag(NBTType.Bool, name, reader.ReadBoolean(), parent));

            case NBTType.Color:
                return(new NBTag(NBTType.Color, name, Color.FromArgb(reader.ReadInt32()), parent));

            case NBTType.Point:
                int iX = reader.ReadInt32();
                int iY = reader.ReadInt32();
                return(new NBTag(NBTType.Point, name, new Point(iX, iY), parent));

            case NBTType.PointF:
                float fX = reader.ReadSingle();
                float fY = reader.ReadSingle();
                return(new NBTag(NBTType.PointF, name, new PointF(fX, fY), parent));


            case NBTType.List:
                NBTList list = new NBTList {
                    Type     = NBTType.List,
                    Name     = name,
                    Parent   = parent,
                    ListType = (NBTType)reader.ReadByte()
                };
                int listLength = reader.ReadInt32();
                list.Tags = new NBTag[listLength];
                for (int i = 0; i < listLength; i++)
                {
                    list.Tags[i] = ReadTag(reader, list.ListType, "", list);
                }
                return(list);


            case NBTType.Compound:
                NBTCompound compound = new NBTCompound(name)
                {
                    Parent = parent
                };
                while (true)
                {
                    NBTag childTag = ReadTag(reader, (NBTType)reader.ReadByte(), null, compound);
                    if (childTag.Type == NBTType.End)
                    {
                        break;
                    }
                    if (childTag.Name == null)
                    {
                        continue;
                    }
                    if (compound.Tags.ContainsKey(childTag.Name))
                    {
                        throw new IOException(
                                  "NBT parsing error: null names and duplicate names are not allowed within a compound tags.");
                    }
                    else
                    {
                        compound.Tags.Add(childTag.Name, childTag);
                    }
                }
                return(compound);

            default:
                throw new IOException("NBT parsing error: unknown tag type.");
            }
        }