12 Leltár [C++,.PY fájlok]

[huzsihun1997]

Elöször is sziasztok!
Másodszor, DEV-en publikáltak nem olyan régen, egy 12 leltáros dolgot.
De ugye televolt hibával, és nem csatoltak hozzá kliens oldali részeket.
Hibák voltak pl: ha felvettél a földről tárgyat, max. 5. leltárig rakta.
Ha horgásztál a földre esett a hal (alád)
ha boltbol vásároltál 5. leltárig tudtál venni utánna "nincs több helyed"
Ha kereskedtél, szintén 5. leltárig engedte
A Tárgyak kilógtak alul.
Nos, teljesen hibátlanul:
--------------------------------------------SZERVER--------------------------------------

common/length.h

Kód Kijelölés Kibont

-    INVENTORY_MAX_NUM                = 135,
+    INVENTORY_MAX_NUM                = 540, 
common/tables.h

Kód Kijelölés Kibont

typedef struct SQuickslot
{
     BYTE    type;
-    BYTE    pos;
+    UINT    pos;
} TQuickslot; 
game/src/char.h

Kód Kijelölés Kibont

-    BYTE            bItemGrid[INVENTORY_AND_EQUIP_SLOT_MAX];
+    UINT            bItemGrid[INVENTORY_AND_EQUIP_SLOT_MAX];

- void SyncQuickslot(BYTE bType, BYTE bOldPos, BYTE bNewPos);
+ void SyncQuickslot(BYTE bType, UINT bOldPos, UINT bNewPos);

- bool GetQuickslot(BYTE pos, TQuickslot ** ppSlot);
+ bool GetQuickslot(UINT pos, TQuickslot ** ppSlot);

- bool SetQuickslot(BYTE pos, TQuickslot & rSlot);
+ bool SetQuickslot(UINT pos, TQuickslot & rSlot);

- bool DelQuickslot(BYTE pos);
+ bool DelQuickslot(UINT pos);

- bool SwapQuickslot(BYTE a, BYTE b);
+ bool SwapQuickslot(UINT a, UINT b);

- void ChainQuickslotItem(LPITEM pItem, BYTE bType, BYTE bOldPos);
+ void ChainQuickslotItem(LPITEM pItem, BYTE bType, UINT bOldPos);

- void SetWear(BYTE bCell, LPITEM item);
+ void SetWear(UINT bCell, LPITEM item);

- LPITEM GetWear(BYTE bCell) const;
+ LPITEM GetWear(UINT bCell) const;

-        bool            RefineInformation(BYTE bCell, BYTE bType, int iAdditionalCell = -1);
+        bool            RefineInformation(UINT bCell, BYTE bType, int iAdditionalCell = -1);

-        bool            SwapItem(BYTE bCell, BYTE bDestCell);
+        bool            SwapItem(UINT bCell, UINT bDestCell); 
game/src/char_battle.cpp

Kód Kijelölés Kibont


[code]-                SyncQuickslot(QUICKSLOT_TYPE_ITEM, vec_bSlots[i], 255);
+                SyncQuickslot(QUICKSLOT_TYPE_ITEM, vec_bSlots[i], 1000);


-            SyncQuickslot(QUICKSLOT_TYPE_ITEM, WEAR_UNIQUE1, 255);
+            SyncQuickslot(QUICKSLOT_TYPE_ITEM, WEAR_UNIQUE1, 1000);  [/code]
game/src/char_item.cpp

Kód Kijelölés Kibont

-LPITEM CHARACTER::GetWear(BYTE bCell) const
+LPITEM CHARACTER::GetWear(UINT bCell) const

Kód Kijelölés Kibont

-void CHARACTER::SetWear(BYTE bCell, LPITEM item)
+void CHARACTER::SetWear(UINT bCell, LPITEM item)

Kód Kijelölés Kibont

