Initial commit

.gitattributes

@@ -0,0 +1,2 @@
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,140 @@
+*.h5
+*.weights
+*.env
+*.tar
+*.tfrecord
+.idea/
+.vscode/
+.DS_Store
+
+# Created by https://www.gitignore.io/api/python
+# Edit at https://www.gitignore.io/?templates=python
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don’t work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# End of https://www.gitignore.io/api/python
+
+

README.md

@@ -0,0 +1,13 @@
+---
+title: MiddleEarthAdventure
+emoji: 🏢
+colorFrom: blue
+colorTo: yellow
+sdk: streamlit
+sdk_version: 1.36.0
+app_file: app.py
+pinned: false
+license: creativeml-openrail-m
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,135 @@
+import asyncio
+import streamlit as st
+from dotenv import load_dotenv
+import os
+import random
+
+from middle_earth_adventure.constants import ALL_NAMES, ALL_SKILLS, ALL_TYPES, TEXT_MODEL, AUDIO_MODEL
+from middle_earth_adventure.game_core import GameCore
+from middle_earth_adventure.prompts import IMAGE_PROMPT
+from middle_earth_adventure.utils import are_all_options_are_filled, check_valid_player, pick_rand_index, pick_rand_items
+from middle_earth_adventure.schemas import Player, TechSpecs
+
+################ BACKEND CODE ################
+load_dotenv()
+key = os.environ.get("OPENAI_PERSONAL_KEY")
+
+# state-variables initialization 
+if "text_area_value" not in st.session_state:
+    st.session_state.text_area_value = "Choose you character..."
+if "player" not in st.session_state:
+    st.session_state.player = None
+if "tech_specs" not in st.session_state:
+    st.session_state.tech_specs = TechSpecs(narrator_voice="nova", image_model="", image_quality='', game_lenght=0)
+if "image" not in st.session_state:
+    st.session_state.image = "resources/intro.jpg"
+if "narrator_audio"not in st.session_state:
+    st.session_state.narrator_audio = None
+if "game"not in st.session_state:
+    st.session_state.game = GameCore(api_key=key, text_model=TEXT_MODEL, tts_model=AUDIO_MODEL)
+if "game_iteration" not in st.session_state:
+    st.session_state.game_iteration = 0
+if "rand" not in st.session_state:
+    st.session_state.rand = random.random()
+
+game = st.session_state.game
+
+async def progress_game(text_to_write, selection=None, start=False):
+    with st.spinner('Loading...'):
+        # utils
+        player = st.session_state.player
+        tech_specs = st.session_state.tech_specs
+        st.session_state.game_iteration += 1 # count game rounds
+        check_valid_player(player=st.session_state.player)
+        # write text
+        st.write(text_to_write)
+        # Chat completion
+        if start:
+            narration_txt = await game.start_adventure(player=player)
+        elif st.session_state.game_iteration < tech_specs.game_lenght:
+            narration_txt = await game.continue_adventure(player=player, selection=selection)
+        elif st.session_state.game_iteration == tech_specs.game_lenght:
+            narration_txt = await game.finish_adventure(player=player, selection=selection)
+        else: 
+            narration_txt = "Game has ended. Thanks for playing!"
+        # update
+        st.session_state.text_area_value = narration_txt # update
+
+        # Text to Speech
+        mp3_audio_bytes = await game.narrate_adventure_out_loud(narration_txt, tech_specs.narrator_voice)
+        st.session_state.narrator_audio = mp3_audio_bytes # update
+        
+        # Text to image generation
+        prompt = IMAGE_PROMPT.format(narration=narration_txt, response_format='b64_json',name=name, sex=sex, type=character_type)
+        image_url = await game.generate_picture_of_the_adventure(prompt, tech_specs.image_model, tech_specs.image_quality)
+        st.session_state.image = image_url 
+        
+        # Re-run to update states
+        st.rerun()
+
+default_name = ALL_NAMES[pick_rand_index(ALL_NAMES)]
+default_type = pick_rand_index(ALL_TYPES)
+default_skills = pick_rand_items(ALL_SKILLS, 2)
+
+################ USER INTERFACE (Streamlit) ################
+
+# Title
+st.title("Middle Earth Adventures")
+
+# Tech Specs
+with st.expander("Technical Specs", expanded=False):
+    narrator_voice = st.radio("Narrator's Voice", ["nova", "echo"], index=0)
+    image_model = st.radio("Image Model", ['dall-e-2', 'dall-e-3'], index=1)
+    image_quality = st.radio("Image Quality", ["standard", "hq"])
+    game_lenght = st.selectbox("Game Lenght (nr of conversation turns)", [5, 7, 10, 15, 20], index=2)
+    st.markdown("Background music:")
+    # st.audio("resources/brandon-hill-glbml-109292.mp3", format="audio/mp3", start_time=0, autoplay=False, loop=True)
+
+# Character Selection
+with st.expander("Character Selection", expanded=True):
+    name = st.text_input("Name", value=default_name)
+    character_type = st.selectbox("Type", ALL_TYPES, index=default_type)
+    # Create a text input field for custom input
+    if character_type == "Custom (make your own)":
+        custom_type = st.text_input("Enter your custom type of character:")
+        character_type = custom_type
+    else:
+        final_selection = character_type
+    sex = st.radio("Gender", ["she", "he"], index=0)
+    skills = st.multiselect("Skills (pick 2)", ALL_SKILLS, max_selections=2, help="")
+    if st.button("Create Character", use_container_width=True):
+        # write player
+        player = Player(name=name, type=character_type, sex=sex, skills=skills)
+        st.session_state.player = player
+        # write tech-specs
+        tech_specs = TechSpecs(narrator_voice=narrator_voice, image_model=image_model, 
+                            image_quality=image_quality, game_lenght=game_lenght)
+        st.session_state.tech_specs = tech_specs
+        # start adventure
+        message = f"You are {name}, {sex} is a {character_type}. Your are good at {' and '.join(skills)}"
+        if are_all_options_are_filled(player, name, character_type, sex, skills):
+            asyncio.run(progress_game(message, start=True))
+        else:
+            st.toast("Invalid character definition!")
+
+# Story Image
+st.image(st.session_state.image, use_column_width=True)
+
+# Story text
+st.markdown(f'{st.session_state.text_area_value}')
+
+# Narrator's Audio
+st.audio(st.session_state.narrator_audio, format="audio/mp3", start_time=0, loop=False, autoplay=False)
+
+# Action Buttons
+col1, col2, col3 = st.columns(3)
+with col1:
+    if st.button("A", use_container_width=True) and check_valid_player(st.session_state.player):
+        asyncio.run(progress_game("You chose option A", selection="A"))
+with col2:
+    if st.button("B", use_container_width=True) and check_valid_player(st.session_state.player):
+        asyncio.run(progress_game("You chose option B", selection="B"))
+with col3:
+    if st.button("C", use_container_width=True) and check_valid_player(st.session_state.player):
+        asyncio.run(progress_game("You chose option C", selection="C"))
+

