Walls

Description

Walls are considered an “actor” in Quanser Interactive Labs Open Worlds. Walls can be spawned anywhere in the Open Worlds and accompany several different products including the QCar Studio and the QBot Platform. The origin of the wall is at the bottom center. Walls are static by default but dynamics can be optionally enabled.

Library

class qvl.walls.QLabsWalls(qlabs, verbose=False)[source]: This class is for spawning both static and dynamic walls.

Constants

QLabsWalls.ID_WALL = 10080: Class ID

Member Variables

QLabsWalls.actorNumber = None: The current actor number of this class to be addressed. This will be set by spawn methods and cleared by destroy methods. It will not be modified by the destroy all actors. This can be manually altered at any time to use one object to address multiple actors.

Methods

QLabsWalls.spawn(location=[0, 0, 0], rotation=[0, 0, 0], scale=[1, 1, 1], configuration=0, waitForConfirmation=True)

Spawns a new actor with the next available actor number within this class.

Parameters

location (float array[3]) – (Optional) An array of floats for x, y and z coordinates
rotation (float array[3]) – (Optional) An array of floats for the roll, pitch, and yaw in radians
scale (float array[3]) – (Optional) An array of floats for the scale in the x, y, and z directions. Scale values of 0.0 should not be used.
configuration (uint32) – (Optional) Spawn configuration. See class library for configuration options.
waitForConfirmation (boolean) – (Optional) Make this operation blocking until confirmation of the spawn has occurred. Note that if this is False, the returned actor number will be invalid.

Returns

status - 0 if successful, 1 class not available, 3 unknown error, -1 communications error.
actorNumber - An actor number to use for future references.

Return type

int32, int32

QLabsWalls.spawn_degrees(location=[0, 0, 0], rotation=[0, 0, 0], scale=[1, 1, 1], configuration=0, waitForConfirmation=True)

Spawns a new actor with the next available actor number within this class.

Parameters

location (float array[3]) – (Optional) An array of floats for x, y and z coordinates
rotation (float array[3]) – (Optional) An array of floats for the roll, pitch, and yaw in degrees
scale (float array[3]) – (Optional) An array of floats for the scale in the x, y, and z directions. Scale values of 0.0 should not be used.
configuration (uint32) – (Optional) Spawn configuration. See class library for configuration options.
waitForConfirmation (boolean) – (Optional) Make this operation blocking until confirmation of the spawn has occurred. Note that if this is False, the returned actor number will be invalid.

Returns

status - 0 if successful, 1 class not available, 3 unknown error, -1 communications error.
actorNumber - An actor number to use for future references.

Return type

int32, int32

QLabsWalls.spawn_id(actorNumber, location=[0, 0, 0], rotation=[0, 0, 0], scale=[1, 1, 1], configuration=0, waitForConfirmation=True)

Spawns a new actor.

Parameters

actorNumber (uint32) – User defined unique identifier for the class actor in QLabs
location (float array[3]) – (Optional) An array of floats for x, y and z coordinates
rotation (float array[3]) – (Optional) An array of floats for the roll, pitch, and yaw in radians
scale (float array[3]) – (Optional) An array of floats for the scale in the x, y, and z directions. Scale values of 0.0 should not be used.
configuration (uint32) – (Optional) Spawn configuration. See class library for configuration options.
waitForConfirmation (boolean) – (Optional) Make this operation blocking until confirmation of the spawn has occurred.

Returns

status - 0 if successful, 1 class not available, 2 actor number not available or already in use, 3 unknown error, -1 communications error

Return type

int32

QLabsWalls.spawn_id_degrees(actorNumber, location=[0, 0, 0], rotation=[0, 0, 0], scale=[1, 1, 1], configuration=0, waitForConfirmation=True)

Spawns a new actor.

Parameters

