stroop-task

stroop-task.js

define(['timeAPI'], function(APIconstructor) {

	var API = new APIconstructor();

	API.addSettings('canvas',{
		textSize: 5
	});

	API.addStimulusSets('red',[
		{media:'Red', css:{color:'red'}},
		{media:'Blue', css:{color:'red'}},
		{media:'Green', css:{color:'red'}}
	]);

	API.addStimulusSets('blue',[
		{media:'Red', css:{color:'blue'}},
		{media:'Blue', css:{color:'blue'}},
		{media:'Green', css:{color:'blue'}}
	]);

	API.addStimulusSets('green',[
		{media:'Red', css:{color:'green'}},
		{media:'Blue', css:{color:'green'}},
		{media:'Green', css:{color:'green'}}
	]);

	API.addStimulusSets('error',[
		{handle:'error',media:'X', css:{fontSize:'2em',color:'#FF0000'}, location:{top:70}}
	]);

	API.addTrialSets('base',[{
		input: [
			{handle:'red',on:'keypressed',key:'1'},
			{handle:'blue',on:'keypressed',key:'2'},
			{handle:'green',on:'keypressed',key:'3'}
		],
		layout: [
			{media:'1',location:{left:2,top:2},css:{background:'red',padding:'2%',fontSize:'1.5em'}},
			{media:'2',location:{top:2},css:{background:'blue',padding:'2%',fontSize:'1.5em'}},
			{media:'3',location:{right:2,top:2},css:{background:'green',padding:'2%',fontSize:'1.5em'}}
		],
		interactions: [
			/* Display the target stimulus. */
			{
				conditions:[{type:'begin'}],
				actions: [{type:'showStim', handle: 'target'}]
			},

			// ### Error feedback
			// Lets add error feedback to our task.

			// Above, we created the error stimulus. This creates a stimulus that displays a red X at the bottom of the screen.

			// Now that we have the error stimulus in place we can add the instruction how to display it.
			// On incorrect responses we will display the error feedback, and trigger the end of the trial only after another 250 miliseconds.

			/* Correct response actions */
			{
				conditions: [
					{type:'inputEqualsTrial',property:'group'}
				],
				actions: [
					{type:'setTrialAttr', setter:{score:1}},
					{type:'log'},
					{type:'trigger', handle:'ITI'}
				]
			},

			/* Incorrect response actions */
			{
				conditions: [
					{type:'inputEqualsTrial',property:'group',negate:true},
					{type:'inputEquals',value:['red','blue','green']}
				],
				actions: [
					{type:'setTrialAttr', setter:{score:0}},
					{type:'log'},
					{type:'showStim', handle:'error'},
					{type:'removeInput',handle:['red','blue','green']},
					{type:'trigger', handle:'ITI', duration:500}
				]
			},

			// There are several changes done here to achieve this task.

			// First, all the end trial actions have move into an interaction of their own (see below), that is activated when `ITI` is triggered.
			// Second, the correct response now triggers the ITI immediately.
			// Third, The incorrect response first displays the error feedback (`showStim`) and only after 500 milliseconds triggers the ITI.

			// You should also note that the `hideStim` action within the ITI interaction uses the handle `'All'`. When you want to refer to all the stimuli in a trial you can use the handle `'All'` and all stimuli will be affected.

			// ### Inter trial interval
			// We add an inter trial interval (ITI).
			// The way we are going to do this is by adding a set interval to the end of each trial.
			// Instead of directly calling the `endTrial` action, we will trigger a timeout, and end the trial from it.
			// While waiting for the trial to end we want to prevent users from responding again.
			// Note that we only need to do this to the *base* trial, all other trials inherit everything from it...

			/* Inter trial interval */
			{
				conditions: [{type:'inputEquals', value:'ITI'}],
				actions:[
					{type:'hideStim',handle:'All'},
					{type:'removeInput',handle:['red','blue','green']},
					{type:'trigger', handle:'end',duration:500}
				]
			},

			// We've added three actions to each of the responses.
			// `hideStim` hides the target stimulus so that we see a blank screen as soon as a response is made.
			// `removeInput` removes the input listeners that have the handles *red*, *blue* and *green*, this prevents users from giving any further responses.
			// `trigger` triggers an internal player event as if the user has committed an action.
			// In this case, it triggers an event with the input handle `end` after a `duration` of 500 milliseconds.

			// Furthermore, we've added an interaction that responds to the `end` event, that ends the trial.
			// Note that the users can not trigger the `end` event directly, only through the events that were exposed to them using the `keypressed` input.

			/* End trial */
			{
				conditions: [{type:'inputEquals', value:'end'}],
				actions:[
					{type:'endTrial'}
				]
			}


		]
	}]);

	// Finaly, we need to add it to each of the specific color trials.
	// We can't add it to the *base* trial because the specific color trials make changes to `stimuli` and would overwrite it.

	API.addTrialSets('red',[{
		inherit:'base',
		data: {group:'red'},
		stimuli: [
			{inherit:{set:'red',type:'exRandom'}, handle:'target'},
			{inherit:'error'}
		]
	}]);

	API.addTrialSets('blue',[{
		inherit:'base',
		data: {group:'blue'},
		stimuli: [
			{inherit:{set:'blue',type:'exRandom'}, handle:'target'},
			{inherit:'error'}
		]
	}]);

	API.addTrialSets('green',[{
		inherit:'base',
		data: {group:'green'},
		stimuli: [
			{inherit:{set:'green',type:'exRandom'}, handle:'target'},
			{inherit:'error'}
		]
	}]);

	// ### Sequence

	API.addSequence([
		{
			mixer: 'random',
			data: [
				{
					mixer: 'repeat',
					times: 20,
					data: [
						{inherit:'red'},
						{inherit:'blue'},
						{inherit:'green'}
					]
				}
			]
		}
	]);

	// Return script
	return API.script;
});
Last modified March 11, 2021: setup hugo (11980dc)