*******************************************************************************************************************
*******************************************************************************************************************
EDITABLE CODE
*******************************************************************************************************************
*******************************************************************************************************************

***************************************************************************************
*********************************************
Editable Values
*********************************************
***************************************************************************************

Zoom Feature: the zooming effect is achieved through trial.increase/decrease that keep calling themselves/each other
until the mouse cursor hits the top or bottom of the screen. The amount that the picture increases/decreases depends on
a) values.Startheight_ratioA/values.Startheight_ratioB      (editable)
b) values.MinHeight_ratio 				(editable)
and
c) how much change there was in the cursor position in the current trial (if the mouse is gradually
moved, the pictures shrinks more slowly than when the mouse is moved quickly)

/Startheight_ratioA:			sets the initial size of the landscape pictures (default ratio: 0.5 of active screenheight)
/Startheight_ratioB:			sets the initial size of the portrait pictures (default ratio: 0.6 of active screenheight)
/MinHeight_ratioA:				sets the the min picture height of the landscape pictures(default: 0.05 => 5% of MaxHeight)
/MinHeight_ratioB:				sets the the min picture height of the portrait pictures(default: 0.1 => 10% of MaxHeight)
/intertrialinterval: 			sets the intertrialinterval for the AAT trials (default: 300ms)
/pixeltolerance:				sets the initial tolerance of pixelchanges after participants click
								the center cross (so that accidental movements are not 'punished')
								(default: 10)

<values>
/Startheight_ratioA = 0.5
/Startheight_ratioB = 0.5
/Startheight_ratioC = 0.5
/Startheight_ratioD = 0.5
/Startheight_ratioE = 0.5
/Startheight_ratioF = 0.5
/Startheight_ratioG = 0.5
/Startheight_ratioH = 0.5
/Startheight_ratioI = 0.5
/Startheight_ratioJ = 0.5
/MinHeight_ratioA = 0.1
/MinHeight_ratioB = 0.1
/MinHeight_ratioC = 0.1
/MinHeight_ratioD = 0.1
/MinHeight_ratioE = 0.1
/MinHeight_ratioF = 0.1
/MinHeight_ratioG = 0.1
/MinHeight_ratioH = 0.1
/MinHeight_ratioI = 0.1
/MinHeight_ratioJ = 0.1
/intertrialinterval = 300
/pixeltolerance = 5
</values>

***************************************************************************************
*********************************************
Editable Stimuli
*********************************************
***************************************************************************************
The list item.targets is organized in the following way:
main category 1 (here: unhealthy food blue) indices 1-5
main category 1 (here: unhealthy food violet) indices 6-10
main category 2 (here: healthy food blue) indices 11-15
main category 2 (here: healthy food violet) indices 16-20
main category 3 (here: IAPS Pictures blue) indices 21-30
main category 3 (here: IAPS Pictures violet) indices 31-40
Filler pictures???

<item targets>
/1 = "Pictures_new\cheeseburger_b.jpg"
/2 = "Pictures_new\pizza_b.jpg"
/3 = "Pictures_new\luxemburgerli_b.jpg"
/4 = "Pictures_new\pommes_b.jpg"
/5 = "Pictures_new\paprikachips_b.jpg"

/6 = "Pictures_new\cheeseburger_v.jpg"
/7 = "Pictures_new\pizza_v.jpg"
/8 = "Pictures_new\luxemburgerli_v.jpg"
/9 = "Pictures_new\pommes_v.jpg"
/10 = "Pictures_new\paprikachips_v.jpg"

/11 = "Pictures_new\apfel_b.jpg"
/12 = "Pictures_new\gemuesedip_b.jpg"
/13 = "Pictures_new\gruenersalat_b.jpg"
/14 = "Pictures_new\Muesli_b.jpg"
/15 = "Pictures_new\Lachs_b.jpg"

/16 = "Pictures_new\apfel_v.jpg"
/17 = "Pictures_new\gemuesedip_v.jpg"
/18 = "Pictures_new\gruenersalat_v.jpg"
/19 = "Pictures_new\Muesli_v.jpg"
/20 = "Pictures_new\Lachs_v.jpg"

/21 = "Pictures_new\1630_b.jpg"
/22 = "Pictures_new\2035_b.jpg"
/23 = "Pictures_new\2045_b.jpg"
/24 = "Pictures_new\2100_b.jpg"
/25 = "Pictures_new\5829_b.jpg"
/26 = "Pictures_new\5833_b.jpg"
/27 = "Pictures_new\6230_b.jpg"
/28 = "Pictures_new\9280_b.jpg"
/29 = "Pictures_new\9911_b.jpg"
/30 = "Pictures_new\8485_b.jpg"

/31 = "Pictures_new\1630_v.jpg"
/32 = "Pictures_new\2035_v.jpg"
/33 = "Pictures_new\2045_v.jpg"
/34 = "Pictures_new\2100_v.jpg"
/35 = "Pictures_new\5829_v.jpg"
/36 = "Pictures_new\5833_v.jpg"
/37 = "Pictures_new\6230_v.jpg"
/38 = "Pictures_new\9280_v.jpg"
/39 = "Pictures_new\9911_v.jpg"
/40 = "Pictures_new\8485_v.jpg"
</item>

NOTE:
organization of practice stimuli
practice category 1 (here: practice pictures blue) indices 1-5
practice category 1 (here: practice pictures violet) indices 6-10

<item practicestimuli>
/1 = "Pictures_new\1440_b.jpg"
/2 = "Pictures_new\1603_b.jpg"
/3 = "Pictures_new\1731_b.jpg"
/4 = "Pictures_new\7530_b.jpg"
/5 = "Pictures_new\9831_b.jpg"

/6 = "Pictures_new\1440_v.jpg"
/7 = "Pictures_new\1603_v.jpg"
/8 = "Pictures_new\1731_v.jpg"
/9 = "Pictures_new\7530_v.jpg"
/10 = "Pictures_new\9831_v.jpg"
</item>

***************************************************************************************
*********************************************
Editable Instructions
*********************************************
***************************************************************************************
<instruct >
/ windowsize = (90%, 90%)
/ fontstyle = ("Arial", 3%, false, false, false, false, 5, 0)
/inputdevice = mouse
/finishlabel = "Hier klicken um fortzufahren"
/nextlabel = "Hier klicken um fortzufahren"
/prevlabel = "Hier klicken um zurückzugehen"
</instruct>

<page intro>
In der folgenden Aufgabe siehst du Bilder, welche entweder einen blauen oder einen violetten Rahmen haben.
^*Wenn du ein Bild mit <%values.format1%> Rahmen siehst, sollst du das Bild zu dir hin bewegen (sprich mit der Maus nach unten)
^* Wenn du ein Bild mit <%values.format2%> Rahmen siehst, sollst du das Bild von dir weg bewegen (sprich mit der Maus nach oben)
^^=> Wenn du die Maus nach oben bewegst, wird das Bild kleiner werden.
^=> Wenn du nach nach unten bewegest, wird das Bild grösser werden.
^^Du musst die Maus jeweils ganz bis zum Rand bewegen.
^^Nach jedem Bild musst du die Maus in der Mitte platzieren um das neue Bild zu sehen.
^^Drücke auf den Knopf um die Übung zu starten.
</page>

<page practice>
Jetzt kommt der Übungsdurchgang. Es werden 20 Bilder präsentiert.
^^**********************************************************************************
^* Zieh die Maus zu dir hin, wenn du einen <%values.format1%>  Rahmen siehst
^* Bewege die Maus von dir weg, wenn du einen <%values.format2%> Rahmen siehst
^***********************************************************************************
^^Du solltest so schnell und genau wie möglich sein.
^^^Drücke den Knopf um den Übungsdurchgang zu starten.
</page>

<page taskinstructions>
Jetzt kommt der richtige Durchgang. Du wirst verschiedene Bilder mit blauen und violetten Rahmen sehen, wie im Übungsdurchgang.
^^**********************************************************************************
^* Zieh die Maus zu dir hin, wenn du einen <%values.format1%> Rahmen siehst
^* Bewege die Maus von dir weg, wenn du einen <%values.format2%> Rahmen siehst
^***********************************************************************************
^^Du solltest so schnell und genau wie möglich sein.
^^^Drücke den Knopf um zu starten.
</page>

<page End>
Du hast die Aufgabe vollständig absolviert.
</page>

<item trialstartinstructions>
/1 = "Klick auf das X um fortzufahren."
</item>

***************************************************************************************
*********************************************
Editable Lists
*********************************************
***************************************************************************************
AAT lists contain the indices of the target stimuli for each category
(see item.targets above)

!!! NOTE: if the number of stimuli per category changes, change the appropriate
list accordingly otherwise you can leave these lists as they are

<list category1>
/ items = (1, 2, 3, 4, 5)
/ replace = false
</list>

<list category2>
/ items = (6, 7, 8, 9, 10)
/ replace = false
</list>

<list category3>
/ items = (11, 12, 13, 14, 15)
/ replace = false
</list>

<list category4>
/ items = (16, 17, 18, 19, 20)
/ replace = false
</list>

<list category5>
/ items = (21, 22, 23, 24, 25, 26, 27, 28, 29, 30)
/ replace = false
</list>

<list category6>
/ items = (31, 32, 33, 34, 35, 36, 37, 38, 39, 40)
/ replace = false
</list>
**************************************************************************************************************
**************************************************************************************************************
DATA: this section contains data file information
**************************************************************************************************************
**************************************************************************************************************

*****************
raw data
*****************
date, time, subject:			date and time script was run with the current subjectnumber
/expcondition:					used for counterbalancing experimental conditions
									1: push for landscape, pull for portrait
									2: pull for landscape, push for portrait

blockcode, blocknum:			the name and number of the current block
trialcode, trialnum: 			the name and number of the currently recorded trial
									(Note: not all trials that are run might record data)
