Merge pull request #86 from neph1/update-v0.31.0

Update v0.31.0

Author: neph1

llm_config.yaml

@@ -10,7 +10,7 @@ ITEM_TEMPLATE: '{{"name":"", "type":"", "short_descr":"", "level":int, "value":i
 CREATURE_TEMPLATE: '{{"name":"", "body":"", "mass":int(kg), "hp":int, "type":"Npc or Mob", "level":int, "aggressive":bool, "unarmed_attack":One of [FISTS, CLAWS, BITE, TAIL, HOOVES, HORN, TUSKS, BEAK, TALON], "short_descr":""}}'
 EXIT_TEMPLATE: '{{"direction":"", "name":"name of new location", "short_descr":"exit description"}}'
 NPC_TEMPLATE: '{{"name":"", "sentiment":"", "race":"", "gender":"m, f, or n", "level":(int), "aggressive":bool, "description":"25 words", "appearance":"25 words"}}'
-LOCATION_TEMPLATE: '{{"name": "", "exits":[], "items":[], "npcs":[]}}'
+LOCATION_TEMPLATE: '{{"name": "", "description":"", "exits":[], "items":[], "npcs":[], "indoors":"true or false"}}'
 ZONE_TEMPLATE: '{{"name":name of the room, "description": "75 words", "races":[], "items":[], "mood":"5 to -5, where 5 is extremely friendly and -5 is extremely hostile.", "level":(int)}}'
 DUNGEON_LOCATION_TEMPLATE: '{"index": (int), "name": "", "description": 25 words}'
 CHARACTER_TEMPLATE: '{"name":"", "description": "50 words", "appearance": "25 words", "personality": "50 words", "money":(int), "level":"", "gender":"m/f/n", "age":(int), "race":""}'
@@ -44,5 +44,7 @@ NOTE_LORE_PROMPT: '<context>{context}</context> Zone info: {zone_info};\n[USER_S
 ACTION_PROMPT: '<context>{context}</context>\n[USER_START]Act as as {character_name}.\nUsing the information supplied inside the <context> tag, pick an action according to {character_name}s description and mood. If suitable, select something to perform the action on (target). The action should be in the supplied list and should be related to {character_name}s goal and thoughts. Build on events in "History" without repeating them. Respond using JSON in the following format with up to 3 actions: """{action_template}""". Continue the sequence of events: {previous_events}'
 REQUEST_FOLLOW_PROMPT: '<context>{context}</context>\n[USER_START]Act as as {character_name}.\nUsing the information supplied inside the <context> tag. {character_name} has received a request to follow {target}. Answer based on {character_name}s description and mood. Reason given by {target}: {target_reason}. Respond using JSON in the following format: {follow_template}'
 DAY_CYCLE_EVENT_PROMPT: '<context>{context}</context>\n[USER_START] Write up to two sentences describing the transition from {from_time} to {to_time} in {location_name}, using the information supplied inside the <context> tags.'
+NARRATIVE_EVENT_PROMPT: '<context>{context}</context>\n[USER_START] Write a narrative event that occurs in {location_name} using the information supplied inside the <context> tags. The event should be related to the location and the characters present. Use up to 50 words.'
+RANDOM_SPAWN_PROMPT: '<context>{context}</context>\n[USER_START] An npc or a mob has entered {location_name}. Select either and fill in one of the following templates using the information supplied inside the <context> tags. Respond using JSON in the following format: {npc_template}'
 USER_START: '### Instruction:\n'
 USER_END: '### Response:\n'

tale/base.py

@@ -668,6 +668,7 @@ def __init__(self, name: str, descr: str="") -> None:
         self.built = True     # has this location been built yet? If not, LLM will describe it.
         self.generated = False # whether this location is LLM generated or not
         self.world_location = Coord() # the world location of this location
+        self.indoors = False  # is this location indoors?
 
     def __contains__(self, obj: Union['Living', Item]) -> bool:
         return obj in self.livings or obj in self.items
@@ -1217,7 +1218,7 @@ def remember_previous_parse(self) -> None:
         """remember the previously parsed data, soul uses this to reference back to earlier items/livings"""
         self.soul.remember_previous_parse(self._previous_parse)
 
