pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2025-12-11 21:01:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Revert "Merge pull request #1007 from EQEmu/feature/improved-name-generator"

Browse Source 
This reverts commit 3c71e2c91df68421ab32d7f14094f067014cb70b, reversing
changes made to 80d160175450a7e74500f5c773f9e1d72ecb907d.
This commit is contained in:
Akkadius 2020-04-08 16:00:27 -05:00
parent cbd1f42a08
commit 1728923bbb
4 changed files with 73 additions and 801 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
common/CMakeLists.txt
View File

@ -77,7 +77,6 @@ SET(common_sources
unix.cpp unix.cpp
platform.cpp platform.cpp
json/jsoncpp.cpp json/jsoncpp.cpp
namegenerator/namegen.cpp
net/console_server.cpp net/console_server.cpp
net/console_server_connection.cpp net/console_server_connection.cpp
net/crc32.cpp net/crc32.cpp
@ -222,7 +221,6 @@ SET(common_headers
event/timer.h event/timer.h
json/json.h json/json.h
json/json-forwards.h json/json-forwards.h
namegenerator/namegen.h
net/console_server.h net/console_server.h
net/console_server_connection.h net/console_server_connection.h
net/crc32.h net/crc32.h

522
common/namegenerator/namegen.cpp
View File

@ -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 <algorithm> // for move, reverse
#include <chrono> // for rng seed
#include <cwchar> // for size_t, mbsrtowcs, wcsrtombs
#include <cwctype> // for towupper
#include <memory> // for make_unique
#include <random> // for mt19937, uniform_real_distribution
#include <stdexcept> // 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<std::string, const std::vector<std::string>>& Generator::SymbolMap()
{
static auto* const symbols = new std::unordered_map<std::string, const std::vector<std::string>>({
{
"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<std::unique_ptr<Generator>>&& 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<Generator>&& g)
{
generators.push_back(std::move(g));
}
Random::Random()
{
}
Random::Random(std::vector<std::unique_ptr<Generator>>&& 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<double> distribution(0, generators.size() - 1);
int rnd = distribution(rng) + 0.5;
return generators[rnd]->toString();
}
Sequence::Sequence()
{
}
Sequence::Sequence(std::vector<std::unique_ptr<Generator>>&& 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<Generator>&& 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<Generator>&& 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<Generator>&& 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<Generator> last;
std::stack<std::unique_ptr<Group>> stack;
std::unique_ptr<Group> top = std::unique_ptr<GroupSymbol>();
for (auto c : pattern) {
switch (c) {
case '<':
stack.push(std::move(top));
top = std::unique_ptr<GroupSymbol>();
break;
case '(':
stack.push(std::move(top));
top = std::unique_ptr<GroupLiteral>();
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<Generator> g = top->produce();
if (collapse_triples) {
g = std::unique_ptr<Collapser>(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<Generator>&& g)
{
while (!wrappers.empty()) {
switch (wrappers.top()) {
case reverser:
g = std::unique_ptr<Reverser>(new Reverser(std::move(g)));
break;
case capitalizer:
g = std::unique_ptr<Capitalizer>(new Capitalizer(std::move(g)));
break;
}
wrappers.pop();
}
if (set.size() == 0) {
set.push_back(std::unique_ptr<Sequence>());
}
set.back()->add(std::move(g));
}
void Generator::Group::add(char c)
{
std::string value(1, c);
std::unique_ptr<Generator> g = std::unique_ptr<Random>();
g->add(std::unique_ptr<Literal>(new Literal(value)));
Group::add(std::move(g));
}
std::unique_ptr<Generator> Generator::Group::produce()
{
switch (set.size()) {
case 0:
return std::unique_ptr<Literal>(new Literal(""));
case 1:
return std::move(*set.begin());
default:
return std::unique_ptr<Random>(new Random(std::move(set)));
}
}
void Generator::Group::split()
{
if (set.size() == 0) {
set.push_back(std::unique_ptr<Sequence>());
}
set.push_back(std::unique_ptr<Sequence>());
}
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<Generator> g = std::unique_ptr<Random>();
try {
static const auto& symbols = SymbolMap();
for (const auto& s : symbols.at(value)) {
g->add(std::unique_ptr<Literal>(new Literal(s)));
}
} catch (const std::out_of_range&) {
g->add(std::unique_ptr<Literal>(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<size_t>(-1)) {
return L"";
}
std::vector<wchar_t> buf(wn);
cs = s.c_str();
const size_t wn_again = std::mbsrtowcs(buf.data(), &cs, wn, nullptr);
if (wn_again == static_cast<size_t>(-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<size_t>(-1)) {
return "";
}
std::vector<char> buf(wn);
const size_t wn_again = std::wcsrtombs(buf.data(), &cs, wn, nullptr);
if (wn_again == static_cast<size_t>(-1)) {
return "";
}
return std::string(buf.data(), wn);
}

269
common/namegenerator/namegen.h
View File

@ -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 "<c|v|>" 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 "~<sV'i>". 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 <stddef.h> // for size_t
#include <iosfwd> // for wstring
#include <memory> // for unique_ptr
#include <stack> // for stack
#include <string> // for string
#include <unordered_map> // for unordered_map
#include <vector> // 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 "<s<v|V>(tia)|s<v|V>(os)|B<v|V>c(ios)|B<v|V><c|C>v(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 "<<s|ss>|<VC|vC|B|BVs|Vs>><v|V|v|<v(l|n|r)|vc>>(th)"
// Dragon Riders
#define DRAGON_RIDERS "c'<s|cvc>"
// Pokemon
#define POKEMON "<i|s>v(mon|chu|zard|rtle)"
// Fantasy (Vowels, R, etc.)
#define FANTASY_VOWELS_R "(|(<B>|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|<BVC>)(jask|ast|ista|adar|irra|im|ossa|assa|osia|ilsa|<vCv>)(|(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)(|(<vc>|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)(<vc>|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)(|(<vc>|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_t> wrappers;
std::vector<std::unique_ptr<Generator>> set;
public:
group_types_t type;
Group(group_types_t type_);
virtual ~Group() { }
std::unique_ptr<Generator> produce();
void split();
void wrap(wrappers_t type);
void add(std::unique_ptr<Generator>&& 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<std::unique_ptr<Generator>> generators;
public:
static const std::unordered_map<std::string, const std::vector<std::string>>& SymbolMap();
Generator();
Generator(const std::string& pattern, bool collapse_triples=true);
Generator(std::vector<std::unique_ptr<Generator>>&& 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<Generator>&& g);
};
class Random : public Generator
{
public:
Random();
Random(std::vector<std::unique_ptr<Generator>>&& generators_);
size_t combinations();
size_t min();
size_t max();
std::string toString();
};
class Sequence : public Generator
{
public:
Sequence();
Sequence(std::vector<std::unique_ptr<Generator>>&& 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<Generator>&& g);
std::string toString();
};
class Capitalizer : public Generator
{
public:
Capitalizer(std::unique_ptr<Generator>&& g);
std::string toString();
};
class Collapser : public Generator
{
public:
Collapser(std::unique_ptr<Generator>&& g);
std::string toString();
};
}
std::wstring towstring(const std::string& s);
std::string tostring(const std::wstring& s);

81
world/client.cpp
View File

@ -46,7 +46,6 @@
#include "clientlist.h" #include "clientlist.h"
#include "wguild_mgr.h" #include "wguild_mgr.h"
#include "sof_char_create_data.h" #include "sof_char_create_data.h"
#include "../common/namegenerator/namegen.h"
#include <iostream> #include <iostream>
#include <iomanip> #include <iomanip>
@ -534,14 +533,80 @@ bool Client::HandleNameApprovalPacket(const EQApplicationPacket *app)
return true; return true;
} }
bool Client::HandleGenerateRandomNamePacket(const EQApplicationPacket *app) bool Client::HandleGenerateRandomNamePacket(const EQApplicationPacket *app) {
{ // creates up to a 10 char name
NameGen::Generator generator("!Bvss"); char vowels[18]="aeiouyaeiouaeioe";
std::string random_name = generator.toString(); 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;i<namlen;i++)
{
dlc=false;
if (vwl) //last char was a vowel
{ // so pick a cons or cons pair
rndnum=emu_random.Int(0, 62);
if (rndnum>46)
{ // 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; rndname[0]=toupper(rndname[0]);
memset(ngs->name, 0, 64); NameGeneration_Struct* ngs = (NameGeneration_Struct*)app->pBuffer;
strcpy(ngs->name, random_name.c_str()); memset(ngs->name,0,64);
strcpy(ngs->name,rndname);
QueuePacket(app); QueuePacket(app);
return true; return true;