protected virtual void ExitPlacing(int numPlaced, AbilityType aType){
		AbilityObjectPlacedMessage objMess = new AbilityObjectPlacedMessage (numPlaced, aType);
		MessageCenter.Instance.Broadcast (objMess);
		AbilityStatusChangedMessage abMess = new AbilityStatusChangedMessage (false);
		MessageCenter.Instance.Broadcast (abMess);
		Destroy (this.gameObject);
	}

 public Ability(int cooldown, int power, int moveSpeed, AbilityType type, float specialPower)
 {
     Cooldown = cooldown;
     AbilityPower = power;
     MoveSpeed = moveSpeed;
     SpecialPower = specialPower;
     Type = type;
 }

 public void ActionNotUsableWhenBlockedByStatusEffect(
     AbilityType abilityType,
     StatusEffect statusEffect)
 {
     battleAbility.Ability.AbilityType = abilityType;
     player.StatusEffects = new StatusEffect[] { statusEffect };
     VerifyActionNotUsable();
 }

 public void NotRecastableWhenOnRecast(AbilityType abilityType)
 {
     ability.AbilityType = abilityType;
     var memoryApi = new FakeMemoryAPI();
     memoryApi.Timer = new FakeTimer() { ActionRecast = 1 };
     var result = AbilityUtils.IsRecastable(memoryApi, ability);
     Assert.False(result);
 }

 public void IsRecastableWhenNotOnRecast(AbilityType abilityType)
 {
     ability.AbilityType = abilityType;
     var memoryApi = new FakeMemoryAPI();
     memoryApi.Timer = new FakeTimer();
     var result = AbilityUtils.IsRecastable(memoryApi, ability);
     Assert.True(result);
 }

 /// <summary>
 /// 破盾
 /// </summary>
 /// <param name="general"></param>
 /// <param name="abilityType"></param>
 /// <returns></returns>
 public static bool AttackPoDun(CombatGeneral general, AbilityType abilityType)
 {
     SkillLvInfo skillLvInfo = CreateSkillLvInfo(general).Find(m => m.EffType == abilityType);
     if (skillLvInfo != null && RandomUtils.IsHit(skillLvInfo.Probability))
     {
         return true;
     }
     return false;
 }

 public BossMonster(int monsterMaxHealth, AbilityType? type = null)
     : base(monsterMaxHealth, type ?? AbilityType.Kamakaze)
 {
     Size = new Size((int)(Width * 1.5), (int)(Height * 1.5));
     Speed = MaxSpeed = MaxSpeed * 0.75;
     _gravityConstant = 400;
     FoeType = FoeType.Boss;
     SetMonsterSize();
 }

 public Ability(int cooldown, int minPower, int maxPower, AbilityType abilityType, string textureName)
 {
     _cooldown = cooldown;
       _minPower = minPower;
       _maxPower = maxPower;
       TextureName = textureName;
       AbilityType = abilityType;
       _rand = new Random();
 }

 public Skill(uint id, string name, uint ability, uint type, uint cost, uint aoe, uint range, float cooldown) {
     skillID = id;
     skillName = name;
     skillAbility = (AbilityType)ability;
     skillType = (SkillType)type;
     skillCost = cost;
     skillAoe = aoe;
     skillRange = range;
     skillCooldown = cooldown;
 }

        public Ability(AbilityType type, PhaseType phase, LimitType limit, string text)
        {
            if (text == null)
                throw new ArgumentNullException("text");

            this.type = type;
            this.phase = phase;
            this.limit = limit;
            this.text = text;
        }

 protected AbstractActionAbility(String name, int actionCost, AbilityType abilityType, TargetTypes targetTypes,
     DefaultTargetType defaultTarget, AnimationType animType , AbstractDamageBehaviour damageBehaviour)
     : base(name, actionCost, abilityType)
 {
     this.TargetType = targetTypes;
     this.DefaultTarget = defaultTarget;
     abilityType |= AbilityType.Action;
     //this.AnimationBehaviour = animBehaviour;
     this.DamageBehaviour = damageBehaviour;
     this.AnimationType = animType;
 }

 //constructor for instant, 1-time abilities, no DOTs
 public CharAbility(bool limitedByRange, List<AbilityStatsToAffect> characterStatsToEffect, AbilityType type, AbilityPosibleTargets possibleTargets, string name, int id, int range = 0)
 {
     this.limitedByRange = limitedByRange;
     this.characterStatsToEffect = characterStatsToEffect;
     this.type = type;
     this.name = name;
     this.id = id;
     this.range = range;
     this.overTime = false;
     this.overTimeRounds = 0;
     this.abilityPossibleTargets = possibleTargets;
 }

 /// <summary>
 ///     Represents all the types that are spells or casted.
 /// </summary>
 public static bool IsSpell(AbilityType abilityType)
 {
     switch (abilityType)
     {
         case AbilityType.Magic:
         case AbilityType.Ninjutsu:
         case AbilityType.Song:
         case AbilityType.Item:
             return true;
         default:
             return false;
     }
 }

 /// <summary>
 /// 法宝基础属性
 /// </summary>
 /// <param name="trumpInfo"></param>
 /// <param name="abilityType"></param>
 /// <returns></returns>
 public static short GetTrumpProperty(TrumpInfo trumpInfo, AbilityType abilityType)
 {
     short propertyNum = 0;
     if (trumpInfo.Property.Count > 0)
     {
         GeneralProperty property = trumpInfo.Property.Find(m => m.AbilityType == abilityType);
         if (property != null)
         {
             propertyNum = (short)property.AbilityValue;
         }
     }
     return propertyNum;
 }

        /// <summary>
        ///     Represents all the types that are not spells or casted.
        /// </summary>
        public static bool IsAbility(AbilityType abilityType)
        {
            switch (abilityType)
            {
                case AbilityType.Weaponskill:
                case AbilityType.Range:
                case AbilityType.Jobability:
                case AbilityType.Pet:
                case AbilityType.Monsterskill:
                    return true;

                default:
                    return false;
            }
        }

 public Monster(int monsterMaxHealth, AbilityType abilityType)
 {
     Velocity = new Vector(GetRandomVDelta() * 40, GetRandomVDelta() * 40);
     Size = new Size(Width, Height);
     Id = _id++;
     Health = MaxHealth = GetMonsterMaxHealth(monsterMaxHealth, abilityType);
     Speed = MaxSpeed = GetMaxSpeed(abilityType);
     Generation = 1;
     CreateAbilities();
     AbilityType = abilityType;
     Ability = AbilitiesDictionary[AbilityType];
     SetOnDeathAbilities();
     SetOnHitAbilities();
     SetMovementTypes();
     SetMonsterSize();
 }

        private AbilityData(byte[] data)
        {
            byte b2 = data[2];
            byte b11 = data[11];
            byte b12 = data[12];

            data.Decode();

            data[2] = b2;
            data[11] = b11;
            data[12] = b12;

            this.id = data[0] | data[1] << 8;
            this.type = (AbilityType)data[2];
            this.mpcost = data[6] | data[7] << 8;
            this.timerid = data[8] | data[9] << 8;
            this.validtargets = (ValidTargets)(data[10] | data[11] << 8);
            this.tpcost = data[12];
        }

        public static short maxFeelLv = ConfigEnvSet.GetInt("Gift.MaxFeelLv").ToShort(); //好感度最大等级

        #endregion Fields

        #region Methods

        /// <summary>
        /// 下一级属性数值
        /// </summary>
        /// <param name="userID"></param>
        /// <param name="generalID"></param>
        /// <param name="abilityType"></param>
        /// <returns></returns>
        public static int FeelUpPropertyNum(string userID, int generalID, AbilityType abilityType)
        {
            int upPropertyNum = 0;
            UserGeneral userGeneral = new GameDataCacheSet<UserGeneral>().FindKey(userID, generalID);
            if (userGeneral != null)
            {
                short maxFeelLv = ConfigEnvSet.GetInt("Gift.MaxFeelLv").ToShort();
                short feelLv = MathUtils.Addition(userGeneral.FeelLv, (short)1, maxFeelLv);
                FeelLvInfo upfeelLvInfo = new ConfigCacheSet<FeelLvInfo>().FindKey(feelLv);
                if (upfeelLvInfo != null && upfeelLvInfo.Property.Count > 0)
                {
                    GeneralProperty property = upfeelLvInfo.Property.Find(m => m.AbilityType == abilityType);
                    if (property != null)
                    {
                        upPropertyNum = property.AbilityValue.ToInt();
                    }
                }
            }
            return upPropertyNum;
        }

 public static decimal GetEffect(CombatGeneral general, AbilityType abilityType)
 {
     decimal effNum = 1;
     if (general.GeneralID != LanguageManager.GetLang().GameUserGeneralID)
     {
         return 0;
     }
     switch (abilityType)
     {
         case AbilityType.BaoJiJiaCheng:
             effNum = MathUtils.Addition(effNum, GetEffTypeNum(general, abilityType));
             break;
         case AbilityType.IsBaoJiReduce:
             effNum = MathUtils.Subtraction(effNum, GetEffTypeNum(general, abilityType));
             break;
         case AbilityType.Resurrect:
             effNum = GetEffTypeNum(general, abilityType);
             break;
         case AbilityType.AttackLife:
             effNum = GetEffTypeNum(general, abilityType);
             break;
         case AbilityType.Furious:
             effNum = LifeLowerTnumEffNum(general, abilityType);
             break;
         case AbilityType.NormalAttackPoFang:
             effNum = GetEffTypeNum(general, abilityType);
             break;
         case AbilityType.AttackPoDun:
             //effNum = GetEffTypeNum(general, abilityType);
             break;
         case AbilityType.FanShang:
             effNum = GetEffTypeNum(general, abilityType);
             break;
         default:
             return effNum;
     }
     return effNum;
 }

 public static bool getLockGun(AbilityType abil)
 {
     switch(abil)
     {
         case AbilityType.doubleThrottle:
             return false;
         case AbilityType.gas:
             return true;
         case AbilityType.halfRoundTurn:
             return false;
         case AbilityType.homingMissle:
             return true;
         case AbilityType.homingThorpede:
             return true;
         case AbilityType.mines:
             return false;
         case AbilityType.shield:
             return true;
         case AbilityType.turnAround:
             return false;
         default:
             return false;
     }
 }