private boolean isAllowedToEdit(EntityPlayer player, ItemStack remote) { NBTTagCompound tag = remote.getTagCompound(); if (tag != null) { if (tag.hasKey("securityX")) { int x = tag.getInteger("securityX"); int y = tag.getInteger("securityY"); int z = tag.getInteger("securityZ"); int dimensionId = tag.getInteger("securityDimension"); WorldServer world = DimensionManager.getWorld(dimensionId); if (world != null) { TileEntity te = world.getTileEntity(new BlockPos(x, y, z)); if (te instanceof TileEntitySecurityStation) { boolean canAccess = ((TileEntitySecurityStation) te).doesAllowPlayer(player); if (!canAccess) { player.sendStatusMessage(new TextComponentTranslation("gui.remote.noEditRights", x, y, z), false); } return canAccess; } } } } return true; }
@Override public void onUpdate(ItemStack remote, World worl, Entity entity, int slot, boolean holdingItem) { if (!worl.isRemote) { NBTTagCompound tag = remote.getTagCompound(); if (tag != null) { if (tag.hasKey("securityX")) { int x = tag.getInteger("securityX"); int y = tag.getInteger("securityY"); int z = tag.getInteger("securityZ"); int dimensionId = tag.getInteger("securityDimension"); WorldServer world = DimensionManager.getWorld(dimensionId); if (world != null) { TileEntity te = world.getTileEntity(new BlockPos(x, y, z)); if (!(te instanceof TileEntitySecurityStation)) { tag.removeTag("securityX"); tag.removeTag("securityY"); tag.removeTag("securityZ"); tag.removeTag("securityDimension"); } } } } } }
@SubscribeEvent public void move(TickEvent.PlayerTickEvent event) { if (event.player.world.isRemote) { //System.out.println("CLIENT "+event.player.world.getBiome(event.player.getPosition()).getBiomeName()); return; } //System.out.println(event.player.world.getBiome(event.player.getPosition()).getBiomeName()); if (CommonProxy.d == 0) { return; } World w = event.player.world; if (w != null && w.getWorldType() == WorldType.DEFAULT) { new SpawnTeleport(DimensionManager.getWorld(CommonProxy.d)).teleport(event.player, DimensionManager.getWorld(CommonProxy.d)); } }
private boolean isFakePlayer(Entity entity) { if (!(entity instanceof EntityPlayer)) { return false; } if (entity instanceof FakePlayer) { return true; } // If this returns false it is still possible we have a fake player. Try to find the player in the list of online players PlayerList playerList = DimensionManager.getWorld(0).getMinecraftServer().getPlayerList(); EntityPlayerMP playerByUUID = playerList.getPlayerByUUID(((EntityPlayer) entity).getGameProfile().getId()); if (playerByUUID == null) { // The player isn't online. Then it can't be real return true; } // The player is in the list. But is it this player? return entity != playerByUUID; }
/** * Called when this EntityThrowable hits a block or entity. */ @Override protected void onImpact(RayTraceResult result) { if (!world.isRemote) { if (result.typeOfHit == RayTraceResult.Type.BLOCK) { EntityPlayer player = null; if (playerId != null) { MinecraftServer server = DimensionManager.getWorld(0).getMinecraftServer(); player = playerId == null ? null : server.getPlayerList().getPlayerByUUID(playerId); } if (player != null) { TeleportationTools.makePortalPair(player, result.getBlockPos(), result.sideHit, destination); } else { TeleportationTools.makePortalPair(world, result.getBlockPos(), result.sideHit, destination); } } this.setDead(); } }
@Override public void handleData(NBTTagCompound data) { Biome b = Biome.getBiome(data.getInteger("biomeID")); DimBlockPos dbp = SerializationUtils.deserialize(data.getByteArray("blockPosData")); if (MC.getSide() == Side.CLIENT) { VoidApi.proxy.getClientListener().addScheduledTask(() -> { if (VoidApi.proxy.getClientWorld().isBlockLoaded(dbp.pos)) ChunkUtils.setBiomeAt(b, dbp.pos, VoidApi.proxy.getClientWorld());} ); } else { WorldServer ws = DimensionManager.getWorld(dbp.dim); ws.addScheduledTask(() -> { if (ws.isBlockLoaded(dbp.pos)) ChunkUtils.setBiomeAt(b, dbp.pos, ws);} ); } }
@Override public void set(GlobalChunkPos pos, float value) { if (loaded.containsKey(pos)) if (loaded.get(pos).equals(value)) return; loaded.put(pos, value); WorldServer wrld = DimensionManager.getWorld(pos.getDimension()); wrld.getChunkFromChunkCoords(pos.getX(), pos.getZ()).markDirty(); PlayerChunkMapEntry map = wrld.getPlayerChunkMap().getEntry(pos.getX(), pos.getZ()); if (map != null) { for (EntityPlayerMP p : map.players) { NetworkManager.sendTo(new CPacketSyncSif(pos, value), p); } } }
public static String getNiceDimensionName(int dim) { // try to get a nice dimension name String dimName = DimensionManager.getProvider(dim).getDimensionType().getName() .replaceAll("(\\p{Ll})(\\p{Lu})", "$1 $2").replace("_", " ").trim(); // TODO clean up this formatting mess String[] dimNameWords = dimName.split(" "); for (int i = 0; i < dimNameWords.length; i++) { if (dimNameWords[i].length() > 1) { dimNameWords[i] = dimNameWords[i].substring(0, 1).toUpperCase() + dimNameWords[i].substring(1); } } return String.join(" ", dimNameWords); }
@Override public void startNewDay() { if (oldHandler != null) oldHandler.startNewDay(); //Start the new day if (FirstAidConfig.externalHealing.sleepHealing == 0F) return; WorldSleepState sleepState = Morpheus.playerSleepStatus.get(0); if (sleepState == null) return; if (areEnoughPlayersAsleep(sleepState)) { World world = DimensionManager.getWorld(0); for (EntityPlayer player : world.playerEntities) { if (player.isPlayerFullyAsleep()) { HealthDistribution.distributeHealth(FirstAid.activeHealingConfig.sleepHealing, player, true); //heal the player who did sleep } } } }
@Override public void onCraftingMatrixChanged() { if (currentRecipe == null || !currentRecipe.matches(matrix, DimensionManager.getWorld(controllerDimension))) { currentRecipe = CraftingManager.findMatchingRecipe(matrix, DimensionManager.getWorld(controllerDimension)); } if (currentRecipe == null) { result.setInventorySlotContents(0, ItemStack.EMPTY); } else { result.setInventorySlotContents(0, currentRecipe.getCraftingResult(matrix)); } if (!getStack().hasTagCompound()) { getStack().setTagCompound(new NBTTagCompound()); } StackUtils.writeItems(matrix, 1, getStack().getTagCompound()); }
public Optional<Boolean> isChunkLoaded(ItemStack stack) { if (!stack.hasTagCompound()) return UNATTUNED; NBTTagCompound tag = stack.getTagCompound(); if (tag.hasKey("world")) { int worldId = tag.getInteger("world"); if (!DimensionManager.isDimensionRegistered(worldId)) return UNATTUNED; //We're reasonably certain at this point the unloader is attuned to a valid world. WorldServer world = DimensionManager.getWorld(worldId); if (world==null) return UNLOADED; //boolean playerLoad = world.getPlayerChunkMap().contains(tag.getInteger("x"), tag.getInteger("z")); //System.out.println("chunk["+tag.getInteger("x")+","+tag.getInteger("z")+"] isPlayerLoaded:"+playerLoad); Chunk chunk = world.getChunkProvider().getLoadedChunk(tag.getInteger("x"), tag.getInteger("z")); return (chunk!=null) ? LOADED : UNLOADED; //Chunk chunk = world.getChunkFromChunkCoords(tag.getInteger("x"),tag.getInteger("z")); //return (chunk.isLoaded()) ? LOADED : UNLOADED; } return UNATTUNED; }
public boolean unloadChunk(ItemStack stack) { if (!stack.hasTagCompound()) return false; NBTTagCompound tag = stack.getTagCompound(); if (tag.getBoolean("ignoreClick")) { tag.removeTag("ignoreClick"); stack.setTagCompound(tag); return false; } int worldId = tag.getInteger("world"); int x = tag.getInteger("x"); int z = tag.getInteger("z"); World world = DimensionManager.getWorld(worldId); if (world==null) return false; IChunkProvider provider = world.getChunkProvider(); Chunk chunk = provider.getLoadedChunk(x, z); if (chunk==null) return false; if (provider instanceof ChunkProviderServer) { ((ChunkProviderServer) provider).queueUnload(chunk); return true; } else { return false; } }
public static void init() { ExampleMod.logger.info("ATTEMPTING TO COMMIT GREAT EVIL:"); try { doImmenseEvil(); } catch(Throwable e) { e.printStackTrace(); } MinecraftForge.EVENT_BUS.register(new Listener()); grassCache = CacheBuilder.newBuilder() .maximumSize(2048) .build( new CacheLoader<GrassCacheKey, Biome>() { @Override public Biome load(GrassCacheKey key) { return DimensionManager.getWorld(key.dim).getBiome(new BlockPos(key.x, 63, key.z)); } } ); }
public static Data getData() { if (data != null) return data; MinecraftServer server = FMLCommonHandler.instance().getMinecraftServerInstance(); Integer[] dimsObj = DimensionManager.getIDs(); TIntDoubleMap map = new TIntDoubleHashMap(dimsObj.length); for (Integer dim : dimsObj) { map.put(dim, mean(server.worldTickTimes.get(dim)) * 1.0E-6D); } double meanTickTime = mean(server.tickTimeArray) * 1.0E-6D; int total = (int) (Runtime.getRuntime().totalMemory() / 1024 / 1024); int max = (int) (Runtime.getRuntime().maxMemory() / 1024 / 1024); int free = (int) (Runtime.getRuntime().freeMemory() / 1024 / 1024); data = new Data(meanTickTime, map, free, total, max); return data; }
/** * Performs a case-sensitive search for a loaded world by a given name. * * First, it tries to match the name with dimension 0 (overworld), then it tries to * match from the world's save folder name (e.g. DIM_MYST10) and then finally the * Dynmap compatible identifier (e.g. DIM10) * * @param name Name of world to find * @return World if found, else null */ public static WorldServer getWorld(String name) { if ( name == null || name.isEmpty() ) throw new IllegalArgumentException("World name cannot be empty or null"); for ( WorldServer world : DimensionManager.getWorlds() ) { String dimName = "DIM" + world.provider.getDimension(); String saveFolder = world.provider.getSaveFolder(); if (world.provider.getDimension() == 0) { // Special case for dimension 0 (overworld) if ( WorldBorder.SERVER.getFolderName().equals(name) ) return world; } else if ( saveFolder.equals(name) || dimName.equals(name) ) return world; } return null; }
public static void checkPlayers() { final World worldObj = (World)DimensionManager.getWorld(1); if (worldObj == null || worldObj.isRemote) { EventHandlerSiege.SiegeParticipants.clear(); return; } if (EventHandlerSiege.SiegeParticipants.size() > 0) { for (int i = 0; i < EventHandlerSiege.SiegeParticipants.size(); ++i) { if (worldObj.getPlayerEntityByName((String)EventHandlerSiege.SiegeParticipants.get(i)) == null) { EventHandlerSiege.SiegeParticipants.remove(EventHandlerSiege.SiegeParticipants.get(i)); --i; } } if (EventHandlerSiege.SiegeParticipants.size() == 0) { endSiege(worldObj, true); } } }
@SubscribeEvent public void addUnstableTimer(final SmelteryCastedEvent.CastingTable event) { if (ExtraUtils.tcon_unstable_material_id <= 0) { return; } final ItemStack output = event.output; if (output == null || !(output.getItem() instanceof IToolPart)) { return; } final IToolPart part = (IToolPart)output.getItem(); if (part.getMaterialID(output) != ExtraUtils.tcon_unstable_material_id) { return; } final NBTTagCompound tag = getOrInitTag(output); final WorldServer world = DimensionManager.getWorld(0); if (world == null) { return; } tag.setLong("XUDeadline", world.getTotalWorldTime()); final WorldServer localWorld = DimensionManager.getWorld(this.curDim); if (localWorld != null) { tag.setLong("XULocalDeadline", localWorld.getTotalWorldTime()); tag.setInteger("XULocalDim", this.curDim); } }
@SubscribeEvent(priority = EventPriority.LOWEST) public void denyCraft(final ToolBuildEvent event) { if (ExtraUtils.tcon_unstable_material_id <= 0) { return; } final WorldServer world = DimensionManager.getWorld(0); if (world == null) { return; } if (isToolExpired(event.headStack, world) || isToolExpired(event.handleStack, world) || isToolExpired(event.accessoryStack, world) || isToolExpired(event.extraStack, world)) { event.headStack = null; event.handleStack = null; event.accessoryStack = null; event.extraStack = null; } }
private static void readFromFile() { if (saveDir == null) saveDir = DimensionManager.getCurrentSaveRootDirectory(); if (saveDir == null) { Overlord.logError("Could not get save directory. Either you are connected to a server or Squads will not load properly."); instance = new Squads(); return; } File f = new File(saveDir, dataFileName); if (f.exists()) { try { ObjectInputStream stream = new ObjectInputStream(new FileInputStream(f)); instance = (Squads) stream.readObject(); stream.close(); } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); instance = new Squads(); f.delete(); } } if (instance == null) instance = new Squads(); }
public void registerOverriddenDimensions() { for (DimensionConfigEntry entry : this.dimensions.values()) { if (Configs.enableUnregisteringDimensions && entry.getUnregister() && DimensionManager.isDimensionRegistered(entry.getId())) { JustEnoughDimensions.logInfo("Unregistering dimension {}...", entry.getId()); DimensionManager.unregisterDimension(entry.getId()); } else if (entry.getOverride() && (Configs.enableReplacingRegisteredDimensions || DimensionManager.isDimensionRegistered(entry.getId()) == false)) { this.registerDimension(entry.getId(), entry); } } }
private static void readFromFile() { if (saveDir == null) saveDir = DimensionManager.getCurrentSaveRootDirectory(); if (saveDir == null) { Overlord.logError("Could not get save directory. Enemies will not load properly."); instance = new Enemies(); return; } File f = new File(saveDir, dataFileName); if (f.exists()) { try { ObjectInputStream stream = new ObjectInputStream(new FileInputStream(f)); instance = (Enemies) stream.readObject(); stream.close(); } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); instance = new Enemies(); f.delete(); } } if (instance == null) instance = new Enemies(); }
/*** * Now returns a boolean to indicate whether registration of the WorldProvider type was successful. * (If it failed, you should probably set the CelestialBody as unreachable.) * * @param id * @param provider * @param keepLoaded * @return <boolean> success */ public static boolean registerProvider(int id, Class<? extends WorldProvider> provider, boolean keepLoaded, int defaultID) { boolean flag = DimensionManager.registerProviderType(id, provider, keepLoaded); if (flag) { GalacticraftRegistry.worldProviderIDs.add(id); return true; } else { GalacticraftRegistry.worldProviderIDs.add(defaultID); //Adding the 0 here preserves the order, important for network compatibility between GC versions FMLLog.severe("Could not register dimension " + id + " - does it clash with another mod? Change the ID in config."); return false; } }
private static File getSaveDir() { if (DimensionManager.getWorld(0) != null) { File saveDir = new File(DimensionManager.getCurrentSaveRootDirectory(), "galacticraft"); if (!saveDir.exists()) { if (!saveDir.mkdirs()) { GCLog.severe("Could not create chunk loader save data folder: " + saveDir.getAbsolutePath()); } } return saveDir; } return null; }
public static void registerPlanetClient(Integer dimID, int providerIndex) { int providerID = GalacticraftRegistry.getProviderID(providerIndex); if (providerID == 0) { GCLog.severe("Server dimension " + dimID + " has no match on client due to earlier registration problem."); } else { if (!WorldUtil.registeredPlanets.contains(dimID)) { WorldUtil.registeredPlanets.add(dimID); DimensionManager.registerDimension(dimID, providerID); } else { GCLog.severe("Dimension already registered to another mod: unable to register planet dimension " + dimID); } } }
public static SpaceStationWorldData bindSpaceStationToNewDimension(World world, EntityPlayerMP player, int homePlanetID) { int dynamicProviderID = -1; int staticProviderID = -1; for (Satellite satellite : GalaxyRegistry.getRegisteredSatellites().values()) { if (satellite.getParentPlanet().getDimensionID() == homePlanetID) { dynamicProviderID = satellite.getDimensionID(); staticProviderID = satellite.getDimensionIdStatic(); } } if (dynamicProviderID == -1 || staticProviderID == -1) { throw new RuntimeException("Space station being bound on bad provider IDs!"); } int newID = DimensionManager.getNextFreeDimId(); SpaceStationWorldData data = WorldUtil.createSpaceStation(world, newID, homePlanetID, dynamicProviderID, staticProviderID, player); dimNames.put(newID, "Space Station " + newID); GCPlayerStats stats = GCPlayerStats.get(player); stats.spaceStationDimensionData.put(homePlanetID, newID); GalacticraftCore.packetPipeline.sendTo(new PacketSimple(EnumSimplePacket.C_UPDATE_SPACESTATION_CLIENT_ID, new Object[] { WorldUtil.spaceStationDataToString(stats.spaceStationDimensionData) }), player); return data; }
public void unregisterCustomDimensions() { Set<Integer> toRemove = new HashSet<Integer>(); for (int dimension : this.registeredDimensions) { if (dimension != 0 && DimensionManager.isDimensionRegistered(dimension) && DimensionManager.getWorld(dimension) == null) { JustEnoughDimensions.logInfo("Unregistering dimension {}...", dimension); DimensionManager.unregisterDimension(dimension); toRemove.add(dimension); } } this.registeredDimensions.removeAll(toRemove); }
@Override public void call(String[] args) { DSTeleporter tp = getTp(); if (arg0.equalsIgnoreCase("gob")) { tp.destination = selected.getMinCorner(); } else if (arg0.equalsIgnoreCase("got")) { tp.destination = selected.getMaxCorner(); } else { tp.destination = selected.getCenter(); } if (DimensionManager.getWorld(DeltaChunk.getDimensionId()) != player.worldObj) { manager.transferPlayerToDimension(player, DeltaChunk.getDimensionId(), tp); } else { tp.destination.x--; tp.destination.moveToTopBlock(); player.setPositionAndUpdate(tp.destination.x + 0.5, tp.destination.y, tp.destination.z + 0.5); } }
public static final String getDimensionName(UUID requestID, int dimension){ if(FMLCommonHandler.instance().getSide() == Side.SERVER){ try{ DimensionType type = DimensionManager.getProviderType(dimension); return type.getName(); } catch(Exception e){} } else { if(!DIMENSION_NAMES.containsKey(dimension)){ CrystalModNetwork.sendToServer(new PacketDimensionNameRequest(requestID, dimension)); } else { return DIMENSION_NAMES.get(dimension); } } return ""+dimension; }
public static void worldLoad(FMLServerStartedEvent serverStartedEvent) throws IOException { File worldFile = new File(FMLCommonHandler.instance().getSavesDirectory(), FMLCommonHandler.instance().getMinecraftServerInstance().getFolderName()); File dataFile = new File(worldFile, fileName); if (!dataFile.exists()) { return; } String json = FileUtils.readFileToString(dataFile); Gson gson = new Gson(); Type typeOfHashMap = new TypeToken<List<DimData>>() { }.getType(); List<DimData> tempDataList = gson.fromJson(json, typeOfHashMap); for (DimData data : tempDataList) { DimensionType type = DimensionType.register("technicaldimensions", data.name, data.id, CustomWorldProvider.class, false); DimensionManager.registerDimension(data.id, type); data.type = type; dimDataHashMap.put(data.id, data); dimDataList.add(data); } }
public static void unloadAll(FMLServerStoppingEvent serverStoppingEvent) { File worldFile = new File(FMLCommonHandler.instance().getSavesDirectory(), FMLCommonHandler.instance().getMinecraftServerInstance().getFolderName()); File dataFile = new File(worldFile, fileName); if (dimDataList == null || dimDataList.isEmpty()) { return; } Gson gson = new GsonBuilder().setPrettyPrinting().create(); String json = gson.toJson(dimDataList); try { if (dataFile.exists()) { dataFile.delete(); } FileUtils.writeStringToFile(dataFile, json); } catch (IOException e) { e.printStackTrace(); } for (DimData data : dimDataList) { DimensionManager.unloadWorld(data.id); DimensionManager.unregisterDimension(data.id); } dimDataList.clear(); dimDataHashMap.clear(); }
@Override protected void applyWithTargetDimension(Entity target, int targetDim, CallbackMetadata metadata) { WorldServer worldServer = DimensionManager.getWorld(targetDim); if(worldServer == null) { LogHelper.error("Attempted to set the time for a world (" + targetDim + ") that doesn't exist."); runCallbacks(onFailure, target, metadata); runCallbacks(onComplete, target, metadata); return; } // Calc how far we need to set it: int dayTickLength = CraftingHarmonicsMod.getConfigManager().getDayTickLength(); long curTime = worldServer.getWorldTime(); long newTime = (curTime % dayTickLength) + time; // If we were going to set it back, then we need to add a day: if(newTime < curTime) newTime += dayTickLength; // Actually set the time now... worldServer.setWorldTime(newTime); runCallbacks(onSuccess, target, metadata); runCallbacks(onComplete, target, metadata); }
@Mod.EventHandler public void load(FMLInitializationEvent event) { if (Config.voidNether == true) { wtvn = new WorldTypeVoidNether(); DimensionManager.unregisterDimension(-1); DimensionManager.registerDimension(-1, DimensionType.register("VoidNether", "_nether", -1, WorldProviderVoidNether.class, false)); } if (Config.voidOverworld == true) { wtvo = new WorldTypeVoidOverworld(); DimensionManager.unregisterDimension(0); DimensionManager.registerDimension(0, DimensionType.register("VoidOverworld", "overworld", 0, WorldProviderVoidOverworld.class, false)); } if (Config.voidEnd == true) { wtve = new WorldTypeVoidEnd(); DimensionManager.unregisterDimension(1); DimensionManager.registerDimension(1, DimensionType.register("VoidEnd", "end", 1, WorldProviderVoidEnd.class, false)); } }
@Override public void update() { if (inventory[0] != null && inventory[0].hasCapability(TeslaCapabilities.CAPABILITY_CONSUMER, EnumFacing.DOWN) && inventory[0].hasCapability(TeslaCapabilities.CAPABILITY_HOLDER, EnumFacing.DOWN)) { ITeslaConsumer c = inventory[0].getCapability(TeslaCapabilities.CAPABILITY_CONSUMER, EnumFacing.DOWN); ITeslaHolder h = inventory[0].getCapability(TeslaCapabilities.CAPABILITY_HOLDER, EnumFacing.DOWN); if (h.getStoredPower() < h.getCapacity()) container.takePower(c.givePower(Math.min(container.getOutputRate(), container.getStoredPower()), false), false); } if(syncTick==10 && !worldObj.isRemote){ if(pos!=null){ int dim = 0; for(int i : DimensionManager.getIDs()) if(DimensionManager.getWorld(i).equals(worldObj)) { dim = i; break; } ModSquad.channel.sendToAll(new TileDataSync(pos, serializeNBT().toString(), dim)); } syncTick = 0; }else if(syncTick<10) ++syncTick; }
private NBTTagCompound readFromDisk(EntityPlayerMP player) { NBTTagCompound nbt = new NBTTagCompound(); try { File saveDir = DimensionManager.getCurrentSaveRootDirectory(); if (saveDir != null) { File file = new File(new File(saveDir, Reference.MOD_ID), player.getUniqueID() + ".dat"); if (file.exists() && file.isFile()) { // read player inventory file FileInputStream in = new FileInputStream(file); nbt = CompressedStreamTools.readCompressed(in); in.close(); } } } catch (Exception e) { JustEnoughDimensions.logger.warn("Failed to read GamemodeInventory for player " + player.getName()); } return nbt; }
@Override public void process(EntityPlayer player, Side side) { if(ResearchDimensions.get(player.world).researchDimIDs.get(this.username) == null) { DimensionType researchDim = DimensionType.register("research" + this.username, "", this.dimID, WorldProviderResearch.class, false); DimensionManager.registerDimension(this.dimID, researchDim); ResearchDimensions.get(player.world).researchDimIDs.put(this.username, this.dimID); ResearchDimensions.get(player.world).researchDimTypes.put(this.dimID, researchDim); }else{ ResearchDimensions.get(player.world).researchDimIDs.put(this.username, this.dimID); ResearchDimensions.get(player.world).researchDimTypes.put(this.dimID, DimensionType.getById(this.dimID)); } }
/** * Performs a case-sensitive search for a loaded world by a given name. * * First, it tries to match the name with dimension 0 (overworld), then it tries to * match from the world's save folder name (e.g. DIM_MYST10) and then finally the * Dynmap compatible identifier (e.g. DIM10) * * @param name Name of world to find * @return World if found, else null */ public static WorldServer getWorld(String name) { if ( name == null || name.isEmpty() ) throw new IllegalArgumentException("World name cannot be empty or null"); for ( WorldServer world : DimensionManager.getWorlds() ) { String dimName = "DIM" + world.provider.dimensionId; String saveFolder = world.provider.getSaveFolder(); if (world.provider.dimensionId == 0) { // Special case for dimension 0 (overworld) if ( WorldBorder.SERVER.getFolderName().equals(name) ) return world; } else if ( saveFolder.equals(name) || dimName.equals(name) ) return world; } return null; }
@Override @Nonnull public List<String> getTabCompletions(MinecraftServer server, ICommandSender sender, String[] args, @Nullable BlockPos pos) { List<String> filters = new ArrayList<>(); filters.add("all"); filters.add("dim"); filters.add("name"); filters.add("owner"); filters.add("radius"); if (args.length == 1 && !filters.contains(args[0])) { return filters; } else if (args.length == 2 && args[1].isEmpty()) { if (args[0].equals("dim")) { List<Integer> dimList = new ArrayList<>(Arrays.asList(DimensionManager.getStaticDimensionIDs())); dimList = Lists.reverse(dimList); Function<Integer, String> toString = input -> toString(); return Lists.transform(dimList, toString::apply); } else if (args[0].equals("owner")) { if (sender.getServer() != null) return new ArrayList<>(Arrays.asList(sender.getServer().getPlayerProfileCache().getUsernames())); } } return super.getTabCompletions(server, sender, args, pos); }
@SubscribeEvent public void onGlobalTick(TickEvent.ServerTickEvent event) { if(event.side == Side.CLIENT) return; if(this.torches.size() == 0) return; this.checkIndex = (this.checkIndex + 1) % this.torches.size(); TorchLocation loc = this.torches.get(this.checkIndex); World world = DimensionManager.getWorld(loc.DimensionId); if(world == null) return; if(world.isBlockLoaded(loc.Position)) { if(!this.blockValidator.test(world.getBlockState(loc.Position))) { TorchMasterMod.Log.info("Torch @ " + loc + " is no longer valid, removing from registry"); } } }
public static IFluidHandler getLiquidProvider(ItemStack tablet) { BlockPos pos = getLiquidProvidingLocation(tablet); if (pos != null) { int dimension = getLiquidProvidingDimension(tablet); return FluidUtil.getFluidHandler(DimensionManager.getWorld(dimension), pos, null); } return null; }
public static TileEntity getTileEntity(BlockPos pos, int dimension) { World world = DimensionManager.getWorld(dimension); if (world != null && world.isBlockLoaded(pos)) { return world.getTileEntity(pos); } return null; }