private void RecoverySpring(NecClient client, int objectId)
        {
            if (client.character.eventSelectExecCode == 0)
            {
                if (client.character.hp.current == client.character.hp.max &&
                    client.character.mp.current == client.character.mp.max)
                {
                    IBuffer res12 = BufferProvider.Provide();
                    res12.WriteCString(
                        "You try drinking the water but it doesn't seem to have an effect."); // Length 0xC01
                    router.Send(client, (ushort)AreaPacketId.recv_event_system_message, res12,
                                ServerType.Area);                                             // show system message on middle of the screen.
                }
                else
                {
                    RecvEventScriptPlay recvEventScriptPlay = new RecvEventScriptPlay("etc/heal_fountain", client.character.instanceId);
                    router.Send(recvEventScriptPlay, client);

                    IBuffer res12 = BufferProvider.Provide();
                    res12.WriteCString("You drink The water and it replenishes you"); // Length 0xC01
                    router.Send(client, (ushort)AreaPacketId.recv_event_system_message, res12,
                                ServerType.Area);                                     // show system message on middle of the screen.

                    IBuffer res7 = BufferProvider.Provide();
                    res7.WriteInt32(client.character.hp.max); //To-Do : Math for Max gain of 50% MaxHp
                    router.Send(client, (ushort)AreaPacketId.recv_chara_update_hp, res7, ServerType.Area);
                    client.character.hp.ToMax();

                    IBuffer res9 = BufferProvider.Provide();
                    res9.WriteInt32(client.character.mp.max); //To-Do : Math for Max gain of 50% MaxMp
                    router.Send(client, (ushort)AreaPacketId.recv_chara_update_mp, res9, ServerType.Area);
                    client.character.mp.SetCurrent(client.character.mp.max);
                }
            }
            else if (client.character.eventSelectExecCode == 1)
            {
                IBuffer res12 = BufferProvider.Provide();
                res12.WriteCString("You Say no to random Dungeun water"); // Length 0xC01
                router.Send(client, (ushort)AreaPacketId.recv_event_system_message, res12,
                            ServerType.Area);                             // show system message on middle of the screen.
            }

            IBuffer res13 = BufferProvider.Provide();

            res13.WriteCString("To raise your level, you need 1337 more exp."); // Length 0xC01
            router.Send(client, (ushort)AreaPacketId.recv_event_system_message, res13,
                        ServerType.Area);                                       // show system message on middle of the screen.

            RecvEventEnd(client);                                               //End The Event
        }
Example #2
0
        public override void Handle(NecClient client, NecPacket packet)
        {
            IBuffer res22 = BufferProvider.Provide();

            res22.WriteInt32(1); // 0 = normal 1 = cinematic
            res22.WriteByte(0);
            router.Send(client, (ushort)AreaPacketId.recv_event_start, res22, ServerType.Area);
            //if success
            RecvEventScriptPlay recvEventScriptPlay1 = new RecvEventScriptPlay("scale\revive_success", client.character.instanceId);

            router.Send(recvEventScriptPlay1, client);
            //if fail
            RecvEventScriptPlay recvEventScriptPlay2 = new RecvEventScriptPlay("scale\revive_fail", client.character.instanceId);
            //Router.Send(recvEventScriptPlay2, client);
            //if fail again. you're lost
            RecvEventScriptPlay recvEventScriptPlay3 = new RecvEventScriptPlay("scale\revive_lost", client.character.instanceId);
            //Router.Send(recvEventScriptPlay3, client);
        }
