The default experience manager is written in Java, so make sure you have Java installed and on your path. Camelot does not require Java to run, but the default experience manager does. If you don't have or don't want Java, skip ahead to the next section about using other experience managers.
Download Camelot for your platform (Windows or Mac).
Unzip the file you downloaded and start Camelot.
- For Windows, double click on Camelot.exe.
- For Mac, double click Camelot.app. If double-clicking the app shows an error that you cannot open it, you need to take additional steps to run an app from "an unkown developer".
  - Do not use Launchpad to do this. Launchpad doesn’t allow you to access the shortcut menu. Control-click Camelot.app, hover over the open option to expand it, and select open. You can now double-click Camelot.app to run it.
  - If you still get an error, type the following in the terminal application: chmod -R +x Camelot.app/Contents/MacOS
The default experience manager allows you to type Camelot commands by hand and see their effect. Type these commands one at a time, pressing the ENTER key after each one:
```
CreatePlace(BobsHouse, Cottage)
CreateCharacter(Bob, B)
SetClothing(Bob, Peasant)
SetPosition(Bob, BobsHouse.Door)
ShowMenu()
```
You transition from the loading screen to the main menu after typing in ShowMenu().
When you click on the Start button, you see this message in the experience manager:
```
RECEIVED: input Selected Start
```
Then type these commands into the experience manager:
```
SetCameraFocus(Bob)
HideMenu()
EnableInput()
```
Now you should be in control of Bob and able to walk around his house using the W, A, S, and D keys.
The default experience manager is a very simple program. All it does it prepend the string "start " to whatever you type and send the string to Camelot via standard output. It also shows you Camelot's responses. This experience manager can be helpful when debugging.

An experience manager controls what happens in Camelot. It sends messages to Camelot via standard output (e.g. System.out.println(String) in Java or print(string) in Python) and receives messages from Camelot via standard input.
By default, Camelot will use StartExperienceManager.bat (or StartExperienceManager.sh in Mac).
To run Camelot with a different experience manager, you can modify the default shell script files or open a console window and run Camelot.exe (or Camelot.app) with the command line argument "-em_path". For example:
```
Camelot.exe -em_path "C:\XP\run.bat"
```
To start an action, send a message in this format over standard output:
```
start [ActionName]([Action Arguments])
```
After the action starts, Camelot responds with a message in this format:
```
started [ActionName]([Action Arguments])
```
Remember to only use double quotations in your strings.
Camelot leaves the loading screen and shows the Start button after it receives this command:
```
start ShowMenu()
```
After the player presses the start button, Camelot responds with:
```
input Selected Start
```
You can use this command to reset Camelot without restarting the experience manager:
```
start Reset()
```
When an action succeeds, Camelot sends a message in format:
```
succeeded [ActionName]([Action Arguments])
```
When an action fails, Camelot sends a message in format:
```
failed [ActionName]([Action Arguments])
```
An action that has not succeeded or failed yet can be stopped using:
```
stop [ActionName]([Action Arguments])
```
Everything currently executed by that action is reversed.

First, make sure Python is installed. This example will use Python 3.

Create a new text file named em.py and copy and paste this code into it:

# Send a command to Camelot.
def action(command):
	print('start ' + command)
	while(True):
		i = input()
		if(i == 'succeeded ' + command):
			return True
		elif(i == 'failed ' + command):
			return False
		elif(i.startswith('error')):
			return False

# Set up a small house with a door.
action('CreatePlace(BobsHouse, Cottage)')
action('CreateCharacter(Bob, B)')
action('SetClothing(Bob, Peasant)')
action('SetPosition(Bob, BobsHouse.Door)')
action('EnableIcon("Open_Door", Open, BobsHouse.Door, "Leave the house", true)')
action('ShowMenu()')

# Respond to input.
while(True):
	i = input()
	if(i == 'input Selected Start'):
		action('SetCameraFocus(Bob)')
		action('HideMenu()')
		action('EnableInput()')
	elif(i == 'input Open_Door BobsHouse.Door'):
		action('SetNarration("The door is locked!")')
		action('ShowNarration()')
	elif(i == 'input Close Narration'):
		action('HideNarration()')

Now open the file named StartExperienceManager.bat (or StartExperienceManager.sh on Mac) in a text editor and replace its contents with this:
```
python em.py
```
Now simply double click on Camelot.exe (or Camelot.app), and you should now have a working Python experience manager!

Camelot entity types include characters, items, and furniture.

Character and Player Commands

Characters have customizable body types, eye colors, skin colors, hair styles, hair colors, and clothes.
In order to set a character as the player, refer to SetCameraFocus.

Interacting with Entities

Items are small, portable things that can be held in a character's hand.
Furniture are large, immovable things that are part of places.
You can enable icons on entities such as characters, items, and furniture.
When something has at least one icon enabled, the player can left click on it to perform a default action (that you specify) or right click to see a radial menu of possible actions based on which icons you have enabled.

Player Input

After the player interacts with an entity, Camelot sends a message in this format:
```
input [Action name] [Entity name]
```
When the player gets close to an entity, Camelot sends a message in this format:
```
input arrived [Character name] position [Entity name]
```
This is important for place exits that do not include a door and only send an arrived message.
When the player leaves a position, Camelot sends a message in this format:
```
input exited [Character name] position [Entity name]
```
Camelot captures keyboard key presses for the "Escape", "I", and "E" keys. When these happen, Camelot sends a message in this format:
```
input Key Pause
```
```
input Key Inventory
```
```
input Key Interact
```
It is very important to note that pressing the Escape key also disables the input.

Other Commands

Check out the complete list of all available commands.

Every time you run Camelot with an experience manager, a log file is automatically generated. The log files are generated in the GameplayLogs folder in the same directory as the Camelot executable.
Each line of the log file includes a timestamp and a message. A message represents the standard output text that is generated by Camelot and sent to the experience manager. The first and last message of each log file are respectively START GAME and END GAME.
You can use log files to recreate a playthrough. To do so, you can use CamelotReplay as an experience manager and specify the log file you want to recreate as its argument. For instance, the StartExperienceManager.bat should contain CamelotReplay.exe 'Path_to_log_file/log_file_to_recreate.log'
CamelotReplay requires Java to run.

Download CamelotReplay for Windows Download CamelotReplay for Mac Source code on Github

Camelot: Narrative SandBox Environment

Getting Started

How Experience Managers Work

Creating a Custom Experience Manager in Python

Important Commands

Character and Player Commands

Interacting with Entities

Player Input

Other Commands

Gameplay Logs