gamedata.java

来自「Java mulitplayer strategy game. Adaptati」· Java 代码 · 共 523 行

package net.sf.jawp.client;

import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;

import java.util.Map;


import net.sf.jawp.api.domain.BattleReportVO;
import net.sf.jawp.api.domain.Fleet;
import net.sf.jawp.api.domain.GameSpeed;
import net.sf.jawp.api.domain.Planet;
import net.sf.jawp.api.domain.Realm;
import net.sf.jawp.api.domain.stub.FleetVO;
import net.sf.jawp.api.domain.stub.PlanetRO;
import net.sf.jawp.api.service.JAWPGameService;
import net.sf.jawp.gf.api.Resolver;
import net.sf.jawp.util.Log;

/**
 * client view over player data
 * 
 * @author jarek
 * @version $Revision: 1.32 $
 * 
 */
public class GameData
{
	public static final String UNKNOWN_REALM = "?";
	
	
	private static final Log LOG = Log.getLog(GameData.class );
	
	private static final NumberFormat MINUTE_FORMATTER = new DecimalFormat("00");
	
	private static final int SEC_PER_MINUTE = 60;
	
	private static final int SEC_PER_HOUR = SEC_PER_MINUTE * 60;
	
	private static final int SEC_PER_DAY = SEC_PER_HOUR * 24;

	private final JAWPGameService gameService;

	private Realm realmData;

	private GameSpeed gameSpeed;
	
	private final Map<Long, Realm> visibleRealms;
	
	
	
	private final PlanetsHolder planetsHolder;
	
	
	private final FleetHolder fleetsHolder;
	
	private final PlanetResolver planetResolver;
	
	private final Resolver<Realm> realmResolver;
	/**
	 * 
	 * Creates new instance of GameData.
	 * @param game communication service endpoint
	 */
	public GameData(final JAWPGameService game)
	{
		this.gameService = game;
		this.visibleRealms = new HashMap<Long, Realm>();
		
		this.planetsHolder = new PlanetsHolder();
		this.fleetsHolder = new FleetHolder();
		
		
		this.planetResolver = new PlanetResolver();
		this.realmResolver = new RealmResolver();
	}

	private GameSpeed getGameSpeed()
	{
		if ( this.gameSpeed == null)
		{
			this.gameSpeed = this.gameService.getGameSpeed();
		}
		return this.gameSpeed;
	}
	
	public final Collection<Planet> getVisiblePlanets()
	{
		/*if (this.visiblePlanets.isEmpty())
		{
			refreshPlanets();
		}
		return this.visiblePlanets.values();*/
		return convertToPlanet(this.planetsHolder.getAll());
	}

	public final Planet getPlanet(final long key)
	{
		return this.planetsHolder.find(key);
	}
	
	/*private void updateShownFleets()
	{
		// to show
		for (final Fleet f : this.ownFleets.values())
		{

			updateOwnFleet(f);
		}

		// to hide
		for (final long key : this.shownFleets)
		{
			
			if (!this.ownFleets.containsKey(key) )
			{
				final Fleet toHide = getFleet(key);
				addHideFleet(toHide);
			}
			else
			{
				final Fleet f = this.getFleet(key);
				if (f.getTarget() == null)
				{
					addHideFleet(f);
				}
			}

		}
	}*/
	
	public final Fleet getFleet( final long key)
	{
		return this.fleetsHolder.find( key);
	}

	/*private void updateOwnFleet(final Fleet f)
	{
		if (this.shownFleets.contains(f.getKey()))
		{
			// update position only
			this.shownFleets.add(f.getKey());
		}
		else if (f.getTarget() != null
				&& !this.shownFleets.contains(f.getKey()))
		{
			addShowFleet(f);
		}
	}*/

	/*private void addShowFleet(final Fleet f)
	{
		this.showFleets.add(f.getKey());
	}

	private void addHideFleet(final Fleet f)
	{
		this.hideFleets.add(f);
	}*/

	public final Collection<Fleet> getFleetsToShow()
	{
		return convertToFleet( this.fleetsHolder.getAdded() );
	}

	public final Collection<Fleet> getFleetsToHide()
	{
		return convertToFleet( this.fleetsHolder.getRemoved() );
	}

	public final Collection<Fleet> getFleetsToUpdate()
	{
		return convertToFleet( this.fleetsHolder.getUpdated() );
	}

