***************************************************************************************
*********************************************
Stimuli
*********************************************
***************************************************************************************
<item objects>
/1 = "RED.GIF"
/2 = "BLACK.GIF"
/3 = "GREEN.GIF"
/4 = "BLUE.GIF"
/5 = "VIOLET.GIF"
/6 = "YELLOW.GIF"
/7 = "WHITE.GIF"
</item>


***************************************************************************************
*********************************************
Editable Instructions
*********************************************
***************************************************************************************
<instruct>
/windowsize = (90%, 90%)
/ fontstyle = ("Arial", 2.50%, false, false, false, false, 5, 1)
/ txcolor = (black)
/ finishlabel = "Press <Spacebar> to continue"
/ nextkey = (57)
/ nextlabel = "Press <Spacebar> to continue"
/ prevkey = (28)
/ prevlabel = "Press <Enter> to go back"
</instruct>


Note: these instructions are not the originals. Customize.

<page intro_prechange>
Welcome!

^^^In this task you will be shown a 'before' and an 'after' picture. These pictures contain a varying number of objects such as a car, a beetle, a frog etc. 

^^The two pictures are almost identical but for the following: One object in the 'before' picture (e.g. the car) gets replaced with a new object in the 
'after' picture (e.g. a flower). The 'after' picture may also have shifted a little to the right or the left.

^^Your job is to find the objects that were different between the two pictures and identify them in 2 recognition tasks:
^^Task 1: you will be presented 4 objects. One of the objects is the one that was presented in the 'before' picture (e.g. car) but was then replaced 
in the 'after' picture. Your task is to select the object (e.g. car) that was replaced and did not appear in the 'after' picture anymore.

^^^Task 2: you will be presented 4 objects. One of the objects is the one that was NOT present in the 'before' picture (e.g. flower) but appeared
as the replacement in the 'after' pictures. Your task is to select this new object (e.g. flower).

^^You will always be asked to do these 2 recognition tasks in this particular order.

^^^Ready to practice? During practice you will only be presented 4 objects per picture and 
the time the two pictures are presented will be longer than during the actual task.
^^^Press the <SPACEBAR> to start practice.
</page>

<page end>
You have reached the end of the experiment. Thank you for your participation!
</page>


***************************************************************************************
*********************************************
Lists
*********************************************
***************************************************************************************
<list objectnumberinarray>
/items = (1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,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,2,2,2,2,2,2,2,2,2,2,2,2,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,3,3,3,3,3,3,3,3,3,3,3,3,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,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4)
/replace = false
/selectionmode = random
</list>

Used to determine if trial is same trial or different trial
<list sameordifferentarray>
/items = (1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,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,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,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,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2)
/ replace = false
/selectionmode = random
</list>


Note: contains the itemnumbers of all possible array objects
If the possible number of items changes, adjust item list accordingly
<list possiblearrayobjects>
/items = (1, 2, 3, 4, 5, 6, 7)
/replace = false
/selectionrate = always
</list>


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

<data>
/file = "ChangeDetection_rawdata.iqdat"
/columns = [date, time, subject, group, blockcode, blocknum, trialcode, trialnum, values.array_itemnumbers, values.object1, values.object2, 
values.object3, values.object4, values.expcondition, values.numberofobjects, stimulusitem, stimulusitem, stimulusitem, stimulusitem, response, correct, latency]
/separatefiles = true
</data>

<summarydata >
/file = "ChangeBlindness_summary.iqdat"
/columns = [script.startdate, script.starttime, script.subjectid, script.groupid, expressions.overallaccurcacy, expressions.setsize1accuracy, expressions.setsize1hitrate,
expressions.setsize1farate, expressions.setsize1k, expressions.setsize2accuracy, expressions.setsize2hitrate, expressions.setsize2farate, expressions.setsize2k, expressions.setsize3accuracy,
expressions.setsize3hitrate, expressions.setsize3farate, expressions.setsize3k, expressions.setsize4accuracy, expressions.setsize4hitrate, expressions.setsize4farate, expressions.setsize4k]
</summarydata>


*******************************************************************************************************************
*******************************************************************************************************************
	DEFAULTS:
*******************************************************************************************************************
*******************************************************************************************************************
requires Inquisit 4.0.3.0

<defaults>
/minimumversion = "4.0.3.0"
/canvasaspectratio = (4,3)
</defaults>

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

