Hello,
I have two questions about adapting the joystick AAT script.

1. I need to change the number of trials, and configurations of the trials. I have not been able to figure out how to do this – I am guessing it should be in the SequenceGenerator script, but not sure if anything should also be changed in the main AAT script. The way it is in the script from Milisecond, there are 80 trials (4 categories of images x 2 formats (landscape/portrait) x 10 repetitions). I need to adapt it to be 480 trials (broken into two parts, where the first part is: 2 categories of images x 12 images x 2 formats (landscape/portrait) x 20 repetitions, second part: 2 categories of images x 8 images x 2 formats (landscape/portrait) x 20 repetitions). Of note is that I will also have breaks for participants every 96 trials.
2. I need to change the percentage of time that the images are in landscape/portrait (one experimental group will be instructed to pull images towards themselves 90% of the time, and pushing 10%, the other experimental group will be instructed 50/50 pull and push). However, I do not see where I can alter the proportions for “targetformat” which is how landscape/portrait is coded in the script. Perhaps this is because it is “Format A” and “Format B” in the SequenceGenerator script?

Thank you very much as always for any help!

 Hi Dave,
Thank you for your help with this. I have been attempting to address this from your comments as well as prior threads' comments, but my script doesn't seem to be loading properly as I have to do control B to get past the first (blank) page. If you are able to provide me with any feedback as to where I went wrong, that would be greatly appreciated. I've reduced the number of trials in my experiment's methods since previously posting and here is what I am trying to achieve now. I have a feeling it relates to "values.index" but I have had trouble following how to modify it correctly.

Thank you so very much in advance.

2 Parts of my experiment to be run sequentially:
Part 1: 2 categories of ("untrained") images x 8 images x 2 formats (landscape/portrait - same for all participants, not randomizing who sees which format) x 6 repetitions = 192 trials
Part 2: 2 categories of ("trained") images x 12 images x 2 formats x 6 repetitions = 288 trials
There will be instructions telling participants to take a break every 96 trials.

Here's what I have modified in the AAT script template:
<trial AAT_1untrained>
/ ontrialbegin = [
values.selectstimulus = list.category1.nextvalue;
values.targetcategory = 1;
values.targetformat = "l";
picture.targetstimulus.height = values.startheight_A;
values.starttime = script.elapsedtime;
values.endtime = 0;
values.completeRT = 0;
values.changedirection = 0;
values.finalresponse="";
]
/ stimulusframes = [1 = targetstimulus]
/ validresponse = (back, forward)
/ iscorrectresponse = [(values.expcondition == 1 && trial.AAT_1untrained.response == "forward") || (values.expcondition == 2 && trial.AAT_1untrained.response == "back")]
/ ontrialend = [
values.joystick_y = joystick.y;
values.joystick_change = abs(values.joystick_y);
values.trialcode = "AAT_1untrained";
values.RT = trial.AAT_1untrained.latency;
values.correct = trial.AAT_1untrained.correct;
values.stimulus = picture.targetstimulus.currentitem;
if (trial.AAT_1untrained.response == "forward")
values.initialresponse = "PUSH"
else
values.initialresponse = "PULL";
list.accuracy_overall.insertitem(trial.AAT_1untrained.correct,1);
if (trial.AAT_1untrained.correct) {
list.AAT_1untrainedcorrectlatencies.insertitem(trial.AAT_1untrained.latency, 1);
list.latencies_overall.insertitem(trial.AAT_1untrained.latency, 1);
}
]
/ branch = [
if (trial.AAT_1untrained.response == "forward")
trial.decrease
else
trial.increase;
]
/ recorddata = false
</trial>

