public static void Send(Character character, InventoryEntries inventoryEntries)
        {
            PacketWriter packetWriter = new PacketWriter();

            packetWriter.PushByte(0xdf);
            packetWriter.PushByte(0xdf);
            packetWriter.PushShort(0xa);
            packetWriter.PushShort(1);
            packetWriter.PushShort(0);
            packetWriter.PushInt(3086);
            packetWriter.PushInt(character.Id);
            packetWriter.PushInt(0x52526858);
            packetWriter.PushInt(50000);
            packetWriter.PushInt(character.Id);
            packetWriter.PushByte(0);
            packetWriter.PushInt(1);
            packetWriter.PushInt(3);
            packetWriter.PushInt(3);
            packetWriter.PushInt(0);
            packetWriter.PushInt(50000);
            packetWriter.PushInt(character.Id);
            packetWriter.PushInt(inventoryEntries.Container);
            packetWriter.PushInt(inventoryEntries.Placement);
            byte[] pack = packetWriter.Finish();
            character.Client.SendCompressed(pack);
        }
        public static void Send(Character character, InventoryEntries inventoryEntry)
        {
            PacketWriter packetWriter = new PacketWriter();

            packetWriter.PushByte(0xdf);
            packetWriter.PushByte(0xdf);
            packetWriter.PushShort(0xa);
            packetWriter.PushShort(1);
            packetWriter.PushShort(0);
            packetWriter.PushInt(3086);
            packetWriter.PushInt(character.Id);
            packetWriter.PushInt(0x35505644);
            packetWriter.PushInt(50000);
            packetWriter.PushInt(character.Id);
            packetWriter.PushByte(0);
            packetWriter.PushInt(inventoryEntry.Item.LowID);
            packetWriter.PushInt(inventoryEntry.Item.HighID);
            packetWriter.PushInt(inventoryEntry.Item.Quality);
            packetWriter.PushInt(1); // Unknown
            packetWriter.PushInt(3); // Consume??
            packetWriter.PushInt(inventoryEntry.Container);
            packetWriter.PushInt(inventoryEntry.Placement);
            packetWriter.PushInt(0); // Unknown
            packetWriter.PushInt(0); // Unknown

            byte[] packet = packetWriter.Finish();
            character.Client.SendCompressed(packet);
        }
 public override void ExecuteCommand(Client client, Identity target, string[] args)
 {
     Client targetClient = null;
     if ((targetClient = FindClient.FindClientByName(args[1])) != null)
     {
         int firstfree = 64;
         firstfree = targetClient.Character.GetNextFreeInventory(104);
         if (firstfree <= 93)
         {
             InventoryEntries mi = new InventoryEntries();
             AOItem it = ItemHandler.GetItemTemplate(Convert.ToInt32(args[2]));
             mi.Placement = firstfree;
             mi.Container = 104;
             mi.Item.LowID = Convert.ToInt32(args[2]);
             mi.Item.HighID = Convert.ToInt32(args[3]);
             mi.Item.Quality = Convert.ToInt32(args[4]);
             if (it.ItemType != 1)
             {
                 mi.Item.MultipleCount = Math.Max(1, it.getItemAttribute(212));
             }
             else
             {
                 bool found = false;
                 foreach (AOItemAttribute a in mi.Item.Stats)
                 {
                     if (a.Stat != 212)
                     {
                         continue;
                     }
                     found = true;
                     a.Value = Math.Max(1, it.getItemAttribute(212));
                     break;
                 }
                 if (!found)
                 {
                     AOItemAttribute aoi = new AOItemAttribute();
                     aoi.Stat = 212;
                     aoi.Value = Math.Max(1, it.getItemAttribute(212));
                     mi.Item.Stats.Add(aoi);
                 }
             }
             targetClient.Character.Inventory.Add(mi);
             AddTemplate.Send(targetClient, mi);
         }
         else
         {
             client.SendChatText("Your Inventory is full");
         }
     }
 }
        public static void Send(Client client, InventoryEntries inventoryEntry)
        {
            PacketWriter packetWriter = new PacketWriter();

            packetWriter.PushByte(0xdf);
            packetWriter.PushByte(0xdf);
            packetWriter.PushShort(0xa);
            packetWriter.PushShort(1);
            packetWriter.PushShort(0);
            packetWriter.PushInt(3086);
            packetWriter.PushInt(client.Character.Id);
            packetWriter.PushInt(0x052e2f0c);
            packetWriter.PushIdentity(client.Character.Type, client.Character.Id);
            packetWriter.PushByte(0);
            packetWriter.PushInt(inventoryEntry.Item.LowID);
            packetWriter.PushInt(inventoryEntry.Item.HighID);
            packetWriter.PushInt(inventoryEntry.Item.Quality);
            packetWriter.PushInt(inventoryEntry.Item.MultipleCount);

            byte[] packet = packetWriter.Finish();

            client.SendCompressed(packet);
        }
Beispiel #5
0
 /// <summary>
 /// Add/Subtract stacked item or add a item to inventory
 /// </summary>
 /// <param name="ie"></param>
 public void InventoryReplaceAdd(InventoryEntries ie)
 {
     lock (Inventory)
     {
         ItemHandler.Item it = new ItemHandler.Item(ie.Item.lowID);
         //            if (it.isStackable())
         {
             foreach (InventoryEntries ia in Inventory)
             {
                 if ((ia.Item.lowID == ie.Item.lowID) && (ia.Item.highID == ie.Item.highID) && (ia.Container == -1))
                 {
                     ia.Item.multiplecount += ie.Item.multiplecount;
                     if (ia.Item.multiplecount == 0)
                     {
                         Inventory.Remove(ia);
                     }
                     return;
                 }
             }
         }
         Inventory.Add(ie);
     }
 }