/stimulus:						the presented stimulus
/mouse_y:						helper variable to track the y-position of the cursor
/initialresponse:				stores the original response to the stimulus
/correct:						stores the correctness of the initial response
/finalresponse:					stores the final response (at time mouse cursor hits top or bottom of screen)
/changedirection:				stores whether and how often participant changed direction during zooming (0 = no change)
/RT:							stores the latency of the initial response
/completeRT:					stores how long it takes until the cursor hits the screen top or bottom


<data >
/file = "AATmouseinput_raw.iqdat"
/ separatefiles = true
/ columns = [date, time, subject, values.expcondition, blockcode, blocknum, trialcode, values.trialcode, values.stimulus, values.mouse_y,
			values.initialresponse, values.correct, values.finalresponse, values.changedirection,
			values.RT, values.completeRT]
</data>


*****************
summary data
*****************
uncorrecte AAT Difference Scores for each of the 4 main categories,
Diff Scores = median latency for Push trials - median latency for Pull trials
!!! NOTE: NOT corrected for accuracy, latency only for original response (not until joystick is fully extended)

/sequence:	  the experimental sequence generated for the participant

<summarydata >
/file = "ATTmouseinput_summary.iqdat"
/columns = [script.startdate, script.starttime, script.subjectid, values.expcondition,
expressions.aat_diffscore_cat1, expressions.aat_diffscore_cat2,
expressions.aat_diffscore_cat3, values.sequence]
</summarydata>

*******************************************************************************************************************
*******************************************************************************************************************
							REMAINING CODE: Customize after careful consideration only
*******************************************************************************************************************
*******************************************************************************************************************

**************************************************************************************************************
**************************************************************************************************************
DEFAULT SCREEN SETTING
**************************************************************************************************************
**************************************************************************************************************
requires Inquisit 4.0.4.0 or higher

<defaults >
/canvasaspectratio = (4,3)
/minimumversion = "4.0.4.0"
/ inputdevice = mouse
</defaults>

**************************************************************************************************************
**************************************************************************************************************
VALUES
**************************************************************************************************************
**************************************************************************************************************

*****************************
automatically updated at runtime
****************************

                                     AAT code:
/totaltrialcount:							the number of experimental trials (here 80)
/nextstimulus :								the number of the next targetstimulus to be presented
/selectstimulus:							the index of targetstimulus (in item )
/targetcategory:							the targetcategory of the targetstimulus, 1 - 4
/targetformat :								the targetformat of the targetstimulus (l = landscape; p = portrait)
/sumRTcorrect_1- sumRTcorrect_8 :			the sum of latencies for stimuli of (e.g.) category 1 - only for correct responses
/sumRT_1 - sumRT_8:							the sum of latencies for stimuli of (e.g.) category 1 - regardless of accuracy
/repeat:									helper variable: counts how often a change trial has run itself
/selectpracticepicture:						helper variable: dictates which rectangle (landscape/portrait) to select for practice
/starttime:									determines the starttime of a trial (measured at beginning of a picture trial)
/endtime:									determines the endtime of a zooming (measured at end of zoom trials)
/expcondition:								used for counterbalancing experimental conditions
/format1/forma2:							helper variables for instruction purposes; set in expt
/startheight_A/startheight_B:				sets the default height of the A(landscape)/B (portrait) picture
/maxheight:									maximum height for pictures (used canvasheight: display.canvasheight)
/mouse_y:									helper variable to track the y-position of the cursor
/completeRT:								stores how long it takes until the cursor hits the screen top or bottom
/changedirection:							stores whether and how often participant changed direction during zooming
											(0 = no change)
/mouse_change:							    stores the absolute change in cursor y-positions from one zoom trial to the next
/trialcode:									stores the trialcode of the trial
/RT:										stores the latency of the initial response
/correct:									stores the correctness of the initial response
/stimulus:									stores the stimulus
/initialresponse:							stores the initial response
/finalresponse:								stores the final response (at time mouse cursor hits top or bottom of screen)
/response:									1 = push (cursor UP), 0 = pull (cursor DOWN)


<values >
/totaltrialcount = 80
/nextstimulus = 0
/selectstimulus = 0
/targetcategory = 0
/targetformat = ""
/sumRTcorrect_1 = 0
/sumRT_1 = 0
/sumRTcorrect_2 = 0
/sumRT_2 = 0
/sumRTcorrect_3 = 0
/sumRT_3 = 0
/sumRTcorrect_4 = 0
/sumRT_4 = 0
/sumRTcorrect_5 = 0
/sumRT_5 = 0
/sumRTcorrect_6 = 0
/sumRT_6 = 0
/repeat = 0
/selectpracticepicture = 0
/starttime = 0
/endtime = 0
/expcondition = 0
/format1 = 0
/format2 = 0
/startheight_A = 0
/startheight_B = 0
/startheight_C = 0
/startheight_D = 0
/startheight_E = 0
/startheight_F = 0
/startheight_G = 0
/startheight_H = 0
/startheight_I = 0
/startheight_J = 0
/Maxheight = display.canvasheight
/mouse_y = 0
/completeRT = 0
/changedirection = 0
/mouse_change = 0
/trialcode = 0
/RT = 0
/correct = 0
/stimulus = 0
/initialresponse = ""
/finalresponse = ""
/response = 0
</values>
**************************************************************************************************************
**************************************************************************************************************
EXPRESSIONS
**************************************************************************************************************
**************************************************************************************************************
uncorrecte AAT Difference Scores for each of the 4 main categories,
Diff Scores = median latency for Push trials - median latency for Pull trials
!!! NOTE: NOT corrected for accuracy, latency only for original response (not until cursor hits top or bottom of screen)

/maxheightchange_px: max pixel height change of picture

<expressions >
/ AAT_Diffscore_Cat1 = if (values.expcondition == 1) trial.AAT_1.medianlatency - trial.AAT_2.medianlatency else
									trial.AAT_2.medianlatency - trial.AAT_1.medianlatency
/ AAT_Diffscore_Cat2 = if (values.expcondition == 1) trial.AAT_3.medianlatency - trial.AAT_4.medianlatency else
									trial.AAT_4.medianlatency - trial.AAT_3.medianlatency
/ AAT_Diffscore_Cat3 = if (values.expcondition == 1) trial.AAT_5.medianlatency - trial.AAT_6.medianlatency else
									trial.AAT_6.medianlatency - trial.AAT_5.medianlatency
/maxheightchange_px = if (values.targetformat == "blue") {(values.Startheight_ratioA - values.MinHeight_ratioA) * values.Maxheight}
										else {(values.Startheight_ratioB - values.MinHeight_ratioB) * values.Maxheight}
</expressions>




**************************************************************************************************************
**************************************************************************************************************
 AAT STIMULI
**************************************************************************************************************
**************************************************************************************************************
<picture targetstimulus>
/ items = targets
/ select = values.selectstimulus
/ position = (50%, 50%)
/ size = (100%, 100%)
/ erase = false
</picture>

***helper stimulus
<shape eraser>
/ shape = rectangle
/ color = white
/ size = (100%, 100%)
/ erase = false
</shape>

<text instructtext>
/items = trialstartinstructions
/select = 1
/position = (50%, 40%)
/ fontstyle = ("Arial", 3%, false, false, false, false, 5, 1)
</text>

<text center>
/items = ("x")
/position = (50%, 50%)
/ fontstyle = ("Arial", 5%, true, false, false, false, 5, 1)
/ txcolor = (red)
</text>

<text fixation>
/ items = ("+")
/ fontstyle = ("Verdana", 8.00%, true)
/ position = (50%,50%)
/ erase = false
</text>

<shape blank>
/ shape = rectangle
/ color = (white)
/ position = (50%,50%)
/ size = (100%,100%)
/ erase = false
</shape>
**************************************************************************************************************
**************************************************************************************************************
AAT LISTS
**************************************************************************************************************
**************************************************************************************************************

**************************************************************************************************************
**************************************************************************************************************
AAT PRACTICE
**************************************************************************************************************
**************************************************************************************************************

*************************
Practice Stimuli
*************************
<text error>
/ items = ("Falsch")
/ position = (50%, 50%)
/ fontstyle = ("Arial", 5%, true, false, false, false, 5, 0)
/ txcolor = (white)
/txbgcolor = (red)
</text>

<text x>
/ items = ("Falsch")
/ position = (50, 60)
/ fontstyle = ("Arial", 7%, true, false, false, false, 5, 0)
/color = red
</text>

*************************
Practice Stimuli
*************************

NOTE:
 picture.practicetarget selects the target via
values.selectpracticepicture (this value is set in the
practice trials, see below)

<picture practicetarget>
/ items = practicestimuli
/ select = values.selectpracticepicture
/ position = (50%, 50%)
/ size = (100%, 100%)
/ erase = false
</picture>
*************************
Practice Trials
*************************
NOTE: practice trials report error feedback to participant.

Note: trial.practicestarta/trial.practicestartb
* makes sure the mouse cursor is in the middle of the screen by asking participants
to click on a center stimulus (here:X)
<trial practicestartA>
/inputdevice = mouse
/stimulusframes = [1 = instructtext, center]
/validresponse = (center)
/ontrialend = [values.mouse_y = trial.practicestartA.responsey]
/recorddata = false
/branch = [trial.practicetrial_a]
</trial>

<trial practicestartB>
/inputdevice = mouse
/stimulusframes = [1 = instructtext, center]
/validresponse = (center)
/ontrialend = [values.mouse_y = trial.practicestartB.responsey]
/recorddata = false
/branch = [trial.practicetrial_b]
</trial>

<trial practicestartC>
/inputdevice = mouse
/stimulusframes = [1 = instructtext, center]
/validresponse = (center)
/ontrialend = [values.mouse_y = trial.practicestartC.responsey]
/recorddata = false
/branch = [trial.practicetrial_c]
</trial>

<trial practicestartD>
/inputdevice = mouse
/stimulusframes = [1 = instructtext, center]
/validresponse = (center)
/ontrialend = [values.mouse_y = trial.practicestartD.responsey]
/recorddata = false
/branch = [trial.practicetrial_d]
</trial>

<trial practicestartE>
/inputdevice = mouse
/stimulusframes = [1 = instructtext, center]
/validresponse = (center)
/ontrialend = [values.mouse_y = trial.practicestartE.responsey]
/recorddata = false
/branch = [trial.practicetrial_e]
</trial>

