------------------------------------------------------------

const metadata = {name: "letters", version: "0.1.0", inverted: false}

let repetitions = 12

let sizes = [200,400,600]

let durations = [60,120,180]

function* measureIntegrity(stimuli,every=5*60) {

// every N seconds, do a flash

let integrityMeta

let elapsedTime = every

for (let s of stimuli) {

if (elapsedTime>=every && s.metadata.block===undefined) {

integrityMeta = {group: r.uuid(), label: "integrity"}

yield new Wait(120, integrityMeta)

yield new Solid(60, "white", integrityMeta)

yield new Wait(240, integrityMeta)

elapsedTime = 0

yield s

} else {

yield s

}

elapsedTime=elapsedTime+s["lifespan"]/120

}

}

let letters = ["C", "D", "H", "K", "N", "O", "R", "S", "V", "Z"]

let x

let y

let stimuli = []

let l

let before

let after

let id

let cohort

for (let i = 0; i < repetitions; i++) {

for (let size of sizes) {

for (let duration of durations) {

cohort = r.uuid(i)

for (let letter of letters) {

id = r.uuid(i)

// block means "do not insert a integrity check before me"

// backgroundColor, letter, x, y, size, color

x = windowWidth/2 - size/2

y = windowHeight/2 + size/2

l = new Letter(duration, "black", letter,x,y,size,

"white", {group: id, cohort: cohort, block: true})

before = new Wait(r.randi(60,120), {group: id})

after = new Wait(r.randi(60,120), {group: id, block: true})

// before + lit + after = lifespan

// this pads the white flash

stimuli.push([before, l, after])

}

}

}

}

r.shuffle(stimuli)

let stimulusGenerator = measureIntegrity(flatten(stimuli))

for (let s of stimulusGenerator) {

yield s

}

const metadata = {name: "letters", version: "0.1.0", inverted: true}

let repetitions = 12

let sizes = [200,400,600]

let durations = [60,120,180]

function* measureIntegrity(stimuli,every=5*60) {

// every N seconds, do a flash

let integrityMeta

let elapsedTime = every

for (let s of stimuli) {

if (elapsedTime>=every && s.metadata.block===undefined) {

integrityMeta = {group: r.uuid(), label: "integrity"}

yield new Solid(120, "white",integrityMeta)

yield new Solid(60, "black", integrityMeta)

yield new Solid(240, "white",integrityMeta)

elapsedTime = 0

yield s

} else {

yield s

}

elapsedTime=elapsedTime+s["lifespan"]/120

}

}

let letters = ["C", "D", "H", "K", "N", "O", "R", "S", "V", "Z"]

let x

let y

let stimuli = []

let l

let before

let after

let id

let cohort

for (let i = 0; i < repetitions; i++) {

for (let size of sizes) {

for (let duration of durations) {

cohort = r.uuid(i)

for (let letter of letters) {

id = r.uuid(i)

// block means "do not insert a integrity check before me"

// backgroundColor, letter, x, y, size, color

x = windowWidth/2 - size/2

y = windowHeight/2 + size/2

l = new Letter(duration, "white", letter,x,y,size,

"black", {group: id, cohort: cohort, block: true})

before = new Solid(r.randi(60,120), "white" {group: id})

after = new Solid(r.randi(60,120), "white" {group: id, block: true})

// before + lit + after = lifespan

// this pads the white flash

stimuli.push([before, l, after])

}

}

}

}

r.shuffle(stimuli)

let stimulusGenerator = measureIntegrity(flatten(stimuli))

for (let s of stimulusGenerator) {

yield s

}

------------------------------------------------------------

const metadata = {name: "acuity", version: "0.3.2"}

function* measureIntegrity(stimuli,every=5*60) {

// every N seconds, do a flash

let integrityMeta

let elapsedTime = every

for (let s of stimuli) {

if (elapsedTime>=every && s.metadata.block===undefined) {

integrityMeta = {group: r.uuid(), label: "integrity"}

yield new Wait(120, integrityMeta)

yield new Solid(60, "white", integrityMeta)

yield new Wait(240, integrityMeta)

elapsedTime = 0

yield s

} else {

yield s

}

elapsedTime=elapsedTime+s["lifespan"]/120

}

}

let widths = [...Array(12).keys()].map(x => (x+1)*10)

let speeds = [...Array(8).keys()].map(x => (1+x)*100)

// 12 angles, offset by 22 degrees to reduce diamond artifact

let angles = [...Array(12).keys()].map(x => (x*2+1)*PI/12)

let stimuli = []

let width

let lit

let lifespan

let group = Array(3)

let id

let before

let after

let solid

for (let speed of speeds) {

for (let width of widths) {

lifespan = calcBarLifespan(speed,width,windowHeight,windowWidth)

id = r.uuid()

for (let angle of angles) {

stimuli.push(new Bar(lifespan,"black",

speed, width, angle, "white", {group: id}))

}

// block means "do not insert a integrity check before me"

lit = ceil(width/speed*120)

solid = new Solid(lit, "white", {group: id, block: true})

before = new Wait(floor((lifespan-lit)/2), {group: id})

after = new Wait(ceil((lifespan-lit)/2), {group: id, block: true})

// before + lit + after = lifespan

// this pads the white flash

stimuli.push([before, solid, after])

}

}

r.shuffle(stimuli)

let stimulusGenerator = measureIntegrity(flatten(stimuli))

for (let s of stimulusGenerator) {

yield s

}

------------------------------------------------------------

// BELOW THIS IS NOT FINISHED

---

// BELOW THIS IS NOT FINISHED

---

// BELOW THIS IS NOT FINISHED