jawpgameworlddo.java

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

package net.sf.jawp.game.domain;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CopyOnWriteArrayList;


import net.sf.jawp.api.domain.BattleReportVO;
import net.sf.jawp.api.domain.BattleResult;
import net.sf.jawp.api.domain.Fleet;
import net.sf.jawp.api.domain.GameSpeed;
import net.sf.jawp.api.domain.JAWPOptions;
import net.sf.jawp.api.domain.Planet;
import net.sf.jawp.api.domain.Realm;
import net.sf.jawp.api.domain.Rules;
import net.sf.jawp.api.domain.SpaceCoords;
import net.sf.jawp.api.domain.stub.JAWPOptionsVO;
import net.sf.jawp.api.domain.stub.RealmVO;
import net.sf.jawp.gf.api.EntityHolder;
import net.sf.jawp.gf.api.Resolver;
import net.sf.jawp.gf.api.UIDGenerator;
import net.sf.jawp.gf.api.domain.GameOptions;
import net.sf.jawp.gf.api.domain.GameWorld;
import net.sf.jawp.gf.domain.GameWorldBase;
import net.sf.jawp.gf.domain.PlayerDO;
import net.sf.jawp.gf.system.SystemContext;
import net.sf.jawp.util.Log;
import net.sf.jawp.util.NumUtils;
import net.sf.jawp.util.WordGenerator;



/**
 * Implementation of gameworld
 * 
 * @author jareke
 * @version $Revision: 1.60 $
 */
