void Player_Effect_CallBack(object e)
        {
            try
            {
                StopEffectTimer((byte)e);

                WorldMgr.targetObject thisObject = new WorldMgr.targetObject(this, null);

                foreach (KeyValuePair <string, int> p in ObjData.Manager.SkillBase[Character.Action.DeBuff.Effect.SkillID[(byte)e]].Properties1)
                {
                    switch (p.Key)
                    {
                    case "fb":
                        CLGameServer.Effect.DeleteEffect_fb(thisObject, (byte)e);
                        break;

                    case "bu":

                        break;

                    case "fz":
                        CLGameServer.Effect.DeleteEffect_fz(thisObject, (byte)e);
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
        void MainSkill_Attack(List<int> list)
        {
            if (!Character.Action.sAttack) return;
            try
            {

                AmountControl();
                //Send(Packet.SkillBirdAttack(Character.Action.Target));
                int[,] p_dmg = new int[Character.Action.Skill.Found, Character.Action.Skill.NumberOfAttack];
                int[] statichp = new int[Character.Action.Skill.Found];

                PacketWriter Writer = new PacketWriter();

                Writer.Create(OperationCode.SERVER_SKILL_DATA);
                Writer.Byte(1);
                Writer.DWord(Character.Action.Skill.MainCasting);
                Writer.DWord(Character.Action.Target);
                Writer.Byte(1);
                Writer.Byte(Character.Action.Skill.NumberOfAttack);
                Writer.Byte(Character.Action.Skill.Found);
                byte[] status;
                status = new byte[Character.Action.Skill.Found];
                WorldMgr.targetObject[] target = new WorldMgr.targetObject[Character.Action.Skill.Found];
                for (byte f = 0; f < Character.Action.Skill.Found; f++)
                {
                    if (Character.Action.Skill.FoundID[f] != 0)
                    {
                        Writer.DWord(Character.Action.Skill.FoundID[f]);
                        target[f] = new WorldMgr.targetObject(Helpers.GetInformation.GetObjects(Character.Action.Skill.FoundID[f]), this);
                        if (target[f].sys == null && target[f].os == null) { }
                        else
                        {
                            statichp[f] = target[f].GetHp;
                            for (byte n = 0; n < Character.Action.Skill.NumberOfAttack; n++)
                            {
                                bool block = false;
                                /*if (Character.Information.Item.sID != 0 && Character.Information.Item.sID != 62)
                                {
                                    if (ObjData.RandomID.GetRandom(0, 25) < 10) block = true;
                                }*/
                                if (!block)
                                {
                                    byte crit = 1;
                                    p_dmg[f, n] = 1;

                                    if (Character.Action.Skill.P_M) // for magic damage
                                    {
                                        p_dmg[f, n] = (int)Formule.gamedamage((Character.Stat.MaxMagAttack + ObjData.Manager.SkillBase[Character.Action.Skill.SkillID[n]].MaxAttack), MasteryGetPower(Character.Action.Skill.SkillID[n]), target[f].AbsrobMag, target[f].MagDef, Character.Information.Mag_Balance, (ObjData.Manager.SkillBase[Character.Action.Skill.SkillID[n]].MagPer + Character.Stat.UpdatededMagAttack));
                                        if (Character.Action.ImbueID != 0) p_dmg[f, n] += (int)Formule.gamedamage((Character.Stat.MinMagAttack + ObjData.Manager.SkillBase[Character.Action.ImbueID].MaxAttack), MasteryGetPower(Character.Action.ImbueID), 0, target[f].MagDef, Character.Information.Mag_Balance, Character.Stat.UpdatededMagAttack);
                                    }
                                    else // for phy damage
                                    {
                                        p_dmg[f, n] = (int)Formule.gamedamage((Character.Stat.MaxPhyAttack + ObjData.Manager.SkillBase[Character.Action.Skill.SkillID[n]].MaxAttack), MasteryGetPower(Character.Action.Skill.SkillID[n]), target[f].AbsrobPhy, target[f].PhyDef, Character.Information.Phy_Balance, Character.Stat.UpdatededPhyAttack + ObjData.Manager.SkillBase[Character.Action.Skill.SkillID[n]].MagPer);
                                        if (Character.Action.ImbueID != 0) p_dmg[f, n] += (int)Formule.gamedamage((Character.Stat.MinMagAttack + ObjData.Manager.SkillBase[Character.Action.ImbueID].MaxAttack), MasteryGetPower(Character.Action.ImbueID), 0, target[f].MagDef, Character.Information.Mag_Balance, Character.Stat.UpdatededMagAttack);
                                        if (Rnd.Next(16) < 5)
                                        {
                                            p_dmg[f, n] *= 2;
                                            crit = 2;
                                        }
                                    }

                                    if (f > 0) p_dmg[f, n] = (p_dmg[f, n] * (100 - (f * 10))) / 100;

                                    if (Character.Information.Berserking)
                                        p_dmg[f, n] = (p_dmg[f, n] * Character.Information.BerserkOran) / 100;

                                    if (p_dmg[f, n] <= 0)
                                        p_dmg[f, n] = 1;
                                    else
                                    {
                                        if (target[f].mAbsorb() > 0)
                                        {
                                            int static_dmg = (p_dmg[f, n] * (100 - (int)target[f].mAbsorb())) / 100;
                                            target[f].MP(static_dmg);
                                            p_dmg[f, n] = static_dmg;
                                        }
                                        p_dmg[f, n] += Rnd.Next(0, p_dmg.ToString().Length);
                                    }

                                    statichp[f] -= p_dmg[f, n];
                                    if (statichp[f] < 1)
                                    {
                                        status[f] = 128;
                                        target[f].GetDead();
                                    }

                                    if (Character.Action.Skill.OzelEffect == 4 && status[f] != 128)
                                    {
                                        if (Rnd.Next(20) < 5)
                                            status[f] = 4;
                                    }
                                    if (Character.Action.Skill.OzelEffect == 5 && status[f] != 128)
                                    {
                                        if (Rnd.Next(20) < 5)
                                            status[f] = 5;
                                    }

                                    Writer.Byte(status[f]); //so here we add status same opcode 132:Knock down yaptığın zaman ölecekse 133:knock back yaptığın zaman ölecekse
                                    Writer.Byte(crit);
                                    Writer.DWord(p_dmg[f, n]);
                                    Writer.Byte(0);
                                    Writer.Word(0);

                                    if (status[f] == 4) // if status was knockdown just add the new position of the mob where it should be knocked down
                                    {
                                        Writer.Byte(target[f].xSec);
                                        Writer.Byte(target[f].ySec);
                                        Writer.Word(Formule.packetx(target[f].x, target[f].xSec));
                                        Writer.Word(0);
                                        Writer.Word(Formule.packety(target[f].y, target[f].ySec));
                                         Writer.Word(65535);
                                        Writer.Word(1832);
                                        Writer.Word(0);
                                    }
                                    else if (status[f] == 5)
                                    {
                                        if (target[f].os == null && target[f].sys != null)
                                        {
                                            target[f].sys.Character.Position.x += 1;
                                            target[f].sys.Character.Position.y += 1;
                                        }
                                        else
                                        {
                                            target[f].os.x += 1;
                                            target[f].os.y += 1;
                                        }
                                        Writer.Byte(target[f].xSec);
                                        Writer.Byte(target[f].ySec);
                                        Writer.Word(Formule.packetx(target[f].x, target[f].xSec));
                                        Writer.Word(0);
                                        Writer.Word(Formule.packety(target[f].y, target[f].ySec));
                                        Writer.Word(65535);
                                        Writer.Word(1832);
                                        Writer.Word(0);
                                    }
                                }
                                else Writer.Byte(2);
                            }
                        }

                    }
                }
                Send(list, Writer.GetBytes());

                for (byte f = 0; f < Character.Action.Skill.Found; f++)
                {
                    if (target[f].sys == null && target[f].os == null)
                    { }
                    else
                    {
                        if (target[f].sys != null && target[f].os == null) // player
                            Effect.EffectMain(target[f].sys, Character.Action.Skill.MainSkill);

                        if (target[f].sys == null && target[f].os != null) // mob
                            Effect.EffectMain(target[f].os, Character.Action.Skill.MainSkill);
                    }
                }

                Character.Action.sCasting = true;
                Character.Action.sAttack = false;
                /*if (ObjData.Manager.SkillBase[Character.Action.Skill.MainSkill].Action_CoolTime == 0)
                    ObjData.Manager.SkillBase[Character.Action.Skill.MainSkill].Action_CoolTime = 150;*/

                StartsWaitTimer(ObjData.Manager.SkillBase[Character.Action.Skill.MainSkill].Action_ActionDuration, target, p_dmg, status);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 void AmountControl()
 {
     try
     {
         Character.Action.Skill.FoundID[Character.Action.Skill.Found] = Character.Action.Target;
         Character.Action.Skill.Found++;
         if (Character.Action.Skill.Tdistance > 1)
         {
             object mainObject = Helpers.GetInformation.GetObjects(Character.Action.Target);
             if (mainObject == null) return;
             WorldMgr.targetObject target = new WorldMgr.targetObject(mainObject, this);
             float x = target.x - Character.Action.Skill.Tdistance;
             float y = target.y - Character.Action.Skill.Tdistance;
             for (int i = 0; i < Helpers.Manager.Objects.Count; i++)
             {
                 if (Character.Action.Skill.Found == Character.Action.Skill.Tdistance) return;
                 if (Helpers.Manager.Objects[i] != null)
                 {
                     WorldMgr.Monsters o = Helpers.Manager.Objects[i];
                     if (!o.Die && o.LocalType == 1)
                     {
                         if (o.x >= x && o.x <= (x + (Character.Action.Skill.Tdistance * 2)) && o.y >= y - Character.Action.Skill.Tdistance && o.y <= (y + (Character.Action.Skill.Tdistance * 2)) && o.UniqueID != Character.Action.Target)
                         {
                             //if (o.AgressiveDMG == null) o.AgressiveDMG = new List<_agro>();
                             Character.Action.Skill.FoundID[Character.Action.Skill.Found] = o.UniqueID;
                             Character.Action.Skill.Found++;
                         }
                     }
                 }
             }
             lock (Helpers.Manager.clients)
             {
                 for (int i = 0; i < Helpers.Manager.clients.Count; i++)
                 {
                     try
                     {
                         if (Character.Action.Skill.Found == Character.Action.Skill.Tdistance) return;
                         if (Helpers.Manager.clients[i] != null)
                         {
                             PlayerMgr sys = Helpers.Manager.clients[i];
                             if (sys.Character.Information.PvP && sys != this && !sys.Character.State.Die)
                                 if (sys.Character.Information.UniqueID != Character.Action.Target && Character.Information.UniqueID != Character.Action.Target)
                                 {
                                     if (sys.Character.Position.x >= x && sys.Character.Position.x <= (x + (Character.Action.Skill.Tdistance * 2)) && sys.Character.Position.y >= y && sys.Character.Position.y <= (y + (Character.Action.Skill.Tdistance * 2)))
                                     {
                                         Character.Action.Skill.FoundID[Character.Action.Skill.Found] = sys.Character.Information.UniqueID;
                                         Character.Action.Skill.Found++;
                                     }
                                 }
                         }
                     }
                     catch (Exception ex)
                     {
                         Log.Exception(ex);
                     }
                 }
             }
             target = null;
         }
     }
     catch (Exception ex)
     {
         Log.Exception(ex);
     }
 }
        void ActionAttack()
        {
            try
            {
                //Predefined info needs work!
                #region Predefined info
                byte NumberAttack = 2;
                int AttackType = 1;
                int[] found = new int[3];
                byte numbert = 1;
                int p_dmg = 0;
                byte status = 0, crit = 1;
                #endregion
                client.Send(Packet.ActionState(1, 1));
                //Bow information
                if (CheckBow())
                {
                    StopSkillTimer();
                    StopAttackTimer();
                    return;
                }

                WorldMgr.targetObject target = new WorldMgr.targetObject(Character.Action.Object, this);

                if (Character.Action.ImbueID != 0 && ObjData.Manager.SkillBase[Character.Action.ImbueID].Series.Remove(ObjData.Manager.SkillBase[Character.Action.ImbueID].Series.Length - 2) == "SKILL_CH_LIGHTNING_GIGONGTA")
                {
                    numbert = ActionGetObject(ref found, 2, target.x, target.y, Character.Action.Target, 5);
                }
                else found[1] = Character.Action.Target;

                if (Character.Information.Item.wID != 0)
                {
                    switch (ObjData.Manager.ItemBase[Character.Information.Item.wID].TypeID4)
                    {
                        //Chinese base skills
                        case 2:                 //One handed sword
                        case 3:
                            NumberAttack = 2;
                            AttackType = 2;
                            break;
                        case 4:                 //Spear attack + glavie
                        case 5:
                            NumberAttack = 1;
                            AttackType = 40;
                            break;
                        case 6:                 //Bow attack
                            NumberAttack = 1;
                            AttackType = 70;
                            break;
                        //Europe Base skills
                        case 7:
                            NumberAttack = 1;
                            AttackType = 7127; // One handed sword
                            break;
                        case 8:
                            NumberAttack = 1;
                            AttackType = 7128; // Two handed sword
                            break;
                        case 9:
                            NumberAttack = 2;
                            AttackType = 7129; // Axe basic attack
                            break;
                        case 10:
                            NumberAttack = 1;
                            AttackType = 9069; // Warlock base
                            break;
                        case 11:
                            NumberAttack = 1;
                            AttackType = 8454; // Staff / Tstaff
                            break;
                        case 12:
                            NumberAttack = 1;
                            AttackType = 7909; // Crossbow base
                            break;
                        case 13:
                            NumberAttack = 2; //Dagger
                            AttackType = 7910;
                            break;
                        case 14:
                            NumberAttack = 1;
                            AttackType = 9606; // Harp base
                            break;
                        case 15:
                            NumberAttack = 1;
                            AttackType = 9970; // Light staff cleric
                            break;
                        case 16:
                            NumberAttack = 1;
                            AttackType = ObjData.Manager.SkillBase[Character.Action.UsingSkillID].ID;
                            break;
                        default:
                            Console.WriteLine("Action attack case: {0} , SkillID = {1}" + ObjData.Manager.ItemBase[Character.Information.Item.wID].TypeID4, ObjData.Manager.SkillBase[Character.Action.UsingSkillID].ID);
                            break;
                    }
                }
                else
                {
                    //Punch attack
                    NumberAttack = 1;
                    AttackType = 1;
                }
                //Get casting id
                Character.Action.AttackingID = Character.Ids.GetCastingID();
                //Create new packet writer
                PacketWriter Writer = new PacketWriter();
                Writer.Create(OperationCode.SERVER_ACTION_DATA);
                Writer.Byte(1);
                Writer.Byte(2);
                Writer.Byte(0x30);
                Writer.DWord(AttackType);
                Writer.DWord(Character.Information.UniqueID);
                Writer.DWord(Character.Action.AttackingID);
                Writer.DWord(Character.Action.Target);
                Writer.Bool(true);
                Writer.Byte(NumberAttack);
                Writer.Byte(numbert);

                for (int t = 1; t <= numbert; t++)
                {
                    Writer.DWord(found[t]);

                    for (byte n = 1; n <= NumberAttack; n++)
                    {
                        //Set defaults
                        p_dmg = (int)Formule.gamedamage(Character.Stat.MaxPhyAttack, Character.Stat.AttackPower + MasteryGetPower(AttackType), 0, (double)target.PhyDef, Character.Information.Phy_Balance, Character.Stat.UpdatededPhyAttack);
                        status = 0;
                        crit = 0;
                        //Set target
                        target = new WorldMgr.targetObject(Helpers.GetInformation.GetObjects(found[t]), this);

                        //Make sure we dont get null error
                        if (Character.Action.UsingSkillID != 0)
                        {
                            //If we have an active imbue
                            if (ObjData.Manager.SkillBase[Character.Action.UsingSkillID].Definedname == ObjData.s_data.Definedtype.Imbue)
                            {
                                p_dmg += ObjData.Manager.SkillBase[Character.Action.UsingSkillID].MaxAttack;
                                p_dmg += Rnd.Next(0, p_dmg.ToString().Length);
                            }
                        }
                        if (status != 128)
                        {
                            status = target.HP((int)p_dmg);
                        }
                        else
                        {
                            target.GetDead();
                            Character.Action.nAttack = false;
                        }
                        Writer.Byte(status);
                        Writer.Byte(crit);
                        Writer.DWord(p_dmg);
                        Writer.Byte(0);
                        Writer.Word(0);

                        p_dmg = 0;
                    }
                }

                Send(Writer.GetBytes());
                client.Send(Packet.ActionState(2, 0));
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
        void Player_Effect_CallBack(object e)
        {
            try
            {
                StopEffectTimer((byte)e);

                WorldMgr.targetObject thisObject = new WorldMgr.targetObject(this, null);

                foreach (KeyValuePair<string, int> p in ObjData.Manager.SkillBase[Character.Action.DeBuff.Effect.SkillID[(byte)e]].Properties1)
                {
                    switch (p.Key)
                    {
                        case "fb":
                            CLGameServer.Effect.DeleteEffect_fb(thisObject, (byte)e);
                            break;
                        case "bu":

                            break;
                        case "fz":
                            CLGameServer.Effect.DeleteEffect_fz(thisObject, (byte)e);
                            break;
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }