Example #1
0
        private GameOperationResponse HandleLoginCharacter(int sessionId, LoginCharacter operation)
        {
            try
            {
                var playerData = application.CharacterDatabase.Query <PlayerData>("PlayerData/ByUsernameAndByName")
                                 //.Customize(x => x.WaitForNonStaleResultsAsOfNow())
                                 .Select(chr => new { chr.Username, chr.Name, chr.Guid, chr.ZoneId })
                                 .FirstOrDefault(
                    chr =>
                    chr.Username.Equals(operation.Username, StringComparison.CurrentCultureIgnoreCase) &&
                    chr.Name.Equals(operation.CharacterName, StringComparison.CurrentCultureIgnoreCase));

                if (playerData == null)
                {
                    return(operation.GetErrorResponse((short)ResultCode.PlayerNotFound));
                }

                // requesting master to zone in the client
                this.peer.SendOperationRequest(new OperationRequest((byte)ServerOperationCode.AckClientCharacterLogin,
                                                                    new AckClientCharacterLogin
                {
                    SessionId     = sessionId,
                    Guid          = playerData.Guid,
                    CharacterName = playerData.Name,
                    ZoneId        = playerData.ZoneId,
                }),
                                               new SendParameters());
                return(null);
            }
            catch (Exception e)
            {
                _logger.Error(e);
                return(operation.GetErrorResponse((short)ResultCode.Fail));
            }
        }
Example #2
0
        public override void HandlePacket(PacketReader packet, LoginClient client)
        {
            var name         = packet.ReadString();
            var face         = packet.ReadInt();
            var hair         = packet.ReadInt();
            var hairColor    = packet.ReadInt();
            var skin         = (byte)packet.ReadInt();
            var topId        = packet.ReadInt();
            var bottomId     = packet.ReadInt();
            var shoesId      = packet.ReadInt();
            var weaponId     = packet.ReadInt();
            var strength     = packet.ReadByte();
            var dexterity    = packet.ReadByte();
            var intelligence = packet.ReadByte();
            var luck         = packet.ReadByte();
            var error        = ValidateCharacterCreation(client.Server, client.World, name, face, hair, hairColor, skin, topId,
                                                         bottomId, shoesId, weaponId, client.Account.Gender);

            var character = new LoginCharacter
            {
                AccountId = client.Account.Id,
                WorldId   = client.World,
                Name      = name,
                Map       = new Map(ServerConfig.Instance.DefaultMapId)
            };

            character.PrimaryStats = new CharacterStats(character)
            {
                Gender       = client.Account.Gender,
                Skin         = skin,
                Face         = face,
                Hair         = hair + hairColor,
                Level        = 1,
                Job          = Job.Beginner,
                Strength     = strength,
                Dexterity    = dexterity,
                Intelligence = intelligence,
                Luck         = luck,
                MaxHealth    = 50,
                MaxMana      = 5,
                Health       = 50,
                Mana         = 5
            };

            character.Items.Add(new Item(topId, equipped: true));
            character.Items.Add(new Item(bottomId, equipped: true));
            character.Items.Add(new Item(shoesId, equipped: true));
            character.Items.Add(new Item(weaponId, equipped: true));
            character.Create();

            using var pw = new PacketWriter(ServerOperationCode.CreateCharacterResult);
            pw.WriteBool(error);
            if (!error)
            {
                pw.WriteBytes(character.ToByteArray());
            }

            client.Send(pw);
        }
Example #3
0
        public override void HandlePacket(PacketReader packet, LoginClient client)
        {
            packet.ReadInt(); // Birthday
            var characterId = packet.ReadInt();

            LoginCharacter.Delete(client.Account.Id, characterId);

            using var pw = new PacketWriter(ServerOperationCode.DeleteCharacterResult);
            pw.WriteInt(characterId);
            pw.WriteByte(CharacterDeletionResult.Valid);
            client.Send(pw);
        }
Example #4
0
        protected virtual GameOperationResponse HandleOperationLoginCharacter(GameOperationRequest operationRequest, MessageParameters parameters)
        {
            var operation = new LoginCharacter(this.peer.Protocol, operationRequest);

            if (!operation.IsValid)
            {
                return(operation.GetErrorResponse((short)ResultCode.InvalidOperationParameter, operation.GetErrorMessage()));
            }

            ThreadPool.QueueUserWorkItem(
                o => this.ExecUserOperation(() => this.HandleLoginCharacter(operationRequest.ClientId, operation), operationRequest.ClientId, parameters));

            return(null);
        }
