commit 54601b19932b4574e77770a027618e019f0df155 Author: FernandoJVideira <03.pleaser-minster@icloud.com> Date: Fri Aug 1 00:15:34 2025 +0100 Initial commit diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..7f93384 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,16 @@ +# Start from the official Golang image for building +FROM golang:1.22-alpine AS builder +WORKDIR /app +COPY . . +RUN go mod download +RUN go build -o app main.go + +# Use a minimal image for running +FROM alpine:latest +WORKDIR /app +COPY --from=builder /app/app . +COPY data ./data +EXPOSE 8080 +ENV RATE_LIMIT_RPS=2 +ENV RATE_LIMIT_BURST=5 +CMD ["./app"] diff --git a/data/aasimar.json b/data/aasimar.json new file mode 100644 index 0000000..3067008 --- /dev/null +++ b/data/aasimar.json @@ -0,0 +1,273 @@ +{ + "male": { + "nm1": [ + "", + "", + "", + "", + "b", + "br", + "c", + "cr", + "h", + "l", + "m", + "n", + "p", + "r", + "t", + "v", + "w", + "z" + ], + "nm2": [ + "a", + "e", + "i", + "o", + "u", + "y", + "a", + "e", + "i", + "o", + "u", + "y", + "a", + "e", + "i", + "o", + "u", + "y", + "au", + "ai", + "ea", + "ei" + ], + "nm3": [ + "d", + "dr", + "g", + "gg", + "gr", + "gw", + "k", + "kr", + "kl", + "l", + "ld", + "lg", + "lw", + "lr", + "lt", + "n", + "nr", + "nw", + "nl", + "r", + "rn", + "rr", + "rw", + "rl", + "v", + "vr", + "w" + ], + "nm4": [ + "a", + "i", + "a", + "i", + "a", + "i", + "a", + "i", + "a", + "i", + "a", + "i", + "e", + "a", + "i", + "e", + "a", + "i", + "e", + "o", + "o", + "u", + "u", + "ee", + "ia", + "ie", + "ai", + "ei" + ], + "nm5": [ + "d", + "l", + "m", + "n", + "t", + "v" + ], + "nm6": [ + "l", + "m", + "n", + "nt", + "r" + ] + }, + "female": { + "nm7": [ + "", + "", + "", + "", + "", + "br", + "d", + "dr", + "h", + "l", + "m", + "n", + "ph", + "r", + "rh", + "th", + "v", + "w", + "z" + ], + "nm8": [ + "a", + "i", + "o", + "a", + "i", + "o", + "a", + "i", + "o", + "a", + "i", + "o", + "a", + "i", + "o", + "a", + "i", + "o", + "e", + "e", + "ia", + "io", + "ea", + "eo" + ], + "nm9": [ + "d", + "j", + "l", + "ld", + "ldr", + "lv", + "ll", + "lt", + "m", + "mm", + "mn", + "n", + "nr", + "nv", + "nl", + "ndr", + "nm", + "r", + "rd", + "rk", + "rs", + "s", + "sr", + "sl", + "v" + ], + "nm10": [ + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "ea", + "ia", + "ie" + ], + "nm11": [ + "l", + "m", + "n", + "r", + "s", + "z" + ], + "nm12": [ + "a", + "e", + "i", + "a", + "e", + "i", + "a", + "e", + "i", + "a", + "e", + "i", + "a", + "e", + "i", + "au", + "ou", + "oe" + ], + "nm13": [ + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "h", + "l", + "m", + "n", + "r" + ] + } +} \ No newline at end of file diff --git a/data/arakocra.json b/data/arakocra.json new file mode 100644 index 0000000..ee42c63 --- /dev/null +++ b/data/arakocra.json @@ -0,0 +1,120 @@ +{ + "nm1": [ + "", + "", + "", + "", + "", + "c", + "cl", + "cr", + "d", + "g", + "gr", + "h", + "k", + "kh", + "kl", + "kr", + "q", + "qh", + "ql", + "qr", + "r", + "rh", + "s", + "y", + "z" + ], + "nm2": [ + "a", + "e", + "i", + "u", + "a", + "e", + "i", + "u", + "a", + "e", + "i", + "u", + "a", + "e", + "i", + "u", + "a", + "e", + "i", + "u", + "a", + "e", + "i", + "u", + "a", + "e", + "i", + "u", + "ae", + "aia", + "ee", + "oo", + "ou", + "ua", + "uie" + ], + "nm3": [ + "c", + "cc", + "k", + "kk", + "l", + "ll", + "q", + "r", + "rr" + ], + "nm4": [ + "a", + "e", + "i", + "a", + "e", + "i", + "a", + "e", + "i", + "a", + "e", + "i", + "a", + "e", + "i", + "aa", + "ea", + "ee", + "ia", + "ie" + ], + "nm5": [ + "", + "", + "", + "", + "c", + "ck", + "d", + "f", + "g", + "hk", + "k", + "l", + "r", + "rr", + "rc", + "rk", + "rrk", + "s", + "ss" + ] +} \ No newline at end of file diff --git a/data/bugbear.json b/data/bugbear.json new file mode 100644 index 0000000..d1cec01 --- /dev/null +++ b/data/bugbear.json @@ -0,0 +1,65 @@ +{ + "nm1": [ + "b", + "br", + "chr", + "d", + "g", + "gh", + "hr", + "kh", + "n", + "r", + "st", + "t", + "th", + "v", + "z", + "zh" + ], + "nm2": [ + "a", + "e", + "i", + "o", + "u" + ], + "nm3": [ + "d", + "dd", + "dr", + "g", + "gh", + "gg", + "gr", + "rr", + "rd", + "rg", + "rn", + "t", + "tt", + "tr", + "v", + "vr", + "z", + "zz" + ], + "nm4": [ + "a", + "i", + "o", + "u" + ], + "nm5": [ + "k", + "lk", + "mkk", + "n", + "nn", + "nk", + "r", + "rk", + "rr", + "th" + ] +} \ No newline at end of file diff --git a/data/centaur.json b/data/centaur.json new file mode 100644 index 0000000..efb2c45 --- /dev/null +++ b/data/centaur.json @@ -0,0 +1,425 @@ +{ + "male": { + "nm1": [ + "", + "", + "", + "b", + "d", + "dw", + "g", + "gh", + "gw", + "j", + "k", + "kh", + "m", + "n", + "rh", + "t", + "th", + "v", + "vr", + "z" + ], + "nm2": [ + "ae", + "ai", + "a", + "e", + "i", + "o", + "a", + "e", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "o" + ], + "nm3": [ + "f'r", + "l'n", + "l'd", + "m'v", + "m'z", + "n'z", + "n'v", + "n'r", + "sh'r", + "s'r", + "s'z", + "s'l", + "z'r", + "z'h", + "d", + "dr", + "g", + "gl", + "gr", + "k", + "kr", + "kl", + "l", + "ll", + "ld", + "ldr", + "ln", + "lr", + "lv", + "lz", + "lzr", + "m", + "mr", + "n", + "nn", + "nd", + "nv", + "r", + "rl", + "th", + "z", + "zl", + "zr" + ], + "nm4": [ + "a", + "e", + "i", + "u", + "e", + "i", + "u" + ], + "nm5": [ + "d", + "g", + "k", + "l", + "m", + "n", + "r", + "th", + "v" + ], + "nm6": [ + "a", + "e", + "i", + "o" + ], + "nm7": [ + "", + "", + "", + "d", + "g", + "h", + "l", + "ld", + "lk", + "n", + "nd", + "r", + "rd", + "s", + "t", + "th" + ] + }, + "female": { + "nm8": [ + "b", + "d", + "f", + "h", + "l", + "m", + "n", + "ph", + "r", + "s", + "sh", + "v", + "z" + ], + "nm9": [ + "a", + "e", + "i", + "a", + "e", + "i", + "o", + "y" + ], + "nm10": [ + "d", + "dh", + "dr", + "fr", + "fl", + "fn", + "g", + "gl", + "gr", + "ld", + "ldr", + "lg", + "ln", + "lr", + "lth", + "lv", + "lz", + "n", + "nr", + "nv", + "r", + "rl", + "rn", + "rg", + "rs", + "rz", + "rsh", + "z", + "zh", + "zr", + "zl" + ], + "nm11": [ + "a", + "e", + "i", + "i", + "o", + "y", + "y" + ], + "nm12": [ + "l", + "n", + "r", + "v", + "z" + ], + "nm13": [ + "ea", + "ia", + "ae", + "a", + "e", + "a", + "e", + "i", + "a", + "e", + "a", + "e", + "i", + "a", + "e", + "a", + "e", + "i", + "o", + "a", + "e", + "a", + "e", + "i", + "a", + "e", + "a", + "e", + "i", + "a", + "e", + "a", + "e", + "i", + "o" + ], + "nm14": [ + "g", + "h", + "l", + "n", + "r", + "s", + "sh", + "t", + "th" + ] + }, + "surname1": [ + "Aspen", + "Autumn", + "Birch", + "Bloom", + "Boulder", + "Brook", + "Brown", + "Bright", + "Brush", + "Burrow", + "Cedar", + "Crater", + "Creek", + "Drift", + "Dust", + "Earthen", + "Elm", + "Fall", + "Flood", + "Fog", + "Forest", + "Grass", + "Green", + "Grove", + "Hail", + "Hazel", + "Hill", + "Hollow", + "Ice", + "Iron", + "Laurel", + "Maple", + "Moon", + "Moss", + "Mountain", + "Oaken", + "Peak", + "Pine", + "Plain", + "Rain", + "Ridge", + "River", + "Rock", + "Snow", + "Spring", + "Star", + "Stone", + "Storm", + "Summer", + "Sun", + "Thorn", + "Timber", + "Valley", + "Vine", + "Willow", + "Winter", + "Wood", + "Yew" + ], + "surname2": [ + "bark", + "basker", + "bearer", + "binder", + "blade", + "blesser", + "blossom", + "blossoms", + "booster", + "borne", + "braid", + "braider", + "braids", + "breaker", + "bringer", + "bruiser", + "caller", + "carver", + "catcher", + "chanter", + "charger", + "chaser", + "cleanser", + "conqueror", + "crest", + "dancer", + "darter", + "defender", + "divider", + "dreamer", + "drinker", + "eyes", + "fader", + "fighter", + "force", + "forcer", + "former", + "gatherer", + "glow", + "groom", + "groomer", + "guard", + "heart", + "herald", + "hold", + "hoof", + "laugh", + "leaf", + "leaper", + "leaves", + "limp", + "love", + "mane", + "mangle", + "march", + "mask", + "mind", + "muse", + "pass", + "pelt", + "petals", + "prowl", + "prowler", + "push", + "reign", + "rest", + "reveler", + "ride", + "rise", + "roamer", + "roar", + "run", + "runner", + "rush", + "rusher", + "scorn", + "screamer", + "seeker", + "shadow", + "shield", + "shifter", + "shine", + "sign", + "sleep", + "slumber", + "smile", + "smirk", + "spark", + "spell", + "stare", + "strength", + "tail", + "temper", + "thread", + "trampler", + "tree", + "twister", + "voice", + "volley", + "wander", + "wanderer", + "watch", + "watcher", + "whisper", + "whisperer", + "wish" + ] +} \ No newline at end of file diff --git a/data/changeling.json b/data/changeling.json new file mode 100644 index 0000000..00d2ea3 --- /dev/null +++ b/data/changeling.json @@ -0,0 +1,66 @@ +{ + "nm1": [ + "", + "", + "", + "b", + "d", + "f", + "h", + "j", + "l", + "m", + "n", + "p", + "r", + "s", + "t", + "v", + "w", + "y" + ], + "nm2": [ + "a", + "i", + "o", + "u", + "a", + "i", + "o", + "u", + "a", + "i", + "o", + "u", + "a", + "i", + "o", + "u", + "ee", + "ie", + "ea", + "ae", + "ai", + "oo", + "ou" + ], + "nm3": [ + "c", + "g", + "gs", + "k", + "ks", + "kt", + "m", + "n", + "rx", + "rt", + "rs", + "s", + "sk", + "t", + "ts", + "x", + "z" + ] +} \ No newline at end of file diff --git a/data/deep_gnome.json b/data/deep_gnome.json new file mode 100644 index 0000000..6aa5166 --- /dev/null +++ b/data/deep_gnome.json @@ -0,0 +1,477 @@ +{ + "male": { + "nm1": [ + "b", + "br", + "d", + "dr", + "fr", + "g", + "gh", + "gr", + "k", + "kh", + "kr", + "sch", + "schn", + "sn", + "sh", + "t", + "th", + "w", + "z", + "zh" + ], + "nm2": [ + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "ie", + "ee", + "ai", + "aa", + "ei" + ], + "nm3": [ + "ck", + "ckt", + "ckh", + "cn", + "dg", + "dl", + "ddl", + "dm", + "g", + "gg", + "gn", + "gl", + "ggl", + "kt", + "kth", + "kl", + "kn", + "lsch", + "lw", + "lth", + "lk", + "lkr", + "ltr", + "ll", + "ld", + "ldr", + "nth", + "nt", + "nd", + "ndr", + "ntr", + "rbl", + "rthm", + "rt", + "rdr", + "t", + "tt", + "tl", + "ttl", + "tr", + "thr", + "th" + ], + "nm4": [ + "a", + "e", + "i", + "u" + ], + "nm5": [ + "", + "", + "", + "c", + "ck", + "d", + "g", + "l", + "ll", + "ld", + "n", + "nd", + "nk", + "r", + "rs", + "t" + ] + }, + "female": { + "nm6": [ + "", + "", + "", + "", + "", + "b", + "d", + "fr", + "gh", + "gr", + "h", + "k", + "kh", + "kr", + "l", + "m", + "n", + "s", + "sh", + "sn", + "sch", + "schn", + "t", + "th", + "y", + "w", + "z" + ], + "nm7": [ + "a", + "e", + "i", + "u" + ], + "nm8": [ + "ckn", + "d", + "dl", + "dd", + "g", + "gg", + "gd", + "gn", + "gh", + "l", + "ll", + "lg", + "lm", + "lv", + "ls", + "lsch", + "lsh", + "m", + "mk", + "mg", + "n", + "nn", + "nt", + "ny", + "ng", + "nk", + "rb", + "rg", + "rl", + "rsh", + "rv", + "rt", + "rth", + "rs", + "s", + "ss", + "sh", + "sn", + "sk", + "sg", + "sl", + "th", + "t", + "tr", + "thr", + "v", + "vr", + "vy", + "z" + ], + "nm9": [ + "a", + "e", + "i", + "a", + "e", + "i", + "a", + "e", + "i", + "a", + "e", + "i", + "ee", + "ie", + "ei", + "ai", + "ia" + ], + "nm10": [ + "d", + "dd", + "l", + "ll", + "ld", + "ln", + "lk", + "n", + "nn", + "r", + "rr", + "ry", + "rt", + "sh", + "sch" + ], + "nm11": [ + "a", + "e", + "i", + "a", + "i", + "a", + "i" + ], + "nm12": [ + "", + "", + "", + "", + "", + "", + "", + "d", + "dd", + "h", + "l", + "ll", + "n", + "nn", + "s", + "ss" + ] + }, + "surname1": [ + "adamant", + "agate", + "alabaster", + "alloy", + "amethyst", + "basalt", + "bedrock", + "block", + "boulder", + "brass", + "brick", + "bronze", + "clay", + "cobalt", + "cobble", + "copper", + "crag", + "crystal", + "deposit", + "diamond", + "dirt", + "dust", + "emerald", + "flint", + "fossil", + "garnet", + "gem", + "geo", + "geode", + "gold", + "granite", + "gravel", + "grime", + "ground", + "ingot", + "iron", + "jade", + "jewel", + "joint", + "lapis", + "lazuli", + "lead", + "lime", + "lodge", + "lump", + "marble", + "mason", + "metal", + "mill", + "mineral", + "mold", + "nickel", + "nugget", + "obsidian", + "onyx", + "opal", + "ore", + "pebble", + "pellet", + "peridot", + "pit", + "quartz", + "rock", + "rough", + "rubble", + "ruby", + "sand", + "sapphire", + "scrap", + "seam", + "shelf", + "silver", + "slab", + "slate", + "smelt", + "soil", + "spinel", + "steel", + "stone", + "stony", + "sturdy", + "terra", + "tile", + "tin", + "topaz", + "turf", + "wedge", + "wire", + "zinc", + "zircon" + ], + "surname2": [ + "back", + "basher", + "bender", + "biter", + "bleacher", + "bone", + "bones", + "brander", + "breaker", + "bringer", + "browser", + "brusher", + "carrier", + "carver", + "catcher", + "checker", + "cheek", + "chest", + "chewer", + "chin", + "chiseler", + "cleaner", + "cleanser", + "collector", + "counter", + "crusher", + "cutter", + "designer", + "digger", + "duster", + "ear", + "eye", + "eyes", + "face", + "feet", + "finder", + "finger", + "fingers", + "fist", + "foot", + "forger", + "gatherer", + "gazer", + "getter", + "grasper", + "grinder", + "hand", + "head", + "heart", + "hewer", + "holder", + "knuckle", + "leg", + "legs", + "lifter", + "loader", + "maker", + "marker", + "mask", + "melter", + "mender", + "merger", + "molder", + "moulder", + "mug", + "neck", + "nose", + "packer", + "presser", + "pusher", + "rater", + "recorder", + "rinser", + "saver", + "scanner", + "scratcher", + "sealer", + "searcher", + "seeker", + "seizer", + "senser", + "shaper", + "shoveler", + "skin", + "smasher", + "smelter", + "snatcher", + "sniffer", + "sorter", + "splitter", + "stamper", + "stasher", + "stocker", + "surveyor", + "sweeper", + "switcher", + "teeth", + "temperer", + "tooth", + "trader", + "twirler", + "twister", + "vein", + "viewer", + "warper", + "watcher" + ] +} \ No newline at end of file diff --git a/data/deva.json b/data/deva.json new file mode 100644 index 0000000..f9f1660 --- /dev/null +++ b/data/deva.json @@ -0,0 +1,355 @@ +{ + "male": { + "nm1": [ + "Ad", + "Ans", + "Ars", + "Ay", + "Bav", + "Ber", + "Dar", + "Eb", + "Ely", + "Er", + "Ery", + "Gal", + "Gam", + "Gar", + "Hiy", + "Iann", + "Ker", + "Mah", + "Mahr", + "Man", + "Mar", + "Math", + "Mor", + "Nat", + "Neh", + "Ner", + "Ob", + "Or", + "Rah", + "Ron", + "Sam", + "Sav", + "Ser", + "Sor", + "Tar", + "Tav", + "Vat", + "Ver", + "Zach", + "Zay" + ], + "nm2": [ + "ab", + "ach", + "ad", + "ahk", + "ahm", + "ahn", + "ahr", + "ak", + "al", + "am", + "an", + "ar", + "as", + "ath", + "eb", + "ech", + "ed", + "ehr", + "ek", + "el", + "em", + "en", + "er", + "es", + "iah", + "ihm", + "ihn", + "im", + "in", + "ir", + "is" + ], + "nm3": [ + "Ab", + "Ad", + "An", + "Ar", + "Ash", + "Chan", + "Dan", + "Dar", + "Dav", + "Din", + "Elk", + "Eran", + "Eys", + "Han", + "Hav", + "Hen", + "Idr", + "Is", + "Jan", + "Jen", + "Kal", + "Kan", + "Kay", + "Len", + "Lih", + "Mah", + "Mar", + "Nal", + "Nav", + "Nom", + "Paz", + "Rav", + "Ren", + "Riy", + "Sad", + "Shar", + "Sir", + "Tar", + "Tel", + "Tir" + ], + "nm4": [ + "a", + "ael", + "aen", + "ah", + "ahne", + "ana", + "anaeh", + "anael", + "anah", + "ane", + "anel", + "aniah", + "ara", + "araeh", + "are", + "ariah", + "ea", + "ehl", + "ek", + "el", + "ele", + "elle", + "era", + "ey", + "eya", + "i", + "ia", + "iah", + "im", + "ima" + ], + "nm5": [ + "b", + "ch", + "d", + "h", + "hk", + "hm", + "hn", + "hr", + "k", + "l", + "m", + "n", + "r", + "s", + "th" + ] + }, + "female": { + "nm1": [ + "", + "", + "", + "", + "b", + "d", + "g", + "h", + "k", + "m", + "n", + "r", + "s", + "t", + "v", + "z" + ], + "nm2": [ + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "ia", + "ie", + "ea", + "ei" + ], + "nm3": [ + "b", + "ch", + "d", + "h", + "hr", + "l", + "ly", + "m", + "n", + "nn", + "ns", + "r", + "rs", + "ry", + "t", + "th", + "v", + "y" + ], + "nm4": [ + "a", + "e", + "i" + ], + "nm5": [ + "b", + "ch", + "d", + "h", + "hk", + "hm", + "hn", + "hr", + "k", + "l", + "m", + "n", + "r", + "s", + "th" + ], + "nm6": [ + "", + "", + "", + "", + "", + "ch", + "d", + "h", + "j", + "k", + "l", + "m", + "n", + "p", + "r", + "s", + "sh", + "t", + "th" + ], + "nm7": [ + "a", + "e", + "i" + ], + "nm8": [ + "b", + "d", + "dr", + "h", + "l", + "lk", + "m", + "n", + "r", + "s", + "sh", + "v", + "y", + "ys", + "z" + ], + "nm9": [ + "a", + "e", + "i", + "a", + "e", + "i", + "a", + "e", + "i", + "a", + "e", + "i", + "a", + "e", + "i", + "a", + "e", + "i", + "ia", + "ae", + "ea" + ], + "nm10": [ + "hn", + "l", + "ll", + "m", + "n", + "r", + "y" + ], + "nm11": [ + "", + "", + "", + "", + "", + "", + "h", + "h", + "hl", + "k", + "l", + "l", + "n", + "n", + "m", + "m" + ] + } +} \ No newline at end of file diff --git a/data/dragonborn.json b/data/dragonborn.json new file mode 100644 index 0000000..5c2abae --- /dev/null +++ b/data/dragonborn.json @@ -0,0 +1,566 @@ +{ + "nm1": [ + "Ali", + "Ar", + "Ba", + "Bal", + "Bel", + "Bha", + "Bren", + "Caer", + "Calu", + "Dur", + "Do", + "Dra", + "Era", + "Faer", + "Fro", + "Gre", + "Ghe", + "Gora", + "He", + "Hi", + "Ior", + "Jin", + "Jar", + "Kil", + "Kriv", + "Lor", + "Lumi", + "Mar", + "Mor", + "Med", + "Nar", + "Nes", + "Na", + "Oti", + "Orla", + "Pri", + "Pa", + "Qel", + "Ravo", + "Ras", + "Rho", + "Sa", + "Sha", + "Sul", + "Taz", + "To", + "Trou", + "Udo", + "Uro", + "Vor", + "Vyu", + "Vrak", + "Wor", + "Wu", + "Wra", + "Wul", + "Xar", + "Yor", + "Zor", + "Zra" + ], + "nm2": [ + "barum", + "bor", + "broth", + "ciar", + "crath", + "daar", + "dhall", + "dorim", + "farn", + "fras", + "gar", + "ghull", + "grax", + "hadur", + "hazar", + "jhan", + "jurn", + "kax", + "kris", + "kul", + "lasar", + "lin", + "mash", + "morn", + "naar", + "prax", + "qiroth", + "qrin", + "qull", + "rakas", + "rash", + "rinn", + "roth", + "sashi", + "seth", + "skan", + "trin", + "turim", + "varax", + "vroth", + "vull", + "warum", + "wunax", + "xan", + "xiros", + "yax", + "ythas", + "zavur", + "zire", + "ziros" + ], + "nm3": [ + "Ari", + "A", + "Bi", + "Bel", + "Cris", + "Ca", + "Drys", + "Da", + "Erli", + "Esh", + "Fae", + "Fen", + "Gur", + "Gri", + "Hin", + "Ha", + "Irly", + "Irie", + "Jes", + "Jo", + "Ka", + "Kel", + "Ko", + "Lilo", + "Lora", + "Mal", + "Mi", + "Na", + "Nes", + "Nys", + "Ori", + "O", + "Ophi", + "Phi", + "Per", + "Qi", + "Quil", + "Rai", + "Rashi", + "So", + "Su", + "Tha", + "Ther", + "Uri", + "Ushi", + "Val", + "Vyra", + "Welsi", + "Wra", + "Xy", + "Xis", + "Ya", + "Yr", + "Zen", + "Zof" + ], + "nm4": [ + "birith", + "bis", + "bith", + "coria", + "cys", + "dalynn", + "drish", + "drith", + "faeth", + "fyire", + "gil", + "gissa", + "gwen", + "hime", + "hymm", + "karyn", + "kira", + "larys", + "liann", + "lyassa", + "meila", + "myse", + "norae", + "nys", + "patys", + "pora", + "qorel", + "qwen", + "rann", + "riel", + "rina", + "rinn", + "rish", + "rith", + "saadi", + "shann", + "sira", + "thibra", + "thyra", + "vayla", + "vyre", + "vys", + "wophyl", + "wyn", + "xiris", + "xora", + "yassa", + "yries", + "zita", + "zys" + ], + "nm5": [ + "", + "", + "", + "", + "c", + "cl", + "cr", + "d", + "dr", + "f", + "g", + "k", + "kl", + "kr", + "l", + "m", + "my", + "n", + "ny", + "pr", + "sh", + "t", + "th", + "v", + "y" + ], + "nm6": [ + "a", + "e", + "i", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "a", + "e", + "i", + "o", + "u", + "aa", + "ia", + "ea", + "ua", + "uu" + ], + "nm7": [ + "c", + "cc", + "ch", + "lm", + "lk", + "lx", + "ld", + "lr", + "ldr", + "lt", + "lth", + "mb", + "mm", + "mp", + "mph", + "mr", + "mt", + "nk", + "nx", + "nc", + "p", + "ph", + "r", + "rd", + "rj", + "rn", + "rrh", + "rth", + "st", + "tht", + "x" + ], + "nm8": [ + "c", + "cm", + "cn", + "d", + "j", + "k", + "km", + "l", + "n", + "nd", + "ndr", + "nk", + "nsht", + "nth", + "r", + "s", + "sht", + "shkm", + "st", + "t", + "th", + "x" + ], + "nm9": [ + "d", + "j", + "l", + "ll", + "m", + "n", + "nd", + "rg", + "r", + "rr", + "rd" + ], + "nm10": [ + "c", + "d", + "k", + "l", + "n", + "r", + "s", + "sh", + "th" + ], + "nm11": [ + "Able", + "Adamant", + "Adapter", + "Ambitious", + "Amuser", + "Analyzer", + "Babbler", + "Baffler", + "Barger", + "Basher", + "Battler", + "Bender", + "Binder", + "Biter", + "Blunderer", + "Bouncer", + "Bragger", + "Brawler", + "Brilliant", + "Bruiser", + "Bustler", + "Cackler", + "Calm", + "Caring", + "Charger", + "Chomper", + "Chuckler", + "Cleaver", + "Climber", + "Clinker", + "Composed", + "Cougher", + "Courageous", + "Courteous", + "Crackler", + "Crawler", + "Creative", + "Crumbler", + "Cruncher", + "Crusher", + "Dancer", + "Dangerous", + "Defender", + "Delightful", + "Devourer", + "Devout", + "Discreet", + "Diver", + "Dodger", + "Draconian", + "Dreamer", + "Drifter", + "Elegant", + "Enchanter", + "Enchanting", + "Energizer", + "Esteemed", + "Evader", + "Exalted", + "Fainter", + "Faithful", + "Faker", + "Favorable", + "Favoured", + "Fearless", + "Feigner", + "Flexer", + "Flincher", + "Flouncer", + "Flourisher", + "Folder", + "Follower", + "Forger", + "Fortunate", + "Frowner", + "Fumbler", + "Gatherer", + "Giggler", + "Glamorous", + "Glider", + "Gobbler", + "Grabber", + "Graceful", + "Gracious", + "Grappler", + "Grasper", + "Grounded", + "Growler", + "Grunter", + "Harmonious", + "Heartfelt", + "Heckler", + "Helper", + "Honorable", + "Hopeful", + "Humorous", + "Innocent", + "Intrepid", + "Joyous", + "Jumper", + "Kindhearted", + "Laugher", + "Launcher", + "Leaper", + "Limper", + "Lovable", + "Lunger", + "Lurker", + "Majestic", + "Marcher", + "Meddler", + "Mumbler", + "Murmurer", + "Mysterious", + "Napper", + "Nibbler", + "Nuzzler", + "Peaceful", + "Pious", + "Pouncer", + "Powerful", + "Proud", + "Puffer", + "Radiant", + "Reflective", + "Rester", + "Roarer", + "Rustler", + "Seeker", + "Serene", + "Serious", + "Shifter", + "Shusher", + "Silent", + "Sleeper", + "Sloucher", + "Smiler", + "Smoocher", + "Snuggler", + "Sophisticated", + "Spirited", + "Sprinter", + "Stamper", + "Stumbler", + "Tackler", + "Taunter", + "Thunderous", + "Tickler", + "Trampler", + "Trembler", + "Trustworthy", + "Truthful", + "Tumbler", + "Vigilant", + "Wanderer", + "Wandering", + "Whisperer", + "Zealous" + ], + "nm12": [ + "Barrel", + "Bed", + "Bow", + "Chair", + "Door", + "Plank", + "Plate", + "Roof", + "Room", + "Shelf", + "Shield", + "Spoon", + "Staff", + "Steel", + "Table", + "Tree", + "Wall", + "Wood" + ], + "nm13": [ + "bender", + "biter", + "breaker", + "carver", + "chomper", + "crumbler", + "cruncher", + "crusher", + "cutter", + "gnawer", + "masher", + "nibbler", + "piercer", + "razer", + "scraper", + "scratcher", + "scrawler", + "snapper", + "squasher", + "wrecker" + ] +} \ No newline at end of file diff --git a/data/drow.json b/data/drow.json new file mode 100644 index 0000000..ebae121 --- /dev/null +++ b/data/drow.json @@ -0,0 +1,1383 @@ +{ + "nmF": [ + "Ahlysaaria", + "Akordia", + "Alaunirra", + "Alystin", + "Amalica", + "Angaste", + "Anluryn", + "Ardulace", + "Aunrae", + "Balaena", + "Baltana", + "Bautha", + "Belarbreena", + "Beszrima", + "Brigantyna", + "Briza", + "Brorna", + "Burryna", + "Byrtyn", + "Cazna", + "Chadra", + "Chadzina", + "Chalithra", + "Chandara", + "Chardalyn", + "Charinida", + "Charlindra", + "Chenzira", + "Chessintra", + "Dhaunae", + "Dilynrae", + "Drada", + "Drisinil", + "Eclavdra", + "Elerra", + "Elvanshalee", + "Elvraema", + "Erakasyne", + "Ereldra", + "Faeryl", + "Felyndiira", + "Felyndiira", + "Filfaere", + "G'eldriia", + "Gaussra", + "Ghilanna", + "Greyanna", + "Gurina", + "Haelra", + "Halisstra", + "Ilharess", + "Ilivarrra", + "Ilmra", + "Imrae", + "Jaelryn", + "Jezzara", + "Jhaelryna", + "Jhaelrynna", + "Jhalass", + "Jhangara", + "Jhanniss", + "Jhulae", + "Khaless", + "Kiaran", + "Laele", + "Laele", + "Larynda", + "LiNeerlay", + "Lledrith", + "Llolfaen", + "Lualyrr", + "Lythrana", + "Malice", + "Maya", + "Menzoberra", + "Mez'Barris", + "Micarlin", + "Miz'ri", + "Mizzrym", + "Myrymma", + "Narcelia", + "Nathrae", + "Nedylene", + "Nendra", + "Nizana", + "Nulliira", + "Olorae", + "Pellanistra", + "Phaere", + "Phyrra", + "Qilue", + "Quarra", + "Rauva", + "Rilrae", + "Sabrae", + "Saradreza", + "Sassandra", + "Schezalle", + "Shimyra", + "ShriNeerune", + "Shulvallriel", + "Shurdriira", + "Shurdriira", + "Shurraenil", + "Shyntlara", + "SiNafay", + "Sindyrrith", + "Solenzara", + "Ssapriina", + "T'risstree", + "Talabrina", + "Talice", + "Tallrene", + "Thalra", + "Thirza", + "Thraele", + "Triel", + "Ulitree", + "Ulviirala", + "Umrae", + "Urlryn", + "Urmelena", + "Vhondryl", + "Viconia", + "Vierna", + "Vornalla", + "Waerva", + "Wuyondra", + "Xalyth", + "Xullrae", + "Xune", + "Yasrena", + "Yvonnel", + "Z'ress", + "Zarra", + "Zebeyana", + "Zeerith", + "Zelpassa", + "Zendalure", + "Zesstra", + "Zilvra" + ], + "nmFRf": [ + "Akor", + "Alaun", + "Aly", + "Ang", + "Ardul", + "Aun", + "Bae", + "Bal", + "Belar", + "Briz", + "Bur", + "Chal", + "Char", + "Chess", + "Dhaun", + "Dil", + "Dirz", + "Dris", + "Eclav", + "Elvan", + "Elv", + "Erel", + "Ethe", + "Faer", + "Felyn", + "Filf", + "Gauss", + "G'eld", + "Ghuan", + "Gin", + "Grey", + "Hael", + "Hal", + "Houn", + "Iiv", + "Iim", + "Illiam", + "In", + "Ilph", + "Irae", + "In", + "Iym", + "Jan", + "Jhael", + "Jhul", + "Jys", + "Lael", + "Lar", + "LiNeer", + "Lird", + "Lua", + "Mal", + "May", + "Micar", + "Min", + "Mol", + "Myr", + "Nath", + "Ned", + "Nhil", + "Neer", + "Null", + "Olor", + "Pellan", + "Phaer", + "Phyr", + "Qualn", + "Quar", + "Quav", + "Qil", + "Rauv", + "Ril", + "Sbat", + "Sab", + "Shi'n", + "Shri", + "Shur", + "Shynt", + "Sin", + "Ssap", + "Susp", + "Talab", + "Tal", + "Triel", + "T'riss", + "Ulvir", + "Umrae", + "Vas", + "Vic", + "Vier", + "Vlon", + "Waer", + "Wuyon", + "Xull", + "Xun", + "Yas", + "Zar", + "Zebey", + "Zes", + "Zilv" + ], + "nmFRl": [ + "a", + "ace", + "ae", + "aer", + "afae", + "afay", + "ala", + "anna", + "arra", + "aste", + "avin", + "ayne", + "baste", + "breena", + "bryn", + "cice", + "cyrl", + "da", + "dia", + "diira", + "dra", + "driira", + "dril", + "e", + "eari", + "eyl", + "ffyn", + "fryn", + "iara", + "ice", + "idil", + "iira", + "inidia", + "inil", + "intra", + "isstra", + "ithra", + "jra", + "jss", + "kacha", + "kiira", + "lay", + "lara", + "lin", + "lochar", + "mice", + "mur'ss", + "na", + "nilee", + "niss", + "nitra", + "nolu", + "olin", + "onia", + "oyss", + "qualyn", + "quarra", + "quiri", + "ra", + "rae", + "raema", + "raena", + "riia", + "ril", + "riina", + "ryna", + "ryne", + "shalee", + "ssysn", + "stin", + "stra", + "tana", + "thara", + "thrae", + "tree", + "tyrr", + "ual", + "ue", + "uit", + "une", + "uque", + "urra", + "va", + "vayas", + "vyll", + "vyrae", + "wae", + "wiira", + "wyss", + "xae", + "xena", + "xyra", + "yl", + "ylene", + "ymma", + "ynda", + "ynrae", + "vrae", + "yrr", + "zyne" + ], + "nmFFf": [ + "Ahly", + "Akor", + "Alau", + "Aly", + "Ama", + "Anga", + "Anlu", + "Ardu", + "Aun", + "Ba", + "Bal", + "Bau", + "Belar", + "Bes", + "Bri", + "Brigan", + "Bror", + "Bur", + "Byr", + "Caz", + "Cha", + "Chad", + "Chali", + "Chan", + "Char", + "Chari", + "Chen", + "Ches", + "Dhau", + "Dilyn", + "Dra", + "Dri", + "Eclav", + "Eler", + "Elv", + "Elvan", + "Era", + "Erel", + "Fae", + "Felyn", + "Fil", + "G'el", + "Gaus", + "Ghi", + "Gre", + "Gu", + "Hael", + "Halis", + "Ilha", + "Ilivar", + "Ilm", + "Im", + "Jael", + "Jez", + "Jha", + "Jhael", + "Jhan", + "Jhu", + "Kha", + "Kia", + "La", + "Lae", + "Lle", + "Llol", + "Lua", + "Ly", + "Ma", + "Menzo", + "Mez'Bar", + "Micar", + "Miz", + "Miz'", + "Myrym", + "Na", + "Narce", + "Nedy", + "Nen", + "Ni", + "Nul", + "Olo", + "Pella", + "Phae", + "Phyr", + "Qi", + "Quar", + "Rau", + "Ril", + "Sab", + "Sara", + "Sas", + "Sche", + "Shi", + "Shulvall", + "Shur", + "Shyn", + "Sindyr", + "Solen", + "Ssap", + "T'ris", + "Ta", + "Tala", + "Tall", + "Thal", + "Thir", + "Thrae", + "Uli", + "Ulvii", + "Um", + "Url", + "Urme", + "Vhon", + "Vico", + "Vier", + "Vor", + "Waer", + "Wuyon", + "Xa", + "Xu", + "Xull", + "Yas", + "Yvon", + "Z'res", + "Zar", + "Zebe", + "Zee", + "Zel", + "Zenda", + "Zes", + "Zil" + ], + "nmFFl": [ + "berra", + "breena", + "brina", + "da", + "dalyn", + "dara", + "dia", + "diira", + "dra", + "dreza", + "driia", + "driira", + "drith", + "dryl", + "faen", + "faere", + "gara", + "ka", + "lace", + "lae", + "laena", + "lanna", + "lass", + "le", + "lena", + "lene", + "less", + "lia", + "lica", + "lice", + "liira", + "lin", + "lindra", + "lue", + "lure", + "lyrr", + "lyth", + "ma", + "myra", + "na", + "nae", + "nalla", + "ne", + "nel", + "nia", + "nida", + "nirra", + "niss", + "nistra", + "passa", + "ra", + "rae", + "raema", + "raenil", + "rala", + "ran", + "re", + "rena", + "rene", + "ress", + "ri", + "riel", + "riina", + "rina", + "ris", + "rith", + "ryl", + "ryn", + "ryna", + "rynda", + "rynna", + "saaria", + "sandra", + "shalee", + "sinil", + "sintra", + "sra", + "ste", + "stin", + "stra", + "stree", + "syne", + "tana", + "tha", + "thra", + "thrae", + "thrana", + "tlara", + "tree", + "tyn", + "tyna", + "va", + "vra", + "ya", + "yana", + "yanna", + "za", + "zalle", + "zana", + "zara", + "zina", + "zira", + "zrima", + "zrym" + ], + "nmM": [ + "Alton", + "Balok", + "Baragh", + "Belaern", + "Belgos", + "Bemril", + "Berg'inyon", + "Bhintel", + "Brorn", + "Bruherd", + "Caelkoth", + "Callimar", + "Chakos", + "Chaszmyr", + "Coranzen", + "Dantrag", + "Dhuunyl", + "Dinin", + "Dresmorlin", + "Dro", + "Duagloth", + "Durdyn", + "Elamshin", + "Elendar", + "Elkantar", + "Filraen", + "Ghaundan", + "Ghaundar", + "Guldor", + "Guldor", + "Gwylyss", + "Hadrogh", + "Hatch'net", + "Honemmeth", + "Houndaer", + "Ildan", + "Ilmryn", + "Ilphrin", + "Imbros", + "Irennan", + "Istolil", + "Istorvir", + "Iymril", + "Jaezred", + "Jalynfein", + "Jeggred", + "Jevan", + "Jhaamdath", + "Jhaldrym", + "Jivvin", + "Jyslin", + "K'yorl", + "Kalannar", + "Kethan", + "Kluthruel", + "Kophyn", + "Krenaste", + "Krondorl", + "Kyorlin", + "Lesaonar", + "Lirdnolu", + "Llaulmyn", + "Malaggar", + "Micarlin", + "Minolin", + "Molvayas", + "Morennel", + "Nadal", + "Nalfein", + "Narissorin", + "Narlros", + "Nilonim", + "Nimruil", + "Numrini'th", + "Nyloth", + "Nym", + "Omareth", + "Orgoloth", + "Ornaryn", + "Pharaun", + "Pharius", + "Quave", + "Quendar", + "Quenthel", + "Quevven", + "Ranaghar", + "Relonor", + "Riklaunim", + "Rinnill", + "Ristel", + "Ruathym", + "Ryld", + "Ryltar", + "Sabal", + "Selakiir", + "Seldszar", + "Seldszar", + "Sengo", + "Solaufein", + "Sorn", + "Syrdar", + "Szordrin", + "Szordrin", + "Taldinyon", + "Tarlyn", + "Tathlyn", + "Tazennin", + "Tebryn", + "Tolokoph", + "Torrellan", + "Trelgath", + "Tsabrak", + "Urlryn", + "Valas", + "Veldrin", + "Velkyn", + "Vhurdaer", + "Vhurindrar", + "Vielyn", + "Vlondril", + "Vorn", + "Vuzlyn", + "Welverin", + "Xarann", + "Xundus", + "Yazston", + "Yuimmar", + "Zaknafein", + "Zeerith", + "Zyn" + ], + "nmMRf": [ + "Adin", + "Alak", + "Alton", + "Amal", + "Ant", + "Bar", + "Bel", + "Berg", + "Bhin", + "Bruh", + "Cal", + "Chasz", + "Din", + "Dip", + "Div", + "Driz", + "Duag", + "Dur", + "Elaug", + "Elk", + "Erth", + "Fil", + "Gel", + "Go", + "Gul", + "Hatch", + "Hurz", + "Ilzt", + "Im", + "Ist", + "Izz", + "Jar", + "Kalan", + "Kel", + "Kren", + "Kron", + "Les", + "Llt", + "Lyme", + "Malag", + "Mas", + "Mer", + "Mourn", + "Nad", + "Nal", + "Nil", + "Nym", + "Omar", + "Orgoll", + "Phar", + "Phyx", + "Quev", + "Quil", + "Ran", + "Relon", + "Rhyl", + "Rik", + "Riz", + "Ryl", + "Ryld", + "Selds", + "Shar", + "Sol", + "Sorn", + "Spir", + "Ssz", + "Szin", + "Szor", + "Tar", + "Tath", + "Taz", + "Teb", + "Tluth", + "Tsab", + "Uhls", + "Url", + "Val", + "Vesz", + "Vorn", + "Vuz", + "Wehl", + "Welv", + "Wod", + "Wruz", + "Yaz", + "Zakn", + "Zek", + "Zsz" + ], + "nmMRl": [ + "afein", + "agh", + "aghar", + "al", + "antar", + "aonar", + "as", + "atar", + "atlab", + "aufein", + "aun", + "axle", + "d", + "daer", + "dan", + "dar", + "dax", + "diin", + "diirn", + "dor", + "dorl", + "driirn", + "drin", + "dyn", + "erd", + "erin", + "eth", + "fein", + "gloth", + "gos", + "hrae", + "hriir", + "hrys", + "ica", + "imar", + "in", + "inid", + "inyon", + "irahc", + "kah", + "launim", + "lyn", + "myr", + "nar", + "net", + "nozz", + "oj", + "olg", + "olil", + "olvir", + "omph", + "onim", + "or", + "orvir", + "oyn", + "raen", + "rak", + "ral", + "rar", + "ree", + "roos", + "ryn", + "rysn", + "tar", + "tel", + "ton", + "tran", + "trin", + "ven", + "vyr", + "yln", + "yraen", + "yrd", + "zaer", + "zar", + "zen", + "zt", + "zyr" + ], + "nmMFf": [ + "Al", + "Ba", + "Be", + "Bel", + "Bem", + "Berg'", + "Bhin", + "Bru", + "Cael", + "Cal", + "Cha", + "Chas", + "Coran", + "Dan", + "Dhuu", + "Di", + "Dres", + "Dro", + "Duag", + "Dur", + "El", + "Elam", + "Elen", + "Fil", + "Ghaun", + "Gul", + "Gwy", + "Had", + "Hatch'", + "Honem", + "Houn", + "Il", + "Ilm", + "Im", + "Iren", + "Isto", + "Istor", + "Iym", + "Jaez", + "Jalyn", + "Je", + "Jeg", + "Jhaam", + "Jhal", + "Jiv", + "Jys", + "K'yo", + "Kalan", + "Ke", + "Kluth", + "Ko", + "Kre", + "Kron", + "Kyor", + "Lesao", + "Lird", + "Llaul", + "Malag", + "Micar", + "Mino", + "Mol", + "Moren", + "Na", + "Nal", + "Naris", + "Narl", + "Nilo", + "Nim", + "Num", + "Ny", + "Nym", + "Oma", + "Orgo", + "Orna", + "Pha", + "Qua", + "Quen", + "Quev", + "Rana", + "Relo", + "Riklau", + "Rin", + "Ris", + "Rua", + "Ryl", + "Ryld", + "Sa", + "Sela", + "Seld", + "Sen", + "Solau", + "Syr", + "Szor", + "Tal", + "Tar", + "Tath", + "Tazen", + "Teb", + "Tolo", + "Torrel", + "Trel", + "Tsab", + "Url", + "Va", + "Vel", + "Vhu", + "Vhur", + "Vie", + "Vlon", + "Vuz", + "Wel", + "Xa", + "Xun", + "Yaz", + "Yuim", + "Zakna", + "Zee" + ], + "nmMFl": [ + "bal", + "bros", + "daer", + "dal", + "dan", + "dar", + "dath", + "dinyon", + "dor", + "dorl", + "drar", + "dril", + "drin", + "drym", + "dus", + "dyn", + "fein", + "gar", + "gath", + "ghar", + "go", + "gos", + "gred", + "herd", + "inyon", + "kantar", + "kiir", + "koph", + "kos", + "koth", + "kyn", + "laern", + "lan", + "las", + "lil", + "limar", + "lin", + "lok", + "loth", + "lyn", + "lyss", + "mar", + "meth", + "morlin", + "myn", + "nan", + "nar", + "naste", + "nel", + "net", + "nill", + "nim", + "nin", + "nolu", + "nor", + "nyl", + "phrin", + "phyn", + "raen", + "ragh", + "rak", + "rann", + "raun", + "red", + "reth", + "ril", + "rin", + "rini'th", + "rith", + "rius", + "rogh", + "ros", + "ruel", + "ruil", + "ryn", + "shin", + "sorin", + "ston", + "szar", + "tar", + "tel", + "than", + "thel", + "thym", + "ton", + "trag", + "van", + "vayas", + "ve", + "ven", + "verin", + "vin", + "vir", + "zen", + "zmyr" + ], + "nmS": [ + "A'Daragon", + "Abaeir", + "Abbylan", + "Argith", + "Baenre", + "Beltaulur", + "Blaerabban", + "Blundyth", + "Chaulssin", + "Coborel", + "Coloara", + "Cormrael", + "Daevion'lyr", + "Dalael", + "Dhalmass", + "Dhunnyl", + "Diliriy", + "Dinoryn", + "Dryaalis", + "Duskryn", + "Dyrr", + "Elpragh", + "Elpragh", + "Faertala", + "Filifar", + "Gallaer", + "Glannath", + "Glaurach", + "Helviiryn", + "Hune", + "Hunzrin", + "Hyluan", + "Icharyd", + "Ilaleztice", + "Illistyn", + "Illykur", + "Jhalavar", + "Jusztiirn", + "Keteeruae", + "Khalazza", + "Khalazza", + "Kront'tane", + "Lhalabar", + "Lueltar", + "Mizzrym", + "Mlezziir", + "Naerth", + "Nirinath", + "Olonrae", + "Omriwin", + "Philiom", + "Quavein", + "Rhomduil", + "Rrostarr", + "Seerear", + "Ssambra", + "T'orgh", + "T'sarran", + "Tanor'Thal", + "Telenna", + "Tlin'orzza", + "Tlintarn", + "Tuin", + "Uloavae", + "Vrammyr", + "Vrinn", + "Waeglossz", + "Xiltyn", + "Yauntyrr", + "Yauthlo", + "Yril'Lysaen", + "Zaphresz", + "Zauviir", + "Zolond" + ], + "nmSRf": [ + "Alean", + "Ale", + "Arab", + "Arken", + "Auvry", + "Baen", + "Barri", + "Cladd", + "Desp", + "De", + "Do'", + "Eils", + "Everh", + "Fre", + "Gode", + "Helvi", + "Hla", + "Hun'", + "Ken", + "Kil", + "Mae", + "Mel", + "My", + "Noqu", + "Orly", + "Ouss", + "Rilyn", + "Teken'", + "Tor", + "Zau" + ], + "nmSRl": [ + "afin", + "ana", + "ani", + "ar", + "arn", + "ate", + "ath", + "duis", + "ervs", + "ep", + "ett", + "ghym", + "iryn", + "lyl", + "mtor", + "ndar", + "neld", + "rae", + "rahel", + "rret", + "sek", + "th", + "tlar", + "t'tar", + "tyl", + "und", + "urden", + "val", + "viir", + "zynge" + ], + "nmSFf": [ + "A'Dar", + "Ab", + "Abb", + "Arg", + "Baenre", + "Belt", + "Blaer", + "Blund", + "Chaulss", + "Cob", + "Col", + "Cormr", + "D", + "Daev", + "Dal", + "Dhalm", + "Dhunn", + "Dil", + "Din", + "Dryaal", + "Duskr", + "Elpr", + "Faert", + "Fil", + "Gall", + "Glann", + "Glaur", + "H", + "Helv", + "Hunzr", + "Hyl", + "Ich", + "Ilal", + "Ill", + "Jhal", + "Juszt", + "Keteer", + "Khal", + "Kront't", + "Lhal", + "Luelt", + "Mizzr", + "Mlezz", + "N", + "Nir", + "Ol", + "Omr", + "Phil", + "Quav", + "Rhomd", + "Rrost", + "Seer", + "Ss", + "T", + "T'", + "T's", + "Tanor'Th", + "Tel", + "Tlin'", + "Tlint", + "Ul", + "Vr", + "Vramm", + "Waegl", + "Xilt", + "Yaunt", + "Yril'Lys", + "Zaphr", + "Zauv", + "Zol" + ], + "nmSFl": [ + "abar", + "abban", + "ach", + "aeir", + "ael", + "aen", + "aer", + "aerth", + "agh", + "agon", + "al", + "ala", + "ambra", + "ane", + "ar", + "arn", + "arr", + "arran", + "aryd", + "ass", + "ath", + "aulur", + "avar", + "azza", + "ear", + "ein", + "enna", + "esz", + "eztice", + "ifar", + "iir", + "iirn", + "iiryn", + "in", + "inath", + "inn", + "iom", + "ion'lyr", + "iriy", + "is", + "istyn", + "ith", + "iwin", + "oara", + "oavae", + "ond", + "onrae", + "orel", + "orgh", + "oryn", + "orzza", + "ossz", + "uae", + "uan", + "uil", + "uin", + "une", + "ykur", + "yl", + "ylan", + "ym", + "yn", + "yr", + "yrr", + "yth" + ] +} \ No newline at end of file diff --git a/data/duergar.json b/data/duergar.json new file mode 100644 index 0000000..3361485 --- /dev/null +++ b/data/duergar.json @@ -0,0 +1,1050 @@ +{ + "nm1": [ + "Ad", + "Am", + "Arm", + "Baer", + "Daer", + "Bal", + "Ban", + "Bar", + "Bel", + "Ben", + "Ber", + "Bhal", + "Bhar", + "Bhel", + "Bram", + "Bran", + "Brom", + "Brum", + "Bun", + "Dal", + "Dar", + "Dol", + "Dul", + "Eb", + "Em", + "Erm", + "Far", + "Gal", + "Gar", + "Ger", + "Gim", + "Gral", + "Gram", + "Gran", + "Grem", + "Gren", + "Gril", + "Gry", + "Gul", + "Har", + "Hjal", + "Hjol", + "Hjul", + "Hor", + "Hul", + "Hur", + "Kar", + "Khar", + "Kram", + "Krom", + "Krum", + "Mag", + "Mal", + "Mel", + "Mor", + "Muir", + "Mur", + "Rag", + "Ran", + "Reg", + "Rot", + "Thal", + "Thar", + "Thel", + "Ther", + "Tho", + "Thor", + "Thul", + "Thur", + "Thy", + "Tor", + "Ty", + "Um", + "Urm", + "Von" + ], + "nm2": [ + "adin", + "bek", + "brek", + "dahr", + "dain", + "dal", + "dan", + "dar", + "dek", + "dir", + "dohr", + "dor", + "drak", + "dram", + "dren", + "drom", + "drum", + "drus", + "duhr", + "dur", + "dus", + "garn", + "gram", + "gran", + "grim", + "grom", + "gron", + "grum", + "grun", + "gurn", + "gus", + "iggs", + "kahm", + "kam", + "kohm", + "kom", + "kuhm", + "kum", + "kyl", + "man", + "mand", + "mar", + "mek", + "miir", + "min", + "mir", + "mond", + "mor", + "mun", + "mund", + "mur", + "mus", + "myl", + "myr", + "nam", + "nar", + "nik", + "nir", + "nom", + "num", + "nur", + "nus", + "nyl", + "rak", + "ram", + "ren", + "rig", + "rigg", + "rik", + "rim", + "rom", + "ron", + "rum", + "rus", + "ryl", + "tharm", + "tharn", + "thran", + "thrum", + "thrun" + ], + "nm3": [ + "An", + "Ar", + "Baer", + "Bar", + "Bel", + "Belle", + "Bon", + "Bonn", + "Braen", + "Bral", + "Bralle", + "Bran", + "Bren", + "Bret", + "Bril", + "Brille", + "Brol", + "Bron", + "Brul", + "Bryl", + "Brylle", + "Bryn", + "Bryt", + "Byl", + "Bylle", + "Daer", + "Dear", + "Dim", + "Ed", + "Ein", + "El", + "Gem", + "Ger", + "Gwan", + "Gwen", + "Gwin", + "Gwyn", + "Gym", + "Ing", + "Jen", + "Jenn", + "Jin", + "Jyn", + "Kait", + "Kar", + "Kat", + "Kath", + "Ket", + "Las", + "Lass", + "Les", + "Less", + "Lyes", + "Lys", + "Lyss", + "Maer", + "Maev", + "Mar", + "Mis", + "Mist", + "Myr", + "Mys", + "Myst", + "Naer", + "Nal", + "Nas", + "Nass", + "Nes", + "Nis", + "Nys", + "Raen", + "Ran", + "Red", + "Reyn", + "Run", + "Ryn", + "Sar", + "Sol", + "Tas", + "Taz", + "Tis", + "Tish", + "Tiz", + "Tor", + "Tys", + "Tysh" + ], + "nm4": [ + "belle", + "bera", + "delle", + "deth", + "dielle", + "dille", + "dish", + "dora", + "dryn", + "dyl", + "giel", + "glia", + "glian", + "gwyn", + "la", + "leen", + "leil", + "len", + "lin", + "linn", + "lyl", + "lyn", + "lynn", + "ma", + "mera", + "mora", + "mura", + "myl", + "myla", + "nan", + "nar", + "nas", + "nera", + "nia", + "nip", + "nis", + "niss", + "nora", + "nura", + "nyl", + "nys", + "nyss", + "ra", + "ras", + "res", + "ri", + "ria", + "rielle", + "rin", + "ris", + "ros", + "ryl", + "ryn", + "sael", + "selle", + "sora", + "syl", + "thel", + "thiel", + "tin", + "tyn", + "va", + "van", + "via", + "vian", + "waen", + "win", + "wyn", + "wynn" + ], + "nm5": [ + "ash", + "barren", + "battle", + "black", + "blast", + "blind", + "blood", + "bold", + "bone", + "bright", + "broad", + "broken", + "bronze", + "burn", + "craven", + "dark", + "doom", + "earth", + "fire", + "flame", + "flint", + "fore", + "forge", + "giant", + "goblin", + "gore", + "grave", + "grim", + "hell", + "hollow", + "iron", + "keen", + "knife", + "mad", + "mind", + "molten", + "neck", + "onyx", + "ore", + "proud", + "rage", + "red", + "rock", + "rune", + "rust", + "shadow", + "silent", + "skull", + "stark", + "steel", + "stone", + "storm", + "stout", + "thunder", + "troll", + "under", + "venge", + "vice", + "war", + "wicked", + "wild", + "wrath" + ], + "nm6": [ + "axe", + "basher", + "battle", + "beard", + "belch", + "belcher", + "belt", + "blade", + "bleeder", + "boot", + "boots", + "braid", + "brand", + "breaker", + "breath", + "bringer", + "brow", + "buster", + "chain", + "chains", + "champion", + "chewer", + "cleaver", + "crag", + "crusher", + "drum", + "dust", + "earth", + "eater", + "edge", + "eye", + "fall", + "favor", + "feast", + "fight", + "fist", + "flayer", + "flow", + "force", + "forge", + "fury", + "gift", + "gore", + "grace", + "guard", + "hammer", + "hand", + "handle", + "head", + "heart", + "helm", + "hold", + "honor", + "horn", + "hunt", + "hunter", + "lord", + "mantle", + "march", + "mask", + "master", + "might", + "minder", + "pass", + "past", + "pride", + "reach", + "rest", + "ripper", + "rock", + "runner", + "slayer", + "slice", + "snapper", + "sorrow", + "spite", + "stand", + "stone", + "storm", + "strike", + "striker", + "tale", + "tamer", + "ward" + ], + "nm7": [ + "axe", + "basher", + "battle", + "beard", + "belch", + "belcher", + "belt", + "blade", + "bleeder", + "boot", + "boots", + "braid", + "brand", + "breaker", + "breath", + "bringer", + "brow", + "buster", + "chain", + "chains", + "champion", + "chewer", + "cleaver", + "crag", + "crusher", + "drum", + "dust", + "earth", + "eater", + "edge", + "eye", + "fall", + "favor", + "feast", + "fight", + "fist", + "flayer", + "flow", + "force", + "forge", + "fury", + "gift", + "gore", + "grace", + "guard", + "hammer", + "hand", + "handle", + "head", + "heart", + "helm", + "hold", + "honor", + "horn", + "hunt", + "hunter", + "lord", + "mantle", + "march", + "mask", + "master", + "might", + "minder", + "pass", + "past", + "pride", + "reach", + "rest", + "ripper", + "rock", + "runner", + "slayer", + "slice", + "snapper", + "sorrow", + "spite", + "stand", + "stone", + "storm", + "strike", + "striker", + "tale", + "tamer", + "ward" + ], + "nm8": [ + "axe", + "basher", + "battle", + "beard", + "belch", + "belcher", + "belt", + "blade", + "bleeder", + "boot", + "boots", + "braid", + "brand", + "breaker", + "breath", + "bringer", + "brow", + "buster", + "chain", + "chains", + "champion", + "chewer", + "cleaver", + "crag", + "crusher", + "drum", + "dust", + "earth", + "eater", + "edge", + "eye", + "fall", + "favor", + "feast", + "fight", + "fist", + "flayer", + "flow", + "force", + "forge", + "fury", + "gift", + "gore", + "grace", + "guard", + "hammer", + "hand", + "handle", + "head", + "heart", + "helm", + "hold", + "honor", + "horn", + "hunt", + "hunter", + "lord", + "mantle", + "march", + "mask", + "master", + "might", + "minder", + "pass", + "past", + "pride", + "reach", + "rest", + "ripper", + "rock", + "runner", + "slayer", + "slice", + "snapper", + "sorrow", + "spite", + "stand", + "stone", + "storm", + "strike", + "striker", + "tale", + "tamer", + "ward" + ], + "nm9": [ + "axe", + "basher", + "battle", + "beard", + "belch", + "belcher", + "belt", + "blade", + "bleeder", + "boot", + "boots", + "braid", + "brand", + "breaker", + "breath", + "bringer", + "brow", + "buster", + "chain", + "chains", + "champion", + "chewer", + "cleaver", + "crag", + "crusher", + "drum", + "dust", + "earth", + "eater", + "edge", + "eye", + "fall", + "favor", + "feast", + "fight", + "fist", + "flayer", + "flow", + "force", + "forge", + "fury", + "gift", + "gore", + "grace", + "guard", + "hammer", + "hand", + "handle", + "head", + "heart", + "helm", + "hold", + "honor", + "horn", + "hunt", + "hunter", + "lord", + "mantle", + "march", + "mask", + "master", + "might", + "minder", + "pass", + "past", + "pride", + "reach", + "rest", + "ripper", + "rock", + "runner", + "slayer", + "slice", + "snapper", + "sorrow", + "spite", + "stand", + "stone", + "storm", + "strike", + "striker", + "tale", + "tamer", + "ward" + ], + "nm10": [ + "axe", + "basher", + "battle", + "beard", + "belch", + "belcher", + "belt", + "blade", + "bleeder", + "boot", + "boots", + "braid", + "brand", + "breaker", + "breath", + "bringer", + "brow", + "buster", + "chain", + "chains", + "champion", + "chewer", + "cleaver", + "crag", + "crusher", + "drum", + "dust", + "earth", + "eater", + "edge", + "eye", + "fall", + "favor", + "feast", + "fight", + "fist", + "flayer", + "flow", + "force", + "forge", + "fury", + "gift", + "gore", + "grace", + "guard", + "hammer", + "hand", + "handle", + "head", + "heart", + "helm", + "hold", + "honor", + "horn", + "hunt", + "hunter", + "lord", + "mantle", + "march", + "mask", + "master", + "might", + "minder", + "pass", + "past", + "pride", + "reach", + "rest", + "ripper", + "rock", + "runner", + "slayer", + "slice", + "snapper", + "sorrow", + "spite", + "stand", + "stone", + "storm", + "strike", + "striker", + "tale", + "tamer", + "ward" + ], + "nm11": [ + "axe", + "basher", + "battle", + "beard", + "belch", + "belcher", + "belt", + "blade", + "bleeder", + "boot", + "boots", + "braid", + "brand", + "breaker", + "breath", + "bringer", + "brow", + "buster", + "chain", + "chains", + "champion", + "chewer", + "cleaver", + "crag", + "crusher", + "drum", + "dust", + "earth", + "eater", + "edge", + "eye", + "fall", + "favor", + "feast", + "fight", + "fist", + "flayer", + "flow", + "force", + "forge", + "fury", + "gift", + "gore", + "grace", + "guard", + "hammer", + "hand", + "handle", + "head", + "heart", + "helm", + "hold", + "honor", + "horn", + "hunt", + "hunter", + "lord", + "mantle", + "march", + "mask", + "master", + "might", + "minder", + "pass", + "past", + "pride", + "reach", + "rest", + "ripper", + "rock", + "runner", + "slayer", + "slice", + "snapper", + "sorrow", + "spite", + "stand", + "stone", + "storm", + "strike", + "striker", + "tale", + "tamer", + "ward" + ], + "nm12": [ + "ash", + "barren", + "battle", + "black", + "blast", + "blind", + "blood", + "bold", + "bone", + "bright", + "broad", + "broken", + "bronze", + "burn", + "craven", + "dark", + "doom", + "earth", + "fire", + "flame", + "flint", + "fore", + "forge", + "giant", + "goblin", + "gore", + "grave", + "grim", + "hell", + "hollow", + "iron", + "keen", + "knife", + "mad", + "mind", + "molten", + "neck", + "onyx", + "ore", + "proud", + "rage", + "red", + "rock", + "rune", + "rust", + "shadow", + "silent", + "skull", + "stark", + "steel", + "stone", + "storm", + "stout", + "thunder", + "troll", + "under", + "venge", + "vice", + "war", + "wicked", + "wild", + "wrath" + ], + "nm13": [ + "axe", + "basher", + "battle", + "beard", + "belch", + "belcher", + "belt", + "blade", + "bleeder", + "boot", + "boots", + "braid", + "brand", + "breaker", + "breath", + "bringer", + "brow", + "buster", + "chain", + "chains", + "champion", + "chewer", + "cleaver", + "crag", + "crusher", + "drum", + "dust", + "earth", + "eater", + "edge", + "eye", + "fall", + "favor", + "feast", + "fight", + "fist", + "flayer", + "flow", + "force", + "forge", + "fury", + "gift", + "gore", + "grace", + "guard", + "hammer", + "hand", + "handle", + "head", + "heart", + "helm", + "hold", + "honor", + "horn", + "hunt", + "hunter", + "lord", + "mantle", + "march", + "mask", + "master", + "might", + "minder", + "pass", + "past", + "pride", + "reach", + "rest", + "ripper", + "rock", + "runner", + "slayer", + "slice", + "snapper", + "sorrow", + "spite", + "stand", + "stone", + "storm", + "strike", + "striker", + "tale", + "tamer", + "ward" + ] +} \ No newline at end of file diff --git a/data/dwarf.json b/data/dwarf.json new file mode 100644 index 0000000..3cf5a2d --- /dev/null +++ b/data/dwarf.json @@ -0,0 +1,547 @@ +{ + "nm1": [ + "Ad", + "Am", + "Arm", + "Baer", + "Daer", + "Bal", + "Ban", + "Bar", + "Bel", + "Ben", + "Ber", + "Bhal", + "Bhar", + "Bhel", + "Bram", + "Bran", + "Brom", + "Brum", + "Bun", + "Dal", + "Dar", + "Dol", + "Dul", + "Eb", + "Em", + "Erm", + "Far", + "Gal", + "Gar", + "Ger", + "Gim", + "Gral", + "Gram", + "Gran", + "Grem", + "Gren", + "Gril", + "Gry", + "Gul", + "Har", + "Hjal", + "Hjol", + "Hjul", + "Hor", + "Hul", + "Hur", + "Kar", + "Khar", + "Kram", + "Krom", + "Krum", + "Mag", + "Mal", + "Mel", + "Mor", + "Muir", + "Mur", + "Rag", + "Ran", + "Reg", + "Rot", + "Thal", + "Thar", + "Thel", + "Ther", + "Tho", + "Thor", + "Thul", + "Thur", + "Thy", + "Tor", + "Ty", + "Um", + "Urm", + "Von" + ], + "nm2": [ + "adin", + "bek", + "brek", + "dahr", + "dain", + "dal", + "dan", + "dar", + "dek", + "dir", + "dohr", + "dor", + "drak", + "dram", + "dren", + "drom", + "drum", + "drus", + "duhr", + "dur", + "dus", + "garn", + "gram", + "gran", + "grim", + "grom", + "gron", + "grum", + "grun", + "gurn", + "gus", + "iggs", + "kahm", + "kam", + "kohm", + "kom", + "kuhm", + "kum", + "kyl", + "man", + "mand", + "mar", + "mek", + "miir", + "min", + "mir", + "mond", + "mor", + "mun", + "mund", + "mur", + "mus", + "myl", + "myr", + "nam", + "nar", + "nik", + "nir", + "nom", + "num", + "nur", + "nus", + "nyl", + "rak", + "ram", + "ren", + "rig", + "rigg", + "rik", + "rim", + "rom", + "ron", + "rum", + "rus", + "ryl", + "tharm", + "tharn", + "thran", + "thrum", + "thrun" + ], + "nm3": [ + "An", + "Ar", + "Baer", + "Bar", + "Bel", + "Belle", + "Bon", + "Bonn", + "Braen", + "Bral", + "Bralle", + "Bran", + "Bren", + "Bret", + "Bril", + "Brille", + "Brol", + "Bron", + "Brul", + "Bryl", + "Brylle", + "Bryn", + "Bryt", + "Byl", + "Bylle", + "Daer", + "Dear", + "Dim", + "Ed", + "Ein", + "El", + "Gem", + "Ger", + "Gwan", + "Gwen", + "Gwin", + "Gwyn", + "Gym", + "Ing", + "Jen", + "Jenn", + "Jin", + "Jyn", + "Kait", + "Kar", + "Kat", + "Kath", + "Ket", + "Las", + "Lass", + "Les", + "Less", + "Lyes", + "Lys", + "Lyss", + "Maer", + "Maev", + "Mar", + "Mis", + "Mist", + "Myr", + "Mys", + "Myst", + "Naer", + "Nal", + "Nas", + "Nass", + "Nes", + "Nis", + "Nys", + "Raen", + "Ran", + "Red", + "Reyn", + "Run", + "Ryn", + "Sar", + "Sol", + "Tas", + "Taz", + "Tis", + "Tish", + "Tiz", + "Tor", + "Tys", + "Tysh" + ], + "nm4": [ + "belle", + "bera", + "delle", + "deth", + "dielle", + "dille", + "dish", + "dora", + "dryn", + "dyl", + "giel", + "glia", + "glian", + "gwyn", + "la", + "leen", + "leil", + "len", + "lin", + "linn", + "lyl", + "lyn", + "lynn", + "ma", + "mera", + "mora", + "mura", + "myl", + "myla", + "nan", + "nar", + "nas", + "nera", + "nia", + "nip", + "nis", + "niss", + "nora", + "nura", + "nyl", + "nys", + "nyss", + "ra", + "ras", + "res", + "ri", + "ria", + "rielle", + "rin", + "ris", + "ros", + "ryl", + "ryn", + "sael", + "selle", + "sora", + "syl", + "thel", + "thiel", + "tin", + "tyn", + "va", + "van", + "via", + "vian", + "waen", + "win", + "wyn", + "wynn" + ], + "nm5": [ + "b", + "br", + "c", + "d", + "dr", + "f", + "g", + "gl", + "gr", + "h", + "l", + "m", + "r", + "str", + "t", + "thr" + ], + "nm6": [ + "ae", + "a", + "e", + "o", + "u", + "a", + "e", + "o", + "u", + "a", + "e", + "o", + "u", + "a", + "e", + "o", + "u" + ], + "nm7": [ + "br", + "d", + "fd", + "h", + "k", + "lbr", + "ld", + "ll", + "mn", + "ng", + "nh", + "nk", + "r", + "rd", + "rth", + "tg", + "thg", + "zz" + ], + "nm8": [ + "a", + "e", + "i", + "o", + "u" + ], + "nm9": [ + "g", + "h", + "k", + "n", + "r", + "v" + ], + "nm10": [ + "a", + "a", + "e", + "e", + "i", + "o", + "u" + ], + "nm11": [ + "ck", + "g", + "hk", + "hr", + "k", + "ln", + "m", + "n", + "nn", + "r", + "rk", + "rr", + "rt" + ], + "nm12": [ + "battle", + "big", + "black", + "blood", + "bold", + "boulder", + "brave", + "brawn", + "bright", + "broad", + "bronze", + "brood", + "burrow", + "cold", + "dark", + "deep", + "drunk", + "even", + "ever", + "fire", + "first", + "flint", + "frost", + "frozen", + "giant", + "goblin", + "gold", + "golden", + "gray", + "great", + "half", + "hammer", + "hard", + "iron", + "keen", + "kind", + "last", + "light", + "loud", + "mad", + "marble", + "might", + "molten", + "mountain", + "silver", + "smug", + "stark", + "steel", + "stern", + "stone", + "storm", + "stout", + "strong", + "thunder", + "troll", + "true", + "wild" + ], + "nm13": [ + "ale", + "anvil", + "axe", + "back", + "bane", + "beard", + "belch", + "belt", + "blade", + "bleeder", + "blood", + "boot", + "boots", + "bottom", + "braid", + "branch", + "breaker", + "breath", + "brow", + "buster", + "delver", + "eye", + "eyes", + "fall", + "feast", + "finder", + "fist", + "fists", + "flight", + "force", + "forge", + "found", + "front", + "fury", + "gift", + "grace", + "grip", + "guard", + "hammer", + "hand", + "handle", + "head", + "heart", + "helm", + "hold", + "horn", + "kin", + "kind", + "kith", + "mane", + "mantle", + "mask", + "might", + "pass", + "past", + "pride", + "reach", + "rest", + "roar", + "rock", + "shaper", + "shield", + "song", + "stand", + "stone", + "storm", + "strike", + "tale", + "tankard", + "ward" + ] +} \ No newline at end of file diff --git a/data/eladrin.json b/data/eladrin.json new file mode 100644 index 0000000..1de5c4c --- /dev/null +++ b/data/eladrin.json @@ -0,0 +1,215 @@ +{ + "nm1": [ + "Ara", + "Aran", + "Ber", + "Bran", + "Cor", + "Cru", + "Da", + "Daye", + "Elro", + "Ere", + "Far", + "Fyla", + "Gal", + "Galin", + "Ha", + "Hor", + "Im", + "Ira", + "Ja", + "Jor", + "Kru", + "Kuo", + "Lan", + "Lic", + "Mar", + "Min", + "Nal", + "Nark", + "Ola", + "Otir", + "Pae", + "Pan", + "Qua", + "Quo", + "Rel", + "Riar", + "Sarn", + "Sove", + "Tav", + "Trin", + "Uri", + "Veth", + "Vic", + "Wal", + "Wrug", + "Xan", + "Yan", + "Yor", + "Zen", + "Zor" + ], + "nm2": [ + "aris", + "aster", + "baver", + "bin", + "card", + "corin", + "dan", + "darai", + "dartis", + "don", + "emin", + "erta", + "fis", + "fros", + "geon", + "grephor", + "heros", + "horn", + "ikul", + "iver", + "kris", + "kul", + "lias", + "liss", + "mendi", + "meral", + "mil", + "morn", + "neiros", + "nis", + "okas", + "oros", + "peiros", + "prath", + "ratra", + "reth", + "rian", + "rion", + "sirak", + "ster", + "thas", + "tihr", + "torin", + "urian", + "uvir", + "van", + "vis", + "wirn", + "worn", + "xeral", + "xis", + "ykos", + "yth", + "zeiros", + "zion" + ], + "nm3": [ + "Al", + "An", + "Anas", + "Be", + "Bri", + "Cae", + "Cyl", + "Dris", + "Dur", + "Eil", + "Ena", + "Fae", + "Fan", + "Gru", + "Gyl", + "Hen", + "Hyl", + "Illa", + "Ire", + "Jar", + "Jelen", + "Kai", + "Kora", + "Les", + "Lyv", + "Mag", + "Me", + "Nai", + "Neri", + "Ol", + "Ori", + "Pi", + "Prys", + "Qi", + "Que", + "Ri", + "Rol", + "Sa", + "Sha", + "Thei", + "Tri", + "Ul", + "Ura", + "Va", + "Vela", + "Wes", + "Wre", + "Xyr", + "Ylla", + "Zen" + ], + "nm4": [ + "bis", + "bynn", + "cahne", + "caryn", + "celle", + "cena", + "diel", + "dys", + "faera", + "fyra", + "glyn", + "grys", + "hanna", + "hyssa", + "kiries", + "kyrath", + "lenae", + "lenna", + "lyn", + "lynna", + "meiv", + "miris", + "mynis", + "nairra", + "neth", + "parys", + "prana", + "qirith", + "qis", + "raste", + "rastra", + "riele", + "rynna", + "sanna", + "shana", + "sys", + "thaea", + "tora", + "trianna", + "vara", + "viryn", + "vyre", + "wena", + "wyse", + "xana", + "xis", + "yana", + "yeira", + "zane", + "zora" + ] +} \ No newline at end of file diff --git a/data/elf.json b/data/elf.json new file mode 100644 index 0000000..e2e19df --- /dev/null +++ b/data/elf.json @@ -0,0 +1,578 @@ +{ + "nm1": [ + "Ad", + "Ae", + "Bal", + "Bei", + "Car", + "Cra", + "Dae", + "Dor", + "El", + "Ela", + "Er", + "Far", + "Fen", + "Gen", + "Glyn", + "Hei", + "Her", + "Ian", + "Ili", + "Kea", + "Kel", + "Leo", + "Lu", + "Mira", + "Mor", + "Nae", + "Nor", + "Olo", + "Oma", + "Pa", + "Per", + "Pet", + "Qi", + "Qin", + "Ralo", + "Ro", + "Sar", + "Syl", + "The", + "Tra", + "Ume", + "Uri", + "Va", + "Vir", + "Waes", + "Wran", + "Yel", + "Yin", + "Zin", + "Zum" + ], + "nm2": [ + "balar", + "beros", + "can", + "ceran", + "dan", + "dithas", + "faren", + "fir", + "geiros", + "golor", + "hice", + "horn", + "jeon", + "jor", + "kas", + "kian", + "lamin", + "lar", + "len", + "maer", + "maris", + "menor", + "myar", + "nan", + "neiros", + "nelis", + "norin", + "peiros", + "petor", + "qen", + "quinal", + "ran", + "ren", + "ric", + "ris", + "ro", + "salor", + "sandoral", + "toris", + "tumal", + "valur", + "ven", + "warin", + "wraek", + "xalim", + "xidor", + "yarus", + "ydark", + "zeiros", + "zumin" + ], + "nm3": [ + "Ad", + "Ara", + "Bi", + "Bry", + "Cai", + "Chae", + "Da", + "Dae", + "Eil", + "En", + "Fa", + "Fae", + "Gil", + "Gre", + "Hele", + "Hola", + "Iar", + "Ina", + "Jo", + "Key", + "Kris", + "Lia", + "Lora", + "Mag", + "Mia", + "Neri", + "Ola", + "Ori", + "Phi", + "Pres", + "Qi", + "Qui", + "Rava", + "Rey", + "Sha", + "Syl", + "Tor", + "Tris", + "Ula", + "Uri", + "Val", + "Ven", + "Wyn", + "Wysa", + "Xil", + "Xyr", + "Yes", + "Ylla", + "Zin", + "Zyl" + ], + "nm4": [ + "banise", + "bella", + "caryn", + "cyne", + "di", + "dove", + "fiel", + "fina", + "gella", + "gwyn", + "hana", + "harice", + "jyre", + "kalyn", + "krana", + "lana", + "lee", + "leth", + "lynn", + "moira", + "mys", + "na", + "nala", + "phine", + "phyra", + "qirelle", + "ra", + "ralei", + "rel", + "rie", + "rieth", + "rona", + "rora", + "roris", + "satra", + "stina", + "sys", + "thana", + "thyra", + "tris", + "varis", + "vyre", + "wenys", + "wynn", + "xina", + "xisys", + "ynore", + "yra", + "zana", + "zorwyn" + ], + "nm5": [ + "", + "", + "", + "b", + "c", + "d", + "dr", + "f", + "fl", + "g", + "h", + "k", + "l", + "m", + "n", + "r", + "qu", + "s", + "sh", + "t", + "th", + "v", + "w", + "x", + "y" + ], + "nm6": [ + "ae", + "ie", + "ia", + "ei", + "ey", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u" + ], + "nm7": [ + "dr", + "l", + "l", + "ld", + "ldr", + "ll", + "lph", + "lt", + "lth", + "m", + "n", + "ndr", + "nn", + "nt", + "ph", + "r", + "r", + "rd", + "rn", + "s", + "sh", + "st", + "str", + "th", + "thr", + "v" + ], + "nm8": [ + "a", + "e", + "i", + "o" + ], + "nm9": [ + "dr", + "lk", + "ndr", + "nthr", + "sc", + "st", + "str", + "thr", + "c", + "h", + "l", + "m", + "n", + "nn", + "ph", + "r", + "rr", + "s", + "ss", + "v", + "x" + ], + "nm10": [ + "ii", + "ie", + "aea", + "ia", + "ua", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o" + ], + "nm11": [ + "", + "", + "", + "", + "", + "l", + "n", + "nn", + "nt", + "r", + "s", + "sh", + "th" + ], + "nm12": [ + "alder", + "amber", + "ash", + "aspen", + "autumn", + "azure", + "beech", + "birch", + "blue", + "bold", + "bronze", + "cedar", + "crimson", + "dawn", + "dew", + "diamond", + "dusk", + "eager", + "elder", + "elm", + "ember", + "even", + "fall", + "far", + "feather", + "fir", + "flower", + "fog", + "forest", + "gem", + "gold", + "green", + "hazel", + "light", + "lunar", + "mist", + "moon", + "moss", + "night", + "oak", + "oaken", + "ocean", + "poplar", + "rain", + "rapid", + "raven", + "sage", + "shadow", + "silent", + "silver", + "spark", + "spirit", + "spring", + "star", + "still", + "stone", + "summer", + "sun", + "swift", + "wild", + "willow", + "wind", + "winter", + "wood" + ], + "nm13": [ + "beam", + "bell", + "birth", + "blossom", + "breath", + "breeze", + "brook", + "cloud", + "crown", + "dew", + "dream", + "dreamer", + "fall", + "fate", + "flight", + "flow", + "flower", + "fond", + "gaze", + "gazer", + "gift", + "gleam", + "grove", + "guard", + "heart", + "heel", + "hold", + "kind", + "light", + "mane", + "might", + "mind", + "moon", + "path", + "petal", + "pride", + "rest", + "river", + "seeker", + "sense", + "shadow", + "shard", + "shine", + "singer", + "smile", + "song", + "spark", + "spell", + "spirit", + "star", + "vale", + "walker", + "watcher", + "whisper", + "wish" + ], + "nm14": [ + "br", + "ph", + "th", + "tr", + "c", + "d", + "f", + "g", + "j", + "k", + "l", + "m", + "n", + "p", + "r", + "s", + "t", + "v", + "w", + "z", + "", + "", + "", + "" + ], + "nm15": [ + "ae", + "ay", + "oe", + "ue", + "ai", + "ia", + "y", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o" + ], + "nm16": [ + "k", + "l", + "ll", + "m", + "n", + "nn", + "r" + ], + "nm17": [ + "a", + "i" + ], + "nm18": [ + "ll", + "ng", + "nn", + "th", + "rn", + "l", + "m", + "n", + "r", + "s", + "", + "" + ] +} \ No newline at end of file diff --git a/data/fairy.json b/data/fairy.json new file mode 100644 index 0000000..510cf86 --- /dev/null +++ b/data/fairy.json @@ -0,0 +1,1359 @@ +{ + "nm1": [ + "Ad", + "Ae", + "Bal", + "Bei", + "Car", + "Cra", + "Dae", + "Dor", + "El", + "Ela", + "Er", + "Far", + "Fen", + "Gen", + "Glyn", + "Hei", + "Her", + "Ian", + "Ili", + "Kea", + "Kel", + "Leo", + "Lu", + "Mira", + "Mor", + "Nae", + "Nor", + "Olo", + "Oma", + "Pa", + "Per", + "Pet", + "Qi", + "Qin", + "Ralo", + "Ro", + "Sar", + "Syl", + "The", + "Tra", + "Ume", + "Uri", + "Va", + "Vir", + "Waes", + "Wran", + "Yel", + "Yin", + "Zin", + "Zum" + ], + "nm2": [ + "balar", + "beros", + "can", + "ceran", + "dan", + "dithas", + "faren", + "fir", + "geiros", + "golor", + "hice", + "horn", + "jeon", + "jor", + "kas", + "kian", + "lamin", + "lar", + "len", + "maer", + "maris", + "menor", + "myar", + "nan", + "neiros", + "nelis", + "norin", + "peiros", + "petor", + "qen", + "quinal", + "ran", + "ren", + "ric", + "ris", + "ro", + "salor", + "sandoral", + "toris", + "tumal", + "valur", + "ven", + "warin", + "wraek", + "xalim", + "xidor", + "yarus", + "ydark", + "zeiros", + "zumin" + ], + "nm3": [ + "Ad", + "Ara", + "Bi", + "Bry", + "Cai", + "Chae", + "Da", + "Dae", + "Eil", + "En", + "Fa", + "Fae", + "Gil", + "Gre", + "Hele", + "Hola", + "Iar", + "Ina", + "Jo", + "Key", + "Kris", + "Lia", + "Lora", + "Mag", + "Mia", + "Neri", + "Ola", + "Ori", + "Phi", + "Pres", + "Qi", + "Qui", + "Rava", + "Rey", + "Sha", + "Syl", + "Tor", + "Tris", + "Ula", + "Uri", + "Val", + "Ven", + "Wyn", + "Wysa", + "Xil", + "Xyr", + "Yes", + "Ylla", + "Zin", + "Zyl" + ], + "nm4": [ + "banise", + "bella", + "caryn", + "cyne", + "di", + "dove", + "fiel", + "fina", + "gella", + "gwyn", + "hana", + "harice", + "jyre", + "kalyn", + "krana", + "lana", + "lee", + "leth", + "lynn", + "moira", + "mys", + "na", + "nala", + "phine", + "phyra", + "qirelle", + "ra", + "ralei", + "rel", + "rie", + "rieth", + "rona", + "rora", + "roris", + "satra", + "stina", + "sys", + "thana", + "thyra", + "tris", + "varis", + "vyre", + "wenys", + "wynn", + "xina", + "xisys", + "ynore", + "yra", + "zana", + "zorwyn" + ], + "nm5": [ + "A", + "Ae", + "Ar", + "Arga", + "Au", + "Be", + "Ben", + "Bene", + "Ble", + "Blei", + "Bra", + "Bre", + "Bri", + "Brio", + "Bryo", + "Ca", + "Can", + "Cara", + "Cas", + "Cen", + "Cin", + "Cle", + "Co", + "Con", + "Cor", + "Da", + "De", + "Deme", + "Fre", + "Freo", + "Frio", + "Ga", + "Gau", + "Ge", + "Ger", + "Go", + "Gri", + "Gry", + "Gu", + "Gur", + "Gwa", + "He", + "Hed", + "Hu", + "Hum", + "Ia", + "Il", + "In", + "Iu", + "Ja", + "Jo", + "Ke", + "Ken", + "Ko", + "Lo", + "Lowe", + "Ma", + "Mae", + "Mas", + "Me", + "Mel", + "Mer", + "Mi", + "Mo", + "Mor", + "Mue", + "My", + "Pa", + "Pe", + "Per", + "Ra", + "Re", + "Ru", + "Rua", + "Se", + "Sele", + "Te", + "Tele", + "Tew", + "Tree", + "Tri", + "We", + "Wel", + "Wen", + "Wi", + "Win", + "Wu", + "Wur", + "Wy", + "Ya", + "Ye", + "Yl" + ], + "nm6": [ + "bri", + "cant", + "cencor", + "cohn", + "con", + "cor", + "cryn", + "cum", + "dan", + "der", + "dern", + "dhek", + "dic", + "dilic", + "dis", + "dok", + "dret", + "drod", + "dros", + "fagan", + "fra", + "fure", + "gan", + "gent", + "gethen", + "ghal", + "girn", + "gor", + "guallon", + "gur", + "gustel", + "lan", + "lic", + "loc", + "lon", + "louen", + "marh", + "men", + "menoc", + "min", + "mo", + "moere", + "monoc", + "moyre", + "muyre", + "myn", + "nac", + "nan", + "nci", + "neder", + "nesek", + "noac", + "noc", + "nok", + "radok", + "rael", + "ran", + "redis", + "rek", + "ren", + "rentyn", + "ret", + "riant", + "rient", + "rit", + "rok", + "ron", + "ryn", + "sek", + "sen", + "sian", + "stel", + "tan", + "tanet", + "thael", + "thek", + "thien", + "thion", + "thon", + "thrit", + "thyen", + "tigirn", + "tok", + "trec", + "tyn", + "wallon", + "wan", + "wen", + "wyn" + ], + "nm7": [ + "A", + "Ae", + "Anau", + "Anni", + "As", + "Be", + "Bea", + "Ber", + "Bo", + "Bria", + "Cee", + "Cei", + "Cein", + "Che", + "Con", + "De", + "Deme", + "Dero", + "E", + "Ele", + "Elo", + "Em", + "En", + "Ese", + "Ewe", + "Fua", + "Fuan", + "Gla", + "Gloi", + "Gloiu", + "Gue", + "Guen", + "Gwen", + "Ia", + "Je", + "Jene", + "Jo", + "Ka", + "Kel", + "Kele", + "Ker", + "Kere", + "La", + "Lamo", + "Lo", + "Lowe", + "Ma", + "Me", + "Mel", + "Mo", + "Mor", + "Morve", + "Ne", + "Nes", + "No", + "O", + "On", + "Ou", + "Our", + "Pa", + "Pas", + "Pro", + "Ro", + "Ru", + "Se", + "Sena", + "So", + "Sowe", + "Ste", + "Ta", + "Tal", + "Tam", + "Tama", + "Tan", + "Te", + "Tre", + "Tree", + "True", + "We", + "Wen", + "Wue", + "Wuen", + "Y", + "Ys" + ], + "nm8": [ + "cen", + "cenedl", + "der", + "dhuil", + "doc", + "duil", + "dylyc", + "fer", + "gen", + "gereth", + "guen", + "guetel", + "guled", + "la", + "led", + "len", + "lewen", + "lin", + "lis", + "luen", + "lyn", + "lynen", + "mara", + "med", + "mon", + "morna", + "na", + "nath", + "nedl", + "neret", + "net", + "nik", + "nol", + "rec", + "rel", + "reth", + "rezen", + "rith", + "rowen", + "sa", + "saba", + "seld", + "sella", + "sen", + "sin", + "stren", + "styl", + "syn", + "teilin", + "tel", + "ten", + "wanet", + "wean", + "wen", + "wena", + "wenna", + "wetel", + "wuen", + "wynn", + "zen" + ], + "nm9": [ + "Acorn", + "Aed", + "Aeden", + "Alaneo", + "Albedo", + "Ali", + "Almond", + "Aloha", + "Anthurium", + "Aodh", + "Aphid", + "Apogee", + "Aqua", + "Ash", + "Astro", + "Aven", + "Avo", + "Axis", + "Badger", + "Barley", + "Basil", + "Bear", + "Berry", + "Bim", + "Birch", + "Blathnat", + "Blaze", + "Bracken", + "Bramble", + "Briar", + "Brock", + "Bud", + "Bumble", + "Calico", + "Canyon", + "Caraway", + "Carpus", + "Carrot", + "Cedar", + "Christopher", + "Cinnamon", + "Cirro", + "Cirrus", + "Citron", + "Cloud", + "Coconut", + "Comet", + "Cookie", + "Cosmo", + "Crator", + "Cricket", + "Daybreak", + "Dew", + "Dewdrop", + "Diaspor", + "Dragonfly", + "Drake", + "Dune", + "Dusk", + "Earth", + "Echo", + "Elliot", + "Elm", + "Finch", + "Firo", + "Flame", + "Flamo", + "Flare", + "Flax", + "Flint", + "Flix", + "Florian", + "Fox", + "Foxglove", + "Freddie", + "Frost", + "Frostbite", + "Ginko", + "Happy", + "Harbor", + "Harley", + "Helio", + "Herb", + "Indi", + "Indigo", + "Jamie", + "Jarrah", + "Jeremy", + "Karma", + "Koko", + "Lake", + "Lapis", + "Lark", + "Laurel", + "Lazuli", + "Lemony", + "Light", + "Lightning", + "Liri", + "Lucky", + "Luke", + "Magpie", + "Mahogany", + "Mango", + "Marlie", + "Meadow", + "Mercury", + "Midnight", + "Miles", + "Mitah", + "Moon", + "Moonbeam", + "Moonbean", + "Moptop", + "Morel", + "Mountain", + "Mulberry", + "Nebula", + "Nelly", + "Newt", + "Nightfall", + "Nightshade", + "Nimbus", + "North", + "Nova", + "Novus", + "Nutmeg", + "Nyx", + "Oak", + "Ocean", + "Oleander", + "Oliver", + "Onyx", + "Oregano", + "Pandora", + "Peanut", + "Pecan", + "Pepper", + "Peridot", + "Persimmon", + "Petal", + "Pine", + "Pinecone", + "Pistachio", + "Plume", + "Poppy", + "Pyro", + "Quicksilver", + "Quinn", + "Rain", + "Raine", + "Reef", + "Rhubarb", + "Ridge", + "Robbie", + "Robin", + "Rock", + "Rocky", + "Saffron", + "Scorpia", + "Shade", + "Silver", + "Sky", + "Skylark", + "Smokey", + "Sneezy", + "Snow", + "Snowdrop", + "Snowflake", + "Spark", + "Spice", + "Spring", + "Sprinkle", + "Sprinkles", + "Stardust", + "Starfish", + "Stargazer", + "Stone", + "Storm", + "Stormy", + "Strombo", + "Sunbeam", + "Sundew", + "Sunrise", + "Sunset", + "Tadpole", + "Tangy", + "Tarragon", + "Thicket", + "Thistle", + "Tidal", + "Tiger", + "Timber", + "Timothy", + "Tiny", + "Tori", + "Trevan", + "Trumpet", + "Turnip", + "Twig", + "Walnut", + "Willow", + "Winnie", + "Wolf", + "Woods", + "Zephyr" + ], + "nm10": [ + "Pervinca", + "Hiedra", + "Vinca", + "Dandelia", + "Dandelion", + "Clavelina", + "Clavellina", + "Vulparia", + "Luparia", + "Belladonna", + "Passiflora", + "Pimpinella", + "Eupherbia", + "Poinsetia", + "Rafflesia", + "Phyre", + "Abeyance", + "Abigail", + "Abyss", + "Acacia", + "Adriata", + "Alcyone", + "Alexa", + "Alexandra", + "Alexi", + "Alexia", + "Ali", + "Alina", + "Allium", + "Almond", + "Aloha", + "Alyssum", + "Amaltheia", + "Amantha", + "Amaryllis", + "Amber", + "Amethyst", + "Amode", + "Amy", + "Anastasia", + "Anemone", + "Angel", + "Annie", + "Apple", + "Apricot", + "April", + "Aqua", + "Aria", + "Arianna", + "Arlette", + "Ashley", + "Aspen", + "Asphodel", + "Aurora", + "Autumn", + "Ayanna", + "Azalea", + "Azore", + "Badger", + "Barbara", + "Bayberry", + "Bedra", + "Begonia", + "Bellflower", + "Berline", + "Beryl", + "Bethany", + "Betsy", + "Betty", + "Bianca", + "Bim", + "Birch", + "Birdy", + "Blodwen", + "Blooma", + "Blossom", + "Bluebell", + "Bonnie", + "Breeze", + "Breezy", + "Briar", + "Briny", + "Bryla", + "Bumble", + "Buttercup", + "Cadmi", + "Calico", + "Caliphe", + "Calla", + "Camelia", + "Camellia", + "Camie", + "Camille", + "Candala", + "Canyon", + "Caraway", + "Carnelia", + "Carrie", + "Carrot", + "Cassia", + "Cassie", + "Cayenne", + "Cecil", + "Cecile", + "Celeste", + "Celestia", + "Chaldera", + "Chante", + "Charity", + "Charlotte", + "Chasma", + "Cherry", + "Chert", + "Chestnut", + "Chickadee", + "Chipmunk", + "Chloe", + "Chlora", + "Christal", + "Cinder", + "Cinnamon", + "Cintrine", + "Citron", + "Cleo", + "Cloud", + "Clove", + "Clover", + "Coconut", + "Confiance", + "Cookie", + "Coral", + "Coriander", + "Cornflower", + "Corona", + "Cowrie", + "Coyote", + "Crabapple", + "Cranberry", + "Cricket", + "Crystal", + "Cupcake", + "Cypress", + "Daffodil", + "Dahlia", + "Daisy", + "Dalila", + "Dandelion", + "Daphne", + "Darla", + "Dawn", + "Daybreak", + "Daylily", + "Delia", + "Desily", + "Dew", + "Dewdrop", + "Dey", + "Diamond", + "Didi", + "Dill", + "Dilys", + "Dina", + "Dolly", + "Dragonfly", + "Earth", + "Ebbie", + "Ebony", + "Elaina", + "Eli", + "Ella", + "Elle", + "Elliot", + "Elm", + "Elma", + "Elva", + "Ember", + "Emerald", + "Emily", + "Emma", + "Erissa", + "Estrella", + "Evangeline", + "Eve", + "Evening", + "Evie", + "Ezra", + "Faith", + "Fantasia", + "Fauna", + "Faye", + "Fee", + "Fern", + "Feu", + "Fiery", + "Fifi", + "Flame", + "Flamo", + "Flare", + "Flax", + "Flora", + "Floura", + "Forsythia", + "Frances", + "Frangi", + "Freesia", + "Frost", + "Galaxa", + "Galaxy", + "Gardenia", + "Garnet", + "Gem", + "Genevieve", + "Gerania", + "Gerbera", + "Ginger", + "Ginny", + "Gloria", + "Gloriosa", + "Grace", + "Grevillea", + "Grove", + "Gullie", + "Gypsum", + "Happy", + "Harbor", + "Harley", + "Harmony", + "Hazel", + "Heather", + "Heaven", + "Heidi", + "Helen", + "Helia", + "Helio", + "Heliodor", + "Herb", + "Hibiscus", + "Hickoy", + "Holly", + "Hollyann", + "Hollyhock", + "Honey", + "Hope", + "Horizon", + "Hurricane", + "Hyacinth", + "Hydrangea", + "Ignea", + "Igni", + "Indigo", + "Infinity", + "Ionia", + "Iridia", + "Iris", + "Isabel", + "Isabelle", + "Island", + "Isle", + "Ivory", + "Ivy", + "Jada", + "Jade", + "Jamie", + "Jane", + "Jasmine", + "Jayla", + "Jeanie", + "Jenny", + "Jessamine", + "Jewel", + "Jewels", + "Jillian", + "Joanna", + "Johanna", + "Joy", + "Julianne", + "Julie", + "June", + "Juniper", + "Karina", + "Karma", + "Kate", + "Kayleighe", + "Kaylor", + "Kelly", + "Kenzie", + "Kesiray", + "Kiki", + "Kiwi", + "Kobi", + "Koko", + "Kyanne", + "Kylee", + "Kyra", + "Labivia", + "Labyrinth", + "Lake", + "Lala", + "Lantana", + "Lapis", + "Laura", + "Laurelai", + "Lauren", + "Lavender", + "Layla", + "Lazuli", + "Leaf", + "Leeta", + "Lella", + "Lemony", + "Lenora", + "Levia", + "Liatris", + "Libby", + "Lichen", + "Light", + "Lila", + "Lilac", + "Lilah", + "Lily", + "Liri", + "Little", + "Liza", + "Lizzy", + "Lorella", + "Lori", + "Loue", + "Lucia", + "Lucky", + "Lucy", + "Lula", + "Lulu", + "Lumiona", + "Luna", + "Lynn", + "Lynne", + "Maddie", + "Maeve", + "Maga", + "Magenta", + "Magna", + "Magnola", + "Magnolia", + "Magpie", + "Mahogany", + "Maie", + "Manga", + "Mango", + "Maple", + "Marcasite", + "Marceline", + "Margo", + "Marigold", + "Marin", + "Marina", + "Marlie", + "Mary", + "May", + "Meadow", + "Meer", + "Melanie", + "Melody", + "Meri", + "Meridian", + "Mia", + "Midnight", + "Mildread", + "Milkweed", + "Minerva", + "Miranda", + "Misha", + "Misty", + "Mivian", + "Molly", + "Moon", + "Moonbeam", + "Moonbean", + "Mora", + "Mossy", + "Mudpie", + "Mulberry", + "Muriel", + "Mythia", + "Nastur", + "Nature", + "Nautila", + "Nebula", + "Nectarine", + "Nelly", + "Newt", + "Nightfall", + "Nightshade", + "Nimbus", + "Nina", + "Nissa", + "Nora", + "Nutmeg", + "Nyphadora", + "Nyra", + "Oceana", + "Octavia", + "Olive", + "Olivia", + "Opal", + "Ora", + "Orange", + "Orchid", + "Oreal", + "Oregano", + "Oriole", + "Palmera", + "Pandora", + "Paprika", + "Parsley", + "Peach", + "Peachy", + "Peanut", + "Pearl", + "Pecan", + "Penelope", + "Peoni", + "Pepper", + "Percula", + "Peridot", + "Petal", + "Petunia", + "Phira", + "Phoebe", + "Pine", + "Pineapple", + "Pinecone", + "Pluma", + "Plume", + "Plumeria", + "Poison", + "Polly", + "Poplar", + "Poppy", + "Posey", + "Posy", + "Prairie", + "Primrose", + "Prinna", + "Prise", + "Prudence", + "Pumpkin", + "Purple", + "Pyro", + "Rachel", + "Rain", + "Rainbow", + "Raine", + "Rainy", + "Raven", + "Rebutia", + "Relle", + "Rhoda", + "Rhodie", + "Rhonda", + "Rhubarb", + "Rill", + "River", + "Robin", + "Rola", + "Rore", + "Rosa", + "Rosalind", + "Rose", + "Rosemary", + "Rosepetal", + "Rosie", + "Ruby", + "Sadie", + "Saffron", + "Sage", + "Sahara", + "Saira", + "Salle", + "Sally", + "Sandy", + "Sapphire", + "Sassafras", + "Savannah", + "Scarlet", + "Scorpia", + "Sea", + "Seaweed", + "Sela", + "Selene", + "Selenia", + "Sequoia", + "Serena", + "Serendipity", + "Shade", + "Shanna", + "Shayleigh", + "Shelly", + "Shiny", + "Shyla", + "Sienna", + "Silhouette", + "Silver", + "Sivelle", + "Sky", + "Skyler", + "Sneezy", + "Snow", + "Snowdrop", + "Snowflake", + "Solara", + "Soleil", + "Sophie", + "Sorrell", + "Spark", + "Sparkla", + "Spectra", + "Spice", + "Spirala", + "Spore", + "Spring", + "Sprinkle", + "Sprinkles", + "Spruce", + "Star", + "Stardust", + "Starfish", + "Stargazer", + "Stella", + "Stormy", + "Strawberri", + "Strawberry", + "Sue", + "Sugar", + "Sulcore", + "Summer", + "Sun", + "Sunbeam", + "Sundew", + "Sunflower", + "Sunlight", + "Sunny", + "Sunrise", + "Sunset", + "Sunshine", + "Swan", + "Tamara", + "Tangy", + "Tansy", + "Tara", + "Tasi", + "Tempest", + "Tess", + "Tessa", + "Thallia", + "Thistle", + "Tidal", + "Tiger", + "Tinder", + "Tinkerbell", + "Tiny", + "Topaz", + "Topiary", + "Tori", + "Tourmaline", + "Tournant", + "Treva", + "Trinity", + "Trish", + "Tulip", + "Turnip", + "Turquoise", + "Twig", + "Twilight", + "Tyra", + "Urchin", + "Valorie", + "Vanessa", + "Velocity", + "Venus", + "Verey", + "Vickie", + "Victoria", + "Vilotta", + "Viola", + "Violet", + "Vivi", + "Wallflower", + "Walnut", + "Waterfall", + "Wave", + "West", + "Whirl", + "Willow", + "Wind", + "Windy", + "Winnie", + "Winter", + "Wispa", + "Woods", + "Wrassey", + "Wren", + "Xenops", + "Yasmine", + "Yavia", + "Yitri", + "Yucca" + ] +} \ No newline at end of file diff --git a/data/genasi.json b/data/genasi.json new file mode 100644 index 0000000..5f0b722 --- /dev/null +++ b/data/genasi.json @@ -0,0 +1,379 @@ +{ + "nm1": [ + "Ablaze", + "Alight", + "Ardor", + "Ardour", + "Arson", + "Ash", + "Austral", + "Bake", + "Beacon", + "Blaze", + "Blight", + "Boil", + "Bonfire", + "Brand", + "Broil", + "Burn", + "Calcine", + "Candle", + "Cauterize", + "Char", + "Charcoal", + "Cinder", + "Coal", + "Combust", + "Conflagration", + "Cremate", + "Crisp", + "Dante", + "Dantean", + "Ember", + "Enkindle", + "Explosion", + "Fervor", + "Fever", + "Fiery", + "Flame", + "Flare", + "Flash", + "Flicker", + "Flux", + "Forge", + "Frizzle", + "Fry", + "Fuego", + "Fuel", + "Fume", + "Furnace", + "Glare", + "Gleam", + "Glint", + "Glow", + "Grill", + "Heat", + "Hell", + "Hellfire", + "Hot", + "Igneous", + "Ignite", + "Ignition", + "Incendiary", + "Incinerate", + "Infernal", + "Inferno", + "Kiln", + "Kindle", + "Lantern", + "Lava", + "Light", + "Lit", + "Magma", + "Melt", + "Nether", + "Oven", + "Parch", + "Phoenix", + "Piping", + "Pyre", + "Pyro", + "Roast", + "Scald", + "Scorch", + "Scoria", + "Sear", + "Seethe", + "Shine", + "Singe", + "Sizzle", + "Smoke", + "Smolder", + "Soot", + "Spark", + "Sultry", + "Sun", + "Swelter", + "Thermal", + "Thermo", + "Tinder", + "Toast", + "Torch", + "Torrid", + "Volcano", + "Warmth", + "Wildfire", + "Wither" + ], + "nm2": [ + "Agua", + "Aqua", + "Azure", + "Basin", + "Bath", + "Bathe", + "Beck", + "Bore", + "Branch", + "Brine", + "Brook", + "Cleanse", + "Course", + "Creek", + "Current", + "Dabble", + "Damp", + "Deluge", + "Dew", + "Dewdrop", + "Douse", + "Downpour", + "Drain", + "Drench", + "Drift", + "Drip", + "Drizzle", + "Drop", + "Droplet", + "Drown", + "Eagre", + "Estuary", + "Expanse", + "Flood", + "Flow", + "Flux", + "Fog", + "Fountain", + "Geyser", + "Gush", + "Hose", + "Hydra", + "Hydrogen", + "Influx", + "Jet", + "Lagoon", + "Lake", + "Lakelet", + "Liquid", + "Mere", + "Mist", + "Monsoon", + "Neptune", + "Ocean", + "Paddle", + "Plash", + "Plunge", + "Pond", + "Pool", + "Precip", + "Puddle", + "Quagmire", + "Rain", + "Rill", + "Rinse", + "Ripple", + "River", + "Rivulet", + "Run", + "Runnel", + "Rush", + "Sea", + "Seiche", + "Shower", + "Soak", + "Spatter", + "Splash", + "Spout", + "Spring", + "Sprinkle", + "Storm", + "Stream", + "Streamlet", + "Surf", + "Surge", + "Swish", + "Tear", + "Teardrop", + "Tempest", + "Tidal", + "Tide", + "Torrent", + "Tributary", + "Tsunami", + "Typhoon", + "Vapor", + "Wash", + "Wave", + "Well", + "Wet" + ], + "nm3": [ + "Adamant", + "Agate", + "Alabaster", + "Amethyst", + "Azurite", + "Basalt", + "Bedrock", + "Block", + "Boulder", + "Brick", + "Callous", + "Citrine", + "Clay", + "Cliff", + "Cobble", + "Cobblestone", + "Crag", + "Crystal", + "Dense", + "Diamond", + "Emerald", + "Flint", + "Fossil", + "Fossilstone", + "Garnet", + "Gem", + "Geo", + "Geode", + "Granite", + "Gravel", + "Grime", + "Ground", + "Hill", + "Hunk", + "Ingot", + "Jade", + "Jewel", + "Lapis", + "Lazuli", + "Limestone", + "Lodge", + "Lump", + "Malachite", + "Marble", + "Marmoreal", + "Mason", + "Masonry", + "Mineral", + "Monolith", + "Moonstone", + "Mountain", + "Nugget", + "Obsidian", + "Onyx", + "Opal", + "Ore", + "Pebble", + "Pellet", + "Peridot", + "Precious", + "Quarry", + "Quartz", + "Quartzite", + "Rock", + "Rocky", + "Rough", + "Rubble", + "Ruby", + "Rugged", + "Sand", + "Sandstone", + "Sapphire", + "Sediment", + "Shelf", + "Slab", + "Slate", + "Soapstone", + "Solid", + "Spinel", + "Stone", + "Stony", + "Sturdy", + "Terra", + "Tile", + "Topaz", + "Travertine", + "Turf", + "Umber", + "Wedge", + "Zircon" + ], + "nm4": [ + "Aerate", + "Aerial", + "Air", + "Ascend", + "Atmosphere", + "Aura", + "Aviate", + "Azure", + "Blast", + "Blow", + "Breath", + "Breeze", + "Celeste", + "Celestial", + "Chinook", + "Cruise", + "Current", + "Cyclone", + "Draft", + "Drift", + "Eddy", + "Empyrean", + "Fan", + "Float", + "Flow", + "Flurry", + "Flute", + "Flutter", + "Fly", + "Funnel", + "Gale", + "Gasp", + "Glide", + "Gust", + "Heave", + "Heaven", + "Hiss", + "Hover", + "Hurricane", + "Lift", + "Mistral", + "Murmur", + "Oxygen", + "Ozone", + "Pipe", + "Pneumatic", + "Puff", + "Rise", + "Sail", + "Shriek", + "Sigh", + "Sky", + "Soar", + "Squall", + "Storm", + "Stratosphere", + "Surge", + "Tempest", + "Tornado", + "Troposphere", + "Tumult", + "Turbine", + "Turbulence", + "Twister", + "Vent", + "Waft", + "Wheeze", + "Whiff", + "Whirl", + "Whirlwind", + "Whisk", + "Whistle", + "Wind", + "Wing", + "Zephyr" + ] +} \ No newline at end of file diff --git a/data/githyanki.json b/data/githyanki.json new file mode 100644 index 0000000..7870ff2 --- /dev/null +++ b/data/githyanki.json @@ -0,0 +1,223 @@ +{ + "nm1": [ + "", + "", + "d", + "g", + "j", + "k", + "l", + "q", + "r", + "tr", + "v", + "vr", + "x" + ], + "nm2": [ + "a'a", + "'a'", + "'a'a", + "y", + "a", + "e", + "i", + "o", + "y", + "a", + "e", + "i", + "o", + "y", + "a", + "e", + "i", + "o" + ], + "nm3": [ + "d", + "k", + "l", + "m", + "n", + "p", + "r", + "s" + ], + "nm4": [ + "'i'", + "'a'", + "'a'a", + "a", + "i", + "o", + "a", + "i", + "o", + "a", + "i", + "o" + ], + "nm5": [ + "d", + "l", + "ld", + "lr", + "m", + "n", + "nd", + "r", + "rd" + ], + "nm6": [ + "aa", + "ai", + "a", + "a", + "o", + "u", + "a", + "a", + "o", + "u", + "a", + "a", + "o", + "u", + "a", + "a", + "o", + "u" + ], + "nm7": [ + "c", + "n", + "s", + "th", + "n", + "s", + "th" + ], + "nm8": [ + "b'l", + "b'n", + "s'r", + "v'n", + "", + "", + "", + "f", + "j", + "p", + "q", + "s", + "v", + "y", + "z", + "f", + "j", + "p", + "q", + "s", + "v", + "y", + "z", + "f", + "j", + "p", + "q", + "s", + "v", + "y", + "z" + ], + "nm9": [ + "aa", + "ai", + "a", + "e", + "i", + "a", + "e", + "i", + "a", + "e", + "i", + "a", + "e", + "i" + ], + "nm10": [ + "h'z", + "n'l", + "r'r", + "dr", + "gr", + "l", + "ll", + "lr", + "mr", + "n", + "nd", + "r", + "rr", + "rst", + "ss", + "str", + "tr" + ], + "nm11": [ + "a", + "e", + "u" + ], + "nm12": [ + "d", + "dr", + "l", + "lz", + "n", + "s", + "sr", + "r", + "rl", + "rz", + "z" + ], + "nm13": [ + "i'i", + "'i'", + "oo", + "y", + "a", + "e", + "i", + "y", + "a", + "e", + "i", + "y", + "a", + "e", + "i", + "y", + "a", + "e", + "i", + "y", + "a", + "e", + "i", + "u", + "u", + "u" + ], + "nm14": [ + "", + "", + "g", + "l", + "r", + "th" + ] +} \ No newline at end of file diff --git a/data/githzerai.json b/data/githzerai.json new file mode 100644 index 0000000..5c2d01e --- /dev/null +++ b/data/githzerai.json @@ -0,0 +1,265 @@ +{ + "nm1": [ + "Am", + "Ar", + "Ara", + "Aza", + "Bar", + "Bra", + "Bran", + "Bru", + "Da", + "Dar", + "Dor", + "Dra", + "Dro", + "Du", + "Duu", + "Fa", + "Far", + "Fe", + "Fer", + "Fur", + "Gan", + "Gra", + "Gran", + "Gre", + "Gro", + "Gru", + "Hra", + "Hu", + "Ka", + "Kar", + "Kha", + "Kra", + "Kro", + "Ma", + "Mar", + "Mu", + "Muu", + "Na", + "Nar", + "Nir", + "Nu", + "On", + "Or", + "Ora", + "Oro", + "Ra", + "Ran", + "Rhu", + "Rin", + "Ru", + "Sa", + "Sha", + "Shra", + "Sra", + "Un", + "Una", + "Ur", + "Ura", + "Xa", + "Xha", + "Xo", + "Zar", + "Zra" + ], + "nm2": [ + "d", + "d", + "d", + "dahn", + "dak", + "dar", + "dh", + "dh", + "dh", + "dran", + "gahr", + "gh", + "gh", + "gh", + "gor", + "k", + "k", + "kh", + "kh", + "kahr", + "kar", + "khar", + "kiak", + "kk", + "kk", + "kk", + "kk", + "kk", + "kran", + "lag", + "lahr", + "lian", + "lid", + "lis", + "lla", + "llak", + "loth", + "mag", + "mak", + "miak", + "mir", + "nag", + "nak", + "niar", + "nod", + "rad", + "rag", + "rak", + "ram", + "rath", + "rek", + "rg", + "rg", + "rg", + "rg", + "rm", + "rm", + "rm", + "rm", + "rra", + "rth", + "rth", + "rth", + "rth", + "ruk", + "rzth", + "rzth", + "rzth", + "tar", + "th", + "th", + "th", + "th", + "tig", + "zad", + "zag", + "zak", + "zar", + "zeg", + "zirg", + "zth" + ], + "nm3": [ + "Ad", + "Alm", + "Ar", + "Arw", + "Ash", + "Dah", + "Dhar", + "Dolm", + "Dran", + "El", + "Ell", + "Erzh", + "Esz", + "Ezh", + "Genr", + "Grel", + "Grin", + "Halm", + "Han", + "Harn", + "Heln", + "Ihr", + "Iln", + "Imm", + "Immil", + "Iz", + "Jan", + "Kan", + "Kharm", + "Khaz", + "Krez", + "Laz", + "Lez", + "Lhash", + "Lir", + "Lor", + "Magd", + "Marm", + "Meir", + "Mir", + "Nagr", + "Nah", + "Nalm", + "Nash", + "Niar", + "Ohn", + "Or", + "Rasz", + "Rez", + "Sham", + "Sharm", + "Shund", + "Sil", + "Um", + "Ur", + "Uw", + "Vith" + ], + "nm4": [ + "a", + "ah", + "aka", + "al", + "alin", + "alla", + "ane", + "anith", + "anya", + "arah", + "arin", + "aya", + "ayah", + "ayis", + "eah", + "eka", + "ekus", + "el", + "ela", + "elna", + "elya", + "elzal", + "ena", + "enah", + "era", + "erah", + "erath", + "erra", + "eth", + "eya", + "ihn", + "ila", + "ilias", + "ilzin", + "in", + "ina", + "ines", + "ira", + "iren", + "iris", + "ith", + "iza", + "la", + "mina", + "mira", + "nara", + "nel", + "nera", + "nia", + "niya", + "ra", + "ya", + "yara", + "zin" + ] +} \ No newline at end of file diff --git a/data/gnome.json b/data/gnome.json new file mode 100644 index 0000000..398a969 --- /dev/null +++ b/data/gnome.json @@ -0,0 +1,507 @@ +{ + "nm1": [ + "Al", + "Ari", + "Bil", + "Bri", + "Cal", + "Cor", + "Dav", + "Dor", + "Eni", + "Er", + "Far", + "Fel", + "Ga", + "Gra", + "His", + "Hor", + "Ian", + "Ipa", + "Je", + "Jor", + "Kas", + "Kel", + "Lan", + "Lo", + "Man", + "Mer", + "Nes", + "Ni", + "Or", + "Oru", + "Pana", + "Po", + "Qua", + "Quo", + "Ras", + "Ron", + "Sa", + "Sal", + "Sin", + "Tan", + "To", + "Tra", + "Um", + "Uri", + "Val", + "Vor", + "War", + "Wil", + "Wre", + "Xal", + "Xo", + "Ye", + "Yos", + "Zan", + "Zil" + ], + "nm2": [ + "bar", + "ben", + "bis", + "corin", + "cryn", + "don", + "dri", + "fan", + "fiz", + "gim", + "grim", + "hik", + "him", + "ji", + "jin", + "kas", + "kur", + "len", + "lin", + "min", + "mop", + "morn", + "nan", + "ner", + "ni", + "pip", + "pos", + "rick", + "ros", + "rug", + "ryn", + "ser", + "ston", + "tix", + "tor", + "ver", + "vyn", + "win", + "wor", + "xif", + "xim", + "ybar", + "yur", + "ziver", + "zu" + ], + "nm3": [ + "Alu", + "Ari", + "Ban", + "Bree", + "Car", + "Cel", + "Daphi", + "Do", + "Eili", + "El", + "Fae", + "Fen", + "Fol", + "Gal", + "Gren", + "Hel", + "Hes", + "Ina", + "Iso", + "Jel", + "Jo", + "Klo", + "Kri", + "Lil", + "Lori", + "Min", + "My", + "Ni", + "Ny", + "Oda", + "Or", + "Phi", + "Pri", + "Qi", + "Que", + "Re", + "Rosi", + "Sa", + "Sel", + "Spi", + "Ta", + "Tifa", + "Tri", + "Ufe", + "Uri", + "Ven", + "Vo", + "Wel", + "Wro", + "Xa", + "Xyro", + "Ylo", + "Yo", + "Zani", + "Zin" + ], + "nm4": [ + "bi", + "bys", + "celi", + "ci", + "dira", + "dysa", + "fi", + "fyx", + "gani", + "gyra", + "hana", + "hani", + "kasys", + "kini", + "la", + "li", + "lin", + "lys", + "mila", + "miphi", + "myn", + "myra", + "na", + "niana", + "noa", + "nove", + "phina", + "pine", + "qaryn", + "qys", + "rhana", + "roe", + "sany", + "ssa", + "sys", + "tina", + "tra", + "wyn", + "wyse", + "xi", + "xis", + "yaris", + "yore", + "za", + "zyre" + ], + "nm5": [ + "", + "", + "b", + "d", + "f", + "g", + "h", + "l", + "m", + "n", + "p", + "r", + "s", + "t", + "w", + "z" + ], + "nm6": [ + "ae", + "oo", + "ee", + "aa", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u" + ], + "nm7": [ + "bbl", + "ckl", + "f", + "ff", + "ggl", + "kk", + "lb", + "lk", + "ln", + "lr", + "lw", + "mb", + "ml", + "mm", + "mml", + "mp", + "mpl", + "nb", + "ng", + "ngg", + "nn", + "np", + "p", + "pl", + "pp", + "r", + "rc", + "rg", + "rk", + "rn", + "rr", + "s", + "sg", + "sgr" + ], + "nm8": [ + "a", + "a", + "e", + "e", + "i", + "o", + "u" + ], + "nm9": [ + "b", + "d", + "n", + "r", + "s", + "t" + ], + "nm10": [ + "a", + "e", + "e", + "i", + "o" + ], + "nm11": [ + "", + "", + "ck", + "g", + "l", + "l", + "ll", + "mp", + "n", + "n", + "n", + "nd", + "r", + "r", + "rs", + "s", + "s" + ], + "nm12": [ + "bl", + "bbl", + "ckl", + "dl", + "ddl", + "ggl", + "gl", + "mbl", + "mpl", + "pl", + "ppl" + ], + "nm13": [ + "babble", + "baffle", + "bellow", + "belly", + "berry", + "billow", + "bold", + "boon", + "brass", + "brisk", + "broad", + "bronze", + "cobble", + "copper", + "dapple", + "dark", + "dazzle", + "deep", + "fapple", + "fiddle", + "fine", + "fizzle", + "flicker", + "fluke", + "glitter", + "gobble", + "gold", + "iron", + "kind", + "last", + "light", + "long", + "loud", + "lucky", + "marble", + "pale", + "pebble", + "puddle", + "quick", + "quiet", + "quill", + "shadow", + "short", + "silver", + "single", + "sparkle", + "spring", + "squiggle", + "stark", + "stout", + "strong", + "swift", + "thistle", + "thunder", + "tinker", + "toggle", + "tossle", + "true", + "twin", + "twist", + "waggle", + "whistle", + "wiggle", + "wild", + "wobble" + ], + "nm14": [ + "back", + "badge", + "belch", + "bell", + "belt", + "bit", + "block", + "bonk", + "boot", + "boots", + "bottom", + "braid", + "branch", + "brand", + "case", + "cheek", + "cloak", + "collar", + "cord", + "craft", + "crag", + "diggles", + "drop", + "dust", + "dwadle", + "fall", + "feast", + "fen", + "fern", + "field", + "firn", + "flight", + "flow", + "front", + "gem", + "gift", + "grace", + "guard", + "hand", + "heart", + "helm", + "hide", + "hold", + "kind", + "ligt", + "lob", + "mane", + "mantle", + "mask", + "patch", + "peak", + "pitch", + "pocket", + "reach", + "rest", + "river", + "rock", + "shield", + "song", + "span", + "spark", + "spell", + "spring", + "stamp", + "stand", + "stitch", + "stone", + "thread", + "top", + "trick", + "twist", + "wander" + ] +} \ No newline at end of file diff --git a/data/goblin.json b/data/goblin.json new file mode 100644 index 0000000..666e305 --- /dev/null +++ b/data/goblin.json @@ -0,0 +1,319 @@ +{ + "nm1": [ + "", + "", + "c", + "cr", + "d", + "g", + "h", + "j", + "kr", + "m", + "n", + "p", + "r", + "s", + "st", + "t", + "v", + "vr", + "z", + "zr" + ], + "nm2": [ + "a", + "e", + "i", + "o", + "u", + "a", + "u" + ], + "nm3": [ + "ch", + "dg", + "dr", + "g", + "gd", + "gl", + "gg", + "gr", + "j", + "ll", + "rr", + "rd" + ], + "nm4": [ + "", + "b", + "g", + "gg", + "k", + "lk", + "rg", + "rk", + "s", + "t" + ], + "nm5": [ + "", + "", + "b", + "d", + "g", + "j", + "m", + "n", + "p", + "q", + "r", + "v", + "z" + ], + "nm6": [ + "a", + "i", + "u", + "a", + "i", + "u", + "o", + "e" + ], + "nm7": [ + "b", + "br", + "d", + "dr", + "g", + "gn", + "gv", + "gr", + "lg", + "lgr", + "ld", + "ldr", + "lv", + "lz", + "ln", + "nd", + "nv", + "nr", + "rg", + "rz", + "rdr", + "rgr", + "rt" + ], + "nm8": [ + "d", + "dd", + "g", + "l", + "ld", + "ll", + "n", + "nd", + "nn", + "y", + "v", + "z" + ], + "nm9": [ + "", + "", + "k", + "l", + "n", + "r", + "s", + "t" + ], + "nm10": [ + "Ant", + "Bait", + "Baitworm", + "Bearbelch", + "Bearbite", + "Beardung", + "Beetle", + "Belch", + "Bigchin", + "Birdbrain", + "Bitenose", + "Bitesize", + "Blockhead", + "Boarbait", + "Boardung", + "Bonehead", + "Bottomfeeder", + "Bottomfood", + "Brainmush", + "Breadstick", + "Bucket", + "Buffoon", + "Bugbite", + "Candlestick", + "Chickenbrain", + "Chowder", + "Clam", + "Coldnose", + "Crawly", + "Deviant", + "Dirtbrain", + "Dirtface", + "Donkey", + "Dungbreath", + "Fly", + "Frogface", + "Froghead", + "Frogwart", + "Gnat", + "Gnatface", + "Grubface", + "Grubgrub", + "Guano", + "Ingrate", + "Insect", + "Larva", + "Leech", + "Leechbrain", + "Leechhead", + "Leechnose", + "Louse", + "Lousehead", + "Maggot", + "Maggotbrain", + "Malformed", + "Mealworm", + "Mite", + "Mitemouth", + "Moldbrain", + "Moldnose", + "Mongrel", + "Mud", + "Mudface", + "Mudmouth", + "Mudmug", + "Mudnose", + "Mule", + "No-Ear", + "No-Ears", + "No-Eyes", + "No-Nose", + "No-Toes", + "One-Eye", + "Owlball", + "Peon", + "Pest", + "Pig", + "Pigface", + "Pighead", + "Pigmud", + "Pigmug", + "Pinkeye", + "Redeye", + "Sleaze", + "Slime", + "Slug", + "Slugmug", + "Snack", + "Snailbrain", + "Snailnose", + "Snot", + "Snotnose", + "Spiderbait", + "Toadbrain", + "Toadface", + "Toadwart", + "Toenail", + "Uglymug", + "Vermin", + "Wartface", + "Weasel", + "Weevil", + "Worm", + "Wormfood", + "Wormmouth", + "Wriggler" + ], + "nm11": [ + "Wide", + "Ugly", + "Strange", + "Slime", + "Pale", + "Grime", + "Grease", + "Bone", + "Bent", + "Bitter", + "Broken", + "Dirt", + "Dull", + "Fat", + "Flat", + "Frail", + "Glob", + "Gout", + "Grim", + "Grub", + "Half", + "Ichor", + "Limp", + "Lump", + "Mad", + "Meek", + "Mold", + "Moss", + "Muck", + "Mud", + "Murk", + "Numb", + "Oaf", + "Shrill", + "Sick", + "Smug", + "Snail", + "Snot", + "Slug", + "Stink", + "Stub", + "Wart", + "Weak", + "Worm" + ], + "nm12": [ + "arm", + "arms", + "ear", + "eye", + "eyes", + "bone", + "bones", + "brain", + "cheek", + "cheeks", + "chin", + "face", + "flab", + "flank", + "foot", + "feet", + "gob", + "gut", + "guts", + "head", + "knuckle", + "knuckles", + "leg", + "legs", + "maw", + "mug", + "nose", + "tooth", + "teeth", + "will" + ] +} \ No newline at end of file diff --git a/data/goliath.json b/data/goliath.json new file mode 100644 index 0000000..17735cf --- /dev/null +++ b/data/goliath.json @@ -0,0 +1,405 @@ +{ + "nmFF": [ + "Age", + "Ane", + "Are", + "Daa", + "Dau", + "Di", + "Ga", + "Gal", + "Gau", + "Ge", + "Gel", + "Ila", + "Ina", + "Ka", + "Kau", + "Ke", + "Ki", + "Kuo", + "La", + "Lau", + "Le", + "Lo", + "Maa", + "Man", + "Mau", + "Me", + "Na", + "Nal", + "Nau", + "Ni", + "No", + "Ola", + "One", + "Ore", + "Ori", + "Pa", + "Paa", + "Pau", + "Pe", + "Tha", + "Thau", + "The", + "Thu", + "Vaa", + "Vau", + "Ve", + "Vo", + "Vu", + "Za", + "Zaa", + "Zau", + "Zo" + ], + "nmFL": [ + "gea", + "geo", + "ggeo", + "ghu", + "gia", + "gu", + "kea", + "keo", + "kha", + "ki", + "kia", + "kio", + "kko", + "la", + "lai", + "lane", + "lea", + "leo", + "lo", + "lu", + "ma", + "meo", + "mi", + "mia", + "ne", + "nea", + "neo", + "ni", + "nia", + "nna", + "nnio", + "nu", + "peo", + "peu", + "pu", + "rea", + "rheo", + "ri", + "ria", + "rra", + "rrea", + "the", + "thea", + "thi", + "thia", + "thio", + "thu", + "vea", + "vi", + "via", + "vu" + ], + "nmMF": [ + "Ag", + "Apa", + "Ar", + "Au", + "Aug", + "Aur", + "Eag", + "Eg", + "Erg", + "Ga", + "Gau", + "Gea", + "Gha", + "Gra", + "Ila", + "Ili", + "Ira", + "Kana", + "Kava", + "Kaza", + "Keo", + "Khu", + "Kora", + "Kra", + "La", + "Lau", + "Laza", + "Loro", + "Ma", + "Mara", + "Mau", + "Mea", + "Mo", + "Na", + "Nara", + "Nau", + "Neo", + "Pa", + "Pu", + "Tara", + "Tau", + "Tha", + "Thava", + "Tho", + "Va", + "Vara", + "Vau", + "Vaura", + "Vega", + "Vi", + "Vo", + "Za", + "Zau" + ], + "nmML": [ + "dak", + "dath", + "dhan", + "gak", + "gal", + "gan", + "gath", + "ghan", + "gith", + "glath", + "gun", + "kan", + "kein", + "khal", + "kin", + "kon", + "lath", + "lig", + "lok", + "mahg", + "mahk", + "mahl", + "mak", + "man", + "mith", + "mul", + "nak", + "nath", + "nihl", + "noth", + "path", + "phak", + "rad", + "rath", + "rein", + "rhak", + "rhan", + "riak", + "rian", + "rin", + "rok", + "roth", + "thag", + "thak", + "tham", + "thi", + "thok", + "veith", + "vek", + "vhal", + "vhik", + "vith", + "voi", + "zak", + "ziath" + ], + "nmMdF": [ + "Adept", + "Bear", + "Brave", + "Bright", + "Dawn", + "Day", + "Deer", + "Dream", + "Flint", + "Fearless", + "Flower", + "Food", + "Fright", + "Goat", + "Hard", + "Hide", + "High", + "Honest", + "Horn", + "Keen", + "Lone", + "Long", + "Low", + "Lumber", + "Master", + "Mind", + "Mountain", + "Night", + "Rain", + "River", + "Rock", + "Root", + "Silent", + "Sky", + "Sly", + "Smart", + "Steady", + "Stone", + "Storm", + "Strong", + "Swift", + "Thread", + "Thunder", + "Tree", + "Tribe", + "True", + "Truth", + "Wander", + "Wild", + "Wise", + "Wound" + ], + "nmMdL": [ + "aid", + "bearer", + "breaker", + "caller", + "carver", + "chaser", + "climber", + "cook", + "dream", + "drifter", + "eye", + "finder", + "fist", + "friend", + "frightener", + "guard", + "hand", + "hauler", + "heart", + "herder", + "hunter", + "jumper", + "killer", + "lander", + "leader", + "leaper", + "logger", + "maker", + "mender", + "picker", + "runner", + "shot", + "smasher", + "speaker", + "stalker", + "striker", + "tanner", + "twister", + "vigor", + "walker", + "wanderer", + "warrior", + "watcher", + "weaver", + "worker" + ], + "nmSF": [ + "Agu-Ul", + "Agu-V", + "Anakal", + "Apuna-M", + "Athun", + "Egena-V", + "Egum", + "Elan", + "Ganu-M", + "Gathak", + "Gean", + "Inul", + "Kalag", + "Kaluk", + "Katho-Ol", + "Kolae-G", + "Kolak", + "Kulan", + "Kulum", + "Lakum", + "Maluk", + "Munak", + "Muthal", + "Nalak", + "Nola-K", + "Nugal", + "Nulak", + "Ogol", + "Oveth", + "Thenal", + "Thul", + "Thunuk", + "Ugun", + "Uthenu-K", + "Vaimei-L", + "Valu-N", + "Vathun", + "Veom", + "Vuma-Th", + "Vunak" + ], + "nmSL": [ + "aga", + "ageane", + "akane", + "akanu", + "akume", + "alathi", + "amino", + "amune", + "anathi", + "atake", + "athai", + "athala", + "atho", + "avea", + "avi", + "avone", + "eaku", + "ekali", + "elo", + "iaga", + "iago", + "iala", + "iano", + "igala", + "igane", + "igano", + "igo", + "igone", + "ileana", + "ithino", + "olake", + "ugate", + "ugoni", + "ukane", + "ukate", + "ukena", + "ulane", + "upine", + "utha", + "uthea" + ] +} \ No newline at end of file diff --git a/data/grung.json b/data/grung.json new file mode 100644 index 0000000..5623086 --- /dev/null +++ b/data/grung.json @@ -0,0 +1,89 @@ +{ + "nm1": [ + "b", + "c", + "d", + "g", + "n", + "p", + "r" + ], + "nm2": [ + "", + "d", + "l", + "n", + "r" + ], + "nm3": [ + "ee", + "oo", + "ie", + "ou", + "a", + "e", + "i", + "o", + "u" + ], + "nm4": [ + "hb", + "hp", + "hn", + "b", + "h", + "n", + "ng", + "p", + "ph", + "s", + "sh" + ], + "nm5": [ + "bh", + "kh", + "rh", + "b", + "br", + "k", + "r" + ], + "nm6": [ + "ë", + "ü", + "ö", + "a", + "a", + "e", + "e", + "i", + "o", + "a", + "a", + "e", + "e", + "i", + "o" + ], + "nm7": [ + "ht", + "hr", + "hk", + "b", + "d", + "k", + "kh", + "l", + "n", + "r", + "t" + ], + "nm8": [ + "a", + "a", + "e", + "e", + "i", + "o" + ] +} \ No newline at end of file diff --git a/data/half-elf.json b/data/half-elf.json new file mode 100644 index 0000000..7e440bd --- /dev/null +++ b/data/half-elf.json @@ -0,0 +1,215 @@ +{ + "nm1": [ + "Al", + "Aro", + "Bar", + "Bel", + "Cor", + "Cra", + "Dav", + "Dor", + "Eir", + "El", + "Fal", + "Fril", + "Gaer", + "Gra", + "Hal", + "Hor", + "Ian", + "Ilo", + "Jam", + "Kev", + "Kri", + "Leo", + "Lor", + "Mar", + "Mei", + "Nil", + "Nor", + "Ori", + "Os", + "Pan", + "Pet", + "Quo", + "Raf", + "Ri", + "Sar", + "Syl", + "Tra", + "Tyr", + "Uan", + "Ul", + "Van", + "Vic", + "Wal", + "Wil", + "Xan", + "Xav", + "Yen", + "Yor", + "Zan", + "Zyl" + ], + "nm2": [ + "avor", + "ben", + "borin", + "coril", + "craes", + "deyr", + "dithas", + "elor", + "enas", + "faelor", + "faerd", + "finas", + "fyr", + "gotin", + "gretor", + "homin", + "horn", + "kas", + "koris", + "lamir", + "lanann", + "lumin", + "minar", + "morn", + "nan", + "neak", + "neiros", + "orin", + "ovar", + "parin", + "phanis", + "qarim", + "qinor", + "reak", + "ril", + "ros", + "sariph", + "staer", + "torin", + "tumil", + "valor", + "voril", + "warith", + "word", + "xian", + "xiron", + "yeras", + "ynor", + "zaphir", + "zaren" + ], + "nm3": [ + "Alu", + "Aly", + "Ar", + "Bren", + "Byn", + "Car", + "Co", + "Dar", + "Del", + "El", + "Eli", + "Fae", + "Fha", + "Gal", + "Gif", + "Haly", + "Ho", + "Ile", + "Iro", + "Jen", + "Jil", + "Kri", + "Kys", + "Les", + "Lora", + "Ma", + "Mar", + "Mare", + "Neri", + "Nor", + "Ol", + "Ophi", + "Phaye", + "Pri", + "Qi", + "Que", + "Rel", + "Res", + "Sael", + "Saf", + "Syl", + "Ther", + "Tyl", + "Una", + "Uri", + "Ven", + "Vyl", + "Win", + "Wol", + "Xil", + "Xyr", + "Yes", + "Yll", + "Zel", + "Zin" + ], + "nm4": [ + "aerys", + "anys", + "bellis", + "bwynn", + "cerys", + "charis", + "diane", + "dove", + "elor", + "enyphe", + "faen", + "fine", + "galyn", + "gwynn", + "hana", + "hophe", + "kaen", + "kilia", + "lahne", + "lynn", + "mae", + "malis", + "mythe", + "nalore", + "noa", + "nys", + "ona", + "phira", + "pisys", + "qarin", + "qwyn", + "rila", + "rora", + "seris", + "stine", + "sys", + "thana", + "theris", + "tihne", + "trana", + "viel", + "vyre", + "walyn", + "waris", + "xaris", + "xipha", + "yaries", + "yra", + "zenya", + "zira" + ] +} \ No newline at end of file diff --git a/data/half-orc.json b/data/half-orc.json new file mode 100644 index 0000000..c03c560 --- /dev/null +++ b/data/half-orc.json @@ -0,0 +1,299 @@ +{ + "nm1": [ + "Ag", + "Agg", + "Ar", + "Arn", + "As", + "At", + "Atr", + "B", + "Bar", + "Bel", + "Bor", + "Br", + "Brak", + "C", + "Cr", + "D", + "Dor", + "Dr", + "Dur", + "G", + "Gal", + "Gan", + "Gar", + "Gna", + "Gor", + "Got", + "Gr", + "Gram", + "Grim", + "Grom", + "Grum", + "Gul", + "H", + "Hag", + "Han", + "Har", + "Hog", + "Hon", + "Hor", + "Hun", + "Hur", + "K", + "Kal", + "Kam", + "Kar", + "Kel", + "Kil", + "Kom", + "Kor", + "Kra", + "Kru", + "Kul", + "Kur", + "Lum", + "M", + "Mag", + "Mahl", + "Mak", + "Mal", + "Mar", + "Mog", + "Mok", + "Mor", + "Mug", + "Muk", + "Mura", + "N", + "Oggu", + "Ogu", + "Ok", + "Oll", + "Or", + "Rek", + "Ren", + "Ron", + "Rona", + "S", + "Sar", + "Sor", + "T", + "Tan", + "Th", + "Thar", + "Ther", + "Thr", + "Thur", + "Trak", + "Truk", + "Ug", + "Uk", + "Ukr", + "Ull", + "Ur", + "Urth", + "Urtr", + "Z", + "Za", + "Zar", + "Zas", + "Zav", + "Zev", + "Zor", + "Zur", + "Zus" + ], + "nm2": [ + "a", + "a", + "a", + "o", + "o", + "e", + "i", + "u", + "u", + "u" + ], + "nm3": [ + "bak", + "bar", + "bark", + "bash", + "bur", + "burk", + "d", + "dak", + "dall", + "dar", + "dark", + "dash", + "dim", + "dur", + "durk", + "g", + "gak", + "gall", + "gar", + "gark", + "gash", + "glar", + "gul", + "gur", + "m", + "mak", + "mar", + "marsh", + "mash", + "mir", + "mur", + "n", + "nar", + "nars", + "nur", + "rak", + "rall", + "rash", + "rim", + "rimm", + "rk", + "rsh", + "rth", + "ruk", + "sk", + "tar", + "tir", + "tur", + "z", + "zall", + "zar", + "zur" + ], + "nm4": [ + "Al", + "Ar", + "Br", + "Ek", + "El", + "Fal", + "Fel", + "Fol", + "Ful", + "G", + "Gaj", + "Gar", + "Gij", + "Gor", + "Gr", + "Gry", + "Gyn", + "Hur", + "K", + "Kar", + "Kat", + "Ker", + "Ket", + "Kir", + "Kot", + "Kur", + "Kut", + "Lag", + "M", + "Mer", + "Mir", + "Mor", + "N", + "Ol", + "Oot", + "Puy", + "R", + "Rah", + "Rahk", + "Ras", + "Rash", + "Raw", + "Roh", + "Rohk", + "S", + "Sam", + "San", + "Sem", + "Sen", + "Sh", + "Shay", + "Sin", + "Sum", + "Sun", + "Tam", + "Tem", + "Tu", + "Tum", + "Ub", + "Um", + "Ur", + "Van", + "Zan", + "Zen", + "Zon", + "Zun" + ], + "nm5": [ + "a", + "a", + "o", + "o", + "e", + "i", + "i", + "u" + ], + "nm6": [ + "d", + "da", + "dar", + "dur", + "g", + "gar", + "gh", + "gri", + "gu", + "sh", + "sha", + "shi", + "gum", + "gume", + "gur", + "ki", + "mar", + "mi", + "mira", + "me", + "mur", + "ne", + "ner", + "nir", + "nar", + "nchu", + "ni", + "nur", + "ral", + "rel", + "ri", + "rook", + "ti", + "tah", + "tir", + "tar", + "tur", + "war", + "z", + "zar", + "zara", + "zi", + "zur", + "zura", + "zira" + ] +} \ No newline at end of file diff --git a/data/halfling.json b/data/halfling.json new file mode 100644 index 0000000..a546c3c --- /dev/null +++ b/data/halfling.json @@ -0,0 +1,398 @@ +{ + "nm1": [ + "An", + "Ar", + "Bar", + "Bel", + "Con", + "Cor", + "Dan", + "Dav", + "El", + "Er", + "Fal", + "Fin", + "Flyn", + "Gar", + "Go", + "Hal", + "Hor", + "Ido", + "Ira", + "Jan", + "Jo", + "Kas", + "Kor", + "La", + "Lin", + "Mar", + "Mer", + "Ne", + "Nor", + "Ori", + "Os", + "Pan", + "Per", + "Pim", + "Quin", + "Quo", + "Ri", + "Ric", + "San", + "Shar", + "Tar", + "Te", + "Ul", + "Uri", + "Val", + "Vin", + "Wen", + "Wil", + "Xan", + "Xo", + "Yar", + "Yen", + "Zal", + "Zen" + ], + "nm2": [ + "ace", + "amin", + "bin", + "bul", + "dak", + "dal", + "der", + "don", + "emin", + "eon", + "fer", + "fire", + "gin", + "hace", + "horn", + "kas", + "kin", + "lan", + "los", + "min", + "mo", + "nad", + "nan", + "ner", + "orin", + "os", + "pher", + "pos", + "ras", + "ret", + "ric", + "rich", + "rin", + "ry", + "ser", + "sire", + "ster", + "ton", + "tran", + "umo", + "ver", + "vias", + "von", + "wan", + "wrick", + "yas", + "yver", + "zin", + "zor", + "zu" + ], + "nm3": [ + "An", + "Ari", + "Bel", + "Bre", + "Cal", + "Chen", + "Dar", + "Dia", + "Ei", + "Eo", + "Eli", + "Era", + "Fay", + "Fen", + "Fro", + "Gel", + "Gra", + "Ha", + "Hil", + "Ida", + "Isa", + "Jay", + "Jil", + "Kel", + "Kith", + "Le", + "Lid", + "Mae", + "Mal", + "Mar", + "Ne", + "Ned", + "Odi", + "Ora", + "Pae", + "Pru", + "Qi", + "Qu", + "Ri", + "Ros", + "Sa", + "Shae", + "Syl", + "Tham", + "Ther", + "Tryn", + "Una", + "Uvi", + "Va", + "Ver", + "Wel", + "Wi", + "Xan", + "Xi", + "Yes", + "Yo", + "Zef", + "Zen" + ], + "nm4": [ + "alyn", + "ara", + "brix", + "byn", + "caryn", + "cey", + "da", + "dove", + "drey", + "elle", + "eni", + "fice", + "fira", + "grace", + "gwen", + "haly", + "jen", + "kath", + "kis", + "leigh", + "la", + "lie", + "lile", + "lienne", + "lyse", + "mia", + "mita", + "ne", + "na", + "ni", + "nys", + "ola", + "ora", + "phina", + "prys", + "rana", + "ree", + "ri", + "ris", + "sica", + "sira", + "sys", + "tina", + "trix", + "ula", + "vira", + "vyre", + "wyn", + "wyse", + "yola", + "yra", + "zana", + "zira" + ], + "nm12": [ + "amber", + "apple", + "autumn", + "barley", + "big", + "boulder", + "bramble", + "bright", + "bronze", + "brush", + "cherry", + "cinder", + "clear", + "cloud", + "common", + "copper", + "deep", + "dust", + "earth", + "elder", + "ember", + "fast", + "fat", + "fern", + "flint", + "fog", + "fore", + "free", + "glen", + "glow", + "gold", + "good", + "grand", + "grass", + "great", + "green", + "haven", + "heart", + "high", + "hill", + "hog", + "humble", + "keen", + "laughing", + "lea", + "leaf", + "light", + "little", + "lone", + "long", + "lunar", + "marble", + "mild", + "mist", + "moon", + "moss", + "night", + "nimble", + "proud", + "quick", + "raven", + "reed", + "river", + "rose", + "rumble", + "shadow", + "silent", + "silver", + "smooth", + "soft", + "spring", + "still", + "stone", + "stout", + "strong", + "summer", + "sun", + "swift", + "tall", + "tea", + "ten", + "thistle", + "thorn", + "toss", + "true", + "twilight", + "under", + "warm", + "whisper", + "wild", + "wise" + ], + "nm13": [ + "ace", + "barrel", + "beam", + "belly", + "berry", + "bloom", + "blossom", + "bluff", + "bottle", + "bough", + "brace", + "braid", + "branch", + "brand", + "bridge", + "brook", + "brush", + "cheeks", + "cloak", + "cobble", + "creek", + "crest", + "dance", + "dancer", + "dew", + "dream", + "earth", + "eye", + "eyes", + "feet", + "fellow", + "finger", + "fingers", + "flow", + "flower", + "foot", + "found", + "gather", + "glide", + "grove", + "hand", + "hands", + "hare", + "heart", + "hill", + "hollow", + "kettle", + "lade", + "leaf", + "man", + "mane", + "mantle", + "meadow", + "moon", + "mouse", + "pot", + "rabbit", + "seeker", + "shadow", + "shine", + "sky", + "song", + "spark", + "spell", + "spirit", + "step", + "stride", + "sun", + "surge", + "top", + "topple", + "vale", + "water", + "whistle", + "willow", + "wind", + "wood", + "woods" + ] +} \ No newline at end of file diff --git a/data/harengon.json b/data/harengon.json new file mode 100644 index 0000000..7fbde83 --- /dev/null +++ b/data/harengon.json @@ -0,0 +1,322 @@ +{ + "nm1": [ + "Ad", + "Ae", + "Bal", + "Bei", + "Car", + "Cra", + "Dae", + "Dor", + "El", + "Ela", + "Er", + "Far", + "Fen", + "Gen", + "Glyn", + "Hei", + "Her", + "Ian", + "Ili", + "Kea", + "Kel", + "Leo", + "Lu", + "Mira", + "Mor", + "Nae", + "Nor", + "Olo", + "Oma", + "Pa", + "Per", + "Pet", + "Qi", + "Qin", + "Ralo", + "Ro", + "Sar", + "Syl", + "The", + "Tra", + "Ume", + "Uri", + "Va", + "Vir", + "Waes", + "Wran", + "Yel", + "Yin", + "Zin", + "Zum" + ], + "nm2": [ + "balar", + "beros", + "can", + "ceran", + "dan", + "dithas", + "faren", + "fir", + "geiros", + "golor", + "hice", + "horn", + "jeon", + "jor", + "kas", + "kian", + "lamin", + "lar", + "len", + "maer", + "maris", + "menor", + "myar", + "nan", + "neiros", + "nelis", + "norin", + "peiros", + "petor", + "qen", + "quinal", + "ran", + "ren", + "ric", + "ris", + "ro", + "salor", + "sandoral", + "toris", + "tumal", + "valur", + "ven", + "warin", + "wraek", + "xalim", + "xidor", + "yarus", + "ydark", + "zeiros", + "zumin" + ], + "nm3": [ + "Ad", + "Ara", + "Bi", + "Bry", + "Cai", + "Chae", + "Da", + "Dae", + "Eil", + "En", + "Fa", + "Fae", + "Gil", + "Gre", + "Hele", + "Hola", + "Iar", + "Ina", + "Jo", + "Key", + "Kris", + "Lia", + "Lora", + "Mag", + "Mia", + "Neri", + "Ola", + "Ori", + "Phi", + "Pres", + "Qi", + "Qui", + "Rava", + "Rey", + "Sha", + "Syl", + "Tor", + "Tris", + "Ula", + "Uri", + "Val", + "Ven", + "Wyn", + "Wysa", + "Xil", + "Xyr", + "Yes", + "Ylla", + "Zin", + "Zyl" + ], + "nm4": [ + "banise", + "bella", + "caryn", + "cyne", + "di", + "dove", + "fiel", + "fina", + "gella", + "gwyn", + "hana", + "harice", + "jyre", + "kalyn", + "krana", + "lana", + "lee", + "leth", + "lynn", + "moira", + "mys", + "na", + "nala", + "phine", + "phyra", + "qirelle", + "ra", + "ralei", + "rel", + "rie", + "rieth", + "rona", + "rora", + "roris", + "satra", + "stina", + "sys", + "thana", + "thyra", + "tris", + "varis", + "vyre", + "wenys", + "wynn", + "xina", + "xisys", + "ynore", + "yra", + "zana", + "zorwyn" + ], + "nm5": [ + "", + "", + "b", + "br", + "d", + "dr", + "g", + "j", + "l", + "m", + "n", + "r", + "t", + "th", + "tr", + "v", + "z" + ], + "nm6": [ + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "o" + ], + "nm7": [ + "b", + "b", + "bb", + "br", + "d", + "d", + "dd", + "dr", + "g", + "g", + "gd", + "gl", + "l", + "l", + "ld", + "ll", + "ln", + "lm", + "lr", + "m", + "m", + "mm", + "mn", + "n", + "n", + "nb", + "nd", + "nn", + "r", + "r", + "rd", + "rl", + "rn", + "rr", + "rv", + "v", + "v", + "vl", + "vr", + "z", + "z", + "zd", + "zl", + "zn", + "zz" + ], + "nm8": [ + "a", + "e", + "i", + "o", + "a", + "e", + "o", + "i", + "a", + "e", + "o", + "u" + ], + "nm9": [ + "b", + "d", + "g", + "l", + "ll", + "m", + "n", + "nn", + "r", + "v", + "z" + ], + "nm10": [ + "", + "h", + "k", + "l", + "n", + "r", + "t" + ] +} \ No newline at end of file diff --git a/data/hobgoblin.json b/data/hobgoblin.json new file mode 100644 index 0000000..a5b1389 --- /dev/null +++ b/data/hobgoblin.json @@ -0,0 +1,253 @@ +{ + "nm1": [ + "", + "", + "", + "", + "", + "d", + "dr", + "g", + "gl", + "gr", + "k", + "kh", + "kl", + "kr", + "l", + "m", + "n", + "r", + "rh", + "sh", + "v", + "vr", + "z", + "zr" + ], + "nm2": [ + "a", + "o", + "a", + "o", + "e", + "u" + ], + "nm3": [ + "d", + "dr", + "g", + "gr", + "gn", + "k", + "kk", + "kr", + "kn", + "kv", + "ldr", + "lv", + "lz", + "lvr", + "nd", + "ndr", + "nk", + "r", + "rb", + "rd", + "rk", + "v", + "vr", + "vl", + "z", + "zr" + ], + "nm4": [ + "e", + "e", + "a", + "o", + "i", + "u", + "e", + "a", + "o" + ], + "nm5": [ + "d", + "l", + "n", + "r", + "v", + "z" + ], + "nm6": [ + "a", + "e", + "o", + "u" + ], + "nm7": [ + "c", + "d", + "g", + "k", + "l", + "n", + "r", + "rg", + "rz" + ], + "nm8": [ + "Bark", + "Bash", + "Bellow", + "Bleed", + "Blow", + "Bolster", + "Bolt", + "Brawl", + "Break", + "Bruise", + "Buckle", + "Bully", + "Burn", + "Burst", + "Butcher", + "Cackle", + "Carve", + "Chomp", + "Conquer", + "Crash", + "Crunch", + "Crush", + "Dash", + "Devour", + "Dodge", + "Duel", + "Edge", + "Etch", + "Feign", + "Flail", + "Flare", + "Forge", + "Froth", + "Fume", + "Glare", + "Gnash", + "Grimace", + "Grin", + "Growl", + "Hook", + "Impale", + "Jolt", + "Kill", + "Lash", + "Lurch", + "Mangle", + "Mark", + "Maul", + "Pierce", + "Prowl", + "Pummel", + "Quake", + "Rage", + "Rebuke", + "Reign", + "Rend", + "Repel", + "Retch", + "Revel", + "Roam", + "Ruin", + "Rush", + "Saw", + "Scorch", + "Scrub", + "Seethe", + "Sever", + "Shock", + "Shred", + "Slay", + "Smirk", + "Smush", + "Snarl", + "Squish", + "Stalk", + "Sting", + "Stomp", + "Strike", + "Stunt", + "Swipe", + "Thrash", + "Thunder", + "Trail", + "Trample", + "Twist", + "Twitch", + "Vex", + "Whack", + "the Beast", + "the Behemoth", + "the Blade", + "the Boar", + "the Bold", + "the Brute", + "the Bull", + "the Butcher", + "the Cold", + "the Corrupt", + "the Cruel", + "the Dagger", + "the Demon", + "the Edge", + "the Fury", + "the Giant", + "the Grand", + "the Grim", + "the Harsh", + "the Hollow", + "the Hook", + "the Hungry", + "the Hunter", + "the Insane", + "the Knife", + "the Loud", + "the Mad", + "the Maniac", + "the Manslayer", + "the Marked", + "the Mask", + "the Mighty", + "the Monster", + "the Oaf", + "the Ox", + "the Razor", + "the Reckless", + "the Red", + "the Rogue", + "the Rotten", + "the Sabre", + "the Serpent", + "the Shallow", + "the Shank", + "the Shield", + "the Shiv", + "the Skeleton", + "the Slayer", + "the Snake", + "the Strong", + "the Sword", + "the Thief", + "the Tyrant", + "the Vengeful", + "the Vicious", + "the Violent", + "the Vulture", + "the Warlord", + "the Warmonger", + "the Warrior", + "the Watcher", + "the Wrath", + "the Wretched" + ] +} \ No newline at end of file diff --git a/data/human.json b/data/human.json new file mode 100644 index 0000000..9227e34 --- /dev/null +++ b/data/human.json @@ -0,0 +1,757 @@ +{ + "nm1": [ + "", + "", + "b", + "bh", + "f", + "h", + "j", + "kh", + "m", + "n", + "nh", + "r", + "rh", + "s", + "z" + ], + "nm2": [ + "a", + "e", + "u", + "a", + "e", + "u", + "a", + "e", + "u", + "i", + "ei" + ], + "nm3": [ + "b", + "d", + "hm", + "hn", + "hl", + "kh", + "l", + "m", + "rd", + "r", + "s", + "sh", + "z" + ], + "nm4": [ + "d", + "m", + "n", + "r" + ], + "nm5": [ + "", + "", + "c", + "f", + "h", + "j", + "m", + "n", + "r", + "s", + "sh", + "y", + "z" + ], + "nm6": [ + "a", + "e", + "u", + "a", + "e", + "u", + "o", + "o", + "i", + "i", + "ei" + ], + "nm7": [ + "d", + "f", + "hn", + "hl", + "hm", + "hr", + "l", + "m", + "n", + "p", + "r", + "s", + "sh", + "sm", + "sn", + "t", + "v", + "z" + ], + "nm8": [ + "h", + "l" + ], + "nm9": [ + "b", + "bh", + "c", + "d", + "dh", + "h", + "j", + "kh", + "m", + "n", + "p", + "r", + "rh", + "sh", + "z" + ], + "nm10": [ + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "a", + "a", + "ei" + ], + "nm11": [ + "d", + "h", + "hr", + "hl", + "k", + "kh", + "l", + "m", + "mm", + "n", + "nn", + "ss", + "st", + "sh" + ], + "nm12": [ + "", + "", + "", + "", + "", + "d", + "l", + "m", + "n", + "r" + ], + "nm13": [ + "", + "b", + "br", + "d", + "g", + "gr", + "h", + "m", + "n", + "r", + "st", + "t", + "v" + ], + "nm14": [ + "a", + "e", + "i", + "o", + "u" + ], + "nm15": [ + "", + "br", + "cr", + "gr", + "kv", + "kr", + "l", + "ll", + "ld", + "lv", + "nd", + "ng", + "nk", + "nv", + "rd", + "rg", + "rk", + "rst", + "rv", + "v" + ], + "nm16": [ + "", + "", + "", + "d", + "dd", + "g", + "l", + "lm", + "m", + "n", + "r", + "rk", + "rn" + ], + "nm17": [ + "", + "c", + "j", + "jh", + "k", + "l", + "m", + "n", + "r", + "s", + "sh", + "t" + ], + "nm18": [ + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "ee", + "ai", + "ei", + "ie" + ], + "nm19": [ + "ch", + "dr", + "l", + "ll", + "lr", + "ldr", + "ls", + "lz", + "n", + "ndr", + "rl", + "r", + "rr", + "rv", + "ss", + "sr", + "sv", + "w", + "z", + "zz", + "zn" + ], + "nm20": [ + "", + "", + "", + "", + "h", + "l", + "ll", + "n" + ], + "nm21": [ + "Axe", + "Glow", + "Blade", + "Blood", + "Bone", + "Cloud", + "Crag", + "Crest", + "Doom", + "Dream", + "Coven", + "Elf", + "Fern", + "Feather", + "Fire", + "Fist", + "Flame", + "Forest", + "Hammer", + "Heart", + "Hell", + "Leaf", + "Light", + "Moon", + "Rage", + "River", + "Rock", + "Shade", + "Shadow", + "Shield", + "Snow", + "Spirit", + "Star", + "Steel", + "Stone", + "Swift", + "Tree", + "Whisper", + "Wind", + "Wolf", + "Wood", + "Gloom", + "Glory", + "Orb", + "Ash", + "Blaze", + "Amber", + "Autumn", + "Barley", + "Battle", + "Bear", + "Black", + "Blue", + "Boulder", + "Bright", + "Bronze", + "Burning", + "Cask", + "Chest", + "Cinder", + "Clan", + "Claw", + "Clear", + "Cliff", + "Cold", + "Common", + "Crystal", + "Dark", + "Dawn", + "Day", + "Dead", + "Death", + "Deep", + "Dew", + "Dirge", + "Distant", + "Down", + "Dragon", + "Dusk", + "Dust", + "Eagle", + "Earth", + "Ember", + "Even", + "Far", + "Flat", + "Flint", + "Fog", + "Fore", + "Four", + "Free", + "Frost", + "Frozen", + "Full", + "Fuse", + "Gold", + "Horse", + "Gore", + "Grand", + "Gray", + "Grass", + "Great", + "Green", + "Grizzly", + "Hallow", + "Hallowed", + "Hard", + "Hawk", + "Haze", + "Heavy", + "Haven", + "High", + "Hill", + "Holy", + "Honor", + "Forest", + "Humble", + "Hydra", + "Ice", + "Iron", + "Keen", + "Laughing", + "Lightning", + "Lion", + "Lone", + "Long", + "Low", + "Luna", + "Marble", + "Meadow", + "Mild", + "Mirth", + "Mist", + "Molten", + "Monster", + "Morning", + "Moss", + "Mountain", + "Moon", + "Mourn", + "Mourning", + "Night", + "Noble", + "Nose", + "Oat", + "Ocean", + "Pale", + "Peace", + "Phoenix", + "Pine", + "Plain", + "Pride", + "Proud", + "Pyre", + "Rain", + "Rapid", + "Raven", + "Red", + "Regal", + "Rich", + "Rose", + "Rough", + "Rumble", + "Rune", + "Sacred", + "Sage", + "Saur", + "Sea", + "Serpent", + "Sharp", + "Silent", + "Silver", + "Simple", + "Single", + "Skull", + "Sky", + "Slate", + "Smart", + "Snake", + "Soft", + "Solid", + "Spider", + "Spring", + "Stag", + "Star", + "Stern", + "Still", + "Storm", + "Stout", + "Strong", + "Summer", + "Sun", + "Tall", + "Three", + "Thunder", + "Titan", + "True", + "Truth", + "Marsh", + "Tusk", + "Twilight", + "Two", + "Void", + "War", + "Wheat", + "Whit", + "White", + "Wild", + "Winter", + "Wise", + "Wyvern", + "Young", + "Alpen", + "Crest", + "Crow", + "Fallen", + "Farrow", + "Haven", + "Master", + "Nether", + "Nickle", + "Raven", + "River", + "Stone", + "Tarren", + "Terra", + "Water", + "Willow", + "Wooden" + ], + "nm22": [ + "axe", + "glow", + "beam", + "blade", + "blood", + "bone", + "cloud", + "dane", + "crag", + "crest", + "doom", + "dream", + "feather", + "fire", + "fist", + "flame", + "forest", + "hammer", + "heart", + "hell", + "leaf", + "light", + "moon", + "rage", + "river", + "rock", + "shade", + "claw", + "shadow", + "shield", + "snow", + "spirit", + "star", + "steel", + "stone", + "swift", + "tree", + "whisper", + "wind", + "wolf", + "wood", + "gloom", + "glory", + "orb", + "ash", + "blaze", + "arm", + "arrow", + "bane", + "bash", + "basher", + "beard", + "belly", + "bend", + "bender", + "binder", + "bleeder", + "blight", + "bloom", + "blossom", + "blower", + "glade", + "bluff", + "bough", + "bow", + "brace", + "braid", + "branch", + "brand", + "breaker", + "breath", + "breeze", + "brew", + "bringer", + "brook", + "brow", + "caller", + "chaser", + "reaper", + "chewer", + "cleaver", + "creek", + "crusher", + "cut", + "cutter", + "dancer", + "dew", + "down", + "draft", + "dreamer", + "drifter", + "dust", + "eye", + "eyes", + "fall", + "fang", + "flare", + "flaw", + "flayer", + "flow", + "follower", + "flower", + "force", + "forge", + "fury", + "gaze", + "gazer", + "gem", + "gleam", + "glide", + "grain", + "grip", + "grove", + "guard", + "gust", + "hair", + "hand", + "helm", + "hide", + "horn", + "hunter", + "jumper", + "keep", + "keeper", + "killer", + "lance", + "lash", + "less", + "mane", + "mantle", + "mark", + "maul", + "maw", + "might", + "more", + "mourn", + "oak", + "ore", + "peak", + "pelt", + "pike", + "punch", + "reaver", + "rider", + "ridge", + "ripper", + "roar", + "run", + "runner", + "scar", + "scream", + "scribe", + "seeker", + "shaper", + "shard", + "shot", + "shout", + "singer", + "sky", + "slayer", + "snarl", + "snout", + "soar", + "song", + "sorrow", + "spark", + "spear", + "spell", + "spire", + "splitter", + "sprinter", + "stalker", + "steam", + "stream", + "strength", + "stride", + "strider", + "strike", + "striker", + "sun", + "surge", + "sword", + "sworn", + "tail", + "taker", + "talon", + "thorn", + "tide", + "toe", + "track", + "trap", + "trapper", + "vale", + "valor", + "vigor", + "walker", + "ward", + "watcher", + "water", + "weaver", + "whirl", + "whisk", + "winds", + "wing", + "woods", + "wound", + "brooke", + "fall", + "fallow", + "horn", + "root", + "shine", + "swallow", + "thorne", + "willow", + "wood" + ] +} \ No newline at end of file diff --git a/data/kalashtar.json b/data/kalashtar.json new file mode 100644 index 0000000..824bf0e --- /dev/null +++ b/data/kalashtar.json @@ -0,0 +1,137 @@ +{ + "nm1": [ + "b", + "c", + "ch", + "d", + "g", + "gh", + "h", + "k", + "kh", + "l", + "m", + "n", + "s", + "t", + "v", + "z" + ], + "nm2": [ + "a", + "e", + "o", + "a", + "e", + "o", + "i" + ], + "nm3": [ + "l", + "n", + "r", + "s", + "v", + "w", + "y", + "z" + ], + "nm4": [ + "a", + "a", + "e", + "i", + "i", + "o" + ], + "nm5": [ + "ulad", + "hareth", + "khad", + "kosh", + "melk", + "tash", + "vash" + ], + "nm6": [ + "ashana", + "ashtai", + "ishara", + "nari", + "tara", + "vakri" + ], + "nm7": [ + "d", + "h", + "g", + "gh", + "k", + "kh", + "m", + "n", + "r", + "sh", + "sht", + "t", + "v", + "z" + ], + "nm8": [ + "a", + "e", + "i", + "o", + "u" + ], + "nm9": [ + "dr", + "kr", + "l", + "ld", + "ldr", + "lr", + "n", + "r", + "rr", + "v", + "z" + ], + "nm10": [ + "ai", + "ei", + "ia", + "a", + "e", + "i", + "a", + "e", + "i", + "a", + "e", + "i", + "a", + "e", + "i", + "a", + "e", + "i" + ], + "nm11": [ + "", + "", + "", + "", + "", + "d", + "l", + "lk", + "n", + "ns", + "nt", + "s", + "ss", + "sh", + "th" + ] +} \ No newline at end of file diff --git a/data/kenku.json b/data/kenku.json new file mode 100644 index 0000000..c700c95 --- /dev/null +++ b/data/kenku.json @@ -0,0 +1,486 @@ +{ + "nm1": [ + "Angler", + "Baker", + "Barker", + "Basher", + "Bather", + "Beggar", + "Biter", + "Boiler", + "Bomber", + "Bonker", + "Bouncer", + "Braker", + "Brander", + "Breaker", + "Broiler", + "Bruiser", + "Bubbler", + "Burner", + "Butcher", + "Buzzer", + "Cackler", + "Carver", + "Caster", + "Chimer", + "Chitter", + "Chomper", + "Chopper", + "Clamor", + "Clamper", + "Clanger", + "Clapper", + "Clawer", + "Cleaver", + "Clicker", + "Clinger", + "Clinker", + "Clipper", + "Clubber", + "Clucker", + "Cobbler", + "Cooker", + "Cougher", + "Crackler", + "Crinkler", + "Croaker", + "Cruncher", + "Crusher", + "Cutter", + "Dangler", + "Deflater", + "Digger", + "Dipper", + "Doodler", + "Dragger", + "Drawer", + "Dribbler", + "Driller", + "Dripper", + "Drummer", + "Duster", + "Enchanter", + "Engraver", + "Etcher", + "Exploder", + "Flapper", + "Flipper", + "Flopper", + "Flusher", + "Forger", + "Fryer", + "Giggler", + "Gnasher", + "Gnawer", + "Gouger", + "Greaser", + "Griller", + "Grinder", + "Growler", + "Gusher", + "Hammer", + "Hammerer", + "Hiccup", + "Hummer", + "Impaler", + "Inscriber", + "Itcher", + "Jangler", + "Jingler", + "Knocker", + "Lasher", + "Locker", + "Lugger", + "Mangler", + "Masher", + "Mauler", + "Mewer", + "Mimer", + "Molder", + "Nailer", + "Neigher", + "Nestler", + "Nibbler", + "Paddler", + "Piercer", + "Piper", + "Plunger", + "Presser", + "Prodder", + "Puffer", + "Raker", + "Rasper", + "Rattler", + "Ripper", + "Roarer", + "Roaster", + "Ruffler", + "Rustler", + "Scooper", + "Scorcher", + "Scratcher", + "Scribbler", + "Scrubber", + "Shaker", + "Shaver", + "Shearer", + "Shoveler", + "Shrieker", + "Sifter", + "Singer", + "Sketcher", + "Slammer", + "Slicer", + "Smasher", + "Snapper", + "Sneezer", + "Snorer", + "Spitter", + "Splasher", + "Splitter", + "Squeaker", + "Squealer", + "Squisher", + "Stamper", + "Stomper", + "Strangler", + "Striker", + "Strummer", + "Swatter", + "Sweeper", + "Swiper", + "Tinkerer", + "Trampler", + "Walloper", + "Whacker", + "Whipper", + "Whistler" + ], + "nm2": [ + "Albatross Call", + "Albatross Flap", + "Alligator Hiss", + "Alligator Roar", + "Ape Call", + "Ape Hoot", + "Ape Scratch", + "Aper", + "Badger Growl", + "Badger Run", + "Badger Scratch", + "Barker", + "Bat Flap", + "Bat Screech", + "Bat Swoop", + "Bear Growl", + "Bear Roar", + "Bear Rustle", + "Bear Step", + "Bear Stomp", + "Beaver Call", + "Beaver Chew", + "Beaver Nibble", + "Beaver Rustle", + "Bee Buzzer", + "Bison Breath", + "Bison Call", + "Bison Stomp", + "Bleater", + "Boar Charge", + "Boar Grunt", + "Boar Rustle", + "Boar Squeal", + "Boar Stamp", + "Boarer", + "Cackler", + "Cat Call", + "Cat Hiss", + "Cat Purr", + "Cat Rustle", + "Cat Scratch", + "Catter", + "Chirper", + "Cow Moo", + "Cow Step", + "Cow Stomp", + "Cower", + "Coyote Cackle", + "Coyote Howl", + "Coyote Yelp", + "Coyote Yowl", + "Cricket Chirp", + "Cricketer", + "Croaker", + "Crocodile Hiss", + "Crocodile Roar", + "Crocodiler", + "Crow Call", + "Crow Rustle", + "Crower", + "Deer Clash", + "Deer Rustle", + "Deer Scratch", + "Deer Stomp", + "Dino Chew", + "Dino Growl", + "Dino Roar", + "Dino Snort", + "Dino Stomp", + "Dog Bark", + "Dog Growl", + "Dog Howl", + "Dog Run", + "Dog Sneeze", + "Dog Step", + "Dog Wiggle", + "Dog Yelp", + "Dog Yip", + "Dog Yowl", + "Dogger", + "Donkey Call", + "Donkey Stomp", + "Dove Rustle", + "Dove Swoop", + "Dover", + "Dragon Bite", + "Dragon Breath", + "Dragon Chew", + "Dragon Roar", + "Dragon Swoop", + "Duck Quacker", + "Duck Rustle", + "Ducker", + "Eagle Screech", + "Elephant Roar", + "Elephant Stampede", + "Elephant Stomp", + "Falcon Rustle", + "Falcon Swoop", + "Fox Rustle", + "Fox Yelp", + "Fox Yowl", + "Foxer", + "Frog Croak", + "Frog Splash", + "Frogger", + "Gecko Croak", + "Giraffe Smash", + "Giraffe Snort", + "Giraffe Stomp", + "Goat Baa", + "Goat Bleat", + "Goat Chew", + "Goater", + "Goose Hiss", + "Goose Honk", + "Growler", + "Hamster Squeak", + "Hee-Haw", + "Hisser", + "Hog Oink", + "Hog Snort", + "Honker", + "Hooter", + "Horse Blow", + "Horse Neigh", + "Horse Sneeze", + "Horse Snort", + "Horse Stamp", + "Horse Whinny", + "Horser", + "Howler", + "Hyena Cackle", + "Hyena Laugh", + "Jackal Call", + "Jackal Laugh", + "Jackal Rustle", + "Lion Growl", + "Lion Roar", + "Monker", + "Monkey Howl", + "Monkey Rustle", + "Monkey Scream", + "Mouse Peep", + "Mouse Rustle", + "Mouse Squeak", + "Mouser", + "Nightingale Song", + "Nightingaler", + "Oinker", + "Owl Call", + "Owl Hoot", + "Owl Rustle", + "Owl Swoop", + "Owler", + "Panda Sneeze", + "Panther Growl", + "Panther Roar", + "Parrot", + "Parrot Bite", + "Parrot Call", + "Parrot Nibble", + "Parrot Rustle", + "Parrot Squawk", + "Parroter", + "Pheasant Call", + "Pheasant Rustle", + "Pig Snort", + "Pigeon Coo", + "Pigeon Rustle", + "Pigeoner", + "Quacker", + "Quail Call", + "Quail Rustle", + "Quailer", + "Rabbit Scream", + "Rabbit Yelp", + "Ram Ram", + "Ram Stamp", + "Rammer", + "Rat", + "Rat Rustle", + "Rat Squeak", + "Rat Yelp", + "Ratter", + "Raven Rustle", + "Rhino Snort", + "Rhino Stamp", + "Rook Rustle", + "Rooker", + "Screamer", + "Screecher", + "Seal Bark", + "Seal Flop", + "Sealer", + "Sheep Baa", + "Sheep Bleat", + "Singer", + "Snake Hiss", + "Snake Rattle", + "Snake Slither", + "Snaker", + "Snorter", + "Squawker", + "Squeaker", + "Squirrel Chatter", + "Squirrel Chitter", + "Squirrel Nibble", + "Squirrel Rustle", + "Squirreler", + "Stampede", + "Swan Cry", + "Swan Flap", + "Swan Hiss", + "Swan Honk", + "Swanner", + "Toad Croak", + "Trumpet", + "Trumpeter", + "Turkey Call", + "Turkey Gobble", + "Tweeter", + "Vulture Scream", + "Warbler", + "Whale Song", + "Wolf Growl", + "Wolf Howl", + "Wolf Yelp", + "Wolfer", + "Wolverine Growl", + "Wolverine Yelp" + ], + "nm3": [ + "Net Cast", + "Net Splash", + "Anchor Splash", + "Anchor Chain", + "Anchor Drop", + "Leather Smack", + "Leather Flick", + "Leather Drop", + "Hide Smack", + "Hide Flick", + "Hide Drop", + "Paint Drop", + "Paint Stroke", + "Paint Squeeze", + "Brush Stroke", + "Brush Flick", + "Hammer Crash", + "Hammer Drop", + "Hammer Clank", + "Nail Drop", + "Nail Tingle", + "Saw Drop", + "Saw Wobble", + "Saw Pull", + "Spade Dig", + "Spade Drop", + "Hoe Dig", + "Hoe Scrape", + "Hoe Scratch", + "Mallet Crash", + "Mallet Smash", + "Mallet Drop", + "Chisel Tick", + "Chisel Cut", + "Chisel Carve", + "Armor Clank", + "Armor Crash", + "Steel Clank", + "Steel Crash", + "Steel Drop", + "Furnace Roar", + "Furnace Door", + "Hatchet Cut", + "Hatchet Drop", + "Hatchet Split", + "Hatchet Chop", + "Wood Chop", + "Wood Crack", + "Wood Creak", + "Wood Drop", + "Tree Fall", + "Tree Creak", + "Fire Crackle", + "Fire Roar", + "Potion Bubble", + "Potion Crash", + "Potion Gush", + "Potion Swirl", + "Potion Splash", + "Kettle Bubble", + "Kettle Splash", + "Kettle Bubble", + "Cauldron Swirl", + "Cauldron Stir", + "Cauldron Bubble", + "Cauldron Splash", + "Bell Ring", + "Bell Drop", + "Crier Bell", + "Bowstring Flick", + "Bowstring Stretch", + "Blacksmith Clank", + "Lute Pluck", + "Lute String", + "Glass Shatter", + "Fruit Squish", + "Crate Smash", + "Crate Crack", + "Crate Creak", + "Ship Creak", + "Sail Slap", + "Rope Slap", + "Rope Whip", + "Book Drop", + "Book Slam", + "Page Turn", + "Grain Trash", + "Grain Mill", + "Cork Pop", + "Wood Scrape", + "Sail Flick" + ] +} \ No newline at end of file diff --git a/data/kobold.json b/data/kobold.json new file mode 100644 index 0000000..9ad2e58 --- /dev/null +++ b/data/kobold.json @@ -0,0 +1,90 @@ +{ + "nm1": [ + "", + "", + "", + "", + "d", + "g", + "h", + "k", + "m", + "n", + "r", + "s", + "sn", + "t", + "v", + "z" + ], + "nm2": [ + "a", + "e", + "i", + "o", + "u" + ], + "nm3": [ + "b", + "bl", + "d", + "dr", + "g", + "gg", + "gl", + "gn", + "gr", + "hz", + "hr", + "hl", + "hs", + "k", + "kk", + "kr", + "kl", + "kb", + "kd", + "l", + "ld", + "lb", + "lt", + "ll", + "lp", + "lg", + "p", + "pl", + "pp", + "r", + "rt", + "rp", + "rb", + "rk", + "t", + "tr", + "tl", + "v", + "vl", + "vn" + ], + "nm4": [ + "", + "", + "", + "", + "", + "d", + "g", + "gs", + "k", + "ks", + "m", + "n", + "r", + "rn", + "s", + "ss", + "tt", + "v", + "x" + ] +} \ No newline at end of file diff --git a/data/leonin.json b/data/leonin.json new file mode 100644 index 0000000..b680fd9 --- /dev/null +++ b/data/leonin.json @@ -0,0 +1,301 @@ +{ + "nm1": [ + "", + "", + "", + "b", + "br", + "d", + "dr", + "g", + "gr", + "k", + "kr", + "p", + "pr", + "t", + "tr", + "x", + "z" + ], + "nm2": [ + "y", + "a", + "e", + "i", + "o" + ], + "nm3": [ + "g", + "g", + "gn", + "gt", + "kn", + "kr", + "kt", + "kn", + "m", + "mn", + "pt", + "r", + "r", + "r", + "rt", + "rth", + "th", + "th", + "x", + "x" + ], + "nm4": [ + "a", + "a", + "e", + "e", + "i", + "o" + ], + "nm5": [ + "g", + "k", + "m", + "n", + "r", + "th" + ], + "nm6": [ + "io", + "eo", + "io", + "e", + "i", + "o", + "u", + "e", + "i", + "o", + "u", + "e", + "i", + "o", + "u", + "e", + "i", + "o", + "u" + ], + "nm7": [ + "", + "", + "n", + "r", + "s", + "z", + "n", + "r", + "s", + "z", + "n", + "r", + "s", + "z" + ], + "nm8": [ + "", + "", + "c", + "d", + "d", + "dr", + "g", + "g", + "gr", + "k", + "k", + "s", + "s", + "z", + "z" + ], + "nm9": [ + "ia", + "oi", + "io", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o" + ], + "nm10": [ + "c", + "g", + "l", + "m", + "n", + "nn", + "r", + "rr", + "t", + "x", + "z", + "dn", + "dm", + "gn", + "lm", + "ln", + "lr", + "mn", + "rm", + "rn", + "zr" + ], + "nm11": [ + "a", + "e", + "o" + ], + "nm12": [ + "g", + "l", + "m", + "mn", + "n", + "nd", + "r", + "t", + "th" + ], + "nm13": [ + "ia", + "a", + "e", + "e", + "a", + "e", + "e", + "a", + "e", + "e", + "a", + "e", + "e", + "a", + "e", + "e" + ], + "nm14": [ + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "z" + ], + "nm16": [ + "amber", + "autumn", + "bold", + "bronze", + "dawn", + "ember", + "fierce", + "flint", + "free", + "full", + "gloom", + "glow", + "golden", + "grand", + "great", + "hazel", + "iron", + "keen", + "light", + "lone", + "long", + "lunar", + "moon", + "plain", + "prime", + "proud", + "quick", + "rough", + "shadow", + "silent", + "smooth", + "soft", + "solar", + "spirit", + "star", + "storm", + "strong", + "summer", + "sun", + "swift", + "thunder", + "wild", + "wind", + "wise" + ], + "nm17": [ + "brace", + "breath", + "brow", + "caller", + "claw", + "dream", + "dreamer", + "drifter", + "eye", + "eyes", + "field", + "force", + "front", + "guide", + "guides", + "heart", + "hide", + "hold", + "kith", + "mane", + "mask", + "moon", + "pelt", + "pride", + "reach", + "rest", + "rider", + "roar", + "seeker", + "shadow", + "shield", + "song", + "stride", + "tail", + "tale", + "tooth", + "ward", + "watcher", + "weaver", + "whisper", + "wind" + ] +} \ No newline at end of file diff --git a/data/lizardfolk.json b/data/lizardfolk.json new file mode 100644 index 0000000..fa59885 --- /dev/null +++ b/data/lizardfolk.json @@ -0,0 +1,508 @@ +{ + "nm1": [ + "", + "", + "", + "", + "", + "b", + "d", + "g", + "jh", + "k", + "l", + "m", + "n", + "r", + "s", + "sh", + "t", + "tr", + "th", + "thr", + "v" + ], + "nm2": [ + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "aa", + "ae", + "ao", + "au" + ], + "nm3": [ + "ch", + "d", + "dr", + "dh", + "g", + "gr", + "gh", + "gg", + "l", + "ll", + "lt", + "lth", + "lr", + "p", + "r", + "rg", + "rht", + "rk", + "rt", + "rd", + "rth", + "sh", + "sk", + "shr", + "sh", + "sl", + "t", + "th", + "tr", + "thr" + ], + "nm4": [ + "a", + "e", + "i", + "o", + "u", + "y", + "a", + "e", + "i", + "o", + "u", + "y", + "a", + "e", + "i", + "o", + "u", + "y", + "a", + "e", + "i", + "o", + "u", + "y", + "a", + "e", + "i", + "o", + "u", + "y", + "a", + "e", + "i", + "o", + "u", + "y", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "ea", + "ua", + "ae", + "ia", + "aa", + "ao" + ], + "nm5": [ + "c", + "g", + "gr", + "gn", + "k", + "kh", + "kr", + "r", + "rr", + "s", + "ss", + "sr", + "st", + "str", + "t", + "th", + "tr" + ], + "nm6": [ + "", + "", + "", + "", + "", + "", + "", + "ch", + "k", + "n", + "nd", + "nk", + "nt", + "r", + "rd", + "rk", + "rt", + "rth", + "s", + "ss", + "sh", + "sj", + "sk", + "t", + "th", + "v", + "x" + ], + "nm7": [ + "Achiever", + "Advantage", + "Adventure", + "Air", + "Alarm", + "Ambition", + "Anger", + "Animal", + "Answer", + "Anxiety", + "Armor", + "Art", + "Artist", + "Author", + "Axe", + "Badge", + "Bait", + "Balance", + "Ball", + "Bank", + "Battle", + "Beach", + "Bead", + "Beam", + "Bean", + "Bear", + "Beast", + "Beetle", + "Beginning", + "Bell", + "Belt", + "Bird", + "Bite", + "Bitter", + "Black", + "Blade", + "Blood", + "Board", + "Bone", + "Book", + "Boot", + "Border", + "Bother", + "Bowl", + "Brain", + "Brass", + "Brave", + "Bravery", + "Bread", + "Breath", + "Burn", + "Button", + "Camp", + "Cart", + "Cash", + "Catch", + "Cave", + "Cell", + "Chain", + "Chalk", + "Challenge", + "Champion", + "Chance", + "Change", + "Chaos", + "Chest", + "Choice", + "Clever", + "Cloud", + "Clue", + "Comfort", + "Courage", + "Creative", + "Crimson", + "Crown", + "Cub", + "Curiosity", + "Dance", + "Danger", + "Dark", + "Demon", + "Desire", + "Dexterity", + "Diamond", + "Direction", + "Dirt", + "Double", + "Dragon", + "Dream", + "Earth", + "Edge", + "Effect", + "Elegance", + "Emerald", + "Emotion", + "Emphasis", + "Envy", + "Error", + "Eternity", + "Eye", + "Faith", + "Fall", + "Family", + "Fang", + "Farm", + "Fear", + "Feast", + "Fight", + "Final", + "Fire", + "Flame", + "Flight", + "Flower", + "Fluke", + "Force", + "Forever", + "Fortune", + "Freedom", + "Friend", + "Gem", + "Generous", + "Ghost", + "Gold", + "Good", + "Green", + "Guide", + "Habit", + "Half", + "Hammer", + "Happiness", + "Happy", + "Harmony", + "Hate", + "Heart", + "Hearth", + "Home", + "Honor", + "Horn", + "Ice", + "Icicle", + "Imagination", + "Impulse", + "Ink", + "Insect", + "Intelligent", + "Iron", + "Journey", + "Judgement", + "Justice", + "Kind", + "Kindness", + "Knowledge", + "Lesson", + "Liberty", + "Lie", + "Life", + "Light", + "Limit", + "Locket", + "Love", + "Many", + "Marble", + "Mark", + "Mask", + "Match", + "Memory", + "Mercy", + "Middle", + "Midnight", + "Might", + "Miracle", + "Misery", + "Mist", + "Moment", + "Moon", + "Mountain", + "Muscle", + "Nerve", + "Night", + "Nobody", + "Nothing", + "Omen", + "Orange", + "Paint", + "Paste", + "Patch", + "Patience", + "Patient", + "Piece", + "Pitch", + "Pleasure", + "Plenty", + "Pocket", + "Power", + "Pride", + "Promise", + "Prompt", + "Push", + "Question", + "Quick", + "Rabbit", + "Rain", + "Rainstorm", + "Range", + "Reason", + "Red", + "Relief", + "Reserve", + "Respect", + "Rest", + "Riches", + "Riddle", + "Ring", + "Risk", + "Rose", + "Rumor", + "Sanguine", + "Scent", + "Scratch", + "Secret", + "Sense", + "Serene", + "Shade", + "Shadow", + "Shell", + "Shock", + "Shot", + "Sign", + "Signal", + "Silver", + "Single", + "Skill", + "Sky", + "Sleep", + "Slice", + "Slide", + "Small", + "Smart", + "Smash", + "Smile", + "Smoke", + "Snow", + "Snowflake", + "Song", + "Sorrow", + "Spark", + "Sparkle", + "Spell", + "Spider", + "Spirit", + "Spite", + "Split", + "Steel", + "Stick", + "Stitch", + "Stock", + "Storm", + "Strength", + "Strike", + "Struggle", + "Tackle", + "Talent", + "Tell", + "Temper", + "Theory", + "Thicket", + "Thing", + "Thrill", + "Thunder", + "Tired", + "Tolerance", + "Tool", + "Travel", + "Trick", + "Trust", + "Truth", + "Tune", + "Twist", + "Victory", + "Village", + "Visitor", + "Voice", + "Voyage", + "Walk", + "War", + "Watch", + "Wave", + "Wealth", + "Welcome", + "Whole", + "Will", + "Wisdom", + "Wish", + "Wistle", + "Wonder", + "Wrath" + ] +} \ No newline at end of file diff --git a/data/locathah.json b/data/locathah.json new file mode 100644 index 0000000..a270cc4 --- /dev/null +++ b/data/locathah.json @@ -0,0 +1,64 @@ +{ + "nm1": [ + "d", + "dh", + "g", + "gh", + "h", + "k", + "kh", + "l", + "m", + "n", + "r", + "th", + "v", + "z" + ], + "nm2": [ + "a", + "e", + "i", + "o", + "u" + ], + "nm3": [ + "ao", + "au", + "ou", + "oa", + "d", + "l", + "ll", + "m", + "n", + "nn", + "r", + "rr", + "v", + "z", + "d", + "l", + "ll", + "m", + "n", + "nn", + "r", + "rr", + "v", + "z" + ], + "nm4": [ + "a", + "i", + "u" + ], + "nm5": [ + "l", + "m", + "n", + "s", + "t", + "th" + ] +} \ No newline at end of file diff --git a/data/loxodon.json b/data/loxodon.json new file mode 100644 index 0000000..faf874b --- /dev/null +++ b/data/loxodon.json @@ -0,0 +1,199 @@ +{ + "nm1": [ + "", + "", + "", + "b", + "br", + "ch", + "d", + "dr", + "g", + "h", + "k", + "n", + "r", + "s", + "sv", + "t", + "thr", + "v", + "vr", + "z" + ], + "nm2": [ + "oo", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o" + ], + "nm3": [ + "b", + "br", + "d", + "dj", + "dr", + "g", + "h", + "j", + "k", + "m", + "nd", + "ndr", + "nj", + "nr", + "nt", + "l", + "ld", + "ldr", + "lr", + "r", + "rd", + "s", + "t", + "y" + ], + "nm4": [ + "oo", + "e", + "o", + "u", + "o", + "u", + "e", + "o", + "u", + "o", + "u" + ], + "nm5": [ + "l", + "m", + "n", + "r" + ], + "nm6": [ + "j", + "l", + "m", + "n", + "s", + "v", + "z", + "zh" + ], + "nm7": [ + "", + "", + "", + "b", + "d", + "f", + "j", + "k", + "l", + "ly", + "m", + "r", + "s", + "sh", + "t", + "v", + "y", + "z" + ], + "nm8": [ + "oo", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u" + ], + "nm9": [ + "d", + "f", + "fy", + "j", + "l", + "ln", + "lr", + "lt", + "ly", + "n", + "nc", + "nt", + "ny", + "r", + "rj", + "s", + "sn", + "sm", + "sr", + "t", + "tr", + "v" + ], + "nm10": [ + "oo", + "a", + "i", + "u", + "a", + "i", + "u", + "a", + "i", + "u", + "e", + "e" + ], + "nm11": [ + "j", + "l", + "n", + "r", + "v", + "z" + ], + "nm12": [ + "a", + "e", + "i", + "o", + "u" + ], + "nm13": [ + "", + "", + "", + "", + "", + "j", + "l", + "m", + "n", + "r", + "s", + "y" + ] +} \ No newline at end of file diff --git a/data/minotaur.json b/data/minotaur.json new file mode 100644 index 0000000..9c3cbd7 --- /dev/null +++ b/data/minotaur.json @@ -0,0 +1,288 @@ +{ + "nmFF": [ + "Aam", + "Ane", + "Are", + "Ase", + "Den", + "Duo", + "Duu", + "Em", + "Enti", + "Era", + "Este", + "Fas", + "Fen", + "Hene", + "Hes", + "Hila", + "Hine", + "Ias", + "Ire", + "Ki", + "Kia", + "Kuo", + "Laan", + "Line", + "Loo", + "Mira", + "Mou", + "Muu", + "Nan", + "Nea", + "Neo", + "Noo", + "Nuo", + "Oen", + "Oes", + "Raas", + "Ras", + "Reo", + "Rina", + "Sees", + "Seo", + "Sina", + "Tee", + "Tes", + "Tia", + "Tina", + "Uova", + "Veo", + "Vi", + "Via", + "Weo", + "Wina" + ], + "nmFL": [ + "dane", + "dera", + "din", + "dra", + "fa", + "fen", + "fin", + "kane", + "kea", + "ken", + "kia", + "la", + "las", + "len", + "lian", + "lin", + "lo", + "mas", + "me", + "mi", + "min", + "mira", + "na", + "nan", + "nas", + "nim", + "nore", + "nu", + "pe", + "pen", + "ra", + "ren", + "res", + "rin", + "ris", + "ru", + "sen", + "sia", + "ta", + "ter", + "tin", + "tra", + "tred", + "tri", + "trin", + "tris", + "ven", + "vena", + "vera", + "vin", + "za", + "zara", + "zin" + ], + "nmMF": [ + "Ar", + "Are", + "Aste", + "Bar", + "Bjor", + "Bran", + "Car", + "Cod", + "Da", + "Djar", + "Djun", + "Doen", + "Dor", + "Drin", + "Dur", + "Far", + "Foos", + "Gar", + "Goe", + "Gra", + "Gran", + "Gun", + "Har", + "Hir", + "Hun", + "Ja", + "Jar", + "Kar", + "Kin", + "Kir", + "Koo", + "Koor", + "Kran", + "Krum", + "Kur", + "Man", + "Min", + "Mir", + "Mun", + "Nar", + "Noe", + "Noo", + "Pod", + "Rak", + "Te", + "Tir", + "Toon", + "Trak", + "Tur", + "Zam", + "Zar", + "Zun" + ], + "nmML": [ + "ban", + "baran", + "bur", + "dak", + "daran", + "diar", + "dor", + "drin", + "fajar", + "faruk", + "fran", + "furan", + "gajan", + "garak", + "giran", + "gur", + "jar", + "kan", + "kar", + "karat", + "kun", + "kurat", + "kus", + "manuk", + "marin", + "maruk", + "narak", + "nark", + "narun", + "nir", + "nus", + "paran", + "piran", + "raduk", + "rak", + "rakar", + "ranak", + "rapak", + "ras", + "rat", + "rilak", + "rios", + "ron", + "rus", + "rut", + "tagar", + "taruk", + "tiran", + "toron", + "turok", + "tus", + "vrak" + ], + "nmSF": [ + "Agile", + "Bear", + "Bold", + "Boulder", + "Brave", + "Bright", + "Fearless", + "Fist", + "Glory", + "Goblin", + "Great", + "Heavy", + "Honor", + "Iron", + "Jagged", + "Keen", + "Nimble", + "Orc", + "Rock", + "Rugged", + "Sharp", + "Silent", + "Single", + "Steady", + "Steel", + "Stone", + "Storm", + "Stout", + "Strong", + "Swift", + "Thick", + "Thunder", + "Tough", + "Truth", + "Valiant", + "Vigil", + "Wolf" + ], + "nmSL": [ + "bane", + "body", + "eye", + "fighter", + "fist", + "fury", + "hand", + "heart", + "hide", + "hoof", + "horn", + "horns", + "hunter", + "leader", + "mind", + "pelt", + "roar", + "runner", + "skin", + "skull", + "slash", + "slayer", + "speaker", + "step", + "striker", + "vigor", + "walker", + "warrior" + ] +} \ No newline at end of file diff --git a/data/modern-english.json b/data/modern-english.json new file mode 100644 index 0000000..f992414 --- /dev/null +++ b/data/modern-english.json @@ -0,0 +1,3289 @@ +{ + "nm1": [ + "Aaron", + "Adam", + "Aidan", + "Aiden", + "Alex", + "Alexander", + "Alfie", + "Andrew", + "Anthony", + "Archie", + "Arthur", + "Ashton", + "Bailey", + "Ben", + "Benjamin", + "Billy", + "Blake", + "Bobby", + "Bradley", + "Brandon", + "Caleb", + "Callum", + "Cameron", + "Charles", + "Charlie", + "Christopher", + "Cody", + "Connor", + "Corey", + "Daniel", + "David", + "Declan", + "Dexter", + "Dominic", + "Dylan", + "Edward", + "Elliot", + "Ellis", + "Ethan", + "Evan", + "Ewan", + "Finlay", + "Finley", + "Frankie", + "Freddie", + "Frederick", + "Gabriel", + "George", + "Harley", + "Harrison", + "Harry", + "Harvey", + "Hayden", + "Henry", + "Isaac", + "Jack", + "Jackson", + "Jacob", + "Jake", + "James", + "Jamie", + "Jay", + "Jayden", + "Jenson", + "Joe", + "Joel", + "John", + "Jonathan", + "Jordan", + "Joseph", + "Josh", + "Joshua", + "Jude", + "Kai", + "Kayden", + "Kian", + "Kieran", + "Kyle", + "Leo", + "Leon", + "Lewis", + "Liam", + "Logan", + "Louie", + "Louis", + "Luca", + "Lucas", + "Luke", + "Mason", + "Matthew", + "Max", + "Michael", + "Morgan", + "Nathan", + "Nicholas", + "Noah", + "Oliver", + "Ollie", + "Oscar", + "Owen", + "Patrick", + "Peter", + "Reece", + "Reuben", + "Rhys", + "Riley", + "Robert", + "Rory", + "Ryan", + "Sam", + "Samuel", + "Scott", + "Sean", + "Sebastian", + "Spencer", + "Stanley", + "Taylor", + "Theo", + "Thomas", + "Toby", + "Tom", + "Tommy", + "Tyler", + "William", + "Zac", + "Zachary", + "Zak" + ], + "nm2": [ + "Abbie", + "Abby", + "Abigail", + "Aimee", + "Alex", + "Alexandra", + "Alice", + "Alicia", + "Alisha", + "Amber", + "Amelia", + "Amelie", + "Amy", + "Anna", + "Ava", + "Bella", + "Bethany", + "Brooke", + "Caitlin", + "Cerys", + "Charlie", + "Charlotte", + "Chelsea", + "Chloe", + "Courtney", + "Daisy", + "Danielle", + "Demi", + "Eleanor", + "Eliza", + "Elizabeth", + "Ella", + "Ellie", + "Eloise", + "Elsie", + "Emilia", + "Emily", + "Emma", + "Erin", + "Esme", + "Eva", + "Eve", + "Evelyn", + "Evie", + "Faith", + "Freya", + "Georgia", + "Georgina", + "Grace", + "Gracie", + "Hannah", + "Harriet", + "Heidi", + "Hollie", + "Holly", + "Imogen", + "Isabel", + "Isabella", + "Isabelle", + "Isla", + "Isobel", + "Jade", + "Jasmine", + "Jennifer", + "Jessica", + "Jodie", + "Julia", + "Kate", + "Katherine", + "Katie", + "Kayla", + "Kayleigh", + "Keira", + "Lacey", + "Lara", + "Laura", + "Lauren", + "Layla", + "Leah", + "Lexi", + "Lexie", + "Libby", + "Lilly", + "Lily", + "Lola", + "Louise", + "Lucy", + "Lydia", + "Maddison", + "Madeleine", + "Madison", + "Maisie", + "Maisy", + "Maria", + "Martha", + "Matilda", + "Maya", + "Megan", + "Melissa", + "Mia", + "Millie", + "Mollie", + "Molly", + "Morgan", + "Mya", + "Naomi", + "Natasha", + "Niamh", + "Nicole", + "Olivia", + "Paige", + "Phoebe", + "Poppy", + "Rachel", + "Rebecca", + "Rose", + "Rosie", + "Ruby", + "Samantha", + "Sara", + "Sarah", + "Scarlett", + "Shannon", + "Sienna", + "Skye", + "Sofia", + "Sophia", + "Sophie", + "Summer", + "Tegan", + "Tia", + "Tilly", + "Victoria", + "Willow", + "Yasmin", + "Zara", + "Zoe" + ], + "nm3": [ + "Adams", + "Allen", + "Anderson", + "Andrews", + "Armstrong", + "Atkinson", + "Austin", + "Bailey", + "Baker", + "Ball", + "Barker", + "Barnes", + "Barrett", + "Bates", + "Baxter", + "Bell", + "Bennett", + "Berry", + "Black", + "Booth", + "Bradley", + "Brooks", + "Brown", + "Burke", + "Burns", + "Burton", + "Butler", + "Byrne", + "Campbell", + "Carr", + "Carter", + "Chambers", + "Chapman", + "Clark", + "Clarke", + "Cole", + "Collins", + "Cook", + "Cooke", + "Cooper", + "Cox", + "Cunningham", + "Davidson", + "Davies", + "Davis", + "Dawson", + "Day", + "Dean", + "Dixon", + "Doyle", + "Duncan", + "Edwards", + "Elliott", + "Ellis", + "Evans", + "Fisher", + "Fletcher", + "Foster", + "Fox", + "Francis", + "Fraser", + "Gallagher", + "Gardner", + "George", + "Gibson", + "Gill", + "Gordon", + "Graham", + "Grant", + "Gray", + "Green", + "Griffiths", + "Hall", + "Hamilton", + "Harper", + "Harris", + "Harrison", + "Hart", + "Harvey", + "Hawkins", + "Hayes", + "Henderson", + "Hill", + "Holland", + "Holmes", + "Hopkins", + "Houghton", + "Howard", + "Hudson", + "Hughes", + "Hunt", + "Hunter", + "Hussain", + "Jackson", + "James", + "Jenkins", + "John", + "Johnson", + "Johnston", + "Jones", + "Jordan", + "Kaur", + "Kelly", + "Kennedy", + "Khan", + "King", + "Knight", + "Lane", + "Lawrence", + "Lawson", + "Lee", + "Lewis", + "Lloyd", + "Lowe", + "Macdonald", + "Marsh", + "Marshall", + "Martin", + "Mason", + "Matthews", + "May", + "Mccarthy", + "Mcdonald", + "Miller", + "Mills", + "Mitchell", + "Moore", + "Morgan", + "Morris", + "Moss", + "Murphy", + "Murray", + "Newman", + "Nicholson", + "Owen", + "Palmer", + "Parker", + "Parry", + "Patel", + "Pearce", + "Pearson", + "Perry", + "Phillips", + "Poole", + "Porter", + "Powell", + "Price", + "Read", + "Rees", + "Reid", + "Reynolds", + "Richards", + "Richardson", + "Riley", + "Roberts", + "Robertson", + "Robinson", + "Rogers", + "Rose", + "Ross", + "Russell", + "Ryan", + "Saunders", + "Scott", + "Sharp", + "Shaw", + "Simpson", + "Smith", + "Spencer", + "Stevens", + "Stewart", + "Stone", + "Sutton", + "Taylor", + "Thomas", + "Thompson", + "Thomson", + "Turner", + "Walker", + "Wallace", + "Walsh", + "Ward", + "Watson", + "Watts", + "Webb", + "Wells", + "West", + "White", + "Wilkinson", + "Williams", + "Williamson", + "Willis", + "Wilson", + "Wood", + "Woods", + "Wright", + "Young" + ], + "nm4": [ + "Aaden", + "Aarav", + "Aaron", + "Abdiel", + "Abdullah", + "Abel", + "Abraham", + "Abram", + "Ace", + "Adam", + "Adan", + "Aden", + "Aditya", + "Adonis", + "Adrian", + "Adriel", + "Adrien", + "Agustin", + "Ahmad", + "Ahmed", + "Aidan", + "Aiden", + "Aidyn", + "Alan", + "Albert", + "Alberto", + "Alden", + "Aldo", + "Alec", + "Alejandro", + "Alessandro", + "Alex", + "Alexander", + "Alexis", + "Alexzander", + "Alfonso", + "Alfred", + "Alfredo", + "Alijah", + "Allan", + "Allen", + "Alonso", + "Alonzo", + "Alvaro", + "Alvin", + "Amari", + "Ameer", + "Amir", + "Amos", + "Anders", + "Anderson", + "Andre", + "Andres", + "Andrew", + "Andy", + "Angel", + "Angelo", + "Anthony", + "Antoine", + "Anton", + "Antonio", + "Apollo", + "Archer", + "Ari", + "Arian", + "Ariel", + "Arjun", + "Arlo", + "Armando", + "Armani", + "Arnav", + "Aron", + "Arthur", + "Arturo", + "Aryan", + "Asa", + "Asher", + "Ashton", + "Atticus", + "August", + "Augustine", + "Augustus", + "Austin", + "Austyn", + "Avery", + "Axel", + "Axton", + "Ayaan", + "Aydan", + "Ayden", + "Aydin", + "Barrett", + "Beau", + "Beckett", + "Beckham", + "Ben", + "Benjamin", + "Bennett", + "Benson", + "Bentlee", + "Bentley", + "Bently", + "Benton", + "Billy", + "Blaine", + "Blaise", + "Blake", + "Blaze", + "Bo", + "Bobby", + "Bodhi", + "Boston", + "Bowen", + "Braden", + "Bradley", + "Brady", + "Bradyn", + "Braeden", + "Braiden", + "Branden", + "Brandon", + "Branson", + "Brantley", + "Braxton", + "Brayan", + "Brayden", + "Braydon", + "Braylen", + "Braylon", + "Brecken", + "Brendan", + "Brenden", + "Brendon", + "Brennan", + "Brennen", + "Brent", + "Brentley", + "Brenton", + "Brett", + "Brian", + "Brice", + "Bridger", + "Briggs", + "Brock", + "Broderick", + "Brodie", + "Brody", + "Brogan", + "Bronson", + "Brooks", + "Bruce", + "Bruno", + "Bryan", + "Bryant", + "Bryce", + "Brycen", + "Bryson", + "Byron", + "Cade", + "Caden", + "Cael", + "Caiden", + "Cain", + "Cale", + "Caleb", + "Callan", + "Callen", + "Callum", + "Calvin", + "Camden", + "Camdyn", + "Cameron", + "Camilo", + "Camren", + "Camron", + "Camryn", + "Cannon", + "Carl", + "Carlos", + "Carmelo", + "Carson", + "Carter", + "Case", + "Casen", + "Casey", + "Cash", + "Cason", + "Cassius", + "Cayden", + "Cayson", + "Cedric", + "Cesar", + "Chace", + "Chad", + "Chaim", + "Chance", + "Chandler", + "Channing", + "Charles", + "Charlie", + "Chase", + "Chris", + "Christian", + "Christopher", + "Clark", + "Clay", + "Clayton", + "Clinton", + "Cody", + "Cohen", + "Colby", + "Cole", + "Coleman", + "Colin", + "Collin", + "Colt", + "Colten", + "Colton", + "Conner", + "Connor", + "Conor", + "Conrad", + "Cooper", + "Corbin", + "Corey", + "Cory", + "Craig", + "Crew", + "Cristian", + "Cristopher", + "Crosby", + "Cruz", + "Cullen", + "Curtis", + "Cyrus", + "Dakota", + "Dallas", + "Dalton", + "Damarion", + "Damian", + "Damien", + "Damion", + "Damon", + "Dane", + "Dangelo", + "Daniel", + "Danny", + "Dante", + "Darian", + "Dariel", + "Darien", + "Dario", + "Darius", + "Darnell", + "Darrell", + "Darren", + "Darryl", + "Darwin", + "Davian", + "David", + "Davin", + "Davion", + "Davis", + "Davon", + "Dawson", + "Dax", + "Daxton", + "Dayton", + "Deacon", + "Dean", + "Deandre", + "Deangelo", + "Declan", + "Deegan", + "Demarcus", + "Demetrius", + "Dennis", + "Denzel", + "Deon", + "Derek", + "Derick", + "Derrick", + "Deshawn", + "Desmond", + "Devan", + "Devin", + "Devon", + "Dexter", + "Diego", + "Dillon", + "Dominic", + "Dominick", + "Dominik", + "Dominique", + "Donald", + "Donovan", + "Donte", + "Dorian", + "Douglas", + "Drake", + "Draven", + "Drew", + "Duncan", + "Dustin", + "Dwayne", + "Dylan", + "Ean", + "Easton", + "Eddie", + "Eden", + "Edgar", + "Edison", + "Eduardo", + "Edward", + "Edwin", + "Efrain", + "Eli", + "Elian", + "Elias", + "Elijah", + "Eliot", + "Eliseo", + "Elisha", + "Elliot", + "Elliott", + "Ellis", + "Emanuel", + "Emerson", + "Emery", + "Emiliano", + "Emilio", + "Emmanuel", + "Emmett", + "Emmitt", + "Emory", + "Enrique", + "Enzo", + "Eric", + "Erick", + "Erik", + "Ernest", + "Ernesto", + "Esteban", + "Ethan", + "Eugene", + "Evan", + "Everett", + "Ezekiel", + "Ezequiel", + "Ezra", + "Fabian", + "Felipe", + "Felix", + "Fernando", + "Finley", + "Finn", + "Finnegan", + "Fisher", + "Fletcher", + "Flynn", + "Foster", + "Francis", + "Francisco", + "Franco", + "Frank", + "Frankie", + "Franklin", + "Freddy", + "Frederick", + "Gabriel", + "Gael", + "Gage", + "Gaige", + "Garrett", + "Gary", + "Gauge", + "Gavin", + "Gavyn", + "George", + "Gerald", + "Gerardo", + "Giancarlo", + "Gianni", + "Gibson", + "Gideon", + "Gilbert", + "Gilberto", + "Giovani", + "Giovanni", + "Giovanny", + "Grady", + "Graeme", + "Graham", + "Grant", + "Graysen", + "Grayson", + "Gregory", + "Greyson", + "Griffin", + "Guillermo", + "Gunnar", + "Gunner", + "Gustavo", + "Hamza", + "Hank", + "Harley", + "Harold", + "Harper", + "Harrison", + "Harry", + "Harvey", + "Hassan", + "Hayden", + "Hayes", + "Heath", + "Hector", + "Hendrix", + "Henry", + "Hezekiah", + "Holden", + "Houston", + "Howard", + "Hudson", + "Hugh", + "Hugo", + "Hunter", + "Ian", + "Ibrahim", + "Ignacio", + "Iker", + "Immanuel", + "Isaac", + "Isai", + "Isaiah", + "Isaias", + "Ishaan", + "Isiah", + "Ismael", + "Israel", + "Issac", + "Ivan", + "Izaiah", + "Izayah", + "Jabari", + "Jace", + "Jack", + "Jackson", + "Jacob", + "Jacoby", + "Jaden", + "Jadiel", + "Jadon", + "Jaeden", + "Jael", + "Jagger", + "Jaiden", + "Jaidyn", + "Jaime", + "Jairo", + "Jake", + "Jakob", + "Jalen", + "Jamal", + "Jamar", + "Jamari", + "Jamarion", + "James", + "Jameson", + "Jamie", + "Jamir", + "Jamison", + "Jared", + "Jarrett", + "Jase", + "Jasiah", + "Jason", + "Jasper", + "Javier", + "Javion", + "Javon", + "Jax", + "Jaxen", + "Jaxon", + "Jaxson", + "Jaxton", + "Jay", + "Jayce", + "Jaycob", + "Jayden", + "Jaydon", + "Jaylen", + "Jaylin", + "Jaylon", + "Jayson", + "Jedidiah", + "Jefferson", + "Jeffery", + "Jeffrey", + "Jensen", + "Jeremiah", + "Jeremy", + "Jermaine", + "Jerome", + "Jerry", + "Jesse", + "Jessie", + "Jett", + "Jimmy", + "Jionni", + "Joaquin", + "Joe", + "Joel", + "Joey", + "Johan", + "Johann", + "John", + "Johnathan", + "Johnathon", + "Johnny", + "Jon", + "Jonah", + "Jonas", + "Jonathan", + "Jonathon", + "Jordan", + "Jorden", + "Jordyn", + "Jorge", + "Jose", + "Joseph", + "Joshua", + "Josiah", + "Josue", + "Jovani", + "Jovanni", + "Joziah", + "Juan", + "Judah", + "Jude", + "Juelz", + "Julian", + "Julien", + "Julio", + "Julius", + "Junior", + "Justice", + "Justin", + "Justus", + "Kade", + "Kaden", + "Kaeden", + "Kael", + "Kai", + "Kaiden", + "Kale", + "Kaleb", + "Kamari", + "Kamden", + "Kameron", + "Kamron", + "Kamryn", + "Kane", + "Kareem", + "Karsen", + "Karson", + "Karter", + "Kase", + "Kasen", + "Kash", + "Kason", + "Kayden", + "Kaysen", + "Kayson", + "Keagan", + "Keaton", + "Keegan", + "Keenan", + "Keith", + "Kellan", + "Kellen", + "Kelvin", + "Kendall", + "Kendrick", + "Kenneth", + "Kenny", + "Kevin", + "Khalil", + "Kian", + "Kieran", + "Killian", + "King", + "Kingsley", + "Kingston", + "Knox", + "Kobe", + "Kody", + "Kohen", + "Kolby", + "Kole", + "Kolten", + "Kolton", + "Konner", + "Konnor", + "Korbin", + "Krish", + "Kristian", + "Kristopher", + "Kylan", + "Kyle", + "Kylen", + "Kyler", + "Kymani", + "Kyree", + "Kyrie", + "Kyson", + "Lamar", + "Lance", + "Landen", + "Landon", + "Landry", + "Landyn", + "Lane", + "Larry", + "Lawrence", + "Lawson", + "Layne", + "Layton", + "Leandro", + "Lee", + "Legend", + "Leland", + "Lennon", + "Lennox", + "Leo", + "Leon", + "Leonard", + "Leonardo", + "Leonel", + "Leonidas", + "Leroy", + "Levi", + "Lewis", + "Liam", + "Lincoln", + "Lionel", + "Logan", + "London", + "Lorenzo", + "Louis", + "Luca", + "Lucas", + "Lucca", + "Lucian", + "Luciano", + "Luis", + "Luka", + "Lukas", + "Luke", + "Lyric", + "Mack", + "Madden", + "Maddox", + "Maison", + "Major", + "Makai", + "Makhi", + "Malachi", + "Malakai", + "Malaki", + "Malcolm", + "Malik", + "Manuel", + "Marc", + "Marcel", + "Marcelo", + "Marco", + "Marcos", + "Marcus", + "Mario", + "Mark", + "Markus", + "Marlon", + "Marquis", + "Marshall", + "Martin", + "Marvin", + "Masen", + "Mason", + "Mateo", + "Mathew", + "Mathias", + "Matias", + "Matteo", + "Matthew", + "Matthias", + "Maurice", + "Mauricio", + "Maverick", + "Max", + "Maxim", + "Maximilian", + "Maximiliano", + "Maximo", + "Maximus", + "Maxton", + "Maxwell", + "Mayson", + "Mekhi", + "Melvin", + "Memphis", + "Messiah", + "Micah", + "Michael", + "Micheal", + "Miguel", + "Mike", + "Miles", + "Milo", + "Misael", + "Mitchell", + "Mohamed", + "Mohammad", + "Mohammed", + "Moises", + "Morgan", + "Myles", + "Nash", + "Nasir", + "Nathan", + "Nathanael", + "Nathaniel", + "Nehemiah", + "Neil", + "Nelson", + "Neymar", + "Nicholas", + "Nickolas", + "Nico", + "Nicolas", + "Niko", + "Nikolai", + "Nikolas", + "Nixon", + "Noah", + "Noe", + "Noel", + "Nolan", + "Oakley", + "Odin", + "Oliver", + "Omar", + "Omari", + "Orion", + "Orlando", + "Oscar", + "Osvaldo", + "Otto", + "Owen", + "Pablo", + "Parker", + "Patrick", + "Paul", + "Paxton", + "Payton", + "Pedro", + "Peter", + "Peyton", + "Philip", + "Phillip", + "Phoenix", + "Pierce", + "Porter", + "Preston", + "Prince", + "Princeton", + "Quentin", + "Quincy", + "Quinn", + "Quintin", + "Quinton", + "Rafael", + "Raiden", + "Ramiro", + "Ramon", + "Randall", + "Randy", + "Raphael", + "Rashad", + "Raul", + "Ray", + "Rayan", + "Rayden", + "Raylan", + "Raymond", + "Reagan", + "Reece", + "Reed", + "Reese", + "Reginald", + "Reid", + "Remington", + "Remy", + "Rene", + "Reuben", + "Rex", + "Rey", + "Rhett", + "Rhys", + "Ricardo", + "Richard", + "Ricky", + "Riley", + "River", + "Robert", + "Roberto", + "Rocco", + "Roderick", + "Rodney", + "Rodolfo", + "Rodrigo", + "Rogelio", + "Roger", + "Rohan", + "Roland", + "Rolando", + "Roman", + "Romeo", + "Ronald", + "Ronan", + "Ronin", + "Ronnie", + "Rory", + "Ross", + "Rowan", + "Rowen", + "Roy", + "Royce", + "Ruben", + "Rudy", + "Russell", + "Ryan", + "Ryder", + "Ryker", + "Rylan", + "Ryland", + "Rylee", + "Rylen", + "Sage", + "Sam", + "Samson", + "Samuel", + "Saul", + "Sawyer", + "Scott", + "Seamus", + "Sean", + "Sebastian", + "Semaj", + "Sergio", + "Seth", + "Shane", + "Shaun", + "Shawn", + "Sheldon", + "Sidney", + "Silas", + "Simeon", + "Simon", + "Sincere", + "Skylar", + "Skyler", + "Solomon", + "Sonny", + "Soren", + "Spencer", + "Stanley", + "Stefan", + "Stephen", + "Sterling", + "Steve", + "Steven", + "Sullivan", + "Sylas", + "Talon", + "Tanner", + "Tate", + "Tatum", + "Taylor", + "Teagan", + "Terrance", + "Terrell", + "Terrence", + "Terry", + "Thaddeus", + "Theo", + "Theodore", + "Thiago", + "Thomas", + "Timothy", + "Titan", + "Titus", + "Tobias", + "Toby", + "Todd", + "Tomas", + "Tommy", + "Tony", + "Trace", + "Travis", + "Trent", + "Trenton", + "Trevon", + "Trevor", + "Trey", + "Tripp", + "Tristan", + "Tristen", + "Tristian", + "Tristin", + "Triston", + "Troy", + "Truman", + "Trystan", + "Tucker", + "Turner", + "Ty", + "Tyler", + "Tyree", + "Tyrell", + "Tyrone", + "Tyson", + "Ulises", + "Uriah", + "Uriel", + "Urijah", + "Valentin", + "Valentino", + "Van", + "Vance", + "Vaughn", + "Vicente", + "Victor", + "Vihaan", + "Vincent", + "Vincenzo", + "Wade", + "Walker", + "Walter", + "Warren", + "Waylon", + "Wayne", + "Wesley", + "Westin", + "Weston", + "Will", + "William", + "Willie", + "Wilson", + "Winston", + "Wyatt", + "Xander", + "Xavi", + "Xavier", + "Xzavier", + "Yael", + "Yahir", + "Yandel", + "Yehuda", + "Yosef", + "Yousef", + "Yusuf", + "Zachariah", + "Zachary", + "Zackary", + "Zaid", + "Zaiden", + "Zain", + "Zaire", + "Zander", + "Zane", + "Zavier", + "Zayden", + "Zayne", + "Zechariah", + "Zeke", + "Zion" + ], + "nm5": [ + "Sophia", + "Emma", + "Isabella", + "Olivia", + "Ava", + "Emily", + "Abigail", + "Mia", + "Madison", + "Elizabeth", + "Chloe", + "Ella", + "Avery", + "Addison", + "Aubrey", + "Lily", + "Natalie", + "Sofia", + "Charlotte", + "Zoey", + "Grace", + "Hannah", + "Amelia", + "Harper", + "Lillian", + "Samantha", + "Evelyn", + "Victoria", + "Brooklyn", + "Zoe", + "Layla", + "Hailey", + "Leah", + "Kaylee", + "Anna", + "Aaliyah", + "Gabriella", + "Allison", + "Nevaeh", + "Alexis", + "Audrey", + "Savannah", + "Sarah", + "Alyssa", + "Claire", + "Taylor", + "Riley", + "Camila", + "Arianna", + "Ashley", + "Brianna", + "Sophie", + "Peyton", + "Bella", + "Khloe", + "Genesis", + "Alexa", + "Serenity", + "Kylie", + "Aubree", + "Scarlett", + "Stella", + "Maya", + "Katherine", + "Julia", + "Lucy", + "Madelyn", + "Autumn", + "Makayla", + "Kayla", + "Mackenzie", + "Lauren", + "Gianna", + "Ariana", + "Faith", + "Alexandra", + "Melanie", + "Sydney", + "Bailey", + "Caroline", + "Naomi", + "Morgan", + "Kennedy", + "Ellie", + "Jasmine", + "Eva", + "Skylar", + "Kimberly", + "Violet", + "Molly", + "Aria", + "Jocelyn", + "Trinity", + "London", + "Lydia", + "Madeline", + "Reagan", + "Piper", + "Andrea", + "Annabelle", + "Maria", + "Brooke", + "Payton", + "Paisley", + "Paige", + "Ruby", + "Nora", + "Mariah", + "Rylee", + "Lilly", + "Brielle", + "Jade", + "Destiny", + "Nicole", + "Mila", + "Kendall", + "Liliana", + "Kaitlyn", + "Natalia", + "Sadie", + "Jordyn", + "Vanessa", + "Mary", + "Mya", + "Penelope", + "Isabelle", + "Alice", + "Reese", + "Gabrielle", + "Hadley", + "Katelyn", + "Angelina", + "Rachel", + "Isabel", + "Eleanor", + "Clara", + "Brooklynn", + "Jessica", + "Elena", + "Aliyah", + "Vivian", + "Laila", + "Sara", + "Amy", + "Eliana", + "Lyla", + "Juliana", + "Valeria", + "Adriana", + "Makenzie", + "Elise", + "Mckenzie", + "Quinn", + "Delilah", + "Cora", + "Kylee", + "Rebecca", + "Gracie", + "Izabella", + "Josephine", + "Alaina", + "Michelle", + "Jennifer", + "Eden", + "Valentina", + "Aurora", + "Catherine", + "Stephanie", + "Valerie", + "Jayla", + "Willow", + "Daisy", + "Alana", + "Melody", + "Hazel", + "Summer", + "Melissa", + "Margaret", + "Kinsley", + "Kinley", + "Ariel", + "Lila", + "Giselle", + "Ryleigh", + "Haley", + "Julianna", + "Ivy", + "Alivia", + "Brynn", + "Keira", + "Daniela", + "Aniyah", + "Angela", + "Kate", + "Londyn", + "Hayden", + "Harmony", + "Adalyn", + "Megan", + "Allie", + "Gabriela", + "Alayna", + "Presley", + "Jenna", + "Alexandria", + "Ashlyn", + "Adrianna", + "Jada", + "Fiona", + "Norah", + "Emery", + "Maci", + "Miranda", + "Ximena", + "Amaya", + "Cecilia", + "Ana", + "Shelby", + "Katie", + "Hope", + "Callie", + "Jordan", + "Luna", + "Leilani", + "Eliza", + "Mckenna", + "Angel", + "Genevieve", + "Makenna", + "Isla", + "Lola", + "Danielle", + "Chelsea", + "Leila", + "Tessa", + "Adelyn", + "Camille", + "Mikayla", + "Adeline", + "Adalynn", + "Sienna", + "Esther", + "Jacqueline", + "Emerson", + "Arabella", + "Maggie", + "Athena", + "Lucia", + "Lexi", + "Ayla", + "Diana", + "Alexia", + "Juliet", + "Josie", + "Allyson", + "Addyson", + "Delaney", + "Teagan", + "Marley", + "Amber", + "Rose", + "Erin", + "Leslie", + "Kayleigh", + "Amanda", + "Kathryn", + "Kelsey", + "Emilia", + "Alina", + "Kenzie", + "Kaydence", + "Alicia", + "Alison", + "Paris", + "Sabrina", + "Ashlynn", + "Lilliana", + "Sierra", + "Cassidy", + "Laura", + "Alondra", + "Iris", + "Kyla", + "Christina", + "Carly", + "Jillian", + "Madilyn", + "Kyleigh", + "Madeleine", + "Cadence", + "Nina", + "Evangeline", + "Nadia", + "Raegan", + "Lyric", + "Giuliana", + "Briana", + "Georgia", + "Yaretzi", + "Elliana", + "Haylee", + "Fatima", + "Phoebe", + "Selena", + "Charlie", + "Dakota", + "Annabella", + "Abby", + "Daniella", + "Juliette", + "Lilah", + "Bianca", + "Mariana", + "Miriam", + "Parker", + "Veronica", + "Gemma", + "Noelle", + "Cheyenne", + "Marissa", + "Heaven", + "Vivienne", + "Brynlee", + "Joanna", + "Mallory", + "Aubrie", + "Journey", + "Nyla", + "Cali", + "Tatum", + "Carmen", + "Gia", + "Jazmine", + "Heidi", + "Miley", + "Baylee", + "Elaina", + "Macy", + "Ainsley", + "Jane", + "Raelynn", + "Anastasia", + "Adelaide", + "Ruth", + "Camryn", + "Kiara", + "Alessandra", + "Hanna", + "Finley", + "Maddison", + "Lia", + "Bethany", + "Karen", + "Kelly", + "Malia", + "Jazmin", + "Jayda", + "Esmeralda", + "Kira", + "Lena", + "Kamryn", + "Kamila", + "Karina", + "Eloise", + "Kara", + "Elisa", + "Rylie", + "Olive", + "Nayeli", + "Tiffany", + "Macie", + "Skyler", + "Addisyn", + "Angelica", + "Briella", + "Fernanda", + "Annie", + "Maliyah", + "Amiyah", + "Jayden", + "Charlee", + "Caitlyn", + "Elle", + "Crystal", + "Julie", + "Imani", + "Kendra", + "Talia", + "Angelique", + "Jazlyn", + "Guadalupe", + "Alejandra", + "Emely", + "Lucille", + "Anya", + "April", + "Elsie", + "Madelynn", + "Myla", + "Julissa", + "Scarlet", + "Helen", + "Breanna", + "Kyra", + "Madisyn", + "Rosalie", + "Brittany", + "Brylee", + "Jayleen", + "Arielle", + "Karla", + "Kailey", + "Arya", + "Sarai", + "Harley", + "Miracle", + "Kaelyn", + "Kali", + "Cynthia", + "Daphne", + "Aleah", + "Caitlin", + "Cassandra", + "Holly", + "Janelle", + "Marilyn", + "Katelynn", + "Kaylie", + "Itzel", + "Carolina", + "Bristol", + "Haven", + "Michaela", + "Monica", + "June", + "Janiyah", + "Camilla", + "Jamie", + "Rebekah", + "Audrina", + "Dayana", + "Lana", + "Serena", + "Tiana", + "Nylah", + "Braelyn", + "Savanna", + "Skye", + "Raelyn", + "Madalyn", + "Sasha", + "Perla", + "Bridget", + "Aniya", + "Rowan", + "Logan", + "Mckinley", + "Averie", + "Jaylah", + "Aylin", + "Joselyn", + "Nia", + "Hayley", + "Lilian", + "Adelynn", + "Jaliyah", + "Kassidy", + "Kaylin", + "Kadence", + "Celeste", + "Jaelyn", + "Zariah", + "Tatiana", + "Jimena", + "Lilyana", + "Anaya", + "Catalina", + "Viviana", + "Cataleya", + "Sloane", + "Courtney", + "Johanna", + "Amari", + "Melany", + "Anabelle", + "Francesca", + "Ada", + "Alanna", + "Priscilla", + "Danna", + "Angie", + "Kailyn", + "Lacey", + "Sage", + "Lillie", + "Brinley", + "Caylee", + "Joy", + "Kenley", + "Vera", + "Bailee", + "Amira", + "Aileen", + "Aspen", + "Emmalyn", + "Erica", + "Gracelyn", + "Kennedi", + "Skyla", + "Annalise", + "Danica", + "Dylan", + "Kiley", + "Gwendolyn", + "Jasmin", + "Lauryn", + "Aleena", + "Justice", + "Annabel", + "Tenley", + "Dahlia", + "Gloria", + "Lexie", + "Lindsey", + "Hallie", + "Sylvia", + "Elyse", + "Annika", + "Maeve", + "Marlee", + "Aryanna", + "Kenya", + "Lorelei", + "Selah", + "Kaliyah", + "Adele", + "Natasha", + "Brenda", + "Erika", + "Alyson", + "Braylee", + "Emilee", + "Raven", + "Ariella", + "Blakely", + "Liana", + "Jaycee", + "Sawyer", + "Anahi", + "Jaelynn", + "Elsa", + "Farrah", + "Cameron", + "Evelynn", + "Luciana", + "Zara", + "Madilynn", + "Eve", + "Kaia", + "Helena", + "Anne", + "Estrella", + "Leighton", + "Nataly", + "Whitney", + "Lainey", + "Amara", + "Anabella", + "Malaysia", + "Samara", + "Zoie", + "Amani", + "Phoenix", + "Dulce", + "Paola", + "Marie", + "Aisha", + "Harlow", + "Virginia", + "Ember", + "Regina", + "Jaylee", + "Anika", + "Ally", + "Kayden", + "Alani", + "Miah", + "Yareli", + "Journee", + "Kiera", + "Nathalie", + "Mikaela", + "Jaylynn", + "Litzy", + "Charley", + "Claudia", + "Aliya", + "Madyson", + "Cecelia", + "Liberty", + "Braelynn", + "Evie", + "Rosemary", + "Myah", + "Lizbeth", + "Giana", + "Ryan", + "Teresa", + "Ciara", + "Isis", + "Lea", + "Shayla", + "Jazlynn", + "Rosa", + "Gracelynn", + "Desiree", + "Elisabeth", + "Isabela", + "Arely", + "Mariam", + "Abbigail", + "Emersyn", + "Brenna", + "Kaylynn", + "Nova", + "Raquel", + "Dana", + "Laney", + "Laylah", + "Siena", + "Amelie", + "Clarissa", + "Lilianna", + "Lylah", + "Halle", + "Madalynn", + "Maleah", + "Sherlyn", + "Linda", + "Shiloh", + "Jessie", + "Kenia", + "Greta", + "Marina", + "Melina", + "Amiya", + "Bria", + "Natalee", + "Sariah", + "Mollie", + "Nancy", + "Christine", + "Felicity", + "Zuri", + "Irene", + "Simone", + "Amya", + "Matilda", + "Colette", + "Kristen", + "Paityn", + "Alayah", + "Janiya", + "Kallie", + "Mira", + "Hailee", + "Kathleen", + "Meredith", + "Janessa", + "Noemi", + "Aiyana", + "Aliana", + "Leia", + "Mariyah", + "Tori", + "Alissa", + "Ivanna", + "Joslyn", + "Sandra", + "Maryam", + "Saniyah", + "Kassandra", + "Danika", + "Denise", + "Jemma", + "River", + "Charleigh", + "Emelia", + "Kristina", + "Armani", + "Beatrice", + "Jaylene", + "Karlee", + "Blake", + "Cara", + "Addilyn", + "Amina", + "Ansley", + "Kaitlynn", + "Iliana", + "Mckayla", + "Adelina", + "Briley", + "Elaine", + "Lailah", + "Mercedes", + "Chaya", + "Lindsay", + "Hattie", + "Lisa", + "Marisol", + "Patricia", + "Bryanna", + "Taliyah", + "Adrienne", + "Emmy", + "Millie", + "Paislee", + "Charli", + "Kourtney", + "Leyla", + "Maia", + "Willa", + "Milan", + "Paula", + "Ayleen", + "Clare", + "Kensley", + "Reyna", + "Martha", + "Adley", + "Elianna", + "Emilie", + "Karsyn", + "Yasmin", + "Lorelai", + "Amirah", + "Aryana", + "Livia", + "Alena", + "Kiana", + "Celia", + "Kailee", + "Rylan", + "Ellen", + "Galilea", + "Kynlee", + "Leanna", + "Renata", + "Mae", + "Ayanna", + "Chanel", + "Lesly", + "Cindy", + "Carla", + "Pearl", + "Jaylin", + "Kimora", + "Angeline", + "Carlee", + "Aubri", + "Edith", + "Alia", + "Frances", + "Corinne", + "Jocelynn", + "Cherish", + "Wendy", + "Carolyn", + "Lina", + "Tabitha", + "Winter", + "Abril", + "Bryn", + "Jolie", + "Yaritza", + "Casey", + "Zion", + "Lillianna", + "Jordynn", + "Zariyah", + "Audriana", + "Jayde", + "Jaida", + "Salma", + "Diamond", + "Malaya", + "Kimber", + "Ryann", + "Abbie", + "Paloma", + "Destinee", + "Kaleigh", + "Asia", + "Demi", + "Yamileth", + "Deborah", + "Elin", + "Kaiya", + "Mara", + "Averi", + "Nola", + "Tara", + "Taryn", + "Emmalee", + "Aubrianna", + "Janae", + "Kyndall", + "Jewel", + "Zaniyah", + "Kaya", + "Sonia", + "Alaya", + "Heather", + "Nathaly", + "Shannon", + "Ariah", + "Avah", + "Giada", + "Lilith", + "Samiyah", + "Sharon", + "Coraline", + "Eileen", + "Julianne", + "Milania", + "Chana", + "Regan", + "Krystal", + "Rihanna", + "Sidney", + "Hadassah", + "Macey", + "Mina", + "Paulina", + "Rayne", + "Kaitlin", + "Maritza", + "Susan", + "Raina", + "Hana", + "Keyla", + "Temperance", + "Aimee", + "Alisson", + "Charlize", + "Kendal", + "Lara", + "Roselyn", + "Alannah", + "Alma", + "Dixie", + "Larissa", + "Patience", + "Taraji", + "Sky", + "Zaria", + "Aleigha", + "Alyvia", + "Aviana", + "Bryleigh", + "Elliot", + "Jenny", + "Luz", + "Ali", + "Alisha", + "Ayana", + "Campbell", + "Karis", + "Lilyanna", + "Azaria", + "Blair", + "Micah", + "Moriah", + "Myra", + "Lilia", + "Aliza", + "Giovanna", + "Karissa", + "Saniya", + "Emory", + "Estella", + "Juniper", + "Kairi", + "Kenna", + "Meghan", + "Abrielle", + "Elissa", + "Rachael", + "Emmaline", + "Jolene", + "Joyce", + "Britney", + "Carlie", + "Haylie", + "Judith", + "Renee", + "Saanvi", + "Yesenia", + "Barbara", + "Dallas", + "Jaqueline", + "Karma", + "America", + "Sariyah", + "Azalea", + "Everly", + "Ingrid", + "Lillyana", + "Emmalynn", + "Marianna", + "Brisa", + "Kaelynn", + "Leona", + "Libby", + "Deanna", + "Mattie", + "Miya", + "Annalee", + "Nahla", + "Dorothy", + "Kaylyn", + "Rayna", + "Araceli", + "Cambria", + "Evalyn", + "Haleigh", + "Thalia", + "Jakayla", + "Maliah", + "Saige", + "Avianna", + "Charity", + "Kaylen", + "Raylee", + "Tamia", + "Aubrielle", + "Bayleigh", + "Carley", + "Kailynn", + "Katrina", + "Belen", + "Karlie", + "Natalya", + "Alaysia", + "Celine", + "Milana", + "Monroe", + "Estelle", + "Meadow", + "Audrianna", + "Cristina", + "Harlee", + "Jazzlyn", + "Scarlette", + "Zahra", + "Akira", + "Ann", + "Collins", + "Kendyl", + "Anabel", + "Azariah", + "Carissa", + "Milena", + "Tia", + "Alisa", + "Bree", + "Carleigh", + "Cheyanne", + "Sarahi", + "Laurel", + "Kylah", + "Tinley", + "Kora", + "Marisa", + "Esme", + "Sloan", + "Cailyn", + "Gisselle", + "Kasey", + "Kyndal", + "Marlene", + "Riya", + "Annabell", + "Aubriana", + "Izabelle", + "Kirsten", + "Aya", + "Dalilah", + "Devyn", + "Geraldine", + "Analia", + "Hayleigh", + "Landry", + "Sofie", + "Tess", + "Ashtyn", + "Jessa", + "Katalina" + ], + "nm6": [ + "Abbott", + "Acevedo", + "Acosta", + "Adams", + "Adkins", + "Aguilar", + "Aguirre", + "Albert", + "Alexander", + "Alford", + "Allen", + "Allison", + "Alston", + "Anderson", + "Andrews", + "Anthony", + "Armstrong", + "Arnold", + "Ashley", + "Atkins", + "Atkinson", + "Austin", + "Avery", + "Avila", + "Ayala", + "Ayers", + "Bailey", + "Baird", + "Baker", + "Baldwin", + "Ball", + "Ballard", + "Banks", + "Barber", + "Barker", + "Barlow", + "Barnes", + "Barnett", + "Barr", + "Barrera", + "Barrett", + "Barron", + "Barry", + "Bartlett", + "Barton", + "Bass", + "Bates", + "Battle", + "Bauer", + "Baxter", + "Beach", + "Bean", + "Beard", + "Beasley", + "Beck", + "Becker", + "Bell", + "Bender", + "Benjamin", + "Bennett", + "Benson", + "Bentley", + "Benton", + "Berg", + "Berger", + "Bernard", + "Berry", + "Best", + "Bird", + "Bishop", + "Black", + "Blackburn", + "Blackwell", + "Blair", + "Blake", + "Blanchard", + "Blankenship", + "Blevins", + "Bolton", + "Bond", + "Bonner", + "Booker", + "Boone", + "Booth", + "Bowen", + "Bowers", + "Bowman", + "Boyd", + "Boyer", + "Boyle", + "Bradford", + "Bradley", + "Bradshaw", + "Brady", + "Branch", + "Bray", + "Brennan", + "Brewer", + "Bridges", + "Briggs", + "Bright", + "Britt", + "Brock", + "Brooks", + "Brown", + "Browning", + "Bruce", + "Bryan", + "Bryant", + "Buchanan", + "Buck", + "Buckley", + "Buckner", + "Bullock", + "Burch", + "Burgess", + "Burke", + "Burks", + "Burnett", + "Burns", + "Burris", + "Burt", + "Burton", + "Bush", + "Butler", + "Byers", + "Byrd", + "Cabrera", + "Cain", + "Calderon", + "Caldwell", + "Calhoun", + "Callahan", + "Camacho", + "Cameron", + "Campbell", + "Campos", + "Cannon", + "Cantrell", + "Cantu", + "Cardenas", + "Carey", + "Carlson", + "Carney", + "Carpenter", + "Carr", + "Carrillo", + "Carroll", + "Carson", + "Carter", + "Carver", + "Case", + "Casey", + "Cash", + "Castaneda", + "Castillo", + "Castro", + "Cervantes", + "Chambers", + "Chan", + "Chandler", + "Chaney", + "Chang", + "Chapman", + "Charles", + "Chase", + "Chavez", + "Chen", + "Cherry", + "Christensen", + "Christian", + "Church", + "Clark", + "Clarke", + "Clay", + "Clayton", + "Clements", + "Clemons", + "Cleveland", + "Cline", + "Cobb", + "Cochran", + "Coffey", + "Cohen", + "Cole", + "Coleman", + "Collier", + "Collins", + "Colon", + "Combs", + "Compton", + "Conley", + "Conner", + "Conrad", + "Contreras", + "Conway", + "Cook", + "Cooke", + "Cooley", + "Cooper", + "Copeland", + "Cortez", + "Cote", + "Cotton", + "Cox", + "Craft", + "Craig", + "Crane", + "Crawford", + "Crosby", + "Cross", + "Cruz", + "Cummings", + "Cunningham", + "Curry", + "Curtis", + "Dale", + "Dalton", + "Daniel", + "Daniels", + "Daugherty", + "Davenport", + "David", + "Davidson", + "Davis", + "Dawson", + "Day", + "Dean", + "Decker", + "Dejesus", + "Delacruz", + "Delaney", + "Deleon", + "Delgado", + "Dennis", + "Diaz", + "Dickerson", + "Dickson", + "Dillard", + "Dillon", + "Dixon", + "Dodson", + "Dominguez", + "Donaldson", + "Donovan", + "Dorsey", + "Dotson", + "Douglas", + "Downs", + "Doyle", + "Drake", + "Dudley", + "Duffy", + "Duke", + "Duncan", + "Dunlap", + "Dunn", + "Duran", + "Durham", + "Dyer", + "Eaton", + "Edwards", + "Elliott", + "Ellis", + "Ellison", + "Emerson", + "England", + "English", + "Erickson", + "Espinoza", + "Estes", + "Estrada", + "Evans", + "Everett", + "Ewing", + "Farley", + "Farmer", + "Farrell", + "Faulkner", + "Ferguson", + "Fernandez", + "Ferrell", + "Fields", + "Figueroa", + "Finch", + "Finley", + "Fischer", + "Fisher", + "Fitzgerald", + "Fitzpatrick", + "Fleming", + "Fletcher", + "Flores", + "Flowers", + "Floyd", + "Flynn", + "Foley", + "Forbes", + "Ford", + "Foreman", + "Foster", + "Fowler", + "Fox", + "Francis", + "Franco", + "Frank", + "Franklin", + "Franks", + "Frazier", + "Frederick", + "Freeman", + "French", + "Frost", + "Fry", + "Frye", + "Fuentes", + "Fuller", + "Fulton", + "Gaines", + "Gallagher", + "Gallegos", + "Galloway", + "Gamble", + "Garcia", + "Gardner", + "Garner", + "Garrett", + "Garrison", + "Garza", + "Gates", + "Gay", + "Gentry", + "George", + "Gibbs", + "Gibson", + "Gilbert", + "Giles", + "Gill", + "Gillespie", + "Gilliam", + "Gilmore", + "Glass", + "Glenn", + "Glover", + "Goff", + "Golden", + "Gomez", + "Gonzales", + "Gonzalez", + "Good", + "Goodman", + "Goodwin", + "Gordon", + "Gould", + "Graham", + "Grant", + "Graves", + "Gray", + "Green", + "Greene", + "Greer", + "Gregory", + "Griffin", + "Griffith", + "Grimes", + "Gross", + "Guerra", + "Guerrero", + "Guthrie", + "Gutierrez", + "Guy", + "Guzman", + "Hahn", + "Hale", + "Haley", + "Hall", + "Hamilton", + "Hammond", + "Hampton", + "Hancock", + "Haney", + "Hansen", + "Hanson", + "Hardin", + "Harding", + "Hardy", + "Harmon", + "Harper", + "Harrell", + "Harrington", + "Harris", + "Harrison", + "Hart", + "Hartman", + "Harvey", + "Hatfield", + "Hawkins", + "Hayden", + "Hayes", + "Haynes", + "Hays", + "Head", + "Heath", + "Hebert", + "Henderson", + "Hendricks", + "Hendrix", + "Henry", + "Hensley", + "Henson", + "Herman", + "Hernandez", + "Herrera", + "Herring", + "Hess", + "Hester", + "Hewitt", + "Hickman", + "Hicks", + "Higgins", + "Hill", + "Hines", + "Hinton", + "Hobbs", + "Hodge", + "Hodges", + "Hoffman", + "Hogan", + "Holcomb", + "Holden", + "Holder", + "Holland", + "Holloway", + "Holman", + "Holmes", + "Holt", + "Hood", + "Hooper", + "Hoover", + "Hopkins", + "Hopper", + "Horn", + "Horne", + "Horton", + "House", + "Houston", + "Howard", + "Howe", + "Howell", + "Hubbard", + "Huber", + "Hudson", + "Huff", + "Huffman", + "Hughes", + "Hull", + "Humphrey", + "Hunt", + "Hunter", + "Hurley", + "Hurst", + "Hutchinson", + "Hyde", + "Ingram", + "Irwin", + "Jackson", + "Jacobs", + "Jacobson", + "James", + "Jarvis", + "Jefferson", + "Jenkins", + "Jennings", + "Jensen", + "Jimenez", + "Johns", + "Johnson", + "Johnston", + "Jones", + "Jordan", + "Joseph", + "Joyce", + "Joyner", + "Juarez", + "Justice", + "Kane", + "Kaufman", + "Keith", + "Keller", + "Kelley", + "Kelly", + "Kemp", + "Kennedy", + "Kent", + "Kerr", + "Key", + "Kidd", + "Kim", + "King", + "Kinney", + "Kirby", + "Kirk", + "Kirkland", + "Klein", + "Kline", + "Knapp", + "Knight", + "Knowles", + "Knox", + "Koch", + "Kramer", + "Lamb", + "Lambert", + "Lancaster", + "Landry", + "Lane", + "Lang", + "Langley", + "Lara", + "Larsen", + "Larson", + "Lawrence", + "Lawson", + "Leach", + "Leblanc", + "Lee", + "Leon", + "Leonard", + "Lester", + "Levine", + "Levy", + "Lewis", + "Lindsay", + "Lindsey", + "Little", + "Livingston", + "Lloyd", + "Logan", + "Long", + "Lopez", + "Lott", + "Love", + "Lowe", + "Loyd", + "Lucas", + "Luna", + "Lynch", + "Mack", + "Maddox", + "Maldonado", + "Malone", + "Mann", + "Manning", + "Marin", + "Mark", + "Marks", + "Marquez", + "Marshall", + "Martin", + "Martinez", + "Mason", + "Mathews", + "Matthews", + "Maxwell", + "Mayer", + "Mcbride", + "Mccall", + "Mccarthy", + "Mcdaniel", + "Mcdonald", + "Mcfarland", + "Mcguire", + "Mckenzie", + "Mckinney", + "Mclaughlin", + "Mclean", + "Mclendon", + "Mcmillan", + "Mcpherson", + "Mejia", + "Melendez", + "Mendez", + "Mercado", + "Merritt", + "Meyer", + "Michaels", + "Middleton", + "Miller", + "Mills", + "Miranda", + "Mitchell", + "Monroe", + "Montgomery", + "Morales", + "Morgan", + "Morris", + "Morrison", + "Moss", + "Mueller", + "Murray", + "Navarro", + "Neal", + "Nelson", + "Nieves", + "Nixon", + "Noble", + "Norton", + "Ochoa", + "Oliver", + "Olson", + "Ortega", + "Ortiz", + "Osborne", + "Owen", + "Pacheco", + "Palacios", + "Palmer", + "Parker", + "Parrish", + "Patel", + "Patterson", + "Pena", + "Peralta", + "Perez", + "Perry", + "Peterson", + "Pineda", + "Pittman", + "Ponce", + "Pope", + "Porter", + "Quintero", + "Ramirez", + "Ramos", + "Randall", + "Rangel", + "Reed", + "Reese", + "Reyes", + "Rhodes", + "Rivera", + "Rivas", + "Roberts", + "Robertson", + "Robinson", + "Rodriguez", + "Rodrigues", + "Rogers", + "Romero", + "Rosales", + "Rose", + "Ross", + "Rubio", + "Ruiz", + "Salas", + "Salinas", + "Sampson", + "Sanders", + "Santiago", + "Santos", + "Sapp", + "Schmidt", + "Schneider", + "Scott", + "Serrano", + "Shaw", + "Shepherd", + "Simmons", + "Sims", + "Smith", + "Soto", + "Sparks", + "Spencer", + "Stevens", + "Stewart", + "Stone", + "Sutton", + "Taylor", + "Thomas", + "Thompson", + "Thomson", + "Turner", + "Valdez", + "Vargas", + "Vasquez", + "Vaughn", + "Vega", + "Velasquez", + "Wade", + "Walker", + "Wallace", + "Walsh", + "Ward", + "Watson", + "Watts", + "Webb", + "Wells", + "West", + "White", + "Wilkinson", + "Williams", + "Williamson", + "Willis", + "Wilson", + "Wood", + "Woods", + "Wright", + "Young" + ], + "nm7": [ + "Aaren", + "Addison", + "Aiden", + "Alex", + "Alexis", + "Ali", + "Angel", + "Ash", + "Ashley", + "Ashton", + "Aubrey", + "Avery", + "Bailey", + "Bennie", + "Bev", + "Billie", + "Billy", + "Blair", + "Blake", + "Bret", + "Brett", + "Brice", + "Brook", + "Brynn", + "Caden", + "Cameron", + "Carmen", + "Carol", + "Casey", + "Charlie", + "Chris", + "Clem", + "Cory", + "Dane", + "Danni", + "Danny", + "Denny", + "Drew", + "Eli", + "Elliot", + "Emerson", + "Erin", + "Fran", + "Frankie", + "Franky", + "Gabby", + "Gabe", + "Gail", + "Gale", + "Gene", + "Glen", + "Glenn", + "Haiden", + "Harley", + "Harper", + "Hayden", + "Jackie", + "Jaden", + "Jaime", + "Jamie", + "Jess", + "Jesse", + "Jessie", + "Jo", + "Jody", + "Jordan", + "Jude", + "Justice", + "Kai", + "Kerry", + "Kiran", + "Kit", + "Kris", + "Lane", + "Lee", + "Leigh", + "Lesley", + "Leslie", + "Logan", + "Lynn", + "Maddox", + "Marley", + "Mason", + "Mel", + "Mell", + "Morgan", + "Nicky", + "Noel", + "Phoenix", + "Quinn", + "Ray", + "Raylee", + "Reed", + "Reggie", + "Rene", + "Riley", + "River", + "Robin", + "Rory", + "Rowan", + "Rudy", + "Ryan", + "Sam", + "Sammy", + "Shay", + "Sidney", + "Silver", + "Skye", + "Skylar", + "Skyler", + "Steff", + "Tanner", + "Taylor", + "Terry", + "Tyler", + "Val", + "Vic", + "Will", + "Willy" + ] +} \ No newline at end of file diff --git a/data/modern-portuguese-eu.json b/data/modern-portuguese-eu.json new file mode 100644 index 0000000..5eb8d11 --- /dev/null +++ b/data/modern-portuguese-eu.json @@ -0,0 +1,595 @@ +{ + "nm1": [ + "João", + "Miguel", + "Martim", + "Francisco", + "Santiago", + "Afonso", + "Tomás", + "Gonçalo", + "Rodrigo", + "Duarte", + "Gabriel", + "Pedro", + "Guilherme", + "Diogo", + "Tiago", + "Rafael", + "David", + "Simão", + "Lucas", + "André", + "Gustavo", + "Henrique", + "Alexandre", + "António", + "Bernardo", + "Samuel", + "Leonardo", + "Vasco", + "Manuel", + "Eduardo", + "Bruno", + "Filipe", + "Ricardo", + "Daniel", + "Carlos", + "Paulo", + "Jorge", + "Luís", + "Rui", + "Mário", + "Hugo", + "Nuno", + "Artur", + "Salvador", + "Leandro", + "Caio", + "Enzo", + "Valentim", + "Isaac", + "Noah", + "Lourenço", + "Mateus", + "Ângelo", + "Frederico", + "Ivo", + "Cristiano", + "Adriano", + "Gil", + "Edgar", + "Armando", + "Emanuel", + "Renato", + "Vítor", + "Cláudio", + "César", + "Joaquim", + "Américo", + "Álvaro", + "Bento", + "Celso", + "Dinis", + "Estêvão", + "Fausto", + "Gaspar", + "Horácio", + "Inácio", + "Júlio", + "Lázaro", + "Moisés", + "Nélson", + "Orlando", + "Pascoal", + "Quim", + "Raimundo", + "Serafim", + "Tobias", + "Ulisses", + "Valério", + "Xavier", + "Zacarias" + ], + "nm2": [ + "Maria", + "Matilde", + "Leonor", + "Carolina", + "Mariana", + "Beatriz", + "Ana", + "Inês", + "Lara", + "Margarida", + "Sofia", + "Francisca", + "Clara", + "Mafalda", + "Camila", + "Gabriela", + "Bárbara", + "Joana", + "Catarina", + "Isabel", + "Rita", + "Luana", + "Marta", + "Eva", + "Lia", + "Alice", + "Helena", + "Filipa", + "Daniela", + "Sara", + "Patrícia", + "Raquel", + "Teresa", + "Susana", + "Diana", + "Vera", + "Andreia", + "Célia", + "Débora", + "Elsa", + "Fátima", + "Graça", + "Helena", + "Irene", + "Jéssica", + "Liliana", + "Mónica", + "Natália", + "Olga", + "Paula", + "Renata", + "Sandra", + "Tatiana", + "Vânia", + "Zélia", + "Bruna", + "Cândida", + "Dalila", + "Ema", + "Fabiana", + "Glória", + "Heloísa", + "Ivone", + "Júlia", + "Lídia", + "Madalena", + "Nádia", + "Odete", + "Palmira", + "Quitéria", + "Rosário", + "Sílvia", + "Telma", + "Ursula", + "Vanessa", + "Ximena", + "Zita" + ], + "nm3": [ + "Silva", + "Santos", + "Ferreira", + "Pereira", + "Oliveira", + "Costa", + "Rodrigues", + "Martins", + "Jesus", + "Sousa", + "Fernandes", + "Gonçalves", + "Gomes", + "Lopes", + "Marques", + "Alves", + "Almeida", + "Ribeiro", + "Pinto", + "Carvalho", + "Teixeira", + "Moreira", + "Correia", + "Mendes", + "Nunes", + "Soares", + "Vieira", + "Monteiro", + "Cardoso", + "Rocha", + "Cruz", + "Cunha", + "Pires", + "Barbosa", + "Machado", + "Moura", + "Dias", + "Simões", + "Antunes", + "Fonseca", + "Freitas", + "Ramos", + "Azevedo", + "Castro", + "Campos", + "Borges", + "Peixoto", + "Figueiredo", + "Neves", + "Batista", + "Matos", + "Tavares", + "Mota", + "Pinheiro", + "Coelho", + "Aguiar", + "Macedo", + "Valente", + "Moura", + "Lima", + "Menezes", + "Bento", + "Coutinho", + "Faria", + "Leite", + "Barros", + "Amaral", + "Serra", + "Prata", + "Lacerda", + "Guedes", + "Mira", + "Bastos", + "Carmo", + "Duarte", + "Esteves", + "Franco", + "Garcia", + "Henriques", + "Jardim", + "Lourenço", + "Macedo", + "Nóbrega", + "Pacheco", + "Queirós", + "Reis", + "Sá", + "Teles", + "Vaz", + "Xavier", + "Zagalo" + ], + "nm4": [ + "João", + "Miguel", + "Martim", + "Francisco", + "Santiago", + "Afonso", + "Tomás", + "Gonçalo", + "Rodrigo", + "Duarte", + "Gabriel", + "Pedro", + "Guilherme", + "Diogo", + "Tiago", + "Rafael", + "David", + "Simão", + "Lucas", + "André", + "Gustavo", + "Henrique", + "Alexandre", + "António", + "Bernardo", + "Samuel", + "Leonardo", + "Vasco", + "Manuel", + "Eduardo", + "Bruno", + "Filipe", + "Ricardo", + "Daniel", + "Carlos", + "Paulo", + "Jorge", + "Luís", + "Rui", + "Mário", + "Hugo", + "Nuno", + "Artur", + "Salvador", + "Leandro", + "Caio", + "Enzo", + "Valentim", + "Isaac", + "Noah", + "Lourenço", + "Mateus", + "Ângelo", + "Frederico", + "Ivo", + "Cristiano", + "Adriano", + "Gil", + "Edgar", + "Armando", + "Emanuel", + "Renato", + "Vítor", + "Cláudio", + "César", + "Joaquim", + "Américo", + "Álvaro", + "Bento", + "Celso", + "Dinis", + "Estêvão", + "Fausto", + "Gaspar", + "Horácio", + "Inácio", + "Júlio", + "Lázaro", + "Moisés", + "Nélson", + "Orlando", + "Pascoal", + "Quim", + "Raimundo", + "Serafim", + "Tobias", + "Ulisses", + "Valério", + "Xavier", + "Zacarias" + ], + "nm5": [ + "Maria", + "Matilde", + "Leonor", + "Carolina", + "Mariana", + "Beatriz", + "Ana", + "Inês", + "Lara", + "Margarida", + "Sofia", + "Francisca", + "Clara", + "Mafalda", + "Camila", + "Gabriela", + "Bárbara", + "Joana", + "Catarina", + "Isabel", + "Rita", + "Luana", + "Marta", + "Eva", + "Lia", + "Alice", + "Helena", + "Filipa", + "Daniela", + "Sara", + "Patrícia", + "Raquel", + "Teresa", + "Susana", + "Diana", + "Vera", + "Andreia", + "Célia", + "Débora", + "Elsa", + "Fátima", + "Graça", + "Helena", + "Irene", + "Jéssica", + "Liliana", + "Mónica", + "Natália", + "Olga", + "Paula", + "Renata", + "Sandra", + "Tatiana", + "Vânia", + "Zélia", + "Bruna", + "Cândida", + "Dalila", + "Ema", + "Fabiana", + "Glória", + "Heloísa", + "Ivone", + "Júlia", + "Lídia", + "Madalena", + "Nádia", + "Odete", + "Palmira", + "Quitéria", + "Rosário", + "Sílvia", + "Telma", + "Ursula", + "Vanessa", + "Ximena", + "Zita" + ], + "nm6": [ + "Silva", + "Santos", + "Ferreira", + "Pereira", + "Oliveira", + "Costa", + "Rodrigues", + "Martins", + "Jesus", + "Sousa", + "Fernandes", + "Gonçalves", + "Gomes", + "Lopes", + "Marques", + "Alves", + "Almeida", + "Ribeiro", + "Pinto", + "Carvalho", + "Teixeira", + "Moreira", + "Correia", + "Mendes", + "Nunes", + "Soares", + "Vieira", + "Monteiro", + "Cardoso", + "Rocha", + "Cruz", + "Cunha", + "Pires", + "Barbosa", + "Machado", + "Moura", + "Dias", + "Simões", + "Antunes", + "Fonseca", + "Freitas", + "Ramos", + "Azevedo", + "Castro", + "Campos", + "Borges", + "Peixoto", + "Figueiredo", + "Neves", + "Batista", + "Matos", + "Tavares", + "Mota", + "Pinheiro", + "Coelho", + "Aguiar", + "Macedo", + "Valente", + "Moura", + "Lima", + "Menezes", + "Bento", + "Coutinho", + "Faria", + "Leite", + "Barros", + "Amaral", + "Serra", + "Prata", + "Lacerda", + "Guedes", + "Mira", + "Bastos", + "Carmo", + "Duarte", + "Esteves", + "Franco", + "Garcia", + "Henriques", + "Jardim", + "Lourenço", + "Macedo", + "Nóbrega", + "Pacheco", + "Queirós", + "Reis", + "Sá", + "Teles", + "Vaz", + "Xavier", + "Zagalo" + ], + "nm7": [ + "Alex", + "André", + "Ariel", + "Bruno", + "Caio", + "Cris", + "Daniel", + "Dani", + "Duarte", + "Edu", + "Filipe", + "Gabriel", + "Gil", + "Henrique", + "Jo", + "João", + "Jorge", + "José", + "Leo", + "Lucas", + "Luís", + "Manu", + "Marco", + "Marcos", + "Mário", + "Miguel", + "Nuno", + "Paulo", + "Pedro", + "Rafa", + "Ricardo", + "Rui", + "Samuel", + "Sandro", + "Tiago", + "Tomás", + "Vasco", + "Vítor", + "Ana", + "Bia", + "Bruna", + "Catarina", + "Clara", + "Diana", + "Filipa", + "Gabi", + "Helena", + "Inês", + "Joana", + "Lara", + "Leonor", + "Luana", + "Mafalda", + "Maria", + "Mariana", + "Marta", + "Matilde", + "Patrícia", + "Rita", + "Sara", + "Sofia", + "Teresa", + "Vera" + ] +} \ No newline at end of file diff --git a/data/modern-portuguese.json b/data/modern-portuguese.json new file mode 100644 index 0000000..5eb8d11 --- /dev/null +++ b/data/modern-portuguese.json @@ -0,0 +1,595 @@ +{ + "nm1": [ + "João", + "Miguel", + "Martim", + "Francisco", + "Santiago", + "Afonso", + "Tomás", + "Gonçalo", + "Rodrigo", + "Duarte", + "Gabriel", + "Pedro", + "Guilherme", + "Diogo", + "Tiago", + "Rafael", + "David", + "Simão", + "Lucas", + "André", + "Gustavo", + "Henrique", + "Alexandre", + "António", + "Bernardo", + "Samuel", + "Leonardo", + "Vasco", + "Manuel", + "Eduardo", + "Bruno", + "Filipe", + "Ricardo", + "Daniel", + "Carlos", + "Paulo", + "Jorge", + "Luís", + "Rui", + "Mário", + "Hugo", + "Nuno", + "Artur", + "Salvador", + "Leandro", + "Caio", + "Enzo", + "Valentim", + "Isaac", + "Noah", + "Lourenço", + "Mateus", + "Ângelo", + "Frederico", + "Ivo", + "Cristiano", + "Adriano", + "Gil", + "Edgar", + "Armando", + "Emanuel", + "Renato", + "Vítor", + "Cláudio", + "César", + "Joaquim", + "Américo", + "Álvaro", + "Bento", + "Celso", + "Dinis", + "Estêvão", + "Fausto", + "Gaspar", + "Horácio", + "Inácio", + "Júlio", + "Lázaro", + "Moisés", + "Nélson", + "Orlando", + "Pascoal", + "Quim", + "Raimundo", + "Serafim", + "Tobias", + "Ulisses", + "Valério", + "Xavier", + "Zacarias" + ], + "nm2": [ + "Maria", + "Matilde", + "Leonor", + "Carolina", + "Mariana", + "Beatriz", + "Ana", + "Inês", + "Lara", + "Margarida", + "Sofia", + "Francisca", + "Clara", + "Mafalda", + "Camila", + "Gabriela", + "Bárbara", + "Joana", + "Catarina", + "Isabel", + "Rita", + "Luana", + "Marta", + "Eva", + "Lia", + "Alice", + "Helena", + "Filipa", + "Daniela", + "Sara", + "Patrícia", + "Raquel", + "Teresa", + "Susana", + "Diana", + "Vera", + "Andreia", + "Célia", + "Débora", + "Elsa", + "Fátima", + "Graça", + "Helena", + "Irene", + "Jéssica", + "Liliana", + "Mónica", + "Natália", + "Olga", + "Paula", + "Renata", + "Sandra", + "Tatiana", + "Vânia", + "Zélia", + "Bruna", + "Cândida", + "Dalila", + "Ema", + "Fabiana", + "Glória", + "Heloísa", + "Ivone", + "Júlia", + "Lídia", + "Madalena", + "Nádia", + "Odete", + "Palmira", + "Quitéria", + "Rosário", + "Sílvia", + "Telma", + "Ursula", + "Vanessa", + "Ximena", + "Zita" + ], + "nm3": [ + "Silva", + "Santos", + "Ferreira", + "Pereira", + "Oliveira", + "Costa", + "Rodrigues", + "Martins", + "Jesus", + "Sousa", + "Fernandes", + "Gonçalves", + "Gomes", + "Lopes", + "Marques", + "Alves", + "Almeida", + "Ribeiro", + "Pinto", + "Carvalho", + "Teixeira", + "Moreira", + "Correia", + "Mendes", + "Nunes", + "Soares", + "Vieira", + "Monteiro", + "Cardoso", + "Rocha", + "Cruz", + "Cunha", + "Pires", + "Barbosa", + "Machado", + "Moura", + "Dias", + "Simões", + "Antunes", + "Fonseca", + "Freitas", + "Ramos", + "Azevedo", + "Castro", + "Campos", + "Borges", + "Peixoto", + "Figueiredo", + "Neves", + "Batista", + "Matos", + "Tavares", + "Mota", + "Pinheiro", + "Coelho", + "Aguiar", + "Macedo", + "Valente", + "Moura", + "Lima", + "Menezes", + "Bento", + "Coutinho", + "Faria", + "Leite", + "Barros", + "Amaral", + "Serra", + "Prata", + "Lacerda", + "Guedes", + "Mira", + "Bastos", + "Carmo", + "Duarte", + "Esteves", + "Franco", + "Garcia", + "Henriques", + "Jardim", + "Lourenço", + "Macedo", + "Nóbrega", + "Pacheco", + "Queirós", + "Reis", + "Sá", + "Teles", + "Vaz", + "Xavier", + "Zagalo" + ], + "nm4": [ + "João", + "Miguel", + "Martim", + "Francisco", + "Santiago", + "Afonso", + "Tomás", + "Gonçalo", + "Rodrigo", + "Duarte", + "Gabriel", + "Pedro", + "Guilherme", + "Diogo", + "Tiago", + "Rafael", + "David", + "Simão", + "Lucas", + "André", + "Gustavo", + "Henrique", + "Alexandre", + "António", + "Bernardo", + "Samuel", + "Leonardo", + "Vasco", + "Manuel", + "Eduardo", + "Bruno", + "Filipe", + "Ricardo", + "Daniel", + "Carlos", + "Paulo", + "Jorge", + "Luís", + "Rui", + "Mário", + "Hugo", + "Nuno", + "Artur", + "Salvador", + "Leandro", + "Caio", + "Enzo", + "Valentim", + "Isaac", + "Noah", + "Lourenço", + "Mateus", + "Ângelo", + "Frederico", + "Ivo", + "Cristiano", + "Adriano", + "Gil", + "Edgar", + "Armando", + "Emanuel", + "Renato", + "Vítor", + "Cláudio", + "César", + "Joaquim", + "Américo", + "Álvaro", + "Bento", + "Celso", + "Dinis", + "Estêvão", + "Fausto", + "Gaspar", + "Horácio", + "Inácio", + "Júlio", + "Lázaro", + "Moisés", + "Nélson", + "Orlando", + "Pascoal", + "Quim", + "Raimundo", + "Serafim", + "Tobias", + "Ulisses", + "Valério", + "Xavier", + "Zacarias" + ], + "nm5": [ + "Maria", + "Matilde", + "Leonor", + "Carolina", + "Mariana", + "Beatriz", + "Ana", + "Inês", + "Lara", + "Margarida", + "Sofia", + "Francisca", + "Clara", + "Mafalda", + "Camila", + "Gabriela", + "Bárbara", + "Joana", + "Catarina", + "Isabel", + "Rita", + "Luana", + "Marta", + "Eva", + "Lia", + "Alice", + "Helena", + "Filipa", + "Daniela", + "Sara", + "Patrícia", + "Raquel", + "Teresa", + "Susana", + "Diana", + "Vera", + "Andreia", + "Célia", + "Débora", + "Elsa", + "Fátima", + "Graça", + "Helena", + "Irene", + "Jéssica", + "Liliana", + "Mónica", + "Natália", + "Olga", + "Paula", + "Renata", + "Sandra", + "Tatiana", + "Vânia", + "Zélia", + "Bruna", + "Cândida", + "Dalila", + "Ema", + "Fabiana", + "Glória", + "Heloísa", + "Ivone", + "Júlia", + "Lídia", + "Madalena", + "Nádia", + "Odete", + "Palmira", + "Quitéria", + "Rosário", + "Sílvia", + "Telma", + "Ursula", + "Vanessa", + "Ximena", + "Zita" + ], + "nm6": [ + "Silva", + "Santos", + "Ferreira", + "Pereira", + "Oliveira", + "Costa", + "Rodrigues", + "Martins", + "Jesus", + "Sousa", + "Fernandes", + "Gonçalves", + "Gomes", + "Lopes", + "Marques", + "Alves", + "Almeida", + "Ribeiro", + "Pinto", + "Carvalho", + "Teixeira", + "Moreira", + "Correia", + "Mendes", + "Nunes", + "Soares", + "Vieira", + "Monteiro", + "Cardoso", + "Rocha", + "Cruz", + "Cunha", + "Pires", + "Barbosa", + "Machado", + "Moura", + "Dias", + "Simões", + "Antunes", + "Fonseca", + "Freitas", + "Ramos", + "Azevedo", + "Castro", + "Campos", + "Borges", + "Peixoto", + "Figueiredo", + "Neves", + "Batista", + "Matos", + "Tavares", + "Mota", + "Pinheiro", + "Coelho", + "Aguiar", + "Macedo", + "Valente", + "Moura", + "Lima", + "Menezes", + "Bento", + "Coutinho", + "Faria", + "Leite", + "Barros", + "Amaral", + "Serra", + "Prata", + "Lacerda", + "Guedes", + "Mira", + "Bastos", + "Carmo", + "Duarte", + "Esteves", + "Franco", + "Garcia", + "Henriques", + "Jardim", + "Lourenço", + "Macedo", + "Nóbrega", + "Pacheco", + "Queirós", + "Reis", + "Sá", + "Teles", + "Vaz", + "Xavier", + "Zagalo" + ], + "nm7": [ + "Alex", + "André", + "Ariel", + "Bruno", + "Caio", + "Cris", + "Daniel", + "Dani", + "Duarte", + "Edu", + "Filipe", + "Gabriel", + "Gil", + "Henrique", + "Jo", + "João", + "Jorge", + "José", + "Leo", + "Lucas", + "Luís", + "Manu", + "Marco", + "Marcos", + "Mário", + "Miguel", + "Nuno", + "Paulo", + "Pedro", + "Rafa", + "Ricardo", + "Rui", + "Samuel", + "Sandro", + "Tiago", + "Tomás", + "Vasco", + "Vítor", + "Ana", + "Bia", + "Bruna", + "Catarina", + "Clara", + "Diana", + "Filipa", + "Gabi", + "Helena", + "Inês", + "Joana", + "Lara", + "Leonor", + "Luana", + "Mafalda", + "Maria", + "Mariana", + "Marta", + "Matilde", + "Patrícia", + "Rita", + "Sara", + "Sofia", + "Teresa", + "Vera" + ] +} \ No newline at end of file diff --git a/data/orc.json b/data/orc.json new file mode 100644 index 0000000..8fbc298 --- /dev/null +++ b/data/orc.json @@ -0,0 +1,426 @@ +{ + "nm1": [ + "", + "", + "", + "b", + "bh", + "br", + "d", + "dh", + "dr", + "g", + "gh", + "gr", + "j", + "l", + "m", + "n", + "r", + "rh", + "sh", + "z", + "zh" + ], + "nm2": [ + "a", + "o", + "u" + ], + "nm3": [ + "b", + "br", + "bz", + "d", + "dd", + "dz", + "dg", + "dr", + "g", + "gg", + "gr", + "gz", + "gv", + "hr", + "hz", + "j", + "kr", + "kz", + "m", + "mz", + "mv", + "n", + "ng", + "nd", + "nz", + "r", + "rt", + "rz", + "rd", + "rl", + "rz", + "t", + "tr", + "v", + "vr", + "z", + "zz" + ], + "nm4": [ + "b", + "d", + "g", + "g", + "k", + "k", + "kk", + "kk", + "l", + "ll", + "n", + "r" + ], + "nm5": [ + "", + "", + "", + "", + "b", + "bh", + "d", + "dh", + "g", + "gh", + "h", + "k", + "m", + "n", + "r", + "rh", + "s", + "sh", + "v", + "z" + ], + "nm6": [ + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "ee", + "au", + "ye", + "ie", + "aa", + "ou", + "ua", + "ao" + ], + "nm7": [ + "d", + "dd", + "dk", + "dg", + "dv", + "g", + "gg", + "gn", + "gv", + "gz", + "l", + "ll", + "lv", + "lz", + "m", + "md", + "mz", + "mv", + "ng", + "nk", + "ns", + "nz", + "t", + "thr", + "th", + "v", + "vn", + "vr", + "vg", + "vd", + "wnk", + "wg", + "wn" + ], + "nm8": [ + "", + "", + "", + "", + "", + "f", + "h", + "k", + "l", + "m", + "n", + "ng", + "v", + "z" + ], + "nm9": [ + "Aberrant", + "Ancient", + "Angry", + "Anguished", + "Arrogant", + "Barbarian", + "Barbaric", + "Barren", + "Berserk", + "Bitter", + "Bloody", + "Broad", + "Broken", + "Brutal", + "Brute", + "Butcher", + "Coarse", + "Cold", + "Colossal", + "Crazy", + "Crooked", + "Cruel", + "Dark", + "Defiant", + "Delirious", + "Deranged", + "Disfigured", + "Enormous", + "Enraged", + "Fearless", + "Feisty", + "Fierce", + "Filthy", + "Forsaken", + "Frantic", + "Gargantuan", + "Giant", + "Glorious", + "Grand", + "Grave", + "Grim", + "Gross", + "Gruesome", + "Hollow", + "Infernal", + "Lethal", + "Lost", + "Loyal", + "Macabre", + "Mad", + "Maniac", + "Merciless", + "Mighty", + "Miscreant", + "Noxious", + "Outlandish", + "Powerful", + "Prime", + "Proud", + "Putrid", + "Radical", + "Reckless", + "Repulsive", + "Rotten", + "Ruthless", + "Shady", + "Sick", + "Silent", + "Simple", + "Smug", + "Spiteful", + "Swift", + "Turbulent", + "Ugly", + "Unsightly", + "Vengeful", + "Venomous", + "Vicious", + "Violent", + "Vivid", + "Volatile", + "Vulgar", + "Warped", + "Wicked", + "Wild", + "Worthless", + "Wrathful", + "Wretched" + ], + "nm10": [ + "Anger", + "Ankle", + "Ash", + "Battle", + "Beast", + "Bitter", + "Black", + "Blood", + "Bone", + "Brain", + "Brass", + "Breath", + "Chaos", + "Chest", + "Chin", + "Cold", + "Dark", + "Death", + "Dirt", + "Doom", + "Dream", + "Elf", + "Eye", + "Fang", + "Feet", + "Fiend", + "Finger", + "Flame", + "Flesh", + "Foot", + "Ghost", + "Giant", + "Gnoll", + "Gnome", + "Gore", + "Hand", + "Hate", + "Head", + "Heart", + "Heel", + "Hell", + "Horror", + "Iron", + "Joint", + "Kidney", + "Kill", + "Knee", + "Muscle", + "Nose", + "Pest", + "Poison", + "Power", + "Pride", + "Rib", + "Scale", + "Skin", + "Skull", + "Slave", + "Smoke", + "Sorrow", + "Spine", + "Spite", + "Steel", + "Storm", + "Talon", + "Teeth", + "Throat", + "Thunder", + "Toe", + "Tooth", + "Vein", + "Venom", + "Vermin", + "War" + ], + "nm11": [ + "Axe", + "Blade", + "Brand", + "Breaker", + "Bruiser", + "Burster", + "Butcher", + "Carver", + "Chopper", + "Cleaver", + "Clobberer", + "Conquerer", + "Cracker", + "Cruncher", + "Crusher", + "Cutter", + "Dagger", + "Defacer", + "Despoiler", + "Destroyer", + "Dissector", + "Ender", + "Flayer", + "Gasher", + "Glaive", + "Gouger", + "Hacker", + "Hammer", + "Killer", + "Lance", + "Marauder", + "Masher", + "Mutilator", + "Piercer", + "Pummel", + "Quasher", + "Quelcher", + "Queller", + "Razer", + "Render", + "Ripper", + "Saber", + "Sabre", + "Scalper", + "Shatterer", + "Skinner", + "Slayer", + "Slicer", + "Smasher", + "Snapper", + "Spear", + "Splitter", + "Squasher", + "Squelcher", + "Squisher", + "Strangler", + "Sunderer", + "Sword", + "Trampler", + "Trasher", + "Vanquisher", + "Wrecker" + ] +} \ No newline at end of file diff --git a/data/satyr.json b/data/satyr.json new file mode 100644 index 0000000..ad4540c --- /dev/null +++ b/data/satyr.json @@ -0,0 +1,319 @@ +{ + "nm1": [ + "", + "", + "", + "d", + "f", + "k", + "n", + "p", + "sp", + "t", + "z" + ], + "nm2": [ + "eo", + "y", + "a", + "e", + "i", + "o" + ], + "nm3": [ + "f", + "k", + "l", + "m", + "n", + "nt", + "r" + ], + "nm4": [ + "ia", + "y", + "a", + "e", + "i", + "y", + "a", + "e", + "i" + ], + "nm5": [ + "k", + "l", + "m", + "n", + "pp", + "r", + "t", + "v", + "z" + ], + "nm6": [ + "ia", + "a", + "i", + "o", + "o", + "o" + ], + "nm7": [ + "", + "n", + "s", + "s", + "s", + "n", + "s", + "s", + "s", + "n", + "s", + "s", + "s" + ], + "nm8": [ + "ch", + "d", + "k", + "l", + "n", + "t", + "x", + "y", + "z", + "", + "" + ], + "nm9": [ + "ei", + "ai", + "oi", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o" + ], + "nm10": [ + "fn", + "k", + "l", + "lp", + "n", + "nn", + "r", + "s", + "t", + "vr" + ], + "nm11": [ + "a", + "e", + "i", + "i" + ], + "nm12": [ + "d", + "l", + "n", + "r", + "y" + ], + "nm13": [ + "ia", + "oi", + "oe", + "a", + "i", + "a", + "i", + "a", + "i", + "a", + "i", + "a", + "i", + "a", + "i" + ], + "nm14": [ + "amber", + "auburn", + "bristle", + "bronze", + "copper", + "crimson", + "dapple", + "fawn", + "frazzle", + "frizzle", + "ginger", + "hazel", + "messy", + "orange", + "ragged", + "rough", + "scarlet", + "scraggy", + "scruffle", + "scruffy", + "shaggy", + "stubble", + "umber" + ], + "nm15": [ + "back", + "beard", + "chin", + "crest", + "crown", + "fluff", + "fringe", + "fur", + "fuzz", + "hair", + "mane", + "ridge", + "ruff", + "tuft" + ], + "nm16": [ + "dark", + "flat", + "free", + "great", + "hard", + "keen", + "little", + "nobble", + "proud", + "quick", + "skip", + "still", + "stout", + "strong", + "stubby", + "swift", + "twinkle" + ], + "nm17": [ + "horn", + "horns", + "foot", + "hoof", + "hoofs", + "hooves", + "feet" + ], + "nm18": [ + "Arrow", + "Bash", + "Basher", + "Berry", + "Bigby", + "Bitsy", + "Blaze", + "Blossom", + "Blush", + "Blusher", + "Bouncer", + "Bounder", + "Buster", + "Caper", + "Chip", + "Comet", + "Crimson", + "Cuddles", + "Curles", + "Dancer", + "Diamond", + "Digger", + "Dimple", + "Dimples", + "Dizzy", + "Dusty", + "Ember", + "Flounce", + "Flutters", + "Fuzz", + "Fuzzy", + "Gambol", + "Grace", + "Grouch", + "Happy", + "Hopper", + "Jitter", + "Jolly", + "Kindle", + "Leaper", + "Little", + "Lopper", + "Lucky", + "Mellow", + "Mistletoe", + "Mouse", + "Mugs", + "Mugsy", + "Nimble", + "Parade", + "Petal", + "Pitch", + "Plummet", + "Prancer", + "Pyro", + "Quickstep", + "Rags", + "Rebel", + "Red", + "Robin", + "Rose", + "Rouge", + "Ruby", + "Rusty", + "Scruffy", + "Shimmer", + "Shimmy", + "Sketch", + "Skip", + "Skipper", + "Skippy", + "Slick", + "Slim", + "Smiles", + "Smiley", + "Spark", + "Sparkle", + "Sparkles", + "Sparrow", + "Spike", + "Springstep", + "Stretch", + "Strutter", + "Thunder", + "Torch", + "Tricks", + "Tricky", + "Twinkle", + "Twinkles", + "Twitch", + "Waver", + "Wiggles", + "Wobble", + "Zero", + "Ziggy" + ] +} \ No newline at end of file diff --git a/data/shadar-kai.json b/data/shadar-kai.json new file mode 100644 index 0000000..08b2200 --- /dev/null +++ b/data/shadar-kai.json @@ -0,0 +1,237 @@ +{ + "nm1": [ + "", + "", + "c", + "cr", + "h", + "l", + "m", + "n", + "r", + "s", + "sk", + "th", + "tr", + "v", + "z" + ], + "nm2": [ + "ee", + "au", + "ie", + "ae", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u" + ], + "nm3": [ + "d", + "g", + "m", + "n", + "nn", + "r", + "rr", + "sh", + "t", + "th", + "v", + "w", + "z" + ], + "nm4": [ + "ie", + "a", + "a", + "e", + "i", + "o", + "a", + "a", + "e", + "i", + "o", + "a", + "a", + "e", + "i", + "o", + "a", + "a", + "e", + "i", + "o", + "a", + "a", + "e", + "i", + "o" + ], + "nm5": [ + "l", + "n", + "r", + "th", + "v", + "y" + ], + "nm6": [ + "a", + "e", + "i", + "o" + ], + "nm7": [ + "", + "", + "ch", + "k", + "l", + "n", + "s", + "l", + "n", + "s", + "l", + "n", + "s" + ], + "nm8": [ + "", + "", + "", + "", + "", + "", + "", + "", + "c", + "h", + "l", + "n", + "r", + "s", + "th", + "v", + "y", + "z" + ], + "nm9": [ + "a", + "e", + "i" + ], + "nm10": [ + "d", + "dr", + "gl", + "gn", + "gr", + "gv", + "l", + "ld", + "lk", + "ll", + "ln", + "lr", + "lv", + "m", + "mn", + "mt", + "n", + "nd", + "nk", + "nm", + "nn", + "nt", + "rk", + "rl", + "rn", + "rr", + "rv", + "v", + "vl", + "vr" + ], + "nm11": [ + "a", + "a", + "e", + "e", + "i" + ], + "nm12": [ + "d", + "dr", + "l", + "ll", + "ln", + "lr", + "lth", + "n", + "nt", + "nth", + "r", + "rn", + "rth", + "th", + "thr", + "v" + ], + "nm13": [ + "a", + "a", + "e", + "i", + "i" + ], + "nm14": [ + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "l", + "ll", + "n", + "nn", + "s", + "ss", + "th" + ] +} \ No newline at end of file diff --git a/data/shardmind.json b/data/shardmind.json new file mode 100644 index 0000000..b375acb --- /dev/null +++ b/data/shardmind.json @@ -0,0 +1,106 @@ +{ + "nm1": [ + "Adu", + "Ama", + "Ani", + "Ar", + "Arsha", + "Ashi", + "Ashtu", + "Bala", + "Bara", + "Basha", + "Beles", + "Delu", + "Di", + "Dura", + "Duru", + "Enu", + "Eri", + "Eshu", + "Hua", + "Hun", + "Il", + "Ilu", + "Ira", + "Ish", + "Ku", + "Kua", + "Kuba", + "Lu", + "Mani", + "Mara", + "Mashi", + "Na", + "Nara", + "Nashi", + "Nu", + "Rua", + "Run", + "Sana", + "Sari", + "Selu", + "Shir", + "Suma", + "Tab", + "Tin", + "Tiru", + "Uba", + "Uku", + "Ura", + "Ut", + "Zaki" + ], + "nm2": [ + "ba", + "bam", + "bani", + "bu", + "ha", + "hara", + "hu", + "ka", + "ku", + "lazu", + "lua", + "mea", + "nar", + "nara", + "naram", + "naru", + "nashtu", + "ni", + "niri", + "nu", + "nua", + "pana", + "ram", + "ranu", + "rashi", + "raya", + "ri", + "rin", + "runu", + "shara", + "shari", + "shi", + "shti", + "shtu", + "shu", + "sunu", + "ta", + "tana", + "tani", + "tari", + "ti", + "tira", + "tiru", + "tua", + "tum", + "wia", + "ya", + "yara", + "yua", + "zu" + ] +} \ No newline at end of file diff --git a/data/shifter.json b/data/shifter.json new file mode 100644 index 0000000..5f04b76 --- /dev/null +++ b/data/shifter.json @@ -0,0 +1,257 @@ +{ + "names1": [ + "Acor", + "Almond", + "Ash", + "Astro", + "Badger", + "Barb", + "Basalt", + "Basil", + "Beast", + "Birch", + "Blast", + "Blaze", + "Bluff", + "Bog", + "Boulder", + "Bramble", + "Breach", + "Briar", + "Brock", + "Brook", + "Burst", + "Canyon", + "Char", + "Chasm", + "Cinder", + "Claw", + "Cliff", + "Cloud", + "Coal", + "Cobalt", + "Cobble", + "Comet", + "Cosmo", + "Crag", + "Crater", + "Dash", + "Drake", + "Drift", + "Dune", + "Dusk", + "Dust", + "Echo", + "Fang", + "Flame", + "Flare", + "Flax", + "Flint", + "Flood", + "Foam", + "Fog", + "Forest", + "Fox", + "Frost", + "Frostbite", + "Fume", + "Fury", + "Gale", + "Glare", + "Gorge", + "Grime", + "Grit", + "Grove", + "Gulch", + "Gust", + "Kindle", + "Light", + "Lumber", + "Magma", + "Mahogany", + "Marsh", + "Mercury", + "Midnight", + "Mire", + "Moss", + "Mountain", + "Nebula", + "Newt", + "Nightfall", + "Nightshade", + "Nimbus", + "North", + "Nova", + "Nyx", + "Oak", + "Ocean", + "Onyx", + "Pitch", + "Pyre", + "Pyro", + "Quicksilver", + "Ravine", + "Ridge", + "Rift", + "River", + "Rock", + "Rubble", + "Scar", + "Shrub", + "Silver", + "Smoke", + "Soot", + "Spark", + "Spike", + "Spine", + "Steam", + "Steel", + "Stone", + "Storm", + "Surge", + "Talon", + "Thicket", + "Thistle", + "Thorn", + "Thunder", + "Tide", + "Tiger", + "Timber", + "Tinder", + "Tor", + "Torrent", + "Vapor", + "Vermin", + "Vine", + "Void", + "Wave", + "Willow", + "Wolf", + "Woods" + ], + "names2": [ + "Abyss", + "Almond", + "Amber", + "Amethyst", + "Anemone", + "Aqua", + "Aurora", + "Autumn", + "Birch", + "Bloom", + "Blossom", + "Breeze", + "Briar", + "Brook", + "Canyon", + "Chestnut", + "Cloud", + "Coral", + "Coyote", + "Crest", + "Cricket", + "Crystal", + "Dawn", + "Dew", + "Dewdrop", + "Diamond", + "Elm", + "Ember", + "Emerald", + "Evening", + "Feather", + "Fern", + "Flare", + "Floe", + "Flora", + "Floret", + "Flow", + "Fluff", + "Galaxy", + "Gem", + "Hail", + "Harley", + "Haze", + "Hazel", + "Horizon", + "Ice", + "Indigo", + "Iris", + "Isle", + "Ivy", + "Jade", + "Jasmine", + "Juniper", + "Karma", + "Lake", + "Lavender", + "Leaf", + "Lily", + "Luna", + "Magenta", + "Maple", + "Marigold", + "Meadow", + "Midnight", + "Mist", + "Moon", + "Moss", + "Nebula", + "Nutmeg", + "Ocean", + "Olive", + "Opal", + "Orchid", + "Pearl", + "Petal", + "Pine", + "Pinecone", + "Plume", + "Poison", + "Pyro", + "Quill", + "Rain", + "Raven", + "Rill", + "River", + "Robin", + "Rose", + "Rosemary", + "Ruby", + "Saffron", + "Sage", + "Sapphire", + "Scarlet", + "Shade", + "Silver", + "Sky", + "Snow", + "Snowflake", + "Spring", + "Star", + "Stardust", + "Sugar", + "Summer", + "Sun", + "Sunrise", + "Sunset", + "Sunshine", + "Swill", + "Thistle", + "Tidal", + "Tiger", + "Tinder", + "Topaz", + "Twig", + "Twilight", + "Urchin", + "Vapor", + "Violet", + "Whirl", + "Willow", + "Wind", + "Wing", + "Winter" + ] +} \ No newline at end of file diff --git a/data/simic_hybrid.json b/data/simic_hybrid.json new file mode 100644 index 0000000..b29d27a --- /dev/null +++ b/data/simic_hybrid.json @@ -0,0 +1,272 @@ +{ + "nm1": [ + "b", + "c", + "ch", + "d", + "g", + "gh", + "h", + "k", + "kh", + "l", + "m", + "n", + "s", + "t", + "v", + "z" + ], + "nm2": [ + "a", + "e", + "o", + "a", + "e", + "o", + "i" + ], + "nm3": [ + "l", + "n", + "r", + "s", + "v", + "w", + "y", + "z" + ], + "nm4": [ + "a", + "a", + "e", + "i", + "i", + "o" + ], + "nm5": [ + "ulad", + "hareth", + "khad", + "kosh", + "melk", + "tash", + "vash" + ], + "nm6": [ + "ashana", + "ashtai", + "ishara", + "nari", + "tara", + "vakri" + ], + "nm7": [ + "Ad", + "Ae", + "Bal", + "Bei", + "Car", + "Cra", + "Dae", + "Dor", + "El", + "Ela", + "Er", + "Far", + "Fen", + "Gen", + "Glyn", + "Hei", + "Her", + "Ian", + "Ili", + "Kea", + "Kel", + "Leo", + "Lu", + "Mira", + "Mor", + "Nae", + "Nor", + "Olo", + "Oma", + "Pa", + "Per", + "Pet", + "Qi", + "Qin", + "Ralo", + "Ro", + "Sar", + "Syl", + "The", + "Tra", + "Ume", + "Uri", + "Va", + "Vir", + "Waes", + "Wran", + "Yel", + "Yin", + "Zin", + "Zum" + ], + "nm8": [ + "balar", + "beros", + "can", + "ceran", + "dan", + "dithas", + "faren", + "fir", + "geiros", + "golor", + "hice", + "horn", + "jeon", + "jor", + "kas", + "kian", + "lamin", + "lar", + "len", + "maer", + "maris", + "menor", + "myar", + "nan", + "neiros", + "nelis", + "norin", + "peiros", + "petor", + "qen", + "quinal", + "ran", + "ren", + "ric", + "ris", + "ro", + "salor", + "sandoral", + "toris", + "tumal", + "valur", + "ven", + "warin", + "wraek", + "xalim", + "xidor", + "yarus", + "ydark", + "zeiros", + "zumin" + ], + "nm9": [ + "Ad", + "Ara", + "Bi", + "Bry", + "Cai", + "Chae", + "Da", + "Dae", + "Eil", + "En", + "Fa", + "Fae", + "Gil", + "Gre", + "Hele", + "Hola", + "Iar", + "Ina", + "Jo", + "Key", + "Kris", + "Lia", + "Lora", + "Mag", + "Mia", + "Neri", + "Ola", + "Ori", + "Phi", + "Pres", + "Qi", + "Qui", + "Rava", + "Rey", + "Sha", + "Syl", + "Tor", + "Tris", + "Ula", + "Uri", + "Val", + "Ven", + "Wyn", + "Wysa", + "Xil", + "Xyr", + "Yes", + "Ylla", + "Zin", + "Zyl" + ], + "nm10": [ + "banise", + "bella", + "caryn", + "cyne", + "di", + "dove", + "fiel", + "fina", + "gella", + "gwyn", + "hana", + "harice", + "jyre", + "kalyn", + "krana", + "lana", + "lee", + "leth", + "lynn", + "moira", + "mys", + "na", + "nala", + "phine", + "phyra", + "qirelle", + "ra", + "ralei", + "rel", + "rie", + "rieth", + "rona", + "rora", + "roris", + "satra", + "stina", + "sys", + "thana", + "thyra", + "tris", + "varis", + "vyre", + "wenys", + "wynn", + "xina", + "xisys", + "ynore", + "yra", + "zana", + "zorwyn" + ] +} \ No newline at end of file diff --git a/data/tabaxi.json b/data/tabaxi.json new file mode 100644 index 0000000..c426a7e --- /dev/null +++ b/data/tabaxi.json @@ -0,0 +1,664 @@ +{ + "nm1": [ + "Afternoon Nap (Nap)", + "Animal in the Woods (Woods)", + "Answered Riddle (Riddle)", + "Art of Shadows (Art)", + "Aura of Passion (Aura)", + "Aurora of Winter (Aurora)", + "Autumn Harvest (Autumn)", + "Beats of a Heart (Beats)", + "Beauty of Summer (Summer)", + "Beauty's Eye (Beauty)", + "Belly of a Beast (Beast)", + "Berry Bush (Bush)", + "Big Heart (Big)", + "Bird Feather (Bird)", + "Bite Marks (Bite)", + "Blank Board (Board)", + "Blank Canvas (Canvas)", + "Blazing Fire (Blaze)", + "Blossoms in Summer (Blossom)", + "Branch of a River (River)", + "Breath of Fresh Air (Breath)", + "Broken Chain (Chain)", + "Bubble of a Cauldron (Bubble)", + "Burden of Chains (Chains)", + "Burning Desire (Desire)", + "Burning Fire (Fire)", + "Bush in the Forest (Forest)", + "Bushy Branch (Branch)", + "Busy Bee (Bee)", + "Cadence of Water (Cadence)", + "Cake of Chocolate (Cake)", + "Call of a Bird (Bird)", + "Call of the Owl (Owl)", + "Call to Action (Action)", + "Candle in the Dark (Candle)", + "Cannon on Deck (Cannon)", + "Carriage on the Road (Road)", + "Clanking Bottle (Clank)", + "Cloaking Dagger (Dagger)", + "Cloud in the Sky (Sky)", + "Coursing River (River)", + "Cover of Clouds (Cover)", + "Crescent Moon (Moon)", + "Dangling Button (Button)", + "Dangling Lace (Lace)", + "Daydream at Night (Dream)", + "Dew on the Grass (Dew)", + "Dream of Days (Dream)", + "Drifting Cloud (Cloud)", + "Drifting Snowflake (Snowflake)", + "Drop in a Pond (Drop)", + "Dust of Chalk (Dust)", + "Dust on the Road (Dust)", + "Eclipse of the Moon (Eclipse)", + "Edge of the World (Edge)", + "End of Winter (Winter)", + "Endless Time (Time)", + "Fall of Water (Water)", + "Fallen Twig (Twig)", + "Fang of a Snake (Fang)", + "Feather in the Wind (Feather)", + "Fire in the Distance (Fire)", + "Fish in the River (River)", + "Flame of Passion (Passion)", + "Flame of the Spirit (Flame)", + "Flickering Fire (Fire)", + "Flickering Flame (Flame)", + "Flight of a Robin (Robin)", + "Flow of the River (Flow)", + "Flower in the Field (Flower)", + "Flower of Ivory (Ivory)", + "Forgotten Link (Link)", + "Four-Leaf Clover (Clover)", + "Fragrance of Spring (Spring)", + "Friend of Foe (Friend)", + "Gale of the Storm (Gale)", + "Game of Chance (Game)", + "Garden of Flowers (Flower)", + "Gift of a Guest (Gift)", + "Glow of the Sun (Sun)", + "Grass of Spring (Grass)", + "Guest at Home (Guest)", + "Guide of Life (Guide)", + "Hawk Feather (Hawk)", + "Hen of the Flock (Hen)", + "Hidden Depths (Depth)", + "Hidden Treasure (Treasure)", + "Hide of the Beast (Hide)", + "High Noon (Noon)", + "Honey of Bees (Honey)", + "Hot Flame (Flame)", + "Hot as Fire (Fire)", + "Ice in Summer (Ice)", + "Ice on the Lake (Ice)", + "Ink on Skin (Ink)", + "Jewel of the Mountain (Jewel)", + "Kite in the Wind (Kite)", + "Leaf on the Water (Leaf)", + "Leaping Frog (Frog)", + "Light in the Morning (Light)", + "Lightning After Thunder (Lightning)", + "Little Flower (Little)", + "Lock on an Open Door (Lock)", + "Locket on a Heart (Locket)", + "Looping Coil (Coil)", + "Loose String (String)", + "Luck of the Draw (Luck)", + "Marble in the Sky (Marble)", + "Mark of Life (Mark)", + "Melting of Snow (Snow)", + "Mirror's Reflection (Mirror)", + "Mist in the Morning (Mist)", + "Mountain Boulder (Boulder)", + "Needle in Hay (Needle)", + "Night of Dreams (Night)", + "Open Gates (Gate)", + "Owl in the Morning (Owl)", + "Page of a Book (Page)", + "Paint on a Canvas (Paint)", + "Patch in the Forest (Patch)", + "Paw of a Bear (Paw)", + "Peak of Mountains (Peak)", + "Piece of the Puzzle (Piece)", + "Plume in the Wind (Plume)", + "Plume of Smoke (Smoke)", + "Poem of Summer (Poem)", + "Print of a Boot (Boot)", + "Print of an Animal (Animal)", + "Quill in the Grass (Quill)", + "Rain in Summer (Rain)", + "Rain of Fall (Rain)", + "Rainbow After Rain (Rainbow)", + "Rays of the Sun (Ray)", + "Remnants of History (Remnant)", + "Rhythm of Drums (Rhythm)", + "Ringing of Bells (Bell)", + "Rinkling Chains (Chains)", + "Roar of a Bear (Roar)", + "Rope in a Knot (Knot)", + "Rustling of a Deer (Deer)", + "Sailing Ship (Ship)", + "Sand of the Beach (Sand)", + "Sands of Time (Sand)", + "Scarf in Summer (Scarf)", + "Scratch on Wood (Scratch)", + "Screech of Bats (Bat)", + "Sea of Opportunity (Sea)", + "Second Chance (Chance)", + "Serpent Scale (Scale)", + "Shadow of a Star (Shadow)", + "Shadows in the Wind (Shadow)", + "Sky Full of Stars (Sky)", + "Sky of a Sunset (Sky)", + "Sleight Hand (Hand)", + "Smooth as Silk (Silk)", + "Snapping Branch (Snap)", + "Snow of the Mountain (Snow)", + "Solstice of Summer (Solstice)", + "Song of Paradise (Song)", + "Sound of the Drum (Drum)", + "Spark of Life (Spark)", + "Sparkle of Light (Sparkle)", + "Spell of Rain (Spell)", + "Spots of a Leopard (Spot)", + "Spring Blossom (Spring)", + "Spring Winds (Spring)", + "Star in the Morning (Star)", + "Steady Rock (Rock)", + "Stitch of Fabric (Stitch)", + "Stone in Water (Stone)", + "Storm at Sea (Sea)", + "Storm on the Horizon (Storm)", + "Strength of Love (Love)", + "Stripes of a Tiger (Tiger)", + "Stroke of a Brush (Brush)", + "Summer Afternoon (Summer)", + "Sunshine at Night (Sunshine)", + "Tale of Wonder (Tale)", + "Taste of Fruit (Taste)", + "Three Tree (Three)", + "Thrill of Life (Thrill)", + "Thunder in the Morning (Thunder)", + "Ticking Clock (Clock)", + "Tome of Secrets (Tome)", + "Top Card (Card)", + "Trail in the Woods (Trail)", + "Tree Blossom (Blossom)", + "Tree in the Woods (Tree)", + "Tricking Treat (Trick)", + "Two River (River)", + "Unpulled Cart (Cart)", + "Unread Book (Book)", + "Veil of Shadows (Veil)", + "Veil of a Mask (Veil)", + "Wave on the Shore (Wave)", + "Windy Shore (Shore)", + "Wing of an Angel (Angel)", + "Winter Breath (Winter)", + "Wish Upon a Star (Wish)", + "Wonder of the World (Wonder)" + ], + "nm2": [ + "Active", + "Agile", + "Amused", + "Amusing", + "Ancient", + "Angelic", + "Arctic", + "Austere", + "Bizarre", + "Bold", + "Brash", + "Brave", + "Bright", + "Bronze", + "Cheeky", + "Clever", + "Curious", + "Defiant", + "Dynamic", + "Eager", + "Elegant", + "Elite", + "Emerald", + "Ethereal", + "Faint", + "Fine", + "Five", + "Flawless", + "Four", + "Fragile", + "Fragrant", + "Free", + "Fresh", + "Gentle", + "Gold", + "Golden", + "Grand", + "Half", + "Happy", + "Hearty", + "Hidden", + "Humble", + "Hushed", + "Icy", + "Jade", + "Jolly", + "Kind", + "Lazy", + "Light", + "Little", + "Lone", + "Lost", + "Lucky", + "Magic", + "Mellow", + "Merry", + "Misty", + "Mystery", + "Nimble", + "Odd", + "Opal", + "Prime", + "Proud", + "Pure", + "Quick", + "Quiet", + "Quirky", + "Radiant", + "Rare", + "Ruby", + "Sapphire", + "Secret", + "Serene", + "Seven", + "Shady", + "Silent", + "Single", + "Six", + "Smooth", + "Stout", + "Subtle", + "Sweet", + "Swift", + "Three", + "Tranquil", + "True", + "Twin", + "Two", + "Velvet", + "Vibrant", + "Violet", + "Wild" + ], + "nm3": [ + "Animal", + "Aspect", + "Bat", + "Beach", + "Bear", + "Beast", + "Beauty", + "Beetle", + "Bell", + "Berry", + "Bird", + "Bit", + "Bite", + "Block", + "Board", + "Boat", + "Book", + "Boot", + "Bottle", + "Brain", + "Branch", + "Breath", + "Brush", + "Bubble", + "Bush", + "Button", + "Cable", + "Cake", + "Candle", + "Candy", + "Cannon", + "Canvas", + "Card", + "Carriage", + "Cart", + "Chain", + "Chains", + "Chalk", + "Chance", + "Child", + "Clock", + "Cloud", + "Clover", + "Coil", + "Deer", + "Device", + "Dream", + "Drop", + "Dust", + "Edge", + "Fang", + "Feather", + "Fire", + "Fish", + "Flame", + "Flower", + "Frog", + "Game", + "Garden", + "Gate", + "Gift", + "Glove", + "Grass", + "Guest", + "Guide", + "Hen", + "Hide", + "Honey", + "Ice", + "Ink", + "Jewel", + "Kite", + "Knot", + "Lace", + "Leaf", + "Light", + "Lightning", + "Link", + "Lock", + "Locket", + "Love", + "Luck", + "Marble", + "Mark", + "Mask", + "Mirror", + "Needle", + "Night", + "Owl", + "Page", + "Patch", + "Path", + "Peak", + "Piece", + "Plume", + "Poem", + "Quill", + "Quilt", + "Rain", + "Riddle", + "River", + "Robin", + "Rock", + "Scale", + "Scarf", + "Scratch", + "Sea", + "Shadow", + "Shoe", + "Shore", + "Silk", + "Smoke", + "Snow", + "Snowflake", + "Song", + "Spark", + "Sparkle", + "Spell", + "Star", + "Stitch", + "Stone", + "Storm", + "Straw", + "Stream", + "String", + "Stripe", + "Tale", + "Thing", + "Thrill", + "Thunder", + "Timber", + "Time", + "Tome", + "Trail", + "Tree", + "Trick", + "Veil", + "Wave", + "Wind", + "Wing", + "Wish", + "Wonder" + ], + "nm4": [ + "Abandoned", + "Adamant", + "Anchored", + "Ancient", + "Angelic", + "Animated", + "Arctic", + "Ascending", + "Awakening", + "Awoken", + "Barren", + "Basking", + "Bellowing", + "Binding", + "Blank", + "Bleak", + "Blossoming", + "Boundless", + "Bright", + "Brisk", + "Broken", + "Bustling", + "Changing", + "Cherished", + "Chilly", + "Cleansing", + "Clear", + "Colorful", + "Covering", + "Crawling", + "Dancing", + "Dark", + "Darkening", + "Desired", + "Distant", + "Dreaming", + "Dreary", + "Dry", + "Dual", + "Echoing", + "Elder", + "Enchanted", + "Enchanting", + "Entangling", + "Ethereal", + "Evading", + "Everlasting", + "Exotic", + "Expanding", + "Fading", + "Far", + "Faraway", + "Fertile", + "Flawless", + "Flickering", + "Fragile", + "Fragrant", + "Free", + "Gathering", + "Gentle", + "Gleaming", + "Glistening", + "Graceful", + "Grand", + "Great", + "Grieving", + "Growing", + "Healing", + "Heavenly", + "Hidden", + "High", + "Humble", + "Hushed", + "Infinite", + "Lasting", + "Light", + "Little", + "Living", + "Lone", + "Longing", + "Loving", + "Lurking", + "Lush", + "Magical", + "Meager", + "Mellow", + "Merging", + "Mild", + "Misty", + "Mountain", + "Mumbling", + "Murky", + "Murmuring", + "Musing", + "Noiseless", + "Passing", + "Pleasing", + "Precious", + "Protecting", + "Prowling", + "Pure", + "Quiet", + "Radiant", + "Reflected", + "Reflecting", + "Reigning", + "Rising", + "Roaming", + "Roaring", + "Rumbling", + "Scented", + "Serene", + "Shimmering", + "Silent", + "Sleepy", + "Snoozing", + "Snoring", + "Soothing", + "Stormy", + "Surging", + "Thundering", + "Tired", + "Trailing", + "Tranquil", + "Tumbling", + "Twinkling", + "Twirling", + "Twisting", + "Unraveling", + "Velvet", + "Vibrant", + "Wailing", + "Wandering", + "Watching", + "Weeping", + "Whispering", + "Whistling", + "Wild" + ], + "nm5": [ + "Barrens", + "Bayou", + "Bluff", + "Bluffs", + "Bog", + "Bogs", + "Bush", + "Cave", + "Cavern", + "Caverns", + "Caves", + "Cliff", + "Cliffs", + "Coast", + "Coasts", + "Copse", + "Crag", + "Crags", + "Creek", + "Creeks", + "Deluge", + "Den", + "Desert", + "Deserts", + "Dune", + "Dunes", + "Estuary", + "Field", + "Fields", + "Fjord", + "Fjords", + "Forest", + "Forests", + "Glade", + "Glades", + "Grotto", + "Hail", + "Island", + "Islands", + "Isle", + "Isles", + "Jungle", + "Jungles", + "Lagoon", + "Lagoons", + "Lake", + "Lakes", + "Marsh", + "Mesa", + "Mist", + "Mists", + "Monsoon", + "Morass", + "Mountain", + "Mountains", + "Oasis", + "Peak", + "Peaks", + "Rain", + "Rainforest", + "Reservoir", + "Ridge", + "River", + "Rivers", + "Shore", + "Shores", + "Shower", + "Sierra", + "Slopes", + "Storm", + "Swamp", + "Swamps", + "Thicket", + "Torrent", + "Wild", + "Wilderness", + "Wilds", + "Woodland", + "Woodlands", + "Woods" + ] +} \ No newline at end of file diff --git a/data/tiefling.json b/data/tiefling.json new file mode 100644 index 0000000..a6b01d2 --- /dev/null +++ b/data/tiefling.json @@ -0,0 +1,366 @@ +{ + "nm1": [ + "Aet", + "Ak", + "Am", + "Aran", + "And", + "Ar", + "Ark", + "Bar", + "Car", + "Cas", + "Dam", + "Dhar", + "Eb", + "Ek", + "Er", + "Gar", + "Gu", + "Gue", + "Hor", + "Ia", + "Ka", + "Kai", + "Kar", + "Kil", + "Kos", + "Ky", + "Loke", + "Mal", + "Male", + "Mav", + "Me", + "Mor", + "Neph", + "Oz", + "Ral", + "Re", + "Rol", + "Sal", + "Sha", + "Sir", + "Ska", + "The", + "Thy", + "Thyne", + "Ur", + "Uri", + "Val", + "Xar", + "Zar", + "Zer", + "Zher", + "Zor" + ], + "nm2": [ + "adius", + "akas", + "akos", + "char", + "cis", + "cius", + "dos", + "emon", + "ichar", + "il", + "ilius", + "ira", + "lech", + "lius", + "lyre", + "marir", + "menos", + "meros", + "mir", + "mong", + "mos", + "mus", + "non", + "rai", + "rakas", + "rakir", + "reus", + "rias", + "ris", + "rius", + "ron", + "ros", + "rus", + "rut", + "shoon", + "thor", + "thos", + "thus", + "us", + "venom", + "vir", + "vius", + "xes", + "xik", + "xikas", + "xire", + "xius", + "xus", + "zer", + "zire" + ], + "nm3": [ + "Achievement", + "Adventure", + "Aid", + "Ambition", + "Anguish", + "Art", + "Ashes", + "Atonement", + "Awe", + "Bliss", + "Bright", + "Carrion", + "Carrior", + "Chant", + "Cheer", + "Cherish", + "Closed", + "Comfort", + "Compassion", + "Confidence", + "Content", + "Courage", + "Creed", + "Cunning", + "Darkness", + "Death", + "Debauchery", + "Deceit", + "Delight", + "Desire", + "Despair", + "Devotion", + "Dexterity", + "Different", + "Doom", + "Doubt", + "Dread", + "Ecstasy", + "End", + "Enduring", + "Ennui", + "Entropy", + "Essential", + "Esteem", + "Eternal", + "Euphoria", + "Excellence", + "Exceptional", + "Exciting", + "Expert", + "Expertise", + "Expressive", + "Extreme", + "Faith", + "Fear", + "Flawed", + "Free", + "Freedom", + "Fresh", + "Gentle", + "Gladness", + "Glee", + "Gloom", + "Glory", + "Gluttony", + "Grief", + "Happiness", + "Happy", + "Harmony", + "Hate", + "Hatred", + "Hero", + "Hope", + "Horror", + "Hunt", + "Hymn", + "Ideal", + "Ignominy", + "Immortal", + "Innovation", + "Interesting", + "Journey", + "Joy", + "Laughter", + "Life", + "Light", + "Love", + "Loyal", + "Lust", + "Mantra", + "Master", + "Mastery", + "Mayhem", + "Misery", + "Mockery", + "Murder", + "Muse", + "Music", + "Mystery", + "Normal", + "Nowhere", + "Odd", + "Open", + "Optimal", + "Pain", + "Panic", + "Passion", + "Perfect", + "Piety", + "Pleasure", + "Poetry", + "Possession", + "Promise", + "Psalm", + "Pure", + "Quest", + "Random", + "Rare", + "Recovery", + "Redemption", + "Regular", + "Relentless", + "Respect", + "Reverence", + "Revulsion", + "Sadness", + "Sanctity", + "Silence", + "Skilled", + "Sly", + "Song", + "Sorrow", + "Suffering", + "Temerity", + "Terror", + "Timeless", + "Torment", + "Tragedy", + "Trickery", + "Trouble", + "Trust", + "Truth", + "Uncommon", + "Unlocked", + "Vice", + "Virtue", + "Void", + "Voyage", + "Weary", + "Winning", + "Wit", + "Woe" + ], + "nm4": [ + "Af", + "Agne", + "Ani", + "Ara", + "Ari", + "Aria", + "Bel", + "Bri", + "Cre", + "Da", + "Di", + "Dim", + "Dor", + "Ea", + "Fri", + "Gri", + "His", + "In", + "Ini", + "Kal", + "Le", + "Lev", + "Lil", + "Ma", + "Mar", + "Mis", + "Mith", + "Na", + "Nat", + "Ne", + "Neth", + "Nith", + "Ori", + "Pes", + "Phe", + "Qu", + "Ri", + "Ro", + "Sa", + "Sar", + "Seiri", + "Sha", + "Val", + "Vel", + "Ya", + "Yora", + "Yu", + "Za", + "Zai", + "Ze" + ], + "nm5": [ + "bis", + "borys", + "cria", + "cyra", + "dani", + "doris", + "faris", + "firith", + "goria", + "grea", + "hala", + "hiri", + "karia", + "ki", + "laia", + "lia", + "lies", + "lista", + "lith", + "loth", + "lypsis", + "lyvia", + "maia", + "meia", + "mine", + "narei", + "nirith", + "nise", + "phi", + "pione", + "punith", + "qine", + "rali", + "rissa", + "seis", + "solis", + "spira", + "tari", + "tish", + "uphis", + "vari", + "vine", + "wala", + "wure", + "xibis", + "xori", + "yis", + "yola", + "za", + "zes" + ] +} \ No newline at end of file diff --git a/data/tortle.json b/data/tortle.json new file mode 100644 index 0000000..33a7405 --- /dev/null +++ b/data/tortle.json @@ -0,0 +1,109 @@ +{ + "nm1": [ + "", + "", + "", + "", + "b", + "d", + "g", + "j", + "k", + "kr", + "l", + "n", + "pl", + "q", + "s", + "t", + "w", + "x", + "y" + ], + "nm2": [ + "ue", + "uo", + "ua", + "ia", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u" + ], + "nm3": [ + "b", + "d", + "k", + "l", + "lb", + "ld", + "lk", + "m", + "n", + "nn", + "nl", + "nq", + "nqw", + "qw", + "p", + "pp", + "r", + "rdl", + "rt", + "rtl", + "z", + "zl" + ], + "nm4": [ + "y", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u" + ], + "nm5": [ + "", + "", + "", + "", + "", + "c", + "d", + "g", + "k", + "l", + "ll", + "m", + "n", + "r", + "t", + "tt" + ] +} \ No newline at end of file diff --git a/data/triton.json b/data/triton.json new file mode 100644 index 0000000..0c42dc5 --- /dev/null +++ b/data/triton.json @@ -0,0 +1,213 @@ +{ + "nm1": [ + "c", + "d", + "dh", + "j", + "jh", + "k", + "kh", + "m", + "n", + "r", + "v", + "z" + ], + "nm2": [ + "a", + "e", + "i", + "o", + "u" + ], + "nm3": [ + "d", + "dd", + "g", + "gl", + "hn", + "hl", + "hr", + "l", + "lg", + "lm", + "ld", + "ln", + "lz", + "m", + "mn", + "mr", + "n", + "nn", + "nd", + "nl", + "nr", + "nv", + "r", + "rl", + "rn", + "rv", + "rz", + "v", + "vn", + "z" + ], + "nm4": [ + "", + "", + "", + "", + "", + "", + "", + "", + "b", + "bh", + "d", + "dh", + "f", + "fl", + "h", + "l", + "m", + "n", + "s", + "sh", + "vl", + "w", + "wh", + "y" + ], + "nm5": [ + "a", + "e", + "o", + "u", + "a", + "e", + "o", + "u", + "i" + ], + "nm6": [ + "d", + "dd", + "dr", + "gr", + "gl", + "hl", + "hn", + "l", + "lr", + "lt", + "lth", + "ml", + "nl", + "nth", + "nr", + "r", + "rn", + "rl", + "rr", + "s", + "sh", + "st", + "sl", + "sn", + "t", + "th", + "tr", + "thr", + "tl", + "thl" + ], + "nm7": [ + "d", + "h", + "l", + "m", + "n", + "r" + ], + "nm8": [ + "e", + "y", + "y", + "y", + "y", + "y", + "y" + ], + "nm9": [ + "", + "", + "", + "b", + "bh", + "d", + "dh", + "j", + "g", + "l", + "m", + "n", + "p", + "r", + "s", + "v", + "z" + ], + "nm10": [ + "a", + "u", + "a", + "u", + "a", + "u", + "e", + "o" + ], + "nm11": [ + "b", + "d", + "g", + "gh", + "hl", + "hn", + "hm", + "hr", + "l", + "n", + "m", + "r", + "v" + ], + "nm12": [ + "a", + "o", + "a", + "o", + "e", + "u" + ], + "nm13": [ + "d", + "g", + "l", + "ll", + "ln", + "lm", + "lv", + "m", + "mn", + "n", + "ns", + "nz", + "r", + "rs", + "s", + "sn", + "x", + "z" + ] +} \ No newline at end of file diff --git a/data/vedalken.json b/data/vedalken.json new file mode 100644 index 0000000..b1377f6 --- /dev/null +++ b/data/vedalken.json @@ -0,0 +1,226 @@ +{ + "nm1": [ + "", + "", + "", + "", + "", + "", + "b", + "bh", + "d", + "dh", + "dr", + "f", + "k", + "kh", + "l", + "m", + "n", + "nh", + "p", + "r", + "tr", + "y", + "z" + ], + "nm2": [ + "a", + "e", + "i", + "o", + "u" + ], + "nm3": [ + "b", + "bl", + "d", + "dr", + "dv", + "g", + "gg", + "gl", + "l", + "ld", + "ll", + "lv", + "m", + "n", + "pl", + "r", + "rd", + "rv", + "t", + "th", + "tl", + "thv", + "tr", + "v", + "vl", + "vr" + ], + "nm4": [ + "l", + "ll", + "n", + "r", + "v", + "z" + ], + "nm5": [ + "c", + "d", + "l", + "ll", + "n", + "r", + "sh", + "t", + "tt", + "v", + "z" + ], + "nm6": [ + "", + "", + "", + "", + "", + "b", + "bl", + "br", + "d", + "dr", + "f", + "gr", + "h", + "k", + "kl", + "l", + "m", + "n", + "p", + "r", + "s", + "sl", + "tr", + "y", + "z", + "zl" + ], + "nm7": [ + "ai", + "ie", + "ia", + "ei", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o" + ], + "nm8": [ + "d", + "dd", + "dr", + "dv", + "g", + "gr", + "gg", + "l", + "ld", + "lg", + "ll", + "ln", + "lv", + "r", + "rr", + "rv", + "s", + "ss", + "str", + "tr", + "v", + "y", + "z" + ], + "nm9": [ + "a", + "e", + "i", + "a", + "e", + "i", + "o" + ], + "nm10": [ + "l", + "ll", + "n", + "nn", + "s", + "v", + "y", + "z" + ], + "nm11": [ + "ia", + "ai", + "aa", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o", + "a", + "e", + "i", + "o" + ], + "nm12": [ + "", + "", + "", + "", + "", + "", + "h", + "l", + "ll", + "n", + "nn", + "s", + "sh", + "ss" + ] +} \ No newline at end of file diff --git a/data/verdan.json b/data/verdan.json new file mode 100644 index 0000000..9dbbc6a --- /dev/null +++ b/data/verdan.json @@ -0,0 +1,115 @@ +{ + "nm1": [ + "br", + "cr", + "d", + "dr", + "gr", + "h", + "j", + "k", + "kl", + "l", + "p", + "pr", + "r", + "s", + "sh", + "sl", + "st", + "str", + "t", + "v", + "w", + "wr" + ], + "nm2": [ + "ee", + "ea", + "ae", + "oi", + "y", + "a", + "a", + "e", + "i", + "o", + "u" + ], + "nm3": [ + "b", + "d", + "gl", + "hm", + "k", + "l", + "ll", + "ls", + "m", + "mv", + "n", + "nv", + "r", + "rk", + "rx", + "s", + "ss", + "th", + "v", + "vl", + "zn" + ], + "nm4": [ + "y", + "a", + "e", + "i", + "a", + "e", + "i", + "a", + "e", + "i" + ], + "nm5": [ + "c", + "g", + "k", + "l", + "n", + "r" + ], + "nm6": [ + "ee", + "ii", + "a", + "i", + "o", + "u", + "a", + "i", + "o", + "u" + ], + "nm7": [ + "", + "", + "", + "", + "", + "g", + "l", + "ld", + "lk", + "lm", + "ls", + "n", + "nn", + "q", + "r", + "rm", + "rt", + "sh", + "t" + ] +} \ No newline at end of file diff --git a/data/warforged.json b/data/warforged.json new file mode 100644 index 0000000..317835b --- /dev/null +++ b/data/warforged.json @@ -0,0 +1,311 @@ +{ + "nm1": [ + "Abider", + "Achiever", + "Actor", + "Adapter", + "Adviser", + "Aegis", + "Agent", + "Animal", + "Apparatus", + "Armament", + "Artist", + "Audience", + "Author", + "Awakener", + "Basher", + "Bastion", + "Battler", + "Bear", + "Beast", + "Beauty", + "Beetle", + "Bender", + "Binder", + "Blade", + "Book", + "Booster", + "Boot", + "Bouncer", + "Brain", + "Brander", + "Brawler", + "Breaker", + "Bringer", + "Browser", + "Bruiser", + "Buffet", + "Bug", + "Builder", + "Bulwark", + "Calmer", + "Candle", + "Cannon", + "Carer", + "Carriage", + "Carrier", + "Cart", + "Carver", + "Case", + "Caster", + "Catcher", + "Chain", + "Chains", + "Challenger", + "Champion", + "Chaperon", + "Charger", + "Chaser", + "Chopper", + "Claymore", + "Cleaver", + "Climber", + "Clock", + "Club", + "Clubber", + "Coil", + "Commander", + "Controller", + "Cook", + "Counter", + "Creator", + "Creature", + "Creese", + "Crew", + "Croaker", + "Crow", + "Crumbler", + "Crusher", + "Curator", + "Curtana", + "Custodian", + "Cutlas", + "Cutlass", + "Cutter", + "Dagger", + "Data", + "Dealer", + "Decipherer", + "Defender", + "Definer", + "Delver", + "Designer", + "Destroyer", + "Diagnoser", + "Director", + "Dirk", + "Diver", + "Doctor", + "Dozer", + "Dreamer", + "Drifter", + "Driver", + "Drone", + "Echo", + "Edge", + "Enchanter", + "Epee", + "Eraser", + "Estoc", + "Etcher", + "Examiner", + "Expert", + "Falchion", + "Familiar", + "Fighter", + "Figure", + "Fire", + "Five", + "Flail", + "Flame", + "Fluke", + "Foil", + "Follower", + "Forger", + "Four", + "Friend", + "Fumbler", + "Gasher", + "Gauger", + "Ghost", + "Giant", + "Gift", + "Glaive", + "Glancer", + "Griller", + "Grunter", + "Guardian", + "Guest", + "Guide", + "Hacker", + "Hammer", + "Handler", + "Heart", + "Help", + "Hook", + "Horn", + "Host", + "Hummer", + "Hunter", + "Image", + "Inspector", + "Iron", + "Judge", + "Junior", + "Jury", + "Katana", + "Kid", + "Killer", + "Knife", + "Knocker", + "Kris", + "Launcher", + "Leaper", + "Lifter", + "Lock", + "Locket", + "Lurker", + "Mace", + "Machine", + "Mark", + "Marker", + "Mask", + "Masker", + "Mauler", + "Melter", + "Menace", + "Mentor", + "Merger", + "Metal", + "Mime", + "Mistake", + "Model", + "Molder", + "Murderer", + "Nameless", + "Needle", + "Nemo", + "Novice", + "Nurse", + "Observer", + "Officer", + "Ogler", + "One", + "Ornament", + "Painter", + "Passenger", + "Patient", + "Patriot", + "Pierce", + "Pilot", + "Pious", + "Player", + "Porter", + "Preacher", + "Pretender", + "Prize", + "Probe", + "Protector", + "Prowler", + "Punisher", + "Query", + "Ravager", + "Reader", + "Reckoner", + "Relic", + "Render", + "Rescuer", + "Responder", + "Reviewer", + "Rider", + "Rune", + "Saber", + "Sabre", + "Safeguard", + "Salvager", + "Saviour", + "Scimitar", + "Scorcher", + "Scratcher", + "Scrubber", + "Searcher", + "Security", + "Seeker", + "Senior", + "Senser", + "Sentinel", + "Sentry", + "Servant", + "Shaper", + "Shepherd", + "Shield", + "Shielder", + "Shredder", + "Slasher", + "Slicer", + "Smasher", + "Smiter", + "Snooper", + "Spark", + "Sparkle", + "Special", + "Spirit", + "Sprinter", + "Sprite", + "Squasher", + "Stalker", + "Status", + "Steel", + "Steeple", + "Stick", + "Sticks", + "Stitcher", + "Striker", + "Student", + "Stumbler", + "Subject", + "Suit", + "Sunderer", + "Supporter", + "Surveyor", + "Sword", + "Tackler", + "Taunter", + "Teacher", + "Teaser", + "Tempter", + "Tester", + "Thief", + "Thinker", + "Three", + "Thunder", + "Tinkerer", + "Titan", + "Toad", + "Toledo", + "Tutor", + "Twister", + "Two", + "Undoer", + "Unit", + "Unmaker", + "Unsung", + "Vessel", + "Victor", + "Visitor", + "Voice", + "Walker", + "Ward", + "Warden", + "Watcher", + "Whisperer", + "Wielder", + "Winker", + "Winner", + "Wonderer", + "Wrestler", + "Zealot", + "Zero" + ] +} \ No newline at end of file diff --git a/data/wilden.json b/data/wilden.json new file mode 100644 index 0000000..95849bf --- /dev/null +++ b/data/wilden.json @@ -0,0 +1,214 @@ +{ + "nmMFf": [ + "Ban", + "Bar", + "Dal", + "Dam", + "Dun", + "Dur", + "Fas", + "Fin", + "Kan", + "Kin", + "Kor", + "Lan", + "Lim", + "Lon", + "Man", + "Mar", + "Mas", + "Mid", + "Mor", + "Mur", + "Nam", + "Nor", + "Rad", + "Ran", + "Ras", + "Rod", + "San", + "Sin", + "Tor", + "Tum" + ], + "nmMFl": [ + "darras", + "darris", + "dommar", + "donnir", + "durrun", + "farran", + "fidden", + "garron", + "kammin", + "karran", + "lammir", + "larrin", + "mannor", + "marden", + "mennar", + "mennor", + "mindin", + "mirron", + "morrin", + "murrin", + "norren", + "norten", + "rammas", + "sammas", + "sannim", + "sarrin", + "sarris", + "sorran", + "tarrin", + "torrin" + ], + "nmMSf": [ + "Barrun", + "Burrin", + "Darras", + "Farran", + "Farrin", + "Fidden", + "Garrin", + "Harren", + "Harrun", + "Karrat", + "Karren", + "Ketten", + "Korrin", + "Larras", + "Lommir", + "Lorrin", + "Marrad", + "Mirren", + "Mirrun", + "Morrin", + "Parran", + "Purren", + "Tarris", + "Torren", + "Torrim", + "Turrus", + "Venner", + "Vunnar", + "Zakkan", + "Zarrak" + ], + "nmMSl": [ + "bar", + "bor", + "bun", + "das", + "din", + "dun", + "dur", + "fas", + "fum", + "gar", + "gun", + "kas", + "kin", + "las", + "lis", + "mar", + "mas", + "min", + "mur", + "nas", + "nim", + "nor", + "pan", + "rak", + "ras", + "tor", + "tur", + "zad", + "zim", + "zor" + ], + "nmFF": [ + "Allin", + "Ashin", + "Bunn", + "Dann", + "Darn", + "Diss", + "Enn", + "Eril", + "Fenn", + "Fert", + "Firr", + "Fiss", + "Genn", + "Grin", + "Kalk", + "Kenn", + "Kers", + "Krin", + "Lerm", + "Less", + "Linn", + "Lorr", + "Minn", + "Mirt", + "Mist", + "Nem", + "Niss", + "Shall", + "Shan", + "Shenn", + "Tarr", + "Taz", + "Tell", + "Tin", + "Tirr", + "Tris", + "Wenn", + "Zar", + "Zaz", + "Zell" + ], + "nmFL": [ + "ahai", + "akei", + "alin", + "amai", + "anai", + "annar", + "annas", + "arris", + "arrel", + "arresh", + "artish", + "asha", + "atish", + "elbis", + "embin", + "enna", + "ennash", + "entah", + "eris", + "erla", + "erlis", + "imai", + "imbel", + "imei", + "immesh", + "inah", + "inash", + "inda", + "inna", + "innem", + "irrah", + "ishai", + "issa", + "itas", + "onnes", + "onteh", + "orda", + "oren", + "oris", + "orren" + ] +} \ No newline at end of file diff --git a/data/yuan-ti.json b/data/yuan-ti.json new file mode 100644 index 0000000..ae90083 --- /dev/null +++ b/data/yuan-ti.json @@ -0,0 +1,151 @@ +{ + "nm1": [ + "", + "", + "", + "", + "", + "h", + "m", + "n", + "s", + "sh", + "ss", + "ssh", + "sz", + "t", + "th", + "y", + "z", + "zh", + "zs" + ], + "nm2": [ + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "a", + "e", + "i", + "o", + "u", + "oa", + "ui" + ], + "nm3": [ + "h", + "hl", + "htl", + "hl", + "hs", + "hsh", + "k", + "kh", + "kl", + "ktl", + "ks", + "l", + "lk", + "ls", + "ltl", + "lts", + "lsh", + "m", + "n", + "s", + "sh", + "ss", + "st", + "stl", + "sz", + "sk", + "t", + "tl", + "ts", + "tsh", + "tsz", + "tz", + "tstl", + "zs", + "zh", + "zsh", + "zt", + "ztl" + ], + "nm4": [ + "h", + "hs", + "hl", + "l", + "ll", + "s", + "sh", + "ss", + "shl", + "t", + "th", + "y", + "z", + "zh" + ], + "nm5": [ + "a", + "i", + "u", + "a", + "i", + "u", + "a", + "i", + "u", + "a", + "i", + "u", + "a", + "i", + "u", + "a", + "i", + "u", + "ie", + "ia", + "ei", + "ee", + "iu", + "ui" + ], + "nm6": [ + "", + "", + "", + "", + "", + "", + "", + "", + "h", + "h", + "l", + "ll", + "s", + "ss", + "sh" + ] +} \ No newline at end of file diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..a3c9385 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,10 @@ +services: + namegen: + build: . + ports: + - "8080:8080" + environment: + - RATE_LIMIT_RPS=2 + - RATE_LIMIT_BURST=5 + - ALLOWED_ORIGINS=https://utills.fernandovideira.com + restart: unless-stopped diff --git a/env.go b/env.go new file mode 100644 index 0000000..e0b5fde --- /dev/null +++ b/env.go @@ -0,0 +1,39 @@ +package main + +import ( + "os" + "strconv" + "strings" +) + +// GetEnvFloat retrieves a float64 from env or returns fallback +func GetEnvFloat(key string, fallback float64) float64 { + val, ok := os.LookupEnv(key) + if !ok { + return fallback + } + if v, err := strconv.ParseFloat(val, 64); err == nil { + return v + } + return fallback +} + +// GetEnvInt retrieves an int from env or returns fallback +func GetEnvInt(key string, fallback int) int { + val, ok := os.LookupEnv(key) + if !ok { + return fallback + } + if v, err := strconv.Atoi(val); err == nil { + return v + } + return fallback +} + +func GetEnvList(key string, fallback []string) []string { + val, ok := os.LookupEnv(key) + if !ok { + return fallback + } + return strings.Split(val, ",") +} diff --git a/generators/aasimar.go b/generators/aasimar.go new file mode 100644 index 0000000..2eaa644 --- /dev/null +++ b/generators/aasimar.go @@ -0,0 +1,118 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "time" +) + +type AasimarData struct { + Male struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + } `json:"male"` + Female struct { + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` + Nm11 []string `json:"nm11"` + Nm12 []string `json:"nm12"` + Nm13 []string `json:"nm13"` + } `json:"female"` +} + +var aasimarData AasimarData + +func LoadAasimarData(path string) error { + file, err := os.Open(path) + if err != nil { + return err + } + defer file.Close() + return json.NewDecoder(file).Decode(&aasimarData) +} + +func GenerateAasimarName(gender string) string { + rand.Seed(time.Now().UnixNano()) + if gender == "female" { + return generateAasimarFemaleName() + } + return generateAasimarMaleName() +} + +func generateAasimarMaleName() string { + nm1 := aasimarData.Male.Nm1 + nm2 := aasimarData.Male.Nm2 + nm3 := aasimarData.Male.Nm3 + nm4 := aasimarData.Male.Nm4 + nm5 := aasimarData.Male.Nm5 + nm6 := aasimarData.Male.Nm6 + i := rand.Intn(10) + var nMs string + if i < 6 { + rnd := rand.Intn(len(nm1)) + rnd2 := rand.Intn(len(nm2)) + rnd3 := rand.Intn(len(nm3)) + rnd4 := rand.Intn(len(nm4)) + rnd5 := rand.Intn(len(nm6)) + for nm3[rnd3] == nm1[rnd] || nm3[rnd3] == nm6[rnd5] { + rnd3 = rand.Intn(len(nm3)) + } + nMs = nm1[rnd] + nm2[rnd2] + nm3[rnd3] + nm4[rnd4] + nm6[rnd5] + } else { + rnd := rand.Intn(len(nm1)) + rnd2 := rand.Intn(len(nm2)) + rnd3 := rand.Intn(len(nm3)) + rnd4 := rand.Intn(len(nm4)) + rnd5 := rand.Intn(len(nm6)) + rnd6 := rand.Intn(len(nm5)) + rnd7 := rand.Intn(len(nm4)) + for nm5[rnd6] == nm3[rnd3] || nm5[rnd6] == nm6[rnd5] { + rnd6 = rand.Intn(len(nm5)) + } + nMs = nm1[rnd] + nm2[rnd2] + nm3[rnd3] + nm4[rnd4] + nm5[rnd6] + nm4[rnd7] + nm6[rnd5] + } + return nMs +} + +func generateAasimarFemaleName() string { + nm7 := aasimarData.Female.Nm7 + nm8 := aasimarData.Female.Nm8 + nm9 := aasimarData.Female.Nm9 + nm10 := aasimarData.Female.Nm10 + nm11 := aasimarData.Female.Nm11 + nm12 := aasimarData.Female.Nm12 + nm13 := aasimarData.Female.Nm13 + i := rand.Intn(10) + var nMs string + if i < 6 { + rnd := rand.Intn(len(nm7)) + rnd2 := rand.Intn(len(nm8)) + rnd3 := rand.Intn(len(nm9)) + rnd4 := rand.Intn(len(nm10)) + rnd5 := rand.Intn(len(nm13)) + for nm9[rnd3] == nm7[rnd] || nm9[rnd3] == nm13[rnd5] { + rnd3 = rand.Intn(len(nm9)) + } + nMs = nm7[rnd] + nm8[rnd2] + nm9[rnd3] + nm10[rnd4] + nm13[rnd5] + } else { + rnd := rand.Intn(len(nm7)) + rnd2 := rand.Intn(len(nm8)) + rnd3 := rand.Intn(len(nm9)) + rnd4 := rand.Intn(len(nm10)) + rnd5 := rand.Intn(len(nm13)) + rnd6 := rand.Intn(len(nm11)) + rnd7 := rand.Intn(len(nm12)) + for nm11[rnd6] == nm9[rnd3] || nm11[rnd6] == nm13[rnd5] { + rnd6 = rand.Intn(len(nm11)) + } + nMs = nm7[rnd] + nm8[rnd2] + nm9[rnd3] + nm10[rnd4] + nm11[rnd6] + nm12[rnd7] + nm13[rnd5] + } + return nMs +} diff --git a/generators/arakocra.go b/generators/arakocra.go new file mode 100644 index 0000000..aa29f40 --- /dev/null +++ b/generators/arakocra.go @@ -0,0 +1,50 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "strings" +) + +type ArakocraArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` +} + +func LoadArakocraArrays(path string) (*ArakocraArrays, error) { + file, err := os.Open(path) + if err != nil { + return nil, err + } + defer file.Close() + var arr ArakocraArrays + if err := json.NewDecoder(file).Decode(&arr); err != nil { + return nil, err + } + return &arr, nil +} + +func ArakocraNameMas(arr *ArakocraArrays, check func(string) bool, i int) string { + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + rnd3 := rand.Intn(len(arr.Nm5)) + var nMs string + if i < 5 { + for arr.Nm1[rnd] == arr.Nm5[rnd3] { + rnd3 = rand.Intn(len(arr.Nm5)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm5[rnd3] + } else { + rnd4 := rand.Intn(len(arr.Nm3)) + rnd5 := rand.Intn(len(arr.Nm4)) + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd4] + arr.Nm4[rnd5] + arr.Nm5[rnd3] + } + if check(strings.ToLower(nMs)) { + return "" + } + return nMs +} diff --git a/generators/bugbear.go b/generators/bugbear.go new file mode 100644 index 0000000..ffbc48c --- /dev/null +++ b/generators/bugbear.go @@ -0,0 +1,49 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "time" +) + +type BugbearArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` +} + +func LoadBugbearArrays(path string) (*BugbearArrays, error) { + file, err := os.Open(path) + if err != nil { + return nil, err + } + defer file.Close() + var arrays BugbearArrays + if err := json.NewDecoder(file).Decode(&arrays); err != nil { + return nil, err + } + return &arrays, nil +} + +func BugbearNameMas(arr *BugbearArrays, checkSwear func(string) bool) string { + rand.Seed(time.Now().UnixNano()) + nTp := rand.Intn(3) + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm4)) + rnd3 := rand.Intn(len(arr.Nm5)) + var nMs string + if nTp == 0 { + nMs = arr.Nm1[rnd] + arr.Nm4[rnd2] + arr.Nm5[rnd3] + } else { + rnd4 := rand.Intn(len(arr.Nm2)) + rnd5 := rand.Intn(len(arr.Nm3)) + nMs = arr.Nm1[rnd] + arr.Nm2[rnd4] + arr.Nm3[rnd5] + arr.Nm4[rnd2] + arr.Nm5[rnd3] + } + if checkSwear != nil && checkSwear(nMs) { + return "" + } + return nMs +} diff --git a/generators/centaur.go b/generators/centaur.go new file mode 100644 index 0000000..3f3e5f6 --- /dev/null +++ b/generators/centaur.go @@ -0,0 +1,116 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "time" +) + +type CentaurData struct { + Male struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + } `json:"male"` + Female struct { + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` + Nm11 []string `json:"nm11"` + Nm12 []string `json:"nm12"` + Nm13 []string `json:"nm13"` + Nm14 []string `json:"nm14"` + } `json:"female"` + Surname1 []string `json:"surname1"` + Surname2 []string `json:"surname2"` +} + +var centaurData CentaurData + +func LoadCentaurData(path string) error { + file, err := os.Open(path) + if err != nil { + return err + } + defer file.Close() + return json.NewDecoder(file).Decode(¢aurData) +} + +func GenerateCentaurName(gender string) string { + rand.Seed(time.Now().UnixNano()) + var nMs string + if gender == "female" { + nMs = generateCentaurFemaleName() + } else { + nMs = generateCentaurMaleName() + } + sur1 := centaurData.Surname1[rand.Intn(len(centaurData.Surname1))] + sur2 := centaurData.Surname2[rand.Intn(len(centaurData.Surname2))] + return nMs + " " + sur1 + sur2 +} + +func generateCentaurMaleName() string { + m := centaurData.Male + nTp := rand.Intn(5) + rnd := rand.Intn(len(m.Nm1)) + rnd2 := rand.Intn(len(m.Nm2)) + rnd5 := rand.Intn(len(m.Nm7)) + if nTp == 0 { + for m.Nm1[rnd] == "" { + rnd = rand.Intn(len(m.Nm1)) + } + for m.Nm7[rnd5] == "" { + rnd5 = rand.Intn(len(m.Nm7)) + } + return m.Nm1[rnd] + m.Nm2[rnd2] + m.Nm7[rnd5] + } else { + rnd3 := rand.Intn(len(m.Nm3)) + rnd4 := rand.Intn(len(m.Nm4)) + for m.Nm3[rnd3] == m.Nm1[rnd] || m.Nm3[rnd3] == m.Nm7[rnd5] { + rnd3 = rand.Intn(len(m.Nm3)) + } + if rnd2 == 0 { + for rnd4 == 0 { + rnd4 = rand.Intn(len(m.Nm4)) + } + } + if nTp < 4 { + return m.Nm1[rnd] + m.Nm2[rnd2] + m.Nm3[rnd3] + m.Nm4[rnd4] + m.Nm7[rnd5] + } else { + rnd6 := rand.Intn(len(m.Nm5)) + rnd7 := rand.Intn(len(m.Nm6)) + for m.Nm3[rnd3] == m.Nm5[rnd6] || m.Nm5[rnd6] == m.Nm7[rnd5] { + rnd6 = rand.Intn(len(m.Nm5)) + } + return m.Nm1[rnd] + m.Nm2[rnd2] + m.Nm3[rnd3] + m.Nm4[rnd4] + m.Nm5[rnd6] + m.Nm6[rnd7] + m.Nm7[rnd5] + } + } +} + +func generateCentaurFemaleName() string { + f := centaurData.Female + nTp := rand.Intn(3) + rnd := rand.Intn(len(f.Nm8)) + rnd2 := rand.Intn(len(f.Nm9)) + rnd3 := rand.Intn(len(f.Nm10)) + rnd4 := rand.Intn(len(f.Nm13)) + rnd5 := rand.Intn(len(f.Nm14)) + if nTp < 2 { + for f.Nm8[rnd] == f.Nm10[rnd3] || f.Nm10[rnd3] == f.Nm14[rnd5] { + rnd3 = rand.Intn(len(f.Nm10)) + } + return f.Nm8[rnd] + f.Nm9[rnd2] + f.Nm10[rnd3] + f.Nm13[rnd4] + f.Nm14[rnd5] + } else { + rnd6 := rand.Intn(len(f.Nm11)) + rnd7 := rand.Intn(len(f.Nm12)) + for f.Nm12[rnd7] == f.Nm10[rnd3] || f.Nm12[rnd7] == f.Nm14[rnd5] { + rnd7 = rand.Intn(len(f.Nm12)) + } + return f.Nm8[rnd] + f.Nm9[rnd2] + f.Nm10[rnd3] + f.Nm11[rnd6] + f.Nm12[rnd7] + f.Nm13[rnd4] + f.Nm14[rnd5] + } +} diff --git a/generators/changeling.go b/generators/changeling.go new file mode 100644 index 0000000..cd95c28 --- /dev/null +++ b/generators/changeling.go @@ -0,0 +1,42 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "time" +) + +type ChangelingArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` +} + +func LoadChangelingArrays(path string) (*ChangelingArrays, error) { + file, err := os.Open(path) + if err != nil { + return nil, err + } + defer file.Close() + var arrays ChangelingArrays + if err := json.NewDecoder(file).Decode(&arrays); err != nil { + return nil, err + } + return &arrays, nil +} + +func ChangelingNameMas(arr *ChangelingArrays, checkSwear func(string) bool) string { + rand.Seed(time.Now().UnixNano()) + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + rnd3 := rand.Intn(len(arr.Nm3)) + for arr.Nm1[rnd] == arr.Nm3[rnd3] { + rnd3 = rand.Intn(len(arr.Nm3)) + } + nMs := arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + if checkSwear != nil && checkSwear(nMs) { + return "" + } + return nMs +} diff --git a/generators/deep_gnome.go b/generators/deep_gnome.go new file mode 100644 index 0000000..2344455 --- /dev/null +++ b/generators/deep_gnome.go @@ -0,0 +1,98 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "time" +) + +type DeepGnomeData struct { + Male struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + } `json:"male"` + Female struct { + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` + Nm11 []string `json:"nm11"` + Nm12 []string `json:"nm12"` + } `json:"female"` + Surname1 []string `json:"surname1"` + Surname2 []string `json:"surname2"` +} + +var deepGnomeData DeepGnomeData + +func LoadDeepGnomeData(path string) error { + file, err := os.Open(path) + if err != nil { + return err + } + defer file.Close() + return json.NewDecoder(file).Decode(&deepGnomeData) +} + +func GenerateDeepGnomeName(gender string) string { + rand.Seed(time.Now().UnixNano()) + var nMs string + if gender == "female" { + nMs = generateDeepGnomeFemaleName() + } else { + nMs = generateDeepGnomeMaleName() + } + sur1 := deepGnomeData.Surname1[rand.Intn(len(deepGnomeData.Surname1))] + sur2 := deepGnomeData.Surname2[rand.Intn(len(deepGnomeData.Surname2))] + return nMs + " " + sur1 + sur2 +} + +func generateDeepGnomeMaleName() string { + m := deepGnomeData.Male + rnd := rand.Intn(len(m.Nm1)) + rnd2 := rand.Intn(len(m.Nm2)) + rnd3 := rand.Intn(len(m.Nm3)) + rnd4 := rand.Intn(len(m.Nm4)) + rnd5 := rand.Intn(len(m.Nm5)) + for m.Nm3[rnd3] == m.Nm1[rnd] || m.Nm3[rnd3] == m.Nm5[rnd5] { + rnd3 = rand.Intn(len(m.Nm3)) + } + return m.Nm1[rnd] + m.Nm2[rnd2] + m.Nm3[rnd3] + m.Nm4[rnd4] + m.Nm5[rnd5] +} + +func generateDeepGnomeFemaleName() string { + f := deepGnomeData.Female + i := rand.Intn(10) + if i < 5 { + rnd := rand.Intn(len(f.Nm6)) + rnd2 := rand.Intn(len(f.Nm7)) + rnd3 := rand.Intn(len(f.Nm8)) + rnd4 := rand.Intn(len(f.Nm9)) + rnd5 := rand.Intn(len(f.Nm12)) + if rnd < 5 && rnd5 < 7 { + for rnd5 < 7 { + rnd5 = rand.Intn(len(f.Nm12)) + } + } + for f.Nm8[rnd3] == f.Nm6[rnd] || f.Nm8[rnd3] == f.Nm12[rnd5] { + rnd3 = rand.Intn(len(f.Nm8)) + } + return f.Nm6[rnd] + f.Nm7[rnd2] + f.Nm8[rnd3] + f.Nm9[rnd4] + f.Nm12[rnd5] + } else { + rnd := rand.Intn(len(f.Nm6)) + rnd2 := rand.Intn(len(f.Nm7)) + rnd3 := rand.Intn(len(f.Nm8)) + rnd4 := rand.Intn(len(f.Nm9)) + rnd5 := rand.Intn(len(f.Nm10)) + rnd6 := rand.Intn(len(f.Nm11)) + for f.Nm10[rnd5] == f.Nm8[rnd3] || f.Nm8[rnd3] == f.Nm6[rnd] { + rnd3 = rand.Intn(len(f.Nm8)) + } + return f.Nm6[rnd] + f.Nm7[rnd2] + f.Nm8[rnd3] + f.Nm9[rnd4] + f.Nm10[rnd5] + f.Nm11[rnd6] + } +} diff --git a/generators/deva.go b/generators/deva.go new file mode 100644 index 0000000..77540cc --- /dev/null +++ b/generators/deva.go @@ -0,0 +1,91 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "time" +) + +type DevaData struct { + Male struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + } `json:"male"` + Female struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` + Nm11 []string `json:"nm11"` + } `json:"female"` +} + +var devaData DevaData + +func LoadDevaData(path string) error { + file, err := os.Open(path) + if err != nil { + return err + } + defer file.Close() + return json.NewDecoder(file).Decode(&devaData) +} + +func GenerateDevaName(gender string) string { + rand.Seed(time.Now().UnixNano()) + if gender == "female" { + return generateDevaFemaleName() + } + return generateDevaMaleName() +} + +func generateDevaMaleName() string { + m := devaData.Male + rnd := rand.Intn(len(m.Nm1)) + rnd2 := rand.Intn(len(m.Nm2)) + rnd3 := rand.Intn(len(m.Nm3)) + rnd4 := rand.Intn(len(m.Nm4)) + rnd5 := rand.Intn(len(m.Nm5)) + for m.Nm3[rnd3] == m.Nm1[rnd] || m.Nm3[rnd3] == m.Nm5[rnd5] { + rnd3 = rand.Intn(len(m.Nm3)) + } + return m.Nm1[rnd] + m.Nm2[rnd2] + m.Nm3[rnd3] + m.Nm4[rnd4] + m.Nm5[rnd5] +} + +func generateDevaFemaleName() string { + f := devaData.Female + i := rand.Intn(10) + if i < 6 { + rnd := rand.Intn(len(f.Nm6)) + rnd2 := rand.Intn(len(f.Nm7)) + rnd3 := rand.Intn(len(f.Nm8)) + rnd4 := rand.Intn(len(f.Nm9)) + rnd5 := rand.Intn(len(f.Nm11)) + for f.Nm8[rnd3] == f.Nm6[rnd] || f.Nm8[rnd3] == f.Nm11[rnd5] { + rnd3 = rand.Intn(len(f.Nm8)) + } + return f.Nm6[rnd] + f.Nm7[rnd2] + f.Nm8[rnd3] + f.Nm9[rnd4] + f.Nm11[rnd5] + } else { + rnd := rand.Intn(len(f.Nm6)) + rnd2 := rand.Intn(len(f.Nm7)) + rnd3 := rand.Intn(len(f.Nm8)) + rnd4 := rand.Intn(len(f.Nm9)) + rnd5 := rand.Intn(len(f.Nm10)) + rnd6 := rand.Intn(len(f.Nm9)) + rnd7 := rand.Intn(len(f.Nm11)) + for f.Nm10[rnd5] == f.Nm11[rnd7] || f.Nm10[rnd5] == f.Nm8[rnd3] { + rnd5 = rand.Intn(len(f.Nm10)) + } + return f.Nm6[rnd] + f.Nm7[rnd2] + f.Nm8[rnd3] + f.Nm9[rnd4] + f.Nm10[rnd5] + f.Nm9[rnd6] + f.Nm11[rnd7] + } +} diff --git a/generators/dragonborn.go b/generators/dragonborn.go new file mode 100644 index 0000000..3bf4e24 --- /dev/null +++ b/generators/dragonborn.go @@ -0,0 +1,99 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type DragonbornArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` + Nm11 []string `json:"nm11"` + Nm12 []string `json:"nm12"` + Nm13 []string `json:"nm13"` +} + +func LoadDragonbornArrays(path string) (*DragonbornArrays, error) { + file, err := os.Open(path) + if err != nil { + return nil, err + } + defer file.Close() + var arrays DragonbornArrays + if err := json.NewDecoder(file).Decode(&arrays); err != nil { + return nil, err + } + return &arrays, nil +} + +func DragonbornNameMas(arr *DragonbornArrays, checkSwear func(string) bool) string { + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + nMs := arr.Nm1[rnd] + arr.Nm2[rnd2] + if checkSwear != nil && checkSwear(nMs) { + return "" + } + return nMs +} + +func DragonbornNameFem(arr *DragonbornArrays, checkSwear func(string) bool) string { + rnd := rand.Intn(len(arr.Nm3)) + rnd2 := rand.Intn(len(arr.Nm4)) + nMs := arr.Nm3[rnd] + arr.Nm4[rnd2] + if checkSwear != nil && checkSwear(nMs) { + return "" + } + return nMs +} + +func DragonbornNameSur(arr *DragonbornArrays, checkSwear func(string) bool) string { + ntp := rand.Intn(10) + rnd := rand.Intn(len(arr.Nm5)) + rnd2 := rand.Intn(len(arr.Nm6)) + rnd3 := rand.Intn(len(arr.Nm7)) + rnd4 := rand.Intn(len(arr.Nm6)) + rnd5 := rand.Intn(len(arr.Nm10)) + for arr.Nm7[rnd3] == arr.Nm5[rnd] || arr.Nm7[rnd3] == arr.Nm10[rnd5] { + rnd3 = rand.Intn(len(arr.Nm7)) + } + if ntp < 4 { + nSr := arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm7[rnd3] + arr.Nm6[rnd4] + arr.Nm10[rnd5] + if checkSwear != nil && checkSwear(nSr) { + return "" + } + return nSr + } else { + rnd6 := rand.Intn(len(arr.Nm6)) + rnd7 := rand.Intn(len(arr.Nm8)) + for arr.Nm7[rnd3] == arr.Nm8[rnd7] || arr.Nm8[rnd7] == arr.Nm10[rnd5] { + rnd7 = rand.Intn(len(arr.Nm8)) + } + if ntp < 7 { + nSr := arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm7[rnd3] + arr.Nm6[rnd4] + arr.Nm8[rnd7] + arr.Nm6[rnd6] + arr.Nm10[rnd5] + if checkSwear != nil && checkSwear(nSr) { + return "" + } + return nSr + } else { + rnd8 := rand.Intn(len(arr.Nm6)) + rnd9 := rand.Intn(len(arr.Nm9)) + for arr.Nm9[rnd9] == arr.Nm8[rnd7] || arr.Nm9[rnd9] == arr.Nm10[rnd5] { + rnd9 = rand.Intn(len(arr.Nm9)) + } + nSr := arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm7[rnd3] + arr.Nm6[rnd4] + arr.Nm8[rnd7] + arr.Nm6[rnd6] + arr.Nm9[rnd9] + arr.Nm6[rnd8] + arr.Nm10[rnd5] + if checkSwear != nil && checkSwear(nSr) { + return "" + } + return nSr + } + } +} diff --git a/generators/drow.go b/generators/drow.go new file mode 100644 index 0000000..04d6e25 --- /dev/null +++ b/generators/drow.go @@ -0,0 +1,105 @@ +package generators + +import ( + "encoding/json" + "fmt" + "math/rand" + "os" + "strings" + "time" +) + +type DrowData struct { + NmF []string `json:"nmF"` + NmFRf []string `json:"nmFRf"` + NmFRl []string `json:"nmFRl"` + NmFFf []string `json:"nmFFf"` + NmFFl []string `json:"nmFFl"` + NmM []string `json:"nmM"` + NmMRf []string `json:"nmMRf"` + NmMRl []string `json:"nmMRl"` + NmMFf []string `json:"nmMFf"` + NmMFl []string `json:"nmMFl"` + NmS []string `json:"nmS"` + NmSRf []string `json:"nmSRf"` + NmSRl []string `json:"nmSRl"` + NmSFf []string `json:"nmSFf"` + NmSFl []string `json:"nmSFl"` +} + +var drowData DrowData + +func init() { + file, err := os.Open("data/drow.json") + if err != nil { + panic(fmt.Errorf("failed to open drow.json: %w", err)) + } + defer file.Close() + if err := json.NewDecoder(file).Decode(&drowData); err != nil { + panic(fmt.Errorf("failed to decode drow.json: %w", err)) + } + rand.Seed(time.Now().UnixNano()) +} + +func DrowName(gender, surname string) string { + var first, last string + gender = strings.ToLower(gender) + switch gender { + case "male": + first = drowFirstNameMale() + case "female": + first = drowFirstNameFemale() + default: + if rand.Intn(2) == 0 { + first = drowFirstNameMale() + } else { + first = drowFirstNameFemale() + } + } + + // Surname logic + if surname == "true" { + last = drowSurname() + } + + if last != "" { + return first + " " + last + } + return first +} + +func drowFirstNameMale() string { + if rand.Intn(2) == 0 { + return drowData.NmM[rand.Intn(len(drowData.NmM))] + } + return drowData.NmMRf[rand.Intn(len(drowData.NmMRf))] + drowData.NmMRl[rand.Intn(len(drowData.NmMRl))] +} + +func drowFirstNameFemale() string { + if rand.Intn(2) == 0 { + return drowData.NmF[rand.Intn(len(drowData.NmF))] + } + return drowData.NmFFf[rand.Intn(len(drowData.NmFFf))] + drowData.NmFFl[rand.Intn(len(drowData.NmFFl))] +} + +func drowSurname() string { + if rand.Intn(2) == 0 { + return drowData.NmS[rand.Intn(len(drowData.NmS))] + } + return drowData.NmSRf[rand.Intn(len(drowData.NmSRf))] + drowData.NmSRl[rand.Intn(len(drowData.NmSRl))] +} + +// DrowSurname returns a random Drow surname. +func DrowSurname() string { + return drowSurname() +} + +// LoadDrowData loads the Drow data from the specified JSON file. +func LoadDrowData(path string) error { + file, err := os.Open(path) + if err != nil { + return err + } + defer file.Close() + return json.NewDecoder(file).Decode(&drowData) +} diff --git a/generators/duergar.go b/generators/duergar.go new file mode 100644 index 0000000..8d13fec --- /dev/null +++ b/generators/duergar.go @@ -0,0 +1,97 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type DuergarArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` + Nm11 []string `json:"nm11"` + Nm12 []string `json:"nm12"` + Nm13 []string `json:"nm13"` +} + +func LoadDuergarArrays(path string) (*DuergarArrays, error) { + file, err := os.Open(path) + if err != nil { + return nil, err + } + defer file.Close() + var arrays DuergarArrays + if err := json.NewDecoder(file).Decode(&arrays); err != nil { + return nil, err + } + return &arrays, nil +} + +func DuergarNameMas(arr *DuergarArrays, checkSwear func(string) bool) string { + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + nMs := arr.Nm1[rnd] + arr.Nm2[rnd2] + if checkSwear != nil && checkSwear(nMs) { + return "" + } + return nMs +} + +func DuergarNameFem(arr *DuergarArrays, checkSwear func(string) bool) string { + rnd := rand.Intn(len(arr.Nm3)) + rnd2 := rand.Intn(len(arr.Nm4)) + nMs := arr.Nm3[rnd] + arr.Nm4[rnd2] + if checkSwear != nil && checkSwear(nMs) { + return "" + } + return nMs +} + +func DuergarNameSur(arr *DuergarArrays, checkSwear func(string) bool) string { + nTp := rand.Intn(2) + rnd := rand.Intn(len(arr.Nm5)) + rnd2 := rand.Intn(len(arr.Nm6)) + rnd3 := rand.Intn(len(arr.Nm7)) + rnd4 := rand.Intn(len(arr.Nm10)) + rnd5 := rand.Intn(len(arr.Nm11)) + if nTp == 0 { + for arr.Nm11[rnd5] == arr.Nm7[rnd3] && arr.Nm7[rnd3] == arr.Nm5[rnd] { + rnd3 = rand.Intn(len(arr.Nm7)) + } + nMs := arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm7[rnd3] + arr.Nm10[rnd4] + arr.Nm11[rnd5] + if checkSwear != nil && checkSwear(nMs) { + return "" + } + return nMs + } else { + rnd6 := rand.Intn(len(arr.Nm8)) + rnd7 := rand.Intn(len(arr.Nm9)) + for arr.Nm11[rnd5] == arr.Nm9[rnd6] && arr.Nm9[rnd6] == arr.Nm7[rnd3] { + rnd6 = rand.Intn(len(arr.Nm9)) + } + nMs := arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm7[rnd3] + arr.Nm8[rnd6] + arr.Nm9[rnd7] + arr.Nm10[rnd4] + arr.Nm11[rnd5] + if checkSwear != nil && checkSwear(nMs) { + return "" + } + return nMs + } +} + +func DuergarNameFull(arr *DuergarArrays, gender string, checkSwear func(string) bool) string { + var first string + if gender == "female" { + first = DuergarNameFem(arr, checkSwear) + } else { + first = DuergarNameMas(arr, checkSwear) + } + surname := DuergarNameSur(arr, checkSwear) + return first + " " + surname +} diff --git a/generators/dwarf.go b/generators/dwarf.go new file mode 100644 index 0000000..0d13a30 --- /dev/null +++ b/generators/dwarf.go @@ -0,0 +1,84 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "strings" +) + +type DwarfArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` + Nm11 []string `json:"nm11"` + Nm12 []string `json:"nm12"` + Nm13 []string `json:"nm13"` +} + +func LoadDwarfArrays(path string) (*DwarfArrays, error) { + file, err := os.Open(path) + if err != nil { + return nil, err + } + defer file.Close() + var arr DwarfArrays + if err := json.NewDecoder(file).Decode(&arr); err != nil { + return nil, err + } + return &arr, nil +} + +func DwarfNameFem(arr *DwarfArrays, check func(string) bool) string { + rnd := rand.Intn(len(arr.Nm3)) + rnd2 := rand.Intn(len(arr.Nm4)) + nMs := arr.Nm3[rnd] + arr.Nm4[rnd2] + if check(strings.ToLower(nMs)) { + return "" + } + return nMs +} + +func DwarfNameMas(arr *DwarfArrays, check func(string) bool) string { + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + nMs := arr.Nm1[rnd] + arr.Nm2[rnd2] + if check(strings.ToLower(nMs)) { + return "" + } + return nMs +} + +func DwarfNameSur(arr *DwarfArrays, check func(string) bool) string { + nTp := rand.Intn(2) + rnd := rand.Intn(len(arr.Nm5)) + rnd2 := rand.Intn(len(arr.Nm6)) + rnd3 := rand.Intn(len(arr.Nm7)) + rnd4 := rand.Intn(len(arr.Nm10)) + rnd5 := rand.Intn(len(arr.Nm11)) + var nMs string + if nTp == 0 { + for arr.Nm11[rnd5] == arr.Nm7[rnd3] && arr.Nm7[rnd3] == arr.Nm5[rnd] { + rnd3 = rand.Intn(len(arr.Nm7)) + } + nMs = arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm7[rnd3] + arr.Nm10[rnd4] + arr.Nm11[rnd5] + } else { + rnd6 := rand.Intn(len(arr.Nm8)) + rnd7 := rand.Intn(len(arr.Nm9)) + for arr.Nm11[rnd5] == arr.Nm9[rnd7] || arr.Nm9[rnd7] == arr.Nm7[rnd3] { + rnd7 = rand.Intn(len(arr.Nm9)) + } + nMs = arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm7[rnd3] + arr.Nm8[rnd6] + arr.Nm9[rnd7] + arr.Nm10[rnd4] + arr.Nm11[rnd5] + } + if check(strings.ToLower(nMs)) { + return "" + } + return nMs +} diff --git a/generators/eladrin.go b/generators/eladrin.go new file mode 100644 index 0000000..cf8d5e4 --- /dev/null +++ b/generators/eladrin.go @@ -0,0 +1,47 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type EladrinArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` +} + +func LoadEladrinArrays(path string) (*EladrinArrays, error) { + file, err := os.Open(path) + if err != nil { + return nil, err + } + defer file.Close() + var arrays EladrinArrays + if err := json.NewDecoder(file).Decode(&arrays); err != nil { + return nil, err + } + return &arrays, nil +} + +func EladrinNameMas(arr *EladrinArrays, checkSwear func(string) bool) string { + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + nMs := arr.Nm1[rnd] + arr.Nm2[rnd2] + if checkSwear != nil && checkSwear(nMs) { + return "" + } + return nMs +} + +func EladrinNameFem(arr *EladrinArrays, checkSwear func(string) bool) string { + rnd := rand.Intn(len(arr.Nm3)) + rnd2 := rand.Intn(len(arr.Nm4)) + nMs := arr.Nm3[rnd] + arr.Nm4[rnd2] + if checkSwear != nil && checkSwear(nMs) { + return "" + } + return nMs +} diff --git a/generators/elf.go b/generators/elf.go new file mode 100644 index 0000000..6780c0e --- /dev/null +++ b/generators/elf.go @@ -0,0 +1,132 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "strings" +) + +type ElfArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` + Nm11 []string `json:"nm11"` + Nm12 []string `json:"nm12"` + Nm13 []string `json:"nm13"` + Nm14 []string `json:"nm14"` + Nm15 []string `json:"nm15"` + Nm16 []string `json:"nm16"` + Nm17 []string `json:"nm17"` + Nm18 []string `json:"nm18"` +} + +func LoadElfArrays(path string) (*ElfArrays, error) { + file, err := os.Open(path) + if err != nil { + return nil, err + } + defer file.Close() + var arr ElfArrays + if err := json.NewDecoder(file).Decode(&arr); err != nil { + return nil, err + } + return &arr, nil +} + +func ElfNameFem(arr *ElfArrays, check func(string) bool) string { + rnd := rand.Intn(len(arr.Nm3)) + rnd2 := rand.Intn(len(arr.Nm4)) + nMs := arr.Nm3[rnd] + arr.Nm4[rnd2] + if check(strings.ToLower(nMs)) { + return "" + } + return nMs +} + +func ElfNameMas(arr *ElfArrays, check func(string) bool) string { + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + nMs := arr.Nm1[rnd] + arr.Nm2[rnd2] + if check(strings.ToLower(nMs)) { + return "" + } + return nMs +} + +func ElfNameSur(arr *ElfArrays, check func(string) bool) string { + nTp := rand.Intn(8) + rnd := rand.Intn(len(arr.Nm5)) + rnd2 := rand.Intn(len(arr.Nm6)) + rnd3 := rand.Intn(len(arr.Nm7)) + rnd4 := rand.Intn(len(arr.Nm10)) + rnd5 := rand.Intn(len(arr.Nm11)) + var nMs string + if nTp < 3 { + for arr.Nm11[rnd5] == arr.Nm7[rnd3] && arr.Nm7[rnd3] == arr.Nm5[rnd] { + rnd3 = rand.Intn(len(arr.Nm7)) + } + nMs = arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm7[rnd3] + arr.Nm10[rnd4] + arr.Nm11[rnd5] + } else { + rnd6 := rand.Intn(len(arr.Nm8)) + rnd7 := rand.Intn(len(arr.Nm9)) + for arr.Nm11[rnd5] == arr.Nm9[rnd6] && arr.Nm9[rnd6] == arr.Nm7[rnd3] { + rnd7 = rand.Intn(len(arr.Nm9)) + } + if nTp < 6 { + nMs = arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm7[rnd3] + arr.Nm8[rnd6] + arr.Nm9[rnd7] + arr.Nm10[rnd4] + arr.Nm11[rnd5] + } else { + rnd8 := rand.Intn(len(arr.Nm8)) + rnd9 := rand.Intn(len(arr.Nm9)) + for arr.Nm11[rnd5] == arr.Nm9[rnd6] && arr.Nm9[rnd6] == arr.Nm9[rnd9] { + rnd7 = rand.Intn(len(arr.Nm9)) + } + for rnd9 < 8 && rnd7 < 8 { + rnd7 = rand.Intn(len(arr.Nm9)) + } + if nTp == 6 { + nMs = arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm7[rnd3] + arr.Nm8[rnd6] + arr.Nm9[rnd7] + arr.Nm8[rnd8] + arr.Nm9[rnd9] + arr.Nm10[rnd4] + arr.Nm11[rnd5] + } else { + nMs = arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm9[rnd7] + arr.Nm8[rnd8] + arr.Nm7[rnd3] + arr.Nm8[rnd6] + arr.Nm9[rnd9] + arr.Nm10[rnd4] + arr.Nm11[rnd5] + } + } + } + if check(strings.ToLower(nMs)) { + return "" + } + return nMs +} + +func ElfNameChild(arr *ElfArrays, check func(string) bool) string { + nTp := rand.Intn(2) + rnd := rand.Intn(len(arr.Nm14)) + rnd2 := rand.Intn(len(arr.Nm15)) + rnd3 := rand.Intn(len(arr.Nm18)) + var nMs string + if nTp == 0 { + if arr.Nm14[rnd] == "" { + for arr.Nm18[rnd3] == "" { + rnd3 = rand.Intn(len(arr.Nm18)) + } + } + if arr.Nm18[rnd3] == "" { + rnd2 = rand.Intn(7) + } + nMs = arr.Nm14[rnd] + arr.Nm15[rnd2] + arr.Nm18[rnd3] + } else { + rnd4 := rand.Intn(len(arr.Nm16)) + rnd5 := rand.Intn(len(arr.Nm17)) + nMs = arr.Nm14[rnd] + arr.Nm15[rnd2] + arr.Nm16[rnd4] + arr.Nm17[rnd5] + arr.Nm18[rnd3] + } + if check(strings.ToLower(nMs)) { + return "" + } + return nMs +} diff --git a/generators/fairy.go b/generators/fairy.go new file mode 100644 index 0000000..98158d9 --- /dev/null +++ b/generators/fairy.go @@ -0,0 +1,80 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "time" +) + +type FairyArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` +} + +func LoadFairyArrays(path string) (FairyArrays, error) { + var arrays FairyArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func GenerateFairyNames(arr FairyArrays, gender string, swearFilter func(string) bool) []string { + rand.Seed(time.Now().UnixNano()) + var names []string + for i := 0; i < 10; i++ { + var n string + if gender == "female" { + if i < 3 { + for { + n = arr.Nm3[rand.Intn(len(arr.Nm3))] + arr.Nm4[rand.Intn(len(arr.Nm4))] + if !swearFilter(n) { + break + } + } + } else if i < 6 { + for { + n = arr.Nm7[rand.Intn(len(arr.Nm7))] + arr.Nm8[rand.Intn(len(arr.Nm8))] + if !swearFilter(n) { + break + } + } + } else { + n = arr.Nm10[rand.Intn(len(arr.Nm10))] + } + } else { + if i < 3 { + for { + n = arr.Nm1[rand.Intn(len(arr.Nm1))] + arr.Nm2[rand.Intn(len(arr.Nm2))] + if !swearFilter(n) { + break + } + } + } else if i < 6 { + for { + n = arr.Nm5[rand.Intn(len(arr.Nm5))] + arr.Nm6[rand.Intn(len(arr.Nm6))] + if !swearFilter(n) { + break + } + } + } else { + n = arr.Nm9[rand.Intn(len(arr.Nm9))] + } + } + names = append(names, n) + } + return names +} diff --git a/generators/genasi.go b/generators/genasi.go new file mode 100644 index 0000000..96b778c --- /dev/null +++ b/generators/genasi.go @@ -0,0 +1,72 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type GenasiArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` +} + +func LoadGenasiArrays(path string) (GenasiArrays, error) { + var arrays GenasiArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func GenerateGenasiNames(arr GenasiArrays, swearFilter func(string) bool) []string { + // Copy slices to avoid mutating the original arrays + nm1 := append([]string{}, arr.Nm1...) + nm2 := append([]string{}, arr.Nm2...) + nm3 := append([]string{}, arr.Nm3...) + nm4 := append([]string{}, arr.Nm4...) + var names []string + for i := 0; i < 12; i++ { + var n string + if i < 3 { + if len(nm1) == 0 { + continue + } + rnd := rand.Intn(len(nm1)) + n = nm1[rnd] + nm1 = append(nm1[:rnd], nm1[rnd+1:]...) + } else if i < 6 { + if len(nm2) == 0 { + continue + } + rnd := rand.Intn(len(nm2)) + n = nm2[rnd] + nm2 = append(nm2[:rnd], nm2[rnd+1:]...) + } else if i < 9 { + if len(nm3) == 0 { + continue + } + rnd := rand.Intn(len(nm3)) + n = nm3[rnd] + nm3 = append(nm3[:rnd], nm3[rnd+1:]...) + } else { + if len(nm4) == 0 { + continue + } + rnd := rand.Intn(len(nm4)) + n = nm4[rnd] + nm4 = append(nm4[:rnd], nm4[rnd+1:]...) + } + if swearFilter != nil && swearFilter(n) { + continue + } + names = append(names, n) + } + return names +} diff --git a/generators/githyanki.go b/generators/githyanki.go new file mode 100644 index 0000000..8ecbc33 --- /dev/null +++ b/generators/githyanki.go @@ -0,0 +1,133 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type GithyankiArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` + Nm11 []string `json:"nm11"` + Nm12 []string `json:"nm12"` + Nm13 []string `json:"nm13"` + Nm14 []string `json:"nm14"` +} + +func LoadGithyankiArrays(path string) (GithyankiArrays, error) { + var arrays GithyankiArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func GithyankiNameFem(arr *GithyankiArrays, swearFilter func(string) bool) string { + for { + nTp := rand.Intn(5) + rnd := rand.Intn(len(arr.Nm8)) + rnd2 := rand.Intn(len(arr.Nm9)) + rnd3 := rand.Intn(len(arr.Nm14)) + rnd4 := rand.Intn(len(arr.Nm10)) + rnd5 := rand.Intn(len(arr.Nm11)) + for rnd < 4 && rnd4 < 3 { + rnd4 = rand.Intn(len(arr.Nm10)) + } + var nMs string + if nTp < 4 { + for arr.Nm10[rnd4] == arr.Nm8[rnd] || arr.Nm10[rnd4] == arr.Nm14[rnd3] { + rnd4 = rand.Intn(len(arr.Nm10)) + } + nMs = arr.Nm8[rnd] + arr.Nm9[rnd2] + arr.Nm10[rnd4] + arr.Nm11[rnd5] + arr.Nm14[rnd3] + } else { + rnd6 := rand.Intn(len(arr.Nm12)) + rnd7 := rand.Intn(len(arr.Nm13)) + for rnd7 < 4 && rnd4 < 3 { + rnd7 = rand.Intn(len(arr.Nm13)) + } + for rnd7 < 4 && rnd < 3 { + rnd7 = rand.Intn(len(arr.Nm13)) + } + for arr.Nm10[rnd4] == arr.Nm12[rnd6] || arr.Nm12[rnd6] == arr.Nm14[rnd3] { + rnd6 = rand.Intn(len(arr.Nm12)) + } + nMs = arr.Nm8[rnd] + arr.Nm9[rnd2] + arr.Nm10[rnd4] + arr.Nm11[rnd5] + arr.Nm12[rnd6] + arr.Nm13[rnd7] + arr.Nm14[rnd3] + } + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + } +} + +func GithyankiNameMas(arr *GithyankiArrays, swearFilter func(string) bool) string { + for { + nTp := rand.Intn(5) + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + rnd3 := rand.Intn(len(arr.Nm7)) + if nTp == 0 { + for arr.Nm1[rnd] == "" { + rnd = rand.Intn(len(arr.Nm1)) + } + for arr.Nm1[rnd] == arr.Nm7[rnd3] || arr.Nm7[rnd3] == "" { + rnd3 = rand.Intn(len(arr.Nm7)) + } + nMs := arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm7[rnd3] + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + } else { + rnd4 := rand.Intn(len(arr.Nm3)) + rnd5 := rand.Intn(len(arr.Nm4)) + for rnd2 < 3 && rnd5 < 3 { + rnd2 = rand.Intn(len(arr.Nm2)) + } + if nTp < 4 { + for arr.Nm3[rnd4] == arr.Nm1[rnd] || arr.Nm3[rnd4] == arr.Nm7[rnd3] { + rnd4 = rand.Intn(len(arr.Nm3)) + } + nMs := arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd4] + arr.Nm4[rnd5] + arr.Nm7[rnd3] + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + } else { + rnd6 := rand.Intn(len(arr.Nm5)) + rnd7 := rand.Intn(len(arr.Nm6)) + for arr.Nm3[rnd4] == arr.Nm5[rnd6] || arr.Nm5[rnd6] == arr.Nm7[rnd3] { + rnd6 = rand.Intn(len(arr.Nm5)) + } + nMs := arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd4] + arr.Nm4[rnd5] + arr.Nm5[rnd6] + arr.Nm6[rnd7] + arr.Nm7[rnd3] + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + } + } + } +} + +func GenerateGithyankiNames(arr *GithyankiArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + var n string + if gender == "female" { + n = GithyankiNameFem(arr, swearFilter) + } else { + n = GithyankiNameMas(arr, swearFilter) + } + names = append(names, n) + } + return names +} diff --git a/generators/githzerai.go b/generators/githzerai.go new file mode 100644 index 0000000..d5dabe4 --- /dev/null +++ b/generators/githzerai.go @@ -0,0 +1,74 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type GithzeraiArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` +} + +func LoadGithzeraiArrays(path string) (GithzeraiArrays, error) { + var arrays GithzeraiArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func GithzeraiNameFem(arr *GithzeraiArrays, swearFilter func(string) bool) string { + for { + rnd := rand.Intn(len(arr.Nm3)) + rnd2 := rand.Intn(len(arr.Nm4)) + charL := arr.Nm3[rnd][len(arr.Nm3[rnd])-1] + charF := arr.Nm4[rnd2][0] + for charL == charF { + rnd2 = rand.Intn(len(arr.Nm4)) + charF = arr.Nm4[rnd2][0] + } + nMs := arr.Nm3[rnd] + arr.Nm4[rnd2] + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + } +} + +func GithzeraiNameMas(arr *GithzeraiArrays, swearFilter func(string) bool) string { + for { + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + charL := arr.Nm1[rnd][len(arr.Nm1[rnd])-1] + charF := arr.Nm2[rnd2][0] + for charL == charF { + rnd2 = rand.Intn(len(arr.Nm2)) + charF = arr.Nm2[rnd2][0] + } + nMs := arr.Nm1[rnd] + arr.Nm2[rnd2] + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + } +} + +func GenerateGithzeraiNames(arr *GithzeraiArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + var n string + if gender == "female" { + n = GithzeraiNameFem(arr, swearFilter) + } else { + n = GithzeraiNameMas(arr, swearFilter) + } + names = append(names, n) + } + return names +} diff --git a/generators/gnome.go b/generators/gnome.go new file mode 100644 index 0000000..3d96469 --- /dev/null +++ b/generators/gnome.go @@ -0,0 +1,127 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type GnomeArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` + Nm11 []string `json:"nm11"` + Nm12 []string `json:"nm12"` + Nm13 []string `json:"nm13"` + Nm14 []string `json:"nm14"` +} + +func LoadGnomeArrays(path string) (GnomeArrays, error) { + var arrays GnomeArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func GnomeNameFem(arr *GnomeArrays, swearFilter func(string) bool) string { + rnd := rand.Intn(len(arr.Nm3)) + rnd2 := rand.Intn(len(arr.Nm4)) + return arr.Nm3[rnd] + arr.Nm4[rnd2] +} + +func GnomeNameMas(arr *GnomeArrays, swearFilter func(string) bool) string { + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + return arr.Nm1[rnd] + arr.Nm2[rnd2] +} + +func GnomeNameSur(arr *GnomeArrays, swearFilter func(string) bool) string { + nTp := rand.Intn(8) + if nTp < 2 { + rnd := rand.Intn(len(arr.Nm5)) + rnd2 := rand.Intn(len(arr.Nm10)) + rnd3 := rand.Intn(len(arr.Nm12)) + rnd4 := rand.Intn(len(arr.Nm5)) + rnd5 := rand.Intn(len(arr.Nm10)) + for arr.Nm5[rnd] == "" { + rnd = rand.Intn(len(arr.Nm5)) + } + for arr.Nm5[rnd4] == "" { + rnd4 = rand.Intn(len(arr.Nm5)) + } + return arr.Nm5[rnd] + arr.Nm10[rnd2] + arr.Nm12[rnd3] + "e" + arr.Nm5[rnd4] + arr.Nm10[rnd5] + arr.Nm12[rnd3] + "e" + } else { + rnd := rand.Intn(len(arr.Nm5)) + rnd2 := rand.Intn(len(arr.Nm6)) + rnd3 := rand.Intn(len(arr.Nm7)) + rnd4 := rand.Intn(len(arr.Nm8)) + rnd5 := rand.Intn(len(arr.Nm11)) + if nTp < 3 { + for arr.Nm7[rnd3] == arr.Nm5[rnd] || arr.Nm7[rnd3] == arr.Nm11[rnd5] { + rnd3 = rand.Intn(len(arr.Nm7)) + } + return arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm7[rnd3] + arr.Nm8[rnd4] + arr.Nm11[rnd5] + } else { + rnd6 := rand.Intn(len(arr.Nm9)) + rnd7 := rand.Intn(len(arr.Nm10)) + for arr.Nm7[rnd3] == arr.Nm9[rnd6] || arr.Nm9[rnd6] == arr.Nm11[rnd5] { + rnd6 = rand.Intn(len(arr.Nm9)) + } + if nTp < 5 { + return arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm7[rnd3] + arr.Nm8[rnd4] + arr.Nm9[rnd6] + arr.Nm10[rnd7] + arr.Nm11[rnd5] + } else { + rnd8 := rand.Intn(len(arr.Nm9)) + rnd9 := rand.Intn(len(arr.Nm10)) + for arr.Nm7[rnd3] == arr.Nm9[rnd8] || arr.Nm9[rnd6] == arr.Nm9[rnd8] { + rnd8 = rand.Intn(len(arr.Nm9)) + } + return arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm7[rnd3] + arr.Nm8[rnd4] + arr.Nm9[rnd6] + arr.Nm10[rnd7] + arr.Nm9[rnd8] + arr.Nm10[rnd9] + arr.Nm11[rnd5] + } + } + } +} + +func GenerateGnomeNames(arr *GnomeArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + var nMs, baseName string + if i < 5 { + rnd := rand.Intn(len(arr.Nm13)) + rnd2 := rand.Intn(len(arr.Nm14)) + for arr.Nm13[rnd] == arr.Nm14[rnd2] { + rnd2 = rand.Intn(len(arr.Nm14)) + } + baseName = arr.Nm13[rnd] + arr.Nm14[rnd2] + } else { + baseName = GnomeNameSur(arr, swearFilter) + for baseName == "" { + baseName = GnomeNameSur(arr, swearFilter) + } + } + if gender == "female" { + nMs = GnomeNameFem(arr, swearFilter) + for nMs == "" { + nMs = GnomeNameFem(arr, swearFilter) + } + } else { + nMs = GnomeNameMas(arr, swearFilter) + for nMs == "" { + nMs = GnomeNameMas(arr, swearFilter) + } + } + names = append(names, nMs+" "+baseName) + } + return names +} diff --git a/generators/goblin.go b/generators/goblin.go new file mode 100644 index 0000000..b35d0bd --- /dev/null +++ b/generators/goblin.go @@ -0,0 +1,143 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type GoblinArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` + Nm11 []string `json:"nm11"` + Nm12 []string `json:"nm12"` +} + +func LoadGoblinArrays(path string) (GoblinArrays, error) { + var arrays GoblinArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func GoblinNameMas(arr *GoblinArrays, swearFilter func(string) bool) string { + nTp := rand.Intn(3) + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + rnd5 := rand.Intn(len(arr.Nm4)) + if nTp == 0 { + for arr.Nm1[rnd] == "" { + rnd = rand.Intn(len(arr.Nm1)) + } + for arr.Nm4[rnd5] == "" { + rnd5 = rand.Intn(len(arr.Nm4)) + } + nMs := arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm4[rnd5] + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + } else { + rnd3 := rand.Intn(len(arr.Nm3)) + rnd4 := rand.Intn(len(arr.Nm2)) + for arr.Nm3[rnd3] == arr.Nm1[rnd] || arr.Nm3[rnd3] == arr.Nm4[rnd5] { + rnd3 = rand.Intn(len(arr.Nm3)) + } + nMs := arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm2[rnd4] + arr.Nm4[rnd5] + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + } + return "" +} + +func GoblinNameFem(arr *GoblinArrays, swearFilter func(string) bool) string { + nTp := rand.Intn(5) + rnd := rand.Intn(len(arr.Nm5)) + rnd2 := rand.Intn(len(arr.Nm6)) + rnd5 := rand.Intn(len(arr.Nm9)) + if nTp == 0 { + for arr.Nm5[rnd] == "" { + rnd = rand.Intn(len(arr.Nm5)) + } + for arr.Nm9[rnd5] == "" { + rnd5 = rand.Intn(len(arr.Nm9)) + } + nMs := arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm9[rnd5] + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + } else { + rnd3 := rand.Intn(len(arr.Nm7)) + rnd4 := rand.Intn(len(arr.Nm6)) + for arr.Nm7[rnd3] == arr.Nm5[rnd] || arr.Nm7[rnd3] == arr.Nm9[rnd5] { + rnd3 = rand.Intn(len(arr.Nm7)) + } + if nTp < 4 { + nMs := arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm7[rnd3] + arr.Nm6[rnd4] + arr.Nm9[rnd5] + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + } else { + rnd6 := rand.Intn(len(arr.Nm8)) + rnd7 := rand.Intn(len(arr.Nm6)) + for arr.Nm7[rnd3] == arr.Nm8[rnd6] || arr.Nm8[rnd6] == arr.Nm9[rnd5] { + rnd6 = rand.Intn(len(arr.Nm8)) + } + nMs := arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm7[rnd3] + arr.Nm6[rnd4] + arr.Nm8[rnd6] + arr.Nm6[rnd7] + arr.Nm9[rnd5] + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + } + } + return "" +} + +func GenerateGoblinNames(arr *GoblinArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + var nMs string + if i < 5 { + if gender == "female" { + nMs = GoblinNameFem(arr, swearFilter) + for nMs == "" { + nMs = GoblinNameFem(arr, swearFilter) + } + } else { + nMs = GoblinNameMas(arr, swearFilter) + for nMs == "" { + nMs = GoblinNameMas(arr, swearFilter) + } + } + } else { + nTp := rand.Intn(2) + if nTp == 0 { + rnd := rand.Intn(len(arr.Nm10)) + nMs = arr.Nm10[rnd] + } else { + rnd := rand.Intn(len(arr.Nm11)) + rnd2 := rand.Intn(len(arr.Nm12)) + if arr.Nm11[rnd][len(arr.Nm11[rnd])-1] == 'y' || arr.Nm11[rnd][len(arr.Nm11[rnd])-1] == 'e' { + for arr.Nm12[rnd2][0] == 'a' || arr.Nm12[rnd2][0] == 'e' { + rnd2 = rand.Intn(len(arr.Nm12)) + } + } + nMs = arr.Nm11[rnd] + arr.Nm12[rnd2] + } + } + names = append(names, nMs) + } + return names +} diff --git a/generators/goliath.go b/generators/goliath.go new file mode 100644 index 0000000..b2f6e3c --- /dev/null +++ b/generators/goliath.go @@ -0,0 +1,79 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type GoliathArrays struct { + NmFF []string `json:"nmFF"` + NmFL []string `json:"nmFL"` + NmMF []string `json:"nmMF"` + NmML []string `json:"nmML"` + NmMdF []string `json:"nmMdF"` + NmMdL []string `json:"nmMdL"` + NmSF []string `json:"nmSF"` + NmSL []string `json:"nmSL"` +} + +func LoadGoliathArrays(path string) (GoliathArrays, error) { + var arrays GoliathArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func GoliathNameFem(arr *GoliathArrays, swearFilter func(string) bool) string { + rnd := rand.Intn(len(arr.NmFF)) + rnd2 := rand.Intn(len(arr.NmFL)) + nMs := arr.NmFF[rnd] + arr.NmFL[rnd2] + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + return "" +} + +func GoliathNameMas(arr *GoliathArrays, swearFilter func(string) bool) string { + rnd := rand.Intn(len(arr.NmMF)) + rnd2 := rand.Intn(len(arr.NmML)) + nMs := arr.NmMF[rnd] + arr.NmML[rnd2] + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + return "" +} + +func GoliathNameSur(arr *GoliathArrays) string { + rnd := rand.Intn(len(arr.NmMdF)) + rnd2 := rand.Intn(len(arr.NmMdL)) + rnd3 := rand.Intn(len(arr.NmSF)) + rnd4 := rand.Intn(len(arr.NmSL)) + return arr.NmMdF[rnd] + arr.NmMdL[rnd2] + " " + arr.NmSF[rnd3] + arr.NmSL[rnd4] +} + +func GenerateGoliathNames(arr *GoliathArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + nSr := GoliathNameSur(arr) + var nMs string + if gender == "female" { + nMs = GoliathNameFem(arr, swearFilter) + for nMs == "" { + nMs = GoliathNameFem(arr, swearFilter) + } + } else { + nMs = GoliathNameMas(arr, swearFilter) + for nMs == "" { + nMs = GoliathNameMas(arr, swearFilter) + } + } + names = append(names, nMs+" "+nSr) + } + return names +} diff --git a/generators/grung.go b/generators/grung.go new file mode 100644 index 0000000..0453afe --- /dev/null +++ b/generators/grung.go @@ -0,0 +1,92 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "strings" +) + +type GrungArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` +} + +func LoadGrungArrays(path string) (GrungArrays, error) { + var arrays GrungArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func GrungName(arr *GrungArrays, swearFilter func(string) bool) string { + for { + nTp := rand.Intn(8) + rnd := rand.Intn(len(arr.Nm1)) + rnd3 := rand.Intn(len(arr.Nm3)) + rnd4 := rand.Intn(len(arr.Nm4)) + var nMs string + if nTp < 4 { + rnd2 := rand.Intn(len(arr.Nm2)) + for arr.Nm1[rnd] == arr.Nm2[rnd2] { + rnd2 = rand.Intn(len(arr.Nm2)) + } + nTmp := arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm4[rnd4] + nTmp = strings.Title(nTmp) + nMs = arr.Nm1[rnd] + "'" + nTmp + } else if nTp < 6 { + rnd2 := rand.Intn(len(arr.Nm1)) + nTmp := arr.Nm3[rnd3] + nTmp = strings.Title(nTmp) + nMs = arr.Nm1[rnd] + "'" + nTmp + arr.Nm4[rnd4] + "'" + arr.Nm1[rnd2] + "'" + nTmp + arr.Nm4[rnd4] + } else { + rnd2 := rand.Intn(len(arr.Nm2)) + rnd5 := rand.Intn(len(arr.Nm5)) + rnd6 := rand.Intn(len(arr.Nm6)) + rnd7 := rand.Intn(len(arr.Nm7)) + rnd8 := rand.Intn(len(arr.Nm8)) + rnd9 := rand.Intn(len(arr.Nm4)) + if nTp == 6 { + for rnd7 < 3 && rnd9 < 3 { + rnd9 = rand.Intn(len(arr.Nm4)) + } + nTmp := arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm4[rnd4] + "-" + arr.Nm5[rnd5] + arr.Nm6[rnd6] + arr.Nm7[rnd7] + arr.Nm8[rnd8] + arr.Nm4[rnd9] + nTmp = strings.Title(nTmp) + nMs = arr.Nm1[rnd] + "'" + nTmp + } else { + for rnd5 < 3 && rnd9 < 3 { + rnd9 = rand.Intn(len(arr.Nm4)) + } + for rnd5 < 3 && rnd4 < 3 { + rnd4 = rand.Intn(len(arr.Nm4)) + } + nTmp := arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm7[rnd7] + arr.Nm8[rnd8] + arr.Nm4[rnd9] + "'" + arr.Nm5[rnd5] + arr.Nm6[rnd6] + arr.Nm4[rnd4] + nTmp = strings.Title(nTmp) + nMs = arr.Nm1[rnd] + "'" + nTmp + } + } + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + } +} + +func GenerateGrungNames(arr *GrungArrays, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + n := GrungName(arr, swearFilter) + names = append(names, n) + } + return names +} diff --git a/generators/half_elf.go b/generators/half_elf.go new file mode 100644 index 0000000..bcfba0e --- /dev/null +++ b/generators/half_elf.go @@ -0,0 +1,66 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type HalfElfArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` +} + +func LoadHalfElfArrays(path string) (HalfElfArrays, error) { + var arrays HalfElfArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func HalfElfNameFem(arr *HalfElfArrays, swearFilter func(string) bool) string { + rnd := rand.Intn(len(arr.Nm3)) + rnd2 := rand.Intn(len(arr.Nm4)) + nMs := arr.Nm3[rnd] + arr.Nm4[rnd2] + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + return "" +} + +func HalfElfNameMas(arr *HalfElfArrays, swearFilter func(string) bool) string { + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + nMs := arr.Nm1[rnd] + arr.Nm2[rnd2] + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + return "" +} + +func GenerateHalfElfNames(arr *HalfElfArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + var nMs string + if gender == "female" { + nMs = HalfElfNameFem(arr, swearFilter) + for nMs == "" { + nMs = HalfElfNameFem(arr, swearFilter) + } + } else { + nMs = HalfElfNameMas(arr, swearFilter) + for nMs == "" { + nMs = HalfElfNameMas(arr, swearFilter) + } + } + names = append(names, nMs) + } + return names +} diff --git a/generators/half_orc.go b/generators/half_orc.go new file mode 100644 index 0000000..64c0809 --- /dev/null +++ b/generators/half_orc.go @@ -0,0 +1,70 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type HalfOrcArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` +} + +func LoadHalfOrcArrays(path string) (HalfOrcArrays, error) { + var arrays HalfOrcArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func HalfOrcNameFem(arr *HalfOrcArrays, swearFilter func(string) bool) string { + rnd := rand.Intn(len(arr.Nm4)) + rnd2 := rand.Intn(len(arr.Nm5)) + rnd3 := rand.Intn(len(arr.Nm6)) + nMs := arr.Nm4[rnd] + arr.Nm5[rnd2] + arr.Nm6[rnd3] + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + return "" +} + +func HalfOrcNameMas(arr *HalfOrcArrays, swearFilter func(string) bool) string { + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + rnd3 := rand.Intn(len(arr.Nm3)) + nMs := arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + return "" +} + +func GenerateHalfOrcNames(arr *HalfOrcArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + var nMs string + if gender == "female" { + nMs = HalfOrcNameFem(arr, swearFilter) + for nMs == "" { + nMs = HalfOrcNameFem(arr, swearFilter) + } + } else { + nMs = HalfOrcNameMas(arr, swearFilter) + for nMs == "" { + nMs = HalfOrcNameMas(arr, swearFilter) + } + } + names = append(names, nMs) + } + return names +} diff --git a/generators/halfling.go b/generators/halfling.go new file mode 100644 index 0000000..d1aed17 --- /dev/null +++ b/generators/halfling.go @@ -0,0 +1,77 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type HalflingArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm12 []string `json:"nm12"` + Nm13 []string `json:"nm13"` +} + +func LoadHalflingArrays(path string) (HalflingArrays, error) { + var arrays HalflingArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func HalflingNameFem(arr *HalflingArrays) string { + rnd := rand.Intn(len(arr.Nm3)) + rnd2 := rand.Intn(len(arr.Nm4)) + return arr.Nm3[rnd] + arr.Nm4[rnd2] +} + +func HalflingNameMas(arr *HalflingArrays, swearFilter func(string) bool) string { + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + nMs := arr.Nm1[rnd] + arr.Nm2[rnd2] + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + return "" +} + +func GenerateHalflingNames(arr *HalflingArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + nm12 := make([]string, len(arr.Nm12)) + nm13 := make([]string, len(arr.Nm13)) + copy(nm12, arr.Nm12) + copy(nm13, arr.Nm13) + for i := 0; i < 10; i++ { + var nMs string + if gender == "female" { + nMs = HalflingNameFem(arr) + for nMs == "" { + nMs = HalflingNameFem(arr) + } + } else { + nMs = HalflingNameMas(arr, swearFilter) + for nMs == "" { + nMs = HalflingNameMas(arr, swearFilter) + } + } + // Surname logic + rnd := rand.Intn(len(nm12)) + rnd2 := rand.Intn(len(nm13)) + for nm12[rnd] == nm13[rnd2] { + rnd2 = rand.Intn(len(nm13)) + } + surname := nm12[rnd] + nm13[rnd2] + nm12 = append(nm12[:rnd], nm12[rnd+1:]...) + nm13 = append(nm13[:rnd2], nm13[rnd2+1:]...) + names = append(names, nMs+" "+surname) + } + return names +} diff --git a/generators/harengon.go b/generators/harengon.go new file mode 100644 index 0000000..d250c97 --- /dev/null +++ b/generators/harengon.go @@ -0,0 +1,115 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type HarengonArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` +} + +func LoadHarengonArrays(path string) (HarengonArrays, error) { + var arrays HarengonArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func HarengonNameFemT(arr *HarengonArrays, swearFilter func(string) bool) string { + rnd := rand.Intn(len(arr.Nm3)) + rnd2 := rand.Intn(len(arr.Nm4)) + nMs := arr.Nm3[rnd] + arr.Nm4[rnd2] + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + return "" +} + +func HarengonNameMasT(arr *HarengonArrays, swearFilter func(string) bool) string { + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + nMs := arr.Nm1[rnd] + arr.Nm2[rnd2] + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + return "" +} + +func GenerateHarengonNames(arr *HarengonArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + var nMs string + if gender == "female" { + if i < 6 { + nMs = HarengonNameFem(arr, swearFilter) + for nMs == "" { + nMs = HarengonNameFem(arr, swearFilter) + } + } else { + nMs = HarengonNameFemT(arr, swearFilter) + for nMs == "" { + nMs = HarengonNameFemT(arr, swearFilter) + } + } + } else { + if i < 6 { + nMs = HarengonNameFem(arr, swearFilter) + for nMs == "" { + nMs = HarengonNameFem(arr, swearFilter) + } + } else { + nMs = HarengonNameMasT(arr, swearFilter) + for nMs == "" { + nMs = HarengonNameMasT(arr, swearFilter) + } + } + } + names = append(names, nMs) + } + return names +} + +func HarengonNameFem(arr *HarengonArrays, swearFilter func(string) bool) string { + nTp := rand.Intn(3) + rnd := rand.Intn(len(arr.Nm5)) + rnd2 := rand.Intn(len(arr.Nm6)) + rnd3 := rand.Intn(len(arr.Nm7)) + rnd4 := rand.Intn(len(arr.Nm8)) + rnd5 := rand.Intn(len(arr.Nm10)) + for arr.Nm7[rnd3] == arr.Nm5[rnd] && arr.Nm10[rnd5] != "" { + rnd3 = rand.Intn(len(arr.Nm7)) + } + var nMs string + if nTp < 2 { + nMs = arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm7[rnd3] + arr.Nm8[rnd4] + arr.Nm10[rnd5] + } else { + nTp = rand.Intn(2) + rnd6 := rand.Intn(len(arr.Nm8)) + rnd7 := rand.Intn(len(arr.Nm9)) + if nTp == 0 { + nMs = arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm7[rnd3] + arr.Nm8[rnd4] + arr.Nm9[rnd7] + arr.Nm8[rnd6] + arr.Nm10[rnd5] + } else { + nMs = arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm9[rnd7] + arr.Nm8[rnd6] + arr.Nm7[rnd3] + arr.Nm8[rnd4] + arr.Nm10[rnd5] + } + } + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + return "" +} diff --git a/generators/hobgoblin.go b/generators/hobgoblin.go new file mode 100644 index 0000000..07c27c5 --- /dev/null +++ b/generators/hobgoblin.go @@ -0,0 +1,80 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type HobgoblinArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` +} + +func LoadHobgoblinArrays(path string) (HobgoblinArrays, error) { + var arrays HobgoblinArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func HobgoblinName(arr *HobgoblinArrays, swearFilter func(string) bool) string { + nTp := rand.Intn(5) + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + rnd5 := rand.Intn(len(arr.Nm7)) + var nMs string + if nTp == 0 { + for arr.Nm1[rnd] == "" { + rnd = rand.Intn(len(arr.Nm1)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm7[rnd5] + } else { + rnd3 := rand.Intn(len(arr.Nm3)) + rnd4 := rand.Intn(len(arr.Nm6)) + for arr.Nm3[rnd3] == arr.Nm1[rnd] || arr.Nm3[rnd3] == arr.Nm7[rnd5] { + rnd3 = rand.Intn(len(arr.Nm3)) + } + if nTp < 4 { + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm6[rnd4] + arr.Nm7[rnd5] + } else { + rnd6 := rand.Intn(len(arr.Nm5)) + rnd7 := rand.Intn(len(arr.Nm4)) + for arr.Nm3[rnd3] == arr.Nm5[rnd6] || arr.Nm5[rnd6] == arr.Nm7[rnd5] { + rnd6 = rand.Intn(len(arr.Nm5)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm4[rnd7] + arr.Nm5[rnd6] + arr.Nm6[rnd4] + arr.Nm7[rnd5] + } + } + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + return "" +} + +func GenerateHobgoblinNames(arr *HobgoblinArrays, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + nMs := HobgoblinName(arr, swearFilter) + for nMs == "" { + nMs = HobgoblinName(arr, swearFilter) + } + if i > 4 { + rnd := rand.Intn(len(arr.Nm8)) + nMs = nMs + " " + arr.Nm8[rnd] + } + names = append(names, nMs) + } + return names +} diff --git a/generators/human.go b/generators/human.go new file mode 100644 index 0000000..e26ab51 --- /dev/null +++ b/generators/human.go @@ -0,0 +1,81 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type HumanArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` + Nm11 []string `json:"nm11"` + Nm12 []string `json:"nm12"` + Nm13 []string `json:"nm13"` + Nm14 []string `json:"nm14"` + Nm15 []string `json:"nm15"` + Nm16 []string `json:"nm16"` + Nm17 []string `json:"nm17"` + Nm18 []string `json:"nm18"` + Nm19 []string `json:"nm19"` + Nm20 []string `json:"nm20"` + Nm21 []string `json:"nm21"` + Nm22 []string `json:"nm22"` +} + +func LoadHumanArrays(path string) (HumanArrays, error) { + var arrays HumanArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +// Example: Generate a simple human name (Calashite male) +func HumanNameCalashiteMas(arr *HumanArrays, swearFilter func(string) bool) string { + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + rnd3 := rand.Intn(len(arr.Nm3)) + rnd4 := rand.Intn(len(arr.Nm4)) + rnd5 := rand.Intn(len(arr.Nm5)) + nMs := arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm4[rnd4] + arr.Nm5[rnd5] + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + return "" +} + +// Add more generators for other ethnicities and genders as needed + +func GenerateHumanNames(arr *HumanArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + var nMs string + if gender == "female" { + // Placeholder: implement female logic as needed + nMs = HumanNameCalashiteMas(arr, swearFilter) // Replace with actual female logic + for nMs == "" { + nMs = HumanNameCalashiteMas(arr, swearFilter) + } + } else { + nMs = HumanNameCalashiteMas(arr, swearFilter) + for nMs == "" { + nMs = HumanNameCalashiteMas(arr, swearFilter) + } + } + names = append(names, nMs) + } + return names +} diff --git a/generators/kalashtar.go b/generators/kalashtar.go new file mode 100644 index 0000000..463666a --- /dev/null +++ b/generators/kalashtar.go @@ -0,0 +1,71 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type KalashtarArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` + Nm11 []string `json:"nm11"` +} + +func LoadKalashtarArrays(path string) (KalashtarArrays, error) { + var arrays KalashtarArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func KalashtarNameMas(arr *KalashtarArrays, swearFilter func(string) bool) string { + nTp := rand.Intn(4) + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + var nMs string + if nTp < 2 { + if nTp == 0 { + nMs = arr.Nm1[rnd] + } else { + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + } + } else { + rnd3 := rand.Intn(len(arr.Nm3)) + rnd4 := rand.Intn(len(arr.Nm4)) + if nTp == 2 { + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + } else { + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm4[rnd4] + } + } + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + return "" +} + +func GenerateKalashtarNames(arr *KalashtarArrays, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + nMs := KalashtarNameMas(arr, swearFilter) + for nMs == "" { + nMs = KalashtarNameMas(arr, swearFilter) + } + names = append(names, nMs) + } + return names +} diff --git a/generators/kenku.go b/generators/kenku.go new file mode 100644 index 0000000..eb66797 --- /dev/null +++ b/generators/kenku.go @@ -0,0 +1,53 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type KenkuArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` +} + +func LoadKenkuArrays(path string) (KenkuArrays, error) { + var arrays KenkuArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func GenerateKenkuNames(arr *KenkuArrays) []string { + names := make([]string, 0, 10) + nm1 := make([]string, len(arr.Nm1)) + nm2 := make([]string, len(arr.Nm2)) + nm3 := make([]string, len(arr.Nm3)) + copy(nm1, arr.Nm1) + copy(nm2, arr.Nm2) + copy(nm3, arr.Nm3) + for i := 0; i < 10; i++ { + var name string + if i < 4 { + rnd := rand.Intn(len(nm1)) + name = nm1[rnd] + nm1 = append(nm1[:rnd], nm1[rnd+1:]...) + } else if i < 7 { + rnd := rand.Intn(len(nm2)) + name = nm2[rnd] + nm2 = append(nm2[:rnd], nm2[rnd+1:]...) + } else { + rnd := rand.Intn(len(nm3)) + name = nm3[rnd] + nm3 = append(nm3[:rnd], nm3[rnd+1:]...) + } + names = append(names, name) + } + return names +} diff --git a/generators/kobold.go b/generators/kobold.go new file mode 100644 index 0000000..ad3000e --- /dev/null +++ b/generators/kobold.go @@ -0,0 +1,70 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type KoboldArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` +} + +func LoadKoboldArrays(path string) (KoboldArrays, error) { + var arrays KoboldArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func KoboldNameMas(arr *KoboldArrays, i int, swearFilter func(string) bool) string { + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + rnd4 := rand.Intn(len(arr.Nm4)) + var nMs string + if i < 4 { + for rnd < 4 { + rnd = rand.Intn(len(arr.Nm1)) + } + for rnd4 < 5 || arr.Nm4[rnd4] == arr.Nm1[rnd] { + rnd4 = rand.Intn(len(arr.Nm4)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm4[rnd4] + } else { + rnd3 := rand.Intn(len(arr.Nm3)) + rnd5 := rand.Intn(len(arr.Nm2)) + if rnd < 4 { + for rnd4 < 5 { + rnd4 = rand.Intn(len(arr.Nm4)) + } + } + for arr.Nm3[rnd3] == arr.Nm1[rnd] || arr.Nm3[rnd3] == arr.Nm4[rnd4] { + rnd3 = rand.Intn(len(arr.Nm3)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm2[rnd5] + arr.Nm4[rnd2] + } + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + return "" +} + +func GenerateKoboldNames(arr *KoboldArrays, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + nMs := KoboldNameMas(arr, i, swearFilter) + for nMs == "" { + nMs = KoboldNameMas(arr, i, swearFilter) + } + names = append(names, nMs) + } + return names +} diff --git a/generators/leonin.go b/generators/leonin.go new file mode 100644 index 0000000..ed6e39a --- /dev/null +++ b/generators/leonin.go @@ -0,0 +1,140 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type LeoninArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` + Nm11 []string `json:"nm11"` + Nm12 []string `json:"nm12"` + Nm13 []string `json:"nm13"` + Nm14 []string `json:"nm14"` + Nm16 []string `json:"nm16"` + Nm17 []string `json:"nm17"` +} + +func LoadLeoninArrays(path string) (LeoninArrays, error) { + var arrays LeoninArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func LeoninNameFem(arr *LeoninArrays, swearFilter func(string) bool) string { + nTp := rand.Intn(7) + rnd := rand.Intn(len(arr.Nm8)) + rnd2 := rand.Intn(len(arr.Nm9)) + rnd3 := rand.Intn(len(arr.Nm10)) + rnd4 := rand.Intn(len(arr.Nm13)) + rnd5 := rand.Intn(len(arr.Nm14)) + var nMs string + if nTp < 3 { + for arr.Nm10[rnd3] == arr.Nm14[rnd5] || arr.Nm10[rnd3] == arr.Nm8[rnd] { + rnd3 = rand.Intn(len(arr.Nm10)) + } + nMs = arr.Nm8[rnd] + arr.Nm9[rnd2] + arr.Nm10[rnd3] + arr.Nm13[rnd4] + arr.Nm14[rnd5] + } else { + rnd6 := rand.Intn(len(arr.Nm11)) + rnd7 := rand.Intn(len(arr.Nm12)) + for arr.Nm14[rnd5] == arr.Nm12[rnd7] || arr.Nm12[rnd7] == arr.Nm10[rnd3] { + rnd7 = rand.Intn(len(arr.Nm12)) + } + if nTp < 6 { + nMs = arr.Nm8[rnd] + arr.Nm9[rnd2] + arr.Nm10[rnd3] + arr.Nm11[rnd6] + arr.Nm12[rnd7] + arr.Nm13[rnd4] + arr.Nm14[rnd5] + } else { + rnd8 := rand.Intn(len(arr.Nm11)) + rnd9 := rand.Intn(len(arr.Nm12)) + for arr.Nm14[rnd5] == arr.Nm12[rnd9] || arr.Nm12[rnd9] == arr.Nm12[rnd7] { + rnd9 = rand.Intn(len(arr.Nm12)) + } + nMs = arr.Nm8[rnd] + arr.Nm9[rnd2] + arr.Nm10[rnd3] + arr.Nm11[rnd6] + arr.Nm12[rnd7] + arr.Nm11[rnd8] + arr.Nm12[rnd9] + arr.Nm13[rnd4] + arr.Nm14[rnd5] + } + } + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + return "" +} + +func LeoninNameMas(arr *LeoninArrays, swearFilter func(string) bool) string { + nTp := rand.Intn(5) + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(3) + rnd5 := rand.Intn(len(arr.Nm7)) + var nMs string + if nTp == 0 { + for arr.Nm1[rnd] == "" { + rnd = rand.Intn(len(arr.Nm1)) + } + for arr.Nm7[rnd5] == "" { + rnd5 = rand.Intn(len(arr.Nm7)) + } + nMs = arr.Nm1[rnd] + arr.Nm6[rnd2] + arr.Nm7[rnd5] + } else { + if nTp < 4 { + rnd2 = rand.Intn(len(arr.Nm2)) + rnd3 := rand.Intn(len(arr.Nm3)) + rnd4 := rand.Intn(len(arr.Nm6)) + for arr.Nm3[rnd3] == arr.Nm7[rnd5] || arr.Nm3[rnd3] == arr.Nm1[rnd] { + rnd3 = rand.Intn(len(arr.Nm3)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm6[rnd4] + arr.Nm7[rnd5] + } else { + rnd3 := rand.Intn(len(arr.Nm3)) + rnd4 := rand.Intn(len(arr.Nm6)) + rnd6 := rand.Intn(len(arr.Nm4)) + rnd7 := rand.Intn(len(arr.Nm5)) + for arr.Nm3[rnd5] == arr.Nm5[rnd7] || arr.Nm5[rnd7] == arr.Nm7[rnd5] { + rnd7 = rand.Intn(len(arr.Nm5)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm4[rnd6] + arr.Nm5[rnd7] + arr.Nm6[rnd4] + arr.Nm7[rnd5] + } + } + if swearFilter == nil || !swearFilter(nMs) { + return nMs + } + return "" +} + +func GenerateLeoninNames(arr *LeoninArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + var nMs string + if gender == "female" { + nMs = LeoninNameFem(arr, swearFilter) + for nMs == "" { + nMs = LeoninNameFem(arr, swearFilter) + } + } else { + nMs = LeoninNameMas(arr, swearFilter) + for nMs == "" { + nMs = LeoninNameMas(arr, swearFilter) + } + } + rnd := rand.Intn(len(arr.Nm16)) + rnd2 := rand.Intn(len(arr.Nm17)) + for arr.Nm16[rnd] == arr.Nm17[rnd2] { + rnd2 = rand.Intn(len(arr.Nm17)) + } + nMs += " " + arr.Nm16[rnd] + arr.Nm17[rnd2] + names = append(names, nMs) + } + return names +} diff --git a/generators/lizardfolk.go b/generators/lizardfolk.go new file mode 100644 index 0000000..7fc6928 --- /dev/null +++ b/generators/lizardfolk.go @@ -0,0 +1,99 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type LizardfolkArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` +} + +func LoadLizardfolkArrays(path string) (LizardfolkArrays, error) { + var arrays LizardfolkArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func LizardfolkNameMas(arr *LizardfolkArrays, i int, swearFilter func(string) bool) string { + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + rnd3 := rand.Intn(len(arr.Nm6)) + var nMs string + if i < 2 { + if rnd < 5 { + for arr.Nm6[rnd3] == arr.Nm1[rnd] { + rnd3 = rand.Intn(len(arr.Nm6)) + } + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm6[rnd3] + } else { + rnd4 := rand.Intn(len(arr.Nm3)) + rnd5 := rand.Intn(len(arr.Nm4)) + for arr.Nm3[rnd4] == arr.Nm1[rnd] || arr.Nm3[rnd4] == arr.Nm6[rnd3] { + rnd4 = rand.Intn(len(arr.Nm3)) + } + if i < 7 { + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd4] + arr.Nm4[rnd5] + arr.Nm6[rnd3] + } else { + rnd6 := rand.Intn(len(arr.Nm2)) + rnd7 := rand.Intn(len(arr.Nm5)) + for arr.Nm5[rnd7] == arr.Nm3[rnd4] || arr.Nm5[rnd7] == arr.Nm6[rnd3] { + rnd7 = rand.Intn(len(arr.Nm5)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd4] + arr.Nm2[rnd6] + arr.Nm5[rnd7] + arr.Nm4[rnd5] + arr.Nm6[rnd3] + } + } + if swearFilter != nil && swearFilter(nMs) { + return "" + } + return nMs +} + +func LizardfolkNameWord(arr *LizardfolkArrays, used map[int]bool) string { + if len(used) >= len(arr.Nm7) { + return "" + } + for { + rnd := rand.Intn(len(arr.Nm7)) + if !used[rnd] { + used[rnd] = true + return arr.Nm7[rnd] + } + } +} + +func GenerateLizardfolkNames(arr *LizardfolkArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + if gender == "female" { + used := make(map[int]bool) + for i := 0; i < 10; i++ { + word := LizardfolkNameWord(arr, used) + if word != "" { + names = append(names, word) + } + } + } else { + for i := 0; i < 10; i++ { + n := LizardfolkNameMas(arr, i, swearFilter) + for n == "" { + n = LizardfolkNameMas(arr, i, swearFilter) + } + names = append(names, n) + } + } + return names +} diff --git a/generators/locathah.go b/generators/locathah.go new file mode 100644 index 0000000..7fd791e --- /dev/null +++ b/generators/locathah.go @@ -0,0 +1,55 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type LocathahArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` +} + +func LoadLocathahArrays(path string) (LocathahArrays, error) { + var arrays LocathahArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func LocathahNameMas(arr *LocathahArrays, swearFilter func(string) bool) string { + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + rnd3 := rand.Intn(len(arr.Nm3)) + rnd4 := rand.Intn(len(arr.Nm4)) + rnd5 := rand.Intn(len(arr.Nm5)) + for arr.Nm3[rnd3] == arr.Nm5[rnd5] || arr.Nm3[rnd3] == arr.Nm1[rnd] { + rnd3 = rand.Intn(len(arr.Nm3)) + } + nMs := arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm4[rnd4] + arr.Nm5[rnd5] + if swearFilter != nil && swearFilter(nMs) { + return "" + } + return nMs +} + +func GenerateLocathahNames(arr *LocathahArrays, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + n := LocathahNameMas(arr, swearFilter) + for n == "" { + n = LocathahNameMas(arr, swearFilter) + } + names = append(names, n) + } + return names +} diff --git a/generators/loxodon.go b/generators/loxodon.go new file mode 100644 index 0000000..1ea1b30 --- /dev/null +++ b/generators/loxodon.go @@ -0,0 +1,121 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type LoxodonArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` + Nm11 []string `json:"nm11"` + Nm12 []string `json:"nm12"` + Nm13 []string `json:"nm13"` +} + +func LoadLoxodonArrays(path string) (LoxodonArrays, error) { + var arrays LoxodonArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func LoxodonNameMas(arr *LoxodonArrays, swearFilter func(string) bool) string { + nTp := rand.Intn(5) + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + rnd5 := rand.Intn(len(arr.Nm6)) + var nMs string + if nTp == 0 { + for arr.Nm1[rnd] == "" { + rnd = rand.Intn(len(arr.Nm1)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm6[rnd5] + } else { + rnd3 := rand.Intn(len(arr.Nm3)) + rnd4 := rand.Intn(len(arr.Nm4)) + for arr.Nm3[rnd3] == arr.Nm1[rnd] || arr.Nm3[rnd3] == arr.Nm6[rnd5] { + rnd3 = rand.Intn(len(arr.Nm3)) + } + if rnd2 == 0 { + for rnd4 == 0 { + rnd4 = rand.Intn(len(arr.Nm4)) + } + } + if nTp < 4 { + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm4[rnd4] + arr.Nm6[rnd5] + } else { + rnd6 := rand.Intn(len(arr.Nm5)) + for arr.Nm3[rnd3] == arr.Nm5[rnd6] || arr.Nm5[rnd6] == arr.Nm6[rnd5] { + rnd6 = rand.Intn(len(arr.Nm5)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm4[rnd4] + arr.Nm5[rnd6] + "o" + arr.Nm6[rnd5] + } + } + if swearFilter != nil && swearFilter(nMs) { + return "" + } + return nMs +} + +func LoxodonNameFem(arr *LoxodonArrays, swearFilter func(string) bool) string { + nTp := rand.Intn(3) + rnd := rand.Intn(len(arr.Nm7)) + rnd2 := rand.Intn(len(arr.Nm8)) + rnd3 := rand.Intn(len(arr.Nm9)) + rnd4 := rand.Intn(len(arr.Nm12)) + rnd5 := rand.Intn(len(arr.Nm13)) + var nMs string + if nTp < 2 { + for arr.Nm7[rnd] == arr.Nm9[rnd3] || arr.Nm9[rnd3] == arr.Nm13[rnd5] { + rnd3 = rand.Intn(len(arr.Nm9)) + } + nMs = arr.Nm7[rnd] + arr.Nm8[rnd2] + arr.Nm9[rnd3] + arr.Nm12[rnd4] + arr.Nm13[rnd5] + } else { + rnd7 := rand.Intn(len(arr.Nm11)) + for arr.Nm11[rnd7] == arr.Nm9[rnd3] || arr.Nm11[rnd7] == arr.Nm13[rnd5] { + rnd7 = rand.Intn(len(arr.Nm11)) + } + nMs = arr.Nm7[rnd] + arr.Nm8[rnd2] + arr.Nm9[rnd3] + arr.Nm12[rnd4] + arr.Nm13[rnd5] + } + if swearFilter != nil && swearFilter(nMs) { + return "" + } + return nMs +} + +func GenerateLoxodonNames(arr *LoxodonArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + if gender == "female" { + for i := 0; i < 10; i++ { + n := LoxodonNameFem(arr, swearFilter) + for n == "" { + n = LoxodonNameFem(arr, swearFilter) + } + names = append(names, n) + } + } else { + for i := 0; i < 10; i++ { + n := LoxodonNameMas(arr, swearFilter) + for n == "" { + n = LoxodonNameMas(arr, swearFilter) + } + names = append(names, n) + } + } + return names +} diff --git a/generators/minotaur.go b/generators/minotaur.go new file mode 100644 index 0000000..040876a --- /dev/null +++ b/generators/minotaur.go @@ -0,0 +1,82 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type MinotaurArrays struct { + NmFF []string `json:"nmFF"` + NmFL []string `json:"nmFL"` + NmMF []string `json:"nmMF"` + NmML []string `json:"nmML"` + NmSF []string `json:"nmSF"` + NmSL []string `json:"nmSL"` +} + +func LoadMinotaurArrays(path string) (MinotaurArrays, error) { + var arrays MinotaurArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func MinotaurNameFem(arr *MinotaurArrays, swearFilter func(string) bool) string { + rnd := rand.Intn(len(arr.NmFF)) + rnd2 := rand.Intn(len(arr.NmFL)) + nMs := arr.NmFF[rnd] + arr.NmFL[rnd2] + if swearFilter != nil && swearFilter(nMs) { + return "" + } + return nMs +} + +func MinotaurNameMas(arr *MinotaurArrays, i int, swearFilter func(string) bool) string { + var nMs string + if i < 5 { + rnd := rand.Intn(len(arr.NmFF)) + rnd2 := rand.Intn(len(arr.NmFL)) + nMs = arr.NmFF[rnd] + arr.NmFL[rnd2] + } else { + rnd := rand.Intn(len(arr.NmMF)) + rnd2 := rand.Intn(len(arr.NmML)) + nMs = arr.NmMF[rnd] + arr.NmML[rnd2] + } + if swearFilter != nil && swearFilter(nMs) { + return "" + } + return nMs +} + +func MinotaurSurname(arr *MinotaurArrays) string { + rnd := rand.Intn(len(arr.NmSF)) + rnd2 := rand.Intn(len(arr.NmSL)) + return arr.NmSF[rnd] + arr.NmSL[rnd2] +} + +func GenerateMinotaurNames(arr *MinotaurArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + var nMs string + if gender == "female" { + nMs = MinotaurNameFem(arr, swearFilter) + for nMs == "" { + nMs = MinotaurNameFem(arr, swearFilter) + } + } else { + nMs = MinotaurNameMas(arr, i, swearFilter) + for nMs == "" { + nMs = MinotaurNameMas(arr, i, swearFilter) + } + } + nMs = nMs + " " + MinotaurSurname(arr) + names = append(names, nMs) + } + return names +} diff --git a/generators/modernenglish.go b/generators/modernenglish.go new file mode 100644 index 0000000..404dcbc --- /dev/null +++ b/generators/modernenglish.go @@ -0,0 +1,74 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type ModernEnglishArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` +} + +func LoadModernEnglishArrays(path string) (ModernEnglishArrays, error) { + var arr ModernEnglishArrays + f, err := os.Open(path) + if err != nil { + return arr, err + } + defer f.Close() + dec := json.NewDecoder(f) + if err := dec.Decode(&arr); err != nil { + return arr, err + } + return arr, nil +} + +// type: 0=male, 1=female, 2=unisex +func GenerateModernEnglishNames(arr *ModernEnglishArrays, swear func(string) bool, t int) []string { + var names []string + for i := 0; i < 10; i++ { + var name string + if t == 1 { + if i < 5 { + rnd := rand.Intn(len(arr.Nm2)) + rnd2 := rand.Intn(len(arr.Nm3)) + name = arr.Nm2[rnd] + " " + arr.Nm3[rnd2] + } else { + rnd := rand.Intn(len(arr.Nm5)) + rnd2 := rand.Intn(len(arr.Nm6)) + name = arr.Nm5[rnd] + " " + arr.Nm6[rnd2] + } + } else if t == 2 { + if i < 5 { + rnd := rand.Intn(len(arr.Nm7)) + rnd2 := rand.Intn(len(arr.Nm3)) + name = arr.Nm7[rnd] + " " + arr.Nm3[rnd2] + } else { + rnd := rand.Intn(len(arr.Nm7)) + rnd2 := rand.Intn(len(arr.Nm6)) + name = arr.Nm7[rnd] + " " + arr.Nm6[rnd2] + } + } else { + if i < 5 { + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm3)) + name = arr.Nm1[rnd] + " " + arr.Nm3[rnd2] + } else { + rnd := rand.Intn(len(arr.Nm4)) + rnd2 := rand.Intn(len(arr.Nm6)) + name = arr.Nm4[rnd] + " " + arr.Nm6[rnd2] + } + } + if !swear(name) { + names = append(names, name) + } + } + return names +} diff --git a/generators/modernportuguese.go b/generators/modernportuguese.go new file mode 100644 index 0000000..db5e986 --- /dev/null +++ b/generators/modernportuguese.go @@ -0,0 +1,75 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type ModernPortugueseEUArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` +} + +func LoadModernPortugueseEUArrays(path string) (ModernPortugueseEUArrays, error) { + var arr ModernPortugueseEUArrays + f, err := os.Open(path) + if err != nil { + return arr, err + } + defer f.Close() + dec := json.NewDecoder(f) + if err := dec.Decode(&arr); err != nil { + return arr, err + } + return arr, nil +} + +// type: 0=male, 1=female, 2=unisex +func GenerateModernPortugueseEUNames(arr *ModernPortugueseEUArrays, swear func(string) bool, t int) []string { + var names []string + for i := 0; i < 10; i++ { + var name string + switch t { + case 1: + if i < 5 { + rnd := rand.Intn(len(arr.Nm2)) + rnd2 := rand.Intn(len(arr.Nm3)) + name = arr.Nm2[rnd] + " " + arr.Nm3[rnd2] + } else { + rnd := rand.Intn(len(arr.Nm5)) + rnd2 := rand.Intn(len(arr.Nm6)) + name = arr.Nm5[rnd] + " " + arr.Nm6[rnd2] + } + case 2: + if i < 5 { + rnd := rand.Intn(len(arr.Nm7)) + rnd2 := rand.Intn(len(arr.Nm3)) + name = arr.Nm7[rnd] + " " + arr.Nm3[rnd2] + } else { + rnd := rand.Intn(len(arr.Nm7)) + rnd2 := rand.Intn(len(arr.Nm6)) + name = arr.Nm7[rnd] + " " + arr.Nm6[rnd2] + } + default: + if i < 5 { + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm3)) + name = arr.Nm1[rnd] + " " + arr.Nm3[rnd2] + } else { + rnd := rand.Intn(len(arr.Nm4)) + rnd2 := rand.Intn(len(arr.Nm6)) + name = arr.Nm4[rnd] + " " + arr.Nm6[rnd2] + } + } + if !swear(name) { + names = append(names, name) + } + } + return names +} diff --git a/generators/orc.go b/generators/orc.go new file mode 100644 index 0000000..b1a59e5 --- /dev/null +++ b/generators/orc.go @@ -0,0 +1,113 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type OrcArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` + Nm11 []string `json:"nm11"` +} + +func LoadOrcArrays(path string) (OrcArrays, error) { + var arrays OrcArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func OrcNameFem(arr *OrcArrays, i int, swearFilter func(string) bool) string { + rnd := rand.Intn(len(arr.Nm5)) + rnd2 := rand.Intn(len(arr.Nm6)) + rnd3 := rand.Intn(len(arr.Nm8)) + var nFm string + if i < 4 { + for rnd < 4 { + rnd = rand.Intn(len(arr.Nm5)) + } + for rnd3 < 5 || arr.Nm8[rnd3] == arr.Nm5[rnd] { + rnd3 = rand.Intn(len(arr.Nm8)) + } + nFm = arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm8[rnd3] + } else { + rnd4 := rand.Intn(len(arr.Nm7)) + rnd5 := rand.Intn(len(arr.Nm6)) + for arr.Nm7[rnd4] == arr.Nm8[rnd3] { + rnd4 = rand.Intn(len(arr.Nm7)) + } + nFm = arr.Nm5[rnd] + arr.Nm6[rnd2] + arr.Nm7[rnd4] + arr.Nm6[rnd5] + arr.Nm8[rnd3] + } + if swearFilter != nil && swearFilter(nFm) { + return "" + } + return nFm +} + +func OrcNameMas(arr *OrcArrays, i int, swearFilter func(string) bool) string { + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + rnd3 := rand.Intn(len(arr.Nm4)) + var nMs string + if i < 4 { + for rnd < 3 || arr.Nm1[rnd] == arr.Nm4[rnd3] { + rnd = rand.Intn(len(arr.Nm1)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm4[rnd3] + } else { + rnd4 := rand.Intn(len(arr.Nm3)) + rnd5 := rand.Intn(len(arr.Nm2)) + for arr.Nm3[rnd4] == arr.Nm1[rnd] || arr.Nm3[rnd4] == arr.Nm4[rnd3] { + rnd4 = rand.Intn(len(arr.Nm3)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd4] + arr.Nm2[rnd5] + arr.Nm4[rnd3] + } + if swearFilter != nil && swearFilter(nMs) { + return "" + } + return nMs +} + +func OrcSurname(arr *OrcArrays) string { + rSr := rand.Intn(2) + if rSr == 0 { + return "The " + arr.Nm9[rand.Intn(len(arr.Nm9))] + } + return arr.Nm10[rand.Intn(len(arr.Nm10))] + " " + arr.Nm11[rand.Intn(len(arr.Nm11))] +} + +func GenerateOrcNames(arr *OrcArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + var n string + if gender == "female" { + n = OrcNameFem(arr, i, swearFilter) + for n == "" { + n = OrcNameFem(arr, i, swearFilter) + } + } else { + n = OrcNameMas(arr, i, swearFilter) + for n == "" { + n = OrcNameMas(arr, i, swearFilter) + } + } + n = n + " " + OrcSurname(arr) + names = append(names, n) + } + return names +} diff --git a/generators/satyr.go b/generators/satyr.go new file mode 100644 index 0000000..9b9c587 --- /dev/null +++ b/generators/satyr.go @@ -0,0 +1,163 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type SatyrArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` + Nm11 []string `json:"nm11"` + Nm12 []string `json:"nm12"` + Nm13 []string `json:"nm13"` + Nm14 []string `json:"nm14"` + Nm15 []string `json:"nm15"` + Nm16 []string `json:"nm16"` + Nm17 []string `json:"nm17"` + Nm18 []string `json:"nm18"` +} + +func LoadSatyrArrays(path string) (SatyrArrays, error) { + var arrays SatyrArrays + file, err := os.Open(path) + if err != nil { + return arrays, err + } + defer file.Close() + decoder := json.NewDecoder(file) + err = decoder.Decode(&arrays) + return arrays, err +} + +func SatyrNameMas(arr *SatyrArrays, swearFilter func(string) bool) string { + nTp := rand.Intn(2) + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + rnd3 := rand.Intn(len(arr.Nm3)) + rnd4 := rand.Intn(len(arr.Nm6)) + rnd5 := rand.Intn(len(arr.Nm7)) + for rnd2 == 0 && rnd4 == 0 { + rnd2 = rand.Intn(len(arr.Nm2)) + } + var nMs string + if nTp == 0 { + for arr.Nm3[rnd3] == arr.Nm7[rnd5] && arr.Nm3[rnd3] == arr.Nm1[rnd] { + rnd3 = rand.Intn(len(arr.Nm3)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm6[rnd4] + arr.Nm7[rnd5] + } else { + rnd6 := rand.Intn(len(arr.Nm4)) + rnd7 := rand.Intn(len(arr.Nm5)) + for arr.Nm3[rnd5] == arr.Nm5[rnd3] && arr.Nm3[rnd5] == arr.Nm1[rnd] { + rnd5 = rand.Intn(len(arr.Nm3)) + } + for rnd6 == 0 && rnd4 == 0 { + rnd6 = rand.Intn(len(arr.Nm4)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm4[rnd6] + arr.Nm5[rnd7] + arr.Nm6[rnd4] + arr.Nm7[rnd5] + } + if swearFilter != nil && swearFilter(nMs) { + return "" + } + return nMs +} + +func SatyrNameFem(arr *SatyrArrays, swearFilter func(string) bool) string { + nTp := rand.Intn(8) + var nMs string + if nTp == 0 { + rnd := rand.Intn(9) + rnd2 := rand.Intn(3) + nMs = arr.Nm8[rnd] + arr.Nm13[rnd2] + } else { + rnd := rand.Intn(len(arr.Nm8)) + rnd2 := rand.Intn(len(arr.Nm9)) + rnd3 := rand.Intn(len(arr.Nm10)) + rnd4 := rand.Intn(len(arr.Nm13)) + if nTp < 3 { + for arr.Nm8[rnd] == arr.Nm10[rnd3] { + rnd3 = rand.Intn(len(arr.Nm10)) + } + for rnd2 < 3 { + rnd2 = rand.Intn(len(arr.Nm9)) + } + nMs = arr.Nm8[rnd] + arr.Nm9[rnd2] + arr.Nm10[rnd3] + arr.Nm13[rnd4] + } else { + rnd5 := rand.Intn(len(arr.Nm11)) + rnd6 := rand.Intn(len(arr.Nm12)) + for arr.Nm12[rnd6] == arr.Nm10[rnd3] && arr.Nm10[rnd3] == arr.Nm8[rnd] { + rnd3 = rand.Intn(len(arr.Nm10)) + } + for rnd2 < 3 && rnd4 < 3 { + rnd2 = rand.Intn(len(arr.Nm9)) + } + nMs = arr.Nm8[rnd] + arr.Nm9[rnd2] + arr.Nm10[rnd3] + arr.Nm11[rnd5] + arr.Nm12[rnd6] + arr.Nm13[rnd4] + } + } + if swearFilter != nil && swearFilter(nMs) { + return "" + } + return nMs +} + +func SatyrNameChild(arr *SatyrArrays) string { + nTp := rand.Intn(5) + var nMs string + if nTp == 0 { + rnd := rand.Intn(len(arr.Nm18)) + nMs = arr.Nm18[rnd] + } else if nTp < 3 { + rnd := rand.Intn(len(arr.Nm14)) + rnd2 := rand.Intn(len(arr.Nm15)) + for arr.Nm14[rnd] == arr.Nm15[rnd2] { + rnd2 = rand.Intn(len(arr.Nm15)) + } + nMs = arr.Nm14[rnd] + arr.Nm15[rnd2] + } else { + rnd := rand.Intn(len(arr.Nm16)) + rnd2 := rand.Intn(len(arr.Nm17)) + for arr.Nm16[rnd] == arr.Nm17[rnd2] { + rnd2 = rand.Intn(len(arr.Nm17)) + } + nMs = arr.Nm16[rnd] + arr.Nm17[rnd2] + } + return nMs +} + +func GenerateSatyrNames(arr *SatyrArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + switch gender { + case "child": + for i := 0; i < 10; i++ { + n := SatyrNameChild(arr) + names = append(names, n) + } + case "female": + for i := 0; i < 10; i++ { + n := SatyrNameFem(arr, swearFilter) + for n == "" { + n = SatyrNameFem(arr, swearFilter) + } + names = append(names, n) + } + default: + for i := 0; i < 10; i++ { + n := SatyrNameMas(arr, swearFilter) + for n == "" { + n = SatyrNameMas(arr, swearFilter) + } + names = append(names, n) + } + } + return names +} diff --git a/generators/shadar_kai.go b/generators/shadar_kai.go new file mode 100644 index 0000000..4aa2efb --- /dev/null +++ b/generators/shadar_kai.go @@ -0,0 +1,94 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "time" +) + +type ShadarKaiArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` + Nm11 []string `json:"nm11"` + Nm12 []string `json:"nm12"` + Nm13 []string `json:"nm13"` + Nm14 []string `json:"nm14"` +} + +func LoadShadarKaiArrays(path string) (ShadarKaiArrays, error) { + var arr ShadarKaiArrays + file, err := os.Open(path) + if err != nil { + return arr, err + } + defer file.Close() + decoder := json.NewDecoder(file) + if err := decoder.Decode(&arr); err != nil { + return arr, err + } + return arr, nil +} + +func GenerateShadarKaiName(arr ShadarKaiArrays, gender string) string { + rand.Seed(time.Now().UnixNano()) + if gender == "female" { + return shadarKaiFemale(arr) + } + return shadarKaiMale(arr) +} + +func shadarKaiFemale(a ShadarKaiArrays) string { + nTp := rand.Intn(7) + rnd := rand.Intn(len(a.Nm8)) + rnd2 := rand.Intn(len(a.Nm9)) + rnd3 := rand.Intn(len(a.Nm10)) + rnd4 := rand.Intn(len(a.Nm13)) + rnd5 := rand.Intn(len(a.Nm14)) + if nTp < 3 { + for a.Nm10[rnd3] == a.Nm14[rnd5] || a.Nm10[rnd3] == a.Nm8[rnd] { + rnd3 = rand.Intn(len(a.Nm10)) + } + return a.Nm8[rnd] + a.Nm9[rnd2] + a.Nm10[rnd3] + a.Nm13[rnd4] + a.Nm14[rnd5] + } else { + rnd6 := rand.Intn(len(a.Nm11)) + rnd7 := rand.Intn(len(a.Nm12)) + for a.Nm14[rnd5] == a.Nm12[rnd7] || a.Nm12[rnd7] == a.Nm10[rnd3] { + rnd7 = rand.Intn(len(a.Nm12)) + } + return a.Nm8[rnd] + a.Nm9[rnd2] + a.Nm10[rnd3] + a.Nm11[rnd6] + a.Nm12[rnd7] + a.Nm13[rnd4] + a.Nm14[rnd5] + } +} + +func shadarKaiMale(a ShadarKaiArrays) string { + nTp := rand.Intn(8) + rnd := rand.Intn(len(a.Nm1)) + rnd2 := rand.Intn(len(a.Nm2)) + rnd3 := rand.Intn(len(a.Nm3)) + rnd4 := rand.Intn(len(a.Nm6)) + rnd5 := rand.Intn(len(a.Nm7)) + if nTp < 7 { + for a.Nm3[rnd3] == a.Nm7[rnd5] && a.Nm3[rnd3] == a.Nm1[rnd] { + rnd3 = rand.Intn(len(a.Nm3)) + } + return a.Nm1[rnd] + a.Nm2[rnd2] + a.Nm3[rnd3] + a.Nm6[rnd4] + a.Nm7[rnd5] + } else { + rnd6 := rand.Intn(len(a.Nm4)) + rnd7 := rand.Intn(len(a.Nm5)) + for a.Nm3[rnd5] == a.Nm5[rnd3] && a.Nm3[rnd5] == a.Nm1[rnd] { + rnd5 = rand.Intn(len(a.Nm3)) + } + for rnd2 < 4 && rnd6 == 0 { + rnd2 = rand.Intn(len(a.Nm2)) + } + return a.Nm1[rnd] + a.Nm2[rnd2] + a.Nm3[rnd3] + a.Nm4[rnd6] + a.Nm5[rnd7] + a.Nm6[rnd4] + a.Nm7[rnd5] + } +} diff --git a/generators/shadar_kai_names.go b/generators/shadar_kai_names.go new file mode 100644 index 0000000..21001af --- /dev/null +++ b/generators/shadar_kai_names.go @@ -0,0 +1,23 @@ +package generators + +// GenerateShadarKaiNames returns 10 names for the given gender, filtering with CheckSwear +func GenerateShadarKaiNames(arr *ShadarKaiArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + var n string + if gender == "female" { + n = GenerateShadarKaiName(*arr, "female") + } else { + n = GenerateShadarKaiName(*arr, "male") + } + for n == "" || swearFilter(n) { + if gender == "female" { + n = GenerateShadarKaiName(*arr, "female") + } else { + n = GenerateShadarKaiName(*arr, "male") + } + } + names = append(names, n) + } + return names +} diff --git a/generators/shardmind.go b/generators/shardmind.go new file mode 100644 index 0000000..19f3699 --- /dev/null +++ b/generators/shardmind.go @@ -0,0 +1,46 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "time" +) + +type ShardmindArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` +} + +func LoadShardmindArrays(path string) (ShardmindArrays, error) { + var arr ShardmindArrays + file, err := os.Open(path) + if err != nil { + return arr, err + } + defer file.Close() + decoder := json.NewDecoder(file) + if err := decoder.Decode(&arr); err != nil { + return arr, err + } + return arr, nil +} + +func GenerateShardmindName(arr ShardmindArrays) string { + rand.Seed(time.Now().UnixNano()) + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + return arr.Nm1[rnd] + arr.Nm2[rnd2] +} + +func GenerateShardmindNames(arr *ShardmindArrays, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + n := GenerateShardmindName(*arr) + for n == "" || swearFilter(n) { + n = GenerateShardmindName(*arr) + } + names = append(names, n) + } + return names +} diff --git a/generators/shifter.go b/generators/shifter.go new file mode 100644 index 0000000..1fbd1db --- /dev/null +++ b/generators/shifter.go @@ -0,0 +1,59 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "time" +) + +type ShifterArrays struct { + Names1 []string `json:"names1"` + Names2 []string `json:"names2"` +} + +func LoadShifterArrays(path string) (ShifterArrays, error) { + var arr ShifterArrays + file, err := os.Open(path) + if err != nil { + return arr, err + } + defer file.Close() + decoder := json.NewDecoder(file) + if err := decoder.Decode(&arr); err != nil { + return arr, err + } + return arr, nil +} + +// gender: "male" or "female" +func GenerateShifterName(arr ShifterArrays, gender string) string { + rand.Seed(time.Now().UnixNano()) + if gender == "female" { + rnd := rand.Intn(len(arr.Names2)) + return arr.Names2[rnd] + } + rnd := rand.Intn(len(arr.Names1)) + return arr.Names1[rnd] +} + +func GenerateShifterNames(arr *ShifterArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + var n string + if gender == "female" { + n = GenerateShifterName(*arr, "female") + } else { + n = GenerateShifterName(*arr, "male") + } + for n == "" || swearFilter(n) { + if gender == "female" { + n = GenerateShifterName(*arr, "female") + } else { + n = GenerateShifterName(*arr, "male") + } + } + names = append(names, n) + } + return names +} diff --git a/generators/simic_hybrid.go b/generators/simic_hybrid.go new file mode 100644 index 0000000..bfcc38c --- /dev/null +++ b/generators/simic_hybrid.go @@ -0,0 +1,134 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "time" +) + +type SimicHybridArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` +} + +func LoadSimicHybridArrays(path string) (SimicHybridArrays, error) { + var arr SimicHybridArrays + file, err := os.Open(path) + if err != nil { + return arr, err + } + defer file.Close() + decoder := json.NewDecoder(file) + if err := decoder.Decode(&arr); err != nil { + return arr, err + } + return arr, nil +} + +func simicHybridNameMas(a SimicHybridArrays) (string, int) { + rand.Seed(time.Now().UnixNano()) + nTp := rand.Intn(4) + rnd := rand.Intn(len(a.Nm1)) + rnd2 := rand.Intn(len(a.Nm2)) + if nTp < 2 { + if nTp == 0 { + return a.Nm1[rnd], nTp + } else { + return a.Nm1[rnd] + a.Nm2[rnd2], nTp + } + } else { + rnd3 := rand.Intn(len(a.Nm3)) + rnd4 := rand.Intn(len(a.Nm4)) + if nTp == 2 { + return a.Nm1[rnd] + a.Nm2[rnd2] + a.Nm3[rnd3], nTp + } else { + return a.Nm1[rnd] + a.Nm2[rnd2] + a.Nm3[rnd3] + a.Nm4[rnd4], nTp + } + } +} + +func simicHybridNameFir(a SimicHybridArrays) string { + rand.Seed(time.Now().UnixNano()) + rnd := rand.Intn(len(a.Nm7)) + rnd2 := rand.Intn(len(a.Nm8)) + return a.Nm7[rnd] + a.Nm8[rnd2] +} + +func simicHybridNameSec(a SimicHybridArrays) string { + rand.Seed(time.Now().UnixNano()) + rnd := rand.Intn(len(a.Nm9)) + rnd2 := rand.Intn(len(a.Nm10)) + return a.Nm9[rnd] + a.Nm10[rnd2] +} + +func GenerateSimicHybridNames(arr *SimicHybridArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + var nMs string + if i < 5 { + var nTp int + nMs, nTp = simicHybridNameMas(*arr) + if gender == "female" { + rnd := rand.Intn(3) + if nTp == 0 || nTp == 3 { + nMs = nMs + arr.Nm6[rnd] + } else { + rnd += 3 + nMs = nMs + arr.Nm6[rnd] + } + } else { + if nTp == 0 || nTp == 3 { + nMs = nMs + arr.Nm5[0] + } else { + rnd := rand.Intn(5) + nMs = nMs + arr.Nm5[rnd+1] + } + } + } else { + if gender == "female" { + nMs = simicHybridNameSec(*arr) + } else { + nMs = simicHybridNameFir(*arr) + } + } + for nMs == "" || swearFilter(nMs) { + if i < 5 { + var nTp int + nMs, nTp = simicHybridNameMas(*arr) + if gender == "female" { + rnd := rand.Intn(3) + if nTp == 0 || nTp == 3 { + nMs = nMs + arr.Nm6[rnd] + } else { + rnd += 3 + nMs = nMs + arr.Nm6[rnd] + } + } else { + if nTp == 0 || nTp == 3 { + nMs = nMs + arr.Nm5[0] + } else { + rnd := rand.Intn(5) + nMs = nMs + arr.Nm5[rnd+1] + } + } + } else { + if gender == "female" { + nMs = simicHybridNameSec(*arr) + } else { + nMs = simicHybridNameFir(*arr) + } + } + } + names = append(names, nMs) + } + return names +} diff --git a/generators/tabaxi.go b/generators/tabaxi.go new file mode 100644 index 0000000..1ec40eb --- /dev/null +++ b/generators/tabaxi.go @@ -0,0 +1,96 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "time" +) + +type TabaxiArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` +} + +func LoadTabaxiArrays(path string) (TabaxiArrays, error) { + var arr TabaxiArrays + file, err := os.Open(path) + if err != nil { + return arr, err + } + defer file.Close() + decoder := json.NewDecoder(file) + if err := decoder.Decode(&arr); err != nil { + return arr, err + } + return arr, nil +} + +func GenerateTabaxiNames(arr *TabaxiArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + r := rand.New(rand.NewSource(time.Now().UnixNano())) + if gender == "female" { + for i := 0; i < 10; i++ { + rnd := r.Intn(len(arr.Nm4)) + rnd2 := r.Intn(len(arr.Nm5)) + name := "The " + arr.Nm4[rnd] + " " + arr.Nm5[rnd2] + " Clan" + for name == "" || swearFilter(name) { + rnd = r.Intn(len(arr.Nm4)) + rnd2 = r.Intn(len(arr.Nm5)) + name = "The " + arr.Nm4[rnd] + " " + arr.Nm5[rnd2] + " Clan" + } + names = append(names, name) + } + return names + } + // For main type, ensure unique draws for nm1, nm2, nm3 as in JS + nm1 := make([]string, len(arr.Nm1)) + copy(nm1, arr.Nm1) + nm2 := make([]string, len(arr.Nm2)) + copy(nm2, arr.Nm2) + nm3 := make([]string, len(arr.Nm3)) + copy(nm3, arr.Nm3) + for i := 0; i < 10; i++ { + var name string + if i < 5 { + rnd := r.Intn(len(nm1)) + name = nm1[rnd] + nm1 = append(nm1[:rnd], nm1[rnd+1:]...) + } else { + rnd := r.Intn(len(nm2)) + rnd2 := r.Intn(len(nm3)) + nTp := r.Intn(2) + if nTp == 0 { + name = nm2[rnd] + " " + nm3[rnd2] + " (" + nm2[rnd] + ")" + } else { + name = nm2[rnd] + " " + nm3[rnd2] + " (" + nm3[rnd2] + ")" + } + nm2 = append(nm2[:rnd], nm2[rnd+1:]...) + nm3 = append(nm3[:rnd2], nm3[rnd2+1:]...) + } + for name == "" || swearFilter(name) { + // repeat logic for unique draws + if i < 5 && len(nm1) > 0 { + rnd := r.Intn(len(nm1)) + name = nm1[rnd] + nm1 = append(nm1[:rnd], nm1[rnd+1:]...) + } else if len(nm2) > 0 && len(nm3) > 0 { + rnd := r.Intn(len(nm2)) + rnd2 := r.Intn(len(nm3)) + nTp := r.Intn(2) + if nTp == 0 { + name = nm2[rnd] + " " + nm3[rnd2] + " (" + nm2[rnd] + ")" + } else { + name = nm2[rnd] + " " + nm3[rnd2] + " (" + nm3[rnd2] + ")" + } + nm2 = append(nm2[:rnd], nm2[rnd+1:]...) + nm3 = append(nm3[:rnd2], nm3[rnd2+1:]...) + } + } + names = append(names, name) + } + return names +} diff --git a/generators/tiefling.go b/generators/tiefling.go new file mode 100644 index 0000000..303d641 --- /dev/null +++ b/generators/tiefling.go @@ -0,0 +1,74 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "time" +) + +type TieflingArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` +} + +func LoadTieflingArrays(path string) (TieflingArrays, error) { + var arr TieflingArrays + file, err := os.Open(path) + if err != nil { + return arr, err + } + defer file.Close() + decoder := json.NewDecoder(file) + if err := decoder.Decode(&arr); err != nil { + return arr, err + } + return arr, nil +} + +func GenerateTieflingName(arr *TieflingArrays, gender string) string { + rand.Seed(time.Now().UnixNano()) + switch gender { + case "female": + rnd := rand.Intn(len(arr.Nm4)) + rnd2 := rand.Intn(len(arr.Nm5)) + return arr.Nm4[rnd] + arr.Nm5[rnd2] + case "virtue": + rnd := rand.Intn(len(arr.Nm3)) + return arr.Nm3[rnd] + default: + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + return arr.Nm1[rnd] + arr.Nm2[rnd2] + } +} + +func GenerateTieflingNames(arr *TieflingArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + for i := 0; i < 10; i++ { + var n string + switch gender { + case "female": + n = GenerateTieflingName(arr, "female") + case "virtue": + n = GenerateTieflingName(arr, "virtue") + default: + n = GenerateTieflingName(arr, "male") + } + for n == "" || swearFilter(n) { + switch gender { + case "female": + n = GenerateTieflingName(arr, "female") + case "virtue": + n = GenerateTieflingName(arr, "virtue") + default: + n = GenerateTieflingName(arr, "male") + } + } + names = append(names, n) + } + return names +} diff --git a/generators/tortle.go b/generators/tortle.go new file mode 100644 index 0000000..9e4dc14 --- /dev/null +++ b/generators/tortle.go @@ -0,0 +1,70 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "time" +) + +type TortleArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` +} + +func LoadTortleArrays(path string) (TortleArrays, error) { + var arr TortleArrays + file, err := os.Open(path) + if err != nil { + return arr, err + } + defer file.Close() + decoder := json.NewDecoder(file) + if err := decoder.Decode(&arr); err != nil { + return arr, err + } + return arr, nil +} + +func GenerateTortleNames(arr *TortleArrays, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + r := rand.New(rand.NewSource(time.Now().UnixNano())) + for i := 0; i < 10; i++ { + var nMs string + nTp := r.Intn(3) + rnd := r.Intn(len(arr.Nm1)) + rnd2 := r.Intn(len(arr.Nm2)) + rnd3 := r.Intn(len(arr.Nm5)) + if nTp == 0 { + for arr.Nm1[rnd] == "" && arr.Nm5[rnd3] == "" { + rnd = r.Intn(len(arr.Nm1)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm5[rnd3] + } else { + rnd4 := r.Intn(len(arr.Nm4)) + rnd5 := r.Intn(len(arr.Nm3)) + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd5] + arr.Nm4[rnd4] + arr.Nm5[rnd3] + } + for nMs == "" || swearFilter(nMs) { + nTp = r.Intn(3) + rnd = r.Intn(len(arr.Nm1)) + rnd2 = r.Intn(len(arr.Nm2)) + rnd3 = r.Intn(len(arr.Nm5)) + if nTp == 0 { + for arr.Nm1[rnd] == "" && arr.Nm5[rnd3] == "" { + rnd = r.Intn(len(arr.Nm1)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm5[rnd3] + } else { + rnd4 := r.Intn(len(arr.Nm4)) + rnd5 := r.Intn(len(arr.Nm3)) + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd5] + arr.Nm4[rnd4] + arr.Nm5[rnd3] + } + } + names = append(names, nMs) + } + return names +} diff --git a/generators/triton.go b/generators/triton.go new file mode 100644 index 0000000..86aaa2a --- /dev/null +++ b/generators/triton.go @@ -0,0 +1,106 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "time" +) + +type TritonArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` + Nm11 []string `json:"nm11"` + Nm12 []string `json:"nm12"` + Nm13 []string `json:"nm13"` +} + +func LoadTritonArrays(path string) (TritonArrays, error) { + var arr TritonArrays + file, err := os.Open(path) + if err != nil { + return arr, err + } + defer file.Close() + decoder := json.NewDecoder(file) + if err := decoder.Decode(&arr); err != nil { + return arr, err + } + return arr, nil +} + +func tritonSurname(a TritonArrays, r *rand.Rand) string { + for { + rnd := r.Intn(len(a.Nm9)) + rnd2 := r.Intn(len(a.Nm10)) + rnd3 := r.Intn(len(a.Nm11)) + rnd4 := r.Intn(len(a.Nm12)) + rnd5 := r.Intn(len(a.Nm13)) + if a.Nm11[rnd3] != a.Nm9[rnd] && a.Nm11[rnd3] != a.Nm13[rnd5] { + return a.Nm9[rnd] + a.Nm10[rnd2] + a.Nm11[rnd3] + a.Nm12[rnd4] + a.Nm13[rnd5] + "ath" + } + } +} + +func tritonNameFem(a TritonArrays, r *rand.Rand, i int) string { + for { + rnd := r.Intn(len(a.Nm4)) + rnd2 := r.Intn(len(a.Nm5)) + rnd3 := r.Intn(len(a.Nm6)) + rnd4 := r.Intn(len(a.Nm8)) + if a.Nm6[rnd3] != a.Nm4[rnd] { + if i < 5 { + return a.Nm4[rnd] + a.Nm5[rnd2] + a.Nm6[rnd3] + a.Nm8[rnd4] + "n" + } else { + rnd5 := r.Intn(len(a.Nm5)) + rnd6 := r.Intn(len(a.Nm7)) + if a.Nm7[rnd6] != a.Nm6[rnd3] { + return a.Nm4[rnd] + a.Nm5[rnd2] + a.Nm6[rnd3] + a.Nm5[rnd5] + a.Nm7[rnd6] + a.Nm8[rnd4] + "n" + } + } + } + } +} + +func tritonNameMas(a TritonArrays, r *rand.Rand) string { + for { + rnd := r.Intn(len(a.Nm1)) + rnd2 := r.Intn(len(a.Nm2)) + rnd3 := r.Intn(len(a.Nm3)) + if a.Nm1[rnd] != a.Nm3[rnd3] { + return a.Nm1[rnd] + a.Nm2[rnd2] + a.Nm3[rnd3] + a.Nm2[rnd2] + "s" + } + } +} + +func GenerateTritonNames(arr *TritonArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + r := rand.New(rand.NewSource(time.Now().UnixNano())) + for i := 0; i < 10; i++ { + surname := tritonSurname(*arr, r) + var name string + if gender == "female" { + name = tritonNameFem(*arr, r, i) + " " + surname + } else { + name = tritonNameMas(*arr, r) + " " + surname + } + for name == "" || swearFilter(name) { + surname = tritonSurname(*arr, r) + if gender == "female" { + name = tritonNameFem(*arr, r, i) + " " + surname + } else { + name = tritonNameMas(*arr, r) + " " + surname + } + } + names = append(names, name) + } + return names +} diff --git a/generators/vedalken.go b/generators/vedalken.go new file mode 100644 index 0000000..c37ef33 --- /dev/null +++ b/generators/vedalken.go @@ -0,0 +1,108 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "time" +) + +type VedalkenArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` + Nm8 []string `json:"nm8"` + Nm9 []string `json:"nm9"` + Nm10 []string `json:"nm10"` + Nm11 []string `json:"nm11"` + Nm12 []string `json:"nm12"` +} + +func LoadVedalkenArrays(path string) (VedalkenArrays, error) { + var arr VedalkenArrays + file, err := os.Open(path) + if err != nil { + return arr, err + } + defer file.Close() + decoder := json.NewDecoder(file) + if err := decoder.Decode(&arr); err != nil { + return arr, err + } + return arr, nil +} + +func vedalkenNameMas(a VedalkenArrays, r *rand.Rand) string { + nTp := r.Intn(3) + rnd := r.Intn(len(a.Nm1)) + rnd2 := r.Intn(len(a.Nm2)) + rnd3 := r.Intn(len(a.Nm3)) + rnd4 := r.Intn(len(a.Nm2)) + rnd5 := r.Intn(len(a.Nm5)) + if nTp < 2 { + for a.Nm1[rnd] == a.Nm3[rnd3] || a.Nm3[rnd3] == a.Nm5[rnd5] { + rnd3 = r.Intn(len(a.Nm3)) + } + return a.Nm1[rnd] + a.Nm2[rnd2] + a.Nm3[rnd3] + a.Nm2[rnd4] + a.Nm5[rnd5] + } else { + rnd6 := r.Intn(len(a.Nm2)) + rnd7 := r.Intn(len(a.Nm4)) + for a.Nm4[rnd7] == a.Nm3[rnd3] || a.Nm4[rnd7] == a.Nm5[rnd5] { + rnd7 = r.Intn(len(a.Nm4)) + } + return a.Nm1[rnd] + a.Nm2[rnd2] + a.Nm3[rnd3] + a.Nm2[rnd4] + a.Nm4[rnd7] + a.Nm2[rnd6] + a.Nm5[rnd5] + } +} + +func vedalkenNameFem(a VedalkenArrays, r *rand.Rand) string { + nTp := r.Intn(3) + rnd := r.Intn(len(a.Nm6)) + rnd2 := r.Intn(len(a.Nm7)) + rnd3 := r.Intn(len(a.Nm8)) + rnd4 := r.Intn(len(a.Nm11)) + rnd5 := r.Intn(len(a.Nm12)) + if rnd2 < 4 { + for rnd4 < 3 { + rnd4 = r.Intn(len(a.Nm11)) + } + } + if nTp < 2 { + for a.Nm6[rnd] == a.Nm8[rnd3] || a.Nm8[rnd3] == a.Nm12[rnd5] { + rnd3 = r.Intn(len(a.Nm8)) + } + return a.Nm6[rnd] + a.Nm7[rnd2] + a.Nm8[rnd3] + a.Nm11[rnd4] + a.Nm12[rnd5] + } else { + rnd6 := r.Intn(len(a.Nm9)) + rnd7 := r.Intn(len(a.Nm10)) + for a.Nm10[rnd7] == a.Nm8[rnd3] || a.Nm10[rnd7] == a.Nm12[rnd5] { + rnd7 = r.Intn(len(a.Nm10)) + } + return a.Nm6[rnd] + a.Nm7[rnd2] + a.Nm8[rnd3] + a.Nm9[rnd6] + a.Nm10[rnd7] + a.Nm11[rnd4] + a.Nm12[rnd5] + } +} + +func GenerateVedalkenNames(arr *VedalkenArrays, gender string, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + r := rand.New(rand.NewSource(time.Now().UnixNano())) + for i := 0; i < 10; i++ { + var n string + if gender == "female" { + n = vedalkenNameFem(*arr, r) + } else { + n = vedalkenNameMas(*arr, r) + } + for n == "" || swearFilter(n) { + if gender == "female" { + n = vedalkenNameFem(*arr, r) + } else { + n = vedalkenNameMas(*arr, r) + } + } + names = append(names, n) + } + return names +} diff --git a/generators/verdan.go b/generators/verdan.go new file mode 100644 index 0000000..7ad5bff --- /dev/null +++ b/generators/verdan.go @@ -0,0 +1,96 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "time" +) + +type VerdanArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` + Nm7 []string `json:"nm7"` +} + +func LoadVerdanArrays(path string) (VerdanArrays, error) { + var arr VerdanArrays + file, err := os.Open(path) + if err != nil { + return arr, err + } + defer file.Close() + decoder := json.NewDecoder(file) + if err := decoder.Decode(&arr); err != nil { + return arr, err + } + return arr, nil +} + +func GenerateVerdanNames(arr *VerdanArrays, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + r := rand.New(rand.NewSource(time.Now().UnixNano())) + for i := 0; i < 10; i++ { + var nMs string + nTp := r.Intn(5) + rnd := r.Intn(len(arr.Nm1)) + rnd2 := r.Intn(len(arr.Nm2)) + rnd5 := r.Intn(len(arr.Nm7)) + if nTp < 2 { + for arr.Nm7[rnd5] == "" { + rnd5 = r.Intn(len(arr.Nm7)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm7[rnd5] + } else if nTp < 4 { + rnd3 := r.Intn(len(arr.Nm3)) + rnd4 := r.Intn(len(arr.Nm4)) + for arr.Nm3[rnd3] == arr.Nm7[rnd5] || arr.Nm3[rnd3] == arr.Nm1[rnd] { + rnd3 = r.Intn(len(arr.Nm3)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm4[rnd4] + arr.Nm7[rnd5] + } else { + rnd3 := r.Intn(len(arr.Nm3)) + rnd4 := r.Intn(len(arr.Nm4)) + rnd6 := r.Intn(len(arr.Nm6)) + rnd7 := r.Intn(len(arr.Nm5)) + for arr.Nm3[rnd5] == arr.Nm5[rnd7] || arr.Nm5[rnd7] == arr.Nm7[rnd5] { + rnd7 = r.Intn(len(arr.Nm5)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm4[rnd4] + arr.Nm5[rnd7] + arr.Nm6[rnd6] + arr.Nm7[rnd5] + } + for nMs == "" || swearFilter(nMs) { + nTp = r.Intn(5) + rnd = r.Intn(len(arr.Nm1)) + rnd2 = r.Intn(len(arr.Nm2)) + rnd5 = r.Intn(len(arr.Nm7)) + if nTp < 2 { + for arr.Nm7[rnd5] == "" { + rnd5 = r.Intn(len(arr.Nm7)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm7[rnd5] + } else if nTp < 4 { + rnd3 := r.Intn(len(arr.Nm3)) + rnd4 := r.Intn(len(arr.Nm4)) + for arr.Nm3[rnd3] == arr.Nm7[rnd5] || arr.Nm3[rnd3] == arr.Nm1[rnd] { + rnd3 = r.Intn(len(arr.Nm3)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm4[rnd4] + arr.Nm7[rnd5] + } else { + rnd3 := r.Intn(len(arr.Nm3)) + rnd4 := r.Intn(len(arr.Nm4)) + rnd6 := r.Intn(len(arr.Nm6)) + rnd7 := r.Intn(len(arr.Nm5)) + for arr.Nm3[rnd5] == arr.Nm5[rnd7] || arr.Nm5[rnd7] == arr.Nm7[rnd5] { + rnd7 = r.Intn(len(arr.Nm5)) + } + nMs = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm4[rnd4] + arr.Nm5[rnd7] + arr.Nm6[rnd6] + arr.Nm7[rnd5] + } + } + names = append(names, nMs) + } + return names +} diff --git a/generators/warforged.go b/generators/warforged.go new file mode 100644 index 0000000..4bc4783 --- /dev/null +++ b/generators/warforged.go @@ -0,0 +1,42 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" + "time" +) + +type WarforgedArrays struct { + Nm1 []string `json:"nm1"` +} + +func LoadWarforgedArrays(path string) (WarforgedArrays, error) { + var arr WarforgedArrays + file, err := os.Open(path) + if err != nil { + return arr, err + } + defer file.Close() + decoder := json.NewDecoder(file) + if err := decoder.Decode(&arr); err != nil { + return arr, err + } + return arr, nil +} + +func GenerateWarforgedNames(arr *WarforgedArrays, swearFilter func(string) bool) []string { + names := make([]string, 0, 10) + r := rand.New(rand.NewSource(time.Now().UnixNano())) + for i := 0; i < 10; i++ { + var n string + rnd := r.Intn(len(arr.Nm1)) + n = arr.Nm1[rnd] + for n == "" || swearFilter(n) { + rnd = r.Intn(len(arr.Nm1)) + n = arr.Nm1[rnd] + } + names = append(names, n) + } + return names +} diff --git a/generators/wilden.go b/generators/wilden.go new file mode 100644 index 0000000..c20af50 --- /dev/null +++ b/generators/wilden.go @@ -0,0 +1,57 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type WildenArrays struct { + NmMFf []string `json:"nmMFf"` + NmMFl []string `json:"nmMFl"` + NmMSf []string `json:"nmMSf"` + NmMSl []string `json:"nmMSl"` + NmFF []string `json:"nmFF"` + NmFL []string `json:"nmFL"` +} + +func LoadWildenArrays(path string) (WildenArrays, error) { + var arr WildenArrays + f, err := os.Open(path) + if err != nil { + return arr, err + } + defer f.Close() + dec := json.NewDecoder(f) + if err := dec.Decode(&arr); err != nil { + return arr, err + } + return arr, nil +} + +// type: "female" or "male" (default male) +func GenerateWildenNames(arr *WildenArrays, swear func(string) bool, gender string) []string { + var names []string + for i := 0; i < 10; i++ { + var name string + if gender == "female" { + rnd := rand.Intn(len(arr.NmFF)) + rnd2 := rand.Intn(len(arr.NmFL)) + name = arr.NmFF[rnd] + arr.NmFL[rnd2] + } else { + if i < 5 { + rnd := rand.Intn(len(arr.NmMFf)) + rnd2 := rand.Intn(len(arr.NmMFl)) + name = arr.NmMFf[rnd] + arr.NmMFl[rnd2] + } else { + rnd := rand.Intn(len(arr.NmMSf)) + rnd2 := rand.Intn(len(arr.NmMSl)) + name = arr.NmMSf[rnd] + arr.NmMSl[rnd2] + } + } + if !swear(name) { + names = append(names, name) + } + } + return names +} diff --git a/generators/yuanti.go b/generators/yuanti.go new file mode 100644 index 0000000..638ab4c --- /dev/null +++ b/generators/yuanti.go @@ -0,0 +1,59 @@ +package generators + +import ( + "encoding/json" + "math/rand" + "os" +) + +type YuanTiArrays struct { + Nm1 []string `json:"nm1"` + Nm2 []string `json:"nm2"` + Nm3 []string `json:"nm3"` + Nm4 []string `json:"nm4"` + Nm5 []string `json:"nm5"` + Nm6 []string `json:"nm6"` +} + +func LoadYuanTiArrays(path string) (YuanTiArrays, error) { + var arr YuanTiArrays + f, err := os.Open(path) + if err != nil { + return arr, err + } + defer f.Close() + dec := json.NewDecoder(f) + if err := dec.Decode(&arr); err != nil { + return arr, err + } + return arr, nil +} + +func GenerateYuanTiNames(arr *YuanTiArrays, swear func(string) bool) []string { + var names []string + for i := 0; i < 10; i++ { + var name string + rnd := rand.Intn(len(arr.Nm1)) + rnd2 := rand.Intn(len(arr.Nm2)) + rnd3 := rand.Intn(len(arr.Nm3)) + rnd4 := rand.Intn(len(arr.Nm5)) + rnd5 := rand.Intn(len(arr.Nm6)) + if i < 6 { + for arr.Nm1[rnd] == arr.Nm3[rnd3] || arr.Nm3[rnd3] == arr.Nm6[rnd5] { + rnd3 = rand.Intn(len(arr.Nm3)) + } + name = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm5[rnd4] + arr.Nm6[rnd5] + } else { + rnd6 := rand.Intn(len(arr.Nm4)) + rnd7 := rand.Intn(len(arr.Nm2)) + for arr.Nm3[rnd4] == arr.Nm4[rnd6] || arr.Nm4[rnd6] == arr.Nm6[rnd5] { + rnd6 = rand.Intn(len(arr.Nm4)) + } + name = arr.Nm1[rnd] + arr.Nm2[rnd2] + arr.Nm3[rnd3] + arr.Nm2[rnd7] + arr.Nm4[rnd6] + arr.Nm5[rnd4] + arr.Nm6[rnd5] + } + if !swear(name) { + names = append(names, name) + } + } + return names +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..a1fa7aa --- /dev/null +++ b/go.mod @@ -0,0 +1,14 @@ +module namegen + +go 1.23.0 + +toolchain go1.23.11 + +require ( + github.com/go-chi/chi/v5 v5.2.2 + golang.org/x/text v0.27.0 +) + +require github.com/go-chi/cors v1.2.2 + +require golang.org/x/time v0.12.0 diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..e79e170 --- /dev/null +++ b/go.sum @@ -0,0 +1,8 @@ +github.com/go-chi/chi/v5 v5.2.2 h1:CMwsvRVTbXVytCk1Wd72Zy1LAsAh9GxMmSNWLHCG618= +github.com/go-chi/chi/v5 v5.2.2/go.mod h1:L2yAIGWB3H+phAw1NxKwWM+7eUH/lU8pOMm5hHcoops= +github.com/go-chi/cors v1.2.2 h1:Jmey33TE+b+rB7fT8MUy1u0I4L+NARQlK6LhzKPSyQE= +github.com/go-chi/cors v1.2.2/go.mod h1:sSbTewc+6wYHBBCW7ytsFSn836hqM7JxpglAy2Vzc58= +golang.org/x/text v0.27.0 h1:4fGWRpyh641NLlecmyl4LOe6yDdfaYNrGb2zdfo4JV4= +golang.org/x/text v0.27.0/go.mod h1:1D28KMCvyooCX9hBiosv5Tz/+YLxj0j7XhWjpSUF7CU= +golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE= +golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg= diff --git a/handlers.go b/handlers.go new file mode 100644 index 0000000..7cfd1f0 --- /dev/null +++ b/handlers.go @@ -0,0 +1,1114 @@ +package main + +import ( + "encoding/json" + "log" + "math/rand" + "net/http" + "strconv" + "strings" + + "golang.org/x/text/cases" + "golang.org/x/text/language" + + "namegen/generators" +) + +var elfArrays *generators.ElfArrays +var dwarfArrays *generators.DwarfArrays +var arakocraArrays *generators.ArakocraArrays +var bugbearArrays *generators.BugbearArrays +var changelingArrays *generators.ChangelingArrays +var titleCaser = cases.Title(language.English) +var dragonbornArrays *generators.DragonbornArrays +var duergarArrays *generators.DuergarArrays +var eladrinArrays *generators.EladrinArrays +var fairyArrays *generators.FairyArrays +var genasiArrays *generators.GenasiArrays +var githyankiArrays *generators.GithyankiArrays +var githzeraiArrays *generators.GithzeraiArrays +var gnomeArrays *generators.GnomeArrays +var goblinArrays *generators.GoblinArrays +var goliathArrays *generators.GoliathArrays +var grungArrays *generators.GrungArrays +var halfElfArrays *generators.HalfElfArrays +var halfOrcArrays *generators.HalfOrcArrays +var halflingArrays *generators.HalflingArrays +var harengonArrays *generators.HarengonArrays +var leoninArrays *generators.LeoninArrays +var humanArrays *generators.HumanArrays +var koboldArrays *generators.KoboldArrays +var kenkuArrays *generators.KenkuArrays +var kalashtarArrays *generators.KalashtarArrays +var hobgoblinArrays *generators.HobgoblinArrays +var lizardfolkArrays *generators.LizardfolkArrays +var locathahArrays *generators.LocathahArrays +var loxodonArrays *generators.LoxodonArrays +var minotaurArrays *generators.MinotaurArrays +var orcArrays *generators.OrcArrays +var satyrArrays *generators.SatyrArrays +var shadarKaiArrays *generators.ShadarKaiArrays +var shardmindArrays *generators.ShardmindArrays +var shifterArrays *generators.ShifterArrays +var simicHybridArrays *generators.SimicHybridArrays +var tabaxiArrays *generators.TabaxiArrays +var tieflingArrays *generators.TieflingArrays +var tortleArrays *generators.TortleArrays +var tritonArrays *generators.TritonArrays +var vedalkenArrays *generators.VedalkenArrays +var verdanArrays *generators.VerdanArrays +var warforgedArrays *generators.WarforgedArrays +var wildenArrays *generators.WildenArrays +var yuantiArrays *generators.YuanTiArrays +var modernEnglishArrays *generators.ModernEnglishArrays +var modernPortugueseEUArrays *generators.ModernPortugueseEUArrays + +func init() { + var err error + elfArrays, err = generators.LoadElfArrays("data/elf.json") + if err != nil { + log.Fatalf("Failed to load elf arrays: %v", err) + } + dwarfArrays, err = generators.LoadDwarfArrays("data/dwarf.json") + if err != nil { + log.Fatalf("Failed to load dwarf arrays: %v", err) + } + arakocraArrays, err = generators.LoadArakocraArrays("data/arakocra.json") + if err != nil { + log.Fatalf("Failed to load arakocra arrays: %v", err) + } + bugbearArrays, err = generators.LoadBugbearArrays("data/bugbear.json") + if err != nil { + log.Fatalf("Failed to load bugbear arrays: %v", err) + } + changelingArrays, err = generators.LoadChangelingArrays("data/changeling.json") + if err != nil { + log.Fatalf("Failed to load changeling arrays: %v", err) + } + // Load Aasimar data + if err := generators.LoadAasimarData("data/aasimar.json"); err != nil { + log.Fatalf("Failed to load aasimar arrays: %v", err) + } + // Load Centaur data + if err := generators.LoadCentaurData("data/centaur.json"); err != nil { + log.Fatalf("Failed to load centaur arrays: %v", err) + } + // Load Deep Gnome data + if err := generators.LoadDeepGnomeData("data/deep_gnome.json"); err != nil { + log.Fatalf("Failed to load deep gnome arrays: %v", err) + } + // Load Deva data + if err := generators.LoadDevaData("data/deva.json"); err != nil { + log.Fatalf("Failed to load deva arrays: %v", err) + } + // Load Dragonborn data + dragonbornArrays, err = generators.LoadDragonbornArrays("data/dragonborn.json") + if err != nil { + log.Fatalf("Failed to load dragonborn arrays: %v", err) + } + // Load Drow data + if err := generators.LoadDrowData("data/drow.json"); err != nil { + log.Fatalf("Failed to load drow arrays: %v", err) + } + // Load Duergar data + duergarArrays, err = generators.LoadDuergarArrays("data/duergar.json") + if err != nil { + log.Fatalf("Failed to load duergar arrays: %v", err) + } + // Load Eladrin data + eladrinArrays, err = generators.LoadEladrinArrays("data/eladrin.json") + if err != nil { + log.Fatalf("Failed to load eladrin arrays: %v", err) + } + // Load Fairy data + fa, err := generators.LoadFairyArrays("data/fairy.json") + if err != nil { + log.Fatalf("Failed to load fairy arrays: %v", err) + } + fairyArrays = &fa + // Load Genasi data + ga, err := generators.LoadGenasiArrays("data/genasi.json") + if err != nil { + log.Fatalf("Failed to load genasi arrays: %v", err) + } + genasiArrays = &ga + // Load Githyanki data + gaGith, err := generators.LoadGithyankiArrays("data/githyanki.json") + if err != nil { + log.Fatalf("Failed to load githyanki arrays: %v", err) + } + githyankiArrays = &gaGith + // Load Githzerai data + gz, err := generators.LoadGithzeraiArrays("data/githzerai.json") + if err != nil { + log.Fatalf("Failed to load githzerai arrays: %v", err) + } + githzeraiArrays = &gz + // Load Gnome data + gn, err := generators.LoadGnomeArrays("data/gnome.json") + if err != nil { + log.Fatalf("Failed to load gnome arrays: %v", err) + } + gnomeArrays = &gn + // Load Goblin data + gb, err := generators.LoadGoblinArrays("data/goblin.json") + if err != nil { + log.Fatalf("Failed to load goblin arrays: %v", err) + } + goblinArrays = &gb + // Load Goliath data + gol, err := generators.LoadGoliathArrays("data/goliath.json") + if err != nil { + log.Fatalf("Failed to load goliath arrays: %v", err) + } + goliathArrays = &gol + // Load Grung data + gr, err := generators.LoadGrungArrays("data/grung.json") + if err != nil { + log.Fatalf("Failed to load grung arrays: %v", err) + } + grungArrays = &gr + // Load Half-Elf data + halfElf, err := generators.LoadHalfElfArrays("data/half-elf.json") + if err != nil { + log.Fatalf("Failed to load half-elf arrays: %v", err) + } + halfElfArrays = &halfElf + // Load Half-Orc data + halfOrc, err := generators.LoadHalfOrcArrays("data/half-orc.json") + if err != nil { + log.Fatalf("Failed to load half-orc arrays: %v", err) + } + halfOrcArrays = &halfOrc + // Load Halfling data + halfling, err := generators.LoadHalflingArrays("data/halfling.json") + if err != nil { + log.Fatalf("Failed to load halfling arrays: %v", err) + } + halflingArrays = &halfling + // Load Harengon data + harengon, err := generators.LoadHarengonArrays("data/harengon.json") + if err != nil { + log.Fatalf("Failed to load harengon arrays: %v", err) + } + harengonArrays = &harengon + // Load Leonin data + leonin, err := generators.LoadLeoninArrays("data/leonin.json") + if err != nil { + log.Fatalf("Failed to load leonin arrays: %v", err) + } + leoninArrays = &leonin + // Load Human data + human, err := generators.LoadHumanArrays("data/human.json") + if err != nil { + log.Fatalf("Failed to load human arrays: %v", err) + } + humanArrays = &human + // Load Kobold data + kobold, err := generators.LoadKoboldArrays("data/kobold.json") + if err != nil { + log.Fatalf("Failed to load kobold arrays: %v", err) + } + koboldArrays = &kobold + // Load Kenku data + kenku, err := generators.LoadKenkuArrays("data/kenku.json") + if err != nil { + log.Fatalf("Failed to load kenku arrays: %v", err) + } + kenkuArrays = &kenku + // Load Kalashtar data + kalashtar, err := generators.LoadKalashtarArrays("data/kalashtar.json") + if err != nil { + log.Fatalf("Failed to load kalashtar arrays: %v", err) + } + kalashtarArrays = &kalashtar + // Load Hobgoblin data + hobgoblin, err := generators.LoadHobgoblinArrays("data/hobgoblin.json") + if err != nil { + log.Fatalf("Failed to load hobgoblin arrays: %v", err) + } + hobgoblinArrays = &hobgoblin + // Load Lizardfolk data + lizardfolk, err := generators.LoadLizardfolkArrays("data/lizardfolk.json") + if err != nil { + log.Fatalf("Failed to load lizardfolk arrays: %v", err) + } + lizardfolkArrays = &lizardfolk + // Load Locathah data + locathah, err := generators.LoadLocathahArrays("data/locathah.json") + if err != nil { + log.Fatalf("Failed to load locathah arrays: %v", err) + } + locathahArrays = &locathah + // Load Loxodon data + loxodon, err := generators.LoadLoxodonArrays("data/loxodon.json") + if err != nil { + log.Fatalf("Failed to load loxodon arrays: %v", err) + } + loxodonArrays = &loxodon + // Load Minotaur data + minotaur, err := generators.LoadMinotaurArrays("data/minotaur.json") + if err != nil { + log.Fatalf("Failed to load minotaur arrays: %v", err) + } + minotaurArrays = &minotaur + // Load Orc data + orc, err := generators.LoadOrcArrays("data/orc.json") + if err != nil { + log.Fatalf("Failed to load orc arrays: %v", err) + } + orcArrays = &orc + // Load Satyr data + satyr, err := generators.LoadSatyrArrays("data/satyr.json") + if err != nil { + log.Fatalf("Failed to load satyr arrays: %v", err) + } + satyrArrays = &satyr + // Load Shadar-Kai data + shadarKai, err := generators.LoadShadarKaiArrays("data/shadar-kai.json") + if err != nil { + log.Fatalf("Failed to load shadar-kai arrays: %v", err) + } + shadarKaiArrays = &shadarKai + // Load Shardmind data + shardmind, err := generators.LoadShardmindArrays("data/shardmind.json") + if err != nil { + log.Fatalf("Failed to load shardmind arrays: %v", err) + } + shardmindArrays = &shardmind + // Load Shifter data + shifter, err := generators.LoadShifterArrays("data/shifter.json") + if err != nil { + log.Fatalf("Failed to load shifter arrays: %v", err) + } + shifterArrays = &shifter + // Load Simic Hybrid data + simicHybrid, err := generators.LoadSimicHybridArrays("data/simic_hybrid.json") + if err != nil { + log.Fatalf("Failed to load simic hybrid arrays: %v", err) + } + simicHybridArrays = &simicHybrid + // Load Tabaxi data + tabaxi, err := generators.LoadTabaxiArrays("data/tabaxi.json") + if err != nil { + log.Fatalf("Failed to load tabaxi arrays: %v", err) + } + tabaxiArrays = &tabaxi + // Load Tiefling data + tiefling, err := generators.LoadTieflingArrays("data/tiefling.json") + if err != nil { + log.Fatalf("Failed to load tiefling arrays: %v", err) + } + tieflingArrays = &tiefling + // Load Tortle data + tortle, err := generators.LoadTortleArrays("data/tortle.json") + if err != nil { + log.Fatalf("Failed to load tortle arrays: %v", err) + } + tortleArrays = &tortle + // Load Triton data + triton, err := generators.LoadTritonArrays("data/triton.json") + if err != nil { + log.Fatalf("Failed to load triton arrays: %v", err) + } + tritonArrays = &triton + // Load Vedalken data + vedalken, err := generators.LoadVedalkenArrays("data/vedalken.json") + if err != nil { + log.Fatalf("Failed to load vedalken arrays: %v", err) + } + vedalkenArrays = &vedalken + // Load Verdan data + verdan, err := generators.LoadVerdanArrays("data/verdan.json") + if err != nil { + log.Fatalf("Failed to load verdan arrays: %v", err) + } + verdanArrays = &verdan + // Load Warforged data + warforged, err := generators.LoadWarforgedArrays("data/warforged.json") + if err != nil { + log.Fatalf("Failed to load warforged arrays: %v", err) + } + warforgedArrays = &warforged + // Load Wilden data + wilden, err := generators.LoadWildenArrays("data/wilden.json") + if err != nil { + log.Fatalf("Failed to load wilden arrays: %v", err) + } + wildenArrays = &wilden + // Load Yuan-Ti data + yuanti, err := generators.LoadYuanTiArrays("data/yuan-ti.json") + if err != nil { + log.Fatalf("Failed to load yuan-ti arrays: %v", err) + } + yuantiArrays = &yuanti + // Load Modern English data + modernEnglish, err := generators.LoadModernEnglishArrays("data/modern-english.json") + if err != nil { + log.Fatalf("Failed to load modern english arrays: %v", err) + } + modernEnglishArrays = &modernEnglish + // Load Modern Portuguese (EU) data + modernPortugueseEU, err := generators.LoadModernPortugueseEUArrays("data/modern-portuguese.json") + if err != nil { + log.Fatalf("Failed to load modern portuguese (EU) arrays: %v", err) + } + modernPortugueseEUArrays = &modernPortugueseEU +} + +// gender: male, female, child, or 0/1/2 +func parseGender(param string) int { + switch strings.ToLower(param) { + case "male", "0": + return 0 + case "female", "1": + return 1 + case "child", "2": + return 2 + default: + if g, err := strconv.Atoi(param); err == nil { + return g + } + } + return 0 +} + +func getGender(r *http.Request) string { + genderParam := r.URL.Query().Get("gender") + if strings.ToLower(genderParam) == "female" || parseGender(genderParam) == 1 { + return "female" + } + return "male" +} + +// gender: 0=male, 1=female, 2=child (if supported) +func ElfNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + var names []string + for i := 0; i < 10; i++ { + var nMs, baseName string + if gender == "child" || parseGender(r.URL.Query().Get("gender")) == 2 { + nMs = generators.ElfNameChild(elfArrays, CheckSwear) + for nMs == "" { + nMs = generators.ElfNameChild(elfArrays, CheckSwear) + } + } else { + if i < 5 { + rnd := rand.Intn(len(elfArrays.Nm12)) + rnd2 := rand.Intn(len(elfArrays.Nm13)) + for elfArrays.Nm12[rnd] == elfArrays.Nm13[rnd2] { + rnd2 = rand.Intn(len(elfArrays.Nm13)) + } + nMs = elfArrays.Nm12[rnd] + elfArrays.Nm13[rnd2] + } else { + nMs = generators.ElfNameSur(elfArrays, CheckSwear) + for nMs == "" { + nMs = generators.ElfNameSur(elfArrays, CheckSwear) + } + } + baseName = nMs + if gender == "female" { + nMs = generators.ElfNameFem(elfArrays, CheckSwear) + for nMs == "" { + nMs = generators.ElfNameFem(elfArrays, CheckSwear) + } + } else { + nMs = generators.ElfNameMas(elfArrays, CheckSwear) + for nMs == "" { + nMs = generators.ElfNameMas(elfArrays, CheckSwear) + } + } + nMs = nMs + " " + baseName + } + names = append(names, titleCaser.String(nMs)) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +func DwarfNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + var names []string + for i := 0; i < 10; i++ { + var nMs, baseName string + if i < 5 { + rnd := rand.Intn(len(dwarfArrays.Nm12)) + rnd2 := rand.Intn(len(dwarfArrays.Nm13)) + for dwarfArrays.Nm12[rnd] == dwarfArrays.Nm13[rnd2] { + rnd2 = rand.Intn(len(dwarfArrays.Nm13)) + } + nMs = dwarfArrays.Nm12[rnd] + dwarfArrays.Nm13[rnd2] + } else { + nMs = generators.DwarfNameSur(dwarfArrays, CheckSwear) + for nMs == "" { + nMs = generators.DwarfNameSur(dwarfArrays, CheckSwear) + } + } + baseName = nMs + if gender == "female" { + nMs = generators.DwarfNameFem(dwarfArrays, CheckSwear) + for nMs == "" { + nMs = generators.DwarfNameFem(dwarfArrays, CheckSwear) + } + } else { + nMs = generators.DwarfNameMas(dwarfArrays, CheckSwear) + for nMs == "" { + nMs = generators.DwarfNameMas(dwarfArrays, CheckSwear) + } + } + nMs = nMs + " " + baseName + names = append(names, titleCaser.String(nMs)) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +func ArakocraNamesHandler(w http.ResponseWriter, r *http.Request) { + var names []string + for i := 0; i < 10; i++ { + nMs := generators.ArakocraNameMas(arakocraArrays, CheckSwear, i) + for nMs == "" { + nMs = generators.ArakocraNameMas(arakocraArrays, CheckSwear, i) + } + names = append(names, titleCaser.String(nMs)) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /aasimar-names?gender=male|female|0|1 +func AasimarNamesHandler(w http.ResponseWriter, r *http.Request) { + genderParam := r.URL.Query().Get("gender") + gender := "male" + if parseGender(genderParam) == 1 { + gender = "female" + } + var names []string + for i := 0; i < 10; i++ { + nMs := generators.GenerateAasimarName(gender) + for nMs == "" { + nMs = generators.GenerateAasimarName(gender) + } + if CheckSwear(nMs) { + nMs = generators.GenerateAasimarName(gender) + } + names = append(names, titleCaser.String(nMs)) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +func BugbearNamesHandler(w http.ResponseWriter, r *http.Request) { + var names []string + for i := 0; i < 10; i++ { + nMs := generators.BugbearNameMas(bugbearArrays, CheckSwear) + for nMs == "" { + nMs = generators.BugbearNameMas(bugbearArrays, CheckSwear) + } + names = append(names, titleCaser.String(nMs)) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /centaur-names?gender=male|female|0|1 +func CentaurNamesHandler(w http.ResponseWriter, r *http.Request) { + genderParam := r.URL.Query().Get("gender") + gender := "male" + if parseGender(genderParam) == 1 { + gender = "female" + } + var names []string + for i := 0; i < 10; i++ { + nMs := generators.GenerateCentaurName(gender) + for nMs == "" { + nMs = generators.GenerateCentaurName(gender) + } + if CheckSwear(nMs) { + nMs = generators.GenerateCentaurName(gender) + } + names = append(names, titleCaser.String(nMs)) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +func ChangelingNamesHandler(w http.ResponseWriter, r *http.Request) { + var names []string + for i := 0; i < 10; i++ { + nMs := generators.ChangelingNameMas(changelingArrays, CheckSwear) + for nMs == "" { + nMs = generators.ChangelingNameMas(changelingArrays, CheckSwear) + } + names = append(names, titleCaser.String(nMs)) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /deep-gnome-names?gender=male|female|0|1 +func DeepGnomeNamesHandler(w http.ResponseWriter, r *http.Request) { + genderParam := r.URL.Query().Get("gender") + gender := "male" + if parseGender(genderParam) == 1 { + gender = "female" + } + var names []string + for i := 0; i < 10; i++ { + nMs := generators.GenerateDeepGnomeName(gender) + for nMs == "" { + nMs = generators.GenerateDeepGnomeName(gender) + } + if CheckSwear(nMs) { + nMs = generators.GenerateDeepGnomeName(gender) + } + names = append(names, titleCaser.String(nMs)) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /deva-names?gender=male|female|0|1 +func DevaNamesHandler(w http.ResponseWriter, r *http.Request) { + genderParam := r.URL.Query().Get("gender") + gender := "male" + if parseGender(genderParam) == 1 { + gender = "female" + } + var names []string + for i := 0; i < 10; i++ { + nMs := generators.GenerateDevaName(gender) + for nMs == "" { + nMs = generators.GenerateDevaName(gender) + } + if CheckSwear(nMs) { + nMs = generators.GenerateDevaName(gender) + } + names = append(names, titleCaser.String(nMs)) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /dragonborn-names?gender=male|female|surname|0|1|2 +func DragonbornNamesHandler(w http.ResponseWriter, r *http.Request) { + genderParam := r.URL.Query().Get("gender") + gender := "male" + if parseGender(genderParam) == 1 { + gender = "female" + } else if strings.ToLower(genderParam) == "surname" || parseGender(genderParam) == 2 { + gender = "surname" + } + var names []string + for i := 0; i < 10; i++ { + var nMs string + switch gender { + case "female": + nMs = generators.DragonbornNameFem(dragonbornArrays, CheckSwear) + for nMs == "" { + nMs = generators.DragonbornNameFem(dragonbornArrays, CheckSwear) + } + case "surname": + nMs = generators.DragonbornNameSur(dragonbornArrays, CheckSwear) + for nMs == "" { + nMs = generators.DragonbornNameSur(dragonbornArrays, CheckSwear) + } + default: + nMs = generators.DragonbornNameMas(dragonbornArrays, CheckSwear) + for nMs == "" { + nMs = generators.DragonbornNameMas(dragonbornArrays, CheckSwear) + } + } + names = append(names, titleCaser.String(nMs)) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /drow-names?gender=male|female|surname|0|1|2&surname=true +func DrowNamesHandler(w http.ResponseWriter, r *http.Request) { + genderParam := r.URL.Query().Get("gender") + gender := genderParam + if gender == "" { + gender = "male" + } + var names []string + for i := 0; i < 10; i++ { + first := generators.DrowName(gender, "false") + surname := generators.DrowSurname() + fullName := titleCaser.String(first + " " + surname) + for CheckSwear(fullName) { + first = generators.DrowName(gender, "false") + surname = generators.DrowSurname() + fullName = titleCaser.String(first + " " + surname) + } + names = append(names, fullName) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +func DuergarNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + var names []string + for i := 0; i < 10; i++ { + fullName := generators.DuergarNameFull(duergarArrays, gender, CheckSwear) + for fullName == "" { + fullName = generators.DuergarNameFull(duergarArrays, gender, CheckSwear) + } + names = append(names, titleCaser.String(fullName)) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +func EladrinNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + var names []string + for i := 0; i < 10; i++ { + var nMs string + if gender == "female" { + nMs = generators.EladrinNameFem(eladrinArrays, CheckSwear) + for nMs == "" { + nMs = generators.EladrinNameFem(eladrinArrays, CheckSwear) + } + } else { + nMs = generators.EladrinNameMas(eladrinArrays, CheckSwear) + for nMs == "" { + nMs = generators.EladrinNameMas(eladrinArrays, CheckSwear) + } + } + names = append(names, titleCaser.String(nMs)) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +func FairyNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateFairyNames(*fairyArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +func GenasiNamesHandler(w http.ResponseWriter, r *http.Request) { + names := generators.GenerateGenasiNames(*genasiArrays, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +func GithyankiNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateGithyankiNames(githyankiArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +func GithzeraiNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateGithzeraiNames(githzeraiArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +func GnomeNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateGnomeNames(gnomeArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +func GoblinNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateGoblinNames(goblinArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +func GoliathNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateGoliathNames(goliathArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +func GrungNamesHandler(w http.ResponseWriter, r *http.Request) { + names := generators.GenerateGrungNames(grungArrays, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /half-elf-names?gender=male|female|0|1 +func HalfElfNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateHalfElfNames(halfElfArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /half-orc-names?gender=male|female|0|1 +func HalfOrcNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateHalfOrcNames(halfOrcArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /halfling-names?gender=male|female|0|1 +func HalflingNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateHalflingNames(halflingArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /harengon-names?gender=male|female|0|1 +func HarengonNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateHarengonNames(harengonArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /hobgoblin-names +func HobgoblinNamesHandler(w http.ResponseWriter, r *http.Request) { + names := generators.GenerateHobgoblinNames(hobgoblinArrays, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /human-names?gender=male|female|0|1 +func HumanNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateHumanNames(humanArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /kalashtar-names?gender=male|female|0|1 +func KalashtarNamesHandler(w http.ResponseWriter, r *http.Request) { + names := generators.GenerateKalashtarNames(kalashtarArrays, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /kenku-names +func KenkuNamesHandler(w http.ResponseWriter, r *http.Request) { + names := generators.GenerateKenkuNames(kenkuArrays) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /kobold-names +func KoboldNamesHandler(w http.ResponseWriter, r *http.Request) { + names := generators.GenerateKoboldNames(koboldArrays, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /leonin-names?gender=male|female|0|1 +func LeoninNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateLeoninNames(leoninArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /lizardfolk-names?gender=male|female|0|1 +func LizardfolkNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateLizardfolkNames(lizardfolkArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /locathah-names +func LocathahNamesHandler(w http.ResponseWriter, r *http.Request) { + names := generators.GenerateLocathahNames(locathahArrays, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /loxodon-names?gender=male|female|0|1 +func LoxodonNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateLoxodonNames(loxodonArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /minotaur-names?gender=male|female|0|1 +func MinotaurNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateMinotaurNames(minotaurArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /orc-names?gender=male|female|0|1 +func OrcNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateOrcNames(orcArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /satyr-names?gender=male|female|child|0|1|2 +func SatyrNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateSatyrNames(satyrArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /shadar-kai-names?gender=male|female|0|1 +func ShadarKaiNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateShadarKaiNames(shadarKaiArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /shardmind-names +func ShardmindNamesHandler(w http.ResponseWriter, r *http.Request) { + names := generators.GenerateShardmindNames(shardmindArrays, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /shifter-names?gender=male|female|0|1 +func ShifterNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateShifterNames(shifterArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /simic-hybrid-names?gender=male|female|0|1 +func SimicHybridNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateSimicHybridNames(simicHybridArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /tabaxi-names?gender=male|female|0|1 +func TabaxiNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateTabaxiNames(tabaxiArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /tiefling-names?gender=male|female|virtue|0|1|2 +func TieflingNamesHandler(w http.ResponseWriter, r *http.Request) { + genderParam := r.URL.Query().Get("gender") + gender := "male" + if genderParam == "female" || parseGender(genderParam) == 1 { + gender = "female" + } else if genderParam == "virtue" || parseGender(genderParam) == 2 { + gender = "virtue" + } + names := generators.GenerateTieflingNames(tieflingArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /tortle-names +func TortleNamesHandler(w http.ResponseWriter, r *http.Request) { + names := generators.GenerateTortleNames(tortleArrays, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /triton-names?gender=male|female|0|1 +func TritonNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateTritonNames(tritonArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /vedalken-names?gender=male|female|0|1 +func VedalkenNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateVedalkenNames(vedalkenArrays, gender, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /verdan-names +func VerdanNamesHandler(w http.ResponseWriter, r *http.Request) { + names := generators.GenerateVerdanNames(verdanArrays, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /warforged-names +func WarforgedNamesHandler(w http.ResponseWriter, r *http.Request) { + names := generators.GenerateWarforgedNames(warforgedArrays, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /wilden-names +func WildenNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + names := generators.GenerateWildenNames(wildenArrays, CheckSwear, gender) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /yuan-ti-names +func YuanTiNamesHandler(w http.ResponseWriter, r *http.Request) { + names := generators.GenerateYuanTiNames(yuantiArrays, CheckSwear) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /modern/english?type=0|1|2 +func ModernEnglishNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + typeInt := 0 + switch gender { + case "female": + typeInt = 1 + case "unisex": + typeInt = 2 + } + names := generators.GenerateModernEnglishNames(modernEnglishArrays, CheckSwear, typeInt) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} + +// /modern/portuguese-eu?type=0|1|2 +func ModernPortugueseNamesHandler(w http.ResponseWriter, r *http.Request) { + gender := getGender(r) + typeInt := 0 + switch gender { + case "female": + typeInt = 1 + case "unisex": + typeInt = 2 + } + names := generators.GenerateModernPortugueseEUNames(modernPortugueseEUArrays, CheckSwear, typeInt) + for i := range names { + names[i] = titleCaser.String(names[i]) + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string][]string{"names": names}) +} diff --git a/main.go b/main.go new file mode 100644 index 0000000..26301df --- /dev/null +++ b/main.go @@ -0,0 +1,97 @@ +package main + +import ( + "log" + "net/http" + + "github.com/go-chi/chi/v5" + "github.com/go-chi/chi/v5/middleware" + "github.com/go-chi/cors" +) + +func main() { + r := chi.NewRouter() + + rps := GetEnvFloat("RATE_LIMIT_RPS", 2.0) + burst := GetEnvInt("RATE_LIMIT_BURST", 5) + + // *CORS + r.Use(middleware.RequestID) + r.Use(middleware.RealIP) + r.Use(middleware.Logger) + r.Use(middleware.Recoverer) + + r.Use(cors.Handler(cors.Options{ + //AllowedOrigins: []string{"https://*", "http://*"}, //* Use this for development + AllowedOrigins: GetEnvList("ALLOWED_ORIGINS", []string{"https://lk-api-temp.onrender.com"}), //* Use this for production + AllowedMethods: []string{"GET"}, + AllowedHeaders: []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token"}, + ExposedHeaders: []string{"Link"}, + AllowCredentials: false, + MaxAge: 300, + })) + r.Use(RateLimiter(rps, burst)) + + r.Route("/v1", func(r chi.Router) { + r.Route("/fantasy", func(r chi.Router) { + r.Get("/elf-names", ElfNamesHandler) + r.Get("/dwarf-names", DwarfNamesHandler) + r.Get("/arakocra-names", ArakocraNamesHandler) + r.Get("/aasimar-names", AasimarNamesHandler) + r.Get("/bugbear-names", BugbearNamesHandler) + r.Get("/centaur-names", CentaurNamesHandler) + r.Get("/changeling-names", ChangelingNamesHandler) + r.Get("/deep-gnome-names", DeepGnomeNamesHandler) + r.Get("/deva-names", DevaNamesHandler) + r.Get("/dragonborn-names", DragonbornNamesHandler) + r.Get("/drow-names", DrowNamesHandler) + r.Get("/duergar-names", DuergarNamesHandler) + r.Get("/eladrin-names", EladrinNamesHandler) + r.Get("/fairy-names", FairyNamesHandler) + r.Get("/firbolg-names", ElfNamesHandler) + r.Get("/genasi-names", GenasiNamesHandler) + r.Get("/githyanki-names", GithyankiNamesHandler) + r.Get("/githzerai-names", GithzeraiNamesHandler) + r.Get("/gnome-names", GnomeNamesHandler) + r.Get("/goblin-names", GoblinNamesHandler) + r.Get("/goliath-names", GoliathNamesHandler) + r.Get("/grung-names", GrungNamesHandler) + r.Get("/half-elf-names", HalfElfNamesHandler) + r.Get("/half-orc-names", HalfOrcNamesHandler) + r.Get("/halfling-names", HalflingNamesHandler) + r.Get("/harengon-names", HarengonNamesHandler) + r.Get("/hobgoblin-names", HobgoblinNamesHandler) + r.Get("/human-names", HumanNamesHandler) + r.Get("/kalashtar-names", KalashtarNamesHandler) + r.Get("/kenku-names", KenkuNamesHandler) + r.Get("/kobold-names", KoboldNamesHandler) + r.Get("/leonin-names", LeoninNamesHandler) + r.Get("/lizardfolk-names", LizardfolkNamesHandler) + r.Get("/locathah-names", LocathahNamesHandler) + r.Get("/loxodon-names", LoxodonNamesHandler) + r.Get("/minotaur-names", MinotaurNamesHandler) + r.Get("/orc-names", OrcNamesHandler) + r.Get("/satyr-names", SatyrNamesHandler) + r.Get("/shadar-kai-names", ShadarKaiNamesHandler) + r.Get("/shardmind-names", ShardmindNamesHandler) + r.Get("/shifter-names", ShifterNamesHandler) + r.Get("/simic-hybrid-names", SimicHybridNamesHandler) + r.Get("/tabaxi-names", TabaxiNamesHandler) + r.Get("/tiefling-names", TieflingNamesHandler) + r.Get("/tortle-names", TortleNamesHandler) + r.Get("/triton-names", TritonNamesHandler) + r.Get("/vedalken-names", VedalkenNamesHandler) + r.Get("/verdan-names", VerdanNamesHandler) + r.Get("/warforged-names", WarforgedNamesHandler) + r.Get("/wilden-names", WildenNamesHandler) + r.Get("/yuan-ti-names", YuanTiNamesHandler) + }) + r.Route("/modern", func(r chi.Router) { + r.Get("/english", ModernEnglishNamesHandler) + r.Get("/portuguese", ModernPortugueseNamesHandler) + }) + }) + + log.Println("Listening on :8080") + log.Fatal(http.ListenAndServe(":8080", r)) +} diff --git a/middleware.go b/middleware.go new file mode 100644 index 0000000..cefc5a9 --- /dev/null +++ b/middleware.go @@ -0,0 +1,21 @@ +package main + +import ( + "net/http" + + "golang.org/x/time/rate" +) + +// RateLimiter middleware limits requests per IP +func RateLimiter(rps float64, burst int) func(http.Handler) http.Handler { + limiter := rate.NewLimiter(rate.Limit(rps), burst) + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { + if !limiter.Allow() { + http.Error(w, http.StatusText(http.StatusTooManyRequests), http.StatusTooManyRequests) + return + } + next.ServeHTTP(w, req) + }) + } +} diff --git a/swear.go b/swear.go new file mode 100644 index 0000000..8c91aad --- /dev/null +++ b/swear.go @@ -0,0 +1,11 @@ +package main + +import "slices" + +var swearWords = []string{ + "alah", "allah", "anal", "anilingus", "anus", "apeshit", "arse", "arsehole", "ass", "asshole", "assmunch", "autoerotic", "babeland", "balls", "ballsack", "bangbros", "bareback", "barenaked", "bastard", "bastardo", "bastinado", "beaner", "beaners", "bestiality", "biatch", "bigtits", "bimbos", "birdlock", "bitch", "bitches", "black", "bloody", "blowjob", "blumpkin", "bollock", "bollocks", "bollok", "bondage", "boner", "boob", "boobs", "bugger", "bukkake", "bulldyke", "bullshit", "bum", "bunghole", "busty", "butt", "buttcheeks", "butthole", "buttplug", "cameltoe", "camgirl", "camslut", "camwhore", "clit", "clitbeard", "clitoris", "cloaka", "clusterfuck", "cock", "cocks", "coon", "coons", "cornhole", "crap", "creampie", "crystalnight", "crystal night", "cum", "cumming", "cunt", "damn", "darkie", "daterape", "deepthroat", "dick", "dildo", "doggy", "dolcett", "domination", "dominatrix", "dommes", "dryhump", "dyke", "ecchi", "ejaculation", "erotic", "erotism", "escort", "eunuch", "fag", "fags", "fagget", "faggets", "faggit", "faggits", "faggot", "faggots", "faggut", "faghet", "faghit", "faghot", "faghut", "fecal", "feck", "felch", "felching", "fellate", "fellatio", "feltch", "femdom", "fetish", "figging", "fingerbang", "fingering", "fisting", "flange", "footjob", "frotting", "fuck", "fuckin", "fucking", "fucktard", "fucktards", "fudgepacker", "futanari", "gangbang", "gaysex", "genitals", "goatcx", "goatse", "god", "goddamn", "gokkun", "goodpoop", "googirl", "gook", "goregasm", "grope", "groupsex", "guro", "handjob", "hardcore", "hell", "hentai", "homo", "homoerotic", "honkey", "hooker", "humping", "incest", "intercourse", "jackoff", "jailbait", "jerk", "jerkoff", "jigaboo", "jiggaboo", "jiggerboo", "jizz", "juggs", "kike", "kinbaku", "kinkster", "kinky", "knobbing", "knobend", "kum", "labia", "lmao", "lmfao", "lolita", "maleass", "masturbate", "milf", "muff", "nambla", "nawashi", "nazi", "neeger", "neegger", "negger", "negro", "neonazi", "nieger", "niegger", "nig", "niga", "nigar", "niger", "nigga", "nighar", "nigah", "niggah", "nyg", "nyga", "nygah", "nygger", "nyggah", "nyggar", "nyger", "nygra", "niggar", "niggas", "nigir", "niggir", "nigirr", "niggirr", "niggaz", "nigger", "niggers", "nigges", "niggir", "niggis", "niggor", "niggos", "niggur", "niggus", "niggrer", "niggret", "nigher", "nighes", "nignog", "nigra", "nimphomania", "nipple", "nipples", "nude", "nudity", "nympho", "nymphomania", "obama", "octopussy", "omg", "omorashi", "oral", "orgasm", "orgy", "paedo", "paki", "panties", "panty", "pedo", "pegging", "penis", "pis", "piss", "pissing", "pisspig", "playboy", "ponyplay", "poof", "poon", "poontang", "poop", "porn", "porno", "prick", "pube", "pubes", "punany", "pussy", "queaf", "queef", "queer", "quim", "raghead", "rape", "raping", "rapist", "rectum", "rimjob", "rimming", "sadism", "santorum", "scat", "schlong", "scissoring", "scrotum", "semen", "sex", "sexo", "sexy", "sexx", "sexxy", "sexei", "sexxei", "shaved", "shemale", "shibari", "shit", "shitblimp", "shitty", "shota", "shrimping", "skeet", "slanteye", "slut", "smegma", "smut", "snatch", "sodomize", "sodomy", "spic", "splooge", "spooge", "spunk", "squaw", "strapon", "suck", "sucks", "suicide", "sultry", "swastika", "swinger", "threesome", "throating", "tiits", "tit", "tits", "titties", "titty", "topless", "tosser", "towelhead", "trani", "tranie", "tranni", "trannie", "tranny", "trany", "trennie", "tubgirl", "turd", "tushy", "twat", "twink", "twinkie", "upskirt", "urethra", "urophilia", "vagina", "vibrator", "voyeur", "vulva", "wank", "wetback", "whore", "wtf", "yaoi", "yiffy", "stillborn", +} + +func CheckSwear(name string) bool { + return slices.Contains(swearWords, name) +}