Mirrored_Repos/DarkflameServer
1
0
Fork 0
mirror of https://github.com/DarkflameUniverse/DarkflameServer.git synced 2024-11-22 05:27:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/main' into first-draft-leaderboard-re-write

Browse Source
This commit is contained in:
David Markowitz 2023-05-02 15:49:23 -07:00
commit b5e3bd22e3
184 changed files with 1564 additions and 1132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
README.md
View File

@ -245,30 +245,11 @@ To connect to a server follow these steps:
* In the client directory, locate `boot.cfg`
* Open it in a text editor and locate where it says `AUTHSERVERIP=0:`
* Replace the contents after to `:` and the following `,` with what you configured as the server's public facing IP. For example `AUTHSERVERIP=0:localhost` for locally hosted servers
* Next locate the line `UGCUSE3DSERVICES=7:`
* Ensure the number after the 7 is a `0`
* Launch `legouniverse.exe`, through `wine` if on a Unix-like operating system
* Note that if you are on WSL2, you will need to configure the public IP in the server and client to be the IP of the WSL2 instance and not localhost, which can be found by running `ifconfig` in the terminal. Windows defaults to WSL1, so this will not apply to most users.
## Brick-By-Brick building
Should you choose to do any brick building, you will want to have some form of a http server that returns a 404 error since we are unable to emulate live User Generated Content at the moment. If you attempt to do any brick building without a 404 server running properly, you will be unable to load into your game. Python is the easiest way to do this, but any thing that returns a 404 should work fine.
* Note: the client hard codes this request on port 80.
<font size="4">**If you do not plan on doing any Brick Building, then you can skip this step.**</font>
The easiest way to do this is to install [python](https://www.python.org/downloads/).
### Allowing a user to build in Brick-by-Brick mode
Brick-By-Brick building requires `PATCHSERVERIP=0:` and `UGCSERVERIP=0:` in the `boot.cfg` to point to a HTTP server which always returns `HTTP 404 - Not Found` for all requests. This can be most easily achieved by pointing both of those variables to `localhost` while having running in the background.
Each client must have their own 404 server running if they are using a locally hosted 404 server.
```bash
# If on linux run this command. Because this is run on a port below 1024, binary network permissions are needed.
sudo python3 -m http.server 80
# If on windows one of the following will work when run through Powershell or Command Prompt assuming python is installed
python3 -m http.server 80
python http.server 80
py -m http.server 80
```
## Updating your server
To update your server to the latest version navigate to your cloned directory
```bash

17
dChatServer/ChatPacketHandler.cpp
View File

@ -12,6 +12,7 @@
#include "eAddFriendResponseType.h"
#include "RakString.h"
#include "dConfig.h"
#include "eObjectBits.h"
extern PlayerContainer playerContainer;
@ -45,8 +46,8 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
FriendData fd;
fd.isFTP = false; // not a thing in DLU
fd.friendID = res->getUInt(1);
GeneralUtils::SetBit(fd.friendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_PERSISTENT));
GeneralUtils::SetBit(fd.friendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_CHARACTER));
GeneralUtils::SetBit(fd.friendID, eObjectBits::PERSISTENT);
GeneralUtils::SetBit(fd.friendID, eObjectBits::CHARACTER);
fd.isBestFriend = res->getInt(2) == 3; //0 = friends, 1 = left_requested, 2 = right_requested, 3 = both_accepted - are now bffs
if (fd.isBestFriend) player->countOfBestFriends += 1;
@ -178,10 +179,10 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
bestFriendStatus = oldBestFriendStatus;
// Set the bits
GeneralUtils::SetBit(queryPlayerID, static_cast<size_t>(eObjectBits::OBJECT_BIT_CHARACTER));
GeneralUtils::SetBit(queryPlayerID, static_cast<size_t>(eObjectBits::OBJECT_BIT_PERSISTENT));
GeneralUtils::SetBit(queryFriendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_CHARACTER));
GeneralUtils::SetBit(queryFriendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_PERSISTENT));
GeneralUtils::SetBit(queryPlayerID, eObjectBits::CHARACTER);
GeneralUtils::SetBit(queryPlayerID, eObjectBits::PERSISTENT);
GeneralUtils::SetBit(queryFriendID, eObjectBits::CHARACTER);
GeneralUtils::SetBit(queryFriendID, eObjectBits::PERSISTENT);
// Since this player can either be the friend of someone else or be friends with someone else
// their column in the database determines what bit gets set. When the value hits 3, they
@ -336,8 +337,8 @@ void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
}
// Convert friendID to LWOOBJID
GeneralUtils::SetBit(friendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_PERSISTENT));
GeneralUtils::SetBit(friendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_CHARACTER));
GeneralUtils::SetBit(friendID, eObjectBits::PERSISTENT);
GeneralUtils::SetBit(friendID, eObjectBits::CHARACTER);
std::unique_ptr<sql::PreparedStatement> deletestmt(Database::CreatePreppedStmt("DELETE FROM friends WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?) LIMIT 1;"));
deletestmt->setUInt(1, static_cast<uint32_t>(playerID));

11
dCommon/Brick.h Normal file
View File

@ -0,0 +1,11 @@
#ifndef __BRICK__H__
#define __BRICK__H__
#include <cstdint>
struct Brick {
uint32_t designerID;
uint32_t materialID;
};
#endif //!__BRICK__H__

9
dCommon/GeneralUtils.h
View File

@ -16,6 +16,7 @@
#include "dLogger.h"
enum eInventoryType : uint32_t;
enum class eObjectBits : size_t;
enum class eReplicaComponentType : uint32_t;
/*!
@ -66,9 +67,9 @@ namespace GeneralUtils {
//! Sets a bit on a numerical value
template <typename T>
void SetBit(T& value, size_t index) {
inline void SetBit(T& value, eObjectBits bits) {
static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
auto index = static_cast<size_t>(bits);
if (index > (sizeof(T) * 8) - 1) {
return;
}
@ -78,9 +79,9 @@ namespace GeneralUtils {
//! Clears a bit on a numerical value
template <typename T>
void ClearBit(T& value, size_t index) {
inline void ClearBit(T& value, eObjectBits bits) {
static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
auto index = static_cast<size_t>(bits);
if (index > (sizeof(T) * 8 - 1)) {
return;
}

244
dCommon/LDFFormat.cpp
View File

@ -3,122 +3,174 @@
// Custom Classes
#include "GeneralUtils.h"
#include "Game.h"
#include "dLogger.h"
// C++
#include <sstream>
#include <string_view>
#include <vector>
using LDFKey = std::string_view;
using LDFTypeAndValue = std::string_view;
using LDFType = std::string_view;
using LDFValue = std::string_view;
//! Returns a pointer to a LDFData value based on string format
LDFBaseData* LDFBaseData::DataFromString(const std::string& format) {
LDFBaseData* LDFBaseData::DataFromString(const std::string_view& format) {
// A valid LDF must be at least 3 characters long (=0:) is the shortest valid LDF (empty UTF-16 key with no initial value)
if (format.empty() || format.length() <= 2) return nullptr;
auto equalsPosition = format.find('=');
// You can have an empty key, just make sure the type and value might exist
if (equalsPosition == std::string::npos || equalsPosition == (format.size() - 1)) return nullptr;
// First, check the format
std::istringstream ssFormat(format);
std::string token;
std::pair<LDFKey, LDFTypeAndValue> keyValue;
keyValue.first = format.substr(0, equalsPosition);
keyValue.second = format.substr(equalsPosition + 1, format.size());
std::vector<std::string> keyValueArray;
while (std::getline(ssFormat, token, '=')) {
keyValueArray.push_back(token);
std::u16string key = GeneralUtils::ASCIIToUTF16(keyValue.first);
auto colonPosition = keyValue.second.find(':');
// If : is the first thing after an =, then this is an invalid LDF since
// we dont have a type to use.
if (colonPosition == std::string::npos || colonPosition == 0) return nullptr;
std::pair<LDFType, LDFValue> ldfTypeAndValue;
ldfTypeAndValue.first = keyValue.second.substr(0, colonPosition);
ldfTypeAndValue.second = keyValue.second.substr(colonPosition + 1, keyValue.second.size());
// Only allow empty values for string values.
if (ldfTypeAndValue.second.size() == 0 && !(ldfTypeAndValue.first == "0" || ldfTypeAndValue.first == "13")) return nullptr;
eLDFType type;
char* storage;
try {
type = static_cast<eLDFType>(strtol(ldfTypeAndValue.first.data(), &storage, 10));
} catch (std::exception) {
Game::logger->Log("LDFFormat", "Attempted to process invalid ldf type (%s) from string (%s)", ldfTypeAndValue.first.data(), format.data());
return nullptr;
}
if (keyValueArray.size() == 2) {
std::u16string key = GeneralUtils::ASCIIToUTF16(keyValueArray[0]);
LDFBaseData* returnValue = nullptr;
switch (type) {
case LDF_TYPE_UTF_16: {
std::u16string data = GeneralUtils::UTF8ToUTF16(ldfTypeAndValue.second);
returnValue = new LDFData<std::u16string>(key, data);
break;
}
std::vector<std::string> dataArray;
std::istringstream ssData(keyValueArray[1]);
while (std::getline(ssData, token, ':')) {
dataArray.push_back(token);
case LDF_TYPE_S32: {
try {
int32_t data = static_cast<int32_t>(strtoul(ldfTypeAndValue.second.data(), &storage, 10));
returnValue = new LDFData<int32_t>(key, data);
} catch (std::exception) {
Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid int32 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
return nullptr;
}
break;
}
if (dataArray.size() > 2) { // hacky fix for strings with colons in them
std::vector<std::string> newDataArray;
newDataArray.push_back(dataArray[0]);
std::string value = "";
for (size_t i = 1; i < dataArray.size(); ++i) {
value += dataArray[i] + ':';
}
value.pop_back(); // remove last colon
newDataArray.push_back(value);
dataArray = newDataArray;
case LDF_TYPE_FLOAT: {
try {
float data = strtof(ldfTypeAndValue.second.data(), &storage);
returnValue = new LDFData<float>(key, data);
} catch (std::exception) {
Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid float value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
return nullptr;
}
break;
}
if ((dataArray[0] == "0" || dataArray[0] == "13") && dataArray.size() == 1) {
dataArray.push_back("");
case LDF_TYPE_DOUBLE: {
try {
double data = strtod(ldfTypeAndValue.second.data(), &storage);
returnValue = new LDFData<double>(key, data);
} catch (std::exception) {
Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid double value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
return nullptr;
}
break;
}
if (dataArray.size() == 2) {
eLDFType type = static_cast<eLDFType>(stoi(dataArray[0]));
case LDF_TYPE_U32:
{
uint32_t data;
switch (type) {
case LDF_TYPE_UTF_16: {
std::u16string data = GeneralUtils::UTF8ToUTF16(dataArray[1]);
return new LDFData<std::u16string>(key, data);
}
case LDF_TYPE_S32: {
int32_t data = static_cast<int32_t>(stoull(dataArray[1]));
return new LDFData<int32_t>(key, data);
}
case LDF_TYPE_FLOAT: {
float data = static_cast<float>(stof(dataArray[1]));
return new LDFData<float>(key, data);
}
case LDF_TYPE_DOUBLE: {
double data = static_cast<float>(stod(dataArray[1]));
return new LDFData<double>(key, data);
}
case LDF_TYPE_U32:
{
uint32_t data;
if (dataArray[1] == "true") {
data = 1;
} else if (dataArray[1] == "false") {
data = 0;
} else {
data = static_cast<uint32_t>(stoul(dataArray[1]));
}
return new LDFData<uint32_t>(key, data);
}
case LDF_TYPE_BOOLEAN: {
bool data;
if (dataArray[1] == "true") {
data = true;
} else if (dataArray[1] == "false") {
data = false;
} else {
data = static_cast<bool>(stoi(dataArray[1]));
}
return new LDFData<bool>(key, data);
}
case LDF_TYPE_U64: {
uint64_t data = static_cast<uint64_t>(stoull(dataArray[1]));
return new LDFData<uint64_t>(key, data);
}
case LDF_TYPE_OBJID: {
LWOOBJID data = static_cast<LWOOBJID>(stoll(dataArray[1]));
return new LDFData<LWOOBJID>(key, data);
}
case LDF_TYPE_UTF_8: {
std::string data = dataArray[1];
return new LDFData<std::string>(key, data);
}
case LDF_TYPE_UNKNOWN: {
if (ldfTypeAndValue.second == "true") {
data = 1;
} else if (ldfTypeAndValue.second == "false") {
data = 0;
} else {
try {
data = static_cast<uint32_t>(strtoul(ldfTypeAndValue.second.data(), &storage, 10));
} catch (std::exception) {
Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid uint32 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
return nullptr;
}
}
}
returnValue = new LDFData<uint32_t>(key, data);
break;
}
return nullptr;
case LDF_TYPE_BOOLEAN: {
bool data;
if (ldfTypeAndValue.second == "true") {
data = true;
} else if (ldfTypeAndValue.second == "false") {
data = false;
} else {
try {
data = static_cast<bool>(strtol(ldfTypeAndValue.second.data(), &storage, 10));
} catch (std::exception) {
Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid bool value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
return nullptr;
}
}
returnValue = new LDFData<bool>(key, data);
break;
}
case LDF_TYPE_U64: {
try {
uint64_t data = static_cast<uint64_t>(strtoull(ldfTypeAndValue.second.data(), &storage, 10));
returnValue = new LDFData<uint64_t>(key, data);
} catch (std::exception) {
Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid uint64 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
return nullptr;
}
break;
}
case LDF_TYPE_OBJID: {
try {
LWOOBJID data = static_cast<LWOOBJID>(strtoll(ldfTypeAndValue.second.data(), &storage, 10));
returnValue = new LDFData<LWOOBJID>(key, data);
} catch (std::exception) {
Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid LWOOBJID value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
return nullptr;
}
break;
}
case LDF_TYPE_UTF_8: {
std::string data = ldfTypeAndValue.second.data();
returnValue = new LDFData<std::string>(key, data);
break;
}
case LDF_TYPE_UNKNOWN: {
Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid unknown value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
break;
}
default: {
Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid LDF type (%d) from string (%s)", type, format.data());
break;
}
}
return returnValue;
}

86
dCommon/LDFFormat.h
View File

@ -1,4 +1,5 @@
#pragma once
#ifndef __LDFFORMAT__H__
#define __LDFFORMAT__H__
// Custom Classes
#include "dCommonVars.h"
@ -6,18 +7,12 @@
// C++
#include <string>
#include <string_view>
#include <sstream>
// RakNet
#include "BitStream.h"
#include "../thirdparty/raknet/Source/BitStream.h"
/*!
\file LDFFormat.hpp
\brief A collection of LDF format classes
*/
//! An enum for LDF Data Types
enum eLDFType {
LDF_TYPE_UNKNOWN = -1, //!< Unknown data type
LDF_TYPE_UTF_16 = 0, //!< UTF-16 wstring data type
@ -31,36 +26,21 @@ enum eLDFType {
LDF_TYPE_UTF_8 = 13, //!< UTF-8 string data type
};
//! A base class for the LDF data
class LDFBaseData {
public:
//! Destructor
virtual ~LDFBaseData(void) {}
virtual ~LDFBaseData() {}
//! Writes the data to a packet
/*!
\param packet The packet
*/
virtual void WriteToPacket(RakNet::BitStream* packet) = 0;
//! Gets the key
/*!
\return The key
*/
virtual const std::u16string& GetKey(void) = 0;
virtual const std::u16string& GetKey() = 0;
//! Gets the value type
/*!
\return The value type
*/
virtual eLDFType GetValueType(void) = 0;
virtual eLDFType GetValueType() = 0;
//! Gets a string from the key/value pair
/*!
\param includeKey Whether or not to include the key in the data
\param includeTypeId Whether or not to include the type id in the data
\return The string representation of the data
/** Gets a string from the key/value pair
* @param includeKey Whether or not to include the key in the data
* @param includeTypeId Whether or not to include the type id in the data
* @return The string representation of the data
*/
virtual std::string GetString(bool includeKey = true, bool includeTypeId = true) = 0;
@ -68,19 +48,15 @@ public:
virtual LDFBaseData* Copy() = 0;
// MARK: Functions
//! Returns a pointer to a LDFData value based on string format
/*!
\param format The format
/**
* Given an input string, return the data as a LDF key.
*/
static LDFBaseData* DataFromString(const std::string& format);
static LDFBaseData* DataFromString(const std::string_view& format);
};
//! A structure for an LDF key-value pair
template<typename T>
class LDFData : public LDFBaseData {
class LDFData: public LDFBaseData {
private:
std::u16string key;
T value;
@ -164,15 +140,11 @@ public:
if (includeKey) {
const std::string& sKey = GeneralUtils::UTF16ToWTF8(this->key, this->key.size());
stream << sKey << "=";
stream << sKey << '=';
}
if (includeTypeId) {
const std::string& sType = std::to_string(this->GetValueType());
stream << sType << ":";
stream << this->GetValueType() << ':';
}
const std::string& sData = this->GetValueString();
@ -234,20 +206,18 @@ inline void LDFData<std::string>::WriteValue(RakNet::BitStream* packet) {
}
}
// MARK: String Data
template<> inline std::string LDFData<std::u16string>::GetValueString(void) {
//std::string toReturn(this->value.begin(), this->value.end());
//return toReturn;
template<> inline std::string LDFData<std::u16string>::GetValueString() {
return GeneralUtils::UTF16ToWTF8(this->value, this->value.size());
}
template<> inline std::string LDFData<int32_t>::GetValueString(void) { return std::to_string(this->value); }
template<> inline std::string LDFData<float>::GetValueString(void) { return std::to_string(this->value); }
template<> inline std::string LDFData<double>::GetValueString(void) { return std::to_string(this->value); }
template<> inline std::string LDFData<uint32_t>::GetValueString(void) { return std::to_string(this->value); }
template<> inline std::string LDFData<bool>::GetValueString(void) { return std::to_string(this->value); }
template<> inline std::string LDFData<uint64_t>::GetValueString(void) { return std::to_string(this->value); }
template<> inline std::string LDFData<LWOOBJID>::GetValueString(void) { return std::to_string(this->value); }
template<> inline std::string LDFData<int32_t>::GetValueString() { return std::to_string(this->value); }
template<> inline std::string LDFData<float>::GetValueString() { return std::to_string(this->value); }
template<> inline std::string LDFData<double>::GetValueString() { return std::to_string(this->value); }
template<> inline std::string LDFData<uint32_t>::GetValueString() { return std::to_string(this->value); }
template<> inline std::string LDFData<bool>::GetValueString() { return std::to_string(this->value); }
template<> inline std::string LDFData<uint64_t>::GetValueString() { return std::to_string(this->value); }
template<> inline std::string LDFData<LWOOBJID>::GetValueString() { return std::to_string(this->value); }
template<> inline std::string LDFData<std::string>::GetValueString(void) { return this->value; }
template<> inline std::string LDFData<std::string>::GetValueString() { return this->value; }
#endif //!__LDFFORMAT__H__

406
dCommon/dEnums/dCommonVars.h
View File

@ -10,8 +10,6 @@
#pragma warning (disable:4251) //Disables SQL warnings
typedef int RESTICKET;
// These are the same define, but they mean two different things in different contexts
// so a different define to distinguish what calculation is happening will help clarity.
#define FRAMES_TO_MS(x) 1000 / x
@ -45,23 +43,16 @@ typedef uint16_t LWOINSTANCEID; //!< Used for Instance IDs
typedef uint32_t PROPERTYCLONELIST; //!< Used for Property Clone IDs
typedef uint32_t StripId;
typedef int32_t PetTamingPiece; //!< Pet Taming Pieces
const LWOOBJID LWOOBJID_EMPTY = 0; //!< An empty object ID
const LOT LOT_NULL = -1; //!< A null LOT
const int32_t LOOTTYPE_NONE = 0; //!< No loot type available
const float SECONDARY_PRIORITY = 1.0f; //!< Secondary Priority
const uint32_t INVENTORY_INVALID = -1; //!< Invalid Inventory
const uint32_t INVENTORY_DEFAULT = -1; //!< Default Inventory
const uint32_t StatusChangeInfo = 0; //!< Status Change Info (???)
const uint32_t INVENTORY_MAX = 9999999; //!< The Maximum Inventory Size
const uint32_t LWOCLONEID_INVALID = -1; //!< Invalid LWOCLONEID
const uint16_t LWOINSTANCEID_INVALID = -1; //!< Invalid LWOINSTANCEID
const uint16_t LWOMAPID_INVALID = -1; //!< Invalid LWOMAPID
const uint64_t LWOZONEID_INVALID = 0; //!< Invalid LWOZONEID
typedef std::set<LWOOBJID> TSetObjID;
const float PI = 3.14159f;
//============ STRUCTS ==============
@ -164,401 +155,4 @@ public:
}
};
struct Brick {
uint32_t designerID;
uint32_t materialID;
};
//This union is used by the behavior system
union suchar {
unsigned char usigned;
char svalue;
};
//=========== LU ENUMS ============
//! An enum for object ID bits
enum eObjectBits : int32_t {
OBJECT_BIT_PERSISTENT = 32, //!< The 32 bit index
OBJECT_BIT_CLIENT = 46, //!< The 46 bit index
OBJECT_BIT_SPAWNED = 58, //!< The 58 bit index
OBJECT_BIT_CHARACTER = 60 //!< The 60 bit index
};
//! An enum for MatchUpdate types
enum eMatchUpdate : int {
MATCH_UPDATE_PLAYER_JOINED = 0,
MATCH_UPDATE_PLAYER_LEFT = 1,
MATCH_UPDATE_TIME = 3,
MATCH_UPDATE_TIME_START_DELAY = 4,
MATCH_UPDATE_PLAYER_READY = 5,
MATCH_UPDATE_PLAYER_UNREADY = 6
};
//! An enum for camera cycling modes
enum eCyclingMode : uint32_t {
ALLOW_CYCLE_TEAMMATES,
DISALLOW_CYCLING
};
enum eCinematicEvent : uint32_t {
STARTED,
WAYPOINT,
ENDED,
};
//! An enum for character creation responses
enum eCreationResponse : uint8_t {
CREATION_RESPONSE_SUCCESS = 0, //!< The creation was successful
CREATION_RESPONSE_OBJECT_ID_UNAVAILABLE, //!< The Object ID can't be used
CREATION_RESPONSE_NAME_NOT_ALLOWED, //!< The name is not allowed
CREATION_RESPONSE_PREDEFINED_NAME_IN_USE, //!< The predefined name is already in use
CREATION_RESPONSE_CUSTOM_NAME_IN_USE //!< The custom name is already in use
};
//! An enum for login responses
enum eLoginResponse : uint8_t {
LOGIN_RESPONSE_GENERAL_FAILED = 0,
LOGIN_RESPONSE_SUCCESS = 1,
LOGIN_RESPONSE_BANNED = 2,
LOGIN_RESPONSE_PERMISSIONS_NOT_HIGH_ENOUGH = 5,
LOGIN_RESPONSE_WRONG_PASS_OR_USER = 6,
LOGIN_RESPONSE_ACCOUNT_LOCKED = 7
};
//! An enum for character rename responses
enum eRenameResponse : uint8_t {
RENAME_RESPONSE_SUCCESS = 0, //!< The renaming was successful
RENAME_RESPONSE_UNKNOWN_ERROR, //!< There was an unknown error
RENAME_RESPONSE_NAME_UNAVAILABLE, //!< The name is unavailable
RENAME_RESPONSE_NAME_IN_USE //!< The name is already in use
};
//! A replica packet type
enum eReplicaPacketType {
PACKET_TYPE_CONSTRUCTION, //!< A construction packet
PACKET_TYPE_SERIALIZATION, //!< A serialization packet
PACKET_TYPE_DESTRUCTION //!< A destruction packet
};
//! The Behavior Types for use with the AI system
enum eCombatBehaviorTypes : uint32_t {
PASSIVE = 0, //!< The object is passive
AGGRESSIVE = 1, //!< The object is aggressive
PASSIVE_TURRET = 2, //!< The object is a passive turret
AGGRESSIVE_TURRET = 3 //!< The object is an aggressive turret
};
//! The Combat Role Type for use with the AI system
enum eCombatRoleType : uint32_t {
MELEE = 0, //!< Used for melee attacks
RANGED = 1, //!< Used for range attacks
SUPPORT = 2 //!< Used for support
};
//! The kill types for the Die packet
enum eKillType : uint32_t {
VIOLENT,
SILENT
};
//! The various world states used throughout the server
enum eObjectWorldState {
WORLDSTATE_INWORLD, //!< Probably used when the object is in the world
WORLDSTATE_ATTACHED, //!< Probably used when the object is attached to another object
WORLDSTATE_INVENTORY //!< Probably used when the object is in an inventory
};
//! The trigger stats (???)
enum eTriggerStat {
INVALID_STAT, //!< ???
HEALTH, //!< Probably used for health
ARMOR, //!< Probably used for armor
IMAGINATION //!< Probably used for imagination
};
//! The trigger operations (???)
enum eTriggerOperator {
INVALID_OPER, //!< ???
EQUAL, //!< ???
NOT_EQUAL, //!< ???
GREATER, //!< ???
GREATER_EQUAL, //!< ???
LESS, //!< ???
LESS_EQUAL //!< ???
};
//! The various build types
enum eBuildType {
BUILD_NOWHERE, //!< Used if something can't be built anywhere
BUILD_IN_WORLD, //!< Used if something can be built in the world
BUILD_ON_PROPERTY //!< Used if something can be build on a property
};
//! Quickbuild fail reasons
enum eFailReason : uint32_t {
REASON_NOT_GIVEN,
REASON_OUT_OF_IMAGINATION,
REASON_CANCELED_EARLY,
REASON_BUILD_ENDED
};
//! Terminate interaction type
enum eTerminateType : uint32_t {
RANGE,
USER,
FROM_INTERACTION
};
//! The combat state
enum eCombatState {
IDLE, //!< The AI is in an idle state
AGGRO, //!< The AI is in an aggressive state
TETHER, //!< The AI is being redrawn back to tether point
SPAWN, //!< The AI is spawning
DEAD //!< The AI is dead
};
enum eControlSceme {
SCHEME_A,
SCHEME_D,
SCHEME_GAMEPAD,
SCHEME_E,
SCHEME_FPS,
SCHEME_DRIVING,
SCHEME_TAMING,
SCHEME_MODULAR_BUILD,
SCHEME_WEAR_A_ROBOT //== freecam?
};
enum class eStateChangeType : uint32_t {
PUSH,
POP
};
enum eNotifyType {
NOTIFY_TYPE_SUCCESS,
NOTIFY_TYPE_QUIT,
NOTIFY_TYPE_FAILED,
NOTIFY_TYPE_BEGIN,
NOTIFY_TYPE_READY,
NOTIFY_TYPE_NAMINGPET
};
enum class UseItemResponse : uint32_t {
NoImaginationForPet = 1,
FailedPrecondition,
MountsNotAllowed
};
enum eRebuildState : uint32_t {
REBUILD_OPEN,
REBUILD_COMPLETED = 2,
REBUILD_RESETTING = 4,
REBUILD_BUILDING,
REBUILD_INCOMPLETE
};
/**
* The loot source's type.
*/
enum eLootSourceType : int32_t {
LOOT_SOURCE_NONE = 0,
LOOT_SOURCE_CHEST,
LOOT_SOURCE_MISSION,
LOOT_SOURCE_MAIL,
LOOT_SOURCE_CURRENCY,
LOOT_SOURCE_ACHIEVEMENT,
LOOT_SOURCE_TRADE,
LOOT_SOURCE_QUICKBUILD,
LOOT_SOURCE_DELETION,
LOOT_SOURCE_VENDOR,
LOOT_SOURCE_ACTIVITY,
LOOT_SOURCE_PICKUP,
LOOT_SOURCE_BRICK,
LOOT_SOURCE_PROPERTY,
LOOT_SOURCE_MODERATION,
LOOT_SOURCE_EXHIBIT,
LOOT_SOURCE_INVENTORY,
LOOT_SOURCE_CLAIMCODE,
LOOT_SOURCE_CONSUMPTION,
LOOT_SOURCE_CRAFTING,
LOOT_SOURCE_LEVEL_REWARD,
LOOT_SOURCE_RELOCATE
};
enum eGameActivities : uint32_t {
ACTIVITY_NONE,
ACTIVITY_QUICKBUILDING,
ACTIVITY_SHOOTING_GALLERY,
ACTIVITY_RACING,
ACTIVITY_PINBALL,
ACTIVITY_PET_TAMING
};
enum ePlayerFlags {
BTARR_TESTING = 0,
PLAYER_HAS_ENTERED_PET_RANCH = 1,
MINIMAP_UNLOCKED = 2,
ACTIVITY_REBUILDING_FAIL_TIME = 3,
ACTIVITY_REBUILDING_FAIL_RANGE = 4,
ACTIVITY_SHOOTING_GALLERY_HELP = 5,
HELP_WALKING_CONTROLS = 6,
FIRST_SMASHABLE = 7,
FIRST_IMAGINATION_PICKUP = 8,
FIRST_DAMAGE = 9,
FIRST_ITEM = 10,
FIRST_BRICK = 11,
FIRST_CONSUMABLE = 12,
FIRST_EQUIPPABLE = 13,
CHAT_HELP = 14,
FIRST_PET_TAMING_MINIGAME = 15,
FIRST_PET_ON_SWITCH = 16,
FIRST_PET_JUMPED_ON_SWITCH = 17,
FIRST_PET_FOUND_TREASURE = 18,
FIRST_PET_DUG_TREASURE = 19,
FIRST_PET_OWNER_ON_PET_BOUNCER = 20,
FIRST_PET_DESPAWN_NO_IMAGINATION = 21,
FIRST_PET_SELECTED_ENOUGH_BRICKS = 22,
FIRST_EMOTE_UNLOCKED = 23,
GF_PIRATE_REP = 24,
AG_BOB_CINEMATIC_EVENT = 25,
HELP_JUMPING_CONTROLS = 26,
HELP_DOUBLE_JUMP_CONTROLS = 27,
HELP_CAMERA_CONTROLS = 28,
HELP_ROTATE_CONTROLS = 29,
HELP_SMASH = 30,
MONUMENT_INTRO_MUSIC_PLAYED = 31,
BEGINNING_ZONE_SUMMARY_DISPLAYED = 32,
AG_FINISH_LINE_BUILT = 33,
AG_BOSS_AREA_FOUND = 34,
AG_LANDED_IN_BATTLEFIELD = 35,
GF_PLAYER_HAS_BEEN_TO_THE_RAVINE = 36,
MODULAR_BUILD_STARTED = 37,
MODULAR_BUILD_FINISHED_CLICK_BUTTON = 38,
THINKING_HAT_RECEIVED_GO_TO_MODULAR_BUILD_AREA = 39,
BUILD_AREA_ENTERED_MOD_NOT_ACTIVATED_PUT_ON_HAT = 40,
HAT_ON_INSIDE_OF_MOD_BUILD_EQUIP_A_MODULE_FROM_LEG = 41,
MODULE_EQUIPPED_PLACE_ON_GLOWING_BLUE_SPOT = 42,
FIRST_MODULE_PLACED_CORRECTLY_NOW_DO_THE_REST = 43,
ROCKET_COMPLETE_NOW_LAUNCH_FROM_PAD = 44,
JOINED_A_FACTION = 45,
VENTURE_FACTION = 46,
ASSEMBLY_FACTION = 47,
PARADOX_FACTION = 48,
SENTINEL_FACTION = 49,
LUP_WORLD_ACCESS = 50,
AG_FIRST_FLAG_COLLECTED = 51,
TOOLTIP_TALK_TO_SKYLAND_TO_GET_HAT = 52,
MODULAR_BUILD_PLAYER_PLACES_FIRST_MODEL_IN_SCRATCH = 53,
MODULAR_BUILD_FIRST_ARROW_DISPLAY_FOR_MODULE = 54,
AG_BEACON_QB_SO_THE_PLAYER_CAN_ALWAYS_BUILD_THEM = 55,
GF_PET_DIG_FLAG_1 = 56,
GF_PET_DIG_FLAG_2 = 57,
GF_PET_DIG_FLAG_3 = 58,
SUPPRESS_SPACESHIP_CINEMATIC_FLYTHROUGH = 59,
GF_PLAYER_FALL_DEATH = 60,
GF_PLAYER_CAN_GET_FLAG_1 = 61,
GF_PLAYER_CAN_GET_FLAG_2 = 62,
GF_PLAYER_CAN_GET_FLAG_3 = 63,
ENTER_BBB_FROM_PROPERTY_EDIT_CONFIRMATION_DIALOG = 64,
AG_FIRST_COMBAT_COMPLETE = 65,
AG_COMPLETE_BOB_MISSION = 66,
IS_NEWS_SCREEN_VISIBLE = 114,
NJ_GARMADON_CINEMATIC_SEEN = 125,
ELEPHANT_PET_3050 = 801,
CAT_PET_3054 = 802,
TRICERATOPS_PET_3195 = 803,
TERRIER_PET_3254 = 804,
SKUNK_PET_3261 = 805,
LION_PET_3520 = 806,
BUNNY_PET_3672 = 807,
CROCODILE_PET_3994 = 808,
DOBERMAN_PET_5635 = 809,
BUFFALO_PET_5636 = 810,
ROBOT_DOG_PET_5637 = 811,
EUROPEAN_DRAGON_PET_5639 = 812,
TORTOISE_PET_5640 = 813,
ASIAN_DRAGON_PET_5641 = 814,
MANTIS_PET_5642 = 815,
PANDA_PET_5643 = 816,
WARTHOG_PET_6720 = 817,
GOAT_PET_7638 = 818,
CRAB_PET_7694 = 819,
AG_SPACE_SHIP_BINOC_AT_LAUNCH = 1001,
AG_SPACE_SHIP_BINOC_AT_LAUNCH_PLATFORM = 1002,
AG_SPACE_SHIP_BINOC_ON_PLATFORM_TO_LEFT_OF_START = 1003,
AG_SPACE_SHIP_BINOC_ON_PLATFORM_TO_RIGHT_OF_START = 1004,
AG_SPACE_SHIP_BINOC_AT_BOB = 1005,
AG_BATTLE_BINOC_FOR_TRICERETOPS = 1101,
AG_BATTLE_BINOC_AT_PARADOX = 1102,
AG_BATTLE_BINOC_AT_MISSION_GIVER = 1103,
AG_BATTLE_BINOC_AT_BECK = 1104,
AG_MONUMENT_BINOC_INTRO = 1105,
AG_MONUMENT_BINOC_OUTRO = 1106,
AG_LAUNCH_BINOC_INTRO = 1107,
AG_LAUNCH_BINOC_BISON = 1108,
AG_LAUNCH_BINOC_SHARK = 1109,
NS_BINOC_CONCERT_TRANSITION = 1201,
NS_BINOC_RACE_PLACE_TRANSITION = 1202,
NS_BINOC_BRICK_ANNEX_TRANSITION = 1203,
NS_BINOC_GF_LAUNCH = 1204,
NS_BINOC_FV_LAUNCH = 1205,
NS_BINOC_BRICK_ANNEX_WATER = 1206,
NS_BINOC_AG_LAUNCH_AT_RACE_PLACE = 1207,
NS_BINOC_AG_LAUNCH_AT_BRICK_ANNEX = 1208,
NS_BINOC_AG_LAUNCH_AT_PLAZA = 1209,
NS_BINOC_TBA = 1210,
NS_FLAG_COLLECTABLE_1_BY_JONNY_THUNDER = 1211,
NS_FLAG_COLLECTABLE_2_UNDER_CONCERT_BRIDGE = 1212,
NS_FLAG_COLLECTABLE_3_BY_FV_LAUNCH = 1213,
NS_FLAG_COLLECTABLE_4_IN_PLAZA_BEHIND_BUILDING = 1214,
NS_FLAG_COLLECTABLE_5_BY_GF_LAUNCH = 1215,
NS_FLAG_COLLECTABLE_6_BY_DUCK_SG = 1216,
NS_FLAG_COLLECTABLE_7_BY_LUP_LAUNCH = 1217,
NS_FLAG_COLLECTABLE_8_BY_NT_LUANCH = 1218,
NS_FLAG_COLLECTABLE_9_BY_RACE_BUILD = 1219,
NS_FLAG_COLLECTABLE_10_ON_AG_LAUNCH_PATH = 1220,
PR_BINOC_AT_LAUNCH_PAD = 1251,
PR_BINOC_AT_BEGINNING_OF_ISLAND_B = 1252,
PR_BINOC_AT_FIRST_PET_BOUNCER = 1253,
PR_BINOC_ON_BY_CROWS_NEST = 1254,
PR_PET_DIG_AT_BEGINNING_OF_ISLAND_B = 1261,
PR_PET_DIG_AT_THE_LOCATION_OF_OLD_BOUNCE_BACK = 1262,
PR_PET_DIG_UNDER_QB_BRIDGE = 1263,
PR_PET_DIG_BACK_SIDE_BY_PARTNER_BOUNCE = 1264,
PR_PET_DIG_BY_LAUNCH_PAD = 1265,
PR_PET_DIG_BY_FIRST_PET_BOUNCER = 1266,
GF_BINOC_ON_LANDING_PAD = 1301,
GF_BINOC_AT_RAVINE_START = 1302,
GF_BINOC_ON_TOP_OF_RAVINE_HEAD = 1303,
GF_BINOC_AT_TURTLE_AREA = 1304,
GF_BINOC_IN_TUNNEL_TO_ELEPHANTS = 1305,
GF_BINOC_IN_ELEPHANTS_AREA = 1306,
GF_BINOC_IN_RACING_AREA = 1307,
GF_BINOC_IN_CROC_AREA = 1308,
GF_BINOC_IN_JAIL_AREA = 1309,
GF_BINOC_TELESCOPE_NEXT_TO_CAPTAIN_JACK = 1310,
NT_PLINTH_REBUILD = 1919,
NT_FACTION_SPY_DUKE = 1974,
NT_FACTION_SPY_OVERBUILD = 1976,
NT_FACTION_SPY_HAEL = 1977,
NJ_EARTH_SPINJITZU = 2030,
NJ_LIGHTNING_SPINJITZU = 2031,
NJ_ICE_SPINJITZU = 2032,
NJ_FIRE_SPINJITZU = 2033,
NJ_WU_SHOW_DAILY_CHEST = 2099
};
//======== FUNC ===========
template<typename T>
inline T const& clamp(const T& val, const T& low, const T& high) {
if (val < low) return low;
else if (val > high) return high;
return val;
}
#endif //!__DCOMMONVARS__H__

12
dCommon/dEnums/eBuildType.h Normal file
View File

@ -0,0 +1,12 @@
#ifndef __EBUILDTYPE__H__
#define __EBUILDTYPE__H__
#include <cstdint>
enum class eBuildType :uint32_t {
NOWHERE,
IN_WORLD,
ON_PROPERTY
};
#endif //!__EBUILDTYPE__H__

14
dCommon/dEnums/eCharacterCreationResponse.h Normal file
View File

@ -0,0 +1,14 @@
#ifndef __ECHARACTERCREATIONRESPONSE__H__
#define __ECHARACTERCREATIONRESPONSE__H__
#include <cstdint>
enum class eCharacterCreationResponse : uint8_t {
SUCCESS = 0,
OBJECT_ID_UNAVAILABLE,
NAME_NOT_ALLOWED,
PREDEFINED_NAME_IN_USE,
CUSTOM_NAME_IN_USE
};
#endif //!__ECHARACTERCREATIONRESPONSE__H__

12
dCommon/dEnums/eCinematicEvent.h Normal file
View File

@ -0,0 +1,12 @@
#ifndef __ECINEMATICEVENT__H__
#define __ECINEMATICEVENT__H__
#include <cstdint>
enum class eCinematicEvent : uint32_t {
STARTED,
WAYPOINT,
ENDED,
};
#endif //!__ECINEMATICEVENT__H__

18
dCommon/dEnums/eControlScheme.h Normal file
View File

@ -0,0 +1,18 @@
#ifndef __ECONTROLSCHEME__H__
#define __ECONTROLSCHEME__H__
#include <cstdint>
enum class eControlScheme : uint32_t {
SCHEME_A,
SCHEME_D,
SCHEME_GAMEPAD,
SCHEME_E,
SCHEME_FPS,
SCHEME_DRIVING,
SCHEME_TAMING,
SCHEME_MODULAR_BUILD,
SCHEME_WEAR_A_ROBOT //== freecam?
};
#endif //!__ECONTROLSCHEME__H__

11
dCommon/dEnums/eCyclingMode.h Normal file
View File

@ -0,0 +1,11 @@
#ifndef __ECYCLINGMODE__H__
#define __ECYCLINGMODE__H__
#include <cstdint>
enum class eCyclingMode : uint32_t {
ALLOW_CYCLE_TEAMMATES,
DISALLOW_CYCLING
};
#endif //!__ECYCLINGMODE__H__

15
dCommon/dEnums/eGameActivity.h Normal file
View File

@ -0,0 +1,15 @@
#ifndef __EGAMEACTIVITY__H__
#define __EGAMEACTIVITY__H__
#include <cstdint>
enum class eGameActivity : uint32_t {
NONE,
QUICKBUILDING,
SHOOTING_GALLERY,
RACING,
PINBALL,
PET_TAMING
};
#endif //!__EGAMEACTIVITY__H__

11
dCommon/dEnums/eKillType.h Normal file
View File

@ -0,0 +1,11 @@
#ifndef __EKILLTYPE__H__
#define __EKILLTYPE__H__
#include <cstdint>
enum class eKillType : uint32_t {
VIOLENT,
SILENT
};
#endif //!__EKILLTYPE__H__

24
dCommon/dEnums/eLoginResponse.h Normal file
View File

@ -0,0 +1,24 @@
#ifndef __ELOGINRESPONSE__H__
#define __ELOGINRESPONSE__H__
#include <cstdint>
enum class eLoginResponse : uint8_t {
GENERAL_FAILED = 0,
SUCCESS,
BANNED,
// Unused 3
// Unused 4
PERMISSIONS_NOT_HIGH_ENOUGH = 5,
INVALID_USER,
ACCOUNT_LOCKED,
WRONG_PASS,
ACCOUNT_ACTIVATION_PENDING,
ACCOUNT_DISABLED,
GAME_TIME_EXPIRED,
FREE_TRIAL_ENDED,
PLAY_SCHEDULE_TIME_UP,
ACCOUNT_NOT_ACTIVATED
};
#endif //!__ELOGINRESPONSE__H__

31
dCommon/dEnums/eLootSourceType.h Normal file
View File

@ -0,0 +1,31 @@
#ifndef __ELOOTSOURCETYPE__H__
#define __ELOOTSOURCETYPE__H__
#include <cstdint>
enum class eLootSourceType : uint32_t {
NONE = 0,
CHEST,
MISSION,
MAIL,
CURRENCY,
ACHIEVEMENT,
TRADE,
QUICKBUILD,
DELETION,
VENDOR,
ACTIVITY,
PICKUP,
BRICK,
PROPERTY,
MODERATION,
EXHIBIT,
INVENTORY,
CLAIMCODE,
CONSUMPTION,
CRAFTING,
LEVEL_REWARD,
RELOCATE
};
#endif //!__ELOOTSOURCETYPE__H__

17
dCommon/dEnums/eMatchUpdate.h Normal file
View File

@ -0,0 +1,17 @@
#ifndef __EMATCHUPDATE__H__
#define __EMATCHUPDATE__H__
#include <cstdint>
enum class eMatchUpdate : int32_t {
PLAYER_ADDED = 0,
PLAYER_REMOVED,
PHASE_CREATED,
PHASE_WAIT_READY,
PHASE_WAIT_START,
PLAYER_READY,
PLAYER_NOT_READY,
PLAYER_UPDATE
};
#endif //!__EMATCHUPDATE__H__

13
dCommon/dEnums/eObjectBits.h Normal file
View File

@ -0,0 +1,13 @@
#ifndef __EOBJECTBITS__H__
#define __EOBJECTBITS__H__
#include <cstdint>
enum class eObjectBits : size_t {
PERSISTENT = 32,
CLIENT = 46,
SPAWNED = 58,
CHARACTER = 60
};
#endif //!__EOBJECTBITS__H__

12
dCommon/dEnums/eObjectWorldState.h Normal file
View File

@ -0,0 +1,12 @@
#ifndef __EOBJECTWORLDSTATE__H__
#define __EOBJECTWORLDSTATE__H__
#include <cstdint>
enum class eObjectWorldState : uint32_t {
INWORLD,
ATTACHED,
INVENTORY
};
#endif //!__EOBJECTWORLDSTATE__H__

15
dCommon/dEnums/ePetTamingNotifyType.h Normal file
View File

@ -0,0 +1,15 @@
#ifndef __EPETTAMINGNOTIFYTYPE__H__
#define __EPETTAMINGNOTIFYTYPE__H__
#include <cstdint>
enum class ePetTamingNotifyType : uint32_t {
SUCCESS,
QUIT,
FAILED,
BEGIN,
READY,
NAMINGPET
};
#endif //!__EPETTAMINGNOTIFYTYPE__H__

172
dCommon/dEnums/ePlayerFlag.h Normal file
View File

@ -0,0 +1,172 @@
#ifndef __EPLAYERFLAG__H__
#define __EPLAYERFLAG__H__
#include <cstdint>
enum ePlayerFlag : int32_t {
BTARR_TESTING = 0,
PLAYER_HAS_ENTERED_PET_RANCH = 1,
MINIMAP_UNLOCKED = 2,
ACTIVITY_REBUILDING_FAIL_TIME = 3,
ACTIVITY_REBUILDING_FAIL_RANGE = 4,
ACTIVITY_SHOOTING_GALLERY_HELP = 5,
HELP_WALKING_CONTROLS = 6,
FIRST_SMASHABLE = 7,
FIRST_IMAGINATION_PICKUP = 8,
FIRST_DAMAGE = 9,
FIRST_ITEM = 10,
FIRST_BRICK = 11,
FIRST_CONSUMABLE = 12,
FIRST_EQUIPPABLE = 13,
CHAT_HELP = 14,
FIRST_PET_TAMING_MINIGAME = 15,
FIRST_PET_ON_SWITCH = 16,
FIRST_PET_JUMPED_ON_SWITCH = 17,
FIRST_PET_FOUND_TREASURE = 18,
FIRST_PET_DUG_TREASURE = 19,
FIRST_PET_OWNER_ON_PET_BOUNCER = 20,
FIRST_PET_DESPAWN_NO_IMAGINATION = 21,
FIRST_PET_SELECTED_ENOUGH_BRICKS = 22,
FIRST_EMOTE_UNLOCKED = 23,
GF_PIRATE_REP = 24,
AG_BOB_CINEMATIC_EVENT = 25,
HELP_JUMPING_CONTROLS = 26,
HELP_DOUBLE_JUMP_CONTROLS = 27,
HELP_CAMERA_CONTROLS = 28,
HELP_ROTATE_CONTROLS = 29,
HELP_SMASH = 30,
MONUMENT_INTRO_MUSIC_PLAYED = 31,
BEGINNING_ZONE_SUMMARY_DISPLAYED = 32,
AG_FINISH_LINE_BUILT = 33,
AG_BOSS_AREA_FOUND = 34,
AG_LANDED_IN_BATTLEFIELD = 35,
GF_PLAYER_HAS_BEEN_TO_THE_RAVINE = 36,
MODULAR_BUILD_STARTED = 37,
MODULAR_BUILD_FINISHED_CLICK_BUTTON = 38,
THINKING_HAT_RECEIVED_GO_TO_MODULAR_BUILD_AREA = 39,
BUILD_AREA_ENTERED_MOD_NOT_ACTIVATED_PUT_ON_HAT = 40,
HAT_ON_INSIDE_OF_MOD_BUILD_EQUIP_A_MODULE_FROM_LEG = 41,
MODULE_EQUIPPED_PLACE_ON_GLOWING_BLUE_SPOT = 42,
FIRST_MODULE_PLACED_CORRECTLY_NOW_DO_THE_REST = 43,
ROCKET_COMPLETE_NOW_LAUNCH_FROM_PAD = 44,
JOINED_A_FACTION = 45,
VENTURE_FACTION = 46,
ASSEMBLY_FACTION = 47,
PARADOX_FACTION = 48,
SENTINEL_FACTION = 49,
LUP_WORLD_ACCESS = 50,
AG_FIRST_FLAG_COLLECTED = 51,
TOOLTIP_TALK_TO_SKYLAND_TO_GET_HAT = 52,
MODULAR_BUILD_PLAYER_PLACES_FIRST_MODEL_IN_SCRATCH = 53,
MODULAR_BUILD_FIRST_ARROW_DISPLAY_FOR_MODULE = 54,
AG_BEACON_QB_SO_THE_PLAYER_CAN_ALWAYS_BUILD_THEM = 55,
GF_PET_DIG_FLAG_1 = 56,
GF_PET_DIG_FLAG_2 = 57,
GF_PET_DIG_FLAG_3 = 58,
SUPPRESS_SPACESHIP_CINEMATIC_FLYTHROUGH = 59,
GF_PLAYER_FALL_DEATH = 60,
GF_PLAYER_CAN_GET_FLAG_1 = 61,
GF_PLAYER_CAN_GET_FLAG_2 = 62,
GF_PLAYER_CAN_GET_FLAG_3 = 63,
ENTER_BBB_FROM_PROPERTY_EDIT_CONFIRMATION_DIALOG = 64,
AG_FIRST_COMBAT_COMPLETE = 65,
AG_COMPLETE_BOB_MISSION = 66,
FIRST_MANUAL_PET_HIBERNATE = 69,
CAGED_SPIDER = 74,
IS_NEWS_SCREEN_VISIBLE = 114,
NJ_GARMADON_CINEMATIC_SEEN = 125,
EQUPPED_TRIAL_FACTION_GEAR = 126,
ELEPHANT_PET_3050 = 801,
CAT_PET_3054 = 803,
TRICERATOPS_PET_3195 = 806,
TERRIER_PET_3254 = 807,
SKUNK_PET_3261 = 811,
BUNNY_PET_3672 = 813,
CROCODILE_PET_3994 = 814,
DOBERMAN_PET_5635 = 815,
BUFFALO_PET_5636 = 816,
ROBOT_DOG_PET_5637 = 818,
RED_DRAGON_PET_5639 = 819,
TORTOISE_PET_5640 = 820,
GREEN_DRAGON_PET_5641 = 821,
PANDA_PET_5643 = 822,
MANTIS_PET_5642 = 823,
WARTHOG_PET_6720 = 824,
LION_PET_3520 = 825,
GOAT_PET_7638 = 818,
CRAB_PET_7694 = 827,
REINDEER_PET_12294 = 829,
STEGOSAURUS_PET_12431 = 830,
SABER_CAT_PET_12432 = 831,
GRYPHON_PET_12433 = 832,
ALINE_PET_12334 = 833,
UNKNOWN_PET = 834,
EARTH_DRAGON_PET_16210 = 836,
SKELETON_DRAGON_PET_13067 = 838,
AG_SPACE_SHIP_BINOC_AT_LAUNCH = 1001,
AG_SPACE_SHIP_BINOC_AT_LAUNCH_PLATFORM = 1002,
AG_SPACE_SHIP_BINOC_ON_PLATFORM_TO_LEFT_OF_START = 1003,
AG_SPACE_SHIP_BINOC_ON_PLATFORM_TO_RIGHT_OF_START = 1004,
AG_SPACE_SHIP_BINOC_AT_BOB = 1005,
AG_BATTLE_BINOC_FOR_TRICERETOPS = 1101,
AG_BATTLE_BINOC_AT_PARADOX = 1102,
AG_BATTLE_BINOC_AT_MISSION_GIVER = 1103,
AG_BATTLE_BINOC_AT_BECK = 1104,
AG_MONUMENT_BINOC_INTRO = 1105,
AG_MONUMENT_BINOC_OUTRO = 1106,
AG_LAUNCH_BINOC_INTRO = 1107,
AG_LAUNCH_BINOC_BISON = 1108,
AG_LAUNCH_BINOC_SHARK = 1109,
NS_BINOC_CONCERT_TRANSITION = 1201,
NS_BINOC_RACE_PLACE_TRANSITION = 1202,
NS_BINOC_BRICK_ANNEX_TRANSITION = 1203,
NS_BINOC_GF_LAUNCH = 1204,
NS_BINOC_FV_LAUNCH = 1205,
NS_BINOC_BRICK_ANNEX_WATER = 1206,
NS_BINOC_AG_LAUNCH_AT_RACE_PLACE = 1207,
NS_BINOC_AG_LAUNCH_AT_BRICK_ANNEX = 1208,
NS_BINOC_AG_LAUNCH_AT_PLAZA = 1209,
NS_BINOC_TBA = 1210,
NS_FLAG_COLLECTABLE_1_BY_JONNY_THUNDER = 1211,
NS_FLAG_COLLECTABLE_2_UNDER_CONCERT_BRIDGE = 1212,
NS_FLAG_COLLECTABLE_3_BY_FV_LAUNCH = 1213,
NS_FLAG_COLLECTABLE_4_IN_PLAZA_BEHIND_BUILDING = 1214,
NS_FLAG_COLLECTABLE_5_BY_GF_LAUNCH = 1215,
NS_FLAG_COLLECTABLE_6_BY_DUCK_SG = 1216,
NS_FLAG_COLLECTABLE_7_BY_LUP_LAUNCH = 1217,
NS_FLAG_COLLECTABLE_8_BY_NT_LUANCH = 1218,
NS_FLAG_COLLECTABLE_9_BY_RACE_BUILD = 1219,
NS_FLAG_COLLECTABLE_10_ON_AG_LAUNCH_PATH = 1220,
PR_BINOC_AT_LAUNCH_PAD = 1251,
PR_BINOC_AT_BEGINNING_OF_ISLAND_B = 1252,
PR_BINOC_AT_FIRST_PET_BOUNCER = 1253,
PR_BINOC_ON_BY_CROWS_NEST = 1254,
PR_PET_DIG_AT_BEGINNING_OF_ISLAND_B = 1261,
PR_PET_DIG_AT_THE_LOCATION_OF_OLD_BOUNCE_BACK = 1262,
PR_PET_DIG_UNDER_QB_BRIDGE = 1263,
PR_PET_DIG_BACK_SIDE_BY_PARTNER_BOUNCE = 1264,
PR_PET_DIG_BY_LAUNCH_PAD = 1265,
PR_PET_DIG_BY_FIRST_PET_BOUNCER = 1266,
GF_BINOC_ON_LANDING_PAD = 1301,
GF_BINOC_AT_RAVINE_START = 1302,
GF_BINOC_ON_TOP_OF_RAVINE_HEAD = 1303,
GF_BINOC_AT_TURTLE_AREA = 1304,
GF_BINOC_IN_TUNNEL_TO_ELEPHANTS = 1305,
GF_BINOC_IN_ELEPHANTS_AREA = 1306,
GF_BINOC_IN_RACING_AREA = 1307,
GF_BINOC_IN_CROC_AREA = 1308,
GF_BINOC_IN_JAIL_AREA = 1309,
GF_BINOC_TELESCOPE_NEXT_TO_CAPTAIN_JACK = 1310,
NT_HEART_OF_DARKNESS = 1911,
NT_PLINTH_REBUILD = 1919,
NT_FACTION_SPY_DUKE = 1974,
NT_FACTION_SPY_OVERBUILD = 1976,
NT_FACTION_SPY_HAEL = 1977,
NJ_EARTH_SPINJITZU = 2030,
NJ_LIGHTNING_SPINJITZU = 2031,
NJ_ICE_SPINJITZU = 2032,
NJ_FIRE_SPINJITZU = 2033,
NJ_WU_SHOW_DAILY_CHEST = 2099
};
#endif //!__EPLAYERFLAG__H__

13
dCommon/dEnums/eQuickBuildFailReason.h Normal file
View File

@ -0,0 +1,13 @@
#ifndef __EQUICKBUILDFAILREASON__H__
#define __EQUICKBUILDFAILREASON__H__
#include <cstdint>
enum class eQuickBuildFailReason : uint32_t {
NOT_GIVEN,
OUT_OF_IMAGINATION,
CANCELED_EARLY,
BUILD_ENDED
};
#endif //!__EQUICKBUILDFAILREASON__H__

15
dCommon/dEnums/eRebuildState.h Normal file
View File

@ -0,0 +1,15 @@
#ifndef __EREBUILDSTATE__H__
#define __EREBUILDSTATE__H__
#include <cstdint>
enum class eRebuildState : uint32_t {
OPEN,
COMPLETED = 2,
RESETTING = 4,
BUILDING,
INCOMPLETE
};
#endif //!__EREBUILDSTATE__H__

15
dCommon/dEnums/eRenameResponse.h Normal file
View File

@ -0,0 +1,15 @@
#ifndef __ERENAMERESPONSE__H__
#define __ERENAMERESPONSE__H__
#include <cstdint>
//! An enum for character rename responses
enum class eRenameResponse : uint8_t {
SUCCESS = 0,
UNKNOWN_ERROR,
NAME_UNAVAILABLE,
NAME_IN_USE
};
#endif //!__ERENAMERESPONSE__H__

12
dCommon/dEnums/eReplicaPacketType.h Normal file
View File

@ -0,0 +1,12 @@
#ifndef __EREPLICAPACKETTYPE__H__
#define __EREPLICAPACKETTYPE__H__
#include <cstdint>
enum class eReplicaPacketType : uint8_t {
CONSTRUCTION,
SERIALIZATION,
DESTRUCTION
};
#endif //!__EREPLICAPACKETTYPE__H__

11
dCommon/dEnums/eStateChangeType.h Normal file
View File

@ -0,0 +1,11 @@
#ifndef __ESTATECHANGETYPE__H__
#define __ESTATECHANGETYPE__H__
#include <cstdint>
enum class eStateChangeType : uint32_t {
PUSH,
POP
};
#endif //!__ESTATECHANGETYPE__H__

12
dCommon/dEnums/eTerminateType.h Normal file
View File

@ -0,0 +1,12 @@
#ifndef __ETERMINATETYPE__H__
#define __ETERMINATETYPE__H__
#include <cstdint>
enum class eTerminateType : uint32_t {
RANGE,
USER,
FROM_INTERACTION
};
#endif //!__ETERMINATETYPE__H__

12
dCommon/dEnums/eUseItemResponse.h Normal file
View File

@ -0,0 +1,12 @@
#ifndef __EUSEITEMRESPONSE__H__
#define __EUSEITEMRESPONSE__H__
#include <cstdint>
enum class eUseItemResponse : uint32_t {
NoImaginationForPet = 1,
FailedPrecondition,
MountsNotAllowed
};
#endif //!__EUSEITEMRESPONSE__H__

28
dGame/Character.cpp
View File

@ -18,7 +18,9 @@
#include "InventoryComponent.h"
#include "eMissionTaskType.h"
#include "eMissionState.h"
#include "eObjectBits.h"
#include "eGameMasterLevel.h"
#include "ePlayerFlag.h"
Character::Character(uint32_t id, User* parentUser) {
//First load the name, etc:
@ -69,8 +71,8 @@ Character::Character(uint32_t id, User* parentUser) {
//Set our objectID:
m_ObjectID = m_ID;
m_ObjectID = GeneralUtils::SetBit(m_ObjectID, OBJECT_BIT_CHARACTER);
m_ObjectID = GeneralUtils::SetBit(m_ObjectID, OBJECT_BIT_PERSISTENT);
GeneralUtils::SetBit(m_ObjectID, eObjectBits::CHARACTER);
GeneralUtils::SetBit(m_ObjectID, eObjectBits::PERSISTENT);
m_ParentUser = parentUser;
m_OurEntity = nullptr;
@ -128,8 +130,8 @@ void Character::UpdateFromDatabase() {
//Set our objectID:
m_ObjectID = m_ID;
m_ObjectID = GeneralUtils::SetBit(m_ObjectID, OBJECT_BIT_CHARACTER);
m_ObjectID = GeneralUtils::SetBit(m_ObjectID, OBJECT_BIT_PERSISTENT);
GeneralUtils::SetBit(m_ObjectID, eObjectBits::CHARACTER);
GeneralUtils::SetBit(m_ObjectID, eObjectBits::PERSISTENT);
m_OurEntity = nullptr;
m_BuildMode = false;
@ -361,9 +363,9 @@ void Character::SaveXMLToDatabase() {
}
// Prevents the news feed from showing up on world transfers
if (GetPlayerFlag(ePlayerFlags::IS_NEWS_SCREEN_VISIBLE)) {
if (GetPlayerFlag(ePlayerFlag::IS_NEWS_SCREEN_VISIBLE)) {
auto* s = m_Doc->NewElement("s");
s->SetAttribute("si", ePlayerFlags::IS_NEWS_SCREEN_VISIBLE);
s->SetAttribute("si", ePlayerFlag::IS_NEWS_SCREEN_VISIBLE);
flags->LinkEndChild(s);
}
@ -416,7 +418,7 @@ void Character::WriteToDatabase() {
delete printer;
}
void Character::SetPlayerFlag(const uint32_t flagId, const bool value) {
void Character::SetPlayerFlag(const int32_t flagId, const bool value) {
// If the flag is already set, we don't have to recalculate it
if (GetPlayerFlag(flagId) == value) return;
@ -463,7 +465,7 @@ void Character::SetPlayerFlag(const uint32_t flagId, const bool value) {
GameMessages::SendNotifyClientFlagChange(m_ObjectID, flagId, value, m_ParentUser->GetSystemAddress());
}
bool Character::GetPlayerFlag(const uint32_t flagId) const {
bool Character::GetPlayerFlag(const int32_t flagId) const {
// Calculate the index first
const auto flagIndex = uint32_t(std::floor(flagId / 64));
@ -480,8 +482,8 @@ bool Character::GetPlayerFlag(const uint32_t flagId) const {
void Character::SetRetroactiveFlags() {
// Retroactive check for if player has joined a faction to set their 'joined a faction' flag to true.
if (GetPlayerFlag(ePlayerFlags::VENTURE_FACTION) || GetPlayerFlag(ePlayerFlags::ASSEMBLY_FACTION) || GetPlayerFlag(ePlayerFlags::PARADOX_FACTION) || GetPlayerFlag(ePlayerFlags::SENTINEL_FACTION)) {
SetPlayerFlag(ePlayerFlags::JOINED_A_FACTION, true);
if (GetPlayerFlag(ePlayerFlag::VENTURE_FACTION) || GetPlayerFlag(ePlayerFlag::ASSEMBLY_FACTION) || GetPlayerFlag(ePlayerFlag::PARADOX_FACTION) || GetPlayerFlag(ePlayerFlag::SENTINEL_FACTION)) {
SetPlayerFlag(ePlayerFlag::JOINED_A_FACTION, true);
}
}
@ -541,7 +543,7 @@ void Character::OnZoneLoad() {
if (missionComponent != nullptr) {
// Fix the monument race flag
if (missionComponent->GetMissionState(319) >= eMissionState::READY_TO_COMPLETE) {
SetPlayerFlag(33, true);
SetPlayerFlag(ePlayerFlag::AG_FINISH_LINE_BUILT, true);
}
}
@ -557,7 +559,7 @@ void Character::OnZoneLoad() {
*/
if (HasPermission(ePermissionMap::Old)) {
if (GetCoins() > 1000000) {
SetCoins(1000000, eLootSourceType::LOOT_SOURCE_NONE);
SetCoins(1000000, eLootSourceType::NONE);
}
}
@ -635,7 +637,7 @@ void Character::SetBillboardVisible(bool visible) {
// The GameMessage we send for turning the nameplate off just deletes the BillboardSubcomponent from the parent component.
// Because that same message does not allow for custom parameters, we need to create the BillboardSubcomponent a different way
// This workaround involves sending an unrelated GameMessage that does not apply to player entites,
// This workaround involves sending an unrelated GameMessage that does not apply to player entites,
// but forces the client to create the necessary SubComponent that controls the billboard.
GameMessages::SendShowBillboardInteractIcon(UNASSIGNED_SYSTEM_ADDRESS, m_OurEntity->GetObjectID());

5
dGame/Character.h
View File

@ -16,6 +16,7 @@ struct Packet;
class Entity;
enum class ePermissionMap : uint64_t;
enum class eGameMasterLevel : uint8_t;
enum class eLootSourceType : uint32_t;
/**
* Meta information about a character, like their name and style
@ -414,14 +415,14 @@ public:
* @param flagId the ID of the flag to set
* @param value the value to set for the flag
*/
void SetPlayerFlag(uint32_t flagId, bool value);
void SetPlayerFlag(int32_t flagId, bool value);
/**
* Gets the value for a certain character flag
* @param flagId the ID of the flag to get a value for
* @return the value of the flag given the ID (the default is false, obviously)
*/
bool GetPlayerFlag(uint32_t flagId) const;
bool GetPlayerFlag(int32_t flagId) const;
/**
* Notifies the character that they're now muted

19
dGame/Entity.cpp
View File

@ -24,6 +24,7 @@
#include "Loot.h"
#include "eMissionTaskType.h"
#include "eTriggerEventType.h"
#include "eObjectBits.h"
//Component includes:
#include "Component.h"
@ -72,6 +73,7 @@
#include "TriggerComponent.h"
#include "eGameMasterLevel.h"
#include "eReplicaComponentType.h"
#include "eReplicaPacketType.h"
// Table includes
#include "CDComponentsRegistryTable.h"
@ -727,7 +729,7 @@ void Entity::Initialize() {
if (!m_Character && EntityManager::Instance()->GetGhostingEnabled()) {
// Don't ghost what is likely large scene elements
if (m_Components.size() == 2 && HasComponent(eReplicaComponentType::SIMPLE_PHYSICS) && HasComponent(eReplicaComponentType::RENDER)) {
if (HasComponent(eReplicaComponentType::SIMPLE_PHYSICS) && HasComponent(eReplicaComponentType::RENDER) && (m_Components.size() == 2 || (HasComponent(eReplicaComponentType::TRIGGER) && m_Components.size() == 3))) {
goto no_ghosting;
}
@ -875,7 +877,7 @@ void Entity::SetGMLevel(eGameMasterLevel value) {
}
void Entity::WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacketType packetType) {
if (packetType == PACKET_TYPE_CONSTRUCTION) {
if (packetType == eReplicaPacketType::CONSTRUCTION) {
outBitStream->Write(m_ObjectID);
outBitStream->Write(m_TemplateID);
@ -952,9 +954,9 @@ void Entity::WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacke
if (m_ParentEntity != nullptr || m_SpawnerID != 0) {
outBitStream->Write1();
if (m_ParentEntity != nullptr) outBitStream->Write(GeneralUtils::SetBit(m_ParentEntity->GetObjectID(), OBJECT_BIT_CLIENT));
if (m_ParentEntity != nullptr) outBitStream->Write(GeneralUtils::SetBit(m_ParentEntity->GetObjectID(), static_cast<uint32_t>(eObjectBits::CLIENT)));
else if (m_Spawner != nullptr && m_Spawner->m_Info.isNetwork) outBitStream->Write(m_SpawnerID);
else outBitStream->Write(GeneralUtils::SetBit(m_SpawnerID, OBJECT_BIT_CLIENT));
else outBitStream->Write(GeneralUtils::SetBit(m_SpawnerID, static_cast<uint32_t>(eObjectBits::CLIENT)));
} else outBitStream->Write0();
outBitStream->Write(m_HasSpawnerNodeID);
@ -977,8 +979,8 @@ void Entity::WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacke
}
// Only serialize parent / child info should the info be dirty (changed) or if this is the construction of the entity.
outBitStream->Write(m_IsParentChildDirty || packetType == PACKET_TYPE_CONSTRUCTION);
if (m_IsParentChildDirty || packetType == PACKET_TYPE_CONSTRUCTION) {
outBitStream->Write(m_IsParentChildDirty || packetType == eReplicaPacketType::CONSTRUCTION);
if (m_IsParentChildDirty || packetType == eReplicaPacketType::CONSTRUCTION) {
m_IsParentChildDirty = false;
outBitStream->Write(m_ParentEntity != nullptr);
if (m_ParentEntity) {
@ -1003,7 +1005,7 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
bool destroyableSerialized = false;
bool bIsInitialUpdate = false;
if (packetType == PACKET_TYPE_CONSTRUCTION) bIsInitialUpdate = true;
if (packetType == eReplicaPacketType::CONSTRUCTION) bIsInitialUpdate = true;
unsigned int flags = 0;
PossessableComponent* possessableComponent;
@ -1232,6 +1234,7 @@ void Entity::Update(const float deltaTime) {
for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
script->OnTimerDone(this, timerName);
}
TriggerEvent(eTriggerEventType::TIMER_DONE, this);
} else {
timerPosition++;
}
@ -1622,7 +1625,7 @@ void Entity::PickupItem(const LWOOBJID& objectID) {
}
}
} else {
inv->AddItem(p.second.lot, p.second.count, eLootSourceType::LOOT_SOURCE_PICKUP, eInventoryType::INVALID, {}, LWOOBJID_EMPTY, true, false, LWOOBJID_EMPTY, eInventoryType::INVALID, 1);
inv->AddItem(p.second.lot, p.second.count, eLootSourceType::PICKUP, eInventoryType::INVALID, {}, LWOOBJID_EMPTY, true, false, LWOOBJID_EMPTY, eInventoryType::INVALID, 1);
}
}
}

3
dGame/Entity.h
View File

@ -10,6 +10,7 @@
#include "NiPoint3.h"
#include "NiQuaternion.h"
#include "LDFFormat.h"
#include "eKillType.h"
namespace Loot {
class Info;
@ -33,6 +34,8 @@ class EntityCallbackTimer;
enum class eTriggerEventType;
enum class eGameMasterLevel : uint8_t;
enum class eReplicaComponentType : uint32_t;
enum class eReplicaPacketType : uint8_t;
enum class eCinematicEvent : uint32_t;
namespace CppScripts {
class Script;

18
dGame/EntityManager.cpp
View File

@ -20,8 +20,10 @@
#include "MessageIdentifiers.h"
#include "dConfig.h"
#include "eTriggerEventType.h"
#include "eObjectBits.h"
#include "eGameMasterLevel.h"
#include "eReplicaComponentType.h"
#include "eReplicaPacketType.h"
EntityManager* EntityManager::m_Address = nullptr;
@ -108,11 +110,11 @@ Entity* EntityManager::CreateEntity(EntityInfo info, User* user, Entity* parentE
if (!controller && info.lot != 14) {
// The client flags means the client should render the entity
id = GeneralUtils::SetBit(id, OBJECT_BIT_CLIENT);
GeneralUtils::SetBit(id, eObjectBits::CLIENT);
// Spawned entities require the spawned flag to render
if (info.spawnerID != 0) {
id = GeneralUtils::SetBit(id, OBJECT_BIT_SPAWNED);
GeneralUtils::SetBit(id, eObjectBits::SPAWNED);
}
}
}
@ -196,8 +198,8 @@ void EntityManager::UpdateEntities(const float deltaTime) {
stream.Write(static_cast<char>(ID_REPLICA_MANAGER_SERIALIZE));
stream.Write(static_cast<unsigned short>(entity->GetNetworkId()));
entity->WriteBaseReplicaData(&stream, PACKET_TYPE_SERIALIZATION);
entity->WriteComponents(&stream, PACKET_TYPE_SERIALIZATION);
entity->WriteBaseReplicaData(&stream, eReplicaPacketType::SERIALIZATION);
entity->WriteComponents(&stream, eReplicaPacketType::SERIALIZATION);
if (entity->GetIsGhostingCandidate()) {
for (auto* player : Player::GetAllPlayers()) {
@ -217,9 +219,9 @@ void EntityManager::UpdateEntities(const float deltaTime) {
if (!entity) continue;
if (entity->GetScheduledKiller()) {
entity->Smash(entity->GetScheduledKiller()->GetObjectID(), SILENT);
entity->Smash(entity->GetScheduledKiller()->GetObjectID(), eKillType::SILENT);
} else {
entity->Smash(LWOOBJID_EMPTY, SILENT);
entity->Smash(LWOOBJID_EMPTY, eKillType::SILENT);
}
}
m_EntitiesToKill.clear();
@ -351,8 +353,8 @@ void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr
stream.Write(true);
stream.Write(static_cast<unsigned short>(entity->GetNetworkId()));
entity->WriteBaseReplicaData(&stream, PACKET_TYPE_CONSTRUCTION);
entity->WriteComponents(&stream, PACKET_TYPE_CONSTRUCTION);
entity->WriteBaseReplicaData(&stream, eReplicaPacketType::CONSTRUCTION);
entity->WriteComponents(&stream, eReplicaPacketType::CONSTRUCTION);
if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) {
if (skipChecks) {

8
dGame/TradingManager.cpp
View File

@ -156,21 +156,21 @@ void Trade::Complete() {
}
// Now actually do the trade.
characterA->SetCoins(characterA->GetCoins() - m_CoinsA + m_CoinsB, eLootSourceType::LOOT_SOURCE_TRADE);
characterB->SetCoins(characterB->GetCoins() - m_CoinsB + m_CoinsA, eLootSourceType::LOOT_SOURCE_TRADE);
characterA->SetCoins(characterA->GetCoins() - m_CoinsA + m_CoinsB, eLootSourceType::TRADE);
characterB->SetCoins(characterB->GetCoins() - m_CoinsB + m_CoinsA, eLootSourceType::TRADE);
for (const auto& tradeItem : m_ItemsA) {
auto* itemToRemove = inventoryA->FindItemById(tradeItem.itemId);
if (itemToRemove) itemToRemove->SetCount(itemToRemove->GetCount() - tradeItem.itemCount);
missionsA->Progress(eMissionTaskType::GATHER, tradeItem.itemLot, LWOOBJID_EMPTY, "", -tradeItem.itemCount);
inventoryB->AddItem(tradeItem.itemLot, tradeItem.itemCount, eLootSourceType::LOOT_SOURCE_TRADE);
inventoryB->AddItem(tradeItem.itemLot, tradeItem.itemCount, eLootSourceType::TRADE);
}
for (const auto& tradeItem : m_ItemsB) {
auto* itemToRemove = inventoryB->FindItemById(tradeItem.itemId);
if (itemToRemove) itemToRemove->SetCount(itemToRemove->GetCount() - tradeItem.itemCount);
missionsB->Progress(eMissionTaskType::GATHER, tradeItem.itemLot, LWOOBJID_EMPTY, "", -tradeItem.itemCount);
inventoryA->AddItem(tradeItem.itemLot, tradeItem.itemCount, eLootSourceType::LOOT_SOURCE_TRADE);
inventoryA->AddItem(tradeItem.itemLot, tradeItem.itemCount, eLootSourceType::TRADE);
}
characterA->SaveXMLToDatabase();

35
dGame/UserManager.cpp
View File

@ -23,7 +23,10 @@
#include "AssetManager.h"
#include "CDClientDatabase.h"
#include "dMessageIdentifiers.h"
#include "eObjectBits.h"
#include "eGameMasterLevel.h"
#include "eCharacterCreationResponse.h"
#include "eRenameResponse.h"
UserManager* UserManager::m_Address = nullptr;
@ -268,13 +271,13 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
if (name != "" && !UserManager::IsNameAvailable(name)) {
Game::logger->Log("UserManager", "AccountID: %i chose unavailable name: %s", u->GetAccountID(), name.c_str());
WorldPackets::SendCharacterCreationResponse(sysAddr, CREATION_RESPONSE_CUSTOM_NAME_IN_USE);
WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::CUSTOM_NAME_IN_USE);
return;
}
if (!IsNameAvailable(predefinedName)) {
Game::logger->Log("UserManager", "AccountID: %i chose unavailable predefined name: %s", u->GetAccountID(), predefinedName.c_str());
WorldPackets::SendCharacterCreationResponse(sysAddr, CREATION_RESPONSE_PREDEFINED_NAME_IN_USE);
WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::PREDEFINED_NAME_IN_USE);
return;
}
@ -293,7 +296,7 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
if (overlapResult->next()) {
Game::logger->Log("UserManager", "Character object id unavailable, check objectidtracker!");
WorldPackets::SendCharacterCreationResponse(sysAddr, CREATION_RESPONSE_OBJECT_ID_UNAVAILABLE);
WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::OBJECT_ID_UNAVAILABLE);
return;
}
@ -313,16 +316,16 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
std::stringstream xml2;
LWOOBJID lwoidforshirt = idforshirt;
lwoidforshirt = GeneralUtils::SetBit(lwoidforshirt, OBJECT_BIT_CHARACTER);
lwoidforshirt = GeneralUtils::SetBit(lwoidforshirt, OBJECT_BIT_PERSISTENT);
GeneralUtils::SetBit(lwoidforshirt, eObjectBits::CHARACTER);
GeneralUtils::SetBit(lwoidforshirt, eObjectBits::PERSISTENT);
xml2 << xmlSave1 << "<i l=\"" << shirtLOT << "\" id=\"" << lwoidforshirt << "\" s=\"0\" c=\"1\" eq=\"1\" b=\"1\"/>";
std::string xmlSave2 = xml2.str();
ObjectIDManager::Instance()->RequestPersistentID([=](uint32_t idforpants) {
LWOOBJID lwoidforpants = idforpants;
lwoidforpants = GeneralUtils::SetBit(lwoidforpants, OBJECT_BIT_CHARACTER);
lwoidforpants = GeneralUtils::SetBit(lwoidforpants, OBJECT_BIT_PERSISTENT);
GeneralUtils::SetBit(lwoidforpants, eObjectBits::CHARACTER);
GeneralUtils::SetBit(lwoidforpants, eObjectBits::PERSISTENT);
std::stringstream xml3;
xml3 << xmlSave2 << "<i l=\"" << pantsLOT << "\" id=\"" << lwoidforpants << "\" s=\"1\" c=\"1\" eq=\"1\" b=\"1\"/>";
@ -369,7 +372,7 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
stmt->execute();
delete stmt;
WorldPackets::SendCharacterCreationResponse(sysAddr, CREATION_RESPONSE_SUCCESS);
WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::SUCCESS);
UserManager::RequestCharacterList(sysAddr);
});
});
@ -480,8 +483,8 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
}
LWOOBJID objectID = PacketUtils::ReadPacketS64(8, packet);
objectID = GeneralUtils::ClearBit(objectID, OBJECT_BIT_CHARACTER);
objectID = GeneralUtils::ClearBit(objectID, OBJECT_BIT_PERSISTENT);
GeneralUtils::ClearBit(objectID, eObjectBits::CHARACTER);
GeneralUtils::ClearBit(objectID, eObjectBits::PERSISTENT);
uint32_t charID = static_cast<uint32_t>(objectID);
Game::logger->Log("UserManager", "Received char rename request for ID: %llu (%u)", objectID, charID);
@ -499,10 +502,10 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
if (!hasCharacter || !character) {
Game::logger->Log("UserManager", "User %i tried to rename a character that it does not own!", u->GetAccountID());
WorldPackets::SendCharacterRenameResponse(sysAddr, RENAME_RESPONSE_UNKNOWN_ERROR);
WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::UNKNOWN_ERROR);
} else if (hasCharacter && character) {
if (newName == character->GetName()) {
WorldPackets::SendCharacterRenameResponse(sysAddr, RENAME_RESPONSE_NAME_UNAVAILABLE);
WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::NAME_UNAVAILABLE);
return;
}
@ -516,7 +519,7 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
delete stmt;
Game::logger->Log("UserManager", "Character %s now known as %s", character->GetName().c_str(), newName.c_str());
WorldPackets::SendCharacterRenameResponse(sysAddr, RENAME_RESPONSE_SUCCESS);
WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::SUCCESS);
UserManager::RequestCharacterList(sysAddr);
} else {
sql::PreparedStatement* stmt = Database::CreatePreppedStmt("UPDATE charinfo SET pending_name=?, needs_rename=0, last_login=? WHERE id=? LIMIT 1");
@ -527,15 +530,15 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
delete stmt;
Game::logger->Log("UserManager", "Character %s has been renamed to %s and is pending approval by a moderator.", character->GetName().c_str(), newName.c_str());
WorldPackets::SendCharacterRenameResponse(sysAddr, RENAME_RESPONSE_SUCCESS);
WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::SUCCESS);
UserManager::RequestCharacterList(sysAddr);
}
} else {
WorldPackets::SendCharacterRenameResponse(sysAddr, RENAME_RESPONSE_NAME_IN_USE);
WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::NAME_IN_USE);
}
} else {
Game::logger->Log("UserManager", "Unknown error occurred when renaming character, either hasCharacter or character variable != true.");
WorldPackets::SendCharacterRenameResponse(sysAddr, RENAME_RESPONSE_UNKNOWN_ERROR);
WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::UNKNOWN_ERROR);
}
}

1
dGame/dBehaviors/ImmunityBehavior.cpp
View File

@ -7,6 +7,7 @@
#include "dLogger.h"
#include "DestroyableComponent.h"
#include "ControllablePhysicsComponent.h"
#include "eStateChangeType.h"
void ImmunityBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, const BehaviorBranchContext branch) {
auto* target = EntityManager::Instance()->GetEntity(branch.target);

3
dGame/dBehaviors/ProjectileAttackBehavior.cpp
View File

@ -6,6 +6,7 @@
#include "dLogger.h"
#include "SkillComponent.h"
#include "../dWorldServer/ObjectIDManager.h"
#include "eObjectBits.h"
void ProjectileAttackBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
LWOOBJID target{};
@ -107,7 +108,7 @@ void ProjectileAttackBehavior::Calculate(BehaviorContext* context, RakNet::BitSt
for (auto i = 0u; i < this->m_projectileCount; ++i) {
auto id = static_cast<LWOOBJID>(ObjectIDManager::Instance()->GenerateObjectID());
id = GeneralUtils::SetBit(id, OBJECT_BIT_SPAWNED);
GeneralUtils::SetBit(id, eObjectBits::SPAWNED);
bitStream->Write(id);

4
dGame/dComponents/BaseCombatAIComponent.cpp
View File

@ -248,7 +248,7 @@ void BaseCombatAIComponent::CalculateCombat(const float deltaTime) {
if (rebuild != nullptr) {
const auto state = rebuild->GetState();
if (state != REBUILD_COMPLETED) {
if (state != eRebuildState::COMPLETED) {
return;
}
}
@ -566,7 +566,7 @@ bool BaseCombatAIComponent::IsEnemy(LWOOBJID target) const {
if (quickbuild != nullptr) {
const auto state = quickbuild->GetState();
if (state != REBUILD_COMPLETED) {
if (state != eRebuildState::COMPLETED) {
return false;
}
}

3
dGame/dComponents/CharacterComponent.cpp
View File

@ -15,6 +15,7 @@
#include "Item.h"
#include "AMFFormat.h"
#include "eGameMasterLevel.h"
#include "eGameActivity.h"
CharacterComponent::CharacterComponent(Entity* parent, Character* character) : Component(parent) {
m_Character = character;
@ -35,7 +36,7 @@ CharacterComponent::CharacterComponent(Entity* parent, Character* character) : C
m_EditorLevel = m_GMLevel;
m_Reputation = 0;
m_CurrentActivity = 0;
m_CurrentActivity = eGameActivity::NONE;
m_CountryCode = 0;
m_LastUpdateTimestamp = std::time(nullptr);
}

8
dGame/dComponents/CharacterComponent.h
View File

@ -11,6 +11,8 @@
#include "tinyxml2.h"
#include "eReplicaComponentType.h"
enum class eGameActivity : uint32_t;
/**
* The statistics that can be achieved per zone
*/
@ -112,13 +114,13 @@ public:
* Gets the current activity that the character is partaking in, see ScriptedActivityComponent for more details
* @return the current activity that the character is partaking in
*/
const uint32_t GetCurrentActivity() const { return m_CurrentActivity; }
const eGameActivity GetCurrentActivity() const { return m_CurrentActivity; }
/**
* Set the current activity of the character, see ScriptedActivityComponent for more details
* @param currentActivity the activity to set
*/
void SetCurrentActivity(uint32_t currentActivity) { m_CurrentActivity = currentActivity; m_DirtyCurrentActivity = true; }
void SetCurrentActivity(eGameActivity currentActivity) { m_CurrentActivity = currentActivity; m_DirtyCurrentActivity = true; }
/**
* Gets if the entity is currently racing
@ -353,7 +355,7 @@ private:
/**
* The ID of the curently active activity
*/
int m_CurrentActivity;
eGameActivity m_CurrentActivity;
/**
* Whether the social info has been changed

1
dGame/dComponents/ControllablePhysicsComponent.cpp
View File

@ -13,6 +13,7 @@
#include "Character.h"
#include "dZoneManager.h"
#include "LevelProgressionComponent.h"
#include "eStateChangeType.h"
ControllablePhysicsComponent::ControllablePhysicsComponent(Entity* entity) : Component(entity) {
m_Position = {};

1
dGame/dComponents/ControllablePhysicsComponent.h
View File

@ -14,6 +14,7 @@
class Entity;
class dpEntity;
enum class eStateChangeType : uint32_t;
/**
* Handles the movement of controllable Entities, e.g. enemies and players

14
dGame/dComponents/DestroyableComponent.cpp
View File

@ -33,6 +33,8 @@
#include "dZoneManager.h"
#include "WorldConfig.h"
#include "eMissionTaskType.h"
#include "eStateChangeType.h"
#include "eGameActivity.h"
#include "CDComponentsRegistryTable.h"
@ -468,7 +470,7 @@ bool DestroyableComponent::IsKnockbackImmune() const {
auto* characterComponent = m_Parent->GetComponent<CharacterComponent>();
auto* inventoryComponent = m_Parent->GetComponent<InventoryComponent>();
if (characterComponent != nullptr && inventoryComponent != nullptr && characterComponent->GetCurrentActivity() == eGameActivities::ACTIVITY_QUICKBUILDING) {
if (characterComponent != nullptr && inventoryComponent != nullptr && characterComponent->GetCurrentActivity() == eGameActivity::QUICKBUILDING) {
const auto hasPassive = inventoryComponent->HasAnyPassive({
eItemSetPassiveAbilityID::EngineerRank2, eItemSetPassiveAbilityID::EngineerRank3,
eItemSetPassiveAbilityID::SummonerRank2, eItemSetPassiveAbilityID::SummonerRank3,
@ -514,7 +516,7 @@ bool DestroyableComponent::CheckValidity(const LWOOBJID target, const bool ignor
if (targetQuickbuild != nullptr) {
const auto state = targetQuickbuild->GetState();
if (state != REBUILD_COMPLETED) {
if (state != eRebuildState::COMPLETED) {
return false;
}
}
@ -803,7 +805,7 @@ void DestroyableComponent::Smash(const LWOOBJID source, const eKillType killType
coinsTotal -= coinsToLose;
LootGenerator::Instance().DropLoot(m_Parent, m_Parent, -1, coinsToLose, coinsToLose);
character->SetCoins(coinsTotal, eLootSourceType::LOOT_SOURCE_PICKUP);
character->SetCoins(coinsTotal, eLootSourceType::PICKUP);
}
}
@ -992,7 +994,7 @@ void DestroyableComponent::DoHardcoreModeDrops(const LWOOBJID source){
auto uscoreToLose = uscore * (EntityManager::Instance()->GetHardcoreLoseUscoreOnDeathPercent() / 100);
character->SetUScore(uscore - uscoreToLose);
GameMessages::SendModifyLEGOScore(m_Parent, m_Parent->GetSystemAddress(), -uscoreToLose, eLootSourceType::LOOT_SOURCE_MISSION);
GameMessages::SendModifyLEGOScore(m_Parent, m_Parent->GetSystemAddress(), -uscoreToLose, eLootSourceType::MISSION);
if (EntityManager::Instance()->GetHardcoreDropinventoryOnDeath()) {
//drop all items from inventory:
@ -1023,7 +1025,7 @@ void DestroyableComponent::DoHardcoreModeDrops(const LWOOBJID source){
auto coins = chars->GetCoins();
//lose all coins:
chars->SetCoins(0, eLootSourceType::LOOT_SOURCE_NONE);
chars->SetCoins(0, eLootSourceType::NONE);
//drop all coins:
GameMessages::SendDropClientLoot(m_Parent, source, LOT_NULL, coins, m_Parent->GetPosition());
@ -1047,7 +1049,7 @@ void DestroyableComponent::DoHardcoreModeDrops(const LWOOBJID source){
int uscore = maxHealth * EntityManager::Instance()->GetHardcoreUscoreEnemiesMultiplier();
playerStats->SetUScore(playerStats->GetUScore() + uscore);
GameMessages::SendModifyLEGOScore(player, player->GetSystemAddress(), uscore, eLootSourceType::LOOT_SOURCE_MISSION);
GameMessages::SendModifyLEGOScore(player, player->GetSystemAddress(), uscore, eLootSourceType::MISSION);
EntityManager::Instance()->SerializeEntity(m_Parent);
}

1
dGame/dComponents/DestroyableComponent.h
View File

@ -11,6 +11,7 @@
namespace CppScripts {
class Script;
}; //! namespace CppScripts
enum class eStateChangeType : uint32_t;
/**
* Represents the stats of an entity, for example its health, imagination and armor. Also handles factions, which

8
dGame/dComponents/InventoryComponent.cpp
View File

@ -29,6 +29,8 @@
#include "eUnequippableActiveType.h"
#include "CppScripts.h"
#include "eMissionTaskType.h"
#include "eStateChangeType.h"
#include "eUseItemResponse.h"
#include "CDComponentsRegistryTable.h"
#include "CDInventoryComponentTable.h"
@ -356,7 +358,7 @@ void InventoryComponent::MoveItemToInventory(Item* item, const eInventoryType in
left -= delta;
AddItem(lot, delta, eLootSourceType::LOOT_SOURCE_NONE, inventory, {}, LWOOBJID_EMPTY, showFlyingLot, isModMoveAndEquip, LWOOBJID_EMPTY, origin->GetType(), 0, false, preferredSlot);
AddItem(lot, delta, eLootSourceType::NONE, inventory, {}, LWOOBJID_EMPTY, showFlyingLot, isModMoveAndEquip, LWOOBJID_EMPTY, origin->GetType(), 0, false, preferredSlot);
item->SetCount(item->GetCount() - delta, false, false);
@ -371,7 +373,7 @@ void InventoryComponent::MoveItemToInventory(Item* item, const eInventoryType in
const auto delta = std::min<uint32_t>(item->GetCount(), count);
AddItem(lot, delta, eLootSourceType::LOOT_SOURCE_NONE, inventory, config, LWOOBJID_EMPTY, showFlyingLot, isModMoveAndEquip, subkey, origin->GetType(), 0, item->GetBound(), preferredSlot);
AddItem(lot, delta, eLootSourceType::NONE, inventory, config, LWOOBJID_EMPTY, showFlyingLot, isModMoveAndEquip, subkey, origin->GetType(), 0, item->GetBound(), preferredSlot);
item->SetCount(item->GetCount() - delta, false, false);
}
@ -1247,7 +1249,7 @@ void InventoryComponent::SpawnPet(Item* item) {
auto destroyableComponent = m_Parent->GetComponent<DestroyableComponent>();
if (Game::config->GetValue("pets_take_imagination") == "1" && destroyableComponent && destroyableComponent->GetImagination() <= 0) {
GameMessages::SendUseItemRequirementsResponse(m_Parent->GetObjectID(), m_Parent->GetSystemAddress(), UseItemResponse::NoImaginationForPet);
GameMessages::SendUseItemRequirementsResponse(m_Parent->GetObjectID(), m_Parent->GetSystemAddress(), eUseItemResponse::NoImaginationForPet);
return;
}

3
dGame/dComponents/InventoryComponent.h
View File

@ -21,6 +21,7 @@
#include "PossessorComponent.h"
#include "eInventoryType.h"
#include "eReplicaComponentType.h"
#include "eLootSourceType.h"
class Entity;
class ItemSet;
@ -99,7 +100,7 @@ public:
void AddItem(
LOT lot,
uint32_t count,
eLootSourceType lootSourceType = eLootSourceType::LOOT_SOURCE_NONE,
eLootSourceType lootSourceType = eLootSourceType::NONE,
eInventoryType inventoryType = INVALID,
const std::vector<LDFBaseData*>& config = {},
LWOOBJID parent = LWOOBJID_EMPTY,

2
dGame/dComponents/LevelProgressionComponent.cpp
View File

@ -59,7 +59,7 @@ void LevelProgressionComponent::HandleLevelUp() {
for (auto* reward : rewards) {
switch (reward->rewardType) {
case 0:
inventoryComponent->AddItem(reward->value, reward->count, eLootSourceType::LOOT_SOURCE_LEVEL_REWARD);
inventoryComponent->AddItem(reward->value, reward->count, eLootSourceType::LEVEL_REWARD);
break;
case 4:
{

37
dGame/dComponents/PetComponent.cpp
View File

@ -15,6 +15,10 @@
#include "PetDigServer.h"
#include "../dWorldServer/ObjectIDManager.h"
#include "eUnequippableActiveType.h"
#include "eTerminateType.h"
#include "ePetTamingNotifyType.h"
#include "eUseItemResponse.h"
#include "ePlayerFlag.h"
#include "Game.h"
#include "dConfig.h"
@ -22,6 +26,7 @@
#include "Database.h"
#include "EntityInfo.h"
#include "eMissionTaskType.h"
#include "eObjectBits.h"
#include "eGameMasterLevel.h"
std::unordered_map<LOT, PetComponent::PetPuzzleData> PetComponent::buildCache{};
@ -32,7 +37,7 @@ std::unordered_map<LWOOBJID, LWOOBJID> PetComponent::activePets{};
* Maps all the pet lots to a flag indicating that the player has caught it. All basic pets have been guessed by ObjID
* while the faction ones could be checked using their respective missions.
*/
std::map<LOT, uint32_t> PetComponent::petFlags = {
std::map<LOT, int32_t> PetComponent::petFlags = {
{ 3050, 801 }, // Elephant
{ 3054, 803 }, // Cat
{ 3195, 806 }, // Triceratops
@ -284,7 +289,7 @@ void PetComponent::OnUse(Entity* originator) {
m_Parent->GetObjectID(),
LWOOBJID_EMPTY,
true,
NOTIFY_TYPE_BEGIN,
ePetTamingNotifyType::BEGIN,
petPosition,
position,
rotation,
@ -296,7 +301,7 @@ void PetComponent::OnUse(Entity* originator) {
LWOOBJID_EMPTY,
originator->GetObjectID(),
true,
NOTIFY_TYPE_BEGIN,
ePetTamingNotifyType::BEGIN,
petPosition,
position,
rotation,
@ -312,7 +317,7 @@ void PetComponent::OnUse(Entity* originator) {
// Notify the start of a pet taming minigame
for (CppScripts::Script* script : CppScripts::GetEntityScripts(m_Parent)) {
script->OnNotifyPetTamingMinigame(m_Parent, originator, NOTIFY_TYPE_BEGIN);
script->OnNotifyPetTamingMinigame(m_Parent, originator, ePetTamingNotifyType::BEGIN);
}
}
@ -551,8 +556,8 @@ void PetComponent::NotifyTamingBuildSuccess(NiPoint3 position) {
LWOOBJID petSubKey = ObjectIDManager::Instance()->GenerateRandomObjectID();
petSubKey = GeneralUtils::SetBit(petSubKey, OBJECT_BIT_CHARACTER);
petSubKey = GeneralUtils::SetBit(petSubKey, OBJECT_BIT_PERSISTENT);
GeneralUtils::SetBit(petSubKey, eObjectBits::CHARACTER);
GeneralUtils::SetBit(petSubKey, eObjectBits::PERSISTENT);
m_DatabaseId = petSubKey;
@ -565,7 +570,7 @@ void PetComponent::NotifyTamingBuildSuccess(NiPoint3 position) {
GameMessages::SendRegisterPetDBID(m_Tamer, petSubKey, tamer->GetSystemAddress());
inventoryComponent->AddItem(m_Parent->GetLOT(), 1, eLootSourceType::LOOT_SOURCE_ACTIVITY, eInventoryType::MODELS, {}, LWOOBJID_EMPTY, true, false, petSubKey);
inventoryComponent->AddItem(m_Parent->GetLOT(), 1, eLootSourceType::ACTIVITY, eInventoryType::MODELS, {}, LWOOBJID_EMPTY, true, false, petSubKey);
auto* item = inventoryComponent->FindItemBySubKey(petSubKey, MODELS);
if (item == nullptr) {
@ -589,7 +594,7 @@ void PetComponent::NotifyTamingBuildSuccess(NiPoint3 position) {
LWOOBJID_EMPTY,
LWOOBJID_EMPTY,
false,
NOTIFY_TYPE_NAMINGPET,
ePetTamingNotifyType::NAMINGPET,
NiPoint3::ZERO,
NiPoint3::ZERO,
NiQuaternion::IDENTITY,
@ -669,7 +674,7 @@ void PetComponent::RequestSetPetName(std::u16string name) {
m_Parent->GetObjectID(),
m_Tamer,
false,
NOTIFY_TYPE_SUCCESS,
ePetTamingNotifyType::SUCCESS,
NiPoint3::ZERO,
NiPoint3::ZERO,
NiQuaternion::IDENTITY,
@ -690,7 +695,7 @@ void PetComponent::RequestSetPetName(std::u16string name) {
// Notify the end of a pet taming minigame
for (CppScripts::Script* script : CppScripts::GetEntityScripts(m_Parent)) {
script->OnNotifyPetTamingMinigame(m_Parent, tamer, NOTIFY_TYPE_SUCCESS);
script->OnNotifyPetTamingMinigame(m_Parent, tamer, ePetTamingNotifyType::SUCCESS);
}
}
@ -710,7 +715,7 @@ void PetComponent::ClientExitTamingMinigame(bool voluntaryExit) {
m_Parent->GetObjectID(),
m_Tamer,
false,
NOTIFY_TYPE_QUIT,
ePetTamingNotifyType::QUIT,
NiPoint3::ZERO,
NiPoint3::ZERO,
NiQuaternion::IDENTITY,
@ -731,7 +736,7 @@ void PetComponent::ClientExitTamingMinigame(bool voluntaryExit) {
// Notify the end of a pet taming minigame
for (CppScripts::Script* script : CppScripts::GetEntityScripts(m_Parent)) {
script->OnNotifyPetTamingMinigame(m_Parent, tamer, NOTIFY_TYPE_QUIT);
script->OnNotifyPetTamingMinigame(m_Parent, tamer, ePetTamingNotifyType::QUIT);
}
}
@ -761,7 +766,7 @@ void PetComponent::ClientFailTamingMinigame() {
m_Parent->GetObjectID(),
m_Tamer,
false,
NOTIFY_TYPE_FAILED,
ePetTamingNotifyType::FAILED,
NiPoint3::ZERO,
NiPoint3::ZERO,
NiQuaternion::IDENTITY,
@ -782,7 +787,7 @@ void PetComponent::ClientFailTamingMinigame() {
// Notify the end of a pet taming minigame
for (CppScripts::Script* script : CppScripts::GetEntityScripts(m_Parent)) {
script->OnNotifyPetTamingMinigame(m_Parent, tamer, NOTIFY_TYPE_FAILED);
script->OnNotifyPetTamingMinigame(m_Parent, tamer, ePetTamingNotifyType::FAILED);
}
}
@ -883,7 +888,7 @@ void PetComponent::Activate(Item* item, bool registerPet, bool fromTaming) {
EntityManager::Instance()->SerializeEntity(m_Parent);
owner->GetCharacter()->SetPlayerFlag(69, true);
owner->GetCharacter()->SetPlayerFlag(ePlayerFlag::FIRST_MANUAL_PET_HIBERNATE, true);
if (registerPet) {
GameMessages::SendAddPetToPlayer(m_Owner, 0, GeneralUtils::UTF8ToUTF16(m_Name), m_DatabaseId, m_Parent->GetLOT(), owner->GetSystemAddress());
@ -927,7 +932,7 @@ void PetComponent::AddDrainImaginationTimer(Item* item, bool fromTaming) {
auto playerEntity = playerDestroyableComponent->GetParent();
if (!playerEntity) return;
GameMessages::SendUseItemRequirementsResponse(playerEntity->GetObjectID(), playerEntity->GetSystemAddress(), UseItemResponse::NoImaginationForPet);
GameMessages::SendUseItemRequirementsResponse(playerEntity->GetObjectID(), playerEntity->GetSystemAddress(), eUseItemResponse::NoImaginationForPet);
}
this->AddDrainImaginationTimer(item);

2
dGame/dComponents/PetComponent.h
View File

@ -263,7 +263,7 @@ private:
/**
* Flags that indicate that a player has tamed a pet, indexed by the LOT of the pet
*/
static std::map<LOT, uint32_t> petFlags;
static std::map<LOT, int32_t> petFlags;
/**
* The ID of the component in the pet component table

4
dGame/dComponents/PossessorComponent.cpp
View File

@ -4,6 +4,8 @@
#include "EntityManager.h"
#include "GameMessages.h"
#include "eUnequippableActiveType.h"
#include "eControlScheme.h"
#include "eStateChangeType.h"
PossessorComponent::PossessorComponent(Entity* parent) : Component(parent) {
m_Possessable = LWOOBJID_EMPTY;
@ -78,5 +80,5 @@ void PossessorComponent::Dismount(Entity* mount, bool forceDismount) {
if (characterComponent) characterComponent->SetIsRacing(false);
}
// Make sure we don't have wacky controls
GameMessages::SendSetPlayerControlScheme(m_Parent, eControlSceme::SCHEME_A);
GameMessages::SendSetPlayerControlScheme(m_Parent, eControlScheme::SCHEME_A);
}

5
dGame/dComponents/PropertyEntranceComponent.cpp
View File

@ -12,6 +12,7 @@
#include "UserManager.h"
#include "dLogger.h"
#include "AMFFormat.h"
#include "eObjectBits.h"
#include "eGameMasterLevel.h"
PropertyEntranceComponent::PropertyEntranceComponent(uint32_t componentID, Entity* parent) : Component(parent) {
@ -243,8 +244,8 @@ void PropertyEntranceComponent::OnPropertyEntranceSync(Entity* entity, bool incl
// Convert owner char id to LWOOBJID
LWOOBJID ownerObjId = owner;
ownerObjId = GeneralUtils::SetBit(ownerObjId, OBJECT_BIT_CHARACTER);
ownerObjId = GeneralUtils::SetBit(ownerObjId, OBJECT_BIT_PERSISTENT);
GeneralUtils::SetBit(ownerObjId, eObjectBits::CHARACTER);
GeneralUtils::SetBit(ownerObjId, eObjectBits::PERSISTENT);
// Query to get friend and best friend fields
auto friendCheck = Database::CreatePreppedStmt("SELECT best_friend FROM friends WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?)");

24
dGame/dComponents/PropertyManagementComponent.cpp
View File

@ -19,6 +19,7 @@
#include "PropertyEntranceComponent.h"
#include "InventoryComponent.h"
#include "eMissionTaskType.h"
#include "eObjectBits.h"
#include <vector>
#include "CppScripts.h"
@ -66,8 +67,8 @@ PropertyManagementComponent::PropertyManagementComponent(Entity* parent) : Compo
if (propertyEntry->next()) {
this->propertyId = propertyEntry->getUInt64(1);
this->owner = propertyEntry->getUInt64(2);
this->owner = GeneralUtils::SetBit(this->owner, OBJECT_BIT_CHARACTER);
this->owner = GeneralUtils::SetBit(this->owner, OBJECT_BIT_PERSISTENT);
GeneralUtils::SetBit(this->owner, eObjectBits::CHARACTER);
GeneralUtils::SetBit(this->owner, eObjectBits::PERSISTENT);
this->clone_Id = propertyEntry->getInt(2);
this->propertyName = propertyEntry->getString(5).c_str();
this->propertyDescription = propertyEntry->getString(6).c_str();
@ -372,16 +373,15 @@ void PropertyManagementComponent::UpdateModelPosition(const LWOOBJID id, const N
info.emulated = true;
info.emulator = EntityManager::Instance()->GetZoneControlEntity()->GetObjectID();
LWOOBJID id = static_cast<LWOOBJID>(persistentId) | 1ull << OBJECT_BIT_CLIENT;
info.spawnerID = id;
info.spawnerID = persistentId;
GeneralUtils::SetBit(info.spawnerID, eObjectBits::CLIENT);
const auto spawnerId = dZoneManager::Instance()->MakeSpawner(info);
auto* spawner = dZoneManager::Instance()->GetSpawner(spawnerId);
auto ldfModelBehavior = new LDFData<LWOOBJID>(u"modelBehaviors", 0);
auto userModelID = new LDFData<LWOOBJID>(u"userModelID", id);
auto userModelID = new LDFData<LWOOBJID>(u"userModelID", info.spawnerID);
auto modelType = new LDFData<int>(u"modelType", 2);
auto propertyObjectID = new LDFData<bool>(u"propertyObjectID", true);
auto componentWhitelist = new LDFData<int>(u"componentWhitelist", 1);
@ -476,7 +476,7 @@ void PropertyManagementComponent::DeleteModel(const LWOOBJID id, const int delet
settings.push_back(propertyObjectID);
settings.push_back(modelType);
inventoryComponent->AddItem(6662, 1, eLootSourceType::LOOT_SOURCE_DELETION, eInventoryType::MODELS_IN_BBB, settings, LWOOBJID_EMPTY, false, false, spawnerId);
inventoryComponent->AddItem(6662, 1, eLootSourceType::DELETION, eInventoryType::MODELS_IN_BBB, settings, LWOOBJID_EMPTY, false, false, spawnerId);
auto* item = inventoryComponent->FindItemBySubKey(spawnerId);
if (item == nullptr) {
@ -498,7 +498,7 @@ void PropertyManagementComponent::DeleteModel(const LWOOBJID id, const int delet
if (spawner != nullptr) {
dZoneManager::Instance()->RemoveSpawner(spawner->m_Info.spawnerID);
} else {
model->Smash(SILENT);
model->Smash(LWOOBJID_EMPTY, eKillType::SILENT);
}
item->SetCount(0, true, false, false);
@ -506,7 +506,7 @@ void PropertyManagementComponent::DeleteModel(const LWOOBJID id, const int delet
return;
}
inventoryComponent->AddItem(model->GetLOT(), 1, eLootSourceType::LOOT_SOURCE_DELETION, INVALID, {}, LWOOBJID_EMPTY, false);
inventoryComponent->AddItem(model->GetLOT(), 1, eLootSourceType::DELETION, INVALID, {}, LWOOBJID_EMPTY, false);
auto* item = inventoryComponent->FindItemByLot(model->GetLOT());
@ -551,7 +551,7 @@ void PropertyManagementComponent::DeleteModel(const LWOOBJID id, const int delet
if (spawner != nullptr) {
dZoneManager::Instance()->RemoveSpawner(spawner->m_Info.spawnerID);
} else {
model->Smash(SILENT);
model->Smash(LWOOBJID_EMPTY, eKillType::SILENT);
}
}
@ -622,8 +622,8 @@ void PropertyManagementComponent::Load() {
//BBB property models need to have extra stuff set for them:
if (lot == 14) {
LWOOBJID blueprintID = lookupResult->getUInt(10);
blueprintID = GeneralUtils::SetBit(blueprintID, OBJECT_BIT_CHARACTER);
blueprintID = GeneralUtils::SetBit(blueprintID, OBJECT_BIT_PERSISTENT);
GeneralUtils::SetBit(blueprintID, eObjectBits::CHARACTER);
GeneralUtils::SetBit(blueprintID, eObjectBits::PERSISTENT);
LDFBaseData* ldfBlueprintID = new LDFData<LWOOBJID>(u"blueprintid", blueprintID);
LDFBaseData* componentWhitelist = new LDFData<int>(u"componentWhitelist", 1);

4
dGame/dComponents/RacingControlComponent.cpp
View File

@ -311,7 +311,7 @@ void RacingControlComponent::OnRequestDie(Entity* player) {
if (!racingPlayer.noSmashOnReload) {
racingPlayer.smashedTimes++;
GameMessages::SendDie(vehicle, vehicle->GetObjectID(), LWOOBJID_EMPTY, true,
VIOLENT, u"", 0, 0, 90.0f, false, true, 0);
eKillType::VIOLENT, u"", 0, 0, 90.0f, false, true, 0);
auto* destroyableComponent = vehicle->GetComponent<DestroyableComponent>();
uint32_t respawnImagination = 0;
@ -765,7 +765,7 @@ void RacingControlComponent::Update(float deltaTime) {
// be smashed by death plane
if (vehiclePosition.y < -500) {
GameMessages::SendDie(vehicle, m_Parent->GetObjectID(),
LWOOBJID_EMPTY, true, VIOLENT, u"", 0, 0, 0,
LWOOBJID_EMPTY, true, eKillType::VIOLENT, u"", 0, 0, 0,
true, false, 0);
OnRequestDie(playerEntity);

3
dGame/dComponents/RailActivatorComponent.cpp
View File

@ -7,6 +7,7 @@
#include "RebuildComponent.h"
#include "Game.h"
#include "dLogger.h"
#include "eStateChangeType.h"
RailActivatorComponent::RailActivatorComponent(Entity* parent, int32_t componentID) : Component(parent) {
m_ComponentID = componentID;
@ -41,7 +42,7 @@ RailActivatorComponent::~RailActivatorComponent() = default;
void RailActivatorComponent::OnUse(Entity* originator) {
auto* rebuildComponent = m_Parent->GetComponent<RebuildComponent>();
if (rebuildComponent != nullptr && rebuildComponent->GetState() != REBUILD_COMPLETED)
if (rebuildComponent != nullptr && rebuildComponent->GetState() != eRebuildState::COMPLETED)
return;
if (rebuildComponent != nullptr) {

59
dGame/dComponents/RebuildComponent.cpp
View File

@ -9,6 +9,9 @@
#include "MissionComponent.h"
#include "eMissionTaskType.h"
#include "eTriggerEventType.h"
#include "eQuickBuildFailReason.h"
#include "eTerminateType.h"
#include "eGameActivity.h"
#include "dServer.h"
#include "PacketUtils.h"
@ -47,7 +50,7 @@ RebuildComponent::~RebuildComponent() {
Entity* builder = GetBuilder();
if (builder) {
CancelRebuild(builder, eFailReason::REASON_BUILD_ENDED, true);
CancelRebuild(builder, eQuickBuildFailReason::BUILD_ENDED, true);
}
DespawnActivator();
@ -66,7 +69,7 @@ void RebuildComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitia
// If build state is completed and we've already serialized once in the completed state,
// don't serializing this component anymore as this will cause the build to jump again.
// If state changes, serialization will begin again.
if (!m_StateDirty && m_State == REBUILD_COMPLETED) {
if (!m_StateDirty && m_State == eRebuildState::COMPLETED) {
outBitStream->Write0();
outBitStream->Write0();
return;
@ -90,7 +93,7 @@ void RebuildComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitia
outBitStream->Write1();
outBitStream->Write<uint32_t>(m_State);
outBitStream->Write(m_State);
outBitStream->Write(m_ShowResetEffect);
outBitStream->Write(m_Activator != nullptr);
@ -120,7 +123,7 @@ void RebuildComponent::Update(float deltaTime) {
}*/
switch (m_State) {
case REBUILD_OPEN: {
case eRebuildState::OPEN: {
SpawnActivator();
m_TimeBeforeDrain = 0;
@ -150,7 +153,7 @@ void RebuildComponent::Update(float deltaTime) {
break;
}
case REBUILD_COMPLETED: {
case eRebuildState::COMPLETED: {
m_Timer += deltaTime;
// For reset times < 0 this has to be handled manually
@ -172,7 +175,7 @@ void RebuildComponent::Update(float deltaTime) {
}
break;
}
case REBUILD_BUILDING:
case eRebuildState::BUILDING:
{
Entity* builder = GetBuilder();
@ -201,7 +204,7 @@ void RebuildComponent::Update(float deltaTime) {
++m_DrainedImagination;
if (newImagination == 0 && m_DrainedImagination < m_TakeImagination) {
CancelRebuild(builder, eFailReason::REASON_OUT_OF_IMAGINATION, true);
CancelRebuild(builder, eQuickBuildFailReason::OUT_OF_IMAGINATION, true);
break;
}
@ -213,7 +216,7 @@ void RebuildComponent::Update(float deltaTime) {
break;
}
case REBUILD_INCOMPLETE: {
case eRebuildState::INCOMPLETE: {
m_TimerIncomplete += deltaTime;
// For reset times < 0 this has to be handled manually
@ -234,12 +237,12 @@ void RebuildComponent::Update(float deltaTime) {
}
break;
}
case REBUILD_RESETTING: break;
case eRebuildState::RESETTING: break;
}
}
void RebuildComponent::OnUse(Entity* originator) {
if (GetBuilder() != nullptr || m_State == REBUILD_COMPLETED) {
if (GetBuilder() != nullptr || m_State == eRebuildState::COMPLETED) {
return;
}
@ -393,18 +396,18 @@ void RebuildComponent::SetRepositionPlayer(bool value) {
}
void RebuildComponent::StartRebuild(Entity* user) {
if (m_State == eRebuildState::REBUILD_OPEN || m_State == eRebuildState::REBUILD_COMPLETED || m_State == eRebuildState::REBUILD_INCOMPLETE) {
if (m_State == eRebuildState::OPEN || m_State == eRebuildState::COMPLETED || m_State == eRebuildState::INCOMPLETE) {
m_Builder = user->GetObjectID();
auto* character = user->GetComponent<CharacterComponent>();
character->SetCurrentActivity(eGameActivities::ACTIVITY_QUICKBUILDING);
character->SetCurrentActivity(eGameActivity::QUICKBUILDING);
EntityManager::Instance()->SerializeEntity(user);
GameMessages::SendRebuildNotifyState(m_Parent, m_State, eRebuildState::REBUILD_BUILDING, user->GetObjectID());
GameMessages::SendEnableRebuild(m_Parent, true, false, false, eFailReason::REASON_NOT_GIVEN, 0.0f, user->GetObjectID());
GameMessages::SendRebuildNotifyState(m_Parent, m_State, eRebuildState::BUILDING, user->GetObjectID());
GameMessages::SendEnableRebuild(m_Parent, true, false, false, eQuickBuildFailReason::NOT_GIVEN, 0.0f, user->GetObjectID());
m_State = eRebuildState::REBUILD_BUILDING;
m_State = eRebuildState::BUILDING;
m_StateDirty = true;
EntityManager::Instance()->SerializeEntity(m_Parent);
@ -432,7 +435,7 @@ void RebuildComponent::CompleteRebuild(Entity* user) {
auto* characterComponent = user->GetComponent<CharacterComponent>();
if (characterComponent != nullptr) {
characterComponent->SetCurrentActivity(eGameActivities::ACTIVITY_NONE);
characterComponent->SetCurrentActivity(eGameActivity::NONE);
characterComponent->TrackRebuildComplete();
} else {
Game::logger->Log("RebuildComponent", "Some user tried to finish the rebuild but they didn't have a character somehow.");
@ -441,13 +444,13 @@ void RebuildComponent::CompleteRebuild(Entity* user) {
EntityManager::Instance()->SerializeEntity(user);
GameMessages::SendRebuildNotifyState(m_Parent, m_State, eRebuildState::REBUILD_COMPLETED, user->GetObjectID());
GameMessages::SendRebuildNotifyState(m_Parent, m_State, eRebuildState::COMPLETED, user->GetObjectID());
GameMessages::SendPlayFXEffect(m_Parent, 507, u"create", "BrickFadeUpVisCompleteEffect", LWOOBJID_EMPTY, 0.4f, 1.0f, true);
GameMessages::SendEnableRebuild(m_Parent, false, false, true, eFailReason::REASON_NOT_GIVEN, m_ResetTime, user->GetObjectID());
GameMessages::SendEnableRebuild(m_Parent, false, false, true, eQuickBuildFailReason::NOT_GIVEN, m_ResetTime, user->GetObjectID());
GameMessages::SendTerminateInteraction(user->GetObjectID(), eTerminateType::FROM_INTERACTION, m_Parent->GetObjectID());
m_State = eRebuildState::REBUILD_COMPLETED;
m_State = eRebuildState::COMPLETED;
m_StateDirty = true;
m_Timer = 0.0f;
m_DrainedImagination = 0;
@ -520,17 +523,17 @@ void RebuildComponent::CompleteRebuild(Entity* user) {
void RebuildComponent::ResetRebuild(bool failed) {
Entity* builder = GetBuilder();
if (m_State == eRebuildState::REBUILD_BUILDING && builder) {
GameMessages::SendEnableRebuild(m_Parent, false, false, failed, eFailReason::REASON_NOT_GIVEN, m_ResetTime, builder->GetObjectID());
if (m_State == eRebuildState::BUILDING && builder) {
GameMessages::SendEnableRebuild(m_Parent, false, false, failed, eQuickBuildFailReason::NOT_GIVEN, m_ResetTime, builder->GetObjectID());
if (failed) {
GameMessages::SendPlayAnimation(builder, u"rebuild-fail");
}
}
GameMessages::SendRebuildNotifyState(m_Parent, m_State, eRebuildState::REBUILD_RESETTING, LWOOBJID_EMPTY);
GameMessages::SendRebuildNotifyState(m_Parent, m_State, eRebuildState::RESETTING, LWOOBJID_EMPTY);
m_State = eRebuildState::REBUILD_RESETTING;
m_State = eRebuildState::RESETTING;
m_StateDirty = true;
m_Timer = 0.0f;
m_TimerIncomplete = 0.0f;
@ -552,15 +555,15 @@ void RebuildComponent::ResetRebuild(bool failed) {
}
}
void RebuildComponent::CancelRebuild(Entity* entity, eFailReason failReason, bool skipChecks) {
if (m_State != eRebuildState::REBUILD_COMPLETED || skipChecks) {
void RebuildComponent::CancelRebuild(Entity* entity, eQuickBuildFailReason failReason, bool skipChecks) {
if (m_State != eRebuildState::COMPLETED || skipChecks) {
m_Builder = LWOOBJID_EMPTY;
const auto entityID = entity != nullptr ? entity->GetObjectID() : LWOOBJID_EMPTY;
// Notify the client that a state has changed
GameMessages::SendRebuildNotifyState(m_Parent, m_State, eRebuildState::REBUILD_INCOMPLETE, entityID);
GameMessages::SendRebuildNotifyState(m_Parent, m_State, eRebuildState::INCOMPLETE, entityID);
GameMessages::SendEnableRebuild(m_Parent, false, true, false, failReason, m_Timer, entityID);
// Now terminate any interaction with the rebuild
@ -568,7 +571,7 @@ void RebuildComponent::CancelRebuild(Entity* entity, eFailReason failReason, boo
GameMessages::SendTerminateInteraction(m_Parent->GetObjectID(), eTerminateType::FROM_INTERACTION, m_Parent->GetObjectID());
// Now update the component itself
m_State = eRebuildState::REBUILD_INCOMPLETE;
m_State = eRebuildState::INCOMPLETE;
m_StateDirty = true;
// Notify scripts and possible subscribers
@ -586,7 +589,7 @@ void RebuildComponent::CancelRebuild(Entity* entity, eFailReason failReason, boo
CharacterComponent* characterComponent = entity->GetComponent<CharacterComponent>();
if (characterComponent) {
characterComponent->SetCurrentActivity(eGameActivities::ACTIVITY_NONE);
characterComponent->SetCurrentActivity(eGameActivity::NONE);
EntityManager::Instance()->SerializeEntity(entity);
}
}

6
dGame/dComponents/RebuildComponent.h
View File

@ -10,8 +10,10 @@
#include "Preconditions.h"
#include "Component.h"
#include "eReplicaComponentType.h"
#include "eRebuildState.h"
class Entity;
enum class eQuickBuildFailReason : uint32_t;
/**
* Component that handles entities that can be built into other entities using the quick build mechanic. Generally
@ -215,7 +217,7 @@ public:
* @param failReason the reason the rebuild was cancelled
* @param skipChecks whether or not to skip the check for the rebuild not being completed
*/
void CancelRebuild(Entity* builder, eFailReason failReason, bool skipChecks = false);
void CancelRebuild(Entity* builder, eQuickBuildFailReason failReason, bool skipChecks = false);
private:
/**
* Whether or not the quickbuild state has been changed since we last serialized it.
@ -225,7 +227,7 @@ private:
/**
* The state the rebuild is currently in
*/
eRebuildState m_State = eRebuildState::REBUILD_OPEN;
eRebuildState m_State = eRebuildState::OPEN;
/**
* The time that has passed since initiating the rebuild

3
dGame/dComponents/RocketLaunchpadControlComponent.cpp
View File

@ -17,6 +17,7 @@
#include "dServer.h"
#include "dMessageIdentifiers.h"
#include "PacketUtils.h"
#include "eObjectWorldState.h"
RocketLaunchpadControlComponent::RocketLaunchpadControlComponent(Entity* parent, int rocketId) : Component(parent) {
auto query = CDClientDatabase::CreatePreppedStmt(
@ -77,7 +78,7 @@ void RocketLaunchpadControlComponent::Launch(Entity* originator, LWOMAPID mapId,
GameMessages::SendFireEventClientSide(m_Parent->GetObjectID(), originator->GetSystemAddress(), u"RocketEquipped", rocket->GetId(), cloneId, -1, originator->GetObjectID());
GameMessages::SendChangeObjectWorldState(rocket->GetId(), WORLDSTATE_ATTACHED, UNASSIGNED_SYSTEM_ADDRESS);
GameMessages::SendChangeObjectWorldState(rocket->GetId(), eObjectWorldState::ATTACHED, UNASSIGNED_SYSTEM_ADDRESS);
EntityManager::Instance()->SerializeEntity(originator);
}

17
dGame/dComponents/ScriptedActivityComponent.cpp
View File

@ -21,6 +21,7 @@
#include "dMessageIdentifiers.h"
#include "Loot.h"
#include "eMissionTaskType.h"
#include "eMatchUpdate.h"
#include "CDCurrencyTableTable.h"
#include "CDActivityRewardsTable.h"
@ -167,9 +168,9 @@ void ScriptedActivityComponent::PlayerJoinLobby(Entity* player) {
}
std::string matchUpdate = "player=9:" + std::to_string(entity->GetObjectID()) + "\nplayerName=0:" + entity->GetCharacter()->GetName();
GameMessages::SendMatchUpdate(player, player->GetSystemAddress(), matchUpdate, eMatchUpdate::MATCH_UPDATE_PLAYER_JOINED);
GameMessages::SendMatchUpdate(player, player->GetSystemAddress(), matchUpdate, eMatchUpdate::PLAYER_ADDED);
PlayerReady(entity, joinedPlayer->ready);
GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchUpdateJoined, eMatchUpdate::MATCH_UPDATE_PLAYER_JOINED);
GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchUpdateJoined, eMatchUpdate::PLAYER_ADDED);
}
}
}
@ -185,7 +186,7 @@ void ScriptedActivityComponent::PlayerJoinLobby(Entity* player) {
if (m_ActivityInfo.maxTeamSize != 1 && playerLobby->players.size() >= m_ActivityInfo.minTeamSize || m_ActivityInfo.maxTeamSize == 1 && playerLobby->players.size() >= m_ActivityInfo.minTeams) {
// Update the joining player on the match timer
std::string matchTimerUpdate = "time=3:" + std::to_string(playerLobby->timer);
GameMessages::SendMatchUpdate(player, player->GetSystemAddress(), matchTimerUpdate, eMatchUpdate::MATCH_UPDATE_TIME);
GameMessages::SendMatchUpdate(player, player->GetSystemAddress(), matchTimerUpdate, eMatchUpdate::PHASE_WAIT_READY);
}
}
@ -201,7 +202,7 @@ void ScriptedActivityComponent::PlayerLeave(LWOOBJID playerID) {
if (entity == nullptr)
continue;
GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchUpdateLeft, eMatchUpdate::MATCH_UPDATE_PLAYER_LEFT);
GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchUpdateLeft, eMatchUpdate::PLAYER_REMOVED);
}
delete lobby->players[i];
@ -242,7 +243,7 @@ void ScriptedActivityComponent::Update(float deltaTime) {
continue;
std::string matchTimerUpdate = "time=3:" + std::to_string(lobby->timer);
GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchTimerUpdate, eMatchUpdate::MATCH_UPDATE_TIME);
GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchTimerUpdate, eMatchUpdate::PHASE_WAIT_READY);
}
}
@ -267,7 +268,7 @@ void ScriptedActivityComponent::Update(float deltaTime) {
if (entity == nullptr)
continue;
GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchTimerUpdate, eMatchUpdate::MATCH_UPDATE_TIME_START_DELAY);
GameMessages::SendMatchUpdate(entity, entity->GetSystemAddress(), matchTimerUpdate, eMatchUpdate::PHASE_WAIT_START);
}
}
@ -375,8 +376,8 @@ void ScriptedActivityComponent::PlayerReady(Entity* player, bool bReady) {
// Update players in lobby on player being ready
std::string matchReadyUpdate = "player=9:" + std::to_string(player->GetObjectID());
eMatchUpdate readyStatus = eMatchUpdate::MATCH_UPDATE_PLAYER_READY;
if (!bReady) readyStatus = eMatchUpdate::MATCH_UPDATE_PLAYER_UNREADY;
eMatchUpdate readyStatus = eMatchUpdate::PLAYER_READY;
if (!bReady) readyStatus = eMatchUpdate::PLAYER_NOT_READY;
for (LobbyPlayer* otherPlayer : lobby->players) {
auto* entity = otherPlayer->GetEntity();
if (entity == nullptr)

2
dGame/dComponents/SkillComponent.cpp
View File

@ -260,6 +260,8 @@ SkillExecutionResult SkillComponent::CalculateBehavior(const uint32_t skillId, c
context->caster = m_Parent->GetObjectID();
context->skillID = skillId;
context->clientInitalized = clientInitalized;
context->foundTarget = target != LWOOBJID_EMPTY || ignoreTarget || clientInitalized;

2
dGame/dComponents/SwitchComponent.cpp
View File

@ -39,7 +39,7 @@ bool SwitchComponent::GetActive() const {
void SwitchComponent::EntityEnter(Entity* entity) {
if (!m_Active) {
if (m_Rebuild) {
if (m_Rebuild->GetState() != eRebuildState::REBUILD_COMPLETED) return;
if (m_Rebuild->GetState() != eRebuildState::COMPLETED) return;
}
m_Active = true;
if (!m_Parent) return;

40
dGame/dComponents/TriggerComponent.cpp
View File

@ -83,8 +83,12 @@ void TriggerComponent::HandleTriggerCommand(LUTriggers::Command* command, Entity
case eTriggerCommandType::REPEL_OBJECT:
HandleRepelObject(targetEntity, command->args);
break;
case eTriggerCommandType::SET_TIMER: break;
case eTriggerCommandType::CANCEL_TIMER: break;
case eTriggerCommandType::SET_TIMER:
HandleSetTimer(targetEntity, argArray);
break;
case eTriggerCommandType::CANCEL_TIMER:
HandleCancelTimer(targetEntity, command->args);
break;
case eTriggerCommandType::PLAY_CINEMATIC:
HandlePlayCinematic(targetEntity, argArray);
break;
@ -194,7 +198,7 @@ void TriggerComponent::HandleDestroyObject(Entity* targetEntity, std::string arg
void TriggerComponent::HandleToggleTrigger(Entity* targetEntity, std::string args){
auto* triggerComponent = targetEntity->GetComponent<TriggerComponent>();
if (!triggerComponent) {
Game::logger->Log("TriggerComponent::HandleToggleTrigger", "Trigger component not found!");
Game::logger->LogDebug("TriggerComponent::HandleToggleTrigger", "Trigger component not found!");
return;
}
triggerComponent->SetTriggerEnabled(args == "1");
@ -203,7 +207,7 @@ void TriggerComponent::HandleToggleTrigger(Entity* targetEntity, std::string arg
void TriggerComponent::HandleResetRebuild(Entity* targetEntity, std::string args){
auto* rebuildComponent = targetEntity->GetComponent<RebuildComponent>();
if (!rebuildComponent) {
Game::logger->Log("TriggerComponent::HandleResetRebuild", "Rebuild component not found!");
Game::logger->LogDebug("TriggerComponent::HandleResetRebuild", "Rebuild component not found!");
return;
}
rebuildComponent->ResetRebuild(args == "1");
@ -233,7 +237,7 @@ void TriggerComponent::HandleRotateObject(Entity* targetEntity, std::vector<std:
void TriggerComponent::HandlePushObject(Entity* targetEntity, std::vector<std::string> argArray){
auto* phantomPhysicsComponent = m_Parent->GetComponent<PhantomPhysicsComponent>();
if (!phantomPhysicsComponent) {
Game::logger->Log("TriggerComponent::HandlePushObject", "Phantom Physics component not found!");
Game::logger->LogDebug("TriggerComponent::HandlePushObject", "Phantom Physics component not found!");
return;
}
phantomPhysicsComponent->SetPhysicsEffectActive(true);
@ -250,7 +254,7 @@ void TriggerComponent::HandlePushObject(Entity* targetEntity, std::vector<std::s
void TriggerComponent::HandleRepelObject(Entity* targetEntity, std::string args){
auto* phantomPhysicsComponent = m_Parent->GetComponent<PhantomPhysicsComponent>();
if (!phantomPhysicsComponent) {
Game::logger->Log("TriggerComponent::HandleRepelObject", "Phantom Physics component not found!");
Game::logger->LogDebug("TriggerComponent::HandleRepelObject", "Phantom Physics component not found!");
return;
}
float forceMultiplier;
@ -271,6 +275,20 @@ void TriggerComponent::HandleRepelObject(Entity* targetEntity, std::string args)
EntityManager::Instance()->SerializeEntity(m_Parent);
}
void TriggerComponent::HandleSetTimer(Entity* targetEntity, std::vector<std::string> argArray){
if (argArray.size() != 2) {
Game::logger->LogDebug("TriggerComponent::HandleSetTimer", "Not ehought variables!");
return;
}
float time = 0.0;
GeneralUtils::TryParse<float>(argArray.at(1), time);
m_Parent->AddTimer(argArray.at(0), time);
}
void TriggerComponent::HandleCancelTimer(Entity* targetEntity, std::string args){
m_Parent->CancelTimer(args);
}
void TriggerComponent::HandlePlayCinematic(Entity* targetEntity, std::vector<std::string> argArray) {
float leadIn = -1.0;
auto wait = eEndBehavior::RETURN;
@ -300,7 +318,7 @@ void TriggerComponent::HandlePlayCinematic(Entity* targetEntity, std::vector<std
void TriggerComponent::HandleToggleBBB(Entity* targetEntity, std::string args) {
auto* character = targetEntity->GetCharacter();
if (!character) {
Game::logger->Log("TriggerComponent::HandleToggleBBB", "Character was not found!");
Game::logger->LogDebug("TriggerComponent::HandleToggleBBB", "Character was not found!");
return;
}
bool buildMode = !(character->GetBuildMode());
@ -316,7 +334,7 @@ void TriggerComponent::HandleUpdateMission(Entity* targetEntity, std::vector<std
if (argArray.at(0) != "exploretask") return;
MissionComponent* missionComponent = targetEntity->GetComponent<MissionComponent>();
if (!missionComponent){
Game::logger->Log("TriggerComponent::HandleUpdateMission", "Mission component not found!");
Game::logger->LogDebug("TriggerComponent::HandleUpdateMission", "Mission component not found!");
return;
}
missionComponent->Progress(eMissionTaskType::EXPLORE, 0, 0, argArray.at(4));
@ -335,7 +353,7 @@ void TriggerComponent::HandlePlayEffect(Entity* targetEntity, std::vector<std::s
void TriggerComponent::HandleCastSkill(Entity* targetEntity, std::string args){
auto* skillComponent = targetEntity->GetComponent<SkillComponent>();
if (!skillComponent) {
Game::logger->Log("TriggerComponent::HandleCastSkill", "Skill component not found!");
Game::logger->LogDebug("TriggerComponent::HandleCastSkill", "Skill component not found!");
return;
}
uint32_t skillId;
@ -346,7 +364,7 @@ void TriggerComponent::HandleCastSkill(Entity* targetEntity, std::string args){
void TriggerComponent::HandleSetPhysicsVolumeEffect(Entity* targetEntity, std::vector<std::string> argArray) {
auto* phantomPhysicsComponent = targetEntity->GetComponent<PhantomPhysicsComponent>();
if (!phantomPhysicsComponent) {
Game::logger->Log("TriggerComponent::HandleSetPhysicsVolumeEffect", "Phantom Physics component not found!");
Game::logger->LogDebug("TriggerComponent::HandleSetPhysicsVolumeEffect", "Phantom Physics component not found!");
return;
}
phantomPhysicsComponent->SetPhysicsEffectActive(true);
@ -381,7 +399,7 @@ void TriggerComponent::HandleSetPhysicsVolumeEffect(Entity* targetEntity, std::v
void TriggerComponent::HandleSetPhysicsVolumeStatus(Entity* targetEntity, std::string args) {
auto* phantomPhysicsComponent = targetEntity->GetComponent<PhantomPhysicsComponent>();
if (!phantomPhysicsComponent) {
Game::logger->Log("TriggerComponent::HandleSetPhysicsVolumeEffect", "Phantom Physics component not found!");
Game::logger->LogDebug("TriggerComponent::HandleSetPhysicsVolumeEffect", "Phantom Physics component not found!");
return;
}
phantomPhysicsComponent->SetPhysicsEffectActive(args == "On");

2
dGame/dComponents/TriggerComponent.h
View File

@ -30,6 +30,8 @@ private:
void HandleRotateObject(Entity* targetEntity, std::vector<std::string> argArray);
void HandlePushObject(Entity* targetEntity, std::vector<std::string> argArray);
void HandleRepelObject(Entity* targetEntity, std::string args);
void HandleSetTimer(Entity* targetEntity, std::vector<std::string> argArray);
void HandleCancelTimer(Entity* targetEntity, std::string args);
void HandlePlayCinematic(Entity* targetEntity, std::vector<std::string> argArray);
void HandleToggleBBB(Entity* targetEntity, std::string args);
void HandleUpdateMission(Entity* targetEntity, std::vector<std::string> argArray);

3
dGame/dComponents/VehiclePhysicsComponent.cpp
View File

@ -11,6 +11,7 @@ VehiclePhysicsComponent::VehiclePhysicsComponent(Entity* parent) : Component(par
m_DirtyPosition = true;
m_DirtyVelocity = true;
m_DirtyAngularVelocity = true;
m_EndBehavior = GeneralUtils::GenerateRandomNumber<uint32_t>(0, 7);
}
VehiclePhysicsComponent::~VehiclePhysicsComponent() {
@ -93,7 +94,7 @@ void VehiclePhysicsComponent::Serialize(RakNet::BitStream* outBitStream, bool bI
}
if (bIsInitialUpdate) {
outBitStream->Write<uint8_t>(5);
outBitStream->Write<uint8_t>(m_EndBehavior);
outBitStream->Write1();
}

1
dGame/dComponents/VehiclePhysicsComponent.h
View File

@ -109,4 +109,5 @@ private:
bool m_IsOnRail;
float m_SoftUpdate = 0;
uint32_t m_EndBehavior;
};

93
dGame/dGameMessages/GameMessages.cpp
View File

@ -34,7 +34,14 @@
#include "eRacingTaskParam.h"
#include "eMissionTaskType.h"
#include "eMissionState.h"
#include "eObjectBits.h"
#include "eTriggerEventType.h"
#include "eMatchUpdate.h"
#include "eCyclingMode.h"
#include "eCinematicEvent.h"
#include "eQuickBuildFailReason.h"
#include "eControlScheme.h"
#include "eStateChangeType.h"
#include <sstream>
#include <future>
@ -293,9 +300,9 @@ void GameMessages::SendPlayerSetCameraCyclingMode(const LWOOBJID& objectID, cons
bitStream.Write(bAllowCyclingWhileDeadOnly);
bitStream.Write(cyclingMode != ALLOW_CYCLE_TEAMMATES);
if (cyclingMode != ALLOW_CYCLE_TEAMMATES) {
bitStream.Write<uint32_t>(cyclingMode);
bitStream.Write(cyclingMode != eCyclingMode::ALLOW_CYCLE_TEAMMATES);
if (cyclingMode != eCyclingMode::ALLOW_CYCLE_TEAMMATES) {
bitStream.Write(cyclingMode);
}
SEND_PACKET;
@ -439,8 +446,8 @@ void GameMessages::SendAddItemToInventoryClientSync(Entity* entity, const System
bitStream.Write(item->GetInfo().isBOE);
bitStream.Write(item->GetInfo().isBOP);
bitStream.Write(lootSourceType != eLootSourceType::LOOT_SOURCE_NONE); // Loot source
if (lootSourceType != eLootSourceType::LOOT_SOURCE_NONE) bitStream.Write(lootSourceType);
bitStream.Write(lootSourceType != eLootSourceType::NONE); // Loot source
if (lootSourceType != eLootSourceType::NONE) bitStream.Write(lootSourceType);
LWONameValue extraInfo;
auto config = item->GetConfig();
@ -488,7 +495,7 @@ void GameMessages::SendAddItemToInventoryClientSync(Entity* entity, const System
SEND_PACKET;
}
void GameMessages::SendNotifyClientFlagChange(const LWOOBJID& objectID, int iFlagID, bool bFlag, const SystemAddress& sysAddr) {
void GameMessages::SendNotifyClientFlagChange(const LWOOBJID& objectID, uint32_t iFlagID, bool bFlag, const SystemAddress& sysAddr) {
CBITSTREAM;
CMSGHEADER;
@ -500,7 +507,7 @@ void GameMessages::SendNotifyClientFlagChange(const LWOOBJID& objectID, int iFla
SEND_PACKET;
}
void GameMessages::SendChangeObjectWorldState(const LWOOBJID& objectID, int state, const SystemAddress& sysAddr) {
void GameMessages::SendChangeObjectWorldState(const LWOOBJID& objectID, eObjectWorldState state, const SystemAddress& sysAddr) {
CBITSTREAM;
CMSGHEADER;
@ -581,8 +588,8 @@ void GameMessages::SendModifyLEGOScore(Entity* entity, const SystemAddress& sysA
bitStream.Write((uint16_t)GAME_MSG_MODIFY_LEGO_SCORE);
bitStream.Write(score);
bitStream.Write(sourceType != eLootSourceType::LOOT_SOURCE_NONE);
if (sourceType != eLootSourceType::LOOT_SOURCE_NONE) bitStream.Write(sourceType);
bitStream.Write(sourceType != eLootSourceType::NONE);
if (sourceType != eLootSourceType::NONE) bitStream.Write(sourceType);
SEND_PACKET;
}
@ -742,14 +749,14 @@ void GameMessages::SendSetCurrency(Entity* entity, int64_t currency, int lootTyp
bitStream.Write(sourceTradeID != LWOOBJID_EMPTY);
if (sourceTradeID != LWOOBJID_EMPTY) bitStream.Write(sourceTradeID);
bitStream.Write(sourceType != LOOTTYPE_NONE);
if (sourceType != LOOTTYPE_NONE) bitStream.Write(sourceType);
bitStream.Write(sourceType != eLootSourceType::NONE);
if (sourceType != eLootSourceType::NONE) bitStream.Write(sourceType);
SystemAddress sysAddr = entity->GetSystemAddress();
SEND_PACKET;
}
void GameMessages::SendRebuildNotifyState(Entity* entity, int prevState, int state, const LWOOBJID& playerID) {
void GameMessages::SendRebuildNotifyState(Entity* entity, eRebuildState prevState, eRebuildState state, const LWOOBJID& playerID) {
CBITSTREAM;
CMSGHEADER;
@ -763,7 +770,7 @@ void GameMessages::SendRebuildNotifyState(Entity* entity, int prevState, int sta
SEND_PACKET_BROADCAST;
}
void GameMessages::SendEnableRebuild(Entity* entity, bool enable, bool fail, bool success, int failReason, float duration, const LWOOBJID& playerID) {
void GameMessages::SendEnableRebuild(Entity* entity, bool enable, bool fail, bool success, eQuickBuildFailReason failReason, float duration, const LWOOBJID& playerID) {
CBITSTREAM;
CMSGHEADER;
@ -774,8 +781,8 @@ void GameMessages::SendEnableRebuild(Entity* entity, bool enable, bool fail, boo
bitStream.Write(fail);
bitStream.Write(success);
bitStream.Write(failReason != eFailReason::REASON_NOT_GIVEN);
if (failReason != eFailReason::REASON_NOT_GIVEN) bitStream.Write(failReason);
bitStream.Write(failReason != eQuickBuildFailReason::NOT_GIVEN);
if (failReason != eQuickBuildFailReason::NOT_GIVEN) bitStream.Write(failReason);
bitStream.Write(duration);
bitStream.Write(playerID);
@ -842,8 +849,8 @@ void GameMessages::SendDie(Entity* entity, const LWOOBJID& killerID, const LWOOB
bitStream.Write(directionRelative_AngleY);
bitStream.Write(directionRelative_Force);
bitStream.Write(killType != VIOLENT);
if (killType != VIOLENT) bitStream.Write(killType);
bitStream.Write(killType != eKillType::VIOLENT);
if (killType != eKillType::VIOLENT) bitStream.Write(killType);
bitStream.Write(killerID);
@ -1103,7 +1110,7 @@ void GameMessages::SendDropClientLoot(Entity* entity, const LWOOBJID& sourceID,
SEND_PACKET;
}
void GameMessages::SendSetPlayerControlScheme(Entity* entity, eControlSceme controlScheme) {
void GameMessages::SendSetPlayerControlScheme(Entity* entity, eControlScheme controlScheme) {
CBITSTREAM;
CMSGHEADER;
@ -1116,8 +1123,8 @@ void GameMessages::SendSetPlayerControlScheme(Entity* entity, eControlSceme cont
bitStream.Write(bDelayCamSwitchIfInCinematic);
bitStream.Write(bSwitchCam);
bitStream.Write(controlScheme != SCHEME_A);
if (controlScheme != SCHEME_A) bitStream.Write(controlScheme);
bitStream.Write(controlScheme != eControlScheme::SCHEME_A);
if (controlScheme != eControlScheme::SCHEME_A) bitStream.Write(controlScheme);
SystemAddress sysAddr = entity->GetSystemAddress();
SEND_PACKET;
@ -1375,7 +1382,7 @@ void GameMessages::SendUseItemResult(Entity* entity, LOT templateID, bool useIte
SEND_PACKET;
}
void GameMessages::SendUseItemRequirementsResponse(LWOOBJID objectID, const SystemAddress& sysAddr, UseItemResponse itemResponse) {
void GameMessages::SendUseItemRequirementsResponse(LWOOBJID objectID, const SystemAddress& sysAddr, eUseItemResponse itemResponse) {
CBITSTREAM;
CMSGHEADER;
@ -1448,7 +1455,7 @@ void GameMessages::SendMatchResponse(Entity* entity, const SystemAddress& sysAdd
SEND_PACKET;
}
void GameMessages::SendMatchUpdate(Entity* entity, const SystemAddress& sysAddr, std::string data, int type) {
void GameMessages::SendMatchUpdate(Entity* entity, const SystemAddress& sysAddr, std::string data, eMatchUpdate type) {
CBITSTREAM;
CMSGHEADER;
@ -2575,14 +2582,14 @@ void GameMessages::HandleBBBSaveRequest(RakNet::BitStream* inStream, Entity* ent
//We need to get a new ID for our model first:
ObjectIDManager::Instance()->RequestPersistentID([=](uint32_t newID) {
LWOOBJID newIDL = newID;
newIDL = GeneralUtils::SetBit(newIDL, OBJECT_BIT_CHARACTER);
newIDL = GeneralUtils::SetBit(newIDL, OBJECT_BIT_PERSISTENT);
GeneralUtils::SetBit(newIDL, eObjectBits::CHARACTER);
GeneralUtils::SetBit(newIDL, eObjectBits::PERSISTENT);
ObjectIDManager::Instance()->RequestPersistentID([=](uint32_t blueprintIDSmall) {
blueprintIDSmall = ObjectIDManager::Instance()->GenerateRandomObjectID();
LWOOBJID blueprintID = blueprintIDSmall;
blueprintID = GeneralUtils::SetBit(blueprintID, OBJECT_BIT_CHARACTER);
blueprintID = GeneralUtils::SetBit(blueprintID, OBJECT_BIT_PERSISTENT);
GeneralUtils::SetBit(blueprintID, eObjectBits::CHARACTER);
GeneralUtils::SetBit(blueprintID, eObjectBits::PERSISTENT);
//We need to get the propertyID: (stolen from Wincent's propertyManagementComp)
const auto& worldId = dZoneManager::Instance()->GetZone()->GetZoneID();
@ -2878,7 +2885,7 @@ void GameMessages::SendEndCinematic(LWOOBJID objectId, std::u16string pathName,
void GameMessages::HandleCinematicUpdate(RakNet::BitStream* inStream, Entity* entity, const SystemAddress& sysAddr) {
eCinematicEvent event;
if (!inStream->ReadBit()) {
event = STARTED;
event = eCinematicEvent::STARTED;
} else {
inStream->Read<eCinematicEvent>(event);
}
@ -3424,7 +3431,7 @@ void GameMessages::HandleClientTradeUpdate(RakNet::BitStream* inStream, Entity*
//Pets:
void GameMessages::SendNotifyPetTamingMinigame(LWOOBJID objectId, LWOOBJID petId, LWOOBJID playerTamingId, bool bForceTeleport, uint32_t notifyType, NiPoint3 petsDestPos, NiPoint3 telePos, NiQuaternion teleRot, const SystemAddress& sysAddr) {
void GameMessages::SendNotifyPetTamingMinigame(LWOOBJID objectId, LWOOBJID petId, LWOOBJID playerTamingId, bool bForceTeleport, ePetTamingNotifyType notifyType, NiPoint3 petsDestPos, NiPoint3 telePos, NiQuaternion teleRot, const SystemAddress& sysAddr) {
CBITSTREAM;
CMSGHEADER;
@ -4140,7 +4147,7 @@ void GameMessages::HandleRequestDie(RakNet::BitStream* inStream, Entity* entity,
float directionRelativeAngleXZ;
float directionRelativeAngleY;
float directionRelativeForce;
int32_t killType = VIOLENT;
eKillType killType = eKillType::VIOLENT;
LWOOBJID killerID;
LWOOBJID lootOwnerID = LWOOBJID_EMPTY;
@ -4414,7 +4421,7 @@ void GameMessages::SendVehicleStopBoost(Entity* targetEntity, const SystemAddres
bitStream.Write(targetEntity->GetObjectID());
bitStream.Write(GAME_MSG::GAME_MSG_VEHICLE_STOP_BOOST);
bitStream.Write(affectPassive);
SEND_PACKET_BROADCAST;
@ -4426,7 +4433,7 @@ void GameMessages::SendSetResurrectRestoreValues(Entity* targetEntity, int32_t a
bitStream.Write(targetEntity->GetObjectID());
bitStream.Write(GAME_MSG::GAME_MSG_SET_RESURRECT_RESTORE_VALUES);
bitStream.Write(armorRestore != -1);
if (armorRestore != -1) bitStream.Write(armorRestore);
@ -4765,7 +4772,7 @@ void GameMessages::HandleBuyFromVendor(RakNet::BitStream* inStream, Entity* enti
inv->RemoveItem(tokenId, altCurrencyCost);
inv->AddItem(item, count, eLootSourceType::LOOT_SOURCE_VENDOR);
inv->AddItem(item, count, eLootSourceType::VENDOR);
} else {
float buyScalar = vend->GetBuyScalar();
@ -4785,8 +4792,8 @@ void GameMessages::HandleBuyFromVendor(RakNet::BitStream* inStream, Entity* enti
inv->RemoveItem(itemComp.currencyLOT, altCurrencyCost);
}
character->SetCoins(character->GetCoins() - (coinCost), eLootSourceType::LOOT_SOURCE_VENDOR);
inv->AddItem(item, count, eLootSourceType::LOOT_SOURCE_VENDOR);
character->SetCoins(character->GetCoins() - (coinCost), eLootSourceType::VENDOR);
inv->AddItem(item, count, eLootSourceType::VENDOR);
}
GameMessages::SendVendorTransactionResult(entity, sysAddr);
@ -4828,12 +4835,12 @@ void GameMessages::HandleSellToVendor(RakNet::BitStream* inStream, Entity* entit
float sellScalar = vend->GetSellScalar();
if (Inventory::IsValidItem(itemComp.currencyLOT)) {
const auto altCurrency = static_cast<uint32_t>(itemComp.altCurrencyCost * sellScalar) * count;
inv->AddItem(itemComp.currencyLOT, std::floor(altCurrency), eLootSourceType::LOOT_SOURCE_VENDOR); // Return alt currencies like faction tokens.
inv->AddItem(itemComp.currencyLOT, std::floor(altCurrency), eLootSourceType::VENDOR); // Return alt currencies like faction tokens.
}
//inv->RemoveItem(count, -1, iObjID);
inv->MoveItemToInventory(item, eInventoryType::VENDOR_BUYBACK, count, true, false, true);
character->SetCoins(std::floor(character->GetCoins() + (static_cast<uint32_t>(itemComp.baseValue * sellScalar) * count)), eLootSourceType::LOOT_SOURCE_VENDOR);
character->SetCoins(std::floor(character->GetCoins() + (static_cast<uint32_t>(itemComp.baseValue * sellScalar) * count)), eLootSourceType::VENDOR);
//EntityManager::Instance()->SerializeEntity(player); // so inventory updates
GameMessages::SendVendorTransactionResult(entity, sysAddr);
}
@ -4892,7 +4899,7 @@ void GameMessages::HandleBuybackFromVendor(RakNet::BitStream* inStream, Entity*
//inv->RemoveItem(count, -1, iObjID);
inv->MoveItemToInventory(item, Inventory::FindInventoryTypeForLot(item->GetLot()), count, true, false);
character->SetCoins(character->GetCoins() - cost, eLootSourceType::LOOT_SOURCE_VENDOR);
character->SetCoins(character->GetCoins() - cost, eLootSourceType::VENDOR);
//EntityManager::Instance()->SerializeEntity(player); // so inventory updates
GameMessages::SendVendorTransactionResult(entity, sysAddr);
}
@ -5014,7 +5021,7 @@ void GameMessages::HandleRebuildCancel(RakNet::BitStream* inStream, Entity* enti
RebuildComponent* rebComp = static_cast<RebuildComponent*>(entity->GetComponent(eReplicaComponentType::QUICK_BUILD));
if (!rebComp) return;
rebComp->CancelRebuild(EntityManager::Instance()->GetEntity(userID), eFailReason::REASON_CANCELED_EARLY);
rebComp->CancelRebuild(EntityManager::Instance()->GetEntity(userID), eQuickBuildFailReason::CANCELED_EARLY);
}
void GameMessages::HandleRequestUse(RakNet::BitStream* inStream, Entity* entity, const SystemAddress& sysAddr) {
@ -5134,12 +5141,12 @@ void GameMessages::HandleModularBuildConvertModel(RakNet::BitStream* inStream, E
item->Disassemble(TEMP_MODELS);
item->SetCount(item->GetCount() - 1, false, false, true, eLootSourceType::LOOT_SOURCE_QUICKBUILD);
item->SetCount(item->GetCount() - 1, false, false, true, eLootSourceType::QUICKBUILD);
}
void GameMessages::HandleSetFlag(RakNet::BitStream* inStream, Entity* entity) {
bool bFlag{};
int iFlagID{};
int32_t iFlagID{};
inStream->Read(bFlag);
inStream->Read(iFlagID);
@ -5300,7 +5307,7 @@ void GameMessages::HandlePickupCurrency(RakNet::BitStream* inStream, Entity* ent
auto* ch = entity->GetCharacter();
if (entity->CanPickupCoins(currency)) {
ch->SetCoins(ch->GetCoins() + currency, eLootSourceType::LOOT_SOURCE_PICKUP);
ch->SetCoins(ch->GetCoins() + currency, eLootSourceType::PICKUP);
}
}
@ -5614,9 +5621,9 @@ void GameMessages::HandleModularBuildFinish(RakNet::BitStream* inStream, Entity*
config.push_back(moduleAssembly);
if (count == 3) {
inv->AddItem(6416, 1, eLootSourceType::LOOT_SOURCE_QUICKBUILD, eInventoryType::MODELS, config);
inv->AddItem(6416, 1, eLootSourceType::QUICKBUILD, eInventoryType::MODELS, config);
} else if (count == 7) {
inv->AddItem(8092, 1, eLootSourceType::LOOT_SOURCE_QUICKBUILD, eInventoryType::MODELS, config);
inv->AddItem(8092, 1, eLootSourceType::QUICKBUILD, eInventoryType::MODELS, config);
}
auto* missionComponent = character->GetComponent<MissionComponent>();

34
dGame/dGameMessages/GameMessages.h
View File

@ -8,6 +8,9 @@
#include "eMovementPlatformState.h"
#include "NiPoint3.h"
#include "eEndBehavior.h"
#include "eCyclingMode.h"
#include "eLootSourceType.h"
#include "Brick.h"
class AMFValue;
class Entity;
@ -23,6 +26,16 @@ enum class eAnimationFlags : uint32_t;
enum class eUnequippableActiveType;
enum eInventoryType : uint32_t;
enum class eGameMasterLevel : uint8_t;
enum class eMatchUpdate : int32_t;
enum class eKillType : uint32_t;
enum class eObjectWorldState : uint32_t;
enum class eTerminateType : uint32_t;
enum class eControlScheme : uint32_t;
enum class eStateChangeType : uint32_t;
enum class ePetTamingNotifyType : uint32_t;
enum class eUseItemResponse : uint32_t;
enum class eQuickBuildFailReason : uint32_t;
enum class eRebuildState : uint32_t;
namespace GameMessages {
class PropertyDataMessage;
@ -51,8 +64,7 @@ namespace GameMessages {
int targetTYPE = 0
);
void SendPlayerSetCameraCyclingMode(const LWOOBJID& objectID, const SystemAddress& sysAddr,
bool bAllowCyclingWhileDeadOnly = true, eCyclingMode cyclingMode = ALLOW_CYCLE_TEAMMATES);
void SendPlayerSetCameraCyclingMode(const LWOOBJID& objectID, const SystemAddress& sysAddr, bool bAllowCyclingWhileDeadOnly = true, eCyclingMode cyclingMode = eCyclingMode::ALLOW_CYCLE_TEAMMATES);
void SendPlayNDAudioEmitter(Entity* entity, const SystemAddress& sysAddr, std::string audioGUID);
@ -66,9 +78,9 @@ namespace GameMessages {
void SendGMLevelBroadcast(const LWOOBJID& objectID, eGameMasterLevel level);
void SendChatModeUpdate(const LWOOBJID& objectID, eGameMasterLevel level);
void SendAddItemToInventoryClientSync(Entity* entity, const SystemAddress& sysAddr, Item* item, const LWOOBJID& objectID, bool showFlyingLoot, int itemCount, LWOOBJID subKey = LWOOBJID_EMPTY, eLootSourceType lootSourceType = eLootSourceType::LOOT_SOURCE_NONE);
void SendNotifyClientFlagChange(const LWOOBJID& objectID, int iFlagID, bool bFlag, const SystemAddress& sysAddr);
void SendChangeObjectWorldState(const LWOOBJID& objectID, int state, const SystemAddress& sysAddr);
void SendAddItemToInventoryClientSync(Entity* entity, const SystemAddress& sysAddr, Item* item, const LWOOBJID& objectID, bool showFlyingLoot, int itemCount, LWOOBJID subKey = LWOOBJID_EMPTY, eLootSourceType lootSourceType = eLootSourceType::NONE);
void SendNotifyClientFlagChange(const LWOOBJID& objectID, uint32_t iFlagID, bool bFlag, const SystemAddress& sysAddr);
void SendChangeObjectWorldState(const LWOOBJID& objectID, eObjectWorldState state, const SystemAddress& sysAddr);
void SendOfferMission(const LWOOBJID& entity, const SystemAddress& sysAddr, int32_t missionID, const LWOOBJID& offererID);
void SendNotifyMission(Entity* entity, const SystemAddress& sysAddr, int missionID, int missionState, bool sendingRewards);
@ -86,8 +98,8 @@ namespace GameMessages {
void SendBroadcastTextToChatbox(Entity* entity, const SystemAddress& sysAddr, const std::u16string& attrs, const std::u16string& wsText);
void SendSetCurrency(Entity* entity, int64_t currency, int lootType, const LWOOBJID& sourceID, const LOT& sourceLOT, int sourceTradeID, bool overrideCurrent, eLootSourceType sourceType);
void SendRebuildNotifyState(Entity* entity, int prevState, int state, const LWOOBJID& playerID);
void SendEnableRebuild(Entity* entity, bool enable, bool fail, bool success, int failReason, float duration, const LWOOBJID& playerID);
void SendRebuildNotifyState(Entity* entity, eRebuildState prevState, eRebuildState state, const LWOOBJID& playerID);
void SendEnableRebuild(Entity* entity, bool enable, bool fail, bool success, eQuickBuildFailReason failReason, float duration, const LWOOBJID& playerID);
void AddActivityOwner(Entity* entity, LWOOBJID& ownerID);
void SendTerminateInteraction(const LWOOBJID& objectID, eTerminateType type, const LWOOBJID& terminator);
@ -104,7 +116,7 @@ namespace GameMessages {
void SendSetNetworkScriptVar(Entity* entity, const SystemAddress& sysAddr, std::string data);
void SendDropClientLoot(Entity* entity, const LWOOBJID& sourceID, LOT item, int currency, NiPoint3 spawnPos = NiPoint3::ZERO, int count = 1);
void SendSetPlayerControlScheme(Entity* entity, eControlSceme controlScheme);
void SendSetPlayerControlScheme(Entity* entity, eControlScheme controlScheme);
void SendPlayerReachedRespawnCheckpoint(Entity* entity, const NiPoint3& position, const NiQuaternion& rotation);
void SendAddSkill(Entity* entity, TSkillID skillID, int slotID);
@ -123,7 +135,7 @@ namespace GameMessages {
void SendMoveInventoryBatch(Entity* entity, uint32_t stackCount, int srcInv, int dstInv, const LWOOBJID& iObjID);
void SendMatchResponse(Entity* entity, const SystemAddress& sysAddr, int response);
void SendMatchUpdate(Entity* entity, const SystemAddress& sysAddr, std::string data, int type);
void SendMatchUpdate(Entity* entity, const SystemAddress& sysAddr, std::string data, eMatchUpdate type);
void HandleUnUseModel(RakNet::BitStream* inStream, Entity* entity, const SystemAddress& sysAddr);
void SendStartCelebrationEffect(Entity* entity, const SystemAddress& sysAddr, int celebrationID);
@ -350,7 +362,7 @@ namespace GameMessages {
void HandleClientTradeUpdate(RakNet::BitStream* inStream, Entity* entity, const SystemAddress& sysAddr);
//Pets:
void SendNotifyPetTamingMinigame(LWOOBJID objectId, LWOOBJID petId, LWOOBJID playerTamingId, bool bForceTeleport, uint32_t notifyType, NiPoint3 petsDestPos, NiPoint3 telePos, NiQuaternion teleRot, const SystemAddress& sysAddr);
void SendNotifyPetTamingMinigame(LWOOBJID objectId, LWOOBJID petId, LWOOBJID playerTamingId, bool bForceTeleport, ePetTamingNotifyType notifyType, NiPoint3 petsDestPos, NiPoint3 telePos, NiQuaternion teleRot, const SystemAddress& sysAddr);
void SendNotifyPetTamingPuzzleSelected(LWOOBJID objectId, std::vector<Brick>& bricks, const SystemAddress& sysAddr);
@ -520,7 +532,7 @@ namespace GameMessages {
void SendActivityPause(LWOOBJID objectId, bool pause = false, const SystemAddress& sysAddr = UNASSIGNED_SYSTEM_ADDRESS);
void SendStartActivityTime(LWOOBJID objectId, float_t startTime, const SystemAddress& sysAddr = UNASSIGNED_SYSTEM_ADDRESS);
void SendRequestActivityEnter(LWOOBJID objectId, const SystemAddress& sysAddr, bool bStart, LWOOBJID userID);
void SendUseItemRequirementsResponse(LWOOBJID objectID, const SystemAddress& sysAddr, UseItemResponse itemResponse);
void SendUseItemRequirementsResponse(LWOOBJID objectID, const SystemAddress& sysAddr, eUseItemResponse itemResponse);
// SG:

7
dGame/dInventory/Inventory.cpp
View File

@ -244,9 +244,9 @@ eInventoryType Inventory::FindInventoryTypeForLot(const LOT lot) {
return PROPERTY_DEEDS;
case eItemType::MODEL:
case eItemType::VEHICLE:
case eItemType::PET_INVENTORY_ITEM:
case eItemType::LOOT_MODEL:
case eItemType::LUP_MODEL:
case eItemType::VEHICLE:
case eItemType::MOUNT:
return MODELS;
@ -263,9 +263,8 @@ eInventoryType Inventory::FindInventoryTypeForLot(const LOT lot) {
case eItemType::CHEST:
case eItemType::EGG:
case eItemType::PET_FOOD:
case eItemType::PET_INVENTORY_ITEM:
case eItemType::PACKAGE:
case eItemType::LUP_MODEL:
return ITEMS;
case eItemType::QUEST_OBJECT:

16
dGame/dInventory/Item.cpp
View File

@ -16,7 +16,9 @@
#include "AssetManager.h"
#include "InventoryComponent.h"
#include "Loot.h"
#include "eObjectBits.h"
#include "eReplicaComponentType.h"
#include "eUseItemResponse.h"
#include "CDBrickIDTableTable.h"
#include "CDObjectSkillsTable.h"
@ -77,13 +79,13 @@ Item::Item(
LWOOBJID id = ObjectIDManager::GenerateRandomObjectID();
id = GeneralUtils::SetBit(id, OBJECT_BIT_CHARACTER);
id = GeneralUtils::SetBit(id, OBJECT_BIT_PERSISTENT);
GeneralUtils::SetBit(id, eObjectBits::CHARACTER);
GeneralUtils::SetBit(id, eObjectBits::PERSISTENT);
const auto type = static_cast<eItemType>(info->itemType);
if (type == eItemType::MOUNT) {
id = GeneralUtils::SetBit(id, OBJECT_BIT_CLIENT);
GeneralUtils::SetBit(id, eObjectBits::CLIENT);
}
this->id = id;
@ -329,7 +331,7 @@ void Item::UseNonEquip(Item* item) {
}
}
if (playerInventoryComponent->HasSpaceForLoot(rolledLoot)) {
LootGenerator::Instance().GiveLoot(playerInventoryComponent->GetParent(), rolledLoot, eLootSourceType::LOOT_SOURCE_CONSUMPTION);
LootGenerator::Instance().GiveLoot(playerInventoryComponent->GetParent(), rolledLoot, eLootSourceType::CONSUMPTION);
item->SetCount(item->GetCount() - 1);
} else {
success = false;
@ -338,7 +340,7 @@ void Item::UseNonEquip(Item* item) {
GameMessages::SendUseItemRequirementsResponse(
playerInventoryComponent->GetParent()->GetObjectID(),
playerInventoryComponent->GetParent()->GetSystemAddress(),
UseItemResponse::FailedPrecondition
eUseItemResponse::FailedPrecondition
);
success = false;
}
@ -378,7 +380,7 @@ void Item::Disassemble(const eInventoryType inventoryType) {
}
for (const auto mod : modArray) {
inventory->GetComponent()->AddItem(mod, 1, eLootSourceType::LOOT_SOURCE_DELETION, inventoryType);
inventory->GetComponent()->AddItem(mod, 1, eLootSourceType::DELETION, inventoryType);
}
}
}
@ -476,7 +478,7 @@ void Item::DisassembleModel() {
continue;
}
GetInventory()->GetComponent()->AddItem(brickID[0].NDObjectID, 1, eLootSourceType::LOOT_SOURCE_DELETION);
GetInventory()->GetComponent()->AddItem(brickID[0].NDObjectID, 1, eLootSourceType::DELETION);
}
}

7
dGame/dInventory/Item.h
View File

@ -7,6 +7,7 @@
#include "dLogger.h"
#include "Preconditions.h"
#include "eInventoryType.h"
#include "eLootSourceType.h"
/**
* An item that can be stored in an inventory and optionally consumed or equipped
@ -38,7 +39,7 @@ public:
const std::vector<LDFBaseData*>& config,
LWOOBJID parent,
LWOOBJID subKey,
eLootSourceType lootSourceType = eLootSourceType::LOOT_SOURCE_NONE
eLootSourceType lootSourceType = eLootSourceType::NONE
);
/**
@ -65,7 +66,7 @@ public:
bool isModMoveAndEquip = false,
LWOOBJID subKey = LWOOBJID_EMPTY,
bool bound = false,
eLootSourceType lootSourceType = eLootSourceType::LOOT_SOURCE_NONE
eLootSourceType lootSourceType = eLootSourceType::NONE
);
~Item();
@ -89,7 +90,7 @@ public:
* @param disassemble if items were removed, this returns all the sub parts of the item individually if it had assembly part lots
* @param showFlyingLoot shows flying loot to the client, if not silent
*/
void SetCount(uint32_t value, bool silent = false, bool disassemble = true, bool showFlyingLoot = true, eLootSourceType lootSourceType = eLootSourceType::LOOT_SOURCE_NONE);
void SetCount(uint32_t value, bool silent = false, bool disassemble = true, bool showFlyingLoot = true, eLootSourceType lootSourceType = eLootSourceType::NONE);
/**
* Returns the number of items this item represents (e.g. for stacks)

12
dGame/dMission/Mission.cpp
View File

@ -388,7 +388,7 @@ void Mission::Catchup() {
}
if (type == eMissionTaskType::PLAYER_FLAG) {
for (auto target : task->GetAllTargets()) {
for (int32_t target : task->GetAllTargets()) {
const auto flag = GetUser()->GetLastUsedChar()->GetPlayerFlag(target);
if (!flag) {
@ -442,7 +442,7 @@ void Mission::YieldRewards() {
int32_t coinsToSend = 0;
if (info->LegoScore > 0) {
eLootSourceType lootSource = info->isMission ? eLootSourceType::LOOT_SOURCE_MISSION : eLootSourceType::LOOT_SOURCE_ACHIEVEMENT;
eLootSourceType lootSource = info->isMission ? eLootSourceType::MISSION : eLootSourceType::ACHIEVEMENT;
if (levelComponent->GetLevel() >= dZoneManager::Instance()->GetWorldConfig()->levelCap) {
// Since the character is at the level cap we reward them with coins instead of UScore.
coinsToSend += info->LegoScore * dZoneManager::Instance()->GetWorldConfig()->levelCapCurrencyConversion;
@ -475,11 +475,11 @@ void Mission::YieldRewards() {
count = 0;
}
inventoryComponent->AddItem(pair.first, count, IsMission() ? eLootSourceType::LOOT_SOURCE_MISSION : eLootSourceType::LOOT_SOURCE_ACHIEVEMENT);
inventoryComponent->AddItem(pair.first, count, IsMission() ? eLootSourceType::MISSION : eLootSourceType::ACHIEVEMENT);
}
if (info->reward_currency_repeatable > 0 || coinsToSend > 0) {
eLootSourceType lootSource = info->isMission ? eLootSourceType::LOOT_SOURCE_MISSION : eLootSourceType::LOOT_SOURCE_ACHIEVEMENT;
eLootSourceType lootSource = info->isMission ? eLootSourceType::MISSION : eLootSourceType::ACHIEVEMENT;
character->SetCoins(character->GetCoins() + info->reward_currency_repeatable + coinsToSend, lootSource);
}
@ -508,11 +508,11 @@ void Mission::YieldRewards() {
count = 0;
}
inventoryComponent->AddItem(pair.first, count, IsMission() ? eLootSourceType::LOOT_SOURCE_MISSION : eLootSourceType::LOOT_SOURCE_ACHIEVEMENT);
inventoryComponent->AddItem(pair.first, count, IsMission() ? eLootSourceType::MISSION : eLootSourceType::ACHIEVEMENT);
}
if (info->reward_currency > 0 || coinsToSend > 0) {
eLootSourceType lootSource = info->isMission ? eLootSourceType::LOOT_SOURCE_MISSION : eLootSourceType::LOOT_SOURCE_ACHIEVEMENT;
eLootSourceType lootSource = info->isMission ? eLootSourceType::MISSION : eLootSourceType::ACHIEVEMENT;
character->SetCoins(character->GetCoins() + info->reward_currency + coinsToSend, lootSource);
}

4
dGame/dUtilities/Loot.cpp
View File

@ -318,13 +318,13 @@ void LootGenerator::GiveActivityLoot(Entity* player, Entity* source, uint32_t ac
maxCoins = currencyTable[0].maxvalue;
}
GiveLoot(player, selectedReward->LootMatrixIndex, eLootSourceType::LOOT_SOURCE_ACTIVITY);
GiveLoot(player, selectedReward->LootMatrixIndex, eLootSourceType::ACTIVITY);
uint32_t coins = (int)(minCoins + GeneralUtils::GenerateRandomNumber<float>(0, 1) * (maxCoins - minCoins));
auto* character = player->GetCharacter();
character->SetCoins(character->GetCoins() + coins, eLootSourceType::LOOT_SOURCE_ACTIVITY);
character->SetCoins(character->GetCoins() + coins, eLootSourceType::ACTIVITY);
}
void LootGenerator::DropLoot(Entity* player, Entity* killedObject, uint32_t matrixIndex, uint32_t minCoins, uint32_t maxCoins) {

4
dGame/dUtilities/Loot.h
View File

@ -47,8 +47,8 @@ public:
std::unordered_map<LOT, int32_t> RollLootMatrix(Entity* player, uint32_t matrixIndex);
std::unordered_map<LOT, int32_t> RollLootMatrix(uint32_t matrixIndex);
void GiveLoot(Entity* player, uint32_t matrixIndex, eLootSourceType lootSourceType = eLootSourceType::LOOT_SOURCE_NONE);
void GiveLoot(Entity* player, std::unordered_map<LOT, int32_t>& result, eLootSourceType lootSourceType = eLootSourceType::LOOT_SOURCE_NONE);
void GiveLoot(Entity* player, uint32_t matrixIndex, eLootSourceType lootSourceType = eLootSourceType::NONE);
void GiveLoot(Entity* player, std::unordered_map<LOT, int32_t>& result, eLootSourceType lootSourceType = eLootSourceType::NONE);
void GiveActivityLoot(Entity* player, Entity* source, uint32_t activityID, int32_t rating = 0);
void DropLoot(Entity* player, Entity* killedObject, uint32_t matrixIndex, uint32_t minCoins, uint32_t maxCoins);
void DropLoot(Entity* player, Entity* killedObject, std::unordered_map<LOT, int32_t>& result, uint32_t minCoins, uint32_t maxCoins);

4
dGame/dUtilities/Mail.cpp
View File

@ -259,7 +259,7 @@ void Mail::HandleSendMail(RakNet::BitStream* packet, const SystemAddress& sysAdd
}
Mail::SendSendResponse(sysAddr, Mail::MailSendResponse::Success);
entity->GetCharacter()->SetCoins(entity->GetCharacter()->GetCoins() - mailCost, eLootSourceType::LOOT_SOURCE_MAIL);
entity->GetCharacter()->SetCoins(entity->GetCharacter()->GetCoins() - mailCost, eLootSourceType::MAIL);
Game::logger->Log("Mail", "Seeing if we need to remove item with ID/count/LOT: %i %i %i", itemID, attachmentCount, itemLOT);
@ -359,7 +359,7 @@ void Mail::HandleAttachmentCollect(RakNet::BitStream* packet, const SystemAddres
auto inv = static_cast<InventoryComponent*>(player->GetComponent(eReplicaComponentType::INVENTORY));
if (!inv) return;
inv->AddItem(attachmentLOT, attachmentCount, eLootSourceType::LOOT_SOURCE_MAIL);
inv->AddItem(attachmentLOT, attachmentCount, eLootSourceType::MAIL);
Mail::SendAttachmentRemoveConfirm(sysAddr, mailID);

30
dGame/dUtilities/SlashCommandHandler.cpp
View File

@ -75,8 +75,10 @@
#include "eMissionState.h"
#include "TriggerComponent.h"
#include "eServerDisconnectIdentifiers.h"
#include "eObjectBits.h"
#include "eGameMasterLevel.h"
#include "eReplicaComponentType.h"
#include "eControlScheme.h"
#include "CDObjectsTable.h"
#include "CDZoneTableTable.h"
@ -496,7 +498,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
const auto state = !entity->GetVar<bool>(u"freecam");
entity->SetVar<bool>(u"freecam", state);
GameMessages::SendSetPlayerControlScheme(entity, static_cast<eControlSceme>(state ? 9 : 1));
GameMessages::SendSetPlayerControlScheme(entity, static_cast<eControlScheme>(state ? 9 : 1));
ChatPackets::SendSystemMessage(sysAddr, u"Toggled freecam.");
return;
@ -510,7 +512,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
return;
}
GameMessages::SendSetPlayerControlScheme(entity, static_cast<eControlSceme>(scheme));
GameMessages::SendSetPlayerControlScheme(entity, static_cast<eControlScheme>(scheme));
ChatPackets::SendSystemMessage(sysAddr, u"Switched control scheme.");
return;
@ -652,7 +654,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
}
if (chatCommand == "setflag" && entity->GetGMLevel() >= eGameMasterLevel::DEVELOPER && args.size() == 1) {
uint32_t flagId;
int32_t flagId;
if (!GeneralUtils::TryParse(args[0], flagId)) {
ChatPackets::SendSystemMessage(sysAddr, u"Invalid flag id.");
@ -663,7 +665,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
}
if (chatCommand == "setflag" && entity->GetGMLevel() >= eGameMasterLevel::DEVELOPER && args.size() == 2) {
uint32_t flagId;
int32_t flagId;
std::string onOffFlag = args[0];
if (!GeneralUtils::TryParse(args[1], flagId)) {
ChatPackets::SendSystemMessage(sysAddr, u"Invalid flag id.");
@ -676,7 +678,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
entity->GetCharacter()->SetPlayerFlag(flagId, onOffFlag == "on");
}
if (chatCommand == "clearflag" && entity->GetGMLevel() >= eGameMasterLevel::DEVELOPER && args.size() == 1) {
uint32_t flagId;
int32_t flagId;
if (!GeneralUtils::TryParse(args[0], flagId)) {
ChatPackets::SendSystemMessage(sysAddr, u"Invalid flag id.");
@ -792,7 +794,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
InventoryComponent* inventory = static_cast<InventoryComponent*>(entity->GetComponent(eReplicaComponentType::INVENTORY));
inventory->AddItem(itemLOT, 1, eLootSourceType::LOOT_SOURCE_MODERATION);
inventory->AddItem(itemLOT, 1, eLootSourceType::MODERATION);
} else if (args.size() == 2) {
uint32_t itemLOT;
@ -810,7 +812,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
InventoryComponent* inventory = static_cast<InventoryComponent*>(entity->GetComponent(eReplicaComponentType::INVENTORY));
inventory->AddItem(itemLOT, count, eLootSourceType::LOOT_SOURCE_MODERATION);
inventory->AddItem(itemLOT, count, eLootSourceType::MODERATION);
} else {
ChatPackets::SendSystemMessage(sysAddr, u"Correct usage: /gmadditem <lot>");
}
@ -1029,8 +1031,8 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
accountId = result->getUInt(1);
characterId = result->getUInt64(2);
characterId = GeneralUtils::SetBit(characterId, OBJECT_BIT_CHARACTER);
characterId = GeneralUtils::SetBit(characterId, OBJECT_BIT_PERSISTENT);
GeneralUtils::SetBit(characterId, eObjectBits::CHARACTER);
GeneralUtils::SetBit(characterId, eObjectBits::PERSISTENT);
}
}
@ -1345,9 +1347,9 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
CharacterComponent* character = entity->GetComponent<CharacterComponent>();
if (character) character->SetUScore(character->GetUScore() + uscore);
// LOOT_SOURCE_MODERATION should work but it doesn't. Relog to see uscore changes
// MODERATION should work but it doesn't. Relog to see uscore changes
eLootSourceType lootType = eLootSourceType::LOOT_SOURCE_MODERATION;
eLootSourceType lootType = eLootSourceType::MODERATION;
int32_t type;
if (args.size() >= 2 && GeneralUtils::TryParse(args[1], type)) {
@ -1465,7 +1467,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
}
auto* ch = entity->GetCharacter();
ch->SetCoins(ch->GetCoins() + money, eLootSourceType::LOOT_SOURCE_MODERATION);
ch->SetCoins(ch->GetCoins() + money, eLootSourceType::MODERATION);
}
if ((chatCommand == "setcurrency") && args.size() == 1 && entity->GetGMLevel() >= eGameMasterLevel::DEVELOPER) {
@ -1477,7 +1479,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
}
auto* ch = entity->GetCharacter();
ch->SetCoins(money, eLootSourceType::LOOT_SOURCE_MODERATION);
ch->SetCoins(money, eLootSourceType::MODERATION);
}
// Allow for this on even while not a GM, as it sometimes toggles incorrrectly.
@ -1726,7 +1728,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
std::vector<LDFBaseData*> data{};
data.push_back(new LDFData<int32_t>(u"reforgedLOT", reforgedItem));
inventoryComponent->AddItem(baseItem, 1, eLootSourceType::LOOT_SOURCE_MODERATION, eInventoryType::INVALID, data);
inventoryComponent->AddItem(baseItem, 1, eLootSourceType::MODERATION, eInventoryType::INVALID, data);
}
if (chatCommand == "crash" && entity->GetGMLevel() >= eGameMasterLevel::OPERATOR) {

21
dNet/AuthPackets.cpp
View File

@ -22,6 +22,7 @@
#include "Game.h"
#include "dConfig.h"
#include "eServerDisconnectIdentifiers.h"
#include "eLoginResponse.h"
void AuthPackets::HandleHandshake(dServer* server, Packet* packet) {
RakNet::BitStream inStream(packet->data, packet->length, false);
@ -61,7 +62,7 @@ void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) {
if (res->rowsCount() == 0) {
server->GetLogger()->Log("AuthPackets", "No user found!");
AuthPackets::SendLoginResponse(server, packet->systemAddress, LOGIN_RESPONSE_WRONG_PASS_OR_USER, "", "", 2001, username);
AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::INVALID_USER, "", "", 2001, username);
return;
}
@ -85,14 +86,14 @@ void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) {
//If we aren't running in live mode, then only GMs are allowed to enter:
const auto& closedToNonDevs = Game::config->GetValue("closed_to_non_devs");
if (closedToNonDevs.size() > 0 && bool(std::stoi(closedToNonDevs)) && sqlGmLevel == 0) {
AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::LOGIN_RESPONSE_PERMISSIONS_NOT_HIGH_ENOUGH, "The server is currently only open to developers.", "", 2001, username);
AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "The server is currently only open to developers.", "", 2001, username);
return;
}
if (Game::config->GetValue("dont_use_keys") != "1") {
//Check to see if we have a play key:
if (sqlPlayKey == 0 && sqlGmLevel == 0) {
AuthPackets::SendLoginResponse(server, packet->systemAddress, LOGIN_RESPONSE_PERMISSIONS_NOT_HIGH_ENOUGH, "Your account doesn't have a play key associated with it!", "", 2001, username);
AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "Your account doesn't have a play key associated with it!", "", 2001, username);
server->GetLogger()->Log("AuthPackets", "User %s tried to log in, but they don't have a play key.", username.c_str());
return;
}
@ -104,7 +105,7 @@ void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) {
bool isKeyActive = false;
if (keyRes->rowsCount() == 0 && sqlGmLevel == 0) {
AuthPackets::SendLoginResponse(server, packet->systemAddress, LOGIN_RESPONSE_PERMISSIONS_NOT_HIGH_ENOUGH, "Your account doesn't have a play key associated with it!", "", 2001, username);
AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "Your account doesn't have a play key associated with it!", "", 2001, username);
return;
}
@ -113,18 +114,18 @@ void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) {
}
if (!isKeyActive && sqlGmLevel == 0) {
AuthPackets::SendLoginResponse(server, packet->systemAddress, LOGIN_RESPONSE_PERMISSIONS_NOT_HIGH_ENOUGH, "Your play key has been disabled.", "", 2001, username);
AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "Your play key has been disabled.", "", 2001, username);
server->GetLogger()->Log("AuthPackets", "User %s tried to log in, but their play key was disabled", username.c_str());
return;
}
}
if (sqlBanned) {
AuthPackets::SendLoginResponse(server, packet->systemAddress, LOGIN_RESPONSE_BANNED, "", "", 2001, username); return;
AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::BANNED, "", "", 2001, username); return;
}
if (sqlLocked) {
AuthPackets::SendLoginResponse(server, packet->systemAddress, LOGIN_RESPONSE_ACCOUNT_LOCKED, "", "", 2001, username); return;
AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::ACCOUNT_LOCKED, "", "", 2001, username); return;
}
/*
@ -170,18 +171,18 @@ void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) {
}
if (!loginSuccess) {
AuthPackets::SendLoginResponse(server, packet->systemAddress, LOGIN_RESPONSE_WRONG_PASS_OR_USER, "", "", 2001, username);
AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::WRONG_PASS, "", "", 2001, username);
server->GetLogger()->Log("AuthPackets", "Wrong password used");
} else {
SystemAddress system = packet->systemAddress; //Copy the sysAddr before the Packet gets destroyed from main
if (!server->GetIsConnectedToMaster()) {
AuthPackets::SendLoginResponse(server, system, LOGIN_RESPONSE_GENERAL_FAILED, "", "", 0, username);
AuthPackets::SendLoginResponse(server, system, eLoginResponse::GENERAL_FAILED, "", "", 0, username);
return;
}
ZoneInstanceManager::Instance()->RequestZoneTransfer(server, 0, 0, false, [system, server, username](bool mythranShift, uint32_t zoneID, uint32_t zoneInstance, uint32_t zoneClone, std::string zoneIP, uint16_t zonePort) {
AuthPackets::SendLoginResponse(server, system, LOGIN_RESPONSE_SUCCESS, "", zoneIP, zonePort, username);
AuthPackets::SendLoginResponse(server, system, eLoginResponse::SUCCESS, "", zoneIP, zonePort, username);
});
}
}

1
dNet/AuthPackets.h
View File

@ -6,6 +6,7 @@
#include "dNetCommon.h"
enum class ServerType : uint32_t;
enum class eLoginResponse : uint8_t;
class dServer;
namespace AuthPackets {

3
dNet/WorldPackets.cpp
View File

@ -15,7 +15,6 @@
#include "CharacterComponent.h"
#include "ZCompression.h"
void WorldPackets::SendLoadStaticZone(const SystemAddress& sysAddr, float x, float y, float z, uint32_t checksum) {
RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_LOAD_STATIC_ZONE);
@ -89,7 +88,7 @@ void WorldPackets::SendCharacterList(const SystemAddress& sysAddr, User* user) {
SEND_PACKET;
}
void WorldPackets::SendCharacterCreationResponse(const SystemAddress& sysAddr, eCreationResponse response) {
void WorldPackets::SendCharacterCreationResponse(const SystemAddress& sysAddr, eCharacterCreationResponse response) {
RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_CHARACTER_CREATE_RESPONSE);
bitStream.Write(response);

4
dNet/WorldPackets.h
View File

@ -9,11 +9,13 @@
class User;
struct SystemAddress;
enum class eGameMasterLevel : uint8_t;
enum class eCharacterCreationResponse : uint8_t;
enum class eRenameResponse : uint8_t;
namespace WorldPackets {
void SendLoadStaticZone(const SystemAddress& sysAddr, float x, float y, float z, uint32_t checksum);
void SendCharacterList(const SystemAddress& sysAddr, User* user);
void SendCharacterCreationResponse(const SystemAddress& sysAddr, eCreationResponse response);
void SendCharacterCreationResponse(const SystemAddress& sysAddr, eCharacterCreationResponse response);
void SendCharacterRenameResponse(const SystemAddress& sysAddr, eRenameResponse response);
void SendCharacterDeleteResponse(const SystemAddress& sysAddr, bool response);
void SendTransferToWorld(const SystemAddress& sysAddr, const std::string& serverIP, uint32_t serverPort, bool mythranShift);

3
dScripts/02_server/Enemy/General/BaseEnemyApe.cpp
View File

@ -6,6 +6,7 @@
#include "EntityInfo.h"
#include "SkillComponent.h"
#include "eAninmationFlags.h"
#include "eStateChangeType.h"
void BaseEnemyApe::OnStartup(Entity* self) {
self->SetVar<uint32_t>(u"timesStunned", 2);
@ -15,7 +16,7 @@ void BaseEnemyApe::OnStartup(Entity* self) {
void BaseEnemyApe::OnDie(Entity* self, Entity* killer) {
auto* anchor = EntityManager::Instance()->GetEntity(self->GetVar<LWOOBJID>(u"QB"));
if (anchor != nullptr && !anchor->GetIsDead()) {
anchor->Smash(self->GetObjectID(), SILENT);
anchor->Smash(self->GetObjectID(), eKillType::SILENT);
}
}

4
dScripts/02_server/Equipment/BootyDigServer.cpp
View File

@ -30,7 +30,7 @@ BootyDigServer::OnFireEventServerSide(Entity* self, Entity* sender, std::string
return;
if (args == "ChestReady" && (propertyOwner == std::to_string(LWOOBJID_EMPTY) || player->GetVar<bool>(u"bootyDug"))) {
self->Smash(self->GetObjectID(), SILENT);
self->Smash(self->GetObjectID(), eKillType::SILENT);
} else if (args == "ChestOpened") {
// Make sure players only dig up one booty per instance
player->SetVar<bool>(u"bootyDug", true);
@ -49,6 +49,6 @@ BootyDigServer::OnFireEventServerSide(Entity* self, Entity* sender, std::string
}
}
} else if (args == "ChestDead") {
self->Smash(player->GetObjectID(), SILENT);
self->Smash(player->GetObjectID(), eKillType::SILENT);
}
}

3
dScripts/02_server/Map/AG/AgCagedBricksServer.cpp
View File

@ -4,6 +4,7 @@
#include "Character.h"
#include "EntityManager.h"
#include "eReplicaComponentType.h"
#include "ePlayerFlag.h"
void AgCagedBricksServer::OnUse(Entity* self, Entity* user) {
//Tell the client to spawn the baby spiderling:
@ -17,7 +18,7 @@ void AgCagedBricksServer::OnUse(Entity* self, Entity* user) {
if (!character) return;
character->SetPlayerFlag(74, true);
character->SetPlayerFlag(ePlayerFlag::CAGED_SPIDER, true);
//Remove the maelstrom cube:
auto inv = static_cast<InventoryComponent*>(user->GetComponent(eReplicaComponentType::INVENTORY));

2
dScripts/02_server/Map/AG/NpcCowboyServer.cpp
View File

@ -18,7 +18,7 @@ void NpcCowboyServer::OnMissionDialogueOK(Entity* self, Entity* target, int miss
missionState == eMissionState::AVAILABLE ||
missionState == eMissionState::COMPLETE_AVAILABLE) {
if (inventoryComponent->GetLotCount(14378) == 0) {
inventoryComponent->AddItem(14378, 1, eLootSourceType::LOOT_SOURCE_NONE);
inventoryComponent->AddItem(14378, 1, eLootSourceType::NONE);
}
} else if (missionState == eMissionState::READY_TO_COMPLETE || missionState == eMissionState::COMPLETE_READY_TO_COMPLETE) {
inventoryComponent->RemoveItem(14378, 1);

2
dScripts/02_server/Map/AG/NpcPirateServer.cpp
View File

@ -10,7 +10,7 @@ void NpcPirateServer::OnMissionDialogueOK(Entity* self, Entity* target, int miss
// Add or remove the lucky shovel based on whether the mission was completed or started
if ((missionState == eMissionState::AVAILABLE || missionState == eMissionState::COMPLETE_AVAILABLE)
&& luckyShovel == nullptr) {
inventory->AddItem(14591, 1, eLootSourceType::LOOT_SOURCE_NONE);
inventory->AddItem(14591, 1, eLootSourceType::NONE);
} else if (missionState == eMissionState::READY_TO_COMPLETE || missionState == eMissionState::COMPLETE_READY_TO_COMPLETE) {
inventory->RemoveItem(14591, 1);
}

2
dScripts/02_server/Map/AG/NpcWispServer.cpp
View File

@ -19,7 +19,7 @@ void NpcWispServer::OnMissionDialogueOK(Entity* self, Entity* target, int missio
// For the daily we add the maelstrom vacuum if the player doesn't have it yet
if (missionID == 1883 && (missionState == eMissionState::AVAILABLE || missionState == eMissionState::COMPLETE_AVAILABLE)
&& maelstromVacuum == nullptr) {
inventory->AddItem(maelstromVacuumLot, 1, eLootSourceType::LOOT_SOURCE_NONE);
inventory->AddItem(maelstromVacuumLot, 1, eLootSourceType::NONE);
} else if (missionState == eMissionState::READY_TO_COMPLETE || missionState == eMissionState::COMPLETE_READY_TO_COMPLETE) {
inventory->RemoveItem(maelstromVacuumLot, 1);
}

3
dScripts/02_server/Map/AG/RemoveRentalGear.cpp
View File

@ -4,6 +4,7 @@
#include "eMissionState.h"
#include "Character.h"
#include "eReplicaComponentType.h"
#include "ePlayerFlag.h"
/*
--------------------------------------------------------------
@ -36,6 +37,6 @@ void RemoveRentalGear::OnMissionDialogueOK(Entity* self, Entity* target, int mis
//reset the equipment flag
auto character = target->GetCharacter();
if (character) character->SetPlayerFlag(equipFlag, false);
if (character) character->SetPlayerFlag(ePlayerFlag::EQUPPED_TRIAL_FACTION_GEAR, false);
}
}

1
dScripts/02_server/Map/AG/RemoveRentalGear.h
View File

@ -7,6 +7,5 @@ class RemoveRentalGear : public CppScripts::Script {
private:
int defaultMission = 768; //mission to remove gearSets on completion
std::vector<int> gearSets = { 14359,14321,14353,14315 }; //inventory items to remove
int equipFlag = 126; //Set upon wearing trial faction armor for the first time in a session
};

2
dScripts/02_server/Map/AM/AmBlueX.cpp
View File

@ -18,7 +18,7 @@ void AmBlueX::OnSkillEventFired(Entity* self, Entity* caster, const std::string&
auto* character = caster->GetCharacter();
if (character != nullptr) {
character->SetPlayerFlag(self->GetVar<int32_t>(m_FlagVariable), true);
character->SetPlayerFlag(self->GetVar<uint32_t>(m_FlagVariable), true);
}
EntityInfo info{};

2
dScripts/02_server/Map/AM/AmBridge.cpp
View File

@ -24,5 +24,5 @@ void AmBridge::OnTimerDone(Entity* self, std::string timerName) {
return;
}
self->Smash(self->GetObjectID(), VIOLENT);
self->Smash(self->GetObjectID(), eKillType::VIOLENT);
}

3
dScripts/02_server/Map/AM/AmDrawBridge.cpp
View File

@ -2,6 +2,7 @@
#include "EntityManager.h"
#include "GameMessages.h"
#include "SimplePhysicsComponent.h"
#include "eTerminateType.h"
void AmDrawBridge::OnStartup(Entity* self) {
self->SetNetworkVar(u"InUse", false);
@ -25,7 +26,7 @@ void AmDrawBridge::OnUse(Entity* self, Entity* user) {
auto* player = user;
GameMessages::SendTerminateInteraction(player->GetObjectID(), FROM_INTERACTION, self->GetObjectID());
GameMessages::SendTerminateInteraction(player->GetObjectID(), eTerminateType::FROM_INTERACTION, self->GetObjectID());
}
void AmDrawBridge::OnTimerDone(Entity* self, std::string timerName) {

8
dScripts/02_server/Map/AM/AmDropshipComputer.cpp
View File

@ -12,7 +12,7 @@ void AmDropshipComputer::OnStartup(Entity* self) {
void AmDropshipComputer::OnUse(Entity* self, Entity* user) {
auto* rebuildComponent = self->GetComponent<RebuildComponent>();
if (rebuildComponent == nullptr || rebuildComponent->GetState() != REBUILD_COMPLETED) {
if (rebuildComponent == nullptr || rebuildComponent->GetState() != eRebuildState::COMPLETED) {
return;
}
@ -27,7 +27,7 @@ void AmDropshipComputer::OnUse(Entity* self, Entity* user) {
return;
}
inventoryComponent->AddItem(m_NexusTalonDataCard, 1, eLootSourceType::LOOT_SOURCE_NONE);
inventoryComponent->AddItem(m_NexusTalonDataCard, 1, eLootSourceType::NONE);
}
void AmDropshipComputer::OnDie(Entity* self, Entity* killer) {
@ -76,7 +76,7 @@ void AmDropshipComputer::OnTimerDone(Entity* self, std::string timerName) {
return;
}
if (timerName == "reset" && rebuildComponent->GetState() == REBUILD_OPEN) {
self->Smash(self->GetObjectID(), SILENT);
if (timerName == "reset" && rebuildComponent->GetState() == eRebuildState::OPEN) {
self->Smash(self->GetObjectID(), eKillType::SILENT);
}
}

2
dScripts/02_server/Map/AM/AmShieldGeneratorQuickbuild.cpp
View File

@ -176,7 +176,7 @@ void AmShieldGeneratorQuickbuild::BuffPlayers(Entity* self) {
void AmShieldGeneratorQuickbuild::EnemyEnteredShield(Entity* self, Entity* intruder) {
auto* rebuildComponent = self->GetComponent<RebuildComponent>();
if (rebuildComponent == nullptr || rebuildComponent->GetState() != REBUILD_COMPLETED) {
if (rebuildComponent == nullptr || rebuildComponent->GetState() != eRebuildState::COMPLETED) {
return;
}

5
dScripts/02_server/Map/AM/AmSkullkinDrill.cpp
View File

@ -5,6 +5,7 @@
#include "ProximityMonitorComponent.h"
#include "MissionComponent.h"
#include "EntityInfo.h"
#include "eStateChangeType.h"
void AmSkullkinDrill::OnStartup(Entity* self) {
self->SetNetworkVar(u"bIsInUse", false);
@ -246,7 +247,7 @@ void AmSkullkinDrill::OnHitOrHealResult(Entity* self, Entity* attacker, int32_t
}
}
self->Smash(attacker->GetObjectID(), SILENT);
self->Smash(attacker->GetObjectID(), eKillType::SILENT);
self->CancelAllTimers();
@ -264,7 +265,7 @@ void AmSkullkinDrill::OnTimerDone(Entity* self, std::string timerName) {
auto* child = EntityManager::Instance()->GetEntity(childID);
if (child != nullptr) {
child->Smash(self->GetObjectID(), SILENT);
child->Smash(self->GetObjectID(), eKillType::SILENT);
}
self->SetNetworkVar(u"bIsInUse", false);

3
dScripts/02_server/Map/AM/AmTeapotServer.cpp
View File

@ -2,6 +2,7 @@
#include "InventoryComponent.h"
#include "GameMessages.h"
#include "Item.h"
#include "eTerminateType.h"
void AmTeapotServer::OnUse(Entity* self, Entity* user) {
auto* inventoryComponent = user->GetComponent<InventoryComponent>();
@ -18,5 +19,5 @@ void AmTeapotServer::OnUse(Entity* self, Entity* user) {
blueFlowerItem->SetCount(blueFlowerItem->GetCount() - 10);
inventoryComponent->AddItem(WU_S_IMAGINATION_TEA, 1);
}
GameMessages::SendTerminateInteraction(user->GetObjectID(), FROM_INTERACTION, self->GetObjectID());
GameMessages::SendTerminateInteraction(user->GetObjectID(), eTerminateType::FROM_INTERACTION, self->GetObjectID());
}

19
dScripts/02_server/Map/FV/ImgBrickConsoleQB.cpp
View File

@ -6,6 +6,7 @@
#include "MissionComponent.h"
#include "eMissionState.h"
#include "InventoryComponent.h"
#include "eTerminateType.h"
int32_t ImgBrickConsoleQB::ResetBricks = 30;
int32_t ImgBrickConsoleQB::ResetConsole = 60;
@ -20,7 +21,7 @@ void ImgBrickConsoleQB::OnStartup(Entity* self) {
void ImgBrickConsoleQB::OnUse(Entity* self, Entity* user) {
auto* rebuildComponent = self->GetComponent<RebuildComponent>();
if (rebuildComponent->GetState() == REBUILD_COMPLETED) {
if (rebuildComponent->GetState() == eRebuildState::COMPLETED) {
if (!self->GetNetworkVar<bool>(u"used")) {
const auto consoles = EntityManager::Instance()->GetEntitiesInGroup("Console");
@ -29,7 +30,7 @@ void ImgBrickConsoleQB::OnUse(Entity* self, Entity* user) {
for (auto* console : consoles) {
auto* consoleRebuildComponent = console->GetComponent<RebuildComponent>();
if (consoleRebuildComponent->GetState() != REBUILD_COMPLETED) {
if (consoleRebuildComponent->GetState() != eRebuildState::COMPLETED) {
continue;
}
@ -87,7 +88,7 @@ void ImgBrickConsoleQB::OnUse(Entity* self, Entity* user) {
self->SetNetworkVar(u"used", true);
GameMessages::SendTerminateInteraction(player->GetObjectID(), FROM_INTERACTION, self->GetObjectID());
GameMessages::SendTerminateInteraction(player->GetObjectID(), eTerminateType::FROM_INTERACTION, self->GetObjectID());
}
}
@ -113,7 +114,7 @@ void ImgBrickConsoleQB::SmashCanister(Entity* self) {
const auto canisters = EntityManager::Instance()->GetEntitiesInGroup("Canister");
for (auto* canister : canisters) {
canister->Smash(canister->GetObjectID(), VIOLENT);
canister->Smash(canister->GetObjectID(), eKillType::VIOLENT);
}
const auto canister = dZoneManager::Instance()->GetSpawnersByName("BrickCanister");
@ -146,7 +147,7 @@ void ImgBrickConsoleQB::OnRebuildComplete(Entity* self, Entity* target) {
for (auto* console : consoles) {
auto* consoleRebuildComponent = console->GetComponent<RebuildComponent>();
if (consoleRebuildComponent->GetState() != REBUILD_COMPLETED) {
if (consoleRebuildComponent->GetState() != eRebuildState::COMPLETED) {
continue;
}
@ -167,7 +168,7 @@ void ImgBrickConsoleQB::OnDie(Entity* self, Entity* killer) {
auto* rebuildComponent = self->GetComponent<RebuildComponent>();
if (rebuildComponent->GetState() == REBUILD_COMPLETED) {
if (rebuildComponent->GetState() == eRebuildState::COMPLETED) {
auto offFX = 0;
const auto location = GeneralUtils::UTF16ToWTF8(self->GetVar<std::u16string>(u"console"));
@ -228,14 +229,14 @@ void ImgBrickConsoleQB::OnTimerDone(Entity* self, std::string timerName) {
if (timerName == "reset") {
auto* rebuildComponent = self->GetComponent<RebuildComponent>();
if (rebuildComponent->GetState() == REBUILD_OPEN) {
self->Smash(self->GetObjectID(), SILENT);
if (rebuildComponent->GetState() == eRebuildState::OPEN) {
self->Smash(self->GetObjectID(), eKillType::SILENT);
}
} else if (timerName == "Die") {
const auto consoles = EntityManager::Instance()->GetEntitiesInGroup("Console");
for (auto* console : consoles) {
console->Smash(console->GetObjectID(), VIOLENT);
console->Smash(console->GetObjectID(), eKillType::VIOLENT);
}
}
}

2
dScripts/02_server/Map/FV/Racing/RaceMaelstromGeiser.cpp
View File

@ -55,7 +55,7 @@ void RaceMaelstromGeiser::OnProximityUpdate(Entity* self, Entity* entering, std:
}
GameMessages::SendDie(vehicle, self->GetObjectID(), LWOOBJID_EMPTY, true, VIOLENT, u"", 0, 0, 0, true, false, 0);
GameMessages::SendDie(vehicle, self->GetObjectID(), LWOOBJID_EMPTY, true, eKillType::VIOLENT, u"", 0, 0, 0, true, false, 0);
auto* zoneController = dZoneManager::Instance()->GetZoneControlObject();

4
dScripts/02_server/Map/GF/GfCaptainsCannon.cpp
View File

@ -2,6 +2,8 @@
#include "GameMessages.h"
#include "EntityManager.h"
#include "MissionComponent.h"
#include "eTerminateType.h"
#include "eStateChangeType.h"
void GfCaptainsCannon::OnUse(Entity* self, Entity* user) {
if (self->GetVar<bool>(u"bIsInUse")) {
@ -78,6 +80,6 @@ void GfCaptainsCannon::OnTimerDone(Entity* self, std::string timerName) {
missionComponent->ForceProgress(601, 910, 1);
}
GameMessages::SendTerminateInteraction(playerId, FROM_INTERACTION, self->GetObjectID());
GameMessages::SendTerminateInteraction(playerId, eTerminateType::FROM_INTERACTION, self->GetObjectID());
}
}

3
dScripts/02_server/Map/GF/GfTikiTorch.cpp
View File

@ -5,6 +5,7 @@
#include "RenderComponent.h"
#include "eMissionTaskType.h"
#include "eReplicaComponentType.h"
#include "eTerminateType.h"
void GfTikiTorch::OnStartup(Entity* self) {
LightTorch(self);
@ -33,7 +34,7 @@ void GfTikiTorch::OnTimerDone(Entity* self, std::string timerName) {
Entity* player = EntityManager::Instance()->GetEntity(self->GetI64(u"userID"));
if (player != nullptr && player->GetCharacter()) {
GameMessages::SendTerminateInteraction(player->GetObjectID(), FROM_INTERACTION, self->GetObjectID());
GameMessages::SendTerminateInteraction(player->GetObjectID(), eTerminateType::FROM_INTERACTION, self->GetObjectID());
}
self->SetBoolean(u"isInUse", false);

1
dScripts/02_server/Map/GF/MastTeleport.cpp
View File

@ -4,6 +4,7 @@
#include "Preconditions.h"
#include "eEndBehavior.h"
#include "DestroyableComponent.h"
#include "eStateChangeType.h"
#ifdef _WIN32
#define _USE_MATH_DEFINES

2
dScripts/02_server/Map/General/Ninjago/NjRailActivatorsServer.cpp
View File

@ -7,7 +7,7 @@ void NjRailActivatorsServer::OnUse(Entity* self, Entity* user) {
auto* rebuildComponent = self->GetComponent<RebuildComponent>();
// Only allow use if this is not a quick build or the quick build is built
if (rebuildComponent == nullptr || rebuildComponent->GetState() == REBUILD_COMPLETED) {
if (rebuildComponent == nullptr || rebuildComponent->GetState() == eRebuildState::COMPLETED) {
auto* character = user->GetCharacter();
if (character != nullptr) {
character->SetPlayerFlag(flag, true);

4
dScripts/02_server/Map/General/Ninjago/NjRailPostServer.cpp
View File

@ -19,7 +19,7 @@ void NjRailPostServer::OnNotifyObject(Entity* self, Entity* sender, const std::s
}
void NjRailPostServer::OnRebuildNotifyState(Entity* self, eRebuildState state) {
if (state == REBUILD_COMPLETED) {
if (state == eRebuildState::COMPLETED) {
auto* relatedRail = GetRelatedRail(self);
if (relatedRail == nullptr)
return;
@ -30,7 +30,7 @@ void NjRailPostServer::OnRebuildNotifyState(Entity* self, eRebuildState state) {
return;
self->SetNetworkVar(NetworkNotActiveVariable, false);
} else if (state == REBUILD_RESETTING) {
} else if (state == eRebuildState::RESETTING) {
auto* relatedRail = GetRelatedRail(self);
if (relatedRail == nullptr)
return;

Some files were not shown because too many files have changed in this diff Show More