public Task SendInfoFromMonster(IPlayerEntity player, ReqInfoEvent e)
        {
            NpcMonsterDto target = _npcMonsterService.GetById(e.TargetId);

            if (target == null)
            {
                return(Task.CompletedTask);
            }

            //todo: use i18n to send the right npc name!
            return(player?.SendPacketAsync(target.GenerateEInfoPacket()));
        }
Beispiel #2
0
        public void Fill(string filePath)
        {
            _npcMonsterService = ChickenContainer.Instance.Resolve <INpcMonsterService>();
            string tmp = File.ReadAllText(filePath, Encoding.GetEncoding(1252));

            string[] lines = tmp.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);

            foreach (string line in lines.Where(s => s.StartsWith("e_info 10")))
            {
                string[] currentPacket = line.Split(new[] { ' ', '\t' }, StringSplitOptions.None);

                if (currentPacket.Length <= 25)
                {
                    continue;
                }

                NpcMonsterDto npcMonster = _npcMonsterService.GetById(short.Parse(currentPacket[2]));
                if (npcMonster == null)
                {
                    continue;
                }

                npcMonster.AttackClass          = byte.Parse(currentPacket[5]);
                npcMonster.AttackUpgrade        = byte.Parse(currentPacket[7]);
                npcMonster.DamageMinimum        = short.Parse(currentPacket[8]);
                npcMonster.DamageMaximum        = short.Parse(currentPacket[9]);
                npcMonster.Concentrate          = short.Parse(currentPacket[10]);
                npcMonster.CriticalChance       = byte.Parse(currentPacket[11]);
                npcMonster.CriticalRate         = short.Parse(currentPacket[12]);
                npcMonster.DefenceUpgrade       = byte.Parse(currentPacket[13]);
                npcMonster.CloseDefence         = short.Parse(currentPacket[14]);
                npcMonster.DefenceDodge         = short.Parse(currentPacket[15]);
                npcMonster.DistanceDefence      = short.Parse(currentPacket[16]);
                npcMonster.DistanceDefenceDodge = short.Parse(currentPacket[17]);
                npcMonster.MagicDefence         = short.Parse(currentPacket[18]);
                npcMonster.FireResistance       = sbyte.Parse(currentPacket[19]);
                npcMonster.WaterResistance      = sbyte.Parse(currentPacket[20]);
                npcMonster.LightResistance      = sbyte.Parse(currentPacket[21]);
                npcMonster.DarkResistance       = sbyte.Parse(currentPacket[22]);
                if (_npcMonsters.Any(s => s.Id == npcMonster.Id))
                {
                    continue;
                }

                _npcMonsters.Add(npcMonster);
            }

            _npcMonsterService.Save(_npcMonsters);
        }
