New Physics based jme3 example game.

jme3-examples/src/main/java/jme3test/games/RollingTheMonkey.java

@@ -0,0 +1,429 @@
+/*
+ * Copyright (c) 2009-2017 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 com.jme3.system.AppSettings;
+import com.jme3.util.TempVars;
+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 TITLE           = "Rolling The Monkey";
+    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) {
+        AppSettings settings = new AppSettings(true);
+        settings.setTitle(TITLE);
+        settings.setResolution(1440, 810);
+        settings.setFullscreen(false);
+        
+        RollingTheMonkey app = new RollingTheMonkey();
+        app.setShowSettings(false);
+        app.setSettings(settings);
+        app.start();
+    }
+    
+    private boolean keyForward;
+    private boolean keyBackward;
+    private boolean keyLeft;
+    private boolean keyRight;
+    
+    private PhysicsSpace space;
+    
+    private RigidBodyControl player;
+    private int score;
+    
+    private Node pickUps;
+    
+    BitmapText infoText;
+    BitmapText scoreText;
+    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);
+        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 ammount = FastMath.TWO_PI / PICKUP_COUNT;
+        for(float angle = 0; angle < FastMath.TWO_PI; angle += ammount) {
+            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
+        infoText = new BitmapText(guiFont, false);
+        infoText.setText(INFO_MESSAGE);
+        guiNode.attachChild(infoText);
+        
+        scoreText = new BitmapText(guiFont, false);
+        scoreText.setText("Score: 0");
+        guiNode.attachChild(scoreText);
+        
+        messageText = new BitmapText(guiFont, false);
+        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);
+        }
+        
+        TempVars tempVars = TempVars.get();
+        
+        Vector3f centralForce = tempVars.vect1.set(Vector3f.ZERO);
+        
+        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 pusing down or flying up
+            centralForce.normalizeLocal();          // normalize force
+            centralForce.multLocal(PLAYER_FORCE);   // scale vector to force
+
+            player.applyCentralForce(centralForce); // apply force to player
+        }
+        tempVars.release();
+        
+        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);
+    }
+    
+}