mental-nav.mwel

%include 'mental-nav-stim'
%include 'eye'
%include 'keyboard'
%include 'mouse'
var sync = -1

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Display
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

stimulus_display (
    background_color = br, bg, bb
    redraw_on_every_refresh = true
    announce_stimuli_on_implicit_updates = false
)

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Experiment parameters
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

var num_trials_per_block = 10

var trials_from_meta = 1

var selection_trial_index = 0
var selection_seq_index = 0

var seq_index = 0

selection trial_index (
    values = 0:num_pairs
    selection = random_without_replacement
    advance_on_accept = YES
    autoreset = YES
)

var options_pos = [0, 0, 0, 0, 0, 0]
var options_bin = [0, 0, 0, 0, 0, 0]

%define update_block_params_from_meta ()
    selection_block_index = block_index
%end

%define update_trial_params_from_meta ()
    trials_from_meta = 1
    selection_trial_index = trial_index
    run_python_string(get_metaparameters())
    report('Trial $py_meta_index')
    start_stim_index = py_start_stim_index
    end_stim_index = py_end_stim_index
    pair_index = py_pair_index
    py_meta_index = py_meta_index
    options_bin = py_options_bin
    options_pos = py_options_pos
    num_options = py_num_options
    stim_dist_cum = py_stim_dist_cum
    stim_drift_direction = py_stim_drift_direction
%end

%define increment_alpha_m ()
    if (nconsecsuccess == nconsecsucc_increment) {
        nconsecsuccess = 0
        alpha_m = min(1, alpha_m_inc + alpha_m)
    }
    else {
        alpha_m = alpha_m
    }
%end

%define reset_vars ()
    choice = 0
    feedback = 0
    failure = 0
    success = 0
    ignore = 0

    selected = -1
    stim_drift_fixed = 0
    if (use_mouse) {
        reset_pointer_position (
            x_position=-100
            y_position=-100
        )
    }
%end

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Protocols
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

protocol 'Set for testing keyboard'{
    testing = 1
    rand_drift_pause_dur = 1
    use_keyboard = 1
    use_mouse = 0
}

protocol 'Mental Navigation - Sequential' {
    start_io_device (eye_tracker)
    start_io_device (keyboard)
    start_io_device (pointer)

    live_queue_stimulus (center_indicator)
    live_queue_stimulus (center_indicator_fill)

    for_each_stim {
        list {
	        live_queue_stimulus (img_stims[stim_index])
	        live_queue_stimulus (mask_stims[stim_index])
        }
    }

    live_queue_stimulus (window_mask_left)
    live_queue_stimulus (window_mask_right)

    reset_selection (trial_index)
    run_python_file ('mental-nav_utils.py')

