public void transferPlayerToDimension(EntityPlayerMP par1EntityPlayerMP, int par2) {
    int var3 = par1EntityPlayerMP.dimension;
    WorldServer var4 = this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension);
    par1EntityPlayerMP.dimension = par2;
    WorldServer var5 = this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension);
    par1EntityPlayerMP.playerNetServerHandler.sendPacketToPlayer(
        new Packet9Respawn(
            par1EntityPlayerMP.dimension,
            (byte) par1EntityPlayerMP.worldObj.difficultySetting,
            var5.getWorldInfo().getTerrainType(),
            var5.getHeight(),
            par1EntityPlayerMP.theItemInWorldManager.getGameType()));
    var4.removeEntity(par1EntityPlayerMP);
    par1EntityPlayerMP.isDead = false;
    this.transferEntityToWorld(par1EntityPlayerMP, var3, var4, var5);
    this.func_72375_a(par1EntityPlayerMP, var4);
    par1EntityPlayerMP.playerNetServerHandler.setPlayerLocation(
        par1EntityPlayerMP.posX,
        par1EntityPlayerMP.posY,
        par1EntityPlayerMP.posZ,
        par1EntityPlayerMP.rotationYaw,
        par1EntityPlayerMP.rotationPitch);
    par1EntityPlayerMP.theItemInWorldManager.setWorld(var5);
    this.updateTimeAndWeatherForPlayer(par1EntityPlayerMP, var5);
    this.syncPlayerInventory(par1EntityPlayerMP);
    Iterator var6 = par1EntityPlayerMP.getActivePotionEffects().iterator();

    while (var6.hasNext()) {
      PotionEffect var7 = (PotionEffect) var6.next();
      par1EntityPlayerMP.playerNetServerHandler.sendPacketToPlayer(
          new Packet41EntityEffect(par1EntityPlayerMP.entityId, var7));
    }
  }
  private static double[] findBestSpawnLocation(WorldServer machineWorld, int coord) {
    int size = Reference.getBoxSize(CompactMachines.instance.machineHandler.getRoomSize(coord));

    int posX1 = coord * ConfigurationHandler.cubeDistance + 1;
    int posY1 = 40 + 1;
    int posZ1 = 1;

    int posX2 = coord * ConfigurationHandler.cubeDistance + size - 1;
    int posY2 = 40 + size - 1;
    int posZ2 = size - 1;

    int minX = Math.min(posX1, posX2);
    int minY = Math.min(posY1, posY2);
    int minZ = Math.min(posZ1, posZ2);

    int maxX = Math.max(posX1, posX2);
    int maxY = Math.max(posY1, posY2) - 1;
    int maxZ = Math.max(posZ1, posZ2);

    for (int x = minX; x <= maxX; x++) {
      for (int y = minY; y <= maxY; y++) {
        for (int z = minZ; z <= maxZ; z++) {
          if (machineWorld.isAirBlock(x, y, z) && machineWorld.isAirBlock(x, y + 1, z)) {
            return new double[] {x + 0.5, y + 0.5, z + 0.5};
          }
        }
      }
    }

    return null;
  }
  public static void setWorld(int id, WorldServer world) {
    if (world != null) {
      worlds.put(id, world);
      weakWorldMap.put(world, world);
      MinecraftServer.getServer().worldTickTimes.put(id, new long[100]);
      FMLLog.info(
          "Loading dimension %d (%s) (%s)",
          id, world.getWorldInfo().getWorldName(), world.getMinecraftServer());
    } else {
      worlds.remove(id);
      MinecraftServer.getServer().worldTickTimes.remove(id);
      FMLLog.info("Unloading dimension %d", id);
    }

    ArrayList<WorldServer> tmp = new ArrayList<WorldServer>();
    if (worlds.get(0) != null) tmp.add(worlds.get(0));
    if (worlds.get(-1) != null) tmp.add(worlds.get(-1));
    if (worlds.get(1) != null) tmp.add(worlds.get(1));

    for (Entry<Integer, WorldServer> entry : worlds.entrySet()) {
      int dim = entry.getKey();
      if (dim >= -1 && dim <= 1) {
        continue;
      }
      tmp.add(entry.getValue());
    }

    MinecraftServer.getServer().worldServers = tmp.toArray(new WorldServer[tmp.size()]);
  }
