mirror of
https://github.com/DarkflameUniverse/DarkflameServer.git
synced 2024-11-10 02:08:20 +00:00
370 lines
14 KiB
C++
370 lines
14 KiB
C++
#include <CDPropertyEntranceComponentTable.h>
|
|
#include "PropertyEntranceComponent.h"
|
|
#include "PropertySelectQueryProperty.h"
|
|
#include "RocketLaunchpadControlComponent.h"
|
|
#include "Character.h"
|
|
#include "GameMessages.h"
|
|
#include "dLogger.h"
|
|
#include "Database.h"
|
|
#include "PropertyManagementComponent.h"
|
|
#include "UserManager.h"
|
|
|
|
PropertyEntranceComponent::PropertyEntranceComponent(uint32_t componentID, Entity* parent) : Component(parent)
|
|
{
|
|
this->propertyQueries = {};
|
|
|
|
auto table = CDClientManager::Instance()->GetTable<CDPropertyEntranceComponentTable>("PropertyEntranceComponent");
|
|
const auto& entry = table->GetByID(componentID);
|
|
|
|
this->m_MapID = entry.mapID;
|
|
this->m_PropertyName = entry.propertyName;
|
|
}
|
|
|
|
void PropertyEntranceComponent::OnUse(Entity* entity)
|
|
{
|
|
GameMessages::SendPropertyEntranceBegin(m_Parent->GetObjectID(), entity->GetSystemAddress());
|
|
|
|
AMFArrayValue args;
|
|
|
|
auto* state = new AMFStringValue();
|
|
state->SetStringValue("property_menu");
|
|
|
|
args.InsertValue("state", state);
|
|
|
|
GameMessages::SendUIMessageServerToSingleClient(entity, entity->GetSystemAddress(), "pushGameState", &args);
|
|
|
|
delete state;
|
|
}
|
|
|
|
void PropertyEntranceComponent::OnEnterProperty(Entity* entity, uint32_t index, bool returnToZone, const SystemAddress& sysAddr)
|
|
{
|
|
LWOCLONEID cloneId = 0;
|
|
|
|
if (index == -1 && !returnToZone)
|
|
{
|
|
cloneId = entity->GetCharacter()->GetPropertyCloneID();
|
|
}
|
|
else if (index == -1 && returnToZone)
|
|
{
|
|
cloneId = 0;
|
|
}
|
|
else if (index >= 0)
|
|
{
|
|
// Increment index once here because the first index of other player properties is 2 in the propertyQueries cache.
|
|
index++;
|
|
|
|
const auto& pair = propertyQueries.find(entity->GetObjectID());
|
|
|
|
if (pair == propertyQueries.end()) return;
|
|
|
|
const auto& query = pair->second;
|
|
|
|
if (index >= query.size()) return;
|
|
|
|
cloneId = query[index].CloneId;
|
|
}
|
|
|
|
Game::logger->Log("PropertyEntranceComponent", "index is %i\n", index);
|
|
|
|
auto* launcher = m_Parent->GetComponent<RocketLaunchpadControlComponent>();
|
|
|
|
if (launcher == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
launcher->SetSelectedCloneId(entity->GetObjectID(), cloneId);
|
|
|
|
launcher->Launch(entity, LWOOBJID_EMPTY, launcher->GetTargetZone(), cloneId);
|
|
}
|
|
|
|
PropertySelectQueryProperty PropertyEntranceComponent::SetPropertyValues(PropertySelectQueryProperty property, LWOCLONEID cloneId, std::string ownerName, std::string propertyName, std::string propertyDescription,
|
|
float reputation, bool isBFF, bool isFriend, bool isModeratorApproved, bool isAlt, bool isOwned, uint32_t privacyOption, uint32_t timeLastUpdated, float performanceCost) {
|
|
property.CloneId = cloneId;
|
|
property.OwnerName = ownerName;
|
|
property.Name = propertyName;
|
|
property.Description = propertyDescription;
|
|
property.Reputation = reputation;
|
|
property.IsBestFriend = isBFF;
|
|
property.IsFriend = isFriend;
|
|
property.IsModeratorApproved = isModeratorApproved;
|
|
property.IsAlt = isAlt;
|
|
property.IsOwned = isOwned;
|
|
property.AccessType = privacyOption;
|
|
property.DateLastPublished = timeLastUpdated;
|
|
property.PerformanceCost = performanceCost;
|
|
|
|
return property;
|
|
}
|
|
|
|
std::string PropertyEntranceComponent::BuildQuery(Entity* entity, int32_t sortMethod) {
|
|
auto base = baseQueryForProperties;
|
|
std::string orderBy = "";
|
|
std::string friendsList = " AND p.owner_id IN (";
|
|
if (sortMethod == SORT_TYPE_FEATURED || sortMethod == SORT_TYPE_FRIENDS) {
|
|
auto friendsListQuery = Database::CreatePreppedStmt("SELECT * FROM (SELECT CASE WHEN player_id = ? THEN friend_id WHEN friend_id = ? THEN player_id END AS requested_player FROM dlu.friends ) AS fr WHERE requested_player IS NOT NULL ORDER BY requested_player DESC;");
|
|
|
|
friendsListQuery->setInt64(1, entity->GetObjectID());
|
|
friendsListQuery->setInt64(2, entity->GetObjectID());
|
|
|
|
auto friendsListQueryResult = friendsListQuery->executeQuery();
|
|
|
|
while (friendsListQueryResult->next()) {
|
|
auto playerIDToConvert = friendsListQueryResult->getInt64(1);
|
|
playerIDToConvert = GeneralUtils::ClearBit(playerIDToConvert, OBJECT_BIT_CHARACTER);
|
|
playerIDToConvert = GeneralUtils::ClearBit(playerIDToConvert, OBJECT_BIT_PERSISTENT);
|
|
friendsList = friendsList + std::to_string(playerIDToConvert) + ",";
|
|
}
|
|
// Replace trailing comma with the closing parenthesis.
|
|
if (friendsList.at(friendsList.size() - 1) == ',') friendsList.erase(friendsList.size() - 1, 1);
|
|
friendsList += ") ";
|
|
|
|
// If we have no friends then use a -1 for the query.
|
|
if (friendsList.find("()") == std::string::npos) {
|
|
orderBy = friendsList;
|
|
} else {
|
|
friendsList = " AND p.owner_id IN (-1) ";
|
|
}
|
|
orderBy += friendsList + "ORDER BY ci.name ASC ";
|
|
|
|
delete friendsListQueryResult;
|
|
friendsListQueryResult = nullptr;
|
|
|
|
delete friendsListQuery;
|
|
friendsListQuery = nullptr;
|
|
}
|
|
else if (sortMethod == SORT_TYPE_RECENT) {
|
|
orderBy = "ORDER BY p.last_updated DESC ";
|
|
}
|
|
else if (sortMethod == SORT_TYPE_REPUTATION) {
|
|
orderBy = "ORDER BY p.reputation DESC, p.last_updated DESC ";
|
|
}
|
|
else {
|
|
orderBy = "ORDER BY p.last_updated DESC ";
|
|
}
|
|
return baseQueryForProperties + orderBy + "LIMIT ? OFFSET ?;";
|
|
}
|
|
|
|
void PropertyEntranceComponent::OnPropertyEntranceSync(Entity* entity, bool includeNullAddress, bool includeNullDescription, bool playerOwn, bool updateUi, int32_t numResults, int32_t lReputationTime, int32_t sortMethod, int32_t startIndex, std::string filterText, const SystemAddress& sysAddr){
|
|
|
|
std::vector<PropertySelectQueryProperty> entries {};
|
|
PropertySelectQueryProperty playerEntry {};
|
|
|
|
auto character = entity->GetCharacter();
|
|
if (!character) return;
|
|
|
|
// Player property goes in index 1 of the vector. This is how the client expects it.
|
|
auto playerPropertyLookup = Database::CreatePreppedStmt("SELECT * FROM properties WHERE owner_id = ? AND zone_id = ?");
|
|
|
|
playerPropertyLookup->setInt(1, character->GetID());
|
|
playerPropertyLookup->setInt(2, this->m_MapID);
|
|
|
|
auto playerPropertyLookupResults = playerPropertyLookup->executeQuery();
|
|
|
|
// If the player has a property this query will have a single result.
|
|
if (playerPropertyLookupResults->next()) {
|
|
const auto cloneId = playerPropertyLookupResults->getUInt64(4);
|
|
const auto name = playerPropertyLookupResults->getString(5).asStdString();
|
|
const auto description = playerPropertyLookupResults->getString(6).asStdString();
|
|
const auto privacyOption = playerPropertyLookupResults->getInt(9);
|
|
const auto modApproved = playerPropertyLookupResults->getBoolean(10);
|
|
const auto dateLastUpdated = playerPropertyLookupResults->getInt64(11);
|
|
const auto reputation = playerPropertyLookupResults->getUInt(14);
|
|
const auto performanceCost = (float)playerPropertyLookupResults->getDouble(16);
|
|
|
|
playerEntry = SetPropertyValues(playerEntry, cloneId, character->GetName(), name, description, reputation, true, true, modApproved, true, true, privacyOption, dateLastUpdated, performanceCost);
|
|
} else {
|
|
playerEntry = SetPropertyValues(playerEntry, character->GetPropertyCloneID(), character->GetName(), "", "", 0, true, true);
|
|
}
|
|
|
|
delete playerPropertyLookupResults;
|
|
playerPropertyLookupResults = nullptr;
|
|
|
|
delete playerPropertyLookup;
|
|
playerPropertyLookup = nullptr;
|
|
|
|
entries.push_back(playerEntry);
|
|
|
|
const auto query = BuildQuery(entity, sortMethod);
|
|
|
|
auto propertyLookup = Database::CreatePreppedStmt(query);
|
|
|
|
const auto searchString = "%" + filterText + "%";
|
|
propertyLookup->setUInt(1, this->m_MapID);
|
|
propertyLookup->setString(2, searchString.c_str());
|
|
propertyLookup->setString(3, searchString.c_str());
|
|
propertyLookup->setString(4, searchString.c_str());
|
|
propertyLookup->setInt(5, entity->GetGMLevel() >= GAME_MASTER_LEVEL_LEAD_MODERATOR || sortMethod == SORT_TYPE_FRIENDS ? 0 : 1);
|
|
propertyLookup->setInt(6, sortMethod == SORT_TYPE_FEATURED || sortMethod == SORT_TYPE_FRIENDS ? 1 : 2);
|
|
propertyLookup->setInt(7, numResults);
|
|
propertyLookup->setInt(8, startIndex);
|
|
|
|
Game::logger->Log("PropertyEntranceComponent", "Property query is \n%s\n. Entity is %s.\n", query.c_str(), entity->GetGMLevel() >= GAME_MASTER_LEVEL_LEAD_MODERATOR ? "a moderator" : "not a moderator");
|
|
|
|
auto propertyEntry = propertyLookup->executeQuery();
|
|
|
|
while (propertyEntry->next())
|
|
{
|
|
const auto propertyId = propertyEntry->getUInt64(1);
|
|
const auto owner = propertyEntry->getInt(2);
|
|
const auto cloneId = propertyEntry->getUInt64(4);
|
|
const auto name = propertyEntry->getString(5).asStdString();
|
|
const auto description = propertyEntry->getString(6).asStdString();
|
|
const auto privacyOption = propertyEntry->getInt(9);
|
|
const auto modApproved = propertyEntry->getBoolean(10);
|
|
const auto dateLastUpdated = propertyEntry->getInt(11);
|
|
const float reputation = propertyEntry->getInt(14);
|
|
const auto performanceCost = (float)propertyEntry->getDouble(16);
|
|
|
|
PropertySelectQueryProperty entry {};
|
|
|
|
std::string ownerName = "";
|
|
bool isOwned = true;
|
|
auto nameLookup = Database::CreatePreppedStmt("SELECT name FROM charinfo WHERE prop_clone_id = ?;");
|
|
|
|
nameLookup->setUInt64(1, cloneId);
|
|
|
|
auto nameResult = nameLookup->executeQuery();
|
|
|
|
if (!nameResult->next()) {
|
|
delete nameLookup;
|
|
nameLookup = nullptr;
|
|
|
|
Game::logger->Log("PropertyEntranceComponent", "Failed to find property owner name for %llu!\n", cloneId);
|
|
|
|
continue;
|
|
}
|
|
else {
|
|
isOwned = cloneId == character->GetPropertyCloneID();
|
|
ownerName = nameResult->getString(1).asStdString();
|
|
}
|
|
|
|
delete nameResult;
|
|
nameResult = nullptr;
|
|
|
|
delete nameLookup;
|
|
nameLookup = nullptr;
|
|
|
|
std::string propertyName = "";
|
|
std::string propertyDescription = "";
|
|
propertyName = name;
|
|
propertyDescription = description;
|
|
|
|
bool isBestFriend = false;
|
|
bool isFriend = false;
|
|
|
|
// Convert owner char id to LWOOBJID
|
|
LWOOBJID ownerObjId = owner;
|
|
ownerObjId = GeneralUtils::SetBit(ownerObjId, OBJECT_BIT_CHARACTER);
|
|
ownerObjId = GeneralUtils::SetBit(ownerObjId, OBJECT_BIT_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 = ?)");
|
|
|
|
friendCheck->setInt64(1, entity->GetObjectID());
|
|
friendCheck->setInt64(2, ownerObjId);
|
|
friendCheck->setInt64(3, ownerObjId);
|
|
friendCheck->setInt64(4, entity->GetObjectID());
|
|
|
|
auto friendResult = friendCheck->executeQuery();
|
|
|
|
// If we got a result than the two players are friends.
|
|
if (friendResult->next()) {
|
|
isFriend = true;
|
|
if (friendResult->getInt(1) == 2) {
|
|
isBestFriend = true;
|
|
}
|
|
}
|
|
|
|
delete friendCheck;
|
|
friendCheck = nullptr;
|
|
|
|
delete friendResult;
|
|
friendResult = nullptr;
|
|
|
|
bool isModeratorApproved = propertyEntry->getBoolean(10);
|
|
|
|
if (!isModeratorApproved && entity->GetGMLevel() >= GAME_MASTER_LEVEL_LEAD_MODERATOR) {
|
|
propertyName = "[AWAITING APPROVAL]";
|
|
propertyDescription = "[AWAITING APPROVAL]";
|
|
isModeratorApproved = true;
|
|
}
|
|
|
|
bool isAlt = false;
|
|
// Query to determine whether this property is an alt of the entity.
|
|
auto isAltQuery = Database::CreatePreppedStmt("SELECT id FROM charinfo where account_id in (SELECT account_id from charinfo WHERE id = ?) AND id = ?;");
|
|
|
|
isAltQuery->setInt(1, character->GetID());
|
|
isAltQuery->setInt(2, owner);
|
|
|
|
auto isAltQueryResults = isAltQuery->executeQuery();
|
|
|
|
if (isAltQueryResults->next()) {
|
|
isAlt = true;
|
|
}
|
|
|
|
delete isAltQueryResults;
|
|
isAltQueryResults = nullptr;
|
|
|
|
delete isAltQuery;
|
|
isAltQuery = nullptr;
|
|
|
|
entry = SetPropertyValues(entry, cloneId, ownerName, propertyName, propertyDescription, reputation, isBestFriend, isFriend, isModeratorApproved, isAlt, isOwned, privacyOption, dateLastUpdated, performanceCost);
|
|
|
|
entries.push_back(entry);
|
|
}
|
|
|
|
delete propertyEntry;
|
|
propertyEntry = nullptr;
|
|
|
|
delete propertyLookup;
|
|
propertyLookup = nullptr;
|
|
|
|
propertyQueries[entity->GetObjectID()] = entries;
|
|
|
|
uint32_t numberOfProperties = 0;
|
|
if (sortMethod != SORT_TYPE_FRIENDS || sortMethod != SORT_TYPE_FEATURED) {
|
|
auto propertiesLeft = Database::CreatePreppedStmt("SELECT COUNT(*) FROM properties WHERE zone_id = ?;");
|
|
|
|
propertiesLeft->setInt(1, this->m_MapID);
|
|
|
|
auto result = propertiesLeft->executeQuery();
|
|
result->next();
|
|
numberOfProperties = result->getInt(1);
|
|
|
|
delete result;
|
|
result = nullptr;
|
|
|
|
delete propertiesLeft;
|
|
propertiesLeft = nullptr;
|
|
} else {
|
|
auto forFriends = query;
|
|
forFriends.replace(7, 3, "COUNT(*)");
|
|
|
|
auto friendsQuery = Database::CreatePreppedStmt(query);
|
|
|
|
propertyLookup->setUInt(1, this->m_MapID);
|
|
propertyLookup->setString(2, searchString.c_str());
|
|
propertyLookup->setString(3, searchString.c_str());
|
|
propertyLookup->setString(4, searchString.c_str());
|
|
propertyLookup->setInt(5, entity->GetGMLevel() >= GAME_MASTER_LEVEL_LEAD_MODERATOR || sortMethod == SORT_TYPE_FRIENDS ? 0 : 1);
|
|
propertyLookup->setInt(6, sortMethod == SORT_TYPE_FEATURED || sortMethod == SORT_TYPE_FRIENDS ? 1 : 2);
|
|
propertyLookup->setInt(7, numResults);
|
|
propertyLookup->setInt(8, startIndex);
|
|
|
|
auto result = friendsQuery->executeQuery();
|
|
result->next();
|
|
numberOfProperties = result->getInt(1);
|
|
|
|
delete friendsQuery;
|
|
friendsQuery = nullptr;
|
|
|
|
delete result;
|
|
result = nullptr;
|
|
}
|
|
|
|
// if sort method is friends or featured do above query.
|
|
// do same maths below with resulting query
|
|
// else use default count.
|
|
GameMessages::SendPropertySelectQuery(m_Parent->GetObjectID(), startIndex, numberOfProperties - (startIndex + numResults) > 0, character->GetPropertyCloneID(), false, true, entries, sysAddr);
|
|
} |