Exemplo n.º 1
0
  private void playMovementSound() {
    if (_godMode) return;

    if ((MathHelper.fastAbs(_velocity.x) > 0.01 || MathHelper.fastAbs(_velocity.z) > 0.01)
        && _touchingGround) {
      if (_currentFootstepSound == null) {
        Vector3d playerDirection = directionOfReferencePoint();
        _currentFootstepSound =
            _footstepSounds[
                MathHelper.fastAbs(_parent.getWorldProvider().getRandom().randomInt()) % 5];

        _currentFootstepSound.playAsSoundEffect(
            0.7f
                + (float) MathHelper.fastAbs(_parent.getWorldProvider().getRandom().randomDouble())
                    * 0.3f,
            0.2f
                + (float) MathHelper.fastAbs(_parent.getWorldProvider().getRandom().randomDouble())
                    * 0.2f,
            false,
            (float) playerDirection.x,
            (float) playerDirection.y,
            (float) playerDirection.z);
      } else {
        long timeDiff = Terasology.getInstance().getTime() - _lastFootStepSoundPlayed;

        if (!_currentFootstepSound.isPlaying()
            && timeDiff > 400 / (_activeWalkingSpeed / _walkingSpeed)) {
          _lastFootStepSoundPlayed = Terasology.getInstance().getTime();
          _currentFootstepSound = null;
        }
      }
    }
  }
  @Override
  public boolean step() {
    EntityManager entityManager = context.get(EntityManager.class);
    WorldRenderer worldRenderer = context.get(WorldRenderer.class);

    Iterator<EntityRef> worldEntityIterator =
        entityManager.getEntitiesWith(WorldComponent.class).iterator();
    // TODO: Move the world renderer bits elsewhere
    if (worldEntityIterator.hasNext()) {
      EntityRef worldEntity = worldEntityIterator.next();
      worldRenderer.getChunkProvider().setWorldEntity(worldEntity);

      // get the world generator config from the world entity
      // replace the world generator values from the components in the world entity
      WorldGenerator worldGenerator = context.get(WorldGenerator.class);
      WorldConfigurator worldConfigurator = worldGenerator.getConfigurator();
      Map<String, Component> params = worldConfigurator.getProperties();
      for (Map.Entry<String, Component> entry : params.entrySet()) {
        Class<? extends Component> clazz = entry.getValue().getClass();
        Component comp = worldEntity.getComponent(clazz);
        if (comp != null) {
          worldConfigurator.setProperty(entry.getKey(), comp);
        }
      }
    } else {
      EntityRef worldEntity = entityManager.create();
      worldEntity.addComponent(new WorldComponent());
      worldRenderer.getChunkProvider().setWorldEntity(worldEntity);

      // transfer all world generation parameters from Config to WorldEntity
      WorldGenerator worldGenerator = context.get(WorldGenerator.class);
      SimpleUri generatorUri = worldGenerator.getUri();
      Config config = context.get(Config.class);

      // get the map of properties from the world generator.
      // Replace its values with values from the config set by the UI.
      // Also set all the components to the world entity.
      WorldConfigurator worldConfigurator = worldGenerator.getConfigurator();
      Map<String, Component> params = worldConfigurator.getProperties();
      for (Map.Entry<String, Component> entry : params.entrySet()) {
        Class<? extends Component> clazz = entry.getValue().getClass();
        Component comp = config.getModuleConfig(generatorUri, entry.getKey(), clazz);
        if (comp != null) {
          worldEntity.addComponent(comp);
          worldConfigurator.setProperty(entry.getKey(), comp);
        } else {
          worldEntity.addComponent(entry.getValue());
        }
      }
    }

    return true;
  }
Exemplo n.º 3
0
  /** Updates the status if the entity is currently swimming (in water). */
  private void updateSwimStatus() {
    ArrayList<BlockPosition> blockPositions = gatherAdjacentBlockPositions(getPosition());

    boolean swimming = false, headUnderWater = false;

    for (int i = 0; i < blockPositions.size(); i++) {
      BlockPosition p = blockPositions.get(i);
      byte blockType = _parent.getWorldProvider().getBlockAtPosition(new Vector3d(p.x, p.y, p.z));
      AABB blockAABB = Block.AABBForBlockAt(p.x, p.y, p.z);

      if (BlockManager.getInstance().getBlock(blockType).isLiquid()
          && getAABB().overlaps(blockAABB)) {
        swimming = true;
      }

      Vector3d eyePos = calcEyePosition();
      eyePos.y += 0.25;

      if (BlockManager.getInstance().getBlock(blockType).isLiquid() && blockAABB.contains(eyePos)) {
        headUnderWater = true;
      }
    }

    _headUnderWater = headUnderWater;
    _isSwimming = swimming;
  }
