mms

Introduction

mms is a Micromouse simulator.

It makes it easy to write and test maze-solving code without a physical robot.

With it, you can:

Test how your robot would behave in a real maze
Visualize what your robot is thinking
- Show known/unknown walls
- Set the color of the cells
- Display ASCII text on the cells
Simulate a crash-and-reset scenario
Test your algorithm on custom maze files
Write code in any language you want

Previous versions of mms exist in the old/ directory.

For information about Micromouse, see the Micromouse Wikipedia page.

Download

You can download pre-compiled binaries from the releases page. Simply download the asset corresponding to your platform:

Windows: Download and unzip windows.zip and run the "mms" exe
macOS: Download and unzip macos.zip and run the "mms" app
- Note: you may get warnings about running an application from an unidentified developer. To get past those warnings, control-click on the app and select "Open" (as opposed to simply double-clicking on the app).

If pre-compiled binaries for your platform are unavailable, you'll have to build from source.

Quick Start

Writing a Micromouse algorithm is easy! Here are some available templates:

C++: mackorone/mms-cpp
Python: mackorone/mms-python

If a template for a particular language is missing, don't fret! Writing your own template is as easy as writing to stdout, reading from stdin, and implementing the mouse API below. If you have a template you'd like to share, please make a pull request!

Mouse API

Algorithms communicate with the simulator via stdin/stdout. To issue a command, simply print to stdout. To read a response, simply read from stdin. All valid commands are listed below. Invalid commands are simply ignored.

For commands that return a response, it's recommended to wait for the response before issuing additional commands.

Summary

int mazeWidth();
int mazeHeight();

bool wallFront();
bool wallRight();
bool wallLeft();

void moveForward();  // can result in "crash"
void turnRight();
void turnLeft();

void setWall(int x, int y, char direction);
void clearWall(int x, int y, char direction);

void setColor(int x, int y, char color);
void clearColor(int x, int y);
void clearAllColor();

void setText(int x, int y, const std::string& text);
void clearText(int x, int y);
void clearAllText();

bool wasReset();
void ackReset();

`mazeWidth`

Args: None
Action: None
Response: The height of the maze

`mazeHeight`

Args: None
Action: None
Response: The width of the maze

`wallFront`

Args: None
Action: None
Response: true if there is a wall in front of the robot, else false

`wallRight`

Args: None
Action: None
Response: true if there is a wall to the right of the robot, else false

`wallLeft`

Args: None
Action: None
Response: true if there is a wall to the left of the robot, else false

`moveForward`

Args: None
Action: Move the robot forward by one cell
Response:
- crash if there is a wall in front of the robot
- else ack once the movement completes

`turnRight`

Args: None
Action: Turn the robot ninty degrees to the right
Response: ack once the movement completes

`turnLeft`

Args: None
Action: Turn the robot ninty degrees to the left
Response: ack once the movement completes

`setWall X Y D`

Args:
- X - The X coordinate of the cell
- Y - The Y coordinate of the cell
- D - The direction of the wall: n, e, s, or w
Action: Display a wall at the given position
Response: None

`clearWall X Y D`

Args:
- X - The X coordinate of the cell
- Y - The Y coordinate of the cell
- D - The direction of the wall: n, e, s, or w
Action: Clear the wall at the given position
Response: None

`setColor X Y C`

Args:
- X - The X coordinate of the cell
- Y - The Y coordinate of the cell
- C - The character of the desired color
Action: Set the color of the cell at the given position
Response: None

`clearColor X Y`

Args:
- X - The X coordinate of the cell
- Y - The Y coordinate of the cell
Action: Clear the color of the cell at the given position
Response: None

`clearAllColor`

Args: None
Action: Clear the color of all cells
Response: None

`setText X Y TEXT`

Args:
- X - The X coordinate of the cell
- Y - The Y coordinate of the cell
- TEXT - The desired text, max length 10
Action: Set the text of the cell at the given position
Response: None

`clearText X Y`

Args:
- X - The X coordinate of the cell
- Y - The Y coordinate of the cell
Action: Clear the text of the cell at the given position
Response: None

`clearAllText`

Args: None
Action: Clear the text of all cells
Response: None

`wasReset`

Args: None
Action: None
Response: true if the reset button was pressed, else false

`ackReset`

Args: None
Action: Allow the mouse to be moved back to the start of the maze
Response: ack once the movement completes

Example

Algorithm Request (stdout)  Simulator Response (stdin)   
--------------------------  --------------------------
mazeWidth                   16
mazeWidth                   16
wallLeft                    true
setWall 0 0 W               <NO RESPONSE>
wallFront                   false
moveForward                 ack
turnLeft                    ack
wallFront                   true
moveForward                 crash
setColor 0 1 r              <NO RESPONSE>
setText 0 1 whoops          <NO RESPONSE>
wasReset                    false
...                       
wasReset                    true
clearAllColor               <NO RESPONSE>
clearAllText                <NO RESPONSE>
ackReset                    ack

Cell Walls

Cell walls allow the robot to diplay where it thinks walls exist, and where it thinks they don't. At the beginning of each run, all walls are assumed non-existent. By default, the simulator will display walls that haven't been discovered as dark red. As the robot explores the maze, it should set walls as it discovers them.

Cell Color

The available colors are as follows:

Char	Color
k	Black
b	Blue
a	Gray
c	Cyan
g	Green
o	Orange
r	Red
w	White
y	Yellow
B	Dark Blue
C	Dark Cyan
A	Dark Gray
G	Dark Green
R	Dark Red
Y	Dark Yellow

Cell Text

All printable ASCII characters, except for <DEL>, can be used as cell text. Any invalid characters, such as a newline or tab, will be replaced with ?.

When no algorithm is running, the simulator displays the distance of each cell from the center of the maze.

Reset Button

The reset button makes it possible to test crash handling code. Press the button to simulate a crash. Your algorithm should periodically check if the button was pressed via wasReset. If so, your algorithm should reset any internal state and then call ackReset to send the robot back to the beginning of the maze.

Maze Files

The simulator supports a few different maze file formats, as specified below. If your format isn't supported, feel free to put up a pull request.

Note that, in order to use a maze in the simulator, it must be:

Nonempty
Rectangular
Fully enclosed

Also note that official Micromouse mazes have additional requirements:

No inaccessible locations
Exactly three starting walls
Only one entrance to the center
Has a hollow center, i.e., the center peg has no walls attached to it
Has walls attached to every peg except the center peg
Is unsolvable by a wall-following robot

Here are some links to collections of maze files:

Map format

Example:

+---+---+---+
|       |   |
+   +   +   +
|   |       |
+---+---+---+

Each cell is 5 spaces wide and 3 spaces tall
All characters besides spaces count as walls
Walls are determined by checking the locations marked with an "x":

+ x +
x   x
+ x +

Num format

Format:

X Y N E S W

X: The X coordinate of the cell
Y: The Y coordinate of the cell
N: 1 if there is a wall on the north side, else 0
S: 1 if there is a wall on the east side, else 0
E: 1 if there is a wall on the south side, else 0
W: 1 if there is a wall on the west side, else 0