/////////////////////////////////////////////////////////////////////////
// Union Apply
/////////////////////////////////////////////////////////////////////////
void unionapply()
{
try
{
//Open our packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Get target id (Targeted).
int Target = Reader.Int32();
//Close reader
Reader.Close();
//Get target details
Systems targetplayer = GetPlayer(Target);
//Make sure the target is still there
if (targetplayer != null)
{
//If allready in union
if (targetplayer.Character.Network.Guild.UnionActive) return;
//Set bools for both players
targetplayer.Character.State.UnionApply = true;
this.Character.State.UnionApply = true;
//Set target player to us
targetplayer.Character.Network.TargetID = this.Character.Information.UniqueID;
//Send request to targeted player
targetplayer.client.Send(Packet.PartyRequest(6, this.Character.Information.UniqueID, 0));
}
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
public void Connect()
{
//Wrap our function inside a catcher
try
{
//Open our packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
byte type = Reader.Byte();
Reader.Skip(3);
string ID = Reader.Text();
string PW = Reader.Text();
Reader.Close();
//Set login result information
int LoginResult = LoginUser(ID, ref PW, ref Player, true);
//If the login is succesfull
if (LoginResult == 0)
{
//Send succes packet
client.Send(Packet.ConnectSuccess());
}
//If the login is wrong
else
{
//Disconnect the user
client.Disconnect(PacketInformation.Client);
}
}
catch (Exception ex)
{
Console.WriteLine("Client connect error {0}", ex);
Systems.Debugger.Write(ex);
}
}
/////////////////////////////////////////////////////////////////////////////////
// Add new friend
/////////////////////////////////////////////////////////////////////////////////
void FriendAdd()
{
try
{
PacketReader reader = new PacketReader(PacketInformation.buffer);
short namelenght = reader.Int16();
string name = reader.String(namelenght);
reader.Close();
if (name == Character.Information.Name) return;
Systems sys = GetPlayerName(name);
if (sys != null)
{
sys.client.Send(Packet.FriendInviteTarget(sys.Character));
}
else
{
//Packet cannot find user
}
}
catch (Exception ex)
{
Console.WriteLine("Friend Add error {0}", ex);
Systems.Debugger.Write(ex);
}
}
/////////////////////////////////////////////////////////////////////////////////
// Friend add response
/////////////////////////////////////////////////////////////////////////////////
void FriendAddResponse()
{
try
{
PacketReader reader = new PacketReader(PacketInformation.buffer);
int Inviterid = reader.Int32();
int Myid = reader.Int32();
byte State = reader.Byte();
reader.Close();
Systems sys = GetPlayer(Inviterid);
if (sys != null)
{
if (State == 0)
{
//Declined
client.Send(Packet.FriendDecline(Character.Information.Name));
sys.client.Send(Packet.FriendDecline(Character.Information.Name));
}
else
{
//Accepted
sys.client.Send(Packet.FriendData(Myid, 2, Character.Information.Name, Character, false));
client.Send(Packet.FriendData(Inviterid, 2, sys.Character.Information.Name, sys.Character, false));
MsSQL.InsertData("INSERT INTO friends (owner,friend_name,model_info) VALUES ('" + Character.Information.CharacterID + "','" + sys.Character.Information.CharacterID + "','" + sys.Character.Information.Model + "')");
MsSQL.InsertData("INSERT INTO friends (owner,friend_name,model_info) VALUES ('" + sys.Character.Information.CharacterID + "','" + Character.Information.CharacterID + "','" + Character.Information.Model + "')");
}
}
}
catch (Exception ex)
{
Console.WriteLine("Friend Add Response Error {0}", ex);
Systems.Debugger.Write(ex);
}
}
//This is for checking the new character name
public void CharacterCheck(byte[] buff)
{
//Wrap our function into a catcher
try
{
//Open our packet reader
PacketReader Reader = new PacketReader(buff);
//Ignore first byte
Reader.Skip(1);
//Read character name
string Charactername = Reader.Text();
//Close packet reader
Reader.Close();
//If Character name is in use
if (CharacterCheck(Charactername))
//Send in use packet
client.Send(Packet.CharacterName(4));
//If character name is ok
else
//Send succes packet
client.Send(Packet.ScreenSuccess(4));
}
catch (Exception ex)
{
//Write any error to debog log
Systems.Debugger.Write(ex);
}
}
//Void character delete
void CharacterDelete()
{
//Wrap our function in a catcher
try
{
//Create new packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Skip one not used byte
Reader.Skip(1);
//Get character name information
string CharacterName = Reader.Text();
//Close packet reader
Reader.Close();
//Update and set time + deletion state into the database
MsSQL.InsertData("UPDATE character SET deletedtime=dateadd(dd,7,getdate()),deleted='1' WHERE name='" + CharacterName + "'");
//Send visual state of character on screen sit down
client.Send(Packet.ScreenSuccess(3));
}
//Catch bad exception errors
catch (Exception ex)
{
//Write information to the console
Console.WriteLine("Character deletion error {0}", ex);
//Write information to debug logger
Systems.Debugger.Write(ex);
}
}
void CharacterRestore()
{
//Wrap our function in a catcher
try
{
//Create new packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Skip one byte
Reader.Skip(1);
//Read charactername to be restored
string CharacterName = Reader.Text();
Reader.Close();
//Update database information set deleted state to 0
MsSQL.InsertData("UPDATE character SET deleted='0' WHERE name='" + CharacterName + "'");
//Send state packet to client character standing up
client.Send(Packet.ScreenSuccess(5));
}
//Catch bad exception errors
catch (Exception ex)
{
//Write information to the console
Console.WriteLine("Character restore error {0}", ex);
//Write information to the debug log
Systems.Debugger.Write(ex);
}
}
/////////////////////////////////////////////////////////////////////////////////
// Open Npc
/////////////////////////////////////////////////////////////////////////////////
protected void Open_NPC()
{
#region Open Npc
try
{
Character.State.Busy = true;
PacketReader Reader = new PacketReader(PacketInformation.buffer);
Reader.UInt32();
byte type = Reader.Byte();
if (type == 1)
{
client.Send(Packet.OpenNPC(type));
}
else
{
client.Send(Packet.OpenNPC(type));
}
Reader.Close();
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
#endregion
}
void GuildInvite()
{
//Wrap our code into a catcher
try
{
//Create new packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Read lenght of invited character name
Int16 InvitedCharacterLEN = Reader.Int16();
//Read invited character name
string InvitedCharacter = Reader.String(InvitedCharacterLEN);
//Close packet reader
Reader.Close();
//Get information for target
Systems sys = GetPlayerName(InvitedCharacter);
//Set targetid information
Character.Network.TargetID = sys.Character.Information.UniqueID;
//If player allready has a guild
if (sys.Character.Network.Guild.Guildid != 0)
{
client.Send(Packet.IngameMessages(Systems.SERVER_GUILD_WAIT, IngameMessages.UIIT_MSG_GUILDERR_MEMBER_OF_ANOTHER_GUILD));
return;
}
//If player has to wait before the player can join another guild
if (sys.Character.Information.JoinGuildWait)
{
client.Send(Packet.IngameMessages(Systems.SERVER_GUILD_WAIT, IngameMessages.UIIT_MSG_GUILD_PENALTY));
return;
}
//If the guild has max members
if (Character.Network.Guild.TotalMembers >= Character.Network.Guild.MaxMembers)
{
client.Send(Packet.IngameMessages(Systems.SERVER_GUILD_WAIT, IngameMessages.UIIT_MSG_GUILDERR_MEMBER_FULL));
}
//If the character doesnt have join rights
if (!Character.Network.Guild.joinRight)
{
//This should not happen unless hack attempt, because button should be grayed out
return;
}
//Set targetid to the invited player
sys.Character.Network.TargetID = this.Character.Information.UniqueID;
//Send guild request packet
sys.client.Send(Packet.PartyRequest(5, this.Character.Information.UniqueID, 0));
//Set bools active
Character.State.GuildInvite = true;
sys.Character.State.GuildInvite = true;
}
//Catch bad exception errors
catch (Exception ex)
{
//Write information to the console
Console.WriteLine("Guild invite error {0}", ex);
//Write information to the debug log
Systems.Debugger.Write(ex);
}
}
void GuildTransferLeaderShip()
{
try
{
//Create new packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Read guild id
int Guildid = Reader.Int32();
//Read guild member id to transfer to
int GuildMemberID = Reader.Int32();
//Close reader
Reader.Close();
//Get detailed player information
Systems NewLeader = GetPlayerid(GuildMemberID);
//Update database
MsSQL.InsertData("UPDATE guild_members SET guild_rank='10',guild_perm_join='0',guild_perm_withdraw='0',guild_perm_union='0',guild_perm_storage='0',guild_perm_notice='0' WHERE guild_member_id='" + Character.Information.CharacterID + "'");
MsSQL.InsertData("UPDATE guild_members SET guild_rank='0',guild_perm_join='1',guild_perm_withdraw='1',guild_perm_union='1',guild_perm_storage='1',guild_perm_notice='1' WHERE guild_member_id='" + GuildMemberID + "'");
//Repeat for each member in our guild
foreach (int member in Character.Network.Guild.Members)
{
//Make sure member is not null
if (member != 0)
{
//Get information for the guildmember
Systems guildmember = GetPlayerMainid(member);
//Make sure the guildmember isnt null
if (guildmember != null)
{
//Send update packet of new leader
guildmember.client.Send(Packet.GuildUpdate(Character, 3, GuildMemberID, 0, 0));
}
}
}
//Send message to old owner
PacketWriter Writer = new PacketWriter();
//Add opcode
Writer.Create(Systems.SERVER_GUILD_TRANSFER_MSG);
//Static byte 1
Writer.Byte(1);
//Send bytes to client
client.Send(Writer.GetBytes());
}
//If a bad exception error happens
catch (Exception ex)
{
//Write information to the console
Console.WriteLine("Guild Transfer Error: {0}", ex);
//Write information to the debug log
Systems.Debugger.Write(ex);
}
}
public void CharacterScreen()
{
//Wrap our function inside a catcher
try
{
//Open our packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
byte type = Reader.Byte();
//Switch on byte type
switch (type)
{
case 1:
//Character creation
CharacterCreate();
break;
case 2:
//Character listening
client.Send(CharacterListing(Player));
break;
case 3:
//Character deletion
CharacterDelete();
break;
case 4:
//Character checking
CharacterCheck(PacketInformation.buffer);
break;
case 5:
//Character restoring
CharacterRestore();
break;
case 9:
//Character job information
CharacterJobInfo();
break;
case 16:
//Select job
CharacterJobPick(PacketInformation.buffer);
break;
default:
//We use this if we get a new case.
Console.WriteLine("Character Screen Type: " + type);
break;
}
//Close packet reader
Reader.Close();
}
catch (Exception ex)
{
Console.WriteLine("Characterscreen switch error {0}", ex);
Systems.Debugger.Write(ex);
}
}
void GuildMessage()
{
//Wrap our function inside a catcher
try
{
//Create new packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Read short int16 for title lenght
short TitleL = Reader.Int16();
//Read string for title
string Title = Reader.String(TitleL);
//Read short Message lenght
short MessageL = Reader.Int16();
//Read message
string Message = Reader.String(MessageL);
//Close reader
Reader.Close();
//Update database guild message title and message
MsSQL.InsertData("UPDATE guild SET guild_news_t='" + Title + "',guild_news_m='" + Message + "' WHERE guild_name='" + Character.Network.Guild.Name + "'");
//Set new message info to current member for sending packet update.
Character.Network.Guild.NewsTitle = Title;
Character.Network.Guild.NewsMessage = Message;
//Repeat for each member in our guild
foreach (int member in Character.Network.Guild.Members)
{
//Make sure the member is there
if (member != 0)
{
//Get detailed information from member main id
Systems characterinformation = GetPlayerid(member);
//Set the current member news title and message information
characterinformation.Character.Network.Guild.NewsMessage = Message;
characterinformation.Character.Network.Guild.NewsTitle = Title;
//Send packet to the member to update guild message.
characterinformation.client.Send(Packet.GuildUpdate(characterinformation.Character, 11, 0, 0, 0));
}
}
}
//Catch any bad exception error
catch (Exception ex)
{
//Write error to the console
Console.WriteLine("Guild Message Error: {0}", ex);
//Write information to the debug log
Systems.Debugger.Write(ex);
}
}
void CharacterJobPick(byte[] buff)
{
//Wrap our function inside a catcher
try
{
//Create new packet reader
PacketReader Reader = new PacketReader(buff);
//Skip first byte not used
Reader.Skip(1);
//Read name lenght
short CharacterNameLEN = Reader.Int16();
//Read character name
string CharacterName = Reader.String(CharacterNameLEN);
//Read job selection
byte job = Reader.Byte();
//Close packet reader
Reader.Close();
//Get row count from character to check if the current account and character match
int NameCheck = MsSQL.GetRowsCount("SELECT * FROM character WHERE account='" + Player.AccountName + "'");
//Get job information from database as integer
int jobcheck = MsSQL.GetDataInt("SELECT jobtype FROM users WHERE id='" + Player.AccountName + "'", "jobtype");
//If the name check is succesfull and account has no job set.
if (jobcheck == 0 && NameCheck != 0)
{
//Write new job information to the database
MsSQL.UpdateData("UPDATE users SET jobtype='" + job + "' WHERE id='" + Player.AccountName + "'");
}
//Send visual confirmation in packet
PacketWriter writer = new PacketWriter();
//Add opcode
writer.Create(Systems.SERVER_CHARACTERSCREEN);
//Write static byte 10
writer.Byte(0x10);
//Write succes byte 1
writer.Byte(1);
//Send bytes to client
client.Send(writer.GetBytes());
}
//Catch any bad exception error
catch (Exception ex)
{
//Write error information to the console
Console.WriteLine("Job selection error {0}", ex);
//Write error to debug log file
Systems.Debugger.Write(ex);
}
}
void HandleRegisterIcon()
{
try
{
PacketReader reader = new PacketReader(PacketInformation.buffer);
byte type = reader.Byte();
int iconlenght = reader.Int32();
string icon = reader.Text();
reader.Close();
string convertedicon = ConvertToHex(icon);
//Save output to .dat file in hex formatting.
}
catch (Exception ex)
{
Console.WriteLine("Guild icon register error {0}", ex);
}
}
public void CharacterCheck(byte[] buff)
{
try
{
PacketReader Reader = new PacketReader(buff);
Reader.Byte();
string name = Reader.Text();
Reader.Close();
if (CharacterCheck(name))
client.Send(Packet.CharacterName(4));
else client.Send(Packet.ScreenSuccess(4));
}
catch (Exception ex)
{
Console.WriteLine("CharacterCheck()");
deBug.Write(ex);
Console.WriteLine(ex);
}
}
void GuildTitle()
{
//Wrap our function inside a catcher
try
{
//Extra hack check
if (Character.Network.Guild.Level < 4)
return;
//Create new packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Read integer guild member selected
int SelectedGuildMember = Reader.Int32();
//Read short lenght of title for guild member
short GuildMemberTitleLEN = Reader.Int16();
//Read string guild member title
string GuildMemberTitle = Reader.String(GuildMemberTitleLEN);
//Close packet reader
Reader.Close();
//Get selected guild member information
Systems playerinfo = GetPlayerMainid(SelectedGuildMember);
//Make sure the character is still there
if (playerinfo.Character != null)
{
//Update database set new title
MsSQL.InsertData("UPDATE guild_members SET guild_grant='" + GuildMemberTitle + "' WHERE guild_member_id='" + playerinfo.Character.Information.CharacterID + "'");
//Send new character guild title update to each player in spawn reach
Send(Packet.GuildSetTitle(Character.Guild.GuildID, playerinfo.Character.Information.Name, GuildMemberTitle));
//Send Final packet to client
playerinfo.client.Send(Packet.GuildSetTitle2(Character.Guild.GuildID, SelectedGuildMember, GuildMemberTitle));
}
}
//Catch bad exception errors
catch (Exception ex)
{
//Write information to the console
Console.WriteLine("Guild Title Error: {0}", ex);
//Write information to debug log
Systems.Debugger.Write(ex);
}
}
void GuildWarGold()
{
try
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
int guildid = Reader.Int32();
Reader.Close();
if (Character.Guild.GuildWarGold == 0)
{
//Send Packet Message No War Gold Received
client.Send(Packet.GuildWarMsg(2));
}
else
{
//Sniff packet for war gold
}
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
void MovementSkill(PacketReader Reader)
{
try
{
if (!Character.Action.movementskill)
{
Character.Action.movementskill = true;
MovementSkillTimer(Data.SkillBase[Character.Action.UsingSkillID].Properties1["tele"] + 500);
if (Character.Action.sAttack || Character.Action.sCasting) return;
if (Character.Stat.SecondMP < Data.SkillBase[Character.Action.UsingSkillID].Mana) { client.Send(Packet.ActionPacket(2, 4)); return; }
else
{
Character.Stat.SecondMP -= Data.SkillBase[Character.Action.UsingSkillID].Mana;
UpdateMp();
if (Timer.Movement != null) { Timer.Movement.Dispose(); Character.Position.Walking = false; }
byte xSec = Reader.Byte(), ySec = Reader.Byte();
int x = Reader.Int32(), z = Reader.Int32(), y = Reader.Int32();
Reader.Close();
float gamex = DarkEmu_GameServer.Formule.gamex((float)x, xSec);
float gamey = DarkEmu_GameServer.Formule.gamey((float)y, ySec);
float farkx = gamex - Character.Position.x;
float farky = gamey - Character.Position.y;
float hesapy = 0, hesapx = 0;
while (hesapx + hesapy < Data.SkillBase[Character.Action.UsingSkillID].Properties2["tele"] / 10)
{
Character.Position.x += (farkx / 30);
Character.Position.y += (farky / 30);
hesapx += Math.Abs((farkx / 30));
hesapy += Math.Abs((farky / 30));
}
PacketWriter Writer = new PacketWriter();
Writer.Create(SERVER_ACTION_DATA);
Writer.Byte(1);
Writer.Byte(2);
Writer.Byte(0x30);
int overid = Character.Ids.GetCastingID();
Writer.DWord(Character.Action.UsingSkillID);//skillid
Writer.DWord(Character.Information.UniqueID); //charid
Writer.DWord(overid);//overid
Writer.DWord(0);
Writer.Byte(8);
Writer.Byte(xSec);
Writer.Byte(ySec);
Writer.DWord(Formule.packetx(Character.Position.x, xSec));
Writer.DWord(0);
Writer.DWord(Formule.packety(Character.Position.y, ySec));
Send(Writer.GetBytes());
client.Send(Packet.ActionState(2, 0));
ObjectSpawnCheck();
}
}
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
void GuildCreate()
{
try
{
//Extra check if user is allready in guild.
if (Character.Network.Guild.Guildid != 0) return;
//If player has recently been in a guild
if (Character.Information.JoinGuildWait)
{
//Need to sniff the retail packet (Tmp used guild war error).
client.Send(Packet.IngameMessages(Systems.SERVER_GUILD_WAIT, IngameMessages.UIIT_MSG_GUILDWARERR_GUILD_CREATE_PENALTY));
return;
}
//Create new packet reader for reading information
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//None needed integer
int notneeded = Reader.Int32();
//Get guild name lenght
short GuildNameLen = Reader.Int16();
//Get guild name
string GuildName = Reader.String(GuildNameLen);
//Close packet reader
Reader.Close();
//Remove bad characters from guildname
GuildName = Removebadchars(GuildName);
//Check length lower are 4 return
if (GuildName.Length < 4)
{
//Send incorrect lenght
client.Send(Packet.IngameMessages(Systems.SERVER_GUILD_WAIT, IngameMessages.UIIT_MSG_GUILDERR_INVALID_GUILDNAME_LEN));
return;
}
//Check if guild name is taken or not.
int guildcheckname = MsSQL.GetRowsCount("SELECT * FROM guild WHERE guild_name='" + GuildName + "'");
//If name excists
if (guildcheckname == 1)
{
client.Send(Packet.IngameMessages(Systems.SERVER_GUILD_WAIT, IngameMessages.UIIT_MSG_GUILDERR_SAME_GUILDNAME_EXIST));
return;
}
//If character level is to low
if (Character.Information.Level < 20)
{
//Send packet level to low message
client.Send(Packet.IngameMessages(Systems.SERVER_GUILD, IngameMessages.UIIT_MSG_GUILDERR_TOO_LOW_CREATOR_LEVEL));
return;
}
//Set the gold requirements 500.000 retail info
int goldrequired = 500000;
//If gold is lower then price of creating a guild
if (Character.Information.Gold < goldrequired)
{
//Send message not enough gold
client.Send(Packet.IngameMessages(SERVER_GUILD, IngameMessages.UIIT_MSG_GUILDERR_NOT_ENOUGH_GOLD));
return;
}
//All checks ok, continue creating new guild.
else
{
//Reduct the gold required from player gold
Character.Information.Gold -= goldrequired;
//Save player information
SavePlayerInfo();
//Insert guild into database
MsSQL.InsertData("INSERT INTO guild (guild_name, guild_level, guild_points, guild_news_t, guild_news_m, guild_members_t, guild_master_id) VALUES ('" + GuildName + "','1','0','" + "" + "','" + "" + "','1','" + Character.Information.CharacterID + "')");
//Get guild id
string guildid = MsSQL.GetData("SELECT id FROM guild WHERE guild_name='" + GuildName + "'", "id");
int docount = Convert.ToInt32(guildid);
//Insert member into database
MsSQL.InsertData("INSERT INTO guild_members (guild_id, guild_member_id, guild_rank, guild_points, guild_fortress, guild_grant, guild_perm_join, guild_perm_withdraw, guild_perm_union, guild_perm_storage, guild_perm_notice) VALUES ('" + docount + "','" + Character.Information.CharacterID + "','0','0','1','','1','1','1','1','1')");
//Load our new guild
LoadPlayerGuildInfo(true);
//Private packet
client.Send(Packet.Guild_Create(Character.Network.Guild));
//Public spawn packet
Send(Packet.SendGuildInfo2(this.Character));
}
}
catch (Exception ex)
{
Console.WriteLine("Guild creation error: " + ex);
Systems.Debugger.Write(ex);
}
}
public void RequestIcons()
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
byte IconType = Reader.Byte();
short IconHexLenght = Reader.Int16();
string Icon = Reader.String(IconHexLenght);
Reader.Close();
//Need to figure out the string.. identification of the icon probably
client.Send(Packet.IconSend(IconType, Icon));
// Below is sniffed data
/*
* [S -> C][2114]
01 Byte = Type icon (1 = Guild 2 = union).
1C 01 Lenght of hex icon string
// below is the hex string (Ascii) icon
74 6D 28 73 81 2A 47 37 F6 13 99 62 8C 3F 4E 29 tm(s.*G7...b.?N)
0F 04 CB 3D E6 5F FC 0B D6 07 03 DD 0D 72 9A 25 ...=._.......r.%
8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^.
8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^.
8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^.
8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^.
8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^.
8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^.
8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^.
8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^.
8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^.
8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^.
8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^.
8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^.
8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^.
8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^.
8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^.
FE DC BA 98 76 54 32 10 0F 1E 2D 3C ....vT2...-<....
[C -> S][2114]
02 ................
0C 00 ................
AE A5 BF 3C 23 65 0C 01 03 1E 27 3C ...<#e....'<....
*/
/*
(Nukei)Discovered so far:
client requests image by contacting 121.128.134.16 (gdmark.joymax.com) using HTTP protocol over port 15080
like:
http://gdmark.joymax.com:15080/SRO_CREST/A96_2132_1.crb (this files is saved in sro-client's RD folder as A96_2132.rd converted to BMP format)
the returned header indicates, that the returned content is 256 Bytes in size (16 x 16 = 256). the given type is "application".
ToDo:
1. Why or when the client starts this request for images ?
2. Is the returned array of bytes 16x16 palette entries ?
3. if 2 is right, what palette is used ?
Result:
1. dont know :-P
2. Yes, we get a paletted image in 16x16 size (without palette, without size, RAW pixel), so every byte is one pixel. pay attention that the Y coordinates are reversed, so the image is bottom up.
3. discovered that it is the windows system palette !!
* I dont know if the image really is transfered with 2114 packet !!!
Tools used: PhotoShop, Wireshark, WinHex
*/
/*Xsense:
* Result:
* 1. I believe send on guild name spawn by 1 byte indication active non active.
* 1. Simple check would be a bool from database on creation of icon set to true,
* 1. Deletion item / guild disband / union kick / leave would remove the bool information from db.
* 2. Indexed color 8 bit setting. (Change extension to bmp / checked photoshop indications).
* 3.
* 4. RD should be cache folder, which server could check from registry path to see excisting icons.
*/
/*
(Rokky93) Discovered:
I search a bit about CREST System of Joymax and found an interesting blog.So now i will tell you my results:
1. Silkroad stores Guild Icons on a stand-alone FTP Server. You can find them in the Media.pk2/type.txt
2. For example A96_2132_1.crb:
A - type(Guild or Alliance)
96- Server ID
2132 - guild id
1 - crest id
When we want to convert it to bmp:
1. Silkroad uses 16x16 pixel big 8bbp bitmaps with static color palette and no compression. The stored crests are 256B big.
2. BMP Structure:
header - static
meta - static
palette - static
bitmap (crest file content) - dynamic
When we want to send icons to Client
1. We have to change the FTP Server in the Media.pk2
2. We must send this packet to Client
byte - type(alliance, guild) 00 or 01
dword - guildid
string - guildname
dword - crestindex
For example:
type G
serverId 187
guildId 2929
crestid 3
Client makes this : G187_2929_3.crb and download them from server ( this is my theory)
GET /SRO_CREST/A239_282_3.crb HTTP/1.1
Accept-Encoding: gzip, deflate
User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.1; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; InfoPath.3; .NET4.0C; .NET4.0E)
Host: gdmark.joymax.com:15080
Connection: Keep-Alive
*/
}
void ActionMain()
{
try
{
if (Character.State.Die || Character.Information.Scroll || Character.Action.Cast)
return;
//Create new packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Read main action type
byte type = Reader.Byte();
//If attack action byte is not equal to 2
if (type != 2)
{
//Read player action byte
byte PlayerAction = Reader.Byte();
//Create switch on player actions
switch (PlayerAction)
{
//Normal attacking
case 1:
//If character is allready using normal attack
if (Character.Action.nAttack)
{
//Return
return;
}
//If the character is riding a horse
if (Character.Transport.Right)
{
//Return, because character cannot attack while riding a horse.
return;
}
//If the character is picking up a item
if (Character.Action.PickUping)
{
//Stop pick up timer
StopPickUpTimer();
}
//Skip non needed byte
Reader.Skip(1);
//Read integer target id (DWORD).
int TargetID = Reader.Int32();
//Close packet reader
Reader.Close();
//Set target id for usage later in attacking.
Character.Action.Object = GetObjects(TargetID);
//Set bool normal attack to true
Character.Action.nAttack = true;
//Set character target id
Character.Action.Target = TargetID;
//Start attacking
StartAttackTimer(1425);
break;
case 2://pickup
if (Character.Action.nAttack) return;
if (Character.Action.sAttack) return;
if (Character.Action.sCasting) return;
if (Character.Action.PickUping) return;
Reader.Byte();
int id2 = Reader.Int32();
Reader.Close();
Character.Action.Target = id2;
Character.Action.PickUping = true;
StartPickupTimer(600);
break;
case 3://trace
if (Character.Action.sAttack) return;
if (Character.Action.sCasting) return;
if (Character.State.Sitting) return;
if (Character.Stall.Stallactive) return;
Reader.Byte();
int id3 = Reader.Int32();
Character.Action.Target = id3;
Reader.Close();
client.Send(Packet.ActionState(1, 1));
Character.Action.PickUping = false;
Player_Trace(id3);
break;
case 4://use skill
Character.Action.UsingSkillID = Reader.Int32();
SkillMain(Reader.Byte(), Reader);
break;
case 5:
int id4 = Reader.Int32();
byte b_index = SkillGetBuffIndex(id4);
SkillBuffEnd(b_index);
break;
default:
Console.WriteLine("ActionMain case: " + Reader.Byte());
break;
}
}
else
StopAttackTimer();
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
void DonateGP()
{
//First we write our function inside a catcher
try
{
//Max level of guild wont allow new gp donations.
if (Character.Network.Guild.Level == 5)
{
//Send error message to client
client.Send(Packet.IngameMessages(SERVER_GUILD_PROMOTE_MSG, IngameMessages.UIIT_MSG_GUILD_LACK_GP));
return;
}
//Open our packet reader
PacketReader reader = new PacketReader(PacketInformation.buffer);
//Read donated gp amount (int).
int donatedgp = reader.Int32();
//Close packet reader
reader.Close();
//Anti hack checking (If donated gp higher is then the player skillpoints.
if (donatedgp > Character.Information.SkillPoint)
return;
//Calculate total
int totalgp = Character.Network.Guild.PointsTotal + donatedgp;
//Set guild points total
Character.Network.Guild.PointsTotal += donatedgp;
//Set skill points minus donated amount
Character.Information.SkillPoint -= donatedgp;
//Set donated gp + donated skill points
Character.Network.Guild.DonateGP += donatedgp;
//Save our information (Skill points).
SavePlayerInfo();
//Update database total guild points
MsSQL.UpdateData("UPDATE guild SET guild_points='" + totalgp + "' WHERE guild_name='" + Character.Network.Guild.Name + "'");
//Update database donated player guild points amount
MsSQL.UpdateData("UPDATE guild_members SET guild_points='" + Character.Network.Guild.DonateGP + "' WHERE guild_member_id='"+ Character.Information.CharacterID +"'");
//Send packets to donator.
client.Send(Packet.InfoUpdate(1, totalgp, 0));
//Send donated gp info
PacketWriter writer = new PacketWriter();
//Add opcode
writer.Create(Systems.SERVER_GUILD_DONATE_GP);
//Write static byte 1
writer.Byte(1);
//Write dword int value donated gp amount.
writer.DWord(donatedgp);
//Send bytes to client
client.Send(writer.GetBytes());
//Repeat for each member in our guild
foreach (int member in Character.Network.Guild.Members)
{
//Make sure that the member isnt null
if (member != 0)
{
//Now we get the detailed information for each member
Systems guildmember = GetPlayerMainid(member);
//Make sure the guildmember is still there
if (guildmember != null)
{
//Send guild update packets to each member (Donated gp information and % bar update).
guildmember.client.Send(Packet.GuildUpdate(Character, 13, 0, 0, totalgp));
guildmember.client.Send(Packet.GuildUpdate(Character, 9, 0, 0, totalgp));
}
}
}
}
//Catch any bad exception error
catch (Exception ex)
{
//Write information to the console
Console.WriteLine("Donate GP Error {0}", ex);
//Write information to the debug log.
Systems.Debugger.Write(ex);
}
}
void SelectObject()
{
try
{
if (Character.Information.Scroll) return;
PacketReader Reader = new PacketReader(PacketInformation.buffer);
int objectid = Reader.Int32();
if (objectid == 0) return;
//if (Character.Position.Walking) StopPlayerMovementO(objectid);
if (objectid == Character.Information.UniqueID && Character.State.Die)
{
Player_Up();
return;
}
obj o = GetObject(objectid);
if (o != null)
{
byte[] bb = DarkEmu_GameServer.Packet.SelectObject(objectid, o.ID, o.LocalType, o.HP);
if (bb == null) return;
client.Send(bb);
return;
}
Systems sys = GetPlayers(objectid);
if (o == null && sys != null)
{
client.Send(DarkEmu_GameServer.Packet.SelectObject(objectid, 0, 5, sys.Character.Stat.Hp));
return;
}
Reader.Close();
}
catch (Exception ex)
{
Console.WriteLine("Selectobject error: {0}", ex);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Exchange Request
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Exchange_Request()
{
try
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
int targetid = Reader.Int32();
Reader.Close();
Systems sys = GetPlayer(targetid);
Character.Network.TargetID = targetid;
sys.Character.Network.TargetID = this.Character.Information.UniqueID;
sys.client.Send(Packet.PartyRequest(1, this.Character.Information.UniqueID, 0));
Character.State.Exchanging = true;
sys.Character.State.Exchanging = true;
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
//###########################################################################################
// Start teleporting
//###########################################################################################
void Teleport_Start()
{
try
{
lock (this)
{
//Checks before we continue
if (Character.Action.PickUping) return;
//Timer checks
StopTimers();
//Open the packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Teleport id
int teleportidinfo = Reader.Int32();
//Number
byte number = Reader.Byte();
//Teleport selected
int teleportselect = Reader.Int32();
Reader.Close();
//Find price information
int price = Data.TeleportPrice.Find(pc => (pc.ID == number)).price;
//If the user has less gold then it costs
if (this.Character.Information.Gold < price)
{
//Send error message
this.client.Send(Packet.IngameMessages(SERVER_TELEPORTSTART, IngameMessages.UIIT_MSG_INTERACTION_FAIL_NOT_ENOUGH_MONEY));
return;
}
//If the user level is lower then the required level
if (Data.TeleportPrice.Find(dd => (dd.ID == teleportselect)).level > 0 && Character.Information.Level < Data.TeleportPrice.Find(dd => (dd.ID == teleportselect)).level)
{
client.Send(Packet.IngameMessages(SERVER_TELEPORTSTART, IngameMessages.UIIT_MSG_INTERACTION_FAIL_OUT_OF_REQUIRED_LEVEL_FOR_TELEPORT));
return;
}
//If the user is currently with job transport (TODO).
//Update players gold
this.Character.Information.Gold -= price;
//Update players gold in database
SaveGold();
//Close buffs
BuffAllClose();
//Send teleport packet #1
this.client.Send(Packet.TeleportStart());
//Set state
this.Character.InGame = false;
//Update location
Teleport_UpdateXYZ(Convert.ToByte(teleportselect));
//Despawn objects
ObjectDeSpawnCheck();
//Despawn player to other players
DeSpawnMe();
//Required
client.Send(Packet.TeleportStart2());
//Send loading screen image
this.client.Send(Packet.TeleportImage(Data.PointBase[Convert.ToByte(teleportselect)].xSec, Data.PointBase[Convert.ToByte(teleportselect)].ySec));
//Set bool
this.Character.Teleport = true;
}
}
catch (Exception ex)
{
Console.WriteLine("Teleport select error {0}", ex);
Systems.Debugger.Write(ex);
}
}
/////////////////////////////////////////////////////////////////////////////////
// Item Switch
/////////////////////////////////////////////////////////////////////////////////
void ItemMain()
{
#region Item Actions
try
{
if (Character.State.Die || Character.Information.Scroll) return;
PacketReader Reader = new PacketReader(PacketInformation.buffer);
byte iType = Reader.Byte();
switch (iType)
{
case 0:
if (Character.State.Busy) return;
ItemMove(Reader.Byte(), Reader.Byte(), Reader.Int16());
break;
case 1:
ItemMoveInStorage(Reader.Byte(), Reader.Byte(), Reader.Int16());
break;
case 2:
Player_MoveItemToStorage(Reader.Byte(), Reader.Byte(), Reader.Int32());
break;
case 3:
Player_MoveStorageItemToInv(Reader.Byte(), Reader.Byte(), Reader.Int32());
break;
case 4:
ItemMoveToExhangePage(Reader.Byte());
break;
case 5:
ItemMoveExchangeToInv(Reader.Byte());
break;
case 8:
Player_BuyItem(Reader.Byte(), Reader.Byte(), Reader.Int16(), Reader.Int32());
break;
case 9:
Player_SellItem(Reader.Byte(), Reader.Int16(), Reader.UInt16());
break;
case 7:
if (Character.State.Busy) return;
Player_DropItem(Reader.Byte());
break;
case 10:
if (Character.State.Busy) return;
Player_DropGold(Reader.UInt64());
break;
case 11:
Player_TakeGoldW(iType, Reader.Int64());
break;
case 12:
Player_GiveGoldW(iType, Reader.Int64());
break;
case 13:
ItemExchangeGold(Reader.Int64());
break;
case 16:
MovePetToPet(Reader.Int32(), Reader.Byte(), Reader.Byte(), Reader.Int16());
break;
case 24:
Player_BuyItemFromMall(Reader.Byte(), Reader.Byte(), Reader.Byte(), Reader.Byte(), Reader.Byte(), Reader.Text());
break;
case 26:
MoveItemFromPet(Reader.Int32(), Reader.Byte(), Reader.Byte());
break;
case 27:
MoveItemToPet(Reader.Int32(), Reader.Byte(), Reader.Byte());
break;
case 29:
ItemMoveInStorage(Reader.Byte(), Reader.Byte(), Reader.Int16());//Move inside guild storage
break;
case 30:
Player_MoveItemToStorage(Reader.Byte(), Reader.Byte(), Reader.Int32());//Move to guild storage
break;
case 31:
Player_MoveStorageItemToInv(Reader.Byte(), Reader.Byte(), Reader.Int32());//Move from guild storage
break;
case 32:
Player_GiveGoldW(iType, Reader.Int64());//Guild storage
break;
case 33:
Player_TakeGoldW(iType, Reader.Int64());//Guild storage
break;
case 35:
ItemAvatarUnEquip(Reader.Byte(), Reader.Byte());
break;
case 36:
ItemAvatarEquip(Reader.Byte(), Reader.Byte());
break;
default:
Print.Format("Unknown Item Function:{0}:{1}", iType, Decode.StringToPack(PacketInformation.buffer));
break;
}
Reader.Close();
}
catch (Exception ex)
{
Console.WriteLine("Item Switch Error {0}", ex);
}
#endregion
}
void GuildPermissions()
{
try
{
//Create new packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Skip first
Reader.Skip(1);
//Read member id
int memberid = Reader.Int32();
//Read permission byte
byte permissions = (byte)Reader.Int32();
//Set new char bits 8
char[] bits = new char[8];
//Repeat for each 8 bits
for (int i = 0; i < 8; ++i) bits[i] = (char)0;
//Convert bits to string / to char array
bits = Convert.ToString(permissions, 2).ToCharArray();
//Close reader
Reader.Close();
//Set amount to player targetindex
int targetindex = this.Character.Network.Guild.MembersInfo.FindIndex(i => i.MemberID == memberid);
//If character is online
if (this.Character.Network.Guild.MembersInfo[targetindex].Online)
{
//Get detailed player information
Systems member = GetPlayerMainid(memberid);
//Set bits
member.Character.Network.Guild.joinRight = bits[4] == '1' ? true : false;
member.Character.Network.Guild.withdrawRight = bits[3] == '1' ? true : false;
member.Character.Network.Guild.unionRight = bits[2] == '1' ? true : false;
member.Character.Network.Guild.guildstorageRight = bits[0] == '1' ? true : false;
member.Character.Network.Guild.noticeeditRight = bits[1] == '1' ? true : false;
}
// set new amount to every guild members guild class
foreach (int m in Character.Network.Guild.Members)
{
//Set int index (Find member id)
int index = Character.Network.Guild.MembersInfo.FindIndex(i => i.MemberID == m);
//If the character is online
if (Character.Network.Guild.MembersInfo[index].Online)
{
//Get detailed information of the player
Systems sys = Systems.GetPlayerMainid(m);
//Set new guild player
Global.guild_player mygp = new Global.guild_player();
int myindex = 0;
//Repeat for each player
foreach (Global.guild_player gp in sys.Character.Network.Guild.MembersInfo)
{
//if the member id equals the player
if (gp.MemberID == memberid)
{
//Set my gp
mygp = gp;
//Set bits
mygp.joinRight = bits[4] == '1' ? true : false;
mygp.withdrawRight = bits[3] == '1' ? true : false;
mygp.unionRight = bits[2] == '1' ? true : false;
mygp.guildstorageRight = bits[0] == '1' ? true : false;
mygp.noticeeditRight = bits[1] == '1' ? true : false;
break;
}
//Index ++
myindex++;
}
//Set membersinfo index as mygp
sys.Character.Network.Guild.MembersInfo[myindex] = mygp;
}
}
//Update guild database information rights
MsSQL.UpdateData("UPDATE guild_members SET guild_perm_join='" + bits[4] + "',guild_perm_withdraw='" + bits[3] + "',guild_perm_union='" + bits[2] + "',guild_perm_storage='" + bits[0] + "',guild_perm_notice='" + bits[1] + "' WHERE guild_member_id='" + memberid + "'");
//Send to everyone in guild update of permissions
Character.Network.Guild.Send(Packet.GuildUpdate(Character, 4, 0, permissions, 0));
}
//If an error happens
catch (Exception ex)
{
//Write the information to the console
Console.WriteLine("Guild permission error: {0}", ex);
//Write information to the debug 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 GuildPromote()
{
try
{
//Read client information int32 id
PacketReader reader = new PacketReader(PacketInformation.buffer);
int guildid = reader.Int32();
reader.Close();
//When a guild has reached its max level
if (Character.Network.Guild.Level == 5)
{
//Send packet to client and return (Message level up max).
client.Send(Packet.IngameMessages(Systems.SERVER_GUILD_WAIT, IngameMessages.UIIT_MSG_ERROR_GUILD_LEVEL_UP_FULL));
return;
}
//Definition for gold needed
int GoldRequired;
//Definition for guild points needed
int GuildPointRequired;
//Check if player is allready in process of upgrading
if (!IsUpgrading)
{
//Set bool to true, so we cant dupe
IsUpgrading = true;
//Load player guild information before we continue (Check last info).
LoadPlayerGuildInfo(false);
//Create switch on guildl evel
switch (Character.Network.Guild.Level)
{
case 1:
GoldRequired = 3000000;
GuildPointRequired = 5400;
break;
case 2:
GoldRequired = 9000000;
GuildPointRequired = 50400;
break;
case 3:
GoldRequired = 15000000;
GuildPointRequired = 135000;
break;
case 4:
GoldRequired = 21000000;
GuildPointRequired = 378000;
break;
default:
return;
}
//Set new guild level definition + 1
int NewLevel = Character.Network.Guild.Level + 1;
//Set new guild storage slot amount
int NewStorageSlots = Character.Network.Guild.StorageSlots + 30;
//If character's gold is not enough
if (Character.Information.Gold < GoldRequired)
{
//Send message to client
client.Send(Packet.IngameMessages(SERVER_GUILD_PROMOTE_MSG, IngameMessages.UIIT_MSG_ERROR_GUILD_LEVEL_UP_GOLD_DEFICIT));
return;
}
//Not enough guildpoints
if (Character.Network.Guild.PointsTotal < GuildPointRequired)
{
//Send client message
client.Send(Packet.IngameMessages(SERVER_GUILD_PROMOTE_MSG, IngameMessages.UIIT_MSG_ERROR_GUILD_LEVEL_UP_GP_DEFICIT));
return;
}
//Max level
if (Character.Network.Guild.Level == 5)
{
//Send client message
client.Send(Packet.IngameMessages(SERVER_GUILD_PROMOTE_MSG, IngameMessages.UIIT_MSG_ERROR_GUILD_LEVEL_UP_FULL));
return;
}
//If everything else is fine
else
//Upgrade guild initiate
{
//If max level return just incase.
if (Character.Network.Guild.Level == 5) return;
//Reduct guildpoints
Character.Network.Guild.PointsTotal -= GuildPointRequired;
//If the upgrade is final upgrade set points to 0
if (Character.Network.Guild.Level == 4) Character.Network.Guild.PointsTotal = 0;
//Reduct gold
Character.Information.Gold -= GoldRequired;
//Send update information to client
client.Send(Packet.InfoUpdate(1, Character.Network.Guild.PointsTotal, 0));
//Send success message to client
client.Send(Packet.PromoteOrDisband(2));
//Update guild in database
MsSQL.UpdateData("UPDATE guild SET guild_level='" + NewLevel + "',guild_points='" + Character.Network.Guild.PointsTotal + "',guild_storage_slots='" + NewStorageSlots + "' WHERE guild_name='" + Character.Network.Guild.Name + "'");
//Repeat for each member in our guild
foreach (int member in Character.Network.Guild.Members)
{
//Check if memeber is not null
if (member != 0)
{
//Get detailed member information
Systems memberinfo = GetPlayerMainid(member);
//Make sure the member is not null
if (memberinfo != null)
{
//Reload information for the current guild member
memberinfo.LoadPlayerGuildInfo(false);
//Send guild update packet for current guild member
memberinfo.client.Send(Packet.GuildUpdate(Character, 5, 0, 0, 0));
}
}
}
//Save player's gold
SaveGold();
//Send update gold packet to client
client.Send(Packet.UpdateGold(Character.Information.Gold));
}
}
//Disable the bool so we can upgrade again
IsUpgrading = false;
}
//If any error accures
catch (Exception ex)
{
//Write error to the console
Console.WriteLine("Guild Promote Error: {0}", ex);
//Write error to debug log
Systems.Debugger.Write(ex);
}
}
void SkillMain(byte type, PacketReader Reader)
{
try
{
if (!SkillGetOpened(Character.Action.UsingSkillID)) return;
client.Send(Packet.ActionState(1, 1));
//Console.WriteLine("Skill id: {0}", Data.SkillBase[Character.Action.UsingSkillID].Series); // Dev Mode
switch (type)
{
case 1:
if (Character.Action.sAttack) return;
if (Character.Action.sCasting) return;
if (Character.Action.nAttack) StopAttackTimer();
if (!Base.Skill.CheckWeapon(Character.Information.Item.wID, Character.Action.UsingSkillID))
{
client.Send(Packet.IngameMessages(SERVER_ACTION_DATA, IngameMessages.UIIT_SKILL_USE_FAIL_WRONGWEAPON));
client.Send(Packet.IngameMessages2(SERVER_ACTIONSTATE, IngameMessages.UIIT_SKILL_USE_FAIL_WRONGWEAPON));
return;
}
Character.Action.Target = Reader.Int32();
Character.Action.Skill.MainSkill = Character.Action.UsingSkillID;
Character.Action.UsingSkillID = 0;
Character.Action.Object = GetObjects(Character.Action.Target);
if (Data.SkillBase[Character.Action.Skill.MainSkill].isAttackSkill)
{
Character.Action.Skill = Base.Skill.Info(Character.Action.Skill.MainSkill, Character);
if (!Character.Action.Skill.canUse || Character.Action.Target == Character.Information.UniqueID) return;
obj o = null;
if (Character.Action.Object != null && Character.Action.Object.GetType().ToString() == "DarkEmu_GameServer.obj")
{
o = Character.Action.Object as obj;
if (o.Agro == null) o.Agro = new List<_agro>();
if (Character.Action.Skill.OzelEffect == 5 && o.State != 4) return;
if (o.State == 4 && Character.Action.Skill.OzelEffect != 5) return;
}
if (o == null && Character.Action.Object != null && Character.Action.Object.GetType().ToString() == "DarkEmu_GameServer.Systems")
{
if (!Character.Information.PvP || Character.State.Die) return;
Systems sys = Character.Action.Object as Systems;
if (Character.Action.Skill.OzelEffect == 5 && sys.Character.State.LastState != 5) return;
if (sys.Character.State.LastState == 4 && Character.Action.Skill.OzelEffect != 5) return;
}
Character.Action.sAttack = true;
ActionSkillAttack();
Reader.Close();
}
else
{
Character.Action.sAttack = true;
ActionSkill();
}
break;
case 0:
SkillBuff();
break;
case 2:
MovementSkill(Reader);
break;
default:
Console.WriteLine("Skillmain type: {0}", type);
break;
}
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