actorNumber (uint32) – User defined unique identifier for the class actor in QLabs
location (float array[3]) – (Optional) An array of floats for x, y and z coordinates
rotation (float array[3]) – (Optional) An array of floats for the roll, pitch, and yaw in radians
scale (float array[3]) – (Optional) An array of floats for the scale in the x, y, and z directions. Scale values of 0.0 should not be used.
configuration (uint32) – (Optional) Spawn configuration. See class library for configuration options.
waitForConfirmation (boolean) – (Optional) Make this operation blocking until confirmation of the spawn has occurred.

Returns

status - 0 if successful, 1 class not available, 2 actor number not available or already in use, 3 unknown error, -1 communications error

Return type

int32

QLabsWalls.spawn_id_and_parent_with_relative_transform(actorNumber, location=[0, 0, 0], rotation=[0, 0, 0], scale=[1, 1, 1], configuration=0, parentClassID=0, parentActorNumber=0, parentComponent=0, waitForConfirmation=True)

Spawns a new actor relative to an existing actor and creates a kinematic relationship.

Parameters

actorNumber (uint32) – User defined unique identifier for the class actor in QLabs
location (float array[3]) – (Optional) An array of floats for x, y and z coordinates
rotation (float array[3]) – (Optional) An array of floats for the roll, pitch, and yaw in radians
scale (float array[3]) – (Optional) An array of floats for the scale in the x, y, and z directions. Scale values of 0.0 should not be used.
configuration (uint32) – (Optional) Spawn configuration. See class library for configuration options.
parentClassID (uint32) – See the ID variables in the respective library classes for the class identifier
parentActorNumber (uint32) – User defined unique identifier for the class actor in QLabs
parentComponent (uint32) – 0 for the origin of the parent actor, see the parent class for additional reference frame options
waitForConfirmation (boolean) – (Optional) Make this operation blocking until confirmation of the spawn has occurred.

Returns

status - 0 if successful, 1 class not available, 2 actor number not available or already in use, 3 cannot find the parent actor, 4 unknown error, -1 communications error

Return type

int32

QLabsWalls.spawn_id_and_parent_with_relative_transform_degrees(actorNumber, location=[0, 0, 0], rotation=[0, 0, 0], scale=[1, 1, 1], configuration=0, parentClassID=0, parentActorNumber=0, parentComponent=0, waitForConfirmation=True)

Spawns a new actor relative to an existing actor and creates a kinematic relationship.

Parameters

actorNumber (uint32) – User defined unique identifier for the class actor in QLabs
location (float array[3]) – (Optional) An array of floats for x, y and z coordinates
rotation (float array[3]) – (Optional) An array of floats for the roll, pitch, and yaw in degrees
scale (float array[3]) – (Optional) An array of floats for the scale in the x, y, and z directions. Scale values of 0.0 should not be used.
configuration (uint32) – (Optional) Spawn configuration. See class library for configuration options.
parentClassID (uint32) – See the ID variables in the respective library classes for the class identifier
parentActorNumber (uint32) – User defined unique identifier for the class actor in QLabs
parentComponent (uint32) – 0 for the origin of the parent actor, see the parent class for additional reference frame options
waitForConfirmation (boolean) – (Optional) Make this operation blocking until confirmation of the spawn has occurred.

Returns

status - 0 if successful, 1 class not available, 2 actor number not available or already in use, 3 cannot find the parent actor, 4 unknown error, -1 communications error

Return type

int32

QLabsWalls.destroy()

Find and destroy a specific actor. This is a blocking operation.

Returns

numActorsDestroyed - The number of actors destroyed. -1 if failed.

Return type

int32

QLabsWalls.destroy_all_actors_of_class()

Find and destroy all actors of this class. This is a blocking operation.

Returns

numActorsDestroyed - The number of actors destroyed. -1 if failed.

Return type

int32

QLabsWalls.ping()

Checks if the actor is still present in the environment. Note that if you did not spawn the actor with one of the spawn functions, you may need to manually set the actorNumber member variable.

Returns

status - True if successful, False otherwise

Return type

boolean

QLabsWalls.get_world_transform()

Get the location, rotation, and scale in world coordinates of the actor.

Returns

status - True if successful, False otherwise
location
rotation
scale

Return type

boolean, float array[3], float array[3], float array[3]

