private void climb(
      final CharacterStateEvent state, CharacterMoveInputEvent input, Vector3f desiredVelocity) {
    if (state.getClimbDirection() == null) {
      return;
    }
    Vector3f tmp;

    Vector3i climbDir3i = state.getClimbDirection();
    Vector3f climbDir3f = climbDir3i.toVector3f();

    Quat4f rotation = new Quat4f(TeraMath.DEG_TO_RAD * state.getYaw(), 0, 0);
    tmp = new Vector3f(0.0f, 0.0f, -1.0f);
    QuaternionUtil.quatRotate(rotation, tmp, tmp);
    float angleToClimbDirection = tmp.angle(climbDir3f);

    boolean clearMovementToDirection = !state.isGrounded();

    // facing the ladder or looking down or up
    if (angleToClimbDirection < Math.PI / 4.0 || Math.abs(input.getPitch()) > 60f) {
      float pitchAmount = state.isGrounded() ? 45f : 90f;
      float pitch = input.getPitch() > 30f ? pitchAmount : -pitchAmount;
      rotation = new Quat4f(TeraMath.DEG_TO_RAD * state.getYaw(), TeraMath.DEG_TO_RAD * pitch, 0);
      QuaternionUtil.quatRotate(rotation, desiredVelocity, desiredVelocity);

      // looking sidewards from ladder
    } else if (angleToClimbDirection < Math.PI * 3.0 / 4.0) {
      float rollAmount = state.isGrounded() ? 45f : 90f;
      tmp = new Vector3f();
      QuaternionUtil.quatRotate(rotation, climbDir3f, tmp);
      float leftOrRight = tmp.x;
      float plusOrMinus = (leftOrRight < 0f ? -1.0f : 1.0f) * (climbDir3i.x != 0 ? -1.0f : 1.0f);
      rotation =
          new Quat4f(
              TeraMath.DEG_TO_RAD * input.getYaw(),
              0f,
              TeraMath.DEG_TO_RAD * rollAmount * plusOrMinus);
      QuaternionUtil.quatRotate(rotation, desiredVelocity, desiredVelocity);

      // facing away from ladder
    } else {
      rotation = new Quat4f(TeraMath.DEG_TO_RAD * state.getYaw(), 0, 0);
      QuaternionUtil.quatRotate(rotation, desiredVelocity, desiredVelocity);
      clearMovementToDirection = false;
    }

    // clear out movement towards or away from the ladder
    if (clearMovementToDirection) {
      if (climbDir3i.x != 0) {
        desiredVelocity.x = 0f;
      }
      if (climbDir3i.z != 0) {
        desiredVelocity.z = 0f;
      }
    }
  }