<trial AAT_2untrained>
/ ontrialbegin = [
values.selectstimulus = list.category2.nextvalue;
values.targetcategory = 1;
values.targetformat = "p";
picture.targetstimulus.height = values.startheight_B;
values.starttime = script.elapsedtime;
values.endtime = 0;
values.completeRT = 0;
values.changedirection = 0;
values.finalresponse="";
]
/ stimulusframes = [1 = targetstimulus]
/ validresponse = (back, forward)
/ iscorrectresponse = [(values.expcondition == 1 && trial.AAT_2untrained.response == "back") || (values.expcondition == 2 && trial.AAT_2untrained.response == "forward")]
/ ontrialend = [
values.joystick_y = joystick.y;
values.joystick_change = abs(values.joystick_y);
values.trialcode = "AAT_2untrained";
values.RT = trial.AAT_2untrained.latency;
values.correct = trial.AAT_2untrained.correct;
values.stimulus = picture.targetstimulus.currentitem;
if (trial.AAT_2untrained.response == "forward")
values.initialresponse = "PUSH"
else
values.initialresponse = "PULL";
list.accuracy_overall.insertitem(trial.AAT_2untrained.correct,1);
if (trial.AAT_2untrained.correct) {
list.AAT_2untrainedcorrectlatencies.insertitem(trial.AAT_2untrained.latency, 1);
list.latencies_overall.insertitem(trial.AAT_2untrained.latency, 1);
}
]
/ branch = [
if (trial.AAT_2untrained.response == "forward")
trial.decrease
else
trial.increase
]
/ recorddata = false
</trial>

<trial AAT_1trained>
/ ontrialbegin = [
values.selectstimulus = list.category2.nextvalue;
values.targetcategory = 1;
values.targetformat = "p";
picture.targetstimulus.height = values.startheight_B;
values.starttime = script.elapsedtime;
values.endtime = 0;
values.completeRT = 0;
values.changedirection = 0;
values.finalresponse="";
]
/ stimulusframes = [1 = targetstimulus]
/ validresponse = (back, forward)
/ iscorrectresponse = [(values.expcondition == 1 && trial.AAT_1trained.response == "back") || (values.expcondition == 2 && trial.AAT_1trained.response == "forward")]
/ ontrialend = [
values.joystick_y = joystick.y;
values.joystick_change = abs(values.joystick_y);
values.trialcode = "AAT_1trained";
values.RT = trial.AAT_1trained.latency;
values.correct = trial.AAT_1trained.correct;
values.stimulus = picture.targetstimulus.currentitem;
if (trial.AAT_1trained.response == "forward")
values.initialresponse = "PUSH"
else
values.initialresponse = "PULL";
list.accuracy_overall.insertitem(trial.AAT_1trained.correct,1);
if (trial.AAT_1trained.correct) {
list.AAT_1trainedcorrectlatencies.insertitem(trial.AAT_1trained.latency, 1);
list.latencies_overall.insertitem(trial.AAT_1trained.latency, 1);
}
]
/ branch = [
if (trial.AAT_1trained.response == "forward")
trial.decrease
else
trial.increase
]
/ recorddata = false
</trial>

<trial AAT_2trained>
/ ontrialbegin = [
values.selectstimulus = list.category2.nextvalue;
values.targetcategory = 1;
values.targetformat = "p";
picture.targetstimulus.height = values.startheight_B;
values.starttime = script.elapsedtime;
values.endtime = 0;
values.completeRT = 0;
values.changedirection = 0;
values.finalresponse="";
]
/ stimulusframes = [1 = targetstimulus]
/ validresponse = (back, forward)
/ iscorrectresponse = [(values.expcondition == 1 && trial.AAT_2trained.response == "back") || (values.expcondition == 2 && trial.AAT_2trained.response == "forward")]
/ ontrialend = [
values.joystick_y = joystick.y;
values.joystick_change = abs(values.joystick_y);
values.trialcode = "AAT_2trained";
values.RT = trial.AAT_2trained.latency;
values.correct = trial.AAT_2trained.correct;
values.stimulus = picture.targetstimulus.currentitem;
if (trial.AAT_2trained.response == "forward")
values.initialresponse = "PUSH"
else
values.initialresponse = "PULL";
list.accuracy_overall.insertitem(trial.AAT_2trained.correct,1);
if (trial.AAT_2trained.correct) {
list.AAT_2trainedcorrectlatencies.insertitem(trial.AAT_2trained.latency, 1);
list.latencies_overall.insertitem(trial.AAT_2trained.latency, 1);
}
]
/ branch = [
if (trial.AAT_2trained.response == "forward")
trial.decrease
else
trial.increase
]
/ recorddata = false
</trial>

