public static void CreateCharHandler(WorldClient client, Packet packet)
{
string name;
byte slot, jobGender, hair, color, style;
if (!packet.TryReadByte(out slot) || !packet.TryReadString(out name, 16) ||
!packet.TryReadByte(out jobGender) || !packet.TryReadByte(out hair) ||
!packet.TryReadByte(out color) || !packet.TryReadByte(out style))
{
Log.WriteLine(LogLevel.Warn, "Error reading create char for {0}", client.Username);
return;
}
if (DatabaseChecks.IsCharNameUsed(name))
{
SendCharCreationError(client, CreateCharError.NameTaken);
return;
}
else if (DataProvider.Instance.IsBadName(name))
{
SendCharCreationError(client, CreateCharError.NameInUse);
return;
}
byte isMaleByte = (byte)((jobGender >> 7) & 0x01);
byte classIDByte = (byte)((jobGender >> 2) & 0x1F);
Job job = (Job)classIDByte;
switch (job)
{
case Job.Archer:
case Job.Cleric:
case Job.Fighter:
case Job.Mage:
case Job.Trickster:
case Job.Crusader:
//create character here
try
{
WorldCharacter wchar = client.CreateCharacter(name, slot, hair, color, style, job, Convert.ToBoolean(isMaleByte));
SendCharOKResponse(client, wchar);
}
catch (Exception ex)
{
Log.WriteLine(LogLevel.Exception, "Error creating character for {0}: {1}", client.Username, ex.InnerException.ToString());
SendCharCreationError(client, CreateCharError.FailedToCreate);
return;
}
break;
default:
SendCharCreationError(client, CreateCharError.WrongClass);
Log.WriteLine(LogLevel.Warn, "Invalid job ID at char creation from {0}", client.Username);
break;
}
}
public static void CharacterSelectHandler(WorldClient client, Packet packet)
{
byte slot;
if (!packet.TryReadByte(out slot) || slot > 10 || !client.Characters.ContainsKey(slot))
{
Log.WriteLine(LogLevel.Warn, "{0} selected an invalid character.", client.Username);
return;
}
WorldCharacter character;
if (client.Characters.TryGetValue(slot, out character))
{
//generate transfer
ZoneConnection zone = Program.GetZoneByMap(character.Character.PositionInfo.Map);
if (zone != null)
{
client.Characters.Clear(); //we clear the other ones from memory
client.Character = character; //only keep the one selecte
//Database.Storage.Characters.AddChars(character.Character);
zone.SendTransferClientFromZone(client.AccountID, client.Username, client.Character.Character.Name,client.Character.ID, client.RandomID, client.Admin, client.Host);
ClientManager.Instance.AddClientByName(client); //so we can look them up fast using charname later.
SendZoneServerIP(client, zone);
}
else
{
Log.WriteLine(LogLevel.Warn, "Character tried to join unloaded map: {0}", character.Character.PositionInfo.Map);
SendConnectError(client, ConnectErrors.MapUnderMaintenance);
}
}
}
public static void HandleSetStatPoint(ZoneClient client, Packet packet)
{
byte stat;
if (!packet.TryReadByte(out stat))
{
Log.WriteLine(LogLevel.Warn, "Couldn't read HandleSetStatPoint packet. {0}", client);
return;
}
if (client.Character.Character.UsablePoints == 0)
{
Log.WriteLine(LogLevel.Warn, "User tried to set stat point while not having any left. {0}", client);
}
else
{
// LETS DO ET
switch (stat)
{
case 0: client.Character.Str++; break;
case 1: client.Character.Dex++; break;
case 2: client.Character.End++; break;
case 3: client.Character.Int++; break;
case 4: client.Character.Spr++; break;
default:
{
Log.WriteLine(LogLevel.Warn, "User tried to set stat point on unknown stat {0} {1}", stat, client);
return;
}
}
client.Character.Character.UsablePoints--;
//Program.Entity.SaveChanges();
SendSetUsablePoint(client, stat);
}
}
public static void ChangeDropMode(WorldClient client, Packet packet)
{
byte dropState;
if (packet.TryReadByte(out dropState)) {
client.Character.Group.ChangeDropType(client.Character, dropState);
}
}
public static void sendPartyMessage(WorldClient client, Packet packet)
{
string mess;
byte len;
if (!packet.TryReadByte(out len) || !packet.TryReadString(out mess, len))
{
Log.WriteLine(LogLevel.Error, "PartyChat :: Can not parse party chat from {0}", client.Character.Character.Name);
return;
}
if(Program.Entity.Parties.Where(c => c.CharNo == client.Character.Character.ID).Count() == 1)
{
Party getPartyInfo = Program.Entity.Parties.First(c => c.CharNo == client.Character.Character.ID);
foreach (Party party in Program.Entity.Parties.Where(c => c.PartyNo == getPartyInfo.PartyNo))
{
Character character = Program.Entity.Characters.First(c => c.ID == party.CharNo);
WorldClient wclient = ClientManager.Instance.GetClientByCharname(character.Name);
using (var ppacket = new Packet(SH8Type.PartyChat))
{
ppacket.WriteString(client.Character.Character.Name, 16);
ppacket.WriteByte(len);
ppacket.WriteString(mess, len);
wclient.SendPacket(ppacket);
}
}
}
else
{
using (var ppacket = new Packet(SH8Type.PartyChatErr))
{
ppacket.WriteUShort(1985);
client.SendPacket(ppacket);
}
}
}
public static void TradeRemovitem(ZoneClient pClient, Packet pPacket)
{
byte pSlot;
if (!pPacket.TryReadByte(out pSlot))
return;
if (pClient.Character.Trade == null)
return;
pClient.Character.Trade.RemoveItemToHandel(pClient.Character, pSlot);
}
public static void MasterRequestCoper(ZoneClient client, Packet pPacket)
{
byte unk;
if (!pPacket.TryReadByte(out unk))
return;
using (var packet = new Packet(SH37Type.SendRecivveCopper))
{
packet.WriteUShort(7264);//unk
packet.WriteLong(client.Character.Character.ReviveCoper);
client.SendPacket(packet);
}
}
public static void PartyChat(WorldClient client, Packet packet)
{
if (client.Character.Group == null)
return;
byte msgLen;
string msg = string.Empty;
if (!packet.TryReadByte(out msgLen) || !packet.TryReadString(out msg, msgLen))
return;
client.Character.Group.Chat(client, msg);
}
public static void ChangeCharNameHandler(WorldClient client, Packet packet)
{
byte Character_slot;
string charname;
if (!packet.TryReadByte(out Character_slot) || !packet.TryReadString(out charname, 16))
return;
using (var pack = new Packet(SH5Type.SendCharacterChangeNewName))
{
pack.WriteByte(Character_slot);
pack.WriteString(charname,16);
pack.WriteUShort(208);//Responsecode?
}
//Todo ChangeinDatabase
}
public static void Wisper(WorldClient client, Packet packet)
{
string toname;
byte messagelenght;
if (packet.TryReadString(out toname, 16) && packet.TryReadByte(out messagelenght))
{
string message;
if (!packet.TryReadString(out message, messagelenght))
{
return;
}
WorldClient toChar = ClientManager.Instance.GetClientByCharname(toname);
if (toChar != null)
{
using (var frompacket = new Packet(SH8Type.WisperFrom))
{
frompacket.WriteString(client.Character.Character.Name, 16);
if (!toChar.Character.BlocketUser.Contains(client.Character.Character.Name))
{
frompacket.WriteByte(0);
}
else
{
frompacket.WriteByte(12);//blocket notdisplay message
}
frompacket.WriteByte(messagelenght);
frompacket.WriteString(message, messagelenght);
toChar.SendPacket(frompacket);
}
using (var pack = new Packet(SH8Type.WisperTo))
{
pack.WriteString(toname, 16);
pack.WriteByte(messagelenght);
pack.WriteString(message, messagelenght);
client.SendPacket(pack);
}
}
else
{
//target not found
using (var pp = new Packet(SH8Type.WisperTargetNotfound))
{
pp.WriteUShort(3945);//unk
pp.WriteString(toname, 16);
client.SendPacket(pp);
}
}
}
}
public static void questionHandler(ZoneClient client, Packet packet)
{
byte answer;
if (!packet.TryReadByte(out answer))
{
Log.WriteLine(LogLevel.Warn, "Received invalid question response.");
return;
}
ZoneCharacter character = client.Character;
if (character.Question == null)
return;
else if (character.Question.Answers.Count <= answer)
return;
character.Question.Function(character, answer);
character.Question = null;
}
public static void ClientEquippedItem(ZoneClient pClient, Packet pPacket)
{
byte fromSlot;
if (!pPacket.TryReadByte(out fromSlot))
{
Log.WriteLine(LogLevel.Warn, "Could not read equip slot.");
return;
}
Item fromItem;
if (!pClient.Character.Inventory.InventoryItems.TryGetValue(fromSlot, out fromItem))
{
Log.WriteLine(LogLevel.Warn, "Equipping empty inventory slot.");
return;
}
if (fromItem == null)
{
Log.WriteLine(LogLevel.Warn, "Client tries to equip an ITEM, not EQUIP!");
return;
}
byte toSlot = (byte)fromItem.Slot;
Item toEquip = pClient.Character.Inventory.EquippedItems.Find(e => e.ItemInfo.Slot == fromItem.ItemInfo.Slot);
// TODO: Check, does user equip item to correct slot. Right now client only does it.
ZoneClient client = pClient;
if (fromItem.ItemInfo.Level > pClient.Character.Level)
{
FailedEquip(client.Character, 645); // 85 02
}
else
{
if (toEquip == null)
{
pClient.Character.EquipItem(fromItem);
}
else
{
pClient.Character.SwapEquips(toEquip, fromItem);
}
}
}
public static void DeleteCharacterHandler(WorldClient client, Packet packet)
{
byte slot;
if (!packet.TryReadByte(out slot) || slot > 10 || !client.Characters.ContainsKey(slot))
{
Log.WriteLine(LogLevel.Warn, "{0} tried to delete character out of range.", client.Username);
return;
}
WorldCharacter todelete = client.Characters[slot];
if (todelete.Delete())
{
client.Characters.Remove(slot);
SendCharDeleteOKResponse(client, slot);
}
else
{
Handler3.SendError(client, ServerError.DATABASE_ERROR);
}
}
public static void getWhisperMessage(WorldClient client, Packet packet)
{
string toChar;
byte len;
string mess;
if (!packet.TryReadString(out toChar, 16) || !packet.TryReadByte(out len) || !packet.TryReadString(out mess, len))
{
Log.WriteLine(LogLevel.Error, "WhisperChat :: Can not parse Whisper request from {0}", client.Character.Character.Name);
return;
}
WorldClient wclient = ClientManager.Instance.GetClientByCharname(toChar);
if (wclient != null)
{
using (var ppacket = new Packet(SH8Type.WhisperTo))
{
ppacket.WriteString(toChar, 16);
ppacket.WriteByte(len);
ppacket.WriteString(mess, len);
client.SendPacket(ppacket);
}
using (var ppacket = new Packet(SH8Type.WhisperFrom))
{
ppacket.WriteString(client.Character.Character.Name, 16);
ppacket.WriteByte(0); // unk
ppacket.WriteByte(len);
ppacket.WriteString(mess, len);
wclient.SendPacket(ppacket);
}
}
else
{
using (var ppacket = new Packet(SH8Type.WhisperErrAnswer))
{
ppacket.WriteUShort(3945);
ppacket.WriteString(toChar, 16);
client.SendPacket(ppacket);
}
}
}
public static void MasterRequestResponse(WorldClient client, Packet packet)
{
string requester = string.Empty;
string target = string.Empty;
byte response;
if (!packet.TryReadString(out requester, 16))
return;
if (!packet.TryReadString(out target, 16))
return;
if (!packet.TryReadByte(out response))
return;
if (response == 0)
{
MasterManager.Instance.RemoveMasterRequest(client);
}
else if(response == 1)
{
MasterManager.Instance.MasterRequestAccept(requester, target);
}
}
public static void NormalChatHandler(ZoneClient client, Packet packet)
{
byte len;
string text;
if (!packet.TryReadByte(out len) || !packet.TryReadString(out text, len))
{
Log.WriteLine(LogLevel.Warn, "Could not parse normal chat from {0}.", client.Character.Name);
return;
}
if (client.Admin > 0 && (text.StartsWith("&") || text.StartsWith("/")))
{
CommandLog.Instance.LogCommand(client.Character.Name, text);
CommandStatus status = CommandHandler.Instance.ExecuteCommand(client.Character, text.Split(' '));
switch (status)
{
case CommandStatus.ERROR:
client.Character.DropMessage("Error executing command.");
break;
case CommandStatus.GM_LEVEL_TOO_LOW:
client.Character.DropMessage("You do not have the privileges for this command.");
break;
case CommandStatus.NOT_FOUND:
client.Character.DropMessage("Command not found.");
break;
}
}
else
{
int chatblock = client.Character.ChatCheck();
if (chatblock == -1)
{
ChatLog.Instance.LogChat(client.Character.Name, text, false);
SendNormalChat(client.Character, text, client.Admin > 0 ? (byte)0x03 : (byte)0x2a);
}
else
{
Handler2.SendChatBlock(client.Character, chatblock);
}
}
}
public static void UseTeleporter(ZoneClient client, Packet packet)
{
byte anwser;
if (packet.TryReadByte(out anwser))
{
using (Packet Packet = new Packet(SH6Type.TelePorter))
{
Packet.WriteShort(6593);//code for normal teleport
client.SendPacket(Packet);
}
switch (anwser)
{
case 0:
client.Character.ChangeMap(0, 4199, 4769);//Roumen
break;
case 1:
client.Character.ChangeMap(9, 11802, 10466);//Eldrine
break;
case 2:
client.Character.ChangeMap(75, 9069, 9312);//EldGbl02
break;
case 3:
client.Character.ChangeMap(5,13658,7812);//RouVal01
break;
default:
Log.WriteLine(LogLevel.Warn,"Unkown Teleport Answer {1}",anwser);
break;
}
}
}
public static void UseHandler(ZoneClient client, Packet packet)
{
byte slot;
if (!packet.TryReadByte(out slot))
{
Log.WriteLine(LogLevel.Warn, "Error reading used item slot.");
return;
}
client.Character.UseItem(slot);
}
public static void ShoutHandler(ZoneClient client, Packet packet)
{
ZoneCharacter character = client.Character;
byte len;
string message;
if (!packet.TryReadByte(out len) ||
!packet.TryReadString(out message, len))
{
Log.WriteLine(LogLevel.Warn, "Could not read shout from {0}.", character.Name);
return;
}
int shoutcheck = character.ShoutCheck();
if (shoutcheck > 0)
{
Handler2.SendChatBlock(character, shoutcheck);
}
else
{
ChatLog.Instance.LogChat(client.Character.Name, message, true);
using (var broad = Shout(character.Name, message))
{
character.Map.Broadcast(broad);
}
}
}
public static void SellItem(ZoneClient client, Packet packet)
{
byte slot;
int sellcount;
ZoneCharacter character = client.Character;
if (packet.TryReadByte(out slot) && packet.TryReadInt(out sellcount))
{
Item item;
character.Inventory.InventoryItems.TryGetValue(slot, out item);
if (item != null)
{
long fullSellPrice = sellcount * item.ItemInfo.SellPrice;
if (item.Ammount > 1)
{
item.Ammount -= (ushort)sellcount;
byte Slot = (byte)item.Slot;
Handler12.ModifyInventorySlot(character, 0x24, Slot, Slot, item);
character.Inventory.Money += fullSellPrice;
character.ChangeMoney(character.Inventory.Money);
}
else
{
character.Inventory.Money += fullSellPrice;
character.ChangeMoney(character.Inventory.Money);
character.Inventory.InventoryItems.Remove(slot);
ResetInventorySlot(character, slot);
}
System.Console.WriteLine(item.ItemInfo.Type);
}
}
}
public static void EmoteHandler(ZoneClient client, Packet packet)
{
ZoneCharacter character = client.Character;
byte action;
if (!packet.TryReadByte(out action))
{
Log.WriteLine(LogLevel.Warn, "{0} did empty emote.", character.Name);
return;
}
if (action > 74)
{
character.CheatTracker.AddCheat(CheatTypes.EMOTE, 500);
return;
}
using (var broad = Animation(character, action))
{
character.Broadcast(broad, true);
}
}
public static void GetPremiumItemList(ZoneClient pClient, Packet pPacket)
{
byte PageID;
if (!pPacket.TryReadByte(out PageID))
return;
pClient.Character.WritePremiumList(PageID);
}
public static void MoveItemHandler(ZoneClient pClient, Packet pPacket)
{
byte oldslot, oldstate, newslot, newstate;
if (!pPacket.TryReadByte(out oldslot) ||
!pPacket.TryReadByte(out oldstate) ||
!pPacket.TryReadByte(out newslot) ||
!pPacket.TryReadByte(out newstate))
{
Log.WriteLine(LogLevel.Warn, "Could not read item move.");
return;
}
if (oldslot == newslot)
{
Log.WriteLine(LogLevel.Warn, "Client tried to dupe an item.");
return;
}
Item source;
if (!pClient.Character.Inventory.InventoryItems.TryGetValue(oldslot, out source) && newstate != 0x00 && oldstate != 0x00 || newstate == 0x00)
{
if (pClient.Character.Guild != null)
{
if(newstate == 0x00 && oldstate == 0x24)
{
source.Flags = Data.ItemFlags.GuildItem;
}
else if(newstate == 0x24 && oldstate == 0x00)
{
source.Flags = Data.ItemFlags.Normal;
}
else if (source == null || newstate != 0x24)
{
if (!pClient.Character.Guild.GuildStore.GuildStorageItems.TryGetValue(oldslot, out source))
{
return;
}
}
}
if (source == null)
{
Log.WriteLine(LogLevel.Warn, "Client tried to move empty slot.");
return;
}
}
if (newslot == 0xff || newstate == 0xff)
{
pClient.Character.Inventory.InventoryItems.Remove(oldslot);
source.Delete(); //TODO: make a drop
Handler12.ModifyInventorySlot(pClient.Character, oldslot, oldstate, (byte)source.Slot, null);
}
else if(newstate == 0x00 && oldstate == 0x24 && pClient.Character.Guild != null)
{
if (!pClient.Character.Guild.GuildStore.GetHasFreeGuildStoreSlot())
//todo GuildStorefuell
return;
pClient.Character.Inventory.RemoveInventory(source);
pClient.Character.Guild.GuildStore.GuildStorageItems.Add(newslot, source);
pClient.Character.Guild.GuildStore.SendAddGuildStore(Data.GuildStoreAddFlags.Item, pClient.Character.Character.Name, source.Ammount, 0, source.ItemInfo.ItemID);
pClient.Character.Guild.GuildStore.SaveStoreItem(pClient.Character.Guild.ID, source.ItemInfo.ItemID, newslot);
Handler12.ModifyInventorySlot(pClient.Character, oldstate, newstate, oldslot, null);
Handler12.ModifyInventorySlot(pClient.Character, oldstate, newstate, oldslot, newslot, source);
return;
}
else if(oldstate == 0x00 && newstate == 0x24 && pClient.Character.Guild != null)
{
if (!pClient.Character.Guild.GuildStore.GuildStorageItems.TryGetValue(oldslot, out source))
return;
source.Slot = (sbyte)newslot;
pClient.Character.Guild.GuildStore.GuildStorageItems.Remove(oldslot);
pClient.Character.Inventory.AddToInventory(source);
pClient.Character.Guild.GuildStore.SendRemoveFromGuildStore (Data.GuildStoreAddFlags.Item, pClient.Character.Character.Name, source.Ammount, 0, source.ItemInfo.ItemID);
pClient.Character.Guild.GuildStore.RemoveStoreItem(pClient.Character.Guild.ID, source.ItemInfo.ItemID);
Handler12.ModifyInventorySlot(pClient.Character, newstate,oldstate, newslot, oldslot, null);
Handler12.ModifyInventorySlot(pClient.Character, newstate, newstate, newstate, newslot, source);
return;
}
if (source.Flags == Data.ItemFlags.Normal)
{
Item destination;
if (pClient.Character.Inventory.InventoryItems.TryGetValue(newslot, out destination))
{
//item swap
pClient.Character.Inventory.InventoryItems.Remove(oldslot);
pClient.Character.Inventory.InventoryItems.Remove(newslot);
source.Slot = (sbyte)newslot;
destination.Slot = (sbyte)oldslot;
pClient.Character.Inventory.InventoryItems.Add(newslot, source);
pClient.Character.Inventory.InventoryItems.Add(oldslot, destination);
source.Save();
destination.Save();
Handler12.ModifyInventorySlot(pClient.Character, newslot, 0x24, oldslot, destination);
Handler12.ModifyInventorySlot(pClient.Character, oldslot, 0x24, newslot, source);
}
else
{
//item moved to empty slot
pClient.Character.Inventory.InventoryItems.Remove(oldslot);
pClient.Character.Inventory.InventoryItems.Add(newslot, source);
source.Slot = (sbyte)newslot;
source.Save();
Handler12.ModifyInventorySlot(pClient.Character, newslot, 0x24, oldslot, null);
Handler12.ModifyInventorySlot(pClient.Character, oldslot, 0x24, newslot, source);
}
}
else if (source.Flags == Data.ItemFlags.GuildItem)
{
Item destination;
if (pClient.Character.Guild.GuildStore.GuildStorageItems.TryGetValue(newslot, out destination))
{
//item swap
pClient.Character.Guild.GuildStore.GuildStorageItems.Remove(oldslot);
pClient.Character.Guild.GuildStore.GuildStorageItems.Remove(newslot);
source.Slot = (sbyte)newslot;
destination.Slot = (sbyte)oldslot;
pClient.Character.Guild.GuildStore.GuildStorageItems.Add(newslot, source);
pClient.Character.Guild.GuildStore.GuildStorageItems.Add(oldslot, destination);
Handler12.ModifyInventorySlot(pClient.Character, oldstate, newstate, newslot, oldslot, destination);
Handler12.ModifyInventorySlot(pClient.Character, oldstate, oldstate, newstate, newslot, source);
}
else
{
//item moved to empty slot
pClient.Character.Guild.GuildStore.GuildStorageItems.Remove(oldslot);
pClient.Character.Guild.GuildStore.GuildStorageItems.Add(newslot, source);
source.Slot = (sbyte)newslot;
Handler12.ModifyInventorySlot(pClient.Character, oldstate, newstate, newslot, oldslot,null);
Handler12.ModifyInventorySlot(pClient.Character, newstate, oldstate, newstate, newslot, source);
}
}
}
public static void EnhancementHandler(ZoneClient client, Packet packet)
{
byte weapslot, stoneslot;
if (!packet.TryReadByte(out weapslot) ||
!packet.TryReadByte(out stoneslot))
{
Log.WriteLine(LogLevel.Warn, "Invalid item enhance request.");
return;
}
client.Character.UpgradeItem(weapslot, stoneslot);
}
public static void DropItemHandler(ZoneClient client, Packet packet)
{
byte slot;
if (!packet.TryReadByte(out slot))
{
Log.WriteLine(LogLevel.Warn, "Invalid drop request.");
return;
}
client.Character.DropItemRequest(slot);
}
public static void ClientUnequippedItem(ZoneClient pClient, Packet pPacket)
{
byte sourceSlot, destinationSlot;
if (!pPacket.TryReadByte(out sourceSlot) ||
!pPacket.TryReadByte(out destinationSlot))
{
Log.WriteLine(LogLevel.Warn, "Could not read unequip values.");
return;
}
Item sourceEquip = pClient.Character.Inventory.EquippedItems.Find(e => (byte)e.ItemInfo.Slot == sourceSlot);
//Item destinationItem = pClient.Character.Inventory.EquippedItems.Find(i => i.Slot == destinationSlot);// Item was searched from wrong place
Item destinationItem;
pClient.Character.Inventory.InventoryItems.TryGetValue(destinationSlot, out destinationItem); // check if something there
if (destinationItem != null && (destinationItem.ItemInfo.Slot == ItemSlot.None))
{
Log.WriteLine(LogLevel.Warn, "Equipping an item, not possible.");
// Failed to unequip message here, no need to log it
return;
}
// TODO: If source and destination types are different return.
// Except rings and costumes (But that can be done later).
/*
if( sourceEquip.Type != destinationItem.Type ) {
Log.WriteLine(LogLevel.Warn, "SourceType != DestinationType, just debugging message, not important");
// Failed to unequip message here, no need to log it
return;
}
*/
if (destinationItem != null)
{
Item destinationEquip = (Item)destinationItem;
pClient.Character.SwapEquips(sourceEquip, destinationEquip);
}
else
{
if (sourceEquip == null)
{
Handler12.UpdateEquipSlot(pClient.Character, destinationSlot, 0x24, 0, null);
return;
}
pClient.Character.UnequipItem(sourceEquip, destinationSlot);
}
}
public static void WorldSelectHandler(LoginClient pClient, Packet pPacket)
{
if (!pClient.IsAuthenticated || pClient.IsTransferring)
{
Log.WriteLine(LogLevel.Warn, "Invalid world select request.");
SendFailedLogin(pClient, ServerError.EXCEPTION);
return;
}
byte id;
if (!pPacket.TryReadByte(out id))
{
Log.WriteLine(LogLevel.Warn, "Invalid world select.");
return;
}
WorldConnection world;
if (WorldManager.Instance.Worlds.TryGetValue(id, out world))
{
switch (world.Status)
{
case WorldStatus.MAINTENANCE:
Log.WriteLine(LogLevel.Warn, "{0} tried to join world in maintentance.", pClient.Username);
SendFailedLogin(pClient, ServerError.SERVER_MAINTENANCE);
return;
case WorldStatus.OFFLINE:
Log.WriteLine(LogLevel.Warn, "{0} tried to join offline world.", pClient.Username);
SendFailedLogin(pClient, ServerError.SERVER_MAINTENANCE);
return;
default: Log.WriteLine(LogLevel.Debug, "{0} joins world {1}", pClient.Username, world.Name); break;
}
string hash = System.Guid.NewGuid().ToString().Replace("-", "");
world.SendTransferClientFromWorld(pClient.AccountID, pClient.Username, pClient.Admin, pClient.Host, hash);
Log.WriteLine(LogLevel.Debug, "Transferring login client {0}.", pClient.Username);
pClient.IsTransferring = true;
SendWorldServerIP(pClient, world, hash);
}
else
{
Log.WriteLine(LogLevel.Warn, "{0} selected invalid world {1}.", pClient.Username, id);
return;
}
}
public static void MoveItemHandler(ZoneClient client, Packet packet)
{
byte from, oldstate, to, newstate;
if(!packet.TryReadByte(out from) ||
!packet.TryReadByte(out oldstate) ||
!packet.TryReadByte(out to) ||
!packet.TryReadByte(out newstate))
{
Log.WriteLine(LogLevel.Warn, "Invalid item move received.");
return;
}
client.Character.MoveItem((sbyte)from, (sbyte)to);
}
public static void UnequipHandler(ZoneClient client, Packet packet)
{
ZoneCharacter character = client.Character;
byte sourceSlot;
sbyte destinationSlot; //not so sure about this one anymore
if (!packet.TryReadByte(out sourceSlot) ||
!packet.TryReadSByte(out destinationSlot))
{
Log.WriteLine(LogLevel.Warn, "Could not read unequip values from {0}.", character.Name);
return;
}
character.UnequipItem((ItemSlot)sourceSlot, destinationSlot);
}
public static void On_GameClient_AcademyChat(WorldClient Client, Packet Packet)
{
byte len;
string msg;
if (!Packet.TryReadByte(out len)
|| !Packet.TryReadString(out msg, len))
{
return;
}
if (Client.Character.IsInGuildAcademy
|| Client.Character.IsInGuild)
{
if (Client.Character.IsInGuildAcademy
&& Client.Character.GuildAcademyMember.IsChatBlocked)
{
using (var packet = new Packet(SH38Type.AcademyChatBlocked))
{
packet.WriteUShort(6140);
Client.SendPacket(packet);
}
return;
}
using (var packet = new Packet(SH38Type.AcademyChat))
{
packet.WriteInt(Client.Character.Guild.ID);
packet.WriteString(Client.Character.Character.Name, 16);
packet.WriteByte(len);
packet.WriteString(msg, len);
Client.Character.Guild.Broadcast(packet);
Client.Character.GuildAcademy.Broadcast(packet);
}
}
}