Delete src

src/database.py

@@ -1,47 +0,0 @@
-import pixeltable as pxt
-from pixeltable.functions import openai
-import os
-import getpass
-
-# Set up OpenAI API key
-if 'OPENAI_API_KEY' not in os.environ:
-    os.environ['OPENAI_API_KEY'] = getpass.getpass('Enter your OpenAI API key: ')
-
-# Initialize Pixeltable
-pxt.drop_dir('ai_rpg', force=True)
-pxt.create_dir('ai_rpg')
-
-# Create a single table for all game data
-interactions = pxt.create_table(
-    'ai_rpg.interactions',
-    {
-        'session_id': pxt.StringType(),
-        'player_name': pxt.StringType(),
-        'genre': pxt.StringType(),
-        'initial_scenario': pxt.StringType(),
-        'turn_number': pxt.IntType(),
-        'player_input': pxt.StringType(),
-        'timestamp': pxt.TimestampType(),
-    }
-)
-
-# Add computed columns for AI responses
-from src.utils import generate_messages, extract_options
-
-interactions['messages'] = generate_messages(
-    interactions.genre,
-    interactions.player_name,
-    interactions.initial_scenario,
-    interactions.player_input,
-    interactions.turn_number
-)
-
-interactions['ai_response'] = openai.chat_completions(
-    messages=interactions.messages,
-    model='gpt-4o-mini-2024-07-18',
-    max_tokens=500,
-    temperature=0.8
-)
-
-interactions['story_text'] = interactions.ai_response.choices[0].message.content
-interactions['options'] = extract_options(interactions.story_text)

src/game_logic.py

@@ -1,66 +0,0 @@
-from datetime import datetime
-from src.database import interactions
-
-class RPGGame:
-    def __init__(self):
-        self.current_session_id = None
-        self.turn_number = 0
-    
-    def start_game(self, player_name: str, genre: str, scenario: str) -> str:
-        session_id = f"session_{datetime.now().strftime('%Y%m%d%H%M%S')}_{player_name}"
-        self.current_session_id = session_id
-        self.turn_number = 0
-        
-        # Create initial interaction with all session data
-        interactions.insert([{
-            'session_id': session_id,
-            'player_name': player_name,
-            'genre': genre,
-            'initial_scenario': scenario,
-            'turn_number': 0,
-            'player_input': "Game starts",
-            'timestamp': datetime.now()
-        }])
-        
-        # Get initial story and options
-        initial_response = interactions.select(interactions.story_text).where(
-            (interactions.session_id == session_id) & 
-            (interactions.turn_number == 0)
-        ).collect()['story_text'][0]
-        
-        return session_id, initial_response
-    
-    def process_action(self, action: str) -> str:
-        if not self.current_session_id:
-            return "No active game session. Please start a new game."
-        
-        self.turn_number += 1
-        
-        # Get session info from previous turn
-        prev_turn = interactions.select(
-            interactions.player_name,
-            interactions.genre,
-            interactions.initial_scenario
-        ).where(
-            (interactions.session_id == self.current_session_id) &
-            (interactions.turn_number == 0)
-        ).collect()
-        
-        # Record player action with session data
-        interactions.insert([{
-            'session_id': self.current_session_id,
-            'player_name': prev_turn['player_name'][0],
-            'genre': prev_turn['genre'][0],
-            'initial_scenario': prev_turn['initial_scenario'][0],
-            'turn_number': self.turn_number,
-            'player_input': action,
-            'timestamp': datetime.now()
-        }])
-        
-        # Get AI response
-        response = interactions.select(interactions.story_text).where(
-            (interactions.session_id == self.current_session_id) & 
-            (interactions.turn_number == self.turn_number)
-        ).collect()['story_text'][0]
-        
-        return response

src/utils.py

@@ -1,35 +0,0 @@
-import pixeltable as pxt
-import re
-
-@pxt.udf
-def generate_messages(genre: str, player_name: str, initial_scenario: str, player_input: str, turn_number: int) -> list[dict]:
-    return [
-        {
-            'role': 'system',
-            'content': f"""You are the game master for a {genre} RPG. The player's name is {player_name}. 
-            Provide an engaging response to the player's action and present exactly 3 numbered options for their next move:
-            1. A dialogue option (saying something)
-            2. A random action they could take
-            3. A unique or unexpected choice
-            
-            Format each option with a number (1., 2., 3.) followed by the action description."""
-        },
-        {
-            'role': 'user',
-            'content': f"Current scenario: {initial_scenario}\n"
-                      f"Player's action: {player_input}\n"
-                      f"Turn number: {turn_number}\n\n"
-                      "Provide a response and 3 options:"
-        }
-    ]
-
-@pxt.udf
-def extract_options(story_text: str) -> list[str]:
-    """Extract the three options from the story text"""
-    # Look for numbered options (1., 2., 3.) and grab the text after them
-    options = re.findall(r'\d\.\s*(.*?)(?=\d\.|$)', story_text, re.DOTALL)
-    # Clean up the options and ensure we have exactly 3
-    options = [opt.strip() for opt in options[:3]]
-    while len(options) < 3:
-        options.append("Take another action...")
-    return options