From 590240af68970c9b0229b7795c410c847a842afc Mon Sep 17 00:00:00 2001
From: qfox <qfox@users.sf.net>
Date: Thu, 31 Jul 2008 22:57:32 +0000
Subject: [PATCH] Right. Add files before committing...

---
 documentation/basicbot_framework.lua | 581 +++++++++++++++++++++++++++
 documentation/basicbot_front.lua     | 268 ++++++++++++
 2 files changed, 849 insertions(+)
 create mode 100644 documentation/basicbot_framework.lua
 create mode 100644 documentation/basicbot_front.lua

diff --git a/documentation/basicbot_framework.lua b/documentation/basicbot_framework.lua
new file mode 100644
index 00000000..d4559b98
--- /dev/null
+++ b/documentation/basicbot_framework.lua
@@ -0,0 +1,581 @@
+-- LuaBot, concept bot for FCEU and ZSnes and any other emu that has compatible Lua engine
+-- qFox, 30 July 2008
+-- version 1.04
+
+-- Botscript data following
+-- Rom: ROMNAME
+-- Comment: COMMENT
+-- Version: VERSION
+
+local function realcount(t) -- accurately count the number of elements of a table, even if they contain nil values. not fast, but accurate.
+	local n = 0;
+	for i,_ in pairs(t) do
+		n = n + 1;
+	end;
+	return n;
+end;
+
+local maxvalue = 100;    -- always "true", yes, pressed
+local minvalue = 0;      -- always "false", no, released
+
+-- the bot kind of works like this function. for every option, a value is requested from the programmer. 
+-- if that value is higher then a random value 0-99, this function returns true, else false.
+-- the idea is that keys are pressed based on a heuristic value. if you want absolute values, simply
+-- return values like minvalue or maxvalue, or their syntactic equals yes/no and press/release (to make
+-- the sourcecode easier to read). you can use the variable maybe for 50% chance.
+-- this function also reduces a lot of calls to random() if the user uses absolute values.
+local function rand_if(n)
+	if (n <= minvalue) then return false; end;
+	if (n >= maxvalue) then return true; end;
+	if (n > math.random(minvalue, maxvalue-1)) then return true; end;
+	return false;
+end;
+
+local loopcounter = 0;   -- counts the main loop
+local key1 = {};         -- holds the to be pressed keys this frame for player 1
+local key2 = {};         -- holds the to be pressed keys this frame for player 2
+local lastkey1 = {};     -- keys pressed in previous frame for player 1
+local lastkey2 = {};     -- keys pressed in previous frame for player 2
+local frame = 0;         -- number of frames (current value is current frame count, incremented at the start of a new frame)
+local attempt = 1;       -- number of attempts (current value is current attempt, incremented after the end of an attempt)
+local segment = 1;       -- number of segments (current value is current segment, incremented after the end of a segment)
+local okattempts = 0;    -- number of successfull attempts (including rollback)
+local failattempts = 0;  -- number of failed attempts (including rollback)
+
+local segments = {};     -- table that holds every segment, each segment is another table that consists of the score, ties, savestate (begin of segment), lastkeys, keys pressed, etc.
+segments[1] = {};        -- initialize the first segment, we initialize the savestate right after the before code has ran
+
+-- these dont have to be used, but it makes it easier to control here
+local maxframes = 400;
+local maxattempts = 200;
+local maxsegments = 100;
+
+local playingbest = false;    -- when going to the next segment, we need to play the best segment to record, this indicates when we're doing so
+local keyrecording1 = {};     -- every key pressed for player 1 is put in here
+local keyrecording2 = {};     -- every key pressed for player 2 is put in here
+
+-- some constants/macro's/whatever to make source easier to read
+local press = maxvalue;
+local release = minvalue;
+local yes = maxvalue;
+local maybe = maxvalue/2; -- 50%
+local no = minvalue;
+
+-- static constants, will be used by the frontend later
+local X = 95;
+local Y = 30;
+local Z = 0;
+local P = 0;
+local Q = 0;
+
+local vars = {};              -- variable table. each cell holds a variable. variables are remembered accross segments
+
+local outputcounter = 0;
+local updateevery = 1000;
+
+-- user defined functions
+
+local function getScore()     -- score of current attempt
+	local result = no;
+	-- SCORE
+	return result;
+end;
+
+local function getTie1()      -- tie breaker of current attempt in case score is equal
+	local result = no;
+	-- TIE1
+	return result;
+end;
+
+local function getTie2()      -- second tie breaker
+	local result = no;
+	-- TIE2
+	return result;
+end;
+
+local function getTie3()      -- third tie breaker
+	local result = no;
+	-- TIE3
+	return result;
+end;
+
+local function getTie4()      -- fourth tie breaker
+	local result = no;
+	-- TIE4
+	return result;
+end;
+
+local function isRunEnd()     -- gets called 3x! twice in the main loop (every frame). determines whether the bot should quit.
+	local result = no;
+	-- ISRUNEND
+	return result;
+end;
+
+local function mustRollBack() -- drop back to previous segment? called at the end of a segment
+	local result = no;
+	-- MUSTROLLBACK
+	return result;
+end;
+
+local function isSegmentEnd() -- end of current segment? (usually just x frames or being really stuck (to rollback))
+	local result = no;
+	-- ISSEGMENTEND
+	return result;
+end;
+
+local function isAttemptOk()  -- is current run ok? like, did you die? (then the run is NOT ok... :). return no for no and yes for yes or be left by chance.
+	local result = yes;
+	-- ISATTEMPTOK
+	return result;
+end;
+
+local function isAttemptEnd() -- end of current attempt? (like when you die or reach a goal)
+	local result = no;
+	-- ISATTEMPTEND
+	return result;
+end;
+
+-- the next 2x8 functions determine whether a button should be pressed for player 1 and 2
+-- return yes or no for absolute values, return anything between minvalue and maxvalue
+-- to set a chance of pressing that button.
+
+local function pressKeyA1()
+	local result = no;
+	-- bA1
+	return result;
+end;
+
+local function pressKeyB1()
+	local result = no;
+	-- bB1
+	return result;
+end;
+
+local function pressKeyStart1()
+	local result = no;
+	-- START1
+	return result;
+end;
+
+local function pressKeySelect1()
+	local result = no;
+	-- SELECT1
+	return result;
+end;
+
+local function pressKeyUp1()
+	local result = no;
+	-- UP1
+	return result;
+end;
+
+local function pressKeyDown1()
+	local result = no;
+	-- DOWN1
+	return result;
+end;
+
+local function pressKeyLeft1()
+	local result = no;
+	-- LEFT1
+	return result;
+end;
+
+local function pressKeyRight1()
+	local result = no;
+	-- RIGHT1
+	return result;
+end;
+
+local function pressKeyA2()
+	local result = no;
+	-- bA2
+	return result;
+end;
+
+local function pressKeyB2()
+	local result = no;
+	-- bB2
+	return result;
+end;
+
+local function pressKeyStart2()
+	local result = no;
+	-- START2
+	return result;
+end;
+
+local function pressKeySelect2()
+	local result = no;
+	-- SELECT2
+	return result;
+end;
+
+local function pressKeyUp2()
+	local result = no;
+	-- UP2
+	return result;
+end;
+
+local function pressKeyDown2()
+	local result = no;
+	-- DOWN2
+	return result;
+end;
+
+local function pressKeyLeft2()
+	local result = no;
+	-- LEFT2
+	return result;
+end;
+
+local function pressKeyRight2()
+	local result = no;
+	-- RIGHT2
+	return result;
+end;
+
+local function pressKeyA3()
+	local result = no;
+	-- bA3
+	return result;
+end;
+
+local function pressKeyB3()
+	local result = no;
+	-- bB3
+	return result;
+end;
+
+local function pressKeyStart3()
+	local result = no;
+	-- START3
+	return result;
+end;
+
+local function pressKeySelect3()
+	local result = no;
+	-- SELECT3
+	return result;
+end;
+
+local function pressKeyUp3()
+	local result = no;
+	-- UP3
+	return result;
+end;
+
+local function pressKeyDown3()
+	local result = no;
+	-- DOWN3
+	return result;
+end;
+
+local function pressKeyLeft3()
+	local result = no;
+	-- LEFT3
+	return result;
+end;
+
+local function pressKeyRight3()
+	local result = no;
+	-- RIGHT3
+	return result;
+end;
+
+local function pressKeyA4()
+	local result = no;
+	-- bA4
+	return result;
+end;
+
+local function pressKeyB4()
+	local result = no;
+	-- bB4
+	return result;
+end;
+
+local function pressKeyStart4()
+	local result = no;
+	-- START4
+	return result;
+end;
+
+local function pressKeySelect4()
+	local result = no;
+	-- SELECT4
+	return result;
+end;
+
+local function pressKeyUp4()
+	local result = no;
+	-- UP4
+	return result;
+end;
+
+local function pressKeyDown4()
+	local result = no;
+	-- DOWN4
+	return result;
+end;
+
+local function pressKeyLeft4()
+	local result = no;
+	-- LEFT4
+	return result;
+end;
+
+local function pressKeyRight4()
+	local result = no;
+	-- RIGHT4
+	return result;
+end;
+
+-- now follow the "events", one for the start and end of a frame, attempt, segment and whole bot. none of them need to return anything
+
+local function onStart() -- this code should run before the bot starts, for instance to start the game from power on and get setup the game
+	-- ONSTART
+end;
+
+local function onFinish() -- code ran after the bot finishes
+	-- ONFINISH
+end;
+
+local function onSegmentStart() -- code ran after initializing a new segment, before onAttemptStart(). framecount is always one fewer then actual frame!
+	-- ONSEGMENTSTART
+end;
+
+local function onSegmentEnd() -- code ran after a segment finishes, before cleanup of segment vars
+	-- ONSEGMENTEND
+end;
+
+local function onAttemptStart() -- code ran after initalizing a new attempt, before onInputStart(). not ran when playing back. framecount is always one fewer then actual frame!
+	-- ONATTEMPTSTART
+end;
+
+local function onAttemptEnd(wasOk) -- code ran after an attempt ends before cleanup code, argument is boolean true when attempt was ok, boolean false otherwise. not ran when playing back
+	-- ONATTEMPTEND
+end;
+
+local function onInputStart() -- code ran prior to getting input (keys are empty). not ran when playing back
+	-- ONINPUTSTART
+end;
+
+local function onInputEnd() -- code ran after getting input (lastkey are still valid) (last function before frame ends, you can still manipulate the input here!). not ran when playing back
+	-- ONINPUTEND
+end;
+
+-- the bot starts here..
+
+onStart();                                       -- run this code first
+
+segments[segment].savestate = savestate.create();       -- create anonymous savestate obj for start of first segment
+savestate.save(segments[segment].savestate);            -- save current state to it, it will be reloaded at the start of each frame
+local startkey1 = key1;                                 -- save the last key pressed in the onStart. serves as an anchor for the first segment
+local startkey2 = key2;
+local startvars = vars;                                 -- save the vars array (it might have been used by the onStart)
+lastkey1 = key1;                                        -- to enter the loop...
+lastkey2 = key2;
+--FCEU.speedmode("maximum");                            -- uncomment this line to make the bot run faster ("normal","turbo","maximum")
+
+onSegmentStart();
+onAttemptStart();
+
+collectgarbage();                                       -- just in case...
+
+-- This will loops for each frame, at the end of the while
+-- the frameadvance is called, causing it to advance
+while (rand_if(isRunEnd())) do
+	loopcounter = loopcounter + 1;   -- count the number of botloops
+	--gui.text(200,10,loopcounter);  -- print it on the right side if you want to see the number of total frames
+	
+	if (not playingbest and rand_if(isAttemptEnd())) then -- load save state, continue with next attempt (disabled when playing back best)
+		-- record this attempt as the last attempt
+		if (not segments[segment].prev) then segments[segment].prev = {}; end;
+		segments[segment].prev.frames = frame;
+		segments[segment].prev.attempt = attempt;
+		segments[segment].prev.score = getScore();
+		segments[segment].prev.tie1 = getTie1();
+		segments[segment].prev.tie2 = getTie2();
+		segments[segment].prev.tie3 = getTie3();
+		segments[segment].prev.tie4 = getTie4();
+		segments[segment].prev.ok = rand_if(isAttemptOk()); -- this is the check whether this attempt was valid or not. if not, it cannot become the best attempt.
+		-- update ok/failed attempt counters
+		if (segments[segment].prev.ok) then 
+			okattempts = okattempts + 1;
+			onAttemptEnd(true);
+		else 
+			failattempts = failattempts + 1;
+			onAttemptEnd(false);
+		end;
+
+		-- if this attempt was better then the previous one, replace it
+		-- its a long IF, but all it checks (lazy eval) is whether the current
+		-- score is better then the previous one, or if its equal and the tie1
+		-- is better then the previous tie1 or if the tie1 is equal to the prev
+		-- etc... for all four ties. Only tie4 actually needs to be better, tie1
+		-- through tie3 can be equal as well, as long as the next tie breaks the
+		-- same tie of the previous attempt :)
+		if (segments[segment].prev.ok and (not segments[segment].best or (getScore() > segments[segment].best.score or (getScore() == segments[segment].best.score and (getTie1() > segments[segment].best.tie1 or (getTie1() == segments[segment].best.tie1 and (getTie1() > segments[segment].best.tie1 or (getTie1() == segments[segment].best.tie1 and (getTie1() > segments[segment].best.tie1 or (getTie1() == segments[segment].best.tie1 and getTie1() > segments[segment].best.tie1)))))))))) then
+			-- previous attempt was better then current best (or no current best
+			-- exists), so we (re)place it.
+			if (not segments[segment].best) then segments[segment].best = {}; end;
+			segments[segment].best.frames = segments[segment].prev.frames;
+			segments[segment].best.attempt = segments[segment].prev.attempt;
+			segments[segment].best.score = segments[segment].prev.score;
+			segments[segment].best.tie1 = segments[segment].prev.tie1;
+			segments[segment].best.tie2 = segments[segment].prev.tie2;
+			segments[segment].best.tie3 = segments[segment].prev.tie3;
+			segments[segment].best.tie4 = segments[segment].prev.tie4;
+			segments[segment].best.keys1 = keyrecording1; -- backup the recorded keys
+			segments[segment].best.keys2 = keyrecording2; -- backup the recorded keys player 2
+			segments[segment].best.lastkey1 = lastkey1; -- backup the lastkey
+			segments[segment].best.lastkey2 = lastkey2; -- backup the lastkey
+			segments[segment].best.vars = vars; -- backup the vars table
+		end
+		
+		if (rand_if(isSegmentEnd())) then -- the current segment ends, replay the best attempt and continue from there onwards...
+			onSegmentEnd();
+			if (rand_if(mustRollBack())) then -- rollback to previous segment
+				gui.text(50,50,"Rolling back to segment "..(segment-1));
+				segments[segment] = nil; -- remove current segment data
+				attempt = 0; -- will be incremented in a few lines to be 1
+				segment = segment - 1;
+				segments[segment].best = nil;
+				segments[segment].prev = nil;
+				collectgarbage(); -- collect the removed segment please
+			else
+				playingbest = true; -- this will start playing back the best attempt in this frame
+			end;
+		end;
+
+		-- reset vars
+		attempt = attempt + 1;
+		frame = 0;
+		keyrecording1 = {}; -- reset the recordings :)
+		keyrecording2 = {};
+		-- set lastkey to lastkey of previous segment (or start, if first segment)
+		-- also set the vars table to the table of the previous segment
+		if (segment == 1) then 
+			lastkey1 = startkey1;
+			lastkey1 = startkey1;
+			vars = startvars;
+		else 
+			lastkey1 = segments[segment-1].best.lastkey1;
+			lastkey2 = segments[segment-1].best.lastkey2;
+			vars = segments[segment-1].best.vars;
+		end;
+		-- load the segment savestate to go back to the start of this segment
+		if (segments[segment].savestate) then -- load segment savestate and try again :)
+			savestate.load(segments[segment].savestate); 
+		else
+			fceu.crash(); -- this crashes because fceu is a nil table :) as long as gui.popup() doesnt work... we're crashing because no save state exists..? it should never happen.
+		end;
+
+		if (rand_if(isRunEnd())) then break; end; -- if end of run, break out of main loop and run in end loop.
+		
+		if (not playingbest) then onAttemptStart(); end; -- only call this when not playing back best attempt. has decreased frame counter!
+	end; -- continues with (new) attempt
+
+	-- increase framecounter _after_ processing attempt-end
+	frame = frame + 1; -- inrease the frame count (++frame?)
+
+	if (playingbest and segments[segment].best) then -- press keys from memory (if there are any)
+		gui.text(10,150,"frame "..frame.." of "..segments[segment].best.frames);
+		if (frame >= segments[segment].best.frames) then -- end of playback, start new segment
+			playingbest = false;
+			lastkey1 = segments[segment].best.lastkey1;
+			lastkey2 = segments[segment].best.lastkey2;
+			vars = segments[segment].best.vars;
+			segment = segment + 1;
+			segments[segment] = {};
+			-- create a new savestate for the start of this segment
+			segments[segment].savestate = savestate.create();
+			savestate.save(segments[segment].savestate);
+			-- reset vars
+			frame = 0; -- onSegmentStart and onAttemptStart expect this to be one fewer...
+			attempt = 1;
+			--key1 = {}; -- i dont think this has to be done just for the two events below. they get reset anyways before input.
+			--key2 = {};
+			keyrecording1 = {}; -- reset recordings :)
+			keyrecording2 = {};
+			-- after this, the next segment starts because playingbest is no longer true
+			onSegmentStart();
+			onAttemptStart();
+			frame = 1; -- now set it to 1
+		else
+			key1 = segments[segment].best.keys1[frame]; -- fill keys with that of the best attempt
+			key2 = segments[segment].best.keys2[frame];
+			gui.text(10,10,"Playback best of segment "..segment.."\nFrame: "..frame);
+		end;
+	end;
+
+	if (rand_if(isRunEnd())) then break; end; -- if end of run, break out of main loop
+  -- note this is the middle, this is where an attempt or segment has ended if it would and started if it would!
+  -- now comes the input part for this frame
+	
+	if (not playingbest) then -- when playing best, the keys have been filled above.
+		-- press keys from bot
+		gui.text(10,10,"Attempt: "..attempt.." / "..maxattempts.."\nFrame: "..frame.." / "..maxframes);
+		if (segments[segment] and segments[segment].best and segments[segment].prev) then 
+			gui.text(10,30,"Last score: "..segments[segment].prev.score.." ok="..okattempts..", fail="..failattempts.."\nBest score: "..segments[segment].best.score);
+		elseif (segments[segment] and segments[segment].prev) then
+			gui.text(10,30,"Last score: "..segments[segment].prev.score.."\nBest score: none, fails="..failattempts); 
+		end;
+		gui.text(10,50,"Segment: "..segment);
+		
+		key1 = {};
+		key2 = {};
+
+		onInputStart();
+
+		-- player 1
+		if (rand_if(pressKeyUp1()) )    then key1.up = 1; end;
+		if (rand_if(pressKeyDown1()))   then key1.down = 1; end;
+		if (rand_if(pressKeyLeft1()))   then key1.left = 1; end;
+		if (rand_if(pressKeyRight1()))  then key1.right = 1; end;
+		if (rand_if(pressKeyA1()))      then key1.A = 1; end;
+		if (rand_if(pressKeyB1()))      then key1.B = 1; end;
+		if (rand_if(pressKeySelect1())) then key1.select = 1; end;
+		if (rand_if(pressKeyStart1()))  then key1.start = 1; end;
+
+		-- player 2
+		if (rand_if(pressKeyUp2()) )    then key2.up = 1; end;
+		if (rand_if(pressKeyDown2()))   then key2.down = 1; end;
+		if (rand_if(pressKeyLeft2()))   then key2.left = 1; end;
+		if (rand_if(pressKeyRight2()))  then key2.right = 1; end;
+		if (rand_if(pressKeyA2()))      then key2.A = 1; end;
+		if (rand_if(pressKeyB2()))      then key2.B = 1; end;
+		if (rand_if(pressKeySelect2())) then key2.select = 1; end;
+		if (rand_if(pressKeyStart2()))  then key2.start = 1; end;
+
+		onInputEnd();
+
+		lastkey1 = key1;
+		lastkey2 = key2;
+	
+		keyrecording1[frame] = key1; -- record these keys
+		keyrecording2[frame] = key2; -- record these keys
+	end;
+
+	-- actually set the keys here.
+	joypad.set(1, key1);
+	joypad.set(2, key2);
+
+	-- next frame
+	FCEU.frameadvance();
+end;
+
+onFinish(); -- allow user cleanup before starting the final botloop
+
+-- now enter an endless loop displaying the results of this run.
+while (true) do 
+	if (segments[segment].best) then gui.text(30,100,"end: max attempt ["..segment.."] had score = "..segments[segment].best.score);
+	elseif (segment > 1 and segments[segment-1].best) then gui.text(30,100,"end: no best attempt ["..segment.."]\nPrevious best score: "..segments[segment-1].best.score);
+	else gui.text(30,100,"end: no best attempt ["..segment.."] ..."); end;
+	FCEU.frameadvance();
+end;
+
+-- i dont think it ever reaches this place... perhaps it should, or some event or whatever...
+segments = nil;
+collectgarbage(); -- collect the segment data... anything else is probably not worth it...
diff --git a/documentation/basicbot_front.lua b/documentation/basicbot_front.lua
new file mode 100644
index 00000000..d798e45c
--- /dev/null
+++ b/documentation/basicbot_front.lua
@@ -0,0 +1,268 @@
+-- BasicBot, a LuaBot frontend
+-- qFox, 30 July 2008
+-- version 1.04 (unstable!)
+
+-- we need iup, so include it here
+local iuplua_open = package.loadlib("iuplua51.dll", "iuplua_open");
+iuplua_open();
+local iupcontrolslua_open = package.loadlib("iupluacontrols51.dll", "iupcontrolslua_open");
+iupcontrolslua_open();
+
+local botVersion = 1; -- check this version when saving/loading. this will change whenever the botsave-file changes.
+
+-- callback function to clean up our mess
+function emu.OnClose.iuplua()
+	--iup.Message ("IupMessage", "OnClose!");
+	if(emu and emu.OnCloseIup ~= nil) then
+		emu.OnCloseIup();
+	end
+	iup.Close(); 
+end
+
+local handles = {}; -- this table should hold the handle to all dialogs created in lua
+local dialogs = 0; -- should be incremented PRIOR to creating a new dialog
+-- called by the onclose event
+function emu.OnCloseIup()
+	if (handles) then -- just in case the user was "smart" enough to clear this
+		local i = 1;
+		while (handles[i] ~= nil) do -- cycle through all handles, false handles are skipped, nil denotes the end
+			if (handles[i] and handles[i].destroy) then -- check for the existence of what we need
+				-- close this dialog
+				handles[i]:destroy();
+				handles[i] = nil;
+			end;
+			i = i + 1;
+		end;
+	end;
+end;
+
+function createTextareaTab(reftable, tmptable, token, tab, fun, val) -- specific one, at that :)
+	reftable[token] = iup.multiline{title="Contents",expand="YES", border="YES",value=val};
+	tmptable[token] = iup.vbox{iup.label{title="function "..fun.."()\n  local result = no;"},reftable[token],iup.label{title="  return result;\nend;"}};
+	tmptable[token].tabtitle = tab;
+end;
+function createTextareaTab2(reftable, tmptable, token, fun, arg) -- specific one, at that :) this one generates no return values
+	reftable[token] = iup.multiline{title="Contents",expand="YES", border="YES",value=fun};
+	if (arg) then
+		tmptable[token] = iup.vbox{iup.label{title="function "..fun.."(wasOk) -- wasOk (boolean) is true when the attempt was ok\n"},reftable[token],iup.label{title="end;"}};
+	else
+		tmptable[token] = iup.vbox{iup.label{title="function "..fun.."()\n"},reftable[token],iup.label{title="end;"}};
+	end;
+	tmptable[token].tabtitle = fun;
+end;
+
+function createGUI(n)
+	-- this table will keep the references for easy and fast lookup. <STRID, itemobj>
+	local reftable = {};
+	-- this table we wont keep, it holds references to (mostly) cosmetic elements of the dialog
+	local tmptable = {};
+
+	-- ok, dont be intimidated by the next eight blocks of code. they basically all say the same!
+	-- every line creates an element for the gui and sets it up. every block is a tabbed pane and
+	-- they are all put into another tabbed pane themselves. all references are put into a table
+	-- paired with the tokens in the basicbot framework. this allows us to easily walk through
+	-- all the pairs of <tokens,references> and replace them in the file, uppon writing.
+	
+	reftable.ROMNAME = iup.text{title="rom name", size="300x", value="something_or_the_other.rom"};
+	tmptable.ROMNAME = iup.hbox{iup.label{title="Rom name: ", size="50x"}, reftable.ROMNAME, iup.fill{}};
+	reftable.COMMENT = iup.text{title="comment", size="300x",value="a botscript for some game"};
+	tmptable.COMMENT = iup.hbox{iup.label{title="Comment: ", size="50x"}, reftable.COMMENT, iup.fill{}};
+	reftable.VERSION = iup.text{title="version", size="70x",value="1.00"};
+	tmptable.VERSION = iup.hbox{iup.label{title="Version: ", size="50x"}, reftable.VERSION, iup.fill{}};
+	tmptable.SAVE = iup.button{title="Save contents"};
+	-- the callback is set after the dialog is created. we need the references to all controls for saving to work :)
+	tmptable.LOAD = iup.button{title="Load contents"};
+	tmptable.WRITE = iup.button{title="Write bot script"};
+	general = iup.vbox{tmptable.ROMNAME,tmptable.COMMENT,tmptable.VERSION,iup.fill{size="5x",},tmptable.SAVE,iup.fill{size="5x",},tmptable.LOAD,iup.fill{size="5x",},tmptable.WRITE,iup.fill{}};
+	general.tabtitle = "General";
+
+	createTextareaTab(reftable, tmptable, "bA1",    "A",      "isPressedA1",      "a1");
+	createTextareaTab(reftable, tmptable, "bB1",    "B",      "isPressedB1",      "b1");
+	createTextareaTab(reftable, tmptable, "START1", "Start",  "isPressedStart1",  "start1");
+	createTextareaTab(reftable, tmptable, "SELECT1","Select", "isPressedSelect1", "select1");
+	createTextareaTab(reftable, tmptable, "UP1",    "Up",     "isPressedUp1",     "up1");
+	createTextareaTab(reftable, tmptable, "DOWN1",  "Down",   "isPressedDown1",   "down1");
+	createTextareaTab(reftable, tmptable, "LEFT1",  "Left",   "isPressedLeft1",   "left1");
+	createTextareaTab(reftable, tmptable, "RIGHT1", "Right",  "isPressedRight1",  "right1");
+	tabs1 = iup.vbox{iup.tabs{tmptable.bA1,tmptable.bB1,tmptable.START1,tmptable.SELECT1,tmptable.UP1,tmptable.DOWN1,tmptable.LEFT1,tmptable.RIGHT1}};
+	tabs1.tabtitle = "Player 1";
+
+	createTextareaTab(reftable, tmptable, "bA2",    "A",      "isPressedA2",      "a2");
+	createTextareaTab(reftable, tmptable, "bB2",    "B",      "isPressedB2",      "b2");
+	createTextareaTab(reftable, tmptable, "START2", "Start",  "isPressedStart2",  "start2");
+	createTextareaTab(reftable, tmptable, "SELECT2","Select", "isPressedSelect2", "select2");
+	createTextareaTab(reftable, tmptable, "UP2",    "Up",     "isPressedUp2",     "up2");
+	createTextareaTab(reftable, tmptable, "DOWN2",  "Down",   "isPressedDown2",   "down2");
+	createTextareaTab(reftable, tmptable, "LEFT2",  "Left",   "isPressedLeft2",   "left2");
+	createTextareaTab(reftable, tmptable, "RIGHT2", "Right",  "isPressedRight2",  "right2");
+	tabs2 = iup.vbox{iup.tabs{tmptable.bA2,tmptable.bB2,tmptable.START2,tmptable.SELECT2,tmptable.UP2,tmptable.DOWN2,tmptable.LEFT2,tmptable.RIGHT2}};
+	tabs2.tabtitle = "Player 2";
+
+	createTextareaTab(reftable, tmptable, "bA3",    "A",      "isPressedA3",      "a3");
+	createTextareaTab(reftable, tmptable, "bB3",    "B",      "isPressedB3",      "b3");
+	createTextareaTab(reftable, tmptable, "START3", "Start",  "isPressedStart3",  "start3");
+	createTextareaTab(reftable, tmptable, "SELECT3","Select", "isPressedSelect3", "select3");
+	createTextareaTab(reftable, tmptable, "UP3",    "Up",     "isPressedUp3",     "up3");
+	createTextareaTab(reftable, tmptable, "DOWN3",  "Down",   "isPressedDown3",   "down3");
+	createTextareaTab(reftable, tmptable, "LEFT3",  "Left",   "isPressedLeft3",   "left3");
+	createTextareaTab(reftable, tmptable, "RIGHT3", "Right",  "isPressedRight3",  "right3");
+	tabs3 = iup.vbox{iup.tabs{tmptable.bA3,tmptable.bB3,tmptable.START3,tmptable.SELECT3,tmptable.UP3,tmptable.DOWN3,tmptable.LEFT3,tmptable.RIGHT3}};
+	tabs3.tabtitle = "Player 3";
+
+	createTextareaTab(reftable, tmptable, "bA4",    "A",      "isPressedA4",      "a4");
+	createTextareaTab(reftable, tmptable, "bB4",    "B",      "isPressedB4",      "b4");
+	createTextareaTab(reftable, tmptable, "START4", "Start",  "isPressedStart4",  "start4");
+	createTextareaTab(reftable, tmptable, "SELECT4","Select", "isPressedSelect4", "select4");
+	createTextareaTab(reftable, tmptable, "UP4",    "Up",     "isPressedUp4",     "up4");
+	createTextareaTab(reftable, tmptable, "DOWN4",  "Down",   "isPressedDown4",   "down4");
+	createTextareaTab(reftable, tmptable, "LEFT4",  "Left",   "isPressedLeft4",   "left4");
+	createTextareaTab(reftable, tmptable, "RIGHT4", "Right",  "isPressedRight4",  "right4");
+	tabs4 = iup.vbox{iup.tabs{tmptable.bA4,tmptable.bB4,tmptable.START4,tmptable.SELECT4,tmptable.UP4,tmptable.DOWN4,tmptable.LEFT4,tmptable.RIGHT4}};
+	tabs4.tabtitle = "Player 4";
+
+	createTextareaTab2(reftable, tmptable, "ONSTART",       "onStart",        false);
+	createTextareaTab2(reftable, tmptable, "ONFINISH",      "onFinish",       false);
+	createTextareaTab2(reftable, tmptable, "ONSEGMENTSTART","onSegmentStart", false);
+	createTextareaTab2(reftable, tmptable, "ONSEGMENTEND",  "onSegmentEnd",   false);
+	createTextareaTab2(reftable, tmptable, "ONATTEMPTSTART","onAttemptStart", false);
+	createTextareaTab2(reftable, tmptable, "ONATTEMPTEND",  "onAttemptEnd",   true);
+	createTextareaTab2(reftable, tmptable, "ONINPUTSTART",  "onInputStart",   false);
+	createTextareaTab2(reftable, tmptable, "ONINPUTEND",    "onInputEnd",     false);
+	tabs5 = iup.vbox{iup.tabs{tmptable.ONSTART, tmptable.ONFINISH, tmptable.ONSEGMENTSTART, tmptable.ONSEGMENTEND, tmptable.ONATTEMPTSTART, tmptable.ONATTEMPTEND, tmptable.ONINPUTSTART, tmptable.ONINPUTEND}};
+	tabs5.tabtitle = "Events";
+	
+	createTextareaTab(reftable, tmptable, "SCORE",    "score",      "getScore",      "score");
+	createTextareaTab(reftable, tmptable, "TIE1",    "tie1",      "getTie1",      "tie1");
+	createTextareaTab(reftable, tmptable, "TIE2",    "tie2",      "getTie2",      "tie2");
+	createTextareaTab(reftable, tmptable, "TIE3",    "tie3",      "getTie3",      "tie3");
+	createTextareaTab(reftable, tmptable, "TIE4",    "tie4",      "getTie4",      "tie4");
+	tabs6 = iup.vbox{iup.tabs{tmptable.SCORE,tmptable.TIE1,tmptable.TIE2,tmptable.TIE3,tmptable.TIE4}};
+	tabs6.tabtitle = "Score";
+	
+	createTextareaTab(reftable, tmptable, "ISRUNEND",     "isRunEnd",     "isRunEnd",     "isRunEnd");
+	createTextareaTab(reftable, tmptable, "MUSTROLLBACK", "mustRollBack", "mustRollBack", "mustRollBack");
+	createTextareaTab(reftable, tmptable, "ISSEGMENTEND", "isSegmentEnd", "isSegmentEnd", "isSegmentEnd");
+	createTextareaTab(reftable, tmptable, "ISATTEMPTEND", "isAttemptEnd", "isAttemptEnd", "isAttemptEnd");
+	createTextareaTab(reftable, tmptable, "ISATTEMPTOK",  "isAttemptOk",  "isAttemptOk",  "isAttemptOk");
+	tabs7 = iup.vbox{iup.tabs{tmptable.ISRUNEND,tmptable.MUSTROLLBACK,tmptable.ISSEGMENTEND,tmptable.ISATTEMPTEND,tmptable.ISATTEMPTOK}};
+	tabs7.tabtitle = "Selection";
+	
+	playertabs = iup.tabs{general,tabs1,tabs2,tabs3,tabs4,tabs5,tabs6,tabs7,title};
+	handles[n] = iup.dialog{playertabs, title="Basic Bot Frontend", size="450x200"}
+	handles[n]:showxy(iup.CENTER, iup.CENTER)
+
+	-- now set the callback function for the save button. this will use all the references above.
+	-- these remain ok in the anonymous function by something called "closures". this means that
+	-- these variables, although local to the scope of the function, will remain their value in
+	-- the anonymous function. hence we can refer to them and fetch their contents, even though
+	-- you cant refer to them outside the context of the createGUI function.
+	tmptable.WRITE.action = 
+		function(self, n)
+			local file = iup.filedlg{allownew="YES",dialogtype="SAVE",directory="./lua",showhidden="YES",title="Save botfile"};
+			file:popup(iup.ANYWHERE,iup.ANYWHERE);
+
+			if (file.value == "NULL") then
+				iup.Message("An error occurred trying to save your settings");
+				return;
+			elseif (file.status == "-1") then 
+			  iup.Message("IupFileDlg","Operation canceled");
+			  return;
+			end
+
+			-- ok, file selected, if an error occurred or user canceled, the function already returned, so lets write the bot!
+
+			-- get the framework first. we need it to find the relevant tokens
+			local fh = assert(io.open("basicbot_framework.lua","r"));
+			local framework = fh:read("*a");
+			fh:close();
+
+			-- now replace all tokens by gui values
+			-- this is where the reftable comes in very handy :p
+			for token,obj in pairs(reftable) do
+				local st00pid = (reftable[token].value or "");
+				framework = string.gsub(framework, "-- "..token, st00pid, 1); -- if nothing was entered, obj.value returns nil (not ""), so we have to make that translation
+			end;
+
+			-- open the file, if old file, clear it
+			if (file.status == "1") then 
+				fh = assert(io.open(file.value,"wb"));
+			else -- (file.status == "0")
+				fh = assert(io.open(file.value,"w+b")); -- clear file contents
+			end;
+			
+			-- write it
+			fh:write(framework);
+			
+			-- close it (automatically flushed)
+			fh:close();
+			fh = nil;
+			
+			iup.Message ("Success", "Bot written to "..file.value.."!");
+		end;
+	tmptable.SAVE.action =
+		function(self, n)
+			local file = iup.filedlg{allownew="YES",dialogtype="SAVE",directory="./lua",showhidden="YES",title="Save botfile",extfilter="BasicBot (*.bot)|*.bot|All files (*.*)|*.*|"};
+			file:popup(iup.ANYWHERE,iup.ANYWHERE);
+
+			if (file.status == 1) then -- cancel
+				return;
+			end;
+			
+			-- open the file, if old file, clear it
+			if (file.status == "1") then 
+				fh = assert(io.open(file.value,"wb"));
+			else -- (file.status == "0")
+				fh = assert(io.open(file.value,"w+b")); -- clear file contents
+			end;
+
+			-- allow us to detect the botfile version (warn the user if it's different?)
+			fh:write(botVersion.."\n");
+
+			-- now replace all tokens by gui values
+			-- this is where the reftable comes in very handy :p
+			for token,obj in pairs(reftable) do
+				print("------");
+				print(token.." control -> "..tostring(obj));
+				print(".value: "..tostring(obj.value));
+				local st00pid = obj.value;
+				if (not st00pid) then st00pid = ""; end;
+				print(string.len(st00pid));
+				fh:write(string.len(st00pid).."\n");
+				if (string.len(st00pid) > 0) then fh:write(st00pid); end;
+				fh:write("\n");
+			end;
+			
+			fh:close();
+			iup.Message ("Success", "Settings saved!");
+		end;
+		tmptable.LOAD.action =
+			function (self, n)
+				-- this function currently crashes fceux without notification
+				-- possibly because offsets are badly calculated, but serves as an example now
+				local file = iup.filedlg{allownew="NO",dialogtype="OPEN",directory="./lua",showhidden="YES",title="Save botfile",extfilter="BasicBot (*.bot)|*.bot|All files (*.*)|*.*|"};
+				file:popup(iup.ANYWHERE,iup.ANYWHERE);
+				if (file.status == 1) then -- cancel
+					return;
+				end;
+				local nellen = string.len("\n"); -- platform independent
+				fh = assert(io.open(file.value,"r"));
+				print("seek: "..fh:seek());
+				print("version: "..fh:read("*l"));
+				print("seek: "..fh:seek());
+				if (true) then return; end;
+				for token,crap in pairs(reftable) do
+					local len = fh:read("*n"); -- read line (length)
+					if (not len) then break; end;
+					fh:seek("set",fh:seek("cur", nellen)); -- remove the aesthetic return
+					print(len);
+					reftable[token].value = fh:read(len);
+					fh:seek("set",fh:seek("cur", nellen)); -- remove the aesthetic return
+				end;
+			end;
+end;
+
+dialogs = dialogs + 1;
+createGUI(dialogs);
+while (true) do
+	FCEU.frameadvance();
+end;
\ No newline at end of file