RollingTheMonkey.java

/*
 * Copyright (c) 2009-2021 jMonkeyEngine
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * * Neither the name of 'jMonkeyEngine' nor the names of its contributors
 *   may be used to endorse or promote products derived from this software
 *   without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
package jme3test.games;

import com.jme3.app.SimpleApplication;
import com.jme3.bullet.BulletAppState;
import com.jme3.bullet.PhysicsSpace;
import com.jme3.bullet.collision.PhysicsCollisionEvent;
import com.jme3.bullet.collision.PhysicsCollisionListener;
import com.jme3.bullet.collision.shapes.BoxCollisionShape;
import com.jme3.bullet.collision.shapes.CompoundCollisionShape;
import com.jme3.bullet.collision.shapes.SphereCollisionShape;
import com.jme3.bullet.control.GhostControl;
import com.jme3.bullet.control.RigidBodyControl;
import com.jme3.font.BitmapText;
import com.jme3.input.KeyInput;
import com.jme3.input.controls.ActionListener;
import com.jme3.input.controls.KeyTrigger;
import com.jme3.light.DirectionalLight;
import com.jme3.material.Material;
import com.jme3.math.ColorRGBA;
import com.jme3.math.FastMath;
import com.jme3.math.Quaternion;
import com.jme3.math.Vector3f;
import com.jme3.post.FilterPostProcessor;
import com.jme3.renderer.queue.RenderQueue.ShadowMode;
import com.jme3.scene.Geometry;
import com.jme3.scene.Node;
import com.jme3.scene.Spatial;
import com.jme3.scene.shape.Box;
import com.jme3.scene.shape.Sphere;
import com.jme3.shadow.DirectionalLightShadowFilter;
import java.util.concurrent.Callable;

/**
 * Physics based marble game.
 * 
 * @author SkidRunner (Mark E. Picknell)
 */
public class RollingTheMonkey extends SimpleApplication implements ActionListener, PhysicsCollisionListener {
    
    private static final String MESSAGE         = "Thanks for Playing!";
    private static final String INFO_MESSAGE    = "Collect all the spinning cubes!\nPress the 'R' key any time to reset!";
    
    private static final float PLAYER_DENSITY   = 1200;  // OLK(Java LOL) = 1200, STEEL = 8000, RUBBER = 1000
    private static final float PLAYER_REST      = 0.1f;     // OLK = 0.1f, STEEL = 0.0f, RUBBER = 1.0f I made these up.
    
    private static final float PLAYER_RADIUS    = 2.0f;
    private static final float PLAYER_ACCEL     = 1.0f;
    
    private static final float PICKUP_SIZE      = 0.5f;
    private static final float PICKUP_RADIUS    = 15.0f;
    private static final int   PICKUP_COUNT     = 16;
    private static final float PICKUP_SPEED     = 5.0f;
    
    private static final float PLAYER_VOLUME    = (FastMath.pow(PLAYER_RADIUS, 3) * FastMath.PI) / 3;   // V = 4/3 * PI * R pow 3
    private static final float PLAYER_MASS      = PLAYER_DENSITY * PLAYER_VOLUME;
    private static final float PLAYER_FORCE     = 80000 * PLAYER_ACCEL;  // F = M(4m diameter steel ball) * A
    private static final Vector3f PLAYER_START  = new Vector3f(0.0f, PLAYER_RADIUS * 2, 0.0f);
    
    private static final String INPUT_MAPPING_FORWARD   = "INPUT_MAPPING_FORWARD";
    private static final String INPUT_MAPPING_BACKWARD  = "INPUT_MAPPING_BACKWARD";
    private static final String INPUT_MAPPING_LEFT      = "INPUT_MAPPING_LEFT";
    private static final String INPUT_MAPPING_RIGHT     = "INPUT_MAPPING_RIGHT";
    private static final String INPUT_MAPPING_RESET     = "INPUT_MAPPING_RESET";
    
    public static void main(String[] args) {
        RollingTheMonkey app = new RollingTheMonkey();
        app.start();
    }
    
    private boolean keyForward;
    private boolean keyBackward;
    private boolean keyLeft;
    private boolean keyRight;
    private RigidBodyControl player;
    private int score;
    
    private Node pickUps;
    private BitmapText scoreText;
    private BitmapText messageText;
    