<trial practicestartF>
/inputdevice = mouse
/stimulusframes = [1 = instructtext, center]
/validresponse = (center)
/ontrialend = [values.mouse_y = trial.practicestartF.responsey]
/recorddata = false
/branch = [trial.practicetrial_f]
</trial>

<trial practicestartG>
/inputdevice = mouse
/stimulusframes = [1 = instructtext, center]
/validresponse = (center)
/ontrialend = [values.mouse_y = trial.practicestartG.responsey]
/recorddata = false
/branch = [trial.practicetrial_g]
</trial>

<trial practicestartH>
/inputdevice = mouse
/stimulusframes = [1 = instructtext, center]
/validresponse = (center)
/ontrialend = [values.mouse_y = trial.practicestartH.responsey]
/recorddata = false
/branch = [trial.practicetrial_h]
</trial>

<trial practicestartI>
/inputdevice = mouse
/stimulusframes = [1 = instructtext, center]
/validresponse = (center)
/ontrialend = [values.mouse_y = trial.practicestartI.responsey]
/recorddata = false
/branch = [trial.practicetrial_i]
</trial>

<trial practicestartJ>
/inputdevice = mouse
/stimulusframes = [1 = instructtext, center]
/validresponse = (center)
/ontrialend = [values.mouse_y = trial.practicestartJ.responsey]
/recorddata = false
/branch = [trial.practicetrial_j]
</trial>


NOTE:
*trial.practicetrial_A displays the stimulus of format A (here: landscape) by setting
values.selectpracticepicture = 1
*if a push movement is detected (=mouse is pushed away from body)-> decrease picture
*if a pull movement is detected (=mouse is pulled towards body)-> increase picture
<trial practicetrial_A>
/inputdevice = mouse
/ontrialbegin = [values.trialcode = "practicetrial_A"]
/ontrialbegin = [values.targetformat = "blue"]
/ ontrialbegin = [values.selectpracticepicture = 1]
/ ontrialbegin = [values.starttime = script.elapsedtime; values.endtime = 0]
/ ontrialbegin = [picture.practicetarget.height = values.startheight_A]
/ ontrialbegin = [values.completeRT = 0; values.changedirection = 0; values.finalresponse=""]

/ stimulusframes = [1 = practicetarget]
/ validresponse = (mousemove)
/isvalidresponse = [(trial.practicetrial_a.responsey > (values.mouse_y + values.pixeltolerance)) ||
					(trial.practicetrial_a.responsey < (values.mouse_y - values.pixeltolerance)) ]

/ iscorrectresponse = [(values.expcondition == 1 && trial.practicetrial_a.responsey < values.mouse_y) ||
						(values.expcondition == 2 && trial.practicetrial_a.responsey > values.mouse_y)]
/ errormessage = true(x,0)

/ontrialend = [if (trial.practicetrial_a.responsey < values.mouse_y) values.response = 1 else values.response = 2]
/ ontrialend = [values.mouse_change = abs(values.mouse_y - trial.practicetrial_a.responsey)]
/ ontrialend = [values.mouse_y = trial.practicetrial_a.responsey]

/ontrialend = [values.RT = trial.practicetrial_A.latency]
/ontrialend = [values.correct = trial.practicetrial_A.correct]
/ontrialend = [values.stimulus = picture.practicetarget.currentitem]
/ontrialend = [if (values.response == 1) values.initialresponse = "PUSH"
						else values.initialresponse = "PULL"]

/ branch = [if (values.response == 1) trial.practicedecrease else trial.practiceincrease]
/ recorddata = false
</trial>

<trial practicetrial_B>
/inputdevice = mouse
/ontrialbegin = [values.trialcode = "practicetrial_B"]
/ontrialbegin = [values.targetformat = "blue"]
/ ontrialbegin = [values.selectpracticepicture = 2]
/ ontrialbegin = [values.starttime = script.elapsedtime; values.endtime = 0]
/ ontrialbegin = [picture.practicetarget.height = values.startheight_B]
/ ontrialbegin = [values.completeRT = 0; values.changedirection = 0; values.finalresponse=""]

/ stimulusframes = [1 = practicetarget]
/ validresponse = (mousemove)
/isvalidresponse = [(trial.practicetrial_B.responsey > (values.mouse_y + values.pixeltolerance)) ||
					(trial.practicetrial_B.responsey < (values.mouse_y - values.pixeltolerance)) ]

/ iscorrectresponse = [(values.expcondition == 1 && trial.practicetrial_B.responsey < values.mouse_y) ||
						(values.expcondition == 2 && trial.practicetrial_B.responsey > values.mouse_y)]
/ errormessage = true(x,0)

/ontrialend = [if (trial.practicetrial_B.responsey < values.mouse_y) values.response = 1 else values.response = 2]
/ ontrialend = [values.mouse_change = abs(values.mouse_y - trial.practicetrial_B.responsey)]
/ ontrialend = [values.mouse_y = trial.practicetrial_B.responsey]

/ontrialend = [values.RT = trial.practicetrial_B.latency]
/ontrialend = [values.correct = trial.practicetrial_B.correct]
/ontrialend = [values.stimulus = picture.practicetarget.currentitem]
/ontrialend = [if (values.response == 1) values.initialresponse = "PUSH"
						else values.initialresponse = "PULL"]

/ branch = [if (values.response == 1) trial.practicedecrease else trial.practiceincrease]
/ recorddata = false
</trial>

<trial practicetrial_C>
/inputdevice = mouse
/ontrialbegin = [values.trialcode = "practicetrial_C"]
/ontrialbegin = [values.targetformat = "blue"]
/ ontrialbegin = [values.selectpracticepicture = 3]
/ ontrialbegin = [values.starttime = script.elapsedtime; values.endtime = 0]
/ ontrialbegin = [picture.practicetarget.height = values.startheight_C]
/ ontrialbegin = [values.completeRT = 0; values.changedirection = 0; values.finalresponse=""]

/ stimulusframes = [1 = practicetarget]
/ validresponse = (mousemove)
/isvalidresponse = [(trial.practicetrial_C.responsey > (values.mouse_y + values.pixeltolerance)) ||
					(trial.practicetrial_C.responsey < (values.mouse_y - values.pixeltolerance)) ]

/ iscorrectresponse = [(values.expcondition == 1 && trial.practicetrial_C.responsey < values.mouse_y) ||
						(values.expcondition == 2 && trial.practicetrial_C.responsey > values.mouse_y)]
/ errormessage = true(x,0)

/ontrialend = [if (trial.practicetrial_C.responsey < values.mouse_y) values.response = 1 else values.response = 2]
/ ontrialend = [values.mouse_change = abs(values.mouse_y - trial.practicetrial_C.responsey)]
/ ontrialend = [values.mouse_y = trial.practicetrial_C.responsey]

/ontrialend = [values.RT = trial.practicetrial_C.latency]
/ontrialend = [values.correct = trial.practicetrial_C.correct]
/ontrialend = [values.stimulus = picture.practicetarget.currentitem]
/ontrialend = [if (values.response == 1) values.initialresponse = "PUSH"
						else values.initialresponse = "PULL"]

/ branch = [if (values.response == 1) trial.practicedecrease else trial.practiceincrease]
/ recorddata = false
</trial>

<trial practicetrial_D>
/inputdevice = mouse
/ontrialbegin = [values.trialcode = "practicetrial_D"]
/ontrialbegin = [values.targetformat = "blue"]
/ ontrialbegin = [values.selectpracticepicture = 4]
/ ontrialbegin = [values.starttime = script.elapsedtime; values.endtime = 0]
/ ontrialbegin = [picture.practicetarget.height = values.startheight_D]
/ ontrialbegin = [values.completeRT = 0; values.changedirection = 0; values.finalresponse=""]

/ stimulusframes = [1 = practicetarget]
/ validresponse = (mousemove)
/isvalidresponse = [(trial.practicetrial_D.responsey > (values.mouse_y + values.pixeltolerance)) ||
					(trial.practicetrial_D.responsey < (values.mouse_y - values.pixeltolerance)) ]

/ iscorrectresponse = [(values.expcondition == 1 && trial.practicetrial_D.responsey < values.mouse_y) ||
						(values.expcondition == 2 && trial.practicetrial_D.responsey > values.mouse_y)]
/ errormessage = true(x,0)

/ontrialend = [if (trial.practicetrial_D.responsey < values.mouse_y) values.response = 1 else values.response = 2]
/ ontrialend = [values.mouse_change = abs(values.mouse_y - trial.practicetrial_D.responsey)]
/ ontrialend = [values.mouse_y = trial.practicetrial_D.responsey]

/ontrialend = [values.RT = trial.practicetrial_D.latency]
/ontrialend = [values.correct = trial.practicetrial_D.correct]
/ontrialend = [values.stimulus = picture.practicetarget.currentitem]
/ontrialend = [if (values.response == 1) values.initialresponse = "PUSH"
						else values.initialresponse = "PULL"]

/ branch = [if (values.response == 1) trial.practicedecrease else trial.practiceincrease]
/ recorddata = false
</trial>

<trial practicetrial_E>
/inputdevice = mouse
/ontrialbegin = [values.trialcode = "practicetrial_E"]
/ontrialbegin = [values.targetformat = "blue"]
/ ontrialbegin = [values.selectpracticepicture = 5]
/ ontrialbegin = [values.starttime = script.elapsedtime; values.endtime = 0]
/ ontrialbegin = [picture.practicetarget.height = values.startheight_E]
/ ontrialbegin = [values.completeRT = 0; values.changedirection = 0; values.finalresponse=""]

/ stimulusframes = [1 = practicetarget]
/ validresponse = (mousemove)
/isvalidresponse = [(trial.practicetrial_E.responsey > (values.mouse_y + values.pixeltolerance)) ||
					(trial.practicetrial_E.responsey < (values.mouse_y - values.pixeltolerance)) ]