Example #4
0
  /** par1 indicates if a log message should be output. */
  protected void saveAllWorlds(boolean dontLog) {
    if (!this.worldIsBeingDeleted) {
      WorldServer[] var2 = this.worldServers;
      int var3 = var2.length;

      for (int var4 = 0; var4 < var3; ++var4) {
        WorldServer var5 = var2[var4];

        if (var5 != null) {
          if (!dontLog) {
            logger.info(
                "Saving chunks for level \'"
                    + var5.getWorldInfo().getWorldName()
                    + "\'/"
                    + var5.provider.getDimensionName());
          }

          try {
            var5.saveAllChunks(true, (IProgressUpdate) null);
          } catch (MinecraftException var7) {
            logger.warn(var7.getMessage());
          }
        }
      }
    }
  }
Example #5
0
  /** Saves all necessary data as preparation for stopping the server. */
  public void stopServer() {
    if (!this.worldIsBeingDeleted) {
      logger.info("Stopping server");

      if (this.getNetworkSystem() != null) {
        this.getNetworkSystem().terminateEndpoints();
      }

      if (this.serverConfigManager != null) {
        logger.info("Saving players");
        this.serverConfigManager.saveAllPlayerData();
        this.serverConfigManager.removeAllPlayers();
      }

      if (this.worldServers != null) {
        logger.info("Saving worlds");
        this.saveAllWorlds(false);

        for (int var1 = 0; var1 < this.worldServers.length; ++var1) {
          WorldServer var2 = this.worldServers[var1];
          var2.flush();
        }
      }

      if (this.usageSnooper.isSnooperRunning()) {
        this.usageSnooper.stopSnooper();
      }
    }
  }
Example #6
0
  @Override
  public void processCommand(ICommandSender sender, String[] params) {
    MinecraftServer server = MinecraftServer.getServer();
    EntityPlayerMP player = getCommandSenderAsPlayer(sender);
    WorldServer world =
        server.worldServerForDimension(player.getEntityWorld().provider.dimensionId);

    if (!TFCOptions.enableDebugMode) {
      TFC_Core.sendInfoMessage(player, new ChatComponentText("Debug Mode Required"));
      return;
    }

    if (params.length == 0) {
      TFC_Core.sendInfoMessage(player, new ChatComponentText("Stripping Chunk"));
      Chunk chunk = world.getChunkFromBlockCoords((int) player.posX, (int) player.posZ);
      for (int x = 0; x < 16; x++) {
        for (int z = 0; z < 16; z++) {
          for (int y = 0; y < 256; y++) {
            Block id = chunk.getBlock(x, y, z);
            if (id != TFCBlocks.Ore
                && id != TFCBlocks.Ore2
                && id != TFCBlocks.Ore3
                && id != Blocks.bedrock)
              world.setBlock(
                  x + (chunk.xPosition * 16), y, z + (chunk.zPosition * 16), Blocks.air, 0, 2);
          }
        }
      }

      TFC_Core.sendInfoMessage(player, new ChatComponentText("Stripping Chunk Complete"));
    } else if (params.length == 1) {
      TFC_Core.sendInfoMessage(
          player,
          new ChatComponentText(
              "Stripping Chunks Within a Radius of " + Integer.parseInt(params[0])));
      int radius = Integer.parseInt(params[0]);
      for (int i = -radius; i <= radius; i++) {
        for (int k = -radius; k <= radius; k++) {
          Chunk chunk =
              world.getChunkFromBlockCoords(
                  (int) player.posX + (i * 16), (int) player.posZ + (k * 16));
          for (int x = 0; x < 16; x++) {
            for (int z = 0; z < 16; z++) {
              for (int y = 0; y < 256; y++) {
                Block id = chunk.getBlock(x, y, z);
                if (id != TFCBlocks.Ore
                    && id != TFCBlocks.Ore2
                    && id != TFCBlocks.Ore3
                    && id != Blocks.bedrock)
                  world.setBlock(
                      x + (chunk.xPosition * 16), y, z + (chunk.zPosition * 16), Blocks.air, 0, 2);
              }
            }
          }
        }
      }

      TFC_Core.sendInfoMessage(player, new ChatComponentText("Stripping Chunk Complete"));
    }
  }
  private void handleChestPage(Packet250CustomPayload packet) {
    DataInputStream inputStream = new DataInputStream(new ByteArrayInputStream(packet.data));

    try {
      int x = inputStream.readInt();
      int y = inputStream.readInt();
      int z = inputStream.readInt();
      int d = inputStream.readInt();

      MinecraftServer s = MinecraftServer.getServer();
      WorldServer w = s.worldServerForDimension(d);
      TileEntity te = w.getBlockTileEntity(x, y, z);
      if (te instanceof YC_TileEntityBlockChest) {
        int t = 0;
        t = inputStream.readInt();
        int l = inputStream.readInt();
        String PlayerName = "";
        for (int i = 0; i < l; i++) {
          PlayerName = PlayerName + ((char) inputStream.readInt());
        }
        ((YC_TileEntityBlockChest) te).handlePacketDataPage(t, PlayerName);
        PacketDispatcher.sendPacketToAllAround(x, y, z, 16, d, te.getDescriptionPacket());
      }
    } catch (IOException e) {
      e.printStackTrace();
      return;
    }
  }
  /** Saves all necessary data as preparation for stopping the server. */
  public void stopServer() {
    if (!this.worldIsBeingDeleted) {
      this.func_98033_al().func_98233_a("Stopping server");

      if (this.getNetworkThread() != null) {
        this.getNetworkThread().stopListening();
      }

      if (this.serverConfigManager != null) {
        this.func_98033_al().func_98233_a("Saving players");
        this.serverConfigManager.saveAllPlayerData();
        this.serverConfigManager.removeAllPlayers();
      }

      this.func_98033_al().func_98233_a("Saving worlds");
      this.saveAllWorlds(false);

      for (int i = 0; i < this.worldServers.length; ++i) {
        WorldServer worldserver = this.worldServers[i];
        MinecraftForge.EVENT_BUS.post(new WorldEvent.Unload(worldserver));
        worldserver.flush();
      }

      WorldServer[] tmp = worldServers;
      for (WorldServer world : tmp) {
        DimensionManager.setWorld(world.provider.dimensionId, null);
      }

      if (this.usageSnooper != null && this.usageSnooper.isSnooperRunning()) {
        this.usageSnooper.stopSnooper();
      }
    }
  }