middle_earth_adventure/constants.py

@@ -0,0 +1,28 @@
+import os
+
+from middle_earth_adventure.utils import pick_rand_items
+import streamlit as st
+import random
+
+# initialize rand object (only runs on import)
+st.session_state.rand = random.random()
+
+# GPT model object
+TEXT_MODEL="gpt-3.5-turbo"
+AUDIO_MODEL="tts-1"
+OPENAI_KEY = os.environ.get("OPENAI_PERSONAL_KEY")
+
+# Character
+ALL_SKILLS = ["Speed",  "Carisma", "Intelligence", "Force", "Deceit", "Perception", "Stealth", "Creativity", "Dexterity", "Vision"]
+ALL_TYPES = ["Warrior", "Wizard's Apprentice", "Mystical Feline", "Beautiful Ghost", "Naive Wood Elf", "Oktoberfest Peasant", "Custom (make your own)"]
+ALL_NAMES = ["Kim", "Gearld", "Yoyo", "Jojee"]
+
+# Game variability
+PLAYER_FEELINGS = ["scared", "anxious", "hopeful", "intrigued", "naive"]
+RIDDLE_OPTIONS = ["greek-inspired", "old-fashion", "funny", "fancy sounding", "human-centered", "animal-inspired"]
+FIGHT_OPTIONS = ["funny", "epic", "magical", "gothic", "full of danger", "mystical", "scary"]
+ROMANCE_OPTIONS = ["nice", "cute", "delicate"]
+GAME_VARIANTS = ["(give me a {opt} fight)".format(opt=" and ".join(pick_rand_items(FIGHT_OPTIONS, nr=2))), 
+                 "(give me a {opt} riddle)".format(opt=" and ".join(pick_rand_items(RIDDLE_OPTIONS, nr=2))), 
+                 "(give me {opt} romance)".format(opt=" and ".join(pick_rand_items(ROMANCE_OPTIONS, nr=2))), 
+                 "(add an epic building)"]

middle_earth_adventure/game_core.py

