Java 类net.minecraftforge.fml.common.gameevent.TickEvent.WorldTickEvent 实例源码

public void tickWorld(WorldTickEvent event) {
    if(!(event.world instanceof WorldServer))
        return;

    // System.out.println("TICKING WORLD -> @" + event.world);
    // TaleCraft.proxy.tick(event);

    GameRules rules = event.world.getGameRules();
    //TODO: Fix this
    if(rules.getBoolean("tc_disableWeather")) {
        // Clear the weather for 5 seconds.
        event.world.getWorldInfo().setCleanWeatherTime(20*5);
    }
    NBTTagCompound current = rules.writeToNBT();
    if(!current.equals(gamerules)){
        gamerules = current;
        TaleCraft.network.sendToAll(new GameruleSyncPacket(current));
    }
}

@SubscribeEvent
public void onServerWorldTick(WorldTickEvent event)
{
    World world = event.world;
    if(event.phase == Phase.START)
    {
        if(WorldGen.getInstance() != null)
        {
            if(world.provider.getDimension() == 0)
            {
                WorldGen.getInstance().trimCache();
                WorldGen.getInstance().buildFromQueue();
                WorldGen.getInstance().runUpdateLoop(event.world);
            }
        }           
    }
}

@SubscribeEvent
public void onServerWorldTick(WorldTickEvent event)
{
    World world = event.world;
    if(event.phase == Phase.START)
    {
        if(WorldGen.getInstance() != null)
        {
            if(world.provider.getDimension() == 0)
            {
                WorldGen.getInstance().trimCache();
                WorldGen.getInstance().buildFromQueue();
                WorldGen.getInstance().runUpdateLoop(event.world);
            }
        }           
    }
}

@SubscribeEvent
public void onTick(WorldTickEvent event)
{
    if(Minecraft.getMinecraft().world != null && ticks++%40==0)
        for(TileEntity te : new ArrayList<TileEntity>(Minecraft.getMinecraft().world.loadedTileEntityList))
            if(te instanceof TileEntityCaulronBlock && ((TileEntityCaulronBlock)te).isLeader())
                Minecraft.getMinecraft().renderGlobal.markBlockRangeForRenderUpdate(te.getPos().getX(), te.getPos().getY(), te.getPos().getZ(), 
                        te.getPos().getX() + ((TileEntityCaulronBlock)te).getSize(), te.getPos().getY() + ((TileEntityCaulronBlock)te).getSize(), te.getPos().getZ() + ((TileEntityCaulronBlock)te).getSize());
}

@SubscribeEvent
public void serverTick(WorldTickEvent event) {
    if (!event.world.isRemote) {
        if (event.phase == Phase.END) {
            RedstoneEther.server().tick(event.world);
        } else {
            RedstoneEtherAddons.server().processSMPMaps(event.world);
        }
    }
}

@SubscribeEvent
public static void onWorldTick(WorldTickEvent event) {
    WorldServer world = (WorldServer) event.world;


    if (world.isRaining()) {
        onTickSnowIncrease(world);
    } else if (world.provider.isDaytime()) {
        onTickSnowDecrease(world);
    }
}

@SubscribeEvent
public static void worldTick(WorldTickEvent event){
    // I only want to tick on the server
    if(event.world.isRemote){return;}
    // If I don't have this code everything runs twice per tick
    if(event.phase == Phase.END){return;}
    if(Math.floorMod(event.world.getTotalWorldTime(), tickSpeed) != 0){return;}
    TickTracker tickTracker = getTickTrackerForDimension(event.world.provider.getDimension());
    if(!tickTracker.trackedWorldHasPlayers()){
        if(tickTracker.worldToTick == nextWorldToTick){
            tickTracker.hasTicked = true;
            findNextWorldToTick();
        }
        return;
    }
    if(!tickTracker.hasTicked && tickTracker.worldToTick == nextWorldToTick && event.world.getTotalWorldTime() > lastTickProcessed){
        if(dimensionsToTick.contains(tickTracker.worldToTick)){
            if(ConfigHandler.LOGGING)LogManager.getLogger().log(Level.INFO, "We're ticking in this dimension: " + tickTracker.worldToTick);
            if(tickTracker.trackedWorldHasPlayers() && tickTracker.playerToTick < event.world.playerEntities.size()){
                SpawnHandler.attemptSpawnNearPlayer(event.world.playerEntities.get(tickTracker.playerToTick), event.world);
                tickTracker.setNextPlayerToTick(event.world);
            }
        }
        tickTracker.hasTicked = true;
        findNextWorldToTick();
        lastTickProcessed = event.world.getTotalWorldTime();
        return;
    }
    // if we get to this point, a world has probably unloaded and eaten our tick tracker, so find a new world to tick on
    if(DimensionManager.getWorld(nextWorldToTick) == null){
        if(ConfigHandler.LOGGING)LogManager.getLogger().log(Level.WARN, "Tracker lost, generating new tracker.");
        findNextWorldToTick();
    }
}