Exemplo n.º 4
0
 @Override
 public boolean step() {
   if (worldRenderer.pregenerateChunks()) {
     return true;
   }
   EngineTime time = (EngineTime) context.get(Time.class);
   long totalTime = time.getRawTimeInMs() - startTime;
   return totalTime > 5000;
 }
Exemplo n.º 5
0
  public void render() {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();

    if (_worldRenderer != null) {
      _worldRenderer.render();
    }

    /* UI */
    PerformanceMonitor.startActivity("Render and Update UI");
    renderUserInterface();
    PerformanceMonitor.endActivity();
  }
  public void render() {

    FloatBuffer mBuffer = BufferUtils.createFloatBuffer(16);
    float[] mFloat = new float[16];

    GL11.glPushMatrix();

    Vector3d cameraPosition = _parent.getActiveCamera().getPosition();
    GL11.glTranslated(-cameraPosition.x, -cameraPosition.y, -cameraPosition.z);

    List<CollisionObject> collisionObjects = _discreteDynamicsWorld.getCollisionObjectArray();

    for (CollisionObject co : collisionObjects) {
      if (co.getClass().equals(BlockRigidBody.class)) {
        BlockRigidBody br = (BlockRigidBody) co;
        Block block = BlockManager.getInstance().getBlock(br.getType());

        Transform t = new Transform();
        br.getMotionState().getWorldTransform(t);

        t.getOpenGLMatrix(mFloat);
        mBuffer.put(mFloat);
        mBuffer.flip();

        GL11.glPushMatrix();
        GL11.glMultMatrix(mBuffer);

        if (br.getCollisionShape() == _blockShapeHalf) GL11.glScalef(0.5f, 0.5f, 0.5f);
        else if (br.getCollisionShape() == _blockShapeQuarter) GL11.glScalef(0.25f, 0.25f, 0.25f);

        block.renderWithLightValue(_parent.getRenderingLightValueAt(new Vector3d(t.origin)));

        GL11.glPopMatrix();
      }
    }

    GL11.glPopMatrix();
  }
  public void update(float delta) {
    for (EntityRef entity : entityManager.iteratorEntities(MiniaturizerComponent.class)) {
      MiniaturizerComponent min = entity.getComponent(MiniaturizerComponent.class);

      if (min.chunkMesh == null && min.miniatureChunk != null) {
        min.chunkMesh =
            worldRenderer.getChunkTesselator().generateMinaturizedMesh(min.miniatureChunk);
        min.chunkMesh.generateVBOs();
        min.chunkMesh._vertexElements = null;
      }

      // min.orientation += delta * 15f;
    }
  }
Exemplo n.º 8
0
  /**
   * Checks for blocks around the entity.
   *
   * @param origin The original position of the entity
   * @return True if the entity is colliding horizontally
   */
  private boolean horizontalHitTest(Vector3d origin) {
    boolean result = false;
    ArrayList<BlockPosition> blockPositions = gatherAdjacentBlockPositions(origin);

    // Check each block position for collision
    for (int i = 0; i < blockPositions.size(); i++) {
      BlockPosition p = blockPositions.get(i);
      byte blockType = _parent.getWorldProvider().getBlockAtPosition(new Vector3d(p.x, p.y, p.z));
      AABB blockAABB = Block.AABBForBlockAt(p.x, p.y, p.z);

      if (!BlockManager.getInstance().getBlock(blockType).isPenetrable()) {
        if (getAABB().overlaps(blockAABB)) {
          result = true;

          // Calculate the direction from the origin to the current position
          Vector3d direction = new Vector3d(getPosition().x, 0f, getPosition().z);
          direction.x -= origin.x;
          direction.z -= origin.z;

          // Calculate the point of intersection on the block's AABB
          Vector3d blockPoi = blockAABB.closestPointOnAABBToPoint(origin);
          Vector3d entityPoi = generateAABBForPosition(origin).closestPointOnAABBToPoint(blockPoi);

          Vector3d planeNormal =
              blockAABB.normalForPlaneClosestToOrigin(blockPoi, origin, true, false, true);

          // Find a vector parallel to the surface normal
          Vector3d slideVector = new Vector3d(planeNormal.z, 0, -planeNormal.x);
          Vector3d pushBack = new Vector3d();

          pushBack.sub(blockPoi, entityPoi);

          // Calculate the intensity of the diversion alongside the block
          double length = slideVector.dot(direction);

          Vector3d newPosition = new Vector3d();
          newPosition.z = origin.z + pushBack.z * 0.2 + length * slideVector.z;
          newPosition.x = origin.x + pushBack.x * 0.2 + length * slideVector.x;
          newPosition.y = origin.y;

          // Update the position
          getPosition().set(newPosition);
        }
      }
    }

    return result;
  }
