mirror of
https://github.com/islehorse/HISP.git
synced 2025-04-06 05:05:40 +12:00
8276 lines
412 KiB
C#
Executable file
8276 lines
412 KiB
C#
Executable file
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Net.Sockets;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Drawing;
|
|
|
|
using HISP.Player;
|
|
using HISP.Game;
|
|
using HISP.Security;
|
|
using HISP.Game.Chat;
|
|
using HISP.Player.Equips;
|
|
using HISP.Game.Services;
|
|
using HISP.Game.Inventory;
|
|
using HISP.Game.SwfModules;
|
|
using HISP.Game.Horse;
|
|
using HISP.Game.Events;
|
|
using HISP.Game.Items;
|
|
using HISP.Util;
|
|
|
|
namespace HISP.Server
|
|
{
|
|
public class GameServer
|
|
{
|
|
public static Socket ServerSocket;
|
|
|
|
|
|
public static int IdleTimeout;
|
|
public static int IdleWarning;
|
|
|
|
public static Random RandomNumberGenerator = new Random();
|
|
|
|
// Events
|
|
public static RealTimeRiddle RiddleEvent = RealTimeRiddle.GetRandomRiddle();
|
|
public static TackShopGiveaway TackShopGiveawayEvent = null;
|
|
public static RealTimeQuiz QuizEvent = null;
|
|
public static WaterBalloonGame WaterBalloonEvent = new WaterBalloonGame();
|
|
public static IsleCardTradingGame IsleCardTrading;
|
|
public static ModsRevenge ModsRevengeEvent = new ModsRevenge();
|
|
|
|
/*
|
|
* Private stuff
|
|
*/
|
|
private static int gameTickSpeed = 4800; // Changing this to ANYTHING else will cause desync with the client.
|
|
private static int totalMinutesElapsed = 0;
|
|
private static int oneMinute = 1000 * 60;
|
|
private static Timer gameTimer; // Controls in-game time.
|
|
private static Timer minuteTimer; // ticks every real world minute.
|
|
private static void onGameTick(object state)
|
|
{
|
|
// Tick the game clock.
|
|
World.TickWorldClock();
|
|
|
|
// Start all events with this RaceEvery set.
|
|
Arena.StartArenas(World.ServerTime.Minutes);
|
|
|
|
// Decrement horse train timer
|
|
Database.DecHorseTrainTimeout();
|
|
|
|
// Write time to database:
|
|
Database.SetServerTime(World.ServerTime.Minutes, World.ServerTime.Days, World.ServerTime.Years);
|
|
|
|
// Ranch Windmill Payments
|
|
if (World.ServerTime.Minutes % 720 == 0) // every 12 hours
|
|
{
|
|
Logger.DebugPrint("Paying windmill owners . . . ");
|
|
foreach (Ranch ranch in Ranch.Ranches)
|
|
{
|
|
int ranchOwner = ranch.OwnerId;
|
|
if (ranchOwner != -1)
|
|
{
|
|
int moneyToAdd = 5000 * ranch.GetBuildingCount(8); // Windmill
|
|
if (GameServer.IsUserOnline(ranchOwner))
|
|
GameServer.GetUserById(ranchOwner).AddMoney(moneyToAdd);
|
|
else
|
|
{
|
|
try
|
|
{
|
|
Database.SetPlayerMoney(Database.GetPlayerMoney(ranchOwner) + moneyToAdd, ranchOwner);
|
|
}
|
|
catch (OverflowException)
|
|
{
|
|
Database.SetPlayerMoney(2147483647, ranchOwner);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if((World.StartDate != -1)) // Birthday tokens
|
|
{
|
|
int curTime = (int)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
|
|
if (curTime >= World.StartDate + 378691200)
|
|
{
|
|
Logger.InfoPrint("Your server has been running for 12 years! Adding birthday tokens");
|
|
Database.SetStartTime(-1);
|
|
World.StartDate = -1;
|
|
|
|
|
|
AddItemToAllUsersEvenOffline(Item.BirthdayToken, 10);
|
|
}
|
|
|
|
}
|
|
|
|
gameTimer.Change(gameTickSpeed, gameTickSpeed);
|
|
|
|
}
|
|
private static void onMinuteTick(object state)
|
|
{
|
|
totalMinutesElapsed++;
|
|
|
|
if (totalMinutesElapsed % 8 == 0)
|
|
{
|
|
Database.IncAllUsersFreeTime(1);
|
|
}
|
|
|
|
if (totalMinutesElapsed % 25 == 0)
|
|
{
|
|
|
|
Logger.DebugPrint("Randomizing Weather...");
|
|
foreach (World.Town town in World.Towns)
|
|
{
|
|
if (RandomNumberGenerator.Next(0, 100) < 25)
|
|
{
|
|
town.Weather = town.SelectRandomWeather();
|
|
}
|
|
}
|
|
|
|
foreach (World.Isle isle in World.Isles)
|
|
{
|
|
if (RandomNumberGenerator.Next(0, 100) < 25)
|
|
{
|
|
isle.Weather = isle.SelectRandomWeather();
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* EVENTS
|
|
*/
|
|
|
|
// Mods Revenge
|
|
if(totalMinutesElapsed % ((60*8)+15) == 0)
|
|
{
|
|
ModsRevengeEvent.StartEvent();
|
|
}
|
|
|
|
// Isle Card Trading Game
|
|
if(totalMinutesElapsed % (60 *2) == 0)
|
|
{
|
|
IsleCardTrading = new IsleCardTradingGame();
|
|
IsleCardTrading.StartEvent();
|
|
}
|
|
|
|
// Water Balloon Game
|
|
if(totalMinutesElapsed % (60 * 2) == 0)
|
|
{
|
|
WaterBalloonEvent.StartEvent();
|
|
}
|
|
|
|
// Tack Shop Giveaway
|
|
if(totalMinutesElapsed % ((60 * 3)+5) == 0)
|
|
{
|
|
TackShopGiveawayEvent = new TackShopGiveaway();
|
|
TackShopGiveawayEvent.StartEvent();
|
|
}
|
|
|
|
// Real Time Riddle
|
|
if(totalMinutesElapsed % (RealTimeRiddle.LastWon ? 20 : 15) == 0)
|
|
{
|
|
RiddleEvent = RealTimeRiddle.GetRandomRiddle();
|
|
RiddleEvent.StartEvent();
|
|
}
|
|
|
|
// Real Time Quiz
|
|
if(totalMinutesElapsed % (60 + 30) == 0)
|
|
{
|
|
QuizEvent = new RealTimeQuiz();
|
|
QuizEvent.StartEvent();
|
|
}
|
|
|
|
|
|
if (totalMinutesElapsed % 60 == 0) // Do spoils
|
|
{
|
|
foreach (HorseInstance horse in Database.GetMostSpoiledHorses())
|
|
{
|
|
horse.BasicStats.Health = 1000;
|
|
horse.BasicStats.Mood = 1000;
|
|
horse.BasicStats.Hunger = 1000;
|
|
horse.BasicStats.Thirst = 1000;
|
|
}
|
|
}
|
|
|
|
if (totalMinutesElapsed % 5 == 0)
|
|
{
|
|
Treasure.AddValue();
|
|
}
|
|
|
|
|
|
foreach (GameClient client in GameClient.ConnectedClients)
|
|
{
|
|
if (client == null)
|
|
continue;
|
|
|
|
if (client.LoggedIn)
|
|
{
|
|
if (!client.LoggedinUser.MajorPriority)
|
|
if(!client.LoggedinUser.MinorPriority)
|
|
UpdateArea(client);
|
|
byte[] BaseStatsPacketData = PacketBuilder.CreateMoneyPlayerCountAndMail(client.LoggedinUser.Money, GameServer.GetNumberOfPlayers(), client.LoggedinUser.MailBox.UnreadMailCount);
|
|
client.SendPacket(BaseStatsPacketData);
|
|
|
|
UpdateWorld(client);
|
|
UpdatePlayer(client);
|
|
}
|
|
}
|
|
|
|
foreach(Auction auction in Auction.AuctionRooms.ToArray())
|
|
{
|
|
foreach(Auction.AuctionEntry entry in auction.AuctionEntries.ToArray())
|
|
{
|
|
entry.TimeRemaining--;
|
|
if (entry.Completed)
|
|
auction.DeleteEntry(entry);
|
|
else if (entry.TimeRemaining <= 0)
|
|
entry.Completed = true;
|
|
|
|
auction.UpdateAuctionRoom();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
Database.IncPlayerTirednessForOfflineUsers();
|
|
|
|
// Offline player handling w sql black magic...
|
|
|
|
Database.DecrementHorseLeaseTimeForOfflinePlayers();
|
|
Database.TpOfflinePlayersBackToUniterForOfflinePlayers();
|
|
Database.DeleteExpiredLeasedHorsesForOfflinePlayers();
|
|
|
|
DroppedItems.DespawnItems();
|
|
DroppedItems.GenerateItems();
|
|
|
|
|
|
WildHorse.Update();
|
|
Npc.WanderNpcs();
|
|
minuteTimer.Change(oneMinute, oneMinute);
|
|
}
|
|
|
|
/*
|
|
* This section is where all the event handlers live,
|
|
* eg: OnMovementPacket is whenever the server receies a movement request from the client.
|
|
*/
|
|
|
|
// HI1 Protocol
|
|
|
|
public static void OnPlayerInteration(GameClient sender, byte[] packet)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Requested Bird Map when not logged in.");
|
|
return;
|
|
}
|
|
if(packet.Length >= 2)
|
|
{
|
|
byte method = packet[1];
|
|
switch (method)
|
|
{
|
|
case PacketBuilder.PLAYER_INTERACTION_TRADE_REJECT:
|
|
if (sender.LoggedinUser.TradingWith != null)
|
|
sender.LoggedinUser.TradingWith.CancelTrade();
|
|
break;
|
|
case PacketBuilder.PLAYER_INTERACTION_ACCEPT:
|
|
if (sender.LoggedinUser.TradingWith != null)
|
|
sender.LoggedinUser.TradingWith.AcceptTrade();
|
|
break;
|
|
case PacketBuilder.PLAYER_INTERACTION_PROFILE:
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string playerIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
int playerId = -1;
|
|
try
|
|
{
|
|
playerId = int.Parse(playerIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to view profile of User ID NaN.");
|
|
break;
|
|
}
|
|
|
|
if (IsUserOnline(playerId))
|
|
{
|
|
User user = GetUserById(playerId);
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
|
|
byte[] metaTag = PacketBuilder.CreateMeta(Meta.BuildStatsMenu(user, true));
|
|
sender.SendPacket(metaTag);
|
|
}
|
|
break;
|
|
case PacketBuilder.PLAYER_INTERACTION_MUTE:
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
playerIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
playerId = -1;
|
|
try
|
|
{
|
|
playerId = int.Parse(playerIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to MUTE User ID NaN.");
|
|
break;
|
|
}
|
|
|
|
if (IsUserOnline(playerId))
|
|
{
|
|
User user = GetUserById(playerId);
|
|
if (!sender.LoggedinUser.MutePlayer.IsUserMuted(user))
|
|
sender.LoggedinUser.MutePlayer.MuteUser(user);
|
|
|
|
byte[] nowMuting = PacketBuilder.CreateChat(Messages.FormatNowMutingPlayer(user.Username), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(nowMuting);
|
|
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(Meta.BuildPlayerListMenu(sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
}
|
|
break;
|
|
case PacketBuilder.PLAYER_INTERACTION_UNMUTE:
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
playerIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
playerId = -1;
|
|
try
|
|
{
|
|
playerId = int.Parse(playerIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to UNMUTE User ID NaN.");
|
|
break;
|
|
}
|
|
|
|
if (IsUserOnline(playerId))
|
|
{
|
|
User user = GetUserById(playerId);
|
|
if (sender.LoggedinUser.MutePlayer.IsUserMuted(user))
|
|
sender.LoggedinUser.MutePlayer.UnmuteUser(user);
|
|
|
|
byte[] stoppedMuting = PacketBuilder.CreateChat(Messages.FormatStoppedMutingPlayer(user.Username), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(stoppedMuting);
|
|
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(Meta.BuildPlayerListMenu(sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
}
|
|
break;
|
|
case PacketBuilder.PLAYER_INTERACTION_REMOVE_BUDDY:
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
playerIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
playerId = -1;
|
|
try
|
|
{
|
|
playerId = int.Parse(playerIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to remove User ID NaN as a buddy.");
|
|
break;
|
|
}
|
|
|
|
|
|
if (sender.LoggedinUser.Friends.IsFriend(playerId))
|
|
{
|
|
sender.LoggedinUser.Friends.RemoveFriend(playerId);
|
|
|
|
byte[] friendRemoved = PacketBuilder.CreateChat(Messages.FormatAddBuddyRemoveBuddy(Database.GetUsername(playerId)), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(friendRemoved);
|
|
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(Meta.BuildPlayerListMenu(sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
}
|
|
|
|
break;
|
|
case PacketBuilder.PLAYER_INTERACTION_TAG:
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
playerIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
playerId = -1;
|
|
try
|
|
{
|
|
playerId = int.Parse(playerIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to trade with User ID NaN.");
|
|
break;
|
|
}
|
|
|
|
if (IsUserOnline(playerId))
|
|
{
|
|
User user = GetUserById(playerId); ;
|
|
string TAGYourIT = Messages.FormatTagYourIt(user.Username, sender.LoggedinUser.Username);
|
|
int totalBuds = 0;
|
|
foreach (int friendId in sender.LoggedinUser.Friends.List)
|
|
{
|
|
if (friendId == sender.LoggedinUser.Id)
|
|
continue;
|
|
|
|
if (IsUserOnline(friendId))
|
|
{
|
|
User buddy = GetUserById(friendId);
|
|
byte[] tagYourItPacket = PacketBuilder.CreateChat(TAGYourIT, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
buddy.LoggedinClient.SendPacket(tagYourItPacket);
|
|
totalBuds++;
|
|
}
|
|
}
|
|
string budStr = Messages.FormatTagTotalBuddies(totalBuds);
|
|
|
|
byte[] tagYouItPacket = PacketBuilder.CreateChat(TAGYourIT + budStr, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(tagYouItPacket);
|
|
|
|
}
|
|
break;
|
|
case PacketBuilder.PLAYER_INTERACTION_ADD_BUDDY:
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
playerIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
playerId = -1;
|
|
try
|
|
{
|
|
playerId = int.Parse(playerIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to add friend with User ID NaN.");
|
|
break;
|
|
}
|
|
if (IsUserOnline(playerId))
|
|
{
|
|
User userToAdd = GetUserById(playerId);
|
|
sender.LoggedinUser.Friends.AddFriend(userToAdd);
|
|
}
|
|
break;
|
|
case PacketBuilder.PLAYER_INTERACTION_ADD_ITEM:
|
|
if (sender.LoggedinUser.TradingWith == null)
|
|
break;
|
|
if (packet.Length < 5)
|
|
break;
|
|
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
string idStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
char firstChar = idStr[0];
|
|
switch (firstChar)
|
|
{
|
|
case '3': // Trade Money
|
|
|
|
if (sender.LoggedinUser.Bids.Length > 0)
|
|
{
|
|
byte[] cantBuyWhileAuctioning = PacketBuilder.CreateChat(Messages.AuctionNoOtherTransactionAllowed, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantBuyWhileAuctioning);
|
|
break;
|
|
}
|
|
|
|
sender.LoggedinUser.TradeMenuPriority = true;
|
|
sender.LoggedinUser.AttemptingToOfferItem = -1;
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(Meta.BuildTradeAddMoney(sender.LoggedinUser.TradingWith.MoneyOffered));
|
|
sender.SendPacket(metaPacket);
|
|
|
|
break;
|
|
case '2': // Trade Horse
|
|
string horseRandomIdStr = idStr.Substring(1);
|
|
int horseRandomId = -1;
|
|
try
|
|
{
|
|
horseRandomId = int.Parse(horseRandomIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (!sender.LoggedinUser.HorseInventory.HorseIdExist(horseRandomId))
|
|
break;
|
|
|
|
HorseInstance horse = sender.LoggedinUser.HorseInventory.GetHorseById(horseRandomId);
|
|
if (!sender.LoggedinUser.TradingWith.HorsesOffered.Contains(horse))
|
|
sender.LoggedinUser.TradingWith.OfferHorse(horse);
|
|
|
|
UpdateArea(sender);
|
|
|
|
if (sender.LoggedinUser.TradingWith != null)
|
|
if (!sender.LoggedinUser.TradingWith.OtherTrade.Trader.TradeMenuPriority)
|
|
UpdateArea(sender.LoggedinUser.TradingWith.OtherTrade.Trader.LoggedinClient);
|
|
|
|
break;
|
|
case '1': // Trade Item
|
|
string itemIdStr = idStr.Substring(1);
|
|
int itemId = -1;
|
|
try
|
|
{
|
|
itemId = int.Parse(itemIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (!sender.LoggedinUser.Inventory.HasItemId(itemId))
|
|
break;
|
|
|
|
sender.LoggedinUser.TradeMenuPriority = true;
|
|
sender.LoggedinUser.AttemptingToOfferItem = itemId;
|
|
InventoryItem item = sender.LoggedinUser.Inventory.GetItemByItemId(itemId);
|
|
byte[] addItemPacket = PacketBuilder.CreateMeta(Meta.BuildTradeAddItem(item.ItemInstances.Length));
|
|
sender.SendPacket(addItemPacket);
|
|
break;
|
|
|
|
}
|
|
break;
|
|
case PacketBuilder.PLAYER_INTERACTION_TRADE:
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
playerIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
playerId = -1;
|
|
try
|
|
{
|
|
playerId = int.Parse(playerIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to trade with User ID NaN.");
|
|
break;
|
|
}
|
|
if (IsUserOnline(playerId))
|
|
{
|
|
User user = GetUserById(playerId);
|
|
byte[] tradeMsg = PacketBuilder.CreateChat(Messages.TradeRequiresBothPlayersMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(tradeMsg);
|
|
|
|
sender.LoggedinUser.PendingTradeTo = user.Id;
|
|
|
|
if (user.PendingTradeTo == sender.LoggedinUser.Id)
|
|
{
|
|
// Start Trade
|
|
Trade tradeWithYou = new Trade(sender.LoggedinUser);
|
|
Trade tradeWithOther = new Trade(user);
|
|
tradeWithYou.OtherTrade = tradeWithOther;
|
|
tradeWithOther.OtherTrade = tradeWithYou;
|
|
|
|
sender.LoggedinUser.TradingWith = tradeWithYou;
|
|
user.TradingWith = tradeWithOther;
|
|
|
|
UpdateArea(sender);
|
|
UpdateArea(user.LoggedinClient);
|
|
}
|
|
|
|
}
|
|
break;
|
|
default:
|
|
Logger.DebugPrint("Unknown Player interaction Method: 0x" + method.ToString("X") + " Packet: " + BitConverter.ToString(packet).Replace("-", " "));
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
public static void OnSocialPacket(GameClient sender, byte[] packet)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Tried to be socialable, but has no account and therefor no friends.");
|
|
return;
|
|
}
|
|
byte method = packet[1];
|
|
|
|
switch (method)
|
|
{
|
|
case PacketBuilder.SOCIALS_MENU:
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string playerIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
int playerId = -1;
|
|
try
|
|
{
|
|
playerId = int.Parse(playerIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to socialize with User ID NaN.");
|
|
break;
|
|
}
|
|
|
|
if(IsUserOnline(playerId))
|
|
{
|
|
sender.LoggedinUser.SocializingWith = GetUserById(playerId);
|
|
|
|
sender.LoggedinUser.SocializingWith.AddSocailizedWith(sender.LoggedinUser);
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(Meta.BuildSocialMenu(sender.LoggedinUser.CurrentlyRidingHorse != null));
|
|
sender.SendPacket(metaPacket);
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to socialize with User #"+playerId.ToString()+" but there not online.");
|
|
}
|
|
break;
|
|
case PacketBuilder.SOCIALS_USE:
|
|
int socialId = Convert.ToInt32(packet[2] - (byte)0x21);
|
|
SocialType.Social social = SocialType.GetSocial(socialId);
|
|
/*
|
|
* Check if player being socialed with
|
|
* is actually on this tile, not muted, etc
|
|
*/
|
|
if (sender.LoggedinUser.SocializingWith != null && social.BaseSocialType.Type != "GROUP")
|
|
{
|
|
if (sender.LoggedinUser.SocializingWith.MuteAll || sender.LoggedinUser.SocializingWith.MuteSocials)
|
|
{
|
|
byte[] cantSocialize = PacketBuilder.CreateChat(Messages.PlayerIgnoringAllSocials, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantSocialize);
|
|
break;
|
|
}
|
|
|
|
if (sender.LoggedinUser.SocializingWith.MutePlayer.IsUserMuted(sender.LoggedinUser))
|
|
{
|
|
byte[] cantSocialize = PacketBuilder.CreateChat(Messages.PlayerIgnoringYourSocials, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantSocialize);
|
|
break;
|
|
}
|
|
|
|
if(sender.LoggedinUser.SocializingWith.X != sender.LoggedinUser.X && sender.LoggedinUser.SocializingWith.Y != sender.LoggedinUser.Y)
|
|
{
|
|
byte[] playerNotNearby = PacketBuilder.CreateChat(Messages.SocialPlayerNoLongerNearby, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(playerNotNearby);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
if(social.ForEveryone != null)
|
|
{
|
|
foreach (User user in GetUsersAt(sender.LoggedinUser.X, sender.LoggedinUser.Y, true, true))
|
|
{
|
|
if (social.BaseSocialType.Type != "GROUP")
|
|
if (user.Id == sender.LoggedinUser.SocializingWith.Id)
|
|
continue;
|
|
|
|
if (user.Id == sender.LoggedinUser.Id)
|
|
continue;
|
|
|
|
if (user.MuteAll || user.MuteSocials)
|
|
continue;
|
|
string socialTarget = "";
|
|
if(sender.LoggedinUser.SocializingWith != null)
|
|
socialTarget = sender.LoggedinUser.SocializingWith.Username;
|
|
byte[] msgEveryone = PacketBuilder.CreateChat(Messages.FormatSocialMessage(social.ForEveryone, socialTarget, sender.LoggedinUser.Username), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
user.LoggedinClient.SendPacket(msgEveryone);
|
|
}
|
|
|
|
}
|
|
if(social.ForTarget != null)
|
|
{
|
|
if(sender.LoggedinUser.SocializingWith != null)
|
|
{
|
|
if (social.BaseSocialType.Type != "GROUP")
|
|
{
|
|
byte[] msgTarget = PacketBuilder.CreateChat(Messages.FormatSocialMessage(social.ForTarget, sender.LoggedinUser.SocializingWith.Username, sender.LoggedinUser.Username), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.LoggedinUser.SocializingWith.LoggedinClient.SendPacket(msgTarget);
|
|
}
|
|
}
|
|
}
|
|
if(social.ForSender != null)
|
|
{
|
|
string socialTarget = "";
|
|
if (sender.LoggedinUser.SocializingWith != null)
|
|
socialTarget = sender.LoggedinUser.SocializingWith.Username;
|
|
|
|
byte[] msgSender = PacketBuilder.CreateChat(Messages.FormatSocialMessage(social.ForSender, socialTarget, sender.LoggedinUser.Username), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(msgSender);
|
|
|
|
|
|
}
|
|
|
|
if (social.SoundEffect != null)
|
|
{
|
|
foreach (User user in GetUsersAt(sender.LoggedinUser.X, sender.LoggedinUser.Y, true, true))
|
|
{
|
|
|
|
if (user.MuteAll || user.MuteSocials)
|
|
continue;
|
|
|
|
byte[] soundEffect = PacketBuilder.CreatePlaySound(social.SoundEffect);
|
|
user.LoggedinClient.SendPacket(soundEffect);
|
|
}
|
|
}
|
|
|
|
break;
|
|
default:
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " unknown social: " + method.ToString("X") + " packet dump: " + BitConverter.ToString(packet).Replace("-", " "));
|
|
break;
|
|
}
|
|
|
|
}
|
|
public static void OnBirdMapRequested(GameClient sender, byte[] packet)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Requested Bird Map when not logged in.");
|
|
return;
|
|
}
|
|
|
|
if(sender.LoggedinUser.Inventory.HasItemId(Item.Telescope))
|
|
{
|
|
byte[] birdMapPacket = PacketBuilder.CreateBirdMap(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
sender.SendPacket(birdMapPacket);
|
|
}
|
|
else
|
|
{
|
|
byte[] noTelescopeMessage = PacketBuilder.CreateChat(Messages.NoTelescope, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(noTelescopeMessage);
|
|
}
|
|
}
|
|
|
|
public static void OnAuctionPacket(GameClient sender, byte[] packet)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Sent auction packet when not logged in.");
|
|
return;
|
|
}
|
|
if (packet.Length < 3)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid sized auction packet: " + BitConverter.ToString(packet).Replace("-", " "));
|
|
return;
|
|
}
|
|
byte method = packet[1];
|
|
int bidAmount = 0;
|
|
switch (method)
|
|
{
|
|
case PacketBuilder.AUCTION_BID_100:
|
|
bidAmount = 100;
|
|
goto doBids;
|
|
case PacketBuilder.AUCTION_BID_1K:
|
|
bidAmount = 1000;
|
|
goto doBids;
|
|
case PacketBuilder.AUCTION_BID_10K:
|
|
bidAmount = 10000;
|
|
goto doBids;
|
|
case PacketBuilder.AUCTION_BID_100K:
|
|
bidAmount = 100000;
|
|
goto doBids;
|
|
case PacketBuilder.AUCTION_BID_1M:
|
|
bidAmount = 1000000;
|
|
goto doBids;
|
|
case PacketBuilder.AUCTION_BID_10M:
|
|
bidAmount = 10000000;
|
|
goto doBids;
|
|
case PacketBuilder.AUCITON_BID_100M:
|
|
bidAmount = 100000000;
|
|
doBids:;
|
|
if(World.InSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
World.SpecialTile tile = World.GetSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
if(tile.Code != null)
|
|
{
|
|
if(tile.Code.StartsWith("AUCTION-"))
|
|
{
|
|
Auction auctionRoom = Auction.GetAuctionRoomById(int.Parse(tile.Code.Split('-')[1]));
|
|
int auctionEntryId = -1;
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string auctionEntryStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
try
|
|
{
|
|
auctionEntryId = int.Parse(auctionEntryStr);
|
|
}
|
|
catch(FormatException)
|
|
{
|
|
Logger.ErrorPrint("Cant find auciton entry id NaN.");
|
|
break;
|
|
}
|
|
if (!auctionRoom.HasAuctionEntry(auctionEntryId))
|
|
break;
|
|
|
|
Auction.AuctionEntry entry = auctionRoom.GetAuctionEntry(auctionEntryId);
|
|
entry.Bid(sender.LoggedinUser, bidAmount);
|
|
|
|
UpdateAreaForAll(tile.X, tile.Y, true, null);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
Logger.ErrorPrint("Unknown method id: 0x" + method.ToString("X"));
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
public static void OnHorseInteraction(GameClient sender, byte[] packet)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Sent horse interaction when not logged in.");
|
|
return;
|
|
}
|
|
|
|
if(packet.Length < 2)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid sized horse interaction packet: " + BitConverter.ToString(packet).Replace("-", " "));
|
|
return;
|
|
}
|
|
|
|
byte method = packet[1];
|
|
switch(method)
|
|
{
|
|
case PacketBuilder.HORSE_LIST:
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] metaTags = PacketBuilder.CreateMeta(Meta.BuildHorseInventory(sender.LoggedinUser));
|
|
sender.SendPacket(metaTags);
|
|
break;
|
|
case PacketBuilder.HORSE_PROFILE:
|
|
byte methodProfileEdit = packet[2];
|
|
if(methodProfileEdit == PacketBuilder.HORSE_PROFILE_EDIT)
|
|
{
|
|
if (sender.LoggedinUser.LastViewedHorse != null)
|
|
{
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(Meta.BuildHorseDescriptionEditMeta(sender.LoggedinUser.LastViewedHorse));
|
|
sender.SendPacket(metaPacket);
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + "Trying to edit description of no horse");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.InfoPrint(BitConverter.ToString(packet).Replace("-", " "));
|
|
}
|
|
break;
|
|
case PacketBuilder.HORSE_FEED:
|
|
int randomId = 0;
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
try
|
|
{
|
|
randomId = int.Parse(randomIdStr);
|
|
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid randomid to horse interaction packet ");
|
|
break;
|
|
}
|
|
if (sender.LoggedinUser.HorseInventory.HorseIdExist(randomId))
|
|
{
|
|
HorseInstance horseFeedInst = sender.LoggedinUser.HorseInventory.GetHorseById(randomId);
|
|
|
|
sender.LoggedinUser.LastViewedHorse = horseFeedInst;
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(Meta.BuildHorseFeedMenu(horseFeedInst, sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to feed at a non existant horse.");
|
|
break;
|
|
}
|
|
case PacketBuilder.HORSE_PET:
|
|
randomId = 0;
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
try
|
|
{
|
|
randomId = int.Parse(randomIdStr);
|
|
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid randomid to horse interaction packet ");
|
|
break;
|
|
}
|
|
if (sender.LoggedinUser.HorseInventory.HorseIdExist(randomId))
|
|
{
|
|
HorseInstance horsePetInst = sender.LoggedinUser.HorseInventory.GetHorseById(randomId);
|
|
sender.LoggedinUser.LastViewedHorse = horsePetInst;
|
|
int randMoodAddition = RandomNumberGenerator.Next(1, 20);
|
|
int randTiredMinus = RandomNumberGenerator.Next(1, 10);
|
|
|
|
string msgs = "";
|
|
if (horsePetInst.BasicStats.Mood + randMoodAddition >= 1000)
|
|
{
|
|
msgs += Messages.HorsePetTooHappy;
|
|
}
|
|
|
|
if (horsePetInst.BasicStats.Tiredness - randTiredMinus <= 0)
|
|
{
|
|
msgs += Messages.HorsePetTooTired;
|
|
}
|
|
|
|
horsePetInst.BasicStats.Tiredness -= randTiredMinus;
|
|
horsePetInst.BasicStats.Mood += randMoodAddition;
|
|
|
|
byte[] petMessagePacket = PacketBuilder.CreateChat(Messages.FormatHorsePetMessage(msgs,randMoodAddition, randTiredMinus), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(petMessagePacket);
|
|
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to feed at a non existant horse.");
|
|
break;
|
|
}
|
|
case PacketBuilder.HORSE_VET_SERVICE_ALL:
|
|
|
|
if (World.InSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
World.SpecialTile tile = World.GetSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
if(tile.Code != null)
|
|
{
|
|
if (tile.Code.StartsWith("VET-"))
|
|
{
|
|
string[] vetInfo = tile.Code.Split('-');
|
|
int vetId = int.Parse(vetInfo[1]);
|
|
Vet vet = Vet.GetVetById(vetId);
|
|
int price = 0;
|
|
|
|
foreach (HorseInstance horse in sender.LoggedinUser.HorseInventory.HorseList)
|
|
price += vet.CalculatePrice(horse.BasicStats.Health);
|
|
if (price == 0)
|
|
{
|
|
byte[] notNeededMessagePacket = PacketBuilder.CreateChat(Messages.VetServicesNotNeededAll, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(notNeededMessagePacket);
|
|
break;
|
|
}
|
|
else if (sender.LoggedinUser.Money >= price)
|
|
{
|
|
foreach (HorseInstance horse in sender.LoggedinUser.HorseInventory.HorseList)
|
|
horse.BasicStats.Health = 1000;
|
|
|
|
byte[] healedMessagePacket = PacketBuilder.CreateChat(Messages.VetAllFullHealthRecoveredMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(healedMessagePacket);
|
|
|
|
sender.LoggedinUser.TakeMoney(price);
|
|
|
|
}
|
|
else
|
|
{
|
|
byte[] cannotAffordMessagePacket = PacketBuilder.CreateChat(Messages.VetCannotAffordMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cannotAffordMessagePacket);
|
|
break;
|
|
}
|
|
UpdateArea(sender);
|
|
}
|
|
|
|
}
|
|
}
|
|
break;
|
|
case PacketBuilder.HORSE_VET_SERVICE:
|
|
randomId = 0;
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
|
|
if (randomIdStr == "NaN")
|
|
break;
|
|
|
|
try
|
|
{
|
|
randomId = int.Parse(randomIdStr);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid randomid to horse interaction packet ");
|
|
break;
|
|
}
|
|
if (sender.LoggedinUser.HorseInventory.HorseIdExist(randomId))
|
|
{
|
|
HorseInstance horseVetServiceInst = sender.LoggedinUser.HorseInventory.GetHorseById(randomId);
|
|
sender.LoggedinUser.LastViewedHorse = horseVetServiceInst;
|
|
|
|
if(World.InSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
World.SpecialTile tile = World.GetSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
if(tile.Code != null)
|
|
{
|
|
if (tile.Code.StartsWith("VET-"))
|
|
{
|
|
string[] vetInfo = tile.Code.Split('-');
|
|
int vetId = int.Parse(vetInfo[1]);
|
|
|
|
Vet vet = Vet.GetVetById(vetId);
|
|
int price = vet.CalculatePrice(horseVetServiceInst.BasicStats.Health);
|
|
if (sender.LoggedinUser.Money >= price)
|
|
{
|
|
horseVetServiceInst.BasicStats.Health = 1000;
|
|
sender.LoggedinUser.TakeMoney(price);
|
|
|
|
byte[] messagePacket = PacketBuilder.CreateChat(Messages.FormatVetHorseAtFullHealthMessage(horseVetServiceInst.Name), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(messagePacket);
|
|
}
|
|
else
|
|
{
|
|
byte[] cantAffordMessage = PacketBuilder.CreateChat(Messages.VetCannotAffordMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantAffordMessage);
|
|
break;
|
|
}
|
|
UpdateArea(sender);
|
|
}
|
|
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to use vet services on a non existant horse.");
|
|
break;
|
|
}
|
|
case PacketBuilder.HORSE_SHOE_STEEL:
|
|
case PacketBuilder.HORSE_SHOE_IRON:
|
|
randomId = 0;
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
|
|
if (randomIdStr == "NaN")
|
|
break;
|
|
|
|
try
|
|
{
|
|
randomId = int.Parse(randomIdStr);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid randomid to horse interaction packet ");
|
|
break;
|
|
}
|
|
if (sender.LoggedinUser.HorseInventory.HorseIdExist(randomId))
|
|
{
|
|
HorseInstance horseFarrierServiceInst = sender.LoggedinUser.HorseInventory.GetHorseById(randomId);
|
|
sender.LoggedinUser.LastViewedHorse = horseFarrierServiceInst;
|
|
|
|
if (World.InSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
World.SpecialTile tile = World.GetSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
if(tile.Code != null)
|
|
{
|
|
if (tile.Code.StartsWith("FARRIER-"))
|
|
{
|
|
string[] farrierInfo = tile.Code.Split('-');
|
|
int farrierId = int.Parse(farrierInfo[1]);
|
|
|
|
Farrier farrier = Farrier.GetFarrierById(farrierId);
|
|
int price = 0;
|
|
int incAmount = 0;
|
|
string msg = "";
|
|
|
|
if (method == PacketBuilder.HORSE_SHOE_STEEL)
|
|
{
|
|
price = farrier.SteelCost;
|
|
incAmount = farrier.SteelShoesAmount;
|
|
msg = Messages.FormatFarrierPutOnSteelShoesMessage(incAmount, 1000);
|
|
}
|
|
else
|
|
{
|
|
price = farrier.IronCost;
|
|
incAmount = farrier.IronShoesAmount;
|
|
msg = Messages.FormatFarrierPutOnIronShoesMessage(incAmount, 1000);
|
|
}
|
|
|
|
if (sender.LoggedinUser.Money >= price)
|
|
{
|
|
horseFarrierServiceInst.BasicStats.Shoes = incAmount;
|
|
sender.LoggedinUser.TakeMoney(price);
|
|
|
|
byte[] messagePacket = PacketBuilder.CreateChat(msg, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(messagePacket);
|
|
}
|
|
else
|
|
{
|
|
byte[] cantAffordMessage = PacketBuilder.CreateChat(Messages.FarrierShoesCantAffordMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantAffordMessage);
|
|
break;
|
|
}
|
|
UpdateArea(sender);
|
|
}
|
|
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to use farrier services on a non existant horse.");
|
|
break;
|
|
}
|
|
case PacketBuilder.HORSE_SHOE_ALL:
|
|
if (World.InSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
World.SpecialTile tile = World.GetSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
if(tile.Code != null)
|
|
{
|
|
if (tile.Code.StartsWith("FARRIER-"))
|
|
{
|
|
string[] farrierInfo = tile.Code.Split('-');
|
|
int farrierId = int.Parse(farrierInfo[1]);
|
|
|
|
Farrier farrier = Farrier.GetFarrierById(farrierId);
|
|
|
|
int totalPrice = 0;
|
|
foreach (HorseInstance horse in sender.LoggedinUser.HorseInventory.HorseList)
|
|
{
|
|
if (horse.BasicStats.Shoes < farrier.SteelShoesAmount)
|
|
{
|
|
totalPrice += farrier.SteelCost;
|
|
}
|
|
}
|
|
|
|
if (sender.LoggedinUser.Money >= totalPrice)
|
|
{
|
|
foreach (HorseInstance horse in sender.LoggedinUser.HorseInventory.HorseList)
|
|
{
|
|
if (horse.BasicStats.Shoes < farrier.SteelShoesAmount)
|
|
{
|
|
horse.BasicStats.Shoes = farrier.SteelShoesAmount;
|
|
}
|
|
}
|
|
sender.LoggedinUser.TakeMoney(totalPrice);
|
|
|
|
byte[] messagePacket = PacketBuilder.CreateChat(Messages.FormatFarrierPutOnSteelShoesAllMesssage(farrier.SteelShoesAmount, 1000), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(messagePacket);
|
|
}
|
|
else
|
|
{
|
|
byte[] cantAffordMessage = PacketBuilder.CreateChat(Messages.FarrierShoesCantAffordMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantAffordMessage);
|
|
break;
|
|
}
|
|
UpdateArea(sender);
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case PacketBuilder.HORSE_GROOM_SERVICE:
|
|
randomId = 0;
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
|
|
if (randomIdStr == "NaN")
|
|
break;
|
|
|
|
try
|
|
{
|
|
randomId = int.Parse(randomIdStr);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid randomid to horse interaction packet ");
|
|
break;
|
|
}
|
|
if (sender.LoggedinUser.HorseInventory.HorseIdExist(randomId))
|
|
{
|
|
HorseInstance groomHorseInst = sender.LoggedinUser.HorseInventory.GetHorseById(randomId);
|
|
sender.LoggedinUser.LastViewedHorse = groomHorseInst;
|
|
|
|
if (World.InSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
World.SpecialTile tile = World.GetSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
if(tile.Code != null)
|
|
{
|
|
if (tile.Code.StartsWith("GROOMER-"))
|
|
{
|
|
string[] groomerInfo = tile.Code.Split('-');
|
|
int groomerId = int.Parse(groomerInfo[1]);
|
|
|
|
Groomer groomer = Groomer.GetGroomerById(groomerId);
|
|
int price = groomer.CalculatePrice(groomHorseInst.BasicStats.Groom);
|
|
|
|
|
|
if (sender.LoggedinUser.Money >= price)
|
|
{
|
|
groomHorseInst.BasicStats.Groom = groomer.Max;
|
|
sender.LoggedinUser.TakeMoney(price);
|
|
|
|
byte[] messagePacket = PacketBuilder.CreateChat(Messages.FormatHorseGroomedToBestAbilities(groomHorseInst.Name), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(messagePacket);
|
|
}
|
|
else
|
|
{
|
|
byte[] cantAffordMessage = PacketBuilder.CreateChat(Messages.GroomerCannotAffordMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantAffordMessage);
|
|
break;
|
|
}
|
|
UpdateArea(sender);
|
|
}
|
|
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to use groomer services on a non existant horse.");
|
|
break;
|
|
}
|
|
case PacketBuilder.HORSE_GROOM_SERVICE_ALL:
|
|
if (World.InSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
World.SpecialTile tile = World.GetSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
if(tile.Code != null)
|
|
{
|
|
if (tile.Code.StartsWith("GROOMER-"))
|
|
{
|
|
string[] groomerInfo = tile.Code.Split('-');
|
|
int groomId = int.Parse(groomerInfo[1]);
|
|
Groomer groomer = Groomer.GetGroomerById(groomId);
|
|
int price = 0;
|
|
int count = 0;
|
|
|
|
foreach (HorseInstance horse in sender.LoggedinUser.HorseInventory.HorseList)
|
|
{
|
|
if (horse.BasicStats.Groom < groomer.Max)
|
|
{
|
|
price += groomer.CalculatePrice(horse.BasicStats.Groom);
|
|
count++;
|
|
}
|
|
}
|
|
if (count == 0)
|
|
{
|
|
byte[] notNeededMessagePacket = PacketBuilder.CreateChat(Messages.GroomerDontNeed, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(notNeededMessagePacket);
|
|
break;
|
|
}
|
|
else if (sender.LoggedinUser.Money >= price)
|
|
{
|
|
foreach (HorseInstance horse in sender.LoggedinUser.HorseInventory.HorseList)
|
|
if (horse.BasicStats.Groom < groomer.Max)
|
|
horse.BasicStats.Groom = groomer.Max;
|
|
|
|
byte[] groomedAllHorsesPacket = PacketBuilder.CreateChat(Messages.GroomerBestToHisAbilitiesALL, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(groomedAllHorsesPacket);
|
|
|
|
sender.LoggedinUser.TakeMoney(price);
|
|
|
|
}
|
|
else
|
|
{
|
|
byte[] cannotAffordMessagePacket = PacketBuilder.CreateChat(Messages.GroomerCannotAffordMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cannotAffordMessagePacket);
|
|
break;
|
|
}
|
|
UpdateArea(sender);
|
|
}
|
|
|
|
}
|
|
}
|
|
break;
|
|
case PacketBuilder.HORSE_BARN_SERVICE:
|
|
randomId = 0;
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
|
|
if (randomIdStr == "NaN")
|
|
break;
|
|
|
|
try
|
|
{
|
|
randomId = int.Parse(randomIdStr);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid randomid to horse interaction packet ");
|
|
break;
|
|
}
|
|
if (sender.LoggedinUser.HorseInventory.HorseIdExist(randomId))
|
|
{
|
|
HorseInstance barnHorseInst = sender.LoggedinUser.HorseInventory.GetHorseById(randomId);
|
|
sender.LoggedinUser.LastViewedHorse = barnHorseInst;
|
|
|
|
if (World.InSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
World.SpecialTile tile = World.GetSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
if (tile.Code != null)
|
|
{
|
|
if (tile.Code.StartsWith("BARN-"))
|
|
{
|
|
string[] barnInfo = tile.Code.Split('-');
|
|
int barnId = int.Parse(barnInfo[1]);
|
|
|
|
Barn barn = Barn.GetBarnById(barnId);
|
|
int price = barn.CalculatePrice(barnHorseInst.BasicStats.Tiredness, barnHorseInst.BasicStats.Hunger, barnHorseInst.BasicStats.Thirst); ;
|
|
|
|
|
|
if (sender.LoggedinUser.Money >= price)
|
|
{
|
|
barnHorseInst.BasicStats.Tiredness = 1000;
|
|
barnHorseInst.BasicStats.Hunger = 1000;
|
|
barnHorseInst.BasicStats.Thirst = 1000;
|
|
sender.LoggedinUser.TakeMoney(price);
|
|
|
|
byte[] messagePacket = PacketBuilder.CreateChat(Messages.FormatBarnHorseFullyFed(barnHorseInst.Name), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(messagePacket);
|
|
}
|
|
else
|
|
{
|
|
byte[] cantAffordMessage = PacketBuilder.CreateChat(Messages.BarnCantAffordService, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantAffordMessage);
|
|
break;
|
|
}
|
|
UpdateArea(sender);
|
|
}
|
|
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to use groomer services on a non existant horse.");
|
|
break;
|
|
}
|
|
case PacketBuilder.HORSE_BARN_SERVICE_ALL:
|
|
if (World.InSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
World.SpecialTile tile = World.GetSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
if(tile.Code != null)
|
|
{
|
|
if (tile.Code.StartsWith("BARN-"))
|
|
{
|
|
string[] barnInfo = tile.Code.Split('-');
|
|
int barnId = int.Parse(barnInfo[1]);
|
|
Barn barn = Barn.GetBarnById(barnId);
|
|
int totalPrice = 0;
|
|
|
|
foreach (HorseInstance horse in sender.LoggedinUser.HorseInventory.HorseList)
|
|
{
|
|
int price = barn.CalculatePrice(horse.BasicStats.Tiredness, horse.BasicStats.Hunger, horse.BasicStats.Thirst);
|
|
if (price > 0)
|
|
totalPrice += price;
|
|
}
|
|
if (totalPrice == 0)
|
|
{
|
|
byte[] notNeededMessagePacket = PacketBuilder.CreateChat(Messages.BarnServiceNotNeeded, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(notNeededMessagePacket);
|
|
break;
|
|
}
|
|
else if (sender.LoggedinUser.Money >= totalPrice)
|
|
{
|
|
foreach (HorseInstance horse in sender.LoggedinUser.HorseInventory.HorseList)
|
|
{
|
|
horse.BasicStats.Tiredness = 1000;
|
|
horse.BasicStats.Thirst = 1000;
|
|
horse.BasicStats.Hunger = 1000;
|
|
}
|
|
|
|
byte[] barnedAllHorsesPacket = PacketBuilder.CreateChat(Messages.BarnAllHorsesFullyFed, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(barnedAllHorsesPacket);
|
|
|
|
sender.LoggedinUser.TakeMoney(totalPrice);
|
|
|
|
}
|
|
else
|
|
{
|
|
byte[] cannotAffordMessagePacket = PacketBuilder.CreateChat(Messages.BarnCantAffordService, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cannotAffordMessagePacket);
|
|
break;
|
|
}
|
|
UpdateArea(sender);
|
|
}
|
|
|
|
}
|
|
}
|
|
break;
|
|
case PacketBuilder.HORSE_TRAIN:
|
|
randomId = 0;
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
|
|
if (randomIdStr == "NaN")
|
|
break;
|
|
|
|
try
|
|
{
|
|
randomId = int.Parse(randomIdStr);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid randomid to horse interaction packet ");
|
|
break;
|
|
}
|
|
if (sender.LoggedinUser.HorseInventory.HorseIdExist(randomId))
|
|
{
|
|
HorseInstance trainHorseInst = sender.LoggedinUser.HorseInventory.GetHorseById(randomId);
|
|
sender.LoggedinUser.LastViewedHorse = trainHorseInst;
|
|
|
|
if (World.InSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
World.SpecialTile tile = World.GetSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
if (tile.Code != null)
|
|
{
|
|
if (tile.Code.StartsWith("TRAINER-"))
|
|
{
|
|
if (trainHorseInst.TrainTimer > 0)
|
|
{
|
|
byte[] trainSuccessfulMessage = PacketBuilder.CreateChat(Messages.FormatTrainerCantTrainAgainIn(trainHorseInst.TrainTimer), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(trainSuccessfulMessage);
|
|
break;
|
|
}
|
|
string[] trainerInfo = tile.Code.Split('-');
|
|
int trainerId = int.Parse(trainerInfo[1]);
|
|
|
|
Trainer trainer = Trainer.GetTrainerById(trainerId);
|
|
|
|
if (sender.LoggedinUser.Money >= trainer.MoneyCost)
|
|
{
|
|
sender.LoggedinUser.TakeMoney(trainer.MoneyCost);
|
|
trainHorseInst.BasicStats.Mood -= trainer.MoodCost;
|
|
trainHorseInst.BasicStats.Thirst -= trainer.ThirstCost;
|
|
trainHorseInst.BasicStats.Hunger -= trainer.HungerCost;
|
|
|
|
|
|
switch (trainer.ImprovesStat.ToUpper())
|
|
{
|
|
case "SPEED":
|
|
trainHorseInst.AdvancedStats.Speed += trainer.ImprovesAmount;
|
|
break;
|
|
case "STRENGTH":
|
|
trainHorseInst.AdvancedStats.Strength += trainer.ImprovesAmount;
|
|
break;
|
|
case "AGILITY":
|
|
trainHorseInst.AdvancedStats.Agility += trainer.ImprovesAmount;
|
|
break;
|
|
case "ENDURANCE":
|
|
trainHorseInst.AdvancedStats.Endurance += trainer.ImprovesAmount;
|
|
break;
|
|
case "CONFORMATION":
|
|
trainHorseInst.AdvancedStats.Conformation += trainer.ImprovesAmount;
|
|
break;
|
|
default:
|
|
trainHorseInst.AdvancedStats.Speed += trainer.ImprovesAmount;
|
|
break;
|
|
}
|
|
trainHorseInst.BasicStats.Experience += trainer.ExperienceGained;
|
|
if (!sender.LoggedinUser.Subscribed)
|
|
trainHorseInst.TrainTimer = 1440;
|
|
else
|
|
trainHorseInst.TrainTimer = 720;
|
|
|
|
byte[] trainSuccessfulMessage = PacketBuilder.CreateChat(Messages.FormatTrainedInStatFormat(trainHorseInst.Name, trainer.ImprovesStat), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(trainSuccessfulMessage);
|
|
|
|
|
|
sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.Training).Count++;
|
|
|
|
if (sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.Training).Count >= 1000)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(26)); // Pro Trainer
|
|
if (sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.Training).Count >= 10000)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(53)); // Top Trainer
|
|
|
|
UpdateArea(sender);
|
|
}
|
|
else
|
|
{
|
|
byte[] cantAffordPacket = PacketBuilder.CreateChat(Messages.TrainerCantAfford, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantAffordPacket);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to use trauber services on a non existant horse.");
|
|
break;
|
|
}
|
|
case PacketBuilder.HORSE_GIVE_FEED:
|
|
randomId = 0;
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
try
|
|
{
|
|
randomId = int.Parse(randomIdStr);
|
|
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid randomid to horse interaction packet ");
|
|
break;
|
|
}
|
|
if(sender.LoggedinUser.LastViewedHorse == null)
|
|
{
|
|
Logger.InfoPrint(sender.LoggedinUser.Username + " Tried to feed a non existant horse.");
|
|
break;
|
|
}
|
|
if (sender.LoggedinUser.Inventory.HasItem(randomId))
|
|
{
|
|
InventoryItem item = sender.LoggedinUser.Inventory.GetItemByRandomid(randomId);
|
|
Item.ItemInformation itemInfo = item.ItemInstances[0].GetItemInfo();
|
|
HorseInstance horseInstance = sender.LoggedinUser.LastViewedHorse;
|
|
bool tooMuch = false;
|
|
bool changePersonality = false;
|
|
bool changeInteligence = false;
|
|
|
|
foreach(Item.Effects effect in itemInfo.Effects)
|
|
{
|
|
switch(effect.EffectsWhat)
|
|
{
|
|
case "HEALTH":
|
|
if (horseInstance.BasicStats.Health + effect.EffectAmount > 1000)
|
|
tooMuch = true;
|
|
horseInstance.BasicStats.Health += effect.EffectAmount;
|
|
break;
|
|
case "HUNGER":
|
|
if (horseInstance.BasicStats.Hunger + effect.EffectAmount > 1000)
|
|
tooMuch = true;
|
|
horseInstance.BasicStats.Hunger += effect.EffectAmount;
|
|
break;
|
|
case "MOOD":
|
|
if (horseInstance.BasicStats.Mood + effect.EffectAmount > 1000)
|
|
tooMuch = true;
|
|
horseInstance.BasicStats.Mood += effect.EffectAmount;
|
|
break;
|
|
case "GROOM":
|
|
if (horseInstance.BasicStats.Groom + effect.EffectAmount > 1000)
|
|
tooMuch = true;
|
|
horseInstance.BasicStats.Groom += effect.EffectAmount;
|
|
break;
|
|
case "SHOES":
|
|
if (horseInstance.BasicStats.Shoes + effect.EffectAmount > 1000)
|
|
tooMuch = true;
|
|
horseInstance.BasicStats.Shoes += effect.EffectAmount;
|
|
break;
|
|
case "THIRST":
|
|
if (horseInstance.BasicStats.Thirst + effect.EffectAmount > 1000)
|
|
tooMuch = true;
|
|
horseInstance.BasicStats.Thirst += effect.EffectAmount;
|
|
break;
|
|
case "TIREDNESS":
|
|
if (horseInstance.BasicStats.Tiredness + effect.EffectAmount > 1000)
|
|
tooMuch = true;
|
|
horseInstance.BasicStats.Tiredness += effect.EffectAmount;
|
|
break;
|
|
case "INTELLIGENCEOFFSET":
|
|
horseInstance.AdvancedStats.Inteligence += effect.EffectAmount;
|
|
changeInteligence = true;
|
|
break;
|
|
case "PERSONALITYOFFSET":
|
|
horseInstance.AdvancedStats.Personality += effect.EffectAmount;
|
|
changePersonality = true;
|
|
|
|
break;
|
|
case "SPOILED":
|
|
horseInstance.Spoiled += effect.EffectAmount;
|
|
break;
|
|
}
|
|
}
|
|
sender.LoggedinUser.Inventory.Remove(item.ItemInstances[0]);
|
|
|
|
if(changePersonality)
|
|
{
|
|
byte[] personalityIncreased = PacketBuilder.CreateChat(Messages.HorseFeedPersonalityIncreased, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(personalityIncreased);
|
|
}
|
|
if (changeInteligence)
|
|
{
|
|
byte[] inteligenceIncreased = PacketBuilder.CreateChat(Messages.HorseFeedInteligenceIncreased, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(inteligenceIncreased);
|
|
}
|
|
|
|
if(item.ItemId == Item.MagicDroplet)
|
|
{
|
|
string oldColor = horseInstance.Color;
|
|
string newColor = horseInstance.Breed.Colors[RandomNumberGenerator.Next(0, horseInstance.Breed.Colors.Length)];
|
|
|
|
horseInstance.Color = newColor;
|
|
horseInstance.MagicUsed++;
|
|
|
|
byte[] magicDropletUsed = PacketBuilder.CreateChat(Messages.FormatHorseFeedMagicDropletUsed(oldColor, newColor), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(magicDropletUsed);
|
|
}
|
|
|
|
if(item.ItemId == Item.MagicBean)
|
|
{
|
|
double oldH = HorseInfo.CalculateHands(horseInstance.AdvancedStats.Height, false);
|
|
int newHeight = RandomNumberGenerator.Next(horseInstance.Breed.BaseStats.MinHeight, horseInstance.Breed.BaseStats.MaxHeight+1);
|
|
double newH = HorseInfo.CalculateHands(newHeight, false);
|
|
|
|
horseInstance.AdvancedStats.Height = newHeight;
|
|
horseInstance.MagicUsed++;
|
|
|
|
byte[] magicBeansUsed = PacketBuilder.CreateChat(Messages.FormatHorseFeedMagicBeanUsed(oldH, newH), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(magicBeansUsed);
|
|
}
|
|
|
|
byte[] horseNeighThanksPacket = PacketBuilder.CreateChat(Messages.HorseNeighsThanks, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(horseNeighThanksPacket);
|
|
|
|
if (tooMuch)
|
|
{
|
|
byte[] horseCouldntFinishItAll = PacketBuilder.CreateChat(Messages.HorseCouldNotFinish, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(horseCouldntFinishItAll);
|
|
}
|
|
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(Meta.BuildHorseFeedMenu(sender.LoggedinUser.LastViewedHorse, sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
|
|
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to feed a non existant item to a horse.");
|
|
break;
|
|
}
|
|
case PacketBuilder.HORSE_ENTER_ARENA:
|
|
randomId = 0;
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
try
|
|
{
|
|
randomId = int.Parse(randomIdStr);
|
|
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid randomid to horse interaction packet ");
|
|
break;
|
|
}
|
|
if (sender.LoggedinUser.HorseInventory.HorseIdExist(randomId))
|
|
{
|
|
HorseInstance horseInstance = sender.LoggedinUser.HorseInventory.GetHorseById(randomId);
|
|
if(World.InSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
World.SpecialTile tile = World.GetSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
if(tile.Code != null)
|
|
{
|
|
if (tile.Code.StartsWith("ARENA-"))
|
|
{
|
|
string[] arenaInfo = tile.Code.Split('-');
|
|
int arenaId = int.Parse(arenaInfo[1]);
|
|
Arena arena = Arena.GetAreaById(arenaId);
|
|
if (!Arena.UserHasEnteredHorseInAnyArena(sender.LoggedinUser))
|
|
{
|
|
if (horseInstance.BasicStats.Thirst <= 200)
|
|
{
|
|
byte[] tooThirsty = PacketBuilder.CreateChat(Messages.ArenaTooThirsty, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(tooThirsty);
|
|
break;
|
|
}
|
|
else if (horseInstance.BasicStats.Hunger <= 200)
|
|
{
|
|
byte[] tooHungry = PacketBuilder.CreateChat(Messages.ArenaTooHungry, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(tooHungry);
|
|
break;
|
|
}
|
|
else if (horseInstance.BasicStats.Shoes <= 200)
|
|
{
|
|
byte[] needsFarrier = PacketBuilder.CreateChat(Messages.ArenaNeedsFarrier, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(needsFarrier);
|
|
break;
|
|
}
|
|
else if (horseInstance.BasicStats.Tiredness <= 200)
|
|
{
|
|
byte[] tooTired = PacketBuilder.CreateChat(Messages.ArenaTooTired, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(tooTired);
|
|
break;
|
|
}
|
|
else if (horseInstance.BasicStats.Health <= 200)
|
|
{
|
|
byte[] needsVet = PacketBuilder.CreateChat(Messages.ArenaNeedsVet, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(needsVet);
|
|
break;
|
|
}
|
|
|
|
|
|
|
|
if (sender.LoggedinUser.Money >= arena.EntryCost)
|
|
{
|
|
arena.AddEntry(sender.LoggedinUser, horseInstance);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
byte[] cantAffordEntryFee = PacketBuilder.CreateChat(Messages.ArenaCantAfford, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantAffordEntryFee);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
byte[] allreadyEntered = PacketBuilder.CreateChat(Messages.ArenaAlreadyEntered, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(allreadyEntered);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to enter a non existant horse into a competition.");
|
|
break;
|
|
}
|
|
break;
|
|
case PacketBuilder.HORSE_RELEASE:
|
|
randomId = 0;
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
try
|
|
{
|
|
randomId = int.Parse(randomIdStr);
|
|
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid randomid to horse interaction packet ");
|
|
break;
|
|
}
|
|
if (sender.LoggedinUser.HorseInventory.HorseIdExist(randomId))
|
|
{
|
|
if(World.InTown(sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to reelease a horse while inside a town....");
|
|
break;
|
|
}
|
|
|
|
|
|
HorseInstance horseReleaseInst = sender.LoggedinUser.HorseInventory.GetHorseById(randomId);
|
|
if(sender.LoggedinUser.CurrentlyRidingHorse != null)
|
|
{
|
|
if(horseReleaseInst.RandomId == sender.LoggedinUser.CurrentlyRidingHorse.RandomId)
|
|
{
|
|
byte[] errorChatPacket = PacketBuilder.CreateChat(Messages.HorseCantReleaseTheHorseYourRidingOn, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(errorChatPacket);
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
if (horseReleaseInst.Description == "")
|
|
horseReleaseInst.Description += Messages.FormatHorseReleasedBy(sender.LoggedinUser.Username);
|
|
|
|
Logger.InfoPrint(sender.LoggedinUser.Username + " RELEASED HORSE: " + horseReleaseInst.Name + " (a " + horseReleaseInst.Breed.Name + ").");
|
|
|
|
sender.LoggedinUser.HorseInventory.DeleteHorse(horseReleaseInst);
|
|
new WildHorse(horseReleaseInst, sender.LoggedinUser.X, sender.LoggedinUser.Y, 60, true);
|
|
|
|
sender.LoggedinUser.LastViewedHorse = horseReleaseInst;
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(Meta.BuildHorseReleased());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to release at a non existant horse.");
|
|
break;
|
|
}
|
|
case PacketBuilder.HORSE_TACK:
|
|
randomId = 0;
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
try
|
|
{
|
|
randomId = int.Parse(randomIdStr);
|
|
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid randomid to horse interaction packet ");
|
|
break;
|
|
}
|
|
if (sender.LoggedinUser.HorseInventory.HorseIdExist(randomId))
|
|
{
|
|
HorseInstance horseTackInst = sender.LoggedinUser.HorseInventory.GetHorseById(randomId);
|
|
|
|
sender.LoggedinUser.LastViewedHorse = horseTackInst;
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(Meta.BuildTackMenu(horseTackInst, sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to tack at a non existant horse.");
|
|
break;
|
|
}
|
|
case PacketBuilder.HORSE_DRINK:
|
|
if(World.InSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
World.SpecialTile tile = World.GetSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
if(tile.Code != "POND")
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to drink from a pond when not on one.");
|
|
break;
|
|
}
|
|
}
|
|
|
|
randomId = 0;
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
try
|
|
{
|
|
randomId = int.Parse(randomIdStr);
|
|
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid randomid to horse interaction packet ");
|
|
break;
|
|
}
|
|
if (sender.LoggedinUser.HorseInventory.HorseIdExist(randomId))
|
|
{
|
|
HorseInstance horseDrinkInst = sender.LoggedinUser.HorseInventory.GetHorseById(randomId);
|
|
|
|
if(horseDrinkInst.BasicStats.Health < 200)
|
|
{
|
|
byte[] hpToLow = PacketBuilder.CreateChat(Messages.FormatPondHpLowMessage(horseDrinkInst.Name), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(hpToLow);
|
|
break;
|
|
}
|
|
|
|
if(horseDrinkInst.BasicStats.Thirst < 1000)
|
|
{
|
|
horseDrinkInst.BasicStats.Thirst = 1000;
|
|
byte[] drinkFull = PacketBuilder.CreateChat(Messages.FormatPondDrinkFull(horseDrinkInst.Name),PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(drinkFull);
|
|
|
|
if(RandomNumberGenerator.Next(0, 100) < 25)
|
|
{
|
|
horseDrinkInst.BasicStats.Health -= 200;
|
|
byte[] ohNoes = PacketBuilder.CreateChat(Messages.FormatPondDrinkOhNoes(horseDrinkInst.Name), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(ohNoes);
|
|
}
|
|
|
|
UpdateArea(sender);
|
|
}
|
|
else
|
|
{
|
|
byte[] notThirsty = PacketBuilder.CreateChat(Messages.FormatPondNotThirsty(horseDrinkInst.Name), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(notThirsty);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to tack at a non existant horse.");
|
|
break;
|
|
}
|
|
case PacketBuilder.HORSE_TACK_EQUIP:
|
|
|
|
int itemId = 0;
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
string itemIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
try
|
|
{
|
|
itemId = int.Parse(itemIdStr);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid randomid to horse interaction packet ");
|
|
break;
|
|
}
|
|
if(Item.ItemIdExist(itemId))
|
|
{
|
|
if(sender.LoggedinUser.LastViewedHorse != null)
|
|
{
|
|
if(sender.LoggedinUser.LastViewedHorse.AutoSell > 0)
|
|
{
|
|
byte[] failMessagePacket = PacketBuilder.CreateChat(Messages.HorseTackFailAutoSell, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(failMessagePacket);
|
|
break;
|
|
}
|
|
|
|
if(sender.LoggedinUser.Inventory.HasItemId(itemId))
|
|
{
|
|
Item.ItemInformation itemInfo = Item.GetItemById(itemId);
|
|
if (itemInfo.Type == "TACK")
|
|
{
|
|
switch (itemInfo.GetMiscFlag(0))
|
|
{
|
|
case 1: // Saddle
|
|
if(sender.LoggedinUser.LastViewedHorse.Equipment.Saddle != null)
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(new ItemInstance(sender.LoggedinUser.LastViewedHorse.Equipment.Saddle.Id));
|
|
Database.SetSaddle(sender.LoggedinUser.LastViewedHorse.RandomId, itemInfo.Id);
|
|
sender.LoggedinUser.LastViewedHorse.Equipment.Saddle = itemInfo;
|
|
break;
|
|
case 2: // Saddle Pad
|
|
if (sender.LoggedinUser.LastViewedHorse.Equipment.SaddlePad != null)
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(new ItemInstance(sender.LoggedinUser.LastViewedHorse.Equipment.SaddlePad.Id));
|
|
Database.SetSaddlePad(sender.LoggedinUser.LastViewedHorse.RandomId, itemInfo.Id);
|
|
sender.LoggedinUser.LastViewedHorse.Equipment.SaddlePad = itemInfo;
|
|
break;
|
|
case 3: // Bridle
|
|
if (sender.LoggedinUser.LastViewedHorse.Equipment.Bridle != null)
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(new ItemInstance(sender.LoggedinUser.LastViewedHorse.Equipment.Bridle.Id));
|
|
Database.SetBridle(sender.LoggedinUser.LastViewedHorse.RandomId, itemInfo.Id);
|
|
sender.LoggedinUser.LastViewedHorse.Equipment.Bridle = itemInfo;
|
|
break;
|
|
}
|
|
|
|
|
|
sender.LoggedinUser.Inventory.Remove(sender.LoggedinUser.Inventory.GetItemByItemId(itemId).ItemInstances[0]); // Remove item from inventory.
|
|
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(Meta.BuildTackMenu(sender.LoggedinUser.LastViewedHorse, sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
|
|
byte[] equipMsgPacket = PacketBuilder.CreateChat(Messages.FormatEquipTackMessage(itemInfo.Name, sender.LoggedinUser.LastViewedHorse.Name), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(equipMsgPacket);
|
|
|
|
}
|
|
else if(itemInfo.Type == "COMPANION")
|
|
{
|
|
if (sender.LoggedinUser.LastViewedHorse.Equipment.Companion != null)
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(new ItemInstance(sender.LoggedinUser.LastViewedHorse.Equipment.Companion.Id));
|
|
Database.SetCompanion(sender.LoggedinUser.LastViewedHorse.RandomId, itemInfo.Id);
|
|
sender.LoggedinUser.LastViewedHorse.Equipment.Companion = itemInfo;
|
|
|
|
sender.LoggedinUser.Inventory.Remove(sender.LoggedinUser.Inventory.GetItemByItemId(itemId).ItemInstances[0]); // Remove item from inventory.
|
|
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(Meta.BuildHorseCompanionEquipMenu(sender.LoggedinUser.LastViewedHorse, sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
|
|
byte[] equipMsgPacket = PacketBuilder.CreateChat(Messages.FormatHorseCompanionEquipMessage(sender.LoggedinUser.LastViewedHorse.Name, itemInfo.Name), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(equipMsgPacket);
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to equip a tack item to a hrose but that item was not of type \"TACK\".");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " tried to equip tack he doesnt have");
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to equip tack to a horse when not viewing one.");
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " tried to equip tack he doesnt exist");
|
|
break;
|
|
}
|
|
|
|
break;
|
|
case PacketBuilder.HORSE_TACK_UNEQUIP:
|
|
if (sender.LoggedinUser.LastViewedHorse != null)
|
|
{
|
|
byte equipSlot = packet[2];
|
|
switch(equipSlot)
|
|
{
|
|
case 0x31: // Saddle
|
|
if (sender.LoggedinUser.LastViewedHorse.Equipment.Saddle != null)
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(new ItemInstance(sender.LoggedinUser.LastViewedHorse.Equipment.Saddle.Id));
|
|
Database.ClearSaddle(sender.LoggedinUser.LastViewedHorse.RandomId);
|
|
sender.LoggedinUser.LastViewedHorse.Equipment.Saddle = null;
|
|
break;
|
|
case 0x32: // Saddle Pad
|
|
if (sender.LoggedinUser.LastViewedHorse.Equipment.SaddlePad != null)
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(new ItemInstance(sender.LoggedinUser.LastViewedHorse.Equipment.SaddlePad.Id));
|
|
Database.ClearSaddlePad(sender.LoggedinUser.LastViewedHorse.RandomId);
|
|
sender.LoggedinUser.LastViewedHorse.Equipment.SaddlePad = null;
|
|
break;
|
|
case 0x33: // Bridle
|
|
if (sender.LoggedinUser.LastViewedHorse.Equipment.Bridle != null)
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(new ItemInstance(sender.LoggedinUser.LastViewedHorse.Equipment.Bridle.Id));
|
|
Database.ClearBridle(sender.LoggedinUser.LastViewedHorse.RandomId);
|
|
sender.LoggedinUser.LastViewedHorse.Equipment.Bridle = null;
|
|
break;
|
|
case 0x34: // Companion
|
|
if (sender.LoggedinUser.LastViewedHorse.Equipment.Companion != null)
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(new ItemInstance(sender.LoggedinUser.LastViewedHorse.Equipment.Companion.Id));
|
|
Database.ClearCompanion(sender.LoggedinUser.LastViewedHorse.RandomId);
|
|
sender.LoggedinUser.LastViewedHorse.Equipment.Companion = null;
|
|
goto companionRemove;
|
|
default:
|
|
Logger.ErrorPrint("Unknown equip slot: " + equipSlot.ToString("X"));
|
|
break;
|
|
}
|
|
byte[] itemUnequipedMessage = PacketBuilder.CreateChat(Messages.FormatUnEquipTackMessage(sender.LoggedinUser.LastViewedHorse.Name), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(itemUnequipedMessage);
|
|
|
|
if(sender.LoggedinUser.CurrentlyRidingHorse != null)
|
|
{
|
|
if(sender.LoggedinUser.CurrentlyRidingHorse.RandomId == sender.LoggedinUser.LastViewedHorse.RandomId)
|
|
{
|
|
byte[] disMounted = PacketBuilder.CreateChat(Messages.FormatHorseDismountedBecauseTackedMessage(sender.LoggedinUser.CurrentlyRidingHorse.Name), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.LoggedinUser.Facing %= 5;
|
|
sender.LoggedinUser.CurrentlyRidingHorse = null;
|
|
sender.SendPacket(disMounted);
|
|
}
|
|
}
|
|
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(Meta.BuildTackMenu(sender.LoggedinUser.LastViewedHorse, sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
companionRemove:;
|
|
itemUnequipedMessage = PacketBuilder.CreateChat(Messages.FormatHorseCompanionRemoveMessage(sender.LoggedinUser.LastViewedHorse.Name), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(itemUnequipedMessage);
|
|
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildHorseCompanionEquipMenu(sender.LoggedinUser.LastViewedHorse, sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to unequip items from non existnat horse");
|
|
}
|
|
break;
|
|
case PacketBuilder.HORSE_DISMOUNT:
|
|
randomId = 0;
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
|
|
if(randomIdStr == "") // F7 Shortcut
|
|
{
|
|
if(sender.LoggedinUser.CurrentlyRidingHorse != null)
|
|
{
|
|
|
|
byte[] stopRidingHorseMessagePacket = PacketBuilder.CreateChat(Messages.HorseStopRidingMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(stopRidingHorseMessagePacket);
|
|
|
|
StopRidingHorse(sender);
|
|
}
|
|
else
|
|
{
|
|
if(sender.LoggedinUser.HorseInventory.HorseIdExist(sender.LoggedinUser.LastRiddenHorse))
|
|
StartRidingHorse(sender, sender.LoggedinUser.LastRiddenHorse);
|
|
}
|
|
break;
|
|
}
|
|
|
|
try
|
|
{
|
|
randomId = int.Parse(randomIdStr);
|
|
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid randomid to horse interaction packet ");
|
|
break;
|
|
}
|
|
if (sender.LoggedinUser.HorseInventory.HorseIdExist(randomId))
|
|
{
|
|
|
|
byte[] stopRidingHorseMessagePacket = PacketBuilder.CreateChat(Messages.HorseStopRidingMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(stopRidingHorseMessagePacket);
|
|
|
|
StopRidingHorse(sender);
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to dismount at a non existant horse.");
|
|
break;
|
|
}
|
|
break;
|
|
case PacketBuilder.HORSE_MOUNT:
|
|
randomId = 0;
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
try
|
|
{
|
|
randomId = int.Parse(randomIdStr);
|
|
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid randomid to horse interaction packet ");
|
|
break;
|
|
}
|
|
if (sender.LoggedinUser.HorseInventory.HorseIdExist(randomId))
|
|
{
|
|
StartRidingHorse(sender, randomId);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to mount at a non existant horse.");
|
|
break;
|
|
}
|
|
case PacketBuilder.HORSE_LOOK:
|
|
randomId = 0;
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
HorseInstance horseInst;
|
|
try
|
|
{
|
|
randomId = int.Parse(randomIdStr);
|
|
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid randomid to horse interaction packet ");
|
|
return;
|
|
}
|
|
if(sender.LoggedinUser.HorseInventory.HorseIdExist(randomId))
|
|
{
|
|
horseInst = sender.LoggedinUser.HorseInventory.GetHorseById(randomId);
|
|
UpdateHorseMenu(sender, horseInst);
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{ // Not your horse? possibly viewed inside a ranch?
|
|
horseInst = Database.GetPlayerHorse(randomId);
|
|
UpdateHorseMenu(sender, horseInst);
|
|
break;
|
|
}
|
|
catch(Exception)
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to look at a non existant horse.");
|
|
break;
|
|
}
|
|
}
|
|
|
|
break;
|
|
case PacketBuilder.HORSE_ESCAPE:
|
|
if(WildHorse.DoesHorseExist(sender.LoggedinUser.CapturingHorseId))
|
|
{
|
|
WildHorse capturing = WildHorse.GetHorseById(sender.LoggedinUser.CapturingHorseId);
|
|
sender.LoggedinUser.CapturingHorseId = 0;
|
|
|
|
if (capturing.X == sender.LoggedinUser.X && capturing.Y == sender.LoggedinUser.Y)
|
|
{
|
|
capturing.Escape();
|
|
Logger.InfoPrint(sender.LoggedinUser.Username + " Failed to capture: " + capturing.Instance.Breed.Name + " new location: " + capturing.X + ", " + capturing.Y);
|
|
|
|
}
|
|
}
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] hoseEscaped = PacketBuilder.CreateMeta(Meta.BuildHorseEscapedMessage());
|
|
sender.SendPacket(hoseEscaped);
|
|
break;
|
|
case PacketBuilder.HORSE_CAUGHT:
|
|
if (WildHorse.DoesHorseExist(sender.LoggedinUser.CapturingHorseId))
|
|
{
|
|
WildHorse capturing = WildHorse.GetHorseById(sender.LoggedinUser.CapturingHorseId);
|
|
sender.LoggedinUser.CapturingHorseId = 0;
|
|
|
|
if (capturing.X == sender.LoggedinUser.X && capturing.Y == sender.LoggedinUser.Y)
|
|
{
|
|
try
|
|
{
|
|
capturing.Capture(sender.LoggedinUser);
|
|
}
|
|
catch (InventoryFullException)
|
|
{
|
|
byte[] chatMsg = PacketBuilder.CreateChat(Messages.TooManyHorses, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatMsg);
|
|
break;
|
|
}
|
|
|
|
sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.HorseCapture).Count++;
|
|
|
|
if (sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.HorseCapture).Count >= 100)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(24)); // Wrangler
|
|
if (sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.HorseCapture).Count >= 1000)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(25)); // Pro Wrangler
|
|
|
|
Logger.InfoPrint(sender.LoggedinUser.Username + " Captured a: " + capturing.Instance.Breed.Name);
|
|
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] horseCaught = PacketBuilder.CreateMeta(Meta.BuildHorseCaughtMessage());
|
|
sender.SendPacket(horseCaught);
|
|
|
|
break;
|
|
}
|
|
}
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] horseAllreadyCaught = PacketBuilder.CreateMeta(Meta.BuildHorseEscapedAnyway());
|
|
sender.SendPacket(horseAllreadyCaught);
|
|
break;
|
|
case PacketBuilder.HORSE_TRY_CAPTURE:
|
|
randomId = 0;
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
try
|
|
{
|
|
randomId = int.Parse(randomIdStr);
|
|
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid randomid to horse interaction packet ");
|
|
return;
|
|
}
|
|
if (!WildHorse.DoesHorseExist(randomId))
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to catch a horse that doesnt exist.");
|
|
return;
|
|
}
|
|
|
|
if(sender.LoggedinUser.HorseInventory.HorseList.Length >= sender.LoggedinUser.MaxHorses)
|
|
{
|
|
byte[] caughtTooManyHorses = PacketBuilder.CreateChat(Messages.HorseCatchTooManyHorsesMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(caughtTooManyHorses);
|
|
return;
|
|
}
|
|
|
|
sender.LoggedinUser.CapturingHorseId = randomId;
|
|
byte[] chatPacket = PacketBuilder.CreateChat(Messages.HorseCaptureTimer, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatPacket);
|
|
byte[] swfModulePacket = PacketBuilder.CreateSwfModule("catchhorse", PacketBuilder.PACKET_SWF_MODULE_FORCE);
|
|
sender.SendPacket(swfModulePacket);
|
|
|
|
break;
|
|
default:
|
|
Logger.DebugPrint("Unknown horse packet: " + BitConverter.ToString(packet).Replace("-", " "));
|
|
break;
|
|
}
|
|
}
|
|
|
|
public static void OnDynamicInputReceived(GameClient sender, byte[] packet)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Sent dyamic input when not logged in.");
|
|
return;
|
|
}
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string dynamicInputStr = packetStr.Substring(1, (packetStr.Length - 1) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
if(dynamicInputStr.Contains("|"))
|
|
{
|
|
string[] dynamicInput = dynamicInputStr.Split('|');
|
|
if(dynamicInput.Length >= 1)
|
|
{
|
|
int inputId = 0;
|
|
try
|
|
{
|
|
inputId = int.Parse(dynamicInput[0]);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to send a invalid dynamic input ");
|
|
return;
|
|
}
|
|
|
|
switch(inputId)
|
|
{
|
|
case 1: // Bank
|
|
if (dynamicInput.Length >= 3)
|
|
{
|
|
Int64 moneyDeposited = 0;
|
|
Int64 moneyWithdrawn = 0;
|
|
try
|
|
{
|
|
moneyDeposited = Int64.Parse(dynamicInput[1]);
|
|
moneyWithdrawn = Int64.Parse(dynamicInput[2]);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to deposit/witthdraw NaN money....");
|
|
UpdateArea(sender);
|
|
break;
|
|
}
|
|
|
|
// Check if trying to deposit more than can be held in the bank.
|
|
|
|
if (Convert.ToInt64(sender.LoggedinUser.BankMoney) + moneyDeposited > 9999999999)
|
|
{
|
|
byte[] chatPacket = PacketBuilder.CreateChat(Messages.BankCantHoldThisMuch, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatPacket);
|
|
UpdateArea(sender);
|
|
break;
|
|
}
|
|
|
|
// Check if trying to deposit more than 2.1B
|
|
|
|
if (moneyWithdrawn > 2100000000)
|
|
{
|
|
byte[] chatPacket = PacketBuilder.CreateChat(Messages.BankYouCantHoldThisMuch, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatPacket);
|
|
UpdateArea(sender);
|
|
break;
|
|
}
|
|
|
|
|
|
if((moneyDeposited <= sender.LoggedinUser.Money) && moneyDeposited != 0)
|
|
{
|
|
sender.LoggedinUser.TakeMoney(Convert.ToInt32(moneyDeposited));
|
|
sender.LoggedinUser.BankMoney += moneyDeposited;
|
|
|
|
byte[] chatPacket = PacketBuilder.CreateChat(Messages.FormatDepositedMoneyMessage(Convert.ToInt32(moneyDeposited)), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatPacket);
|
|
}
|
|
|
|
if ((moneyWithdrawn <= sender.LoggedinUser.BankMoney) && moneyWithdrawn != 0)
|
|
{
|
|
sender.LoggedinUser.BankMoney -= moneyWithdrawn;
|
|
sender.LoggedinUser.AddMoney(Convert.ToInt32(moneyWithdrawn));
|
|
|
|
byte[] chatPacket = PacketBuilder.CreateChat(Messages.FormatWithdrawMoneyMessage(Convert.ToInt32(moneyWithdrawn)), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatPacket);
|
|
}
|
|
|
|
UpdateArea(sender);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to send a invalid dynamic input (private notes, wrong size)");
|
|
break;
|
|
}
|
|
case 2: // Send Mail
|
|
if(dynamicInput.Length >= 4)
|
|
{
|
|
string to = dynamicInput[1];
|
|
string subject = dynamicInput[2];
|
|
string message = dynamicInput[3];
|
|
|
|
if(sender.LoggedinUser.Money >= 3)
|
|
{
|
|
if(Database.CheckUserExist(to))
|
|
{
|
|
int playerId = Database.GetUserid(to);
|
|
|
|
sender.LoggedinUser.TakeMoney(3);
|
|
Mailbox.Mail mailMessage = new Mailbox.Mail();
|
|
mailMessage.RandomId = RandomID.NextRandomId();
|
|
mailMessage.FromUser = sender.LoggedinUser.Id;
|
|
mailMessage.ToUser = playerId;
|
|
mailMessage.Timestamp = Convert.ToInt32((DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds);
|
|
mailMessage.Read = false;
|
|
mailMessage.Subject = subject;
|
|
mailMessage.Message = message;
|
|
|
|
if(IsUserOnline(playerId))
|
|
{
|
|
User user = GetUserById(playerId);
|
|
user.MailBox.AddMail(mailMessage);
|
|
|
|
byte[] BaseStatsPacketData = PacketBuilder.CreateMoneyPlayerCountAndMail(user.Money, GameServer.GetNumberOfPlayers(), user.MailBox.UnreadMailCount);
|
|
user.LoggedinClient.SendPacket(BaseStatsPacketData);
|
|
}
|
|
else
|
|
{
|
|
Database.AddMail(mailMessage.RandomId, mailMessage.ToUser, mailMessage.FromUser, mailMessage.Subject, mailMessage.Message, mailMessage.Timestamp, mailMessage.Read);
|
|
}
|
|
|
|
byte[] mailMessageSent = PacketBuilder.CreateChat(Messages.FormatCityHallSendMailMessage(to.ToLower()),PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(mailMessageSent);
|
|
|
|
UpdateArea(sender);
|
|
}
|
|
else
|
|
{
|
|
byte[] userDontExistFormat = PacketBuilder.CreateChat(Messages.FormatCityHallCantFindPlayerMessage(to), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(userDontExistFormat);
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case 3: // Add Item or Money to Trade
|
|
{
|
|
if (dynamicInput.Length >= 2)
|
|
{
|
|
if(sender.LoggedinUser.AttemptingToOfferItem == -1) // Money
|
|
{
|
|
string answer = dynamicInput[1];
|
|
int amountMoney = -1;
|
|
try
|
|
{
|
|
amountMoney = int.Parse(answer);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
byte[] tooMuchMoney = PacketBuilder.CreateChat(Messages.TradeMoneyOfferTooMuch, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(tooMuchMoney);
|
|
break;
|
|
}
|
|
if(amountMoney < 0)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to trade less than 0$");
|
|
}
|
|
if(amountMoney >= sender.LoggedinUser.Money)
|
|
{
|
|
byte[] tooMuchMoney = PacketBuilder.CreateChat(Messages.TradeMoneyOfferTooMuch, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(tooMuchMoney);
|
|
break;
|
|
}
|
|
|
|
sender.LoggedinUser.TradingWith.MoneyOffered = amountMoney;
|
|
|
|
UpdateArea(sender);
|
|
if(sender.LoggedinUser.TradingWith != null)
|
|
if (!sender.LoggedinUser.TradingWith.OtherTrade.Trader.TradeMenuPriority)
|
|
UpdateArea(sender.LoggedinUser.TradingWith.OtherTrade.Trader.LoggedinClient);
|
|
break;
|
|
}
|
|
|
|
|
|
|
|
if (Item.ItemIdExist(sender.LoggedinUser.AttemptingToOfferItem))
|
|
{
|
|
string answer = dynamicInput[1];
|
|
int itemCount = -1;
|
|
try
|
|
{
|
|
itemCount = int.Parse(answer);
|
|
}
|
|
catch(FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to send a invalid dynamic input (Item TRADE, id is NaN)");
|
|
}
|
|
|
|
InventoryItem item = sender.LoggedinUser.Inventory.GetItemByItemId(sender.LoggedinUser.AttemptingToOfferItem);
|
|
|
|
if (itemCount <= 0)
|
|
{
|
|
byte[] MustBeAtleast1 = PacketBuilder.CreateChat(Messages.TradeItemOfferAtleast1, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(MustBeAtleast1);
|
|
break;
|
|
}
|
|
if(itemCount > item.ItemInstances.Length)
|
|
{
|
|
byte[] TooMuchItems = PacketBuilder.CreateChat(Messages.FormatTradeItemOfferTooMuch(item.ItemInstances.Length, itemCount), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(TooMuchItems);
|
|
break;
|
|
}
|
|
|
|
foreach(ItemInstance[] existingItems in sender.LoggedinUser.TradingWith.ItemsOffered)
|
|
{
|
|
if(existingItems[0].ItemId == sender.LoggedinUser.AttemptingToOfferItem)
|
|
{
|
|
sender.LoggedinUser.TradingWith.RemoveOfferedItems(existingItems);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
ItemInstance[] items = new ItemInstance[itemCount];
|
|
for (int i = 0; i < itemCount; i++)
|
|
{
|
|
items[i] = item.ItemInstances[i];
|
|
}
|
|
sender.LoggedinUser.TradingWith.OfferItems(items);
|
|
|
|
UpdateArea(sender);
|
|
if (sender.LoggedinUser.TradingWith != null)
|
|
if (!sender.LoggedinUser.TradingWith.OtherTrade.Trader.TradeMenuPriority)
|
|
UpdateArea(sender.LoggedinUser.TradingWith.OtherTrade.Trader.LoggedinClient);
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to send a invalid dynamic input (Item TRADE, wrong size)");
|
|
break;
|
|
}
|
|
}
|
|
case 6: // Riddle Room
|
|
if (dynamicInput.Length >= 2)
|
|
{
|
|
if (sender.LoggedinUser.LastRiddle != null)
|
|
{
|
|
string answer = dynamicInput[1];
|
|
if(sender.LoggedinUser.LastRiddle.CheckAnswer(sender.LoggedinUser, answer))
|
|
sender.LoggedinUser.LastRiddle = null;
|
|
UpdateArea(sender);
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to send a invalid dynamic input (LastRiddle, wrong size)");
|
|
break;
|
|
}
|
|
case 5: // Horse Description
|
|
if (dynamicInput.Length >= 3)
|
|
{
|
|
if(sender.LoggedinUser.LastViewedHorse != null)
|
|
{
|
|
string desc = dynamicInput[2];
|
|
string name = dynamicInput[1];
|
|
name.Trim();
|
|
desc.Trim();
|
|
|
|
if(name.Length > 50)
|
|
{
|
|
byte[] horseNameTooLongPacket = PacketBuilder.CreateChat(Messages.HorseNameTooLongError, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(horseNameTooLongPacket);
|
|
break;
|
|
}
|
|
|
|
if (desc.Length > 250)
|
|
{
|
|
byte[] horseNameTooLongPacket = PacketBuilder.CreateChat(Messages.HorseNameTooLongError, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(horseNameTooLongPacket);
|
|
break;
|
|
}
|
|
|
|
object filterReason = Chat.FilterMessage(name);
|
|
if (filterReason != null)
|
|
{
|
|
byte[] msg = PacketBuilder.CreateChat(Messages.HorseNameViolationsError, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(msg);
|
|
return;
|
|
}
|
|
|
|
filterReason = Chat.FilterMessage(desc);
|
|
if (filterReason != null)
|
|
{
|
|
Chat.Reason reason = (Chat.Reason)filterReason;
|
|
byte[] msg = PacketBuilder.CreateChat(Messages.FormatHorseProfileBlocked(reason.Message), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(msg);
|
|
return;
|
|
}
|
|
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
sender.LoggedinUser.LastViewedHorse.Name = dynamicInput[1];
|
|
sender.LoggedinUser.LastViewedHorse.Description = dynamicInput[2];
|
|
byte[] horseProfileSavedPacket = PacketBuilder.CreateChat(Messages.FormatHorseSavedProfileMessage(sender.LoggedinUser.LastViewedHorse.Name), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(horseProfileSavedPacket);
|
|
UpdateHorseMenu(sender, sender.LoggedinUser.LastViewedHorse);
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to send a invalid dynamic input (NPC Search, wrong size)");
|
|
break;
|
|
}
|
|
case 4: // NPC Search
|
|
if(dynamicInput.Length >= 2)
|
|
{
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
string metaWindow = Meta.BuildNpcSearch(dynamicInput[1]);
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(metaWindow);
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to send a invalid dynamic input (NPC Search, wrong size)");
|
|
break;
|
|
}
|
|
case 7: // Private Notes
|
|
if (dynamicInput.Length >= 2)
|
|
{
|
|
sender.LoggedinUser.PrivateNotes = dynamicInput[1];
|
|
UpdateStats(sender);
|
|
byte[] chatPacket = PacketBuilder.CreateChat(Messages.PrivateNotesSavedMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatPacket);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to send a invalid dynamic input (private notes, wrong size)");
|
|
break;
|
|
}
|
|
case 10: // Change auto sell price
|
|
if (dynamicInput.Length >= 2)
|
|
{
|
|
if (sender.LoggedinUser.LastViewedHorse != null)
|
|
{
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
HorseInstance horseInstance = sender.LoggedinUser.LastViewedHorse;
|
|
int newSellPrice = 0;
|
|
try
|
|
{
|
|
newSellPrice = int.Parse(dynamicInput[1]);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
newSellPrice = 2147483647; // too high
|
|
}
|
|
|
|
if(newSellPrice > 500000000 || newSellPrice < 0)
|
|
{
|
|
byte[] priceTooHigh = PacketBuilder.CreateChat(Messages.HorseAutoSellValueTooHigh, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(priceTooHigh);
|
|
break;
|
|
}
|
|
byte[] sellPricePacket;
|
|
if (newSellPrice > 0)
|
|
sellPricePacket = PacketBuilder.CreateChat(Messages.FormatAutoSellConfirmedMessage(newSellPrice), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
else
|
|
sellPricePacket = PacketBuilder.CreateChat(Messages.HorseAutoSellRemoved, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(sellPricePacket);
|
|
horseInstance.AutoSell = newSellPrice;
|
|
|
|
UpdateHorseMenu(sender, sender.LoggedinUser.LastViewedHorse);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to send a invalid dynamic input (autosell, wrong size)");
|
|
break;
|
|
}
|
|
break;
|
|
case 11: // Ranch Description Edit
|
|
if (dynamicInput.Length >= 2)
|
|
{
|
|
string title = dynamicInput[1];
|
|
string desc = dynamicInput[2];
|
|
if(sender.LoggedinUser.OwnedRanch != null)
|
|
{
|
|
title.Trim();
|
|
desc.Trim();
|
|
if(title.Length > 100)
|
|
{
|
|
byte[] tooLongPacket = PacketBuilder.CreateChat(Messages.RanchSavedTitleTooLongError, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(tooLongPacket);
|
|
break;
|
|
}
|
|
if (desc.Length > 4000)
|
|
{
|
|
byte[] tooLongPacket = PacketBuilder.CreateChat(Messages.RanchSavedTitleTooLongError, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(tooLongPacket);
|
|
break;
|
|
}
|
|
|
|
object filterReason = Chat.FilterMessage(title);
|
|
if (filterReason != null)
|
|
{
|
|
byte[] msg = PacketBuilder.CreateChat(Messages.RanchSavedTitleViolationsError, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(msg);
|
|
return;
|
|
}
|
|
|
|
filterReason = Chat.FilterMessage(desc);
|
|
if (filterReason != null)
|
|
{
|
|
Chat.Reason reason = (Chat.Reason)filterReason;
|
|
byte[] msg = PacketBuilder.CreateChat(Messages.FormatRanchDesriptionBlocked(reason.Message), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(msg);
|
|
return;
|
|
}
|
|
|
|
|
|
sender.LoggedinUser.OwnedRanch.Title = title;
|
|
sender.LoggedinUser.OwnedRanch.Description = desc;
|
|
}
|
|
byte[] descriptionEditedMessage = PacketBuilder.CreateChat(Messages.RanchSavedRanchDescripton, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(descriptionEditedMessage);
|
|
|
|
/*
|
|
* Pinto bug: Saving ranch description will take you to the STATS menu
|
|
* instead of just back to your ranch.
|
|
*/
|
|
|
|
if (ConfigReader.FixOfficalBugs)
|
|
UpdateArea(sender);
|
|
else
|
|
UpdateStats(sender);
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to send a invalid dynamic input (ranch description, wrong size)");
|
|
break;
|
|
}
|
|
break;
|
|
case 12: // Abuse Report
|
|
if (dynamicInput.Length >= 2)
|
|
{
|
|
string userName = dynamicInput[1];
|
|
string reason = dynamicInput[2];
|
|
if(Database.CheckUserExist(userName))
|
|
{
|
|
if(reason == "")
|
|
{
|
|
byte[] validReasonPlz = PacketBuilder.CreateChat(Messages.AbuseReportProvideValidReason, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(validReasonPlz);
|
|
break;
|
|
}
|
|
|
|
Database.AddReport(sender.LoggedinUser.Username, userName, reason);
|
|
byte[] chatPacket = PacketBuilder.CreateChat(Messages.AbuseReportFiled, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatPacket);
|
|
UpdateArea(sender);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
byte[] chatPacket = PacketBuilder.CreateChat(Messages.FormatAbuseReportPlayerNotFound(userName), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatPacket);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to send a invalid dynamic input (private notes, wrong size)");
|
|
break;
|
|
}
|
|
case 13: // Libary Ranch Search
|
|
if (dynamicInput.Length >= 2)
|
|
{
|
|
string searchQuery = dynamicInput[1];
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] serachResponse = PacketBuilder.CreateMeta(Meta.BuildRanchSearchResults(searchQuery));
|
|
sender.SendPacket(serachResponse);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to send a invalid dynamic input (private notes, wrong size)");
|
|
break;
|
|
}
|
|
case 14:
|
|
if(dynamicInput.Length >= 1)
|
|
{
|
|
string password = dynamicInput[1];
|
|
// Get current tile
|
|
if(World.InSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
World.SpecialTile tile = World.GetSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
if(tile.Code != null)
|
|
{
|
|
if (tile.Code.StartsWith("PASSWORD-"))
|
|
{
|
|
string[] args = tile.Code.Replace("!", "-").Split('-');
|
|
if (args.Length >= 3)
|
|
{
|
|
string expectedPassword = args[1];
|
|
int questId = int.Parse(args[2]);
|
|
if (password.ToLower() == expectedPassword.ToLower())
|
|
{
|
|
Quest.CompleteQuest(sender.LoggedinUser, Quest.GetQuestById(questId), false);
|
|
}
|
|
else
|
|
{
|
|
Quest.QuestResult result = Quest.FailQuest(sender.LoggedinUser, Quest.GetQuestById(questId), true);
|
|
if (result.NpcChat == null || result.NpcChat == "")
|
|
result.NpcChat = Messages.IncorrectPasswordMessage;
|
|
byte[] ChatPacket = PacketBuilder.CreateChat(result.NpcChat, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(ChatPacket);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Send invalid password input request. (Too few arguments!)");
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Send password input request. (Not on password tile!)");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Sent a password while not in a special tile.");
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to send a invalid password request, (wrong size)");
|
|
break;
|
|
}
|
|
|
|
break;
|
|
case 15: // Real Time Quiz
|
|
if (dynamicInput.Length >= 2)
|
|
{
|
|
if(QuizEvent != null)
|
|
{
|
|
if (sender.LoggedinUser.InRealTimeQuiz)
|
|
{
|
|
RealTimeQuiz.Participent participent = QuizEvent.JoinEvent(sender.LoggedinUser);
|
|
string answer = dynamicInput[1];
|
|
participent.CheckAnswer(answer);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to send a invalid dynamic input (RealTimeQuiz, wrong size)");
|
|
break;
|
|
}
|
|
default:
|
|
Logger.ErrorPrint("Unknown dynamic input: " + inputId.ToString() + " packet dump: " + BitConverter.ToString(packet).Replace("-", " "));
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to send a invalid dynamic input (wrong size)");
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public static void OnPlayerInfoPacket(GameClient sender, byte[] packet)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Requests player info when not logged in.");
|
|
return;
|
|
}
|
|
if(packet.Length < 2)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent playerinfo packet of wrong size");
|
|
}
|
|
|
|
byte method = packet[1];
|
|
switch(method)
|
|
{
|
|
case PacketBuilder.PLAYERINFO_PLAYER_LIST:
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(Meta.BuildPlayerListMenu(sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
}
|
|
|
|
}
|
|
public static void OnDynamicButtonPressed(GameClient sender, byte[] packet)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Clicked dynamic button when not logged in.");
|
|
return;
|
|
}
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string buttonIdStr = packetStr.Substring(1, (packetStr.Length - 1) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
|
|
switch(buttonIdStr)
|
|
{
|
|
case "2": // Compose Mail
|
|
if(sender.LoggedinUser.Money <= 3)
|
|
{
|
|
byte[] cantAffordPostage = PacketBuilder.CreateChat(Messages.CityHallCantAffordPostageMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantAffordPostage);
|
|
break;
|
|
}
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(Meta.BuildComposeMailMenu());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "3": // Quest Log
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildQuestLog(sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "4": // View Horse Breeds
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildHorseBreedListLibary());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "5": // Back to horse
|
|
if (sender.LoggedinUser.LastViewedHorse != null)
|
|
UpdateHorseMenu(sender, sender.LoggedinUser.LastViewedHorse);
|
|
break;
|
|
case "6": // Equip companion
|
|
if (sender.LoggedinUser.LastViewedHorse != null)
|
|
{
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
HorseInstance horseInstance = sender.LoggedinUser.LastViewedHorse;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildHorseCompanionEquipMenu(horseInstance,sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
}
|
|
break;
|
|
case "7": // TP To nearest wagon (ranch)
|
|
if(sender.LoggedinUser.OwnedRanch != null)
|
|
{
|
|
if(sender.LoggedinUser.OwnedRanch.GetBuildingCount(7) > 0) // Wagon
|
|
{
|
|
int ranchX = sender.LoggedinUser.OwnedRanch.X;
|
|
int ranchY = sender.LoggedinUser.OwnedRanch.Y;
|
|
|
|
double smallestDistance = Double.PositiveInfinity;
|
|
int smalestTransportPointId = 0;
|
|
for (int i = 0; i < Transport.TransportPoints.Count; i++)
|
|
{
|
|
Transport.TransportPoint tpPoint = Transport.TransportPoints[i];
|
|
|
|
if(Transport.GetTransportLocation(tpPoint.Locations[0]).Type == "WAGON") // is wagon?
|
|
{
|
|
double distance = Helper.PointsToDistance(ranchX, ranchY, tpPoint.X, tpPoint.Y);
|
|
if(distance < smallestDistance)
|
|
{
|
|
smallestDistance = distance;
|
|
smalestTransportPointId = i;
|
|
}
|
|
}
|
|
}
|
|
Transport.TransportPoint newPoint = Transport.TransportPoints[smalestTransportPointId];
|
|
|
|
int newX = newPoint.X;
|
|
int newY = newPoint.Y;
|
|
|
|
if (World.InSpecialTile(newX, newY))
|
|
{
|
|
World.SpecialTile tile = World.GetSpecialTile(newX, newY);
|
|
if (tile.ExitX != 0)
|
|
newX = tile.ExitX;
|
|
if (tile.ExitY != 0)
|
|
newY = tile.ExitY;
|
|
}
|
|
|
|
byte[] transported = PacketBuilder.CreateChat(Messages.RanchWagonDroppedYouOff, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(transported);
|
|
sender.LoggedinUser.Teleport(newX, newY);
|
|
}
|
|
}
|
|
break;
|
|
case "8":
|
|
if(sender.LoggedinUser.LastViewedHorse != null)
|
|
{
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
HorseInstance horseInstance = sender.LoggedinUser.LastViewedHorse;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildHorseReleaseConfirmationMessage(horseInstance));
|
|
sender.SendPacket(metaPacket);
|
|
}
|
|
break;
|
|
case "9": // View Tack (Libary)
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildTackLibary());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "10": // View Companions (Libary)
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildCompanionLibary());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "11": // Randomize horse name
|
|
if (sender.LoggedinUser.LastViewedHorse != null)
|
|
{
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
HorseInstance horseInstance = sender.LoggedinUser.LastViewedHorse;
|
|
horseInstance.ChangeNameWithoutUpdatingDatabase(HorseInfo.GenerateHorseName());
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildHorseDescriptionEditMeta(horseInstance));
|
|
sender.SendPacket(metaPacket);
|
|
}
|
|
break;
|
|
case "12": // View Minigames (Libary)
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildMinigamesLibary());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "13": // Train All (Ranch)
|
|
if (sender.LoggedinUser.OwnedRanch != null)
|
|
{
|
|
if(sender.LoggedinUser.OwnedRanch.GetBuildingCount(6) > 0) // Training Pen
|
|
{
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildRanchTraining(sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
}
|
|
}
|
|
break;
|
|
case "14": // Most Valued Ranches
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildMostValuedRanches());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "15": // Most Richest Players
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildRichestPlayers());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "16": // Most Adventurous Players
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildAdventurousPlayers());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "17": // Most Experienced Players
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildExperiencedPlayers());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "18": // Best Minigame Players
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildMinigamePlayers());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "19": // Most Experienced Horses
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildMostExperienedHoses());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "20": // Minigame Rankings
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildMinigameRankingsForUser(sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "21": // Private Notes
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildPrivateNotes(sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "22": // View Locations (Libary)
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildLocationsLibary());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "23": // View Awards (Libary)
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildAwardsLibary());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "26": // Buy Horse (Auto Sell)
|
|
if(sender.LoggedinUser.LastViewedHorseOther != null)
|
|
{
|
|
bool isOnRanch = false;
|
|
bool isOnPlayer = false;
|
|
HorseInstance horseToSell = sender.LoggedinUser.LastViewedHorseOther;
|
|
if (Ranch.IsRanchOwned(horseToSell.Owner))
|
|
{
|
|
Ranch ranch = Ranch.GetRanchOwnedBy(horseToSell.Owner);
|
|
if(sender.LoggedinUser.X == ranch.X && sender.LoggedinUser.Y == ranch.Y)
|
|
{
|
|
isOnRanch = true;
|
|
}
|
|
|
|
}
|
|
if(GameServer.IsUserOnline(horseToSell.Owner))
|
|
{
|
|
User user = GameServer.GetUserById(horseToSell.Owner);
|
|
if (user.X == sender.LoggedinUser.X && user.Y == sender.LoggedinUser.Y)
|
|
{
|
|
isOnPlayer = true;
|
|
}
|
|
}
|
|
|
|
if (isOnRanch || isOnPlayer)
|
|
{
|
|
|
|
if (horseToSell.AutoSell == 0)
|
|
break;
|
|
if(sender.LoggedinUser.Money >= horseToSell.AutoSell)
|
|
{
|
|
if (sender.LoggedinUser.HorseInventory.HorseList.Length + 1 > sender.LoggedinUser.MaxHorses)
|
|
{
|
|
byte[] tooManyHorses = PacketBuilder.CreateChat(Messages.AutoSellTooManyHorses, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(tooManyHorses);
|
|
break;
|
|
}
|
|
|
|
sender.LoggedinUser.TakeMoney(horseToSell.AutoSell);
|
|
|
|
if (IsUserOnline(horseToSell.Owner))
|
|
{
|
|
User seller = GetUserById(horseToSell.Owner);
|
|
seller.HorseInventory.DeleteHorse(horseToSell, false);
|
|
seller.AddMoney(horseToSell.AutoSell);
|
|
|
|
byte[] horseBrought = PacketBuilder.CreateChat(Messages.FormatAutoSellSold(horseToSell.Name, horseToSell.AutoSell, sender.LoggedinUser.Username), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
seller.LoggedinClient.SendPacket(horseBrought);
|
|
}
|
|
else
|
|
{
|
|
Database.AddMessageToQueue(horseToSell.Owner, Messages.FormatAutoSellSoldOffline(horseToSell.Name, horseToSell.AutoSell, sender.LoggedinUser.Username));
|
|
try
|
|
{
|
|
Database.SetPlayerMoney((Database.GetPlayerMoney(horseToSell.Owner) + horseToSell.AutoSell), horseToSell.Owner);
|
|
}
|
|
catch (OverflowException)
|
|
{
|
|
Database.SetPlayerMoney(2147483647, horseToSell.Owner);
|
|
}
|
|
}
|
|
|
|
horseToSell.Owner = sender.LoggedinUser.Id;
|
|
horseToSell.AutoSell = 0;
|
|
sender.LoggedinUser.HorseInventory.AddHorse(horseToSell, false);
|
|
|
|
byte[] success = PacketBuilder.CreateChat(Messages.FormatAutoSellSuccess(horseToSell.Name), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(success);
|
|
|
|
UpdateArea(sender);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
byte[] noMoney = PacketBuilder.CreateChat(Messages.AutoSellInsufficentFunds, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(noMoney);
|
|
break;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
byte[] notInRightPlace = PacketBuilder.CreateChat(Messages.AutoSellNotStandingInSamePlace, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(notInRightPlace);
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case "24": // Award List
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildAwardList(sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "27": // Ranch Edit
|
|
if(sender.LoggedinUser.OwnedRanch != null)
|
|
{
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildRanchEdit(sender.LoggedinUser.OwnedRanch));
|
|
sender.SendPacket(metaPacket);
|
|
}
|
|
break;
|
|
case "29": // Auto Sell Horses
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildTopAutoSellHorses());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "31":
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildRanchSearchLibary());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "35": // Buddy List
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildBuddyList(sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "36": // Nearby list
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildNearbyList(sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "37": // All Players List
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildPlayerList(sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "40": // All Players Alphabetical
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildPlayerListAlphabetical(sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "30": // Find NPC
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildFindNpcMenu());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "25": // Set auto sell price
|
|
if (sender.LoggedinUser.LastViewedHorse != null)
|
|
{
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
HorseInstance horseInstance = sender.LoggedinUser.LastViewedHorse;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildAutoSellMenu(horseInstance));
|
|
sender.SendPacket(metaPacket);
|
|
}
|
|
break;
|
|
case "33": // View All stats (Horse)
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildAllBasicStats(sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "34": // View Basic stats (Horse)
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildAllStats(sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "38": // Read Books
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildBooksLibary());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "41": // Put horse into auction
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildAuctionHorseList(sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "47":
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildPawneerOrderBreedList());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "53": // Misc Stats / Tracked Items
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildMiscStats(sender.LoggedinUser));
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "58": // Add new item to trade
|
|
if(sender.LoggedinUser.TradingWith != null)
|
|
{
|
|
sender.LoggedinUser.TradeMenuPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildTradeAdd(sender.LoggedinUser.TradingWith));
|
|
sender.SendPacket(metaPacket);
|
|
}
|
|
break;
|
|
case "59": // Done
|
|
if (sender.LoggedinUser.TradingWith != null)
|
|
{
|
|
sender.LoggedinUser.TradingWith.Stage = "DONE";
|
|
|
|
if (sender.LoggedinUser.TradingWith != null)
|
|
if (sender.LoggedinUser.TradingWith.OtherTrade.Trader.TradeMenuPriority == false)
|
|
UpdateArea(sender.LoggedinUser.TradingWith.OtherTrade.Trader.LoggedinClient);
|
|
UpdateArea(sender);
|
|
|
|
}
|
|
break;
|
|
case "60": // Ranch Sell
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildRanchSellConfirmation());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "61": // Most Spoiled Horse
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildMostSpoiledHorses());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "28c1": // Abuse Report
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildAbuseReportPage());
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
case "52c1": // Horse set to KEEPER
|
|
string category = "KEEPER";
|
|
goto setCategory;
|
|
case "52c2": // Horse set to TRAINING
|
|
category = "TRAINING";
|
|
goto setCategory;
|
|
case "52c3": // Horse set to TRADING
|
|
category = "TRADING";
|
|
goto setCategory;
|
|
case "52c4": // Horse set to RETIRED
|
|
category = "RETIRED";
|
|
goto setCategory;
|
|
setCategory:;
|
|
if (sender.LoggedinUser.LastViewedHorse != null)
|
|
{
|
|
sender.LoggedinUser.LastViewedHorse.Category = category;
|
|
byte[] categoryChangedPacket = PacketBuilder.CreateChat(Messages.FormatHorseSetToNewCategory(category), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(categoryChangedPacket);
|
|
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
UpdateHorseMenu(sender, sender.LoggedinUser.LastViewedHorse);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
if(buttonIdStr.StartsWith("39c")) // Book Read
|
|
{
|
|
string idStr = buttonIdStr.Substring(3);
|
|
int bookId = -1;
|
|
try
|
|
{
|
|
bookId = int.Parse(idStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.DebugPrint(sender.LoggedinUser.Username + " Tried to read a book of id NaN");
|
|
break;
|
|
};
|
|
|
|
if(Book.BookExists(bookId))
|
|
{
|
|
Book book = Book.GetBookById(bookId);
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildBookReadLibary(book));
|
|
sender.SendPacket(metaPacket);
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + "Tried to read a book that doesnt exist.");
|
|
}
|
|
break;
|
|
}
|
|
if (buttonIdStr.StartsWith("32c")) // Horse Whisperer
|
|
{
|
|
string idStr = buttonIdStr.Substring(3);
|
|
int breedId = -1;
|
|
try
|
|
{
|
|
breedId = int.Parse(idStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.DebugPrint(sender.LoggedinUser.Username + " Tried to whisper a horse with BreedId NaN.");
|
|
break;
|
|
};
|
|
|
|
if (sender.LoggedinUser.Money < 50000)
|
|
{
|
|
byte[] cannotAffordMessage = PacketBuilder.CreateChat(Messages.WhispererServiceCannotAfford, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cannotAffordMessage);
|
|
break;
|
|
}
|
|
|
|
List<WildHorse> horsesFound = new List<WildHorse>();
|
|
foreach (WildHorse horse in WildHorse.WildHorses)
|
|
{
|
|
if (horse.Instance.Breed.Id == breedId)
|
|
{
|
|
horsesFound.Add(horse);
|
|
}
|
|
}
|
|
int cost = 0;
|
|
if (horsesFound.Count >= 1)
|
|
{
|
|
cost = 50000;
|
|
}
|
|
else
|
|
{
|
|
cost = 10000;
|
|
}
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
|
|
byte[] pricingMessage = PacketBuilder.CreateChat(Messages.FormatWhispererPrice(cost), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(pricingMessage);
|
|
|
|
byte[] serachResultMeta = PacketBuilder.CreateMeta(Meta.BuildWhisperSearchResults(horsesFound.ToArray()));
|
|
sender.SendPacket(serachResultMeta);
|
|
|
|
sender.LoggedinUser.TakeMoney(cost);
|
|
break;
|
|
}
|
|
else if (buttonIdStr.StartsWith("4c")) // Libary Breed Search
|
|
{
|
|
string idStr = buttonIdStr.Substring(2);
|
|
int breedId = -1;
|
|
HorseInfo.Breed horseBreed;
|
|
try
|
|
{
|
|
breedId = int.Parse(idStr);
|
|
horseBreed = HorseInfo.GetBreedById(breedId);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Logger.DebugPrint(sender.LoggedinUser.Username + " Sent invalid libary breed viewer request.");
|
|
break;
|
|
};
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
string metaTag = Meta.BuildBreedViewerLibary(horseBreed);
|
|
metaPacket = PacketBuilder.CreateMeta(metaTag);
|
|
sender.SendPacket(metaPacket);
|
|
|
|
string swf = "breedviewer.swf?terrain=book&breed=" + horseBreed.Swf + "&j=";
|
|
byte[] loadSwf = PacketBuilder.CreateSwfModule(swf, PacketBuilder.PACKET_SWF_MODULE_FORCE);
|
|
sender.SendPacket(loadSwf);
|
|
|
|
break;
|
|
|
|
}
|
|
else if (buttonIdStr.StartsWith("50c"))
|
|
{
|
|
string gender = buttonIdStr.Substring(3);
|
|
if (sender.LoggedinUser.PawneerOrderBreed != null)
|
|
{
|
|
if (sender.LoggedinUser.PawneerOrderBreed.GenderTypes().Contains(gender))
|
|
{
|
|
if (sender.LoggedinUser.Inventory.HasItemId(Item.PawneerOrder))
|
|
{
|
|
sender.LoggedinUser.PawneerOrderGender = gender;
|
|
|
|
HorseInstance horseInstance = new HorseInstance(sender.LoggedinUser.PawneerOrderBreed);
|
|
horseInstance.Color = sender.LoggedinUser.PawneerOrderColor;
|
|
horseInstance.Gender = sender.LoggedinUser.PawneerOrderGender;
|
|
horseInstance.Name = "Pawneer Order";
|
|
|
|
sender.LoggedinUser.Inventory.Remove(sender.LoggedinUser.Inventory.GetItemByItemId(Item.PawneerOrder).ItemInstances[0]);
|
|
sender.LoggedinUser.HorseInventory.AddHorse(horseInstance, true, true);
|
|
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildPawneerOrderFound(horseInstance));
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Error occured when doing a Pawneer Order.");
|
|
break;
|
|
}
|
|
else if (buttonIdStr.StartsWith("49c"))
|
|
{
|
|
string color = buttonIdStr.Substring(3);
|
|
if (sender.LoggedinUser.PawneerOrderBreed != null)
|
|
{
|
|
if (sender.LoggedinUser.PawneerOrderBreed.Colors.Contains(color))
|
|
{
|
|
sender.LoggedinUser.PawneerOrderColor = color;
|
|
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildPawneerOrderGenderList(sender.LoggedinUser.PawneerOrderBreed, color));
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
}
|
|
}
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Asked for a horse of an unknown color " + color);
|
|
break;
|
|
}
|
|
else if (buttonIdStr.StartsWith("48c")) // Pawneer Order Breed Select
|
|
{
|
|
string idStr = buttonIdStr.Substring(3);
|
|
int breedId = -1;
|
|
HorseInfo.Breed breed;
|
|
try
|
|
{
|
|
breedId = int.Parse(idStr);
|
|
breed = HorseInfo.GetBreedById(breedId);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Logger.DebugPrint(sender.LoggedinUser.Username + " Tried to pawner order a horse with id NaN.");
|
|
break;
|
|
}
|
|
sender.LoggedinUser.PawneerOrderBreed = breed;
|
|
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(Meta.BuildPawneerOrderColorList(breed));
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
}
|
|
else if (buttonIdStr.StartsWith("43c")) // Pawn Horse Confirm
|
|
{
|
|
string idStr = buttonIdStr.Substring(3);
|
|
int horseId = -1;
|
|
try
|
|
{
|
|
horseId = int.Parse(idStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.DebugPrint(sender.LoggedinUser.Username + " Tried to pawn a horse with id NaN.");
|
|
break;
|
|
}
|
|
|
|
if (sender.LoggedinUser.HorseInventory.HorseIdExist(horseId))
|
|
{
|
|
HorseInstance inst = sender.LoggedinUser.HorseInventory.GetHorseById(horseId);
|
|
int price = Pawneer.CalculateTotalPrice(inst);
|
|
string name = inst.Name;
|
|
|
|
sender.LoggedinUser.HorseInventory.DeleteHorse(inst); // 1000% a "distant land.."
|
|
sender.LoggedinUser.LastViewedHorse = null;
|
|
|
|
sender.LoggedinUser.AddMoney(price);
|
|
byte[] soldHorseMessage = PacketBuilder.CreateChat(Messages.FormatPawneerSold(name, price), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(soldHorseMessage);
|
|
|
|
sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.HorsePawn).Count++;
|
|
if (sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.HorsePawn).Count >= 100)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(44)); // Vendor
|
|
if (sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.HorsePawn).Count >= 1000)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(45)); // Pro Vendor
|
|
if (sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.HorsePawn).Count >= 10000)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(52)); // Top Vendor
|
|
|
|
UpdateArea(sender);
|
|
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
byte[] cantFindHorse = PacketBuilder.CreateChat(Messages.PawneerHorseNotFound, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantFindHorse);
|
|
}
|
|
break;
|
|
}
|
|
else if (buttonIdStr.StartsWith("51c")) // Pawn Horse
|
|
{
|
|
string idStr = buttonIdStr.Substring(3);
|
|
int horseId = -1;
|
|
try
|
|
{
|
|
horseId = int.Parse(idStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.DebugPrint(sender.LoggedinUser.Username + " Tried to pawn a horse with id NaN.");
|
|
break;
|
|
}
|
|
|
|
if (sender.LoggedinUser.HorseInventory.HorseIdExist(horseId))
|
|
{
|
|
HorseInstance inst = sender.LoggedinUser.HorseInventory.GetHorseById(horseId);
|
|
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] confirmScreen = PacketBuilder.CreateMeta(Meta.BuildPawneerConfimation(inst));
|
|
sender.SendPacket(confirmScreen);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
byte[] cantFindHorse = PacketBuilder.CreateChat(Messages.PawneerHorseNotFound, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantFindHorse);
|
|
}
|
|
break;
|
|
}
|
|
else if (buttonIdStr.StartsWith("42c"))
|
|
{
|
|
string idStr = buttonIdStr.Substring(3);
|
|
int horseId = -1;
|
|
try
|
|
{
|
|
horseId = int.Parse(idStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.DebugPrint(sender.LoggedinUser.Username + " Tried to auction a horse with id NaN.");
|
|
break;
|
|
}
|
|
if (sender.LoggedinUser.HorseInventory.HorseIdExist(horseId))
|
|
{
|
|
HorseInstance inst = sender.LoggedinUser.HorseInventory.GetHorseById(horseId);
|
|
|
|
if(World.InSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
World.SpecialTile tile = World.GetSpecialTile(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
if(tile.Code == null || !tile.Code.StartsWith("AUCTION-"))
|
|
{
|
|
Logger.ErrorPrint("Cant find auction room that " + sender.LoggedinUser.Username + " Is trying to place a horse in.");
|
|
return;
|
|
}
|
|
Auction auctionRoom = Auction.GetAuctionRoomById(int.Parse(tile.Code.Split('-')[1]));
|
|
if(auctionRoom.HasUserPlacedAuctionAllready(sender.LoggedinUser))
|
|
{
|
|
byte[] cantPlaceAuction = PacketBuilder.CreateChat(Messages.AuctionOneHorsePerPlayer, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantPlaceAuction);
|
|
break;
|
|
}
|
|
if (sender.LoggedinUser.Money >= 1000)
|
|
{
|
|
sender.LoggedinUser.TakeMoney(1000);
|
|
Auction.AuctionEntry entry = new Auction.AuctionEntry(8, 0, sender.LoggedinUser.Id);
|
|
entry.Horse = inst;
|
|
entry.OwnerId = sender.LoggedinUser.Id;
|
|
entry.Completed = false;
|
|
inst.Hidden = true;
|
|
auctionRoom.AddEntry(entry);
|
|
UpdateArea(sender);
|
|
UpdateAreaForAll(sender.LoggedinUser.X, sender.LoggedinUser.Y, true);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
byte[] cantAffordAuctionMsg = PacketBuilder.CreateChat(Messages.AuctionCantAffordAuctionFee, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantAffordAuctionMsg);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to auction a horse they did not have.");
|
|
break;
|
|
}
|
|
}
|
|
if (Leaser.LeaserButtonIdExists(buttonIdStr))
|
|
{
|
|
Leaser horseLeaser = Leaser.GetLeaserByButtonId(buttonIdStr);
|
|
|
|
if(sender.LoggedinUser.Money >= horseLeaser.Price)
|
|
{
|
|
if(sender.LoggedinUser.HorseInventory.HorseList.Length + 1 > sender.LoggedinUser.MaxHorses)
|
|
{
|
|
byte[] cantManageHorses = PacketBuilder.CreateChat(Messages.HorseLeaserHorsesFull, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantManageHorses);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
sender.LoggedinUser.TakeMoney(horseLeaser.Price);
|
|
|
|
HorseInstance leaseHorse = horseLeaser.GenerateLeaseHorse();
|
|
|
|
if(leaseHorse.Breed.Id == 170) // UniPeg
|
|
{
|
|
sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.UnipegTeamup).Count++;
|
|
if(sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.UnipegTeamup).Count >= 5)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(55)); // UniPeg Friend
|
|
}
|
|
else if(leaseHorse.Breed.Type == "unicorn")
|
|
{
|
|
sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.UnicornTeamup).Count++;
|
|
if (sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.UnicornTeamup).Count >= 5)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(42)); // Unicorn Friend
|
|
}
|
|
else if(leaseHorse.Breed.Type == "pegasus")
|
|
{
|
|
sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.PegasusTeamup).Count++;
|
|
if (sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.PegasusTeamup).Count >= 5)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(43)); // Pegasus Friend
|
|
}
|
|
|
|
sender.LoggedinUser.HorseInventory.AddHorse(leaseHorse);
|
|
|
|
byte[] addedHorseMeta = PacketBuilder.CreateMeta(Meta.BuildLeaserOnLeaseInfo(horseLeaser));
|
|
sender.SendPacket(addedHorseMeta);
|
|
|
|
byte[] addedNewTempHorseMessage = PacketBuilder.CreateChat(Messages.HorseLeaserTemporaryHorseAdded, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(addedNewTempHorseMessage);
|
|
break;
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
byte[] cantAffordLease = PacketBuilder.CreateChat(Messages.HorseLeaserCantAffordMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantAffordLease);
|
|
break;
|
|
}
|
|
|
|
}
|
|
if(AbuseReport.DoesReasonExist(buttonIdStr))
|
|
{
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
metaPacket = PacketBuilder.CreateMeta(AbuseReport.GetReasonById(buttonIdStr).Meta);
|
|
sender.SendPacket(metaPacket);
|
|
break;
|
|
}
|
|
|
|
Logger.ErrorPrint("Dynamic button #" + buttonIdStr + " unknown... Packet Dump: "+BitConverter.ToString(packet).Replace("-", " "));
|
|
break;
|
|
}
|
|
}
|
|
public static void OnArenaScored(GameClient sender, byte[] packet)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Requested user information when not logged in.");
|
|
return;
|
|
}
|
|
if(packet.Length <= 2)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + "Sent invalid Arena Scored Packet.");
|
|
return;
|
|
}
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string scoreStr = packetStr.Substring(1, (packet.Length - 1) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
int score = -1;
|
|
try
|
|
{
|
|
score = int.Parse(scoreStr);
|
|
}
|
|
catch(FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Scored NAN in an arena.");
|
|
return;
|
|
}
|
|
|
|
if(Arena.UserHasEnteredHorseInAnyArena(sender.LoggedinUser))
|
|
{
|
|
byte[] waitingOnResults = PacketBuilder.CreateChat(Messages.FormatArenaYourScore(score), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(waitingOnResults);
|
|
|
|
Arena enteredArena = Arena.GetArenaUserEnteredIn(sender.LoggedinUser);
|
|
enteredArena.SubmitScore(sender.LoggedinUser, score);
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Scored in an arena while not in one");
|
|
}
|
|
return;
|
|
|
|
}
|
|
public static void OnUserInfoRequest(GameClient sender, byte[] packet)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Requested user information when not logged in.");
|
|
return;
|
|
}
|
|
|
|
// Prevent duplicate requests.
|
|
if (sender.LoggedinUser.UserInfoSend)
|
|
return;
|
|
|
|
sender.LoggedinUser.UserInfoSend = true;
|
|
|
|
// This allows the website to view that the player is online.
|
|
Database.AddOnlineUser(sender.LoggedinUser.Id, sender.LoggedinUser.Administrator, sender.LoggedinUser.Moderator, sender.LoggedinUser.Subscribed, sender.LoggedinUser.NewPlayer);
|
|
|
|
Logger.DebugPrint(sender.LoggedinUser.Username + " Requested user information.");
|
|
User user = sender.LoggedinUser;
|
|
|
|
// Send player current location & map data
|
|
byte[] MovementPacket = PacketBuilder.CreateMovement(user.X, user.Y, user.CharacterId, user.Facing, PacketBuilder.DIRECTION_TELEPORT, true);
|
|
sender.SendPacket(MovementPacket);
|
|
|
|
// Send "Welcome to the Secret Land of Horses" message.
|
|
byte[] WelcomeMessage = PacketBuilder.CreateChat(Messages.FormatWelcomeMessage(user.Username), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(WelcomeMessage);
|
|
|
|
// Send weather effects, and current server time.
|
|
byte[] WorldData = PacketBuilder.CreateTimeAndWeatherUpdate(World.ServerTime.Minutes, World.ServerTime.Days, World.ServerTime.Years, sender.LoggedinUser.GetWeatherSeen());
|
|
sender.SendPacket(WorldData);
|
|
|
|
// if the player is logging in for the first time, send Welcome newest rider of Horse Isle message.
|
|
if (sender.LoggedinUser.NewPlayer)
|
|
{
|
|
byte[] NewUserMessage = PacketBuilder.CreateChat(Messages.NewUserMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(NewUserMessage);
|
|
}
|
|
|
|
// Send Security Codes, used (badly) to verify Minigame Rewards
|
|
byte[] SecCodePacket = PacketBuilder.CreateSecCode(user.SecCodeSeeds, user.SecCodeInc, user.Administrator, user.Moderator);
|
|
sender.SendPacket(SecCodePacket);
|
|
|
|
// Send player money count, total players and total unread mail.
|
|
byte[] BaseStatsPacketData = PacketBuilder.CreateMoneyPlayerCountAndMail(user.Money, GameServer.GetNumberOfPlayers(), user.MailBox.UnreadMailCount);
|
|
sender.SendPacket(BaseStatsPacketData);
|
|
|
|
// Sends Meta Window information (Nearby, current tile, etc)
|
|
UpdateArea(sender);
|
|
|
|
/*
|
|
* Send all nearby players locations to the client
|
|
* if there not nearby, say there at 1000,1000.
|
|
*/
|
|
foreach (GameClient client in GameClient.ConnectedClients)
|
|
{
|
|
if (client.LoggedIn)
|
|
{
|
|
if (client.LoggedinUser.Id != user.Id)
|
|
{
|
|
if(IsOnScreen(client.LoggedinUser.X, client.LoggedinUser.Y, sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
byte[] PlayerInfo = PacketBuilder.CreatePlayerInfoUpdateOrCreate(client.LoggedinUser.X, client.LoggedinUser.Y, client.LoggedinUser.Facing, client.LoggedinUser.CharacterId, client.LoggedinUser.Username);
|
|
sender.SendPacket(PlayerInfo);
|
|
}
|
|
else
|
|
{
|
|
byte[] PlayerInfo = PacketBuilder.CreatePlayerInfoUpdateOrCreate(1000+4, 1000+1, client.LoggedinUser.Facing, client.LoggedinUser.CharacterId, client.LoggedinUser.Username);
|
|
sender.SendPacket(PlayerInfo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Update all nearby users
|
|
* that the new player logged in.
|
|
*/
|
|
foreach (User nearbyUser in GameServer.GetNearbyUsers(sender.LoggedinUser.X, sender.LoggedinUser.Y, false, false))
|
|
if (nearbyUser.Id != sender.LoggedinUser.Id)
|
|
if(!nearbyUser.MajorPriority)
|
|
if(!nearbyUser.MinorPriority)
|
|
UpdateArea(nearbyUser.LoggedinClient);
|
|
|
|
/*
|
|
* Send a list of isles, towns and areas to the player
|
|
* This is used for the world map.
|
|
*/
|
|
|
|
byte[] IsleData = PacketBuilder.CreatePlaceData(World.Isles.ToArray(), World.Towns.ToArray(), World.Areas.ToArray());
|
|
sender.SendPacket(IsleData);
|
|
|
|
// Tells the client which tiles are passable, which the player should appear ontop of and which it should be below.
|
|
byte[] TileFlags = PacketBuilder.CreateTileOverlayFlags(Map.OverlayTileDepth);
|
|
sender.SendPacket(TileFlags);
|
|
|
|
// Send Todays Note:
|
|
byte[] MotdData = PacketBuilder.CreateMotd(Messages.FormatMotd(ConfigReader.Motd));
|
|
sender.SendPacket(MotdData);
|
|
|
|
// Send riddle annoucement
|
|
if (RiddleEvent != null)
|
|
if (RiddleEvent.Active)
|
|
RiddleEvent.ShowStartMessage(sender);
|
|
|
|
/*
|
|
* Gives Queued Items
|
|
* When you buy a PO from the store on the website
|
|
* its added to this queued items list.
|
|
*/
|
|
DoItemPurchases(sender);
|
|
|
|
// Send Queued Messages
|
|
string[] queuedMessages = Database.GetMessageQueue(sender.LoggedinUser.Id);
|
|
foreach(string queuedMessage in queuedMessages)
|
|
{
|
|
byte[] msg = PacketBuilder.CreateChat(Messages.MessageQueueHeader+queuedMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(msg);
|
|
}
|
|
Database.ClearMessageQueue(sender.LoggedinUser.Id);
|
|
|
|
// Send "Playername Logged in" message
|
|
byte[] loginMessageBytes = PacketBuilder.CreateChat(Messages.FormatLoginMessage(sender.LoggedinUser.Username), PacketBuilder.CHAT_BOTTOM_LEFT);
|
|
foreach (GameClient client in GameClient.ConnectedClients)
|
|
if (client.LoggedIn)
|
|
if (!client.LoggedinUser.MuteLogins && !client.LoggedinUser.MuteAll)
|
|
if (client.LoggedinUser.Id != sender.LoggedinUser.Id)
|
|
client.SendPacket(loginMessageBytes);
|
|
|
|
|
|
/*
|
|
* Send players nearby to you
|
|
* your position, otherwise just send 1000,1000
|
|
*/
|
|
byte[] yourPlayerInfo = PacketBuilder.CreatePlayerInfoUpdateOrCreate(sender.LoggedinUser.X, sender.LoggedinUser.Y, sender.LoggedinUser.Facing, sender.LoggedinUser.CharacterId, sender.LoggedinUser.Username);
|
|
byte[] yourPlayerInfoOffscreen = PacketBuilder.CreatePlayerInfoUpdateOrCreate(1000 + 4, 1000 + 1, sender.LoggedinUser.Facing, sender.LoggedinUser.CharacterId, sender.LoggedinUser.Username);
|
|
|
|
foreach (GameClient client in GameClient.ConnectedClients)
|
|
{
|
|
if (client.LoggedIn)
|
|
{
|
|
if (client.LoggedinUser.Id != sender.LoggedinUser.Id)
|
|
{
|
|
if (IsOnScreen(client.LoggedinUser.X, client.LoggedinUser.Y, sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
client.SendPacket(yourPlayerInfo);
|
|
else
|
|
client.SendPacket(yourPlayerInfoOffscreen);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public static void OnSwfModuleCommunication(GameClient sender, byte[] packet)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " tried to send swf communication when not logged in.");
|
|
return;
|
|
}
|
|
if (packet.Length < 3)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid swf commmunication Packet");
|
|
return;
|
|
}
|
|
|
|
|
|
byte module = packet[1];
|
|
switch(module)
|
|
{
|
|
case PacketBuilder.SWFMODULE_INVITE:
|
|
if(packet.Length < 3)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid 2PLAYER INVITE Packet (WRONG SIZE)");
|
|
break;
|
|
}
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string playerIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
int playerId = -1;
|
|
try
|
|
{
|
|
playerId = int.Parse(playerIdStr);
|
|
}
|
|
catch (Exception) { };
|
|
|
|
if(IsUserOnline(playerId))
|
|
{
|
|
User toInvite = GetUserById(playerId);
|
|
TwoPlayer twoPlayerGame = new TwoPlayer(toInvite, sender.LoggedinUser, false);
|
|
}
|
|
break;
|
|
case PacketBuilder.SWFMODULE_ACCEPT:
|
|
if (packet.Length < 3)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid 2PLAYER ACCEPT Packet (WRONG SIZE)");
|
|
break;
|
|
}
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
playerIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
playerId = -1;
|
|
try
|
|
{
|
|
playerId = int.Parse(playerIdStr);
|
|
}
|
|
catch (Exception) { };
|
|
|
|
if (IsUserOnline(playerId))
|
|
{
|
|
User toAccept = GetUserById(playerId);
|
|
if(TwoPlayer.IsPlayerInvitingPlayer(toAccept, sender.LoggedinUser))
|
|
{
|
|
TwoPlayer twoPlayerGame = TwoPlayer.GetGameInvitingPlayer(toAccept, sender.LoggedinUser);
|
|
twoPlayerGame.Accept(sender.LoggedinUser);
|
|
}
|
|
}
|
|
break;
|
|
case PacketBuilder.SWFMODULE_DRAWINGROOM:
|
|
if(packet.Length < 3)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent invalid DRAWINGROOM packet (swf communication, WRONG SIZE)");
|
|
break;
|
|
}
|
|
if(packet[2] == PacketBuilder.DRAWINGROOM_GET_DRAWING)
|
|
{
|
|
if (packet.Length < 5)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent invalid DRAWINGROOM GET DRAWING packet (swf communication, WRONG SIZE)");
|
|
break;
|
|
}
|
|
int roomId = packet[3] - 40;
|
|
Drawingroom room;
|
|
try
|
|
{
|
|
room = Drawingroom.GetDrawingRoomById(roomId);
|
|
}
|
|
catch(KeyNotFoundException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to load an invalid drawing room: " + roomId);
|
|
break;
|
|
}
|
|
|
|
if(room.Drawing != "")
|
|
{
|
|
byte[] drawingPacket = PacketBuilder.CreateDrawingUpdate(room.Drawing);
|
|
sender.SendPacket(drawingPacket);
|
|
}
|
|
|
|
}
|
|
else if(packet[2] == PacketBuilder.DRAWINGROOM_SAVE)
|
|
{
|
|
if (packet.Length < 4)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent invalid DRAWINGROOM GET DRAWING packet (swf communication, WRONG SIZE)");
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* The lack of an if case for if the user isnt subscribed
|
|
* is NOT a bug thats just how pinto does it.
|
|
* you can save but not load if your subscribed. weird huh?
|
|
*/
|
|
|
|
int roomId = packet[3] - 40;
|
|
Drawingroom room;
|
|
try
|
|
{
|
|
room = Drawingroom.GetDrawingRoomById(roomId);
|
|
}
|
|
catch (KeyNotFoundException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to load an invalid drawing room: " + roomId);
|
|
break;
|
|
}
|
|
|
|
if (!Database.SavedDrawingsExist(sender.LoggedinUser.Id))
|
|
Database.CreateSavedDrawings(sender.LoggedinUser.Id);
|
|
|
|
int slotNo = 0;
|
|
byte slot = packet[4];
|
|
switch (slot)
|
|
{
|
|
case 0x29: // Slot 1
|
|
Database.SaveDrawingSlot1(sender.LoggedinUser.Id, room.Drawing);
|
|
slotNo = 1;
|
|
break;
|
|
case 0x2A: // Slot 2
|
|
Database.SaveDrawingSlot2(sender.LoggedinUser.Id, room.Drawing);
|
|
slotNo = 2;
|
|
break;
|
|
case 0x2B: // Slot 3
|
|
Database.SaveDrawingSlot3(sender.LoggedinUser.Id, room.Drawing);
|
|
slotNo = 3;
|
|
break;
|
|
}
|
|
|
|
byte[] savedDrawingMessage = PacketBuilder.CreateChat(Messages.FormatDrawingRoomSaved(slotNo), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(savedDrawingMessage);
|
|
|
|
break;
|
|
}
|
|
else if (packet[2] == PacketBuilder.DRAWINGROOM_LOAD)
|
|
{
|
|
if (packet.Length < 4)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent invalid DRAWINGROOM GET DRAWING packet (swf communication, WRONG SIZE)");
|
|
break;
|
|
}
|
|
|
|
if(!sender.LoggedinUser.Subscribed)
|
|
{
|
|
byte[] notSubscribedCantLoad = PacketBuilder.CreateChat(Messages.DrawingCannotLoadNotSubscribed, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(notSubscribedCantLoad);
|
|
break;
|
|
}
|
|
|
|
int roomId = packet[3] - 40;
|
|
Drawingroom room;
|
|
try{
|
|
room = Drawingroom.GetDrawingRoomById(roomId);
|
|
}
|
|
catch (KeyNotFoundException){
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to load an invalid drawing room: " + roomId);
|
|
break;
|
|
}
|
|
|
|
if (!Database.SavedDrawingsExist(sender.LoggedinUser.Id))
|
|
Database.CreateSavedDrawings(sender.LoggedinUser.Id);
|
|
|
|
int slotNo = 0;
|
|
byte slot = packet[4];
|
|
string drawingToAdd = "";
|
|
switch (slot)
|
|
{
|
|
case 0x29: // Slot 1
|
|
drawingToAdd = Database.LoadDrawingSlot1(sender.LoggedinUser.Id);
|
|
slotNo = 1;
|
|
break;
|
|
case 0x2A: // Slot 2
|
|
drawingToAdd = Database.LoadDrawingSlot2(sender.LoggedinUser.Id);
|
|
slotNo = 2;
|
|
break;
|
|
case 0x2B: // Slot 3
|
|
drawingToAdd = Database.LoadDrawingSlot3(sender.LoggedinUser.Id);
|
|
slotNo = 3;
|
|
break;
|
|
}
|
|
|
|
try {
|
|
room.Drawing += drawingToAdd;
|
|
}
|
|
catch(DrawingroomFullException){
|
|
byte[] roomFullMessage = PacketBuilder.CreateChat(Messages.DrawingPlzClearLoad, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(roomFullMessage);
|
|
break;
|
|
}
|
|
|
|
Database.SetLastPlayer("D" + room.Id.ToString(), sender.LoggedinUser.Id);
|
|
UpdateDrawingForAll("D" + room.Id, sender, drawingToAdd, true);
|
|
|
|
byte[] loadedDrawingMessage = PacketBuilder.CreateChat(Messages.FormatDrawingRoomLoaded(slotNo), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(loadedDrawingMessage);
|
|
|
|
break;
|
|
}
|
|
else // Default action- draw line
|
|
{
|
|
if (packet.Length < 4)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent invalid DRAWINGROOM GET DRAWING packet (swf communication, WRONG SIZE)");
|
|
break;
|
|
}
|
|
|
|
if(!sender.LoggedinUser.Subscribed)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to draw while not subscribed.");
|
|
byte[] notSubscribedMessage = PacketBuilder.CreateChat(Messages.DrawingNotSentNotSubscribed, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(notSubscribedMessage);
|
|
break;
|
|
}
|
|
|
|
int roomId = packet[2] - 40;
|
|
Drawingroom room;
|
|
try
|
|
{
|
|
room = Drawingroom.GetDrawingRoomById(roomId);
|
|
}
|
|
catch (KeyNotFoundException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to load an invalid drawing room: " + roomId);
|
|
break;
|
|
}
|
|
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
|
|
string drawing = packetStr.Substring(3, (packetStr.Length - 3) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
if (drawing.Contains("X!")) // Clear byte
|
|
{
|
|
room.Drawing = "";
|
|
goto update;
|
|
}
|
|
|
|
try {
|
|
room.Drawing += drawing;
|
|
}
|
|
catch (DrawingroomFullException)
|
|
{
|
|
byte[] roomFullMessage = PacketBuilder.CreateChat(Messages.DrawingPlzClearDraw, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(roomFullMessage);
|
|
break;
|
|
}
|
|
update:;
|
|
Database.SetLastPlayer("D" + room.Id.ToString(), sender.LoggedinUser.Id);
|
|
UpdateDrawingForAll("D" + room.Id, sender, drawing, false);
|
|
}
|
|
|
|
break;
|
|
case PacketBuilder.SWFMODULE_BRICKPOET:
|
|
if(packet.Length < 4)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent invalid BRICKPOET packet (swf communication, WRONG SIZE)");
|
|
break;
|
|
}
|
|
if(packet[2] == PacketBuilder.BRICKPOET_LIST_ALL)
|
|
{
|
|
if (packet.Length < 5)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent invalid BRICKPOET LIST ALL packet (swf communication, WRONG SIZE)");
|
|
break;
|
|
}
|
|
|
|
int roomId = packet[3] - 40;
|
|
Brickpoet.PoetryPeice[] room;
|
|
try // Make sure the room exists-
|
|
{
|
|
room = Brickpoet.GetPoetryRoom(roomId);
|
|
}
|
|
catch(KeyNotFoundException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to load an invalid brickpoet room: " + roomId);
|
|
break;
|
|
}
|
|
// Send list of peices
|
|
byte[] poetPacket = PacketBuilder.CreateBrickPoetList(room);
|
|
sender.SendPacket(poetPacket);
|
|
|
|
}
|
|
else if(packet[3] == PacketBuilder.BRICKPOET_MOVE)
|
|
{
|
|
if (packet.Length < 0xA)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent invalid BRICKPOET MOVE packet (swf communication, WRONG SIZE)");
|
|
break;
|
|
}
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
if(!packetStr.Contains('|'))
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent invalid BRICKPOET MOVE packet (swf communication, NO | SEPERATOR)");
|
|
break;
|
|
}
|
|
string[] args = packetStr.Split('|');
|
|
if(args.Length < 5)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent invalid BRICKPOET MOVE Packet (swf communication, NOT ENOUGH | SEPERATORS.");
|
|
break;
|
|
}
|
|
|
|
int roomId = packet[2] - 40;
|
|
int peiceId;
|
|
int x;
|
|
int y;
|
|
Brickpoet.PoetryPeice[] room;
|
|
Brickpoet.PoetryPeice peice;
|
|
|
|
try // Make sure these are acturally numbers!
|
|
{
|
|
peiceId = int.Parse(args[1]);
|
|
x = int.Parse(args[2]);
|
|
y = int.Parse(args[3]);
|
|
|
|
|
|
room = Brickpoet.GetPoetryRoom(roomId);
|
|
peice = Brickpoet.GetPoetryPeice(room, peiceId);
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " brickpoet - "+e.ToString());
|
|
break;
|
|
}
|
|
// Change location in Database
|
|
peice.X = x;
|
|
peice.Y = y;
|
|
|
|
foreach(User user in GetUsersOnSpecialTileCode("MULTIROOM-" + "P" + roomId.ToString())) // Send to each user!
|
|
{
|
|
if (user.Id == sender.LoggedinUser.Id)
|
|
continue;
|
|
|
|
byte[] updatePoetRoomPacket = PacketBuilder.CreateBrickPoetMove(peice);
|
|
user.LoggedinClient.SendPacket(updatePoetRoomPacket);
|
|
|
|
}
|
|
|
|
if (Database.GetLastPlayer("P" + roomId) != sender.LoggedinUser.Id)
|
|
{
|
|
Database.SetLastPlayer("P" + roomId, sender.LoggedinUser.Id);
|
|
UpdateAreaForAll(sender.LoggedinUser.X, sender.LoggedinUser.Y, true);
|
|
}
|
|
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Logger.DebugPrint(" packet dump: " + BitConverter.ToString(packet).Replace("-", " "));
|
|
break;
|
|
}
|
|
|
|
break;
|
|
case PacketBuilder.SWFMODULE_DRESSUPROOM:
|
|
if ( packet.Length < 5 )
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent invalid DRESSUPROOM packet (swf communication, WRONG SIZE)");
|
|
break;
|
|
}
|
|
if (packet[2] == PacketBuilder.DRESSUPROOM_LIST_ALL)
|
|
{
|
|
int roomId = packet[3] - 40;
|
|
Dressup.DressupRoom room = Dressup.GetDressupRoom(roomId);
|
|
|
|
if (room.DressupPeices.Length > 0)
|
|
{
|
|
byte[] allDressupsResponse = PacketBuilder.CreateDressupRoomPeiceLoad(room.DressupPeices);
|
|
sender.SendPacket(allDressupsResponse);
|
|
}
|
|
|
|
}
|
|
else // Move
|
|
{
|
|
if (packet.Length < 8)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent invalid DRESSUPROOM MOVE packet (swf communication, WRONG SIZE)");
|
|
break;
|
|
}
|
|
|
|
int roomId = packet[2] - 40;
|
|
if (roomId <= 0)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent invalid DRESSUPROOM MOVE packet (swf communication, INVALID ROOM)");
|
|
break;
|
|
}
|
|
Dressup.DressupRoom room = Dressup.GetDressupRoom(roomId);
|
|
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
string moveStr = packetStr.Substring(3, (packetStr.Length - 3) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
|
|
string[] moves = moveStr.Split('|');
|
|
|
|
if(moves.Length < 3)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent invalid DRESSUPROOM MOVE packet (swf communication, MOVES WRONG SIZE)");
|
|
break;
|
|
}
|
|
|
|
int peiceId;
|
|
double moveToX;
|
|
double moveToY;
|
|
bool active = true;
|
|
try // Make sure these are acturally numbers!
|
|
{
|
|
peiceId = int.Parse(moves[0]);
|
|
if (moves[1] == "D" || moves[2] == "D")
|
|
{
|
|
active = false;
|
|
moveToX = 0;
|
|
moveToY = 0;
|
|
}
|
|
else
|
|
{
|
|
moveToX = double.Parse(moves[1]);
|
|
moveToY = double.Parse(moves[2]);
|
|
}
|
|
}
|
|
catch(FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent invalid DRESSUPROOM MOVE packet (swf communication, INVALID LOCATION)");
|
|
break;
|
|
}
|
|
|
|
Dressup.DressupPeice peice = room.GetDressupPeice(peiceId);
|
|
// Update database entries
|
|
peice.X = Convert.ToInt32(Math.Round(moveToX));
|
|
peice.Y = Convert.ToInt32(Math.Round(moveToY));
|
|
peice.Active = active;
|
|
|
|
// Forward to other users
|
|
byte[] movePeicePacket = PacketBuilder.CreateDressupRoomPeiceMove(peice.PeiceId, moveToX, moveToY, peice.Active);
|
|
User[] users = GetUsersAt(sender.LoggedinUser.X, sender.LoggedinUser.Y, true, true);
|
|
foreach(User user in users)
|
|
{
|
|
if (user.Id != sender.LoggedinUser.Id)
|
|
user.LoggedinClient.SendPacket(movePeicePacket);
|
|
}
|
|
}
|
|
break;
|
|
case PacketBuilder.SWFMODULE_BANDHALL:
|
|
byte[] response = PacketBuilder.CreateForwardedSwfModule(packet);
|
|
foreach (User user in GetUsersAt(sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
if (user.Id == sender.LoggedinUser.Id)
|
|
continue;
|
|
user.LoggedinClient.SendPacket(response);
|
|
}
|
|
break;
|
|
case PacketBuilder.SWFMODULE_2PLAYER:
|
|
if(TwoPlayer.IsPlayerInGame(sender.LoggedinUser))
|
|
{
|
|
TwoPlayer twoPlayerGame = TwoPlayer.GetTwoPlayerGameInProgress(sender.LoggedinUser);
|
|
|
|
User otherUser = null;
|
|
if (twoPlayerGame.Invitee.Id == sender.LoggedinUser.Id)
|
|
otherUser = twoPlayerGame.Inviting;
|
|
else if (twoPlayerGame.Inviting.Id == sender.LoggedinUser.Id)
|
|
otherUser = twoPlayerGame.Invitee;
|
|
|
|
response = PacketBuilder.CreateForwardedSwfModule(packet);
|
|
otherUser.LoggedinClient.SendPacket(response);
|
|
}
|
|
break;
|
|
case PacketBuilder.SWFMODULE_CLOSE:
|
|
if (TwoPlayer.IsPlayerInGame(sender.LoggedinUser))
|
|
{
|
|
TwoPlayer twoPlayerGame = TwoPlayer.GetTwoPlayerGameInProgress(sender.LoggedinUser);
|
|
|
|
User otherUser = null;
|
|
if (twoPlayerGame.Invitee.Id == sender.LoggedinUser.Id)
|
|
otherUser = twoPlayerGame.Inviting;
|
|
else if (twoPlayerGame.Inviting.Id == sender.LoggedinUser.Id)
|
|
otherUser = twoPlayerGame.Invitee;
|
|
|
|
response = PacketBuilder.Create2PlayerClose();
|
|
otherUser.LoggedinClient.SendPacket(response);
|
|
|
|
twoPlayerGame.CloseGame(sender.LoggedinUser);
|
|
|
|
|
|
}
|
|
break;
|
|
case PacketBuilder.SWFMODULE_ARENA:
|
|
if (Arena.UserHasEnteredHorseInAnyArena(sender.LoggedinUser))
|
|
{
|
|
Arena arena = Arena.GetArenaUserEnteredIn(sender.LoggedinUser);
|
|
response = PacketBuilder.CreateForwardedSwfModule(packet);
|
|
foreach (Arena.ArenaEntry entry in arena.Entries.ToArray())
|
|
{
|
|
if (entry.EnteredUser.Id == sender.LoggedinUser.Id)
|
|
continue;
|
|
if(entry.EnteredUser.LoggedinClient.LoggedIn)
|
|
entry.EnteredUser.LoggedinClient.SendPacket(response);
|
|
}
|
|
|
|
}
|
|
break;
|
|
default:
|
|
Logger.DebugPrint("Unknown moduleid : " + module + " packet dump: " + BitConverter.ToString(packet).Replace("-"," "));
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public static void OnWish(GameClient sender, byte[] packet)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " tried to wish when not logged in.");
|
|
return;
|
|
}
|
|
|
|
if(packet.Length < 3)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid wish Packet");
|
|
return;
|
|
}
|
|
|
|
if (!sender.LoggedinUser.Inventory.HasItemId(Item.WishingCoin))
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to use a wishing well while having 0 coins.");
|
|
return;
|
|
}
|
|
|
|
InventoryItem wishingCoinInvItems = sender.LoggedinUser.Inventory.GetItemByItemId(Item.WishingCoin);
|
|
byte wishType = packet[1];
|
|
string message = "";
|
|
|
|
byte[] chatMsg = PacketBuilder.CreateChat(Messages.TossedCoin, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatMsg);
|
|
|
|
switch(wishType)
|
|
{
|
|
case PacketBuilder.WISH_MONEY:
|
|
int gainMoney = RandomNumberGenerator.Next(500, 1000);
|
|
sender.LoggedinUser.AddMoney(gainMoney);
|
|
message = Messages.FormatWishMoneyMessage(gainMoney);
|
|
break;
|
|
case PacketBuilder.WISH_ITEMS:
|
|
Item.ItemInformation[] wishableItmes = Item.GetAllWishableItems();
|
|
int item = RandomNumberGenerator.Next(0, wishableItmes.Length);
|
|
Item.ItemInformation itm = wishableItmes[item];
|
|
item = RandomNumberGenerator.Next(0, wishableItmes.Length);
|
|
Item.ItemInformation itm2 = wishableItmes[item];
|
|
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(new ItemInstance(itm.Id));
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(new ItemInstance(itm2.Id));
|
|
|
|
message = Messages.FormatWishThingsMessage(itm.Name, itm2.Name);
|
|
break;
|
|
case PacketBuilder.WISH_WORLDPEACE:
|
|
byte[] tooDeep = PacketBuilder.CreateChat(Messages.WorldPeaceOnlySoDeep, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(tooDeep);
|
|
|
|
wishableItmes = Item.GetAllWishableItems();
|
|
item = RandomNumberGenerator.Next(0, wishableItmes.Length);
|
|
int earnMoney = RandomNumberGenerator.Next(0, 500);
|
|
itm = wishableItmes[item];
|
|
|
|
|
|
sender.LoggedinUser.AddMoney(earnMoney);
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(new ItemInstance(itm.Id));
|
|
|
|
message = Messages.FormatWishWorldPeaceMessage(earnMoney, itm.Name);
|
|
break;
|
|
default:
|
|
Logger.ErrorPrint("Unknnown Wish type: " + wishType.ToString("X"));
|
|
break;
|
|
}
|
|
sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.WishingWell).Count++;
|
|
|
|
if(sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.WishingWell).Count >= 100)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(30)); // Well Wisher
|
|
|
|
if (sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.WishingWell).Count >= 1000)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(31)); // Star Wisher
|
|
|
|
if (sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.WishingWell).Count >= 10000)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(51)); // Extraordanary Wisher
|
|
|
|
byte[] msg = PacketBuilder.CreateChat(message, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(msg);
|
|
|
|
sender.LoggedinUser.Inventory.Remove(wishingCoinInvItems.ItemInstances[0]);
|
|
UpdateArea(sender);
|
|
}
|
|
public static void OnKeepAlive(GameClient sender, byte[] packet)
|
|
{
|
|
if (packet.Length < 2)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid update Packet");
|
|
return;
|
|
}
|
|
|
|
if (packet[1] == PacketBuilder.PACKET_CLIENT_TERMINATOR)
|
|
{
|
|
Logger.DebugPrint("Received KEEP_ALIVE from: " + sender.LoggedinUser.Username);
|
|
return;
|
|
}
|
|
}
|
|
public static void OnStatsPacket(GameClient sender, byte[] packet)
|
|
{
|
|
if(!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Requested stats when not logged in.");
|
|
return;
|
|
}
|
|
if(packet.Length < 2)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + "Sent an invalid Stats Packet");
|
|
return;
|
|
}
|
|
|
|
|
|
}
|
|
public static void OnProfilePacket(GameClient sender, byte[] packet)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Requested to change profile page when not logged in.");
|
|
return;
|
|
}
|
|
if (packet.Length < 2)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid Profile Packet");
|
|
return;
|
|
}
|
|
|
|
byte method = packet[1];
|
|
if (method == PacketBuilder.PACKET_CLIENT_TERMINATOR)
|
|
{
|
|
UpdateStats(sender);
|
|
}
|
|
if (method == PacketBuilder.VIEW_PROFILE)
|
|
{
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
string profilePage = sender.LoggedinUser.ProfilePage;
|
|
byte[] profilePacket = PacketBuilder.CreateProfilePage(profilePage);
|
|
sender.SendPacket(profilePacket);
|
|
}
|
|
else if (method == PacketBuilder.SAVE_PROFILE)
|
|
{
|
|
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
if (packet.Length <= 3 || !packetStr.Contains('|'))
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid Profile SAVE Packet");
|
|
return;
|
|
}
|
|
|
|
int characterId = (packet[2] - 20) * 64 + (packet[3] - 20);
|
|
|
|
string profilePage = packetStr.Split('|')[1];
|
|
profilePage = profilePage.Substring(0, profilePage.Length - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
sender.LoggedinUser.CharacterId = characterId;
|
|
|
|
if (profilePage.Length > 4000)
|
|
{
|
|
byte[] notSaved = PacketBuilder.CreateChat(Messages.ProfileTooLongMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(notSaved);
|
|
return;
|
|
}
|
|
|
|
object filterReason = Chat.FilterMessage(profilePage);
|
|
if(filterReason != null)
|
|
{
|
|
Chat.Reason reason = (Chat.Reason)filterReason;
|
|
byte[] msg = PacketBuilder.CreateChat(Messages.FormatProfileSavedBlocked(reason.Message), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(msg);
|
|
return;
|
|
}
|
|
|
|
sender.LoggedinUser.ProfilePage = profilePage;
|
|
|
|
Logger.DebugPrint(sender.LoggedinUser.Username + " Changed to character id: " + characterId + " and set there Profile Description to '" + profilePage + "'");
|
|
|
|
byte[] chatPacket = PacketBuilder.CreateChat(Messages.ProfileSavedMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatPacket);
|
|
|
|
UpdateArea(sender);
|
|
UpdateUserFacingAndLocation(sender.LoggedinUser);
|
|
}
|
|
else if (method == PacketBuilder.SECCODE_AWARD)
|
|
{
|
|
byte[] ExpectedSecCode = sender.LoggedinUser.GenerateSecCode();
|
|
byte[] GotSecCode = new byte[4];
|
|
Array.ConstrainedCopy(packet, 2, GotSecCode, 0, GotSecCode.Length);
|
|
Logger.DebugPrint(sender.LoggedinUser.Username + " Sent sec code: " + BitConverter.ToString(GotSecCode).Replace("-", " "));
|
|
if (ExpectedSecCode.SequenceEqual(GotSecCode))
|
|
{
|
|
if (packet.Length < 5)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent a seccode AWARD request with invalid size");
|
|
return;
|
|
}
|
|
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string awardIdStr = packetStr.Substring(6, (packetStr.Length - 6) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
|
|
int value = -1;
|
|
try
|
|
{
|
|
value = int.Parse(awardIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent correct sec code, but invalid awardid value");
|
|
return;
|
|
}
|
|
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(value));
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
byte[] errorMessage = PacketBuilder.CreateChat(Messages.InvalidSecCodeError, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(errorMessage);
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Sent invalid sec code");
|
|
return;
|
|
}
|
|
}
|
|
else if (method == PacketBuilder.SECCODE_SCORE || method == PacketBuilder.SECCODE_TIME || method == PacketBuilder.SECCODE_WINLOOSE)
|
|
{
|
|
bool time = (method == PacketBuilder.SECCODE_TIME);
|
|
bool winloose = (method == PacketBuilder.SECCODE_WINLOOSE);
|
|
|
|
byte[] ExpectedSecCode = sender.LoggedinUser.GenerateSecCode();
|
|
byte[] GotSecCode = new byte[4];
|
|
Array.ConstrainedCopy(packet, 2, GotSecCode, 0, GotSecCode.Length);
|
|
Logger.DebugPrint(sender.LoggedinUser.Username + " Sent sec code: " + BitConverter.ToString(GotSecCode).Replace("-", " "));
|
|
if (ExpectedSecCode.SequenceEqual(GotSecCode))
|
|
{
|
|
if (packet.Length < 5)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent a seccode score/time/winloose request with invalid size");
|
|
return;
|
|
}
|
|
|
|
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string gameInfoStr = packetStr.Substring(6, (packetStr.Length - 6) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
if (winloose)
|
|
{
|
|
string gameTitle = gameInfoStr.Substring(1);
|
|
byte pmethod = packet[6];
|
|
if(pmethod == PacketBuilder.WINLOOSE_WIN)
|
|
{
|
|
sender.LoggedinUser.Highscores.Win(gameTitle);
|
|
byte[] winMsg = PacketBuilder.CreateChat(Messages.Format2PlayerRecordWin(gameTitle), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(winMsg);
|
|
}
|
|
else if(pmethod == PacketBuilder.WINLOOSE_LOOSE)
|
|
{
|
|
sender.LoggedinUser.Highscores.Loose(gameTitle);
|
|
byte[] looseMsg = PacketBuilder.CreateChat(Messages.Format2PlayerRecordLose(gameTitle), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(looseMsg);
|
|
}
|
|
|
|
if (sender.LoggedinUser.Highscores.HighscoreList.Length >= 30)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(12)); // Minigame Player
|
|
|
|
if (sender.LoggedinUser.Highscores.HighscoreList.Length >= 60)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(13)); // Minigame Master
|
|
|
|
if (Database.GetPlayerTotalMinigamesPlayed(sender.LoggedinUser.Id) >= 1000)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(14)); // Minigame Nut
|
|
|
|
if (Database.GetPlayerTotalMinigamesPlayed(sender.LoggedinUser.Id) >= 10000)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(15)); // Minigame Crazy
|
|
return;
|
|
}
|
|
if (gameInfoStr.Contains("|"))
|
|
{
|
|
string[] gameInfo = gameInfoStr.Split('|');
|
|
if (gameInfo.Length < 2)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent a invalid seccode score request");
|
|
return;
|
|
}
|
|
|
|
string gameTitle = gameInfo[0];
|
|
string gameScoreStr = gameInfo[1];
|
|
|
|
int value = -1;
|
|
try
|
|
{
|
|
value = int.Parse(gameScoreStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent correct sec code, but invalid score value");
|
|
return;
|
|
}
|
|
Highscore.HighscoreTableEntry[] scores = Database.GetTopScores(gameTitle, 5, !time);
|
|
bool bestScoreEver = false;
|
|
if (scores.Length >= 1)
|
|
bestScoreEver = scores[0].Score <= value;
|
|
|
|
bool newHighscore = sender.LoggedinUser.Highscores.UpdateHighscore(gameTitle, value, time);
|
|
if(bestScoreEver && !time)
|
|
{
|
|
byte[] bestScoreBeaten = PacketBuilder.CreateChat(Messages.BeatBestHighscore, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(bestScoreBeaten);
|
|
sender.LoggedinUser.AddMoney(2500);
|
|
}
|
|
else if (newHighscore)
|
|
{
|
|
if(time)
|
|
{
|
|
byte[] chatPacket = PacketBuilder.CreateChat(Messages.FormatTimeBeatenMessage(value), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatPacket);
|
|
}
|
|
else
|
|
{
|
|
byte[] chatPacket = PacketBuilder.CreateChat(Messages.FormatHighscoreBeatenMessage(value), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatPacket);
|
|
}
|
|
|
|
}
|
|
|
|
if(sender.LoggedinUser.Highscores.HighscoreList.Length >= 30)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(12)); // Minigame Player
|
|
|
|
if (sender.LoggedinUser.Highscores.HighscoreList.Length >= 60)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(13)); // Minigame Master
|
|
|
|
if (Database.GetPlayerTotalMinigamesPlayed(sender.LoggedinUser.Id) >= 1000)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(14)); // Minigame Nut
|
|
|
|
if (Database.GetPlayerTotalMinigamesPlayed(sender.LoggedinUser.Id) >= 10000)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(15)); // Minigame Crazy
|
|
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " didnt send a game name AND a score.");
|
|
return;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
byte[] errorMessage = PacketBuilder.CreateChat(Messages.InvalidSecCodeError, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(errorMessage);
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Sent invalid sec code");
|
|
return;
|
|
}
|
|
}
|
|
else if (method == PacketBuilder.SECCODE_MONEY)
|
|
{
|
|
|
|
byte[] ExpectedSecCode = sender.LoggedinUser.GenerateSecCode();
|
|
byte[] GotSecCode = new byte[4];
|
|
Array.ConstrainedCopy(packet, 2, GotSecCode, 0, GotSecCode.Length);
|
|
Logger.DebugPrint(sender.LoggedinUser.Username + " Sent sec code: " + BitConverter.ToString(GotSecCode).Replace("-", " "));
|
|
if (ExpectedSecCode.SequenceEqual(GotSecCode))
|
|
{
|
|
if (packet.Length < 5)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent a seccode money request with invalid size");
|
|
return;
|
|
}
|
|
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string gameInfoStr = packetStr.Substring(6, (packetStr.Length - 6) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
if (gameInfoStr.Contains("|"))
|
|
{
|
|
string[] moneyInfo = gameInfoStr.Split('|');
|
|
if (moneyInfo.Length < 2)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent a invalid money score request");
|
|
return;
|
|
}
|
|
|
|
string id = moneyInfo[0]; // not sure what this is for?
|
|
|
|
string moneyStr = moneyInfo[1];
|
|
int value = -1;
|
|
try
|
|
{
|
|
value = int.Parse(moneyStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent correct sec code, but invalid money value");
|
|
return;
|
|
}
|
|
|
|
int moneyEarned = value * 10;
|
|
Logger.InfoPrint(sender.LoggedinUser.Username + " Earned $" + moneyEarned + " In: " + id);
|
|
|
|
sender.LoggedinUser.AddMoney(moneyEarned);
|
|
byte[] chatPacket = PacketBuilder.CreateChat(Messages.FormatMoneyEarnedMessage(moneyEarned), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatPacket);
|
|
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " didnt send a game name AND a score.");
|
|
return;
|
|
}
|
|
|
|
}
|
|
}
|
|
else if (method == PacketBuilder.SECCODE_GIVE_ITEM)
|
|
{
|
|
byte[] ExpectedSecCode = sender.LoggedinUser.GenerateSecCode();
|
|
byte[] GotSecCode = new byte[4];
|
|
Array.ConstrainedCopy(packet, 2, GotSecCode, 0, GotSecCode.Length);
|
|
Logger.DebugPrint(sender.LoggedinUser.Username + " Sent sec code: " + BitConverter.ToString(GotSecCode).Replace("-", " "));
|
|
if (ExpectedSecCode.SequenceEqual(GotSecCode))
|
|
{
|
|
if (packet.Length < 5)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent a seccode item request with invalid size");
|
|
return;
|
|
}
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string intStr = packetStr.Substring(6, (packetStr.Length - 6) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
int value = -1;
|
|
try
|
|
{
|
|
value = int.Parse(intStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent correct sec code, but invalid value");
|
|
return;
|
|
}
|
|
|
|
|
|
if (Item.ItemIdExist(value))
|
|
{
|
|
ItemInstance itm = new ItemInstance(value);
|
|
|
|
Item.ItemInformation itemInfo = Item.GetItemById(value);
|
|
string messageToSend = Messages.FormatYouEarnedAnItemMessage(itemInfo.Name);
|
|
try
|
|
{
|
|
sender.LoggedinUser.Inventory.Add(itm);
|
|
}
|
|
catch(InventoryException)
|
|
{
|
|
messageToSend = Messages.FormatYouEarnedAnItemButInventoryFullMessage(itemInfo.Name);
|
|
}
|
|
|
|
byte[] earnedItemMessage = PacketBuilder.CreateChat(messageToSend, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(earnedItemMessage);
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Sent correct sec code, but tried to give an non existant item");
|
|
return;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
byte[] errorMessage = PacketBuilder.CreateChat(Messages.InvalidSecCodeError, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(errorMessage);
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Sent invalid sec code");
|
|
return;
|
|
}
|
|
}
|
|
else if (method == PacketBuilder.SECCODE_DELETE_ITEM)
|
|
{
|
|
byte[] ExpectedSecCode = sender.LoggedinUser.GenerateSecCode();
|
|
byte[] GotSecCode = new byte[4];
|
|
Array.ConstrainedCopy(packet, 2, GotSecCode, 0, GotSecCode.Length);
|
|
Logger.DebugPrint(sender.LoggedinUser.Username + " Sent sec code: " + BitConverter.ToString(GotSecCode).Replace("-", " "));
|
|
if (ExpectedSecCode.SequenceEqual(GotSecCode))
|
|
{
|
|
if (packet.Length < 5)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent a seccode item request with invalid size");
|
|
return;
|
|
}
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string intStr = packetStr.Substring(6, (packetStr.Length - 6) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
int value = -1;
|
|
try
|
|
{
|
|
value = int.Parse(intStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent correct sec code, but invalid value");
|
|
return;
|
|
}
|
|
|
|
|
|
if (sender.LoggedinUser.Inventory.HasItemId(value))
|
|
{
|
|
InventoryItem item = sender.LoggedinUser.Inventory.GetItemByItemId(value);
|
|
sender.LoggedinUser.Inventory.Remove(item.ItemInstances[0]);
|
|
|
|
Item.ItemInformation itemInfo = Item.GetItemById(value);
|
|
byte[] lostItemMessage = PacketBuilder.CreateChat(Messages.FormatYouLostAnItemMessage(itemInfo.Name), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(lostItemMessage);
|
|
|
|
UpdateArea(sender);
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Sent correct sec code, but tried to delete an non existant item");
|
|
return;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
byte[] errorMessage = PacketBuilder.CreateChat(Messages.InvalidSecCodeError, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(errorMessage);
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Sent invalid sec code");
|
|
return;
|
|
}
|
|
}
|
|
else if (method == PacketBuilder.SECCODE_QUEST)
|
|
{
|
|
byte[] ExpectedSecCode = sender.LoggedinUser.GenerateSecCode();
|
|
byte[] GotSecCode = new byte[4];
|
|
Array.ConstrainedCopy(packet, 2, GotSecCode, 0, GotSecCode.Length);
|
|
Logger.DebugPrint(sender.LoggedinUser.Username + " Sent sec code: " + BitConverter.ToString(GotSecCode).Replace("-", " "));
|
|
if (ExpectedSecCode.SequenceEqual(GotSecCode))
|
|
{
|
|
if (packet.Length < 5)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent a seccode quest request with invalid size");
|
|
return;
|
|
}
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string intStr = packetStr.Substring(6, (packetStr.Length - 6) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
int value = -1;
|
|
try
|
|
{
|
|
value = int.Parse(intStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Sent correct sec code, but invalid value");
|
|
return;
|
|
}
|
|
|
|
|
|
if (Quest.DoesQuestExist(value))
|
|
{
|
|
Quest.QuestEntry questEntry = Quest.GetQuestById(value);
|
|
Quest.ActivateQuest(sender.LoggedinUser, questEntry);
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Sent correct sec code, but tried to activate a non existant quest");
|
|
return;
|
|
}
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
byte[] errorMessage = PacketBuilder.CreateChat(Messages.InvalidSecCodeError, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(errorMessage);
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Sent invalid sec code");
|
|
return;
|
|
}
|
|
}
|
|
else if (method == PacketBuilder.PROFILE_HIGHSCORES_LIST)
|
|
{
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string gameName = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
byte[] metaTag = PacketBuilder.CreateMeta(Meta.BuildTopHighscores(gameName));
|
|
sender.SendPacket(metaTag);
|
|
}
|
|
else if (method == PacketBuilder.PROFILE_BESTTIMES_LIST)
|
|
{
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string gameName = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
byte[] metaTag = PacketBuilder.CreateMeta(Meta.BuildTopTimes(gameName));
|
|
sender.SendPacket(metaTag);
|
|
}
|
|
else if (method == PacketBuilder.PROFILE_WINLOOSE_LIST)
|
|
{
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string gameName = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
byte[] metaTag = PacketBuilder.CreateMeta(Meta.BuildTopWinners(gameName));
|
|
sender.SendPacket(metaTag);
|
|
}
|
|
else
|
|
{
|
|
Logger.DebugPrint("Unknown Profile Packet! " + BitConverter.ToString(packet).Replace("-", " "));
|
|
}
|
|
}
|
|
public static void OnMovementPacket(GameClient sender, byte[] packet)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Sent movement packet when not logged in.");
|
|
return;
|
|
}
|
|
|
|
|
|
User loggedInUser = sender.LoggedinUser;
|
|
|
|
/*
|
|
* Player stuff
|
|
*/
|
|
|
|
// Store this for later... do it now to avoid TOCTOU.
|
|
User[] onScreenBefore = GetOnScreenUsers(loggedInUser.X, loggedInUser.Y, true, true);
|
|
|
|
// Leave Multirooms
|
|
Multiroom.LeaveAllMultirooms(loggedInUser);
|
|
|
|
loggedInUser.PendingBuddyRequestTo = null;
|
|
|
|
// Close Social Windows
|
|
foreach (User sUser in loggedInUser.BeingSocializedBy)
|
|
UpdateArea(sUser.LoggedinClient);
|
|
loggedInUser.ClearSocailizedWith();
|
|
|
|
|
|
if (loggedInUser.CurrentlyRidingHorse != null)
|
|
{
|
|
if(loggedInUser.CurrentlyRidingHorse.BasicStats.Experience < 25)
|
|
{
|
|
if(GameServer.RandomNumberGenerator.Next(0, 100) == 97)
|
|
{
|
|
loggedInUser.CurrentlyRidingHorse.BasicStats.Experience++;
|
|
byte[] horseBuckedMessage;
|
|
if(loggedInUser.CurrentlyRidingHorse.Breed.Type == "llama")
|
|
horseBuckedMessage = PacketBuilder.CreateChat(Messages.HorseLlamaBuckedYou, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
else if (loggedInUser.CurrentlyRidingHorse.Breed.Type == "camel")
|
|
horseBuckedMessage = PacketBuilder.CreateChat(Messages.HorseCamelBuckedYou, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
else
|
|
horseBuckedMessage = PacketBuilder.CreateChat(Messages.HorseBuckedYou, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
|
|
sender.LoggedinUser.CurrentlyRidingHorse = null;
|
|
sender.LoggedinUser.Facing %= 5;
|
|
sender.SendPacket(horseBuckedMessage);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Randomly move if thirst, hunger, tiredness too low-
|
|
|
|
byte movementDirection = packet[1];
|
|
|
|
if (loggedInUser.Thirst <= 0 || loggedInUser.Hunger <= 0 || loggedInUser.Tiredness <= 0)
|
|
{
|
|
if (RandomNumberGenerator.Next(0, 10) == 7)
|
|
{
|
|
byte[] possibleDirections = new byte[] { PacketBuilder.MOVE_UP, PacketBuilder.MOVE_DOWN, PacketBuilder.MOVE_RIGHT, PacketBuilder.MOVE_LEFT };
|
|
|
|
if (possibleDirections.Contains(movementDirection))
|
|
{
|
|
byte newDirection = possibleDirections[RandomNumberGenerator.Next(0, possibleDirections.Length)];
|
|
if (newDirection != movementDirection)
|
|
{
|
|
movementDirection = newDirection;
|
|
if (loggedInUser.Thirst <= 0)
|
|
{
|
|
byte[] chatMessage = PacketBuilder.CreateChat(Messages.FormatRandomMovementMessage(Messages.StatThirst.ToUpper(), Messages.StatThirstDizzy), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatMessage);
|
|
}
|
|
else if (loggedInUser.Hunger <= 0)
|
|
{
|
|
byte[] chatMessage = PacketBuilder.CreateChat(Messages.FormatRandomMovementMessage(Messages.StatHunger.ToUpper(), Messages.StatHungerStumble), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatMessage);
|
|
}
|
|
/*
|
|
* Doesnt appear to acturally exist.
|
|
*
|
|
else if (loggedInUser.Tiredness <= 0)
|
|
{
|
|
byte[] chatMessage = PacketBuilder.CreateChat(Messages.FormatRandomMovementMessage(Messages.StatTired.ToUpper()), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatMessage);
|
|
}
|
|
*/
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
int onHorse = 0;
|
|
int facing = sender.LoggedinUser.Facing;
|
|
while (facing >= 5)
|
|
{
|
|
facing -= 5;
|
|
onHorse++;
|
|
}
|
|
byte direction = 0;
|
|
int newX = loggedInUser.X;
|
|
int newY = loggedInUser.Y;
|
|
|
|
|
|
bool moveTwo = false;
|
|
|
|
if (movementDirection == PacketBuilder.MOVE_ESCAPE) // Exit this place / X Button
|
|
{
|
|
|
|
byte Direction;
|
|
if (World.InSpecialTile(loggedInUser.X, loggedInUser.Y))
|
|
{
|
|
|
|
World.SpecialTile tile = World.GetSpecialTile(loggedInUser.X, loggedInUser.Y);
|
|
if (tile.ExitX != 0)
|
|
newX = tile.ExitX;
|
|
if (tile.ExitY != 0)
|
|
newY = tile.ExitY;
|
|
else
|
|
if (Map.CheckPassable(loggedInUser.X, loggedInUser.Y + 1) || loggedInUser.NoClip)
|
|
newY += 1;
|
|
|
|
|
|
|
|
if (loggedInUser.X + 1 == newX && loggedInUser.Y == newY)
|
|
Direction = PacketBuilder.DIRECTION_RIGHT;
|
|
else if (loggedInUser.X - 1 == newX && loggedInUser.Y == newY)
|
|
Direction = PacketBuilder.DIRECTION_LEFT;
|
|
else if (loggedInUser.Y + 1 == newY && loggedInUser.X == newX)
|
|
Direction = PacketBuilder.DIRECTION_DOWN;
|
|
else if (loggedInUser.Y - 1 == newY && loggedInUser.X == newX)
|
|
Direction = PacketBuilder.DIRECTION_UP;
|
|
else
|
|
Direction = PacketBuilder.DIRECTION_TELEPORT;
|
|
|
|
loggedInUser.X = newX;
|
|
loggedInUser.Y = newY;
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
if (Map.CheckPassable(loggedInUser.X, loggedInUser.Y + 1) || loggedInUser.NoClip)
|
|
loggedInUser.Y += 1;
|
|
|
|
Direction = PacketBuilder.DIRECTION_DOWN;
|
|
}
|
|
|
|
loggedInUser.Facing = Direction + (onHorse * 5);
|
|
Logger.DebugPrint("Exiting player: " + loggedInUser.Username + " to: " + loggedInUser.X + "," + loggedInUser.Y);
|
|
byte[] moveResponse = PacketBuilder.CreateMovement(loggedInUser.X, loggedInUser.Y, loggedInUser.CharacterId, loggedInUser.Facing, Direction, true);
|
|
sender.SendPacket(moveResponse);
|
|
goto Complete;
|
|
}
|
|
|
|
if (movementDirection == PacketBuilder.MOVE_UP)
|
|
{
|
|
direction = PacketBuilder.DIRECTION_UP;
|
|
if (Map.CheckPassable(newX, newY - 1) || loggedInUser.NoClip)
|
|
newY -= 1;
|
|
|
|
|
|
if (loggedInUser.Facing == (direction + (onHorse * 5)) && loggedInUser.CurrentlyRidingHorse != null && !World.InTown(loggedInUser.X, loggedInUser.Y)) // Double move
|
|
if (Map.CheckPassable(newX, newY - 1) || loggedInUser.NoClip)
|
|
{
|
|
newY -= 1;
|
|
moveTwo = true;
|
|
}
|
|
}
|
|
else if (movementDirection == PacketBuilder.MOVE_LEFT)
|
|
{
|
|
direction = PacketBuilder.DIRECTION_LEFT;
|
|
if (Map.CheckPassable(newX - 1, newY) || loggedInUser.NoClip)
|
|
newX -= 1;
|
|
|
|
|
|
if (loggedInUser.Facing == (direction + (onHorse * 5)) && loggedInUser.CurrentlyRidingHorse != null && !World.InTown(loggedInUser.X, loggedInUser.Y)) // Double move
|
|
if (Map.CheckPassable(newX - 1, newY) || loggedInUser.NoClip)
|
|
{
|
|
newX -= 1;
|
|
moveTwo = true;
|
|
}
|
|
}
|
|
else if (movementDirection == PacketBuilder.MOVE_RIGHT)
|
|
{
|
|
direction = PacketBuilder.DIRECTION_RIGHT;
|
|
if (Map.CheckPassable(newX + 1, newY) || loggedInUser.NoClip)
|
|
newX += 1;
|
|
|
|
|
|
if (loggedInUser.Facing == (direction + (onHorse * 5)) && loggedInUser.CurrentlyRidingHorse != null && !World.InTown(loggedInUser.X, loggedInUser.Y)) // Double move
|
|
if (Map.CheckPassable(newX + 1, newY) || loggedInUser.NoClip)
|
|
{
|
|
newX += 1;
|
|
moveTwo = true;
|
|
}
|
|
}
|
|
else if (movementDirection == PacketBuilder.MOVE_DOWN)
|
|
{
|
|
direction = PacketBuilder.DIRECTION_DOWN;
|
|
if (Map.CheckPassable(newX, newY + 1) || loggedInUser.NoClip)
|
|
newY += 1;
|
|
|
|
|
|
if (loggedInUser.Facing == (direction + (onHorse * 5)) && loggedInUser.CurrentlyRidingHorse != null && !World.InTown(loggedInUser.X, loggedInUser.Y)) // Double move
|
|
if (Map.CheckPassable(newX, newY + 1) || loggedInUser.NoClip)
|
|
{
|
|
newY += 1;
|
|
moveTwo = true;
|
|
}
|
|
}
|
|
else if(movementDirection == PacketBuilder.MOVE_UPDATE)
|
|
{
|
|
UpdateArea(sender);
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
loggedInUser.Facing = direction + (onHorse * 5);
|
|
if (loggedInUser.Y != newY || loggedInUser.X != newX)
|
|
{
|
|
if (moveTwo)
|
|
direction += 20;
|
|
|
|
loggedInUser.Y = newY;
|
|
loggedInUser.X = newX;
|
|
|
|
// Check Treasures
|
|
if (Treasure.IsTileTreasure(loggedInUser.X, loggedInUser.Y))
|
|
{
|
|
Treasure treasure = Treasure.GetTreasureAt(loggedInUser.X, loggedInUser.Y);
|
|
if (treasure.Type == "RAINBOW")
|
|
{
|
|
treasure.CollectTreasure(loggedInUser);
|
|
goto Complete;
|
|
}
|
|
}
|
|
|
|
byte[] moveResponse = PacketBuilder.CreateMovement(loggedInUser.X, loggedInUser.Y, loggedInUser.CharacterId, loggedInUser.Facing, direction, true);
|
|
sender.SendPacket(moveResponse);
|
|
}
|
|
else
|
|
{
|
|
byte[] moveResponse = PacketBuilder.CreateMovement(loggedInUser.X, loggedInUser.Y, loggedInUser.CharacterId, loggedInUser.Facing, PacketBuilder.DIRECTION_NONE, false);
|
|
sender.SendPacket(moveResponse);
|
|
}
|
|
Complete:;
|
|
|
|
// Cancel Trades
|
|
if (loggedInUser.TradingWith != null)
|
|
if ((loggedInUser.TradingWith.Trader.X != loggedInUser.X) && (loggedInUser.TradingWith.Trader.Y != loggedInUser.Y))
|
|
loggedInUser.TradingWith.CancelTradeMoved();
|
|
|
|
// Pac-man the world.
|
|
if (loggedInUser.X > Map.Width)
|
|
loggedInUser.Teleport(2, loggedInUser.Y);
|
|
else if (loggedInUser.X < 2)
|
|
loggedInUser.Teleport(Map.Width - 2, loggedInUser.Y);
|
|
else if (loggedInUser.Y > Map.Height - 2)
|
|
loggedInUser.Teleport(loggedInUser.X, 2);
|
|
else if (loggedInUser.Y < 2)
|
|
loggedInUser.Teleport(loggedInUser.X, Map.Height - 2);
|
|
|
|
|
|
User[] onScreenNow = GetOnScreenUsers(loggedInUser.X, loggedInUser.Y, true, true);
|
|
|
|
User[] goneOffScreen = onScreenBefore.Except(onScreenNow).ToArray();
|
|
User[] goneOnScreen = onScreenNow.Except(onScreenBefore).ToArray();
|
|
|
|
foreach (User offScreenUsers in goneOffScreen)
|
|
{
|
|
if (offScreenUsers.Id == loggedInUser.Id)
|
|
continue;
|
|
|
|
byte[] playerInfoBytes = PacketBuilder.CreatePlayerInfoUpdateOrCreate(1000 + 4, 1000 + 1, loggedInUser.Facing, loggedInUser.CharacterId, loggedInUser.Username);
|
|
offScreenUsers.LoggedinClient.SendPacket(playerInfoBytes);
|
|
}
|
|
|
|
foreach (User onScreenUsers in goneOnScreen)
|
|
{
|
|
if (onScreenUsers.Id == loggedInUser.Id)
|
|
continue;
|
|
|
|
byte[] playerInfoBytes = PacketBuilder.CreatePlayerInfoUpdateOrCreate(onScreenUsers.X, onScreenUsers.Y, onScreenUsers.Facing, onScreenUsers.CharacterId, onScreenUsers.Username);
|
|
loggedInUser.LoggedinClient.SendPacket(playerInfoBytes);
|
|
}
|
|
|
|
Update(sender);
|
|
|
|
}
|
|
public static void OnQuitPacket(GameClient sender, byte[] packet)
|
|
{
|
|
if(!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Sent quit packet when not logged in.");
|
|
return;
|
|
}
|
|
Logger.InfoPrint(sender.LoggedinUser.Username + " Clicked \"Quit Game\".. Disconnecting");
|
|
sender.Disconnect();
|
|
}
|
|
public static void OnNpcInteraction(GameClient sender, byte[] packet)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Sent npc interaction packet when not logged in.");
|
|
return;
|
|
}
|
|
if (packet.Length < 2)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Sent an invalid npc interaction packet.");
|
|
return;
|
|
}
|
|
byte action = packet[1];
|
|
if (action == PacketBuilder.NPC_START_CHAT)
|
|
{
|
|
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string number = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
int chatId = 0;
|
|
|
|
try
|
|
{
|
|
chatId = int.Parse(number);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to start talking to an NPC with id that is NaN.");
|
|
return;
|
|
}
|
|
if(!Npc.NpcExists(chatId))
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to start talking to an NPC that doesnt exist.");
|
|
return;
|
|
}
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
Npc.NpcEntry entry = Npc.GetNpcById(chatId);
|
|
|
|
if(entry.Chatpoints.Length <= 0)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to start talking to an NPC with no chatpoints.");
|
|
return;
|
|
}
|
|
|
|
int defaultChatpointId = Npc.GetDefaultChatpoint(sender.LoggedinUser, entry);
|
|
Npc.NpcChat startingChatpoint = Npc.GetNpcChatpoint(entry, defaultChatpointId);
|
|
|
|
string metaInfo = Meta.BuildNpcChatpoint(sender.LoggedinUser, entry, startingChatpoint);
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(metaInfo);
|
|
sender.SendPacket(metaPacket);
|
|
|
|
sender.LoggedinUser.LastTalkedToNpc = entry;
|
|
}
|
|
else if (action == PacketBuilder.NPC_CONTINUE_CHAT)
|
|
{
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string number = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
int replyId = 0;
|
|
try
|
|
{
|
|
replyId = int.Parse(number);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to reply to an NPC with replyid that is NaN.");
|
|
return;
|
|
}
|
|
|
|
Npc.NpcEntry lastNpc = sender.LoggedinUser.LastTalkedToNpc;
|
|
Npc.NpcReply reply;
|
|
try
|
|
{
|
|
reply = Npc.GetNpcReply(lastNpc, replyId);
|
|
}
|
|
catch(KeyNotFoundException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to reply with replyid that does not exist.");
|
|
return;
|
|
}
|
|
|
|
if (reply.GotoChatpoint == -1)
|
|
{
|
|
UpdateArea(sender);
|
|
return;
|
|
}
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
string metaInfo = Meta.BuildNpcChatpoint(sender.LoggedinUser, lastNpc, Npc.GetNpcChatpoint(lastNpc, reply.GotoChatpoint));
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(metaInfo);
|
|
sender.SendPacket(metaPacket);
|
|
return;
|
|
}
|
|
}
|
|
public static void OnTransportUsed(GameClient sender, byte[] packet)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Sent transport packet when not logged in.");
|
|
return;
|
|
}
|
|
if (packet.Length < 2)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Sent an invalid transport packet.");
|
|
return;
|
|
}
|
|
|
|
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string number = packetStr.Substring(1, (packetStr.Length - 1) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
|
|
int transportid;
|
|
try
|
|
{
|
|
transportid = Int32.Parse(number);
|
|
}
|
|
catch(FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to use a transport with id that is NaN.");
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
Transport.TransportPoint transportPoint = Transport.GetTransportPoint(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
if (transportPoint.X != sender.LoggedinUser.X && transportPoint.Y != sender.LoggedinUser.Y)
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to use transport id: " + transportid.ToString() + " while not the correct transport point!");
|
|
return;
|
|
}
|
|
|
|
Transport.TransportLocation transportLocation = Transport.GetTransportLocation(transportid);
|
|
int cost = transportLocation.Cost;
|
|
|
|
if (transportLocation.Type == "WAGON")
|
|
{
|
|
if(sender.LoggedinUser.OwnedRanch != null)
|
|
{
|
|
if(sender.LoggedinUser.OwnedRanch.GetBuildingCount(7) > 0) // Wagon
|
|
{
|
|
cost = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (sender.LoggedinUser.Bids.Length > 0)
|
|
{
|
|
byte[] cantBuyWhileAuctioning = PacketBuilder.CreateChat(Messages.AuctionNoOtherTransactionAllowed, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantBuyWhileAuctioning);
|
|
return;
|
|
}
|
|
|
|
|
|
if (sender.LoggedinUser.Money >= cost)
|
|
{
|
|
string swfToLoad = Messages.BoatCutscene;
|
|
if (transportLocation.Type == "WAGON")
|
|
swfToLoad = Messages.WagonCutscene;
|
|
|
|
if (transportLocation.Type != "ROWBOAT")
|
|
{
|
|
byte[] swfModulePacket = PacketBuilder.CreateSwfModule(swfToLoad, PacketBuilder.PACKET_SWF_MODULE_CUTSCENE);
|
|
sender.SendPacket(swfModulePacket);
|
|
}
|
|
|
|
sender.LoggedinUser.Teleport(transportLocation.GotoX, transportLocation.GotoY);
|
|
sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.Transport).Count++;
|
|
|
|
|
|
if (sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.Transport).Count >= 500)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(27)); // Traveller
|
|
if (sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.Transport).Count >= 5000)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(28)); // Globetrotter
|
|
|
|
byte[] welcomeToIslePacket = PacketBuilder.CreateChat(Messages.FormatWelcomeToAreaMessage(transportLocation.LocationTitle), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(welcomeToIslePacket);
|
|
|
|
if(cost > 0)
|
|
sender.LoggedinUser.TakeMoney(cost);
|
|
}
|
|
else
|
|
{
|
|
byte[] cantAfford = PacketBuilder.CreateChat(Messages.CantAffordTransport, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantAfford);
|
|
}
|
|
}
|
|
catch (KeyNotFoundException)
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to use transport id: " + transportid.ToString() + " while not on a transport point!");
|
|
}
|
|
|
|
|
|
}
|
|
public static void OnRanchPacket(GameClient sender, byte[] packet)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Sent ranch packet when not logged in.");
|
|
return;
|
|
}
|
|
if (packet.Length < 3)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid ranch packet.");
|
|
return;
|
|
}
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
byte method = packet[1];
|
|
|
|
if (method == PacketBuilder.RANCH_INFO)
|
|
{
|
|
string buildingIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
int buildingId = 0;
|
|
try
|
|
{
|
|
buildingId = int.Parse(buildingIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to get info for building id NaN");
|
|
return;
|
|
}
|
|
if (Ranch.RanchBuilding.RanchBuildingExists(buildingId))
|
|
{
|
|
Ranch.RanchBuilding building = Ranch.RanchBuilding.GetRanchBuildingById(buildingId);
|
|
|
|
byte[] ranchBuild = PacketBuilder.CreateChat(Messages.FormatBuildingInformaton(building.Title, building.Description), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(ranchBuild);
|
|
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to get info for building id that didnt exist.");
|
|
return;
|
|
}
|
|
}
|
|
else if (method == PacketBuilder.RANCH_SELL)
|
|
{
|
|
string NanSTR = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
if (NanSTR == "NaN")
|
|
{
|
|
if (sender.LoggedinUser.OwnedRanch == null)
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to sell there ranch when they didnt own one.");
|
|
return;
|
|
}
|
|
int sellPrice = sender.LoggedinUser.OwnedRanch.GetSellPrice();
|
|
sender.LoggedinUser.AddMoney(sellPrice);
|
|
byte[] sellPacket = PacketBuilder.CreateChat(Messages.FormatRanchSoldMessage(sellPrice), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.LoggedinUser.OwnedRanch.OwnerId = -1;
|
|
sender.SendPacket(sellPacket);
|
|
|
|
// Change map sprite.
|
|
User[] users = GetUsersAt(sender.LoggedinUser.X, sender.LoggedinUser.Y, true, true);
|
|
foreach (User user in users)
|
|
{
|
|
byte[] MovementPacket = PacketBuilder.CreateMovement(user.X, user.Y, user.CharacterId, user.Facing, PacketBuilder.DIRECTION_TELEPORT, true);
|
|
user.LoggedinClient.SendPacket(MovementPacket);
|
|
}
|
|
UpdateAreaForAll(sender.LoggedinUser.X, sender.LoggedinUser.Y, true);
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to sell there ranch without sending NaN.");
|
|
return;
|
|
}
|
|
}
|
|
else if (method == PacketBuilder.RANCH_UPGRADE)
|
|
{
|
|
string NanSTR = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
if (NanSTR == "NaN")
|
|
{
|
|
if (sender.LoggedinUser.OwnedRanch != null)
|
|
{
|
|
Ranch.RanchUpgrade currentUpgrade = sender.LoggedinUser.OwnedRanch.GetRanchUpgrade();
|
|
|
|
if (!Ranch.RanchUpgrade.RanchUpgradeExists(currentUpgrade.Id + 1))
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to upgrade there ranch when it was max upgrade.");
|
|
return;
|
|
}
|
|
|
|
Ranch.RanchUpgrade nextUpgrade = Ranch.RanchUpgrade.GetRanchUpgradeById(currentUpgrade.Id + 1);
|
|
if (sender.LoggedinUser.Money >= nextUpgrade.Cost)
|
|
{
|
|
sender.LoggedinUser.TakeMoney(nextUpgrade.Cost);
|
|
sender.LoggedinUser.OwnedRanch.InvestedMoney += nextUpgrade.Cost;
|
|
sender.LoggedinUser.OwnedRanch.UpgradedLevel++;
|
|
|
|
byte[] upgraded = PacketBuilder.CreateChat(Messages.UpgradedMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(upgraded);
|
|
|
|
// Change map sprite.
|
|
User[] users = GetUsersAt(sender.LoggedinUser.X, sender.LoggedinUser.Y, true, true);
|
|
foreach (User user in users)
|
|
{
|
|
byte[] MovementPacket = PacketBuilder.CreateMovement(user.X, user.Y, user.CharacterId, user.Facing, PacketBuilder.DIRECTION_TELEPORT, true);
|
|
user.LoggedinClient.SendPacket(MovementPacket);
|
|
}
|
|
UpdateAreaForAll(sender.LoggedinUser.X, sender.LoggedinUser.Y, true);
|
|
}
|
|
else
|
|
{
|
|
byte[] cantAfford = PacketBuilder.CreateChat(Messages.UpgradeCannotAfford, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantAfford);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to upgrade there ranch when they didnt own one.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to upgrade there ranch without sending NaN.");
|
|
return;
|
|
}
|
|
}
|
|
else if (method == PacketBuilder.RANCH_REMOVE)
|
|
{
|
|
string buildingIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
int buildingId = 0;
|
|
try
|
|
{
|
|
buildingId = int.Parse(buildingIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to get info for building id NaN");
|
|
return;
|
|
}
|
|
if (Ranch.RanchBuilding.RanchBuildingExists(buildingId))
|
|
{
|
|
Ranch.RanchBuilding building = Ranch.RanchBuilding.GetRanchBuildingById(buildingId);
|
|
int ranchBuild = sender.LoggedinUser.LastClickedRanchBuilding;
|
|
if (ranchBuild <= 0)
|
|
return;
|
|
if (sender.LoggedinUser.OwnedRanch != null)
|
|
{
|
|
if (ranchBuild > sender.LoggedinUser.OwnedRanch.GetRanchUpgrade().Limit)
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to remove more buildings than the limit.");
|
|
return;
|
|
}
|
|
|
|
Ranch.RanchBuilding ranchBuilding = sender.LoggedinUser.OwnedRanch.GetBuilding(ranchBuild - 1);
|
|
|
|
if (ranchBuilding == null)
|
|
return;
|
|
|
|
if (ranchBuilding.Id == buildingId)
|
|
{
|
|
sender.LoggedinUser.OwnedRanch.SetBuilding(ranchBuild - 1, null);
|
|
sender.LoggedinUser.AddMoney(ranchBuilding.GetTeardownPrice());
|
|
sender.LoggedinUser.OwnedRanch.InvestedMoney -= building.Cost;
|
|
byte[] chatPacket = PacketBuilder.CreateChat(Messages.FormatBuildingTornDown(ranchBuilding.GetTeardownPrice()), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
|
|
sender.SendPacket(chatPacket);
|
|
UpdateAreaForAll(sender.LoggedinUser.X, sender.LoggedinUser.Y, true);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to remove bulidingid: " + buildingId + " from building slot " + ranchBuild + " but the building was not found there.");
|
|
}
|
|
|
|
}
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to remove in a ranch when they dont own one.");
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to get info for building id that didnt exist.");
|
|
return;
|
|
}
|
|
}
|
|
else if (method == PacketBuilder.RANCH_BUILD)
|
|
{
|
|
string buildingIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
int buildingId = 0;
|
|
try
|
|
{
|
|
buildingId = int.Parse(buildingIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to get info for building id NaN");
|
|
return;
|
|
}
|
|
if (Ranch.RanchBuilding.RanchBuildingExists(buildingId))
|
|
{
|
|
Ranch.RanchBuilding building = Ranch.RanchBuilding.GetRanchBuildingById(buildingId);
|
|
int ranchBuild = sender.LoggedinUser.LastClickedRanchBuilding;
|
|
if (ranchBuild == 0)
|
|
return;
|
|
if (sender.LoggedinUser.OwnedRanch != null)
|
|
{
|
|
if (ranchBuild > sender.LoggedinUser.OwnedRanch.GetRanchUpgrade().Limit)
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to build more buildings than the limit.");
|
|
return;
|
|
}
|
|
|
|
if (sender.LoggedinUser.Money >= building.Cost)
|
|
{
|
|
sender.LoggedinUser.OwnedRanch.SetBuilding(ranchBuild - 1, building);
|
|
sender.LoggedinUser.OwnedRanch.InvestedMoney += building.Cost;
|
|
sender.LoggedinUser.TakeMoney(building.Cost);
|
|
byte[] chatPacket = PacketBuilder.CreateChat(Messages.RanchBuildingComplete, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatPacket);
|
|
UpdateAreaForAll(sender.LoggedinUser.X, sender.LoggedinUser.Y, true);
|
|
return;
|
|
|
|
}
|
|
else
|
|
{
|
|
byte[] chatPacket = PacketBuilder.CreateChat(Messages.RanchCantAffordThisBuilding, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatPacket);
|
|
return;
|
|
}
|
|
}
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to build in a ranch when they dont own one.");
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to get info for building id that didnt exist.");
|
|
return;
|
|
}
|
|
}
|
|
else if (method == PacketBuilder.RANCH_BUY)
|
|
{
|
|
string nan = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
if (nan == "NaN")
|
|
{
|
|
if (Ranch.IsRanchHere(sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
Ranch ranch = Ranch.GetRanchAt(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
if (sender.LoggedinUser.Money >= ranch.Value)
|
|
{
|
|
byte[] broughtRanch = PacketBuilder.CreateChat(Messages.FormatRanchBroughtMessage(ranch.Value), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(broughtRanch);
|
|
sender.LoggedinUser.TakeMoney(ranch.Value);
|
|
ranch.OwnerId = sender.LoggedinUser.Id;
|
|
ranch.InvestedMoney += ranch.Value;
|
|
UpdateAreaForAll(sender.LoggedinUser.X, sender.LoggedinUser.Y, true);
|
|
|
|
}
|
|
else
|
|
{
|
|
byte[] cantAfford = PacketBuilder.CreateChat(Messages.RanchCantAffordRanch, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantAfford);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to buy a non existant ranch.");
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent RANCH_BUY without \"NaN\".");
|
|
return;
|
|
}
|
|
}
|
|
else if (method == PacketBuilder.RANCH_CLICK)
|
|
{
|
|
if (packet.Length < 5)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid ranch click packet.");
|
|
return;
|
|
}
|
|
byte action = packet[2];
|
|
if (action == PacketBuilder.RANCH_CLICK_BUILD)
|
|
{
|
|
if (Ranch.IsRanchHere(sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
Ranch ranch = Ranch.GetRanchAt(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
if (sender.LoggedinUser.OwnedRanch != null)
|
|
{
|
|
if (sender.LoggedinUser.OwnedRanch.Id == ranch.Id)
|
|
{
|
|
int buildSlot = packet[3] - 40;
|
|
sender.LoggedinUser.LastClickedRanchBuilding = buildSlot;
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
|
|
if (buildSlot == 0)
|
|
{
|
|
byte[] buildingsAvalible = PacketBuilder.CreateMeta(Meta.BuildRanchUpgrade(ranch));
|
|
sender.SendPacket(buildingsAvalible);
|
|
|
|
}
|
|
else
|
|
{
|
|
byte[] buildingsAvalible = PacketBuilder.CreateMeta(Meta.BuildRanchBuildingsAvalible(ranch, buildSlot));
|
|
sender.SendPacket(buildingsAvalible);
|
|
}
|
|
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to build in a ranch they didnt own.");
|
|
return;
|
|
}
|
|
else if (action == PacketBuilder.RANCH_CLICK_NORM)
|
|
{
|
|
if (Ranch.IsRanchHere(sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
Ranch ranch = Ranch.GetRanchAt(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
int buildSlot = packet[3] - 40;
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
|
|
if (buildSlot == 0) // Main Building
|
|
{
|
|
byte[] upgradeDescription = PacketBuilder.CreateMeta(Meta.BuildRanchBuilding(ranch, ranch.GetRanchUpgrade()));
|
|
sender.SendPacket(upgradeDescription);
|
|
}
|
|
else // Other Building
|
|
{
|
|
byte[] buildingDescription = PacketBuilder.CreateMeta(Meta.BuildRanchBuilding(ranch, ranch.GetBuilding(buildSlot - 1)));
|
|
sender.SendPacket(buildingDescription);
|
|
}
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " sent an Unknown ranch packet " + BitConverter.ToString(packet).Replace("-", " "));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " sent an Unknown ranch packet " + BitConverter.ToString(packet).Replace("-", " "));
|
|
}
|
|
}
|
|
public static void OnChatPacket(GameClient sender, byte[] packet)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Sent chat packet when not logged in.");
|
|
return;
|
|
}
|
|
|
|
if (packet.Length < 3)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Sent an invalid chat packet.");
|
|
return;
|
|
}
|
|
|
|
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
|
|
Chat.ChatChannel channel = (Chat.ChatChannel)packet[1];
|
|
string message = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
|
|
Logger.DebugPrint(sender.LoggedinUser.Username + " Attempting to say '" + message + "' in channel: " + channel.ToString());
|
|
|
|
string nameTo = null;
|
|
if (channel == Chat.ChatChannel.Dm)
|
|
{
|
|
nameTo = Chat.GetDmRecipiant(message);
|
|
message = Chat.GetDmMessage(message);
|
|
}
|
|
|
|
if (message == "")
|
|
return;
|
|
|
|
if (message.StartsWith("/"))
|
|
{
|
|
string channelString = message.Split(' ')[0].ToLower();
|
|
string newMessage = string.Join(' ', message.Split(' ').Skip(1));
|
|
message = newMessage.Trim();
|
|
|
|
if (message == "")
|
|
channelString = "/";
|
|
|
|
switch (channelString)
|
|
{
|
|
case "/$":
|
|
case "/ads":
|
|
channel = Chat.ChatChannel.Ads;
|
|
break;
|
|
case "/a":
|
|
case "/all":
|
|
channel = Chat.ChatChannel.All;
|
|
break;
|
|
case "/h":
|
|
case "/here":
|
|
channel = Chat.ChatChannel.Here;
|
|
break;
|
|
case "/n":
|
|
case "/near":
|
|
channel = Chat.ChatChannel.Near;
|
|
break;
|
|
case "/b":
|
|
case "/buddy":
|
|
channel = Chat.ChatChannel.Buddies;
|
|
break;
|
|
case "/i":
|
|
case "/island":
|
|
channel = Chat.ChatChannel.Isle;
|
|
break;
|
|
case "/admin":
|
|
if (sender.LoggedinUser.Administrator)
|
|
channel = Chat.ChatChannel.Admin;
|
|
else
|
|
return;
|
|
break;
|
|
case "/mod":
|
|
if (sender.LoggedinUser.Moderator)
|
|
channel = Chat.ChatChannel.Mod;
|
|
else
|
|
return;
|
|
break;
|
|
default:
|
|
channel = Chat.ChatChannel.Dm;
|
|
nameTo = channelString.Substring(1).Trim();
|
|
break;
|
|
}
|
|
|
|
if (message == "") // this is how pinto does it, im serious.
|
|
{
|
|
channel = Chat.ChatChannel.Dm;
|
|
nameTo = "";
|
|
}
|
|
}
|
|
|
|
message = message.Trim();
|
|
|
|
if (channel == Chat.ChatChannel.All && message.Length > 150)
|
|
{
|
|
byte[] tooLong = PacketBuilder.CreateChat(Messages.GlobalChatTooLong, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(tooLong);
|
|
return;
|
|
}
|
|
|
|
if (channel == Chat.ChatChannel.Ads && message.Length > 150)
|
|
{
|
|
byte[] tooLong = PacketBuilder.CreateChat(Messages.AdsChatTooLong, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(tooLong);
|
|
return;
|
|
}
|
|
if (Chat.ProcessCommand(sender.LoggedinUser, message))
|
|
{
|
|
Logger.DebugPrint(sender.LoggedinUser.Username + " Attempting to run command '" + message + "' in channel: " + channel.ToString());
|
|
return;
|
|
}
|
|
|
|
// Check events
|
|
if (RiddleEvent.Active)
|
|
if(RiddleEvent.CheckRiddle(message))
|
|
RiddleEvent.Win(sender.LoggedinUser);
|
|
|
|
|
|
|
|
// Check if player is muting channel
|
|
|
|
if( (sender.LoggedinUser.MuteGlobal && channel == Chat.ChatChannel.All) || (sender.LoggedinUser.MuteAds && channel == Chat.ChatChannel.Ads) || (sender.LoggedinUser.MuteHere && channel == Chat.ChatChannel.Here) && (sender.LoggedinUser.MuteBuddy && channel == Chat.ChatChannel.Buddies) && (sender.LoggedinUser.MuteNear && channel == Chat.ChatChannel.Near) && (sender.LoggedinUser.MuteIsland && channel == Chat.ChatChannel.Isle))
|
|
{
|
|
byte[] cantSendMessage = PacketBuilder.CreateChat(Messages.CantSendInMutedChannel, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantSendMessage);
|
|
return;
|
|
}
|
|
|
|
if(sender.LoggedinUser.MutePrivateMessage && channel == Chat.ChatChannel.Dm)
|
|
{
|
|
byte[] cantSendDmMessage = PacketBuilder.CreateChat(Messages.CantSendPrivateMessageWhileMuted, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantSendDmMessage);
|
|
return;
|
|
}
|
|
|
|
Object violationReason = Chat.FilterMessage(message);
|
|
if (violationReason != null)
|
|
{
|
|
sender.LoggedinUser.ChatViolations += 1;
|
|
string chatViolationMessage = Messages.FormatGlobalChatViolationMessage((Chat.Reason)violationReason);
|
|
byte[] chatViolationPacket = PacketBuilder.CreateChat(chatViolationMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatViolationPacket);
|
|
return;
|
|
}
|
|
|
|
byte chatSide = Chat.GetSide(channel);
|
|
message = Chat.DoCorrections(message);
|
|
message = Chat.EscapeMessage(message);
|
|
|
|
string failedReason = Chat.NonViolationChecks(sender.LoggedinUser, message);
|
|
if (failedReason != null)
|
|
{
|
|
byte[] failedMessage = PacketBuilder.CreateChat(failedReason, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(failedMessage);
|
|
return;
|
|
}
|
|
|
|
GameClient[] recipiants = Chat.GetRecipiants(sender.LoggedinUser, channel, nameTo);
|
|
|
|
|
|
if(channel == Chat.ChatChannel.Dm)
|
|
{
|
|
if(recipiants.Length <= 0)
|
|
{
|
|
byte[] cantFindPlayer = PacketBuilder.CreateChat(Messages.CantFindPlayerToPrivateMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantFindPlayer);
|
|
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
nameTo = recipiants[0].LoggedinUser.Username;
|
|
}
|
|
}
|
|
|
|
// Spam filter
|
|
if(ConfigReader.EnableSpamFilter)
|
|
{
|
|
if (channel == Chat.ChatChannel.Ads)
|
|
{
|
|
if (!sender.LoggedinUser.CanUseAdsChat && !sender.LoggedinUser.Administrator)
|
|
{
|
|
byte[] cantSendInAds = PacketBuilder.CreateChat(Messages.AdsOnlyOncePerMinute, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantSendInAds);
|
|
|
|
return;
|
|
}
|
|
sender.LoggedinUser.CanUseAdsChat = false;
|
|
}
|
|
else if (channel == Chat.ChatChannel.All)
|
|
{
|
|
if (sender.LoggedinUser.TotalGlobalChatMessages <= 0 && !sender.LoggedinUser.Administrator)
|
|
{
|
|
byte[] globalLimited = PacketBuilder.CreateChat(Messages.GlobalChatLimited, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(globalLimited);
|
|
|
|
return;
|
|
}
|
|
sender.LoggedinUser.TotalGlobalChatMessages--;
|
|
}
|
|
}
|
|
|
|
|
|
// Muted user checks
|
|
if(channel == Chat.ChatChannel.Dm)
|
|
{
|
|
try
|
|
{
|
|
User userTo = GetUserByNameStartswith(nameTo);
|
|
if (sender.LoggedinUser.MutePlayer.IsUserMuted(userTo))
|
|
{
|
|
byte[] dmWasBlocked = PacketBuilder.CreateChat(Messages.FormatCantSendYourIgnoringPlayer(userTo.Username), PacketBuilder.CHAT_DM_RIGHT);
|
|
sender.SendPacket(dmWasBlocked);
|
|
return;
|
|
}
|
|
else if (userTo.MutePrivateMessage)
|
|
{
|
|
byte[] dmWasBlocked = PacketBuilder.CreateChat(Messages.FormatPlayerIgnoringAllPms(userTo.Username), PacketBuilder.CHAT_DM_RIGHT);
|
|
sender.SendPacket(dmWasBlocked);
|
|
return;
|
|
}
|
|
else if (userTo.MutePlayer.IsUserMuted(sender.LoggedinUser))
|
|
{
|
|
byte[] dmWasBlocked = PacketBuilder.CreateChat(Messages.FormatPlayerIgnoringYourPms(userTo.Username), PacketBuilder.CHAT_DM_RIGHT);
|
|
sender.SendPacket(dmWasBlocked);
|
|
return;
|
|
}
|
|
}
|
|
catch (KeyNotFoundException)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
// Finally send chat message.
|
|
string formattedMessage = Chat.FormatChatForOthers(sender.LoggedinUser, channel, message);
|
|
string formattedMessageSender = Chat.FormatChatForSender(sender.LoggedinUser, channel, message, nameTo);
|
|
|
|
|
|
byte[] chatPacketOthers = PacketBuilder.CreateChat(formattedMessage, chatSide);
|
|
byte[] chatPacketSender = PacketBuilder.CreateChat(formattedMessageSender, chatSide);
|
|
byte[] playDmSound = PacketBuilder.CreatePlaySound(Chat.PrivateMessageSound);
|
|
|
|
// Send to clients ...
|
|
foreach (GameClient recipiant in recipiants)
|
|
{
|
|
recipiant.SendPacket(chatPacketOthers);
|
|
|
|
if (channel == Chat.ChatChannel.Dm)
|
|
recipiant.SendPacket(playDmSound);
|
|
}
|
|
|
|
// Send to sender
|
|
sender.SendPacket(chatPacketSender);
|
|
|
|
// AutoReply
|
|
if (channel == Chat.ChatChannel.Dm)
|
|
{
|
|
foreach (GameClient recipiant in recipiants)
|
|
{
|
|
if (recipiant.LoggedinUser.AutoReplyText != "")
|
|
{
|
|
string formattedMessageAuto = Chat.FormatChatForOthers(recipiant.LoggedinUser, channel, recipiant.LoggedinUser.AutoReplyText, true);
|
|
string formattedMessageSenderAuto = Chat.FormatChatForSender(recipiant.LoggedinUser, channel, recipiant.LoggedinUser.AutoReplyText, nameTo, true);
|
|
|
|
byte[] chatPacketAutoOthers = PacketBuilder.CreateChat(formattedMessageAuto, chatSide);
|
|
sender.SendPacket(chatPacketAutoOthers);
|
|
|
|
byte[] chatPacketAutoSender = PacketBuilder.CreateChat(formattedMessageSenderAuto, chatSide);
|
|
recipiant.SendPacket(chatPacketAutoSender);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
public static void OnClickPacket(GameClient sender, byte[] packet)
|
|
{
|
|
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Send click packet when not logged in.");
|
|
return;
|
|
}
|
|
if (packet.Length < 5)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid Click Packet");
|
|
return;
|
|
}
|
|
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
if(packetStr.Contains("|"))
|
|
{
|
|
string packetContents = packetStr.Substring(1, (packetStr.Length - 1) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
string[] xy = packetContents.Split('|');
|
|
int x = 0;
|
|
int y = 0;
|
|
|
|
try
|
|
{
|
|
x = int.Parse(xy[0])+4;
|
|
y = int.Parse(xy[1])+1;
|
|
}
|
|
catch(FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent a click packet with non-string xy value.");
|
|
return;
|
|
}
|
|
|
|
Logger.DebugPrint(sender.LoggedinUser.Username + " Clicked on tile: " + Map.GetTileId(x, y, false).ToString() + "(overlay: " + Map.GetTileId(x, y, true).ToString() + ") at " + x.ToString() + "," + y.ToString());
|
|
|
|
|
|
// Get description of tile
|
|
string returnedMsg = Messages.NothingInterestingHere;
|
|
if(World.InSpecialTile(x, y))
|
|
{
|
|
World.SpecialTile tile = World.GetSpecialTile(x, y);
|
|
if (tile.Title != null)
|
|
returnedMsg = tile.Title;
|
|
}
|
|
if(Ranch.IsRanchHere(x, y)) // Ranch here?
|
|
{
|
|
Ranch ranch = Ranch.GetRanchAt(x, y);
|
|
if(ranch.OwnerId == -1)
|
|
{
|
|
returnedMsg = Messages.RanchUnownedRanchClicked;
|
|
}
|
|
else
|
|
{
|
|
string title = ranch.Title;
|
|
if (title == null || title == "")
|
|
title = Messages.RanchDefaultRanchTitle;
|
|
returnedMsg = Messages.FormatRanchClickMessage(Database.GetUsername(ranch.OwnerId), title);
|
|
}
|
|
}
|
|
User[] users = GetUsersAt(x, y, false, true);
|
|
if (users.Length > 0) // Player here?
|
|
{
|
|
string usernameStr = "";
|
|
|
|
for(int i = 0; i < users.Length; i++)
|
|
{
|
|
usernameStr += users[i].Username;
|
|
if (i + 1 < users.Length)
|
|
usernameStr += ", ";
|
|
}
|
|
|
|
returnedMsg = Messages.FormatPlayerHereMessage(usernameStr);
|
|
}
|
|
byte[] tileInfoPacket = PacketBuilder.CreateTileClickInfo(returnedMsg);
|
|
// Debug tile id information
|
|
//byte[] tileInfoPacket = PacketBuilder.CreateTileClickInfo("ground: " + (Map.GetTileId(x, y, false)-1).ToString() + ", overlay: " + (Map.GetTileId(x, y, true)-1).ToString());
|
|
sender.SendPacket(tileInfoPacket);
|
|
}
|
|
}
|
|
public static void OnItemInteraction(GameClient sender, byte[] packet)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Sent object interaction packet when not logged in.");
|
|
return;
|
|
}
|
|
if (packet.Length < 2)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid object interaction packet. " + BitConverter.ToString(packet));
|
|
return;
|
|
}
|
|
|
|
byte action = packet[1];
|
|
switch(action)
|
|
{
|
|
case PacketBuilder.ITEM_PICKUP_ALL:
|
|
string chatMsg = Messages.GrabAllItemsMessage;
|
|
DroppedItems.DroppedItem[] droppedItems = DroppedItems.GetItemsAt(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
|
|
foreach (DroppedItems.DroppedItem item in droppedItems)
|
|
{
|
|
try
|
|
{
|
|
sender.LoggedinUser.Inventory.Add(item.Instance);
|
|
DroppedItems.RemoveDroppedItem(item);
|
|
}
|
|
catch (InventoryException)
|
|
{
|
|
chatMsg = Messages.GrabbedAllItemsButInventoryFull;
|
|
}
|
|
}
|
|
|
|
UpdateAreaForAll(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
|
|
byte[] chatMessage = PacketBuilder.CreateChat(chatMsg, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatMessage);
|
|
|
|
break;
|
|
case PacketBuilder.ITEM_PICKUP:
|
|
string packetStr = Encoding.UTF8.GetString(packet);
|
|
string randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
int randomId = 0;
|
|
|
|
try
|
|
{
|
|
randomId = Int32.Parse(randomIdStr);
|
|
}
|
|
catch(FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid object interaction packet. " + BitConverter.ToString(packet));
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
DroppedItems.DroppedItem item = DroppedItems.GetDroppedItemById(randomId);
|
|
try
|
|
{
|
|
sender.LoggedinUser.Inventory.Add(item.Instance);
|
|
}
|
|
catch (InventoryException)
|
|
{
|
|
byte[] inventoryFullMessage = PacketBuilder.CreateChat(Messages.GrabbedItemButInventoryFull, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(inventoryFullMessage);
|
|
break;
|
|
}
|
|
|
|
|
|
DroppedItems.RemoveDroppedItem(item);
|
|
|
|
UpdateAreaForAll(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
|
|
chatMessage = PacketBuilder.CreateChat(Messages.GrabbedItemMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatMessage);
|
|
}
|
|
catch(KeyNotFoundException)
|
|
{
|
|
byte[] pickedUp = PacketBuilder.CreateChat(Messages.DroppedItemCouldntPickup, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(pickedUp);
|
|
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to grab a non existing object.");
|
|
return;
|
|
}
|
|
|
|
break;
|
|
case PacketBuilder.ITEM_REMOVE:
|
|
char toRemove = (char)packet[2];
|
|
switch(toRemove)
|
|
{
|
|
case '1':
|
|
if(sender.LoggedinUser.EquipedCompetitionGear.Head != null)
|
|
{
|
|
ItemInstance itemInstance = new ItemInstance(sender.LoggedinUser.EquipedCompetitionGear.Head.Id);
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(itemInstance);
|
|
sender.LoggedinUser.EquipedCompetitionGear.Head = null;
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Attempted to remove competition gear when none was equipped.");
|
|
}
|
|
break;
|
|
case '2':
|
|
if (sender.LoggedinUser.EquipedCompetitionGear.Body != null)
|
|
{
|
|
ItemInstance itemInstance = new ItemInstance(sender.LoggedinUser.EquipedCompetitionGear.Body.Id);
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(itemInstance);
|
|
sender.LoggedinUser.EquipedCompetitionGear.Body = null;
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Attempted to remove competition gear when none was equipped.");
|
|
}
|
|
break;
|
|
case '3':
|
|
if (sender.LoggedinUser.EquipedCompetitionGear.Legs != null)
|
|
{
|
|
ItemInstance itemInstance = new ItemInstance(sender.LoggedinUser.EquipedCompetitionGear.Legs.Id);
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(itemInstance);
|
|
sender.LoggedinUser.EquipedCompetitionGear.Legs = null;
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Attempted to remove competition gear when none was equipped.");
|
|
}
|
|
break;
|
|
case '4':
|
|
if (sender.LoggedinUser.EquipedCompetitionGear.Feet != null)
|
|
{
|
|
ItemInstance itemInstance = new ItemInstance(sender.LoggedinUser.EquipedCompetitionGear.Feet.Id);
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(itemInstance);
|
|
sender.LoggedinUser.EquipedCompetitionGear.Feet = null;
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Attempted to remove competition gear when none was equipped.");
|
|
}
|
|
break;
|
|
case '5':
|
|
if (sender.LoggedinUser.EquipedJewelry.Slot1 != null)
|
|
{
|
|
ItemInstance itemInstance = new ItemInstance(sender.LoggedinUser.EquipedJewelry.Slot1.Id);
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(itemInstance);
|
|
sender.LoggedinUser.EquipedJewelry.Slot1 = null;
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Attempted to remove jewery when none was equipped.");
|
|
}
|
|
break;
|
|
case '6':
|
|
if (sender.LoggedinUser.EquipedJewelry.Slot2 != null)
|
|
{
|
|
ItemInstance itemInstance = new ItemInstance(sender.LoggedinUser.EquipedJewelry.Slot2.Id);
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(itemInstance);
|
|
sender.LoggedinUser.EquipedJewelry.Slot2 = null;
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Attempted to remove jewery when none was equipped.");
|
|
}
|
|
break;
|
|
case '7':
|
|
if (sender.LoggedinUser.EquipedJewelry.Slot3 != null)
|
|
{
|
|
ItemInstance itemInstance = new ItemInstance(sender.LoggedinUser.EquipedJewelry.Slot3.Id);
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(itemInstance);
|
|
sender.LoggedinUser.EquipedJewelry.Slot3 = null;
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Attempted to remove jewery when none was equipped.");
|
|
}
|
|
break;
|
|
case '8':
|
|
if (sender.LoggedinUser.EquipedJewelry.Slot4 != null)
|
|
{
|
|
ItemInstance itemInstance = new ItemInstance(sender.LoggedinUser.EquipedJewelry.Slot4.Id);
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(itemInstance);
|
|
sender.LoggedinUser.EquipedJewelry.Slot4 = null;
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Attempted to remove jewery when none was equipped.");
|
|
}
|
|
break;
|
|
default:
|
|
Logger.InfoPrint(sender.LoggedinUser.Username + "Unimplemented \"remove worn item\" ItemInteraction packet: " + BitConverter.ToString(packet).Replace("-", " "));
|
|
break;
|
|
}
|
|
|
|
UpdateStats(sender);
|
|
if(toRemove >= '1' && toRemove <= '4')
|
|
{
|
|
byte[] itemRemovedMessage = PacketBuilder.CreateChat(Messages.RemoveCompetitionGear, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(itemRemovedMessage);
|
|
}
|
|
else if (toRemove >= '5' && toRemove <= '8')
|
|
{
|
|
byte[] itemRemovedMessage = PacketBuilder.CreateChat(Messages.RemoveJewelry, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(itemRemovedMessage);
|
|
}
|
|
|
|
break;
|
|
case PacketBuilder.ITEM_THROW:
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
string itemidStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
int itemId = 0;
|
|
|
|
try
|
|
{
|
|
itemId = Int32.Parse(itemidStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid object interaction packet. (THROW) " + BitConverter.ToString(packet));
|
|
return;
|
|
}
|
|
if (sender.LoggedinUser.Inventory.HasItemId(itemId))
|
|
{
|
|
if (!Item.IsThrowable(itemId))
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to throw an item that isnt throwable.");
|
|
return;
|
|
}
|
|
|
|
ItemInstance curItem = sender.LoggedinUser.Inventory.GetItemByItemId(itemId).ItemInstances[0];
|
|
User[] userAt = GetReallyNearbyUsers(sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
|
|
while (true)
|
|
{
|
|
int userIndx = RandomNumberGenerator.Next(0, userAt.Length);
|
|
|
|
if (userAt.Length > 1)
|
|
if (userAt[userIndx].Id == sender.LoggedinUser.Id)
|
|
continue;
|
|
|
|
Item.ThrowableItem throwableItem = Item.GetThrowableItem(curItem.ItemId);
|
|
|
|
if (userAt[userIndx].Id == sender.LoggedinUser.Id)
|
|
{
|
|
byte[] thrownHitYourself = PacketBuilder.CreateChat(throwableItem.HitYourselfMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(thrownHitYourself);
|
|
break;
|
|
}
|
|
if(itemId == Item.WaterBalloon)
|
|
{
|
|
if (WaterBalloonEvent != null)
|
|
if (WaterBalloonEvent.Active)
|
|
WaterBalloonEvent.AddWaterBallon(userAt[userIndx]);
|
|
}
|
|
if(itemId == Item.ModSplatterball)
|
|
{
|
|
ModsRevengeEvent.Payout(sender.LoggedinUser, userAt[userIndx]);
|
|
}
|
|
|
|
byte[] thrownForYou = PacketBuilder.CreateChat(Messages.FormatThrownItemMessage(throwableItem.ThrowMessage, userAt[userIndx].Username), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
byte[] thrownForOthers = PacketBuilder.CreateChat(Messages.FormatThrownItemMessage(throwableItem.HitMessage, sender.LoggedinUser.Username), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
|
|
sender.SendPacket(thrownForYou);
|
|
userAt[userIndx].LoggedinClient.SendPacket(thrownForOthers);
|
|
|
|
break;
|
|
}
|
|
|
|
sender.LoggedinUser.Inventory.Remove(curItem);
|
|
UpdateInventory(sender);
|
|
|
|
}
|
|
break;
|
|
case PacketBuilder.ITEM_WRAP:
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
randomId = 0;
|
|
|
|
try
|
|
{
|
|
randomId = Int32.Parse(randomIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid object interaction packet. " + BitConverter.ToString(packet));
|
|
return;
|
|
}
|
|
if (sender.LoggedinUser.Inventory.HasItem(randomId))
|
|
{
|
|
ItemInstance curItem = sender.LoggedinUser.Inventory.GetItemByRandomid(randomId).ItemInstances[0];
|
|
ItemInstance wrappedItem = new ItemInstance(Item.Present, -1, curItem.ItemId);
|
|
|
|
try
|
|
{
|
|
sender.LoggedinUser.Inventory.Add(wrappedItem);
|
|
sender.LoggedinUser.Inventory.Remove(curItem);
|
|
}
|
|
catch(InventoryException)
|
|
{
|
|
byte[] cantWrapPresent = PacketBuilder.CreateChat(Messages.SantaCantWrapInvFull, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantWrapPresent);
|
|
UpdateArea(sender);
|
|
break;
|
|
}
|
|
}
|
|
byte[] wrappedObjectMessage = PacketBuilder.CreateChat(Messages.SantaWrappedObjectMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(wrappedObjectMessage);
|
|
UpdateArea(sender);
|
|
break;
|
|
case PacketBuilder.ITEM_OPEN:
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packet.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
randomId = 0;
|
|
|
|
try
|
|
{
|
|
randomId = Int32.Parse(randomIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid object interaction packet. " + BitConverter.ToString(packet));
|
|
return;
|
|
}
|
|
if (sender.LoggedinUser.Inventory.HasItem(randomId))
|
|
{
|
|
InventoryItem item = sender.LoggedinUser.Inventory.GetItemByRandomid(randomId);
|
|
int newItem = item.ItemInstances[0].Data;
|
|
if(newItem == 0)
|
|
{
|
|
sender.LoggedinUser.Inventory.Remove(item.ItemInstances[0]);
|
|
|
|
byte[] itemOpenFailedNothingInside = PacketBuilder.CreateChat(Messages.SantaCantOpenNothingInside, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(itemOpenFailedNothingInside);
|
|
|
|
UpdateInventory(sender);
|
|
|
|
break;
|
|
}
|
|
|
|
try
|
|
{
|
|
sender.LoggedinUser.Inventory.Add(new ItemInstance(newItem));
|
|
sender.LoggedinUser.Inventory.Remove(item.ItemInstances[0]);
|
|
}
|
|
catch(InventoryException)
|
|
{
|
|
byte[] cantOpenInvFull = PacketBuilder.CreateChat(Messages.SantaItemCantOpenInvFull, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantOpenInvFull);
|
|
break;
|
|
}
|
|
byte[] itemOpened = PacketBuilder.CreateChat(Messages.FormatSantaOpenPresent(Item.GetItemById(newItem).Name), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(itemOpened);
|
|
UpdateInventory(sender);
|
|
}
|
|
break;
|
|
case PacketBuilder.ITEM_USE:
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
|
|
if(randomIdStr == "") // f12 ranch shortcut
|
|
{
|
|
if (sender.LoggedinUser.Inventory.HasItemId(Item.DorothyShoes))
|
|
{
|
|
InventoryItem itm = sender.LoggedinUser.Inventory.GetItemByItemId(Item.DorothyShoes);
|
|
Item.UseItem(sender.LoggedinUser, itm.ItemInstances[0]);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
byte[] noShoesMessage = PacketBuilder.CreateChat(Messages.RanchNoDorothyShoesMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(noShoesMessage);
|
|
return;
|
|
}
|
|
}
|
|
|
|
randomId = 0;
|
|
|
|
try
|
|
{
|
|
randomId = Int32.Parse(randomIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid object interaction packet. " + BitConverter.ToString(packet));
|
|
return;
|
|
}
|
|
if (sender.LoggedinUser.Inventory.HasItem(randomId))
|
|
{
|
|
InventoryItem itm = sender.LoggedinUser.Inventory.GetItemByRandomid(randomId);
|
|
Item.UseItem(sender.LoggedinUser, itm.ItemInstances[0]);
|
|
}
|
|
break;
|
|
case PacketBuilder.ITEM_WEAR:
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
randomId = 0;
|
|
|
|
try
|
|
{
|
|
randomId = Int32.Parse(randomIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid object interaction packet. " + BitConverter.ToString(packet));
|
|
return;
|
|
}
|
|
if (sender.LoggedinUser.Inventory.HasItem(randomId))
|
|
{
|
|
InventoryItem itm = sender.LoggedinUser.Inventory.GetItemByRandomid(randomId);
|
|
ItemInstance instance = itm.ItemInstances[0];
|
|
|
|
Item.ItemInformation itemInf = instance.GetItemInfo();
|
|
if(itemInf.Type == "CLOTHES")
|
|
{
|
|
switch (itemInf.GetMiscFlag(0))
|
|
{
|
|
case CompetitionGear.MISC_FLAG_HEAD:
|
|
if (sender.LoggedinUser.EquipedCompetitionGear.Head == null)
|
|
sender.LoggedinUser.EquipedCompetitionGear.Head = itemInf;
|
|
else
|
|
{
|
|
ItemInstance itemInstance = new ItemInstance(sender.LoggedinUser.EquipedCompetitionGear.Head.Id);
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(itemInstance);
|
|
sender.LoggedinUser.EquipedCompetitionGear.Head = itemInf;
|
|
}
|
|
break;
|
|
case CompetitionGear.MISC_FLAG_BODY:
|
|
if (sender.LoggedinUser.EquipedCompetitionGear.Body == null)
|
|
sender.LoggedinUser.EquipedCompetitionGear.Body = itemInf;
|
|
else
|
|
{
|
|
ItemInstance itemInstance = new ItemInstance(sender.LoggedinUser.EquipedCompetitionGear.Body.Id);
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(itemInstance);
|
|
sender.LoggedinUser.EquipedCompetitionGear.Body = itemInf;
|
|
}
|
|
break;
|
|
case CompetitionGear.MISC_FLAG_LEGS:
|
|
if (sender.LoggedinUser.EquipedCompetitionGear.Legs == null)
|
|
sender.LoggedinUser.EquipedCompetitionGear.Legs = itemInf;
|
|
else
|
|
{
|
|
ItemInstance itemInstance = new ItemInstance(sender.LoggedinUser.EquipedCompetitionGear.Legs.Id);
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(itemInstance);
|
|
sender.LoggedinUser.EquipedCompetitionGear.Legs = itemInf;
|
|
}
|
|
break;
|
|
case CompetitionGear.MISC_FLAG_FEET:
|
|
if (sender.LoggedinUser.EquipedCompetitionGear.Feet == null)
|
|
sender.LoggedinUser.EquipedCompetitionGear.Feet = itemInf;
|
|
else
|
|
{
|
|
ItemInstance itemInstance = new ItemInstance(sender.LoggedinUser.EquipedCompetitionGear.Feet.Id);
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(itemInstance);
|
|
sender.LoggedinUser.EquipedCompetitionGear.Feet = itemInf;
|
|
}
|
|
break;
|
|
default:
|
|
Logger.ErrorPrint(itemInf.Name + " Has unknown misc flags.");
|
|
return;
|
|
}
|
|
sender.LoggedinUser.Inventory.Remove(instance);
|
|
byte[] chatPacket = PacketBuilder.CreateChat(Messages.FormatEquipCompetitionGearMessage(itemInf.Name), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatPacket);
|
|
}
|
|
else if(itemInf.Type == "JEWELRY")
|
|
{
|
|
bool addedJewelry = false;
|
|
if (sender.LoggedinUser.EquipedJewelry.Slot1 == null)
|
|
{
|
|
sender.LoggedinUser.EquipedJewelry.Slot1 = itemInf;
|
|
addedJewelry = true;
|
|
}
|
|
else if (sender.LoggedinUser.EquipedJewelry.Slot2 == null)
|
|
{
|
|
sender.LoggedinUser.EquipedJewelry.Slot2 = itemInf;
|
|
addedJewelry = true;
|
|
}
|
|
else if (sender.LoggedinUser.EquipedJewelry.Slot3 == null)
|
|
{
|
|
sender.LoggedinUser.EquipedJewelry.Slot3 = itemInf;
|
|
addedJewelry = true;
|
|
}
|
|
else if (sender.LoggedinUser.EquipedJewelry.Slot4 == null)
|
|
{
|
|
sender.LoggedinUser.EquipedJewelry.Slot4 = itemInf;
|
|
addedJewelry = true;
|
|
}
|
|
|
|
if(addedJewelry)
|
|
{
|
|
sender.LoggedinUser.Inventory.Remove(instance);
|
|
byte[] chatPacket = PacketBuilder.CreateChat(Messages.FormatJewerlyEquipMessage(itemInf.Name), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatPacket);
|
|
}
|
|
else
|
|
{
|
|
byte[] chatPacket = PacketBuilder.CreateChat(Messages.MaxJewelryMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatPacket);
|
|
}
|
|
}
|
|
|
|
UpdateInventory(sender);
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to wear an item they did not have.");
|
|
}
|
|
break;
|
|
case PacketBuilder.ITEM_DRINK:
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
string idStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
if(idStr == "NaN") // Fountain
|
|
{
|
|
string msg = Messages.FountainDrankYourFull;
|
|
bool looseMoney = RandomNumberGenerator.Next(0, 20) == 18;
|
|
if(looseMoney)
|
|
{
|
|
int looseAmount = RandomNumberGenerator.Next(0, 100);
|
|
if (looseAmount > sender.LoggedinUser.Money)
|
|
looseAmount = sender.LoggedinUser.Money;
|
|
sender.LoggedinUser.TakeMoney(looseAmount);
|
|
msg = Messages.FormatDroppedMoneyMessage(looseAmount);
|
|
}
|
|
|
|
sender.LoggedinUser.Thirst = 1000;
|
|
byte[] drankFromFountainMessage = PacketBuilder.CreateChat(msg, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(drankFromFountainMessage);
|
|
}
|
|
else
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + "Sent unknown ITEM_DRINK command id: " + idStr);
|
|
}
|
|
break;
|
|
case PacketBuilder.ITEM_CONSUME:
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
randomId = 0;
|
|
|
|
try
|
|
{
|
|
randomId = Int32.Parse(randomIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid object interaction packet. " + BitConverter.ToString(packet));
|
|
return;
|
|
}
|
|
|
|
if (sender.LoggedinUser.Inventory.HasItem(randomId))
|
|
{
|
|
InventoryItem itm = sender.LoggedinUser.Inventory.GetItemByRandomid(randomId);
|
|
ItemInstance instance = itm.ItemInstances[0];
|
|
sender.LoggedinUser.Inventory.Remove(instance);
|
|
Item.ItemInformation itmInfo = instance.GetItemInfo();
|
|
bool toMuch = Item.ConsumeItem(sender.LoggedinUser, itmInfo);
|
|
|
|
byte[] chatPacket = PacketBuilder.CreateChat(Messages.FormatConsumeItemMessaege(itmInfo.Name), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatPacket);
|
|
if (toMuch)
|
|
{
|
|
chatPacket = PacketBuilder.CreateChat(Messages.ConsumedButMaxReached, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatPacket);
|
|
}
|
|
|
|
UpdateInventory(sender);
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to consume an item they did not have.");
|
|
}
|
|
break;
|
|
case PacketBuilder.ITEM_DROP:
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
randomId = 0;
|
|
|
|
try
|
|
{
|
|
randomId = Int32.Parse(randomIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid object interaction packet. (drop)"+BitConverter.ToString(packet));
|
|
return;
|
|
}
|
|
|
|
if(sender.LoggedinUser.Inventory.HasItem(randomId))
|
|
{
|
|
InventoryItem itm = sender.LoggedinUser.Inventory.GetItemByRandomid(randomId);
|
|
ItemInstance instance = itm.ItemInstances[0];
|
|
if(DroppedItems.GetItemsAt(sender.LoggedinUser.X, sender.LoggedinUser.Y).Length > 25)
|
|
{
|
|
byte[] tileIsFullPacket = PacketBuilder.CreateChat(Messages.DroppedItemTileIsFull, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(tileIsFullPacket);
|
|
break;
|
|
}
|
|
DroppedItems.AddItem(instance, sender.LoggedinUser.X, sender.LoggedinUser.Y);
|
|
sender.LoggedinUser.Inventory.Remove(instance);
|
|
byte[] chatPacket = PacketBuilder.CreateChat(Messages.DroppedAnItemMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(chatPacket);
|
|
UpdateInventory(sender);
|
|
|
|
UpdateAreaForAll(sender.LoggedinUser.X, sender.LoggedinUser.Y, false, sender.LoggedinUser);
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to drop an item they did not have.");
|
|
}
|
|
break;
|
|
case PacketBuilder.ITEM_SHOVEL:
|
|
if (packet[2] != 0x14)
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Used ITEM_SHOVEL with 3rd byte not 0x14.");
|
|
if (!Quest.UseTool(sender.LoggedinUser, Quest.Shovel, sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
byte[] ChatPacket = PacketBuilder.CreateChat(Messages.ShovelNothing, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(ChatPacket);
|
|
}
|
|
break;
|
|
case PacketBuilder.ITEM_RAKE:
|
|
if (packet[2] != 0x14)
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Used ITEM_RAKE with 3rd byte not 0x14.");
|
|
if (!Quest.UseTool(sender.LoggedinUser, Quest.Rake, sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
byte[] ChatPacket = PacketBuilder.CreateChat(Messages.RakeNothing, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(ChatPacket);
|
|
}
|
|
break;
|
|
case PacketBuilder.ITEM_MAGNIFYING:
|
|
if (packet[2] != 0x14)
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Used ITEM_MAGNIFYING with 3rd byte not 0x14.");
|
|
if (!Quest.UseTool(sender.LoggedinUser, Quest.MagnifyingGlass, sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
byte[] ChatPacket = PacketBuilder.CreateChat(Messages.MagnifyNothing, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(ChatPacket);
|
|
}
|
|
break;
|
|
case PacketBuilder.ITEM_BINOCULARS:
|
|
if (packet[2] != 0x14)
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Used ITEM_BINOCULARS with 3rd byte not 0x14.");
|
|
if(!Quest.UseTool(sender.LoggedinUser, Quest.Binoculars, sender.LoggedinUser.X, sender.LoggedinUser.Y))
|
|
{
|
|
byte[] ChatPacket = PacketBuilder.CreateChat(Messages.BinocularsNothing, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(ChatPacket);
|
|
}
|
|
break;
|
|
case PacketBuilder.ITEM_CRAFT:
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
string craftIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
int craftId = 0;
|
|
// Prevent crashing on non-int string.
|
|
try
|
|
{
|
|
craftId = Int32.Parse(craftIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " tried to craft using craft id NaN.");
|
|
return;
|
|
}
|
|
if(Workshop.CraftIdExists(craftId))
|
|
{
|
|
Workshop.CraftableItem itm = Workshop.GetCraftId(craftId);
|
|
if(itm.MoneyCost <= sender.LoggedinUser.Money) // Check money
|
|
{
|
|
foreach(Workshop.RequiredItem reqItem in itm.RequiredItems)
|
|
{
|
|
if (sender.LoggedinUser.Inventory.HasItemId(reqItem.RequiredItemId))
|
|
{
|
|
if (sender.LoggedinUser.Inventory.GetItemByItemId(reqItem.RequiredItemId).ItemInstances.Length < reqItem.RequiredItemCount)
|
|
goto failMissingItem;
|
|
}
|
|
else
|
|
goto failMissingItem;
|
|
}
|
|
|
|
// Finally create the items
|
|
try
|
|
{
|
|
sender.LoggedinUser.Inventory.Add(new ItemInstance(itm.GiveItemId));
|
|
}
|
|
catch(InventoryException)
|
|
{
|
|
byte[] inventoryFullMessage = PacketBuilder.CreateChat(Messages.WorkshopNoRoomInInventory, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(inventoryFullMessage);
|
|
break;
|
|
}
|
|
sender.LoggedinUser.TakeMoney(itm.MoneyCost);
|
|
|
|
// Remove the required items..
|
|
foreach(Workshop.RequiredItem reqItem in itm.RequiredItems)
|
|
for(int i = 0; i < reqItem.RequiredItemCount; i++)
|
|
sender.LoggedinUser.Inventory.Remove(sender.LoggedinUser.Inventory.GetItemByItemId(reqItem.RequiredItemId).ItemInstances[0]);
|
|
|
|
sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.Crafting).Count++;
|
|
|
|
if (sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.Crafting).Count >= 100)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(22)); // Craftiness
|
|
if (sender.LoggedinUser.TrackedItems.GetTrackedItem(Tracking.TrackableItem.Crafting).Count >= 1000)
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(23)); // Workmanship
|
|
|
|
byte[] itemCraftSuccess = PacketBuilder.CreateChat(Messages.WorkshopCraftingSuccess, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(itemCraftSuccess);
|
|
break;
|
|
|
|
}
|
|
else
|
|
{
|
|
byte[] cantAffordMessage = PacketBuilder.CreateChat(Messages.WorkshopCannotAfford, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantAffordMessage);
|
|
break;
|
|
}
|
|
|
|
failMissingItem:
|
|
{
|
|
byte[] missingItemMessage = PacketBuilder.CreateChat(Messages.WorkshopMissingRequiredItem, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(missingItemMessage);
|
|
break;
|
|
}
|
|
}
|
|
|
|
break;
|
|
case PacketBuilder.ITEM_SELL: // Handles selling an item.
|
|
int totalSold = 1;
|
|
int message = 1;
|
|
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
randomId = 0;
|
|
// Prevent crashing on non-int string.
|
|
try
|
|
{
|
|
randomId = Int32.Parse(randomIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid object sell packet.");
|
|
return;
|
|
}
|
|
|
|
if (!sender.LoggedinUser.Inventory.HasItem(randomId))
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to sell a item that they doesnt have in there inventory");
|
|
return;
|
|
}
|
|
|
|
InventoryItem invItem = sender.LoggedinUser.Inventory.GetItemByRandomid(randomId);
|
|
itemId = invItem.ItemId;
|
|
goto doSell;
|
|
case PacketBuilder.ITEM_SELL_ALL:
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
string itemIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
itemId = 0;
|
|
// Prevent crashing on non-int string.
|
|
try
|
|
{
|
|
itemId = Int32.Parse(itemIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid object sell packet.");
|
|
return;
|
|
}
|
|
|
|
if (!sender.LoggedinUser.Inventory.HasItemId(itemId))
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to sell a item that they doesnt have in there inventory");
|
|
return;
|
|
}
|
|
invItem = sender.LoggedinUser.Inventory.GetItemByItemId(itemId);
|
|
|
|
totalSold = invItem.ItemInstances.Length;
|
|
message = 2;
|
|
goto doSell;
|
|
doSell:;
|
|
|
|
Item.ItemInformation itemInfo = Item.GetItemById(itemId);
|
|
Shop shop = sender.LoggedinUser.LastShoppedAt;
|
|
if (shop != null)
|
|
{
|
|
UInt64 sellPrice = Convert.ToUInt64(shop.CalculateSellCost(itemInfo) * Convert.ToUInt64(totalSold));
|
|
if (shop.CanSell(itemInfo))
|
|
{
|
|
// Check if goes over 2.1b
|
|
if (Convert.ToUInt64(sender.LoggedinUser.Money) + sellPrice > 2100000000)
|
|
{
|
|
byte[] cantSellMoneyCapCheck = PacketBuilder.CreateChat(Messages.CannotSellYoudGetTooMuchMoney, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantSellMoneyCapCheck);
|
|
break;
|
|
}
|
|
|
|
// Remove items
|
|
for (int i = 0; i < totalSold; i++)
|
|
{
|
|
ItemInstance itemInstance = invItem.ItemInstances[0];
|
|
sender.LoggedinUser.Inventory.Remove(itemInstance);
|
|
shop.Inventory.Add(itemInstance);
|
|
}
|
|
|
|
if (sellPrice < 2147483647) // Sanity Check (yes i checked it earlier)
|
|
sender.LoggedinUser.AddMoney(Convert.ToInt32(sellPrice));
|
|
|
|
UpdateAreaForAll(sender.LoggedinUser.X, sender.LoggedinUser.Y, true);
|
|
if(message == 1)
|
|
{
|
|
byte[] soldItemMessage = PacketBuilder.CreateChat(Messages.FormatSellMessage(itemInfo.Name, sellPrice), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(soldItemMessage);
|
|
}
|
|
if(message == 2)
|
|
{
|
|
string name = itemInfo.Name;
|
|
|
|
if (totalSold > 1)
|
|
name = itemInfo.PluralName;
|
|
|
|
byte[] soldItemMessage = PacketBuilder.CreateChat(Messages.FormatSellAllMessage(name, sellPrice, totalSold), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(soldItemMessage);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to sell a item that was not avalible to be sold.");
|
|
}
|
|
}
|
|
break;
|
|
|
|
case PacketBuilder.ITEM_BUY_AND_CONSUME:
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
itemIdStr = packetStr.Substring(2, (packetStr.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
itemId = 0;
|
|
// Prevent crashing on non-int string.
|
|
try
|
|
{
|
|
itemId = Int32.Parse(itemIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid object buy and consume packet.");
|
|
return;
|
|
}
|
|
if (!Item.ItemIdExist(itemId))
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to buy an itemid that doesnt even exist.");
|
|
break;
|
|
}
|
|
|
|
Inn lastInn = sender.LoggedinUser.LastVisitedInn;
|
|
if (lastInn != null)
|
|
{
|
|
try
|
|
{
|
|
itemInfo = lastInn.GetStockedItem(itemId);
|
|
int price = lastInn.CalculateBuyCost(itemInfo);
|
|
if(sender.LoggedinUser.Money >= price)
|
|
{
|
|
sender.LoggedinUser.TakeMoney(price);
|
|
bool toMuch = Item.ConsumeItem(sender.LoggedinUser, itemInfo);
|
|
|
|
string tooMuchMessage = Messages.ConsumedButMaxReached;
|
|
if (itemInfo.Effects.Length > 0)
|
|
if (itemInfo.Effects[0].EffectsWhat == "TIREDNESS")
|
|
tooMuchMessage = Messages.InnFullyRested;
|
|
if (itemInfo.Effects.Length > 1)
|
|
if (itemInfo.Effects[1].EffectsWhat == "TIREDNESS")
|
|
tooMuchMessage = Messages.InnFullyRested;
|
|
|
|
byte[] enjoyedServiceMessage = PacketBuilder.CreateChat(Messages.FormatInnEnjoyedServiceMessage(itemInfo.Name, price), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(enjoyedServiceMessage);
|
|
|
|
if(toMuch)
|
|
{
|
|
byte[] toMuchMessage = PacketBuilder.CreateChat(tooMuchMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(toMuchMessage);
|
|
}
|
|
|
|
UpdateArea(sender);
|
|
}
|
|
else
|
|
{
|
|
byte[] cantAffordMessage = PacketBuilder.CreateChat(Messages.InnCannotAffordService, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantAffordMessage);
|
|
}
|
|
}
|
|
catch(KeyNotFoundException)
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to buy and consume an item not stocked by the inn there standing on.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to buy and consume item while not in a inn.");
|
|
}
|
|
break;
|
|
|
|
case PacketBuilder.ITEM_BUY: // Handles buying an item.
|
|
message = 1;
|
|
int count = 1;
|
|
goto doPurchase;
|
|
case PacketBuilder.ITEM_BUY_5:
|
|
message = 2;
|
|
count = 5;
|
|
goto doPurchase;
|
|
case PacketBuilder.ITEM_BUY_25:
|
|
message = 3;
|
|
count = 25;
|
|
doPurchase:;
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
itemIdStr = packetStr.Substring(2, (packet.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
itemId = 0;
|
|
// Prevent crashing on non-int string.
|
|
try
|
|
{
|
|
itemId = Int32.Parse(itemIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid object buy packet.");
|
|
return;
|
|
}
|
|
|
|
if(!Item.ItemIdExist(itemId))
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to buy an itemid that doesnt even exist.");
|
|
break;
|
|
}
|
|
|
|
itemInfo = Item.GetItemById(itemId);
|
|
shop = sender.LoggedinUser.LastShoppedAt;
|
|
if (shop != null)
|
|
{
|
|
UInt64 buyCost = Convert.ToUInt64(shop.CalculateBuyCost(itemInfo) * Convert.ToUInt64(count));
|
|
if (sender.LoggedinUser.Bids.Length > 0)
|
|
{
|
|
byte[] cantBuyWhileAuctioning = PacketBuilder.CreateChat(Messages.AuctionNoOtherTransactionAllowed, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantBuyWhileAuctioning);
|
|
return;
|
|
}
|
|
|
|
if (Convert.ToUInt64(sender.LoggedinUser.Money) < buyCost)
|
|
{
|
|
byte[] cantAffordMessage = PacketBuilder.CreateChat(Messages.CantAfford1, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(cantAffordMessage);
|
|
return;
|
|
}
|
|
if (shop.Inventory.HasItemId(itemId))
|
|
{
|
|
if (shop.Inventory.GetItemByItemId(itemId).ItemInstances.Length < count)
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to buy more of an item than is in stock.");
|
|
break;
|
|
}
|
|
|
|
|
|
// Check we wont overflow the inventory
|
|
if (sender.LoggedinUser.Inventory.HasItemId(itemId))
|
|
{
|
|
InventoryItem items = sender.LoggedinUser.Inventory.GetItemByItemId(itemId);
|
|
if (items.ItemInstances.Length + count > Item.MAX_STACK)
|
|
{
|
|
goto showError;
|
|
}
|
|
|
|
}
|
|
else if(sender.LoggedinUser.Inventory.Count + 1 > sender.LoggedinUser.MaxItems)
|
|
{
|
|
goto showError;
|
|
}
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
ItemInstance itemInstance = shop.Inventory.GetItemByItemId(itemId).ItemInstances[0];
|
|
try
|
|
{
|
|
sender.LoggedinUser.Inventory.Add(itemInstance);
|
|
}
|
|
catch (InventoryException)
|
|
{
|
|
Logger.ErrorPrint("Failed to add: " + itemInfo.Name + " to " + sender.LoggedinUser.Username + " inventory.");
|
|
break;
|
|
}
|
|
shop.Inventory.Remove(itemInstance);
|
|
}
|
|
|
|
if(buyCost < 2147483647) // Sanity Check (yes i checked it earlier)
|
|
sender.LoggedinUser.TakeMoney(Convert.ToInt32(buyCost));
|
|
|
|
|
|
// Send chat message to client.
|
|
UpdateAreaForAll(sender.LoggedinUser.X, sender.LoggedinUser.Y, true);
|
|
if (message == 1)
|
|
{
|
|
byte[] broughtItemMessage = PacketBuilder.CreateChat(Messages.FormatBuyMessage(itemInfo.Name, buyCost), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(broughtItemMessage);
|
|
}
|
|
else if (message == 2)
|
|
{
|
|
byte[] broughtItemMessage = PacketBuilder.CreateChat(Messages.FormatBuy5Message(itemInfo.PluralName, buyCost), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(broughtItemMessage);
|
|
}
|
|
else if (message == 3)
|
|
{
|
|
byte[] broughtItemMessage = PacketBuilder.CreateChat(Messages.FormatBuy25Message(itemInfo.PluralName, buyCost), PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(broughtItemMessage);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to buy a item that was not for sale.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to buy an item while not in a store.");
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
showError:;
|
|
if (message == 1)
|
|
{
|
|
byte[] inventoryFullMessage = PacketBuilder.CreateChat(Messages.Brought1ButInventoryFull, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(inventoryFullMessage);
|
|
}
|
|
else if (message == 2)
|
|
{
|
|
|
|
byte[] inventoryFullMessage = PacketBuilder.CreateChat(Messages.Brought5ButInventoryFull, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(inventoryFullMessage);
|
|
}
|
|
else if (message == 3)
|
|
{
|
|
|
|
byte[] inventoryFullMessage = PacketBuilder.CreateChat(Messages.Brought25ButInventoryFull, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(inventoryFullMessage);
|
|
}
|
|
break;
|
|
case PacketBuilder.ITEM_RIP:
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(2, (packet.Length - 2) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
randomId = 0;
|
|
try
|
|
{
|
|
randomId = Int32.Parse(randomIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid object interaction packet. " + BitConverter.ToString(packet));
|
|
return;
|
|
}
|
|
|
|
if (!sender.LoggedinUser.Inventory.HasItem(randomId))
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to rip someone elses mail. " + randomId.ToString());
|
|
return;
|
|
}
|
|
|
|
InventoryItem ripItems = sender.LoggedinUser.Inventory.GetItemByRandomid(randomId);
|
|
foreach (ItemInstance item in ripItems.ItemInstances)
|
|
{
|
|
if (item.RandomId == randomId)
|
|
{
|
|
if (item.Data == 0)
|
|
continue;
|
|
sender.LoggedinUser.MailBox.RipUpMessage(sender.LoggedinUser.MailBox.GetMessageByRandomId(item.Data));
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case PacketBuilder.ITEM_VIEW:
|
|
byte method = packet[2];
|
|
if (method == PacketBuilder.ITEM_LOOK)
|
|
{
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
itemIdStr = packetStr.Substring(3, (packetStr.Length - 3) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
itemId = 0;
|
|
try
|
|
{
|
|
itemId = Int32.Parse(itemIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid object interaction packet. " + BitConverter.ToString(packet));
|
|
return;
|
|
}
|
|
|
|
if (itemId == Item.MailMessage)
|
|
{
|
|
if (!sender.LoggedinUser.Inventory.HasItemId(Item.MailMessage))
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Tried to view a mail message when they didnt have one.");
|
|
return;
|
|
}
|
|
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] mailList = PacketBuilder.CreateMeta(Meta.BuildMailList(sender.LoggedinUser, sender.LoggedinUser.Inventory.GetItemByItemId(Item.MailMessage)));
|
|
sender.SendPacket(mailList);
|
|
break;
|
|
}
|
|
}
|
|
else if(method == PacketBuilder.ITEM_READ)
|
|
{
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
randomIdStr = packetStr.Substring(3, (packetStr.Length - 3) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
randomId = 0;
|
|
try
|
|
{
|
|
randomId = Int32.Parse(randomIdStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid object interaction packet. " + BitConverter.ToString(packet));
|
|
return;
|
|
}
|
|
|
|
if (!sender.LoggedinUser.Inventory.HasItem(randomId))
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " Tried to view someone elses mail. " + randomId.ToString());
|
|
return;
|
|
}
|
|
|
|
InventoryItem items = sender.LoggedinUser.Inventory.GetItemByRandomid(randomId);
|
|
foreach (ItemInstance item in items.ItemInstances)
|
|
{
|
|
if (item.RandomId == randomId)
|
|
{
|
|
if (item.Data == 0)
|
|
continue;
|
|
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
byte[] readMail = PacketBuilder.CreateMeta(Meta.BuildMailLetter(sender.LoggedinUser.MailBox.GetMessageByRandomId(item.Data), randomId));
|
|
sender.SendPacket(readMail);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Unknown Method- " + method.ToString("X") + " " + BitConverter.ToString(packet).Replace("-", " "));
|
|
break;
|
|
case PacketBuilder.PACKET_INFORMATION:
|
|
packetStr = Encoding.UTF8.GetString(packet);
|
|
string valueStr = packetStr.Substring(3, (packetStr.Length - 3) - PacketBuilder.PACKET_CLIENT_TERMINATOR_LENGTH);
|
|
int value = 0;
|
|
try
|
|
{
|
|
value = Int32.Parse(valueStr);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
Logger.ErrorPrint(sender.LoggedinUser.Username + " Sent an invalid object interaction packet. "+BitConverter.ToString(packet));
|
|
return;
|
|
}
|
|
if (packet[2] == PacketBuilder.ITEM_INFORMATON)
|
|
{
|
|
itemId = -1;
|
|
if (sender.LoggedinUser.Inventory.HasItem(value))
|
|
itemId = sender.LoggedinUser.Inventory.GetItemByRandomid(value).ItemId;
|
|
else if (DroppedItems.IsDroppedItemExist(value))
|
|
itemId = DroppedItems.GetDroppedItemById(value).Instance.ItemId;
|
|
if (itemId == -1)
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " asked for details of non existiant item.");
|
|
return;
|
|
}
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
Item.ItemInformation info = Item.GetItemById(itemId);
|
|
string infoMessage = Meta.BuildItemInfo(info);
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(infoMessage);
|
|
sender.SendPacket(metaPacket);
|
|
}
|
|
if (packet[2] == PacketBuilder.ITEM_INFORMATON_ID)
|
|
{
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
if (!Item.ItemIdExist(value))
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " asked for details of non existiant item.");
|
|
return;
|
|
}
|
|
|
|
Item.ItemInformation info = Item.GetItemById(value);
|
|
string infoMessage = Meta.BuildItemInfo(info);
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(infoMessage);
|
|
sender.SendPacket(metaPacket);
|
|
}
|
|
else if(packet[2] == PacketBuilder.NPC_INFORMATION)
|
|
{
|
|
if(Npc.NpcExists(value))
|
|
{
|
|
sender.LoggedinUser.MajorPriority = true;
|
|
Npc.NpcEntry npc = Npc.GetNpcById(value);
|
|
string infoMessage = Meta.BuildNpcInfo(npc);
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(infoMessage);
|
|
sender.SendPacket(metaPacket);
|
|
}
|
|
else
|
|
{
|
|
Logger.HackerPrint(sender.LoggedinUser.Username + " asked for details of non existiant npc.");
|
|
return;
|
|
}
|
|
}
|
|
|
|
break;
|
|
default:
|
|
Logger.WarnPrint(sender.LoggedinUser.Username + " Sent an unknown Item Interaction Packet type: " + action.ToString() + ", Packet Dump: " + BitConverter.ToString(packet).Replace('-', ' '));
|
|
break;
|
|
}
|
|
|
|
}
|
|
public static void OnInventoryRequested(GameClient sender, byte[] packet)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Sent chat packet when not logged in.");
|
|
return;
|
|
}
|
|
|
|
if (packet.Length < 1)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Sent an invalid inventory request packet.");
|
|
return;
|
|
}
|
|
|
|
UpdateInventory(sender);
|
|
}
|
|
public static void OnUserLogin(GameClient sender, byte[] packet)
|
|
{
|
|
Logger.DebugPrint("Login request received from: " + sender.RemoteIp);
|
|
|
|
string loginRequestString = Encoding.UTF8.GetString(packet).Substring(1);
|
|
|
|
if (!loginRequestString.Contains('|') || packet.Length < 2)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Sent an invalid login request");
|
|
return;
|
|
}
|
|
|
|
if (packet[1] != PacketBuilder.PACKET_CLIENT_TERMINATOR)
|
|
{
|
|
string[] loginParts = loginRequestString.Split('|');
|
|
if (loginParts.Length < 3)
|
|
{
|
|
Logger.ErrorPrint(sender.RemoteIp + " Sent a login request of invalid length. " + loginRequestString);
|
|
return;
|
|
}
|
|
|
|
int version = int.Parse(loginParts[0]);
|
|
string encryptedUsername = loginParts[1];
|
|
string encryptedPassword = loginParts[2];
|
|
string username = Authentication.DecryptLogin(encryptedUsername);
|
|
string password = Authentication.DecryptLogin(encryptedPassword);
|
|
|
|
if (Authentication.CheckPassword(username, password))
|
|
{
|
|
// Obtain user information
|
|
int userId = Database.GetUserid(username);
|
|
|
|
if(Database.IsUserBanned(userId))
|
|
{
|
|
Logger.DebugPrint(sender.RemoteIp + " Tried to login to : " + username + " but, the account was banned.");
|
|
byte[] userBannedPacket = PacketBuilder.CreateLogin(false, Messages.LoginFailedReasonBanned);
|
|
sender.SendPacket(userBannedPacket);
|
|
return;
|
|
}
|
|
|
|
if(Database.IsIpBanned(sender.RemoteIp))
|
|
{
|
|
Logger.DebugPrint(sender.RemoteIp + " Tried to login to : " + username + " but, the IP was banned.");
|
|
byte[] ipBannedPacket = PacketBuilder.CreateLogin(false, Messages.FormatIpBannedMessage(sender.RemoteIp));
|
|
sender.SendPacket(ipBannedPacket);
|
|
return;
|
|
}
|
|
|
|
sender.Login(userId);
|
|
sender.LoggedinUser.Password = password;
|
|
|
|
byte[] ResponsePacket = PacketBuilder.CreateLogin(true);
|
|
sender.SendPacket(ResponsePacket);
|
|
|
|
Logger.DebugPrint(sender.RemoteIp + " Logged into : " + sender.LoggedinUser.Username + " (ADMIN: " + sender.LoggedinUser.Administrator + " MOD: " + sender.LoggedinUser.Moderator + ")");
|
|
|
|
}
|
|
else
|
|
{
|
|
Logger.WarnPrint(sender.RemoteIp + " Attempted to login to: " + username + " with incorrect password ");
|
|
byte[] ResponsePacket = PacketBuilder.CreateLogin(false);
|
|
sender.SendPacket(ResponsePacket);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public static void OnDisconnect(GameClient sender)
|
|
{
|
|
if (sender.LoggedIn)
|
|
{
|
|
Database.SetPlayerLastLogin(Convert.ToInt32(new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds()), sender.LoggedinUser.Id); // Set last login date
|
|
Database.RemoveOnlineUser(sender.LoggedinUser.Id);
|
|
|
|
// Leave multirooms
|
|
Multiroom.LeaveAllMultirooms(sender.LoggedinUser);
|
|
TwoPlayer.TwoPlayerRemove(sender.LoggedinUser);
|
|
|
|
// Remove Trade Reference
|
|
sender.LoggedinUser.TradingWith = null;
|
|
sender.LoggedinUser.PendingTradeTo = 0;
|
|
|
|
// Leave open water balloon game
|
|
if (WaterBalloonEvent != null)
|
|
if(WaterBalloonEvent.Active)
|
|
WaterBalloonEvent.LeaveEvent(sender.LoggedinUser);
|
|
|
|
// Leave open quiz.
|
|
if (QuizEvent != null)
|
|
QuizEvent.LeaveEvent(sender.LoggedinUser);
|
|
|
|
ModsRevengeEvent.LeaveEvent(sender.LoggedinUser);
|
|
|
|
// Delete Arena Entries
|
|
if (Arena.UserHasEnteredHorseInAnyArena(sender.LoggedinUser))
|
|
{
|
|
Arena arena = Arena.GetArenaUserEnteredIn(sender.LoggedinUser);
|
|
arena.DeleteEntry(sender.LoggedinUser);
|
|
}
|
|
|
|
|
|
// Send disconnect message
|
|
byte[] logoutMessageBytes = PacketBuilder.CreateChat(Messages.FormatLogoutMessage(sender.LoggedinUser.Username), PacketBuilder.CHAT_BOTTOM_LEFT);
|
|
foreach (GameClient client in GameClient.ConnectedClients)
|
|
if (client.LoggedIn)
|
|
if (!client.LoggedinUser.MuteLogins && !client.LoggedinUser.MuteAll)
|
|
if (client.LoggedinUser.Id != sender.LoggedinUser.Id)
|
|
client.SendPacket(logoutMessageBytes);
|
|
|
|
// Tell clients of diconnect (remove from chat)
|
|
byte[] playerRemovePacket = PacketBuilder.CreatePlayerLeave(sender.LoggedinUser.Username);
|
|
foreach (GameClient client in GameClient.ConnectedClients)
|
|
if (client.LoggedIn)
|
|
if (client.LoggedinUser.Id != sender.LoggedinUser.Id)
|
|
client.SendPacket(playerRemovePacket);
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* Get(Some Information)
|
|
*/
|
|
|
|
|
|
public static bool IsUserOnline(int id)
|
|
{
|
|
try
|
|
{
|
|
GetUserById(id);
|
|
return true;
|
|
}
|
|
catch (KeyNotFoundException)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static User[] GetUsersInTown(World.Town town, bool includeStealth = false, bool includeMuted = false)
|
|
{
|
|
List<User> usersInTown = new List<User>();
|
|
foreach (GameClient client in GameClient.ConnectedClients)
|
|
if (client.LoggedIn)
|
|
{
|
|
if (!includeStealth && client.LoggedinUser.Stealth)
|
|
continue;
|
|
if (!includeMuted && client.LoggedinUser.MuteIsland)
|
|
continue;
|
|
if (World.InTown(client.LoggedinUser.X, client.LoggedinUser.Y))
|
|
if (World.GetIsle(client.LoggedinUser.X, client.LoggedinUser.Y).Name == town.Name)
|
|
usersInTown.Add(client.LoggedinUser);
|
|
}
|
|
|
|
return usersInTown.ToArray();
|
|
}
|
|
public static User[] GetUsersInIsle(World.Isle isle, bool includeStealth = false, bool includeMuted = false)
|
|
{
|
|
List<User> usersInIsle = new List<User>();
|
|
foreach (GameClient client in GameClient.ConnectedClients)
|
|
if (client.LoggedIn)
|
|
{
|
|
if (!includeStealth && client.LoggedinUser.Stealth)
|
|
continue;
|
|
if (!includeMuted && client.LoggedinUser.MuteIsland)
|
|
continue;
|
|
if (World.InIsle(client.LoggedinUser.X, client.LoggedinUser.Y))
|
|
if (World.GetIsle(client.LoggedinUser.X, client.LoggedinUser.Y).Name == isle.Name)
|
|
usersInIsle.Add(client.LoggedinUser);
|
|
}
|
|
|
|
return usersInIsle.ToArray();
|
|
}
|
|
|
|
public static User[] GetUsersOnSpecialTileCode(string code)
|
|
{
|
|
List<User> userList = new List<User>();
|
|
|
|
foreach (GameClient client in GameClient.ConnectedClients)
|
|
{
|
|
if (client.LoggedIn)
|
|
{
|
|
|
|
if (World.InSpecialTile(client.LoggedinUser.X, client.LoggedinUser.Y))
|
|
{
|
|
World.SpecialTile tile = World.GetSpecialTile(client.LoggedinUser.X, client.LoggedinUser.Y);
|
|
|
|
if (tile.Code == code)
|
|
{
|
|
userList.Add(client.LoggedinUser);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return userList.ToArray();
|
|
}
|
|
public static User[] GetUsersAt(int x, int y, bool includeStealth = false, bool includeMuted = false)
|
|
{
|
|
List<User> usersHere = new List<User>();
|
|
foreach(GameClient client in GameClient.ConnectedClients)
|
|
{
|
|
if(client.LoggedIn)
|
|
{
|
|
if (!includeStealth && client.LoggedinUser.Stealth)
|
|
continue;
|
|
if (!includeMuted && client.LoggedinUser.MuteNear)
|
|
continue;
|
|
if (client.LoggedinUser.X == x && client.LoggedinUser.Y == y)
|
|
usersHere.Add(client.LoggedinUser);
|
|
}
|
|
}
|
|
return usersHere.ToArray();
|
|
}
|
|
public static User GetUserByNameStartswith(string username)
|
|
{
|
|
foreach (GameClient client in GameClient.ConnectedClients)
|
|
{
|
|
if (client.LoggedIn)
|
|
{
|
|
if (client.LoggedinUser.Username.ToLower().StartsWith(username.ToLower()))
|
|
return client.LoggedinUser;
|
|
}
|
|
}
|
|
throw new KeyNotFoundException("User was not found.");
|
|
}
|
|
|
|
public static User GetUserByName(string username)
|
|
{
|
|
foreach(GameClient client in GameClient.ConnectedClients)
|
|
{
|
|
if(client.LoggedIn)
|
|
{
|
|
if (client.LoggedinUser.Username.ToLower() == username.ToLower())
|
|
return client.LoggedinUser;
|
|
}
|
|
}
|
|
throw new KeyNotFoundException("User was not found.");
|
|
}
|
|
|
|
public static User GetUserById(int id)
|
|
{
|
|
foreach(GameClient client in GameClient.ConnectedClients)
|
|
{
|
|
if (client.LoggedIn)
|
|
if (client.LoggedinUser.Id == id)
|
|
return client.LoggedinUser;
|
|
}
|
|
|
|
throw new KeyNotFoundException("User not found (not online?)");
|
|
}
|
|
|
|
public static User[] GetReallyNearbyUsers(int x, int y)
|
|
{
|
|
int startX = x - 3;
|
|
int endX = x + 3;
|
|
int startY = y - 3;
|
|
int endY = y + 3;
|
|
List<User> usersNearby = new List<User>();
|
|
|
|
foreach (GameClient client in GameClient.ConnectedClients)
|
|
{
|
|
if (client.LoggedIn)
|
|
{
|
|
if (startX <= client.LoggedinUser.X && endX >= client.LoggedinUser.X && startY <= client.LoggedinUser.Y && endY >= client.LoggedinUser.Y)
|
|
usersNearby.Add(client.LoggedinUser);
|
|
}
|
|
}
|
|
|
|
return usersNearby.ToArray();
|
|
}
|
|
|
|
|
|
public static bool IsOnScreen(int screenX, int screenY, int playerX, int playerY)
|
|
{
|
|
int startX = screenX - 9;
|
|
int endX = screenX + 9;
|
|
int startY = screenY - 8;
|
|
int endY = screenY + 9;
|
|
if (startX <= playerX && endX >= playerX && startY <= playerY && endY >= playerY)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
public static User[] GetOnScreenUsers(int x, int y, bool includeStealth = false, bool includeMuted = false)
|
|
{
|
|
|
|
List<User> usersOnScreen = new List<User>();
|
|
|
|
foreach (GameClient client in GameClient.ConnectedClients)
|
|
if (client.LoggedIn)
|
|
{
|
|
if (!includeStealth && client.LoggedinUser.Stealth)
|
|
continue;
|
|
if (!includeMuted && client.LoggedinUser.MuteNear)
|
|
continue;
|
|
if (IsOnScreen(x,y,client.LoggedinUser.X, client.LoggedinUser.Y))
|
|
usersOnScreen.Add(client.LoggedinUser);
|
|
}
|
|
|
|
return usersOnScreen.ToArray();
|
|
}
|
|
|
|
public static User[] GetNearbyUsers(int x, int y, bool includeStealth=false, bool includeMuted=false)
|
|
{
|
|
int startX = x - 15;
|
|
int endX = x + 15;
|
|
int startY = y - 19;
|
|
int endY = y + 19;
|
|
List<User> usersNearby = new List<User>();
|
|
|
|
foreach (GameClient client in GameClient.ConnectedClients)
|
|
{
|
|
if (client.LoggedIn)
|
|
{
|
|
if (!includeStealth && client.LoggedinUser.Stealth)
|
|
continue;
|
|
if (!includeMuted && client.LoggedinUser.MuteNear)
|
|
continue;
|
|
if (startX <= client.LoggedinUser.X && endX >= client.LoggedinUser.X && startY <= client.LoggedinUser.Y && endY >= client.LoggedinUser.Y)
|
|
usersNearby.Add(client.LoggedinUser);
|
|
}
|
|
}
|
|
|
|
return usersNearby.ToArray();
|
|
}
|
|
public static int GetNumberOfPlayers(bool includeStealth=false)
|
|
{
|
|
int count = 0;
|
|
foreach(GameClient client in GameClient.ConnectedClients)
|
|
if (client.LoggedIn)
|
|
{
|
|
if (!includeStealth && client.LoggedinUser.Stealth)
|
|
continue;
|
|
if (!client.LoggedinUser.Stealth)
|
|
count++;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
public static Point[] GetAllBuddyLocations(User caller)
|
|
{
|
|
List<Point> allLocations = new List<Point>();
|
|
|
|
foreach (GameClient client in GameClient.ConnectedClients)
|
|
{
|
|
if (client.LoggedIn)
|
|
{
|
|
|
|
if (!caller.Friends.List.Contains(client.LoggedinUser.Id))
|
|
continue;
|
|
|
|
|
|
if (!client.LoggedinUser.Stealth)
|
|
allLocations.Add(new Point(client.LoggedinUser.X, client.LoggedinUser.Y));
|
|
|
|
}
|
|
}
|
|
|
|
return allLocations.ToArray();
|
|
}
|
|
|
|
public static Point[] GetAllPlayerLocations(User caller)
|
|
{
|
|
List<Point> allLocations = new List<Point>();
|
|
|
|
foreach (GameClient client in GameClient.ConnectedClients)
|
|
{
|
|
if (client.LoggedIn)
|
|
{
|
|
|
|
if (client.LoggedinUser.Id == caller.Id)
|
|
continue;
|
|
|
|
if (!client.LoggedinUser.Stealth)
|
|
allLocations.Add(new Point(client.LoggedinUser.X, client.LoggedinUser.Y));
|
|
|
|
}
|
|
|
|
|
|
}
|
|
return allLocations.ToArray();
|
|
}
|
|
public static int GetNumberOfPlayersListeningToAdsChat()
|
|
{
|
|
int count = 0;
|
|
foreach (GameClient client in GameClient.ConnectedClients)
|
|
{
|
|
if (client.LoggedIn)
|
|
if (!client.LoggedinUser.MuteAds)
|
|
count++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
public static void CheckMail(User user)
|
|
{
|
|
if (user.MailBox.UnreadMailCount > 0)
|
|
{
|
|
|
|
byte[] RipOffAOLSound = PacketBuilder.CreatePlaySound(Messages.MailSe);
|
|
user.LoggedinClient.SendPacket(RipOffAOLSound);
|
|
|
|
byte[] mailReceivedText = PacketBuilder.CreateChat(Messages.MailReceivedMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
user.LoggedinClient.SendPacket(mailReceivedText);
|
|
|
|
user.MailBox.ReadAllMail();
|
|
}
|
|
}
|
|
public static int GetNumberOfModsOnline()
|
|
{
|
|
int count = 0;
|
|
foreach (GameClient client in GameClient.ConnectedClients)
|
|
{
|
|
if (client.LoggedIn)
|
|
if(client.LoggedinUser.Moderator)
|
|
count++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
public static int GetNumberOfBuddiesOnline(User user)
|
|
{
|
|
int total = 0;
|
|
foreach(int bud in user.Friends.List.ToArray())
|
|
{
|
|
if (IsUserOnline(bud))
|
|
{
|
|
total++;
|
|
}
|
|
}
|
|
return total;
|
|
}
|
|
|
|
public static int GetNumberOfAdminsOnline()
|
|
{
|
|
int count = 0;
|
|
foreach (GameClient client in GameClient.ConnectedClients)
|
|
{
|
|
if (client.LoggedIn)
|
|
if (client.LoggedinUser.Administrator)
|
|
count++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
/*
|
|
* Update game state functions.
|
|
*/
|
|
|
|
public static void Update(GameClient client)
|
|
{
|
|
UpdateArea(client);
|
|
foreach (User nearbyUser in GameServer.GetNearbyUsers(client.LoggedinUser.X, client.LoggedinUser.Y, false, false))
|
|
if (nearbyUser.Id != client.LoggedinUser.Id)
|
|
if(!nearbyUser.MajorPriority)
|
|
if(!nearbyUser.MinorPriority)
|
|
UpdateArea(nearbyUser.LoggedinClient);
|
|
|
|
UpdateUserFacingAndLocation(client.LoggedinUser);
|
|
}
|
|
|
|
public static void UpdateDrawingForAll(string id, GameClient sender, string drawing, bool includingSender=false)
|
|
{
|
|
World.SpecialTile[] tiles = World.GetSpecialTilesByCode("MULTIROOM-" + id);
|
|
foreach (World.SpecialTile tile in tiles)
|
|
{
|
|
UpdateAreaForAll(tile.X, tile.Y, true, null);
|
|
User[] usersHere = GameServer.GetUsersAt(tile.X, tile.Y, true, true);
|
|
foreach (User user in usersHere)
|
|
{
|
|
if (!includingSender)
|
|
if (user.Id == sender.LoggedinUser.Id)
|
|
continue;
|
|
|
|
byte[] patchDrawing = PacketBuilder.CreateDrawingUpdate(drawing);
|
|
user.LoggedinClient.SendPacket(patchDrawing);
|
|
}
|
|
}
|
|
}
|
|
public static void UpdateHorseMenu(GameClient forClient, HorseInstance horseInst)
|
|
{
|
|
|
|
forClient.LoggedinUser.MajorPriority = true;
|
|
|
|
int TileID = Map.GetTileId(forClient.LoggedinUser.X, forClient.LoggedinUser.Y, false);
|
|
string type = Map.TerrainTiles[TileID - 1].Type;
|
|
|
|
if (horseInst.Owner == forClient.LoggedinUser.Id)
|
|
forClient.LoggedinUser.LastViewedHorse = horseInst;
|
|
else
|
|
forClient.LoggedinUser.LastViewedHorseOther = horseInst;
|
|
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(Meta.BuildHorseInformation(horseInst, forClient.LoggedinUser));
|
|
forClient.SendPacket(metaPacket);
|
|
|
|
string loadSwf = HorseInfo.BreedViewerSwf(horseInst, type);
|
|
byte[] swfPacket = PacketBuilder.CreateSwfModule(loadSwf, PacketBuilder.PACKET_SWF_MODULE_FORCE);
|
|
forClient.SendPacket(swfPacket);
|
|
}
|
|
public static void UpdateInventory(GameClient forClient)
|
|
{
|
|
if (!forClient.LoggedIn)
|
|
return;
|
|
forClient.LoggedinUser.MajorPriority = true;
|
|
byte[] metaPacket = PacketBuilder.CreateMeta(Meta.BuildInventoryInfo(forClient.LoggedinUser.Inventory));
|
|
forClient.SendPacket(metaPacket);
|
|
}
|
|
|
|
public static void UpdateWeather(GameClient forClient)
|
|
{
|
|
if (!forClient.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(forClient.RemoteIp + "tried to update weather information when not logged in.");
|
|
return;
|
|
}
|
|
|
|
string lastWeather = forClient.LoggedinUser.LastSeenWeather;
|
|
string weather = forClient.LoggedinUser.GetWeatherSeen();
|
|
if (lastWeather != weather)
|
|
{
|
|
byte[] WeatherUpdate = PacketBuilder.CreateWeatherUpdate(weather);
|
|
forClient.SendPacket(WeatherUpdate);
|
|
}
|
|
}
|
|
public static void UpdateWorld(GameClient forClient)
|
|
{
|
|
if (!forClient.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(forClient.RemoteIp + "tried to update world information when not logged in.");
|
|
return;
|
|
}
|
|
|
|
byte[] WorldData = PacketBuilder.CreateTimeAndWeatherUpdate(World.ServerTime.Minutes, World.ServerTime.Days, World.ServerTime.Years, forClient.LoggedinUser.GetWeatherSeen());
|
|
forClient.SendPacket(WorldData);
|
|
}
|
|
public static void UpdatePlayer(GameClient forClient)
|
|
{
|
|
if (!forClient.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(forClient.RemoteIp + "tried to update player information when not logged in.");
|
|
return;
|
|
}
|
|
byte[] PlayerData = PacketBuilder.CreateMoneyPlayerCountAndMail(forClient.LoggedinUser.Money, GameServer.GetNumberOfPlayers(), forClient.LoggedinUser.MailBox.UnreadMailCount);
|
|
forClient.SendPacket(PlayerData);
|
|
}
|
|
|
|
public static void UpdateUserFacingAndLocation(User user)
|
|
{
|
|
byte[] playerInfoBytes = PacketBuilder.CreatePlayerInfoUpdateOrCreate(user.X, user.Y, user.Facing, user.CharacterId, user.Username);
|
|
|
|
foreach (User onScreenUser in GetOnScreenUsers(user.X, user.Y, true, true))
|
|
if (onScreenUser.Id != user.Id)
|
|
onScreenUser.LoggedinClient.SendPacket(playerInfoBytes);
|
|
}
|
|
public static void UpdateAreaForAll(int x, int y, bool ignoreMetaPrio=false, User exceptMe=null)
|
|
{
|
|
foreach(GameClient client in GameClient.ConnectedClients)
|
|
{
|
|
if (client.LoggedIn)
|
|
if (client.LoggedinUser.X == x && client.LoggedinUser.Y == y)
|
|
if(!client.LoggedinUser.MinorPriority || ignoreMetaPrio)
|
|
if(!client.LoggedinUser.MajorPriority)
|
|
if(client.LoggedinUser != exceptMe)
|
|
UpdateArea(client);
|
|
}
|
|
}
|
|
|
|
public static void UpdateArea(GameClient forClient)
|
|
{
|
|
if(forClient == null)
|
|
{
|
|
Logger.ErrorPrint(forClient.RemoteIp + "tried to update tile information when not connected.");
|
|
return;
|
|
}
|
|
if (!forClient.LoggedIn)
|
|
{
|
|
Logger.ErrorPrint(forClient.RemoteIp + "tried to update tile information when not logged in.");
|
|
return;
|
|
}
|
|
|
|
if(forClient.LoggedinUser.TradingWith != null)
|
|
{
|
|
if (!forClient.LoggedinUser.TradingWith.OtherTrade.Trader.LoggedinClient.LoggedIn)
|
|
{
|
|
forClient.LoggedinUser.TradingWith.InteruptTrade();
|
|
return;
|
|
}
|
|
|
|
if (forClient.LoggedinUser.TradingWith.OtherTrade.Trader.TradingWith == null)
|
|
{
|
|
forClient.LoggedinUser.TradingWith.InteruptTrade();
|
|
return;
|
|
}
|
|
|
|
forClient.LoggedinUser.MajorPriority = true;
|
|
forClient.LoggedinUser.TradeMenuPriority = false;
|
|
byte[] tradeMeta = PacketBuilder.CreateMeta(Meta.BuildTrade(forClient.LoggedinUser.TradingWith));
|
|
forClient.SendPacket(tradeMeta);
|
|
return;
|
|
}
|
|
|
|
forClient.LoggedinUser.MajorPriority = false;
|
|
forClient.LoggedinUser.MinorPriority = false;
|
|
|
|
string locationStr;
|
|
|
|
int tileX = forClient.LoggedinUser.X;
|
|
int tileY = forClient.LoggedinUser.Y;
|
|
if (!World.InSpecialTile(tileX, tileY))
|
|
{
|
|
if (forClient.LoggedinUser.InRealTimeQuiz)
|
|
return;
|
|
locationStr = Meta.BuildMetaInfo(forClient.LoggedinUser, tileX, tileY);
|
|
}
|
|
else
|
|
{
|
|
World.SpecialTile specialTile = World.GetSpecialTile(tileX, tileY);
|
|
if (specialTile.AutoplaySwf != null && specialTile.AutoplaySwf != "")
|
|
{
|
|
byte[] swfModulePacket = PacketBuilder.CreateSwfModule(specialTile.AutoplaySwf,PacketBuilder.PACKET_SWF_MODULE_GENTLE);
|
|
forClient.SendPacket(swfModulePacket);
|
|
}
|
|
|
|
if (forClient.LoggedinUser.InRealTimeQuiz && QuizEvent != null)
|
|
{
|
|
QuizEvent.JoinEvent(forClient.LoggedinUser).UpdateParticipent();
|
|
return;
|
|
}
|
|
|
|
if (specialTile.Code != null)
|
|
if (!ProcessMapCodeWithArg(forClient, specialTile))
|
|
return;
|
|
locationStr = Meta.BuildSpecialTileInfo(forClient.LoggedinUser, specialTile);
|
|
}
|
|
|
|
|
|
byte[] areaMessage = PacketBuilder.CreateMeta(locationStr);
|
|
forClient.SendPacket(areaMessage);
|
|
|
|
}
|
|
public static void UpdateStats(GameClient client)
|
|
{
|
|
if (!client.LoggedIn)
|
|
return;
|
|
|
|
client.LoggedinUser.MajorPriority = true;
|
|
string metaWind = Meta.BuildStatsMenu(client.LoggedinUser);
|
|
byte[] statsPacket = PacketBuilder.CreateMeta(metaWind);
|
|
client.SendPacket(statsPacket);
|
|
|
|
}
|
|
|
|
/*
|
|
* Other...
|
|
*/
|
|
|
|
public static void AddItemToAllUsersEvenOffline(int itemId, int itemCount)
|
|
{
|
|
int[] allUsers = Database.GetUsers();
|
|
foreach (int userid in allUsers)
|
|
{
|
|
for (int i = 0; i < itemCount; i++)
|
|
{
|
|
ItemInstance itm = new ItemInstance(itemId);
|
|
|
|
if (GameServer.IsUserOnline(userid))
|
|
GameServer.GetUserById(userid).Inventory.AddWithoutDatabase(itm);
|
|
|
|
Database.AddItemToInventory(userid, itm);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void RemoveAllItemsOfIdInTheGame(int id)
|
|
{
|
|
// Remove from all online players
|
|
foreach (GameClient connectedClient in GameClient.ConnectedClients)
|
|
{
|
|
if (connectedClient.LoggedIn)
|
|
{
|
|
if (connectedClient.LoggedinUser.Inventory.HasItemId(id))
|
|
{
|
|
InventoryItem invItm = connectedClient.LoggedinUser.Inventory.GetItemByItemId(id);
|
|
foreach (ItemInstance itm in invItm.ItemInstances.ToArray())
|
|
connectedClient.LoggedinUser.Inventory.Remove(itm);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Remove from shops
|
|
foreach(Shop shop in Shop.ShopList)
|
|
{
|
|
if (shop.Inventory.HasItemId(id))
|
|
{
|
|
InventoryItem invItm = shop.Inventory.GetItemByItemId(id);
|
|
foreach (ItemInstance itm in invItm.ItemInstances.ToArray())
|
|
shop.Inventory.Remove(itm);
|
|
}
|
|
|
|
}
|
|
DroppedItems.DeleteAllItemsWithId(id); // Delete all dropped items
|
|
Database.DeleteAllItemsFromUsers(id); // Delete from offline players
|
|
}
|
|
|
|
public static void StartRidingHorse(GameClient sender, int horseRandomId)
|
|
{
|
|
HorseInstance horseMountInst = sender.LoggedinUser.HorseInventory.GetHorseById(horseRandomId);
|
|
|
|
if (horseMountInst.Breed.Type != "unicorn" && horseMountInst.Breed.Type != "pegasus")
|
|
{
|
|
if (horseMountInst.Equipment.Saddle == null || horseMountInst.Equipment.SaddlePad == null || horseMountInst.Equipment.Bridle == null)
|
|
{
|
|
byte[] horseNotTackedMessage = PacketBuilder.CreateChat(Messages.HorseCannotMountUntilTackedMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(horseNotTackedMessage);
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
string ridingHorseMessage = Messages.FormatHorseRidingMessage(horseMountInst.Name);
|
|
byte[] ridingHorseMessagePacket = PacketBuilder.CreateChat(ridingHorseMessage, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
sender.SendPacket(ridingHorseMessagePacket);
|
|
|
|
sender.LoggedinUser.CurrentlyRidingHorse = horseMountInst;
|
|
|
|
// Determine what sprite to use;
|
|
int incBy = 0;
|
|
switch (horseMountInst.Color)
|
|
{
|
|
case "brown":
|
|
incBy = 1;
|
|
break;
|
|
case "cremello":
|
|
case "white":
|
|
incBy = 2;
|
|
break;
|
|
case "black":
|
|
incBy = 3;
|
|
break;
|
|
case "chestnut":
|
|
incBy = 4;
|
|
break;
|
|
case "bay":
|
|
incBy = 5;
|
|
break;
|
|
case "grey":
|
|
incBy = 6;
|
|
break;
|
|
case "dun":
|
|
incBy = 7;
|
|
break;
|
|
case "palomino":
|
|
incBy = 8;
|
|
break;
|
|
case "roan":
|
|
incBy = 9;
|
|
break;
|
|
case "pinto":
|
|
incBy = 10;
|
|
break;
|
|
}
|
|
|
|
|
|
if (horseMountInst.Breed.Type == "zebra")
|
|
{
|
|
incBy = 11;
|
|
}
|
|
if (horseMountInst.Breed.Id == 5) // Appaloosa
|
|
{
|
|
if (horseMountInst.Color == "cremello")
|
|
incBy = 12;
|
|
}
|
|
if (horseMountInst.Breed.Type == "camel")
|
|
{
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(40)); // Camel Rider
|
|
|
|
incBy = 13;
|
|
}
|
|
if(horseMountInst.Breed.Type == "llama")
|
|
{
|
|
sender.LoggedinUser.Awards.AddAward(Award.GetAwardById(41)); // Llama Rider
|
|
|
|
incBy = 14;
|
|
}
|
|
if (horseMountInst.Breed.Type == "unicorn")
|
|
{
|
|
incBy = 15;
|
|
}
|
|
if (horseMountInst.Breed.Type == "pegasus")
|
|
{
|
|
incBy = 16;
|
|
}
|
|
if (horseMountInst.Breed.Id == 170) // Unipeg
|
|
{
|
|
incBy = 17;
|
|
}
|
|
|
|
incBy *= 5;
|
|
sender.LoggedinUser.Facing %= 5;
|
|
sender.LoggedinUser.Facing += incBy;
|
|
sender.LoggedinUser.LastRiddenHorse = horseRandomId;
|
|
|
|
UpdateUserFacingAndLocation(sender.LoggedinUser);
|
|
|
|
byte[] updatePlayer = PacketBuilder.CreateMovement(sender.LoggedinUser.X, sender.LoggedinUser.Y, sender.LoggedinUser.CharacterId, sender.LoggedinUser.Facing, PacketBuilder.DIRECTION_NONE, true);
|
|
sender.SendPacket(updatePlayer);
|
|
|
|
if (sender.LoggedinUser.HorseWindowOpen)
|
|
UpdateArea(sender);
|
|
}
|
|
public static void DoItemPurchases(GameClient sender)
|
|
{
|
|
if (!sender.LoggedIn)
|
|
return;
|
|
|
|
Item.ItemPurchaseQueueItem[] queueItems = Database.GetItemPurchaseQueue(sender.LoggedinUser.Id);
|
|
foreach (Item.ItemPurchaseQueueItem queueItem in queueItems)
|
|
{
|
|
for (int i = 0; i < queueItem.ItemCount; i++)
|
|
{
|
|
sender.LoggedinUser.Inventory.AddIgnoringFull(new ItemInstance(queueItem.ItemId));
|
|
}
|
|
}
|
|
Database.ClearItemPurchaseQueue(sender.LoggedinUser.Id);
|
|
|
|
}
|
|
public static void StopRidingHorse(GameClient sender)
|
|
{
|
|
sender.LoggedinUser.CurrentlyRidingHorse = null;
|
|
|
|
sender.LoggedinUser.Facing %= 5;
|
|
UpdateUserFacingAndLocation(sender.LoggedinUser);
|
|
|
|
byte[] updatePlayer = PacketBuilder.CreateMovement(sender.LoggedinUser.X, sender.LoggedinUser.Y, sender.LoggedinUser.CharacterId, sender.LoggedinUser.Facing, PacketBuilder.DIRECTION_NONE, true);
|
|
sender.SendPacket(updatePlayer);
|
|
|
|
if (sender.LoggedinUser.HorseWindowOpen)
|
|
UpdateArea(sender);
|
|
}
|
|
public static bool ProcessMapCodeWithArg(GameClient forClient, World.SpecialTile tile)
|
|
{
|
|
string mapCode = tile.Code;
|
|
if (mapCode == null)
|
|
return false;
|
|
if(mapCode.Contains('-'))
|
|
{
|
|
string[] codeInfo = mapCode.Split('-');
|
|
string command = codeInfo[0];
|
|
string paramaters = codeInfo[1];
|
|
|
|
if(command == "JUMP")
|
|
{
|
|
if(paramaters.Contains(','))
|
|
{
|
|
string[] args = paramaters.Split(',');
|
|
try
|
|
{
|
|
int newX = int.Parse(args[0]);
|
|
int newY = int.Parse(args[1]);
|
|
forClient.LoggedinUser.Teleport(newX, newY);
|
|
if (World.InIsle(tile.X, tile.Y))
|
|
{
|
|
World.Isle isle = World.GetIsle(tile.X, tile.Y);
|
|
int tileset = isle.Tileset;
|
|
int overlay = Map.GetTileId(tile.X, tile.Y, true);
|
|
if (tileset == 6 && overlay == 249) // warp point
|
|
{
|
|
byte[] swfPacket = PacketBuilder.CreateSwfModule("warpcutscene", PacketBuilder.PACKET_SWF_MODULE_CUTSCENE);
|
|
forClient.SendPacket(swfPacket);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
catch(Exception)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(mapCode == "HAMMOCK")
|
|
{
|
|
byte[] hammockText = PacketBuilder.CreateChat(Messages.HammockText, PacketBuilder.CHAT_BOTTOM_RIGHT);
|
|
forClient.SendPacket(hammockText);
|
|
|
|
forClient.LoggedinUser.Tiredness = 1000;
|
|
foreach(HorseInstance horse in forClient.LoggedinUser.HorseInventory.HorseList)
|
|
{
|
|
horse.BasicStats.Tiredness = 1000;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
public static void OnShutdown()
|
|
{
|
|
if(ServerSocket != null)
|
|
ServerSocket.Dispose();
|
|
if (gameTimer != null)
|
|
gameTimer.Dispose();
|
|
if (minuteTimer != null)
|
|
minuteTimer.Dispose();
|
|
}
|
|
public static void ShutdownServer()
|
|
{
|
|
Logger.InfoPrint("Server shutting down.");
|
|
try
|
|
{
|
|
GameClient.OnShutdown();
|
|
GameServer.OnShutdown();
|
|
Database.OnShutdown();
|
|
}
|
|
catch (Exception) { }
|
|
|
|
Entry.OnShutdown();
|
|
}
|
|
|
|
|
|
public static void StartServer()
|
|
{
|
|
ServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
IPAddress hostIP = IPAddress.Parse(ConfigReader.BindIP);
|
|
IPEndPoint ep = new IPEndPoint(hostIP, ConfigReader.Port);
|
|
ServerSocket.Bind(ep);
|
|
ServerSocket.Listen(0xFFFF);
|
|
gameTimer = new Timer(new TimerCallback(onGameTick), null, gameTickSpeed, gameTickSpeed);
|
|
minuteTimer = new Timer(new TimerCallback(onMinuteTick), null, oneMinute, oneMinute);
|
|
Logger.InfoPrint("Binding to ip: " + ConfigReader.BindIP + " On port: " + ConfigReader.Port.ToString());
|
|
|
|
|
|
SocketAsyncEventArgs e = new SocketAsyncEventArgs();
|
|
e.Completed += GameClient.CreateClient;
|
|
GameClient.CreateClient(null, e);
|
|
}
|
|
|
|
}
|
|
}
|