net.minecraftforge.eventbus.api.SubscribeEvent 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 entityDrops(LivingDropsEvent ev)
{
    if (!ConfigManager.SERVER.dropStringFromSheep.get())
        return;

    Entity entity = ev.getEntity();
    if (!(entity instanceof SheepEntity))
        return;

    Collection<ItemEntity> drops = ev.getDrops();
    if (drops instanceof ImmutableList)
    {
        SurvivalistMod.LOGGER.warn("WARNING: Some mod is returning an ImmutableList, replacing drops will NOT be possible.");
        return;
    }

    if (rnd.nextFloat() < 0.25f)
        drops.add(new ItemEntity(entity.getEntityWorld(), entity.getPosX(), entity.getPosY(), entity.getPosZ(), new ItemStack(Items.STRING)));
}
 

@SubscribeEvent
public void tickEnd(TickEvent.ServerTickEvent event) {
    if (event.phase == TickEvent.Phase.END && playerItemTankStates != null) {
        for (Map.Entry<UUID, PlayerItemTankCache> entry : playerItemTankStates.entrySet()) {
            entry.getValue().update();
        }
    }
}
 

@SubscribeEvent
public void onPlayerDestroyItem(PlayerDestroyItemEvent ev)
{
    if (!ConfigManager.SERVER.enableScraping.get())
        return;
    if (ev.getPlayer().world.isRemote)
        return;

    ItemStack stack = ev.getOriginal();
    if (stack.isEmpty())
        return;

    Item item = stack.getItem();

    if (!(item instanceof TieredItem))
        return;

    onItemBroken(ev.getPlayer(), stack);
}
 

@SubscribeEvent
public static void modConfig(ModConfig.ModConfigEvent event)
{
    ModConfig config = event.getConfig();
    if (config.getSpec() != SERVER_SPEC)
        return;

    Config axeLevels = SERVER.axeLevels.get();

    for (Config.Entry e : axeLevels.entrySet())
    {
        Matcher m = AXE_LEVEL_ENTRY_PATTERN.matcher(e.getKey());
        if (m.matches())
        {
            String numberPart = m.group("level");
            int levelNumber = Integer.parseInt(numberPart);
            axeLevelMap.put(levelNumber, e.getIntOrElse(1 + levelNumber));
        }
    }
}
 

@SubscribeEvent
public void entityJoinWorld(EntityJoinWorldEvent ev)
{
    if (!ConfigManager.SERVER.enableScraping.get())
        return;
    if (ev.getEntity().world.isRemote)
        return;

    if (ev.getEntity() instanceof PlayerEntity)
    {
        PlayerEntity player = (PlayerEntity) ev.getEntity();

        CombatTrackerIntercept interceptTracker = new CombatTrackerIntercept(player);
        ObfuscationReflectionHelper.setPrivateValue(LivingEntity.class, player, interceptTracker, "field_94063_bt");
    }
}
 

@SubscribeEvent
public void onTick(TickEvent e) {
    if (e.phase != TickEvent.Phase.START) {
        return;
    }

    if (e.type != this.type) {
        return;
    }

    onTick();
}
 

@SubscribeEvent
public static void runTests(FMLServerStartedEvent event) {
	final TestRepository testRepository = new TestRepository();
	final MinecraftServer server = event.getServer();
	final long fails = testRepository.tests.parallelStream()
		.filter(test -> runTestWithCatch(test, server))
		.count();
	if (fails > 0)
		log(server, new StringTextComponent(fails + " TESTS FAILED").applyTextStyle(TextFormatting.RED));
	else
		log(server, new StringTextComponent("ALL TESTS PASSED").applyTextStyle(TextFormatting.GREEN));
	if (!TestUtil.IS_CI_ENVIRONMENT.get())
		return;
	if (fails > 0)
		throw new RuntimeException("Had failed tests");
	else
		event.getServer().initiateShutdown(false);
}
 

@SubscribeEvent
  public void onTick(TickEvent.ClientTickEvent event) {
if (!(event.phase == Phase.END)) return;

try {
	ModuleManager.onUpdate();
  		ModuleManager.updateKeys();
  		
  		if (Minecraft.getInstance().player.ticksExisted % 100 == 0) {
  			fileReader.saveModules();
  			fileReader.saveSettings();
  			fileReader.saveClickGui();
  		}
  		
  		BleachQueue.nextQueue();
  	} catch (Exception e) {}
  }
 

@SubscribeEvent
public void onChatMsg(ClientChatEvent event) {
	if (event.getMessage().startsWith(".")) {
		CommandManager cmd = new CommandManager();
		cmd.callCommand(event.getMessage().substring(1));
		event.setCanceled(true);
	}
}
 

