コード例 #1
0
        public void SelectObject()
        {
            try
            {

                if (Character.Information.Scroll) return;
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                int objectid = Reader.Int32();
                if (objectid == 0) return;
                //Character.Action.Target = objectid;
                //if (Character.Position.Walking) StopPlayerMovementO(objectid);
                if (objectid == Character.Information.UniqueID) return;
                WorldMgr.Monsters o = Helpers.GetInformation.GetObject(objectid);
                if (o != null)
                {
                    byte[] bb = Packet.SelectObject(objectid, o.ID, o.LocalType, o.HP);
                    if (bb == null) return;
                    client.Send(bb);
                    //Character.Action.Object = o;
                    return;
                }
                PlayerMgr sys = Helpers.GetInformation.GetPlayers(objectid);
                if (o == null && sys != null)
                {
                    client.Send(Packet.SelectObject(objectid, 0, 5, sys.Character.Stat.Hp));
                    Character.Action.Object = sys;
                    return;
                }
                Reader.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Selectobject error: {0}", ex);
            }
        }
コード例 #2
0
        public void Mastery_Skill_Up()
        {
            PacketReader Reader = new PacketReader(PacketInformation.buffer);
            int SkillID = Reader.Int32();
            /*if (Array.Exists(ObjData.Manager.SkillBase, GetSkill => GetSkill.ID == SkillID) == false)
            {
                Console.WriteLine("SkillID bulunamadı:{0}", Character.Information.Name);
            }
            */
            if (Character.Information.SkillPoint < ObjData.Manager.SkillBase[SkillID].SkillPoint) { Console.WriteLine("SP LAZIM"); return; }
            int check = DB.GetRowsCount("SELECT * FROM saved_skills WHERE skillid = " + SkillID + " AND owner=" + Character.Information.CharacterID);
            if (check == 1)
            {
                client.Send(Packet.Message(OperationCode.SERVER_SKILL_UPDATE, Messages.UIIT_STT_SKILL_LEARN_MASTERY_LIMIT));
                return;
            }
            else
            {
                Character.Stat.Skill.AmountSkill++;
                Character.Stat.Skill.Skill[Character.Stat.Skill.AmountSkill] = SkillID;
            }
            if (SkillGetOpened(SkillID))
            {
                Character.Information.SkillPoint -= ObjData.Manager.SkillBase[SkillID].SkillPoint;
                client.Send(Packet.InfoUpdate(2, Character.Information.SkillPoint, 0));
                client.Send(Packet.SkillUpdate(SkillID));
                client.Send(Packet.PlayerStat(Character));

                SaveSkill(SkillID);
            }
            else
            {
               return;
            }
        }
コード例 #3
0
        /////////////////////////////////////////////////////////////////////////////////
        // 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
        }
コード例 #4
0
        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);
            }
        }
コード例 #5
0
        /////////////////////////////////////////////////////////////////////////////////
        // 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);
            }
        }
コード例 #6
0
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // 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);
            }
        }
コード例 #7
0
 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);
     }
 }
コード例 #8
0
        public void PartyAddmembers()
        {
            try
            {
                //Create new packet reader
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                //Read target id
                int targetid = Reader.Int32();
                //Close packet reader
                Reader.Close();
                //Get detailed information from target
                PlayerMgr InvitedPlayer = Helpers.GetInformation.GetPlayer(targetid);
                //Check if the targeted player allready is in a party.
                if (InvitedPlayer.Character.Network.Party == null)
                {
                    //Set target id of target player to our id
                    InvitedPlayer.Character.Network.TargetID = this.Character.Information.UniqueID;
                    //Send request
                    InvitedPlayer.client.Send(Packet.PartyRequest(2, Character.Information.UniqueID, Character.Network.Party.Type));
                }
            }
            //Write bad exception errors
            catch (Exception ex)
            {
                //Write error to the console.
                Console.WriteLine(ex);
                //Write error to the debug log

            }
        }