<trial AAT_3trained>
/ ontrialbegin = [
values.selectstimulus = list.category2.nextvalue;
values.targetcategory = 1;
values.targetformat = "p";
picture.targetstimulus.height = values.startheight_B;
values.starttime = script.elapsedtime;
values.endtime = 0;
values.completeRT = 0;
values.changedirection = 0;
values.finalresponse="";
]
/ stimulusframes = [1 = targetstimulus]
/ validresponse = (back, forward)
/ iscorrectresponse = [(values.expcondition == 1 && trial.AAT_3trained.response == "back") || (values.expcondition == 2 && trial.AAT_3trained.response == "forward")]
/ ontrialend = [
values.joystick_y = joystick.y;
values.joystick_change = abs(values.joystick_y);
values.trialcode = "AAT_3trained";
values.RT = trial.AAT_3trained.latency;
values.correct = trial.AAT_3trained.correct;
values.stimulus = picture.targetstimulus.currentitem;
if (trial.AAT_3trained.response == "forward")
values.initialresponse = "PUSH"
else
values.initialresponse = "PULL";
list.accuracy_overall.insertitem(trial.AAT_3trained.correct,1);
if (trial.AAT_3trained.correct) {
list.AAT_3trainedcorrectlatencies.insertitem(trial.AAT_3trained.latency, 1);
list.latencies_overall.insertitem(trial.AAT_3trained.latency, 1);
}
]
/ branch = [
if (trial.AAT_3trained.response == "forward")
trial.decrease
else
trial.increase
]
/ recorddata = false
</trial>

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

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>
/ trials = [1-2 = instructions; 3-12 = noreplace(practicetrial_A, practicetrial_B)]
</block>

Note:
The trial sequence is generated by helper script 'AAT_SequenceGenerator.iqx'
!!!! The time to generate the appropriate sequence will differ between participants.
Two alternatives are:
1) use pregenerated sequences.
2) run the experiment with simple random sampling (easiest solution)
-> / trials = [1 = instructions; 2-81 = noreplace(AAT_1, AAT_2)]

<block assessment1_AAT>
/ onblockbegin = [values.index = 0]
/ trials = [1 = instructions; 2-97 = AAT_1untrained; 98 = instructions2; 99-194 = AAT_2untrained]
</block>

<block assessment2_AAT>
/ onblockbegin = [values.index = 0]
/ trials = [1 = instructions; 2-97 = AAT_1trained; 98 = instructions2; 99-194 = AAT_2trained; 195 = instructions2; 196-292 = AAT_3trained]
</block>


**************************************************************************************************************
**************************************************************************************************************
BREAKS
**************************************************************************************************************
**************************************************************************************************************

<text instructions2>
/ items = instructions2
/ select = sequence
/ position = (50%, 50%)
/ fontstyle = ("Arial", 3%, false, false, false, false, 5, 0)
/ txcolor = black
/ resetinterval = 3
/ size = (80%, 80%)
</text>

<item instructions2>
/ 1 = "PLEASE TAKE A FEW MOMENTS TO TAKE A BREAK DURING THE SESSION.
^^
Press press any key on the keyboard when you are ready to continue."
</item>

<trial instructions2>
/ stimulusframes = [1 = instructions2]
/ validresponse = ("anyresponse")
</trial>


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

NOTE:

<expt>
/ subjects = (1 of 1)
/ groupassignment = groupnumber
/ onexptbegin = [
values.expcondition = 1;
values.format1 = "PORTRAIT";
values.format2 = "LANDSCAPE";
values.startheight_A = parameters.Startheight_ratioA*values.Maxheight_px;
values.startheight_B = parameters.Startheight_ratioB* values.Maxheight_px;
]
/ blocks = [
1 = SequenceGenerator;
2 = practice_AAT;
3 = assessment1_AAT;
4 = assessment2_AAT
]
/ postinstructions = (End)
/ onexptend = [values.completed = 1]
</expt>