QLabsWalls.get_world_transform_degrees()

Get the location, rotation, and scale in world coordinates of the actor.

Returns

status - True if successful, False otherwise
location
rotation
scale

Return type

boolean, float array[3], float array[3], float array[3]

QLabsWalls.parent_with_relative_transform(location=[0, 0, 0], rotation=[0, 0, 0], scale=[1, 1, 1], parentClassID=0, parentActorNumber=0, parentComponent=0, waitForConfirmation=True)

Parents one existing actor to another to create a kinematic relationship.

Parameters

location (float array[3]) – (Optional) An array of floats for x, y and z coordinates
rotation (float array[3]) – (Optional) An array of floats for the roll, pitch, and yaw in radians
scale (float array[3]) – (Optional) An array of floats for the scale in the x, y, and z directions. Scale values of 0.0 should not be used.
parentClassID (uint32) – See the ID variables in the respective library classes for the class identifier
parentActorNumber (uint32) – User defined unique identifier for the class actor in QLabs
parentComponent (uint32) – 0 for the origin of the parent actor, see the parent class for additional reference frame options
waitForConfirmation (boolean) – (Optional) Make this operation blocking until confirmation of the spawn has occurred.

Returns

status - 0 if successful, 1 cannot find this actor, 2 cannot find the parent actor, 3 unknown error, -1 communications error

Return type

int32

QLabsWalls.parent_with_relative_transform_degrees(location=[0, 0, 0], rotation=[0, 0, 0], scale=[1, 1, 1], parentClassID=0, parentActorNumber=0, parentComponent=0, waitForConfirmation=True)

Parents one existing actor to another to create a kinematic relationship.

Parameters

location (float array[3]) – (Optional) An array of floats for x, y and z coordinates
rotation (float array[3]) – (Optional) An array of floats for the roll, pitch, and yaw in degrees
scale (float array[3]) – (Optional) An array of floats for the scale in the x, y, and z directions. Scale values of 0.0 should not be used.
parentClassID (uint32) – (Optional) See the ID variables in the respective library classes for the class identifier
parentActorNumber (uint32) – (Optional) User defined unique identifier for the class actor in QLabs
parentComponent (uint32) – (Optional) 0 for the origin of the parent actor, see the parent class for additional reference frame options
waitForConfirmation (boolean) – (Optional) Make this operation blocking until confirmation of the spawn has occurred.

Returns

status - 0 if successful, 1 cannot find this actor, 2 cannot find the parent actor, 3 unknown error, -1 communications error

Return type

int32

QLabsWalls.parent_with_current_world_transform(parentClassID=0, parentActorNumber=0, parentComponent=0, waitForConfirmation=True)

Parents one existing actor to another to create a kinematic relationship while preserving the current world transform of the child actor.

Parameters

parentClassID (uint32) – See the ID variables in the respective library classes for the class identifier
parentActorNumber (uint32) – User defined unique identifier for the class actor in QLabs
parentComponent (uint32) – 0 for the origin of the parent actor, see the parent class for additional reference frame options
waitForConfirmation (boolean) – (Optional) Make this operation blocking until confirmation of the spawn has occurred.

Returns

status - 0 if successful, 1 cannot find this actor, 2 cannot find the parent actor, 3 unknown error, -1 communications error

Return type

int32

QLabsWalls.parent_break(waitForConfirmation=True)

Breaks any relationship with a parent actor (if it exists) and preserves the current world transform

Parameters

waitForConfirmation (boolean) – (Optional) Make this operation blocking until confirmation of the spawn has occurred.

Returns

status - 0 if successful, 1 cannot find this actor, -1 communications error

Return type

int32

QLabsWalls.set_enable_dynamics(enableDynamics, waitForConfirmation=True)[source]

Sets the physics properties of the wall.

Parameters

enableDynamics (boolean) – Enable (True) or disable (False) the wall dynamics. A dynamic actor can be pushed with other static or dynamic actors. A static actor will generate collisions, but will not be affected by interactions with other actors.
waitForConfirmation (boolean) – (Optional) Wait for confirmation of the operation before proceeding. This makes the method a blocking operation.

