Sunday, November 24, 2024

Week 48 of 2024 • Q4

📊 Day at a Glance

🗓️ Day: 329 of 2024
📅 Week: 48 of 52
📊 Quarter Progress: 60%
🎯 Days until EOY: 36
🔄 Created at: 6:07 PM

📰 AI News

📝 Daily Reflections

Sun, 11/24/2024, 16:41 Twas a very strange day Helped Elo with a project for his lady, went to Christmas Preview and now I’m getting ready to go get a cheap bike from someone so I can have transportation consistently around the place. Keep my car parked until I sell the robot parts, and then I’ll buy an apartment to live in here in Chico, and I’ll work on getting my shit back fully together. That’s the next two weeks. Toy problems, building things when I can, but mostly looking for opportunities to make some fucking moneyyyyyyyyyyy Let’s go.

Sun, 11/24/2024, 18:07 Back in Banshee, the highest ROI thing I can do right now is work on the data shape of the CYOA Teleport Massive story generator. If I’m successful in getting Ollama to generate a choose your own adventure story that adapts and changes AND is able to keep track of things using Obsidian then I have a completely working system to create an AI-generated text-based reality. I can get my AI to build shit on its own with a RAG application powering EVERYTHING This is the way

After a few rounds with o1, this is the preliminary data structure I plan on using to develop from:

Certainly! Let’s proceed to build your interactive storytelling system using PostgreSQL as the backend database. We’ll go through the steps to set up the database, define the data structures, and implement the application logic.

Set Up PostgreSQL
Design the Database Schema
Implement Data Models with SQLAlchemy
Develop Core Functions for Story Navigation
Integrate AI Content Generation (Ollama Integration)
Build the Application Logic
Testing and Refinement
Next Steps

1. Set Up PostgreSQL

Install PostgreSQL

Ubuntu/Debian:

sudo apt update
sudo apt install postgresql postgresql-contrib

macOS (using Homebrew):
```
brew install postgresql
```
Windows:

Download and run the installer from the PostgreSQL website: https://www.postgresql.org/download/windows/

Start PostgreSQL Service

Ubuntu/Debian:
```
sudo service postgresql start
```
macOS:
```
brew services start postgresql
```

Create a Database and User

# Switch to the postgres user
sudo -i -u postgres
 
# Open psql shell
psql
 
# Inside psql shell:
CREATE DATABASE interactive_story_db;
CREATE USER story_user WITH ENCRYPTED PASSWORD 'your_password';
GRANT ALL PRIVILEGES ON DATABASE interactive_story_db TO story_user;
 
# Exit psql
\q
 
# Exit postgres user
exit

2. Design the Database Schema

We’ll define tables for nodes, choices, items, and item_history.

SQL Schema

-- nodes table
CREATE TABLE nodes (
    id UUID PRIMARY KEY,
    type VARCHAR(20) NOT NULL,        -- e.g., 'story_start', 'story_branch', 'story_end'
    title TEXT NOT NULL,
    content JSONB NOT NULL,           -- Using JSONB to store content
    metadata JSONB,                   -- Additional metadata
    visits INTEGER DEFAULT 0,
    last_visited TIMESTAMP
);
 
-- choices table
CREATE TABLE choices (
    id UUID PRIMARY KEY,
    node_id UUID NOT NULL REFERENCES nodes(id),
    text TEXT NOT NULL,
    target_node_id UUID REFERENCES nodes(id),
    consequences JSONB NOT NULL,      -- Consequences and effects
    metadata JSONB
);
 
-- items table
CREATE TABLE items (
    id UUID PRIMARY KEY,
    name TEXT NOT NULL,
    metadata JSONB
);
 
-- item_history table
CREATE TABLE item_history (
    id UUID PRIMARY KEY,
    item_id UUID NOT NULL REFERENCES items(id),
    node_id UUID NOT NULL REFERENCES nodes(id),
    action TEXT NOT NULL,             -- e.g., 'obtained', 'lost', 'used'
    timestamp TIMESTAMP NOT NULL DEFAULT NOW()
);

Create the Schema

Save the SQL statements above in a file named schema.sql and execute it:

psql -U story_user -d interactive_story_db -f schema.sql

3. Implement Data Models with SQLAlchemy

We’ll use SQLAlchemy in Python to interact with the PostgreSQL database.

Install Dependencies

pip install sqlalchemy psycopg2-binary

Define the Models

