@Override
 public boolean step() {
   NetworkSystemImpl networkSystem = (NetworkSystemImpl) CoreRegistry.get(NetworkSystem.class);
   EntityRef client = networkSystem.getServer().getClientEntity();
   if (client.exists()) {
     CoreRegistry.get(LocalPlayer.class).setClientEntity(client);
     return true;
   }
   return false;
 }
  @Override
  public boolean step() {
    EngineEntityManager entityManager = (EngineEntityManager) CoreRegistry.get(EntityManager.class);
    EntitySystemLibrary entitySystemLibrary = CoreRegistry.get(EntitySystemLibrary.class);
    BlockEntityRegistry blockEntityRegistry = CoreRegistry.get(BlockEntityRegistry.class);

    CoreRegistry.get(NetworkSystem.class)
        .connectToEntitySystem(entityManager, entitySystemLibrary, blockEntityRegistry);
    CoreRegistry.get(ComponentSystemManager.class).initialise();
    return true;
  }
/** @author Immortius <*****@*****.**> */
public class BlockFamilyTypeHandler implements TypeHandler<BlockFamily> {

  private BlockManager blockManager = CoreRegistry.get(BlockManager.class);

  @Override
  public EntityData.Value serialize(BlockFamily value) {
    return EntityData.Value.newBuilder().addString(value.getURI().toString()).build();
  }

  @Override
  public BlockFamily deserialize(EntityData.Value value) {
    if (value.getStringCount() > 0) {
      return blockManager.getBlockFamily(value.getString(0));
    }
    return null;
  }

  @Override
  public EntityData.Value serializeCollection(Iterable<BlockFamily> value) {
    EntityData.Value.Builder result = EntityData.Value.newBuilder();
    for (BlockFamily item : value) {
      result.addString(item.getURI().toString());
    }
    return result.build();
  }

  @Override
  public List<BlockFamily> deserializeCollection(EntityData.Value value) {
    List<BlockFamily> result = Lists.newArrayListWithCapacity(value.getStringCount());
    for (String item : value.getStringList()) {
      result.add(blockManager.getBlockFamily(item));
    }
    return result;
  }
}
  @Override
  public void initialise() {
    final BlockManager blockManager = CoreRegistry.get(BlockManager.class);
    lampTurnedOff = blockManager.getBlock("signalling:SignalLampOff");
    lampTurnedOn = blockManager.getBlock("signalling:SignalLampOn");
    signalTransformer = blockManager.getBlock("signalling:SignalTransformer");
    signalPressurePlate = blockManager.getBlock("signalling:SignalPressurePlate");
    signalSwitch = blockManager.getBlock("signalling:SignalSwitch");
    signalLimitedSwitch = blockManager.getBlock("signalling:SignalLimitedSwitch");
    signalButton = blockManager.getBlock("signalling:SignalButton");

    signalOrGate = blockManager.getBlockFamily("signalling:SignalOrGate");
    signalAndGate = blockManager.getBlockFamily("signalling:SignalAndGate");
    signalXorGate = blockManager.getBlockFamily("signalling:SignalXorGate");
    signalNandGate = blockManager.getBlockFamily("signalling:SignalNandGate");

    signalOnDelayGate = blockManager.getBlockFamily("signalling:SignalOnDelayGate");
    signalOffDelayGate = blockManager.getBlockFamily("signalling:SignalOffDelayGate");

    signalSetResetGate = blockManager.getBlockFamily("signalling:SignalSetResetGate");
  }
Example #5
0
/**
 * Camera base class.
 *
 * @author Benjamin Glatzel <*****@*****.**>
 */
public abstract class Camera {

  /* CAMERA PARAMETERS */
  protected final Vector3f position = new Vector3f(0, 0, 0);
  protected final Vector3f up = new Vector3f(0, 1, 0);
  protected final Vector3f viewingDirection = new Vector3f(1, 0, 0);

  protected float zNear = 0.1f;
  // TODO: This is too large, but many properties have to be adjusted if it changes
  protected float zFar = 5000.0f;

  protected float targetFov = CoreRegistry.get(Config.class).getRendering().getFieldOfView();
  protected float activeFov = targetFov / 4f;

  /* VIEW FRUSTUM */
  protected final ViewFrustum viewFrustum = new ViewFrustum();
  protected final ViewFrustum viewFrustumReflected = new ViewFrustum();

  /* MATRICES */
  protected Matrix4f projectionMatrix = new Matrix4f();
  protected Matrix4f inverseProjectionMatrix = new Matrix4f();
  protected Matrix4f normViewMatrix = new Matrix4f();
  protected Matrix4f viewMatrix = new Matrix4f();
  protected Matrix4f viewProjectionMatrix = new Matrix4f();
  protected Matrix4f inverseViewProjectionMatrix = new Matrix4f();
  protected Matrix4f prevViewProjectionMatrix = new Matrix4f();
  protected Matrix4f reflectionMatrix = new Matrix4f();

