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()]); }
/** 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()); } } } } }
/** 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(); } } }
@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(); } } }
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; }
/** 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()); } } } } }
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)); } }
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)); }
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)); }
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); }
@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); }
@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; }
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); } }
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)); }
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()); }
/** 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); } } } }