Esempio n. 1
0
  @Override
  public void controlUpdate(float tpf) {
    if (characterControl == null) {
      return;
    }
    String currentAnim = getCurrentAnimationName();
    if (currentAnim != null && currentAnim.equals("StandUpGround")) return;

    if (!characterControl.onGround()) {
      /*if(!"JumpLoop".equals(torsoChannel.getAnimationName()))
      torsoChannel.setAnim("JumpLoop");
      if(!"JumpLoop".equals(feetChannel.getAnimationName()))
      feetChannel.setAnim("JumpLoop");
      return;*/
    }

    if (characterControl.getWalkDirection().length() > 0) {
      if (!"WalkForward".equals(headChannel.getAnimationName())) {
        headChannel.setAnim("WalkForward", 0.5f);
      }
    } else {
      if (!"IdleStanding".equals(headChannel.getAnimationName())) {
        headChannel.setAnim("IdleStanding", 0.5f);
      }
    }
  }
Esempio n. 2
0
 @Override
 public void onAnimCycleDone(AnimControl ac, AnimChannel ac1, String string) {
   if (string.equals("StandUpGround")) {
     characterControl.setWalkDirection(Vector3f.ZERO);
     characterControl.setEnabled(true);
     headChannel.setAnim("IdleStanding", 0.5f);
     // Vector3f center = animControl.getSpatial().getWorldBound().getCenter();
     animControl.getSpatial().setLocalTranslation(new Vector3f(0f, -1f, 0f));
     // animControl.getSpatial().getParent().setLocalTranslation(animControl.getSpatial().getParent().getLocalTranslation().add(0f,0.1f,0f));
   }
 }
