示例#1
0
        public override GameData.AbilityResult CanCast(bool IsStart)
        {
            GameData.AbilityResult Result = GameData.AbilityResult.ABILITYRESULT_OK;

            if (Target == null || !Target.IsPlayer()) //nonplayer Chars are illegal too
            {
                Result = GameData.AbilityResult.ABILITYRESULT_ILLEGALTARGET;
            }
            else if (Target.IsDead)
            {
                Result = GameData.AbilityResult.ABILITYRESULT_ILLEGALTARGET_DEAD;
            }
            else if (Ab.Caster.GetDistanceTo(Target) > Ab.Info.Info.MaxRange)
            {
                Result = GameData.AbilityResult.ABILITYRESULT_OUTOFRANGE;
            }
            else if (IsStart && Ab.Caster.GetDistanceTo(Target) < Ab.Info.Info.MinRange)
            {
                Result = GameData.AbilityResult.ABILITYRESULT_TOOCLOSE;
            }
            else if (IsStart && Ab.Info.Info.MinRange <= 5 && !Ab.Caster.IsObjectInFront(Target, 110))
            {
                Result = GameData.AbilityResult.ABILITYRESULT_OUT_OF_ARC;
            }
            else if (!CombatInterface.IsFriend(Ab.Caster.GetUnit(), Target))
            {
                Result = GameData.AbilityResult.ABILITYRESULT_ILLEGALTARGET_NOT_ALLY;
            }

            //Log.Info("SimpleHeal", Result.ToString());
            return(Result);
        }
示例#2
0
        public override GameData.AbilityResult CanCast(bool IsStart)
        {
            GameData.AbilityResult Result = GameData.AbilityResult.ABILITYRESULT_OK;

            //Log.Info("SimpleHeal", Result.ToString());
            return(Result);
        }
示例#3
0
        public void Cast(Ability_Stats Info, ushort Px, ushort Py, ushort Pz, ushort ZoneId)
        {
            GameData.AbilityResult Result = CanCast(Info, true);

            if (Result == GameData.AbilityResult.ABILITYRESULT_OK)
            {
                Ability NewAbility = new Ability(this, null, Info, _Owner.GetUnit(), false, Px, Py, Pz, ZoneId);

                if (NewAbility.Handler != null)
                {
                    Result = NewAbility.Handler.CanCast(true);
                }

                if (NewAbility.Handler == null || Result == GameData.AbilityResult.ABILITYRESULT_OK)
                {
                    //Log.Info("Cast", Info.Entry.ToString() + ":" + Info.Description + " : " + Info.Damages1);
                    SetCooldown(0, GlobalMSCoolDown);
                    CurrentAbility = NewAbility;
                    CurrentAbility.Start();
                    SetCooldown(Info.Entry, Info.Info.Cooldown * 1000);
                }
                else
                {
                    Cancel(false);
                }
            }
            else
            {
                Cancel(false);
            }
        }
        public override GameData.AbilityResult CanCast(bool IsStart)
        {
            GameData.AbilityResult Result = GameData.AbilityResult.ABILITYRESULT_OK;
            if (TargetHandler != null)
            {
                return(TargetHandler.CanCast(IsStart));
            }

            return(Result);
        }
        public void StartCast(ushort AbilityID)
        {
            Ability_Info Info = GetAbility(AbilityID);

            if (Info == null)
            {
                return;
            }

            if (IsCasting() && CurrentAbility.Info == Info)
            {
                return;
            }

            Log.Info("AbilityInterface", "StartCast : " + AbilityID);

            if (CurrentAbility != null)
            {
                CurrentAbility.Stop();
                CurrentAbility = null;
            }

            GameData.AbilityResult Result = CanCast(Info);

            if (Result == GameData.AbilityResult.ABILITYRESULT_OK)
            {
                LastCast = TCPServer.GetTimeStampMS();

                CurrentAbility = new Ability(Info, Obj);
                CurrentAbility.Start();

                if (CurrentAbility.Handler != null)
                {
                    Result = CurrentAbility.Handler.CanCast();
                }

                Log.Info("Cast", "CastResult = " + Result);

                if (CurrentAbility.Handler == null || Result == GameData.AbilityResult.ABILITYRESULT_OK)
                {
                    Obj.GetUnit().ActionPoints -= Info.ActionPoints;
                    if (Obj.IsPlayer())
                    {
                        Obj.GetPlayer().SendHealh();
                    }
                }
                else
                {
                    CurrentAbility.Stop();
                }
            }
        }
示例#6
0
        public override GameData.AbilityResult CanCast(bool IsStart)
        {
            GameData.AbilityResult Result = GameData.AbilityResult.ABILITYRESULT_OK;

            if (Target == null)
            {
                Result = GameData.AbilityResult.ABILITYRESULT_ILLEGALTARGET;
            }
            else if (Target.IsDead)
            {
                Result = GameData.AbilityResult.ABILITYRESULT_ILLEGALTARGET_DEAD;
            }
            else if (!CombatInterface.CanAttack(Ab.Caster.GetUnit(), Target))
            {
                Result = GameData.AbilityResult.ABILITYRESULT_ILLEGALTARGET_NOT_PVP_FLAGGED;
            }
            else if (!CombatInterface.IsEnemy(Ab.Caster.GetUnit(), Target))
            {
                Result = GameData.AbilityResult.ABILITYRESULT_ILLEGALTARGET_IN_YOUR_ALLIANCE;
            }
            else if (IsStart)
            {
                float Distance = Ab.Caster.GetDistanceTo(Target);
                if (Distance > Ab.Info.Info.MaxRange)
                {
                    Result = GameData.AbilityResult.ABILITYRESULT_OUTOFRANGE;
                }
                else if (Distance < Ab.Info.Info.MinRange)
                {
                    Result = GameData.AbilityResult.ABILITYRESULT_TOOCLOSE;
                }
                else if (Ab.Info.Info.MaxRange <= 5 && !Ab.Caster.IsObjectInFront(Target, 110))
                {
                    Result = GameData.AbilityResult.ABILITYRESULT_OUT_OF_ARC;
                }
            }
            else
            {
                CalcualteStat(); // get Offensive/Defensive stat
                //Result = CheckBlock(); // check for parry, evade or disrupt.
            }

            return(Result);
        }
        public override GameData.AbilityResult CanCast(bool IsStart)
        {
            GameData.AbilityResult Result = GameData.AbilityResult.ABILITYRESULT_OK;

            if (Target == null)
            {
                Result = GameData.AbilityResult.ABILITYRESULT_ILLEGALTARGET;
            }
            else if (!Target.IsDead)
            {
                Result = GameData.AbilityResult.ABILITYRESULT_ILLEGALTARGET_DEAD;
            }
            else if (CombatInterface.IsEnemy(Ab.Caster.GetUnit(), Target))
            {
                Result = GameData.AbilityResult.ABILITYRESULT_ILLEGALTARGET_IN_YOUR_ALLIANCE;
            }

            return(Result);
        }
示例#8
0
        public void Cast()
        {
            Log.Info("Ability", "Cast");

            if (IsDone)
            {
                return;
            }

            IsDone   = true;
            DoneTime = TCPServer.GetTimeStampMS();

            if (Handler != null)
            {
                GameData.AbilityResult Result = Handler.CanCast();

                if (Result == GameData.AbilityResult.ABILITYRESULT_OK)
                {
                    Handler.Cast();
                }
            }
        }
示例#9
0
        public override GameData.AbilityResult CanCast(bool IsStart)
        {
            GameData.AbilityResult Result = GameData.AbilityResult.ABILITYRESULT_OK;

            return(Result);
        }