Adding some changes to enable and test C++11 support
Fixing C++11 support check to handle Visual Studio
Adding build directory to .gitignore
Makefile should specify C++11 standard libraries
Fixing pointers with the magic of C++11 (part 1)

Replaced all occurrences of NULL with nullptr, except in third-party
code (LuaWrapper, JsonCpp, TinyXml).

Started conversion of naked pointers in app to std::unique_ptr where
possible, and std::shared_ptr where otherwise appropriate.
Converting Resource types, Tasks to use shared_ptr

ResourceLoader now only creates and returns shared_ptr instances.

Resource now inherits from enable_shared_from_this to allow resources
to operate on themselves (particularly Music/Sound, which are
inherently tied to global state since they rely on SDL_Mixer).

Tasks are also now created using shared_ptrs only, meaning we can
remove the self-destruct code inside the Task object.
Converting Scheduler and ScriptEngine to use smart pointers
Switching to lambdas in A* and Aspect validation algorithms
Converting DialogueController to use smart pointers
Updating GUI event handlers to use simple lambdas
MenuShell needs to be managed via shared_ptr
Converting TileEngine components to use smart pointers
Moving EdenRocketBindings definitions to CPP file
 Creating a Grid class to manage 2D arrays

Replacing several occurrences of 2D C-style arrays with a Grid class,
which manages the creation and destruction of the array (via an
std::vector). This also reduces memory fragmentation since the 2D array
is actually implemented using a single N*M entry array instead of N
M-sized arrays.

The Grid abstracts away the details of accessing the grid entries so
that clients can just use (x,y) coordinate pairs as they would with 2D
C-style arrays.
Refactoring MessagePipe, map triggers and settings

MessagePipe, triggers and settings have been updated to use C++11 smart
pointers instead of managing their own memory.
Fixing tiny UI text issue

It seems that there is a bug in libRocket currently,
where the "pt" measurement of font is extremely small.
Switching to "px" brings the UI back to reasonable sizes.
Extracting GameStateType into new header

Since there are a lot of classes referencing GameStateType, decided to
decouple it from GameState so that the entirety of GameState doesn’t
need to be included just to refer to the enum.
Changing RocketListeners to pass Events by ref

As a small addition to the change to RocketListener in 0549ff8 to use
lambdas, RocketListener now always passes events by ref instead of by
pointer. The pointer passing was a workaround to allow calls to the
handlers even with no event (by passing nullptr). Instead, now handlers
that don’t care about the event just don’t take the event parameter.
With the lambda notation, supporting parameterless handlers is cleaner.
Alloc Item/skill metadata in contiguous blocks

Instead of holding an array of pointers to Item and Skill objects, the
Metadata list now places them directly into a vector. This has two
benefits: objects allocated in this way will be automatically cleaned
up, and storing the objects in a contiguous block of memory will
improve spatial locality.

To effect this change, the constness of Metadata had to be reconsidered
somewhat. Components that invoke Item/Skill scripts can no longer have
const references to Metadata (which is fine because technically messing
with an Item pointer that Metadata owns is violating the spirit of
constness if not the letter).

Since Metadata will always receive the same ScriptEngine to invoke
Item/Skill scripts, the script engine is now passed into Metadata on
construction. This means that components like the Shortcut Bar (a view
component) no longer need to hold an extra reference to the
ScriptEngine. Components now use the Metadata object as an interface to
invoke item/skill scripts. As a result, the checks to determine if
items exist are now pushed to Metadata. Item/Skill data itself is now
read-only to components outside Metadata, meaning that only components
that invoke item/skill scripts actually need non-const references to
the Metadata object.
Allocate Schedulers as part of their GameStates

Since Schedulers are created at GameState construction time (or never),
and deleted at GameState destruction time, they should just be
allocated with their respective GameState owners instead of elsewhere
in the heap. This ties the Scheduler’s lifecycle to the lifecycle of
its owning GameState.