Initial State Machine and Config assist ideas

app.py

@@ -1,4 +1,5 @@
 import gradio as gr
+import random
 
 # Default configuration template
 default_config = {
@@ -32,9 +33,265 @@ def add_target(targets_items, name, x, y, collisionType, collisiontext):
     targets_items.append(new_target)
     return targets_items
 
+#-----------------------------------------------------------------------------------------------------------------------------------
+
+# List of player engagement UI elements
+player_engagement_items = [
+    "Health Bar", "Mana/Energy Bar", "Experience Bar", "Mini-Map", "Quest Tracker",
+    "Inventory Quick Access Slots", "Skill Cooldown Indicators", "Currency Display",
+    "Compass", "Timer/Clock", "Action Prompts", "Reticle/Crosshair", "Enemy Health Bars",
+    "Score Display", "Inventory Grid", "Item Tooltip", "Item Categories/Tabs",
+    "Equip/Unequip Buttons", "Item Sorting Options", "Character Stats Panel",
+    "Character Model Viewer", "Quick Equip Slots", "Dialogue Box", "Dialogue Choices",
+    "Character Portraits", "Character Name Display", "Subtitle Text", "World Map",
+    "Local Map", "Fast Travel Points", "Map Markers", "Map Legend", "Crafting Recipe List",
+    "Ingredient Slots", "Craft Button", "Crafting Progress Bar", "Skill Nodes",
+    "Skill Descriptions", "Skill Point Counter", "Unlock Button", "Skill Path Highlight",
+    "Quest List", "Quest Details Panel", "Quest Objectives", "Quest Rewards",
+    "Quest Status Indicators", "Chat Box", "Player List", "Voice Chat Indicators",
+    "Ping/Latency Indicator", "Party/Team UI", "Scoreboard", "Matchmaking Screen",
+    "Pop-up Notifications", "Achievement Unlocks", "System Messages",
+    "On-screen Key Prompts", "Environmental Interaction Icons", "Save/Auto-Save Indicators",
+    "Credits Screen"
+]
+
+# List of character-based story events
+story_events = [
+    'exploreLocation', 'discoverClue', 'meetCharacter', 'solveRiddle', 'findItem',
+    'faceChallenge', 'makeDecision', 'engageBattle', 'unlockAbility', 'learnSecret',
+    'completeMission', 'experienceSetback', 'earnReward', 'uncoverMystery', 'formAlliance',
+    'faceBetrayal', 'confrontNemesis', 'makeDiscovery', 'overcomeLoss', 'achieveVictory'
+]
+
+def pick_random_items(items, n):
+    return random.sample(items, n)
+
+def generate_timeline(events, label):
+    timeline = []
+    for event in events:
+        timeline.append((random.randint(1, 100), label, event))
+    return timeline
+
+def create_story(timeline):
+    story = []
+    for entry in timeline:
+        if entry[1] == "Story":
+            story.append(f"The hero {entry[2].replace('engageBattle', 'engaged in a fierce battle').replace('solveRiddle', 'solved a complex riddle').replace('exploreLocation', 'explored a mysterious location')}.")
+        else:
+            story.append(f"The player interacted with {entry[2]}.")
+    return " ".join(story)
+
+def generate_story_and_timeline():
+    # Pick 10 random UI items
+    random_ui_items = pick_random_items(player_engagement_items, 10)
+
+    # Generate UI and story timelines
+    ui_timeline = generate_timeline(random_ui_items, "UI")
+    story_timeline = generate_timeline(story_events, "Story")
+
+    # Merge the timelines
+    merged_timeline = ui_timeline + story_timeline
+
+    # Sort the merged timeline based on the random numbers
+    merged_timeline.sort(key=lambda x: x[0])
+
+    # Create the story
+    story = create_story(merged_timeline)
+
+    # Format the timeline for display
+    formatted_timeline = "\n".join([f"{entry[0]}: {entry[1]} - {entry[2]}" for entry in merged_timeline])
+
+    return formatted_timeline, story
+
+#-----------------------------------------------------------------------------------------------------------------------------------
+
+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 = []
+        self.money = 20
+        self.knowledge = {}
+
+    def add_item(self, item):
+        self.inventory.append(item)
+
+    def has_item(self, item):
+        return item in self.inventory
+
+    def update_knowledge(self, topic):
+        self.knowledge[topic] = True
+
+# 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={
+                '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={
+                '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'}
+        ),
+    },
+    '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'}
+        ),
+    },
+    '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={
+                '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'}
+        ),
+    },
+    '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'}
+        ),
+    },
+    'end': {
+        'end': GameState(
+            "Your adventure ends here. The villagers are grateful and everyone's lives improve.",
+            [],
+            {}
+        ),
+    }
+}
+
+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():
+                # 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
+                elif '_' in transition_state:
+                    trans_location, trans_state = transition_state.split('_')
+                else:
+                    trans_location, trans_state = location, transition_state
+
+                # Validate the transition state
+                if trans_location not in all_states or trans_state not in all_states[trans_location]:
+                    errors.append(f"Invalid transition from {location}.{state_key} to {trans_location}.{trans_state}")
+
+    return errors
+
+path_errors = validate_transitions(all_states)
+# if path_errors:
+#     for error in path_errors:
+#         print(error)
+# else:
+#     print("All transitions are valid.")
+
+class GameSession:
+    def __init__(self):
+        self.player = Player()
+        self.current_location = 'village'
+        self.current_state = 'start'
+        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]
+
+            self.game_log.append(f"You chose: {choice}")
+            self.game_log.append(state.description)
+
+            state.apply_consequence(choice, self.player)
+
+            if '_' in next_state:
+                self.current_location, self.current_state = next_state.split('_')
+            else:
+                self.current_state = next_state
+
+            return self.get_current_state_info()
+        else:
+            return "Invalid choice. Please try again."
+
+    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)
+
+def start_game():
+    game_session = GameSession()
+    description, choices, game_log = game_session.get_current_state_info()
+    return description, choices, game_log, game_session
+
+def make_choice(choice, game_session):
+    if not choice:
+        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)
+    result = game_session.make_choice(choice_index)
+
+    return result[0], gr.update(choices=result[1]), result[2], game_session
+
+initgameinfo = start_game()
+
+
+#-----------------------------------------------------------------------------------------------------------------------------------
+
 with gr.Blocks() as demo:
     gr.HTML("Companion Space for zerogpu / client api workflow planning for a way to send a zip to the Basic Game Engine at the bottom of https://huggingface.co/spaces/KwabsHug/TestSvelteStatic (Also to test how much can be done majority on cpu)")
