def init_all(open_window = False):
global window, window_reading, chunk_defs, chunk_names, correct_dict
actr.reset()
window = actr.open_exp_window("Letter Writing", open_window,
windowX, windowY, 200, 300)
window_reading = actr.open_exp_window("Letter Goal", open_window,
windowX, windowY, 800, 300)
actr.install_device(window_reading)
actr.install_device(window)
chunk_defs = define_chunks(defs = True)
chunk_names = define_chunks(defs = False)
correct_dict = correctDict.make_correct_dict()
def trials(n=200,reset=True,output=True):
global responses,task_over,exp_length,window
if reset:
actr.reset()
window = actr.open_exp_window("Compilation task",visible=False)
times = []
responses = []
task_over = False
exp_length = n
present_next_trial()
actr.install_device(window)
# actr.add_command('compilation-issues-game-over',game_over,"Test for the production compilation issues game being over")
actr.add_command('compilation-issues-response',respond_to_key_press,"Compilation issues key press response monitor")
actr.monitor_command('output-key','compilation-issues-response')
# this is how the original ran: actr.run_until_condition('compilation-issues-game-over')
# however performing a remote call for each event to determine the stopping point
# takes almost 2 orders of magnitude longer to run! So instead just run
# sufficiently long to complete the task and assume the model stops when there's
# nothing left to do.
actr.run(20000)
actr.remove_command_monitor('output-key','compilation-issues-response')
actr.remove_command ('compilation-issues-response')
# actr.remove_command ('compilation-issues-game-over')
return analyze_results(output)
def experiment(human=False):
actr.reset()
items = actr.permute_list([
"B", "C", "D", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R",
"S", "T", "V", "W", "X", "Y", "Z"
])
text1 = items[0]
window = actr.open_exp_window("Letter recognition")
actr.add_text_to_exp_window(window, text1, x=125, y=150)
actr.add_command("demo2-key-press", respond_to_key_press,
"Demo2 task output-key monitor")
actr.monitor_command("output-key", "demo2-key-press")
global response
response = False
if human == True:
while response == False:
actr.process_events()
else:
actr.install_device(window)
actr.run(10, True)
actr.remove_command_monitor("output-key", "demo2-key-press")
actr.remove_command("demo2-key-press")
return response
def do_experiment(trials, test=False):
"""
This function run the experiment, and return simulated model behavior
:param size:
:param trials:
:param human:
:return:
"""
#TODO: need to comment if seperate to core and body script
# actr.reset()
result = []
window = actr.open_exp_window("Gambling Experiment", visible=False)
actr.install_device(window)
for trial in trials:
# time = 0
prompt, feedback, block_type = trial
# guess
response, time = do_guess(prompt, window)
# this test is to see if model can learn feedback
if test: feedback = test_unit5(response)
# encode feedback
do_feedback(feedback, window)
result.append((feedback, block_type, response, time))
return result
def show_human_results(own_cards, others_cards, own_result, others_result):
win = actr.open_exp_window('Human')
actr.add_text_to_exp_window(win, 'You', x=50, y=20)
actr.add_text_to_exp_window(win, 'Model', x=200, y=20)
for i in range(2):
for j in range(3):
actr.add_text_to_exp_window(win,
"C%d" % (j + 1),
x=(25 + (j * 30) + (i * 150)),
y=40,
width=20)
if i == 0:
if j < len(own_cards):
actr.add_text_to_exp_window(win,
str(own_cards[j]),
x=(25 + (j * 30) + (i * 150)),
y=60,
width=20)
else:
if j < len(others_cards):
actr.add_text_to_exp_window(win,
str(others_cards[j]),
x=(25 + (j * 30) + (i * 150)),
y=60,
width=20)
actr.add_text_to_exp_window(win, own_result, x=50, y=85)
actr.add_text_to_exp_window(win, others_result, x=200, y=85)
start_time = actr.get_time(False)
while (actr.get_time(False) - start_time) < 10000:
actr.process_events()
def agi ():
actr.reset()
# open a window and add the text
window = actr.open_exp_window("Moving X", visible=True)
text = actr.add_text_to_exp_window(window, "x", x=10, y=10)
y = 10
actr.install_device(window)
# schedule an event to move it but don't have the
# periodic-event command available at this point so
# just use a relative event which schedules itself
actr.add_command("agi-move-it",move_text)
actr.schedule_event_relative (1, "agi-move-it",params=[text,y],maintenance=True)
# run the model in real time since it's a visible window
actr.run(3,True)
actr.remove_command("agi-move-it")
def graph_it(data):
win = actr.open_exp_window("Irregular Verbs correct",visible=True,width=500,height=475)
low = min(data)
zoom = min([.9,math.floor(10 * low)/10])
actr.clear_exp_window(win)
actr.add_text_to_exp_window(win, "1.0", x=5, y=5, width=22)
actr.add_text_to_exp_window(win, "%0.2f" % zoom, x=5, y=400, width=22)
actr.add_text_to_exp_window(win, "%0.2f" % (zoom + ((1.0 - zoom) / 2)), x=5, y=200, width=22)
actr.add_text_to_exp_window(win, "Trials", x=200, y=420, width=100)
actr.add_line_to_exp_window(win,[30,10],[30,410],'black')
actr.add_line_to_exp_window(win,[450,410],[25,410],'black')
for i in range(10):
actr.add_line_to_exp_window(win,[25,10 + i*40],[35,10 + i*40],'black')
start = data[0]
increment = max([1.0,math.floor( 450 / len(data))])
r = math.floor (400/ (1.0 - zoom))
intercept = r + 10
lastx =30
lasty = intercept - math.floor(r * start)
for p in data[1:]:
x = lastx + 30
y = intercept - math.floor(r * p)
actr.add_line_to_exp_window(win,[lastx,lasty],[x,y],'red')
lastx = x
lasty = y
def person():
global response
window = actr.open_exp_window("Choice Experiment", visible=True)
actr.add_command("choice-response", respond_to_key_press,
"Choice task key response")
actr.monitor_command("output-key", "choice-response")
actr.add_text_to_exp_window(window, 'choose', x=50, y=100)
response = ''
while response == '':
actr.process_events()
actr.clear_exp_window(window)
if actr.random(1.0) < .9:
answer = 'heads'
else:
answer = 'tails'
actr.add_text_to_exp_window(window, answer, x=50, y=100)
start = actr.get_time(False)
while (actr.get_time(False) - start) < 1000:
actr.process_events()
actr.remove_command_monitor("output-key", "choice-response")
actr.remove_command("choice-response")
return response
def task(which=False):
global response, response_time
actr.reset()
alphabet = [
"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N",
"O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"
]
letter = actr.permute_list(alphabet)[0]
alphabet = ["Z"] + alphabet
if which == 'next' or which == 'previous':
task = which
elif actr.random(2) == 0:
task = 'next'
else:
task = 'previous'
time = 1500 + actr.random(1000)
window = actr.open_exp_window("Simple task")
actr.install_device(window)
actr.add_command("pm-issues-response", respond_to_key_press,
"Perceptual-motor issues task response")
actr.monitor_command("output-key", "pm-issues-response")
actr.add_text_to_exp_window(window, letter, x=130, y=150)
actr.add_command("pm-issue-display", display_prompt,
"Perceptual-motor issues task prompt display")
actr.schedule_event_relative(time,
"pm-issue-display",
params=[window, task],
time_in_ms=True)
response = []
response_time = False
actr.run(10, True)
actr.remove_command("pm-issue-display")
actr.remove_command_monitor("output-key", "pm-issues-response")
actr.remove_command("pm-issues-response")
if (len(response) == 2 and response_time > time and response[0] == letter
and ((task == 'next' and alphabet.index(response[0]) ==
(alphabet.index(response[1]) - 1)) or
(task == 'previous' and alphabet.index(response[0]) ==
(alphabet.index(response[1]) + 1)))):
result = True
else:
result = False
return [task, result]
def trial(onset_time):
actr.reset()
letters = actr.permute_list([
"B", "C", "D", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R",
"S", "T", "V", "W", "X", "Y", "Z"
])
answers = []
row = actr.random(3)
window = actr.open_exp_window("Sperling Experiment", visible=True)
for i in range(3):
for j in range(4):
txt = letters[j + (i * 4)]
if i == row:
answers.append(txt)
actr.add_text_to_exp_window(window,
txt,
x=(75 + (j * 50)),
y=(100 + (i * 50)))
actr.install_device(window)
if row == 0:
freq = 2000
elif row == 1:
freq = 1000
else:
freq = 500
actr.new_tone_sound(freq, .5, onset_time)
actr.schedule_event_relative(900 + actr.random(200),
"clear-exp-window",
params=[window],
time_in_ms=True)
global responses
responses = []
actr.add_command("sperling-response", respond_to_key_press,
"Sperling task key press response monitor")
actr.monitor_command("output-key", "sperling-response")
actr.run(30, True)
actr.remove_command_monitor("output-key", "sperling-response")
actr.remove_command("sperling-response")
if show_responses:
print("answers: %s" % answers)
print("responses: %s" % responses)
return (compute_score(answers))
def experiment_initialization(self, vis=False):
# actr.reset()
# actr.reload()
actr.add_command("unit2-key-press", self.respond_to_key_press,
"Assignment 2 task output-key monitor")
actr.add_command("my-event-hook", self.post_event_hook,
"called after an event")
actr.monitor_command("output-key", "unit2-key-press")
actr.call_command("add-post-event-hook", "my-event-hook")
self.window = actr.open_exp_window("Leter difference task",
visible=vis)
def example():
actr.reset()
# The first window is located at x=0 and y=0 which
# is fine for virtual windows, but if it were a real
# window that window would be behind the menu bar
# at the top of the display under OS X which makes
# it difficult to interact with. The second window
# is located at x=200, y=200. The default mouse
# position is x=0, y=0.
w1 = actr.open_exp_window("W1",
visible=False,
width=100,
height=100,
x=0,
y=0)
w2 = actr.open_exp_window("W2",
visible=False,
width=100,
height=100,
x=200,
y=200)
# add text to the same local position in each window.
actr.add_text_to_exp_window(w1, "a", x=10, y=10, color='red')
actr.add_text_to_exp_window(w2, "a", x=10, y=10, color='blue')
# Install both windows and the mouse cursor
actr.install_device(w1)
actr.install_device(w2)
actr.install_device(["vision", "cursor", "mouse"])
# Just run the model to have vision module process
# things and print the visicon.
# The model doesn't do anything.
actr.run(1)
actr.print_visicon()
def simulate(self, trace=False, utility_offset=True):
"""Runs SP simulations using real stimuli"""
# Function hook to modify the utility calculation
# (will add a mismatch penalty). Need to be defined
# before the model is loaded
actr.add_command("parser-offset", self.utility_offset,
"Calculates a mismatch penalty for AI condition")
actr.load_act_r_model(self.model)
for condition in self.CONDITIONS:
self.current_condition = condition
subset = [t for t in self.trials if t.condition == condition]
for j in range(self.n):
actr.reset()
# Make the model silent in case
if not trace:
actr.set_parameter_value(":V", False)
# The model does not really need a visual interface,
# but the default AGI provides a virtual mic to record
# voice output.
win = actr.open_exp_window("SP", width = 80,
height = 60,
visible=False)
actr.install_device(win)
# Function hooks to record the model responses.
actr.add_command("record-response", self.record_response,
"Accepts a response for the SP task")
actr.monitor_command("output-speech",
"record-response")
# Run a single trial in the given condition
trial = random.choice(subset)
self.run_trial(trial)
# Clean up the function hooks
actr.remove_command_monitor("output-speech",
"record-response")
actr.remove_command("record-response")
# Removes the offset
actr.remove_command("parser-offset")
def present_trial(trial, new_window=True):
if new_window:
w = actr.open_exp_window("Alpha-arithmetic Experiment",
visible=trial.visible)
if run_model:
actr.install_device(w)
else:
actr.clear_exp_window()
actr.add_text_to_exp_window(None, trial.text, x=100, y=150)
trial.start = actr.get_time(run_model)
def run_experiment(model_name="response-monkey.lisp",
time=200,
verbose=True,
visible=True,
trace=True,
params=[]):
"""Runs an experiment"""
actr.reset()
# current directory
curr_dir = os.path.dirname(os.path.realpath(__file__))
actr.load_act_r_model(os.path.join(curr_dir, model_name))
# Set then model parameters
for name, val in params:
actr.set_parameter_value(name, val)
win = actr.open_exp_window("* STROOP TASK *",
width=800,
height=600,
visible=visible)
actr.install_device(win)
task = StroopTask(setup=False)
#task.window = win
actr.add_command("stroop-next", task.next, "Updates the internal task")
actr.add_command("stroop-update-window", task.update_window,
"Updates the window")
actr.add_command("stroop-accept-response", task.accept_response,
"Accepts a response for the Stroop task")
actr.monitor_command("output-key", "stroop-accept-response")
task.setup(win)
if not trace:
actr.set_parameter_value(":V", False)
actr.run(time)
if verbose:
print("-" * 80)
task.print_stats(task.run_stats())
# Cleans up the interface
# (Removes all the links between ACT-R and this object).
actr.remove_command_monitor("output-key", "stroop-accept-response")
actr.remove_command("stroop-next")
actr.remove_command("stroop-update-window")
actr.remove_command("stroop-accept-response")
# Returns the task as a Python object for further analysis of data
return task
def do_experiment(size, trials, human):
actr.reset()
result = []
model = not (human)
window = actr.open_exp_window("Paired-Associate Experiment", visible=human)
if model:
actr.install_device(window)
for i in range(trials):
score = 0
time = 0
for prompt, associate in actr.permute_list(pairs[20 - size:]):
actr.clear_exp_window(window)
actr.add_text_to_exp_window(window, prompt, x=150, y=150)
global response
response = ''
start = actr.get_time(model)
if model:
actr.run_full_time(5)
else:
while (actr.get_time(False) - start) < 5000:
actr.process_events()
if response == associate:
score += 1
time += response_time - start
actr.clear_exp_window(window)
actr.add_text_to_exp_window(window, associate, x=150, y=150)
start = actr.get_time(model)
if model:
actr.run_full_time(5)
else:
while (actr.get_time(False) - start) < 5000:
actr.process_events()
if score > 0:
average_time = time / score / 1000.0
else:
average_time = 0
result.append((score / size, average_time))
return result
def experiment(human=False):
actr.reset()
items = actr.permute_list([
"B", "C", "D", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R",
"S", "T", "V", "W", "X", "Y", "Z"
])
target = items[0]
foil = items[1]
window = actr.open_exp_window("Letter difference")
text1 = foil
text2 = foil
text3 = foil
index = actr.random(3)
if index == 0:
text1 = target
elif index == 1:
text2 = target
else:
text3 = target
actr.add_text_to_exp_window(window, text1, x=125, y=75)
actr.add_text_to_exp_window(window, text2, x=75, y=175)
actr.add_text_to_exp_window(window, text3, x=175, y=175)
actr.add_command("unit2-key-press", respond_to_key_press,
"Assignment 2 task output-key monitor")
actr.monitor_command("output-key", "unit2-key-press")
global response
response = ''
if human == True:
while response == '':
actr.process_events()
else:
actr.install_device(window)
actr.run(10, True)
actr.remove_command_monitor("output-key", "unit2-key-press")
actr.remove_command("unit2-key-press")
if response.lower() == target.lower():
return True
else:
return False
def model_loop():
global win
actr.add_command('present_stim', present_stim, 'presents stimulus')
actr.add_command('present_feedback', present_feedback, 'presents feedback')
actr.add_command('get_response', get_response, 'gets response')
#open window for interaction
win = actr.open_exp_window("test", visible=False)
actr.install_device(win)
actr.schedule_event_relative(0, 'present_stim')
#waits for a key press?
actr.monitor_command("output-key", 'get_response')
actr.run(45)
def test_unit3():
"""this test unit examines trace"""
assert check_load()
trial = ('?', 'Punishment', 'MostlyReward')
prompt, feedback, block_type = trial
window = actr.open_exp_window("Gambling Experiment", visible=False)
actr.install_device(window)
actr.clear_exp_window(window)
actr.add_text_to_exp_window(window, prompt, x=150, y=150)
actr.run_full_time(5)
actr.clear_exp_window(window)
actr.add_text_to_exp_window(window, feedback, x=150, y=150)
actr.run_full_time(5)
def build_display(a, b, c, goal):
global window, target, current_stick, done, current_line, choice
target = goal
current_stick = 0
done = False
choice = None
current_line = None
window = actr.open_exp_window("Building Sticks Task",
visible=visible,
width=600,
height=400)
actr.add_button_to_exp_window(window,
text="A",
x=5,
y=23,
action=["bst-button-pressed", a, "under"],
height=24,
width=40)
actr.add_button_to_exp_window(window,
text="B",
x=5,
y=48,
action=["bst-button-pressed", b, "over"],
height=24,
width=40)
actr.add_button_to_exp_window(window,
text="C",
x=5,
y=73,
action=["bst-button-pressed", c, "under"],
height=24,
width=40)
actr.add_button_to_exp_window(window,
text="Reset",
x=5,
y=123,
action="bst-reset-button-pressed",
height=24,
width=65)
actr.add_line_to_exp_window(window, [75, 35], [a + 75, 35], "black")
actr.add_line_to_exp_window(window, [75, 60], [b + 75, 60], "black")
actr.add_line_to_exp_window(window, [75, 85], [c + 75, 85], "black")
actr.add_line_to_exp_window(window, [75, 110], [goal + 75, 110], "green")
def sentence(person, location, target, term):
actr.reset()
window = actr.open_exp_window("Sentence Experiment",
visible=False,
width=600,
height=300)
x = 25
actr.install_device(window)
actr.add_command("fan-response", respond_to_key_press,
"Fan experiment model response")
actr.monitor_command("output-key", "fan-response")
if term == 'person':
actr.pdisable("retrieve-from-location")
else:
actr.pdisable("retrieve-from-person")
actr.add_text_to_exp_window(window, person, x=50, y=150, width=75)
actr.add_text_to_exp_window(window, location, x=250, y=150, width=75)
global response, response_time
response = ''
response_time = 0
actr.run(30)
actr.remove_command_monitor("output-key", "fan-response")
actr.remove_command("fan-response")
if response == '':
return (30, False)
elif target:
if response.lower() == 'k'.lower():
return (response_time / 1000, True)
else:
return (response_time / 1000, False)
else:
if response.lower() == 'd'.lower():
return (response_time / 1000, True)
else:
return (response_time / 1000, False)
def setup_experiment(human=True):
'''
Load the correct ACT-R model, and create a window to display the words
'''
if subject == "controls":
actr.load_act_r_model(
"/Users/chisa/Desktop/masters/first_year_research_project/my_model/csm_free_recall_model.lisp"
)
elif subject == "depressed":
actr.load_act_r_model(
"/Users/chisa/Desktop/masters/first_year_research_project/my_model/csm_free_recall_model_depressed.lisp"
)
window = actr.open_exp_window("Free Recall Experiment",
width=1024,
height=768,
visible=human) # 15inch resolution window
actr.install_device(window)
return window
def draw_graph(points):
w = actr.open_exp_window('Data', visible=True, width=550, height=460)
actr.add_line_to_exp_window(w, [50, 0], [50, 420], 'white')
for i in range(11):
actr.add_text_to_exp_window(w,
"%3.1f" % (1.0 - (i * .1)),
x=5,
y=(5 + (i * 40)),
width=35)
actr.add_line_to_exp_window(w, [45, 10 + (i * 40)],
[550, 10 + (i * 40)], 'white')
x = 50
for (a, b) in zip(points[0:-1], points[1:]):
actr.add_line_to_exp_window(
w, [x, math.floor(410 - (a * 400))],
[x + 25, math.floor(410 - (b * 400))], 'blue')
x += 25
def play_human(cards, oc1):
win = actr.open_exp_window('Human')
actr.add_text_to_exp_window(win, 'You', x=50, y=20)
actr.add_text_to_exp_window(win, 'Model', x=200, y=20)
for i in range(2):
for j in range(3):
actr.add_text_to_exp_window(win,
"C%d" % (j + 1),
x=(25 + (j * 30) + (i * 150)),
y=40,
width=20)
if i == 0 and j < 2:
actr.add_text_to_exp_window(win,
str(cards[j]),
x=(25 + (j * 30) + (i * 150)),
y=60,
width=20)
if i == 1 and j == 0:
actr.add_text_to_exp_window(win,
str(oc1),
x=(25 + (j * 30) + (i * 150)),
y=60,
width=20)
global human_action
human_action = None
start_time = actr.get_time(False)
while (actr.get_time(False) - start_time) < 10000:
actr.process_events()
if human_action:
return human_action
else:
return 's'
def run_test(visible=False):
actr.reset()
win = actr.open_exp_window("background test",
visible=visible,
width=390,
height=390,
x=100,
y=100)
actr.install_device(win)
actr.start_hand_at_mouse()
actr.add_image_to_exp_window(win,
"background",
"ref-brain.gif",
x=0,
y=0,
width=390,
height=390)
for x in range(3):
for y in range(3):
actr.add_visicon_features([
"screen-x", 164 + (x * 130), "screen-y", 164 + (y * 130),
"height", 128, "width", 128, "name",
["'brain'", "'brain-%d'" % (x + (y * 3))]
])
# run for the vision module to process the scene
actr.run_n_events(2)
actr.print_visicon()
# run for up to 5 seconds using real-time if the window is visible
actr.run(10, visible)
def run_test (visible=False):
actr.reset()
win = actr.open_exp_window("image test",visible=visible, width=310, height=420)
actr.install_device(win)
actr.start_hand_at_mouse()
actr.add_image_to_exp_window(win, "logo", "smalllogo.gif", x=10, y=10, width=288, height=142)
actr.add_items_to_exp_window(win, actr.create_image_for_exp_window(win, "brain", "ref-brain.gif", x=10, y=160, width=128, height=128, action="click-brain-py"))
actr.add_image_to_exp_window(win, "brain-2", "ref-brain.gif", x=10, y=290, width=128, height=128, action=["click-brain-2-py","this string"])
# run for the vision module to process the scene
actr.run_n_events(2)
actr.print_visicon()
# run for up to 5 seconds using real-time if the window is visible
actr.run(5, visible)
def experiment(human=False):
# I guess setting response to false globally
global response, light1Color, light2Color, window, text1,text2,text3,text4, \
light1_obj,light2_obj,gauge1_obj,temp1_y,gauge1_startx,gauge1_starty, \
gauge2_startx,gauge2_startx
# some default parameters
# for lights
text1 = "A"
text2 = "B"
light1Color = "green"
light2Color = "black"
light1_obj = None
light2_obj = None
# for gauges
text3 = "C"
text4 = "D"
gauge1_startx = 60
gauge1_starty = 200
gauge2_startx = 110
gauge2_starty = 200
gauge1_rate = 2
gauge2_rate = 2
fps = 5
actr.reset()
window = actr.open_exp_window("hello world",
width=400,
height=400,
x=400,
y=400)
# adding commands
actr.add_command("demo2-key-press", respond_to_key_press,
"Demo2 task output-key monitor")
actr.add_command("gauge_1_move", gauge_1_move)
actr.add_command("gauge_2_move", gauge_2_move)
actr.add_command("light1_off", light1_off)
actr.add_command("light2_off", light2_off)
actr.add_command("delayed_print_visicon", delayed_print_visicon)
actr.add_command("move_y", move_y)
# monitoring for key board
actr.monitor_command("output-key", "demo2-key-press")
# putting the initial screen onto the window
intialize_screen(window, text1, text2, text3, text4, gauge1_startx,
gauge1_starty, gauge2_startx, gauge2_starty)
response = False
# human = participant. Good for testing
if human == True:
if actr.visible_virtuals_available():
# puts time.sleep(0)
# I guess it lets the program run
# maybe will need to change in the future
while response == False:
actr.process_events()
else:
actr.install_device(window)
light1 = 1
light2 = 1
time1 = 0
count = 0
for event in range(0, df.shape[0]):
time1 = df["time"][event]
count += 1
if df["event"][event] == (
" 'Green (First) Light Script-triggered Fault'"
) and light1 == 1:
#actr.schedule_event(time1-.1,"delayed_print_visicon",params=[],maintenance=True)
actr.schedule_event(time1,
"light1_off",
params=[window, text1, "exp"],
maintenance=True)
event_times.append(time1)
event_type.append("light1_off")
#actr.schedule_event(time1+.1,"delayed_print_visicon",params=[],maintenance=True)
elif df["event"][event] == (
" 'Red (Second) Light Script-triggered Fault'"
) and light2 == 1:
actr.schedule_event(time1,
"light2_off",
params=[window, text2, "exp"],
maintenance=True)
event_times.append(time1)
event_type.append("light2_off")
# parameters for gauges
temp1_y = gauge1_starty
temp2_y = gauge2_starty
time1 = 0
first_time_exceeded_gauge1 = 0
first_time_exceeded_gauge2 = 0
gauges_on = 1
#
if gauges_on == 1:
for event in range(0,
round(df["time"][len(df["time"]) - 1] * fps)):
time1 = time1 + (1 / fps)
temp1_y = temp1_y + gauge1_rate
temp2_y = temp2_y + (gauge2_rate * -1)
if temp1_y < 150 or temp1_y > 250:
gauge1_color = "red"
if first_time_exceeded_gauge1 == 0:
first_time_exceeded_gauge1 += 1
actr.schedule_event(time1,
"delayed_print_visicon",
params=[],
maintenance=True)
actr.schedule_event(time1 + .1,
"delayed_print_visicon",
params=[],
maintenance=True)
else:
gauge1_color = "black"
first_time_exceeded_gauge1 = 0
if temp2_y < 150 or temp2_y > 250:
gauge2_color = "red"
if first_time_exceeded_gauge2 == 0:
first_time_exceeded_gauge2 += 1
else:
gauge2_color = "black"
first_time_exceeded_gauge2 = 0
if temp1_y < 125 or temp1_y > 275:
gauge1_rate = gauge1_rate * -1
if first_time_exceeded_gauge1 == 1:
event_times.append(time1)
event_type.append("gauge1_off")
if temp2_y < 125 or temp2_y > 275:
gauge2_rate = gauge2_rate * -1
if first_time_exceeded_gauge2 == 1:
event_times.append(time1)
event_type.append("gauge2_off")
#actr.schedule_event(time1-.1,"delayed_print_visicon",params=[],maintenance=True)
actr.schedule_event(time1,
"gauge_1_move",
params=[
window, text3, gauge1_startx, temp1_y,
gauge1_color
],
maintenance=True)
actr.schedule_event(time1,
"gauge_2_move",
params=[
window, text4, gauge2_startx, temp2_y,
gauge2_color
],
maintenance=True)
#actr.schedule_event(time1+.1,"delayed_print_visicon",params=[],maintenance=True)
#actr.run(df["time"][len(df["time"])-1])
actr.run(15, True)
# pause actr
# removing commands and things
actr.remove_command_monitor("output-key", "demo2-key-press")
actr.remove_command("gauge_1_move")
actr.remove_command("gauge_2_move")
actr.remove_command("light1_off")
actr.remove_command("light2_off")
actr.remove_command("move_y")
# printing some things
print("respones", responses)
print("response_times", times)
print("event_times", event_times)
print("event_type", event_type)
def play(player1, player2):
global p1, p2, p1_position, p2_position, game_over, current_player, safety_stop, winner, p1p1, p1p2, p2p1, p2p2
if (player1.lower() in (x.lower() for x in actr.mp_models())) and (
player2.lower() in (x.lower() for x in actr.mp_models())):
actr.add_command('stop-a-run', stop_a_run,
'Set the flag to terminate the game.')
win = actr.open_exp_window('Safety',
visible=True,
height=100,
width=100,
x=100,
y=300)
actr.add_button_to_exp_window('Safety',
text='STOP',
x=0,
y=0,
action='stop-a-run',
height=90,
width=90,
color='red')
actr.add_command('move', make_move, 'Handle player key presses')
actr.monitor_command('output-key', 'move')
actr.reset()
# initialize the game information
p1 = player1
p2 = player2
p1_position = 0
p2_position = 5
game_over = False
current_player = player1
safety_stop = False
winner = None
actr.set_current_model(player1)
actr.define_chunks(player2)
feats = actr.add_visicon_features([
'isa', ['player-loc', 'player'], 'screen-x', 0, 'screen-y', 0,
'name', player1, 'position', [False, p1_position], 'turn',
[False, True]
], [
'isa', ['player-loc', 'player'], 'screen-x', 100, 'screen-y', 0,
'name', player2, 'position', [False, p2_position]
])
p1p1 = feats[0]
p1p2 = feats[1]
actr.set_current_model(player2)
actr.define_chunks(player1)
feats = actr.add_visicon_features([
'isa', ['player-loc', 'player'], 'screen-x', 0, 'screen-y', 0,
'name', player1, 'position', [False, p1_position], 'turn',
[False, True]
], [
'isa', ['player-loc', 'player'], 'screen-x', 100, 'screen-y', 0,
'name', player2, 'position', [False, p2_position]
])
p2p1 = feats[0]
p2p2 = feats[1]
actr.add_command('is-game-over', is_game_over,
'Test whether game should stop running.')
actr.add_command('set_game_over', set_game_over,
'Set the flag to stop the game.')
actr.run_until_condition('is-game-over')
actr.clear_exp_window(win)
actr.remove_command('stop-a-run')
actr.remove_command_monitor('output-key', 'move')
actr.remove_command('move')
actr.remove_command('is-game-over')
actr.remove_command('set_game_over')
return winner
def build_display(a, b, c, d, e, f, goal):
global window, target, current_stick, done, current_line, choice
target = goal
current_stick = 0
done = False
choice = None
current_line = None
window = actr.open_exp_window("停车对标",
visible=visible,
width=600,
height=400)
actr.add_button_to_exp_window(window,
text="A",
x=5,
y=23,
action=["bst-button-pressed", a, "under"],
height=24,
width=40)
actr.add_button_to_exp_window(window,
text="B",
x=5,
y=48,
action=["bst-button-pressed", b, "over"],
height=24,
width=40)
actr.add_button_to_exp_window(window,
text="C",
x=5,
y=73,
action=["bst-button-pressed", c, "under"],
height=24,
width=40)
actr.add_button_to_exp_window(window,
text="D",
x=5,
y=98,
action=["bst-button-pressed", d, "under"],
height=24,
width=40)
actr.add_button_to_exp_window(window,
text="E",
x=5,
y=120,
action=["bst-button-pressed", e, "under"],
height=24,
width=40)
actr.add_button_to_exp_window(window,
text="F",
x=5,
y=140,
action=["bst-button-pressed", f, "under"],
height=24,
width=40)
# actr.add_text_to_exp_window(window, text="实际距离： ", x=5, y=123, height=24, width=65)
actr.add_button_to_exp_window(window,
text="Reset",
x=5,
y=340,
action="bst-reset-button-pressed",
height=24,
width=65)
actr.add_line_to_exp_window(window, [75, 35], [a + 75, 35], "black")
actr.add_line_to_exp_window(window, [75, 60], [b + 75, 60], "black")
actr.add_line_to_exp_window(window, [75, 85], [c + 75, 85], "black")
actr.add_line_to_exp_window(window, [75, 110], [d + 75, 110], "black")
actr.add_line_to_exp_window(window, [75, 135], [e + 75, 135], "black")
actr.add_line_to_exp_window(window, [75, 160], [f + 75, 160], "black")
actr.add_line_to_exp_window(window, [75, 310], [goal + 75, 310], "green")
# actr.add_line_to_exp_window(window, [75, 320], [current_stick + 75, 215], "blue")
actr.add_text_to_exp_window(
window,
"注意！\nB表示目标距离；模型先注视ABCDEF四条线，之后将目标线与C对比，求其差值，依次比较A,D,E,F,直至出现Done,结束对标。\nA表示四级制动，制动距离较长；"
"\nC表示一级制动，制动距离最长;",
x=400,
y=310,
color='blue',
height=200,
width=150,
font_size=12)
def play(player1, player2):
global window, p1, p2, p1_position, p2_position, current_player, game_over, safety_stop, p1_text, p2_text
if (player1.lower() in (x.lower() for x in actr.mp_models())) and (
player2.lower() in (x.lower() for x in actr.mp_models())):
actr.reset()
actr.set_current_model(player1)
# create a goal chunk with the player's color and name
actr.define_chunks([
'goal', 'isa', 'play', 'my-color', 'red', 'my-name',
"'%s'" % player1
])
actr.goal_focus('goal')
actr.set_parameter_value(':show-focus', 'red')
actr.set_current_model(player2)
# create a goal chunk with the player's color and name
actr.define_chunks([
'goal', 'isa', 'play', 'my-color', 'blue', 'my-name',
"'%s'" % player2
])
actr.goal_focus('goal')
actr.set_parameter_value(':show-focus', 'blue')
window = actr.open_exp_window("game",
visible=True,
width=200,
height=100)
safety_window = actr.open_exp_window('Safety',
visible=True,
height=100,
width=100,
x=100,
y=100)
actr.add_command('stop-a-run', stop_a_run,
'Set the flag to terminate the game.')
actr.add_button_to_exp_window(safety_window,
text="STOP",
x=0,
y=0,
action='stop-a-run',
height=80,
width=80,
color='red')
p1 = player1
p2 = player2
game_over = False
safety_stop = False
current_player = player1
p1_position = 0
p2_position = 5
for m in actr.mp_models():
actr.set_current_model(m)
actr.install_device(window)
p1_text = actr.add_text_to_exp_window(window,
str(p1_position),
x=20,
y=10,
color='red',
height=30,
width=30,
font_size=20)
p2_text = actr.add_text_to_exp_window(window,
str(p2_position),
x=140,
y=10,
color='blue',
height=30,
width=30,
font_size=20)
actr.add_command("process-moves", process_moves,
"Handle player speak actions")
actr.monitor_command("output-speech", "process-moves")
# speak to all models telling them the name
# of the first player.
for m in actr.mp_models():
actr.set_current_model(m)
actr.new_word_sound(p1, 0, 'start')
actr.add_command('is-game-over', is_game_over,
'Test whether game should stop running.')
actr.add_command('set_game_over', set_game_over,
'Set the flag to stop the game.')
actr.run_until_condition('is-game-over', True)
actr.remove_command_monitor("output-speech", "process-moves")
actr.remove_command("process-moves")
actr.remove_command('stop-a-run')
actr.remove_command('is-game-over')
actr.remove_command('set_game_over')
return game_over