-            SyncQuickslot(QUICKSLOT_TYPE_ITEM, i, 255);
+            SyncQuickslot(QUICKSLOT_TYPE_ITEM, i, 1000);

Kód Kijelölés Kibont

-            BYTE bCell = Cell.cell;
+            UINT bCell = Cell.cell;

Kód Kijelölés Kibont

-                    if (m_pointsInstant.bItemGrid[bCell] == iExceptionCell)
+                    if (m_pointsInstant.bItemGrid[bCell] == (UINT)iExceptionCell)

Kód Kijelölés Kibont

-                    BYTE bPage = bCell / (INVENTORY_MAX_NUM / 3);
+                    UINT bPage = bCell / (INVENTORY_MAX_NUM / 12);

Kód Kijelölés Kibont

-                        BYTE p = bCell + (5 * j);
+                        UINT p = bCell + (5 * j);

Kód Kijelölés Kibont

-                    if (p / (INVENTORY_MAX_NUM / 3) != bPage)
+                    if (p / (INVENTORY_MAX_NUM / 12) != bPage)

Kód Kijelölés Kibont

-            BYTE bCell = item->GetCell();
+            UINT bCell = item->GetCell();

Kód Kijelölés Kibont

-bool CHARACTER::RefineInformation(BYTE bCell, BYTE bType, int iAdditionalCell)
+bool CHARACTER::RefineInformation(UINT bCell, BYTE bType, int iAdditionalCell)

Kód Kijelölés Kibont

-    SyncQuickslot(QUICKSLOT_TYPE_ITEM, Cell.cell, 255);
+    SyncQuickslot(QUICKSLOT_TYPE_ITEM, Cell.cell, 1000);

Kód Kijelölés Kibont

-bool CHARACTER::SwapItem(BYTE bCell, BYTE bDestCell)
+bool CHARACTER::SwapItem(UINT bCell, UINT bDestCell)

Kód Kijelölés Kibont

- BYTE bEquipCell = item2->GetCell() - INVENTORY_MAX_NUM;
+ INT bEquipCell = item2->GetCell() - INVENTORY_MAX_NUM;

Kód Kijelölés Kibont

- BYTE bInvenCell = item1->GetCell();
+ UINT bInvenCell = item1->GetCell();

Kód Kijelölés Kibont

- BYTE bCell1 = item1->GetCell();
+ UINT bCell1 = item1->GetCell();

Kód Kijelölés Kibont

- BYTE bCell2 = item2->GetCell();
+ UINT bCell2 = item2->GetCell();

Kód Kijelölés Kibont

-            BYTE bOldCell = item->GetCell();
+            UINT bOldCell = item->GetCell(); 
game/src/char_quickslot.cpp

Kód Kijelölés Kibont

-void CHARACTER::SyncQuickslot(BYTE bType, BYTE bOldPos, BYTE bNewPos)
+void CHARACTER::SyncQuickslot(BYTE bType, UINT bOldPos, UINT bNewPos)

Kód Kijelölés Kibont

-            if (bNewPos == 255)
+            if (bNewPos == 1000)

Kód Kijelölés Kibont

-bool CHARACTER::GetQuickslot(BYTE pos, TQuickslot ** ppSlot)
+bool CHARACTER::GetQuickslot(UINT pos, TQuickslot ** ppSlot)

Kód Kijelölés Kibont

-bool CHARACTER::SetQuickslot(BYTE pos, TQuickslot & rSlot)
+bool CHARACTER::SetQuickslot(UINT pos, TQuickslot & rSlot)

Kód Kijelölés Kibont

-bool CHARACTER::DelQuickslot(BYTE pos)
+bool CHARACTER::DelQuickslot(UINT pos)

Kód Kijelölés Kibont

-bool CHARACTER::SwapQuickslot(BYTE a, BYTE b)
+bool CHARACTER::SwapQuickslot(UINT a, UINT b)

Kód Kijelölés Kibont

