Day two completed, we would be happy if we stopped right now and released what we have. Which is a very good feeling. We've been working together well as a team and are having lots of fun with this project. I'm not much of an artist but I took the lead on our art and I'm actually really happy with what I've managed to make. I'm the most impressed with my water texture, check it out!

So we've been so focused back there that we completely forgot to give some updates. Honestly the theme had us stumped for a bit, but we settled on a concept and fired up a rapid prototype to test viability. We decided pretty quickly that it was a good idea and ran with it.

We're pretty excited about it, and I dont want to give too much away, but we're making use of some pretty cutting edge technology.

Here are a couple of screenshots from our current draft. We're pushing to get a "finished" version done, after that we'll work on polish.

Can you tell what our game is?

Our musician is absolutely crushing it, I want to give a huge shoutout to Desmond Bagely who seriously took this to the next level. Check out their professional work at desmondcheese dot com. Look at this setup!

We finished, what a ride. We are all incredibly proud of what we accomplished. I sincerely hope people get to play and enjoy it!

So if you haven't seen it yet, here's our game: https://ldjam.com/events/ludum-dare/53/stand-and-deliver-2

Basically we really wanted to do something obscure, and try to avoid the obvious when it came to the prompt. During our brain storming we thought about "dialogue/joke delivery" as a concept, but how do you make a game about a player telling jokes? How do you assess something as nebulous as humor programatically?

Well it just so happened that I had been spending a lot of time working with the gpt-api recently, and I thought it might actually be a great fit.

We very quickly prototyped some prompts using chatGPT to see if it was even remotely possible, we were looking for gpt's ability to react differently depending on the input, and for it's reactions to seem sensible.

I also wanted to be certain I could force it into giving me easily parse-able data, so far so good!

The next step was to try and engineer some prompts that would let gpt fill the various roles we had in mind for it, I wish I had kept some of the progress but all I have are the finals here:

The Crowd: `` role: "user", content: You are the collective minds of the audience in a play, you are watching an improv show where the actors are given a prompt, you are reacting to each line of dialogue. You love a good joke. You love it when they use the prompt.

            Here is the prompt the actors were given, use this for context:
            ${prompt}

            Here is the transcript from the show so far, they are improvising based on the prompt:
            ${ messages.map(h => {
                return `${h.role == 'user' ? 'Actor' : 'Support'}: ${h.content}`
            }).join('

') }

            You are judging the Actor their lines start with "Actor:", not "Support:". Only critique the Actor's performance based on their lines. Ignore dialogue from Support.
            Use the following format. Your response must be valid json. You may only respond with a single json object. Nothing else. No extra messages.
            {
              "scores": {
                "humor": {score}, // 1-10 How funny is the actors last line? Is it a good joke?
                "relevance": {score} // 1-10  Are they following the prompt and keeping in character? Does their dialogue make sense?
                },
                "feedback": "{your_message}" // Give your thoughts here, summarize your feelings? keep this to 20 words or less
            }

```

The supporting actor: An actor has just delivered a line of dialogue: ${messages} Here is the prompt they were given: ${prompt} You are the supporting actor, your role is: ${role} ${history.length > 0 ? "Here is the entire transcript of the show, including past messages you sent (you are Support), you should use this for context only" : ""} ${ history.length > 0 ? history.map(h => { return `${h.role == 'user' ? 'Actor' : 'Support'}: ${h.content}` }).join(' ') : '' } You are an improv comedian, you are extremely funny, witty, sometimes a bit silly and playful. You like slapstick comedy and act out your actions like this "*{verb or action}*" You should consider the last line of dialogue from the Actor, and come up with a response that is funny, and makes sense with the prompt, if the actor gave bad dialogue just make something up Keep your response short, no more than 25 words. Write out your response in character, You must respond with only a single line of dialogue, nothing else, do not wrap the response in quotation marks, do not prefix your response with anything Do not start your message with anything like "Support: " or "Friend: " do not use any prefixes at all.

And finally my favorite, the critic: `` role: "user", content: You are a theater critic, you have watched an improv show, You are reviewing an actor, you will be given the transcript of the show to review. You are sarcastic, witty, and snarky. Your critiques are known to be harsh but fair. You love a good joke, you love it when they stick to the prompt.

            Here is the prompt they were given:
            ${prompt}

            Here is the transcript from the show:
            ${ messages.map(h => {
                return `${h.role == 'user' ? 'Actor' : 'Support'}: ${h.content}`
            }).join('

') }

            You are judging the Actor their lines start with "Actor:", not "Support:". Only critique the Actor's performance based on their lines. Ignore dialogue from Support.
            Use the following JSON format. Your response must be valid JSON. You may only respond with a single JSON object. Nothing else. No extra messages.
            {
              "scores": {
                "humor": {score}, // 1-10 How funny were the Actor's lines?.
                "originality": {score}, // 1-10  How well does the actor's dialogue avoid cliches and tropes, how creative is the Actor?
                "relevance": {score}, // 1-10  How well does the Actor's dialogue fit with the prompt?
                "overall": {score} // 1-10  How well did the actor do overall.
                },
                "feedback": "{critique}" // Write an overly wordy, dramatic theater style critique that will appear in the newspaper on the show and the actor's performance, did they keep to the prompt? were they funny and original? keep this to 75 words or less
            }

```

Some things I learned are super important: - Don't be overly specific about behavior/personality - Always give it relevant context early in the prompt - Be OVERLY specific about your required output

It took us a lot of work to get our AI to behave reliably, and even then we still get some odd responses where it seems to have lost the context. It's Ok though, after all this is a relatively complex concept, especially for our poor supporting actor, who has to not only come up with a line, but understand it is playing "the other" character in the prompt.

All in all we are really impressed with how this all came together, and we have one final trick up our sleeve, once GPT4 is available via the api I really think this will completely change how our game works, making the AI far more creative, far more accurate, and most importantly far more human. That will be a simple one line change and I'm really looking forward to that moment.

Thanks for reading!

We're trying to decide on an engine, and one of the big factors driving this decision for our team right now is whether we can build for the web. A native engine like BabylonJS, Phaser, or something like Unity could be best as we can export as html and embed directly in our entry page. But these engines can be limited, and we were thinking of learning to use Unreal. Unreal however cannot bundle for the web.

So I thought I'd ask the community, do people play games if they're download only?

This year my team are going to be trying out Unreal. Previously we used PhaserJS and worked in VSCode. We were able to easily collaborate with live-sharing: multiple users/cursors in a single VSCode instance. We found it really powerful and worked together well in this kind of set up. We really wanted to try and find something similar in the new engine we were going to use (whichever it was) and while doing research we learned that Unreal has some kind of support for this. Today we had our prep session and explored Multi-user collaboration in Unreal, and came across some limitations that we weren't expecting: - It only works with LAN (!?) - It doesn't real-time sync blueprints - We have no idea if it syncs code at all (we're not even sure we'll be writing code)

However we were able to get things working with Hamachi, and it was honestly a really exciting prospect to "see" each other in the world and work in real time together. It felt a bit like we were playing a game together, and really woke something up for the team. We're now really looking forward to next weekend and cant wait for the Jam!

If anyone else is interested in getting this set up, we just followed this youtube tutorial: https://www.youtube.com/watch?v=7wM7f_AJgMA