<values>
/runpracticeblock = true

/practice_arraypresentationtime = 100
/test_arraypresentationtime = 100
/array_ISI = 900
/ITI = 1000

/column1_x = 30%
/column2_x = 40%
/column3_x = 50%
/column4_x = 60%
/row1_y = 30%
/row2_y = 40%
/row3_y = 50%
/row4_y = 60%

/expcondition = 0
/practice = 0
/arraypresentationtime = 0
/array_itemnumbers = ""

/numberofobjects = 0
/countobjects = 0

/sameordifferenttrial = 0

/object = 0
/object1 = 0
/object2 = 0
/object3 = 0
/object4 = 0

/testobject = 0
/newobject = 0

/object1_x = 0
/object2_x = 0
/object3_x = 0
/object4_x = 0

/object1_y = 0
/object2_y = 0
/object3_y = 0
/object4_y = 0

/setsize1correct = 0
/setsize2correct = 0
/setsize3correct = 0
/setsize4correct = 0

/setsize1count = 0
/setsize2count = 0
/setsize3count = 0
/setsize4count = 0

/setsize1hits = 0
/setsize2hits = 0
/setsize3hits = 0
/setsize4hits = 0

/setsize1FAs = 0
/setsize2FAs = 0
/setsize3FAs = 0
/setsize4FAs = 0

/setsize1misses = 0
/setsize2misses = 0
/setsize3misses = 0
/setsize4misses = 0

/setsize1CRs = 0
/setsize2CRs = 0
/setsize3CRs = 0
/setsize4CRs = 0

</values>

*******************************************************************************************************************
*******************************************************************************************************************
	EXPRESSIONS
*******************************************************************************************************************
*******************************************************************************************************************
/prechange3_diff: 		difference in values.prechange_hits - values.prechange_FAs for array  number = 3
/postchange3_diff:		difference in values.postchange_hits - values.postchange_FAs for array number = 3
(same for all array numbers 3-16)

<expressions>

/overallaccurcacy = totalpercentcorrect(block.cb)
/setsize1accuracy = values.setsize1correct/values.setsize1count
/setsize2accuracy = values.setsize2correct/values.setsize2count
/setsize3accuracy = values.setsize3correct/values.setsize3count
/setsize4accuracy = values.setsize4correct/values.setsize4count

/setsize1hitrate = values.setsize1hits/(values.setsize1hits + values.setsize1misses)
/setsize1FArate = values.setsize1fas/(values.setsize1fas + values.setsize1crs)

/setsize2hitrate = values.setsize2hits/(values.setsize2hits + values.setsize2misses)
/setsize2FArate = values.setsize2fas/(values.setsize2fas + values.setsize2crs)

/setsize3hitrate = values.setsize3hits/(values.setsize3hits + values.setsize3misses)
/setsize3FArate = values.setsize3fas/(values.setsize3fas + values.setsize3crs)

/setsize4hitrate = values.setsize4hits/(values.setsize4hits + values.setsize4misses)
/setsize4FArate = values.setsize4fas/(values.setsize4fas + values.setsize4crs)

/setsize1k = 1*((expressions.setsize1hitrate-expressions.setsize1farate)/(1-expressions.setsize1farate))
/setsize2k = 2*((expressions.setsize2hitrate-expressions.setsize2farate)/(1-expressions.setsize2farate))
/setsize3k = 3*((expressions.setsize3hitrate-expressions.setsize3farate)/(1-expressions.setsize3farate))
/setsize4k = 4*((expressions.setsize4hitrate-expressions.setsize4farate)/(1-expressions.setsize4farate))

</expressions>


*******************************************************************************************************************
*******************************************************************************************************************
	STIMULI
*******************************************************************************************************************
*******************************************************************************************************************
<picture object1>
/items = objects
/select = values.object1
/hposition = values.object1_x
/vposition = values.object1_y
/size = (20,20)
</picture>

<picture object2>
/items = objects
/select = values.object2
/hposition = values.object2_x
/vposition = values.object2_y
/size = (20,20)
</picture>

<picture object3>
/items = objects
/select = values.object3
/hposition = values.object3_x
/vposition = values.object3_y
/size = (20,20)
</picture>

<picture object4>
/items = objects
/select = values.object4
/hposition = values.object4_x
/vposition = values.object4_y
/size = (20,20)
</picture>

