Exemple #1
0
        /// <summary>
        /// 持续加血
        /// </summary>
        /// <param name="self"></param>
        public void ExecuteAddLife(IObject self)
        {
            MagicHelperItem magicHelperItem = null;

            lock (_MagicHelperDict)
            {
                _MagicHelperDict.TryGetValue(MagicActionIDs.TIME_ADDLIFE, out magicHelperItem);
            }

            if (null == magicHelperItem)
            {
                return;
            }
            if (!CanExecuteItem(magicHelperItem, (int)magicHelperItem.MagicActionParams[1], (int)magicHelperItem.MagicActionParams[2]))
            {
                return;
            }

            magicHelperItem.ExecutedNum++;
            magicHelperItem.LastTicks = DateTime.Now.Ticks;

            if (self is GameClient) //如果是角色
            {
                GameManager.ClientMgr.AddSpriteLifeV(Global._TCPManager.MySocketListener, Global._TCPManager.TcpOutPacketPool,
                                                     self as GameClient, magicHelperItem.MagicActionParams[0]);
            }
        }
Exemple #2
0
        /// <summary>
        /// 持续加魔1
        /// </summary>
        /// <param name="self"></param>
        public void ExecuteAddMagic1(IObject self)
        {
            MagicHelperItem magicHelperItem = null;

            lock (_MagicHelperDict)
            {
                _MagicHelperDict.TryGetValue(MagicActionIDs.TIME_ADDMAGIC1, out magicHelperItem);
            }

            if (null == magicHelperItem)
            {
                return;
            }
            if (!CanExecuteItem(magicHelperItem, (int)magicHelperItem.MagicActionParams[1], (int)magicHelperItem.MagicActionParams[2]))
            {
                return;
            }

            magicHelperItem.ExecutedNum++;
            magicHelperItem.LastTicks = TimeUtil.NOW() * 10000;

            if (self is GameClient) //如果是角色
            {
                GameManager.ClientMgr.AddSpriteMagicV(Global._TCPManager.MySocketListener, Global._TCPManager.TcpOutPacketPool, self as GameClient, magicHelperItem.MagicActionParams[0], "道具脚本" + MagicActionIDs.TIME_ADDMAGIC1.ToString());
            }
        }
        public double GetNewMagicSubInjure()
        {
            double          injure2Magic    = 0.0;
            MagicHelperItem magicHelperItem = null;

            lock (this._MagicHelperDict)
            {
                this._MagicHelperDict.TryGetValue(MagicActionIDs.NEW_MAGIC_SUBINJURE, out magicHelperItem);
            }
            double result;

            if (null == magicHelperItem)
            {
                result = injure2Magic;
            }
            else if (!this.CanExecuteItem(magicHelperItem, (int)magicHelperItem.MagicActionParams[1], 0))
            {
                result = injure2Magic;
            }
            else
            {
                injure2Magic = magicHelperItem.MagicActionParams[0];
                result       = injure2Magic;
            }
            return(result);
        }
        public double GetMoveSlow()
        {
            double          percent         = 0.0;
            MagicHelperItem magicHelperItem = null;

            lock (this._MagicHelperDict)
            {
                this._MagicHelperDict.TryGetValue(MagicActionIDs.TIME_SLOW, out magicHelperItem);
            }
            double result;

            if (null == magicHelperItem)
            {
                result = percent;
            }
            else if (!this.CanExecuteItem(magicHelperItem, (int)magicHelperItem.MagicActionParams[1], 0))
            {
                result = percent;
            }
            else
            {
                percent = magicHelperItem.MagicActionParams[0] / 100.0;
                result  = percent;
            }
            return(result);
        }
