///////////////////////////////////////////////////////////////////////////////// // Item reinforce with stones ///////////////////////////////////////////////////////////////////////////////// public void AlchemyStoneMain() { try { PacketReader Reader = new PacketReader(PacketInformation.buffer); Character.Alchemy.ItemList = new List <ObjData.slotItem>(); byte type = Reader.Byte(); if (type == 1) { try { Character.Alchemy.AlchemyThread.Abort(); client.Send(Packet.AlchemyCancel()); } catch (Exception ex) { Log.Exception(ex); } } else if (type == 2) { Reader.Skip(1); byte numitem = Reader.Byte(); Character.Alchemy.ItemList.Add(GetItem((uint)Character.Information.CharacterID, Reader.Byte(), 0)); Character.Alchemy.ItemList.Add(GetItem((uint)Character.Information.CharacterID, Reader.Byte(), 0)); } Alchemy = new Timer(new TimerCallback(StartAlchemyStoneResponse), 0, 4500, 0); } catch (Exception ex) { Log.Exception(ex); } }
void Request() { try { PacketReader Reader = new PacketReader(PacketInformation.buffer); if (Reader.Byte() == 1 && Reader.Byte() == 0) { PlayerMgr sys = Helpers.GetInformation.GetPlayer(Character.Network.TargetID); sys.client.Send(Packet.Exchange_Cancel()); } else { PlayerMgr sys = Helpers.GetInformation.GetPlayer(Character.Network.TargetID); sys.client.Send(Packet.OpenExhangeWindow(1, Character.Information.UniqueID)); client.Send(Packet.OpenExhangeWindow(sys.Character.Information.UniqueID)); Character.Network.Exchange.Window = true; Character.Network.Exchange.ItemList = new List <ObjData.slotItem>(); sys.Character.Network.Exchange.Window = true; sys.Character.Network.Exchange.ItemList = new List <ObjData.slotItem>(); } } catch (Exception ex) { Log.Exception(ex); } }
public void RenameParty() { try { //Create new packet reader PacketReader reader = new PacketReader(PacketInformation.buffer); //First integer is party id int partyid = reader.Int32(); //Second integer is not needed int NotNeeded = reader.Int32(); //Byte party type byte ptype = reader.Byte(); //Byte party purpose byte purpose = reader.Byte(); //Byte minimum level byte minlevel = reader.Byte(); //Byte max level to enter party byte maxlevel = reader.Byte(); //Party name lenght short namel = reader.Int16(); //Party name each character is a word value using text3 string pname = reader.Text3(); //Create new packet writer PacketWriter Writer = new PacketWriter(); //Add opcode to server packet Writer.Create(OperationCode.SERVER_PARTY_CHANGENAME); //Write static byte 1 Writer.Byte(1); //Write party id Writer.DWord(partyid); //Write dword 0 Writer.DWord(0); //Write party type Writer.Byte(ptype); //Write party purpose Writer.Byte(purpose); //Write party minimum level Writer.Byte(minlevel); //Write party max level Writer.Byte(maxlevel); //Write party name Writer.Text3(pname); //Send bytes to client client.Send(Writer.GetBytes()); } //If a error happens catch (Exception ex) { //Write the exception to the log } }
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(); }
///////////////////////////////////////////////////////////////////////////////// // 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); } }
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); } }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // 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 MakeAlias() { try { /////////////////////////////////////////////////////////////////////////////////////////////////// PacketReader Reader = new PacketReader(PacketInformation.buffer); int id = Reader.Int32(); byte type = Reader.Byte(); short nLenght = Reader.Int16(); string name = Reader.String(nLenght); /////////////////////////////////////////////////////////////////////////////////////////////////// Console.WriteLine(name); DB ms = new DB("SELECT * FROM character_jobs WHERE job_alias='" + name + "'"); int checkjob = ms.Count(); /////////////////////////////////////////////////////////////////////////////////////////////////// client.Send(Packet.MakeAlias(name, type)); if (checkjob == 0) { client.Send(Packet.MakeAlias(name, type)); DB.query("UPDATE character_jobs SET job_alias='" + name + "' WHERE character_name='" + Character.Information.Name + "'"); } else if (checkjob >= 0) { client.Send(Packet.MakeAliasError(name, type)); } } catch (Exception 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 }
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); }
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); } }
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 JoinMerc() { try { DB ms = new DB("SELECT * FROM character_jobs WHERE character_name='" + Character.Information.Name + "'"); int checkjob = ms.Count(); if (checkjob == 0) { ///////////////////////////////////////////////////////////////////////////////////// PacketReader Reader = new PacketReader(PacketInformation.buffer); int id = Reader.Int32(); byte type = Reader.Byte(); ///////////////////////////////////////////////////////////////////////////////////// client.Send(Packet.InfoUpdate(1, Character.Information.CharacterID, 0)); client.Send(Packet.JoinMerchant(id, type)); ///////////////////////////////////////////////////////////////////////////////////// DB.query("INSERT INTO character_jobs (character_name, job_type) VALUES ('" + Character.Information.Name + "','2')"); ms.Close(); } else { // Not needed cant join job because excist } } 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); } }
/////////////////////////////////////////////////////////////////////////// // Grabpet settings /////////////////////////////////////////////////////////////////////////// public void GrabPetSettings() { //Not worked on yet. PacketReader Reader = new PacketReader(PacketInformation.buffer); int petid = Reader.Int32(); byte type = Reader.Byte(); int settingsinfo = Reader.Int32(); client.Send(Packet.ChangePetSettings(1, petid, type, settingsinfo)); }
public void Gameguide()//Will need to read this byte by byte to get the id for the server to record for the chardata { try { PacketReader Reader = new PacketReader(PacketInformation.buffer); bool Guideok = false; int[] b1 = new int[8]; for (int b = 0; b < 8; ++b) //Reads Guide Data { b1[b] = Reader.Byte(); //Puts into a int Array } for (int gc = 0; gc < 8; ++gc)//This Checks The Last Send Guide Paket To Make Sure The Same Packet Is Not Read Twice { if (b1[gc] == Character.Guideinfo.Gchk[gc]) { Guideok = false;//If Guide Packet Has Been Sent Will Return False } else { Guideok = true;//If Guide Packet Is New Will Retun True And Break break; } } if (Guideok) { for (int gc = 0; gc < 8; ++gc) // Guide Packet Check { Character.Guideinfo.Gchk[gc] = b1[gc]; //Adds Packet To Int Array } for (int gi = 0; gi < 8; ++gi) //Guide Packet Update For Save And Teleport,Return,Etc { Character.Guideinfo.G1[gi] = Character.Guideinfo.G1[gi] + b1[gi]; //Adds The Packet And Updates The Data } PacketWriter Writer = new PacketWriter(); //Writes the Packet Responce For Guide Window Writer.Create(OperationCode.SERVER_SEND_GUIDE); Writer.Byte(1); for (int b = 0; b < 8; ++b) { Writer.Byte(b1[b]); } client.Send(Writer.GetBytes()); } } catch (Exception ex) { Log.Exception(ex); } }
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(); }
//############################################################################## // Start timers voids //############################################################################## public void StartPvpTimer(int time) { //Need to add checks PacketReader reader = new PacketReader(PacketInformation.buffer); byte pvptype = reader.Byte(); if (Timer.Pvp != null) { Timer.Pvp.Dispose(); } Timer.Pvp = new Timer(new TimerCallback(Player_Pvp_CallBack), 0, time, 0); Send(Packet.PvpSystemWait(Character.Information.UniqueID)); Character.Information.PvpWait = true; Character.Information.Pvptype = pvptype; }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Private Message Delete /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// public void PrivateMessageDelete() { try { PacketReader Reader = new PacketReader(PacketInformation.buffer); byte messageid = Reader.Byte(); client.Send(Packet.DeletePrivateMessage(messageid)); DB.query("delete FROM message WHERE idinfo='" + messageid + "' AND receiver='" + Character.Information.Name + "'"); return; } catch (Exception ex) { Log.Exception(ex); } }
public void Init() { byte[] _data = File.ReadAllBytes(this.fileName); reader = new PacketReader(_data); files = new List <XfsFileData>(); #region HeaderInfo offset = reader.Int32(); reader.Offset(offset); zsize = reader.Byte(); info_size = zsize * 0x80; byte[] head_data_com = reader.Bytes(zsize); //Console.WriteLine(Utils.HexDump(head_data_com)); byte[] head_data_des = ZlibStream.UncompressBuffer(head_data_com); //Console.WriteLine(Utils.HexDump(head_data_des)); PacketReader head_data = new PacketReader(head_data_des); str_head = head_data.String(4); version = head_data.Int32(); files_count = head_data.Int32(); validation = head_data.Int32(); offset2 = head_data.Int32(); #endregion #region data_info byte[] size_24bts = reader.Bytes(3); int info_size_data = size_24bts[0] + (size_24bts[1] << 8) + (size_24bts[2] << 16); //Console.WriteLine("info_size_data: {0}", info_size_data); byte[] info_data_com = reader.Bytes(info_size_data); byte[] info_data = ZlibStream.UncompressBuffer(info_data_com); //Console.WriteLine(Utils.HexDump(info_data)); PacketReader reader_info = new PacketReader(info_data); for (int cx = 0; cx < files_count; cx++) { XfsFileData fdata = new XfsFileData(); fdata.fileName = reader_info.String(true); fdata.offset = reader_info.Int32(); fdata.compresed = reader_info.Int32(); fdata.UCSize = reader_info.Int32(); fdata.CSize = reader_info.Int32(); //Console.WriteLine("fileName: '{0}' offset_file: 0x{1:X} compresed: {2} UCSize: {3} CSize: {4}", fdata.fileName, fdata.offset, fdata.compresed, fdata.UCSize, fdata.CSize); files.Add(fdata); } #endregion }
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); } }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Player Actions / Sit / Stand / Walk etc /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// public void Doaction() { try { PacketReader Reader = new PacketReader(PacketInformation.buffer); List <int> toall = Character.Spawn; byte type = Reader.Byte(); switch (type) { case 2: if (Character.Transport.Right) { Send(toall, Packet.SetSpeed(Character.Transport.Horse.UniqueID, Character.Transport.Horse.Speed1, Character.Transport.Horse.Speed2)); Send(toall, Packet.ChangeStatus(Character.Transport.Horse.UniqueID, type, 0)); } Send(toall, Packet.ChangeStatus(Character.Information.UniqueID, type, 0)); break; case 3: if (Character.Transport.Right) { Send(toall, Packet.SetSpeed(Character.Transport.Horse.UniqueID, Character.Transport.Horse.Speed1, Character.Transport.Horse.Speed2)); Send(toall, Packet.ChangeStatus(Character.Transport.Horse.UniqueID, type, 0)); } Send(toall, Packet.ChangeStatus(Character.Information.UniqueID, type, 0)); break; case 4: SitDown(); break; default: Send(toall, Packet.ChangeStatus(Character.Information.UniqueID, type, 0)); break; } } catch (Exception ex) { Log.Exception(ex); } }
void CharacterRestore() { //Wrap our function in a catcher try { //Open packet readers PacketReader Reader = new PacketReader(PacketInformation.buffer); byte unused = Reader.Byte(); string name = Reader.Text(); Reader.Close(); //Update database information set delete time to 0 DB.query("UPDATE character SET deletedtime=0 WHERE name='" + name + "'"); //Update visually screen with packet client.Send(Packet.ScreenSuccess(5)); } catch (Exception ex) { Log.Exception(ex); } }
void CharacterDelete() { //Wrap our function in a catcher try { //Open our reader PacketReader Reader = new PacketReader(PacketInformation.buffer); byte unused = Reader.Byte(); string name = Reader.Text(); Reader.Close(); //Update character deletion information DB.query("UPDATE character SET deletedtime=dateadd(dd,7,getdate()) WHERE name='" + name + "'"); //Update character visual screen client.Send(Packet.ScreenSuccess(3)); } catch (Exception ex) { Log.Exception(ex); } }
public static void ClientCheck(Definitions.Clientdefinition sys) { PacketReader Reader = new PacketReader(sys.PacketInformation.buffer); byte Locale = Reader.Byte(); string Name = Reader.Text(); int Version = Reader.Int32(); Reader.Close(); try { if (Name == "SR_Client") { sys.client.Send(Core.Packets.Connect._1()); sys.client.Send(Core.Packets.Connect._2()); sys.client.Send(Core.Packets.Connect._3()); sys.client.Send(Core.Packets.Connect._4()); sys.client.Send(Core.Packets.Connect._5()); if (Version == Definitions.Serverdef.SilkroadClientVersion)// { sys.client.Send(Core.Packets.Connect.ActualVersion()); } else if (Version < Definitions.Serverdef.SilkroadClientVersion - 1)// { sys.client.Send(Core.Packets.Connect.ClientIsToOld()); } else if (Version > Definitions.Serverdef.SilkroadClientVersion)// { sys.client.Send(Core.Packets.Connect.ClientIsToNew()); } else { //sys.client.Send(Patch.SendPatchFiles()); } } } catch (Exception error) { Console.WriteLine("Connect.cs Error: {0}", error); } }
///////////////////////////////////////////////////////////////////////////////// // Pet movement ///////////////////////////////////////////////////////////////////////////////// public void MovementPet() { try { //Open our packet reader PacketReader Reader = new PacketReader(PacketInformation.buffer); //This one happens to all pets. int petid = Reader.Int32(); //We switch on type (2 = attack pet, 1 = horse). byte type = Reader.Byte(); switch (type) { //Horse pet movement case 1: byte movetype = Reader.Byte(); byte xsec = Reader.Byte(); byte ysec = Reader.Byte(); float x = Reader.Int16(); float z = Reader.Int16(); float y = Reader.Int16(); Reader.Close(); //Make sure attack timer is gone StopAttackTimer(); //Set pickup to false Character.Action.PickUping = false; //Set movement active Character.Position.Walking = true; double distance = Formule.gamedistance(Character.Position.x, Character.Position.y, Formule.gamex(x, xsec), Formule.gamey(y, ysec)); Character.Position.xSec = xsec; Character.Position.ySec = ysec; Character.Position.wX = Formule.gamex(x, xsec) - Character.Position.x; Character.Position.wZ = z; Character.Position.wY = Formule.gamey(y, ysec) - Character.Position.y; Character.Position.packetxSec = xsec; Character.Position.packetySec = ysec; Character.Position.packetX = (ushort)x; Character.Position.packetZ = (ushort)z; Character.Position.packetY = (ushort)y; Send(Packet.Movement(new ObjData.vektor(petid, x, z, y, xsec, ysec))); break; //Attack pet movement case 2: //Set pet info Character.Attackpet.Details.x = Character.Position.x; Character.Attackpet.Details.y = Character.Position.y; Character.Attackpet.Details.z = Character.Position.z; Character.Attackpet.Details.xSec = Character.Position.xSec; Character.Attackpet.Details.ySec = Character.Position.ySec; //Target id information int targetid = Reader.Int32(); Reader.Close(); //Set pet speed information Send(Packet.SetSpeed(petid, 50, 100)); //Need to make correct speed info later //Check distances / target detailed. //Send attack packet (new void pet attack to be created). break; } } catch (Exception ex) { Log.Exception(ex); } }
public void StallBuy() { try { if (!Character.Network.Stall.isOpened) { return; } PacketReader Reader = new PacketReader(PacketInformation.buffer); byte stallslot = Reader.Byte(); WorldMgr.stall currentStall = Character.Network.Stall; WorldMgr.stall.stallItem sitem = currentStall.ItemList.Find(i => (i.stallSlot == stallslot)); // stall buyer update byte slot = GetFreeSlot(); if (slot <= 12) { return; } if (Character.Information.Gold >= (long)sitem.price) { Character.Information.Gold -= (long)sitem.price; client.Send(Packet.UpdateGold(Character.Information.Gold)); SaveGold(); } else { return; //insufficent gold } // staller update if (currentStall.ItemList.Contains(sitem)) { PlayerMgr staller = Helpers.GetInformation.GetPlayer(currentStall.ownerID); staller.Character.Information.Gold += (long)sitem.price; staller.client.Send(Packet.UpdateGold(staller.Character.Information.Gold)); DB.query("update character set gold='" + staller.Character.Information.Gold + "' where id='" + staller.Character.Information.CharacterID + "'"); //DB.query("delete from char_items where itemnumber='item" + sitem.Item.Slot + "' AND owner='" + staller.Character.Information.CharacterID + "'"); DB.query("UPDATE char_items SET owner='" + Character.Information.CharacterID + "',slot='" + slot + "',itemnumber='item" + slot + "' WHERE owner='" + staller.Character.Information.CharacterID + "' AND itemid='" + sitem.Item.ID + "' AND id='" + sitem.Item.dbID + "' AND storagetype='0'"); //take item out from stall if (currentStall.ItemList.Count == 1) { staller.Character.Stall.Stallactive = false; Character.Stall.Stallactive = false; } currentStall.ItemList.Remove(sitem); client.Send(Packet.StallBuyItem(stallslot, 1)); currentStall.Send(Packet.StallBuyItem2(Character.Information.Name, stallslot, currentStall.ItemList)); } else { Disconnect("ban"); Console.WriteLine("Autobanned user: "******" Due to hacking"); } } catch (Exception ex) { Log.Exception(ex); } }
void MovementNormalClicking(PacketReader Reader) { float XPosition = 0; float YPosition = 0; float ZPosition = 0; byte xsec = Reader.Byte(); byte ysec = Reader.Byte(); double Distance = 0; Character.Position.Walking = true; if (!FileDB.CheckCave(xsec, ysec)) { XPosition = Reader.Int16(); ZPosition = Reader.Int16(); YPosition = Reader.Int16(); Distance = Formule.gamedistance(Character.Position.x, Character.Position.y, Formule.gamex(XPosition, xsec), Formule.gamey(YPosition, ysec)); Character.Position.xSec = xsec; Character.Position.ySec = ysec; Character.Position.wX = Formule.gamex(XPosition, xsec) - Character.Position.x; Character.Position.wZ = ZPosition; Character.Position.wY = Formule.gamey(YPosition, ysec) - Character.Position.y; Character.Position.packetxSec = xsec; Character.Position.packetySec = ysec; Character.Position.packetX = (ushort)XPosition; Character.Position.packetZ = (ushort)ZPosition; Character.Position.packetY = (ushort)YPosition; if ((xsec != 0) && (ysec != 0)) { Send(Packet.Movement(new ObjData.vektor(Character.Information.UniqueID, XPosition, ZPosition, YPosition, xsec, ysec))); } StartMovementTimer(GetMovementTime(Distance)); } else { XPosition = Formule.cavegamex((float)Reader.Int16(), (float)Reader.Int16()); ZPosition = Formule.cavegamez((float)Reader.Int16(), (float)Reader.Int16()); YPosition = Formule.cavegamey((float)Reader.Int16(), (float)Reader.Int16()); Distance = Formule.gamedistance(Character.Position.x, Character.Position.y, Formule.cavegamex(XPosition), Formule.cavegamey(YPosition)); Character.Position.xSec = xsec; Character.Position.ySec = ysec; Character.Position.wX = Formule.cavegamex(XPosition) - Character.Position.x; Character.Position.wZ = ZPosition; Character.Position.wY = Formule.cavegamey(YPosition) - Character.Position.y; Character.Position.packetxSec = xsec; Character.Position.packetySec = ysec; Character.Position.packetX = (ushort)XPosition; Character.Position.packetZ = (ushort)ZPosition; Character.Position.packetY = (ushort)YPosition; if ((xsec != 0) && (ysec != 0)) { Send(Packet.Movement(new ObjData.vektor(Character.Information.UniqueID, XPosition, ZPosition, YPosition, xsec, ysec))); } StartMovementTimer(GetMovementTime(Distance)); } Reader.Close(); if (Character.Grabpet.Active) { Send(Packet.Movement(new ObjData.vektor(Character.Grabpet.Details.UniqueID, XPosition + Rnd.Next(10, 15), ZPosition, YPosition + Rnd.Next(10, 15), xsec, ysec))); } if (Character.Attackpet.Active) { Send(Packet.Movement(new ObjData.vektor(Character.Attackpet.Details.UniqueID, XPosition + Rnd.Next(10, 15), ZPosition, YPosition + Rnd.Next(10, 15), xsec, ysec))); } }
public void Connect() { try { PacketReader Reader = new PacketReader(PacketInformation.buffer); if (Reader.Byte() == 18) { string ID = Reader.Text(); string PW = Reader.Text(); byte ukn = Reader.Byte(); // 0xff UInt16 ServerID = Reader.UInt16(); int lResult = 99; //Console.WriteLine("Id:{0} Pass:{1} ServerID:{2}",ID,PW,ServerID); SRX_Serverinfo SSI = GSList[ServerID]; if (SSI != null) { UInt16 myKey = 0; string sReason = ""; lock (Program.IPCResultList) { myKey = Program.IPCNewId++; } byte[] rqp = Program.IPCServer.PacketRequestLogin(Program.IPCPort, ID, PW, myKey); Servers.IPCenCode(ref rqp, SSI.code); lock (Program.IPCResultList) { Program.IPCResultList.Add(myKey, new IPCItem()); Program.IPCResultList[myKey].resultCode = 0x8000; } Program.IPCServer.Send(SSI.ip, SSI.ipcport, rqp); DateTime tOut = DateTime.Now.AddSeconds(30); while ((tOut >= DateTime.Now) && (Program.IPCResultList[myKey].resultCode == 0x8000) && (client.clientSocket.Connected)) { System.Threading.Thread.Sleep(10); } lResult = Program.IPCResultList[myKey].resultCode; sReason = Program.IPCResultList[myKey].banReason; lock (Program.IPCResultList) { Program.IPCResultList[myKey] = null; Program.IPCResultList.Remove(myKey); } rqp = null; //Console.WriteLine("Resultado de login: {0}",lResult); switch (lResult) { case 0: if (SSI.lan_wan) { client.Send(ConnectSucces(SSI.wan, SSI.port, 1)); } else { client.Send(ConnectSucces(SSI.ip, SSI.port, 1)); } return; case 1: if (WrongPassword < 3) { client.Send(WrongInformation()); WrongPassword++; return; } else { client.Disconnect(PacketInformation.Client); return; } case 2: client.Send(ServerIsFull()); client.Disconnect(PacketInformation.Client); return; case 3: client.Send(AllreadyConnected()); client.Disconnect(PacketInformation.Client); return; case 4: client.Send(BannedUser(sReason)); client.Disconnect(PacketInformation.Client); return; default: if (lResult == 0x8000) { Console.WriteLine("[IPC] Timeout"); } else { Console.WriteLine("[IPC] Result unknown {0}", lResult); } return; } } else { Console.WriteLine("F**k No fun.. SSI"); } } } catch (Exception ex) { Console.WriteLine("Connection Error: " + ex); } }
///////////////////////////////////////////////////////////////////////////////// // Movement ///////////////////////////////////////////////////////////////////////////////// public void Movement() { try { //foreach (var item in ObjData.Manager.MapObject) //{ // for (int i2 = 0; i2 < ObjData.Manager.MapObject[item.Key].entitys.Count; i2++) // { // if (ObjData.Manager.MapObject[item.Key].entitys[i2].OutLines.Exists(te => te.PointA == Formule.packetx(Character.Position.x, Character.Position.xSec) && te.PointB == Formule.packety(Character.Position.y, Character.Position.ySec))) // { // Console.WriteLine("Çarpışma Bulundu"); // } // else if (ObjData.Manager.MapObject[item.Key].entitys[i2].Points.Exists(te => te.x == Formule.packetx(Character.Position.x, Character.Position.xSec) && te.y == Formule.packety(Character.Position.y, Character.Position.ySec))) // { // Console.WriteLine("Çarpışma bulundu2"); // } // } //} #region Check Character.Action.Object = null; Character.Action.nAttack = false; Character.Action.Target = -1; if (Timer.Pickup != null && Character.Action.PickUping) { StopPickupTimer(); } if (Character.Information.SkyDroming) { StopSkyDromeTimer(); } if (Character.Action.nAttack) { StopAttackTimer(); Character.Action.nAttack = false; } if (Character.Action.sAttack) { StopAttackTimer(); Character.Action.sAttack = false; } if (Character.Action.sCasting) { StopAttackTimer(); Character.Action.sCasting = false; } if (Character.Information.PvpWait) { Send(Packet.PvpInterupt(Character.Information.UniqueID)); Character.Information.PvpWait = false; Character.Information.Pvptype = 0; StopPvpTimer(); } // returned if (Character.Stall.Stallactive || Character.Information.SkyDroming || Character.State.Die || Character.State.Sitting || Character.Information.Scroll || Character.Action.sCasting || Character.Action.sAttack || Character.Action.nAttack) { return; } #endregion PacketReader Reader = new PacketReader(PacketInformation.buffer); byte MovementFlag = Reader.Byte(); if (MovementFlag == 0) { MovementSkyClicking(Reader); } if (MovementFlag == 1) { MovementNormalClicking(Reader); } } catch (Exception exception) { Console.WriteLine("Movement error: {0}", exception); } }
public void StallMain() { try { PacketReader Reader = new PacketReader(PacketInformation.buffer); byte Type = Reader.Byte(); //Item edit if (Type == 1) { if (Character.Network.Stall.isOpened) { return; } byte stallslot = Reader.Byte(); Reader.Skip(2); ulong price = Reader.UInt64(); if (price <= 999999999) { int StallItemIndex = Character.Network.Stall.ItemList.FindIndex(i => (i.stallSlot == stallslot)); Character.Network.Stall.ItemList[StallItemIndex].price = price; Character.Network.Stall.Send(Packet.StallModifyItem(stallslot, price)); } else { return; } } //Add an item else if (Type == 2) { if (Character.Network.Stall.isOpened) { return; } byte stallslot = Reader.Byte(); byte invpos = Reader.Byte(); short quantity = Reader.Int16(); ulong price = Reader.UInt64(); ObjData.slotItem uItemID = GetItem((uint)Character.Information.CharacterID, invpos, 0); //Disable item mall items in stalls for now. if (ObjData.Manager.ItemBase[uItemID.ID].Etctype == ObjData.item_database.EtcType.GLOBALCHAT || ObjData.Manager.ItemBase[uItemID.ID].Type == ObjData.item_database.ArmorType.AVATAR || ObjData.Manager.ItemBase[uItemID.ID].Type == ObjData.item_database.ArmorType.AVATARHAT || ObjData.Manager.ItemBase[uItemID.ID].Type == ObjData.item_database.ArmorType.AVATARATTACH ) { return; } if (quantity <= ObjData.Manager.ItemBase[uItemID.ID].Max_Stack) { WorldMgr.stall.stallItem StallItem = new WorldMgr.stall.stallItem(); LoadBluesid(uItemID.dbID); StallItem.stallSlot = stallslot; StallItem.price = price; StallItem.Item = (GetItem((uint)Character.Information.CharacterID, invpos, 0)); if (Character.Network.Stall.ItemList.Exists((get => get.Item.dbID == StallItem.Item.dbID))) { return; } Character.Network.Stall.ItemList.Add(StallItem); Character.Network.Stall.Send(Packet.StallItemMain(Character.Network.Stall.ItemList)); } else { return; } } //Item pulling out else if (Type == 3) { if (Character.Network.Stall.isOpened) { return; } byte stallslot = Reader.Byte(); //remove stallItem from stall Character.Network.Stall.ItemList.Remove(Character.Network.Stall.ItemList.Find(i => (i.stallSlot == stallslot))); Character.Network.Stall.Send(Packet.StallItemMain(Character.Network.Stall.ItemList)); } //Stall modify state else if (Type == 5) { byte State = Reader.Byte(); Character.Network.Stall.isOpened = (State == 1) ? true : false; Character.Network.Stall.Send(Packet.StallSetState(State)); } //Set Welcome msg else if (Type == 6) { if (Character.Network.Stall.isOpened) { return; } short length = Reader.Int16(); Character.Network.Stall.WelcomeMsg = Reader.Text3(); //Console.WriteLine("New Welcome msg:" + welcome); Character.Network.Stall.Send(Packet.StallWelcome(Character.Network.Stall.WelcomeMsg)); } //Set StallName else if (Type == 7) { string stallname = Reader.Text3(); Send(Packet.StallNameGlobal(Character.Information.UniqueID, stallname)); Character.Network.Stall.Send(Packet.StallName(stallname)); } } catch (Exception ex) { Console.WriteLine("Additem Stall error: {0}", ex); } }
///////////////////////////////////////////////////////////////////////// //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); } }