Beispiel #3
0
        protected override async Task Handle(AddPetEvent e, CancellationToken cancellation)
        {
            if (!(e.Sender is IPlayerEntity player))
            {
                return;
            }

            NpcMonsterDto heldMonster = _npcMonsterService.GetById(e.MonsterVnum);

            if (heldMonster == null)
            {
                return;
            }

            var mate = new CharacterMateDto
            {
                NpcMonsterId = (short)e.MonsterVnum,
                CanPickUp    = false,
                CharacterId  = player.Id,
                Attack       = 0,
                Defence      = 0,
                Direction    = 0,
                Experience   = 0,
                Hp           = heldMonster.MaxHp,
                Level        = 1,
                IsSummonable = false,
                IsTeamMember = true,
                Loyalty      = 1000,
                MapX         = player.Position.X,
                MapY         = player.Position.Y,
                Mp           = heldMonster.MaxMp,
                Name         = heldMonster.Name,
                Skin         = 0,
                Agility      = 0,
                MateType     = e.MateType
            };

            IMateEntity mateEn = await _entityFactory.CreateNewMateEntityAsync(player, mate);

            await player.AddPet(mateEn);

            await player.SendPacketAsync(player.GenerateInfoBubble("PET_LEAVE_BEAD"));
        }
        protected override async Task Handle(GameStartPacketBase packet, ISession session)
        {
            if (session.Player != null)
            {
                return;
            }

            CharacterDto dto = await _characterService.GetByIdAsync(session.CharacterId);

            IEnumerable <CharacterSkillDto> skills = await _characterSkillService.GetByCharacterIdAsync(session.CharacterId);

            IEnumerable <CharacterQuicklistDto> quicklist = await _characterQuicklistService.GetByCharacterIdAsync(session.CharacterId);

            IEnumerable <CharacterMateDto> mates = await _characterMateService.GetMatesByCharacterIdAsync(session.CharacterId);

            IMapLayer mapLayer = _mapManager.GetBaseMapLayer(dto.MapId);

            session.InitializeEntity(new PlayerEntity(session, dto, skills, quicklist));

            // Register Player
            _playerManager.RegisterPlayer(session.Player);

            // load inventory
            await session.Player.EmitEventAsync(new InventoryLoadEvent());

            // motd
            await session.Player.SendChatMessageAsync("┌------------------[NosWings]------------------┐", SayColorType.Yellow);

            await session.Player.SendChatMessageAsync($"XP     : {dto.LevelXp}/{_algorithmService.GetLevelXp(dto.Class, dto.Level)}", SayColorType.Yellow);

            await session.Player.SendChatMessageAsync($"JOBXP  : {dto.JobLevelXp}/{_algorithmService.GetJobLevelXp(dto.Class, dto.Level)}", SayColorType.Yellow);

            await session.Player.SendChatMessageAsync($"HEROXP : {dto.HeroXp}/{_algorithmService.GetHeroLevelXp(dto.Class, dto.Level)}", SayColorType.Yellow);

            await session.Player.SendChatMessageAsync("└----------------------------------------------┘", SayColorType.Yellow);

            await session.SendPacketAsync(new TitPacket { ClassType = "Adventurer", Name = dto.Name });

            await session.SendPacketAsync(new MapoutPacket());

            session.Player.Character.SpPoint         = 10000;
            session.Player.Character.SpAdditionPoint = 500000;

            // transfer to map
            session.Player.TransferEntity(mapLayer);

            await session.Player.ActualizeUiSkillList();

            await session.Player.ActualizeUiReputation();

            await session.SendPacketAsync(new RagePacket { RagePoints = 0, RagePointsMax = 250000 });

            // rank_cool
            // pet basket ? ib 1278 1
            // cleftOfDarkness ? bc 0 0 0
            await session.Player.ActualiseUiSpPoints();

            // scr 0
            for (byte i = 0; i < 10; i++)
            {
                await session.Player.SendPacketAsync(new BnPacket { BnNumber = i, Message = $"SaltyEmu^{i}" });
            }

            // exts
            // MlInfo
            await session.SendPacketAsync(new PClearPacket());

            await session.Player.ActualizeGroupList();

            await session.Player.ActualizeUiGroupIcons();

            await session.SendPacketAsync(new ZzimPacket());

            // twk 2
            await session.SendPacketAsync(new Act6Packet());

            await session.SendPacketAsync(session.Player.GenerateFsPacket());

            // scP
            // scN

            await session.Player.EmitEventAsync(new InventoryRequestDetailsEvent());

            await session.Player.ActualizePlayerCondition();

            await session.Player.ActualizeUiGold();

            await session.Player.ActualizeUiQuicklist();

            await session.Player.ActualizeUiFriendList();

            await session.Player.ActualizeUiBlackList();

            await session.Player.ActualizeUiWearPanel();

            // Blinit
            // clinit
            // flinit
            // kdlinit

            await session.Player.ActualizeUiStatChar();

            await session.SendPacketAsync(session.Player.GeneratePairyPacket());

            await session.SendPacketAsync(session.Player.GenerateGInfoPacket());

            await session.Player.BroadcastAsync(session.Player.GenerateGidxPacket());

            // Session.SendPackets(Session.Character.GetFamilyHistory());
            // await session.SendPacketAsync(Session.Character.GenerateFamilyMember());
            // await session.SendPacketAsync(Session.Character.GenerateFamilyMemberMessage());
            // await session.SendPacketAsync(Session.Character.GenerateFamilyMemberExp());

            // mails
            // quests

            foreach (CharacterMateDto s in mates)
            {
                var mate = new MateEntity(session.Player, s, _npcMonsterService.GetById(s.NpcMonsterId));
                session.Player.Mates.Add(mate);
            }
        }