    @Override
    public void simpleInitApp() {
        flyCam.setEnabled(false);
        cam.setLocation(new Vector3f(0.0f, 12.0f, 21.0f));
        viewPort.setBackgroundColor(new ColorRGBA(0.2118f, 0.0824f, 0.6549f, 1.0f));
        
        // init physics
        BulletAppState bulletState = new BulletAppState();
        stateManager.attach(bulletState);
        PhysicsSpace space = bulletState.getPhysicsSpace();
        space.addCollisionListener(this);
        
        // create light
        DirectionalLight sun = new DirectionalLight();
        sun.setDirection((new Vector3f(-0.7f, -0.3f, -0.5f)).normalizeLocal());
        System.out.println("Here We Go: " + sun.getDirection());
        sun.setColor(ColorRGBA.White);
        rootNode.addLight(sun); 
        
        // create materials
        Material materialRed = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md");
        materialRed.setBoolean("UseMaterialColors",true);
        materialRed.setBoolean("HardwareShadows", true);
        materialRed.setColor("Diffuse", new ColorRGBA(0.9451f, 0.0078f, 0.0314f, 1.0f));
        materialRed.setColor("Specular", ColorRGBA.White);
        materialRed.setFloat("Shininess", 64.0f);
        
        Material materialGreen = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md");
        materialGreen.setBoolean("UseMaterialColors",true);
        materialGreen.setBoolean("HardwareShadows", true);
        materialGreen.setColor("Diffuse", new ColorRGBA(0.0431f, 0.7725f, 0.0078f, 1.0f));
        materialGreen.setColor("Specular", ColorRGBA.White);
        materialGreen.setFloat("Shininess", 64.0f);
        
        Material logoMaterial = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md");
        logoMaterial.setBoolean("UseMaterialColors",true);
        logoMaterial.setBoolean("HardwareShadows", true);
        logoMaterial.setTexture("DiffuseMap", assetManager.loadTexture("com/jme3/app/Monkey.png"));
        logoMaterial.setColor("Diffuse", ColorRGBA.White);
        logoMaterial.setColor("Specular", ColorRGBA.White);
        logoMaterial.setFloat("Shininess", 32.0f);
        
        Material materialYellow = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md");
        materialYellow.setBoolean("UseMaterialColors",true);
        materialYellow.setBoolean("HardwareShadows", true);
        materialYellow.setColor("Diffuse", new ColorRGBA(0.9529f, 0.7843f, 0.0078f, 1.0f));
        materialYellow.setColor("Specular", ColorRGBA.White);
        materialYellow.setFloat("Shininess", 64.0f);
        
        // create level spatial
        // TODO: create your own level mesh
        Node level = new Node("level");
        level.setShadowMode(ShadowMode.CastAndReceive);
        
        Geometry floor = new Geometry("floor", new Box(22.0f, 0.5f, 22.0f));
        floor.setShadowMode(ShadowMode.Receive);
        floor.setLocalTranslation(0.0f, -0.5f, 0.0f);
        floor.setMaterial(materialGreen);
        
        Geometry wallNorth = new Geometry("wallNorth", new Box(22.0f, 2.0f, 0.5f));
        wallNorth.setLocalTranslation(0.0f, 2.0f, 21.5f);
        wallNorth.setMaterial(materialRed);
        
        Geometry wallSouth = new Geometry("wallSouth", new Box(22.0f, 2.0f, 0.5f));
        wallSouth.setLocalTranslation(0.0f, 2.0f, -21.5f);
        wallSouth.setMaterial(materialRed);
        
        Geometry wallEast = new Geometry("wallEast", new Box(0.5f, 2.0f, 21.0f));
        wallEast.setLocalTranslation(-21.5f, 2.0f, 0.0f);
        wallEast.setMaterial(materialRed);
        
        Geometry wallWest = new Geometry("wallWest", new Box(0.5f, 2.0f, 21.0f));
        wallWest.setLocalTranslation(21.5f, 2.0f, 0.0f);
        wallWest.setMaterial(materialRed);
        
        level.attachChild(floor);
        level.attachChild(wallNorth);
        level.attachChild(wallSouth);
        level.attachChild(wallEast);
        level.attachChild(wallWest);
        
        // The easy way: level.addControl(new RigidBodyControl(0));
        
        // create level Shape
        CompoundCollisionShape levelShape = new CompoundCollisionShape();
        BoxCollisionShape floorShape = new BoxCollisionShape(new Vector3f(22.0f, 0.5f, 22.0f));
        BoxCollisionShape wallNorthShape = new BoxCollisionShape(new Vector3f(22.0f, 2.0f, 0.5f));
        BoxCollisionShape wallSouthShape = new BoxCollisionShape(new Vector3f(22.0f, 2.0f, 0.5f));
        BoxCollisionShape wallEastShape = new BoxCollisionShape(new Vector3f(0.5f, 2.0f, 21.0f));
        BoxCollisionShape wallWestShape = new BoxCollisionShape(new Vector3f(0.5f, 2.0f, 21.0f));
        
        levelShape.addChildShape(floorShape, new Vector3f(0.0f, -0.5f, 0.0f));
        levelShape.addChildShape(wallNorthShape, new Vector3f(0.0f, 2.0f, -21.5f));
        levelShape.addChildShape(wallSouthShape, new Vector3f(0.0f, 2.0f, 21.5f));
        levelShape.addChildShape(wallEastShape, new Vector3f(-21.5f, 2.0f, 0.0f));
        levelShape.addChildShape(wallEastShape, new Vector3f(21.5f, 2.0f, 0.0f));
        
        level.addControl(new RigidBodyControl(levelShape, 0));
        
        rootNode.attachChild(level);
        space.addAll(level);
        
        // create Pickups
        // TODO: create your own pickUp mesh
        //       create single mesh for all pickups
        // HINT: think particles.
        pickUps = new Node("pickups");
        
        Quaternion rotation = new Quaternion();
        Vector3f translation = new Vector3f(0.0f, PICKUP_SIZE * 1.5f, -PICKUP_RADIUS);
        int index = 0;
        float amount = FastMath.TWO_PI / PICKUP_COUNT;
        for(float angle = 0; angle < FastMath.TWO_PI; angle += amount) {
            Geometry pickUp = new Geometry("pickUp" + (index++), new Box(PICKUP_SIZE,PICKUP_SIZE, PICKUP_SIZE));
            pickUp.setShadowMode(ShadowMode.CastAndReceive);
            pickUp.setMaterial(materialYellow);
            pickUp.setLocalRotation(rotation.fromAngles(
                    FastMath.rand.nextFloat() * FastMath.TWO_PI,
                    FastMath.rand.nextFloat() * FastMath.TWO_PI,
                    FastMath.rand.nextFloat() * FastMath.TWO_PI));
            
            rotation.fromAngles(0.0f, angle, 0.0f);
            rotation.mult(translation, pickUp.getLocalTranslation());
            pickUps.attachChild(pickUp);
            
            pickUp.addControl(new GhostControl(new SphereCollisionShape(PICKUP_SIZE)));
            
            
            space.addAll(pickUp);
            //space.addCollisionListener(pickUpControl);
        }
        rootNode.attachChild(pickUps);
        
        // Create player
        // TODO: create your own player mesh
        Geometry playerGeometry = new Geometry("player", new Sphere(16, 32, PLAYER_RADIUS));
        playerGeometry.setShadowMode(ShadowMode.CastAndReceive);
        playerGeometry.setLocalTranslation(PLAYER_START.clone());
        playerGeometry.setMaterial(logoMaterial);
        
        // Store control for applying forces
        // TODO: create your own player control
        player = new RigidBodyControl(new SphereCollisionShape(PLAYER_RADIUS), PLAYER_MASS);
        player.setRestitution(PLAYER_REST);
        
        playerGeometry.addControl(player);
        
        rootNode.attachChild(playerGeometry);
        space.addAll(playerGeometry);
        
        inputManager.addMapping(INPUT_MAPPING_FORWARD, new KeyTrigger(KeyInput.KEY_UP)
                , new KeyTrigger(KeyInput.KEY_W));
        inputManager.addMapping(INPUT_MAPPING_BACKWARD, new KeyTrigger(KeyInput.KEY_DOWN)
                , new KeyTrigger(KeyInput.KEY_S));
        inputManager.addMapping(INPUT_MAPPING_LEFT, new KeyTrigger(KeyInput.KEY_LEFT)
                , new KeyTrigger(KeyInput.KEY_A));
        inputManager.addMapping(INPUT_MAPPING_RIGHT, new KeyTrigger(KeyInput.KEY_RIGHT)
                , new KeyTrigger(KeyInput.KEY_D));
        inputManager.addMapping(INPUT_MAPPING_RESET, new KeyTrigger(KeyInput.KEY_R));
        inputManager.addListener(this, INPUT_MAPPING_FORWARD, INPUT_MAPPING_BACKWARD
                , INPUT_MAPPING_LEFT, INPUT_MAPPING_RIGHT, INPUT_MAPPING_RESET);
        
        // init UI
        BitmapText infoText = new BitmapText(guiFont);
        infoText.setText(INFO_MESSAGE);
        guiNode.attachChild(infoText);
        
        scoreText = new BitmapText(guiFont);
        scoreText.setText("Score: 0");
        guiNode.attachChild(scoreText);
        
        messageText = new BitmapText(guiFont);
        messageText.setText(MESSAGE);
        messageText.setLocalScale(0.0f);
        guiNode.attachChild(messageText);
        
        infoText.setLocalTranslation(0.0f, cam.getHeight(), 0.0f);
        scoreText.setLocalTranslation((cam.getWidth() - scoreText.getLineWidth()) / 2.0f,
                scoreText.getLineHeight(), 0.0f);
        messageText.setLocalTranslation((cam.getWidth() - messageText.getLineWidth()) / 2.0f,
                (cam.getHeight() - messageText.getLineHeight()) / 2, 0.0f);
        
        // init shadows
        FilterPostProcessor processor = new FilterPostProcessor(assetManager);
        DirectionalLightShadowFilter filter = new DirectionalLightShadowFilter(assetManager, 2048, 1);
        filter.setLight(sun);
        processor.addFilter(filter);
        viewPort.addProcessor(processor);
        
    }
    