@SubscribeEvent
public static void gatherData(GatherDataEvent event) {
     if( event.includeServer() )
        registerServerProviders(event.getGenerator());

    if( event.includeClient() )
        registerClientProviders(event.getGenerator(), event);
}
 

@SubscribeEvent
public static void registerParticles(RegistryEvent.Register<ParticleType<?>> evt) {
    evt.getRegistry().registerAll(
            new LaserParticleType().setRegistryName("laserparticle"),
            new PlayerParticleType().setRegistryName("playerparticle"),
            new LightParticleType().setRegistryName("light_particle")
    );
}
 

@SubscribeEvent
public static void onGuiInitPost(GuiScreenEvent.InitGuiEvent.Post e){
	Screen gui = e.getGui();
	
	if (gui instanceof ControlsScreen){
		ControlsScreen controls = (ControlsScreen)gui;
		
		e.getWidgetList()
		 .stream()
		 .filter(btn -> btn instanceof OptionButton && ((OptionButton)btn).enumOptions == AbstractOption.AUTO_JUMP)
		 .findFirst()
		 .ifPresent(e::removeWidget);
		
		controls.children()
		        .stream()
		        .filter(widget -> widget instanceof KeyBindingList)
		        .map(widget -> ((KeyBindingList)widget).children())
		        .findFirst()
		        .ifPresent(children -> children.removeIf(entry ->
		        	(entry instanceof KeyEntry && ArrayUtils.contains(ClientModManager.keyBindings, ((KeyEntry)entry).keybinding)) ||
		        	(entry instanceof CategoryEntry && ((CategoryEntry)entry).labelText.equals(I18n.format(ClientModManager.categoryName)))
		        ));
		
		if (!openedControlsFromSprintMenu){
			e.addWidget(new GuiButton((controls.width / 2) + 5, 18, 150, "Better Sprinting", () -> mc.displayGuiScreen(new GuiSprint(mc.currentScreen))));
		}
	}
}
 

@SubscribeEvent
public void onLivingHurt(LivingHurtEvent ev)
{
    if (!ConfigManager.SERVER.enableScraping.get())
        return;
    if (ev.getEntity().world.isRemote)
        return;

    if (ev.getEntity() instanceof PlayerEntity)
    {
        PlayerEntity player = (PlayerEntity) ev.getEntityLiving();

        ItemBreakingTracker.get(player).ifPresent(ItemBreakingTracker::before);
    }
}
 

@SubscribeEvent
public static void onWorldRenderLast( RenderWorldLastEvent event ) // Called when drawing the world.
{
	if ( Controller.isXRayActive() && XRay.mc.player != null )
	{
		// this is a world pos of the player
		Render.renderBlocks(event);
	}
}
 

@OnlyIn (Dist.CLIENT)
@SubscribeEvent (priority = EventPriority.LOW)
public void onBlockHighlight(DrawHighlightEvent.HighlightBlock event) {
    //We have found a CuboidRayTraceResult, Lets render it properly..
    BlockRayTraceResult hit = event.getTarget();
    if (hit instanceof CuboidRayTraceResult) {
        CuboidRayTraceResult cuboidHit = (CuboidRayTraceResult) hit;
        event.setCanceled(true);
        Matrix4 mat = new Matrix4(event.getMatrix());
        mat.translate(cuboidHit.getPos());
        RenderUtils.bufferHitbox(mat, event.getBuffers(), event.getInfo(), cuboidHit.cuboid6);
    }
}
 

@SubscribeEvent
public static void onPlayerJoinWorld(EntityJoinWorldEvent e){
	if (stopCheckingNewServer || e.getEntity() != mc.player){
		return;
	}
	
	stopCheckingNewServer = true;
	
	if (!mc.isIntegratedServerRunning() && mc.getCurrentServerData() != null && !ClientSettings.disableMod.get()){
		PacketPipeline.sendToServer(ClientNetwork.writeModNotification(10));
	}
}
 

@SubscribeEvent
public void tickEnd(TickEvent.ClientTickEvent event) {
    if (event.phase == TickEvent.Phase.END) {
        if (ClientUtils.inWorld() && clientState != null) {
            clientState.update();
        }
    }
}
 

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

@SubscribeEvent
public static void onRegisterBlocks(RegistryEvent.Register<Block> event) {
    IForgeRegistry<Block> registry = event.getRegistry();

    Block.Properties properties = Block.Properties.create(Material.ROCK)//
            .hardnessAndResistance(20, 100);
    registry.register(new BlockEnderChest(properties).setRegistryName("ender_chest"));
    registry.register(new BlockEnderTank(properties).setRegistryName("ender_tank"));
}
 