Exemple #5
0
        /// <summary>
        /// 执行延迟的魔法伤害
        /// </summary>
        public void ExecuteDelayMAttack(IObject self)
        {
            MagicHelperItem magicHelperItem = null;

            lock (_MagicHelperDict)
            {
                _MagicHelperDict.TryGetValue(MagicActionIDs.TIME_DELAYMAGIC, out magicHelperItem);
            }

            if (null == magicHelperItem)
            {
                return;
            }

            long nowTicks = DateTime.Now.Ticks;
            long ticks    = magicHelperItem.StartedTicks + ((int)magicHelperItem.MagicActionParams[1] * 1000 * 10000);

            //判断是否超过了时间
            if (nowTicks < ticks)
            {
                return;
            }

            //只执行一次
            lock (_MagicHelperDict)
            {
                _MagicHelperDict.Remove(magicHelperItem.MagicActionID);
            }

            //执行伤害
            //根据敌人ID判断对方是系统爆的怪还是其他玩家
            int enemy = magicHelperItem.ObjectID;

            if (-1 != enemy)
            {
                GSpriteTypes st = Global.GetSpriteType((UInt32)enemy);
                if (st == GSpriteTypes.Monster)
                {
                    Monster enemyMonster = GameManager.MonsterMgr.FindMonster((self as GameClient).ClientData.MapCode, enemy);
                    if (null != enemyMonster)
                    {
                        ; GameManager.MonsterMgr.NotifyInjured(Global._TCPManager.MySocketListener, Global._TCPManager.TcpOutPacketPool,
                                                               self as GameClient, enemyMonster, 0, 0, (magicHelperItem.MagicActionParams[0] / 100.0), 1, false, 0, 1.0, 0, 0, 0, 0.0, 0.0);
                    }
                }
                else
                {
                    GameClient enemyClient = GameManager.ClientMgr.FindClient(enemy);
                    if (null != enemyClient)
                    {
                        GameManager.ClientMgr.NotifyOtherInjured(Global._TCPManager.MySocketListener, Global._TCPManager.TcpOutPacketPool,
                                                                 self as GameClient, enemyClient, 0, 0, (magicHelperItem.MagicActionParams[0] / 100.0), 1, false, 0, 1.0, 0, 0, 0, 0.0, 0.0);
                    }
                }
            }
        }
        public bool GetFreeze()
        {
            MagicHelperItem magicHelperItem = null;

            lock (this._MagicHelperDict)
            {
                this._MagicHelperDict.TryGetValue(MagicActionIDs.TIME_FREEZE, out magicHelperItem);
            }
            return(null != magicHelperItem && this.CanExecuteItem(magicHelperItem, (int)magicHelperItem.MagicActionParams[0], 0));
        }
