diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt index 57f000ccb..e312c202d 100644 --- a/common/CMakeLists.txt +++ b/common/CMakeLists.txt @@ -77,7 +77,6 @@ SET(common_sources unix.cpp platform.cpp json/jsoncpp.cpp - namegenerator/namegen.cpp net/console_server.cpp net/console_server_connection.cpp net/crc32.cpp @@ -222,7 +221,6 @@ SET(common_headers event/timer.h json/json.h json/json-forwards.h - namegenerator/namegen.h net/console_server.h net/console_server_connection.h net/crc32.h diff --git a/common/namegenerator/namegen.cpp b/common/namegenerator/namegen.cpp deleted file mode 100644 index 3ef880ea4..000000000 --- a/common/namegenerator/namegen.cpp +++ /dev/null @@ -1,522 +0,0 @@ -/** - * - * @file A fantasy name generator library. - * @version 1.0.1 - * @license Public Domain - * @author German M. Bravo (Kronuz) - * - */ - -#include "namegen.h" - -#include // for move, reverse -#include // for rng seed -#include // for size_t, mbsrtowcs, wcsrtombs -#include // for towupper -#include // for make_unique -#include // for mt19937, uniform_real_distribution -#include // for invalid_argument, out_of_range - - -using namespace NameGen; - - -static std::mt19937 rng(std::chrono::high_resolution_clock::now().time_since_epoch().count()); - - -// https://isocpp.org/wiki/faq/ctors#static-init-order -// Avoid the "static initialization order fiasco" -const std::unordered_map>& Generator::SymbolMap() -{ - static auto* const symbols = new std::unordered_map>({ - { - "s", { - "ach", "ack", "ad", "age", "ald", "ale", "an", "ang", "ar", "ard", - "as", "ash", "at", "ath", "augh", "aw", "ban", "bel", "bur", "cer", - "cha", "che", "dan", "dar", "del", "den", "dra", "dyn", "ech", "eld", - "elm", "em", "en", "end", "eng", "enth", "er", "ess", "est", "et", - "gar", "gha", "hat", "hin", "hon", "ia", "ight", "ild", "im", "ina", - "ine", "ing", "ir", "is", "iss", "it", "kal", "kel", "kim", "kin", - "ler", "lor", "lye", "mor", "mos", "nal", "ny", "nys", "old", "om", - "on", "or", "orm", "os", "ough", "per", "pol", "qua", "que", "rad", - "rak", "ran", "ray", "ril", "ris", "rod", "roth", "ryn", "sam", - "say", "ser", "shy", "skel", "sul", "tai", "tan", "tas", "ther", - "tia", "tin", "ton", "tor", "tur", "um", "und", "unt", "urn", "usk", - "ust", "ver", "ves", "vor", "war", "wor", "yer" - } - }, - { - "v", { - "a", "e", "i", "o", "u", "y" - } - }, - { - "V", { - "a", "e", "i", "o", "u", "y", "ae", "ai", "au", "ay", "ea", "ee", - "ei", "eu", "ey", "ia", "ie", "oe", "oi", "oo", "ou", "ui" - } - }, - { - "c", { - "b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", - "s", "t", "v", "w", "x", "y", "z" - } - }, - { - "B", { - "b", "bl", "br", "c", "ch", "chr", "cl", "cr", "d", "dr", "f", "g", - "h", "j", "k", "l", "ll", "m", "n", "p", "ph", "qu", "r", "rh", "s", - "sch", "sh", "sl", "sm", "sn", "st", "str", "sw", "t", "th", "thr", - "tr", "v", "w", "wh", "y", "z", "zh" - } - }, - { - "C", { - "b", "c", "ch", "ck", "d", "f", "g", "gh", "h", "k", "l", "ld", "ll", - "lt", "m", "n", "nd", "nn", "nt", "p", "ph", "q", "r", "rd", "rr", - "rt", "s", "sh", "ss", "st", "t", "th", "v", "w", "y", "z" - } - }, - { - "i", { - "air", "ankle", "ball", "beef", "bone", "bum", "bumble", "bump", - "cheese", "clod", "clot", "clown", "corn", "dip", "dolt", "doof", - "dork", "dumb", "face", "finger", "foot", "fumble", "goof", - "grumble", "head", "knock", "knocker", "knuckle", "loaf", "lump", - "lunk", "meat", "muck", "munch", "nit", "numb", "pin", "puff", - "skull", "snark", "sneeze", "thimble", "twerp", "twit", "wad", - "wimp", "wipe" - } - }, - { - "m", { - "baby", "booble", "bunker", "cuddle", "cuddly", "cutie", "doodle", - "foofie", "gooble", "honey", "kissie", "lover", "lovey", "moofie", - "mooglie", "moopie", "moopsie", "nookum", "poochie", "poof", - "poofie", "pookie", "schmoopie", "schnoogle", "schnookie", - "schnookum", "smooch", "smoochie", "smoosh", "snoogle", "snoogy", - "snookie", "snookum", "snuggy", "sweetie", "woogle", "woogy", - "wookie", "wookum", "wuddle", "wuddly", "wuggy", "wunny" - } - }, - { - "M", { - "boo", "bunch", "bunny", "cake", "cakes", "cute", "darling", - "dumpling", "dumplings", "face", "foof", "goo", "head", "kin", - "kins", "lips", "love", "mush", "pie", "poo", "pooh", "pook", "pums" - } - }, - { - "D", { - "b", "bl", "br", "cl", "d", "f", "fl", "fr", "g", "gh", "gl", "gr", - "h", "j", "k", "kl", "m", "n", "p", "th", "w" - } - }, - { - "d", { - "elch", "idiot", "ob", "og", "ok", "olph", "olt", "omph", "ong", - "onk", "oo", "oob", "oof", "oog", "ook", "ooz", "org", "ork", "orm", - "oron", "ub", "uck", "ug", "ulf", "ult", "um", "umb", "ump", "umph", - "un", "unb", "ung", "unk", "unph", "unt", "uzz" - } - } - }); - - return *symbols; -} - -Generator::Generator() -{ -} - - -Generator::Generator(std::vector>&& generators_) : - generators(std::move(generators_)) -{ -} - - -size_t Generator::combinations() -{ - size_t total = 1; - for (auto& g : generators) { - total *= g->combinations(); - } - return total; -} - - -size_t Generator::min() -{ - size_t final = 0; - for (auto& g : generators) { - final += g->min(); - } - return final; -} - - -size_t Generator::max() -{ - size_t final = 0; - for (auto& g : generators) { - final += g->max(); - } - return final; -} - - -std::string Generator::toString() { - std::string str; - for (auto& g : generators) { - str.append(g->toString()); - } - return str; -} - - -void Generator::add(std::unique_ptr&& g) -{ - generators.push_back(std::move(g)); -} - - -Random::Random() -{ -} - -Random::Random(std::vector>&& generators_) : - Generator(std::move(generators_)) -{ -} - -size_t Random::combinations() -{ - size_t total = 0; - for (auto& g : generators) { - total += g->combinations(); - } - return total ? total : 1; -} - -size_t Random::min() -{ - size_t final = -1; - for (auto& g : generators) { - size_t current = g->min(); - if (current < final) { - final = current; - } - } - return final; -} - -size_t Random::max() -{ - size_t final = 0; - for (auto& g : generators) { - size_t current = g->max(); - if (current > final) { - final = current; - } - } - return final; -} - - -std::string Random::toString() -{ - if (!generators.size()) { - return ""; - } - std::uniform_real_distribution distribution(0, generators.size() - 1); - int rnd = distribution(rng) + 0.5; - return generators[rnd]->toString(); -} - - -Sequence::Sequence() -{ -} - -Sequence::Sequence(std::vector>&& generators_) : - Generator(std::move(generators_)) -{ -} - -Literal::Literal(const std::string &value_) : - value(value_) -{ -} - -size_t Literal::combinations() -{ - return 1; -} - -size_t Literal::min() -{ - return value.size(); -} - -size_t Literal::max() -{ - return value.size(); -} - -std::string Literal::toString() -{ - return value; -} - -Reverser::Reverser(std::unique_ptr&& g) -{ - add(std::move(g)); -} - - -std::string Reverser::toString() -{ - std::wstring str = towstring(Generator::toString()); - std::reverse(str.begin(), str.end()); - return tostring(str); -} - -Capitalizer::Capitalizer(std::unique_ptr&& g) -{ - add(std::move(g)); -} - -std::string Capitalizer::toString() -{ - std::wstring str = towstring(Generator::toString()); - str[0] = std::towupper(str[0]); - return tostring(str); -} - - -Collapser::Collapser(std::unique_ptr&& g) -{ - add(std::move(g)); -} - -std::string Collapser::toString() -{ - std::wstring str = towstring(Generator::toString()); - std::wstring out; - int cnt = 0; - wchar_t pch = L'\0'; - for (auto ch : str) { - if (ch == pch) { - cnt++; - } else { - cnt = 0; - } - int mch = 2; - switch(ch) { - case 'a': - case 'h': - case 'i': - case 'j': - case 'q': - case 'u': - case 'v': - case 'w': - case 'x': - case 'y': - mch = 1; - } - if (cnt < mch) { - out.push_back(ch); - } - pch = ch; - } - return tostring(out); -} - - -Generator::Generator(const std::string &pattern, bool collapse_triples) { - std::unique_ptr last; - - std::stack> stack; - std::unique_ptr top = std::unique_ptr(); - - for (auto c : pattern) { - switch (c) { - case '<': - stack.push(std::move(top)); - top = std::unique_ptr(); - break; - case '(': - stack.push(std::move(top)); - top = std::unique_ptr(); - break; - case '>': - case ')': - if (stack.size() == 0) { - throw std::invalid_argument("Unbalanced brackets"); - } else if (c == '>' && top->type != group_types::symbol) { - throw std::invalid_argument("Unexpected '>' in pattern"); - } else if (c == ')' && top->type != group_types::literal) { - throw std::invalid_argument("Unexpected ')' in pattern"); - } - last = top->produce(); - top = std::move(stack.top()); - stack.pop(); - top->add(std::move(last)); - break; - case '|': - top->split(); - break; - case '!': - if (top->type == group_types::symbol) { - top->wrap(wrappers::capitalizer); - } else { - top->add(c); - } - break; - case '~': - if (top->type == group_types::symbol) { - top->wrap(wrappers::reverser); - } else { - top->add(c); - } - break; - default: - top->add(c); - break; - } - } - - if (stack.size() != 0) { - throw std::invalid_argument("Missing closing bracket"); - } - - std::unique_ptr g = top->produce(); - if (collapse_triples) { - g = std::unique_ptr(new Collapser(std::move(g))); - } - add(std::move(g)); -} - - -Generator::Group::Group(group_types_t type_) : - type(type_) -{ -} - -void Generator::Group::add(std::unique_ptr&& g) -{ - while (!wrappers.empty()) { - switch (wrappers.top()) { - case reverser: - g = std::unique_ptr(new Reverser(std::move(g))); - break; - case capitalizer: - g = std::unique_ptr(new Capitalizer(std::move(g))); - break; - } - wrappers.pop(); - } - if (set.size() == 0) { - set.push_back(std::unique_ptr()); - } - set.back()->add(std::move(g)); -} - -void Generator::Group::add(char c) -{ - std::string value(1, c); - std::unique_ptr g = std::unique_ptr(); - g->add(std::unique_ptr(new Literal(value))); - Group::add(std::move(g)); -} - -std::unique_ptr Generator::Group::produce() -{ - switch (set.size()) { - case 0: - return std::unique_ptr(new Literal("")); - case 1: - return std::move(*set.begin()); - default: - return std::unique_ptr(new Random(std::move(set))); - } -} - -void Generator::Group::split() -{ - if (set.size() == 0) { - set.push_back(std::unique_ptr()); - } - set.push_back(std::unique_ptr()); -} - -void Generator::Group::wrap(wrappers_t type) -{ - wrappers.push(type); -} - -Generator::GroupSymbol::GroupSymbol() : - Group(group_types::symbol) -{ -} - -void Generator::GroupSymbol::add(char c) -{ - std::string value(1, c); - std::unique_ptr g = std::unique_ptr(); - try { - static const auto& symbols = SymbolMap(); - for (const auto& s : symbols.at(value)) { - g->add(std::unique_ptr(new Literal(s))); - } - } catch (const std::out_of_range&) { - g->add(std::unique_ptr(new Literal(value))); - } - Group::add(std::move(g)); -} - -Generator::GroupLiteral::GroupLiteral() : - Group(group_types::literal) -{ -} - -std::wstring towstring(const std::string & s) -{ - const char *cs = s.c_str(); - const size_t wn = std::mbsrtowcs(nullptr, &cs, 0, nullptr); - - if (wn == static_cast(-1)) { - return L""; - } - - std::vector buf(wn); - cs = s.c_str(); - const size_t wn_again = std::mbsrtowcs(buf.data(), &cs, wn, nullptr); - - if (wn_again == static_cast(-1)) { - return L""; - } - - return std::wstring(buf.data(), wn); -} - -std::string tostring(const std::wstring & s) -{ - const wchar_t *cs = s.c_str(); - const size_t wn = std::wcsrtombs(nullptr, &cs, 0, nullptr); - - if (wn == static_cast(-1)) { - return ""; - } - - std::vector buf(wn); - const size_t wn_again = std::wcsrtombs(buf.data(), &cs, wn, nullptr); - - if (wn_again == static_cast(-1)) { - return ""; - } - - return std::string(buf.data(), wn); -} diff --git a/common/namegenerator/namegen.h b/common/namegenerator/namegen.h deleted file mode 100644 index 4ddcf1bf5..000000000 --- a/common/namegenerator/namegen.h +++ /dev/null @@ -1,269 +0,0 @@ -/** - * - * @file A fantasy name generator library. - * @version 1.0.1 - * @license Public Domain - * @author German M. Bravo (Kronuz) - * - * This library is designed after the RinkWorks Fantasy Name Generator. - * @see http://www.rinkworks.com/namegen/ - * - * @example - * NameGen::Generator generator("sV'i"); - * generator.toString(); // Returns a new name each call with produce() - * // => "entheu'loaf" - * - * ## Pattern Syntax - * - * The compile() function creates a name generator based on an input - * pattern. The letters s, v, V, c, B, C, i, m, M, D, and d represent - * different types of random replacements. Everything else is produced - * literally. - * - * s - generic syllable - * v - vowel - * V - vowel or vowel combination - * c - consonant - * B - consonant or consonant combination suitable for beginning a word - * C - consonant or consonant combination suitable anywhere in a word - * i - insult - * m - mushy name - * M - mushy name ending - * D - consonant suited for a stupid person's name - * d - syllable suited for a stupid person's name (begins with a vowel) - * - * All characters between parenthesis () are produced literally. For - * example, the pattern "s(dim)", produces a random generic syllable - * followed by "dim". - * - * Characters between angle brackets <> produce patterns from the table - * above. Imagine the entire pattern is wrapped in one of these. - * - * In both types of groupings, a vertical bar | denotes a random - * choice. Empty groups are allowed. For example, "(foo|bar)" produces - * either "foo" or "bar". The pattern "" produces a constant, - * vowel, or nothing at all. - * - * An exclamation point ! means to capitalize the component that - * follows it. For example, "!(foo)" will produce "Foo" and "v!s" will - * produce a lowercase vowel followed by a capitalized syllable, like - * "eRod". - * - * A tilde ~ means to reverse the letters of the component that - * follows it. For example, "~(foo)" will produce "oof". To reverse an - * entire template, wrap it in brackets. For example, to reverse - * "sV'i" as a whole use "~". The template "~sV'i" will only - * reverse the initial syllable. - * - * ## Internals - * - * A name generator is anything with a toString() method, including, - * importantly, strings themselves. The generator constructors - * (Random, Sequence) perform additional optimizations when *not* used - * with the `new` keyword: they may pass through a provided generator, - * combine provided generators, or even return a simple string. - * - * New pattern symbols added to Generator.symbols will automatically - * be used by the compiler. - */ - -#pragma once - -#include // for size_t -#include // for wstring -#include // for unique_ptr -#include // for stack -#include // for string -#include // for unordered_map -#include // for vector - - -namespace NameGen { - -// Middle Earth -#define MIDDLE_EARTH "(bil|bal|ban|hil|ham|hal|hol|hob|wil|me|or|ol|od|gor|for|fos|tol|ar|fin|ere|leo|vi|bi|bren|thor)(|go|orbis|apol|adur|mos|ri|i|na|ole|n)(|tur|axia|and|bo|gil|bin|bras|las|mac|grim|wise|l|lo|fo|co|ra|via|da|ne|ta|y|wen|thiel|phin|dir|dor|tor|rod|on|rdo|dis)" - -// Japanese Names (Constrained) -#define JAPANESE_NAMES_CONSTRAINED "(aka|aki|bashi|gawa|kawa|furu|fuku|fuji|hana|hara|haru|hashi|hira|hon|hoshi|ichi|iwa|kami|kawa|ki|kita|kuchi|kuro|marui|matsu|miya|mori|moto|mura|nabe|naka|nishi|no|da|ta|o|oo|oka|saka|saki|sawa|shita|shima|i|suzu|taka|take|to|toku|toyo|ue|wa|wara|wata|yama|yoshi|kei|ko|zawa|zen|sen|ao|gin|kin|ken|shiro|zaki|yuki|asa)(||||||||||bashi|gawa|kawa|furu|fuku|fuji|hana|hara|haru|hashi|hira|hon|hoshi|chi|wa|ka|kami|kawa|ki|kita|kuchi|kuro|marui|matsu|miya|mori|moto|mura|nabe|naka|nishi|no|da|ta|o|oo|oka|saka|saki|sawa|shita|shima|suzu|taka|take|to|toku|toyo|ue|wa|wara|wata|yama|yoshi|kei|ko|zawa|zen|sen|ao|gin|kin|ken|shiro|zaki|yuki|sa)" - -// Japanese Names (Diverse) -#define JAPANESE_NAMES_DIVERSE "(a|i|u|e|o|||||)(ka|ki|ki|ku|ku|ke|ke|ko|ko|sa|sa|sa|shi|shi|shi|su|su|se|so|ta|ta|chi|chi|tsu|te|to|na|ni|ni|nu|nu|ne|no|no|ha|hi|fu|fu|he|ho|ma|ma|ma|mi|mi|mi|mu|mu|mu|mu|me|mo|mo|mo|ya|yu|yu|yu|yo|ra|ra|ra|ri|ru|ru|ru|re|ro|ro|ro|wa|wa|wa|wa|wo|wo)(ka|ki|ki|ku|ku|ke|ke|ko|ko|sa|sa|sa|shi|shi|shi|su|su|se|so|ta|ta|chi|chi|tsu|te|to|na|ni|ni|nu|nu|ne|no|no|ha|hi|fu|fu|he|ho|ma|ma|ma|mi|mi|mi|mu|mu|mu|mu|me|mo|mo|mo|ya|yu|yu|yu|yo|ra|ra|ra|ri|ru|ru|ru|re|ro|ro|ro|wa|wa|wa|wa|wo|wo)(|(ka|ki|ki|ku|ku|ke|ke|ko|ko|sa|sa|sa|shi|shi|shi|su|su|se|so|ta|ta|chi|chi|tsu|te|to|na|ni|ni|nu|nu|ne|no|no|ha|hi|fu|fu|he|ho|ma|ma|ma|mi|mi|mi|mu|mu|mu|mu|me|mo|mo|mo|ya|yu|yu|yu|yo|ra|ra|ra|ri|ru|ru|ru|re|ro|ro|ro|wa|wa|wa|wa|wo|wo)|(ka|ki|ki|ku|ku|ke|ke|ko|ko|sa|sa|sa|shi|shi|shi|su|su|se|so|ta|ta|chi|chi|tsu|te|to|na|ni|ni|nu|nu|ne|no|no|ha|hi|fu|fu|he|ho|ma|ma|ma|mi|mi|mi|mu|mu|mu|mu|me|mo|mo|mo|ya|yu|yu|yu|yo|ra|ra|ra|ri|ru|ru|ru|re|ro|ro|ro|wa|wa|wa|wa|wo|wo)(|(ka|ki|ki|ku|ku|ke|ke|ko|ko|sa|sa|sa|shi|shi|shi|su|su|se|so|ta|ta|chi|chi|tsu|te|to|na|ni|ni|nu|nu|ne|no|no|ha|hi|fu|fu|he|ho|ma|ma|ma|mi|mi|mi|mu|mu|mu|mu|me|mo|mo|mo|ya|yu|yu|yu|yo|ra|ra|ra|ri|ru|ru|ru|re|ro|ro|ro|wa|wa|wa|wa|wo|wo)))(|||n)" - -// Chinese Names -#define CHINESE_NAMES "(zh|x|q|sh|h)(ao|ian|uo|ou|ia)(|(l|w|c|p|b|m)(ao|ian|uo|ou|ia)(|n)|-(l|w|c|p|b|m)(ao|ian|uo|ou|ia)(|(d|j|q|l)(a|ai|iu|ao|i)))" - -// Greek Names -#define GREEK_NAMES "(tia)|s(os)|Bc(ios)|Bv(ios|os)>" - -// Hawaiian Names (1) -#define HAWAIIAN_NAMES_1 "((h|k|l|m|n|p|w|')|)(a|e|i|o|u)((h|k|l|m|n|p|w|')|)(a|e|i|o|u)(((h|k|l|m|n|p|w|')|)(a|e|i|o|u)|)(((h|k|l|m|n|p|w|')|)(a|e|i|o|u)|)(((h|k|l|m|n|p|w|')|)(a|e|i|o|u)|)(((h|k|l|m|n|p|w|')|)(a|e|i|o|u)|)" - -// Hawaiian Names (2) -#define HAWAIIAN_NAMES_2 "((h|k|l|m|n|p|w|)(a|e|i|o|u|a'|e'|i'|o'|u'|ae|ai|ao|au|oi|ou|eu|ei)(k|l|m|n|p|)|)(h|k|l|m|n|p|w|)(a|e|i|o|u|a'|e'|i'|o'|u'|ae|ai|ao|au|oi|ou|eu|ei)(k|l|m|n|p|)" - -// Old Latin Place Names -#define OLD_LATIN_PLACE_NAMES "sv(nia|lia|cia|sia)" - -// Dragons (Pern) -#define DRAGONS_PERN "<|>>(th)" - -// Dragon Riders -#define DRAGON_RIDERS "c'" - -// Pokemon -#define POKEMON "v(mon|chu|zard|rtle)" - -// Fantasy (Vowels, R, etc.) -#define FANTASY_VOWELS_R "(|(|s|h|ty|ph|r))(i|ae|ya|ae|eu|ia|i|eo|ai|a)(lo|la|sri|da|dai|the|sty|lae|due|li|lly|ri|na|ral|sur|rith)(|(su|nu|sti|llo|ria|))(|(n|ra|p|m|lis|cal|deu|dil|suir|phos|ru|dru|rin|raap|rgue))" - -// Fantasy (S, A, etc.) -#define FANTASY_S_A "(cham|chan|jisk|lis|frich|isk|lass|mind|sond|sund|ass|chad|lirt|und|mar|lis|il|)(jask|ast|ista|adar|irra|im|ossa|assa|osia|ilsa|)(|(an|ya|la|sta|sda|sya|st|nya))" - -// Fantasy (H, L, etc.) -#define FANTASY_H_L "(ch|ch't|sh|cal|val|ell|har|shar|shal|rel|laen|ral|jh't|alr|ch|ch't|av)(|(is|al|ow|ish|ul|el|ar|iel))(aren|aeish|aith|even|adur|ulash|alith|atar|aia|erin|aera|ael|ira|iel|ahur|ishul)" - -// Fantasy (N, L, etc.) -#define FANTASY_N_L "(ethr|qil|mal|er|eal|far|fil|fir|ing|ind|il|lam|quel|quar|quan|qar|pal|mal|yar|um|ard|enn|ey)(|(|on|us|un|ar|as|en|ir|ur|at|ol|al|an))(uard|wen|arn|on|il|ie|on|iel|rion|rian|an|ista|rion|rian|cil|mol|yon)" - -// Fantasy (K, N, etc.) -#define FANTASY_K_N "(taith|kach|chak|kank|kjar|rak|kan|kaj|tach|rskal|kjol|jok|jor|jad|kot|kon|knir|kror|kol|tul|rhaok|rhak|krol|jan|kag|ryr)(|in|or|an|ar|och|un|mar|yk|ja|arn|ir|ros|ror)(|(mund|ard|arn|karr|chim|kos|rir|arl|kni|var|an|in|ir|a|i|as))" - -// Fantasy (J, G, Z, etc.) -#define FANTASY_J_G_Z "(aj|ch|etz|etzl|tz|kal|gahn|kab|aj|izl|ts|jaj|lan|kach|chaj|qaq|jol|ix|az|biq|nam)(|(|aw|al|yes|il|ay|en|tom||oj|im|ol|aj|an|as))(aj|am|al|aqa|ende|elja|ich|ak|ix|in|ak|al|il|ek|ij|os|al|im)" - -// Fantasy (K, J, Y, etc.) -#define FANTASY_K_J_Y "(yi|shu|a|be|na|chi|cha|cho|ksa|yi|shu)(th|dd|jj|sh|rr|mk|n|rk|y|jj|th)(us|ash|eni|akra|nai|ral|ect|are|el|urru|aja|al|uz|ict|arja|ichi|ural|iru|aki|esh)" - -// Fantasy (S, E, etc.) -#define FANTASY_S_E "(syth|sith|srr|sen|yth|ssen|then|fen|ssth|kel|syn|est|bess|inth|nen|tin|cor|sv|iss|ith|sen|slar|ssil|sthen|svis|s|ss|s|ss)(|(tys|eus|yn|of|es|en|ath|elth|al|ell|ka|ith|yrrl|is|isl|yr|ast|iy))(us|yn|en|ens|ra|rg|le|en|ith|ast|zon|in|yn|ys)" - - - class Generator - { - typedef enum wrappers { - capitalizer, - reverser - } wrappers_t; - - typedef enum group_types { - symbol, - literal - } group_types_t; - - - class Group { - std::stack wrappers; - std::vector> set; - - public: - group_types_t type; - - Group(group_types_t type_); - virtual ~Group() { } - - std::unique_ptr produce(); - void split(); - void wrap(wrappers_t type); - void add(std::unique_ptr&& g); - - virtual void add(char c); - }; - - - class GroupSymbol : public Group { - public: - GroupSymbol(); - void add(char c); - }; - - - class GroupLiteral : public Group { - public: - GroupLiteral(); - }; - - protected: - std::vector> generators; - - public: - static const std::unordered_map>& SymbolMap(); - - Generator(); - Generator(const std::string& pattern, bool collapse_triples=true); - Generator(std::vector>&& generators_); - - virtual ~Generator() = default; - - virtual size_t combinations(); - virtual size_t min(); - virtual size_t max(); - virtual std::string toString(); - - void add(std::unique_ptr&& g); - }; - - - class Random : public Generator - { - public: - Random(); - Random(std::vector>&& generators_); - - size_t combinations(); - size_t min(); - size_t max(); - std::string toString(); - }; - - - class Sequence : public Generator - { - public: - Sequence(); - Sequence(std::vector>&& generators_); - }; - - - class Literal : public Generator - { - std::string value; - - public: - Literal(const std::string& value_); - - size_t combinations(); - size_t min(); - size_t max(); - std::string toString(); - }; - - - class Reverser : public Generator { - public: - Reverser(std::unique_ptr&& g); - - std::string toString(); - }; - - - class Capitalizer : public Generator - { - public: - Capitalizer(std::unique_ptr&& g); - - std::string toString(); - }; - - - class Collapser : public Generator - { - public: - Collapser(std::unique_ptr&& g); - - std::string toString(); - }; - -} - -std::wstring towstring(const std::string& s); -std::string tostring(const std::wstring& s); \ No newline at end of file diff --git a/world/client.cpp b/world/client.cpp index c4d1c6c70..2d4b65e71 100644 --- a/world/client.cpp +++ b/world/client.cpp @@ -46,7 +46,6 @@ #include "clientlist.h" #include "wguild_mgr.h" #include "sof_char_create_data.h" -#include "../common/namegenerator/namegen.h" #include #include @@ -534,14 +533,80 @@ bool Client::HandleNameApprovalPacket(const EQApplicationPacket *app) return true; } -bool Client::HandleGenerateRandomNamePacket(const EQApplicationPacket *app) -{ - NameGen::Generator generator("!Bvss"); - std::string random_name = generator.toString(); +bool Client::HandleGenerateRandomNamePacket(const EQApplicationPacket *app) { + // creates up to a 10 char name + char vowels[18]="aeiouyaeiouaeioe"; + char cons[48]="bcdfghjklmnpqrstvwxzybcdgklmnprstvwbcdgkpstrkd"; + char rndname[17]="\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"; + char paircons[33]="ngrkndstshthphsktrdrbrgrfrclcr"; + int rndnum=emu_random.Int(0, 75),n=1; + bool dlc=false; + bool vwl=false; + bool dbl=false; + if (rndnum>63) + { // rndnum is 0 - 75 where 64-75 is cons pair, 17-63 is cons, 0-16 is vowel + rndnum=(rndnum-61)*2; // name can't start with "ng" "nd" or "rk" + rndname[0]=paircons[rndnum]; + rndname[1]=paircons[rndnum+1]; + n=2; + } + else if (rndnum>16) + { + rndnum-=17; + rndname[0]=cons[rndnum]; + } + else + { + rndname[0]=vowels[rndnum]; + vwl=true; + } + int namlen=emu_random.Int(5, 10); + for (int i=n;i46) + { // pick a cons pair + if (i>namlen-3) // last 2 chars in name? + { // name can only end in cons pair "rk" "st" "sh" "th" "ph" "sk" "nd" or "ng" + rndnum=emu_random.Int(0, 7)*2; + } + else + { // pick any from the set + rndnum=(rndnum-47)*2; + } + rndname[i]=paircons[rndnum]; + rndname[i+1]=paircons[rndnum+1]; + dlc=true; // flag keeps second letter from being doubled below + i+=1; + } + else + { // select a single cons + rndname[i]=cons[rndnum]; + } + } + else + { // select a vowel + rndname[i]=vowels[emu_random.Int(0, 16)]; + } + vwl=!vwl; + if (!dbl && !dlc) + { // one chance at double letters in name + if (!emu_random.Int(0, i+9)) // chances decrease towards end of name + { + rndname[i+1]=rndname[i]; + dbl=true; + i+=1; + } + } + } - auto *ngs = (NameGeneration_Struct *) app->pBuffer; - memset(ngs->name, 0, 64); - strcpy(ngs->name, random_name.c_str()); + rndname[0]=toupper(rndname[0]); + NameGeneration_Struct* ngs = (NameGeneration_Struct*)app->pBuffer; + memset(ngs->name,0,64); + strcpy(ngs->name,rndname); QueuePacket(app); return true;