/** * Travel between two locations, where neither is a city. * @param vessel travelling between two locations at sea * @param location destination location */ public void travelNotBetweenCities(INavigableVessel vessel, Point2D location) { List<Point2D> path = travelTo(vessel, location); Preconditions.checkNotNull(path); pathConverter.createPath(vessel, path, 1); VesselPositionUpdateData vesselPositionUpdateData = interpolators.get(vessel); vesselPositionUpdateData.setDestinationCity(false); vesselPositionUpdateData.setSourceCity(false); }
@Override public void run() { seafaringService.travelBetweenCities(vessel, destinationCity); } };
/** * Send a vessel to be repaired. * @param vessel to be repaired */ private void sendForRepairs(INavigableVessel vessel) { vessel.togglePirateFlag(); ICity city = cityService.findNearestCity(vessel.getLocation()); seafaringService.travelToCity(vessel, city); }
/** * Handle the event for the finished repair. * @param event repair has finished */ @Subscribe public void handleRepairFinished(RepairFinishedEvent event) { if (handlePirateShip(event.getShip())) { INavigableVessel vessel = event.getShip(); Point2D destination = mapService.getRandomPointAtSeaNear(vessel.getLocation()); seafaringService.travelFromCity(vessel, destination); vessel.togglePirateFlag(); } }
} /** * Select a new destination for the pirate. * @param pirate free sea pirate */ private void selectDestination(ISeaPirate pirate) { Point2D destination; if (pirate instanceof INonFreeSeaPirate && ((INonFreeSeaPirate) pirate).roamingNearCity().isPresent()) { ICity city = ((INonFreeSeaPirate) pirate).roamingNearCity().get(); destination = mapService.getRandomPointAtSeaNear(city.getCoordinates()); } else { destination = mapService.getLocationAtOtherEndOfMap(pirate.getShip().getLocation()); } // make sure that the source of the pirate location is in the graph Point2D adjustedDestination = aStarHeuristicProvider.findClosest(destination); aStarHeuristicProvider.addTargetNodeToHeuristic(adjustedDestination); logger.debug("Source point of pirate is {}", pirate.getShip().getLocation()); seafaringService.travelNotBetweenCities(pirate.getShip(), adjustedDestination); }
/** * Travel from a city to a place that is not a city. * @param vessel traveling from a city to a location at sea * @param location destination location */ public void travelFromCity(INavigableVessel vessel, Point2D location) { List<Point2D> path = travelTo(vessel, location); Preconditions.checkNotNull(path); pathConverter.createPath(vessel, path, 1); VesselPositionUpdateData vesselPositionUpdateData = interpolators.get(vessel); vesselPositionUpdateData.setDestinationCity(false); vesselPositionUpdateData.setSourceCity(true); } }
@Override public boolean execute() { Preconditions.checkNotNull(vessel, "Vessel assigned to trade step must not be null"); Preconditions.checkNotNull(destinationCity, "The destination city must not be null"); if (vessel instanceof IConvoy) { IConvoy convoy = (IConvoy) vessel; if (convoy.isPublicConvoy()) { // TimedTask definition here is ok, as HireSailorStep is serialized. TimedTask task = new TimedTask() { { setExecutionTime(date.getCurrentDate().plusDays(5)); } @Override public void run() { seafaringService.travelBetweenCities(vessel, destinationCity); } }; taskList.add(task); } else { seafaringService.travelBetweenCities(vessel, destinationCity); } } else { seafaringService.travelBetweenCities(vessel, destinationCity); } LOGGER.debug("Ship {} travels from {} to {}", vessel.getName(), vessel.getLocation(), destinationCity.getCoordinates()); return false; }
@Override public void initializeTradeCycle(IAIPlayer player, INavigableVessel vessel) { CollectWaresMissionData missionData = createMissionData(player); player.setTradeMission(vessel, missionData); // Assume the ship is not in a port => redirect List<IWare> requiredWares = new ArrayList<>(missionData.getRequiredWareAmounts().keySet()); Optional<ICity> currentCity = shipService.findCity(vessel); HashSet<ICity> excludeCities = new HashSet<>(); currentCity.ifPresent(excludeCities::add); ICity firstStop = findDestinationToBuyRequiredProductionWares(player, requiredWares, vessel, excludeCities); IAITradeStrategyType strategyType = getStrategyType(); player.setTradeStrategyType(vessel, strategyType); logger.debug("Reroute vessel "+vessel.getName()+" to "+firstStop.getName()+" current location: "+vessel.getLocation()); if (player.hasMoreTradeSteps(vessel)) { logger.debug("There are tradesteps for vessel "+vessel.getName()+" that may cause problems"); } seafaringService.travelToCity(vessel, firstStop); }
@Subscribe public void handleBlockadeStart(BlockadeShipRequestEvent event) { IAIPlayer player = event.getPlayer(); int requiredShips = event.getNumberOfShips(); for (int i = 0; i < requiredShips; i++) { Optional<IShip> optShip = blockadeStrategy.selectShip(player); if (optShip.isPresent()) { IShip vessel = optShip.get(); player.setTradeMission(vessel, new IBlockadeMission() {}); seafaringService.travelTo(vessel, event.getAssemblyCity().getCoordinates()); } else { break; } } } @Subscribe
createConvoy(blockade, aldermanCity); IConvoy convoy = blockade.getBlockadeConvoy(); seafaringService.travelBetweenCities(convoy, blockadeCity); } else { blockadeState.finishBlockade(blockadeCity); seafaringService.travelBetweenCities(blockade.getBlockadeConvoy(), returnTo);
private void startTradeStrategySteps(IAIPlayer player, INavigableVessel ship) { IAITradeStrategy tradeStrategy = player.getTradeStrategyType(ship).getStrategy(); // If the vessel is traveling do not execute if (!player.hasMoreTradeSteps(ship)) { if (shipService.findCity(ship).isPresent()) { tradeStrategy.initializeTradeCycle(player, ship); logger.info("No more tradesteps for vessel {} of {} {} defined, but located in city: Reinitialize trade strategy", ship.getName(), player.getName(), player.getLastName()); } else { if (!vessels.isTravelling(ship)) { // already traveling to destination ICity nearestCity = tradeStrategy.getCityToRestartTradeCycle(ship); seafaringService.travelToCity(ship, nearestCity); logger.warn("No tradesteps defined for vessel {} of {} {}. Travel to nearest city {}", ship.getName(), player.getName(), player.getLastName(), nearestCity.getName()); } } } if (!player.waitingForTradeStepToFinish(ship)) { tradeStrategy.executeTradeSteps(player, ship); } else { logger.warn("Skip starting of trade execution as waitingForTradeStepToFinish for {} of {} {} is {}", ship.getName(), player.getName(), player.getLastName(), player.waitingForTradeStepToFinish(ship)); } }
/** * Travel from one city to another. * @param vessel which travels between cities * @param toCity destination city */ public void travelBetweenCities(INavigableVessel vessel, ICity toCity) { List<Point2D> path = travelTo(vessel, toCity.getCoordinates()); Preconditions.checkNotNull(path); pathConverter.createPath(vessel, path, 1); VesselPositionUpdateData vesselPositionUpdateData = interpolators.get(vessel); vesselPositionUpdateData.setDestinationCity(true); vesselPositionUpdateData.setSourceCity(true); }
/** * Travel from a location that is not a city to a city. * @param vessel traveling to a city * @param toCity destination city */ public void travelToCity(INavigableVessel vessel, ICity toCity) { List<Point2D> path = travelTo(vessel, toCity.getCoordinates()); Preconditions.checkNotNull(path); pathConverter.createPath(vessel, path, 1); VesselPositionUpdateData vesselPositionUpdateData = interpolators.get(vessel); vesselPositionUpdateData.setDestinationCity(true); vesselPositionUpdateData.setSourceCity(false); }
List<Point2D> path = new ArrayList<>(); if (destinationCity.isPresent()) { path = seafaringService.travelTo(vessel, destinationCity.get().getCoordinates()); } else { final Point2D destination = new Point2D(unscaledX, unscaledY); if (aStarGraphService.isOnSea(destination)) { path = seafaringService.travelTo(vessel, destination);