public Location(double latitude, double longitude, Planet p)
     : this()
 {
     this.Latitude = latitude;
     this.Longitude = longitude;
     this.CurrentPlanet = p;
 }

 public Location(double latitude, double longitude, Planet planet)
     : this()
 {
     Latitude = latitude;
     Longitude = longitude;
     Planet = planet;
 }

	public List<Structure> GetStructureList(Planet.PlanetType Type)
	{
		bool bIsAllowed;
		List<Structure> AvailableStructures = new List<Structure> ();

		for (int i = 0; i < Structures.Count; i++)
		{
			bIsAllowed = true;

			for (int j = 0; j < Structures[i].RestrictedEnvironments.Count; j++)
			{
				if (Type == Structures[i].RestrictedEnvironments[j])
				{
					bIsAllowed = false;
				}
			}

			if (bIsAllowed)
			{
				AvailableStructures.Add(new Structure(Structures[i]));
			}
		}

		return AvailableStructures;
	}

 public Location(double latitude, double longitude, Planet planetName)
     : this()
 {
     this.Latitude = latitude;
     this.Longitude = longitude;
     this.PlanetName = planetName;
 }

    public void Link(Planet planet)
    {
        this.planet = planet;

        planet.hexPlanet = GetComponent<HexPlanet>();
        planet.behavior = this;
    }

 public NewTroopMovementEvent(object sender, Planet startPlanet, Planet targetPlanet, int shipCount)
 {
     Sender = sender;
     StartPlanet = startPlanet;
     TargetPlanet = targetPlanet;
     ShipCount = shipCount;
 }

 public Location(double inputLatitude, double inputLongitude, Planet inputPlanet)
     : this()
 {
     this.Latitude = inputLatitude;
     this.Longitude = inputLongitude;
     this.Planet = inputPlanet;
 }

    // Use this for initialization
    protected virtual void Start()
    {
        if(transform.parent != null)
        {
            planet = transform.parent.GetComponent<Planet>();
            if(planet != null)
            {
                //if(!CheckRequirements(planet))
                //	Destroy(gameObject);
            }
        }

        //maintain global scale
        if(transform.parent != null)
        {
            Vector3 correctedScale = new Vector3(transform.localScale.x / transform.parent.localScale.x,
                                                 transform.localScale.y / transform.parent.localScale.y,
                                                 transform.localScale.z / transform.parent.localScale.z);
            transform.localScale = correctedScale;
        }

        //Initialize
        input = new  LocalResource[0];
        output = new LocalResource();
        output.type = LocalResourceType.Power;
        output.quantity = 5;

        outputRange = DEFAULT_OUTPUT_RANGE;
    }

 public void DeployToPlanet()
 {
     var planet = new Planet();
     planet.SetSize(100, 50);
     iRover.DeployTo(planet, 0, 0, Movement.CardinalHeading.North);
     Assert.IsNotNull(iRover.DeployedTo);
 }

 public Location(double x, double y,Planet planet):this()
 {
     this.latitude = x;
     this.longitude = y;
     this.planets = planet;
     
 }

    internal List<Planet> MuteerMijnPlaneet(Planet myPlanet, int strength)
    {
        int index = MijnPlaneten.FindIndex(c => c.PlanetId() == myPlanet.PlanetId());

        MijnPlaneten[index].Sterkte -= strength;
        return MijnPlaneten;
    }

    internal List<Planet> MuteerDoelPlaneten(Planet target)
    {
        int index = NietMijnPlaneten.FindIndex(c => c.PlanetId() == target.PlanetId());
        NietMijnPlaneten[index].Owner(1);

        return NietMijnPlaneten;
    }

 public Location(double latitude, double longitude, Planet planet)
     : this() // http://stackoverflow.com/questions/788958/why-do-i-have-to-assign-all-fields-inside-an-structs-constructor
 {
     this.Latitude = latitude;
     this.Longitude = longitude;
     this.Planet = planet;
 }

    public bool createSystem()
    {
        bool system_created = false;

        if(num_planets > 0 ){
          //create the system!
          base.sub_spheres = new SphereRenderer[num_planets];

          /*create the sun!*/
          int ptype = 101;
          float pmass = 1000000f;
          string pname = name + " - Sun";
          float pradius = 12f;
          float pdistance = 0f;
          Vector3 pposition = new Vector3(position.x, Random.Range(-400, 400), position.z);
          Debug.Log(pposition);
          Planet planet = new Planet(ptype, pmass, pname, pradius, pdistance, pposition);
          planet.createPlanet();

          factory = (SphereRendererFactory)GameObject.Find("SphereRendererFactory").GetComponent("SphereRendererFactory");
          base.sub_spheres[0] = factory.createSphereRenderer();
          base.sub_spheres[0].initialize(0, 0, planet_threshold,1 , planet);
          base.sub_spheres[0].setIsDisplayed(true);
          /* end create sun */
          pdistance += 15f;
          /*create planets*/
          for(int i = 1; i < (num_planets); i++){
        float omega = Random.Range(0, 2*Mathf.PI);
        /* sphere types
        * 0 - Dead
        * 1 - Fuel Source
        * 2 - Habitable
        * 3 - Sun
        * 4 - Planetary System
        * 5 - System Cluster
        */
        ptype = Random.Range(0, 100);
        pmass = Random.Range(1000f, 10000f);
        pname = name + " - " + i;
        pradius = Random.Range(10f, 20f);
        pdistance = Random.Range(pdistance, pdistance + 100f);
        pposition = new Vector3(position.x + pdistance*Mathf.Cos(omega) , Random.Range(-100, 100), position.z + pdistance*Mathf.Sin(omega));
        planet = new Planet(ptype, pmass, pname, pradius, pdistance, pposition);
        planet_threshold = pradius + 10f;

        if(!planet.createPlanet()){
          system_created = false;
          break;
        }
        else{
          factory = (SphereRendererFactory)GameObject.Find("SphereRendererFactory").GetComponent("SphereRendererFactory");
          base.sub_spheres[i] = factory.createSphereRenderer();
          base.sub_spheres[i].initialize(0, 0, planet_threshold,1 , planet);
          base.sub_spheres[i].setIsDisplayed(true);
        }
        system_created = true;
          }
        }
        return system_created;
    }

    // Use this for initialization
    void Start()
    {
        Material earthMaterial = Resources.Load("Materials/Earth/Earth") as Material;
        Material sunMaterial = Resources.Load("Materials/Sun") as Material;
        Material moonMaterial = Resources.Load("Materials/Moon/Moon") as Material;

        Star sun = new Star("Sun", new Vector3(0,0,0), 10, sunMaterial);
        IList planets = new ArrayList();

        for(int i = 0; i < 10; i++) {
            // TODO Change x/z random to randomize within a radius of sun instead of square
            int x = Random.Range(-200, 200);
            int y = 0;
            int z = Random.Range(-200, 200);
            float r = Random.Range(1, 4);
            float spinSpeed = Random.Range(-20, 21);

            Planet p = new Planet("Planet" + i, new Vector3(x, y, z), r, earthMaterial, spinSpeed, sun);
            planets.Add(p);

            int nSatellites = Random.Range(0, 4);
            for(int j = 0; j < nSatellites; j++) {
                float d = Random.Range(2*r, 8*r);
                Vector3 satellitePosition = new Vector3(x+d, y, z);
                float satelliteRadius = (float)Random.Range(r, r*5) / 10;
                float satelliteSpinSpeed = Random.Range(-20, 21);
                p.addSatellite("Satellite"+j+p.name,satellitePosition, satelliteRadius, moonMaterial, satelliteSpinSpeed);
            }
        }

        startUI();
    }

 public void AssignPlanet(Planet planet, int orbit)
 {
     if (orbit <= level + 3)
     {
         planets[orbit] = planet;
     }
 }

        public void BeUnEqualForObjectsWithDifferentValues()
        {
            var p1 = new Planet(
                name: "Mercury",
                massKg: 328500000000000000000000M,
                equatorialDiameterKm: 4879,
                polarDiameterKm: 4879,
                equatorialCircumferenceKm: 15329,
                orbitalDistanceKm: 57909227,
                orbitPeriodEarthDays: 87.97M,
                minSurfaceTemperatureCelsius: -173,
                maxSurfaceTemperatureCelsius: 427);

            var p2 = new Planet(
                name: "Venus",
                massKg: 4867000000000000000000000M,
                equatorialDiameterKm: 12104,
                polarDiameterKm: 12104,
                equatorialCircumferenceKm: 38025,
                orbitalDistanceKm: 108209475,
                orbitPeriodEarthDays: 224.70M,
                minSurfaceTemperatureCelsius: 462,
                maxSurfaceTemperatureCelsius: 462);

            Assert.IsFalse(p1.Equals(p2));
            Assert.IsFalse(p2.Equals(p1));
        }

        public void GridIsCreated()
        {
            var planet = new Planet(3, 3);

            Assert.That(planet.NumberOfRows, Is.EqualTo(3));
            Assert.That(planet.NumberOfColumns, Is.EqualTo(3));
        }

        public void BeEqualForObjectsWithSameValues()
        {
            var p1 = new Planet(
                name: "Mercury",
                massKg: 328500000000000000000000M,
                equatorialDiameterKm: 4879,
                polarDiameterKm: 4879,
                equatorialCircumferenceKm: 15329,
                orbitalDistanceKm: 57909227,
                orbitPeriodEarthDays: 87.97M,
                minSurfaceTemperatureCelsius: -173,
                maxSurfaceTemperatureCelsius: 427);

            var p2 = new Planet(
                name: "Mercury",
                massKg: 328500000000000000000000M,
                equatorialDiameterKm: 4879,
                polarDiameterKm: 4879,
                equatorialCircumferenceKm: 15329,
                orbitalDistanceKm: 57909227,
                orbitPeriodEarthDays: 87.97M,
                minSurfaceTemperatureCelsius: -173,
                maxSurfaceTemperatureCelsius: 427);

            Assert.IsTrue(p1.Equals(p2));
            Assert.IsTrue(p2.Equals(p1));
        }

 public Polyhedra(Planet p, List<Node> n, List<Edge> e, List<Face> f)
 {
     this.planet = p;
     this.nodes = n;
     this.edges = e;
     this.faces = f;
 }