-void CHARACTER::ChainQuickslotItem(LPITEM pItem, BYTE bType, BYTE bOldPos)
+void CHARACTER::ChainQuickslotItem(LPITEM pItem, BYTE bType, UINT bOldPos)
game/src/cmd_general.cpp

Kód Kijelölés Kibont

-        for (BYTE i=0; i<INVENTORY_MAX_NUM; ++i)
+        for (UINT i=0; i<INVENTORY_MAX_NUM; ++i) 
game/src/cmd_gm.cpp

Kód Kijelölés Kibont

-            ch->SyncQuickslot(QUICKSLOT_TYPE_ITEM, i, 255);
+            ch->SyncQuickslot(QUICKSLOT_TYPE_ITEM, i, 1000);

Kód Kijelölés Kibont

-    BYTE cell = 0;
+    UINT cell = 0; 
game/src/exchange.cpp

Kód Kijelölés Kibont

bool CExchange::CheckSpace()

Kód Kijelölés Kibont

bool CExchange::CheckSpace()
{
    static CGrid s_grid1(5, INVENTORY_MAX_NUM / 5 / 12); // leltar 1
    static CGrid s_grid2(5, INVENTORY_MAX_NUM / 5 / 12); // leltar 2
    static CGrid s_grid3(5, INVENTORY_MAX_NUM / 5 / 12); // leltar  3
    static CGrid s_grid4(5, INVENTORY_MAX_NUM / 5 / 12); // leltar 4
    static CGrid s_grid5(5, INVENTORY_MAX_NUM / 5 / 12); // leltar 5
    static CGrid s_grid6(5, INVENTORY_MAX_NUM / 5 / 12); // leltar 6
    static CGrid s_grid7(5, INVENTORY_MAX_NUM / 5 / 12); // leltar 7
    static CGrid s_grid8(5, INVENTORY_MAX_NUM / 5 / 12); // leltar 8
    static CGrid s_grid9(5, INVENTORY_MAX_NUM / 5 / 12); // leltar 9
    static CGrid s_grid10(5, INVENTORY_MAX_NUM / 5 / 12); // leltar 10
    static CGrid s_grid11(5, INVENTORY_MAX_NUM / 5 / 12); // leltar 11
    static CGrid s_grid12(5, INVENTORY_MAX_NUM / 5 / 12); // leltar 12

Kód Kijelölés Kibont

    s_grid1.Clear();
    s_grid2.Clear();
    s_grid3.Clear();
    s_grid4.Clear();
    s_grid5.Clear();
    s_grid6.Clear();
    s_grid7.Clear();
    s_grid8.Clear();
    s_grid9.Clear();
    s_grid10.Clear();
    s_grid11.Clear();
    s_grid12.Clear();

Kód Kijelölés Kibont

LPCHARACTER    victim = GetCompany()->GetOwner();
    LPITEM item;

    int i;
    const int PageSlotCount = INVENTORY_MAX_NUM / 12;

    for (i = 0; i < INVENTORY_MAX_NUM; ++i)
    {
        if (!(item = victim->GetInventoryItem(i)))
            continue;

        BYTE itemSize = item->GetSize();

        if (i < PageSlotCount)
            s_grid1.Put(i, 1, itemSize);
        else if (i < PageSlotCount * 2)
            s_grid2.Put(i - PageSlotCount, 1, itemSize);
        else if (i < PageSlotCount * 3)
            s_grid3.Put(i - PageSlotCount * 2, 1, itemSize);
        else if (i < PageSlotCount * 4)
            s_grid4.Put(i - PageSlotCount * 3, 1, itemSize);
        else if (i < PageSlotCount * 5)
            s_grid5.Put(i - PageSlotCount * 4, 1, itemSize);
        else if (i < PageSlotCount * 6)
            s_grid6.Put(i - PageSlotCount * 5, 1, itemSize);
        else if (i < PageSlotCount * 7)
            s_grid7.Put(i - PageSlotCount * 6, 1, itemSize);
        else if (i < PageSlotCount * 8)
            s_grid8.Put(i - PageSlotCount * 7, 1, itemSize);
        else if (i < PageSlotCount * 9)
            s_grid9.Put(i - PageSlotCount * 8, 1, itemSize);
        else if (i < PageSlotCount * 10)
            s_grid10.Put(i - PageSlotCount * 9, 1, itemSize);
        else if (i < PageSlotCount * 11)
            s_grid11.Put(i - PageSlotCount * 10, 1, itemSize);
        else if (i < PageSlotCount * 12)
            s_grid12.Put(i - PageSlotCount * 11, 1, itemSize);
    }

Kód Kijelölés Kibont

    static std::vector <WORD> s_vDSGrid(DRAGON_SOUL_INVENTORY_MAX_NUM);
   
    bool bDSInitialized = false;
   
    for (i = 0; i < EXCHANGE_ITEM_MAX_NUM; ++i)
    {
        if (!(item = m_apItems[i]))
            continue;

        BYTE itemSize = item->GetSize();

        if (item->IsDragonSoul())
        {
            if (!victim->DragonSoul_IsQualified())
            {
                return false;
            }

            if (!bDSInitialized)
            {
                bDSInitialized = true;
                victim->CopyDragonSoulItemGrid(s_vDSGrid);
            }

            bool bExistEmptySpace = false;
            WORD wBasePos = DSManager::instance().GetBasePosition(item);
            if (wBasePos >= DRAGON_SOUL_INVENTORY_MAX_NUM)
                return false;
           
            for (int i = 0; i < DRAGON_SOUL_BOX_SIZE; i++)
            {
                WORD wPos = wBasePos + i;
                if (0 == s_vDSGrid[wBasePos])
                {
                    bool bEmpty = true;
                    for (int j = 1; j < item->GetSize(); j++)
                    {
                        if (s_vDSGrid[wPos + j * DRAGON_SOUL_BOX_COLUMN_NUM])
                        {
                            bEmpty = false;
                            break;
                        }
                    }
                    if (bEmpty)
                    {
                        for (int j = 0; j < item->GetSize(); j++)
                        {
                            s_vDSGrid[wPos + j * DRAGON_SOUL_BOX_COLUMN_NUM] =  wPos + 1;
                        }
                        bExistEmptySpace = true;
                        break;
                    }
                }
                if (bExistEmptySpace)
                    break;
            }
            if (!bExistEmptySpace)
                return false;
        }
        else
        {
            int iPos = s_grid1.FindBlank(1, itemSize);
            if (iPos >= 0)
            {
                s_grid1.Put(iPos, 1, itemSize);
                continue;
            }

            iPos = s_grid2.FindBlank(1, itemSize);
            if (iPos >= 0)
            {
                s_grid2.Put(iPos, 1, itemSize);
                continue;
            }

            iPos = s_grid3.FindBlank(1, itemSize);
            if (iPos >= 0)
            {
                s_grid3.Put(iPos, 1, itemSize);
                continue;
            }

            iPos = s_grid4.FindBlank(1, itemSize);
            if (iPos >= 0)
            {
                s_grid4.Put(iPos, 1, itemSize);
                continue;
            }

            iPos = s_grid5.FindBlank(1, itemSize);
            if (iPos >= 0)
            {
                s_grid5.Put(iPos, 1, itemSize);
                continue;
            }

            iPos = s_grid6.FindBlank(1, itemSize);
            if (iPos >= 0)
            {
                s_grid6.Put(iPos, 1, itemSize);
                continue;
            }

            iPos = s_grid7.FindBlank(1, itemSize);
            if (iPos >= 0)
            {
                s_grid7.Put(iPos, 1, itemSize);
                continue;
            }

            iPos = s_grid8.FindBlank(1, itemSize);
            if (iPos >= 0)
            {
                s_grid8.Put(iPos, 1, itemSize);
                continue;
            }

            iPos = s_grid9.FindBlank(1, itemSize);
            if (iPos >= 0)
            {
                s_grid9.Put(iPos, 1, itemSize);
                continue;
            }

            iPos = s_grid10.FindBlank(1, itemSize);
            if (iPos >= 0)
            {
                s_grid10.Put(iPos, 1, itemSize);
                continue;
            }

            iPos = s_grid11.FindBlank(1, itemSize);
            if (iPos >= 0)
            {
                s_grid11.Put(iPos, 1, itemSize);
                continue;
            }

            iPos = s_grid12.FindBlank(1, itemSize);
            if (iPos >= 0)
            {
                s_grid12.Put(iPos, 1, itemSize);
                continue;
            }

            return false;
        }
    }

    return true;
} 
exchange.cpp:

Kód Kijelölés Kibont

-        m_pOwner->SyncQuickslot(QUICKSLOT_TYPE_ITEM, item->GetCell(), 255);
+        m_pOwner->SyncQuickslot(QUICKSLOT_TYPE_ITEM, item->GetCell(), 1000); 
game/src/fishing.cpp

Kód Kijelölés Kibont

-            BYTE bCell = rod->GetCell();
+            UINT bCell = rod->GetCell(); 
game/src/input_main.cpp

Kód Kijelölés Kibont


         case SHOP_SUBHEADER_CG_SELL2:
             {
-                if (uiBytes < sizeof(BYTE) + sizeof(BYTE))
+                if (uiBytes < sizeof(UINT) + sizeof(BYTE))
                     return -1;
 

Kód Kijelölés Kibont

-                BYTE pos = *(c_pData++);
+                UINT pos = *reinterpret_cast<const UINT*>(c_pData++);
                 BYTE count = *(c_pData);
 
             

Kód Kijelölés Kibont

    sys_log(0, "INPUT: %s SHOP: SELL2", ch->GetName());
                 CShopManager::instance().Sell(ch, pos, count);
-                return sizeof(BYTE) + sizeof(BYTE);
+                return sizeof(UINT) + sizeof(BYTE);
             }

