**************************************************************************************************************
**************************************************************************************************************
	EDITABLE PARAMETERS: change editable parameters here
**************************************************************************************************************
**************************************************************************************************************

<parameters>
/congruentStim = "heart"
/incongruentStim = "flower"

/minPracticeACC = 0.75
/maxPracticeRepeats = 3
/numberPracticeTrials = 8
/numberTestTrials = 20

/stimDuration_simpleBlock = 5000
/stimDuration_mixedBlock = 6000
/iti = 1000

/picSize = 10%
/fixationSize = 15%
/left_x = 30%
/right_x = 70%

/leftkey = 30
/leftkey_label = "A"
/rightkey = 38
/rightkey_label = "L"
</parameters>



**************************************************************************************************************
**************************************************************************************************************
	EDITABLE STIMULI
**************************************************************************************************************
**************************************************************************************************************



**************************************************************************************************************
**************************************************************************************************************
	EDITABLE INSTRUCTIONS: change instructions here
**************************************************************************************************************
**************************************************************************************************************
<instruct>
/ fontstyle = ("Arial", 3.5%, true, false, false, false, 5, 1)
/ txcolor = black
/ screencolor = white
/ windowsize = (100%, 100%)
</instruct>

<text welcome>
/ items = ("Welcome!")
/ fontstyle = ("Arial", 10%, true, false, false, false, 5, 1)
/ position = (50%, 10%)
/ vjustify = center
/ size = (80%, 12%)
</text>

<picture heart>
/ items = ("heart.jpg")
/ position = (50%, 15%)
/ size = (12%, 12%)
</picture>

<text intro_congruent>
/ items = ("We will you show you hearts!")
/ fontstyle = ("Arial", 5%, true, false, false, false, 5, 1)
/ position = (50%, 25%)
/ vjustify = center
/ size = (80%, 8%)
</text>

<text intro2_congruent>
/ items = ("The hearts can appear on the left or the right")
/ fontstyle = ("Arial", 3%, true, false, false, false, 5, 1)
/ position = (50%, 75%)
/ vjustify = center
/ size = (80%, 8%)
</text>

<text continue>
/ items = ("press one of the two buttons now")
/ fontstyle = ("Arial", 3%, true, false, false, false, 5, 1)
/ position = (50%, 90%)
/ vjustify = center
/ size = (80%, 8%)
</text>

<text continueLeft>
/ items = ("press the '<%parameters.leftkey_label%>' button now")
/ fontstyle = ("Arial", 5%, true, false, false, false, 5, 1)
/ position = (50%, 90%)
/ vjustify = center
/ size = (80%, 8%)
</text>

<text continueRight>
/ items = ("press the '<%parameters.rightkey_label%>' button now")
/ fontstyle = ("Arial", 5%, true, false, false, false, 5, 1)
/ position = (50%, 90%)
/ vjustify = center
/ size = (80%, 8%)
</text>