Returns

True if successful, False otherwise

Return type

boolean

QLabsWalls.set_enable_collisions(enableCollisions, waitForConfirmation=True)[source]

Enables and disables physics collisions. When disabled, other physics or velocity-based actors will be able to pass through.

Parameters

enableCollisions (boolean) – Enable (True) or disable (False) the collision.
waitForConfirmation (boolean) – (Optional) Wait for confirmation of the operation before proceeding. This makes the method a blocking operation.

Returns

True if successful, False otherwise

Return type

boolean

QLabsWalls.set_physics_properties(enableDynamics, mass=1.0, linearDamping=0.01, angularDamping=0.0, staticFriction=0.0, dynamicFriction=0.7, frictionCombineMode=COMBINE_AVERAGE, restitution=0.3, restitutionCombineMode=COMBINE_AVERAGE, waitForConfirmation=True)[source]

Sets the dynamic properties of the wall.

Parameters

enableDynamics (boolean) – Enable (True) or disable (False) the wall dynamics. A dynamic actor can be pushed with other static or dynamic actors. A static actor will generate collisions, but will not be affected by interactions with other actors.
mass (float) – (Optional) Sets the mass of the actor in kilograms.
linearDamping (float) – (Optional) Sets the damping of the actor for linear motions.
angularDamping (float) – (Optional) Sets the damping of the actor for angular motions.
staticFriction (float) – (Optional) Sets the coefficient of friction when the actor is at rest. A value of 0.0 is frictionless.
dynamicFriction (float) – (Optional) Sets the coefficient of friction when the actor is moving relative to the surface it is on. A value of 0.0 is frictionless.
frictionCombineMode (byte) – (Optional) Defines how the friction between two surfaces with different coefficients should be calculated (see COMBINE constants).
restitution (float) – (Optional) The coefficient of restitution defines how plastic or elastic a collision is. A value of 0.0 is plastic and will absorb all energy. A value of 1.0 is elastic and will bounce forever. A value greater than 1.0 will add energy with each collision.
restitutionCombineMode (byte) – (Optional) Defines how the restitution between two surfaces with different coefficients should be calculated (see COMBINE constants).
waitForConfirmation (boolean) – (Optional) Wait for confirmation of the operation before proceeding. This makes the method a blocking operation.

Returns

True if successful, False otherwise

Return type

boolean

QLabsWalls.set_transform(location, rotation, scale, waitForConfirmation=True)[source]

Sets the location, rotation in radians, and scale. If a wall is parented to another actor then the location, rotation, and scale are relative to the parent actor.

Parameters

location (float array[3]) – An array of floats for x, y and z coordinates in full-scale units. Multiply physical QCar locations by 10 to get full scale locations.
rotation (float array[3]) – An array of floats for the roll, pitch, and yaw in radians
scale (float array[3]) – An array of floats for the scale in the x, y, and z directions.
waitForConfirmation (boolean) – (Optional) Wait for confirmation of the operation before proceeding. This makes the method a blocking operation.

Returns

True if successful or False otherwise

Return type

boolean

QLabsWalls.set_transform_degrees(location, rotation, scale, waitForConfirmation=True)[source]

Sets the location, rotation in degrees, and scale. If a wall is parented to another actor then the location, rotation, and scale are relative to the parent actor.

Parameters

location (float array[3]) – An array of floats for x, y and z coordinates in full-scale units. Multiply physical QCar locations by 10 to get full scale locations.
rotation (float array[3]) – An array of floats for the roll, pitch, and yaw in degrees
scale (float array[3]) – An array of floats for the scale in the x, y, and z directions.
waitForConfirmation (boolean) – (Optional) Wait for confirmation of the operation before proceeding. This makes the method a blocking operation.

Returns

True if successful or False otherwise

Return type

boolean

Configurations

There is only one configuration for the walls class.

Connection Points

There are no connection points for this actor class.

Walls Tutorial

Maze