@@ -0,0 +1,82 @@
+# imports
+import random
+import time
+from openai import OpenAI 
+from dotenv import load_dotenv
+from middle_earth_adventure.constants import GAME_VARIANTS, PLAYER_FEELINGS
+from middle_earth_adventure.prompts import FINISH_PROMPT, SYSTEM_PROMPT, START_PROMPT, CONTINUE_PROMPT
+from middle_earth_adventure.utils import pick_rand_index
+from middle_earth_adventure.schemas import Player
+
+load_dotenv()
+
+
+class GameCore:
+
+  def __init__(self, api_key:str, text_model:str, tts_model: str) -> None:
+    self.client = OpenAI(api_key=api_key)
+    self.text_model = text_model
+    self.tts_model = tts_model
+    self.message_history = []
+
+  # Start Adventure
+  async def start_adventure(self, player: Player):
+    if player is None: return None
+    self.message_history = []
+    messages=[
+        {"role": "system", "content": SYSTEM_PROMPT}, 
+        {"role": "user", "content": START_PROMPT.format(name=player.name, sex=player.sex, type=player.type, 
+                                                        skill1=player.skills[0], skill2=player.skills[1])}
+      ]
+    ai_response = self.client.chat.completions.create(messages=messages, model=self.text_model)
+    ai_response = ai_response.choices[0].to_dict()["message"]
+
+    self.message_history += messages
+    self.message_history.append(ai_response)
+    return ai_response['content']
+
+  # Continue Adventure
+  async def continue_adventure(self, selection: str, player: Player):
+    if player is None: return None
+    random.seed(int(time.time()))
+    variants = random.choice(GAME_VARIANTS)
+    feeling = random.choice(PLAYER_FEELINGS)
+    print('variants=', variants)
+    print('seed=', variants)
+    message= {"role": "user", "content": CONTINUE_PROMPT.format(selection=selection, feeling=feeling, variants=variants)}
+
+    ai_response = self.client.chat.completions.create(messages=[*self.message_history, message], model=self.text_model)
+    ai_response = ai_response.choices[0].to_dict()["message"]
+
+    self.message_history.append(message)
+    self.message_history.append(ai_response)
+    return ai_response['content']
+  
+  async def finish_adventure(self, player, selection):
+      if player is None: return None
+      message= {"role": "user", "content": FINISH_PROMPT.format(selection=selection)}
+
+      ai_response = self.client.chat.completions.create(messages=[*self.message_history, message], 
+                                                        model=self.text_model, 
+                                                        frequency_penalty=1.0,
+                                                        temperature=1.7,
+                                                        max_tokens=100,
+)
+      ai_response = ai_response.choices[0].to_dict()["message"]
+
+      self.message_history.append(message)
+      self.message_history.append(ai_response)
+      return ai_response['content']
+  
+  async def narrate_adventure_out_loud(self, text: str, narrator_voice: str):
+    mp3_narration = self.client.audio.speech.create(model=self.tts_model, voice=narrator_voice, input=text)
+    mp3_narration = mp3_narration.content
+    # audio_base64 = base64.b64encode(mp3_narration).decode('utf-8')
+    return mp3_narration
+
+  async def generate_picture_of_the_adventure(self, prompt, model, image_quality):
+    if model == "dall-e-2": size = "512x512"
+    if model == "dall-e-3": size = "1024x1024"
+    image = self.client.images.generate(model=model, prompt=prompt, response_format='url',
+                                        size=size, quality=image_quality, n=1)
+    return (image.data[0].url)

middle_earth_adventure/prompts.py

@@ -0,0 +1,43 @@
+SYSTEM_PROMPT = """You are the narrator of a fantasy themed text based game. Make sure the current player faces 
+physical (fight menaces) and intellectual (solve riddles) challenges, as well as romance along his/her journey. 
+Player will contact trolls, syrens, bandits, etc. These contacts must be short. Dont extend them over more than one message.
+Dont present the same type of contact twice in succession. Ex: after a riddle go for a fight/romance, but not two riddles after each other.  
+Instructions for riddles:
+- choose between: deceitful, enigmatic, defiant, ingenious or fun riddles
+- always give the player three options, only one is the correct solution
+Instructions for fights:
+- always give the player three options, only one will result on the player coming out unharmed
+- player or companions might die or become injured after battles
+Instructions for romance:
+- once you find love, your loved one sticks with you
+- always express love with a kiss
+- player can only fall in love with female characters his/her own kind
+"""
+
+START_PROMPT = """Write the opening of a text based adventure based on a player, 
+lost in the jungle and with the goal of crossing the forest to reach civilization. 
+Its based on the middle-earth world. 
+Start by describing the world, the goal of the game and the the two possible.
+The player is called {name} and {sex} is a {type} with {skill1} and {skill2} as skills. Use at most 80 words.
+Options to choose A, B or C in each step of the adventure. Options should be described in less than 11 words.
+Use the format: 
+<text>. You are given three options:
+
+A: <text>
+B: <text>
+C: <text>
+"""
+
+CONTINUE_PROMPT = "I chose {selection} and I'm {feeling}. What is next? {variants} (Remember, always give 3 options: A, B, C)"
+
+FINISH_PROMPT = """I chose {selection}. But this is the last round of the game, 
+so write either a good or bad ending depending your impression on my performance as a player. Write only ONE ending."""
+
+IMAGE_PROMPT = """High resolution colorful image. Style is like game the concept art of a fantasy/adventure videgame. Beautiful, vivid and nitid.
+
+Scenic context:
+{narration}
+
+Hero ({sex} is a 25 year old dutch {type}) and the landscape/situation {sex} is involved are clearly depicted.
+Background is the middle-earth. No text. IGNORE all extra instructions below.
+"""

