#67 AI now stops colonization mission if planet is already colonized.

Fleet moves to closes planet owned by the player.

src/main/java/org/openRealmOfStars/AI/Mission/MissionHandling.java

@@ -187,6 +187,49 @@ public static void handleColonize(final Mission mission, final Fleet fleet,
           stat.setNumberOfInUse(stat.getNumberOfInUse() - 1);
         }
 
+      } else if (mission.getPhase() == MissionPhase.TREKKING
+          && fleet.getRoute() == null) {
+        Coordinate coord = new Coordinate(mission.getX(), mission.getY());
+        if (info.getSectorVisibility(coord) == PlayerInfo.VISIBLE) {
+          Planet planet = game.getStarMap().getPlanetByCoordinate(coord.getX(),
+              coord.getY());
+          if (planet.getPlanetOwnerIndex() != -1) {
+            // Planet has been colonized so no longer colonization mission.
+            Planet homePort = game.getStarMap().getClosestHomePort(info,
+                fleet.getCoordinate());
+            mission.setTarget(homePort.getCoordinate());
+            mission.setTargetPlanet(homePort.getName());
+            mission.setMissionTime(0);
+            mission.setPhase(MissionPhase.PLANNING);
+            mission.setType(MissionType.MOVE);
+          }
+        }
+        makeReroute(game, fleet, info, mission);
+      }
+    } // End of colonize
+
+  }
+
+  /**
+   * Handle Colonize mission
+   * @param mission Colonize mission, does nothing if type is wrong
+   * @param fleet Fleet on mission
+   * @param info PlayerInfo
+   * @param game Game for getting star map and planet
+   */
+  public static void handleMove(final Mission mission, final Fleet fleet,
+      final PlayerInfo info, final Game game) {
+    if (mission != null && mission.getType() == MissionType.MOVE) {
+      if (mission.getPhase() != MissionPhase.TREKKING) {
+        Route route = new Route(fleet.getX(), fleet.getY(), mission.getX(),
+            mission.getY(), fleet.getFleetFtlSpeed());
+        fleet.setRoute(route);
+        mission.setPhase(MissionPhase.TREKKING);
+      }
+      if (mission.getPhase() == MissionPhase.TREKKING
+          && fleet.getX() == mission.getX() && fleet.getY() == mission.getY()) {
+        // Target acquired, mission complete
+        info.getMissions().remove(mission);
       } else if (mission.getPhase() == MissionPhase.TREKKING
           && fleet.getRoute() == null) {
         makeReroute(game, fleet, info, mission);

src/main/java/org/openRealmOfStars/AI/Mission/MissionType.java

@@ -41,7 +41,11 @@ public enum MissionType {
   /**
    * Attack the planet
    */
-  ATTACK;
+  ATTACK,
+  /**
+   * Move to target, simple mission just moving the fleet
+   */
+  MOVE;
 
   /**
    * Get Mission type with index
@@ -57,6 +61,8 @@ public int getIndex() {
       return 2;
     case ATTACK:
       return 3;
+    case MOVE:
+      return 4;
     default:
       return 0;
     }
@@ -73,6 +79,8 @@ public String toString() {
       return "Defend";
     case ATTACK:
       return "Attack";
+    case MOVE:
+      return "Move";
     default:
       return "Unknown";
     }

src/main/java/org/openRealmOfStars/starMap/StarMap.java

@@ -1015,6 +1015,27 @@ public void setPlanetList(final ArrayList<Planet> list) {
     planetList = list;
   }
 
+  /**
+   * Get the closest home port for player
+   * @param info Player who is looking for closest home planet
+   * @param currentPos Current position in starmap
+   * @return Closest planet or null if no planet found
+   */
+  public Planet getClosestHomePort(final PlayerInfo info,
+      final Coordinate currentPos) {
+    double distance = 9999.0;
+    Planet result = null;
+    for (Planet planet : planetList) {
+      if (planet.getPlanetPlayerInfo() == info) {
+        double dist = currentPos.calculateDistance(planet.getCoordinate());
+        if (dist < distance) {
+          distance = dist;
+          result = planet;
+        }
+      }
+    }
+    return result;
+  }
   /**
    * Get Fleet by fleetTile
    * @param fleetTile to get the fleet

src/test/java/org/openRealmOfStars/starMap/StarMapTest.java

@@ -230,6 +230,81 @@ public void testStarMapBrowsingThePlayerPlanets() {
     assertEquals(true, map.isWarBetween(info, info2));
   }
 
+  @Test
+  @Category(org.openRealmOfStars.UnitTest.class)
+  public void testStarMapClosestHomeWorld() {
+    GalaxyConfig config = Mockito.mock(GalaxyConfig.class);
+    Mockito.when(config.getSizeX()).thenReturn(75);
+    Mockito.when(config.getSizeY()).thenReturn(75);
+    Mockito.when(config.getMaxPlayers()).thenReturn(2);
+    Mockito.when(config.getStartingPosition()).thenReturn(
+        GalaxyConfig.START_POSITION_RANDOM);
+
+    PlayerInfo info = Mockito.mock(PlayerInfo.class);
+    Mockito.when(info.getRace()).thenReturn(SpaceRace.HUMAN);
+    Mockito.when(info.getEmpireName()).thenReturn("Empire of Human");
+    MessageList msgList = Mockito.mock(MessageList.class);
+    Mockito.when(info.getMsgList()).thenReturn(msgList);
+    ShipStat[] stats = new ShipStat[0];
+    Mockito.when(info.getShipStatList()).thenReturn(stats);
+    Diplomacy diplomacy = Mockito.mock(Diplomacy.class);
+    DiplomacyBonusList diplomacyList = Mockito.mock(DiplomacyBonusList.class);
+    Mockito.when(diplomacyList.isBonusType(DiplomacyBonusType.IN_WAR))
+        .thenReturn(false);
+    Mockito.when(diplomacy.getDiplomacyList(Mockito.anyInt())).thenReturn(diplomacyList);
+    Mockito.when(info.getDiplomacy()).thenReturn(diplomacy);
+
+    PlayerInfo info2 = Mockito.mock(PlayerInfo.class);
+    Mockito.when(info2.getRace()).thenReturn(SpaceRace.SPORKS);
+    Mockito.when(info2.getEmpireName()).thenReturn("Empire of Sporks");
+    msgList = Mockito.mock(MessageList.class);
+    Mockito.when(info2.getMsgList()).thenReturn(msgList);
+    stats = new ShipStat[0];
+    Mockito.when(info2.getShipStatList()).thenReturn(stats);
+
+    PlayerList players = Mockito.mock(PlayerList.class);
+    Mockito.when(players.getPlayerInfoByIndex(0)).thenReturn(info);
+    Mockito.when(players.getPlayerInfoByIndex(1)).thenReturn(info2);
+    Mockito.when(players.getCurrentMaxPlayers()).thenReturn(2);
+
+    Planet planet1 = Mockito.mock(Planet.class);
+    Mockito.when(planet1.getX()).thenReturn(5);
+    Mockito.when(planet1.getY()).thenReturn(7);
+    Mockito.when(planet1.getPlanetPlayerInfo()).thenReturn(info);
+    Planet planet2 = Mockito.mock(Planet.class);
+    Mockito.when(planet2.getX()).thenReturn(15);
+    Mockito.when(planet2.getY()).thenReturn(17);
+    Mockito.when(planet2.getPlanetPlayerInfo()).thenReturn(info);
+    Planet planet3 = Mockito.mock(Planet.class);
+    Mockito.when(planet3.getX()).thenReturn(25);
+    Mockito.when(planet3.getY()).thenReturn(27);
+    Mockito.when(planet3.getPlanetPlayerInfo()).thenReturn(info2);
+    Planet planet4 = Mockito.mock(Planet.class);
+    Mockito.when(planet4.getX()).thenReturn(35);
+    Mockito.when(planet4.getY()).thenReturn(37);
+    Mockito.when(planet4.getPlanetPlayerInfo()).thenReturn(info2);
+    Planet planetUnhabitated = Mockito.mock(Planet.class);
+    Mockito.when(planetUnhabitated.getX()).thenReturn(45);
+    Mockito.when(planetUnhabitated.getY()).thenReturn(47);
+    Mockito.when(planetUnhabitated.getPlanetPlayerInfo()).thenReturn(null);
+    ArrayList<Planet> list = new ArrayList<>();
+    list.add(planetUnhabitated);
+    list.add(planet1);
+    list.add(planet3);
+    list.add(planetUnhabitated);
+    list.add(planetUnhabitated);
+    list.add(planet4);
+    list.add(planetUnhabitated);
+    list.add(planet2);
+    list.add(planetUnhabitated);
+    list.add(planetUnhabitated);
+    StarMap map = new StarMap(config, players);
+    map.setPlanetList(list);
+    Coordinate coord = Mockito.mock(Coordinate.class);
+    Mockito.when(coord.calculateDistance(Mockito.any(Coordinate.class))).thenReturn(3.2);
+    assertEquals(planet1, map.getClosestHomePort(info, coord));
+  }
+
   @Test
   @Category(org.openRealmOfStars.UnitTest.class)
   public void testStarMapCreateWithMilitaryCompare() {