debug 0
#works to improve the sigil
#quits with parse IMPROVE SIGIL FINISHED

############## PLAYER DEFINED VARIABLES #####################



###### accepts any sigil at or greater than the target.
## Quality = "workability" value for the sigil 1-99
## Precision = "hardness" value for the sigil 1-99
## WO sigils will have high quality, lowish precision. Product sigils will have super high precision above all else.
## Danger threshold will need to be very high for product sigils.  WO sigils can be low
	var qualityTarget 55
	var precisionTarget 95

###### Abandon sigil improves when beneath this threshold
## set 0 to turn it off
## Range of possible sigils is 1-15
	var abandonLimit 11

###### risk = 1-3
## Primarily used for testing
## modifier for sanity/resolve/focus bucket only used if guaranteed to the sigil doesn't blow due to overused stars.
## 0 = assume maximum resource pulls only.  Slightly lower chance of high-precision sigils, but lower chance of failure.
## 1 = average
## 2 = assume minimum pulls only.  Higher chance of high-precision sigils, but very high chance of failure.
	var acceptableRisk 2

###### Skip Options
## Primarily used for testing
## Disable trivial, maybe straightforward for high-value sigils.
## Set to NULL to do all actions
## This will skip everything, but I don't know why you would: var skipmoves trivial|straightforward|challenging|formidable|difficult
	var skipMoves NULL
	if ("$guild" = "Trader") then var skipMoves trivial|difficult













#######################################################################
#######################################################################
##################   DO NOT EDIT BELOW THIS LINE ######################
#######################################################################

goto Improve.Sigil.Main.Start



############################## CONTROLLER ##########################
Improve.Sigil.Main.Start:
	gosub Improve.Sigil.GuildPrework
	gosub Improve.Sigil.Init.Vars
	gosub Improve.Sigil.Stats.Init
	gosub Improve.Sigil.Init.Actions

Improve.Sigil.Loop:
	### reset the moves, mostly redundant, executes an improve to trigger actions
		gosub Improve.Sigil.ResetMoves

	### check if quality can be improved
		if (%qualityLevel <= %qualityTarget) then gosub Improve.Sigil.TestVar quality

	### check if precision can be improved
		if (%precisionLevel <= %precisionTarget) then gosub Improve.Sigil.TestVar precision

	### check if win conditions are still possible
		gosub Improve.Sigil.CheckWinPossible

goto Improve.Sigil.Loop





#######################################################################
#######################################################################

##########################
#### Generic Functions ###
##########################
	Improve.Sigil.Put:
		put $0
		waitforre ^You|^Stow|^But|^What|^The
	return


##########################
#### Setup Functions #####
##########################

	Improve.Sigil.GuildPrework:
		if ("$guild" = "Trader" || "$guild" = "Bard") then {
			gosub Improve.Sigil.Put stow left
			gosub Improve.Sigil.Put get alm
			gosub Improve.Sigil.Put study alm
			if ($roundtime > 0) then {
				pause $roundtime
				pause 1
			}
			gosub Improve.Sigil.Put stow alm

			if ($Arcana.LearningRate > 30) then gosub Improve.Sigil.Put turn taran to arcana
			if ($Outdoorsmanship.LearningRate > 30) then gosub Improve.Sigil.Put turn taran to outdoorsmanship
			if ($Scholarship.LearningRate > 30) then gosub Improve.Sigil.Put turn taran to schol
			gosub Improve.Sigil.Put rub taran
			gosub Improve.Sigil.Put gaze cry
		}

		if ("$guild" = "Trader") then {
			gosub Improve.Sigil.Put spec luck
		}
		if ("$guild" = "Bard") then {
			if ($Bardic_Lore.LearningRate < 30) then gosub Improve.Sigil.Put put whist pier
		}
	return


