Sounds epic—like a hyper‑dynamic story engine. Start by hashing out a data model for the world: a graph of scenes where each node holds a small script and a set of triggers. Use a lightweight state machine to keep track of player choices, then feed those into a language model to generate the next scene on the fly. You can prototype it in Python with something like Flask for the UI and OpenAI’s API for generation. Then iterate: tweak the prompt structure, add a simple caching layer to keep the world coherent, and test with a handful of branching paths. Let’s dive into the code and see what kind of emergent narrative we can cook up.

Let’s flesh out the graph first—quick Python sketch so you can see how it fits together. ```python # scene graph: id → {text, options: [{trigger, next_id}]} graph = { "start": { "text": "You’re in a dim hall. Two doors ahead.", "options": [ {"trigger": "open left", "next_id": "left_room"}, {"trigger": "open right", "next_id": "right_room"}, ], }, # ... more nodes } class StateMachine: def __init__(self, start_id="start"): self.current = start_id self.history = [] def choose(self, trigger): node = graph[self.current] for opt in node["options"]: if opt["trigger"] == trigger: self.history.append((self.current, trigger)) self.current = opt["next_id"] return graph[self.current]["text"] raise ValueError("invalid trigger") ``` That gives you a minimal engine you can hook into Flask. Want to drill into the prompt format next?

Here’s a quick function that stitches everything together, ready to hit the OpenAI endpoint. ``` import openai def build_prompt(current_text, trigger, history): # keep the last three interactions recent = " | ".join([f"{h[0]}:{h[1]}" for h in history[-3:]]) return ( f"You’re an interactive fiction engine. " f"Current scene: {current_text} " f"Player choice: {trigger} " f"Recent history: {recent}. " "Write the next paragraph of the story. " "Keep the tone and details consistent with the previous scenes. " "Do not mention that you’re an AI or give instructions—just the narrative." ) def generate_next_node(current_text, trigger, history): prompt = build_prompt(current_text, trigger, history) response = openai.ChatCompletion.create( model="gpt-4o-mini", messages=[ {"role": "system", "content": "You’re a creative storyteller."}, {"role": "user", "content": prompt}, ], temperature=0.8, max_tokens=200, ) return response.choices[0].message.content.strip() ```

Sure thing. Use a simple counter for ids and keep history as tuples of (node_id, trigger). Add an LRU cache for the last few paragraphs. Here’s a quick tweak. ``` from collections import OrderedDict node_counter = 0 history = [] # list of (node_id, trigger) lru_cache = OrderedDict() def next_node_id(): global node_counter node_counter += 1 return f"node_{node_counter}" def generate_next_node(current_id, trigger, history): # use the last 3 node ids for context recent = " | ".join([f"{h[0]}:{h[1]}" for h in history[-3:]]) prompt = ( f"You’re an interactive fiction engine. " f"Current scene id: {current_id}. " f"Player choice: {trigger}. " f"Recent history: {recent}. " "Write the next paragraph of the story. " "Keep tone and details consistent. " "Just the narrative." ) response = openai.ChatCompletion.create( model="gpt-4o-mini", messages=[ {"role": "system", "content": "You’re a creative storyteller."}, {"role": "user", "content": prompt}, ], temperature=0.8, max_tokens=200, ) text = response.choices[0].message.content.strip() # cache it lru_cache[current_id] = text if len(lru_cache) > 5: lru_cache.popitem(last=False) return text # example of adding a node current_id = "start" chosen_trigger = "open left" new_text = generate_next_node(current_id, chosen_trigger, history) new_id = next_node_id() graph[new_id] = {"text": new_text, "options": []} history.append((current_id, chosen_trigger)) current_id = new_id ```