    @Override
    public void simpleUpdate(float tpf) {
        // Update and position the score
        scoreText.setText("Score: " + score);
        scoreText.setLocalTranslation((cam.getWidth() - scoreText.getLineWidth()) / 2.0f,
                scoreText.getLineHeight(), 0.0f);
        
        // Rotate all the pickups
        float pickUpSpeed = PICKUP_SPEED * tpf;
        for(Spatial pickUp : pickUps.getChildren()) {
            pickUp.rotate(pickUpSpeed, pickUpSpeed, pickUpSpeed);
        }
        
        Vector3f centralForce = new Vector3f();
        
        if(keyForward) centralForce.addLocal(cam.getDirection());
        if(keyBackward) centralForce.addLocal(cam.getDirection().negate());
        if(keyLeft) centralForce.addLocal(cam.getLeft());
        if(keyRight) centralForce.addLocal(cam.getLeft().negate());
        
        if(!Vector3f.ZERO.equals(centralForce)) {
            centralForce.setY(0);                   // stop ball from pushing down or flying up
            centralForce.normalizeLocal();          // normalize force
            centralForce.multLocal(PLAYER_FORCE);   // scale vector to force

            player.applyCentralForce(centralForce); // apply force to player
        }
        
        cam.lookAt(player.getPhysicsLocation(), Vector3f.UNIT_Y);
    }

