public Hero(ObjectType mObjectType, ContentManager content,
            SpriteState defaultState, Vector2 SpritePosition)
            : base(mObjectType, content, defaultState, SpritePosition, Hostility.FRIENDLY)
        {
            mSpriteScale = 0.8f;
            this.mSprite.SpriteScale = mSpriteScale;
            this.hostility = Hostility.FRIENDLY;
            SetUnitAnimation();
            mTarget = SpritePosition;
            mBehaviorHero = new BehaviorHero(1.0f, mTarget);
            mObjectID = mGlobalID;
            mGlobalID++;
            mheroAttribute = new HeroAttribute(this, content);
            SetAttributes();

            int mAttackLevel = (int)HeroAttribute.AttackUpgradeLevel;
            int mDefenseLevel = (int)HeroAttribute.DefenseUpgradeLevel;

            for (int i = 0; i < mAttackLevel; i++)
            {
                mheroAttribute.UpgradeAttack();
            }

            for (int i = 0; i < mDefenseLevel; i++)
            {
                mheroAttribute.UpgradeDefense();
            }
        }

        public static async Task<ObjectWriteResult> CreateTempFile(ObjectType type, int length, byte[] data, string rootPath)
        {
            var name = Path.Combine(rootPath, "tmp" + _random.Next(0, int.MaxValue));
            
            using (var file = File.OpenWrite(name))
            using (var stream = CompressionStream.CompressStream(file))
            using (var md = new MessageDigest())
            {
                var header = Encoding.ASCII.GetBytes(string.Format("{0} {1}\0", type.ToTypeCode(), length));

                await stream.WriteAsync(header, 0, header.Length);
                await stream.WriteAsync(data, 0, data.Length);

                md.Update(header);
                md.Update(data);

                var digest = md.Digest();

                return new ObjectWriteResult
                {
                    FileInfo = new FileInfo(name),
                    ObjectId = Helper.ByteArrayToId(digest)
                };
            }
        }

 public Camera3D(string id, ObjectType objectType,
     Transform3D transform, ProjectionParameters projectionParameters, Viewport viewPort)
     : base(id, objectType, transform)
 {
     this.projectionParameters = projectionParameters;
     this.viewPort = viewPort;
 }

        private static void ReadHeader(Stream stream, out ObjectType type, out int size)
        {
            size = 0;
            var typeCode = string.Empty;
            var sb = new StringBuilder();
            var inHeader = true;

            while (inHeader)
            {
                var c = (char)stream.ReadByte();
                switch (c)
                {
                    case ' ':
                        typeCode = sb.ToString();
                        sb.Clear();
                        continue;
                    case '\0':
                        size = int.Parse(sb.ToString());
                        sb.Clear();
                        inHeader = false;
                        continue;
                }
                sb.Append(c);
            }

            type = ObjectTypeFromString(typeCode);
        }

    public void verifyTarget(GameObject obj)
    {
        if (_targetType != ObjectType.Unknown)
        {
            if (obj == _target)
            {
                if (hoverObject != null)
                {
                    if (hoverObject.GetComponent<ActionTile>())
                    {
                        Debug.Log("item");
                        hoverObject.GetComponent<ActionTile>().ClickAction(this.gameObject);
                    }
                    if (hoverObject.GetComponent<ActionCharacter>())
                    {
                        Debug.Log("character");
                        hoverObject.GetComponent<ActionCharacter>().ClickAction();
                    }
                    hoverObject = null;
                }
                else
                {
                    Debug.Log("no action possible");
                }

                _targetPos.x = this.transform.position.x;
                _targetPos.y = this.transform.position.y;
                scriptAnim.hasAnim = false;
                this.rigidbody.velocity = new Vector3(0, 0, 0);
                _targetType = ObjectType.Unknown;
            }
        }
    }

 public DrawnActor(string id, ObjectType objectType, Transform3D transform, Effect effect, Color color, float alpha)
     : base(id, objectType, transform)
 {
     this.Effect = effect;
     this.Color = color;
     this.Alpha = alpha;
 }

 public GameObject GetObject(ObjectType type, Vector3 pos, Quaternion rot)
 {
     
     switch(type)
     {
         case ObjectType.Bullet:
             tempList = BulletList;
         break;
     }
     itemFound = false;
     for(int i = 0; i < tempList.Count; i++)
     {
         if(!tempList[i].activeInHierarchy)
         {
           //  Debug.Log("ItemFound");
             tempList[i].SetActive(true);
             tempObj = tempList[i];
             tempObj.transform.position = pos;
             tempObj.transform.rotation = rot;
             itemFound = true;
             break;
         }
     }
     if(itemFound)
         return tempObj;
     else
         return CreateNewObject(type, pos, rot);
 }

        public override int ReadPrefix(string shortSha, out ObjectId id, out UnmanagedMemoryStream data, out ObjectType objectType)
        {
            id = null;
            data = null;
            objectType = default(ObjectType);

            ObjectId matchingKey;

            int ret = ExistsPrefix(shortSha, out matchingKey);

            if (ret != (int)ReturnCode.GIT_OK)
            {
                return ret;
            }

            ret = Read(matchingKey, out data, out objectType);

            if (ret != (int)ReturnCode.GIT_OK)
            {
                return ret;
            }

            id = matchingKey;

            return (int)ReturnCode.GIT_OK;
        }

 public PrimitiveObject(string id, ObjectType objectType,
     Transform3D transform, IVertexData vertexData, Effect effect, Color color, float alpha)
     : base(id, objectType, transform, effect, color, alpha)
 {
     this.vertexData = vertexData;
     this.effect = effect;
 }

 /// <summary>
 /// 构造物件
 /// </summary>
 /// <param name="x1">x坐标</param>
 /// <param name="y1">y坐标</param>
 /// <param name="hitTime1">击打时间</param>
 /// <param name="type1">物件种类</param>
 public HitObject(int x1, int y1, int hitTime1, ObjectType type1)
 {
     x = x1;
     y = y1;
     hitTime = hitTime1;
     type = type1;
 }

 public TrackCamera3D(string id, ObjectType objectType,
     Transform3D transform, ProjectionParameters projectionParameters,
     Viewport viewPort, Camera3DTrack track)
     : base(id, objectType, transform, projectionParameters, viewPort)
 {
     this.track = track;
 }

 public GameObject RequestPoolObject(ObjectType type, Vector3 position, Quaternion rotation)
 {
     if(objectPools[type].Count > 0)
     {
         // Get object of the specified kind from the pool
         GameObject obj = objectPools[type].Pop();
         // Set the specified position and rotation
         obj.transform.position = position;
         obj.transform.rotation = rotation;
         // Enable the object
         obj.SetActive(true);
         return obj;
     }
     else if (objectCount < HardSizeLimit)
     {
         // Create new object of the specified type and set it as a child of the pool game object
         GameObject obj = Instantiate (ObjectPrefabs[(int)type]);
         obj.transform.parent = transform;
         // Set the specified position and rotation
         obj.transform.position = position;
         obj.transform.rotation = rotation;
         // Update object count
         ++objectCount;
         return obj;
     }
     else
     {
         throw new System.Exception("Object Pool hard size limit reached. No more pool objects will be instantiated.");
     }
 }

 public void DisablePoolObject(GameObject obj, ObjectType type)
 {
     // Disable the object
     obj.SetActive(false);
     // Put it in the pool for this kind of object
     objectPools[type].Push(obj);
 }

 protected ConcreteObject(ObjectType objectType, ConcreteObjectBuilder builder)
     : base(objectType, builder)
 {
     m_name = builder.Name;
     m_color = builder.Color;
     m_materialID = builder.MaterialID;
 }

        public long ReadObjectHeader(out ObjectType type)
        {
            if (!IsStartOfStream)
                Rewind();

            long length;

            string typeString = ReadWord().GetString();
            switch (typeString)
            {
                case "blob":
                    type = ObjectType.Blob;
                    break;
                case "commit":
                    type = ObjectType.Commit;
                    break;
                case "tag":
                    type = ObjectType.Tag;
                    break;
                case "tree":
                    type = ObjectType.Tree;
                    break;
                default:
                    throw new ParseException("Unknown type: {0}".FormatWith(typeString));
            }
            length = ReadToNull().Sum(b => b);
            return length;
        }

        public Friendly(ObjectType mObjectType, ContentManager content,
                        SpriteState defaultState, Vector2 SpritePosition, Vector2 mDefaultTarget, int mAttackLevel, int mDefenseLevel)
            : base(mObjectType, content, defaultState, SpritePosition, Hostility.FRIENDLY)
        {
            this.DefaultTarget = mDefaultTarget;
            this.mCurrentTarget = mDefaultTarget;
            this.hostility = Hostility.FRIENDLY;
            mBehaviorFriendly = new BehaviorFriendly(1.0f);
            mFieldOfViewSize = 300;

            mObjectID = mGlobalID;
            mGlobalID++;
            SetUnitAnimation();

            mFriendlyAttribute = new FriendlyAttribute(this, content);
            if (GameObject.FromSaveGameState == FromSaveGame.NEWGAME)
            {
                SetAttributes();
            }
            this.FriendlyAggroMode = FriendlyAggroMode.MOVING;

            for (int i = 0; i < mAttackLevel; i++)
            {
                mFriendlyAttribute.UpgradeAttack();
            }
            for (int i = 0; i < mDefenseLevel; i++)
            {
                mFriendlyAttribute.UpgradeDefense();
            }
        }

 public ItemDropProfile(ObjectType p_item, bool p_freeze)
 {
     this.equipmentString = "";
     this.item = p_item;
     this.freezeOnAppear = p_freeze;
     this.chance = 100;
 }

 public Texture(string name, Sprite sprite, Bitmap image)
 {
     Sprite = sprite;
     Image = image;
     Name = name;
     Type = ObjectType.Texture;
 }

 /// <summary>
 /// Only derived classes should use this constructor. Creates an Object from parameters
 /// </summary>
 /// <param name="objectType">The ObjectType</param>
 /// <param name="bounds">The Rect bounds</param>
 /// <param name="rotation">Object's rotation</param>
 /// <param name="points">Object's list of points</param>
 internal Object(ObjectType objectType, Rect bounds, float rotation, List<Vector2> points)
 {
     ObjectType = objectType;
     Bounds = bounds;
     Rotation = rotation;
     Points = points;
 }

        /// <summary>
        /// Deletes specified object
        /// </summary>
        /// <param name="objectID">ID of the object to delete</param>
        /// <param name="objectType">Type of the object</param>
        /// <returns>Operation status</returns>
        public DeleteObjectStatus DeleteObject(long objectID, ObjectType objectType)
        {
            string type = ObjectType2String(objectType);
            string result = _service.delete(_apiKey, _token, type, objectID);

            return StatusMessageParser.ParseDeleteObjectStatus(result);
        }