Example #9
0
  private static boolean trySpawnEntity(ItemStack stack, WorldServer world, EntityPlayerMP player) {
    int damage = stack.getItemDamage();
    if (damage >= stack.getMaxDamage()) return false;

    NBTTagCompound tag = ItemUtils.getItemTag(stack);
    String structureName = tag.getString(TAG_STRUCTURE);

    if (Strings.isNullOrEmpty(structureName)) return false;

    Map<String, ChunkPosition> nearbyStructures =
        StructureRegistry.instance.getNearestStructures(
            world, (int) player.posX, (int) player.posY, (int) player.posZ);

    ChunkPosition structurePos = nearbyStructures.get(structureName);
    if (structurePos != null) {
      if (Config.eyeDebug)
        player.addChatComponentMessage(
            new ChatComponentTranslation(
                "openblocks.misc.structure_pos",
                structureName,
                structurePos.chunkPosX,
                structurePos.chunkPosY,
                structurePos.chunkPosZ));

      stack.setItemDamage(damage + 1);
      EntityGoldenEye eye = new EntityGoldenEye(world, stack, player, structurePos);
      world.spawnEntityInWorld(eye);
      world.playSoundAtEntity(
          player, "random.bow", 0.5F, 0.4F / (itemRand.nextFloat() * 0.4F + 0.8F));
      return true;
    }
    return false;
  }
Example #10
0
  /** par1 indicates if a log message should be output. */
  protected void saveAllWorlds(boolean par1) {
    if (!this.worldIsBeingDeleted) {
      WorldServer[] aworldserver = this.worldServers;
      int i = aworldserver.length;

      for (int j = 0; j < i; ++j) {
        WorldServer worldserver = aworldserver[j];

        if (worldserver != null) {
          if (!par1) {
            this.func_98033_al()
                .func_98233_a(
                    "Saving chunks for level \'"
                        + worldserver.getWorldInfo().getWorldName()
                        + "\'/"
                        + worldserver.provider.getDimensionName());
          }

          try {
            worldserver.saveAllChunks(true, (IProgressUpdate) null);
          } catch (MinecraftException minecraftexception) {
            this.func_98033_al().func_98236_b(minecraftexception.getMessage());
          }
        }
      }
    }
  }
