Add all scripts

Author: adamgraham

Assets/Scripts.meta

@@ -0,0 +1,133 @@
+using UnityEngine;
+
+/// <summary>
+/// Handle bunker destruction simulations.
+/// </summary>
+[RequireComponent(typeof(SpriteRenderer))]
+[RequireComponent(typeof(BoxCollider2D))]
+public class Bunker : MonoBehaviour
+{
+    /// <summary>
+    /// The texture that will be used as an alpha mask when a projectile splats
+    /// on the bunker.
+    /// </summary>
+    [Tooltip("The texture that will be used as an alpha mask when a projectile splats on the bunker.")]
+    public Texture2D splat;
+
+    /// <summary>
+    /// The sprite renderer component of the bunker.
+    /// </summary>
+    private SpriteRenderer _spriteRenderer;
+
+    /// <summary>
+    /// The box collider component of the bunker.
+    /// </summary>
+    private BoxCollider2D _collider;
+
+    private void Awake()
+    {
+        _spriteRenderer = GetComponent<SpriteRenderer>();
+        _collider = GetComponent<BoxCollider2D>();
+
+        // Each bunker needs a unique instance of the sprite since we will be
+        // changing the source texture
+        CreateSpriteInstance();
+    }
+
+    private void CreateSpriteInstance()
+    {
+        Sprite sprite = _spriteRenderer.sprite;
+
+        // Create a copy of the source texture with the same properties
+        Texture2D texture = new Texture2D(sprite.texture.width, sprite.texture.height, sprite.texture.format, false);
+        texture.filterMode = sprite.texture.filterMode;
+        texture.alphaIsTransparency = sprite.texture.alphaIsTransparency;
+        texture.anisoLevel = sprite.texture.anisoLevel;
+        texture.wrapMode = sprite.texture.wrapMode;
+        texture.SetPixels(sprite.texture.GetPixels());
+        texture.Apply();
+
+        // Create a new sprite using the cloned texture
+        Sprite instance = Sprite.Create(texture, sprite.rect, new Vector2(0.5f, 0.5f), sprite.pixelsPerUnit);
+        _spriteRenderer.sprite = instance;
+    }
+
+    public bool CheckPoint(Vector3 hitPoint, out int px, out int py)
+    {
+        // Transform the point from world space to local space
+        Vector3 localPoint = this.transform.InverseTransformPoint(hitPoint);
+
+        // Offset the point to the corner of the object instead of the center so
+        // we can transform to uv coordinates
+        localPoint.x += _collider.size.x / 2;
+        localPoint.y += _collider.size.y / 2;
+
+        Texture2D texture = _spriteRenderer.sprite.texture;
+
+        // Transform the point from local space to uv coordinates
+        px = (int)((localPoint.x / _collider.size.x) * texture.width);
+        py = (int)((localPoint.y / _collider.size.y) * texture.height);
+
+        // Return true if the pixel is not empty (not transparent)
+        return texture.GetPixel(px, py).a != 0.0f;
+    }
+
+    public bool Splat(Vector3 hitPoint)
+    {
+        int px;
+        int py;
+
+        // Only proceed if the point maps to a non-empty pixel
+        if (!CheckPoint(hitPoint, out px, out py)) {
+            return false;
+        }
+
+        Texture2D texture = _spriteRenderer.sprite.texture;
+
+        // Offset the point by half the size of the splat texture so the splat
+        // is centered around the hit point
+        px -= this.splat.width / 2;
+        py -= this.splat.height / 2;
+
+        int startX = px;
+
+        // Loop through all of the coordinates in the splat texture so we can
+        // alpha mask the bunker texture with the splat texture
+        for (int y = 0; y < this.splat.height; y++)
+        {
+            px = startX;
+
+            for (int x = 0; x < this.splat.width; x++)
+            {
+                // Multiply the alpha of the splat pixel with the alpha of the
+                // bunker texture to make it look like parts of the bunker are
+                // being destroyed
+                Color pixel = texture.GetPixel(px, py);
+                pixel.a *= this.splat.GetPixel(x, y).a;
+                texture.SetPixel(px, py, pixel);
+                px++;
+            }
+
+            py++;
+        }
+
+        // Apply any changes made to the texture
+        texture.Apply();
+
+        return true;
+    }
+
+    public bool CheckCollision(BoxCollider2D other, Vector3 hitPoint)
+    {
+        Vector2 offset = other.size / 2;
+
+        // Check the hit point and each edge of the colliding object to see if
+        // it splats with the bunker for more accurate collision detection
+        return Splat(hitPoint) ||
+               Splat(hitPoint + (Vector3.down * offset.y)) ||
+               Splat(hitPoint + (Vector3.up * offset.y)) ||
+               Splat(hitPoint + (Vector3.left * offset.x)) ||
+               Splat(hitPoint + (Vector3.right * offset.x));
+    }
+
+}

