Merge pull request #77 from neph1/update-v0.27.0

Update v0.27.0

Author: neph1

llm_config.yaml

@@ -4,11 +4,12 @@ BACKEND: "kobold_cpp" # valid options: "openai", "llama_cpp", "kobold_cpp". if u
 MEMORY_SIZE: 512
 UNLIMITED_REACTS: False
 DIALOGUE_TEMPLATE: '{{"response":"may be both dialogue and action.", "sentiment":"sentiment based on response", "give":"if any physical item of {character2}s is given as part of the dialogue. Or nothing."}}'
+ACTION_LIST: ['move, say, attack, wear, remove, wield, take, eat, drink, emote']
 ACTION_TEMPLATE: '{{"goal": reason for action, "thoughts":thoughts about performing action, 25 words "action":chosen action, "target":character, item or exit or description, "text": if anything is said during the action}}'
 ITEM_TEMPLATE: '{{"name":"", "type":"", "short_descr":"", "level":int, "value":int}}'
 CREATURE_TEMPLATE: '{{"name":"", "body":"", "mass":int(kg), "hp":int, "type":"Npc or Mob", "level":int, "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), "description":"25 words"}}'
+NPC_TEMPLATE: '{{"name":"", "sentiment":"", "race":"", "gender":"m, f, or n", "level":(int), "description":"25 words", "has_quest":(bool)}}'
 LOCATION_TEMPLATE: '{{"name": "", "exits":[], "items":[], "npcs":[]}}'
 ZONE_TEMPLATE: '{{"name":"", "description": "75 words", "races":[], "items":[], "mood":"5 to -5, where 5 is extremely friendly and -5 is extremely hostile.", "level":(int)}}'
 ITEM_TYPES: ["Weapon", "Wearable", "Health", "Money", "Trash", "Food", "Drink", "Key"]

requirements.txt

@@ -6,7 +6,7 @@ smartypants>=1.8.6
 serpent>=1.23
 aiohttp==3.8.5
 pillow
-packaging==20.3
+packaging>=20.3
 #pillow>=8.3.2
 
 

stories/anything/story.py

@@ -5,40 +5,23 @@
 
 import tale
 from tale import lang
+from tale import parse_utils
 from tale.driver import Driver
-from tale.llm.llm_ext import DynamicStory
+from tale.json_story import JsonStory
 from tale.main import run_from_cmdline
 from tale.player import Player, PlayerConnection
 from tale.charbuilder import PlayerNaming
 from tale.story import *
 from tale.weapon_type import WeaponType
-from tale.zone import Zone
 
-class Story(DynamicStory):
+class Story(JsonStory):
 
-    config = StoryConfig()
-    config.name = "The Land of Anything"
-    config.author = "Rickard Edén, github.com/neph1"
-    config.author_address = "[email protected]"
-    config.version = tale.__version__
-    config.supported_modes = {GameMode.IF}
-    config.player_money = 0
-    config.playable_races = {"human"}
-    config.money_type = MoneyType.FANTASY
-    config.server_tick_method = TickMethod.TIMER
-    config.server_tick_time = 0.5
-    config.gametime_to_realtime = 5
-    config.display_gametime = True
-    config.startlocation_player = "start_zone.transit"
-    config.startlocation_wizard = "start_zone.transit"
-    config.zones = ["start_zone"]
-    config.context = ""
-    config.savegames_enabled = False
+
+    def __init__(self) -> None:
+        super(Story, self).__init__('', parse_utils.load_story_config(parse_utils.load_json('story_config.json')))
 
     def init(self, driver: Driver) -> None:
