net.minecraftforge.event.world.WorldEvent Java Examples

@SubscribeEvent
public void worldLoad(WorldEvent.Load event)
{
	GameRules rules = event.getWorld().getGameRules();
	if(!rules.hasRule(KEEP_WARE_GAMERULE))
	{
		rules.addGameRule(KEEP_WARE_GAMERULE, Boolean.toString(CyberwareConfig.DEFAULT_KEEP), ValueType.BOOLEAN_VALUE);
	}
	if(!rules.hasRule(DROP_WARE_GAMERULE))
	{
		rules.addGameRule(DROP_WARE_GAMERULE, Boolean.toString(CyberwareConfig.DEFAULT_DROP), ValueType.BOOLEAN_VALUE);
	}
}
 

@SubscribeEvent
public void onWorldLoad(WorldEvent.Load event) {
    if (event.world.isRemote)
        RedstoneEther.loadClientEther(event.world);
    else
        RedstoneEther.loadServerWorld(event.world);
}
 

@SubscribeEvent
public void onWorldSave(WorldEvent.Save event)
{
    if(worldMap.containsKey(event.world))
        for(WorldExtension extension : worldMap.get(event.world))
            extension.save();
}
 

@SubscribeEvent
public void onWorldLoad(WorldEvent.Load event){
    if(!event.world.isRemote) {
        if(event.world.provider.dimensionId == 0) {
            GlobalVariableManager.overworld = event.world;
            event.world.loadItemData(GlobalVariableManager.class, GlobalVariableManager.DATA_KEY);
        }
    }
}
 

@SubscribeEvent
public void onWorldLoad(WorldEvent.Load event) {
  if (originalPlayer == null || getLocalPlayer() == null) {
    return;
  }
  
  pos = getLocalPlayer().getPositionVector();
  angle = LocalPlayerUtils.getViewAngles();
}
 

public static List<Biome.SpawnEntry> getPotentialSpawns(IWorld world, EntityCategory type, BlockPos pos, List<Biome.SpawnEntry> oldSpawns) {
	WorldEvent.PotentialSpawns event = new WorldEvent.PotentialSpawns(world, type, pos, oldSpawns);

	if (MinecraftForge.EVENT_BUS.post(event)) {
		return Collections.emptyList();
	}

	return event.getList();
}
 

@SubscribeEvent
public static void onUnloadWorld(WorldEvent.Unload event) {
    World world = event.getWorld();
    for (String uid : toUUIDs(Instance.getTEWithinDim(world.provider.getDimension()))) {
        //It is a world unload, so isSystem is here to prevent bugs from misdetailed event.
        Instance.unload(uid, true);
    }
}
 

@SubscribeEvent
public static void onLoad(WorldEvent.Load event) {
	if (event.getWorld().isRemote)
		return;
	if (event.getWorld().provider.getDimensionType() != StorageDimReg.storageDimensionType)
		return;

	MapStorage storage = event.getWorld().getPerWorldStorage();
	CellSavedWorldData instance = (CellSavedWorldData) storage.getOrLoadData(CellSavedWorldData.class, DATA_NAME);
}
 

@SubscribeEvent
public void onWorldSave(WorldEvent.Save evt) {
	if (!(evt.getWorld() instanceof ServerWorld)) return;
	
	try {
		UUID world = getUUIDForWorld((ServerWorld) evt.getWorld());
		
		for (ServerEventListener listener : eventListeners) listener.onWorldSaveToDisk(world);
		
	} catch (IOException ignore) {}
}
 

@SubscribeEvent
public void worldTick(WorldEvent.Load event) {
    String s = TofuVillageCollection.fileNameForProvider(event.getWorld().provider);

    TofuVillageCollection tofuVillageCollection = (TofuVillageCollection) event.getWorld().getPerWorldStorage().getOrLoadData(TofuVillageCollection.class, s);

    if (tofuVillageCollection == null) {
        tofuVillageCollection = new TofuVillageCollection(event.getWorld());
        event.getWorld().getPerWorldStorage().setData(s, tofuVillageCollection);
    } else {
        tofuVillageCollection.setWorldsForAll(event.getWorld());
    }
}
 

