title: basic planet wars ai issues
body: <p>I am programming a very basic bot for planet wars in java and I cant seem to find the errors in my code. I am receiving a few different error messages but the main issue for me is the error: class, interface, or enum expected. Ive checked my brackets about a thousand times. Any help would be appreciated. Here's my bot code:</p>
  
  <pre><code>import java.util.List;
  import java.util.Random;
  
  import shared.Planet;
  import shared.PlanetWars;
  
  public class MyNewBot {
  
  public static void doTurn(PlanetWars pw) {
      // (1) If we currently have a fleet in flight, then do nothing until
      // it arrives.
      if (pw.myFleets().size() &gt;= 10) {
          return;
      }
  
      // (2) Pick one of my planets based on the number of ships 
  
      Planet source = null;
      int largestForce = 0;
      for (Planet p : pw.myPlanets()){
          int force = pw.numShips();
          if( force &gt; largestForce){
              largestForce = force;
              source = p;
          }
      }
  
      // (3) Pick a target planet at random.
      Planet dest = null;
      int highestGrowthRate = 0;
      int shortestDistance = 9999;
      for (Planet p = pw.notMyPlanets()){
          int growthRate = pw.growthRate();
          if( growthRate &gt; highestGrowthRate){
              highestGrowthRate = growthRate;
              dest = p;
          }else if (growthRate == highestGrowthRate){
              int distance = pw.distance(source,p);
              if (distance &lt; shortestDistance){
                  shortestDistance = distance;
                  dest = p;
              }
          }
      }
  
  
      // (4) Send half the ships from source to destination.
      if (source != null &amp;&amp; dest != null) {
          int numShips = source.numShips() / 2;
          pw.issueOrder(source, dest, numShips);
      }
  }
  
  // Ignore the main method unless you know what you're doing.
  // Refer to the doTurn function to code your bot.
  public static void main(String[] args) {
      String line = "";
      String message = "";
      int c;
      try {
          while ((c = System.in.read()) &gt;= 0) {
              switch (c) {
              case '\n':
                  if (line.equals("go")) {
                      PlanetWars pw = new PlanetWars(message);
                      doTurn(pw);
                      pw.finishTurn();
                      message = "";
                  } else {
                      message += line + "\n";
                  }
                  line = "";
                  break;
              default:
                  line += (char) c;
                  break;
              }
          }
      } catch (Exception e) {
          // Owned.
      }
  }
  
  }
  </code></pre>
  
  <p>and the supporting class files:</p>
  
  <pre><code>package shared;
  public class Planet implements Cloneable {
  
  private int planetID;
  private int owner;
  private int numShips;
  private int growthRate;
  private double x, y;
  
  public Planet(int planetID, int owner, int numShips, int growthRate,
          double x, double y) {
      this.planetID = planetID;
      this.owner = owner;
      this.numShips = numShips;
      this.growthRate = growthRate;
      this.x = x;
      this.y = y;
  }
  
  public int planetID() {
      return planetID;
  }
  
  public int owner() {
      return owner;
  }
  
  public int numShips() {
      return numShips;
  }
  
  public int growthRate() {
      return growthRate;
  }
  
  public double x() {
      return x;
  }
  
  public double y() {
      return y;
  }
  
  public void owner(int newOwner) {
      this.owner = newOwner;
  }
  
  public void numShips(int newNumShips) {
      this.numShips = newNumShips;
  }
  
  public void addShips(int amount) {
      numShips += amount;
  }
  
  public void removeShips(int amount) {
      numShips -= amount;
  }
  
  private Planet(Planet _p) {
      planetID = _p.planetID;
      owner = _p.owner;
      numShips = _p.numShips;
      growthRate = _p.growthRate;
      x = _p.x;
      y = _p.y;
  }
  
  public Object clone() {
      return new Planet(this);
  }
  }
  
  package shared;
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Set;
  import java.util.TreeSet;
  
  public class PlanetWars {
  // Constructs a PlanetWars object instance, given a string containing a
  // description of a game state.
  public PlanetWars(String gameStateString) {
      planets = new ArrayList&lt;Planet&gt;();
      fleets = new ArrayList&lt;Fleet&gt;();
      parseGameState(gameStateString);
  }
  
  // Returns the number of planets. Planets are numbered starting with 0.
  public int numPlanets() {
      return planets.size();
  }
  
  // Returns the planet with the given planet_id. There are NumPlanets()
  // planets. They are numbered starting at 0.
  public Planet getPlanet(int planetID) {
      return planets.get(planetID);
  }
  
  // Returns the number of fleets.
  public int numFleets() {
      return fleets.size();
  }
  
  // Returns the fleet with the given fleet_id. Fleets are numbered starting
  // with 0. There are NumFleets() fleets. fleet_id's are not consistent from
  // one turn to the next.
  public Fleet getFleet(int fleetID) {
      return fleets.get(fleetID);
  }
  
  // Returns a list of all the planets.
  public List&lt;Planet&gt; planets() {
      return planets;
  }
  
  // Return a list of all the planets owned by the current player. By
  // convention, the current player is always player number 1.
  public List&lt;Planet&gt; myPlanets() {
      List&lt;Planet&gt; r = new ArrayList&lt;Planet&gt;();
      for (Planet p : planets) {
          if (p.owner() == 1) {
              r.add(p);
          }
      }
      return r;
  }
  
  // Return a list of all neutral planets.
  public List&lt;Planet&gt; neutralPlanets() {
      List&lt;Planet&gt; r = new ArrayList&lt;Planet&gt;();
      for (Planet p : planets) {
          if (p.owner() == 0) {
              r.add(p);
          }
      }
      return r;
  }
  
  // Return a list of all the planets owned by rival players. This excludes
  // planets owned by the current player, as well as neutral planets.
  public List&lt;Planet&gt; enemyPlanets() {
      List&lt;Planet&gt; r = new ArrayList&lt;Planet&gt;();
      for (Planet p : planets) {
          if (p.owner() &gt;= 2) {
              r.add(p);
          }
      }
      return r;
  }
  
  // Return a list of all the planets that are not owned by the current
  // player. This includes all enemy planets and neutral planets.
  public List&lt;Planet&gt; notMyPlanets() {
      List&lt;Planet&gt; r = new ArrayList&lt;Planet&gt;();
      for (Planet p : planets) {
          if (p.owner() != 1) {
              r.add(p);
          }
      }
      return r;
  }
  
  // Return a list of all the fleets.
  public List&lt;Fleet&gt; fleets() {
      List&lt;Fleet&gt; r = new ArrayList&lt;Fleet&gt;();
      for (Fleet f : fleets) {
          r.add(f);
      }
      return r;
  }
  
  // Return a list of all the fleets owned by the current player.
  public List&lt;Fleet&gt; myFleets() {
      List&lt;Fleet&gt; r = new ArrayList&lt;Fleet&gt;();
      for (Fleet f : fleets) {
          if (f.owner() == 1) {
              r.add(f);
          }
      }
      return r;
  }
  
  // Return a list of all the fleets owned by enemy players.
  public List&lt;Fleet&gt; enemyFleets() {
      List&lt;Fleet&gt; r = new ArrayList&lt;Fleet&gt;();
      for (Fleet f : fleets) {
          if (f.owner() != 1) {
              r.add(f);
          }
      }
      return r;
  }
  
  // Returns the distance between two planets, rounded up to the next highest
  // integer. This is the number of discrete time steps it takes to get
  // between the two planets.
  public int distance(int sourcePlanet, int destinationPlanet) {
      Planet source = planets.get(sourcePlanet);
      Planet destination = planets.get(destinationPlanet);
      double dx = source.x() - destination.x();
      double dy = source.y() - destination.y();
      return (int) Math.ceil(Math.sqrt(dx * dx + dy * dy));
  }
  
  // Returns the distance between two planets, rounded up to the next highest
  // integer. This is the number of discrete time steps it takes to get
  // between the two planets.
  public int distance(Planet source, Planet destination) {
      double dx = source.x() - destination.x();
      double dy = source.y() - destination.y();
      return (int) Math.ceil(Math.sqrt(dx * dx + dy * dy));
  }
  
  // Sends an order to the game engine. An order is composed of a source
  // planet number, a destination planet number, and a number of ships. A
  // few things to keep in mind:
  // * you can issue many orders per turn if you like.
  // * the planets are numbered starting at zero, not one.
  // * you must own the source planet. If you break this rule, the game
  // engine kicks your bot out of the game instantly.
  // * you can't move more ships than are currently on the source planet.
  // * the ships will take a few turns to reach their destination. Travel
  // is not instant. See the Distance() function for more info.
  public void issueOrder(int sourcePlanet, int destinationPlanet, int 
  numShips) {
      System.out.println("" + sourcePlanet + " " + destinationPlanet + " "
              + numShips);
      System.out.flush();
  }
  
  // Sends an order to the game engine. An order is composed of a source
  // planet number, a destination planet number, and a number of ships. A
  // few things to keep in mind:
  // * you can issue many orders per turn if you like.
  // * the planets are numbered starting at zero, not one.
  // * you must own the source planet. If you break this rule, the game
  // engine kicks your bot out of the game instantly.
  // * you can't move more ships than are currently on the source planet.
  // * the ships will take a few turns to reach their destination. Travel
  // is not instant. See the Distance() function for more info.
  public void issueOrder(Planet source, Planet dest, int numShips) {
      System.out.println("" + source.planetID() + " " + dest.planetID() + " "
              + numShips);
      System.out.flush();
  }
  
  // Sends the game engine a message to let it know that we're done sending
  // orders. This signifies the end of our turn.
  public void finishTurn() {
      System.out.println("go");
      System.out.flush();
  }
  
  // Returns true if the named player owns at least one planet or fleet.
  // Otherwise, the player is deemed to be dead and false is returned.
  public boolean isAlive(int playerID) {
      for (Planet p : planets) {
          if (p.owner() == playerID) {
              return true;
          }
      }
      for (Fleet f : fleets) {
          if (f.owner() == playerID) {
              return true;
          }
      }
      return false;
  }
  
  // If the game is not yet over (ie: at least two players have planets or
  // fleets remaining), returns -1. If the game is over (ie: only one player
  // is left) then that player's number is returned. If there are no
  // remaining players, then the game is a draw and 0 is returned.
  public int winner() {
      Set&lt;Integer&gt; remainingPlayers = new TreeSet&lt;Integer&gt;();
      for (Planet p : planets) {
          remainingPlayers.add(p.owner());
      }
      for (Fleet f : fleets) {
          remainingPlayers.add(f.owner());
      }
      switch (remainingPlayers.size()) {
      case 0:
          return 0;
      case 1:
          return ((Integer) remainingPlayers.toArray()[0]).intValue();
      default:
          return -1;
      }
  }
  
  // Returns the number of ships that the current player has, either located
  // on planets or in flight.
  public int numShips(int playerID) {
      int numShips = 0;
      for (Planet p : planets) {
          if (p.owner() == playerID) {
              numShips += p.numShips();
          }
      }
      for (Fleet f : fleets) {
          if (f.owner() == playerID) {
              numShips += f.numShips();
          }
      }
      return numShips;
  }
  
  // Returns the production of the given player.
  public int production(int playerID) {
      int prod = 0;
      for (Planet p : planets) {
          if (p.owner() == playerID) {
              prod += p.growthRate();
          }
      }
      return prod;
  }
  
  // Parses a game state from a string. On success, returns 1. On failure,
  // returns 0.
  private int parseGameState(String s) {
      planets.clear();
      fleets.clear();
      int planetID = 0;
      String[] lines = s.split("\n");
      for (int i = 0; i &lt; lines.length; ++i) {
          String line = lines[i];
          int commentBegin = line.indexOf('#');
          if (commentBegin &gt;= 0) {
              line = line.substring(0, commentBegin);
          }
          if (line.trim().length() == 0) {
              continue;
          }
          String[] tokens = line.split(" ");
          if (tokens.length == 0) {
              continue;
          }
          if (tokens[0].equals("P")) {
              if (tokens.length != 6) {
                  return 0;
              }
              double x = Double.parseDouble(tokens[1]);
              double y = Double.parseDouble(tokens[2]);
              int owner = Integer.parseInt(tokens[3]);
              int numShips = Integer.parseInt(tokens[4]);
              int growthRate = Integer.parseInt(tokens[5]);
              Planet p = new Planet(planetID++, owner, numShips, growthRate,
                      x, y);
              planets.add(p);
          } else if (tokens[0].equals("F")) {
              if (tokens.length != 7) {
                  return 0;
              }
              int owner = Integer.parseInt(tokens[1]);
              int numShips = Integer.parseInt(tokens[2]);
              int source = Integer.parseInt(tokens[3]);
              int destination = Integer.parseInt(tokens[4]);
              int totalTripLength = Integer.parseInt(tokens[5]);
              int turnsRemaining = Integer.parseInt(tokens[6]);
              Fleet f = new Fleet(owner, numShips, source, destination,
                      totalTripLength, turnsRemaining);
              fleets.add(f);
          } else {
              return 0;
          }
      }
      return 1;
  }
  
  // Store all the planets and fleets. OMG we wouldn't wanna lose all the
  // planets and fleets, would we!?
  private ArrayList&lt;Planet&gt; planets;
  private ArrayList&lt;Fleet&gt; fleets;
  }
  
  package shared;
  public class Fleet implements Comparable&lt;Fleet&gt;, Cloneable {
  
  private int owner;
  private int numShips;
  private int sourcePlanet;
  private int destinationPlanet;
  private int totalTripLength;
  private int turnsRemaining;
  
  public Fleet(int owner, int numShips, int sourcePlanet,
          int destinationPlanet, int totalTripLength, int turnsRemaining) {
      this.owner = owner;
      this.numShips = numShips;
      this.sourcePlanet = sourcePlanet;
      this.destinationPlanet = destinationPlanet;
      this.totalTripLength = totalTripLength;
      this.turnsRemaining = turnsRemaining;
  }
  
  public Fleet(int owner, int numShips) {
      this.owner = owner;
      this.numShips = numShips;
      this.sourcePlanet = -1;
      this.destinationPlanet = -1;
      this.totalTripLength = -1;
      this.turnsRemaining = -1;
  }
  
  public int owner() {
      return owner;
  }
  
  public int numShips() {
      return numShips;
  }
  
  public int sourcePlanet() {
      return sourcePlanet;
  }
  
  public int destinationPlanet() {
      return destinationPlanet;
  }
  
  public int totalTripLength() {
      return totalTripLength;
  }
  
  public int turnsRemaining() {
      return turnsRemaining;
  }
  
  public void removeShips(int amount) {
      numShips -= amount;
  }
  
  // Subtracts one turn remaining. Call this function to make the fleet get
  // one turn closer to its destination.
  public void TimeStep() {
      if (turnsRemaining &gt; 0) {
          --turnsRemaining;
      } else {
          turnsRemaining = 0;
      }
  }
  
  @Override
  public int compareTo(Fleet f) {
      return this.numShips - f.numShips;
  }
  
  private Fleet(Fleet _f) {
      owner = _f.owner;
      numShips = _f.numShips;
      sourcePlanet = _f.sourcePlanet;
      destinationPlanet = _f.destinationPlanet;
      totalTripLength = _f.totalTripLength;
      turnsRemaining = _f.turnsRemaining;
  }
  
  public Object clone() {
      return new Fleet(this);
  }
  }
  </code></pre>