<picture changedobject>
/items = objects
/select = values.newobject
/hposition = values.object1_x
/vposition = values.object1_y
/size = (20,20)
</picture>

<text errorfeedback>
/items = ("That was not correct")
/fontstyle = ("Arial", 5%, false, false, false, false, 5, 1)
/txcolor = (red)
/position = (50%, 50%)
</text>

<text fixation>
/items = ("+")
/fontstyle = ("Arial", 5%, false, false, false, false, 5, 1)
/txcolor = (black)
/position = (50%, 50%)
</text>


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

Note: created during runtime
<list arrayobjects>
/replace = false
/selectionrate = always
</list>


***************************************************
Lists that control screen locations of the objects
***************************************************

Note: lists that assign randomly with replacement the 16 possible matrix coordinates
change x-coordinates here

<list screencoordinates_x>
/items = (values.column1_x, values.column1_x, values.column1_x, values.column1_x, values.column2_x, values.column2_x, values.column2_x, values.column2_x, 
values.column3_x, values.column3_x, values.column3_x, values.column3_x, values.column4_x, values.column4_x, values.column4_x, values.column4_x)
/replace = false
/selectionrate = always
</list>

change corresponding y coordinates here
<list screencoordinates_y>
/items = (values.row1_y, values.row2_y, values.row3_y, values.row4_y, values.row1_y, values.row2_y, values.row3_y, values.row4_y, 
values.row1_y, values.row2_y, values.row3_y, values.row4_y, values.row1_y, values.row2_y, values.row3_y, values.row4_y)
/selectionmode= list.screencoordinates_x.currentindex
/selectionrate = always
</list>


*******************************************************************************************************************
*******************************************************************************************************************
	TRIALS
*******************************************************************************************************************
*******************************************************************************************************************
 
Note: trial.start resets variables at the beginning of each new trial and selects the number
of array items for the current array
<trial start>
/ontrialbegin = [if (values.practice == 1) values.numberofobjects = 4 else values.numberofobjects = list.objectnumberinarray.nextvalue]
/ontrialbegin = [values.countobjects = 0]
/ontrialbegin = [list.arrayobjects.reset(); reset(list.possiblearrayobjects); values.array_itemnumbers = ""]
/ontrialbegin = [values.object1 = 0; values.object2 = 0; values.object3 = 0; values.object4 = 0]
/ontrialbegin = [if (values.practice == 1) values.arraypresentationtime = values.practice_arraypresentationtime else values.arraypresentationtime = values.test_arraypresentationtime]
/timeout = 0
/branch = [trial.createarray]
/recorddata = false
</trial>


Note: trial.createarray selects the itemnumbers of the specified number of array items (3-16) from the entire pool of items 
and stores them into list.arrayobjects.
<trial createarray>
/ontrialbegin = [values.countobjects += 1]
/ontrialbegin = [values.object = list.possiblearrayobjects.nextvalue]
/ontrialbegin = [values.array_itemnumbers = concat(values.array_itemnumbers, values.object)]
/ontrialbegin = [values.array_itemnumbers = concat(values.array_itemnumbers, ",")]
/ontrialbegin = [list.arrayobjects.insertitem(values.object, list.arrayobjects.itemcount+1)]
/timeout = 0
/branch = [if (values.countobjects < values.numberofobjects) trial.createarray else trial.createarray2]
/recorddata = false
</trial>

Note: trial.createarray2 assigns itemnumbers and randomly selected screen coordinates to the specified number of objects as well
as selects the prechanged object, postchanged objects, foils and unrelated objects for the following forced choice tasks.
<trial createarray2>
/ontrialbegin = [if (values.numberofobjects >= 1) {values.object1 = list.arrayobjects.nextvalue; values.object1_x = list.screencoordinates_x.nextvalue; values.object1_y = list.screencoordinates_y.nextvalue}]
/ontrialbegin = [if (values.numberofobjects >= 2) {values.object2 = list.arrayobjects.nextvalue; values.object2_x = list.screencoordinates_x.nextvalue; values.object2_y = list.screencoordinates_y.nextvalue}]
/ontrialbegin = [if (values.numberofobjects >= 3) {values.object3 = list.arrayobjects.nextvalue; values.object3_x = list.screencoordinates_x.nextvalue; values.object3_y = list.screencoordinates_y.nextvalue}]
/ontrialbegin = [if (values.numberofobjects >= 4) {values.object4 = list.arrayobjects.nextvalue; values.object4_x = list.screencoordinates_x.nextvalue; values.object4_y = list.screencoordinates_y.nextvalue}]
/ontrialbegin = [values.testobject = values.object1]
/ontrialbegin = [values.newobject = list.possiblearrayobjects.nextvalue]
/ontrialbegin = [values.sameordifferenttrial = list.sameordifferentarray.nextvalue]
/timeout = 0
/branch = [trial.fixation]
/recorddata = false
</trial>