##########################
##### Init Functions #####
##########################

	Improve.Sigil.Init.Vars:
		put #echo blue Initializing script
		var dangerLevel 0
		var sanityLevel 0
		var resolveLevel 0
		var focusLevel 0

		#Global variable set to 0 if you don't want the calling script to scribe it
		put #var scribeSigil 0

		var precisionLevel NULL
		var qualityLevel NULL

		var possibleBuckets ACTION|APPROACH|EFFORT|FORM|METHOD|PROCESS|RITUAL|TASK|TECHNIQUE
		eval Improve.Sigil.possibleBuckets.count count("%possibleBuckets","|")

		## Assign numeric values to difficulties - minimum number of stars required to complete the action ##
		#trivial = 1-3 (2)
		#straightforward = 2-5 (3)
		#formidable = 3-6 (4)
		#challenging = 4-8 (6)
		#difficult = 6-8 (8)
		var Improve.Sigil.static.trivial 1|2|3
		var Improve.Sigil.static.straightforward 2|3|5
		var Improve.Sigil.static.challenging 3|4|6
		var Improve.Sigil.static.formidable 4|6|8
		var Improve.Sigil.static.difficult 6|8|9

		pause .05
	return

	Improve.Sigil.Init.Actions:

		#Main buckets
		#capture the sigil - not necessary due to being fed the sigil from the improve script, but it could find errors.
			action var sigilName $1 when \) (\w+) sigil [comprised|formed]

		#out of 1-100, anything below 20 removes visibility
			action var STATS.previousQuality %qualityLevel;var qualityLevel $1 when Clarity:(\d+)
			action var STATS.previousPrecision %precisionLevel;var precisionLevel $1 when Precision:(\d+)

		#0-20
			action var STATS.previoussanityLevel %sanityLevel; eval sanityLevel count("$1","*") when Sanity:  (\**)
			action var STATS.previousresolveLevel %resolveLevel;eval resolveLevel count("$1","*") when Resolve: (\**)
			action var STATS.previousfocusLevel %focusLevel;eval focusLevel count("$1","*") when Focus:   (\**)
			action var STATS.previousDangerLevel %dangerLevel; eval dangerLevel count("$1","*") when Danger:  (\**)

		#early exit actions
			action goto Improve.Sigil.EMPTY when You are unaware of any completely identified sigils in the area|You are unaware of any sigil
			action goto Improve.Sigil.BLEWIT when You lose track of your surroundings
			action goto Improve.Sigil.TIMEOUT when You are unaware of any sigils in the area.  First identify one before attempting to improve its detail.
			action goto Improve.Sigil.BLEWIT when the sigil is nowhere to be found now|With dismay you ponder|removing all traces of the sigil|No traces of the sigil remain|you find yourself unable to locate the sigil anywhere

		##bucket assignment
			#$1 = difficulty (stars from pool) - trivial|straightforward|challenging|formidable|difficult
			#$2 = bucket (pool name) - focus|resolve|sanity
			#$3 = move name - ACTION|APPROACH|EFFORT|FORM|METHOD|PROCESS|RITUAL|TASK|TECHNIQUE
			#$4 = improvement - (precision|quality)... ignoring bucket to bucket moves right now as the danger level makes it impossible to use.
			action var Improve.Sigil.Move.$3 $4|$2|$1 when ^\.\.\.a (trivial|straightforward|challenging|formidable|difficult), (sanity|resolve|focus) [taxing|destroying|disrupting]* (%possibleBuckets) [for|to]* [elevate|improving|enhancing]* the sigil (precision|quality)\.$

		pause .05
	return

	Improve.Sigil.ResetMoves:
		var possibleBuckets ACTION|APPROACH|EFFORT|FORM|METHOD|PROCESS|RITUAL|TASK|TECHNIQUE
		## Setup difficulty, action variables ##
		## presetting to flags which will not trigger an improve attempt
		## quality/precision|bucketname|Difficulty
		var moveMadeThisPass 0

		eval Improve.Sigil.ResetMoves.count count("%possibleBuckets","|")
		var Improve.Sigil.ResetMoves.i 0
		Improve.Sigil.ResetMoves.While:
			var Improve.Sigil.ResetMoves.tmp %possibleBuckets(%Improve.Sigil.ResetMoves.i)
			var Improve.Sigil.Move.%Improve.Sigil.ResetMoves.tmp NULL|NULL|NULL
			math Improve.Sigil.ResetMoves.i ADD 1
			if %Improve.Sigil.ResetMoves.i <= %Improve.Sigil.possibleBuckets.count then goto Improve.Sigil.ResetMoves.While
		gosub Improve.Sigil.find.MakeMove improve na
		if (%precisionLevel < %abandonLimit) then goto Improve.Sigil.ABANDON
	return