Exemple #7
0
        /// <summary>
        /// 执行持续的魔法伤害4
        /// </summary>
        public void ExecuteNewMAttack4(IObject self)
        {
            MagicHelperItem magicHelperItem = null;

            lock (_MagicHelperDict)
            {
                _MagicHelperDict.TryGetValue(MagicActionIDs.NEW_TIME_MAGIC4, out magicHelperItem);
            }

            if (null == magicHelperItem)
            {
                return;
            }
            if (!CanExecuteItem(magicHelperItem, (int)magicHelperItem.MagicActionParams[1], (int)magicHelperItem.MagicActionParams[2]))
            {
                return;
            }

            magicHelperItem.ExecutedNum++;
            magicHelperItem.LastTicks = DateTime.Now.Ticks;

            //执行伤害
            //根据敌人ID判断对方是系统爆的怪还是其他玩家
            int enemy = magicHelperItem.ObjectID;

            if (-1 != enemy)
            {
                GSpriteTypes st = Global.GetSpriteType((UInt32)enemy);
                if (st == GSpriteTypes.Monster)
                {
                    Monster enemyMonster = GameManager.MonsterMgr.FindMonster((self as GameClient).ClientData.MapCode, enemy);
                    if (null != enemyMonster)
                    {
                        int injureValue = (int)(magicHelperItem.MagicActionParams[0] / magicHelperItem.MagicActionParams[2]);
                        GameManager.MonsterMgr.NotifyInjured(Global._TCPManager.MySocketListener, Global._TCPManager.TcpOutPacketPool,
                                                             self as GameClient, enemyMonster, 0, injureValue, 0.0, 0, false, 0, 1.0, 0, 0, 0, 0.0, 0.0);
                    }
                }
                else
                {
                    GameClient enemyClient = GameManager.ClientMgr.FindClient(enemy);
                    if (null != enemyClient)
                    {
                        int injureValue = (int)(magicHelperItem.MagicActionParams[0] / magicHelperItem.MagicActionParams[2]);
                        GameManager.ClientMgr.NotifyOtherInjured(Global._TCPManager.MySocketListener, Global._TCPManager.TcpOutPacketPool,
                                                                 self as GameClient, enemyClient, 0, injureValue, 0.0, 0, false, 0, 1.0, 0, 0, 0, 0.0, 0.0);
                    }
                }
            }
        }
        public double GetAddDrugEffect()
        {
            double percent = 1.0;

            lock (this._MagicHelperDict)
            {
                MagicHelperItem magicHelperItem = null;
                if (this._MagicHelperDict.TryGetValue(MagicActionIDs.FOREVER_ADDDRUGEFFECT, out magicHelperItem))
                {
                    percent = magicHelperItem.MagicActionParams[0] / 100.0;
                }
            }
            return(percent);
        }
        public void ExecuteSubLife2(IObject self)
        {
            MagicHelperItem magicHelperItem = null;

            lock (this._MagicHelperDict)
            {
                this._MagicHelperDict.TryGetValue(MagicActionIDs.TIME_DS_INJURE, out magicHelperItem);
            }
            if (null != magicHelperItem)
            {
                if (this.CanExecuteItem(magicHelperItem, (int)magicHelperItem.MagicActionParams[0], (int)magicHelperItem.MagicActionParams[1]))
                {
                    magicHelperItem.ExecutedNum++;
                    magicHelperItem.LastTicks = TimeUtil.NOW() * 10000L;
                    int enemy = magicHelperItem.ObjectID;
                    if (-1 != enemy)
                    {
                        int          nOcc       = Global.CalcOriginalOccupationID(self as GameClient);
                        int          attackType = nOcc;
                        GSpriteTypes st         = Global.GetSpriteType((uint)enemy);
                        if (st == GSpriteTypes.Monster)
                        {
                            Monster enemyMonster = GameManager.MonsterMgr.FindMonster((self as GameClient).ClientData.MapCode, enemy);
                            if (null != enemyMonster)
                            {
                                GameManager.MonsterMgr.NotifyInjured(Global._TCPManager.MySocketListener, Global._TCPManager.TcpOutPacketPool, self as GameClient, enemyMonster, 0, (int)magicHelperItem.MagicActionParams[2], 1.0, attackType, false, 0, 0.0, 0, 0, 0, 0.0, 0.0, false, 1.0, 0, 0, 0, 0.0);
                                if (enemyMonster.VLife <= 0.0)
                                {
                                    magicHelperItem.ExecutedNum = (int)magicHelperItem.MagicActionParams[1];
                                }
                            }
                        }
                        else
                        {
                            GameClient enemyClient = GameManager.ClientMgr.FindClient(enemy);
                            if (null != enemyClient)
                            {
                                GameManager.ClientMgr.NotifyOtherInjured(Global._TCPManager.MySocketListener, Global._TCPManager.TcpOutPacketPool, self as GameClient, enemyClient, 0, (int)magicHelperItem.MagicActionParams[2], 1.0, attackType, false, 0, 0.0, 0, 0, 0, 0.0, 0.0, false, false, 1.0, 0, 0, 0, 0.0);
                                if (enemyClient.ClientData.CurrentLifeV <= 0)
                                {
                                    magicHelperItem.ExecutedNum = (int)magicHelperItem.MagicActionParams[1];
                                }
                            }
                        }
                    }
                }
            }
        }
