MoveToObject() public static method

public static MoveToObject ( int Index_, _Position &obj_1, _Position obj_2, Player general, bool Monster ) : bool
Index_ int
obj_1 _Position
obj_2 _Position
general Player
Monster bool
return bool
Example #1
0
        public static void CheckAttack(int Index_)
        {
            Timers.MonsterMovement[Index_].Stop();

            if (Player.General[Monsters.General[Index_].AttackingObjectIndex].User != null)
            {
                if (Movement.MoveToObject(Index_, ref Monsters.Position[Index_], Player.Position[Monsters.General[Index_].AttackingObjectIndex], Monsters.General[Index_].UniqueID, true))
                {
                    Attack.OnMonsterAttack(Index_);
                }
            }
        }
Example #2
0
        public static void Action(PacketReader reader_, int Index_)
        {
            PacketWriter writer = new PacketWriter();

            reader_.ModifyIndex(1);
            byte type = reader_.ReadByte();

            if (Player.General[Index_].State != 1)
            {
                switch (type)
                {
                case 1:

                    reader_.ModifyIndex(1);
                    uint ObjectId = reader_.ReadDword();
                    Player.Objects[Index_].AttackingObjectId = ObjectId;
                    int ObjectIndex = Players.GetObjectIndexAndType(Index_, Player.Objects[Index_].AttackingObjectId);

                    bool attack = false;

                    if (Player.Objects[Index_].SelectedObjectType == 2)
                    {
                        attack = Movement.MoveToObject(Index_, ref Player.Position[Index_], Monsters.Position[ObjectIndex], Player.General[Index_], false);
                    }

                    else
                    {
                        attack = Movement.MoveToObject(Index_, ref Player.Position[Index_], Player.Position[ObjectIndex], Player.General[Index_], false);
                    }

                    if (attack)
                    {
                        if (!Player.Objects[Index_].NormalAttack)
                        {
                            Attack.NormalAttack(Index_);
                        }
                    }
                    break;

                case 2:
                    reader_.ModifyIndex(1);
                    ObjectId = reader_.ReadDword();

                    ObjectIndex = 0;
                    for (int i = 0; i <= Item.ItemAmount; i++)
                    {
                        if (Item.General[i].UniqueID == ObjectId && Index_ != i)
                        {
                            ObjectIndex = i;
                            break;
                        }
                    }

                    bool pickup = false;

                    pickup = Movement.MoveToObject(Index_, ref Player.Position[Index_], Item.Position[ObjectIndex], Player.General[Index_], false);

                    if (pickup)
                    {
                        PickUpItem(Index_, ObjectIndex);
                    }

                    break;

                case 4:

                    uint skillid = reader_.ReadDword();

                    bool skillexist          = false;
                    int  CharacterSkillIndex = DatabaseCore.Skill.GetIndexByName(Player.General[Index_].CharacterName);

                    for (int i = 0; i <= DatabaseCore.Skill.SkillAmount[CharacterSkillIndex]; i++)
                    {
                        if (skillid == DatabaseCore.Skill.Skills[CharacterSkillIndex].SkillId[i])
                        {
                            skillexist = true;
                            break;
                        }
                        skillexist = false;
                    }

                    if (skillexist)
                    {
                        byte type_ = reader_.ReadByte();
                        switch (type_)
                        {
                        case 0:
                            bool alreadyactive = false;
                            for (byte i = 0; i < Player.Objects[Index_].ActiveBuffs.Length; i++)
                            {
                                if (Player.Objects[Index_].ActiveBuffs[i].Id == skillid)
                                {
                                    alreadyactive = true;
                                }
                            }
                            if (!alreadyactive)
                            {
                                Player.Objects[Index_].UsingSkillID = skillid;
                                if (!Player.Objects[Index_].UsingSkill)
                                {
                                    PrepareBuff(Index_);
                                }
                            }
                            return;

                        case 1:
                            uint attackingObjectId = reader_.ReadDword();

                            Player.Objects[Index_].AttackingSkillID  = skillid;
                            Player.Objects[Index_].AttackingObjectId = attackingObjectId;
                            Player.Objects[Index_].NormalAttack      = false;
                            if (!Player.Objects[Index_].UsingSkill)
                            {
                                SkillAttackType(Index_);
                            }

                            return;
                        }
                    }
                    break;

                default:
                    Timers.PlayerAttack[Index_].Stop();
                    break;
                }
            }
        }
Example #3
0
        private static void SkillAttackType(int Index_)
        {
            PacketWriter writer = new PacketWriter();

            Silkroad.Skill_ tmpSkill = Silkroad.GetSkillById(Player.Objects[Index_].AttackingSkillID);

            byte weapontype = 0;

            if (Player.General[Index_].WeaponType == 6)
            {
                weapontype = Silkroad.TypeTable.Bow;
            }
            if ((Player.General[Index_].WeaponType == 2) || (Player.General[Index_].WeaponType == 3))
            {
                weapontype = Silkroad.TypeTable.Bicheon;
            }
            if ((Player.General[Index_].WeaponType == 4) || (Player.General[Index_].WeaponType == 5))
            {
                weapontype = Silkroad.TypeTable.Heuksal;
            }

            byte skilltype = tmpSkill.Type2;

            if (!(weapontype == skilltype) && !(skilltype == Silkroad.TypeTable.All))
            {
                Player.Objects[Index_].UsingSkill = false;
                writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ATTACK);
                writer.AppendWord(0xD02);
                ServerSocket.Send(writer.getWorkspace(), Index_);

                writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_SKILL_ATTACK);
                writer.AppendWord(3);
                writer.AppendByte(4);
                ServerSocket.Send(writer.getWorkspace(), Index_);
            }
            else
            {
                int ObjectIndex = Players.GetObjectIndexAndType(Index_, Player.Objects[Index_].AttackingObjectId);
                if (Player.Objects[Index_].SelectedObjectType == 2)
                {
                    Timers.MonsterMovement[ObjectIndex].Stop();
                }

                bool attack = false;

                if (Player.Objects[Index_].SelectedObjectType == 2)
                {
                    attack = Movement.MoveToObject(Index_, ref Player.Position[Index_], Monsters.Position[ObjectIndex], Player.General[Index_].UniqueID, Player.General[Index_].CharacterID, tmpSkill.Distance * 10, weapontype, false);
                }

                else
                {
                    attack = Movement.MoveToObject(Index_, ref Player.Position[Index_], Player.Position[ObjectIndex], Player.General[Index_].UniqueID, Player.General[Index_].CharacterID, tmpSkill.Distance * 10, weapontype, false);
                }

                if (attack)
                {
                    Attack.BeginSkill(Index_);
                }
            }
        }