	public final Collection<Fleet> getOwnFleets()
	{
		return convertToFleet( this.fleetsHolder.getAll() );
	}

	public Collection<Planet> getUpdateOwnerShipCollection()
	{
		return convertToPlanet(this.planetsHolder.getUpdated());
	}
	
	public Collection<Planet> getAddedPlanets()
	{
		return convertToPlanet(this.planetsHolder.getAdded());
	}
	
	public final Realm getRealm()
	{
		if (this.realmData == null)
		{
			loadOwnRealm();
		}
		return this.realmData;
	}

	public final void moveFleet(final Planet from, final Planet to, final int sz)
	{
		final long startTime = System.currentTimeMillis(); 
		this.gameService.moveFleet(from.getKey(), to.getKey(), sz);
		final PlanetRO pl = this.planetsHolder.find(from.getKey() );
		pl.setHomeFleetSize( pl.getHomeFleetSize() - sz); //TODO: this is semihack
		assert LOG.debug(System.currentTimeMillis() - startTime + "ms to send move order");
	}

	private Realm getRealm(final long key)
	{

		final Realm visible = this.visibleRealms.get(key);
		if (visible == null)
		{
			return loadRealm(key);
		}
		else
		{
			return visible;
		}
	}

	private Realm loadRealm(final long key)
	{
		final Realm result = this.gameService.getOtherRealm(key);
		this.visibleRealms.put(result.getKey(), result);
		return result;
	}

	public final String getRealmName(final long key)
	{
		final Realm realm = getRealm(key);
		if (realm != null)
		{
			return realm.getName();
		}
		else
		{
			return GameData.UNKNOWN_REALM;
		}
	}
	
	private Realm loadOwnRealm()
	{
		this.realmData = gameService.getRealm();
		this.visibleRealms.put ( this.realmData.getKey() , this.realmData);
		return realmData;
	}

	public final void refresh()
	{
		loadOwnRealm();
		refreshPlanets();
		refreshVisibleFleets();
		refreshRealms();
	}

	private void refreshPlanets()
	{
		final Collection<Planet> allPlanets = this.gameService.getPlanets();

		this.planetsHolder.bulkRefresh(convertToPlanetRO(allPlanets));
		
		
		
		

	}

	private void refreshVisibleFleets()
	{
		final Collection<Fleet> allFleets = this.gameService.getOwnFleets();
		this.fleetsHolder.bulkRefresh( removeHomeFleets(convertToFleetVO(allFleets)));
	}

/*	private void refreshFleet(final Fleet f)
	{
		final Fleet old = this.oldFleets.get(f.getKey());
		if (old == null)
		{
			this.ownFleets.put(f.getKey(), f);
		}
		else
		{
			//@todo: update using RO 
			old.setDirection( f.getDirection()); 
			old.setPosition( f.getPosition());
			old.setSize(f.getSize());
			old.setTarget( f.getTarget());
			old.setTargetPosition( f.getTargetPosition());
			this.ownFleets.put(old.getKey(), old);
		}
		
	}*/
	

	public final boolean isOwn(final Planet planet)
	{
		final Planet real = this.getPlanet( planet.getKey());
		return real.getOwner().getKey() == getRealmKey();
	}

	public final boolean isNeutral(final Planet planet)
	{
		final Planet real = this.getPlanet( planet.getKey());
		final long realmKey = real.getOwner().getKey();
		final String realmName = getRealmName(realmKey );
		return realmName.equals("neutral"); //todo: change this to sth more sensible
	}
	
	/**
	 * neutral is also enemy
	 */
	public final boolean isEnemy( final Planet p)
	{
		return !isOwn(p);
	}
		
	private long getRealmKey()
	{
		return getRealm().getKey();
	}
	
	private static class PlanetsHolder extends ClientObjectsHolder<PlanetRO>
	{

		/**
		 * {@inheritDoc}
		 */
		@Override
		protected boolean hasChanged(final PlanetRO old, final PlanetRO newObject)
		{
			return  !old.getOwner().equals( newObject.getOwner());
		}

		/**
		 * {@inheritDoc}
		 */
		@Override
		protected void update(final PlanetRO old, final PlanetRO newObject, final boolean changed)
		{
			if ( changed)
			{
				//assert LOG.debug( "old owner of: " + old.getKey() + " was " + old.getOwner().getKey());
				//assert LOG.debug( "new owner of: " + newObject.getKey() + "  is " + newObject.getOwner().getKey());
				old.setOwner( newObject.getOwner());
			}
			old.setHomeFleetSize( newObject.getHomeFleetSize());
			old.setProduced( newObject.getProduced());
			old.setProductivity( newObject.getProductivity());
		}
		
	}
	
