/// <summary>
/// select packet
/// </summary>
/// <param name="selectPacket"></param>
public void SelectCharacter(SelectPacket selectPacket)
{
try
{
if (Session?.Account == null || Session.HasSelectedCharacter)
{
return;
}
CharacterDTO characterDto =
DAOFactory.CharacterDAO.FirstOrDefault(s => s.AccountId == Session.Account.AccountId && s.Slot == selectPacket.Slot && s.State == (byte)CharacterState.Active);
if (characterDto == null)
{
return;
}
if (!(characterDto is Character character))
{
return;
}
character.GeneralLogs = DAOFactory.GeneralLogDAO.Where(s => s.AccountId == Session.Account.AccountId && s.CharacterId == character.CharacterId).ToList();
character.MapInstanceId = ServerManager.Instance.GetBaseMapInstanceIdByMapId(character.MapId);
character.PositionX = character.MapX;
character.PositionY = character.MapY;
character.Authority = Session.Account.Authority;
Session.SetCharacter(character);
if (!Session.Character.GeneralLogs.Any(s => s.Timestamp == DateTime.Now && s.LogData == "World" && s.LogType == "Connection"))
{
Session.Character.SpAdditionPoint += Session.Character.SpPoint;
Session.Character.SpPoint = 10000;
}
if (Session.Character.Hp > Session.Character.HPLoad())
{
Session.Character.Hp = (int)Session.Character.HPLoad();
}
if (Session.Character.Mp > Session.Character.MPLoad())
{
Session.Character.Mp = (int)Session.Character.MPLoad();
}
Session.Character.Respawns = DAOFactory.RespawnDAO.Where(s => s.CharacterId == Session.Character.CharacterId).ToList();
Session.Character.StaticBonusList = DAOFactory.StaticBonusDAO.Where(s => s.CharacterId == Session.Character.CharacterId).ToList();
Session.Character.LoadInventory();
Session.Character.LoadQuicklists();
Session.Character.GenerateMiniland();
DAOFactory.MateDAO.Where(s => s.CharacterId == Session.Character.CharacterId).ToList().ForEach(s =>
{
Mate mate = (Mate)s;
mate.Owner = Session.Character;
mate.GeneateMateTransportId();
mate.Monster = ServerManager.Instance.GetNpc(s.NpcMonsterVNum);
Session.Character.Mates.Add(mate);
});
Session.Character.Life = Observable.Interval(TimeSpan.FromMilliseconds(300)).Subscribe(x =>
{
Session.Character.CharacterLife();
});
Session.Character.GeneralLogs.Add(new GeneralLogDTO {
AccountId = Session.Account.AccountId, CharacterId = Session.Character.CharacterId, IpAddress = Session.IpAddress, LogData = "World", LogType = "Connection", Timestamp = DateTime.Now
});
Session.SendPacket("OK");
// Inform everyone about connected character
CommunicationServiceClient.Instance.ConnectCharacter(ServerManager.Instance.WorldId, character.CharacterId);
}
catch (Exception ex)
{
Logger.Log.Error("Select character failed.", ex);
}
}
public override void Use(ClientSession session, ref ItemInstance inv, byte option = 0, string[] packetsplit = null)
{
switch (Effect)
{
default:
bool delay = false;
if (option == 255)
{
delay = true;
option = 0;
}
Mate mate = null;
if (option != 0)
{
mate = session.Character.Mates.FirstOrDefault(s => s.MateType == MateType.Partner && s.PetId == (option - 1));
}
short slot = inv.Slot;
InventoryType equipment = InventoryType.Wear;
switch (option)
{
case 1:
equipment = InventoryType.FirstPartnerInventory;
break;
case 2:
equipment = InventoryType.SecondPartnerInventory;
break;
case 3:
equipment = InventoryType.ThirdPartnerInventory;
break;
}
InventoryType itemToWearType = inv.Type;
if (inv == null)
{
return;
}
if (ItemValidTime > 0 && !inv.IsBound)
{
inv.ItemDeleteTime = DateTime.Now.AddSeconds(ItemValidTime);
}
if (!inv.IsBound)
{
switch (inv.Item.Effect)
{
case 790: // Tarot
case 932: // Attack amulet
case 933: // defense amulet
inv.BoundCharacterId = session.Character.CharacterId;
break;
}
if (!delay && (EquipmentSlot == EquipmentType.Fairy && (MaxElementRate == 70 || MaxElementRate == 80) || EquipmentSlot == EquipmentType.CostumeHat || EquipmentSlot == EquipmentType.CostumeSuit || EquipmentSlot == EquipmentType.WeaponSkin))
{
session.SendPacket($"qna #u_i^1^{session.Character.CharacterId}^{(byte)itemToWearType}^{slot}^1 {Language.Instance.GetMessageFromKey("ASK_BIND")}");
return;
}
if (delay)
{
inv.BoundCharacterId = session.Character.CharacterId;
}
}
double timeSpanSinceLastSpUsage = (DateTime.Now - Process.GetCurrentProcess().StartTime.AddSeconds(-50)).TotalSeconds - session.Character.LastSp;
if (EquipmentSlot == EquipmentType.Sp && inv.Rare == -2)
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("CANT_EQUIP_DESTROYED_SP"), 0));
return;
}
if (option == 0)
{
if (EquipmentSlot == EquipmentType.Sp && timeSpanSinceLastSpUsage <= session.Character.SpCooldown && session.Character.Inventory.LoadBySlotAndType <SpecialistInstance>((byte)EquipmentType.Sp, InventoryType.Specialist) != null)
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(string.Format(Language.Instance.GetMessageFromKey("SP_INLOADING"), session.Character.SpCooldown - (int)Math.Round(timeSpanSinceLastSpUsage)), 0));
return;
}
if (ItemType != ItemType.Weapon && ItemType != ItemType.Armor && ItemType != ItemType.Fashion && ItemType != ItemType.Jewelery && ItemType != ItemType.Specialist ||
LevelMinimum > (IsHeroic ? session.Character.HeroLevel : session.Character.Level) || Sex != 0 && Sex != (byte)session.Character.Gender + 1 ||
ItemType != ItemType.Jewelery && EquipmentSlot != EquipmentType.Boots && EquipmentSlot != EquipmentType.Gloves && (Class >> (byte)session.Character.Class & 1) != 1)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("BAD_EQUIPMENT"), 10));
return;
}
if (session.Character.UseSp)
{
SpecialistInstance sp = session.Character.Inventory.LoadBySlotAndType <SpecialistInstance>((byte)EquipmentType.Sp, equipment);
if (sp != null && sp.Item.Element != 0 && EquipmentSlot == EquipmentType.Fairy && Element != sp.Item.Element && Element != sp.Item.SecondaryElement)
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("BAD_FAIRY"), 0));
return;
}
}
if (ItemType == ItemType.Weapon || ItemType == ItemType.Armor)
{
if (inv.BoundCharacterId.HasValue && inv.BoundCharacterId.Value != session.Character.CharacterId)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("BAD_EQUIPMENT"), 10));
return;
}
}
if (session.Character.UseSp && EquipmentSlot == EquipmentType.Sp)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SP_BLOCKED"), 10));
return;
}
if (session.Character.JobLevel < LevelJobMinimum)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("LOW_JOB_LVL"), 10));
return;
}
}
else if (mate != null)
{
if (mate.Level < LevelMinimum)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("BAD_EQUIPMENT"), 10));
return;
}
switch (EquipmentSlot)
{
case EquipmentType.Armor:
if (ItemSubType == 4)
{
mate.ArmorInstance = inv;
break;
}
else
{
goto default;
}
case EquipmentType.MainWeapon:
if (ItemSubType == 12)
{
mate.WeaponInstance = inv;
break;
}
else
{
goto default;
}
case EquipmentType.Gloves:
mate.GlovesInstance = inv;
break;
case EquipmentType.Boots:
mate.BootsInstance = inv;
break;
case EquipmentType.Sp:
if (ItemSubType == 4)
{
mate.SpInstance = inv;
break;
}
else
{
goto default;
}
default:
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("BAD_EQUIPMENT"), 10));
return;
}
}
ItemInstance currentlyEquippedItem = session.Character.Inventory.LoadBySlotAndType((short)EquipmentSlot, equipment);
if (currentlyEquippedItem == null)
{
// move from equipment to wear
session.Character.Inventory.MoveInInventory(inv.Slot, itemToWearType, equipment);
session.SendPacket(UserInterfaceHelper.Instance.GenerateInventoryRemove(itemToWearType, slot));
}
else
{
// move from wear to equipment and back
session.Character.Inventory.MoveInInventory(currentlyEquippedItem.Slot, equipment, itemToWearType, inv.Slot);
session.SendPacket(currentlyEquippedItem.GenerateInventoryAdd());
session.Character.BattleEntity.StaticBcards.RemoveWhere(o => o.ItemVNum != currentlyEquippedItem.ItemVNum, out ConcurrentBag <BCard> eqBcards);
session.Character.BattleEntity.StaticBcards = eqBcards;
}
inv.Item.BCards.ForEach(s => session.Character.BattleEntity.StaticBcards.Add(s));
if (inv is WearableInstance wearableInstance)
{
SpecialistInstance specialistInstance = session.Character.Inventory.LoadBySlotAndType <SpecialistInstance>((byte)EquipmentType.Sp, InventoryType.Wear);
if (wearableInstance.EquipmentOptions != null)
{
switch (wearableInstance.Item.ItemType)
{
case ItemType.Armor:
case ItemType.Weapon:
case ItemType.Jewelery:
switch (wearableInstance.Slot)
{
case (byte)EquipmentType.Armor:
session.Character.Inventory.Armor = wearableInstance;
EquipmentOptionHelper.Instance.ShellToBCards(wearableInstance.EquipmentOptions, wearableInstance.ItemVNum)
.ForEach(s => session.Character.BattleEntity.StaticBcards.Add(s));
break;
case (byte)EquipmentType.MainWeapon:
session.Character.Inventory.PrimaryWeapon = wearableInstance;
EquipmentOptionHelper.Instance.ShellToBCards(wearableInstance.EquipmentOptions, wearableInstance.ItemVNum)
.ForEach(s => session.Character.BattleEntity.StaticBcards.Add(s));
specialistInstance?.RestorePoints(session, specialistInstance);
break;
case (byte)EquipmentType.SecondaryWeapon:
session.Character.Inventory.SecondaryWeapon = wearableInstance;
EquipmentOptionHelper.Instance.ShellToBCards(wearableInstance.EquipmentOptions, wearableInstance.ItemVNum)
.ForEach(s => session.Character.BattleEntity.StaticBcards.Add(s));
specialistInstance?.RestorePoints(session, specialistInstance);
break;
case (byte)EquipmentType.Ring:
case (byte)EquipmentType.Necklace:
case (byte)EquipmentType.Bracelet:
EquipmentOptionHelper.Instance.CellonToBCards(wearableInstance.EquipmentOptions, wearableInstance.ItemVNum)
.ForEach(s => session.Character.BattleEntity.StaticBcards.Add(s));
break;
}
break;
}
}
}
if (option == 0)
{
session.SendPacket(session.Character.GenerateStatChar());
session.CurrentMapInstance?.Broadcast(session.Character.GenerateEq());
session.SendPacket(session.Character.GenerateEquipment());
session.CurrentMapInstance?.Broadcast(session.Character.GeneratePairy());
switch (EquipmentSlot)
{
case EquipmentType.Fairy:
WearableInstance fairy = session.Character.Inventory.LoadBySlotAndType <WearableInstance>((byte)EquipmentType.Fairy, equipment);
session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("FAIRYSTATS"), fairy.XP, CharacterHelper.LoadFairyXpData(fairy.ElementRate + fairy.Item.ElementRate)), 10));
break;
case EquipmentType.Amulet:
session.SendPacket(session.Character.GenerateEff(39));
break;
}
}
else if (mate != null)
{
session.SendPacket(mate.GenerateScPacket());
}
break;
}
}
public static void NRun(ClientSession session, NRunPacket packet)
{
if (!session.HasCurrentMapInstance)
{
return;
}
MapNpc npc = session.CurrentMapInstance.Npcs.FirstOrDefault(s => s.MapNpcId == packet.NpcId);
TeleporterDTO tp;
Random rand = new Random();
switch (packet.Runner)
{
case 1:
if (session.Character.Class != (byte)ClassType.Adventurer)
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("NOT_ADVENTURER"), 0));
return;
}
if (session.Character.Level < 15 || session.Character.JobLevel < 20)
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("TOO_LOW_LVL"), 0));
return;
}
if (packet.Type == (byte)session.Character.Class)
{
return;
}
if (session.Character.Inventory.All(i => i.Value.Type != InventoryType.Wear))
{
session.Character.Inventory.AddNewToInventory((short)(4 + packet.Type * 14), type: InventoryType.Wear);
session.Character.Inventory.AddNewToInventory((short)(81 + packet.Type * 13), type: InventoryType.Wear);
switch (packet.Type)
{
case 1:
session.Character.Inventory.AddNewToInventory(68, type: InventoryType.Wear);
session.Character.Inventory.AddNewToInventory(2082, 10);
break;
case 2:
session.Character.Inventory.AddNewToInventory(78, type: InventoryType.Wear);
session.Character.Inventory.AddNewToInventory(2083, 10);
break;
case 3:
session.Character.Inventory.AddNewToInventory(86, type: InventoryType.Wear);
break;
}
foreach (var item in session.Character.Inventory.Values.Where(i => i.Type == InventoryType.Wear && i.Item.EquipmentSlot != EquipmentType.Sp))
{
switch (item.Slot)
{
case (byte)EquipmentType.MainWeapon:
session.Character.Inventory.PrimaryWeapon = (WearableInstance)item;
break;
case (byte)EquipmentType.SecondaryWeapon:
session.Character.Inventory.SecondaryWeapon = (WearableInstance)item;
break;
case (byte)EquipmentType.Armor:
session.Character.Inventory.Armor = (WearableInstance)item;
break;
}
}
session.CurrentMapInstance?.Broadcast(session.Character.GenerateEq());
session.SendPacket(session.Character.GenerateEquipment());
session.Character.ChangeClass((ClassType)packet.Type);
}
else
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("EQ_NOT_EMPTY"), 0));
}
break;
case 2:
session.SendPacket("wopen 1 0");
break;
case 4:
Mate mate = session.Character.Mates.FirstOrDefault(s => s.MateTransportId == packet.NpcId);
switch (packet.Type)
{
case 2:
if (mate != null)
{
if (session.Character.Level >= mate.Level)
{
Mate teammate = session.Character.Mates.Where(s => s.IsTeamMember).FirstOrDefault(s => s.MateType == mate.MateType);
if (teammate != null)
{
teammate.RemoveTeamMember();
}
mate.AddTeamMember();
}
else
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("PET_HIGHER_LEVEL"), 0));
}
}
break;
case 3:
if (mate != null && session.Character.Miniland == session.Character.MapInstance)
{
mate.RemoveTeamMember();
}
break;
case 4:
if (mate != null)
{
if (session.Character.Miniland == session.Character.MapInstance)
{
mate.RemoveTeamMember();
}
else
{
session.SendPacket($"qna #n_run^4^5^3^{mate.MateTransportId} {Language.Instance.GetMessageFromKey("ASK_KICK_PET")}");
}
break;
}
break;
case 5:
if (mate != null)
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateDelay(3000, 10, $"#n_run^4^6^3^{mate.MateTransportId}"));
}
break;
case 6:
if (mate != null)
{
if (session.Character.Miniland != session.Character.MapInstance)
{
mate.RemoveTeamMember();
session.CurrentMapInstance.Broadcast(mate.GenerateOut());
session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("PET_KICKED"), mate.Name), 11));
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(string.Format(Language.Instance.GetMessageFromKey("PET_KICKED"), mate.Name), 0));
}
}
break;
case 7:
if (mate != null)
{
if (session.Character.Mates.Any(s => s.MateType == mate.MateType && s.IsTeamMember))
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("ALREADY_PET_IN_TEAM"), 11));
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("ALREADY_PET_IN_TEAM"), 0));
}
else
{
MateHelper.Instance.RemovePetBuffs(session);
session.SendPacket(UserInterfaceHelper.Instance.GenerateDelay(3000, 10, $"#n_run^4^9^3^{mate.MateTransportId}"));
}
}
break;
case 9:
if (mate != null)
{
if (session.Character.Level >= mate.Level)
{
mate.PositionX = (short)(session.Character.PositionX + 1);
}
mate.PositionY = (short)(session.Character.PositionY + 1);
mate.AddTeamMember();
session.CurrentMapInstance.Broadcast(mate.GenerateIn());
}
else
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("PET_HIGHER_LEVEL"), 0));
}
break;
}
session.SendPacket(session.Character.GeneratePinit());
session.SendPackets(session.Character.Mates.Where(s => s.IsTeamMember)
.OrderBy(s => s.MateType)
.Select(s => s.GeneratePst()));
break;
case 10:
session.SendPacket("wopen 3 0");
break;
case 12:
session.SendPacket($"wopen {packet.Type} 0");
break;
case 14:
session.SendPacket("wopen 27 0");
string recipelist = "m_list 2";
if (npc != null)
{
List <Recipe> tps = npc.Recipes;
recipelist = tps.Where(s => s.Amount > 0).Aggregate(recipelist, (current, s) => current + $" {s.ItemVNum}");
recipelist += " -100";
session.SendPacket(recipelist);
}
break;
case 15:
if (npc != null)
{
if (packet.Value == 2)
{
session.SendPacket($"qna #n_run^15^1^1^{npc.MapNpcId} {Language.Instance.GetMessageFromKey("ASK_CHANGE_SPAWNLOCATION")}");
}
else
{
switch (npc.MapId)
{
case 1:
session.Character.SetRespawnPoint(1, 79, 116);
break;
case 20:
session.Character.SetRespawnPoint(20, 9, 92);
break;
case 145:
session.Character.SetRespawnPoint(145, 13, 110);
break;
case (short)SpecialMapIdType.Lobby:
session.Character.SetRespawnPoint((short)SpecialMapIdType.Lobby, 145, 91);
break;
}
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("RESPAWNLOCATION_CHANGED"), 0));
}
}
break;
case 16:
tp = npc?.Teleporters?.FirstOrDefault(s => s.Index == packet.Type);
if (tp != null)
{
if (session.Character.Gold >= 1000 * packet.Type)
{
session.Character.Gold -= 1000 * packet.Type;
session.SendPacket(session.Character.GenerateGold());
ServerManager.Instance.ChangeMap(session.Character.CharacterId, tp.MapId, tp.MapX, tp.MapY);
}
else
{
session.SendPacket(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("NOT_ENOUGH_MONEY"),
10));
}
}
break;
case 17:
double currentRunningSeconds = (DateTime.Now - Process.GetCurrentProcess().StartTime.AddSeconds(-50)).TotalSeconds;
double timeSpanSinceLastPortal = currentRunningSeconds - session.Character.LastPortal;
if (!(timeSpanSinceLastPortal >= 4) || !session.HasCurrentMapInstance || session.CurrentMapInstance.MapInstanceType == MapInstanceType.Act4Instance)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("CANT_MOVE"), 10));
return;
}
if (session.CurrentMapInstance.MapInstanceType == MapInstanceType.RaidInstance)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("CANT_JOIN_ARENA_IN_RAID"), 10));
return;
}
if (session.Character.Gold >= 500 * (1 + packet.Type))
{
session.Character.LastPortal = currentRunningSeconds;
session.Character.Gold -= 500 * (1 + packet.Type);
session.SendPacket(session.Character.GenerateGold());
ServerManager.Instance.TeleportOnRandomPlaceInMap(session,
packet.Type == 0 ? ServerManager.Instance.ArenaInstance.MapInstanceId : ServerManager.Instance.FamilyArenaInstance.MapInstanceId);
}
else
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("NOT_ENOUGH_MONEY"), 10));
}
break;
case 18:
session.SendPacket(session.Character.GenerateNpcDialog(17));
break;
case 26:
tp = npc?.Teleporters?.FirstOrDefault(s => s.Index == packet.Type);
if (tp != null)
{
if (session.Character.Gold >= 5000 * packet.Type)
{
session.Character.Gold -= 5000 * packet.Type;
ServerManager.Instance.ChangeMap(session.Character.CharacterId, tp.MapId, tp.MapX, tp.MapY);
}
else
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("NOT_ENOUGH_MONEY"), 10));
}
}
break;
case 45:
tp = npc?.Teleporters?.FirstOrDefault(s => s.Index == packet.Type);
if (tp != null)
{
if (session.Character.Gold >= 500)
{
session.Character.Gold -= 500;
session.SendPacket(session.Character.GenerateGold());
ServerManager.Instance.ChangeMap(session.Character.CharacterId, tp.MapId, tp.MapX, tp.MapY);
}
else
{
session.SendPacket(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("NOT_ENOUGH_MONEY"),
10));
}
}
break;
case 61:
if (session.Character.Inventory.CountItem(5917) <= 0 ||
session.Character.Inventory.CountItem(5918) <= 0 || npc == null)
{
return;
}
session.Character.GiftAdd(5922, 1);
session.Character.Inventory.RemoveItemAmount(5917);
session.Character.Inventory.RemoveItemAmount(5918);
break;
case 62:
if (npc == null || session.Character.Inventory.CountItem(5919) <= 0)
{
return;
}
ServerManager.Instance.ChangeMap(session.Character.CharacterId, 2536, 26, 31);
session.Character.Inventory.RemoveItemAmount(5919);
break;
case 65:
if (npc == null)
{
return;
}
session.Character.AddQuest(5514);
break;
case 66:
if (npc == null)
{
return;
}
session.Character.AddQuest(5914);
break;
case 67:
if (npc == null)
{
return;
}
session.Character.AddQuest(5908);
break;
case 68:
if (npc == null)
{
return;
}
session.Character.AddQuest(5919);
break;
case 132:
tp = npc?.Teleporters?.FirstOrDefault(s => s.Index == packet.Type);
if (tp != null)
{
ServerManager.Instance.ChangeMap(session.Character.CharacterId, tp.MapId, tp.MapX, tp.MapY);
}
break;
case 137:
session.SendPacket("taw_open");
break;
case 138:
ConcurrentBag <ArenaTeamMember> at = ServerManager.Instance.ArenaTeams.OrderBy(s => rand.Next()).FirstOrDefault();
if (at != null)
{
ServerManager.Instance.ChangeMapInstance(session.Character.CharacterId, at.FirstOrDefault(s => s.Session != null).Session.CurrentMapInstance.MapInstanceId, 69, 100);
ArenaTeamMember zenas = at.OrderBy(s => s.Order).FirstOrDefault(s => s.Session != null && !s.Dead && s.ArenaTeamType == ArenaTeamType.ZENAS);
ArenaTeamMember erenia = at.OrderBy(s => s.Order).FirstOrDefault(s => s.Session != null && !s.Dead && s.ArenaTeamType == ArenaTeamType.ERENIA);
session.SendPacket(erenia.Session.Character.GenerateTaM(0));
session.SendPacket(erenia.Session.Character.GenerateTaM(3));
session.SendPacket("taw_sv 0");
session.SendPacket(zenas.Session.Character.GenerateTaP(0, true));
session.SendPacket(erenia.Session.Character.GenerateTaP(2, true));
session.SendPacket(zenas.Session.Character.GenerateTaFc(0));
session.SendPacket(erenia.Session.Character.GenerateTaFc(1));
}
else
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateInfo(Language.Instance.GetMessageFromKey("NO_TALENT_ARENA")));
}
break;
case 135:
if (!ServerManager.Instance.StartedEvents.Contains(EventType.TALENTARENA))
{
session.SendPacket(npc?.GenerateSay(Language.Instance.GetMessageFromKey("ARENA_NOT_OPEN"), 10));
}
else
{
int tickets = 5 - session.Character.GeneralLogs.Count(s => s.LogType == "TalentArena" && s.Timestamp.Date == DateTime.Today);
if (ServerManager.Instance.ArenaMembers.All(s => s.Session != session) && tickets > 0)
{
if (ServerManager.Instance.IsCharacterMemberOfGroup(session.Character.CharacterId))
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("TALENT_ARENA_GROUP"), 0));
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("TALENT_ARENA_GROUP"), 10));
}
else
{
session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("ARENA_TICKET_LEFT"), tickets), 10));
ServerManager.Instance.ArenaMembers.Add(new ArenaMember
{
ArenaType = EventType.TALENTARENA,
Session = session,
GroupId = null,
Time = 0
});
}
}
else
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("TALENT_ARENA_NO_MORE_TICKET"), 0));
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("TALENT_ARENA_NO_MORE_TICKET"), 10));
}
}
break;
case 150:
if (session.Character?.Family == null || npc == null)
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("NEED_FAMILY"), 0));
break;
}
if (session.Character?.Family?.LandOfDeath == null)
{
session.Character.Family.LandOfDeath =
ServerManager.Instance.GenerateMapInstance(150, MapInstanceType.LodInstance,
new InstanceBag());
}
if (session.Character?.Family?.LandOfDeath != null)
{
ServerManager.Instance.ChangeMapInstance(session.Character.CharacterId, session.Character.Family.LandOfDeath.MapInstanceId, 153, 145);
}
break;
case 300:
if (npc == null)
{
return;
}
session.Character.AddQuest(6040);
break;
case 301:
tp = npc?.Teleporters?.FirstOrDefault(s => s.Index == packet.Type);
if (tp != null)
{
ServerManager.Instance.ChangeMap(session.Character.CharacterId, tp.MapId, tp.MapX, tp.MapY);
}
break;
case 1600:
session.SendPacket(session.Character.OpenFamilyWarehouse());
break;
case 1601:
session.SendPackets(session.Character.OpenFamilyWarehouseHist());
break;
case 1602:
if (session.Character.Family != null && session.Character.Family.FamilyLevel >= 3 && session.Character.Family.WarehouseSize < 21)
{
if (session.Character.FamilyCharacter.Authority == FamilyAuthority.Head)
{
if (500000 >= session.Character.Gold)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("NOT_ENOUGH_MONEY"), 10));
return;
}
session.Character.Family.WarehouseSize = 21;
session.Character.Gold -= 500000;
session.SendPacket(session.Character.GenerateGold());
FamilyDTO fam = session.Character.Family;
DaoFactory.FamilyDao.InsertOrUpdate(ref fam);
ServerManager.Instance.FamilyRefresh(session.Character.Family.FamilyId);
}
else
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("ONLY_HEAD_CAN_BUY"), 10));
session.SendPacket(UserInterfaceHelper.Instance.GenerateModal(Language.Instance.GetMessageFromKey("ONLY_HEAD_CAN_BUY"), 1));
}
}
break;
case 1603:
if (session.Character.Family != null && session.Character.Family.FamilyLevel >= 7 && session.Character.Family.WarehouseSize < 49)
{
if (session.Character.FamilyCharacter.Authority == FamilyAuthority.Head)
{
if (2000000 >= session.Character.Gold)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("NOT_ENOUGH_MONEY"), 10));
return;
}
session.Character.Family.WarehouseSize = 49;
session.Character.Gold -= 2000000;
session.SendPacket(session.Character.GenerateGold());
FamilyDTO fam = session.Character.Family;
DaoFactory.FamilyDao.InsertOrUpdate(ref fam);
ServerManager.Instance.FamilyRefresh(session.Character.Family.FamilyId);
}
else
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("ONLY_HEAD_CAN_BUY"), 10));
session.SendPacket(UserInterfaceHelper.Instance.GenerateModal(Language.Instance.GetMessageFromKey("ONLY_HEAD_CAN_BUY"), 1));
}
}
break;
case 1604:
if (session.Character.Family != null && session.Character.Family.FamilyLevel >= 5 && session.Character.Family.MaxSize < 70)
{
if (session.Character.FamilyCharacter.Authority == FamilyAuthority.Head)
{
if (5000000 >= session.Character.Gold)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("NOT_ENOUGH_MONEY"), 10));
return;
}
session.Character.Family.MaxSize = 70;
session.Character.Gold -= 5000000;
session.SendPacket(session.Character.GenerateGold());
FamilyDTO fam = session.Character.Family;
DaoFactory.FamilyDao.InsertOrUpdate(ref fam);
ServerManager.Instance.FamilyRefresh(session.Character.Family.FamilyId);
}
else
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("ONLY_HEAD_CAN_BUY"), 10));
session.SendPacket(UserInterfaceHelper.Instance.GenerateModal(Language.Instance.GetMessageFromKey("ONLY_HEAD_CAN_BUY"), 1));
}
}
break;
case 1605:
if (session.Character.Family != null && session.Character.Family.FamilyLevel >= 9 && session.Character.Family.MaxSize < 100)
{
if (session.Character.FamilyCharacter.Authority == FamilyAuthority.Head)
{
if (10000000 >= session.Character.Gold)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("NOT_ENOUGH_MONEY"), 10));
return;
}
session.Character.Family.MaxSize = 100;
session.Character.Gold -= 10000000;
session.SendPacket(session.Character.GenerateGold());
FamilyDTO fam = session.Character.Family;
DaoFactory.FamilyDao.InsertOrUpdate(ref fam);
ServerManager.Instance.FamilyRefresh(session.Character.Family.FamilyId);
}
else
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("ONLY_HEAD_CAN_BUY"), 10));
session.SendPacket(UserInterfaceHelper.Instance.GenerateModal(Language.Instance.GetMessageFromKey("ONLY_HEAD_CAN_BUY"), 1));
}
}
break;
case 23:
if (packet.Type == 0)
{
if (session.Character.Group != null && session.Character.Group.CharacterCount == 3)
{
if (session.Character.Group.Characters.Any(s => s.Character.Family != null))
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateInfo(Language.Instance.GetMessageFromKey("GROUP_MEMBER_ALREADY_IN_FAMILY")));
return;
}
}
if (session.Character.Group == null || session.Character.Group.CharacterCount != 3)
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateInfo(Language.Instance.GetMessageFromKey("FAMILY_GROUP_NOT_FULL")));
return;
}
session.SendPacket(UserInterfaceHelper.Instance.GenerateInbox($"#glmk^ {14} 1 {Language.Instance.GetMessageFromKey("CREATE_FAMILY").Replace(' ', '^')}"));
}
else
{
if (session.Character.Family == null)
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateInfo(Language.Instance.GetMessageFromKey("NOT_IN_FAMILY")));
return;
}
if (session.Character.Family != null && session.Character.FamilyCharacter != null && session.Character.FamilyCharacter.Authority != FamilyAuthority.Head)
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateInfo(Language.Instance.GetMessageFromKey("NOT_FAMILY_HEAD")));
return;
}
session.SendPacket($"qna #glrm^1 {Language.Instance.GetMessageFromKey("DISMISS_FAMILY")}");
}
break;
case 60:
StaticBonusDTO medal = session.Character.StaticBonusList.FirstOrDefault(s => s.StaticBonusType == StaticBonusType.BazaarMedalGold || s.StaticBonusType == StaticBonusType.BazaarMedalSilver);
byte Medal = 0;
int Time = 0;
if (medal != null)
{
Medal = medal.StaticBonusType == StaticBonusType.BazaarMedalGold ? (byte)MedalType.Gold : (byte)MedalType.Silver;
Time = (int)(medal.DateEnd - DateTime.Now).TotalHours;
}
session.SendPacket($"wopen 32 {Medal} {Time}");
break;
case 3000:
if (npc != null)
{
}
break;
case 3006:
if (npc != null)
{
session.Character.AddQuest(packet.Type);
}
break;
case 5001:
if (npc != null)
{
switch (session.Character.Faction)
{
case FactionType.Neutral:
session.SendPacket(UserInterfaceHelper.Instance.GenerateInfo("NEED_FACTION_ACT4"));
return;
}
if (3000 > session.Character.Gold)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("NOT_ENOUGH_MONEY"), 10));
return;
}
session.Character.Gold -= 3000;
session.Character.ConnectAct4();
}
break;
case 5002:
if (npc != null)
{
tp = npc.Teleporters?.FirstOrDefault(s => s.Index == packet.Type);
if (tp != null)
{
session.SendPacket("it 3");
SerializableWorldServer connection = CommunicationServiceClient.Instance.GetPreviousChannelByAccountId(session.Account.AccountId);
if (connection == null || session.Character == null)
{
break;
}
session.Character.MapId = tp.MapId;
session.Character.MapX = tp.MapX;
session.Character.MapY = tp.MapY;
session.Character.ChangeChannel(connection.EndPointIp, connection.EndPointPort, 3);
}
}
break;
case 5011:
if (npc != null)
{
ServerManager.Instance.ChangeMap(session.Character.CharacterId, 170, 127, 46);
}
break;
case 5012:
tp = npc?.Teleporters?.FirstOrDefault(s => s.Index == packet.Type);
if (tp != null)
{
ServerManager.Instance.ChangeMap(session.Character.CharacterId, tp.MapId, tp.MapX, tp.MapY);
}
break;
default:
Logger.Log.Warn(string.Format(Language.Instance.GetMessageFromKey("NO_NRUN_HANDLER"), packet.Runner));
break;
}
}
public void CanGetMessagesTest()
{
IEmployerDAO <Employer> employerDAO = new EmployerDAO(_connection);
Employer testEmployerC = new Employer();
testEmployerC.FirstName = "Ema";
testEmployerC.LastName = "Coelho";
testEmployerC.UserName = "******";
testEmployerC.Password = "******";
testEmployerC.Email = "*****@*****.**";
testEmployerC.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testEmployerC.Address = "Lousada";
// Employe a utilizar
Employer returnedEmployer = employerDAO.Create(testEmployerC);
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate firstMate = new Mate();
firstMate.FirstName = "Marcelddo";
firstMate.LastName = "Carvalho";
firstMate.UserName = "******";
firstMate.Password = "******";
firstMate.Email = "*****@*****.**";
firstMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
firstMate.Address = "Sra. Aparecida, Lousada";
firstMate.Categories = new[] { Categories.CLEANING, Categories.ELECTRICITY };
firstMate.Rank = Ranks.MATE;
firstMate.Range = 50;
Mate returnMate = MateDAO.Create(firstMate);
ChatDAO chatDAO = new ChatDAO(_connection);
chatDAO.AddChatHubConnection(returnedEmployer.Id, "connection1");
chatDAO.AddChatHubConnection(returnMate.Id, "connection2");
int chatId = chatDAO.CreateChatId();
Chat chat = new Chat();
chat.ChatId = chatId;
chat.UserId = returnedEmployer.Id;
chatDAO.CreateChat(chat);
chat.UserId = returnMate.Id;
chatDAO.CreateChat(chat);
ChatConnection connect1 = chatDAO.GetChatConnectionFromUserId(returnedEmployer.Id);
ChatConnection connect2 = chatDAO.GetChatConnectionFromUserId(returnMate.Id);
String MessageSend = "message test";
String MessageSend2 = "message test 2";
chatDAO.AddMessage(connect1.Connection, connect2.Connection, MessageSend, DateTime.Now, returnedEmployer.Id);
chatDAO.AddMessage(connect2.Connection, connect1.Connection, MessageSend2, DateTime.Now, returnMate.Id);
List <Message> messages = chatDAO.GetMessageList(chatId, returnMate.Id);
List <Message> messages2 = chatDAO.GetMessageList(chatId, returnedEmployer.Id);
Assert.Equal(messages.Count, messages2.Count);
Assert.Equal(2, messages.Count);
Assert.Equal(2, messages2.Count);
messages.ToArray();
messages2.ToArray();
Assert.Equal("message test", messages[0].MessageSend);
Assert.Equal("message test", messages2[0].MessageSend);
Assert.Equal("message test 2", messages[1].MessageSend);
Assert.Equal("message test 2", messages2[1].MessageSend);
_fixture.Dispose();
}
// n == 0 なら 0終端、n == 1 なら 1終端、n == -1 ならそれ以外のノードを作る
public ZDDNode(int n)
{
mate_ = null;
id_ = n;
}
public override void Use(ClientSession session, ref ItemInstance inv, byte option = 0, string[] packetsplit = null)
{
if (session == null)
{
return;
}
switch (Effect)
{
case 0:
case 999:
if (option == 0)
{
if (packetsplit != null && packetsplit.Length == 9)
{
BoxInstance box = session.Character.Inventory.LoadBySlotAndType <BoxInstance>(inv.Slot, InventoryType.Equipment);
if (box != null)
{
if (box.Item.ItemSubType == 3)
{
session.SendPacket($"qna #guri^300^8023^{inv.Slot} {Language.Instance.GetMessageFromKey("ASK_OPEN_BOX")}");
}
else if (box.HoldingVNum == 0)
{
session.SendPacket($"qna #guri^300^8023^{inv.Slot}^{packetsplit[3]} {Language.Instance.GetMessageFromKey("ASK_STORE_PET")}");
}
else
{
session.SendPacket($"qna #guri^300^8023^{inv.Slot} {Language.Instance.GetMessageFromKey("ASK_RELEASE_PET")}");
}
}
}
}
else
{
//u_i 2 2000000 0 21 0 0
BoxInstance box = session.Character.Inventory.LoadBySlotAndType <BoxInstance>(inv.Slot, InventoryType.Equipment);
if (box != null)
{
if (box.Item.ItemSubType == 3)
{
List <RollGeneratedItemDTO> roll = box.Item.RollGeneratedItems.Where(s => s.MinimumOriginalItemRare <= box.Rare && s.MaximumOriginalItemRare >= box.Rare && s.OriginalItemDesign == box.Design).ToList();
int probabilities = roll.Sum(s => s.Probability);
int rnd = ServerManager.Instance.RandomNumber(0, probabilities);
int currentrnd = 0;
List <ItemInstance> newInv = null;
foreach (RollGeneratedItemDTO rollitem in roll)
{
Item createdItem = ServerManager.Instance.GetItem(rollitem.ItemGeneratedVNum);
if (newInv != null)
{
continue;
}
currentrnd += rollitem.Probability;
if (currentrnd < rnd)
{
continue;
}
if (createdItem.ItemType == ItemType.Shell)
{
rollitem.ItemGeneratedUpgrade = (byte)ServerManager.Instance.RandomNumber();
if (rollitem.ItemGeneratedUpgrade >= 95)
{
rollitem.ItemGeneratedUpgrade =
(byte)ServerManager.Instance.RandomNumber(80, 91);
}
else
{
rollitem.ItemGeneratedUpgrade = (byte)ServerManager.Instance.RandomNumber(70, 80);
}
}
newInv = session.Character.Inventory.AddNewToInventory(rollitem.ItemGeneratedVNum, rollitem.ItemGeneratedAmount, rare: box.Rare, upgrade: rollitem.ItemGeneratedUpgrade);
if (!newInv.Any())
{
continue;
}
short slot = inv.Slot;
if (slot == -1)
{
continue;
}
session.SendPacket(session.Character.GenerateSay($"{Language.Instance.GetMessageFromKey("ITEM_ACQUIRED")}: {newInv.FirstOrDefault()?.Item.Name ?? ""} x {rollitem.ItemGeneratedAmount})", 12));
session.SendPacket($"rdi {rollitem.ItemGeneratedVNum} {rollitem.ItemGeneratedAmount}");
newInv.ForEach(s => session.SendPacket(s?.GenerateInventoryAdd()));
session.Character.Inventory.RemoveItemAmountFromInventory(1, box.Id);
}
}
else if (box.HoldingVNum == 0)
{
if (packetsplit != null && packetsplit.Length == 1)
{
if (int.TryParse(packetsplit[0], out int petId))
{
Mate mate = session.Character.Mates.FirstOrDefault(s => s.MateTransportId == petId);
if (mate == null)
{
return;
}
box.MateType = mate.MateType;
box.HoldingVNum = mate.NpcMonsterVNum;
box.SpLevel = mate.Level;
box.SpDamage = mate.Attack;
box.SpDefence = mate.Defence;
session.Character.Mates.Remove(mate);
session.SendPacket(UserInterfaceHelper.Instance.GenerateInfo(Language.Instance.GetMessageFromKey("PET_STORED")));
session.SendPacket(UserInterfaceHelper.Instance.GeneratePClear());
session.SendPackets(session.Character.GenerateScP());
session.SendPackets(session.Character.GenerateScN());
session.CurrentMapInstance?.Broadcast(mate.GenerateOut());
}
}
}
else
{
NpcMonster heldMonster = ServerManager.Instance.GetNpc(box.HoldingVNum);
if (heldMonster != null)
{
Mate mate = new Mate(session.Character, heldMonster, (byte)(box.SpLevel == 0 ? 1 : box.SpLevel), box.MateType)
{
Attack = box.SpDamage,
Defence = box.SpDefence
};
if (session.Character.AddPet(mate))
{
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
session.SendPacket(UserInterfaceHelper.Instance.GenerateInfo(Language.Instance.GetMessageFromKey("PET_LEAVE_BEAD")));
}
}
}
}
}
break;
case 1:
if (option == 0)
{
session.SendPacket($"qna #guri^300^8023^{inv.Slot} {Language.Instance.GetMessageFromKey("ASK_RELEASE_PET")}");
}
else
{
NpcMonster heldMonster = ServerManager.Instance.GetNpc((short)EffectValue);
if (session.CurrentMapInstance == session.Character.Miniland && heldMonster != null)
{
Mate mate = new Mate(session.Character, heldMonster, LevelMinimum, ItemSubType == 1 ? MateType.Partner : MateType.Pet);
if (session.Character.AddPet(mate))
{
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
session.SendPacket(UserInterfaceHelper.Instance.GenerateInfo(Language.Instance.GetMessageFromKey("PET_LEAVE_BEAD")));
}
}
else
{
//TODO ADD MINILAND SENDPACKET
}
}
break;
case 69:
if (EffectValue == 1 || EffectValue == 2)
{
BoxInstance box = session.Character.Inventory.LoadBySlotAndType <BoxInstance>(inv.Slot, InventoryType.Equipment);
if (box != null)
{
if (box.HoldingVNum == 0)
{
session.SendPacket($"wopen 44 {inv.Slot}");
}
else
{
List <ItemInstance> newInv = session.Character.Inventory.AddNewToInventory(box.HoldingVNum);
if (newInv.Any())
{
ItemInstance itemInstance = newInv.First();
SpecialistInstance specialist = session.Character.Inventory.LoadBySlotAndType <SpecialistInstance>(itemInstance.Slot, itemInstance.Type);
if (specialist != null)
{
specialist.SlDamage = box.SlDamage;
specialist.SlDefence = box.SlDefence;
specialist.SlElement = box.SlElement;
specialist.SlHP = box.SlHP;
specialist.SpDamage = box.SpDamage;
specialist.SpDark = box.SpDark;
specialist.SpDefence = box.SpDefence;
specialist.SpElement = box.SpElement;
specialist.SpFire = box.SpFire;
specialist.SpHP = box.SpHP;
specialist.SpLevel = box.SpLevel;
specialist.SpLight = box.SpLight;
specialist.SpStoneUpgrade = box.SpStoneUpgrade;
specialist.SpWater = box.SpWater;
specialist.Upgrade = box.Upgrade;
specialist.XP = box.XP;
}
short slot = inv.Slot;
if (slot != -1)
{
if (specialist != null)
{
session.SendPacket(session.Character.GenerateSay($"{Language.Instance.GetMessageFromKey("ITEM_ACQUIRED")}: {specialist.Item.Name} + {specialist.Upgrade}", 12));
newInv.ForEach(s => session.SendPacket(specialist.GenerateInventoryAdd()));
}
session.Character.Inventory.RemoveItemAmountFromInventory(1, box.Id);
}
}
else
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("NOT_ENOUGH_PLACE"), 0));
}
}
}
}
if (EffectValue == 3)
{
BoxInstance box = session.Character.Inventory.LoadBySlotAndType <BoxInstance>(inv.Slot, InventoryType.Equipment);
if (box != null)
{
if (box.HoldingVNum == 0)
{
session.SendPacket($"guri 26 0 {inv.Slot}");
}
else
{
List <ItemInstance> newInv = session.Character.Inventory.AddNewToInventory(box.HoldingVNum);
if (newInv.Any())
{
ItemInstance itemInstance = newInv.First();
WearableInstance fairy = session.Character.Inventory.LoadBySlotAndType <WearableInstance>(itemInstance.Slot, itemInstance.Type);
if (fairy != null)
{
fairy.ElementRate = box.ElementRate;
}
short slot = inv.Slot;
if (slot != -1)
{
if (fairy != null)
{
session.SendPacket(session.Character.GenerateSay($"{Language.Instance.GetMessageFromKey("ITEM_ACQUIRED")}: {fairy.Item.Name} ({fairy.ElementRate}%)", 12));
newInv.ForEach(s => session.SendPacket(fairy.GenerateInventoryAdd()));
}
session.Character.Inventory.RemoveItemAmountFromInventory(1, box.Id);
}
}
else
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("NOT_ENOUGH_PLACE"), 0));
}
}
}
}
if (EffectValue == 4)
{
BoxInstance box = session.Character.Inventory.LoadBySlotAndType <BoxInstance>(inv.Slot, InventoryType.Equipment);
if (box != null)
{
if (box.HoldingVNum == 0)
{
session.SendPacket($"guri 24 0 {inv.Slot}");
}
else
{
List <ItemInstance> newInv = session.Character.Inventory.AddNewToInventory(box.HoldingVNum);
if (newInv.Any())
{
short slot = inv.Slot;
if (slot != -1)
{
session.SendPacket(session.Character.GenerateSay($"{Language.Instance.GetMessageFromKey("ITEM_ACQUIRED")}: {newInv.First().Item.Name} x 1)", 12));
newInv.ForEach(s => session.SendPacket(s.GenerateInventoryAdd()));
session.Character.Inventory.RemoveItemAmountFromInventory(1, box.Id);
}
}
else
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("NOT_ENOUGH_PLACE"), 0));
}
}
}
}
break;
default:
Logger.Log.Warn(string.Format(Language.Instance.GetMessageFromKey("NO_HANDLER_ITEM"), GetType()));
break;
}
}
public void ApplyBCards(IBattleEntity session, IBattleEntity caster = null)
{
Mate mate;
switch ((BCardType.CardType)Type)
{
case BCardType.CardType.Buff:
if (ServerManager.Instance.RandomNumber() < FirstData)
{
session?.BattleEntity.AddBuff(new Buff(SecondData, caster?.BattleEntity.Level ?? session.BattleEntity.Level));
}
break;
case BCardType.CardType.Move:
if (session.GetSession() is Character chara)
{
chara.LastSpeedChange = DateTime.Now;
chara.LoadSpeed();
chara?.Session.SendPacket(chara.GenerateCond());
}
break;
case BCardType.CardType.Summons:
NpcMonster npcMonster = session.GetSession() is MapMonster mob ? mob.Monster : session.GetSession() is MapNpc npc ? npc.Npc : null;
ConcurrentBag <ToSummon> summonParameters = new ConcurrentBag <ToSummon>();
switch ((AdditionalTypes.Summons)SubType)
{
case AdditionalTypes.Summons.Summons:
for (int i = 0; i < FirstData; i++)
{
MapCell cell = session.GetPos();
cell.Y += (short)ServerManager.Instance.RandomNumber(-3, 3);
cell.X += (short)ServerManager.Instance.RandomNumber(-3, 3);
summonParameters.Add(new ToSummon((short)SecondData, cell, null, true, (byte)Math.Abs(ThirdData)));
}
EventHelper.Instance.RunEvent(new EventContainer(session.MapInstance, EventActionType.SPAWNMONSTERS, summonParameters));
break;
case AdditionalTypes.Summons.SummonTrainingDummy:
if (npcMonster != null && session.BattleEntity.OnHitEvents.All(s => s?.EventActionType != EventActionType.SPAWNMONSTERS))
{
summonParameters.Add(new ToSummon((short)SecondData, session.GetPos(), null, true, (byte)Math.Abs(ThirdData)));
session.BattleEntity.OnHitEvents.Add(new EventContainer(session.MapInstance, EventActionType.SPAWNMONSTERS, summonParameters));
}
break;
case AdditionalTypes.Summons.SummonUponDeathChance:
case AdditionalTypes.Summons.SummonUponDeath:
if (npcMonster != null && session.BattleEntity.OnDeathEvents.All(s => s?.EventActionType != EventActionType.SPAWNMONSTERS))
{
for (int i = 0; i < FirstData; i++)
{
MapCell cell = session.GetPos();
cell.Y += (short)i;
summonParameters.Add(new ToSummon((short)SecondData, cell, null, true, (byte)Math.Abs(ThirdData)));
}
session.BattleEntity.OnDeathEvents.Add(new EventContainer(session.MapInstance, EventActionType.SPAWNMONSTERS, summonParameters));
}
break;
default:
break;
}
break;
case BCardType.CardType.SpecialAttack:
break;
case BCardType.CardType.SpecialDefence:
break;
case BCardType.CardType.AttackPower:
break;
case BCardType.CardType.Target:
break;
case BCardType.CardType.Critical:
break;
case BCardType.CardType.SpecialCritical:
break;
case BCardType.CardType.Element:
break;
case BCardType.CardType.IncreaseDamage:
break;
case BCardType.CardType.Defence:
break;
case BCardType.CardType.DodgeAndDefencePercent:
break;
case BCardType.CardType.Block:
break;
case BCardType.CardType.Absorption:
break;
case BCardType.CardType.ElementResistance:
break;
case BCardType.CardType.EnemyElementResistance:
break;
case BCardType.CardType.Damage:
break;
case BCardType.CardType.GuarantedDodgeRangedAttack:
break;
case BCardType.CardType.Morale:
break;
case BCardType.CardType.Casting:
break;
case BCardType.CardType.Reflection:
break;
case BCardType.CardType.DrainAndSteal:
break;
case BCardType.CardType.HealingBurningAndCasting:
var subtype = (AdditionalTypes.HealingBurningAndCasting)SubType;
Character sess;
switch (subtype)
{
case AdditionalTypes.HealingBurningAndCasting.RestoreHP:
case AdditionalTypes.HealingBurningAndCasting.RestoreHPWhenCasting:
if (session.GetSession() is Character)
{
sess = (Character)session.GetSession();
int heal = FirstData;
bool change = false;
if (IsLevelScaled)
{
if (IsLevelDivided)
{
heal /= sess.Level;
}
else
{
heal *= sess.Level;
}
}
if (sess.Hp + heal < sess.HpLoad())
{
sess.Hp += heal;
sess.Session?.CurrentMapInstance?.Broadcast(sess.GenerateRc(heal));
change = true;
}
else
{
if (sess.Hp != (int)sess.HpLoad())
{
sess.Session?.CurrentMapInstance?.Broadcast(sess.GenerateRc((int)(sess.HpLoad() - sess.Hp)));
change = true;
}
sess.Hp = (int)sess.HpLoad();
}
if (change)
{
sess.Session?.SendPacket(sess.GenerateStat());
}
}
if (session.GetSession() is Mate)
{
mate = (Mate)session.GetSession();
int heal = FirstData;
if (IsLevelScaled)
{
if (IsLevelDivided)
{
heal /= mate.Level;
}
else
{
heal *= mate.Level;
}
}
if (mate.Hp + heal < mate.HpLoad())
{
mate.Hp += heal;
}
else
{
mate.Hp = mate.HpLoad();
}
}
break;
case AdditionalTypes.HealingBurningAndCasting.RestoreMP:
if (session.GetSession() is Character)
{
sess = (Character)session.GetSession();
int heal = FirstData;
bool change = false;
if (IsLevelScaled)
{
if (IsLevelDivided)
{
heal /= sess.Level;
}
else
{
heal *= sess.Level;
}
}
if (sess.Mp + heal < sess.MpLoad())
{
sess.Mp += heal;
change = true;
}
else
{
if (sess.Mp != (int)sess.MpLoad())
{
change = true;
}
sess.Mp = (int)sess.MpLoad();
}
if (change)
{
sess.Session?.SendPacket(sess.GenerateStat());
}
}
if (session.GetSession() is Mate)
{
mate = (Mate)session.GetSession();
int heal = FirstData;
if (IsLevelScaled)
{
if (IsLevelDivided)
{
heal /= mate.Level;
}
else
{
heal *= mate.Level;
}
}
if (mate.Mp + heal < mate.MpLoad())
{
mate.Mp += heal;
}
else
{
mate.Mp = mate.MpLoad();
}
}
break;
}
break;
case BCardType.CardType.HPMP:
break;
case BCardType.CardType.SpecialisationBuffResistance:
break;
case BCardType.CardType.SpecialEffects:
break;
case BCardType.CardType.Capture:
if (session is MapMonster monsterToCapture && caster is Character hunter)
{
if (monsterToCapture.Monster.RaceType == 1 && (hunter.MapInstance.MapInstanceType == MapInstanceType.BaseMapInstance || hunter.MapInstance.MapInstanceType == MapInstanceType.TimeSpaceInstance))
{
if (monsterToCapture.Monster.Level < hunter.Level)
{
if (monsterToCapture.CurrentHp < (monsterToCapture.Monster.MaxHP / 2))
{
if (hunter.MaxMateCount > hunter.Mates.Count())
{
// Algo
int capturerate = 100 - (monsterToCapture.CurrentHp / monsterToCapture.Monster.MaxHP + 1) / 2;
if (ServerManager.Instance.RandomNumber() <= capturerate)
{
if (hunter.Quests.Any(q => q.Quest.QuestType == (int)QuestType.Capture1 && q.Quest.QuestObjectives.Any(d => d.Data == monsterToCapture.MonsterVNum)))
{
hunter.IncrementQuests(QuestType.Capture1, monsterToCapture.MonsterVNum);
return;
}
hunter.IncrementQuests(QuestType.Capture2, monsterToCapture.MonsterVNum);
int level = monsterToCapture.Monster.Level - 15 < 1 ? 1 : monsterToCapture.Monster.Level - 15;
Mate currentmate = hunter.Mates?.FirstOrDefault(m => m.IsTeamMember && m.MateType == MateType.Pet);
if (currentmate != null)
{
currentmate.RemoveTeamMember(); // remove current pet
hunter.MapInstance.Broadcast(currentmate.GenerateOut());
}
monsterToCapture.MapInstance.DespawnMonster(monsterToCapture);
NpcMonster mateNpc = ServerManager.Instance.GetNpc(monsterToCapture.MonsterVNum);
mate = new Mate(hunter, mateNpc, (byte)level, MateType.Pet);
hunter.Mates?.Add(mate);
mate.RefreshStats();
hunter.Session.SendPacket($"ctl 2 {mate.PetId} 3");
hunter.MapInstance.Broadcast(mate.GenerateIn());
hunter.Session.SendPacket(hunter.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("YOU_GET_PET"), mate.Name), 0));
hunter.Session.SendPacket(UserInterfaceHelper.Instance.GeneratePClear());
hunter.Session.SendPackets(hunter.GenerateScP());
hunter.Session.SendPackets(hunter.GenerateScN());
hunter.Session.SendPacket(hunter.GeneratePinit());
hunter.Session.SendPackets(hunter.Mates.Where(s => s.IsTeamMember)
.OrderBy(s => s.MateType)
.Select(s => s.GeneratePst()));
}
else
{
hunter.Session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("CAPTURE_FAILED"), 0));
}
}
else
{
hunter.Session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("MAX_MATES_COUNT"), 0));
}
}
else
{
hunter.Session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("monsterToCapture_MUST_BE_LOW_HP"), 0));
}
}
else
{
hunter.Session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("monsterToCapture_LVL_MUST_BE_LESS"), 0));
}
}
else
{
hunter.Session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("monsterToCapture_CANNOT_BE_CAPTURED"), 0));
}
}
break;
case BCardType.CardType.SpecialDamageAndExplosions:
break;
case BCardType.CardType.SpecialEffects2:
break;
case BCardType.CardType.CalculatingLevel:
break;
case BCardType.CardType.Recovery:
break;
case BCardType.CardType.MaxHPMP:
break;
case BCardType.CardType.MultAttack:
break;
case BCardType.CardType.MultDefence:
break;
case BCardType.CardType.TimeCircleSkills:
break;
case BCardType.CardType.RecoveryAndDamagePercent:
break;
case BCardType.CardType.Count:
break;
case BCardType.CardType.NoDefeatAndNoDamage:
break;
case BCardType.CardType.SpecialActions:
if (session.GetSession() is Character charact)
{
if (SubType.Equals((byte)AdditionalTypes.SpecialActions.Hide))
{
charact.Invisible = true;
charact.Mates.Where(s => s.IsTeamMember).ToList().ForEach(s => charact.Session.CurrentMapInstance?.Broadcast(s.GenerateOut()));
charact.Session.CurrentMapInstance?.Broadcast(charact.GenerateInvisible());
}
}
break;
case BCardType.CardType.Mode:
break;
case BCardType.CardType.NoCharacteristicValue:
break;
case BCardType.CardType.LightAndShadow:
break;
case BCardType.CardType.Item:
break;
case BCardType.CardType.DebuffResistance:
break;
case BCardType.CardType.SpecialBehaviour:
break;
case BCardType.CardType.Quest:
break;
case BCardType.CardType.SecondSPCard:
break;
case BCardType.CardType.SPCardUpgrade:
break;
case BCardType.CardType.HugeSnowman:
break;
case BCardType.CardType.Drain:
break;
case BCardType.CardType.BossMonstersSkill:
break;
case BCardType.CardType.LordHatus:
break;
case BCardType.CardType.LordCalvinas:
break;
case BCardType.CardType.SESpecialist:
break;
case BCardType.CardType.FourthGlacernonFamilyRaid:
break;
case BCardType.CardType.SummonedMonsterAttack:
break;
case BCardType.CardType.BearSpirit:
break;
case BCardType.CardType.SummonSkill:
break;
case BCardType.CardType.InflictSkill:
break;
case BCardType.CardType.HideBarrelSkill:
break;
case BCardType.CardType.FocusEnemyAttentionSkill:
break;
case BCardType.CardType.TauntSkill:
break;
case BCardType.CardType.FireCannoneerRangeBuff:
break;
case BCardType.CardType.VulcanoElementBuff:
break;
case BCardType.CardType.DamageConvertingSkill:
break;
case BCardType.CardType.MeditationSkill:
if (session.GetSession().GetType() == typeof(Character))
{
if (SubType.Equals((byte)AdditionalTypes.MeditationSkill.CausingChance))
{
if (ServerManager.Instance.RandomNumber() < FirstData)
{
if (!(session is Character character))
{
break;
}
if (SkillVNum.HasValue)
{
character.LastSkillCombo = DateTime.Now;
Skill skill = ServerManager.Instance.GetSkill(SkillVNum.Value);
Skill newSkill = ServerManager.Instance.GetSkill((short)SecondData);
Observable.Timer(TimeSpan.FromMilliseconds(100)).Subscribe(observer =>
{
foreach (QuicklistEntryDTO qe in character.QuicklistEntries.Where(s =>
s.Pos.Equals(skill.CastId)))
{
character.Session.SendPacket(
$"qset {qe.Q1} {qe.Q2} {qe.Type}.{qe.Slot}.{newSkill.CastId}.0");
}
character.Session.SendPacket($"mslot {newSkill.CastId} -1");
});
if (skill.CastId > 10)
{
// HACK this way
Observable.Timer(TimeSpan.FromMilliseconds(skill.Cooldown * 100 + 500))
.Subscribe(observer =>
{
character.Session.SendPacket($"sr {skill.CastId}");
});
}
}
}
}
else
{
if (!(session is Character character))
{
break;
}
switch (SubType)
{
case 21:
character.MeditationDictionary[(short)SecondData] = DateTime.Now.AddSeconds(4);
break;
case 31:
character.MeditationDictionary[(short)SecondData] = DateTime.Now.AddSeconds(8);
break;
case 41:
character.MeditationDictionary[(short)SecondData] = DateTime.Now.AddSeconds(12);
break;
}
}
}
break;
case BCardType.CardType.FalconSkill:
break;
case BCardType.CardType.AbsorptionAndPowerSkill:
break;
case BCardType.CardType.LeonaPassiveSkill:
break;
case BCardType.CardType.FearSkill:
break;
case BCardType.CardType.SniperAttack:
break;
case BCardType.CardType.FrozenDebuff:
break;
case BCardType.CardType.JumpBackPush:
break;
case BCardType.CardType.FairyXPIncrease:
break;
case BCardType.CardType.SummonAndRecoverHP:
break;
case BCardType.CardType.TeamArenaBuff:
break;
case BCardType.CardType.ArenaCamera:
break;
case BCardType.CardType.DarkCloneSummon:
break;
case BCardType.CardType.AbsorbedSpirit:
break;
case BCardType.CardType.AngerSkill:
break;
case BCardType.CardType.MeteoriteTeleport:
break;
case BCardType.CardType.StealBuff:
break;
default:
Logger.Error(new ArgumentOutOfRangeException($"Card Type {Type} not defined!"));
//throw new ArgumentOutOfRangeException();
break;
}
}
private void ExecuteHandler(ClientSession session)
{
if (session.Account.IsVerified || Type == 4 && Argument == 11)
{
if (Data.HasValue && Type == 10 && Data.Value >= 973 &&
Data.Value <= 999 && !session.Character.EmoticonsBlocked)
{
if (Parameter == session.Character.CharacterId)
{
session.CurrentMapInstance?.Broadcast(session,
StaticPacketHelper.GenerateEff(UserType.Player, session.Character.CharacterId,
Data.Value + 4099), ReceiverType.AllNoEmoBlocked);
}
else if (Parameter.TryCastToInt(out int mateTransportId))
{
Mate mate = session.Character.Mates.Find(s => s.MateTransportId == mateTransportId);
if (mate != null)
{
session.CurrentMapInstance?.Broadcast(session,
StaticPacketHelper.GenerateEff(UserType.Npc, mate.MateTransportId,
Data.Value + 4099), ReceiverType.AllNoEmoBlocked);
}
}
}
else if (Type == 204)
{
if (Argument == 0 && short.TryParse(Parameter.ToString(), out short slot))
{
ItemInstance shell =
session.Character.Inventory.LoadBySlotAndType(slot, InventoryType.Equipment);
if (shell?.ShellEffects.Count == 0 && shell.Upgrade > 0 && shell.Rare > 0 &&
session.Character.Inventory.CountItem(1429) >= ((shell.Upgrade / 10) + shell.Rare))
{
shell.SetShellEffects();
session.SendPacket(
UserInterfaceHelper.GenerateMsg(
Language.Instance.GetMessageFromKey("OPTION_IDENTIFIED"), 0));
session.SendPacket(StaticPacketHelper.GenerateEff(UserType.Player,
session.Character.CharacterId, 3006));
session.Character.Inventory.RemoveItemAmount(1429, (shell.Upgrade / 10) + shell.Rare);
}
}
}
else if (Type == 205)
{
if (Parameter.TryCastToShort(out short slot))
{
ItemInstance inv = session.Character.Inventory.LoadBySlotAndType(slot, InventoryType.Equipment);
if (inv.Rare < 1 || inv.Rare > 8 || inv.Item.LevelMinimum > 99 ||
inv.BoundCharacterId == null)
{
return;
}
short[][] parfumeReq =
{
new short[] { 0, 0, 0, 0, 0, 5, 10, 10, 20 },
new short[] { 0, 0, 0, 0, 5, 10, 10, 20, 40 },
new short[] { 0, 0, 0, 5, 10, 10, 20, 40, 80 },
new short[] { 0, 0, 5, 5, 10, 20, 40, 80, 120 },
new short[] { 0, 0, 5, 10, 20, 40, 80, 120, 160 },
new short[] { 0, 0, 5, 20, 40, 80, 120, 160, 200 },
new short[] { 0, 0, 10, 40, 80, 120, 160, 200, 300 },
new short[] { 0, 0, 10, 40, 80, 120, 160, 200, 400 }
};
int[] goldReq =
{
1000,
2000,
5000,
8000,
10000,
12500,
15000,
17500,
20000,
30000
};
if (session.Character.Inventory.CountItem(1428)
>= parfumeReq[inv.Rare - 1][(inv.Item.LevelMinimum / 10) - 1] &&
session.Character.Gold >= goldReq[(inv.Item.LevelMinimum / 10) - 1])
{
session.Character.Inventory.RemoveItemAmount(1428,
parfumeReq[inv.Rare - 1][(inv.Item.LevelMinimum / 10) - 1]);
session.Character.Gold -= goldReq[(inv.Item.LevelMinimum / 10) - 1];
session.SendPacket(session.Character.GenerateGold());
inv.BoundCharacterId = session.Character.CharacterId;
session.SendPacket(
UserInterfaceHelper.GenerateMsg(
Language.Instance.GetMessageFromKey("SHELL_PERFUMED"), 0));
}
}
}
else if (Type == 300)
{
if (Argument == 8023 && Parameter.TryCastToShort(out short slot))
{
ItemInstance box = session.Character.Inventory.LoadBySlotAndType(slot, InventoryType.Equipment);
if (box != null)
{
box.Item.Use(session, ref box, 1, new[] { Data?.ToString() ?? string.Empty });
}
}
}
else if (Type == 506)
{
session.Character.IsWaitingForEvent |= ServerManager.Instance.EventInWaiting;
}
else if (Type == 199 && Argument == 2)
{
short[] listWingOfFriendship = { 2160, 2312, 10048 };
short vnumToUse = -1;
foreach (short vnum in listWingOfFriendship)
{
if (session.Character.Inventory.CountItem(vnum) > 0)
{
vnumToUse = vnum;
}
}
if (vnumToUse != -1 || session.Character.IsSpouseOfCharacter(Parameter))
{
ClientSession sess = ServerManager.Instance.GetSessionByCharacterId(Parameter);
if (sess != null)
{
if (session.Character.IsFriendOfCharacter(Parameter))
{
if (sess.CurrentMapInstance?.MapInstanceType == MapInstanceType.BaseMapInstance)
{
if (session.Character.MapInstance.MapInstanceType
!= MapInstanceType.BaseMapInstance ||
(ServerManager.Instance.ChannelId == 51 &&
session.Character.Faction != sess.Character.Faction))
{
session.SendPacket(
session.Character.GenerateSay(
Language.Instance.GetMessageFromKey("CANT_USE_THAT"), 10));
return;
}
short mapy = sess.Character.PositionY;
short mapx = sess.Character.PositionX;
short mapId = sess.Character.MapInstance.Map.MapId;
ServerManager.Instance.ChangeMap(session.Character.CharacterId, mapId, mapx, mapy);
if (!session.Character.IsSpouseOfCharacter(Parameter))
{
session.Character.Inventory.RemoveItemAmount(vnumToUse);
}
}
else
{
session.SendPacket(
UserInterfaceHelper.GenerateMsg(
Language.Instance.GetMessageFromKey("USER_ON_INSTANCEMAP"), 0));
}
}
}
else
{
session.SendPacket(
UserInterfaceHelper.GenerateMsg(
Language.Instance.GetMessageFromKey("USER_NOT_CONNECTED"), 0));
}
}
else
{
session.SendPacket(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("NO_WINGS"), 10));
}
}
else if (Type == 400)
{
if (!session.HasCurrentMapInstance)
{
return;
}
MapNpc npc = session.CurrentMapInstance.Npcs.Find(n => n.MapNpcId.Equals(Argument));
if (npc != null)
{
NpcMonster mapobject = ServerManager.GetNpcMonster(npc.NpcVNum);
int rateDrop = ServerManager.Instance.Configuration.RateDrop;
int delay = (int)Math.Round(
(3 + (mapobject.RespawnTime / 1000d)) * session.Character.TimesUsed);
delay = delay > 11 ? 8 : delay;
if (session.Character.LastMapObject.AddSeconds(delay) < DateTime.UtcNow)
{
if (mapobject.Drops.Any(s => s.MonsterVNum != null) && mapobject.VNumRequired > 10 &&
session.Character.Inventory
.CountItem(mapobject.VNumRequired)
< mapobject.AmountRequired)
{
session.SendPacket(
UserInterfaceHelper.GenerateMsg(
Language.Instance.GetMessageFromKey("NOT_ENOUGH_ITEM"), 0));
return;
}
Random random = new Random();
double randomAmount = ServerManager.RandomNumber() * random.NextDouble();
DropDTO drop = mapobject.Drops.Find(s => s.MonsterVNum == npc.NpcVNum);
if (drop != null)
{
int dropChance = drop.DropChance;
if (randomAmount <= (double)dropChance * rateDrop / 5000.000)
{
short vnum = drop.ItemVNum;
ItemInstance newInv = session.Character.Inventory.AddNewToInventory(vnum)
.FirstOrDefault();
session.Character.LastMapObject = DateTime.UtcNow;
session.Character.TimesUsed++;
if (session.Character.TimesUsed >= 4)
{
session.Character.TimesUsed = 0;
}
if (newInv != null)
{
session.SendPacket(UserInterfaceHelper.GenerateMsg(
string.Format(Language.Instance.GetMessageFromKey("RECEIVED_ITEM"),
newInv.Item.Name), 0));
session.SendPacket(session.Character.GenerateSay(
string.Format(Language.Instance.GetMessageFromKey("RECEIVED_ITEM"),
newInv.Item.Name), 11));
}
else
{
session.SendPacket(UserInterfaceHelper.GenerateMsg(
Language.Instance.GetMessageFromKey("NOT_ENOUGH_PLACE"), 0));
}
}
else
{
session.SendPacket(
UserInterfaceHelper.GenerateMsg(
Language.Instance.GetMessageFromKey("TRY_FAILED"), 0));
}
}
}
else
{
session.SendPacket(UserInterfaceHelper.GenerateMsg(
string.Format(Language.Instance.GetMessageFromKey("TRY_FAILED_WAIT"),
(int)(session.Character.LastMapObject.AddSeconds(delay) - DateTime.UtcNow)
.TotalSeconds), 0));
}
}
}
else if (Type == 710)
{
if (Value != null)
{
// TODO: MAP TELEPORTER
}
}
else if (Type == 750)
{
const short baseVnum = 1623;
if (Argument.TryCastToByte(out byte faction) &&
(Enum.IsDefined(typeof(FactionType), faction) ||
Enum.IsDefined(typeof(FactionType), (byte)(faction / 2))) &&
session.Character.Inventory.CountItem(baseVnum + faction) > 0)
{
if (faction < 3)
{
if (session.Character.Family != null)
{
session.SendPacket(
UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("IN_FAMILY"),
0));
return;
}
session.Character.Faction = (FactionType)faction;
session.Character.Inventory.RemoveItemAmount(baseVnum + faction);
session.SendPacket("scr 0 0 0 0 0 0 0");
session.SendPacket(session.Character.GenerateFaction());
session.SendPacket(StaticPacketHelper.GenerateEff(UserType.Player,
session.Character.CharacterId, 4799 + faction));
session.SendPacket(UserInterfaceHelper.GenerateMsg(
Language.Instance.GetMessageFromKey($"GET_PROTECTION_POWER_{faction}"), 0));
}
else
{
if (session.Character.Family == null || session.Character.Family.FamilyCharacters
.Find(s => s.Authority.Equals(FamilyAuthority.Head))?.CharacterId
.Equals(session.Character.CharacterId) != true)
{
session.SendPacket(
UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("NO_FAMILY"),
0));
return;
}
if (session.Character.Family.LastFactionChange > DateTime.UtcNow.AddDays(-1).Ticks)
{
session.SendPacket(UserInterfaceHelper.GenerateMsg(
Language.Instance.GetMessageFromKey("CHANGE_NOT PERMITTED"), 0));
return;
}
session.Character.Faction = (FactionType)(faction / 2);
session.Character.Inventory.RemoveItemAmount(baseVnum + faction);
session.SendPacket("scr 0 0 0 0 0 0 0");
session.SendPacket(session.Character.GenerateFaction());
session.SendPacket(StaticPacketHelper.GenerateEff(UserType.Player,
session.Character.CharacterId, 4799 + (faction / 2)));
session.SendPacket(UserInterfaceHelper.GenerateMsg(
Language.Instance.GetMessageFromKey($"GET_PROTECTION_POWER_{faction / 2}"), 0));
session.Character.Family.LastFactionChange = DateTime.UtcNow.Ticks;
session.Character.Save();
ServerManager.Instance.FamilyRefresh(session.Character.Family.FamilyId);
CommunicationServiceClient.Instance.SendMessageToCharacter(new ScsCharacterMessage
{
DestinationCharacterId = session.Character.Family.FamilyId,
SourceCharacterId = 0,
SourceWorldId = ServerManager.Instance.WorldId,
Message = "fhis_stc",
Type = MessageType.Family
});
}
}
}
else if (Type == 2)
{
session.CurrentMapInstance?.Broadcast(
UserInterfaceHelper.GenerateGuri(2, 1, session.Character.CharacterId),
session.Character.PositionX, session.Character.PositionY);
}
else if (Type == 4)
{
const int speakerVNum = 2173;
const int petnameVNum = 2157;
if (Argument == 1 && Data.HasValue)
{
Mate mate = session.Character.Mates.Find(s => s.MateTransportId == Data.Value);
if (mate != null && session.Character.Inventory.CountItem(petnameVNum) > 0)
{
mate.Name = Value.Truncate(16);
session.CurrentMapInstance?.Broadcast(mate.GenerateOut(), ReceiverType.AllExceptMe);
session.CurrentMapInstance?.Broadcast(mate.GenerateIn());
session.SendPacket(mate.GenerateCond());
session.SendPacket(
UserInterfaceHelper.GenerateInfo(Language.Instance.GetMessageFromKey("NEW_NAME_PET")));
session.SendPacket(session.Character.GeneratePinit());
session.SendPackets(session.Character.GeneratePst());
session.SendPackets(session.Character.GenerateScP());
session.Character.Inventory.RemoveItemAmount(petnameVNum);
}
}
// presentation message
if (Argument == 2)
{
int presentationVNum = session.Character.Inventory.CountItem(1117) > 0
? 1117
: (session.Character.Inventory.CountItem(9013) > 0 ? 9013 : -1);
if (presentationVNum != -1)
{
string message = string.Empty;
string[] valuesplit = Value?.Split(' ');
if (valuesplit == null)
{
return;
}
for (int i = 0; i < valuesplit.Length; i++)
{
message += valuesplit[i] + "^";
}
message = message.Substring(0, message.Length - 1); // Remove the last ^
message = message.Trim();
if (message.Length > 60)
{
message = message.Substring(0, 60);
}
session.Character.Biography = message;
session.SendPacket(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("INTRODUCTION_SET"),
10));
session.Character.Inventory.RemoveItemAmount(presentationVNum);
}
}
// Speaker
if (Argument == 3 && session.Character.Inventory.CountItem(speakerVNum) > 0)
{
string message =
$"[{session.Character.Name}]:";
int baseLength = message.Length;
string[] valuesplit = Value?.Split(' ');
if (valuesplit == null)
{
return;
}
for (int i = 0; i < valuesplit.Length; i++)
{
message += valuesplit[i] + " ";
}
if (message.Length > 120 + baseLength)
{
message = message.Substring(0, 120 + baseLength);
}
message = message.Replace("\n", string.Empty).Replace("\r", string.Empty)
.Replace($"<{Language.Instance.GetMessageFromKey("SPEAKER")}>", string.Empty).Trim();
message = $"<{Language.Instance.GetMessageFromKey("SPEAKER")}> {message}";
if (session.Character.IsMuted())
{
session.SendPacket(
session.Character.GenerateSay(
Language.Instance.GetMessageFromKey("SPEAKER_CANT_BE_USED"), 10));
return;
}
session.Character.Inventory.RemoveItemAmount(speakerVNum);
ServerManager.Instance.Broadcast(session.Character.GenerateSay(message, 13));
if (ServerManager.Instance.Configuration.UseChatLogService)
{
ChatLogServiceClient.Instance.LogChatMessage(new ChatLogEntry
{
Sender = session.Character.Name,
SenderId = session.Character.CharacterId,
Receiver = null,
ReceiverId = null,
MessageType = ChatLogType.Speaker,
Message = message
});
}
}
if (Argument == 11 && !string.IsNullOrWhiteSpace(Value) &&
!string.IsNullOrWhiteSpace(session.Account.TotpSecret))
{
Totp totp = new Totp(Base32Encoding.ToBytes(session.Account.TotpSecret));
if (totp.VerifyTotp(Value, out long _, VerificationWindow.RfcSpecifiedNetworkDelay))
{
session.Character.GeneralLogs.Add(new GeneralLogDTO
{
AccountId = session.Account.AccountId,
IpAddress = session.IpAddress,
LogType = GeneralLogType.TOTP.ToString(),
LogData = "SUCCESS",
Timestamp = DateTime.UtcNow
});
session.Account.IsVerified = true;
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("TOTP_VERIFIED"), 12));
}
else
{
session.Character.GeneralLogs.Add(new GeneralLogDTO
{
AccountId = session.Account.AccountId,
IpAddress = session.IpAddress,
LogType = GeneralLogType.TOTP.ToString(),
LogData = "FAIL",
Timestamp = DateTime.UtcNow
});
session.Disconnect();
}
}
}
else if (Type == 199 && Argument == 1)
{
if (!session.Character.IsFriendOfCharacter(Parameter))
{
session.SendPacket(Language.Instance.GetMessageFromKey("CHARACTER_NOT_IN_FRIENDLIST"));
return;
}
session.SendPacket(UserInterfaceHelper.GenerateDelay(3000, 4, $"#guri^199^2^{Parameter}"));
}
else if (Type == 201)
{
if (session.Character.StaticBonusList.Any(s => s.StaticBonusType == StaticBonusType.PetBasket))
{
session.SendPacket(session.Character.GenerateStashAll());
}
}
else if (Type == 202)
{
session.SendPacket(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("PARTNER_BACKPACK"), 10));
session.SendPacket(session.Character.GeneratePStashAll());
}
else if (Type == 208 && Argument == 0)
{
if (short.TryParse(Value, out short mountSlot) &&
Parameter.TryCastToShort(out short pearlSlot))
{
ItemInstance mount =
session.Character.Inventory.LoadBySlotAndType <ItemInstance>(mountSlot, InventoryType.Main);
ItemInstance pearl =
session.Character.Inventory.LoadBySlotAndType(pearlSlot, InventoryType.Equipment);
if (mount != null && pearl != null)
{
pearl.HoldingVNum = mount.ItemVNum;
session.Character.Inventory.RemoveItemFromInventory(mount.Id);
}
}
}
else if (Type == 209 && Argument == 0)
{
if (short.TryParse(Value, out short mountSlot) &&
Parameter.TryCastToShort(out short pearlSlot))
{
ItemInstance fairy =
session.Character.Inventory.LoadBySlotAndType(mountSlot, InventoryType.Equipment);
ItemInstance pearl =
session.Character.Inventory.LoadBySlotAndType(pearlSlot, InventoryType.Equipment);
if (fairy != null && pearl != null)
{
pearl.HoldingVNum = fairy.ItemVNum;
pearl.ElementRate = fairy.ElementRate;
session.Character.Inventory.RemoveItemFromInventory(fairy.Id);
}
}
}
else if (Type == 203 && Argument == 0)
{
// SP points initialization
int[] listPotionResetVNums = { 1366, 1427, 5115, 9040 };
int vnumToUse = -1;
foreach (int vnum in listPotionResetVNums)
{
if (session.Character.Inventory.CountItem(vnum) > 0)
{
vnumToUse = vnum;
}
}
if (vnumToUse != -1)
{
if (session.Character.UseSp)
{
ItemInstance specialistInstance =
session.Character.Inventory.LoadBySlotAndType((byte)EquipmentType.Sp,
InventoryType.Wear);
if (specialistInstance != null)
{
specialistInstance.SlDamage = 0;
specialistInstance.SlDefence = 0;
specialistInstance.SlElement = 0;
specialistInstance.SlHP = 0;
specialistInstance.DamageMinimum = 0;
specialistInstance.DamageMaximum = 0;
specialistInstance.HitRate = 0;
specialistInstance.CriticalLuckRate = 0;
specialistInstance.CriticalRate = 0;
specialistInstance.DefenceDodge = 0;
specialistInstance.DistanceDefenceDodge = 0;
specialistInstance.ElementRate = 0;
specialistInstance.DarkResistance = 0;
specialistInstance.LightResistance = 0;
specialistInstance.FireResistance = 0;
specialistInstance.WaterResistance = 0;
specialistInstance.CriticalDodge = 0;
specialistInstance.CloseDefence = 0;
specialistInstance.DistanceDefence = 0;
specialistInstance.MagicDefence = 0;
specialistInstance.HP = 0;
specialistInstance.MP = 0;
session.Character.Inventory.RemoveItemAmount(vnumToUse);
session.Character.Inventory.DeleteFromSlotAndType((byte)EquipmentType.Sp,
InventoryType.Wear);
session.Character.Inventory.AddToInventoryWithSlotAndType(specialistInstance,
InventoryType.Wear, (byte)EquipmentType.Sp);
session.SendPacket(session.Character.GenerateCond());
session.SendPacket(specialistInstance.GenerateSlInfo());
session.SendPacket(session.Character.GenerateLev());
session.SendPacket(session.Character.GenerateStatChar());
session.SendPacket(
UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("POINTS_RESET"),
0));
}
}
else
{
session.SendPacket(
session.Character.GenerateSay(
Language.Instance.GetMessageFromKey("TRANSFORMATION_NEEDED"), 10));
}
}
else
{
session.SendPacket(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("NOT_ENOUGH_POINTS"),
10));
}
}
}
private void ExecuteHandler(ClientSession session)
{
InventoryType equipment;
Mate mate = null;
if (Type >= 1 && Type <= 12)
{
// Partner inventories
equipment = (InventoryType)(Type + 12);
mate = session.Character.Mates.FirstOrDefault(s => s.PartnerSlot == (Type - 1) && s.MateType == MateType.Partner);
}
else
{
equipment = InventoryType.Wear;
}
if (session.HasCurrentMapInstance &&
session.CurrentMapInstance.UserShops.FirstOrDefault(mapshop =>
mapshop.Value.OwnerId.Equals(session.Character.CharacterId)).Value == null &&
(session.Character.ExchangeInfo == null ||
(session.Character.ExchangeInfo?.ExchangeList).Count == 0))
{
ItemInstance inventory =
session.Character.Inventory.LoadBySlotAndType(InventorySlot, equipment);
if (inventory != null)
{
double currentRunningSeconds =
(DateTime.UtcNow - Process.GetCurrentProcess().StartTime.AddHours(-2).AddSeconds(-50)).TotalSeconds;
double timeSpanSinceLastSpUsage = currentRunningSeconds - session.Character.LastSp;
if (Type == 0)
{
if (InventorySlot == (byte)EquipmentType.Sp && session.Character.UseSp)
{
if (session.Character.IsVehicled)
{
session.SendPacket(
UserInterfaceHelper.GenerateMsg(
Language.Instance.GetMessageFromKey("REMOVE_VEHICLE"), 0));
return;
}
if (session.Character.LastSkillUse.AddSeconds(2) > DateTime.UtcNow)
{
return;
}
session.Character.LastSp =
(DateTime.UtcNow - Process.GetCurrentProcess().StartTime.AddHours(-2).AddSeconds(-50)).TotalSeconds;
session.RemoveSp(inventory.ItemVNum);
}
else if (InventorySlot == (byte)EquipmentType.Sp &&
!session.Character.UseSp &&
timeSpanSinceLastSpUsage <= session.Character.SpCooldown)
{
session.SendPacket(UserInterfaceHelper.GenerateMsg(
string.Format(Language.Instance.GetMessageFromKey("SP_INLOADING"),
session.Character.SpCooldown - (int)Math.Round(timeSpanSinceLastSpUsage, 0)),
0));
return;
}
else if (InventorySlot == (byte)EquipmentType.Fairy &&
session.Character.IsUsingFairyBooster)
{
session.SendPacket(UserInterfaceHelper.GenerateMsg(
Language.Instance.GetMessageFromKey("REMOVE_FAIRY_WHILE_USING_BOOSTER"), 0));
return;
}
session.Character.EquipmentBCards.RemoveAll(o => o.ItemVNum == inventory.ItemVNum);
}
ItemInstance inv = session.Character.Inventory.MoveInInventory(InventorySlot,
equipment, InventoryType.Equipment);
if (inv == null)
{
session.SendPacket(
UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("NOT_ENOUGH_PLACE"),
0));
return;
}
if (inv.Slot != -1)
{
session.SendPacket(inventory.GenerateInventoryAdd());
}
if (Type == 0)
{
session.SendPacket(session.Character.GenerateStatChar());
session.CurrentMapInstance?.Broadcast(session.Character.GenerateEq());
session.SendPacket(session.Character.GenerateEquipment());
session.CurrentMapInstance?.Broadcast(session.Character.GeneratePairy());
}
else if (mate != null)
{
switch (inv.Item.EquipmentSlot)
{
case EquipmentType.Armor:
mate.ArmorInstance = null;
break;
case EquipmentType.MainWeapon:
mate.WeaponInstance = null;
break;
case EquipmentType.Gloves:
mate.GlovesInstance = null;
break;
case EquipmentType.Boots:
mate.BootsInstance = null;
break;
case EquipmentType.Sp:
mate.SpInstance = null;
mate.RemoveSp();
break;
}
session.SendPacket(mate.GenerateScPacket());
}
}
}
}
public GroupsBuilder WithMateAdmin(Mate mate)
{
_group.FriendGroupAdminUser = mate;
return(this);
}
public void CanMakePaymentPayPalTest()
{
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate
{
FirstName = "Miguel",
LastName = "Dev",
UserName = "******",
Password = "******",
Email = "*****@*****.**",
Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.",
Address = "Figueiró",
Categories = new[] { Categories.CLEANING, Categories.PLUMBING },
Rank = Ranks.SUPER_MATE,
Range = 20
};
Mate returned = MateDAO.Create(testMate);
IEmployerDAO <Employer> EmployerDAO = new EmployerDAO(_connection);
Employer testEmployer = new Employer
{
FirstName = "Marcelo",
LastName = "Carvalho",
UserName = "******",
Password = "******",
Email = "*****@*****.**",
Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.",
Address = "Lixa"
};
Employer returnedEmp = EmployerDAO.Create(testEmployer);
IJobDAO jobPostDAO = new JobDAO(_connection);
JobPost testPost = new JobPost
{
Title = "Canalização Estourada",
Category = Categories.PLUMBING,
ImagePath = "path/image",
Description = "Grande estouro nos canos da sanita",
Tradable = false,
InitialPrice = 60.6,
Address = "Rua sem fim",
PaymentMethod = new[] { Payment.PAYPAL, Payment.MONEY }
};
JobPost jobReturned = jobPostDAO.Create(returnedEmp.Id, testPost);
DateTime date = new DateTime(2020, 01, 16);
Job job = new Job
{
Date = date,
Mate = returned.Id,
JobPost = jobReturned.Id,
FinishedConfirmedByEmployer = false,
FinishedConfirmedByMate = false,
Employer = returnedEmp.Id
};
IWorkDAO workDAO = new WorkDAO(_connection);
Job returnedJob = workDAO.Create(returnedEmp.Id, job);
workDAO.MarkJobAsDone(returnedJob.Id, returnedEmp.Id);
workDAO.MarkJobAsDone(returnedJob.Id, returned.Id);
Invoice invoice = new Invoice
{
Value = 60.6,
PaymentType = Payment.PAYPAL
};
string email = "*****@*****.**";
string paypalLink = String.Format("https://www.sandbox.paypal.com/cgi-bin/webscr?cmd=_xclick&amount={0}¤cy_code=EUR&business={1}&item_name={2}&return=Page", testPost.InitialPrice, email, testPost.Title);
PaymentDAO paymentDAO = new PaymentDAO(_connection);
Invoice result = paymentDAO.makePayment(invoice, returnedJob.Id, returnedEmp.Id);
Assert.Equal(invoice.Value, result.Value);
Assert.Equal(invoice.PaymentType, result.PaymentType);
Assert.False(result.ConfirmedPayment);
Assert.Equal(paypalLink, result.Link);
_fixture.Dispose();
}
private void ExecuteHandler(ClientSession session)
{
PenaltyLogDTO penalty = session.Account.PenaltyLogs.OrderByDescending(s => s.DateEnd).FirstOrDefault();
if (session.Character.IsMuted() && penalty != null)
{
if (session.Character.Gender == GenderType.Female)
{
session.CurrentMapInstance?.Broadcast(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_FEMALE"), 1));
session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
}
else
{
session.CurrentMapInstance?.Broadcast(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_MALE"), 1));
session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
}
return;
}
Mate attacker = session.Character.Mates.FirstOrDefault(x => x.MateTransportId == MateTransportId);
if (attacker == null)
{
return;
}
NpcMonsterSkill mateSkill = null;
if (attacker.Monster.Skills.Any())
{
mateSkill = attacker.Monster.Skills.FirstOrDefault(sk => MateHelper.Instance.PetSkills.Contains(sk.SkillVNum));
}
if (mateSkill == null)
{
mateSkill = new NpcMonsterSkill
{
SkillVNum = 200
};
}
if (attacker.IsSitting)
{
return;
}
MapMonster target = session.CurrentMapInstance?.GetMonster(TargetId);
switch (TargetType)
{
case UserType.Monster:
case UserType.Npc:
if (attacker.Hp <= 0)
{
return;
}
if (target != null)
{
session.CurrentMapInstance.Broadcast(StaticPacketHelper.CastOnTarget(UserType.Npc, attacker.MateTransportId, 3, target.MapMonsterId, mateSkill.Skill.CastAnimation, mateSkill.Skill.CastEffect, mateSkill.SkillVNum));
session.CurrentMapInstance.Broadcast(StaticPacketHelper.SkillUsed(UserType.Npc, attacker.MateTransportId, 3, target.MapMonsterId, mateSkill.SkillVNum, mateSkill.Skill.Cooldown, mateSkill.Skill.AttackAnimation, mateSkill.Skill.Effect, target.MapX, target.MapY, target.CurrentHp > 0, (int)(target.CurrentHp / (double)target.MaxHp * 100), 0, 0, 0));
}
session.AttackMonster(attacker, mateSkill.Skill, TargetId, target?.MapX ?? attacker.PositionX, target?.MapY ?? attacker.PositionY);
session.SendPacketAfter("petsr 0", mateSkill.Skill.Cooldown * 100);
return;
case UserType.Player:
if (attacker.Hp <= 0)
{
return;
}
Character targetChar = session.CurrentMapInstance?.GetSessionByCharacterId(TargetId)
?.Character;
if (targetChar != null && session.CurrentMapInstance != null &&
(targetChar.Session.CurrentMapInstance == session.CurrentMapInstance &&
targetChar.CharacterId != session.Character.CharacterId &&
session.CurrentMapInstance.Map.MapTypes.Any(s =>
s.MapTypeId == (short)MapTypeEnum.Act4) && session.Character.Faction !=
targetChar.Faction && session.CurrentMapInstance.Map
.MapId != 130 && session.CurrentMapInstance.Map
.MapId != 131 ||
session.CurrentMapInstance.Map.MapTypes.Any(m =>
m.MapTypeId == (short)MapTypeEnum.PvpMap) &&
(session.Character.Group == null ||
!session.Character.Group
.IsMemberOfGroup(
targetChar.CharacterId)) ||
session.CurrentMapInstance.IsPvp && (session.Character.Group == null ||
!session.Character.Group.IsMemberOfGroup(
targetChar.CharacterId))))
{
session.AttackCharacter(attacker, mateSkill, targetChar);
}
return;
case UserType.Object:
return;
default:
return;
}
}
public void AttackCharacter(Mate attacker, NpcMonsterSkill skill, Character target)
{
}
public void CanDeleteWorkTest()
{
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Miguel";
testMate.LastName = "Dev";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testMate.Address = "Figueiró";
testMate.Categories = new[] { Categories.CLEANING, Categories.PLUMBING };
testMate.Rank = Ranks.SUPER_MATE;
testMate.Range = 20;
Mate returned = MateDAO.Create(testMate);
IEmployerDAO <Employer> EmployerDAO = new EmployerDAO(_connection);
Employer testEmployer = new Employer();
testEmployer.FirstName = "Marcelo";
testEmployer.LastName = "Carvalho";
testEmployer.UserName = "******";
testEmployer.Password = "******";
testEmployer.Email = "*****@*****.**";
testEmployer.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testEmployer.Address = "Lixa";
Employer returnedEmp = EmployerDAO.Create(testEmployer);
IJobDAO jobPostDAO = new JobDAO(_connection);
JobPost testPost = new JobPost();
testPost.Title = "Canalização Estourada";
testPost.Category = Categories.PLUMBING;
testPost.ImagePath = "path/image";
testPost.Description = "Grande estouro nos canos da sanita";
testPost.Tradable = true;
testPost.InitialPrice = 60.6;
testPost.Address = "Rua sem fim";
testPost.PaymentMethod = new[] { Payment.PAYPAL, Payment.MONEY };
JobPost jobReturned = jobPostDAO.Create(returnedEmp.Id, testPost);
DateTime date = new DateTime(2020, 01, 16);
Job job = new Job();
job.Date = date;
job.Mate = returned.Id;
job.JobPost = jobReturned.Id;
job.FinishedConfirmedByEmployer = false;
job.FinishedConfirmedByMate = false;
job.Employer = returnedEmp.Id;
IWorkDAO workDAO = new WorkDAO(_connection);
Job created = workDAO.Create(returnedEmp.Id, job);
Assert.True(workDAO.Delete(created.Id));
_fixture.Dispose();
}
public void CanSearchWithoutAddressTest()
{
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate firstMate = new Mate();
firstMate.FirstName = "Marcelo";
firstMate.LastName = "Carvalho";
firstMate.UserName = "******";
firstMate.Password = "******";
firstMate.Email = "*****@*****.**";
firstMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
firstMate.Address = "Rua Eng. Luís Carneiro Leão, Figueiró";
firstMate.Categories = new[] { Categories.CLEANING, Categories.ELECTRICITY };
firstMate.Rank = Ranks.MATE;
firstMate.Range = 50;
Mate returnedFirst = MateDAO.Create(firstMate);
using (SqlCommand cmd = _connection.Fetch().CreateCommand())
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = "UPDATE dbo.[User] SET AverageRating = @Ar " +
"WHERE Id = @id";
cmd.Parameters.Add("@id", SqlDbType.Int).Value = returnedFirst.Id;
cmd.Parameters.Add("@Ar", SqlDbType.NVarChar).Value = 4;
cmd.ExecuteNonQuery();
}
Mate secondMate = new Mate();
secondMate.FirstName = "Samuel";
secondMate.LastName = "Cunha";
secondMate.UserName = "******";
secondMate.Password = "******";
secondMate.Email = "*****@*****.**";
secondMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
secondMate.Address = "Vila Nova de Gaia";
secondMate.Categories = new[] { Categories.GARDENING, Categories.FURNITURE_ASSEMBLE };
secondMate.Rank = Ranks.SUPER_MATE;
secondMate.Range = 20;
MateDAO.Create(secondMate);
Categories[] categories = { Categories.CLEANING, Categories.GARDENING };
List <Mate> mates = MateDAO.GetMates(categories, null, Ranks.MATE, 40, 4);
Mate[] matesArray = mates.ToArray();
Assert.Equal(returnedFirst.FirstName, matesArray[0].FirstName);
Assert.Equal(returnedFirst.LastName, matesArray[0].LastName);
Assert.Equal(returnedFirst.UserName, matesArray[0].UserName);
Assert.Equal(returnedFirst.Email, matesArray[0].Email);
Assert.Equal(returnedFirst.Description, matesArray[0].Description);
Assert.Equal(returnedFirst.Address, matesArray[0].Address);
Array.Reverse(matesArray[0].Categories);
Assert.Equal(returnedFirst.Categories, matesArray[0].Categories);
Assert.Equal(returnedFirst.Rank, matesArray[0].Rank);
Assert.Equal(returnedFirst.Range, matesArray[0].Range);
Assert.Single(matesArray);
_fixture.Dispose();
}
private void ExecuteHandler(ClientSession session)
{
PenaltyLogDTO penalty = session.Account.PenaltyLogs.OrderByDescending(s => s.DateEnd).FirstOrDefault();
if (session.Character.IsMuted() && penalty != null)
{
if (session.Character.Gender == GenderType.Female)
{
session.CurrentMapInstance?.Broadcast(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_FEMALE"), 1));
session.SendPacket(session.Character.GenerateSay(
string.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"),
(penalty.DateEnd - DateTime.UtcNow).ToString("hh\\:mm\\:ss")), 11));
}
else
{
session.CurrentMapInstance?.Broadcast(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_MALE"), 1));
session.SendPacket(session.Character.GenerateSay(
string.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"),
(penalty.DateEnd - DateTime.UtcNow).ToString("hh\\:mm\\:ss")), 11));
}
return;
}
Mate attacker = session.Character.Mates.First(x => x.MateTransportId == MateTransportId);
if (attacker != null)
{
switch (TargetType)
{
case UserType.Monster:
if (attacker.IsAlive)
{
MapMonster target = session.CurrentMapInstance?.GetMonster(TargetId);
NpcMonsterSkill skill = attacker.Monster.Skills.Find(x => x.NpcMonsterSkillId == CastId);
session.AttackMonster(attacker, skill?.Skill, target);
}
return;
case UserType.Player:
if (attacker.IsAlive)
{
Character target = session.CurrentMapInstance?.GetSessionByCharacterId(TargetId)
?.Character;
if (target != null && session.CurrentMapInstance != null &&
((target.Session.CurrentMapInstance == session.CurrentMapInstance &&
target.CharacterId != session.Character.CharacterId &&
session.CurrentMapInstance.Map.MapTypes.Any(s =>
s.MapTypeId == (short)MapTypeEnum.Act4) && session.Character.Faction
!= target.Faction && session.CurrentMapInstance.Map
.MapId != 130 && session.CurrentMapInstance.Map
.MapId != 131) ||
(session.CurrentMapInstance.Map.MapTypes.Any(m =>
m.MapTypeId == (short)MapTypeEnum.PvpMap) &&
(session.Character.Group?
.IsMemberOfGroup(
target.CharacterId) != true)) ||
(session.CurrentMapInstance.IsPvp && (session.Character.Group?.IsMemberOfGroup(
target.CharacterId) != true))))
{
NpcMonsterSkill skill = attacker.Monster.Skills.Find(x => x.NpcMonsterSkillId == CastId);
session.AttackCharacter(attacker, skill?.Skill, target);
}
}
return;
case UserType.Npc:
case UserType.Object:
return;
}
}
}
private void ExecuteHandler(ClientSession session)
{
PenaltyLogDTO penalty = session.Account.PenaltyLogs.OrderByDescending(s => s.DateEnd).FirstOrDefault();
if (session.Character.IsMuted() && penalty != null)
{
if (session.Character.Gender == GenderType.Female)
{
session.CurrentMapInstance?.Broadcast(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_FEMALE"), 1));
session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
}
else
{
session.CurrentMapInstance?.Broadcast(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_MALE"), 1));
session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
}
return;
}
Mate attacker = session.Character.Mates.FirstOrDefault(x => x.MateTransportId == MateTransportId);
if (attacker?.SpInstance == null || !attacker.IsUsingSp)
{
return;
}
short?skillVnum = null;
byte value = 0;
switch (SkillSlot)
{
case 0:
skillVnum = attacker.SpInstance.FirstPartnerSkill;
value = 0;
break;
case 1:
skillVnum = attacker.SpInstance.SecondPartnerSkill;
value = 1;
break;
case 2:
skillVnum = attacker.SpInstance.ThirdPartnerSkill;
value = 2;
break;
}
if (skillVnum == null)
{
return;
}
var mateSkill = ServerManager.GetSkill(skillVnum.Value);
if (mateSkill == null)
{
return;
}
session.SendPacketAfter($"psr {value}", mateSkill.Cooldown * 100);
if (attacker.IsSitting)
{
return;
}
attacker.Owner.MapInstance.Broadcast(StaticPacketHelper.GenerateEff(UserType.Npc, attacker.MateTransportId, 5005), attacker.PositionX, attacker.PositionY);
switch (TargetType)
{
case UserType.Monster:
if (attacker.Hp <= 0)
{
return;
}
var target = session.Character.MapInstance.GetMonster(TargetId);
if (target != null)
{
session.CurrentMapInstance.Broadcast(StaticPacketHelper.CastOnTarget(UserType.Npc, attacker.MateTransportId, 3, target.MapMonsterId, mateSkill.CastAnimation, mateSkill.CastEffect, mateSkill.SkillVNum));
session.CurrentMapInstance.Broadcast(StaticPacketHelper.SkillUsed(UserType.Npc, attacker.MateTransportId, 3, target.MapMonsterId, mateSkill.SkillVNum, mateSkill.Cooldown, mateSkill.AttackAnimation, mateSkill.Effect, target.MapX, target.MapY, target.CurrentHp > 0, (int)(target.CurrentHp / (double)target.MaxHp * 100), 0, 0, 0));
}
session.AttackMonster(attacker, mateSkill, TargetId, target?.MapX ?? attacker.PositionX, target?.MapY ?? attacker.PositionY);
return;
case UserType.Npc:
if (attacker.Hp <= 0)
{
return;
}
var npcTarget = session.Character.MapInstance.GetNpc(TargetId);
if (npcTarget != null)
{
session.CurrentMapInstance.Broadcast(StaticPacketHelper.CastOnTarget(UserType.Npc, attacker.MateTransportId, 3, npcTarget.MapNpcId, mateSkill.CastAnimation, mateSkill.CastEffect, mateSkill.SkillVNum));
session.CurrentMapInstance.Broadcast(StaticPacketHelper.SkillUsed(UserType.Npc, attacker.MateTransportId, 3, npcTarget.MapNpcId, mateSkill.SkillVNum, mateSkill.Cooldown, mateSkill.AttackAnimation, mateSkill.Effect, npcTarget.MapX, npcTarget.MapY, true, 100, 0, 0, 0));
}
session.AttackMonster(attacker, mateSkill, TargetId, npcTarget?.MapX ?? attacker.PositionX, npcTarget?.MapY ?? attacker.PositionY);
return;
case UserType.Player:
return;
case UserType.Object:
return;
default:
return;
}
}
public void CanSearchMateWithMultipleCategoriesAndAddressTest()
{
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate firstMate = new Mate();
firstMate.FirstName = "Marcelo";
firstMate.LastName = "Carvalho";
firstMate.UserName = "******";
firstMate.Password = "******";
firstMate.Email = "*****@*****.**";
firstMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
firstMate.Address = "Sra. Aparecida, Lousada";
firstMate.Categories = new[] { Categories.CLEANING, Categories.ELECTRICITY };
firstMate.Rank = Ranks.SUPER_MATE;
firstMate.Range = 50;
Mate returnedFirst = MateDAO.Create(firstMate);
Mate secondMate = new Mate();
secondMate.FirstName = "Samuel";
secondMate.LastName = "Cunha";
secondMate.UserName = "******";
secondMate.Password = "******";
secondMate.Email = "*****@*****.**";
secondMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
secondMate.Address = "Rua de Salgueiros, Penafiel";
secondMate.Categories = new[] { Categories.GARDENING, Categories.FURNITURE_ASSEMBLE };
secondMate.Rank = Ranks.SUPER_MATE;
secondMate.Range = 20;
Mate returnedSecond = MateDAO.Create(secondMate);
Categories[] categories = { Categories.CLEANING, Categories.GARDENING };
string myAddress = "Rua de Salgueiros, Penafiel";
List <Mate> mates = MateDAO.GetMates(categories, myAddress, null, null, null);
Mate[] matesArray = mates.ToArray();
Assert.Equal(returnedFirst.FirstName, matesArray[0].FirstName);
Assert.Equal(returnedFirst.LastName, matesArray[0].LastName);
Assert.Equal(returnedFirst.UserName, matesArray[0].UserName);
Assert.Equal(returnedFirst.Email, matesArray[0].Email);
Assert.Equal(returnedFirst.Description, matesArray[0].Description);
Assert.Equal(returnedFirst.Address, matesArray[0].Address);
Array.Reverse(matesArray[0].Categories);
Assert.Equal(returnedFirst.Categories, matesArray[0].Categories);
Assert.Equal(returnedFirst.Rank, matesArray[0].Rank);
Assert.Equal(returnedFirst.Range, matesArray[0].Range);
Assert.Equal(returnedSecond.FirstName, matesArray[1].FirstName);
Assert.Equal(returnedSecond.LastName, matesArray[1].LastName);
Assert.Equal(returnedSecond.UserName, matesArray[1].UserName);
Assert.Equal(returnedSecond.Email, matesArray[1].Email);
Assert.Equal(returnedSecond.Description, matesArray[1].Description);
Assert.Equal(returnedSecond.Address, matesArray[1].Address);
Assert.Equal(returnedSecond.Categories, matesArray[1].Categories);
Assert.Equal(returnedSecond.Rank, matesArray[1].Rank);
Assert.Equal(returnedSecond.Range, matesArray[1].Range);
_fixture.Dispose();
}
private void ExecuteHandler(ClientSession session)
{
switch (Type)
{
// characters
case 1:
session.SendPacket(ServerManager.Instance.GetSessionByCharacterId(TargetId)?.Character
?.GenerateStatInfo());
break;
// npcs/mates
case 2:
if (session.HasCurrentMapInstance)
{
session.CurrentMapInstance.Npcs.Where(n => n.MapNpcId == (int)TargetId).ToList()
.ForEach(npc =>
{
NpcMonster npcinfo = ServerManager.GetNpcMonster(npc.NpcVNum);
if (npcinfo == null)
{
return;
}
session.Character.LastNpcMonsterId = npc.MapNpcId;
session.SendPacket(
$"st 2 {TargetId} {npcinfo.Level} {npcinfo.HeroLevel} 100 100 50000 50000");
});
Parallel.ForEach(session.CurrentMapInstance.Sessions, sess =>
{
Mate mate = sess.Character.Mates.Find(
s => s.MateTransportId == (int)TargetId);
if (mate != null)
{
session.SendPacket(mate.GenerateStatInfo());
}
});
}
break;
// monsters
case 3:
if (session.HasCurrentMapInstance)
{
session.CurrentMapInstance.Monsters.Where(m => m.MapMonsterId == (int)TargetId)
.ToList().ForEach(monster =>
{
NpcMonster monsterinfo = ServerManager.GetNpcMonster(monster.MonsterVNum);
if (monsterinfo == null)
{
return;
}
session.Character.LastNpcMonsterId = monster.MapMonsterId;
session.SendPacket(
$"st 3 {TargetId} {monsterinfo.Level} {monsterinfo.HeroLevel} {(int)(monster.CurrentHp / (float)monster.MaxHp * 100)} {(int)(monster.CurrentMp / (float)monster.MaxMp * 100)} {monster.CurrentHp} {monster.CurrentMp}{monster.Buff.GetAllItems().Aggregate(string.Empty, (current, buff) => current + $" {buff.Card.CardId}")}");
});
}
break;
}
}
public ZDDNode(Mate mate)
{
mate_ = mate;
}
public override void Use(ClientSession session, ref ItemInstance inv, byte option = 0, string[] packetsplit = null)
{
inv.Item.BCards.ForEach(c => c.ApplyBCards(session.Character));
switch (Effect)
{
case 0:
switch (VNum)
{
case 5370:
if (session.Character.Buff.Any(s => s.Card.CardId == 393))
{
session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("ALREADY_GOT_BUFF"), session.Character.Buff.FirstOrDefault(s => s.Card.CardId == 393)?.Card.Name), 10));
return;
}
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
session.Character.AddStaticBuff(new StaticBuffDTO {
CardId = 393
});
break;
case 1428:
session.SendPacket("guri 18 1");
break;
case 1429:
session.SendPacket("guri 18 0");
break;
case 1430:
if (packetsplit == null)
{
return;
}
if (packetsplit.Length < 9)
{
// MODIFIED PACKET
return;
}
if (!short.TryParse(packetsplit[9], out short eqSlot) || !Enum.TryParse(packetsplit[8], out InventoryType eqType))
{
return;
}
WearableInstance eq = session.Character.Inventory.LoadBySlotAndType <WearableInstance>(eqSlot, eqType);
if (eq == null)
{
// PACKET MODIFIED
return;
}
if (eq.Item.ItemType != ItemType.Armor && eq.Item.ItemType != ItemType.Weapon)
{
return;
}
eq.EquipmentOptions.Clear();
eq.ShellRarity = null;
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("SHELL_ERASED"), 0));
session.SendPacket(UserInterfaceHelper.Instance.GenerateGuri(17, 1, session.Character.CharacterId));
break;
case 1904:
short[] items = { 1894, 1895, 1896, 1897, 1898, 1899, 1900, 1901, 1902, 1903 };
for (int i = 0; i < 5; i++)
{
session.Character.GiftAdd(items[ServerManager.Instance.RandomNumber(0, items.Length)], 1);
}
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
break;
case 5916:
session.Character.AddStaticBuff(new StaticBuffDTO
{
CardId = 340,
CharacterId = session.Character.CharacterId,
RemainingTime = 7200
});
session.Character.RemoveBuff(339, true);
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
break;
case 5929:
session.Character.AddStaticBuff(new StaticBuffDTO
{
CardId = 340,
CharacterId = session.Character.CharacterId,
RemainingTime = 600
});
session.Character.RemoveBuff(339, true);
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
break;
default:
IEnumerable <RollGeneratedItemDTO> roll = DaoFactory.RollGeneratedItemDao.LoadByItemVNum(VNum);
IEnumerable <RollGeneratedItemDTO> rollGeneratedItemDtos = roll as IList <RollGeneratedItemDTO> ?? roll.ToList();
if (!rollGeneratedItemDtos.Any())
{
return;
}
int probabilities = rollGeneratedItemDtos.Sum(s => s.Probability);
int rnd = ServerManager.Instance.RandomNumber(0, probabilities);
int currentrnd = 0;
foreach (RollGeneratedItemDTO rollitem in rollGeneratedItemDtos)
{
if (rollitem.Probability == 10000)
{
session.Character.GiftAdd(rollitem.ItemGeneratedVNum, rollitem.ItemGeneratedAmount);
continue;
}
currentrnd += rollitem.Probability;
if (currentrnd < rnd)
{
continue;
}
if (rollitem.IsSuperReward)
{
CommunicationServiceClient.Instance.SendMessageToCharacter(new SCSCharacterMessage
{
DestinationCharacterId = null,
SourceCharacterId = session.Character.CharacterId,
SourceWorldId = ServerManager.Instance.WorldId,
Message = Language.Instance.GetMessageFromKey("SUPER_REWARD"),
Type = MessageType.Shout
});
}
session.Character.GiftAdd(rollitem.ItemGeneratedVNum, rollitem.ItemGeneratedAmount, 0, rollitem.ItemGeneratedUpgrade);
break;
}
session.Character.Inventory.RemoveItemAmount(VNum);
break;
}
break;
// sp point potions
case 150:
case 151:
session.Character.SpAdditionPoint += EffectValue;
if (session.Character.SpAdditionPoint > 1000000)
{
session.Character.SpAdditionPoint = 1000000;
}
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(string.Format(Language.Instance.GetMessageFromKey("SP_POINTSADDED"), EffectValue), 0));
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
session.SendPacket(session.Character.GenerateSpPoint());
break;
case 204:
session.Character.SpPoint += EffectValue;
session.Character.SpAdditionPoint += EffectValue * 3;
if (session.Character.SpAdditionPoint > 1000000)
{
session.Character.SpAdditionPoint = 1000000;
}
if (session.Character.SpPoint > 10000)
{
session.Character.SpPoint = 10000;
}
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(string.Format(Language.Instance.GetMessageFromKey("SP_POINTSADDEDBOTH"), EffectValue, EffectValue * 3), 0));
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
session.SendPacket(session.Character.GenerateSpPoint());
break;
case 250:
if (session.Character.Buff.Any(s => s.Card.CardId == 131))
{
session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("ALREADY_GOT_BUFF"), session.Character.Buff.FirstOrDefault(s => s.Card.CardId == 131)?.Card.Name), 10));
return;
}
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
session.Character.AddStaticBuff(new StaticBuffDTO {
CardId = 131
});
session.CurrentMapInstance.Broadcast(session.Character.GeneratePairy());
session.SendPacket(session.Character.GeneratePairy());
break;
case 208:
if (session.Character.Buff.Any(s => s.Card.CardId == 121))
{
session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("ALREADY_GOT_BUFF"), session.Character.Buff.FirstOrDefault(s => s.Card.CardId == 121)?.Card.Name), 10));
return;
}
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
session.Character.AddStaticBuff(new StaticBuffDTO {
CardId = 121, CharacterId = session.Character.CharacterId, RemainingTime = 3600
});
break;
case 301:
if (ServerManager.Instance.IsCharacterMemberOfGroup(session.Character.CharacterId))
{
//TODO you are in group
return;
}
ItemInstance raidSeal = session.Character.Inventory.LoadBySlotAndType <ItemInstance>(inv.Slot, InventoryType.Main);
ScriptedInstance raid = ServerManager.Instance?.Raids?.FirstOrDefault(s =>
{
return(s?.RequieredItems != null && s.RequieredItems.Any(obj => obj?.VNum == raidSeal?.ItemVNum));
})?.GetClone();
if (raid != null)
{
session.Character.Inventory.RemoveItemAmountFromInventory(1, raidSeal.Id);
GroupType groupType = GroupType.Team;
switch (raidSeal.Item.EffectValue)
{
case 20:
groupType = GroupType.GiantTeam;
break;
case 23:
groupType = GroupType.BigTeam;
break;
}
Group group = new Group(groupType);
group.Raid = raid;
group.JoinGroup(session.Character.CharacterId);
ServerManager.Instance.AddGroup(group);
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(string.Format(Language.Instance.GetMessageFromKey("YOU_ARE_RAID_CHIEF"), session.Character.Name), 0));
session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("YOU_ARE_RAID_CHIEF"), session.Character.Name), 10));
if (session.Character.Level > raid.LevelMaximum || session.Character.Level < raid.LevelMinimum)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("RAID_LEVEL_INCORRECT"), 10));
}
session.SendPacket(session.Character.GenerateRaid(2, false));
session.SendPacket(session.Character.GenerateRaid(0, false));
session.SendPacket(session.Character.GenerateRaid(1, false));
session.SendPacket(group.GenerateRdlst());
}
break;
case 305:
Mate partner = session.Character.Mates
.FirstOrDefault(x => x.IsTeamMember && (x.NpcMonsterVNum == 317 || x.NpcMonsterVNum == 318 || x.NpcMonsterVNum == 319) && x.MateType == MateType.Partner);
if (partner == null)
{
return;
}
switch (partner.NpcMonsterVNum)
{
case 317:
if (inv.Item.VNum == 1103 && partner.Skin != inv.Item.Morph)
{
partner.Skin = inv.Item.Morph;
}
else
{
return;
}
break;
case 318:
if (inv.Item.VNum == 1141 && partner.Skin != inv.Item.Morph)
{
partner.Skin = inv.Item.Morph;
}
else
{
return;
}
break;
case 319:
if (inv.Item.VNum == 1142 && partner.Skin != inv.Item.Morph)
{
partner.Skin = inv.Item.Morph;
}
else
{
return;
}
break;
}
session.Character?.Inventory?.RemoveItemAmountFromInventory(1, inv.Id);
session.CurrentMapInstance?.Broadcast(partner.GenerateCMode(partner.Skin));
break;
//suction Funnel (Quest Item / QuestId = 1724)
case 400:
if (session.Character == null || session.Character.Quests.All(q => q.QuestId != 1724))
{
break;
}
MapMonster kenko = session.CurrentMapInstance?.Monsters.FirstOrDefault(m => m.MapMonsterId == session.Character.LastMonsterId && m.MonsterVNum == 146);
if (kenko == null)
{
break;
}
kenko.GenerateDeath(session.Character);
kenko.GenerateOut();
session.Character.Inventory.AddNewToInventory(1174); // Kenko Bead
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
break;
//speed booster
case 998:
if (!session.Character.IsVehicled || session.Character.Buff.Any(s => s.Card.CardId == 336))
{
return;
}
session.CurrentMapInstance?.Broadcast(session.Character.GenerateEff(885), session.Character.MapX, session.Character.MapY);
session.Character.AddBuff(new Buff.Buff(336));
session.Character.Speed += 5;
switch (session.Character.Morph)
{
case 2517: // Nossi M
case 2518: // Nossi F
case 2522: // Roller M
case 2523: // Roller F
// Removes <= lv 4 debuffs
List <BuffType> bufftodisable = new List <BuffType> {
BuffType.Bad
};
session.Character.DisableBuffs(bufftodisable, 4);
break;
}
Observable.Timer(TimeSpan.FromSeconds(session.Character.BuffRandomTime * 0.1D)).Subscribe(o =>
{
session.Character.Speed -= 5;
session.Character.LoadSpeed();
switch (session.Character.Morph)
{
case 2526: // White male unicorn
case 2527: // White female unicorn
case 2528: // Pink male unicorn
case 2529: // Pink female unicorn
case 2530: // Black male unicorn
case 2531: // Black Female Unicorn
case 2928: // Male UFO
case 2929: // Female UFO
case 3679: // Male squelettic dragon
case 3680: // Female squelettic dragon
ServerManager.Instance.TeleportOnRandomPlaceInMap(session, session.Character.MapInstanceId, true);
break;
case 2432: // Magic broom
case 2433: // Magic broom F
case 2520: // VTT M
case 2521: // VTT F
switch (session.Character.Direction)
{
case 0:
// -y
ServerManager.Instance.TeleportForward(session, session.Character.MapInstanceId, session.Character.PositionX, (short)(session.Character.PositionY - 5));
break;
case 1:
// +x
ServerManager.Instance.TeleportForward(session, session.Character.MapInstanceId, (short)(session.Character.PositionX + 5), session.Character.PositionY);
break;
case 2:
// +y
ServerManager.Instance.TeleportForward(session, session.Character.MapInstanceId, session.Character.PositionX, (short)(session.Character.PositionY + 5));
break;
case 3:
// -x
ServerManager.Instance.TeleportForward(session, session.Character.MapInstanceId, (short)(session.Character.PositionX - 5), session.Character.PositionY);
break;
case 4:
ServerManager.Instance.TeleportForward(session, session.Character.MapInstanceId, (short)(session.Character.PositionX - 5), (short)(session.Character.PositionY - 5));
// -x -y
break;
case 5:
// +x +y
ServerManager.Instance.TeleportForward(session, session.Character.MapInstanceId, (short)(session.Character.PositionX - 5), (short)(session.Character.PositionY - 5));
break;
case 6:
// +x -y
ServerManager.Instance.TeleportForward(session, session.Character.MapInstanceId, (short)(session.Character.PositionX + 5), (short)(session.Character.PositionY + 5));
break;
case 7:
// -x +y
ServerManager.Instance.TeleportForward(session, session.Character.MapInstanceId, (short)(session.Character.PositionX - 5), (short)(session.Character.PositionY + 5));
break;
}
break;
case 2524:
case 2525:
if (session.Character.Hp > 0)
{
session.Character.Hp += session.Character.Level * 15;
if (session.Character.Hp > session.Character.HpLoad())
{
session.Character.Hp = (int)session.Character.HpLoad();
}
}
break;
}
});
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
break;
//Atk/Def/HP/Exp potions
case 6600:
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
break;
// Divorce letter
case 6969: // this is imaginary number I = √(-1)
CharacterRelationDTO rel = session.Character.CharacterRelations.FirstOrDefault(s => s.RelationType == CharacterRelationType.Spouse);
if (rel != null)
{
session.Character.DeleteRelation(rel.CharacterId == session.Character.CharacterId ? rel.RelatedCharacterId : rel.CharacterId);
session.SendPacket(UserInterfaceHelper.Instance.GenerateInfo(Language.Instance.GetMessageFromKey("DIVORCED")));
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
}
break;
// Cupid's arrow
case 34:
if (packetsplit != null && packetsplit.Length > 3)
{
if (long.TryParse(packetsplit[3], out long characterId))
{
if (session.Character.CharacterRelations.Any(s => s.RelationType == CharacterRelationType.Spouse))
{
session.SendPacket($"info {Language.Instance.GetMessageFromKey("ALREADY_MARRIED")}");
return;
}
ClientSession otherSession = ServerManager.Instance.GetSessionByCharacterId(characterId);
if (otherSession != null)
{
otherSession.SendPacket(UserInterfaceHelper.Instance.GenerateDialog(
$"#fins^-34^{session.Character.CharacterId} #fins^-69^{session.Character.CharacterId} {string.Format(Language.Instance.GetMessageFromKey("MARRY_REQUEST"), session.Character.Name)}"));
session.Character.FriendRequestCharacters.Add(characterId);
//session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
}
}
}
break;
case 570:
if (session.CurrentMapInstance?.MapInstanceType == MapInstanceType.Act4Instance)
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("MUST_BE_IN_CLASSIC_MAP"), 0));
return;
}
if (EffectValue < 3)
{
if (session.Character.Faction == (FactionType)EffectValue)
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("SAME_FACTION"), 0));
return;
}
session.SendPacket(session.Character.Family == null
? $"qna #guri^750^{EffectValue} {Language.Instance.GetMessageFromKey($"ASK_CHANGE_FACTION{EffectValue}")}"
: UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("IN_FAMILY"),
0));
}
else
{
if (session.Character.Family == null)
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("NO_FAMILY"), 0));
return;
}
if (session.Character.Family.FamilyFaction / 2 == EffectValue)
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("SAME_FACTION"), 0));
return;
}
session.SendPacket(session.Character.Family != null
? $"qna #guri^750^{EffectValue} {Language.Instance.GetMessageFromKey($"ASK_CHANGE_FACTION{EffectValue}")}"
: UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("NOT_IN_FAMILY"),
0));
}
break;
// wings
case 650:
if (session.Character.UseSp && session.Character.SpInstance != null)
{
if (option == 0)
{
session.SendPacket($"qna #u_i^1^{session.Character.CharacterId}^{(byte)inv.Type}^{inv.Slot}^3 {Language.Instance.GetMessageFromKey("ASK_WINGS_CHANGE")}");
}
else
{
session.Character.SpInstance.Design = (byte)EffectValue;
session.Character.MorphUpgrade2 = EffectValue;
session.CurrentMapInstance?.Broadcast(session.Character.GenerateCMode());
session.SendPacket(session.Character.GenerateStat());
session.SendPacket(session.Character.GenerateStatChar());
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
}
}
else
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("NO_SP"), 0));
}
break;
// presentation messages
case 203:
if (!session.Character.IsVehicled)
{
if (option == 0)
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateGuri(10, 2, session.Character.CharacterId, 1));
}
}
break;
// magic lamps
case 651:
if (session.Character.Inventory.All(i => i.Value.Type != InventoryType.Wear))
{
if (option == 0)
{
session.SendPacket($"qna #u_i^1^{session.Character.CharacterId}^{(byte)inv.Type}^{inv.Slot}^3 {Language.Instance.GetMessageFromKey("ASK_USE")}");
}
else
{
session.Character.ChangeSex();
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
}
}
else
{
session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("EQ_NOT_EMPTY"), 0));
}
break;
// vehicles
case 1000:
if (session.Character.HasShopOpened)
{
return;
}
if (Morph > 0)
{
if (option == 0 && !session.Character.IsVehicled)
{
if (session.Character.IsSitting)
{
session.Character.IsSitting = false;
session.CurrentMapInstance?.Broadcast(session.Character.GenerateRest());
}
session.Character.LastDelay = DateTime.Now;
session.SendPacket(UserInterfaceHelper.Instance.GenerateDelay(3000, 3, $"#u_i^1^{session.Character.CharacterId}^{(byte)inv.Type}^{inv.Slot}^2"));
}
else
{
if (!session.Character.IsVehicled && option != 0)
{
DateTime delay = DateTime.Now.AddSeconds(-4);
if (session.Character.LastDelay > delay && session.Character.LastDelay < delay.AddSeconds(2))
{
session.Character.Speed = Speed;
session.Character.IsVehicled = true;
session.Character.VehicleSpeed = Speed;
session.Character.MorphUpgrade = 0;
session.Character.MorphUpgrade2 = 0;
session.Character.Morph = Morph + (byte)session.Character.Gender;
session.Character.Mates?.ForEach(x => session.CurrentMapInstance?.Broadcast(x.GenerateOut()));
session.CurrentMapInstance?.Broadcast(session.Character.GenerateEff(196), session.Character.MapX, session.Character.MapY);
session.CurrentMapInstance?.Broadcast(session.Character.GenerateCMode());
session.SendPacket(session.Character.GenerateCond());
session.Character.LastSpeedChange = DateTime.Now;
}
}
else if (session.Character.IsVehicled)
{
session.Character.Mates?.Where(s => s.IsTeamMember).ToList().ForEach(x =>
{
x.PositionX = session.Character.PositionX;
x.PositionY = session.Character.PositionY;
session.CurrentMapInstance?.Broadcast(x.GenerateIn());
});
session.Character.RemoveVehicle();
}
}
}
break;
case 1002:
if (session.HasCurrentMapInstance)
{
if (session.CurrentMapInstance.Map.MapTypes.All(m => m.MapTypeId != (short)MapTypeEnum.Act4))
{
short[] vnums =
{
1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399,
1400, 1401, 1402, 1403, 1404, 1405
};
short vnum = vnums[ServerManager.Instance.RandomNumber(0, 20)];
NpcMonster npcmonster = ServerManager.Instance.GetNpc(vnum);
if (npcmonster == null)
{
return;
}
MapMonster monster = new MapMonster
{
MonsterVNum = vnum,
MapY = session.Character.MapY,
MapX = session.Character.MapX,
MapId = session.Character.MapInstance.Map.MapId,
Position = (byte)session.Character.Direction,
IsMoving = true,
MapMonsterId = session.CurrentMapInstance.GetNextId(),
ShouldRespawn = false
};
monster.Initialize(session.CurrentMapInstance);
session.CurrentMapInstance.AddMonster(monster);
session.CurrentMapInstance.Broadcast(monster.GenerateIn());
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
}
}
break;
case 69:
session.Character.GetReput(ReputPrice);
session.SendPacket(session.Character.GenerateFd());
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
break;
case 789:
session.Character.GiftAdd((short)inv.Item.EffectValue, 1);
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
break;
case 1003:
if (!session.Character.StaticBonusList.Any(s => s.StaticBonusType == StaticBonusType.BazaarMedalGold || s.StaticBonusType == StaticBonusType.BazaarMedalSilver))
{
session.Character.StaticBonusList.Add(new StaticBonusDTO
{
CharacterId = session.Character.CharacterId,
DateEnd = DateTime.Now.AddDays(EffectValue),
StaticBonusType = StaticBonusType.BazaarMedalGold
});
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("EFFECT_ACTIVATED"), Name), 12));
}
break;
case 1004:
if (!session.Character.StaticBonusList.Any(s => s.StaticBonusType == StaticBonusType.BazaarMedalGold || s.StaticBonusType == StaticBonusType.BazaarMedalGold))
{
session.Character.StaticBonusList.Add(new StaticBonusDTO
{
CharacterId = session.Character.CharacterId,
DateEnd = DateTime.Now.AddDays(EffectValue),
StaticBonusType = StaticBonusType.BazaarMedalSilver
});
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("EFFECT_ACTIVATED"), Name), 12));
}
break;
case 1005:
if (session.Character.StaticBonusList.All(s => s.StaticBonusType != StaticBonusType.BackPack))
{
session.Character.StaticBonusList.Add(new StaticBonusDTO
{
CharacterId = session.Character.CharacterId,
DateEnd = DateTime.Now.AddDays(EffectValue),
StaticBonusType = StaticBonusType.BackPack
});
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
session.SendPacket(session.Character.GenerateExts());
session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("EFFECT_ACTIVATED"), Name), 12));
}
break;
case 1006:
if (option == 0)
{
session.SendPacket($"qna #u_i^1^{session.Character.CharacterId}^{(byte)inv.Type}^{inv.Slot}^2 {Language.Instance.GetMessageFromKey("ASK_PET_MAX")}");
}
else
{
if (session.Character.MaxMateCount < 30)
{
session.SendPacket(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("GET_PET_PLACES"), 10));
session.SendPacket(session.Character.GenerateScpStc());
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
}
}
break;
case 1007:
if (session.Character.StaticBonusList.All(s => s.StaticBonusType != StaticBonusType.PetBasket))
{
session.Character.StaticBonusList.Add(new StaticBonusDTO
{
CharacterId = session.Character.CharacterId,
DateEnd = DateTime.Now.AddDays(EffectValue),
StaticBonusType = StaticBonusType.PetBasket
});
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
session.SendPacket(session.Character.GenerateExts());
session.SendPacket("ib 1278 1");
session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("EFFECT_ACTIVATED"), Name), 12));
}
break;
case 1008:
if (session.Character.StaticBonusList.All(s => s.StaticBonusType != StaticBonusType.PetBackPack))
{
session.Character.StaticBonusList.Add(new StaticBonusDTO
{
CharacterId = session.Character.CharacterId,
DateEnd = DateTime.Now.AddDays(EffectValue),
StaticBonusType = StaticBonusType.PetBackPack
});
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
session.SendPacket(session.Character.GenerateExts());
session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("EFFECT_ACTIVATED"), Name), 12));
}
break;
default:
List <RollGeneratedItemDTO> rolls = inv.Item.RollGeneratedItems?.ToList();
if (rolls != null && rolls.Any())
{
if (option == 0)
{
if (packetsplit != null && packetsplit.Length == 9 || inv.Item.ItemSubType == 3)
{
session.SendPacket($"qna #guri^4999^8023^{inv.Slot} {Language.Instance.GetMessageFromKey("ASK_OPEN_BOX")}");
}
break;
}
else
{
int probabilities = rolls.Sum(s => s.Probability);
int rnd = ServerManager.Instance.RandomNumber(0, probabilities);
int currentrnd = 0;
List <ItemInstance> newInv = null;
foreach (RollGeneratedItemDTO rollitem in rolls)
{
if (rollitem.Probability == 10000)
{
session.Character.GiftAdd(rollitem.ItemGeneratedVNum, rollitem.ItemGeneratedAmount);
continue;
}
currentrnd += rollitem.Probability;
if (newInv != null || currentrnd < rnd)
{
continue;
}
newInv = session.Character.Inventory.AddNewToInventory(rollitem.ItemGeneratedVNum, rollitem.ItemGeneratedAmount, upgrade: rollitem.ItemGeneratedUpgrade);
short slot = inv.Slot;
if (!newInv.Any() || slot == -1)
{
continue;
}
session.SendPacket(session.Character.GenerateSay($"{Language.Instance.GetMessageFromKey("ITEM_ACQUIRED")}: {newInv.FirstOrDefault()?.Item.Name ?? ""} x {rollitem.ItemGeneratedAmount})", 12));
session.SendPacket($"rdi {rollitem.ItemGeneratedVNum} {rollitem.ItemGeneratedAmount}");
newInv.ForEach(s => session.SendPacket(s?.GenerateInventoryAdd()));
}
session.Character.Inventory.RemoveItemAmountFromInventory(1, inv.Id);
break;
}
}
Logger.Log.Warn(string.Format(Language.Instance.GetMessageFromKey("NO_HANDLER_ITEM"), GetType()));
break;
}
session.Character.IncrementQuests(QuestType.Use, inv.ItemVNum);
}
