pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2025-12-12 17:51:28 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

More 'dictionary' updates..added 'constants' files to client translators..started replacement of hard-coded inventory values.

Browse Source
This commit is contained in:
Uleat 2014-07-27 20:35:43 -04:00
parent d0756ff2af
commit 36a2d52f1c
51 changed files with 2564 additions and 514 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
changelog.txt
View File

@ -1,5 +1,8 @@
EQEMu Changelog (Started on Sept 24, 2003 15:50) EQEMu Changelog (Started on Sept 24, 2003 15:50)
------------------------------------------------------- -------------------------------------------------------
== 07/27/2014 ==
Uleat: More updates to the dictionary. Added a 'constants' file for each client translator..these will tie-in to the dictionary. Started
replacement of hard-coded numeric values with a pre-defined constant. This will help in the transition.
== 07/16/2014 == == 07/16/2014 ==
Uleat: Initial commit of new client/server 'dictionaries' - work in-progress... Changed equipment slot references to reflect new naming Uleat: Initial commit of new client/server 'dictionaries' - work in-progress... Changed equipment slot references to reflect new naming

25
common/CMakeLists.txt
View File

@ -72,6 +72,7 @@ SET(common_sources
patches/SoD.cpp patches/SoD.cpp
patches/SoF.cpp patches/SoF.cpp
patches/RoF.cpp patches/RoF.cpp
#patches/RoF2.cpp
patches/Titanium.cpp patches/Titanium.cpp
patches/Underfoot.cpp patches/Underfoot.cpp
SocketLib/Base64.cpp SocketLib/Base64.cpp
@ -191,15 +192,18 @@ SET(common_headers
ZoneNumbers.h ZoneNumbers.h
platform.h platform.h
patches/Client62.h patches/Client62.h
patches/Client62_constants.h
patches/Client62_itemfields.h patches/Client62_itemfields.h
patches/Client62_ops.h patches/Client62_ops.h
patches/Client62_structs.h patches/Client62_structs.h
patches/patches.h patches/patches.h
patches/SoD.h patches/SoD.h
patches/SoD_constants.h
patches/SoD_itemfields.h patches/SoD_itemfields.h
patches/SoD_ops.h patches/SoD_ops.h
patches/SoD_structs.h patches/SoD_structs.h
patches/SoF.h patches/SoF.h
patches/SoF_constants.h
patches/SoF_itemfields.h patches/SoF_itemfields.h
patches/SoF_opcode_list.h patches/SoF_opcode_list.h
patches/SoF_ops.h patches/SoF_ops.h
@ -208,14 +212,22 @@ SET(common_headers
patches/SSDefine.h patches/SSDefine.h
patches/SSRegister.h patches/SSRegister.h
patches/RoF.h patches/RoF.h
patches/RoF_constants.h
patches/RoF_itemfields.h patches/RoF_itemfields.h
patches/RoF_ops.h patches/RoF_ops.h
patches/RoF_structs.h patches/RoF_structs.h
#patches/RoF2.h
#patches/RoF2_constants.h
#patches/RoF2_itemfields.h
#patches/RoF2_ops.h
#patches/RoF2_structs.h
patches/Titanium.h patches/Titanium.h
patches/Titanium_constants.h
patches/Titanium_itemfields.h patches/Titanium_itemfields.h
patches/Titanium_ops.h patches/Titanium_ops.h
patches/Titanium_structs.h patches/Titanium_structs.h
patches/Underfoot.h patches/Underfoot.h
patches/Underfoot_constants.h
patches/Underfoot_itemfields.h patches/Underfoot_itemfields.h
patches/Underfoot_ops.h patches/Underfoot_ops.h
patches/Underfoot_structs.h patches/Underfoot_structs.h
@ -240,16 +252,19 @@ SOURCE_GROUP(Patches FILES
patches/Client62.h patches/Client62.h
patches/Client62_itemfields.h patches/Client62_itemfields.h
patches/Client62_ops.h patches/Client62_ops.h
patches/Client62_constants.h
patches/Client62_structs.h patches/Client62_structs.h
patches/patches.h patches/patches.h
patches/SoD.h patches/SoD.h
patches/SoD_itemfields.h patches/SoD_itemfields.h
patches/SoD_ops.h patches/SoD_ops.h
patches/SoD_constants.h
patches/SoD_structs.h patches/SoD_structs.h
patches/SoF.h patches/SoF.h
patches/SoF_itemfields.h patches/SoF_itemfields.h
patches/SoF_opcode_list.h patches/SoF_opcode_list.h
patches/SoF_ops.h patches/SoF_ops.h
patches/SoF_constants.h
patches/SoF_structs.h patches/SoF_structs.h
patches/SSDeclare.h patches/SSDeclare.h
patches/SSDefine.h patches/SSDefine.h
@ -257,20 +272,29 @@ SOURCE_GROUP(Patches FILES
patches/RoF.h patches/RoF.h
patches/RoF_itemfields.h patches/RoF_itemfields.h
patches/RoF_ops.h patches/RoF_ops.h
patches/RoF_constants.h
patches/RoF_structs.h patches/RoF_structs.h
#patches/RoF2.h
#patches/RoF2_itemfields.h
#patches/RoF2_ops.h
#patches/RoF2_constants.h
#patches/RoF2_structs.h
patches/Titanium.h patches/Titanium.h
patches/Titanium_itemfields.h patches/Titanium_itemfields.h
patches/Titanium_ops.h patches/Titanium_ops.h
patches/Titanium_constants.h
patches/Titanium_structs.h patches/Titanium_structs.h
patches/Underfoot.h patches/Underfoot.h
patches/Underfoot_itemfields.h patches/Underfoot_itemfields.h
patches/Underfoot_ops.h patches/Underfoot_ops.h
patches/Underfoot_constants.h
patches/Underfoot_structs.h patches/Underfoot_structs.h
patches/Client62.cpp patches/Client62.cpp
patches/patches.cpp patches/patches.cpp
patches/SoD.cpp patches/SoD.cpp
patches/SoF.cpp patches/SoF.cpp
patches/RoF.cpp patches/RoF.cpp
#patches/RoF2.cpp
patches/Titanium.cpp patches/Titanium.cpp
patches/Underfoot.cpp patches/Underfoot.cpp
) )
@ -321,6 +345,7 @@ ADD_LIBRARY(common ${common_sources} ${common_headers})
IF(UNIX) IF(UNIX)
ADD_DEFINITIONS(-fPIC) ADD_DEFINITIONS(-fPIC)
#TODO: Add "patches/RoF2.cpp" when it becomes active
SET_SOURCE_FILES_PROPERTIES("patches/SoD.cpp" "patches/SoF.cpp" "patches/RoF.cpp" "patches/Underfoot.cpp" PROPERTIES COMPILE_FLAGS -O0) SET_SOURCE_FILES_PROPERTIES("patches/SoD.cpp" "patches/SoF.cpp" "patches/RoF.cpp" "patches/Underfoot.cpp" PROPERTIES COMPILE_FLAGS -O0)
ENDIF(UNIX) ENDIF(UNIX)

131
common/Item.cpp
View File

@ -166,63 +166,63 @@ ItemInst* Inventory::GetItem(int16 slot_id) const
ItemInst* result = nullptr; ItemInst* result = nullptr;
// Cursor // Cursor
if (slot_id == MainCursor) { if (slot_id == EmuConstants::CURSOR) {
// Cursor slot // Cursor slot
result = m_cursor.peek_front(); result = m_cursor.peek_front();
} }
// Non bag slots // Non bag slots
else if (slot_id >= 3000 && slot_id <= 3007) { else if (slot_id >= EmuConstants::TRADE_BEGIN && slot_id <= EmuConstants::TRADE_END) {
// Trade slots
result = _GetItem(m_trade, slot_id); result = _GetItem(m_trade, slot_id);
} }
else if (slot_id >= 2500 && slot_id <= 2501) { else if (slot_id >= EmuConstants::SHARED_BANK_BEGIN && slot_id <= EmuConstants::SHARED_BANK_END) {
// Shared Bank slots // Shared Bank slots
result = _GetItem(m_shbank, slot_id); result = _GetItem(m_shbank, slot_id);
} }
else if (slot_id >= 2000 && slot_id <= 2023) { else if (slot_id >= EmuConstants::BANK_BEGIN && slot_id <= EmuConstants::BANK_END) {
// Bank slots // Bank slots
result = _GetItem(m_bank, slot_id); result = _GetItem(m_bank, slot_id);
} }
else if ((slot_id >= 22 && slot_id <= 29)) { else if ((slot_id >= EmuConstants::GENERAL_BEGIN && slot_id <= EmuConstants::GENERAL_END)) {
// Personal inventory slots // Personal inventory slots
result = _GetItem(m_inv, slot_id); result = _GetItem(m_inv, slot_id);
} }
else if ((slot_id >= 0 && slot_id <= 21) || (slot_id >= 400 && slot_id <= 404) || (slot_id == 9999)) { else if ((slot_id >= EmuConstants::EQUIPMENT_BEGIN && slot_id <= EmuConstants::EQUIPMENT_END) ||
(slot_id >= EmuConstants::TRIBUTE_BEGIN && slot_id <= EmuConstants::TRIBUTE_END) || (slot_id == EmuConstants::POWER_SOURCE)) {
// Equippable slots (on body) // Equippable slots (on body)
result = _GetItem(m_worn, slot_id); result = _GetItem(m_worn, slot_id);
} }
// Inner bag slots // Inner bag slots
else if (slot_id >= 3031 && slot_id <= 3110) { else if (slot_id >= EmuConstants::TRADE_BAGS_BEGIN && slot_id <= EmuConstants::TRADE_BAGS_END) {
// Trade bag slots // Trade bag slots
ItemInst* inst = _GetItem(m_trade, Inventory::CalcSlotId(slot_id)); ItemInst* inst = _GetItem(m_trade, Inventory::CalcSlotId(slot_id));
if (inst && inst->IsType(ItemClassContainer)) { if (inst && inst->IsType(ItemClassContainer)) {
result = inst->GetItem(Inventory::CalcBagIdx(slot_id)); result = inst->GetItem(Inventory::CalcBagIdx(slot_id));
} }
} }
else if (slot_id >= 2531 && slot_id <= 2550) { else if (slot_id >= EmuConstants::SHARED_BANK_BAGS_BEGIN && slot_id <= EmuConstants::SHARED_BANK_BAGS_END) {
// Shared Bank bag slots // Shared Bank bag slots
ItemInst* inst = _GetItem(m_shbank, Inventory::CalcSlotId(slot_id)); ItemInst* inst = _GetItem(m_shbank, Inventory::CalcSlotId(slot_id));
if (inst && inst->IsType(ItemClassContainer)) { if (inst && inst->IsType(ItemClassContainer)) {
result = inst->GetItem(Inventory::CalcBagIdx(slot_id)); result = inst->GetItem(Inventory::CalcBagIdx(slot_id));
} }
} }
else if (slot_id >= 2031 && slot_id <= 2270) { else if (slot_id >= EmuConstants::BANK_BAGS_BEGIN && slot_id <= EmuConstants::BANK_BAGS_END) {
// Bank bag slots // Bank bag slots
ItemInst* inst = _GetItem(m_bank, Inventory::CalcSlotId(slot_id)); ItemInst* inst = _GetItem(m_bank, Inventory::CalcSlotId(slot_id));
if (inst && inst->IsType(ItemClassContainer)) { if (inst && inst->IsType(ItemClassContainer)) {
result = inst->GetItem(Inventory::CalcBagIdx(slot_id)); result = inst->GetItem(Inventory::CalcBagIdx(slot_id));
} }
} }
else if (slot_id >= 331 && slot_id <= 340) { else if (slot_id >= EmuConstants::CURSOR_BAG_BEGIN && slot_id <= EmuConstants::CURSOR_BAG_END) {
// Cursor bag slots // Cursor bag slots
ItemInst* inst = m_cursor.peek_front(); ItemInst* inst = m_cursor.peek_front();
if (inst && inst->IsType(ItemClassContainer)) { if (inst && inst->IsType(ItemClassContainer)) {
result = inst->GetItem(Inventory::CalcBagIdx(slot_id)); result = inst->GetItem(Inventory::CalcBagIdx(slot_id));
} }
} }
else if (slot_id >= 251 && slot_id <= 330) { else if (slot_id >= EmuConstants::GENERAL_BAGS_BEGIN && slot_id <= EmuConstants::GENERAL_BAGS_END) {
// Personal inventory bag slots // Personal inventory bag slots
ItemInst* inst = _GetItem(m_inv, Inventory::CalcSlotId(slot_id)); ItemInst* inst = _GetItem(m_inv, Inventory::CalcSlotId(slot_id));
if (inst && inst->IsType(ItemClassContainer)) { if (inst && inst->IsType(ItemClassContainer)) {
@ -651,67 +651,86 @@ int16 Inventory::FindFreeSlot(bool for_bag, bool try_cursor, uint8 min_size, boo
} }
// Opposite of below: Get parent bag slot_id from a slot inside of bag // Opposite of below: Get parent bag slot_id from a slot inside of bag
int16 Inventory::CalcSlotId(int16 slot_id) int16 Inventory::CalcSlotId(int16 slot_id) {
{
int16 parent_slot_id = INVALID_INDEX; int16 parent_slot_id = INVALID_INDEX;
if (slot_id >= 251 && slot_id <= 330) if (slot_id >= EmuConstants::GENERAL_BAGS_BEGIN && slot_id <= EmuConstants::GENERAL_BAGS_END)
parent_slot_id = IDX_INV + (slot_id - 251) / MAX_ITEMS_PER_BAG; parent_slot_id = EmuConstants::GENERAL_BEGIN + (slot_id - EmuConstants::GENERAL_BAGS_BEGIN) / EmuConstants::ITEM_CONTAINER_SIZE;
else if (slot_id >= 331 && slot_id <= 340)
parent_slot_id = MainCursor; else if (slot_id >= EmuConstants::CURSOR_BAG_BEGIN && slot_id <= EmuConstants::CURSOR_BAG_END)
else if (slot_id >= 2000 && slot_id <= 2023) parent_slot_id = EmuConstants::CURSOR;
parent_slot_id = IDX_BANK + (slot_id - 2000) / MAX_ITEMS_PER_BAG;
else if (slot_id >= 2031 && slot_id <= 2270) /*
parent_slot_id = IDX_BANK + (slot_id - 2031) / MAX_ITEMS_PER_BAG; // this is not a bag range...
else if (slot_id >= 2531 && slot_id <= 2550) else if (slot_id >= EmuConstants::BANK_BEGIN && slot_id <= EmuConstants::BANK_END)
parent_slot_id = IDX_SHBANK + (slot_id - 2531) / MAX_ITEMS_PER_BAG; parent_slot_id = EmuConstants::BANK_BEGIN + (slot_id - EmuConstants::BANK_BEGIN) / EmuConstants::ITEM_CONTAINER_SIZE;
else if (slot_id >= 3100 && slot_id <= 3179) */
parent_slot_id = IDX_TRADE + (slot_id - 3100) / MAX_ITEMS_PER_BAG;
else if (slot_id >= EmuConstants::BANK_BAGS_BEGIN && slot_id <= EmuConstants::BANK_BAGS_END)
parent_slot_id = EmuConstants::BANK_BEGIN + (slot_id - EmuConstants::BANK_BAGS_BEGIN) / EmuConstants::ITEM_CONTAINER_SIZE;
else if (slot_id >= EmuConstants::SHARED_BANK_BAGS_BEGIN && slot_id <= EmuConstants::SHARED_BANK_BAGS_END)
parent_slot_id = EmuConstants::SHARED_BANK_BEGIN + (slot_id - EmuConstants::SHARED_BANK_BAGS_BEGIN) / EmuConstants::ITEM_CONTAINER_SIZE;
//else if (slot_id >= 3100 && slot_id <= 3179) should be {3031..3110}..where did this range come from!!? (verified db save range)
else if (slot_id >= EmuConstants::TRADE_BAGS_BEGIN && slot_id <= EmuConstants::TRADE_BAGS_END)
parent_slot_id = EmuConstants::TRADE_BEGIN + (slot_id - EmuConstants::TRADE_BAGS_BEGIN) / EmuConstants::ITEM_CONTAINER_SIZE;
return parent_slot_id; return parent_slot_id;
} }
// Calculate slot_id for an item within a bag // Calculate slot_id for an item within a bag
int16 Inventory::CalcSlotId(int16 bagslot_id, uint8 bagidx) int16 Inventory::CalcSlotId(int16 bagslot_id, uint8 bagidx) {
{ if (!Inventory::SupportsContainers(bagslot_id))
if (!Inventory::SupportsContainers(bagslot_id)) {
return INVALID_INDEX; return INVALID_INDEX;
}
int16 slot_id = INVALID_INDEX; int16 slot_id = INVALID_INDEX;
if (bagslot_id == MainCursor || bagslot_id == 8000) // Cursor if (bagslot_id == EmuConstants::CURSOR || bagslot_id == 8000)
slot_id = IDX_CURSOR_BAG + bagidx; slot_id = EmuConstants::CURSOR_BAG_BEGIN + bagidx;
else if (bagslot_id >= 22 && bagslot_id <= 29) // Inventory slots
slot_id = IDX_INV_BAG + (bagslot_id - 22)*MAX_ITEMS_PER_BAG + bagidx; else if (bagslot_id >= EmuConstants::GENERAL_BEGIN && bagslot_id <= EmuConstants::GENERAL_END)
else if (bagslot_id >= 2000 && bagslot_id <= 2023) // Bank slots slot_id = EmuConstants::GENERAL_BAGS_BEGIN + (bagslot_id - EmuConstants::GENERAL_BEGIN) * EmuConstants::ITEM_CONTAINER_SIZE + bagidx;
slot_id = IDX_BANK_BAG + (bagslot_id - 2000)*MAX_ITEMS_PER_BAG + bagidx;
else if (bagslot_id >= 2500 && bagslot_id <= 2501) // Shared bank slots else if (bagslot_id >= EmuConstants::BANK_BEGIN && bagslot_id <= EmuConstants::BANK_END)
slot_id = IDX_SHBANK_BAG + (bagslot_id - 2500)*MAX_ITEMS_PER_BAG + bagidx; slot_id = EmuConstants::BANK_BAGS_BEGIN + (bagslot_id - EmuConstants::BANK_BEGIN) * EmuConstants::ITEM_CONTAINER_SIZE + bagidx;
else if (bagslot_id >= 3000 && bagslot_id <= 3007) // Trade window slots
slot_id = IDX_TRADE_BAG + (bagslot_id - 3000)*MAX_ITEMS_PER_BAG + bagidx; else if (bagslot_id >= EmuConstants::SHARED_BANK_BEGIN && bagslot_id <= EmuConstants::SHARED_BANK_END)
slot_id = EmuConstants::SHARED_BANK_BAGS_BEGIN + (bagslot_id - EmuConstants::SHARED_BANK_BEGIN) * EmuConstants::ITEM_CONTAINER_SIZE + bagidx;
else if (bagslot_id >= EmuConstants::TRADE_BEGIN && bagslot_id <= EmuConstants::TRADE_END)
slot_id = EmuConstants::TRADE_BAGS_BEGIN + (bagslot_id - EmuConstants::TRADE_BEGIN) * EmuConstants::ITEM_CONTAINER_SIZE + bagidx;
return slot_id; return slot_id;
} }
uint8 Inventory::CalcBagIdx(int16 slot_id) uint8 Inventory::CalcBagIdx(int16 slot_id) {
{
uint8 index = 0; uint8 index = 0;
if (slot_id >= 251 && slot_id <= 330) if (slot_id >= EmuConstants::GENERAL_BAGS_BEGIN && slot_id <= EmuConstants::GENERAL_BAGS_END)
index = (slot_id - 251) % MAX_ITEMS_PER_BAG; index = (slot_id - EmuConstants::GENERAL_BAGS_BEGIN) % EmuConstants::ITEM_CONTAINER_SIZE;
else if (slot_id >= 331 && slot_id <= 340)
index = (slot_id - 331) % MAX_ITEMS_PER_BAG; else if (slot_id >= EmuConstants::CURSOR_BAG_BEGIN && slot_id <= EmuConstants::CURSOR_BAG_END)
else if (slot_id >= 2000 && slot_id <= 2023) index = (slot_id - EmuConstants::CURSOR_BAG_BEGIN); // % EmuConstants::ITEM_CONTAINER_SIZE; - not needed since range is 10 slots
index = (slot_id - 2000) % MAX_ITEMS_PER_BAG;
else if (slot_id >= 2031 && slot_id <= 2270) /*
index = (slot_id - 2031) % MAX_ITEMS_PER_BAG; // this is not a bag range...
else if (slot_id >= 2531 && slot_id <= 2550) else if (slot_id >= EmuConstants::BANK_BEGIN && slot_id <= EmuConstants::BANK_END)
index = (slot_id - 2531) % MAX_ITEMS_PER_BAG; index = (slot_id - EmuConstants::BANK_BEGIN) % EmuConstants::ITEM_CONTAINER_SIZE;
else if (slot_id >= 3100 && slot_id <= 3179) */
index = (slot_id - 3100) % MAX_ITEMS_PER_BAG;
else if (slot_id >= 4000 && slot_id <= 4009) else if (slot_id >= EmuConstants::BANK_BAGS_BEGIN && slot_id <= EmuConstants::BANK_BAGS_END)
index = (slot_id - 4000) % MAX_ITEMS_PER_BAG; index = (slot_id - EmuConstants::BANK_BAGS_BEGIN) % EmuConstants::ITEM_CONTAINER_SIZE;
else if (slot_id >= EmuConstants::SHARED_BANK_BAGS_BEGIN && slot_id <= EmuConstants::SHARED_BANK_BAGS_END)
index = (slot_id - EmuConstants::SHARED_BANK_BAGS_BEGIN) % EmuConstants::ITEM_CONTAINER_SIZE;
else if (slot_id >= EmuConstants::TRADE_BAGS_BEGIN && slot_id <= EmuConstants::TRADE_BAGS_END)
index = (slot_id - EmuConstants::TRADE_BAGS_BEGIN) % EmuConstants::ITEM_CONTAINER_SIZE;
// odd..but, ok... (probably a range-slot conversion for ItemInst* Object::item
else if (slot_id >= EmuConstants::WORLD_BEGIN && slot_id <= EmuConstants::WORLD_END)
index = (slot_id - EmuConstants::WORLD_BEGIN); // % EmuConstants::ITEM_CONTAINER_SIZE; - not needed since range is 10 slots
return index; return index;
} }

15
common/Item.h
View File

@ -55,21 +55,6 @@ namespace ItemField
}; };
}; };
// Indexing positions to the beginning slot_id's for a bucket of slots
#define IDX_EQUIP 0
#define IDX_CURSOR_BAG 331
#define IDX_INV 22
#define IDX_INV_BAG 251
#define IDX_TRIBUTE 400
#define IDX_BANK 2000
#define IDX_BANK_BAG 2031
#define IDX_SHBANK 2500
#define IDX_SHBANK_BAG 2531
#define IDX_TRADE 3000
#define IDX_TRADE_BAG 3031
#define IDX_TRADESKILL 4000
#define MAX_ITEMS_PER_BAG 10
// Specifies usage type for item inside ItemInst // Specifies usage type for item inside ItemInst
enum ItemInstTypes enum ItemInstTypes
{ {

5
common/clientversions.h
View File

@ -31,11 +31,6 @@ typedef enum {
// Values below are not implemented, as yet... // Values below are not implemented, as yet...
// - RoF2 is added for convenience of implementor..creation client will need to be changed once that client is actually added
// - Code will be added to 'relieve' characters of any illegal inventory items based on their client version. This will
// oversee cheats and mis-placement of starting items whenever a client is loaded.
_EQCreationClient = EQClientRoF, // bump to latest client as new ones are added (make sure that db is updated accordingly)
EmuNPC = _EQClientCount, EmuNPC = _EQClientCount,
EmuMerc, EmuMerc,
EmuBot, EmuBot,

16
common/database.cpp
View File

@ -793,7 +793,7 @@ bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inven
// Doodman: Is this even used? // Doodman: Is this even used?
// now the inventory // now the inventory
for (i=0; i<=2270;) for (i = EmuConstants::POSSESSIONS_BEGIN; i <= EmuConstants::BANK_BAGS_END;)
{ {
const ItemInst* newinv = inv->GetItem((int16)i); const ItemInst* newinv = inv->GetItem((int16)i);
if (newinv) if (newinv)
@ -821,14 +821,16 @@ bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inven
safe_delete_array(invquery); safe_delete_array(invquery);
} }
if(i==30){ //end of standard inventory/cursor, jump to internals of bags/cursor if (i == EmuConstants::CURSOR) {
i = 251; i = EmuConstants::GENERAL_BAGS_BEGIN;
continue; continue;
} else if(i==340){ //end of internals of bags/cursor, jump to bank slots }
i = 2000; else if (i == EmuConstants::CURSOR_BAG_END) {
i = EmuConstants::BANK_BEGIN;
continue; continue;
} else if(i==2023){ //end of bank slots, jump to internals of bank bags }
i = 2031; else if (i == EmuConstants::BANK_END) {
i = EmuConstants::BANK_BAGS_BEGIN;
continue; continue;
} }

1
common/emu_oplist.h
View File

@ -539,3 +539,4 @@ N(OP_MercenaryTimerRequest),
N(OP_OpenInventory), N(OP_OpenInventory),
N(OP_OpenContainer), N(OP_OpenContainer),
N(OP_Marquee), N(OP_Marquee),
N(OP_ClientTimeStamp),

10
common/eq_constants.h
View File

@ -873,8 +873,8 @@ enum InventoryMainTypes : int16 {
MainGeneral8, MainGeneral8,
//MainGeneral9, //MainGeneral9,
//MainGeneral10, //MainGeneral10,
MainCursor //, MainCursor,
//_MainCount, _MainCount
}; };
enum InventorySlot enum InventorySlot
@ -949,5 +949,11 @@ enum InventorySlot
#define NOT_USED 0 #define NOT_USED 0
#define NO_ITEM 0 #define NO_ITEM 0
// yes..these are redundant... but, they help to identify and define what is actually being performed
// plus, since they're pre-op's, they don't affect the actual binary size
#define MAP_BEGIN 0
#define MAIN_BEGIN 0
#define SUB_BEGIN 0
#define AUG_BEGIN 0
#endif #endif

830
common/eq_dictionary.cpp
View File

@ -1,22 +1,26 @@
/* EQEMu: Everquest Server Emulator /*
Copyright (C) 2001-2003 EQEMu Development Team (http://eqemulator.net) EQEMu: Everquest Server Emulator
This program is free software; you can redistribute it and/or modify Copyright (C) 2001-2014 EQEMu Development Team (http://eqemulator.net)
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful, This program is free software; you can redistribute it and/or modify
but WITHOUT ANY WARRANTY except by those people which sell it, which it under the terms of the GNU General Public License as published by
are required to give you total support for your newly bought product; the Free Software Foundation; version 2 of the License.
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details. This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/ */
#include "eq_dictionary.h" #include "eq_dictionary.h"
#include "StringUtil.h"
// //
// class ServerConstants // class ServerConstants
@ -28,7 +32,7 @@ uint16 EmuConstants::InventoryMapSize(int16 map) {
case MapBank: case MapBank:
return MAP_BANK_SIZE; return MAP_BANK_SIZE;
case MapSharedBank: case MapSharedBank:
return MAP_SHAREDBANK_SIZE; return MAP_SHARED_BANK_SIZE;
case MapTrade: case MapTrade:
return MAP_TRADE_SIZE; return MAP_TRADE_SIZE;
case MapWorld: case MapWorld:
@ -38,9 +42,9 @@ uint16 EmuConstants::InventoryMapSize(int16 map) {
case MapTribute: case MapTribute:
return MAP_TRIBUTE_SIZE; return MAP_TRIBUTE_SIZE;
case MapTrophyTribute: case MapTrophyTribute:
return MAP_TROPHYTRIBUTE_SIZE; return MAP_TROPHY_TRIBUTE_SIZE;
case MapGuildTribute: case MapGuildTribute:
return MAP_GUILDTRIBUTE_SIZE; return MAP_GUILD_TRIBUTE_SIZE;
case MapMerchant: case MapMerchant:
return MAP_MERCHANT_SIZE; return MAP_MERCHANT_SIZE;
case MapDeleted: case MapDeleted:
@ -52,23 +56,23 @@ uint16 EmuConstants::InventoryMapSize(int16 map) {
case MapInspect: case MapInspect:
return MAP_INSPECT_SIZE; return MAP_INSPECT_SIZE;
case MapRealEstate: case MapRealEstate:
return MAP_REALESTATE_SIZE; return MAP_REAL_ESTATE_SIZE;
case MapViewMODPC: case MapViewMODPC:
return MAP_VIEWMODPC_SIZE; return MAP_VIEW_MOD_PC_SIZE;
case MapViewMODBank: case MapViewMODBank:
return MAP_VIEWMODBANK_SIZE; return MAP_VIEW_MOD_BANK_SIZE;
case MapViewMODSharedBank: case MapViewMODSharedBank:
return MAP_VIEWMODSHAREDBANK_SIZE; return MAP_VIEW_MOD_SHARED_BANK_SIZE;
case MapViewMODLimbo: case MapViewMODLimbo:
return MAP_VIEWMODLIMBO_SIZE; return MAP_VIEW_MOD_LIMBO_SIZE;
case MapAltStorage: case MapAltStorage:
return MAP_ALTSTORAGE_SIZE; return MAP_ALT_STORAGE_SIZE;
case MapArchived: case MapArchived:
return MAP_ARCHIVED_SIZE; return MAP_ARCHIVED_SIZE;
case MapMail: case MapMail:
return MAP_MAIL_SIZE; return MAP_MAIL_SIZE;
case MapGuildTrophyTribute: case MapGuildTrophyTribute:
return MAP_GUILDTROPHYTRIBUTE_SIZE; return MAP_GUILD_TROPHY_TRIBUTE_SIZE;
case MapKrono: case MapKrono:
return MAP_KRONO_SIZE; return MAP_KRONO_SIZE;
case MapOther: case MapOther:
@ -78,6 +82,179 @@ uint16 EmuConstants::InventoryMapSize(int16 map) {
} }
} }
/*
std::string EmuConstants::InventoryLocationName(Location_Struct location) {
// not ready for implementation...
std::string ret_str;
StringFormat(ret_str, "%s, %s, %s, %s", InventoryMapName(location.map), InventoryMainName(location.main), InventorySubName(location.sub), InventoryAugName(location.aug));
return ret_str;
}
*/
std::string EmuConstants::InventoryMapName(int16 map) {
switch (map) {
case INVALID_INDEX:
return "Invalid Map";
case MapPossessions:
return "Possessions";
case MapBank:
return "Bank";
case MapSharedBank:
return "Shared Bank";
case MapTrade:
return "Trade";
case MapWorld:
return "World";
case MapLimbo:
return "Limbo";
case MapTribute:
return "Tribute";
case MapTrophyTribute:
return "Trophy Tribute";
case MapGuildTribute:
return "Guild Tribute";
case MapMerchant:
return "Merchant";
case MapDeleted:
return "Deleted";
case MapCorpse:
return "Corpse";
case MapBazaar:
return "Bazaar";
case MapInspect:
return "Inspect";
case MapRealEstate:
return "Real Estate";
case MapViewMODPC:
return "View MOD PC";
case MapViewMODBank:
return "View MOD Bank";
case MapViewMODSharedBank:
return "View MOD Shared Bank";
case MapViewMODLimbo:
return "View MOD Limbo";
case MapAltStorage:
return "Alt Storage";
case MapArchived:
return "Archived";
case MapMail:
return "Mail";
case MapGuildTrophyTribute:
return "Guild Trophy Tribute";
case MapKrono:
return "Krono";
case MapOther:
return "Other";
default:
return "Unknown Map";
}
}
std::string EmuConstants::InventoryMainName(int16 main) {
switch (main) {
case INVALID_INDEX:
return "Invalid Main";
case MainCharm:
return "Charm";
case MainEar1:
return "Ear 1";
case MainHead:
return "Head";
case MainFace:
return "Face";
case MainEar2:
return "Ear 2";
case MainNeck:
return "Neck";
case MainShoulders:
return "Shoulders";
case MainArms:
return "Arms";
case MainBack:
return "Back";
case MainWrist1:
return "Wrist 1";
case MainWrist2:
return "Wrist 2";
case MainRange:
return "Range";
case MainHands:
return "Hands";
case MainPrimary:
return "Primary";
case MainSecondary:
return "Secondary";
case MainFinger1:
return "Finger 1";
case MainFinger2:
return "Finger 2";
case MainChest:
return "Chest";
case MainLegs:
return "Legs";
case MainFeet:
return "Feet";
case MainWaist:
return "Waist";
case MainPowerSource:
return "Power Source";
case MainAmmo:
return "Ammo";
case MainGeneral1:
return "General 1";
case MainGeneral2:
return "General 2";
case MainGeneral3:
return "General 3";
case MainGeneral4:
return "General 4";
case MainGeneral5:
return "General 5";
case MainGeneral6:
return "General 6";
case MainGeneral7:
return "General 7";
case MainGeneral8:
return "General 8";
/*
case MainGeneral9:
return "General 9";
case MainGeneral10:
return "General 10";
*/
case MainCursor:
return "Cursor";
default:
return "Unknown Main";
}
}
std::string EmuConstants::InventorySubName(int16 sub) {
if (sub == INVALID_INDEX)
return "Invalid Sub";
if ((uint16)sub >= ITEM_CONTAINER_SIZE)
return "Unknown Sub";
std::string ret_str;
StringFormat(ret_str, "Container %i", (sub + 1)); // zero-based index..but, count starts at one
return ret_str;
}
std::string EmuConstants::InventoryAugName(int16 aug) {
if (aug == INVALID_INDEX)
return "Invalid Aug";
if ((uint16)aug >= ITEM_COMMON_SIZE)
return "Unknown Aug";
std::string ret_str;
StringFormat(ret_str, "Augment %i", (aug + 1)); // zero-based index..but, count starts at one
return ret_str;
}
// //
// class ClientLimits // class ClientLimits
// //
@ -160,34 +337,390 @@ uint16 EQLimits::InventoryMapSize(int16 map, uint32 version) {
// //
// make sure that you transcribe the actual value from 'defaults' to here before updating or client crashes will ensue..and/or... // make sure that you transcribe the actual value from 'defaults' to here before updating or client crashes will ensue..and/or...
// insert older clients inside of the progression of client order // insert older clients inside of the progression of client order
//
// MAP_POSSESSIONS_SIZE does not reflect all actual <client>_constants size due to bitmask-use compatibility
//
// when setting NPC-based values, try to adhere to an EmuConstants::<property> or NOT_USED value to avoid unnecessary issues
static const uint16 local[_MapCount][_EmuClientCount] = { static const uint16 local[_MapCount][_EmuClientCount] = {
/* { Unknown, 62, Titanium, SoF, SoD, Underfoot, RoF, RoF2, NPC, Merc, Bot, Pet }*/ // server and database are sync'd to current MapPossessions's client as set in 'using namespace RoF::slots;' and
{ NOT_USED, 34, 34, 34, 34, 34, EmuConstants::MAP_POSSESSIONS_SIZE, 0, 0, 0, 0, 0 }, // (requires bitmask use...) // 'EmuConstants::MAP_POSSESSIONS_SIZE' - use/update EquipmentBitmask(), GeneralBitmask() and CursorBitmask()
{ NOT_USED, 16, 16, 24, 24, 24, EmuConstants::MAP_BANK_SIZE, 0, 0, 0, 0, 0 }, // for partial range validation checks and 'EmuConstants::MAP_POSSESSIONS_SIZE' for full range iterations
{ NOT_USED, 2, 2, 2, 2, 2, EmuConstants::MAP_SHAREDBANK_SIZE, 0, 0, 0, 0, 0 }, { // local[MainPossessions]
{ NOT_USED, 8, 8, 8, 8, 8, EmuConstants::MAP_TRADE_SIZE, 0, 0, 0, 0, 0 }, /*Unknown*/ NOT_USED,
{ NOT_USED, 10, 10, 10, 10, 10, EmuConstants::MAP_WORLD_SIZE, 0, 0, 0, 0, 0 }, /*62*/ EmuConstants::MAP_POSSESSIONS_SIZE,
{ NOT_USED, 36, 36, 36, 36, 36, EmuConstants::MAP_LIMBO_SIZE, 0, 0, 0, 0, 0 }, /*Titanium*/ EmuConstants::MAP_POSSESSIONS_SIZE,
{ NOT_USED, 0, 0, 0, 0, 0, EmuConstants::MAP_TRIBUTE_SIZE, 0, 0, 0, 0, 0 }, /*SoF*/ EmuConstants::MAP_POSSESSIONS_SIZE,
{ NOT_USED, 0, 0, 0, 0, 0, EmuConstants::MAP_TROPHYTRIBUTE_SIZE, 0, 0, 0, 0, 0 }, /*SoD*/ EmuConstants::MAP_POSSESSIONS_SIZE,
{ NOT_USED, 0, 0, 0, 0, 0, EmuConstants::MAP_GUILDTRIBUTE_SIZE, 0, 0, 0, 0, 0 }, /*Underfoot*/ EmuConstants::MAP_POSSESSIONS_SIZE,
{ NOT_USED, 0, 0, 0, 0, 0, EmuConstants::MAP_MERCHANT_SIZE, 0, 0, 0, 0, 0 }, /*RoF*/ EmuConstants::MAP_POSSESSIONS_SIZE,
{ NOT_USED, 0, 0, 0, 0, 0, EmuConstants::MAP_DELETED_SIZE, 0, 0, 0, 0, 0 }, /*RoF2*/ 0,
{ NOT_USED, 0, 0, 0, 0, 34, EmuConstants::MAP_CORPSE_SIZE, 0, 0, 0, 0, 0 },
{ NOT_USED, 0, 0, 0, 0, 80, EmuConstants::MAP_BAZAAR_SIZE, 0, 0, 0, 0, 0 }, /*NPC*/ EmuConstants::MAP_POSSESSIONS_SIZE,
{ NOT_USED, 0, 0, 0, 0, 0, EmuConstants::MAP_INSPECT_SIZE, 0, 0, 0, 0, 0 }, /*Merc*/ EmuConstants::MAP_POSSESSIONS_SIZE,
{ NOT_USED, 0, 0, 0, 0, 0, EmuConstants::MAP_REALESTATE_SIZE, 0, 0, 0, 0, 0 }, /*Bot*/ EmuConstants::MAP_POSSESSIONS_SIZE,
{ NOT_USED, 0, 0, 0, 0, 0, EmuConstants::MAP_VIEWMODPC_SIZE, 0, 0, 0, 0, 0 }, /*Pet*/ EmuConstants::MAP_POSSESSIONS_SIZE
{ NOT_USED, 0, 0, 0, 0, 0, EmuConstants::MAP_VIEWMODBANK_SIZE, 0, 0, 0, 0, 0 }, },
{ NOT_USED, 0, 0, 0, 0, 0, EmuConstants::MAP_VIEWMODSHAREDBANK_SIZE, 0, 0, 0, 0, 0 }, { // local[MapBank]
{ NOT_USED, 0, 0, 0, 0, 0, EmuConstants::MAP_VIEWMODLIMBO_SIZE, 0, 0, 0, 0, 0 }, /*Unknown*/ NOT_USED,
{ NOT_USED, 0, 0, 0, 0, 0, EmuConstants::MAP_ALTSTORAGE_SIZE, 0, 0, 0, 0, 0 }, /*62*/ Client62::consts::MAP_BANK_SIZE,
{ NOT_USED, 0, 0, 0, 0, 0, EmuConstants::MAP_ARCHIVED_SIZE, 0, 0, 0, 0, 0 }, /*Titanium*/ Titanium::consts::MAP_BANK_SIZE,
{ NOT_USED, 0, 0, 0, 0, 0, EmuConstants::MAP_MAIL_SIZE, 0, 0, 0, 0, 0 }, /*SoF*/ EmuConstants::MAP_BANK_SIZE,
{ NOT_USED, 0, 0, 0, 0, 0, EmuConstants::MAP_GUILDTROPHYTRIBUTE_SIZE, 0, 0, 0, 0, 0 }, /*SoD*/ EmuConstants::MAP_BANK_SIZE,
{ NOT_USED, NOT_USED, NOT_USED, NOT_USED, NOT_USED, NOT_USED, EmuConstants::MAP_KRONO_SIZE, 0, 0, 0, 0, 0 }, // (will be implemented in RoF2) /*Underfoot*/ EmuConstants::MAP_BANK_SIZE,
{ NOT_USED, 0, 0, 0, 0, 0, EmuConstants::MAP_OTHER_SIZE, 0, 0, 0, 0, 0 } /*RoF*/ EmuConstants::MAP_BANK_SIZE,
/*RoF2*/ 0,
/*NPC*/ NOT_USED,
/*Merc*/ NOT_USED,
/*Bot*/ NOT_USED,
/*Pet*/ NOT_USED
},
{ // local[MapSharedBank]
/*Unknown*/ NOT_USED,
/*62*/ EmuConstants::MAP_SHARED_BANK_SIZE,
/*Titanium*/ EmuConstants::MAP_SHARED_BANK_SIZE,
/*SoF*/ EmuConstants::MAP_SHARED_BANK_SIZE,
/*SoD*/ EmuConstants::MAP_SHARED_BANK_SIZE,
/*Underfoot*/ EmuConstants::MAP_SHARED_BANK_SIZE,
/*RoF*/ EmuConstants::MAP_SHARED_BANK_SIZE,
/*RoF2*/ 0,
/*NPC*/ NOT_USED,
/*Merc*/ NOT_USED,
/*Bot*/ NOT_USED,
/*Pet*/ NOT_USED
},
{ // local[MapTrade]
/*Unknown*/ NOT_USED,
/*62*/ EmuConstants::MAP_TRADE_SIZE,
/*Titanium*/ EmuConstants::MAP_TRADE_SIZE,
/*SoF*/ EmuConstants::MAP_TRADE_SIZE,
/*SoD*/ EmuConstants::MAP_TRADE_SIZE,
/*Underfoot*/ EmuConstants::MAP_TRADE_SIZE,
/*RoF*/ EmuConstants::MAP_TRADE_SIZE,
/*RoF2*/ 0,
/*NPC*/ 4,
/*Merc*/ 4,
/*Bot*/ EmuConstants::MAP_TRADE_SIZE, // client thinks this is another client
/*Pet*/ 4
},
{ // local[MapWorld]
/*Unknown*/ NOT_USED,
/*62*/ EmuConstants::MAP_WORLD_SIZE,
/*Titanium*/ EmuConstants::MAP_WORLD_SIZE,
/*SoF*/ EmuConstants::MAP_WORLD_SIZE,
/*SoD*/ EmuConstants::MAP_WORLD_SIZE,
/*Underfoot*/ EmuConstants::MAP_WORLD_SIZE,
/*RoF*/ EmuConstants::MAP_WORLD_SIZE,
/*RoF2*/ 0,
/*NPC*/ NOT_USED,
/*Merc*/ NOT_USED,
/*Bot*/ NOT_USED,
/*Pet*/ NOT_USED
},
{ // local[MapLimbo]
/*Unknown*/ NOT_USED,
/*62*/ EmuConstants::MAP_LIMBO_SIZE,
/*Titanium*/ EmuConstants::MAP_LIMBO_SIZE,
/*SoF*/ EmuConstants::MAP_LIMBO_SIZE,
/*SoD*/ EmuConstants::MAP_LIMBO_SIZE,
/*Underfoot*/ EmuConstants::MAP_LIMBO_SIZE,
/*RoF*/ EmuConstants::MAP_LIMBO_SIZE,
/*RoF2*/ 0,
/*NPC*/ NOT_USED,
/*Merc*/ NOT_USED,
/*Bot*/ NOT_USED,
/*Pet*/ NOT_USED
},
{ // local[MapTribute]
/*Unknown*/ NOT_USED,
/*62*/ EmuConstants::MAP_TRIBUTE_SIZE,
/*Titanium*/ EmuConstants::MAP_TRIBUTE_SIZE,
/*SoF*/ EmuConstants::MAP_TRIBUTE_SIZE,
/*SoD*/ EmuConstants::MAP_TRIBUTE_SIZE,
/*Underfoot*/ EmuConstants::MAP_TRIBUTE_SIZE,
/*RoF*/ EmuConstants::MAP_TRIBUTE_SIZE,
/*RoF2*/ 0,
/*NPC*/ 0,
/*Merc*/ 0,
/*Bot*/ 0,
/*Pet*/ 0
},
{ // local[MapTrophyTribute]
/*Unknown*/ NOT_USED,
/*62*/ 0,
/*Titanium*/ 0,
/*SoF*/ 0,
/*SoD*/ 0,
/*Underfoot*/ 0,
/*RoF*/ EmuConstants::MAP_TROPHY_TRIBUTE_SIZE,
/*RoF2*/ 0,
/*NPC*/ 0,
/*Merc*/ 0,
/*Bot*/ 0,
/*Pet*/ 0
},
{ // local[MapGuildTribute]
/*Unknown*/ NOT_USED,
/*62*/ 0,
/*Titanium*/ 0,
/*SoF*/ 0,
/*SoD*/ 0,
/*Underfoot*/ 0,
/*RoF*/ EmuConstants::MAP_GUILD_TRIBUTE_SIZE,
/*RoF2*/ 0,
/*NPC*/ 0,
/*Merc*/ 0,
/*Bot*/ 0,
/*Pet*/ 0
},
{ // local[MapMerchant]
/*Unknown*/ NOT_USED,
/*62*/ 0,
/*Titanium*/ 0,
/*SoF*/ 0,
/*SoD*/ 0,
/*Underfoot*/ 0,
/*RoF*/ EmuConstants::MAP_MERCHANT_SIZE,
/*RoF2*/ 0,
/*NPC*/ 0,
/*Merc*/ 0,
/*Bot*/ 0,
/*Pet*/ 0
},
{ // local[MapDeleted]
/*Unknown*/ NOT_USED,
/*62*/ 0,
/*Titanium*/ 0,
/*SoF*/ 0,
/*SoD*/ 0,
/*Underfoot*/ 0,
/*RoF*/ EmuConstants::MAP_DELETED_SIZE,
/*RoF2*/ 0,
/*NPC*/ 0,
/*Merc*/ 0,
/*Bot*/ 0,
/*Pet*/ 0
},
{ // local[MapCorpse]
/*Unknown*/ NOT_USED,
/*62*/ Client62::consts::MAP_CORPSE_SIZE,
/*Titanium*/ Titanium::consts::MAP_CORPSE_SIZE,
/*SoF*/ SoF::consts::MAP_CORPSE_SIZE,
/*SoD*/ SoD::consts::MAP_CORPSE_SIZE,
/*Underfoot*/ Underfoot::consts::MAP_CORPSE_SIZE,
/*RoF*/ RoF::consts::MAP_CORPSE_SIZE,
/*RoF2*/ 0,
/*NPC*/ 0,
/*Merc*/ 0,
/*Bot*/ 0,
/*Pet*/ 0
},
{ // local[MapBazaar]
/*Unknown*/ NOT_USED,
/*62*/ EmuConstants::MAP_BAZAAR_SIZE,
/*Titanium*/ EmuConstants::MAP_BAZAAR_SIZE,
/*SoF*/ EmuConstants::MAP_BAZAAR_SIZE,
/*SoD*/ EmuConstants::MAP_BAZAAR_SIZE,
/*Underfoot*/ EmuConstants::MAP_BAZAAR_SIZE,
/*RoF*/ EmuConstants::MAP_BAZAAR_SIZE,
/*RoF2*/ 0,
/*NPC*/ 0, // this may need to be 'EmuConstants::MAP_BAZAAR_SIZE' if offline client traders respawn as an npc
/*Merc*/ 0,
/*Bot*/ 0,
/*Pet*/ 0
},
{ // local[MapInspect]
/*Unknown*/ NOT_USED,
/*62*/ Client62::consts::MAP_INSPECT_SIZE,
/*Titanium*/ Titanium::consts::MAP_INSPECT_SIZE,
/*SoF*/ SoF::consts::MAP_INSPECT_SIZE,
/*SoD*/ SoD::consts::MAP_INSPECT_SIZE,
/*Underfoot*/ Underfoot::consts::MAP_INSPECT_SIZE,
/*RoF*/ RoF::consts::MAP_INSPECT_SIZE,
/*RoF2*/ 0,
/*NPC*/ NOT_USED,
/*Merc*/ NOT_USED,
/*Bot*/ NOT_USED,
/*Pet*/ NOT_USED
},
{ // local[MapRealEstate]
/*Unknown*/ NOT_USED,
/*62*/ 0,
/*Titanium*/ 0,
/*SoF*/ 0,
/*SoD*/ 0,
/*Underfoot*/ 0,
/*RoF*/ EmuConstants::MAP_REAL_ESTATE_SIZE,
/*RoF2*/ 0,
/*NPC*/ 0,
/*Merc*/ 0,
/*Bot*/ 0,
/*Pet*/ 0
},
{ // local[MapViewMODPC]
/*Unknown*/ NOT_USED,
/*62*/ 0,
/*Titanium*/ 0,
/*SoF*/ 0,
/*SoD*/ 0,
/*Underfoot*/ 0,
/*RoF*/ EmuConstants::MAP_VIEW_MOD_PC_SIZE,
/*RoF2*/ 0,
/*NPC*/ 0,
/*Merc*/ 0,
/*Bot*/ 0,
/*Pet*/ 0
},
{ // local[MapViewMODBank]
/*Unknown*/ NOT_USED,
/*62*/ 0,
/*Titanium*/ 0,
/*SoF*/ 0,
/*SoD*/ 0,
/*Underfoot*/ 0,
/*RoF*/ EmuConstants::MAP_VIEW_MOD_BANK_SIZE,
/*RoF2*/ 0,
/*NPC*/ 0,
/*Merc*/ 0,
/*Bot*/ 0,
/*Pet*/ 0
},
{ // local[MapViewMODSharedBank]
/*Unknown*/ NOT_USED,
/*62*/ 0,
/*Titanium*/ 0,
/*SoF*/ 0,
/*SoD*/ 0,
/*Underfoot*/ 0,
/*RoF*/ EmuConstants::MAP_VIEW_MOD_SHARED_BANK_SIZE,
/*RoF2*/ 0,
/*NPC*/ 0,
/*Merc*/ 0,
/*Bot*/ 0,
/*Pet*/ 0
},
{ // local[MapViewMODLimbo]
/*Unknown*/ NOT_USED,
/*62*/ 0,
/*Titanium*/ 0,
/*SoF*/ 0,
/*SoD*/ 0,
/*Underfoot*/ 0,
/*RoF*/ EmuConstants::MAP_VIEW_MOD_LIMBO_SIZE,
/*RoF2*/ 0,
/*NPC*/ 0,
/*Merc*/ 0,
/*Bot*/ 0,
/*Pet*/ 0
},
{ // local[MapAltStorage]
/*Unknown*/ NOT_USED,
/*62*/ 0,
/*Titanium*/ 0,
/*SoF*/ 0,
/*SoD*/ 0,
/*Underfoot*/ 0,
/*RoF*/ EmuConstants::MAP_ALT_STORAGE_SIZE,
/*RoF2*/ 0,
/*NPC*/ 0,
/*Merc*/ 0,
/*Bot*/ 0,
/*Pet*/ 0
},
{ // local[MapArchived]
/*Unknown*/ NOT_USED,
/*62*/ 0,
/*Titanium*/ 0,
/*SoF*/ 0,
/*SoD*/ 0,
/*Underfoot*/ 0,
/*RoF*/ EmuConstants::MAP_ARCHIVED_SIZE,
/*RoF2*/ 0,
/*NPC*/ 0,
/*Merc*/ 0,
/*Bot*/ 0,
/*Pet*/ 0
},
{ // local[MapMail]
/*Unknown*/ NOT_USED,
/*62*/ 0,
/*Titanium*/ 0,
/*SoF*/ 0,
/*SoD*/ 0,
/*Underfoot*/ 0,
/*RoF*/ EmuConstants::MAP_MAIL_SIZE,
/*RoF2*/ 0,
/*NPC*/ 0,
/*Merc*/ 0,
/*Bot*/ 0,
/*Pet*/ 0
},
{ // local[MapGuildTrophyTribute]
/*Unknown*/ NOT_USED,
/*62*/ 0,
/*Titanium*/ 0,
/*SoF*/ 0,
/*SoD*/ 0,
/*Underfoot*/ 0,
/*RoF*/ EmuConstants::MAP_GUILD_TROPHY_TRIBUTE_SIZE,
/*RoF2*/ 0,
/*NPC*/ 0,
/*Merc*/ 0,
/*Bot*/ 0,
/*Pet*/ 0
},
{ // local[MapKrono]
/*Unknown*/ NOT_USED,
/*62*/ NOT_USED,
/*Titanium*/ NOT_USED,
/*SoF*/ NOT_USED,
/*SoD*/ NOT_USED,
/*Underfoot*/ NOT_USED,
/*RoF*/ EmuConstants::MAP_KRONO_SIZE,
/*RoF2*/ 0,
/*NPC*/ 0,
/*Merc*/ 0,
/*Bot*/ 0,
/*Pet*/ 0
},
{ // local[MapOther]
/*Unknown*/ NOT_USED,
/*62*/ 0,
/*Titanium*/ 0,
/*SoF*/ 0,
/*SoD*/ 0,
/*Underfoot*/ 0,
/*RoF*/ EmuConstants::MAP_OTHER_SIZE,
/*RoF2*/ 0,
/*NPC*/ 0,
/*Merc*/ 0,
/*Bot*/ 0,
/*Pet*/ 0
}
}; };
if ((uint16)map < _MapCount) if ((uint16)map < _MapCount)
@ -197,10 +730,10 @@ uint16 EQLimits::InventoryMapSize(int16 map, uint32 version) {
} }
uint64 EQLimits::PossessionsBitmask(uint32 version) { uint64 EQLimits::PossessionsBitmask(uint32 version) {
// these are for the new inventory system..not the current one... // these are for the new inventory system (RoF)..not the current (Ti) one...
// 0x0000000000200000 is SlotPowerSource (SoF+) // 0x0000000000200000 is SlotPowerSource (SoF+)
// 0x0000000100000000 is SlotGeneral9 (RoF+) // 0x0000000080000000 is SlotGeneral9 (RoF+)
// 0x0000000200000000 is SlotGeneral10 (RoF+) // 0x0000000100000000 is SlotGeneral10 (RoF+)
static const uint64 local[_EmuClientCount] = { static const uint64 local[_EmuClientCount] = {
/*Unknown*/ NOT_USED, /*Unknown*/ NOT_USED,
@ -218,7 +751,8 @@ uint64 EQLimits::PossessionsBitmask(uint32 version) {
/*Pet*/ 0 /*Pet*/ 0
}; };
return local[ValidateMobVersion(version)]; return NOT_USED;
//return local[ValidateMobVersion(version)];
} }
uint64 EQLimits::EquipmentBitmask(uint32 version) { uint64 EQLimits::EquipmentBitmask(uint32 version) {
@ -238,7 +772,8 @@ uint64 EQLimits::EquipmentBitmask(uint32 version) {
/*Pet*/ 0 /*Pet*/ 0
}; };
return local[ValidateMobVersion(version)]; return NOT_USED;
//return local[ValidateMobVersion(version)];
} }
uint64 EQLimits::GeneralBitmask(uint32 version) { uint64 EQLimits::GeneralBitmask(uint32 version) {
@ -258,7 +793,8 @@ uint64 EQLimits::GeneralBitmask(uint32 version) {
/*Pet*/ 0 /*Pet*/ 0
}; };
return local[ValidateMobVersion(version)]; return NOT_USED;
//return local[ValidateMobVersion(version)];
} }
uint64 EQLimits::CursorBitmask(uint32 version) { uint64 EQLimits::CursorBitmask(uint32 version) {
@ -278,18 +814,81 @@ uint64 EQLimits::CursorBitmask(uint32 version) {
/*Pet*/ 0 /*Pet*/ 0
}; };
return local[ValidateMobVersion(version)]; return NOT_USED;
//return local[ValidateMobVersion(version)];
} }
bool EQLimits::AllowsEmptyBagInBag(uint32 version) { bool EQLimits::AllowsEmptyBagInBag(uint32 version) {
static const bool local[_EmuClientCount] = { static const bool local[_EmuClientCount] = {
/*Unknown*/ false, /*Unknown*/ false,
/*62*/ false, /*62*/ Client62::limits::ALLOWS_EMPTY_BAG_IN_BAG,
/*Titanium*/ false, /*Titanium*/ Titanium::limits::ALLOWS_EMPTY_BAG_IN_BAG,
/*SoF*/ false, /*SoF*/ SoF::limits::ALLOWS_EMPTY_BAG_IN_BAG,
/*SoD*/ false, /*SoD*/ SoD::limits::ALLOWS_EMPTY_BAG_IN_BAG,
/*Underfoot*/ false, /*Underfoot*/ Underfoot::limits::ALLOWS_EMPTY_BAG_IN_BAG,
/*RoF*/ true, /*RoF*/ RoF::limits::ALLOWS_EMPTY_BAG_IN_BAG,
/*RoF2*/ false,
/*NPC*/ false,
/*Merc*/ false,
/*Bot*/ false,
/*Pet*/ false
};
return false; // not implemented
//return local[ValidateMobVersion(version)];
}
// items
uint16 EQLimits::ItemCommonSize(uint32 version) {
static const uint16 local[_EmuClientCount] = {
/*Unknown*/ NOT_USED,
/*62*/ EmuConstants::ITEM_COMMON_SIZE,
/*Titanium*/ EmuConstants::ITEM_COMMON_SIZE,
/*SoF*/ EmuConstants::ITEM_COMMON_SIZE,
/*SoD*/ EmuConstants::ITEM_COMMON_SIZE,
/*Underfoot*/ EmuConstants::ITEM_COMMON_SIZE,
/*RoF*/ EmuConstants::ITEM_COMMON_SIZE,
/*RoF2*/ 0,
/*NPC*/ EmuConstants::ITEM_COMMON_SIZE,
/*Merc*/ EmuConstants::ITEM_COMMON_SIZE,
/*Bot*/ EmuConstants::ITEM_COMMON_SIZE,
/*Pet*/ EmuConstants::ITEM_COMMON_SIZE
};
return local[ValidateMobVersion(version)];
}
uint16 EQLimits::ItemContainerSize(uint32 version) {
static const uint16 local[_EmuClientCount] = {
/*Unknown*/ NOT_USED,
/*62*/ EmuConstants::ITEM_CONTAINER_SIZE,
/*Titanium*/ EmuConstants::ITEM_CONTAINER_SIZE,
/*SoF*/ EmuConstants::ITEM_CONTAINER_SIZE,
/*SoD*/ EmuConstants::ITEM_CONTAINER_SIZE,
/*Underfoot*/ EmuConstants::ITEM_CONTAINER_SIZE,
/*RoF*/ EmuConstants::ITEM_CONTAINER_SIZE,
/*RoF2*/ 0,
/*NPC*/ EmuConstants::ITEM_CONTAINER_SIZE,
/*Merc*/ EmuConstants::ITEM_CONTAINER_SIZE,
/*Bot*/ EmuConstants::ITEM_CONTAINER_SIZE,
/*Pet*/ EmuConstants::ITEM_CONTAINER_SIZE
};
return local[ValidateMobVersion(version)];
}
bool EQLimits::CoinHasWeight(uint32 version) {
static const bool local[_EmuClientCount] = {
/*Unknown*/ true,
/*62*/ Client62::limits::COIN_HAS_WEIGHT,
/*Titanium*/ Titanium::limits::COIN_HAS_WEIGHT,
/*SoF*/ SoF::limits::COIN_HAS_WEIGHT,
/*SoD*/ SoD::limits::COIN_HAS_WEIGHT,
/*Underfoot*/ Underfoot::limits::COIN_HAS_WEIGHT,
/*RoF*/ RoF::limits::COIN_HAS_WEIGHT,
/*RoF2*/ true, /*RoF2*/ true,
/*NPC*/ true, /*NPC*/ true,
@ -301,62 +900,61 @@ bool EQLimits::AllowsEmptyBagInBag(uint32 version) {
return local[ValidateMobVersion(version)]; return local[ValidateMobVersion(version)];
} }
// items uint32 EQLimits::BandoliersCount(uint32 version) {
uint16 EQLimits::ItemCommonSize(uint32 version) {
static const uint16 local[_EmuClientCount] = {
/*Unknown*/ NOT_USED,
/*62*/ 5,
/*Titanium*/ 5,
/*SoF*/ 5,
/*SoD*/ 5,
/*Underfoot*/ 5,
/*RoF*/ EmuConstants::ITEM_COMMON_SIZE,
/*RoF2*/ 0,
/*NPC*/ 0,
/*Merc*/ 0,
/*Bot*/ 0,
/*Pet*/ 0
};
return local[ValidateMobVersion(version)];
}
uint16 EQLimits::ItemContainerSize(uint32 version) {
static const uint16 local[_EmuClientCount] = {
/*Unknown*/ NOT_USED,
/*62*/ 10,
/*Titanium*/ 10,
/*SoF*/ 10,
/*SoD*/ 10,
/*Underfoot*/ 10,
/*RoF*/ EmuConstants::ITEM_CONTAINER_SIZE,
/*RoF2*/ 0,
/*NPC*/ 0,
/*Merc*/ 0,
/*Bot*/ 0,
/*Pet*/ 0
};
return local[ValidateMobVersion(version)];
}
bool EQLimits::CoinHasWeight(uint32 version) {
static const bool local[_EmuClientCount] = { static const bool local[_EmuClientCount] = {
/*Unknown*/ true, /*Unknown*/ NOT_USED,
/*62*/ true, /*62*/ EmuConstants::BANDOLIERS_COUNT,
/*Titanium*/ true, /*Titanium*/ EmuConstants::BANDOLIERS_COUNT,
/*SoF*/ true, /*SoF*/ EmuConstants::BANDOLIERS_COUNT,
/*SoD*/ false, /*SoD*/ EmuConstants::BANDOLIERS_COUNT,
/*Underfoot*/ false, /*Underfoot*/ EmuConstants::BANDOLIERS_COUNT,
/*RoF*/ false, /*RoF*/ EmuConstants::BANDOLIERS_COUNT,
/*RoF2*/ false, /*RoF2*/ 0,
/*NPC*/ false, /*NPC*/ NOT_USED,
/*Merc*/ false, /*Merc*/ NOT_USED,
/*Bot*/ false, /*Bot*/ NOT_USED,
/*Pet*/ false /*Pet*/ NOT_USED
};
return local[ValidateMobVersion(version)];
}
uint32 EQLimits::BandolierSize(uint32 version) {
static const bool local[_EmuClientCount] = {
/*Unknown*/ NOT_USED,
/*62*/ EmuConstants::BANDOLIER_SIZE,
/*Titanium*/ EmuConstants::BANDOLIER_SIZE,
/*SoF*/ EmuConstants::BANDOLIER_SIZE,
/*SoD*/ EmuConstants::BANDOLIER_SIZE,
/*Underfoot*/ EmuConstants::BANDOLIER_SIZE,
/*RoF*/ EmuConstants::BANDOLIER_SIZE,
/*RoF2*/ 0,
/*NPC*/ NOT_USED,
/*Merc*/ NOT_USED,
/*Bot*/ NOT_USED,
/*Pet*/ NOT_USED
};
return local[ValidateMobVersion(version)];
}
uint32 EQLimits::PotionBeltSize(uint32 version) {
static const bool local[_EmuClientCount] = {
/*Unknown*/ NOT_USED,
/*62*/ EmuConstants::POTION_BELT_SIZE,
/*Titanium*/ EmuConstants::POTION_BELT_SIZE,
/*SoF*/ EmuConstants::POTION_BELT_SIZE,
/*SoD*/ EmuConstants::POTION_BELT_SIZE,
/*Underfoot*/ EmuConstants::POTION_BELT_SIZE,
/*RoF*/ EmuConstants::POTION_BELT_SIZE,
/*RoF2*/ 0,
/*NPC*/ NOT_USED,
/*Merc*/ NOT_USED,
/*Bot*/ NOT_USED,
/*Pet*/ NOT_USED
}; };
return local[ValidateMobVersion(version)]; return local[ValidateMobVersion(version)];

174
common/eq_dictionary.h
View File

@ -1,19 +1,22 @@
/* EQEMu: Everquest Server Emulator /*
Copyright (C) 2001-2003 EQEMu Development Team (http://eqemulator.net) EQEMu: Everquest Server Emulator
This program is free software; you can redistribute it and/or modify Copyright (C) 2001-2014 EQEMu Development Team (http://eqemulator.net)
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful, This program is free software; you can redistribute it and/or modify
but WITHOUT ANY WARRANTY except by those people which sell it, which it under the terms of the GNU General Public License as published by
are required to give you total support for your newly bought product; the Free Software Foundation; version 2 of the License.
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details. This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/ */
#ifndef EQ_DICTIONARY_H #ifndef EQ_DICTIONARY_H
@ -22,65 +25,145 @@
#include "types.h" #include "types.h"
#include "eq_constants.h" #include "eq_constants.h"
#include "clientversions.h" #include "clientversions.h"
#include <string>
#include "../common/patches/Client62_constants.h"
#include "../common/patches/Titanium_constants.h"
#include "../common/patches/SoF_constants.h"
#include "../common/patches/SoD_constants.h"
#include "../common/patches/Underfoot_constants.h"
#include "../common/patches/RoF_constants.h"
//#include "../common/patches/RoF2_constants.h"
// *** DO NOT CHANGE without a full understanding of the consequences..the server is set up to use these settings explicitly!! ***
// *** You will cause compilation failures and corrupt your database if partial or incorrect attempts to them change are made!! ***
// Hard-coded values usually indicate that further research is needed and the values given are from the old (known) system
// (future use)
//using namespace RoF2::maps; // server inventory maps enumeration (code and database sync'd to reference)
//using namespace RoF::slots; // server possessions slots enumeration (code and database sync'd to reference)
// an immutable value is required to initialize arrays, etc... use this class as a repository for those
typedef class { typedef class {
// an immutable value is required to initialize arrays, etc... use this class as a repository for those
public: public:
// database // database
static const EQClientVersion CHARACTER_CREATION_CLIENT = _EQCreationClient; static const EQClientVersion CHARACTER_CREATION_CLIENT = EQClientRoF; // adjust according to starting item placement and target client
// inventory // inventory
static uint16 InventoryMapSize(int16 map); static uint16 InventoryMapSize(int16 map);
//static std::string InventoryLocationName(Location_Struct location);
static std::string InventoryMapName(int16 map);
static std::string InventoryMainName(int16 main);
static std::string InventorySubName(int16 sub);
static std::string InventoryAugName(int16 aug);
static const uint16 MAP_POSSESSIONS_SIZE = 22; //_SlotCount; // these are currently hard-coded for existing inventory system..do not use in place of special client version handlers until ready
static const uint16 MAP_POSSESSIONS_SIZE = _MainCount;
static const uint16 MAP_BANK_SIZE = 24; static const uint16 MAP_BANK_SIZE = 24;
static const uint16 MAP_SHAREDBANK_SIZE = 2; static const uint16 MAP_SHARED_BANK_SIZE = 2;
static const uint16 MAP_TRADE_SIZE = 8; static const uint16 MAP_TRADE_SIZE = 8;
static const uint16 MAP_WORLD_SIZE = 10; static const uint16 MAP_WORLD_SIZE = 10;
static const uint16 MAP_LIMBO_SIZE = 36; static const uint16 MAP_LIMBO_SIZE = 36;
static const uint16 MAP_TRIBUTE_SIZE = 5; static const uint16 MAP_TRIBUTE_SIZE = 5; // (need client values)
static const uint16 MAP_TROPHYTRIBUTE_SIZE = 0; static const uint16 MAP_TROPHY_TRIBUTE_SIZE = 0;
static const uint16 MAP_GUILDTRIBUTE_SIZE = 0; static const uint16 MAP_GUILD_TRIBUTE_SIZE = 0;
static const uint16 MAP_MERCHANT_SIZE = 0; static const uint16 MAP_MERCHANT_SIZE = 0;
static const uint16 MAP_DELETED_SIZE = 0; static const uint16 MAP_DELETED_SIZE = 0;
static const uint16 MAP_CORPSE_SIZE = 22; //_SlotCount; // actual code still needs lots of work... static const uint16 MAP_CORPSE_SIZE = _MainCount; // no bitmask use..limits to size of client corpse window (see EQLimits::InventoryMapSize(MapCorpse, <EQClientVersion))
static const uint16 MAP_BAZAAR_SIZE = 80; //200; static const uint16 MAP_BAZAAR_SIZE = 80;
static const uint16 MAP_INSPECT_SIZE = 22; //_SlotEquipmentCount; static const uint16 MAP_INSPECT_SIZE = 22;
static const uint16 MAP_REALESTATE_SIZE = 0; static const uint16 MAP_REAL_ESTATE_SIZE = 0;
static const uint16 MAP_VIEWMODPC_SIZE = NOT_USED; static const uint16 MAP_VIEW_MOD_PC_SIZE = NOT_USED;
static const uint16 MAP_VIEWMODBANK_SIZE = NOT_USED; static const uint16 MAP_VIEW_MOD_BANK_SIZE = NOT_USED;
static const uint16 MAP_VIEWMODSHAREDBANK_SIZE = NOT_USED; static const uint16 MAP_VIEW_MOD_SHARED_BANK_SIZE = NOT_USED;
static const uint16 MAP_VIEWMODLIMBO_SIZE = NOT_USED; static const uint16 MAP_VIEW_MOD_LIMBO_SIZE = NOT_USED;
static const uint16 MAP_ALTSTORAGE_SIZE = 0; static const uint16 MAP_ALT_STORAGE_SIZE = 0;
static const uint16 MAP_ARCHIVED_SIZE = 0; static const uint16 MAP_ARCHIVED_SIZE = 0;
static const uint16 MAP_MAIL_SIZE = 0; static const uint16 MAP_MAIL_SIZE = 0;
static const uint16 MAP_GUILDTROPHYTRIBUTE_SIZE = 0; static const uint16 MAP_GUILD_TROPHY_TRIBUTE_SIZE = 0;
static const uint16 MAP_KRONO_SIZE = 0; // this will be '1' when RoF2 is implemented static const uint16 MAP_KRONO_SIZE = 0;
static const uint16 MAP_OTHER_SIZE = 0; static const uint16 MAP_OTHER_SIZE = 0;
//static const int16 EQUIPMENT_BEGIN = _SlotEquipmentBegin; // most of these definitions will go away with the structure-based system..this maintains compatibility for now
//static const int16 EQUIPMENT_END = _SlotEquipmentEnd; // (these are mainly to assign specific values to constants used in conversions and to identify per-client ranges/offsets)
static const uint16 EQUIPMENT_SIZE = 22; //_SlotEquipmentCount; // not ready for client usage..only equipment arrays for npcs... static const int16 POSSESSIONS_BEGIN = MainCharm;
static const int16 POSSESSIONS_END = MainCursor;
static const int16 GENERAL_BEGIN = 22; //_SlotGeneralBegin; static const int16 EQUIPMENT_BEGIN = MainCharm;
static const int16 GENERAL_END = 29; //_SlotGeneralEnd; static const int16 EQUIPMENT_END = MainAmmo;
static const uint16 GENERAL_SIZE = 8; //_SlotGeneralCount; static const uint16 EQUIPMENT_SIZE = 22; // does not account for 'Power Source' - used mainly for npc equipment arrays
static const int16 POWER_SOURCE = MainPowerSource; // temp
static const int16 GENERAL_BEGIN = MainGeneral1;
static const int16 GENERAL_END = MainGeneral8;
static const uint16 GENERAL_SIZE = 8;
static const int16 GENERAL_BAGS_BEGIN = 251;
static const int16 GENERAL_BAGS_END_OFFSET = 79;
static const int16 GENERAL_BAGS_END = GENERAL_BAGS_BEGIN + GENERAL_BAGS_END_OFFSET;
static const int16 CURSOR = MainCursor;
static const int16 CURSOR_BAG_BEGIN = 331;
static const int16 CURSOR_BAG_END_OFFSET = 9;
static const int16 CURSOR_BAG_END = CURSOR_BAG_BEGIN + CURSOR_BAG_END_OFFSET;
static const int16 BANK_BEGIN = 2000;
static const int16 BANK_END = 2023;
static const int16 BANK_BAGS_BEGIN = 2031;
static const int16 BANK_BAGS_END_OFFSET = 239;
static const int16 BANK_BAGS_END = BANK_BAGS_BEGIN + BANK_BAGS_END_OFFSET;
static const int16 SHARED_BANK_BEGIN = 2500;
static const int16 SHARED_BANK_END = 2501;
static const int16 SHARED_BANK_BAGS_BEGIN = 2531;
static const int16 SHARED_BANK_BAGS_END_OFFSET = 19;
static const int16 SHARED_BANK_BAGS_END = SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_END_OFFSET;
static const int16 TRADE_BEGIN = 3000;
static const int16 TRADE_END = 3007;
static const int16 TRADE_NPC_END = 3003;
static const int16 TRADE_BAGS_BEGIN = 3031;
static const int16 TRADE_BAGS_END_OFFSET = 79;
static const int16 TRADE_BAGS_END = TRADE_BAGS_BEGIN + TRADE_BAGS_END_OFFSET;
static const int16 WORLD_BEGIN = 4000;
static const int16 WORLD_END = 4009;
static const int16 WORLD_SIZE = 10;
static const int16 TRIBUTE_BEGIN = 400;
static const int16 TRIBUTE_END = 404;
static const int16 TRIBUTE_SIZE = 5;
static const int16 CORPSE_BEGIN = 22;
//static const int16 CORPSE_END = RoF::consts::CORPSE_END; // not ready for use
static const int16 MATERIAL_BEGIN = MaterialHead;
static const int16 MATERIAL_END = MaterialSecondary;
static const int16 MATERIAL_SIZE = _MaterialCount;
static const int16 TINTABLE_BEGIN = MaterialHead;
static const int16 TINTABLE_END = MaterialFeet;
static const int16 TINTABLE_SIZE = 7;
// items // items
static const uint16 ITEM_COMMON_SIZE = 5; // common and container sizes will not increase until the new 'location' struct is implemented
static const uint16 ITEM_CONTAINER_SIZE = 10; static const uint16 ITEM_COMMON_SIZE = Underfoot::consts::ITEM_COMMON_SIZE;
static const uint16 ITEM_CONTAINER_SIZE = Underfoot::consts::ITEM_CONTAINER_SIZE;
// player profile // player profile
//static const uint32 CLASS_BITMASK = 0; // needs value //static const uint32 CLASS_BITMASK = 0; // needs value
//static const uint32 RACE_BITMASK = 0; // needs value //static const uint32 RACE_BITMASK = 0; // needs value
// TODO: resolve naming convention and use for bandolier count versus size // BANDOLIERS_COUNT sets maximum limit..active limit will need to be handled by the appropriate AA
//static const uint32 BANDOLIER_COUNT = 4; static const uint32 BANDOLIERS_COUNT = Titanium::consts::BANDOLIERS_COUNT; // count = number of bandolier instances
static const uint32 BANDOLIER_SIZE = 4; static const uint32 BANDOLIER_SIZE = Titanium::consts::BANDOLIER_SIZE; // size = number of equipment slots in bandolier instance
static const uint32 POTION_BELT_SIZE = 5; static const uint32 POTION_BELT_SIZE = Titanium::consts::POTION_BELT_SIZE;
} EmuConstants; } EmuConstants;
typedef class { typedef class {
// values should default to a non-beneficial value..unless value conflicts with intended operation
//
// EmuConstants may be used as references..but, not every reference needs to be in EmuConstants (i.e., AllowsEmptyBagInBag(), CoinHasWeight(), etc...)
public: public:
// client version validation (checks to avoid crashing zone server when accessing reference arrays) // client version validation (checks to avoid crashing zone server when accessing reference arrays)
// use this inside of class Client (limits to actual clients) // use this inside of class Client (limits to actual clients)
@ -113,6 +196,11 @@ public:
// player profile // player profile
static bool CoinHasWeight(uint32 version); static bool CoinHasWeight(uint32 version);
static uint32 BandoliersCount(uint32 version);
static uint32 BandolierSize(uint32 version);
static uint32 PotionBeltSize(uint32 version);
} EQLimits; } EQLimits;
#endif /* EQ_LIMITS_H */ #endif /* EQ_LIMITS_H */

28
common/eq_packet_structs.h
View File

@ -721,12 +721,8 @@ struct Disciplines_Struct {
uint32 values[MAX_PP_DISCIPLINES]; uint32 values[MAX_PP_DISCIPLINES];
}; };
static const uint32 TRIBUTE_SLOT_START = 400;
static const uint32 MAX_PLAYER_TRIBUTES = 5;
static const uint32 MAX_PLAYER_BANDOLIER = 4;
static const uint32 MAX_PLAYER_BANDOLIER_ITEMS = 4;
static const uint32 MAX_POTIONS_IN_BELT = 4;
static const uint32 TRIBUTE_NONE = 0xFFFFFFFF; static const uint32 TRIBUTE_NONE = 0xFFFFFFFF;
struct Tribute_Struct { struct Tribute_Struct {
uint32 tribute; uint32 tribute;
uint32 tier; uint32 tier;
@ -748,10 +744,10 @@ enum { //bandolier item positions
}; };
struct Bandolier_Struct { struct Bandolier_Struct {
char name[32]; char name[32];
BandolierItem_Struct items[MAX_PLAYER_BANDOLIER_ITEMS]; BandolierItem_Struct items[EmuConstants::BANDOLIER_SIZE];
}; };
struct PotionBelt_Struct { struct PotionBelt_Struct {
BandolierItem_Struct items[MAX_POTIONS_IN_BELT]; BandolierItem_Struct items[EmuConstants::POTION_BELT_SIZE];
}; };
struct MovePotionToBelt_Struct { struct MovePotionToBelt_Struct {
@ -1000,7 +996,7 @@ struct PlayerProfile_Struct
/*7212*/ uint32 tribute_points; /*7212*/ uint32 tribute_points;
/*7216*/ uint32 unknown7252; /*7216*/ uint32 unknown7252;
/*7220*/ uint32 tribute_active; //1=active /*7220*/ uint32 tribute_active; //1=active
/*7224*/ Tribute_Struct tributes[MAX_PLAYER_TRIBUTES]; /*7224*/ Tribute_Struct tributes[EmuConstants::TRIBUTE_SIZE];
/*7264*/ Disciplines_Struct disciplines; /*7264*/ Disciplines_Struct disciplines;
/*7664*/ uint32 recastTimers[MAX_RECAST_TYPES]; // Timers (GMT of last use) /*7664*/ uint32 recastTimers[MAX_RECAST_TYPES]; // Timers (GMT of last use)
/*7744*/ char unknown7780[160]; /*7744*/ char unknown7780[160];
@ -1027,7 +1023,7 @@ struct PlayerProfile_Struct
/*12800*/ uint32 expAA; /*12800*/ uint32 expAA;
/*12804*/ uint32 aapoints; //avaliable, unspent /*12804*/ uint32 aapoints; //avaliable, unspent
/*12808*/ uint8 unknown12844[36]; /*12808*/ uint8 unknown12844[36];
/*12844*/ Bandolier_Struct bandoliers[MAX_PLAYER_BANDOLIER]; /*12844*/ Bandolier_Struct bandoliers[EmuConstants::BANDOLIERS_COUNT];
/*14124*/ uint8 unknown14160[4506]; /*14124*/ uint8 unknown14160[4506];
/*18630*/ SuspendedMinion_Struct SuspendedMinion; // No longer in use /*18630*/ SuspendedMinion_Struct SuspendedMinion; // No longer in use
/*19240*/ uint32 timeentitledonaccount; /*19240*/ uint32 timeentitledonaccount;
@ -1470,6 +1466,16 @@ struct MoveItem_Struct
/*0008*/ uint32 number_in_stack; /*0008*/ uint32 number_in_stack;
}; };
// both MoveItem_Struct/DeleteItem_Struct server structures will be changing to a structure-based slot format..this will
// be used for handling SoF/SoD/etc... time stamps sent using the MoveItem_Struct format. (nothing will be done with this
// info at the moment..but, it forwards it on to the server for handling/future use)
struct ClientTimeStamp_Struct
{
/*0000*/ uint32 from_slot;
/*0004*/ uint32 to_slot;
/*0008*/ uint32 number_in_stack;
};
// //
// from_slot/to_slot // from_slot/to_slot
// -1 - destroy // -1 - destroy
@ -3343,8 +3349,8 @@ struct SelectTributeReply_Struct {
struct TributeInfo_Struct { struct TributeInfo_Struct {
uint32 active; //0 == inactive, 1 == active uint32 active; //0 == inactive, 1 == active
uint32 tributes[MAX_PLAYER_TRIBUTES]; //-1 == NONE uint32 tributes[EmuConstants::TRIBUTE_SIZE]; //-1 == NONE
uint32 tiers[MAX_PLAYER_TRIBUTES]; //all 00's uint32 tiers[EmuConstants::TRIBUTE_SIZE]; //all 00's
uint32 tribute_master_id; uint32 tribute_master_id;
}; };

214
common/patches/Client62_constants.h Normal file
View File

@ -0,0 +1,214 @@
/*
EQEMu: Everquest Server Emulator
Copyright (C) 2001-2014 EQEMu Development Team (http://eqemulator.net)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef CLIENT62_CONSTANTS_H_
#define CLIENT62_CONSTANTS_H_
#include "../common/types.h"
namespace Client62 {
namespace maps {
typedef enum : int16 {
// this needs work to match actual client equivilents
MapPossessions = 0,
MapBank,
MapSharedBank,
MapTrade,
MapWorld,
MapLimbo,
MapTribute,
MapTrophyTribute,
MapGuildTribute,
MapMerchant,
MapDeleted,
MapCorpse,
MapBazaar,
MapInspect,
MapRealEstate,
MapViewMODPC,
MapViewMODBank,
MapViewMODSharedBank,
MapViewMODLimbo,
MapAltStorage,
MapArchived,
MapMail,
MapGuildTrophyTribute,
MapOther,
_MapCount
};
}
namespace slots {
typedef enum : int16 {
MainCharm = 0,
MainEar1,
MainHead,
MainFace,
MainEar2,
MainNeck,
MainShoulders,
MainArms,
MainBack,
MainWrist1,
MainWrist2,
MainRange,
MainHands,
MainPrimary,
MainSecondary,
MainFinger1,
MainFinger2,
MainChest,
MainLegs,
MainFeet,
MainWaist,
MainAmmo,
MainGeneral1,
MainGeneral2,
MainGeneral3,
MainGeneral4,
MainGeneral5,
MainGeneral6,
MainGeneral7,
MainGeneral8,
MainCursor,
_MainCount,
_MainEquipmentBegin = MainCharm,
_MainEquipmentEnd = MainAmmo,
_MainEquipmentCount = (_MainEquipmentEnd - _MainEquipmentBegin + 1),
_MainGeneralBegin = MainGeneral1,
_MainGeneralEnd = MainGeneral8,
_MainGeneralCount = (_MainGeneralEnd - _MainGeneralBegin + 1)
};
}
namespace consts {
static const uint16 MAP_POSSESSIONS_SIZE = slots::_MainCount;
static const uint16 MAP_BANK_SIZE = 16;
static const uint16 MAP_SHARED_BANK_SIZE = 2;
static const uint16 MAP_TRADE_SIZE = 8;
static const uint16 MAP_WORLD_SIZE = 10;
static const uint16 MAP_LIMBO_SIZE = 36;
static const uint16 MAP_TRIBUTE_SIZE = 0; //?
static const uint16 MAP_TROPHY_TRIBUTE_SIZE = 0;
static const uint16 MAP_GUILD_TRIBUTE_SIZE = 0;
static const uint16 MAP_MERCHANT_SIZE = 0;
static const uint16 MAP_DELETED_SIZE = 0;
static const uint16 MAP_CORPSE_SIZE = slots::_MainCount;
static const uint16 MAP_BAZAAR_SIZE = 80;
static const uint16 MAP_INSPECT_SIZE = slots::_MainEquipmentCount;
static const uint16 MAP_REAL_ESTATE_SIZE = 0;
static const uint16 MAP_VIEW_MOD_PC_SIZE = MAP_POSSESSIONS_SIZE;
static const uint16 MAP_VIEW_MOD_BANK_SIZE = MAP_BANK_SIZE;
static const uint16 MAP_VIEW_MOD_SHARED_BANK_SIZE = MAP_SHARED_BANK_SIZE;
static const uint16 MAP_VIEW_MOD_LIMBO_SIZE = MAP_LIMBO_SIZE;
static const uint16 MAP_ALT_STORAGE_SIZE = 0;
static const uint16 MAP_ARCHIVED_SIZE = 0;
static const uint16 MAP_MAIL_SIZE = 0;
static const uint16 MAP_GUILD_TROPHY_TRIBUTE_SIZE = 0;
static const uint16 MAP_KRONO_SIZE = NOT_USED;
static const uint16 MAP_OTHER_SIZE = 0;
static const int16 POSSESSIONS_BEGIN = slots::MainCharm;
static const int16 POSSESSIONS_END = slots::MainCursor;
static const int16 EQUIPMENT_BEGIN = slots::MainCharm;
static const int16 EQUIPMENT_END = slots::MainAmmo;
static const uint16 EQUIPMENT_SIZE = slots::_MainEquipmentCount;
static const int16 GENERAL_BEGIN = slots::MainGeneral1;
static const int16 GENERAL_END = slots::MainGeneral8;
static const uint16 GENERAL_SIZE = slots::_MainGeneralCount;
static const int16 GENERAL_BAGS_BEGIN = 251;
static const int16 GENERAL_BAGS_END_OFFSET = 79;
static const int16 GENERAL_BAGS_END = GENERAL_BAGS_BEGIN + GENERAL_BAGS_END_OFFSET;
static const int16 CURSOR = slots::MainCursor;
static const int16 CURSOR_BAG_BEGIN = 331;
static const int16 CURSOR_BAG_END_OFFSET = 9;
static const int16 CURSOR_BAG_END = CURSOR_BAG_BEGIN + CURSOR_BAG_END_OFFSET;
static const int16 BANK_BEGIN = 2000;
static const int16 BANK_END = 2015;
static const int16 BANK_BAGS_BEGIN = 2031;
static const int16 BANK_BAGS_END_OFFSET = 159;
static const int16 BANK_BAGS_END = BANK_BAGS_BEGIN + BANK_BAGS_END_OFFSET;
static const int16 SHARED_BANK_BEGIN = 2500;
static const int16 SHARED_BANK_END = 2501;
static const int16 SHARED_BANK_BAGS_BEGIN = 2531;
static const int16 SHARED_BANK_BAGS_END_OFFSET = 19;
static const int16 SHARED_BANK_BAGS_END = SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_END_OFFSET;
static const int16 TRADE_BEGIN = 3000;
static const int16 TRADE_END = 3007;
static const int16 TRADE_END_NPC = 3003;
static const int16 TRADE_BAGS_BEGIN = 3031;
static const int16 TRADE_BAGS_END_OFFSET = 79;
static const int16 TRADE_BAGS_END = TRADE_BAGS_BEGIN + TRADE_BAGS_END_OFFSET;
static const int16 WORLD_BEGIN = 4000;
static const int16 WORLD_END = 4009;
static const int16 TRIBUTE_BEGIN = 400;
static const int16 TRIBUTE_END = 404;
static const int16 CORPSE_BEGIN = slots::MainGeneral1;
static const int16 CORPSE_END = slots::MainGeneral1 + slots::MainCursor;
static const uint16 ITEM_COMMON_SIZE = 5;
static const uint16 ITEM_CONTAINER_SIZE = 10;
static const uint32 BANDOLIERS_COUNT = 4; // count = number of bandolier instances
static const uint32 BANDOLIER_SIZE = 4; // size = number of equipment slots in bandolier instance
static const uint32 POTION_BELT_SIZE = 4;
}
namespace limits {
static const bool ALLOWS_EMPTY_BAG_IN_BAG = false;
static const bool COIN_HAS_WEIGHT = true;
}
}; //end namespace Client62
#endif /*CLIENT62_CONSTANTS_H_*/
/*
Client62 Notes:
** Integer-based inventory **
ok Possessions: 0 - 30 (Corpse: 22 - 52 [Offset 22])
ok [Equipment: 0 - 21]
ok [General: 22 - 29]
ok [Cursor: 30]
ok General Bags: 251 - 330
ok Cursor Bags: 331 - 340
ok Bank: 2000 - 2015
ok Bank Bags: 2031 - 2190
ok Shared Bank: 2500 - 2501
ok Shared Bank Bags: 2531 - 2550
Trade: 3000 - 3007
(Trade Bags: 3031 - 3110 -- server values)
World: 4000 - 4009
*/

16
common/patches/RoF.cpp
View File

@ -1200,11 +1200,11 @@ ENCODE(OP_PlayerProfile)
outapp->WriteUInt32(structs::MAX_PLAYER_BANDOLIER); outapp->WriteUInt32(structs::MAX_PLAYER_BANDOLIER);
for(uint32 r = 0; r < MAX_PLAYER_BANDOLIER; r++) for(uint32 r = 0; r < EmuConstants::BANDOLIERS_COUNT; r++)
{ {
outapp->WriteString(emu->bandoliers[r].name); outapp->WriteString(emu->bandoliers[r].name);
for(uint32 j = 0; j < MAX_PLAYER_BANDOLIER_ITEMS; ++j) for(uint32 j = 0; j < EmuConstants::BANDOLIER_SIZE; ++j)
{ {
outapp->WriteString(emu->bandoliers[r].items[j].item_name); outapp->WriteString(emu->bandoliers[r].items[j].item_name);
outapp->WriteUInt32(emu->bandoliers[r].items[j].item_id); outapp->WriteUInt32(emu->bandoliers[r].items[j].item_id);
@ -1212,11 +1212,11 @@ ENCODE(OP_PlayerProfile)
} }
} }
for(uint32 r = 0; r < structs::MAX_PLAYER_BANDOLIER - MAX_PLAYER_BANDOLIER; r++) for(uint32 r = 0; r < structs::MAX_PLAYER_BANDOLIER - EmuConstants::BANDOLIERS_COUNT; r++)
{ {
outapp->WriteString(""); outapp->WriteString("");
for(uint32 j = 0; j < MAX_PLAYER_BANDOLIER_ITEMS; ++j) for(uint32 j = 0; j < EmuConstants::BANDOLIER_SIZE; ++j)
{ {
outapp->WriteString(""); outapp->WriteString("");
outapp->WriteUInt32(0); outapp->WriteUInt32(0);
@ -1227,7 +1227,7 @@ ENCODE(OP_PlayerProfile)
outapp->WriteUInt32(structs::MAX_POTIONS_IN_BELT); outapp->WriteUInt32(structs::MAX_POTIONS_IN_BELT);
for(uint32 r = 0; r < MAX_POTIONS_IN_BELT; r++) for(uint32 r = 0; r < EmuConstants::POTION_BELT_SIZE; r++)
{ {
outapp->WriteString(emu->potionbelt.items[r].item_name); outapp->WriteString(emu->potionbelt.items[r].item_name);
outapp->WriteUInt32(emu->potionbelt.items[r].item_id); outapp->WriteUInt32(emu->potionbelt.items[r].item_id);
@ -1235,7 +1235,7 @@ ENCODE(OP_PlayerProfile)
} }
for(uint32 r = 0; r < structs::MAX_POTIONS_IN_BELT - MAX_POTIONS_IN_BELT; r++) for(uint32 r = 0; r < structs::MAX_POTIONS_IN_BELT - EmuConstants::POTION_BELT_SIZE; r++)
{ {
outapp->WriteString(""); outapp->WriteString("");
outapp->WriteUInt32(0); outapp->WriteUInt32(0);
@ -1357,9 +1357,9 @@ ENCODE(OP_PlayerProfile)
outapp->WriteUInt8(0); // Unknown outapp->WriteUInt8(0); // Unknown
outapp->WriteUInt8(0); // Unknown outapp->WriteUInt8(0); // Unknown
outapp->WriteUInt32(MAX_PLAYER_TRIBUTES); outapp->WriteUInt32(EmuConstants::TRIBUTE_SIZE);
for(uint32 r = 0; r < MAX_PLAYER_TRIBUTES; r++) for(uint32 r = 0; r < EmuConstants::TRIBUTE_SIZE; r++)
{ {
outapp->WriteUInt32(emu->tributes[r].tribute); outapp->WriteUInt32(emu->tributes[r].tribute);
outapp->WriteUInt32(emu->tributes[r].tier); outapp->WriteUInt32(emu->tributes[r].tier);

218
common/patches/RoF_constants.h Normal file
View File

@ -0,0 +1,218 @@
/*
EQEMu: Everquest Server Emulator
Copyright (C) 2001-2014 EQEMu Development Team (http://eqemulator.net)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef RoF_CONSTANTS_H_
#define RoF_CONSTANTS_H_
#include "../common/types.h"
namespace RoF {
namespace maps {
typedef enum : int16 {
MapPossessions = 0,
MapBank,
MapSharedBank,
MapTrade,
MapWorld,
MapLimbo,
MapTribute,
MapTrophyTribute,
MapGuildTribute,
MapMerchant,
MapDeleted,
MapCorpse,
MapBazaar,
MapInspect,
MapRealEstate,
MapViewMODPC,
MapViewMODBank,
MapViewMODSharedBank,
MapViewMODLimbo,
MapAltStorage,
MapArchived,
MapMail,
MapGuildTrophyTribute,
MapOther,
_MapCount
};
}
namespace slots {
typedef enum : int16 {
MainCharm = 0,
MainEar1,
MainHead,
MainFace,
MainEar2,
MainNeck,
MainShoulders,
MainArms,
MainBack,
MainWrist1,
MainWrist2,
MainRange,
MainHands,
MainPrimary,
MainSecondary,
MainFinger1,
MainFinger2,
MainChest,
MainLegs,
MainFeet,
MainWaist,
MainPowerSource,
MainAmmo,
MainGeneral1,
MainGeneral2,
MainGeneral3,
MainGeneral4,
MainGeneral5,
MainGeneral6,
MainGeneral7,
MainGeneral8,
MainGeneral9,
MainGeneral10,
MainCursor,
_MainCount,
_MainEquipmentBegin = MainCharm,
_MainEquipmentEnd = MainAmmo,
_MainEquipmentCount = (_MainEquipmentEnd - _MainEquipmentBegin + 1),
_MainGeneralBegin = MainGeneral1,
_MainGeneralEnd = MainGeneral10,
_MainGeneralCount = (_MainGeneralEnd - _MainGeneralBegin + 1)
};
}
namespace consts {
static const uint16 MAP_POSSESSIONS_SIZE = slots::_MainCount;
static const uint16 MAP_BANK_SIZE = 24;
static const uint16 MAP_SHARED_BANK_SIZE = 2;
static const uint16 MAP_TRADE_SIZE = 8;
static const uint16 MAP_WORLD_SIZE = 10;
static const uint16 MAP_LIMBO_SIZE = 36;
static const uint16 MAP_TRIBUTE_SIZE = 0; //?
static const uint16 MAP_TROPHY_TRIBUTE_SIZE = 0;
static const uint16 MAP_GUILD_TRIBUTE_SIZE = 0;
static const uint16 MAP_MERCHANT_SIZE = 0;
static const uint16 MAP_DELETED_SIZE = 0;
static const uint16 MAP_CORPSE_SIZE = slots::_MainCount;
static const uint16 MAP_BAZAAR_SIZE = 200;
static const uint16 MAP_INSPECT_SIZE = slots::_MainEquipmentCount;
static const uint16 MAP_REAL_ESTATE_SIZE = 0;
static const uint16 MAP_VIEW_MOD_PC_SIZE = MAP_POSSESSIONS_SIZE;
static const uint16 MAP_VIEW_MOD_BANK_SIZE = MAP_BANK_SIZE;
static const uint16 MAP_VIEW_MOD_SHARED_BANK_SIZE = MAP_SHARED_BANK_SIZE;
static const uint16 MAP_VIEW_MOD_LIMBO_SIZE = MAP_LIMBO_SIZE;
static const uint16 MAP_ALT_STORAGE_SIZE = 0;
static const uint16 MAP_ARCHIVED_SIZE = 0;
static const uint16 MAP_MAIL_SIZE = 0;
static const uint16 MAP_GUILD_TROPHY_TRIBUTE_SIZE = 0;
static const uint16 MAP_KRONO_SIZE = NOT_USED;
static const uint16 MAP_OTHER_SIZE = 0;
// most of these definitions will go away with the structure-based system..this maintains compatibility for now
// (bag slots and main slots beyond Possessions are assigned for compatibility with current server coding)
static const int16 POSSESSIONS_BEGIN = slots::MainCharm;
static const int16 POSSESSIONS_END = slots::MainCursor;
static const int16 EQUIPMENT_BEGIN = slots::MainCharm;
static const int16 EQUIPMENT_END = slots::MainAmmo;
static const uint16 EQUIPMENT_SIZE = slots::_MainEquipmentCount;
static const int16 GENERAL_BEGIN = slots::MainGeneral1;
static const int16 GENERAL_END = slots::MainGeneral10;
static const uint16 GENERAL_SIZE = slots::_MainGeneralCount;
static const int16 GENERAL_BAGS_BEGIN = 251;
static const int16 GENERAL_BAGS_END_OFFSET = 99;
static const int16 GENERAL_BAGS_END = GENERAL_BAGS_BEGIN + GENERAL_BAGS_END_OFFSET;
static const int16 CURSOR = slots::MainCursor;
static const int16 CURSOR_BAG_BEGIN = 351;
static const int16 CURSOR_BAG_END_OFFSET = 9;
static const int16 CURSOR_BAG_END = CURSOR_BAG_BEGIN + CURSOR_BAG_END_OFFSET;
static const int16 BANK_BEGIN = 2000;
static const int16 BANK_END = 2023;
static const int16 BANK_BAGS_BEGIN = 2031;
static const int16 BANK_BAGS_END_OFFSET = 239;
static const int16 BANK_BAGS_END = BANK_BAGS_BEGIN + BANK_BAGS_END_OFFSET;
static const int16 SHARED_BANK_BEGIN = 2500;
static const int16 SHARED_BANK_END = 2501;
static const int16 SHARED_BANK_BAGS_BEGIN = 2531;
static const int16 SHARED_BANK_BAGS_END_OFFSET = 19;
static const int16 SHARED_BANK_BAGS_END = SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_END_OFFSET;
static const int16 TRADE_BEGIN = 3000;
static const int16 TRADE_END = 3007;
static const int16 TRADE_END_NPC = 3003;
static const int16 TRADE_BAGS_BEGIN = 3031;
static const int16 TRADE_BAGS_END_OFFSET = 79;
static const int16 TRADE_BAGS_END = TRADE_BAGS_BEGIN + TRADE_BAGS_END_OFFSET;
static const int16 WORLD_BEGIN = 4000;
static const int16 WORLD_END = 4009;
static const int16 TRIBUTE_BEGIN = 400;
static const int16 TRIBUTE_END = 404;
static const int16 CORPSE_BEGIN = slots::MainGeneral1;
static const int16 CORPSE_END = slots::MainGeneral1 + slots::MainCursor;
static const uint16 ITEM_COMMON_SIZE = 6;
static const uint16 ITEM_CONTAINER_SIZE = 255; // 255; (server max will be 255..unsure what actual client is - test)
static const uint32 BANDOLIERS_COUNT = 20; // count = number of bandolier instances
static const uint32 BANDOLIER_SIZE = 4; // size = number of equipment slots in bandolier instance
static const uint32 POTION_BELT_SIZE = 5;
}
namespace limits {
static const bool ALLOWS_EMPTY_BAG_IN_BAG = true;
static const bool COIN_HAS_WEIGHT = false;
}
}; //end namespace RoF
#endif /*RoF_CONSTANTS_H_*/
/*
RoF Notes:
** Structure-based inventory **
ok Possessions: ( 0, { 0 .. 33 }, -1, -1 ) (Corpse: { 23 .. 56 } [Offset 23])
ok [Equipment: ( 0, { 0 .. 22 }, -1, -1 )]
ok [General: ( 0, { 23 .. 32 }, -1, -1 )]
ok [Cursor: ( 0, 33, -1, -1 )]
General Bags: ( 0, { 23 .. 32 }, { 0 .. (maxsize - 1) }, -1 )
Cursor Bags: ( 0, 33, { 0 .. (maxsize - 1) }, -1 )
Bank: ( 1, { 0 .. 23 }, -1, -1 )
Bank Bags: ( 1, { 0 .. 23 }, { 0 .. (maxsize - 1)}, -1 )
Shared Bank: ( 2, { 0 .. 1 }, -1, -1 )
Shared Bank Bags: ( 2, { 0 .. 1 }, { 0 .. (maxsize - 1) }, -1 )
Trade: ( 3, { 0 .. 8 }, -1, -1 )
(Trade Bags: 3031 - 3110 -- server values)
World: ( 4, { 0 .. 10 }, -1, -1 )
*/

215
common/patches/SoD_constants.h Normal file
View File

@ -0,0 +1,215 @@
/*
EQEMu: Everquest Server Emulator
Copyright (C) 2001-2014 EQEMu Development Team (http://eqemulator.net)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef SoD_CONSTANTS_H_
#define SoD_CONSTANTS_H_
#include "../common/types.h"
namespace SoD {
namespace maps {
typedef enum : int16 {
// this needs work to match actual client equivilents
MapPossessions = 0,
MapBank,
MapSharedBank,
MapTrade,
MapWorld,
MapLimbo,
MapTribute,
MapTrophyTribute,
MapGuildTribute,
MapMerchant,
MapDeleted,
MapCorpse,
MapBazaar,
MapInspect,
MapRealEstate,
MapViewMODPC,
MapViewMODBank,
MapViewMODSharedBank,
MapViewMODLimbo,
MapAltStorage,
MapArchived,
MapMail,
MapGuildTrophyTribute,
MapOther,
_MapCount
};
}
namespace slots {
typedef enum : int16 {
MainCharm = 0,
MainEar1,
MainHead,
MainFace,
MainEar2,
MainNeck,
MainShoulders,
MainArms,
MainBack,
MainWrist1,
MainWrist2,
MainRange,
MainHands,
MainPrimary,
MainSecondary,
MainFinger1,
MainFinger2,
MainChest,
MainLegs,
MainFeet,
MainWaist,
MainPowerSource,
MainAmmo,
MainGeneral1,
MainGeneral2,
MainGeneral3,
MainGeneral4,
MainGeneral5,
MainGeneral6,
MainGeneral7,
MainGeneral8,
MainCursor,
_MainCount,
_MainEquipmentBegin = MainCharm,
_MainEquipmentEnd = MainAmmo,
_MainEquipmentCount = (_MainEquipmentEnd - _MainEquipmentBegin + 1),
_MainGeneralBegin = MainGeneral1,
_MainGeneralEnd = MainGeneral8,
_MainGeneralCount = (_MainGeneralEnd - _MainGeneralBegin + 1)
};
}
namespace consts {
static const uint16 MAP_POSSESSIONS_SIZE = slots::_MainCount;
static const uint16 MAP_BANK_SIZE = 24;
static const uint16 MAP_SHARED_BANK_SIZE = 2;
static const uint16 MAP_TRADE_SIZE = 8;
static const uint16 MAP_WORLD_SIZE = 10;
static const uint16 MAP_LIMBO_SIZE = 36;
static const uint16 MAP_TRIBUTE_SIZE = 0; //?
static const uint16 MAP_TROPHY_TRIBUTE_SIZE = 0;
static const uint16 MAP_GUILD_TRIBUTE_SIZE = 0;
static const uint16 MAP_MERCHANT_SIZE = 0;
static const uint16 MAP_DELETED_SIZE = 0;
static const uint16 MAP_CORPSE_SIZE = slots::_MainCount;
static const uint16 MAP_BAZAAR_SIZE = 80;
static const uint16 MAP_INSPECT_SIZE = slots::_MainEquipmentCount;
static const uint16 MAP_REAL_ESTATE_SIZE = 0;
static const uint16 MAP_VIEW_MOD_PC_SIZE = MAP_POSSESSIONS_SIZE;
static const uint16 MAP_VIEW_MOD_BANK_SIZE = MAP_BANK_SIZE;
static const uint16 MAP_VIEW_MOD_SHARED_BANK_SIZE = MAP_SHARED_BANK_SIZE;
static const uint16 MAP_VIEW_MOD_LIMBO_SIZE = MAP_LIMBO_SIZE;
static const uint16 MAP_ALT_STORAGE_SIZE = 0;
static const uint16 MAP_ARCHIVED_SIZE = 0;
static const uint16 MAP_MAIL_SIZE = 0;
static const uint16 MAP_GUILD_TROPHY_TRIBUTE_SIZE = 0;
static const uint16 MAP_KRONO_SIZE = NOT_USED;
static const uint16 MAP_OTHER_SIZE = 0;
static const int16 POSSESSIONS_BEGIN = slots::MainCharm;
static const int16 POSSESSIONS_END = slots::MainCursor;
static const int16 EQUIPMENT_BEGIN = slots::MainCharm;
static const int16 EQUIPMENT_END = slots::MainAmmo;
static const uint16 EQUIPMENT_SIZE = slots::_MainEquipmentCount;
static const int16 GENERAL_BEGIN = slots::MainGeneral1;
static const int16 GENERAL_END = slots::MainGeneral8;
static const uint16 GENERAL_SIZE = slots::_MainGeneralCount;
static const int16 GENERAL_BAGS_BEGIN = 262;
static const int16 GENERAL_BAGS_END_OFFSET = 79;
static const int16 GENERAL_BAGS_END = GENERAL_BAGS_BEGIN + GENERAL_BAGS_END_OFFSET;
static const int16 CURSOR = slots::MainCursor;
static const int16 CURSOR_BAG_BEGIN = 342;
static const int16 CURSOR_BAG_END_OFFSET = 9;
static const int16 CURSOR_BAG_END = CURSOR_BAG_BEGIN + CURSOR_BAG_END_OFFSET;
static const int16 BANK_BEGIN = 2000;
static const int16 BANK_END = 2023;
static const int16 BANK_BAGS_BEGIN = 2032;
static const int16 BANK_BAGS_END_OFFSET = 239;
static const int16 BANK_BAGS_END = BANK_BAGS_BEGIN + BANK_BAGS_END_OFFSET;
static const int16 SHARED_BANK_BEGIN = 2500;
static const int16 SHARED_BANK_END = 2501;
static const int16 SHARED_BANK_BAGS_BEGIN = 2532;
static const int16 SHARED_BANK_BAGS_END_OFFSET = 19;
static const int16 SHARED_BANK_BAGS_END = SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_END_OFFSET;
static const int16 TRADE_BEGIN = 3000;
static const int16 TRADE_END = 3007;
static const int16 TRADE_END_NPC = 3003;
static const int16 TRADE_BAGS_BEGIN = 3031; // no change from Ti?
static const int16 TRADE_BAGS_END_OFFSET = 79;
static const int16 TRADE_BAGS_END = TRADE_BAGS_BEGIN + TRADE_BAGS_END_OFFSET;
static const int16 WORLD_BEGIN = 4000;
static const int16 WORLD_END = 4009;
static const int16 TRIBUTE_BEGIN = 400;
static const int16 TRIBUTE_END = 404;
static const int16 CORPSE_BEGIN = slots::MainGeneral1;
static const int16 CORPSE_END = slots::MainGeneral1 + slots::MainCursor;
static const uint16 ITEM_COMMON_SIZE = 5;
static const uint16 ITEM_CONTAINER_SIZE = 10;
static const uint32 BANDOLIERS_COUNT = 20; // count = number of bandolier instances
static const uint32 BANDOLIER_SIZE = 4; // size = number of equipment slots in bandolier instance
static const uint32 POTION_BELT_SIZE = 5;
}
namespace limits {
static const bool ALLOWS_EMPTY_BAG_IN_BAG = false;
static const bool COIN_HAS_WEIGHT = false;
}
}; //end namespace SoD
#endif /*SoD_CONSTANTS_H_*/
/*
SoD Notes:
** Integer-based inventory **
ok Possessions: 0 - 31 (Corpse: 23 - 54 [Offset 23])
ok [Equipment: 0 - 22]
ok [General: 23 - 30]
ok [Cursor: 31]
ok General Bags: 262 - 341
ok Cursor Bags: 342 - 351
ok Bank: 2000 - 2023
ok Bank Bags: 2032 - 2271
ok Shared Bank: 2500 - 2501
ok Shared Bank Bags: 2532 - 2551
Trade: 3000 - 3007
(Trade Bags: 3031 - 3110 -- server values)
World: 4000 - 4009
*/

218
common/patches/SoF_constants.h Normal file
View File

@ -0,0 +1,218 @@
/*
EQEMu: Everquest Server Emulator
Copyright (C) 2001-2014 EQEMu Development Team (http://eqemulator.net)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef SoF_CONSTANTS_H_
#define SoF_CONSTANTS_H_
#include "../common/types.h"
namespace SoF {
namespace maps {
typedef enum : int16 {
// this needs work to match actual client equivilents
MapPossessions = 0,
MapBank,
MapSharedBank,
MapTrade,
MapWorld,
MapLimbo,
MapTribute,
MapTrophyTribute,
MapGuildTribute,
MapMerchant,
MapDeleted,
MapCorpse,
MapBazaar,
MapInspect,
MapRealEstate,
MapViewMODPC,
MapViewMODBank,
MapViewMODSharedBank,
MapViewMODLimbo,
MapAltStorage,
MapArchived,
MapMail,
MapGuildTrophyTribute,
MapOther,
_MapCount
};
}
namespace slots {
typedef enum : int16 {
MainCharm = 0,
MainEar1,
MainHead,
MainFace,
MainEar2,
MainNeck,
MainShoulders,
MainArms,
MainBack,
MainWrist1,
MainWrist2,
MainRange,
MainHands,
MainPrimary,
MainSecondary,
MainFinger1,
MainFinger2,
MainChest,
MainLegs,
MainFeet,
MainWaist,
MainPowerSource,
MainAmmo,
MainGeneral1,
MainGeneral2,
MainGeneral3,
MainGeneral4,
MainGeneral5,
MainGeneral6,
MainGeneral7,
MainGeneral8,
MainCursor,
_MainCount,
_MainEquipmentBegin = MainCharm,
_MainEquipmentEnd = MainAmmo,
_MainEquipmentCount = (_MainEquipmentEnd - _MainEquipmentBegin + 1),
_MainGeneralBegin = MainGeneral1,
_MainGeneralEnd = MainGeneral8,
_MainGeneralCount = (_MainGeneralEnd - _MainGeneralBegin + 1)
};
}
namespace consts {
static const uint16 MAP_POSSESSIONS_SIZE = slots::_MainCount;
static const uint16 MAP_BANK_SIZE = 24;
static const uint16 MAP_SHARED_BANK_SIZE = 2;
static const uint16 MAP_TRADE_SIZE = 8;
static const uint16 MAP_WORLD_SIZE = 10;
static const uint16 MAP_LIMBO_SIZE = 36;
static const uint16 MAP_TRIBUTE_SIZE = 0; //?
static const uint16 MAP_TROPHY_TRIBUTE_SIZE = 0;
static const uint16 MAP_GUILD_TRIBUTE_SIZE = 0;
static const uint16 MAP_MERCHANT_SIZE = 0;
static const uint16 MAP_DELETED_SIZE = 0;
static const uint16 MAP_CORPSE_SIZE = slots::_MainCount;
static const uint16 MAP_BAZAAR_SIZE = 80;
static const uint16 MAP_INSPECT_SIZE = slots::_MainEquipmentCount;
static const uint16 MAP_REAL_ESTATE_SIZE = 0;
static const uint16 MAP_VIEW_MOD_PC_SIZE = MAP_POSSESSIONS_SIZE;
static const uint16 MAP_VIEW_MOD_BANK_SIZE = MAP_BANK_SIZE;
static const uint16 MAP_VIEW_MOD_SHARED_BANK_SIZE = MAP_SHARED_BANK_SIZE;
static const uint16 MAP_VIEW_MOD_LIMBO_SIZE = MAP_LIMBO_SIZE;
static const uint16 MAP_ALT_STORAGE_SIZE = 0;
static const uint16 MAP_ARCHIVED_SIZE = 0;
static const uint16 MAP_MAIL_SIZE = 0;
static const uint16 MAP_GUILD_TROPHY_TRIBUTE_SIZE = 0;
static const uint16 MAP_KRONO_SIZE = NOT_USED;
static const uint16 MAP_OTHER_SIZE = 0;
static const int16 POSSESSIONS_BEGIN = slots::MainCharm;
static const int16 POSSESSIONS_END = slots::MainCursor;
static const int16 EQUIPMENT_BEGIN = slots::MainCharm;
static const int16 EQUIPMENT_END = slots::MainAmmo;
static const uint16 EQUIPMENT_SIZE = slots::_MainEquipmentCount;
static const int16 GENERAL_BEGIN = slots::MainGeneral1;
static const int16 GENERAL_END = slots::MainGeneral8;
static const uint16 GENERAL_SIZE = slots::_MainGeneralCount;
static const int16 GENERAL_BAGS_BEGIN = 262;
static const int16 GENERAL_BAGS_END_OFFSET = 79;
static const int16 GENERAL_BAGS_END = GENERAL_BAGS_BEGIN + GENERAL_BAGS_END_OFFSET;
static const int16 CURSOR = slots::MainCursor;
static const int16 CURSOR_BAG_BEGIN = 342;
static const int16 CURSOR_BAG_END_OFFSET = 9;
static const int16 CURSOR_BAG_END = CURSOR_BAG_BEGIN + CURSOR_BAG_END_OFFSET;
static const int16 BANK_BEGIN = 2000;
static const int16 BANK_END = 2023;
static const int16 BANK_BAGS_BEGIN = 2032;
static const int16 BANK_BAGS_END_OFFSET = 239;
static const int16 BANK_BAGS_END = BANK_BAGS_BEGIN + BANK_BAGS_END_OFFSET;
static const int16 SHARED_BANK_BEGIN = 2500;
static const int16 SHARED_BANK_END = 2501;
static const int16 SHARED_BANK_BAGS_BEGIN = 2532;
static const int16 SHARED_BANK_BAGS_END_OFFSET = 19;
static const int16 SHARED_BANK_BAGS_END = SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_END_OFFSET;
static const int16 TRADE_BEGIN = 3000;
static const int16 TRADE_END = 3007;
static const int16 TRADE_END_NPC = 3003;
static const int16 TRADE_BAGS_BEGIN = 3031; // no change from Ti?
static const int16 TRADE_BAGS_END_OFFSET = 79;
static const int16 TRADE_BAGS_END = TRADE_BAGS_BEGIN + TRADE_BAGS_END_OFFSET;
static const int16 WORLD_BEGIN = 4000;
static const int16 WORLD_END = 4009;
static const int16 TRIBUTE_BEGIN = 400;
static const int16 TRIBUTE_END = 404;
static const int16 CORPSE_BEGIN = slots::MainGeneral1;
static const int16 CORPSE_END = slots::MainGeneral1 + slots::MainCursor;
static const uint16 ITEM_COMMON_SIZE = 5;
static const uint16 ITEM_CONTAINER_SIZE = 10;
static const uint32 BANDOLIERS_COUNT = 20; // count = number of bandolier instances
static const uint32 BANDOLIER_SIZE = 4; // size = number of equipment slots in bandolier instance
static const uint32 POTION_BELT_SIZE = 5;
}
namespace limits {
static const bool ALLOWS_EMPTY_BAG_IN_BAG = false;
static const bool COIN_HAS_WEIGHT = true;
}
}; //end namespace SoF
#endif /*SoF_CONSTANTS_H_*/
/*
SoF Notes:
** Integer-based inventory **
ok Possessions: 0 - 31 (Corpse: 23 - 54 [Offset 23])
ok [Equipment: 0 - 22]
ok [General: 23 - 30]
ok [Cursor: 31]
ok General Bags: 262 - 341
ok Cursor Bags: 342 - 351
ok Bank: 2000 - 2023
ok Bank Bags: 2032 - 2271
ok Shared Bank: 2500 - 2501
ok Shared Bank Bags: 2532 - 2551
Trade: 3000 - 3007
(Trade Bags: 3031 - 3110 -- server values)
World: 4000 - 4009
code file reviewed..
..SerializeItem() needs work
..still needs timestamp redirect code
*/

214
common/patches/Titanium_constants.h Normal file
View File

@ -0,0 +1,214 @@
/*
EQEMu: Everquest Server Emulator
Copyright (C) 2001-2014 EQEMu Development Team (http://eqemulator.net)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef Titanium_CONSTANTS_H_
#define Titanium_CONSTANTS_H_
#include "../common/types.h"
namespace Titanium {
namespace maps {
typedef enum : int16 {
// this needs work to match actual client equivilents
MapPossessions = 0,
MapBank,
MapSharedBank,
MapTrade,
MapWorld,
MapLimbo,
MapTribute,
MapTrophyTribute,
MapGuildTribute,
MapMerchant,
MapDeleted,
MapCorpse,
MapBazaar,
MapInspect,
MapRealEstate,
MapViewMODPC,
MapViewMODBank,
MapViewMODSharedBank,
MapViewMODLimbo,
MapAltStorage,
MapArchived,
MapMail,
MapGuildTrophyTribute,
MapOther,
_MapCount
};
}
namespace slots {
typedef enum : int16 {
MainCharm = 0,
MainEar1,
MainHead,
MainFace,
MainEar2,
MainNeck,
MainShoulders,
MainArms,
MainBack,
MainWrist1,
MainWrist2,
MainRange,
MainHands,
MainPrimary,
MainSecondary,
MainFinger1,
MainFinger2,
MainChest,
MainLegs,
MainFeet,
MainWaist,
MainAmmo,
MainGeneral1,
MainGeneral2,
MainGeneral3,
MainGeneral4,
MainGeneral5,
MainGeneral6,
MainGeneral7,
MainGeneral8,
MainCursor,
_MainCount,
_MainEquipmentBegin = MainCharm,
_MainEquipmentEnd = MainAmmo,
_MainEquipmentCount = (_MainEquipmentEnd - _MainEquipmentBegin + 1),
_MainGeneralBegin = MainGeneral1,
_MainGeneralEnd = MainGeneral8,
_MainGeneralCount = (_MainGeneralEnd - _MainGeneralBegin + 1)
};
}
namespace consts {
static const uint16 MAP_POSSESSIONS_SIZE = slots::_MainCount;
static const uint16 MAP_BANK_SIZE = 16;
static const uint16 MAP_SHARED_BANK_SIZE = 2;
static const uint16 MAP_TRADE_SIZE = 8;
static const uint16 MAP_WORLD_SIZE = 10;
static const uint16 MAP_LIMBO_SIZE = 36;
static const uint16 MAP_TRIBUTE_SIZE = 0; //?
static const uint16 MAP_TROPHY_TRIBUTE_SIZE = 0;
static const uint16 MAP_GUILD_TRIBUTE_SIZE = 0;
static const uint16 MAP_MERCHANT_SIZE = 0;
static const uint16 MAP_DELETED_SIZE = 0;
static const uint16 MAP_CORPSE_SIZE = slots::_MainCount;
static const uint16 MAP_BAZAAR_SIZE = 80;
static const uint16 MAP_INSPECT_SIZE = slots::_MainEquipmentCount;
static const uint16 MAP_REAL_ESTATE_SIZE = 0;
static const uint16 MAP_VIEW_MOD_PC_SIZE = MAP_POSSESSIONS_SIZE;
static const uint16 MAP_VIEW_MOD_BANK_SIZE = MAP_BANK_SIZE;
static const uint16 MAP_VIEW_MOD_SHARED_BANK_SIZE = MAP_SHARED_BANK_SIZE;
static const uint16 MAP_VIEW_MOD_LIMBO_SIZE = MAP_LIMBO_SIZE;
static const uint16 MAP_ALT_STORAGE_SIZE = 0;
static const uint16 MAP_ARCHIVED_SIZE = 0;
static const uint16 MAP_MAIL_SIZE = 0;
static const uint16 MAP_GUILD_TROPHY_TRIBUTE_SIZE = 0;
static const uint16 MAP_KRONO_SIZE = NOT_USED;
static const uint16 MAP_OTHER_SIZE = 0;
static const int16 POSSESSIONS_BEGIN = slots::MainCharm;
static const int16 POSSESSIONS_END = slots::MainCursor;
static const int16 EQUIPMENT_BEGIN = slots::MainCharm;
static const int16 EQUIPMENT_END = slots::MainAmmo;
static const uint16 EQUIPMENT_SIZE = slots::_MainEquipmentCount;
static const int16 GENERAL_BEGIN = slots::MainGeneral1;
static const int16 GENERAL_END = slots::MainGeneral8;
static const uint16 GENERAL_SIZE = slots::_MainGeneralCount;
static const int16 GENERAL_BAGS_BEGIN = 251;
static const int16 GENERAL_BAGS_END_OFFSET = 79;
static const int16 GENERAL_BAGS_END = GENERAL_BAGS_BEGIN + GENERAL_BAGS_END_OFFSET;
static const int16 CURSOR = slots::MainCursor;
static const int16 CURSOR_BAG_BEGIN = 331;
static const int16 CURSOR_BAG_END_OFFSET = 9;
static const int16 CURSOR_BAG_END = CURSOR_BAG_BEGIN + CURSOR_BAG_END_OFFSET;
static const int16 BANK_BEGIN = 2000;
static const int16 BANK_END = 2015;
static const int16 BANK_BAGS_BEGIN = 2031;
static const int16 BANK_BAGS_END_OFFSET = 159;
static const int16 BANK_BAGS_END = BANK_BAGS_BEGIN + BANK_BAGS_END_OFFSET;
static const int16 SHARED_BANK_BEGIN = 2500;
static const int16 SHARED_BANK_END = 2501;
static const int16 SHARED_BANK_BAGS_BEGIN = 2531;
static const int16 SHARED_BANK_BAGS_END_OFFSET = 19;
static const int16 SHARED_BANK_BAGS_END = SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_END_OFFSET;
static const int16 TRADE_BEGIN = 3000;
static const int16 TRADE_END = 3007;
static const int16 TRADE_END_NPC = 3003;
static const int16 TRADE_BAGS_BEGIN = 3031;
static const int16 TRADE_BAGS_END_OFFSET = 79;
static const int16 TRADE_BAGS_END = TRADE_BAGS_BEGIN + TRADE_BAGS_END_OFFSET;
static const int16 WORLD_BEGIN = 4000;
static const int16 WORLD_END = 4009;
static const int16 TRIBUTE_BEGIN = 400;
static const int16 TRIBUTE_END = 404;
static const int16 CORPSE_BEGIN = slots::MainGeneral1;
static const int16 CORPSE_END = slots::MainGeneral1 + slots::MainCursor;
static const uint16 ITEM_COMMON_SIZE = 5;
static const uint16 ITEM_CONTAINER_SIZE = 10;
static const uint32 BANDOLIERS_COUNT = 4; // count = number of bandolier instances
static const uint32 BANDOLIER_SIZE = 4; // size = number of equipment slots in bandolier instance
static const uint32 POTION_BELT_SIZE = 4;
}
namespace limits {
static const bool ALLOWS_EMPTY_BAG_IN_BAG = false;
static const bool COIN_HAS_WEIGHT = true;
}
}; //end namespace Titanium
#endif /*Titanium_CONSTANTS_H_*/
/*
Titanium Notes:
** Integer-based inventory **
ok Possessions: 0 - 30 (Corpse: 22 - 52 [Offset 22])
ok [Equipment: 0 - 21]
ok [General: 22 - 29]
ok [Cursor: 30]
ok General Bags: 251 - 330
ok Cursor Bags: 331 - 340
ok Bank: 2000 - 2015
ok Bank Bags: 2031 - 2190
ok Shared Bank: 2500 - 2501
ok Shared Bank Bags: 2531 - 2550
Trade: 3000 - 3007
(Trade Bags: 3031 - 3110 -- server values)
World: 4000 - 4009
*/

215
common/patches/Underfoot_constants.h Normal file
View File

@ -0,0 +1,215 @@
/*
EQEMu: Everquest Server Emulator
Copyright (C) 2001-2014 EQEMu Development Team (http://eqemulator.net)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef Underfoot_CONSTANTS_H_
#define Underfoot_CONSTANTS_H_
#include "../common/types.h"
namespace Underfoot {
namespace maps {
typedef enum : int16 {
// this needs work to match actual client equivilents
MapPossessions = 0,
MapBank,
MapSharedBank,
MapTrade,
MapWorld,
MapLimbo,
MapTribute,
MapTrophyTribute,
MapGuildTribute,
MapMerchant,
MapDeleted,
MapCorpse,
MapBazaar,
MapInspect,
MapRealEstate,
MapViewMODPC,
MapViewMODBank,
MapViewMODSharedBank,
MapViewMODLimbo,
MapAltStorage,
MapArchived,
MapMail,
MapGuildTrophyTribute,
MapOther,
_MapCount
};
}
namespace slots {
typedef enum : int16 {
MainCharm = 0,
MainEar1,
MainHead,
MainFace,
MainEar2,
MainNeck,
MainShoulders,
MainArms,
MainBack,
MainWrist1,
MainWrist2,
MainRange,
MainHands,
MainPrimary,
MainSecondary,
MainFinger1,
MainFinger2,
MainChest,
MainLegs,
MainFeet,
MainWaist,
MainPowerSource,
MainAmmo,
MainGeneral1,
MainGeneral2,
MainGeneral3,
MainGeneral4,
MainGeneral5,
MainGeneral6,
MainGeneral7,
MainGeneral8,
MainCursor,
_MainCount,
_MainEquipmentBegin = MainCharm,
_MainEquipmentEnd = MainAmmo,
_MainEquipmentCount = (_MainEquipmentEnd - _MainEquipmentBegin + 1),
_MainGeneralBegin = MainGeneral1,
_MainGeneralEnd = MainGeneral8,
_MainGeneralCount = (_MainGeneralEnd - _MainGeneralBegin + 1)
};
}
namespace consts {
static const uint16 MAP_POSSESSIONS_SIZE = slots::_MainCount;
static const uint16 MAP_BANK_SIZE = 24;
static const uint16 MAP_SHARED_BANK_SIZE = 2;
static const uint16 MAP_TRADE_SIZE = 8;
static const uint16 MAP_WORLD_SIZE = 10;
static const uint16 MAP_LIMBO_SIZE = 36;
static const uint16 MAP_TRIBUTE_SIZE = 0; //?
static const uint16 MAP_TROPHY_TRIBUTE_SIZE = 0;
static const uint16 MAP_GUILD_TRIBUTE_SIZE = 0;
static const uint16 MAP_MERCHANT_SIZE = 0;
static const uint16 MAP_DELETED_SIZE = 0;
static const uint16 MAP_CORPSE_SIZE = slots::_MainCount;
static const uint16 MAP_BAZAAR_SIZE = 80;
static const uint16 MAP_INSPECT_SIZE = slots::_MainEquipmentCount;
static const uint16 MAP_REAL_ESTATE_SIZE = 0;
static const uint16 MAP_VIEW_MOD_PC_SIZE = MAP_POSSESSIONS_SIZE;
static const uint16 MAP_VIEW_MOD_BANK_SIZE = MAP_BANK_SIZE;
static const uint16 MAP_VIEW_MOD_SHARED_BANK_SIZE = MAP_SHARED_BANK_SIZE;
static const uint16 MAP_VIEW_MOD_LIMBO_SIZE = MAP_LIMBO_SIZE;
static const uint16 MAP_ALT_STORAGE_SIZE = 0;
static const uint16 MAP_ARCHIVED_SIZE = 0;
static const uint16 MAP_MAIL_SIZE = 0;
static const uint16 MAP_GUILD_TROPHY_TRIBUTE_SIZE = 0;
static const uint16 MAP_KRONO_SIZE = NOT_USED;
static const uint16 MAP_OTHER_SIZE = 0;
static const int16 POSSESSIONS_BEGIN = slots::MainCharm;
static const int16 POSSESSIONS_END = slots::MainCursor;
static const int16 EQUIPMENT_BEGIN = slots::MainCharm;
static const int16 EQUIPMENT_END = slots::MainAmmo;
static const uint16 EQUIPMENT_SIZE = slots::_MainEquipmentCount;
static const int16 GENERAL_BEGIN = slots::MainGeneral1;
static const int16 GENERAL_END = slots::MainGeneral8;
static const uint16 GENERAL_SIZE = slots::_MainGeneralCount;
static const int16 GENERAL_BAGS_BEGIN = 262;
static const int16 GENERAL_BAGS_END_OFFSET = 79;
static const int16 GENERAL_BAGS_END = GENERAL_BAGS_BEGIN + GENERAL_BAGS_END_OFFSET;
static const int16 CURSOR = slots::MainCursor;
static const int16 CURSOR_BAG_BEGIN = 342;
static const int16 CURSOR_BAG_END_OFFSET = 9;
static const int16 CURSOR_BAG_END = CURSOR_BAG_BEGIN + CURSOR_BAG_END_OFFSET;
static const int16 BANK_BEGIN = 2000;
static const int16 BANK_END = 2023;
static const int16 BANK_BAGS_BEGIN = 2032;
static const int16 BANK_BAGS_END_OFFSET = 239;
static const int16 BANK_BAGS_END = BANK_BAGS_BEGIN + BANK_BAGS_END_OFFSET;
static const int16 SHARED_BANK_BEGIN = 2500;
static const int16 SHARED_BANK_END = 2501;
static const int16 SHARED_BANK_BAGS_BEGIN = 2532;
static const int16 SHARED_BANK_BAGS_END_OFFSET = 19;
static const int16 SHARED_BANK_BAGS_END = SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_END_OFFSET;
static const int16 TRADE_BEGIN = 3000;
static const int16 TRADE_END = 3007;
static const int16 TRADE_END_NPC = 3003;
static const int16 TRADE_BAGS_BEGIN = 3031; // no change from Ti?
static const int16 TRADE_BAGS_END_OFFSET = 79;
static const int16 TRADE_BAGS_END = TRADE_BAGS_BEGIN + TRADE_BAGS_END_OFFSET;
static const int16 WORLD_BEGIN = 4000;
static const int16 WORLD_END = 4009;
static const int16 TRIBUTE_BEGIN = 400;
static const int16 TRIBUTE_END = 404;
static const int16 CORPSE_BEGIN = slots::MainGeneral1;
static const int16 CORPSE_END = slots::MainGeneral1 + slots::MainCursor;
static const uint16 ITEM_COMMON_SIZE = 5;
static const uint16 ITEM_CONTAINER_SIZE = 10;
static const uint32 BANDOLIERS_COUNT = 20; // count = number of bandolier instances
static const uint32 BANDOLIER_SIZE = 4; // size = number of equipment slots in bandolier instance
static const uint32 POTION_BELT_SIZE = 5;
}
namespace limits {
static const bool ALLOWS_EMPTY_BAG_IN_BAG = false;
static const bool COIN_HAS_WEIGHT = false;
}
}; //end namespace Underfoot
#endif /*Underfoot_CONSTANTS_H_*/
/*
Underfoot Notes:
** Integer-based inventory **
ok Possessions: 0 - 31 (Corpse: 23 - 54 [Offset 23])
ok [Equipment: 0 - 22]
ok [General: 23 - 30]
ok [Cursor: 31]
ok General Bags: 262 - 341
ok Cursor Bags: 342 - 351
ok Bank: 2000 - 2023
ok Bank Bags: 2032 - 2271
ok Shared Bank: 2500 - 2501
ok Shared Bank Bags: 2532 - 2551
Trade: 3000 - 3007
(Trade Bags: 3031 - 3110 -- server values)
World: 4000 - 4009
*/

2
common/patches/makepatch
View File

@ -5,7 +5,7 @@ if [ -z "$1" ]; then
exit 1 exit 1
fi fi
for ext in .cpp .h _ops.h _structs.h for ext in .cpp .h _ops.h _constants.h _structs.h
do do
cp template$ext $1$ext cp template$ext $1$ext
perl -pi -e "s/TEMPLATE/$1/g" $1$ext perl -pi -e "s/TEMPLATE/$1/g" $1$ext

3
common/patches/patches.cpp
View File

@ -8,6 +8,7 @@
#include "SoF.h" #include "SoF.h"
#include "SoD.h" #include "SoD.h"
#include "RoF.h" #include "RoF.h"
//#include "RoF2.h"
void RegisterAllPatches(EQStreamIdentifier &into) { void RegisterAllPatches(EQStreamIdentifier &into) {
Client62::Register(into); Client62::Register(into);
@ -16,6 +17,7 @@ void RegisterAllPatches(EQStreamIdentifier &into) {
SoD::Register(into); SoD::Register(into);
Underfoot::Register(into); Underfoot::Register(into);
RoF::Register(into); RoF::Register(into);
//RoF2::Register(into);
} }
void ReloadAllPatches() { void ReloadAllPatches() {
@ -25,4 +27,5 @@ void ReloadAllPatches() {
SoD::Reload(); SoD::Reload();
Underfoot::Reload(); Underfoot::Reload();
RoF::Reload(); RoF::Reload();
//RoF2::Reload();
} }

20
common/patches/template_constants.h Normal file
View File

@ -0,0 +1,20 @@
#ifndef TEMPLATE_CONSTANTS_H_
#define TEMPLATE_CONSTANTS_H_
namespace TEMPLATE {
// put constants here and #include appropriately
}; //end namespace TEMPLATE
#endif /*TEMPLATE_CONSTANTS_H_*/

40
zone/MobAI.cpp
View File

@ -824,17 +824,17 @@ void Client::AI_Process()
if(GetTarget() && !IsStunned() && !IsMezzed() && !GetFeigned()) { if(GetTarget() && !IsStunned() && !IsMezzed() && !GetFeigned()) {
if(attack_timer.Check()) { if(attack_timer.Check()) {
Attack(GetTarget(), 13); Attack(GetTarget(), MainPrimary);
if(GetTarget()) { if(GetTarget()) {
if(CheckDoubleAttack()) { if(CheckDoubleAttack()) {
Attack(GetTarget(), 13); Attack(GetTarget(), MainPrimary);
if(GetTarget()) { if(GetTarget()) {
bool triple_attack_success = false; bool triple_attack_success = false;
if((((GetClass() == MONK || GetClass() == WARRIOR || GetClass() == RANGER || GetClass() == BERSERKER) if((((GetClass() == MONK || GetClass() == WARRIOR || GetClass() == RANGER || GetClass() == BERSERKER)
&& GetLevel() >= 60) || GetSpecialAbility(SPECATK_TRIPLE)) && GetLevel() >= 60) || GetSpecialAbility(SPECATK_TRIPLE))
&& CheckDoubleAttack(true)) && CheckDoubleAttack(true))
{ {
Attack(GetTarget(), 13, true); Attack(GetTarget(), MainPrimary, true);
triple_attack_success = true; triple_attack_success = true;
} }
@ -848,8 +848,8 @@ void Client::AI_Process()
if(MakeRandomInt(0, 100) < flurrychance) if(MakeRandomInt(0, 100) < flurrychance)
{ {
Message_StringID(MT_NPCFlurry, YOU_FLURRY); Message_StringID(MT_NPCFlurry, YOU_FLURRY);
Attack(GetTarget(), 13, false); Attack(GetTarget(), MainPrimary, false);
Attack(GetTarget(), 13, false); Attack(GetTarget(), MainPrimary, false);
} }
} }
@ -864,7 +864,7 @@ void Client::AI_Process()
{ {
if(MakeRandomInt(0, 100) < ExtraAttackChanceBonus) if(MakeRandomInt(0, 100) < ExtraAttackChanceBonus)
{ {
Attack(GetTarget(), 13, false); Attack(GetTarget(), MainPrimary, false);
} }
} }
} }
@ -903,10 +903,10 @@ void Client::AI_Process()
if(MakeRandomFloat(0.0, 1.0) < DualWieldProbability) if(MakeRandomFloat(0.0, 1.0) < DualWieldProbability)
{ {
Attack(GetTarget(), 14); Attack(GetTarget(), MainSecondary);
if(CheckDoubleAttack()) if(CheckDoubleAttack())
{ {
Attack(GetTarget(), 14); Attack(GetTarget(), MainSecondary);
} }
} }
@ -1145,14 +1145,14 @@ void Mob::AI_Process() {
if(IsNPC()) { if(IsNPC()) {
int16 n_atk = CastToNPC()->GetNumberOfAttacks(); int16 n_atk = CastToNPC()->GetNumberOfAttacks();
if(n_atk <= 1) { if(n_atk <= 1) {
Attack(target, 13); Attack(target, MainPrimary);
} else { } else {
for(int i = 0; i < n_atk; ++i) { for(int i = 0; i < n_atk; ++i) {
Attack(target, 13); Attack(target, MainPrimary);
} }
} }
} else { } else {
Attack(target, 13); Attack(target, MainPrimary);
} }
if (target) { if (target) {
@ -1164,16 +1164,16 @@ void Mob::AI_Process() {
|| GetSpecialAbility(SPECATK_QUAD)) || GetSpecialAbility(SPECATK_QUAD))
//check double attack, this is NOT the same rules that clients use... //check double attack, this is NOT the same rules that clients use...
&& RandRoll < (GetLevel() + NPCDualAttackModifier)) { && RandRoll < (GetLevel() + NPCDualAttackModifier)) {
Attack(target, 13); Attack(target, MainPrimary);
// lets see if we can do a triple attack with the main hand // lets see if we can do a triple attack with the main hand
//pets are excluded from triple and quads... //pets are excluded from triple and quads...
if ((GetSpecialAbility(SPECATK_TRIPLE) || GetSpecialAbility(SPECATK_QUAD)) if ((GetSpecialAbility(SPECATK_TRIPLE) || GetSpecialAbility(SPECATK_QUAD))
&& !IsPet() && RandRoll < (GetLevel() + NPCTripleAttackModifier)) { && !IsPet() && RandRoll < (GetLevel() + NPCTripleAttackModifier)) {
Attack(target, 13); Attack(target, MainPrimary);
// now lets check the quad attack // now lets check the quad attack
if (GetSpecialAbility(SPECATK_QUAD) if (GetSpecialAbility(SPECATK_QUAD)
&& RandRoll < (GetLevel() + NPCQuadAttackModifier)) { && RandRoll < (GetLevel() + NPCQuadAttackModifier)) {
Attack(target, 13); Attack(target, MainPrimary);
} }
} }
} }
@ -1319,13 +1319,13 @@ void Mob::AI_Process() {
float DualWieldProbability = (GetSkill(SkillDualWield) + GetLevel()) / 400.0f; float DualWieldProbability = (GetSkill(SkillDualWield) + GetLevel()) / 400.0f;
if(MakeRandomFloat(0.0, 1.0) < DualWieldProbability) if(MakeRandomFloat(0.0, 1.0) < DualWieldProbability)
{ {
Attack(target, 14); Attack(target, MainSecondary);
if (CanThisClassDoubleAttack()) if (CanThisClassDoubleAttack())
{ {
int32 RandRoll = MakeRandomInt(0, 99); int32 RandRoll = MakeRandomInt(0, 99);
if (RandRoll < (GetLevel() + 20)) if (RandRoll < (GetLevel() + 20))
{ {
Attack(target, 14); Attack(target, MainSecondary);
} }
} }
} }
@ -2024,7 +2024,7 @@ bool Mob::Flurry(ExtraAttackOptions *opts)
int num_attacks = GetSpecialAbilityParam(SPECATK_FLURRY, 1); int num_attacks = GetSpecialAbilityParam(SPECATK_FLURRY, 1);
num_attacks = num_attacks > 0 ? num_attacks : RuleI(Combat, MaxFlurryHits); num_attacks = num_attacks > 0 ? num_attacks : RuleI(Combat, MaxFlurryHits);
for (int i = 0; i < num_attacks; i++) for (int i = 0; i < num_attacks; i++)
Attack(target, 13, false, false, false, opts); Attack(target, MainPrimary, false, false, false, opts);
} }
return true; return true;
} }
@ -2073,14 +2073,14 @@ bool Mob::Rampage(ExtraAttackOptions *opts)
if (m_target == GetTarget()) if (m_target == GetTarget())
continue; continue;
if (CombatRange(m_target)) { if (CombatRange(m_target)) {
Attack(m_target, 13, false, false, false, opts); Attack(m_target, MainPrimary, false, false, false, opts);
index_hit++; index_hit++;
} }
} }
} }
if (RuleB(Combat, RampageHitsTarget) && index_hit < rampage_targets) if (RuleB(Combat, RampageHitsTarget) && index_hit < rampage_targets)
Attack(GetTarget(), 13, false, false, false, opts); Attack(GetTarget(), MainPrimary, false, false, false, opts);
return true; return true;
} }
@ -2099,7 +2099,7 @@ void Mob::AreaRampage(ExtraAttackOptions *opts)
index_hit = hate_list.AreaRampage(this, GetTarget(), rampage_targets, opts); index_hit = hate_list.AreaRampage(this, GetTarget(), rampage_targets, opts);
if(index_hit == 0) { if(index_hit == 0) {
Attack(GetTarget(), 13, false, false, false, opts); Attack(GetTarget(), MainPrimary, false, false, false, opts);
} }
} }

2
zone/Object.cpp
View File

@ -349,7 +349,7 @@ void Object::Close() {
ItemInst* container = this->m_inst; ItemInst* container = this->m_inst;
if(container != nullptr) if(container != nullptr)
{ {
for (uint8 i = 0; i < MAX_ITEMS_PER_BAG; i++) for (uint8 i = SUB_BEGIN; i < EmuConstants::ITEM_CONTAINER_SIZE; i++)
{ {
ItemInst* inst = container->PopItem(i); ItemInst* inst = container->PopItem(i);
if(inst != nullptr) if(inst != nullptr)

6
zone/attack.cpp
View File

@ -454,9 +454,9 @@ bool Mob::AvoidDamage(Mob* other, int32 &damage, bool CanRiposte)
if(damage > 0 && (aabonuses.TwoHandBluntBlock || spellbonuses.TwoHandBluntBlock || itembonuses.TwoHandBluntBlock) if(damage > 0 && (aabonuses.TwoHandBluntBlock || spellbonuses.TwoHandBluntBlock || itembonuses.TwoHandBluntBlock)
&& (other->InFrontMob(this, other->GetX(), other->GetY()) || bShieldBlockFromRear)) { && (other->InFrontMob(this, other->GetX(), other->GetY()) || bShieldBlockFromRear)) {
bool equiped2 = CastToClient()->m_inv.GetItem(13); bool equiped2 = CastToClient()->m_inv.GetItem(MainPrimary);
if(equiped2) { if(equiped2) {
uint8 TwoHandBlunt = CastToClient()->m_inv.GetItem(13)->GetItem()->ItemType; uint8 TwoHandBlunt = CastToClient()->m_inv.GetItem(MainPrimary)->GetItem()->ItemType;
float bonusStaffBlock = 0.0f; float bonusStaffBlock = 0.0f;
if(TwoHandBlunt == ItemType2HBlunt) { if(TwoHandBlunt == ItemType2HBlunt) {
@ -4055,7 +4055,7 @@ void Mob::TrySpellProc(const ItemInst *inst, const Item_Struct *weapon, Mob *on,
rangedattk = true; rangedattk = true;
} }
if (!weapon && hand == 11 && GetSpecialAbility(SPECATK_RANGED_ATK)) if (!weapon && hand == MainRange && GetSpecialAbility(SPECATK_RANGED_ATK))
rangedattk = true; rangedattk = true;
for (uint32 i = 0; i < MAX_PROCS; i++) { for (uint32 i = 0; i < MAX_PROCS; i++) {

2
zone/beacon.h
View File

@ -33,7 +33,7 @@ public:
//abstract virtual function implementations requird by base abstract class //abstract virtual function implementations requird by base abstract class
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill) { return true; } virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill) { return true; }
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false) { return; } virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false) { return; }
virtual bool Attack(Mob* other, int Hand = 13, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false, virtual bool Attack(Mob* other, int Hand = MainPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
ExtraAttackOptions *opts = nullptr) { return false; } ExtraAttackOptions *opts = nullptr) { return false; }
virtual bool HasRaid() { return false; } virtual bool HasRaid() { return false; }
virtual bool HasGroup() { return false; } virtual bool HasGroup() { return false; }

8
zone/bonuses.cpp
View File

@ -159,8 +159,8 @@ void Client::CalcItemBonuses(StatBonuses* newbon) {
} }
//tribute items //tribute items
for (i = 0; i < MAX_PLAYER_TRIBUTES; i++) { for (i = 0; i < EmuConstants::TRIBUTE_SIZE; i++) {
const ItemInst* inst = m_inv[TRIBUTE_SLOT_START + i]; const ItemInst* inst = m_inv[EmuConstants::TRIBUTE_BEGIN + i];
if(inst == 0) if(inst == 0)
continue; continue;
AddItemBonuses(inst, newbon, false, true); AddItemBonuses(inst, newbon, false, true);
@ -544,7 +544,7 @@ void Client::CalcEdibleBonuses(StatBonuses* newbon) {
bool food = false; bool food = false;
bool drink = false; bool drink = false;
for (i = 22; i <= 29; i++) for (i = EmuConstants::GENERAL_BEGIN; i <= EmuConstants::GENERAL_BAGS_BEGIN; i++)
{ {
if (food && drink) if (food && drink)
break; break;
@ -560,7 +560,7 @@ void Client::CalcEdibleBonuses(StatBonuses* newbon) {
AddItemBonuses(inst, newbon); AddItemBonuses(inst, newbon);
} }
} }
for (i = 251; i <= 330; i++) for (i = EmuConstants::GENERAL_BAGS_BEGIN; i <= EmuConstants::GENERAL_BAGS_END; i++)
{ {
if (food && drink) if (food && drink)
break; break;

100
zone/bot.cpp
View File

@ -3304,7 +3304,7 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillUseTypes
int damage = 0; int damage = 0;
uint32 hate = 0; uint32 hate = 0;
int Hand = 13; int Hand = MainPrimary;
if (hate == 0 && weapon_damage > 1) hate = weapon_damage; if (hate == 0 && weapon_damage > 1) hate = weapon_damage;
if(weapon_damage > 0){ if(weapon_damage > 0){
@ -4103,7 +4103,7 @@ void Bot::PetAIProcess() {
int32 RandRoll = MakeRandomInt(0, 99); int32 RandRoll = MakeRandomInt(0, 99);
if (botPet->CanThisClassDoubleAttack() && (RandRoll < (botPet->GetLevel() + NPCDualAttackModifier))) if (botPet->CanThisClassDoubleAttack() && (RandRoll < (botPet->GetLevel() + NPCDualAttackModifier)))
{ {
if(botPet->Attack(botPet->GetTarget(), 13)) if(botPet->Attack(botPet->GetTarget(), MainPrimary))
{} {}
} }
} }
@ -4145,13 +4145,13 @@ void Bot::PetAIProcess() {
float DualWieldProbability = (botPet->GetSkill(SkillDualWield) + botPet->GetLevel()) / 400.0f; float DualWieldProbability = (botPet->GetSkill(SkillDualWield) + botPet->GetLevel()) / 400.0f;
DualWieldProbability -= MakeRandomFloat(0, 1); DualWieldProbability -= MakeRandomFloat(0, 1);
if(DualWieldProbability < 0){ if(DualWieldProbability < 0){
botPet->Attack(botPet->GetTarget(), 14); botPet->Attack(botPet->GetTarget(), MainSecondary);
if (botPet->CanThisClassDoubleAttack()) if (botPet->CanThisClassDoubleAttack())
{ {
int32 RandRoll = MakeRandomInt(0, 99); int32 RandRoll = MakeRandomInt(0, 99);
if (RandRoll < (botPet->GetLevel() + 20)) if (RandRoll < (botPet->GetLevel() + 20))
{ {
botPet->Attack(botPet->GetTarget(), 14); botPet->Attack(botPet->GetTarget(), MainSecondary);
} }
} }
} }
@ -8195,7 +8195,7 @@ void Bot::TryBackstab(Mob *other, int ReuseTime) {
} }
} }
else { //We do a single regular attack if we attack from the front without chaotic stab else { //We do a single regular attack if we attack from the front without chaotic stab
Attack(other, 13); Attack(other, MainPrimary);
} }
} }
@ -12333,30 +12333,31 @@ void Bot::ProcessBotCommands(Client *c, const Seperator *sep) {
gearbot->BotRemoveEquipItem(slotId); gearbot->BotRemoveEquipItem(slotId);
gearbot->CalcBotStats(); gearbot->CalcBotStats();
switch(slotId) { switch(slotId) {
case 0: case MainCharm:
case 1: case MainEar1:
case 2: case MainHead:
case 3: case MainFace:
case 4: case MainEar2:
case 5: case MainNeck:
case 8: case MainBack:
case 9: case MainWrist1:
case 10: case MainWrist2:
case 11: case MainRange:
case 13: case MainPrimary:
case 14: case MainSecondary:
case 15: case MainFinger1:
case 16: case MainFinger2:
case 17: case MainChest:
case 20: case MainWaist:
case 21: //case MainPowerSource:
case MainAmmo:
gearbot->Say("My %s is now unequipped.", equipped[slotId]); gearbot->Say("My %s is now unequipped.", equipped[slotId]);
break; break;
case 6: case MainShoulders:
case 7: case MainArms:
case 12: case MainHands:
case 18: case MainLegs:
case 19: case MainFeet:
gearbot->Say("My %s are now unequipped.", equipped[slotId]); gearbot->Say("My %s are now unequipped.", equipped[slotId]);
break; break;
default: default:
@ -12365,30 +12366,31 @@ void Bot::ProcessBotCommands(Client *c, const Seperator *sep) {
} }
else { else {
switch(slotId) { switch(slotId) {
case 0: case MainCharm:
case 1: case MainEar1:
case 2: case MainHead:
case 3: case MainFace:
case 4: case MainEar2:
case 5: case MainNeck:
case 8: case MainBack:
case 9: case MainWrist1:
case 10: case MainWrist2:
case 11: case MainRange:
case 13: case MainPrimary:
case 14: case MainSecondary:
case 15: case MainFinger1:
case 16: case MainFinger2:
case 17: case MainChest:
case 20: case MainWaist:
case 21: //case MainPowerSource:
case MainAmmo:
c->GetTarget()->Say("My %s is already unequipped.", equipped[slotId]); c->GetTarget()->Say("My %s is already unequipped.", equipped[slotId]);
break; break;
case 6: case MainShoulders:
case 7: case MainArms:
case 12: case MainHands:
case 18: case MainLegs:
case 19: case MainFeet:
c->GetTarget()->Say("My %s are already unequipped.", equipped[slotId]); c->GetTarget()->Say("My %s are already unequipped.", equipped[slotId]);
break; break;
default: default:

2
zone/bot.h
View File

@ -137,7 +137,7 @@ public:
//abstract virtual function implementations requird by base abstract class //abstract virtual function implementations requird by base abstract class
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill); virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill);
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false); virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false);
virtual bool Attack(Mob* other, int Hand = 13, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false, virtual bool Attack(Mob* other, int Hand = MainPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
ExtraAttackOptions *opts = nullptr); ExtraAttackOptions *opts = nullptr);
virtual bool HasRaid() { return (GetRaid() ? true : false); } virtual bool HasRaid() { return (GetRaid() ? true : false); }
virtual bool HasGroup() { return (GetGroup() ? true : false); } virtual bool HasGroup() { return (GetGroup() ? true : false); }

54
zone/client.cpp
View File

@ -4141,14 +4141,14 @@ void Client::UpdateLFP() {
uint16 Client::GetPrimarySkillValue() uint16 Client::GetPrimarySkillValue()
{ {
SkillUseTypes skill = HIGHEST_SKILL; //because nullptr == 0, which is 1H Slashing, & we want it to return 0 from GetSkill SkillUseTypes skill = HIGHEST_SKILL; //because nullptr == 0, which is 1H Slashing, & we want it to return 0 from GetSkill
bool equiped = m_inv.GetItem(13); bool equiped = m_inv.GetItem(MainPrimary);
if (!equiped) if (!equiped)
skill = SkillHandtoHand; skill = SkillHandtoHand;
else { else {
uint8 type = m_inv.GetItem(13)->GetItem()->ItemType; //is this the best way to do this? uint8 type = m_inv.GetItem(MainPrimary)->GetItem()->ItemType; //is this the best way to do this?
switch (type) switch (type)
{ {
@ -5702,7 +5702,7 @@ void Client::AddCrystals(uint32 Radiant, uint32 Ebon)
SendCrystalCounts(); SendCrystalCounts();
} }
// Processes a client request to inspect a SoF client's equipment. // Processes a client request to inspect a SoF+ client's equipment.
void Client::ProcessInspectRequest(Client* requestee, Client* requester) { void Client::ProcessInspectRequest(Client* requestee, Client* requester) {
if(requestee && requester) { if(requestee && requester) {
EQApplicationPacket* outapp = new EQApplicationPacket(OP_InspectAnswer, sizeof(InspectResponse_Struct)); EQApplicationPacket* outapp = new EQApplicationPacket(OP_InspectAnswer, sizeof(InspectResponse_Struct));
@ -5727,28 +5727,30 @@ void Client::ProcessInspectRequest(Client* requestee, Client* requester) {
} }
} }
inst = requestee->GetInv().GetItem(9999); inst = requestee->GetInv().GetItem(MainPowerSource);
if(inst) { if(inst) {
item = inst->GetItem(); item = inst->GetItem();
if(item) { if(item) {
strcpy(insr->itemnames[21], item->Name); // we shouldn't do this..but, that's the way it's coded atm...
insr->itemicons[21] = item->Icon; // (this type of action should be handled exclusively in the client translator)
strcpy(insr->itemnames[SoF::slots::MainPowerSource], item->Name);
insr->itemicons[SoF::slots::MainPowerSource] = item->Icon;
} }
else else
insr->itemicons[21] = 0xFFFFFFFF; insr->itemicons[SoF::slots::MainPowerSource] = 0xFFFFFFFF;
} }
inst = requestee->GetInv().GetItem(21); inst = requestee->GetInv().GetItem(MainAmmo);
if(inst) { if(inst) {
item = inst->GetItem(); item = inst->GetItem();
if(item) { if(item) {
strcpy(insr->itemnames[22], item->Name); strcpy(insr->itemnames[SoF::slots::MainAmmo], item->Name);
insr->itemicons[22] = item->Icon; insr->itemicons[SoF::slots::MainAmmo] = item->Icon;
} }
else else
insr->itemicons[22] = 0xFFFFFFFF; insr->itemicons[SoF::slots::MainAmmo] = 0xFFFFFFFF;
} }
strcpy(insr->text, requestee->GetInspectMessage().text); strcpy(insr->text, requestee->GetInspectMessage().text);
@ -6277,8 +6279,8 @@ void Client::Doppelganger(uint16 spell_id, Mob *target, const char *name_overrid
made_npc->PR = GetPR(); made_npc->PR = GetPR();
made_npc->Corrup = GetCorrup(); made_npc->Corrup = GetCorrup();
// looks // looks
made_npc->texture = GetEquipmentMaterial(1); made_npc->texture = GetEquipmentMaterial(MaterialChest);
made_npc->helmtexture = GetEquipmentMaterial(0); made_npc->helmtexture = GetEquipmentMaterial(MaterialHead);
made_npc->haircolor = GetHairColor(); made_npc->haircolor = GetHairColor();
made_npc->beardcolor = GetBeardColor(); made_npc->beardcolor = GetBeardColor();
made_npc->eyecolor1 = GetEyeColor1(); made_npc->eyecolor1 = GetEyeColor1();
@ -6289,9 +6291,9 @@ void Client::Doppelganger(uint16 spell_id, Mob *target, const char *name_overrid
made_npc->drakkin_heritage = GetDrakkinHeritage(); made_npc->drakkin_heritage = GetDrakkinHeritage();
made_npc->drakkin_tattoo = GetDrakkinTattoo(); made_npc->drakkin_tattoo = GetDrakkinTattoo();
made_npc->drakkin_details = GetDrakkinDetails(); made_npc->drakkin_details = GetDrakkinDetails();
made_npc->d_meele_texture1 = GetEquipmentMaterial(7); made_npc->d_meele_texture1 = GetEquipmentMaterial(MaterialPrimary);
made_npc->d_meele_texture2 = GetEquipmentMaterial(8); made_npc->d_meele_texture2 = GetEquipmentMaterial(MaterialSecondary);
for (int i = 0; i < _MaterialCount; i++) { for (int i = EmuConstants::MATERIAL_BEGIN; i <= EmuConstants::MATERIAL_END; i++) {
made_npc->armor_tint[i] = GetEquipmentColor(i); made_npc->armor_tint[i] = GetEquipmentColor(i);
} }
made_npc->loottable_id = 0; made_npc->loottable_id = 0;
@ -7829,17 +7831,17 @@ void Client::TickItemCheck()
if(zone->tick_items.empty()) { return; } if(zone->tick_items.empty()) { return; }
//Scan equip slots for items //Scan equip slots for items
for(i = 0; i <= 21; i++) for(i = EmuConstants::EQUIPMENT_BEGIN; i <= EmuConstants::EQUIPMENT_END; i++)
{ {
TryItemTick(i); TryItemTick(i);
} }
//Scan main inventory + cursor //Scan main inventory + cursor
for(i = 22; i < 31; i++) for(i = EmuConstants::GENERAL_BEGIN; i <= EmuConstants::CURSOR; i++)
{ {
TryItemTick(i); TryItemTick(i);
} }
//Scan bags //Scan bags
for(i = 251; i < 340; i++) for(i = EmuConstants::GENERAL_BAGS_BEGIN; i <= EmuConstants::CURSOR_BAG_END; i++)
{ {
TryItemTick(i); TryItemTick(i);
} }
@ -7863,9 +7865,9 @@ void Client::TryItemTick(int slot)
} }
//Only look at augs in main inventory //Only look at augs in main inventory
if(slot > 21) { return; } if(slot > EmuConstants::EQUIPMENT_END) { return; }
for (int x = 0; x < EmuConstants::ITEM_COMMON_SIZE; ++x) for (int x = AUG_BEGIN; x < EmuConstants::ITEM_COMMON_SIZE; ++x)
{ {
ItemInst * a_inst = inst->GetAugment(x); ItemInst * a_inst = inst->GetAugment(x);
if(!a_inst) { continue; } if(!a_inst) { continue; }
@ -7886,17 +7888,17 @@ void Client::TryItemTick(int slot)
void Client::ItemTimerCheck() void Client::ItemTimerCheck()
{ {
int i; int i;
for(i = 0; i <= 21; i++) for(i = EmuConstants::EQUIPMENT_BEGIN; i <= EmuConstants::EQUIPMENT_END; i++)
{ {
TryItemTimer(i); TryItemTimer(i);
} }
for(i = 22; i < 31; i++) for(i = EmuConstants::GENERAL_BAGS_BEGIN; i <= EmuConstants::CURSOR; i++)
{ {
TryItemTimer(i); TryItemTimer(i);
} }
for(i = 251; i < 340; i++) for(i = EmuConstants::GENERAL_BAGS_BEGIN; i <= EmuConstants::CURSOR_BAG_END; i++)
{ {
TryItemTimer(i); TryItemTimer(i);
} }
@ -7918,11 +7920,11 @@ void Client::TryItemTimer(int slot)
++it_iter; ++it_iter;
} }
if(slot > 21) { if(slot > EmuConstants::EQUIPMENT_END) {
return; return;
} }
for (int x = 0; x < EmuConstants::ITEM_COMMON_SIZE; ++x) for (int x = AUG_BEGIN; x < EmuConstants::ITEM_COMMON_SIZE; ++x)
{ {
ItemInst * a_inst = inst->GetAugment(x); ItemInst * a_inst = inst->GetAugment(x);
if(!a_inst) { if(!a_inst) {

2
zone/client.h
View File

@ -214,7 +214,7 @@ public:
//abstract virtual function implementations requird by base abstract class //abstract virtual function implementations requird by base abstract class
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill); virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill);
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false); virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false);
virtual bool Attack(Mob* other, int Hand = 13, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false, virtual bool Attack(Mob* other, int Hand = MainPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
ExtraAttackOptions *opts = nullptr); ExtraAttackOptions *opts = nullptr);
virtual bool HasRaid() { return (GetRaid() ? true : false); } virtual bool HasRaid() { return (GetRaid() ? true : false); }
virtual bool HasGroup() { return (GetGroup() ? true : false); } virtual bool HasGroup() { return (GetGroup() ? true : false); }

23
zone/client_mods.cpp
View File

@ -873,9 +873,9 @@ int16 Client::CalcAC() {
// Shield AC bonus for HeroicSTR // Shield AC bonus for HeroicSTR
if(itembonuses.HeroicSTR) { if(itembonuses.HeroicSTR) {
bool equiped = CastToClient()->m_inv.GetItem(14); bool equiped = CastToClient()->m_inv.GetItem(MainSecondary);
if(equiped) { if(equiped) {
uint8 shield = CastToClient()->m_inv.GetItem(14)->GetItem()->ItemType; uint8 shield = CastToClient()->m_inv.GetItem(MainSecondary)->GetItem()->ItemType;
if(shield == ItemTypeShield) if(shield == ItemTypeShield)
displayed += itembonuses.HeroicSTR/2; displayed += itembonuses.HeroicSTR/2;
} }
@ -903,9 +903,9 @@ int16 Client::GetACMit() {
// Shield AC bonus for HeroicSTR // Shield AC bonus for HeroicSTR
if(itembonuses.HeroicSTR) { if(itembonuses.HeroicSTR) {
bool equiped = CastToClient()->m_inv.GetItem(14); bool equiped = CastToClient()->m_inv.GetItem(MainSecondary);
if(equiped) { if(equiped) {
uint8 shield = CastToClient()->m_inv.GetItem(14)->GetItem()->ItemType; uint8 shield = CastToClient()->m_inv.GetItem(MainSecondary)->GetItem()->ItemType;
if(shield == ItemTypeShield) if(shield == ItemTypeShield)
mitigation += itembonuses.HeroicSTR/2; mitigation += itembonuses.HeroicSTR/2;
} }
@ -1127,7 +1127,7 @@ uint32 Client::CalcCurrentWeight() {
ItemInst* ins; ItemInst* ins;
uint32 Total = 0; uint32 Total = 0;
int x; int x;
for(x = 0; x <= 30; x++) for(x = EmuConstants::EQUIPMENT_BEGIN; x <= EmuConstants::CURSOR; x++) // include cursor or not?
{ {
TempItem = 0; TempItem = 0;
ins = GetInv().GetItem(x); ins = GetInv().GetItem(x);
@ -1136,7 +1136,7 @@ uint32 Client::CalcCurrentWeight() {
if (TempItem) if (TempItem)
Total += TempItem->Weight; Total += TempItem->Weight;
} }
for (x = 251; x < 331; x++) for (x = EmuConstants::GENERAL_BAGS_BEGIN; x <= EmuConstants::GENERAL_BAGS_END; x++) // include cursor bags or not?
{ {
int TmpWeight = 0; int TmpWeight = 0;
TempItem = 0; TempItem = 0;
@ -1147,9 +1147,11 @@ uint32 Client::CalcCurrentWeight() {
TmpWeight = TempItem->Weight; TmpWeight = TempItem->Weight;
if (TmpWeight > 0) if (TmpWeight > 0)
{ {
int bagslot = 22; // this code indicates that weight redux bags canonly be in the first general inventory slot to be effective...
// is this correct? or can we scan for the highest weight redux and use that? (need client verifications)
int bagslot = MainGeneral1;
int reduction = 0; int reduction = 0;
for (int m = 261; m < 331; m += 10) for (int m = MainGeneral2; m <= EmuConstants::GENERAL_BAGS_END; m += 10) // include cursor bags or not?
{ {
if (x >= m) if (x >= m)
bagslot += 1; bagslot += 1;
@ -1172,10 +1174,9 @@ uint32 Client::CalcCurrentWeight() {
This is the ONLY instance I have seen where the client is hard coded to particular Item IDs to set a certain property for an item. It is very odd. This is the ONLY instance I have seen where the client is hard coded to particular Item IDs to set a certain property for an item. It is very odd.
*/ */
// SoD client has no weight for coin // SoD+ client has no weight for coin
if (GetClientVersion() < EQClientSoD) { if (EQLimits::CoinHasWeight(ClientVersion))
Total += (m_pp.platinum + m_pp.gold + m_pp.silver + m_pp.copper) / 4; Total += (m_pp.platinum + m_pp.gold + m_pp.silver + m_pp.copper) / 4;
}
float Packrat = (float)spellbonuses.Packrat + (float)aabonuses.Packrat + (float)itembonuses.Packrat; float Packrat = (float)spellbonuses.Packrat + (float)aabonuses.Packrat + (float)itembonuses.Packrat;
if (Packrat > 0) if (Packrat > 0)

26
zone/client_packet.cpp
View File

@ -386,6 +386,7 @@ void MapOpcodes() {
ConnectedOpcodes[OP_MercenaryTimerRequest] = &Client::Handle_OP_MercenaryTimerRequest; ConnectedOpcodes[OP_MercenaryTimerRequest] = &Client::Handle_OP_MercenaryTimerRequest;
ConnectedOpcodes[OP_OpenInventory] = &Client::Handle_OP_OpenInventory; ConnectedOpcodes[OP_OpenInventory] = &Client::Handle_OP_OpenInventory;
ConnectedOpcodes[OP_OpenContainer] = &Client::Handle_OP_OpenContainer; ConnectedOpcodes[OP_OpenContainer] = &Client::Handle_OP_OpenContainer;
ConnectedOpcodes[OP_ClientTimeStamp] = &Client::Handle_OP_ClientTimeStamp;
} }
void ClearMappedOpcode(EmuOpcode op) { void ClearMappedOpcode(EmuOpcode op) {
@ -1629,7 +1630,7 @@ void Client::Handle_OP_Shielding(const EQApplicationPacket *app)
Shielding_Struct* shield = (Shielding_Struct*)app->pBuffer; Shielding_Struct* shield = (Shielding_Struct*)app->pBuffer;
shield_target = entity_list.GetMob(shield->target_id); shield_target = entity_list.GetMob(shield->target_id);
bool ack = false; bool ack = false;
ItemInst* inst = GetInv().GetItem(14); ItemInst* inst = GetInv().GetItem(MainSecondary);
if (!shield_target) if (!shield_target)
return; return;
if (inst) if (inst)
@ -3259,7 +3260,7 @@ void Client::Handle_OP_MoveItem(const EQApplicationPacket *app)
MoveItem_Struct* mi = (MoveItem_Struct*)app->pBuffer; MoveItem_Struct* mi = (MoveItem_Struct*)app->pBuffer;
if(spellend_timer.Enabled() && casting_spell_id && !IsBardSong(casting_spell_id)) if(spellend_timer.Enabled() && casting_spell_id && !IsBardSong(casting_spell_id))
{ {
if(mi->from_slot != mi->to_slot && (mi->from_slot < 30 || mi->from_slot > 39) && IsValidSlot(mi->from_slot) && IsValidSlot(mi->to_slot)) if(mi->from_slot != mi->to_slot && (mi->from_slot <= EmuConstants::GENERAL_END || mi->from_slot > 39) && IsValidSlot(mi->from_slot) && IsValidSlot(mi->to_slot))
{ {
char *detect = nullptr; char *detect = nullptr;
const ItemInst *itm_from = GetInv().GetItem(mi->from_slot); const ItemInst *itm_from = GetInv().GetItem(mi->from_slot);
@ -3280,8 +3281,8 @@ void Client::Handle_OP_MoveItem(const EQApplicationPacket *app)
// Illegal bagslot useage checks. Currently, user only receives a message if this check is triggered. // Illegal bagslot useage checks. Currently, user only receives a message if this check is triggered.
bool mi_hack = false; bool mi_hack = false;
if(mi->from_slot >= 251 && mi->from_slot <= 340) { if(mi->from_slot >= EmuConstants::GENERAL_BAGS_BEGIN && mi->from_slot <= EmuConstants::CURSOR_BAG_END) {
if(mi->from_slot > 330) { mi_hack = true; } if(mi->from_slot >= EmuConstants::CURSOR_BAG_BEGIN) { mi_hack = true; }
else { else {
int16 from_parent = m_inv.CalcSlotId(mi->from_slot); int16 from_parent = m_inv.CalcSlotId(mi->from_slot);
if(!m_inv[from_parent]) { mi_hack = true; } if(!m_inv[from_parent]) { mi_hack = true; }
@ -3290,8 +3291,8 @@ void Client::Handle_OP_MoveItem(const EQApplicationPacket *app)
} }
} }
if(mi->to_slot >= 251 && mi->to_slot <= 340) { if(mi->to_slot >= EmuConstants::GENERAL_BAGS_BEGIN && mi->to_slot <= EmuConstants::CURSOR_BAG_END) {
if(mi->to_slot > 330) { mi_hack = true; } if(mi->to_slot >= EmuConstants::CURSOR_BAG_BEGIN) { mi_hack = true; }
else { else {
int16 to_parent = m_inv.CalcSlotId(mi->to_slot); int16 to_parent = m_inv.CalcSlotId(mi->to_slot);
if(!m_inv[to_parent]) { mi_hack = true; } if(!m_inv[to_parent]) { mi_hack = true; }
@ -6791,14 +6792,15 @@ void Client::Handle_OP_InspectAnswer(const EQApplicationPacket *app) {
else { insr->itemicons[L] = 0xFFFFFFFF; } else { insr->itemicons[L] = 0xFFFFFFFF; }
} }
const ItemInst* inst = GetInv().GetItem(21); const ItemInst* inst = GetInv().GetItem(MainAmmo);
item = inst ? inst->GetItem() : nullptr; item = inst ? inst->GetItem() : nullptr;
if(item) { if(item) {
strcpy(insr->itemnames[22], item->Name); // another one..I did these, didn't I!!?
insr->itemicons[22] = item->Icon; strcpy(insr->itemnames[SoF::slots::MainAmmo], item->Name);
insr->itemicons[SoF::slots::MainAmmo] = item->Icon;
} }
else { insr->itemicons[22] = 0xFFFFFFFF; } else { insr->itemicons[SoF::slots::MainAmmo] = 0xFFFFFFFF; }
InspectMessage_Struct* newmessage = (InspectMessage_Struct*) insr->text; InspectMessage_Struct* newmessage = (InspectMessage_Struct*) insr->text;
InspectMessage_Struct& playermessage = this->GetInspectMessage(); InspectMessage_Struct& playermessage = this->GetInspectMessage();
@ -13866,3 +13868,7 @@ void Client::Handle_OP_OpenContainer(const EQApplicationPacket *app) {
// SideNote: Watching the slot translations, Unknown1 is showing '141' as well on certain item swaps. // SideNote: Watching the slot translations, Unknown1 is showing '141' as well on certain item swaps.
// Manually looting a corpse results in a from '34' to '68' value for equipment items, '0' to '0' for inventory. // Manually looting a corpse results in a from '34' to '68' value for equipment items, '0' to '0' for inventory.
} }
void Client::Handle_OP_ClientTimeStamp(const EQApplicationPacket *app) {
// handle as needed or ignore like we have been doing...
}

1
zone/client_packet.h
View File

@ -288,3 +288,4 @@
void Handle_OP_MercenaryTimerRequest(const EQApplicationPacket *app); void Handle_OP_MercenaryTimerRequest(const EQApplicationPacket *app);
void Handle_OP_OpenInventory(const EQApplicationPacket *app); void Handle_OP_OpenInventory(const EQApplicationPacket *app);
void Handle_OP_OpenContainer(const EQApplicationPacket *app); void Handle_OP_OpenContainer(const EQApplicationPacket *app);
void Handle_OP_ClientTimeStamp(const EQApplicationPacket *app);

30
zone/client_process.cpp
View File

@ -402,10 +402,10 @@ bool Client::Process() {
{ {
entity_list.AEAttack(this, 30); entity_list.AEAttack(this, 30);
} else { } else {
Attack(auto_attack_target, 13); // Kaiyodo - added attacking hand to arguments Attack(auto_attack_target, MainPrimary); // Kaiyodo - added attacking hand to arguments
} }
ItemInst *wpn = GetInv().GetItem(MainPrimary); ItemInst *wpn = GetInv().GetItem(MainPrimary);
TryWeaponProc(wpn, auto_attack_target, 13); TryWeaponProc(wpn, auto_attack_target, MainPrimary);
bool tripleAttackSuccess = false; bool tripleAttackSuccess = false;
if( auto_attack_target && CanThisClassDoubleAttack() ) { if( auto_attack_target && CanThisClassDoubleAttack() ) {
@ -416,7 +416,7 @@ bool Client::Process() {
if(CheckAAEffect(aaEffectRampage)) { if(CheckAAEffect(aaEffectRampage)) {
entity_list.AEAttack(this, 30); entity_list.AEAttack(this, 30);
} else { } else {
Attack(auto_attack_target, 13, false); Attack(auto_attack_target, MainPrimary, false);
} }
} }
@ -426,13 +426,13 @@ bool Client::Process() {
&& CheckDoubleAttack(true)) && CheckDoubleAttack(true))
{ {
tripleAttackSuccess = true; tripleAttackSuccess = true;
Attack(auto_attack_target, 13, false); Attack(auto_attack_target, MainPrimary, false);
} }
//quad attack, does this belong here?? //quad attack, does this belong here??
if(GetSpecialAbility(SPECATK_QUAD) && CheckDoubleAttack(true)) if(GetSpecialAbility(SPECATK_QUAD) && CheckDoubleAttack(true))
{ {
Attack(auto_attack_target, 13, false); Attack(auto_attack_target, MainPrimary, false);
} }
} }
@ -444,8 +444,8 @@ bool Client::Process() {
if(MakeRandomInt(0, 99) < flurrychance) if(MakeRandomInt(0, 99) < flurrychance)
{ {
Message_StringID(MT_NPCFlurry, YOU_FLURRY); Message_StringID(MT_NPCFlurry, YOU_FLURRY);
Attack(auto_attack_target, 13, false); Attack(auto_attack_target, MainPrimary, false);
Attack(auto_attack_target, 13, false); Attack(auto_attack_target, MainPrimary, false);
} }
} }
@ -460,7 +460,7 @@ bool Client::Process() {
{ {
if(MakeRandomInt(0, 99) < ExtraAttackChanceBonus) if(MakeRandomInt(0, 99) < ExtraAttackChanceBonus)
{ {
Attack(auto_attack_target, 13, false); Attack(auto_attack_target, MainPrimary, false);
} }
} }
} }
@ -507,19 +507,19 @@ bool Client::Process() {
CheckIncreaseSkill(SkillDualWield, auto_attack_target, -10); CheckIncreaseSkill(SkillDualWield, auto_attack_target, -10);
if (random < DualWieldProbability){ // Max 78% of DW if (random < DualWieldProbability){ // Max 78% of DW
if(CheckAAEffect(aaEffectRampage)) { if(CheckAAEffect(aaEffectRampage)) {
entity_list.AEAttack(this, 30, 14); entity_list.AEAttack(this, 30, MainSecondary);
} else { } else {
Attack(auto_attack_target, 14); // Single attack with offhand Attack(auto_attack_target, MainSecondary); // Single attack with offhand
} }
ItemInst *wpn = GetInv().GetItem(MainSecondary); ItemInst *wpn = GetInv().GetItem(MainSecondary);
TryWeaponProc(wpn, auto_attack_target, 14); TryWeaponProc(wpn, auto_attack_target, MainSecondary);
if( CanThisClassDoubleAttack() && CheckDoubleAttack()) { if( CanThisClassDoubleAttack() && CheckDoubleAttack()) {
if(CheckAAEffect(aaEffectRampage)) { if(CheckAAEffect(aaEffectRampage)) {
entity_list.AEAttack(this, 30, 14); entity_list.AEAttack(this, 30, MainSecondary);
} else { } else {
if(auto_attack_target && auto_attack_target->GetHP() > -10) if(auto_attack_target && auto_attack_target->GetHP() > -10)
Attack(auto_attack_target, 14); // Single attack with offhand Attack(auto_attack_target, MainSecondary); // Single attack with offhand
} }
} }
} }
@ -878,9 +878,9 @@ void Client::BulkSendInventoryItems() {
// Power Source // Power Source
if(GetClientVersion() >= EQClientSoF) { if(GetClientVersion() >= EQClientSoF) {
const ItemInst* inst = m_inv[9999]; const ItemInst* inst = m_inv[MainPowerSource];
if(inst) { if(inst) {
std::string packet = inst->Serialize(9999); std::string packet = inst->Serialize(MainPowerSource);
ser_items[i++] = packet; ser_items[i++] = packet;
size += packet.length(); size += packet.length();
} }

6
zone/command.cpp
View File

@ -2957,9 +2957,9 @@ void command_peekinv(Client *c, const Seperator *sep)
} }
if(c->GetClientVersion() >= EQClientSoF) if(c->GetClientVersion() >= EQClientSoF)
{ {
const ItemInst* inst = client->GetInv().GetItem(9999); const ItemInst* inst = client->GetInv().GetItem(MainPowerSource);
item = (inst) ? inst->GetItem() : nullptr; item = (inst) ? inst->GetItem() : nullptr;
c->Message((item==0), "InvSlot: %i, Item: %i (%c%06X00000000000000000000000000000000000000000000%s%c), Charges: %i", 9999, c->Message((item==0), "InvSlot: %i, Item: %i (%c%06X00000000000000000000000000000000000000000000%s%c), Charges: %i", MainPowerSource,
((item==0)?0:item->ID),0x12, ((item==0)?0:item->ID), ((item==0)?0:item->ID),0x12, ((item==0)?0:item->ID),
((item==0)?"null":item->Name), 0x12, ((item==0)?"null":item->Name), 0x12,
((item==0)?0:inst->GetCharges())); ((item==0)?0:inst->GetCharges()));
@ -3034,7 +3034,7 @@ void command_peekinv(Client *c, const Seperator *sep)
if (bAll || (strcasecmp(sep->arg[1], "trib")==0)) { if (bAll || (strcasecmp(sep->arg[1], "trib")==0)) {
// Active tribute effect items // Active tribute effect items
bFound = true; bFound = true;
for (int16 i=TRIBUTE_SLOT_START; i<(TRIBUTE_SLOT_START + MAX_PLAYER_TRIBUTES); i++) { for (int16 i = EmuConstants::TRIBUTE_BEGIN; i <= EmuConstants::TRIBUTE_END; i++) {
const ItemInst* inst = client->GetInv().GetItem(i); const ItemInst* inst = client->GetInv().GetItem(i);
item = (inst) ? inst->GetItem() : nullptr; item = (inst) ? inst->GetItem() : nullptr;
if (c->GetClientVersion() >= EQClientSoF) if (c->GetClientVersion() >= EQClientSoF)

18
zone/corpse.cpp
View File

@ -367,9 +367,9 @@ Corpse::Corpse(Client* client, int32 in_rezexp)
for(i = 0; i <= 30; i++) for(i = 0; i <= 30; i++)
{ {
if(i == 21 && client->GetClientVersion() >= EQClientSoF) { if(i == 21 && client->GetClientVersion() >= EQClientSoF) {
item = client->GetInv().GetItem(9999); item = client->GetInv().GetItem(MainPowerSource);
if((item && (!client->IsBecomeNPC())) || (item && client->IsBecomeNPC() && !item->GetItem()->NoRent)) { if((item && (!client->IsBecomeNPC())) || (item && client->IsBecomeNPC() && !item->GetItem()->NoRent)) {
std::list<uint32> slot_list = MoveItemToCorpse(client, item, 9999); std::list<uint32> slot_list = MoveItemToCorpse(client, item, MainPowerSource);
removed_list.merge(slot_list); removed_list.merge(slot_list);
} }
@ -999,12 +999,8 @@ void Corpse::MakeLootRequestPackets(Client* client, const EQApplicationPacket* a
end = itemlist.end(); end = itemlist.end();
uint8 containercount = 0; uint8 containercount = 0;
int corpselootlimit;
if(client->GetClientVersion() >= EQClientRoF) { corpselootlimit = 34; } int corpselootlimit = EQLimits::InventoryMapSize(MapCorpse, client->GetClientVersion());
else if(client->GetClientVersion() >= EQClientSoF) { corpselootlimit = 32; }
else if(client->GetClientVersion() == EQClientTitanium) { corpselootlimit = 31; }
else { corpselootlimit = 30; }
for(; cur != end; ++cur) { for(; cur != end; ++cur) {
ServerLootItem_Struct* item_data = *cur; ServerLootItem_Struct* item_data = *cur;
@ -1331,17 +1327,13 @@ void Corpse::QueryLoot(Client* to) {
cur = itemlist.begin(); cur = itemlist.begin();
end = itemlist.end(); end = itemlist.end();
int corpselootlimit; int corpselootlimit = EQLimits::InventoryMapSize(MapCorpse, to->GetClientVersion());
if (to->GetClientVersion() >= EQClientSoF) { corpselootlimit = 32; }
else if (to->GetClientVersion() == EQClientTitanium) { corpselootlimit = 31; }
else { corpselootlimit = 30; }
for(; cur != end; ++cur) { for(; cur != end; ++cur) {
ServerLootItem_Struct* sitem = *cur; ServerLootItem_Struct* sitem = *cur;
if (IsPlayerCorpse()) { if (IsPlayerCorpse()) {
if (sitem->equipSlot >= 251 && sitem->equipSlot <= 340) if (sitem->equipSlot >= EmuConstants::GENERAL_BAGS_BEGIN && sitem->equipSlot <= EmuConstants::CURSOR_BAG_END)
sitem->lootslot = 0xFFFF; sitem->lootslot = 0xFFFF;
else else
x < corpselootlimit ? sitem->lootslot = x : sitem->lootslot = 0xFFFF; x < corpselootlimit ? sitem->lootslot = x : sitem->lootslot = 0xFFFF;

2
zone/corpse.h
View File

@ -41,7 +41,7 @@ public:
//abstract virtual function implementations requird by base abstract class //abstract virtual function implementations requird by base abstract class
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill) { return true; } virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill) { return true; }
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false) { return; } virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false) { return; }
virtual bool Attack(Mob* other, int Hand = 13, bool FromRiposte = false, bool IsStrikethrough = true, bool IsFromSpell = false, virtual bool Attack(Mob* other, int Hand = MainPrimary, bool FromRiposte = false, bool IsStrikethrough = true, bool IsFromSpell = false,
ExtraAttackOptions *opts = nullptr) { return false; } ExtraAttackOptions *opts = nullptr) { return false; }
virtual bool HasRaid() { return false; } virtual bool HasRaid() { return false; }
virtual bool HasGroup() { return false; } virtual bool HasGroup() { return false; }

2
zone/entity.h
View File

@ -305,7 +305,7 @@ public:
void QueueToGroupsForNPCHealthAA(Mob* sender, const EQApplicationPacket* app); void QueueToGroupsForNPCHealthAA(Mob* sender, const EQApplicationPacket* app);
void QueueManaged(Mob* sender, const EQApplicationPacket* app, bool ignore_sender=false, bool ackreq = true); void QueueManaged(Mob* sender, const EQApplicationPacket* app, bool ignore_sender=false, bool ackreq = true);
void AEAttack(Mob *attacker, float dist, int Hand = 13, int count = 0, bool IsFromSpell = false); void AEAttack(Mob *attacker, float dist, int Hand = MainPrimary, int count = 0, bool IsFromSpell = false);
void AETaunt(Client *caster, float range = 0); void AETaunt(Client *caster, float range = 0);
void AESpell(Mob *caster, Mob *center, uint16 spell_id, bool affect_caster = true, int16 resist_adjust = 0); void AESpell(Mob *caster, Mob *center, uint16 spell_id, bool affect_caster = true, int16 resist_adjust = 0);
void MassGroupBuff(Mob *caster, Mob *center, uint16 spell_id, bool affect_caster = true); void MassGroupBuff(Mob *caster, Mob *center, uint16 spell_id, bool affect_caster = true);

4
zone/forage.cpp
View File

@ -301,7 +301,7 @@ void Client::GoFish()
Bait = m_inv.GetItem(bslot); Bait = m_inv.GetItem(bslot);
//if the bait isnt equipped, need to add its skill bonus //if the bait isnt equipped, need to add its skill bonus
if(bslot >= IDX_INV && Bait->GetItem()->SkillModType == SkillFishing) { if(bslot >= EmuConstants::GENERAL_BEGIN && Bait->GetItem()->SkillModType == SkillFishing) {
fishing_skill += Bait->GetItem()->SkillModValue; fishing_skill += Bait->GetItem()->SkillModValue;
} }
@ -393,7 +393,7 @@ void Client::GoFish()
//and then swap out items in primary slot... too lazy to fix right now //and then swap out items in primary slot... too lazy to fix right now
if (MakeRandomInt(0, 49) == 1) { if (MakeRandomInt(0, 49) == 1) {
Message_StringID(MT_Skills, FISHING_POLE_BROKE); //Your fishing pole broke! Message_StringID(MT_Skills, FISHING_POLE_BROKE); //Your fishing pole broke!
DeleteItemInInventory(13,0,true); DeleteItemInInventory(MainPrimary, 0, true);
} }
if(CheckIncreaseSkill(SkillFishing, nullptr, 5)) if(CheckIncreaseSkill(SkillFishing, nullptr, 5))

2
zone/hate_list.cpp
View File

@ -545,7 +545,7 @@ int HateList::AreaRampage(Mob *caster, Mob *target, int count, ExtraAttackOption
if(cur) if(cur)
{ {
for(int i = 0; i < count; ++i) { for(int i = 0; i < count; ++i) {
caster->Attack(cur, 13, false, false, false, opts); caster->Attack(cur, MainPrimary, false, false, false, opts);
} }
} }
iter++; iter++;

101
zone/inventory.cpp
View File

@ -44,7 +44,7 @@ uint32 Client::NukeItem(uint32 itemnum, uint8 where_to_check) {
int i; int i;
if(where_to_check & invWhereWorn) { if(where_to_check & invWhereWorn) {
for (i=0; i<=21; i++) { // Equipped for (i = EmuConstants::EQUIPMENT_BEGIN; i <= EmuConstants::EQUIPMENT_END; i++) {
if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) { if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) {
cur = m_inv.GetItem(i); cur = m_inv.GetItem(i);
if(cur && cur->GetItem()->Stackable) { if(cur && cur->GetItem()->Stackable) {
@ -57,9 +57,8 @@ uint32 Client::NukeItem(uint32 itemnum, uint8 where_to_check) {
} }
} }
// Power Source Slot if (GetItemIDAt(MainPowerSource) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(MainPowerSource) != INVALID_ID)) {
if (GetItemIDAt(9999) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(9999) != INVALID_ID)) { cur = m_inv.GetItem(MainPowerSource);
cur = m_inv.GetItem(9999);
if(cur && cur->GetItem()->Stackable) { if(cur && cur->GetItem()->Stackable) {
x += cur->GetCharges(); x += cur->GetCharges();
} else { } else {
@ -67,25 +66,25 @@ uint32 Client::NukeItem(uint32 itemnum, uint8 where_to_check) {
} }
if (GetClientVersion() >= EQClientSoF) if (GetClientVersion() >= EQClientSoF)
DeleteItemInInventory(9999, 0, true); DeleteItemInInventory(MainPowerSource, 0, true);
else else
DeleteItemInInventory(9999, 0, false); // Prevents Titanium crash DeleteItemInInventory(MainPowerSource, 0, false); // Prevents Titanium crash
} }
} }
if(where_to_check & invWhereCursor) { if(where_to_check & invWhereCursor) {
if (GetItemIDAt(30) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(30) != INVALID_ID)) { if (GetItemIDAt(MainCursor) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(MainCursor) != INVALID_ID)) {
cur = m_inv.GetItem(30); cur = m_inv.GetItem(MainCursor);
if(cur && cur->GetItem()->Stackable) { if(cur && cur->GetItem()->Stackable) {
x += cur->GetCharges(); x += cur->GetCharges();
} else { } else {
x++; x++;
} }
DeleteItemInInventory(30, 0, true); DeleteItemInInventory(MainCursor, 0, true);
} }
for (i=331; i<=340; i++) { // cursor's containers for (i = EmuConstants::CURSOR_BAG_BEGIN; i <= EmuConstants::CURSOR_BAG_END; i++) {
if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) { if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) {
cur = m_inv.GetItem(i); cur = m_inv.GetItem(i);
if(cur && cur->GetItem()->Stackable) { if(cur && cur->GetItem()->Stackable) {
@ -100,7 +99,7 @@ uint32 Client::NukeItem(uint32 itemnum, uint8 where_to_check) {
} }
if(where_to_check & invWherePersonal) { if(where_to_check & invWherePersonal) {
for (i=22; i<=29; i++) { // Equipped for (i = EmuConstants::GENERAL_BEGIN; i <= EmuConstants::GENERAL_END; i++) {
if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) { if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) {
cur = m_inv.GetItem(i); cur = m_inv.GetItem(i);
if(cur && cur->GetItem()->Stackable) { if(cur && cur->GetItem()->Stackable) {
@ -113,7 +112,7 @@ uint32 Client::NukeItem(uint32 itemnum, uint8 where_to_check) {
} }
} }
for (i=251; i<=330; i++) { // Main inventory's containers for (i = EmuConstants::GENERAL_BAGS_BEGIN; i <= EmuConstants::GENERAL_BAGS_END; i++) {
if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) { if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) {
cur = m_inv.GetItem(i); cur = m_inv.GetItem(i);
if(cur && cur->GetItem()->Stackable) { if(cur && cur->GetItem()->Stackable) {
@ -128,7 +127,7 @@ uint32 Client::NukeItem(uint32 itemnum, uint8 where_to_check) {
} }
if(where_to_check & invWhereBank) { if(where_to_check & invWhereBank) {
for (i=2000; i<=2023; i++) { // Bank slots for (i = EmuConstants::BANK_BEGIN; i <= EmuConstants::BANK_END; i++) {
if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) { if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) {
cur = m_inv.GetItem(i); cur = m_inv.GetItem(i);
if(cur && cur->GetItem()->Stackable) { if(cur && cur->GetItem()->Stackable) {
@ -141,7 +140,7 @@ uint32 Client::NukeItem(uint32 itemnum, uint8 where_to_check) {
} }
} }
for (i=2031; i<=2270; i++) { // Bank's containers for (i = EmuConstants::BANK_BAGS_BEGIN; i <= EmuConstants::BANK_BAGS_END; i++) {
if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) { if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) {
cur = m_inv.GetItem(i); cur = m_inv.GetItem(i);
if(cur && cur->GetItem()->Stackable) { if(cur && cur->GetItem()->Stackable) {
@ -156,7 +155,7 @@ uint32 Client::NukeItem(uint32 itemnum, uint8 where_to_check) {
} }
if(where_to_check & invWhereSharedBank) { if(where_to_check & invWhereSharedBank) {
for (i=2500; i<=2501; i++) { // Shared bank for (i = EmuConstants::SHARED_BANK_BEGIN; i <= EmuConstants::SHARED_BANK_END; i++) {
if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) { if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) {
cur = m_inv.GetItem(i); cur = m_inv.GetItem(i);
if(cur && cur->GetItem()->Stackable) { if(cur && cur->GetItem()->Stackable) {
@ -169,7 +168,7 @@ uint32 Client::NukeItem(uint32 itemnum, uint8 where_to_check) {
} }
} }
for (i=2531; i<=2550; i++) { // Shared bank's containers for (i = EmuConstants::SHARED_BANK_BAGS_BEGIN; i <= EmuConstants::SHARED_BANK_BAGS_END; i++) {
if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) { if (GetItemIDAt(i) == itemnum || (itemnum == 0xFFFE && GetItemIDAt(i) != INVALID_ID)) {
cur = m_inv.GetItem(i); cur = m_inv.GetItem(i);
if(cur && cur->GetItem()->Stackable) { if(cur && cur->GetItem()->Stackable) {
@ -1225,17 +1224,17 @@ void Client::SendLootItemInPacket(const ItemInst* inst, int16 slot_id)
} }
bool Client::IsValidSlot(uint32 slot) { bool Client::IsValidSlot(uint32 slot) {
if ((slot == (uint32)INVALID_INDEX) || // Destroying/Dropping item if ((slot == (uint32)INVALID_INDEX) ||
(slot >= MainCharm && slot <= MainCursor) || // Worn inventory, normal inventory, and cursor (slot >= EmuConstants::POSSESSIONS_BEGIN && slot <= EmuConstants::POSSESSIONS_END) ||
(slot >= 251 && slot <= 340) || // Normal inventory bags and cursor bag (slot >= EmuConstants::GENERAL_BAGS_BEGIN && slot <= EmuConstants::CURSOR_BAG_END) ||
(slot >= 400 && slot <= 404) || // Tribute (slot >= EmuConstants::TRIBUTE_BEGIN && slot <= EmuConstants::TRIBUTE_END) ||
(slot >= 2000 && slot <= 2023) || // Bank (slot >= EmuConstants::BANK_BEGIN && slot <= EmuConstants::BANK_END) ||
(slot >= 2031 && slot <= 2270) || // Bank bags (slot >= EmuConstants::BANK_BAGS_BEGIN && slot <= EmuConstants::BANK_BAGS_END) ||
(slot >= 2500 && slot <= 2501) || // Shared bank (slot >= EmuConstants::SHARED_BANK_BEGIN && slot <= EmuConstants::SHARED_BANK_END) ||
(slot >= 2531 && slot <= 2550) || // Shared bank bags (slot >= EmuConstants::SHARED_BANK_BAGS_BEGIN && slot <= EmuConstants::SHARED_BANK_BAGS_END) ||
(slot >= 3000 && slot <= 3007) || // Trade window (slot >= EmuConstants::TRADE_BEGIN && slot <= EmuConstants::TRADE_END) ||
(slot >= 4000 && slot <= 4009) || // Tradeskill container (slot >= EmuConstants::WORLD_BEGIN && slot <= EmuConstants::WORLD_END) ||
(slot == MainPowerSource)) // Power Source (slot == EmuConstants::POWER_SOURCE))
return true; return true;
else else
return false; return false;
@ -1945,10 +1944,10 @@ bool Client::DecreaseByID(uint32 type, uint8 amt) {
ItemInst* ins; ItemInst* ins;
int x; int x;
int num = 0; int num = 0;
for(x=0; x < 331; x++) for(x = EmuConstants::POSSESSIONS_BEGIN; x <= EmuConstants::GENERAL_BAGS_END; x++)
{ {
if (x == 31) if (x == EmuConstants::CURSOR + 1)
x = 251; x = EmuConstants::GENERAL_BAGS_BEGIN;
TempItem = 0; TempItem = 0;
ins = GetInv().GetItem(x); ins = GetInv().GetItem(x);
if (ins) if (ins)
@ -1962,10 +1961,10 @@ bool Client::DecreaseByID(uint32 type, uint8 amt) {
} }
if (num < amt) if (num < amt)
return false; return false;
for(x=0; x < 331; x++) for(x = EmuConstants::POSSESSIONS_BEGIN; x <= EmuConstants::GENERAL_BAGS_END; x++) // should this be CURSOR_BAG_END
{ {
if (x == 31) if (x == EmuConstants::CURSOR + 1)
x = 251; x = EmuConstants::GENERAL_BAGS_BEGIN;
TempItem = 0; TempItem = 0;
ins = GetInv().GetItem(x); ins = GetInv().GetItem(x);
if (ins) if (ins)
@ -1994,7 +1993,7 @@ void Client::RemoveNoRent(bool client_update) {
int16 slot_id; int16 slot_id;
// personal // personal
for(slot_id = 0; slot_id <= 30; slot_id++) { for(slot_id = EmuConstants::POSSESSIONS_BEGIN; slot_id <= EmuConstants::POSSESSIONS_END; slot_id++) {
const ItemInst* inst = m_inv[slot_id]; const ItemInst* inst = m_inv[slot_id];
if(inst && !inst->GetItem()->NoRent) { if(inst && !inst->GetItem()->NoRent) {
mlog(INVENTORY__SLOTS, "NoRent Timer Lapse: Deleting %s from slot %i", inst->GetItem()->Name, slot_id); mlog(INVENTORY__SLOTS, "NoRent Timer Lapse: Deleting %s from slot %i", inst->GetItem()->Name, slot_id);
@ -2003,14 +2002,14 @@ void Client::RemoveNoRent(bool client_update) {
} }
// power source // power source
const ItemInst* inst = m_inv[9999]; const ItemInst* inst = m_inv[EmuConstants::POWER_SOURCE];
if(inst && !inst->GetItem()->NoRent) { if(inst && !inst->GetItem()->NoRent) {
mlog(INVENTORY__SLOTS, "NoRent Timer Lapse: Deleting %s from slot %i", inst->GetItem()->Name, slot_id); mlog(INVENTORY__SLOTS, "NoRent Timer Lapse: Deleting %s from slot %i", inst->GetItem()->Name, EmuConstants::POWER_SOURCE);
DeleteItemInInventory(MainPowerSource, 0, (GetClientVersion() >= EQClientSoF) ? client_update : false); // Ti slot non-existent DeleteItemInInventory(EmuConstants::POWER_SOURCE, 0, (GetClientVersion() >= EQClientSoF) ? client_update : false); // Ti slot non-existent
} }
// containers // containers
for(slot_id = 251; slot_id <= 340; slot_id++) { for(slot_id = EmuConstants::GENERAL_BAGS_BEGIN; slot_id <= EmuConstants::CURSOR_BAG_END; slot_id++) {
const ItemInst* inst = m_inv[slot_id]; const ItemInst* inst = m_inv[slot_id];
if(inst && !inst->GetItem()->NoRent) { if(inst && !inst->GetItem()->NoRent) {
mlog(INVENTORY__SLOTS, "NoRent Timer Lapse: Deleting %s from slot %i", inst->GetItem()->Name, slot_id); mlog(INVENTORY__SLOTS, "NoRent Timer Lapse: Deleting %s from slot %i", inst->GetItem()->Name, slot_id);
@ -2019,7 +2018,7 @@ void Client::RemoveNoRent(bool client_update) {
} }
// bank // bank
for(slot_id = 2000; slot_id <= 2023; slot_id++) { for(slot_id = EmuConstants::BANK_BEGIN; slot_id <= EmuConstants::BANK_END; slot_id++) {
const ItemInst* inst = m_inv[slot_id]; const ItemInst* inst = m_inv[slot_id];
if(inst && !inst->GetItem()->NoRent) { if(inst && !inst->GetItem()->NoRent) {
mlog(INVENTORY__SLOTS, "NoRent Timer Lapse: Deleting %s from slot %i", inst->GetItem()->Name, slot_id); mlog(INVENTORY__SLOTS, "NoRent Timer Lapse: Deleting %s from slot %i", inst->GetItem()->Name, slot_id);
@ -2028,7 +2027,7 @@ void Client::RemoveNoRent(bool client_update) {
} }
// bank containers // bank containers
for(slot_id = 2031; slot_id <= 2270; slot_id++) { for(slot_id = EmuConstants::BANK_BAGS_BEGIN; slot_id <= EmuConstants::BANK_BAGS_END; slot_id++) {
const ItemInst* inst = m_inv[slot_id]; const ItemInst* inst = m_inv[slot_id];
if(inst && !inst->GetItem()->NoRent) { if(inst && !inst->GetItem()->NoRent) {
mlog(INVENTORY__SLOTS, "NoRent Timer Lapse: Deleting %s from slot %i", inst->GetItem()->Name, slot_id); mlog(INVENTORY__SLOTS, "NoRent Timer Lapse: Deleting %s from slot %i", inst->GetItem()->Name, slot_id);
@ -2037,7 +2036,7 @@ void Client::RemoveNoRent(bool client_update) {
} }
// shared bank // shared bank
for(slot_id = 2500; slot_id <= 2501; slot_id++) { for(slot_id = EmuConstants::SHARED_BANK_BEGIN; slot_id <= EmuConstants::SHARED_BANK_END; slot_id++) {
const ItemInst* inst = m_inv[slot_id]; const ItemInst* inst = m_inv[slot_id];
if(inst && !inst->GetItem()->NoRent) { if(inst && !inst->GetItem()->NoRent) {
mlog(INVENTORY__SLOTS, "NoRent Timer Lapse: Deleting %s from slot %i", inst->GetItem()->Name, slot_id); mlog(INVENTORY__SLOTS, "NoRent Timer Lapse: Deleting %s from slot %i", inst->GetItem()->Name, slot_id);
@ -2046,7 +2045,7 @@ void Client::RemoveNoRent(bool client_update) {
} }
// shared bank containers // shared bank containers
for(slot_id = 2531; slot_id <= 2550; slot_id++) { for(slot_id = EmuConstants::SHARED_BANK_BAGS_BEGIN; slot_id <= EmuConstants::SHARED_BANK_BAGS_END; slot_id++) {
const ItemInst* inst = m_inv[slot_id]; const ItemInst* inst = m_inv[slot_id];
if(inst && !inst->GetItem()->NoRent) { if(inst && !inst->GetItem()->NoRent) {
mlog(INVENTORY__SLOTS, "NoRent Timer Lapse: Deleting %s from slot %i", inst->GetItem()->Name, slot_id); mlog(INVENTORY__SLOTS, "NoRent Timer Lapse: Deleting %s from slot %i", inst->GetItem()->Name, slot_id);
@ -2061,7 +2060,7 @@ void Client::RemoveDuplicateLore(bool client_update) {
int16 slot_id; int16 slot_id;
// personal // personal
for(slot_id = 0; slot_id <= 30; slot_id++) { for(slot_id = EmuConstants::POSSESSIONS_BEGIN; slot_id <= EmuConstants::POSSESSIONS_END; slot_id++) {
ItemInst* inst = m_inv.PopItem(slot_id); ItemInst* inst = m_inv.PopItem(slot_id);
if(inst) { if(inst) {
if(CheckLoreConflict(inst->GetItem())) { if(CheckLoreConflict(inst->GetItem())) {
@ -2076,20 +2075,20 @@ void Client::RemoveDuplicateLore(bool client_update) {
} }
// power source // power source
ItemInst* inst = m_inv.PopItem(9999); ItemInst* inst = m_inv.PopItem(EmuConstants::POWER_SOURCE);
if(inst) { if(inst) {
if(CheckLoreConflict(inst->GetItem())) { if(CheckLoreConflict(inst->GetItem())) {
mlog(INVENTORY__ERROR, "Lore Duplication Error: Deleting %s from slot %i", inst->GetItem()->Name, slot_id); mlog(INVENTORY__ERROR, "Lore Duplication Error: Deleting %s from slot %i", inst->GetItem()->Name, slot_id);
database.SaveInventory(character_id, nullptr, 9999); database.SaveInventory(character_id, nullptr, EmuConstants::POWER_SOURCE);
} }
else { else {
m_inv.PutItem(9999, *inst); m_inv.PutItem(EmuConstants::POWER_SOURCE, *inst);
} }
safe_delete(inst); safe_delete(inst);
} }
// containers // containers
for(slot_id = 251; slot_id <= 340; slot_id++) { for(slot_id = EmuConstants::GENERAL_BAGS_BEGIN; slot_id <= EmuConstants::CURSOR_BAG_END; slot_id++) {
ItemInst* inst = m_inv.PopItem(slot_id); ItemInst* inst = m_inv.PopItem(slot_id);
if(inst) { if(inst) {
if(CheckLoreConflict(inst->GetItem())) { if(CheckLoreConflict(inst->GetItem())) {
@ -2104,7 +2103,7 @@ void Client::RemoveDuplicateLore(bool client_update) {
} }
// bank // bank
for(slot_id = 2000; slot_id <= 2023; slot_id++) { for(slot_id = EmuConstants::BANK_BEGIN; slot_id <= EmuConstants::BANK_END; slot_id++) {
ItemInst* inst = m_inv.PopItem(slot_id); ItemInst* inst = m_inv.PopItem(slot_id);
if(inst) { if(inst) {
if(CheckLoreConflict(inst->GetItem())) { if(CheckLoreConflict(inst->GetItem())) {
@ -2119,7 +2118,7 @@ void Client::RemoveDuplicateLore(bool client_update) {
} }
// bank containers // bank containers
for(slot_id = 2031; slot_id <= 2270; slot_id++) { for(slot_id = EmuConstants::BANK_BAGS_BEGIN; slot_id <= EmuConstants::BANK_BAGS_END; slot_id++) {
ItemInst* inst = m_inv.PopItem(slot_id); ItemInst* inst = m_inv.PopItem(slot_id);
if(inst) { if(inst) {
if(CheckLoreConflict(inst->GetItem())) { if(CheckLoreConflict(inst->GetItem())) {
@ -2141,7 +2140,7 @@ void Client::MoveSlotNotAllowed(bool client_update) {
int16 slot_id; int16 slot_id;
// equipment // equipment
for(slot_id = 0; slot_id <= 21; slot_id++) { for(slot_id = EmuConstants::EQUIPMENT_BEGIN; slot_id <= EmuConstants::EQUIPMENT_END; slot_id++) {
if(m_inv[slot_id] && !m_inv[slot_id]->IsSlotAllowed(slot_id)) { if(m_inv[slot_id] && !m_inv[slot_id]->IsSlotAllowed(slot_id)) {
ItemInst* inst = m_inv.PopItem(slot_id); ItemInst* inst = m_inv.PopItem(slot_id);
bool is_arrow = (inst->GetItem()->ItemType == ItemTypeArrow) ? true : false; bool is_arrow = (inst->GetItem()->ItemType == ItemTypeArrow) ? true : false;
@ -2154,7 +2153,7 @@ void Client::MoveSlotNotAllowed(bool client_update) {
} }
// power source // power source
slot_id = 9999; slot_id = EmuConstants::POWER_SOURCE;
if(m_inv[slot_id] && !m_inv[slot_id]->IsSlotAllowed(slot_id)) { if(m_inv[slot_id] && !m_inv[slot_id]->IsSlotAllowed(slot_id)) {
ItemInst* inst = m_inv.PopItem(slot_id); ItemInst* inst = m_inv.PopItem(slot_id);
bool is_arrow = (inst->GetItem()->ItemType == ItemTypeArrow) ? true : false; bool is_arrow = (inst->GetItem()->ItemType == ItemTypeArrow) ? true : false;

6
zone/lua_general.cpp
View File

@ -1453,13 +1453,13 @@ luabind::scope lua_register_slot() {
luabind::value("General8", static_cast<int>(MainGeneral8)), luabind::value("General8", static_cast<int>(MainGeneral8)),
//luabind::value("General9", static_cast<int>(MainGeneral9)), //luabind::value("General9", static_cast<int>(MainGeneral9)),
//luabind::value("General10", static_cast<int>(MainGeneral10)), //luabind::value("General10", static_cast<int>(MainGeneral10)),
luabind::value("Cursor", static_cast<int>(MainCursor)),
//luabind::value("EquipmentBegin", static_cast<int>(EmuConstants::EQUIPMENT_BEGIN)), //luabind::value("EquipmentBegin", static_cast<int>(EmuConstants::EQUIPMENT_BEGIN)),
//luabind::value("EquipmentEnd", static_cast<int>(EmuConstants::EQUIPMENT_END)), //luabind::value("EquipmentEnd", static_cast<int>(EmuConstants::EQUIPMENT_END)),
luabind::value("PersonalBegin", static_cast<int>(EmuConstants::GENERAL_BEGIN)), // deprecated luabind::value("PersonalBegin", static_cast<int>(EmuConstants::GENERAL_BEGIN)), // deprecated
luabind::value("GeneralBegin", static_cast<int>(EmuConstants::GENERAL_BEGIN)), luabind::value("GeneralBegin", static_cast<int>(EmuConstants::GENERAL_BEGIN)),
luabind::value("PersonalEnd", static_cast<int>(EmuConstants::GENERAL_END)), // deprecated luabind::value("PersonalEnd", static_cast<int>(EmuConstants::GENERAL_END)), // deprecated
luabind::value("GeneralEnd", static_cast<int>(EmuConstants::GENERAL_END)), luabind::value("GeneralEnd", static_cast<int>(EmuConstants::GENERAL_END)),
luabind::value("Cursor", static_cast<int>(MainCursor)),
luabind::value("CursorEnd", 0xFFFE), // deprecated luabind::value("CursorEnd", 0xFFFE), // deprecated
luabind::value("Tradeskill", static_cast<int>(SLOT_TRADESKILL)), // deprecated luabind::value("Tradeskill", static_cast<int>(SLOT_TRADESKILL)), // deprecated
luabind::value("Augment", static_cast<int>(SLOT_AUGMENT)), // deprecated luabind::value("Augment", static_cast<int>(SLOT_AUGMENT)), // deprecated
@ -1483,6 +1483,7 @@ luabind::scope lua_register_material() {
luabind::value("Secondary", static_cast<int>(MaterialSecondary)), luabind::value("Secondary", static_cast<int>(MaterialSecondary)),
luabind::value("Max", static_cast<int>(_MaterialCount)), // deprecated luabind::value("Max", static_cast<int>(_MaterialCount)), // deprecated
luabind::value("Count", static_cast<int>(_MaterialCount)), luabind::value("Count", static_cast<int>(_MaterialCount)),
//luabind::value("TintCount", static_cast<int>(_MaterialCount - 2)),
luabind::value("Invalid", static_cast<int>(_MaterialInvalid)) luabind::value("Invalid", static_cast<int>(_MaterialInvalid))
]; ];
} }
@ -1497,7 +1498,8 @@ luabind::scope lua_register_client_version() {
luabind::value("SoF", static_cast<int>(EQClientSoF)), luabind::value("SoF", static_cast<int>(EQClientSoF)),
luabind::value("SoD", static_cast<int>(EQClientSoD)), luabind::value("SoD", static_cast<int>(EQClientSoD)),
luabind::value("Underfoot", static_cast<int>(EQClientUnderfoot)), luabind::value("Underfoot", static_cast<int>(EQClientUnderfoot)),
luabind::value("RoF", static_cast<int>(EQClientRoF)) luabind::value("RoF", static_cast<int>(EQClientRoF))//,
//luabind::value("RoF2", static_cast<int>(EQClientRoF2))
]; ];
} }

2
zone/merc.cpp
View File

@ -277,7 +277,7 @@ void Merc::CalcItemBonuses(StatBonuses* newbon) {
//Power Source Slot //Power Source Slot
/*if (GetClientVersion() >= EQClientSoF) /*if (GetClientVersion() >= EQClientSoF)
{ {
const ItemInst* inst = m_inv[9999]; const ItemInst* inst = m_inv[MainPowerSource];
if(inst) if(inst)
AddItemBonuses(inst, newbon); AddItemBonuses(inst, newbon);
}*/ }*/

20
zone/mob.h
View File

@ -131,11 +131,11 @@ public:
virtual void ThrowingAttack(Mob* other) { } virtual void ThrowingAttack(Mob* other) { }
uint16 GetThrownDamage(int16 wDmg, int32& TotalDmg, int& minDmg); uint16 GetThrownDamage(int16 wDmg, int32& TotalDmg, int& minDmg);
// 13 = Primary (default), 14 = secondary // 13 = Primary (default), 14 = secondary
virtual bool Attack(Mob* other, int Hand = 13, bool FromRiposte = false, bool IsStrikethrough = false, virtual bool Attack(Mob* other, int Hand = MainPrimary, bool FromRiposte = false, bool IsStrikethrough = false,
bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr) = 0; bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr) = 0;
int MonkSpecialAttack(Mob* other, uint8 skill_used); int MonkSpecialAttack(Mob* other, uint8 skill_used);
virtual void TryBackstab(Mob *other,int ReuseTime = 10); virtual void TryBackstab(Mob *other,int ReuseTime = 10);
void TriggerDefensiveProcs(const ItemInst* weapon, Mob *on, uint16 hand = 13, int damage = 0); void TriggerDefensiveProcs(const ItemInst* weapon, Mob *on, uint16 hand = MainPrimary, int damage = 0);
virtual bool AvoidDamage(Mob* attacker, int32 &damage, bool CanRiposte = true); virtual bool AvoidDamage(Mob* attacker, int32 &damage, bool CanRiposte = true);
virtual bool CheckHitChance(Mob* attacker, SkillUseTypes skillinuse, int Hand, int16 chance_mod = 0); virtual bool CheckHitChance(Mob* attacker, SkillUseTypes skillinuse, int Hand, int16 chance_mod = 0);
virtual void TryCriticalHit(Mob *defender, uint16 skill, int32 &damage, ExtraAttackOptions *opts = nullptr); virtual void TryCriticalHit(Mob *defender, uint16 skill, int32 &damage, ExtraAttackOptions *opts = nullptr);
@ -990,19 +990,19 @@ protected:
bool focused; bool focused;
void CalcSpellBonuses(StatBonuses* newbon); void CalcSpellBonuses(StatBonuses* newbon);
virtual void CalcBonuses(); virtual void CalcBonuses();
void TrySkillProc(Mob *on, uint16 skill, uint16 ReuseTime, bool Success = false, uint16 hand = 0, bool IsDefensive = false); void TrySkillProc(Mob *on, uint16 skill, uint16 ReuseTime, bool Success = false, uint16 hand = 0, bool IsDefensive = false); // hand = MainCharm?
bool PassLimitToSkill(uint16 spell_id, uint16 skill); bool PassLimitToSkill(uint16 spell_id, uint16 skill);
bool PassLimitClass(uint32 Classes_, uint16 Class_); bool PassLimitClass(uint32 Classes_, uint16 Class_);
void TryDefensiveProc(const ItemInst* weapon, Mob *on, uint16 hand = 13); void TryDefensiveProc(const ItemInst* weapon, Mob *on, uint16 hand = MainPrimary);
void TryWeaponProc(const ItemInst* inst, const Item_Struct* weapon, Mob *on, uint16 hand = 13); void TryWeaponProc(const ItemInst* inst, const Item_Struct* weapon, Mob *on, uint16 hand = MainPrimary);
void TrySpellProc(const ItemInst* inst, const Item_Struct* weapon, Mob *on, uint16 hand = 13); void TrySpellProc(const ItemInst* inst, const Item_Struct* weapon, Mob *on, uint16 hand = MainPrimary);
void TryWeaponProc(const ItemInst* weapon, Mob *on, uint16 hand = 13); void TryWeaponProc(const ItemInst* weapon, Mob *on, uint16 hand = MainPrimary);
void ExecWeaponProc(const ItemInst* weapon, uint16 spell_id, Mob *on); void ExecWeaponProc(const ItemInst* weapon, uint16 spell_id, Mob *on);
virtual float GetProcChances(float ProcBonus, uint16 hand = 13); virtual float GetProcChances(float ProcBonus, uint16 hand = MainPrimary);
virtual float GetDefensiveProcChances(float &ProcBonus, float &ProcChance, uint16 hand = 13, Mob *on = nullptr); virtual float GetDefensiveProcChances(float &ProcBonus, float &ProcChance, uint16 hand = MainPrimary, Mob *on = nullptr);
virtual float GetSpecialProcChances(uint16 hand); virtual float GetSpecialProcChances(uint16 hand);
virtual float GetAssassinateProcChances(uint16 ReuseTime); virtual float GetAssassinateProcChances(uint16 ReuseTime);
virtual float GetSkillProcChances(uint16 ReuseTime, uint16 hand = 0); virtual float GetSkillProcChances(uint16 ReuseTime, uint16 hand = 0); // hand = MainCharm?
uint16 GetWeaponSpeedbyHand(uint16 hand); uint16 GetWeaponSpeedbyHand(uint16 hand);
int GetWeaponDamage(Mob *against, const Item_Struct *weapon_item); int GetWeaponDamage(Mob *against, const Item_Struct *weapon_item);
int GetWeaponDamage(Mob *against, const ItemInst *weapon_item, uint32 *hate = nullptr); int GetWeaponDamage(Mob *against, const ItemInst *weapon_item, uint32 *hate = nullptr);

2
zone/npc.h
View File

@ -104,7 +104,7 @@ public:
//abstract virtual function implementations requird by base abstract class //abstract virtual function implementations requird by base abstract class
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill); virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill);
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false); virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false);
virtual bool Attack(Mob* other, int Hand = 13, bool FromRiposte = false, bool IsStrikethrough = false, virtual bool Attack(Mob* other, int Hand = MainPrimary, bool FromRiposte = false, bool IsStrikethrough = false,
bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr); bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr);
virtual bool HasRaid() { return false; } virtual bool HasRaid() { return false; }
virtual bool HasGroup() { return false; } virtual bool HasGroup() { return false; }

2
zone/perl_mob.cpp
View File

@ -872,7 +872,7 @@ XS(XS_Mob_Attack)
Perl_croak(aTHX_ "other is nullptr, avoiding crash."); Perl_croak(aTHX_ "other is nullptr, avoiding crash.");
if (items < 3) if (items < 3)
Hand = 13; Hand = MainPrimary;
else { else {
Hand = (int)SvIV(ST(2)); Hand = (int)SvIV(ST(2));
} }

4
zone/questmgr.cpp
View File

@ -2429,12 +2429,12 @@ int QuestManager::collectitems(uint32 item_id, bool remove)
int quantity = 0; int quantity = 0;
int slot_id; int slot_id;
for (slot_id = 22; slot_id <= 29; ++slot_id) for (slot_id = EmuConstants::GENERAL_BEGIN; slot_id <= EmuConstants::GENERAL_END; ++slot_id)
{ {
quantity += collectitems_processSlot(slot_id, item_id, remove); quantity += collectitems_processSlot(slot_id, item_id, remove);
} }
for (slot_id = 251; slot_id <= 330; ++slot_id) for (slot_id = EmuConstants::GENERAL_BAGS_BEGIN; slot_id <= EmuConstants::GENERAL_BAGS_END; ++slot_id)
{ {
quantity += collectitems_processSlot(slot_id, item_id, remove); quantity += collectitems_processSlot(slot_id, item_id, remove);
} }

36
zone/special_attacks.cpp
View File

@ -131,7 +131,7 @@ void Mob::DoSpecialAttackDamage(Mob *who, SkillUseTypes skill, int32 max_damage,
min_damage += min_damage * GetMeleeMinDamageMod_SE(skill) / 100; min_damage += min_damage * GetMeleeMinDamageMod_SE(skill) / 100;
if(HitChance && !who->CheckHitChance(this, skill, 13)) if(HitChance && !who->CheckHitChance(this, skill, MainPrimary))
max_damage = 0; max_damage = 0;
else{ else{
@ -570,7 +570,7 @@ void Mob::TryBackstab(Mob *other, int ReuseTime) {
CastToClient()->CheckIncreaseSkill(SkillBackstab, other, 10); CastToClient()->CheckIncreaseSkill(SkillBackstab, other, 10);
} }
else { //We do a single regular attack if we attack from the front without chaotic stab else { //We do a single regular attack if we attack from the front without chaotic stab
Attack(other, 13); Attack(other, MainPrimary);
} }
} }
@ -817,7 +817,7 @@ void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Item
if (!CanDoSpecialAttack(other)) if (!CanDoSpecialAttack(other))
return; return;
if (!other->CheckHitChance(this, SkillArchery, 13,chance_mod)) { if (!other->CheckHitChance(this, SkillArchery, MainPrimary, chance_mod)) {
mlog(COMBAT__RANGED, "Ranged attack missed %s.", other->GetName()); mlog(COMBAT__RANGED, "Ranged attack missed %s.", other->GetName());
other->Damage(this, 0, SPELL_UNKNOWN, SkillArchery); other->Damage(this, 0, SPELL_UNKNOWN, SkillArchery);
} else { } else {
@ -939,27 +939,27 @@ void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Item
if (ReuseTime) if (ReuseTime)
TrySkillProc(other, SkillArchery, ReuseTime); TrySkillProc(other, SkillArchery, ReuseTime);
else else
TrySkillProc(other, SkillArchery, 0, true, 11); TrySkillProc(other, SkillArchery, 0, true, MainRange);
} }
} }
//try proc on hits and misses //try proc on hits and misses
if((RangeWeapon != nullptr) && GetTarget() && other && !other->HasDied()) if((RangeWeapon != nullptr) && GetTarget() && other && !other->HasDied())
{ {
TryWeaponProc(RangeWeapon, other, 11); TryWeaponProc(RangeWeapon, other, MainRange);
} }
//Arrow procs because why not? //Arrow procs because why not?
if((Ammo != NULL) && GetTarget() && other && !other->HasDied()) if((Ammo != NULL) && GetTarget() && other && !other->HasDied())
{ {
TryWeaponProc(Ammo, other, 11); TryWeaponProc(Ammo, other, MainRange);
} }
if (HasSkillProcs() && GetTarget() && other && !other->HasDied()){ if (HasSkillProcs() && GetTarget() && other && !other->HasDied()){
if (ReuseTime) if (ReuseTime)
TrySkillProc(other, SkillArchery, ReuseTime); TrySkillProc(other, SkillArchery, ReuseTime);
else else
TrySkillProc(other, SkillArchery, 0, false, 11); TrySkillProc(other, SkillArchery, 0, false, MainRange);
} }
} }
@ -1028,7 +1028,7 @@ void NPC::RangedAttack(Mob* other)
FaceTarget(other); FaceTarget(other);
if (!other->CheckHitChance(this, skillinuse, 11, GetSpecialAbilityParam(SPECATK_RANGED_ATK, 2))) if (!other->CheckHitChance(this, skillinuse, MainRange, GetSpecialAbilityParam(SPECATK_RANGED_ATK, 2)))
{ {
mlog(COMBAT__RANGED, "Ranged attack missed %s.", other->GetName()); mlog(COMBAT__RANGED, "Ranged attack missed %s.", other->GetName());
other->Damage(this, 0, SPELL_UNKNOWN, skillinuse); other->Damage(this, 0, SPELL_UNKNOWN, skillinuse);
@ -1069,15 +1069,15 @@ void NPC::RangedAttack(Mob* other)
other->Damage(this, TotalDmg, SPELL_UNKNOWN, skillinuse); other->Damage(this, TotalDmg, SPELL_UNKNOWN, skillinuse);
if (TotalDmg > 0 && HasSkillProcSuccess() && GetTarget() && !other->HasDied()) if (TotalDmg > 0 && HasSkillProcSuccess() && GetTarget() && !other->HasDied())
TrySkillProc(other, skillinuse, 0, true, 11); TrySkillProc(other, skillinuse, 0, true, MainRange);
} }
//try proc on hits and misses //try proc on hits and misses
if(other && !other->HasDied()) if(other && !other->HasDied())
TrySpellProc(nullptr, (const Item_Struct*)nullptr, other, 11); TrySpellProc(nullptr, (const Item_Struct*)nullptr, other, MainRange);
if (HasSkillProcs() && other && !other->HasDied()) if (HasSkillProcs() && other && !other->HasDied())
TrySkillProc(other, skillinuse, 0, false, 11); TrySkillProc(other, skillinuse, 0, false, MainRange);
CommonBreakInvisible(); CommonBreakInvisible();
} }
@ -1200,7 +1200,7 @@ void Mob::DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Ite
if (!CanDoSpecialAttack(other)) if (!CanDoSpecialAttack(other))
return; return;
if (!other->CheckHitChance(this, SkillThrowing, 13, chance_mod)){ if (!other->CheckHitChance(this, SkillThrowing, MainPrimary, chance_mod)){
mlog(COMBAT__RANGED, "Ranged attack missed %s.", other->GetName()); mlog(COMBAT__RANGED, "Ranged attack missed %s.", other->GetName());
other->Damage(this, 0, SPELL_UNKNOWN, SkillThrowing); other->Damage(this, 0, SPELL_UNKNOWN, SkillThrowing);
} else { } else {
@ -1251,18 +1251,18 @@ void Mob::DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Ite
if (ReuseTime) if (ReuseTime)
TrySkillProc(other, SkillThrowing, ReuseTime); TrySkillProc(other, SkillThrowing, ReuseTime);
else else
TrySkillProc(other, SkillThrowing, 0, true, 11); TrySkillProc(other, SkillThrowing, 0, true, MainRange);
} }
} }
if((RangeWeapon != nullptr) && GetTarget() && other && (other->GetHP() > -10)) if((RangeWeapon != nullptr) && GetTarget() && other && (other->GetHP() > -10))
TryWeaponProc(RangeWeapon, other, 11); TryWeaponProc(RangeWeapon, other, MainRange);
if (HasSkillProcs() && GetTarget() && other && !other->HasDied()){ if (HasSkillProcs() && GetTarget() && other && !other->HasDied()){
if (ReuseTime) if (ReuseTime)
TrySkillProc(other, SkillThrowing, ReuseTime); TrySkillProc(other, SkillThrowing, ReuseTime);
else else
TrySkillProc(other, SkillThrowing, 0, false, 11); TrySkillProc(other, SkillThrowing, 0, false, MainRange);
} }
} }
@ -1987,7 +1987,7 @@ uint32 Mob::TryHeadShot(Mob* defender, SkillUseTypes skillInUse) {
if(HeadShot_Dmg && HeadShot_Level && (defender->GetLevel() <= HeadShot_Level)){ if(HeadShot_Dmg && HeadShot_Level && (defender->GetLevel() <= HeadShot_Level)){
float ProcChance = GetSpecialProcChances(11); float ProcChance = GetSpecialProcChances(MainRange);
if(ProcChance > MakeRandomFloat(0,1)) if(ProcChance > MakeRandomFloat(0,1))
return HeadShot_Dmg; return HeadShot_Dmg;
} }
@ -2050,7 +2050,7 @@ uint32 Mob::TryAssassinate(Mob* defender, SkillUseTypes skillInUse, uint16 Reuse
float ProcChance = 0.0f; float ProcChance = 0.0f;
if (skillInUse == SkillThrowing) if (skillInUse == SkillThrowing)
ProcChance = GetSpecialProcChances(11); ProcChance = GetSpecialProcChances(MainRange);
else else
ProcChance = GetAssassinateProcChances(ReuseTime); ProcChance = GetAssassinateProcChances(ReuseTime);
@ -2099,7 +2099,7 @@ void Mob::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillUseTypes
int damage = 0; int damage = 0;
int32 hate = 0; int32 hate = 0;
int Hand = 13; int Hand = MainPrimary;
if (hate == 0 && weapon_damage > 1) hate = weapon_damage; if (hate == 0 && weapon_damage > 1) hate = weapon_damage;
if(weapon_damage > 0){ if(weapon_damage > 0){

4
zone/spell_effects.cpp
View File

@ -2200,7 +2200,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial)
snprintf(effect_desc, _EDLEN, "Rampage"); snprintf(effect_desc, _EDLEN, "Rampage");
#endif #endif
if(caster) if(caster)
entity_list.AEAttack(caster, 30, 13, 0, true); // on live wars dont get a duration ramp, its a one shot deal entity_list.AEAttack(caster, 30, MainPrimary, 0, true); // on live wars dont get a duration ramp, its a one shot deal
break; break;
} }
@ -5264,7 +5264,7 @@ int16 Client::GetFocusEffect(focusType type, uint16 spell_id) {
} }
//Tribute Focus //Tribute Focus
for(int x = TRIBUTE_SLOT_START; x < (TRIBUTE_SLOT_START + MAX_PLAYER_TRIBUTES); ++x) for(int x = EmuConstants::TRIBUTE_BEGIN; x <= EmuConstants::TRIBUTE_END; ++x)
{ {
TempItem = nullptr; TempItem = nullptr;
ItemInst* ins = GetInv().GetItem(x); ItemInst* ins = GetInv().GetItem(x);

4
zone/trading.cpp
View File

@ -146,13 +146,13 @@ void Trade::SendItemData(const ItemInst* inst, int16 dest_slot_id)
Client* with = mob->CastToClient(); Client* with = mob->CastToClient();
Client* trader = owner->CastToClient(); Client* trader = owner->CastToClient();
if (with && with->IsClient()) { if (with && with->IsClient()) {
with->SendItemPacket(dest_slot_id -IDX_TRADE,inst,ItemPacketTradeView); with->SendItemPacket(dest_slot_id - EmuConstants::TRADE_BEGIN, inst, ItemPacketTradeView);
if (inst->GetItem()->ItemClass == 1) { if (inst->GetItem()->ItemClass == 1) {
for (uint16 i=0; i<10; i++) { for (uint16 i=0; i<10; i++) {
uint16 bagslot_id = Inventory::CalcSlotId(dest_slot_id, i); uint16 bagslot_id = Inventory::CalcSlotId(dest_slot_id, i);
const ItemInst* bagitem = trader->GetInv().GetItem(bagslot_id); const ItemInst* bagitem = trader->GetInv().GetItem(bagslot_id);
if (bagitem) { if (bagitem) {
with->SendItemPacket(bagslot_id-IDX_TRADE,bagitem,ItemPacketTradeView); with->SendItemPacket(bagslot_id - EmuConstants::TRADE_BEGIN, bagitem, ItemPacketTradeView);
} }
} }
} }

30
zone/tribute.cpp
View File

@ -66,7 +66,7 @@ void Client::ToggleTribute(bool enabled) {
int r; int r;
uint32 cost = 0; uint32 cost = 0;
uint32 level = GetLevel(); uint32 level = GetLevel();
for(r = 0; r < MAX_PLAYER_TRIBUTES; r++) { for(r = 0; r < EmuConstants::TRIBUTE_SIZE; r++) {
uint32 tid = m_pp.tributes[r].tribute; uint32 tid = m_pp.tributes[r].tribute;
if(tid == TRIBUTE_NONE) if(tid == TRIBUTE_NONE)
continue; continue;
@ -119,7 +119,7 @@ void Client::DoTributeUpdate() {
tis->tribute_master_id = tribute_master_id; //Dont know what this is for tis->tribute_master_id = tribute_master_id; //Dont know what this is for
int r; int r;
for(r = 0; r < MAX_PLAYER_TRIBUTES; r++) { for(r = 0; r < EmuConstants::TRIBUTE_SIZE; r++) {
if(m_pp.tributes[r].tribute != TRIBUTE_NONE) { if(m_pp.tributes[r].tribute != TRIBUTE_NONE) {
tis->tributes[r] = m_pp.tributes[r].tribute; tis->tributes[r] = m_pp.tributes[r].tribute;
tis->tiers[r] = m_pp.tributes[r].tier; tis->tiers[r] = m_pp.tributes[r].tier;
@ -134,24 +134,24 @@ void Client::DoTributeUpdate() {
if(m_pp.tribute_active) { if(m_pp.tribute_active) {
//send and equip tribute items... //send and equip tribute items...
for(r = 0; r < MAX_PLAYER_TRIBUTES; r++) { for(r = 0; r < EmuConstants::TRIBUTE_SIZE; r++) {
uint32 tid = m_pp.tributes[r].tribute; uint32 tid = m_pp.tributes[r].tribute;
if(tid == TRIBUTE_NONE) { if(tid == TRIBUTE_NONE) {
if(m_inv[TRIBUTE_SLOT_START+r]) if(m_inv[EmuConstants::TRIBUTE_BEGIN + r])
DeleteItemInInventory(TRIBUTE_SLOT_START+r, 0, false); DeleteItemInInventory(EmuConstants::TRIBUTE_BEGIN + r, 0, false);
continue; continue;
} }
if(tribute_list.count(tid) != 1) { if(tribute_list.count(tid) != 1) {
if(m_inv[TRIBUTE_SLOT_START+r]) if (m_inv[EmuConstants::TRIBUTE_BEGIN + r])
DeleteItemInInventory(TRIBUTE_SLOT_START+r, 0, false); DeleteItemInInventory(EmuConstants::TRIBUTE_BEGIN + r, 0, false);
continue; continue;
} }
//sanity check //sanity check
if(m_pp.tributes[r].tier >= MAX_TRIBUTE_TIERS) { if(m_pp.tributes[r].tier >= MAX_TRIBUTE_TIERS) {
if(m_inv[TRIBUTE_SLOT_START+r]) if (m_inv[EmuConstants::TRIBUTE_BEGIN + r])
DeleteItemInInventory(TRIBUTE_SLOT_START+r, 0, false); DeleteItemInInventory(EmuConstants::TRIBUTE_BEGIN + r, 0, false);
m_pp.tributes[r].tier = 0; m_pp.tributes[r].tier = 0;
continue; continue;
} }
@ -165,15 +165,15 @@ void Client::DoTributeUpdate() {
if(inst == nullptr) if(inst == nullptr)
continue; continue;
PutItemInInventory(TRIBUTE_SLOT_START+r, *inst, false); PutItemInInventory(EmuConstants::TRIBUTE_BEGIN + r, *inst, false);
SendItemPacket(TRIBUTE_SLOT_START+r, inst, ItemPacketTributeItem); SendItemPacket(EmuConstants::TRIBUTE_BEGIN + r, inst, ItemPacketTributeItem);
safe_delete(inst); safe_delete(inst);
} }
} else { } else {
//unequip tribute items... //unequip tribute items...
for(r = 0; r < MAX_PLAYER_TRIBUTES; r++) { for(r = 0; r < EmuConstants::TRIBUTE_SIZE; r++) {
if(m_inv[TRIBUTE_SLOT_START+r]) if (m_inv[EmuConstants::TRIBUTE_BEGIN + r])
DeleteItemInInventory(TRIBUTE_SLOT_START+r, 0, false); DeleteItemInInventory(EmuConstants::TRIBUTE_BEGIN + r, 0, false);
} }
} }
CalcBonuses(); CalcBonuses();
@ -192,7 +192,7 @@ void Client::SendTributeTimer() {
void Client::ChangeTributeSettings(TributeInfo_Struct *t) { void Client::ChangeTributeSettings(TributeInfo_Struct *t) {
int r; int r;
for(r = 0; r < MAX_PLAYER_TRIBUTES; r++) { for(r = 0; r < EmuConstants::TRIBUTE_SIZE; r++) {
m_pp.tributes[r].tribute = TRIBUTE_NONE; m_pp.tributes[r].tribute = TRIBUTE_NONE;