-        """Called by the game driver when it is done with its initial initialization."""
-        self.driver = driver
-        self._zones = dict() # type: dict(str, Zone)
+        super(Story, self).init(driver)
 
     def init_player(self, player: Player) -> None:
         """

stories/anything/story_config.json

@@ -0,0 +1,25 @@
+{
+    "name": "A Tale of Anything",
+    "author": "You",
+    "author_address": "",
+    "version": "1.0",
+    "supported_modes": [
+        "IF"
+    ],
+    "player_name": "",
+    "player_gender": "",
+    "player_race": "human",
+    "player_money": 0,
+    "money_type": "FANTASY",
+    "server_tick_method": "TIMER",
+    "server_tick_time": 0.5,
+    "gametime_to_realtime": 5,
+    "display_gametime": true,
+    "startlocation_player": "start_zone.transit",
+    "startlocation_wizard": "start_zone.transit",
+    "zones": [
+        "start_zone"
+    ],
+    "server_mode": "IF",
+    "save_games_enabled": false
+}

stories/anything/world.json

@@ -0,0 +1,11 @@
+{
+    "story": {
+        "name": "The Land of Anything"
+    },
+    "zones": {
+    },
+    "world": {
+    },
+    "catalogue": {
+    }
+}

tale/driver.py

@@ -930,6 +930,7 @@ def build_location(self, targetLocation: base.Location, zone: Zone, player: play
                 # fail silently
                 pass
         for npc in npcs:
+            dynamic_story.world.add_npc(npc)
             if isinstance(npc, StationaryNpc) and random.random() < 0.2:
                 new_quest = dynamic_story.generate_quest(npc)
                 new_quest.giver = npc

tale/item_spawner.py

@@ -0,0 +1,45 @@
+import random
+
+from tale import mud_context
+from tale.base import Container, Location
+from tale.util import call_periodically
+from tale.zone import Zone
+
+
+class ItemSpawner():
+    def __init__(self, items: list, item_probabilities: list, zone: Zone, spawn_rate: int, container: Container = None, max_items: int = 1):
+        self.items = items
+        self.item_probabilities = item_probabilities
+        self.zone = zone
+        self.container = container
+        self.max_items = max_items
+        self.spawn_rate = spawn_rate
+        self.time = 0
+        mud_context.driver.register_periodicals(self)
+
+    @call_periodically(15)
+    def spawn(self):
+        self.time += 15
+        if self.time < self.spawn_rate:
+            return
+        self.time -= self.spawn_rate
+        item = random.choices(self.items, weights=self.item_probabilities)[0]
+        
+        if self.container:
+            self.container.insert(item, None)
+        else:
+            location = random.choice(list(self.zone.locations.values())) # type: Location
+            if len(location.items) < self.max_items:
+                location.insert(item, None)
+                location.tell(f'{item} appears.')
+    
+    def to_json(self):
+        data = {
+            'items': [item.name for item in self.items],
+            'item_probabilities': self.item_probabilities,
+            'zone': self.zone.name,
+            'spawn_rate': self.spawn_rate,
+            'container': self.container.name if self.container else None,
+            'max_items': self.max_items
+        }
+        return data

tale/json_story.py

@@ -41,6 +41,8 @@ def init(self, driver) -> None:
                 self._world.items = parse_utils.load_items(world['world']['items'].values(), self.locations)
             if world['world'].get('spawners', None):
                 self._world.mob_spawners = parse_utils.load_mob_spawners(world['world']['spawners'], self.locations, self._catalogue._creatures, self._catalogue._items)
+            if world['world'].get('item_spawners', None):
+                self._world.item_spawners = parse_utils.load_item_spawners(world['world']['item_spawners'], self._zones, self._catalogue._items)
 
         llm_cache.load(parse_utils.load_json(self.path +'llm_cache.json'))
 

tale/llm/contexts/ActionContext.py

@@ -7,17 +7,18 @@
 
 class ActionContext(BaseContext):
 
-    def __init__(self, story_context: str, story_type: str, character_name: str, character_card: str, event_history: str, location: Location):
+    def __init__(self, story_context: str, story_type: str, character_name: str, character_card: str, event_history: str, location: Location, actions: list):
         super().__init__(story_context)
         self.story_type = story_type
         self.character_name = character_name
         self.character_card = character_card
         self.event_history = event_history.replace('<break>', '\n')
         self.location = location
+        self.actions = actions
 
 
     def to_prompt_string(self) -> str:
-        actions = ', '.join(['move, say, attack, wear, remove, wield, take, eat, drink, emote'])
+        actions = ', '.join(self.actions)
         characters = {}
         for living in self.location.livings:
             if living.visible and living.name != self.character_name.lower():

tale/llm/io_adapters.py

@@ -37,9 +37,12 @@ def set_prompt(self, request_body: dict, prompt: str, context: str = '') -> dict
 
 class KoboldCppAdapter(AbstractIoAdapter):
 
+
+
     def __init__(self, url: str, stream_endpoint: str, data_endpoint: str, user_start_prompt: str, user_end_prompt: str):
         super().__init__(url, stream_endpoint, user_start_prompt, user_end_prompt)
         self.data_endpoint = data_endpoint
+        self.place_context_in_memory = False
 
     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))
@@ -88,9 +91,12 @@ def set_prompt(self, request_body: dict, prompt: str, context: str = '') -> dict
             prompt = prompt.replace('[USER_START]', self.user_start_prompt)
         if self.user_end_prompt:
             prompt = prompt + self.user_end_prompt
-        prompt = prompt.replace('<context>{context}</context>', '')
+        if self.place_context_in_memory:
+            prompt = prompt.replace('<context>{context}</context>', '')
+            request_body['memory'] = f'<context>{context}</context>'
+        else:
+            prompt = prompt.replace('<context>{context}</context>', f'<context>{context}</context>')
         request_body['prompt'] = prompt
-        request_body['memory'] = f'<context>{context}</context>'
         return request_body
 
 class LlamaCppAdapter(AbstractIoAdapter):