	private static class FleetHolder extends ClientObjectsHolder<FleetVO>
	{
		protected boolean hasChanged(final FleetVO old, final FleetVO newObject)
		{
			return old.getTimeToGo() != newObject.getTimeToGo();
		}

		protected void update(final FleetVO old, final FleetVO f, final boolean changed)
		{
			old.setTimeToGo( f.getTimeToGo());
			old.setDirection( f.getDirection()); 
			old.setPosition( f.getPosition());
			old.setSize(f.getSize());
			old.setTarget( f.getTarget());
			old.setTargetPosition( f.getTargetPosition());
		}
		
	}
	
	
	private Collection<Planet> convertToPlanet( final Collection<PlanetRO> input)
	{
		return new ArrayList<Planet>(input);
	}
	
	private Collection<PlanetRO> convertToPlanetRO( final Collection<Planet> input)
	{
		final ArrayList<PlanetRO> result = new ArrayList<PlanetRO>(input.size());
		for ( final Planet p : input)
		{
			result.add( new PlanetRO(p));
		}
		return result;
	}
	
	private Collection<Fleet> convertToFleet( final Collection<FleetVO> input)
	{
		return new ArrayList<Fleet>(input);
	}
	
	private Collection<FleetVO> removeHomeFleets( final Collection<FleetVO> input)
	{
		
		final ArrayList<FleetVO> result = new ArrayList<FleetVO>( input.size());
		for ( final FleetVO f : input)
		{
			if ( f.getTimeToGo() > 0) 
			{
				result.add ( f);
			}
		}
		result.trimToSize();
		return result;
	}
	
	private Collection<FleetVO> convertToFleetVO( final Collection<Fleet> input)
	{
		final ArrayList<FleetVO> result = new ArrayList<FleetVO>( input.size());
		for ( final Fleet f : input)
		{
			result.add ( new FleetVO( f));
		}
		return result;
	}
	
	

	public final PlanetResolver getPlanetResolver()
	{
		return planetResolver;
	}

	public Resolver<Realm> getRealmResolver()
	{
		return realmResolver;
	}
	
	private class PlanetResolver implements Resolver<Planet>
	{
		public Planet find(final long key)
		{
			return getPlanet(key);
		}
		
	}
	private class RealmResolver implements Resolver<Realm>
	{
		public Realm find(final long key)
		{
			
			final Realm r = getRealm(key);
			//System.out.println("rr:"+r.getName());
			return r;
		}
		
	}
	
	public final Collection<Realm> getKnownRealms()
	{
		return this.visibleRealms.values();
	}
	
	public final void refreshRealms()
	{
		final Collection<Long> keys = this.visibleRealms.keySet();
		for ( final Long key : keys)
		{
			loadRealm(key);
		}
	}
	
	public final Collection<BattleReportVO> getBattleReports()
	{
		return this.gameService.getBattleReports();
	}
	
	public final String getDistanceAsString( final Planet src, final Planet trg)
	{
		final double dist = src.calcDistance( trg );
		
		return convertDistToString(  dist);
	}
	
	private double  convertDistToTime( final double dist)
	{
		return dist / getGameSpeed().getBaseFleetSpeed();
	}
	
	public final String convertDistToString( final double dist)
	{
		return convertTimeToString( (int)convertDistToTime( dist));
	}
	
	public static final String convertTimeToString( final int sec)
	{
		int secs = sec; 
		final int days = secs / SEC_PER_DAY;
		secs = secs % SEC_PER_DAY;
		final int hours = secs / SEC_PER_HOUR;
		secs = secs % SEC_PER_HOUR;
		final int mins = secs / SEC_PER_MINUTE;
		secs  = secs % SEC_PER_MINUTE;
		final StringBuilder sb = new StringBuilder();
		if ( days > 0)
		{
			sb.append( days + "d ");
		}
		if ( hours > 0)
		{
			sb.append( hours + ":");
		}
		if ( mins > 0)
		{
			sb.append( MINUTE_FORMATTER.format( mins) );
			sb.append(':');
		}
		
		sb.append( MINUTE_FORMATTER.format(secs));
		sb.append('s');
		return sb.toString();
	}
	

		
}