Beispiel #6
0
        /// <summary>
        /// Transfer item from bank account to inventory
        /// </summary>
        /// <param name="_from">from bank location</param>
        /// <param name="_to">to inventory location</param>
        public void TransferItemfromBank(int _from, int _to)
        {
            lock (this)
            {
                int placement = GetNextFreeInventory(0x68);

                AOItem tempitem = null;
                foreach (AOItem aoi in Bank)
                {
                    if (aoi.flags == _from)
                    {
                        tempitem = aoi;
                        break;
                    }
                }
                if (tempitem == null)
                {
                    Console.WriteLine("Not valid item...");
                    return;
                }



                InventoryEntries mi = new InventoryEntries();
                ItemHandler.Item it = new ItemHandler.Item(tempitem.lowID);
                mi.Placement = placement;
                mi.Container = 104;
                mi.Item.lowID = tempitem.lowID;
                mi.Item.highID = tempitem.highID;
                mi.Item.Quality = tempitem.Quality;
                mi.Item.multiplecount = Math.Max(1, (int)tempitem.multiplecount);
                Inventory.Add(mi);
                Bank.Remove(tempitem);
                writeBankContentstoSQL();
                writeInventorytoSQL();
            }
        }
 public void FillInventory()
 {
     List<ShopInv> shopinvs = new List<ShopInv>();
     int place = 0;
     Random r = new Random();
     string like = "";
     SqlWrapper sqlWrapper = new SqlWrapper();
     DataTable dt = sqlWrapper.ReadDatatable("SELECT * from vendortemplate where HASH='" + this.Hash + "'");
     foreach (DataRow row in dt.Rows)
     {
         ShopInv shopInventory = new ShopInv
             { Hash = (string)row["ShopInvHash"], MinQl = (Int32)row["minQL"], MaxQl = (Int32)row["maxQL"] };
         shopinvs.Add(shopInventory);
         if (like != "")
         {
             like += "OR ";
         }
         like += "HASH LIKE '%" + shopInventory.Hash + "%' ";
     }
     if (like != "")
     {
         this.Inventory.Clear();
         dt = sqlWrapper.ReadDatatable("SELECT * from shopinventorytemplates where " + like + "and active = 1");
         foreach (DataRow row in dt.Rows)
         {
             string thisHash = (string)row["Hash"];
             foreach (ShopInv si in shopinvs)
             {
                 if (si.Hash == thisHash)
                 {
                     int minQl = (Int32)row["minql"];
                     int maxQl = (Int32)row["maxql"];
                     // Dont add Items that are not between si.minQL and si.maxQL
                     if ((minQl <= si.MaxQl) && (maxQl >= si.MinQl))
                     {
                         InventoryEntries inventoryEntry = new InventoryEntries
                             {
                                 Container = 104,
                                 Placement = place++,
                                 Item =
                                     {
                                         LowID = (Int32)row["lowid"],
                                         HighID = (Int32)row["highid"],
                                         MultipleCount = (Int32)row["multiplecount"],
                                         Nothing = 0,
                                         Quality =
                                             Math.Min(
                                                 Math.Max(Convert.ToInt32(r.Next(si.MinQl, si.MaxQl)), minQl),
                                                 maxQl)
                                     }
                             };
                         this.Inventory.Add(inventoryEntry);
                     }
                 }
             }
         }
     }
 }
 public void fillInventory()
 {
     InventoryEntries ie;
     List<ShopInv> shopinvs = new List<ShopInv>();
     ShopInv temp;
     int place = 0;
     int iminql = 0;
     int imaxql = 0;
     Random r = new Random();
     string like = "";
     SqlWrapper Sql = new SqlWrapper();
     DataTable dt = Sql.ReadDT("SELECT * from vendortemplate where HASH='" + HASH + "'");
     foreach (DataRow row in dt.Rows)
     {
         temp = new ShopInv();
         temp.HASH = (string)row["ShopInvHash"];
         temp.minQL = (Int32)row["minQL"];
         temp.maxQL = (Int32)row["maxQL"];
         shopinvs.Add(temp);
         if (like != "")
         {
             like += "OR ";
         }
         like += "HASH LIKE '%" + temp.HASH + "%' ";
     }
     if (like != "")
     {
         Inventory.Clear();
         dt = Sql.ReadDT("SELECT * from shopinventorytemplates where " + like);
         string thishash;
         foreach (DataRow row in dt.Rows)
         {
             thishash = (string)row["Hash"];
             foreach (ShopInv si in shopinvs)
             {
                 if (si.HASH == thishash)
                 {
                     iminql = (Int32)row["minql"];
                     imaxql = (Int32)row["maxql"];
                     // Dont add Items that are not between si.minQL and si.maxQL
                     if ((iminql <= si.maxQL) && (imaxql >= si.minQL))
                     {
                         ie = new InventoryEntries();
                         ie.Container = 104;
                         ie.Placement = place++;
                         ie.Item.lowID = (Int32)row["lowid"];
                         ie.Item.highID = (Int32)row["highid"];
                         ie.Item.multiplecount = (Int32)row["multiplecount"];
                         ie.Item.Nothing = 0;
                         ie.Item.Quality = Math.Min(Math.Max(Convert.ToInt32(r.Next(si.minQL, si.maxQL)), iminql), imaxql);
                         Inventory.Add(ie);
                     }
                 }
             }
         }
     }
 }
Beispiel #9
0
        /// <summary>
        /// Transfer item from bank account to inventory
        /// </summary>
        /// <param name="fromPlacement">from bank location</param>
        /// <param name="toPlacement">to inventory location</param>
        public void TransferItemfromBank(int fromPlacement, int toPlacement)
        {
            lock (this)
            {
                int placement = this.GetNextFreeInventory(0x68);

                AOItem tempItem = null;
                foreach (AOItem item in this.bank)
                {
                    if (item.Flags == fromPlacement)
                    {
                        tempItem = item;
                        break;
                    }
                }
                if (tempItem == null)
                {
                    Console.WriteLine("Not valid item...");
                    return;
                }

                InventoryEntries mi = new InventoryEntries();
                AOItem it = ItemHandler.GetItemTemplate(tempItem.LowID);
                mi.Placement = placement;
                mi.Container = 104;
                mi.Item.LowID = tempItem.LowID;
                mi.Item.HighID = tempItem.HighID;
                mi.Item.Quality = tempItem.Quality;
                mi.Item.MultipleCount = Math.Max(1, tempItem.MultipleCount);
                this.inventory.Add(mi);
                this.bank.Remove(tempItem);
                this.WriteBankContentsToSql();
                this.WriteInventoryToSql();
            }
        }