@SubscribeEvent
public void onPlayerTick(ClientTickEvent e){
	if (e.phase == Phase.END && mc.player != null && mc.player.ticksExisted > 1){
		if (!LivingUpdate.checkIntegrity()){
			mc.player.sendMessage(new StringTextComponent(ClientModManager.chatPrefix + I18n.format("bs.game.integrity")));
		}
		
		unregister();
	}
}
 

@SubscribeEvent
public static void interactEvent(PlayerInteractEvent.LeftClickBlock event)
{
    PlayerEntity player = event.getPlayer();
    World world = player.world;
    BlockPos pos = event.getPos();
    BlockState state = world.getBlockState(pos);
    Block block = state.getBlock();
    if (block instanceof ChoppingBlock)
    {
        if (((ChoppingBlock) block).interceptClick(world, pos, state, player))
            event.setCanceled(true);
    }
}
 

@SubscribeEvent
public static void gatherDataGenerators(GatherDataEvent event) {
    DataGenerator gen = event.getGenerator();
    ExistingFileHelper files = event.getExistingFileHelper();
    if (event.includeClient()) {
        gen.addProvider(new BlockStates(gen, files));
        gen.addProvider(new ItemModels(gen, files));
    }
}
 

@SubscribeEvent
public void onClientPayload(NetworkEvent.LoginPayloadEvent event) {
    PacketCustom packet = new PacketCustom(event.getPayload());
    NetworkEvent.Context ctx = event.getSource().get();
    INetHandler netHandler = ctx.getNetworkManager().getNetHandler();
    ctx.setPacketHandled(true);
    if (netHandler instanceof ClientLoginNetHandler) {
        ClientLoginNetHandler nh = (ClientLoginNetHandler) netHandler;
        packetHandler.handleLoginPacket(packet, Minecraft.getInstance(), nh, ctx);
        //For _some_ reason sending this response packet in FML is private. So just spoof the packet :D
        ctx.getPacketDispatcher().sendPacket(new ResourceLocation("fml:handshake"), new PacketBuffer(Unpooled.buffer().writeByte(99)));
    }
}
 

@SubscribeEvent
public void onGatherLoginPayloads(NetworkEvent.GatherLoginPayloadsEvent event) {
    packetHandler.gatherLoginPackets((ctx, packetSupplier) -> {
        PacketCustom packet = packetSupplier.get();
        event.add(packet.toPacketBuffer(), packet.getChannel(), ctx);
    });
}
 

@SubscribeEvent
public static void onServerStarting(FMLServerStartingEvent e){
	ServerCommandConfig.register(e.getCommandDispatcher());
}
 

@SubscribeEvent
public void onClientPayload(NetworkEvent.ServerCustomPayloadEvent event) {
    if (event instanceof NetworkEvent.ServerCustomPayloadLoginEvent) {
        return;
    }
    PacketCustom packet = new PacketCustom(event.getPayload());
    NetworkEvent.Context ctx = event.getSource().get();
    INetHandler netHandler = ctx.getNetworkManager().getNetHandler();
    ctx.setPacketHandled(true);
    if (netHandler instanceof ClientPlayNetHandler) {
        ClientPlayNetHandler nh = (ClientPlayNetHandler) netHandler;
        ctx.enqueueWork(() -> packetHandler.handlePacket(packet, Minecraft.getInstance(), nh));
    }
}
 

@SubscribeEvent
public static void onClientDisconnected(ClientPlayerNetworkEvent.LoggedOutEvent event) {
    for (Map.Entry<ResourceLocation, SyncState> entry : clientRollbackMap.entrySet()) {
        logger.log(Level.INFO, "Client disconnect, rolling back config for {}.", entry.getKey());
        entry.getValue().revert(syncMap.get(entry.getKey()));
    }
    clientRollbackMap.clear();
}
 

@SubscribeEvent
public void onServerStarting(FMLServerStartingEvent event) {
}
 

@SubscribeEvent
public static void clientTick(TickEvent.ClientTickEvent event) {
    if (event.phase == TickEvent.Phase.END) {
        //Clear the known exceptions every 5 seconds.
        long time = System.nanoTime();
        if (TimeUnit.NANOSECONDS.toSeconds(time - lastExceptionClear) > 5) {
            lastExceptionClear = time;
            exceptionMessageCache.clear();
        }
    }
}