コード例 #9
0
 /////////////////////////////////////////////////////////////////////////////////
 // Add new friend
 /////////////////////////////////////////////////////////////////////////////////
 public void FriendAdd()
 {
     try
     {
         PacketReader reader = new PacketReader(PacketInformation.buffer);
         short namelenght = reader.Int16();
         string name = reader.String(namelenght);
         reader.Close();
         if (name == Character.Information.Name) return;
         PlayerMgr sys = Helpers.GetInformation.GetPlayerName(name);
         if (sys != null)
         {
             sys.client.Send(Packet.FriendInviteTarget(sys.Character));
         }
         else
         {
             //Packet cannot find user
         }
     }
     catch (Exception ex)
     {
         Console.WriteLine("Friend Add error {0}", ex);
         Log.Exception(ex);
     }
 }
コード例 #10
0
 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);
     }
 }
コード例 #11
0
        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);
            }
        }
コード例 #12
0
        /////////////////////////////////////////////////////////////////////////
        // Union Apply
        /////////////////////////////////////////////////////////////////////////
        public void unionapply()
        {
            try
            {
                //Open our packet reader
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                //Get target id (Targeted).
                int Target = Reader.Int32();
                //Close reader
                Reader.Close();

                //Get target details
                PlayerMgr targetplayer = Helpers.GetInformation.GetPlayer(Target);
                //Make sure the target is still there
                if (targetplayer != null)
                {
                    //If allready in union
                    if (targetplayer.Character.Network.Guild.UnionActive) return;
                    //Set bools for both players
                    targetplayer.Character.State.UnionApply = true;
                    Character.State.UnionApply = true;
                    //Set target player to us
                    targetplayer.Character.Network.TargetID = Character.Information.UniqueID;
                    //Send request to targeted player
                    targetplayer.client.Send(Packet.PartyRequest(6, Character.Information.UniqueID, 0));
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
コード例 #13
0
 /////////////////////////////////////////////////////////////////////////////////
 // Movement angle
 /////////////////////////////////////////////////////////////////////////////////
 public void Angle()
 {
     PacketReader Reader = new PacketReader(PacketInformation.buffer);
     ushort angle = Reader.UInt16();
     client.Send(Packet.Angle(Character.Information.UniqueID, angle));
     client.Send(Packet.ChatPacket(7, 0, string.Format("ANGLE:{0}", angle), ""));
 }
コード例 #14
0
        ///////////////////////////////////////////////////////////////////////////
        // 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));
        }
コード例 #15
0
 public void GuildInvite()
 {
     //Wrap our code into a catcher
     try
     {
         //Create new packet reader
         PacketReader Reader = new PacketReader(PacketInformation.buffer);
         //Read lenght of invited character name
         Int16 InvitedCharacterLEN = Reader.Int16();
         //Read invited character name
         string InvitedCharacter = Reader.String(InvitedCharacterLEN);
         //Close packet reader
         Reader.Close();
         //Get information for target
         PlayerMgr sys = Helpers.GetInformation.GetPlayerName(InvitedCharacter);
         //Set targetid information
         Character.Network.TargetID = sys.Character.Information.UniqueID;
         //If player allready has a guild
         if (sys.Character.Network.Guild.Guildid != 0)
         {
             client.Send(Packet.Message(OperationCode.SERVER_GUILD_WAIT, Messages.UIIT_MSG_GUILDERR_MEMBER_OF_ANOTHER_GUILD));
             return;
         }
         //If player has to wait before the player can join another guild
         if (sys.Character.Information.GuildPenalty)
         {
             client.Send(Packet.Message(OperationCode.SERVER_GUILD_WAIT, Messages.UIIT_MSG_GUILD_PENALTY));
             return;
         }
         //If the guild has max members
         if (Character.Network.Guild.TotalMembers >= Character.Network.Guild.MaxMembers)
         {
             client.Send(Packet.Message(OperationCode.SERVER_GUILD_WAIT, Messages.UIIT_MSG_GUILDERR_MEMBER_FULL));
         }
         //If the character doesnt have join rights
         if (!Character.Network.Guild.joinRight)
         {
             //This should not happen unless hack attempt, because button should be grayed out
             return;
         }
         //Set targetid to the invited player
         sys.Character.Network.TargetID = this.Character.Information.UniqueID;
         //Send guild request packet
         sys.client.Send(Packet.PartyRequest(5, this.Character.Information.UniqueID, 0));
         //Set bools active
         Character.State.GuildInvite = true;
         sys.Character.State.GuildInvite = true;
     }
     //Catch bad exception errors
     catch (Exception ex)
     {
         Log.Exception(ex);
     }
 }
コード例 #16
0
        //##############################################################################
        // 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;
        }
コード例 #17
0
        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);
            }
        }
