void RenameParty()
{
try
{
//Create new packet reader
PacketReader reader = new PacketReader(PacketInformation.buffer);
//First integer is party id
int partyid = reader.Int32();
//Second integer is not needed
int NotNeeded = reader.Int32();
//Byte party type
byte ptype = reader.Byte();
//Byte party purpose
byte purpose = reader.Byte();
//Byte minimum level
byte minlevel = reader.Byte();
//Byte max level to enter party
byte maxlevel = reader.Byte();
//Party name lenght
short namel = reader.Int16();
//Party name each character is a word value using text3
string pname = reader.Text3();
//Create new packet writer
PacketWriter Writer = new PacketWriter();
//Add opcode to server packet
Writer.Create(Systems.SERVER_PARTY_CHANGENAME);
//Write static byte 1
Writer.Byte(1);
//Write party id
Writer.DWord(partyid);
//Write dword 0
Writer.DWord(0);
//Write party type
Writer.Byte(ptype);
//Write party purpose
Writer.Byte(purpose);
//Write party minimum level
Writer.Byte(minlevel);
//Write party max level
Writer.Byte(maxlevel);
//Write party name
Writer.Text3(pname);
//Send bytes to client
client.Send(Writer.GetBytes());
}
//If a error happens
catch (Exception ex)
{
//Write the exception to the log
Systems.Debugger.Write(ex);
}
}
void Handle()
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
byte iSlot = Reader.Byte();
Global.slotItem uItemID = GetItem((uint)Character.Information.CharacterID, iSlot, 0);
if (uItemID.ID == 0 || Character.State.Die) return;
switch (uItemID.ID)
{
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Stall decoration
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case 3847:
case 3848:
case 3849:
case 3850:
case 35482:
case 35483:
case 35484:
StallDeco(uItemID.ID, iSlot);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Monster Masks
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case 10364:
if (Character.Transformed) return;
//Load Mask
MonsterMasks(uItemID.ID, iSlot);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Forgotten world entrance
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case 33235:
ForgottenWorld(uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Repair items
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case 3784:
case 24432:
case 35249:
if (!Character.Action.repair)
{
Character.Action.repair = true;
RepairTimer(30000);
//Check if there are any items that need repair
double durability = Data.ItemBase[uItemID.ID].Defans.Durability;
double currentdurability = Data.ItemBase[uItemID.dbID].Defans.Durability;
if (currentdurability < durability)
{
int countrepairs = MsSQL.GetRowsCount("SELECT * FROM char_items WHERE owner='" + Character.Information.CharacterID + "'");
if (countrepairs == 0)
{
//Do nothing client sends message automaticly
}
else
{
//Start repairing call handle
HandleRepair(iSlot, uItemID.dbID);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
}
}
}
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Thief Return Scrolls
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case 2128:
if (Character.Information.Scroll) return;
HandleThiefScroll(uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Inventory Expansion
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case 24456:
HandleInventoryExp(uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Monster Summon Scrolls
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case 3935:
case 3936:
case 3937:
case 10133:
case 10145:
case 30925:
HandleSummon(Character.Information.Level);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Reverse return scrolls
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case 3795:
case 24467:
if (Character.Information.Scroll) return;
HandleReverse(Reader.Int16(),Reader.Byte(), Reader.Int32());
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Premium Tickets
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case 7490:
case 24505:
HandlePremiumType(uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Normal Return Scrolls
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case 61:
case 2198:
case 2199:
case 3769:
case 19599:
case 24684:
if (Character.Information.Scroll) return;
if (Timer.Movement != null)
{
Timer.Movement.Dispose();
Character.Position.Walking = false;
}
HandleReturnScroll(uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// HP Potions
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case 4:
case 5:
case 6:
case 7:
case 8:
case 3817:
case 3818:
case 3819:
case 5912:
case 3765:
byte type = 1;
HandlePotion(type, uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// MP Potions
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case 11:
case 12:
case 13:
case 14:
case 15:
case 3820:
case 3821:
case 3822:
case 5913:
type = 2;
HandlePotion(type, uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
break;
case 9:
type = 3;
HandlePotion(type, uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
break;
case 16:
type = 4;
HandlePotion(type, uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Vigor Potions
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case 18:
case 19:
case 20:
case 21:
case 22:
case 23:
case 3739:
case 4013:
case 5881:
case 5944:
case 23316:
type = 5;
HandlePotion(type, uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Special Transport
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case 19601:
case 22770:
if (!Character.Stall.Stallactive && !Character.Transport.Right && Character.Action.MonsterID.Count == 0 && !Character.State.Sitting && !Character.Information.Scroll)
{
bool r = HandleSpecialTrans(uItemID.ID);
if (!r)
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
}
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Normal transports
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case 2137:
case 2138:
case 2139:
case 3909:
case 23330:
case 22953:
case 23396:
case 23395:
case 22952:
if (!Character.Stall.Stallactive && !Character.Transport.Right && Character.Action.MonsterID.Count == 0 && !Character.State.Sitting && !Character.Information.Scroll)
{
if (this.Character.Information.Level >= Data.ItemBase[uItemID.ID].Level)
{
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
HandleHorseScroll(uItemID.ID);
}
else
{
//client.Send();// needs error
}
}
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Global Chatting
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case 3851:
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
string text = " " + Reader.Text3();
Reader.Close();
SendAll(Packet.ChatPacket(6, 0, text, Character.Information.Name));
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Buff Items
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case 7100:
SpecialBuff(3977);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
break;
case 7098:
SpecialBuff(3975);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
break;
case 23311:
if (Character.Information.Berserking) return;
int style = 1;
HandleRegenZerk(style, uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
break;
case 23938:
if (Character.Information.Berserking) return;
style = 2;
HandleRegenZerk(style, uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Grab Pets
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case 23313:
case 35578:
case 35583:
if (!Character.Grabpet.Active && Character.Action.MonsterID.Count == 0)
{
bool r = HandleGrabPet(iSlot, uItemID.ID);
if (!r)
HandleUpdateSlotn(iSlot, uItemID, Reader.UInt16());
}
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Attack Pets
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
case 22778:
if (!Character.Grabpet.Active && Character.Action.MonsterID.Count == 0)
{
bool r = HandleAttackPet(iSlot, uItemID.ID);
if (!r)
HandleUpdateSlotn(iSlot, uItemID, Reader.UInt16());
}
break;
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Gender Switch Tools
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case 24479:
//HandleGenderSwitch(iSlot, uItemID.ID);
//HandleUpdateSlotn(iSlot, uItemID, Reader.UInt16());
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Balloons
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case 24342:
//HandleBalloon(iSlot, 31157);
SpecialBuff(31182);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
break;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Default , Check item ID
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
default:
//Console.WriteLine("{0} Tried to use item {1} , The cast type: {2}", Character.Information.Name, Data.ItemBase[uItemID.ID].Name, uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
break;
}
Reader.Close();
}
void Chat()
{
/*
* We use for each now, to make sure there wont be any issues
* Incase the list we send the packet to can have none connected clients.
* To prevent bugging of chat we repeat and check each client before sending.
*/
try
{
//Set our list of ranged players
List<int> Rangedplayers = Character.Spawn;
//Create new packet reader for reading packet data
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Chat type byte (for our switch case).
byte chatType = Reader.Byte();
//Byte chat index
byte chatIndex = Reader.Byte();
//Link count byte
byte linkCount = Reader.Byte();
//Create switch to switch on type of chat (normal party etc).
switch (chatType)
{
//--------------------------------- [Normal chat] ---------------------------------//
case 1:
//Read written text from packet data
string Text = Reader.Text3();
//Close packet reader
Reader.Close();
// .additem 111 12
if (Character.Information.GM == 1 && Text[0] == '.')
{
gmCommands(Text);
}
//Repeat for each in range player
foreach (int member in Rangedplayers)
{
//Make sure the member is not null
if (member != 0)
{
//Make sure its not sending to our client
if (member != Character.Information.UniqueID)
{
//Get member detail
Systems memberinfo = GetPlayer(member);
//Send packet to the in range player
memberinfo.client.Send(Packet.ChatPacket(chatType, Character.Information.UniqueID, Text, null));
}
}
}
//Send chatindex packet to ourselfs
client.Send(Packet.ChatIndexPacket(chatType, chatIndex));
break;
//--------------------------------- [Normal chat pink] ---------------------------------//
case 3:
//Check if our character has gm rights or not
if (Character.Information.GM == 1)
{
//Read packet information (text typed).
Text = Reader.Text3();
//Close packet reader
Reader.Close();
//Repeat for each player in our range list
foreach (int member in Rangedplayers)
{
//Check if the member is not null
if (member != 0)
{
//Make sure its not sending to our own client
if (member != Character.Information.UniqueID)
{
//Get member detail
Systems memberinfo = GetPlayer(member);
//Send packet to the member
memberinfo.client.Send(Packet.ChatPacket(chatType, Character.Information.UniqueID, Text, null));
}
}
}
//Send chat index to our client
client.Send(Packet.ChatIndexPacket(chatType, chatIndex));
break;
}
//If character tried to use pink chat but isnt a gm
else
{
//We ban the player for hacking attempt.
Disconnect("ban");
}
break;
//--------------------------------- [Private chat] ---------------------------------//
case 2:
//Read from packet data who we are sending the message to
string Target = Reader.Text();
//Get information from the given player we send to
Systems Targetplayer = GetPlayerName(Target);
//Make sure the player sending to is not null
if (Targetplayer != null)
{
//Make sure the player is ingame (Not teleporting or such).
if (Targetplayer.Character.InGame)
{
//Read the message from the packet data
Text = Reader.Text3();
//Close the packet reader
Reader.Close();
//Send packet to our target
Targetplayer.client.Send(Packet.ChatPacket(chatType, 0, Text, this.Character.Information.Name));
//Send chatindex packet to ourselfs
client.Send(Packet.ChatIndexPacket(chatType, chatIndex));
}
}
break;
//--------------------------------- [Party chat] ---------------------------------//
case 4:
//Make sure the player is in a party
if (Character.Network.Party != null)
{
//Read the text the player has typed from packet data
Text = Reader.Text3();
//Close packet reader
Reader.Close();
//Repeat for each member in the party member list
foreach (int member in Character.Network.Party.Members)
{
//Make sure the member isnt null (0)
if (member != 0)
{
//Get detailed info for the player
Systems memberinfo = GetPlayer(member);
//Send packet information to the member for chat
memberinfo.client.Send(Packet.ChatPacket(chatType, Character.Information.UniqueID, Text, this.Character.Information.Name));
}
}
//Finally send chatindex packet to ourselfs
client.Send(Packet.ChatIndexPacket(chatType, chatIndex));
}
break;
//--------------------------------- [Guild chat] ---------------------------------//
case 5:
//Read message beeing send from packet data
Text = Reader.Text3();
//Close packet reader
Reader.Close();
//Repeat for each member in the guild member list
foreach (int member in Character.Network.Guild.Members)
{
//Make sure the member is not null (0)
if (member != 0)
{
//Get guild member detailed information
Systems Guildmember = GetPlayerMainid(member);
//Again check if the guild member is not null
if (Guildmember != null)
{
//Send chat packet to the member
Guildmember.client.Send(Packet.ChatPacket(chatType, Character.Information.UniqueID, Text, this.Character.Information.Name));
}
}
}
//Send chat index packet to our client
client.Send(Packet.ChatIndexPacket(chatType, chatIndex));
break;
//--------------------------------- [Global chat] ---------------------------------//
case 6:
//Get sender name from packet data
string Sender = Reader.Text();
//Get message from packet data
Text = Reader.Text3();
//Send to every client connected and logged in
SendAll(Packet.ChatPacket(chatType, Character.Information.UniqueID, " " + Text, Sender));
break;
//--------------------------------- [Notice chat] ---------------------------------//
case 7:
//Make sure the character sending is a gm
if (Character.Information.GM == 1)
{
//Get message from packet data
Text = Reader.Text3();
//Close packet reader
Reader.Close();
//Send to everyone ingame (using void sendnoticecon).
SendAll(sendnoticecon(chatType, Character.Information.UniqueID, Text, null));
}
//If the character is not a gm
else
{
//Disconnect and ban the player for hack attempt
Disconnect("ban");
}
break;
//--------------------------------- [Stall chat] ---------------------------------//
case 9:
//Read message from packet data
Text = Reader.Text3();
//Close packet reader
Reader.Close();
//Repeat for each member in the stall
foreach (int stallmember in Character.Network.Stall.Members)
{
//Make sure the stall member isnt null 0
if (stallmember != 0)
{
//Get stall member details
Systems member = GetPlayer(stallmember);
//Make sure the member isnt null
if (member != null)
{
//Send chat packet to the member
member.client.Send(Packet.ChatPacket(chatType, Character.Network.Stall.ownerID, Text, this.Character.Information.Name));
}
}
}
//Send chat index to ourselfs
client.Send(Packet.ChatIndexPacket(chatType, chatIndex));
break;
//--------------------------------- [Academy chat] ---------------------------------//
case 10:
//Todo academy system then chat.
break;
//--------------------------------- [Union chat] ---------------------------------//
case 11:
//Read message from packet data
Text = Reader.Text3();
//Close packet reader
Reader.Close();
//If the character has no union
if (!Character.Network.Guild.UnionActive)
//Return
return;
//Else for each member in the union
foreach (int member in Character.Network.Guild.UnionMembers)
{
//Make sure the union member is not null 0
if (member != 0)
{
//Get member detailed information
Systems tomember = GetPlayerMainid(member);
//Make sure the member is not null
if (tomember != null)
{
//Make sure the member isnt ourself
if(tomember.Character.Information.CharacterID != Character.Information.CharacterID)
{
//Send packet to the union member
tomember.client.Send(Packet.ChatPacket(chatType, Character.Information.UniqueID, Text, Character.Information.Name));
}
}
}
}
//Repeat for each member in the guild
foreach (int member in Character.Network.Guild.Members)
{
//Make sure the member isnt null 0
if (member != 0)
{
//Get member detailed information
Systems tomember = GetPlayerMainid(member);
//Make sure the member isnt null
if (tomember != null)
{
//Make sure the member isnt ourself
if (tomember.Character.Information.CharacterID != Character.Information.CharacterID)
{
//Send packet to the member
tomember.Character.Network.Guild.SingleSend = false;
}
}
}
}
//Finally send chat index packet to ourself
client.Send(Packet.ChatIndexPacket(chatType, chatIndex));
break;
}
}
//If an exception error happens
catch (Exception errorinformation)
{
//Write the information to the console
Console.WriteLine("Chat error {0}", errorinformation);
//Write the information to the log system
Systems.Debugger.Write(errorinformation);
}
}
void CreateFormedParty()
{
try
{
//Get packet data
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//First and second dword are static
Reader.Int32();
Reader.Int32();
//First byte is our party type
byte PartyType = Reader.Byte();
//Second byte is purpose information
byte PartyPurpose = Reader.Byte();
//3rd byte is minimal level required to join
byte PartyMinLevelReq = Reader.Byte();
//4th byte is max level to join
byte PartyMaxLevelReq = Reader.Byte();
//5th is short, party name lenght
//6th is party name
string PartyName = Reader.Text3();
//Close our reader
Reader.Close();
//Make sure the user isnt in a party yet.
if (Character.Network.Party != null)
{
//If party is formed allready return
if (Character.Network.Party.IsFormed)
{
return;
}
//If party is not formed
else
{
//Get current party information
party CurrentParty = Character.Network.Party;
//Set formed state
CurrentParty.IsFormed = true;
//Party type
CurrentParty.Type = PartyType;
//Party purpose
CurrentParty.ptpurpose = PartyPurpose;
//Party minimal level
CurrentParty.minlevel = PartyMinLevelReq;
//Party maximum level
CurrentParty.maxlevel = PartyMaxLevelReq;
//Party name
CurrentParty.partyname = PartyName;
//Party owner
CurrentParty.LeaderID = Character.Information.UniqueID;
//Add party eu / ch information by model
CurrentParty.Race = Character.Information.Model;
//Send packet information to user
client.Send(Packet.CreateFormedParty(CurrentParty));
//Add party to list
Party.Add(CurrentParty);
}
}
//If a new formed party is created from 0
else
{
//New party for details
party newparty = new party();
//Set formed state
newparty.IsFormed = true;
//Party type
newparty.Type = PartyType;
//Party purpose
newparty.ptpurpose = PartyPurpose;
//Party minimal level
newparty.minlevel = PartyMinLevelReq;
//Party maximum level
newparty.maxlevel = PartyMaxLevelReq;
//Party name
newparty.partyname = PartyName;
//Party owner
newparty.LeaderID = Character.Information.UniqueID;
//Add party eu / ch information by model
newparty.Race = Character.Information.Model;
//Add our player to the member list
newparty.Members.Add(Character.Information.UniqueID);
//Add player client to party list information
newparty.MembersClient.Add(client);
//Party id , is current count of party's + 1
newparty.ptid = Party.Count + 1;
//Add the new party list
Party.Add(newparty);
//Set party to player
Character.Network.Party = newparty;
//bool set player in party
Character.Network.Party.InParty = true;
//Send packet information to user
client.Send(Packet.CreateFormedParty(newparty));
}
}
//Catch bad exception errors
catch (Exception ex)
{
//Write information to the console
Console.WriteLine("Create formed party error {0}", ex);
//Write info to the debug log
Systems.Debugger.Write(ex);
}
}
void Handle()
{
try
{
//Read packet information
PacketReader Reader = new PacketReader(PacketInformation.buffer);
byte iSlot = Reader.Byte();
//Get global item information
Global.slotItem uItemID = GetItem((uint)Character.Information.CharacterID, iSlot, 0);
//Checks before continuing
if (uItemID.ID != 0 || !Character.State.Die)
{
//###########################################################################################
// Grabpets
//###########################################################################################
#region Pets (PET OBJECTS)
// Grabpets
#region Grabpets
if (Data.ItemBase[uItemID.ID].Pettype == Global.item_database.PetType.GRABPET)
{
//Check if we have pet active allready.
if (!Character.Grabpet.Active && Character.Action.MonsterID.Count == 0)
{
//If not active , add new pet object.
HandleGrabPet(iSlot, uItemID.ID);
//Need to change this to active effect on slot.
HandleUpdateSlotn(iSlot, uItemID, Reader.Int32());
}
}
#endregion
// Attackpets
#region Attackpets
else if (Data.ItemBase[uItemID.ID].Pettype == Global.item_database.PetType.ATTACKPET)
{
//Check if we have pet active allready.
if (!Character.Attackpet.Active && Character.Action.MonsterID.Count == 0 || !Character.Attackpet.Active && Character.Action.MonsterID == null)
{
//If not active , add new pet object.
if (!Character.Attackpet.Active)
{
HandleUpdateSlotn(iSlot, uItemID, Reader.Int32());
HandleAttackPet(iSlot, uItemID.ID);
client.Send(Packet.Update2(iSlot));
client.Send(Packet.ChangeStatus(Character.Information.UniqueID, 5, 0));
}
}
}
#endregion
#endregion
// Horses (NOTE: Detail error messages per if statement (if level, summoned etc).
#region Horses
if (Data.ItemBase[uItemID.ID].Pettype == Global.item_database.PetType.TRANSPORT)
{
//Checks before we continue
if (!Character.Stall.Stallactive && !Character.Transport.Right && Character.Action.MonsterID.Count == 0 && !Character.State.Sitting && !Character.Information.Scroll)
{
//Check if level is high enough
if (this.Character.Information.Level >= Data.ItemBase[uItemID.ID].Level)
{
HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
HandleHorseScroll(uItemID.ID);
}
//Else
else
{
client.Send(Packet.IngameMessages(SERVER_PLAYER_UPTOHORSE, IngameMessages.UIIT_MSG_COSPETERR_CANT_PETSUM_HIGHLEVEL));
}
}
}
#endregion
// Special transport
#region Special transport
else if (Data.ItemBase[uItemID.ID].Pettype == Global.item_database.PetType.ATTACKPET)
{
}
#endregion
// Job Transport
#region Job Transport
else if (Data.ItemBase[uItemID.ID].Pettype == Global.item_database.PetType.JOBTRANSPORT)
{
//HandleJobTransport(uItemID.ID);
}
#endregion
//###########################################################################################
// Potions
//###########################################################################################
#region Potions
#region HP potion
if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.HP_POTION && Data.ItemBase[uItemID.ID].Etctype != Global.item_database.EtcType.HPSTATPOTION)
{
HandlePotion(1, uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
}
else if (Data.ItemBase[uItemID.ID].Name.Contains("_HP_") && Data.ItemBase[uItemID.ID].Name.Contains("_SUPERSET_"))
{
HandlePotion(1, uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
}
#endregion
#region HP STAT Potions
else if (Data.ItemBase[uItemID.ID].Etctype != Global.item_database.EtcType.HP_POTION && Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.HPSTATPOTION)
{
}
#endregion
#region MP potions
else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.MP_POTION && Data.ItemBase[uItemID.ID].Etctype != Global.item_database.EtcType.MPSTATPOTION)
{
HandlePotion(2, uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
}
else if (Data.ItemBase[uItemID.ID].Name.Contains("_MP_") && Data.ItemBase[uItemID.ID].Name.Contains("_SUPERSET_"))
{
HandlePotion(1, uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
}
#endregion
#region HP STAT Potions
else if (Data.ItemBase[uItemID.ID].Etctype != Global.item_database.EtcType.HP_POTION && Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.MPSTATPOTION)
{
}
#endregion
#region Vigor potions
/*
else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.VIGOR_POTION)
{
HandlePotion(5, uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
}
*/
else if (Data.ItemBase[uItemID.ID].Name.Contains("ITEM_ETC_ALL_"))
{
HandlePotion(5, uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
}
#endregion
#region Speed potions
else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.SPEED_POTION)
{
if (Character.Speed.DefaultSpeed == Character.Speed.RunSpeed ||
Character.Speed.DefaultSpeed + Character.Speed.Updateded[20] != Character.Speed.RunSpeed && Character.Information.Berserking)
{
this.SpecialBuff(Data.ItemBase[uItemID.ID].SkillID);
HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
}
}
#endregion
#region Berserk Potion
else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.BERSERKPOTION)
{
if (Character.Information.BerserkBar < 5)
{
if (Character.Information.Berserking == false)
{
this.Character.Information.BerserkBar = 5;
client.Send(Packet.InfoUpdate(4, 0, Character.Information.BerserkBar));
HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
}
}
}
#endregion
#endregion
//###########################################################################################
// Tickets
//###########################################################################################
#region Tickets
//Forgotten world
#region Forgotten world
else if (Data.ItemBase[uItemID.ID].Ticket == Global.item_database.Tickets.DUNGEON_FORGOTTEN_WORLD)
{
//Must add check if user location currently is forgotten world.
//Must add level check of portal.
ForgottenWorld(uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
}
#endregion
#endregion
//###########################################################################################
// Global chat
//###########################################################################################
#region Global Chat
else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.GLOBALCHAT)
{
HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
byte something = Reader.Byte();
string text = Reader.Text3();
Reader.Close();
SendAll(Packet.ChatPacket(6, 0, text, Character.Information.Name));
}
#endregion
//###########################################################################################
// Stall decoration
//###########################################################################################
#region Stall decoration
else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.STALLDECORATION)
{
StallDeco(uItemID.ID, iSlot);
HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
}
#endregion
//###########################################################################################
// Monster masks
//###########################################################################################
#region Monster masks
else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.MONSTERMASK)
{
//If character monster mask isnt enabled allready.
if (!Character.Transformed)
{
if (Character.Information.Level >= Data.ItemBase[uItemID.ID].Level)
{
//Load Mask
MonsterMasks(uItemID.ID, iSlot);
HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
}
else
{
//Send msg level to low
}
}
else
{
//Send msg allready in use
}
}
#endregion
//###########################################################################################
// Return scrolls
//###########################################################################################
#region Return scrolls
else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.RETURNSCROLL && Data.ItemBase[uItemID.ID].Etctype != Global.item_database.EtcType.REVERSESCROLL)
{
if (Character.Information.Scroll) return;
if (Timer.Movement != null)
{
Timer.Movement.Dispose();
Character.Position.Walking = false;
}
HandleReturnScroll(uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
}
#endregion
//###########################################################################################
// Reverse scrolls
//###########################################################################################
#region Reverse scrolls
else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.REVERSESCROLL)
{
if (Character.Information.Scroll) return;
if (Character.Position.Walking) return;
//Read item id
int itemid = Reader.Int32();
//Our switch byte
byte type = Reader.Byte();
//locations for reverse
int locid = 0;
if (type == 7) locid = Reader.Int32();
//Start our handle
HandleReverse(itemid, type, locid);
//Update slot
HandleUpdateSlot(iSlot, uItemID, itemid);
}
#endregion
//###########################################################################################
// Thief scrolls
//###########################################################################################
#region Thief scrolls
else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.BANDITSCROLL)
{
if (Character.Information.Scroll) return;
HandleThiefScroll(uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
}
#endregion
//###########################################################################################
// Summon scrolls
//###########################################################################################
#region Summon scrolls
else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.SUMMONSCROLL)
{
HandleSummon(Character.Information.Level);
HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
}
#endregion
//###########################################################################################
// Skin change scrolls
//###########################################################################################
#region Skin change scrolls
else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.CHANGESKIN)
{
HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
int skinmodel = Reader.Int32();
HandleSkinScroll(skinmodel, uItemID.ID);
}
#endregion
//###########################################################################################
// Item change tool
//###########################################################################################
#region Skin change scrolls
else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.ITEMCHANGETOOL)
{
int itemid = Reader.Int32();
byte targetslot = Reader.Byte();
//Make sure the item target is not equiped.
if (targetslot < 13) return;
//Continue
HandleUpdateSlot(iSlot, uItemID, itemid);
HandleItemChange(uItemID.ID, iSlot, targetslot);
}
#endregion
//###########################################################################################
// Dungeon items
//###########################################################################################
#region Forgotten world
else if (Data.ItemBase[uItemID.ID].Ticket == Global.item_database.Tickets.DUNGEON_FORGOTTEN_WORLD)
{
HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
ForgottenWorld(uItemID.ID);
}
#endregion
//###########################################################################################
// Inventory expansion
//###########################################################################################
#region Inventory expansion
else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.INVENTORYEXPANSION)
{
HandleInventoryExp(uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
}
#endregion
//###########################################################################################
// Warehouse expansion
//###########################################################################################
#region Warehouse expansion
else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.WAREHOUSE)
{
HandleWareHouse(uItemID.ID);
HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
}
#endregion
//###########################################################################################
// Guild related
//###########################################################################################
#region Guild Icon
else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.GUILD_ICON)
{
HandleRegisterIcon();
}
#endregion
//###########################################################################################
// Non coded types
//###########################################################################################
else
{
//Need to make message in progress or such
Console.WriteLine("Non Coded Item ID: " + Data.ItemBase[uItemID.ID].ID + " Name: " + Data.ItemBase[uItemID.ID].Name + "");
}
}
// Close our packet reader
Reader.Close();
}
catch (Exception ex)
{
Console.WriteLine("Item usage error {0}", ex);
Systems.Debugger.Write(ex);
}
}
public void StallOpen()
{
try
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
if (Character.Stall.Stallactive || Character.State.Sitting || Character.Transport.Spawned || Character.Information.Scroll) return;
Character.Network.Stall = new stall();
Character.Network.Stall.ItemList = new List<stall.stallItem>();
Character.Network.Stall.StallName = Reader.Text3();
Character.Network.Stall.Members.Add(Character.Information.UniqueID);
Character.Network.Stall.MembersClient.Add(this.client);
Character.Network.Stall.ownerID = Character.Information.UniqueID;
Character.Network.Stall.isOpened = false;
client.Send(Packet.StallOpen(Character.Network.Stall.StallName, Character.Information.UniqueID, Character.Information.StallModel));
client.Send(Packet.StallOpened());
Send(Packet.StallOpenGlobal(Character.Network.Stall.StallName, Character.Information.UniqueID, Character.Information.StallModel));
Character.Stall.Stallactive = true;
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
public void StallMain()
{
try
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
byte Type = Reader.Byte();
//Item edit
if (Type == 1)
{
if (Character.Network.Stall.isOpened) return;
byte stallslot = Reader.Byte();
Reader.Skip(2);
ulong price = Reader.UInt64();
if (price <= 999999999)
{
int StallItemIndex = Character.Network.Stall.ItemList.FindIndex(i => (i.stallSlot == stallslot));
Character.Network.Stall.ItemList[StallItemIndex].price = price;
Character.Network.Stall.Send(Packet.StallModifyItem(stallslot, price));
}
else
return;
}
//Add an item
else if (Type == 2)
{
if (Character.Network.Stall.isOpened) return;
byte stallslot = Reader.Byte();
byte invpos = Reader.Byte();
short quantity = Reader.Int16();
ulong price = Reader.UInt64();
Global.slotItem uItemID = GetItem((uint)Character.Information.CharacterID, invpos, 0);
//Disable item mall items in stalls for now.
if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.GLOBALCHAT ||
Data.ItemBase[uItemID.ID].Type == Global.item_database.ArmorType.AVATAR ||
Data.ItemBase[uItemID.ID].Type == Global.item_database.ArmorType.AVATARHAT ||
Data.ItemBase[uItemID.ID].Type == Global.item_database.ArmorType.AVATARATTACH
) return;
if (quantity <= Data.ItemBase[uItemID.ID].Max_Stack)
{
stall.stallItem StallItem = new stall.stallItem();
LoadBluesid(uItemID.dbID);
StallItem.stallSlot = stallslot;
StallItem.price = price;
StallItem.Item = (GetItem((uint)Character.Information.CharacterID, invpos, 0));
if (Character.Network.Stall.ItemList.Exists((get => get.Item.dbID == StallItem.Item.dbID))) return;
Character.Network.Stall.ItemList.Add(StallItem);
Character.Network.Stall.Send(Packet.StallItemMain(Character.Network.Stall.ItemList));
}
else
return;
}
//Item pulling out
else if (Type == 3)
{
if (Character.Network.Stall.isOpened) return;
byte stallslot = Reader.Byte();
//remove stallItem from stall
Character.Network.Stall.ItemList.Remove(Character.Network.Stall.ItemList.Find(i => (i.stallSlot == stallslot)));
Character.Network.Stall.Send(Packet.StallItemMain(Character.Network.Stall.ItemList));
}
//Stall modify state
else if (Type == 5)
{
byte State = Reader.Byte();
Character.Network.Stall.isOpened = (State == 1) ? true : false;
Character.Network.Stall.Send(Packet.StallSetState(State));
}
//Set Welcome msg
else if (Type == 6)
{
if (Character.Network.Stall.isOpened) return;
short length = Reader.Int16();
Character.Network.Stall.WelcomeMsg = Reader.Text3();
//Console.WriteLine("New Welcome msg:" + welcome);
Character.Network.Stall.Send(Packet.StallWelcome(Character.Network.Stall.WelcomeMsg));
}
//Set StallName
else if (Type == 7)
{
string stallname = Reader.Text3();
Send(Packet.StallNameGlobal(Character.Information.UniqueID, stallname));
Character.Network.Stall.Send(Packet.StallName(stallname));
}
}
catch (Exception ex)
{
Console.WriteLine("Additem Stall error: {0}", ex);
}
}
