VehicleControl.java

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package mygame.controls_states;

import com.jme3.bullet.BulletAppState;
import com.jme3.bullet.collision.PhysicsCollisionEvent;
import com.jme3.bullet.collision.PhysicsCollisionListener;
import com.jme3.bullet.collision.PhysicsSweepTestResult;
import com.jme3.bullet.collision.shapes.BoxCollisionShape;
import com.jme3.bullet.control.RigidBodyControl;
import com.jme3.collision.CollisionResults;
import com.jme3.input.InputManager;
import com.jme3.input.KeyInput;
import com.jme3.input.controls.AnalogListener;
import com.jme3.input.controls.KeyTrigger;
import com.jme3.math.Ray;
import com.jme3.math.Transform;
import com.jme3.math.Vector3f;
import com.jme3.renderer.RenderManager;
import com.jme3.renderer.ViewPort;
import com.jme3.scene.Geometry;
import com.jme3.scene.Spatial;
import com.jme3.scene.control.AbstractControl;
import com.jme3.scene.shape.Box;
import java.util.List;

/**
 *
 *
 */
public class VehicleController extends AbstractControl implements PhysicsCollisionListener {

    Vector3f movement = null;
    float rebound;
    float rotLeft, rotRight;
    float deltaTime;
    public int signal = 0;
    Geometry vehicle;
    InputManager inputManager;
    float forward;
    float backwards;
    float left;
    float right;
    float up;
    float down;
    Spatial terrain;
    int hitpoints = 100;
    RigidBodyControl vehiclePhysics;
    BulletAppState appState;
    BoxCollisionShape shape = new BoxCollisionShape(new Vector3f(10, 2, 10));

    public VehicleController(InputManager inputManager, Geometry vehicle, Spatial terrain, RigidBodyControl vehiclePhysics, BulletAppState appState) {

        this.appState = appState;
        this.vehiclePhysics = vehiclePhysics;
        this.terrain = terrain;
        this.vehicle = vehicle;
        this.inputManager = inputManager;

        initKeys();
    }

    AnalogListener analogListener = new AnalogListener() {
        @Override
        public void onAnalog(String name, float value, float tpf) {
            switch (name) {
                case "Forwards":

                    forward += 1;
                    break;
                case "Backwards":

                    backwards += 1;
                    break;
                case "Left":

                    left += 1;
                    break;
                case "Right":

                    right += 1;
                    break;
                case "Up":

                    up += 1;
                    break;
                case "Down":

                    down += 1;
                    break;

                case "RotRight":

                    rotRight += 0.25;
                    break;
                case "RotLeft":

                    rotLeft += 0.25;
                    break;

            }
        }

    };

    private void initKeys() {

        inputManager.addMapping("Forwards", new KeyTrigger(KeyInput.KEY_1));
        inputManager.addMapping("RotLeft", new KeyTrigger(KeyInput.KEY_2));
        inputManager.addMapping("RotRight", new KeyTrigger(KeyInput.KEY_3));

        inputManager.addListener(analogListener, "Forwards");
        inputManager.addListener(analogListener, "RotRight");
        inputManager.addListener(analogListener, "RotLeft");

    }

