Esempio n. 1
0
  @Override
  public boolean teleport(Location location) {
    WorldServer oldWorld = ((CraftWorld) getWorld()).getHandle();
    WorldServer newWorld = ((CraftWorld) location.getWorld()).getHandle();
    ServerConfigurationManager manager = server.getHandle();
    EntityPlayer entity = getHandle();
    boolean teleportSuccess;

    if (oldWorld != newWorld) {

      EntityPlayer newEntity =
          new EntityPlayer(manager.c, newWorld, entity.name, new ItemInWorldManager(newWorld));

      newEntity.id = entity.id;
      newEntity.a = entity.a;
      newEntity.health = entity.health;
      newEntity.fireTicks = entity.fireTicks;
      newEntity.inventory = entity.inventory;
      newEntity.inventory.d = newEntity;
      newEntity.activeContainer = entity.activeContainer;
      newEntity.defaultContainer = entity.defaultContainer;
      newEntity.lastwarp = entity.lastwarp; // Buck - It
      newEntity.locX = location.getX();
      newEntity.locY = location.getY();
      newEntity.locZ = location.getZ();
      newEntity.displayName = entity.displayName;
      newEntity.compassTarget = entity.compassTarget;
      newEntity.fauxSleeping = entity.fauxSleeping;
      newWorld.u.c((int) location.getBlockX() >> 4, (int) location.getBlockZ() >> 4);

      teleportSuccess = newEntity.a.teleport(location);

      if (teleportSuccess) {
        manager.c.k.a(entity);
        manager.c.k.b(entity);
        oldWorld.manager.b(entity);
        manager.b.remove(entity);
        oldWorld.e(entity);

        newWorld.manager.a(newEntity);
        newWorld.a(newEntity);
        manager.b.add(newEntity);

        entity.a.e = newEntity;
        this.entity = newEntity;

        setCompassTarget(getCompassTarget());
      }

      return teleportSuccess;
    } else {
      return entity.a.teleport(location);
    }
  }
Esempio n. 2
0
  public void z() {
    this.methodProfiler.a("jobs");
    Queue queue = this.i;

    synchronized (this.i) {
      while (!this.i.isEmpty()) {
        try {
          // CraftBukkit start - log exceptions
          FutureTask task = ((FutureTask) this.i.poll());
          task.run();
          task.get();
        } catch (Throwable throwable) {
          MinecraftServer.LOGGER.fatal("Handling task", throwable);
          // CraftBukkit end
        }
      }
    }

    this.methodProfiler.c("levels");

    SpigotTimings.schedulerTimer.startTiming(); // Spigot
    // CraftBukkit start
    this.server.getScheduler().mainThreadHeartbeat(this.ticks);
    SpigotTimings.schedulerTimer.stopTiming(); // Spigot

    // Run tasks that are waiting on processing
    SpigotTimings.processQueueTimer.startTiming(); // Spigot
    while (!processQueue.isEmpty()) {
      processQueue.remove().run();
    }
    SpigotTimings.processQueueTimer.stopTiming(); // Spigot

    SpigotTimings.chunkIOTickTimer.startTiming(); // Spigot
    org.bukkit.craftbukkit.chunkio.ChunkIOExecutor.tick();
    SpigotTimings.chunkIOTickTimer.stopTiming(); // Spigot

    SpigotTimings.timeUpdateTimer.startTiming(); // Spigot
    // Send time updates to everyone, it will get the right time from the world the player is in.
    if (this.ticks % 20 == 0) {
      for (int i = 0; i < this.getPlayerList().players.size(); ++i) {
        EntityPlayer entityplayer = (EntityPlayer) this.getPlayerList().players.get(i);
        entityplayer.playerConnection.sendPacket(
            new PacketPlayOutUpdateTime(
                entityplayer.world.getTime(),
                entityplayer.getPlayerTime(),
                entityplayer
                    .world
                    .getGameRules()
                    .getBoolean("doDaylightCycle"))); // Add support for per player time
      }
    }
    SpigotTimings.timeUpdateTimer.stopTiming(); // Spigot

    int i;

    for (i = 0; i < this.worlds.size(); ++i) {
      long j = System.nanoTime();

      // if (i == 0 || this.getAllowNether()) {
      WorldServer worldserver = this.worlds.get(i);

      this.methodProfiler.a(worldserver.getWorldData().getName());
      /* Drop global time updates
      if (this.ticks % 20 == 0) {
          this.methodProfiler.a("timeSync");
          this.v.a(new PacketPlayOutUpdateTime(worldserver.getTime(), worldserver.getDayTime(), worldserver.getGameRules().getBoolean("doDaylightCycle")), worldserver.worldProvider.getDimension());
          this.methodProfiler.b();
      }
      // CraftBukkit end */

      this.methodProfiler.a("tick");

      CrashReport crashreport;

      try {
        worldserver.timings.doTick.startTiming(); // Spigot
        worldserver.doTick();
        worldserver.timings.doTick.stopTiming(); // Spigot
      } catch (Throwable throwable1) {
        // Spigot Start
        try {
          crashreport = CrashReport.a(throwable1, "Exception ticking world");
        } catch (Throwable t) {
          throw new RuntimeException("Error generating crash report", t);
        }
        // Spigot End
        worldserver.a(crashreport);
        throw new ReportedException(crashreport);
      }

      try {
        worldserver.timings.tickEntities.startTiming(); // Spigot
        worldserver.tickEntities();
        worldserver.timings.tickEntities.stopTiming(); // Spigot
      } catch (Throwable throwable2) {
        // Spigot Start
        try {
          crashreport = CrashReport.a(throwable2, "Exception ticking world entities");
        } catch (Throwable t) {
          throw new RuntimeException("Error generating crash report", t);
        }
        // Spigot End
        worldserver.a(crashreport);
        throw new ReportedException(crashreport);
      }

      this.methodProfiler.b();
      this.methodProfiler.a("tracker");
      worldserver.timings.tracker.startTiming(); // Spigot
      worldserver.getTracker().updatePlayers();
      worldserver.timings.tracker.stopTiming(); // Spigot
      this.methodProfiler.b();
      this.methodProfiler.b();
      // } // CraftBukkit

      // this.h[i][this.ticks % 100] = System.nanoTime() - j; // CraftBukkit
    }

    this.methodProfiler.c("connection");
    SpigotTimings.connectionTimer.startTiming(); // Spigot
    this.ao().c();
    SpigotTimings.connectionTimer.stopTiming(); // Spigot
    this.methodProfiler.c("players");
    SpigotTimings.playerListTimer.startTiming(); // Spigot
    this.v.tick();
    SpigotTimings.playerListTimer.stopTiming(); // Spigot
    this.methodProfiler.c("tickables");

    SpigotTimings.tickablesTimer.startTiming(); // Spigot
    for (i = 0; i < this.o.size(); ++i) {
      ((IUpdatePlayerListBox) this.o.get(i)).c();
    }
    SpigotTimings.tickablesTimer.stopTiming(); // Spigot

    this.methodProfiler.b();
  }