-    def do_socialize(self, cmdline: str, external_verbs: Set[str]=set()) -> None:
+    def do_socialize(self, cmdline: str, external_verbs: Set[str]=set(), evoke=True) -> None:
         """
         Perform a command line with a socialize/soul verb on the living's behalf.
         It only performs soul emotes, no custom command functions!
@@ -1230,7 +1231,7 @@ def do_socialize(self, cmdline: str, external_verbs: Set[str]=set()) -> None:
                 # emulate the say command (which is not an emote, but it's convenient to be able to use it as such)
                 verb, _, rest = cmdline.partition(" ")
                 rest = rest.strip()
-                self.tell_others("{Actor} says: " + rest)
+                self.tell_others("{Actor} says: " + rest, evoke=evoke)
             else:
                 raise
 
@@ -1246,7 +1247,7 @@ def do_command_verb(self, cmdline: str, ctx: util.Context) -> None:
         """
         command_verbs = ctx.driver.current_verbs(self)
         try:
-            self.do_socialize(cmdline, command_verbs)
+            self.do_socialize(cmdline, command_verbs, evoke=False)
         except NonSoulVerb as nx:
             parsed = nx.parsed
             if parsed.verb in command_verbs:

tale/day_cycle/day_cycle.py

@@ -1,7 +1,9 @@
 
 
+import enum
 from typing import List, Protocol
 from tale import mud_context
+from tale.driver import Driver
 from tale.util import GameDateTime, call_periodically
 
 class DayCycleEventObserver(Protocol):
@@ -11,13 +13,20 @@ def on_day(self): pass
     def on_night(self): pass
     def on_midnight(self): pass
 
+class TimeOfDay(str, enum.Enum):
+    DAWN = 'Dawn'
+    DAY = 'Day'
+    DUSK = 'Dusk'
+    NIGHT = 'Night'
 class DayCycle:
-    
-    def __init__(self, game_date_time: GameDateTime):
-        self.game_date_time = game_date_time
-        self.current_hour = game_date_time.clock.hour
+
+    def __init__(self, driver: Driver):
+        
+        self.game_date_time = driver.game_clock
+        self.current_hour = self.game_date_time.clock.hour
         self.observers: List[DayCycleEventObserver] = []
-        mud_context.driver.register_periodicals(self)
+        driver.register_periodicals(self)
+        self._time_of_day = TimeOfDay.DAY
 
     def register_observer(self, observer: DayCycleEventObserver):
         self.observers.append(observer)
@@ -50,16 +59,25 @@ def hour(self):
 
     def dawn(self):
         self.notify_observers('on_dawn')
+        self._time_of_day = TimeOfDay.DAWN
 
     def dusk(self):
         self.notify_observers('on_dusk')
+        self._time_of_day = TimeOfDay.DUSK
 
     def day(self):
         self.notify_observers('on_day')
+        self._time_of_day = TimeOfDay.DAY
 
     def night(self):
         self.notify_observers('on_night')
+        self._time_of_day = TimeOfDay.NIGHT
 
     def midnight(self):
         self.current_hour = 0
         self.notify_observers('on_midnight')
+        self._time_of_day = TimeOfDay.NIGHT
+
+    @property
+    def time_of_day(self) -> TimeOfDay:
+        return self._time_of_day

tale/json_story.py

@@ -3,6 +3,7 @@
 from tale.items import generic
 from tale.llm.llm_ext import DynamicStory
 from tale.player import Player
+from tale.random_event import RandomEvent
 from tale.story import GameMode, StoryConfig
 import tale.parse_utils as parse_utils
 import tale.llm.llm_cache as llm_cache
@@ -54,9 +55,12 @@ def init(self, driver) -> None:
                 self._catalogue.add_item(item)
 
         if self.config.day_night:
-            self.day_cycle = DayCycle(self.driver.game_clock)
+            self.day_cycle = DayCycle(driver)
             if self.config.server_mode == GameMode.IF:
                 self.day_cycle.register_observer(LlmDayCycleListener(self.driver))
+        
+        if self.config.random_events:
+            self.random_events = RandomEvent(driver)
 
     def welcome(self, player: Player) -> str:
         player.tell("<bright>Welcome to `%s'.</>" % self.config.name, end=True)

tale/llm/LivingNpc.py