@SubscribeEvent
public void onWorldLoad(WorldEvent.Load event)
{
    //Load a 3x3 around spawn to make sure that it populates and calls our hooks.
    if (!event.getWorld().isRemote && event.getWorld() instanceof WorldServer)
    {
        WorldServer world = (WorldServer)event.getWorld();
        int spawnX = (int)(event.getWorld().getWorldInfo().getSpawnX() / world.provider.getMovementFactor() / 16);
        int spawnZ = (int)(event.getWorld().getWorldInfo().getSpawnZ() / world.provider.getMovementFactor() / 16);
        for (int x = -1; x <= 1; x++)
            for (int z = -1; z <= 1; z++)
                world.getChunkProvider().loadChunk(spawnX + x, spawnZ + z);
    }
}
 

@SubscribeEvent
public void onWorldLoad(WorldEvent.Load event)
{
	if(event.getWorld().provider.getDimension() == 0)
	{
		Timekeeper.initialize(event.getWorld());
	}
}
 

@SubscribeEvent
public void onCreateSpawn(WorldEvent.CreateSpawnPosition event)
{
	World world = event.getWorld();

	world.findingSpawnPoint = true;
	Random random = new Random(world.getSeed());
	BlockPos blockpos = findTerrainPositionForSpawn(random);
	int i = 0;
	int j = world.provider.getAverageGroundLevel();
	int k = 0;

	if (blockpos != null)
	{
		i = blockpos.getX();
		k = blockpos.getZ();
	}

	int l = 0;

	/*while (!world.provider.canCoordinateBeSpawn(i, k))
	{
		i += random.nextInt(64) - random.nextInt(64);
		k += random.nextInt(64) - random.nextInt(64);
		++l;

		if (l == 1000)
		{
			break;
		}
	}*/

	world.getWorldInfo().setSpawn(new BlockPos(i, j, k));
	world.findingSpawnPoint = false;
	event.setCanceled(true);
}
 

@SubscribeEvent
public void onWorldUnload(WorldEvent.Unload event) {
  once = false;
  position = 0;
  
  if (MC.getCurrentServerData() != null) {
    serverName = getServerName();
  }
}
 

@SideOnly(Side.CLIENT)
@SubscribeEvent
public void onWorldUnload(WorldEvent.Unload event)
{
	if (event.getWorld().isRemote && !Minecraft.getMinecraft().getConnection().getNetworkManager().isChannelOpen())
	{
		loadConfig();
	}
}
 

@SubscribeEvent
public void onWorldUnload(WorldEvent.Load event) {
  try {
    // shutdown vbos
    vboShutdown();
  } catch (Throwable e) {
    handleException(e);
  }
}
 

@SubscribeEvent
public void handleWorldUnload(WorldEvent.Unload event)
{
	if (missingArm)
	{
		GameSettings settings = Minecraft.getMinecraft().gameSettings;
		missingArm = false;
		settings.mainHand = oldHand;
	}
}
 

@SubscribeEvent(priority = EventPriority.HIGHEST)
public void onWorldLoad(WorldEvent.Load event) {
    World world = event.getWorld();
    event.getWorld().addEventListener(new VSWorldEventListener(world));
    IHasShipManager shipManager = (IHasShipManager) world;
    if (!event.getWorld().isRemote) {
        ValkyrienSkiesMod.VS_CHUNK_MANAGER.initWorld(world);
        shipManager.setManager(WorldServerShipManager::new);
    } else {
        shipManager.setManager(WorldClientShipManager::new);
    }
}
 

@SubscribeEvent(priority = EventPriority.HIGHEST)
public void onWorldUnload(WorldEvent.Unload event) {
    if (!event.getWorld().isRemote) {
        ValkyrienSkiesMod.VS_CHUNK_MANAGER.removeWorld(event.getWorld());
    } else {
        // Fixes memory leak; @DaPorkChop please don't leave static maps lying around D:
        lastPositions.clear();
    }
    ValkyrienSkiesMod.VS_PHYSICS_MANAGER.removeWorld(event.getWorld());
    IHasShipManager shipManager = (IHasShipManager) event.getWorld();
    shipManager.getManager().onWorldUnload();
}
 

@SubscribeEvent
public void onWorldLoad(WorldEvent.Load event) {
    if (event.getWorld().isRemote()) {
        clientState = new PlayerItemTankCache();
    } else if (playerItemTankStates == null) {
        playerItemTankStates = new HashMap<>();
    }
}
 

@SubscribeEvent
public void worldSaveEvent(WorldEvent.Save event) {
	//TODO: save only the one dimension
	if(event.getWorld().provider.getDimension() == 0)
		try {
			DimensionManager.getInstance().saveDimensions(DimensionManager.workingPath);
		} catch (Exception e) {
			AdvancedRocketry.logger.fatal("!!!!!!!!!!!!!! An error has occured saving planet data, please report to the mod dev with the entire fml-latest.log file!  This report may contain information relevent to solving a longstanding bug.");
			e.printStackTrace();
		}
}
 

