CatRider2.app.py

import streamlit as st
import pandas as pd
import plotly.express as px
import random
import uuid
from datetime import datetime
from streamlit_flow import streamlit_flow
from streamlit_flow.elements import StreamlitFlowNode, StreamlitFlowEdge
from streamlit_flow.layouts import TreeLayout

# 🌍 Game World Data
SITUATIONS = [
    {
        "id": "feline_escape",
        "name": "The Great Feline Escape",
        "description": "Your cat rider is trapped in an old mansion, which is about to be demolished. Using agility, wit, and bravery, orchestrate the perfect escape.",
        "emoji": "🚪",
        "type": "escape"
    },
    {
        "id": "lost_temple",
        "name": "The Treasure of the Lost Temple",
        "description": "On a quest to retrieve an ancient artifact, your cat rider must navigate through a labyrinth filled with traps and guardian spirits.",
        "emoji": "🏛️",
        "type": "exploration"
    },
    {
        "id": "royal_tournament",
        "name": "The Royal Tournament",
        "description": "Compete in a grand tournament where the finest cat riders showcase their skills and bravery to earn the title of the Royal Rider.",
        "emoji": "👑",
        "type": "competition"
    }
]

ACTIONS = [
    {
        "id": "stealth",
        "name": "Use Stealth",
        "description": "Sneak past obstacles or enemies without being detected.",
        "emoji": "🤫",
        "type": "skill"
    },
    {
        "id": "agility",
        "name": "Showcase Agility",
        "description": "Perform impressive acrobatic maneuvers to overcome challenges.",
        "emoji": "🏃",
        "type": "physical"
    },
    {
        "id": "charm",
        "name": "Charm Others",
        "description": "Use your cat's natural charisma to win over allies or distract foes.",
        "emoji": "😻",
        "type": "social"
    },
    {
        "id": "resourcefulness",
        "name": "Be Resourceful",
        "description": "Utilize the environment or items in creative ways to solve problems.",
        "emoji": "🧠",
        "type": "mental"
    }
]

# 🎲 Game Mechanics
def generate_situation():
    return random.choice(SITUATIONS)

def generate_actions():
    return random.sample(ACTIONS, 3)

def evaluate_action(action, gear_strength, rider_skill, history):
    base_success_chance = (gear_strength + rider_skill) / 2
    if action['id'] in history:
        success_chance = base_success_chance + (history[action['id']] * 2)
    else:
        success_chance = base_success_chance
    outcome = random.randint(1, 100) <= success_chance
    return outcome, success_chance

# 🌳 Journey Visualization with Heterogeneous Graph Structure
def create_heterogeneous_graph(history_df):
    nodes = []
    edges = []
    
    # Define node shapes based on situation and action types
    situation_shapes = {
        "escape": "diamond",
        "exploration": "triangle",
        "competition": "star"
    }
    action_shapes = {
        "skill": "square",
        "physical": "circle",
        "social": "hexagon",
        "mental": "octagon"
    }
    
    for index, row in history_df.iterrows():
        situation_id = f"situation-{index}"
        action_id = f"action-{index}"
        
        # Create situation node
        situation_content = f"{row['situation_emoji']} {row['situation_name']}\n🕒 {row['timestamp']}"
        situation_node = StreamlitFlowNode(situation_id, (0, 0), {'content': situation_content}, 'output', 'bottom', 'top', shape=situation_shapes[row['situation_type']])
        nodes.append(situation_node)
        
        # Create action node
        action_content = f"{row['action_emoji']} {row['action_name']}\nOutcome: {'✅ Success' if row['outcome'] else '❌ Failure'}"
        action_node = StreamlitFlowNode(action_id, (0, 0), {'content': action_content}, 'output', 'bottom', 'top', shape=action_shapes[row['action_type']])
        nodes.append(action_node)
        
        # Create edge between situation and action
        edge = StreamlitFlowEdge(f"{situation_id}-{action_id}", situation_id, action_id, animated=True, dashed=False)
        edges.append(edge)
        
        # Create edge to previous action if not the first node
        if index > 0:
            prev_action_id = f"action-{index-1}"
            prev_edge = StreamlitFlowEdge(f"{prev_action_id}-{situation_id}", prev_action_id, situation_id, animated=True, dashed=True)
            edges.append(prev_edge)
    
    return nodes, edges

# 📝 Markdown Preview
def create_markdown_preview(history_df):
    markdown = "## 🌳 Journey Preview\n\n"
    for index, row in history_df.iterrows():
        indent = "  " * index
        markdown += f"{indent}- {row['situation_emoji']} **{row['situation_name']}** ({row['situation_type']})\n"
        markdown += f"{indent}  - {row['action_emoji']} {row['action_name']} ({row['action_type']}): "
        markdown += "✅ Success\n" if row['outcome'] else "❌ Failure\n"
    return markdown