Beispiel #10
0
 public void SpawnItem(int lowid, int highid, int ql)
 {
     // TODO: Add check for full inventory!
     InventoryEntries mi = new InventoryEntries();
     AOItem it = ItemHandler.interpolate(lowid, highid, ql);
     mi.Item = it;
     mi.Container = 104;
     mi.Placement = this.TalkingTo.GetNextFreeInventory(104);
     this.TalkingTo.Inventory.Add(mi);
     AddTemplate.Send(this.TalkingTo.Client, mi);
 }
        public static void Read(byte[] packet, Client client)
        {
            SqlWrapper mys = new SqlWrapper();

            // Packet Reader Unknown Values are Returning 0 Integers, Unable to Store Needed Packet data To Reply.

            #region PacketReader
            PacketReader packetReader = new PacketReader(packet);
            Header m_header = packetReader.PopHeader(); // 0 - 28
            byte unknown = packetReader.PopByte(); // 29
            int actionNum = packetReader.PopInt(); // 30 - 33
            int unknown1 = packetReader.PopInt(); // 34 - 37
            Identity m_ident = packetReader.PopIdentity(); // 38 - 35
            int unknown2 = packetReader.PopInt(); // 36 - 39
            int unknown3 = packetReader.PopInt(); // 40 - 43
            short unknown4 = packetReader.PopShort(); // 44 - 45
            #endregion

            switch (actionNum)
            {
                    #region Cast nano
                case 19: // Cast nano
                    {
                        // CastNanoSpell
                        PacketWriter castNanoSpell = new PacketWriter();
                        castNanoSpell.PushByte(0xDF);
                        castNanoSpell.PushByte(0xDF);
                        castNanoSpell.PushShort(10);
                        castNanoSpell.PushShort(1);
                        castNanoSpell.PushShort(0);
                        castNanoSpell.PushInt(3086);
                        castNanoSpell.PushInt(client.Character.Id);
                        castNanoSpell.PushInt(0x25314D6D);
                        castNanoSpell.PushIdentity(50000, client.Character.Id);
                        castNanoSpell.PushByte(0);
                        castNanoSpell.PushInt(unknown3); // Nano ID
                        castNanoSpell.PushIdentity(m_ident); // Target
                        castNanoSpell.PushInt(0);
                        castNanoSpell.PushIdentity(50000, client.Character.Id); // Caster
                        byte[] castNanoSpellA = castNanoSpell.Finish();
                        Announce.Playfield(client.Character.PlayField, castNanoSpellA);

                        // CharacterAction 107
                        PacketWriter characterAction107 = new PacketWriter();
                        characterAction107.PushByte(0xDF);
                        characterAction107.PushByte(0xDF);
                        characterAction107.PushShort(10);
                        characterAction107.PushShort(1);
                        characterAction107.PushShort(0);
                        characterAction107.PushInt(3086);
                        characterAction107.PushInt(client.Character.Id);
                        characterAction107.PushInt(0x5E477770);
                        characterAction107.PushIdentity(50000, client.Character.Id);
                        characterAction107.PushByte(0);
                        characterAction107.PushInt(107);
                        characterAction107.PushInt(0);
                        characterAction107.PushInt(0);
                        characterAction107.PushInt(0);
                        characterAction107.PushInt(1);
                        characterAction107.PushInt(unknown3);
                        characterAction107.PushShort(0);
                        byte[] characterAction107A = characterAction107.Finish();
                        Announce.Playfield(client.Character.PlayField, characterAction107A);

                        // CharacterAction 98
                        PacketWriter characterAction98 = new PacketWriter();
                        characterAction98.PushByte(0xDF);
                        characterAction98.PushByte(0xDF);
                        characterAction98.PushShort(10);
                        characterAction98.PushShort(1);
                        characterAction98.PushShort(0);
                        characterAction98.PushInt(3086);
                        characterAction98.PushInt(client.Character.Id);
                        characterAction98.PushInt(0x5E477770);
                        characterAction98.PushIdentity(m_ident);
                        characterAction98.PushByte(0);
                        characterAction98.PushInt(98);
                        characterAction98.PushInt(0);
                        characterAction98.PushInt(0xCF1B);
                        characterAction98.PushInt(unknown3);
                        characterAction98.PushInt(client.Character.Id);
                        characterAction98.PushInt(0x249F0); // duration?
                        characterAction98.PushShort(0);
                        byte[] characterAction98A = characterAction98.Finish();
                        Announce.Playfield(client.Character.PlayField, characterAction98A);
                    }
                    break;
                    #endregion

                    #region search
                    /* this is here to prevent server crash that is caused by
                 * search action if server doesn't reply if something is
                 * found or not */
                case 66: // If action == search
                    {
                        /* Msg 110:136744723 = "No hidden objects found." */
                        client.SendFeedback(110, 136744723);
                    }
                    break;
                    #endregion

                    #region info
                case 105: // If action == Info Request
                    {
                        Client tPlayer = null;
                        if ((tPlayer = FindClient.FindClientById(m_ident.Instance)) != null)
                        {
                            #region Titles
                            uint LegacyScore = tPlayer.Character.Stats.PvpRating.StatBaseValue;
                            string LegacyTitle = null;
                            if (LegacyScore < 1400)
                            {
                                LegacyTitle = "";
                            }
                            else if (LegacyScore < 1500)
                            {
                                LegacyTitle = "Freshman";
                            }
                            else if (LegacyScore < 1600)
                            {
                                LegacyTitle = "Rookie";
                            }
                            else if (LegacyScore < 1700)
                            {
                                LegacyTitle = "Apprentice";
                            }
                            else if (LegacyScore < 1800)
                            {
                                LegacyTitle = "Novice";
                            }
                            else if (LegacyScore < 1900)
                            {
                                LegacyTitle = "Neophyte";
                            }
                            else if (LegacyScore < 2000)
                            {
                                LegacyTitle = "Experienced";
                            }
                            else if (LegacyScore < 2100)
                            {
                                LegacyTitle = "Expert";
                            }
                            else if (LegacyScore < 2300)
                            {
                                LegacyTitle = "Master";
                            }
                            else if (LegacyScore < 2500)
                            {
                                LegacyTitle = "Champion";
                            }
                            else
                            {
                                LegacyTitle = "Grand Master";
                            }
                            #endregion

                            int orgGoverningForm = 0;
                            SqlWrapper ms = new SqlWrapper();
                            DataTable dt =
                                ms.ReadDatatable(
                                    "SELECT `GovernmentForm` FROM organizations WHERE ID=" + tPlayer.Character.OrgId);

                            if (dt.Rows.Count > 0)
                            {
                                orgGoverningForm = (Int32)dt.Rows[0][0];
                            }

                            string orgRank = OrgClient.GetRank(
                                orgGoverningForm, tPlayer.Character.Stats.ClanLevel.StatBaseValue);
                            // Uses methods in ZoneEngine\PacketHandlers\OrgClient.cs
                            /* Known packetFlags--
                             * 0x40 - No org | 0x41 - Org | 0x43 - Org and towers | 0x47 - Org, towers, player has personal towers | 0x50 - No pvp data shown
                             * Bitflags--
                             * Bit0 = hasOrg, Bit1 = orgTowers, Bit2 = personalTowers, Bit3 = (Int32) time until supression changes (Byte) type of supression level?, Bit4 = noPvpDataShown, Bit5 = hasFaction, Bit6 = ?, Bit 7 = null.
                            */
                            byte packetFlags = 0x40; // Player has no Org
                            if (tPlayer.Character.OrgId != 0)
                            {
                                packetFlags = 0x41; // Player has Org, no towers
                            }
                            PacketWriter infoPacket = new PacketWriter();

                            // Start packet header
                            infoPacket.PushByte(0xDF);
                            infoPacket.PushByte(0xDF);
                            infoPacket.PushShort(10);
                            infoPacket.PushShort(1);
                            infoPacket.PushShort(0);
                            infoPacket.PushInt(3086); // sender (server ID)
                            infoPacket.PushInt(client.Character.Id); // receiver 
                            infoPacket.PushInt(0x4D38242E); // packet ID
                            infoPacket.PushIdentity(50000, tPlayer.Character.Id); // affected identity
                            infoPacket.PushByte(0); // ?
                            // End packet header

                            infoPacket.PushByte(packetFlags); // Based on flags above
                            infoPacket.PushByte(1); // esi_001?
                            infoPacket.PushByte((byte)tPlayer.Character.Stats.Profession.Value); // Profession
                            infoPacket.PushByte((byte)tPlayer.Character.Stats.Level.Value); // Level
                            infoPacket.PushByte((byte)tPlayer.Character.Stats.TitleLevel.Value); // Titlelevel
                            infoPacket.PushByte((byte)tPlayer.Character.Stats.VisualProfession.Value);
                            // Visual Profession
                            infoPacket.PushShort(0); // Side XP Bonus
                            infoPacket.PushUInt(tPlayer.Character.Stats.Health.Value); // Current Health (Health)
                            infoPacket.PushUInt(tPlayer.Character.Stats.Life.Value); // Max Health (Life)
                            infoPacket.PushInt(0); // BreedHostility?
                            infoPacket.PushUInt(tPlayer.Character.OrgId); // org ID
                            infoPacket.PushShort((short)tPlayer.Character.FirstName.Length);
                            infoPacket.PushBytes(Encoding.ASCII.GetBytes(tPlayer.Character.FirstName));
                            infoPacket.PushShort((short)tPlayer.Character.LastName.Length);
                            infoPacket.PushBytes(Encoding.ASCII.GetBytes(tPlayer.Character.LastName));
                            infoPacket.PushShort((short)LegacyTitle.Length);
                            infoPacket.PushBytes(Encoding.ASCII.GetBytes(LegacyTitle));
                            infoPacket.PushShort(0); // Title 2

                            // If receiver is in the same org as affected identity, whom is not orgless, send org rank and city playfield
                            if ((client.Character.OrgId == tPlayer.Character.OrgId) && (tPlayer.Character.OrgId != 0))
                            {
                                infoPacket.PushShort((short)orgRank.Length);
                                infoPacket.PushBytes(Encoding.ASCII.GetBytes(orgRank));
                                infoPacket.PushInt(0);
                                //infoPacket.PushIdentity(0, 0); // City (50201, Playfield) // Pushed 1 zero to much and screwed info for characters in orgs, but I´ll leave it for later just incase.
                            }

                            infoPacket.PushUInt(tPlayer.Character.Stats.InvadersKilled.Value); // Invaders Killed
                            infoPacket.PushUInt(tPlayer.Character.Stats.KilledByInvaders.Value); // Killed by Invaders
                            infoPacket.PushUInt(tPlayer.Character.Stats.AlienLevel.Value); // Alien Level
                            infoPacket.PushUInt(tPlayer.Character.Stats.PvpDuelKills.Value); // Pvp Duel Kills 
                            infoPacket.PushUInt(tPlayer.Character.Stats.PvpDuelDeaths.Value); // Pvp Duel Deaths
                            infoPacket.PushUInt(tPlayer.Character.Stats.PvpProfessionDuelDeaths.Value);
                            // Pvp Profession Duel Kills 
                            infoPacket.PushUInt(tPlayer.Character.Stats.PvpRankedSoloKills.Value); // Pvp Solo Kills
                            infoPacket.PushUInt(tPlayer.Character.Stats.PvpRankedSoloDeaths.Value); // Pvp Team Kills
                            infoPacket.PushUInt(tPlayer.Character.Stats.PvpSoloScore.Value); // Pvp Solo Score
                            infoPacket.PushUInt(tPlayer.Character.Stats.PvpTeamScore.Value); // Pvp Team Score
                            infoPacket.PushUInt(tPlayer.Character.Stats.PvpDuelScore.Value); // Pvp Duel Score

                            byte[] infoPacketA = infoPacket.Finish();
                            client.SendCompressed(infoPacketA);
                        }
                        else
                        {
                            NonPlayerCharacterClass npc =
                                (NonPlayerCharacterClass)FindDynel.FindDynelById(m_ident.Type, m_ident.Instance);
                            if (npc != null)
                            {
                                PacketWriter infoPacket = new PacketWriter();

                                // Start packet header
                                infoPacket.PushByte(0xDF);
                                infoPacket.PushByte(0xDF);
                                infoPacket.PushShort(10);
                                infoPacket.PushShort(1);
                                infoPacket.PushShort(0);
                                infoPacket.PushInt(3086); // sender (server ID)
                                infoPacket.PushInt(client.Character.Id); // receiver 
                                infoPacket.PushInt(0x4D38242E); // packet ID
                                infoPacket.PushIdentity(50000, npc.Id); // affected identity
                                infoPacket.PushByte(0); // ?
                                // End packet header

                                infoPacket.PushByte(0x50); // npc's just have 0x50
                                infoPacket.PushByte(1); // esi_001?
                                infoPacket.PushByte((byte)npc.Stats.Profession.Value); // Profession
                                infoPacket.PushByte((byte)npc.Stats.Level.Value); // Level
                                infoPacket.PushByte((byte)npc.Stats.TitleLevel.Value); // Titlelevel
                                infoPacket.PushByte((byte)npc.Stats.VisualProfession.Value); // Visual Profession

                                infoPacket.PushShort(0); // no idea for npc's
                                infoPacket.PushUInt(npc.Stats.Health.Value); // Current Health (Health)
                                infoPacket.PushUInt(npc.Stats.Life.Value); // Max Health (Life)
                                infoPacket.PushInt(0); // BreedHostility?
                                infoPacket.PushUInt(0); // org ID
                                infoPacket.PushShort(0);
                                infoPacket.PushShort(0);
                                infoPacket.PushShort(0);
                                infoPacket.PushShort(0);
                                infoPacket.PushInt(0x499602d2);
                                infoPacket.PushInt(0x499602d2);
                                infoPacket.PushInt(0x499602d2);
                                byte[] infoPacketA = infoPacket.Finish();
                                client.SendCompressed(infoPacketA);
                            }
                        }
                    }
                    break;
                    #endregion

                    #region logout
                case 120: // If action == Logout
                    {
                        //Start 30 second logout timer if client is not a GM (statid 215)
                        if (client.Character.Stats.GMLevel.Value == 0)
                        {
                            client.startLogoutTimer();
                        }
                        else // If client is a GM, disconnect without timer
                        {
                            client.Server.DisconnectClient(client);
                        }
                    }
                    break;
                case 121: // If action == Stop Logout
                    {
                        //Stop current logout timer and send stop logout packet
                        client.Character.UpdateMoveType((byte)client.Character.PreviousMoveMode);
                        client.CancelLogOut();
                    }
                    break;
                    #endregion

                    #region stand
                case 87: // If action == Stand
                    {
                        client.Character.UpdateMoveType(37);
                        //Send stand up packet, and cancel timer/send stop logout packet if timer is enabled
                        client.StandCancelLogout();
                    }
                    break;
                    #endregion

                    #region Team
                case 22: //Kick Team Member
                    {
                    }
                    break;
                case 24: //Leave Team
                    {
                        TeamClass team = new TeamClass();
                        team.LeaveTeam(client);
                    }
                    break;
                case 25: //Transfer Team Leadership
                    {
                    }
                    break;
                case 26: //Team Join Request
                    {
                        // Send Team Invite Request To Target Player

                        TeamClass team = new TeamClass();
                        team.SendTeamRequest(client, m_ident);
                    }
                    break;
                case 28: //Request Reply
                    {
                        // Check if positive or negative response

                        // if positive

                        TeamClass team = new TeamClass();
                        uint teamID = TeamClass.GenerateNewTeamId(client, m_ident);

                        // Destination Client 0 = Sender, 1 = Reciever

                        // Reciever Packets
                        ///////////////////

                        // CharAction 15
                        team.TeamRequestReply(client, m_ident);
                        // CharAction 23
                        team.TeamRequestReplyCharacterAction23(client, m_ident);

                        // TeamMember Packet
                        team.TeamReplyPacketTeamMember(1, client, m_ident, "Member1");
                        // TeamMemberInfo Packet
                        team.TeamReplyPacketTeamMemberInfo(1, client, m_ident);
                        // TeamMember Packet
                        team.TeamReplyPacketTeamMember(1, client, m_ident, "Member2");

                        // Sender Packets
                        /////////////////

                        // TeamMember Packet
                        team.TeamReplyPacketTeamMember(0, client, m_ident, "Member1");
                        // TeamMemberInfo Packet
                        team.TeamReplyPacketTeamMemberInfo(0, client, m_ident);
                        // TeamMember Packet
                        team.TeamReplyPacketTeamMember(0, client, m_ident, "Member2");
                    }
                    break;
                    #endregion

                    #region Delete Item
                case 0x70:
                    mys.SqlDelete(
                        "DELETE FROM " + client.Character.GetSqlTablefromDynelType() + "inventory WHERE placement="
                        + m_ident.Instance.ToString() + " AND container=" + m_ident.Type.ToString());
                    InventoryEntries i_del = client.Character.GetInventoryAt(m_ident.Instance);
                    client.Character.Inventory.Remove(i_del);
                    byte[] action2 = new byte[0x37];
                    Array.Copy(packet, action2, 0x37);
                    action2[8] = 0x00;
                    action2[9] = 0x00;
                    action2[10] = 0x0C;
                    action2[11] = 0x0E;
                    client.SendCompressed(action2);
                    break;
                    #endregion

                    #region Split item
                case 0x34:
                    int nextid = client.Character.GetNextFreeInventory(m_ident.Type);
                    InventoryEntries i = client.Character.GetInventoryAt(m_ident.Instance);
                    i.Item.MultipleCount -= unknown3;
                    InventoryEntries i2 = new InventoryEntries();
                    i2.Item = i.Item.ShallowCopy();
                    i2.Item.MultipleCount = unknown3;
                    i2.Placement = nextid;
                    client.Character.Inventory.Add(i2);
                    client.Character.WriteInventoryToSql();
                    break;
                    #endregion

                    #region Join item
                case 0x35:
                    InventoryEntries j1 = client.Character.GetInventoryAt(m_ident.Instance);
                    InventoryEntries j2 = client.Character.GetInventoryAt(unknown3);
                    j1.Item.MultipleCount += j2.Item.MultipleCount;
                    client.Character.Inventory.Remove(j2);
                    client.Character.WriteInventoryToSql();

                    byte[] joined = new byte[0x37];
                    Array.Copy(packet, joined, 0x37);
                    joined[8] = 0x00;
                    joined[9] = 0x00;
                    joined[10] = 0x0C;
                    joined[11] = 0x0E;
                    client.SendCompressed(joined);
                    break;
                    #endregion

                    #region Sneak Action
                    // ###################################################################################
                    // Spandexpants: This is all i have done so far as to make sneak turn on and off, 
                    // currently i cannot find a missing packet or link which tells the server the player
                    // has stopped sneaking, hidden packet or something, will come back to later.
                    // ###################################################################################

                    // Sneak Packet Received

                case 163:
                    {
                        PacketWriter Sneak = new PacketWriter();
                        // TODO: IF SNEAKING IS ALLOWED RUN THIS CODE.
                        // Send Action 162 : Enable Sneak
                        Sneak.PushByte(0xDF);
                        Sneak.PushByte(0xDF);
                        Sneak.PushShort(0xA);
                        Sneak.PushShort(1);
                        Sneak.PushShort(0);
                        Sneak.PushInt(3086); // Send 
                        Sneak.PushInt(client.Character.Id); // Reciever
                        Sneak.PushInt(0x5e477770); // Packet ID
                        Sneak.PushIdentity(50000, client.Character.Id); // TYPE / ID
                        Sneak.PushInt(0);
                        Sneak.PushByte(0xA2); // Action ID
                        Sneak.PushInt(0);
                        Sneak.PushInt(0);
                        Sneak.PushInt(0);
                        Sneak.PushInt(0);
                        Sneak.PushInt(0);
                        Sneak.PushShort(0);
                        byte[] sneakpacket = Sneak.Finish();
                        client.SendCompressed(sneakpacket);
                        // End of Enable sneak
                        // TODO: IF SNEAKING IS NOT ALLOWED SEND REJECTION PACKET
                    }
                    break;
                    #endregion

                    #region Use Item on Item
                case 81:
                    {
                        Identity item1 = new Identity();
                        Identity item2 = new Identity();

                        item1.Type = m_ident.Type;
                        item1.Instance = m_ident.Instance;

                        item2.Type = unknown2;
                        item2.Instance = unknown3;

                        Tradeskill cts = new Tradeskill(client, item1.Instance, item2.Instance);
                        cts.ClickBuild();
                        break;
                    }
                    #endregion

                    #region Change Visual Flag
                case 166:
                    {
                        client.Character.Stats.VisualFlags.Set(unknown3);
                        // client.SendChatText("Setting Visual Flag to "+unknown3.ToString());
                        AppearanceUpdate.AnnounceAppearanceUpdate(client.Character);
                        break;
                    }
                    #endregion

                    #region Tradeskill Source Changed
                case 0xdc:
                    TradeSkillReceiver.TradeSkillSourceChanged(client, unknown2, unknown3);
                    break;
                    #endregion

                    #region Tradeskill Target Changed
                case 0xdd:
                    TradeSkillReceiver.TradeSkillTargetChanged(client, unknown2, unknown3);
                    break;
                    #endregion

                    #region Tradeskill Build Pressed
                case 0xde:
                    TradeSkillReceiver.TradeSkillBuildPressed(client, m_ident.Instance);
                    break;
                    #endregion

                    #region default
                default:
                    {
                        byte[] action = new byte[0x37];
                        Array.Copy(packet, action, 0x37);
                        action[8] = 0x00;
                        action[9] = 0x00;
                        action[10] = 0x0C;
                        action[11] = 0x0E;
                        Announce.Playfield(client.Character.PlayField, action);
                    }
                    break;
                    #endregion
            }
            packetReader.Finish();
        }
        private int SpawnItem()
        {
            int firstfree = this.client.Character.GetNextFreeInventory(104);
            if (firstfree <= 93)
            {
                InventoryEntries mi = new InventoryEntries();
                AOItem it = ItemHandler.GetItemTemplate(this.ResultLowId);
                mi.Placement = firstfree;
                mi.Container = 104;
                mi.Item.LowID = this.ResultLowId;
                mi.Item.HighID = this.ResultHighId;
                mi.Item.Quality = this.Quality;
                if (it.ItemType != 1)
                {
                    mi.Item.MultipleCount = Math.Max(1, it.getItemAttribute(212));
                }
                else
                {
                    bool found = false;
                    foreach (AOItemAttribute a in mi.Item.Stats)
                    {
                        if (a.Stat != 212)
                        {
                            continue;
                        }
                        found = true;
                        a.Value = Math.Max(1, it.getItemAttribute(212));
                        break;
                    }
                    if (!found)
                    {
                        AOItemAttribute aoi = new AOItemAttribute();
                        aoi.Stat = 212;
                        aoi.Value = Math.Max(1, it.getItemAttribute(212));
                        mi.Item.Stats.Add(aoi);
                    }
                }
                this.client.Character.Inventory.Add(mi);
                AddTemplate.Send(this.client, mi);

                return firstfree;
            }
            else
            {
                this.client.SendChatText("Your Inventory is full");
                return 0;
            }
        }
