Load config fixed

app.py

@@ -1,5 +1,6 @@
 import gradio as gr
 import random
+import json
 
 # Default configuration template
 default_config = {
@@ -105,19 +106,6 @@ def generate_story_and_timeline():
 
 #-----------------------------------------------------------------------------------------------------------------------------------
 
-class GameState:
-    def __init__(self, description, choices, transitions, conditions=None, npcs=None, consequences=None):
-        self.description = description
-        self.choices = choices
-        self.transitions = transitions
-        self.conditions = conditions if conditions else {}
-        self.npcs = npcs if npcs else []
-        self.consequences = consequences if consequences else {}
-
-    def apply_consequence(self, choice, player):
-        if choice in self.consequences:
-            self.consequences[choice](player)
-
 class Player:
     def __init__(self):
         self.inventory = []
@@ -136,78 +124,78 @@ class Player:
 # Define the states
 all_states = {
     'village': {
-        'start': GameState(
-            "You wake up in a small village. You hear a rumor about a lost treasure.",
-            ['explore village', 'gather supplies', 'rest'],
-            {'explore village': 'village_rumor', 'gather supplies': 'village_supplies', 'rest': 'village_start'},
-            consequences={
+        'start': {
+            "description": "You wake up in a small village. You hear a rumor about a lost treasure.",
+            "choices": ['explore village', 'gather supplies', 'rest'],
+            "transitions": {'explore village': 'village_rumor', 'gather supplies': 'village_supplies', 'rest': 'village_start'},
+            "consequences": {
                 'gather supplies': lambda player: player.add_item('basic supplies')
             }
-        ),
-        'rumor': GameState(
-            "You hear more details about the treasure hidden in the ancient ruins nearby.",
-            ['decide to go', 'ignore'],
-            {'decide to go': 'village_supplies', 'ignore': 'village_start'},
-            consequences={
+        },
+        'rumor': {
+            "description": "You hear more details about the treasure hidden in the ancient ruins nearby.",
+            "choices": ['decide to go', 'ignore'],
+            "transitions": {'decide to go': 'village_supplies', 'ignore': 'village_start'},
+            "consequences": {
                 'decide to go': lambda player: player.update_knowledge('treasure location')
             }
-        ),
-        'supplies': GameState(
-            "You gather supplies for your journey.",
-            ['head to forest', 'stay in village'],
-            {'head to forest': 'forest_forest', 'stay in village': 'village_start'}
-        ),
+        },
+        'supplies': {
+            "description": "You gather supplies for your journey.",
+            "choices": ['head to forest', 'stay in village'],
+            "transitions": {'head to forest': 'forest_forest', 'stay in village': 'village_start'}
+        },
     },
     'forest': {
-        'forest': GameState(
-            "You enter the dense forest, heading towards the ruins.",
-            ['travel further', 'return to village'],
-            {'travel further': 'ruins_ruins', 'return to village': 'village_start'}
-        ),
+        'forest': {
+            "description": "You enter the dense forest, heading towards the ruins.",
+            "choices": ['travel further', 'return to village'],
+            "transitions": {'travel further': 'ruins_ruins', 'return to village': 'village_start'}
+        },
     },
     'ruins': {
-        'ruins': GameState(
-            "You reach the ancient ruins. The entrance is dark and eerie.",
-            ['enter ruins', 'return to forest'],
-            {'enter ruins': 'ruins_explore', 'return to forest': 'forest_forest'}
-        ),
-        'explore': GameState(
-            "You explore the ruins, encountering traps and puzzles.",
-            ['solve puzzle', 'avoid traps'],
-            {'solve puzzle': 'ruins_hiddenPassage', 'avoid traps': 'ruins_ruins'}
-        ),
-        'hiddenPassage': GameState(
-            "You solve a challenging puzzle and unlock a hidden passage.",
-            ['enter passage', 'go back'],
-            {'enter passage': 'ruins_treasureRoom', 'go back': 'ruins_explore'}
-        ),
-        'treasureRoom': GameState(
-            "You enter the treasure room and find the treasure chest.",
-            ['take treasure', 'leave'],
-            {'take treasure': 'ruins_celebrate', 'leave': 'ruins_ruins'},
-            consequences={
+        'ruins': {
+            "description": "You reach the ancient ruins. The entrance is dark and eerie.",
+            "choices": ['enter ruins', 'return to forest'],
+            "transitions": {'enter ruins': 'ruins_explore', 'return to forest': 'forest_forest'}
+        },
+        'explore': {
+            "description": "You explore the ruins, encountering traps and puzzles.",
+            "choices": ['solve puzzle', 'avoid traps'],
+            "transitions": {'solve puzzle': 'ruins_hiddenPassage', 'avoid traps': 'ruins_ruins'}
+        },
+        'hiddenPassage': {
+            "description": "You solve a challenging puzzle and unlock a hidden passage.",
+            "choices": ['enter passage', 'go back'],
+            "transitions": {'enter passage': 'ruins_treasureRoom', 'go back': 'ruins_explore'}
+        },
+        'treasureRoom': {
+            "description": "You enter the treasure room and find the treasure chest.",
+            "choices": ['take treasure', 'leave'],
+            "transitions": {'take treasure': 'ruins_celebrate', 'leave': 'ruins_ruins'},
+            "consequences": {
                 'take treasure': lambda player: player.add_item('treasure')
             }
-        ),
-        'celebrate': GameState(
-            "You celebrate your discovery and decide to bring the treasure back to the village.",
-            ['return to village'],
-            {'return to village': 'village_return'}
-        ),
+        },
+        'celebrate': {
+            "description": "You celebrate your discovery and decide to bring the treasure back to the village.",
+            "choices": ['return to village'],
+            "transitions": {'return to village': 'village_return'}
+        },
     },
     'village_return': {
-        'village_return': GameState(
-            "You return to the village with the treasure and share it with the villagers.",
-            ['end adventure'],
-            {'end adventure': 'end_end'}
-        ),
+        'village_return': {
+            "description": "You return to the village with the treasure and share it with the villagers.",
+            "choices": ['end adventure'],
+            "transitions": {'end adventure': 'end_end'}
+        },
     },
     'end': {
-        'end': GameState(
-            "Your adventure ends here. The villagers are grateful and everyone's lives improve.",
-            [],
-            {}
-        ),
+        'end': {
+            "description": "Your adventure ends here. The villagers are grateful and everyone's lives improve.",
+            "choices": [],
+            "transitions": {}
+        },
     }
 }
 
@@ -215,7 +203,7 @@ def validate_transitions(all_states):
     errors = []
     for location, states in all_states.items():
         for state_key, state in states.items():
-            for transition_key, transition_state in state.transitions.items():
+            for transition_key, transition_state in state['transitions'].items():
                 # Check if the transition is to another location
                 if transition_state in all_states:
                     trans_location, trans_state = transition_state, 'start'  # Assuming 'start' state for new locations
@@ -231,29 +219,35 @@ def validate_transitions(all_states):
     return errors
 
 path_errors = validate_transitions(all_states)
-# if path_errors:
-#     for error in path_errors:
-#         print(error)
-# else:
-#     print("All transitions are valid.")
+if path_errors:
+    for error in path_errors:
+        print(error)
+else:
+    print("All transitions are valid.")
 
 class GameSession:
-    def __init__(self):
+    def __init__(self, starting_location='village', starting_state='start'):
         self.player = Player()
-        self.current_location = 'village'
-        self.current_state = 'start'
+        self.current_location = starting_location
+        self.current_state = starting_state
         self.game_log = []
 
     def make_choice(self, choice_index):
         state = all_states[self.current_location][self.current_state]
-        if 0 <= choice_index < len(state.choices):
-            choice = state.choices[choice_index]
-            next_state = state.transitions[choice]
+        if 0 <= choice_index < len(state['choices']):
+            choice = state['choices'][choice_index]
+            next_state = state['transitions'][choice]
 
             self.game_log.append(f"You chose: {choice}")
-            self.game_log.append(state.description)
+            self.game_log.append(state['description'])
 
-            state.apply_consequence(choice, self.player)
+            if 'consequences' in state and choice in state['consequences']:
+              if state['consequences'][choice]:
+                  state['consequences'][choice](self.player)
+              else:
+                  # Handle empty consequence, e.g., log a message or provide a default action
+                  print(f"No consequence for choice: {choice}")
+                  # You can add any default action here if needed
 
             if '_' in next_state:
                 self.current_location, self.current_state = next_state.split('_')
@@ -266,11 +260,11 @@ class GameSession:
 
     def get_current_state_info(self):
         state = all_states[self.current_location][self.current_state]
-        choices = [f"{idx + 1}. {choice}" for idx, choice in enumerate(state.choices)]
-        return state.description, choices, "\n".join(self.game_log)
+        choices = [f"{idx + 1}. {choice}" for idx, choice in enumerate(state['choices'])]
+        return state['description'], choices, "\n".join(self.game_log)
 
-def start_game():
-    game_session = GameSession()
+def start_game(starting_location='village', starting_state='start'):
+    game_session = GameSession(starting_location, starting_state)
     description, choices, game_log = game_session.get_current_state_info()
     return description, choices, game_log, game_session
 
@@ -279,11 +273,56 @@ def make_choice(choice, game_session):
         description, choices, game_log = game_session.get_current_state_info()
         return description, choices, "Please select a choice before proceeding.", game_session
 
-    choice_index = game_session.get_current_state_info()[1].index(choice)
+    choice_index = int(choice.split('.')[0]) - 1 
     result = game_session.make_choice(choice_index)
 
     return result[0], gr.update(choices=result[1]), result[2], game_session
 
+def load_game(custom_config=None):
+    global all_states
+    if custom_config:
+        try:
+            new_config = json.loads(custom_config)
+
+            all_states = new_config
+
+            # Determine the starting location and state
+            starting_location = next(iter(all_states.keys()))
+            starting_state = next(iter(all_states[starting_location].keys()))
+
+            game_session = GameSession(starting_location, starting_state)
+            description, choices, game_log = game_session.get_current_state_info()
+            new_path_errors = validate_transitions(all_states)
+
+            return gr.update(value=f"Custom configuration loaded successfully! \n{new_path_errors}"), game_log, description, gr.update(choices=choices), game_session, gr.update(value=custom_config)
+        except json.JSONDecodeError as e:
+            # Get the line number and column of the error
+            lineno, colno = e.lineno, e.colno
+
+            # Get the problematic line
+            lines = custom_config.split('\n')
+            error_line = lines[lineno - 1] if lineno <= len(lines) else ""
+
+            # Create a pointer to the error location
+            pointer = ' ' * (colno - 1) + '^'
+
+            error_message = f"Invalid JSON format in custom configuration:\n"
+            error_message += f"Error at line {lineno}, column {colno}:\n"
+            error_message += f"{error_line}\n"
+            error_message += f"{pointer}\n"
+            error_message += f"Error details: {str(e)}"
+
+            return gr.update(value=error_message), gr.update(), gr.update(), None, gr.update(value=custom_config)
+        except Exception as e:
+            return gr.update(value=f"Error loading custom configuration: {str(e)}"), gr.update(), gr.update(), None, gr.update(value=custom_config)
+
+    # If no custom config, start with the default configuration
+    starting_location = next(iter(all_states.keys()))
+    starting_state = next(iter(all_states[starting_location].keys()))
+    game_session = GameSession(starting_location, starting_state)
+    description, choices, game_log = game_session.get_current_state_info()
+    return description, gr.update(choices=choices), game_log, game_session, gr.update()
+
 initgameinfo = start_game()
 
 
@@ -368,26 +407,28 @@ with gr.Blocks() as demo:
             gr.HTML("Some Kinds of game skeletons ideas - Timelines, Graph as State machine paths, Economy ecosystem")
             gr.HTML("One prompt to be used to test models - <br>Please make 10 python lists for the types of media files and their purposes in a game and then use those lists to random generate a timeline of 20 items when the function is called <br>Great next suggest ways to improve this function to create better timelines")
             with gr.Tab("Generate Timeline"):
-                gr.HTML("Placeholder")
-                gr.Markdown("# Story and Timeline Generator")
-                gr.Markdown("Click the button to generate a random timeline and story based on UI elements and story events.")
-
-                with gr.Row():
-                    timeline_output = gr.Textbox(label="Timeline", lines=20)
-                    story_output = gr.Textbox(label="Generated Story", lines=20)
-
-                generate_button = gr.Button("Generate Story and Timeline")
-                generate_button.click(generate_story_and_timeline, inputs=[], outputs=[timeline_output, story_output])
-            with gr.Tab("Test Example State Machine"):    
-                gr.HTML("Placeholder")
+                with gr.Tab("Without Asset generation consideration"):
+                    gr.Markdown("# Story and Timeline Generator")
+                    gr.Markdown("Click the button to generate a random timeline and story based on UI elements and story events.")
+
+                    with gr.Row():
+                        timeline_output = gr.Textbox(label="Timeline", lines=20)
+                        story_output = gr.Textbox(label="Generated Story", lines=20)
+
+                    generate_button = gr.Button("Generate Story and Timeline")
+                    generate_button.click(generate_story_and_timeline, inputs=[], outputs=[timeline_output, story_output])
+                with gr.Tab("Asset generation considered"):
+                    gr.HTML("placeholder")
+            with gr.Tab("Test Example State Machine"): 
                 with gr.Row():
                     with gr.Column(scale=2):
                         gr.Markdown("# Text-based Adventure Game")
+
                         description = gr.Textbox(label="Current Situation", lines=4, value=initgameinfo[0])
                         choices = gr.Radio(label="Your Choices", choices=initgameinfo[1])
                         submit_btn = gr.Button("Make Choice")
                         game_log = gr.Textbox(label="Game Log", lines=20, value=initgameinfo[2])
-                        game_session = gr.State(value=initgameinfo[3]) 
+                        game_session = gr.State(value=initgameinfo[3])
                         submit_btn.click(
                             make_choice,
                             inputs=[choices, game_session],
@@ -395,10 +436,16 @@ with gr.Blocks() as demo:
                         )
                     with gr.Column(scale=1):
                         gr.Markdown("# Debugging")
-                        gr.Textbox(label="Path Errors", lines=4, value=path_errors)
+                        error_box = gr.Textbox(label="Path Errors", lines=4, value=path_errors)
                         with gr.Accordion("Config (Game Spoiler)", open=False):
-                            custom_config = gr.Textbox(label="", value=all_states, lines=8)
-                            custom_configbtn = gr.Button("Load a new config")
+                            custom_config = gr.Textbox(label="Custom Configuration (JSON)", value=json.dumps(all_states, default=lambda o: o.__dict__, indent=2), lines=8)
+                            custom_configbtn = gr.Button("Load Custom Config")
+
+                            custom_configbtn.click(
+                                load_game,
+                                inputs=[custom_config],
+                                outputs=[error_box, game_log, description, choices, game_session, custom_config]
+                            )
                     
 
     with gr.Tab("Asset Generation"):
@@ -415,6 +462,7 @@ with gr.Blocks() as demo:
             gr.HTML("Images Generation Portraits = https://huggingface.co/spaces/okaris/omni-zero")
             gr.HTML("Images Generation General = https://huggingface.co/spaces/stabilityai/stable-diffusion-3-medium, https://huggingface.co/spaces/PixArt-alpha/PixArt-Sigma, https://huggingface.co/spaces/stabilityai/stable-diffusion, https://www.craiyon.com/, https://huggingface.co/spaces/prodia/sdxl-stable-diffusion-xl")
             gr.HTML("Images Generation Posters with text - https://huggingface.co/spaces/GlyphByT5/Glyph-SDXL-v2")
+            gr.HTML("Images Generation Very Specific position and shape - https://huggingface.co/spaces/linoyts/scribble-sdxl-flash")
             gr.HTML("SVG Generation = Coding models - ")
             gr.HTML("Placeholder for huggingface spaces that can assist <br> https://huggingface.co/spaces/gokaygokay/Florence-2 <br>")
             gr.HTML("Placeholder for models small enough to run on cpu here in this space that can assist")