public void CosntructionRequestCantBeNull()
        {
            var offer = new MaterialType[] { MaterialType.Brick };
            var player = new Mock<IPlayer>();

            Assert.Throws<ArgumentNullException>(() => new Trade(offer, null, player.Object));
        }

        public void ConstructionOfferCantBeNull()
        {
            var request = new MaterialType[] { MaterialType.Brick };
            var player = new Mock<IPlayer>();

            Assert.Throws<ArgumentNullException>(() => new Trade(null, request, player.Object));
        }

        public void ConstructionPlayerCantBeNull()
        {
            var request = new MaterialType[] { MaterialType.Lumber };
            var offer = new MaterialType[] { MaterialType.Wool };

            Assert.Throws<ArgumentNullException>(() => new Trade(offer, request, null));
        }

 public static Material Create(string description, MaterialType type, HttpPostedFileBase file, BaseDbContext db)
 {
     if (!type.Match(file))
         return null;
     string uploadFileName = DateTime.Now.ToString("yyyyMMddHHmmss") + Path.GetExtension(file.FileName);
     string absolutFileName;
     switch (type)
     {
         case MaterialType.Identity:
             absolutFileName = HttpContext.Current.Server.MapPath("~/UserUpload/") + "Identity/" + uploadFileName;
             break;
         case MaterialType.Avatar:
             absolutFileName = HttpContext.Current.Server.MapPath("~/UserUpload/") + "Avatar/" + uploadFileName;
             break;
         default:
             absolutFileName = HttpContext.Current.Server.MapPath("~/UserUpload/") + "Administrator/" + uploadFileName;
             break;
     }
     //执行上传
     if (File.Exists(absolutFileName))
     {
         File.Delete(absolutFileName);
     }
     file.SaveAs(absolutFileName);
     Material material = new Material(uploadFileName, description, type);
     //添加Material记录
     db.Materials.Add(material);
     //保存更改
     db.SaveChanges();
     return db.Materials.Find(material.Id);
 }

 public Tile(int x, int y, int number, MaterialType material)
 {
     X = x;
     Y = y;
     Number = number;
     Rawmaterial = material;
 }

        public void FarmTest(MaterialType type)
        {
            var tile = new Tile(1, 2, 3, type);
            IRawMaterial material = tile.Farm();

            Assert.Equal(type, material.Type);
        }

 public Table(string model, MaterialType initialMaterial, decimal price, decimal height, 
     decimal initalLength, decimal initialWidth)
     : base(model, initialMaterial, price, height)
 {
     this.Length = initalLength;
     this.Width = initialWidth;
 }

 public Furniture(string initialModel, MaterialType initialMaterialType, decimal initialPrice, decimal initialHeight)
 {
     this.Model = initialModel;
     this.materialType = initialMaterialType;
     this.Price = initialPrice;
     this.Height = initialHeight;
 }

	public static void fillSchemesMap () {
		schemesMaterials = new Dictionary<WorkbenchSchemeType, MaterialType[]>();

		MaterialType[] materials = new MaterialType[2];
		materials[0] = MaterialType.STEEL_BAR;
		materials[1] = MaterialType.WOOD_STICK;
		schemesMaterials.Add(WorkbenchSchemeType.IRON_DAGGER, materials);

		materials = new MaterialType[3];
		materials[0] = MaterialType.STEEL_BAR;
		materials[1] = MaterialType.STEEL_BAR;
		materials[2] = MaterialType.WOOD_STICK;
		schemesMaterials.Add(WorkbenchSchemeType.IRON_SWORD, materials);

		materials = new MaterialType[3];
		materials[0] = MaterialType.STEEL_BAR;
		materials[1] = MaterialType.WOOD_STICK;
		materials[2] = MaterialType.WOOD_STICK;
		schemesMaterials.Add(WorkbenchSchemeType.IRON_AXE, materials);

		materials = new MaterialType[4];
		materials[0] = MaterialType.STEEL_BAR;
		materials[1] = MaterialType.STEEL_BAR;
		materials[2] = MaterialType.STEEL_BAR;
		materials[3] = MaterialType.STEEL_BAR;
		schemesMaterials.Add(WorkbenchSchemeType.STEEL_ARMOR, materials);
	}

 protected Furniture(string model, decimal price, decimal height, MaterialType material)
 {
     this.Model = model;
     this.Price = price;
     this.Height = height;
     this.material = material;
 }

 public ETool()
 {
     _processSpd = 0.0f;
     _swingType = SwingType.Dig;
     _materialType = MaterialType.Wood;
     _maxRange = 0;
 }

 protected Furniture(string model, MaterialType type, decimal price, decimal height)
 {
     this.Model = model;
     this._type = type;
     this.Price = price;
     this.Height = height;
 }

 public Table(string model, MaterialType material, decimal price, decimal height, decimal length, decimal width) 
     : base(model, material, price, height)
 {
     this.width = width;
     this.length = length;
     this.Area = this.Length*this.Width;
 }

        public void ConstructionCantTradeSeaAndDessert(MaterialType[] request, MaterialType[] offer)
        {
            var player = new Mock<IPlayer>();

            Assert.Throws<ArgumentException>(() => new Trade(offer, request, player.Object));

        }

 public Furniture(string model, MaterialType materialType, decimal price, decimal height)
 {
     this.Model = model;
     this.Price = price;
     this.material = materialType;
     this.height = height;
 }

        public Texture2D TextureFromVertices(Vertices vertices, MaterialType type, Color color, float materialScale)
        {
            // copy vertices
            Vertices verts = new Vertices(vertices);

            // scale to display units (i.e. pixels) for rendering to texture
            Vector2 scale = ConvertUnits.ToDisplayUnits(Vector2.One);
            verts.Scale(ref scale);

            // translate the boundingbox center to the texture center
            // because we use an orthographic projection for rendering later
            AABB vertsBounds = verts.GetCollisionBox();
            verts.Translate(-vertsBounds.Center);

            List<Vertices> decomposedVerts;
            if (!verts.IsConvex())
            {
                decomposedVerts = EarclipDecomposer.ConvexPartition(verts);
            }
            else
            {
                decomposedVerts = new List<Vertices>();
                decomposedVerts.Add(verts);
            }
            List<VertexPositionColorTexture[]> verticesFill =
                new List<VertexPositionColorTexture[]>(decomposedVerts.Count);

            materialScale /= _materials[type].Width;

            for (int i = 0; i < decomposedVerts.Count; ++i)
            {
                verticesFill.Add(new VertexPositionColorTexture[3 * (decomposedVerts[i].Count - 2)]);
                for (int j = 0; j < decomposedVerts[i].Count - 2; ++j)
                {
                    // fill vertices
                    verticesFill[i][3 * j].Position = new Vector3(decomposedVerts[i][0], 0f);
                    verticesFill[i][3 * j + 1].Position = new Vector3(decomposedVerts[i].NextVertex(j), 0f);
                    verticesFill[i][3 * j + 2].Position = new Vector3(decomposedVerts[i].NextVertex(j + 1), 0f);
                    verticesFill[i][3 * j].TextureCoordinate = decomposedVerts[i][0] * materialScale;
                    verticesFill[i][3 * j + 1].TextureCoordinate = decomposedVerts[i].NextVertex(j) * materialScale;
                    verticesFill[i][3 * j + 2].TextureCoordinate = decomposedVerts[i].NextVertex(j + 1) * materialScale;
                    verticesFill[i][3 * j].Color =
                        verticesFill[i][3 * j + 1].Color = verticesFill[i][3 * j + 2].Color = color;
                }
            }

            // calculate outline
            VertexPositionColor[] verticesOutline = new VertexPositionColor[2 * verts.Count];
            for (int i = 0; i < verts.Count; ++i)
            {
                verticesOutline[2 * i].Position = new Vector3(verts[i], 0f);
                verticesOutline[2 * i + 1].Position = new Vector3(verts.NextVertex(i), 0f);
                verticesOutline[2 * i].Color = verticesOutline[2 * i + 1].Color = Color.Black;
            }

            Vector2 vertsSize = new Vector2(vertsBounds.UpperBound.X - vertsBounds.LowerBound.X,
                                            vertsBounds.UpperBound.Y - vertsBounds.LowerBound.Y);
            return RenderTexture((int)vertsSize.X, (int)vertsSize.Y,
                                 _materials[type], verticesFill, verticesOutline);
        }

        public void InitialTileShouldBeDesert(MaterialType type)
        {
            var tile = new Mock<ITile>();
            tile.Setup(t => t.Rawmaterial).Returns(type);

            Assert.Throws<ArgumentException>(() => new Robber(tile.Object));
        }

 protected Furniture(string model, MaterialType materialType, decimal price, decimal height)
 {
     this.Model = model;
     this.Price = price;
     this.Height = height;
     this.Material = materialType.ToString();
 }

        public override List<IObject> GetNotCulledObjectsList(MaterialType? Filter, CullerComparer CullerComparer = CullerComparer.None, Vector3? CameraPosition = null)
        {         
                switch (CullerComparer)
                {
                    case CullerComparer.ComparerFrontToBack:
                        System.Diagnostics.Debug.Assert(CameraPosition.HasValue);
                        ComparerFrontToBack.CameraPosition = CameraPosition.Value;
                        forward.Sort(ComparerFrontToBack);
                        deferred.Sort(ComparerFrontToBack);
                        break;
                    case CullerComparer.ComparerBackToFront:
                        System.Diagnostics.Debug.Assert(CameraPosition.HasValue);
                        ComparerBackToFront.CameraPosition = CameraPosition.Value;
                        forward.Sort(ComparerBackToFront);
                        deferred.Sort(ComparerBackToFront);
                        break;
                    default:
                        break;
                }

            if (Filter == PloobsEngine.Material.MaterialType.DEFERRED)
                return deferred.ToList();
            else if (Filter == PloobsEngine.Material.MaterialType.FORWARD)
                return forward.ToList();
            else
            {
                List<IObject> objs = new List<IObject>();
                objs.AddRange(deferred);
                objs.AddRange(forward);
                return objs;
            }
        }

        public void AddChilds(MaterialCategoryObject materialCategory)
        {
            try
            {
                Revision blRev = new Revision();
                MaterialType bl = new MaterialType();
                materialCategory.Types = bl.GetByCategory(materialCategory);
                materialCategory.Revisions = blRev.GetByMaterialCategory(materialCategory);
                foreach (MaterialTypeObject materialType in  materialCategory.Types)
                {
                    materialType.SubTypes = new MaterialSubType().GetSubTypesByType(materialType);
                    materialType.Revisions = blRev.GetByMaterialType(materialType);
                    materialType.ChildsAdded = true;
                    foreach (MaterialSubTypeObject materialSubType in materialType.SubTypes)
                    {
                        materialSubType.Revisions = blRev.GetByMaterialSubType(materialSubType);
                        materialSubType.ChildsAdded = true;
                    }

                }
                materialCategory.ChildsAdded = true;
            }
            catch (Exception exception1)
            {
                Exception innerException = exception1;
                throw new Exception(MethodBase.GetCurrentMethod().Name, innerException);
            }
        }