Example usage for com.badlogic.gdx.math Vector2 setAngleRad

List of usage examples for com.badlogic.gdx.math Vector2 setAngleRad

  1. HOME
  2. Java
  3. com.badlogic.gdx
  4. com.badlogic.gdx.math.*
  5. Vector2
  6. setAngleRad

Introduction

In this page you can find the example usage for com.badlogic.gdx.math Vector2 setAngleRad.

Prototype

public Vector2 setAngleRad(float radians)

Source Link

Document

Sets the angle of the vector in radians relative to the x-axis, towards the positive y-axis (typically counter-clockwise).

Usage

From source file:headmade.arttag.Guard.java

License:Apache License

public void update(ArtTagScreen artTag, float delta) {
    if (body == null) {
        return;//  ww  w .  j a  v  a2 s . co m
    }
    isRunning = isAlert || isCautious;
    moveSpeed = isRunning ? maxMoveSpeed * runFactor
            : isSuspicious ? maxMoveSpeed * 0.75f : isHeardPlayer ? 0.5f : maxMoveSpeed;
    final Vector2 oldMoveVec = targetMoveVec.cpy();

    Vector2 targetPoint = null;
    Float distanceToPlayer = null;
    if (isLightOn) {
        for (final Fixture fixture : playerInView) {
            targetPoint = fixture.getBody().getWorldCenter().cpy();
            final Vector2 diffVec = body.getWorldCenter().cpy().sub(targetPoint);
            boolean seesPlayer = false;
            distanceToPlayer = diffVec.len();
            if (distanceToPlayer < 1f) {
                seesPlayer = true;
            } else {
                final Vector2 outOfBodyVec = diffVec.scl(fixture.getShape().getRadius() * 1.01f);
                targetPoint.add(outOfBodyVec);
                seesPlayer = light.contains(targetPoint.x, targetPoint.y);
            }
            // Gdx.app.log(TAG, light.contains(targetPoint.x, targetPoint.y) + " diffVec.length " + diffVec.len());
            if (seesPlayer) {
                // Gdx.app.log(TAG, "Guard sees player");
                playerLastSeenVec = fixture.getBody().getWorldCenter().cpy();
                if (!isAlert) {
                    Assets.instance.playSound(AssetSounds.whosThere);
                }
                isAlert = true;
                Player.instance.isSpotted = true;
                reactionTime = 0f;
            } else {
                if (isAlert) {
                    Assets.instance.playSound(AssetSounds.huh);
                    reactionTime = MAX_REACTION_TIME;
                    isCautious = true;
                }
                isAlert = false;
            }
        }
    }

    // handle hearing
    if (Player.instance.isRunning && (Player.instance.isMoveDown || Player.instance.isMoveUp
            || Player.instance.isMoveLeft || Player.instance.isMoveRight) && null != Player.instance.body) {
        if (distanceToPlayer == null) {
            distanceToPlayer = body.getWorldCenter().cpy().sub(Player.instance.body.getWorldCenter()).len();
        }
        if (distanceToPlayer < MAX_LIGHT_CONE_LENGTH * 0.9f) {
            sumDeltaSinceHeardPlayer = 0;

            final RayCastCallback callback = new RayCastCallback() {
                @Override
                public float reportRayFixture(Fixture fixture, Vector2 point, Vector2 normal, float fraction) {
                    // Gdx.app.log(TAG, "reportRayFixture " + point + " normal " + normal);
                    if (fixture.isSensor()) {
                        // Gdx.app.log(TAG, "Raycast ignoring sensor");
                        return 1;
                    }
                    if (body.equals(fixture.getBody())) {
                        // this is the guards body so there is nothing inbetween them
                        // Gdx.app.log(TAG, "Guard CAN see the point where the noise happened" + Player.instance.body.getWorldCenter());
                        // playerLastHeardVisibleVec = Player.instance.body.getWorldCenter().cpy();
                        return 1;
                    }
                    // Gdx.app.log(TAG, "Fall through");
                    isHearingObstructed = true;
                    return 0;
                }
            };
            try {
                isSuspicious = true;
                playerLastHeardVec = Player.instance.body.getWorldCenter().cpy();
                isHearingObstructed = false;
                // Gdx.app.log(TAG, "###################################");
                // Gdx.app.log(TAG, "Guard " + body.getWorldCenter());
                // Gdx.app.log(TAG, "Player " + playerLastHeardVec);
                artTag.world.rayCast(callback, playerLastHeardVec, body.getWorldCenter());
                if (!isHearingObstructed) {
                    playerLastHeardVisibleVec = Player.instance.body.getWorldCenter().cpy();
                }
            } catch (final Exception e) {
                Gdx.app.error(TAG, "Error Raycasting :(", e);
            }
        } else {
            sumDeltaSinceHeardPlayer += delta;
        }
    } else {
        sumDeltaSinceHeardPlayer += delta;
    }
    isHeardPlayer = playerLastHeardVisibleVec != null || sumDeltaSinceHeardPlayer < 3;

    if (isTouchingPlayerLightCone && Player.instance.isLightOn) {
        // isAlert = true;
    }

    // handle backToPath
    if (isAlert || isCautious || (isSuspicious && playerLastHeardVisibleVec != null)) {
        if (lastVisibleVecBackToPath == null) {
            lastVisibleVecBackToPath = body.getWorldCenter();
        }

        Vector2 checkPoint = path.get(currentPathIndex);
        if (backToPath.size > 0) {
            checkPoint = backToPath.get(backToPath.size - 1);
        }
        if (BODY_RADIUS < checkPoint.dst(body.getWorldCenter())) {
            // not touching checkpoint
            // Gdx.app.log(TAG, "Goard not touching checkpoint");
            final RayCastCallback callback = new RayCastCallback() {
                @Override
                public float reportRayFixture(Fixture fixture, Vector2 point, Vector2 normal, float fraction) {
                    // Gdx.app.log(TAG, "reportRayFixture adds new backToPathPoint" + lastVisibleVecBackToPath);
                    backToPath.add(lastVisibleVecBackToPath.cpy());
                    return 0;
                }
            };
            try {
                artTag.world.rayCast(callback, body.getWorldCenter(), checkPoint);
            } catch (final Exception e) {
                Gdx.app.error(TAG, "Error Raycasting :(", e);
            }
        }
        lastVisibleVecBackToPath = body.getWorldCenter();
    }

    // determine targetPoint
    if (isAlert && playerInView.size > 0 && Player.instance.body != null) {
        targetPoint = Player.instance.body.getWorldCenter();
    } else if (isCautious && playerLastSeenVec != null) {
        targetPoint = playerLastSeenVec;
        if (BODY_RADIUS / 10 > targetPoint.dst2(body.getPosition())) {
            // Lost player
            Assets.instance.playSound(AssetSounds.hm);
            Gdx.app.log(TAG, "Guard no longer cautious");
            isCautious = false;
            isSuspicious = true;
        }
    } else if (isSuspicious && playerLastHeardVisibleVec != null) {
        targetPoint = playerLastHeardVisibleVec;
        // Gdx.app.log(TAG, "Guard going to playerLastHeardVisibleVec");
        if (BODY_RADIUS / 10 > targetPoint.dst2(body.getPosition())) {
            // Lost player
            Assets.instance.playSound(AssetSounds.hm);
            Gdx.app.log(TAG, "Guard no longer suspicious");
            isSuspicious = false;
            playerLastHeardVisibleVec = null;
        }
    } else {
        lastVisibleVecBackToPath = null;
        if (backToPath.size > 0) {
            // following Path back to path
            targetPoint = backToPath.get(backToPath.size - 1);
            if (BODY_RADIUS / 10 > targetPoint.dst(body.getPosition())) {
                // Gdx.app.log(TAG, "Guard reached target back to path point " + targetPoint);
                backToPath.pop();
            }
        } else {
            // following path
            isSuspicious = false;
            targetPoint = path.get(currentPathIndex);
            if (BODY_RADIUS > targetPoint.dst(body.getPosition())) {
                // Gdx.app.log(TAG, "Guard reached target point " + targetPoint);
                currentPathIndex++;
                if (currentPathIndex >= path.size) {
                    currentPathIndex = 0;
                }
                targetPoint = path.get(currentPathIndex);
                // Gdx.app.log(TAG, "New target point " + targetPoint);
            }
        }

    }

    targetMoveVec = targetPoint.cpy().sub(body.getPosition());
    targetMoveVec.nor().scl(moveSpeed);

    if (MathUtils.isEqual(0f, oldMoveVec.angle(targetMoveVec))) {
        sumDeltaSinceMoveChange += delta;
    } else {
        // movment direction changed
        sumDeltaSinceMoveChange = 0f;
    }

    final float alpha = reactionTime > 0 ? MathUtils.clamp(sumDeltaSinceMoveChange / reactionTime, 0.1f, 1f)
            : 1f;
    body.setLinearVelocity(targetMoveVec);

    final Vector2 bodyRotVec = new Vector2(1f, 0f);
    bodyRotVec.setAngleRad(body.getAngle());
    float angleDiff;
    if (!isAlert && !isSuspicious && isHeardPlayer && null == playerLastHeardVisibleVec
            && null != playerLastHeardVec) {
        // look at last heard
        angleDiff = bodyRotVec.angleRad(playerLastHeardVec.cpy().sub(body.getWorldCenter()).rotate90(-1));
    } else {
        angleDiff = bodyRotVec.angleRad(targetMoveVec.cpy().rotate90(-1));
    }
    final float rotByRad = MathUtils.clamp(angleDiff, -(MAX_ROTATION_SPEED * delta) / reactionTime,
            MAX_ROTATION_SPEED * delta / reactionTime);
    // Gdx.app.log(TAG, "angleDiff: " + angleDiff + " rotByRad: " + rotByRad + " bodyRotVec: " + bodyRotVec + " - targetMoveVec:
    // "
    // + targetMoveVec);

    // is moving?
    if (!MathUtils.isEqual(targetMoveVec.len2(), 0f)) {
        if (Player.instance.body != null) {
            final float dist = body.getPosition().dst(Player.instance.body.getPosition());
            float volume = isRunning ? STEP_VOLUME * 2 : STEP_VOLUME;
            if (dist > 1) {
                volume = volume / dist;
            }
            sound.setVolume(stepSoundId, volume);
            sound.setPitch(stepSoundId, isRunning ? runFactor : 1f);
            body.setTransform(body.getPosition(), body.getAngle() + rotByRad);
        }
    } else {
        sound.setVolume(stepSoundId, 0f);
        sound.setPitch(stepSoundId, 1f);
    }

    light.setActive(isLightOn);
}