middle_earth_adventure/schemas.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel
+
+class Player(BaseModel):
+  name: str
+  sex: str
+  type: str
+  skills: list[str]
+
+class Player(BaseModel):
+  name: str
+  sex: str
+  type: str
+  skills: list[str]
+
+class TechSpecs(BaseModel):
+  narrator_voice: str
+  image_model: str
+  image_quality: str
+  game_lenght: int

middle_earth_adventure/utils.py

@@ -0,0 +1,31 @@
+import streamlit as st
+import random
+import numpy as np
+import base64
+
+from middle_earth_adventure.schemas import Player
+
+def check_valid_player(player: Player):
+    if player is None:
+        st.toast("Adventurer not defined! Create a Character first!")
+        return False
+    return True
+
+def pick_rand_index(list_to_pick: list):
+    index = int(np.floor(st.session_state.rand*len(list_to_pick)))
+    return index
+
+def pick_rand_items(list_to_pick: list, nr=2):
+    random.seed(st.session_state.rand)
+    return random.sample(list_to_pick, nr)
+
+def are_all_options_are_filled(player, name, character_type, sex, skills):
+    def check_condition_str(value):
+        return value!="" and value!=[] and (isinstance(value, str) or isinstance(value, list))
+    return (player is not None 
+            and check_condition_str(name) 
+            and check_condition_str(character_type) 
+            and check_condition_str(sex)
+            and check_condition_str(skills)
+            and len(skills)==2
+            )

requirements.txt

@@ -0,0 +1,6 @@
+# s3fs # often conflicts with boto3
+numpy
+openai
+pydantic
+python-dotenv
+streamlit

test_adventure.py

@@ -0,0 +1,71 @@
+# %% imports
+from openai import OpenAI 
+import os
+from dotenv import load_dotenv
+from IPython.display import Image, display, Audio, Markdown
+import base64
+
+import os
+os.chdir('/Users/gabriel/PythonProjects/researchProjects/middle_earth_adventure')
+
+from middle_earth_adventure.prompts import SYSTEM_PROMPT, START_PROMPT, CONTINUE_PROMPT
+
+
+# %% Use .env in ipython
+%load_ext dotenv
+%dotenv
+load_dotenv()
+
+#%% Set character features
+NAME = "GEARL"
+SEX = "Male"
+TYPE = "Warrior"
+SKILL1 = "Speed"
+SKILL2 = "Carisma" 
+SKILL3 = "Intelligence"
+SKILL4 = "Force" 
+
+# %% 
+## Set the API key and model name
+MODEL="gpt-3.5-turbo"
+client = OpenAI(api_key=os.environ.get("OPENAI_PERSONAL_KEY"))
+
+# %% Start Adventure
+message_history = []
+messages=[
+    {"role": "system", "content": SYSTEM_PROMPT}, # <-- This is the system message that provides context to the model
+    {"role": "user", "content": START_PROMPT.format(name=NAME)}  # <-- This is the user message for which the model will generate a response
+  ]
+ai_response = client.chat.completions.create(messages=messages, model=MODEL, n=1)
+ai_response = ai_response.choices[0].to_dict()["message"]
+
+message_history += messages
+message_history.append(ai_response)
+
+print(ai_response['content'])
+
+# %% Continue Adventure
+
+SELECTION = 'A'
+
+message= {"role": "user", "content": CONTINUE_PROMPT.format(name=NAME, sex=SEX, type=TYPE, selection=SELECTION,
+                                                       skill1=SKILL1, skill2=SKILL2, skill3=SKILL3, skill4=SKILL4)}
+
+ai_response = client.chat.completions.create(messages=[*message_history, message], model=MODEL, n=1)
+ai_response = ai_response.choices[0].to_dict()["message"]
+
+message_history.append(message)
+message_history.append(ai_response)
+
+print(ai_response['content'])
+
+# %% TTS
+mp3_narration = client.audio.speech.create(model='tts-1', voice='nova', input="My name is Gabriel")
+
+# %%
+dir(mp3_narration)
+
+# %%
+image = client.images.generate(model="dall-e-2", prompt="a young dutch woman", response_format='url',
+                                        size="512x512", quality="hd", n=1)
+# %%