I spawn a second fairy in the Reflect Trek. I really should have looked if the rest of the trek goes fine, but I have other things I need to work on.
So I manually tried the next few of my fairy spawn list for the first fairy on the way to town. Yes, much faster than my concept trial. I'll keep this, as delays appear particularly minimal. The entry I tried is the fifth one in the list, with 2 frames at cave and 2 frames at child. Well, 2 frames more delayed than your TAS, anyway.
The next trap is dealt with by using a normal encounter. TAS-kill two enemies as well.
The next step, then, is to figure out which RNGs and gTimers I can use that won't cause any delay to the next fairy spawn. At the point I leave town, I can spare 5 frames, with gTimer 15 down to gTimer 10. When I exit, if I leave later than gTimer 0, we're stuck waiting 21 frames for the next group. So, I constrain my search as such.
I got this list:
gT=15 R[2]= 48
gT=15 R[2]= 50
gT=15 R[2]= 52
gT=15 R[2]= 54
gT=15 R[2]=113
gT=15 R[2]=115
gT=15 R[2]=117
gT=15 R[2]=119
gT=14 R[2]= 52
gT=14 R[2]= 53
gT=14 R[2]= 54
gT=14 R[2]= 55
gT=14 R[2]=112
gT=14 R[2]=113
gT=14 R[2]=114
gT=14 R[2]=115
gT=13 R[2]= 20
gT=13 R[2]= 21
gT=13 R[2]= 54
gT=13 R[2]= 55
gT=13 R[2]=114
gT=13 R[2]=115
gT=12 R[2]= 4
gT=12 R[2]= 21
gT=12 R[2]= 55
gT=12 R[2]= 65
gT=12 R[2]= 80
gT=12 R[2]= 99
gT=11 R[2]= 12
gT=11 R[2]= 38
gT=11 R[2]= 73
gT=11 R[2]= 99
gT=10 R[2]= 34
gT=10 R[2]= 55
gT=10 R[2]= 77
gT=10 R[2]= 88
All of these spawn an east fairy. I have not constrained for path, I will check those manually.
Once I knew which numbers were available to me, I created a lua table to hold them, then tried some interesting scripting to find the possible frame delays. This is the script:
Language: lua
local PassTable={
[0]={[48]=true,[50]=true,[52]=true,[54]=true,[113]=true,[115]=true,[117]=true,[119]=true},
{[52]=true,[53]=true,[54]=true,[55]=true,[112]=true,[113]=true,[114]=true,[115]=true},
{[20]=true,[21]=true,[54]=true,[55]=true,[114]=true,[115]=true},
{[4]=true,[21]=true,[55]=true,[65]=true,[80]=true,[99]=true},
{[12]=true,[38]=true,[73]=true,[99]=true},
{[34]=true,[55]=true,[77]=true,[88]=true}
}
--*****************************************************************************
local function RecursionOverhead(T,FrameLim,r2)
--*****************************************************************************
local RNG_main= {0xA5,r2*2}
local Path= {}
--*************************************************************************
local function RecursiveScreenCheck(T,n,fl,r)
--*************************************************************************
--Yes, defining a function inside another. I say, lua is sure fun!
if not T[n] then
--This part is to terminate our recursive loop.
local s= ""
for i= 1, #Path do --Identify our frame delays.
s= s .. " " .. Path[i]
end
local val= math.floor(r[2]/2)
s= s .. " : " .. val
if PassTable[FrameLim-fl][val] then s= s .. " PASS" end
print(s)
return
end
--Oh, we're not at the end. Calculate things, then.
local RNG= {unpack(r)} --Preserve higher tier RNG
RNG[1]= 0xA5 --Screen transitions reset R[1].
Roll(RNG,T[n]-1) --Pass however long it takes us to go.
for i= 0, fl do
Roll(RNG) --Every frame we delay, add a roll.
Path[n]= i --Keep track of which screens have our delay
RecursiveScreenCheck(T,n+1,fl-i,RNG)
end
end --Function
RecursiveScreenCheck(T,1,FrameLim,RNG_main)
end
local Transitions= {453,705,705,367,370,1074,364}
RecursionOverhead(Transitions,5,115)
Okay, complicated scripting aside, this thing's output? Well, all the passes are:
2 0 0 0 0 1 0: 55
0 0 0 1 1 0 1: 80
0 0 1 0 1 0 1: 80
0 1 0 0 3 0 0: 12
0 2 1 0 1 0 0: 12
0 0 1 0 0 1 2: 38
2 0 0 0 0 0 2: 38
0 0 1 1 0 1 1: 99
1 2 0 0 0 0 2: 34
0 0 1 0 1 1 2: 55
0 1 1 0 2 1 0: 55
2 1 0 0 0 2 0: 55
0 1 0 2 0 0 2: 77
0 1 1 0 2 0 1: 77
0 2 0 1 0 0 2: 77
0 4 0 0 0 0 1: 77
0 1 0 0 0 2 2: 88
2 0 0 0 1 2 0: 88
2 0 1 2 0 0 0: 88
The single-digit numbers are the frame delays for each transition. The two-digit values on the right are R[2]. The script spat out all the fails, too, which I wanted to see in case there were mistakes. The passes look encouraging.
Time to trim things down some more. There are multiple ways to get the same R[2] and gTimer pair, so it would be pointless to bother with these duplicates. My list is now this short:
gT=12 R[2]= 55
gT=12 R[2]= 80
gT=11 R[2]= 12
gT=11 R[2]= 38
gT=11 R[2]= 99
gT=10 R[2]= 34
gT=10 R[2]= 55
gT=10 R[2]= 77
gT=10 R[2]= 88
Small enough to manually check them all. I did a direct memory edit to skip some movie tweaking, then when I found one I liked, picked the set of delays that got me the RNG, and created the input file.
I took 1 2 0 0 0 0 2, delaying town entry by 1 frame, its first screen exit by 2 frames, and delaying exiting the Reflect building by 2 frames. I was left with a gTimer of 10 and R[2] of 34. Sure enough, the run matched my memory edit, and I got a lovely fairy spawn.
If the encounters after my movie don't behave, try delaying when you trigger the approaching encounter and see if that helps. You probably already know this at this point, but I figure it wouldn't hurt to have a reminder.