Raw to download this tutorial: Wall Maze Tutorial (.py).

"""
Maze Example
---------------

.. note::

    Make sure you have Quanser Interactive Labs open before running this
    example. This example is designed to be run in the Plane or Warehouse
    environment.

"""

from qvl.qlabs import QuanserInteractiveLabs
from qvl.free_camera import QLabsFreeCamera 
from qvl.system import QLabsSystem

import numpy as np
import random
import time

from qvl.walls import QLabsWalls

# Use the ramdom seed if you want the same maze every time (uncomment the following line)
#random.seed(12)

# Do you want the walls to be able to fall over if hit? (Maze generation will take slightly longer.)
dynamic_walls = False

# Maze size
maze_x = 10
maze_y = 10

# Initialize constants and variables. We'll use a bit mask to efficiently store multiple
# pieces of information inside a single value.
North =      0b00001
East =       0b00010
South =      0b00100
West =       0b01000
Unexplored = 0b10000
maze_data = np.ones(shape=(maze_x,maze_y), dtype=int) * (North | East | South | West | Unexplored)

# Length of a wall segment plus a bit of padding
wall_length = 1.05



def generate_maze():
    location = [0, 0]

    # Mark the first cell as explored and remove the North wall as the entrance to the maze
    maze_data[0,0] = maze_data[0,0] & (~Unexplored) & (~North)

    # Start digging through the maze recursively
    remove_maze_wall(location)

    # Remove one wall on the South side of the maze
    maze_data[0,maze_y-1] = maze_data[0,maze_y-1] & (~South)


def remove_maze_wall(location):
    
    # first pick a random direction (N, S, W, E) (The order helps reduce "easy" solutions to the maze)
    first_direction = random.randint(0,3)
    
    # Check all four compass directions for a valid travel path
    for direction in range(4):

        # Offset the direction count by the random direction
        current_direction = (direction + first_direction) % 4

        if (current_direction == 0):
            if ((location[1] > 0) and (maze_data[location[0], location[1]-1] & Unexplored)):
                # Remove North wall from the current cell and the South wall of the new cell and mark the new cell as explored
                maze_data[location[0], location[1]-1] = maze_data[location[0], location[1]-1] & (~Unexplored)
                maze_data[location[0], location[1]-1] = maze_data[location[0], location[1]-1] & (~South)
                maze_data[location[0], location[1]]   = maze_data[location[0], location[1]] & (~North)

                remove_maze_wall([location[0], location[1]-1])

        elif (current_direction == 1):
            if ((location[1] < (maze_y-1)) and (maze_data[location[0], location[1]+1] & Unexplored)):
                # Remove South wall from the current cell and the North wall of the new cell and mark the new cell as explored
                maze_data[location[0], location[1]+1] = maze_data[location[0], location[1]+1] & (~Unexplored)
                maze_data[location[0], location[1]+1] = maze_data[location[0], location[1]+1] & (~North)
                maze_data[location[0], location[1]]   = maze_data[location[0], location[1]] & (~South)

                remove_maze_wall([location[0], location[1]+1])   

        elif (current_direction == 2):
            if ((location[0] > 0) and (maze_data[location[0]-1, location[1]] & Unexplored)):
                # Remove West wall from the current cell and the East wall of the new cell and mark the new cell as explored
                maze_data[location[0]-1, location[1]] = maze_data[location[0]-1, location[1]] & (~Unexplored)
                maze_data[location[0]-1, location[1]] = maze_data[location[0]-1, location[1]] & (~East)
                maze_data[location[0],   location[1]] = maze_data[location[0], location[1]] & (~West)

                remove_maze_wall([location[0]-1, location[1]])   

        else:            
            if ((location[0] < (maze_x-1)) and (maze_data[location[0]+1, location[1]] & Unexplored)):
                # Remove East wall from the current cell and the West wall of the new cell and mark the new cell as explored
                maze_data[location[0]+1, location[1]] = maze_data[location[0]+1, location[1]] & (~Unexplored)
                maze_data[location[0]+1, location[1]] = maze_data[location[0]+1, location[1]] & (~West)
                maze_data[location[0],   location[1]] = maze_data[location[0], location[1]] & (~East)

                remove_maze_wall([location[0]+1, location[1]])            

              