/ iscorrectresponse = [(values.expcondition == 1 && trial.practicetrial_E.responsey < values.mouse_y) ||
						(values.expcondition == 2 && trial.practicetrial_E.responsey > values.mouse_y)]
/ errormessage = true(x,0)

/ontrialend = [if (trial.practicetrial_E.responsey < values.mouse_y) values.response = 1 else values.response = 2]
/ ontrialend = [values.mouse_change = abs(values.mouse_y - trial.practicetrial_E.responsey)]
/ ontrialend = [values.mouse_y = trial.practicetrial_E.responsey]

/ontrialend = [values.RT = trial.practicetrial_E.latency]
/ontrialend = [values.correct = trial.practicetrial_E.correct]
/ontrialend = [values.stimulus = picture.practicetarget.currentitem]
/ontrialend = [if (values.response == 1) values.initialresponse = "PUSH"
						else values.initialresponse = "PULL"]

/ branch = [if (values.response == 1) trial.practicedecrease else trial.practiceincrease]
/ recorddata = false
</trial>

<trial practicetrial_F>
/inputdevice = mouse
/ontrialbegin = [values.trialcode = "practicetrial_F"]
/ontrialbegin = [values.targetformat = "violet"]
/ ontrialbegin = [values.selectpracticepicture = 6]
/ ontrialbegin = [values.starttime = script.elapsedtime; values.endtime = 0]
/ ontrialbegin = [picture.practicetarget.height = values.startheight_F]
/ ontrialbegin = [values.completeRT = 0; values.changedirection = 0; values.finalresponse=""]

/ stimulusframes = [1 = practicetarget]
/ validresponse = (mousemove)
/isvalidresponse = [(trial.practicetrial_F.responsey > (values.mouse_y + values.pixeltolerance)) ||
					(trial.practicetrial_F.responsey < (values.mouse_y - values.pixeltolerance)) ]

/ iscorrectresponse = [(values.expcondition == 1 && trial.practicetrial_F.responsey > values.mouse_y) ||
						(values.expcondition == 2 && trial.practicetrial_F.responsey < values.mouse_y)]
/ errormessage = true(x,0)

/ontrialend = [if (trial.practicetrial_F.responsey < values.mouse_y) values.response = 1 else values.response = 2]
/ ontrialend = [values.mouse_change = abs(values.mouse_y - trial.practicetrial_F.responsey)]
/ ontrialend = [values.mouse_y = trial.practicetrial_F.responsey]

/ontrialend = [values.RT = trial.practicetrial_F.latency]
/ontrialend = [values.correct = trial.practicetrial_F.correct]
/ontrialend = [values.stimulus = picture.practicetarget.currentitem]
/ontrialend = [if (values.response == 1) values.initialresponse = "PUSH"
						else values.initialresponse = "PULL"]

/ branch = [if (values.response == 1) trial.practicedecrease else trial.practiceincrease]
/ recorddata = false
</trial>

<trial practicetrial_G>
/inputdevice = mouse
/ontrialbegin = [values.trialcode = "practicetrial_G"]
/ontrialbegin = [values.targetformat = "violet"]
/ ontrialbegin = [values.selectpracticepicture = 7]
/ ontrialbegin = [values.starttime = script.elapsedtime; values.endtime = 0]
/ ontrialbegin = [picture.practicetarget.height = values.startheight_G]
/ ontrialbegin = [values.completeRT = 0; values.changedirection = 0; values.finalresponse=""]

/ stimulusframes = [1 = practicetarget]
/ validresponse = (mousemove)
/isvalidresponse = [(trial.practicetrial_G.responsey > (values.mouse_y + values.pixeltolerance)) ||
					(trial.practicetrial_G.responsey < (values.mouse_y - values.pixeltolerance)) ]

/ iscorrectresponse = [(values.expcondition == 1 && trial.practicetrial_G.responsey > values.mouse_y) ||
						(values.expcondition == 2 && trial.practicetrial_G.responsey < values.mouse_y)]
/ errormessage = true(x,0)

/ontrialend = [if (trial.practicetrial_G.responsey < values.mouse_y) values.response = 1 else values.response = 2]
/ ontrialend = [values.mouse_change = abs(values.mouse_y - trial.practicetrial_G.responsey)]
/ ontrialend = [values.mouse_y = trial.practicetrial_G.responsey]

/ontrialend = [values.RT = trial.practicetrial_G.latency]
/ontrialend = [values.correct = trial.practicetrial_G.correct]
/ontrialend = [values.stimulus = picture.practicetarget.currentitem]
/ontrialend = [if (values.response == 1) values.initialresponse = "PUSH"
						else values.initialresponse = "PULL"]

/ branch = [if (values.response == 1) trial.practicedecrease else trial.practiceincrease]
/ recorddata = false
</trial>

<trial practicetrial_H>
/inputdevice = mouse
/ontrialbegin = [values.trialcode = "practicetrial_H"]
/ontrialbegin = [values.targetformat = "violet"]
/ ontrialbegin = [values.selectpracticepicture = 8]
/ ontrialbegin = [values.starttime = script.elapsedtime; values.endtime = 0]
/ ontrialbegin = [picture.practicetarget.height = values.startheight_H]
/ ontrialbegin = [values.completeRT = 0; values.changedirection = 0; values.finalresponse=""]

/ stimulusframes = [1 = practicetarget]
/ validresponse = (mousemove)
/isvalidresponse = [(trial.practicetrial_H.responsey > (values.mouse_y + values.pixeltolerance)) ||
					(trial.practicetrial_H.responsey < (values.mouse_y - values.pixeltolerance)) ]

/ iscorrectresponse = [(values.expcondition == 1 && trial.practicetrial_H.responsey > values.mouse_y) ||
						(values.expcondition == 2 && trial.practicetrial_H.responsey < values.mouse_y)]
/ errormessage = true(x,0)

/ontrialend = [if (trial.practicetrial_H.responsey < values.mouse_y) values.response = 1 else values.response = 2]
/ ontrialend = [values.mouse_change = abs(values.mouse_y - trial.practicetrial_H.responsey)]
/ ontrialend = [values.mouse_y = trial.practicetrial_H.responsey]

/ontrialend = [values.RT = trial.practicetrial_H.latency]
/ontrialend = [values.correct = trial.practicetrial_H.correct]
/ontrialend = [values.stimulus = picture.practicetarget.currentitem]
/ontrialend = [if (values.response == 1) values.initialresponse = "PUSH"
						else values.initialresponse = "PULL"]

/ branch = [if (values.response == 1) trial.practicedecrease else trial.practiceincrease]
/ recorddata = false
</trial>

<trial practicetrial_I>
/inputdevice = mouse
/ontrialbegin = [values.trialcode = "practicetrial_I"]
/ontrialbegin = [values.targetformat = "violet"]
/ ontrialbegin = [values.selectpracticepicture = 9]
/ ontrialbegin = [values.starttime = script.elapsedtime; values.endtime = 0]
/ ontrialbegin = [picture.practicetarget.height = values.startheight_I]
/ ontrialbegin = [values.completeRT = 0; values.changedirection = 0; values.finalresponse=""]

/ stimulusframes = [1 = practicetarget]
/ validresponse = (mousemove)
/isvalidresponse = [(trial.practicetrial_I.responsey > (values.mouse_y + values.pixeltolerance)) ||
					(trial.practicetrial_I.responsey < (values.mouse_y - values.pixeltolerance)) ]

/ iscorrectresponse = [(values.expcondition == 1 && trial.practicetrial_I.responsey > values.mouse_y) ||
						(values.expcondition == 2 && trial.practicetrial_I.responsey < values.mouse_y)]
/ errormessage = true(x,0)

/ontrialend = [if (trial.practicetrial_I.responsey < values.mouse_y) values.response = 1 else values.response = 2]
/ ontrialend = [values.mouse_change = abs(values.mouse_y - trial.practicetrial_I.responsey)]
/ ontrialend = [values.mouse_y = trial.practicetrial_I.responsey]

/ontrialend = [values.RT = trial.practicetrial_I.latency]
/ontrialend = [values.correct = trial.practicetrial_I.correct]
/ontrialend = [values.stimulus = picture.practicetarget.currentitem]
/ontrialend = [if (values.response == 1) values.initialresponse = "PUSH"
						else values.initialresponse = "PULL"]

/ branch = [if (values.response == 1) trial.practicedecrease else trial.practiceincrease]
/ recorddata = false
</trial>

<trial practicetrial_J>
/inputdevice = mouse
/ontrialbegin = [values.trialcode = "practicetrial_J"]
/ontrialbegin = [values.targetformat = "violet"]
/ ontrialbegin = [values.selectpracticepicture = 10]
/ ontrialbegin = [values.starttime = script.elapsedtime; values.endtime = 0]
/ ontrialbegin = [picture.practicetarget.height = values.startheight_J]
/ ontrialbegin = [values.completeRT = 0; values.changedirection = 0; values.finalresponse=""]

/ stimulusframes = [1 = practicetarget]
/ validresponse = (mousemove)
/isvalidresponse = [(trial.practicetrial_J.responsey > (values.mouse_y + values.pixeltolerance)) ||
					(trial.practicetrial_J.responsey < (values.mouse_y - values.pixeltolerance)) ]

/ iscorrectresponse = [(values.expcondition == 1 && trial.practicetrial_J.responsey > values.mouse_y) ||
						(values.expcondition == 2 && trial.practicetrial_J.responsey < values.mouse_y)]
/ errormessage = true(x,0)

/ontrialend = [if (trial.practicetrial_J.responsey < values.mouse_y) values.response = 1 else values.response = 2]
/ ontrialend = [values.mouse_change = abs(values.mouse_y - trial.practicetrial_J.responsey)]
/ ontrialend = [values.mouse_y = trial.practicetrial_J.responsey]

/ontrialend = [values.RT = trial.practicetrial_J.latency]
/ontrialend = [values.correct = trial.practicetrial_J.correct]
/ontrialend = [values.stimulus = picture.practicetarget.currentitem]
/ontrialend = [if (values.response == 1) values.initialresponse = "PUSH"
						else values.initialresponse = "PULL"]

