planetscenenode.java

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

/*
 * Created on 2005-10-11
 * $Id: PlanetSceneNode.java,v 1.23 2006/01/07 15:53:43 macx2k Exp $
 */
package net.sf.jawp.gui.client.j3d;

import java.awt.Font;

import javax.media.j3d.Appearance;
import javax.media.j3d.Billboard;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.Group;
import javax.media.j3d.Material;
import javax.media.j3d.Node;
import javax.media.j3d.Texture;
import javax.media.j3d.TextureAttributes;
import javax.media.j3d.Transform3D;
import javax.media.j3d.TransformGroup;
import javax.vecmath.Color3f;
import javax.vecmath.Point3f;

import net.sf.jawp.api.domain.Planet;
import net.sf.jawp.client.GameData;
import net.sf.jawp.j3d.object.SceneObject;
import net.sf.jawp.j3d.object.PlacementHelper;
import net.sf.jawp.j3d.picking.PickingHelper;
import net.sf.jawp.j3d.texture.TextureGroup;
import net.sf.jawp.j3d.texture.TextureManager;

import com.sun.j3d.utils.geometry.Primitive;
import com.sun.j3d.utils.geometry.Sphere;
import com.sun.j3d.utils.geometry.Text2D;

/**
 * @author maciek
 * @version $Revision: 1.23 $
 * 
 */
public class PlanetSceneNode extends SceneObject<Planet>
{
	private static final float DEFAULT_PLANET_RADIUS = 500f;

	private static final Color3f NEUTRAL_COLOR = new Color3f(1f, 1f, 1f);

	private static final Color3f ENEMY_COLOR = new Color3f(1f, 0.3f, 0.3f);

	private static final Color3f OWN_COLOR = new Color3f(0.3f, 1f, 0.3f);

	private static final Color3f BLACK = new Color3f(0f, 0f, 0f);

	private static final Color3f WHITE = new Color3f(1f, 1f, 1f);

	private final TextureGroup textureGroup;

	private final GameData gameData;

	private Sphere sph = null;

	private BranchGroup parentGroup = null;

	private BranchGroup textGroup = null;

	private Material material = null;

	private TextureAttributes textureAttributes = null;

	private boolean showNames = true;

	private boolean markOwnership = true;

	public PlanetSceneNode(final Planet planet,
			final TextureManager textureManager, final GameData gameData)
	{
		super(planet, false, false);
		this.textureGroup = textureManager.getGroup("planets");
		this.gameData = gameData;
	}

	/**
	 * Returns a string which identifies a planet texture. Refer textures.xml
	 * for correct id->texture mapping.
	 * 
	 * @param planet
	 * @return
	 */
	private String chooseTextureIdForPlanet(final Planet planet)
	{
		int sum = 0;
		final String planetName = planet.getName();
		for (int i = 0; i < planetName.length(); ++i)
		{
			sum += planetName.charAt(i);
		}
		return String.valueOf(sum % textureGroup.getCount());
	}

	public void updatePlanetOwnership()
	{
		if (!markOwnership)
		{
			setColor(NEUTRAL_COLOR);
			return;
		}

		if (gameData.isOwn(this.renderedObject))
		{
			setColor(OWN_COLOR);
		}
		else if (gameData.isNeutral(this.renderedObject))
		{
			setColor(NEUTRAL_COLOR);
		}
		else
		// enemy
		{
			setColor(ENEMY_COLOR);
		}
	}

	public void setSelected(final boolean selected)
	{
		if (selected)
		{
			if (markOwnership)
			{
				if (gameData.isOwn(this.renderedObject))
				{
					material.setEmissiveColor(OWN_COLOR);
				}
				else if (gameData.isNeutral(this.renderedObject))
				{
					material.setEmissiveColor(NEUTRAL_COLOR);
				}
				else
				// enemy
				{
					material.setEmissiveColor(ENEMY_COLOR);
				}
			}
			else
			{
				material.setEmissiveColor(WHITE);
			}
			material.setSpecularColor(WHITE);
		}
		else
		{
			material.setEmissiveColor(BLACK);
			material.setSpecularColor(BLACK);
		}
	}

	public void setShowNames(final boolean flag)
	{
		if (flag == showNames)
		{
			return;
		}
		showNames = flag;

		if (showNames)
		{
			showName();
		}
		else
		{
			hideName();
		}
	}

	public void setMarkOwnership(final boolean flag)
	{
		markOwnership = flag;
		updatePlanetOwnership();
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	protected void updatePosition(final Planet planet,
			final Transform3D transform3d)
	{
		transform3d.set(J3DHelper.toJ3d(planet.getCoords()));
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	protected Node createScenegraphObject(final Planet planet)
	{
		parentGroup = new BranchGroup();
		parentGroup.setCapability(Group.ALLOW_CHILDREN_READ);
		parentGroup.setCapability(Group.ALLOW_CHILDREN_WRITE);
		parentGroup.setCapability(Group.ALLOW_CHILDREN_EXTEND);

		final Appearance app = createAppearance(planet);

		sph = new Sphere(DEFAULT_PLANET_RADIUS,
				Primitive.GENERATE_TEXTURE_COORDS | Primitive.GENERATE_NORMALS
						| Primitive.GEOMETRY_NOT_SHARED, 30, app);
		PickingHelper.enablePicking(sph);

		updatePlanetOwnership();
		parentGroup.addChild(sph);

		createPlanetNameNode(planet);

		if (showNames)
		{
			parentGroup.addChild(textGroup);
		}

		return parentGroup;
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	protected void setUserData(final Planet renderedObject)
	{
		sph.setUserData(renderedObject);
	}

	/*
	 * Creates appearance object for planets.
	 */
	private Appearance createAppearance(final Planet planet)
	{
		final Appearance app = new Appearance();

		// set texture
		app.setTexture(chooseTextureForPlanet(planet));

		// set material
		material = new Material();
		material.setShininess(10f);
		material.setCapability(Material.ALLOW_COMPONENT_WRITE);
		app.setMaterial(material);

		// set texture attributes
		textureAttributes = new TextureAttributes();
		textureAttributes.setTextureMode(TextureAttributes.MODULATE);
		app.setTextureAttributes(textureAttributes);
		return app;
	}

	/*
	 * Creates text with planet name.
	 */
	private void createPlanetNameNode(final Planet planet)
	{
		textGroup = new BranchGroup();
		textGroup.setCapability(BranchGroup.ALLOW_DETACH);

		final Text2D text = new Text2D(planet.getName(), WHITE, "Arial", 50,
				Font.PLAIN);
		PickingHelper.allowIntersect(text);
		final TransformGroup textTG = PlacementHelper
				.wrap(PlacementHelper.placeY(PlacementHelper.scale(
						text, 2000), DEFAULT_PLANET_RADIUS * 1.5f));
		textTG.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
		textGroup.addChild(textTG);

		final Billboard b = new Billboard(textTG, Billboard.ROTATE_ABOUT_POINT,
				new Point3f());
		b.setSchedulingBounds(Scene.getBoundingSphere());
		textGroup.addChild(b);
		textGroup.compile();
	}

	private Texture chooseTextureForPlanet(final Planet planet)
	{
		return textureGroup.getTexture(chooseTextureIdForPlanet(planet));
	}

	private void showName()
	{
		parentGroup.addChild(textGroup);
	}

	private void hideName()
	{
		textGroup.detach();
	}

	private void setColor(final Color3f color)
	{
		material.setAmbientColor(color);
		material.setDiffuseColor(color);
		material.setSpecularColor(BLACK);
	}

}