|SOURCE|
[Common::InputBinder]
* InputBinder aliases input types to sematic values, such as the 'w' key on the
  keyboard to some kind of move forward value
|SOURCE|
[Common::Events]
* Added SemanticInputEvent class which will be used for state-specific input
  event semantics
* SemanticInputEventData::Semantic manipulator verifies the input value is in
  the range [0.0f - 1.0f]
* KeyboardInputEventData no longer accepts a ZED_KEYBOARDSTATE, instead each
  key and its state is sent as an event
[Common::GameStateEvents]
* GameStateInputListener translates input from a mouse, keyboard, or gamepad
  and translates it into an input semantic which different game states will use
[Common::GameplayEvents]
* Gameplay input semantics are defined here
* GameplayInputListener listens for semantic input events and translates them
  into controls for the game
[Common::Game]
* Keyboard input is sent as a KeyboardInputEvent by comparing the keys on an
  individual basis from a new state and a previous state from a prior update
|SOURCE|
[Common::Events]
* KeybaordInputEventData
  * State accessor and modifier re-named to GetState and
    SetState, respectively
[Common::GameStateEvents]
* GameStateInputListener
  * Added a modifier method for setting the InputBinder, Binder
  * HandleEvent converts keyboard input events to semantic input events and
    sends them to the global event handler
[Common::GameStateManager]
* BindInput updates the InputBinder member variable pointer
* Added an InputListener which will always be used for every game state
* Pop sets the InputBinder instance to null, so that it does not get used in
  the next state on the stack
* Push adds the InputBinder instance if it has been set by the game state on
  the top of the stack
[Common::GameplayEvents]
* MOVE_FORWARD and MOVE_BACKWARD semantics changed to MOVE_UP and MOVE_DOWN,
  respectively
[Common::GameplayState]
* Added an InputBinder member for gameplay-specific input events to listen for
|SOURCE|
[Common::Actor]
* Added maximum velcity for the actor (which will be actor-specific rather than
  global)
* Move direction enum added for the actor to move along
[Common::GameplayEvents]
* MoveEventData
  * Contains the actor, direction, and velocity for a move event
* MoveEvent
  * Agent movement is sent via this event
* GameplayInputListener
  * HandleEvent translates an input semantic for movement into a move event
[Common::GameplayState]
* Added an instance of the GameplayInputListener
* MoveEventType and SemanticInputEventType added to the list of event types the
  GameplayInputListener will listen for
|SOURCE|
[Common::Events]
* SemanticInputEventData
  * The accessor and manipulator member functions are now explicitly defined as
    GetSemantic and SetSemantic
  * GetSemantic accepts a reference for each parameter, which was missing from
    the previous iteration which would allow for the value to be modified in
	the variable passed in
[Common::GameplayEvents]
* All non-core semantics are assigned values above 8096
[Common::MainMenuEvents]
* InputListener class changed to MainMenuInputListener, to avoid any possible
  conflicts
* MainMenuInputListener
  * Added SetMainMenuState which will assign the member variable pointer for a
    MainMenuState to use the correct MainMenuState
  * HandleInput only cares about one input semantic, which is the STATE_EXIT
    semantic, when this is encountered, the MainMenuState's Exit member
	function is called, immediately exiting the game (there should be some kind
	of confirm method after that to ensure the player meant to exit the game)
[Common::MainMenuState]
* Exit member function will set the flag for exiting the state which is checked
  on the next iteration of the update
* Added an InputBinder member variable to allow for binding input devices to
  input semantics
[Common::Semantics]
* Added common semantic values which will be shared across states
|SOURCE|
[Common::GameAttributes]
* Removed the Keyboard and Mouse attributes from GameAttributes, as the
  InputBinder handles all input going into the game states
[Common::GameplayEvents]
* All gameplay-specific semantics are now above 8096 and are all unique
* GameplayInputListener
  * Added a pointer to a GameplayState to GameplayInputListener as well as a
    manipulator member function (SetGameplayState) to update the member variable
    pointer to the GameplayState
  * HandleEvent checks for the STATE_EXIT semantic and will call the
    GameplayState member variable pointer's Exit function
[Common::GameplayState]
* Added an Exit member function which sets a flag to indicate that the game
  state should exit
* Update checks if the m_ExitState boolean value has been set, if so then the
  Exit member funciton taking a GameStateManager pointer is called to pop this
  state from the stack
[Common::IntroductionGameState]
* Member variable added to indicate that the introduction should be skipped
* Update checks if the m_SkipIntroduction member variable is set, if it is then
  the Exit member function taking a GameStateManager pointer is called to pop
  this state from the stack
[Common::MainMenuEvents]
* Added a semantic to deal with starting a game instance (this should be
  replaced by functionality to instead move up and down a list of menu entries
  which can be selected)
* MainMenuInputListener
  * HandleEvent uses the EXIT_STATE semantic to determine if the state should
    be exited, which further uses the semantic value to ensure that just
	receiving the event doesn't cause the state to be popped from the stack
  * HandleEvent uses the MAIN_MENU_START_GAME semantic to determine if the
    gameplay state should be pushed onto the stack, using the semantic value to
	ensure that the event is from a confirmation of an input press rather than
	just having received the input semantic ID
[Common::MainMenuState]
* Added StartGame member function which will set a flag to start the game
* Added a boolean member variable to indicate that the game should be started
* Update checks for the m_StartGame member variable, if it's set then a
  GameplayState instance is invoked
|SOURCE|
[common::IntroductionGameState]
* Added a member funciton which will set a flag to skip the introduction
  [SkipIntroduction]
* Added an InputBinder which just binds the escape key to the semantic to allow
  for skipping the introduction
* Added an IntroductionInputListener instance to handle the input semantic for
  skipping the introduction
[Common::IntroductionGameStateEvents.hpp]
* IntroductionInputListener [new class]
  * The constructor takes in a pointer to an instance of an
    IntroductionGameState
  * HandleEvent just listens for the input semantic to skip the introduction,
    which will call IntroductionGameState's SkipIntroduction member function