278 lines
14 KiB
Python
278 lines
14 KiB
Python
#!/usr/bin/env python3
|
||
"""Генератор ников для ботов — порт nickgen.html (логика 1:1).
|
||
|
||
Режимы:
|
||
python nickgen.py --print 30 [--seed 42] напечатать N ников
|
||
python nickgen.py [--seed 42] dry-run: показать, что изменится
|
||
python nickgen.py --apply [--seed 42] переписать имена в сидах:
|
||
server/game/data/FakePlayerProgression.xml (<character name="...">)
|
||
server/db_installer/sql/spp_clan_seed.sql (characters.char_name)
|
||
|
||
Соответствие: character id=N в XML <-> charId 270001000+N в SQL, имена ставятся
|
||
из одного списка, так что XML и БД остаются согласованы. После --apply ники в
|
||
работающей БД не изменятся (INSERT IGNORE) — нужен reset-bots.ps1 и пересборка
|
||
образа.
|
||
"""
|
||
import argparse
|
||
import random
|
||
import re
|
||
import sys
|
||
from pathlib import Path
|
||
|
||
ROOT = Path(__file__).resolve().parent
|
||
XML_PATH = ROOT / 'server' / 'game' / 'data' / 'FakePlayerProgression.xml'
|
||
SQL_PATH = ROOT / 'server' / 'db_installer' / 'sql' / 'spp_clan_seed.sql'
|
||
CHAR_ID_BASE = 270001000
|
||
|
||
# --- Пулы слов (как в nickgen.html) ------------------------------------------
|
||
RU_ADJ = ['злой', 'добрый', 'старый', 'дикий', 'мелкий', 'жирный', 'хитрый', 'бешеный', 'мамкин', 'просто',
|
||
'лысый', 'грозный', 'тихий', 'сонный', 'голодный', 'кривой', 'ржавый', 'бодрый', 'унылый', 'модный',
|
||
'четкий', 'дерзкий', 'борзый', 'лютый', 'шустрый', 'реальный', 'угарный', 'наглый']
|
||
RU_NOUN = ['гном', 'пес', 'кот', 'волк', 'сухарь', 'травка', 'пельмень', 'колбаса', 'мармелад', 'чума',
|
||
'ведьмак', 'сквозняк', 'холодок', 'бомж', 'топор', 'кабан', 'хомяк', 'огурец', 'батон', 'чеснок',
|
||
'валенок', 'тапок', 'кефир', 'компот', 'барсук', 'ежик', 'мухомор', 'лопата', 'кирпич', 'шашлык',
|
||
'беляш', 'танкист', 'дед', 'сосед', 'медоед', 'каратель', 'монах',
|
||
'гопник', 'чебурек', 'шаурма', 'семки', 'пацан', 'браток', 'кент', 'батя', 'гараж', 'подъезд',
|
||
'чушпан', 'задрот', 'нуб', 'читер', 'красавчик', 'нагибатор', 'убиватор', 'терминатор']
|
||
RU_NAME = ['олег', 'вася', 'дашка', 'ленка', 'федор', 'санек', 'толик', 'серега', 'витек', 'петруха',
|
||
'колян', 'димон', 'настя', 'машка', 'гриша', 'степан', 'юрец', 'макс',
|
||
'жека', 'вован', 'толян', 'саня', 'диман', 'леха', 'андрюха', 'кирюха', 'паша', 'стас',
|
||
'руслан', 'тимур', 'натаха', 'светка', 'танюха', 'ирка', 'вовчик', 'петрович', 'палыч']
|
||
RU_SURNAME = ['пупкин', 'сидоров', 'петров', 'иванов', 'смирнов', 'кузнецов', 'козлов', 'волков', 'зайцев', 'медведев']
|
||
PREFIXES = ['MC', 'Dj', 'Mr']
|
||
EN_ADJ = ['Dark', 'Shadow', 'Storm', 'Night', 'Blood', 'Ghost', 'Crazy', 'Old', 'Swift', 'Silent',
|
||
'Grim', 'Mad', 'Evil', 'Frost', 'Iron', 'Black', 'Wild', 'Lone', 'Sweet', 'True']
|
||
EN_NOUN = ['Slayer', 'Reaper', 'Hunter', 'Killer', 'Knight', 'Rogue', 'Monk', 'Rider', 'Arrow', 'Blade',
|
||
'Master', 'Lord', 'King', 'Sniper', 'Mage', 'Angel', 'Demon', 'Raven', 'Wolf', 'Dragon',
|
||
'Fire', 'Ice', 'Death', 'Star', 'Dream', 'Soul', 'Fang', 'Claw', 'Bishop', 'Titan']
|
||
|
||
# --- Транслит: кириллица -> латиница -----------------------------------------
|
||
TRANSLIT = {'а': 'a', 'б': 'b', 'в': 'v', 'г': 'g', 'д': 'd', 'е': 'e', 'ё': 'e', 'ж': 'zh', 'з': 'z',
|
||
'и': 'i', 'й': 'j', 'к': 'k', 'л': 'l', 'м': 'm', 'н': 'n', 'о': 'o', 'п': 'p', 'р': 'r',
|
||
'с': 's', 'т': 't', 'у': 'u', 'ф': 'f', 'х': 'h', 'ц': 'c', 'ч': 'ch', 'ш': 'sh', 'щ': 'sch',
|
||
'ъ': '', 'ы': 'y', 'ь': '', 'э': 'e', 'ю': 'yu', 'я': 'ya'}
|
||
|
||
# --- Псевдокириллица: латинские двойники (KpucuK, TpaBka, IIeJIbMeHb) ---------
|
||
# None = нет похожего символа, берётся транслит буквы.
|
||
FAKE_CYR = {'а': 'a', 'б': '6', 'в': 'B', 'г': 'r', 'д': None, 'е': 'e', 'ё': 'e', 'ж': None, 'з': '3',
|
||
'и': 'u', 'й': 'u', 'к': 'K', 'л': 'JI', 'м': 'M', 'н': 'H', 'о': 'o', 'п': 'II', 'р': 'p',
|
||
'с': 'c', 'т': 'T', 'у': 'y', 'ф': None, 'х': 'x', 'ц': None, 'ч': '4', 'ш': 'LLI', 'щ': None,
|
||
'ъ': '', 'ы': 'bI', 'ь': 'b', 'э': '3', 'ю': 'IO', 'я': '9I'}
|
||
|
||
# --- l33t для латинских слов (Ki4iga, OlegBI4) --------------------------------
|
||
LEET = {'e': '3', 'o': '0', 'a': '4', 'i': '1', 's': '5'}
|
||
|
||
VALID = re.compile(r'^[A-Za-z0-9]{3,16}$')
|
||
RU_RE = re.compile(r'[а-яё]')
|
||
|
||
|
||
class NickGen:
|
||
def __init__(self, seed=None, translit=True, fake_cyr=True, leet=True, digits=True, wrap=True,
|
||
weights=(25, 55, 20)):
|
||
self.r = random.Random(seed)
|
||
self.translit = translit
|
||
self.fake_cyr = fake_cyr
|
||
self.leet = leet
|
||
self.digits = digits
|
||
self.wrap = wrap
|
||
self.weights = weights
|
||
|
||
def chance(self, pct):
|
||
return self.r.randrange(100) < pct
|
||
|
||
def pick(self, arr):
|
||
return arr[self.r.randrange(len(arr))]
|
||
|
||
def translit_word(self, w):
|
||
out = ''
|
||
for ch in w:
|
||
t = TRANSLIT.get(ch, ch)
|
||
if ch == 'й' and self.chance(50):
|
||
t = 'y'
|
||
if ch == 'в' and self.chance(15):
|
||
t = 'w' # Wowan-стиль
|
||
if ch == 'х':
|
||
t = 'x' if self.chance(40) else ('kh' if self.chance(30) else 'h') # Xyligan-стиль
|
||
out += t
|
||
return out[:1].upper() + out[1:]
|
||
|
||
def fake_cyr_word(self, w):
|
||
out = ''
|
||
for ch in w:
|
||
f = FAKE_CYR.get(ch, ch)
|
||
out += f if f is not None else TRANSLIT.get(ch, ch)
|
||
return out
|
||
|
||
def leet_word(self, w):
|
||
out, used = '', 0
|
||
for ch in w:
|
||
l = LEET.get(ch.lower())
|
||
if l and used < 2 and self.chance(45):
|
||
out += l
|
||
used += 1
|
||
else:
|
||
out += ch
|
||
return out
|
||
|
||
def build_parts(self, lang, n):
|
||
"""-> список пар (слово, is_surname)."""
|
||
w = lambda x: (x, False)
|
||
s = lambda x: (x, True)
|
||
if lang == 'ru':
|
||
if n == 1:
|
||
v = self.r.randrange(100)
|
||
if v < 45:
|
||
return [w(self.pick(RU_NOUN))]
|
||
if v < 80:
|
||
return [w(self.pick(RU_NAME))]
|
||
return [s(self.pick(RU_SURNAME))]
|
||
if n == 2:
|
||
v = self.r.randrange(4)
|
||
if v == 0:
|
||
return [w(self.pick(RU_ADJ)), w(self.pick(RU_NOUN))]
|
||
if v == 1:
|
||
return [w(self.pick(RU_ADJ)), w(self.pick(RU_NAME))]
|
||
if v == 2:
|
||
return [w(self.pick(RU_NOUN)), w(self.pick(RU_NOUN))]
|
||
return [w(self.pick(RU_NAME)), s(self.pick(RU_SURNAME))] # VasyaPupkin
|
||
if self.chance(50):
|
||
return [w(self.pick(RU_ADJ)), w(self.pick(RU_NOUN)), w(self.pick(RU_NOUN))]
|
||
return [w(self.pick(RU_ADJ)), w(self.pick(RU_NAME)), s(self.pick(RU_SURNAME))]
|
||
if n == 1:
|
||
return [w(self.pick(EN_NOUN))]
|
||
if n == 2:
|
||
return [w(self.pick(EN_ADJ)), w(self.pick(EN_NOUN))]
|
||
first = self.pick(EN_ADJ)
|
||
second = self.pick([x for x in EN_ADJ if x != first]) if self.chance(50) else self.pick(EN_NOUN)
|
||
return [w(first), w(second), w(self.pick(EN_NOUN))]
|
||
|
||
def generate_one(self):
|
||
total = max(sum(self.weights), 1)
|
||
roll = self.r.randrange(total)
|
||
n = 1 if roll < self.weights[0] else 2 if roll < self.weights[0] + self.weights[1] else 3
|
||
|
||
lang = 'ru' if self.chance(70) else 'en'
|
||
parts = self.build_parts(lang, n)
|
||
# редкая смесь языков в 2-3-частных никах
|
||
if n > 1 and self.chance(15):
|
||
parts[-1] = (self.pick(EN_NOUN), False) if lang == 'ru' else (self.translit_word(self.pick(RU_NOUN)), False)
|
||
|
||
modes = ([['translit'], []][not self.translit]) + ([['fakeCyr'], []][not self.fake_cyr])
|
||
ru_mode = self.pick(modes) if modes else 'translit'
|
||
|
||
rendered = []
|
||
for w, is_surname in parts:
|
||
if RU_RE.search(w):
|
||
if ru_mode == 'fakeCyr':
|
||
rendered.append(self.fake_cyr_word(w))
|
||
else:
|
||
t = self.translit_word(w)
|
||
# фамилии на -ov: SmirnOFF / Smirnoff
|
||
if is_surname and t.lower().endswith('ov') and self.chance(50):
|
||
t = t[:-2] + ('OFF' if self.chance(40) else 'off')
|
||
rendered.append(t)
|
||
else:
|
||
rendered.append(self.leet_word(w) if self.leet and self.chance(20) else w)
|
||
nick = ''.join(rendered)
|
||
|
||
# декорации (стиль сида: dashka, ZloyPES, HolodOK, OldRogue38, MCVovan95, xXDarkSlayerXx)
|
||
if ru_mode == 'translit':
|
||
if self.chance(12):
|
||
nick = nick.lower()
|
||
elif self.chance(12) and len(nick) > 4:
|
||
k = 2 + self.r.randrange(2)
|
||
nick = nick[:-k] + nick[-k:].upper()
|
||
if self.digits and self.chance(28) and len(nick) <= 14:
|
||
v = self.r.randrange(100)
|
||
if v < 45:
|
||
suf = str(1 + self.r.randrange(9)) if self.chance(50) else str(10 + self.r.randrange(90))
|
||
elif v < 80:
|
||
suf = '%02d' % ((85 + self.r.randrange(23)) % 100) # год рождения 85..07
|
||
else:
|
||
suf = str(1985 + self.r.randrange(23)) # 1985..2007
|
||
if len(nick) + len(suf) <= 16:
|
||
nick += suf
|
||
if self.chance(4) and len(nick) <= 13:
|
||
nick += 'RUS'
|
||
prefixed = False
|
||
if self.chance(6) and len(nick) <= 14:
|
||
nick = self.pick(PREFIXES) + nick
|
||
prefixed = True
|
||
if self.wrap and not prefixed and self.chance(4) and len(nick) <= 12:
|
||
nick = 'xX' + nick + 'Xx'
|
||
return nick
|
||
|
||
def batch(self, count, taken=None):
|
||
taken = taken if taken is not None else set()
|
||
out = []
|
||
guard = count * 200
|
||
while len(out) < count and guard > 0:
|
||
guard -= 1
|
||
nick = self.generate_one()
|
||
if VALID.match(nick) and nick.lower() not in taken:
|
||
taken.add(nick.lower())
|
||
out.append(nick)
|
||
if len(out) < count:
|
||
raise RuntimeError(f'Не хватило уникальных имён: {len(out)}/{count}. Расширь пулы слов.')
|
||
return out
|
||
|
||
|
||
# --- Перезапись сидов ---------------------------------------------------------
|
||
XML_RE = re.compile(r'(<character id="(\d+)" name=")([^"]*)(")')
|
||
SQL_RE = re.compile(r"(VALUES \((270\d{6}), 'sppbots', ')([^']*)(')")
|
||
|
||
|
||
def rewrite(xml_path, sql_path, names_by_id, apply_changes):
|
||
xml_text = xml_path.read_text(encoding='utf-8')
|
||
sql_text = sql_path.read_text(encoding='utf-8')
|
||
|
||
def xml_sub(m):
|
||
return m.group(1) + names_by_id[int(m.group(2))] + m.group(4)
|
||
|
||
def sql_sub(m):
|
||
return m.group(1) + names_by_id[int(m.group(2)) - CHAR_ID_BASE] + m.group(4)
|
||
|
||
new_xml, n_xml = XML_RE.subn(xml_sub, xml_text)
|
||
new_sql, n_sql = SQL_RE.subn(sql_sub, sql_text)
|
||
if n_xml != len(names_by_id) or n_sql != len(names_by_id):
|
||
raise RuntimeError(f'Несогласованность: XML={n_xml}, SQL={n_sql}, имён={len(names_by_id)}')
|
||
if apply_changes:
|
||
xml_path.write_text(new_xml, encoding='utf-8', newline='')
|
||
sql_path.write_text(new_sql, encoding='utf-8', newline='')
|
||
return n_xml, n_sql
|
||
|
||
|
||
def main():
|
||
p = argparse.ArgumentParser(description='Генератор ников для ботов')
|
||
p.add_argument('--print', dest='print_n', type=int, metavar='N', help='напечатать N ников и выйти')
|
||
p.add_argument('--apply', action='store_true', help='переписать имена в XML и SQL (по умолчанию dry-run)')
|
||
p.add_argument('--seed', type=int, help='сид для воспроизводимости (по умолчанию случайный)')
|
||
p.add_argument('--xml', type=Path, default=XML_PATH)
|
||
p.add_argument('--sql', type=Path, default=SQL_PATH)
|
||
a = p.parse_args()
|
||
|
||
seed = a.seed if a.seed is not None else random.randrange(1 << 31)
|
||
gen = NickGen(seed=seed)
|
||
print(f'seed = {seed}')
|
||
|
||
if a.print_n:
|
||
for nick in gen.batch(a.print_n):
|
||
print(nick)
|
||
return
|
||
|
||
ids = [int(m.group(2)) for m in XML_RE.finditer(a.xml.read_text(encoding='utf-8'))]
|
||
names = gen.batch(len(ids))
|
||
names_by_id = dict(zip(ids, names))
|
||
n_xml, n_sql = rewrite(a.xml, a.sql, names_by_id, a.apply)
|
||
sample = ', '.join(names[:10])
|
||
if a.apply:
|
||
print(f'Переписано имён: XML={n_xml}, SQL={n_sql}. Первые: {sample}')
|
||
print('В работающей БД имена не изменятся (INSERT IGNORE) — нужен reset-bots.ps1 и пересборка образа.')
|
||
else:
|
||
print(f'Dry-run: заменил бы XML={n_xml}, SQL={n_sql} имён. Первые: {sample}')
|
||
print('Запусти с --apply чтобы записать.')
|
||
|
||
|
||
if __name__ == '__main__':
|
||
sys.exit(main())
|