Assets/Scripts/Bunker.cs

@@ -0,0 +1,153 @@
+using UnityEngine;
+using UnityEngine.UI;
+
+/// <summary>
+/// Manages the overall state of the game, including starting a new game and
+/// handling scoring and lives.
+/// </summary>
+public sealed class GameManager : MonoBehaviour
+{
+    /// <summary>
+    /// A reference to the player game object.
+    /// </summary>
+    [Tooltip("A reference to the player game object.")]
+    public Player player;
+
+    /// <summary>
+    /// A reference to the invaders game object.
+    /// </summary>
+    [Tooltip("A reference to the invaders game object.")]
+    public Invaders invaders;
+
+    /// <summary>
+    /// A reference to the MysteryShip game object.
+    /// </summary>
+    [Tooltip("A reference to the MysteryShip game object.")]
+    public MysteryShip mysteryShip;
+
+    /// <summary>
+    /// The UI text that displays the player's score.
+    /// </summary>
+    [Tooltip("The UI text that displays the player's score.")]
+    public Text scoreText;
+
+    /// <summary>
+    /// The UI text that displays the player's lives.
+    /// </summary>
+    [Tooltip("The UI text that displays the player's lives.")]
+    public Text livesText;
+
+    /// <summary>
+    /// The UI displayed during the game over state.
+    /// </summary>
+    [Tooltip("The UI displayed during the game over state.")]
+    public GameObject gameOverUI;
+
+    /// <summary>
+    /// The player's current score.
+    /// </summary>
+    public int score { get; private set; }
+
+    /// <summary>
+    /// The player's current lives.
+    /// </summary>
+    public int lives { get; private set; }
+
+    private void Start()
+    {
+        // Register callbacks for game state
+        this.player.killed += OnPlayerKilled;
+        this.mysteryShip.killed += OnMysteryShipKilled;
+        this.invaders.killed += OnInvaderKilled;
+
+        // Start a new game
+        NewGame();
+    }
+
+    private void Update()
+    {
+        // Start a new game once the player presses 'Return'
+        if (this.lives == 0 && Input.GetKeyDown(KeyCode.Return)) {
+            NewGame();
+        }
+    }
+
+    private void NewGame()
+    {
+        // Reset score and lives
+        SetScore(0);
+        SetLives(3);
+
+        // Reset all of the invaders
+        this.invaders.ResetInvaders();
+        this.invaders.gameObject.SetActive(true);
+
+        // Hide the game over UI
+        this.gameOverUI.SetActive(false);
+
+        // Spawn the player
+        Respawn();
+    }
+
+    private void GameOver()
+    {
+        // Show the game over UI and hide the invaders
+        this.gameOverUI.SetActive(true);
+        this.invaders.gameObject.SetActive(false);
+    }
+
+    private void Respawn()
+    {
+        // Reset the position of the player
+        Vector3 position = this.player.transform.position;
+        position.x = 0.0f;
+        this.player.transform.position = position;
+
+        // Re-enable the player game object
+        this.player.gameObject.SetActive(true);
+    }
+
+    private void SetScore(int score)
+    {
+        // Set score and update UI text
+        this.score = score;
+        this.scoreText.text = this.score.ToString().PadLeft(4, '0');
+    }
+
+    private void SetLives(int lives)
+    {
+        // Set lives and update UI text
+        this.lives = lives;
+        this.livesText.text = this.lives.ToString();
+    }
+
+    private void OnPlayerKilled()
+    {
+        // Decrement lives by 1
+        SetLives(this.lives - 1);
+
+        // Temporarily disable the player game object
+        this.player.gameObject.SetActive(false);
+
+        // Respawn the player after 1 second or trigger the game over state
+        // after running out of lives
+        if (this.lives > 0) {
+            Invoke(nameof(Respawn), 1.0f);
+        } else {
+            GameOver();
+        }
+    }
+
+    private void OnInvaderKilled(Invader invader)
+    {
+        // Increment score by how much the invader is worth
+        SetScore(this.score + invader.score);
+    }
+
+    private void OnMysteryShipKilled(MysteryShip mysteryShip)
+    {
+        // Increment score by how much the mystery ship is worth
+        SetScore(this.score + mysteryShip.score);
+    }
+
+}