Beispiel #13
0
 public void AddItemToInventory(AOItem item)
 {
     // TODO: Check for full inventory/open overflow
     int nextfreespot = this.GetNextFreeInventory(0x68); // Main inventory
     InventoryEntries ie = new InventoryEntries();
     ie.Container = 0x68;
     ie.Item = item.ShallowCopy();
     ie.Placement = nextfreespot;
     this.inventory.Add(ie);
 }
Beispiel #14
0
 /// <summary>
 /// Add/Subtract stacked item or add a item to inventory
 /// </summary>
 /// <param name="ie"></param>
 public void InventoryReplaceAdd(InventoryEntries ie)
 {
     lock (this.inventory)
     {
         AOItem it = ItemHandler.GetItemTemplate(ie.Item.LowID);
         //            if (it.isStackable())
         {
             foreach (InventoryEntries ia in this.inventory)
             {
                 if ((ia.Item.LowID == ie.Item.LowID) && (ia.Item.HighID == ie.Item.HighID)
                     && (ia.Container == -1))
                 {
                     ia.Item.MultipleCount += ie.Item.MultipleCount;
                     if (ia.Item.MultipleCount == 0)
                     {
                         this.inventory.Remove(ia);
                     }
                     return;
                 }
             }
         }
         this.inventory.Add(ie);
     }
 }