  protected Matrix4f viewMatrixReflected = new Matrix4f();
  protected Matrix4f normViewMatrixReflected = new Matrix4f();

  /* USED FOR DIRTY CHECKS */
  protected Vector3f cachedPosition = new Vector3f();
  protected Vector3f cachedViewigDirection = new Vector3f();
  protected float cachedFov;
  protected float cachedZNear;
  protected float cachedZFar;

  /* ETC */
  private boolean reflected;

  /** Applies the projection and modelview matrix. */
  public void lookThrough() {
    loadProjectionMatrix();
    loadModelViewMatrix();
  }

  /**
   * Applies the projection and the normalized modelview matrix (positioned at the origin without
   * any offset like bobbing) .
   */
  public void lookThroughNormalized() {
    loadProjectionMatrix();
    loadNormalizedModelViewMatrix();
  }

  public void updateFrustum() {
    if (getViewMatrix() == null || getProjectionMatrix() == null) {
      return;
    }

    viewFrustum.updateFrustum(
        MatrixUtils.matrixToFloatBuffer(viewMatrix),
        MatrixUtils.matrixToFloatBuffer(projectionMatrix));
    viewFrustumReflected.updateFrustum(
        MatrixUtils.matrixToFloatBuffer(viewMatrixReflected),
        MatrixUtils.matrixToFloatBuffer(projectionMatrix));
  }

  public abstract boolean isBobbingAllowed();

  public abstract void loadProjectionMatrix();

  public abstract void loadModelViewMatrix();

  public abstract void loadNormalizedModelViewMatrix();

  public abstract void updateMatrices();

  public abstract void updateMatrices(float fov);

  public void update(float delta) {
    double diff = Math.abs(activeFov - targetFov);
    if (diff < 1.0) {
      activeFov = targetFov;
      return;
    }
    if (activeFov < targetFov) {
      activeFov += 50.0 * delta;
      if (activeFov >= targetFov) {
        activeFov = targetFov;
      }
    } else if (activeFov > targetFov) {
      activeFov -= 50.0 * delta;
      if (activeFov <= targetFov) {
        activeFov = targetFov;
      }
    }
  }

  public void extendFov(float fov) {
    targetFov = CoreRegistry.get(Config.class).getRendering().getFieldOfView() + fov;
  }

  public void resetFov() {
    targetFov = CoreRegistry.get(Config.class).getRendering().getFieldOfView();
  }

  public void setReflected(boolean reflected) {
    this.reflected = reflected;
  }

  public void updatePrevViewProjectionMatrix() {
    prevViewProjectionMatrix.set(viewProjectionMatrix);
  }

  public float getClipHeight() {
    return 31.5f;
  }

  public Matrix4f getViewMatrix() {
    if (!reflected) {
      return viewMatrix;
    }

    return viewMatrixReflected;
  }

  public Matrix4f getNormViewMatrix() {
    if (!reflected) {
      return normViewMatrix;
    }

    return normViewMatrixReflected;
  }

  public Matrix4f getProjectionMatrix() {
    return projectionMatrix;
  }

  public Matrix4f getViewProjectionMatrix() {
    return viewProjectionMatrix;
  }

  public Matrix4f getInverseProjectionMatrix() {
    return inverseProjectionMatrix;
  }

  public Matrix4f getInverseViewProjectionMatrix() {
    return inverseViewProjectionMatrix;
  }

  public Matrix4f getPrevViewProjectionMatrix() {
    return prevViewProjectionMatrix;
  }

  public Vector3f getPosition() {
    return position;
  }

  public Vector3f getViewingDirection() {
    return viewingDirection;
  }

  public Vector3f getUp() {
    return up;
  }

  public ViewFrustum getViewFrustum() {
    return viewFrustum;
  }

  public ViewFrustum getViewFrustumReflected() {
    return viewFrustumReflected;
  }

  public float getzNear() {
    return zNear;
  }

  public void setzNear(float zNear) {
    this.zNear = zNear;
  }

  public float getzFar() {
    return zFar;
  }

  public void setzFar(float zFar) {
    this.zFar = zFar;
  }

  public boolean isReflected() {
    return reflected;
  }
}
Example #6
0
 public void resetFov() {
   targetFov = CoreRegistry.get(Config.class).getRendering().getFieldOfView();
 }
Example #7
0
 public void extendFov(float fov) {
   targetFov = CoreRegistry.get(Config.class).getRendering().getFieldOfView() + fov;
 }
 /**
  * Sets the location in the physics engine.
  *
  * @param entity The entity to set the location of.
  * @param newPos The new position of the entity.
  */
 private static void setPhysicsLocation(EntityRef entity, Vector3f newPos) {
   PhysicsEngine physics = CoreRegistry.get(PhysicsEngine.class);
   CharacterCollider collider = physics.getCharacterCollider(entity);
   collider.setLocation(newPos);
 }