Timeline Brainstorm

app.py

@@ -80,119 +80,10 @@ from relatively_constant_variables import *
 
 
 #---------
-#----------
-
-# # Initialize GPU tensor
-# zero = torch.Tensor([0]).cuda()
-# print(zero.device)  # This will print 'cpu' outside the @spaces.GPU decorated function
-
-# # Load the embedding model
-# embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
-
-# # Load the Qwen model and tokenizer
-# llmguide_model = AutoModelForCausalLM.from_pretrained(
-#     "Qwen/Qwen2-0.5B-Instruct",
-#     torch_dtype="auto",
-#     device_map="auto"
-# )
-# llmguide_tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
-
-# # Sample knowledge base (replace with your own data)
-# knowledge_base = [
-#     "The capital of France is Paris.",
-#     "Python is a popular programming language.",
-#     "Machine learning is a subset of artificial intelligence.",
-#     "The Earth orbits around the Sun.",
-#     "orbits are a group of fans of a music group"
-# ]
-
-# # Create embeddings for the knowledge base
-# knowledge_base_embeddings = embedding_model.encode(knowledge_base)
-
-# def retrieve(query, k=2):
-#     query_embedding = embedding_model.encode([query])
-#     similarities = torch.nn.functional.cosine_similarity(torch.tensor(query_embedding), torch.tensor(knowledge_base_embeddings))
-#     top_k_indices = similarities.argsort(descending=True)[:k]
-#     return [knowledge_base[i] for i in top_k_indices]
-
-# def get_resource_usage():
-#     ram_usage = psutil.virtual_memory().percent
-#     gpu_memory_allocated = torch.cuda.memory_allocated() / (1024 ** 3)  # Convert to GB
-#     gpu_memory_reserved = torch.cuda.memory_reserved() / (1024 ** 3)  # Convert to GB
-#     return f"RAM Usage: {ram_usage:.2f}%, GPU Memory Allocated: {gpu_memory_allocated:.2f}GB, GPU Memory Reserved: {gpu_memory_reserved:.2f}GB"
-
-# @spaces.GPU
-# def llmguide_generate_response(prompt, stream=False):
-#     print(zero.device)  # This will print 'cuda:0' inside the @spaces.GPU decorated function
-    
-#     messages = [
-#         {"role": "system", "content": "You are a helpful assistant."},
-#         {"role": "user", "content": prompt}
-#     ]
-#     text = llmguide_tokenizer.apply_chat_template(
-#         messages,
-#         tokenize=False,
-#         add_generation_prompt=True
-#     )
-#     model_inputs = llmguide_tokenizer([text], return_tensors="pt").to(zero.device)
-
-#     start_time = time.time()
-#     total_tokens = 0
-
-#     if stream:
-#         streamer = TextIteratorStreamer(llmguide_tokenizer, skip_special_tokens=True)
-#         generation_kwargs = dict(
-#             model_inputs,
-#             streamer=streamer,
-#             max_new_tokens=512,
-#             temperature=0.7,
-#         )
-#         thread = Thread(target=llmguide_model.generate, kwargs=generation_kwargs)
-#         thread.start()
-
-#         generated_text = ""
-#         for new_text in streamer:
-#             generated_text += new_text
-#             total_tokens += 1
-#             current_time = time.time()
-#             tokens_per_second = total_tokens / (current_time - start_time)
-#             yield generated_text, f"{tokens_per_second:.2f}", ""
-
-#         resource_usage = get_resource_usage()
-#         yield generated_text, f"{tokens_per_second:.2f}", resource_usage
-#     else:
-#         generated_ids = llmguide_model.generate(
-#             model_inputs.input_ids,
-#             max_new_tokens=512
-#         )
-#         generated_ids = [
-#             output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
-#         ]
-#         response = llmguide_tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
-#         total_tokens = len(generated_ids[0])
-#         end_time = time.time()
-#         tokens_per_second = total_tokens / (end_time - start_time)
-#         resource_usage = get_resource_usage()
-#         yield response, f"{tokens_per_second:.2f}", resource_usage
-
-# def rag(query, stream=False):
-#     retrieved_docs = retrieve(query)
-#     context = " ".join(retrieved_docs)
-#     prompt = f"Context: {context}\nQuestion: {query}\nAnswer:"
-    
-#     generator = llmguide_generate_response(prompt, stream)
-    
-#     if stream:
-#         def stream_output():
-#             for generated_text, tokens_per_second, ram_usage in generator:
-#                 yield generated_text, tokens_per_second, ram_usage
-#         return stream_output()
-#     else:
-#         # For non-streaming, we just need to get the final output
-#         for generated_text, tokens_per_second, ram_usage in generator:
-#             pass  # This will iterate to the last yield
-#         return generated_text, tokens_per_second, ram_usage
 
+# # Initialize the zero tensor on CUDA
+zero = torch.Tensor([0]).cuda()
+print(zero.device)  # This will print 'cpu' outside the @spaces.GPU decorated function
 
 # Load the embedding model
 embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