Exemple #10
0
        /// <summary>
        /// 添加技能辅助项
        /// </summary>
        /// <param name="magicActionID"></param>
        /// <param name="magicActionParams"></param>
        public void AddMagicHelper(MagicActionIDs magicActionID, double[] magicActionParams, int objID)
        {
            MagicHelperItem magicHelperItem = new MagicHelperItem()
            {
                MagicActionID     = magicActionID,
                MagicActionParams = magicActionParams,
                StartedTicks      = DateTime.Now.Ticks,
                LastTicks         = 0,
                ExecutedNum       = 0,
                ObjectID          = objID,
            };

            lock (_MagicHelperDict)
            {
                _MagicHelperDict[magicActionID] = magicHelperItem;
            }
        }
        public void AddMagicHelper(MagicActionIDs magicActionID, double[] magicActionParams, int objID)
        {
            MagicHelperItem magicHelperItem = new MagicHelperItem
            {
                MagicActionID     = magicActionID,
                MagicActionParams = magicActionParams,
                StartedTicks      = TimeUtil.NOW() * 10000L,
                LastTicks         = 0L,
                ExecutedNum       = 0,
                ObjectID          = objID
            };

            lock (this._MagicHelperDict)
            {
                this._MagicHelperDict[magicActionID] = magicHelperItem;
            }
        }
Exemple #12
0
        /// <summary>
        /// 是否可以执行选项
        /// </summary>
        /// <param name="magicHelperItem"></param>
        /// <returns></returns>
        private bool CanExecuteItem(MagicHelperItem magicHelperItem, int effectSecs, int maxNum)
        {
            long nowTicks = TimeUtil.NOW();
            long ticks    = magicHelperItem.StartedTicks + ((long)effectSecs * 1000);

            if (maxNum <= 0)
            {
                //判断是否超过了时间
                if (nowTicks >= ticks)
                {
                    lock (_MagicHelperDict)
                    {
                        _MagicHelperDict.Remove(magicHelperItem.MagicActionID);
                    }

                    return(false);
                }
                else
                {
                    //System.Diagnostics.Debug.WriteLine("CanExecuteItem, {0}", nowTicks - ticks);
                    return(true);
                }
            }

            //判断是否超过了次数
            if (magicHelperItem.ExecutedNum >= maxNum)
            {
                lock (_MagicHelperDict)
                {
                    _MagicHelperDict.Remove(magicHelperItem.MagicActionID);
                }

                return(false);
            }

            long ticksSlot = ((effectSecs / maxNum) * 1000 * 10000);

            //判断是否超过了时间
            if (nowTicks - magicHelperItem.LastTicks < ticksSlot)
            {
                return(false);
            }

            return(true);
        }
Exemple #13
0
        /// <summary>
        /// 持续增加伤害的百分比
        /// </summary>
        /// <returns></returns>
        public double GetAddInjure1()
        {
            MagicHelperItem magicHelperItem = null;

            lock (_MagicHelperDict)
            {
                _MagicHelperDict.TryGetValue(MagicActionIDs.TIME_ADDINJUE1, out magicHelperItem);
            }

            if (null == magicHelperItem)
            {
                return(0.0);
            }
            if (!CanExecuteItem(magicHelperItem, (int)magicHelperItem.MagicActionParams[1], 0))
            {
                return(0.0);
            }
            return(magicHelperItem.MagicActionParams[0]);
        }
Exemple #14
0
        /// <summary>
        /// 获取当前是否被冰冻
        /// </summary>
        /// <returns></returns>
        public bool GetFreeze()
        {
            MagicHelperItem magicHelperItem = null;

            lock (_MagicHelperDict)
            {
                _MagicHelperDict.TryGetValue(MagicActionIDs.TIME_FREEZE, out magicHelperItem);
            }

            if (null == magicHelperItem)
            {
                return(false);
            }
            if (!CanExecuteItem(magicHelperItem, (int)magicHelperItem.MagicActionParams[0], 0))
            {
                return(false);
            }
            return(true);
        }