@@ -37,7 +37,6 @@ def __init__(self, name: str, gender: str, *,
         self.example_voice = '' # type: str
         self.autonomous = False
         self.output_thoughts = False
-        self.last_reaction_time = None
 
     def notify_action(self, parsed: ParseResult, actor: Living) -> None:
         # store even our own events.
@@ -64,10 +63,6 @@ def notify_action(self, parsed: ParseResult, actor: Living) -> None:
         elif (targeted and parsed.verb == "idle-action") or parsed.verb == "location-event":
             event_hash = llm_cache.cache_event(unpad_text(parsed.unparsed))
             self._observed_events.append(event_hash)
-            if self.last_reaction_time and mud_context.driver.game_clock.clock == self.last_reaction_time:
-                # only react once per tick
-                return
-            self.last_reaction_time = mud_context.driver.game_clock.clock
             self._do_react(parsed, actor)
         elif targeted and parsed.verb == "give":
             parsed_split = parsed.unparsed.split(" to ")
@@ -162,7 +157,7 @@ def _do_react(self, parsed: ParseResult, actor: Living) -> None:
                                             sentiment=self.sentiments.get(actor.name, '') if actor else '')
         if action:
             self.action_history.append(action)
-            self._defer_result(action, verb='idle-action')
+            self._defer_result(action, verb='reaction')
 
     def handle_item_result(self, result: ItemHandlingResult, actor: Living) -> bool:
         if result.to == self.title:
@@ -305,11 +300,11 @@ def _defer_result(self, action: str, verb: str="idle-action"):
         else:
             action = f"{self.title} : {action}"
         self.deferred_actions.add(action)
-        self.tell_action_deferred()
+        self.tell_action_deferred(verb)
 
-    def tell_action_deferred(self):
+    def tell_action_deferred(self, verb: str):
         actions = '\n'.join(self.deferred_actions) + '\n'
-        deferred_action = ParseResult(verb='idle-action', unparsed=actions, who_info=None)
+        deferred_action = ParseResult(verb=verb, unparsed=actions, who_info=None)
         self.tell_others(actions)
         self.location._notify_action_all(deferred_action, actor=self)
         self.deferred_actions.clear()

tale/llm/contexts/EvokeContext.py

@@ -2,10 +2,11 @@
 
 class EvokeContext(BaseContext):
 
-    def __init__(self, story_context: str, history: str, extra_context: str = '') -> None:
+    def __init__(self, story_context: str, history: str, time_of_day: str = 'day', extra_context: str = '') -> None:
         super().__init__(story_context)
         self.history = history
+        self.time_of_day = time_of_day
         self.extra_context = extra_context
 
     def to_prompt_string(self) -> str:
-        return f"Story context:{self.story_context}; History:{self.history}; " + (f"{self.extra_context};" if self.extra_context else '')
+        return f"Story context:{self.story_context}; History:{self.history}; " + (f"{self.extra_context};" if self.extra_context else '' + f"Time of day:{self.time_of_day};" if self.time_of_day else '')

tale/llm/llm_ext.py

@@ -44,7 +44,7 @@ def find_location(self, name: str) -> Location:
                 return location
 
     def find_zone(self, location: str) -> Zone:
-        """ Find a zone by location."""
+        """ Find a zone by location name."""
         for zone in self._zones.values():
             if zone.get_location(location):
                 return zone

tale/llm/llm_utils.py

@@ -53,6 +53,7 @@ def __init__(self, io_util: IoUtil = None):
         self.short_word_limit = llm_config.params['SHORT_WORD_LIMIT']
         self.story_background_prompt = llm_config.params['STORY_BACKGROUND_PROMPT'] # type: str
         self.day_cycle_event_prompt = llm_config.params['DAY_CYCLE_EVENT_PROMPT'] # type: str
+        self.narrative_event_prompt = llm_config.params['NARRATIVE_EVENT_PROMPT']
         self.__story = None # type: DynamicStory
         self.io_util = io_util or IoUtil(config=llm_config.params, backend_config=backend_config)
         self.stream = backend_config['STREAM']
