400 lines
10 KiB
Python
400 lines
10 KiB
Python
from npc import traits
|
|
import random
|
|
import dice
|
|
import textwrap
|
|
import logging
|
|
|
|
from typing import Union
|
|
|
|
from language.types import Name, Language
|
|
|
|
|
|
def a_or_an(s):
|
|
return 'an' if s[0] in 'aeiouh' else 'a'
|
|
|
|
|
|
class StatBlock:
|
|
|
|
def __init__(
|
|
self,
|
|
STR: int = 10,
|
|
DEX: int = 10,
|
|
CON: int = 10,
|
|
INT: int = 10,
|
|
WIS: int = 10,
|
|
CHA: int = 10,
|
|
HP: int = 10,
|
|
AC: int = 10,
|
|
speed: int = 30,
|
|
passive_perception: int = 10,
|
|
passive_investigation: int = 10,
|
|
):
|
|
self.STR = STR
|
|
self.DEX = DEX
|
|
self.CON = CON
|
|
self.INT = INT
|
|
self.WIS = WIS
|
|
self.CHA = CHA
|
|
self.HP = HP
|
|
self.AC = AC
|
|
self.speed = speed
|
|
self.passive_perception = passive_perception
|
|
self.passive_investigation = passive_investigation
|
|
|
|
def randomize(self):
|
|
stats = [15, 14, 13, 12, 10, 8]
|
|
random.shuffle(stats)
|
|
if random.random() < 0.3:
|
|
i = random.choice(range(len(stats)))
|
|
stats[i] += (random.choice([-1, 1]) * random.randint(1, 3))
|
|
(self.STR, self.DEX, self.CON, self.INT, self.WIS, self.CHA) = stats
|
|
self.HP = str(sum(dice.roll('2d8')) + 2) + ' (2d8+2)'
|
|
|
|
def __str__(self):
|
|
return textwrap.dedent(f"""
|
|
AC {self.AC}
|
|
HP {self.HP}
|
|
STR {self.STR}
|
|
DEX {self.DEX}
|
|
CON {self.CON}
|
|
INT {self.INT}
|
|
WIS {self.WIS}
|
|
CHA {self.CHA}
|
|
|
|
Speed: {self.speed}
|
|
|
|
Passive Perception: {self.passive_perception}
|
|
Passive Investigation: {self.passive_perception}
|
|
""")
|
|
|
|
|
|
class NPC:
|
|
"""
|
|
Return a randomized NPC. Any supplied keyword parameters will override
|
|
generated, randomized values.
|
|
|
|
By default, NPC stats are all 10 (+0). If randomize is True, the NPC will
|
|
be given random stats from the standard distribution, but overrides will
|
|
still take precedence.
|
|
"""
|
|
|
|
# Define this as a language module from language.supported_languages.values()
|
|
language = None
|
|
|
|
# appearance
|
|
has_eyes = True
|
|
has_hair = True
|
|
has_face = True
|
|
has_body = True
|
|
has_nose = True
|
|
has_lips = True
|
|
has_teeth = True
|
|
has_skin_tone = True
|
|
has_skin_color = True
|
|
has_facial_hair = True
|
|
has_facial_structure = True
|
|
has_eyebrows = True
|
|
|
|
has_age = True
|
|
has_voice = True
|
|
|
|
has_tail = False
|
|
has_horns = False
|
|
has_fangs = False
|
|
has_wings = False
|
|
|
|
def __init__(
|
|
self,
|
|
name: Union[Name, None] = None,
|
|
pronouns: Union[str, None] = None,
|
|
whereabouts: str = "Unknown",
|
|
stats: StatBlock = StatBlock(),
|
|
noble: bool = False,
|
|
randomize: bool = False,
|
|
language: Union[Language, None] = None,
|
|
):
|
|
|
|
# identity
|
|
self._name = name
|
|
self._is_noble = noble
|
|
self._whereabouts = whereabouts
|
|
self._stats = stats
|
|
self._pronouns = pronouns
|
|
|
|
# appearance
|
|
self._eyes = None
|
|
self._hair = None
|
|
self._face = None
|
|
self._body = None
|
|
self._nose = None
|
|
self._lips = None
|
|
self._teeth = None
|
|
self._skin_tone = None
|
|
self._skin_color = None
|
|
self._facial_hair = None
|
|
self._facial_structure = None
|
|
self._eyebrows = None
|
|
self._age = None
|
|
self._voice = None
|
|
self._tail = None
|
|
self._horns = None
|
|
self._fangs = None
|
|
self._wings = None
|
|
|
|
# character
|
|
self._flaw = None
|
|
self._goal = None
|
|
self._personality = None
|
|
|
|
if language:
|
|
self.language = language
|
|
|
|
if randomize:
|
|
self.stats.randomize()
|
|
|
|
@property
|
|
def ancestry(self) -> str:
|
|
return self.__class__.__name__
|
|
|
|
@property
|
|
def names(self):
|
|
if not self._names:
|
|
self._names = next(self.name_generator.name(1))
|
|
return self._names
|
|
|
|
@property
|
|
def full_name(self):
|
|
"""Legacy interface"""
|
|
return self.name
|
|
|
|
@property
|
|
def is_noble(self) -> bool:
|
|
return self._is_noble
|
|
|
|
@property
|
|
def name(self):
|
|
if not self._name:
|
|
generator = getattr(
|
|
self.language,
|
|
'NobleName' if self.is_noble else 'Name'
|
|
)
|
|
self._name = generator.name()[0]
|
|
logging.debug(self._name)
|
|
return self._name['fullname']
|
|
|
|
@property
|
|
def pronouns(self):
|
|
if not self._pronouns:
|
|
self._pronouns = random.choice([
|
|
'he/him',
|
|
'she/her',
|
|
'they/they',
|
|
])
|
|
return self._pronouns
|
|
|
|
@property
|
|
def title(self):
|
|
return ' '.join(self.names.titles)
|
|
|
|
@property
|
|
def nickname(self):
|
|
return ', '.join(self.names.nicknames)
|
|
|
|
@property
|
|
def whereabouts(self):
|
|
return self._whereabouts
|
|
|
|
@property
|
|
def flaw(self):
|
|
if self._flaw is None:
|
|
self._flaw = random.choice(traits.flaws)
|
|
return self._flaw
|
|
|
|
@property
|
|
def goal(self):
|
|
if self._goal is None:
|
|
self._goal = random.choice(traits.goals)
|
|
return self._goal
|
|
|
|
@property
|
|
def personality(self):
|
|
if self._personality is None:
|
|
self._personality = ', '.join([
|
|
random.choice(traits.personality),
|
|
random.choice(traits.personality),
|
|
random.choice(traits.personality),
|
|
])
|
|
return self._personality
|
|
|
|
@property
|
|
def eyes(self):
|
|
if self._eyes is None:
|
|
self._eyes = ', '.join([random.choice(traits.eye_shape), random.choice(traits.eye_color)])
|
|
return self._eyes
|
|
|
|
@property
|
|
def skin_color(self):
|
|
if self._skin_color is None:
|
|
self._skin_color = random.choice(traits.skin_color)
|
|
return self._skin_color
|
|
|
|
@property
|
|
def skin_tone(self):
|
|
if self._skin_tone is None:
|
|
self._skin_tone = random.choice(traits.skin_tone)
|
|
return self._skin_tone
|
|
|
|
@property
|
|
def hair(self):
|
|
if self._hair is None:
|
|
self._hair = ' '.join([random.choice(traits.hair_style), random.choice(traits.hair_color)])
|
|
return self._hair
|
|
|
|
@property
|
|
def face(self):
|
|
if not self._face:
|
|
self._face = random.choice(traits.face)
|
|
return self._face
|
|
|
|
@property
|
|
def facial_structure(self):
|
|
if self._facial_structure is None:
|
|
self._facial_structure = random.choice(traits.facial_structure)
|
|
return self._facial_structure
|
|
|
|
@property
|
|
def lips(self):
|
|
if self._lips is None:
|
|
self._lips = random.choice(traits.lips)
|
|
return self._lips
|
|
|
|
@property
|
|
def teeth(self):
|
|
if self._teeth is None:
|
|
self._teeth = random.choice(traits.teeth)
|
|
return self._teeth
|
|
|
|
@property
|
|
def nose(self):
|
|
if self._nose is None:
|
|
self._nose = random.choice(traits.nose)
|
|
return self._nose
|
|
|
|
@property
|
|
def eyebrows(self):
|
|
if self._eyebrows is None:
|
|
self._eyebrows = random.choice(traits.eyebrows)
|
|
return self._eyebrows
|
|
|
|
@property
|
|
def facial_hair(self):
|
|
if self._facial_hair is None:
|
|
self._facial_hair = random.choice(traits.facial_hair)
|
|
return self._facial_hair
|
|
|
|
@property
|
|
def body(self):
|
|
if self._body is None:
|
|
self._body = random.choice(traits.body)
|
|
return self._body
|
|
|
|
@property
|
|
def tail(self):
|
|
if self._tail is None:
|
|
self._tail = random.choice(traits.tail)
|
|
return self._tail
|
|
|
|
@property
|
|
def horns(self):
|
|
if self._horns is None:
|
|
self._horns = random.choice(traits.horns)
|
|
return self._horns
|
|
|
|
@property
|
|
def wings(self):
|
|
if self._wings is None:
|
|
self._wings = random.choice(traits.wings)
|
|
return self._wings
|
|
|
|
@property
|
|
def fangs(self):
|
|
if self._fangs is None:
|
|
self._fangs = random.choice(traits.fangs)
|
|
return self._fangs
|
|
|
|
@property
|
|
def age(self):
|
|
if not self._age:
|
|
self._age = random.choice(traits.age)
|
|
return self._age
|
|
|
|
@property
|
|
def voice(self):
|
|
if not self._voice:
|
|
self._voice = random.choice(traits.voice)
|
|
return self._voice
|
|
|
|
@property
|
|
def stats(self):
|
|
return self._stats
|
|
|
|
@property
|
|
def description(self):
|
|
desc = (
|
|
f"{self.name} ({self.pronouns}) is {a_or_an(self.age)} {self.age}, {self.body} "
|
|
f"{self.ancestry.lower()} with {self.hair} hair, {self.eyes} eyes and {self.skin_color} skin."
|
|
)
|
|
trait = None
|
|
while not trait:
|
|
trait = random.choice([
|
|
f'{self.eyebrows} eyebrows' if self.eyebrows else None,
|
|
self.facial_hair if self.facial_hair else None,
|
|
f'a {self.nose} nose' if self.nose else None,
|
|
f'{self.lips} lips' if self.lips else None,
|
|
f'{self.teeth} teeth' if self.teeth else None,
|
|
self.facial_structure if self.facial_structure else None,
|
|
])
|
|
desc = desc + ' ' + f"Their face is {self.face}, with {trait}."
|
|
if self.has_tail:
|
|
desc = desc + f" Their tail is {self.tail}."
|
|
if self.has_horns:
|
|
desc = desc + f" Their horns are {self.horns}."
|
|
return desc
|
|
|
|
@property
|
|
def character_sheet(self):
|
|
desc = '\n'.join(textwrap.wrap(self.description, width=120))
|
|
return f"""\
|
|
|
|
{desc}
|
|
|
|
Physical Traits:
|
|
|
|
Face: {self.face}, {self.eyebrows} eyebrows, {self.nose} nose, {self.lips} lips,
|
|
{self.teeth} teeth, {self.facial_hair}
|
|
Eyes: {self.eyes}
|
|
Skin: {self.skin_tone}, {self.skin_color}
|
|
Hair: {self.hair}
|
|
Body: {self.body}
|
|
Tail: {self.tail}
|
|
Horns: {self.horns}
|
|
Fangs: {self.fangs}
|
|
Wings: {self.wings}
|
|
Voice: {self.voice}
|
|
|
|
Stats:
|
|
{textwrap.indent(str(self.stats), prefix=' ')}
|
|
|
|
Details:
|
|
|
|
Personality: {self.personality}
|
|
Flaw: {self.flaw}
|
|
Goal: {self.goal}
|
|
|
|
Whereabouts: {self.whereabouts}
|
|
|
|
"""
|
|
|
|
def __repr__(self):
|
|
return self.description
|