    @Override
    protected void controlUpdate(float tpf) {

        System.out.println(vehicle.getWorldRotation());

        if (up > 0) {
            Transform startPosUp = new Transform(vehicle.getWorldTranslation().add(new Vector3f(0, 1, 0)));
            Transform endPosUp = new Transform(vehicle.getWorldTranslation().add(new Vector3f(0, 1, 0)).add(new Vector3f(0, up, 0)));

            List<PhysicsSweepTestResult> sweepUp = appState.getPhysicsSpace().sweepTest(shape, startPosUp, endPosUp);

            if (sweepUp.isEmpty() && up > 1) {
                vehicle.move(0, up, 0);
            } else {
                up = 0;
                down += 5 * tpf;
            }
        }
        if (rotLeft > 0) {

            vehicle.rotate(0, -rotLeft * tpf, 0);
            movement = (vehicle.getWorldRotation().mult(Vector3f.UNIT_Z)).mult(1);
        }


        if (rotRight > 0) {

            vehicle.rotate(0, rotRight * tpf, 0);
            movement = (vehicle.getWorldRotation().mult(Vector3f.UNIT_Z)).mult(1);
        }


        if (down > 0) {
            Transform startPosDown = new Transform(vehicle.getWorldTranslation().add(new Vector3f(0, -1, 0)));
            Transform endPosDown = new Transform(vehicle.getWorldTranslation().add(new Vector3f(0, -1, 0)).add(new Vector3f(0, -down, 0)));

            List<PhysicsSweepTestResult> sweepDown = appState.getPhysicsSpace().sweepTest(shape, startPosDown, endPosDown);

            if (sweepDown.isEmpty()) {
                vehicle.move(0, -down, 0);
            } else {
                down = 0;

            }
        }
        if (forward > 0) {
            Transform startPosForward = new Transform(vehicle.getWorldTranslation().add(new Vector3f(0, 0, 5)));
            Transform endPosForward = new Transform(vehicle.getWorldTranslation().add(new Vector3f(0, 0, 5)).add(vehicle.getWorldRotation().mult(Vector3f.UNIT_Z)));

            List<PhysicsSweepTestResult> sweepForward = appState.getPhysicsSpace().sweepTest(shape, startPosForward, endPosForward);

            if (movement == null) {
                movement = (vehicle.getWorldRotation().mult(Vector3f.UNIT_Z)).mult(1);
            }

            if (sweepForward.isEmpty()) {

                vehicle.move(movement.x * forward * tpf, movement.y * forward * tpf, movement.z * forward * tpf);
            } else {
                if (vehicle.getWorldRotation().mult(Vector3f.UNIT_Z).z > 0) {
                    forward = 0;
                    backwards = 20;
                }

                if (vehicle.getWorldRotation().mult(Vector3f.UNIT_Z).z < 0) {
                    forward = 0;
                    rebound = 20;
                }

            }

        }

        if (backwards > 0) {
            Transform startPosBackwards = new Transform(vehicle.getWorldTranslation().add(new Vector3f(0, 0, -5)));
            Transform endPosBackwards = new Transform(vehicle.getWorldTranslation().add(new Vector3f(0, 0, -5)).add((vehicle.getWorldRotation().mult(new Vector3f(0, 0, -1)))));

            List<PhysicsSweepTestResult> sweepForward = appState.getPhysicsSpace().sweepTest(shape, startPosBackwards, endPosBackwards);

            if (sweepForward.isEmpty()) {
                vehicle.move(-movement.x * backwards * tpf, -movement.y * backwards * tpf, -movement.z * backwards * tpf);
            } else {
                backwards = 0;
                forward = 20;
            }
        }

        if (rebound > 0) {
            Transform startPosBackwards = new Transform(vehicle.getWorldTranslation().add(new Vector3f(0, 0, 5)));
            Transform endPosBackwards = new Transform(vehicle.getWorldTranslation().add(new Vector3f(0, 0, 5)).add((vehicle.getWorldRotation().mult(Vector3f.UNIT_Z))));

            List<PhysicsSweepTestResult> sweepForward = appState.getPhysicsSpace().sweepTest(shape, startPosBackwards, endPosBackwards);

            if (sweepForward.isEmpty()) {
                vehicle.move(movement.x * rebound * tpf, movement.y * rebound * tpf, movement.z * rebound * tpf);
            } else {
                rebound = 0;
                backwards = 20;
            }
        }

        if (rebound > 0) {
            rebound -= 10 * tpf;
        }

        if (rebound < 0) {
            rebound = 0;
        }
//
////        if (forward > 0) {
////            forward -= 10 * tpf;
////        }
////
////        if (forward < 0) {
////            forward = 0;
////        }
        if (backwards > 0) {
            backwards -= 10 * tpf;
        }

        if (backwards < 0) {
            backwards = 10 * tpf;
        }

        if (up > 0) {
            up -= 10 * tpf;
        }

        if (up < 0) {
            up = 0;
        }

        if (down > 0) {
            down -= 10 * tpf;
        }

        if (down < 0) {
            down = 0;
        }

        if (rotLeft > 0) {
            rotLeft -= 10 * tpf;
        }

        if (rotLeft < 0) {
            rotLeft = 0 * tpf;

        }

        if (rotRight > 0) {
            rotRight -= 10 * tpf;
        }

        if (rotRight < 0) {
            rotRight = 0 * tpf;

        }

    }

    @Override
    protected void controlRender(RenderManager rm, ViewPort vp) {

    }

    @Override
    public void collision(PhysicsCollisionEvent event) {

    }
}