Example #11
0
  protected void initialWorldChunkLoad() {
    int i = 0;
    this.setUserMessage("menu.generatingTerrain");
    byte b0 = 0;
    this.func_98033_al().func_98233_a("Preparing start region for level " + b0);
    WorldServer worldserver = this.worldServers[b0];
    ChunkCoordinates chunkcoordinates = worldserver.getSpawnPoint();
    long j = System.currentTimeMillis();

    for (int k = -192; k <= 192 && this.isServerRunning(); k += 16) {
      for (int l = -192; l <= 192 && this.isServerRunning(); l += 16) {
        long i1 = System.currentTimeMillis();

        if (i1 - j > 1000L) {
          this.outputPercentRemaining("Preparing spawn area", i * 100 / 625);
          j = i1;
        }

        ++i;
        worldserver.theChunkProviderServer.loadChunk(
            chunkcoordinates.posX + k >> 4, chunkcoordinates.posZ + l >> 4);
      }
    }

    this.clearCurrentTask();
  }
  /** moves provided player from overworld to nether or vice versa */
  public void transferPlayerToDimension(EntityPlayerMP playerIn, int dimension) {
    int var3 = playerIn.dimension;
    WorldServer var4 = this.mcServer.worldServerForDimension(playerIn.dimension);
    playerIn.dimension = dimension;
    WorldServer var5 = this.mcServer.worldServerForDimension(playerIn.dimension);
    playerIn.playerNetServerHandler.sendPacket(
        new S07PacketRespawn(
            playerIn.dimension,
            playerIn.worldObj.getDifficulty(),
            playerIn.worldObj.getWorldInfo().getTerrainType(),
            playerIn.theItemInWorldManager.getGameType()));
    var4.removePlayerEntityDangerously(playerIn);
    playerIn.isDead = false;
    this.transferEntityToWorld(playerIn, var3, var4, var5);
    this.func_72375_a(playerIn, var4);
    playerIn.playerNetServerHandler.setPlayerLocation(
        playerIn.posX, playerIn.posY, playerIn.posZ, playerIn.rotationYaw, playerIn.rotationPitch);
    playerIn.theItemInWorldManager.setWorld(var5);
    this.updateTimeAndWeatherForPlayer(playerIn, var5);
    this.syncPlayerInventory(playerIn);
    Iterator var6 = playerIn.getActivePotionEffects().iterator();

    while (var6.hasNext()) {
      PotionEffect var7 = (PotionEffect) var6.next();
      playerIn.playerNetServerHandler.sendPacket(
          new S1DPacketEntityEffect(playerIn.getEntityId(), var7));
    }
  }
Example #13
0
 private void modifyWorld(WorldServer worldServer) {
   ChunkProviderServer cubeCache = cc.getServerChunkCacheAndInitWorld(worldServer);
   worldServer.theChunkProviderServer = cubeCache;
   WorldAccess.setChunkProvider(worldServer, cubeCache);
   WorldServerAccess.setPlayerManager(worldServer, cc.getPlayerManager(worldServer));
   worldServer.getGameRules().setOrCreateGameRule("doMobSpawning", String.valueOf(false));
 }
Example #14
0
  protected void initialWorldChunkLoad() {
    boolean var1 = true;
    boolean var2 = true;
    boolean var3 = true;
    boolean var4 = true;
    int var5 = 0;
    this.setUserMessage("menu.generatingTerrain");
    byte var6 = 0;
    logger.info("Preparing start region for level " + var6);
    WorldServer var7 = this.worldServers[var6];
    BlockPos var8 = var7.getSpawnPoint();
    long var9 = getCurrentTimeMillis();

    for (int var11 = -192; var11 <= 192 && this.isServerRunning(); var11 += 16) {
      for (int var12 = -192; var12 <= 192 && this.isServerRunning(); var12 += 16) {
        long var13 = getCurrentTimeMillis();

        if (var13 - var9 > 1000L) {
          this.outputPercentRemaining("Preparing spawn area", var5 * 100 / 625);
          var9 = var13;
        }

        ++var5;
        var7.theChunkProviderServer.loadChunk(var8.getX() + var11 >> 4, var8.getZ() + var12 >> 4);
      }
    }

    this.clearCurrentTask();
  }
 @SubscribeEvent
 public void onWorldLoad(WorldEvent.Load e) {
   if (e.world.provider.dimensionId == 1 && e.world instanceof WorldServer) {
     WorldServer world = (WorldServer) e.world;
     world.chunkProvider =
         world.theChunkProviderServer = new ChunkProviderHardcoreEndServer(world);
   }
 }
 /**
  * Called when a player disconnects from the game. Writes player data to disk and removes them
  * from the world.
  */
 public void playerLoggedOut(EntityPlayerMP par1EntityPlayerMP) {
   this.writePlayerData(par1EntityPlayerMP);
   WorldServer var2 = par1EntityPlayerMP.getServerForPlayer();
   var2.setEntityDead(par1EntityPlayerMP);
   var2.getPlayerManager().removePlayer(par1EntityPlayerMP);
   this.playerEntityList.remove(par1EntityPlayerMP);
   this.sendPacketToAllPlayers(new Packet201PlayerInfo(par1EntityPlayerMP.username, false, 9999));
 }
