"""
All items in the game inherit from a base object. The properties (what you can do
with an object, such as wear, wield, eat, drink, kill etc) are all controlled by
Tags.
Every object has one of a few `obj_type`-category tags:
- weapon
- armor
- shield
- helmet
- consumable (potions, torches etc)
- magic (runestones, magic items)
- quest (quest-items)
- treasure (valuable to sell)
It's possible for an item to have more than one tag, such as a golden helmet (helmet+treasure) or
rune sword (weapon+quest).
"""
from evennia import AttributeProperty, create_object, search_object
from evennia.objects.objects import DefaultObject
from evennia.utils.utils import make_iter
from . import rules
from .enums import Ability, ObjType, WieldLocation
from .utils import get_obj_stats
_BARE_HANDS = None
[docs]class EvAdventureObject(DefaultObject):
"""
Base in-game entity.
"""
# inventory management
inventory_use_slot = AttributeProperty(WieldLocation.BACKPACK)
# how many inventory slots it uses (can be a fraction)
size = AttributeProperty(1)
value = AttributeProperty(0)
# can also be an iterable, for adding multiple obj-type tags
obj_type = ObjType.GEAR
[docs] def at_object_creation(self):
for obj_type in make_iter(self.obj_type):
self.tags.add(obj_type.value, category="obj_type")
[docs] def get_display_desc(self, looker, **kwargs):
return get_obj_stats(self, owner=looker)
[docs] def has_obj_type(self, objtype):
"""
Check if object is of a particular type.
typeobj_enum (enum.ObjType): A type to check, like enums.TypeObj.TREASURE.
"""
return objtype.value in make_iter(self.obj_type)
[docs] def get_help(self):
"""
Get help text for the item.
Returns:
str: The help text, by default taken from the `.help_text` property.
"""
return "No help for this item."
[docs] def at_pre_use(self, *args, **kwargs):
"""
Called before use. If returning False, usage should be aborted.
"""
return True
[docs] def use(self, *args, **kwargs):
"""
Use this object, whatever that may mean.
"""
raise NotImplementedError
[docs] def at_post_use(self, *args, **kwargs):
"""
Called after use happened.
"""
pass
[docs]class EvAdventureObjectFiller(EvAdventureObject):
"""
In _Knave_, the inventory slots act as an extra measure of how you are affected by
various averse effects. For example, mud or water could fill up some of your inventory
slots and make the equipment there unusable until you cleaned it. Inventory is also
used to track how long you can stay under water etc - the fewer empty slots you have,
the less time you can stay under water due to carrying so much stuff with you.
This class represents such an effect filling up an empty slot. It has a quality of 0,
meaning it's unusable.
"""
obj_type = ObjType.QUEST.value # can't be sold
quality = AttributeProperty(0)
[docs]class EvAdventureQuestObject(EvAdventureObject):
"""
A quest object. These cannot be sold and only be used for quest resolution.
"""
obj_type = ObjType.QUEST
value = AttributeProperty(0)
[docs]class EvAdventureTreasure(EvAdventureObject):
"""
A 'treasure' is mainly useful to sell for coin.
"""
obj_type = ObjType.TREASURE
value = AttributeProperty(100, autocreate=False)
[docs]class EvAdventureConsumable(EvAdventureObject):
"""
Item that can be 'used up', like a potion or food. Weapons, armor etc does not
have a limited usage in this way.
"""
obj_type = ObjType.CONSUMABLE
size = AttributeProperty(0.25, autocreate=False)
uses = AttributeProperty(1, autocreate=False)
[docs] def at_pre_use(self, user, target=None, *args, **kwargs):
if target and user.location != target.location:
user.msg("You are not close enough to the target!")
return False
if self.uses <= 0:
user.msg(f"|w{self.key} is used up.|n")
return False
return super().at_pre_use(user, target=target, *args, **kwargs)
[docs] def use(self, user, target=None, *args, **kwargs):
"""
Use the consumable.
"""
if user.location:
user.location.msg_contents(
f"$You() $conj(use) {self.get_display_name(user)}.", from_obj=user
)
[docs] def at_post_use(self, user, *args, **kwargs):
"""
Called after this item was used.
Args:
user (Object): The one using the item.
*args, **kwargs: Optional arguments.
"""
self.uses -= 1
if self.uses <= 0:
user.msg(f"|w{self.key} was used up.|n")
self.delete()
[docs]class EvAdventureWeapon(EvAdventureObject):
"""
Base weapon class for all EvAdventure weapons.
"""
obj_type = ObjType.WEAPON
inventory_use_slot = AttributeProperty(WieldLocation.WEAPON_HAND)
quality = AttributeProperty(3)
# what ability used to attack with this weapon
attack_type = AttributeProperty(Ability.STR)
# what defense stat of the enemy it must defeat
defense_type = AttributeProperty(Ability.ARMOR)
damage_roll = AttributeProperty("1d6")
[docs] def get_display_name(self, looker=None, **kwargs):
quality = self.quality
quality_txt = ""
if quality <= 0:
quality_txt = "|r(broken!)|n"
elif quality < 2:
quality_txt = "|y(damaged)|n"
elif quality < 3:
quality_txt = "|Y(chipped)|n"
return super().get_display_name(looker=looker, **kwargs) + quality_txt
[docs] def at_pre_use(self, user, target=None, *args, **kwargs):
if target and user.location != target.location:
# we assume weapons can only be used in the same location
user.msg("You are not close enough to the target!")
return False
if self.quality is not None and self.quality <= 0:
user.msg(f"{self.get_display_name(user)} is broken and can't be used!")
return False
return super().at_pre_use(user, target=target, *args, **kwargs)
[docs] def use(self, attacker, target, *args, advantage=False, disadvantage=False, **kwargs):
"""When a weapon is used, it attacks an opponent"""
location = attacker.location
is_hit, quality, txt = rules.dice.opposed_saving_throw(
attacker,
target,
attack_type=self.attack_type,
defense_type=self.defense_type,
advantage=advantage,
disadvantage=disadvantage,
)
location.msg_contents(
f"$You() $conj(attack) $You({target.key}) with {self.key}: {txt}",
from_obj=attacker,
mapping={target.key: target},
)
if is_hit:
# enemy hit, calculate damage
dmg = rules.dice.roll(self.damage_roll)
if quality is Ability.CRITICAL_SUCCESS:
# doble damage roll for critical success
dmg += rules.dice.roll(self.damage_roll)
message = (
f" $You() |ycritically|n $conj(hit) $You({target.key}) for |r{dmg}|n damage!"
)
else:
message = f" $You() $conj(hit) $You({target.key}) for |r{dmg}|n damage!"
location.msg_contents(message, from_obj=attacker, mapping={target.key: target})
# call hook
target.at_damage(dmg, attacker=attacker)
else:
# a miss
message = f" $You() $conj(miss) $You({target.key})."
if quality is Ability.CRITICAL_FAILURE:
message += ".. it's a |rcritical miss!|n, damaging the weapon."
if self.quality is not None:
self.quality -= 1
location.msg_contents(message, from_obj=attacker, mapping={target.key: target})
[docs] def at_post_use(self, user, *args, **kwargs):
if self.quality is not None and self.quality <= 0:
user.msg(f"|r{self.get_display_name(user)} breaks and can no longer be used!")
[docs]class EvAdventureThrowable(EvAdventureWeapon, EvAdventureConsumable):
"""
Something you can throw at an enemy to harm them once, like a knife or exploding potion/grenade.
Note: In Knave, ranged attacks are done with WIS (representing the stillness of your mind?)
"""
obj_type = (ObjType.THROWABLE, ObjType.WEAPON, ObjType.CONSUMABLE)
attack_type = AttributeProperty(Ability.WIS)
defense_type = AttributeProperty(Ability.DEX)
damage_roll = AttributeProperty("1d6")
[docs]class EvAdventureRunestone(EvAdventureWeapon, EvAdventureConsumable):
"""
Base class for magic runestones. In _Knave_, every spell is represented by a rune stone
that takes up an inventory slot. It is wielded as a weapon in order to create the specific
magical effect provided by the stone. Normally each stone can only be used once per day but
they are quite powerful (and scales with caster level).
"""
obj_type = (ObjType.WEAPON, ObjType.MAGIC)
inventory_use_slot = WieldLocation.TWO_HANDS
quality = AttributeProperty(3)
attack_type = AttributeProperty(Ability.INT)
defense_type = AttributeProperty(Ability.DEX)
damage_roll = AttributeProperty("1d8")
[docs] def at_post_use(self, user, *args, **kwargs):
"""Called after the spell was cast"""
self.uses -= 1
# the rune stone is not deleted after use, but
# it needs to be refreshed after resting.
[docs] def refresh(self):
self.uses = 1
[docs]class EvAdventureArmor(EvAdventureObject):
"""
Base class for all wearable Armors.
"""
obj_type = ObjType.ARMOR
inventory_use_slot = WieldLocation.BODY
armor = AttributeProperty(1)
quality = AttributeProperty(3)
[docs]class EvAdventureShield(EvAdventureArmor):
"""
Base class for all Shields.
"""
obj_type = ObjType.SHIELD
inventory_use_slot = WieldLocation.SHIELD_HAND
[docs]class EvAdventureHelmet(EvAdventureArmor):
"""
Base class for all Helmets.
"""
obj_type = ObjType.HELMET
inventory_use_slot = WieldLocation.HEAD
[docs]class WeaponBareHands(EvAdventureWeapon):
"""
This is a dummy-class loaded when you wield no weapons. We won't create any db-object for it.
"""
obj_type = ObjType.WEAPON
key = "Bare hands"
inventory_use_slot = WieldLocation.WEAPON_HAND
attack_type = Ability.STR
defense_type = Ability.ARMOR
damage_roll = "1d4"
quality = None # let's assume fists are always available ...
[docs]def get_bare_hands():
"""
Get the bare-hands singleton object.
Returns:
WeaponBareHands
"""
global _BARE_HANDS
if not _BARE_HANDS:
_BARE_HANDS = search_object("Bare hands", typeclass=WeaponBareHands).first()
if not _BARE_HANDS:
_BARE_HANDS = create_object(WeaponBareHands, key="Bare hands")
return _BARE_HANDS