    block (nsamples = 100) {
        trial {
            sync = 0
            update_trial_params_from_meta()

            for_each_option_stim {
                list {
                    live_queue_stimulus(option_stims[option_stim_index])
                }
            }

            display_option_selectors()

            task {
                state 'Begin fixation' {
                    report ("*********BEGIN FIXATION**********")

                    if (not testing) {
                        increment_alpha_m ()
                    }

                    fixation = 1

                    queue_stimulus (fixation_point)

                    update_display ()

                    wait (1s)

                    simulate_fixation ()

                    goto (
                        target = 'Pre drift'
                        when = eye_in_window and (not saccade)
                    )

                }
                state 'Pre drift' {
                    report ("*********PRE DRIFT**********")

                    fixation = 0
                    pre_drift = 1
                    sync = 1

                    dequeue_stimulus (fixation_point)
                    update_display ()

                    report ('direction = $py_stim_drift_direction')
                    report ('start index = $start_stim_index')
                    report ('end index = $end_stim_index')
                    report ('stim_dist_cum = $stim_dist_cum')

                    wait (pre_drift_dur)

                    goto (
                        target = 'Begin drift'
                    )
                }
                state 'Begin drift' {
                    report ("*********BEGIN DRIFT**********")

                    pre_drift = 0
                    drift = 1
                    sync = 2

                    goto ('Drift transition')
                }
                state 'Drift transition' {
                    report ("***********DRIFT TRANSITION***********")

                    drift_pause = 0
                    drift_transition = 1
                    sync = 3

                    stim_drift_start_time = next_frame_time()

                    goto (
                        target = 'Drift pause'
                        when = abs(stim_drift_transition) >= (stim_drift_transition_end - margin)
                    )

                }
                state 'Drift pause' {
                    report ("***********DRIFT PAUSE***********")
                    stim_drift_fixed = stim_drift_fixed + stim_drift_transition

                    drift_transition = 0
                    drift_pause = 1
                    sync = 4

                    if (rand_drift_pause_dur) {
                        drift_pause_dur = rand(0, 0.5) + 0.5
                    }

                    wait (drift_pause_dur)

                    goto (
                        target = 'Post drift'
                        when = abs(stim_drift_fixed) >= (stim_drift_end - margin)
                    )
                    goto (
                        target = 'Drift transition'
                    )
                }
                state 'Post drift' {
                    report ("*********POST DRIFT**********")

                    alpha_multiplier_fixed = alpha_multiplier_drift

                    drift = 0
                    post_drift = 1
                    sync = 3

                    wait (post_drift_dur)

                    goto  ('Pre choice')
                }
                state 'Pre choice' {
                    report ("*********PRE CHOICE**********")

                    post_drift = 0
                    pre_choice = 1
                    sync = 4

                    if (use_mouse) {
                        reset_pointer_position (
                            x_position=0
                            y_position=0
                        )
                    }

                    wait (pre_choice_dur)

                    goto ('Choice')
                }
                state 'Choice' {
                    report ("*********CHOICE**********")

                    pre_choice = 0
                    choice = 1
                    sync = 5

                    // wait (2s)
                    /*
                    if (not use_mouse) {
                        simulate_fixation_choice(end_stim_index)
                    }
                    */

                    start_timer (
                        timer = choice_timer
                        duration = choice_dur
                    )
                    goto (
                        target = 'Selected 0'
                        when = options_bin[0] * ((use_keyboard * keyboard_selected (0) ) or use_mouse * (selected_0))
                    )
                    goto (
                        target = 'Selected 1'
                        when = options_bin[1] * ((use_keyboard * keyboard_selected (1) ) or use_mouse * (selected_1))
                    )
                    goto (
                        target = 'Selected 2'
                        when = options_bin[2] * ((use_keyboard * keyboard_selected (2) ) or use_mouse * (selected_2))
                    )
                    goto (
                        target = 'Selected 3'
                        when = options_bin[3] * ((use_keyboard * keyboard_selected (3) ) or use_mouse * (selected_3))
                    )
                    goto (
                        target = 'Selected 4'
                        when = options_bin[4] * ((use_keyboard * keyboard_selected (4) ) or use_mouse * (selected_4))
                    )
                    goto (
                        target = 'Selected 5'
                        when = options_bin[5] * ((use_keyboard * keyboard_selected (5) ) or use_mouse * (selected_5))
                    )
                    goto (
                        target = 'Ignore'
                        when = timer_expired(choice_timer)
                    )
                }
                state 'Selected 0' {
                     report ("************SELECTED 0************")
                     selected = 0
                     goto (
                        target = 'Success'
                        when = end_stim_index == 0
                    )
                    goto (
                        target = 'Failure'
                        when = end_stim_index != 0
                    )
                }
                state 'Selected 1' {
                    report ("************SELECTED 1************")
                    selected = 1
                    goto (
                        target = 'Success'
                        when = end_stim_index == 1
                    )
                    goto (
                        target = 'Failure'
                        when = end_stim_index != 1
                    )
                }
                state 'Selected 2' {
                    report ("************SELECTED 2************")
                    selected = 2
                    goto (
                        target = 'Success'
                        when = end_stim_index == 2
                    )
                    goto (
                        target = 'Failure'
                        when = end_stim_index != 2
                    )
                }
                state 'Selected 3' {
                    report ("************SELECTED 3************")
                    selected = 3
                    goto (
                        target = 'Success'
                        when = end_stim_index == 3
                    )
                    goto (
                        target = 'Failure'
                        when = end_stim_index != 3
                    )
                }
                state 'Selected 4' {
                    report ("************SELECTED 4************")
                    selected = 4
                    goto (
                        target = 'Success'
                        when = end_stim_index == 4
                    )
                    goto (
                        target = 'Failure'
                        when = end_stim_index != 4
                    )
                }
                state 'Selected 5' {
                    report ("************SELECTED 5************")
                    selected = 5
                    goto (
                        target = 'Success'
                        when = end_stim_index == 5
                    )
                    goto (
                        target = 'Failure'
                        when = end_stim_index != 5
                    )
                }
                state 'Success' {
                    report ("*********SUCCESS**********")

                    nsuccess = nsuccess + 1
                    nconsecsuccess = nconsecsuccess + 1
                    success = 1

                    choice = 0
                    feedback = 1
                    sync = 6

                    wait (feedback_dur)
                    goto ('End trial')
                }
                state 'Failure' {
                    report ("*********FAILURE**********")

                    failure = 1
                    nfailure = nfailure + 1
                    nconsecsuccess = 0

                    choice = 0
                    feedback = 1
                    sync = 6


                    wait (feedback_dur)
                    goto ('End trial')
                }
                state 'Ignore' {

                    ignore = 1
                    nignore = nignore + 1
                    nconsecsuccess = 0


                    choice = 0
                    feedback = 1
                    sync = 6


                    wait (feedback_dur)
                    goto ('End trial')

                }
                state 'End trial' {
                    report ("*********END TRIAL**********")
                    accept_selections (trial_index)
                    reset_vars()
                    sync = -1
                    yield ()
                }

            }
        }
    }
    stop_io_device (pointer)
    stop_io_device (eye_tracker)
    stop_io_device (keyboard)
}