Beispiel #15
0
 /// <summary>
 /// Read inventory from database
 /// TODO: catch exceptions
 /// </summary>
 public void readInventoryfromSQL()
 {
     lock (Inventory)
     {
         SqlWrapper ms = new SqlWrapper();
         {
             InventoryEntries m_inv;
             Inventory.Clear();
             DataTable dt = ms.ReadDT("SELECT * FROM " + getSQLTablefromDynelType() + "inventory WHERE ID=" + ID.ToString() + " AND container=104 ORDER BY placement ASC;");
             if (dt.Rows.Count > 0)
             {
                 foreach (DataRow row in dt.Rows)
                 {
                     m_inv = new InventoryEntries();
                     m_inv.Container = (Int32)row["container"];
                     m_inv.Placement = (Int32)row["placement"];
                     m_inv.Item.highID = (Int32)row["highid"];
                     m_inv.Item.lowID = (Int32)row["lowid"];
                     m_inv.Item.Quality = (Int32)row["quality"];
                     m_inv.Item.multiplecount = (Int32)row["multiplecount"];
                     m_inv.Item.Type = (Int32)row["type"];
                     m_inv.Item.Instance = (Int32)row["instance"];
                     m_inv.Item.flags = (Int32)row["flags"];
                     Inventory.Add(m_inv);
                 }
             }
         }
     }
 }
        private int SpawnItem(int lowid, int highid, int ql)
        {
            // Copied from ChatCmd giveitem. 
            int firstfree = 64;
            firstfree = Cli.Character.GetNextFreeInventory(104);

            if (firstfree <= 93)
            {
                InventoryEntries ie = new InventoryEntries();
                AOItem item = ItemHandler.GetItemTemplate(Convert.ToInt32(lowid));
                ie.Placement = firstfree;
                ie.Container = 104;
                ie.Item.lowID = Convert.ToInt32(lowid);
                ie.Item.highID = Convert.ToInt32(highid);
                ie.Item.Quality = Convert.ToInt32(ql);
                if (item.ItemType != 1)
                {
                    ie.Item.multiplecount = Math.Max(1, (int)item.getItemAttribute(212));
                }
                else
                {
                    bool found = false;
                    foreach (AOItemAttribute a in ie.Item.Stats)
                    {
                        if (a.Stat != 212)
                            continue;
                        found = true;
                        a.Value = Math.Max(1, (int)item.getItemAttribute(212));
                        break;
                    }
                    if (!found)
                    {
                        AOItemAttribute aoi = new AOItemAttribute();
                        aoi.Stat = 212;
                        aoi.Value = Math.Max(1, (int)item.getItemAttribute(212));
                        ie.Item.Stats.Add(aoi);
                    }
                }
                Cli.Character.Inventory.Add(ie);
                Packets.AddTemplate.Send(Cli, ie);
                return firstfree;
            }
            else
            {
                // TODO: open overflow
                Cli.SendChatText("Your Inventory is full");
                return 0;
            }
        }
        public static void Read(byte[] packet, Client client, Dynel dynel)
        {
            PacketReader reader = new PacketReader(packet);
            PacketWriter packetWriter = new PacketWriter();
            Header header = reader.PopHeader();
            reader.PopByte();
            reader.PopInt(); // unknown
            byte action = reader.PopByte(); // unknown
            Identity ident = reader.PopIdentity();
            int container = reader.PopInt();
            int place = reader.PopInt();

            Character character = (Character)FindDynel.FindDynelById(ident.Type, ident.Instance);
            Character chaffected =
                (Character)FindDynel.FindDynelById(header.AffectedId.Type, header.AffectedId.Instance);

            // If target is a NPC, call its Action 0
            if ((character is NonPlayerCharacterClass) && (action == 0))
            {
                if (((NonPlayerCharacterClass)character).KnuBot != null)
                {
                    character.KnuBotTarget = character;
                    ((NonPlayerCharacterClass)character).KnuBot.TalkingTo = chaffected;
                    ((NonPlayerCharacterClass)character).KnuBot.Action(0);
                }
                return;
            }

            int cashDeduct = 0;
            int inventoryCounter;
            InventoryEntries inventoryEntry;

            switch (action)
            {
                case 1: // end trade
                    inventoryCounter = client.Character.Inventory.Count - 1;
                    while (inventoryCounter >= 0)
                    {
                        inventoryEntry = client.Character.Inventory[inventoryCounter];
                        AOItem aoItem;
                        if (inventoryEntry.Container == -1)
                        {
                            int nextFree = client.Character.GetNextFreeInventory(104);
                            aoItem = ItemHandler.GetItemTemplate(inventoryEntry.Item.LowID);
                            int price = aoItem.getItemAttribute(74);
                            int mult = aoItem.getItemAttribute(212); // original multiplecount
                            if (mult == 0)
                            {
                                mult = 1;
                                inventoryEntry.Item.MultipleCount = 1;
                            }
                            // Deduct Cash (ie.item.multiplecount) div mult * price
                            cashDeduct +=
                                Convert.ToInt32(
                                    mult * price
                                    *
                                    (100
                                     - Math.Floor(Math.Min(1500, client.Character.Stats.ComputerLiteracy.Value) / 40.0))
                                    / 2500);
                            // Add the Shop modificator and exchange the CompLit for skill form vendortemplate table
                            inventoryEntry.Placement = nextFree;
                            inventoryEntry.Container = 104;
                            if (!aoItem.isStackable())
                            {
                                int multiplicator = inventoryEntry.Item.MultipleCount;
                                inventoryEntry.Item.MultipleCount = 0;
                                while (multiplicator > 0)
                                {
                                    AddTemplate.Send(client, inventoryEntry);
                                    multiplicator--;
                                }
                            }
                            else
                            {
                                AddTemplate.Send(client, inventoryEntry);
                            }
                        }
                        if (inventoryEntry.Container == -2)
                        {
                            aoItem = ItemHandler.interpolate(
                                inventoryEntry.Item.LowID, inventoryEntry.Item.HighID, inventoryEntry.Item.Quality);
                            double multipleCount = aoItem.getItemAttribute(212); // original multiplecount
                            int price = aoItem.getItemAttribute(74);
                            if (multipleCount == 0.0)
                            {
                                multipleCount = 1.0;
                            }
                            else
                            {
                                multipleCount = inventoryEntry.Item.MultipleCount / multipleCount;
                            }
                            cashDeduct -=
                                Convert.ToInt32(
                                    multipleCount * price
                                    *
                                    (100
                                     + Math.Floor(Math.Min(1500, client.Character.Stats.ComputerLiteracy.Value) / 40.0))
                                    / 2500);
                            // Add the Shop modificator and exchange the CompLit for skill form vendortemplate table
                            client.Character.Inventory.Remove(inventoryEntry);
                        }
                        inventoryCounter--;
                    }

                    client.Character.Stats.Cash.Set((uint)(client.Character.Stats.Cash.Value - cashDeduct));
                    //                    Packets.Stat.Set(client, 61, client.Character.Stats.Cash.StatValue - cashdeduct, false);
                    byte[] reply0 = new byte[32];
                    Array.Copy(packet, reply0, 32);

                    // pushing in server ID
                    reply0[8] = 0;
                    reply0[9] = 0;
                    reply0[10] = 12;
                    reply0[11] = 14;

                    // pushing in Client ID
                    reply0[12] = (byte)(client.Character.Id >> 24);
                    reply0[13] = (byte)(client.Character.Id >> 16);
                    reply0[14] = (byte)(client.Character.Id >> 8);
                    reply0[15] = (byte)(client.Character.Id);

                    packetWriter.PushBytes(reply0);
                    packetWriter.PushByte(1);
                    packetWriter.PushByte(4);
                    packetWriter.PushIdentity(client.Character.LastTrade);
                    packetWriter.PushIdentity(client.Character.LastTrade);
                    client.Character.LastTrade = new Identity { Instance = 0, Type = 0 };

                    byte[] reply2 = packetWriter.Finish();
                    client.SendCompressed(reply2);
                    break;
                case 2:
                    // Decline trade
                    inventoryCounter = client.Character.Inventory.Count - 1;
                    while (inventoryCounter >= 0)
                    {
                        inventoryEntry = client.Character.Inventory[inventoryCounter];
                        if (inventoryEntry.Container == -1)
                        {
                            client.Character.Inventory.Remove(inventoryEntry);
                        }
                        else
                        {
                            if (inventoryEntry.Container == -2)
                            {
                                inventoryEntry.Placement = client.Character.GetNextFreeInventory(104);
                                inventoryEntry.Container = 104;
                            }
                        }
                        inventoryCounter--;
                    }

                    byte[] replyCopy = new byte[50];
                    Array.Copy(packet, replyCopy, 50);

                    // pushing in server ID
                    replyCopy[8] = 0;
                    replyCopy[9] = 0;
                    replyCopy[10] = 12;
                    replyCopy[11] = 14;

                    // pushing in Client ID
                    replyCopy[12] = (byte)(client.Character.Id >> 24);
                    replyCopy[13] = (byte)(client.Character.Id >> 16);
                    replyCopy[14] = (byte)(client.Character.Id >> 8);
                    replyCopy[15] = (byte)(client.Character.Id);

                    packetWriter.PushBytes(replyCopy);
                    byte[] rep1 = packetWriter.Finish();

                    client.SendCompressed(rep1);
                    break;
                case 3:
                    break;
                case 4:
                    break;
                case 5: // add item to trade window
                case 6: // remove item from trade window
                    byte[] reply = new byte[50];
                    Array.Copy(packet, reply, 50);
                    if (character.Inventory.Count == 0)
                    {
                        ((VendingMachine)character).LoadTemplate(((VendingMachine)character).TemplateId);
                    }

                    // pushing in server ID
                    reply[8] = 0;
                    reply[9] = 0;
                    reply[10] = 12;
                    reply[11] = 14;

                    // pushing in Client ID
                    reply[12] = (byte)(client.Character.Id >> 24);
                    reply[13] = (byte)(client.Character.Id >> 16);
                    reply[14] = (byte)(client.Character.Id >> 8);
                    reply[15] = (byte)(client.Character.Id);

                    //PacketWriter pw = new PacketWriter();
                    packetWriter.PushBytes(reply);
                    byte[] replyRemoveItemFromTradeWindow = packetWriter.Finish();
                    client.SendCompressed(replyRemoveItemFromTradeWindow);

                    if (client.Character == character)
                    {
                        if (action == 5)
                        {
                            inventoryEntry = character.GetInventoryAt(place);
                            inventoryEntry.Placement = character.GetNextFreeInventory(-2);
                            inventoryEntry.Container = -2;
                        }
                        if (action == 6)
                        {
                            inventoryEntry = character.GetInventoryAt(place, -2);
                            inventoryEntry.Placement = character.GetNextFreeInventory(104);
                            inventoryEntry.Container = 104;
                        }
                    }
                    else
                    {
                        InventoryEntries inew = new InventoryEntries
                            { Container = -1, Placement = character.GetNextFreeInventory(-1) };
                        int oldPlacement = ((packet[46] >> 24) + (packet[47] >> 16) + (packet[48] >> 8) + packet[49]);
                        InventoryEntries totrade = character.GetInventoryAt(oldPlacement);
                        inew.Item.LowID = totrade.Item.LowID;
                        inew.Item.HighID = totrade.Item.HighID;
                        inew.Item.MultipleCount = totrade.Item.MultipleCount;
                        if (action == 6) // Remove item from trade window
                        {
                            inew.Item.MultipleCount = -inew.Item.MultipleCount;
                        }
                        inew.Item.Quality = totrade.Item.Quality;
                        chaffected.InventoryReplaceAdd(inew);
                    }
                    break;
            }
        }