net.minecraftforge.event.world.ChunkEvent Java Examples

@SubscribeEvent
public void onChunkLoad(ChunkEvent.Load event) {
    IChunk chunk = event.getChunk();
    Map<BlockPos, TileEntity> tiles = null;
    if (chunk instanceof ChunkPrimerWrapper) {
        chunk = ((ChunkPrimerWrapper) chunk).func_217336_u();
    }
    if (chunk instanceof Chunk) {
        tiles = ((Chunk) chunk).getTileEntityMap();
    }
    if (chunk instanceof ChunkPrimer) {
        tiles = ((ChunkPrimer) chunk).getTileEntities();
    }
    if (tiles != null) {
        for (TileEntity tile : tiles.values()) {
            if (tile instanceof IChunkLoadTile) {
                ((IChunkLoadTile) tile).onChunkLoad();
            }
        }
    }
}
 

@SubscribeEvent
public void chunkLoadedEvent(ChunkEvent.Load event) {

	Map map = event.getChunk().getTileEntityMap();
	Iterator<Entry> iter = map.entrySet().iterator();

	try {
		while(iter.hasNext()) {
			Object obj = iter.next().getValue();

			if(obj instanceof TilePipe) {
				((TilePipe)obj).markDirty();
			}
		}
	} catch ( ConcurrentModificationException e) {
		AdvancedRocketry.logger.warn("You have been visited by the rare pepe.. I mean error of pipes not loading, this is not good, some pipe systems may not work right away.  But it's better than a corrupt world");
	}
}
 

@SubscribeEvent
public void onChunkLoad(ChunkEvent.Load cev)
{
    // Pass the event on to the active episode, if there is one:
    this.stateEpisodeLock.readLock().lock();
    if (this.stateEpisode != null && this.stateEpisode.isLive())
    {
        this.stateEpisode.onChunkLoad(cev);
    }
    this.stateEpisodeLock.readLock().unlock();
}
 

@SubscribeEvent
public void onChunkUnLoad(ChunkEvent.Unload event)
{
    if(event.getChunk() instanceof EmptyChunk)
        return;
    
    for(WorldExtension extension : worldMap.get(event.world))
        extension.unloadChunk(event.getChunk());
    
    if(event.world.isRemote)
        removeChunk(event.world, event.getChunk());
}
 

@SideOnly(Side.CLIENT)
@SubscribeEvent
public void onChunkUnload(ChunkEvent.Unload event) {
	if (!event.world.isRemote) return;
	Chunk chunk = event.getChunk();
	// When we unload a chunk 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 (int i = 0; i < chunk.entityLists.length; ++i) {
		List<Entity> list = chunk.entityLists[i];
		for (Entity entity : list) {
			if (entity instanceof EntityPortal) ((EntityPortal) entity).releaseActiveView();
		}
	}
}
 

@SubscribeEvent
public void onChunkLoad(ChunkEvent.Load event)
{
    if(!worldMap.containsKey(event.world))
        WorldExtensionManager.onWorldLoad(event.world);
    
    createChunkExtension(event.world, event.getChunk());
    
    for(WorldExtension extension : worldMap.get(event.world))
        extension.loadChunk(event.getChunk());
}
 

/**
 * Keep track of recently loaded chunks for the magma boss timer.
 */
@SubscribeEvent()
public void onChunkLoad(ChunkEvent.Load e) {
    if (main.getUtils().isOnSkyblock()) {
        int x = e.getChunk().xPosition;
        int z = e.getChunk().zPosition;
        IntPair coords = new IntPair(x, z);
        recentlyLoadedChunks.add(coords);
        main.getScheduler().schedule(Scheduler.CommandType.DELETE_RECENT_CHUNK, 20, x, z);
    }
}
 

@SubscribeEvent
public void onChunkUnload(ChunkEvent.Unload event) {

    if (event.world.isRemote)
        return;

    for (Object o : event.getChunk().chunkTileEntityMap.values()) {
        TileEntity te = (TileEntity) o;
        if (te instanceof TileMotor) {
            ((TileMotor) te).onUnload();
        }
    }
}
 

@SubscribeEvent
public void onChunkLoad(ChunkEvent.Load event) {
    List<TileEntity> list = new ArrayList<TileEntity>(event.getChunk().chunkTileEntityMap.values());
    for(TileEntity t : list)
        if(t instanceof IChunkLoadTile)
            ((IChunkLoadTile)t).onChunkLoad();
}
 