/ branch = [if (values.response == 1) trial.practicedecrease else trial.practiceincrease]
/ recorddata = false
</trial>

*********ZOOM FEATURE: trial  increase/decrease the size of the rectangles depending on participant's response*********

<trial practicedecrease>
/inputdevice = mouse
/ontrialbegin = [if (values.expcondition == 1 && values.targetformat == "violet") trial.practicedecrease.insertstimulustime(text.x, 0)]
/ontrialbegin = [if (values.expcondition == 2 && values.targetformat == "blue") trial.practicedecrease.insertstimulustime(text.x, 0)]

/ ontrialbegin = [picture.practicetarget.height = picture.practicetarget.height - values.mouse_change/(values.maxheight/2) * expressions.maxheightchange_px]
/ stimulusframes = [1 = eraser, practicetarget]
/validresponse = (mousemove)

/ontrialend = [values.mouse_change = abs(values.mouse_y - trial.practicedecrease.responsey)]

/ontrialend = [trial.practicedecrease.resetstimulusframes()]


/branch = [if (script.subjectid == "monkey") {values.endtime = script.elapsedtime; values.finalresponse = "PUSH"; trial.intertrialinterval}]

/branch = [if (trial.practicedecrease.responsey <= 0)
				{values.mouse_y = trial.practicedecrease.responsey; values.endtime = script.elapsedtime; values.finalresponse = "PUSH"; trial.enddecrease_practice}]
/branch = [if (trial.practicedecrease.responsey <= values.mouse_y)
				{values.mouse_y = trial.practicedecrease.responsey; trial.practicedecrease}]
/branch = [if (trial.practicedecrease.responsey > values.mouse_y)
				{values.mouse_y = trial.practicedecrease.responsey; values.changedirection += 1; trial.practiceincrease}]

/ recorddata = false
</trial>

<trial practiceincrease>
/inputdevice = mouse
/ontrialbegin = [if (values.expcondition == 1 && values.targetformat == "blue") trial.practiceincrease.insertstimulustime(text.x, 0)]
/ontrialbegin = [if (values.expcondition == 2 && values.targetformat == "violet") trial.practiceincrease.insertstimulustime(text.x, 0)]

/ ontrialbegin = [picture.practicetarget.height = picture.practicetarget.height + values.mouse_change/(values.maxheight/2) * expressions.maxheightchange_px]
/ stimulusframes = [1 =  practicetarget]
/validresponse = (mousemove)
/ontrialend = [values.mouse_change = abs(values.mouse_y - trial.practiceincrease.responsey)]

/ontrialend = [trial.practiceincrease.resetstimulusframes()]

/branch = [if (script.subjectid == "monkey") {values.endtime = script.elapsedtime; values.finalresponse = "PULL"; trial.intertrialinterval}]
/branch = [if (trial.practiceincrease.responsey >= values.maxheight-1)
				{values.mouse_y = trial.practiceincrease.responsey; values.endtime = script.elapsedtime; values.finalresponse = "PULL"; trial.endincrease_practice}]
/branch = [if (trial.practiceincrease.responsey >= values.mouse_y)
				{values.mouse_y = trial.practiceincrease.responsey; trial.practiceincrease}]
/branch = [if (trial.practiceincrease.responsey < values.mouse_y)
				{values.mouse_y = trial.practiceincrease.responsey; values.changedirection += 1; trial.practicedecrease}]
/recorddata = false
</trial>


Note: trials show the last size of the picture
<trial endincrease_practice>
/ ontrialbegin = [picture.practicetarget.height = picture.practicetarget.height + values.mouse_change/(values.maxheight/2) * expressions.maxheightchange_px]
/stimulusframes = [1 = practicetarget]
/timeout = 0
/branch = [trial.intertrialinterval]
/recorddata = false
</trial>

<trial enddecrease_practice>
/ontrialbegin = [picture.practicetarget.height = picture.practicetarget.height - values.mouse_change/(values.maxheight/2) * expressions.maxheightchange_px]
/stimulusframes = [1 = eraser, practicetarget]
/timeout = 0
/branch = [trial.intertrialinterval]
/recorddata = false
</trial>
*************************
Practice Block
*************************
NOTE:
block.practice_AAT presents 10 practice trials randomly (without replacement) selecting
from format A (landscape) (N=5) and format B (portrait) stimuli (N=5)
<block practice_AAT>
/preinstructions = (intro, practice)
/ trials = [1-20 = noreplace(practicestartA, practicestartB, practicestartC, practicestartD, practicestartE, practicestartF, practicestartG, practicestartH, practicestartI, practicestartJ)]
</block>

**************************************************************************************************************
**************************************************************************************************************
AAT EXPERIMENTAL TRIALS
**************************************************************************************************************
**************************************************************************************************************
Trial Sequence for each targetstimulus:
trial.AAT_start -> (e.g.) trial.AAT_1 -> (e.g. depending on response) trial.decrease ->....-> trial.decrease (until a set amount of trial.decrease have run)

**********************************************************************
trial that selects the next targetstimulus category (1-8)
**********************************************************************
Debug:
<text nextstimulus>
/ items = ("<%values.nextstimulus%>")
/ position = (50%, 60%)
/ fontstyle = ("Arial", 2.33%, false, false, false, false, 5, 0)
</text>


NOTE:
trial.AAT_start is only necessary if a preestablished sequence of target categories is used
(either generated at the beginning of the experiment or by selecting from a
pool of pregenerated sequences). The trial determines the next target
category via values.nextstimulus and calls the corresponding trial for that category (e.g. trial.AAT_1).

<trial AAT_start>
/ ontrialbegin = [values.nextstimulus = substring(values.sequence, values.index, 1);
						values.index += 1]
/ ontrialbegin = [values.repeat = 0]
/ timeout = 0
/ branch = [if (values.nextstimulus == 1) trial.AAT_1_start]
/ branch = [if (values.nextstimulus == 2) trial.AAT_2_start]
/ branch = [if (values.nextstimulus == 3) trial.AAT_3_start]
/ branch = [if (values.nextstimulus == 4) trial.AAT_4_start]
/ branch = [if (values.nextstimulus == 5) trial.AAT_5_start]
/ branch = [if (values.nextstimulus == 6) trial.AAT_6_start]
/ recorddata = false
</trial>

************************************************
Start trials:

* make sure the mouse cursor is in the middle of the screen by asking participants
to click on a center stimulus (here:X)
************************************************
<trial AAT_1_start>
/inputdevice = mouse
/stimulusframes = [1 = instructtext, center]
/validresponse = (center)
/ontrialend = [values.mouse_y = trial.AAT_1_start.responsey]
/recorddata = false
/branch = [trial.AAT_1]
</trial>

<trial AAT_2_start>
/inputdevice = mouse
/stimulusframes = [1 = instructtext, center]
/validresponse = (center)
/ontrialend = [values.mouse_y = trial.AAT_2_start.responsey]
/recorddata = false
/branch = [trial.AAT_2]
</trial>

<trial AAT_3_start>
/inputdevice = mouse
/stimulusframes = [1 = instructtext, center]
/validresponse = (center)
/ontrialend = [values.mouse_y = trial.AAT_3_start.responsey]
/recorddata = false
/branch = [trial.AAT_3]
</trial>

<trial AAT_4_start>
/inputdevice = mouse
/stimulusframes = [1 = instructtext, center]
/validresponse = (center)
/ontrialend = [values.mouse_y = trial.AAT_4_start.responsey]
/recorddata = false
/branch = [trial.AAT_4]
</trial>

<trial AAT_5_start>
/inputdevice = mouse
/stimulusframes = [1 = instructtext, center]
/validresponse = (center)
/ontrialend = [values.mouse_y = trial.AAT_5_start.responsey]
/recorddata = false
/branch = [trial.AAT_5]
</trial>

<trial AAT_6_start>
/inputdevice = mouse
/stimulusframes = [1 = instructtext, center]
/validresponse = (center)
/ontrialend = [values.mouse_y = trial.AAT_6_start.responsey]
/recorddata = false
/branch = [trial.AAT_6]
</trial>

**********************************************************************
trials that select targetstimuli via list.categoryX
and take in initial response (move mouse away vs. mouse mouse closer)

Note: if error feedback should be given, include
/ errormessage = true(error,0) in each of the following trials
**********************************************************************

<trial AAT_1>
/inputdevice = mouse
/ ontrialbegin = [values.trialcode = "AAT_1"]
/ ontrialbegin = [values.selectstimulus = list.category1.nextvalue]
/ ontrialbegin = [values.targetcategory = 1; values.targetformat = "blue"]
/ ontrialbegin = [picture.targetstimulus.height = values.startheight_A]

/ ontrialbegin = [values.starttime = script.elapsedtime; values.endtime = 0]
/ ontrialbegin = [values.completeRT = 0; values.changedirection = 0; values.finalresponse=""]

/ stimulusframes = [1 = targetstimulus]
/ validresponse = (mousemove)
/isvalidresponse = [(trial.AAT_1.responsey > (values.mouse_y + values.pixeltolerance)) ||
					(trial.AAT_1.responsey < (values.mouse_y - values.pixeltolerance)) ]
/ iscorrectresponse = [(values.expcondition == 1 && trial.AAT_1.responsey < values.mouse_y) ||
						(values.expcondition == 2 && trial.AAT_1.responsey > values.mouse_y)]

/ ontrialend = [if (trial.AAT_1.correct) values.sumRTcorrect_1 += trial.AAT_1.latency]
/ ontrialend = [values.sumRT_1 += trial.AAT_1.latency]

/ontrialend = [if (trial.AAT_1.responsey < values.mouse_y) values.response = 1 else values.response = 2]
/ ontrialend = [values.mouse_change = abs(values.mouse_y - trial.AAT_1.responsey)]
/ ontrialend = [values.mouse_y = trial.AAT_1.responsey]

/ ontrialend = [values.RT = trial.AAT_1.latency]
/ ontrialend = [values.correct = trial.AAT_1.correct]
/ ontrialend = [values.stimulus = picture.targetstimulus.currentitem]

