Assignment 3 Solution

In this assignment you will be writing the game that was presented in class.
This game must have the following features:

Assets:
- Entities in the game will be rendered using various Textures and Animations
  which we will be calling Assets (along with Fonts)
- Assets are loaded once at the beginning of the program and stored in the
  Assets class, which is stored by the GameEngine class
- All Assets are defined in assets.txt, with the syntax defined below

Note:
- All entity positions denote the center of their rectangular sprite
  It also denotes the center of the bounding box, if it has one
  This is set via sprite.setOrigin() in the Animation class constructor
- For this assignment only, entities are drawn as if pixel (0,0) was
  in the bottom-left hand corner of the screen. This is so that concepts
  like hitting a block from above / below are a little more mathematically
  intuitive. This is accomplished simply by setting the sprite's y-coordinate
  as the window's y size minus the transform y coordinate.

Player:
- The player Entity in the game is represented by Megaman, which has several
  different Animations: Stand, Run, and Air. You must determine which state
  the player is currently in and assign the correct Animation.
- The player moves with the following controls:
  Left: A key, Right: D key, Jump: W Key, Shoot: Space Key
- The player can move left, move right, or shoot at any time during the game
  This means the player can move left/right while in the air
- The player can only jump if it is currently standing on a tile
- If the player moves left/right, the player's sprite will face in that
  direction until the other direction has been pressed
- Bullets shot by the player travel in the direction the player is facing
- The player collides with 'Tile' entities in the level (see level syntax) and
  cannot move through them. The player land on a Tile entity and stand in place
  if it falls on it from above.
- The player does not collide with 'Dec' (decoration) entities in the level
- If the player falls below a y position of 0, they respawn at the start
- If the player touches the pole, it respawns at the start
- The player should have a Gravity component which constantly accelerates it
  downward on the screen until it collides with a tile
- The player has a maximum speed specified in the Level file (see below) which
  it should not exceed in either x or y direction. This mainly comes into play
  when it is being accelerated downward by gravity.
- The player will be given a CBoundingBox of a size specified in the level file
- The player's sprite and bounding box are centered on the player's position

Animations:
- See below for Animation asset specification
- Animations are implemented by storing multiple frames inside a texture
- The Animation class handles frame advancement based on animation speed
- You need to implement Animation::update() to properly progress animations
- You need to implement Animation::hasEnded() which returns true if an
  animation has finished its last frame, false otherwise
- Animations can be repeating (loop forever) or non-repeating (play once)
- Any entity with a non-repeating animation should be destroyed once its
  Animation's hasEnded() returns true (has finished one cycle)

Decoration Entities:
- Decoration entities ('Dec' in a level file) are simply drawn to the screen,
  and do not interact with any other entities in the game in any way
- Decorations can be given any Animation in the game, but intuitively they
  should be reserved for things like clouds, bushes, etc

Tiles:
- Tiles are Entities that define the level geometry and interact with players
- Tiles can be given any Animation that is defined in the Assets file
- Tiles will be given a CBoundingBox equal to the size of the animation
  tile->getComponent<CAnimation>().animation.getSize()
- The current animation displayed for a tile can be retreieved with:
  tile->getComponent<CAnimation>().animation.getName()
- Tiles have different behavior depending on which Animation they are given

  Brick Tiles:
  - Brick tiles are given the 'Brick' Animation
  - When a brick tile collides with a bullet, or is hit by a player from below:
    - Its animation should change to 'Explosion' (non-repeat)
    - Non-repeating animation entities are destroyed when hasEnded() is true
    - Its CBoundingBox component should be removed

  Question Tiles:
  - Question tiles are given the 'Question' Animation when created
  - When a Question tile is hit by a player from below, 2 things happen:
    - Its Animation changes to the darker 'Question2' animation
    - A temporary lifespan entity with the 'Coin' animation should appear
      for 500ms 64 pixels above the location of the Question entity

Drawing:
- Entity rendering has been implemented for you, no need to change that system

Bonus:
- Any special effects which do not alter game play can be added for up to
  10% bonus marks on the assignment. Note that assignments cannot go above
  100% total marks, but the 5% bonus can overwrite any marks lost in other
  areas of the assignment.
- You may develop a 'special weapon' that has special effects which can
  also contribute to the 5% bonus marks available on the assignment.
- I will show off some of the more impressive bonus submissions in class
  
Misc:
- The 'P' key should pause the game
- Pressing the 'R' key toggles drawing textures
- Pressing the 'F' key toggles drawing bounding boxes of entities
  This should be very helpful for debugging
- The 'ESC' key should go 'back' to the Main Menu, or quit if on the Main Menu

-------------------------------------------------------------------------------
Level Creation
-------------------------------------------------------------------------------

For this assignment you are also required to create your own level. This level
should include some interesting gameplay, but does not have to be as complex
as the included Level 1, as building a large level is quite tedious. Include
this level in the zip file as level.txt, and I will show off some of the more
interesting levels in class after the assignment is due. 10% marks will be
taken off if a level is not submitted.

