Refactor app.py as modular

app.py

@@ -8,6 +8,12 @@ from openai import OpenAI
 from huggingface_hub import HfApi
 from huggingface_hub import InferenceClient
 from datasets import Dataset, load_dataset
+from game.player import create_player
+from game.turn_engine import play_turn
+from systems.alignment_system import evaluate_alignment
+from game.llm_engine import generate_llm_stream
+from game.vlm_engine import extract_scene_data, generate_scene_image_structured
+from data.save_system import save_to_hf, load_from_hf
 
 print("APP STARTING...")
 
@@ -38,7 +44,6 @@ image_client = InferenceClient(
     token=token
 )
 
-
 DATASET_REPO = f"{username}/ai-rpg-saves"
 
 # ----------------------------
@@ -52,234 +57,6 @@ if os.path.exists(prompt_file_path):
 else:
     print("SYSTEM_PROMPT FILE DOES NOT EXIST")
 
-
-
-# ----------------------------
-# PLAYER INIT
-# ----------------------------
-
-def create_player(name, gender, avatar, language):
-    return {
-        "id": str(uuid.uuid4()),
-        "name": name,
-        "language": language,
-        "gender": gender,
-        "avatar": avatar,
-        "light_dark": 0,     # -100 dark, +100 light
-        "order_chaos": 0,    # -100 chaos, +100 order
-        "strength": 5,
-        "agility": 5,
-        "intelligence": 5,
-        "charisma": 5,
-        "willpower": 5,
-    }
-
-# ----------------------------
-# SAVE / LOAD (HF DATASET)
-# ----------------------------
-
-def save_to_hf(state_json, history_json):
-    data = {
-        "state": [state_json],
-        "history": [history_json]
-    }
-
-    ds = Dataset.from_dict(data)
-
-    ds.push_to_hub(
-        DATASET_REPO,
-        private=True
-    )
-    
-    return "Game Saved ☁️"
-
-def load_from_hf():
-    ds = load_dataset(
-        DATASET_REPO,
-        split="train"
-    )
-
-    state_json = ds[0]["state"]
-    history_json = ds[0]["history"]
-
-    return state_json, history_json
-
-# ----------------------------
-# LLM STREAM
-# ----------------------------
-
-def generate_stream(message, history, state):
-    player_lang = state.get("language", "English")
-
-    struct_instruction = f"""
-    \n\nCRITICAL RULE 1: You MUST write your entire response, all storytelling, dialogue, and exactly 5 choices EXCLUSIVELY in {player_lang}.
-    CRITICAL RULE 2: At the very end of your response, you MUST append a hidden visual description for the image generator. Use EXACTLY this format (raw JSON only, no markdown):
-    <SCENE_DATA>
-    {{"image_prompt": "A highly detailed, purely visual description of the current scene, focusing on characters, lighting, and environment.", "location": "Name of the current place"}}
-    </SCENE_DATA>
-    """
-    
-    dynamic_system_prompt = SYSTEM_PROMPT + struct_instruction
-
-    context = f"Player State:\n{json.dumps(state, indent=2)}"
-    
-    messages = [
-        {"role": "system", "content": dynamic_system_prompt},
-        {"role": "system", "content": context},
-    ]
-    
-    for h in history:
-        messages.append({"role": "user", "content": h[0]})
-        messages.append({"role": "assistant", "content": h[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    stream = text_client.chat.completions.create(
-        model=TEXT_MODEL_NAME,
-        messages=messages,
-        temperature=0.95,
-        top_p=0.9,
-        presence_penalty=0.6,
-        frequency_penalty=0.4,
-        max_tokens=1200,
-        stream=True,
-    )
-
-    partial = ""
-    for chunk in stream:
-        if chunk.choices and chunk.choices[0].delta.content:
-            partial += chunk.choices[0].delta.content
-            display_text = partial.split("<SCENE_DATA>")[0].strip() # JSON bloğunu UI'dan gizlemek için ayırıyoruz
-            yield display_text, partial
-
-# ----------------------------
-# IMAGE GENERATION
-# ----------------------------
-
-def extract_scene_data(full_text):
-    """LLM çıktısındaki gizli SCENE_DATA bloğunu bulur ve JSON'a çevirir."""
-    pattern = r"<SCENE_DATA>(.*?)</SCENE_DATA>"
-    match = re.search(pattern, full_text, re.DOTALL | re.IGNORECASE)
-    
-    if match:
-        json_str = match.group(1).strip()
-        # Llama bazen markdown (```json) ekleyebilir, onu temizliyoruz
-        json_str = json_str.replace("```json", "").replace("```", "").strip()
-        try:
-            return json.loads(json_str)
-        except Exception as e:
-            print(f"JSON Parse Error: {e}")
-    return None
-
-def generate_scene_image_structured(scene_data):
-    """Sadece LLM'den gelen saf 'image_prompt'u kullanarak görsel üretir."""
-    if not scene_data or "image_prompt" not in scene_data:
-        return None
-    
-    # Ana Star Wars şablonumuz
-    base_prompt = "Cinematic Star Wars concept art, highly detailed, dark atmosphere, dramatic lighting, 8k resolution, masterpiece. "
-    final_prompt = base_prompt + scene_data["image_prompt"]
-    
-    try:
-        image = image_client.text_to_image(final_prompt)
-        return image
-    except Exception as e:
-        print(f"Image generation failed via Router: {e}")
-        return None
-
-#def generate_scene_image(ai_story_text):
-#    if not ai_story_text:
-#        return None
-#    
-#    base_prompt = "Cinematic Star Wars concept art, highly detailed, dark atmosphere, dramatic lighting, 8k resolution, masterpiece. "
-#    scene_description = ai_story_text[:400].replace("\n", " ").replace('"', "'")
-#    final_prompt = base_prompt + scene_description
-#    
-#    try:
-#        image = image_client.text_to_image(final_prompt)
-#        return image
-#    except Exception as e:
-#        print(f"Image generation failed via correct Router: {e}")
-#        return None
-
-# ----------------------------
-# ALIGNMENT STREAM
-# ----------------------------
-
-def evaluate_alignment(user_input, last_context=""):
-    eval_prompt = f"""You are a hidden Game Master evaluating player morality in a Star Wars RPG.
-    Story Context: "{last_context[-200:]}"
-    Player Action: "{user_input}"
-    
-    Evaluate the alignment shift for this action.
-    Light/Dark: + (Light: compassion, healing) to - (Dark: murder, selfishness, anger).
-    Order/Chaos: + (Order: following rules, loyalty) to - (Chaos: rebellion, deception, breaking laws).
-    
-    Score both from -5 to +5.
-    Return ONLY two integers separated by a comma. NO other text.
-    Example: -3, 2
-    """
-    try:
-        # Arka planda hızlıca puanlama yapması için temperature=0 kullanıyoruz
-        response = text_client.chat.completions.create(
-            model=TEXT_MODEL_NAME,
-            messages=[{"role": "user", "content": eval_prompt}],
-            max_tokens=10,
-            temperature=0.0
-        )
-        result = response.choices[0].message.content.strip()
-        ld_shift, oc_shift = result.split(',')
-        return int(ld_shift.strip()), int(oc_shift.strip())
-    except Exception as e:
-        print("Alignment parsing error:", e)
-        return 0, 0 # Hata olursa puanı değiştirme
-
-# ----------------------------
-# GAME TURN
-# ----------------------------
-
-def play_turn(user_input, history, state_json):
-    if history is None:
-        history = []
-    
-    state = json.loads(state_json)
-
-    last_ai_message = history[-1][1] if len(history) > 0 else ""
-    
-    history.append([user_input, ""])
-
-    full_ai_response = ""
-    for display_text, full_text in generate_stream(user_input, history[:-1], state):
-        history[-1][1] = display_text
-        full_ai_response = full_text  # Gizli JSON dahil tam metni arka planda tutuyoruz
-        yield (
-            history,                    
-            json.dumps(state),
-            state["light_dark"],
-            state["order_chaos"],
-            gr.update()
-        )
-    
-    # UI'da görünen temiz metni alignment için değerlendiriyoruz
-    if user_input.strip() and "Start the adventure" not in user_input:
-        ld_shift, oc_shift = evaluate_alignment(user_input, last_ai_message)
-        state["light_dark"] = max(-100, min(100, state["light_dark"] + ld_shift))
-        state["order_chaos"] = max(-100, min(100, state["order_chaos"] + oc_shift))
-
-    # YENİ: Arka planda biriken tam metinden JSON'u çıkarıyoruz
-    scene_data = extract_scene_data(full_ai_response)
-    
-    # JSON başarıyla alındıysa görseli üretiyoruz
-    new_image = generate_scene_image_structured(scene_data) if scene_data else None
-    
-    yield (
-        history,
-        json.dumps(state),
-        state["light_dark"],
-        state["order_chaos"],
-        new_image if new_image else gr.update()
-    )
-
 # ----------------------------
 # UI
 # ----------------------------
@@ -454,8 +231,19 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
             None
         )
     
+    def play_turn_wrapper(user_input, history, state_json):
+        return play_turn(
+            user_input,
+            history,
+            state_json,
+            text_client,
+            image_client,
+            TEXT_MODEL_NAME,
+            SYSTEM_PROMPT
+        )
+    
     def first_turn(history, state_json):
-        yield from play_turn("Start the adventure. Describe my surroundings and give me 5 choices.", history, state_json)
+        yield from play_turn("Start the adventure. Describe my surroundings and give me 5 choices.", history, state_json, text_client, image_client, TEXT_MODEL_NAME, SYSTEM_PROMPT)
 
     finish_stats.click(
         start_game,
@@ -470,7 +258,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
     )
 
     send_btn.click(
-        play_turn,
+        play_turn_wrapper,
         inputs=[custom_input, chatbot, player_state],
         outputs=[chatbot, player_state, light_dark_slider, order_chaos_slider, scene_image],
         api_name=False
@@ -479,15 +267,15 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
     choice_outputs = [chatbot, player_state, light_dark_slider, order_chaos_slider, scene_image]
     
     def choice1_fn(history, state):
-        yield from play_turn("I choose option 1.", history, state)
+        yield from play_turn_wrapper("I choose option 1.", history, state)
     def choice2_fn(history, state):
-        yield from play_turn("I choose option 2.", history, state)
+        yield from play_turn_wrapper("I choose option 2.", history, state)
     def choice3_fn(history, state):
-        yield from play_turn("I choose option 3.", history, state)
+        yield from play_turn_wrapper("I choose option 3.", history, state)
     def choice4_fn(history, state):
-        yield from play_turn("I choose option 4.", history, state)
+        yield from play_turn_wrapper("I choose option 4.", history, state)
     def choice5_fn(history, state):
-        yield from play_turn("I choose option 5.", history, state)
+        yield from play_turn_wrapper("I choose option 5.", history, state)
 
     choice1.click(choice1_fn, inputs=[chatbot, player_state], outputs=choice_outputs, api_name=False)
     choice2.click(choice2_fn, inputs=[chatbot, player_state], outputs=choice_outputs, api_name=False)
@@ -496,10 +284,10 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
     choice5.click(choice5_fn, inputs=[chatbot, player_state], outputs=choice_outputs, api_name=False)
 
     def save_wrapper(state_json, history_list):
-        return save_to_hf(state_json, json.dumps(history_list))
+        return save_to_hf(DATASET_REPO, state_json, json.dumps(history_list))
     
     def load_wrapper():
-        state_json, history_json = load_from_hf()
+        state_json, history_json = load_from_hf(DATASET_REPO)
         return state_json, json.loads(history_json)
 
     save_btn.click(

data/save_system.py

@@ -0,0 +1,35 @@
+import json
+import os
+import uuid
+import time
+import re
+from datasets import Dataset, load_dataset
+# ----------------------------
+# SAVE / LOAD (HF DATASET)
+# ----------------------------
+
+def save_to_hf(dataset_repo, state_json, history_json):
+    data = {
+        "state": [state_json],
+        "history": [history_json]
+    }
+
+    ds = Dataset.from_dict(data)
+
+    ds.push_to_hub(
+        dataset_repo,
+        private=True
+    )
+    
+    return "Game Saved ☁️"
+
+def load_from_hf(dataset_repo):
+    ds = load_dataset(
+        dataset_repo,
+        split="train"
+    )
+
+    state_json = ds[0]["state"]
+    history_json = ds[0]["history"]
+
+    return state_json, history_json

examples/face_swap.py

@@ -0,0 +1,277 @@
+import os
+import gradio as gr
+import numpy as np
+import random
+import spaces
+import torch
+from diffusers import Flux2KleinPipeline
+from PIL import Image
+
+dtype = torch.bfloat16
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+MAX_SEED = np.iinfo(np.int32).max
+
+# Model repository ID for 9B distilled
+REPO_ID_DISTILLED = "black-forest-labs/FLUX.2-klein-9B"
+
+# LoRA repository and file
+LORA_REPO_ID = "Alissonerdx/BFS-Best-Face-Swap"
+LORA_FILENAME = "bfs_head_v1_flux-klein_9b_step3750_rank64.safetensors"
+
+# Fixed prompt for face swapping
+#FACE_SWAP_PROMPT = "head_swap: start with Picture 1 as the base image, keeping its lighting, environment, and background. remove the head from Picture 1 completely and replace it with the head from Picture 2, strictly preserving the hair, eye color, nose structure of Picture 2. copy the direction of the eye, head rotation, micro expressions from Picture 1, high quality, sharp details, 4k."
+
+FACE_SWAP_PROMPT = """head_swap: start with Picture 1 as the base image, keeping its lighting, environment, and background. Remove the head from Picture 1 completely and replace it with the head from Picture 2.
+FROM PICTURE 1 (strictly preserve):
+- Scene: lighting conditions, shadows, highlights, color temperature, environment, background
+- Head positioning: exact rotation angle, tilt, direction the head is facing
+- Expression: facial expression, micro-expressions, eye gaze direction, mouth position, emotion
+FROM PICTURE 2 (strictly preserve identity):
+- Facial structure: face shape, bone structure, jawline, chin
+- All facial features: eye color, eye shape, nose structure, lip shape and fullness, eyebrows
+- Hair: color, style, texture, hairline
+- Skin: texture, tone, complexion
+The replaced head must seamlessly match Picture 1's lighting and expression while maintaining the complete identity from Picture 2. High quality, photorealistic, sharp details, 4k."""
+
+print("Loading FLUX.2 Klein 9B Distilled model...")
+pipe = Flux2KleinPipeline.from_pretrained(REPO_ID_DISTILLED, torch_dtype=dtype)
+pipe.to(device)
+
+print(f"Loading LoRA from {LORA_REPO_ID}...")
+pipe.load_lora_weights(LORA_REPO_ID, weight_name=LORA_FILENAME)
+print("LoRA loaded successfully!")
+
+def update_dimensions_from_image(target_image):
+    """
+    Update width/height based on target image aspect ratio.
+    Keeps one side at 1024 and scales the other proportionally,
+    with both sides as multiples of 8.
+    Args:
+        target_image: PIL Image of the target/body image.
+    Returns:
+        tuple: A tuple of (width, height) integers, both multiples of 8.
+    """
+    if target_image is None:
+        return 1024, 1024  # Default dimensions
+
+    img_width, img_height = target_image.size
+
+    aspect_ratio = img_width / img_height
+
+    if aspect_ratio >= 1:  # Landscape or square
+        new_width = 1024
+        new_height = int(1024 / aspect_ratio)
+    else:  # Portrait
+        new_height = 1024
+        new_width = int(1024 * aspect_ratio)
+
+    # Round to nearest multiple of 8
+    new_width = round(new_width / 8) * 8
+    new_height = round(new_height / 8) * 8
+
+    # Ensure within valid range (minimum 256, maximum 1024)
+    new_width = max(256, min(1024, new_width))
+    new_height = max(256, min(1024, new_height))
+
+    return new_width, new_height
+
+
+@spaces.GPU(duration=45)
+def face_swap(
+    reference_face: Image.Image,
+    target_image: Image.Image,
+    seed: int = 42,
+    randomize_seed: bool = False,
+    width: int = 1024,
+    height: int = 1024,
+    num_inference_steps: int = 4,
+    guidance_scale: float = 1.0,
+    progress=gr.Progress(track_tqdm=True)
+):
+    """
+    Perform face swapping using FLUX.2 Klein 9B with LoRA.
+    Args:
+        reference_face: The face image to swap in (Picture 2).
+        target_image: The target body/base image (Picture 1).
+        seed: Random seed for reproducible generation.
+        randomize_seed: Set to True to use a random seed.
+        width: Output image width in pixels (256-1024, must be multiple of 8).
+        height: Output image height in pixels (256-1024, must be multiple of 8).
+        num_inference_steps: Number of denoising steps (default 4 for distilled).
+        guidance_scale: How closely to follow the prompt (default 1.0 for distilled).
+    Returns:
+        tuple: A tuple containing the generated PIL Image and the seed used.
+    """
+    if reference_face is None or target_image is None:
+        raise gr.Error("Please provide both a reference face and a target image!")
+
+    if randomize_seed:
+        seed = random.randint(0, MAX_SEED)
+
+    generator = torch.Generator(device=device).manual_seed(seed)
+
+    # Important: Pass target image (body) first, then reference face
+    # This matches the prompt structure: Picture 1 = target, Picture 2 = reference
+    image_list = [target_image, reference_face]
+
+    progress(0.2, desc="Swapping face...")
+
+    image = pipe(
+        prompt=FACE_SWAP_PROMPT,
+        image=image_list,
+        height=height,
+        width=width,
+        num_inference_steps=num_inference_steps,
+        guidance_scale=guidance_scale,
+        generator=generator,
+    ).images[0]
+
+    # Return slider comparison (before, after) and seed
+    return (target_image, image), seed
+
+
+css = """
+#col-container {
+    margin: 0 auto;
+    max-width: 1200px;
+}
+.image-container img {
+    object-fit: contain;
+}
+"""
+
+with gr.Blocks(css=css) as demo:
+
+    with gr.Column(elem_id="col-container"):
+        gr.Markdown("""# Face Swap with FLUX.2 Klein 9B
+Swap faces using Flux.2 Klein 9B [Alissonerdx/BFS-Best-Face-Swap](https://huggingface.co/Alissonerdx/BFS-Best-Face-Swap) LoRA
+        """)
+
+        with gr.Row():
+            with gr.Column():
+                with gr.Row():
+                    reference_face = gr.Image(
+                        label="Reference Face",
+                        type="pil",
+                        sources=["upload"],
+                        elem_classes="image-container"
+                    )
+        
+                    target_image = gr.Image(
+                        label="Target Image (Body/Scene)",
+                        type="pil",
+                        sources=["upload"],
+                        elem_classes="image-container"
+                    )
+                run_button = gr.Button("Swap Face", visible=False)
+                with gr.Accordion("Advanced Settings", open=False):
+                    seed = gr.Slider(
+                        label="Seed",
+                        minimum=0,
+                        maximum=MAX_SEED,
+                        step=1,
+                        value=0,
+                    )
+        
+                    randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
+        
+                    with gr.Row():
+                        width = gr.Slider(
+                            label="Width",
+                            minimum=256,
+                            maximum=1024,
+                            step=8,
+                            value=1024,
+                        )
+        
+                        height = gr.Slider(
+                            label="Height",
+                            minimum=256,
+                            maximum=1024,
+                            step=8,
+                            value=1024,
+                        )
+        
+                    with gr.Row():
+                        num_inference_steps = gr.Slider(
+                            label="Inference Steps",
+                            minimum=1,
+                            maximum=20,
+                            step=1,
+                            value=4,
+                            info="Number of denoising steps (4 is optimal for distilled model)"
+                        )
+        
+                        guidance_scale = gr.Slider(
+                            label="Guidance Scale",
+                            minimum=0.0,
+                            maximum=5.0,
+                            step=0.1,
+                            value=1.0,
+                            info="How closely to follow the prompt (1.0 is optimal for distilled model)"
+                        )
+
+
+            comparison_slider = gr.ImageSlider(
+                label="Before / After",
+                type="pil"
+            )
+
+        
+
+        
+        seed_output = gr.Number(label="Seed Used", visible=False)
+
+    # Auto-update dimensions when target image is uploaded
+    target_image.upload(
+        fn=update_dimensions_from_image,
+        inputs=[target_image],
+        outputs=[width, height]
+    )
+
+    # Create a shared input/output configuration
+    swap_inputs = [
+        reference_face,
+        target_image,
+        seed,
+        randomize_seed,
+        width,
+        height,
+        num_inference_steps,
+        guidance_scale
+    ]
+    swap_outputs = [comparison_slider, seed_output]
+
+    # Manual trigger via button
+    run_button.click(
+        fn=face_swap,
+        inputs=swap_inputs,
+        outputs=swap_outputs,
+    )
+
+    # Auto-trigger when both images are uploaded
+    def auto_swap_wrapper(ref_face, target_img, s, rand_s, w, h, steps, cfg):
+        """Only run face swap if both images are provided"""
+        if ref_face is not None and target_img is not None:
+            result = face_swap(ref_face, target_img, s, rand_s, w, h, steps, cfg)
+            # Show the button after first generation
+            return result[0], result[1], gr.update(visible=True)
+        return None, s, gr.update(visible=False)
+
+    # Trigger on reference face upload/change
+    reference_face.change(
+        fn=auto_swap_wrapper,
+        inputs=swap_inputs,
+        outputs=[comparison_slider, seed_output, run_button],
+    )
+
+    # Trigger on target image upload/change
+    target_image.change(
+        fn=auto_swap_wrapper,
+        inputs=swap_inputs,
+        outputs=[comparison_slider, seed_output, run_button],
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=True, theme=gr.themes.Citrus())

examples/image-gen.py

@@ -0,0 +1,436 @@
+import os
+import subprocess
+import sys
+import io
+import gradio as gr
+import numpy as np
+import random
+import spaces
+import torch
+from diffusers import Flux2KleinPipeline
+import requests
+from PIL import Image
+import json
+import base64
+from huggingface_hub import InferenceClient
+
+dtype = torch.bfloat16
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+MAX_SEED = np.iinfo(np.int32).max
+MAX_IMAGE_SIZE = 1024
+
+hf_client = InferenceClient(
+    api_key=os.environ.get("HF_TOKEN"),
+)
+VLM_MODEL = "baidu/ERNIE-4.5-VL-424B-A47B-Base-PT"
+
+SYSTEM_PROMPT_TEXT_ONLY = """You are an expert prompt engineer for FLUX.2 by Black Forest Labs. Rewrite user prompts to be more descriptive while strictly preserving their core subject and intent.
+Guidelines:
+1. Structure: Keep structured inputs structured (enhance within fields). Convert natural language to detailed paragraphs.
+2. Details: Add concrete visual specifics - form, scale, textures, materials, lighting (quality, direction, color), shadows, spatial relationships, and environmental context.
+3. Text in Images: Put ALL text in quotation marks, matching the prompt's language. Always provide explicit quoted text for objects that would contain text in reality (signs, labels, screens, etc.) - without it, the model generates gibberish.
+Output only the revised prompt and nothing else."""
+
+SYSTEM_PROMPT_WITH_IMAGES = """You are FLUX.2 by Black Forest Labs, an image-editing expert. You convert editing requests into one concise instruction (50-80 words, ~30 for brief requests).
+Rules:
+- Single instruction only, no commentary
+- Use clear, analytical language (avoid "whimsical," "cascading," etc.)
+- Specify what changes AND what stays the same (face, lighting, composition)
+- Reference actual image elements
+- Turn negatives into positives ("don't change X" → "keep X")
+- Make abstractions concrete ("futuristic" → "glowing cyan neon, metallic panels")
+- Keep content PG-13
+Output only the final instruction in plain text and nothing else."""
+
+# Model repository IDs for 9B
+REPO_ID_REGULAR = "black-forest-labs/FLUX.2-klein-base-9B"
+REPO_ID_DISTILLED = "black-forest-labs/FLUX.2-klein-9B"
+
+# Load both 9B models
+print("Loading 9B Regular model...")
+pipe_regular = Flux2KleinPipeline.from_pretrained(REPO_ID_REGULAR, torch_dtype=dtype)
+pipe_regular.to("cuda")
+
+print("Loading 9B Distilled model...")
+pipe_distilled = Flux2KleinPipeline.from_pretrained(REPO_ID_DISTILLED, torch_dtype=dtype)
+pipe_distilled.to("cuda")
+
+# Dictionary for easy access
+pipes = {
+    "Distilled (4 steps)": pipe_distilled,
+    "Base (50 steps)": pipe_regular,
+}
+
+# Default steps for each mode
+DEFAULT_STEPS = {
+    "Distilled (4 steps)": 4,
+    "Base (50 steps)": 50,
+}
+
+DEFAULT_CFG = {
+    "Distilled (4 steps)": 1.0,
+    "Base (50 steps)": 4.0,
+}
+
+def image_to_data_uri(img):
+    """
+    Convert a PIL Image to a base64 data URI.
+    Args:
+        img: The PIL Image to convert.
+    Returns:
+        str: A data URI string containing the base64-encoded PNG image.
+    """
+    buffered = io.BytesIO()
+    img.save(buffered, format="PNG")
+    img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+    return f"data:image/png;base64,{img_str}"
+
+
+def upsample_prompt_logic(prompt, image_list):
+    """
+    Enhance a text prompt using a Vision-Language Model.
+    Args:
+        prompt (str): The original text prompt to enhance.
+        image_list: Optional list of PIL Images for context-aware enhancement.
+    Returns:
+        str: The enhanced prompt, or the original prompt if enhancement fails.
+    """
+    try:
+        if image_list and len(image_list) > 0:
+            # Image + Text Editing Mode
+            system_content = SYSTEM_PROMPT_WITH_IMAGES
+            
+            # Construct user message with text and images
+            user_content = [{"type": "text", "text": prompt}]
+            
+            for img in image_list:
+                data_uri = image_to_data_uri(img)
+                user_content.append({
+                    "type": "image_url",
+                    "image_url": {"url": data_uri}
+                })
+                
+            messages = [
+                {"role": "system", "content": system_content},
+                {"role": "user", "content": user_content}
+            ]
+        else:
+            # Text Only Mode
+            system_content = SYSTEM_PROMPT_TEXT_ONLY
+            messages = [
+                {"role": "system", "content": system_content},
+                {"role": "user", "content": prompt}
+            ]
+
+        completion = hf_client.chat.completions.create(
+            model=VLM_MODEL,
+            messages=messages,
+            max_tokens=1024
+        )
+        
+        return completion.choices[0].message.content
+    except Exception as e:
+        print(f"Upsampling failed: {e}")
+        return prompt
+
+
+def update_dimensions_from_image(image_list):
+    """
+    Update width/height based on uploaded image aspect ratio.
+    
+    Keeps one side at 1024 and scales the other proportionally,
+    with both sides as multiples of 8.
+    Args:
+        image_list: Gallery list of tuples (image, caption) from Gradio.
+    Returns:
+        tuple: A tuple of (width, height) integers, both multiples of 8.
+    """
+    if image_list is None or len(image_list) == 0:
+        return 1024, 1024  # Default dimensions
+    
+    # Get the first image to determine dimensions
+    img = image_list[0][0]  # Gallery returns list of tuples (image, caption)
+    img_width, img_height = img.size
+    
+    aspect_ratio = img_width / img_height
+    
+    if aspect_ratio >= 1:  # Landscape or square
+        new_width = 1024
+        new_height = int(1024 / aspect_ratio)
+    else:  # Portrait
+        new_height = 1024
+        new_width = int(1024 * aspect_ratio)
+    
+    # Round to nearest multiple of 8
+    new_width = round(new_width / 8) * 8
+    new_height = round(new_height / 8) * 8
+    
+    # Ensure within valid range (minimum 256, maximum 1024)
+    new_width = max(256, min(1024, new_width))
+    new_height = max(256, min(1024, new_height))
+    
+    return new_width, new_height
+
+
+def update_steps_from_mode(mode_choice):
+    """
+    Update inference steps and guidance scale based on the selected mode.
+    Args:
+        mode_choice (str): The selected mode, either "Distilled (4 steps)" or "Base (50 steps)".
+    Returns:
+        tuple: A tuple of (num_inference_steps, guidance_scale).
+    """
+    return DEFAULT_STEPS[mode_choice], DEFAULT_CFG[mode_choice]
+
+
+@spaces.GPU(duration=85)
+def infer(
+    prompt: str,
+    input_images=None,
+    mode_choice: str = "Distilled (4 steps)",
+    seed: int = 42,
+    randomize_seed: bool = False,
+    width: int = 1024,
+    height: int = 1024,
+    num_inference_steps: int = 4,
+    guidance_scale: float = 4.0,
+    prompt_upsampling: bool = False,
+    progress=gr.Progress(track_tqdm=True)
+):
+    """
+    Generate or edit images using FLUX.2 Klein 9B model.
+    
+    This tool can generate images from text prompts, or edit/combine existing images
+    based on text instructions. Use the distilled mode for fast 4-step generation,
+    or base mode for higher quality 50-step generation.
+    Args:
+        prompt (str): Text description of the image to generate, or editing instructions when input images are provided.
+        input_images: Optional list of input images for editing or combining. Provide image URLs.
+        mode_choice (str): Model mode - "Distilled (4 steps)" for fast generation or "Base (50 steps)" for higher quality.
+        seed (str): Random seed for reproducible generation. Use "0" with randomize_seed=True for random results.
+        randomize_seed (str): Set to "true" to use a random seed, "false" to use the specified seed.
+        width (str): Output image width in pixels (256-1024, must be multiple of 8).
+        height (str): Output image height in pixels (256-1024, must be multiple of 8).
+        num_inference_steps (str): Number of denoising steps. Use "4" for distilled mode, "50" for base mode.
+        guidance_scale (str): How closely to follow the prompt. Use "1.0" for distilled, "4.0" for base mode.
+        prompt_upsampling (str): Set to "true" to automatically enhance the prompt using a VLM.
+    Returns:
+        tuple: A tuple containing the generated PIL Image and the seed used.
+    """
+    # Convert string inputs to proper types for MCP compatibility
+    if isinstance(seed, str):
+        seed = int(seed)
+    if isinstance(randomize_seed, str):
+        randomize_seed = randomize_seed.lower() == "true"
+    if isinstance(width, str):
+        width = int(width)
+    if isinstance(height, str):
+        height = int(height)
+    if isinstance(num_inference_steps, str):
+        num_inference_steps = int(num_inference_steps)
+    if isinstance(guidance_scale, str):
+        guidance_scale = float(guidance_scale)
+    if isinstance(prompt_upsampling, str):
+        prompt_upsampling = prompt_upsampling.lower() == "true"
+    
+    if randomize_seed:
+        seed = random.randint(0, MAX_SEED)
+    
+    # Select the appropriate pipeline based on mode choice
+    pipe = pipes[mode_choice]
+    
+    # Prepare image list (convert None or empty gallery to None)
+    image_list = None
+    if input_images is not None and len(input_images) > 0:
+        image_list = []
+        for item in input_images:
+            image_list.append(item[0])
+
+    # 1. Upsampling (Network bound)
+    final_prompt = prompt
+    if prompt_upsampling:
+        progress(0.1, desc="Upsampling prompt...")
+        final_prompt = upsample_prompt_logic(prompt, image_list)
+        print(f"Original Prompt: {prompt}")
+        print(f"Upsampled Prompt: {final_prompt}")
+
+    # 2. Image Generation
+    progress(0.2, desc=f"Generating image with 9B {mode_choice}...")
+    
+    generator = torch.Generator(device=device).manual_seed(seed)
+    
+    pipe_kwargs = {
+        "prompt": final_prompt,
+        "height": height,
+        "width": width,
+        "num_inference_steps": num_inference_steps,
+        "guidance_scale": guidance_scale,
+        "generator": generator,
+    }
+    
+    # Add images if provided
+    if image_list is not None:
+        pipe_kwargs["image"] = image_list
+    
+    image = pipe(**pipe_kwargs).images[0]
+    
+    return image, seed
+
+
+examples = [
+    ["Create a vase on a table in living room, the color of the vase is a gradient of color, starting with #02eb3c color and finishing with #edfa3c. The flowers inside the vase have the color #ff0088"],
+    ["Photorealistic infographic showing the complete Berlin TV Tower (Fernsehturm) from ground base to antenna tip, full vertical view with entire structure visible including concrete shaft, metallic sphere, and antenna spire. Slight upward perspective angle looking up toward the iconic sphere, perfectly centered on clean white background. Left side labels with thin horizontal connector lines: the text '368m' in extra large bold dark grey numerals (#2D3748) positioned at exactly the antenna tip with 'TOTAL HEIGHT' in small caps below. The text '207m' in extra large bold with 'TELECAFÉ' in small caps below, with connector line touching the sphere precisely at the window level. Right side label with horizontal connector line touching the sphere's equator: the text '32m' in extra large bold dark grey numerals with 'SPHERE DIAMETER' in small caps below. Bottom section arranged in three balanced columns: Left - Large text '986' in extra bold dark grey with 'STEPS' in caps below. Center - 'BERLIN TV TOWER' in bold caps with 'FERNSEHTURM' in lighter weight below. Right - 'INAUGURATED' in bold caps with 'OCTOBER 3, 1969' below. All typography in modern sans-serif font (such as Inter or Helvetica), color #2D3748, clean minimal technical diagram style. Horizontal connector lines are thin, precise, and clearly visible, touching the tower structure at exact corresponding measurement points. Professional architectural elevation drawing aesthetic with dynamic low angle perspective creating sense of height and grandeur, poster-ready infographic design with perfect visual hierarchy."],
+    ["Soaking wet capybara taking shelter under a banana leaf in the rainy jungle, close up photo"],
+    ["A kawaii die-cut sticker of a chubby orange cat, featuring big sparkly eyes and a happy smile with paws raised in greeting and a heart-shaped pink nose. The design should have smooth rounded lines with black outlines and soft gradient shading with pink cheeks."],
+]
+
+examples_images = [
+    ["The person from image 1 is petting the cat from image 2, the bird from image 3 is next to them", ["woman1.webp", "cat_window.webp", "bird.webp"]]
+]
+
+css = """
+#col-container {
+    margin: 0 auto;
+    max-width: 1200px;
+}
+.gallery-container img{
+    object-fit: contain;
+}
+"""
+
+with gr.Blocks(css=css) as demo:
+    
+    with gr.Column(elem_id="col-container"):
+        gr.Markdown(f"""# FLUX.2 [Klein] - 9B
+FLUX.2 [Klein] is a distilled model capable of generating, editing and combining images based on text instructions [[model](https://huggingface.co/black-forest-labs/FLUX.2-klein-9B)], [[blog](https://bfl.ai/blog/flux-2)]
+        """)
+        with gr.Row():
+            with gr.Column():
+                with gr.Row():
+                    prompt = gr.Text(
+                        label="Prompt",
+                        show_label=False,
+                        max_lines=2,
+                        placeholder="Enter your prompt",
+                        container=False,
+                        scale=3
+                    )
+                    
+                    run_button = gr.Button("Run", scale=1)
+                    
+                with gr.Accordion("Input image(s) (optional)", open=False):
+                    input_images = gr.Gallery(
+                        label="Input Image(s)",
+                        type="pil",
+                        columns=3,
+                        rows=1,
+                    )
+
+                mode_choice = gr.Radio(
+                    label="Mode",
+                    choices=["Distilled (4 steps)", "Base (50 steps)"],
+                    value="Distilled (4 steps)",
+                )
+                
+                with gr.Accordion("Advanced Settings", open=False):
+                    
+                    prompt_upsampling = gr.Checkbox(
+                        label="Prompt Upsampling",
+                        value=False,
+                        info="Automatically enhance the prompt using a VLM"
+                    )
+        
+                    seed = gr.Slider(
+                        label="Seed",
+                        minimum=0,
+                        maximum=MAX_SEED,
+                        step=1,
+                        value=0,
+                    )
+                    
+                    randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
+                    
+                    with gr.Row():
+                        
+                        width = gr.Slider(
+                            label="Width",
+                            minimum=256,
+                            maximum=MAX_IMAGE_SIZE,
+                            step=8,
+                            value=1024,
+                        )
+                        
+                        height = gr.Slider(
+                            label="Height",
+                            minimum=256,
+                            maximum=MAX_IMAGE_SIZE,
+                            step=8,
+                            value=1024,
+                        )
+                    
+                    with gr.Row():
+                        
+                        num_inference_steps = gr.Slider(
+                            label="Number of inference steps",
+                            minimum=1,
+                            maximum=100,
+                            step=1,
+                            value=4,
+                        )
+                        
+                        guidance_scale = gr.Slider(
+                            label="Guidance scale",
+                            minimum=0.0,
+                            maximum=10.0,
+                            step=0.1,
+                            value=1.0,
+                        )
+                
+                
+            with gr.Column():
+                result = gr.Image(label="Result", show_label=False)
+            
+        
+        gr.Examples(
+            examples=examples,
+            fn=infer,
+            inputs=[prompt],
+            outputs=[result, seed],
+            cache_examples=True,
+            cache_mode="lazy"
+        )
+
+        gr.Examples(
+            examples=examples_images,
+            fn=infer,
+            inputs=[prompt, input_images],
+            outputs=[result, seed],
+            cache_examples=True,
+            cache_mode="lazy"
+        )
+
+    # Auto-update dimensions when images are uploaded
+    input_images.upload(
+        fn=update_dimensions_from_image,
+        inputs=[input_images],
+        outputs=[width, height]
+    )
+    
+    # Auto-update steps when mode changes
+    mode_choice.change(
+        fn=update_steps_from_mode,
+        inputs=[mode_choice],
+        outputs=[num_inference_steps, guidance_scale]
+    )
+
+    gr.on(
+        triggers=[run_button.click, prompt.submit],
+        fn=infer,
+        inputs=[prompt, input_images, mode_choice, seed, randomize_seed, width, height, num_inference_steps, guidance_scale, prompt_upsampling],
+        outputs=[result, seed],
+        api_name="generate"  # Explicit API name for MCP tool
+    )
+
+# Launch with MCP server enabled
+demo.launch(mcp_server=True)

game/llm_engine.py

@@ -0,0 +1,52 @@
+import json
+import os
+import uuid
+import time
+import re
+# ----------------------------
+# LLM STREAM
+# ----------------------------
+
+def generate_llm_stream(client, model_name, system_prompt, message, history, state):
+    player_lang = state.get("language", "English")
+
+    struct_instruction = f"""
+    \n\nCRITICAL RULE 1: You MUST write your entire response, all storytelling, dialogue, and exactly 5 choices EXCLUSIVELY in {player_lang}.
+    CRITICAL RULE 2: At the very end of your response, you MUST append a hidden visual description for the image generator. Use EXACTLY this format (raw JSON only, no markdown):
+    <SCENE_DATA>
+    {{"image_prompt": "A highly detailed, purely visual description of the current scene, focusing on characters, lighting, and environment.", "location": "Name of the current place"}}
+    </SCENE_DATA>
+    """
+    
+    dynamic_system_prompt = system_prompt + struct_instruction
+
+    context = f"Player State:\n{json.dumps(state, indent=2)}"
+    
+    messages = [
+        {"role": "system", "content": dynamic_system_prompt},
+        {"role": "system", "content": context},
+    ]
+    
+    for h in history:
+        messages.append({"role": "user", "content": h[0]})
+        messages.append({"role": "assistant", "content": h[1]})
+
+    messages.append({"role": "user", "content": message})
+
+    stream = client.chat.completions.create(
+        model=model_name,
+        messages=messages,
+        temperature=0.95,
+        top_p=0.9,
+        presence_penalty=0.6,
+        frequency_penalty=0.4,
+        max_tokens=1200,
+        stream=True,
+    )
+
+    partial = ""
+    for chunk in stream:
+        if chunk.choices and chunk.choices[0].delta.content:
+            partial += chunk.choices[0].delta.content
+            display_text = partial.split("<SCENE_DATA>")[0].strip() # JSON bloğunu UI'dan gizlemek için ayırıyoruz
+            yield display_text, partial

game/player.py

@@ -0,0 +1,24 @@
+import json
+import os
+import uuid
+import time
+import re
+# ----------------------------
+# PLAYER INIT
+# ----------------------------
+
+def create_player(name, gender, avatar, language):
+    return {
+        "id": str(uuid.uuid4()),
+        "name": name,
+        "language": language,
+        "gender": gender,
+        "avatar": avatar,
+        "light_dark": 0,     # -100 dark, +100 light
+        "order_chaos": 0,    # -100 chaos, +100 order
+        "strength": 5,
+        "agility": 5,
+        "intelligence": 5,
+        "charisma": 5,
+        "willpower": 5,
+    }

game/translate.py

@@ -0,0 +1,34 @@
+import asyncio
+import perchance
+
+#English Deutsch Español Français Türkçe
+langs_list = ["en", "de", "es", "fr", "tr"]
+
+def translate_to_en(text, lang):
+    if lang == "en":
+        return text
+    
+    if lang not in langs_list
+        return text
+    
+    prompt = f"Translate this to English:\n{text}"
+    return llm(prompt)
+
+def translate_from_en(text, lang):
+    if lang == "en":
+        return text
+
+    if lang not in langs_list
+        return text
+
+    prompt = f"Translate this to {lang}:\n{text}"
+    return llm(prompt)
+
+async def generate(prompt):
+    gen = perchance.TextGenerator()
+    text = ""
+
+    async for chunk in gen.text(prompt):
+        text += chunk
+
+    return text

game/turn_engine.py

@@ -0,0 +1,54 @@
+import gradio as gr
+import json
+import os
+import uuid
+import time
+import re
+from game.llm_engine import generate_llm_stream
+from game.vlm_engine import extract_scene_data, generate_scene_image_structured
+from systems.alignment_system import evaluate_alignment
+# ----------------------------
+# GAME TURN
+# ----------------------------
+
+def play_turn(user_input, history, state_json, text_client, image_client, model_name, system_prompt):
+    if history is None:
+        history = []
+    
+    state = json.loads(state_json)
+
+    last_ai_message = history[-1][1] if len(history) > 0 else ""
+    
+    history.append([user_input, ""])
+
+    full_ai_response = ""
+    for display_text, full_text in generate_llm_stream(text_client, model_name, system_prompt, user_input, history[:-1], state):
+        history[-1][1] = display_text
+        full_ai_response = full_text  # Gizli JSON dahil tam metni arka planda tutuyoruz
+        yield (
+            history,                    
+            json.dumps(state),
+            state["light_dark"],
+            state["order_chaos"],
+            gr.update()
+        )
+    
+    # UI'da görünen temiz metni alignment için değerlendiriyoruz
+    if user_input.strip() and "Start the adventure" not in user_input:
+        ld_shift, oc_shift = evaluate_alignment(text_client, model_name, user_input, last_ai_message)
+        state["light_dark"] = max(-100, min(100, state["light_dark"] + ld_shift))
+        state["order_chaos"] = max(-100, min(100, state["order_chaos"] + oc_shift))
+
+    # YENİ: Arka planda biriken tam metinden JSON'u çıkarıyoruz
+    scene_data = extract_scene_data(full_ai_response)
+    
+    # JSON başarıyla alındıysa görseli üretiyoruz
+    new_image = generate_scene_image_structured(image_client, scene_data) if scene_data else None
+    
+    yield (
+        history,
+        json.dumps(state),
+        state["light_dark"],
+        state["order_chaos"],
+        new_image if new_image else gr.update()
+    )

game/vlm_engine.py

@@ -0,0 +1,39 @@
+import json
+import os
+import uuid
+import time
+import re
+# ----------------------------
+# IMAGE GENERATION
+# ----------------------------
+
+def extract_scene_data(full_text):
+    """LLM çıktısındaki gizli SCENE_DATA bloğunu bulur ve JSON'a çevirir."""
+    pattern = r"<SCENE_DATA>(.*?)</SCENE_DATA>"
+    match = re.search(pattern, full_text, re.DOTALL | re.IGNORECASE)
+    
+    if match:
+        json_str = match.group(1).strip()
+        # Llama bazen markdown (```json) ekleyebilir, onu temizliyoruz
+        json_str = json_str.replace("```json", "").replace("```", "").strip()
+        try:
+            return json.loads(json_str)
+        except Exception as e:
+            print(f"JSON Parse Error: {e}")
+    return None
+
+def generate_scene_image_structured(client, scene_data):
+    """Sadece LLM'den gelen saf 'image_prompt'u kullanarak görsel üretir."""
+    if not scene_data or "image_prompt" not in scene_data:
+        return None
+    
+    # Ana Star Wars şablonumuz
+    base_prompt = "Cinematic Star Wars concept art, highly detailed, dark atmosphere, dramatic lighting, 8k resolution, masterpiece. "
+    final_prompt = base_prompt + scene_data["image_prompt"]
+    
+    try:
+        image = client.text_to_image(final_prompt)
+        return image
+    except Exception as e:
+        print(f"Image generation failed via Router: {e}")
+        return None

systems/alignment_system.py

@@ -0,0 +1,36 @@
+import json
+import os
+import uuid
+import time
+import re
+# ----------------------------
+# ALIGNMENT STREAM
+# ----------------------------
+
+def evaluate_alignment(client, model_name, user_input, last_context=""):
+    eval_prompt = f"""You are a hidden Game Master evaluating player morality in a Star Wars RPG.
+    Story Context: "{last_context[-200:]}"
+    Player Action: "{user_input}"
+    
+    Evaluate the alignment shift for this action.
+    Light/Dark: + (Light: compassion, healing) to - (Dark: murder, selfishness, anger).
+    Order/Chaos: + (Order: following rules, loyalty) to - (Chaos: rebellion, deception, breaking laws).
+    
+    Score both from -5 to +5.
+    Return ONLY two integers separated by a comma. NO other text.
+    Example: -3, 2
+    """
+    try:
+        # Arka planda hızlıca puanlama yapması için temperature=0 kullanıyoruz
+        response = client.chat.completions.create(
+            model=model_name,
+            messages=[{"role": "user", "content": eval_prompt}],
+            max_tokens=10,
+            temperature=0.0
+        )
+        result = response.choices[0].message.content.strip()
+        ld_shift, oc_shift = result.split(',')
+        return int(ld_shift.strip()), int(oc_shift.strip())
+    except Exception as e:
+        print("Alignment parsing error:", e)
+        return 0, 0 # Hata olursa puanı değiştirme