<text congruentTask>
/ items = ("If you see the heart: 
Press the button on the same side as the heart")
/ fontstyle = ("Arial", 4%, true, false, false, false, 5, 1)
/ position = (50%, 15%)
/ vjustify = center
/ size = (80%, 20%)
</text>

<text congruentTask2>
/ items = ("If you see the heart on this side: press this button")
/ fontstyle = ("Arial", 3%, true, false, false, false, 5, 1)
/ position = (50%, 75%)
/ vjustify = center
/ size = (80%, 20%)
</text>

<text PracticeStart_congruent>
/ items = ("Are you ready to play?
~n~nRemember:
Press the button on the same side as you see the heart. 
Try to be fast to press the correct button.
~n~nPress one of the two buttons to start practice")
/ fontstyle = ("Arial", 4%, true, false, false, false, 5, 1)
/ position = (50%, 50%)
/ vjustify = center
/ size = (80%, 60%)
</text>

<text ChangeGame>
/ items = ("Let's change the game!")
/ fontstyle = ("Arial", 8%, true, false, false, false, 5, 1)
/ position = (50%, 10%)
/ vjustify = center
/ size = (80%, 8%)
</text>

<picture flower>
/ items = ("flower.jpg")
/ position = (50%, 15%)
/ size = (12%, 12%)
</picture>

<text intro_incongruent>
/ items = ("We will you show you flowers now!")
/ fontstyle = ("Arial", 5%, true, false, false, false, 5, 1)
/ position = (50%, 25%)
/ vjustify = center
/ size = (80%, 8%)
</text>

<text intro2_incongruent>
/ items = ("The flowers can appear on the left or the right")
/ fontstyle = ("Arial", 3%, true, false, false, false, 5, 1)
/ position = (50%, 75%)
/ vjustify = center
/ size = (80%, 8%)
</text>

<text incongruentTask>
/ items = ("If you see the flower: 
Press the button on the OPPOSITE side of the flower")
/ fontstyle = ("Arial", 4%, true, false, false, false, 5, 1)
/ position = (50%, 15%)
/ vjustify = center
/ size = (80%, 20%)
</text>

<text incongruentTask2>
/ items = ("If you see the flower on this side: press that button over there")
/ fontstyle = ("Arial", 3%, true, false, false, false, 5, 1)
/ position = (50%, 75%)
/ vjustify = center
/ size = (80%, 20%)
</text>

<text PracticeStart_incongruent>
/ items = ("Are you ready to play?
~n~nRemember:
Press the button on the OPPOSITE side of the flower. 
Try to be fast to press the correct button.
~n~nPress one of the two buttons to start practice")
/ fontstyle = ("Arial", 4%, true, false, false, false, 5, 1)
/ position = (50%, 50%)
/ vjustify = center
/ size = (80%, 60%)
</text>

<text MixedGame>
/ items = ("Let's put it all together!")
/ fontstyle = ("Arial", 8%, true, false, false, false, 5, 1)
/ position = (50%, 10%)
/ vjustify = center
/ size = (80%, 8%)
</text>

<picture heartflower>
/ items = ("heartflower.jpg")
/ position = (50%, 15%)
/ size = (12%, 12%)
</picture>

<text intro_mixed>
/ items = ("We will you show you hearts AND flowers now!")
/ fontstyle = ("Arial", 5%, true, false, false, false, 5, 1)
/ position = (50%, 25%)
/ vjustify = center
/ size = (80%, 12%)
</text>

<text intro2_mixed>
/ items = ("The flowers and hearts can appear on the left or the right")
/ fontstyle = ("Arial", 3%, true, false, false, false, 5, 1)
/ position = (50%, 75%)
/ vjustify = center
/ size = (80%, 8%)
</text>

<text PracticeStart_mixed>
/ items = ("Are you ready to play?
~n~nRemember:
Press the button on the SAME side as the HEART
Press the button on the OPPOSITE side of the FLOWER.
 
Try to be fast to press the correct button.
~n~nPress one of the two buttons to start practice")
/ fontstyle = ("Arial", 4%, true, false, false, false, 5, 1)
/ position = (50%, 50%)
/ vjustify = center
/ size = (90%, 80%)
</text>

<text reminder_congruent>
/ items = ("press the button on the same side")
/ fontstyle = ("Arial", 5%, true, false, false, false, 5, 1)
/ position = (50%, 65%)
/ vjustify = center
/ size = (80%, 10%)
</text>

<sound reminder_congruent_audio>
/items = ("heart_press.wav")
/ playthrough = true
</sound>

<text reminder_incongruent>
/ items = ("press the button on the opposite side")
/ fontstyle = ("Arial", 5%, true, false, false, false, 5, 1)
/ position = (50%, 65%)
/ vjustify = center
/ size = (80%, 10%)
</text>

<sound reminder_incongruent_audio>
/items = ("flower_press_overthere.wav")
/ playthrough = true
</sound>

<picture Feedback>
/items = ("posfeedback.jpg")
/ position = (50%, 70%)
/ size = (20%, 20%)
</picture>

<sound Feedback_audio>
/ items = ("goodjob.wav")
/ playthrough = true
</sound>

<text noResponseText>
/ items = ("Try to be faster next time")
/ position = (50%, 30%)
/ fontstyle = ("Arial", 5%, true, false, false, false, 5, 1)
/ size = (80%, 10%)
/ vjustify = center
/ txcolor = blue
</text>

<video pressleft>
/ items = ("pressleft.gif")
/ position = (15%, 85%)
/ size = (10%, 10%)
/ loop = true
</video>

<video pressright>
/ items = ("pressright.gif")
/ position = (85%, 85%)
/ size = (10%, 10%)
/ loop = true
</video>

<text teststart>
/items = ("Let's play some more!

But this time the computer will not tell you whether you were right.")
/ fontstyle = ("Arial", 5%, true, false, false, false, 5, 1)
/ position = (50%, 15%)
/ size = (80%, 30%)
/ vjustify = center
</text>

<text teststart2>
/items = ("Press one of the two buttons to start")
/ fontstyle = ("Arial", 4%, true, false, false, false, 5, 1)
/ position = (50%, 90%)
/ size = (80%, 30%)
/ vjustify = center
</text>

<text finish>
/ items = ("Thank you!")
/ fontstyle = ("Arial", 8%, true, false, false, false, 5, 1)
/ position = (50%, 50%)
/ size = (80%, 80%)
/ vjustify = center
</text>

<text exit>
/ items = ("<press spacebar to exit>")
/ fontstyle = ("Arial", 3%, false, false, false, false, 5, 1)
/ position = (50%, 90%)
/ size = (80%, 5%)
/ vjustify = center
</text>

**************************************************************************************************************
**************************************************************************************************************
	INCLUDE: the following helper scripts include visual/text stimuli specific to 
	devices with and without external keyboards
**************************************************************************************************************
**************************************************************************************************************

<include>
/ precondition = [
	computer.haskeyboard
]
/ file = "heartsandflowers_instructions_keyboard.iqx"
</include>

<include>
/ precondition = [
	!computer.haskeyboard
]
/ file = "heartsandflowers_instructions_touchscreen.iqx"
</include>

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


**************************************************************************************************************
**************************************************************************************************************
	DEFAULTS
**************************************************************************************************************
**************************************************************************************************************
script requires Inquisit 5.0.11.0 or higher

<defaults>
/canvasaspectratio = (4,3)
/minimumversion = "5.0.11.0"
/ fontstyle = ("Arial", 3%, false, false, false, false, 5, 1)
/txbgcolor = white
/ txcolor = black
/ screencolor = white
</defaults>

**************************************************************************************************************
**************************************************************************************************************
	DATA
**************************************************************************************************************
**************************************************************************************************************

Note: data file explanations under User Manual Information at the top

To change from one data file per participant to one data file for all participants, set
/separatefiles = false

***********************
raw data file
***********************
<data>
/ separatefiles = true
/ columns = (build, computer.platform, date, time, subject, group, blockcode, blocknum, trialcode, trialnum,
values.condition, values.position, values.congruence, values.prevCongruence, values.switch, values.countSwitch, 
stimulusitem, response, correct, latency, list.ACC_practice.mean, values.countCongruent, values.countIncongruent, values.countMixed)
</data>

***********************
summary data file
***********************
<summarydata>
/columns = (script.startdate, script.starttime, script.subjectid, script.groupid, script.elapsedtime, computer.platform, 
values.completed,

values.countCongruent, values.practiceACC_congruent, values.passCongruent, 
values.countIncongruent, values.practiceACC_incongruent, values.passInCongruent,
values.countMixed, values.practiceACC_mixed, values.passMixed,
expressions.propCorrect, expressions.meanRT,
expressions.propCorrect_congruent, expressions.meanRT_congruent,
expressions.propCorrect_incongruent, expressions.meanRT_incongruent,
expressions.propCorrect_mixed, expressions.meanRT_mixed,
expressions.propCorrect_switch, expressions.meanRT_switch,
expressions.propCorrect_nonswitch, expressions.meanRT_nonswitch,
)
/ separatefiles = true
</summarydata>


**************************************************************************************************************
**************************************************************************************************************
	VALUES: automatically updated
**************************************************************************************************************
**************************************************************************************************************
                                    
/completed:				0 = script was not completed; 1 = script was completed (all conditions run)

/condition:				1 = congruent-only; 2 = incongruent-only; 3 = mixed

/congruence:			1 = congruent trial; 2 = incongruent trial
/stimDuration:			the current stim duration (= response timeout) in ms
/position:				1 = stimulus is positioned on the left; 2 = stimulus is positioned on the right

/prevCongruence:		the congruence of the previous trial (important for mixed condition only)
/switch:				1 = switch trial (trial type changed from congruent to incongruent or vice versa);
						2 = nonswitch trial (trial type stayed the same)
/countSwitch:			counts the number of switch trials per block

/selectTaskInstructions: helper variable to select the correct task instructions/reminder

/passCongruent:			1 = participant successfully passed the congruent practice; 0 = otherwise
/passInCongruent:		1 = participant successfully passed the incongruent practice; 0 = otherwise
/passMixed:				1 = participant successfully passed the mixed practice; 0 = otherwise
/practiceACC_congruent:	the highest proportion correct in one of the congruent practice blocks (if not run, propCorrect = 0)
/practiceACC_incongruent:	the highest proportion correct in one of the incongruent practice blocks (if not run, propCorrect = 0)
/practiceACC_mixed:		the highest proportion correct in one of the mixed practice blocks (if not run, propCorrect = 0)

/countCongruent:		counts the number of congruent practice blocks run
/countIncongruent:		counts the number of incongruent practice blocks run
/countMixed:			counts the number of mixed practice blocks run

<values>
/completed = 0

/condition = 1

/congruence = 0
/stimDuration = 0
/position = 0

/prevCongruence = 0
/switch = 0
/countSwitch = 0

/selectTaskInstructions = 3

/passCongruent = 0
/passInCongruent = 0
/passMixed = 0
/practiceACC_congruent = 0
/practiceACC_incongruent = 0
/practiceACC_mixed = 0

/countCongruent = 0
/countIncongruent = 0
/countMixed = 0
</values>

**************************************************************************************************************
**************************************************************************************************************
	EXPRESSIONS
**************************************************************************************************************
**************************************************************************************************************

/propCorrect:				proportion correct across all test trials
/meanRT:					mean latency of correct responses across all test trials

/propCorrect_congruent:		proportion correct across congruent-only test trials
/meanRT_congruent:			mean latency of correct responses across congruent-only test trials

/propCorrect_incongruent:	proportion correct across incongruent-only test trials
/meanRT_incongruent:		mean latency of correct responses across incongruent-only test trials

/propCorrect_mixed:			proportion correct across test trials in mixed block
/meanRT_mixed:				mean latency of correct responses across test trials in mixed block

/propCorrect_switch:		proportion correct across switch trials in mixed block
/meanRT_switch:				mean latency of correct responses across switch test trials in mixed block
								switch trial: switch from congruent to incongruent trial and vice versa

/propCorrect_nonswitch:		proportion correct across nonswitch trials in mixed block
/meanRT_nonswitch:			mean latency of correct responses across nonswitch test trials in mixed block


<expressions>
/propCorrect = list.ACC.mean
/meanRT = list.RT.mean

/propCorrect_congruent = list.ACC_congruent.mean
/meanRT_congruent = list.RT_congruent.mean

/propCorrect_incongruent = list.ACC_incongruent.mean
/meanRT_incongruent = list.RT_incongruent.mean

/propCorrect_mixed = list.ACC_mixed.mean
/meanRT_mixed = list.RT_mixed.mean

/propCorrect_switch = list.ACC_switch.mean
/meanRT_switch = list.RT_switch.mean

/propCorrect_nonswitch = list.ACC_nonswitch.mean
/meanRT_nonswitch = list.RT_nonswitch.mean
</expressions>

**************************************************************************************************************
**************************************************************************************************************
	INSTRUCTIONS
**************************************************************************************************************
**************************************************************************************************************

<trial intro1_congruent>
/ stimulustimes = [
	0 = welcome, fingerplacement, fingerplacementPic; 
	3000 = continueLeft, fingerplacementleft;
]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ correctresponse = (parameters.leftkey)
/ response = correct
/ beginresponsetime = 3000
/ recorddata = false
</trial>

<trial intro2_congruent>
/ stimulustimes = [
	0 = intro_congruent, heartmoving; 
	2000 = intro2_congruent;
]
/ timeout = 10000
/ recorddata = false
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ correctresponse = (noresponse)
/ response = correct
</trial>

<trial intro3_congruent>
/ stimulustimes = [
	0 = continueRight, fingerplacementright;
]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ correctresponse = (parameters.rightkey)
/ response = correct
/ recorddata = false
</trial>

<trial intro4_congruent>
/ stimulustimes = [
	0 = congruentTask, leftheart;
	2000 = congruentTask2, pressleft_congruent;
	5000 = continueLeft;
]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ correctresponse = (parameters.leftkey)
/ response = correct
/ recorddata = false
</trial>

<trial intro5_congruent>
/ stimulustimes = [
	0 = congruentTask, rightheart;
	2000 = congruentTask2, pressright_congruent;
	5000 = continueRight;
]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ correctresponse = (parameters.rightkey)
/ response = correct
/ recorddata = false
</trial>

<trial intro6_congruent>
/ stimulustimes = [
	0 = PracticeStart_congruent, heart;
]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ recorddata = false
</trial>


<trial intro1_incongruent>
/ stimulustimes = [
	0 = ChangeGame, fingerplacement, fingerplacementPic; 
	3000 = continueLeft, fingerplacementleft;
]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ correctresponse = (parameters.leftkey)
/ response = correct
/ beginresponsetime = 3000
/ recorddata = false
</trial>

<trial intro2_incongruent>
/ stimulustimes = [
	0 = intro_incongruent, flowermoving; 
	2000 = intro2_incongruent;
]
/ timeout = 10000
/ recorddata = false
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ correctresponse = (noresponse)
/ response = correct
</trial>

<trial intro3_incongruent>
/ stimulustimes = [
	0 = continueRight, fingerplacementright;
]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ correctresponse = (parameters.rightkey)
/ response = correct
/ recorddata = false
</trial>

<trial intro4_incongruent>
/ stimulustimes = [
	0 = incongruentTask, rightflower;
	2000 = incongruentTask2, pressleft_incongruent;
	5000 = continueLeft;
]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ correctresponse = (parameters.leftkey)
/ response = correct
/ recorddata = false
</trial>

<trial intro5_incongruent>
/ stimulustimes = [
	0 = incongruentTask, leftflower;
	2000 = incongruentTask2, pressright_incongruent;
	5000 = continueRight;
]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ correctresponse = (parameters.rightkey)
/ response = correct
/ recorddata = false
</trial>

<trial intro6_incongruent>
/ stimulustimes = [
	0 = PracticeStart_incongruent, flower;
]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ recorddata = false
</trial>

<trial intro1_mixed>
/ stimulustimes = [
	0 = MixedGame, fingerplacement, fingerplacementPic; 
	3000 = continueLeft, fingerplacementleft;
]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ correctresponse = (parameters.leftkey)
/ response = correct
/ beginresponsetime = 3000
/ recorddata = false
</trial>

<trial intro2_mixed>
/ stimulustimes = [
	0 = intro_mixed, mixedmoving; 
	2000 = intro2_mixed;
]
/ timeout = 10000
/ recorddata = false
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ correctresponse = (noresponse)
/ response = correct
</trial>

<trial intro3_mixed>
/ stimulustimes = [
	0 = continueRight, fingerplacementright;
]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ correctresponse = (parameters.rightkey)
/ response = correct
/ recorddata = false
</trial>

<trial intro4_mixed>
/ stimulustimes = [
	0 = congruentTask, leftheart;
	2000 = congruentTask2, pressleft_congruent;
	5000 = continueLeft;
]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ correctresponse = (parameters.leftkey)
/ response = correct
/ recorddata = false
</trial>

<trial intro5_mixed>
/ stimulustimes = [
	0 = congruentTask, rightheart;
	2000 = congruentTask2, pressright_congruent;
	5000 = continueRight;
]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ correctresponse = (parameters.rightkey)
/ response = correct
/ recorddata = false
</trial>

<trial intro6_mixed>
/ stimulustimes = [
	0 = incongruentTask, rightflower;
	2000 = incongruentTask2, pressleft_incongruent;
	5000 = continueLeft;
]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ correctresponse = (parameters.leftkey)
/ response = correct
/ recorddata = false
</trial>

<trial intro7_mixed>
/ stimulustimes = [
	0 = incongruentTask, leftflower;
	2000 = incongruentTask2, pressright_incongruent;
	5000 = continueRight;
]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ correctresponse = (parameters.rightkey)
/ response = correct
/ recorddata = false
</trial>

<trial intro8_mixed>
/ stimulustimes = [
	0 = PracticeStart_mixed, heartflower;
]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ recorddata = false
</trial>

<trial testStart>
/ stimulusframes = [1 = teststart, fingerplacementPic, teststart2]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ recorddata = false
</trial>

<trial finish>
/ stimulusframes = [1 = finish, Feedback, exit]
/ validresponse = (57)
/ recorddata = false
</trial>

**************************************************************************************************************
**************************************************************************************************************
	STIMULI
**************************************************************************************************************
**************************************************************************************************************

<picture congruentStim>
/ items = ("heart.jpg")
/ size = (parameters.picSize, parameters.picSize)
/ erase = false
</picture>

<picture incongruentStim>
/ items = ("flower.jpg")
/ size = (parameters.picSize, parameters.picSize)
/ erase = false
</picture>

<text fixation>
/ items = ("+")
/ fontstyle = ("Arial", parameters.fixationSize, false, false, false, false, 5, 1)
/ position = (50%, 50%)
/ erase = false
/ vjustify = center
</text>



**************************************************************************************************************
**************************************************************************************************************
	LISTS	
**************************************************************************************************************
**************************************************************************************************************

Note: list randomly (without replacement) selects 1 = left or 2 = right position for congruent trials in a block.
The poolsize is set under the relevant block. 
Default: 
Congruent block - poolsize is 20 (10 hearts on the left, 10 on the right)
Mixed block - poolsize is 10 (5 hearts on the left, 5 on the right)
<list positions_congruent>
/ items = (1, 2)
/ replace = false
/ resetinterval = 0
</list>

Note: list randomly (without replacement) selects 1 = left or 2 = right position for congruent trials in a block.
The poolsize is set under the relevant block. 
Default: 
Congruent block - poolsize is 20 (10 flowers on the left, 10 on the right)
Mixed block - poolsize is 10 (5 flowers on the left, 5 on the right)
<list positions_incongruent>
/ items = (1, 2)
/ replace = false
/ resetinterval = 0
</list>

Note: list randomly (without replacement) selects 1 (congruent) and 2 (incongruent) trials for the mixed block
The poolsize is set under block.
Default: script runs 10 congruent and 10 incongruent trials
<list mixed>
/ items = (1, 2)
/ replace = false
/ resetinterval = 0
/ maxrunsize = 3
</list>

*************************************************
Data Lists: used for descriptive statistics
store correct latencies/accuracy data
fill up during runtime
*************************************************

Note: list stores 1 = correct response; 0 = incorrect response for each relevant trial
any response coded as an error is automatically coded as 0
<list ACC_practice>
</list>

Note: list stores 1 = correct response; 0 = incorrect response for each relevant trial
any response coded as an error is automatically coded as 0
<list ACC>
</list>

Note: list stores the latency of correct responses for each relevant trial
<list RT>
</list>

Note: list stores 1 = correct response; 0 = incorrect response for each relevant trial
any response coded as an error is automatically coded as 0
<list ACC_congruent>
</list>

Note: list stores the latency of correct responses for each relevant trial
<list RT_congruent>
</list>

Note: list stores 1 = correct response; 0 = incorrect response for each relevant trial
any response coded as an error is automatically coded as 0
<list ACC_incongruent>
</list>

Note: list stores the latency of correct responses for each relevant trial
<list RT_incongruent>
</list>

Note: list stores 1 = correct response; 0 = incorrect response for each relevant trial
any response coded as an error is automatically coded as 0
<list ACC_mixed>
</list>

Note: list stores the latency of correct responses for each relevant trial
<list RT_mixed>
</list>

Note: list stores 1 = correct response; 0 = incorrect response for each relevant trial
any response coded as an error is automatically coded as 0
<list ACC_switch>
</list>

Note: list stores the latency of correct responses for each relevant trial
<list RT_switch>
</list>

Note: list stores 1 = correct response; 0 = incorrect response for each relevant trial
any response coded as an error is automatically coded as 0
<list ACC_nonswitch>
</list>

Note: list stores the latency of correct responses for each relevant trial
<list RT_nonswitch>
</list>

**************************************************************************************************************
**************************************************************************************************************
	TRIALS: Practice
**************************************************************************************************************
**************************************************************************************************************

<trial selectTrial_practice>
/ stimulustimes = [0 = clearscreen, fixation]
/ branch = [
	if (values.condition == 1){
		trial.congruent_practice;
	} else if (values.condition == 2){
		trial.incongruent_practice;
	} else {
		if (list.mixed.nextvalue == 1){
			trial.congruent_practice;
		} else {
			trial.incongruent_practice;
		};
	};
]
/ trialduration = parameters.iti
/ recorddata = false
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ correctresponse = (noresponse)
/ response = correct
</trial>


<trial congruent_practice>
/ ontrialbegin = [
	values.prevCongruence = values.congruence;
	values.congruence = 1;
	if (values.prevCongruence == values.congruence || values.prevCongruence == 0){
		values.switch = 0;
	} else {
		if (values.prevCongruence)
		values.switch = 1;
		values.countSwitch += 1;
	};
	values.position = list.positions_congruent.nextvalue;
	if (values.position == 1){
		picture.congruentStim.hposition = parameters.left_x;
	} else {
		picture.congruentStim.hposition = parameters.right_x;
	};
	
]
/ stimulustimes = [0 = congruentStim]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ iscorrectresponse = [
	(values.position == 1 && trial.congruent_practice.response == parameters.leftkey) ||
	(values.position == 2 && trial.congruent_practice.response == parameters.rightkey)	
]
/ ontrialend = [
	list.ACC_practice.appenditem(trial.congruent_practice.correct);

]
/ timeout = values.stimDuration
/ branch = [
	if (trial.congruent_practice.error){
		trial.repeat_congruent;
	} else {
		trial.posFeedback;
	};
]
</trial>

<trial repeat_congruent>
/ ontrialbegin = [
	if (trial.congruent_practice.response == 0){
		trial.repeat_congruent.insertstimulusframe(text.noResponseText, 1);
	};
	
	if (values.position == 1){
		trial.repeat_congruent.insertstimulusframe(video.pressleft, 1);	
	} else {
		trial.repeat_congruent.insertstimulusframe(video.pressright, 1);		
	};
]
/ stimulusframes = [1 = congruentTask2, reminder_congruent, reminder_congruent_audio]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ iscorrectresponse = [
	(values.position == 1 && trial.repeat_congruent.response == parameters.leftkey) ||
	(values.position == 2 && trial.repeat_congruent.response == parameters.rightkey)	
]
/ ontrialend = [
	trial.repeat_congruent.resetstimulusframes();
]
/ response = correct
/ branch = [
	trial.posFeedback;
]
</trial>

<trial incongruent_practice>
/ ontrialbegin = [
	values.prevCongruence = values.congruence;
	values.congruence = 2;
	if (values.prevCongruence == values.congruence || values.prevCongruence == 0){
		values.switch = 0;
	} else {
		values.switch = 1;
		values.countSwitch += 1;
	};	
	values.position = list.positions_incongruent.nextvalue;
	if (values.position == 1){
		picture.incongruentStim.hposition = parameters.left_x;
	} else {
		picture.incongruentStim.hposition = parameters.right_x;
	};
	
]
/ stimulustimes = [0 = incongruentStim]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ iscorrectresponse = [
	(values.position == 1 && trial.incongruent_practice.response == parameters.rightkey) ||
	(values.position == 2 && trial.incongruent_practice.response == parameters.leftkey)	
]
/ ontrialend = [
	list.ACC_practice.appenditem(trial.incongruent_practice.correct);
]
/ timeout = values.stimDuration
/ branch = [
	if (trial.incongruent_practice.error){
		trial.repeat_incongruent;
	} else {
		trial.posFeedback;
	};
]
</trial>

<trial repeat_incongruent>
/ ontrialbegin = [
	if (trial.incongruent_practice.response == 0){
		trial.repeat_incongruent.insertstimulusframe(text.noResponseText, 1);
	};
	
	if (values.position == 1){
		trial.repeat_incongruent.insertstimulusframe(video.pressright, 1);
	} else {
		trial.repeat_incongruent.insertstimulusframe(video.pressleft, 1);
	};
]
/ stimulusframes = [1 = incongruentTask2, reminder_incongruent, reminder_incongruent_audio]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ iscorrectresponse = [
	(values.position == 1 && trial.repeat_incongruent.response == parameters.rightkey) ||
	(values.position == 2 && trial.repeat_incongruent.response == parameters.leftkey)	
]
/ ontrialend = [
	trial.repeat_incongruent.resetstimulusframes();
]
/ response = correct
/ branch = [
	trial.posFeedback;
]
</trial>


<trial posFeedback>
/ stimulusframes = [1 = Feedback, Feedback_audio]
/ trialduration = 0
/ recorddata = false
/ branch = [
	trial.selectTrial_practice;
]
</trial>
**************************************************************************************************************
**************************************************************************************************************
	TRIALS: Test	
**************************************************************************************************************
**************************************************************************************************************

<trial selectTrial>
/ stimulustimes = [0 = clearscreen, fixation]
/ branch = [
	if (values.condition == 1){
		trial.congruent;
	} else if (values.condition == 2){
		trial.incongruent;
	} else {
		if (list.mixed.nextvalue == 1){
			trial.congruent;
		} else {
			trial.incongruent;
		};
	};
]
/ trialduration = parameters.iti
/ recorddata = false
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ correctresponse = (noresponse)
/ response = correct
</trial>


<trial congruent>
/ ontrialbegin = [
	values.prevCongruence = values.congruence;
	values.congruence = 1;
	if (values.prevCongruence == values.congruence || values.prevCongruence == 0){
		values.switch = 0;
	} else {
		if (values.prevCongruence)
		values.switch = 1;
		values.countSwitch += 1;
	};
	values.position = list.positions_congruent.nextvalue;
	if (values.position == 1){
		picture.congruentStim.hposition = parameters.left_x;
	} else {
		picture.congruentStim.hposition = parameters.right_x;
	};
	
]
/ stimulustimes = [0 = congruentStim]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ iscorrectresponse = [
	(values.position == 1 && trial.congruent.response == parameters.leftkey) ||
	(values.position == 2 && trial.congruent.response == parameters.rightkey)	
]
/ ontrialend = [
	list.ACC.appenditem(trial.congruent.correct);
	if (trial.congruent.correct){
		list.RT.appenditem(trial.congruent.latency);
	};
	
	if (values.condition == 1){
		list.ACC_congruent.appenditem(trial.congruent.correct);
		if (trial.congruent.correct){
			list.RT_congruent.appenditem(trial.congruent.latency);
		};
	} else if (values.condition == 3){
		list.ACC_mixed.appenditem(trial.congruent.correct);
		if (trial.congruent.correct){
			list.RT_mixed.appenditem(trial.congruent.latency);
		};
		if (values.switch == 1){
			list.ACC_switch.appenditem(trial.congruent.correct);
			if (trial.congruent.correct){
				list.RT_switch.appenditem(trial.congruent.latency);
			};
		} else {
			list.ACC_nonswitch.appenditem(trial.congruent.correct);
			if (trial.congruent.correct){
				list.RT_nonswitch.appenditem(trial.congruent.latency);
			};
		};
	};
]
/ timeout = values.stimDuration
/ branch = [
	trial.selectTrial;
]
</trial>


<trial incongruent>
/ ontrialbegin = [
	values.prevCongruence = values.congruence;
	values.congruence = 2;
	if (values.prevCongruence == values.congruence || values.prevCongruence == 0){
		values.switch = 0;
	} else {
		values.switch = 1;
		values.countSwitch += 1;
	};	
	values.position = list.positions_incongruent.nextvalue;
	if (values.position == 1){
		picture.incongruentStim.hposition = parameters.left_x;
	} else {
		picture.incongruentStim.hposition = parameters.right_x;
	};
	
]
/ stimulustimes = [0 = incongruentStim]
/ validresponse = (parameters.leftkey, parameters.rightkey)
/ iscorrectresponse = [
	(values.position == 1 && trial.incongruent.response == parameters.rightkey) ||
	(values.position == 2 && trial.incongruent.response == parameters.leftkey)	
]
/ ontrialend = [
	list.ACC.appenditem(trial.incongruent.correct);
	if (trial.incongruent.correct){
		list.RT.appenditem(trial.incongruent.latency);
	};
	
	if (values.condition == 2){
		list.ACC_incongruent.appenditem(trial.incongruent.correct);
		if (trial.incongruent.correct){
			list.RT_incongruent.appenditem(trial.incongruent.latency);
		};
	} else if (values.condition == 3){
		list.ACC_mixed.appenditem(trial.incongruent.correct);
		if (trial.incongruent.correct){
			list.RT_mixed.appenditem(trial.incongruent.latency);
		};
		if (values.switch == 1){
			list.ACC_switch.appenditem(trial.incongruent.correct);
			if (trial.incongruent.correct){
				list.RT_switch.appenditem(trial.incongruent.latency);
			};
		} else {
			list.ACC_nonswitch.appenditem(trial.incongruent.correct);
			if (trial.incongruent.correct){
				list.RT_nonswitch.appenditem(trial.incongruent.latency);
			};
		};
	};
]
/ timeout = values.stimDuration
/ branch = [
	trial.selectTrial;
]
</trial>

**************************************************************************************************************
**************************************************************************************************************
	BLOCKS
**************************************************************************************************************
**************************************************************************************************************

<block congruent_intro>
/ trials = [
	1 = intro1_congruent; 
	2 = intro2_congruent; 
	3 = intro3_congruent;
	4 = intro4_congruent;
	5 = intro5_congruent;
	6 = intro6_congruent;
	]
</block>


<block congruent_practice>
/ stop = [
	trial.selectTrial_practice.trialcount > parameters.numberPracticeTrials;
]
/ onblockbegin = [
	values.countCongruent += 1;
	list.ACC_practice.reset();
	values.condition = 1;
	list.positions_congruent.poolsize = parameters.numberPracticeTrials;
	list.positions_congruent.reset();
	values.stimDuration = parameters.stimDuration_simpleBlock;
	values.congruence = 0;
]
/ trials = [1 = selectTrial_practice]
/ onblockend = [
	if (values.practiceACC_congruent < list.ACC_practice.mean){
		values.practiceACC_congruent = list.ACC_practice.mean;	
	};
]
/ branch = [
	if (list.ACC_practice.mean >= parameters.minPracticeACC){
		values.passCongruent = 1;
	} else if (list.ACC_practice.mean < parameters.minPracticeACC && values.countCongruent < parameters.maxPracticeRepeats){
		block.congruent_practice;
	} else if (!monkey.monkeymode){
		block.prematureEnd;
	};
]
</block>

<block congruent>
/ stop = [
	trial.selectTrial.trialcount > parameters.numberTestTrials;
]
/ onblockbegin = [
	values.condition = 1;
	list.ACC_practice.reset();
	list.positions_congruent.poolsize = parameters.numberTestTrials;
	list.positions_congruent.reset();
	values.stimDuration = parameters.stimDuration_simpleBlock;
	values.congruence = 0;
]
/ trials = [1 = testStart; 2 = selectTrial]
</block>

<block incongruent_intro>
/ trials = [
	1 = intro1_incongruent; 
	2 = intro2_incongruent; 
	3 = intro3_incongruent;
	4 = intro4_incongruent;
	5 = intro5_incongruent;
	6 = intro6_incongruent;
	]
</block>

<block incongruent_practice>
/ stop = [
	trial.selectTrial_practice.trialcount > parameters.numberPracticeTrials;
]
/ onblockbegin = [
	values.countIncongruent += 1;
	list.ACC_practice.reset();
	values.condition = 2;
	list.positions_incongruent.poolsize = parameters.numberPracticeTrials;
	list.positions_incongruent.reset();
	values.stimDuration = parameters.stimDuration_simpleBlock;
	values.congruence = 0;
]
/ trials = [1 = selectTrial_practice]
/ onblockend = [
	if (values.practiceACC_incongruent < list.ACC_practice.mean){
		values.practiceACC_incongruent = list.ACC_practice.mean;	
	};
]
/ branch = [
	if (list.ACC_practice.mean >= parameters.minPracticeACC){
		values.passInCongruent = 1;
	} else if (list.ACC_practice.mean < parameters.minPracticeACC && values.countInCongruent < parameters.maxPracticeRepeats){
		block.incongruent_practice;
	} else if (!monkey.monkeymode){
		block.prematureEnd;
	};
]
</block>


<block incongruent>
/ stop = [
	trial.selectTrial.trialcount > parameters.numberTestTrials;
]
/ onblockbegin = [
	values.condition = 2;
	list.ACC_practice.reset();
	list.positions_incongruent.poolsize = parameters.numberTestTrials;
	list.positions_incongruent.reset();
	values.stimDuration = parameters.stimDuration_simpleBlock;
	values.congruence = 0;
]
/ trials = [1 = testStart; 2 = selectTrial]
</block>

<block mixed_intro>
/ trials = [
	1 = intro1_mixed; 
	2 = intro2_mixed; 
	3 = intro3_mixed;
	4 = intro4_mixed;
	5 = intro5_mixed;
	6 = intro6_mixed;
	7 = intro7_mixed;
	8 = intro8_mixed;
]
</block>

<block mixed_practice>
/ stop = [
	trial.selectTrial_practice.trialcount > parameters.numberPracticeTrials;
]
/ onblockbegin = [
	values.countMixed += 1;
	list.ACC_practice.reset();
	values.condition = 3;
	list.positions_incongruent.poolsize = parameters.numberPracticeTrials/2;
	list.positions_incongruent.reset();
	list.positions_congruent.poolsize = parameters.numberPracticeTrials/2;
	list.positions_congruent.reset();	
	values.stimDuration = parameters.stimDuration_mixedBlock;
	values.congruence = 0;
]
/ trials = [1 = selectTrial_practice]
/ onblockend = [
	if (values.practiceACC_mixed < list.ACC_practice.mean){
		values.practiceACC_mixed = list.ACC_practice.mean;	
	};
]
/ branch = [
	if (list.ACC_practice.mean >= parameters.minPracticeACC){
		values.passMixed = 1;
	} else if (list.ACC_practice.mean < parameters.minPracticeACC && values.countMixed < parameters.maxPracticeRepeats){
		block.mixed_practice;
	} else if (!monkey.monkeymode){
		block.prematureEnd;
	};
]
</block>

<block mixed>
/ stop = [
	trial.selectTrial.trialcount > parameters.numberTestTrials;
]
/ onblockbegin = [
	values.condition = 3;
	list.ACC_practice.reset();
	list.mixed.poolsize = parameters.numberTestTrials;	
	list.positions_incongruent.poolsize = parameters.numberTestTrials/2;
	list.positions_incongruent.reset();
	list.positions_congruent.poolsize = parameters.numberTestTrials/2;
	list.positions_congruent.reset();	
	values.stimDuration = parameters.stimDuration_mixedBlock;
	values.congruence = 0;
	values.countSwitch = 0;
]
/ trials = [1 = testStart; 2 = selectTrial]
</block>

<block prematureEnd>
/ trials = [1 = finish]
/ onblockend = [
	script.abort();
]
</block>

<block finish>
/ trials = [1 = finish]
</block>


**************************************************************************************************************
**************************************************************************************************************
	EXPERIMENT 
**************************************************************************************************************
**************************************************************************************************************

<expt>
/ blocks = [
	1 = congruent_intro;
	2 = congruent_practice;
	3 = congruent;
	4 = incongruent_intro;
	5 = incongruent_practice;
	6 = incongruent;
	7 = mixed_intro;
	8 = mixed_practice;
	9 = mixed;
	10 = finish;
]
/ onexptend = [

	values.completed = 1;
]
</expt>

**************************************************************************************************************
												End of File
**************************************************************************************************************