Create Custom Visual Novels in 5 Minutes with Generative AI

    story_prompt = f"""
    You are a creative writing AI tasked with generating a short visual novel story for a Ren'Py game. Your goal is to create a compelling narrative based on the following user input:

<user_input>
{user_input}
</user_input>

Using this input as inspiration, generate a story that includes the following elements:
1. A brief introduction to the setting and main character(s)
2. An inciting incident that kicks off the main plot
...
"""
    story_outline = llm_call(haiku_35, story_prompt)
    pretty_save_json(story_outline, output_dir, "story")

    character_prompt = f"""
You are tasked with creating detailed descriptions for the main characters in a visual novel based on a given story outline. Your goal is to develop rich, well-rounded characters that fit the narrative and can be easily visualized.

First, carefully read and analyze the following story outline:

<story_outline>
{story_outline}
</story_outline>

Based on this outline, follow these steps to create detailed character descriptions:

1. Identify ALL characters in the story (for any character that will talk we need info for them).
2. For each main character, create a detailed description using the following structure:
   a. Name
   b. Age
   c. Gender
   d. Physical appearance:
      - Height and build
      - Hair color and style
      - Eye color
      - Distinctive features
   e. Personality traits
   f. Background/backstory
   g. Role in the story
   h. Typical outfit
...
"""
    characters = llm_call(haiku_35, character_prompt)
    pretty_save_json(characters, output_dir, "characters")

    background_prompt = f"""
You are tasked with creating detailed descriptions for the main locations or scenes in a visual novel based on a given story outline. Your goal is to provide rich, vivid descriptions that can be used to create visual representations of these locations.

Here is the story outline you will be working with:
<story_outline>
{story_outline}
</story_outline>

For each main location mentioned in or implied by the story outline, provide the following information:

1. Name of the location
2. Type of environment (e.g., indoor, outdoor, urban, rural)
3. Time of day and lighting conditions
4. Key features and elements of the scene
5. Mood or atmosphere of the location
6. Any important objects or details relevant to the story

After describing each location, create a concise prompt for an image generation model to create a visual representation of this location. This prompt should capture the essence of the location and its most important visual elements.

Output your location descriptions as a JSON array with the following structure:

[
    {{
        "name": "Name of the location",
        "environment": "Type of environment",
        "time_of_day": "Time of day and lighting conditions",
        "features": "Key features and elements of the scene",
        "mood": "Mood or atmosphere of the location",
        "objects": "Important objects or details relevant to the story",
        "image_prompt": "Prompt for image generation"
    }},
    ...
]

Repeat this process for each main location in the story. Ensure that your response can be parsed as valid JSON. Do not include any text outside of the JSON structure in your answer.
"""
    backgrounds = llm_call(haiku_35, background_prompt)
    pretty_save_json(backgrounds, output_dir, "backgrounds")

    dialogue_prompt = f"""
You are tasked with generating dialogue for key scenes in a visual novel based on a provided story outline and character descriptions. Follow these instructions carefully to create engaging and dynamic scenes.

First, review the story outline:
<story_outline>
{story_outline}
</story_outline>

Next, familiarize yourself with the character descriptions:
<characters>
{characters}
</characters>

And, finally review the background locations for the story:
<backgrounds>
{backgrounds}
</backgrounds>

Your task is to generate dialogue for 5-7 key scenes in the story. For each scene, provide the following components:

1. Scene setting: A brief description of the location and atmosphere.
2. Characters present: A list of characters involved in the scene.
3. Context or purpose of the scene: Explain how this scene fits into the overall story.
4. Dialogue exchange: 
   - Include character names before each line of dialogue.
   - Incorporate character personalities and backgrounds into their speech patterns.
   - Include brief action or emotion descriptors where appropriate (e.g., [laughs], [angrily]).
5. Player choice points:
   - At appropriate moments, provide 2-3 dialogue options for the player character.
   - Briefly describe how each choice might affect the scene or story.

...
"""
    scenes = llm_call(haiku_35, dialogue_prompt)
    pretty_save_json(scenes, output_dir, "scenes")

def generate_image_definitions(characters_list, backgrounds_list, output_dir="output"):
    """
    Generates Ren'Py image definitions for characters and backgrounds.
    """
    image_definitions = []
    images_dir = os.path.join(output_dir, "images")
    if not os.path.exists(images_dir):
        os.makedirs(images_dir)

    # Process characters
    for character in characters_list:

        extra = {"aspect_ratio": "4:5"}
        image_file, image_path = generate_image(
            character["image_prompt"], extra, output_dir=images_dir
        )
        # make image 50% smaller for characters, to fit in the game window
        resize_image(image_path, -75)

        image_definitions.append(
            f'image {sanitize_identifier(character["name"])} = "{image_file}"'
        )

    # Process backgrounds
    for background in backgrounds_list:

        extra = {"aspect_ratio": "16:9"}

        image_file, image_path = generate_image(
            background["image_prompt"], extra, output_dir=images_dir
        )

        # resize image to fit the game window
        resize_image(image_path, 50)

        image_definitions.append(
            f'image bg {sanitize_identifier(background["name"])} = "{image_file}"'
        )

    return "\n".join(image_definitions)

FROM amazon/aws-lambda-python:3.12

# Install system dependencies
RUN dnf update -y && dnf install -y \
    mesa-libGL \
    libX11 \
    zip \
    unzip \
    tar \
    bzip2 \
    && dnf clean all

# Set up work directory
WORKDIR /var/task

# Copy application files
COPY . .

# Install Python dependencies
RUN pip install -r requirements.txt

# Run the application
CMD ["lambda_function.lambda_handler"]