**********************************************************************************
Relevant parts I have changed in sequence generator:
<list stimcats>

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

I have left all "values" at 0 even though I am wondering if they need to be increased from 80 to be right for 480 trials. Also wondering if the following is mandatory as I don't have a reason to have participants see this screen: 

<text wait>
/items = ("Please wait; we'll be ready shortly")
/ fontstyle = ("Arial", 3.00%, false, false, false, false, 5, 0)
</text>

Thanks for the file. The code as-is does not make use of the generated sequence, so -- right now -- it doesn't really make sense to run the sequence generation block at all. The freezing / blank screen occurs because, as I suspected, the generator runs into an unrecoverable state or endless loop because it cannot create a suitable sequence. Some of that is due to misconfiguration of the various <values>. /totaltrialcount ought to specify the desired length of the sequence, that is the total amount of trials you want to create a sequence for. /count1 to /count8 ought to reflect the desired number of trials for each respective category (it's 10 per category in the original); neither /totaltrialcount nor the /count1 to /count8 values may all be set to zero as in your modification of the sequence generator.

Also note that, if you do change the values for /count1 to /count8, you need to modify the reset logic in <trial selectnumber> accordingly, otherwise they'll end up being reset to the default 10:

/ontrialend = [if (values.reset == true)
{
values.sequence = "";
values.index = 0; values.count_comparecat = 0; values.count_compareformat = 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 = 10; values.count2 = 10; values.count3 = 10; values.count4 = 10; values.count5 = 10; values.count6 = 10; values.count7 = 10; values.count8 = 10;
list.stimcats.reset()
}]

As I've said before, I don't necessarily think relying on the sequence generator is recommendable in your case, especially since you effectively seem to want two separate / distinct sequences (one for the trained, another for the untrained part) with different parameters. I don't see a straightforward way to extend the generator to create such a thing in one go.

I've coded up a stand-alone version the sequence generator that displays the generated sequence and its various parameters on-screen as it occurs in real time. It will alert to you resets as well as successful sequence generation and display the results on the monitor for review. This should make it easier to understand its mechanics, toy around with different settings and modifications and then examine their effects on sequence generation.

Thank you so much again for your help. I think this is going much better now that the sequence generator is not involved. My remaining issues are:

1) How to add repetitions to the trials so the participants see each photo in each format 6 times without the sequence generator

2) Adding breaks every 96 photos (trial: "instructions2") - would I do this by having something such as:
trials 1-96 = noreplace(AAT_1, AAT_2, AAT_3, AAT_4), 97 = instructions2; 98-194 = noreplace(AAT_1, AAT_2, AAT_3, AAT_4)

3) Is this something I delete from the block now that I don't have the sequence generator? "on blockbegin = [values.index = 0]"

Here's what I have so far:

<block practice_AAT>
/ trials = [1-2 = instructions; 3-12 = noreplace(practicetrial_A, practicetrial_B)]
</block>

<block assessment1untrained_AAT>
/ onblockbegin = [values.index = 0]
/ trials = [1 = instructions; 2-33 = noreplace(AAT_1, AAT_2, AAT_3, AAT_4)]
</block>

<block assessment2trained_AAT>
/ onblockbegin = [values.index = 0]
/ trials = [1 = instructions2; 2-33 = noreplace(AAT_5, AAT_6, AAT_7, AAT_8)]
</block>

<expt>
/ subjects = (1 of 1)
/ groupassignment = groupnumber
/ onexptbegin = [
values.expcondition = 1;
values.format1 = "PORTRAIT";
values.format2 = "LANDSCAPE";
values.startheight_A = parameters.Startheight_ratioA*values.Maxheight_px;
values.startheight_B = parameters.Startheight_ratioB* values.Maxheight_px;
]
/ blocks = [
1 = practice_AAT;
2 = assessment1untrained_AAT;
3 = assessment2trained_AAT;
]
/ postinstructions = (End)
/ onexptend = [values.completed = 1]
</expt>