コード例 #18
0
 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);
     }
 }
コード例 #19
0
        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

            }
        }
コード例 #20
0
        public void Save()
        {
            //Wrap our function inside a catcher
            try
            {
                //Open our packet reader
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                string player_path;
                byte[] file;
                //Switch on byte
                switch (Reader.Byte())
                {
                    case 1:
                        //Save quickbar information
                        player_path = Environment.CurrentDirectory + @"\PlayerData\Hotkey\" + Character.Information.CharacterID + ".ClientSettings";
                        file = System.IO.File.ReadAllBytes(player_path);

                        byte Slot = Reader.Byte();
                        byte sType = Reader.Byte();

                        Slot *= 5;

                        file[Slot] = sType;
                        file[Slot + 1] = Reader.Byte();
                        file[Slot + 2] = Reader.Byte();
                        file[Slot + 3] = Reader.Byte();
                        file[Slot + 4] = Reader.Byte();
                        System.IO.File.WriteAllBytes(player_path, file);
                        break;
                    case 2:
                        //Save autopotion information
                        player_path = Environment.CurrentDirectory + @"\PlayerData\AutoPotion\" + Character.Information.CharacterID + ".ClientSettings";
                        file = System.IO.File.ReadAllBytes(player_path);
                        file[0] = Reader.Byte();
                        file[1] = Reader.Byte();
                        file[2] = Reader.Byte();
                        file[3] = Reader.Byte();
                        file[4] = Reader.Byte();
                        file[5] = Reader.Byte();
                        file[6] = Reader.Byte();
                        System.IO.File.WriteAllBytes(player_path, file);
                        UpdateHp();
                        UpdateMp();
                        break;
                }
                Reader.Close();
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
コード例 #21
0
        public void GuildTransferLeaderShip()
        {
            try
            {
                //Create new packet reader
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                //Read guild id
                int Guildid = Reader.Int32();
                //Read guild member id to transfer to
                int GuildMemberID = Reader.Int32();
                //Close reader
                Reader.Close();

                //Get detailed player information
                PlayerMgr NewLeader = Helpers.GetInformation.GetPlayerid(GuildMemberID);

                //Update database
                DB.query("UPDATE guild_members SET guild_rank='10',guild_perm_join='0',guild_perm_withdraw='0',guild_perm_union='0',guild_perm_storage='0',guild_perm_notice='0' WHERE guild_member_id='" + Character.Information.CharacterID + "'");
                DB.query("UPDATE guild_members SET guild_rank='0',guild_perm_join='1',guild_perm_withdraw='1',guild_perm_union='1',guild_perm_storage='1',guild_perm_notice='1' WHERE guild_member_id='" + GuildMemberID + "'");

                //Repeat for each member in our guild
                foreach (int member in Character.Network.Guild.Members)
                {
                    //Make sure member is not null
                    if (member != 0)
                    {
                        //Get information for the guildmember
                        PlayerMgr guildmember = Helpers.GetInformation.GetPlayerMainid(member);
                        //Make sure the guildmember isnt null
                        if (guildmember != null)
                        {
                            //Send update packet of new leader
                            guildmember.client.Send(Packet.GuildUpdate(Character, 3, GuildMemberID, 0, 0));
                        }
                    }
                }
                //Send message to old owner
                PacketWriter Writer = new PacketWriter();
                //Add opcode
                Writer.Create(OperationCode.SERVER_GUILD_TRANSFER_MSG);
                //Static byte 1
                Writer.Byte(1);
                //Send bytes to client
                client.Send(Writer.GetBytes());
            }
            //If a bad exception error happens
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
コード例 #22
0
        //Will need to read this byte by byte to get the id for the server to record for the chardata
        public void Gameguide()
        {
            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);
            }
        }
コード例 #23
0
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // 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);
     }
 }