Exemple #15
0
        /// <summary>
        /// MU项目持续减少伤害的值
        /// </summary>
        /// <returns></returns>
        public double MU_GetSubInjure2()
        {
            MagicHelperItem magicHelperItem = null;

            lock (_MagicHelperDict)
            {
                _MagicHelperDict.TryGetValue(MagicActionIDs.MU_SUB_DAMAGE_VALUE, out magicHelperItem);
            }

            if (null == magicHelperItem)
            {
                return(0.0);
            }
            if (!CanExecuteItem(magicHelperItem, (int)magicHelperItem.MagicActionParams[0], 0))
            {
                return(0.0);
            }
            return(magicHelperItem.MagicActionParams[1]);
        }
        public void ExecuteDelayMAttack(IObject self)
        {
            MagicHelperItem magicHelperItem = null;

            lock (this._MagicHelperDict)
            {
                this._MagicHelperDict.TryGetValue(MagicActionIDs.TIME_DELAYMAGIC, out magicHelperItem);
            }
            if (null != magicHelperItem)
            {
                long nowTicks = TimeUtil.NOW() * 10000L;
                long ticks    = magicHelperItem.StartedTicks + (long)((int)magicHelperItem.MagicActionParams[1] * 1000 * 10000);
                if (nowTicks >= ticks)
                {
                    lock (this._MagicHelperDict)
                    {
                        this._MagicHelperDict.Remove(magicHelperItem.MagicActionID);
                    }
                    int enemy = magicHelperItem.ObjectID;
                    if (-1 != enemy)
                    {
                        GSpriteTypes st = Global.GetSpriteType((uint)enemy);
                        if (st == GSpriteTypes.Monster)
                        {
                            Monster enemyMonster = GameManager.MonsterMgr.FindMonster((self as GameClient).ClientData.MapCode, enemy);
                            if (null != enemyMonster)
                            {
                                GameManager.MonsterMgr.NotifyInjured(Global._TCPManager.MySocketListener, Global._TCPManager.TcpOutPacketPool, self as GameClient, enemyMonster, 0, 0, magicHelperItem.MagicActionParams[0] / 100.0, 1, false, 0, 1.0, 0, 0, 0, 0.0, 0.0, false, 1.0, 0, 0, 0, 0.0);
                            }
                        }
                        else
                        {
                            GameClient enemyClient = GameManager.ClientMgr.FindClient(enemy);
                            if (null != enemyClient)
                            {
                                GameManager.ClientMgr.NotifyOtherInjured(Global._TCPManager.MySocketListener, Global._TCPManager.TcpOutPacketPool, self as GameClient, enemyClient, 0, 0, magicHelperItem.MagicActionParams[0] / 100.0, 1, false, 0, 1.0, 0, 0, 0, 0.0, 0.0, false, false, 1.0, 0, 0, 0, 0.0);
                            }
                        }
                    }
                }
            }
        }
        public void ExecuteAddLife(IObject self)
        {
            MagicHelperItem magicHelperItem = null;

            lock (this._MagicHelperDict)
            {
                this._MagicHelperDict.TryGetValue(MagicActionIDs.TIME_ADDLIFE, out magicHelperItem);
            }
            if (null != magicHelperItem)
            {
                if (this.CanExecuteItem(magicHelperItem, (int)magicHelperItem.MagicActionParams[1], (int)magicHelperItem.MagicActionParams[2]))
                {
                    magicHelperItem.ExecutedNum++;
                    magicHelperItem.LastTicks = TimeUtil.NOW() * 10000L;
                    if (self is GameClient)
                    {
                        GameManager.ClientMgr.AddSpriteLifeV(Global._TCPManager.MySocketListener, Global._TCPManager.TcpOutPacketPool, self as GameClient, magicHelperItem.MagicActionParams[0], "道具脚本" + MagicActionIDs.TIME_ADDLIFE.ToString());
                    }
                }
            }
        }
        public void ExecuteNewMAttack4(IObject self)
        {
            MagicHelperItem magicHelperItem = null;

            lock (this._MagicHelperDict)
            {
                this._MagicHelperDict.TryGetValue(MagicActionIDs.NEW_TIME_MAGIC4, out magicHelperItem);
            }
            if (null != magicHelperItem)
            {
                if (this.CanExecuteItem(magicHelperItem, (int)magicHelperItem.MagicActionParams[1], (int)magicHelperItem.MagicActionParams[2]))
                {
                    magicHelperItem.ExecutedNum++;
                    magicHelperItem.LastTicks = TimeUtil.NOW() * 10000L;
                    int enemy = magicHelperItem.ObjectID;
                    if (-1 != enemy)
                    {
                        GSpriteTypes st = Global.GetSpriteType((uint)enemy);
                        if (st == GSpriteTypes.Monster)
                        {
                            Monster enemyMonster = GameManager.MonsterMgr.FindMonster((self as GameClient).ClientData.MapCode, enemy);
                            if (null != enemyMonster)
                            {
                                int injureValue = (int)(magicHelperItem.MagicActionParams[0] / magicHelperItem.MagicActionParams[2]);
                                GameManager.MonsterMgr.NotifyInjured(Global._TCPManager.MySocketListener, Global._TCPManager.TcpOutPacketPool, self as GameClient, enemyMonster, 0, injureValue, 0.0, 0, false, 0, 1.0, 0, 0, 0, 0.0, 0.0, false, 1.0, 0, 0, 0, 0.0);
                            }
                        }
                        else
                        {
                            GameClient enemyClient = GameManager.ClientMgr.FindClient(enemy);
                            if (null != enemyClient)
                            {
                                int injureValue = (int)(magicHelperItem.MagicActionParams[0] / magicHelperItem.MagicActionParams[2]);
                                GameManager.ClientMgr.NotifyOtherInjured(Global._TCPManager.MySocketListener, Global._TCPManager.TcpOutPacketPool, self as GameClient, enemyClient, 0, injureValue, 0.0, 0, false, 0, 1.0, 0, 0, 0, 0.0, 0.0, false, false, 1.0, 0, 0, 0, 0.0);
                            }
                        }
                    }
                }
            }
        }