-    gr.HTML("Main ideas for this space is: <br>A program exist around data <br>We can generate almost any media data and more <br>llms good at short questions <br>Time moves in a straight so all considerations are flattend by the nature of time <br>HF + Gradio allows for api use so this my prototype tool for tool use test")
+    gr.HTML("Main ideas for this space is (June 2024): <br>A program exist around data <br>We can generate almost any media data and more <br>llms good at short questions <br>Time moves in a straight so all considerations are flattend by the nature of time <br>HF + Gradio allows for api use so this my prototype tool for tool use test")
     with gr.Tab("Config Creator"):
         with gr.Tab("Simple Config Creator"):
             inventory_items = gr.State([])
@@ -106,25 +363,59 @@ with gr.Blocks() as demo:
             add_target_button.click(aggregate_config, inputs=[inventory_items, skills_items, objectives_items, targets_items], outputs=config_output)
         
         with gr.Tab("Advanced Config Creator"):
-            gr.HTML("")
-
-    with gr.Tab("Skeleton and Asset Generation"):
-        gr.HTML("With some ideas from gemini-1.5-flash-api-0514 and reka-flash-preview-20240611")
-        with gr.Tab("Skeleton Generator"):
+            gr.HTML("Config with More than text and images")
+    with gr.Tab("Skeleton Generator"):
             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.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]) 
+                        submit_btn.click(
+                            make_choice,
+                            inputs=[choices, game_session],
+                            outputs=[description, choices, game_log, game_session]
+                        )
+                    with gr.Column(scale=1):
+                        gr.Markdown("# Debugging")
+                        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")
+                    
+
+    with gr.Tab("Asset Generation"):
+        gr.HTML("With some ideas from gemini-1.5-flash-api-0514 and reka-flash-preview-20240611")
 
         with gr.Tab("Save files"):
             gr.HTML("For Dynamic events overnight or when player is not active what can LLMS edit? <br><br>eg. Waiting for a letter from a random npc can be decided by the llm <br>eg. Improved Stats on certain days (eg. bitrthday) <br>Privacy <br>User Directed DLC eg. Rockstar Editor with local llm guide")
             gr.HTML("Placeholder for huggingface spaces that can assist  ")