def draw_maze(qlabs):
    # Initialize a wall object
    wall = QLabsWalls(qlabs)
    
    # add just the first top row
    for count_x in range(maze_x):
        if (maze_data[count_x, 0] & North):
            place_wall(wall, count_x, 0, North)
    
    for count_y in range(maze_y):
        # left most wall of the maze
        if (maze_data[0, count_y] & West):
            place_wall(wall, 0, count_y, West)

        # all the rest of the walls
        for count_x in range(maze_x):
            if (maze_data[count_x, count_y] & South):
                place_wall(wall, count_x, count_y, South)

            if (maze_data[count_x, count_y] & East):
                place_wall(wall, count_x, count_y, East)       

        if (not dynamic_walls):
            # If we're not waiting for any responses from QLabs, add
            # a slight delay after each row to ensure we don't overflow
            # the buffers for really large mazes.
            time.sleep(0.01)
        

        
def place_wall(wall, x, y, direction):
    # You can tweak the global x/y offset of the maze generation here by entering a position in meters.
    offset = [0, 0]

    # Walls are static by default so we only need to wait for confirmation if the dynamic_walls flag is set.    
    if direction == North:
        wall.spawn_degrees(location=[x*wall_length + offset[0], -(y*wall_length) + offset[1], 0.001], rotation=[0, 0, 90], waitForConfirmation=dynamic_walls)

    elif direction == East:
        wall.spawn_degrees(location=[x*wall_length + wall_length/2 + offset[0], -(y*wall_length + wall_length/2) + offset[1], 0.001], rotation=[0, 0, 0], waitForConfirmation=dynamic_walls)

    elif direction == South:
        wall.spawn_degrees(location=[x*wall_length + offset[0], -(y*wall_length + wall_length) + offset[1], 0.001], rotation=[0, 0, 90], waitForConfirmation=dynamic_walls)
    else:
        wall.spawn_degrees(location=[x*wall_length-wall_length/2 + offset[0], -(y*wall_length + wall_length/2) + offset[1], 0.001], rotation=[0, 0, 0], waitForConfirmation=dynamic_walls)
        
    if (dynamic_walls):
        wall.set_enable_dynamics(dynamic_walls)




def main():

    # Creates a server connection with Quanser Interactive Labs and manages
    # the communications
    qlabs = QuanserInteractiveLabs()

    # Ensure that QLabs is running on your local machine
    print("Connecting to QLabs...")
    if (not qlabs.open("localhost")):
        print("Unable to connect to QLabs")
        return    

    print("Connected")

    # Set the window title
    hSystem = QLabsSystem(qlabs)
    hSystem.set_title_string('Walls Tutorial')

    num_destroyed = qlabs.destroy_all_spawned_actors()

    # Initialize an instance of a camera 
    camera = QLabsFreeCamera(qlabs)

    # Set the spawn of the camera in a specific location 
    camera.spawn([-0.337, 3.205, 4.895], [-0, 0.59, -1.091], [1, 1, 1], 0, 1)
    camera.possess()
       
    generate_maze()
    draw_maze(qlabs)

    # Closing qlabs
    qlabs.close()
    print('Done!')

if __name__ == "__main__":
    main()

Maze

Raw to download this tutorial: Wall Maze Tutorial (.m).

% Wall Maze Example
% -------------------------
% 
% .. note::
% 
%     Make sure you have Quanser Interactive Labs open before running this
%     example.  This example is designed to be run in the Plane, Studio,
%     or Warehouse environments.

% Define globals
global North;
global East;
global South;
global West;
global Unexplored;
global maze_data;
global maze_x;
global maze_y;

load_qvl_path()

% Do you want the walls to be able to fall over if hit? (Maze generation will take slightly longer.)
dynamic_walls = false;

% Maze size
maze_x = 10;
maze_y = 10;