<trial fixation>
/stimulusframes = [1 = fixation]
/timeout = 500
/branch = [trial.studyarray]
/posttrialpause = 500
/recorddata = false
</trial>


Note: trial.studyarray presents the first array 
<trial studyarray>
/ontrialbegin = [if (values.numberofobjects >= 1) trial.studyarray.insertstimulusframe(picture.object1, 1)]
/ontrialbegin = [if (values.numberofobjects >= 2) trial.studyarray.insertstimulusframe(picture.object2, 1)]
/ontrialbegin = [if (values.numberofobjects >= 3) trial.studyarray.insertstimulusframe(picture.object3, 1)]
/ontrialbegin = [if (values.numberofobjects >= 4) trial.studyarray.insertstimulusframe(picture.object4, 1)]
/ontrialend = [trial.studyarray.resetstimulusframes()]
/timeout = values.arraypresentationtime
/branch = [if (values.sameordifferenttrial == 1) trial.sametrial else trial.differenttrial]
/posttrialpause = values.array_ISI
/recorddata = false
/screencapture = true
</trial>

trial.sametrial presents the same array as studytrial with no objects changed
<trial sametrial >
/inputdevice = keyboard
/ontrialbegin = [if (values.numberofobjects >= 1) {trial.sametrial.insertstimulusframe(picture.object1, 1)}]
/ontrialbegin = [if (values.numberofobjects >= 2) {trial.sametrial.insertstimulusframe(picture.object2, 1)}]
/ontrialbegin = [if (values.numberofobjects >= 3) {trial.sametrial.insertstimulusframe(picture.object3, 1)}]
/ontrialbegin = [if (values.numberofobjects >= 4) {trial.sametrial.insertstimulusframe(picture.object4, 1)}]
/ontrialend = [trial.sametrial.resetstimulusframes()]
/timeout = 2000
/validresponse = ("z", "m")
/correctresponse = ("z")
/ontrialend = [if (values.numberofobjects == 1) values.setsize1count +=1]
/ontrialend = [if (values.numberofobjects == 2) values.setsize2count +=1]
/ontrialend = [if (values.numberofobjects == 3) values.setsize3count +=1]
/ontrialend = [if (values.numberofobjects == 4) values.setsize4count +=1]
/ontrialend = [if (values.numberofobjects == 1 && trial.sametrial.response == "z") {values.setsize1correct +=1; values.setsize1hits +=1}]
/ontrialend = [if (values.numberofobjects == 1 && trial.sametrial.response == "m") values.setsize1misses +=1]
/ontrialend = [if (values.numberofobjects == 2 && trial.sametrial.response == "z") {values.setsize2correct +=1; values.setsize2hits +=1}]
/ontrialend = [if (values.numberofobjects == 2 && trial.sametrial.response == "m") values.setsize2misses +=1]
/ontrialend = [if (values.numberofobjects == 3 && trial.sametrial.response == "z") {values.setsize3correct +=1; values.setsize3hits +=1}]
/ontrialend = [if (values.numberofobjects == 3 && trial.sametrial.response == "m") values.setsize3misses +=1]
/ontrialend = [if (values.numberofobjects == 4 && trial.sametrial.response == "z") {values.setsize4correct +=1; values.setsize4hits +=1}]
/ontrialend = [if (values.numberofobjects == 4 && trial.sametrial.response == "m") values.setsize4misses +=1]
/branch = [if (values.practice == 1 && trial.sametrial.error) trial.errorfeedback else trial.intertrial]
/recorddata = true
/screencapture = true
</trial>

