[POLL] Tease AI User Poll

Webteases are great, but what if you're in the mood for a slightly more immersive experience? Chat about Tease AI and other offline tease software.

Moderator: 1885

Which of the following BEST describes your experience as a Tease AI user?

Everything's great, I just wish there were more Personalities/Scripts
63
68%
Everything's not great, I'm very sure I have everything set up right
7
8%
Everything's not great, I'm really not sure I have it set up right
16
17%
I tried to use it before, but nothing worked right/setup was confusing and I gave up on it
2
2%
I don't use Tease AI
4
4%
 
Total votes: 92

Daragorn
Explorer At Heart
Explorer At Heart
Posts: 556
Joined: Fri Nov 06, 2015 1:16 pm
Gender: Male
Sexual Orientation: Straight
I am a: Submissive

Re: [POLL] Tease AI User Poll

Post by Daragorn »

sexybastardo wrote: Wed Mar 22, 2017 12:54 pm I was testing 54.7 now for a while with my personality and I stumbled upon a few bugs. About my personality: In some cases its very complex and many times the scripts need to jump somewhere else or to a different module (for teasing, conversations or punishment etc). It's not working anymore. At some points the new Call and Miniscript behavoir put it to a non functional state. I tryed to figure out the whole behavior in 54.7, but it was very much, Here's the result:
Wow that's a lot of stuff to check :D
First of all, before moving to analyzing the single "errors" (i can anticipate that most, if not all, are not real bug...but that's how they are intended to work :)) i have one big suggestion: don't mix @miniscripts and @callreturns...they work similarly but have some little differences....generally speaking, now that @Callreturns can be nested my suggestion (as well as 1885's, so it is not just me bragging on something i created :D), is to use them instead of @Miniscript.
You can achieve the same things with them and are definitely more reliable (probably there is still some bug that i haven't found yet, but generally speaking they are pretty stable).

Now, with that in mind here are the small differencies between the two:
-single: callreturns keep track of your current stroking/edging status and, when going back, they return you to that status...miniscript do not: so for example you are stroking, launch a callreturn, ask him to stop, do your stuff and, when this end, teaseAI will send you back to stroking...do this with a miniscript and, at the end of the mini, you will not be sent back to stroking....i don't know what happens: i suppose either it will move to a link since you're not stroking or, maybe it will bugs out....never tested it :D

-nesting: nested callreturns will move back 1 step at a time when reaching the @End, until they go back to the first script/situation that launched them. Nested miniscript don't go back...they will instantly return to the script/situation that launched them as soon as the first @End is reached. So, assume you are in a script, launch a miniscript, which in turns launch another mini...when the 2nd mini ends it will NOT go back to the first miniscript (do the same thing with callreturns and, on the contrary, you'll move back to the first callreturn, and then to the script that launched)

With that in mind, you can now probably see why it is not reccomended to combine them in strange nested patterns...they will surely bugs out.

Moving on to the single situations:
MiniScripts:
@MiniScript within a MiniScript works, but leads to a dead end at the last line of the first MiniScript.
this is what i means earlier...mini works like this ;). Use callreturns if you want to move back to where you launched when it ends
@CallReturn within a MiniScript works, tested with a maximum of three level deep nested @CallReturns. But leads to a dead end - it jumps instantly at the first @End to the last line of the MiniScript and stops.
Same problem as before...the miniscript will not continue because, when you move out from it, it basically "disappear", you can't move back to where you left and continue the script....callreturns can, though.
Stroking (@MiniScript from Response File):
@Miniscript within a Miniscript works, but leads from the end in the last file instantly back to the first call. (That's maybe correct?)
same as before
@CallReturn within a Miniscript works, but leads from the end in the last file instantly back to the first call. (In this case its wrong, I guess - it should go back all steps.)
same as before....just use all @CallReturns if you want to move back...i don't get why you start with a mini and then use callreturn...why not starting with a callreturn too??
@CallReturn():
Not Stroking (Start Script):
@Miniscript within a CallReturn works fine. @CallReturn Script -> @MiniScript Script -> Rest of @CallReturn Script -> Back
This works just because you were in a non stroking state and have not changed that state during the miniscript and "luckily", since you go back to the launching script when the mini ends, you continue with the callreturn as expected because you were not in a stroking state, so teaseAI will move to reading the file.
Stroking (Response File):
@Miniscript within a CallReturn works different than before. It jumps back to Stroking after the MiniScript.
That's the problem i was saying earlier...miniscript don't "remember" what you were doing before, they are basically just a "deviation" from the previous path...so you were stroking, you callreturn (and you don't stop stroking), then mini....when the mini ends teaseAI will see you are in a stroking state and will just move to taunts...if, for example you stopped stroking during the mini, i think then you'd go back to the callreturn since now you are in a not stroking state so teaseAi will move to read a script, which currently is the callreturn.
If you used just 2 callreturns, on the contrary, at the end of the 2nd callreturn, you'd go back to the first callreturn, and, when also that one ends, back to stroking
@CallReturn within a CallReturn works, but leads from the @End in the last file instantly back to Stroking.
Mmm this is strange....well at least this one might be a bug, i'll need to check it out..i think i have similar situation in my personaliy and they seemed to work for me..

P.s: nope, you were right i tested it and it does bug indeed..but i fixed it and will send 1885 the fix
@Call after a @CallReturn: Seems to be working fine. Leads to a Module at the end of the last file.
Yes, call is intended to change the current situation no matter which one is (stroking/not stroking) and move to the called file
Stroking & @CallReturn from a Module:
Single @CallReturn: don't work - it throws you back after the end of the @CallReturn and runs a random module
Sometimes I still receive some Stroke Taunts after the @CallReturn before the new module is started.
Actually i would expect it to always send you back to stroking (so the stroke taunts) and then launch a new module...that's because, as i said, callreturn keeps track of your current status...in this case you started a module without the @StopStroking command, so you are still stroking...when you go back from the callreturn he will think you were stroking, so it will send you back to the stroking cycle....this is not "fixeable" (actually it is not a bug, it is doing what it was supposed to do :-) ). There is no way around it...modules and links are supposed to be a "not-stroking" state and that's why you can't use a @StartStroking inside them...if you do, you'll be sent to the stroking cycle. Yes you can enter and go through a module without stopping the stroke, but you can't stop/restart it. In this case, the problem is that since you are in a stroking state, when you try to go back teaseAI will treat it as if you were in the stroke cycle...there is no way to fix this i am afraid.

P.s: i think i might have found a solution to this too actually...have to do some bug checks but it seems to be working :yes:
@Call():
@CallReturn after a @Call works, tested with a maximum of three level deep nested @CallReturns, but the session will end at the last line of the Call script if no further command like @StartStroking is given.
Mmm i will have to check also on this because it sound strange...i have similar situations and it has always worked fine for me...are you sure your teaseSession time was ended and that's why you moved to the end? When the call script ends, teaseAI will either move to a link (if the teaseTimer is not over) or to the end. That's not happen if you use a @Call because you "owerwrite" the normal behaviour and specifically tell it to move to a script.
P.s: if you were trying this using the run file text in the debug window, it is normal to behave like this...launching a script this way doesn't start a session, so as soon as the module end it will move to the end because it thinks the timer is up.
If you want to test it in a "normal" setting launch a session and modify the start script to do the @Call() to the first script you want to test.

So, just to be sure, are you sure that this bug happened while you were doing a session and the timer was not over?
Stroking & @Call from a Module:
@Miniscript after a @Call it throws you back and runs the script file again that contains the original call (or maybe just a random module). (In some scripts this wasn't noticeable instantly ... it leads in most cases to an endless cycle)
@CallReturn after a @Call it throws you back after the last nested CallReturn and runs the script file again that contains the original call (or maybe just a random module). (In some scripts this wasn't noticeable instantly ... it leads in most cases to an endless cycle)
@Call after a @Call: Seems to be working fine. Leads to a Link at the end of the last file.
I think i lost your combo here....so you are in a stroking state, you enter the module, don't stop the stroking state, then do a @Call, then do one or more @Callreturn/Miniscripts....have i got the sequence right?
If so, i would actually have expected it to send you back to the stroking cycle as explained before since you are in a stroking state even if inside a module...
@Call after @Call works fine, as for before, because you overwrite the normal behaviour and tell it to move to a script...but you can't go back to the script that did the 2nd call
Stroking & @Call from response file:
Response files now don't let me use a @Call anymore, TeaseAI does ignore it without any message. Don't know whats happening there.
I don't think this has been touched lately and i think this was intended too....as i said multiple times now, modules are supposed to be launched at the end of a stroke cycle so calling them while in a stroke cycle without ending it would cause bugs...you can use @Interrupt() in those cases if you want to move to a link after the called module ends (but you need to move those files in the interrupt folder) or @CallReturn() if you want to get back to the stroking cycle at its end
Please notice that I didn't test everything, and I noticed in some cases it worked in others not. Mostly it depends if the user is stroking or not. But I don't have the time to figure it out more currently. I marked the lines red that (at least in my view) needs to be fixed.

Basically I'm using @Miniscript and @Calls (for modules) before I'm telling the user to stop stroking, so in general that's the reason most of the scripts doesn't work anymore. I tryed to replace the @Miniscript with @CallReturns and then noticed that it also doesn't work ...

Could you please take a deep look into this?
As i said earlier i am sorry but i am afraid this is not something that can be fixed without a major overhaul of how teaseAI works.
Modules and Links are supposed to be not stroking conditions that usually start with a stop command. The most you can do is going through a module without telling him to stop, but you cant stop/start or move out of a module and go back there.
The only suggestion i can give you is to modify the scripts and the personality to use @Call/Interrupts in those situation, because that's the only way you can override the normal functioning....but to go back to the module that launched it you'll have to work around it with some "scripting tricks" like this:

module1 would look like this:

launch the other script@call(module2)
(returnFrom2)
continue module1
@End

Module2 would look like this:
i was called from module1
and now want to go back where i was earlier @Call(module1,returnFrom2)
@End

Pheeew that was a loooooooong answer...took me more than 1 hour to write it all :D

P.s: it might be possible that the solution i talked about earlier that i am trying will help also with some of the other issues you have (but it works with callreturns only, sorry...miniscript works too differently codewise to fix them...as i said earlier, i suggest you to just use callreturns since they can do anything a mini can, but are way more reliable (we are actually considering skipping them completely and make so that when you use a @MiniScript() it actually uses the @CallReturn code...so you won't have to change your scripts :)
Post Reply

Who is online

Users browsing this forum: Ahrefs [Bot], weywet and 33 guests