You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
191 lines
7.5 KiB
191 lines
7.5 KiB
/*
|
|
* Copyright (c) 2009-2012 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.helloworld;
|
|
|
|
import com.jme3.app.SimpleApplication;
|
|
import com.jme3.asset.plugins.ZipLocator;
|
|
import com.jme3.bullet.BulletAppState;
|
|
import com.jme3.bullet.collision.shapes.CapsuleCollisionShape;
|
|
import com.jme3.bullet.collision.shapes.CollisionShape;
|
|
import com.jme3.bullet.control.CharacterControl;
|
|
import com.jme3.bullet.control.RigidBodyControl;
|
|
import com.jme3.bullet.util.CollisionShapeFactory;
|
|
import com.jme3.input.KeyInput;
|
|
import com.jme3.input.controls.ActionListener;
|
|
import com.jme3.input.controls.KeyTrigger;
|
|
import com.jme3.light.AmbientLight;
|
|
import com.jme3.light.DirectionalLight;
|
|
import com.jme3.math.ColorRGBA;
|
|
import com.jme3.math.Vector3f;
|
|
import com.jme3.scene.Node;
|
|
import com.jme3.scene.Spatial;
|
|
|
|
/**
|
|
* Example 9 - How to make walls and floors solid.
|
|
* This collision code uses Physics and a custom Action Listener.
|
|
* @author normen, with edits by Zathras
|
|
*/
|
|
public class HelloCollision extends SimpleApplication
|
|
implements ActionListener {
|
|
|
|
private Spatial sceneModel;
|
|
private BulletAppState bulletAppState;
|
|
private RigidBodyControl landscape;
|
|
private CharacterControl player;
|
|
private Vector3f walkDirection = new Vector3f();
|
|
private boolean left = false, right = false, up = false, down = false;
|
|
|
|
//Temporary vectors used on each frame.
|
|
//They here to avoid instanciating new vectors on each frame
|
|
private Vector3f camDir = new Vector3f();
|
|
private Vector3f camLeft = new Vector3f();
|
|
|
|
public static void main(String[] args) {
|
|
HelloCollision app = new HelloCollision();
|
|
app.start();
|
|
}
|
|
|
|
public void simpleInitApp() {
|
|
/** Set up Physics */
|
|
bulletAppState = new BulletAppState();
|
|
stateManager.attach(bulletAppState);
|
|
//bulletAppState.getPhysicsSpace().enableDebug(assetManager);
|
|
|
|
// We re-use the flyby camera for rotation, while positioning is handled by physics
|
|
viewPort.setBackgroundColor(new ColorRGBA(0.7f, 0.8f, 1f, 1f));
|
|
flyCam.setMoveSpeed(100);
|
|
setUpKeys();
|
|
setUpLight();
|
|
|
|
// We load the scene from the zip file and adjust its size.
|
|
assetManager.registerLocator("town.zip", ZipLocator.class);
|
|
sceneModel = assetManager.loadModel("main.scene");
|
|
sceneModel.setLocalScale(2f);
|
|
|
|
// We set up collision detection for the scene by creating a
|
|
// compound collision shape and a static RigidBodyControl with mass zero.
|
|
CollisionShape sceneShape =
|
|
CollisionShapeFactory.createMeshShape((Node) sceneModel);
|
|
landscape = new RigidBodyControl(sceneShape, 0);
|
|
sceneModel.addControl(landscape);
|
|
|
|
// We set up collision detection for the player by creating
|
|
// a capsule collision shape and a CharacterControl.
|
|
// The CharacterControl offers extra settings for
|
|
// size, stepheight, jumping, falling, and gravity.
|
|
// We also put the player in its starting position.
|
|
CapsuleCollisionShape capsuleShape = new CapsuleCollisionShape(1.5f, 6f, 1);
|
|
player = new CharacterControl(capsuleShape, 0.05f);
|
|
player.setJumpSpeed(20);
|
|
player.setFallSpeed(30);
|
|
player.setGravity(30);
|
|
player.setPhysicsLocation(new Vector3f(0, 10, 0));
|
|
|
|
// We attach the scene and the player to the rootnode and the physics space,
|
|
// to make them appear in the game world.
|
|
rootNode.attachChild(sceneModel);
|
|
bulletAppState.getPhysicsSpace().add(landscape);
|
|
bulletAppState.getPhysicsSpace().add(player);
|
|
}
|
|
|
|
private void setUpLight() {
|
|
// We add light so we see the scene
|
|
AmbientLight al = new AmbientLight();
|
|
al.setColor(ColorRGBA.White.mult(1.3f));
|
|
rootNode.addLight(al);
|
|
|
|
DirectionalLight dl = new DirectionalLight();
|
|
dl.setColor(ColorRGBA.White);
|
|
dl.setDirection(new Vector3f(2.8f, -2.8f, -2.8f).normalizeLocal());
|
|
rootNode.addLight(dl);
|
|
}
|
|
|
|
/** We over-write some navigational key mappings here, so we can
|
|
* add physics-controlled walking and jumping: */
|
|
private void setUpKeys() {
|
|
inputManager.addMapping("Left", new KeyTrigger(KeyInput.KEY_A));
|
|
inputManager.addMapping("Right", new KeyTrigger(KeyInput.KEY_D));
|
|
inputManager.addMapping("Up", new KeyTrigger(KeyInput.KEY_W));
|
|
inputManager.addMapping("Down", new KeyTrigger(KeyInput.KEY_S));
|
|
inputManager.addMapping("Jump", new KeyTrigger(KeyInput.KEY_SPACE));
|
|
inputManager.addListener(this, "Left");
|
|
inputManager.addListener(this, "Right");
|
|
inputManager.addListener(this, "Up");
|
|
inputManager.addListener(this, "Down");
|
|
inputManager.addListener(this, "Jump");
|
|
}
|
|
|
|
/** These are our custom actions triggered by key presses.
|
|
* We do not walk yet, we just keep track of the direction the user pressed. */
|
|
public void onAction(String binding, boolean value, float tpf) {
|
|
if (binding.equals("Left")) {
|
|
if (value) { left = true; } else { left = false; }
|
|
} else if (binding.equals("Right")) {
|
|
if (value) { right = true; } else { right = false; }
|
|
} else if (binding.equals("Up")) {
|
|
if (value) { up = true; } else { up = false; }
|
|
} else if (binding.equals("Down")) {
|
|
if (value) { down = true; } else { down = false; }
|
|
} else if (binding.equals("Jump")) {
|
|
player.jump();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This is the main event loop--walking happens here.
|
|
* We check in which direction the player is walking by interpreting
|
|
* the camera direction forward (camDir) and to the side (camLeft).
|
|
* The setWalkDirection() command is what lets a physics-controlled player walk.
|
|
* We also make sure here that the camera moves with player.
|
|
*/
|
|
@Override
|
|
public void simpleUpdate(float tpf) {
|
|
camDir.set(cam.getDirection()).multLocal(0.6f);
|
|
camLeft.set(cam.getLeft()).multLocal(0.4f);
|
|
walkDirection.set(0, 0, 0);
|
|
if (left) {
|
|
walkDirection.addLocal(camLeft);
|
|
}
|
|
if (right) {
|
|
walkDirection.addLocal(camLeft.negate());
|
|
}
|
|
if (up) {
|
|
walkDirection.addLocal(camDir);
|
|
}
|
|
if (down) {
|
|
walkDirection.addLocal(camDir.negate());
|
|
}
|
|
player.setWalkDirection(walkDirection);
|
|
cam.setLocation(player.getPhysicsLocation());
|
|
}
|
|
}
|
|
|