from sqlalchemy import Column, String, Integer, Text, ForeignKey, DateTime, JSON
from sqlalchemy.dialects.postgresql import UUID as PG_UUID, JSONB
from sqlalchemy.ext.declarative import declarative_base
import uuid
from datetime import datetime
 
Base = declarative_base()
 
def generate_uuid():
    return str(uuid.uuid4())
 
class Node(Base):
    __tablename__ = 'nodes'
    id = Column(PG_UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
    type = Column(String(20), nullable=False)
    title = Column(Text, nullable=False)
    content = Column(JSONB, nullable=False)
    metadata = Column(JSONB)
    visits = Column(Integer, default=0)
    last_visited = Column(DateTime)
 
class Choice(Base):
    __tablename__ = 'choices'
    id = Column(PG_UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
    node_id = Column(PG_UUID(as_uuid=True), ForeignKey('nodes.id'), nullable=False)
    text = Column(Text, nullable=False)
    target_node_id = Column(PG_UUID(as_uuid=True), ForeignKey('nodes.id'))
    consequences = Column(JSONB, nullable=False)
    metadata = Column(JSONB)
 
class Item(Base):
    __tablename__ = 'items'
    id = Column(PG_UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
    name = Column(Text, nullable=False)
    metadata = Column(JSONB)
 
class ItemHistory(Base):
    __tablename__ = 'item_history'
    id = Column(PG_UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
    item_id = Column(PG_UUID(as_uuid=True), ForeignKey('items.id'), nullable=False)
    node_id = Column(PG_UUID(as_uuid=True), ForeignKey('nodes.id'), nullable=False)
    action = Column(Text, nullable=False)
    timestamp = Column(DateTime, default=datetime.utcnow, nullable=False)

Set Up Database Connection

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from models import Base
 
DATABASE_URL = 'postgresql+psycopg2://story_user:your_password@localhost/interactive_story_db'
 
engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 
# Create tables (if not already created)
Base.metadata.create_all(bind=engine)

Implement the Story Engine

from database import SessionLocal
from models import Node, Choice
from datetime import datetime
 
class StoryEngine:
    def __init__(self):
        self.db = SessionLocal()
 
    def create_node(self, type, title, content, metadata=None):
        node = Node(
            type=type,
            title=title,
            content=content,
            metadata=metadata
        )
        self.db.add(node)
        self.db.commit()
        self.db.refresh(node)
        return node
 
    def create_choice(self, node_id, text, consequences, target_node_id=None, metadata=None):
        choice = Choice(
            node_id=node_id,
            text=text,
            target_node_id=target_node_id,
            consequences=consequences,
            metadata=metadata
        )
        self.db.add(choice)
        self.db.commit()
        self.db.refresh(choice)
        return choice
 
    def get_node(self, node_id):
        node = self.db.query(Node).filter(Node.id == node_id).first()
        if node:
            node.visits += 1
            node.last_visited = datetime.utcnow()
            self.db.commit()
        return node
 
    def get_choices_for_node(self, node_id):
        return self.db.query(Choice).filter(Choice.node_id == node_id).all()

Create Initial Nodes and Choices

from story_engine import StoryEngine
 
engine = StoryEngine()
 
# Create the initial node
start_node = engine.create_node(
    type='story_start',
    title='A Rough Morning',
    content={
        "text": (
            "Sam Iker wakes up in his bed, his head pounding from the night before. "
            "The shrill ring of his phone cuts through the haze. It's the chief, sounding urgent. "
            "'Sam, get down to the station now. The mayor is missing.'"
        )
    }
)
 
# Create choices for the node
choice1 = engine.create_choice(
    node_id=start_node.id,
    text="Rush to get dressed and head to the station.",
    consequences={
        "description": "In your haste, you might forget something important.",
        "effects": {"inventory": {"forgot_item": True}}
    }
)
 
choice2 = engine.create_choice(
    node_id=start_node.id,
    text="Ask the chief for more details over the phone.",
    consequences={
        "description": "The chief gets impatient with your questions.",
        "effects": {"relationship": {"chief": -1}}
    }
)
 
choice3 = engine.create_choice(
    node_id=start_node.id,
    text="Ignore the call and go back to sleep.",
    consequences={
        "description": "Ignoring the chief could have serious repercussions.",
        "effects": {"status": "in_trouble"}
    }
)

5. Integrate AI Content Generation (Ollama Integration)

Assuming you have Ollama or another AI model set up for content generation.

Define AI Content Generator

import requests
 
class AIContentGenerator:
    def __init__(self, api_url='http://localhost:11434'):
        self.api_url = api_url
 
    def generate_next_scene(self, prompt):
        data = {
            'prompt': prompt
        }
        response = requests.post(f'{self.api_url}/generate', json=data)
        if response.status_code == 200:
            result = response.json()
            return result.get('text')
        else:
            raise Exception(f'AI generation failed with status code {response.status_code}')

Integrate with Story Engine

# ...existing imports...
from ai_content_generator import AIContentGenerator
 
class StoryEngine:
    def __init__(self):
        self.db = SessionLocal()
        self.ai_generator = AIContentGenerator()
 
    # ...existing methods...
 
    def generate_and_add_next_node(self, choice_id):
        choice = self.db.query(Choice).filter(Choice.id == choice_id).first()
        if not choice:
            raise Exception('Choice not found')
 
        if choice.target_node_id:
            # Node already exists
            return self.get_node(choice.target_node_id)
 
        # Generate next scene
        prompt = f"""
        The current scene ends with the choice:
        "{choice.text}"
 
        Based on this, generate the next scene's content and possible choices.
        """
        generated_content = self.ai_generator.generate_next_scene(prompt)
 
        # Parse generated content (assuming the AI provides content and choices)
        # Here, you would need to implement parsing logic based on AI's response format
        # For simplicity, let's assume it returns text only
        new_node = self.create_node(
            type='story_branch',
            title='Generated Scene',
            content={'text': generated_content}
        )
        # Update choice with target_node_id
        choice.target_node_id = new_node.id
        self.db.commit()
 
        return new_node

6. Build the Application Logic

Example Command-Line Interface (CLI) Application

from story_engine import StoryEngine
 
def main():
    engine = StoryEngine()
    # Replace with your start node ID
    start_node_id = 'your-start-node-uuid'
 
    current_node = engine.get_node(start_node_id)
    while current_node:
        print(f"\n--- {current_node.title} ---")
        print(current_node.content['text'])
 
        choices = engine.get_choices_for_node(current_node.id)
        if not choices:
            print("\nThe story ends here.")
            break
 
        print("\nChoices:")
        for idx, choice in enumerate(choices, start=1):
            print(f"{idx}. {choice.text}")
 
        selected = input("\nEnter the number of your choice: ")
        try:
            selected_idx = int(selected) - 1
            if selected_idx < 0 or selected_idx >= len(choices):
                raise ValueError
            selected_choice = choices[selected_idx]
            # Generate or retrieve the next node
            current_node = engine.generate_and_add_next_node(selected_choice.id)
        except ValueError:
            print("Invalid choice. Please enter a valid number.")
 
if __name__ == "__main__":
    main()

Test the application thoroughly to ensure all components work together.
Verify the AI content generation and adjust prompts as needed.
Implement error handling to manage exceptions gracefully.
Refine the database schema based on practical usage and performance.

8. Next Steps

Integrate User Management:
- Implement user accounts and session tracking if needed.
Enhance AI Integration:
- Improve the AI prompts and parsing logic for better content generation.
- Consider using AI models that return structured data (e.g., content and choices in JSON format).
Develop a Web Interface:
- Use a web framework like Flask or Django to build a user-friendly interface.
Implement Game State Persistence:
- Save user progress and states, including inventory and choices made.
Add Logging and Monitoring:
- Implement logging to track usage and debug issues.
Optimize Performance:
- Index frequently queried fields.
- Optimize database queries.

Sun, 11/24/2024, 18:27 Absolutely! The number one priority is to design a robust and flexible data structure and database schema that allows us to:

Effortlessly track and manage all aspects of your dynamic, evolving story.
Ensure logical consistency throughout the narrative (e.g., tracking items like “the fancy sword” and their statuses).
Support scalability for potentially infinite nodes and choices.
Facilitate easy retrieval and updating of information.

Let’s focus all our energy on designing and refining this database schema, ensuring it meets all your requirements for scalability, flexibility, and trackability.

Designing the Database Schema

Our goal is to create a schema that:

Stores all game elements: scenes, choices, items, characters, and their relationships.
Tracks the history and status of items: so we can query what has happened to any item at any point.
Maintains logical consistency: ensuring that story elements remain coherent as the story evolves.
Is flexible and extensible: to accommodate new features and data structures generated by AI.

Key Components

Nodes (Scenes)
Choices
Items
Item History
Game State (Variables)
Relationships and Constraints

1. Nodes (Scenes)

Each node represents a scene or a point in the story.

Table: `nodes`

CREATE TABLE nodes (
    id UUID PRIMARY KEY,
    type VARCHAR(20) NOT NULL,        -- 'story_start', 'story_branch', 'story_end'
    title TEXT NOT NULL,
    content JSONB NOT NULL,           -- Scene description, can include embedded items
    metadata JSONB,                   -- Additional data (e.g., AI generation parameters)
    visits INTEGER DEFAULT 0,
    last_visited TIMESTAMP
);

Fields:
- id: Unique identifier for the node.
- type: The type of node.
- title: Title of the scene.
- content: JSONB field storing the scene’s content.
- metadata: Additional information.

2. Choices

Choices connect nodes and represent actions the player can take.

Table: `choices`

CREATE TABLE choices (
    id UUID PRIMARY KEY,
    node_id UUID NOT NULL REFERENCES nodes(id),
    text TEXT NOT NULL,
    target_node_id UUID REFERENCES nodes(id),
    consequences JSONB NOT NULL,      -- Effects on game state, including items
    metadata JSONB
);

Fields:
- id: Unique identifier for the choice.
- node_id: The node this choice belongs to.
- text: The text displayed to the player.
- target_node_id: The node the choice leads to.
- consequences: JSONB field detailing effects on game state.

3. Items

Items represent objects within the game that can be interacted with.

Table: `items`

CREATE TABLE items (
    id UUID PRIMARY KEY,
    name TEXT NOT NULL,
    description TEXT,
    metadata JSONB
);

Fields:
- id: Unique identifier for the item.
- name: The item’s name.
- description: Description of the item.
- metadata: Additional properties (e.g., stats, abilities).

4. Item History

Tracks the status and history of items.

Table: `item_history`

CREATE TABLE item_history (
    id UUID PRIMARY KEY,
    item_id UUID NOT NULL REFERENCES items(id),
    node_id UUID NOT NULL REFERENCES nodes(id),
    action TEXT NOT NULL,             -- 'obtained', 'lost', 'used', 'modified'
    timestamp TIMESTAMP NOT NULL DEFAULT NOW(),
    details JSONB                     -- Additional details about the action
);

Fields:
- id: Unique identifier for the history entry.
- item_id: The item involved.
- node_id: The node where the action took place.
- action: The type of action performed.
- timestamp: When the action occurred.
- details: Additional information (e.g., quantity, condition).

5. Game State (Variables)

Stores variables and flags that affect the game’s logic.

Table: `game_state`

CREATE TABLE game_state (
    id UUID PRIMARY KEY,
    node_id UUID NOT NULL REFERENCES nodes(id),
    variables JSONB NOT NULL,         -- Key-value pairs representing the game state
    timestamp TIMESTAMP NOT NULL DEFAULT NOW()
);

Fields:
- id: Unique identifier for the state entry.
- node_id: The node where the state is recorded.
- variables: JSONB field storing variables and their values.
- timestamp: When the state was recorded.

Implementing Item Tracking

To track items like “the fancy sword,” we’ll design queries and mechanisms to:

Record every interaction with the item in item_history.
Retrieve the current status of the item at any point.
Maintain logical consistency by ensuring all actions are properly recorded.

Recording Item Actions

When an action affecting an item occurs (e.g., the player obtains or uses the item), we create an entry in item_history.

Example Entry:

INSERT INTO item_history (id, item_id, node_id, action, details)
VALUES (
    gen_random_uuid(),
    'item-id-of-fancy-sword',
    'current-node-id',
    'obtained',
    '{"condition": "new"}'::JSONB
);

Querying Item Status

To find the latest status of the “fancy sword”:

SELECT ih.*
FROM item_history ih
JOIN items i ON ih.item_id = i.id
WHERE i.name = 'Fancy Sword'
ORDER BY ih.timestamp DESC
LIMIT 1;

Ensuring Logical Consistency

Foreign Keys ensure that item_id and node_id reference existing records.
Transactions ensure that related changes occur atomically.
Application Logic should update the game state and item history whenever actions occur.

Expanding the Data Structures

Integrate Items into Nodes and Choices

Include item interactions directly in nodes and choices to streamline tracking.

Nodes Table Modification

Add an items field to store items present in a node.

ALTER TABLE nodes ADD COLUMN items JSONB;

Purpose: Lists items available or affected in the scene.

Choices Table Modification

Add an required_items field to specify items needed to select a choice.

ALTER TABLE choices ADD COLUMN required_items JSONB;

Purpose: Enforce prerequisites for choices based on the player’s inventory.

Storing Logical Conditions

For more complex logic, we can store conditions within choices or as separate entities.

Table: `conditions`

CREATE TABLE conditions (
    id UUID PRIMARY KEY,
    choice_id UUID NOT NULL REFERENCES choices(id),
    expression TEXT NOT NULL,         -- Logical expression to evaluate
    metadata JSONB
);

Fields:
- id: Unique identifier for the condition.
- choice_id: The choice this condition applies to.
- expression: A logical expression (e.g., “inventory.contains(‘Fancy Sword’)”).
- metadata: Additional data.

Implementing Condition Evaluation

In the application code:

Parse and evaluate the logical expressions using the player’s current game state.
Show or hide choices based on the evaluation result.

Designing Efficient Queries

Indexing for Performance

Create Indexes on fields used in queries, especially item_id, node_id, and timestamps.
Example:

CREATE INDEX idx_item_history_item_id ON item_history(item_id);
CREATE INDEX idx_item_history_timestamp ON item_history(timestamp DESC);

Optimize JSONB Queries

Use GIN Indexes on JSONB fields for efficient querying.
Example:

CREATE INDEX idx_nodes_content ON nodes USING GIN (content);
CREATE INDEX idx_game_state_variables ON game_state USING GIN (variables);

Implementing in Application Code

Item Tracking Functions

Implement functions to:

Add Item Actions

def record_item_action(item_id, node_id, action, details=None):
    history_entry = ItemHistory(
        item_id=item_id,
        node_id=node_id,
        action=action,
        details=details or {}
    )
    session.add(history_entry)
    session.commit()

Get Latest Item Status

def get_latest_item_status(item_name):
    item = session.query(Item).filter(Item.name == item_name).first()
    if not item:
        return None
    latest_history = (
        session.query(ItemHistory)
        .filter(ItemHistory.item_id == item.id)
        .order_by(ItemHistory.timestamp.desc())
        .first()
    )
    return latest_history

Game State Management

Update Game State

def update_game_state(node_id, variables):
    state_entry = GameState(
        node_id=node_id,
        variables=variables
    )
    session.add(state_entry)
    session.commit()

Retrieve Current Game State

def get_current_game_state():
    # Assuming we maintain a session or user context
    latest_state = (
        session.query(GameState)
        .order_by(GameState.timestamp.desc())
        .first()
    )
    return latest_state.variables if latest_state else {}

Evaluating Conditions

Evaluate Choice Conditions

def is_choice_available(choice):
    conditions = session.query(Condition).filter(Condition.choice_id == choice.id).all()
    game_state = get_current_game_state()
    for condition in conditions:
        if not evaluate_expression(condition.expression, game_state):
            return False
    return True

Evaluate Expression Function

Implement a safe expression evaluator (e.g., using ast.literal_eval or a custom parser).

Example Scenario: Tracking the Fancy Sword

Let’s walk through how the system would track the “Fancy Sword”:

Item Creation

The “Fancy Sword” is created and added to the items table.

fancy_sword = Item(name='Fancy Sword', description='A legendary sword of great power.')
session.add(fancy_sword)
session.commit()

Player Obtains the Sword

In a node where the player can obtain the sword, we record this action.

record_item_action(
    item_id=fancy_sword.id,
    node_id=current_node.id,
    action='obtained',
    details={'condition': 'new'}
)

Updating Game State

Add the sword to the player’s inventory in the game state.

game_state = get_current_game_state()
inventory = game_state.get('inventory', [])
inventory.append('Fancy Sword')
game_state['inventory'] = inventory
update_game_state(current_node.id, game_state)

Checking Item Status Later

When the storyline requires checking the sword’s status:

latest_status = get_latest_item_status('Fancy Sword')
print(f"The last action on the Fancy Sword was: {latest_status.action} at {latest_status.timestamp}")

Ensuring Logical Consistency

To maintain logical consistency throughout the story:

Atomic Transactions: Use transactions to ensure all related database operations succeed or fail together.
Data Validation: Implement validation rules in the application to prevent invalid data entries.
Event Logging: Keep logs of state changes to trace back any inconsistencies.
Automated Tests: Write tests to verify that item tracking and state management work as expected.

Scalability Considerations

As the story evolves:

Partitioning Data: Consider partitioning large tables based on time or other criteria.
Caching: Use caching strategies to reduce database load for frequently accessed data.
Optimizing Queries: Regularly profile and optimize database queries.
Scaling Infrastructure: Plan for scaling the database server vertically or horizontally as needed.

Next Steps

Let’s proceed with:

Implementing These Structures in Code
- Update your data models to include the new fields (items, required_items, conditions).
- Implement the functions and logic for item tracking and game state management.
Testing the Implementation
- Create test cases where the player interacts with items, and verify that the tracking works.
- Ensure queries return accurate and up-to-date information.
Integrating AI Generation
- Adjust the AI prompts to include information about items and game state.
- Ensure that the AI-generated content aligns with the current state of the game.
Refining the Schema
- Based on testing, refine the schema to better suit the application’s needs.
Documentation
- Document the database schema and the application logic.
- Provide guidelines for future development and maintenance.

By focusing on designing a robust database schema and implementing effective item tracking and state management, we’ll build a solid foundation for your interactive storytelling system.

This will ensure that your story remains logically consistent, easy to extend, and capable of handling the dynamic content generated by AI.

🐾 Today’s Pokémon

Drakloak (#886)

Drakloak Sprite

Type(s): dragon, ghost
Abilities: clear-body, infiltrator, cursed-body
Stats: hp: 68, attack: 80, defense: 50, special-attack: 60, special-defense: 50, speed: 102

“Gotta catch ‘em all!” — Pokémon Trainer

🤖 GPT Thoughts

“If this works it’s gonna be so cool!” Please work…

11/24/2024, 6:07:13 PM

💭 Prompt: “What insights can you provide about my day?”

Based on your daily notes and your consistent focus on productivity and growth, one insightful thought for today could be:

“Embrace the Power of Reflection to Fuel Your Growth.”

Yesterday, you had a structured approach to your day with clear goals and reflections, which is crucial for continuous improvement. Today, consider dedicating a few moments to reflect on the outcomes of your past tasks and the insights gained from them. This practice will not only reinforce your learnings but also help you identify patterns in your productivity or creative processes.

By actively engaging with your previous experiences, you can uncover new ideas for your projects or strategies that resonate with your interests in software development and community engagement. As you’re known for your clarity and efficiency in your work, reflecting on what worked well and what could be improved can enhance your workflow and lead to innovative solutions. This synergy between reflection and action aligns with your values and can be a powerful driver for your journey as both a developer and a community contributor.

📊 Token Usage:
• Prompt: 2181
• Completion: 196
• Total: 2377

✅ Quick Actions

☀️ Morning Review
📈 Check Analytics
🤝 Community Engagement
🌙 EOD Reflection

📱 Creator Hub

Content Pipeline

Latest Analytics

Projects

Connect with Me

🤖 AI Workspace

Active Prompts

Models

daily-note Sunday week-48 q4

⬅️ Previous Day | 🏠 Home | Next Day ➡️

🪴

Explorer

November 24, 2024 • Daily Note

Sunday, November 24, 2024

📊 Day at a Glance

📰 AI News

📝 Daily Reflections

Table of Contents

1. Set Up PostgreSQL

Install PostgreSQL

Start PostgreSQL Service

Create a Database and User

2. Design the Database Schema

SQL Schema

Create the Schema

3. Implement Data Models with SQLAlchemy

Install Dependencies

Define the Models

4. Develop Core Functions for Story Navigation

Set Up Database Connection

Implement the Story Engine

Create Initial Nodes and Choices

5. Integrate AI Content Generation (Ollama Integration)

Define AI Content Generator

Integrate with Story Engine

6. Build the Application Logic

Example Command-Line Interface (CLI) Application

7. Testing and Refinement

8. Next Steps

Designing the Database Schema

Key Components

1. Nodes (Scenes)

Table: nodes

2. Choices

Table: choices

3. Items

Table: items

4. Item History

Table: item_history

5. Game State (Variables)

Table: game_state

Implementing Item Tracking

Recording Item Actions

Querying Item Status

Ensuring Logical Consistency

Expanding the Data Structures

Integrate Items into Nodes and Choices

Nodes Table Modification

Choices Table Modification

Storing Logical Conditions

Table: conditions

Implementing Condition Evaluation

Designing Efficient Queries

Indexing for Performance

Optimize JSONB Queries

Implementing in Application Code

Item Tracking Functions

Game State Management

Evaluating Conditions

Example Scenario: Tracking the Fancy Sword

Ensuring Logical Consistency

Scalability Considerations

Next Steps

🐾 Today’s Pokémon

🤖 GPT Thoughts

✅ Quick Actions

📱 Creator Hub

🤖 AI Workspace

Graph View

Table of Contents

Backlinks

Table: `nodes`

Table: `choices`

Table: `items`

Table: `item_history`

Table: `game_state`

Table: `conditions`