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 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); } }