pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2026-03-03 19:52:26 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
eqemu-server/common/repositories/base/base_dynamic_zones_repository.h
hg 676467cbdc
[Dynamic Zones] Implement dz switch id (#2343) 
This adds the `dz_switch_id` field to doors and dynamic_zones. It will
allow for compasses to be automatically added to dz entrances and will
support moving clients to the dz on use without needing to script it.
These can be imported for switches/doors from live packet dumps.

Also removes compass packet encoders (same struct in all clients)
2022-07-30 21:00:11 -05:00

517 lines
17 KiB
C++
Raw Blame History

/**
* DO NOT MODIFY THIS FILE
*
* This repository was automatically generated and is NOT to be modified directly.
* Any repository modifications are meant to be made to the repository extending the base.
* Any modifications to base repositories are to be made by the generator only
*
* @generator ./utils/scripts/generators/repository-generator.pl
* @docs https://eqemu.gitbook.io/server/in-development/developer-area/repositories
*/
#ifndef EQEMU_BASE_DYNAMIC_ZONES_REPOSITORY_H
#define EQEMU_BASE_DYNAMIC_ZONES_REPOSITORY_H
#include "../../database.h"
#include "../../strings.h"
#include <ctime>
class BaseDynamicZonesRepository {
public:
struct DynamicZones {
int id;
int instance_id;
int type;
std::string uuid;
std::string name;
int leader_id;
int min_players;
int max_players;
int dz_switch_id;
int compass_zone_id;
float compass_x;
float compass_y;
float compass_z;
int safe_return_zone_id;
float safe_return_x;
float safe_return_y;
float safe_return_z;
float safe_return_heading;
float zone_in_x;
float zone_in_y;
float zone_in_z;
float zone_in_heading;
int has_zone_in;
};
static std::string PrimaryKey()
{
return std::string("id");
}
static std::vector<std::string> Columns()
{
return {
"id",
"instance_id",
"type",
"uuid",
"name",
"leader_id",
"min_players",
"max_players",
"dz_switch_id",
"compass_zone_id",
"compass_x",
"compass_y",
"compass_z",
"safe_return_zone_id",
"safe_return_x",
"safe_return_y",
"safe_return_z",
"safe_return_heading",
"zone_in_x",
"zone_in_y",
"zone_in_z",
"zone_in_heading",
"has_zone_in",
};
}
static std::vector<std::string> SelectColumns()
{
return {
"id",
"instance_id",
"type",
"uuid",
"name",
"leader_id",
"min_players",
"max_players",
"dz_switch_id",
"compass_zone_id",
"compass_x",
"compass_y",
"compass_z",
"safe_return_zone_id",
"safe_return_x",
"safe_return_y",
"safe_return_z",
"safe_return_heading",
"zone_in_x",
"zone_in_y",
"zone_in_z",
"zone_in_heading",
"has_zone_in",
};
}
static std::string ColumnsRaw()
{
return std::string(Strings::Implode(", ", Columns()));
}
static std::string SelectColumnsRaw()
{
return std::string(Strings::Implode(", ", SelectColumns()));
}
static std::string TableName()
{
return std::string("dynamic_zones");
}
static std::string BaseSelect()
{
return fmt::format(
"SELECT {} FROM {}",
SelectColumnsRaw(),
TableName()
);
}
static std::string BaseInsert()
{
return fmt::format(
"INSERT INTO {} ({}) ",
TableName(),
ColumnsRaw()
);
}
static DynamicZones NewEntity()
{
DynamicZones entry{};
entry.id = 0;
entry.instance_id = 0;
entry.type = 0;
entry.uuid = "";
entry.name = "";
entry.leader_id = 0;
entry.min_players = 0;
entry.max_players = 0;
entry.dz_switch_id = 0;
entry.compass_zone_id = 0;
entry.compass_x = 0;
entry.compass_y = 0;
entry.compass_z = 0;
entry.safe_return_zone_id = 0;
entry.safe_return_x = 0;
entry.safe_return_y = 0;
entry.safe_return_z = 0;
entry.safe_return_heading = 0;
entry.zone_in_x = 0;
entry.zone_in_y = 0;
entry.zone_in_z = 0;
entry.zone_in_heading = 0;
entry.has_zone_in = 0;
return entry;
}
static DynamicZones GetDynamicZonesEntry(
const std::vector<DynamicZones> &dynamic_zoness,
int dynamic_zones_id
)
{
for (auto &dynamic_zones : dynamic_zoness) {
if (dynamic_zones.id == dynamic_zones_id) {
return dynamic_zones;
}
}
return NewEntity();
}
static DynamicZones FindOne(
Database& db,
int dynamic_zones_id
)
{
auto results = db.QueryDatabase(
fmt::format(
"{} WHERE id = {} LIMIT 1",
BaseSelect(),
dynamic_zones_id
)
);
auto row = results.begin();
if (results.RowCount() == 1) {
DynamicZones entry{};
entry.id = atoi(row[0]);
entry.instance_id = atoi(row[1]);
entry.type = atoi(row[2]);
entry.uuid = row[3] ? row[3] : "";
entry.name = row[4] ? row[4] : "";
entry.leader_id = atoi(row[5]);
entry.min_players = atoi(row[6]);
entry.max_players = atoi(row[7]);
entry.dz_switch_id = atoi(row[8]);
entry.compass_zone_id = atoi(row[9]);
entry.compass_x = static_cast<float>(atof(row[10]));
entry.compass_y = static_cast<float>(atof(row[11]));
entry.compass_z = static_cast<float>(atof(row[12]));
entry.safe_return_zone_id = atoi(row[13]);
entry.safe_return_x = static_cast<float>(atof(row[14]));
entry.safe_return_y = static_cast<float>(atof(row[15]));
entry.safe_return_z = static_cast<float>(atof(row[16]));
entry.safe_return_heading = static_cast<float>(atof(row[17]));
entry.zone_in_x = static_cast<float>(atof(row[18]));
entry.zone_in_y = static_cast<float>(atof(row[19]));
entry.zone_in_z = static_cast<float>(atof(row[20]));
entry.zone_in_heading = static_cast<float>(atof(row[21]));
entry.has_zone_in = atoi(row[22]);
return entry;
}
return NewEntity();
}
static int DeleteOne(
Database& db,
int dynamic_zones_id
)
{
auto results = db.QueryDatabase(
fmt::format(
"DELETE FROM {} WHERE {} = {}",
TableName(),
PrimaryKey(),
dynamic_zones_id
)
);
return (results.Success() ? results.RowsAffected() : 0);
}
static int UpdateOne(
Database& db,
DynamicZones dynamic_zones_entry
)
{
std::vector<std::string> update_values;
auto columns = Columns();
update_values.push_back(columns[1] + " = " + std::to_string(dynamic_zones_entry.instance_id));
update_values.push_back(columns[2] + " = " + std::to_string(dynamic_zones_entry.type));
update_values.push_back(columns[3] + " = '" + Strings::Escape(dynamic_zones_entry.uuid) + "'");
update_values.push_back(columns[4] + " = '" + Strings::Escape(dynamic_zones_entry.name) + "'");
update_values.push_back(columns[5] + " = " + std::to_string(dynamic_zones_entry.leader_id));
update_values.push_back(columns[6] + " = " + std::to_string(dynamic_zones_entry.min_players));
update_values.push_back(columns[7] + " = " + std::to_string(dynamic_zones_entry.max_players));
update_values.push_back(columns[8] + " = " + std::to_string(dynamic_zones_entry.dz_switch_id));
update_values.push_back(columns[9] + " = " + std::to_string(dynamic_zones_entry.compass_zone_id));
update_values.push_back(columns[10] + " = " + std::to_string(dynamic_zones_entry.compass_x));
update_values.push_back(columns[11] + " = " + std::to_string(dynamic_zones_entry.compass_y));
update_values.push_back(columns[12] + " = " + std::to_string(dynamic_zones_entry.compass_z));
update_values.push_back(columns[13] + " = " + std::to_string(dynamic_zones_entry.safe_return_zone_id));
update_values.push_back(columns[14] + " = " + std::to_string(dynamic_zones_entry.safe_return_x));
update_values.push_back(columns[15] + " = " + std::to_string(dynamic_zones_entry.safe_return_y));
update_values.push_back(columns[16] + " = " + std::to_string(dynamic_zones_entry.safe_return_z));
update_values.push_back(columns[17] + " = " + std::to_string(dynamic_zones_entry.safe_return_heading));
update_values.push_back(columns[18] + " = " + std::to_string(dynamic_zones_entry.zone_in_x));
update_values.push_back(columns[19] + " = " + std::to_string(dynamic_zones_entry.zone_in_y));
update_values.push_back(columns[20] + " = " + std::to_string(dynamic_zones_entry.zone_in_z));
update_values.push_back(columns[21] + " = " + std::to_string(dynamic_zones_entry.zone_in_heading));
update_values.push_back(columns[22] + " = " + std::to_string(dynamic_zones_entry.has_zone_in));
auto results = db.QueryDatabase(
fmt::format(
"UPDATE {} SET {} WHERE {} = {}",
TableName(),
Strings::Implode(", ", update_values),
PrimaryKey(),
dynamic_zones_entry.id
)
);
return (results.Success() ? results.RowsAffected() : 0);
}
static DynamicZones InsertOne(
Database& db,
DynamicZones dynamic_zones_entry
)
{
std::vector<std::string> insert_values;
insert_values.push_back(std::to_string(dynamic_zones_entry.id));
insert_values.push_back(std::to_string(dynamic_zones_entry.instance_id));
insert_values.push_back(std::to_string(dynamic_zones_entry.type));
insert_values.push_back("'" + Strings::Escape(dynamic_zones_entry.uuid) + "'");
insert_values.push_back("'" + Strings::Escape(dynamic_zones_entry.name) + "'");
insert_values.push_back(std::to_string(dynamic_zones_entry.leader_id));
insert_values.push_back(std::to_string(dynamic_zones_entry.min_players));
insert_values.push_back(std::to_string(dynamic_zones_entry.max_players));
insert_values.push_back(std::to_string(dynamic_zones_entry.dz_switch_id));
insert_values.push_back(std::to_string(dynamic_zones_entry.compass_zone_id));
insert_values.push_back(std::to_string(dynamic_zones_entry.compass_x));
insert_values.push_back(std::to_string(dynamic_zones_entry.compass_y));
insert_values.push_back(std::to_string(dynamic_zones_entry.compass_z));
insert_values.push_back(std::to_string(dynamic_zones_entry.safe_return_zone_id));
insert_values.push_back(std::to_string(dynamic_zones_entry.safe_return_x));
insert_values.push_back(std::to_string(dynamic_zones_entry.safe_return_y));
insert_values.push_back(std::to_string(dynamic_zones_entry.safe_return_z));
insert_values.push_back(std::to_string(dynamic_zones_entry.safe_return_heading));
insert_values.push_back(std::to_string(dynamic_zones_entry.zone_in_x));
insert_values.push_back(std::to_string(dynamic_zones_entry.zone_in_y));
insert_values.push_back(std::to_string(dynamic_zones_entry.zone_in_z));
insert_values.push_back(std::to_string(dynamic_zones_entry.zone_in_heading));
insert_values.push_back(std::to_string(dynamic_zones_entry.has_zone_in));
auto results = db.QueryDatabase(
fmt::format(
"{} VALUES ({})",
BaseInsert(),
Strings::Implode(",", insert_values)
)
);
if (results.Success()) {
dynamic_zones_entry.id = results.LastInsertedID();
return dynamic_zones_entry;
}
dynamic_zones_entry = NewEntity();
return dynamic_zones_entry;
}
static int InsertMany(
Database& db,
std::vector<DynamicZones> dynamic_zones_entries
)
{
std::vector<std::string> insert_chunks;
for (auto &dynamic_zones_entry: dynamic_zones_entries) {
std::vector<std::string> insert_values;
insert_values.push_back(std::to_string(dynamic_zones_entry.id));
insert_values.push_back(std::to_string(dynamic_zones_entry.instance_id));
insert_values.push_back(std::to_string(dynamic_zones_entry.type));
insert_values.push_back("'" + Strings::Escape(dynamic_zones_entry.uuid) + "'");
insert_values.push_back("'" + Strings::Escape(dynamic_zones_entry.name) + "'");
insert_values.push_back(std::to_string(dynamic_zones_entry.leader_id));
insert_values.push_back(std::to_string(dynamic_zones_entry.min_players));
insert_values.push_back(std::to_string(dynamic_zones_entry.max_players));
insert_values.push_back(std::to_string(dynamic_zones_entry.dz_switch_id));
insert_values.push_back(std::to_string(dynamic_zones_entry.compass_zone_id));
insert_values.push_back(std::to_string(dynamic_zones_entry.compass_x));
insert_values.push_back(std::to_string(dynamic_zones_entry.compass_y));
insert_values.push_back(std::to_string(dynamic_zones_entry.compass_z));
insert_values.push_back(std::to_string(dynamic_zones_entry.safe_return_zone_id));
insert_values.push_back(std::to_string(dynamic_zones_entry.safe_return_x));
insert_values.push_back(std::to_string(dynamic_zones_entry.safe_return_y));
insert_values.push_back(std::to_string(dynamic_zones_entry.safe_return_z));
insert_values.push_back(std::to_string(dynamic_zones_entry.safe_return_heading));
insert_values.push_back(std::to_string(dynamic_zones_entry.zone_in_x));
insert_values.push_back(std::to_string(dynamic_zones_entry.zone_in_y));
insert_values.push_back(std::to_string(dynamic_zones_entry.zone_in_z));
insert_values.push_back(std::to_string(dynamic_zones_entry.zone_in_heading));
insert_values.push_back(std::to_string(dynamic_zones_entry.has_zone_in));
insert_chunks.push_back("(" + Strings::Implode(",", insert_values) + ")");
}
std::vector<std::string> insert_values;
auto results = db.QueryDatabase(
fmt::format(
"{} VALUES {}",
BaseInsert(),
Strings::Implode(",", insert_chunks)
)
);
return (results.Success() ? results.RowsAffected() : 0);
}
static std::vector<DynamicZones> All(Database& db)
{
std::vector<DynamicZones> all_entries;
auto results = db.QueryDatabase(
fmt::format(
"{}",
BaseSelect()
)
);
all_entries.reserve(results.RowCount());
for (auto row = results.begin(); row != results.end(); ++row) {
DynamicZones entry{};
entry.id = atoi(row[0]);
entry.instance_id = atoi(row[1]);
entry.type = atoi(row[2]);
entry.uuid = row[3] ? row[3] : "";
entry.name = row[4] ? row[4] : "";
entry.leader_id = atoi(row[5]);
entry.min_players = atoi(row[6]);
entry.max_players = atoi(row[7]);
entry.dz_switch_id = atoi(row[8]);
entry.compass_zone_id = atoi(row[9]);
entry.compass_x = static_cast<float>(atof(row[10]));
entry.compass_y = static_cast<float>(atof(row[11]));
entry.compass_z = static_cast<float>(atof(row[12]));
entry.safe_return_zone_id = atoi(row[13]);
entry.safe_return_x = static_cast<float>(atof(row[14]));
entry.safe_return_y = static_cast<float>(atof(row[15]));
entry.safe_return_z = static_cast<float>(atof(row[16]));
entry.safe_return_heading = static_cast<float>(atof(row[17]));
entry.zone_in_x = static_cast<float>(atof(row[18]));
entry.zone_in_y = static_cast<float>(atof(row[19]));
entry.zone_in_z = static_cast<float>(atof(row[20]));
entry.zone_in_heading = static_cast<float>(atof(row[21]));
entry.has_zone_in = atoi(row[22]);
all_entries.push_back(entry);
}
return all_entries;
}
static std::vector<DynamicZones> GetWhere(Database& db, std::string where_filter)
{
std::vector<DynamicZones> all_entries;
auto results = db.QueryDatabase(
fmt::format(
"{} WHERE {}",
BaseSelect(),
where_filter
)
);
all_entries.reserve(results.RowCount());
for (auto row = results.begin(); row != results.end(); ++row) {
DynamicZones entry{};
entry.id = atoi(row[0]);
entry.instance_id = atoi(row[1]);
entry.type = atoi(row[2]);
entry.uuid = row[3] ? row[3] : "";
entry.name = row[4] ? row[4] : "";
entry.leader_id = atoi(row[5]);
entry.min_players = atoi(row[6]);
entry.max_players = atoi(row[7]);
entry.dz_switch_id = atoi(row[8]);
entry.compass_zone_id = atoi(row[9]);
entry.compass_x = static_cast<float>(atof(row[10]));
entry.compass_y = static_cast<float>(atof(row[11]));
entry.compass_z = static_cast<float>(atof(row[12]));
entry.safe_return_zone_id = atoi(row[13]);
entry.safe_return_x = static_cast<float>(atof(row[14]));
entry.safe_return_y = static_cast<float>(atof(row[15]));
entry.safe_return_z = static_cast<float>(atof(row[16]));
entry.safe_return_heading = static_cast<float>(atof(row[17]));
entry.zone_in_x = static_cast<float>(atof(row[18]));
entry.zone_in_y = static_cast<float>(atof(row[19]));
entry.zone_in_z = static_cast<float>(atof(row[20]));
entry.zone_in_heading = static_cast<float>(atof(row[21]));
entry.has_zone_in = atoi(row[22]);
all_entries.push_back(entry);
}
return all_entries;
}
static int DeleteWhere(Database& db, std::string where_filter)
{
auto results = db.QueryDatabase(
fmt::format(
"DELETE FROM {} WHERE {}",
TableName(),
where_filter
)
);
return (results.Success() ? results.RowsAffected() : 0);
}
static int Truncate(Database& db)
{
auto results = db.QueryDatabase(
fmt::format(
"TRUNCATE TABLE {}",
TableName()
)
);
return (results.Success() ? results.RowsAffected() : 0);
}
};
#endif //EQEMU_BASE_DYNAMIC_ZONES_REPOSITORY_H
Reference in New Issue View Git Blame Copy Permalink