Example #17
0
  protected void loadAllWorlds(
      String par1Str, String par2Str, long par3, WorldType par5WorldType, String par6Str) {
    this.convertMapIfNeeded(par1Str);
    this.setUserMessage("menu.loadingLevel");
    ISaveHandler isavehandler = this.anvilConverterForAnvilFile.getSaveLoader(par1Str, true);
    WorldInfo worldinfo = isavehandler.loadWorldInfo();
    WorldSettings worldsettings;

    if (worldinfo == null) {
      worldsettings =
          new WorldSettings(
              par3,
              this.getGameType(),
              this.canStructuresSpawn(),
              this.isHardcore(),
              par5WorldType);
      worldsettings.func_82750_a(par6Str);
    } else {
      worldsettings = new WorldSettings(worldinfo);
    }

    if (this.enableBonusChest) {
      worldsettings.enableBonusChest();
    }

    WorldServer overWorld =
        (isDemo()
            ? new DemoWorldServer(this, isavehandler, par2Str, 0, theProfiler, func_98033_al())
            : new WorldServer(
                this, isavehandler, par2Str, 0, worldsettings, theProfiler, func_98033_al()));
    for (int dim : DimensionManager.getStaticDimensionIDs()) {
      WorldServer world =
          (dim == 0
              ? overWorld
              : new WorldServerMulti(
                  this,
                  isavehandler,
                  par2Str,
                  dim,
                  worldsettings,
                  overWorld,
                  theProfiler,
                  func_98033_al()));
      world.addWorldAccess(new WorldManager(this, world));

      if (!this.isSinglePlayer()) {
        world.getWorldInfo().setGameType(this.getGameType());
      }

      this.serverConfigManager.setPlayerManager(this.worldServers);

      MinecraftForge.EVENT_BUS.post(new WorldEvent.Load(world));
    }

    this.serverConfigManager.setPlayerManager(new WorldServer[] {overWorld});
    this.setDifficultyForAllWorlds(this.getDifficulty());
    this.initialWorldChunkLoad();
  }
  /** Updates the time and weather for the given player to those of the given world */
  public void updateTimeAndWeatherForPlayer(
      EntityPlayerMP par1EntityPlayerMP, WorldServer par2WorldServer) {
    par1EntityPlayerMP.playerNetServerHandler.sendPacketToPlayer(
        new Packet4UpdateTime(par2WorldServer.getTotalWorldTime(), par2WorldServer.getWorldTime()));

    if (par2WorldServer.isRaining()) {
      par1EntityPlayerMP.playerNetServerHandler.sendPacketToPlayer(new Packet70GameEvent(1, 0));
    }
  }
  public void func_72375_a(EntityPlayerMP playerIn, WorldServer worldIn) {
    WorldServer var3 = playerIn.getServerForPlayer();

    if (worldIn != null) {
      worldIn.getPlayerManager().removePlayer(playerIn);
    }

    var3.getPlayerManager().addPlayer(playerIn);
    var3.theChunkProviderServer.loadChunk((int) playerIn.posX >> 4, (int) playerIn.posZ >> 4);
  }
Example #20
0
 @Override
 public boolean unloadWorld(World world, boolean save) {
   WorldServer handle = ((CraftWorld) world).getHandle();
   WorldUnloadEvent ev = new WorldUnloadEvent(world);
   getPluginManager().callEvent(ev);
   if (ev.isCancelled()) return false; // cancelled
   DimensionManager.unloadWorld(handle.getWorldInfo().getDimension());
   worlds.remove(handle.getWorldInfo().getDimension());
   return true;
 }
  public void func_72375_a(EntityPlayerMP par1EntityPlayerMP, WorldServer par2WorldServer) {
    WorldServer var3 = par1EntityPlayerMP.getServerForPlayer();

    if (par2WorldServer != null) {
      par2WorldServer.getPlayerManager().removePlayer(par1EntityPlayerMP);
    }

    var3.getPlayerManager().addPlayer(par1EntityPlayerMP);
    var3.theChunkProviderServer.loadChunk(
        (int) par1EntityPlayerMP.posX >> 4, (int) par1EntityPlayerMP.posZ >> 4);
  }
Example #22
0
	@Override
	public World getWorld(UUID uid) {
		for (WorldServer w : theServer.worldServers) {
			//return null;
			UUID wUUID = new UUID(w.getSeed(), w.getWorldInfo().getDimension());
			if (wUUID == uid) {
				return worlds.get(w.getWorldInfo().getDimension());
			}
			//if (w.getWorldInfo().)
		}
		return null;
	}
