Source code for evennia.contrib.tutorials.evadventure.npcs

EvAdventure NPCs. This includes both friends and enemies, only separated by their AI.


from random import choice

from evennia import DefaultCharacter
from evennia.typeclasses.attributes import AttributeProperty
from evennia.typeclasses.tags import TagProperty
from evennia.utils.evmenu import EvMenu
from evennia.utils.utils import lazy_property, make_iter

from .ai import AIHandler
from .characters import LivingMixin
from .enums import Ability, WieldLocation
from .objects import get_bare_hands
from .rules import dice

[docs]class EvAdventureNPC(LivingMixin, DefaultCharacter): """ This is the base class for all non-player entities, including monsters. These generally don't advance in level but uses a simplified, abstract measure of how dangerous or competent they are - the 'hit dice' (HD). HD indicates how much health they have and how hard they hit. In _Knave_, HD also defaults to being the bonus for all abilities. HP is 4 x Hit die (this can then be customized per-entity of course). Morale is set explicitly per-NPC, usually between 7 and 9. Monsters don't use equipment in the way PCs do, instead they have a fixed armor value, and their Abilities are dynamically generated from the HD (hit_dice). If wanting monsters or NPCs that can level and work the same as PCs, base them off the EvAdventureCharacter class instead. The weapon of the npc is stored as an Attribute instead of implementing a full inventory/equipment system. This means that the normal inventory can be used for non-combat purposes (or for loot to get when killing an enemy). """ is_pc = False hit_dice = AttributeProperty(default=1, autocreate=False) armor = AttributeProperty(default=1, autocreate=False) # +10 to get armor defense morale = AttributeProperty(default=9, autocreate=False) hp_multiplier = AttributeProperty(default=4, autocreate=False) # 4 default in Knave hp = AttributeProperty(default=None, autocreate=False) # internal tracking, use .hp property allegiance = AttributeProperty(default=Ability.ALLEGIANCE_HOSTILE, autocreate=False) is_idle = AttributeProperty(default=False, autocreate=False) weapon = AttributeProperty(default=get_bare_hands, autocreate=False) # instead of inventory coins = AttributeProperty(default=1, autocreate=False) # coin loot # if this npc is attacked, everyone with the same tag in the current location will also be # pulled into combat. group = TagProperty("npcs") @property def strength(self): return self.hit_dice @property def dexterity(self): return self.hit_dice @property def constitution(self): return self.hit_dice @property def intelligence(self): return self.hit_dice @property def wisdom(self): return self.hit_dice @property def charisma(self): return self.hit_dice @property def hp_max(self): return self.hit_dice * self.hp_multiplier
[docs] def at_object_creation(self): """ Start with max health. """ self.hp = self.hp_max self.tags.add("npcs", category="group")
[docs] def at_attacked(self, attacker, **kwargs): """ Called when being attacked and combat starts. """ pass
[docs] def ai_next_action(self, **kwargs): """ The combat engine should ask this method in order to get the next action the npc should perform in combat. """ pass
[docs]class EvAdventureTalkativeNPC(EvAdventureNPC): """ Talkative NPCs can be addressed by `talk [to] <npc>`. This opens a chat menu with communication options. The menu is created with the npc and we override the .create to allow passing in the menu nodes. """ menudata = AttributeProperty(dict(), autocreate=False) menu_kwargs = AttributeProperty(dict(), autocreate=False) # text shown when greeting at the start of a conversation. If this is an # iterable, a random reply will be chosen by the menu hi_text = AttributeProperty("Hi!", autocreate=False)
[docs] def at_damage(self, damage, attacker=None): """ Talkative NPCs are generally immortal (we don't deduct HP here by default)." """ attacker.msg(f'{self.key} dodges the damage and shouts "|wHey! What are you doing?|n"')
[docs] @classmethod def create(cls, key, account=None, **kwargs): """ Overriding the creation of the NPC, allowing some extra `**kwargs`. Args: key (str): Name of the new object. account (Account, optional): Account to attribute this object to. Keyword Args: description (str): Brief description for this object (same as default Evennia) ip (str): IP address of creator (for object auditing) (same as default Evennia). menudata (dict or str): The `menudata` argument to `EvMenu`. This is either a dict of `{"nodename": <node_callable>,...}` or the python-path to a module containing such nodes (see EvMenu docs). This will be used to generate the chat menu chat menu for the character that talks to the NPC (which means the `at_talk` hook is called (by our custom `talk` command). menu_kwargs (dict): This will be passed as `**kwargs` into `EvMenu` when it is created. Make sure this dict can be pickled to an Attribute. Returns: tuple: `(new_character, errors)`. On error, the `new_character` is `None` and `errors` is a `list` of error strings (an empty list otherwise). """ menudata = kwargs.pop("menudata", None) menu_kwargs = kwargs.pop("menu_kwargs", {}) # since this is a @classmethod we can't use super() here new_object, errors = EvAdventureNPC.create( key, account=account, attributes=(("menudata", menudata), ("menu_kwargs", menu_kwargs)) ) return new_object, errors
[docs] def at_talk(self, talker, startnode="node_start", session=None, **kwargs): """ Called by the `talk` command when another entity addresses us. Args: talker (Object): The one talking to us. startnode (str, optional): Allows to start in a different location in the menu tree. The given node must exist in the tree. session (Session, optional): The talker's current session, allows for routing correctly in multi-session modes. **kwargs: This will be passed into the `EvMenu` creation and appended and `menu_kwargs` given to the NPC at creation. Notes: We pass `npc=self` into the EvMenu for easy back-reference. This will appear in the `**kwargs` of the start node. """ menu_kwargs = {**self.menu_kwargs, **kwargs} EvMenu(talker, self.menudata, startnode=startnode, session=session, npc=self, **menu_kwargs)
[docs]def node_start(caller, raw_string, **kwargs): """ This is the intended start menu node for the Talkative NPC interface. It will use on-npc Attributes to build its message and will also pick its options based on nodes named `node_start_*` are available in the node tree. """ # we presume a back-reference to the npc this is added when the menu is created npc = kwargs["npc"] # grab a (possibly random) welcome text text = choice(make_iter(npc.hi_text)) # determine options based on `node_start_*` nodes available toplevel_node_keys = [ node_key for node_key in caller.ndb._evmenu._menutree if node_key.startswith("node_start_") ] options = [] for node_key in toplevel_node_keys: option_name = node_key[11:].replace("_", " ").capitalized() # we let the menu number the choices, so we don't use key here options.append({"desc": option_name, "goto": node_key}) return text, options
[docs]class EvAdventureQuestGiver(EvAdventureTalkativeNPC): """ An NPC that acts as a dispenser of quests. """
[docs]class EvAdventureShopKeeper(EvAdventureTalkativeNPC): """ ShopKeeper NPC. """ # how much extra the shopkeeper adds on top of the item cost upsell_factor = AttributeProperty(1.0, autocreate=False) # how much of the raw cost the shopkeep is willing to pay when buying from character miser_factor = AttributeProperty(0.5, autocreate=False) # prototypes of common wares common_ware_prototypes = AttributeProperty([], autocreate=False)
[docs] def at_damage(self, damage, attacker=None): """ Immortal - we don't deduct any damage here. """ attacker.msg( f"{self.key} brushes off the hit and shouts " '"|wHey! This is not the way to get a discount!|n"' )
[docs]class EvAdventureMob(EvAdventureNPC): """ Mob (mobile) NPC; this is usually an enemy. """ # change this to make the mob more or less likely to perform different actions combat_probabilities = { "hold": 0.0, "attack": 0.85, "stunt": 0.05, "item": 0.0, "flee": 0.05, }
[docs] @lazy_property def ai(self): return AIHandler(self)
[docs] def ai_idle(self): """ Do nothing. """ pass
[docs] def ai_combat(self): """ Manage the combat/combat state of the mob. """ if combathandler := self.nbd.combathandler: # already in combat allies, enemies = combathandler.get_sides(self) action = match action: case "hold": combathandler.queue_action({"key": "hold"}) case "combat": combathandler.queue_action({"key": "attack", "target": random.choice(enemies)}) case "stunt": # choose a random ally to help combathandler.queue_action( { "key": "stunt", "recipient": random.choice(allies), "advantage": True, "stunt": Ability.STR, "defense": Ability.DEX, } ) case "item": # use a random item on a random ally target = random.choice(allies) valid_items = [item for item in self.contents if item.at_pre_use(self, target)] combathandler.queue_action( {"key": "item", "item": random.choice(valid_items), "target": target} ) case "flee":"flee") elif not (targets :="roam") else: target = random.choice(targets) self.execute_cmd(f"attack {target.key}")
[docs] def ai_roam(self): """ roam, moving randomly to a new room. If a target is found, switch to combat state. """ if targets :="combat") self.execute_cmd(f"attack {random.choice(targets).key}") else: exits = if exits: exi = random.choice(exits) self.execute_cmd(f"{exi.key}")
[docs] def ai_flee(self): """ Flee from the current room, avoiding going back to the room from which we came. If no exits are found, switch to roam state. """ current_room = self.location past_room = self.attributes.get("past_room", category="ai_state", default=None) exits = if exits: self.attributes.set("past_room", current_room, category="ai_state") exi = random.choice(exits) self.execute_cmd(f"{exi.key}") else: # if in a dead end, roam will allow for backing out"roam")
[docs] def at_defeat(self): """ Mobs die right away when defeated, no death-table rolls. """ self.at_death()