Merge pull request #81 from neph1/update-v0.29.1

Update v0.29.1

Author: neph1

llm_config.yaml

@@ -19,7 +19,7 @@ ITEM_TYPES: ["Weapon", "Wearable", "Health", "Money", "Trash", "Food", "Drink",
 PRE_PROMPT: 'You are a creative game keeper for a role playing game (RPG). You craft detailed worlds and interesting characters with unique and deep personalities for the player to interact with.'
 BASE_PROMPT: '<context>{context}</context>\n[USER_START]Rewrite [{input_text}] in your own words using the information found inside the <context> tags to create a background for your text. Use about {max_words} words.'
 DIALOGUE_PROMPT: '<context>{context}</context>\nThe following is a conversation between {character1} and {character2}; {character2}s sentiment towards {character1}: {sentiment}. Write a single response as {character2} in third person pov, using {character2} description and other information found inside the <context> tags. If {character2} has a quest active, they will discuss it based on its status. Respond in JSON using this template: """{dialogue_template}""". [USER_START]Continue the following conversation as {character2}: {previous_conversation}'
-COMBAT_PROMPT: 'The following is a combat scene between user {attacker} and {victim} in {location} into a vivid description. [USER_START] Rewrite the following combat result in about 150 words, using the characters weapons and their health status: 1.0 is highest, 0.0 is lowest. Combat Result: {input_text}'
+COMBAT_PROMPT: '<context>{context}</context>\nThe following is a combat scene between {attackers} and {defenders} in {location}. [USER_START] Describe the following combat result in about 150 words in vivid language, using the characters weapons and their health status: 1.0 is highest, 0.0 is lowest. Combat Result: {input_text}'
 PRE_JSON_PROMPT: 'Below is an instruction that describes a task, paired with an input that provides further context. Write a response in valid JSON format that appropriately completes the request.'
 CREATE_CHARACTER_PROMPT: '<context>{context}</context>\n[USER_START] Create a diverse character with rich personality that can be interacted with using the story context and keywords. {{quest_prompt}} Do not mention height. keywords: {keywords}. Fill in this JSON template and write nothing else: {character_template}'
 CREATE_LOCATION_PROMPT: '<context>{context}</context>\nZone info: {zone_info}; Exit json example: {exit_template};  Npc or mob example: {npc_template}. Existing connected locations: {exit_locations}. [USER_START] Using the information supplied inside the <context> tags, describe the following location: {location_name}. {items_prompt} {spawn_prompt} Add a brief description, and one to three additional exits leading to new locations. Fill in this JSON template and do not write anything else: {location_template}. Write the response in valid JSON.'

tale/base.py

@@ -1423,39 +1423,43 @@ def start_attack(self, defender: 'Living', target_body_part: wearable.WearLocati
         """Starts attacking the given living for one round."""
         attacker_name = lang.capital(self.title)
         victim_name = lang.capital(defender.title)
-        c = combat.Combat(self, defender, target_body_part=target_body_part)
-        result, damage_to_attacker, damage_to_defender = c.resolve_attack()
+        attackers = [self]
+        defenders = [defender]
+        for living in defender.location.livings:
+            if living.following is self:
+                attackers.append(living)
+            elif living.following is defender:
+                defenders.append(living)
+
+        c = combat.Combat(attackers, defenders, target_body_part=target_body_part)
+        result = c.resolve_attack()
 
         room_msg = "%s attacks %s! %s" % (attacker_name, victim_name, result)
         victim_msg = "%s attacks you. %s" % (attacker_name, result)
         attacker_msg = "You attack %s! %s" % (victim_name, result)
         #victim.tell(victim_msg, evoke=True, short_len=False)
 
-        combat_prompt, attacker_msg = mud_context.driver.prepare_combat_prompt(attacker=self, 
-                              defender=defender, 
+        combat_prompt, attacker_msg = mud_context.driver.prepare_combat_prompt(attackers=attackers, 
+                              defenders=defenders, 
                               location_title = self.location.title,
                               combat_result = result,
                               attacker_msg = attacker_msg)
 
-        combat_context = CombatContext(attacker_name=self.name,
-                                        attacker_health=self.stats.hp / self.stats.max_hp, 
-                                        attacker_weapon=self.wielding.name, 
-                                        defender_name=defender.name, 
-                                        defender_health=defender.stats.hp / defender.stats.max_hp, 
-                                        defender_weapon=defender.wielding.name, 
+        combat_context = CombatContext(attackers=attackers, 
+                                        defenders=defenders, 
                                         location_description=self.location.description)
 
         defender.location.tell(room_msg,
                              evoke=True,
                              short_len=False,
                              alt_prompt=combat_prompt,
                              extra_context=combat_context.to_prompt_string())
-        self.stats.hp -= damage_to_attacker
-        defender.stats.hp -= damage_to_defender
-        if self.stats.hp < 1:
-            mud_context.driver.defer(0.1, self.do_on_death)
-        if defender.stats.hp < 1:
-            mud_context.driver.defer(0.1, defender.do_on_death)
+        for attacker in attackers:
+            if attacker.stats.hp < 1:
+                mud_context.driver.defer(0.1, attacker.do_on_death)
+        for defender in defenders:
+            if defender.stats.hp < 1:
+                mud_context.driver.defer(0.1, defender.do_on_death)
         return c
 
     def allow_give_money(self, amount: float, actor: Optional['Living']) -> None:

tale/combat.py

@@ -5,6 +5,7 @@
 """
 
 import random
+from typing import List, Tuple
 from tale import weapon_type
 import tale.base as base
 from tale.wearable import WearLocation, body_parts_for_bodytype
@@ -15,9 +16,9 @@
 
 class Combat():
 
-    def __init__(self, attacker: 'base.Living', defender: 'base.Living', target_body_part: WearLocation = None) -> None:
-        self.attacker = attacker
-        self.defender = defender
+    def __init__(self, attackers: List['base.Living'], defenders: List['base.Living'], target_body_part: WearLocation = None) -> None:
+        self.attackers = attackers
+        self.defenders = defenders
         self.target_body_part = target_body_part
 
     def _calculate_attack_success(self, actor: 'base.Living') -> int:
@@ -83,37 +84,41 @@ def create_probability_distribution(self, locations, size_factor: float = 1.0, t
         normalized_distribution = {location: probability / total_probability for location, probability in probability_distribution.items()}
         return normalized_distribution
 
-    def resolve_attack(self) -> (str, int, int):
+    def resolve_attack(self) -> str:
         """ Both attacker and defender attack each other once.
         They get a chance to block, unless it's a critical hit, 5/100.
         Returns a textual representation of the combat and the damage done to each actor.
         """
         texts = []
-        damage_to_defender = 0
-        damage_to_attacker = 0
 
-        text_result, damage_to_defender = self._round(self.attacker, self.defender)
-        texts.extend(text_result)
+        for attacker in self.attackers:
+            random_defender = random.choice(self.defenders)
+            text_result, damage_to_defender = self._round(attacker, random_defender)   
+            texts.extend(text_result)
+            random_defender.stats.hp -= damage_to_defender
+            if random_defender.stats.hp < 1:
+                texts.append(f'{random_defender.title} dies')
 
-        text_result, damage_to_attacker = self._round(self.defender, self.attacker)
-        texts.extend(text_result)
+        for defender in self.defenders:
+            random_attacker = random.choice(self.attackers)
+            text_result, damage_to_attacker = self._round(defender, random_attacker)
+            texts.extend(text_result)
 
-        if self.defender.stats.hp - damage_to_defender < 0:
-            texts.append(f'{self.defender.title} dies')
-        if self.attacker.stats.hp - damage_to_attacker < 0:
-            texts.append(f'{self.attacker.title} dies')
+            random_attacker.stats.hp -= damage_to_attacker
+            if random_attacker.stats.hp < 1:
+                texts.append(f'{random_attacker.title} dies')
 
-        return ', '.join(texts), damage_to_attacker, damage_to_defender
+        return ', '.join(texts)
 
-    def _round(self, actor1: 'base.Living', actor2: 'base.Living') -> ([str], int):
+    def _round(self, actor1: 'base.Living', actor2: 'base.Living') -> Tuple[List[str], int]:
         attack_result = self._calculate_attack_success(actor1)
         texts = []
         if attack_result < 0:
             if attack_result < -actor1.stats.get_weapon_skill(actor1.wielding.type) + 5:
-                texts.append(f'{actor1.title} performs a critical hit')
+                texts.append(f'{actor1.title} performs a critical hit on {actor2.title}')
                 block_result = 100
             else:
-                texts.append(f'{actor1.title} hits')
+                texts.append(f'{actor1.title} hits {actor2.title}')
                 block_result = self._calculate_block_success(actor1, actor2)
 
             if block_result < 0:
@@ -129,9 +134,9 @@ def _round(self, actor1: 'base.Living', actor2: 'base.Living') -> ([str], int):
                     texts.append(f', {actor2.title} is unharmed')
                 return texts, damage_to_defender
         elif attack_result > 50:
-            texts.append(f'{actor1.title} misses completely')
+            texts.append(f'{actor1.title} misses {actor2.title} completely')
         elif attack_result > 25:
-            texts.append(f'{actor1.title} misses')
+            texts.append(f'{actor1.title} misses {actor2.title}')
         else:
-            texts.append(f'{actor1.title} barely misses')
+            texts.append(f'{actor1.title} barely misses {actor2.title}')
         return texts, 0

tale/driver.py

@@ -885,29 +885,32 @@ def uptime(self) -> Tuple[int, int, int]:
         return int(hours), int(minutes), int(seconds)
 
     def prepare_combat_prompt(self, 
-                              attacker: base.Living, 
-                              defender: base.Living, 
+                              attackers: List[base.Living], 
+                              defenders: List[base.Living], 
                               location_title: str,
                               combat_result: str,
                               attacker_msg: str):
         """ TODO: A bad work around. Need to find a better way to do this."""
-
-        attacker_name = lang.capital(attacker.title)
-        victim_name = lang.capital(defender.title)
-
-        if isinstance(self, player.Player):
-            attacker_msg.replace(attacker_name, "you")
-            attacker_name += " (as 'You')"
-        if isinstance(defender, player.Player):
-            attacker_msg.replace(victim_name, "you")
-            victim_name += " (as 'You')"
+        attacker_names = []
+        defender_titles = []
+        for attacker in attackers:
+            attacker_title = lang.capital(attacker.title)
+            if isinstance(attacker, player.Player):
+                attacker_title = attacker_title + " (as 'You')"
+            attacker_names.append(attacker_title)
+
+        for defender in defenders:
+            defender_title = defender.title
+            if isinstance(defender, player.Player):
+                defender_title = defender_title + " (as 'You')"
+            defender_titles.append(defender_title)
 
 
-        return self.llm_util.combat_prompt.format(attacker=attacker_name, 
-                                                    victim=victim_name,
+        return self.llm_util.combat_prompt.format(attackers=attacker_names, 
+                                                    defenders=defender_titles,
                                                     location=location_title,
                                                     input_text=combat_result,
-                                                    context=''), attacker_msg
+                                                    context=self.story.config.context if self.story else ''), attacker_msg
 
     def build_location(self, targetLocation: base.Location, zone: Zone, player: player.Player):
         dynamic_story = typing.cast(DynamicStory, self.story)

tale/llm/LivingNpc.py

@@ -88,10 +88,6 @@ def notify_action(self, parsed: ParseResult, actor: Living) -> None:
             self._observed_events.append(event_hash)
             # TODO: should llm decide sentiment?
             self.sentiments[actor.title] = 'hostile'
-        elif parsed.verb == 'attack' and self.following == actor:
-            target = self.location.search_living(parsed.who_1) if parsed.who_1 else None
-            if target:
-                self.start_attack(target)
         elif parsed.verb == 'request_to_follow' and targeted:
             result = mud_context.driver.llm_util.request_follow(actor=actor,
                                                                 character_name=self.title, 

tale/llm/contexts/CombatContext.py

@@ -1,14 +1,18 @@
-class CombatContext():
+from typing import List
 
-    def __init__(self, attacker_name: str, attacker_health: float, attacker_weapon: str, defender_name: str, defender_health: float, defender_weapon: str, location_description: str) -> None:
-        self.victim_info = {"name": defender_name, 
-                       "health": defender_health, 
-                       "weapon": defender_weapon}
+from tale import base
+class CombatContext():
 
-        self.attacker_info = {"name": attacker_name, 
-                         "health": attacker_health, 
-                         "weapon": attacker_weapon}
+    def __init__(self, attackers: List['base.Living'], defenders: List['base.Living'], location_description: str) -> None:
+        self.attackers = attackers
+        self.defenders = defenders
         self.location_description = location_description
 
     def to_prompt_string(self) -> str:
-        return f"Attacker: {self.attacker_info['name']} ({self.attacker_info['health']}); Defender: {self.victim_info['name']} ({self.victim_info['health']}); Location: {self.location_description}"
+        attackers_info = []
+        for attacker in self.attackers:
+            attackers_info.append(f"{attacker.name}: Health:({str(attacker.stats.hp / attacker.stats.max_hp)}). Weapon: {attacker.wielding.name}.")
+        defenders_info = []
+        for defender in self.defenders:
+            defenders_info.append(f"{defender.name}: Health:({str(defender.stats.hp / defender.stats.max_hp)}). Weapon: {defender.wielding.name}.")
+        return f"Attackers: {attackers_info}; Defenders: {defenders_info}; Location: {self.location_description}."