Пример #1
0
 public override void OnActorStartsMoving(Actor mActor, MoveArg arg)
 {
     if (mActor.ActorType == ActorType.PC)
     {
         ActorPC pc       = (ActorPC)mActor;
         int     distance = NPC.DistanceToActor(pc);
         if (distance < 150)
         {
             if (pc.Quests.ContainsKey(224))
             {
                 Quest q = pc.Quests[224];
                 if (q.Step == 0)
                 {
                     NextStep(q, 0, 1, 1, 1);
                     UpdateQuest(pc, q);
                 }
                 if (q.Step == 2 && distance < 100 && exe != null && !exe.Activated)
                 {
                     NextStep(q, 0, 7, 7, 7);
                     UpdateQuest(pc, q);
                 }
             }
         }
     }
 }
Пример #2
0
 public override void OnActorStartsMoving(Actor mActor, MoveArg arg)
 {
     if (mActor.ActorType == ActorType.PC)
     {
         Quests.QuestManager.Instance.ProcessQuest((ActorPC)mActor, mActor.MapID, true);
     }
 }
Пример #3
0
        /// <summary>
        /// Move the player towards the given direction.
        /// </summary>
        /// <param name="dir">Direction to move.</param>
        /// <returns>true if moved; false if the path is blocked.</returns>
        public bool MovePlayer(Directions dir)
        {
            var player = BaseAction.FindCharacter(currScenario, MapElements.HERO);

            var moveArg = new MoveArg(player, dir);
            var move    = new MoveAction();

            return(move.Execute(currScenario, moveArg));
        }
Пример #4
0
 public override void OnMoveActor(Actor mActor, MoveArg arg, bool knockBack)
 {
     builder.ActorMove(mActor.ActorID, (short)mActor.X, (short)mActor.Y, (short)mActor.Z, (short)arg.X, (short)arg.Y, (short)arg.Z);
     if (mActor.ActorType == ActorType.PC)
     {
         if (((ActorPC)mActor).HoldingItem != null)
         {
             MoveActor(((ActorPC)mActor).HoldingItem, arg);
         }
         if (arg is MoveArgument a)
         {
             if (a.BNSMoveType == MoveType.Run || a.BNSMoveType == MoveType.Dash)
             {
                 HeightMapBuilder.Collect((short)a.X, (short)a.Y, (short)a.Z);
             }
         }
     }
 }
Пример #5
0
 public override void OnActorStartsMoving(Actor mActor, MoveArg arg)
 {
     if (mActor.ActorType == ActorType.PC)
     {
         ActorPC pc = (ActorPC)mActor;
         if (NPC.DistanceToActor(pc) < 100)
         {
             if (pc.Quests.ContainsKey(223))
             {
                 Quest q = pc.Quests[223];
                 if (q.Step == 0)
                 {
                     NextStep(q, 0, 1, 1, 1);
                     UpdateQuest(pc, q);
                 }
             }
         }
     }
 }
Пример #6
0
 public override void OnActorStopsMoving(Actor mActor, MoveArg arg)
 {
 }