Kód Kijelölés Kibont


-        ch->SyncQuickslot(QUICKSLOT_TYPE_ITEM, p->ItemPos.cell, 255);
+        ch->SyncQuickslot(QUICKSLOT_TYPE_ITEM, p->ItemPos.cell, 1000); 
game/src/item.cpp

Kód Kijelölés Kibont


-                    pOwner->SyncQuickslot(QUICKSLOT_TYPE_ITEM, wCell, 255);
+                    pOwner->SyncQuickslot(QUICKSLOT_TYPE_ITEM, wCell, 1000);

Kód Kijelölés Kibont


-                m_pOwner->SyncQuickslot(QUICKSLOT_TYPE_ITEM, m_wCell, 255);
+                m_pOwner->SyncQuickslot(QUICKSLOT_TYPE_ITEM, m_wCell, 1000);

Kód Kijelölés Kibont

-bool CItem::EquipTo(LPCHARACTER ch, BYTE bWearCell)
+bool CItem::EquipTo(LPCHARACTER ch, UINT bWearCell) 
game/src/item.h

Kód Kijelölés Kibont

-        bool        EquipTo(LPCHARACTER ch, BYTE bWearCell);
+        bool        EquipTo(LPCHARACTER ch, UINT bWearCell); 
game/src/item_manager.cpp

Kód Kijelölés Kibont

-            o->SyncQuickslot(QUICKSLOT_TYPE_ITEM, item->GetCell(), 255);
+            o->SyncQuickslot(QUICKSLOT_TYPE_ITEM, item->GetCell(), 1000); 
game/src/minig.cpp

Kód Kijelölés Kibont

-                BYTE bCell = rkOldPick.GetCell();
+                UINT bCell = rkOldPick.GetCell(); 
game/src/packet.h