Esempio n. 3
0
 private void initPlayer() {
   playerControl =
       new CharacterControl(
           new CapsuleCollisionShape(
               (cubesSettings.getBlockSize() / 2), cubesSettings.getBlockSize() * 2),
           0.05f);
   playerControl.setJumpSpeed(25);
   playerControl.setFallSpeed(20);
   playerControl.setGravity(70);
   playerControl.setPhysicsLocation(
       new Vector3f(5, terrainSize.getY() + 5, 5).mult(cubesSettings.getBlockSize()));
   bulletAppState.getPhysicsSpace().add(playerControl);
 }
 /**
  * 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();
   }
 }
 @Override
 public void onAction(final String name, final boolean keyPressed, final float tpf) {
   if (name.equals("Lefts")) {
     if (keyPressed) {
       TerrainGridTileLoaderTest.this.left = true;
     } else {
       TerrainGridTileLoaderTest.this.left = false;
     }
   } else if (name.equals("Rights")) {
     if (keyPressed) {
       TerrainGridTileLoaderTest.this.right = true;
     } else {
       TerrainGridTileLoaderTest.this.right = false;
     }
   } else if (name.equals("Ups")) {
     if (keyPressed) {
       TerrainGridTileLoaderTest.this.up = true;
     } else {
       TerrainGridTileLoaderTest.this.up = false;
     }
   } else if (name.equals("Downs")) {
     if (keyPressed) {
       TerrainGridTileLoaderTest.this.down = true;
     } else {
       TerrainGridTileLoaderTest.this.down = false;
     }
   } else if (name.equals("Jumps")) {
     TerrainGridTileLoaderTest.this.player3.jump();
   } else if (name.equals("pick") && keyPressed) {
     // Terrain picked = terrain.getTerrainAt(player3.getPhysicsLocation());
     Terrain picked = terrain.getTerrainAtCell(terrain.getCurrentCell());
     System.out.println(
         "** cell " + player3.getPhysicsLocation() + " picked terrain: " + picked);
   }
 }
 /**
  * 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());
 }
Esempio n. 7
0
 @Override
 public void onAction(String actionName, boolean value, float lastTimePerFrame) {
   if (actionName.equals("move_up")) {
     arrowKeys[0] = value;
   } else if (actionName.equals("move_right")) {
     arrowKeys[1] = value;
   } else if (actionName.equals("move_left")) {
     arrowKeys[3] = value;
   } else if (actionName.equals("move_down")) {
     arrowKeys[2] = value;
   } else if (actionName.equals("jump")) {
     playerControl.jump();
   }
 }
Esempio n. 8
0
 @Override
 public void simpleUpdate(float lastTimePerFrame) {
   float playerMoveSpeed = ((cubesSettings.getBlockSize() * 6.5f) * lastTimePerFrame);
   Vector3f camDir = cam.getDirection().mult(playerMoveSpeed);
   Vector3f camLeft = cam.getLeft().mult(playerMoveSpeed);
   walkDirection.set(0, 0, 0);
   if (arrowKeys[0]) {
     walkDirection.addLocal(camDir);
   }
   if (arrowKeys[1]) {
     walkDirection.addLocal(camLeft.negate());
   }
   if (arrowKeys[2]) {
     walkDirection.addLocal(camDir.negate());
   }
   if (arrowKeys[3]) {
     walkDirection.addLocal(camLeft);
   }
   walkDirection.setY(0);
   walkDirection.normalize();
   walkDirection.multLocal(lastTimePerFrame * 10);
   playerControl.setWalkDirection(walkDirection);
   cam.setLocation(playerControl.getPhysicsLocation());
 }
  @Override
  public void simpleInitApp() {
    /** Set up Physics */
    bulletAppState = new BulletAppState();
    stateManager.attach(bulletAppState);
    // bulletAppState.getPhysicsSpace().enableDebug(assetManager);

    flyCam.setMoveSpeed(100);
    setUpKeys();

    /** 1. Create terrain material and load four textures into it. */
    mat_terrain = new Material(assetManager, "Common/MatDefs/Terrain/Terrain.j3md");

    /** 1.1) Add ALPHA map (for red-blue-green coded splat textures) */
    mat_terrain.setTexture(
        "Alpha", assetManager.loadTexture("Textures/Terrain/splat/alphamap.png"));

    /** 1.2) Add GRASS texture into the red layer (Tex1). */
    Texture grass = assetManager.loadTexture("Textures/Terrain/splat/grass.jpg");
    grass.setWrap(WrapMode.Repeat);
    mat_terrain.setTexture("Tex1", grass);
    mat_terrain.setFloat("Tex1Scale", 64f);

    /** 1.3) Add DIRT texture into the green layer (Tex2) */
    Texture dirt = assetManager.loadTexture("Textures/Terrain/splat/dirt.jpg");
    dirt.setWrap(WrapMode.Repeat);
    mat_terrain.setTexture("Tex2", dirt);
    mat_terrain.setFloat("Tex2Scale", 32f);

    /** 1.4) Add ROAD texture into the blue layer (Tex3) */
    Texture rock = assetManager.loadTexture("Textures/Terrain/splat/road.jpg");
    rock.setWrap(WrapMode.Repeat);
    mat_terrain.setTexture("Tex3", rock);
    mat_terrain.setFloat("Tex3Scale", 128f);

    /** 2. Create the height map */
    AbstractHeightMap heightmap = null;
    Texture heightMapImage = assetManager.loadTexture("Textures/Terrain/splat/mountains512.png");
    heightmap = new ImageBasedHeightMap(heightMapImage.getImage());
    heightmap.load();

    /**
     * 3. We have prepared material and heightmap. Now we create the actual terrain: 3.1) Create a
     * TerrainQuad and name it "my terrain". 3.2) A good value for terrain tiles is 64x64 -- so we
     * supply 64+1=65. 3.3) We prepared a heightmap of size 512x512 -- so we supply 512+1=513. 3.4)
     * As LOD step scale we supply Vector3f(1,1,1). 3.5) We supply the prepared heightmap itself.
     */
    terrain = new TerrainQuad("my terrain", 65, 513, heightmap.getHeightMap());

    /** 4. We give the terrain its material, position & scale it, and attach it. */
    terrain.setMaterial(mat_terrain);
    terrain.setLocalTranslation(0, -100, 0);
    terrain.setLocalScale(2f, 1f, 2f);
    rootNode.attachChild(terrain);

    /** 5. The LOD (level of detail) depends on were the camera is: */
    List<Camera> cameras = new ArrayList<Camera>();
    cameras.add(getCamera());
    TerrainLodControl control = new TerrainLodControl(terrain, cameras);
    terrain.addControl(control);

    /** 6. Add physics: */
    /* We set up collision detection for the scene by creating a static
     * RigidBodyControl with mass zero.*/
    terrain.addControl(new RigidBodyControl(0));

    // 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(-10, 10, 10));

    // We attach the scene and the player to the rootnode and the physics space,
    // to make them appear in the game world.
    bulletAppState.getPhysicsSpace().add(terrain);
    bulletAppState.getPhysicsSpace().add(player);
  }
  @Override
  public void simpleInitApp() {
    File file = new File("TerrainGridTestData.zip");
    if (!file.exists()) {
      assetManager.registerLocator(
          "http://jmonkeyengine.googlecode.com/files/TerrainGridTestData.zip",
          HttpZipLocator.class);
    } else {
      assetManager.registerLocator("TerrainGridTestData.zip", ZipLocator.class);
    }

    this.flyCam.setMoveSpeed(100f);
    ScreenshotAppState state = new ScreenshotAppState();
    this.stateManager.attach(state);

    // TERRAIN TEXTURE material
    this.mat_terrain =
        new Material(this.assetManager, "Common/MatDefs/Terrain/HeightBasedTerrain.j3md");

    // Parameters to material:
    // regionXColorMap: X = 1..4 the texture that should be appliad to state X
    // regionX: a Vector3f containing the following information:
    //      regionX.x: the start height of the region
    //      regionX.y: the end height of the region
    //      regionX.z: the texture scale for the region
    //  it might not be the most elegant way for storing these 3 values, but it packs the data
    // nicely :)
    // slopeColorMap: the texture to be used for cliffs, and steep mountain sites
    // slopeTileFactor: the texture scale for slopes
    // terrainSize: the total size of the terrain (used for scaling the texture)
    // GRASS texture
    Texture grass = this.assetManager.loadTexture("Textures/Terrain/splat/grass.jpg");
    grass.setWrap(WrapMode.Repeat);
    this.mat_terrain.setTexture("region1ColorMap", grass);
    this.mat_terrain.setVector3("region1", new Vector3f(88, 200, this.grassScale));

    // DIRT texture
    Texture dirt = this.assetManager.loadTexture("Textures/Terrain/splat/dirt.jpg");
    dirt.setWrap(WrapMode.Repeat);
    this.mat_terrain.setTexture("region2ColorMap", dirt);
    this.mat_terrain.setVector3("region2", new Vector3f(0, 90, this.dirtScale));

    // ROCK texture
    Texture rock = this.assetManager.loadTexture("Textures/Terrain/Rock2/rock.jpg");
    rock.setWrap(WrapMode.Repeat);
    this.mat_terrain.setTexture("region3ColorMap", rock);
    this.mat_terrain.setVector3("region3", new Vector3f(198, 260, this.rockScale));

    this.mat_terrain.setTexture("region4ColorMap", rock);
    this.mat_terrain.setVector3("region4", new Vector3f(198, 260, this.rockScale));

    this.mat_terrain.setTexture("slopeColorMap", rock);
    this.mat_terrain.setFloat("slopeTileFactor", 32);

    this.mat_terrain.setFloat("terrainSize", 129);
    // quad.getHeightMap(), terrain.getLocalScale()), 0
    AssetTileLoader grid = new AssetTileLoader(assetManager, "testgrid", "TerrainGrid");
    this.terrain = new TerrainGrid("terrain", 65, 257, grid);

    this.terrain.setMaterial(this.mat_terrain);
    this.terrain.setLocalTranslation(0, 0, 0);
    this.terrain.setLocalScale(2f, 1f, 2f);
    //        try {
    //            BinaryExporter.getInstance().save(terrain, new
    // File("/Users/normenhansen/Documents/Code/jme3/engine/src/test-data/TerrainGrid/"
    //                    + "TerrainGrid.j3o"));
    //        } catch (IOException ex) {
    //            Logger.getLogger(TerrainFractalGridTest.class.getName()).log(Level.SEVERE, null,
    // ex);
    //        }

    this.rootNode.attachChild(this.terrain);

    TerrainLodControl control = new TerrainGridLodControl(this.terrain, getCamera());
    control.setLodCalculator(new DistanceLodCalculator(65, 2.7f)); // patch size, and a multiplier
    this.terrain.addControl(control);

    final BulletAppState bulletAppState = new BulletAppState();
    stateManager.attach(bulletAppState);

    this.getCamera().updateLocation(new Vector3f(0, 256, 0));

    this.viewPort.setBackgroundColor(new ColorRGBA(0.7f, 0.8f, 1f, 1f));

    if (usePhysics) {
      CapsuleCollisionShape capsuleShape = new CapsuleCollisionShape(0.5f, 1.8f, 1);
      player3 = new CharacterControl(capsuleShape, 0.5f);
      player3.setJumpSpeed(20);
      player3.setFallSpeed(10);
      player3.setGravity(10);

      player3.setPhysicsLocation(
          new Vector3f(cam.getCamera().getLocation().x, 256, cam.getCamera().getLocation().z));

      bulletAppState.getPhysicsSpace().add(player3);

      terrain.addListener(
          new TerrainGridListener() {

            public void gridMoved(Vector3f newCenter) {}

            public void tileAttached(Vector3f cell, TerrainQuad quad) {
              while (quad.getControl(RigidBodyControl.class) != null) {
                quad.removeControl(RigidBodyControl.class);
              }
              quad.addControl(
                  new RigidBodyControl(
                      new HeightfieldCollisionShape(quad.getHeightMap(), terrain.getLocalScale()),
                      0));
              bulletAppState.getPhysicsSpace().add(quad);
            }

            public void tileDetached(Vector3f cell, TerrainQuad quad) {
              if (quad.getControl(RigidBodyControl.class) != null) {
                bulletAppState.getPhysicsSpace().remove(quad);
                quad.removeControl(RigidBodyControl.class);
              }
            }
          });
    }

    this.initKeys();
  }