Exemple #19
0
        /// <summary>
        /// 将伤害转化为魔法消耗
        /// </summary>
        /// <returns></returns>
        public double GetNewMagicSubInjure()
        {
            double injure2Magic = 0.0;

            MagicHelperItem magicHelperItem = null;

            lock (_MagicHelperDict)
            {
                _MagicHelperDict.TryGetValue(MagicActionIDs.NEW_MAGIC_SUBINJURE, out magicHelperItem);
            }

            if (null == magicHelperItem)
            {
                return(injure2Magic);
            }
            if (!CanExecuteItem(magicHelperItem, (int)magicHelperItem.MagicActionParams[1], 0))
            {
                return(injure2Magic);
            }
            injure2Magic = magicHelperItem.MagicActionParams[0];
            return(injure2Magic);
        }
Exemple #20
0
        /// <summary>
        /// 将伤害转化为魔法消耗
        /// </summary>
        /// <returns></returns>
        public double GetInjure2Magic()
        {
            double percent = 0.0;

            MagicHelperItem magicHelperItem = null;

            lock (_MagicHelperDict)
            {
                _MagicHelperDict.TryGetValue(MagicActionIDs.TIME_INJUE2MAGIC, out magicHelperItem);
            }

            if (null == magicHelperItem)
            {
                return(percent);
            }
            if (!CanExecuteItem(magicHelperItem, (int)magicHelperItem.MagicActionParams[1], 0))
            {
                return(percent);
            }
            percent = (magicHelperItem.MagicActionParams[0] / 100.0);
            return(percent);
        }
        private bool CanExecuteItem(MagicHelperItem magicHelperItem, int effectSecs, int maxNum)
        {
            long nowTicks = TimeUtil.NOW();
            long ticks    = magicHelperItem.StartedTicks + (long)effectSecs * 1000L;
            bool result;

            if (maxNum <= 0)
            {
                if (nowTicks >= ticks)
                {
                    lock (this._MagicHelperDict)
                    {
                        this._MagicHelperDict.Remove(magicHelperItem.MagicActionID);
                    }
                    result = false;
                }
                else
                {
                    result = true;
                }
            }
            else if (magicHelperItem.ExecutedNum >= maxNum)
            {
                lock (this._MagicHelperDict)
                {
                    this._MagicHelperDict.Remove(magicHelperItem.MagicActionID);
                }
                result = false;
            }
            else
            {
                long ticksSlot = (long)(effectSecs / maxNum * 1000 * 10000);
                result = (nowTicks - magicHelperItem.LastTicks >= ticksSlot);
            }
            return(result);
        }
        public double MU_GetSubInjure2()
        {
            MagicHelperItem magicHelperItem = null;

            lock (this._MagicHelperDict)
            {
                this._MagicHelperDict.TryGetValue(MagicActionIDs.MU_SUB_DAMAGE_VALUE, out magicHelperItem);
            }
            double result;

            if (null == magicHelperItem)
            {
                result = 0.0;
            }
            else if (!this.CanExecuteItem(magicHelperItem, (int)magicHelperItem.MagicActionParams[0], 0))
            {
                result = 0.0;
            }
            else
            {
                result = magicHelperItem.MagicActionParams[1];
            }
            return(result);
        }
        public double GetAddInjure1()
        {
            MagicHelperItem magicHelperItem = null;

            lock (this._MagicHelperDict)
            {
                this._MagicHelperDict.TryGetValue(MagicActionIDs.TIME_ADDINJUE1, out magicHelperItem);
            }
            double result;

            if (null == magicHelperItem)
            {
                result = 0.0;
            }
            else if (!this.CanExecuteItem(magicHelperItem, (int)magicHelperItem.MagicActionParams[1], 0))
            {
                result = 0.0;
            }
            else
            {
                result = magicHelperItem.MagicActionParams[0];
            }
            return(result);
        }
