Timeline to config for testing added

app.py

@@ -1,6 +1,7 @@
 import gradio as gr
 import random
 import json
+import re
 
 # Default configuration template
 default_config = {
@@ -36,6 +37,7 @@ def add_target(targets_items, name, x, y, collisionType, collisiontext):
 
 #-----------------------------------------------------------------------------------------------------------------------------------
 
+
 # List of player engagement UI elements
 player_engagement_items = [
     "Health Bar", "Mana/Energy Bar", "Experience Bar", "Mini-Map", "Quest Tracker",
@@ -104,6 +106,183 @@ def generate_story_and_timeline():
 
     return formatted_timeline, story
 
+media_file_types = ["image", "video", "audio"]
+
+def generate_media_file_list(n):
+    return [random.choice(media_file_types) for _ in range(n)]
+
+# Example usage
+media_files = generate_media_file_list(10)
+#print(media_files)
+
+def render_media_with_dropdowns(media_files):
+    rendered_output = []
+    for index, media in enumerate(media_files):
+        iframe = f'<iframe src="{media}_source_{index}.html"></iframe>'
+        dropdown = f'''
+        <select>
+            <option value="{media}_source_1">Source 1</option>
+            <option value="{media}_source_2">Source 2</option>
+            <option value="{media}_source_3">Source 3</option>
+        </select>
+        '''
+        rendered_output.append(f"{iframe}{dropdown}")
+    return rendered_output
+
+# Example usage
+rendered_media = render_media_with_dropdowns(media_files)
+#for item in rendered_media:
+#    print(item)
+
+def save_to_placeholder(rendered_media):
+    placeholder = []
+    for item in rendered_media:
+        placeholder.append(item)
+    return placeholder
+
+# Example usage
+placeholder = save_to_placeholder(rendered_media)
+#for item in placeholder:
+#    print(item)
+
+# Example usage with and without media-related items
+timeline_with_media, story_with_media = generate_story_and_timeline(include_media=True)
+timeline_without_media, story_without_media = generate_story_and_timeline(include_media=False)
+
+def split_content_into_blocks(timeline):
+    blocks = []
+    current_text_block = []
+    
+    for entry in timeline.split('\n'):
+        if 'Media -' in entry:
+            # If we have accumulated text, add it as a block
+            if current_text_block:
+                blocks.append((' '.join(current_text_block), 'text'))
+                current_text_block = []
+            
+            # Extract the iframe and dropdown
+            match = re.search(r'<iframe.*?</select>', entry, re.DOTALL)
+            if match:
+                blocks.append((match.group(), 'iframe'))
+        else:
+            current_text_block.append(entry)
+    
+    # Add any remaining text as a final block
+    if current_text_block:
+        blocks.append((' '.join(current_text_block), 'text'))
+    
+    return blocks
+
+def show_elements(text):
+    blocks = split_content_into_blocks(text)
+    outputs = []
+    
+    for content, block_type in blocks:
+        if block_type == 'text':
+            outputs.append(gr.Markdown(content))
+        elif block_type == 'iframe':
+            outputs.append(gr.HTML(content))
+    
+    return outputs
+
+def convert_timeline_to_game_structure(timeline):
+    lines = timeline.split('\n')
+    game_structure = {}
+    current_location = 0
+    sub_location = 0
+
+    for i, line in enumerate(lines):
+        if line.strip() == "":
+            continue
+        
+        if line[0].isdigit():  # New location starts
+            current_location += 1
+            sub_location = 0
+            location_key = f"location{current_location}"
+            game_structure[location_key] = {
+                "description": "",
+                "events": [],
+                "choices": ["continue"],
+                "transitions": {}
+            }
+        else:  # Continue with sub-locations or media entries
+            sub_location += 1
+            location_key = f"location{current_location}_{sub_location}"
+        
+        # Extract the event description
+        parts = line.split(': ', 1)
+        if len(parts) == 2:
+            prefix, rest = parts
+            event_parts = rest.split(' - ', 1)
+            if len(event_parts) == 2:
+                event_type, event_description = event_parts
+            else:
+                event_type, event_description = "Unknown", rest
+        else:
+            event_type, event_description = "Unknown", line
+        
+        description = rest.strip() if event_type in ["Media", "UI"] else f"{event_type}: {event_description}"
+        
+        if sub_location == 0:
+            game_structure[f"location{current_location}"]["description"] = description
+        else:
+            game_structure[f"location{current_location}"]["events"].append({
+                "description": description,
+                "type": event_type
+            })
+        
+        # Set the transition to the next location or to the end
+        if i < len(lines) - 1:
+            next_line = lines[i + 1].strip()
+            if next_line and next_line[0].isdigit():  # New location starts
+                game_structure[f"location{current_location}"]["transitions"]["continue"] = f"masterlocation1_location{current_location + 1}"
+            else:
+                #game_structure[f"location{current_location}"]["transitions"]["continue"] = f"location_{current_location}_{sub_location + 1}"
+                game_structure[f"location{current_location}"]["transitions"]["continue"] = "end"
+        else:
+            game_structure[f"location{current_location}"]["transitions"]["continue"] = "end"
+    
+    # Add an end location
+    game_structure["end"] = {
+        "description": "The adventure ends here.",
+#         "choices": [],
+#         "transitions": {}
+        "choices": ["restart"],
+        "transitions": {"restart": "location1"}  # Assuming location_1 is the start
+
+    }
+    
+    # Wrap the game structure in master_location1
+    wrapped_structure = {"masterlocation1": game_structure}
+    
+    return wrapped_structure
+    
+def generate_game_structures():
+    timeline_with_media, _ = generate_story_and_timeline(include_media=True)
+    timeline_without_media, _ = generate_story_and_timeline(include_media=False)
+    
+    game_structure_with_media = convert_timeline_to_game_structure(timeline_with_media)
+    game_structure_without_media = convert_timeline_to_game_structure(timeline_without_media)
+    
+    return game_structure_with_media, game_structure_without_media
+
+# Generate and print the game structures
+game_structure_with_media, game_structure_without_media = generate_game_structures()
+
+
+#print("Game Structure with Media:")
+#print(json.dumps(game_structure_with_media, indent=2))
+
+#print("\nGame Structure without Media:")
+#print(json.dumps(game_structure_without_media, indent=2))
+
+def show_game_structure(include_media):
+    if include_media:
+        return json.dumps(game_structure_with_media, indent=2)
+    else:
+        return json.dumps(game_structure_without_media, indent=2)
+
+
 #-----------------------------------------------------------------------------------------------------------------------------------
 
 class Player:
@@ -325,7 +504,6 @@ def load_game(custom_config=None):
 
 initgameinfo = start_game()
 
-
 #-----------------------------------------------------------------------------------------------------------------------------------
 
 with gr.Blocks() as demo:
@@ -419,6 +597,26 @@ with gr.Blocks() as demo:
                     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("Prototype for finegrained editing of time line before conversion to game format"):
+                        gr.Textbox(value=timeline_with_media)
+                        gr.Textbox(value=timeline_without_media)
+                        gr.HTML("Splits by new line")
+                        input_text = gr.Textbox(label="Input Text", lines=10)
+                        output_group = gr.Group()
+                        
+                        @gr.render(inputs=input_text)
+                        def update(text):
+                            return show_elements(text)
+                    with gr.Tab("Conversion of game version"):
+                        media_checkbox = gr.Checkbox(label="Include Media")
+                        output_text = gr.Code(language="json")
+                        
+                        media_checkbox.change(
+                            fn=show_game_structure,
+                            inputs=[media_checkbox],
+                            outputs=[output_text]
+                        )
             with gr.Tab("Test Example State Machine"): 
                 with gr.Row():
                     with gr.Column(scale=2):