@@ -92,13 +93,19 @@ def evoke(self, message: str, short_len: bool=False, rolling_prompt: str = '', a
 
         rolling_prompt = self.update_memory(rolling_prompt, message)
 
-        text_hash_value = llm_cache.generate_hash(message)
+        text_hash_value = llm_cache.generate_hash(message + extra_context)
 
         cached_look = llm_cache.get_looks([text_hash_value])
         if cached_look:
             return output_template.format(message=message, text=cached_look), rolling_prompt
         trimmed_message = parse_utils.remove_special_chars(str(message))
-        story_context = EvokeContext(story_context=self.__story_context, history=rolling_prompt if not (skip_history or alt_prompt) else '', extra_context=extra_context)
+        time_of_day = ''
+        if self.__story.config.day_night:
+            time_of_day = self.__story.day_cycle.time_of_day.__str__
+        story_context = EvokeContext(story_context=self.__story_context, 
+                                        time_of_day=time_of_day,
+                                        history=rolling_prompt if not (skip_history or alt_prompt) else '', 
+                                        extra_context=extra_context)
         prompt = self.pre_prompt
         prompt += (alt_prompt or self.evoke_prompt).format(
             context = '{context}',
@@ -296,12 +303,9 @@ def request_follow(self, actor: MudObject, character_name: str, character_card:
     def describe_day_cycle_transition(self, player: PlayerConnection, from_time: str, to_time: str) -> str:
         prompt = self.pre_prompt
         location = player.player.location
-        context = WorldGenerationContext(story_context=self.__story_context,
-                                        story_type=self.__story_type,
-                                        world_info=self.__world_info,
-                                        world_mood=self.__story.config.world_mood)
+        context = self._get_world_context()
         prompt += self.day_cycle_event_prompt.format(
-            context= '',
+            context= '{context}',
             location_name=location.name,
             from_time=from_time,
             to_time=to_time)
@@ -313,6 +317,18 @@ def describe_day_cycle_transition(self, player: PlayerConnection, from_time: str
             return text
         text = self.io_util.stream_request(request_body=request_body, prompt=prompt, context=context.to_prompt_string() + f'Location: {location.name, location.description};', io=player)
         return text
+    
+    def generate_narrative_event(self, location: Location) -> str:
+        prompt = self.pre_prompt
+        context = self._get_world_context()
+        prompt += self.narrative_event_prompt.format(
+            context= '{context}',
+            location_name=location.name)
+        request_body = deepcopy(self.default_body)
+
+        text = self.io_util.synchronous_request(request_body, prompt=prompt, context=context.to_prompt_string() + f'Location: {location.name, location.description};')
+        location.tell(text, evoke=False)
+        return text
 
     def set_story(self, story: DynamicStory):
         """ Set the story object."""

tale/llm/responses/LocationResponse.py

@@ -51,7 +51,9 @@ def _validate_location(self, json_result: dict,
                         # some models don't generate description, sometimes
                         json_result['description'] = exit_location_name
                 location_to_build.description = json_result['description']
-                
+            
+            if json_result.get('indoors', False):
+                location_to_build.indoors = True
 
             self._add_items(location_to_build, json_result, world_items)
 

tale/parse_utils.py

@@ -236,6 +236,7 @@ def load_story_config(json_file: dict):
     config.image_gen = json_file.get('image_gen', config.image_gen)
     config.epoch = json_file.get('epoch', config.epoch)
     config.day_night = json_file.get('day_night', config.day_night)
+    config.random_events = json_file.get('random_events', config.random_events)
     return config
 
 def save_story_config(config: StoryConfig) -> dict:
@@ -271,6 +272,7 @@ def save_story_config(config: StoryConfig) -> dict:
     json_file['image_gen'] = config.image_gen
     json_file['epoch'] = config.epoch
     json_file['day_night'] = config.day_night
+    json_file['random_events'] = config.random_events
     return json_file
 
 
@@ -371,7 +373,7 @@ def sanitize_json(result: str) -> str:
     result = result.strip()
     result = result.replace('```json', '') #.replace('\\"', '"').replace('"\\n"', '","').replace('\\n', '').replace('}\n{', '},{').replace('}{', '},{').replace('\\r', '').replace('\\t', '').replace('"{', '{').replace('}"', '}').replace('"\\', '"').replace('\\”', '"').replace('" "', '","').replace(':,',':').replace('},]', '}]').replace('},}', '}}')
     result = result.split('```')[0]
-    result = result.replace('False', 'false').replace('True', 'true').replace('None', 'null')
+    result = result.replace('False', 'false').replace('True', 'true').replace('None', 'null').replace('\\r', '')
     if not result.endswith('}') and not result.endswith(']'):
         result = result + '}'
     #print('sanitized json: ' + result)