Kód Kijelölés Kibont


typedef struct command_quickslot_add
{
     BYTE    header;
-    BYTE    pos;
+    UINT    pos;
     TQuickslot    slot;
} TPacketCGQuickslotAdd;

typedef struct command_quickslot_del
{
     BYTE    header;
-    BYTE    pos;
+    UINT    pos;
} TPacketCGQuickslotDel;

typedef struct command_quickslot_swap
{
     BYTE    header;
-    BYTE    pos;
+    UINT    pos;
-    BYTE    change_pos;
+    UINT    change_pos;
} TPacketCGQuickslotSwap;

typedef struct packet_item_del
{
     BYTE    header;
-    BYTE    pos;
+    UINT    pos;
} TPacketGCItemDel;

struct packet_quickslot_add
{
     BYTE    header;
-    BYTE    pos;
+    UINT    pos;
     TQuickslot    slot;
};

struct packet_quickslot_del
{
     BYTE    header;
-    BYTE    pos;
+    UINT    pos;
};

struct packet_quickslot_swap
{
     BYTE    header;
-    BYTE    pos;
+    UINT    pos;
-    BYTE    pos_to;
+    UINT    pos_to;
};

typedef struct SPacketCGRefine
{
     BYTE    header;
-    BYTE    pos;
+    UINT    pos;
     BYTE    type;
} TPacketCGRefine;

typedef struct SPacketCGRequestRefineInfo
{
     BYTE    header;
-    BYTE    pos;
+    UINT    pos;
} TPacketCGRequestRefineInfo;