Example #5
0
        override protected void BytesToData(byte[] data)
        {
            if (data == null || data.Length < 3)
            {
                return;
            }

            short num = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 0));

            LoginCharacter[] cs = new LoginCharacter[num];

            int i      = 0;
            int offset = 2;

            for (; i < num; i++)
            {
                cs[i]    = new LoginCharacter();
                cs[i].ID = NetConvert.ToUInt32(IPAddress.NetworkToHostOrder(BitConverter.ToInt32(data, offset)));
                offset  += 4;
            }
            num     = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, offset));
            offset += 2;
            for (i = 0; i < num; i++)
            {
                NetString s = new NetString(data, offset);
                cs[i].Name = s.ToString();
                offset    += s.TotalLength;
            }
            num     = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, offset));
            offset += 2;
            for (i = 0; i < num; i++)
            {
                cs[i].Level = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(data, offset));
                offset     += 4;
            }
            num     = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, offset));
            offset += 2;
            for (i = 0; i < num; i++)
            {
                cs[i].IsOnline = Convert.ToBoolean(IPAddress.NetworkToHostOrder(BitConverter.ToInt32(data, offset)));
                offset        += 4;
            }

            this._characters      = cs;
            this._charactersCount = num;
        }
Example #6
0
        public List <Character> GetCharacters(byte worldId, int accountId)
        {
            using var dbContext = new MapleDbContext();
            var result = new List <Character>();

            var characters = dbContext
                             .Characters
                             .Where(x => x.AccountId == accountId)
                             .Where(x => x.WorldId == worldId);

            characters
            .ToList()
            .ForEach(x =>
            {
                var c = new LoginCharacter()
                {
                    Id = x.Id
                };
                c.Load();
                result.Add(c);
            });

            return(result);
        }
Example #7
0
        /// <summary>
        /// The parse.
        /// </summary>
        /// <param name="client">
        /// </param>
        /// <param name="packet">
        /// </param>
        /// <param name="messageNumber">
        /// </param>
        /// <returns>
        /// </returns>
        public bool Parse(Client client, byte[] packet, ushort messageNumber)
        {
            switch (messageNumber)
            {
            case 0:
                Authenticate.Read(client, ref packet);
                break;

            case 2:

                // Chat bot wants to authenticate
                AuthenticateBot.Read(client, packet);
                break;

            case 3:
                LoginCharacter.Read(client, packet);
                break;

            case 21:
                PlayerNameLookup.Read(client, packet);
                break;

            case 30:
                Tell.Read(client, packet);
                break;

            case 40:
                BuddyAdd.Read(client, packet);
                break;

            case 41:
                new BuddyRemove().Read(client, packet);
                break;

            case 42:
                new OnlineStatus().Read(client, packet);
                break;

            case 50:
                new PrivateGroupInvitePlayer().Read(client, packet);
                break;

            case 51:
                new PrivateGroupKickPlayer().Read(client, packet);
                break;

            case 52:
                new PrivateGroupJoin().Read(client, packet);
                break;

            case 53:
                new PrivateGroupLeave().Read(client, packet);
                break;

            case 54:

                // this packet should have no data to read
                PrivateGroupKickEveryone.Read(client, ref packet);
                break;

            case 57:
                new PrivateGroupMessage().Read(client, packet);
                break;

            case 64:
                new ChannelDataSet().Read(client, packet);
                break;

            case 65:
                ChannelMessage.Read(client, packet);
                break;

            case 66:
                new ChannelMode().Read(client, packet);
                break;

            case 70:
            case 71:

                // should never get these messages (ClimodeGet and ClimodeSet)
                break;

            case 100:

                // Ping
                client.Send(packet);
                break;

            case 110:
                break;

            case 120:
                new ChatCommand().Read(client, packet);
                break;

            default:
                client.Server.Warning(client, "Client sent unknown message {0}", messageNumber.ToString());
                return(false);
            }

            return(true);
        }