コード例 #24
0
        public void GuildWarGold()
        {
            PacketReader Reader = new PacketReader(PacketInformation.buffer);
            int guildid = Reader.Int32();
            Reader.Close();

            if (Character.Guild.GuildWarGold == 0)
            {
                //Send Packet Message No War Gold Received
                client.Send(Packet.GuildWarMsg(2));
            }
            else
            {
                //Sniff packet for war gold
            }
        }
コード例 #25
0
        public void GuildMessage()
        {
            //Wrap our function inside a catcher
            try
            {
                //Create new packet reader
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                //Read short int16 for title lenght
                short TitleL = Reader.Int16();
                //Read string for title
                string Title = Reader.String(TitleL);
                //Read short Message lenght
                short MessageL = Reader.Int16();
                //Read message
                string Message = Reader.String(MessageL);
                //Close reader
                Reader.Close();

                //Update database guild message title and message
                DB.query("UPDATE guild SET guild_news_t='" + Title + "',guild_news_m='" + Message + "' WHERE guild_name='" + Character.Network.Guild.Name + "'");

                //Set new message info to current member for sending packet update.
                Character.Network.Guild.NewsTitle = Title;
                Character.Network.Guild.NewsMessage = Message;
                //Repeat for each member in our guild
                foreach (int member in Character.Network.Guild.Members)
                {
                    //Make sure the member is there
                    if (member != 0)
                    {
                        //Get detailed information from member main id
                        PlayerMgr characterinformation = Helpers.GetInformation.GetPlayerid(member);
                        //Set the current member news title and message information
                        characterinformation.Character.Network.Guild.NewsMessage = Message;
                        characterinformation.Character.Network.Guild.NewsTitle = Title;
                        //Send packet to the member to update guild message.
                        characterinformation.client.Send(Packet.GuildUpdate(characterinformation.Character, 11, 0, 0, 0));
                    }
                }
            }
            //Catch any bad exception error
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
コード例 #26
0
        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);
            }
        }
コード例 #27
0
 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);
     }
 }
コード例 #28
0
        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);
            }
        }
コード例 #29
0
        public void HandleClosePet()
        {
            try
            {
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                int petid = Reader.Int32();

                if (petid == Character.Transport.Horse.UniqueID)
                {
                    Send(Packet.Player_UpToHorse(Character.Information.UniqueID, false, petid));
                    client.Send(Packet.PetSpawn(petid, 1, Character.Transport.Horse));
                    Character.Transport.Horse.DeSpawnMe();
                    Character.Transport.Right = false;
                    if (Character.Position.Walking) Timer.Movement.Dispose();
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
コード例 #30
0
 //Public void select opcode
 public static void Opcode_List(Decode information)
 {
     //Set definition for detailed information
     Definitions.Clientdefinition Control = (Definitions.Clientdefinition)information.Packet;
     //Set Packetinformation as information (short).
     Control.PacketInformation = information;
     //Create a new packet reader to view incoming packet data
     PacketReader R = new PacketReader(Control.PacketInformation.buffer);
     //Create switch code based on the opcode the client sends.
     switch (information.opcode)
     {
         case Opcodes.CLIENT.CLIENT_PING_CHECK:
             break;
         case Opcodes.CLIENT.CLIENT_INFO:
             //If the client connecting is silkroad
             if (R.Text() == "SR_Client")
                 Control.client.Send(Connect.GateWayPacket());
             break;
         case Opcodes.CLIENT.CLIENT_GATEWAY_PATCH_REQUEST:
             Functions.Connect.ClientCheck(Control);
             break;
         case Opcodes.CLIENT.CLIENT_GATEWAY_SERVERLIST_REQUEST:
             Control.client.Send(Serverlist.ServerListPacket(0));
             break;
         case Opcodes.CLIENT.CLIENT_GATEWAY_LOGIN_REQUEST:
             Functions.Auth.Connect(Control);
             break;
         case Opcodes.CLIENT.CLIENT_GATEWAY_NOTICE_REQUEST:
             Control.client.Send(Connect._6());
             Control.client.Send(News.NewsPacket());
             break;
         case 1905:
             byte[] buffer = information.buffer;
             Definitions.Clientdefinition.Connected_Users = BitConverter.ToInt16(buffer, 0);
             break;
         default:
             break;
     }
 }