% Initialize constants and variables. We'll use a bit mask to efficiently store multiple
% pieces of information inside a single value.
North =      0b00001;
East =       0b00010;
South =      0b00100;
West =       0b01000;
Unexplored = 0b10000;
maze_data = uint8(ones(maze_x,maze_y)) * 0b11111; % (bit-or of N, E, S, W, and unexplored)


% Open communications
qlabs =  QuanserInteractiveLabs();
connection_established = qlabs.open('localhost');

if connection_established == false
    disp("Failed to open connection.")
    return
end

disp('Connected')

% Remove any existing actors
num_destroyed = qlabs.destroy_all_spawned_actors();

% Initialize an instance of a custom camera
camera = QLabsFreeCamera(qlabs);
camera.spawn([-0.337, 3.205, 4.895], [-0, 0.59, -1.091]);
camera.possess();


% Initialize instances of walls 
wall = QLabsWalls(qlabs);

generate_maze();
draw_maze(qlabs, dynamic_walls);

% Closing qlabs
qlabs.close();
disp('Done!');




function load_qvl_path()

    % --------------------------------------------------------------
    % Setting MATLAB Path for the libraries
    % Always keep at the start, it will make sure it finds the correct references
    newPathEntry = fullfile(getenv('QAL_DIR'), 'libraries', 'matlab', 'qvl');
    pathCell = regexp(path, pathsep, 'split');
    if ispc  % Windows is not case-sensitive
      onPath = any(strcmpi(newPathEntry, pathCell));
    else
      onPath = any(strcmp(newPathEntry, pathCell));
    end
    
    if onPath == 0
        path(path, newPathEntry)
        savepath
    end
    % --------------------------------------------------------------
end

function generate_maze()
    global North;
    global East;
    global South;
    global West;
    global Unexplored;
    global maze_data;
    global maze_x;
    global maze_y;

    location = [1, 1];

    % Mark the first cell as explored and remove the North wall as the entrance to the maze
    maze_data(1,1) = bitand(bitand(maze_data(1,1), bitcmp(Unexplored)), bitcmp(North));

    % Start digging through the maze recursively
    remove_maze_wall(location);

    % Remove one wall on the South side of the maze
    maze_data(1,maze_y) = bitand(maze_data(1,maze_y), bitcmp(South));
end

function remove_maze_wall(location)
    global North;
    global East;
    global South;
    global West;
    global Unexplored;
    global maze_data;
    global maze_x;
    global maze_y;

    % first pick a random direction (N, S, W, E) (The order helps reduce "easy" solutions to the maze)
    first_direction = randi([1 4]);

    % Check all four compass directions for a valid travel path
    for direction = 1:4

        % Offset the direction count by the random direction
        current_direction = (direction + first_direction);
        if current_direction > 4
            current_direction = current_direction - 4;
        end

        if (current_direction == 1)
            if ((location(2) > 1) && (bitand(maze_data(location(1), location(2)-1), Unexplored)))
                % Remove North wall from the current cell and the South wall of the new cell and mark the new cell as explored
                maze_data(location(1), location(2)-1) = bitand(maze_data(location(1), location(2)-1), bitcmp(Unexplored));
                maze_data(location(1), location(2)-1) = bitand(maze_data(location(1), location(2)-1), bitcmp(South));
                maze_data(location(1), location(2))   = bitand(maze_data(location(1), location(2)), bitcmp(North));

                remove_maze_wall([location(1), location(2)-1]);
            end

        elseif (current_direction == 2)
            if ((location(2) < (maze_y)) && (bitand(maze_data(location(1), location(2)+1), Unexplored)))
                % Remove South wall from the current cell and the North wall of the new cell and mark the new cell as explored
                maze_data(location(1), location(2)+1) = bitand(maze_data(location(1), location(2)+1), bitcmp(Unexplored));
                maze_data(location(1), location(2)+1) = bitand(maze_data(location(1), location(2)+1), bitcmp(North));
                maze_data(location(1), location(2))   = bitand(maze_data(location(1), location(2)), bitcmp(South));

                remove_maze_wall([location(1), location(2)+1]);
            end

        elseif (current_direction == 3)
            if ((location(1) > 1) && (bitand(maze_data(location(1)-1, location(2)), Unexplored)))
                % Remove West wall from the current cell and the East wall of the new cell and mark the new cell as explored
                maze_data(location(1)-1, location(2)) = bitand(maze_data(location(1)-1, location(2)), bitcmp(Unexplored));
                maze_data(location(1)-1, location(2)) = bitand(maze_data(location(1)-1, location(2)), bitcmp(East));
                maze_data(location(1),   location(2)) = bitand(maze_data(location(1), location(2)), bitcmp(West));

                remove_maze_wall([location(1)-1, location(2)]);
            end

        else       
            if ((location(1) < (maze_x)) && (bitand(maze_data(location(1)+1, location(2)), Unexplored)))
                % Remove East wall from the current cell and the West wall of the new cell and mark the new cell as explored
                maze_data(location(1)+1, location(2)) = bitand(maze_data(location(1)+1, location(2)), bitcmp(Unexplored));
                maze_data(location(1)+1, location(2)) = bitand(maze_data(location(1)+1, location(2)), bitcmp(West));
                maze_data(location(1),   location(2)) = bitand(maze_data(location(1), location(2)), bitcmp(East));

                remove_maze_wall([location(1)+1, location(2)]);
            end
        end
    end