##########################
### IMPROVE FUNCTIONS ####
##########################

	#$1 = bucket to test, quality or precision
	Improve.Sigil.TestVar:
		var Improve.Sigil.TestVar.testingBucket $1

		var Improve.Sigil.TestVar.i 0
		#iterate through all possible moves and determine if it's a good move to make
		Improve.Sigil.TestVar.While:
			#only choose moves with the right bucket
			if ("%Improve.Sigil.TestVar.testingBucket" =  "%Improve.Sigil.Move.%possibleBuckets(%Improve.Sigil.TestVar.i)(0)") then {
				#test if there's enough stars in the bucket
				gosub Improve.Sigil.find.TestVar.TestMove %possibleBuckets(%Improve.Sigil.TestVar.i) %Improve.Sigil.Move.%possibleBuckets(%Improve.Sigil.TestVar.i)(1) %Improve.Sigil.Move.%possibleBuckets(%Improve.Sigil.TestVar.i)(2)
			}
			math Improve.Sigil.TestVar.i ADD 1
			if %Improve.Sigil.TestVar.i <= %Improve.Sigil.possibleBuckets.count then goto Improve.Sigil.TestVar.While
	return


	#$1 = move to make if valid
	#$2 = array of bucket to test (improvement[ignore]|bucket|difficulty)
	#you're in this function if and only if the improvement is deemend necessary
	Improve.Sigil.find.TestVar.TestMove:
		#redefining variables as $ global references are lost in regex matches.
		var Improve.Sigil.find.TestVar.TestMove.action $1
		eval Improve.Sigil.find.TestVar.TestMove.bucket $2
		eval Improve.Sigil.find.TestVar.TestMove.difficulty $3

		# test if in the skip list
		if matchre("%Improve.Sigil.find.TestVar.TestMove.difficulty","(%skipMoves)") then {
			put #echo blue skipping a trivial move (%Improve.Sigil.find.TestVar.TestMove.action)
			return
		}

		#test if the bucket has enough resources and make the move if so.
		# I hate genie arrays. It falls apart at 2 levels deep.
		var riskModifiedMin %Improve.Sigil.static.%Improve.Sigil.find.TestVar.TestMove.difficulty
		if (%%Improve.Sigil.find.TestVar.TestMove.bucketLevel >= %riskModifiedMin(%acceptableRisk)) then gosub Improve.Sigil.find.MakeMove %Improve.Sigil.find.TestVar.TestMove.action %Improve.Sigil.find.TestVar.TestMove.difficulty

	return

	#$1 - action to take
	#$2 - difficulty (impove = na)
	Improve.Sigil.find.MakeMove:
		var moveMadeThisPass 1
		COUNTER ADD 1
		put per sigil $1
		waitfor Roundtime

		if ("$1" <> "improve") then {
			MATH Improve.Sigil.STATS.$1 ADD 1
			put #echo blue $1 improve number %Improve.Sigil.STATS.$1
			MATH Improve.Sigil.Stats.Init.NonImproveSteps ADD 1
		}

		if ("$1" = "ACTION") then {
			put per sigil action
			waitfor Roundtime
		}

		if (%c = 1) then {
			## Stats for metrics - capturing only on first improve
			var Improve.Sigil.Stats.Init.startingPrecision %precisionLevel
			var Improve.Sigil.Stats.Init.startingQuality %qualityLevel
		} else {
			gosub Improve.Sigil.Stats.PS.Report $2 $1
		}
