Пример #1
0
        private void OnCreateCharacterRequest(string username, PacketBase p)
        {
            // TODO: Validate + sanitize packet

            CreateCharacterPacket packet = (CreateCharacterPacket)p;
            PCData pcData = new PCData
            {
                LastName  = packet.LastName,
                FirstName = packet.FirstName
            };

            string path = _pathService.ServerVaultDirectory + username + "/" + pcData.GlobalID + ".pcf";

            _dataService.Save(pcData, path);

            CharacterCreatedPacket response = new CharacterCreatedPacket
            {
                Description = pcData.Description,
                LastName    = pcData.LastName,
                FirstName   = pcData.FirstName,
                Level       = pcData.Level,
                GlobalID    = pcData.GlobalID
            };

            _networkService.SendMessage(PacketDeliveryMethod.ReliableUnordered, response, username);
        }
Пример #2
0
        /// <summary>
        /// Handles creation of character.
        /// </summary>
        private async void HandleCreateCharacter(CreateCharacterPacket createCharacterPacket)
        {
            using var database = DependencyContainer.Instance.Resolve <IDatabase>();

            // Get number of user characters.
            var characters = database.Characters.Where(x => x.UserId == _client.UserID).ToList();

            byte freeSlot = createCharacterPacket.Slot;

            if (characters.Any(c => c.Slot == freeSlot && !c.IsDelete))
            {
                // Wrong slot.
                SendCreatedCharacter(false);
                return;
            }

            var charConfig   = DependencyContainer.Instance.Resolve <CharacterConfiguration>();
            var defaultStats = charConfig.DefaultStats.FirstOrDefault(s => s.Job == createCharacterPacket.Class);

            if (defaultStats is null)
            {
                // Something went very wrong. No default stats for this job.
                SendCreatedCharacter(false);
                return;
            }

            DbCharacter character = new DbCharacter()
            {
                Name         = createCharacterPacket.CharacterName,
                Race         = createCharacterPacket.Race,
                Mode         = createCharacterPacket.Mode,
                Hair         = createCharacterPacket.Hair,
                Face         = createCharacterPacket.Face,
                Height       = createCharacterPacket.Height,
                Class        = createCharacterPacket.Class,
                Gender       = createCharacterPacket.Gender,
                Strength     = defaultStats.Str,
                Dexterity    = defaultStats.Dex,
                Rec          = defaultStats.Rec,
                Intelligence = defaultStats.Int,
                Wisdom       = defaultStats.Wis,
                Luck         = defaultStats.Luc,
                Level        = 1,
                Slot         = freeSlot,
                UserId       = _client.UserID
            };

            await database.Characters.AddAsync(character);

            if (await database.SaveChangesAsync() > 0)
            {
                characters.Add(character);
                SendCreatedCharacter(true);
                SendCharacterList(characters);
            }
        }
Пример #3
0
        public async Task Handle(WorldClient client, CreateCharacterPacket packet)
        {
            var ok = await _selectionScreenManager.TryCreateCharacter(client.UserId, packet);

            _packetFactory.SendCreatedCharacter(client, ok);

            if (ok)
            {
                _packetFactory.SendCharacterList(client, await _selectionScreenManager.GetCharacters(client.UserId));
            }
        }
Пример #4
0
        private void CreateCharacter(object obj)
        {
            CreateCharacterPacket packet = new CreateCharacterPacket
            {
                FirstName = FirstName,
                LastName  = LastName,
                Class     = SelectedClass.Resref
            };

            _networkService.SendMessage(PacketDeliveryMethod.ReliableUnordered, packet);
        }
Пример #5
0
    //캐릭터 생성 -> Server
    public void CreateCharacter(int gender, int hClass, string name)
    {
        Debug.Log("캐릭터 생성");

        CreateCharacterData   createCharacterData   = new CreateCharacterData((byte)gender, (byte)hClass, name);
        CreateCharacterPacket createCharacterPacket = new CreateCharacterPacket(createCharacterData);

        createCharacterPacket.SetPacketId((int)ClientPacketId.CreateCharacter);

        DataPacket packet = new DataPacket(CreatePacket(createCharacterPacket), null);

        sendMsgs.Enqueue(packet);
    }