Пример #7
0
        public unsafe override void OnActorStartsMoving(Actor mActor, MoveArg arg)
        {
            if (mActor.ActorType == ActorType.ITEM || client.BroadcastService == null)
            {
                return;
            }

            if (mActor.ActorType != ActorType.NPC || ((MoveArgument)arg).BNSMoveType != Map.MoveType.Dash)
            {
                MoveArgument move = arg as MoveArgument;
                switch (move.BNSMoveType)
                {
                case Map.MoveType.StepForward:
                {
                    UpdateEvent evt = new UpdateEvent()
                    {
                        UpdateType        = UpdateTypes.Actor,
                        AdditionSession   = 0x7001,
                        Actor             = mActor,
                        Target            = mActor,
                        SkillSession      = move.SkillSession,
                        ExtraActivateMode = UpdateEvent.ExtraUpdateModes.Activate
                    };
                    evt.AddActorPara(Common.Packets.GameServer.PacketParameter.X, move.X);
                    evt.AddActorPara(Common.Packets.GameServer.PacketParameter.Y, move.Y);
                    evt.AddActorPara(Common.Packets.GameServer.PacketParameter.Z, move.Z);
                    evt.AddActorPara(Common.Packets.GameServer.PacketParameter.Dir, move.Dir);
                    byte[] buf = new byte[11];
                    fixed(byte *p = buf)
                    {
                        p[0] = 5;
                        short *ptr = (short *)&p[1];

                        ptr[0] = (short)move.X;
                        ptr[1] = (short)move.Y;
                        ptr[2] = (short)move.Z;
                        ptr[3] = (short)move.Dir;
                        ptr[4] = 1;
                    }

                    evt.UserData = buf;
                    client.BroadcastService.EnqueueUpdateEvent(evt);
                    evt = new UpdateEvent()
                    {
                        Actor           = mActor,
                        AdditionSession = 0x7001,
                        UpdateType      = UpdateTypes.ActorExtension
                    };
                    //client.BroadcastService.EnqueueUpdateEvent(evt);
                }
                break;

                case Map.MoveType.PushBack:
                {
                    UpdateEvent evt = new UpdateEvent()
                    {
                        UpdateType        = UpdateTypes.Actor,
                        AdditionSession   = 0x1001,
                        Actor             = ((MoveArgument)arg).PushBackSource,
                        Target            = mActor,
                        SkillSession      = move.SkillSession,
                        ExtraActivateMode = UpdateEvent.ExtraUpdateModes.Activate
                    };
                    //evt.AddActorPara(Common.Packets.GameServer.PacketParameter.Unk7A, 0x2000);
                    //evt.AddActorPara(Common.Packets.GameServer.PacketParameter.UnkD5, 1);
                    evt.AddActorPara(Common.Packets.GameServer.PacketParameter.X, move.X);
                    evt.AddActorPara(Common.Packets.GameServer.PacketParameter.Y, move.Y);
                    evt.AddActorPara(Common.Packets.GameServer.PacketParameter.Dir, move.Dir);
                    byte[] buf = new byte[20];
                    fixed(byte *p = buf)
                    {
                        short *ptr = (short *)p;

                        ptr[0] = 6;
                        ptr[1] = (short)move.X;
                        ptr[2] = (short)move.Y;
                        ptr[3] = (short)move.Z;
                        ptr[4] = (short)move.Dir;
                        ptr[5] = 1;
                    }

                    evt.UserData = buf;
                    client.BroadcastService.EnqueueUpdateEvent(evt);
                }
                break;

                default:
                {
                    UpdateEvent evt = new UpdateEvent()
                    {
                        UpdateType   = UpdateTypes.Movement,
                        Actor        = mActor,
                        MoveArgument = (MoveArgument)arg
                    };
                    client.BroadcastService.EnqueueUpdateEvent(evt);
                }
                break;
                }
            }
            else
            {
                UpdateEvent evt = new UpdateEvent()
                {
                    UpdateType   = UpdateTypes.NPCDash,
                    Actor        = mActor,
                    MoveArgument = new MoveArgument()
                };
                client.BroadcastService.EnqueueUpdateEvent(evt);

                evt = new UpdateEvent()
                {
                    UpdateType   = UpdateTypes.NPCDash,
                    Actor        = mActor,
                    MoveArgument = (MoveArgument)arg
                };
                client.BroadcastService.EnqueueUpdateEvent(evt);

                /*evt = new UpdateEvent();
                 * evt.UpdateType = UpdateTypes.Unknown423;
                 * evt.Actor = mActor;
                 * evt.MoveArgument = (MoveArgument)arg;
                 *
                 * client.BroadcastService.EnqueueUpdateEvent(evt);*/

                /*evt = new UpdateEvent();
                 * evt.UpdateType = UpdateTypes.Unknown50E;
                 * evt.Actor = mActor;
                 * evt.MoveArgument = (MoveArgument)arg;
                 *
                 * client.BroadcastService.EnqueueUpdateEvent(evt);*/
            }
        }
Пример #8
0
        public override void OnActorStartsMoving(Actor mActor, MoveArg arg)
        {
            if (mActor is ActorPC target)
            {
                if (exe?.Activated == false)
                {
                    ushort[] questIDs = new ushort[] { 225, 228, 234, 237 };
                    foreach (ushort i in questIDs)
                    {
                        if (target.Quests.ContainsKey(i))
                        {
                            Quest q = target.Quests[i];
                            if (q.Step == 2)
                            {
                                if (NPC.DistanceToPoint2D(arg.X, arg.Y) < 100)
                                {
                                    ProcessQuest(target, 3, q);
                                    target = null;
                                }
                            }
                            return;
                        }
                    }
                    questIDs = new ushort[] { 227, 230, 236, 239 };
                    foreach (ushort i in questIDs)
                    {
                        if (target.Quests.ContainsKey(i))
                        {
                            Quest q = target.Quests[i];
                            if (q.Step == 1)
                            {
                                if (NPC.DistanceToPoint2D(arg.X, arg.Y) < 100)
                                {
                                    switch (q227_step)
                                    {
                                    case 1:
                                    {
                                        BeginTask();
                                        Dash(-2123, 11037, 555, 254, 0, 0);
                                        Dash(-2313, 10448, 556, 253, 0, 0);
                                        Dash(-2399, 10184, 502, 252, 0, 0);
                                        q227_step = 2;
                                        exe       = StartTask();
                                    }
                                    break;

                                    case 2:
                                    {
                                        BeginTask();
                                        NPCChat(1572, target);
                                        Delay(10);
                                        Dash(-2400, 10174, 504, 265, 1426, 43);
                                        q227_step = 3;
                                        exe       = StartTask();
                                    }
                                    break;

                                    case 3:
                                    {
                                        BeginTask();
                                        Dash(-3183, 10442, 421, 161, 0, 0);
                                        q227_step = 4;
                                        exe       = StartTask();
                                    }
                                    break;

                                    case 4:
                                    {
                                        BeginTask();
                                        NPCChat(2405, target);
                                        Delay(10);
                                        Dash(-3186, 10445, 643, 135, 1427, 43);
                                        q227_step = 5;
                                        exe       = StartTask();
                                    }
                                    break;

                                    case 5:
                                    {
                                        BeginTask();
                                        Dash(-4258, 10987, 319, 153, 0, 0);
                                        q227_step = 6;
                                        exe       = StartTask();
                                    }
                                    break;

                                    case 6:
                                    {
                                        ProcessQuest(target, 2, q);
                                        target = null;
                                        exe    = null;
                                    }
                                    break;
                                    }
                                }
                            }
                            return;
                        }
                    }
                }
            }
        }
