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;
}
}
}
@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;
}
}
}
}
}