bool BaseGuildManager::GetEntireGuild(uint32 guild_id, std::vector<CharGuildInfo *> &members) {
members.clear();
if(m_db == nullptr)
return(false);
//load up the rank info for each guild.
std::string query = StringFormat(GuildMemberBaseQuery " WHERE g.guild_id=%d", guild_id);
auto results = m_db->QueryDatabase(query);
if (!results.Success()) {
_log(GUILDS__ERROR, "Error loading guild member list '%s': %s", query.c_str(), results.ErrorMessage().c_str());
return false;
}
for (auto row = results.begin(); row != results.end(); ++row) {
CharGuildInfo *ci = new CharGuildInfo;
ProcessGuildMember(row, *ci);
members.push_back(ci);
}
_log(GUILDS__DB, "Retreived entire guild member list for guild %d from the database", guild_id);
return true;
}
bool Group::LearnMembers() {
std::string query = StringFormat("SELECT name FROM group_id WHERE groupid = %lu", (unsigned long)GetID());
auto results = database.QueryDatabase(query);
if (!results.Success())
return false;
if (results.RowCount() == 0) {
Log.Out(Logs::General, Logs::Error, "Error getting group members for group %lu: %s", (unsigned long)GetID(), results.ErrorMessage().c_str());
return false;
}
int memberIndex = 0;
for(auto row = results.begin(); row != results.end(); ++row) {
if(!row[0])
continue;
members[memberIndex] = nullptr;
strn0cpy(membername[memberIndex], row[0], 64);
memberIndex++;
}
return true;
}
bool BaseGuildManager::DBSetPublicNote(uint32 charid, const char* note) {
if(m_db == nullptr)
return(false);
//escape our strings.
uint32 len = strlen(note);
char *esc = new char[len*2+1];
m_db->DoEscapeString(esc, note, len);
//insert the new `guilds` entry
std::string query = StringFormat("UPDATE guild_members SET public_note='%s' WHERE char_id=%d", esc, charid);
safe_delete_array(esc);
auto results = m_db->QueryDatabase(query);
if (!results.Success())
{
_log(GUILDS__ERROR, "Error setting public note for char %d '%s': %s", charid, query.c_str(), results.ErrorMessage().c_str());
return false;
}
_log(GUILDS__DB, "Set public not for char %d", charid);
return true;
}
Error ClientState::commit(ClientStateCommitType commitType,
const ::core::FilePath& stateDir,
const ::core::FilePath& projectStateDir)
{
// remove and re-create the stateDirs
Error error = removeAndRecreateStateDir(stateDir);
if (error)
return error;
error = removeAndRecreateStateDir(projectStateDir);
if (error)
return error;
// always commit persistent state
commitState(persistentState_, kPersistentExt, stateDir);
commitState(projectPersistentState_, kProjPersistentExt, projectStateDir);
// commit all state if requested
if (commitType == ClientStateCommitAll)
commitState(temporaryState_, kTemporaryExt, stateDir);
else
temporaryState_.clear();
return Success();
}
// Given a path, searches for the document in the Documents collection that
// has the path given. The out parameter is set to that document's IDispatch
// pointer, or NULL if no document with the path could be found.
Error WordViewer::getDocumentByPath(QString& path, IDispatch** pidispDoc)
{
Error errorHR = Success();
HRESULT hr = S_OK;
IDispatch* idispDocs = NULL;
IDispatch* idispDoc = NULL;
VARIANT varDocIdx;
VARIANT varResult;
int docCount = 0;
*pidispDoc = NULL;
VERIFY_HRESULT(getIDispatchProp(idispWord_, L"Documents", &idispDocs));
VERIFY_HRESULT(getIntProp(idispDocs, L"Count", &docCount));
varDocIdx.vt = VT_INT;
for (int i = 1; i <= docCount; i++)
{
VariantInit(&varResult);
varDocIdx.intVal = i;
VERIFY_HRESULT(invokeDispatch(DISPATCH_METHOD, &varResult, idispDocs,
L"Item", 1, varDocIdx));
idispDoc = varResult.pdispVal;
VERIFY_HRESULT(invokeDispatch(DISPATCH_PROPERTYGET, &varResult, idispDoc,
L"FullName", 0));
if (path.toStdWString() == varResult.bstrVal)
{
*pidispDoc = idispDoc;
break;
}
}
LErrExit:
return errorHR;
}
bool EQEmu::ProfanityManager::RemoveProfanity(DBcore *db, const char *profanity) {
if (!db || !profanity)
return false;
std::string entry(profanity);
std::transform(entry.begin(), entry.end(), entry.begin(), [](unsigned char c) -> unsigned char { return tolower(c); });
if (!check_for_existing_entry(entry.c_str()))
return true;
profanity_list.remove(entry);
std::string query = "DELETE FROM `profanity_list` WHERE `word` LIKE '";
query.append(entry);
query.append("'");
auto results = db->QueryDatabase(query);
if (!results.Success())
return false;
update_originator_flag = true;
return true;
}
void RuleManager::_SaveRule(Database *db, RuleType type, uint16 index) {
char vstr[100];
switch(type) {
case IntRule:
sprintf(vstr, "%d", m_RuleIntValues[index]);
break;
case RealRule:
sprintf(vstr, "%.13f", m_RuleRealValues[index]);
break;
case BoolRule:
sprintf(vstr, "%s", m_RuleBoolValues[index]?"true":"false");
break;
}
std::string query = StringFormat("REPLACE INTO rule_values "
"(ruleset_id, rule_name, rule_value) "
" VALUES(%d, '%s', '%s')",
m_activeRuleset, _GetRuleName(type, index), vstr);
auto results = db->QueryDatabase(query);
if (!results.Success())
_log(RULES__ERROR, "Fauled to set rule in the database: %s: %s", query.c_str(), results.ErrorMessage().c_str());
}
// Add new Zone Object (theoretically only called for items dropped to ground)
uint32 ZoneDatabase::AddObject(uint32 type, uint32 icon, const Object_Struct& object, const ItemInst* inst)
{
uint32 database_id = 0;
uint32 item_id = 0;
int16 charges = 0;
if (inst && inst->GetItem()) {
item_id = inst->GetItem()->ID;
charges = inst->GetCharges();
}
// SQL Escape object_name
uint32 len = strlen(object.object_name) * 2 + 1;
char* object_name = new char[len];
DoEscapeString(object_name, object.object_name, strlen(object.object_name));
// Save new record for object
std::string query = StringFormat("INSERT INTO object "
"(zoneid, xpos, ypos, zpos, heading, "
"itemid, charges, objectname, type, icon) "
"values (%i, %f, %f, %f, %f, %i, %i, '%s', %i, %i)",
object.zone_id, object.x, object.y, object.z, object.heading,
item_id, charges, object_name, type, icon);
safe_delete_array(object_name);
auto results = QueryDatabase(query);
if (!results.Success()) {
LogFile->write(EQEMuLog::Error, "Unable to insert object: %s", results.ErrorMessage().c_str());
return 0;
}
// Save container contents, if container
if (inst && inst->IsType(ItemClassContainer))
SaveWorldContainer(object.zone_id, database_id, inst);
return database_id;
}
void Database::CreateLSAccount(std::string name, std::string password, std::string email, unsigned int created_by, std::string LastIPAddress, std::string creationIP)
{
bool activate = 0;
if (LoadServerSettings("options", "auto_account_activate") == "TRUE")
{
activate = 1;
}
std::string query;
char tmpUN[1024];
DoEscapeString(tmpUN, name.c_str(), (int)name.length());
query = StringFormat("INSERT INTO %s "
"SET AccountName = '%s', "
"AccountPassword = sha('%s'), "
"AccountCreateDate = now(), "
"LastLoginDate = now(), "
"LastIPAddress = '%s', "
"client_unlock = '%s', "
"created_by = '%s', "
"creationIP = '%s'",
LoadServerSettings("schema", "account_table").c_str(),
tmpUN,
password.c_str(),
LastIPAddress.c_str(),
std::to_string(activate).c_str(),
std::to_string(created_by).c_str(),
creationIP.c_str()
);
auto results = QueryDatabase(query);
if (!results.Success())
{
server_log->Log(log_database_error, "Mysql query failed: %s", query.c_str());
}
}
int16 SpawnConditionManager::GetCondition(const char *zone_short, uint32 instance_id, uint16 condition_id) {
if(!strcasecmp(zone_short, zone->GetShortName()) && instance_id == zone->GetInstanceID())
{
//this is a local spawn condition
std::map<uint16, SpawnCondition>::iterator condi;
condi = spawn_conditions.find(condition_id);
if(condi == spawn_conditions.end())
{
Log(Logs::Detail, Logs::Spawns, "Unable to find local condition %d in Get request.", condition_id);
return(0); //unable to find the spawn condition
}
SpawnCondition &cond = condi->second;
return cond.value;
}
//this is a remote spawn condition, grab it from the DB
//load spawn conditions
std::string query = StringFormat("SELECT value FROM spawn_condition_values "
"WHERE zone = '%s' AND instance_id = %u AND id = %d",
zone_short, instance_id, condition_id);
auto results = database.QueryDatabase(query);
if (!results.Success()) {
Log(Logs::Detail, Logs::Spawns, "Unable to query remote condition %d from zone %s in Get request.", condition_id, zone_short);
return 0; //dunno a better thing to do...
}
if (results.RowCount() == 0) {
Log(Logs::Detail, Logs::Spawns, "Unable to load remote condition %d from zone %s in Get request.", condition_id, zone_short);
return 0; //dunno a better thing to do...
}
auto row = results.begin();
return atoi(row[0]);
}
Error ConnectionHistory::readConnections(json::Array* pConnections)
{
FilePath connectionListFile = connectionsDir_.childPath(kConnectionListFile);
if (connectionListFile.exists())
{
std::string contents;
Error error = core::readStringFromFile(connectionListFile, &contents);
if (error)
return error;
json::Value parsedJson;
if (!json::parse(contents, &parsedJson) ||
!json::isType<json::Array>(parsedJson))
{
return systemError(boost::system::errc::protocol_error,
"Error parsing connections json file",
ERROR_LOCATION);
}
*pConnections = parsedJson.get_value<json::Array>();
}
return Success();
}
bool Database::SetServerSettings(std::string type, std::string category, std::string defaults)
{
std::string query;
Config* newval = new Config;
std::string loadINIvalue = newval->LoadOption(category, type, "login.ini");
query = StringFormat(
"UPDATE tblloginserversettings "
"SET value = '%s' "
"WHERE type = '%s' "
"AND category = '%s' "
"LIMIT 1",
loadINIvalue.empty() ? defaults.c_str() : loadINIvalue.c_str(), type.c_str(), category.c_str());
safe_delete(newval);
auto results = QueryDatabase(query);
if (!results.Success())
{
server_log->Log(log_database_error, "SetServerSettings Mysql check_query failed: %s", query.c_str());
return false;
}
return true;
}
bool Database::GetLoginDataFromAccountName(std::string name, std::string &password, unsigned int &id)
{
std::string query;
char tmpUN[1024];
DoEscapeString(tmpUN, name.c_str(), (int)name.length()); (tmpUN, name.c_str(), (int)name.length());
query = StringFormat("SELECT LoginServerID, AccountPassword "
"FROM %s WHERE "
"AccountName = '%s'",
LoadServerSettings("schema", "account_table").c_str(),
tmpUN
);
auto results = QueryDatabase(query);
if (!results.Success())
{
server_log->Log(log_database_error, "Mysql query failed: %s", query.c_str());
return false;
}
if (results.RowCount() > 0)
{
auto row = results.begin();
if (row[0] != nullptr)
{
id = atoi(row[0]);
password = row[1];
return true;
}
server_log->Log(log_database_error, "Unknown error, no result for: %s", query.c_str());
return false;
}
server_log->Log(log_database_error, "Mysql query returned no result for: %s", query.c_str());
return false;
}
void Database::LogPlayerItemMove(QSPlayerLogItemMove_Struct* QS, uint32 items)
{
if (items == 0)
{
return;
}
for(uint32 i = 0; i < items; i++)
{
std::string query = StringFormat(
"INSERT INTO `qs_player_item_move_log` SET "
"`char_id` = '%i', "
"`from_slot` = '%i', "
"`to_slot` = '%i', "
"`item_id` = '%i', "
"`charges` = '%i', "
"`stack_size` = '%i', "
"`char_items` = '%i', "
"`postaction` = '%i', "
"`time` = now()",
QS->char_id,
QS->items[i].from_slot,
QS->items[i].to_slot,
QS->items[i].item_id,
QS->items[i].charges,
QS->stack_size,
QS->char_count,
QS->postaction);
auto results = QueryDatabase(query);
if(!results.Success())
{
Log.Out(Logs::Detail, Logs::QS_Server, "Failed Move Log Record Entry Insert: %s\n%s", results.ErrorMessage().c_str(), query.c_str());
}
}
}
void Database::AddSpeech(const char* from, const char* to, const char* message, uint16 minstatus, uint32 guilddbid, uint8 type) {
char *escapedFrom = new char[strlen(from) * 2 + 1];
char *escapedTo = new char[strlen(to) * 2 + 1];
char *escapedMessage = new char[strlen(message) * 2 + 1];
DoEscapeString(escapedFrom, from, strlen(from));
DoEscapeString(escapedTo, to, strlen(to));
DoEscapeString(escapedMessage, message, strlen(message));
std::string query = StringFormat("INSERT INTO `qs_player_speech` "
"SET `from` = '%s', `to` = '%s', `message`='%s', "
"`minstatus`='%i', `guilddbid`='%i', `type`='%i'",
escapedFrom, escapedTo, escapedMessage, minstatus, guilddbid, type);
safe_delete_array(escapedFrom);
safe_delete_array(escapedTo);
safe_delete_array(escapedMessage);
auto results = QueryDatabase(query);
if(!results.Success()) {
Log.Out(Logs::Detail, Logs::QS_Server, "Failed Speech Entry Insert: %s", results.ErrorMessage().c_str());
Log.Out(Logs::Detail, Logs::QS_Server, "%s", query.c_str());
}
}
bool Database::GetWorldRegistration(unsigned int &id, std::string &desc, unsigned int &trusted, unsigned int &list_id,
std::string &account, std::string &password, std::string long_name, std::string short_name)
{
char escaped_short_name[101];
DoEscapeString(escaped_short_name, short_name.substr(0, 100).c_str(), (int)strlen(short_name.substr(0, 100).c_str()));
std::string query;
query = StringFormat("SELECT "
"ServerID, ServerTagDescription, ServerTrusted, ServerListTypeID, ServerAdminID "
"FROM %s WHERE ServerShortName = '%s'",
LoadServerSettings("schema", "world_registration_table").c_str(),
escaped_short_name
);
auto results = QueryDatabase(query);
if (!results.Success())
{
server_log->Log(log_database_error, "Mysql query failed: %s", query.c_str());
return false;
}
auto row = results.begin();
if (results.RowCount() > 0)
{
id = atoi(row[0]);
desc = row[1];
trusted = atoi(row[2]);
list_id = atoi(row[3]);
int db_account_id = atoi(row[5]);
if (db_account_id > 0)
{
std::string query;
query = StringFormat("SELECT AccountName, AccountPassword "
"FROM %s WHERE ServerAdminID = %s",
LoadServerSettings("schema", "world_admin_registration_table").c_str(),
std::to_string(db_account_id).c_str()
);
auto results = QueryDatabase(query);
if (!results.Success())
{
server_log->Log(log_database_error, "Mysql query failed: %s", query.c_str());
return false;
}
auto row = results.begin();
if (results.RowCount() > 0)
{
account = row[0];
password = row[1];
return true;
}
server_log->Log(log_database_trace, "Mysql query returned no result: %s", query.c_str());
return false;
}
return true;
}
server_log->Log(log_database_error, "Mysql query returned no result: %s", query.c_str());
return false;
}
bool Database::CreateServerSettings()
{
std::string query;
std::string query2;
server_log->Log(log_database_trace, "Entering Server Settings database setup.");
query = StringFormat("SHOW TABLES LIKE 'tblloginserversettings'");
auto results = QueryDatabase(query);
if (!results.Success())
{
server_log->Log(log_database_error, "CreateServerSettings Mysql query failed to search for table: %s", query.c_str());
return false;
}
server_log->Log(log_database, "CreateServerSettings: table does not exist, creating: %s", query.c_str());
if (results.RowCount() <= 0)
{
server_log->Log(log_database, "Server Settings table does not exist, creating.");
query = StringFormat(
"CREATE TABLE `tblloginserversettings` ("
"`type` varchar(50) NOT NULL,"
"`value` varchar(50),"
"`category` varchar(20) NOT NULL,"
"`description` varchar(99) NOT NULL,"
"`defaults` varchar(50)"
") ENGINE=InnoDB DEFAULT CHARSET=latin1");
auto results = QueryDatabase(query);
if (!results.Success())
{
server_log->Log(log_database_error, "CreateServerSettings Mysql query failed to create table: %s", query.c_str());
return false;
}
query2 = StringFormat(
"INSERT INTO `tblloginserversettings` (type, value, category, description, defaults)"
"VALUES"
"('access_log_table', '', 'schema', 'location for access logs, failed logins and goodIP.', 'tblaccountaccesslog'),"
"('account_table', '', 'schema', 'location of all client account info for login server only.', 'tblLoginServerAccounts'),"
"('auto_account_activate', '', 'options', 'set this to TRUE to allow new accounts to log in.', 'TRUE'),"
"('auto_account_create', '', 'options', 'set this to TRUE to auto create accounts on player first log in.', 'TRUE'),"
"('port', '', 'Old', 'port for clients to connect to.', '6000'),"
"('dump_packets_in', '', 'options', 'debugging', 'FALSE'),"
"('dump_packets_out', '', 'options', 'debugging', 'FALSE'),"
"('failed_login_log', '', 'options', 'set this to TRUE to log failed log in attempts.', 'TRUE'),"
"('good_loginIP_log', '', 'options', 'set this to TRUE to log successful account log ins.', 'TRUE'),"
"('listen_port', '', 'options', 'this is the port we listen on for world connection.', '5998'),"
"('local_network', '', 'options', 'set to the network ip that world server is on.', '127.0.0.1'),"
"('mode', '', 'security', 'encryption mode the plugin uses.', '5'),"
"('network_ip', '', 'options', 'set to the network ip that world server is on.', '127.0.0.1'),"
"('opcodes', '', 'Old', 'opcode file for client compatibility. (Old means classic/mac)', 'login_opcodes_oldver.conf'),"
"('plugin', '', 'security', 'the encryption type the login server uses.', 'EQEmuAuthCrypto'),"
"('pop_count', '', 'options', '0 to only display UP or DOWN or 1 to show population count in server select.', '0'),"
"('reject_duplicate_servers', '', 'options', 'set this to TRUE to force unique server name connections.', 'TRUE'),"
"('salt', '', 'options', 'for account security make this a numeric random number.', '12345678'),"
"('ticker', '', 'options', 'Sets the welcome message in server select.', 'Welcome to EQMacEmu'),"
"('trace', '', 'options', 'debugging', 'FALSE'),"
"('unregistered_allowed', '', 'options', 'set this to TRUE to allow any server to connect.', 'TRUE'),"
"('world_admin_registration_table', '', 'schema', 'location of administrator account info for this login server.', 'tblServerAdminRegistration'),"
"('world_registration_table', '', 'schema', 'location of registered or connection records of servers connecting to this loginserver.', 'tblWorldServerRegistration'),"
"('world_server_type_table', '', 'schema', 'location of server type descriptions.', 'tblServerListType'),"
"('world_trace', '', 'options', 'debugging', 'FALSE');");
auto results2 = QueryDatabase(query2);
if (!results2.Success())
{
server_log->Log(log_database_error, "CreateServerSettings Mysql query failed: %s", query2.c_str());
return false;
}
// type, category, default
bool failed = false;
failed |= !SetServerSettings("access_log_table", "schema", "tblaccountaccesslog");
failed |= !SetServerSettings("account_table", "schema", "tblLoginServerAccounts");
failed |= !SetServerSettings("auto_account_activate", "options", "TRUE");
failed |= !SetServerSettings("auto_account_create", "options", "TRUE");
failed |= !SetServerSettings("port", "Old", "6000");
failed |= !SetServerSettings("dump_packets_in", "options", "FALSE");
failed |= !SetServerSettings("dump_packets_out", "options", "FALSE");
failed |= !SetServerSettings("failed_login_log", "options", "TRUE");
failed |= !SetServerSettings("good_loginIP_log", "options", "TRUE");
failed |= !SetServerSettings("listen_port", "options", "5998");
failed |= !SetServerSettings("local_network", "options", "127.0.0.1");
failed |= !SetServerSettings("mode", "security", "5");
failed |= !SetServerSettings("network_ip", "options", "127.0.0.1");
failed |= !SetServerSettings("opcodes", "Old", "login_opcodes_oldver.conf");
failed |= !SetServerSettings("plugin", "security", "EQEmuAuthCrypto");
failed |= !SetServerSettings("pop_count", "options", "0");
failed |= !SetServerSettings("reject_duplicate_servers", "options", "TRUE");
failed |= !SetServerSettings("salt", "options", "12345678");
failed |= !SetServerSettings("ticker", "options", "Welcome to EQMacEmu");
failed |= !SetServerSettings("trace", "options", "FALSE");
failed |= !SetServerSettings("unregistered_allowed", "options", "TRUE");
failed |= !SetServerSettings("world_admin_registration_table", "schema", "tblServerAdminRegistration");
failed |= !SetServerSettings("world_registration_table", "schema", "tblWorldServerRegistration");
failed |= !SetServerSettings("world_server_type_table", "schema", "tblServerListType");
failed |= !SetServerSettings("world_trace", "options", "FALSE");
if (failed)
{
return false;
}
server_log->Log(log_database_trace, "Server Settings table created, continuing.");
}
else
{
server_log->Log(log_database_trace, "CreateServerSettings found existing settings, continuing on.");
}
if (GetServerSettings())
{
return true;
}
return false;
}
void DelayProcess::VUpdate(unsigned int elapsedTime)
{
m_timeDelayed += elapsedTime;
if(m_timeDelayed >= m_timeToDelay)
Success();
}
bool SpawnConditionManager::LoadSpawnConditions(const char* zone_name, uint32 instance_id)
{
//clear out old stuff..
spawn_conditions.clear();
std::string query = StringFormat("SELECT id, onchange, value "
"FROM spawn_conditions "
"WHERE zone = '%s'", zone_name);
auto results = database.QueryDatabase(query);
if (!results.Success()) {
return false;
}
for (auto row = results.begin(); row != results.end(); ++row) {
//load spawn conditions
SpawnCondition cond;
cond.condition_id = atoi(row[0]);
cond.value = atoi(row[2]);
cond.on_change = (SpawnCondition::OnChange) atoi(row[1]);
spawn_conditions[cond.condition_id] = cond;
Log(Logs::Detail, Logs::Spawns, "Loaded spawn condition %d with value %d and on_change %d", cond.condition_id, cond.value, cond.on_change);
}
//load values
query = StringFormat("SELECT id, value FROM spawn_condition_values "
"WHERE zone = '%s' AND instance_id = %u",
zone_name, instance_id);
results = database.QueryDatabase(query);
if (!results.Success()) {
spawn_conditions.clear();
return false;
}
for (auto row = results.begin(); row != results.end(); ++row) {
auto iter = spawn_conditions.find(atoi(row[0]));
if(iter != spawn_conditions.end())
iter->second.value = atoi(row[1]);
}
//load spawn events
query = StringFormat("SELECT id, cond_id, period, next_minute, next_hour, "
"next_day, next_month, next_year, enabled, action, argument, strict "
"FROM spawn_events WHERE zone = '%s'", zone_name);
results = database.QueryDatabase(query);
if (!results.Success()) {
return false;
}
for (auto row = results.begin(); row != results.end(); ++row) {
SpawnEvent event;
event.id = atoi(row[0]);
event.condition_id = atoi(row[1]);
event.period = atoi(row[2]);
if(event.period == 0) {
Log(Logs::General, Logs::Error, "Refusing to load spawn event #%d because it has a period of 0\n", event.id);
continue;
}
event.next.minute = atoi(row[3]);
event.next.hour = atoi(row[4]);
event.next.day = atoi(row[5]);
event.next.month = atoi(row[6]);
event.next.year = atoi(row[7]);
event.enabled = atoi(row[8])==0?false:true;
event.action = (SpawnEvent::Action) atoi(row[9]);
event.argument = atoi(row[10]);
event.strict = atoi(row[11])==0?false:true;
spawn_events.push_back(event);
Log(Logs::Detail, Logs::Spawns, "(LoadSpawnConditions) Loaded %s spawn event %d on condition %d with period %d, action %d, argument %d, strict %d", event.enabled? "enabled": "disabled", event.id, event.condition_id, event.period, event.action, event.argument, event.strict);
}
//now we need to catch up on events that happened while we were away
//and use them to alter just the condition variables.
//each spawn2 will then use its correct condition value when
//it decides what to do. This essentially forces a 'depop' action
//on spawn points which are turned off, and a 'repop' action on
//spawn points which get turned on. Im too lazy to figure out a
//better solution, and I just dont care thats much.
//get our current time
TimeOfDay_Struct tod;
zone->zone_time.GetCurrentEQTimeOfDay(&tod);
for(auto cur = spawn_events.begin(); cur != spawn_events.end(); ++cur) {
SpawnEvent &cevent = *cur;
bool StrictCheck = false;
if(cevent.strict &&
cevent.next.hour == tod.hour &&
cevent.next.day == tod.day &&
cevent.next.month == tod.month &&
cevent.next.year == tod.year)
StrictCheck = true;
//If event is disabled, or we failed the strict check, set initial spawn_condition to 0.
if(!cevent.enabled || !StrictCheck)
SetCondition(zone->GetShortName(), zone->GetInstanceID(),cevent.condition_id,0);
if(!cevent.enabled)
continue;
//watch for special case of all 0s, which means to reset next to now
if(cevent.next.year == 0 && cevent.next.month == 0 && cevent.next.day == 0 && cevent.next.hour == 0 && cevent.next.minute == 0) {
Log(Logs::Detail, Logs::Spawns, "Initial next trigger time set for spawn event %d", cevent.id);
memcpy(&cevent.next, &tod, sizeof(cevent.next));
//add one period
EQTime::AddMinutes(cevent.period, &cevent.next);
//save it in the db.
UpdateDBEvent(cevent);
continue; //were done with this event.
}
bool ran = false;
while(EQTime::IsTimeBefore(&tod, &cevent.next)) {
Log(Logs::Detail, Logs::Spawns, "Catch up triggering on event %d", cevent.id);
//this event has been triggered.
//execute the event
if(!cevent.strict || StrictCheck)
ExecEvent(cevent, false);
//add the period of the event to the trigger time
EQTime::AddMinutes(cevent.period, &cevent.next);
ran = true;
}
//only write it out if the event actually ran
if(ran)
UpdateDBEvent(cevent); //save the event in the DB
}
//now our event timers are all up to date, find our closest event.
FindNearestEvent();
return true;
}
bool ZoneDatabase::PopulateZoneSpawnList(uint32 zoneid, LinkedList<Spawn2*> &spawn2_list, int16 version, uint32 repopdelay) {
std::unordered_map<uint32, uint32> spawn_times;
timeval tv;
gettimeofday(&tv, nullptr);
/* Bulk Load NPC Types Data into the cache */
database.LoadNPCTypesData(0, true);
std::string spawn_query = StringFormat(
"SELECT "
"respawn_times.id, "
"respawn_times.`start`, "
"respawn_times.duration "
"FROM "
"respawn_times "
"WHERE instance_id = %u",
zone->GetInstanceID()
);
auto results = QueryDatabase(spawn_query);
for (auto row = results.begin(); row != results.end(); ++row) {
uint32 start_duration = atoi(row[1]) > 0 ? atoi(row[1]) : 0;
uint32 end_duration = atoi(row[2]) > 0 ? atoi(row[2]) : 0;
/* Our current time was expired */
if ((start_duration + end_duration) <= tv.tv_sec) {
spawn_times[atoi(row[0])] = 0;
}
/* We still have time left on this timer */
else {
spawn_times[atoi(row[0])] = ((start_duration + end_duration) - tv.tv_sec) * 1000;
}
}
const char *zone_name = database.GetZoneName(zoneid);
std::string query = StringFormat(
"SELECT "
"id, "
"spawngroupID, "
"x, "
"y, "
"z, "
"heading, "
"respawntime, "
"variance, "
"pathgrid, "
"_condition, "
"cond_value, "
"enabled, "
"animation "
"FROM "
"spawn2 "
"WHERE zone = '%s' AND (version = %u OR version = -1)",
zone_name,
version
);
results = QueryDatabase(query);
if (!results.Success()) {
return false;
}
for (auto row = results.begin(); row != results.end(); ++row) {
uint32 spawn_time_left = 0;
Spawn2* new_spawn = 0;
bool perl_enabled = atoi(row[11]) == 1 ? true : false;
if (spawn_times.count(atoi(row[0])) != 0)
spawn_time_left = spawn_times[atoi(row[0])];
new_spawn = new Spawn2( //
atoi(row[0]), // uint32 in_spawn2_id
atoi(row[1]), // uint32 spawngroup_id
atof(row[2]), // float in_x
atof(row[3]), // float in_y
atof(row[4]), // float in_z
atof(row[5]), // float in_heading
atoi(row[6]), // uint32 respawn
atoi(row[7]), // uint32 variance
spawn_time_left, // uint32 timeleft
atoi(row[8]), // uint32 grid
atoi(row[9]), // uint16 in_cond_id
atoi(row[10]), // int16 in_min_value
perl_enabled, // bool in_enabled
(EmuAppearance)atoi(row[12]) // EmuAppearance anim
);
spawn2_list.Insert(new_spawn);
}
NPC::SpawnZoneController();
return true;
}
bool Generator::Process()
{
if (GetDuration() < 0.0)
return false;
// Set up mOutputTracks.
// This effect needs Track::All for sync-lock grouping.
this->CopyInputTracks(Track::All);
// Iterate over the tracks
bool bGoodResult = true;
int ntrack = 0;
TrackListIterator iter(mOutputTracks);
Track* t = iter.First();
while (t != NULL)
{
if (t->GetKind() == Track::Wave && t->GetSelected()) {
WaveTrack* track = (WaveTrack*)t;
bool editClipCanMove;
gPrefs->Read(wxT("/GUI/EditClipCanMove"), &editClipCanMove, true);
//if we can't move clips, and we're generating into an empty space,
//make sure there's room.
if (!editClipCanMove &&
track->IsEmpty(mT0, mT1+1.0/track->GetRate()) &&
!track->IsEmpty(mT0, mT0+GetDuration()-(mT1-mT0)-1.0/track->GetRate()))
{
wxMessageBox(
_("There is not enough room available to generate the audio"),
_("Error"), wxICON_STOP);
Failure();
return false;
}
if (GetDuration() > 0.0)
{
AudacityProject *p = GetActiveProject();
// Create a temporary track
std::unique_ptr<WaveTrack> tmp(
mFactory->NewWaveTrack(track->GetSampleFormat(),
track->GetRate())
);
BeforeTrack(*track);
BeforeGenerate();
// Fill it with data
if (!GenerateTrack(&*tmp, *track, ntrack))
bGoodResult = false;
else {
// Transfer the data from the temporary track to the actual one
tmp->Flush();
SetTimeWarper(new StepTimeWarper(mT0+GetDuration(), GetDuration()-(mT1-mT0)));
bGoodResult = track->ClearAndPaste(p->GetSel0(), p->GetSel1(), &*tmp, true,
false, GetTimeWarper());
}
if (!bGoodResult) {
Failure();
return false;
}
}
else
{
// If the duration is zero, there's no need to actually
// generate anything
track->Clear(mT0, mT1);
}
ntrack++;
}
else if (t->IsSyncLockSelected()) {
t->SyncLockAdjust(mT1, mT0 + GetDuration());
}
// Move on to the next track
t = iter.Next();
}
Success();
this->ReplaceProcessedTracks(bGoodResult);
mT1 = mT0 + GetDuration(); // Update selection.
return true;
}
//------------------------- Processing methods -------------------------
bool EffectSineSweepGenerator::Process()
{
// taken `as is` from Audacity`s Generator.cpp to resolve
// a vc++ linking problem...
if (mDuration < 0.0)
return false;
BeforeGenerate();
// Set up mOutputTracks. This effect needs Track::All for grouping
this->CopyInputTracks(Track::All);
// Iterate over the tracks
bool bGoodResult = true;
int ntrack = 0;
TrackListIterator iter(mOutputTracks);
Track* t = iter.First();
while (t != NULL)
{
if (t->GetKind() == Track::Wave && t->GetSelected())
{
WaveTrack* track = (WaveTrack*)t;
bool editClipCanMove = true;
//gPrefs->Read(wxT("/GUI/EditClipCanMove"), &editClipCanMove, true);
//if we can't move clips, and we're generating into an empty space,
//make sure there's room.
if (!editClipCanMove &&
track->IsEmpty(mT0, mT1+1.0/track->GetRate()) &&
!track->IsEmpty(mT0, mT0+mDuration-(mT1-mT0)-1.0/track->GetRate()))
{
wxMessageBox(_("There is not enough room available to generate the audio"),
_("Error"), wxICON_STOP);
Failure();
return false;
}
if (mDuration > 0.0)
{
// Create a temporary track
WaveTrack *tmp = mFactory->NewWaveTrack(track->GetSampleFormat(),
track->GetRate());
//BeforeTrack(*track);
// Fill it with data
if (!GenerateTrack(tmp, *track, ntrack))
bGoodResult = false;
else
{
// Transfer the data from the temporary track to the actual one
tmp->Flush();
SetTimeWarper(new AFStepTimeWarper(mT0+mDuration, mDuration-(mT1-mT0)));
bGoodResult = track->ClearAndPaste(mT0, mT1, tmp, true,
false, GetTimeWarper());
delete tmp;
}
if (!bGoodResult)
{
Failure();
return false;
}
}
else
{
// If the duration is zero, there's no need to actually
// generate anything
track->Clear(mT0, mT1);
}
ntrack++;
}
else if (t->IsSyncLockSelected())
{
t->SyncLockAdjust(mT1, mT0 + mDuration);
}
// Move on to the next track
t = iter.Next();
}
Success();
this->ReplaceProcessedTracks(bGoodResult);
mT1 = mT0 + mDuration; // Update selection.
return true;
}
Error getCppCompletions(const core::json::JsonRpcRequest& request,
core::json::JsonRpcResponse* pResponse)
{
// get params
std::string docPath, userText;
int line, column;
Error error = json::readParams(request.params,
&docPath,
&line,
&column,
&userText);
if (error)
return error;
// resolve the docPath if it's aliased
FilePath filePath = module_context::resolveAliasedPath(docPath);
// get the translation unit and do the code completion
std::string filename = filePath.absolutePath();
TranslationUnit tu = rSourceIndex().getTranslationUnit(filename);
if (!tu.empty())
{
std::string lastTypedText;
json::Array completionsJson;
boost::shared_ptr<CodeCompleteResults> pResults =
tu.codeCompleteAt(filename, line, column);
if (!pResults->empty())
{
// get results
for (unsigned i = 0; i<pResults->getNumResults(); i++)
{
CodeCompleteResult result = pResults->getResult(i);
// filter on user text if we have it
if (!userText.empty() &&
!boost::algorithm::starts_with(result.getTypedText(), userText))
{
continue;
}
// check whether this completion is valid and bail if not
if (result.getAvailability() != CXAvailability_Available)
{
continue;
}
std::string typedText = result.getTypedText();
// if we have the same typed text then just ammend previous result
if ((typedText == lastTypedText) && !completionsJson.empty())
{
json::Object& res = completionsJson.back().get_obj();
json::Array& text = res["text"].get_array();
text.push_back(friendlyCompletionText(result));
}
else
{
completionsJson.push_back(toJson(result));
}
lastTypedText = typedText;
}
}
json::Object resultJson;
resultJson["completions"] = completionsJson;
pResponse->setResult(resultJson);
}
else
{
// set null result indicating this file doesn't support completions
pResponse->setResult(json::Value());
}
return Success();
}
bool ZoneDatabase::LoadDoors(int32 door_count, Door *into, const char *zone_name, int16 version) {
Log(Logs::General, Logs::Status, "Loading Doors from database...");
std::string query = StringFormat(
" SELECT "
" id, "
" doorid, "
" zone, "
" NAME, "
" pos_x, "
" pos_y, "
" pos_z, "
" heading, "
" opentype, "
" guild, "
" lockpick, "
" keyitem, "
" nokeyring, "
" triggerdoor, "
" triggertype, "
" dest_zone, "
" dest_instance, "
" dest_x, "
" dest_y, "
" dest_z, "
" dest_heading, "
" door_param, "
" invert_state, "
" incline, "
" size, "
" is_ldon_door, "
" client_version_mask, "
" disable_timer "
" FROM "
" doors "
" WHERE "
" zone = '%s' "
" AND ( version = % u OR version = - 1 ) "
" ORDER BY "
" doorid ASC ",
zone_name,
version
);
auto results = QueryDatabase(query);
if (!results.Success()) {
return false;
}
int32 row_index = 0;
for (auto row = results.begin(); row != results.end(); ++row, ++row_index) {
if (row_index >= door_count) {
std::cerr << "Error, Door Count of " << door_count << " exceeded." << std::endl;
break;
}
memset(&into[row_index], 0, sizeof(Door));
strn0cpy(into[row_index].zone_name, row[2], 32);
strn0cpy(into[row_index].door_name, row[3], 32);
strn0cpy(into[row_index].dest_zone, row[15], 32);
into[row_index].db_id = static_cast<uint32>(atoi(row[0]));
into[row_index].door_id = static_cast<uint8>(atoi(row[1]));
into[row_index].pos_x = (float) atof(row[4]);
into[row_index].pos_y = (float) atof(row[5]);
into[row_index].pos_z = (float) atof(row[6]);
into[row_index].heading = (float) atof(row[7]);
into[row_index].opentype = static_cast<uint8>(atoi(row[8]));
into[row_index].guild_id = static_cast<uint32>(atoi(row[9]));
into[row_index].lock_pick = static_cast<uint16>(atoi(row[10]));
into[row_index].keyitem = static_cast<uint32>(atoi(row[11]));
into[row_index].nokeyring = static_cast<uint8>(atoi(row[12]));
into[row_index].trigger_door = static_cast<uint8>(atoi(row[13]));
into[row_index].trigger_type = static_cast<uint8>(atoi(row[14]));
into[row_index].dest_instance_id = static_cast<uint32>(atoi(row[16]));
into[row_index].dest_x = (float) atof(row[17]);
into[row_index].dest_y = (float) atof(row[18]);
into[row_index].dest_z = (float) atof(row[19]);
into[row_index].dest_heading = (float) atof(row[20]);
into[row_index].door_param = static_cast<uint32>(atoi(row[21]));
into[row_index].invert_state = atoi(row[22]);
into[row_index].incline = atoi(row[23]);
into[row_index].size = static_cast<uint16>(atoi(row[24]));
into[row_index].is_ldon_door = static_cast<uint8>(atoi(row[25]));
into[row_index].client_version_mask = (uint32) strtoul(row[26], nullptr, 10);
into[row_index].disable_timer = static_cast<uint8>(atoi(row[27]));
Log(Logs::Detail, Logs::Doors, "Door Load: db id: %u, door_id %u disable_timer: %i",
into[row_index].db_id,
into[row_index].door_id,
into[row_index].disable_timer
);
}
return true;
}
void CommandBuilder::BuildCommand(const wxString &cmdName,
const wxString &cmdParamsArg)
{
// Stage 1: create a Command object of the right type
auto scriptOutput = ScriptCommandRelay::GetResponseTarget();
auto output
= std::make_unique<CommandOutputTargets>(std::make_unique<NullProgressTarget>(),
scriptOutput,
scriptOutput);
#ifdef OLD_BATCH_SYSTEM
OldStyleCommandType *factory = CommandDirectory::Get()->LookUp(cmdName);
if (factory == NULL)
{
// Fall back to hoping the Batch Command system can handle it
#endif
OldStyleCommandType *type = CommandDirectory::Get()->LookUp(wxT("BatchCommand"));
wxASSERT(type != NULL);
mCommand = type->Create(nullptr);
mCommand->SetParameter(wxT("CommandName"), cmdName);
mCommand->SetParameter(wxT("ParamString"), cmdParamsArg);
auto aCommand = std::make_shared<ApplyAndSendResponse>(mCommand, output);
Success(aCommand);
return;
#ifdef OLD_BATCH_SYSTEM
}
CommandSignature &signature = factory->GetSignature();
mCommand = factory->Create(nullptr);
//mCommand->SetOutput( std::move(output) );
// Stage 2: set the parameters
ShuttleCli shuttle;
shuttle.mParams = cmdParamsArg;
shuttle.mbStoreInClient = true;
ParamValueMap::const_iterator iter;
ParamValueMap params = signature.GetDefaults();
// Iterate through the parameters defined by the command
for (iter = params.begin(); iter != params.end(); ++iter)
{
wxString paramString;
// IF there is a match in the args actually used
if (shuttle.TransferString(iter->first, paramString, wxT("")))
{
// Then set that parameter.
if (!mCommand->SetParameter(iter->first, paramString))
{
Failure();
return;
}
}
}
// Check for unrecognised parameters
wxString cmdParams(cmdParamsArg);
while (!cmdParams.empty())
{
cmdParams.Trim(true);
cmdParams.Trim(false);
int splitAt = cmdParams.Find(wxT('='));
if (splitAt < 0 && !cmdParams.empty())
{
Failure(wxT("Parameter string is missing '='"));
return;
}
wxString paramName = cmdParams.Left(splitAt);
if (params.find(paramName) == params.end())
{
Failure(wxT("Unrecognized parameter: '") + paramName + wxT("'"));
return;
}
// Handling of quoted strings is quite limitted.
// You start and end with a " or a '.
// There is no escaping in the string.
cmdParams = cmdParams.Mid(splitAt+1);
if( cmdParams.empty() )
splitAt =-1;
else if( cmdParams[0] == '\"' ){
cmdParams = cmdParams.Mid(1);
splitAt = cmdParams.Find(wxT('\"'))+1;
}
else if( cmdParams[0] == '\'' ){
cmdParams = cmdParams.Mid(1);
splitAt = cmdParams.Find(wxT('\''))+1;
}
else
splitAt = cmdParams.Find(wxT(' '))+1;
if (splitAt < 1)
{
splitAt = cmdParams.length();
}
cmdParams = cmdParams.Mid(splitAt);
}
auto aCommand = std::make_shared<ApplyAndSendResponse>(mCommand, output);
Success(aCommand);
#endif
}
Error parseDcfFile(const FilePath& dcfFilePath,
bool preserveKeyCase,
std::map<std::string,std::string>* pFields,
std::string* pUserErrMsg)
{
// read the file
std::string dcfFileContents;
Error error = readStringFromFile(dcfFilePath,
&dcfFileContents);
if (error)
{
error.addProperty("dcf-file", dcfFilePath.absolutePath());
*pUserErrMsg = error.summary();
return error;
}
// split into lines
std::vector<std::string> dcfLines;
boost::algorithm::split(dcfLines,
dcfFileContents,
boost::algorithm::is_any_of("\r\n"));
// iterate over lines
int lineNumber = 0;
std::string currentKey;
std::string currentValue;
for(std::vector<std::string>::const_iterator it = dcfLines.begin();
it != dcfLines.end();
++it)
{
lineNumber++;
// skip blank lines
if (it->empty() || boost::algorithm::trim_copy(*it).empty())
continue;
// skip comment lines
if (it->at(0) == '#')
continue;
// define regexes
boost::regex keyValueRegx("([^\\s]+?)\\s*\\:\\s*(.*)$");
boost::regex continuationRegex("[\t\\s](.*)");
// look for a key-value pair line
boost::smatch keyValueMatch, continuationMatch;
if (regex_match(*it, keyValueMatch, keyValueRegx))
{
// if we have a pending key & value then resolve it
if (!currentKey.empty())
{
pFields->insert(std::make_pair(currentKey,currentValue));
currentKey.clear();
currentValue.clear();
}
// update the current key and value
currentKey = preserveKeyCase ?
keyValueMatch[1] :
string_utils::toLower(keyValueMatch[1]);
currentValue = keyValueMatch[2];
}
// look for a continuation
else if (!currentKey.empty() &&
regex_match(*it, continuationMatch, continuationRegex))
{
currentValue.append("\n");
currentValue.append(continuationMatch[1]);
}
// invalid line
else
{
Error error = systemError(boost::system::errc::protocol_error,
ERROR_LOCATION);
boost::format fmt("file line number %1% is invalid");
*pUserErrMsg = boost::str(fmt % lineNumber);
error.addProperty("parse-error", *pUserErrMsg);
error.addProperty("line-contents", *it);
return error;
}
}
// resolve any pending key and value
if (!currentKey.empty())
pFields->insert(std::make_pair(currentKey,currentValue));
return Success();
}
Error initialize()
{
loadLearningState();
return Success();
}
virtual Error cleanup()
{
return Success();
}
Error completeEmbeddedRInitialization()
{
return Success();
}
Bool BonkEnc::CDDBBatch::ReadEntries()
{
String inputFormat = String::SetInputFormat("UTF-8");
String outputFormat = String::SetOutputFormat("UTF-8");
// Read saved queries from XML
XML::Document *document = new XML::Document();
if (document->LoadFile(String(config->configDir).Append("cddb\\queries.xml")) == Success())
{
XML::Node *root = document->GetRootNode();
if (root != NIL)
{
for (Int i = 0; i < root->GetNOfNodes(); i++)
{
XML::Node *node = root->GetNthNode(i);
if (node->GetName() == "query") queries.Add(node->GetContent());
}
}
}
delete document;
// Read saved submits from XML and database cache
document = new XML::Document();
if (document->LoadFile(String(config->configDir).Append("cddb\\submits.xml")) == Success())
{
XML::Node *root = document->GetRootNode();
if (root != NIL)
{
for (Int i = 0; i < root->GetNOfNodes(); i++)
{
XML::Node *node = root->GetNthNode(i);
if (node->GetName() == "submit")
{
InStream *in = new InStream(STREAM_FILE, String(config->configDir).Append("cddb\\").Append(node->GetAttributeByName("category")->GetContent()).Append("\\").Append(node->GetContent()), IS_READONLY);
if (in->Size() > 0)
{
String result = in->InputString(in->Size());
CDDBInfo cddbInfo;
ParseCDDBRecord(result, cddbInfo);
cddbInfo.category = node->GetAttributeByName("category")->GetContent();
for (Int i = 0; i < submits.Length(); i++)
{
if (submits.GetNth(i) == cddbInfo)
{
submits.Remove(submits.GetNthIndex(i));
break;
}
}
submits.Add(cddbInfo);
}
delete in;
}
}
}
}
delete document;
String::SetInputFormat(inputFormat);
String::SetOutputFormat(outputFormat);
return True;
}