Пример #9
0
        public override void OnActorStartsMoving(Actor mActor, MoveArg arg)
        {
            if (mActor is ActorPC target)
            {
                if (exe?.Activated == false)
                {
                    if (target.Quests.ContainsKey(221))
                    {
                        Quest q = target.Quests[221];
                        if (q.Step == 4)
                        {
                            if (NPC.DistanceToPoint2D(arg.X, arg.Y) < 50)
                            {
                                NextStep(q, 0, 31, 31, 31);
                                UpdateQuest(target, q);

                                BeginTask();
                                Delay(10);
                                Move(-3031, 9250, 582, 244, 125, false);
                                Move(-3036, 9245, 583, 225, 500, false);
                                Move(-3042, 9239, 583, 225, 500, false);
                                Move(-3045, 9236, 583, 225, 250, false);
                                StartTask();
                                target = null;
                            }
                        }
                        return;
                    }
                    if (target.Quests.ContainsKey(222))
                    {
                        Quest q = target.Quests[222];
                        if (q.Step == 0)
                        {
                            if (NPC.DistanceToPoint2D(arg.X, arg.Y) < 100)
                            {
                                NextStep(q, 0, 1, 1, 1);
                                UpdateQuest(target, q);
                            }
                        }
                    }
                    if (target.Quests.ContainsKey(223))
                    {
                        Quest q = target.Quests[223];
                        if (q.Step == 2)
                        {
                            if (NPC.DistanceToPoint2D(arg.X, arg.Y) < 100)
                            {
                                switch (q223State)
                                {
                                case 0:
                                    BeginTask();
                                    //NPCChat(1604, 292);
                                    NPCChat(1570, 119);
                                    Delay(15);
                                    Dash(-2495, 9344, 553, 180, 1397, 32);
                                    Delay(35);
                                    Dash(-2208, 8577, 552, 291, 0, 0);
                                    exe       = StartTask();
                                    q223State = 1;
                                    break;

                                case 1:
                                    BeginTask();
                                    NPCChat(1548, 291);
                                    Delay(5);
                                    Move(-2206, 8564, 552, 279, 209);
                                    Move(-2206, 8533, 550, 269, 500);
                                    Move(-2207, 8502, 557, 269, 500);
                                    Move(-2208, 8471, 567, 269, 500);
                                    Move(-2209, 8464, 568, 269, 112);
                                    Move(-2219, 8435, 586, 250, 500);
                                    Move(-2230, 8406, 600, 250, 500);
                                    Move(-2241, 8377, 611, 250, 500);
                                    Move(-2252, 8348, 622, 250, 500);
                                    Move(-2263, 8319, 632, 250, 500);
                                    Move(-2266, 8311, 634, 250, 129);
                                    Move(-2248, 8286, 641, 306, 500);
                                    Move(-2230, 8261, 645, 306, 500);
                                    Move(-2227, 8256, 645, 306, 80);
                                    Move(-2196, 8262, 646, 11, 500);
                                    Move(-2177, 8266, 649, 11, 306);
                                    Move(-2159, 8291, 650, 53, 500);
                                    Move(-2141, 8316, 655, 53, 500);
                                    Move(-2123, 8341, 657, 53, 500);
                                    Move(-2105, 8366, 658, 53, 500);
                                    Move(-2087, 8391, 657, 53, 500);
                                    Move(-2068, 8416, 657, 53, 500);
                                    Move(-2055, 8433, 658, 53, 338);
                                    exe       = StartTask();
                                    q223State = 2;
                                    break;

                                case 2:
                                {
                                    CutScene(target, 46);
                                    NextStep(q, 0, 7, 7, 7);
                                    UpdateQuest(target, q);
                                    BeginTask();
                                    Move(-2050, 8439, 658, 47, 500, false);
                                    Move(-2044, 8445, 658, 47, 500, false);
                                    exe = StartTask();
                                }
                                break;
                                }
                            }
                        }
                    }
                }
            }
        }
Пример #10
0
 public abstract void OnActorStopsMoving(Actor mActor, MoveArg arg);