From source file:headmade.arttag.Player.java

License:Apache License

public void update(ArtTagScreen artTag, float delta) {
    deltaInLevel += delta;//from   w w  w  . j a  v  a2 s.  c  o  m

    if (body == null) {
        return;
    }

    if (hintText != null) {
        artTag.setInstruction(hintText);
    }

    final float moveSpeed = isRunning ? walkSpeed * runFactor : walkSpeed;
    final Vector2 oldMoveVec = targetMoveVec.cpy();
    targetMoveVec.x = 0f;
    targetMoveVec.y = 0f;
    if (isMoveDown) {
        targetMoveVec.add(0, -moveSpeed);
    }
    if (isMoveUp) {
        targetMoveVec.add(0, moveSpeed);
    }
    if (isMoveLeft) {
        targetMoveVec.add(-moveSpeed, 0);
    }
    if (isMoveRight) {
        targetMoveVec.add(moveSpeed, 0);
    }
    targetMoveVec.nor().scl(moveSpeed);

    if (MathUtils.isEqual(0f, oldMoveVec.angle(targetMoveVec))) {
        sumDeltaSinceMoveChange += delta;
    } else {
        // movment direction changed
        sumDeltaSinceMoveChange = 0f;
    }

    final float alpha = reactionTime > 0 ? MathUtils.clamp(sumDeltaSinceMoveChange / reactionTime, 0.1f, 1f)
            : 1f;
    // Gdx.app.log(TAG, "oldMoveVec " + oldMoveVec + " targetMoveVec" + targetMoveVec + "sumDeltaSinceMoveChange "
    // + sumDeltaSinceMoveChange + " - alpha " + alpha);
    // moveVec.interpolate(targetMoveVec, alpha, Interpolation.linear);
    body.setLinearVelocity(targetMoveVec);

    final Vector2 bodyRotVec = new Vector2(1f, 0f);
    bodyRotVec.setAngleRad(body.getAngle());
    final float angleDiff = bodyRotVec.angleRad(targetMoveVec.cpy().rotate90(-1));
    final float rotByRad = MathUtils.clamp(angleDiff, -(MAX_ROTATION_SPEED * delta) / reactionTime,
            MAX_ROTATION_SPEED * delta / reactionTime);
    // Gdx.app.log(TAG, "angleDiff: " + angleDiff + " rotByRad: " + rotByRad + " bodyRotVec: " + bodyRotVec + " - targetMoveVec:
    // "
    // + targetMoveVec);

    // is player moving?
    if (!MathUtils.isEqual(targetMoveVec.len2(), 0f)) {
        getStepSound().setVolume(stepSoundId, isRunning ? STEP_VOLUME * 2 : STEP_VOLUME);
        getStepSound().setPitch(stepSoundId, isRunning ? runFactor : 1f);
        body.setTransform(body.getPosition(), body.getAngle() + rotByRad);
    } else {
        getStepSound().setVolume(stepSoundId, 0f);
        getStepSound().setPitch(stepSoundId, 1f);
    }

    playerLight.setActive(isLightOn);

    imageAlpha = 0f;
    if (isLightOn) {
        for (final Fixture fixture : artInView) {
            final Vector2 point = fixture.getBody().getWorldCenter();
            final boolean isInLight = Player.instance.playerLight.contains(point.x, point.y);
            if (isInLight || isTouchingArt) {
                final float distance = point.cpy().dst(body.getWorldCenter());
                final float newAlpha = 1 - distance / (playerLightLength * PLAYERLIGHT_CONE_LENGTH_FACTOR);
                if (newAlpha > imageAlpha) {
                    // Gdx.app.log(TAG, "distance " + distance + " alpha " + newAlpha);
                    imageAlpha = newAlpha;
                    if (!((Art) fixture.getBody().getUserData()).equals(artTag.getCurrentArt())) {
                        artTag.setCurrentArt((Art) fixture.getBody().getUserData());
                    }
                    if (artTag.getCurrentArt().isScanned()) {
                        artTag.setInstruction(MSG_SCAN_3);
                    } else {
                        artTag.setInstruction(MSG_SCAN);
                    }
                }
            }
        }
    }

    if (inventory.size >= carryCacity) {
        artTag.setInstruction(MSG_INVENTORY_FULL);
    }
    if (isTouchingExit) {
        artTag.setInstruction(MSG_DOOR);
    }

    if (isScanning) {
        artTag.setInstruction(MSG_SCAN_2);
        if (!isTouchingArt || !isLightOn) {
            // abort scan
            isScanning = false;
            sumDeltaScan = 0f;
            // TODO cancel scan sound
        } else {
            scanProgress = Math.round(sumDeltaScan / scanTime * new Float(SCANNING_PROGRESS.length - 1));// (scanProgress + 1) %
            // SCANNING_PROGRESS.length;
            artTag.setResult(" Scanning " + SCANNING_PROGRESS[scanProgress]);
            sumDeltaScan += delta;
            if (sumDeltaScan > scanTime) {
                artTag.getCurrentArt().onScanFinished(artTag);
                artTag.setResult(artTag.getCurrentArt().resultText());
                isScanning = false;
                sumDeltaScan = 0f;
                // TODO cancel scan sound
                artTag.getCurrentArt().setScanned(true);
                artTag.setInstruction(MSG_SCAN_3);
                TagService.instance.tag(artTag.getCurrentArt(), artTag.jobDescription);
            }
        }
    }
    isAbleToScan = !isScanning && isTouchingArt && artTag.getCurrentArt() != null
            && !artTag.getCurrentArt().isScanned();
    isAbleToSteal = isTouchingArt && artTag.getCurrentArt() != null && artTag.getCurrentArt().isScanned()
            && inventory.size < carryCacity;
}