#		gosub Improve.Sigil.Stats.PS.Save
		#check to see if minimums are met.
		gosub Improve.Sigil.CheckWin return
	return

	Improve.Sigil.CheckWin:
		if ((%qualityTarget <= %qualityLevel) && (%precisionTarget <= %precisionLevel) && ("%precisionTarget" != "NULL")) then goto Improve.Sigil.SUCCESS
		if ("$1" = "return") then return
	goto Improve.Sigil.BLEWIT

	Improve.Sigil.CheckWinPossible:
		var minStars -1

		# I hate genie.  It screws up multiple if/else statements so I have to do something stupid like this.

		if !matchre("trivial","(%skipMoves)") then {
			var minStars %Improve.Sigil.static.trivial(%acceptableRisk)
		}
		if ((minStars = -1) && (!(matchre("straightforward","(%skipMoves)")))) then {
			var minStars %Improve.Sigil.static.straightforward(%acceptableRisk)
		}
		if ((minStars = -1) && (!(matchre("challenging","(%skipMoves)")))) then {
			var minStars %Improve.Sigil.static.challenging(%acceptableRisk)
		}
		if ((minStars = -1) && (!(matchre("formidable","(%skipMoves)")))) then {
			var minStars %Improve.Sigil.static.formidable(%acceptableRisk)
		}
		if ((minStars = -1) && (!(matchre("difficult","(%skipMoves)")))) then {
			var minStars %Improve.Sigil.static.difficult(%acceptableRisk)
		}
		if (minStars = -1) then {
			#you're an idiot message
			put #echo red *** You're running the sigil improvement script with all difficulties filtered out.
			put #echo red *** Exiting the game to prevent unexpected errors.  Goodbye.
			put quit
			exit
		}
		if ((%sanityLevel < %minStars) && (%resolveLevel < %minStars) && (%focusLevel < %minStars)) then goto Improve.Sigil.CheckWin
	return

################################
### ERROR AND EXIT FUNCTIONS ###
################################

	Improve.Sigil.TIMEOUT:
		gosub Improve.Sigil.STATS.SetHeader red ERROR
		put #echo red >Log Script hung.  Exiting
		goto Improve.Sigil.END

	Improve.Sigil.BLEWIT:
		gosub Improve.Sigil.STATS.SetHeader red FAIL
		goto Improve.Sigil.END

	Improve.Sigil.EMPTY:
		gosub Improve.Sigil.STATS.SetHeader red ERROR
		put #echo >SigilLog room empty, shorting out of sigil improve early.
		goto Improve.Sigil.END

	Improve.Sigil.ABANDON:
		gosub Improve.Sigil.STATS.SetHeader white ABANDON
		goto Improve.Sigil.END

	Improve.Sigil.END:
		gosub Improve.Sigil.STATS.Report
		put #parse IMPROVE SIGIL FINISHED
	exit


