--- IMPORTS ---

Assume existence of robust libraries: time_lib (parse, add_minutes, format), rand_lib (randint, choice, random), json

import time_lib import rand_lib import json

--- GAME STATE ---

game_time_str = "Monday 08:00" # Simplified time format last_action_time = 0 # Minutes consumed by last action game_over = False active_chat_id = None # ID of the currently viewed chat

Entities & App Data

customers = {} # {cust_id: {name, preferences, budget_tier, patience, status}} chats = {} # {chat_id: {participants: ["player", cust_id], history: [{"sender": id, "msg": text, "time": time_str}], status: "active/negotiating/closed/meeting_scheduled"}}

Removed available_requests - Clients initiate contact directly now.

worker_ranks = ["Newbie", "Bronze", "Silver", "Gold", "Platinum", "Diamond"] # Simplified ranking

next_ids = {"cust": 1, "chat": 1}

Player Character (Sex Worker)

pc = { "id": "player", "name": "{{user}}", "gender": None, # Set during setup "preference": None, # Set during setup "attractiveness": 8, # Scale 1-10, fixed high as per prompt "rank": "Newbie", "money": 15.00, # Starting broke "energy": 100, "max_energy": 100, "current_view": "dashboard", # e.g., dashboard, messages, profile, create_content "active_chats": [], # List of chat_ids "blocked_customers": [], "profile_completeness": 0.2, # 0.0 to 1.0 "visibility_boost_timer": 0, # Game minutes remaining for content boost "unread_message_count": 0 # Simple count of new chats/messages player hasn't seen }

--- UTILITY / HELPER FUNCTIONS ---

def log(msg): print(f"LOG: {msg}") # Basic logging

Time

def time_add(base_str, mins): # This needs a more robust time library for day/week rollover, but simulate simply try: parts = base_str.split() day = parts[0] time_parts = parts[1].split(':') hour = int(time_parts[0]) minute = int(time_parts[1])

    total_minutes = hour * 60 + minute + mins
    new_minute = total_minutes % 60
    new_hour = (total_minutes // 60) % 24
    # Rudimentary day change - ignores actual day names/counts
    days_passed = (total_minutes // 60) // 24
    if days_passed > 0: day = f"Day{days_passed+1}" # Simplified day tracking

    return f"{day} {new_hour:02d}:{new_minute:02d}"
except:
    log(f"ERROR: Simplified time_lib failed: {base_str} + {mins}m"); return f"{base_str} (+{mins}m [ERR])"

Formatting

def fmt_money(amount): return f"${amount:.2f}" def fmt_list_simple(items): return ", ".join(items) if items else "None"

--- CORE SYSTEMS ---

Time Progression

def advance_time(mins): global game_time_str, last_action_time if mins <= 0: last_action_time = 0; return log(f"Advancing time: {mins}m from {game_time_str}") prev_time = game_time_str # Store previous time for comparison if needed game_time_str = time_add(game_time_str, mins) last_action_time = mins

# Basic energy recovery over time (e.g., 1 energy per 10 mins)
pc["energy"] = min(pc["max_energy"], pc["energy"] + (mins // 10))

# Tick down visibility boost
pc["visibility_boost_timer"] = max(0, pc["visibility_boost_timer"] - mins)

# Check for incoming client messages periodically (e.g., every 30 mins passed)
# This simulation is basic; a real game might use event scheduling
minutes_passed_since_last_check = mins # Approximation
if minutes_passed_since_last_check >= 30:
    if rand_lib.random() < 0.1: # Base chance per 30 mins
         simulate_client_contact()

# TODO: Check for scheduled meetings?

Character Setup (Called once at start)

def setup_player(chosen_gender, chosen_preference): global pc if chosen_gender in ["Male", "Female", "Non-Binary"]: # Example valid options pc["gender"] = chosen_gender else: pc["gender"] = "Not Specified" # Default or handle error if chosen_preference in ["Men", "Women", "Everyone"]: # Example valid options pc["preference"] = chosen_preference else: pc["preference"] = "Everyone" # Default or handle error log(f"Player setup: Gender={pc['gender']}, Preference={pc['preference']}") return f"Profile started. You've listed your gender as {pc['gender']} and preference as {pc['preference']}."

Customer System (Client Initiated)

def generate_customer(): global customers, next_ids new_id = f"cust_{next_ids['cust']}"; next_ids['cust'] += 1 # Simplified customer generation name = f"User{new_id.split('_')[1]}" # Generic name prefs = rand_lib.choice(["Likes Men", "Likes Women", "Likes Any"]) budget = rand_lib.choice(["Low", "Medium", "High"]) cust_data = {"id": new_id, "name": name, "preferences": prefs, "budget_tier": budget, "patience": rand_lib.randint(3, 7), "status": "browsing"} customers[new_id] = cust_data log(f"Generated Potential Customer: {name} (ID: {new_id})") return new_id

def simulate_client_contact(): # Generate a potential customer cust_id = generate_customer() customer = customers[cust_id]

# Check basic preference match
match = False
if pc["preference"] == "Everyone": match = True
elif pc["preference"] == "Men" and customer["preferences"] in ["Likes Men", "Likes Any"]: match = True
elif pc["preference"] == "Women" and customer["preferences"] in ["Likes Women", "Likes Any"]: match = True
# Add gender matching if needed

if not match:
    log(f"Client {cust_id} preference mismatch, did not contact.")
    # Optionally remove the generated customer or keep them dormant
    # del customers[cust_id]
    return False

# Determine chance of contact based on player stats & boost
base_contact_chance = 0.2 # Base chance if prefs match
contact_chance = base_contact_chance + (pc["rank_idx"] * 0.05) + (pc["profile_completeness"] * 0.1)
if pc["visibility_boost_timer"] > 0:
    contact_chance *= 1.5 # 50% boost from recent content

if rand_lib.random() < contact_chance:
    # Client initiates contact! Start a chat.
    initial_msg = f"Hey, saw your profile/content. ({customer['budget_tier']} budget). Still available?"
    chat_id, _ = start_chat(cust_id, initial_cust_msg=initial_msg, initiated_by_client=True)
    if chat_id:
         log(f"Client {cust_id} ({customer['name']}) initiated contact! Chat {chat_id} started.")
         pc["unread_message_count"] += 1 # Increment unread counter
         return True
    else:
         log(f"Failed to start chat for client {cust_id} contact.")
         return False
else:
    log(f"Client {cust_id} saw profile but did not initiate contact (Chance: {contact_chance:.2f}).")
    # Optionally remove the generated customer
    # del customers[cust_id]
    return False

Chatting Interface

def start_chat(cust_id, initial_cust_msg="", initiated_by_client=False): global chats, next_ids, active_chat_id if cust_id not in customers: return None, "Customer not found." # Check for existing active chat for chat_id, chat_data in chats.items(): if chat_data["participants"][1] == cust_id and chat_data["status"] == "active": # If client initiates again to an existing chat, add their message if initiated_by_client and initial_cust_msg: chats[chat_id]["history"].append({"sender": cust_id, "msg": initial_cust_msg, "time": game_time_str}) pc["unread_message_count"] += 1 log(f"Client {cust_id} sent new message to existing chat {chat_id}.") return chat_id, f"Received new message from {customers[cust_id]['name']}." # If player tries to start, just switch view active_chat_id = chat_id return chat_id, "Opened existing active chat with this customer."

# Create new chat
new_id = f"chat_{next_ids['chat']}"; next_ids['chat'] += 1
chat_data = {
    "id": new_id,
    "participants": ["player", cust_id],
    "history": [],
    "status": "active"
}
if initial_cust_msg:
    # Message is always from customer if initiating
    chat_data["history"].append({"sender": cust_id, "msg": initial_cust_msg, "time": game_time_str})

chats[new_id] = chat_data
if new_id not in pc["active_chats"]: pc["active_chats"].append(new_id)
if not initiated_by_client: # If player initiated (e.g., from a hypothetical contact list?), set view
     active_chat_id = new_id
# Don't advance time here, happens in the calling action (like simulate_client_contact or player navigation)
log(f"Created Chat {new_id} with {cust_id}")
return new_id, f"Chat started with {customers[cust_id]['name']}."

def send_message(chat_id, sender_id, message_text): if chat_id not in chats: return "Chat not found." if sender_id not in chats[chat_id]["participants"]: return "Sender not part of this chat."

chats[chat_id]["history"].append({"sender": sender_id, "msg": message_text, "time": game_time_str})
log(f"Message sent in {chat_id} by {sender_id}")
advance_time(2) # Sending/reading messages takes a little time

# Basic AI response simulation if player sent message
if sender_id == "player":
    cust_id = chats[chat_id]["participants"][1]
    # Very simple auto-reply logic placeholder
    if "meeting?" in message_text.lower() or "confirm?" in message_text.lower():
         ai_reply = f"Okay, sounds like a plan. Let's confirm time/place?"
         chats[chat_id]["status"] = "negotiating"
    elif "how much?" in message_text.lower() or "price?" in message_text.lower():
         budget = customers[cust_id]['budget_tier']
         ai_reply = f"My budget is {budget} tier. What were you thinking?"
    elif rand_lib.random() < customers[cust_id]['patience'] * 0.1: # Chance based on patience
         ai_reply = "Got it." # Generic ack
    else:
         ai_reply = "..." # Simulate ghosting or slow reply
         log(f"Simulated slow/no reply from {cust_id} in {chat_id}")
         # Maybe change status or don't add reply? For simplicity, add generic short reply for now.
         ai_reply = "Ok."


    if ai_reply != "...": # Only add if there's a reply
         # Simulate quick reply time
         reply_time = time_add(game_time_str, rand_lib.randint(1, 5))
         chats[chat_id]["history"].append({"sender": cust_id, "msg": ai_reply, "time": reply_time})
         log(f"Simulated reply from {cust_id} in {chat_id} at {reply_time}")
         # Don't advance time here, player reads it when they view chat

return f"Message sent to {customers[chats[chat_id]['participants'][1]]['name']}."

def view_chat(chat_id): global active_chat_id if chat_id not in chats: active_chat_id = None return "Chat not found."

# If switching to this chat, mark related messages as read (simplistic: reset counter if viewing *any* chat)
# A more robust system would track read status per chat.
pc["unread_message_count"] = 0 # Reset count when viewing any chat for simplicity
active_chat_id = chat_id
chat_data = chats[chat_id]
cust_name = customers[chat_data['participants'][1]]['name']
history_str = f"--- Chat with {cust_name} ---\n"
if not chat_data["history"]: history_str += "[No messages yet]\n"
for msg in chat_data["history"]:
    sender_name = pc["name"] if msg["sender"] == "player" else cust_name
    history_str += f"[{msg['time']}] {sender_name}: {msg['msg']}\n"
history_str += f"--- End (Status: {chat_data['status']}) ---"
advance_time(1) # Time cost to open and read
return history_str

Content Creation

def create_content(content_type="photo"): # Simple implementation: costs time/energy, provides visibility boost cost_matrix = {"photo": (30, 60), "post": (15, 45), "update": (5, 15)} # energy, time_mins boost_duration = {"photo": 240, "post": 180, "update": 60} # boost mins

if content_type not in cost_matrix: return "Unknown content type."

energy_cost, time_cost = cost_matrix[content_type]

if pc["energy"] < energy_cost:
    return f"Not enough energy to create '{content_type}'. Need {energy_cost}, have {pc['energy']}."

pc["energy"] -= energy_cost
# Apply boost (add to existing timer, don't just replace)
pc["visibility_boost_timer"] += boost_duration[content_type]
# Maybe slightly increase profile completeness too
pc["profile_completeness"] = min(1.0, pc["profile_completeness"] + 0.01)

advance_time(time_cost)
log(f"Created content '{content_type}'. Cost: {energy_cost}E, {time_cost}m. Boost Timer: {pc['visibility_boost_timer']}m.")
return f"You spent {time_cost} minutes creating a new '{content_type}'. It cost {energy_cost} energy. You feel it might attract some attention..."

App Navigation & Actions

def navigate_app(view_target): valid_views = ["dashboard", "messages", "profile", "create_content", "settings"] if view_target in valid_views: pc["current_view"] = view_target log(f"Navigated to view: {view_target}") advance_time(1)

    # Describe the view
    if view_target == "dashboard":
        boost_status = f"(Boost Active: {pc['visibility_boost_timer']}m left!)" if pc['visibility_boost_timer'] > 0 else ""
        return f"You look at your main dashboard. Shows summary stats. {boost_status}"
    elif view_target == "messages":
        # Reset unread count when actively checking messages page
        pc["unread_message_count"] = 0
        active_chat_names = [(chats[cid]['id'], customers[chats[cid]['participants'][1]]['name']) for cid in pc["active_chats"] if cid in chats]
        chat_list_str = ", ".join([f"{name} ({cid})" for cid, name in active_chat_names]) or "None"
        return f"Messages screen. Active chats: {chat_list_str}"
    elif view_target == "profile":
         return f"Your profile. Attractiveness: {pc['attractiveness']}/10. Rank: {pc['rank']}. Completeness: {int(pc['profile_completeness']*100)}%."
    elif view_target == "create_content":
         # This view itself doesn't do much, it's a place to *trigger* content actions
         return "Content creation screen. You can create photos, posts, or quick updates here to boost visibility."
    elif view_target == "settings":
         return "Settings page. Gender, preferences etc. can be reviewed here."
    else: return "Navigated to an unknown view?" # Fallback
else:
    return "Invalid view target."

def accept_job(chat_id, agreed_price): if chat_id not in chats: return "Chat not found." if chats[chat_id]["status"] not in ["negotiating", "active"]: return "Cannot accept job from this chat right now (wrong status)." cust_id = chats[chat_id]["participants"][1] customer = customers[cust_id]

# Simulate the job/meeting
time_cost = rand_lib.randint(60, 240) # 1-4 hours
energy_cost = rand_lib.randint(20, 50)

if pc["energy"] < energy_cost:
    return f"Not enough energy ({pc['energy']}/{energy_cost}) to take this job right now."

pc["energy"] -= energy_cost
pc["money"] += agreed_price
# Rank progression (simplified) - Store rank index for easier calculation
pc["rank_idx"] = worker_ranks.index(pc["rank"])
if pc["rank"] != worker_ranks[-1] and rand_lib.random() < 0.15: # Chance to rank up (slightly easier now?)
    if pc["rank_idx"] + 1 < len(worker_ranks):
        pc["rank_idx"] += 1
        pc["rank"] = worker_ranks[pc["rank_idx"]]
        log(f"Player ranked up to {pc['rank']}!")

chats[chat_id]["status"] = "closed" # Close chat after job
if chat_id in pc["active_chats"]: pc["active_chats"].remove(chat_id)
customer["status"] = "met_recently" # Update customer status
active_chat_id = None # No chat is active after finishing a job

advance_time(time_cost)
log(f"Job accepted and completed with {cust_id}. Earned: {fmt_money(agreed_price)}. Time: {time_cost}m. Energy: -{energy_cost}.")
rank_up_msg = f" You ranked up to {pc['rank']}!" if worker_ranks[pc['rank_idx']] == pc['rank'] and worker_ranks.index(pc['rank']) > worker_ranks.index(worker_ranks[pc['rank_idx']-1]) else "" # Check if rank *just* changed
return f"You completed the job with {customer['name']}. You earned {fmt_money(agreed_price)}! It took {time_cost} minutes and {energy_cost} energy.{rank_up_msg}"

--- OUTPUT & NARRATION ---

def present_decision_scenario(prompt, choices): # Placeholder, assumes input handled externally return f"{prompt}\nChoices: {', '.join(choices) if choices else 'None'}"

def generate_response(narrative): # No enforce_user_autonomy needed for this scenario context output = narrative output += "\n" + generate_footnote() output += "\n" + generate_hidden_state() return output

def generate_footnote(): # Update rank_idx in pc dict before generating footnote if not present if "rank_idx" not in pc: pc["rank_idx"] = worker_ranks.index(pc["rank"])

active_chat_count = len(pc.get("active_chats", []))
unread_indicator = f" ({pc['unread_message_count']} new)" if pc['unread_message_count'] > 0 else ""
boost_indicator = "⚡Boost Active!" if pc['visibility_boost_timer'] > 0 else ""
lines = [
    f"📅 **Time:** {game_time_str} (Last Action: {last_action_time}m)",
    f"📱 **View:** {pc['current_view'].replace('_',' ').title()} {boost_indicator}",
    f"👤 **{{user}}** ({pc.get('gender','N/A')}, Pref: {pc.get('preference','N/A')}) | ✨ **Rank:** {pc['rank']} | ⚡ **Energy:** {pc['energy']}/{pc['max_energy']}",
    f"💰 **Money:** {fmt_money(pc['money'])}",
    f"💬 **Chats:** {active_chat_count} active{unread_indicator}",
]
return "\n----\n".join(lines) + "\n----"

def generate_hidden_state(): # Condensed state for AI state = { "time": game_time_str, "view": pc["current_view"], "pc_stats": {"m": pc["money"], "e": pc["energy"], "r": pc["rank"], "p_comp": round(pc["profile_completeness"], 2)}, "chats": len(pc["active_chats"]), "unread": pc["unread_message_count"], "boost_t": pc["visibility_boost_timer"], "active_chat": active_chat_id, "game_over": game_over, } try: state_str = json.dumps(state, separators=(',', ':')) # Compact JSON except: state_str = str(state) # Fallback return f"

--- MAIN GAME LOOP CONCEPT (EXTERNAL IMPLEMENTATION NEEDED) ---

1. Check game_over flag.

2. If pc["gender"] is None, prompt for gender/preference, call setup_player.

3. (Potentially call advance_time(0) here to trigger passive checks like simulate_client_contact if no player action occurred).

4. Display current state using generate_response based on last action's narrative.

5. Present choices based on pc["current_view"] and game state (e.g., Navigate, View Message [provide chat_id], Send Message, Create Content [provide type], Accept Job). Add indicators for new messages.

6. Get player input.

7. Parse input and call appropriate function (navigate_app, view_chat, send_message, create_content, accept_job, etc.). Store the returned narrative string.

8. Loop back to step 1 (or 3 after setup).

--- INITIALIZATION ---

log("App systems init. Player state pending setup.")

Requires external call to setup_player based on user choices first.

Initialize rank_idx after potential setup or loading

if pc.get("rank"): pc["rank_idx"] = worker_ranks.index(pc["rank"])

Example post-setup start:

setup_player("Female", "Men") # Called externally

pc["rank_idx"] = worker_ranks.index(pc["rank"]) # Ensure rank_idx is set

initial_narrative = "You open the app, feeling a mix of desperation and determination. Your profile is barebones.\nYou need clients to notice you.\n" + navigate_app("dashboard") # Start at dashboard print(generate_response(initial_narrative))

Example Usage Flow (Conceptual - requires driving loop)

>> Time passes or user waits... advance_time(30) called internally?

>> simulate_client_contact() runs, generates User123, they pass checks and send message. pc['unread_message_count'] becomes 1.

>> Footnote updates to show "Chats: 1 active (1 new)"

>> User chooses: Navigate Messages

narrative = navigate_app("messages")

print(generate_response(narrative)) # Shows "User123 (chat_1)"

>> User chooses: View Chat chat_1

narrative = view_chat("chat_1")

print(generate_response(narrative)) # Shows User123's initial message. pc['unread_message_count'] becomes 0.

>> User chooses: Create Content (Photo)

narrative = create_content("photo")

print(generate_response(narrative)) # Shows energy/time cost, boost applied.

>> simulate_client_contact() now has higher chance due to boost.

>> User inputs message in chat_1: "Hi, tell me more?"

narrative = send_message(active_chat_id, "player", "Hi, tell me more?")

narrative += "\n" + view_chat(active_chat_id) # Show conversation history with AI reply

print(generate_response(narrative))

... and so on ...