177 lines
7.0 KiB
Python
177 lines
7.0 KiB
Python
# Copyright (C) 2020-2021 by ÿnérant, eichhornchen, nicomarg, charlse
|
|
# SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
from random import randint
|
|
from typing import Dict, Optional, Tuple
|
|
from math import log
|
|
|
|
from .items import Item
|
|
from ..interfaces import FightingEntity, InventoryHolder
|
|
from ..translations import gettext as _, Translator
|
|
|
|
|
|
class Player(InventoryHolder, FightingEntity):
|
|
"""
|
|
The class of the player.
|
|
"""
|
|
current_xp: int = 0
|
|
max_xp: int = 10
|
|
xp_buff: float = 1
|
|
paths: Dict[Tuple[int, int], Tuple[int, int]]
|
|
equipped_main: Optional[Item]
|
|
equipped_secondary: Optional[Item]
|
|
equipped_helmet: Optional[Item]
|
|
equipped_armor: Optional[Item]
|
|
|
|
def __init__(self, name: str = "player", maxhealth: int = 20,
|
|
strength: int = 5, intelligence: int = 1, charisma: int = 1,
|
|
dexterity: int = 1, constitution: int = 1, level: int = 1,
|
|
current_xp: int = 0, max_xp: int = 10, inventory: list = None,
|
|
hazel: int = 42, equipped_main: Optional[Item] = None,
|
|
equipped_armor: Optional[Item] = None, critical: int = 5,
|
|
equipped_secondary: Optional[Item] = None,
|
|
equipped_helmet: Optional[Item] = None, xp_buff: float = 1,
|
|
vision: int = 5, *args, **kwargs) -> None:
|
|
super().__init__(name=name, maxhealth=maxhealth, strength=strength,
|
|
intelligence=intelligence, charisma=charisma,
|
|
dexterity=dexterity, constitution=constitution,
|
|
level=level, critical=critical, *args, **kwargs)
|
|
self.current_xp = current_xp
|
|
self.max_xp = max_xp
|
|
self.xp_buff = xp_buff
|
|
self.inventory = self.translate_inventory(inventory or [])
|
|
self.paths = dict()
|
|
self.hazel = hazel
|
|
self.equipped_main = self.dict_to_item(equipped_main) \
|
|
if isinstance(equipped_main, dict) else equipped_main
|
|
self.equipped_armor = self.dict_to_item(equipped_armor) \
|
|
if isinstance(equipped_armor, dict) else equipped_armor
|
|
self.equipped_secondary = self.dict_to_item(equipped_secondary) \
|
|
if isinstance(equipped_secondary, dict) else equipped_secondary
|
|
self.equipped_helmet = self.dict_to_item(equipped_helmet) \
|
|
if isinstance(equipped_helmet, dict) else equipped_helmet
|
|
self.vision = vision
|
|
|
|
def move(self, y: int, x: int) -> None:
|
|
"""
|
|
Moves the view of the map (the point on which the camera is centered)
|
|
according to the moves of the player.
|
|
"""
|
|
super().move(y, x)
|
|
self.map.currenty = y
|
|
self.map.currentx = x
|
|
self.recalculate_paths()
|
|
self.map.compute_visibility(self.y, self.x, self.vision)
|
|
|
|
def dance(self) -> None:
|
|
"""
|
|
Dancing has a certain probability or making ennemies unable
|
|
to fight for 2 turns. That probability depends on the player's
|
|
charisma.
|
|
"""
|
|
diceroll = randint(1, 10)
|
|
found = False
|
|
if diceroll <= self.charisma:
|
|
for entity in self.map.entities:
|
|
if entity.is_fighting_entity() and not entity == self \
|
|
and entity.distance(self)<=3:
|
|
found = True
|
|
entity.confused = 1
|
|
entity.effects.append(["confused", 1, 3])
|
|
if found:
|
|
self.map.logs.add_message(_(
|
|
"It worked! Nearby ennemies will be confused for 3 turns."))
|
|
else:
|
|
self.map.logs.add_message(_(
|
|
"It worked, but there is no one nearby..."))
|
|
else:
|
|
self.map.logs.add_message(
|
|
_("The dance was not effective..."))
|
|
|
|
|
|
def level_up(self) -> None:
|
|
"""
|
|
Add as many levels as possible to the player.
|
|
"""
|
|
while self.current_xp > self.max_xp:
|
|
self.level += 1
|
|
self.current_xp -= self.max_xp
|
|
self.max_xp = self.level * 10
|
|
self.maxhealth += int(2*log(self.level)/log(2))
|
|
self.health = self.maxhealth
|
|
self.strength = self.strength + 1
|
|
if self.level % 3 == 0 :
|
|
self.dexterity += 1
|
|
self.constitution += 1
|
|
if self.level % 4 == 0 :
|
|
self.intelligence += 1
|
|
if self.level % 6 == 0 :
|
|
self.charisma += 1
|
|
if self.level % 10 == 0 and self.critical < 95:
|
|
self.critical += (100-self.charisma)//30
|
|
# TODO Remove it, that's only for fun
|
|
self.map.spawn_random_entities(randint(3 * self.level,
|
|
10 * self.level))
|
|
|
|
def add_xp(self, xp: int) -> None:
|
|
"""
|
|
Adds some experience to the player.
|
|
If the required amount is reached, the player levels up.
|
|
"""
|
|
self.current_xp += int(xp * self.xp_buff)
|
|
self.level_up()
|
|
|
|
def remove_from_inventory(self, obj: Item) -> None:
|
|
"""
|
|
Remove the given item from the inventory, even if the item is equipped.
|
|
"""
|
|
if obj == self.equipped_main:
|
|
self.equipped_main = None
|
|
elif obj == self.equipped_armor:
|
|
self.equipped_armor = None
|
|
elif obj == self.equipped_secondary:
|
|
self.equipped_secondary = None
|
|
elif obj == self.equipped_helmet:
|
|
self.equipped_helmet = None
|
|
else:
|
|
return super().remove_from_inventory(obj)
|
|
|
|
# noinspection PyTypeChecker,PyUnresolvedReferences
|
|
def check_move(self, y: int, x: int, move_if_possible: bool = False) \
|
|
-> bool:
|
|
"""
|
|
If the player tries to move but a fighting entity is there,
|
|
the player fights this entity.
|
|
If the entity dies, the player is rewarded with some XP
|
|
"""
|
|
# Don't move if we are dead
|
|
if self.dead:
|
|
return False
|
|
for entity in self.map.entities:
|
|
if entity.y == y and entity.x == x:
|
|
if entity.is_fighting_entity():
|
|
self.map.logs.add_message(self.hit(entity))
|
|
if entity.dead:
|
|
self.add_xp(randint(3, 7))
|
|
return True
|
|
elif entity.is_item():
|
|
entity.hold(self)
|
|
return super().check_move(y, x, move_if_possible)
|
|
|
|
def save_state(self) -> dict:
|
|
"""
|
|
Saves the state of the entity into a dictionary
|
|
"""
|
|
d = super().save_state()
|
|
d["current_xp"] = self.current_xp
|
|
d["max_xp"] = self.max_xp
|
|
d["equipped_main"] = self.equipped_main.save_state()\
|
|
if self.equipped_main else None
|
|
d["equipped_armor"] = self.equipped_armor.save_state()\
|
|
if self.equipped_armor else None
|
|
d["equipped_secondary"] = self.equipped_secondary.save_state()\
|
|
if self.equipped_secondary else None
|
|
d["equipped_helmet"] = self.equipped_helmet.save_state()\
|
|
if self.equipped_helmet else None
|
|
return d
|