#####################
### STATS PACKAGE ###
#####################


	Improve.Sigil.SUCCESS:
		gosub Improve.Sigil.STATS.SetHeader green SUCCESS
		put #var scribeSigil 1
		goto Improve.Sigil.END

	Improve.Sigil.STATS.Report:
		## Report Stats ##
		if ("%Improve.Sigil.Stats.Init.BodyString" = "") then var Improve.Sigil.Stats.Init.BodyString (%sigilName)

		## Use this to capture the total number of steps
			var Improve.Sigil.Stats.Init.BodyString %Improve.Sigil.Stats.Init.BodyString, Steps:%c

		## Report the number of times each step was called
		##	gosub Improve.Sigil.STATS.Report.Steps

		## Use this to capture the number of non-improve steps
			var Improve.Sigil.Stats.Init.BodyString %Improve.Sigil.Stats.Init.BodyString, NI_Steps:%Improve.Sigil.Stats.Init.NonImproveSteps

		## Use this to capture the starting quality
			var Improve.Sigil.Stats.Init.BodyString %Improve.Sigil.Stats.Init.BodyString, startingP:%Improve.Sigil.Stats.Init.startingPrecision

		## Use this to capture the starting precision
			var Improve.Sigil.Stats.Init.BodyString %Improve.Sigil.Stats.Init.BodyString, startingQ:%Improve.Sigil.Stats.Init.startingQuality

		## Use this to capture the ending quality
			var Improve.Sigil.Stats.Init.BodyString %Improve.Sigil.Stats.Init.BodyString, Q:%qualityLevel

		## Use this to capture the ending precision
			var Improve.Sigil.Stats.Init.BodyString %Improve.Sigil.Stats.Init.BodyString, P:%precisionLevel

		#use this to report the stats
			put #echo %Improve.Sigil.Stats.Init.color >Log Sigil %Improve.Sigil.Stats.Init.result %Improve.Sigil.Stats.Init.BodyString
	return

	Improve.Sigil.STATS.Report.Steps:
		eval Improve.Sigil.STATS.Report.count count("%possibleBuckets","|")
		var Improve.Sigil.STATS.Report.i 0
		Improve.Sigil.STATS.Report.While:
			var Improve.Sigil.STATS.Report.key %possibleBuckets(%Improve.Sigil.STATS.Report.i)
			var Improve.Sigil.STATS.Report.value %Improve.Sigil.STATS.%Improve.Sigil.STATS.Report.key
			var Improve.Sigil.Stats.Init.BodyString %Improve.Sigil.Stats.Init.BodyString, %Improve.Sigil.STATS.Report.key:%Improve.Sigil.STATS.Report.value
			math Improve.Sigil.STATS.Report.i ADD 1
			if %Improve.Sigil.STATS.Report.i <= %Improve.Sigil.possibleBuckets.count then goto Improve.Sigil.STATS.Report.While
	return

	Improve.Sigil.STATS.SetHeader:
		var Improve.Sigil.Stats.Init.color $1
		var Improve.Sigil.Stats.Init.result $2
	return

	Improve.Sigil.Stats.Init:
		COUNTER set 0

		# Prefix
		var Improve.Sigil.Stats.Init.initString
		var Improve.Sigil.Stats.Init.color red
		var Improve.Sigil.Stats.Init.logWindow sigillog
		var Improve.Sigil.Stats.Init.BodyString
		var Improve.Sigil.Stats.Init.NonImproveSteps 0

		# to help determine the abandon threshhold
		var Improve.Sigil.Stats.Init.startingPrecision -1
		var Improve.Sigil.Stats.Init.startingQuality -1

		eval Improve.Sigil.Stats.Init.count count("%possibleBuckets","|")
		var Improve.Sigil.Stats.Init.i 0
		Improve.Sigil.Stats.Init.While:
			var Improve.Sigil.Stats.Init.tmp %possibleBuckets(%Improve.Sigil.Stats.Init.i)
			var Improve.Sigil.STATS.%Improve.Sigil.Stats.Init.tmp 0
			math Improve.Sigil.Stats.Init.i ADD 1
			if %Improve.Sigil.Stats.Init.i <= %Improve.Sigil.possibleBuckets.count then goto Improve.Sigil.Stats.Init.While

		## for P/S reporting (precision per star)
		## adding a hook for quality, but it's not used right now.
		var STATS.previousPrecision NULL
		var STATS.previousQuality NULL

		var STATS.count.trivial 0
		var STATS.count.standard 0
		var STATS.count.formidable 0
		var STATS.count.challening 0
		var STATS.count.difficult 0
		put #echo >sigil_ps -----------------------------
	return

	Improve.Sigil.Stats.PS.Save:
		put #echo green - why is this being called still?
		var STATS.previousPrecision %precisionLevel
		var STATS.previousQuality %qualityLevel

		var STATS.previoussanityLevel %sanityLevel
		var STATS.previousresolveLevel %resolveLevel
		var STATS.previousfocusLevel %focusLevel
		var STATS.previousDangerLevel %dangerLevel
	return

	Improve.Sigil.Stats.PS.Report:

		math STATS.count.$1 add 1
		var STATS.previousDifficultyLevel $1

		## for P/S reporting (precision per star)
		var tmp_bucket sanity
		if (%STATS.previousresolveLevel > %resolveLevel) then var tmp_bucket resolve
		if (%STATS.previousfocusLevel > %focusLevel) then var tmp_bucket focus
		var tmp_val %STATS.previous%tmp_bucketLevel

		evalmath tmp.starChange %tmp_val - %%tmp_bucketLevel
		evalmath tmp.percisionChange %precisionLevel - %STATS.previousPrecision
		evalmath tmp.qualityChange %qualityLevel - %STATS.previousQuality
		evalmath tmp.dangerChange %dangerLevel - %STATS.previousDangerLevel

		if ("$1" = "na") then var tmp_bucket na

		put #echo >sigil_ps %tmp_bucket, $1, Action:$2, SChng:%tmp.starChange, PChng:%tmp.percisionChange, QChng:%tmp.qualityChange, DChng:%tmp.dangerChange, PDL:%STATS.previousDangerLevel
	return



###################################### _________________________________________________ #############
###################################### _________________________________________________ #############
###################################### _________________________________________________ #############
###################################### _________________________________________________ #############
###################################### _________________________________________________ #############
###################################### _________________________________________________ #############