Esempio n. 3
0
  protected void a(String s, String s1, long i, WorldType worldtype, String s2) {
    this.a(s);
    this.b("menu.loadingLevel");
    this.worldServer = new WorldServer[3];
    /* CraftBukkit start - Remove ticktime arrays and worldsettings
    this.h = new long[this.worldServer.length][100];
    IDataManager idatamanager = this.convertable.a(s, true);

    this.a(this.T(), idatamanager);
    WorldData worlddata = idatamanager.getWorldData();
    WorldSettings worldsettings;

    if (worlddata == null) {
        if (this.W()) {
            worldsettings = DemoWorldServer.a;
        } else {
            worldsettings = new WorldSettings(i, this.getGamemode(), this.getGenerateStructures(), this.isHardcore(), worldtype);
            worldsettings.setGeneratorSettings(s2);
            if (this.M) {
                worldsettings.a();
            }
        }

        worlddata = new WorldData(worldsettings, s1);
    } else {
        worlddata.a(s1);
        worldsettings = new WorldSettings(worlddata);
    }
    */
    int worldCount = 3;

    for (int j = 0; j < worldCount; ++j) {
      WorldServer world;
      byte dimension = 0;

      if (j == 1) {
        if (getAllowNether()) {
          dimension = -1;
        } else {
          continue;
        }
      }

      if (j == 2) {
        if (server.getAllowEnd()) {
          dimension = 1;
        } else {
          continue;
        }
      }

      String worldType =
          org.bukkit.World.Environment.getEnvironment(dimension).toString().toLowerCase();
      String name = (dimension == 0) ? s : s + "_" + worldType;

      org.bukkit.generator.ChunkGenerator gen = this.server.getGenerator(name);
      WorldSettings worldsettings =
          new WorldSettings(
              i, this.getGamemode(), this.getGenerateStructures(), this.isHardcore(), worldtype);
      worldsettings.setGeneratorSettings(s2);

      if (j == 0) {
        IDataManager idatamanager = new ServerNBTManager(server.getWorldContainer(), s1, true);
        WorldData worlddata = idatamanager.getWorldData();
        if (worlddata == null) {
          worlddata = new WorldData(worldsettings, s1);
        }
        worlddata.checkName(
            s1); // CraftBukkit - Migration did not rewrite the level.dat; This forces 1.8 to take
                 // the last loaded world as respawn (in this case the end)
        if (this.W()) {
          world =
              (WorldServer)
                  (new DemoWorldServer(
                          this, idatamanager, worlddata, dimension, this.methodProfiler))
                      .b();
        } else {
          world =
              (WorldServer)
                  (new WorldServer(
                          this,
                          idatamanager,
                          worlddata,
                          dimension,
                          this.methodProfiler,
                          org.bukkit.World.Environment.getEnvironment(dimension),
                          gen))
                      .b();
        }

        world.a(worldsettings);
        this.server.scoreboardManager =
            new org.bukkit.craftbukkit.scoreboard.CraftScoreboardManager(
                this, world.getScoreboard());
      } else {
        String dim = "DIM" + dimension;

        File newWorld = new File(new File(name), dim);
        File oldWorld = new File(new File(s), dim);

        if ((!newWorld.isDirectory()) && (oldWorld.isDirectory())) {
          MinecraftServer.LOGGER.info(
              "---- Migration of old " + worldType + " folder required ----");
          MinecraftServer.LOGGER.info(
              "Unfortunately due to the way that Minecraft implemented multiworld support in 1.6, Bukkit requires that you move your "
                  + worldType
                  + " folder to a new location in order to operate correctly.");
          MinecraftServer.LOGGER.info(
              "We will move this folder for you, but it will mean that you need to move it back should you wish to stop using Bukkit in the future.");
          MinecraftServer.LOGGER.info("Attempting to move " + oldWorld + " to " + newWorld + "...");

          if (newWorld.exists()) {
            MinecraftServer.LOGGER.warn("A file or folder already exists at " + newWorld + "!");
            MinecraftServer.LOGGER.info(
                "---- Migration of old " + worldType + " folder failed ----");
          } else if (newWorld.getParentFile().mkdirs()) {
            if (oldWorld.renameTo(newWorld)) {
              MinecraftServer.LOGGER.info(
                  "Success! To restore "
                      + worldType
                      + " in the future, simply move "
                      + newWorld
                      + " to "
                      + oldWorld);
              // Migrate world data too.
              try {
                com.google.common.io.Files.copy(
                    new File(new File(s), "level.dat"), new File(new File(name), "level.dat"));
              } catch (IOException exception) {
                MinecraftServer.LOGGER.warn("Unable to migrate world data.");
              }
              MinecraftServer.LOGGER.info(
                  "---- Migration of old " + worldType + " folder complete ----");
            } else {
              MinecraftServer.LOGGER.warn(
                  "Could not move folder " + oldWorld + " to " + newWorld + "!");
              MinecraftServer.LOGGER.info(
                  "---- Migration of old " + worldType + " folder failed ----");
            }
          } else {
            MinecraftServer.LOGGER.warn("Could not create path for " + newWorld + "!");
            MinecraftServer.LOGGER.info(
                "---- Migration of old " + worldType + " folder failed ----");
          }
        }

        IDataManager idatamanager = new ServerNBTManager(server.getWorldContainer(), name, true);
        // world =, b0 to dimension, s1 to name, added Environment and gen
        WorldData worlddata = idatamanager.getWorldData();
        if (worlddata == null) {
          worlddata = new WorldData(worldsettings, name);
        }
        worlddata.checkName(
            name); // CraftBukkit - Migration did not rewrite the level.dat; This forces 1.8 to take
                   // the last loaded world as respawn (in this case the end)
        world =
            (WorldServer)
                new SecondaryWorldServer(
                        this,
                        idatamanager,
                        dimension,
                        this.worlds.get(0),
                        this.methodProfiler,
                        worlddata,
                        org.bukkit.World.Environment.getEnvironment(dimension),
                        gen)
                    .b();
      }

      if (gen != null) {
        world.getWorld().getPopulators().addAll(gen.getDefaultPopulators(world.getWorld()));
      }

      this.server
          .getPluginManager()
          .callEvent(new org.bukkit.event.world.WorldInitEvent(world.getWorld()));

      world.addIWorldAccess(new WorldManager(this, world));
      if (!this.S()) {
        world.getWorldData().setGameType(this.getGamemode());
      }

      worlds.add(world);
      getPlayerList().setPlayerFileData(worlds.toArray(new WorldServer[worlds.size()]));
    }

    // CraftBukkit end
    this.a(this.getDifficulty());
    this.k();
  }