-            gr.HTML("Placeholder for models small enough to run on cpu here in this space that can assist (9b and under) <br>initial floor for testing can be https://huggingface.co/spaces/Qwen/Qwen2-0.5B-Instruct, https://huggingface.co/spaces/Qwen/Qwen2-1.5b-instruct-demo, https://huggingface.co/spaces/stabilityai/stablelm-2-1_6b-zephyr, https://huggingface.co/spaces/IndexTeam/Index-1.9B, ")
+            gr.HTML("Placeholder for models small enough to run on cpu here in this space that can assist (9b and under) <br>initial floor for testing can be https://huggingface.co/spaces/Qwen/Qwen2-0.5B-Instruct, https://huggingface.co/spaces/Qwen/Qwen2-1.5b-instruct-demo, https://huggingface.co/spaces/stabilityai/stablelm-2-1_6b-zephyr, https://huggingface.co/spaces/IndexTeam/Index-1.9B, https://huggingface.co/microsoft/Phi-3-mini-4k-instruct")
 
         with gr.Tab("Images"):
             gr.HTML("Concept Art, UI elements, Static/3D Characters, Environments and Objects")
             gr.HTML("Image Caption =  https://huggingface.co/spaces/microsoft/Promptist, https://huggingface.co/spaces/gokaygokay/SD3-Long-Captioner, https://huggingface.co/spaces/gokaygokay/Florence-2,  ")
             gr.HTML("Images Generation Portraits = https://huggingface.co/spaces/okaris/omni-zero")
-            gr.HTML("Images Generation General =  ")
+            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("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")
         
@@ -136,22 +427,22 @@ with gr.Blocks() as demo:
 
         with gr.Tab("Video"):
             gr.HTML("Cutscenes, Tutorials, Trailers")
-            gr.HTML("Placeholder for huggingface spaces that can assist")
+            gr.HTML("Placeholder for huggingface spaces that can assist - https://huggingface.co/spaces/KingNish/Instant-Video, https://huggingface.co/spaces/multimodalart/stable-video-diffusion, https://huggingface.co/spaces/multimodalart/stable-video-diffusion")
             gr.HTML("Placeholder for models small enough to run on cpu here in this space that can assist")
 
         with gr.Tab("3D"):
             gr.HTML("Characters, Environments, Objects")
-            gr.HTML("Placeholder for huggingface spaces that can assist")
+            gr.HTML("Placeholder for huggingface spaces that can assist - https://huggingface.co/spaces/dylanebert/3d-arena, https://huggingface.co/spaces/stabilityai/TripoSR, https://huggingface.co/spaces/hysts/Shap-E")
             gr.HTML("Placeholder for models small enough to run on cpu here in this space that can assist")
 
         with gr.Tab("Animations (for lower resource use)"):
             gr.HTML("Characters, Environments, Objects")
-            gr.HTML("Placeholder for huggingface spaces that can assist")
+            gr.HTML("Placeholder for huggingface spaces that can assist - image as 3d object in video https://huggingface.co/spaces/ashawkey/LGM")
             gr.HTML("Placeholder for models small enough to run on cpu here in this space that can assist")
 
         with gr.Tab("Fonts"):
             gr.HTML("Style of whole game, or locations, or characters")
-            gr.HTML("Placeholder for huggingface spaces that can assist")
+            gr.HTML("Placeholder for huggingface spaces that can assist - there was a space that could make letter into pictures based on the prompt but I cant find it now")
             gr.HTML("Placeholder for models small enough to run on cpu here in this space that can assist")
         
         with gr.Tab("Shaders and related"):
@@ -175,6 +466,6 @@ with gr.Blocks() as demo:
             gr.HTML("Prototyping and freemium <br>free api <br>HF Pro subscription")
             gr.HTML("GPU (Data privacy) = No Rate limits? - https://lambdalabs.com/service/gpu-cloud https://huggingface.co/pricing#endpoints")
             gr.HTML("Speed - Groq, SambaNova, ")
-            gr.HTML("Price - Coding -  https://www.deepseek.com/ 0.3 per million")
+            gr.HTML("Price - Coding - https://aider.chat/docs/leaderboards/ -  https://www.deepseek.com/ 0.3 per million - is this per token or chinese character as that means converting code to chinese if possible can save api cost?")
 
 demo.launch()