getting several runtime errors when i try to run the game...

namespace TreehouseDefense
{
  class Invader
  {
    private readonly Path _path;
    private int _pathStep = 0;

    public MapLocation Location => _path.GetLocationAt(_pathStep);

    public int Health { get; private set; } = 2;

    //returns true if the invader has reached the end of the path
    public bool HasScored { get { return _pathStep >= _path.Length; } }

    //returns true if the invader's health is 0 or less
    public bool IsNeutralized => Health <= 0;

    public bool IsActive => !(IsNeutralized || HasScored);

    public Invader(Path path)
    {
      path = _path;
    }

    public void Move() => _pathStep += 1;
    public void DecreaseHealth(int factor)
    {
      Health -= factor;
    }
  }
}

namespace TreehouseDefense
{
  class Tower
  {    
    private const int _range = 1;
    private const int _power = 1;

    private readonly MapLocation _location;

    public Tower(MapLocation location)
    {
      _location = location;
    }

    public void FireOnInvaders(Invader[] invaders)
    {      
      foreach(Invader invader in invaders)
      {
        if(invader.IsActive && _location.InRangeOf(invader.Location, _range))
        {
          invader.DecreaseHealth(_power);
          break;
        }
      }
    }
  }
}

namespace TreehouseDefense
{
  class Level
  {
    private readonly Invader[] _invaders;

    public Tower[] Towers { get; set; }

    public Level(Invader[] invaders)
    {
      _invaders = invaders;
    }

    // returns: true if the player wins, false otherwise.
    public bool Play()
    {
      // run until all invaders are neutralized, or an invader reaches the end of the path.
      int remainingInvaders = _invaders.Length;

      while(remainingInvaders > 0)
      {
        // each tower has an opportunity to fire on invaders.
        foreach(Tower tower in Towers)
        {
          tower.FireOnInvaders(_invaders);
        }

        // count and move the invaders that are still active.
        remainingInvaders = 0;
        foreach(Invader invader in _invaders)
        {
          if(invader.IsActive)
          {
            invader.Move();

            if(invader.HasScored)
            {
              return false;
            }
            remainingInvaders++;
          }
        }
      }  
      return true;
    }
  }
}

using System;

namespace TreehouseDefense
{
  class Game
  {
    public static void Main()
    {
      Map map = new Map(8, 5);

      try
      {
        Path path = new Path(
          new [] {
            new MapLocation(0,2,map),
            new MapLocation(1,2,map),
            new MapLocation(2,2,map),
            new MapLocation(3,2,map),
            new MapLocation(4,2,map),
            new MapLocation(5,2,map),
            new MapLocation(6,2,map),
            new MapLocation(7,2,map)
          }
        );

        Invader[] invaders =
        {
          new Invader(path),
          new Invader(path),
          new Invader(path),
          new Invader(path)
        };

        Tower[] towers = {
          new Tower(new MapLocation(1,3,map)),
          new Tower(new MapLocation(3,3,map)),
          new Tower(new MapLocation(5,3,map))
        };

        Level level = new Level(invaders)
        {
          Towers = towers
        };  

        bool playerWon = level.Play();

        Console.WriteLine("Player " + (playerWon? "won" : "lost"));
      }
      catch (OutOfBoundsException ex)
      {
        Console.WriteLine(ex.Message);
      }
      catch (TreehouseDefenseException)
      {
        Console.WriteLine("Unhandled TreehouseDefenseException.");
      }
      catch (Exception ex)
      {
        Console.WriteLine("Unhandled Exception: " + ex);
      }      
    }
  }
}