@@ -222,6 +113,8 @@ def get_ram_usage():
 
 @spaces.GPU
 def llmguide_generate_response(prompt, doc_ids=None, stream=False):
+    print(zero.device)  # This will print 'cuda:0' inside the @spaces.GPU decorated function
+
     messages = [
         {"role": "system", "content": "You are a helpful assistant."},
         {"role": "user", "content": prompt}
@@ -295,9 +188,6 @@ def process_query(query, use_rag, stream=False):
             pass  # This will iterate to the last yield
         return generated_text, tokens_per_second, ram_usage, doc_references
 
-
-#--------------------------------------------------------------------------------------------------------------------------------
-
 #importing FAQAllprompts from relatively_constant_variables
 
 #--------------------------------------------------------------------------------------------------------------------------------
@@ -809,21 +699,47 @@ def refresh_file_explorer():
 
 #-----------------------------------------------------------------------------------------------------------------------------------
 
-def timeline_get_random_suggestions(num_lists, items_per_list):
+# def timeline_get_random_suggestions(num_lists, items_per_list):
+#     """
+#     Generate random suggestions from a specified number of lists.
+    
+#     :param num_lists: Number of lists to consider
+#     :param items_per_list: Number of items to select from each list
+#     :return: A list of randomly selected suggestions
+#     """
+#     selected_lists = random.sample(all_idea_lists, min(num_lists, len(all_idea_lists)))
+#     suggestions = []
+    
+#     for lst in selected_lists:
+#         suggestions.extend(random.sample(lst, min(items_per_list, len(lst))))
+    
+#     return suggestions
+
+def timeline_get_random_suggestions(num_lists, items_per_list, include_existing_games, include_multiplayer):
     """
     Generate random suggestions from a specified number of lists.
     
     :param num_lists: Number of lists to consider
     :param items_per_list: Number of items to select from each list
-    :return: A list of randomly selected suggestions
+    :param include_existing_games: Whether to include existing game inspiration lists
+    :param include_multiplayer: Whether to include multiplayer features list
+    :return: A tuple containing the list of randomly selected suggestions and the names of selected lists
     """
-    selected_lists = random.sample(all_idea_lists, min(num_lists, len(all_idea_lists)))
+    available_lists = all_idea_lists.copy()
+    if not include_existing_games:
+        available_lists = [lst for lst in available_lists if lst not in existing_game_inspirations]
+    if not include_multiplayer:
+        available_lists = [lst for lst in available_lists if lst != multiplayer_features]
+    
+    selected_lists = random.sample(available_lists, min(num_lists, len(available_lists)))
     suggestions = []
+    selected_list_names = []
     
     for lst in selected_lists:
         suggestions.extend(random.sample(lst, min(items_per_list, len(lst))))
+        selected_list_names.append(list_names[all_idea_lists.index(lst)])
     
-    return suggestions
+    return suggestions, selected_list_names
 
 #-----------------------------------------------------------------------------------------------------------------------------------
 
@@ -911,15 +827,28 @@ with gr.Blocks() as demo:
                 gr.HTML(f"placeholder for current empty JSON config shape")
                 gr.HTML("Structural indicators of quality of config")
             with gr.Tab("Random Suggestions"):
+                # timeline_num_lists_slider = gr.Slider(minimum=1, maximum=len(all_idea_lists), step=1, label="Number of Lists to Consider", value=3)
+                # timeline_items_per_list_slider = gr.Slider(minimum=1, maximum=10, step=1, label="Items per List", value=3)
+                # timeline_generate_button = gr.Button("Generate Random Suggestions")
+                # timeline_output_text = gr.Textbox(label="Random Suggestions", lines=10)
+
+                # timeline_generate_button.click(
+                #     timeline_get_random_suggestions,
+                #     inputs=[timeline_num_lists_slider, timeline_items_per_list_slider],
+                #     outputs=[timeline_output_text]
+                # )
                 timeline_num_lists_slider = gr.Slider(minimum=1, maximum=len(all_idea_lists), step=1, label="Number of Lists to Consider", value=3)
                 timeline_items_per_list_slider = gr.Slider(minimum=1, maximum=10, step=1, label="Items per List", value=3)
+                timeline_include_existing_games = gr.Checkbox(label="Include Existing Game Inspirations", value=True)
+                timeline_include_multiplayer = gr.Checkbox(label="Include Multiplayer Features", value=True)
                 timeline_generate_button = gr.Button("Generate Random Suggestions")
                 timeline_output_text = gr.Textbox(label="Random Suggestions", lines=10)
+                timeline_selected_lists_text = gr.Textbox(label="Selected Lists", lines=2)
 
                 timeline_generate_button.click(
                     timeline_get_random_suggestions,
-                    inputs=[timeline_num_lists_slider, timeline_items_per_list_slider],
-                    outputs=[timeline_output_text]
+                    inputs=[timeline_num_lists_slider, timeline_items_per_list_slider, timeline_include_existing_games, timeline_include_multiplayer],
+                    outputs=[timeline_output_text, timeline_selected_lists_text]
                 )
             with gr.Tab("Config Specific"): 
                 gr.HTML("Timeline for making Timelines?")

relatively_constant_variables.py

@@ -870,6 +870,119 @@ TestmedialoadinHTML = """
 
 #-------------------------#-------------------------#-------------------------#------------------------- 
 
+timeline_components = [
+    "Story progression tracker",
+    "Inventory management system",
+    "Character stat system",
+    "Quest log",
+    "Achievement system",
+    "NPC relationship tracker",
+    "Time and weather simulation",
+    "Economy and trading system",
+    "Crafting system",
+    "Skill tree",
+    "Dialogue manager",
+    "Combat system",
+    "Save/Load system",
+    "Random event generator",
+    "Faction reputation system"
+]
+
+# Decisions (and context explanation)
+timeline_decision_features = [
+    "Moral alignment system (good/neutral/evil)",
+    "Consequence ripple effect (choices affect multiple future events)",
+    "Timed decisions (limited time to choose)",
+    "Hidden choices (unlocked by specific conditions)",
+    "Context-sensitive options (choices change based on character stats/items)",
+    "Dialogue trees with branching paths",
+    "Risk/reward choices (high risk, high reward options)",
+    "Character personality development through choices",
+    "Relationship-altering decisions",
+    "Story-altering key decisions",
+    "Multi-step decision processes",
+    "Decision journals (recap of major choices)",
+    "Faction-based decisions",
+    "Profession or class-specific choices",
+    "Ethical dilemmas with no clear 'right' answer"
+]
+
+# Nested Sections
+timeline_nested_section_ideas = [
+    "Multilevel dungeons",
+    "City districts with sub-locations",
+    "Planetary system with multiple explorable planets",
+    "Dreamworld with nested dreams",
+    "Time periods (past, present, future) with sub-events",
+    "Parallel universes with alternate versions of locations",
+    "Miniature worlds inside objects",
+    "Body systems (for a medical game or body-exploration adventure)",
+    "Nested memories or flashbacks",
+    "Virtual reality levels within the game world",
+    "Dimensional rifts with sub-dimensions",
+    "Organizational hierarchies (e.g., crime family structure)",
+    "Ecosystem layers (e.g., forest canopy, understory, forest floor)",
+    "Nested puzzles (solving one unlocks another)",
+    "Matryoshka doll-like structures with hidden secrets"
+]
+
+# Media (Especially to affect decisions)
+timeline_media_integration = [
+    "Dynamic background music changing with mood/tension",
+    "Character portrait changes reflecting emotional states",
+    "Environmental sound effects influencing player choices",
+    "Visual cues (color schemes, lighting) hinting at outcomes",
+    "Cinematic cutscenes revealing crucial information",
+    "Interactive maps updating with player discoveries",
+    "Voice acting with tone influencing trustworthiness",
+    "Symbolic imagery foreshadowing consequences",
+    "Augmented reality overlays providing decision hints",
+    "Character theme motifs indicating importance of NPCs",
+    "Weather effects reflecting story mood",
+    "Dream sequences visualizing potential outcomes",
+    "Time-lapse visuals showing long-term effects of choices",
+    "Split-screen effects for simultaneous events",
+    "Flashback scenes providing context for decisions"
+]
+
+# Replayability (GTA and Tekken type mechanics in text form)
+timeline_replayability_features = [
+    "Multiple character origins with unique storylines",
+    "Randomized side quests and events",
+    "Unlockable skills and abilities for subsequent playthroughs",
+    "New Game+ mode with increased difficulty and rewards",
+    "Alternative routes to objectives",
+    "Hidden endings based on specific choices or achievements",
+    "Character customization affecting story and gameplay",
+    "Faction system with different allegiances each playthrough",
+    "Time-based events that change on each playthrough",
+    "Roguelike elements (permadeath, procedural generation)",
+    "Challenge modes (speed runs, minimalist runs)",
+    "Branching skill trees with mutually exclusive paths",
+    "Collectibles that unlock new content or lore",
+    "Dynamic world events that evolve differently each time",
+    "Secret characters or modes to unlock"
+]
+
+# Theme integration (Modified Variables that affect UI or config order)
+timeline_theme_integration = [
+    "Dynamic UI color schemes based on location or story progress",
+    "Font styles changing with different eras or dimensions",
+    "Adaptive music system reflecting current theme",
+    "UI element shapes and designs matching the current environment",
+    "Loading screen tips and lore adapted to current theme",
+    "Cursor or pointer design changing with themes",
+    "Theme-specific animations for transitions between scenes",
+    "Variable text descriptors (e.g., 'cold' vs 'scorching' based on environment)",
+    "Themed icons for inventory and skills",
+    "Background textures or patterns reflecting current setting",
+    "Character portrait frames styled to match the theme",
+    "Theme-specific sound effects for UI interactions",
+    "Adaptive difficulty adjustments based on chosen theme",
+    "Mini-map or navigation elements styled to fit the theme",
+    "Theme-specific filters or overlays for the game view"
+]
+
 # GTA Heists - Same Map with overlapping branching narratives
 gta_heist_inspired = [
     "Multiple missions/quests available in the same location",