-------------------------------------------------------------------------------
Config Files
-------------------------------------------------------------------------------

There will be two configuration files in this assignment. The Assets config
file, and the Level configuration file.

-------------------------------------------------------------------------------
Assets File Specification
-------------------------------------------------------------------------------

There will be three different line types in the Assets file, each of which
correspond to a different type of Asset. They are as follows:

Texture Asset Specification:
Texture N P
  Texture Name     N        std::string (it will have no spaces)
  Texture FilePath P        std::string (it will have no spaces)

Animation Asset Specification:
Animation N T F S
  Animation Name   N        std::string (it will have no spaces)
  Texture Name     T        std::string (refers to an existing texture)
  Frame Count      F        int (number of frames in the Animation)
  Anim Speed       S        int (number of game frames between anim frames)
  
Font Asset Specification:
Font N P
  Font Name        N        std::string (it will have no spaces)
  Font File Path   P        std::string (it will have no spaces)
  
-------------------------------------------------------------------------------
Level Specification File
-------------------------------------------------------------------------------
  
Game levels will be specified by a Level file, which will contain a list of
entity specifications, one per line. It will also contain a single line which
specifies properties of the player in that level. In this way, you can define
an entire level in the data file, rather than in programming code. The syntax
of the lines of the Level file are as follows:
  
Tile Entity Specification:
Tile N X Y
  Animation Name   N        std::string (Animation asset name for this tile)
  X Position       X        float
  Y Position       Y        float
  
Decoration Entity Specification:
Dec N X Y
  Animation Name   N        std::string (Animation asset name for this tile)
  X Position       X        float
  Y Position       Y        float
  
Player Specification
Player X Y CW CH SX SY SM GY B
  X, Y Position    X, Y     float, float
  BoundingBox W/H  CW, CH   float, float
  Left/Right Speed SX       float
  Jump Speed       SY       float
  Max Speed        SM       float
  Gravity          GY       float
  Bullet Animation B        std::string (Animation asset to use for bullets)
  
-------------------------------------------------------------------------------
Assignment Hints
-------------------------------------------------------------------------------

I recommend approaching this assignment in the following order, which will
help you debug your program along the way with minimal errors. Remember to
do one step at a time and test whether what you have just implemented is
working properly before moving on to any additional steps.

-  Rendering system has already been set up for you, to help you debug:
   You can press the R key to toggle drawing textures
   You can press the F key to toggle drawing bounding boxes

-  You can implement Animation::update() and Animation::hasEnded() at any
   time, it will not affect the gameplay mechanics whatsoever, just animation
   
-  Implement GameState_Play::loadLevel()
   Since rendering is already completed, once you correctly read in the
   different types of entities, add them to the EntityManager and they should
   automatically be drawn to the screen. Add the correct bounding boxes
   to Tile entities, and no bounding boxes to the Dec entities. Remember
   you can toggle debug viewing of bounding boxes with the R and F keys

-  Implement GameState_Play::spawnPlayer() 
   Read the player configuration from the level file and spawn the player
   This is where the player should restart when they die

-  Implement some basic WASD u/l/d/r movement for the player entity so that
   you can use this to help test collisions in the future

-  Implement GameState_Play::spawnBullet() 
   Bullet should shoot when Space is pressed in same direction player facing
   Holding down the space button should not continuously fire bullets. A
   new bullet can only be fired after the space key has been released. Use
   the entity's CInput.canShoot variable to implement this

-  Implement Physics::GetOverlap()
   This function should return the overlap dimensions between the bounding
   boxes of two entities. This is the same as the purple rectangle in notes.
   GetPreviousOverlap should be a copy/paste of this solution except using
   the previous positions instead of the current positions of the entity.

-  Implement collision checking with bullets / brick tiles such that the brick
   is destroyed when a bullet collides with it. Remember, a collision occurs
   when the overlap is non-zero in both the X and Y component. Bullets should
   always be destroyed when they collide with any non-decorative tile

-  Implement collision resolution such that when the player collides with a
   non-decorative tile, the player cannot enter it over overlap it. When the
   player collides with a tile from below, its y-velocity should be set to
   zero so that it falls back downward and doesn't 'hover' below the tile

-  Implement a way of detecting which side the player collided with the tile

-  Change the controls such that they are the proper left/right/jump style
   Note: All movement logic should be in the movement system. The sUserInput
   sysytem is ONLY used to set the proper CInput variables. If you modify the
   player's speed or position anywhere inside the userInput system, you will
   lose marks as this potentially unsafe / produces unwanted effects

-  Implement gravity such that the player falls toward the bottom of the screen
   and lands on tiles when it collides with a tile from above. Note that when
   the player lands on a tile from above, you should set its vertical speed to
   zero so that gravity does not continue to accelerate the player downward