-- LUA Script - precede every function and global member with lowercase name of script + '_main'
gamedata = {}
gamedata.weaponSlotGot = {}
gamedata.weaponSlotPref = {}
playerHealth = 0
playerLives = 0

local state = 0 -- init for the state of the entity's script
local start = 0 -- init for start of entity's script
local pgc = 0 	-- init variable for player gun count
local index = 0 --init variable for the weapon slot GOT and PREF array
local file = io.open("c:\\test\\example.txt", "w")  -- this opens the file for write using the absolute path I'm not sure at this point where the path would start for a relative path

function writefile_init(e)
	index = 1 -- we are only going to use slot #1 for GOT and PREF
	start = 1 -- turn on executing start routine for entity
end

function writefile_main(e)
	if start == 1 then
		-- start code goes here that runs only once
			-- because I start the player with a weapon we need to run the following 5 lines until they have values in them other than nil
			-- we use the global variables to retrieve the info
		gamedata.weaponSlotGot[index] = g_WeaponSlotGot[index] -- we need to get the slot's GOT
		gamedata.weaponSlotPref[index] = g_WeaponSlotPref[index] -- we need to get the slot's PREF
		playerHealth = g_PlayerHealth
		playerLives = g_PlayerLives
		UpdateWeaponStats()  --I actually don't know how often we should update the weapon stats we may or may not need this but use it to make sure things are updated
		if gamedata.weaponSlotGot[index] ~= nil then -- as long as this is nil then we don't want to actually start the write code
			-- when the value is not nil then we can check to see if it is larger or equal to 1 -- 0 would mean no weapon in slot
			if gamedata.weaponSlotGot[index] >= 1 then
				-- if we have a weapon in the slot then we need to begin the states of the entity script we first go to state #1
				-- we also need to end/cancel the start code
				state = 1
				start = 0
			end
		end
	else
		if state == 1 then
			--code for state 1 goes here
			pgc = g_PlayerGunCount -- assigns player gun count to variable pgc
			-- the following is the code to write the info to the open file
			file:write("WooHoo. Flatlander is amazing".."|")
			file:write("Gun count = " .. pgc .. "|")
			file:write("Weapon slot GOT #1 = " .. gamedata.weaponSlotGot[index] .. "|")
			file:write("Weapon slot PREF #1 = " .. gamedata.weaponSlotPref[index] .."|")
			file:write("Player Health = " .. playerHealth .. "|")
			file:write("Player Lives = " .. playerLives .. "&")
			state = 2
		elseif state == 2 then
			--code for state 2 goes here
			-- the following two commands should always be used for good programming practice in using the i/o for files
			file:flush() -- makes sure all the data is written to file
			file:close() -- this closes the file
			state = 3 -- we don't need to run this state after committing the file to the hard drive
		elseif state == 3 then
			--code for state 3 goes here
		elseif state == 4 then
			--code for state 4  goes here
		end
	end
end

----------------------------------------------------------------------------------
--I actually do not use l_gamedata in this script. It is shown here to  
--demonstrate that you can have a table within a table and that
--you can name each element of the table rather than referring
--to them numerically in sequence. Although it is not necessary I always
--(remember I'm old school) like to list my tables/arrays, local variables
--that are used in the script. All global variables I use in the game would be in  
--another lua file just as Lee does with his global variables. You can put them in Lee's global.lua
--file except for every time there is a new version, anything you add will be erased. 
--Just like Lee, I prefix the variable with "g_" just as I do the local variables with "l_"
--One other thing I like to do is to use variable names that are descriptive.

local l_gamedata = {} --table
	--elements of l_gamedata table
	l_gamedata.weaponSlotGot = {} -- a table within a table - index is 1-9
	l_gamedata.weaponSlotPref = {} -- a table within a table - index is 1-9
	l_gamedata.playerHealth = 0
	l_gamedata.playerLives = 0

local l_file = "" -- the file to be used
local l_list = {} --list of the parsed data as an array
local l_state = 0
local l_start = 0
local l_str2parse = ""
local l_parsechar = ""

function parsing_test_init(e)
	l_start = 1
	l_state = 1
	-- Opens a file in read mode
	l_file = io.open("c:\\test\\example.txt", "r") -- just as "w" was used for write, "r" is used for read
	-- assigns first line of the file to variable
	--     if you remember from the write file example there is only one line in this file
	--     you are able to write more than one line and read more than one line in a file
	--     however, for this example we keep it simple main reason for this example
	--     is to introduce you to a parsing function which you can use to call any 
	--     string of text with a parser character.
	l_str2parse = l_file:read() 
	l_parsechar = "|" -- this identifies the parser character 
end  --function init

function parsing_test_main(e)
	if l_start == 1 then
		l_start = 0
		-- start code goes here that runs only once
		l_list=get_parsed_data(l_str2parse,l_parsechar)
	else
		if l_state == 1 then
			--code for state 1 goes here
			-- closes the opened file
			--Prompt("line = " .. l_str2parse)
			l_file:close()
			l_state = 2
		elseif l_state == 2 then
			--code for state 2 goes here
			-- the l_list table is basically an array that contains the data from the parsed string
			TextCenterOnX(50,25,3,l_list[1] )
			TextCenterOnX(50,35,3,l_list[2] )
			TextCenterOnX(50,45,3,l_list[3] )
			TextCenterOnX(50,55,3,l_list[4] )
			TextCenterOnX(50,65,3,l_list[5] )
			TextCenterOnX(50,75,3,l_list[6] )
		elseif l_state == 3 then
			--code for state 3 goes here
		elseif l_state == 4 then
			--code for state 4  goes here
		end
	end
end --function main

function get_parsed_data(pString, pParser) -- p stands for parameter there are 2 params for this function that need to be passed
	local data_Table = {} 
	local fparser = "(.-)" .. pParser
	local last_end = 1 -- last end increases by '1' until end of string
	-- current_num_of_parser is the current number of the parser within the string
	-- track_end_of_str is a variable that increments by 1 until the end of the string
	-- parsed_data is the parsed packet of data
	local current_num_of_parser, track_end_of_str, parsed_data = pString:find(fparser, 1)
	while current_num_of_parser do
		if current_num_of_parser ~= 1 or parsed_data ~= "" then
			table.insert(data_Table,parsed_data) -- this inserts or adds the data packed to the table
		end
		last_end = track_end_of_str+1 -- increment last_end by 1
		current_num_of_parser, track_end_of_str, parsed_data = pString:find(fparser, last_end)
	end --while
	-- after the while loop ends there is one last packet to add to table
	if last_end <= #pString then
		parsed_data = pString:sub(last_end)
		table.insert(data_Table, parsed_data)
	end
	return data_Table -- return the table to the table list named l_list
end --function get_parsed_data