pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2026-05-31 13:16:39 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Rename Larion -> Laurion; later we'll rename the branch too. Make sure to update your patch file name.

Browse Source
This commit is contained in:
KimLS
2024-11-25 20:25:09 -08:00
parent 4e53f5464f
commit 11636225b1
20 changed files with 298 additions and 298 deletions
Download Patch File Download Diff File Expand all files Collapse all files
common/patches/larion.cpp → common/patches/laurion.cpp
+175 -175
View File
@@ -20,7 +20,7 @@
#include "../global_define.h"
#include "../eqemu_config.h"
#include "../eqemu_logsys.h"
#include "larion.h"
#include "laurion.h"
#include "../opcodemgr.h"
#include "../eq_stream_ident.h"
@@ -30,7 +30,7 @@
#include "../misc_functions.h"
#include "../strings.h"
#include "../inventory_profile.h"
#include "larion_structs.h"
#include "laurion_structs.h"
#include "../rulesys.h"
#include "../path_manager.h"
#include "../classes.h"
@@ -43,25 +43,25 @@
#include <cassert>
#include <cinttypes>
namespace Larion
namespace Laurion
{
static const char* name = "Larion";
static const char* name = "Laurion";
static OpcodeManager* opcodes = nullptr;
static Strategy struct_strategy;
void SerializeItem(SerializeBuffer &buffer, const EQ::ItemInstance* inst, int16 slot_id, uint8 depth, ItemPacketType packet_type);
// server to client inventory location converters
static inline structs::InventorySlot_Struct ServerToLarionSlot(uint32 server_slot);
static inline structs::InventorySlot_Struct ServerToLarionCorpseSlot(uint32 server_corpse_slot);
static inline uint32 ServerToLarionCorpseMainSlot(uint32 server_corpse_slot);
static inline structs::TypelessInventorySlot_Struct ServerToLarionTypelessSlot(uint32 server_slot, int16 server_type);
static inline structs::InventorySlot_Struct ServerToLaurionSlot(uint32 server_slot);
static inline structs::InventorySlot_Struct ServerToLaurionCorpseSlot(uint32 server_corpse_slot);
static inline uint32 ServerToLaurionCorpseMainSlot(uint32 server_corpse_slot);
static inline structs::TypelessInventorySlot_Struct ServerToLaurionTypelessSlot(uint32 server_slot, int16 server_type);
// client to server inventory location converters
static inline uint32 LarionToServerSlot(structs::InventorySlot_Struct larion_slot);
static inline uint32 LarionToServerCorpseSlot(structs::InventorySlot_Struct larion_corpse_slot);
static inline uint32 LarionToServerCorpseMainSlot(uint32 larion_corpse_slot);
static inline uint32 LarionToServerTypelessSlot(structs::TypelessInventorySlot_Struct larion_slot, int16 larion_type);
static inline uint32 LaurionToServerSlot(structs::InventorySlot_Struct laurion_slot);
static inline uint32 LaurionToServerCorpseSlot(structs::InventorySlot_Struct laurion_corpse_slot);
static inline uint32 LaurionToServerCorpseMainSlot(uint32 laurion_corpse_slot);
static inline uint32 LaurionToServerTypelessSlot(structs::TypelessInventorySlot_Struct laurion_slot, int16 laurion_type);
void Register(EQStreamIdentifier& into)
{
@@ -120,7 +120,7 @@ namespace Larion
{
//all opcodes default to passthrough.
#include "ss_register.h"
#include "larion_ops.h"
#include "laurion_ops.h"
}
std::string Strategy::Describe() const
@@ -133,7 +133,7 @@ namespace Larion
const EQ::versions::ClientVersion Strategy::ClientVersion() const
{
return EQ::versions::ClientVersion::Larion;
return EQ::versions::ClientVersion::Laurion;
}
#include "ss_define.h"
@@ -514,7 +514,7 @@ namespace Larion
if (sas->type != AppearanceType::Size)
{
//larion struct is different than rof2's but the idea is the same
//laurion struct is different than rof2's but the idea is the same
auto outapp = new EQApplicationPacket(OP_SpawnAppearance, sizeof(structs::SpawnAppearance_Struct));
structs::SpawnAppearance_Struct *eq = (structs::SpawnAppearance_Struct*)outapp->pBuffer;
@@ -2714,7 +2714,7 @@ namespace Larion
int r;
for (r = 0; r < 29; r++) {
// Size 68 in Larion
// Size 68 in Laurion
IN(filters[r]);
}
@@ -3328,10 +3328,10 @@ namespace Larion
structs::InventorySlot_Struct slot_id{};
switch (packet_type) {
case ItemPacketLoot:
slot_id = ServerToLarionCorpseSlot(slot_id_in);
slot_id = ServerToLaurionCorpseSlot(slot_id_in);
break;
default:
slot_id = ServerToLarionSlot(slot_id_in);
slot_id = ServerToLaurionSlot(slot_id_in);
break;
}
@@ -3499,156 +3499,156 @@ namespace Larion
buffer.WriteInt32(0); //unsupported atm
}
static inline structs::InventorySlot_Struct ServerToLarionSlot(uint32 server_slot)
static inline structs::InventorySlot_Struct ServerToLaurionSlot(uint32 server_slot)
{
structs::InventorySlot_Struct LarionSlot;
LarionSlot.Type = invtype::TYPE_INVALID;
LarionSlot.Slot = invslot::SLOT_INVALID;
LarionSlot.SubIndex = invbag::SLOT_INVALID;
LarionSlot.AugIndex = invaug::SOCKET_INVALID;
structs::InventorySlot_Struct LaurionSlot;
LaurionSlot.Type = invtype::TYPE_INVALID;
LaurionSlot.Slot = invslot::SLOT_INVALID;
LaurionSlot.SubIndex = invbag::SLOT_INVALID;
LaurionSlot.AugIndex = invaug::SOCKET_INVALID;
uint32 TempSlot = EQ::invslot::SLOT_INVALID;
if (server_slot < EQ::invtype::POSSESSIONS_SIZE) {
LarionSlot.Type = invtype::typePossessions;
LarionSlot.Slot = server_slot;
LaurionSlot.Type = invtype::typePossessions;
LaurionSlot.Slot = server_slot;
}
else if (server_slot <= EQ::invbag::CURSOR_BAG_END && server_slot >= EQ::invbag::GENERAL_BAGS_BEGIN) {
TempSlot = server_slot - EQ::invbag::GENERAL_BAGS_BEGIN;
LarionSlot.Type = invtype::typePossessions;
LarionSlot.Slot = invslot::GENERAL_BEGIN + (TempSlot / EQ::invbag::SLOT_COUNT);
LarionSlot.SubIndex = TempSlot - ((LarionSlot.Slot - invslot::GENERAL_BEGIN) * EQ::invbag::SLOT_COUNT);
LaurionSlot.Type = invtype::typePossessions;
LaurionSlot.Slot = invslot::GENERAL_BEGIN + (TempSlot / EQ::invbag::SLOT_COUNT);
LaurionSlot.SubIndex = TempSlot - ((LaurionSlot.Slot - invslot::GENERAL_BEGIN) * EQ::invbag::SLOT_COUNT);
}
else if (server_slot <= EQ::invslot::TRIBUTE_END && server_slot >= EQ::invslot::TRIBUTE_BEGIN) {
LarionSlot.Type = invtype::typeTribute;
LarionSlot.Slot = server_slot - EQ::invslot::TRIBUTE_BEGIN;
LaurionSlot.Type = invtype::typeTribute;
LaurionSlot.Slot = server_slot - EQ::invslot::TRIBUTE_BEGIN;
}
else if (server_slot <= EQ::invslot::GUILD_TRIBUTE_END && server_slot >= EQ::invslot::GUILD_TRIBUTE_BEGIN) {
LarionSlot.Type = invtype::typeGuildTribute;
LarionSlot.Slot = server_slot - EQ::invslot::GUILD_TRIBUTE_BEGIN;
LaurionSlot.Type = invtype::typeGuildTribute;
LaurionSlot.Slot = server_slot - EQ::invslot::GUILD_TRIBUTE_BEGIN;
}
else if (server_slot == EQ::invslot::SLOT_TRADESKILL_EXPERIMENT_COMBINE) {
LarionSlot.Type = invtype::typeWorld;
LaurionSlot.Type = invtype::typeWorld;
}
else if (server_slot <= EQ::invslot::BANK_END && server_slot >= EQ::invslot::BANK_BEGIN) {
LarionSlot.Type = invtype::typeBank;
LarionSlot.Slot = server_slot - EQ::invslot::BANK_BEGIN;
LaurionSlot.Type = invtype::typeBank;
LaurionSlot.Slot = server_slot - EQ::invslot::BANK_BEGIN;
}
else if (server_slot <= EQ::invbag::BANK_BAGS_END && server_slot >= EQ::invbag::BANK_BAGS_BEGIN) {
TempSlot = server_slot - EQ::invbag::BANK_BAGS_BEGIN;
LarionSlot.Type = invtype::typeBank;
LarionSlot.Slot = TempSlot / EQ::invbag::SLOT_COUNT;
LarionSlot.SubIndex = TempSlot - (LarionSlot.Slot * EQ::invbag::SLOT_COUNT);
LaurionSlot.Type = invtype::typeBank;
LaurionSlot.Slot = TempSlot / EQ::invbag::SLOT_COUNT;
LaurionSlot.SubIndex = TempSlot - (LaurionSlot.Slot * EQ::invbag::SLOT_COUNT);
}
else if (server_slot <= EQ::invslot::SHARED_BANK_END && server_slot >= EQ::invslot::SHARED_BANK_BEGIN) {
LarionSlot.Type = invtype::typeSharedBank;
LarionSlot.Slot = server_slot - EQ::invslot::SHARED_BANK_BEGIN;
LaurionSlot.Type = invtype::typeSharedBank;
LaurionSlot.Slot = server_slot - EQ::invslot::SHARED_BANK_BEGIN;
}
else if (server_slot <= EQ::invbag::SHARED_BANK_BAGS_END && server_slot >= EQ::invbag::SHARED_BANK_BAGS_BEGIN) {
TempSlot = server_slot - EQ::invbag::SHARED_BANK_BAGS_BEGIN;
LarionSlot.Type = invtype::typeSharedBank;
LarionSlot.Slot = TempSlot / EQ::invbag::SLOT_COUNT;
LarionSlot.SubIndex = TempSlot - (LarionSlot.Slot * EQ::invbag::SLOT_COUNT);
LaurionSlot.Type = invtype::typeSharedBank;
LaurionSlot.Slot = TempSlot / EQ::invbag::SLOT_COUNT;
LaurionSlot.SubIndex = TempSlot - (LaurionSlot.Slot * EQ::invbag::SLOT_COUNT);
}
else if (server_slot <= EQ::invslot::TRADE_END && server_slot >= EQ::invslot::TRADE_BEGIN) {
LarionSlot.Type = invtype::typeTrade;
LarionSlot.Slot = server_slot - EQ::invslot::TRADE_BEGIN;
LaurionSlot.Type = invtype::typeTrade;
LaurionSlot.Slot = server_slot - EQ::invslot::TRADE_BEGIN;
}
else if (server_slot <= EQ::invbag::TRADE_BAGS_END && server_slot >= EQ::invbag::TRADE_BAGS_BEGIN) {
TempSlot = server_slot - EQ::invbag::TRADE_BAGS_BEGIN;
LarionSlot.Type = invtype::typeTrade;
LarionSlot.Slot = TempSlot / EQ::invbag::SLOT_COUNT;
LarionSlot.SubIndex = TempSlot - (LarionSlot.Slot * EQ::invbag::SLOT_COUNT);
LaurionSlot.Type = invtype::typeTrade;
LaurionSlot.Slot = TempSlot / EQ::invbag::SLOT_COUNT;
LaurionSlot.SubIndex = TempSlot - (LaurionSlot.Slot * EQ::invbag::SLOT_COUNT);
}
else if (server_slot <= EQ::invslot::WORLD_END && server_slot >= EQ::invslot::WORLD_BEGIN) {
LarionSlot.Type = invtype::typeWorld;
LarionSlot.Slot = server_slot - EQ::invslot::WORLD_BEGIN;
LaurionSlot.Type = invtype::typeWorld;
LaurionSlot.Slot = server_slot - EQ::invslot::WORLD_BEGIN;
}
Log(Logs::Detail, Logs::Netcode, "Convert Server Slot %i to Larion Slot [%i, %i, %i, %i]",
server_slot, LarionSlot.Type, LarionSlot.Slot, LarionSlot.SubIndex, LarionSlot.AugIndex);
Log(Logs::Detail, Logs::Netcode, "Convert Server Slot %i to Laurion Slot [%i, %i, %i, %i]",
server_slot, LaurionSlot.Type, LaurionSlot.Slot, LaurionSlot.SubIndex, LaurionSlot.AugIndex);
return LarionSlot;
return LaurionSlot;
}
static inline structs::InventorySlot_Struct ServerToLarionCorpseSlot(uint32 server_corpse_slot)
static inline structs::InventorySlot_Struct ServerToLaurionCorpseSlot(uint32 server_corpse_slot)
{
structs::InventorySlot_Struct LarionSlot;
LarionSlot.Type = invtype::TYPE_INVALID;
LarionSlot.Slot = ServerToLarionCorpseMainSlot(server_corpse_slot);
LarionSlot.SubIndex = invbag::SLOT_INVALID;
LarionSlot.AugIndex = invaug::SOCKET_INVALID;
structs::InventorySlot_Struct LaurionSlot;
LaurionSlot.Type = invtype::TYPE_INVALID;
LaurionSlot.Slot = ServerToLaurionCorpseMainSlot(server_corpse_slot);
LaurionSlot.SubIndex = invbag::SLOT_INVALID;
LaurionSlot.AugIndex = invaug::SOCKET_INVALID;
if (LarionSlot.Slot != invslot::SLOT_INVALID)
LarionSlot.Type = invtype::typeCorpse;
if (LaurionSlot.Slot != invslot::SLOT_INVALID)
LaurionSlot.Type = invtype::typeCorpse;
Log(Logs::Detail, Logs::Netcode, "Convert Server Corpse Slot %i to Larion Corpse Slot [%i, %i, %i, %i]",
server_corpse_slot, LarionSlot.Type, LarionSlot.Slot, LarionSlot.SubIndex, LarionSlot.AugIndex);
Log(Logs::Detail, Logs::Netcode, "Convert Server Corpse Slot %i to Laurion Corpse Slot [%i, %i, %i, %i]",
server_corpse_slot, LaurionSlot.Type, LaurionSlot.Slot, LaurionSlot.SubIndex, LaurionSlot.AugIndex);
return LarionSlot;
return LaurionSlot;
}
static inline uint32 ServerToLarionCorpseMainSlot(uint32 server_corpse_slot)
static inline uint32 ServerToLaurionCorpseMainSlot(uint32 server_corpse_slot)
{
uint32 LarionSlot = invslot::SLOT_INVALID;
uint32 LaurionSlot = invslot::SLOT_INVALID;
if (server_corpse_slot <= EQ::invslot::CORPSE_END && server_corpse_slot >= EQ::invslot::CORPSE_BEGIN) {
LarionSlot = server_corpse_slot;
LaurionSlot = server_corpse_slot;
}
LogNetcode("Convert Server Corpse Slot [{}] to Larion Corpse Main Slot [{}]", server_corpse_slot, LarionSlot);
LogNetcode("Convert Server Corpse Slot [{}] to Laurion Corpse Main Slot [{}]", server_corpse_slot, LaurionSlot);
return LarionSlot;
return LaurionSlot;
}
static inline structs::TypelessInventorySlot_Struct ServerToLarionTypelessSlot(uint32 server_slot, int16 server_type)
static inline structs::TypelessInventorySlot_Struct ServerToLaurionTypelessSlot(uint32 server_slot, int16 server_type)
{
structs::TypelessInventorySlot_Struct LarionSlot;
LarionSlot.Slot = invslot::SLOT_INVALID;
LarionSlot.SubIndex = invbag::SLOT_INVALID;
LarionSlot.AugIndex = invaug::SOCKET_INVALID;
structs::TypelessInventorySlot_Struct LaurionSlot;
LaurionSlot.Slot = invslot::SLOT_INVALID;
LaurionSlot.SubIndex = invbag::SLOT_INVALID;
LaurionSlot.AugIndex = invaug::SOCKET_INVALID;
uint32 TempSlot = EQ::invslot::SLOT_INVALID;
if (server_type == EQ::invtype::typePossessions) {
if (server_slot < EQ::invtype::POSSESSIONS_SIZE) {
LarionSlot.Slot = server_slot;
LaurionSlot.Slot = server_slot;
}
else if (server_slot <= EQ::invbag::CURSOR_BAG_END && server_slot >= EQ::invbag::GENERAL_BAGS_BEGIN) {
TempSlot = server_slot - EQ::invbag::GENERAL_BAGS_BEGIN;
LarionSlot.Slot = invslot::GENERAL_BEGIN + (TempSlot / EQ::invbag::SLOT_COUNT);
LarionSlot.SubIndex = TempSlot - ((LarionSlot.Slot - invslot::GENERAL_BEGIN) * EQ::invbag::SLOT_COUNT);
LaurionSlot.Slot = invslot::GENERAL_BEGIN + (TempSlot / EQ::invbag::SLOT_COUNT);
LaurionSlot.SubIndex = TempSlot - ((LaurionSlot.Slot - invslot::GENERAL_BEGIN) * EQ::invbag::SLOT_COUNT);
}
}
Log(Logs::Detail, Logs::Netcode, "Convert Server Slot %i to Larion Typeless Slot [%i, %i, %i] (implied type: %i)",
server_slot, LarionSlot.Slot, LarionSlot.SubIndex, LarionSlot.AugIndex, server_type);
Log(Logs::Detail, Logs::Netcode, "Convert Server Slot %i to Laurion Typeless Slot [%i, %i, %i] (implied type: %i)",
server_slot, LaurionSlot.Slot, LaurionSlot.SubIndex, LaurionSlot.AugIndex, server_type);
return LarionSlot;
return LaurionSlot;
}
static inline uint32 LarionToServerSlot(structs::InventorySlot_Struct larion_slot)
static inline uint32 LaurionToServerSlot(structs::InventorySlot_Struct laurion_slot)
{
if (larion_slot.AugIndex < invaug::SOCKET_INVALID || larion_slot.AugIndex >= invaug::SOCKET_COUNT) {
Log(Logs::Detail, Logs::Netcode, "Convert Larion Slot [%i, %i, %i, %i] to Server Slot %i",
larion_slot.Type, larion_slot.Slot, larion_slot.SubIndex, larion_slot.AugIndex, EQ::invslot::SLOT_INVALID);
if (laurion_slot.AugIndex < invaug::SOCKET_INVALID || laurion_slot.AugIndex >= invaug::SOCKET_COUNT) {
Log(Logs::Detail, Logs::Netcode, "Convert Laurion Slot [%i, %i, %i, %i] to Server Slot %i",
laurion_slot.Type, laurion_slot.Slot, laurion_slot.SubIndex, laurion_slot.AugIndex, EQ::invslot::SLOT_INVALID);
return EQ::invslot::SLOT_INVALID;
}
@@ -3656,101 +3656,101 @@ namespace Larion
uint32 server_slot = EQ::invslot::SLOT_INVALID;
uint32 temp_slot = invslot::SLOT_INVALID;
switch (larion_slot.Type) {
switch (laurion_slot.Type) {
case invtype::typePossessions: {
if (larion_slot.Slot >= invslot::POSSESSIONS_BEGIN && larion_slot.Slot <= invslot::POSSESSIONS_END) {
if (larion_slot.SubIndex == invbag::SLOT_INVALID) {
server_slot = larion_slot.Slot;
if (laurion_slot.Slot >= invslot::POSSESSIONS_BEGIN && laurion_slot.Slot <= invslot::POSSESSIONS_END) {
if (laurion_slot.SubIndex == invbag::SLOT_INVALID) {
server_slot = laurion_slot.Slot;
}
else if (larion_slot.SubIndex >= invbag::SLOT_BEGIN && larion_slot.SubIndex <= invbag::SLOT_END) {
if (larion_slot.Slot < invslot::GENERAL_BEGIN)
else if (laurion_slot.SubIndex >= invbag::SLOT_BEGIN && laurion_slot.SubIndex <= invbag::SLOT_END) {
if (laurion_slot.Slot < invslot::GENERAL_BEGIN)
return EQ::invslot::SLOT_INVALID;
temp_slot = (larion_slot.Slot - invslot::GENERAL_BEGIN) * invbag::SLOT_COUNT;
server_slot = EQ::invbag::GENERAL_BAGS_BEGIN + temp_slot + larion_slot.SubIndex;
temp_slot = (laurion_slot.Slot - invslot::GENERAL_BEGIN) * invbag::SLOT_COUNT;
server_slot = EQ::invbag::GENERAL_BAGS_BEGIN + temp_slot + laurion_slot.SubIndex;
}
}
break;
}
case invtype::typeBank: {
if (larion_slot.Slot >= invslot::SLOT_BEGIN && larion_slot.Slot < invtype::BANK_SIZE) {
if (larion_slot.SubIndex == invbag::SLOT_INVALID) {
server_slot = EQ::invslot::BANK_BEGIN + larion_slot.Slot;
if (laurion_slot.Slot >= invslot::SLOT_BEGIN && laurion_slot.Slot < invtype::BANK_SIZE) {
if (laurion_slot.SubIndex == invbag::SLOT_INVALID) {
server_slot = EQ::invslot::BANK_BEGIN + laurion_slot.Slot;
}
else if (larion_slot.SubIndex >= invbag::SLOT_BEGIN && larion_slot.SubIndex <= invbag::SLOT_END) {
temp_slot = larion_slot.Slot * invbag::SLOT_COUNT;
server_slot = EQ::invbag::BANK_BAGS_BEGIN + temp_slot + larion_slot.SubIndex;
else if (laurion_slot.SubIndex >= invbag::SLOT_BEGIN && laurion_slot.SubIndex <= invbag::SLOT_END) {
temp_slot = laurion_slot.Slot * invbag::SLOT_COUNT;
server_slot = EQ::invbag::BANK_BAGS_BEGIN + temp_slot + laurion_slot.SubIndex;
}
}
break;
}
case invtype::typeSharedBank: {
if (larion_slot.Slot >= invslot::SLOT_BEGIN && larion_slot.Slot < invtype::SHARED_BANK_SIZE) {
if (larion_slot.SubIndex == invbag::SLOT_INVALID) {
server_slot = EQ::invslot::SHARED_BANK_BEGIN + larion_slot.Slot;
if (laurion_slot.Slot >= invslot::SLOT_BEGIN && laurion_slot.Slot < invtype::SHARED_BANK_SIZE) {
if (laurion_slot.SubIndex == invbag::SLOT_INVALID) {
server_slot = EQ::invslot::SHARED_BANK_BEGIN + laurion_slot.Slot;
}
else if (larion_slot.SubIndex >= invbag::SLOT_BEGIN && larion_slot.SubIndex <= invbag::SLOT_END) {
temp_slot = larion_slot.Slot * invbag::SLOT_COUNT;
server_slot = EQ::invbag::SHARED_BANK_BAGS_BEGIN + temp_slot + larion_slot.SubIndex;
else if (laurion_slot.SubIndex >= invbag::SLOT_BEGIN && laurion_slot.SubIndex <= invbag::SLOT_END) {
temp_slot = laurion_slot.Slot * invbag::SLOT_COUNT;
server_slot = EQ::invbag::SHARED_BANK_BAGS_BEGIN + temp_slot + laurion_slot.SubIndex;
}
}
break;
}
case invtype::typeTrade: {
if (larion_slot.Slot >= invslot::SLOT_BEGIN && larion_slot.Slot < invtype::TRADE_SIZE) {
if (larion_slot.SubIndex == invbag::SLOT_INVALID) {
server_slot = EQ::invslot::TRADE_BEGIN + larion_slot.Slot;
if (laurion_slot.Slot >= invslot::SLOT_BEGIN && laurion_slot.Slot < invtype::TRADE_SIZE) {
if (laurion_slot.SubIndex == invbag::SLOT_INVALID) {
server_slot = EQ::invslot::TRADE_BEGIN + laurion_slot.Slot;
}
else if (larion_slot.SubIndex >= invbag::SLOT_BEGIN && larion_slot.SubIndex <= invbag::SLOT_END) {
temp_slot = larion_slot.Slot * invbag::SLOT_COUNT;
server_slot = EQ::invbag::TRADE_BAGS_BEGIN + temp_slot + larion_slot.SubIndex;
else if (laurion_slot.SubIndex >= invbag::SLOT_BEGIN && laurion_slot.SubIndex <= invbag::SLOT_END) {
temp_slot = laurion_slot.Slot * invbag::SLOT_COUNT;
server_slot = EQ::invbag::TRADE_BAGS_BEGIN + temp_slot + laurion_slot.SubIndex;
}
}
break;
}
case invtype::typeWorld: {
if (larion_slot.Slot >= invslot::SLOT_BEGIN && larion_slot.Slot < invtype::WORLD_SIZE) {
server_slot = EQ::invslot::WORLD_BEGIN + larion_slot.Slot;
if (laurion_slot.Slot >= invslot::SLOT_BEGIN && laurion_slot.Slot < invtype::WORLD_SIZE) {
server_slot = EQ::invslot::WORLD_BEGIN + laurion_slot.Slot;
}
else if (larion_slot.Slot == invslot::SLOT_INVALID) {
else if (laurion_slot.Slot == invslot::SLOT_INVALID) {
server_slot = EQ::invslot::SLOT_TRADESKILL_EXPERIMENT_COMBINE;
}
break;
}
case invtype::typeLimbo: {
if (larion_slot.Slot >= invslot::SLOT_BEGIN && larion_slot.Slot < invtype::LIMBO_SIZE) {
if (laurion_slot.Slot >= invslot::SLOT_BEGIN && laurion_slot.Slot < invtype::LIMBO_SIZE) {
server_slot = EQ::invslot::slotCursor;
}
break;
}
case invtype::typeTribute: {
if (larion_slot.Slot >= invslot::SLOT_BEGIN && larion_slot.Slot < invtype::TRIBUTE_SIZE) {
server_slot = EQ::invslot::TRIBUTE_BEGIN + larion_slot.Slot;
if (laurion_slot.Slot >= invslot::SLOT_BEGIN && laurion_slot.Slot < invtype::TRIBUTE_SIZE) {
server_slot = EQ::invslot::TRIBUTE_BEGIN + laurion_slot.Slot;
}
break;
}
case invtype::typeGuildTribute: {
if (larion_slot.Slot >= invslot::SLOT_BEGIN && larion_slot.Slot < invtype::GUILD_TRIBUTE_SIZE) {
server_slot = EQ::invslot::GUILD_TRIBUTE_BEGIN + larion_slot.Slot;
if (laurion_slot.Slot >= invslot::SLOT_BEGIN && laurion_slot.Slot < invtype::GUILD_TRIBUTE_SIZE) {
server_slot = EQ::invslot::GUILD_TRIBUTE_BEGIN + laurion_slot.Slot;
}
break;
}
case invtype::typeCorpse: {
if (larion_slot.Slot >= invslot::CORPSE_BEGIN && larion_slot.Slot <= invslot::CORPSE_END) {
server_slot = larion_slot.Slot;
if (laurion_slot.Slot >= invslot::CORPSE_BEGIN && laurion_slot.Slot <= invslot::CORPSE_END) {
server_slot = laurion_slot.Slot;
}
break;
@@ -3761,48 +3761,48 @@ namespace Larion
}
}
Log(Logs::Detail, Logs::Netcode, "Convert Larion Slot [%i, %i, %i, %i] to Server Slot %i",
larion_slot.Type, larion_slot.Slot, larion_slot.SubIndex, larion_slot.AugIndex, server_slot);
Log(Logs::Detail, Logs::Netcode, "Convert Laurion Slot [%i, %i, %i, %i] to Server Slot %i",
laurion_slot.Type, laurion_slot.Slot, laurion_slot.SubIndex, laurion_slot.AugIndex, server_slot);
return server_slot;
}
static inline uint32 LarionToServerCorpseSlot(structs::InventorySlot_Struct larion_corpse_slot)
static inline uint32 LaurionToServerCorpseSlot(structs::InventorySlot_Struct laurion_corpse_slot)
{
uint32 ServerSlot = EQ::invslot::SLOT_INVALID;
if (larion_corpse_slot.Type != invtype::typeCorpse || larion_corpse_slot.SubIndex != invbag::SLOT_INVALID || larion_corpse_slot.AugIndex != invaug::SOCKET_INVALID) {
if (laurion_corpse_slot.Type != invtype::typeCorpse || laurion_corpse_slot.SubIndex != invbag::SLOT_INVALID || laurion_corpse_slot.AugIndex != invaug::SOCKET_INVALID) {
ServerSlot = EQ::invslot::SLOT_INVALID;
}
else {
ServerSlot = LarionToServerCorpseMainSlot(larion_corpse_slot.Slot);
ServerSlot = LaurionToServerCorpseMainSlot(laurion_corpse_slot.Slot);
}
Log(Logs::Detail, Logs::Netcode, "Convert Larion Slot [%i, %i, %i, %i] to Server Slot %i",
larion_corpse_slot.Type, larion_corpse_slot.Slot, larion_corpse_slot.SubIndex, larion_corpse_slot.AugIndex, ServerSlot);
Log(Logs::Detail, Logs::Netcode, "Convert Laurion Slot [%i, %i, %i, %i] to Server Slot %i",
laurion_corpse_slot.Type, laurion_corpse_slot.Slot, laurion_corpse_slot.SubIndex, laurion_corpse_slot.AugIndex, ServerSlot);
return ServerSlot;
}
static inline uint32 LarionToServerCorpseMainSlot(uint32 larion_corpse_slot)
static inline uint32 LaurionToServerCorpseMainSlot(uint32 laurion_corpse_slot)
{
uint32 ServerSlot = EQ::invslot::SLOT_INVALID;
if (larion_corpse_slot <= invslot::CORPSE_END && larion_corpse_slot >= invslot::CORPSE_BEGIN) {
ServerSlot = larion_corpse_slot;
if (laurion_corpse_slot <= invslot::CORPSE_END && laurion_corpse_slot >= invslot::CORPSE_BEGIN) {
ServerSlot = laurion_corpse_slot;
}
LogNetcode("Convert Larion Corpse Main Slot [{}] to Server Corpse Slot [{}]", larion_corpse_slot, ServerSlot);
LogNetcode("Convert Laurion Corpse Main Slot [{}] to Server Corpse Slot [{}]", laurion_corpse_slot, ServerSlot);
return ServerSlot;
}
static inline uint32 LarionToServerTypelessSlot(structs::TypelessInventorySlot_Struct larion_slot, int16 larion_type)
static inline uint32 LaurionToServerTypelessSlot(structs::TypelessInventorySlot_Struct laurion_slot, int16 laurion_type)
{
if (larion_slot.AugIndex < invaug::SOCKET_INVALID || larion_slot.AugIndex >= invaug::SOCKET_COUNT) {
Log(Logs::Detail, Logs::Netcode, "Convert Larion Typeless Slot [%i, %i, %i] (implied type: %i) to Server Slot %i",
larion_slot.Slot, larion_slot.SubIndex, larion_slot.AugIndex, larion_type, EQ::invslot::SLOT_INVALID);
if (laurion_slot.AugIndex < invaug::SOCKET_INVALID || laurion_slot.AugIndex >= invaug::SOCKET_COUNT) {
Log(Logs::Detail, Logs::Netcode, "Convert Laurion Typeless Slot [%i, %i, %i] (implied type: %i) to Server Slot %i",
laurion_slot.Slot, laurion_slot.SubIndex, laurion_slot.AugIndex, laurion_type, EQ::invslot::SLOT_INVALID);
return EQ::invslot::SLOT_INVALID;
}
@@ -3810,101 +3810,101 @@ namespace Larion
uint32 ServerSlot = EQ::invslot::SLOT_INVALID;
uint32 TempSlot = invslot::SLOT_INVALID;
switch (larion_type) {
switch (laurion_type) {
case invtype::typePossessions: {
if (larion_slot.Slot >= invslot::POSSESSIONS_BEGIN && larion_slot.Slot <= invslot::POSSESSIONS_END) {
if (larion_slot.SubIndex == invbag::SLOT_INVALID) {
ServerSlot = larion_slot.Slot;
if (laurion_slot.Slot >= invslot::POSSESSIONS_BEGIN && laurion_slot.Slot <= invslot::POSSESSIONS_END) {
if (laurion_slot.SubIndex == invbag::SLOT_INVALID) {
ServerSlot = laurion_slot.Slot;
}
else if (larion_slot.SubIndex >= invbag::SLOT_BEGIN && larion_slot.SubIndex <= invbag::SLOT_END) {
if (larion_slot.Slot < invslot::GENERAL_BEGIN)
else if (laurion_slot.SubIndex >= invbag::SLOT_BEGIN && laurion_slot.SubIndex <= invbag::SLOT_END) {
if (laurion_slot.Slot < invslot::GENERAL_BEGIN)
return EQ::invslot::SLOT_INVALID;
TempSlot = (larion_slot.Slot - invslot::GENERAL_BEGIN) * invbag::SLOT_COUNT;
ServerSlot = EQ::invbag::GENERAL_BAGS_BEGIN + TempSlot + larion_slot.SubIndex;
TempSlot = (laurion_slot.Slot - invslot::GENERAL_BEGIN) * invbag::SLOT_COUNT;
ServerSlot = EQ::invbag::GENERAL_BAGS_BEGIN + TempSlot + laurion_slot.SubIndex;
}
}
break;
}
case invtype::typeBank: {
if (larion_slot.Slot >= invslot::SLOT_BEGIN && larion_slot.Slot < invtype::BANK_SIZE) {
if (larion_slot.SubIndex == invbag::SLOT_INVALID) {
ServerSlot = EQ::invslot::BANK_BEGIN + larion_slot.Slot;
if (laurion_slot.Slot >= invslot::SLOT_BEGIN && laurion_slot.Slot < invtype::BANK_SIZE) {
if (laurion_slot.SubIndex == invbag::SLOT_INVALID) {
ServerSlot = EQ::invslot::BANK_BEGIN + laurion_slot.Slot;
}
else if (larion_slot.SubIndex >= invbag::SLOT_BEGIN && larion_slot.SubIndex <= invbag::SLOT_END) {
TempSlot = larion_slot.Slot * invbag::SLOT_COUNT;
ServerSlot = EQ::invbag::BANK_BAGS_BEGIN + TempSlot + larion_slot.SubIndex;
else if (laurion_slot.SubIndex >= invbag::SLOT_BEGIN && laurion_slot.SubIndex <= invbag::SLOT_END) {
TempSlot = laurion_slot.Slot * invbag::SLOT_COUNT;
ServerSlot = EQ::invbag::BANK_BAGS_BEGIN + TempSlot + laurion_slot.SubIndex;
}
}
break;
}
case invtype::typeSharedBank: {
if (larion_slot.Slot >= invslot::SLOT_BEGIN && larion_slot.Slot < invtype::SHARED_BANK_SIZE) {
if (larion_slot.SubIndex == invbag::SLOT_INVALID) {
ServerSlot = EQ::invslot::SHARED_BANK_BEGIN + larion_slot.Slot;
if (laurion_slot.Slot >= invslot::SLOT_BEGIN && laurion_slot.Slot < invtype::SHARED_BANK_SIZE) {
if (laurion_slot.SubIndex == invbag::SLOT_INVALID) {
ServerSlot = EQ::invslot::SHARED_BANK_BEGIN + laurion_slot.Slot;
}
else if (larion_slot.SubIndex >= invbag::SLOT_BEGIN && larion_slot.SubIndex <= invbag::SLOT_END) {
TempSlot = larion_slot.Slot * invbag::SLOT_COUNT;
ServerSlot = EQ::invbag::SHARED_BANK_BAGS_BEGIN + TempSlot + larion_slot.SubIndex;
else if (laurion_slot.SubIndex >= invbag::SLOT_BEGIN && laurion_slot.SubIndex <= invbag::SLOT_END) {
TempSlot = laurion_slot.Slot * invbag::SLOT_COUNT;
ServerSlot = EQ::invbag::SHARED_BANK_BAGS_BEGIN + TempSlot + laurion_slot.SubIndex;
}
}
break;
}
case invtype::typeTrade: {
if (larion_slot.Slot >= invslot::SLOT_BEGIN && larion_slot.Slot < invtype::TRADE_SIZE) {
if (larion_slot.SubIndex == invbag::SLOT_INVALID) {
ServerSlot = EQ::invslot::TRADE_BEGIN + larion_slot.Slot;
if (laurion_slot.Slot >= invslot::SLOT_BEGIN && laurion_slot.Slot < invtype::TRADE_SIZE) {
if (laurion_slot.SubIndex == invbag::SLOT_INVALID) {
ServerSlot = EQ::invslot::TRADE_BEGIN + laurion_slot.Slot;
}
else if (larion_slot.SubIndex >= invbag::SLOT_BEGIN && larion_slot.SubIndex <= invbag::SLOT_END) {
TempSlot = larion_slot.Slot * invbag::SLOT_COUNT;
ServerSlot = EQ::invbag::TRADE_BAGS_BEGIN + TempSlot + larion_slot.SubIndex;
else if (laurion_slot.SubIndex >= invbag::SLOT_BEGIN && laurion_slot.SubIndex <= invbag::SLOT_END) {
TempSlot = laurion_slot.Slot * invbag::SLOT_COUNT;
ServerSlot = EQ::invbag::TRADE_BAGS_BEGIN + TempSlot + laurion_slot.SubIndex;
}
}
break;
}
case invtype::typeWorld: {
if (larion_slot.Slot >= invslot::SLOT_BEGIN && larion_slot.Slot < invtype::WORLD_SIZE) {
ServerSlot = EQ::invslot::WORLD_BEGIN + larion_slot.Slot;
if (laurion_slot.Slot >= invslot::SLOT_BEGIN && laurion_slot.Slot < invtype::WORLD_SIZE) {
ServerSlot = EQ::invslot::WORLD_BEGIN + laurion_slot.Slot;
}
else if (larion_slot.Slot == invslot::SLOT_INVALID) {
else if (laurion_slot.Slot == invslot::SLOT_INVALID) {
ServerSlot = EQ::invslot::SLOT_TRADESKILL_EXPERIMENT_COMBINE;
}
break;
}
case invtype::typeLimbo: {
if (larion_slot.Slot >= invslot::SLOT_BEGIN && larion_slot.Slot < invtype::LIMBO_SIZE) {
if (laurion_slot.Slot >= invslot::SLOT_BEGIN && laurion_slot.Slot < invtype::LIMBO_SIZE) {
ServerSlot = EQ::invslot::slotCursor;
}
break;
}
case invtype::typeTribute: {
if (larion_slot.Slot >= invslot::SLOT_BEGIN && larion_slot.Slot < invtype::TRIBUTE_SIZE) {
ServerSlot = EQ::invslot::TRIBUTE_BEGIN + larion_slot.Slot;
if (laurion_slot.Slot >= invslot::SLOT_BEGIN && laurion_slot.Slot < invtype::TRIBUTE_SIZE) {
ServerSlot = EQ::invslot::TRIBUTE_BEGIN + laurion_slot.Slot;
}
break;
}
case invtype::typeGuildTribute: {
if (larion_slot.Slot >= invslot::SLOT_BEGIN && larion_slot.Slot < invtype::GUILD_TRIBUTE_SIZE) {
ServerSlot = EQ::invslot::GUILD_TRIBUTE_BEGIN + larion_slot.Slot;
if (laurion_slot.Slot >= invslot::SLOT_BEGIN && laurion_slot.Slot < invtype::GUILD_TRIBUTE_SIZE) {
ServerSlot = EQ::invslot::GUILD_TRIBUTE_BEGIN + laurion_slot.Slot;
}
break;
}
case invtype::typeCorpse: {
if (larion_slot.Slot >= invslot::CORPSE_BEGIN && larion_slot.Slot <= invslot::CORPSE_END) {
ServerSlot = larion_slot.Slot;
if (laurion_slot.Slot >= invslot::CORPSE_BEGIN && laurion_slot.Slot <= invslot::CORPSE_END) {
ServerSlot = laurion_slot.Slot;
}
break;
@@ -3915,9 +3915,9 @@ namespace Larion
}
}
Log(Logs::Detail, Logs::Netcode, "Convert Larion Typeless Slot [%i, %i, %i] (implied type: %i) to Server Slot %i",
larion_slot.Slot, larion_slot.SubIndex, larion_slot.AugIndex, larion_type, ServerSlot);
Log(Logs::Detail, Logs::Netcode, "Convert Laurion Typeless Slot [%i, %i, %i] (implied type: %i) to Server Slot %i",
laurion_slot.Slot, laurion_slot.SubIndex, laurion_slot.AugIndex, laurion_type, ServerSlot);
return ServerSlot;
}
} /*Larion*/
} /*Laurion*/
common/patches/larion.h → common/patches/laurion.h
+6 -6
View File
@@ -17,14 +17,14 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef COMMON_LARION_H
#define COMMON_LARION_H
#ifndef COMMON_LAURION_H
#define COMMON_LAURION_H
#include "../struct_strategy.h"
class EQStreamIdentifier;
namespace Larion
namespace Laurion
{
//these are the only public member of this namespace.
@@ -47,9 +47,9 @@ namespace Larion
//magic macro to declare our opcode processors
#include "ss_declare.h"
#include "larion_ops.h"
#include "laurion_ops.h"
};
}; /*Larion*/
}; /*Laurion*/
#endif /*COMMON_LARION_H*/
#endif /*COMMON_LAURION_H*/
common/patches/larion_limits.cpp → common/patches/laurion_limits.cpp
+8 -8
View File
@@ -17,12 +17,12 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "larion_limits.h"
#include "laurion_limits.h"
#include "../strings.h"
int16 Larion::invtype::GetInvTypeSize(int16 inv_type)
int16 Laurion::invtype::GetInvTypeSize(int16 inv_type)
{
switch (inv_type) {
case invtype::typePossessions:
@@ -80,7 +80,7 @@ int16 Larion::invtype::GetInvTypeSize(int16 inv_type)
}
}
const char* Larion::invtype::GetInvTypeName(int16 inv_type)
const char* Laurion::invtype::GetInvTypeName(int16 inv_type)
{
switch (inv_type) {
case invtype::TYPE_INVALID:
@@ -140,7 +140,7 @@ const char* Larion::invtype::GetInvTypeName(int16 inv_type)
}
}
bool Larion::invtype::IsInvTypePersistent(int16 inv_type)
bool Laurion::invtype::IsInvTypePersistent(int16 inv_type)
{
switch (inv_type) {
case invtype::typePossessions:
@@ -158,7 +158,7 @@ bool Larion::invtype::IsInvTypePersistent(int16 inv_type)
}
}
const char* Larion::invslot::GetInvPossessionsSlotName(int16 inv_slot)
const char* Laurion::invslot::GetInvPossessionsSlotName(int16 inv_slot)
{
switch (inv_slot) {
case invslot::SLOT_INVALID:
@@ -236,7 +236,7 @@ const char* Larion::invslot::GetInvPossessionsSlotName(int16 inv_slot)
}
}
const char* Larion::invslot::GetInvSlotName(int16 inv_type, int16 inv_slot)
const char* Laurion::invslot::GetInvSlotName(int16 inv_type, int16 inv_slot)
{
if (inv_type == invtype::typePossessions)
return invslot::GetInvPossessionsSlotName(inv_slot);
@@ -255,7 +255,7 @@ const char* Larion::invslot::GetInvSlotName(int16 inv_type, int16 inv_slot)
return ret_str.c_str();
}
const char* Larion::invbag::GetInvBagIndexName(int16 bag_index)
const char* Laurion::invbag::GetInvBagIndexName(int16 bag_index)
{
if (bag_index == invbag::SLOT_INVALID)
return "Invalid Bag";
@@ -269,7 +269,7 @@ const char* Larion::invbag::GetInvBagIndexName(int16 bag_index)
return ret_str.c_str();
}
const char* Larion::invaug::GetInvAugIndexName(int16 aug_index)
const char* Laurion::invaug::GetInvAugIndexName(int16 aug_index)
{
if (aug_index == invaug::SOCKET_INVALID)
return "Invalid Augment";
common/patches/larion_limits.h → common/patches/laurion_limits.h
+16 -16
View File
@@ -17,20 +17,20 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef COMMON_LARION_LIMITS_H
#define COMMON_LARION_LIMITS_H
#ifndef COMMON_LAURION_LIMITS_H
#define COMMON_LAURION_LIMITS_H
#include "../types.h"
#include "../emu_versions.h"
#include "../skills.h"
namespace Larion
namespace Laurion
{
const int16 IINVALID = -1;
const int16 INULL = 0;
namespace inventory {
inline EQ::versions::ClientVersion GetInventoryRef() { return EQ::versions::ClientVersion::Larion; }
inline EQ::versions::ClientVersion GetInventoryRef() { return EQ::versions::ClientVersion::Laurion; }
const bool ConcatenateInvTypeLimbo = false;
@@ -42,7 +42,7 @@ namespace Larion
} /*inventory*/
namespace invtype {
inline EQ::versions::ClientVersion GetInvTypeRef() { return EQ::versions::ClientVersion::Larion; }
inline EQ::versions::ClientVersion GetInvTypeRef() { return EQ::versions::ClientVersion::Laurion; }
namespace enum_ {
enum InventoryTypes : int16 {
@@ -133,7 +133,7 @@ namespace Larion
} /*invtype*/
namespace invslot {
inline EQ::versions::ClientVersion GetInvSlotRef() { return EQ::versions::ClientVersion::Larion; }
inline EQ::versions::ClientVersion GetInvSlotRef() { return EQ::versions::ClientVersion::Laurion; }
namespace enum_ {
enum InventorySlots : int16 {
@@ -212,7 +212,7 @@ namespace Larion
} /*invslot*/
namespace invbag {
inline EQ::versions::ClientVersion GetInvBagRef() { return EQ::versions::ClientVersion::Larion; }
inline EQ::versions::ClientVersion GetInvBagRef() { return EQ::versions::ClientVersion::Laurion; }
const int16 SLOT_INVALID = IINVALID;
const int16 SLOT_BEGIN = INULL;
@@ -224,7 +224,7 @@ namespace Larion
} /*invbag*/
namespace invaug {
inline EQ::versions::ClientVersion GetInvAugRef() { return EQ::versions::ClientVersion::Larion; }
inline EQ::versions::ClientVersion GetInvAugRef() { return EQ::versions::ClientVersion::Laurion; }
const int16 SOCKET_INVALID = IINVALID;
const int16 SOCKET_BEGIN = INULL;
@@ -236,7 +236,7 @@ namespace Larion
} /*invaug*/
namespace item {
inline EQ::versions::ClientVersion GetItemRef() { return EQ::versions::ClientVersion::Larion; }
inline EQ::versions::ClientVersion GetItemRef() { return EQ::versions::ClientVersion::Laurion; }
//enum Unknown : int { // looks like item class..but, RoF has it too - nothing in UF-
// Unknown1 = 0,
@@ -265,7 +265,7 @@ namespace Larion
} /*item*/
namespace profile {
inline EQ::versions::ClientVersion GetProfileRef() { return EQ::versions::ClientVersion::Larion; }
inline EQ::versions::ClientVersion GetProfileRef() { return EQ::versions::ClientVersion::Laurion; }
const int16 BANDOLIERS_SIZE = 20; // number of bandolier instances
const int16 BANDOLIER_ITEM_COUNT = 4; // number of equipment slots in bandolier instance
@@ -277,7 +277,7 @@ namespace Larion
} /*profile*/
namespace constants {
inline EQ::versions::ClientVersion GetConstantsRef() { return EQ::versions::ClientVersion::Larion; }
inline EQ::versions::ClientVersion GetConstantsRef() { return EQ::versions::ClientVersion::Laurion; }
const EQ::expansions::Expansion EXPANSION = EQ::expansions::Expansion::LS;
const uint32 EXPANSION_BIT = EQ::expansions::bitLS;
@@ -291,21 +291,21 @@ namespace Larion
} /*constants*/
namespace behavior {
inline EQ::versions::ClientVersion GetBehaviorRef() { return EQ::versions::ClientVersion::Larion; }
inline EQ::versions::ClientVersion GetBehaviorRef() { return EQ::versions::ClientVersion::Laurion; }
const bool CoinHasWeight = false;
} /*behavior*/
namespace skills {
inline EQ::versions::ClientVersion GetSkillsRef() { return EQ::versions::ClientVersion::Larion; }
inline EQ::versions::ClientVersion GetSkillsRef() { return EQ::versions::ClientVersion::Laurion; }
const size_t LastUsableSkill = EQ::skills::Skill2HPiercing;
} /*skills*/
namespace spells {
inline EQ::versions::ClientVersion GetSkillsRef() { return EQ::versions::ClientVersion::Larion; }
inline EQ::versions::ClientVersion GetSkillsRef() { return EQ::versions::ClientVersion::Laurion; }
enum class CastingSlot : uint32 {
Gem1 = 0,
@@ -341,6 +341,6 @@ namespace Larion
} /*spells*/
}; /* Larion */
}; /* Laurion */
#endif /*COMMON_LARION_LIMITS_H*/
#endif /*COMMON_LAURION_LIMITS_H*/
common/patches/larion_ops.h → common/patches/laurion_ops.h
View File
common/patches/larion_structs.h → common/patches/laurion_structs.h
+6 -6
View File
@@ -1,7 +1,7 @@
#ifndef LARION_STRUCTS_H_
#define LARION_STRUCTS_H_
#ifndef LAURION_STRUCTS_H_
#define LAURION_STRUCTS_H_
namespace Larion {
namespace Laurion {
namespace structs {
// constants
static const uint32 MAX_PP_AA_ARRAY = 300;
@@ -351,7 +351,7 @@ namespace Larion {
struct EnterWorld_Struct {
/*000*/ char name[64];
/*064*/ int32 unknown1;
/*068*/ int32 unknown2; //larion handles these differently so for now im just going to ignore them till i figure it out
/*068*/ int32 unknown2; //laurion handles these differently so for now im just going to ignore them till i figure it out
};
struct ZoneChange_Struct {
@@ -441,6 +441,6 @@ namespace Larion {
#pragma pack()
}; //end namespace structs
}; //end namespace larion
}; //end namespace laurion
#endif /*LARION_STRUCTS_H_*/
#endif /*LAURION_STRUCTS_H_*/
common/patches/patches.cpp
+3 -3
View File
@@ -26,7 +26,7 @@
#include "sod.h"
#include "rof.h"
#include "rof2.h"
#include "larion.h"
#include "laurion.h"
void RegisterAllPatches(EQStreamIdentifier &into)
{
@@ -36,7 +36,7 @@ void RegisterAllPatches(EQStreamIdentifier &into)
UF::Register(into);
RoF::Register(into);
RoF2::Register(into);
Larion::Register(into);
Laurion::Register(into);
}
void ReloadAllPatches()
@@ -47,5 +47,5 @@ void ReloadAllPatches()
UF::Reload();
RoF::Reload();
RoF2::Reload();
Larion::Reload();
Laurion::Reload();
}