|
5 | 5 | """ |
6 | 6 |
|
7 | 7 | import random |
| 8 | +from tale import weapon_type |
8 | 9 | import tale.util as util |
9 | 10 | import tale.base as base |
10 | 11 | from tale.util import Context |
11 | 12 |
|
12 | | -def resolve_attack(attacker, victim): |
13 | | - damage_to_attacker, damage_to_defender = combat(attacker, victim) |
14 | | - text = 'After a fierce exchange of attacks ' |
15 | | - if damage_to_attacker > 0: |
16 | | - text = text + f', {attacker.title} is injured ' |
17 | | - if damage_to_defender > 0: |
18 | | - text = text + f', {victim.title} is injured ' |
19 | | - if victim.stats.hp - damage_to_defender < 1: |
20 | | - text = text + f', {victim.title} dies.' |
21 | | - if attacker.stats.hp - damage_to_attacker < 1: |
22 | | - text = text + f', {attacker.title} dies.' |
23 | | - |
24 | | - return text, damage_to_attacker, damage_to_defender |
25 | | - |
26 | | -def combat(actor1: 'base.Living', actor2: 'base.Living'): |
27 | | - """ Simple combat, but rather complex logic. Credit to ChatGPT.""" |
28 | | - |
29 | | - def calculate_attack(actor: 'base.Living'): |
30 | | - # The attack strength depends on the level and strength of the actor |
31 | | - return actor.stats.level * actor.stats.dexterity |
32 | | - |
33 | | - def calculate_defense(actor: 'base.Living'): |
34 | | - # The defense strength depends on the level and dexterity of the actor |
35 | | - return actor.stats.level * actor.stats.dexterity |
36 | | - |
37 | | - def calculate_weapon_bonus(actor: 'base.Living'): |
38 | | - # The weapon bonus is a random factor between 0 and 1. If the actor has no weapon, bonus is 1. |
39 | | - return actor.stats.wc + 1 |
40 | | - |
41 | | - def calculate_armor_bonus(actor: 'base.Living'): |
42 | | - # The armor bonus is a random factor between 0 and 1. If the actor has no armor, bonus is 1. |
43 | | - return actor.stats.ac + 1 |
| 13 | +class Combat(): |
44 | 14 |
|
45 | | - def calculate_damage(attacker: 'base.Living', defender: 'base.Living'): |
46 | | - # Calculate the damage done by the attacker to the defender |
47 | | - attack_strength = calculate_attack(attacker) * calculate_weapon_bonus(attacker) * attacker.stats.strength * attacker.stats.size.order |
48 | | - defense_strength = calculate_defense(defender) * calculate_armor_bonus(defender) * defender.stats.strength * defender.stats.size.order |
49 | | - damage = max(0, attack_strength - defense_strength) |
50 | | - return damage |
51 | | - |
52 | | - # Calculate the chances of actor1 and actor2 winning |
53 | | - damage_to_actor1 = calculate_damage(actor2, actor1) |
54 | | - damage_to_actor2 = calculate_damage(actor1, actor2) |
| 15 | + def __init__(self, attacker: 'base.Living', defender: 'base.Living') -> None: |
| 16 | + self.attacker = attacker |
| 17 | + self.defender = defender |
| 18 | + |
| 19 | + def _calculate_attack_success(self, actor: 'base.Living') -> int: |
| 20 | + """ Calculate the success of an attack. <5 is a critical hit.""" |
| 21 | + return random.randrange(0, 100) - actor.stats.get_weapon_skill(actor.wielding.type) |
| 22 | + |
| 23 | + def _calculate_block_success(self, actor1: 'base.Living', actor2: 'base.Living') -> int: |
| 24 | + """ Calculate the chance of blocking an attack. |
| 25 | + If the attacker is wielding a ranged weapon, the defender can't block. |
| 26 | + If the defender is wielding a ranged weapon, the defender can't block. |
| 27 | + """ |
| 28 | + if actor1.wielding.type in weapon_type.ranged: |
| 29 | + # can't block ranged weapons |
| 30 | + return 100 |
| 31 | + if actor2.wielding.type in weapon_type.ranged: |
| 32 | + # can't block with a ranged weapon |
| 33 | + return 100 |
| 34 | + return random.randrange(0, 100) - actor2.stats.get_weapon_skill(actor2.wielding.type) |
| 35 | + |
| 36 | + def _calculate_weapon_bonus(self, actor: 'base.Living'): |
| 37 | + weapon = actor.wielding |
| 38 | + return actor.stats.wc + 1 + random.randint(1, weapon.base_damage) + weapon.bonus_damage |
55 | 39 |
|
56 | | - # Use some randomness to introduce unpredictability |
57 | | - damage_to_actor1 *= random.uniform(0.9, 1.1) |
58 | | - damage_to_actor2 *= random.uniform(0.9, 1.1) |
| 40 | + def _calculate_armor_bonus(self, actor: 'base.Living'): |
| 41 | + return actor.stats.ac + 1 |
| 42 | + |
| 43 | + def resolve_attack(self) -> (str, int, int): |
| 44 | + """ Both attacker and defender attack each other once. |
| 45 | + They get a chance to block, unless it's a critical hit, 5/100. |
| 46 | + Returns a textual representation of the combat and the damage done to each actor. |
| 47 | + """ |
| 48 | + texts = [] |
| 49 | + damage_to_defender = 0 |
| 50 | + damage_to_attacker = 0 |
| 51 | + |
| 52 | + text_result, damage_to_defender = self._round(self.attacker, self.defender) |
| 53 | + texts.extend(text_result) |
59 | 54 |
|
60 | | - return int(damage_to_actor1), int(damage_to_actor2) |
| 55 | + text_result, damage_to_attacker = self._round(self.defender, self.attacker) |
| 56 | + texts.extend(text_result) |
| 57 | + |
| 58 | + return ', '.join(texts), damage_to_attacker, damage_to_defender |
61 | 59 |
|
| 60 | + def _round(self, actor1: 'base.Living', actor2: 'base.Living') -> ([str], int): |
| 61 | + attack_result = self._calculate_attack_success(actor1) |
| 62 | + texts = [] |
| 63 | + if attack_result < 0: |
| 64 | + if attack_result < -actor1.stats.get_weapon_skill(actor1.wielding.type) + 5: |
| 65 | + texts.append(f'{actor1.title} performs a critical hit') |
| 66 | + block_result = 100 |
| 67 | + else: |
| 68 | + texts.append(f'{actor1.title} hits') |
| 69 | + block_result = self._calculate_block_success(actor1, actor2) |
| 70 | + |
| 71 | + if block_result < 0: |
| 72 | + texts.append(f'{actor2.title} blocks') |
| 73 | + else: |
| 74 | + actor1_strength = self._calculate_weapon_bonus(actor1) * actor1.stats.size.order |
| 75 | + actor2_strength = self._calculate_armor_bonus(actor2) * actor2.stats.size.order |
| 76 | + damage_to_defender = int(max(0, actor1_strength - actor2_strength)) |
| 77 | + if damage_to_defender > 0: |
| 78 | + texts.append(f', {actor2.title} is injured') |
| 79 | + else: |
| 80 | + texts.append(f', {actor2.title} is unharmed') |
| 81 | + if actor2.stats.hp - damage_to_defender < 1: |
| 82 | + texts.append(f', {actor2.title} dies') |
| 83 | + return texts, damage_to_defender |
| 84 | + elif attack_result > 50: |
| 85 | + texts.append(f'{actor1.title} misses completely') |
| 86 | + elif attack_result > 25: |
| 87 | + texts.append(f'{actor1.title} misses') |
| 88 | + else: |
| 89 | + texts.append(f'{actor1.title} barely misses') |
| 90 | + return texts, 0 |
62 | 91 |
|
63 | 92 | def produce_remains(context: Context, actor: 'base.Living'): |
64 | | - # Produce the remains of the actor |
| 93 | + """ Creates a container with the inventory of the Living |
| 94 | + and places it in the living's location. |
| 95 | + """ |
65 | 96 | remains = base.Container(f"remains of {actor.title}") |
66 | 97 | remains.init_inventory(actor.inventory) |
67 | 98 | actor.location.insert(remains, None) |
|
0 commit comments