> 1) How to add repetitions to the trials so the participants see each photo in each format 6 times

That is no different than running the requisite amount of trials. Either increase the amount of trials in your existing blocks or run more blocks, each running X amount of trials.

> 2) Adding breaks every 96 photos (trial: "instructions2") - would I do this by having something such as:
> trials 1-96 = noreplace(AAT_1, AAT_2, AAT_3, AAT_4), 97 = instructions2; 98-194 = noreplace(AAT_1, AAT_2, AAT_3, AAT_4)

Yes, or -- if you want an overall noreplace() pool instead of separate ones, you can do

/ trials = [1-96, 98-194 = noreplace(AAT_1, AAT_2, AAT_3, AAT_4); 97 = instructions2]

> 3) Is this something I delete from the block now that I don't have the sequence generator? "on blockbegin = [values.index = 0]"

You can leave that in, it does not make any difference.

Hi Dave,
Thank you again for your help. I deleted "values.index = 0 in the block" because the script wouldn't run with it and now it will run. To show each image 6 times, I made 6 identical blocks but now realize they will go in order of the blocks and not randomize across blocks. The photos from all categories below should all be shown 6 times but in random order. And also, not sure how to make sure the break is in there every 96 photos.

It feels like instead of what I have tried, I need to be making one large block with all 192 photos and somehow specifying to randomize but show all participants each photos 6 times - could you please let me know the command for this and if this makes sense to you? Then I will repeat the procedure for the second half of the assessment, which is identical but with different photos and 288 trials. Thank you again!

main category 1 (threat, untrained) landscape (trial is AAT_1): indices 1-8
main category 1 (threat, untrained) portrait (trial is AAT_2): indices 9-16
main category 2 (neutral, untrained) landscape (trial is AAT_3): indices 17-24
main category 2 (neutral, untrained) portrait (trial is AAT_4): indices 25-32

<block practice_AAT>
/ trials = [1-2 = instructions; 3-12 = noreplace(practicetrial_A, practicetrial_B)]
</block>

<block assessment1untrained_AAT_1>
/ trials = [1 = 33 = noreplace(AAT_1, AAT_2, AAT_3, AAT_4)]
</block>

<block assessment1untrained_AAT_2>
/ trials = [1 = instructions; 2-33 = noreplace(AAT_1, AAT_2, AAT_3, AAT_4)]
</block>

<block assessment1untrained_AAT_3>
/ trials = [1 = instructions; 2-33 = noreplace(AAT_1, AAT_2, AAT_3, AAT_4)]
</block>

<block assessment1untrained_AAT_4>
/ trials = [1 = instructions; 2-33 = noreplace(AAT_1, AAT_2, AAT_3, AAT_4)]
</block>

<block assessment1untrained_AAT_5>
/ trials = [1 = instructions; 2-33 = noreplace(AAT_1, AAT_2, AAT_3, AAT_4)]
</block>

<block assessment1untrained_AAT_6>
/ trials = [1 = instructions; 2-33 = noreplace(AAT_1, AAT_2, AAT_3, AAT_4)]
</block>