Exemplo n.º 9
0
 public String toString() {
   Camera camera = worldRenderer.getActiveCamera();
   if (targetBlockPos != null) {
     return String.format(
         "From: %f %f %f, Dir: %f %f %f, Hit %d %d %d %f %f %f",
         camera.getPosition().x,
         camera.getPosition().y,
         camera.getPosition().z,
         camera.getViewingDirection().x,
         camera.getViewingDirection().y,
         camera.getViewingDirection().z,
         targetBlockPos.x,
         targetBlockPos.y,
         targetBlockPos.z,
         hitPosition.x,
         hitPosition.y,
         hitPosition.z);
   }
   return "";
 }
Exemplo n.º 10
0
  public void update(float delta) {
    // Repair lost target
    // TODO: Improvements to temporary chunk handling will remove the need for this
    boolean lostTarget = false;

    updateTarget();
    if (!target.exists()) {
      targetBlockPos = null;
      lostTarget = true;
    }

    // TODO: This will change when camera are handled better (via a component)
    Camera camera = worldRenderer.getActiveCamera();

    HitResult hitInfo =
        physics.rayTrace(
            new Vector3f(camera.getPosition()),
            new Vector3f(camera.getViewingDirection()),
            targetDistance,
            filter);
    updateFocalDistance(hitInfo, delta);
    Vector3i newBlockPos = null;

    EntityRef newTarget = EntityRef.NULL;
    if (hitInfo.isHit()) {
      newTarget = hitInfo.getEntity();
      hitPosition = hitInfo.getHitPoint();
      hitNormal = hitInfo.getHitNormal();
      if (hitInfo.isWorldHit()) {
        newBlockPos = new Vector3i(hitInfo.getBlockPosition());
      }
    }
    if (!Objects.equal(target, newTarget) || lostTarget) {
      EntityRef oldTarget = target;
      oldTarget.send(new CameraOutEvent());
      newTarget.send(new CameraOverEvent());
      localPlayer.getCharacterEntity().send(new CameraTargetChangedEvent(oldTarget, newTarget));
    }
    target = newTarget;
    targetBlockPos = newBlockPos;
  }
Exemplo n.º 11
0
  /**
   * Checks for blocks below and above the entity.
   *
   * @param origin The origin position of the entity
   * @return True if a vertical collision was detected
   */
  private boolean verticalHitTest(Vector3d origin) {
    ArrayList<BlockPosition> blockPositions = gatherAdjacentBlockPositions(origin);

    for (int i = 0; i < blockPositions.size(); i++) {
      BlockPosition p = blockPositions.get(i);

      byte blockType1 = _parent.getWorldProvider().getBlockAtPosition(new Vector3d(p.x, p.y, p.z));
      AABB entityAABB = getAABB();

      if (BlockManager.getInstance().getBlock(blockType1).isPenetrable()
          || !entityAABB.overlaps(Block.AABBForBlockAt(p.x, p.y, p.z))) continue;

      double direction = origin.y - getPosition().y;

      if (direction >= 0) getPosition().y = p.y + 0.50001f + entityAABB.getDimensions().y;
      else getPosition().y = p.y - 0.50001f - entityAABB.getDimensions().y;

      return true;
    }

    return false;
  }