Example #2
0
  @ReceiveEvent
  public void onActivate(
      ActivateEvent event, EntityRef entity, TunnelActionComponent tunnelActionComponent) {

    Vector3f dir = new Vector3f(event.getDirection());
    dir.scale(4.0f);
    Vector3f origin = new Vector3f(event.getOrigin());
    origin.add(dir);
    Vector3i blockPos = new Vector3i();

    int particleEffects = 0;
    int blockCounter = tunnelActionComponent.maxDestroyedBlocks;
    for (int s = 0; s <= tunnelActionComponent.maxTunnelDepth; s++) {
      origin.add(dir);
      if (!worldProvider.isBlockRelevant(origin)) {
        break;
      }

      for (int i = 0; i < tunnelActionComponent.maxRaysCast; i++) {
        Vector3f direction = random.nextVector3f();
        Vector3f impulse = new Vector3f(direction);
        impulse.scale(tunnelActionComponent.explosiveForce);

        for (int j = 0; j < 3; j++) {
          Vector3f target = new Vector3f(origin);

          target.x += direction.x * j;
          target.y += direction.y * j;
          target.z += direction.z * j;

          blockPos.set((int) target.x, (int) target.y, (int) target.z);

          Block currentBlock = worldProvider.getBlock(blockPos);

          if (currentBlock.isDestructible()) {
            if (particleEffects < tunnelActionComponent.maxParticalEffects) {
              EntityBuilder builder = entityManager.newBuilder("engine:smokeExplosion");
              builder.getComponent(LocationComponent.class).setWorldPosition(target);
              builder.build();
              particleEffects++;
            }
            if (random.nextFloat() < tunnelActionComponent.thoroughness) {
              EntityRef blockEntity = blockEntityRegistry.getEntityAt(blockPos);
              blockEntity.send(
                  new DoDamageEvent(
                      tunnelActionComponent.damageAmount, tunnelActionComponent.damageType));
            }

            blockCounter--;
          }

          if (blockCounter <= 0) {
            return;
          }
        }
      }
    }
    // No blocks were destroyed, so cancel the event
    if (blockCounter == tunnelActionComponent.maxDestroyedBlocks) {
      event.consume();
    }
  }
  private void walk(
      final CharacterMovementComponent movementComp,
      final CharacterStateEvent state,
      CharacterMoveInputEvent input,
      EntityRef entity) {
    Vector3f desiredVelocity = new Vector3f(input.getMovementDirection());

    float lengthSquared = desiredVelocity.lengthSquared();

    // If the length of desired movement is > 1, normalise it to prevent movement being faster than
    // allowed.
    // (Desired velocity < 1 is allowed, as the character may wish to walk/crawl/otherwise move
    // slowly)
    if (lengthSquared > 1) {
      desiredVelocity.normalize();
    }
    desiredVelocity.scale(movementComp.speedMultiplier);

    float maxSpeed = getMaxSpeed(entity, movementComp);
    if (input.isRunning()) {
      maxSpeed *= movementComp.runFactor;
    }

    // As we can't use it, remove the y component of desired movement while maintaining speed.
    if (movementComp.grounded && desiredVelocity.y != 0) {
      float speed = desiredVelocity.length();
      desiredVelocity.y = 0;
      if (desiredVelocity.x != 0 || desiredVelocity.z != 0) {
        desiredVelocity.normalize();
        desiredVelocity.scale(speed);
      }
    }
    desiredVelocity.scale(maxSpeed);

    if (movementComp.mode == MovementMode.CLIMBING) {
      climb(state, input, desiredVelocity);
    }

    // Modify velocity towards desired, up to the maximum rate determined by friction
    Vector3f velocityDiff = new Vector3f(desiredVelocity);
    velocityDiff.sub(state.getVelocity());
    velocityDiff.scale(Math.min(movementComp.mode.scaleInertia * input.getDelta(), 1.0f));
    Vector3f endVelocity = new Vector3f(state.getVelocity());
    endVelocity.x += velocityDiff.x;
    endVelocity.z += velocityDiff.z;
    if (movementComp.mode.scaleGravity == 0) {
      // apply the velocity without gravity
      endVelocity.y += velocityDiff.y;
    } else if (movementComp.mode.applyInertiaToVertical) {
      endVelocity.y +=
          Math.max(
              -TERMINAL_VELOCITY,
              velocityDiff.y - (GRAVITY * movementComp.mode.scaleGravity) * input.getDelta());
    } else {
      endVelocity.y =
          Math.max(
              -TERMINAL_VELOCITY,
              state.getVelocity().y
                  - (GRAVITY * movementComp.mode.scaleGravity) * input.getDelta());
    }
    Vector3f moveDelta = new Vector3f(endVelocity);
    moveDelta.scale(input.getDelta());
    CharacterCollider collider =
        movementComp.mode.useCollision ? physics.getCharacterCollider(entity) : null;
    MoveResult moveResult =
        move(
            state.getPosition(),
            moveDelta,
            (state.getMode() != MovementMode.CLIMBING
                    && state.isGrounded()
                    && movementComp.mode.canBeGrounded)
                ? movementComp.stepHeight
                : 0,
            movementComp.slopeFactor,
            collider);
    Vector3f distanceMoved = new Vector3f(moveResult.getFinalPosition());
    distanceMoved.sub(state.getPosition());
    state.getPosition().set(moveResult.getFinalPosition());
    if (input.isFirstRun() && distanceMoved.length() > 0) {
      entity.send(new MovedEvent(distanceMoved, state.getPosition()));
    }

    if (moveResult.isBottomHit()) {
      if (!state.isGrounded() && movementComp.mode.canBeGrounded) {
        if (input.isFirstRun()) {
          Vector3f landVelocity = new Vector3f(state.getVelocity());
          landVelocity.y +=
              (distanceMoved.y / moveDelta.y) * (endVelocity.y - state.getVelocity().y);
          logger.debug("Landed at " + landVelocity);
          entity.send(new VerticalCollisionEvent(state.getPosition(), landVelocity));
        }
        state.setGrounded(true);
      }
      endVelocity.y = 0;

      // Jumping is only possible, if the entity is standing on ground
      if (input.isJumpRequested()) {
        state.setGrounded(false);
        endVelocity.y += movementComp.jumpSpeed;
        if (input.isFirstRun()) {
          entity.send(new JumpEvent());
        }
      }
    } else {
      if (moveResult.isTopHit() && endVelocity.y > 0) {
        endVelocity.y = -0.5f * endVelocity.y;
      }
      state.setGrounded(false);
    }
    state.getVelocity().set(endVelocity);
    if (input.isFirstRun() && moveResult.isHorizontalHit()) {
      entity.send(new HorizontalCollisionEvent(state.getPosition(), state.getVelocity()));
    }
    if (state.isGrounded()
        || movementComp.mode == MovementMode.SWIMMING
        || movementComp.mode == MovementMode.DIVING) {
      state.setFootstepDelta(
          state.getFootstepDelta()
              + distanceMoved.length() / movementComp.distanceBetweenFootsteps);
      if (state.getFootstepDelta() > 1) {
        state.setFootstepDelta(state.getFootstepDelta() - 1);
        if (input.isFirstRun()) {
          switch (movementComp.mode) {
            case WALKING:
              entity.send(new FootstepEvent());
              break;
            case DIVING:
            case SWIMMING:
              entity.send(new SwimStrokeEvent(worldProvider.getBlock(state.getPosition())));
              break;
          }
        }
      }
    }
  }