Before we get started, it will be helpful to take a quick look at how Tease AI actually works. Most tease creator options, such as Milovana's own Classic and Nyx, offer you a set of tools to create one self-contained webtease from beginning to end. Tease AI differs from traditional software in the sense that it doesn't play webteases. Rather, it emulates the experience of being teased by a domme over an instant messaging client. To achieve this effect, Tease AI runs a series of smaller scripts like so:
Start -> ( Taunt -> Module -> Link ) -> End
In this overview I'll be focusing on Start scripts and general script creation, with more detailed explanations of the other four types later. For now, here's a quick explanation of these scripts:
Start: Start scripts run when you greet your domme. The program will randomly select one Start script from the ones you have available and selected for use. These scripts usually have a brief greeting, possibly some warm up banter. All Start scripts end with the @StartStroking command, which tells the program to begin running Taunts.
Taunts: Taunts are the only one of these five types that are not actually scripts. Rather, they are a list of taunts that the domme says as you stroke to get under your skin. Taunts can be 1, 2 or 3 lines long. Taunt cycles end either automatically, or when you tell the domme you're close.
Module: Module scripts are the heart of the tease session, and can be anything from being told to edge, experiencing CBT, playing games with the domme or literally anything you can imagine. All modules must contain the @StopStroking command, or an instruction to edge which resolves the @StopStroking command automatically.
Link: Link scripts act as the buffer between Modules and being told to start stroking again, which brings the tease cycle back around to Taunts. Think of these generally as a chance to wind down from Modules or build up to stroking again, though they can be used for anything you like.
End: After the domme has cycled through ( Taunt -> Module -> Link ) enough times, she will move to an End script to decide if you cum. Orgasm chances are always determined by each user's personal settings, so unless you have your domme set to always/never allow/ruin, you'll never know for sure how ANY Tease AI session will end.
These are very simple explanations, but just remember that Start, Module, Link and End scripts are chosen randomly from all such scripts you have available and selected for use.
So let's make our own Start script and see how it works. First I need an idea. Okay, I'll have the domme greet me and tell me she hopes I've been keeping my hands off my cock. That sounds good, so let's see what we can come up with here:
(The @End command lets the program know that the script is finished and it can move on to the next script type. This is necessary because some scripts will have multiple paths, but don't worry too much about that for now)
Okay that's serviceable enough. You might be wondering how to set the delay between sentences, or how to create a "Continue" button to move the tease forward. You don't : ) Tease AI automatically creates a typing delay based on the length of the line the domme is saying. Her typing speed is fast and realistic, so you won't need to worry about pacing your tease as a script writer. In fact, what you're looking at is a complete, viable Tease AI script. Let's try running it and see what happens:
Now the first thing you might be wondering is how she responded to me saying it was good to see her when it wasn't in the script we wrote. That's because Responses are a separate process designed to integrate well with whatever may be happening at the time. Responses work with all scripts, and as a script writer, that's one less thing you have to worry about with Tease AI.
The second thing you might be wondering is if this script is going to play out the same every time. As it's written, yes. That can be a problem, because it's not very dynamic and won't hold up to repeated viewings. That may not be a problem if you have lots of Start scripts, but I think there's a couple things we can do to make it better. The first is by spicing it up with Keywords.
There's two types of Keywords in Tease AI - System Keywords and User-Created Keywords. Keywords can be recognized by the pound sign in front of them, like this: #Keyword
System Keywords return a specific value, whereas User-Created Keywords return a random value from a list of possible choices. I'll explain that later, but let's focus on a couple of System Keywords for now, #PetName and #GeneralTime. Let's take a quick look at the Domme tab in the Settings Menu:
If you've played any webtease before, you've probably been called something by a domme you didn't really care for. "Sissy" may work for some, but not for others. "Handsome" may do it for you, or it may ruin the humiliation vibe you're going for. Maybe "wanker" just hits your ear wrong. As you can see, with Tease AI each user can set the Pet Names they prefer, and they'll even change dynamically with the domme's mood. As a script writer, all you have to do is use the System Keyword #PetName, and the program will either randomly select one of the user's PetNames at random, or use whatever name they've set for themselves.
And while we're on the subject of different users, who knows what time of day each user is going to be running the program. It would be a lot more immersive if we could have the domme react to each person's time of day. The System Keyword #GeneralTime does just that, by looking at the user's time and replacing itself with "this morning", "today" or "tonight". So let's use these System Keywords in our script:
Now let's run the script again and see what we get:
As you can see, the program has replaced the System Keywords we used with words specifically appropriate to me. If I had had run this program a little later, the domme would have said "it's good to see you tonight". If I had run it in the morning, she would have said "it's good to see you this morning". These are just a couple ways that System Keywords can be used to create user-specific scripts with very little additional effort on the part of the scripter. There are System Keywords that cover a wide range of things, from the user's name, cock size, age, etc. A list of all System Keywords will be provided with the User's Guide that will be created for the program.
So let's see what else we can do with our script. It would be nice if the domme could ask if we've been good, instead of just assuming. For that we'll need to introduce the Multiple Choice ability and @Goto command. To create a Multiple Choice branch at any point in your script, simply put all choices in brackets on separate lines, followed by either @DifferentAnswer (which requires the user to answer with one of the available choices to progress) or @AcceptAnswer (which lets the tease progress even if the user didn't give one of the written examples). To see this in action, let's start reworking our script a little bit:
In this example, once the domme asks "Have you been good since the last time I saw you", the program sees the Multiple Choice brackets and waits for a response, in this case "yes" or "no". [yes] and [no] are actually unique Multiple Choice options in Tease AI scripts. As you can see in the following picture, each user can set their own Yes/No phrases. Tease AI will then accept any of those responses for [yes] and [no] Multiple Choice options. These are the only Choices that work this way, the rest are much more direct as I'll demonstrate in a moment.
For now, let's guess what happens when we run this script. If we get to the question and say "yes", then the domme will say the line after the [yes] bracket, and then move on to the next line after @DifferentAnswer. If we say "no", then she says the line after [no] and then moves on to the next line after @DifferentAnswer. If we say something other than yes or no, then she says the line after "@DifferentAnswer" and waits for a new response from us. So now that we know how that works, let's add a third option in case the user wants to specify what she means by being good:
This introduces us to the third and final Multiple Choice command, @LoopAnswer. When the domme says a line with @LoopAnswer, the Multiple Choice process waits for a new response instead of just continuing the tease. So if the user responds with a line containing "what do you mean good" (such as "What do you mean good?", "what do you mean good Mistress?", etc), then the domme will respond with "Have you kept your hands off your cock?" and then wait for a new response. The problem here is that "what do you mean good" is very specific, so let's break it down to allow for a few more options:
As you can see, Multiple Choice brackets can have as many possible response strings as you like, and if one of them is found, then the domme will say that line. For instance, our third choice will now respond to things such as "Only if you tell me what good means", "Now when you say good....", "what do you mean good?", etc.
So the only problem we have left is that the tease keeps progressing the same whether we reply "yes" or "no". To make the choice a little more meaningful, let's use the @Goto command:
So now we've fleshed out our responses a little bit. @Goto commands are very straightforward to use. Simply write @Goto and then any string you want to identity the line it goes to. So if I type @Goto(Blue Balls), then the program will search out (Blue Balls) and pick up on the line right after that. (@Goto commands can be used anywhere in the script, not just Multiple Choice) If the program encounters a Goto line in normal progression, it will simply skip over it and move to the next line. For example:
This is some text
(Goto Line)
This is some more text
The program will only output
Domme: This is some text
Domme: This is some more text
So another viable way of doing our script would be like this:
So let's run this and see how it looks:
By comparing the script to how it plays out, we start to get a sense of how it all works.
One of the nice things about scripting for Tease AI is the modular design. Scripters don't need to create huge sprawling teases from beginning to end. In fact, this is a perfectly viable script as it stands, so starting and finishing scripts for Tease AI is a much less daunting prospect for creators than with most tease creation software.
I'll end this part here for now. Of course, all I've mainly done so far is show you how to emulate what most tease creation software already allows you to do. In the next part, I'll start to show you the aspects of Tease AI that set it apart and create some very unique webteasing scenarios.
In the meantime, if you have any questions or comments about the information presented so far, please let me know and I will clarify everything I can.
