Merge pull request #61 from neph1/update-v0.23.0

Update v0.23.0

Author: neph1

tale/base.py

@@ -1034,6 +1034,7 @@ def __init__(self, name: str, gender: str, *, race: str="human",
         self.is_pet = False   # set this to True if creature is/becomes someone's pet
         self.__wielding = None   # type: Optional[Weapon]
         self.__wearing = dict()  # type: Dict[str, wearable.Wearable]
+        self.should_produce_remains = False
 
         super().__init__(name, title=title, descr=descr, short_descr=short_descr)
 
@@ -1435,9 +1436,9 @@ def start_attack(self, victim: 'Living') -> combat.Combat:
         self.stats.hp -= damage_to_attacker
         victim.stats.hp -= damage_to_defender
         if self.stats.hp < 1:
-            combat.produce_remains(util.Context, self)
+            self.do_on_death(util.Context)
         if victim.stats.hp < 1:
-            combat.produce_remains(util.Context, victim)  
+            victim.do_on_death(util.Context)  
         return c
 
     def allow_give_money(self, amount: float, actor: Optional['Living']) -> None:
@@ -1563,6 +1564,16 @@ def get_wearable(self, location: wearable.WearLocation) -> Optional[Wearable]:
     def get_worn_items(self) -> Iterable[Wearable]:
         """Return all items that are currently worn."""
         return self.__wearing.values()
+    
+    def do_on_death(self, ctx: util.Context) -> 'Container':
+        """Called when the living dies."""
+        if not self.should_produce_remains:
+            return None
+        remains = Container(f"remains of {self.title}")
+        remains.init_inventory(self.inventory)
+        self.location.insert(remains, None)
+        self.destroy(ctx)
+        return remains
 
 
 class Container(Item):

tale/cmds/wizard.py

@@ -17,6 +17,7 @@
 from typing import Generator, Optional
 
 from tale import parse_utils
+from tale.llm.LivingNpc import LivingNpc
 
 from . import wizcmd, disabled_in_gamemode
 from .. import base, lang, util, pubsub, races, __version__
@@ -852,3 +853,16 @@ def do_set_description(player: Player, parsed: base.ParseResult, ctx: util.Conte
     except ValueError as x:
         raise ActionRefused(str(x))
 
+@wizcmd("set_goal")
+def do_set_goal(player: Player, parsed: base.ParseResult, ctx: util.Context) -> None:
+    """Set a goal for a LivingNpc."""
+    if len(parsed.args) != 2:
+        raise ParseError("You need to specify the character and the goal")
+    try:
+        character = player.location.search_living(parsed.args[0])
+        if not character or not isinstance(character, LivingNpc):
+            raise ParseError("No LivingNpc found")
+        character.goal = parsed.args[1]
+        player.tell("%s goal set to %s" % (character, parsed.args[1]))
+    except ValueError as x:
+        raise ActionRefused(str(x))

tale/combat.py

@@ -91,13 +91,3 @@ def _round(self, actor1: 'base.Living', actor2: 'base.Living') -> ([str], int):
         else:
             texts.append(f'{actor1.title} barely misses')
         return texts, 0
-
-def produce_remains(context: Context, actor: 'base.Living'):
-    """ Creates a container with the inventory of the Living
-    and places it in the living's location. 
-    """
-    remains = base.Container(f"remains of {actor.title}")
-    remains.init_inventory(actor.inventory)
-    actor.location.insert(remains, None)
-    actor.destroy(context)
-    return remains

tale/driver.py

@@ -952,4 +952,7 @@ def build_location(self, targetLocation: base.Location, zone: Zone, player: play
                 else:
                     text = self.llm_util.generate_note_lore(zone_info=zone.get_info())
                     item.text = text
-        return True
+        return True
+    
+    def do_on_player_death(self, player: player.Player) -> None:
+        pass

tale/driver_if.py

@@ -442,6 +442,10 @@ def _load_saved_game(self, existing_player: Player) -> Optional[Player]:
             if self.wizard_override:
                 saved_player.privileges.add("wizard")
             return saved_player
+        
+    def do_on_player_death(self, player: Player) -> None:
+        self.story.story_failure()
+        self._stop_driver()
 
 
 class SavegameExistingObjectsFinder:
@@ -488,3 +492,4 @@ def resolve_exit(self, vnum: int, name: str, classname: str, baseclassname: str)
         if exit.name != name or savegames.qual_baseclassname(exit) != baseclassname:
             raise errors.TaleError("exit/door inconsistency for vnum " + str(vnum))
         return exit
+

tale/image_gen/automatic1111.py

@@ -17,7 +17,6 @@ def __init__(self, address: str = '127.0.0.1', port: int = 7860) -> None:
                 self.config = yaml.safe_load(stream)
             except yaml.YAMLError as exc:
                 print(exc)
-        print(self.config)
 
 
     def generate_image(self, prompt: str, save_path: str, image_name: str) -> bool:

tale/llm/LivingNpc.py

@@ -16,7 +16,7 @@ class LivingNpc(Living):
     """An NPC with extra fields to define personality and help LLM generate dialogue"""
 
     def __init__(self, name: str, gender: str, *,
-                 title: str="", descr: str="", short_descr: str="", age: int, personality: str="", occupation: str="", race: str=""):
+                 title: str="", descr: str="", short_descr: str="", age: int = -1, personality: str="", occupation: str="", race: str=""):
         super(LivingNpc, self).__init__(name=name, gender=gender, title=title, descr=descr, short_descr=short_descr, race=race)
         self.age = age
         self.personality = personality
@@ -211,6 +211,8 @@ def autonomous_action(self) -> str:
             return None
 
         defered_actions = []
+        if action.get('goal', ''):
+            self.goal = action['goal']
         if action.get('text', ''):
             text = action['text']
             tell_hash = llm_cache.cache_tell('{actor.title} says: "{response}"'.format(actor=self, response=unpad_text(text)))
@@ -284,6 +286,7 @@ def character_card(self) -> str:
                 occupation=self.occupation,
                 race=self.stats.race,
                 quest=self.quest,
+                goal=self.goal,
                 wearing=','.join([f'"{str(i.name)}"' for i in self.get_worn_items()]),
                 items=','.join(items))
 

tale/llm/character.py

@@ -34,17 +34,15 @@ def __init__(self, backend: str, io_util: IoUtil, default_body: dict):
 
     def generate_dialogue(self,
                           context: DialogueContext,
-                          conversation: str,
                           sentiment = '', 
                           event_history = '',
                           short_len : bool=False):
         prompt = self.pre_prompt
 
         #formatted_conversation = llm_config.params['USER_START']
-        formatted_conversation = conversation.replace('<break>', '\n')#llm_config.params['USER_END'] + '\n' + llm_config.params['USER_START'])
         prompt += self.dialogue_prompt.format(
                 context = '{context}',
-                previous_conversation=formatted_conversation,
+                previous_conversation=context.conversation,
                 character2=context.speaker_name,
                 character1=context.target_name,
                 dialogue_template=self.dialogue_template,

tale/llm/contexts/DialogueContext.py

@@ -11,13 +11,15 @@ def __init__(self,
             speaker_card: str,
             speaker_name: str,
             target_name: str,
-            target_description: str):
+            target_description: str,
+            conversation: str = '',):
         super().__init__(story_context)
         self.location_description = location_description
         self.speaker_card = speaker_card
         self.speaker_name = speaker_name
         self.target_name = target_name
         self.target_description = target_description
+        self.conversation = conversation.replace('<break>', '\n')#llm_config.params['USER_END'] + '\n' + llm_config.params['USER_START'])
 
 
     def to_prompt_string(self) -> str:

tale/llm/io_adapters.py

@@ -8,6 +8,7 @@
 import requests
 
 from tale.errors import LlmResponseException
+from tale.player import PlayerConnection
 
 
 class AbstractIoAdapter(ABC):
@@ -40,7 +41,7 @@ def __init__(self, url: str, stream_endpoint: str, data_endpoint: str, user_star
         super().__init__(url, stream_endpoint, user_start_prompt, user_end_prompt)
         self.data_endpoint = data_endpoint
 
-    def stream_request(self, request_body: dict, io = None, wait: bool = False) -> str:
+    def stream_request(self, request_body: dict, io: PlayerConnection = None, wait: bool = False) -> str:
         result = asyncio.run(self._do_stream_request(self.url + self.stream_endpoint, request_body))
 
         try:
@@ -59,7 +60,7 @@ async def _do_stream_request(self, url: str, request_body: dict,) -> bool:
                 else:
                     print("Error occurred:", response.status)
 
-    def _do_process_result(self, url, io = None, wait: bool = False) -> str:
+    def _do_process_result(self, url, io: PlayerConnection, wait: bool = False) -> str:
         """ Process the result from the stream endpoint """
         tries = 0
         old_text = ''
@@ -94,10 +95,10 @@ def set_prompt(self, request_body: dict, prompt: str, context: str = '') -> dict
 
 class LlamaCppAdapter(AbstractIoAdapter):
 
-    def stream_request(self, request_body: dict, io = None, wait: bool = False) -> str:
+    def stream_request(self, request_body: dict, io: PlayerConnection = None, wait: bool = False) -> str:
         return asyncio.run(self._do_stream_request(self.url + self.stream_endpoint, request_body, io = io))
 
-    async def _do_stream_request(self, url: str, request_body: dict, io = None) -> str:
+    async def _do_stream_request(self, url: str, request_body: dict, io: PlayerConnection) -> str:
         """ Send request to stream endpoint async to not block the main thread"""
         request_body['stream'] = True
         text = ''
@@ -126,7 +127,6 @@ async def _do_stream_request(self, url: str, request_body: dict, io = None) -> s
                                 text += content
                     while len(lines) == 0:
                         await asyncio.sleep(0.15)
-                    
         return text
 
     def parse_result(self, result: str) -> str:
@@ -142,7 +142,7 @@ def set_prompt(self, request_body: dict, prompt: str, context: str = '') -> dict
         if self.user_end_prompt:
             prompt = prompt + self.user_end_prompt
         if context:
-            prompt = prompt.replace('<context>{context}</context>', '')
-            request_body['messages'][0]['content'] = f'<context>{context}</context>'
+            prompt = prompt.replace('<context>{context}</context>', f'<context>{context}</context>')
+            #request_body['messages'][0]['content'] = f'<context>{context}</context>'
         request_body['messages'][1]['content'] = prompt
         return request_body