jawpgameworlddo.java

Java mulitplayer strategy game. Adaptation of KDE Galaxy Conquest. (rules are changed - but still th

	{
		final ArrayList<RealmDO> realms = new ArrayList<RealmDO>();
		synchronized ( this.realmsByKey )
		{
			realms.addAll( this.realmsByKey.values());
		}
		for ( final RealmDO realm : realms)
		{
			realm.recalcStatistics();
		}
	}
	
	private void doMoveOrders()
	{
		final Collection<MoveOrder> moveOrders = getMoveOrders();
		for ( final MoveOrder ord : moveOrders)
		{
			doMoveOrder( ord );
		}
		this.orders.clear();
	}
	
	private void doMoveFleets(final long timeSlice)
	{
		Collection<FleetDO> fleetsToMove;
		synchronized (this.fleets)
		{
			fleetsToMove = new ArrayList<FleetDO>(this.fleets.values());
		}
		for ( final FleetDO fleet : fleetsToMove )
		{
			if ( !fleet.hasFinishedMovement() )
			{
				doFleetMovement(fleet, timeSlice);
				
			}
		}
	}

	private void doFleetMovement(final FleetDO fleet, final long timeSlice)
	{
		assert LOG.debug( "moving fleet:" + fleet.getKey() );
		fleet.move(this.gameSpeed, timeSlice);
		if ( fleet.hasFinishedMovement() )
		{
			//LOG.info( "fleet:" + fleet.getKey() + " has finished movement");
			final PlanetDO target = findPlanetDO(fleet.getTarget().getKey());
			fleet.land( target );
			if (target.getOwner().equals(fleet.getOwner()) )
			{
				joinFleet( fleet, target);
			}
			else
			{
				doBattle( fleet, target);
			}
		}
	}
	
	private void doBattle(final FleetDO fleet, final PlanetDO target)
	{
		final FleetDO defender = target.getHomeFleet();
		final LocalReport loses = new LocalReport(
			findRealmDO( fleet.getOwner().getKey()) , 
			findRealmDO( target.getOwner().getKey() ) );
			
		doBattle( fleet, defender, target, loses);
		checkForAttackerFailure(fleet);
		checkForInvasion(fleet, target, defender, loses);
		
	}

	private void checkForAttackerFailure(final FleetDO attacker)
	{
		if ( !isFleetAlive(attacker) )
		{
			scrap( attacker );
		}
	}

	private void checkForInvasion(final FleetDO attacker, final PlanetDO target, final FleetDO defender, 
			final LocalReport loses)
	{
		if ( !isFleetAlive(defender) )
		{
			scrap( defender );
			if ( isFleetAlive( attacker )) //this makes sense only if attacker survived
			{
				target.invade( attacker , this.realmDOResolver);
				//attacker won
				loses.attackerWon(target );
				return;
			}
		}
		//success of defense
		loses.defenderWon(target );
	}
	
	private boolean isFleetAlive(final FleetDO fleet)
	{
		return fleet != null && fleet.getSize() > 0;
	}
	
	private void doBattle(final FleetDO attacker, final FleetDO defender, 
			final PlanetDO battleField, final LocalReport loses )
	{
		if ( !( isFleetAlive(attacker) && isFleetAlive(defender) ) )
		{
			return;
		}
		//final int attackerLosses = (int)(defender.getSize() * 0.1 + 2);
		//final int defenderLosses = (int)(attacker.getSize() * 0.1 + 1);
		final int attackerLosses = calcDamage( defender.getSize(), getNumericalContext().getRandom(), 5);
		final int defenderLosses = calcDamage( attacker.getSize(), getNumericalContext().getRandom(), 6);
		attacker.reduce( attackerLosses);
		defender.reduce( defenderLosses);
		loses.addLoses( attackerLosses, defenderLosses);
		battleField.revealFleetSize( (float)defenderLosses, getNumericalContext());
		doBattle( attacker, defender, battleField, loses);
	}
	
	private static int calcDamage ( final int fleetSize, final Random random, final int prob )
	{
		int los = 0;
		for ( int i = 0; i < fleetSize; ++i )
		{
			final int p = random.nextInt( prob); 
			if ( p == 0 )
			{
				++los;
			}
		}
		return los;
	}

	private void joinFleet(final FleetDO fleet, final PlanetDO target)
	{
		final FleetDO home = target.getHomeFleet();
		if ( home != null)
		{
			home.setSize( home.getSize() + fleet.getSize());
			fleet.setSize(0);
			scrap( fleet );
		}
		else
		{
			target.setHomeFleet( fleet);
		}
		
		
	}

	/**
	 * @param fleet - fleet to be scrapped, may be null
	 */
	private void scrap(final FleetDO fleet)
	{
		
		if (fleet != null)
		{	
			synchronized (this.fleets)
			{
				this.fleets.remove( fleet.getKey());
				final RealmDO realm = findRealmDO( fleet.getOwner().getKey());
				realm.removeFleet( fleet );
			}
		}
	}

	private void doMoveOrder(final MoveOrder ord)
	{
		//check
		final int size = Math.min( ord.getFleetSize(), ord.getFromPlanet().getHomeFleetSize());
		if ( size <= 0 )
		{
			return;
		}
		else
		{
		
			final FleetDO fleet = ord.getFromPlanet().getHomeFleet();
			fleet.setSize( fleet.getSize() - size);
			final FleetDO newFleet = new FleetDO(getUIDGenerator().nextUID(), fleet.getOwner().getEntity( getRealmResolver() ));
			newFleet.setSize( size );

			newFleet.setPosition( new SpaceCoords( ord.getFromPlanet().getCoords()));
			newFleet.setTargetPosition(  new SpaceCoords( ord.getToPlanet().getCoords()));

			newFleet.setTarget( new EntityHolder<Planet>(ord.getToPlanet())); //@todo: improve code
			newFleet.calculateDirection(this.gameSpeed);
			registerFleet( newFleet);
		}
	}

	public void registerFleet(final FleetDO fleet)
	{
		synchronized ( this.fleets )
		{
			this.fleets.put( fleet.getKey(), fleet);
		}
		if ( fleet.getOwner() != null )
		{
			findRealmDO( fleet.getOwner().getKey()).registerFleet( fleet); 
		}
		
	}
	
	private Resolver<Realm> getRealmResolver()
	{
		return this.realmResolver;
	}

	private PlanetDO findClosestPlanet( final SpaceCoords coords)
	{
		final Collection<PlanetDO> all = new ArrayList<PlanetDO>();
		synchronized (this.planets )
		{
			
			all.addAll( this.planets.values());
		}
		if ( all.isEmpty())
		{
			return null;
		}
		return Collections.min(all , new DistanceComparator(coords));
	}
	
	
	
	private void doProduction(final long timeSlice)
	{
		synchronized (this.planets)
		{
			for (final PlanetDO p : this.planets.values())
			{
				final float currentProductivity = this.gameSpeed.getProductionPerStep( timeSlice, p.getProductivity() ); 
				//*2 means that current productivity will stay as MEAN 
				p.setProduced( p.getProduced() + currentProductivity * 2 * getNumericalContext().getRandom().nextFloat());
				final int productCost = Rules.PRODUCTION_PER_UNIT; //that is fast 
				if ( p.getProduced() > productCost) 
				{
					//time to do sth.
					final int nmb = (int)Math.floor( p.getProduced() / (float)productCost ); 
					p.setProduced( p.getProduced() - nmb * productCost); //reminder
					//inc fleet
					p.incFleet(nmb, this, p.getOwner().getEntity( getRealmResolver()));
					registerFleet(p.getHomeFleet());
				}
				
				p.revealFleetSize( this.gameSpeed.getRevealingFactor(timeSlice), getNumericalContext());
			}
		}
	}

	
	public final Collection< RealmDO> getAIRealms()
	{
		return this.aiRealms;
	}
	
	public RealmVO findRealmByKey(final long realmKey)
	{
		return new RealmVO(findRealmDO( realmKey));
	}
	
	/**
	 * resolver for realm
	 */
	private class RealmResolver implements Resolver<Realm>, Serializable
	
	{

		/**
		 * 
		 */
		private static final long serialVersionUID = 1L;

		public RealmDO find(final long key)
		{
			return findRealmDO( key);
		}
		
	}

	private class RealmDOResolver implements Resolver<RealmDO>, Serializable
	
	{

		/**
		 * 
		 */
		private static final long serialVersionUID = 1L;

		public RealmDO find(final long key)
		{
			return findRealmDO( key);
		}
		
	}
	
	public Collection<Fleet> getFleets(final long realmKey)
	{
		final RealmDO realm = findRealmDO( realmKey);
		return realm.getFleets();
	}

	public GameSpeed getGameSpeed()
	{
		return this.gameSpeed;
	}

	public net.sf.jawp.gf.api.domain.GameWorld getGameWorldDescription()
	{
		return new GameWorld( this.getKey(), this.getName());
	}
	
	/**
	 * distance comparator for searching closest planets
	 * @author jarek
	 * @version $Revision: 1.60 $
	 *
	 */
	private static class DistanceComparator implements Comparator<PlanetDO>
	{

		private final SpaceCoords baseCoord;
		
		
		public DistanceComparator(final SpaceCoords coord)
		{
			super();
			baseCoord = coord;
		}


		public final int compare(final PlanetDO o1, final PlanetDO o2)
		{
			assert o1.getCoords() != null;
			assert o2.getCoords() != null;
			final double dist1 = this.baseCoord.getDistance( o1.getCoords());
			final double dist2 = this.baseCoord.getDistance( o2.getCoords());
			return Double.compare( dist1, dist2);
		}
		
	}
	
	private static final class LocalReport
	{
		private int attackerLoses = 0;
		
		private int defenderLoses = 0;
		
		private final RealmDO attacker;
		
		private final RealmDO defender;
		
		public LocalReport(final RealmDO attacker, final RealmDO defender)
		{
			this.attacker = attacker;
			this.defender = defender;
		}

		public void addLoses( final int attackerL, final int defenderL)
		{
			this.attackerLoses += attackerL;
			this.defenderLoses += defenderL;
		}

		public void defenderWon(final PlanetDO target)
		{
			doRaports( target, false);
		}
		
		public void doRaports(final PlanetDO target, final boolean attackerWon)
		{
			final BattleReportVO defRaport = new BattleReportVO (target, defenderLoses, 
					attackerLoses, attackerWon ?  BattleResult.FAILURE : BattleResult.SUCCESS);
			final BattleReportVO attRaport = new BattleReportVO (target, attackerLoses, 
					defenderLoses, attackerWon ?  BattleResult.SUCCESS : BattleResult.FAILURE);
			
			this.defender.addReport(defRaport);
			this.attacker.addReport(attRaport);
		}

		public void attackerWon(final PlanetDO target)
		{
			doRaports( target, true);
		}
	}
	
	
}