void GuildMessage() { //Wrap our function inside a catcher try { //Create new packet reader PacketReader Reader = new PacketReader(PacketInformation.buffer); //Read short int16 for title lenght short TitleL = Reader.Int16(); //Read string for title string Title = Reader.String(TitleL); //Read short Message lenght short MessageL = Reader.Int16(); //Read message string Message = Reader.String(MessageL); //Close reader Reader.Close(); //Update database guild message title and message MsSQL.InsertData("UPDATE guild SET guild_news_t='" + Title + "',guild_news_m='" + Message + "' WHERE guild_name='" + Character.Network.Guild.Name + "'"); //Set new message info to current member for sending packet update. Character.Network.Guild.NewsTitle = Title; Character.Network.Guild.NewsMessage = Message; //Repeat for each member in our guild foreach (int member in Character.Network.Guild.Members) { //Make sure the member is there if (member != 0) { //Get detailed information from member main id Systems characterinformation = GetPlayerid(member); //Set the current member news title and message information characterinformation.Character.Network.Guild.NewsMessage = Message; characterinformation.Character.Network.Guild.NewsTitle = Title; //Send packet to the member to update guild message. characterinformation.client.Send(Packet.GuildUpdate(characterinformation.Character, 11, 0, 0, 0)); } } } //Catch any bad exception error catch (Exception ex) { //Write error to the console Console.WriteLine("Guild Message Error: {0}", ex); //Write information to the debug log Systems.Debugger.Write(ex); } }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Create Job Alias /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 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); MsSQL ms = new MsSQL("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)); MsSQL.UpdateData("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) { Systems.Debugger.Write(ex); } }
///////////////////////////////////////////////////////////////////////////////// // Add new friend ///////////////////////////////////////////////////////////////////////////////// void FriendAdd() { try { PacketReader reader = new PacketReader(PacketInformation.buffer); short namelenght = reader.Int16(); string name = reader.String(namelenght); reader.Close(); if (name == Character.Information.Name) return; Systems sys = GetPlayerName(name); if (sys != null) { sys.client.Send(Packet.FriendInviteTarget(sys.Character)); } else { //Packet cannot find user } } catch (Exception ex) { Console.WriteLine("Friend Add error {0}", ex); Systems.Debugger.Write(ex); } }
void GuildInvite() { //Wrap our code into a catcher try { //Create new packet reader PacketReader Reader = new PacketReader(PacketInformation.buffer); //Read lenght of invited character name Int16 InvitedCharacterLEN = Reader.Int16(); //Read invited character name string InvitedCharacter = Reader.String(InvitedCharacterLEN); //Close packet reader Reader.Close(); //Get information for target Systems sys = GetPlayerName(InvitedCharacter); //Set targetid information Character.Network.TargetID = sys.Character.Information.UniqueID; //If player allready has a guild if (sys.Character.Network.Guild.Guildid != 0) { client.Send(Packet.IngameMessages(Systems.SERVER_GUILD_WAIT, IngameMessages.UIIT_MSG_GUILDERR_MEMBER_OF_ANOTHER_GUILD)); return; } //If player has to wait before the player can join another guild if (sys.Character.Information.JoinGuildWait) { client.Send(Packet.IngameMessages(Systems.SERVER_GUILD_WAIT, IngameMessages.UIIT_MSG_GUILD_PENALTY)); return; } //If the guild has max members if (Character.Network.Guild.TotalMembers >= Character.Network.Guild.MaxMembers) { client.Send(Packet.IngameMessages(Systems.SERVER_GUILD_WAIT, IngameMessages.UIIT_MSG_GUILDERR_MEMBER_FULL)); } //If the character doesnt have join rights if (!Character.Network.Guild.joinRight) { //This should not happen unless hack attempt, because button should be grayed out return; } //Set targetid to the invited player sys.Character.Network.TargetID = this.Character.Information.UniqueID; //Send guild request packet sys.client.Send(Packet.PartyRequest(5, this.Character.Information.UniqueID, 0)); //Set bools active Character.State.GuildInvite = true; sys.Character.State.GuildInvite = true; } //Catch bad exception errors catch (Exception ex) { //Write information to the console Console.WriteLine("Guild invite error {0}", ex); //Write information to the debug log Systems.Debugger.Write(ex); } }
void RenameParty() { try { //Create new packet reader PacketReader reader = new PacketReader(PacketInformation.buffer); //First integer is party id int partyid = reader.Int32(); //Second integer is not needed int NotNeeded = reader.Int32(); //Byte party type byte ptype = reader.Byte(); //Byte party purpose byte purpose = reader.Byte(); //Byte minimum level byte minlevel = reader.Byte(); //Byte max level to enter party byte maxlevel = reader.Byte(); //Party name lenght short namel = reader.Int16(); //Party name each character is a word value using text3 string pname = reader.Text3(); //Create new packet writer PacketWriter Writer = new PacketWriter(); //Add opcode to server packet Writer.Create(Systems.SERVER_PARTY_CHANGENAME); //Write static byte 1 Writer.Byte(1); //Write party id Writer.DWord(partyid); //Write dword 0 Writer.DWord(0); //Write party type Writer.Byte(ptype); //Write party purpose Writer.Byte(purpose); //Write party minimum level Writer.Byte(minlevel); //Write party max level Writer.Byte(maxlevel); //Write party name Writer.Text3(pname); //Send bytes to client client.Send(Writer.GetBytes()); } //If a error happens catch (Exception ex) { //Write the exception to the log Systems.Debugger.Write(ex); } }
void CharacterJobPick(byte[] buff) { //Wrap our function inside a catcher try { //Create new packet reader PacketReader Reader = new PacketReader(buff); //Skip first byte not used Reader.Skip(1); //Read name lenght short CharacterNameLEN = Reader.Int16(); //Read character name string CharacterName = Reader.String(CharacterNameLEN); //Read job selection byte job = Reader.Byte(); //Close packet reader Reader.Close(); //Get row count from character to check if the current account and character match int NameCheck = MsSQL.GetRowsCount("SELECT * FROM character WHERE account='" + Player.AccountName + "'"); //Get job information from database as integer int jobcheck = MsSQL.GetDataInt("SELECT jobtype FROM users WHERE id='" + Player.AccountName + "'", "jobtype"); //If the name check is succesfull and account has no job set. if (jobcheck == 0 && NameCheck != 0) { //Write new job information to the database MsSQL.UpdateData("UPDATE users SET jobtype='" + job + "' WHERE id='" + Player.AccountName + "'"); } //Send visual confirmation in packet PacketWriter writer = new PacketWriter(); //Add opcode writer.Create(Systems.SERVER_CHARACTERSCREEN); //Write static byte 10 writer.Byte(0x10); //Write succes byte 1 writer.Byte(1); //Send bytes to client client.Send(writer.GetBytes()); } //Catch any bad exception error catch (Exception ex) { //Write error information to the console Console.WriteLine("Job selection error {0}", ex); //Write error to debug log file Systems.Debugger.Write(ex); } }
void GuildTitle() { //Wrap our function inside a catcher try { //Extra hack check if (Character.Network.Guild.Level < 4) return; //Create new packet reader PacketReader Reader = new PacketReader(PacketInformation.buffer); //Read integer guild member selected int SelectedGuildMember = Reader.Int32(); //Read short lenght of title for guild member short GuildMemberTitleLEN = Reader.Int16(); //Read string guild member title string GuildMemberTitle = Reader.String(GuildMemberTitleLEN); //Close packet reader Reader.Close(); //Get selected guild member information Systems playerinfo = GetPlayerMainid(SelectedGuildMember); //Make sure the character is still there if (playerinfo.Character != null) { //Update database set new title MsSQL.InsertData("UPDATE guild_members SET guild_grant='" + GuildMemberTitle + "' WHERE guild_member_id='" + playerinfo.Character.Information.CharacterID + "'"); //Send new character guild title update to each player in spawn reach Send(Packet.GuildSetTitle(Character.Guild.GuildID, playerinfo.Character.Information.Name, GuildMemberTitle)); //Send Final packet to client playerinfo.client.Send(Packet.GuildSetTitle2(Character.Guild.GuildID, SelectedGuildMember, GuildMemberTitle)); } } //Catch bad exception errors catch (Exception ex) { //Write information to the console Console.WriteLine("Guild Title Error: {0}", ex); //Write information to debug log Systems.Debugger.Write(ex); } }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Gm Command Base /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// void GM() { if (Character.Information.GM == 1) { PacketReader Reader = new PacketReader(PacketInformation.buffer); short gType = Reader.Int16(); //Console.WriteLine("GM Command {0} used by:{1} ",gType, Character.Information.Name); switch (gType) { case 0: // Command /playercount break; case 1: // Command /finduser break; case 2: // Command / MsgClear break; case 3: GM_TOTOWN(Reader.Text()); break; case 4: // Command /Getpos break; case 5: // Command /stat break; case 6: GM_LOADMONSTER(Reader.Int32(), Reader.Byte(), Reader.Byte()); break; case 7: GM_MAKEITEM(Reader.Int32(), Reader.Byte()); break; case 8: GM_GOUSER(Reader.Text()); break; case 12: // Command /zoe GM_ZOE(Reader.Int32(), Reader.Byte()); break; case 13: GM_BAN(Reader.Text()); break; case 14: GM_INVISIBLE(); break; case 15: GM_INVINCIBLE(); break; case 16: if (PacketInformation.buffer.Length > 4) GM_WP(Reader.Byte(), Reader.Byte(), Reader.Single(), Reader.Single(), Reader.Single()); break; case 17: GM_RECALLUSER(Reader.Text()); break; case 19: // Command /instance case 20: GM_MOBKILL(Reader.Int32(), Reader.UInt16()); break; case 23: GM_BLOCKLOGOUT(Reader.Text(), Reader.Byte()); break; case 26: GM_LIENAME(Reader.Text()); break; case 27: //initq GM_SKILL(); break; case 42: GM_SPAWN_UNIQUE(); break; case 49: GM_CLEARINVEN(); break; case 50: // Command /barena break; case 25: // Command /fakename // Used for transforming now GM_TRANSFORM(Reader.Text()); break; case 99: // Command /power %d case 100: // Command /timeoff break; case 101: // Command /timeon break; case 102: // Command /time %d break; case 103: // Command /day break; case 104: // Command /night break; case 105: // Command /rain %d int type = 2; GM_WEATHER(Reader.Int32(),type); break; case 106: // Command /snow %d type = 3; GM_WEATHER(Reader.Int32(),type); break; case 107: // Command /clear type = 1; GM_WEATHER(Reader.Int32(),type); break; case 108: // Command /+ break; case 109: // Command /- break; case 110: // Command /zoom break; case 111: // Command /fast break; case 112: // Command /showme break; case 113: // Command /hideme break; case 114: // Command /camera break; case 115: // Command /uioff break; case 116: // Command /uion break; case 117: // Command /frame break; case 118: // Command /colon break; case 119: // Command /coloff break; case 130: // Command /cwclear break; case 131: // Command /cwpop break; case 132: // Command /cwgo break; case 133: // Command /cwstop break; case 134: // Command /cwsave break; case 135: // Command /ms break; case 136: // Command /cs %d break; case 137: // Command /id break; case 150: // Command /wire break; case 151: // Command /ground break; case 152: // Command /sky break; case 153: // Command /mobj break; case 154: // Command /char break; case 155: // Command /lod break; case 400: // Command /Item %d break; case 500: // Command /setfov %d break; case 600: // Command /setspeed %d break; case 601: // Command /equip %d break; case 602: // Command /makeobj %d break; case 603: // Command /snd %s break; default: Console.WriteLine("Non Coded Gm Command: " + gType); Print.Format(Decode.StringToPack(PacketInformation.buffer)); break; } Reader.Close(); } else { lock (Systems.clients) { foreach (Systems sys in Systems.clients) { try { if (sys.Character.Information.Name == Character.Information.Name) { sys.client.Send(Packet.ChatPacket(7, Character.Information.UniqueID, "from GM:You are banned.", null)); sys.Disconnect("ban"); Console.WriteLine("Autobanned user: "******" Due to hacking"); return; } } catch (Exception ex) { Console.WriteLine("Commands error: " + ex); } } } } }
///////////////////////////////////////////////////////////////////////////////// // Movement ///////////////////////////////////////////////////////////////////////////////// public void Movement() { try { PacketReader Reader = new PacketReader(PacketInformation.buffer); Character.Action.PickUping = false; byte Type = Reader.Byte(); ////////////////////////////////////////////////////////////////////////////// Sky drome movement if (Type == 0) { if (!Character.Stall.Stallactive && !Character.Action.PickUping && !Character.State.Die && !Character.Action.sCasting && !Character.Action.sAttack && !Character.Action.nAttack && !Character.Information.Scroll && !Character.State.Sitting && !Character.Information.SkyDroming) { /* if (File.FileLoad.CheckCave(Character.Position.xSec, Character.Position.ySec)) { return; } else { Character.Information.SkyDroming = true; byte info = Reader.Byte(); ushort angle = Reader.UInt16(); Character.Information.Angle = angle / (65535.0 / 360.0); Character.Position.packetxSec = Character.Position.xSec; Character.Position.packetySec = Character.Position.ySec; Character.Position.packetX = (ushort)Game.Formule.packetx(Character.Position.x, Character.Position.xSec); Character.Position.packetY = (ushort)Game.Formule.packetx(Character.Position.x, Character.Position.xSec); double distance = Formule.gamedistance( Character.Position.x, Character.Position.y, Formule.gamex(Character.Position.x, Character.Position.xSec), Formule.gamey(Character.Position.y, Character.Position.ySec)); Character.Position.Time = (distance / (Character.Speed.RunSpeed * 0.0768)) * 1000.0; Character.Position.RecordedTime = Character.Position.Time; PacketWriter Writer = new PacketWriter(); Writer.Create(Systems.SERVER_MOVEMENT); Writer.DWord(Character.Information.UniqueID); Writer.Byte(0); Writer.Byte(info); 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()); StartSkyDromeTimer(1000); }*/ } } //------------------------- Normal movement -------------------------// if (Type == 1) { //If character is in a guild if (Character.Network.Guild.Guildid != 0) { //Repeat for each client in the guild foreach (Client memberclient in Character.Network.Guild.MembersClient) { //Make sure the client is not null if (memberclient != null) { //Send update packet for location of player memberclient.Send(Packet.GuildUpdate(Character, 10, Character.Information.UniqueID, 0, 0)); } } } if (Character.Stall.Stallactive) return; if (Character.Action.PickUping) return; StopPickUpTimer(); if (Character.State.Die) return; if (Character.Information.Scroll) return; if (Character.State.Sitting) return; 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(); } Character.Position.Walking = true; byte xsec = Reader.Byte(); byte ysec = Reader.Byte(); float x, y, z; if (!File.FileLoad.CheckCave(xsec, ysec)) { x = Reader.Int16(); z = Reader.Int16(); y = Reader.Int16(); 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; if (xsec != 0 && ysec != 0) { Send(Packet.Movement(new Global.vektor(Character.Information.UniqueID, x, z, y, xsec, ysec))); } if (Character.Information.Berserking) { Character.Position.Time = (distance / (Character.Speed.RunSpeed * 0.109)) * 1000.0; } else { Character.Position.Time = (distance / (Character.Speed.RunSpeed * 0.109)) * 1000.0; } } else // Added for cave telepad locations { x = Formule.cavegamex(Reader.Int16(),Reader.Int16()); //Reads the location and retunrs the coords for the cave postion x z = Formule.cavegamez(Reader.Int16(), Reader.Int16()); //Reads the location and retunrs the coords for the cave postion z y = Formule.cavegamey(Reader.Int16(), Reader.Int16()); //Reads the location and retunrs the coords for the cave postion y double distance = Formule.gamedistance(Character.Position.x,Character.Position.y,Formule.cavegamex(x),Formule.cavegamey(y)); Character.Position.xSec = xsec; Character.Position.ySec = ysec; Character.Position.wX = Formule.cavegamex(x) - Character.Position.x; Character.Position.wZ = z; Character.Position.wY = Formule.cavegamey(y) - 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; if (xsec != 0 && ysec != 0) { Send(Packet.Movement(new Global.vektor(Character.Information.UniqueID, x, z, y, xsec, ysec))); } if (Character.Information.Berserking) { Character.Position.Time = (distance / (Character.Speed.BerserkSpeed * 0.0768)) * 1000.0; } else { Character.Position.Time = (distance / (Character.Speed.RunSpeed * 0.0768)) * 1000.0; } } Reader.Close(); if (xsec != 0 && ysec != 0) { Send(Packet.Movement(new Global.vektor(Character.Information.UniqueID, x, z, y, xsec, ysec))); } if (Character.Grabpet.Active) { Send(Packet.Movement(new Global.vektor(Character.Grabpet.Details.UniqueID, x + rnd.Next(10, 25), z, y + rnd.Next(10, 25), xsec, ysec))); } if (Character.Attackpet.Active) { Send(Packet.Movement(new Global.vektor(Character.Attackpet.Details.UniqueID, x + rnd.Next(10, 25), z, y + rnd.Next(10, 25), xsec, ysec))); } Character.Position.RecordedTime = Character.Position.Time; StartMovementTimer((int)(Character.Position.Time * 0.1)); } } catch (Exception ex) { Console.WriteLine("Movement error: {0}", ex); } }
// only for buffs now /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // GM Skill /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// void GM_SKILL() { PacketReader reader = new PacketReader(PacketInformation.buffer); short ignore = reader.Int16(); short skilllenght = reader.Int16(); string skill = reader.String(skilllenght); Character.Action.UsingSkillID = Convert.ToInt32(skill); SkillBuff(); }
void Handle() { PacketReader Reader = new PacketReader(PacketInformation.buffer); byte iSlot = Reader.Byte(); Global.slotItem uItemID = GetItem((uint)Character.Information.CharacterID, iSlot, 0); if (uItemID.ID == 0 || Character.State.Die) return; switch (uItemID.ID) { /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Stall decoration /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case 3847: case 3848: case 3849: case 3850: case 35482: case 35483: case 35484: StallDeco(uItemID.ID, iSlot); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); break; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Monster Masks /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case 10364: if (Character.Transformed) return; //Load Mask MonsterMasks(uItemID.ID, iSlot); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); break; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Forgotten world entrance /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case 33235: ForgottenWorld(uItemID.ID); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); break; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Repair items /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case 3784: case 24432: case 35249: if (!Character.Action.repair) { Character.Action.repair = true; RepairTimer(30000); //Check if there are any items that need repair double durability = Data.ItemBase[uItemID.ID].Defans.Durability; double currentdurability = Data.ItemBase[uItemID.dbID].Defans.Durability; if (currentdurability < durability) { int countrepairs = MsSQL.GetRowsCount("SELECT * FROM char_items WHERE owner='" + Character.Information.CharacterID + "'"); if (countrepairs == 0) { //Do nothing client sends message automaticly } else { //Start repairing call handle HandleRepair(iSlot, uItemID.dbID); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); } } } break; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Thief Return Scrolls /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case 2128: if (Character.Information.Scroll) return; HandleThiefScroll(uItemID.ID); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); break; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Inventory Expansion /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case 24456: HandleInventoryExp(uItemID.ID); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); break; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Monster Summon Scrolls /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case 3935: case 3936: case 3937: case 10133: case 10145: case 30925: HandleSummon(Character.Information.Level); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); break; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Reverse return scrolls /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case 3795: case 24467: if (Character.Information.Scroll) return; HandleReverse(Reader.Int16(),Reader.Byte(), Reader.Int32()); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); break; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Premium Tickets /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case 7490: case 24505: HandlePremiumType(uItemID.ID); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); break; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Normal Return Scrolls /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case 61: case 2198: case 2199: case 3769: case 19599: case 24684: if (Character.Information.Scroll) return; if (Timer.Movement != null) { Timer.Movement.Dispose(); Character.Position.Walking = false; } HandleReturnScroll(uItemID.ID); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); break; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // HP Potions /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case 4: case 5: case 6: case 7: case 8: case 3817: case 3818: case 3819: case 5912: case 3765: byte type = 1; HandlePotion(type, uItemID.ID); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); break; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // MP Potions /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case 11: case 12: case 13: case 14: case 15: case 3820: case 3821: case 3822: case 5913: type = 2; HandlePotion(type, uItemID.ID); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); break; case 9: type = 3; HandlePotion(type, uItemID.ID); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); break; case 16: type = 4; HandlePotion(type, uItemID.ID); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); break; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Vigor Potions /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case 18: case 19: case 20: case 21: case 22: case 23: case 3739: case 4013: case 5881: case 5944: case 23316: type = 5; HandlePotion(type, uItemID.ID); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); break; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Special Transport /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case 19601: case 22770: if (!Character.Stall.Stallactive && !Character.Transport.Right && Character.Action.MonsterID.Count == 0 && !Character.State.Sitting && !Character.Information.Scroll) { bool r = HandleSpecialTrans(uItemID.ID); if (!r) HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); } break; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Normal transports /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case 2137: case 2138: case 2139: case 3909: case 23330: case 22953: case 23396: case 23395: case 22952: if (!Character.Stall.Stallactive && !Character.Transport.Right && Character.Action.MonsterID.Count == 0 && !Character.State.Sitting && !Character.Information.Scroll) { if (this.Character.Information.Level >= Data.ItemBase[uItemID.ID].Level) { HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); HandleHorseScroll(uItemID.ID); } else { //client.Send();// needs error } } break; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Global Chatting /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case 3851: HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); string text = " " + Reader.Text3(); Reader.Close(); SendAll(Packet.ChatPacket(6, 0, text, Character.Information.Name)); break; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Buff Items /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case 7100: SpecialBuff(3977); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); break; case 7098: SpecialBuff(3975); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); break; case 23311: if (Character.Information.Berserking) return; int style = 1; HandleRegenZerk(style, uItemID.ID); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); break; case 23938: if (Character.Information.Berserking) return; style = 2; HandleRegenZerk(style, uItemID.ID); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); break; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Grab Pets /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case 23313: case 35578: case 35583: if (!Character.Grabpet.Active && Character.Action.MonsterID.Count == 0) { bool r = HandleGrabPet(iSlot, uItemID.ID); if (!r) HandleUpdateSlotn(iSlot, uItemID, Reader.UInt16()); } break; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Attack Pets /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /* case 22778: if (!Character.Grabpet.Active && Character.Action.MonsterID.Count == 0) { bool r = HandleAttackPet(iSlot, uItemID.ID); if (!r) HandleUpdateSlotn(iSlot, uItemID, Reader.UInt16()); } break; */ /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Gender Switch Tools /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case 24479: //HandleGenderSwitch(iSlot, uItemID.ID); //HandleUpdateSlotn(iSlot, uItemID, Reader.UInt16()); break; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Balloons /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// case 24342: //HandleBalloon(iSlot, 31157); SpecialBuff(31182); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); break; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Default , Check item ID /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// default: //Console.WriteLine("{0} Tried to use item {1} , The cast type: {2}", Character.Information.Name, Data.ItemBase[uItemID.ID].Name, uItemID.ID); HandleUpdateSlot(iSlot, uItemID, Reader.UInt16()); break; } Reader.Close(); }
/////////////////////////////////////////////////////////////////////////// // Rename grab pet /////////////////////////////////////////////////////////////////////////// void RenamePet() { try { //Start reading packet data PacketReader Reader = new PacketReader(PacketInformation.buffer); //Pet id int petid = Reader.Int32(); //Pet name lenght short petnamel = Reader.Int16(); //Pet name string petname = Reader.String(petnamel); //Check availability for pet name. int nameavailable = MsSQL.GetRowsCount("SELECT pet_name FROM pets WHERE pet_name='" + petname + "'"); //If available (Row count is zero). if (nameavailable == 0) { //Create the query we will use MsSQL ms = new MsSQL("SELECT * FROM pets WHERE playerid='" + Character.Information.CharacterID + "' AND pet_unique='" + petid + "'"); //Open our data reader using (SqlDataReader reader = ms.Read()) { //While the reader is reading from database while (reader.Read()) { //First we check the lenght of the name. if (petnamel < 3) { client.Send(Packet.IngameMessages(SERVER_PET_RENAME_MSG, IngameMessages.UIIT_MSG_COSPETERR_PETNAME_NOTPUT)); } //Check if renamed allready. (Should not be needed just extra check) if (Character.Grabpet.Details != null) { if (petid == Character.Grabpet.Details.UniqueID) { if (Character.Grabpet.Details.Petname == "No name") { //Update name in database MsSQL.UpdateData("UPDATE pets SET pet_state='2',pet_name='" + petname + "' WHERE pet_unique='" + petid + "' AND playerid='" + Character.Information.CharacterID + "'"); //Send needed packets to update name (Official sends 2 times)... client.Send(Packet.PetSpawn(petid, 2, Character.Grabpet.Details)); //Send to all currently in spawn range Send(Packet.PetSpawn(petid, 2, Character.Grabpet.Details)); } } } //Check if renamed allready. (Should not be needed just extra check) if (Character.Attackpet.Details != null) { if (petid == Character.Attackpet.Details.UniqueID) { if (Character.Attackpet.Details.Petname == "No name") { //Update name in database MsSQL.UpdateData("UPDATE pets SET pet_state='2',pet_name='" + petname + "' WHERE pet_unique='" + petid + "' AND playerid='" + Character.Information.CharacterID + "'"); //Send needed packets to update name (Official sends 2 times)... client.Send(Packet.PetSpawn(petid, 2, Character.Attackpet.Details)); //Send to all currently in spawn range Send(Packet.PetSpawn(petid, 2, Character.Attackpet.Details)); } } } } } } //If name has been taken else { //Not sure if correct msg. client.Send(Packet.IngameMessages(SERVER_PET_RENAME_MSG, IngameMessages.UIIT_MSG_COSPETERR_PETNAME_NOTPUT)); } } catch (Exception ex) { Console.WriteLine("Grab pet renaming error : " + ex); } }
///////////////////////////////////////////////////////////////////////////////// // Item Switch ///////////////////////////////////////////////////////////////////////////////// void ItemMain() { #region Item Actions try { if (Character.State.Die || Character.Information.Scroll) return; PacketReader Reader = new PacketReader(PacketInformation.buffer); byte iType = Reader.Byte(); switch (iType) { case 0: if (Character.State.Busy) return; ItemMove(Reader.Byte(), Reader.Byte(), Reader.Int16()); break; case 1: ItemMoveInStorage(Reader.Byte(), Reader.Byte(), Reader.Int16()); break; case 2: Player_MoveItemToStorage(Reader.Byte(), Reader.Byte(), Reader.Int32()); break; case 3: Player_MoveStorageItemToInv(Reader.Byte(), Reader.Byte(), Reader.Int32()); break; case 4: ItemMoveToExhangePage(Reader.Byte()); break; case 5: ItemMoveExchangeToInv(Reader.Byte()); break; case 8: Player_BuyItem(Reader.Byte(), Reader.Byte(), Reader.Int16(), Reader.Int32()); break; case 9: Player_SellItem(Reader.Byte(), Reader.Int16(), Reader.UInt16()); break; case 7: if (Character.State.Busy) return; Player_DropItem(Reader.Byte()); break; case 10: if (Character.State.Busy) return; Player_DropGold(Reader.UInt64()); break; case 11: Player_TakeGoldW(iType, Reader.Int64()); break; case 12: Player_GiveGoldW(iType, Reader.Int64()); break; case 13: ItemExchangeGold(Reader.Int64()); break; case 16: MovePetToPet(Reader.Int32(), Reader.Byte(), Reader.Byte(), Reader.Int16()); break; case 24: Player_BuyItemFromMall(Reader.Byte(), Reader.Byte(), Reader.Byte(), Reader.Byte(), Reader.Byte(), Reader.Text()); break; case 26: MoveItemFromPet(Reader.Int32(), Reader.Byte(), Reader.Byte()); break; case 27: MoveItemToPet(Reader.Int32(), Reader.Byte(), Reader.Byte()); break; case 29: ItemMoveInStorage(Reader.Byte(), Reader.Byte(), Reader.Int16());//Move inside guild storage break; case 30: Player_MoveItemToStorage(Reader.Byte(), Reader.Byte(), Reader.Int32());//Move to guild storage break; case 31: Player_MoveStorageItemToInv(Reader.Byte(), Reader.Byte(), Reader.Int32());//Move from guild storage break; case 32: Player_GiveGoldW(iType, Reader.Int64());//Guild storage break; case 33: Player_TakeGoldW(iType, Reader.Int64());//Guild storage break; case 35: ItemAvatarUnEquip(Reader.Byte(), Reader.Byte()); break; case 36: ItemAvatarEquip(Reader.Byte(), Reader.Byte()); break; default: Print.Format("Unknown Item Function:{0}:{1}", iType, Decode.StringToPack(PacketInformation.buffer)); break; } Reader.Close(); } catch (Exception ex) { Console.WriteLine("Item Switch Error {0}", ex); } #endregion }
void PrivateMessageSend() { try { //Create new packet reader for reading packet data PacketReader Reader = new PacketReader(PacketInformation.buffer); //Read lenght of charactername we send the message to short ToCharacterLen = Reader.Int16(); //Read the name of the character we send the message to string ToCharacter = Reader.String(ToCharacterLen); //Read lenght of message characters short MessageLen = Reader.Int16(); //Read message string Message = Reader.String(MessageLen); //Close packet reader Reader.Close(); //Create new mssql query for sending and checking MsSQL ms = new MsSQL("SELECT * FROM character WHERE name='" + ToCharacter + "'"); //Check if the player exists int PlayerExists = ms.Count(); //If the player exists if (PlayerExists > 0) { //First get details of the player we send the message to. Systems sys = GetPlayerName(ToCharacter); //Make sure we dont get a null error if (sys.Character != null) { //Check how many messages the player has if inbox is full or not int TargetMessageCount = MsSQL.GetRowsCount("SELECT * FROM message WHERE receiver='" + sys.Character.Information.CharacterID + "'"); //If less then 50 we continue if (TargetMessageCount < 50) { //Set temp int to character data for new message order sys.Character.Information.MessageCount = TargetMessageCount; //Insert new message into the database MsSQL.InsertData("INSERT INTO message (sender, receiver, message, status, time) VALUES ('" + Character.Information.Name + "','" + ToCharacter + "','" + Message + "','0','" + DateTime.Now + "')"); //Send packet message has been send to our client client.Send(PrivateMessageRespond(2)); //Send packet to receiver information new message has arrived sys.Send(Packet.FriendData(sys.Character.Information.UniqueID, 5, ToCharacter, Character, false)); } //If inbox is full else { //Send message to sender and receiver inbox full client.Send(PrivateMessageRespond(3)); sys.client.Send(PrivateMessageRespond(3)); } } } //If player doesn't exist else { //Send packet message failed to send to our client. client.Send(PrivateMessageRespond(1)); } } //Catch any bad exception errors catch (Exception ex) { //Write information to the console Console.WriteLine("Error sending messages : {0}" + ex); //Write info to the debug logger. Systems.Debugger.Write(ex); } }
public void StallMain() { try { PacketReader Reader = new PacketReader(PacketInformation.buffer); byte Type = Reader.Byte(); //Item edit if (Type == 1) { if (Character.Network.Stall.isOpened) return; byte stallslot = Reader.Byte(); Reader.Skip(2); ulong price = Reader.UInt64(); if (price <= 999999999) { int StallItemIndex = Character.Network.Stall.ItemList.FindIndex(i => (i.stallSlot == stallslot)); Character.Network.Stall.ItemList[StallItemIndex].price = price; Character.Network.Stall.Send(Packet.StallModifyItem(stallslot, price)); } else return; } //Add an item else if (Type == 2) { if (Character.Network.Stall.isOpened) return; byte stallslot = Reader.Byte(); byte invpos = Reader.Byte(); short quantity = Reader.Int16(); ulong price = Reader.UInt64(); Global.slotItem uItemID = GetItem((uint)Character.Information.CharacterID, invpos, 0); //Disable item mall items in stalls for now. if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.GLOBALCHAT || Data.ItemBase[uItemID.ID].Type == Global.item_database.ArmorType.AVATAR || Data.ItemBase[uItemID.ID].Type == Global.item_database.ArmorType.AVATARHAT || Data.ItemBase[uItemID.ID].Type == Global.item_database.ArmorType.AVATARATTACH ) return; if (quantity <= Data.ItemBase[uItemID.ID].Max_Stack) { stall.stallItem StallItem = new stall.stallItem(); LoadBluesid(uItemID.dbID); StallItem.stallSlot = stallslot; StallItem.price = price; StallItem.Item = (GetItem((uint)Character.Information.CharacterID, invpos, 0)); if (Character.Network.Stall.ItemList.Exists((get => get.Item.dbID == StallItem.Item.dbID))) return; Character.Network.Stall.ItemList.Add(StallItem); Character.Network.Stall.Send(Packet.StallItemMain(Character.Network.Stall.ItemList)); } else return; } //Item pulling out else if (Type == 3) { if (Character.Network.Stall.isOpened) return; byte stallslot = Reader.Byte(); //remove stallItem from stall Character.Network.Stall.ItemList.Remove(Character.Network.Stall.ItemList.Find(i => (i.stallSlot == stallslot))); Character.Network.Stall.Send(Packet.StallItemMain(Character.Network.Stall.ItemList)); } //Stall modify state else if (Type == 5) { byte State = Reader.Byte(); Character.Network.Stall.isOpened = (State == 1) ? true : false; Character.Network.Stall.Send(Packet.StallSetState(State)); } //Set Welcome msg else if (Type == 6) { if (Character.Network.Stall.isOpened) return; short length = Reader.Int16(); Character.Network.Stall.WelcomeMsg = Reader.Text3(); //Console.WriteLine("New Welcome msg:" + welcome); Character.Network.Stall.Send(Packet.StallWelcome(Character.Network.Stall.WelcomeMsg)); } //Set StallName else if (Type == 7) { string stallname = Reader.Text3(); Send(Packet.StallNameGlobal(Character.Information.UniqueID, stallname)); Character.Network.Stall.Send(Packet.StallName(stallname)); } } catch (Exception ex) { Console.WriteLine("Additem Stall error: {0}", ex); } }
public void RequestIcons() { PacketReader Reader = new PacketReader(PacketInformation.buffer); byte IconType = Reader.Byte(); short IconHexLenght = Reader.Int16(); string Icon = Reader.String(IconHexLenght); Reader.Close(); //Need to figure out the string.. identification of the icon probably client.Send(Packet.IconSend(IconType, Icon)); // Below is sniffed data /* * [S -> C][2114] 01 Byte = Type icon (1 = Guild 2 = union). 1C 01 Lenght of hex icon string // below is the hex string (Ascii) icon 74 6D 28 73 81 2A 47 37 F6 13 99 62 8C 3F 4E 29 tm(s.*G7...b.?N) 0F 04 CB 3D E6 5F FC 0B D6 07 03 DD 0D 72 9A 25 ...=._.......r.% 8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^. 8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^. 8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^. 8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^. 8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^. 8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^. 8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^. 8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^. 8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^. 8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^. 8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^. 8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^. 8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^. 8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^. 8A 88 BF CB 59 5A 8A 08 74 80 32 53 AA 1C 5E 86 ....YZ..t.2S..^. FE DC BA 98 76 54 32 10 0F 1E 2D 3C ....vT2...-<.... [C -> S][2114] 02 ................ 0C 00 ................ AE A5 BF 3C 23 65 0C 01 03 1E 27 3C ...<#e....'<.... */ /* (Nukei)Discovered so far: client requests image by contacting 121.128.134.16 (gdmark.joymax.com) using HTTP protocol over port 15080 like: http://gdmark.joymax.com:15080/SRO_CREST/A96_2132_1.crb (this files is saved in sro-client's RD folder as A96_2132.rd converted to BMP format) the returned header indicates, that the returned content is 256 Bytes in size (16 x 16 = 256). the given type is "application". ToDo: 1. Why or when the client starts this request for images ? 2. Is the returned array of bytes 16x16 palette entries ? 3. if 2 is right, what palette is used ? Result: 1. dont know :-P 2. Yes, we get a paletted image in 16x16 size (without palette, without size, RAW pixel), so every byte is one pixel. pay attention that the Y coordinates are reversed, so the image is bottom up. 3. discovered that it is the windows system palette !! * I dont know if the image really is transfered with 2114 packet !!! Tools used: PhotoShop, Wireshark, WinHex */ /*Xsense: * Result: * 1. I believe send on guild name spawn by 1 byte indication active non active. * 1. Simple check would be a bool from database on creation of icon set to true, * 1. Deletion item / guild disband / union kick / leave would remove the bool information from db. * 2. Indexed color 8 bit setting. (Change extension to bmp / checked photoshop indications). * 3. * 4. RD should be cache folder, which server could check from registry path to see excisting icons. */ /* (Rokky93) Discovered: I search a bit about CREST System of Joymax and found an interesting blog.So now i will tell you my results: 1. Silkroad stores Guild Icons on a stand-alone FTP Server. You can find them in the Media.pk2/type.txt 2. For example A96_2132_1.crb: A - type(Guild or Alliance) 96- Server ID 2132 - guild id 1 - crest id When we want to convert it to bmp: 1. Silkroad uses 16x16 pixel big 8bbp bitmaps with static color palette and no compression. The stored crests are 256B big. 2. BMP Structure: header - static meta - static palette - static bitmap (crest file content) - dynamic When we want to send icons to Client 1. We have to change the FTP Server in the Media.pk2 2. We must send this packet to Client byte - type(alliance, guild) 00 or 01 dword - guildid string - guildname dword - crestindex For example: type G serverId 187 guildId 2929 crestid 3 Client makes this : G187_2929_3.crb and download them from server ( this is my theory) GET /SRO_CREST/A239_282_3.crb HTTP/1.1 Accept-Encoding: gzip, deflate User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.1; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; InfoPath.3; .NET4.0C; .NET4.0E) Host: gdmark.joymax.com:15080 Connection: Keep-Alive */ }
///////////////////////////////////////////////////////////////////////////////// // Pet movement ///////////////////////////////////////////////////////////////////////////////// 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(); //Normal movement type if (movetype == 1) { //Read xsector information byte xsec = Reader.Byte(); //Read ysector information byte ysec = Reader.Byte(); //Read x float x = Reader.Int16(); //Read z float z = Reader.Int16(); //Read y 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; //Calculate distance double distance = Formule.gamedistance(Character.Position.x, Character.Position.y, Formule.gamex(x, xsec), Formule.gamey(y, ysec)); //Set character position 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 Global.vektor(petid, x, z, y, xsec, ysec))); Character.Position.Time = (distance / (95.0 * 0.0768)) * 1000.0; Character.Position.RecordedTime = Character.Position.Time; StartMovementTimer((int)(Character.Position.Time * 0.1)); } 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) { Console.WriteLine("movement pet error {0}", ex); Systems.Debugger.Write(ex); } }
void KickFromGuild() { //Wrap our function inside a catcher try { //Open a new packet reader PacketReader Reader = new PacketReader(PacketInformation.buffer); //Read short value lenght of name below short CharacterNameLen = Reader.Int16(); //Read string charactername string CharacterName = Reader.String(CharacterNameLen); //Close packet reader Reader.Close(); //Get player information Systems TargetCharacter = GetPlayerName(CharacterName); //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 != TargetCharacter.Character.Information.CharacterID) { guildmember.client.Send(Packet.GuildUpdate(TargetCharacter.Character, 7, 0, 0, 0)); } } } } //Send update packet to the kicked player TargetCharacter.client.Send(Packet.GuildUpdate(TargetCharacter.Character, 7, 0, 0, 0)); //Send guild kick message packet to the kicked player PacketWriter Writer = new PacketWriter(); //Add opcode Writer.Create(Systems.SERVER_GUILD_KICK); //Add static byte 1 Writer.Byte(1); //Send packet to kicked member TargetCharacter.client.Send(Writer.GetBytes()); //Send guildkick visual packet update to kicked player TargetCharacter.Send(Packet.GuildKick(TargetCharacter.Character.Information.UniqueID)); //Remove the player from database MsSQL.UpdateData("DELETE from guild_members where guild_member_id='" + TargetCharacter.Character.Information.CharacterID + "'"); //Update database Character.Network.Guild.TotalMembers -= 1; MsSQL.InsertData("UPDATE guild SET guild_members_t='" + Character.Network.Guild.TotalMembers + "' WHERE guild_name='" + Character.Network.Guild.Name + "'"); TargetCharacter.CleanUp(TargetCharacter); } //Catch bad exception errors catch (Exception ex) { //Write information to the console Console.WriteLine("Guild Kick Error: {0}", ex); //Write information to the debug log Systems.Debugger.Write(ex); } }
void GuildCreate() { try { //Extra check if user is allready in guild. if (Character.Network.Guild.Guildid != 0) return; //If player has recently been in a guild if (Character.Information.JoinGuildWait) { //Need to sniff the retail packet (Tmp used guild war error). client.Send(Packet.IngameMessages(Systems.SERVER_GUILD_WAIT, IngameMessages.UIIT_MSG_GUILDWARERR_GUILD_CREATE_PENALTY)); return; } //Create new packet reader for reading information PacketReader Reader = new PacketReader(PacketInformation.buffer); //None needed integer int notneeded = Reader.Int32(); //Get guild name lenght short GuildNameLen = Reader.Int16(); //Get guild name string GuildName = Reader.String(GuildNameLen); //Close packet reader Reader.Close(); //Remove bad characters from guildname GuildName = Removebadchars(GuildName); //Check length lower are 4 return if (GuildName.Length < 4) { //Send incorrect lenght client.Send(Packet.IngameMessages(Systems.SERVER_GUILD_WAIT, IngameMessages.UIIT_MSG_GUILDERR_INVALID_GUILDNAME_LEN)); return; } //Check if guild name is taken or not. int guildcheckname = MsSQL.GetRowsCount("SELECT * FROM guild WHERE guild_name='" + GuildName + "'"); //If name excists if (guildcheckname == 1) { client.Send(Packet.IngameMessages(Systems.SERVER_GUILD_WAIT, IngameMessages.UIIT_MSG_GUILDERR_SAME_GUILDNAME_EXIST)); return; } //If character level is to low if (Character.Information.Level < 20) { //Send packet level to low message client.Send(Packet.IngameMessages(Systems.SERVER_GUILD, IngameMessages.UIIT_MSG_GUILDERR_TOO_LOW_CREATOR_LEVEL)); return; } //Set the gold requirements 500.000 retail info int goldrequired = 500000; //If gold is lower then price of creating a guild if (Character.Information.Gold < goldrequired) { //Send message not enough gold client.Send(Packet.IngameMessages(SERVER_GUILD, IngameMessages.UIIT_MSG_GUILDERR_NOT_ENOUGH_GOLD)); return; } //All checks ok, continue creating new guild. else { //Reduct the gold required from player gold Character.Information.Gold -= goldrequired; //Save player information SavePlayerInfo(); //Insert guild into database MsSQL.InsertData("INSERT INTO guild (guild_name, guild_level, guild_points, guild_news_t, guild_news_m, guild_members_t, guild_master_id) VALUES ('" + GuildName + "','1','0','" + "" + "','" + "" + "','1','" + Character.Information.CharacterID + "')"); //Get guild id string guildid = MsSQL.GetData("SELECT id FROM guild WHERE guild_name='" + GuildName + "'", "id"); int docount = Convert.ToInt32(guildid); //Insert member into database MsSQL.InsertData("INSERT INTO guild_members (guild_id, guild_member_id, guild_rank, guild_points, guild_fortress, guild_grant, guild_perm_join, guild_perm_withdraw, guild_perm_union, guild_perm_storage, guild_perm_notice) VALUES ('" + docount + "','" + Character.Information.CharacterID + "','0','0','1','','1','1','1','1','1')"); //Load our new guild LoadPlayerGuildInfo(true); //Private packet client.Send(Packet.Guild_Create(Character.Network.Guild)); //Public spawn packet Send(Packet.SendGuildInfo2(this.Character)); } } catch (Exception ex) { Console.WriteLine("Guild creation error: " + ex); Systems.Debugger.Write(ex); } }
///////////////////////////////////////////////////////////////////////////////// // Friend groups ///////////////////////////////////////////////////////////////////////////////// void FriendGroup(string type) { try { //We use string type for switch statement. switch (type) { //Add new group case "ADD": //First check if the user has friends int friendcount = MsSQL.GetRowsCount("SELECT * FROM FRIENDS WHERE owner='" + Character.Information.CharacterID + "'"); //If the user has no friends return if (friendcount == 0) return; //Create our packet reader PacketReader reader = new PacketReader(PacketInformation.buffer); //Start reading information string groupname = reader.Text(); //Close the reader reader.Close(); //Update database information MsSQL.InsertData("INSERT INTO friends_groups (playerid,groupname) VALUES ('" + Character.Information.CharacterID + "','" + groupname + "')"); //Get group id from count short groupid = GetGroupId(Character.Information.CharacterID); //Send packet to client client.Send(Packet.FriendGroupManage("ADD", groupname, groupid, 0)); break; //Remove group case "REMOVE": //Create our packet reader reader = new PacketReader(PacketInformation.buffer); //Start reading information groupid = reader.Int16(); //Close the reader reader.Close(); //Get group name string groupnameinfo = GetGroupName(Character.Information.CharacterID, groupid); //Update database information MsSQL.InsertData("DELETE FROM friends_groups WHERE groupname='" + groupnameinfo + "'"); //Send packet to client client.Send(Packet.FriendGroupManage("REMOVE", groupnameinfo, groupid, 0)); break; //Move to group case "MOVE": //Create our packet reader reader = new PacketReader(PacketInformation.buffer); //Start reading information int targetid = reader.Int32(); groupid = reader.Int16(); //Close the reader reader.Close(); //Get groupname groupnameinfo = GetGroupName(Character.Information.CharacterID, groupid); //Update database information MsSQL.UpdateData("UPDATE friends SET group_name='" + groupnameinfo + "' WHERE owner='" + Character.Information.CharacterID + "' AND friend_name='" + targetid + "'"); //Send packet to client client.Send(Packet.FriendGroupManage("MOVE", groupnameinfo, groupid, targetid)); break; } } catch (Exception ex) { Systems.Debugger.Write(ex); } }