Example #23
0
  public void addServerStatsToSnooper(PlayerUsageSnooper par1PlayerUsageSnooper) {
    par1PlayerUsageSnooper.addData("whitelist_enabled", Boolean.valueOf(false));
    par1PlayerUsageSnooper.addData("whitelist_count", Integer.valueOf(0));
    par1PlayerUsageSnooper.addData(
        "players_current", Integer.valueOf(this.getCurrentPlayerCount()));
    par1PlayerUsageSnooper.addData("players_max", Integer.valueOf(this.getMaxPlayers()));
    par1PlayerUsageSnooper.addData(
        "players_seen", Integer.valueOf(this.serverConfigManager.getAvailablePlayerDat().length));
    par1PlayerUsageSnooper.addData("uses_auth", Boolean.valueOf(this.onlineMode));
    par1PlayerUsageSnooper.addData("gui_state", this.getGuiEnabled() ? "enabled" : "disabled");
    par1PlayerUsageSnooper.addData(
        "avg_tick_ms", Integer.valueOf((int) (MathHelper.average(this.tickTimeArray) * 1.0E-6D)));
    par1PlayerUsageSnooper.addData(
        "avg_sent_packet_count",
        Integer.valueOf((int) MathHelper.average(this.sentPacketCountArray)));
    par1PlayerUsageSnooper.addData(
        "avg_sent_packet_size",
        Integer.valueOf((int) MathHelper.average(this.sentPacketSizeArray)));
    par1PlayerUsageSnooper.addData(
        "avg_rec_packet_count",
        Integer.valueOf((int) MathHelper.average(this.receivedPacketCountArray)));
    par1PlayerUsageSnooper.addData(
        "avg_rec_packet_size",
        Integer.valueOf((int) MathHelper.average(this.receivedPacketSizeArray)));
    int i = 0;

    for (int j = 0; j < this.worldServers.length; ++j) {
      if (this.worldServers[j] != null) {
        WorldServer worldserver = this.worldServers[j];
        WorldInfo worldinfo = worldserver.getWorldInfo();
        par1PlayerUsageSnooper.addData(
            "world[" + i + "][dimension]", Integer.valueOf(worldserver.provider.dimensionId));
        par1PlayerUsageSnooper.addData("world[" + i + "][mode]", worldinfo.getGameType());
        par1PlayerUsageSnooper.addData(
            "world[" + i + "][difficulty]", Integer.valueOf(worldserver.difficultySetting));
        par1PlayerUsageSnooper.addData(
            "world[" + i + "][hardcore]", Boolean.valueOf(worldinfo.isHardcoreModeEnabled()));
        par1PlayerUsageSnooper.addData(
            "world[" + i + "][generator_name]", worldinfo.getTerrainType().getWorldTypeName());
        par1PlayerUsageSnooper.addData(
            "world[" + i + "][generator_version]",
            Integer.valueOf(worldinfo.getTerrainType().getGeneratorVersion()));
        par1PlayerUsageSnooper.addData(
            "world[" + i + "][height]", Integer.valueOf(this.buildLimit));
        par1PlayerUsageSnooper.addData(
            "world[" + i + "][chunks_loaded]",
            Integer.valueOf(worldserver.getChunkProvider().getLoadedChunkCount()));
        ++i;
      }
    }

    par1PlayerUsageSnooper.addData("worlds", Integer.valueOf(i));
  }
  private void handleLowPower(Integer id, int power, boolean doEffects) {
    if (power <= 0) {
      // We ran out of power!
      WorldServer world = DimensionManager.getWorld(id);
      if (world != null) {
        List<EntityPlayer> players = new ArrayList<EntityPlayer>(world.playerEntities);
        if (DimletConfiguration.dimensionDifficulty >= 1) {
          for (EntityPlayer player : players) {
            if (!RfToolsDimensionManager.checkValidPhasedFieldGenerator(player, true)) {
              player.attackEntityFrom(new DamageSourcePowerLow("powerLow"), 1000000.0f);
            } else {
              if (doEffects && DimletConfiguration.phasedFieldGeneratorDebuf) {
                player.addPotionEffect(
                    new PotionEffect(Potion.moveSlowdown.getId(), EFFECTS_MAX * MAXTICKS, 4, true));
                player.addPotionEffect(
                    new PotionEffect(Potion.digSlowdown.getId(), EFFECTS_MAX * MAXTICKS, 2, true));
                player.addPotionEffect(
                    new PotionEffect(Potion.hunger.getId(), EFFECTS_MAX * MAXTICKS, 2, true));
              }
            }
          }
        } else {
          Random random = new Random();
          for (EntityPlayer player : players) {
            if (!RfToolsDimensionManager.checkValidPhasedFieldGenerator(player, true)) {
              WorldServer worldServerForDimension =
                  MinecraftServer.getServer()
                      .worldServerForDimension(DimletConfiguration.spawnDimension);
              int x = random.nextInt(2000) - 1000;
              int z = random.nextInt(2000) - 1000;
              int y = worldServerForDimension.getTopSolidOrLiquidBlock(x, z);
              if (y == -1) {
                y = 63;
              }

              TeleportationTools.teleportToDimension(
                  player, DimletConfiguration.spawnDimension, x, y, z);
            } else {
              if (doEffects) {
                player.addPotionEffect(
                    new PotionEffect(Potion.moveSlowdown.getId(), EFFECTS_MAX * MAXTICKS, 4, true));
                player.addPotionEffect(
                    new PotionEffect(Potion.digSlowdown.getId(), EFFECTS_MAX * MAXTICKS, 4, true));
                player.addPotionEffect(
                    new PotionEffect(Potion.hunger.getId(), EFFECTS_MAX * MAXTICKS, 2, true));
              }
            }
          }
        }
      }
    }
  }
  /**
   * Called when a player successfully logs in. Reads player data from disk and inserts the player
   * into the world.
   */
  public void playerLoggedIn(EntityPlayerMP par1EntityPlayerMP) {
    this.sendPacketToAllPlayers(new Packet201PlayerInfo(par1EntityPlayerMP.username, true, 1000));
    this.playerEntityList.add(par1EntityPlayerMP);
    WorldServer var2 = this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension);
    var2.spawnEntityInWorld(par1EntityPlayerMP);
    this.func_72375_a(par1EntityPlayerMP, (WorldServer) null);

    for (int var3 = 0; var3 < this.playerEntityList.size(); ++var3) {
      EntityPlayerMP var4 = (EntityPlayerMP) this.playerEntityList.get(var3);
      par1EntityPlayerMP.playerNetServerHandler.sendPacketToPlayer(
          new Packet201PlayerInfo(var4.username, true, var4.ping));
    }
  }
  public static void initDimension(int dim) {
    WorldServer overworld = getWorld(0);
    if (overworld == null) {
      throw new RuntimeException("Cannot Hotload Dim: Overworld is not Loaded!");
    }
    try {
      DimensionManager.getProviderType(dim);
    } catch (Exception e) {
      System.err.println("Cannot Hotload Dim: " + e.getMessage());
      return; // If a provider hasn't been registered then we can't hotload the dim
    }
    MinecraftServer mcServer = overworld.getMinecraftServer();
    ISaveHandler savehandler = overworld.getSaveHandler();
    WorldSettings worldSettings = new WorldSettings(overworld.getWorldInfo());

    WorldServer world =
        (dim == 0
            ? overworld
            : new WorldServerMulti(
                mcServer,
                savehandler,
                overworld.getWorldInfo().getWorldName(),
                dim,
                worldSettings,
                overworld,
                mcServer.theProfiler));
    world.addWorldAccess(new WorldManager(mcServer, world));
    MinecraftForge.EVENT_BUS.post(new WorldEvent.Load(world));
    if (!mcServer.isSinglePlayer()) {
      world.getWorldInfo().setGameType(mcServer.getGameType());
    }

    mcServer.func_147139_a(mcServer.func_147135_j());
  }
  private void handleFireworks(WorldServer world) {
    if (random.nextFloat() < 0.05) {
      // Calculate a bounding box for all players in the world.
      double minPosX = 1000000000.0f;
      double minPosZ = 1000000000.0f;
      double maxPosX = -1000000000.0f;
      double maxPosZ = -1000000000.0f;
      for (Object playerEntity : world.playerEntities) {
        EntityPlayer player = (EntityPlayer) playerEntity;
        if (player.posX > maxPosX) {
          maxPosX = player.posX;
        }
        if (player.posX < minPosX) {
          minPosX = player.posX;
        }
        if (player.posZ > maxPosZ) {
          maxPosZ = player.posZ;
        }
        if (player.posZ < minPosZ) {
          minPosZ = player.posZ;
        }
      }
      double posX = random.nextFloat() * (maxPosX - minPosX + 60.0f) + minPosX - 30.0f;
      double posZ = random.nextFloat() * (maxPosZ - minPosZ + 60.0f) + minPosZ - 30.0f;

      ItemStack fireworkStack = new ItemStack(Items.fireworks);
      NBTTagCompound tag = new NBTTagCompound();

      NBTTagCompound fireworks = new NBTTagCompound();
      fireworks.setByte("Flight", (byte) 2);

      NBTTagList explosions = new NBTTagList();
      explosions.appendTag(makeExplosion(tag));
      fireworks.setTag("Explosions", explosions);

      tag.setTag("Fireworks", fireworks);

      fireworkStack.setTagCompound(tag);

      int y = world.getTopSolidOrLiquidBlock((int) posX, (int) posZ);
      if (y == -1) {
        y = 64;
      } else {
        y += 3;
      }
      EntityFireworkRocket entityfireworkrocket =
          new EntityFireworkRocket(world, posX, y, posZ, fireworkStack);
      world.spawnEntityInWorld(entityfireworkrocket);
    }
  }
