import java.util.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class Planet {

private int id;
private String name;
private char politicalValue;
private int StartRebellionLoyalty;
private int ArmageddonLoyalty;
private int numEnvirons;
private StarSystem system;
private Environ[] PlanetEnvirons;
private int planetControl; // 0= imp. 1= rebel -1= neither
private int actualControl; // 0= imp. 1= rebellion 2= rebel 3= reb. stopped
private int loyalty;
private String raceHW;
private int PDBLevel;
private boolean isPDBup;
private int rebellionState;
private boolean isRebellion;
private Orbit PlanetOrbit;
private boolean imperialMUP;
private boolean rebelMUP;
private Vector deUnavailable;


static HumanPlayer humanPlayer = new HumanPlayer();

/** Constructor Method
 * @param i Planet ID
 * @param nam Planet Name
 * @param p Starfaring-Race
 * @param s Start Rebellion Loyalty
 * @param a Armagedon Loyalty
 * @param n No. of Environ
 */

public Planet(int i, String nam, String r,
              int sr, int a, int n, Environ[] environList, Orbit orbit)
{
   int j;
   id = i;
   name = nam;
   
   raceHW = r;
   politicalValue = 'N';
   system = null; /* until StarSystem adds us to it */
   StartRebellionLoyalty = sr;
   ArmageddonLoyalty = a;
   numEnvirons = n;
   PlanetEnvirons = environList;
   for(j=0; j<environList.length; j++) environList[j].isInPlanet(this);
   PlanetOrbit = orbit;
   orbit.isInPlanet(this);
   loyalty = 0;
   PDBLevel = 0;
   deUnavailable = new Vector(1);
}

/** Constructor Method
 * @param i Planet ID
 * @param nam Planet Name
 * @param p Political Status
 * @param s Start Rebellion Loyalty
 * @param a Armagedon Loyalty
 * @param n No. of Environ
 */

public Planet(int i, String nam, char p,
              int sr, int a, int n, Environ[] environList, Orbit orbit)
{  
   int j;
   id = i;
   name = nam;
   politicalValue = p;
   raceHW = null;
   system = null; /* until StarSystem adds us to it */
   StartRebellionLoyalty = sr;
   ArmageddonLoyalty = a;
   numEnvirons = n;
   PlanetEnvirons = environList;
   for(j=0; j<environList.length; j++) environList[j].isInPlanet(this);
   PlanetOrbit = orbit;
   orbit.isInPlanet(this);
   loyalty = 0;
   PDBLevel = 0;
   deUnavailable = new Vector(1);
}

static Planet Underworld[];
static Hashtable PlanetHash;
static Environ PlanetEnviron[];

   /**
    * accessor methods
    */

/** get(int)
 * Returns Planet with matching ID
 * @param id Planet's ID Number
 * @return Matching Planet
 */

public static Planet get(int id)
 {
    int start = 0;
    int end = Underworld.length;
    int middle;

    while (start < end) {
        middle = (start + end)/2;

        if (Underworld[middle].id == id)
          return Underworld[middle];

        else if (Underworld[middle].id > id)
	  end = middle;

        else
          start = middle + 1;
    }

  System.err.println("ID number not found");

  return null;
 }

/** get(String)
 * Returns Planet matching Name
 * @param s Planet Name
 * @return Planet
 */

 public static Planet get(String s)
 {
  return (Planet)PlanetHash.get(s);
 }

/** getPlanet()
 * returns the Planet name
 * @return Planet's Name
 */

public String getName()
{
   return name;
}

/** getID()
 * returns the ID number
 * @return Planet's ID Number
 */

public int getID()
{
   return id;
}

/** numEnvirons()
 * returns the number of environs (int) on the planet
 * @return Number of Environs on Planet
 */

public int getNumEnvirons()
    {
	return numEnvirons;
    }

/** getEnvirons()
 * returns a vector containing all the environs on the lanet
 * @return Vector of Environs
 */

public Vector getEnvirons()
{
    Vector v=new Vector();
    for(int i=0;i<numEnvirons;i++)
        v.addElement(PlanetEnvirons[i]);
    return v;
}

/**
 *getPlanetEnvirons()
 *returns an array (as opposed to a vector) of contained environs
 */
 public Environ [] getPlanetEnvirons()
 {
     return PlanetEnvirons;
 }
/** getSystem()
 * returns the Planet's StarSystem
 * @return Planet's StarSystem
 */
public StarSystem getSystem()
{
   return system;
}

/**
 * getPoliticalValue()
 * Gets the political value of a planet
 * @return 'N' = None, 'T' = Throne World, 'C' = Capital World, 'S' = Secret World
 */
public char getPoliticalValue()
{
    return politicalValue;
}


/**
 * @return Orbit Box
 */
public Orbit getOrbit()
{
   return PlanetOrbit;
}

   /**
    * StarSystem calls this when it is being created, please do not call it!
    */
   public void isInSystem(StarSystem s)
   {
      system = s;
   }
   
/** imperialControl()
    * method for possible change in actual control when planet control is
	*	imperial control
	* @author Team Rebellion (Stan V) (Leave these non Static for instances not the class)
	*/
   public void imperialControl() {
      rebellionState= 0;
      if(imperialMUP == true || (imperialMUP == true && rebelMUP == true) ||
	     (imperialMUP == false && rebelMUP == false)) {
		  planetControl= 0; 
	  }
	  else if(rebelMUP == true && isPDBup == true) {
	      planetControl= 0; 
	  }
	  else if(rebelMUP == true && isPDBup == false) {
	      planetControl= -1; 
	  }
   }
   
    /** startRebellionControl()
    * method when a start rebellion mission is successful
	* @author Team Rebellion (Stan V) (Leave these non Static for instances not the class)
	*/
   public void startRebellionControl() {
      loyalty= -2;
      humanPlayer.calcPoints(-2);
      rebellionState= 1;   
      humanPlayer.calcPoints(6);
      
	  if(isRebellion == false) {
	  	isRebellion= true;
	//	new Purchasing(p).show();  Correct please to affect the instances of a Planet and not the Planet class as a whole
	  }
      
      deRebellion(1);
      
   }  

    /** stateOfRebellionControl()
    * method for possible change in actual control when a Planet is in
	*	a state of rebellion
	* @author Team Rebellion (Stan V) (Leave these non Static for instances not the class)
	*/
   public void stateOfRebellionControl() {
      if(imperialMUP == true || (imperialMUP == true && rebelMUP == true)) {
	     actualControl= -1; 
	  }
	  else if(rebelMUP == true || (imperialMUP == false && rebelMUP == false) &&
	     isPDBup == false) {
		 actualControl= -1;
		 isPDBup= true; 
	  }
	  else if(rebelMUP == true || (imperialMUP == false && rebelMUP == false) &&
	     isPDBup == true) {
	     isRebellion= false;
		 rebelControl();
	  }                   
   }
   
   /** rebelControl()
    * method for possible change in actual control when planet control is
	*	rebel control
	* @author Team Rebellion (Stan V) (Leave these non Static for instances not the class)
	*/
   public void rebelControl() {
      if(rebelMUP == true || (rebelMUP == true && imperialMUP == true) ||
	     (rebelMUP == false && imperialMUP == false)) {
		 planetControl= 1;
                 humanPlayer.calcPoints(6);
		 actualControl= 1;
                 humanPlayer.calcPoints(5);
	  }
	  else if(imperialMUP == true && isPDBup == true)
	     actualControl= 1;
	  else if(imperialMUP == true && isPDBup == false)
         planetControl= -1;	            
         actualControl= -1;
         
         deRebelControl();
   }
   

   /** rebellionStoppedControl()
    * method for possible change in actual control when a stop rebellion
	*	mission is successful
	* @author Team Rebellion (Stan V)
	*/   
   public void rebellionStoppedControl() {
      if(rebelMUP == true || (rebelMUP == true && imperialMUP == true) ||
	     (rebelMUP == false && imperialMUP == false)) {
		 actualControl= -1;
	  }
	  else if(imperialMUP == true) {
	     imperialControl();
	  }
      
      deRebellion(-1);
   }
   
      /** getPlanetControl()
    * returns the planet's state
    * @return 0 - Imperial Control, 1 - Rebellion, 2 - Rebel Control, 3 - Rebellion Stopped
    */
public int getPlanetControl()
{
 return planetControl;
}

/** getActualControl()
 * returns who actually controls the planet 
 * @return 0 - Imperial, 1 - Rebel, -1 - Neither
 */

public int getActualControl()
{
 return actualControl;
}

/** getLoyalty()
 * returns the loyalty level of the planet
 * @return -2 Patriotic, -1 Loyal, 0 Neutral, 1 Dissent, 2 Unrest
 */

public int getLoyalty()
{
 return loyalty;   
}

/** getPDBLevel()
 * returns the PDB level of the planet
 * @return Negative - Imperial Controlled PDB, Positive - Rebel Controlled PDB
 */

public int getPDBLevel()
{
 return PDBLevel;
}

/** getPDBState()
 * returns whether the PDB is up or down
 * @return True - PDB Raised, False - PDB Lowered
 */

public boolean getisPDBUp()
{
 return isPDBup;
}

/**
 * getRebellionState()
 * returns the Rebellion state 
 * @return 0 - None, 1 - Rebellion Start, 2 - Rebellion Stopped
 */

public int getRebellionState()
{
 return rebellionState;
}

public Vector getdeUnavailable()
{
    return deUnavailable;
}

/**
 * Mutator Methods
 */
/** setPlanetControl(int)
 * sets new control of planet
 * @param newPlanetControl 0= imperial. 1= rebellion 2= rebel 3= rebellion stopped
 */

public void setPlanetControl(int newPlanetControl)
{
 planetControl = newPlanetControl;
}

/** setActualControl(int)
 * Sets new actual control
 * @param newActualControl 0 = Imperial, 1 = Rebel, -1 = Neither
 */

public void setActualControl(int newActualControl)
{
 actualControl = newActualControl;
}


/** setLoyalty(int)
 * sets the loyalty level of the planet
 * @param newLoyaly Loyalty Shift Amount 
 */

public void setLoyalty(int newLoyalty)
{
 int temp;
 
 temp = newLoyalty + loyalty;
 
 if (temp > 2 || temp < -2)
    return;
    
 loyalty = temp;   
 
 if (newLoyalty == 2)
     deLoyalty(1);
 
 if (newLoyalty == -2)
     deLoyalty(-1);

 int planNum = getID();
 int loyaltyLevel = getLoyalty();
 boolean PDBUp = getisPDBUp();
 boolean isinRebellion = isRebellion;
 map.MapFrame Map = GameMenu.Map;
 Map.setPlanetFlag(planNum, loyaltyLevel, PDBUp, isinRebellion);
}

/** setPDBLevel(int)
 * sets the PDB level of the planet
 * @param newPDBLevel New PDB Level
 */

public void setPDBLevel(int newPDBLevel)
{
   PDBLevel += newPDBLevel; 
	  
   if(PDBLevel > 2)
      PDBLevel= 2;
   if(PDBLevel < -2)
      PDBLevel= -2;
}

   // quick accessibility to the planets
   //  !!!careful with how you use this!!!
   public static Planet [] getUnderworld() {
      return Underworld;
   }

/** setPDBState(boolean)
 * Raises or lowers the PDB
 * @param newPDBState True - Raise Shield, False - Lower Shield
 */

public void setisPDBUp(boolean newPDBState)
{
 isPDBup = newPDBState;
}

/** setRebellionState(int)
 * sets the Rebellion state
 * @param newRebellionState 0 - None, 1 - Rebellion Start, 2 - Rebellion Stopped
 */

public void setRebellionState(int newRebellionState)
{
 rebellionState = newRebellionState;

 if(rebellionState == 2)
   isRebellion=  false;
}

/**
 * setRebellion();
 * sets a planets state such that the planet is in rebellion
 */
public void setRebellion() {
  isRebellion= true;
}

/**
 * addDEUnavailable()
 * Adds to list of planets unavailable for Domino Effect
 * @param Planet Name
 */
public void addDEUnavailable (String Planet)
{
 deUnavailable.addElement(Planet);
}

/**
 * checkPlanetControl()
 * Checks and Modifies which Player has Planet Control
 */

public void checkPlanetControl()
 {

 }

/** checkActualControl()
 * Checks and Modifies which Player has Actual Control
 */

public void checkActualControl()
 {
  return;
 }

/**
 * deLoyalty(int)
 * Applies Domino Effect if Loyalty Shift is more then 2
 * @param shift -1 = Imperial Favored Shift, 1 = Rebel Favored Shift
 */
public void deLoyalty(int shift)
 {
  Vector availablePlanets;
  Planet currentPlanet;
  Vector starFaringRaces;
  String currentRace;
  Vector choices = new Vector(1);
  Vector galaticchoices = new Vector(1);
  DominoGUI universal;
  DominoGUI galactic;
  boolean pvignored;
  DEListGUI sfHWEffect;
  int i;
  
  if (politicalValue == 'C' || politicalValue == 'T')
      pvignored = true;
  
  else 
      pvignored = false;
  
  if (raceHW != null) {
     availablePlanets = system.getProvince().getProvinceSameRace(raceHW,pvignored);
     deChoice(availablePlanets, shift, 1, 2);

     /* For Galatic Game */
  //    if (gameType == 'G') {
     availablePlanets = Galaxy.getGalacticSameRace(raceHW, id/100, pvignored);
     deChoice(availablePlanets, shift, 1, 1);
  //    }
  }
     
  else  {
      starFaringRaces = getPlanetStarFaringRaces();

      for (i = 0; i < starFaringRaces.size(); i++) {
          currentRace = (String)starFaringRaces.elementAt(i);
          availablePlanets = Galaxy.getGalacticSameRace(currentRace,0,pvignored);
          deChoice(availablePlanets, shift, 1, 1);
      }
  }

  availablePlanets = system.getsiblingplanets();
  deChoice(availablePlanets, shift, 1, 1);

  deUnavailable.clear();
}

/**
 * deRebellion(int)
 * Applies DOmino Effect caused Starting or Stopping of a Rebellion
 * @param shift Imperial Stopped Rebellion = -1, Rebel Started Rebellion = 1
 */
public void deRebellion(int shift)
{
  Vector availablePlanets;
  Planet currentPlanet;
  DEListGUI universal;
  DominoGUI galactic;
  Vector choices;
  int AIChoice;
  Vector galacticchoices;
  Vector starFaringRaces;
  String currentRace;
  DEListGUI sfHWEffect;
  int i;
  boolean pvignored;

  if (politicalValue == 'C' || politicalValue == 'T')
      pvignored = true;

  else
      pvignored = false;

  availablePlanets = system.getsiblingplanets();
  deChoice(availablePlanets, shift, 1, 2);

  if (raceHW != null) {
     availablePlanets = system.getProvince().getProvinceSameRace(raceHW,pvignored);
     deChoice(availablePlanets, shift, 1, 2);

//     if (Game.gameType == 'G') {
     availablePlanets = Galaxy.getGalacticSameRace(raceHW, id/100, pvignored);
     deChoice(availablePlanets, shift, 2, 1);
//       }
  }

  else {
     starFaringRaces = getPlanetStarFaringRaces();
     for (i = 0; i < starFaringRaces.size();i++)
         {
          currentRace = (String)starFaringRaces.elementAt(i);
          if (fitg.thisGame.gameType == 'g')     
             availablePlanets = Galaxy.getGalacticSameRace(raceHW, 0, pvignored);
     
          else 
             availablePlanets = Province.get(id/100).getProvinceSameRace(raceHW, pvignored);

          deChoice(availablePlanets, shift, 2, 1);
         }
  }

  deUnavailable.clear();
}

public void deRebelControl()
{
 Vector availablePlanets;
 Vector starFaringRaces;
 String currentRace;
 boolean pvignored;
 
 if (politicalValue == 'C' || politicalValue == 'T')
      pvignored = true;
  
  else 
      pvignored = false;
 
 availablePlanets = system.getsiblingplanets();
 deChoice(availablePlanets, 1,1,2);
 
 if (raceHW != null)
 { 
     if (fitg.thisGame.gameType == 'g')     
        availablePlanets = Galaxy.getGalacticSameRace(raceHW, 0, pvignored);
     
     else 
        availablePlanets = Province.get(id/100).getProvinceSameRace(raceHW, pvignored);
     
     deChoice(availablePlanets,1,1,2);
 }
 
 else
 {
  starFaringRaces = getPlanetStarFaringRaces();
  for (int i = 0; i < starFaringRaces.size();i++)
      {
       currentRace = (String)starFaringRaces.elementAt(i);
       availablePlanets = Galaxy.getGalacticSameRace(currentRace,0, pvignored);

       deChoice(availablePlanets, 1, 2, 1);
      }
 }
 
 deUnavailable.clear();
}

/**
 * ChoiceList(Vector, int)
 * @param availablePlanets List (Vector) of planets available for Domino Effect
 * @param shift -1 Imperial Favor, 1 Rebel Favor
 * @return List (Vector) of choices for DominoGUI
 */

public Vector ChoiceList(Vector availablePlanets, int shift)
 {
  Planet currentPlanet;
  int currentloyalty;
  Vector choices = new Vector(1);
  for (int i = 0; i < availablePlanets.size();i++) {
      currentPlanet = (Planet)availablePlanets.elementAt(i);
      currentloyalty = currentPlanet.getLoyalty();

      if (getID() == currentPlanet.getID())
          continue;

      if (!deUnavailable.isEmpty() && deUnavailable.contains(currentPlanet.getName()))
         continue;

      if ((shift == 1 && (currentloyalty < -2 || currentloyalty > 2)) ||
          (shift == -1 && (currentloyalty > 1 || currentloyalty < -2)))
         continue;

      choices.addElement(currentPlanet.getName());
  }

  return choices;
 }

/**
 * getPlanetStarFaringRaces()
 * Returns a list of StarFaring Races on Planet
 * @return Vector of StarFaring Races
 */

public Vector getPlanetStarFaringRaces()
{
    Vector list;
    Vector FinalList = new Vector(1);
    int j;
    String race;

    for (int i = 0; i < PlanetEnvirons.length; i++) {
        list = PlanetEnvirons[i].getEnvironStarFaringRaces();

        if (!list.isEmpty()) {
            for (j = 0; j < list.size(); j++) {
                race = (String)list.elementAt(j);

                if (!FinalList .contains(race) && (raceHW == null || removetype(race).equals(raceHW)))
                    FinalList.addElement(race);
            }

        }
    }

    return FinalList;
}

/** hasRace(String)
 * Returns if a race is on a planet
 * @return True - On Planet, False - Not on Planet
 * @param pvignored
 * @param race Race searching for
 */

public boolean hasRace(String race,boolean pvignored) {
  if (raceHW != null && raceHW.equals(removetype(race)))
     return false;

  if (!pvignored && (politicalValue == 'C' || politicalValue == 'T'))
     return false;

  for (int i = 0; i < PlanetEnvirons.length;i++) {
      if (PlanetEnvirons[i].hasRace(race))
         return true;
  }

  return false;
}

/**
 * deChoice(Vector, int, int, int)
 * Applies Domino Effects
 * @param availablePlanets Planets Available for Domino Effect
 * @param shift -1 = Imperial Favor, 1 = Rebel Favor
 * @param numberchoices Number of choices for Domino Effect
 * @param type Type of Domino Effect (1 = Player's Choice, 2 = No Choice, apply all)
 */
public void deChoice(Vector availablePlanets, int shift, int numberchoices, int type)
{
 DominoGUI deChoiceDialog;
 DEListGUI applyAll;
 int AIChoice;
 Vector choices;
 Planet currentPlanet;

 if (availablePlanets.isEmpty())
    return;

 choices = ChoiceList(availablePlanets,shift);

 if (choices.isEmpty())
    return;

  if (type == 1) {
     if (shift == 1) {
        deChoiceDialog = new DominoGUI(choices, this, numberchoices);
        deChoiceDialog.setVisible(true);

        while (!deChoiceDialog.finished){     }
     }

     else {
          for (int i = 0; i<numberchoices;i++) {
              AIChoice = AI.makeDecision(availablePlanets.size());
              currentPlanet = (Planet)availablePlanets.elementAt(AIChoice);
              currentPlanet.setLoyalty(shift);
              addDEUnavailable(currentPlanet.getName());
          }
     }
 }

 else {
      applyAll = new DEListGUI(choices, this, shift);

      if (shift == 1) {
         applyAll.setVisible(true);
         while (!applyAll.finished) { }
     }
 }
}

/**
 * removetype(String race)
 * @param race Race String
 * @return Race without Environ type
 */
    public String removetype(String race)
    {
     String newRace;
     int i;

     i = race.indexOf('_');

     if (i == -1)
        return race;

     newRace = race.substring(0,i);

     return newRace;
    }

    /**
     *hasMissionChars()
     *decides whether the planet has characters on it on the selected side
     */
     public boolean hasMissionChars(int side)
     {
         for(int i=0;i<PlanetEnvirons.length;i++)
             if(PlanetEnvirons[i].hasMissionChars(side))
                 return true;
         return false;
     }
/**
 * init()
 * Intializes all planets
 */

   public static void init()
   {
      /*
       * have to have environs in order to have planets.
       */
   Environ.init();

   PlanetHash = new Hashtable();

   Environ[] PlanetEnviron1 = {Environ.AllEnviron[0]};
   Environ[] PlanetEnviron2 = {Environ.AllEnviron[1],Environ.AllEnviron[2]};
   Environ[] PlanetEnviron3 = {Environ.AllEnviron[3],Environ.AllEnviron[4]};
   Environ[] PlanetEnviron4 = {Environ.AllEnviron[5]};
   Environ[] PlanetEnviron5 = {Environ.AllEnviron[6],Environ.AllEnviron[7],Environ.AllEnviron[8]};
   Environ[] PlanetEnviron6 = {Environ.AllEnviron[9]};
   Environ[] PlanetEnviron7 = {Environ.AllEnviron[10]};
   Environ[] PlanetEnviron8 = {Environ.AllEnviron[11],Environ.AllEnviron[12]};
   Environ[] PlanetEnviron9 = {Environ.AllEnviron[13],Environ.AllEnviron[14]};
   Environ[] PlanetEnviron10 = {Environ.AllEnviron[15],Environ.AllEnviron[16]};
   Environ[] PlanetEnviron11 = {Environ.AllEnviron[17],Environ.AllEnviron[18]};
   Environ[] PlanetEnviron12 = {Environ.AllEnviron[19]};
   Environ[] PlanetEnviron13 = {Environ.AllEnviron[20],Environ.AllEnviron[21],Environ.AllEnviron[22]};
   Environ[] PlanetEnviron14 = {Environ.AllEnviron[23]};
   Environ[] PlanetEnviron15 = {Environ.AllEnviron[24]};
   Environ[] PlanetEnviron16 = {Environ.AllEnviron[25],Environ.AllEnviron[26]};
   Environ[] PlanetEnviron17 = {Environ.AllEnviron[27]};
   Environ[] PlanetEnviron18 = {Environ.AllEnviron[28]};
   Environ[] PlanetEnviron19 = {Environ.AllEnviron[29],Environ.AllEnviron[30]};
   Environ[] PlanetEnviron20 = {Environ.AllEnviron[31],Environ.AllEnviron[32]};
   Environ[] PlanetEnviron21 = {Environ.AllEnviron[33],Environ.AllEnviron[34],Environ.AllEnviron[35]};
   Environ[] PlanetEnviron22 = {Environ.AllEnviron[36],Environ.AllEnviron[37]};
   Environ[] PlanetEnviron23 = {Environ.AllEnviron[38],Environ.AllEnviron[39]};
   Environ[] PlanetEnviron24 = {Environ.AllEnviron[40],Environ.AllEnviron[41]};
   Environ[] PlanetEnviron25 = {Environ.AllEnviron[42]};
   Environ[] PlanetEnviron26 = {Environ.AllEnviron[43],Environ.AllEnviron[44]};
   Environ[] PlanetEnviron27 = {Environ.AllEnviron[45],Environ.AllEnviron[46]};
   Environ[] PlanetEnviron28 = {Environ.AllEnviron[47]};
   Environ[] PlanetEnviron29 = {Environ.AllEnviron[48],Environ.AllEnviron[49]};
   Environ[] PlanetEnviron30 = {Environ.AllEnviron[50],Environ.AllEnviron[51],Environ.AllEnviron[52]};
   Environ[] PlanetEnviron31 = {Environ.AllEnviron[53]};
   Environ[] PlanetEnviron32 = {Environ.AllEnviron[54]};
   Environ[] PlanetEnviron33 = {Environ.AllEnviron[55]};
   Environ[] PlanetEnviron34 = {Environ.AllEnviron[56],Environ.AllEnviron[57]};
   Environ[] PlanetEnviron35 = {Environ.AllEnviron[58],Environ.AllEnviron[59]};
   Environ[] PlanetEnviron36 = {Environ.AllEnviron[60]};
   Environ[] PlanetEnviron37 = {Environ.AllEnviron[61],Environ.AllEnviron[62],Environ.AllEnviron[63]};
   Environ[] PlanetEnviron38 = {Environ.AllEnviron[64],Environ.AllEnviron[65]};
   Environ[] PlanetEnviron39 = {Environ.AllEnviron[66]};
   Environ[] PlanetEnviron40 = {Environ.AllEnviron[67],Environ.AllEnviron[68]};
   Environ[] PlanetEnviron41 = {Environ.AllEnviron[69]};
   Environ[] PlanetEnviron42 = {Environ.AllEnviron[70]};
   Environ[] PlanetEnviron43 = {Environ.AllEnviron[71]};
   Environ[] PlanetEnviron44 = {Environ.AllEnviron[72],Environ.AllEnviron[73]};
   Environ[] PlanetEnviron45 = {Environ.AllEnviron[74]};
   Environ[] PlanetEnviron46 = {Environ.AllEnviron[75]};
   Environ[] PlanetEnviron47 = {Environ.AllEnviron[76],Environ.AllEnviron[77]};
   Environ[] PlanetEnviron48 = {Environ.AllEnviron[78]};
   Environ[] PlanetEnviron49 = {Environ.AllEnviron[79]};
   Environ[] PlanetEnviron50 = {Environ.AllEnviron[80],Environ.AllEnviron[81]};
   Environ[] PlanetEnviron51 = {Environ.AllEnviron[82]};

  Orbit.init();
  Orbit PlanetOrbit1 = Orbit.AllOrbit[0];
  Orbit PlanetOrbit2 = Orbit.AllOrbit[1];
  Orbit PlanetOrbit3 = Orbit.AllOrbit[2];
  Orbit PlanetOrbit4 = Orbit.AllOrbit[3];
  Orbit PlanetOrbit5 = Orbit.AllOrbit[4];
  Orbit PlanetOrbit6 = Orbit.AllOrbit[5];
  Orbit PlanetOrbit7 = Orbit.AllOrbit[6];
  Orbit PlanetOrbit8 = Orbit.AllOrbit[7];
  Orbit PlanetOrbit9 = Orbit.AllOrbit[8];
  Orbit PlanetOrbit10 = Orbit.AllOrbit[9];
  Orbit PlanetOrbit11 = Orbit.AllOrbit[10];
  Orbit PlanetOrbit12 = Orbit.AllOrbit[11];
  Orbit PlanetOrbit13 = Orbit.AllOrbit[12];
  Orbit PlanetOrbit14 = Orbit.AllOrbit[13];
  Orbit PlanetOrbit15 = Orbit.AllOrbit[14];
  Orbit PlanetOrbit16 = Orbit.AllOrbit[15];
  Orbit PlanetOrbit17 = Orbit.AllOrbit[16];
  Orbit PlanetOrbit18 = Orbit.AllOrbit[17];
  Orbit PlanetOrbit19 = Orbit.AllOrbit[18];
  Orbit PlanetOrbit20 = Orbit.AllOrbit[19];
  Orbit PlanetOrbit21 = Orbit.AllOrbit[20];
  Orbit PlanetOrbit22 = Orbit.AllOrbit[21];
  Orbit PlanetOrbit23 = Orbit.AllOrbit[22];
  Orbit PlanetOrbit24 = Orbit.AllOrbit[23];
  Orbit PlanetOrbit25 = Orbit.AllOrbit[24];
  Orbit PlanetOrbit26 = Orbit.AllOrbit[25];
  Orbit PlanetOrbit27 = Orbit.AllOrbit[26];
  Orbit PlanetOrbit28 = Orbit.AllOrbit[27];
  Orbit PlanetOrbit29 = Orbit.AllOrbit[28];
  Orbit PlanetOrbit30 = Orbit.AllOrbit[29];
  Orbit PlanetOrbit31 = Orbit.AllOrbit[30];
  Orbit PlanetOrbit32 = Orbit.AllOrbit[31];
  Orbit PlanetOrbit33 = Orbit.AllOrbit[32];
  Orbit PlanetOrbit34 = Orbit.AllOrbit[33];
  Orbit PlanetOrbit35 = Orbit.AllOrbit[34];
  Orbit PlanetOrbit36 = Orbit.AllOrbit[35];
  Orbit PlanetOrbit37 = Orbit.AllOrbit[36];
  Orbit PlanetOrbit38 = Orbit.AllOrbit[37];
  Orbit PlanetOrbit39 = Orbit.AllOrbit[38];
  Orbit PlanetOrbit40 = Orbit.AllOrbit[39];
  Orbit PlanetOrbit41 = Orbit.AllOrbit[40];
  Orbit PlanetOrbit42 = Orbit.AllOrbit[41];
  Orbit PlanetOrbit43 = Orbit.AllOrbit[42];
  Orbit PlanetOrbit44 = Orbit.AllOrbit[43];
  Orbit PlanetOrbit45 = Orbit.AllOrbit[44];
  Orbit PlanetOrbit46 = Orbit.AllOrbit[45];
  Orbit PlanetOrbit47 = Orbit.AllOrbit[46];
  Orbit PlanetOrbit48 = Orbit.AllOrbit[47];
  Orbit PlanetOrbit49 = Orbit.AllOrbit[48];
  Orbit PlanetOrbit50 = Orbit.AllOrbit[49];
  Orbit PlanetOrbit51 = Orbit.AllOrbit[50];

  Underworld = new Planet[51];
  Underworld[0] = new Planet (111,"Mimulus","Kayns",-2,-1,1,PlanetEnviron1,PlanetOrbit1);
  Underworld[1] = new Planet (112,"Magro",null,-2,-1,2,PlanetEnviron2,PlanetOrbit2);
  Underworld[2] = new Planet (113,"Fliad",'S',-2,0,2,PlanetEnviron3,PlanetOrbit3);
  Underworld[3] = new Planet (121,"Kalgar",null,-2,-1,1,PlanetEnviron4,PlanetOrbit4);
  Underworld[4] = new Planet (122,"Bajukai","Segundens",-1,0,3,PlanetEnviron5,PlanetOrbit5);
  Underworld[5] = new Planet (131,"Tiglyf",'S',-2,1,1,PlanetEnviron6,PlanetOrbit6);
  Underworld[6] = new Planet (141,"Ownex",null,0,3,1,PlanetEnviron7,PlanetOrbit7);
  Underworld[7] = new Planet (142,"Adare",null,-1,0,2,PlanetEnviron8,PlanetOrbit8);
  Underworld[8] = new Planet (143,"Mitrith",'S',-2,1,2,PlanetEnviron9,PlanetOrbit9);
  Underworld[9] = new Planet (151,"Jura",null,-2,-1,2,PlanetEnviron10,PlanetOrbit10);
  Underworld[10] = new Planet (152,"Diomas",'C',-2,-2,2,PlanetEnviron11,PlanetOrbit11);
  Underworld[11] = new Planet (161,"Liomax",null,-2,0,1,PlanetEnviron12,PlanetOrbit12);
  Underworld[12] = new Planet (162,"Orlog",'T',-2,-2,3,PlanetEnviron13,PlanetOrbit13);
  Underworld[13] = new Planet (163,"Icid",null,-2,-1,1,PlanetEnviron14,PlanetOrbit14);
  Underworld[14] = new Planet (211,"Cieson","Yesters",-1,0,1,PlanetEnviron15,PlanetOrbit15);
  Underworld[15] = new Planet (212,"Etreg",'S',-2,0,2,PlanetEnviron16,PlanetOrbit16);
  Underworld[16] = new Planet (221,"Quibron",'S',-1,2,1,PlanetEnviron17,PlanetOrbit17);
  Underworld[17] = new Planet (222,"Angoff",'S',0,3,1,PlanetEnviron18,PlanetOrbit18);
  Underworld[18] = new Planet (223,"Charkhan",null,-2,1,2,PlanetEnviron19,PlanetOrbit19);
  Underworld[19] = new Planet (231,"Pronox",null,-2,-1,2,PlanetEnviron20,PlanetOrbit20);
  Underworld[20] = new Planet (232,"Lysenda",null,-1,1,3,PlanetEnviron21,PlanetOrbit21);
  Underworld[21] = new Planet (241,"Orning",'C',-2,-1,2,PlanetEnviron22,PlanetOrbit22);
  Underworld[22] = new Planet (311,"Chim",'C',-2,-2,2,PlanetEnviron23,PlanetOrbit23);
  Underworld[23] = new Planet (312,"Tamsetx",'S',1,3,2,PlanetEnviron24,PlanetOrbit24);
  Underworld[24] = new Planet (321,"Unarpha","Saurians",-1,0,1,PlanetEnviron25,PlanetOrbit25);
  Underworld[25] = new Planet (322,"Suti",null,0,2,2,PlanetEnviron26,PlanetOrbit26);
  Underworld[26] = new Planet (323,"Tsipa",null,-2,-1,2,PlanetEnviron27,PlanetOrbit27);
  Underworld[27] = new Planet (331,"Squamot",'S',0,3,1,PlanetEnviron28,PlanetOrbit28);
  Underworld[28] = new Planet (341,"Midest",'S',-2,1,2,PlanetEnviron29,PlanetOrbit29);
  Underworld[29] = new Planet (342,"Akubera",null,-2,0,3,PlanetEnviron30,PlanetOrbit30);
  Underworld[30] = new Planet (351,"Mrane","Suvans",-1,0,1,PlanetEnviron31,PlanetOrbit31);
  Underworld[31] = new Planet (352,"Kelta",'S',-1,1,1,PlanetEnviron32,PlanetOrbit32);
  Underworld[32] = new Planet (411,"Troliso",'C',-2,-2,1,PlanetEnviron33,PlanetOrbit33);
  Underworld[33] = new Planet (412,"Heliax",null,-2,0,2,PlanetEnviron34,PlanetOrbit34);
  Underworld[34] = new Planet (421,"Lonica",null,-1,0,2,PlanetEnviron35,PlanetOrbit35);
  Underworld[35] = new Planet (431,"Horon",null,-2,0,1,PlanetEnviron36,PlanetOrbit36);
  Underworld[36] = new Planet (432,"Solvia",null,-1,1,3,PlanetEnviron37,PlanetOrbit37);
  Underworld[37] = new Planet (433,"Cercis",null,0,3,2,PlanetEnviron38,PlanetOrbit38);
  Underworld[38] = new Planet (441,"Rhexia",null,1,3,1,PlanetEnviron39,PlanetOrbit39);
  Underworld[39] = new Planet (442,"Tartio",'S',-1,1,2,PlanetEnviron40,PlanetOrbit40);
  Underworld[40] = new Planet (451,"Ayod","Piorads",-1,0,1,PlanetEnviron41,PlanetOrbit41);
  Underworld[41] = new Planet (511,"Barak",null,0,3,1,PlanetEnviron42,PlanetOrbit42);
  Underworld[42] = new Planet (512,"Liatris",'S',-2,0,1,PlanetEnviron43,PlanetOrbit43);
  Underworld[43] = new Planet (513,"Xan","Xanthons",-1,1,2,PlanetEnviron44,PlanetOrbit44);
  Underworld[44] = new Planet (521,"Aras",'S',-1,0,1,PlanetEnviron45,PlanetOrbit45);
  Underworld[45] = new Planet (522,"Capilax",'S',-1,1,1,PlanetEnviron46,PlanetOrbit46);
  Underworld[46] = new Planet (523,"Aorax",null,-2,-1,2,PlanetEnviron47,PlanetOrbit47);
  Underworld[47] = new Planet (531,"Scythia",'S',-1,3,1,PlanetEnviron48,PlanetOrbit48);
  Underworld[48] = new Planet (541,"Annell",'S',0,2,1,PlanetEnviron49,PlanetOrbit49);
  Underworld[49] = new Planet (542,"Trov",'C',-2,-2,2,PlanetEnviron50,PlanetOrbit50);
  Underworld[50] = new Planet (551,"Niconi",null,-2,0,1,PlanetEnviron51,PlanetOrbit51);

  PlanetHash.put("Mimulus", Underworld[0]);
  PlanetHash.put("Magro", Underworld[1]);
  PlanetHash.put("Fliad",Underworld[2]);
  PlanetHash.put("Kalgar",Underworld[3]);
  PlanetHash.put("Bajukai",Underworld[4]);
  PlanetHash.put("Tiglyf",Underworld[5]);
  PlanetHash.put("Ownex",Underworld[6]);
  PlanetHash.put("Adare",Underworld[7]);
  PlanetHash.put("Mitrith",Underworld[8]);
  PlanetHash.put("Jura",Underworld[9]);
  PlanetHash.put("Diomas",Underworld[10]);
  PlanetHash.put("Liomax",Underworld[11]);
  PlanetHash.put("Orlog",Underworld[12]);
  PlanetHash.put("Icid",Underworld[13]);
  PlanetHash.put("Cieson",Underworld[14]);
  PlanetHash.put("Etreg",Underworld[15]);
  PlanetHash.put("Quibron",Underworld[16]);
  PlanetHash.put("Angoff",Underworld[17]);
  PlanetHash.put("Charkhan",Underworld[18] );
  PlanetHash.put("Pronox",Underworld[19]);
  PlanetHash.put("Lysenda",Underworld[20]);
  PlanetHash.put("Orning",Underworld[21]);
  PlanetHash.put("Chim",Underworld[22]);
  PlanetHash.put("Tamsetx",Underworld[23]);
  PlanetHash.put("Unarpha",Underworld[24]);
  PlanetHash.put("Suti",Underworld[25]);
  PlanetHash.put("Tsipa",Underworld[26]);
  PlanetHash.put("Squamot",Underworld[27]);
  PlanetHash.put("Midest",Underworld[28]);
  PlanetHash.put("Akubera",Underworld[29]);
  PlanetHash.put("Mrane",Underworld[30]);
  PlanetHash.put("Kelta",Underworld[31]);
  PlanetHash.put("Troliso",Underworld[32]);
  PlanetHash.put("Heliax",Underworld[33]);
  PlanetHash.put("Lonica",Underworld[34]);
  PlanetHash.put("Horon",Underworld[35]);
  PlanetHash.put("Solvia",Underworld[36]);
  PlanetHash.put("Cercis",Underworld[37]);
  PlanetHash.put("Rhexia",Underworld[38]);
  PlanetHash.put("Tartio",Underworld[39]);
  PlanetHash.put("Ayod",Underworld[40]);
  PlanetHash.put("Barak",Underworld[41]);
  PlanetHash.put("Liatris",Underworld[42]);
  PlanetHash.put("Xan",Underworld[43]);
  PlanetHash.put("Aras",Underworld[44]);
  PlanetHash.put("Capilax",Underworld[45]);
  PlanetHash.put("Aorax",Underworld[46]);
  PlanetHash.put("Scythia",Underworld[47]);
  PlanetHash.put("Annell",Underworld[48]);
  PlanetHash.put("Trov",Underworld[49]);
  PlanetHash.put("Niconi",Underworld[50]);
 }
  
  public boolean PDBdetectionRoutine(Spaceship ship) {
		String detectionVal;
		if (isPDBup == false) return true;
		if (planetControl == 0 && ship.getPilot().getLoyalty() == "Imperial") return true;
		if (planetControl == 1 && ship.getPilot().getLoyalty() == "Rebel") return true;
		if (planetControl == 2 || planetControl == 3) return true;
		detectionVal = MTDetectionTable.DetectionTable(ship, Math.abs(PDBLevel));
		if (detectionVal == "U") return true;
		if (detectionVal == "D" || detectionVal == "D*") 
			 {
				  for (int i = 0; i < ship.getNumPassengers(); i++)
						((Charactr)ship.getShipPassengers().elementAt(i)).setIsDetected(true);
				  System.out.println("The passengers in the ship are detected.");
				  return true;
			 }
		if (detectionVal == "Dd")
			 {
				  for (int i = 0; i < ship.getNumPassengers(); i++)
						((Charactr)ship.getShipPassengers().elementAt(i)).setIsDetected(true);

				  System.out.println("Your ship has been damaged.  The passengers are detected.");
				  ship.setInPlay(false);
				  return true;
			 }
		for (int i = 0; i < ship.getNumPassengers(); i++)
						((Charactr)ship.getShipPassengers().elementAt(i)).setInPlay(false);
		System.out.println("Your ship was destroyed!!!  Everyone inside is dead!!! AARRGH!!!");
		ship.setInPlay(false);
		return false;
  }

}