446 lines
14 KiB
Python
446 lines
14 KiB
Python
# Copyright (C) 2020 by ÿnérant, eichhornchen, nicomarg, charlse
|
|
# SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
from random import choice, randint
|
|
from typing import Optional
|
|
|
|
from ..interfaces import Entity, FightingEntity, Map, InventoryHolder
|
|
from ..translations import gettext as _
|
|
|
|
|
|
class Item(Entity):
|
|
"""
|
|
A class for items.
|
|
"""
|
|
held: bool
|
|
held_by: Optional[InventoryHolder]
|
|
price: int
|
|
|
|
def __init__(self, held: bool = False,
|
|
held_by: Optional[InventoryHolder] = None,
|
|
price: int = 2, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
self.held = held
|
|
self.held_by = held_by
|
|
self.price = price
|
|
|
|
def drop(self) -> None:
|
|
"""
|
|
The item is dropped from the inventory onto the floor.
|
|
"""
|
|
if self.held:
|
|
self.held_by.remove_from_inventory(self)
|
|
self.held_by.map.add_entity(self)
|
|
self.move(self.held_by.y, self.held_by.x)
|
|
self.held = False
|
|
self.held_by = None
|
|
|
|
def use(self) -> None:
|
|
"""
|
|
Indicates what should be done when the item is used.
|
|
"""
|
|
|
|
def equip(self) -> None:
|
|
"""
|
|
Indicates what should be done when the item is equipped.
|
|
"""
|
|
# Other objects are only equipped as secondary.
|
|
if self.held_by.equipped_secondary:
|
|
self.held_by.equipped_secondary.unequip()
|
|
self.held_by.remove_from_inventory(self)
|
|
self.held_by.equipped_secondary = self
|
|
|
|
def unequip(self) -> None:
|
|
"""
|
|
Indicates what should be done when the item is unequipped.
|
|
"""
|
|
self.held_by.remove_from_inventory(self)
|
|
self.held_by.add_to_inventory(self)
|
|
|
|
def hold(self, holder: InventoryHolder) -> None:
|
|
"""
|
|
The item is taken from the floor and put into the inventory.
|
|
"""
|
|
self.held = True
|
|
self.held_by = holder
|
|
self.held_by.map.remove_entity(self)
|
|
holder.add_to_inventory(self)
|
|
|
|
def save_state(self) -> dict:
|
|
"""
|
|
Saves the state of the item into a dictionary.
|
|
"""
|
|
d = super().save_state()
|
|
d["held"] = self.held
|
|
return d
|
|
|
|
@staticmethod
|
|
def get_all_items() -> list:
|
|
"""
|
|
Returns the list of all item classes.
|
|
"""
|
|
return [BodySnatchPotion, Bomb, Heart, Shield, Sword,\
|
|
Chestplate, Helmet, RingCritical, RingXP]
|
|
|
|
def be_sold(self, buyer: InventoryHolder, seller: InventoryHolder) -> bool:
|
|
"""
|
|
Does all necessary actions when an object is to be sold.
|
|
Is overwritten by some classes that cannot exist in the player's
|
|
inventory.
|
|
"""
|
|
if buyer.hazel >= self.price:
|
|
self.hold(buyer)
|
|
seller.remove_from_inventory(self)
|
|
buyer.change_hazel_balance(-self.price)
|
|
seller.change_hazel_balance(self.price)
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
|
|
class Heart(Item):
|
|
"""
|
|
A heart item to return health to the player.
|
|
"""
|
|
healing: int
|
|
|
|
def __init__(self, name: str = "heart", healing: int = 5, price: int = 3,
|
|
*args, **kwargs):
|
|
super().__init__(name=name, price=price, *args, **kwargs)
|
|
self.healing = healing
|
|
|
|
def hold(self, entity: InventoryHolder) -> None:
|
|
"""
|
|
When holding a heart, the player is healed and
|
|
the item is not put in the inventory.
|
|
"""
|
|
entity.health = min(entity.maxhealth, entity.health + self.healing)
|
|
entity.map.remove_entity(self)
|
|
|
|
def save_state(self) -> dict:
|
|
"""
|
|
Saves the state of the heart into a dictionary.
|
|
"""
|
|
d = super().save_state()
|
|
d["healing"] = self.healing
|
|
return d
|
|
|
|
|
|
class Bomb(Item):
|
|
"""
|
|
A bomb item intended to deal damage to enemies at long range
|
|
"""
|
|
damage: int = 5
|
|
exploding: bool
|
|
owner: Optional["InventoryHolder"]
|
|
tick: int
|
|
|
|
def __init__(self, name: str = "bomb", damage: int = 5,
|
|
exploding: bool = False, price: int = 4, *args, **kwargs):
|
|
super().__init__(name=name, price=price, *args, **kwargs)
|
|
self.damage = damage
|
|
self.exploding = exploding
|
|
self.tick = 4
|
|
self.owner = None
|
|
|
|
def use(self) -> None:
|
|
"""
|
|
When the bomb is used, it is thrown and then it explodes.
|
|
"""
|
|
if self.held:
|
|
self.owner = self.held_by
|
|
super().drop()
|
|
self.exploding = True
|
|
|
|
def act(self, m: Map) -> None:
|
|
"""
|
|
Special exploding action of the bomb.
|
|
"""
|
|
if self.exploding:
|
|
if self.tick > 0:
|
|
# The bomb will explode in <tick> moves
|
|
self.tick -= 1
|
|
else:
|
|
# The bomb is exploding.
|
|
# Each entity that is close to the bomb takes damages.
|
|
# The player earn XP if the entity was killed.
|
|
log_message = _("Bomb is exploding.")
|
|
for e in m.entities.copy():
|
|
if abs(e.x - self.x) + abs(e.y - self.y) <= 3 and \
|
|
isinstance(e, FightingEntity):
|
|
log_message += " " + e.take_damage(self, self.damage)
|
|
if e.dead:
|
|
self.owner.add_xp(randint(3, 7))
|
|
m.logs.add_message(log_message)
|
|
m.entities.remove(self)
|
|
|
|
# Add sparkles where the bomb exploded.
|
|
explosion = Explosion(y=self.y, x=self.x)
|
|
self.map.add_entity(explosion)
|
|
|
|
def save_state(self) -> dict:
|
|
"""
|
|
Saves the state of the bomb into a dictionary.
|
|
"""
|
|
d = super().save_state()
|
|
d["exploding"] = self.exploding
|
|
d["damage"] = self.damage
|
|
return d
|
|
|
|
|
|
class Explosion(Item):
|
|
"""
|
|
When a bomb explodes, the explosion is displayed.
|
|
"""
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(name="explosion", *args, **kwargs)
|
|
|
|
def act(self, m: Map) -> None:
|
|
"""
|
|
The bomb disappears after exploding.
|
|
"""
|
|
m.remove_entity(self)
|
|
|
|
def hold(self, player: InventoryHolder) -> None:
|
|
"""
|
|
The player can't hold an explosion.
|
|
"""
|
|
|
|
|
|
class Weapon(Item):
|
|
"""
|
|
Non-throwable items that improve player damage
|
|
"""
|
|
damage: int
|
|
|
|
def __init__(self, damage: int = 3, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
self.damage = damage
|
|
|
|
def save_state(self) -> dict:
|
|
"""
|
|
Saves the state of the weapon into a dictionary
|
|
"""
|
|
d = super().save_state()
|
|
d["damage"] = self.damage
|
|
return d
|
|
|
|
def equip(self) -> None:
|
|
"""
|
|
When a weapon is equipped, the player gains strength.
|
|
"""
|
|
self.held_by.remove_from_inventory(self)
|
|
self.held_by.equipped_main = self
|
|
self.held_by.strength += self.damage
|
|
|
|
def unequip(self) -> None:
|
|
"""
|
|
Remove the strength earned by the weapon.
|
|
:return:
|
|
"""
|
|
super().unequip()
|
|
self.held_by.strength -= self.damage
|
|
|
|
|
|
class Sword(Weapon):
|
|
"""
|
|
A basic weapon
|
|
"""
|
|
def __init__(self, name: str = "sword", price: int = 20,
|
|
*args, **kwargs):
|
|
super().__init__(name=name, price=price, *args, **kwargs)
|
|
|
|
|
|
class Armor(Item):
|
|
"""
|
|
Class of items that increase the player's constitution.
|
|
"""
|
|
constitution: int
|
|
|
|
def __init__(self, constitution: int, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
self.constitution = constitution
|
|
|
|
def equip(self) -> None:
|
|
super().equip()
|
|
self.held_by.constitution += self.constitution
|
|
|
|
def unequip(self) -> None:
|
|
super().unequip()
|
|
self.held_by.constitution -= self.constitution
|
|
|
|
def save_state(self) -> dict:
|
|
d = super().save_state()
|
|
d["constitution"] = self.constitution
|
|
return d
|
|
|
|
|
|
class Shield(Armor):
|
|
"""
|
|
Class of shield items, they can be equipped in the other hand.
|
|
"""
|
|
def __init__(self, name: str = "shield", constitution: int = 2,
|
|
price: int = 16, *args, **kwargs):
|
|
super().__init__(name=name, constitution=constitution, price=price,
|
|
*args, **kwargs)
|
|
|
|
class Helmet(Armor):
|
|
"""
|
|
Class of helmet items, they can be equipped on the head.
|
|
"""
|
|
def __init__(self, name: str = "helmet", constitution: int = 2,
|
|
price: int = 18, *args, **kwargs):
|
|
super().__init__(name=name, constitution=constitution, price=price,
|
|
*args, **kwargs)
|
|
|
|
def equip(self) -> None:
|
|
if self.held_by.equipped_helmet:
|
|
self.held_by.equipped_helmet.unequip()
|
|
self.held_by.remove_from_inventory(self)
|
|
self.held_by.equipped_helmet = self
|
|
|
|
class Chestplate(Armor):
|
|
"""
|
|
Class of chestplate items, they can be equipped on the body.
|
|
"""
|
|
def __init__(self, name: str = "chestplate", constitution: int = 4,
|
|
price: int = 30, *args, **kwargs):
|
|
super().__init__(name=name, constitution=constitution, price=price,
|
|
*args, **kwargs)
|
|
|
|
def equip(self) -> None:
|
|
if self.held_by.equipped_armor:
|
|
self.held_by.equipped_armor.unequip()
|
|
self.held_by.remove_from_inventory(self)
|
|
self.held_by.equipped_armor = self
|
|
|
|
class BodySnatchPotion(Item):
|
|
"""
|
|
The body-snatch potion allows to exchange all characteristics with a random
|
|
other entity.
|
|
"""
|
|
|
|
def __init__(self, name: str = "body_snatch_potion", price: int = 14,
|
|
*args, **kwargs):
|
|
super().__init__(name=name, price=price, *args, **kwargs)
|
|
|
|
def use(self) -> None:
|
|
"""
|
|
Find a valid random entity, then exchange characteristics.
|
|
"""
|
|
valid_entities = self.held_by.map.find_entities(FightingEntity)
|
|
valid_entities.remove(self.held_by)
|
|
entity = choice(valid_entities)
|
|
entity_state = entity.save_state()
|
|
player_state = self.held_by.save_state()
|
|
self.held_by.__dict__.update(entity_state)
|
|
entity.__dict__.update(player_state)
|
|
self.held_by.map.currenty, self.held_by.map.currentx = self.held_by.y,\
|
|
self.held_by.x
|
|
|
|
self.held_by.map.logs.add_message(
|
|
_("{player} exchanged its body with {entity}.").format(
|
|
player=self.held_by.translated_name.capitalize(),
|
|
entity=entity.translated_name))
|
|
|
|
self.held_by.recalculate_paths()
|
|
|
|
self.held_by.inventory.remove(self)
|
|
|
|
|
|
class Ring(Item):
|
|
"""
|
|
A class of rings that boost the player's statistics.
|
|
"""
|
|
maxhealth: int
|
|
strength: int
|
|
intelligence: int
|
|
charisma: int
|
|
dexterity: int
|
|
constitution: int
|
|
critical: int
|
|
experience: float
|
|
|
|
def __init__(self, maxhealth: int = 0, strength: int = 0,
|
|
intelligence: int = 0, charisma: int = 0,
|
|
dexterity: int = 0, constitution: int = 0,
|
|
critical: int = 0, experience: float = 0, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
self.maxhealth = maxhealth
|
|
self.strength = strength
|
|
self.intelligence = intelligence
|
|
self.charisma = charisma
|
|
self.dexterity = dexterity
|
|
self.constitution = constitution
|
|
self.critical = critical
|
|
self.experience = experience
|
|
|
|
def equip(self) -> None:
|
|
super().equip()
|
|
self.held_by.maxhealth += self.maxhealth
|
|
self.held_by.strength += self.strength
|
|
self.held_by.intelligence += self.intelligence
|
|
self.held_by.charisma += self.charisma
|
|
self.held_by.dexterity += self.dexterity
|
|
self.held_by.constitution += self.constitution
|
|
self.held_by.critical += self.critical
|
|
self.held_by.xp_buff += self.experience
|
|
|
|
def unequip(self) -> None:
|
|
super().unequip()
|
|
self.held_by.maxhealth -= self.maxhealth
|
|
self.held_by.strength -= self.strength
|
|
self.held_by.intelligence -= self.intelligence
|
|
self.held_by.charisma -= self.charisma
|
|
self.held_by.dexterity -= self.dexterity
|
|
self.held_by.constitution -= self.constitution
|
|
self.held_by.critical -= self.critical
|
|
self.held_by.xp_buff -= self.experience
|
|
|
|
def save_state(self) -> dict:
|
|
d = super().save_state()
|
|
d["maxhealth"] = self.maxhealth
|
|
d["strength"] = self.strength
|
|
d["intelligence"] = self.intelligence
|
|
d["charisma"] = self.charisma
|
|
d["dexterity"] = self.dexterity
|
|
d["constitution"] = self.constitution
|
|
d["critical"] = self.critical
|
|
d["experience"] = self.experience
|
|
return d
|
|
|
|
|
|
class RingCritical(Ring):
|
|
def __init__(self, name: str = "ring_of_critical_damage", price: int = 15,
|
|
critical: int = 20, *args, **kwargs):
|
|
super().__init__(name=name, price=price, critical=critical,
|
|
*args, **kwargs)
|
|
|
|
|
|
class RingXP(Ring):
|
|
def __init__(self, name: str = "ring_of_more_experience", price: int = 25,
|
|
experience: float = 2, *args, **kwargs):
|
|
super().__init__(name=name, price=price, experience=experience,
|
|
*args, **kwargs)
|
|
|
|
class ScrollofDamage(Item):
|
|
"""
|
|
A scroll that, when used, deals damage to all entities in a certain radius.
|
|
"""
|
|
|
|
def __init__(self, name: str = "scroll_of_damage", price: int = 18,
|
|
*args, **kwargs):
|
|
super().__init__(name=name, price=price, *args, **kwargs)
|
|
|
|
def use(self) -> None:
|
|
"""
|
|
Find all entities within a radius of 5, and deal damage based on the
|
|
player's intelligence.
|
|
"""
|
|
for entity in self.held_by.map.entities:
|
|
if entity.is_fighting_entity() and not entity == self.held_by:
|
|
if entity.distance(self.held_by)<=5:
|
|
self.held_by.map.logs.add_message(entity.take_damage(\
|
|
self.held_by, self.held_by.intelligence))
|
|
self.held_by.inventory.remove(self)
|