public final class JAWPGameWorldDO extends GameWorldBase<JAWPGameWorldRO>
implements JAWPGameWorldRO
{
	/**
	 * how many planets are created by default for new game world
	 */
	private static final int INITIAL_NUMBER_OF_PLANETS = JAWPOptionsVO.INITIAL_NUMBER_OF_PLANETS;
	
	private static final int NEUTRAL_PLANETS_PER_PLAYER = 2;
	
	private static final float MIN_PLANET_DISTANCE = 1000f;
	
	private static final Log LOG = Log.getLog(JAWPGameWorldDO.class);
	
	/**
	 * wersion 2 gamespeed added
	 */
	private static final long serialVersionUID = 2L;

	private static final String NEUTRAL_REALM_NAME = "neutral";
	
	
	/**
	 * all planets in space
	 */
	private final HashMap<Long, PlanetDO> planets; 
	
	/**
	 * all fleets in space
	 */
	private final HashMap<Long, FleetDO> fleets; 
	 
	/**
	 * realms - for all players
	 */
	private final HashMap<Long, RealmDO> realmsByPlayer;
	
	/**
	 * realms - for all players
	 */
	private final HashMap<Long, RealmDO> realmsByKey;

	private RealmDO neutralRealm;
	
	private final Collection<MoveOrder>  orders;
	
	private final Resolver<Realm> realmResolver;
	
	private final Resolver<RealmDO> realmDOResolver;
	
	private GameSpeed gameSpeed;
	
	private JAWPOptionsDO gameOptions;
	
	/**
	 * realms that are operated by AI
	 */
	private final List<RealmDO> aiRealms;
	
	public JAWPGameWorldDO(final long k, final String name, final SystemContext context)
	{
		super(k, name, context);
		this.planets = new HashMap<Long, PlanetDO>();
		this.fleets = new HashMap<Long, FleetDO>();
		this.realmsByPlayer  = new HashMap<Long, RealmDO>();
		this.realmsByKey  = new HashMap<Long, RealmDO>();
		this.orders = new ArrayList<MoveOrder>(10);
		
		this.realmResolver = new RealmResolver();
		this.realmDOResolver = new RealmDOResolver();
		this.aiRealms = new CopyOnWriteArrayList<RealmDO>();
	}

	private Collection<MoveOrder> getMoveOrders()
	{
		return this.orders;
	}

	public void addMoveOrder( final MoveOrder order)
	{
		this.orders.add( order );
	}
	
	@Override
	public JAWPGameWorldRO getUnmodifiable()
	{
		return this;
	}

	/*@Override
	public JAWPGameWorldRO cloneUnmodifiable()
	{
		return this;
	}*/
	
	public PlanetDO findPlanetDO(final long key )
	{
		synchronized (this.planets)
		{
			return this.planets.get(key);
		}
	}
	
	public Planet findPlanet(final long key )
	{
		return findPlanetDO(key);
	}
	
	private FleetDO findFleetDO(final long key)
	{
		synchronized (this.fleets)
		{
			return this.fleets.get(key);
		}
	}

	private void addPlanet( final PlanetDO planet)
	{
		synchronized ( this.planets )
		{
			this.planets.put( planet.getKey(), planet);
		}
	}
	
	/**
	 * inits the game world
	 *
	 */
	public void init(final UIDGenerator generator, final GameOptions srcOptions)
	{
		//create neutral player
		final RealmDO neutral = createNeutralRealm(generator); 
		registerRealm( neutral);
		//create some initial planets
		this.gameOptions  = JAWPOptionsDO.getOptions( (JAWPOptions)srcOptions);
		this.gameSpeed = this.gameOptions.getGameSpeed();
		createPlanets(this.gameOptions.getNeutralPlanets(), generator, neutral);
		//cpu realms
		for ( int i = 0 ; i < this.gameOptions.getCpuPlayers(); i++)
		{
			createCpuRealm(generator, i);
		}
	}


	private void registerRealm(final RealmDO realm)
	{
		synchronized (this.realmsByKey)
		{
			this.realmsByKey.put( realm.getKey(), realm);
		}
		
	}
	
	
	private RealmDO createCpuRealm(final UIDGenerator generator, final int index)
	{
		final RealmDO realm = new RealmDO(generator.nextUID(), 
								null, "CPU:" + index);
		registerRealm( realm);
		createPlanet(generator, realm);
		turnRealmAIOn( realm);
		return realm;
	}

	private RealmDO createNeutralRealm(final UIDGenerator generator)
	{
		final RealmDO realm = new RealmDO(generator.nextUID(), 
								null, JAWPGameWorldDO.NEUTRAL_REALM_NAME);
		this.neutralRealm = realm;
		turnRealmAIOn( this.neutralRealm);
		return this.neutralRealm;
	}


	private void turnRealmAIOn( final RealmDO realm)
	{
		this.aiRealms.add(realm);
	}
	
	private void turnRealmAIOff( final RealmDO realm)
	{
		this.aiRealms.remove(realm);
	}
	
	public RealmDO getNeutralRealm()
	{
		return this.neutralRealm;
	}
	
	/**
	 * adds given number of planets
	 * @param number
	 */
	private void createPlanets(final int number, final UIDGenerator generator, final RealmDO owner)
	{
		for ( int i = 0; i < number; i++)
		{
			createPlanet( generator, owner );
		}
	}

	private String capitalizeName(final String input)
	{
		return input.substring(0, 1).toUpperCase() + input.substring(1);
	}
	
	/**
	 * 
	 * @param generator
	 */
	private PlanetDO createPlanet(final UIDGenerator generator, final RealmDO owner)
	{
		final long key = generator.nextUID();
		final String name = WordGenerator.generateWord( this.getNumericalContext().getRandom(), 
					4 + this.getNumericalContext().getRandom().nextInt(7));
		int radius = Math.round( (float)Math.pow((float)getNumberOfPlanets(), 0.33) * this.gameOptions.getPlanetsDensity().getDensityValue() ) + 4;
		SpaceCoords coords = null;
		
		do
		{
		
			final int x = getNumericalContext().random( radius + radius ) - NumUtils.getLogicValue(radius);
			final int y = getNumericalContext().random( radius + radius ) - NumUtils.getLogicValue(radius);
			final int z = getNumericalContext().random( radius + radius ) - NumUtils.getLogicValue(radius);
		
			 final SpaceCoords trial = new SpaceCoords( x, y, z);
			 
			 final PlanetDO closest = findClosestPlanet( trial);
			 if (closest == null || trial.getDistance( closest.getCoords()) > MIN_PLANET_DISTANCE)
			 {
				coords = trial; 
			 }
			 else
			 {
				 ++radius; //thanks to this finally planet will be created
			 }
		}
		while ( coords == null);
		final PlanetDO planet = new PlanetDO(key, capitalizeName(name), owner, coords);
		final int p = getNumericalContext().random(7) + getNumericalContext().random(7) + 2;
		planet.setProductivity( NumUtils.floor(p) );
        planet.incFleet(5, this, owner); //by default neutral planets get 5 ships
        planet.reveal();        
		addPlanet(planet );
                
		return planet;
	}


	@Override
	protected void playerAddedEvent(final PlayerDO player, final SystemContext system)
	{
		super.playerAddedEvent(player, system);
		//add some neutral planets
		createPlanets( NEUTRAL_PLANETS_PER_PLAYER,  system.getUIDGenerator(),  this.neutralRealm );
		
		final RealmDO realm = createRealm(player, system); 
		addRealm(realm);
		final PlanetDO playerCapital = createPlanet(system.getUIDGenerator(), realm);
        playerCapital.setProductivity( 10.0f); //each player gets planet with productivity 10
		playerCapital.incFleet( 5, this, realm); //everybody starts with 10 ships (5 are given for each planet by default)
		playerCapital.reveal();
		
		
	}
	
	private void addRealm(final RealmDO realm)
	{
		synchronized (this.realmsByPlayer)
		{
			this.realmsByPlayer.put( realm.getOwner().getKey(), realm);
		}
		registerRealm( realm);
	}
	
	private RealmDO createRealm( final PlayerDO player, final SystemContext system)
	{
		final RealmDO result = new RealmDO (system.getUIDGenerator().nextUID(), 
				player, player.getName());
		return result;
		
	}

	public RealmVO getRealm(final long playerKey)
	{
		synchronized (this.realmsByPlayer)
		{
			return new RealmVO(this.realmsByPlayer.get( playerKey));
		}
	}
	
	public RealmDO findRealmDO(final long realmKey)
	{
		
		synchronized (this.realmsByKey)
		{
			return this.realmsByKey.get( realmKey);
		}
	}




	/*@Override
	public JAWPGameService createGameService(final PersistenceController<RootSystem<JAWPGameWorldDO, JAWPGameWorldRO, JAWPGameService>, 
			RootSystemUnmodifiable< JAWPGameWorldRO> > persistence,
				final Player player) 
	{ 
		return new JAWPGameServiceImpl( persistence, player, this.getUnmodifiable());
		
	}*/

	public Collection<Planet> getAllPlanets(final Realm realm)
	{
		final Collection<Planet> result = new ArrayList<Planet>();
		synchronized ( this.planets)
		{
			//result.addAll( this.planets.values() ); 
			for ( final PlanetDO planet : this.planets.values())
			{
				result.add( planet.getPlayerView( realm));
			}
		}
		return result;
	}

	private int getNumberOfPlanets()
	{
		synchronized (this.planets) 
		{
			return this.planets.size();
		}
	}


	/**
	 * {@inheritDoc}
	 */
	@Override
	public void doStep(final long timeSlice)
	{
		doMoveOrders();
		doProduction(timeSlice);
		doMoveFleets(timeSlice);
		
		doStats();
	}
	
	private void doStats()