Пример #6
0
        /// <summary>
        /// Handles creation of character.
        /// </summary>
        private async void HandleCreateCharacter(CreateCharacterPacket createCharacterPacket)
        {
            using var database = DependencyContainer.Instance.Resolve <IDatabase>();

            // Get number of user characters.
            var characters = database.Characters.Where(x => x.UserId == _client.UserID).ToList();

            if (characters.Count == Constants.MaxCharacters - 1)
            {
                // Max number is reached.
                SendCreatedCharacter(false);
                return;
            }

            byte freeSlot = 0;

            for (byte i = 0; i < Constants.MaxCharacters; i++)
            {
                if (!characters.Any(c => c.Slot == i))
                {
                    freeSlot = i;
                    break;
                }
            }
            DbCharacter character = new DbCharacter()
            {
                Name   = createCharacterPacket.CharacterName,
                Race   = createCharacterPacket.Race,
                Mode   = createCharacterPacket.Mode,
                Hair   = createCharacterPacket.Hair,
                Face   = createCharacterPacket.Face,
                Height = createCharacterPacket.Height,
                Class  = createCharacterPacket.Class,
                Gender = createCharacterPacket.Gender,
                Level  = 1,
                Slot   = freeSlot,
                UserId = _client.UserID
            };

            await database.Characters.AddAsync(character);

            if (await database.SaveChangesAsync() > 0)
            {
                characters.Add(character);
                SendCreatedCharacter(true);
                SendCharacterList(characters);
            }
        }
Пример #7
0
    //캐릭터 생성
    public void CreateCharacter(DataPacket packet)
    {
        Console.WriteLine(packet.client.RemoteEndPoint.ToString() + "캐릭터 생성");

        CreateCharacterPacket createCharacterPacket = new CreateCharacterPacket(packet.msg);
        CreateCharacterData   createCharacterData   = createCharacterPacket.GetData();

        Console.WriteLine("이름 : " + createCharacterData.HName);
        Console.WriteLine("직업 : " + createCharacterData.HClass);
        Console.WriteLine("성별 : " + createCharacterData.Gender);

        string   id       = loginUser[packet.client];
        UserData userData = database.GetUserData(id);

        Result result = Result.Fail;

        try
        {
            userData.CreateHero(createCharacterData);
            database.FileSave(id + ".data", userData);

            result = Result.Success;
        }
        catch
        {
            Console.WriteLine("DataHandler::CreateCharacter.CreateHero 에러");
            result = Result.Fail;
        }

        ResultData   resultData       = new ResultData((byte)result);
        ResultPacket resultDataPacket = new ResultPacket(resultData);

        resultDataPacket.SetPacketId((int)ServerPacketId.CreateCharacterResult);

        byte[] msg = CreatePacket(resultDataPacket);
        packet = new DataPacket(msg, packet.client);

        lock (sendLock)
        {
            sendMsgs.Enqueue(packet);
        }
    }
Пример #8
0
        public static async void OnCreateCharacter(WorldClient client, IPacketStream packet)
        {
            var createCharacterPacket = new CreateCharacterPacket(packet);

            using var database = DependencyContainer.Instance.Resolve <IDatabase>();

            // Get number of user characters.
            var count = (byte)database.Charaters.Count(x => x.UserId == client.UserID);

            if (count == Constants.MaxCharacters - 1)
            {
                // Max number is reached.
                WorldPacketFactory.SendCreatedCharacter(client, false);
            }

            DbCharacter character = new DbCharacter()
            {
                Name   = createCharacterPacket.CharacterName,
                Race   = createCharacterPacket.Race,
                Mode   = createCharacterPacket.Mode,
                Hair   = createCharacterPacket.Hair,
                Face   = createCharacterPacket.Face,
                Height = createCharacterPacket.Height,
                Class  = createCharacterPacket.Class,
                Gender = createCharacterPacket.Gender,
                Level  = 1,
                Slot   = count,
                UserId = client.UserID
            };

            await database.Charaters.CreateAsync(character);

            await database.CompleteAsync();

            WorldPacketFactory.SendCreatedCharacter(client, true);
        }
Пример #9
0
 /// <summary>
 /// Sends a message to the server, requesting creation of a new character.
 /// </summary>
 /// <param name="packet">A completed character creation packet.</param>
 public void CreateCharacter(CreateCharacterPacket packet)
 {
     m_Engine.QueuedModel = new WorldModel();
     m_Network.Send(packet);
 }
Пример #10
0
 public void CreateCharacter(CreateCharacterPacket packet)
 {
     _engine.Models.Next = new WorldModel();
     _network.Send(packet);
 }
