void MovementSkyClicking(PacketReader Reader)
{
Character.Position.Walking = true;
byte Type = Reader.Byte();
ushort Angle = Reader.UInt16();
Character.Information.Angle = (Angle) / 182.04166666666666;
Character.Position.packetxSec = Character.Position.xSec;
Character.Position.packetySec = Character.Position.ySec;
Character.Position.packetX = (ushort)Formule.gamex(Character.Position.x, Character.Position.xSec);
Character.Position.packetY = (ushort)Formule.gamex(Character.Position.y, Character.Position.ySec);
double Distance = Formule.gamedistance(Character.Position.x, Character.Position.y, Formule.gamex((float)Character.Position.packetX, Character.Position.xSec), Formule.gamey((float)Character.Position.packetY, Character.Position.ySec));
PacketWriter writer = new PacketWriter();
writer.Create(0xb021);
writer.DWord(Character.Information.UniqueID);
writer.Byte(0);
writer.Byte(Type);
writer.Word(Angle);
writer.Byte(1);
writer.Byte(Character.Position.xSec);
writer.Byte(Character.Position.ySec);
writer.Word(Character.Position.packetX);
writer.DWord(Character.Position.z);
writer.Word(Character.Position.packetY);
Send(writer.GetBytes());
Reader.Close();
StartSkyDromeTimer(1000);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Private Message Open
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public void PrivateMessageOpen()
{
try
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
/////////////////////////////////////////////////////////////////////////////////////
byte type = Reader.Byte();
short typeget = (short)type;
Reader.Close();
DB ms = new DB("SELECT * FROM message WHERE receiver='" + Character.Information.Name + "' AND idinfo ='" + typeget + "'");
using (SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
string messageinfo = reader.GetString(3);
client.Send(Packet.PrivateMessageOpen(type, messageinfo));
DB.query("UPDATE message SET status='1' WHERE receiver='" + Character.Information.Name + "' AND idinfo ='" + type + "'");
}
}
ms.Close();
}
catch (Exception ex)
{
Log.Exception(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 == 4)
{
//Send succes packet
client.Send(Packet.ConnectSuccess());
}
//If the login is wrong
else
{
//Disconnect the user
client.Disconnect(PacketInformation.Client);
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public void JoinFormedParty()
{
try
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Packet reader party id
int PartyID = Reader.Int32();
Reader.Close();
//Checks
if (PartyID == 0)
{
return;
}
//Get character id from the party id
int Playerid = Helpers.GetInformation.GetPartyleader(PartyID);
//Get character information
PlayerMgr sys = Helpers.GetInformation.GetPlayer(Playerid);
//Open the invite
sys.client.Send(Packet.JoinFormedRequest(Character, sys.Character));
}
catch (Exception ex)
{
Console.WriteLine("Formed party join error {0}", ex);
}
}
/////////////////////////////////////////////////////////////////////////
// Union Apply
/////////////////////////////////////////////////////////////////////////
public 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
PlayerMgr targetplayer = Helpers.GetInformation.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;
Character.State.UnionApply = true;
//Set target player to us
targetplayer.Character.Network.TargetID = Character.Information.UniqueID;
//Send request to targeted player
targetplayer.client.Send(Packet.PartyRequest(6, Character.Information.UniqueID, 0));
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
void CharacterJobPick(byte[] buff)
{
//Wrap our function inside a catcher
try
{
//Open packet reader
PacketReader Reader = new PacketReader(buff);
Reader.Skip(1);
short namel = Reader.Int16();
string name = Reader.String(namel);
byte job = Reader.Byte();
Reader.Close();
//Anti hack check
string namecheck = DB.GetData("SELECT name FROM character WHERE account='" + Player.AccountName + "'", "name");
int jobcheck = Convert.ToInt32(DB.GetData("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.Length > 0)
{
//Write new job info
DB.query("UPDATE users SET jobtype='" + job + "' WHERE id='" + Player.AccountName + "'");
}
//Send visual confirmation
client.Send(Packet.CharacterJobSelection());
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public void CharacterCheck(byte[] buff)
{
//Wrap our function into a catcher
try
{
//Open our reader
PacketReader Reader = new PacketReader(buff);
byte ignored = 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)
{
Log.Exception(ex);
}
}
public static void PlayerQuickBar(PacketWriter Writer, int ID)
{
PacketReader Reader = new PacketReader(System.IO.File.ReadAllBytes(Environment.CurrentDirectory + @"\PlayerData\Hotkey\" + ID + ".ClientSettings"));
byte amm = 0;
int[] skillid = new int[51];
byte[] slotn = new byte[51];
for (byte i = 0; i <= 50; i++)
{
slotn[i] = Reader.Byte();
if (slotn[i] != 0)
{
skillid[i] = Reader.Int32();
amm++;
}
else
{
Reader.Skip(4);
}
}
Writer.Byte(amm);
for (byte i = 0; i <= 50; i++)
{
if (slotn[i] != 0)
{
Writer.Byte(i);
Writer.Byte(slotn[i]);
Writer.DWord(skillid[i]);
}
}
Reader.Close();
}
/////////////////////////////////////////////////////////////////////////////////
// Add new friend
/////////////////////////////////////////////////////////////////////////////////
public 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;
}
PlayerMgr sys = Helpers.GetInformation.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);
Log.Exception(ex);
}
}
/////////////////////////////////////////////////////////////////////////////////
// Friend add response
/////////////////////////////////////////////////////////////////////////////////
public void FriendAddResponse()
{
try
{
PacketReader reader = new PacketReader(PacketInformation.buffer);
int Inviterid = reader.Int32();
int Myid = reader.Int32();
byte State = reader.Byte();
reader.Close();
PlayerMgr sys = Helpers.GetInformation.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));
DB.query("INSERT INTO friends (owner,friend_name,model_info) VALUES ('" + Character.Information.CharacterID + "','" + sys.Character.Information.CharacterID + "','" + sys.Character.Information.Model + "')");
DB.query("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);
Log.Exception(ex);
}
}
/////////////////////////////////////////////////////////////////////////////////
// Remove Friends
/////////////////////////////////////////////////////////////////////////////////
public void FriendRemoval()
{
try
{
//Read client packet data
PacketReader reader = new PacketReader(PacketInformation.buffer);
int target = reader.Int32();
reader.Close();
//Get player information
PlayerMgr sys = Helpers.GetInformation.GetPlayerid(target);
//Remove friend from our list query
DB.query("DELETE FROM friends WHERE owner='" + Character.Information.CharacterID + "' AND friend_name='" + target + "'");
DB.query("DELETE FROM friends WHERE owner='" + target + "' AND friend_name='" + Character.Information.CharacterID + "'");
//Remove friend from our list packet
client.Send(Packet.FriendData(target, 3, "", Character, false));
client.Send(Packet.FriendRemovalTarget(target));
//Remove friend from friend id packet
if (sys != null)
{
sys.Send(Packet.FriendData(sys.Character.Information.UniqueID, 3, "", Character, false));
}
}
catch (Exception ex)
{
Console.WriteLine("Friend removal error {0}", ex);
Log.Exception(ex);
}
}
/////////////////////////////////////////////////////////////////////////////////
// Open Npc
/////////////////////////////////////////////////////////////////////////////////
public 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)
{
Log.Exception(ex);
}
#endregion
}
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:
//WorldMgr.character creation
CharacterCreate();
break;
case 2:
//Character listening
CharacterListing();
break;
case 3:
//Character deletion
CharacterDelete();
break;
case 4:
//WorldMgr.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);
Disconnect("normal");
break;
}
//Close packet reader
Reader.Close();
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
///////////////////////////////////////////////////////////////////////////
// Despawn pets
///////////////////////////////////////////////////////////////////////////
public void UnSummonPet()
{
try
{
PacketReader reader = new PacketReader(PacketInformation.buffer);
int petid = reader.Int32();
reader.Close();
//First we close the pet by calling closepet void.
if (petid == Character.Grabpet.Grabpetid)
{
ClosePet(petid, Character.Grabpet.Details);
Character.Grabpet.Active = false;
Character.Grabpet.Spawned = false;
Character.Grabpet.Details = null;
}
else if (petid == Character.Attackpet.Uniqueid)
{
ClosePet(petid, Character.Attackpet.Details);
Character.Attackpet.Active = false;
Character.Attackpet.Spawned = false;
Character.Attackpet.Details = null;
}
//Update database information
DB.query("UPDATE pets SET pet_active='0' WHERE pet_unique='" + petid + "' AND playerid='" + Character.Information.CharacterID + "'");
//Set active to false so the user can spawn another pet.
Character.Grabpet.Active = false;
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public void PartyAddmembers()
{
try
{
//Create new packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Read target id
int targetid = Reader.Int32();
//Close packet reader
Reader.Close();
//Get detailed information from target
PlayerMgr InvitedPlayer = Helpers.GetInformation.GetPlayer(targetid);
//Check if the targeted player allready is in a party.
if (InvitedPlayer.Character.Network.Party == null)
{
//Set target id of target player to our id
InvitedPlayer.Character.Network.TargetID = this.Character.Information.UniqueID;
//Send request
InvitedPlayer.client.Send(Packet.PartyRequest(2, Character.Information.UniqueID, Character.Network.Party.Type));
}
}
//Write bad exception errors
catch (Exception ex)
{
//Write error to the console.
Console.WriteLine(ex);
//Write error to the debug log
}
}
public 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
PlayerMgr sys = Helpers.GetInformation.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.Message(OperationCode.SERVER_GUILD_WAIT, Messages.UIIT_MSG_GUILDERR_MEMBER_OF_ANOTHER_GUILD));
return;
}
//If player has to wait before the player can join another guild
if (sys.Character.Information.GuildPenalty)
{
client.Send(Packet.Message(OperationCode.SERVER_GUILD_WAIT, Messages.UIIT_MSG_GUILD_PENALTY));
return;
}
//If the guild has max members
if (Character.Network.Guild.TotalMembers >= Character.Network.Guild.MaxMembers)
{
client.Send(Packet.Message(OperationCode.SERVER_GUILD_WAIT, Messages.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)
{
Log.Exception(ex);
}
}
void RecieveMessage(byte[] message, int messageSize)
{
PacketReader pr = new PacketReader(message);
if (packetHandlers.ContainsKey(pr.header))
packetHandlers[pr.header].HandlePacket(pr);
else
Debug.Log("wrong packet");
pr.Close();
}
void restart()
{
youLoseSound.Play();
deterministicGame.currentLevel.gameRestart = false;
graphics.PreferredBackBufferHeight = 600;
graphics.PreferredBackBufferWidth = 800;
graphics.ApplyChanges();
musicControl.Restart();
// Make the game object. The game is currently called 'DuckSlaughterGame'
deterministicGame = new DuckSlaughterGame();
deterministicGame.ResetGame(playerIdentifiers, playerIdentifiers[0]);
deterministicGame.LoadContent(Content);
deterministicGame.Initialize();
// Debugging setup
lastPressedKeys = new List <Keys>();
activePlayer = playerIdentifiers[0];
paused = false;
gameStarted = false;
//Added
isHost = false;
chatText = "";
reader.Close();
writer.Close();
networkSession.Dispose();
networkSession = null;
reader = new PacketReader();
writer = new PacketWriter();
chatlines = 0;
isChatting = false;
mouseChange = false;
buttonPressed = false;
others = new player[4];
update = true;
gameStarted = false;
inMenu = true;
startS.Show();
helpS.Hide();
activeS = startS;
releasedKeys = new List <Keys>();
}
public void Save()
{
//Wrap our function inside a catcher
try
{
//Open our packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
string player_path;
byte[] file;
//Switch on byte
switch (Reader.Byte())
{
case 1:
//Save quickbar information
player_path = Environment.CurrentDirectory + @"\PlayerData\Hotkey\" + Character.Information.CharacterID + ".ClientSettings";
file = System.IO.File.ReadAllBytes(player_path);
byte Slot = Reader.Byte();
byte sType = Reader.Byte();
Slot *= 5;
file[Slot] = sType;
file[Slot + 1] = Reader.Byte();
file[Slot + 2] = Reader.Byte();
file[Slot + 3] = Reader.Byte();
file[Slot + 4] = Reader.Byte();
System.IO.File.WriteAllBytes(player_path, file);
break;
case 2:
//Save autopotion information
player_path = Environment.CurrentDirectory + @"\PlayerData\AutoPotion\" + Character.Information.CharacterID + ".ClientSettings";
file = System.IO.File.ReadAllBytes(player_path);
file[0] = Reader.Byte();
file[1] = Reader.Byte();
file[2] = Reader.Byte();
file[3] = Reader.Byte();
file[4] = Reader.Byte();
file[5] = Reader.Byte();
file[6] = Reader.Byte();
System.IO.File.WriteAllBytes(player_path, file);
UpdateHp();
UpdateMp();
break;
}
Reader.Close();
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
pr.Close();
pw.Close();
st.Close();
socket.Close();
receiveQueue.Dispose();
transmitQueue.Dispose();
}
}
private void netSession_GamerLeft(object sender, GamerLeftEventArgs e)
{
if (e.Gamer.IsLocal)
{
_netSession.Dispose();
_netSession = null;
_hasLeft = true;
_remoteMapName = "";
_packetReader.Close();
_packetWriter.Close();
}
}
public static void PlayerAutoPot(PacketWriter Writer, int ID)
{
PacketReader Reader = new PacketReader(System.IO.File.ReadAllBytes(Environment.CurrentDirectory + @"\PlayerData\AutoPotion\" + ID + ".ClientSettings"));
Writer.Byte(Reader.Byte());
Writer.Byte(Reader.Byte());
Writer.Byte(Reader.Byte());
Writer.Byte(Reader.Byte());
Writer.Byte(Reader.Byte());
Writer.Byte(Reader.Byte());
Writer.Byte(Reader.Byte());
Reader.Close();
}
public 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
PlayerMgr NewLeader = Helpers.GetInformation.GetPlayerid(GuildMemberID);
//Update database
DB.query("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 + "'");
DB.query("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
PlayerMgr guildmember = Helpers.GetInformation.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(OperationCode.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)
{
Log.Exception(ex);
}
}
/// <summary>
/// Сюда будут приходить готовые пакеты.
/// </summary>
/// <param name="message"></param>
/// <param name="size"></param>
private void MessageHandler(RemoteClient client, byte[] buffer, int size)
{
PacketReader pr = new PacketReader(buffer);
if (packetHandlers.ContainsKey(pr.header))
{
packetHandlers[pr.header].HandlePacket(client, pr);
}
else
{
Debug.Log("wrong packet");
}
pr.Close();
}
private static void Handler(PacketReader reader)
{
ushort id = reader.ReadByte();
if (id == (ushort)RoomMessage.Info)
{
string name = reader.ReadUnicode(20);
string pwd = reader.ReadUnicode(32);
lock (Infos)
{
Infos[name] = pwd;
}
}
reader.Close();
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Private Message Send
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public void PrivateMessageSend()
{
try
{
/////////////////////////////////////////////////////////////////////////////////////
PacketReader Reader = new PacketReader(PacketInformation.buffer);
/////////////////////////////////////////////////////////////////////////////////////
short touser = Reader.Int16();
string tousername = Reader.String(touser);
short messagel = Reader.Int16();
string message = Reader.String(messagel);
Reader.Close();
/////////////////////////////////////////////////////////////////////////////////////
int count = DB.GetRowsCount("SELECT * FROM character WHERE name='" + tousername + "'");
int charid = Convert.ToInt32(Convert.ToInt32(DB.GetData("SELECT id FROM character WHERE name='" + tousername + "'", "id")));
/////////////////////////////////////////////////////////////////////////////////////
if (count == 0)//Check username
{
client.Send(Packet.PrivateMessageMsg(1));
return;
}
if (count > 0)//Excisting username
{
DB ms = new DB("SELECT * FROM message WHERE receiver='" + tousername + "' ORDER BY idinfo DESC");
int msgcount = ms.Count();
PlayerMgr sys = Helpers.GetInformation.GetPlayerMainid(charid);
if (msgcount == 0)
{
DB.query("INSERT INTO message (sender, receiver, message, status, time, idinfo) VALUES ('" + Character.Information.Name + "','" + tousername + "','" + message + "','0','10/10/2010 12:00:00 AM','0')");
client.Send(Packet.PrivateMessageMsg(2));
sys.Send(Packet.FriendData(sys.Character.Information.UniqueID, 5, tousername, Character, false));
}
if (msgcount > 0)
{
int messagenewid = msgcount + 1;
DB.query("INSERT INTO message (sender, receiver, message, status, time, idinfo) VALUES ('" + Character.Information.Name + "','" + tousername + "','" + message + "','0','10/10/2010 12:00:00 AM','" + Convert.ToByte(messagenewid) + "')");
client.Send(Packet.PrivateMessageMsg(2));
sys.Send(Packet.FriendData(sys.Character.Information.UniqueID, 5, tousername, Character, false));
}
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public void GuildWarGold()
{
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
}
}
public 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
DB.query("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
PlayerMgr characterinformation = Helpers.GetInformation.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)
{
Log.Exception(ex);
}
}
public void SelectObject()
{
try
{
if (Character.Information.Scroll)
{
return;
}
PacketReader Reader = new PacketReader(PacketInformation.buffer);
int objectid = Reader.Int32();
if (objectid == 0)
{
return;
}
//Character.Action.Target = objectid;
//if (Character.Position.Walking) StopPlayerMovementO(objectid);
if (objectid == Character.Information.UniqueID)
{
return;
}
WorldMgr.Monsters o = Helpers.GetInformation.GetObject(objectid);
if (o != null)
{
byte[] bb = Packet.SelectObject(objectid, o.ID, o.LocalType, o.HP);
if (bb == null)
{
return;
}
client.Send(bb);
//Character.Action.Object = o;
return;
}
PlayerMgr sys = Helpers.GetInformation.GetPlayers(objectid);
if (o == null && sys != null)
{
client.Send(Packet.SelectObject(objectid, 0, 5, sys.Character.Stat.Hp));
Character.Action.Object = sys;
return;
}
Reader.Close();
}
catch (Exception ex)
{
Console.WriteLine("Selectobject error: {0}", 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);
}
}
void GuildInvite()
{
//Wrap our code into a catcher
try
{
//Open our packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
Int16 dLen = Reader.Int16();
string invitename = Reader.String(dLen);
Reader.Close();
//Get information for target
Systems sys = GetPlayerName(invitename);
//Set targetid information
Character.Network.TargetID = sys.Character.Information.UniqueID;
//If player allready has a guild
if (sys.Character.Network.Guild.Guildid != 0)
{
//Add message here
return;
}
//Set targetid to the invited player
sys.Character.Network.TargetID = Character.Information.UniqueID;
//Send guild request packet
sys.client.Send(Packet.P_Request(5, Character.Information.UniqueID, 0));
//Set bools active
Character.State.GuildInvite = true;
sys.Character.State.GuildInvite = true;
}
catch (Exception ex)
{
Console.WriteLine("Guild invite error {0}", ex);
Log.Exception(ex);
}
}
KeyValuePair<TransferBuffer, Packet> GetPacketToSend()
{
if (m_outgoing_packets.Count == 0)
{
throw (new Exception("[SecurityAPI::GetPacketToSend] No packets are avaliable to send."));
}
Packet packet = m_outgoing_packets[0];
m_outgoing_packets.RemoveAt(0);
if (packet.Massive)
{
PacketWriter final = null;
PacketWriter final_data = null;
byte[] raw_bytes = null;
PacketReader input_reader = null;
PacketWriter final_header = null;
try
{
ushort parts = 0;
final = new PacketWriter();
final_data = new PacketWriter();
byte[] input_data = packet.GetBytes();
input_reader = new PacketReader(input_data);
TransferBuffer workspace = new TransferBuffer(4089, 0, (int)input_data.Length);
while (workspace.Size > 0)
{
PacketWriter part_data = null;
try
{
part_data = new PacketWriter();
int cur_size = workspace.Size > 4089 ? 4089 : workspace.Size; // Max buffer size is 4kb for the client
part_data.Write((byte)0); // Data flag
part_data.Write(input_data, workspace.Offset, cur_size);
workspace.Offset += cur_size;
workspace.Size -= cur_size; // Update the size
final_data.Write(FormatPacket(0x600D, part_data.GetBytes(), false));
++parts; // Track how many parts there are
}
finally
{
if (part_data != null)
{
part_data.Close();
}
}
}
// Write the final header packet to the front of the packet
final_header = new PacketWriter();
final_header.Write((byte)1); // Header flag
final_header.Write((short)parts);
final_header.Write(packet.Opcode);
final.Write(FormatPacket(0x600D, final_header.GetBytes(), false));
// Finish the large packet of all the data
final.Write(final_data.GetBytes());
// Return the collated data
raw_bytes = final.GetBytes();
}
finally
{
if (final != null)
{
final.Close();
}
if (final_data != null)
{
final_data.Close();
}
if (input_reader != null)
{
input_reader.Close();
}
if (final_header != null)
{
final_header.Close();
}
}
packet.Lock();
return new KeyValuePair<TransferBuffer, Packet>(new TransferBuffer(raw_bytes, 0, raw_bytes.Length, true), packet);
}
else
{
bool encrypted = packet.Encrypted;
if (!m_client_security)
{
if (m_enc_opcodes.Contains(packet.Opcode))
{
encrypted = true;
}
}
byte[] raw_bytes = FormatPacket(packet.Opcode, packet.GetBytes(), encrypted);
packet.Lock();
return new KeyValuePair<TransferBuffer, Packet>(new TransferBuffer(raw_bytes, 0, raw_bytes.Length, true), packet);
}
}
// Transfers raw incoming data into the security object. Call TransferIncoming to
// obtain a list of ready to process packets.
public void Recv(TransferBuffer raw_buffer)
{
List<TransferBuffer> incoming_buffers_tmp = new List<TransferBuffer>();
lock (m_class_lock)
{
int length = raw_buffer.Size - raw_buffer.Offset;
int index = 0;
while (length > 0)
{
int max_length = length;
int calc_length = m_recv_buffer.Buffer.Length - m_recv_buffer.Size;
if (max_length > calc_length)
{
max_length = calc_length;
}
length -= max_length;
Buffer.BlockCopy(raw_buffer.Buffer, raw_buffer.Offset + index, m_recv_buffer.Buffer, m_recv_buffer.Size, max_length);
m_recv_buffer.Size += max_length;
index += max_length;
// Loop while we have data to process
while (m_recv_buffer.Size > 0)
{
// If we do not have a current packet object, try to allocate one.
if (m_current_buffer == null)
{
// We need at least two bytes to allocate a packet.
if (m_recv_buffer.Size < 2)
{
break;
}
// Calculate the packet size.
int packet_size = m_recv_buffer.Buffer[1] << 8 | m_recv_buffer.Buffer[0];
// Check to see if this packet is encrypted.
if ((packet_size & 0x8000) > 0)
{
// If so, calculate the total payload size.
packet_size &= 0x7FFF; // Mask off the encryption.
if (m_security_flags.blowfish == 1)
{
packet_size = 2 + m_blowfish.GetOutputLength(packet_size + 4);
}
else
{
packet_size += 6;
}
}
else
{
// The packet is unencrypted. The final size is simply
// header size + payload size.
packet_size += 6;
}
// Allocate the final buffer the packet will be written to
m_current_buffer = new TransferBuffer(packet_size, 0, packet_size);
}
// Calculate how many bytes are left to receive in the packet.
int max_copy_count = m_current_buffer.Size - m_current_buffer.Offset;
// If we need more bytes than we currently have, update the size.
if (max_copy_count > m_recv_buffer.Size)
{
max_copy_count = m_recv_buffer.Size;
}
// Copy the buffer data to the packet buffer
Buffer.BlockCopy(m_recv_buffer.Buffer, 0, m_current_buffer.Buffer, m_current_buffer.Offset, max_copy_count);
// Update how many bytes we now have
m_current_buffer.Offset += max_copy_count;
m_recv_buffer.Size -= max_copy_count;
// If there is data remaining in the buffer, copy it over the data
// we just removed (sliding buffer).
if (m_recv_buffer.Size > 0)
{
Buffer.BlockCopy(m_recv_buffer.Buffer, max_copy_count, m_recv_buffer.Buffer, 0, m_recv_buffer.Size);
}
// Check to see if the current packet is now complete.
if (m_current_buffer.Size == m_current_buffer.Offset)
{
// If so, dispatch it to the manager class for processing by the system.
m_current_buffer.Offset = 0;
incoming_buffers_tmp.Add(m_current_buffer);
// Set the current packet to null so we can process the next packet
// in the stream.
m_current_buffer = null;
}
else
{
// Otherwise, we are done with this loop, since we need more
// data for the current packet.
break;
}
}
}
if (incoming_buffers_tmp.Count > 0)
{
foreach (TransferBuffer buffer in incoming_buffers_tmp)
{
PacketReader packet_data = null;
try
{
bool packet_encrypted = false;
int packet_size = buffer.Buffer[1] << 8 | buffer.Buffer[0];
if ((packet_size & 0x8000) > 0)
{
if (m_security_flags.blowfish == 1)
{
packet_size &= 0x7FFF;
packet_encrypted = true;
}
else
{
packet_size &= 0x7FFF;
}
}
if (packet_encrypted)
{
byte[] decrypted = m_blowfish.Decode(buffer.Buffer, 2, buffer.Size - 2);
byte[] new_buffer = new byte[6 + packet_size];
Buffer.BlockCopy(BitConverter.GetBytes((ushort)packet_size), 0, new_buffer, 0, 2);
Buffer.BlockCopy(decrypted, 0, new_buffer, 2, 4 + packet_size);
buffer.Buffer = null;
buffer.Buffer = new_buffer;
}
packet_data = new PacketReader(buffer.Buffer);
packet_size = packet_data.ReadUInt16();
ushort packet_opcode = packet_data.ReadUInt16();
byte packet_security_count = packet_data.ReadByte();
byte packet_security_crc = packet_data.ReadByte();
// Client object whose bytes the server might need to verify
if (m_client_security)
{
if (m_security_flags.security_bytes == 1)
{
byte expected_count = GenerateCountByte(true);
if (packet_security_count != expected_count)
{
throw (new Exception("[SecurityAPI::Recv] Count byte mismatch."));
}
if (packet_encrypted || (m_security_flags.security_bytes == 1 && m_security_flags.blowfish == 0))
{
if (packet_encrypted || m_enc_opcodes.Contains(packet_opcode))
{
packet_size |= 0x8000;
Buffer.BlockCopy(BitConverter.GetBytes((ushort)packet_size), 0, buffer.Buffer, 0, 2);
}
}
buffer.Buffer[5] = 0;
byte expected_crc = GenerateCheckByte(buffer.Buffer);
if (packet_security_crc != expected_crc)
{
throw (new Exception("[SecurityAPI::Recv] CRC byte mismatch."));
}
buffer.Buffer[4] = 0;
if (packet_encrypted || (m_security_flags.security_bytes == 1 && m_security_flags.blowfish == 0))
{
if (packet_encrypted || m_enc_opcodes.Contains(packet_opcode))
{
packet_size &= 0x7FFF;
Buffer.BlockCopy(BitConverter.GetBytes((ushort)packet_size), 0, buffer.Buffer, 0, 2);
}
}
}
}
if (packet_opcode == 0x5000 || packet_opcode == 0x9000) // New logic processing!
{
Handshake(packet_opcode, packet_data, packet_encrypted);
// Pass the handshake packets to the user so they can at least see them.
// They do not need to actually do anything with them. This was added to
// help debugging and make output logs complete.
//CA2000 dont care
Packet packet = new Packet(packet_opcode, packet_encrypted, false, buffer.Buffer, 6, packet_size);
packet.Lock();
m_incoming_packets.Add(packet);
}
else
{
if (m_client_security)
{
// Make sure the client accepted the security system first
if (!m_accepted_handshake)
{
throw (new Exception("[SecurityAPI::Recv] The client has not accepted the handshake."));
}
}
if (packet_opcode == 0x600D) // Auto process massive messages for the user
{
byte mode = packet_data.ReadByte();
if (mode == 1)
{
m_massive_count = packet_data.ReadUInt16();
ushort contained_packet_opcode = packet_data.ReadUInt16();
m_massive_packet = new Packet(contained_packet_opcode, packet_encrypted, true);
}
else
{
if (m_massive_packet == null)
{
throw (new Exception("[SecurityAPI::Recv] A malformed 0x600D packet was received."));
}
m_massive_packet.WriteUInt8Array(packet_data.ReadBytes(packet_size - 1));
m_massive_count--;
if (m_massive_count == 0)
{
m_massive_packet.Lock();
m_incoming_packets.Add(m_massive_packet);
m_massive_packet = null;
}
}
}
else
{
//CA2000 dont care
Packet packet = new Packet(packet_opcode, packet_encrypted, false, buffer.Buffer, 6, packet_size);
packet.Lock();
m_incoming_packets.Add(packet);
}
}
}
finally
{
if (packet_data != null)
{
packet_data.Close();
}
}
}
}
}
}
/////////////////////////////////////////////////////////////////////////
//Guild War
/////////////////////////////////////////////////////////////////////////
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)
{
Log.Exception(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);
}
}
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)
{
client.Send(Packet.ErrorMsg(SERVER_GUILD_PROMOTE_MSG, ErrorMsg.UIIT_MSG_GUILD_LACK_GP));
return;
}
//Open our packet reader
PacketReader reader = new PacketReader(PacketInformation.buffer);
int donatedgp = reader.Int32();
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;
//First we write our base information to use
Character.Network.Guild.PointsTotal += donatedgp;
Character.Information.SkillPoint -= donatedgp;
//Save our information (Skill points).
SavePlayerInfo();
//Update database information
DB.query("UPDATE guild SET guild_points='" + totalgp + "' WHERE guild_name='" + Character.Network.Guild.Name + "'");
//Update packets for each member in the guild
//Send packets to donator.
client.Send(Packet.InfoUpdate(1, totalgp, 0));
client.Send(Packet.GuildDonateGP(donatedgp));
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 packet only once
if (!guildmember.Character.Network.Guild.SingleSend)
{
//Set bool true so it only sends once
guildmember.Character.Network.Guild.SingleSend = true;
//Send packet data to the player
guildmember.client.Send(Packet.GuildUpdate(Character, 13, 0, 0, totalgp));
guildmember.client.Send(Packet.GuildUpdate(Character, 9, 0, 0, totalgp));
guildmember.LoadPlayerGuildInfo(false);
}
}
}
}
//Disable the bool again
foreach (int member in Character.Network.Guild.Members)
{
//Make sure member isnt null
if (member != 0)
{
//Get guildmember details
Systems guildmember = GetPlayerMainid(member);
//Make sure guildmember isnt null
if (guildmember != null)
{
//Disable bool to allow resend new packets.
guildmember.Character.Network.Guild.SingleSend = false;
}
}
}
}
catch (Exception ex)
{
Console.WriteLine("Donate GP Error {0}", ex);
Log.Exception(ex);
}
}
void GuildCreate()
{
try
{
//Extra check if user is allready in guild.
if (Character.Network.Guild.Guildid != 0) return;
//Read client packet ObjData.Manager.
PacketReader Reader = new PacketReader(PacketInformation.buffer);
int infoid = Reader.Int32();
short guildname = Reader.Int16();
string guildnameinfo = Reader.String(guildname);
string charactername = Character.Information.Name;
Reader.Close();
//Will write global class for special chars later.
if (guildnameinfo.Contains("[")) return;
if (guildnameinfo.Contains("]")) return;
if (guildnameinfo.Contains("(")) return;
if (guildnameinfo.Contains(")")) return;
if (guildnameinfo.Contains("@")) return;
if (guildnameinfo.Contains("#")) return;
if (guildnameinfo.Contains("$")) return;
if (guildnameinfo.Contains("^")) return;
if (guildnameinfo.Contains("&")) return;
if (guildnameinfo.Contains("*")) return;
if (guildnameinfo.Contains("+")) return;
if (guildnameinfo.Contains("=")) return;
if (guildnameinfo.Contains("~")) return;
if (guildnameinfo.Contains("`")) return;
//Check length lower are 4 return
if (guildnameinfo.Length < 4) return;
//Check if guild name is taken or not.
int guildcheckname = DB.GetRowsCount("SELECT * FROM guild WHERE guild_name='" + guildnameinfo + "'");
//If name excists
if (guildcheckname == 1)
{
//Need to sniff packet
return;
}
//Set the gold requirements 500.000 retail info
int goldrequired = 500000;
//If character level is to low
if (Character.Information.Level < 20)
{
client.Send(Packet.GuildCreateLow());
return;
}
//If gold is lower then price of creating a guild
else if (Character.Information.Gold < goldrequired)
{
client.Send(Packet.ErrorMsg(SERVER_GUILD, ErrorMsg.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
DB.query("INSERT INTO guild (guild_name, guild_level, guild_points, guild_news_t, guild_news_m, guild_members_t, guild_master_id) VALUES ('" + guildnameinfo + "','1','0','" + "" + "','" + "" + "','1','" + Character.Information.CharacterID + "')");
//Get guild id
string guildid = DB.GetData("SELECT id FROM guild WHERE guild_name='" + guildnameinfo + "'", "id");
int docount = Convert.ToInt32(guildid);
//Insert member into database
DB.query("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(false);
//Private packet
client.Send(Packet.Guild_Create(Character.Network.Guild));
//Public spawn packet
Send(Packet.SendGuildInfo2(Character));
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
/////////////////////////////////////////////////////////////////////////
//Guild Permissions
/////////////////////////////////////////////////////////////////////////
void GuildPermissions()
{
try
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
Reader.Byte();
int memberid = Reader.Int32();
byte permissions = (byte)Reader.Int32();
char[] bits = new char[8];
for (int i = 0; i < 8; ++i) bits[i] = (char)0;
bits = Convert.ToString(permissions, 2).ToCharArray();
Reader.Close();
// set the amount to the target player :)
int targetindex = Character.Network.Guild.MembersInfo.FindIndex(i => i.MemberID == memberid);
if (Character.Network.Guild.MembersInfo[targetindex].Online)
{
Systems member = GetPlayerMainid(memberid);
// so here we can set chars right
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)
{
int index = Character.Network.Guild.MembersInfo.FindIndex(i => i.MemberID == m);
if (Character.Network.Guild.MembersInfo[index].Online)
{
Systems sys = Helpers.GetInformation.GetPlayerMainid(m);
// here comes the messy way
Global.guild_player mygp = new Global.guild_player();
int myindex = 0;
foreach (Global.guild_player gp in sys.Character.Network.Guild.MembersInfo)
{
if (gp.MemberID == memberid)
{
mygp = gp; //
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;
}
myindex++;
}
sys.Character.Network.Guild.MembersInfo[myindex] = mygp;
}
}
DB.query("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 + "'");
Character.Network.Guild.Send(Packet.GuildUpdate(Character, 4, 0, permissions, 0));
}
catch (Exception ex)
{
Console.WriteLine("Guild permission error: {0}", ex);
Log.Exception(ex);
}
}
void GuildMessage()
{
//Wrap our function inside a catcher
try
{
//Start reading packet data
PacketReader Reader = new PacketReader(PacketInformation.buffer);
short TitleL = Reader.Int16();
string Title = Reader.String(TitleL);
short MessageL = Reader.Int16();
string Message = Reader.String(MessageL);
Reader.Close();
//Update database guild message title
DB.query("UPDATE guild SET guild_news_t='" + Title + "' WHERE guild_name='" + Character.Network.Guild.Name + "'");
//Update database guild message
DB.query("UPDATE guild SET 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;
//Send news update to all members currently online
Character.Network.Guild.Send(Packet.GuildUpdate(Character, 11, 0, 0, 0));
}
catch (Exception ex)
{
Console.WriteLine("Guild Message Error: {0}", ex);
Log.Exception(ex);
}
}
void GuildPromote()
{
try
{
//Read client information int32 id
PacketReader reader = new PacketReader(PacketInformation.buffer);
int guildid = reader.Int32();
reader.Close();
//Incase of hacking attempt :)
if (Character.Network.Guild.Level == 5) return;
//Define int's to use
int goldneeded;
int guildpoints;
bool promoting = false;
if (!promoting)
{
LoadPlayerGuildInfo(false);
promoting = true;
switch (Character.Network.Guild.Level)
{
case 1:
goldneeded = 3000000;
guildpoints = 5400;
break;
case 2:
goldneeded = 9000000;
guildpoints = 50400;
break;
case 3:
goldneeded = 15000000;
guildpoints = 135000;
break;
case 4:
goldneeded = 21000000;
guildpoints = 378000;
break;
default:
return;
}
int changelevel = Character.Network.Guild.Level + 1;
int storageslots = Character.Network.Guild.StorageSlots + 30;
if (Character.Information.Gold < goldneeded)
{
client.Send(Packet.ErrorMsg(SERVER_GUILD_PROMOTE_MSG, ErrorMsg.UIIT_MSG_ERROR_GUILD_LEVEL_UP_GOLD_DEFICIT));
return;
}
//Not enough guildpoints
if (Character.Network.Guild.PointsTotal < guildpoints)
{
client.Send(Packet.ErrorMsg(SERVER_GUILD_PROMOTE_MSG, ErrorMsg.UIIT_MSG_ERROR_GUILD_LEVEL_UP_GP_DEFICIT));
}
//Max level
if (Character.Network.Guild.Level == 5)
{
client.Send(Packet.ErrorMsg(SERVER_GUILD_PROMOTE_MSG, ErrorMsg.UIIT_MSG_ERROR_GUILD_LEVEL_UP_FULL));
return;
}
else
//Upgrade guild initiate
{
//If max level return just incase.
if (Character.Network.Guild.Level == 5) return;
//Reduct guildpoints
Character.Network.Guild.PointsTotal -= guildpoints;
//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 -= goldneeded;
client.Send(Packet.InfoUpdate(1, Character.Network.Guild.PointsTotal, 0));
client.Send(Packet.GuildPromoteMsgS());
//Update guild in database
DB.query("UPDATE guild SET guild_level='" + changelevel + "',guild_points='" + Character.Network.Guild.PointsTotal + "',guild_storage_slots='" + storageslots + "' WHERE guild_name='" + Character.Network.Guild.Name + "'");
//Send Guild Packets
foreach (int member in Character.Network.Guild.Members)
{
if (member != 0)
{
Systems memberinfo = GetPlayerMainid(member);
if (memberinfo != null)
{
memberinfo.LoadPlayerGuildInfo(false);
memberinfo.client.Send(Packet.GuildUpdate(Character, 5, 0, 0, 0));
}
}
}
// save
SaveGold();
client.Send(Packet.UpdateGold(Character.Information.Gold));
}
}
promoting = false;
}
catch (Exception ex)
{
Console.WriteLine("Guild Promote Error: {0}", ex);
Log.Exception(ex);
}
}
void GuildRemove()
{
//Wrap our function inside a catcher
try
{
//Open our packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
short UserL = Reader.Int16();
string User = Reader.String(UserL);
Reader.Close();
//Define new count for database check
//Get player information
Systems sys = GetPlayerName(User);
//Send required packets to network
foreach (int member in Character.Network.Guild.Members)
{
//Make sure member s not null
if (member != 0)
{
//Get information for the guildmember
Systems guildmember = GetPlayerMainid(member);
//Make sure the guildmember isnt null
if (guildmember != null)
{
//Make sure the kicked member does not receive the packet
if (guildmember.Character.Information.CharacterID != sys.Character.Information.CharacterID)
{
//Bool check single send packet
if (!guildmember.Character.Network.Guild.SingleSend)
{
//Send update packet
guildmember.client.Send(Packet.GuildUpdate(sys.Character, 7, 0, 0, 0));
guildmember.Character.Network.Guild.SingleSend = true;
}
}
}
}
}
//Send update packet to the kicked player
sys.client.Send(Packet.GuildUpdate(sys.Character, 7, 0, 0, 0));
sys.client.Send(Packet.GuildKickMsg());
sys.Send(Packet.GuildKick(sys.Character.Information.UniqueID));
//Minus 1 count for new database info
int getmembercount = Convert.ToInt32(DB.GetData("SELECT guild_members_t FROM guild WHERE guild_name='" + Character.Network.Guild.Name + "'", "guild_members_t"));
int newmembercount = getmembercount - 1;
//Update database
DB.query("UPDATE guild SET guild_members_t='" + newmembercount + "' WHERE guild_name='" + Character.Network.Guild.Name + "'");
//Remove the player from database
DB.query("DELETE from guild_members where guild_member_id='" + sys.Character.Information.CharacterID + "'");
//Disable bool
foreach (int member in Character.Network.Guild.Members)
{
if (member != 0)
{
Systems guildmember = GetPlayerMainid(member);
if (guildmember != null)
{
guildmember.LoadPlayerGuildInfo(false);
guildmember.Character.Network.Guild.SingleSend = false;
}
}
}
//Final updates
if (Character.Network.Guild.UniqueUnion != 0)
{
Character.Network.Guild.UnionActive = false;
Character.Network.Guild.UnionMembers.Remove(Character.Information.CharacterID);
}
Character.Network.Guild.Members.Remove(sys.Character.Information.UniqueID);
Character.Network.Guild.MembersClient.Remove(sys.client);
sys.Character.Network.Guild.Guildid = 0;
}
catch (Exception ex)
{
Console.WriteLine("Guild Kick Error: {0}", ex);
Log.Exception(ex);
}
}
void GuildTitle()
{
//Wrap our function inside a catcher
try
{
//Extra hack check
if (Character.Network.Guild.Level < 4) return;
//Open our packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
int Selecteduser = Reader.Int32();
short TitleL = Reader.Int16();
string Title = Reader.String(TitleL);
Reader.Close();
//Get character information
Systems playerinfo = GetPlayerMainid(Selecteduser);
//Make sure the user is still there
if (playerinfo.Character != null)
{
//Update database set new title
DB.query("UPDATE guild_members SET guild_grant='" + Title + "' WHERE guild_member_id='" + playerinfo.Character.Information.CharacterID + "'");
//Send title update to send list
Send(Packet.GuildSetTitle(Character.Guild.GuildID, playerinfo.Character.Information.Name, Title));
//Send Final packet to client
client.Send(Packet.GuildSetTitle2(Character.Guild.GuildID, Selecteduser, Title));
}
foreach (int member in Character.Network.Guild.Members)
{
if (member != 0)
{
Systems getplayer = GetPlayerMainid(member);
if (getplayer != null)
{
getplayer.LoadPlayerGuildInfo(false);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine("Guild Title Error: {0}", ex);
Log.Exception(ex);
}
}
void client_Received(object sender, xDataReceivedEventArgs e)
{
ChatClient client = sender as ChatClient;
PacketReader r = new PacketReader(e.Data, false);
switch (e.Header)
{
case ChatClient.Header.USERNAME:
online++;
Invoke((MethodInvoker)delegate
{
lstUsers.Columns[0].Text = "Online (" + online.ToString() + ")";
string _username = r.ReadString();
lstUsers.Items.Add(_username);
if (blocked.Contains(_username))
lstUsers.Items[lstUsers.Items.Count - 1].ForeColor = Color.Red;
lstUsers.Sort();
WriteToChat(_username + ": Connected", Color.Green);
if (connectToolStripMenuItem.Checked)
{
GlobalProperties.SoundPlayer.Stream = Properties.Resources.beep_1;
GlobalProperties.SoundPlayer.Play();
}
});
break;
case ChatClient.Header.USERS:
List<string> usernames = new List<string>();
int len = r.ReadInt32();
for (int i = 0; i < len; i++)
{
usernames.Add(r.ReadString());
}
usernames.Sort();
Invoke((MethodInvoker)delegate
{
lstUsers.Items.Clear();
});
foreach (string name in usernames)
{
Invoke((MethodInvoker)delegate
{
lstUsers.Items.Add(name);
if (blocked.Contains(name))
lstUsers.Items[lstUsers.Items.Count - 1].ForeColor = Color.Red;
});
}
online = usernames.Count;
Invoke((MethodInvoker)delegate
{
lstUsers.Columns[0].Text = "Online (" + online.ToString() + ")";
});
break;
case ChatClient.Header.MESSAGE:
string username = r.ReadString();
string message = r.ReadString();
int bLen = r.ReadInt32();
for (int i = 0; i < bLen; i++)
{
if (GlobalProperties.Client.Username == r.ReadString())
{
r.Close();
return;
}
}
if (blocked.Contains(username))
break;
if (soundOnSentReceivedToolStripMenuItem.Checked)
{
GlobalProperties.SoundPlayer.Stream = Properties.Resources.IM08;
GlobalProperties.SoundPlayer.Play();
}
StringBuilder sb = new StringBuilder();
sb.Append(username + ": " + message);
Invoke((MethodInvoker)delegate
{
WriteToChat(sb.ToString(), Color.Black);
});
break;
case ChatClient.Header.LEFT:
string leftName = r.ReadString();
online--;
for (int i = 0; i < lstUsers.Items.Count; i++)
{
Invoke((MethodInvoker)delegate
{
if (lstUsers.Items[i].Text == leftName)
{
lstUsers.Items.RemoveAt(i);
lstUsers.Columns[0].Text = "Online (" + online.ToString() + ")";
r.Close();
WriteToChat(leftName + ": Disconnected", Color.Red);
if (disconnectToolStripMenuItem.Checked)
{
GlobalProperties.SoundPlayer.Stream = Properties.Resources.boing_2;
GlobalProperties.SoundPlayer.Play();
}
return;
}
});
}
break;
case ChatClient.Header.PM:
string user = r.ReadString();
if (blocked.Contains(user))
break;
GlobalProperties.SoundPlayer.Stream = Properties.Resources.IM08;
GlobalProperties.SoundPlayer.Play();
string msg = r.ReadString();
Invoke((MethodInvoker)delegate
{
if (pmForms.ContainsKey(user))
{
if (!pmForms[user].IsDisposed)
pmForms[user].WriteToChat(msg, Color.Black);
}
else
{
PMForm newPM = new PMForm(user, client);
pmForms.Add(user, newPM);
newPM.Show();
newPM.WriteToChat(msg, Color.Black);
newPM.FormClosed += (s, E) =>
{
pmForms.Remove(user);
};
}
});
break;
}
r.Close();
}
void GuildTransferLeaderShip()
{
try
{
//Read packet data
PacketReader Reader = new PacketReader(PacketInformation.buffer);
int Guildid = Reader.Int32();
int Memberid = Reader.Int32();
Reader.Close();
//Grab the information of the player
Systems sys = GetPlayerid(Memberid);
//Update database
DB.query("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 + "'");
DB.query("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='" + Memberid + "'");
//Send required packets to network
foreach (int member in Character.Network.Guild.Members)
{
//Make sure member s not null
if (member != 0)
{
//Get information for the guildmember
Systems guildmember = GetPlayerMainid(member);
//Make sure the guildmember isnt null
if (guildmember != null)
{
//Bool check single send packet
if (!guildmember.Character.Network.Guild.SingleSend)
{
//Send update packet
guildmember.client.Send(Packet.GuildUpdate(Character, 3, Memberid, 0 , 0));
guildmember.LoadPlayerGuildInfo(false);
}
}
}
}
//Disable bool
foreach (int member in Character.Network.Guild.Members)
{
if (member != 0)
{
Systems guildmember = GetPlayerMainid(member);
if (guildmember != null)
{
guildmember.Character.Network.Guild.SingleSend = false;
}
}
}
//Send message to old owner
client.Send(Packet.GuildTransferMessage());
}
catch (Exception ex)
{
Console.WriteLine("Guild Transfer Error: {0}", ex);
Log.Exception(ex);
}
}