Exemple #24
0
        /// <summary>
        /// 持续伤血2
        /// </summary>
        /// <param name="self"></param>
        public void ExecuteSubLife2(IObject self)
        {
            MagicHelperItem magicHelperItem = null;

            lock (_MagicHelperDict)
            {
                _MagicHelperDict.TryGetValue(MagicActionIDs.TIME_DS_INJURE, out magicHelperItem);
            }

            if (null == magicHelperItem)
            {
                return;
            }
            if (!CanExecuteItem(magicHelperItem, (int)magicHelperItem.MagicActionParams[0], (int)magicHelperItem.MagicActionParams[1]))
            {
                return;
            }

            magicHelperItem.ExecutedNum++;
            magicHelperItem.LastTicks = DateTime.Now.Ticks;

            //执行伤害
            //根据敌人ID判断对方是系统爆的怪还是其他玩家
            int enemy = magicHelperItem.ObjectID;

            if (-1 != enemy)
            {
                // 属性改造 加上一级属性公式 区分职业[8/15/2013 LiaoWei]
                int nOcc = Global.CalcOriginalOccupationID((self as GameClient));

                int          attackType = nOcc;
                GSpriteTypes st         = Global.GetSpriteType((UInt32)enemy);
                if (st == GSpriteTypes.Monster)
                {
                    Monster enemyMonster = GameManager.MonsterMgr.FindMonster((self as GameClient).ClientData.MapCode, enemy);
                    if (null != enemyMonster)
                    {
                        //最低伤害1,使用一个外部传入的1的技巧
                        ; GameManager.MonsterMgr.NotifyInjured(Global._TCPManager.MySocketListener, Global._TCPManager.TcpOutPacketPool,
                                                               self as GameClient, enemyMonster, 0, (int)magicHelperItem.MagicActionParams[2], 1.0, attackType, false, 0, 0.0, 0, 0, 0, 0.0, 0.0);

                        if (enemyMonster.VLife <= 0)                                                 //如果死亡
                        {
                            magicHelperItem.ExecutedNum = (int)magicHelperItem.MagicActionParams[1]; //终止buffer
                        }
                    }
                }
                else
                {
                    GameClient enemyClient = GameManager.ClientMgr.FindClient(enemy);
                    if (null != enemyClient)
                    {
                        //最低伤害1,使用一个外部传入的1的技巧
                        GameManager.ClientMgr.NotifyOtherInjured(Global._TCPManager.MySocketListener, Global._TCPManager.TcpOutPacketPool,
                                                                 self as GameClient, enemyClient, 0, (int)magicHelperItem.MagicActionParams[2], 1.0, attackType, false, 0, 0.0, 0, 0, 0, 0.0, 0.0);

                        if (enemyClient.ClientData.CurrentLifeV <= 0)                                //如果死亡
                        {
                            magicHelperItem.ExecutedNum = (int)magicHelperItem.MagicActionParams[1]; //终止buffer
                        }
                    }
                }
            }
        }