squirrel-battle/squirrelbattle/entities/items.py

641 lines
20 KiB
Python
Raw Normal View History

2021-01-10 09:46:17 +00:00
# Copyright (C) 2020-2021 by ÿnérant, eichhornchen, nicomarg, charlse
2020-11-27 15:33:17 +00:00
# SPDX-License-Identifier: GPL-3.0-or-later
2020-12-05 13:20:58 +00:00
from random import choice, randint
2021-01-10 10:25:53 +00:00
from typing import Any, Optional
2020-11-11 15:47:19 +00:00
2021-01-10 10:25:53 +00:00
from ..interfaces import Entity, FightingEntity, InventoryHolder, Map
from ..translations import gettext as _
2020-11-06 14:33:26 +00:00
2020-10-23 14:51:48 +00:00
class Item(Entity):
"""
A class for items.
"""
2020-11-06 14:33:26 +00:00
held: bool
held_by: Optional[InventoryHolder]
price: int
2020-10-23 14:51:48 +00:00
def __init__(self, held: bool = False,
held_by: Optional[InventoryHolder] = None,
2020-12-11 17:17:08 +00:00
price: int = 2, *args, **kwargs):
2020-11-06 14:33:26 +00:00
super().__init__(*args, **kwargs)
self.held = held
self.held_by = held_by
self.price = price
2020-11-06 14:33:26 +00:00
2021-01-08 10:55:25 +00:00
@property
def description(self) -> str:
"""
In the inventory, indicate the usefulness of the item.
"""
return ""
2020-12-04 15:53:27 +00:00
def drop(self) -> None:
"""
The item is dropped from the inventory onto the floor.
"""
if self.held:
self.held_by.remove_from_inventory(self)
2020-12-11 17:33:47 +00:00
self.held_by.map.add_entity(self)
2020-12-04 15:53:27 +00:00
self.move(self.held_by.y, self.held_by.x)
self.held = False
self.held_by = None
2020-12-04 15:53:27 +00:00
def use(self) -> None:
"""
Indicates what should be done when the item is used.
"""
2021-01-08 17:06:26 +00:00
def throw(self, direction: int) -> None:
"""
Indicates what should be done when the item is thrown.
"""
2020-12-04 15:53:27 +00:00
def equip(self) -> None:
"""
Indicates what should be done when the item is equipped.
"""
2021-01-06 17:31:28 +00:00
# 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
2020-11-06 14:33:26 +00:00
2020-12-18 16:30:03 +00:00
def unequip(self) -> None:
"""
Indicates what should be done when the item is unequipped.
"""
2021-01-08 00:56:54 +00:00
self.held_by.remove_from_inventory(self)
2020-12-18 16:30:03 +00:00
self.held_by.add_to_inventory(self)
2020-11-06 14:33:26 +00:00
2020-12-18 16:30:03 +00:00
def hold(self, holder: InventoryHolder) -> None:
"""
The item is taken from the floor and put into the inventory.
"""
2020-10-23 14:51:48 +00:00
self.held = True
2020-12-18 16:30:03 +00:00
self.held_by = holder
2020-12-11 17:33:47 +00:00
self.held_by.map.remove_entity(self)
2020-12-18 16:30:03 +00:00
holder.add_to_inventory(self)
2020-10-23 16:02:57 +00:00
2020-11-18 23:10:37 +00:00
def save_state(self) -> dict:
"""
Saves the state of the item into a dictionary.
"""
d = super().save_state()
d["held"] = self.held
2020-11-18 23:10:37 +00:00
return d
2020-12-07 20:13:55 +00:00
@staticmethod
def get_all_items() -> list:
"""
Returns the list of all item classes.
"""
return [BodySnatchPotion, Bomb, Bow, Chestplate, FireBallStaff,
Heart, Helmet, Monocle, ScrollofDamage, ScrollofWeakening,
Shield, Sword, RingCritical, RingXP, Ruler]
2021-01-08 22:32:47 +00:00
def be_sold(self, buyer: InventoryHolder, seller: InventoryHolder,
for_free: bool = False) -> bool:
"""
Does all necessary actions when an object is to be sold.
2020-12-11 16:06:30 +00:00
Is overwritten by some classes that cannot exist in the player's
inventory.
"""
if for_free:
self.hold(buyer)
seller.remove_from_inventory(self)
return True
elif 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
2020-12-11 16:06:30 +00:00
else:
return False
2020-11-06 14:33:26 +00:00
2020-11-11 15:23:27 +00:00
class Heart(Item):
"""
A heart item to return health to the player.
"""
healing: int
2020-12-11 16:06:30 +00:00
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
2020-11-11 15:47:19 +00:00
2021-01-08 10:55:25 +00:00
@property
def description(self) -> str:
2021-01-08 11:06:28 +00:00
return f"HP+{self.healing}"
2021-01-08 10:55:25 +00:00
def hold(self, entity: InventoryHolder) -> None:
2020-11-11 15:47:19 +00:00
"""
When holding a heart, the player is healed and
the item is not put in the inventory.
2020-11-11 15:47:19 +00:00
"""
entity.health = min(entity.maxhealth, entity.health + self.healing)
entity.map.remove_entity(self)
2020-11-11 15:23:27 +00:00
2020-11-19 00:11:11 +00:00
def save_state(self) -> dict:
"""
Saves the state of the heart into a dictionary.
2020-11-19 00:11:11 +00:00
"""
d = super().save_state()
d["healing"] = self.healing
return d
2020-11-11 15:23:27 +00:00
2020-10-23 16:02:57 +00:00
class Bomb(Item):
"""
A bomb item intended to deal damage to enemies at long range
"""
2020-11-06 14:33:26 +00:00
damage: int = 5
exploding: bool
2020-12-18 16:30:03 +00:00
owner: Optional["InventoryHolder"]
2020-12-04 17:16:46 +00:00
tick: int
2020-10-23 16:02:57 +00:00
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
2020-12-04 17:16:46 +00:00
self.owner = None
2020-10-23 16:02:57 +00:00
2020-12-04 15:53:27 +00:00
def use(self) -> None:
"""
When the bomb is used, it is thrown and then it explodes.
2020-12-04 15:53:27 +00:00
"""
if self.held:
self.owner = self.held_by
2020-12-04 15:53:27 +00:00
super().drop()
self.exploding = True
2020-11-06 14:33:26 +00:00
def act(self, m: Map) -> None:
"""
Special exploding action of the bomb.
"""
2020-10-23 16:02:57 +00:00
if self.exploding:
2020-12-04 15:53:27 +00:00
if self.tick > 0:
# The bomb will explode in <tick> moves
2020-12-04 15:53:27 +00:00
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.")
2020-12-04 15:53:27 +00:00
for e in m.entities.copy():
if abs(e.x - self.x) + abs(e.y - self.y) <= 3 and \
2020-12-04 15:53:27 +00:00
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)
2020-12-04 15:53:27 +00:00
m.entities.remove(self)
2020-11-19 00:11:11 +00:00
# Add sparkles where the bomb exploded.
explosion = Explosion(y=self.y, x=self.x)
self.map.add_entity(explosion)
2020-11-19 00:11:11 +00:00
def save_state(self) -> dict:
"""
Saves the state of the bomb into a dictionary.
2020-11-19 00:11:11 +00:00
"""
d = super().save_state()
d["exploding"] = self.exploding
d["damage"] = self.damage
return d
2020-12-05 13:20:58 +00:00
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
2021-01-08 10:55:25 +00:00
@property
def description(self) -> str:
return f"STR+{self.damage}" if self.damage else super().description
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:
2020-12-18 16:39:11 +00:00
"""
When a weapon is equipped, the player gains strength.
2020-12-18 16:39:11 +00:00
"""
2021-01-06 17:31:28 +00:00
self.held_by.remove_from_inventory(self)
self.held_by.equipped_main = self
self.held_by.strength += self.damage
2020-12-18 16:39:11 +00:00
def unequip(self) -> None:
"""
Remove the strength earned by the weapon.
2020-12-18 16:39:11 +00:00
:return:
"""
super().unequip()
self.held_by.strength -= self.damage
2020-12-07 20:22:06 +00:00
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)
2021-01-08 21:25:00 +00:00
2021-01-08 17:06:26 +00:00
class Ruler(Weapon):
"""
A basic weapon
"""
def __init__(self, name: str = "ruler", price: int = 2,
damage: int = 1, *args, **kwargs):
2021-01-08 21:25:00 +00:00
super().__init__(name=name, price=price, damage=damage, *args, **kwargs)
class Armor(Item):
"""
Class of items that increase the player's constitution.
"""
constitution: int
2021-01-06 17:02:58 +00:00
def __init__(self, constitution: int, *args, **kwargs):
super().__init__(*args, **kwargs)
self.constitution = constitution
2021-01-08 10:55:25 +00:00
@property
def description(self) -> str:
return f"CON+{self.constitution}" if self.constitution \
else super().description
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
2020-12-07 20:22:06 +00:00
2021-01-06 17:02:58 +00:00
class Shield(Armor):
"""
Class of shield items, they can be equipped in the other hand.
"""
2021-01-06 17:02:58 +00:00
def __init__(self, name: str = "shield", constitution: int = 2,
2021-01-06 16:57:23 +00:00
price: int = 16, *args, **kwargs):
2021-01-06 17:31:28 +00:00
super().__init__(name=name, constitution=constitution, price=price,
*args, **kwargs)
2021-01-08 21:25:00 +00:00
class Helmet(Armor):
"""
Class of helmet items, they can be equipped on the head.
"""
2021-01-06 17:02:58 +00:00
def __init__(self, name: str = "helmet", constitution: int = 2,
2021-01-06 16:57:23 +00:00
price: int = 18, *args, **kwargs):
2021-01-06 17:31:28 +00:00
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
2021-01-08 21:25:00 +00:00
class Chestplate(Armor):
"""
Class of chestplate items, they can be equipped on the body.
"""
2021-01-06 17:02:58 +00:00
def __init__(self, name: str = "chestplate", constitution: int = 4,
2021-01-06 16:57:23 +00:00
price: int = 30, *args, **kwargs):
2021-01-06 17:31:28 +00:00
super().__init__(name=name, constitution=constitution, price=price,
*args, **kwargs)
2020-12-07 20:22:06 +00:00
2021-01-06 17:31:28 +00:00
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
2020-12-05 13:20:58 +00:00
2021-01-08 21:25:00 +00:00
2020-12-05 13:20:58 +00:00
class BodySnatchPotion(Item):
"""
The body-snatch potion allows to exchange all characteristics with a random
other entity.
"""
2020-12-11 16:06:30 +00:00
def __init__(self, name: str = "body_snatch_potion", price: int = 14,
*args, **kwargs):
super().__init__(name=name, price=price, *args, **kwargs)
2020-12-05 13:20:58 +00:00
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()
2020-12-05 13:20:58 +00:00
self.held_by.inventory.remove(self)
2021-01-06 17:02:58 +00:00
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
2021-01-06 17:02:58 +00:00
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
2021-01-08 10:55:25 +00:00
@property
def description(self) -> str:
fields = [("MAX HP", self.maxhealth), ("STR", self.strength),
("INT", self.intelligence), ("CHR", self.charisma),
("DEX", self.dexterity), ("CON", self.constitution),
("CRI", self.critical), ("XP", self.experience)]
return ", ".join(f"{key}+{value}" for key, value in fields if value)
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()
2021-01-08 00:56:54 +00:00
d["maxhealth"] = self.maxhealth
d["strength"] = self.strength
d["intelligence"] = self.intelligence
d["charisma"] = self.charisma
d["dexterity"] = self.dexterity
d["constitution"] = self.constitution
2021-01-08 00:56:54 +00:00
d["critical"] = self.critical
d["experience"] = self.experience
return d
2021-01-06 17:02:58 +00:00
class RingCritical(Ring):
def __init__(self, name: str = "ring_of_critical_damage", price: int = 15,
critical: int = 20, *args, **kwargs):
2021-01-06 17:02:58 +00:00
super().__init__(name=name, price=price, critical=critical,
*args, **kwargs)
2021-01-06 17:02:58 +00:00
class RingXP(Ring):
def __init__(self, name: str = "ring_of_more_experience", price: int = 25,
experience: float = 2, *args, **kwargs):
2021-01-06 17:02:58 +00:00
super().__init__(name=name, price=price, experience=experience,
*args, **kwargs)
2021-01-08 23:01:02 +00:00
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:
2021-01-08 21:25:00 +00:00
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)
2021-01-08 21:25:00 +00:00
class ScrollofWeakening(Item):
"""
2021-01-10 16:10:00 +00:00
A scroll that, when used, reduces the damage of the ennemies for 3 turns.
"""
def __init__(self, name: str = "scroll_of_weakening", price: int = 13,
*args, **kwargs):
super().__init__(name=name, price=price, *args, **kwargs)
def use(self) -> None:
"""
Find all entities and reduce their damage.
"""
for entity in self.held_by.map.entities:
2021-01-08 17:06:26 +00:00
if entity.is_fighting_entity() and not entity == self.held_by:
2021-01-08 21:25:00 +00:00
entity.strength = entity.strength - \
max(1, self.held_by.intelligence // 2)
entity.effects.append(["strength",
-max(1, self.held_by.intelligence // 2),
3])
self.held_by.map.logs.add_message(
_(f"The ennemies have -{max(1, self.held_by.intelligence // 2)}"
+ "strength for 3 turns"))
self.held_by.inventory.remove(self)
2021-01-08 17:06:26 +00:00
2021-01-08 21:25:00 +00:00
2021-01-10 17:09:09 +00:00
class LongRangeWeapon(Weapon):
def __init__(self, damage: int = 4,
rang: int = 3, *args, **kwargs):
super().__init__(*args, **kwargs)
2021-01-08 17:06:26 +00:00
self.damage = damage
self.range = rang
2021-01-08 18:18:29 +00:00
def throw(self, direction: int) -> Any:
2021-01-08 17:06:26 +00:00
to_kill = None
for entity in self.held_by.map.entities:
if entity.is_fighting_entity():
if direction == 0 and self.held_by.x == entity.x \
2021-01-08 21:25:00 +00:00
and self.held_by.y - entity.y > 0 and \
self.held_by.y - entity.y <= self.range:
2021-01-08 17:06:26 +00:00
to_kill = entity
elif direction == 2 and self.held_by.x == entity.x \
2021-01-08 21:25:00 +00:00
and entity.y - self.held_by.y > 0 and \
entity.y - self.held_by.y <= self.range:
2021-01-08 17:06:26 +00:00
to_kill = entity
elif direction == 1 and self.held_by.y == entity.y \
2021-01-08 21:25:00 +00:00
and entity.x - self.held_by.x > 0 and \
entity.x - self.held_by.x <= self.range:
2021-01-08 17:06:26 +00:00
to_kill = entity
elif direction == 3 and self.held_by.y == entity.y \
2021-01-08 21:25:00 +00:00
and self.held_by.x - entity.x > 0 and \
self.held_by.x - entity.x <= self.range:
2021-01-08 17:06:26 +00:00
to_kill = entity
if to_kill:
2021-01-08 21:25:00 +00:00
line = _("{name}").format(name=to_kill.translated_name.capitalize()
) + self.string + " "\
+ to_kill.take_damage(
self.held_by, self.damage
+ getattr(self.held_by, self.stat))
self.held_by.map.logs.add_message(line)
2021-01-08 18:18:29 +00:00
return (to_kill.x, to_kill.y) if to_kill else None
2021-01-08 17:06:26 +00:00
def equip(self) -> None:
"""
Equip the weapon.
2021-01-08 17:06:26 +00:00
"""
self.held_by.remove_from_inventory(self)
self.held_by.equipped_main = self
@property
def stat(self) -> str:
"""
The stat that is used when using the object: dexterity for a bow
or intelligence for a magic staff.
"""
2021-01-08 18:05:02 +00:00
@property
def string(self) -> str:
"""
The string that is printed when we hit an ennemy.
"""
2021-01-08 21:25:00 +00:00
class Bow(LongRangeWeapon):
"""
2021-01-08 21:25:00 +00:00
A type of long range weapon that deals damage
based on the player's dexterity
"""
def __init__(self, name: str = "bow", price: int = 22, damage: int = 4,
rang: int = 3, *args, **kwargs):
2021-01-08 21:25:00 +00:00
super().__init__(name=name, price=price, damage=damage,
rang=rang, *args, **kwargs)
@property
def stat(self) -> str:
"""
Here it is dexterity
"""
return "dexterity"
2021-01-08 18:05:02 +00:00
@property
def string(self) -> str:
return " is shot by an arrow."
2021-01-08 21:25:00 +00:00
2021-01-08 18:05:02 +00:00
class FireBallStaff(LongRangeWeapon):
"""
2021-01-08 21:25:00 +00:00
A type of powerful long range weapon that deals damage
based on the player's intelligence
2021-01-08 18:05:02 +00:00
"""
2021-01-08 21:25:00 +00:00
def __init__(self, name: str = "fire_ball_staff", price: int = 36,
2021-01-08 18:05:02 +00:00
damage: int = 6, rang: int = 4, *args, **kwargs):
2021-01-08 21:25:00 +00:00
super().__init__(name=name, price=price, damage=damage,
2021-01-08 18:05:02 +00:00
rang=rang, *args, **kwargs)
@property
def stat(self) -> str:
"""
2021-01-10 17:36:46 +00:00
Here it is intelligence
2021-01-08 18:05:02 +00:00
"""
return "intelligence"
@property
def string(self) -> str:
return " is shot by a fire ball."
2021-01-08 18:18:29 +00:00
def throw(self, direction: int) -> None:
"""
Adds an explosion animation when killing something.
"""
2021-01-08 21:25:00 +00:00
coord = super().throw(direction)
if coord:
x = coord[0]
y = coord[1]
2021-01-08 18:18:29 +00:00
explosion = Explosion(y=y, x=x)
self.held_by.map.add_entity(explosion)
class Monocle(Item):
def __init__(self, name: str = "monocle", price: int = 10,
*args, **kwargs):
2021-01-08 23:01:02 +00:00
super().__init__(name=name, price=price, *args, **kwargs)