tTraceTest8_lastrun.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
This experiment was created using PsychoPy3 Experiment Builder (v2020.1.3),
    on August 11, 2020, at 17:22
If you publish work using this script the most relevant publication is:

    Peirce J, Gray JR, Simpson S, MacAskill M, Höchenberger R, Sogo H, Kastman E, Lindeløv JK. (2019) 
        PsychoPy2: Experiments in behavior made easy Behav Res 51: 195. 
        https://doi.org/10.3758/s13428-018-01193-y

"""

from __future__ import absolute_import, division

from psychopy import locale_setup
from psychopy import prefs
from psychopy import sound, gui, visual, core, data, event, logging, clock
from psychopy.constants import (NOT_STARTED, STARTED, PLAYING, PAUSED,
                                STOPPED, FINISHED, PRESSED, RELEASED, FOREVER)

import numpy as np  # whole numpy lib is available, prepend 'np.'
from numpy import (sin, cos, tan, log, log10, pi, average,
                   sqrt, std, deg2rad, rad2deg, linspace, asarray)
from numpy.random import random, randint, normal, shuffle
import os  # handy system and path functions
import sys  # to get file system encoding

from psychopy.hardware import keyboard



# Ensure that relative paths start from the same directory as this script
_thisDir = os.path.dirname(os.path.abspath(__file__))
os.chdir(_thisDir)

# Store info about the experiment session
psychopyVersion = '2020.1.3'
expName = 'tTraceTest8'  # from the Builder filename that created this script
expInfo = {'participant': '', 'session': '001'}
dlg = gui.DlgFromDict(dictionary=expInfo, sortKeys=False, title=expName)
if dlg.OK == False:
    core.quit()  # user pressed cancel
expInfo['date'] = data.getDateStr()  # add a simple timestamp
expInfo['expName'] = expName
expInfo['psychopyVersion'] = psychopyVersion

# Data file name stem = absolute path + name; later add .psyexp, .csv, .log, etc
filename = _thisDir + os.sep + u'data/%s_%s_%s' % (expInfo['participant'], expName, expInfo['date'])

# An ExperimentHandler isn't essential but helps with data saving
thisExp = data.ExperimentHandler(name=expName, version='',
    extraInfo=expInfo, runtimeInfo=None,
    originPath='C:\\Users\\Clifton\\Documents\\psych-proj\\tTraceTest8\\tTraceTest8_lastrun.py',
    savePickle=True, saveWideText=True,
    dataFileName=filename)
# save a log file for detail verbose info
logFile = logging.LogFile(filename+'.log', level=logging.EXP)
logging.console.setLevel(logging.WARNING)  # this outputs to the screen, not a file

endExpNow = False  # flag for 'escape' or other condition => quit the exp
frameTolerance = 0.001  # how close to onset before 'same' frame

# Start Code - component code to be run before the window creation

# Setup the Window
win = visual.Window(
    size=[1088, 614], fullscr=True, screen=0, 
    winType='pyglet', allowGUI=False, allowStencil=False,
    monitor='testMonitor', color=[0,0,0], colorSpace='rgb',
    blendMode='avg', useFBO=True, 
    units='height')
# store frame rate of monitor if we can measure it
expInfo['frameRate'] = win.getActualFrameRate()
if expInfo['frameRate'] != None:
    frameDur = 1.0 / round(expInfo['frameRate'])
else:
    frameDur = 1.0 / 60.0  # could not measure, so guess

# create a default keyboard (e.g. to check for escape)
defaultKeyboard = keyboard.Keyboard()

# Initialize components for Routine "setup"
setupClock = core.Clock()
posArray1 = [-0.05,-0.1,-0.15,-0.2,-0.25,-0.3,-0.35,-0.4,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4]
posArray2 = [-0.05,-0.1,-0.15,-0.2,-0.25,-0.3,-0.35,-0.4,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4]



# Initialize components for Routine "instr"
instrClock = core.Clock()
instrText = visual.TextStim(win=win, name='instrText',
    text='The order is 1, A, 2, B, 3, C, 4, D, 5, E, 6, F, 7, G, 8, H. Press space to continue.',
    font='Arial',
    pos=(0, 0), height=0.05, wrapWidth=None, ori=0, 
    color='white', colorSpace='rgb', opacity=1, 
    languageStyle='LTR',
    depth=-1.0);
instrResp = keyboard.Keyboard()

# Initialize components for Routine "trial"
trialClock = core.Clock()
def drawLine(shapeList):
    lines = []
    if not len(shapeList)%2:  # shapes joined
        while len(shapeList):
            pos1 = shapeList.pop()
            pos2 = shapeList.pop()
            lines.append(visual.Line(win, start=pos1.pos, end=pos2.pos))
    if len(lines):
        for line in lines:
            line.setAutoDraw(True)
trialMouse = event.Mouse(win=win)
x, y = [None, None]
trialMouse.mouseClock = core.Clock()
trialCursor = visual.Polygon(
    win=win, name='trialCursor',
    edges=180, size=(0.025, 0.025),
    ori=0, pos=[0,0],
    lineWidth=1, lineColor=[1,1,1], lineColorSpace='rgb',
    fillColor=[1,1,1], fillColorSpace='rgb',
    opacity=1, depth=-2.0, interpolate=True)
trialTarget1 = visual.Polygon(
    win=win, name='trialTarget1',
    edges=180, size=(0.05, 0.05),
    ori=0, pos=[0,0],
    lineWidth=1, lineColor=[1,1,1], lineColorSpace='rgb',
    fillColor=[1,1,1], fillColorSpace='rgb',
    opacity=1.0, depth=-3.0, interpolate=True)
trialTarget2 = visual.Polygon(
    win=win, name='trialTarget2',
    edges=180, size=(0.05, 0.05),
    ori=0, pos=[0,0],
    lineWidth=1, lineColor=[1,1,1], lineColorSpace='rgb',
    fillColor=[1,1,1], fillColorSpace='rgb',
    opacity=1.0, depth=-4.0, interpolate=True)
trialTarget3 = visual.Polygon(
    win=win, name='trialTarget3',
    edges=180, size=(0.05, 0.05),
    ori=0, pos=[0,0],
    lineWidth=1, lineColor=[1,1,1], lineColorSpace='rgb',
    fillColor=[1,1,1], fillColorSpace='rgb',
    opacity=1.0, depth=-5.0, interpolate=True)
trialTarget4 = visual.Polygon(
    win=win, name='trialTarget4',
    edges=180, size=(0.05, 0.05),
    ori=0, pos=[0,0],
    lineWidth=1, lineColor=[1,1,1], lineColorSpace='rgb',
    fillColor=[1,1,1], fillColorSpace='rgb',
    opacity=1.0, depth=-6.0, interpolate=True)
trialTarget5 = visual.Polygon(
    win=win, name='trialTarget5',
    edges=180, size=(0.05, 0.05),
    ori=0, pos=[0,0],
    lineWidth=1, lineColor=[1,1,1], lineColorSpace='rgb',
    fillColor=[1,1,1], fillColorSpace='rgb',
    opacity=1.0, depth=-7.0, interpolate=True)
trialTarget6 = visual.Polygon(
    win=win, name='trialTarget6',
    edges=180, size=(0.05, 0.05),
    ori=0, pos=[0,0],
    lineWidth=1, lineColor=[1,1,1], lineColorSpace='rgb',
    fillColor=[1,1,1], fillColorSpace='rgb',
    opacity=1.0, depth=-8.0, interpolate=True)
trialTarget7 = visual.Polygon(
    win=win, name='trialTarget7',
    edges=180, size=(0.05, 0.05),
    ori=0, pos=[0,0],
    lineWidth=1, lineColor=[1,1,1], lineColorSpace='rgb',
    fillColor=[1,1,1], fillColorSpace='rgb',
    opacity=1.0, depth=-9.0, interpolate=True)
trialTarget8 = visual.Polygon(
    win=win, name='trialTarget8',
    edges=180, size=(0.05, 0.05),
    ori=0, pos=[0,0],
    lineWidth=1, lineColor=[1,1,1], lineColorSpace='rgb',
    fillColor=[1,1,1], fillColorSpace='rgb',
    opacity=1.0, depth=-10.0, interpolate=True)
trialTargetA = visual.Polygon(
    win=win, name='trialTargetA',
    edges=180, size=(0.05, 0.05),
    ori=0, pos=[0,0],
    lineWidth=1, lineColor=[1,1,1], lineColorSpace='rgb',
    fillColor=[1,1,1], fillColorSpace='rgb',
    opacity=1.0, depth=-11.0, interpolate=True)
trialTargetB = visual.Polygon(
    win=win, name='trialTargetB',
    edges=180, size=(0.05, 0.05),
    ori=0, pos=[0,0],
    lineWidth=1, lineColor=[1,1,1], lineColorSpace='rgb',
    fillColor=[1,1,1], fillColorSpace='rgb',
    opacity=1.0, depth=-12.0, interpolate=True)
trialTargetC = visual.Polygon(
    win=win, name='trialTargetC',
    edges=180, size=(0.05, 0.05),
    ori=0, pos=[0,0],
    lineWidth=1, lineColor=[1,1,1], lineColorSpace='rgb',
    fillColor=[1,1,1], fillColorSpace='rgb',
    opacity=1.0, depth=-13.0, interpolate=True)
trialTargetD = visual.Polygon(
    win=win, name='trialTargetD',
    edges=180, size=(0.05, 0.05),
    ori=0, pos=[0,0],
    lineWidth=1, lineColor=[1,1,1], lineColorSpace='rgb',
    fillColor=[1,1,1], fillColorSpace='rgb',
    opacity=1.0, depth=-14.0, interpolate=True)
trialTargetE = visual.Polygon(
    win=win, name='trialTargetE',
    edges=180, size=(0.05, 0.05),
    ori=0, pos=[0,0],
    lineWidth=1, lineColor=[1,1,1], lineColorSpace='rgb',
    fillColor=[1,1,1], fillColorSpace='rgb',
    opacity=1.0, depth=-15.0, interpolate=True)
trialTargetF = visual.Polygon(
    win=win, name='trialTargetF',
    edges=180, size=(0.05, 0.05),
    ori=0, pos=[0,0],
    lineWidth=1, lineColor=[1,1,1], lineColorSpace='rgb',
    fillColor=[1,1,1], fillColorSpace='rgb',
    opacity=1.0, depth=-16.0, interpolate=True)
trialTargetG = visual.Polygon(
    win=win, name='trialTargetG',
    edges=180, size=(0.05, 0.05),
    ori=0, pos=[0,0],
    lineWidth=1, lineColor=[1,1,1], lineColorSpace='rgb',
    fillColor=[1,1,1], fillColorSpace='rgb',
    opacity=1.0, depth=-17.0, interpolate=True)
trialTargetH = visual.Polygon(
    win=win, name='trialTargetH',
    edges=180, size=(0.05, 0.05),
    ori=0, pos=[0,0],
    lineWidth=1, lineColor=[1,1,1], lineColorSpace='rgb',
    fillColor=[1,1,1], fillColorSpace='rgb',
    opacity=1.0, depth=-18.0, interpolate=True)
# Set experiment start values for variable component trialStep
trialStep = 0
trialStepContainer = []
trialText1 = visual.TextStim(win=win, name='trialText1',
    text='1',
    font='Arial',
    pos=[0,0], height=0.03, wrapWidth=None, ori=0, 
    color='black', colorSpace='rgb', opacity=1, 
    languageStyle='LTR',
    depth=-20.0);
trialText2 = visual.TextStim(win=win, name='trialText2',
    text='2',
    font='Arial',
    pos=[0,0], height=0.03, wrapWidth=None, ori=0, 
    color='black', colorSpace='rgb', opacity=1, 
    languageStyle='LTR',
    depth=-21.0);
trialText3 = visual.TextStim(win=win, name='trialText3',
    text='3',
    font='Arial',
    pos=[0,0], height=0.03, wrapWidth=None, ori=0, 
    color='black', colorSpace='rgb', opacity=1, 
    languageStyle='LTR',
    depth=-22.0);
trialText4 = visual.TextStim(win=win, name='trialText4',
    text='4',
    font='Arial',
    pos=[0,0], height=0.03, wrapWidth=None, ori=0, 
    color='black', colorSpace='rgb', opacity=1, 
    languageStyle='LTR',
    depth=-23.0);
trialText5 = visual.TextStim(win=win, name='trialText5',
    text='5',
    font='Arial',
    pos=[0,0], height=0.03, wrapWidth=None, ori=0, 
    color='black', colorSpace='rgb', opacity=1, 
    languageStyle='LTR',
    depth=-24.0);
trialText6 = visual.TextStim(win=win, name='trialText6',
    text='6',
    font='Arial',
    pos=[0,0], height=0.03, wrapWidth=None, ori=0, 
    color='black', colorSpace='rgb', opacity=1, 
    languageStyle='LTR',
    depth=-25.0);
trialText7 = visual.TextStim(win=win, name='trialText7',
    text='7',
    font='Arial',
    pos=[0,0], height=0.03, wrapWidth=None, ori=0, 
    color='black', colorSpace='rgb', opacity=1, 
    languageStyle='LTR',
    depth=-26.0);
trialText8 = visual.TextStim(win=win, name='trialText8',
    text='8',
    font='Arial',
    pos=[0,0], height=0.03, wrapWidth=None, ori=0, 
    color='black', colorSpace='rgb', opacity=1, 
    languageStyle='LTR',
    depth=-27.0);
trialTextA = visual.TextStim(win=win, name='trialTextA',
    text='A',
    font='Arial',
    pos=[0,0], height=0.03, wrapWidth=None, ori=0, 
    color='black', colorSpace='rgb', opacity=1, 
    languageStyle='LTR',
    depth=-28.0);
trialTextB = visual.TextStim(win=win, name='trialTextB',
    text='B',
    font='Arial',
    pos=[0,0], height=0.03, wrapWidth=None, ori=0, 
    color='black', colorSpace='rgb', opacity=1, 
    languageStyle='LTR',
    depth=-29.0);
trialTextC = visual.TextStim(win=win, name='trialTextC',
    text='C',
    font='Arial',
    pos=[0,0], height=0.03, wrapWidth=None, ori=0, 
    color='black', colorSpace='rgb', opacity=1, 
    languageStyle='LTR',
    depth=-30.0);
trialTextD = visual.TextStim(win=win, name='trialTextD',
    text='D',
    font='Arial',
    pos=[0,0], height=0.03, wrapWidth=None, ori=0, 
    color='black', colorSpace='rgb', opacity=1, 
    languageStyle='LTR',
    depth=-31.0);
trialTextE = visual.TextStim(win=win, name='trialTextE',
    text='E',
    font='Arial',
    pos=[0,0], height=0.03, wrapWidth=None, ori=0, 
    color='black', colorSpace='rgb', opacity=1, 
    languageStyle='LTR',
    depth=-32.0);
trialTextF = visual.TextStim(win=win, name='trialTextF',
    text='F',
    font='Arial',
    pos=[0,0], height=0.03, wrapWidth=None, ori=0, 
    color='black', colorSpace='rgb', opacity=1, 
    languageStyle='LTR',
    depth=-33.0);
trialTextG = visual.TextStim(win=win, name='trialTextG',
    text='G',
    font='Arial',
    pos=[0,0], height=0.03, wrapWidth=None, ori=0, 
    color='black', colorSpace='rgb', opacity=1, 
    languageStyle='LTR',
    depth=-34.0);
trialTextH = visual.TextStim(win=win, name='trialTextH',
    text='H',
    font='Arial',
    pos=[0,0], height=0.03, wrapWidth=None, ori=0, 
    color='black', colorSpace='rgb', opacity=1, 
    languageStyle='LTR',
    depth=-35.0);

# Create some handy timers
globalClock = core.Clock()  # to track the time since experiment started
routineTimer = core.CountdownTimer()  # to track time remaining of each (non-slip) routine 

# ------Prepare to start Routine "setup"-------
continueRoutine = True
# update component parameters for each repeat
# keep track of which components have finished
setupComponents = []
for thisComponent in setupComponents:
    thisComponent.tStart = None
    thisComponent.tStop = None
    thisComponent.tStartRefresh = None
    thisComponent.tStopRefresh = None
    if hasattr(thisComponent, 'status'):
        thisComponent.status = NOT_STARTED
# reset timers
t = 0
_timeToFirstFrame = win.getFutureFlipTime(clock="now")
setupClock.reset(-_timeToFirstFrame)  # t0 is time of first possible flip
frameN = -1

# -------Run Routine "setup"-------
while continueRoutine:
    # get current time
    t = setupClock.getTime()
    tThisFlip = win.getFutureFlipTime(clock=setupClock)
    tThisFlipGlobal = win.getFutureFlipTime(clock=None)
    frameN = frameN + 1  # number of completed frames (so 0 is the first frame)
    # update/draw components on each frame
    
    # check for quit (typically the Esc key)
    if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]):
        core.quit()
    
    # check if all components have finished
    if not continueRoutine:  # a component has requested a forced-end of Routine
        break
    continueRoutine = False  # will revert to True if at least one component still running
    for thisComponent in setupComponents:
        if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
            continueRoutine = True
            break  # at least one component has not yet finished
    
    # refresh the screen
    if continueRoutine:  # don't flip if this routine is over or we'll get a blank screen
        win.flip()

# -------Ending Routine "setup"-------
for thisComponent in setupComponents:
    if hasattr(thisComponent, "setAutoDraw"):
        thisComponent.setAutoDraw(False)
# the Routine "setup" was not non-slip safe, so reset the non-slip timer
routineTimer.reset()

# set up handler to look after randomisation of conditions etc
tasks = data.TrialHandler(nReps=5, method='sequential', 
    extraInfo=expInfo, originPath=-1,
    trialList=[None],
    seed=None, name='tasks')
thisExp.addLoop(tasks)  # add the loop to the experiment
thisTask = tasks.trialList[0]  # so we can initialise stimuli with some values
# abbreviate parameter names if possible (e.g. rgb = thisTask.rgb)
if thisTask != None:
    for paramName in thisTask:
        exec('{} = thisTask[paramName]'.format(paramName))

for thisTask in tasks:
    currentLoop = tasks
    # abbreviate parameter names if possible (e.g. rgb = thisTask.rgb)
    if thisTask != None:
        for paramName in thisTask:
            exec('{} = thisTask[paramName]'.format(paramName))
    
    # ------Prepare to start Routine "instr"-------
    continueRoutine = True
    # update component parameters for each repeat
    shuffle(posArray1)
    shuffle(posArray2)
    pos1 = posArray1[0]
    pos2 = posArray2[0]
    pos3 = posArray1[1]
    pos4 = posArray2[1]
    pos5 = posArray1[2]
    pos6 = posArray2[2]
    pos7 = posArray1[3]
    pos8 = posArray2[3]
    pos9 = posArray1[4]
    pos10 = posArray2[4]
    pos11 = posArray1[5]
    pos12 = posArray2[5]
    pos13 = posArray1[6]
    pos14 = posArray2[6]
    pos15 = posArray1[7]
    pos16 = posArray2[7]
    pos17 = posArray1[8]
    pos18 = posArray2[8]
    pos19 = posArray1[9]
    pos20 = posArray2[9]
    pos21 = posArray1[10]
    pos22 = posArray2[10]
    pos23 = posArray1[11]
    pos24 = posArray2[11]
    pos25 = posArray1[12]
    pos26 = posArray2[12]
    pos27 = posArray1[13]
    pos28 = posArray2[13]
    pos29 = posArray1[14]
    pos30 = posArray2[14]
    pos31 = posArray1[15]
    pos32 = posArray2[15]
    instrResp.keys = []
    instrResp.rt = []
    _instrResp_allKeys = []
    # keep track of which components have finished
    instrComponents = [instrText, instrResp]
    for thisComponent in instrComponents:
        thisComponent.tStart = None
        thisComponent.tStop = None
        thisComponent.tStartRefresh = None
        thisComponent.tStopRefresh = None
        if hasattr(thisComponent, 'status'):
            thisComponent.status = NOT_STARTED
    # reset timers
    t = 0
    _timeToFirstFrame = win.getFutureFlipTime(clock="now")
    instrClock.reset(-_timeToFirstFrame)  # t0 is time of first possible flip
    frameN = -1
    
    # -------Run Routine "instr"-------
    while continueRoutine:
        # get current time
        t = instrClock.getTime()
        tThisFlip = win.getFutureFlipTime(clock=instrClock)
        tThisFlipGlobal = win.getFutureFlipTime(clock=None)
        frameN = frameN + 1  # number of completed frames (so 0 is the first frame)
        # update/draw components on each frame
        
        # *instrText* updates
        if instrText.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
            # keep track of start time/frame for later
            instrText.frameNStart = frameN  # exact frame index
            instrText.tStart = t  # local t and not account for scr refresh
            instrText.tStartRefresh = tThisFlipGlobal  # on global time
            win.timeOnFlip(instrText, 'tStartRefresh')  # time at next scr refresh
            instrText.setAutoDraw(True)
        
        # *instrResp* updates
        waitOnFlip = False
        if instrResp.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
            # keep track of start time/frame for later
            instrResp.frameNStart = frameN  # exact frame index
            instrResp.tStart = t  # local t and not account for scr refresh
            instrResp.tStartRefresh = tThisFlipGlobal  # on global time
            win.timeOnFlip(instrResp, 'tStartRefresh')  # time at next scr refresh
            instrResp.status = STARTED
            # keyboard checking is just starting
            waitOnFlip = True
            win.callOnFlip(instrResp.clock.reset)  # t=0 on next screen flip
            win.callOnFlip(instrResp.clearEvents, eventType='keyboard')  # clear events on next screen flip
        if instrResp.status == STARTED and not waitOnFlip:
            theseKeys = instrResp.getKeys(keyList=['space'], waitRelease=False)
            _instrResp_allKeys.extend(theseKeys)
            if len(_instrResp_allKeys):
                instrResp.keys = _instrResp_allKeys[-1].name  # just the last key pressed
                instrResp.rt = _instrResp_allKeys[-1].rt
                # a response ends the routine
                continueRoutine = False
        
        # check for quit (typically the Esc key)
        if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]):
            core.quit()
        
        # check if all components have finished
        if not continueRoutine:  # a component has requested a forced-end of Routine
            break
        continueRoutine = False  # will revert to True if at least one component still running
        for thisComponent in instrComponents:
            if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
                continueRoutine = True
                break  # at least one component has not yet finished
        
        # refresh the screen
        if continueRoutine:  # don't flip if this routine is over or we'll get a blank screen
            win.flip()
    
    # -------Ending Routine "instr"-------
    for thisComponent in instrComponents:
        if hasattr(thisComponent, "setAutoDraw"):
            thisComponent.setAutoDraw(False)
    tasks.addData('instrText.started', instrText.tStartRefresh)
    tasks.addData('instrText.stopped', instrText.tStopRefresh)
    # the Routine "instr" was not non-slip safe, so reset the non-slip timer
    routineTimer.reset()
    
    # set up handler to look after randomisation of conditions etc
    trials = data.TrialHandler(nReps=1, method='sequential', 
        extraInfo=expInfo, originPath=-1,
        trialList=[None],
        seed=None, name='trials')
    thisExp.addLoop(trials)  # add the loop to the experiment
    thisTrial = trials.trialList[0]  # so we can initialise stimuli with some values
    # abbreviate parameter names if possible (e.g. rgb = thisTrial.rgb)
    if thisTrial != None:
        for paramName in thisTrial:
            exec('{} = thisTrial[paramName]'.format(paramName))
    
    for thisTrial in trials:
        currentLoop = trials
        # abbreviate parameter names if possible (e.g. rgb = thisTrial.rgb)
        if thisTrial != None:
            for paramName in thisTrial:
                exec('{} = thisTrial[paramName]'.format(paramName))
        
        # ------Prepare to start Routine "trial"-------
        continueRoutine = True
        # update component parameters for each repeat
        trialCursor.pos = (1.5,1.5)
        trialMouse.pos = (1.5,1.5)
        
        targetOpac1 = 0.25
        targetOpac2 = 0.25
        targetOpac3 = 0.25
        targetOpac4 = 0.25
        targetOpac5 = 0.25
        targetOpac6 = 0.25
        targetOpac7 = 0.25
        targetOpac8 = 0.25
        targetOpacA = 0.25
        targetOpacB = 0.25
        targetOpacC = 0.25
        targetOpacD = 0.25
        targetOpacE = 0.25
        targetOpacF = 0.25
        targetOpacG = 0.25
        targetOpacH = 0.25
        
        trialStep = 1
        steps = []
        shapeList = []
        # setup some python lists for storing info about the trialMouse
        trialMouse.x = []
        trialMouse.y = []
        trialMouse.leftButton = []
        trialMouse.midButton = []
        trialMouse.rightButton = []
        trialMouse.time = []
        gotValidClick = False  # until a click is received
        trialMouse.mouseClock.reset()
        trialTarget1.setPos((pos1, pos2))
        trialTarget2.setPos((pos5, pos6))
        trialTarget3.setPos((pos9, pos10))
        trialTarget4.setPos((pos13, pos14))
        trialTarget5.setPos((pos15, pos16))
        trialTarget6.setPos((pos17, pos18))
        trialTarget7.setPos((pos19, pos20))
        trialTarget8.setPos((pos21, pos22))
        trialTargetA.setPos((pos3, pos4))
        trialTargetB.setPos((pos7, pos8))
        trialTargetC.setPos((pos11, pos12))
        trialTargetD.setPos((pos23, pos24))
        trialTargetE.setPos((pos25, pos26))
        trialTargetF.setPos((pos27, pos28))
        trialTargetG.setPos((pos29, pos30))
        trialTargetH.setPos((pos31, pos32))
        trialText1.setPos((pos1, pos2))
        trialText2.setPos((pos5, pos6))
        trialText3.setPos((pos9, pos10))
        trialText4.setPos((pos13, pos14))
        trialText5.setPos((pos15, pos16))
        trialText6.setPos((pos17, pos18))
        trialText7.setPos((pos19, pos20))
        trialText8.setPos((pos21, pos22))
        trialTextA.setPos((pos3, pos4))
        trialTextB.setPos((pos7, pos8))
        trialTextC.setPos((pos11, pos12))
        trialTextD.setPos((pos23, pos24))
        trialTextE.setPos((pos25, pos26))
        trialTextF.setPos((pos27, pos28))
        trialTextG.setPos((pos29, pos30))
        trialTextH.setPos((pos31, pos32))
        # keep track of which components have finished
        trialComponents = [trialMouse, trialCursor, trialTarget1, trialTarget2, trialTarget3, trialTarget4, trialTarget5, trialTarget6, trialTarget7, trialTarget8, trialTargetA, trialTargetB, trialTargetC, trialTargetD, trialTargetE, trialTargetF, trialTargetG, trialTargetH, trialText1, trialText2, trialText3, trialText4, trialText5, trialText6, trialText7, trialText8, trialTextA, trialTextB, trialTextC, trialTextD, trialTextE, trialTextF, trialTextG, trialTextH]
        for thisComponent in trialComponents:
            thisComponent.tStart = None
            thisComponent.tStop = None
            thisComponent.tStartRefresh = None
            thisComponent.tStopRefresh = None
            if hasattr(thisComponent, 'status'):
                thisComponent.status = NOT_STARTED
        # reset timers
        t = 0
        _timeToFirstFrame = win.getFutureFlipTime(clock="now")
        trialClock.reset(-_timeToFirstFrame)  # t0 is time of first possible flip
        frameN = -1
        
        # -------Run Routine "trial"-------
        while continueRoutine:
            # get current time
            t = trialClock.getTime()
            tThisFlip = win.getFutureFlipTime(clock=trialClock)
            tThisFlipGlobal = win.getFutureFlipTime(clock=None)
            frameN = frameN + 1  # number of completed frames (so 0 is the first frame)
            # update/draw components on each frame
            steps.append(trialStep)
            
            if trialStep == 1:
                CursorTargetDistance = sqrt((trialCursor.pos[0]-trialTarget1.pos[0])**2 + (trialCursor.pos[1]-trialTarget1.pos[1])**2)
                if (CursorTargetDistance < .05):
                    targetOpac1 = 0
                    trialStep = 2
                    shapeList.append(trialTarget1)
                    
            if trialStep == 2:
                CursorTargetDistance = sqrt((trialCursor.pos[0]-trialTargetA.pos[0])**2 + (trialCursor.pos[1]-trialTargetA.pos[1])**2)
                if (CursorTargetDistance < .05):
                    targetOpacA = 0
                    trialStep = 3
                    shapeList.append(trialTargetA)
                    
            if trialStep == 3:
                CursorTargetDistance = sqrt((trialCursor.pos[0]-trialTarget2.pos[0])**2 + (trialCursor.pos[1]-trialTarget2.pos[1])**2)
                if (CursorTargetDistance < .05):
                    targetOpac2 = 0
                    trialStep = 4
                    shapeList.append(trialTargetA)
                    shapeList.append(trialTarget2)
                    
            if trialStep == 4:
                CursorTargetDistance = sqrt((trialCursor.pos[0]-trialTargetB.pos[0])**2 + (trialCursor.pos[1]-trialTargetB.pos[1])**2)
                if (CursorTargetDistance < .05):
                    targetOpacB = 0
                    trialStep = 5
                    shapeList.append(trialTarget2)
                    shapeList.append(trialTargetB)
            
            if trialStep == 5:
                CursorTargetDistance = sqrt((trialCursor.pos[0]-trialTarget3.pos[0])**2 + (trialCursor.pos[1]-trialTarget3.pos[1])**2)
                if (CursorTargetDistance < .05):
                    targetOpac3 = 0
                    trialStep = 6
                    shapeList.append(trialTargetB)
                    shapeList.append(trialTarget3)
                    
            if trialStep == 6:
                CursorTargetDistance = sqrt((trialCursor.pos[0]-trialTargetC.pos[0])**2 + (trialCursor.pos[1]-trialTargetC.pos[1])**2)
                if (CursorTargetDistance < .05):
                    targetOpacC = 0
                    trialStep = 7
                    shapeList.append(trialTarget3)
                    shapeList.append(trialTargetC)
            
            if trialStep == 7:
                CursorTargetDistance = sqrt((trialCursor.pos[0]-trialTarget4.pos[0])**2 + (trialCursor.pos[1]-trialTarget4.pos[1])**2)
                if (CursorTargetDistance < .05):
                    targetOpac4 = 0
                    trialStep = 8
                    shapeList.append(trialTargetC)
                    shapeList.append(trialTarget4)
                    
            if trialStep == 8:
                CursorTargetDistance = sqrt((trialCursor.pos[0]-trialTargetD.pos[0])**2 + (trialCursor.pos[1]-trialTargetD.pos[1])**2)
                if (CursorTargetDistance < .05):
                    targetOpacD = 0
                    trialStep = 9
                    shapeList.append(trialTarget4)
                    shapeList.append(trialTargetD)
                    
            if trialStep == 9:
                CursorTargetDistance = sqrt((trialCursor.pos[0]-trialTarget5.pos[0])**2 + (trialCursor.pos[1]-trialTarget5.pos[1])**2)
                if (CursorTargetDistance < .05):
                    targetOpac5 = 0
                    trialStep = 10
                    shapeList.append(trialTargetD)
                    shapeList.append(trialTarget5)
            
            if trialStep == 10:
                CursorTargetDistance = sqrt((trialCursor.pos[0]-trialTargetE.pos[0])**2 + (trialCursor.pos[1]-trialTargetE.pos[1])**2)
                if (CursorTargetDistance < .05):
                    targetOpacE = 0
                    trialStep = 11
                    shapeList.append(trialTarget5)
                    shapeList.append(trialTargetE)
            
            if trialStep == 11:
                CursorTargetDistance = sqrt((trialCursor.pos[0]-trialTarget6.pos[0])**2 + (trialCursor.pos[1]-trialTarget6.pos[1])**2)
                if (CursorTargetDistance < .05):
                    targetOpac6 = 0
                    trialStep = 12
                    shapeList.append(trialTargetE)
                    shapeList.append(trialTarget6)
            
            if trialStep == 12:
                CursorTargetDistance = sqrt((trialCursor.pos[0]-trialTargetF.pos[0])**2 + (trialCursor.pos[1]-trialTargetF.pos[1])**2)
                if (CursorTargetDistance < .05):
                    targetOpacF = 0
                    trialStep = 13
                    shapeList.append(trialTarget6)
                    shapeList.append(trialTargetF)
                    
            if trialStep == 13:
                CursorTargetDistance = sqrt((trialCursor.pos[0]-trialTarget7.pos[0])**2 + (trialCursor.pos[1]-trialTarget7.pos[1])**2)
                if (CursorTargetDistance < .05):
                    targetOpac7 = 0
                    trialStep = 14
                    shapeList.append(trialTargetF)
                    shapeList.append(trialTarget7)
                    
            if trialStep == 14:
                CursorTargetDistance = sqrt((trialCursor.pos[0]-trialTargetG.pos[0])**2 + (trialCursor.pos[1]-trialTargetG.pos[1])**2)
                if (CursorTargetDistance < .05):
                    targetOpacG = 0
                    trialStep = 15
                    shapeList.append(trialTarget7)
                    shapeList.append(trialTargetG)
            
            if trialStep == 15:
                CursorTargetDistance = sqrt((trialCursor.pos[0]-trialTarget8.pos[0])**2 + (trialCursor.pos[1]-trialTarget8.pos[1])**2)
                if (CursorTargetDistance < .05):
                    targetOpac8 = 0
                    trialStep = 16
                    shapeList.append(trialTargetG)
                    shapeList.append(trialTarget8)
            
            if trialStep == 16:
                CursorTargetDistance = sqrt((trialCursor.pos[0]-trialTargetH.pos[0])**2 + (trialCursor.pos[1]-trialTargetH.pos[1])**2)
                if (CursorTargetDistance < .05):
                    targetOpacH = 0
                    shapeList.append(trialTarget8)
                    shapeList.append(trialTargetH)
                    continueRoutine = False
                    
            drawLine(shapeList)
            
            # *trialMouse* updates
            if trialMouse.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialMouse.frameNStart = frameN  # exact frame index
                trialMouse.tStart = t  # local t and not account for scr refresh
                trialMouse.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialMouse, 'tStartRefresh')  # time at next scr refresh
                trialMouse.status = STARTED
                prevButtonState = [0, 0, 0]  # if now button is down we will treat as 'new' click
            if trialMouse.status == STARTED:  # only update if started and not finished!
                x, y = trialMouse.getPos()
                trialMouse.x.append(x)
                trialMouse.y.append(y)
                buttons = trialMouse.getPressed()
                trialMouse.leftButton.append(buttons[0])
                trialMouse.midButton.append(buttons[1])
                trialMouse.rightButton.append(buttons[2])
                trialMouse.time.append(trialMouse.mouseClock.getTime())
            
            # *trialCursor* updates
            if trialCursor.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialCursor.frameNStart = frameN  # exact frame index
                trialCursor.tStart = t  # local t and not account for scr refresh
                trialCursor.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialCursor, 'tStartRefresh')  # time at next scr refresh
                trialCursor.setAutoDraw(True)
            if trialCursor.status == STARTED:  # only update if drawing
                trialCursor.setPos((trialMouse.getPos()[0], trialMouse.getPos()[1]), log=False)
            
            # *trialTarget1* updates
            if trialTarget1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTarget1.frameNStart = frameN  # exact frame index
                trialTarget1.tStart = t  # local t and not account for scr refresh
                trialTarget1.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTarget1, 'tStartRefresh')  # time at next scr refresh
                trialTarget1.setAutoDraw(True)
            if trialTarget1.status == STARTED:  # only update if drawing
                trialTarget1.setOpacity(targetOpac1, log=False)
            
            # *trialTarget2* updates
            if trialTarget2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTarget2.frameNStart = frameN  # exact frame index
                trialTarget2.tStart = t  # local t and not account for scr refresh
                trialTarget2.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTarget2, 'tStartRefresh')  # time at next scr refresh
                trialTarget2.setAutoDraw(True)
            if trialTarget2.status == STARTED:  # only update if drawing
                trialTarget2.setOpacity(targetOpac2, log=False)
            
            # *trialTarget3* updates
            if trialTarget3.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTarget3.frameNStart = frameN  # exact frame index
                trialTarget3.tStart = t  # local t and not account for scr refresh
                trialTarget3.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTarget3, 'tStartRefresh')  # time at next scr refresh
                trialTarget3.setAutoDraw(True)
            if trialTarget3.status == STARTED:  # only update if drawing
                trialTarget3.setOpacity(targetOpac3, log=False)
            
            # *trialTarget4* updates
            if trialTarget4.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTarget4.frameNStart = frameN  # exact frame index
                trialTarget4.tStart = t  # local t and not account for scr refresh
                trialTarget4.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTarget4, 'tStartRefresh')  # time at next scr refresh
                trialTarget4.setAutoDraw(True)
            if trialTarget4.status == STARTED:  # only update if drawing
                trialTarget4.setOpacity(targetOpac4, log=False)
            
            # *trialTarget5* updates
            if trialTarget5.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTarget5.frameNStart = frameN  # exact frame index
                trialTarget5.tStart = t  # local t and not account for scr refresh
                trialTarget5.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTarget5, 'tStartRefresh')  # time at next scr refresh
                trialTarget5.setAutoDraw(True)
            if trialTarget5.status == STARTED:  # only update if drawing
                trialTarget5.setOpacity(targetOpac5, log=False)
            
            # *trialTarget6* updates
            if trialTarget6.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTarget6.frameNStart = frameN  # exact frame index
                trialTarget6.tStart = t  # local t and not account for scr refresh
                trialTarget6.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTarget6, 'tStartRefresh')  # time at next scr refresh
                trialTarget6.setAutoDraw(True)
            if trialTarget6.status == STARTED:  # only update if drawing
                trialTarget6.setOpacity(targetOpac6, log=False)
            
            # *trialTarget7* updates
            if trialTarget7.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTarget7.frameNStart = frameN  # exact frame index
                trialTarget7.tStart = t  # local t and not account for scr refresh
                trialTarget7.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTarget7, 'tStartRefresh')  # time at next scr refresh
                trialTarget7.setAutoDraw(True)
            if trialTarget7.status == STARTED:  # only update if drawing
                trialTarget7.setOpacity(targetOpac7, log=False)
            
            # *trialTarget8* updates
            if trialTarget8.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTarget8.frameNStart = frameN  # exact frame index
                trialTarget8.tStart = t  # local t and not account for scr refresh
                trialTarget8.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTarget8, 'tStartRefresh')  # time at next scr refresh
                trialTarget8.setAutoDraw(True)
            if trialTarget8.status == STARTED:  # only update if drawing
                trialTarget8.setOpacity(targetOpac8, log=False)
            
            # *trialTargetA* updates
            if trialTargetA.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTargetA.frameNStart = frameN  # exact frame index
                trialTargetA.tStart = t  # local t and not account for scr refresh
                trialTargetA.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTargetA, 'tStartRefresh')  # time at next scr refresh
                trialTargetA.setAutoDraw(True)
            if trialTargetA.status == STARTED:  # only update if drawing
                trialTargetA.setOpacity(targetOpacA, log=False)
            
            # *trialTargetB* updates
            if trialTargetB.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTargetB.frameNStart = frameN  # exact frame index
                trialTargetB.tStart = t  # local t and not account for scr refresh
                trialTargetB.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTargetB, 'tStartRefresh')  # time at next scr refresh
                trialTargetB.setAutoDraw(True)
            if trialTargetB.status == STARTED:  # only update if drawing
                trialTargetB.setOpacity(targetOpacB, log=False)
            
            # *trialTargetC* updates
            if trialTargetC.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTargetC.frameNStart = frameN  # exact frame index
                trialTargetC.tStart = t  # local t and not account for scr refresh
                trialTargetC.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTargetC, 'tStartRefresh')  # time at next scr refresh
                trialTargetC.setAutoDraw(True)
            if trialTargetC.status == STARTED:  # only update if drawing
                trialTargetC.setOpacity(targetOpacC, log=False)
            
            # *trialTargetD* updates
            if trialTargetD.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTargetD.frameNStart = frameN  # exact frame index
                trialTargetD.tStart = t  # local t and not account for scr refresh
                trialTargetD.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTargetD, 'tStartRefresh')  # time at next scr refresh
                trialTargetD.setAutoDraw(True)
            if trialTargetD.status == STARTED:  # only update if drawing
                trialTargetD.setOpacity(targetOpacD, log=False)
            
            # *trialTargetE* updates
            if trialTargetE.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTargetE.frameNStart = frameN  # exact frame index
                trialTargetE.tStart = t  # local t and not account for scr refresh
                trialTargetE.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTargetE, 'tStartRefresh')  # time at next scr refresh
                trialTargetE.setAutoDraw(True)
            if trialTargetE.status == STARTED:  # only update if drawing
                trialTargetE.setOpacity(targetOpacE, log=False)
            
            # *trialTargetF* updates
            if trialTargetF.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTargetF.frameNStart = frameN  # exact frame index
                trialTargetF.tStart = t  # local t and not account for scr refresh
                trialTargetF.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTargetF, 'tStartRefresh')  # time at next scr refresh
                trialTargetF.setAutoDraw(True)
            if trialTargetF.status == STARTED:  # only update if drawing
                trialTargetF.setOpacity(targetOpacF, log=False)
            
            # *trialTargetG* updates
            if trialTargetG.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTargetG.frameNStart = frameN  # exact frame index
                trialTargetG.tStart = t  # local t and not account for scr refresh
                trialTargetG.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTargetG, 'tStartRefresh')  # time at next scr refresh
                trialTargetG.setAutoDraw(True)
            if trialTargetG.status == STARTED:  # only update if drawing
                trialTargetG.setOpacity(targetOpacG, log=False)
            
            # *trialTargetH* updates
            if trialTargetH.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTargetH.frameNStart = frameN  # exact frame index
                trialTargetH.tStart = t  # local t and not account for scr refresh
                trialTargetH.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTargetH, 'tStartRefresh')  # time at next scr refresh
                trialTargetH.setAutoDraw(True)
            if trialTargetH.status == STARTED:  # only update if drawing
                trialTargetH.setOpacity(targetOpacH, log=False)
            
            # *trialText1* updates
            if trialText1.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialText1.frameNStart = frameN  # exact frame index
                trialText1.tStart = t  # local t and not account for scr refresh
                trialText1.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialText1, 'tStartRefresh')  # time at next scr refresh
                trialText1.setAutoDraw(True)
            
            # *trialText2* updates
            if trialText2.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialText2.frameNStart = frameN  # exact frame index
                trialText2.tStart = t  # local t and not account for scr refresh
                trialText2.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialText2, 'tStartRefresh')  # time at next scr refresh
                trialText2.setAutoDraw(True)
            
            # *trialText3* updates
            if trialText3.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialText3.frameNStart = frameN  # exact frame index
                trialText3.tStart = t  # local t and not account for scr refresh
                trialText3.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialText3, 'tStartRefresh')  # time at next scr refresh
                trialText3.setAutoDraw(True)
            
            # *trialText4* updates
            if trialText4.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialText4.frameNStart = frameN  # exact frame index
                trialText4.tStart = t  # local t and not account for scr refresh
                trialText4.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialText4, 'tStartRefresh')  # time at next scr refresh
                trialText4.setAutoDraw(True)
            
            # *trialText5* updates
            if trialText5.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialText5.frameNStart = frameN  # exact frame index
                trialText5.tStart = t  # local t and not account for scr refresh
                trialText5.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialText5, 'tStartRefresh')  # time at next scr refresh
                trialText5.setAutoDraw(True)
            
            # *trialText6* updates
            if trialText6.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialText6.frameNStart = frameN  # exact frame index
                trialText6.tStart = t  # local t and not account for scr refresh
                trialText6.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialText6, 'tStartRefresh')  # time at next scr refresh
                trialText6.setAutoDraw(True)
            
            # *trialText7* updates
            if trialText7.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialText7.frameNStart = frameN  # exact frame index
                trialText7.tStart = t  # local t and not account for scr refresh
                trialText7.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialText7, 'tStartRefresh')  # time at next scr refresh
                trialText7.setAutoDraw(True)
            
            # *trialText8* updates
            if trialText8.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialText8.frameNStart = frameN  # exact frame index
                trialText8.tStart = t  # local t and not account for scr refresh
                trialText8.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialText8, 'tStartRefresh')  # time at next scr refresh
                trialText8.setAutoDraw(True)
            
            # *trialTextA* updates
            if trialTextA.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTextA.frameNStart = frameN  # exact frame index
                trialTextA.tStart = t  # local t and not account for scr refresh
                trialTextA.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTextA, 'tStartRefresh')  # time at next scr refresh
                trialTextA.setAutoDraw(True)
            
            # *trialTextB* updates
            if trialTextB.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTextB.frameNStart = frameN  # exact frame index
                trialTextB.tStart = t  # local t and not account for scr refresh
                trialTextB.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTextB, 'tStartRefresh')  # time at next scr refresh
                trialTextB.setAutoDraw(True)
            
            # *trialTextC* updates
            if trialTextC.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTextC.frameNStart = frameN  # exact frame index
                trialTextC.tStart = t  # local t and not account for scr refresh
                trialTextC.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTextC, 'tStartRefresh')  # time at next scr refresh
                trialTextC.setAutoDraw(True)
            
            # *trialTextD* updates
            if trialTextD.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTextD.frameNStart = frameN  # exact frame index
                trialTextD.tStart = t  # local t and not account for scr refresh
                trialTextD.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTextD, 'tStartRefresh')  # time at next scr refresh
                trialTextD.setAutoDraw(True)
            
            # *trialTextE* updates
            if trialTextE.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTextE.frameNStart = frameN  # exact frame index
                trialTextE.tStart = t  # local t and not account for scr refresh
                trialTextE.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTextE, 'tStartRefresh')  # time at next scr refresh
                trialTextE.setAutoDraw(True)
            
            # *trialTextF* updates
            if trialTextF.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTextF.frameNStart = frameN  # exact frame index
                trialTextF.tStart = t  # local t and not account for scr refresh
                trialTextF.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTextF, 'tStartRefresh')  # time at next scr refresh
                trialTextF.setAutoDraw(True)
            
            # *trialTextG* updates
            if trialTextG.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTextG.frameNStart = frameN  # exact frame index
                trialTextG.tStart = t  # local t and not account for scr refresh
                trialTextG.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTextG, 'tStartRefresh')  # time at next scr refresh
                trialTextG.setAutoDraw(True)
            
            # *trialTextH* updates
            if trialTextH.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
                # keep track of start time/frame for later
                trialTextH.frameNStart = frameN  # exact frame index
                trialTextH.tStart = t  # local t and not account for scr refresh
                trialTextH.tStartRefresh = tThisFlipGlobal  # on global time
                win.timeOnFlip(trialTextH, 'tStartRefresh')  # time at next scr refresh
                trialTextH.setAutoDraw(True)
            
            # check for quit (typically the Esc key)
            if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]):
                core.quit()
            
            # check if all components have finished
            if not continueRoutine:  # a component has requested a forced-end of Routine
                break
            continueRoutine = False  # will revert to True if at least one component still running
            for thisComponent in trialComponents:
                if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
                    continueRoutine = True
                    break  # at least one component has not yet finished
            
            # refresh the screen
            if continueRoutine:  # don't flip if this routine is over or we'll get a blank screen
                win.flip()
        
        # -------Ending Routine "trial"-------
        for thisComponent in trialComponents:
            if hasattr(thisComponent, "setAutoDraw"):
                thisComponent.setAutoDraw(False)
        thisExp.addData('step', steps)  
        # store data for trials (TrialHandler)
        trials.addData('trialMouse.x', trialMouse.x)
        trials.addData('trialMouse.y', trialMouse.y)
        trials.addData('trialMouse.leftButton', trialMouse.leftButton)
        trials.addData('trialMouse.midButton', trialMouse.midButton)
        trials.addData('trialMouse.rightButton', trialMouse.rightButton)
        trials.addData('trialMouse.time', trialMouse.time)
        trials.addData('trialMouse.started', trialMouse.tStartRefresh)
        trials.addData('trialMouse.stopped', trialMouse.tStopRefresh)
        trials.addData('trialCursor.started', trialCursor.tStartRefresh)
        trials.addData('trialCursor.stopped', trialCursor.tStopRefresh)
        trials.addData('trialTarget1.started', trialTarget1.tStartRefresh)
        trials.addData('trialTarget1.stopped', trialTarget1.tStopRefresh)
        trials.addData('trialTarget2.started', trialTarget2.tStartRefresh)
        trials.addData('trialTarget2.stopped', trialTarget2.tStopRefresh)
        trials.addData('trialTarget3.started', trialTarget3.tStartRefresh)
        trials.addData('trialTarget3.stopped', trialTarget3.tStopRefresh)
        trials.addData('trialTarget4.started', trialTarget4.tStartRefresh)
        trials.addData('trialTarget4.stopped', trialTarget4.tStopRefresh)
        trials.addData('trialTarget5.started', trialTarget5.tStartRefresh)
        trials.addData('trialTarget5.stopped', trialTarget5.tStopRefresh)
        trials.addData('trialTarget6.started', trialTarget6.tStartRefresh)
        trials.addData('trialTarget6.stopped', trialTarget6.tStopRefresh)
        trials.addData('trialTarget7.started', trialTarget7.tStartRefresh)
        trials.addData('trialTarget7.stopped', trialTarget7.tStopRefresh)
        trials.addData('trialTarget8.started', trialTarget8.tStartRefresh)
        trials.addData('trialTarget8.stopped', trialTarget8.tStopRefresh)
        trials.addData('trialTargetA.started', trialTargetA.tStartRefresh)
        trials.addData('trialTargetA.stopped', trialTargetA.tStopRefresh)
        trials.addData('trialTargetB.started', trialTargetB.tStartRefresh)
        trials.addData('trialTargetB.stopped', trialTargetB.tStopRefresh)
        trials.addData('trialTargetC.started', trialTargetC.tStartRefresh)
        trials.addData('trialTargetC.stopped', trialTargetC.tStopRefresh)
        trials.addData('trialTargetD.started', trialTargetD.tStartRefresh)
        trials.addData('trialTargetD.stopped', trialTargetD.tStopRefresh)
        trials.addData('trialTargetE.started', trialTargetE.tStartRefresh)
        trials.addData('trialTargetE.stopped', trialTargetE.tStopRefresh)
        trials.addData('trialTargetF.started', trialTargetF.tStartRefresh)
        trials.addData('trialTargetF.stopped', trialTargetF.tStopRefresh)
        trials.addData('trialTargetG.started', trialTargetG.tStartRefresh)
        trials.addData('trialTargetG.stopped', trialTargetG.tStopRefresh)
        trials.addData('trialTargetH.started', trialTargetH.tStartRefresh)
        trials.addData('trialTargetH.stopped', trialTargetH.tStopRefresh)
        trials.addData('trialText1.started', trialText1.tStartRefresh)
        trials.addData('trialText1.stopped', trialText1.tStopRefresh)
        trials.addData('trialText2.started', trialText2.tStartRefresh)
        trials.addData('trialText2.stopped', trialText2.tStopRefresh)
        trials.addData('trialText3.started', trialText3.tStartRefresh)
        trials.addData('trialText3.stopped', trialText3.tStopRefresh)
        trials.addData('trialText4.started', trialText4.tStartRefresh)
        trials.addData('trialText4.stopped', trialText4.tStopRefresh)
        trials.addData('trialText5.started', trialText5.tStartRefresh)
        trials.addData('trialText5.stopped', trialText5.tStopRefresh)
        trials.addData('trialText6.started', trialText6.tStartRefresh)
        trials.addData('trialText6.stopped', trialText6.tStopRefresh)
        trials.addData('trialText7.started', trialText7.tStartRefresh)
        trials.addData('trialText7.stopped', trialText7.tStopRefresh)
        trials.addData('trialText8.started', trialText8.tStartRefresh)
        trials.addData('trialText8.stopped', trialText8.tStopRefresh)
        trials.addData('trialTextA.started', trialTextA.tStartRefresh)
        trials.addData('trialTextA.stopped', trialTextA.tStopRefresh)
        trials.addData('trialTextB.started', trialTextB.tStartRefresh)
        trials.addData('trialTextB.stopped', trialTextB.tStopRefresh)
        trials.addData('trialTextC.started', trialTextC.tStartRefresh)
        trials.addData('trialTextC.stopped', trialTextC.tStopRefresh)
        trials.addData('trialTextD.started', trialTextD.tStartRefresh)
        trials.addData('trialTextD.stopped', trialTextD.tStopRefresh)
        trials.addData('trialTextE.started', trialTextE.tStartRefresh)
        trials.addData('trialTextE.stopped', trialTextE.tStopRefresh)
        trials.addData('trialTextF.started', trialTextF.tStartRefresh)
        trials.addData('trialTextF.stopped', trialTextF.tStopRefresh)
        trials.addData('trialTextG.started', trialTextG.tStartRefresh)
        trials.addData('trialTextG.stopped', trialTextG.tStopRefresh)
        trials.addData('trialTextH.started', trialTextH.tStartRefresh)
        trials.addData('trialTextH.stopped', trialTextH.tStopRefresh)
        # the Routine "trial" was not non-slip safe, so reset the non-slip timer
        routineTimer.reset()
        thisExp.nextEntry()
        
    # completed 1 repeats of 'trials'
    
    thisExp.nextEntry()
    
# completed 5 repeats of 'tasks'


# Flip one final time so any remaining win.callOnFlip() 
# and win.timeOnFlip() tasks get executed before quitting
win.flip()

# these shouldn't be strictly necessary (should auto-save)
thisExp.saveAsWideText(filename+'.csv')
thisExp.saveAsPickle(filename)
logging.flush()
# make sure everything is closed down
thisExp.abort()  # or data files will save again on exit
win.close()
core.quit()