public boolean arrival() { List<Fleet> fleets = new ArrayList<>(); boolean arrival = false; if (Fleets().size() == 0) { return true; } for (Fleet fleet : Fleets()) { if (fleet.TurnsRemaining() == 0) { arrival = true; fleets.add(fleet); } } fleets.forEach( fleet -> { Planet dest = GetPlanet(fleet.DestinationPlanet()); if (fleet.Owner() != dest.Owner()) { dest.NumShips(dest.NumShips() - fleet.NumShips()); if (dest.NumShips() < 0) { dest.Owner(fleet.Owner()); dest.NumShips(Math.abs(dest.NumShips())); } } else { dest.NumShips(dest.NumShips() + fleet.NumShips()); } }); return arrival; }
// Add each possible state in the currentNode.sons list. public void createSons() { // Tested SimulatedPlanetWars simpw = this.getSim(); for (Planet myPlanet : simpw.MyPlanets()) { // avoid planets with only one ship if (myPlanet.NumShips() <= 1) continue; // We create a son for each of the possible situations for (Planet notMyPlanet : simpw.NotMyPlanets()) { // Create simulation environment for this son SimulatedPlanetWars simpw2 = new SimulatedPlanetWars(simpw); int value = Helper.Dcalculation(myPlanet, notMyPlanet); simpw2.IssueOrder(myPlanet, notMyPlanet); simpw2.simulateGrowth(); simpw2.simulateFirstBotAttack(); simpw2.simulateGrowth(); MyNode son; if (this.isRoot()) { son = new MyNode(this, simpw2, value, myPlanet, notMyPlanet); } else { son = new MyNode( this, simpw2, value, this.getSource(), this.getDest()); // We only need to know from where to where we want to send our // ships to get the best turn } this.addSon(son); } } }
@SuppressWarnings("deprecation") @Command( value = "myplanet", desc = "Erzeugt einen Testplaneten", perm = "craftoplugin.galaxywar.generate", onlyplayers = true) public void generatePlanet(final CommandSender cs, final String command, final String[] args) { final Player p = (Player) cs; p.sendMessage("Aktiv!"); final int r = 6; PlanetType type = PlanetType.SUN; if (args.length > 0) { try { type = PlanetType.valueOf(args[0].toUpperCase()); } catch (final IllegalArgumentException e) { } } final World world = p.getWorld(); final Planet planet = new Planet(new Position(p.getLocation()), r, type); final ArrayList<MaterialBlockPoint> blocks = planet.getMaterialBlockPoints(); Block block; for (final MaterialBlockPoint b : blocks) { block = world.getBlockAt(b.getX(), b.getY(), b.getZ()); block.setType(b.getMaterial()); block.setData((byte) 0); } }
public boolean isPlaceEmpty(Vector2 pos, boolean considerPlanets) { Planet np = myPlanetManager.getNearestPlanet(pos); if (considerPlanets) { boolean inPlanet = np.getPos().dst(pos) < np.getFullHeight(); if (inPlanet) return false; } SolSystem ns = myPlanetManager.getNearestSystem(pos); if (ns.getPos().dst(pos) < SunSingleton.SUN_HOT_RAD) return false; List<SolObject> objs = myObjectManager.getObjs(); for (int i = 0, objsSize = objs.size(); i < objsSize; i++) { SolObject o = objs.get(i); if (!o.hasBody()) continue; if (pos.dst(o.getPos()) < myObjectManager.getRadius(o)) { return false; } } List<FarObjData> farObjs = myObjectManager.getFarObjs(); for (int i = 0, farObjsSize = farObjs.size(); i < farObjsSize; i++) { FarObjData fod = farObjs.get(i); FarObj o = fod.fo; if (!o.hasBody()) continue; if (pos.dst(o.getPos()) < o.getRadius()) { return false; } } return true; }
public static void main(String[] args) { Planet sun = new Planet(0, 0, 1.0e9, 0.5); Planet planet = new Planet(1, 0, 100.0, 0.1); Rechner rechner = new Rechner(); rechner.berechnen(sun.getCoords(), planet.getCoords(), sun.getMass()); }
// region Events public void onSave(File file, World world) { isDirty = false; for (Planet planet : getPlanets()) { planet.onSave(file, world); } }
public Universe next() { List<Fleet> futureFleets = new ArrayList<Fleet>(); List<Planet> newPlanets = new ArrayList<Planet>(); for (Planet planet : planets.items) { newPlanets.add(planet.grow()); } List<Fleet> arrivingFleets = new ArrayList<Fleet>(); for (Fleet fleet : fleets.items) { Fleet movedFleet = fleet.move(); if (movedFleet.turnsRemaining > 0) { futureFleets.add(movedFleet); } else { arrivingFleets.add(movedFleet); } } Fleets arriving = new Fleets(arrivingFleets); for (Fleet fleet : arrivingFleets) { Planet planet = new Planets(newPlanets).find(fleet.destinationPlanet); Fleets attacking = arriving.attacking(planet); if (attacking.enemyFleets().ships() != attacking.myFleets().ships()) { newPlanets.remove(planet); planet = planet.receive(fleet); newPlanets.add(planet); } } return new Universe(new Planets(newPlanets), new Fleets(futureFleets), turn + 1, reservations); }
public int predictShips(Planet planet, int turns) { if (NeutralPlanets().contains(planet)) { return planet.NumShips(); } else { return planet.NumShips() + planet.GrowthRate() * turns; } }
public boolean isClaimed() { for (Planet planet : getPlanets()) { if (planet.hasOwner()) { return true; } } return false; }
private static double calculateDistance(Planet first, Planet second) { double a = (first.getX() - second.getX()); double b = (first.getY() - second.getY()); double c = Math.pow(a, 2) + Math.pow(b, 2); // Pythagorean theorem, a² + b² = c² .. return Math.sqrt(c); }
// 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<Planet> NotMyPlanets() { List<Planet> r = new ArrayList<Planet>(); for (Planet p : planets) { if (p.Owner() != 1) { 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<Planet> EnemyPlanets() { List<Planet> r = new ArrayList<Planet>(); for (Planet p : planets) { if (p.Owner() >= 2) { r.add(p); } } return r; }
// 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; }
// Return a list of all neutral planets. public List<Planet> NeutralPlanets() { List<Planet> r = new ArrayList<Planet>(); for (Planet p : planets) { if (p.Owner() == 0) { r.add(p); } } return r; }
private void putPlanetImageToButton() { planetImageIcon = new ImageIcon(fileURL); planetImage = planetImageIcon.getImage().getScaledInstance(65, 65, java.awt.Image.SCALE_SMOOTH); imageButton[buttonIndex] = new JButton(planet.planetName().toUpperCase(), new ImageIcon(planetImage)); imageButton[buttonIndex].addActionListener( PlanetActionListener.planetInformation(planet.toString()) .andMultipleFramesContainer(multipleFramesContainer)); }
@Override public String toString() { return "{" + type + ": " + (from != null ? from.getId() : null) + " -> " + (to != null ? to.getId() : null) + "}"; }
/** @param args */ public static void main(String[] args) { if (args.length != 1) { System.err.println("Usage: java Planet <earth_weight>"); System.exit(-1); } double earthWeight = Double.parseDouble(args[0]); double mass = earthWeight / EARTH.surfaceGravity(); for (Planet p : Planet.values()) System.out.printf("Your weight on %s is %f%n", p, p.surfaceWeight(mass)); }
public float value_myself() { // int myships = this.NumShips(1); // int myplanets = this.NumPlanets(); int mygrowth = 0; float value; for (Planet planet : MyPlanets()) { mygrowth += planet.GrowthRate(); } value = (float) mygrowth; return value; }
public boolean isDirty() { if (isDirty) { return true; } else { for (Planet planet : getPlanets()) { if (planet.isDirty()) { return true; } } } return false; }
// ------------------------------------------------// // ------- Custom methods and/or properties: ------// // ------------------------------------------------// private PlanetWars(PlanetWars _pw) { this.planets = new ArrayList<>(); this.fleets = new ArrayList<>(); for (Planet planet : _pw.Planets()) { Planet lol = planet.clone(); this.planets.add(lol); } for (Fleet fleet : _pw.Fleets()) { fleets.add(fleet.clone()); } }
public Planet releasePlanet(int id) { for (int x = 0; x < planets.size(); x++) { if (planets.get(x).getID() == id) { Planet p = planets.get(x); income = income - p.getIncome(); p.setOwner(null); planets.remove(x); return p; } } return null; }
@Test public void testNumberOfHomePlanets() throws InvalidMoveException { Player player1 = new Player("Player 1", GameColor.BLACK); Assert.assertEquals(Player.DEFAULT_NUMBER_OF_PLANETS, player1.numberOfHomePlanets()); List<Planet> homePlanets = player1.getHomePlanets(); for (Planet planet : homePlanets) { planet.removeShips(player1); } Assert.assertEquals(0, player1.numberOfHomePlanets()); }
public void draw(SolGame game, GameDrawer drawer) { SolCam cam = game.getCam(); Vector2 camPos = cam.getPos(); Planet p = game.getPlanetMan().getNearestPlanet(); Vector2 pPos = p.getPos(); float toCamLen = camPos.dst(pPos); float vd = cam.getViewDist(); float gh = p.getMinGroundHeight(); if (toCamLen < gh + vd) { float sz = gh; drawer.draw(myTex, sz * 2, sz * 2, sz, sz, pPos.x, pPos.y, p.getAngle(), SolColor.W); } }
// 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; }
public void generateMissing(NBTTagCompound tagCompound, GalaxyGenerator galaxyGenerator) { if (galaxyGenerator != null) { for (ISpaceBodyGen<Star> starGen : galaxyGenerator.getStarGen().getGens()) { galaxyGenerator.getStarRandom().setSeed(seed); if (starGen.generateMissing(tagCompound, this, galaxyGenerator.getStarRandom())) { break; } } for (Planet planet : getPlanets()) { planet.generateMissing(tagCompound, galaxyGenerator); } } }
// 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; }
Universe haveEveryPlanetAttack(Planet mine, Planets planetsToAttack) { List<Planet> newPlanets = new ArrayList<Planet>(); List<Fleet> additionalFleets = new ArrayList<Fleet>(); for (Planet p : planetsToAttack.minus(mine).items) { if (!p.isNeutral()) { newPlanets.add(p.removeShips(p.numShips)); additionalFleets.add(p.attack(mine)); } } return new Universe( planets.replace(new Planets(newPlanets)), fleets.union(new Fleets(additionalFleets)), turn, reservations); }
public Country( Planet parent, String iso3166alpha2Code, String iso3166alpha3Code, Integer iso3166numericCode, LocalizedString name, LocalizedString nationality, Class<AddressPrinter> iAddressPrinter) { super(); setBennu(Bennu.getInstance()); setUnit( Unit.create( parent.getUnit(), name, iso3166alpha3Code, getPartyType("País", COUNTRY_PARTYTYPE_NAME), getOrCreateAccountabilityType(), new LocalDate(), null, null)); setIso3166alpha2Code(iso3166alpha2Code); setIAddressPrinter(iAddressPrinter); setIso3166alpha3Code(iso3166alpha3Code); setIso3166numericCode(iso3166numericCode); setNationality(nationality); }
public MailRocket() { // NB ! We need to create offices first! Planet.setRandomStartOfficeToRocket(this); Thread thread = new Thread(new FlyRunnable(this)); thread.start(); }
// 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<Integer> remainingPlayers = new TreeSet<Integer>(); 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; } }