dummyneutralplayer.java

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

package net.sf.jawp.game.ai;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import net.sf.jawp.api.ai.AIPlayer;
import net.sf.jawp.api.domain.Planet;
import net.sf.jawp.api.domain.Realm;
import net.sf.jawp.api.service.JAWPGameService;

/**
 * 
 * @author jarek
 * @version $Revision$
 *
 */
public class DummyNeutralPLayer implements AIPlayer
{
	private static final DistanceComparator CMP = new DistanceComparator();

	private static final double MODIFIER = 0.6; 
		
	public void start(final JAWPGameService service)
	{
		//DO not do a thing
		
	}

	public void stop()
	{
		//DO not do a thing
		
	}

	public void step(final JAWPGameService service)
	{
		//very large step
		
		final Collection<Planet> planets = service.getPlanets();
		final List<Planet> nmePlanets = getNMEPlanets(service.getRealm() , planets);
		final List<Planet> ownPlanets = getOWNPlanets(service.getRealm() , planets);
		final int nmb = Math.min( nmePlanets.size(), 3);
		if (nmb > 0)
		{
			
			for (final Planet p : ownPlanets)
			{
			
				final Set<Planet> nme = getClosest(p, nmePlanets, nmb);
				final double safeval = calcAveregeFleet(nme); //avg nmb of ships on three closest planets
				final double planetval = (double)p.getHomeFleetSize();
				for ( final Planet nmeP : nme)
				{
					final double nmeval = (double)nmeP.getHomeFleetSize();
					
					if ( nmeval  < (planetval - safeval) * MODIFIER )
					{
						final int size = (int)(planetval - safeval) + 1;
						service.moveFleet( p.getKey(), nmeP.getKey(), size);
						
						return; //we just allow one action per step
					}
					
				}
				//	
			}
		}
		

	}
	
	private double calcAveregeFleet(final Set<Planet> planets)
	{
		double sum = 0.0;
		for ( final Planet p : planets)
		{
			sum += p.getHomeFleetSize();
		}
		return sum / (double)planets.size(); 
	}
	

	private List<Planet> getNMEPlanets(final Realm realm, final Collection<Planet> planets )
	{
		final List<Planet> result = new ArrayList<Planet>(planets.size() - 1);
		final long realmKey = realm.getKey();
		for ( final Planet p : planets)
		{
			if ( p.getOwner().getKey() != realmKey)
			{
				result.add(p);
			}
		}
		return result;
	}
	
	private List<Planet> getOWNPlanets(final Realm realm, final Collection<Planet> planets )
	{
		final List<Planet> result = new ArrayList<Planet>(planets.size());
		final long realmKey = realm.getKey();
		for ( final Planet p : planets)
		{
			if ( p.getOwner().getKey() == realmKey)
			{
				result.add(p);
			}
		}
		return result;
	}
	/**
	 * returns closest planets from a given set
	 * @param planets
	 * @param i
	 * @return
	 */
	private Set<Planet> getClosest(final Planet planet, final List<Planet> planets, final int length)
	{
		
		final Set<Planet> result = new HashSet<Planet>(length);
		Collections.sort( planets, CMP);
		for ( int i = 0; i < length; i++)
		{
			result.add( planets.get(i) );
		}
		return result;
	}

	
	private static class DistanceComparator
	implements Comparator<Planet>
	{

		public int compare(final Planet o1, final Planet o2)
		{
			return (int)o1.getCoords().getDistance(o2.getCoords());
		}
		
	}
	
}