/ blocks = [
1 = practice_AAT;
2 = assessment1untrained_AAT_1;
  3 = assessment1untrained_AAT_2;
  4 = assessment1untrained_AAT_3;
  5 = assessment1untrained_AAT_4;
  6 = assessment1untrained_AAT_5;
  7 = assessment1untrained_AAT_6;

The way your images are sampled has nothing to do with the order of the blocks. The code you posted is not relevant to that. You'll want to sample your image items -- i.e. the various indices / item numbers you indicated -- without replacement. If <trial AAT_1> samples indices 1 to 8 from a <list> without replacement, and you run <trial AAT_1> a total of 48 times, then you have 6 repetitions of those 8 images. The same is true for the other categories / indices.

As for running all 192 trials in a single block with a break in-between, see my previous response to your question #2:

/ trials = [1-96, 98-193 = noreplace(AAT_1, AAT_2, AAT_3, AAT_4); 97 = instructions2]

Thank you again! I have changed the code by making just two blocks, one for the first half of assessment which is 192 trials (4 groups of 8 images, each image shown 6 times), and one for second half which is 288 trials (4 groups of 12 images, each shown 6 times). My remaining question about this aspect of the experiment is how can I guarantee that each of the images is shown 6 times each within the randomization scheme? Or can I be assured of this based on the code I do have? Thanks!!


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

<block practice_AAT>
/ trials = [1-2 = instructions; 3-12 = noreplace(practicetrial_A, practicetrial_B)]
</block>

<block assessment1untrained_AAT>
/ trials = [1-96, 98-193 = noreplace(AAT_1, AAT_2, AAT_3, AAT_4); 97, 194 = instructions2]
</block>

<block assessment2trained_AAT>
/ trials = [1-96, 98-193, 195-290 = noreplace(AAT_5, AAT_6, AAT_7, AAT_8); 97, 194 = instructions2]
</block>


**************************************************************************************************************
**************************************************************************************************************
EXPERIMENT
**************************************************************************************************************
**************************************************************************************************************
<expt>
/ subjects = (1 of 1)
/ groupassignment = groupnumber
/ onexptbegin = [
values.expcondition = 1;
values.format1 = "PORTRAIT";
values.format2 = "LANDSCAPE";
values.startheight_A = parameters.Startheight_ratioA*values.Maxheight_px;
values.startheight_B = parameters.Startheight_ratioB* values.Maxheight_px;
]
/ blocks = [
1 = practice_AAT;
2 = assessment1untrained_AAT;
3 = assessment2trained_AAT;
]
/ postinstructions = (End)
/ onexptend = [values.completed = 1]
</expt>

Hi Dave,
Thank you again for your invaluable help last month. We are currently double checking the output from our script to make sure it is running correctly and I noticed an error I am not sure how to solve. The photos shown in the Approach/Avoidance script are sometimes repeated 1 or 2 extra times, and I noticed in the output that when these photos are shown an extra time, they are running under the "trialcode" of "instructions2" rather than "InterTrialInterval" as the other photos are. I am thinking this is because of how I coded the breaks every 96 photos participants are shown - I am just not sure where I went wrong here. Thank you in advance for any help.

Here is how it is coded, please let me know if it would be helpful to attach the output as well.

Code for "instructions2" :
<text instructions2>
/ items = instructions2
/ select = sequence
/ position = (50%, 50%)
/ fontstyle = ("Arial", 3%, false, false, false, false, 5, 0)
/ txcolor = black
/ resetinterval = 3
/ size = (80%, 80%)
</text>

<item instructions2>
/ 1 = "PLEASE TAKE A FEW MOMENTS TO TAKE A BREAK DURING THE SESSION.
^^
Press press any key on the keyboard when you are ready to continue."
</item>

<trial instructions2>
/ stimulusframes = [1 = instructions2]
/ validresponse = ("anyresponse")
</trial>

Blocks:

<block practice_AAT>
/ trials = [1-2 = instructions; 3-12 = noreplace(practicetrial_A, practicetrial_B)]
</block>

<block assessment1untrained_AAT>
/ trials = [1-96, 98-193 = noreplace(AAT_1, AAT_2, AAT_3, AAT_4); 97, 194 = instructions2]
</block>

<block assessment2trained_AAT>
/ trials = [1-96, 98-193, 195-290 = noreplace(AAT_5, AAT_6, AAT_7, AAT_8); 97, 194 = instructions2]
</block>

Also if helpful the way the photos are categorized:
main category 1 (threat, untrained) landscape (1): indices 1-8
main category 1 (threat, untrained) portrait (2): indices 9-16
main category 2 (neutral, untrained) landscape (3): indices 17-24
main category 2 (neutral, untrained) portrait (4): indices 25-32

main category 3 (threat, trained) landscape (5): indices 33-44
main category 3 (threat, trained) portrait (6): indices 45-56
main category 4 (neutral, trained) landscape (7): indices 57-68
main category 4 (neutral, trained) portrait (8): indices 69-80

**8 threat Pictures, untrained, landscape**
<list category1>
/ items = (1, 2, 3, 4, 5, 6, 7, 8,
1, 2, 3, 4, 5, 6, 7, 8,
1, 2, 3, 4, 5, 6, 7, 8,
1, 2, 3, 4, 5, 6, 7, 8,
1, 2, 3, 4, 5, 6, 7, 8,
1, 2, 3, 4, 5, 6, 7, 8)
/ replace = false
</list>

**8 threat Pictures, untrained, portrait**
<list category2>
/ items = (9, 10, 11, 12, 13, 14, 15, 16,
9, 10, 11, 12, 13, 14, 15, 16,
9, 10, 11, 12, 13, 14, 15, 16,
9, 10, 11, 12, 13, 14, 15, 16,
9, 10, 11, 12, 13, 14, 15, 16,
9, 10, 11, 12, 13, 14, 15, 16)
/ replace = false
</list>

**8 Neutral Pictures, untrained, landscape**
<list category3>
/ items = (17, 18, 19, 20, 21, 22, 23, 24,
17, 18, 19, 20, 21, 22, 23, 24,
17, 18, 19, 20, 21, 22, 23, 24,
17, 18, 19, 20, 21, 22, 23, 24,
17, 18, 19, 20, 21, 22, 23, 24,
17, 18, 19, 20, 21, 22, 23, 24)
</list>

**8 Neutral Pictures, untrained, portrait**
<list category4>
/ items = (25, 26, 27, 28, 29, 30, 31, 32,
25, 26, 27, 28, 29, 30, 31, 32,
25, 26, 27, 28, 29, 30, 31, 32,
25, 26, 27, 28, 29, 30, 31, 32,
25, 26, 27, 28, 29, 30, 31, 32,
25, 26, 27, 28, 29, 30, 31, 32)
/ replace = false
</list>

**12 threat Pictures, trained, landscape**
<list category5>
/ items = (33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44)
/ replace = false
</list>

**12 threat Pictures, trained, portrait**
<list category6>
/ items = (45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56)
/ replace = false
</list>

**12 Neutral Pictures, trained, landscape**
<list category7>
/ items = (57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68)
/ replace = false
</list>

**12 Neutral Pictures, trained, portrait**
<list category8>
/ items = (69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80)
/ replace = false
</list>

Thanks for the file. The code as-is does not make use of the generated sequence, so -- right now -- it doesn't really make sense to run the sequence generation block at all. The freezing / blank screen occurs because, as I suspected, the generator runs into an unrecoverable state or endless loop because it cannot create a suitable sequence. Some of that is due to misconfiguration of the various <values>. /totaltrialcount ought to specify the desired length of the sequence, that is the total amount of trials you want to create a sequence for. /count1 to /count8 ought to reflect the desired number of trials for each respective category (it's 10 per category in the original); neither /totaltrialcount nor the /count1 to /count8 values may all be set to zero as in your modification of the sequence generator.

Also note that, if you do change the values for /count1 to /count8, you need to modify the reset logic in <trial selectnumber> accordingly, otherwise they'll end up being reset to the default 10:

/ontrialend = [if (values.reset == true)
{
values.sequence = "";
values.index = 0; values.count_comparecat = 0; values.count_compareformat = 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 = 10; values.count2 = 10; values.count3 = 10; values.count4 = 10; values.count5 = 10; values.count6 = 10; values.count7 = 10; values.count8 = 10;
list.stimcats.reset()
}]

As I've said before, I don't necessarily think relying on the sequence generator is recommendable in your case, especially since you effectively seem to want two separate / distinct sequences (one for the trained, another for the untrained part) with different parameters. I don't see a straightforward way to extend the generator to create such a thing in one go.

Maybe you could explain how you have determined that you're not seeing the right proportions and what the proportions actually are.

From your description I neither understand what proportions you actually want, nor what the proportions actually are.