    @Override
    public void onAction(String name, boolean isPressed, float tpf) {
        switch(name) {
            case INPUT_MAPPING_FORWARD:
                keyForward = isPressed;
                break;
            case INPUT_MAPPING_BACKWARD:
                keyBackward = isPressed;
                break;
            case INPUT_MAPPING_LEFT:
                keyLeft = isPressed;
                break;
            case INPUT_MAPPING_RIGHT:
                keyRight = isPressed;
                break;
            case INPUT_MAPPING_RESET:
                enqueue(new Callable<Void>() {
                    @Override
                    public Void call() {
                        reset();
                        return null;
                    }
                });
                break;
        }
    }
    @Override
    public void collision(PhysicsCollisionEvent event) {
        Spatial nodeA = event.getNodeA();
        Spatial nodeB = event.getNodeB();
        
        String nameA = nodeA == null ? "" : nodeA.getName();
        String nameB = nodeB == null ? "" : nodeB.getName();
        
        if(nameA.equals("player") && nameB.startsWith("pickUp")) {
            GhostControl pickUpControl = nodeB.getControl(GhostControl.class);
            if(pickUpControl != null && pickUpControl.isEnabled()) {
                pickUpControl.setEnabled(false);
                nodeB.removeFromParent();
                nodeB.setLocalScale(0.0f);
                score += 1;
                if(score >= PICKUP_COUNT) {
                    messageText.setLocalScale(1.0f);
                }
            }
        } else if(nameA.startsWith("pickUp") && nameB.equals("player")) {
            GhostControl pickUpControl = nodeA.getControl(GhostControl.class);
            if(pickUpControl != null && pickUpControl.isEnabled()) {
                pickUpControl.setEnabled(false);
                nodeA.setLocalScale(0.0f);
                score += 1;
                if(score >= PICKUP_COUNT) {
                    messageText.setLocalScale(1.0f);
                }
            }
        }
    }
    
    private void reset() {
        // Reset the pickups
        for(Spatial pickUp : pickUps.getChildren()) {
            GhostControl pickUpControl = pickUp.getControl(GhostControl.class);
            if(pickUpControl != null) {
                pickUpControl.setEnabled(true);
            }
            pickUp.setLocalScale(1.0f);
        }
        // Reset the player
        player.setPhysicsLocation(PLAYER_START.clone());
        player.setAngularVelocity(Vector3f.ZERO.clone());
        player.setLinearVelocity(Vector3f.ZERO.clone());
        // Reset the score
        score = 0;
        // Reset the message
        messageText.setLocalScale(0.0f);
    }
    
}