@SubscribeEvent
public static void onWorldLoad(WorldEvent.Load event){
    if(!event.getWorld().isRemote && event.getWorld().provider.getDimension() == 0) {
        overworld = event.getWorld();
        overworld.loadData(NetworkStorage.class, DATA_KEY);
    }
}
 

@SubscribeEvent
public void worldLoadEvent(WorldEvent.Load event) {
	if(!event.getWorld().isRemote)
		AtmosphereHandler.registerWorld(event.getWorld().provider.getDimension());
	else if(Configuration.skyOverride && event.getWorld().provider.getDimension() == 0)
		event.getWorld().provider.setSkyRenderer(new RenderPlanetarySky());
}
 

@SideOnly(Side.CLIENT)
@SubscribeEvent
public void onWorldUnload(WorldEvent.Unload event) {
	if (!event.world.isRemote) return;
	// When we unload a world client side, we want to make sure that any view entities clean up. Not strictly necessary, but a good practice.
	// I don't trust vanilla to unload entity references quickly/correctly/completely.
	for (Object entity : event.world.loadedEntityList) {
		if (entity instanceof EntityPortal) ((EntityPortal) entity).releaseActiveView();
	}
}
 

@Override
public boolean unloadWorld(World world, boolean save) {
    if (world == null) {
        return false;
    }

    net.minecraft.world.WorldServer handle = ((CraftWorld) world).getHandle();

    if (!(console.worlds.contains(handle))) {
        return false;
    }

    if (handle.playerEntities.size() > 0) {
        return false;
    }

    WorldUnloadEvent e = new WorldUnloadEvent(handle.getWorld());
    pluginManager.callEvent(e);

    if (e.isCancelled()) {
        return false;
    }

    if (save) {
        try {
            handle.saveAllChunks(true, null);
            handle.flush();
            WorldSaveEvent event = new WorldSaveEvent(handle.getWorld());
            getPluginManager().callEvent(event);
        } catch (net.minecraft.world.MinecraftException ex) {
            getLogger().log(Level.SEVERE, null, ex);
            FMLLog.log(org.apache.logging.log4j.Level.ERROR, ex, "Failed to save world " + handle.getWorld().getName() + " while unloading it.");
        }
    }
    MinecraftForge.EVENT_BUS.post(new WorldEvent.Unload(handle)); // Cauldron - fire unload event before removing world
    worlds.remove(world.getName().toLowerCase());
    DimensionManager.setWorld(handle.provider.dimensionId, null); // Cauldron - remove world from DimensionManager
    return true;
}
 

@SubscribeEvent
public void worldSave(WorldEvent evt) {
	//Current time milli-seconds is used to prevent the files from saving 20 times when the world loads
	if (System.nanoTime() - lastSaveTime > 2_000_000_000) {
		lastSaveTime = System.nanoTime();
		saveAll();
	}
}
 

@SubscribeEvent(priority = EventPriority.NORMAL)
public void on(WorldEvent.Unload e) {
    if (!e.world.isRemote && e.world.provider.dimensionId == 0) {
        Gadomancy.unloadModData();

        TCMazeHandler.closeAllSessionsAndCleanup();
    }
}
 

@SubscribeEvent(priority = EventPriority.NORMAL)
public void on(WorldEvent.Load e) {
    if (!e.world.isRemote && e.world.provider.dimensionId == 0) {
        Gadomancy.loadModData();

        GolemEnumHelper.validateSavedMapping();
        GolemEnumHelper.reorderEnum();

        TCMazeHandler.init();
    }

    GameRules rules = e.world.getGameRules();
    rules.theGameRules.put("mobGriefing", new ValueOverride(this, String.valueOf(rules.getGameRuleBooleanValue("mobGriefing"))));
}
 

@SubscribeEvent
public void worldSave(WorldEvent evt) {
	//Current time milli-seconds is used to prevent the files from saving 20 times when the world loads
	if (System.nanoTime() - lastSaveTime > 2_000_000_000) {
		lastSaveTime = System.nanoTime();
		saveAll();
	}
}
 

@SubscribeEvent
public void worldSave(WorldEvent evt) {
	//Current time milli-seconds is used to prevent the files from saving 20 times when the world loads
	if (System.nanoTime() - lastSaveTime > 2_000_000_000) {
		lastSaveTime = System.nanoTime();
		saveAll();
	}
}