/ontrialend = [if (values.response == 1) values.initialresponse = "PUSH"
						else values.initialresponse = "PULL"]
/ branch = [if (values.response == 1) trial.decrease else trial.increase]
/recorddata = false
</trial>


<trial AAT_2>
/inputdevice = mouse
/ ontrialbegin = [values.selectstimulus = list.category2.nextvalue]
/ ontrialbegin = [values.targetcategory = 1; values.targetformat = "violet"]
/ ontrialbegin = [picture.targetstimulus.height = values.startheight_B]

/ ontrialbegin = [values.starttime = script.elapsedtime; values.endtime = 0]
/ ontrialbegin = [values.completeRT = 0; values.changedirection = 0; values.finalresponse=""]

/ stimulusframes = [1 = targetstimulus]
/ validresponse = (mousemove)
/isvalidresponse = [(trial.AAT_2.responsey > (values.mouse_y + values.pixeltolerance)) ||
					(trial.AAT_2.responsey < (values.mouse_y - values.pixeltolerance)) ]
/ iscorrectresponse = [(values.expcondition == 1 && trial.AAT_2.responsey > values.mouse_y) ||
						(values.expcondition == 2 && trial.AAT_2.responsey < values.mouse_y)]

/ontrialend = [if (trial.AAT_2.responsey < values.mouse_y) values.response = 1 else values.response = 2]
/ ontrialend = [values.mouse_change = abs(values.mouse_y - trial.AAT_2.responsey)]
/ ontrialend = [values.mouse_y = trial.AAT_2.responsey]

/ ontrialend = [if (trial.AAT_2.correct) values.sumRTcorrect_2 += trial.AAT_2.latency]
/ ontrialend = [values.sumRT_2 += trial.AAT_2.latency]

/ ontrialend = [values.trialcode = "AAT_2"]
/ ontrialend = [values.RT = trial.AAT_2.latency]
/ ontrialend = [values.correct = trial.AAT_2.correct]
/ ontrialend = [values.stimulus = picture.targetstimulus.currentitem]

/ontrialend = [if (values.response == 1) values.initialresponse = "PUSH"
						else values.initialresponse = "PULL"]

/ branch = [if (values.response == 1) trial.decrease else trial.increase]
/recorddata = false
</trial>


<trial AAT_3>
/inputdevice = mouse
/ ontrialbegin = [values.trialcode = "AAT_3"]
/ ontrialbegin = [values.selectstimulus = list.category3.nextvalue]
/ ontrialbegin = [values.targetcategory = 2; values.targetformat = "blue"]
/ ontrialbegin = [picture.targetstimulus.height = values.startheight_A]

/ ontrialbegin = [values.starttime = script.elapsedtime; values.endtime = 0]
/ ontrialbegin = [values.completeRT = 0; values.changedirection = 0; values.finalresponse=""]

/ stimulusframes = [1 = targetstimulus]
/ validresponse = (mousemove)
/isvalidresponse = [(trial.AAT_3.responsey > (values.mouse_y + values.pixeltolerance)) ||
					(trial.AAT_3.responsey < (values.mouse_y - values.pixeltolerance)) ]
/ iscorrectresponse = [(values.expcondition == 1 && trial.AAT_3.responsey < values.mouse_y) ||
						(values.expcondition == 2 && trial.AAT_3.responsey > values.mouse_y)]

/ ontrialend = [if (trial.AAT_3.correct) values.sumRTcorrect_3 += trial.AAT_3.latency]
/ ontrialend = [values.sumRT_3 += trial.AAT_3.latency]

/ontrialend = [if (trial.AAT_3.responsey < values.mouse_y) values.response = 1 else values.response = 2]
/ ontrialend = [values.mouse_change = abs(values.mouse_y - trial.AAT_3.responsey)]
/ ontrialend = [values.mouse_y = trial.AAT_3.responsey]

/ ontrialend = [values.RT = trial.AAT_3.latency]
/ ontrialend = [values.correct = trial.AAT_3.correct]
/ ontrialend = [values.stimulus = picture.targetstimulus.currentitem]

/ontrialend = [if (values.response == 1) values.initialresponse = "PUSH"
						else values.initialresponse = "PULL"]
/ branch = [if (values.response == 1) trial.decrease else trial.increase]
/recorddata = false
</trial>


<trial AAT_4>
/inputdevice = mouse
/ ontrialbegin = [values.selectstimulus = list.category4.nextvalue]
/ ontrialbegin = [values.targetcategory = 2; values.targetformat = "violet"]
/ ontrialbegin = [picture.targetstimulus.height = values.startheight_B]

/ ontrialbegin = [values.starttime = script.elapsedtime; values.endtime = 0]
/ ontrialbegin = [values.completeRT = 0; values.changedirection = 0; values.finalresponse=""]

/ stimulusframes = [1 = targetstimulus]
/ validresponse = (mousemove)
/isvalidresponse = [(trial.AAT_4.responsey > (values.mouse_y + values.pixeltolerance)) ||
					(trial.AAT_4.responsey < (values.mouse_y - values.pixeltolerance)) ]
/ iscorrectresponse = [(values.expcondition == 1 && trial.AAT_4.responsey > values.mouse_y) ||
						(values.expcondition == 2 && trial.AAT_4.responsey < values.mouse_y)]

/ontrialend = [if (trial.AAT_4.responsey < values.mouse_y) values.response = 1 else values.response = 2]
/ ontrialend = [values.mouse_change = abs(values.mouse_y - trial.AAT_4.responsey)]
/ ontrialend = [values.mouse_y = trial.AAT_4.responsey]

/ ontrialend = [if (trial.AAT_4.correct) values.sumRTcorrect_4 += trial.AAT_4.latency]
/ ontrialend = [values.sumRT_4 += trial.AAT_4.latency]

/ ontrialend = [values.trialcode = "AAT_4"]
/ ontrialend = [values.RT = trial.AAT_4.latency]
/ ontrialend = [values.correct = trial.AAT_4.correct]
/ ontrialend = [values.stimulus = picture.targetstimulus.currentitem]

/ontrialend = [if (values.response == 1) values.initialresponse = "PUSH"
						else values.initialresponse = "PULL"]

/ branch = [if (values.response == 1) trial.decrease else trial.increase]
/recorddata = false
</trial>


<trial AAT_5>
/inputdevice = mouse
/ ontrialbegin = [values.trialcode = "AAT_5"]
/ ontrialbegin = [values.selectstimulus = list.category5.nextvalue]
/ ontrialbegin = [values.targetcategory = 3; values.targetformat = "blue"]
/ ontrialbegin = [picture.targetstimulus.height = values.startheight_A]
/ ontrialbegin = [values.starttime = script.elapsedtime; values.endtime = 0]
/ ontrialbegin = [values.completeRT = 0; values.changedirection = 0; values.finalresponse=""]

/ stimulusframes = [1 = targetstimulus]
/ validresponse = (mousemove)
/isvalidresponse = [(trial.AAT_5.responsey > (values.mouse_y + values.pixeltolerance)) ||
					(trial.AAT_5.responsey < (values.mouse_y - values.pixeltolerance)) ]
/ iscorrectresponse = [(values.expcondition == 1 && trial.AAT_5.responsey < values.mouse_y) ||
						(values.expcondition == 2 && trial.AAT_5.responsey > values.mouse_y)]

/ ontrialend = [if (trial.AAT_5.correct) values.sumRTcorrect_5 += trial.AAT_5.latency]
/ ontrialend = [values.sumRT_5 += trial.AAT_5.latency]

/ontrialend = [if (trial.AAT_5.responsey < values.mouse_y) values.response = 1 else values.response = 2]
/ ontrialend = [values.mouse_change = abs(values.mouse_y - trial.AAT_5.responsey)]
/ ontrialend = [values.mouse_y = trial.AAT_5.responsey]

/ ontrialend = [values.RT = trial.AAT_5.latency]
/ ontrialend = [values.correct = trial.AAT_5.correct]
/ ontrialend = [values.stimulus = picture.targetstimulus.currentitem]

/ontrialend = [if (values.response == 1) values.initialresponse = "PUSH"
						else values.initialresponse = "PULL"]
/ branch = [if (values.response == 1) trial.decrease else trial.increase]
/recorddata = false
</trial>


<trial AAT_6>
/inputdevice = mouse
/ ontrialbegin = [values.selectstimulus = list.category6.nextvalue]
/ ontrialbegin = [values.targetcategory = 3; values.targetformat = "violet"]
/ ontrialbegin = [picture.targetstimulus.height = values.startheight_B]

/ ontrialbegin = [values.starttime = script.elapsedtime; values.endtime = 0]
/ ontrialbegin = [values.completeRT = 0; values.changedirection = 0; values.finalresponse=""]

/ stimulusframes = [1 = targetstimulus]
/ validresponse = (mousemove)
/isvalidresponse = [(trial.AAT_6.responsey > (values.mouse_y + values.pixeltolerance)) ||
					(trial.AAT_6.responsey < (values.mouse_y - values.pixeltolerance)) ]
/ iscorrectresponse = [(values.expcondition == 1 && trial.AAT_6.responsey > values.mouse_y) ||
						(values.expcondition == 2 && trial.AAT_6.responsey < values.mouse_y)]

/ontrialend = [if (trial.AAT_6.responsey < values.mouse_y) values.response = 1 else values.response = 2]
/ ontrialend = [values.mouse_change = abs(values.mouse_y - trial.AAT_6.responsey)]
/ ontrialend = [values.mouse_y = trial.AAT_6.responsey]

/ ontrialend = [if (trial.AAT_6.correct) values.sumRTcorrect_6 += trial.AAT_6.latency]
/ ontrialend = [values.sumRT_6 += trial.AAT_6.latency]

/ ontrialend = [values.trialcode = "AAT_6"]
/ ontrialend = [values.RT = trial.AAT_6.latency]
/ ontrialend = [values.correct = trial.AAT_6.correct]
/ ontrialend = [values.stimulus = picture.targetstimulus.currentitem]