Пример #11
0
        /// <summary>
        /// Handles creation of character.
        /// </summary>
        private async void HandleCreateCharacter(CreateCharacterPacket createCharacterPacket)
        {
            // Get number of user characters.
            var characters = _database.Characters.Where(x => x.UserId == _client.UserID).ToList();

            if (characters.Where(c => !c.IsDelete).Count() == MaxCharacterNumber)
            {
                // Max number of characters reached.
                SendCreatedCharacter(false);
                return;
            }

            byte freeSlot = createCharacterPacket.Slot;

            if (characters.Any(c => c.Slot == freeSlot && !c.IsDelete))
            {
                // Wrong slot.
                SendCreatedCharacter(false);
                return;
            }

            var defaultStats = _characterConfiguration.DefaultStats.FirstOrDefault(s => s.Job == createCharacterPacket.Class);

            if (defaultStats is null)
            {
                // Something went very wrong. No default stats for this job.
                SendCreatedCharacter(false);
                return;
            }

            // Validate CharacterName
            if (!createCharacterPacket.CharacterName.IsValidCharacterName())
            {
                SendCreatedCharacter(false);
                return;
            }

            DbCharacter character = new DbCharacter()
            {
                Name         = createCharacterPacket.CharacterName,
                Race         = createCharacterPacket.Race,
                Mode         = createCharacterPacket.Mode,
                Hair         = createCharacterPacket.Hair,
                Face         = createCharacterPacket.Face,
                Height       = createCharacterPacket.Height,
                Class        = createCharacterPacket.Class,
                Gender       = createCharacterPacket.Gender,
                Strength     = defaultStats.Str,
                Dexterity    = defaultStats.Dex,
                Rec          = defaultStats.Rec,
                Intelligence = defaultStats.Int,
                Wisdom       = defaultStats.Wis,
                Luck         = defaultStats.Luc,
                Level        = 1,
                Slot         = freeSlot,
                UserId       = _client.UserID
            };

            await _database.Characters.AddAsync(character);

            if (await _database.SaveChangesAsync() > 0)
            {
                characters.Add(character);
                SendCreatedCharacter(true);
                SendCharacterList(characters);
            }
        }
        public async Task <bool> TryCreateCharacter(int userId, CreateCharacterPacket createCharacterPacket)
        {
            // Get number of user characters.
            var characters = await _database.Characters.Where(x => x.UserId == userId).ToListAsync();

            if (characters.Where(c => !c.IsDelete).Count() == MaxCharacterNumber)
            {
                // Max number of characters reached.
                return(false);
            }

            byte freeSlot = createCharacterPacket.Slot;

            if (characters.Any(c => c.Slot == freeSlot && !c.IsDelete))
            {
                // Wrong slot.
                return(false);
            }

            var defaultStats = _characterConfiguration.DefaultStats.FirstOrDefault(s => s.Job == createCharacterPacket.Class);

            if (defaultStats is null)
            {
                // Something went very wrong. No default stats for this job.
                return(false);
            }

            var user = await _database.Users.FindAsync(userId);

            var createConfig = _characterConfiguration.CreateConfigs.FirstOrDefault(p => p.Country == user.Faction && p.Job == createCharacterPacket.Class);

            if (createConfig is null)
            {
                // Something went very wrong. No default position for this job.
                return(false);
            }

            // Validate CharacterName
            if (!createCharacterPacket.CharacterName.IsValidCharacterName())
            {
                return(false);
            }

            DbCharacter character = new DbCharacter()
            {
                Name          = createCharacterPacket.CharacterName,
                Race          = createCharacterPacket.Race,
                Mode          = createCharacterPacket.Mode,
                Hair          = createCharacterPacket.Hair,
                Face          = createCharacterPacket.Face,
                Height        = createCharacterPacket.Height,
                Class         = createCharacterPacket.Class,
                Gender        = createCharacterPacket.Gender,
                Strength      = defaultStats.Str,
                Dexterity     = defaultStats.Dex,
                Rec           = defaultStats.Rec,
                Intelligence  = defaultStats.Int,
                Wisdom        = defaultStats.Wis,
                Luck          = defaultStats.Luc,
                Level         = 1,
                Slot          = freeSlot,
                UserId        = userId,
                Map           = createConfig.MapId,
                PosX          = createConfig.X,
                PosY          = createConfig.Y,
                PosZ          = createConfig.Z,
                HealthPoints  = 1000,
                ManaPoints    = 1000,
                StaminaPoints = 1000,
            };

            var result = await _database.Characters.AddAsync(character);

            if (await _database.SaveChangesAsync() > 0)
            {
                for (byte i = 0; i < createConfig.StartItems.Length; i++)
                {
                    var itm = createConfig.StartItems[i];
                    await _database.CharacterItems.AddAsync(new DbCharacterItems()
                    {
                        CharacterId = result.Entity.Id,
                        Type        = itm.Type,
                        TypeId      = itm.TypeId,
                        Count       = itm.Count,
                        Quality     = _databasePreloader.Items[(itm.Type, itm.TypeId)].Quality,
Пример #13
0
 /// <summary>
 /// Sends a message to the server, requesting creation of a new character.
 /// </summary>
 /// <param name="packet">A completed character creation packet.</param>
 public void CreateCharacter(CreateCharacterPacket packet)
 {
     Engine.QueuedModel = new WorldModel();
     Send(packet);
 }