def update(self, uKey: KeyTracker, iKey: KeyTracker, spaceKey: KeyTracker,
sm: StateMachine, thisExp: ExperimentHandler):
if self.firstFrame:
logging.exp(f"Trial first frame")
sm.lock()
sm.dontDrawSM()
self.firstFrame = False
if not self.welcomedMsg and spaceKey.getKeyUp():
logging.exp(
f"Trial user confirmed welcome, begin episode: {self.episodeNum}"
)
self.welcomedMsg = True
self.resetSM(sm)
sm.unlock()
sm.doDrawSM()
self.episodeTimer = core.Clock()
if self.welcomedMsg and not self.endEpisode:
if sm.movesLeft == 0:
logging.exp(f"Trial user finished episode")
self.TrialScores.append(sm.totalScore)
self.TrialTimes.append(self.episodeTimer.getTime())
self.endEpisode = True
sm.dontDrawSM()
sm.lock()
if self.endEpisode and spaceKey.getKeyUp():
self.endEpisode = False
self.episodeNum += 1
logging.exp(
f"Trial user confirmed end episode, begin episode: {self.episodeNum}"
)
self.episodeTimer = core.Clock()
self.resetSM(sm)
sm.unlock()
sm.doDrawSM()
if not self.complete and self.episodes <= self.episodeNum:
self.complete = True
thisExp.addData('Trial Scores', self.TrialScores)
thisExp.addData('Trial Times', self.TrialTimes)
self.TrialTimes = []
self.TrialScores = []
def update(self, uKey: KeyTracker, iKey: KeyTracker, spaceKey: KeyTracker,
sm: StateMachine):
phases = self.phase
newPhase = self.currentPhase
if uKey.getKeyUp():
self.buttonPresses[0] += 1
if iKey.getKeyUp():
self.buttonPresses[1] += 1
# ======================================================================
# phase change logic: handles logic for transitions between phases
# ======================================================================
# === 0->2 =============================================================
if self.isPhase("start") and self.uGthan(0):
newPhase = phases["pressI"]
# === 0->1 =============================================================
if self.isPhase("start") and self.iGthan(0):
newPhase = phases["pressU"]
# === 1,2->3 ===========================================================
if self.isPhases(["pressI", "pressU"
]) and self.uGthan(0) and self.iGthan(0):
newPhase = phases["timed"]
self.practiceTimer.reset()
# === 3,4,5,6->7 =======================================================
isRememberUIPhase = self.isPhases(
["rememberUI", "rememberU", "rememberI"])
if self.isPhase("timed") and self.isTimerUp(
"practice") or isRememberUIPhase:
if self.uLthan(self.targetPresses) and self.iLthan(
self.targetPresses):
newPhase = phases["rememberUI"]
elif self.uLthan(self.targetPresses):
newPhase = phases["rememberU"]
elif self.iLthan(self.targetPresses):
newPhase = phases["rememberI"]
else:
newPhase = phases["targetIntro"]
sm.lock()
# === 7->8 =============================================================
if self.isPhase("targetIntro") and spaceKey.getKeyUp():
newPhase = phases["2moves"]
sm.unlock()
# === 8->9 =============================================================
if self.isPhase(
"2moves") and sm.inCorrectState() and sm.movesLeft <= 0:
self.movesPos += 1
if self.movesPos >= len(self.twoMovesArr):
newPhase = phases["1moves"]
else:
self.resetSM(sm)
# === 9->10 ============================================================
if self.isPhase(
"1moves") and sm.inCorrectState() and sm.movesLeft <= 0:
self.movesPos += 1
if self.movesPos >= len(self.oneMovesArr):
newPhase = phases["practice2"]
sm.lock()
else:
self.resetSM(sm)
# === 10->11 ===========================================================
if self.isPhase("practice2") and spaceKey.getKeyUp():
newPhase = phases["memoryI"]
sm.lock()
# === 11->12 ===========================================================
if self.isPhase("memoryI") and spaceKey.getKeyUp():
newPhase = phases["memory"]
self.buttonPresses = [0, 0]
sm.unlock()
# === 11->12 ===========================================================
if self.isPhase("memory") and (
self.buttonPresses[0] +
self.buttonPresses[1]) >= self.targetPresses2:
newPhase = phases["grab"]
sm.reset()
# === 12->13 ===========================================================
if self.isPhase("grab") and sm.totalScore >= self.pointRequirement:
newPhase = phases["grab2movesI"]
self.successes = 0
sm.lock()
# === 13->14 ===========================================================
if self.isPhase("grab2movesI") and spaceKey.getKeyUp():
newPhase = phases["grab2moves"]
sm.reset()
sm.unlock()
# === 14->15 ===========================================================
if self.isPhase(
"grab2moves") and self.successes >= self.successful2moves:
newPhase = phases["timeI"]
self.successes = 0
sm.lock()
sm.dontDrawSM()
# === 16->17 ===========================================================
if self.isPhase("timeI") and spaceKey.getKeyUp():
newPhase = phases["time"]
sm.reset()
sm.unlock()
sm.doDrawSM()
self.moveTimer.reset()
self.thinkTimer.reset()
# === 17->complete ===========================================================
if self.isPhase("time") and self.successes >= self.successfulTime:
newPhase = phases["complete"]
sm.unlock()
# ======================================================================
# phase changing: handles when phases change
# ======================================================================
phaseChanged = not self.currentPhase == newPhase
if self.devModeOn:
if uKey.getKeyUp() or iKey.getKeyUp():
self.devModeOn = False
logging.exp(f"dev mode off")
print(f"dev mode off")
if not phaseChanged and spaceKey.getKeyUp():
self.deveModePhase += 1
newPhase = self.deveModePhase
logging.exp(
f"Debug mode override new Practice Phase: {newPhase}")
print(f"Debug mode override new Practice Phase: {newPhase}")
if phaseChanged:
logging.exp(f"New Practice Phase: {newPhase}")
self.currentPhase = newPhase
# ======================================================================
# conditional update checks: handles specific phase logic
# ======================================================================
if self.isPhases(["2moves", "1moves"]):
if phaseChanged:
self.movesPos = 0
self.resetSM(sm)
if sm.movesLeft <= 0 and not sm.inCorrectState():
self.resetSM(sm)
if self.isPhase("grab2moves"):
if sm.movesLeft == 0:
sm.lock()
if spaceKey.getKeyUp():
self.successes += 1
sm.reset()
if self.isPhase("time"):
if spaceKey.getKeyUp() and self.roundFinished:
sm.reset()
sm.unlock()
self.startedRound = False
self.roundFinished = False
self.thinkTimer.reset()
if not self.startedRound:
if self.isTimerUp(
"think") or uKey.getKeyUp() or iKey.getKeyUp():
self.startedRound = True
self.moveTimer.reset()
if self.startedRound and (sm.movesLeft == 0
or self.isTimerUp("move")):
sm.lock()
if not self.roundFinished:
if sm.totalScore >= 0:
self.successes += 1
logging.exp(f"pp: {newPhase} succeed timed practice")
else:
logging.exp(f"pp: {newPhase} failed timed practice")
self.roundFinished = True
# ======================================================================
# complete condition: checks if complete
# ======================================================================
if self.isPhase("complete") and not self.complete:
self.complete = True
logging.exp(f"Practice complete")