@SubscribeEvent
public void worldTicked(WorldTickEvent event)
{
    if(event.phase == TickEvent.Phase.START && event.type == TickEvent.Type.WORLD)
    {
        if(event.world.getGameRules().getBoolean("teleportXP") || ModConfig.ignoreGamerule)
        {
            for(int i = 0; i < event.world.loadedEntityList.size(); i++)
            {
                if(event.world.loadedEntityList.get(i) instanceof EntityXPOrb)
                {
                    EntityXPOrb xpOrb = (EntityXPOrb) event.world.loadedEntityList.get(i);
                    EntityPlayer player;
                    if (ModConfig.prioritizeNonCreative)
                    {
                        player = event.world.getNearestPlayerNotCreative(xpOrb, Double.MAX_VALUE);
                        if(player != null)
                        {
                            xpOrb.setPosition(player.posX, player.posY, player.posZ);
                            return;
                        }
                    }
                    player = event.world.getClosestPlayerToEntity(xpOrb, Double.MAX_VALUE);
                    if(player != null)
                    {
                        xpOrb.setPosition(player.posX, player.posY, player.posZ);
                    }
                }
            }
        }
    }
}

@SubscribeEvent
public void cleanUp(WorldTickEvent event) {
    if (event.world.getTotalWorldTime() % 20 != 0) {
        return;
    }
    despawnLogic(event, NemesisRegistryProvider.get(event.world));
}

private void despawnLogic(WorldTickEvent event, INemesisRegistry registry) {
    registry.list().forEach((NemesisEntry nemesis) -> {
        if (nemesis.isSpawned()) {
            if (shouldBeDespawned(event.world, nemesis)) {
                despawnNemesis(event.world, registry, nemesis);
            } else {
                unloadNemesis(event.world, registry, nemesis);
            }
        }
    });
}

@SubscribeEvent
public void onWorldTick(WorldTickEvent event)
{
    if (event.phase != Phase.END) { return; }   // Only doing it once
    if (event.side == Side.CLIENT) { return; }

    upkeepTick += 1;

    if (upkeepTick >= Main.getConsumeUpkeepTick())
    {
        TerritoryHandler.consumeUpkeep(event.world);
        upkeepTick = 0; // Reset
    }
}

@SubscribeEvent
public void onTick(WorldTickEvent event) {
    if (event.phase == Phase.START) {
        onTickStart();
    } else if (event.phase == Phase.END) {
        onTickEnd();
    }
}

@SubscribeEvent
public void handleWorldTick(WorldTickEvent event) {
    if (queue.size() < 1) {
        return;
    }
    runNextQueueItem();
}

@SubscribeEvent
public void handleWorldTick(WorldTickEvent event) {
    if (runQueue.size() < 1) {
        return;
    }
    runNextQueueItem();
}

@SubscribeEvent
public void worldTick(WorldTickEvent event) {
    if (event.phase == Phase.END && !event.world.isRemote) {
        ChunkLoaderManager.onTickEnd((WorldServer) event.world);
        PlayerChunkViewerManager.instance().calculateChunkChanges((WorldServer) event.world);
    }
}

public void tickWorld(WorldTickEvent event) {
    TCWorldManager mng = TaleCraft.worldsManager.fetchManager(event.world);

    if(mng == null) {
        TaleCraft.logger.error("No WorldManager for @" + event.world.hashCode());
        return;
    }

    mng.tickWorld(event);
}

@SubscribeEvent
public void onTick(WorldTickEvent event) {
    if (event.world.getWorldTime() % 20 == 0) { // once per second
        if (building.isDone()) {
            System.out.println("done building");
            FMLCommonHandler.instance().bus().unregister(this);
        } else {
            System.out.println("build!");
            building.buildStep();
            generator.generate(plan, x, y, z);
        }
    }
}

@SubscribeEvent
public void onWorldTick(WorldTickEvent evt) {
    if (evt.side == Side.SERVER && evt.phase == Phase.END) {
        int worldId = evt.world.provider.getDimension();
        Queue<Runnable> callbacks = getWorldQueue(worldId);

        Runnable callback;
        while ((callback = callbacks.poll()) != null) {
            callback.run();
        }
    }
}

@SubscribeEvent
public void tickEvent(WorldTickEvent event) {
    if (event.phase == Phase.END) {
        ManaTracker.INSTANCE.tick(event.world);
    }
}

@SubscribeEvent
public void tick(WorldTickEvent event) {
    WorldHandler.onTick(event.world, event.phase);
}

@SubscribeEvent
public void tickWorld(WorldTickEvent event) {
    TaleCraft.proxy.tickWorld(event);
}

@Override
public void tickWorld(WorldTickEvent event) {
    super.tickWorld(event);
}

@SubscribeEvent
public void onTickInGame(WorldTickEvent event) {
    if (Altar.blocktick > 0) {
        Altar.blocktick--;
    }
}

@SubscribeEvent
public void handleWorldTick(WorldTickEvent event) {

}