From fa872c6030e788c38282b878da55dfad56ab5171 Mon Sep 17 00:00:00 2001 From: Akkadius Date: Sat, 12 Dec 2015 00:37:31 -0600 Subject: [PATCH] Some rule code cleanup --- common/rulesys.cpp | 297 +++++++++++++++++++-------------------------- 1 file changed, 127 insertions(+), 170 deletions(-) diff --git a/common/rulesys.cpp b/common/rulesys.cpp index a53dbcabe..13e342fe5 100644 --- a/common/rulesys.cpp +++ b/common/rulesys.cpp @@ -17,43 +17,14 @@ */ #include "rulesys.h" - #include "database.h" #include "string_util.h" #include #include /* - - FatherNitwit: Added new rules subsystem to allow game rules to be changed - at runtime. more about this will come as time goes on. -FatherNitwit: Added #rules command to manage rules data from in game. -FatherNitwit: Renamed old #rules to #serverrules -FatherNitwit: Moved max level into the rules system (Character:MaxLevel) -Requred SQL: - - - -CREATE TABLE rule_sets ( - ruleset_id TINYINT UNSIGNED NOT NULL auto_increment, - name VARCHAR(255) NOT NULL, - PRIMARY KEY(ruleset_id) -); -INSERT INTO rule_sets VALUES(0, "default"); -UPDATE rule_sets SET ruleset_id=0; - -CREATE TABLE rule_values ( - ruleset_id TINYINT UNSIGNED NOT NULL, - rule_name VARCHAR(64) NOT NULL, - rule_value VARCHAR(10) NOT NULL, - INDEX(ruleset_id), - PRIMARY KEY(ruleset_id,rule_name) -); - - - -Commands: -#rules: + Commands: + #rules: current -> lists current set name switch (set name) -> change set in the DB, but dont reload load (set name) -> load set into this zone without changing the world @@ -94,28 +65,28 @@ RuleManager::RuleManager() } RuleManager::CategoryType RuleManager::FindCategory(const char *catname) { - int r; - for(r = 0; r < _CatCount; r++) { - if(strcasecmp(catname, s_categoryNames[r]) == 0) - return((CategoryType) r); + int i; + for (i = 0; i < _CatCount; i++) { + if (strcasecmp(catname, s_categoryNames[i]) == 0) + return((CategoryType)i); } return(InvalidCategory); } bool RuleManager::ListRules(const char *catname, std::vector &into) { CategoryType cat = InvalidCategory; - if(catname != nullptr) { + if (catname != nullptr) { cat = FindCategory(catname); - if(cat == InvalidCategory) { + if (cat == InvalidCategory) { Log.Out(Logs::Detail, Logs::Rules, "Unable to find category '%s'", catname); return(false); } } - int r; - int rcount = CountRules(); - for(r = 0; r < rcount; r++) { - const RuleInfo &rule = s_RuleInfo[r]; - if(catname == nullptr || cat == rule.category) { + int i; + int rule_count = CountRules(); + for (i = 0; i < rule_count; i++) { + const RuleInfo &rule = s_RuleInfo[i]; + if (catname == nullptr || cat == rule.category) { into.push_back(rule.name); } } @@ -123,15 +94,14 @@ bool RuleManager::ListRules(const char *catname, std::vector &into } bool RuleManager::ListCategories(std::vector &into) { - int r; - for(r = 0; r < _CatCount; r++) { - into.push_back(s_categoryNames[r]); + int i; + for (i = 0; i < _CatCount; i++) { + into.push_back(s_categoryNames[i]); } return(true); } - -bool RuleManager::GetRule(const char *rule_name, std::string &ret_val) { +bool RuleManager::GetRule(const char *rule_name, std::string &return_value) { RuleType type; uint16 index; if (!_FindRule(rule_name, type, index)) @@ -151,12 +121,12 @@ bool RuleManager::GetRule(const char *rule_name, std::string &ret_val) { break; } - ret_val = tmp; + return_value = tmp; return true; } -bool RuleManager::SetRule(const char *rule_name, const char *rule_value, Database *db, bool db_save) { +bool RuleManager::SetRule(const char *rule_name, const char *rule_value, Database *database, bool db_save) { if(rule_name == nullptr || rule_value == nullptr) return(false); @@ -166,25 +136,26 @@ bool RuleManager::SetRule(const char *rule_name, const char *rule_value, Databas return(false); switch(type) { - case IntRule: - m_RuleIntValues [index] = atoi(rule_value); - Log.Out(Logs::Detail, Logs::Rules, "Set rule %s to value %d", rule_name, m_RuleIntValues[index]); - break; - case RealRule: - m_RuleRealValues[index] = atof(rule_value); - Log.Out(Logs::Detail, Logs::Rules, "Set rule %s to value %.13f", rule_name, m_RuleRealValues[index]); - break; - case BoolRule: - uint32 val = 0; - if(!strcasecmp(rule_value, "on") || !strcasecmp(rule_value, "true") || !strcasecmp(rule_value, "yes") || !strcasecmp(rule_value, "enabled") || !strcmp(rule_value, "1")) - val = 1; - m_RuleBoolValues[index] = val; - Log.Out(Logs::Detail, Logs::Rules, "Set rule %s to value %s", rule_name, m_RuleBoolValues[index] == 1 ?"true":"false"); - break; + case IntRule: + m_RuleIntValues[index] = atoi(rule_value); + Log.Out(Logs::Detail, Logs::Rules, "Set rule %s to value %d", rule_name, m_RuleIntValues[index]); + break; + case RealRule: + m_RuleRealValues[index] = atof(rule_value); + Log.Out(Logs::Detail, Logs::Rules, "Set rule %s to value %.13f", rule_name, m_RuleRealValues[index]); + break; + case BoolRule: + uint32 val = 0; + if (!strcasecmp(rule_value, "on") || !strcasecmp(rule_value, "true") || !strcasecmp(rule_value, "yes") || !strcasecmp(rule_value, "enabled") || !strcmp(rule_value, "1")) + val = 1; + + m_RuleBoolValues[index] = val; + Log.Out(Logs::Detail, Logs::Rules, "Set rule %s to value %s", rule_name, m_RuleBoolValues[index] == 1 ? "true" : "false"); + break; } if(db_save) - _SaveRule(db, type, index); + _SaveRule(database, type, index); return(true); } @@ -201,14 +172,14 @@ void RuleManager::ResetRules() { } bool RuleManager::_FindRule(const char *rule_name, RuleType &type_into, uint16 &index_into) { - if(rule_name == nullptr) + if (rule_name == nullptr) return(false); - int r; - int rcount = CountRules(); - for(r = 0; r < rcount; r++) { - const RuleInfo &rule = s_RuleInfo[r]; - if(strcmp(rule_name, rule.name) == 0) { + int i; + int rule_count = CountRules(); + for (i = 0; i < rule_count; i++) { + const RuleInfo &rule = s_RuleInfo[i]; + if (strcmp(rule_name, rule.name) == 0) { type_into = rule.type; index_into = rule.rule_index; return(true); @@ -220,191 +191,177 @@ bool RuleManager::_FindRule(const char *rule_name, RuleType &type_into, uint16 & //assumes index is valid! const char *RuleManager::_GetRuleName(RuleType type, uint16 index) { - switch(type) { - case IntRule: - return(s_RuleInfo[index].name); - case RealRule: - return(s_RuleInfo[index+_IntRuleCount].name); - case BoolRule: - return(s_RuleInfo[index+_IntRuleCount+_RealRuleCount].name); + switch (type) { + case IntRule: + return(s_RuleInfo[index].name); + case RealRule: + return(s_RuleInfo[index + _IntRuleCount].name); + case BoolRule: + return(s_RuleInfo[index + _IntRuleCount + _RealRuleCount].name); } //should never happen return("InvalidRule??"); } -void RuleManager::SaveRules(Database *db, const char *ruleset) { +void RuleManager::SaveRules(Database *database, const char *ruleset_name) { - if(ruleset != nullptr) { + if (ruleset_name != nullptr) { //saving to a specific name - if(m_activeName != ruleset) { + if (m_activeName != ruleset_name) { //a new name... - m_activeRuleset = _FindOrCreateRuleset(db, ruleset); - if(m_activeRuleset == -1) { - Log.Out(Logs::Detail, Logs::Rules, "Unable to find or create rule set %s", ruleset); + m_activeRuleset = _FindOrCreateRuleset(database, ruleset_name); + if (m_activeRuleset == -1) { + Log.Out(Logs::Detail, Logs::Rules, "Unable to find or create rule set %s", ruleset_name); return; } - m_activeName = ruleset; + m_activeName = ruleset_name; } - Log.Out(Logs::Detail, Logs::Rules, "Saving running rules into rule set %s (%d)", ruleset, m_activeRuleset); - } else { + Log.Out(Logs::Detail, Logs::Rules, "Saving running rules into rule set %s (%d)", ruleset_name, m_activeRuleset); + } + else { Log.Out(Logs::Detail, Logs::Rules, "Saving running rules into running rule set %s", m_activeName.c_str(), m_activeRuleset); } - int r; - for(r = 0; r < _IntRuleCount; r++) { - _SaveRule(db, IntRule, r); + int i; + for (i = 0; i < _IntRuleCount; i++) { + _SaveRule(database, IntRule, i); } - for(r = 0; r < _RealRuleCount; r++) { - _SaveRule(db, RealRule, r); + for (i = 0; i < _RealRuleCount; i++) { + _SaveRule(database, RealRule, i); } - for(r = 0; r < _BoolRuleCount; r++) { - _SaveRule(db, BoolRule, r); + for (i = 0; i < _BoolRuleCount; i++) { + _SaveRule(database, BoolRule, i); } } +bool RuleManager::LoadRules(Database *database, const char *ruleset_name) { - -bool RuleManager::LoadRules(Database *db, const char *ruleset) { - - int rsid = GetRulesetID(db, ruleset); - if(rsid < 0) { - Log.Out(Logs::Detail, Logs::Rules, "Failed to find ruleset '%s' for load operation. Canceling.", ruleset); + int ruleset_id = GetRulesetID(database, ruleset_name); + if (ruleset_id < 0) { + Log.Out(Logs::Detail, Logs::Rules, "Failed to find ruleset '%s' for load operation. Canceling.", ruleset_name); return(false); } - Log.Out(Logs::Detail, Logs::Rules, "Loading rule set '%s' (%d)", ruleset, rsid); + Log.Out(Logs::Detail, Logs::Rules, "Loading rule set '%s' (%d)", ruleset_name, ruleset_id); - m_activeRuleset = rsid; - m_activeName = ruleset; + m_activeRuleset = ruleset_id; + m_activeName = ruleset_name; - std::string query = StringFormat("SELECT rule_name, rule_value FROM rule_values WHERE ruleset_id=%d", rsid); - auto results = db->QueryDatabase(query); + std::string query = StringFormat("SELECT rule_name, rule_value FROM rule_values WHERE ruleset_id=%d", ruleset_id); + auto results = database->QueryDatabase(query); if (!results.Success()) - { return false; - } - for(auto row = results.begin(); row != results.end(); ++row) - if(!SetRule(row[0], row[1], nullptr, false)) - Log.Out(Logs::Detail, Logs::Rules, "Unable to interpret rule record for %s", row[0]); + for (auto row = results.begin(); row != results.end(); ++row) + if (!SetRule(row[0], row[1], nullptr, false)) + Log.Out(Logs::Detail, Logs::Rules, "Unable to interpret rule record for %s", row[0]); return true; } -void RuleManager::_SaveRule(Database *db, RuleType type, uint16 index) { - char vstr[100]; +void RuleManager::_SaveRule(Database *database, RuleType type, uint16 index) { + char value_string[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; + case IntRule: + sprintf(value_string, "%d", m_RuleIntValues[index]); + break; + case RealRule: + sprintf(value_string, "%.13f", m_RuleRealValues[index]); + break; + case BoolRule: + sprintf(value_string, "%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); + m_activeRuleset, _GetRuleName(type, index), value_string); + auto results = database->QueryDatabase(query); } -int RuleManager::GetRulesetID(Database *db, const char *rulesetname) { +int RuleManager::GetRulesetID(Database *database, const char *ruleset_name) { - uint32 len = strlen(rulesetname); - char* rst = new char[2*len+1]; - db->DoEscapeString(rst, rulesetname, len); + uint32 len = strlen(ruleset_name); + char* rst = new char[2 * len + 1]; + database->DoEscapeString(rst, ruleset_name, len); - std::string query = StringFormat("SELECT ruleset_id FROM rule_sets WHERE name='%s'", rst); - safe_delete_array(rst); - auto results = db->QueryDatabase(query); - if (!results.Success()) { - return -1; - } + std::string query = StringFormat("SELECT ruleset_id FROM rule_sets WHERE name='%s'", rst); + safe_delete_array(rst); + auto results = database->QueryDatabase(query); + if (!results.Success()) + return -1; - if (results.RowCount() == 0) - return -1; + if (results.RowCount() == 0) + return -1; - auto row = results.begin(); + auto row = results.begin(); return atoi(row[0]); } -int RuleManager::_FindOrCreateRuleset(Database *db, const char *ruleset) { +int RuleManager::_FindOrCreateRuleset(Database *database, const char *in_ruleset_name) { - int res = GetRulesetID(db, ruleset); - if(res >= 0) - return res; //found and existing one... + int ruleset_id = GetRulesetID(database, in_ruleset_name); + if (ruleset_id >= 0) + return ruleset_id; //found and existing one... - uint32 len = strlen(ruleset); - char* rst = new char[2*len+1]; - db->DoEscapeString(rst, ruleset, len); + uint32 len = strlen(in_ruleset_name); + char* ruleset_name = new char[2 * len + 1]; + database->DoEscapeString(ruleset_name, in_ruleset_name, len); - std::string query = StringFormat("INSERT INTO rule_sets (ruleset_id, name) VALUES(0, '%s')", rst); - safe_delete_array(rst); - auto results = db->QueryDatabase(query); + std::string query = StringFormat("INSERT INTO rule_sets (ruleset_id, name) VALUES(0, '%s')", ruleset_name); + safe_delete_array(ruleset_name); + auto results = database->QueryDatabase(query); if (!results.Success()) - { return -1; - } - return results.LastInsertedID(); + return results.LastInsertedID(); } -std::string RuleManager::GetRulesetName(Database *db, int id) { - - std::string query = StringFormat("SELECT name FROM rule_sets WHERE ruleset_id=%d", id); - auto results = db->QueryDatabase(query); +std::string RuleManager::GetRulesetName(Database *database, int ruleset_id) { + std::string query = StringFormat("SELECT name FROM rule_sets WHERE ruleset_id=%d", ruleset_id); + auto results = database->QueryDatabase(query); if (!results.Success()) - { - return ""; - } + return ""; if (results.RowCount() == 0) - return ""; + return ""; - auto row = results.begin(); + auto row = results.begin(); return row[0]; } -bool RuleManager::ListRulesets(Database *db, std::map &into) { +bool RuleManager::ListRulesets(Database *database, std::map &into) { //start out with the default set which is always present. into[0] = "default"; - std::string query = "SELECT ruleset_id, name FROM rule_sets"; - auto results = db->QueryDatabase(query); + std::string query = "SELECT ruleset_id, name FROM rule_sets"; + auto results = database->QueryDatabase(query); if (results.Success()) - { return false; - } for (auto row = results.begin(); row != results.end(); ++row) - into[ atoi(row[0]) ] = row[1]; + into[atoi(row[0])] = row[1]; return true; } -int32 RuleManager::GetIntRule(RuleManager::IntType t) const -{ +int32 RuleManager::GetIntRule(RuleManager::IntType t) const{ return(m_RuleIntValues[t]); } -float RuleManager::GetRealRule(RuleManager::RealType t) const -{ +float RuleManager::GetRealRule(RuleManager::RealType t) const{ return(m_RuleRealValues[t]); } -bool RuleManager::GetBoolRule(RuleManager::BoolType t) const -{ +bool RuleManager::GetBoolRule(RuleManager::BoolType t) const{ return (m_RuleBoolValues[t] == 1); }