コード例 #1
0
        public void SendAttackMovement(Unit Target, Ability_Info Info)
        {
            PacketOut Out = new PacketOut((byte)Opcodes.F_HIT_PLAYER);

            Out.WriteUInt16(Oid);

            if (Target != null)
            {
                Out.WriteUInt16(Target.Oid);
            }

            if (Info != null)
            {
                Out.WriteUInt16(Info.Entry);
            }

            Out.WriteByte(2);

            if (Info == null && Target != null)
            {
                Out.WriteByte(Target.PctHealth);
                Out.WriteByte(Target.PctHealth);
            }

            Out.WriteByte(0);
            DispatchPacket(Out, true);
        }
コード例 #2
0
        public bool IsValidAbility(Ability_Info Info)
        {
            if (!HasPlayer())
            {
                return(true);
            }

            Player Plr = GetPlayer();

            if (Info.MinimumRank > Plr.Level)
            {
                //Log.Info(Info.Name, "Rank :" + Info.MinimumRank + ">" + Plr.Level);
                return(false);
            }

            if (Info.MinimumRenown > Plr.Renown)
            {
                //Log.Info(Info.Name, "Renown :" + Info.MinimumRenown + ">" + Plr.Renown);
                return(false);
            }

            if (Info.MinimumCategoryPoints != 0)
            {
                return(false);
            }

            if (Info.PointCost != 0)
            {
                return(false);
            }

            return(true);
        }
コード例 #3
0
ファイル: AbilityMgr.cs プロジェクト: cooler-SAI/waremu-1
        static public Ability_Info GetAbilityInfo(UInt16 AbilityEntry, byte Level)
        {
            Ability_Info Info = null;

            if (_AbilityInfos.ContainsKey(AbilityEntry))
            {
                Info = _AbilityInfos[AbilityEntry].Find(info => info.Level == Level);
            }
            return(Info);
        }
コード例 #4
0
        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();
                }
            }
        }
コード例 #5
0
        public GameData.AbilityResult CanCast(Ability_Info Info)
        {
            if (LastCast + GlobalMSCoolDown > TCPServer.GetTimeStampMS())
            {
                return(GameData.AbilityResult.ABILITYRESULT_NOTREADY);
            }
            else if (Info.ActionPoints > GetPlayer().ActionPoints)
            {
                return(GameData.AbilityResult.ABILITYRESULT_AP);
            }

            return(GameData.AbilityResult.ABILITYRESULT_OK);
        }
コード例 #6
0
 public Ability(Ability_Info Info, Object Caster)
 {
     this.Info   = Info;
     this.Caster = Caster;
     Handler     = AbilityMgr.GetAbilityHandler(Info.AbilityType);
 }
コード例 #7
0
        public void SendAttackState(Unit Target, UInt16 RealDamage, UInt16 Damage, Ability_Info Ability = null)
        {
            if (Target == null)
            {
                return;
            }

            // Frappe
            {
                PacketOut Out = new PacketOut((byte)Opcodes.F_USE_ABILITY);
                Out.WriteUInt16(0);

                Out.WriteUInt16(Ability != null ? Ability.Entry : Oid);
                Out.WriteUInt16(Oid);

                Out.WriteUInt16((ushort)(Ability != null ? 0x610 : 0));
                Out.WriteUInt16(Target.Oid);

                if (Ability != null)
                {
                    Out.WriteByte(6);
                    Out.WriteByte(1);
                    Out.WriteUInt16(0);
                    Out.WriteUInt32(0x023F0C00);
                    Out.WriteUInt16(0);
                }
                else
                {
                    Out.WriteByte(2);
                    Out.Fill(0, 9);
                }

                DispatchPacket(Out, true);
            }

            {
                PacketOut Out = new PacketOut((byte)Opcodes.F_CAST_PLAYER_EFFECT);
                Out.WriteUInt16(Oid);
                Out.WriteUInt16(Target.Oid);

                Out.WriteUInt16((ushort)(Ability != null ? Ability.Entry : 0));
                Out.WriteByte((byte)(Ability != null ? 2 : 0));

                if (Ability == null)
                {
                    Out.WriteByte((byte)GameData.CombatEvent.COMBATEVENT_HIT);
                }
                else
                {
                    Out.WriteByte((byte)GameData.CombatEvent.COMBATEVENT_ABILITY_HIT);
                }

                Out.WriteByte((byte)(Ability != null ? 7 : 0x13));

                if (Ability == null)
                {
                    Out.WriteByte((byte)(RealDamage > 0 ? (RealDamage * 2) - 1 : 0));
                    Out.WriteByte((byte)((Damage - RealDamage) * 2));
                }
                else
                {
                    Out.WriteUInt16(0x0799);
                }

                Out.WriteByte(0);
                DispatchPacket(Out, true);
            }
        }