Exemplo n.º 12
0
  public void update(float delta) {
    /* GUI */
    updateUserInterface();

    for (UpdateSubscriberSystem updater : _componentSystemManager.iterateUpdateSubscribers()) {
      PerformanceMonitor.startActivity(updater.getClass().getSimpleName());
      updater.update(delta);
    }

    if (_worldRenderer != null && shouldUpdateWorld()) _worldRenderer.update(delta);

    if (!screenHasFocus()) _localPlayerSys.updateInput();

    if (screenHasFocus() || !shouldUpdateWorld()) {
      if (Mouse.isGrabbed()) {
        Mouse.setGrabbed(false);
        Mouse.setCursorPosition(Display.getWidth() / 2, Display.getHeight() / 2);
      }
    } else {
      if (!Mouse.isGrabbed()) Mouse.setGrabbed(true);
    }

    // TODO: This seems a little off - plus is more of a UI than single player game state concern.
    // Move somewhere
    // more appropriate?
    boolean dead = true;
    for (EntityRef entity : _entityManager.iteratorEntities(LocalPlayerComponent.class)) {
      dead = entity.getComponent(LocalPlayerComponent.class).isDead;
    }
    if (dead) {
      _statusScreen.setVisible(true);
      _statusScreen.updateStatus("Sorry! Seems like you have died. :-(");
    } else {
      _statusScreen.setVisible(false);
    }
  }
Exemplo n.º 13
0
 private void checkPosition() {
   if (!_godMode && getPosition().y < 0) {
     getPosition().y = _parent.maxHeightAt((int) getPosition().x, (int) getPosition().y);
   }
 }
Exemplo n.º 14
0
  public Vector3d directionOfReferencePoint() {
    Vector3d result = new Vector3d();
    result.sub(_parent.getWorldProvider().getRenderingReferencePoint(), getPosition());

    return result;
  }
Exemplo n.º 15
0
  /** Updates the position of the entity. */
  protected void updatePosition() {
    // Save the previous position before changing any of the values
    Vector3d oldPosition = new Vector3d(getPosition());

    double friction =
        (Double) ConfigurationManager.getInstance().getConfig().get("Player.friction");

    /*
     * Slowdown the speed of the entity each time this method is called.
     */
    if (MathHelper.fastAbs(_velocity.y) > 0f) {
      _velocity.y += -1f * _velocity.y * friction;
    }

    if (MathHelper.fastAbs(_velocity.x) > 0f) {
      _velocity.x += -1f * _velocity.x * friction;
    }

    if (MathHelper.fastAbs(_velocity.z) > 0f) {
      _velocity.z += -1f * _velocity.z * friction;
    }

    /*
     * Apply friction.
     */
    if (MathHelper.fastAbs(_velocity.x) > _activeWalkingSpeed
        || MathHelper.fastAbs(_velocity.z) > _activeWalkingSpeed
        || MathHelper.fastAbs(_velocity.y) > _activeWalkingSpeed) {
      double max =
          Math.max(
              Math.max(MathHelper.fastAbs(_velocity.x), MathHelper.fastAbs(_velocity.z)),
              MathHelper.fastAbs(_velocity.y));
      double div = max / _activeWalkingSpeed;

      _velocity.x /= div;
      _velocity.z /= div;
      _velocity.y /= div;
    }

    /*
     * Increase the speed of the entity by adding the movement
     * vector to the acceleration vector.
     */
    _velocity.x += _movementDirection.x;
    _velocity.y += _movementDirection.y;
    _velocity.z += _movementDirection.z;

    double maxGravity =
        (Double) ConfigurationManager.getInstance().getConfig().get("Player.maxGravity");
    double maxGravitySwimming =
        (Double) ConfigurationManager.getInstance().getConfig().get("Player.maxGravitySwimming");
    double gravitySwimming =
        (Double) ConfigurationManager.getInstance().getConfig().get("Player.gravitySwimming");
    double gravity = (Double) ConfigurationManager.getInstance().getConfig().get("Player.gravity");

    // Normal gravity
    if (_gravity > -maxGravity && !_godMode && !_isSwimming) {
      _gravity -= gravity;
    }

    if (_gravity < -maxGravity && !_godMode && !_isSwimming) {
      _gravity = -maxGravity;
    }

    // Gravity under water
    if (_gravity > -maxGravitySwimming && !_godMode && _isSwimming) {
      _gravity -= gravitySwimming;
    }

    if (_gravity < -maxGravitySwimming && !_godMode && _isSwimming) {
      _gravity = -maxGravitySwimming;
    }

    getPosition().y += _velocity.y;
    getPosition().y += _gravity;

    if (!_godMode) {
      if (verticalHitTest(oldPosition)) {
        handleVerticalCollision();

        double oldGravity = _gravity;
        _gravity = 0;

        if (oldGravity <= 0) {
          // Jumping is only possible, if the entity is standing on ground
          if (_jump) {
            _jump = false;
            _gravity = _jumpIntensity;
          }

          // Entity reaches the ground
          if (!_touchingGround) {
            Vector3d playerDirection = directionOfReferencePoint();
            _footstepSounds[
                MathHelper.fastAbs(_parent.getWorldProvider().getRandom().randomInt()) % 5]
                .playAsSoundEffect(
                    0.7f
                        + (float)
                                MathHelper.fastAbs(
                                    _parent.getWorldProvider().getRandom().randomDouble())
                            * 0.3f,
                    0.2f
                        + (float)
                                MathHelper.fastAbs(
                                    _parent.getWorldProvider().getRandom().randomDouble())
                            * 0.3f,
                    false,
                    (float) playerDirection.x,
                    (float) playerDirection.y,
                    (float) playerDirection.z);
            _touchingGround = true;
          }
        } else {
          _touchingGround = false;
        }
      } else {
        _touchingGround = false;
      }
    } else {
      _gravity = 0f;
    }

    oldPosition.set(getPosition());

    /*
     * Update the position of the entity
     * according to the acceleration vector.
     */
    getPosition().x += _velocity.x;
    getPosition().z += _velocity.z;

    _stepCounter += Math.max(MathHelper.fastAbs(_velocity.x), MathHelper.fastAbs(_velocity.z));

    /*
     * Check for horizontal collisions __after__ checking for vertical
     * collisions.
     */
    if (!_godMode) {
      if (horizontalHitTest(oldPosition)) {
        handleHorizontalCollision();
      }
    }
  }
