public static bool HandleSell(Models.Entities.Player player, Models.Packets.Items.ItemActionPacket packet)
{
Models.Misc.Shop shop;
if (Collections.ShopCollection.TryGetShop(packet.ClientId, out shop))
{
var npc = shop.Npc;
if (npc != null && Tools.RangeTools.ValidDistance(npc.X, npc.Y, player.X, player.Y))
{
Models.Items.Item item;
if (player.Inventory.TryGetItem(packet.Data1, out item))
{
if (!item.Discardable)
{
player.SendSystemMessage("NO_PERMISSION_ITEM");
return(true);
}
player.AddActionLog("Sell", item.DbOwnerItem.Id);
uint giveback = (uint)(item.DbOwnerItem.CurrentDura > 0 ? (item.DbItem.Price / 3) : 0);
if (player.Inventory.Remove(item.ClientId))
{
player.Money += giveback;
}
}
}
}
return(true);
}
public static bool HandlePacket(Models.Entities.Player player, SocketPacket packet)
{
if (player.Battle != null)
{
return(true);
}
packet.Offset = 4;
if (packet.ReadByte() > 2)
{
packet.Offset = 12;
var strings = packet.ReadStrings();
if (strings.Length > 0 && strings[0].Length < 255)
{
if (player.CPs >= 5)
{
player.AddActionLog("Broadcast", strings[0]);
player.CPs -= 5;
Collections.BroadcastQueue.Enqueue(
MessageController.CreateBroadcast(player.Name, strings[0])
);
}
}
}
return(true);
}
/// <summary>
/// Performs a drop within the map.
/// </summary>
/// <param name="x">The x coordinate.</param>
/// <param name="y">The y coordinate.</param>
/// <param name="mobId">The monster id.</param>
/// <param name="player">The player that caused the drop.</param>
public void Drop(ushort x, ushort y, int mobId, Models.Entities.Player player)
{
foreach (var drop in Map.Drops)
{
drop.Perform(Map, x, y, mobId, player);
}
}
public static bool HandleQueryEquipments(Models.Entities.Player player, Models.Packets.Client.DataExchangePacket packet)
{
Models.Entities.Player viewPlayer = Collections.PlayerCollection.GetPlayerByClientId(packet.Data1);
if (viewPlayer != null)
{
player.ClientSocket.Send(viewPlayer.GetSpawnPacket());
foreach (var item in viewPlayer.Equipments.GetAll())
{
item.ViewItem(viewPlayer, player);
}
if (viewPlayer.LoggedIn)
{
viewPlayer.SendFormattedSystemMessage("VIEW_EQUIPMENTS", true, player.Name);
}
player.ClientSocket.Send(new Models.Packets.Misc.StringPacket
{
String = viewPlayer.Spouse,
Action = Enums.StringAction.QueryMate
});
}
return(true);
}
/// <summary>
/// Adds a map object to the screen of another map object.
/// </summary>
/// <param name="obj">The map object to add.</param>
/// <param name="player">The player associated to the owner map object, if any.</param>
/// <param name="spawnPacket">The spawn packet of the owner map object.</param>
/// <param name="packet">A packet to send to the map object if it's a client.</param>
private void AddToScreen(IMapObject obj, Models.Entities.Player player, byte[] spawnPacket, byte[] packet, Enums.UpdateScreenFlags flags, bool spawnToOwner)
{
if (obj is Models.Entities.Player)
{
var objPlayer = (Models.Entities.Player)obj;
if (!objPlayer.LoggedIn)
{
return;
}
objPlayer.ClientSocket.Send(spawnPacket);
if (packet != null)
{
if (flags != Enums.UpdateScreenFlags.DeadPlayers ||
flags == Enums.UpdateScreenFlags.DeadPlayers &&
!objPlayer.Alive)
{
objPlayer.ClientSocket.Send(packet);
}
}
}
if (player != null && spawnToOwner)
{
player.ClientSocket.Send(obj.GetSpawnPacket());
}
(obj as MapObjectController)._screenObjects.TryAdd(MapObject.ClientId, MapObject);
_screenObjects.TryAdd(obj.ClientId, obj);
}
public static bool HandleLeave(Models.Entities.Player player, Models.Packets.Team.TeamActionPacket packet)
{
if (player.Team == null)
{
return(true);
}
if (player.Team.IsLeader(player))
{
return(true);
}
if (player.ClientId != packet.ClientId)
{
return(true);
}
Models.Entities.Player removedPlayer;
if (player.Team.Remove(packet.ClientId, out removedPlayer))
{
foreach (var member in player.Team.GetMembers())
{
member.ClientSocket.Send(packet);
}
player.ClientSocket.Send(packet);
player.Team = null;
}
return(true);
}
public static bool Handle(Models.Entities.Player player, Models.Packets.Nobility.NobilityPacket packet)
{
int pageMax;
var pagedList = Collections.NobilityBoard.GetPaged((int)packet.Data1LowA, out pageMax);
pageMax = pageMax > 0 ? (pageMax + 1) : 0;
if (pagedList.Count > 0)
{
var nobilityPacket = new Models.Packets.Nobility.NobilityPacket(48 * pagedList.Count)
{
Action = Enums.NobilityAction.List,
Data1LowLow = packet.Data1LowA,
Data1LowHigh = (ushort)pageMax,
Data1HighLow = (ushort)pagedList.Count
};
nobilityPacket.WriteData();
nobilityPacket.Offset = 32;
foreach (var donation in pagedList)
{
nobilityPacket.WriteDonation(donation);
}
player.ClientSocket.Send(nobilityPacket);
}
return(true);
}
/// <summary>
/// Handles the mount skill.
/// </summary>
/// <param name="player">The player.</param>
/// <param name="spellPacket">The spell packet.</param>
/// <returns>True if the skill was handled correctly.</returns>
public static bool Handle(Models.Entities.Player player, Models.Packets.Spells.SpellPacket spellPacket)
{
if (player.Equipments.Get(Enums.ItemPosition.Steed, false) == null)
{
return(false);
}
if (player.ContainsStatusFlag(Enums.StatusFlag.Riding))
{
player.RemoveStatusFlag(Enums.StatusFlag.Riding);
}
else if (player.Stamina < 100)
{
return(false);
}
else
{
player.AddStatusFlag(Enums.StatusFlag.Riding);
}
player.ClientSocket.Send(new Models.Packets.Entities.SteedVigorPacket
{
Type = 2,
Amount = 9001
});
TargetFinalization.SkillFinalize(player, null, spellPacket, 0);
return(true);
}
public static bool HandleKeyExchange(Models.Entities.Player player, SocketPacket socketPacket)
{
byte[] packet = socketPacket;
ushort position = 11;
int JunkLen = BitConverter.ToInt32(packet, position);
position += 4;
position += (ushort)JunkLen;
int Len = BitConverter.ToInt32(packet, position);
position += 4;
byte[] pubKey = new byte[Len];
for (int x = 0; x < Len; x++)
{
pubKey[x] = packet[x + position];
}
position += (ushort)Len;
string PubKey = System.Text.ASCIIEncoding.ASCII.GetString(pubKey);
byte[] key = player.KeyExchange.ComputeKey(OpenSSL.BigNumber.FromHexString(PubKey));
var crypto = (BlowfishCryptography)player.ClientSocket.Cryptography;
crypto.SetKey(key);
crypto.EncryptIV = player.KeyExchange.ClientIv;
crypto.DecryptIV = player.KeyExchange.ServerIv;
player.Exchanged = true;
player.ClientSocket.KeyExchange = false;
player.ClientSocket.Suffix = System.Text.Encoding.ASCII.GetBytes("TQServer");
return(true);
}
public static MessagePacket HandlePacket(Models.Entities.Player player, MessagePacket packet, out uint subPacketId)
{
if (packet.From != player.Name)
{
CandyConquer.Database.Dal.Accounts.Ban(
player.DbPlayer.Account, Drivers.Messages.SEND_MESSAGE_FROM_SOMEONE_ELSE,
CandyConquer.Database.Models.DbAccount.BanRangeType.Perm);
player.ClientSocket.Disconnect(Drivers.Messages.SEND_MESSAGE_FROM_SOMEONE_ELSE);
subPacketId = SubCallState.Invalid;
}
else if (packet.Message.StartsWith("@") ||
packet.Message.StartsWith("/") ||
packet.Message.StartsWith("#") ||
packet.Message.StartsWith("."))
{
if (player.Battle != null)
{
subPacketId = SubCallState.DontHandle;
return(packet);
}
player.AddActionLog("Command", packet.Message);
Collections.CommandScriptCollection.Invoke(player, packet.Message, packet.Message.Substring(1), packet.Message[0]);
subPacketId = SubCallState.DontHandle;
}
else
{
player.AddActionLog("ChatMessage-" + packet.MessageType, string.Format("{0} -> {1} : {2}", packet.From, packet.To, packet.Message));
subPacketId = (uint)packet.MessageType;
}
return(packet);
}
/// <summary>
/// Handles the actual buying of an item.
/// </summary>
/// <param name="player">The player.</param>
/// <param name="itemId">The item.</param>
/// <param name="amount">The amount.</param>
/// <param name="money">Boolean indicating whether the buying is by money or not.</param>
/// <returns>True if the buy was a success.</returns>
private static bool HandleBuy(Models.Entities.Player player, uint itemId, uint amount, bool money)
{
var tempItem = Collections.ItemCollection.CreateItemById(itemId);
var price = money ?
tempItem.DbItem.Price * amount :
tempItem.DbItem.CPPrice * amount;
if (money && player.Money < price || !money && player.CPs < price)
{
player.SendFormattedSystemMessage("LOW_MONEY", true, price, money ? "silvers" : "CPs", amount, tempItem.DbItem.Name);
return(true);
}
player.AddActionLog("Buy", "IsMoney : " + money + " : " + itemId);
if (money)
{
player.Money -= price;
}
else
{
player.CPs -= price;
}
for (int i = 0; i < amount; i++)
{
if (!player.Inventory.Add(itemId))
{
player.ClientSocket.Disconnect(string.Format(Drivers.Messages.Errors.FAIL_BUY_ITEMS, itemId, amount, i, tempItem.DbItem.Price, price));
return(false);
}
}
return(true);
}
/// <summary>
/// Creates a new spell collection.
/// </summary>
/// <param name="player">The player.</param>
public SpellCollection(Models.Entities.Player player)
{
_player = player;
_skills = new ConcurrentDictionary <ushort, Skill>();
_proficiencies = new ConcurrentDictionary <ushort, Proficiency>();
}
/// <summary>
/// Donates cps.
/// </summary>
/// <param name="player">The player donating.</param>
/// <param name="amount">The amount to donate.</param>
/// <returns>True if the donation was a success.</returns>
public bool DonateCPs(Models.Entities.Player player, uint amount)
{
if (player.CPs < amount)
{
return(false);
}
player.AddActionLog("DonateCpsGuild", amount);
player.CPs -= amount;
player.GuildMember.DbGuildRank.CPDonation += amount;
player.GuildMember.DbGuildRank.Update();
Guild.DbGuild.CPsFund += amount;
Guild.DbGuild.Update();
player.UpdateClientGuild();
player.ClientSocket.Send(new Models.Packets.Guilds.GuildDonationPacket
{
Flags = Enums.GuildDonationFlags.AllDonations,
Money = player.GuildMember.DbGuildRank.SilverDonation,
CPs = player.GuildMember.DbGuildRank.CPDonation
});
_cachedSortedMembers = null;
SendMessageFormat("GUILD_DONATE", Enums.GuildMessageType.Green, player.Name, amount, "CPs");
return(true);
}
/// <summary>
/// Attempts to create a guild.
/// </summary>
/// <param name="player">The player who becomes the leader.</param>
/// <param name="name">The name of the guild.</param>
/// <returns>True if the guild was created.</returns>
public static bool Create(Models.Entities.Player player, string name)
{
if (GetGuildByName(name) != null)
{
return(false);
}
var guild = new Guild(new Database.Models.DbGuild
{
Name = name,
Announcement = Drivers.Messages.NEW_GUILD_ANNOUNCEMENT,
AnnouncementDate = Drivers.Time.GetTime(Drivers.Time.TimeType.Day),
Fund = 0,
CPsFund = 0,
Level = 0,
Server = Drivers.Settings.WorldSettings.Server
});
if (guild.DbGuild.Create() && _guilds.TryAdd(guild.Id, guild))
{
guild.AddMember(player, Enums.GuildRank.GuildLeader, false);
player.UpdateClientGuild();
player.UpdateScreen(true);
return(true);
}
return(false);
}
public static bool Handle(Models.Entities.Player player, Models.Packets.Trade.TradePacket packet)
{
if (!player.Trade.Trading)
{
return(true);
}
if (!player.Trade.WindowOpen)
{
return(true);
}
uint money = packet.TargetClientId;
if (money > player.Money)
{
player.SendSystemMessage("LOW_MONEY_TRADE");
return(true);
}
player.Trade.Money = money;
packet.Action = Enums.TradeAction.ShowMoney;
player.Trade.Partner.ClientSocket.Send(packet);
return(true);
}
public static bool HandleCourt(Models.Entities.Player player, Models.Packets.Entities.InteractionPacket packet)
{
if (packet.TargetClientId == player.ClientId)
{
return(false);
}
if (player.Spouse != "None")
{
return(true);
}
Models.Maps.IMapObject obj;
if (player.GetFromScreen(packet.TargetClientId, out obj))
{
var marriageTarget = obj as Models.Entities.Player;
if (marriageTarget != null)
{
if (marriageTarget.Spouse != "None")
{
return(true);
}
player.PendingSpouse = marriageTarget.ClientId;
marriageTarget.ClientSocket.Send(packet);
}
}
return(true);
}
/// <summary>
/// Begins the trade.
/// </summary>
/// <param name="partner">The partner.</param>
public void Begin(Models.Entities.Player partner)
{
Reset();
Trading = true;
Partner = partner;
}
public static bool HandleDrawMoney(Models.Entities.Player player, Models.Packets.Items.ItemActionPacket packet)
{
if (player.Guild != null && player.Guild.InHouse(player))
{
if (player.Guild.DbGuild.WHMoney < packet.Data1)
{
return(true);
}
player.Guild.DbGuild.WHMoney -= packet.Data1;
player.Guild.DbGuild.Update();
}
else
{
if (player.WarehouseMoney < packet.Data1)
{
return(true);
}
player.WarehouseMoney -= packet.Data1;
}
player.Money += packet.Data1;
return(true);
}
public static bool HandleRequestInvite(Models.Entities.Player player, Models.Packets.Team.TeamActionPacket packet)
{
if (player.Team == null)
{
return(true);
}
if (!player.Team.IsLeader(player))
{
return(true);
}
Models.Maps.IMapObject mapObject;
if (player.GetFromScreen(packet.ClientId, out mapObject))
{
var newMember = mapObject as Models.Entities.Player;
if (newMember != null && newMember.Team == null)
{
player.Team.PendingInvite = newMember.ClientId;
packet.ClientId = player.ClientId;
newMember.ClientSocket.Send(packet);
}
}
return(true);
}
public static bool Handle(Models.Entities.Player player, Models.Packets.Trade.TradePacket packet)
{
if (!player.Trade.Trading)
{
return(true);
}
if (!player.Trade.WindowOpen)
{
return(true);
}
uint cps = packet.TargetClientId;
if (cps > player.CPs)
{
player.SendSystemMessage("LOW_CPS_TRADE");
return(true);
}
player.Trade.CPs = cps;
packet.Action = Enums.TradeAction.ShowConquerPoints;
player.Trade.Partner.ClientSocket.Send(packet);
return(true);
}
public static bool HandleNpcResponse(Models.Entities.Player player, Models.Packets.Entities.NpcResponsePacket packet)
{
if (!player.Alive)
{
return(true);
}
if (player.CurrentNpc == null)
{
return(true);
}
if (packet.Option == 255)
{
return(true);
}
switch (packet.Action)
{
case Enums.NpcDialogAction.Popup:
case Enums.NpcDialogAction.Answer:
player.AddActionLog("NpcResponse", player.CurrentNpc.ClientId + " : " + packet.Option);
player.NpcInputData = packet.InputData;
player.CurrentNpc.Invoke(player, packet.Option);
break;
}
return(true);
}
public static bool ChangeMap(Models.Entities.Player player, Models.Packets.Client.DataExchangePacket packet)
{
if (player.Map.IsDynamic)
{
if (player.Houses.Count > 0 && player.Houses.GetAll().Any(house => house.DynamicMapId == player.MapId))
{
player.AddActionLog("LeaveHouse");
player.TeleportToLastMap();
return(true);
}
if (player.Guild.InHouse(player))
{
player.AddActionLog("LeaveGuildHouse");
player.TeleportToLastMap();
return(true);
}
}
var coordinate = new Models.Maps.Coordinate(packet.Data1Low, packet.Data1High);
if (Tools.RangeTools.GetDistanceU(player.X, player.Y, coordinate.X, coordinate.Y) <= 5)
{
int mapId = player.MapId;
if (Collections.PortalCollection.Teleport(player, mapId, coordinate.X, coordinate.Y))
{
player.AddActionLog("Portal", string.Format("{0} : {1},{2}", mapId, coordinate.X, coordinate.Y));
return(true);
}
}
player.Pullback();
return(true);
}
/// <summary>
/// Creates a new equipment collection.
/// </summary>
/// <param name="player">The player that owns the equipments.</param>
public Equipments(Models.Entities.Player player)
{
_equipments = new ConcurrentDictionary <CandyConquer.WorldApi.Enums.ItemPosition, CandyConquer.WorldApi.Models.Items.Item>();
_maskedEquipments = new ConcurrentDictionary <CandyConquer.WorldApi.Enums.ItemPosition, Models.Items.Item>();
Player = player;
}
public static bool HandleDismiss(Models.Entities.Player player, Models.Packets.Team.TeamActionPacket packet)
{
if (player.Team == null)
{
return(true);
}
if (!player.Team.IsLeader(player))
{
return(true);
}
if (!player.Alive)
{
return(true);
}
player.RemoveStatusFlag(Enums.StatusFlag.TeamLeader);
var members = player.Team.Delete();
foreach (var member in members)
{
member.Team = null;
member.ClientSocket.Send(packet);
}
return(true);
}
/// <summary>
/// Invokes a script.
/// </summary>
/// <param name="name">The name of the method to invoke.</param>
public static void Invoke(Models.Entities.Player player,
string fullCommand,
string command,
char commandPrefix)
{
Scripts._scripts["HandleCommands"].Invoke(null, new object[] { player, fullCommand, command, commandPrefix });
}
public static bool Handle(Models.Entities.Player player, Models.Packets.Misc.StringPacket packet)
{
var whisperPlayer = Collections.PlayerCollection.GetPlayerByName(packet.Strings[0]);
if (whisperPlayer != null)
{
var guildName = whisperPlayer.Guild != null ? whisperPlayer.Guild.DbGuild.Name : string.Empty;
string infoString = whisperPlayer.ClientId + " ";
infoString += whisperPlayer.Level + " ";
infoString += whisperPlayer.Level + " "; //battle power
infoString += "~" + guildName + " ";
infoString += "# "; //unknown, family ??
infoString += whisperPlayer.Spouse + " ";
infoString += 0 + " "; //unknown
if (whisperPlayer.Mesh % 10 < 3)
{
infoString += "1 ";
}
else
{
infoString += "0 ";
}
var stringPacket = new Models.Packets.Misc.StringPacket
{
Action = Enums.StringAction.WhisperWindowInfo
};
stringPacket.Strings.Add(whisperPlayer.Name);
stringPacket.Strings.Add(infoString);
player.ClientSocket.Send(stringPacket);
}
return(true);
}
public static bool Handle(Models.Entities.Player player, Models.Packets.Trade.TradePacket packet)
{
if (!player.Trade.Trading)
{
return(true);
}
if (!player.Trade.WindowOpen)
{
return(true);
}
Models.Items.Item item;
if (player.Inventory.TryGetItem(packet.TargetClientId, out item))
{
if (!item.Discardable)
{
player.SendSystemMessage("NO_PERMISSION_ITEM");
return(true);
}
if ((player.Trade.Partner.Inventory.Count + player.Trade.Items.Count) >= 40)
{
player.SendSystemMessage("TARGET_FULL_INVENTORY");
return(true);
}
player.Trade.Items.Add(item);
item.UpdateClient(player.Trade.Partner, Enums.ItemUpdateAction.Trade);
}
return(true);
}
public static bool Handle(Models.Entities.Player player, Models.Packets.Arena.ArenaActionPacket packet)
{
Controllers.Arena.ArenaQualifierController.QuitWait(player);
player.ClientSocket.Send(packet);
return(true);
}
/// <summary>
/// Sets the quality of an item.
/// </summary>
/// <param name="owner">The owner of the item.</param>
/// <param name="quality">The quality to set.</param>
/// <returns>True if the quality was set, false if the quality is below the current quality.</returns>
public bool SetQuality(Models.Entities.Player owner, Enums.ItemQuality quality)
{
byte qualityValue = ((byte)quality);
if (qualityValue < ((byte)Quality))
{
return(false);
}
if (IsSteed || IsGarment || IsArrow || IsBottle || IsMountArmor || IsMisc)
{
return(false);
}
uint newItemId = (uint)DbItem.Id;
while ((newItemId % 10) > 5)
{
newItemId--;
}
newItemId += (uint)(qualityValue - 5);
if (!Collections.ItemCollection.Contains(newItemId))
{
return(false);
}
var newItem = Collections.ItemCollection.CreateItemById(newItemId);
if (newItem == null)
{
return(false);
}
if (newItem.DbItem.Name != DbItem.Name)
{
return(false);
}
DbItem = newItem.DbItem;
if (DbOwnerItem == null)
{
DbOwnerItem = new Database.Models.DbOwnerItem();
DbOwnerItem.MaxDura = DbItem.Amount;
DbOwnerItem.CurrentDura = DbOwnerItem.MaxDura;
Gem1 = Enums.Gem.NoSocket;
Gem2 = Enums.Gem.NoSocket;
}
DbOwnerItem.ItemId = (uint)DbItem.Id;
if (owner != null)
{
UpdateClient(owner, Enums.ItemUpdateAction.Update);
owner.UpdateBaseStats();
}
return(true);
}
public static bool GetAssociation(Models.Entities.Player player, DataExchangePacket packet)
{
// load friends
// load enemies
player.ClientSocket.Send(packet);
return(true);
}
