public void TestFlattering()
        {
            var source = new ModelObject
            {
                BaseDate = DateTime.Now,
                Sub = new ModelSubObject
                {
                    ProperName = "Some name",
                    SubSub = new ModelSubSubObject
                    {
                        IAmACoolProperty = "Cool daddy-o"
                    }
                },
                Sub2 = new ModelSubObject
                {
                    ProperName = "Sub 2 name"
                },
                SubWithExtraName = new ModelSubObject
                {
                    ProperName = "Some other name"
                },
            };

            var b =Mapper.Map<ModelObject, ModelDto>(source);

            Assert.AreEqual(source.BaseDate, b.BaseDate);
            Assert.AreEqual(source.Sub.ProperName, b.SubProperName);
            Assert.AreEqual(source.Sub2.ProperName, b.Sub2ProperName);
            Assert.AreEqual(source.SubWithExtraName.ProperName, b.SubWithExtraNameProperName);
            Assert.AreEqual(source.Sub.SubSub.IAmACoolProperty, b.SubSubSubIAmACoolProperty);
        }

        public void TestFlattering()
        {
            var source = new ModelObject
                {
                    BaseDate = DateTime.Now,
                    Sub = new ModelSubObject
                    {
                        ProperName = "Some name",
                        SubSub = new ModelSubSubObject
                        {
                            IAmACoolProperty = "Cool daddy-o"
                        }
                    },
                    Sub2 = new ModelSubObject
                    {
                        ProperName = "Sub 2 name"
                    },
                    SubWithExtraName = new ModelSubObject
                    {
                        ProperName = "Some other name"
                    },
                };

            var mapper = ObjectMapperManager.DefaultInstance.GetMapper<ModelObject, ModelDto>(
                new FlatteringConfig()
            );

            var b = mapper.Map(source);
        }

 protected override void Because_of()
 {
     var model = new ModelObject
     {
         Child = new SubChildModelObject {ChildProperty = "child property value"}
     };
     _result = Mapper.Map<ModelObject, DtoObject>(model);
 }

 //Controller rausgenommen
 public Waffen(ModelObject MO, int Lebenspunkte, float Schusswinkel, float ShootSpeed, string Waffentyp)
 {
     mo = MO;
     lebenspunkte = Lebenspunkte;
     schusswinkel = Schusswinkel;
     waffentyp = Waffentyp;
     shootspeed = ShootSpeed;
 }

        internal static dynamic[] Parse(Stream stream, string key)
        {
            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }

            var objects = new List<ModelObject>();

            using (BinaryReader reader = new BinaryReader(stream))
            {
                while (stream.Position < stream.Length)
                {
                    reader.ReadByte();
                    var language = reader.ReadByte();
                    int id = 0x100 * reader.ReadByte() | reader.ReadByte();

                    dynamic entry = new ModelObject();
                    entry.id = id;

                    string name;

                    if ((id & 0xFF) == 0)
                    {
                        var bracket_name_data = reader.ReadBytes(0x20);
                        var name_data = reader.ReadBytes(0x20);
                        var phrases = reader.ReadInt32();
                        var block_size = reader.ReadInt32();

                        var length = 0;
                        for (; name_data[length] != 0x00; ++length);

                        name = ShiftJISFF11Encoding.ShiftJISFF11.GetString(name_data, 0, length);
                    }
                    else
                    {
                        var length = reader.ReadByte();
                        name = ShiftJISFF11Encoding.ShiftJISFF11.GetString(reader.ReadBytes(length), 0, length - 1);

                        if (language == 1)
                        {
                            reader.ReadBytes(reader.ReadByte());
                        }
                    }

                    entry[key] = name;

                    objects.Add(entry);
                }
            }

            return objects.ToArray();
        }

 public void AddInstance(ModelObject obj)
 {
     if (obj.MModel != null && obj.MModel != this)
     {
         throw new ModelException("The object "+obj+" is already contained by another model.");
     }
     else
     {
         this.instances.Add(obj);
         obj.MModel = this;
     }
 }

            protected override void Establish_context()
            {
                Mapper.AddFormatter<HardEncoder>();
                Mapper.AddFormatter(new SoftEncoder());
                Mapper.AddFormatter(typeof(RokkenEncoder));
                Mapper.AddFormatExpression(context => context.SourceValue + " Medium");

                Mapper.CreateMap<ModelObject, ModelDto>();

                var modelObject = new ModelObject { Value = 14 };

                _modelDto = Mapper.Map<ModelObject, ModelDto>(modelObject);
            }

        //private static List<Waffen> waffenListe = new List<Waffen>();
        public static Objekte createObj(int auswahl, Spieler spieler, float xPos, Vector2 rHv2s)
        {
            idnummer++;
            Vector3 startort = new Vector3(xPos, 2, -5);
            SceneObject newobj;
            Objekte dasobj;

            if (auswahl == 1)//Würfel
            {
                newobj = buildbox(startort, new Vector3(0.4f, 0.4f, 0.4f));
                DrawHelper.setmoney(spieler, -150, rHv2s);
                /*spieler.setMoney(spieler.getMoney() - 150); //Rohkosten abziehen
                Gamestart.setShowGeld(-150, 100);           //Kosten visualisieren
                */
                newobj.Physics.Mass = 1f;
            }
            else if (auswahl == 2)
            {
                ModelObject l = new ModelObject(startort, Quaternion.CreateFromAxisAngle(new Vector3(1,2,0),(float)Math.PI), new Vector3(1, 1, 1), CollisionType.ExactMesh, "", "L", 1f);
                l.SubModels[0].RenderMaterial.Diffuse = new Vector4(1, 1, 1, 1);
                l.SubModels[0].RenderMaterial.Specular = new Vector4(0.1f, 0.1f, 0.1f, 1);
                newobj = l;
                DrawHelper.setmoney(spieler, -200, rHv2s);
            }
            else if (auswahl == 3) // Latte
            {
                newobj = buildbox(startort, new Vector3(1.2f, 0.1f, 0.4f));
                DrawHelper.setmoney(spieler, -200, rHv2s);
                newobj.Physics.Mass = 2f;
            }
            else if (auswahl == 4) // Quader       das kommentierte ist die //Pyramide
            {
                newobj = buildbox(startort, new Vector3(0.8f, 0.4f, 0.4f));
                newobj.Physics.Mass = 2f;
                DrawHelper.setmoney(spieler, -200, rHv2s);
            }
            else
            {
                newobj = buildbox(startort, new Vector3(0.1f, 0.1f, 0.1f));
            }

            //TODO z-Achse sperren
            newobj.Physics.PositionUpdateMode = BEPUphysics.PositionUpdating.PositionUpdateMode.Continuous;
            newobj.Tag = idnummer;
            newobj.PhysicsMaterial.Bounciness = 0.2f;
            scene.Add(newobj);
            dasobj = new Objekte(newobj, 1, "blank");
            objListe.Add(dasobj); //Liste hinzufügen
            return dasobj;
        }

        //private static List<Waffen> waffenListe = new List<Waffen>();

        public static Objekte createObj(int auswahl, Spieler spieler, float xPos)
        {
            idnummer++;
            Vector3 startort = new Vector3(xPos, 2, -5);
            SceneObject newobj;
            Objekte dasobj;

            if (auswahl == 1)//Würfel
            {
                newobj = buildbox(startort, new Vector3(0.4f, 0.4f, 0.4f));
                spieler.setMoney(spieler.getMoney() - 150); //Rohkosten abziehen
                newobj.Physics.Mass = 1f;
            }
            else if (auswahl == 2)
            {
                ModelObject l = new ModelObject(startort, Quaternion.CreateFromAxisAngle(new Vector3(1,2,0),(float)Math.PI), new Vector3(1, 1, 1), CollisionType.ExactMesh, "", "L", 2f);
                newobj = l;
                spieler.setMoney(spieler.getMoney() - 200);
            }
            else if (auswahl == 3) // Latte
            {
                newobj = buildbox(startort, new Vector3(1.2f, 0.1f, 0.4f));
                spieler.setMoney(spieler.getMoney() - 200); //Rohkosten abziehen
                newobj.Physics.Mass = 2f;
            }
            else if (auswahl == 4) // Quader       das kommentierte ist die //Pyramide
            {
                newobj = buildbox(startort, new Vector3(0.8f, 0.4f, 0.4f));
                newobj.Physics.Mass = 2f;
                /*ModelObject p = new ModelObject(startort, Quaternion.CreateFromAxisAngle(new Vector3(1, 2, 0), (float)Math.PI), new Vector3(1, 1, 1), CollisionType.ExactMesh, "", "Pyramide", 1f);
                newobj = p;*/
                spieler.setMoney(spieler.getMoney() - 200);
            }
            else
            {
                newobj = buildbox(startort, new Vector3(0.1f, 0.1f, 0.1f));
            }

            //TODO z-Achse sperren
            newobj.Physics.PositionUpdateMode = BEPUphysics.PositionUpdating.PositionUpdateMode.Continuous;
            newobj.Tag = idnummer;
            newobj.PhysicsMaterial.Bounciness = 0.2f;
            scene.Add(newobj);
            dasobj = new Objekte(newobj, 1, "blank");
            objListe.Add(dasobj); //Liste hinzufügen
            return dasobj;
        }

        public void LoadStartObjects(int level)
        {
            if (level == 1)
            {
                Scene.ShowTriangleCount = true;
                ModelObject Welt = new ModelObject(new Vector3(0, -1.5f, -5f), Quaternion.Identity, new Vector3(1, 1, 1), CollisionType.ExactMesh, " ", "Welt_xna_rotiert", 0f);
                Welt.PhysicsMaterial.Bounciness = 0.2f;
                Welt.SubModels[0].RenderMaterial.Diffuse = new Vector4(1, 1, 1, 1);
                Welt.SubModels[0].RenderMaterial.Specular = new Vector4(0.1f, 0.1f, 0.1f, 0.1f);

                Welt.Name = "Welt";
                scene.Add(Welt);
                Objektverwaltung.addToUmgebungsListe(Welt);

                //Lädt Spielhintergrund
                LoadBackground("himmel");
            }
        }

        internal static dynamic[] Parse(Stream stream, string key)
        {
            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }

            Header header = stream.Read<Header>(0);
            // First valid value was included in the header to get the table size
            stream.Position -= 4;

            if (header.FileSize != stream.Length - 4)
            {
                throw new InvalidOperationException("Data is corrupt.");
            }

            var data = new byte[header.FileSize];
            stream.Read(data, 0, data.Length);
            for (var i = 0; i < data.Length; ++i)
            {
                data[i] ^= 0x80;
            }
            int[] table;
            using (var datastream = new MemoryStream(data))
            {
                table = datastream.ReadArray<int>((int)header.TableSize);
            }

            dynamic objects = new ModelObject[header.TableSize];

            for (var i = 0; i < table.Length; ++i)
            {
                var offset = table[i];
                var length = (int)(i + 1 < table.Length ? table[i + 1] : data.Length) - offset;

                for (; data[offset + length - 1] == 0; --length) ;

                objects[i] = new ModelObject {
                    {key, ShiftJISFF11Encoding.ShiftJISFF11.GetString(data, offset, length)}
                };
            }

            return objects;
        }

            protected override void Establish_context()
            {
                Mapper.Reset();

                var model = new ModelObject
                {
                    Child = new SubChildModelObject {ChildProperty = "child property value"}
                };

                Mapper.CreateMap<ModelObject, DtoObject>();

                Mapper.CreateMap<IChildModelObject, DtoChildObject>()
                    .Include<SubChildModelObject, SubDtoChildObject>();

                Mapper.CreateMap<SubChildModelObject, SubDtoChildObject>();

                Mapper.AssertConfigurationIsValid();

                _result = Mapper.Map<ModelObject, DtoObject>(model);
            }

        private static void PostProcess()
        {
            Console.WriteLine("Post-processing parsed data...");

            bool success = false;
            try
            {
                // Add log names for non-english languages
                foreach (var buff in model.buffs)
                {
                    if (buff.ContainsKey("ja"))
                    {
                        buff.jal = buff.ja;
                    }
                }

                // Populate ability recast table with proper names
                foreach (var recast in model.ability_recasts)
                {
                    foreach (var action in model.actions)
                    {
                        if (recast.id == action.recast_id)
                        {
                            recast.en = action.en;
                            recast.ja = action.ja;
                            break;
                        }
                    }
                }

                // Add categories to key items
                var category = "";
                for (var i = model.key_items.Count - 1; i >= 0; --i)
                {
                    dynamic ki = model.key_items[i];
                    if (ki.en.StartsWith("-"))
                    {
                        category = ki.en.Substring(1);
                        model.key_items.Remove(ki);
                    }
                    else
                    {
                        ki.category = category;
                    }
                }

                // Move item descriptions into separate table
                //TODO: Remove when shared resources are implemented
                model.item_descriptions = new List<dynamic> { };
                foreach (var item in model.items)
                {
                    dynamic item_description = new ModelObject();
                    item_description.id = item.id;
                    item_description.en = item.endesc;
                    item_description.ja = item.jadesc;

                    item.endesc = null;
                    item.jadesc = null;

                    model.item_descriptions.Add(item_description);
                }

                // Fill in linked auto-translate names
                foreach (var at in model.auto_translates)
                {
                    if (at.en.StartsWith("@"))
                    {
                        int id = int.Parse(at.en.Substring(2), NumberStyles.HexNumber);

                        string key;
                        switch ((char)at.en[1])
                        {
                        case 'A':
                            key = "zones";
                            break;
                        case 'C':
                            key = "spells";
                            break;
                        case 'J':
                            key = "jobs";
                            break;
                        case 'Y':
                            key = "actions";
                            break;
                        default:
                            throw new InvalidDataException(string.Format("Unknown auto-translate code: {0}", at.en));
                        }

                        dynamic item = null;
                        foreach (var i in model[key])
                        {
                            if (i.id == id)
                            {
                                item = i;
                                break;
                            }
                        }

                        if (item != null)
                        {
//.........这里部分代码省略.........

        public void Should_throw_a_mapping_exception()
        {
            var model = new ModelObject();
            model.NullableDate = "Lorem Ipsum";

            typeof(AutoMapperMappingException).ShouldBeThrownBy(() => Mapper.Map<ModelObject, ModelDto>(model));
        }

 private static void PrintScope(string indent, ModelObject scope)
 {
     foreach (var entry in scope.MChildren)
     {
         Console.WriteLine(indent + entry);
         if (entry.IsMetaScope())
         {
             PrintScope(indent + "  ", entry);
         }
     }
 }

 public void RemoveInstance(ModelObject obj)
 {
     this.instances.Remove(obj);
     obj.MModel = null;
 }

        public override void Convert(ResourceLocation source, ResourceLocation dest)
        {
            XmlReader xml = XmlReader.Create(source.GetStream);

            MeshData[] entities = null;
            ModelObject[] modelObjects = null;

            List<Material> materials = new List<Material>();
            List<TapeHelper> targetHelpers = new List<TapeHelper>();

            xml.Read();

            string srcPath = Path.GetDirectoryName(((FileLocation)source).Path);

            int depth;
            int index = 0;

            while (xml.Read())
            {
                if (xml.IsStartElement() && !xml.IsEmptyElement)
                {
                    switch (xml.Name)
                    {
                        case "Info":
                            depth = xml.Depth;
                            while (xml.Read() && xml.Depth > depth)
                            {
                                if (xml.IsStartElement() && !xml.IsEmptyElement)
                                {
                                    if (xml.Name == "MeshCount")
                                    {
                                        int meshCount = int.Parse(xml.ReadString());
                                        entities = new MeshData[meshCount];
                                        modelObjects = new ModelObject[meshCount];
                                    }
                                }
                            }
                            break;
                        case "Material":
                            //XmlReader xmlMats = xml.ReadSubtree();
                            depth = xml.Depth;
                            while (xml.Read() && xml.Depth > depth)
                            {
                                if (xml.IsStartElement() && !xml.IsEmptyElement)
                                {
                                    if (xml.Name == "Slot")
                                    {
                                        materials.Add(ParseMaterial(xml, dest, srcPath));
                                    }
                                }
                            }

                            Material defMat = new Material(null);
                            defMat.Ambient = Material.DefaultMaterial.Ambient;
                            defMat.Diffuse = Material.DefaultMaterial.Diffuse;
                            defMat.Specular = Material.DefaultMaterial.Specular;
                            defMat.Emissive = Material.DefaultMaterial.Emissive;
                            materials.Add(defMat);
                            //materialArray = materials.ToArray();
                            //xmlMats.Close();
                            break;
                        case "Object":
                            string objName = xml.GetAttribute("Name");
                            string objClass = xml.GetAttribute("Class");
                            int oindex = int.Parse(xml.GetAttribute("ID"));

                            switch (objClass)
                            {
                                case "Editable_mesh":
                                    modelObjects[index] = ParseMeshData(xml);

                                    modelObjects[index].Index = oindex;

                                    entities[index] = modelObjects[index].Mesh;
                                    entities[index].Name = objName;

                                    index++;
                                    break;

                                //case "Tape":
                                //    Vector3 pos = ParseTapeTarget(xml);


                                //    break;
                                //case "Targetobject":
                                //    pos = ParseTapeTarget(xml);


                                //    break;
                                case "BoneGeometry":

                                    break;
                            }
                            break;
                    }
                }
            }

            xml.Close();

//.........这里部分代码省略.........

 protected override void Because_of()
 {
     _model = new ModelObject();
     _dto = Mapper.Map<ModelObject, ModelDto>(_model);
 }

 private void CheckXsdNamespace(SoalType type, ModelObject symbol)
 {
     if (!type.HasXsdNamespace())
     {
         this.Diagnostics.AddError("The type of this element has no XSD namespace.", this.FileName, symbol);
     }
 }

        private static void ParseFields(string name)
        {
            bool result = false;

            try
            {
                dynamic[] parsed = null;

                foreach (var filepair in DatLut[name])
                {
                    using (FileStream stream = File.OpenRead(GetPath(filepair.Key)))
                    {
                        var single = DatParser.Parse(stream, filepair.Value);
                        if (parsed == null)
                        {
                            parsed = single;
                            continue;
                        }

                        for (var i = 0; i < Math.Min(parsed.Length, single.Length); ++i)
                        {
                            parsed[i].Merge(single[i]);
                        }
                    }
                }

                if (model[name].Count > 0)
                {
                    foreach (var obj in model[name])
                    {
                        obj.Merge(parsed[obj.id]);
                    }
                }
                else
                {
                    for (var i = 0; i < parsed.Length; ++i)
                    {
                        dynamic obj = new ModelObject();
                        obj.id = i;

                        obj.Merge(parsed[i]);

                        model[name].Add(obj);
                    }
                }

                result = true;
            }
            finally
            {
                DisplayResult(result);
            }
        }