trial.differenttrial presents the array with 1 object changed
<trial differenttrial>
/inputdevice = keyboard
/ontrialbegin = [if (values.numberofobjects >= 1) {trial.differenttrial.insertstimulusframe(picture.changedobject, 1)}]
/ontrialbegin = [if (values.numberofobjects >= 2) {trial.differenttrial.insertstimulusframe(picture.object2, 1)}]
/ontrialbegin = [if (values.numberofobjects >= 3) {trial.differenttrial.insertstimulusframe(picture.object3, 1)}]
/ontrialbegin = [if (values.numberofobjects >= 4) {trial.differenttrial.insertstimulusframe(picture.object4, 1)}]
/validresponse = ("z", "m")
/correctresponse = ("m")
/ontrialend = [if (values.numberofobjects == 1) values.setsize1count +=1]
/ontrialend = [if (values.numberofobjects == 2) values.setsize2count +=1]
/ontrialend = [if (values.numberofobjects == 3) values.setsize3count +=1]
/ontrialend = [if (values.numberofobjects == 4) values.setsize4count +=1]
/ontrialend = [if (values.numberofobjects == 1 && trial.differenttrial.response == "m") {values.setsize1correct +=1; values.setsize1crs +=1}]
/ontrialend = [if (values.numberofobjects == 1 && trial.differenttrial.response == "z") values.setsize1fas +=1]
/ontrialend = [if (values.numberofobjects == 2 && trial.differenttrial.response == "m") {values.setsize2correct +=1; values.setsize2crs +=1}]
/ontrialend = [if (values.numberofobjects == 2 && trial.differenttrial.response == "z") values.setsize2fas +=1]
/ontrialend = [if (values.numberofobjects == 3 && trial.differenttrial.response == "m") {values.setsize3correct +=1; values.setsize3crs +=1}]
/ontrialend = [if (values.numberofobjects == 3 && trial.differenttrial.response == "z") values.setsize3fas +=1]
/ontrialend = [if (values.numberofobjects == 4 && trial.differenttrial.response == "m") {values.setsize4correct +=1; values.setsize4crs +=1}]
/ontrialend = [if (values.numberofobjects == 4 && trial.differenttrial.response == "z") values.setsize4fas +=1]
/recorddata = true
/screencapture = true
/recorddata = true
/screencapture = true
/branch = [if (values.practice == 1 && trial.differenttrial.error) trial.errorfeedback else trial.intertrial]
/timeout = 2000
</trial>


Note: presents an empty screen for a pre-determined time interval between trials (aka the last
forced choice question and the next array)
<trial intertrial>
/recorddata = false
/trialduration = values.ITI
</trial>


******************************
Errorfeedbacktrials: run in during practice
******************************
<trial errorfeedback>
/stimulusframes = [1 = errorfeedback]
/timeout = 500
/recorddata = false
/branch = [trial.intertrial]
</trial>

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

Note: practice block runs 10 trial sequences (with error feedback)
<block practice>
/skip = [values.runpracticeblock == false]
/onblockbegin = [values.practice = 1]
/trials = [1-10 = start]
</block>


Note: test block runs 56 trial sequences
<block CB>
/onblockbegin = [values.practice = 0]
/onblockbegin = [values.setsize1correct = 0; values.setsize1count = 0; values.setsize1crs = 0; values.setsize1fas = 0; values.setsize1hits = 0; values.setsize1misses = 0]
/onblockbegin = [values.setsize2correct = 0; values.setsize2count = 0; values.setsize2crs = 0; values.setsize2fas = 0; values.setsize2hits = 0; values.setsize2misses = 0]
/onblockbegin = [values.setsize3correct = 0; values.setsize3count = 0; values.setsize3crs = 0; values.setsize3fas = 0; values.setsize3hits = 0; values.setsize3misses = 0]
/onblockbegin = [values.setsize4correct = 0; values.setsize4count = 0; values.setsize4crs = 0; values.setsize4fas = 0; values.setsize4hits = 0; values.setsize4misses = 0]
/trials = [1-160 = start]
</block>


*******************************************************************************************************************
*******************************************************************************************************************
	EXPERIMENT
*******************************************************************************************************************
*******************************************************************************************************************
Order of the 2 recognition tasks is counterbalanced by groupnumber


<expt >
/preinstructions = (intro_prechange)
/postinstructions = (end)
/blocks = [1 = practice; 1 = CB]
</expt>

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