end            


function draw_maze(qlabs, dynamic_walls)
    global North;
    global East;
    global South;
    global West;
    global maze_data;
    global maze_x;
    global maze_y;

    % Initialize a wall object
    wall = QLabsWalls(qlabs);

    % add just the first top row
    for count_x = 1:maze_x
        if (bitand(maze_data(count_x, 1), North))
            place_wall(wall, count_x, 1, North, dynamic_walls);
        end
    end

    for count_y = 1:maze_y
        % left most wall of the maze
        if (bitand(maze_data(1, count_y), West))
            place_wall(wall, 1, count_y, West, dynamic_walls);
        end

        % all the rest of the walls
        for count_x = 1:maze_x
            if (bitand(maze_data(count_x, count_y), South))
                place_wall(wall, count_x, count_y, South, dynamic_walls);
            end

            if (bitand(maze_data(count_x, count_y), East))
                place_wall(wall, count_x, count_y, East, dynamic_walls);            
            end
        end

        if (~dynamic_walls)
            % If we're not waiting for any responses from QLabs, add
            % a slight delay after each row to ensure we don't overflow
            % the buffers for really large mazes.
            pause(0.01);
        end
    end
end


function place_wall(wall, x, y, direction, dynamic_walls)
    global North;
    global East;
    global South;
    global West; %#ok<NUSED>

    % You can tweak the global x/y offset of the maze generation here by entering a position in meters.
    offset = [0, 0];

    % Length of a wall segment plus a bit of padding
    wall_length = 1.05;

    % Walls are static by default so we only need to wait for confirmation if the dynamic_walls flag is set.

    if direction == North
        wall.spawn_degrees([x*wall_length + offset(1), -(y*wall_length) + offset(2), 0.001], [0, 0, 90], [1,1,1], 0, dynamic_walls);
    
    elseif direction == East
        wall.spawn_degrees([x*wall_length + wall_length/2 + offset(1), -(y*wall_length + wall_length/2) + offset(2), 0.001], [0, 0, 0], [1,1,1], 0, dynamic_walls);

    elseif direction == South
        wall.spawn_degrees([x*wall_length + offset(1), -(y*wall_length + wall_length) + offset(2), 0.001], [0, 0, 90], [1,1,1], 0, dynamic_walls);
    else
        wall.spawn_degrees([x*wall_length-wall_length/2 + offset(1), -(y*wall_length + wall_length/2) + offset(2), 0.001], [0, 0, 0], [1,1,1], 0, dynamic_walls);
    end

    if (dynamic_walls)
        wall.set_enable_dynamics(dynamic_walls);
    end
end