/** * Draw a vessel on the map with default orientation (faceing to the west) * @param vessel to draw on the map */ private void drawShipOnMap(INavigableVessel vessel) { List<Point2D> path = vessels.getTravellingVessel(vessel).getCalculatablePath(); addNewShipIconToCanvas(vessel, path); }
@Subscribe public void handleShipReachesDestination(ShipArrivesAtDestinationEvent event) { INavigableVessel vessel = event.getShip(); vessels.remove(vessel); } }
/** * Retrieve all cities provided by {@link IMap}, that are * currently not under a blockade. * @return list of all non blockaded cities. */ public List<ICity> getAllNonBlockedCities() { List<ICity> cities = new ArrayList<>(map.getCities()); for (Entry<ICity, IBlockade> entry : blockade.entrySet()) { cities.remove(entry.getKey()); } return cities; } }
for (Entry<ICity, IBlockade> blockadeEntry : blockadeState.entrySet()) { IBlockade blockade = blockadeEntry.getValue(); ICity blockadeCity = blockadeEntry.getKey(); if (blockade.getAssemblyDate().isBefore(now) && blockade.getBlockadeConvoy() == null) { List<IPlayer> players = blockade.getPlayersWithRequestedShips(); for (IPlayer player : players) { ArrayList<IShip> ships = new ArrayList<>(); int requestedNumber = blockade.getNumberOfRequestedShips(player); for (IShip ship : player.getFleet()) { if (ship.getLocation().equals(aldermanCity.getCoordinates())) { blockade.addShips(player, ships); if (blockade.getShips().size() > 0) { createConvoy(blockade, aldermanCity); IConvoy convoy = blockade.getBlockadeConvoy(); seafaringService.travelBetweenCities(convoy, blockadeCity); } else { blockadeState.finishBlockade(blockadeCity); if (blockade.getEndBlockade().isBefore(now) && blockade.getBlockadeConvoy() != null && blockade.getBlockadeConvoy().getLocation().equals(blockadeCity.getCoordinates())) { ICity returnTo = mapService.getAldermanCity(); seafaringService.travelBetweenCities(blockade.getBlockadeConvoy(), returnTo);
@Subscribe public void handleBlockadeConvoyReturns(ShipEntersPortEvent event) { // disolve the convoy and remove blockade from blockade state INavigableVessel vessel = event.getShip(); if (vessel instanceof IConvoy) { LocalDateTime now = date.getCurrentDate(); ICity aldermanCity = mapService.getAldermanCity(); for (Entry<ICity, IBlockade> blockadeEntry : blockadeState.entrySet()) { IBlockade blockade = blockadeEntry.getValue(); if (blockade.getEndBlockade().isBefore(now)) { IConvoy convoy = blockade.getBlockadeConvoy(); if (convoy.equals(vessel) && event.getCity().equals(aldermanCity)) { final ICity blockadedCity = blockadeEntry.getKey(); dissolveConvoy(blockade, aldermanCity, blockadedCity); blockadeState.finishBlockade(blockadedCity); IGuild guild = guildList.findGuild(aldermanCity).get(); for (IShip ship : blockade.getShipsToAuction()) { LocalDateTime auctionDate = now.plusDays(10); auctionDate = guildService.cleanUpAuctionAndDetermineAuctionDate(auctionDate, guild); IShipAuction auction = modelFactory.createAnonymousShipAuction(auctionDate, ship.getValue(), ship); guild.getAuctions().add(auction); } return; } } } } }
@Subscribe public void handleShipBreaksBlockade(ShipNearingPortEvent event) { ICity city = event.getCity(); for (Entry<ICity, IBlockade> entry : blockadeState.entrySet()) { if (entry.getKey().equals(city)) { IConvoy blocadingConvoy = entry.getValue().getBlockadeConvoy(); INavigableVessel blockadeBreaker = event.getShip(); BlockadeSeafightContext context = new BlockadeSeafightContext(entry.getValue()); IPlayer owner = (IPlayer) blockadeBreaker.getOwner(); owner.updateCrimialDrive(1); seafightService.calculateOutcome(blocadingConvoy, blockadeBreaker, context); entry.getValue().getShipsToAuction().addAll(context.getCapturedShips()); } } } @Subscribe
private void handleBlockadeMission(INavigableVessel vessel, IAIPlayer player, ICity city) { LocalDateTime now = date.getCurrentDate(); ICity aldermanCity = mapService.getAldermanCity(); if (city.equals(aldermanCity)) { if (blockadeState.entrySet().isEmpty()) { initializeStrategyForVessel(player, vessel); } else { for (Entry<ICity, IBlockade> entry : blockadeState.entrySet()) { IBlockade blockade = entry.getValue(); if (blockade.getAssemblyDate().isBefore(now)) { // Missed assemby date initializeStrategyForVessel(player, vessel); } } } } else { initializeStrategyForVessel(player, vessel); } }
@Subscribe public void handleShipReachesDestination(ShipArrivesAtDestinationEvent event) { INavigableVessel vessel = event.getShip(); TravellingVessel ship = vessels.getTravellingVessel(vessel); final Path drawablePath = ship.getDrwawablePath(); if (drawablePath != null) { Platform.runLater(() -> shipCanvas.getChildren().remove(drawablePath)); } } @Subscribe
void createConvoy(IBlockade blockade, ICity city) { List<IShip> allShips = blockade.getShips(); IConvoy convoy = shipFactory.getConvoy(allShips.get(0), false); for (int i = 1; i < allShips.size(); i++) { IShip ship = allShips.get(i); convoy.addShip(ship); ship.parentShipProperty().setValue(convoy.getOrlegShip()); } for (IShip ship : allShips) { ship.setAvailable(false); IPlayer owner = (IPlayer) ship.getOwner(); if (owner instanceof IHumanPlayer) { clientServerEventBus.post(new TargetedEvent((IHumanPlayer) owner, new ShipBecomesUnavailableEvent(ship, city))); } owner.removeSelectableVessel(ship); } blockade.setConvoy(convoy); } }
TravellingVessel traveling = vessels.getTravellingVessel(vessel); if (isVesselVisible(vessel)) { removeVesselFromView(vessel); drawShipOnMap(traveling.getVessel());
public void initializeNewBlockade(ICity city) { LocalDateTime assemblyDate = date.getCurrentDate().plusDays(21); int variance = rnd.nextInt(120) - 60; LocalDateTime endBlockage = assemblyDate.plusDays(120 + variance); Blockade blockade = (Blockade) context.getBean("blockade", assemblyDate, endBlockage); ICity assemblyPoint = mapService.getAldermanCity(); boolean anyShipRequested = false; for (IPlayer player : players) { int fleetSize = player.getFleet().size(); int nbShips = Math.min(fleetSize/10, 3); if (nbShips > 0) { anyShipRequested = true; blockade.requestShip(player, nbShips); if (player instanceof IHumanPlayer) { String dateAsString = modelTranslationService.toDisplayString(assemblyDate); DisplayMessage msg = new DisplayMessage("ch.sahits.game.openpatrician.engine.sea.BlockadeEngine.blockadeRequest", new Object[]{city.getName(), nbShips, dateAsString, assemblyPoint.getName()}); TargetedEvent targetMsg = new TargetedEvent((IHumanPlayer) player, msg); clientServerEventBus.post(targetMsg); } else { BlockadeShipRequestEvent event = new BlockadeShipRequestEvent(assemblyPoint, nbShips, (IAIPlayer) player); clientServerEventBus.post(event); // this could also be sent on the serverside only } } } if (anyShipRequested) { blockadeState.addBlockade(city, blockade); } }
@Subscribe public void handleShipNearsPort(ShipNearingPortEvent event) { INavigableVessel vessel = event.getShip(); TravellingVessel ship = vessels.getTravellingVessel(vessel); if (ship != null) { if (vessels.getTravellingVessel(vessel) != null) { threadExecution.execute(() -> removeVesselFromView(vessel)); if (isPlayersVessel(vessel)) { Set<INavigableVessel> noLongerVisible = removeVisibleVessel(vessel); for (INavigableVessel v : noLongerVisible) { logger.debug("The ship {} is no longer visible", v.getName()); } Platform.runLater(() -> removeNoLongerVisibleVessels(noLongerVisible)); } } } else { logger.debug("Ship ship nearing port for {} as ship is not a traveling vessel", vessel.getName()); } }
/** * Create a path shape out of a list of points. * When the path is created the vessel will be added to the * TravellingVessels container. * @param vessel vessel that is traveling the path. * @param pointedPath input points. * @param scale scaling that is used on the path due to the sacle of the map. * @return shape representing a path. */ public Optional<Path> createPath(INavigableVessel vessel, List<Point2D> pointedPath, double scale) { Path path = new Path(); path.setStroke(Color.RED); path.setStrokeWidth(2); if (!pointedPath.isEmpty()) { Point2D p = pointedPath.get(0); MoveTo moveTo = new MoveTo(); moveTo.setX(p.getX() * scale); moveTo.setY(p.getY() * scale); path.getElements().add(moveTo); for (int i = 1; i < pointedPath.size(); i++) { p = pointedPath.get(i); LineTo lineTo = new LineTo(); lineTo.setX(p.getX() * scale); lineTo.setY(p.getY() * scale); path.getElements().add(lineTo); } } vessels.addVessel(vessel, Optional.ofNullable(path), pointedPath); return Optional.ofNullable(path); }
/** * Check if the vessel is engaged in trading. That means it is either traveling, trading or repairing. * @param vessel to check if it is engaiged in trading. * @return true if the vessel can execute trade steps. */ public boolean isEngagedInTrading(INavigableVessel vessel) { // Is travelling (Check TravelingVessels) if (vessels.isTravelling(vessel)) { return true; } // Is repairing (check shipyards) for (ICity city : map.getCities()) { IShipyard shipyard = city.getCityState().getShipyardState(); List<IShipDueDate> repairlist = shipyard.getShipRepairList(); for (IShipDueDate dueDate : repairlist) { if (dueDate.getShip().equals(vessel)) { return true; } } } if (vessel.getNumberOfSailors() < shipService.getMinNumberOfSailors(vessel)) { return true; // needs more sailors } // is trading the AIEngine is currently executing tasks return playerEngine.executeCurrentTrade(vessel); }
private void updateCapturedShipInternal(List<IShip> capturedDefendingShips, List<IShip> capturedAttackingShips, boolean attackShipTurn, IShip shipWithMaxSailors, IShip captureShip, SeaFightContext context) { final int numberOfSailors = captureShip.getNumberOfSailors(); int halfTheSailors = numberOfSailors /2; captureShip.setNumberOfSailors(numberOfSailors - halfTheSailors); IShipOwner previousOwner = shipWithMaxSailors.getOwner(); removeFromFleet(shipWithMaxSailors, previousOwner); shipWithMaxSailors.setNumberOfSailors(halfTheSailors); shipWithMaxSailors.setOwner(captureShip.getOwner()); if (context.getType() == ESeaFightType.BLOCKADE && attackShipTurn) { IBlockade blockade = ((BlockadeSeafightContext)context).getBlockade(); blockade.getShipsToAuction().add(captureShip); } else { addToFleet(shipWithMaxSailors, captureShip.getOwner()); } if (attackShipTurn) { // shipWithMaxSailors belongs to attacking fleet capturedAttackingShips.add(shipWithMaxSailors); } else { capturedDefendingShips.add(shipWithMaxSailors); } }
void dissolveConvoy(IBlockade blockade, ICity city, ICity blockadedCity) { IConvoy convoy = blockade.getBlockadeConvoy(); for (IShip ship : convoy.getShips()) { ship.setAvailable(true); IShipOwner owner = ship.getOwner(); convoy.removeShip(ship); ship.parentShipProperty().setValue(null); if (owner instanceof IHumanPlayer) { DisplayMessage msg = new DisplayMessage("ch.sahits.game.openpatrician.engine.sea.BlockadeEngine.blockadesissolve", new Object[]{blockadedCity.getName(), ship.getName(), city.getName()}); TargetedEvent targetMsg = new TargetedEvent((IHumanPlayer) owner, msg); clientServerEventBus.post(targetMsg); } if (owner instanceof IPlayer) { IPlayer player = (IPlayer) owner; player.addSelectableVessel(ship); } clientServerEventBus.post(new ShipEntersPortEvent(ship, city)); } }
vessels.remove(vessel); if (owner instanceof IAIPlayer) { IAIPlayer player = (IAIPlayer) owner;
@Subscribe public void handleShipPositionUpdate(ShipPositionUpdateEvent event) { INavigableVessel vessel = event.getShip(); TravellingVessel ship = vessels.getTravellingVessel(vessel); if (vessel.getOwner().equals(viewState.getPlayer())) { Preconditions.checkNotNull(ship, "The travelling vessel instance for " + vessel.getName() + " of " + vessel.getOwner().getName() + " " + vessel.getOwner().getLastName() + " could not be found"); } if (ship != null) { threadExecution.execute(() -> { if (ship != null) { // The ship is traveling ShipIcon view = findShipIcon(vessel); if (view != null) { // The ship is visible view.updatePosition(); } else { logger.trace("Failed to find vessel with uuid {}", vessel.getUuid()); } } handleVisibilityShips(vessel); }); } else { logger.debug("Ship ship update for {} as ship is not a traveling vessel", vessel.getName()); } }
vessels.addVessel(vessel, optPath, reducedList); final PathInterpolator pathInterpolator = new PathInterpolator(reducedList); long duration = calculateDuration(vessel, pathInterpolator, 1);
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)); } }