@SubscribeEvent
public void onChunkLoad(ChunkEvent.Load event) {
    if (event.world.isRemote)
        return;

    if (RedstoneEther.server() != null)//new world
    {
        RedstoneEther.loadServerWorld(event.world);
        RedstoneEther.server().verifyChunkTransmitters(event.world, event.getChunk().xPosition, event.getChunk().zPosition);
    }
}
 

@SubscribeEvent
public void chunkLoadEvent(ChunkEvent.Load event) {
}
 

@SubscribeEvent
public void eventChunkUnload(ChunkEvent.Unload event){
	if(event.world.isRemote){
		this.mw.onChunkUnload(event.getChunk());
	}
}
 

@SubscribeEvent
public void eventChunkLoad(ChunkEvent.Load event){
	if(event.world.isRemote){
		this.mw.onChunkLoad(event.getChunk());
	}
}
 

@SubscribeEvent(priority = EventPriority.NORMAL)
public void onChunkLoad(ChunkEvent.Load loadEvent) {
	Chunk chunk = loadEvent.getChunk();
	World world = loadEvent.world;
	MultiblockRegistry.onChunkLoaded(world, chunk.xPosition, chunk.zPosition);
}
 

@SubscribeEvent
public void onChunkUnLoad(ChunkEvent.Unload event){
    if(!event.world.isRemote) {
        chunksMarkedForRemoval.add(event.getChunk());
    }
}
 

@SubscribeEvent
public void onChunkUnload(ChunkEvent.Unload event)
{
	if(!event.getWorld().isRemote && event.getWorld().provider.getDimension() == 0)
	{
		BlockPos chunkWorldPos = new BlockPos(event.getChunk().xPosition * 16, 0, event.getChunk().zPosition * 16);
		IslandMap map = Core.getMapForWorld(event.getWorld(), chunkWorldPos);

		Point islandPos = new Point(chunkWorldPos.getX(), chunkWorldPos.getZ()).toIslandCoord();
		AxisAlignedBB chunkAABB = new AxisAlignedBB(islandPos.getX(), 0, islandPos.getZ(), islandPos.getX()+16, 1, islandPos.getZ()+16);
		Center temp = map.getClosestCenter(islandPos);

		ArrayList<Center> genList = new ArrayList<Center>();
		genList.add(temp);
		genList.addAll(temp.neighbors);

		if(loadedCentersMap.containsKey(map.getParams().getCantorizedID()))
		{
			ArrayList<Center> loaded = loadedCentersMap.get(map.getParams().getCantorizedID());
			for(Center c : genList)
			{	
				AxisAlignedBB aabb = c.getAABB();
				boolean intersect =aabb.intersectsWith(chunkAABB);
				if(intersect && loaded.contains(c) )
				{
					loaded.remove(c);
					ArrayList<Herd> herdsToUnload = map.getIslandData().wildlifeManager.getHerdsInCenter(c);
					for(Herd h : herdsToUnload)
					{
						h.setUnloaded();
						for(VirtualAnimal animal : h.getVirtualAnimals())
						{
							if(animal.getEntity() == null)
							{
								animal.setUnloaded();
								continue;
							}
							Predicate<Entity> predicate = Predicates.<Entity>and(EntitySelectors.NOT_SPECTATING, EntitySelectors.notRiding(animal.getEntity()));
							Entity closestEntity = animal.getEntity().world.getClosestPlayer(animal.getEntity().posX, animal.getEntity().posY, animal.getEntity().posZ, 100D, predicate);
							if(closestEntity == null)
							{
								animal.getEntity().setDead();
								animal.setUnloaded();
							}
						}
					}
				}
			}
		}


	}
}
 

@SubscribeEvent
public static void chunkLoad( ChunkEvent.Load event )
{
	Controller.requestBlockFinder( true );
}
 

@SubscribeEvent
public void onChunkUnload(ChunkEvent.Unload event){
    if(!event.getWorld().isRemote) {
        RailNetworkManager.getInstance(event.getWorld().isRemote).onChunkUnload(event.getChunk());
    }
}
 

/** Subclass should overrride this to act on chunk load events.*/
protected void onChunkLoad(ChunkEvent.Load cev) {}
 

@SubscribeEvent
public void onChunkLoad(ChunkEvent.Load event) {
  if (chunks != null) {
  }
}
 

@SubscribeEvent
public static void onChunkUnload(ChunkEvent.Unload event) {
    getPipeNetsForWorld(event.getWorld()).forEach(it -> it.onChunkUnloaded(event.getChunk()));
}
 

@SubscribeEvent
public static void onChunkLoad(ChunkEvent.Load event) {
    getPipeNetsForWorld(event.getWorld()).forEach(it -> it.onChunkLoaded(event.getChunk()));
}