Example #3
0
        public override void Execute(string[] command, NecClient client, ChatMessage message,
                                     List <ChatResponse> responses)
        {
            if (command[0] == null)
            {
                responses.Add(ChatResponse.CommandError(client, $"Invalid argument: {command[0]}"));
                return;
            }

            IBuffer res36 = BufferProvider.Provide();

            switch (command[0])
            {
            case "union":
                res36.WriteUInt32(client.character.instanceId);
                res36.WriteInt32(client.character.unionId);
                res36.WriteCString("Trade_Union");
                router.Send(client.map, (ushort)AreaPacketId.recv_chara_notify_union_data, res36, ServerType.Area);
                break;

            case "mant":
                res36.WriteInt32(0);
                for (int i = 0; i < 0x10; i++)
                {
                    res36.WriteByte(0);
                }

                router.Send(client, (ushort)AreaPacketId.recv_union_mantle_open, res36, ServerType.Area);
                break;

            case "xunion":
                res36.WriteUInt32(client.character.instanceId);
                res36.WriteInt32(0 /*client.Character.UnionId*/);
                res36.WriteCString("");
                router.Send(client.map, (ushort)AreaPacketId.recv_chara_notify_union_data, res36, ServerType.Area);
                break;

            case "disband":
                router.Send(client, (ushort)MsgPacketId.recv_union_notify_disband, res36, ServerType.Msg);

                res36.WriteInt32(0);     //error check
                router.Send(client, (ushort)AreaPacketId.recv_union_request_disband_result, res36,
                            ServerType.Area);

                IBuffer res37 = BufferProvider.Provide();
                res37.WriteInt32(client.character.unionId);
                router.Send(client, (ushort)MsgPacketId.recv_union_request_disband_r, res37, ServerType.Msg);

                IBuffer res40 = BufferProvider.Provide();
                res40.WriteUInt32(client.character.instanceId);
                res40.WriteInt32(0 /*client.Character.UnionId*/);
                res40.WriteCString("");
                router.Send(client.map, (ushort)AreaPacketId.recv_chara_notify_union_data, res40, ServerType.Area);

                client.character.unionId = 0;

                break;

            case "open":
                router.Send(client.map, (ushort)AreaPacketId.recv_union_open_window, res36, ServerType.Area);
                break;

            case "storage":
                //Start an event
                IBuffer res35 = BufferProvider.Provide();
                res35.WriteInt32(0);
                res35.WriteByte(0);
                router.Send(client, (ushort)AreaPacketId.recv_event_start, res35, ServerType.Area);
                //Open union storage
                res36.WriteUInt64(client.soul.warehouseGold); //todo make union gold variable
                res36.WriteInt64(500);                        //??
                router.Send(client, (ushort)AreaPacketId.recv_event_union_storage_open, res36,
                            ServerType.Area);
                break;

            case "establish":
                res36.WriteInt32(0);     //error check
                router.Send(client.map, (ushort)AreaPacketId.recv_union_request_establish_r, res36,
                            ServerType.Area);
                break;

            case "rename":
                res36.WriteCString("YouDidIt");
                router.Send(client.map, (ushort)AreaPacketId.recv_union_rename_open, res36, ServerType.Area);

                IBuffer res38 = BufferProvider.Provide();
                res38.WriteInt32(0);     //error check
                router.Send(client.map, (ushort)AreaPacketId.recv_union_request_rename_r, res38, ServerType.Area);
                break;

            case "resetid":
                client.character.unionId = 0;
                break;

            case "growth":
                res36.WriteInt32(0);     //error check
                router.Send(client.map, (ushort)AreaPacketId.recv_union_request_growth_result, res36,
                            ServerType.Area);
                IBuffer res39 = BufferProvider.Provide();
                res39.WriteInt16(3);     //sets union current exp
                router.Send(client.map, (ushort)MsgPacketId.recv_union_notify_growth, res39, ServerType.Msg);
                break;

            case "display":
                res36.WriteInt32(333);     //error check
                router.Send(client.map, (ushort)AreaPacketId.recv_quest_display_r, res36, ServerType.Area);
                break;

            case "order":
                IBuffer res2 = BufferProvider.Provide();
                res2.WriteInt32(0);     // 0 = normal 1 = cinematic
                res2.WriteByte(0);

                router.Send(client, (ushort)AreaPacketId.recv_event_start, res2, ServerType.Area);
                IBuffer res = BufferProvider.Provide();
                res.WriteInt32(1999);
                res.WriteByte(1);
                res.WriteFixedString("aaaaaaa", 0x61);
                res.WriteInt32(1);
                res.WriteInt32(1);
                res.WriteFixedString("ffffffffff", 0x61);
                res.WriteByte(1);
                res.WriteByte(1);
                res.WriteInt32(1);
                res.WriteInt32(1);
                res.WriteInt32(1);
                int numEntries4 = 0xA;
                res.WriteInt32(numEntries4);
                for (int i = 0; i < numEntries4; i++)
                {
                    res.WriteInt32(0x10);     //size of string
                    res.WriteFixedString("asfsaf", 0x10);
                    res.WriteInt16(1);
                    res.WriteInt32(1);
                }

                res.WriteByte(1);
                int numEntries5 = 0xC;
                for (int k = 0; k < numEntries5; k++)
                {
                    res.WriteInt32(0x10);     //size of string
                    res.WriteFixedString("boooooo", 0x10);
                    res.WriteInt16(1);
                    res.WriteInt32(1);
                }

                res.WriteByte(1);
                //??res.WriteByte(1);
                res.WriteFixedString("Eat the monster", 0x181);
                res.WriteFixedString("no wait,  that'd be a really weird quest", 0x181);
                for (int m = 0; m < 0x5; m++)
                {
                    res.WriteByte(1);
                    res.WriteInt32(10101);
                    res.WriteInt32(100101);
                    res.WriteInt32(0);
                    res.WriteInt32(0);
                }

                res.WriteByte(2);
                //no_JP Router.Send(client, (ushort) AreaPacketId.recv_event_quest_order, res, ServerType.Area);
                break;

            case "mission":
                IBuffer res3 = BufferProvider.Provide();
                res3.WriteInt32(0);     // 0 = normal 1 = cinematic
                res3.WriteByte(0);

                // Router.Send(client, (ushort)AreaPacketId.recv_event_start, res3, ServerType.Area);

                IBuffer res4 = BufferProvider.Provide();
                res4.WriteInt32(1);     // 0 = normal 1 = cinematic
                res4.WriteInt32(1);     // 0 = normal 1 = cinematic

                router.Send(client, (ushort)AreaPacketId.recv_quest_get_mission_quest_works_r, res4,
                            ServerType.Area);
                break;

            case "begin":
                IBuffer res5 = BufferProvider.Provide();
                res5.WriteInt32(0);     // 0 = normal 1 = cinematic
                res5.WriteByte(0);

                router.Send(client, (ushort)AreaPacketId.recv_event_start, res5, ServerType.Area);
                router.Send(client, (ushort)AreaPacketId.recv_event_quest_report_list_begin, res36,
                            ServerType.Area);
                break;

            case "start":
                uint.TryParse(command[1], out uint x);
                IBuffer res21 = BufferProvider.Provide();
                res21.WriteInt32(1);     // 0 = normal 1 = cinematic
                res21.WriteByte(255);
                router.Send(client, (ushort)AreaPacketId.recv_event_start, res21, ServerType.Area);

                RecvEventScriptPlay recvEventScriptPlay = new RecvEventScriptPlay("tutorial/tutorial_soul", client.character.instanceId);
                router.Send(recvEventScriptPlay, client);

                break;

            default:
                _Logger.Error($"There is no recv of type : {command[0]} ");
                Task.Delay(TimeSpan.FromMilliseconds(10 * 1000)).ContinueWith
                    (t1 =>
                {
                    IBuffer res = BufferProvider.Provide();
                    res.WriteByte(0);
                    router.Send(client, (ushort)AreaPacketId.recv_event_end, res, ServerType.Area);
                }
                    );
                break;
            }
        }
        private void ModelLibraryWarp(NecClient client, GGateSpawn ggateSpawn)
        {
            IBuffer res = BufferProvider.Provide();

            switch (client.character.eventSelectExecCode)
            {
            case 0:
                res = BufferProvider.Provide();
                res.WriteCString("Seriously?! Walk across the bridge. Why so Lazy?");                      // Length 0xC01
                router.Send(client, (ushort)AreaPacketId.recv_event_system_message, res, ServerType.Area); // show system message on middle of the screen.

                break;

            case 1:
                res = BufferProvider.Provide();
                RecvEventScriptPlay recvEventScriptPlay = new RecvEventScriptPlay("etc/warp_samemap", client.character.instanceId);
                router.Send(recvEventScriptPlay, client);
                Task.Delay(TimeSpan.FromMilliseconds(1500)).ContinueWith
                    (t1 =>
                {
                    res = BufferProvider.Provide();
                    res.WriteUInt32(client.character.instanceId);
                    res.WriteFloat(1574);
                    res.WriteFloat(26452);
                    res.WriteFloat(-1145);
                    res.WriteByte(client.character.heading);
                    res.WriteByte(client.character.movementAnim);
                    router.Send(client.map, (ushort)AreaPacketId.recv_object_point_move_notify, res, ServerType.Area);
                }
                    );
                break;

            case 2:
                res = BufferProvider.Provide();
                RecvEventScriptPlay recvEventScriptPlay2 = new RecvEventScriptPlay("etc/warp_samemap", client.character.instanceId);
                router.Send(recvEventScriptPlay2, client);
                Task.Delay(TimeSpan.FromMilliseconds(1500)).ContinueWith
                    (t1 =>
                {
                    res = BufferProvider.Provide();
                    res.WriteUInt32(client.character.instanceId);
                    res.WriteFloat(21);
                    res.WriteFloat(39157);
                    res.WriteFloat(-1838);
                    res.WriteByte(client.character.heading);
                    res.WriteByte(client.character.movementAnim);
                    router.Send(client.map, (ushort)AreaPacketId.recv_object_point_move_notify, res, ServerType.Area);
                }
                    );
                break;

            case 3:
                res = BufferProvider.Provide();
                RecvEventScriptPlay recvEventScriptPlay3 = new RecvEventScriptPlay("etc/warp_samemap", client.character.instanceId);
                router.Send(recvEventScriptPlay3, client);
                Task.Delay(TimeSpan.FromMilliseconds(1500)).ContinueWith
                    (t1 =>
                {
                    res = BufferProvider.Provide();
                    res.WriteUInt32(client.character.instanceId);
                    res.WriteFloat(0);
                    res.WriteFloat(47829);
                    res.WriteFloat(-2538);
                    res.WriteByte(client.character.heading);
                    res.WriteByte(client.character.movementAnim);
                    router.Send(client.map, (ushort)AreaPacketId.recv_object_point_move_notify, res, ServerType.Area);
                }
                    );
                break;

            case 4:
                res = BufferProvider.Provide();
                res.WriteCString("Turn around genius");                                                    // Length 0xC01
                router.Send(client, (ushort)AreaPacketId.recv_event_system_message, res, ServerType.Area); // show system message on middle of the screen.
                break;
            }

            RecvEventEnd(client); //End The Event
        }
        private void ResolveInn(NecClient client, int objectId, NpcSpawn npcSpawn)
        {
            if (client.character.eventSelectExecCode == 0)
            {
                int[]   hPandMPperChoice   = { 100, 50, 100, 100, 100, 100, 100, 50, 80, 100, 100 };
                byte[]  conditionPerChoice = { 150, 50, 100, 110, 120, 160, 150, 50, 80, 100, 120 };
                ulong[] goldCostPerChoice  = { 0, 0, 60, 300, 1200, 3000, 100, 0, 60, 300, 10000 };
                _Logger.Debug($"The selection you have made is {client.character.eventSelectExtraSelectionCode}");

                if (client.character.adventureBagGold < goldCostPerChoice[client.character.eventSelectExtraSelectionCode])
                {
                    IBuffer res = BufferProvider.Provide();
                    res.WriteCString("You don't have enough gold! This is why I don't like doing business with adventurers.");
                    router.Send(client, (ushort)AreaPacketId.recv_event_system_message, res, ServerType.Area); // show system message on middle of the screen.
                    RecvEventEnd(client);
                }
                else
                {
                    client.character.hp.SetCurrent((sbyte)hPandMPperChoice[client.character.eventSelectExtraSelectionCode], true);
                    client.character.mp.SetCurrent((sbyte)hPandMPperChoice[client.character.eventSelectExtraSelectionCode], true);
                    client.character.condition.SetCurrent(conditionPerChoice[client.character.eventSelectExtraSelectionCode]);
                    client.character.od.ToMax();
                    client.character.gp.ToMax();
                    client.character.adventureBagGold -= goldCostPerChoice[client.character.eventSelectExtraSelectionCode];
                    if (client.character.hp.current >= client.character.hp.max)
                    {
                        client.character.hp.ToMax();
                    }
                    if (client.character.mp.current >= client.character.mp.current)
                    {
                        client.character.mp.ToMax();
                    }

                    RecvCharaUpdateHp recvCharaUpdateHp = new RecvCharaUpdateHp(client.character.hp.current);
                    router.Send(recvCharaUpdateHp, client);
                    RecvCharaUpdateMp recvCharaUpdateMp = new RecvCharaUpdateMp(client.character.mp.current);
                    router.Send(recvCharaUpdateMp, client);
                    RecvCharaUpdateCon recvCharaUpdateCon = new RecvCharaUpdateCon(conditionPerChoice[client.character.eventSelectExtraSelectionCode]);
                    router.Send(recvCharaUpdateCon, client);
                    RecvSelfMoneyNotify recvSelfMoneyNotify = new RecvSelfMoneyNotify(client, client.character.adventureBagGold);
                    router.Send(recvSelfMoneyNotify, client);
                    RecvEventScriptPlay recvEventScriptPlay = new RecvEventScriptPlay("inn/fade_bgm", client.character.instanceId);
                    router.Send(recvEventScriptPlay, client);
                    Experience experience = new Experience();

                    //Level up stuff after inn cutscene
                    Task.Delay(TimeSpan.FromSeconds(6)).ContinueWith
                        (t1 =>
                    {
                        if (client.character.experienceCurrent > experience.CalculateLevelUp((uint)client.character.level + 1).cumulativeExperience)
                        {
                            RecvEventStart recvEventStart = new RecvEventStart(0, 0);
                            router.Send(recvEventStart, client);

                            LevelUpCheck(client);

                            Task.Delay(TimeSpan.FromSeconds(10)).ContinueWith
                                (t1 =>
                            {
                                RecvEventEnd recvEventEnd = new RecvEventEnd(0);
                                router.Send(recvEventEnd, client);         //Need a better way to end the event at the right time.
                            }
                                );
                        }
                    }
                        );
                }
            }
            else
            {
                SendEventEnd(client);
            }

            client.character.eventSelectExtraSelectionCode = 0;
            client.character.eventSelectExecCode           = 0;
            client.character.eventSelectReadyCode          = 0;
            client.character.secondInnAccess = false;
            server.database.UpdateCharacter(client.character);
        }