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