/ontrialend = [if (values.response == 1) values.initialresponse = "PUSH"
						else values.initialresponse = "PULL"]

/ branch = [if (values.response == 1) trial.decrease else trial.increase]
/recorddata = false
</trial>


**********************************************************************
ZOOM trials that control the size changes of the target stimuli
as dictated by response; zoom trials come to an end when the
mouse cursor has reached either end of the monitor height
**********************************************************************

<trial decrease>
/inputdevice = mouse
/ ontrialbegin = [picture.targetstimulus.height = picture.targetstimulus.height - values.mouse_change/(values.maxheight/2) * expressions.maxheightchange_px]

/ stimulusframes = [1 = eraser, targetstimulus]
/validresponse = (mousemove)
/ontrialend = [values.mouse_change = abs(values.mouse_y - trial.decrease.responsey)]

/ontrialend = [trial.decrease.resetstimulusframes()]

/branch = [if (script.subjectid == "monkey") {values.endtime = script.elapsedtime; values.finalresponse = "PUSH"; trial.intertrialinterval}]

/branch = [if (trial.decrease.responsey <= 1)
				{values.mouse_y = trial.decrease.responsey; values.endtime = script.elapsedtime; values.finalresponse = "PUSH"; trial.enddecrease}]
/branch = [if (trial.decrease.responsey <= values.mouse_y)
				{values.mouse_y = trial.decrease.responsey; trial.decrease}]
/branch = [if (trial.decrease.responsey > values.mouse_y)
				{values.mouse_y = trial.decrease.responsey; values.changedirection += 1; trial.increase}]

/ recorddata = false
</trial>


<trial increase>
/ ontrialbegin = [picture.targetstimulus.height = picture.targetstimulus.height + values.mouse_change/(values.maxheight/2) * expressions.maxheightchange_px]
/ stimulusframes = [1 = targetstimulus]
/validresponse = (mousemove)
/ontrialend = [values.mouse_change = abs(values.mouse_y - trial.increase.responsey)]

/ontrialend = [trial.increase.resetstimulusframes()]

/branch = [if (script.subjectid == "monkey") {values.endtime = script.elapsedtime; values.finalresponse = "PULL"; trial.intertrialinterval}]

/branch = [if (trial.increase.responsey >= values.maxheight-1)
				{values.mouse_y = trial.increase.responsey; values.endtime = script.elapsedtime; values.finalresponse = "PULL"; trial.endincrease}]
/branch = [if (trial.increase.responsey >= values.mouse_y)
				{values.mouse_y = trial.increase.responsey; trial.increase}]
/branch = [if (trial.increase.responsey < values.mouse_y)
				{values.mouse_y = trial.increase.responsey; values.changedirection += 1; trial.decrease}]
/recorddata = false
</trial>

Note: trials show the last size of the picture
<trial endincrease>
/ ontrialbegin = [picture.targetstimulus.height = picture.targetstimulus.height + values.mouse_change/(values.maxheight/2) * expressions.maxheightchange_px]
/stimulusframes = [1 = targetstimulus]
/timeout = 0
/branch = [trial.intertrialinterval]
/recorddata = false
</trial>

<trial enddecrease>
/ontrialbegin = [picture.targetstimulus.height = picture.targetstimulus.height - values.mouse_change/(values.maxheight/2) * expressions.maxheightchange_px]
/stimulusframes = [1 = eraser, targetstimulus]
/timeout = 0
/branch = [trial.intertrialinterval]
/recorddata = false
</trial>
**********************************************************************
Helper Trials:
*trial. InterTrialInterval : sets a predetermined InterTrialInterval
(and stores all relevant data in the data file to have one complete dataline for each trial)
**********************************************************************

<trial InterTrialInterval>
/ontrialbegin = [values.completeRT= values.endtime - values.starttime]
/ stimulusframes = [1 = eraser]
/ timeout = values.intertrialinterval
/ recorddata = true
</trial>

**************************************************************************************************************
**************************************************************************************************************
AAT EXPERIMENTAL BLOCKS
**************************************************************************************************************
**************************************************************************************************************
<block AAT>
/preinstructions = (taskinstructions)
/ onblockbegin = [values.index = 0]
/ trials = [1-80 = AAT_start]
</block>

**************************************************************************************************************
**************************************************************************************************************
EXPERIMENT
**************************************************************************************************************
**************************************************************************************************************
NOTE:
format/direction counterbalanced by group number

<expt >
/ onexptbegin = [values.expcondition = 1]
/ onexptbegin = [values.format1 = "VIOLETTEM"; values.format2 = "BLAUEM"]
/ subjects = (1 of 2)
/groupassignment = groupnumber
/ onexptbegin = [values.startheight_A = values.Startheight_ratioA* values.maxheight]
/ onexptbegin = [values.startheight_B = values.Startheight_ratioB* values.maxheight]
/ onexptbegin = [values.startheight_C = values.Startheight_ratioC* values.maxheight]
/ onexptbegin = [values.startheight_D = values.Startheight_ratioD* values.maxheight]
/ onexptbegin = [values.startheight_E = values.Startheight_ratioE* values.maxheight]
/ onexptbegin = [values.startheight_F = values.Startheight_ratioF* values.maxheight]
/ onexptbegin = [values.startheight_G = values.Startheight_ratioG* values.maxheight]
/ onexptbegin = [values.startheight_H = values.Startheight_ratioH* values.maxheight]
/ onexptbegin = [values.startheight_I = values.Startheight_ratioI* values.maxheight]
/ onexptbegin = [values.startheight_J = values.Startheight_ratioJ* values.maxheight]
/ blocks = [1 = SequenceGenerator; 2 = practice_AAT; 3 = AAT]
/ postinstructions = (End)
</expt>

<expt >
/ onexptbegin = [values.expcondition = 2]
/ onexptbegin = [values.format2 = "VIOLETTEM"; values.format1 = "BLAUEM"]
/ subjects = (2 of 2)
/groupassignment = groupnumber
/ onexptbegin = [values.startheight_A = values.Startheight_ratioA* values.maxheight]
/ onexptbegin = [values.startheight_B = values.Startheight_ratioB* values.maxheight]
/ onexptbegin = [values.startheight_C = values.Startheight_ratioC* values.maxheight]
/ onexptbegin = [values.startheight_D = values.Startheight_ratioD* values.maxheight]
/ onexptbegin = [values.startheight_E = values.Startheight_ratioE* values.maxheight]
/ onexptbegin = [values.startheight_F = values.Startheight_ratioF* values.maxheight]
/ onexptbegin = [values.startheight_G = values.Startheight_ratioG* values.maxheight]
/ onexptbegin = [values.startheight_H = values.Startheight_ratioH* values.maxheight]
/ onexptbegin = [values.startheight_I = values.Startheight_ratioI* values.maxheight]
/ onexptbegin = [values.startheight_J = values.Startheight_ratioJ* values.maxheight]
/ blocks = [1 = SequenceGenerator; 2 = practice_AAT; 3 = AAT]
/ postinstructions = (End)
</expt>

**************************************************************************************************************
**************************************************************************************************************
TRIAL SEQUENCE GENERATION  CODE:
**************************************************************************************************************
**************************************************************************************************************
The trial sequence generation code generates a sequence of trials that fulfills the following
constraints:
1) 10 stimuli of category 1 in Format A (=1), 10 stimuli of category 1 in Format B (=2),
10 stimuli of category 2 in Format A (=3), 10 stimuli of category 1 in Format B (=4),
10 stimuli of category 3 in Format A (=5), 10 stimuli of category 1 in Format B (=6),
10 stimuli of category 4 in Format A (=7), 10 stimuli of category 1 in Format B (=8),
2) no more than three consecutive stimuli of the same category
3) no more than three consecutive stimuli of the same format

the sequences produced look something like this:
868546276815347238341865316174854225166758252358517483251343227374137614617876

NOTE:
!!!! The time to generate the appropriate sequence will differ between participants.
Two alternatives are:
1) pregenerated sequences.
For example, you could generate 100 of these sequences (run this code in a separate script),
store the sequences in an item element and select randomly from these sequences for each
participant.
2) run the experiment with simple random sampling
(without replacement) without paying attention to the added constraints
regarding category/format repetitions.

This trialsequence algorithm is relatively simple and may
reach its limits if more conditions/trials are added. In this case,
a new algorithm may have to be written or any of the two alternatives has
to be used.

*****************************************************************************
Values
*****************************************************************************
Stimulus sequence generation
/count1...count8:							contains the number of trials per stimuli type
/runcount_1 ...runcount_4:					counts how many consecutive stimuli of the same category
/runcount_A / runcount_B = 0:				counts how many consecutive stimuli of the same format
/newnumber :										the next potential stimulus digit (1-8) for the sequence
/count_comparecat:							helper variable: stores the count of the consecutive stimulus category
														relevant for the selected newnumber
/count_compareformat :						helper variable: stores the count of the consecutive stimulus format
														relevant for the selected newnumber
/sequence:									the stimulus generation sequence
/index:										current position in a string variable, helper variable to get individual items
											out of a string of items

<values>
/count1 = 14
/count2 = 14
/count3 = 14
/count4 = 14
/count5 = 14
/count6 = 14
/runcount_1 = 0
/runcount_2 = 0
/runcount_3 = 0
/runcount_4  = 0
/runcount_A = 0
/runcount_B = 0
/newnumber = 0
/count_comparecat = 0
/count_compareformat = 0
/sequence = ""
/index = 0
</values>

*****************************************************************************
List Stimcats: contains all 80 possible stimuli
*****************************************************************************
<list stimcats>
/ items = (
1,1,1,1,1,1,1,1,1,1,1,1,1,1
2,2,2,2,2,2,2,2,2,2,2,2,2,2,
3,3,3,3,3,3,3,3,3,3,3,3,3,3,
4,4,4,4,4,4,4,4,4,4,4,4,4,4,
5,5,5,5,5,5,5,5,5,5,5,5,5,5,
6,6,6,6,6,6,6,6,6,6,6,6,6,6)
/ replace = false
</list>

