pub fn new() -> ActionContext {
        


        /* Other already defined actions go above here */

        // The precondition for moving left and up by one:
        // The closure is given the agent id, the agent manager and grid
        let left_up_step_precond: Precondition = |id, am, grid| {
            let position = am.get_position(id);

            // Make sure that the agent is not already standing on
            // the left-most or top-most edge of the grid
            if position.x == 0 || position.y == 0 {
                return false;
            }
            if COLLSION_DETECTION {
                // Check that the destination has no other
                // agents around its vicinity.
                // In grid.rs, check out the following methods
                // for searching the grid:
                // 'is_subgrid_free', 'is_subgrid_occupied',
                // 'get_subgrid_occupiers'
                grid.is_subgrid_free(
                    // Destination
                    Position {
                        x: position.x - 1,
                        y: position.y - 1,
                    },
                    // See the Parameters secion in Readme
                    STEP_SG_SIDE,
                    STEP_SG_SIDE,
                    // Agent ids which should be ignored in
                    // checking whether the vicinity is free
                    vec![id],
                    // Optional closure of type
                    // Option<&dyn Fn(Id) -> bool>
                    // which checks if given an id of
                    // an agent inside the defined vicinity
                    // should it be ignored or not.
                    // Check out the tag_precond function
                    // which includes a closure which
                    // tells grid to ignore other agents
                    // which are already tagged
                    None,
                )
            } else {
                true
            }
        };

        // The effect of executing the action of moving
        // left and up by one, calling this realises the change
        // in the simulation
        let left_up_step_effect: Effect = |id, am, _grid| {
            let mut position = am.get_position(id);
            position.x -= 1;
            position.y -= 1;
            am.set_position(id, position);
        };

        // Create the action by combining the precondition and effect
        let left_up_step: Action = Action {
            precond: left_up_step_precond,
            effect: left_up_step_effect,
        };

        // Put all actions (including the new, 7th action) in a vector
        let actions: Vec<Action> = vec![
            left_step,
            right_step,
            up_step,
            down_step,
            do_nothing,
            tag,
            left_up_step,
        ];
        let action_count = actions.len();

        ActionContext {
            actions,
            // Define some weights for each action (in the same order
            // as in 'actions') indicating what preferences should
            // agents have on average. For example 0.5 for left_up_step
            // shows that it should, in a longer timeframe, be picked
            // as often as left_step, right_step, up_step and down_step
            mean_preferences: vec![0.5, 0.5, 0.5, 0.5, 0.1, 0.9, 0.5],
            action_count,
        }
    }