ECS189L Programming Exercise 4: The Factory Pattern

   Description of Provided Unity Project 

    Scene and GameObjects in the Hierarcy

* **Main Camera** is the main viewport into the lab.
* **Laboratory** is the parent for the `GameObject`s that compose the testing facility's laboratory. Inside there are the sides of the room, test pedastals, a weapon on the right (camera-relative), and a shield on the left. 
  * **ShieldPedestal** contains a `ShieldPoint` where the shields (i.e. the test subjects) spawn and an instance of the `HealthBar` prefab.
  * **WeaponPedestal** holds the test weapon located at `WeaponPoint` which contains the `ProjectileSpawn` location for new `Projectile`s to spawn at.

    Assets and Scripts

Prefabs of note:  
* **HealthBar** is a prefab that implements the dynamic health bar shown above the shield.
* **Projectile** is a prefab for the projectiles shot by the test weapon.

Scripts: 
* **ShieldController.cs** contains the game logic for test shields. It is where the refreshing capabilities of the shield should be implemented. It contains references to the `ScrollingText` and `HeathBar` instances.
* **EffectType.cs** holds the `enum` for the weapon projectile damage types.
* **ManualFire.cs** implements firing a `Projectile` instance that moves from the `ProjectileSpawn` toward the `ShieldPoint` on `jump` input.
* **ProjectileController.cs** is a component of the `Projectile` prefab that holds the physical parameters of the projectile and has information on the damage the projectile should do to a sheild.
* **ProjectileMotion.cs** is a component of the `Projectile` prefab that controls its motion.
* **HealthBarController.cs** controls the animation and behaviors of the `HealthBar`.
* **ScrollingText.cs** partially controls the upward-scrolling damage values that appear when a `Projectile` collides with a shield.

Assets used by the project that you need not manipulate but are otherwise interesting:
* **ScrollingText** prefab and animation controller.
* **TextScrollUp** animation.
* **Consequences** is the font used for the damage display text.

   Stage 1: Shields Online

The Aegis prototype shield mechanism is nearly complete. Your task is to complete the shield's functionality by adding a recharging mechanism which consists of the following:
* Use the `RechargeRate` and `RechargeDelay` properties of the `ShieldController` class to enable:
  * After the shield has taken damage or is not at maximum capacity, it enters a recharge delay period lasting `RechargeDelay` seconds.
  * After the recharge delay period, the shield begins to recharge at `RechargeRate` capacity points per second.
  * If the shield is damaged before it is fully recharged, the shield stops recharging and enters another recharge delay period.
  * Shields cannot recharge greater than their `Capacity` value.
  * Shield `Capacity` can never be negative.

   Stage 2: Damage Engine

Create a `DamageEngine` class that implements the following combat algorith:

`damage = ProjectileDamage * (TypeFactor)`

| Damage Type Factors |         | Shield Type |        |        |
|:-------------------:|:-------:|:-----------:|:------:|--------|
|                     |         |   Kenetic   | Energy | Arcane |
|  **ProjectileType** | Kenetic |      1      |   0.5  |    2   |
|                     |  Energy |      2      |    1   |   0.5  |
|                     |  Arcane |     0.5     |    2   |    1   |

This class does not need to be a `MonoBehavior` or `ScriptableObject`. It doesn't necessarily have to be a class. It does need to provide a static function that takes the parameters of a shield and the parameters of a projectile and returns a damage value as denoted by the combat algorithm.

   Stage 3: Factories and Specifications

Your task is to create factories that generate shields and projectiles via specification classes. These generated items should be instantiated as `GameObjects`. Use shield and projectile placeholders in the Unity project as a guide for how they should interact with the scene. 

    Stage 3.1: Specific Construction

This task has the following objectives:
1. Create a `ShieldFactory` and a `ProjectileFactory` using the factory design pattern.
2. You need to create `ShieldSpec` and `ProjectileSpec` classes whose only role is to hold a specification to be used by your factory. These types of data classes typically only have properties and no methods.
3. Your factories `Build` function should take a specification class as a parameter and should `Instantiate` a new `GameObject` based on the specification.
4. Your factories should be able `GenerateRandomShield`s and `GenerateRandomProjectile`s with properties within the stated specification ranges.

The automated factories in Aegis primarily build to external specifications. Specifications consist of the following values and ranges:

Shield Specifications:
* Capacity: 50 to 250
* Recharge Delay: 0.5 to 5 seconds
* Recharge Rate: 1 to 25 capacity per second.
* Type: Kinetic, Energy, or Arcane.

Projectile Specifications:
* Damage: 1 to 50
* Charge Time: 0.5 to 3 seconds.
* Type: Kinetic, Energy, or Arcane.

    Stage 3.2: Power Underwhelming

Unfortunately, your factories are also limited in the quality of shields and projectiles they can produce. Shields are limited to a power rating of 300, while projectiles are limited to a rating of 100. The following functions can determine ratings:

`ShieldRating = Capacity + (5 - RechargeDelay) * 5 + RechargeRate * (RechargeRate / 2)`

`ProjectileRating = Damage * 2 + (3 - ChargeTime)^4`

Your factories should not produce shields or projectiles with power ratings higher than the stated limits. If your factory receives a specification with a power rating over the stated limits, your factory should scale down the specification to be within the rating limit. How your factory scales down the specifications is your design choice; you could increase delay or change times, lower all properties by a percentage, or even randomly generate an entirely new shield.

   Stage 4: Still Alive

>This was a triumph!  
>I'm making a note here:  
>Huge success!  
>  
>It's hard to overstate  
>my satisfaction.  
>  
>Aperture Science:  
>We do what we must  
>because we can  
>For the good of all of us.  
>Except the ones who are dead.  

*[Still Alive](https://www.youtube.com/watch?v=VuLktUzq23c), Portal, 2007, Jonathan Coulton*  

In the grand traditions of automation and ever-increasing abstraction, this stage tasks you with creating a `TestFactory` that tests the output of factories.

Your `TestFactory`'s build method should create the following:
* A `ShieldSpec`.
  * A shield based on the generated specification.
* 5 to 10 `ProjectileSpecs`.
  * Projectile instantiations of those 5 to 10 `ProjectileSpec`s
* A `TestSchedule` that is capable of firing the projectiles in a sequential order while respecting their `ChargeTime`s.
* Setting up the generated shield GameObject and the `TestSchedule` in the scene.
* Running the test by shooting the projectiles at the shield via the `TestSchedule`.

You should report failure and huge success with the appropriate fanfare.