Example #28
0
  public void addServerStatsToSnooper(PlayerUsageSnooper playerSnooper) {
    playerSnooper.addClientStat("whitelist_enabled", Boolean.valueOf(false));
    playerSnooper.addClientStat("whitelist_count", Integer.valueOf(0));

    if (this.serverConfigManager != null) {
      playerSnooper.addClientStat("players_current", Integer.valueOf(this.getCurrentPlayerCount()));
      playerSnooper.addClientStat("players_max", Integer.valueOf(this.getMaxPlayers()));
      playerSnooper.addClientStat(
          "players_seen", Integer.valueOf(this.serverConfigManager.getAvailablePlayerDat().length));
    }

    playerSnooper.addClientStat("uses_auth", Boolean.valueOf(this.onlineMode));
    playerSnooper.addClientStat("gui_state", this.getGuiEnabled() ? "enabled" : "disabled");
    playerSnooper.addClientStat(
        "run_time",
        Long.valueOf(
            (getCurrentTimeMillis() - playerSnooper.getMinecraftStartTimeMillis()) / 60L * 1000L));
    playerSnooper.addClientStat(
        "avg_tick_ms", Integer.valueOf((int) (MathHelper.average(this.tickTimeArray) * 1.0E-6D)));
    int var2 = 0;

    if (this.worldServers != null) {
      for (int var3 = 0; var3 < this.worldServers.length; ++var3) {
        if (this.worldServers[var3] != null) {
          WorldServer var4 = this.worldServers[var3];
          WorldInfo var5 = var4.getWorldInfo();
          playerSnooper.addClientStat(
              "world[" + var2 + "][dimension]", Integer.valueOf(var4.provider.getDimensionId()));
          playerSnooper.addClientStat("world[" + var2 + "][mode]", var5.getGameType());
          playerSnooper.addClientStat("world[" + var2 + "][difficulty]", var4.getDifficulty());
          playerSnooper.addClientStat(
              "world[" + var2 + "][hardcore]", Boolean.valueOf(var5.isHardcoreModeEnabled()));
          playerSnooper.addClientStat(
              "world[" + var2 + "][generator_name]", var5.getTerrainType().getWorldTypeName());
          playerSnooper.addClientStat(
              "world[" + var2 + "][generator_version]",
              Integer.valueOf(var5.getTerrainType().getGeneratorVersion()));
          playerSnooper.addClientStat(
              "world[" + var2 + "][height]", Integer.valueOf(this.buildLimit));
          playerSnooper.addClientStat(
              "world[" + var2 + "][chunks_loaded]",
              Integer.valueOf(var4.getChunkProvider().getLoadedChunkCount()));
          ++var2;
        }
      }
    }

    playerSnooper.addClientStat("worlds", Integer.valueOf(var2));
  }