Assets/Scripts/Bunker.cs.meta

@@ -0,0 +1,77 @@
+using UnityEngine;
+
+/// <summary>
+/// Handles animating the invader sprite and detecting when the invader dies.
+/// </summary>
+[RequireComponent(typeof(SpriteRenderer))]
+public class Invader : MonoBehaviour
+{
+    /// <summary>
+    /// The sprite renderer component of the invader.
+    /// </summary>
+    private SpriteRenderer _spriteRenderer;
+
+    /// <summary>
+    /// The sprites that are animated on the invader.
+    /// </summary>
+    [Tooltip("The sprites that are animated on the invader.")]
+    public Sprite[] animationSprites = new Sprite[0];
+
+    /// <summary>
+    /// The amount of seconds between switching sprites to simulate animation.
+    /// </summary>
+    [Tooltip("The amount of seconds between switching sprites to simulate animation.")]
+    public float animationTime = 1.0f;
+
+    /// <summary>
+    /// The index of the current sprite being rendered.
+    /// </summary>
+    private int _animationFrame;
+
+    /// <summary>
+    /// The amount of points the invader is worth when killed.
+    /// </summary>
+    [Tooltip("The amount of points the invader is worth when killed.")]
+    public int score = 10;
+
+    /// <summary>
+    /// The callback invoked when the invader is killed.
+    /// </summary>
+    public System.Action<Invader> killed;
+
+    private void Awake()
+    {
+        // Get a reference to the sprite renderer so we can animate the sprite
+        _spriteRenderer = GetComponent<SpriteRenderer>();
+        _spriteRenderer.sprite = this.animationSprites[0];
+    }
+
+    private void Start()
+    {
+        // Start an animation loop to cycle between sprites
+        InvokeRepeating(nameof(AnimateSprite), this.animationTime, this.animationTime);
+    }
+
+    private void AnimateSprite()
+    {
+        // Move to the next animation frame
+        _animationFrame++;
+
+        // Loop back to the start if the animation frame exceeds the length
+        if (_animationFrame >= this.animationSprites.Length) {
+            _animationFrame = 0;
+        }
+
+        // Set the sprite based on the current animation frame
+        _spriteRenderer.sprite = this.animationSprites[_animationFrame];
+    }
+
+    private void OnTriggerEnter2D(Collider2D other)
+    {
+        // The invader dies when hit by the laser
+        if (other.gameObject.layer == LayerMask.NameToLayer("Laser")) {
+            this.killed?.Invoke(this);
+        }
+    }
+
+}