Ejemplo n.º 1
0
  public void load() {
    // TODO: Eventually replace this?
    if (loadingStage == null) {
      loadingStage = LoadingStage.ALLOCATE_MEMORY;
    }

    if (loadingStage == LoadingStage.ALLOCATE_MEMORY) {
      Runtime runtime = Runtime.getRuntime();
      int usedMemory = (int) ((runtime.totalMemory() - runtime.freeMemory()) / 1024L);
      long currentTime = TimeUtil.getCurrentTimeMillis();
      if (lastgc == 0L) {
        lastgc = currentTime;
      }
      if (usedMemory > 16 * 1024 && currentTime - lastgc < 5000L) {
        if (currentTime - lastgc > 100L) {
          System.gc();
          lastgc = currentTime;
        }
      } else {
        loadingStage = LoadingStage.CREATE_GAME_WORLD;
      }
    }

    if (loadingStage == LoadingStage.CREATE_GAME_WORLD) {
      // Initialize the world traversal maps, one for each plane.
      for (int i = 0; i < traversalMaps.length; i++) {
        traversalMaps[i] = new TraversalMap(104, 104);
      }
      loadingStage = LoadingStage.CONNECT_TO_UPDATE_SERVER;
    }

    if (loadingStage == LoadingStage.CONNECT_TO_UPDATE_SERVER) {

      if (fileIndexFactory == null) {
        fileIndexFactory = new FileIndexFactory(diskEntryWorker, remoteEntryWorker);
      }

      // Once the update table is complete we can continue
      if (fileIndexFactory.isUpdateTableComplete()) {
        loadingStage = LoadingStage.PREPARE_SOUND_ENGINE;
      }
    }

    if (loadingStage == LoadingStage.PREPARE_SOUND_ENGINE) {}
  }
Ejemplo n.º 2
0
  private void establishUpdateConnection() {
    if (currentAttempts < remoteEntryWorker.getAttempts()) {

      // Set the update connection delay to wait 5 seconds for every failed attempt
      // greater than 1.
      updateConnectionDelay = 5 * 50 * (remoteEntryWorker.getAttempts() - 1);

      // Limit the next connection delay to be at maximum 60 seconds
      updateConnectionDelay = Math.min(updateConnectionDelay, 3000);

      // If the client build is out of date report it
      if (remoteEntryWorker.getAttempts() >= 2
          && remoteEntryWorker.getStatus() == Handshake.STATUS_OUT_OF_DATE) {
        reportUpdateError("js5connect_outofdate");
        state = ClientState.UPDATE_ERROR;
        return;
      }

      if (remoteEntryWorker.getAttempts() >= 4 && (state == ClientState.INITIAL_LOADING)) {
        if (remoteEntryWorker.getStatus() > 0) {
          reportUpdateError("js5connect");
        } else {
          reportUpdateError("js5io");
        }
        state = ClientState.UPDATE_ERROR;
        return;
      }
    }

    currentAttempts = remoteEntryWorker.getAttempts();

    if (updateConnectionDelay > 0) {
      updateConnectionDelay--;
    } else {
      try {

        // Create the update server socket
        if (updateStage == 0) {
          updateServerSocketRequest = getSignlink().createSocket(remoteAddress, remotePort);
          updateStage++;
        }

        // Await for the update server socket request to finish
        if (updateStage == 1) {

          // Check if the update server socket request errored
          // if it did report the error and move along
          if (updateServerSocketRequest.errored()) {
            reportUpdateError(RemoteEntryWorker.ERROR_TIMEOUT);
            return;
          }

          // If the request finished increment the stage and move along
          if (updateServerSocketRequest.isFinished()) {
            updateStage++;
          }
        }

        // Write the update server handshake
        if (updateStage == 2) {

          // Create the update server socket stream
          updateServerStream =
              new SocketStream(updateServerSocketRequest.getResult(), getSignlink(), 5000);

          // Write the update server handshake to the server
          // 0: int8  -> update_server_hs
          // 1: int32 -> build
          Buffer buffer = new Buffer(5);
          buffer.putInt8(Handshake.OP_UPDATE_SERVER);
          buffer.putInt32(getBuild());

          updateServerStream.write(buffer.array(), 0, buffer.position());
          updateConnectionStartTime = TimeUtil.getCurrentTimeMillis();

          // Increment the update server connection stage
          updateStage++;
        }

        // Await for the update server handshake response
        if (updateStage == 3) {

          // If we are not initially loading, and the stream has no available bytes wait
          // to read the status since we don't want to block the client. However after
          // thirty seconds from the time the handshake was written we assume that
          // the connection timed out.
          if (state != ClientState.INITIAL_LOADING && updateServerStream.available() < 1) {
            if (TimeUtil.getCurrentTimeMillis() - updateConnectionStartTime > 30000L) {
              reportUpdateError(RemoteEntryWorker.ERROR_TIMEOUT);
              return;
            }
          } else {

            // Read the status from the server, if it is anything
            // but okay report it as an error.
            int status = updateServerStream.read();
            if (status != Handshake.STATUS_OKAY) {
              reportUpdateError(status);
              return;
            }

            // Increment the update server connection stage
            updateStage++;
          }
        }

        // Initialize the remote entry worker
        if (updateStage == 4) {
          boolean online = false; // TODO: Eventually fix this
          remoteEntryWorker.setupConnection(updateServerStream, online);
          updateServerSocketRequest = null;
          updateStage = 0;
        }
      } catch (IOException ex) {
        reportUpdateError(RemoteEntryWorker.ERROR_IO);
      }
    }
  }