Exemplo n.º 16
0
 public void dispose() {
   _worldRenderer.dispose();
   _worldRenderer = null;
 }
Exemplo n.º 17
0
 public IWorldProvider getActiveWorldProvider() {
   return _worldRenderer.getWorldProvider();
 }
Exemplo n.º 18
0
  /** Init. a new random world. */
  public void initWorld(String title, String seed) {
    final FastRandom random = new FastRandom();

    // Get rid of the old world
    if (_worldRenderer != null) {
      _worldRenderer.dispose();
      _worldRenderer = null;
    }

    if (seed == null) {
      seed = random.randomCharacterString(16);
    } else if (seed.isEmpty()) {
      seed = random.randomCharacterString(16);
    }

    Terasology.getInstance()
        .getLogger()
        .log(Level.INFO, "Creating new World with seed \"{0}\"", seed);

    // Init. a new world
    _worldRenderer = new WorldRenderer(title, seed, _entityManager, _localPlayerSys);

    File entityDataFile =
        new File(Terasology.getInstance().getWorldSavePath(title), ENTITY_DATA_FILE);
    _entityManager.clear();
    if (entityDataFile.exists()) {
      try {
        _entityManager.load(entityDataFile, EntityManager.SaveFormat.Binary);
      } catch (IOException e) {
        _logger.log(Level.SEVERE, "Failed to load entity data", e);
      }
    }

    LocalPlayer localPlayer = null;
    Iterator<EntityRef> iterator =
        _entityManager.iteratorEntities(LocalPlayerComponent.class).iterator();
    if (iterator.hasNext()) {
      localPlayer = new LocalPlayer(iterator.next());
    } else {
      PlayerFactory playerFactory = new PlayerFactory(_entityManager);
      localPlayer =
          new LocalPlayer(
              playerFactory.newInstance(
                  new Vector3f(_worldRenderer.getWorldProvider().nextSpawningPoint())));
    }
    _worldRenderer.setPlayer(localPlayer);

    // Create the first Portal if it doesn't exist yet
    _worldRenderer.initPortal();

    fastForwardWorld();
    CoreRegistry.put(WorldRenderer.class, _worldRenderer);
    CoreRegistry.put(IWorldProvider.class, _worldRenderer.getWorldProvider());
    CoreRegistry.put(LocalPlayer.class, _worldRenderer.getPlayer());
    CoreRegistry.put(Camera.class, _worldRenderer.getActiveCamera());
    CoreRegistry.put(BulletPhysicsRenderer.class, _worldRenderer.getBulletRenderer());

    for (ComponentSystem system : _componentSystemManager.iterateAll()) {
      system.initialise();
    }
  }