*****************************************************************************
Trial Selectnumber: selects the newnumber and checks whether
all constraints are met
- if all constraints are met: adds new number to sequence
- constraints are not met: checks whether an alternative number is available that could meet constraint
							=> if yes: returns current number to list and tries again
							=> if no: starts the sequence over
*****************************************************************************
<trial selectnumber>
/ ontrialbegin = [values.newnumber = list.stimcats.nextvalue]
/ ontrialbegin = [values.index += 1]
/ ontrialbegin = [if (values.newnumber == 1)
						{values.runcount_1 += 1;
						values.runcount_A += 1;
						values.count_comparecat = values.runcount_1;
						values.count_compareformat = values.runcount_A;
						values.count1 -=1}]
/ ontrialbegin = [if (values.newnumber ==2)
						{values.runcount_1 += 1;
						values.runcount_B += 1;
						values.count_comparecat = values.runcount_1;
						values.count_compareformat = values.runcount_B;
						values.count2 -=1}]
/ ontrialbegin = [if (values.newnumber ==3)
						{values.runcount_2 += 1;
						values.runcount_A += 1;
						values.count_comparecat = values.runcount_2;
						values.count_compareformat = values.runcount_A;
						values.count3 -= 1}]
/ ontrialbegin = [if (values.newnumber ==4)
						{values.runcount_2 += 1;
						values.runcount_B += 1;
						values.count_comparecat = values.runcount_2;
						values.count_compareformat = values.runcount_B;
						values.count4 -=1}]
/ ontrialbegin = [if (values.newnumber ==5)
						{values.runcount_3 += 1;
						values.runcount_A += 1;
						values.count_comparecat = values.runcount_3;
						values.count_compareformat = values.runcount_A;
						values.count5 -= 1}]
/ ontrialbegin = [if (values.newnumber ==6)
						{values.runcount_3 += 1;
						values.runcount_B += 1;
						values.count_comparecat = values.runcount_3;
						values.count_compareformat = values.runcount_B;
						values.count6 -= 1}]

/ontrialend = [if (values.count_comparecat < 4 && values.count_compareformat < 4)
							{ values.sequence = concat(values.sequence, values.newnumber)}]

/ branch = [if (values.index < values.totaltrialcount && values.count_comparecat < 4 && values.count_compareformat < 4 && values.newnumber == 1)
							{ values.runcount_2 = 0; values.runcount_3 = 0; values.runcount_4 = 0; values.runcount_B = 0;
							trial.selectnumber}]

/ branch = [if (values.index < values.totaltrialcount && values.count_comparecat < 4 && values.count_compareformat < 4 && values.newnumber == 2)
							{ values.runcount_2 = 0; values.runcount_3 = 0; values.runcount_4 = 0;  values.runcount_A = 0;
							trial.selectnumber}]

/ branch = [if (values.index < values.totaltrialcount && values.count_comparecat < 4 && values.count_compareformat < 4 && values.newnumber == 3)
							{ values.runcount_1 = 0; values.runcount_3 = 0; values.runcount_4 = 0; values.runcount_B = 0;
							trial.selectnumber}]

/ branch = [if (values.index <= values.totaltrialcount && values.count_comparecat < 4 && values.count_compareformat < 4 && values.newnumber == 4)
							{ values.runcount_1 = 0; values.runcount_3 = 0; values.runcount_4 = 0;  values.runcount_A = 0;
							trial.selectnumber}]

/ branch = [if (values.index < values.totaltrialcount && values.count_comparecat < 4 && values.count_compareformat < 4 && values.newnumber == 5)
							{ values.runcount_2 = 0; values.runcount_1 = 0; values.runcount_4 = 0; values.runcount_B = 0;
							trial.selectnumber}]

/ branch = [if (values.index < values.totaltrialcount && values.count_comparecat < 4 && values.count_compareformat < 4 && values.newnumber == 6)
							{ values.runcount_2 = 0; values.runcount_1 = 0; values.runcount_4 = 0;  values.runcount_A = 0;
							trial.selectnumber}]

/ branch = [if (values.index < values.totaltrialcount && values.count_comparecat < 4 && values.count_compareformat < 4 && values.newnumber == 7)
							{ values.runcount_2 = 0; values.runcount_3 = 0; values.runcount_1 = 0; values.runcount_B = 0;
							trial.selectnumber}]

/ branch = [if (values.index < values.totaltrialcount && values.count_comparecat < 4 && values.count_compareformat < 4 && values.newnumber == 8)
							{ values.runcount_2 = 0; values.runcount_3 = 0; values.runcount_1 = 0;  values.runcount_A = 0;
							trial.selectnumber}]

/branch = [if (values.newnumber == 1 && values.count_comparecat > 3 &&
(values.count3 != 0 || values.count4 != 0 || values.count5 != 0 || values.count6 != 0 ))
							{values.index -= 1; list.stimcats.insertitem(1, 1); values.runcount_1 -= 1; values.runcount_a -= 1; values.count1 += 1; trial.selectnumber}]

 /branch = [if (values.newnumber == 1 && values.count_compareformat > 3 &&
(values.count2 != 0 || values.count4 != 0 || values.count6 != 0 ))
							{values.index -= 1;list.stimcats.insertitem(1, 1); values.runcount_1 -= 1; values.runcount_a -= 1; values.count1 += 1; trial.selectnumber}]

/branch = [if (values.newnumber == 2 && values.count_comparecat > 3 &&
(values.count3 != 0 || values.count4 != 0 || values.count5 != 0 || values.count6 != 0 ))
							{values.index -= 1;list.stimcats.insertitem(2, 1); values.runcount_1 -= 1; values.runcount_b -= 1; values.count2 += 1; trial.selectnumber}]
/branch = [if (values.newnumber == 2 && values.count_compareformat > 3 &&
(values.count1 != 0 || values.count3 != 0 || values.count5 != 0 ))
							{values.index -= 1;list.stimcats.insertitem(2, 1); values.runcount_1 -= 1; values.runcount_b -= 1; values.count2 += 1; trial.selectnumber}]

/branch = [if (values.newnumber == 3 && values.count_comparecat > 3 &&
(values.count1 != 0 || values.count2 != 0 || values.count5 != 0 || values.count6 != 0 ))
							{values.index -= 1;list.stimcats.insertitem(3, 1); values.runcount_2 -= 1; values.runcount_a -= 1; values.count3 += 1; trial.selectnumber}]
/branch = [if (values.newnumber == 3 && values.count_compareformat > 3 &&
(values.count2 != 0 || values.count4 != 0 || values.count6 != 0 ))
							{values.index -= 1;list.stimcats.insertitem(3, 1); values.runcount_2 -= 1; values.runcount_a -= 1; values.count3 += 1; trial.selectnumber}]

/branch = [if (values.newnumber == 4 && values.count_comparecat > 3 &&
(values.count1 != 0 || values.count2 != 0 || values.count5 != 0 || values.count6 != 0 ))
							{values.index -= 1;list.stimcats.insertitem(4, 1); values.runcount_2 -= 1; values.runcount_b -= 1; values.count4 += 1; trial.selectnumber}]
/branch = [if (values.newnumber == 4 && values.count_compareformat > 3 &&
(values.count1 != 0 || values.count3 != 0 || values.count5 != 0 ))
							{values.index -= 1;list.stimcats.insertitem(4, 1); values.runcount_2 -= 1; values.runcount_b -= 1; values.count4 += 1; trial.selectnumber}]

/branch = [if (values.newnumber == 5 && values.count_comparecat > 3 &&
(values.count3 != 0 || values.count4 != 0 || values.count1 != 0 || values.count2 != 0 ))
							{values.index -= 1;list.stimcats.insertitem(5, 1); values.runcount_3 -= 1; values.runcount_a -= 1; values.count5 += 1; trial.selectnumber}]
/branch = [if (values.newnumber == 5 && values.count_compareformat > 3 &&
(values.count2 != 0 || values.count4 != 0 || values.count6 != 0))
							{values.index -= 1;list.stimcats.insertitem(5, 1); values.runcount_3 -= 1; values.runcount_a -= 1; values.count5 += 1; trial.selectnumber}]

/branch = [if (values.newnumber == 6 && values.count_comparecat > 3 &&
(values.count3 != 0 || values.count4 != 0 || values.count1 != 0 || values.count2 != 0 ))
							{values.index -= 1;list.stimcats.insertitem(6, 1); values.runcount_3 -= 1; values.runcount_b -= 1; values.count6 += 1; trial.selectnumber}]
/branch = [if (values.newnumber == 6 && values.count_compareformat > 3 &&
(values.count1 != 0 || values.count3 != 0 || values.count5 != 0 ))
							{values.index -= 1;list.stimcats.insertitem(6, 1); values.runcount_3 -= 1; values.runcount_b -= 1; values.count6 += 1; trial.selectnumber}]

/branch = [if (values.count_comparecat > 3 || values.count_compareformat > 3)
							{values.sequence = "";
							values.index = 0;
							values.runcount_1 = 0; values.runcount_2 = 0; values.runcount_3 = 0; values.runcount_4 = 0;
							values.runcount_A = 0; values.runcount_B = 0;
							values.count1 = 14; values.count2 = 14; values.count3 = 14; values.count4 = 14; values.count5 = 14; values.count6 = 14;
							list.stimcats.reset(); trial.selectnumber}]

/timeout = 0
/recorddata = false
</trial>

*****************************************************************************
Trial Showsequence: Debug Trial
*****************************************************************************
<text completesequence>
/ items = ("<%values.sequence%>")
</text>

<trial showsequence>
/ inputdevice = keyboard
/ stimulusframes = [1 = completesequence]
/ validresponse = (57)
</trial>

*****************************************************************************
Block SequenceGenerator:
*****************************************************************************
<text wait>
/items = ("Bitte warten...")
/ fontstyle = ("Arial", 3.00%, false, false, false, false, 5, 0)
</text>

<block SequenceGenerator>
/ bgstim = (wait)
/ trials = [1 = selectnumber]
/ recorddata = false
</block>

**************************************************************************************************************
                                                          END OF FILE
**************************************************************************************************************