# 🔄 Game State Management
def update_game_state(game_state, situation, action, outcome, timestamp):
    new_record = pd.DataFrame({
        'user_id': [game_state['user_id']],
        'timestamp': [timestamp],
        'situation_id': [situation['id']],
        'situation_name': [situation['name']],
        'situation_emoji': [situation['emoji']],
        'situation_type': [situation['type']],
        'action_id': [action['id']],
        'action_name': [action['name']],
        'action_emoji': [action['emoji']],
        'action_type': [action['type']],
        'outcome': [outcome],
        'score': [game_state['score']]
    })
    game_state['history_df'] = pd.concat([game_state['history_df'], new_record], ignore_index=True)
    
    if action['id'] in game_state['history']:
        game_state['history'][action['id']] += 1 if outcome else -1
    else:
        game_state['history'][action['id']] = 1 if outcome else -1
    
    return game_state

# 🎮 Main Game Application
def main():
    st.title("🐱 Cat Rider 🏇")
    st.markdown("""
    ## Welcome to Cat Rider!
    In this immersive adventure, you will explore the thrilling world of feline riders. This game sets the stage for dramatic situations and guided storytelling with engaging interactive elements.
    """)

    # 📜 Game Rules
    st.markdown("""
    ### 📜 Game Rules
    | 🛤️ Step | 📝 Description |
    |---------|----------------|
    | 1️⃣ | Choose your Cat Rider |
    | 2️⃣ | Select the Riding Gear |
    | 3️⃣ | Set off on an Adventure |
    | 4️⃣ | Encounter Challenges and Make Decisions |
    | 5️⃣ | Complete the Quest |
    """)

    # 🏁 Initialize game state
    if 'game_state' not in st.session_state:
        st.session_state.game_state = {
            'user_id': str(uuid.uuid4()),
            'score': 0,
            'history': {},
            'gear_strength': 5,
            'rider_skill': 5,
            'history_df': pd.DataFrame(columns=['user_id', 'timestamp', 'situation_id', 'situation_name', 'situation_emoji', 'situation_type', 'action_id', 'action_name', 'action_emoji', 'action_type', 'outcome', 'score'])
        }
    
    # 📊 Game Stats
    st.sidebar.markdown("## 📊 Game Stats")
    st.sidebar.markdown(f"**Score:** {st.session_state.game_state['score']}")
    
    # 🦸 Character Stats
    gear_strength = st.sidebar.slider('Gear Strength 🛡️', 1, 10, st.session_state.game_state['gear_strength'])
    rider_skill = st.sidebar.slider('Rider Skill 🏇', 1, 10, st.session_state.game_state['rider_skill'])
    
    # 🎭 Game Loop
    situation = generate_situation()
    actions = generate_actions()
    
    st.markdown(f"## {situation['emoji']} Current Situation: {situation['name']} ({situation['type']})")
    st.markdown(situation['description'])
    st.markdown("### 🎭 Choose your action:")
    
    cols = st.columns(3)
    for i, action in enumerate(actions):
        if cols[i].button(f"{action['emoji']} {action['name']} ({action['type']})"):
            outcome, success_chance = evaluate_action(action, gear_strength, rider_skill, st.session_state.game_state['history'])
            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            
            st.markdown(f"You decided to: **{action['name']}** ({action['type']})")
            st.markdown(action['description'])
            st.markdown(f"**Outcome:** {'✅ Success!' if outcome else '❌ Failure.'}")
            st.markdown(f"**Success Chance:** {success_chance:.2f}%")
            
            if outcome:
                st.session_state.game_state['score'] += 1
            
            # 🔄 Update game state
            st.session_state.game_state = update_game_state(
                st.session_state.game_state,
                situation,
                action,
                outcome,
                timestamp
            )
    
    # 📝 Display Markdown Preview
    if not st.session_state.game_state['history_df'].empty:
        st.markdown(create_markdown_preview(st.session_state.game_state['history_df']))
    
    # 🌳 Display Heterogeneous Journey Graph
    if not st.session_state.game_state['history_df'].empty:
        st.markdown("## 🌳 Your Journey (Heterogeneous Graph)")
        nodes, edges = create_heterogeneous_graph(st.session_state.game_state['history_df'])
        try:
            streamlit_flow('cat_rider_flow', 
                           nodes, 
                           edges, 
                           layout=TreeLayout(direction='down'),
                           fit_view=True, 
                           height=600)
        except Exception as e:
            st.error(f"An error occurred while rendering the journey graph: {str(e)}")
            st.markdown("Please try refreshing the page if the graph doesn't appear.")
    
    # 📊 Character Stats Visualization
    data = {"Stat": ["Gear Strength 🛡️", "Rider Skill 🏇"],
            "Value": [gear_strength, rider_skill]}
    df = pd.DataFrame(data)
    fig = px.bar(df, x='Stat', y='Value', title="Cat Rider Stats 📊")
    st.plotly_chart(fig)

    # Example of Data Table
    st.markdown("### 🛠️ Available Gear")
    gear_data = {
        'Gear': ['Helmet', 'Armor', 'Boots', 'Gloves'],
        'Protection Level': [8, 7, 5, 4],
        'Type': ['Head', 'Body', 'Feet', 'Hands']
    }
    gear_df = pd.DataFrame(gear_data)
    st.dataframe(gear_df)

if __name__ == "__main__":
    main()