typedef struct SPacketGCRefineInformaion
{
     BYTE    header;
     BYTE    type;
-    BYTE    pos;
+    UINT    pos;
     DWORD    src_vnum;
     DWORD    result_vnum;
     BYTE    material_count; 
game/src/questlua_global.cpp

Kód Kijelölés Kibont


-        BYTE bCell = (BYTE) lua_tonumber(L,-1);
+        UINT bCell = lua_tonumber(L, -1); 
game/src/questlua_item.cpp

Kód Kijelölés Kibont


-            BYTE bCell = pItem->GetCell();
+            UINT bCell = pItem->GetCell(); 
game/src/questlua_pc.cpp

Kód Kijelölés Kibont


,
-        BYTE bCell = (BYTE)lua_tonumber(L, 1);
+        UINT bCell = lua_tonumber(L, 1); 
game/src/safebox.cpp

Kód Kijelölés Kibont


-LPITEM CSafebox::GetItem(BYTE bCell)
+LPITEM CSafebox::GetItem(INT bCell)

Kód Kijelölés Kibont


-bool CSafebox::MoveItem(BYTE bCell, BYTE bDestCell, BYTE count)
+bool CSafebox::MoveItem(INT bCell, INT bDestCell, BYTE count) 
game/src/safebox.h

Kód Kijelölés Kibont


-        bool        MoveItem(BYTE bCell, BYTE bDestCell, BYTE count);
+        bool        MoveItem(INT bCell, INT bDestCell, BYTE count);

-        LPITEM        GetItem(BYTE bCell);
+        LPITEM        GetItem(INT bCell); 
game/src/shop.cpp

Kód Kijelölés Kibont


-        m_pkPC->SyncQuickslot(QUICKSLOT_TYPE_ITEM, item->GetCell(), 255);
+        m_pkPC->SyncQuickslot(QUICKSLOT_TYPE_ITEM, item->GetCell(), 1000); 
game/src/shop_manager.cpp

Kód Kijelölés Kibont


-void CShopManager::Sell(LPCHARACTER ch, BYTE bCell, BYTE bCount)
+void CShopManager::Sell(LPCHARACTER ch, UINT bCell, BYTE bCount) 
game/src/shop_manager.h

Kód Kijelölés Kibont


-    void    Sell(LPCHARACTER ch, BYTE bCell, BYTE bCount=0);
+    void    Sell(LPCHARACTER ch, UINT bCell, BYTE bCount = 0); 
Inditót új posztba irom, mert tullépné a 20k karaktert.

A Letöltésben csatoltam a kliens fájlokat. (uiinventory.py és inventorywindow.py!)

Sok sikert!

[huzsihun1997]

KLIENS----------------------------------------------------------------------------------------------------------------
Client/UserInterface/AbstractPlayer.h

Kód Kijelölés Kibont

-        virtual void    AddQuickSlot(int QuickslotIndex, char IconType, char IconPosition) = 0;
+        virtual void    AddQuickSlot(int QuickslotIndex, char IconType, INT IconPosition) = 0; 
Client/UserInterface/GameType.h

Kód Kijelölés Kibont

-const DWORD c_Inventory_Page_Count
+const DWORD c_Inventory_Page_Count = 12;

typedef struct SQuickSlot
{
     BYTE Type;
-    BYTE Position;
+    UINT Position;
} TQuickSlot; 
Client/UserInterface/Packet.h

Kód Kijelölés Kibont

typedef struct command_quickslot_add
{
     BYTE        header;
-    BYTE        pos;
+    UINT        pos;
     TQuickSlot    slot;
}TPacketCGQuickSlotAdd;

typedef struct command_quickslot_del
{
     BYTE        header;
-    BYTE        pos;
+    UINT        pos;
}TPacketCGQuickSlotDel;

typedef struct command_quickslot_swap
{
     BYTE        header;
-    BYTE        pos;
+    UINT        pos;
-    BYTE        change_pos;
+    UINT        change_pos;
}TPacketCGQuickSlotSwap;

typedef struct SPacketCGRefine
{
     BYTE        header;
-    BYTE        pos;
+    UINT        pos;
     BYTE        type;
} TPacketCGRefine;

typedef struct packet_item_del
{
     BYTE        header;
-    BYTE        pos;
+    UINT        pos;
} TPacketGCItemDel;

typedef struct packet_quickslot_add
{
     BYTE        header;
-    BYTE        pos;
+    UINT        pos;
     TQuickSlot    slot;
} TPacketGCQuickSlotAdd;

typedef struct packet_quickslot_del
{
     BYTE        header;
-    BYTE        pos;
+    UINT        pos;
} TPacketGCQuickSlotDel;

typedef struct packet_quickslot_swap
{
     BYTE        header;
-    BYTE        pos;
+    UINT        pos;
-    BYTE        change_pos;
+    UINT        change_pos;
} TPacketGCQuickSlotSwap;

typedef struct SPacketGCRefineInformation
{
     BYTE            header;
-    BYTE            pos;
+    UINT            pos;
     TRefineTable    refine_table;
} TPacketGCRefineInformation;

typedef struct SPacketGCRefineInformationNew
{
     BYTE            header;
     BYTE            type;
-    BYTE            pos;
+    UINT            pos;
     TRefineTable    refine_table;
} TPacketGCRefineInformationNew; 
Client/UserInterface/PythonNetworkStream.h

Kód Kijelölés Kibont

-        bool SendQuickSlotAddPacket(BYTE wpos, BYTE type, BYTE pos);
+        bool SendQuickSlotAddPacket(UINT wpos, BYTE type, UINT pos);
-        bool SendQuickSlotDelPacket(BYTE wpos);
+        bool SendQuickSlotDelPacket(UINT wpos);
-        bool SendQuickSlotMovePacket(BYTE wpos, BYTE change_pos);
+        bool SendQuickSlotMovePacket(UINT wpos, UINT change_pos);

-        bool SendShopSellPacketNew(BYTE bySlot, BYTE byCount);
+        bool SendShopSellPacketNew(UINT bySlot, BYTE byCount);

-        bool SendRefinePacket(BYTE byPos, BYTE byType);
+        bool SendRefinePacket(UINT byPos, BYTE byType); 
Client/UserInterface/PythonNetworkStreamPhaseGame.cpp

Kód Kijelölés Kibont

-bool CPythonNetworkStream::SendRefinePacket(BYTE byPos, BYTE byType)
+bool CPythonNetworkStream::SendRefinePacket(UINT byPos, BYTE byType) 
Client/UserInterface/PythonNetworkStreamPhaseGameItem.cpp

Kód Kijelölés Kibont


-bool CPythonNetworkStream::SendShopSellPacketNew(BYTE bySlot, BYTE byCount)
+bool CPythonNetworkStream::SendShopSellPacketNew(UINT bySlot, BYTE byCount)
+{
+    if (!__CanActMainInstance())
+        return true;

+    TPacketCGShop PacketShop;
+    PacketShop.header = HEADER_CG_SHOP;
+    PacketShop.subheader = SHOP_SUBHEADER_CG_SELL2;

+    if (!Send(sizeof(TPacketCGShop), &PacketShop))
+    {
+        Tracef("SendShopSellPacket Error\n");
+        return false;
+    }
+    if (!Send(sizeof(UINT), &bySlot))
+    {
+        Tracef("SendShopAddSellPacket Error\n");
+        return false;
+    }
+    if (!Send(sizeof(BYTE), &byCount))
+    {
+        Tracef("SendShopAddSellPacket Error\n");
+        return false;
+    }

+    Tracef(" SendShopSellPacketNew(bySlot=%d, byCount=%d)\n", bySlot, byCount);

+    return SendSequence();
+}

-bool CPythonNetworkStream::SendQuickSlotAddPacket(BYTE wpos, BYTE type, BYTE pos)
+bool CPythonNetworkStream::SendQuickSlotAddPacket(UINT wpos, BYTE type, UINT pos)

-bool CPythonNetworkStream::SendQuickSlotDelPacket(BYTE pos)
+bool CPythonNetworkStream::SendQuickSlotDelPacket(UINT pos)

-bool CPythonNetworkStream::SendQuickSlotMovePacket(BYTE pos, BYTE change_pos)
+bool CPythonNetworkStream::SendQuickSlotMovePacket(UINT pos, UINT change_pos) 
Client/UserInterface/PythonPlayer.cpp

Kód Kijelölés Kibont

-    for (BYTE i = 0; i < QUICKSLOT_MAX_NUM; ++i)
+    for (UINT i = 0; i < QUICKSLOT_MAX_NUM; ++i)

-    rkNetStream.SendQuickSlotMovePacket((BYTE) dwGlobalSrcSlotIndex, (BYTE)dwGlobalDstSlotIndex);
+    rkNetStream.SendQuickSlotMovePacket((UINT) dwGlobalSrcSlotIndex, (UINT)dwGlobalDstSlotIndex);

-    rkNetStream.SendQuickSlotAddPacket((BYTE)dwGlobalSlotIndex, (BYTE)dwWndType, (BYTE)dwWndItemPos);
+    rkNetStream.SendQuickSlotAddPacket((UINT)dwGlobalSlotIndex, (BYTE)dwWndType, (UINT)dwWndItemPos);

-    rkNetStream.SendQuickSlotDelPacket((BYTE)dwGlobalSlotIndex);
+    rkNetStream.SendQuickSlotDelPacket((UINT)dwGlobalSlotIndex);

-void CPythonPlayer::AddQuickSlot(int QuickSlotIndex, char IconType, char IconPosition)
+void CPythonPlayer::AddQuickSlot(int QuickSlotIndex, char IconType, INT IconPosition) 
Client/UserInterface/PythonPlayer.h

Kód Kijelölés Kibont

-        void    AddQuickSlot(int QuickslotIndex, char IconType, char IconPosition);
+        void    AddQuickSlot(int QuickslotIndex, char IconType, INT IconPosition);