Example #29
0
 public WorldServerMulti(
     MinecraftServer p_i11030_1_,
     ISaveHandler p_i11030_2_,
     String p_i11030_3_,
     int p_i11030_4_,
     WorldSettings p_i11030_5_,
     WorldServer p_i11030_6_,
     Profiler p_i11030_7_,
     ILogAgent p_i11030_8_) {
   super(
       p_i11030_1_, p_i11030_2_, p_i11030_3_, p_i11030_4_, p_i11030_5_, p_i11030_7_, p_i11030_8_);
   this.field_72988_C = p_i11030_6_.field_72988_C;
   this.field_96442_D = p_i11030_6_.func_96441_U();
   this.field_72986_A = new DerivedWorldInfo(p_i11030_6_.func_72912_H());
 }
Example #30
0
  /** Send message to all within 64 blocks that have this chunk loaded */
  public static void sendToNearby(World world, BlockPos pos, IMessage toSend) {
    if (world instanceof WorldServer) {
      WorldServer ws = (WorldServer) world;

      for (EntityPlayer player : ws.playerEntities) {
        EntityPlayerMP playerMP = (EntityPlayerMP) player;

        if (playerMP.getDistanceSq(pos) < 64 * 64
            && ws.getPlayerChunkMap()
                .isPlayerWatchingChunk(playerMP, pos.getX() >> 4, pos.getZ() >> 4)) {
          HANDLER.sendTo(toSend, playerMP);
        }
      }
    }
  }