public void SendBlackMarketReward(Player player, uint itemId)
{
var blackMarketItems = ItemService._BlackMarket_Items;
foreach (var blackMarketItem in blackMarketItems)
{
if (blackMarketItem.ItemId == itemId)
{
Character_mail mail = new Character_mail
{
Guid = CharMgr.GenerateMailGuid(),
CharacterId = Convert.ToUInt32(player.CharacterId), //CharacterId
SenderName = "Black Market",
ReceiverName = player.Name,
SendDate = (uint)TCPManager.GetTimeStamp(),
Title = "Black Market Rewards",
Content = "Open it and see...",
Money = 0,
Opened = false,
CharacterIdSender = 0 // system
};
MailItem item = new MailItem(Convert.ToUInt32(1298378521), Convert.ToUInt16(1));
if (item != null)
{
mail.Items.Add(item);
CharMgr.AddMail(mail);
}
}
}
}
protected override void SetDeath(Unit killer)
{
// reset add list
// AddDictionary = new List<Creature>();
base.SetDeath(killer);
if (Instance != null)
{
Instance.OnBossDeath(InstanceGroupSpawnId, this);
// remove barriages from this instance
Instance.RemoveInstanceObjectOnBossDeath(BossId);
}
// handle torch of lileath on horgulul death
if (this is SimpleHorgulul horgulul)
{
foreach (Player plr in horgulul.GetPlayersInRange(300, false))
{
var character = CharMgr.GetCharacter(plr.CharacterId, false);
if (character == null)
{
continue;
}
if (!CharMgr.GetItemsForCharacter(character).Any(x => x.Entry == 11435))
{
plr.ItmInterface.CreateItem(11435, 1);
}
}
}
EvtInterface.AddEvent(ApplyDelayedLockout, 40000, 1);
}
public void Ignore(string name)
{
if (name.Length <= 0 || name.Equals(_player.Name, StringComparison.OrdinalIgnoreCase))
{
_player.SendLocalizeString("", ChatLogFilters.CHATLOGFILTERS_USER_ERROR, Localized_text.TEXT_SN_FRIENDSLIST_ERR_ADD_SELF);
return;
}
string charName = Player.AsCharacterName(name);
uint characterId = CharMgr.GetCharacterId(charName);
// Character didn't exist
if (characterId == 0)
{
_player.SendLocalizeString("", ChatLogFilters.CHATLOGFILTERS_USER_ERROR, Localized_text.TEXT_SN_LISTS_ERR_PLAYER_NOT_FOUND);
return;
}
bool applyIgnore = true;
lock (_ignoreCharacterIds)
if (_ignoreCharacterIds.ContainsKey(characterId))
{
applyIgnore = false;
}
if (applyIgnore)
{
AddIgnore(characterId, name);
}
else
{
RemoveIgnore(characterId, name);
}
}
public static void F_DELETE_NAME(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
string CharName = packet.GetString(30);
string UserName = packet.GetString(20);
byte Bad = 0;
if (CharName.Length < 3 || CharMgr.NameIsUsed(CharName) || !System.Text.RegularExpressions.Regex.IsMatch(CharName, @"^[a-zA-Z]+$"))
{
Bad = 1;
}
Log.Debug("F_DELETE_NAME", "Bad=" + Bad + ",Name=" + CharName);
PacketOut Out = new PacketOut((byte)Opcodes.F_CHECK_NAME, 54);
Out.FillString(CharName, 30);
Out.FillString(UserName, 20);
Out.WriteByte(Bad);
Out.WriteByte(0);
Out.WriteByte(0);
Out.WriteByte(0);
cclient.SendPacket(Out);
}
public static bool ReloadPetModifiers(Player plr, ref List <string> values)
{
lock (Player._Players)
{
foreach (Player player in Player._Players)
{
player.SendClientMessage("[System] Recaching pet tables...", ChatLogFilters.CHATLOGFILTERS_CSR_TELL_RECEIVE);
}
}
CharMgr.ReloadPetModifiers();
lock (Player._Players)
{
foreach (Player player in Player._Players)
{
player.SendClientMessage("[System] Pet tables successfully recached.", ChatLogFilters.CHATLOGFILTERS_CSR_TELL_RECEIVE);
if (player != null && player.CrrInterface != null)
{
if (player.CrrInterface.GetTargetOfInterest() != null && player.CrrInterface.GetTargetOfInterest() is Pet)
{
Pet myPet = (Pet)player.CrrInterface.GetTargetOfInterest();
if (myPet != null)
{
myPet.Dismiss(null, null);
player.SendClientMessage("[System] Pet tables were recached. Your pet has been dismissed.", ChatLogFilters.CHATLOGFILTERS_CSR_TELL_RECEIVE);
}
}
}
}
}
return(true);
}
public static bool MailItem(uint characterId, uint itemId, ushort count)
{
var character = CharMgr.GetCharacter(characterId, true);
if (character == null)
{
return(false);
}
var characterName = character?.Name;
Character_mail mail = new Character_mail
{
Guid = CharMgr.GenerateMailGuid(),
CharacterId = characterId, //CharacterId
SenderName = "Ikthaleon",
ReceiverName = characterName,
SendDate = (uint)TCPManager.GetTimeStamp(),
Title = "",
Content = "",
Money = 0,
Opened = false,
CharacterIdSender = 283
};
MailItem item = new MailItem(itemId, count);
if (item != null)
{
mail.Items.Add(item);
CharMgr.AddMail(mail);
}
return(true);
}
//public bool LoadExisting(Item_Info info, ushort slotId, ushort count, Item itm)
//{
// Info = info;
// if (info == null)
// return false;
// if (count <= 0)
// count = 1;
// _SlotId = slotId;
// _ModelId = info.ModelId;
// _Count = count;
// Player player = Owner as Player;
// if (player != null)
// {
// CharMgr.CreateItem(itm.CharSaveInfo);
// if (info.SpellId != 0)
// player.AbtInterface.AssignItemCooldown(this);
// }
// return true;
//}
public void Delete()
{
if (CharSaveInfo != null)
{
CharMgr.DeleteItem(CharSaveInfo);
}
}
public void TakeLoot(Player plr)
{
Character character = CharMgr.GetCharacter(plr.CharacterId, false);
var bagExists = LootBags.ContainsKey(character.CharacterId);
if (bagExists)
{
var bag = LootBags[character.CharacterId];
foreach (var talisman in bag.Value)
{
// Adding bag to the player
ItemResult result = plr.ItmInterface.CreateItem(bag.Key, 1, bag.Value, 0, 0, false);
if (result == ItemResult.RESULT_OK)
{
LootBags.Remove(plr.CharacterId);
}
else if (result == ItemResult.RESULT_MAX_BAG)
{
plr.SendLocalizeString("", ChatLogFilters.CHATLOGFILTERS_LOOT,
Localized_text.TEXT_OVERAGE_CANT_LOOT);
}
}
//ItemResult result = plr.ItmInterface.CreateItem(bag.Key, 1, items.talisman,
// items.primary_dye, items.secondary_dye, false);
}
}
public static void F_DUMP_ARENAS_LARGE(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (!cclient.HasAccount())
{
cclient.Disconnect("No Account in F_DUMP_ARENAS_LARGE");
return;
}
if (Program.Rm.OnlinePlayers >= Program.Rm.MaxPlayers && cclient._Account.GmLevel == 1)
{
PacketOut Out = new PacketOut((byte)Opcodes.F_LOGINQUEUE);
client.SendPacket(Out);
return;
}
byte CharacterSlot = packet.GetUint8();
Character Char = CharMgr.GetAccountChar(cclient._Account.AccountId).GetCharacterBySlot(CharacterSlot);
if (Char == null)
{
Log.Error("F_DUMP_ARENAS_LARGE", "Can not find character on slot : " + CharacterSlot);
cclient.Disconnect("Character not found in F_DUMP_ARENAS_LARGE");
return;
}
{
if (cclient.Plr == null)
{
cclient.Plr = Player.CreatePlayer(cclient, Char);
}
if (cclient.Plr == null)
{
cclient.Disconnect("NULL Player from CreatePlayer?");
return;
}
if (cclient.Plr.Client != cclient)
{
cclient.Plr.Client?.Disconnect("Ghost client");
cclient.Plr.Destroy();
cclient.Disconnect("Player already exists");
return;
}
PacketOut Out = new PacketOut((byte)Opcodes.F_WORLD_ENTER, 64);
Out.WriteUInt16(0x0608); // TODO
Out.Fill(0, 20);
Out.WriteString("38699", 5);
Out.WriteString("38700", 5);
Out.WriteString("0.0.0.0", 20);
cclient.SendPacket(Out);
}
}
/// <summary>
/// Seach a player's inventory by name <name>
/// </summary>
/// <param name="plr">Player that initiated the command</param>
/// <param name="values">List of command arguments (after command name)</param>
/// <returns>True if command was correctly handled, false if operation was canceled</returns>
public static bool SearchInventory(Player plr, ref List <string> values)
{
var target = plr.CbtInterface.GetCurrentTarget();
var filter = String.Empty;
if (target == null)
{
plr.SendClientMessage($"SEARCH INVENTORY: No target selected.");
}
else
{
var character = CharMgr.GetCharacter((target as Player).CharacterId, false);
if (character == null)
{
plr.SendClientMessage($"SEARCH INVENTORY: The player {(target as Player).Name} in question does not exist.");
return(true);
}
var characterItemList = CharMgr.GetItemsForCharacter(character);
var itemList = new List <Item_Info>();
if (values.Count > 0)
{
// First argument is a wildcard filter.
filter = values[0];
}
foreach (CharacterItem itm in characterItemList)
{
if (itm != null)
{
itemList.Add(ItemService.GetItem_Info(itm.Entry));
}
}
itemList.OrderBy(x => x.Name);
foreach (Item_Info proto in itemList)
{
if (!String.IsNullOrEmpty(filter))
{
if (proto.Name.ToLower().Contains(filter.ToLower()))
{
plr.SendMessage(0, "", $"[{proto.Entry}] {proto.Name} ", ChatLogFilters.CHATLOGFILTERS_EMOTE);
}
}
else
{
plr.SendMessage(0, "", $"[{proto.Entry}] {proto.Name} ", ChatLogFilters.CHATLOGFILTERS_EMOTE);
}
}
}
return(true);
}
/// <summary>
/// Sets offline/online players coordinates in database (player_name byte byte ZoneID , uint WorldX, uint WorldY, uint WorldZ)
/// </summary>
/// <param name="plr">Player that initiated the command</param>
/// <param name="values">List of command arguments (after command name)</param>
/// <returns>True if command was correctly handled, false if operation was canceled</returns>
public static bool TeleportSet(Player plr, ref List <string> values)
{
string playerName = GetString(ref values);
int zoneID = GetZoneId(plr, ref values);
if (zoneID == -1)
{
return(false);
}
int worldX = GetInt(ref values);
int worldY = GetInt(ref values);
int worldZ = GetInt(ref values);
Zone_Info zone = ZoneService.GetZone_Info((ushort)zoneID);
if (zone == null)
{
zone = ZoneService._Zone_Info[0];
}
var existingChar = CharMgr.GetCharacter(Player.AsCharacterName(playerName), false);
if (existingChar == null)
{
plr.SendClientMessage("Player with name '" + values[0] + "' not found.", ChatLogFilters.CHATLOGFILTERS_USER_ERROR);
return(true);
}
var player = Player.GetPlayer(playerName);
GMCommandLog log = new GMCommandLog
{
PlayerName = plr.Name,
AccountId = (uint)plr.Client._Account.AccountId,
Command = "TELEPORT offline player '" + existingChar.Name + "' TO " + zoneID + " " + worldX + " " + worldY,
Date = DateTime.Now
};
CharMgr.Database.AddObject(log);
if (player != null)
{
player.Teleport((ushort)zoneID, (uint)worldX, (uint)worldY, (ushort)worldZ, 0);
}
existingChar.Value.WorldX = worldX;
existingChar.Value.WorldY = worldY;
existingChar.Value.WorldZ = worldZ;
existingChar.Value.ZoneId = zone.ZoneId;
existingChar.Value.RegionId = zone.Region;
CharMgr.Database.SaveObject(existingChar.Value);
CharMgr.Database.ForceSave();
return(true);
}
// Called by Destroy of Object
public override void Dispose()
{
if (IsDisposed)
{
return;
}
try
{
foreach (var lootBag in LootBags)
{
var character = CharMgr.GetCharacter(lootBag.Key, false);
var characterName = character?.Name;
// Forced to have some value here.
if (Content == null)
{
Content = "mail";
}
if (String.IsNullOrEmpty(Content))
{
Content = "mail";
}
Character_mail mail = new Character_mail
{
Guid = CharMgr.GenerateMailGuid(),
CharacterId = lootBag.Key, //CharacterId
SenderName = SenderName,
ReceiverName = characterName,
SendDate = (uint)TCPManager.GetTimeStamp(),
Title = Title,
Content = Content,
Money = 0,
Opened = false
};
mail.CharacterIdSender = lootBag.Key;
MailItem item = new MailItem((uint)lootBag.Value.Key.Entry, lootBag.Value.Value, 0, 0, (ushort)lootBag.Value.Value.Count);
if (item != null)
{
mail.Items.Add(item);
CharMgr.AddMail(mail);
}
}
}
catch (Exception ex)
{
Log.Error("LootChest", $"Failed to mail loot. {ex.Message} {ex.StackTrace}");
}
base.Dispose();
}
/// <summary>
/// Changes the name of the guild by ID (int guildID string guildName)
/// </summary>
/// <param name="plr">Player that initiated the command</param>
/// <param name="values">List of command arguments (after command name)</param>
/// <returns>True if command was correctly handled, false if operation was canceled</returns>
public static bool ModifyGuildNameByID(Player plr, ref List <string> values)
{
if (values.Count < 2)
{
plr.SendClientMessage("Usage: .modify guildnamebyid <guildID> <guildName>");
return(true);
}
uint guildID = (uint)(int)GetInt(ref values);
string guildName = GetTotalString(ref values).Trim();
if (string.IsNullOrEmpty(guildName))
{
plr.SendClientMessage("you need to specify a new guild name");
return(true);
}
Guild guild = Guild.GetGuild(guildID);
if (guild == null)
{
plr.SendClientMessage("The Specified guild does not exist");
return(true);
}
if (Guild.GetGuild(guildName) != null)
{
plr.SendClientMessage("That guildname is already taken");
return(true);
}
else
{
plr.SendClientMessage("Changing from " + guild.Info.Name + " to " + guildName);
if (guild.Info.AllianceId != 0)
{
guild.LeaveAlliance(); //sanity in case of packet changes with guild name change on guild inside alliance
}
GMCommandLog log = new GMCommandLog
{
PlayerName = plr.Name,
AccountId = (uint)plr.Client._Account.AccountId,
Command = "CHANGED GUILDNAME OF: " + guild.Info.Name + " TO: " + guildName,
Date = DateTime.UtcNow
};
CharMgr.Database.AddObject(log);
guild.Info.Name = guildName;
CharMgr.ChangeGuildName(guild.Info, guildName);
return(true);
}
}
/// <summary>
/// Delete the specified ticket
/// </summary>
/// <param name="plr"></param>
/// <param name="values"></param>
/// <returns></returns>
public static bool DeleteTicket(Player plr, ref List <string> values)
{
if (values.Count < 1)
{
plr.SendClientMessage("Usage: .ticket deleteticket <bugtrackerID>");
return(true);
}
string reportID = GetTotalString(ref values).Trim();
if (string.IsNullOrEmpty(reportID))
{
plr.SendClientMessage("you need to specify the ticketID");
return(true);
}
Bug_report report = CharMgr.GetReport(reportID);
if (report == null)
{
plr.SendClientMessage("The Specified report does not exist");
return(true);
}
if (report.Assigned != plr.Client._Account.Username)
{
plr.SendClientMessage("You cannot close a ticket not assigned to you(username), assign it to yourself first if you fixed the ticket");
return(true);
}
else
{
plr.SendClientMessage("You have deleted ticket: " + reportID);
GMCommandLog log = new GMCommandLog
{
PlayerName = plr.Client._Account.Username,
AccountId = (uint)plr.Client._Account.AccountId,
Command = $"Removed Ticket: {reportID} from characterID: {report.CharacterId}. containing the following message: {report.Message} {report.FieldSting}",
Date = DateTime.Now
};
CharMgr.Database.AddObject(log);
lock (CharMgr._report)
{
CharMgr._report.Remove(report);
CharMgr.Database.DeleteObject(report);
CharMgr.Database.ForceSave();
}
return(true);
}
}
public static void CheckAuctionExpiry(object arg)
{
int removeCount = 0;
long expireTimeStart = TCPManager.GetTimeStamp() - (60 * 60 * 24 * 30);
lock (Auctions)
{
for (int i = 0; i < Auctions.Count; ++i)
{
if (Auctions[i].StartTime >= expireTimeStart)
{
continue;
}
Common.Auction auction = Auctions[i];
if (auction.Item == null)
{
auction.Item = ItemService.GetItem_Info(auction.ItemId);
}
if (auction.Item != null)
{
// return item to lister
Character_mail expireMail = new Character_mail
{
Guid = CharMgr.GenerateMailGuid(),
CharacterId = auction.SellerId,
ReceiverName = auction.Seller.Name,
SendDate = (uint)TCPManager.GetTimeStamp(),
AuctionType = 3,
Content = auction.Item.Name,
Money = 0,
Opened = false
};
expireMail.Items.Add(new MailItem(auction.ItemId, auction._Talismans, auction.PrimaryDye, auction.SecondaryDye, auction.Count));
CharMgr.AddMail(expireMail);
}
CharMgr.Database.DeleteObject(auction);
Auctions.RemoveAt(i);
++removeCount;
--i;
}
Log.Info("Auction House", $"Removed {removeCount} expired {(removeCount == 1 ? "auction": "auctions")}.");
}
}
public static void SendCOD(string receiverName, Player sender, uint amount)
{
Character receiver = CharMgr.GetCharacter(receiverName, false);
// Sender may have deleted character, oh well. No one gets the money.
if (receiver == null)
{
return;
}
sender.MlInterface.SendMail(receiver, "COD Payment", "Here is your COD payment", amount, false);
}
public override void SendInteract(Player player, InteractMenu menu)
{
uint itemid = 0;
switch (Bannertyp)
{
case 0: itemid = (uint)(RealmStandard == Realms.REALMS_REALM_DESTRUCTION ? 187704 : 187701); break;
case 1: itemid = (uint)(RealmStandard == Realms.REALMS_REALM_DESTRUCTION ? 187705 : 187702); break;
case 2: itemid = (uint)(RealmStandard == Realms.REALMS_REALM_DESTRUCTION ? 187706 : 187703); break;
}
if (player == Owner)
{
if (player.ItmInterface.GetItemInSlot(14) == null)
{
player.ItmInterface.CreateItem(ItemService.GetItem_Info(itemid), 1, 14);
player.ItmInterface.SendEquipped(player);
player.ItmInterface.SendEquipped(null);
}
else
{
player.ItmInterface.CreateItem(ItemService.GetItem_Info(itemid), 1);
}
}
else if (player.Realm == RealmStandard)
{
Character_mail Mail = new Character_mail();
Mail.Guid = CharMgr.GenerateMailGuid();
Mail.CharacterId = Owner.CharacterId;
Mail.CharacterIdSender = player.CharacterId;
Mail.SenderName = player.Name;
Mail.ReceiverName = Owner.Name;
Mail.SendDate = (uint)TCPManager.GetTimeStamp();
Mail.Title = "Guild Standard";
Mail.Content = "Found your Guild Standard";
Mail.Money = 0;
Mail.Opened = false;
Mail.Items.Add(new MailItem(itemid, 1));
CharMgr.AddMail(Mail);
}
else
{
player.AddRenown(600, false);
}
player.PlantedStandard = null;
Dispose();
}
/// <summary>
/// Assigns a person to a ticket
/// </summary>
/// <param name="plr"></param>
/// <param name="values"></param>
/// <returns></returns>
public static bool Assign(Player plr, ref List <string> values)
{
if (values.Count < 2)
{
plr.SendClientMessage("Usage: .ticket assign <accountname> <bugtrackerID>");
return(true);
}
string account = GetString(ref values);
string reportID = GetTotalString(ref values).Trim();
if (string.IsNullOrEmpty(account))
{
plr.SendClientMessage("you need to specify a person for the ticket");
return(true);
}
if (string.IsNullOrEmpty(reportID))
{
plr.SendClientMessage("you need to specify the ticketID");
return(true);
}
Bug_report report = CharMgr.GetReport(reportID);
if (report == null)
{
plr.SendClientMessage("The Specified report does not exist");
return(true);
}
else
{
if (account == "nobody")
{
plr.SendClientMessage("You have unassigned yourself from ticket: " + reportID);
}
else
{
plr.SendClientMessage("You have assigned " + account + " to ticket: " + reportID);
}
lock (CharMgr._report)
{
report.Assigned = account;
CharMgr.Database.SaveObject(report);
CharMgr.Database.ForceSave();
}
return(true);
}
}
public void RemoveFriend(string name)
{
uint characterId = CharMgr.GetCharacterId(Player.AsCharacterName(name));
Character_social social;
lock (_friendCharacterIds)
_friendCharacterIds.TryGetValue(characterId, out social);
if (social == null)
{
_player.SendLocalizeString("", ChatLogFilters.CHATLOGFILTERS_USER_ERROR, Localized_text.TEXT_SN_LISTS_ERR_PLAYER_NOT_FOUND);
return;
}
PacketOut Out = new PacketOut((byte)Opcodes.F_SOCIAL_NETWORK);
Out.WriteUInt16(0);
Out.WriteByte((byte)SocialListType.SOCIAL_FRIEND);
Out.WriteByte(1); // Count
Out.WriteByte(1);
Out.WriteUInt32(social.DistCharacterId);
_player.SendPacket(Out);
_player.SendLocalizeString(social.DistName, ChatLogFilters.CHATLOGFILTERS_SAY, Localized_text.TEXT_SN_FRIEND_REMOVE);
if (social.Ignore > 0)
{
social.Friend = 0;
CharMgr.Database.SaveObject(social);
}
else
{
lock (_player.Info.Socials)
{
if (_player.Info.Socials.Contains(social))
{
_player.Info.Socials.Remove(social);
}
}
CharMgr.Database.DeleteObject(social);
}
lock (_friendCharacterIds)
_friendCharacterIds.Remove(social.DistCharacterId);
//CharMgr.Database.ForceSave();
}
/// <summary>
/// Reload character <name>
/// </summary>
/// <param name="plr">Player that initiated the command</param>
/// <param name="values">List of command arguments (after command name)</param>
/// <returns>True if command was correctly handled, false if operation was canceled</returns>
public static bool ReloadCharacter(Player plr, ref List <string> values)
{
string name = GetString(ref values);
Character Char = CharMgr.LoadCharacterInfo(name, true);
if (Char != null)
{
plr.SendClientMessage("RELOADCHARACTER: Character Loaded : " + Char.CharacterId);
}
else
{
plr.SendClientMessage("RELOADCHARACTER: Invalid character specified: " + name);
}
return(true);
}
private void Update(object sender, System.EventArgs e)
{
frameLabel.Text = "Frame: " + InputManager.CurrentFrame;
var c = CharMgr.GetPlayerCharacter(PlayerMgr.GetMainPlayer());
xLabel.Text = "Pos X: " + c?.loc.X;
yLabel.Text = "Pos Y: " + c?.loc.Y;
xSpeedLabel.Text = "Spd X: " + c?.traj.X;
ySpeedLabel.Text = "Spd Y: " + c?.traj.Y;
MouseState mouse = InputManager.GetActualMouse();
mouseXLabel.Text = "Pos X: " + mouse.X;
mouseYLabel.Text = "Pos Y: " + mouse.Y;
var charAnim = c?.anim;
animNameLabel.Text = "Name: " + charAnim?.animName;
animKeyLabel.Text = "Key: " + charAnim?.key;
animFrameLabel.Text = "Frame: " + charAnim?.frame;
KeyFrame frame;
try
{
MonsterDef mDef = MonsterCatalog.catalog[c.monsterIdx];
CharDef charDef = CharDefMgr.charDefList[mDef.defIdx];
Animation anim = charDef.animation[charAnim.anim];
frame = anim.keyFrame[charAnim.key];
}
catch
{
frame = null;
}
animFrameDurationLabel.Text = "Duration: " + frame?.duration;
if (NeedsClose)
{
NeedsClose = false;
Close();
}
else
{
Invalidate();
}
}
/// <summary>
/// Changes the renown rank of a player (string playerName, int RenownRank)
/// </summary>
/// <param name="plr">Player that initiated the command</param>
/// <param name="values">List of command arguments (after command name)</param>
/// <returns>True if command was correctly handled, false if operation was canceled</returns>
public static bool ModifyRenown(Player plr, ref List <string> values)
{
string playerName = GetString(ref values);
int renownLevel = GetInt(ref values);
Player target = Player.GetPlayer(playerName);
Character chara = CharMgr.GetCharacter(playerName, false);
if (chara == null)
{
plr.SendClientMessage($"MODIFY RENOWN: The player {playerName} in question does not exist.");
return(true);
}
int desiredRenownRank = renownLevel > 0 ? renownLevel : Math.Max(1, chara.Value.RenownRank + renownLevel);
desiredRenownRank = Math.Min(100, desiredRenownRank);
if (target != null)
{
target.SetRenownLevel((byte)desiredRenownRank);
}
else
{
chara.Value.Renown = 0;
chara.Value.RenownRank = (byte)desiredRenownRank;
CharMgr.Database.SaveObject(chara.Value);
}
if (target != plr)
{
plr.SendClientMessage($"MODIFY RENOWN: {playerName}'s renown rank is now {chara.Value.RenownRank}.");
}
GMCommandLog log = new GMCommandLog
{
PlayerName = plr.Name,
AccountId = (uint)plr.Client._Account.AccountId,
Command = renownLevel > 0 ? $"SET {playerName}'S RENOWN TO {renownLevel}" : $"REDUCED {playerName}'S RENOWN BY {-renownLevel}",
Date = DateTime.Now
};
CharMgr.Database.AddObject(log);
return(true);
}
public void TakeLoot(Player plr)
{
Character chara = CharMgr.GetCharacter(plr.CharacterId, false);
MailItem items = GenerateBag(chara.CharacterId);
ItemResult result = plr.ItmInterface.CreateItem(ItemService.GetItem_Info(items.id), 1, items.talisman, items.primary_dye, items.secondary_dye, false);
if (result == ItemResult.RESULT_OK)
{
_lootBags.Remove(plr.CharacterId);
}
else if (result == ItemResult.RESULT_MAX_BAG)
{
plr.SendLocalizeString("", ChatLogFilters.CHATLOGFILTERS_LOOT, Localized_text.TEXT_OVERAGE_CANT_LOOT);
}
}
public CharacterItem CreateCharSaveInfo(uint characterId)
{
CharSaveInfo = new CharacterItem
{
CharacterId = characterId,
Counts = _Count,
Entry = Info.Entry,
ModelId = _ModelId,
SlotId = _SlotId,
PrimaryDye = 0,
SecondaryDye = 0,
BoundtoPlayer = false
};
CharMgr.CreateItem(CharSaveInfo);
return(CharSaveInfo);
}
public static void DisablePetModifiers(Player plr, string targetString = null)
{
int Disabled;
if (targetString != null && Int32.TryParse(targetString, out Disabled))
{
WorldMgr.WorldSettingsMgr.SetGenericSetting(19, Disabled);
plr.SendClientMessage("Set Pet Modifier System flag Successfully: " + Disabled, ChatLogFilters.CHATLOGFILTERS_TELL_RECEIVE);
lock (Player._Players)
{
foreach (Player player in Player._Players)
{
player.SendClientMessage("[System] Recaching pet tables...", ChatLogFilters.CHATLOGFILTERS_CSR_TELL_RECEIVE);
}
}
CharMgr.ReloadPetModifiers();
lock (Player._Players)
{
foreach (Player player in Player._Players)
{
player.SendClientMessage("[System] Pet tables successfully recached.", ChatLogFilters.CHATLOGFILTERS_CSR_TELL_RECEIVE);
if (player != null && player.CrrInterface != null)
{
if (player.CrrInterface.GetTargetOfInterest() != null && player.CrrInterface.GetTargetOfInterest() is Pet)
{
Pet myPet = (Pet)player.CrrInterface.GetTargetOfInterest();
if (myPet != null)
{
myPet.Dismiss(null, null);
player.SendClientMessage("[System] Pet tables were recached. Your pet has been dismissed.", ChatLogFilters.CHATLOGFILTERS_CSR_TELL_RECEIVE);
}
}
}
}
}
}
else
{
plr.SendClientMessage("Disable Pet Mastery System flag is set to: " + WorldMgr.WorldSettingsMgr.GetGenericSetting(19), ChatLogFilters.CHATLOGFILTERS_TELL_RECEIVE);
}
}
/// <summary>
/// Removes or returns an expired mail.
/// </summary>
private static void MailExpired(Character_mail mail)
{
if (mail.AuctionType != 0 || (mail.Money == 0 && mail.Items.Count == 0))
{
CharMgr.DeleteMail(mail);
return;
}
Character receiver = CharMgr.GetCharacter(mail.SenderName, false);
if (receiver != null)
{
ReturnMail(mail);
}
else
{
CharMgr.DeleteMail(mail);
}
}
/// <summary>
/// Returns an expired mail to its sender.
/// </summary>
private static MailResult ReturnMail(Character_mail mail)
{
// Can't return auction mail.
if (mail.AuctionType != 0)
{
return(MailResult.TEXT_MAIL_RESULT11);
}
Character receiver = CharMgr.GetCharacter(mail.SenderName, false);
// No one to return mail to.
if (receiver == null)
{
return(MailResult.TEXT_MAIL_RESULT11);
}
// If mail is COD, remove the COD requirement and remove the money.
if (mail.Cr)
{
mail.Cr = false;
mail.Money = 0;
}
CharMgr.DeleteMail(mail);
Character_mail returnMail = new Character_mail
{
// Sender -> Reciever, Reciever -> Sender
Guid = CharMgr.GenerateMailGuid(),
CharacterId = mail.CharacterIdSender,
CharacterIdSender = mail.CharacterId,
SenderName = mail.ReceiverName,
ReceiverName = mail.SenderName,
Content = "Your mail expired and has been returned to you.",
ReadDate = 0,
SendDate = (uint)TCPManager.GetTimeStamp(),
Opened = false
};
CharMgr.AddMail(returnMail);
return(MailResult.TEXT_MAIL_UNK);
}
public override void Dispose()
{
if (IsDisposed)
{
return;
}
try
{
foreach (KeyValuePair <uint, GoldBag> loot in _lootBags)
{
Character_mail mail = new Character_mail
{
Guid = CharMgr.GenerateMailGuid(),
CharacterId = loot.Key,
SenderName = "Public Quest",
ReceiverName = loot.Value.plrName,
SendDate = (uint)TCPManager.GetTimeStamp(),
Title = "Public Quest Loot",
Content = "You won a Public Quest Loot Bag",
Money = 0,
Opened = false
};
//Mail.CharacterIdSender = plr.CharacterId;
MailItem item = GenerateBag(loot.Key);
if (item != null)
{
mail.Items.Add(item);
CharMgr.AddMail(mail);
}
}
}
catch (NullReferenceException)
{
Log.Error("GoldChest", "Failed to mail loot.");
}
_lootBags = new Dictionary <uint, GoldBag>();
base.Dispose();
}
public static void F_REQUEST_CHAR(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
cclient.State = (int)eClientState.CharScreen;
ushort Operation = packet.GetUint16();
if (Operation == 0x2D58)
{
PacketOut Out = new PacketOut((byte)Opcodes.F_REQUEST_CHAR_ERROR, 1);
Out.WriteByte((byte)CharMgr.GetAccountRealm(cclient._Account.AccountId));
cclient.SendPacket(Out);
}
else
{
PacketOut Out = new PacketOut((byte)Opcodes.F_REQUEST_CHAR_RESPONSE, 64);
Out.FillString(cclient._Account.Username, 20);
Out.WriteUInt32(0); //RemainingLockoutTime
Out.WriteByte(0);
if (cclient._Account.GmLevel == 1 && !Program.Config.CreateBothRealms)
{
Out.WriteByte((byte)CharMgr.GetAccountRealm(cclient._Account.AccountId));
}
else
{
Out.WriteByte(0);
}
Out.WriteByte(CharMgr.MaxSlot); //Maximum Characters you can have
Out.WriteByte(0); //GameplayRulesetType
Out.WriteByte(0); //LastSwitchedToRealm
Out.WriteByte(0); //NumPaidNameChangesAvailable
Out.WriteByte(0); // unk
byte[] Chars = CharMgr.BuildCharacters(cclient._Account.AccountId);
Out.Write(Chars, 0, Chars.Length);
cclient.SendPacket(Out);
}
}
public static void F_DELETE_CHARACTER(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
byte Slot = packet.GetUint8();
if (cclient._Account == null)
{
cclient.Disconnect("Null Account in F_DELETE_CHARACTER");
return;
}
CharMgr.RemoveCharacter(Slot, cclient);
PacketOut Out = new PacketOut((byte)Opcodes.F_SEND_CHARACTER_RESPONSE, 24);
Out.FillString(cclient._Account.Username, 21);
Out.Fill(0, 3);
cclient.SendPacket(Out);
}
