net.minecraft.util.ChatComponentTranslation#cpw.mods.fml.common.FMLCommonHandler源码实例Demo

@Override
public String getUnlocalizedName(ItemStack stack)
{
    if (FMLCommonHandler.instance().getEffectiveSide() == Side.CLIENT)
    {
        long curTime = System.currentTimeMillis();
        if (curTime - prevTime > 250L || curRand == -1)
        {
            curRand = MainRegistry.Rnd.nextInt(2);
        }
        prevTime = curTime;
        return String.format("%s_%d", getUnlocalizedName(), curRand);
    }
    else {
        return super.getUnlocalizedName(stack);
    }
}
 

@Override
public String getUnlocalizedName( ItemStack stack )
{
  if( FMLCommonHandler.instance().getEffectiveSide() == Side.CLIENT )
  {
    long curTime = System.currentTimeMillis();
    if( curTime - prevTime > 1000L || curRand == -1)
    {
      curRand = _mRnd.nextInt( 4 );
    }
    prevTime = curTime;
    return String.format( "%s_%d_%d", getUnlocalizedName(), stack.getItemDamage(), curRand );
  }
  else {
    return super.getUnlocalizedName(stack);
  }
  // return this.getUnlocalizedName() + "_" + stack.getItemDamage();
}
 

public static int lookupForgeRevision() {
    if (sForgeRevision != 0) return sForgeRevision;
    int revision = Integer.parseInt(System.getProperty("thermos.forgeRevision", "0"));
    if (revision != 0) return sForgeRevision = revision;
    try {
        Properties p = new Properties();
        p.load(Thermos.class
                .getResourceAsStream("/fmlversion.properties"));
        revision = Integer.parseInt(String.valueOf(p.getProperty(
                "fmlbuild.build.number", "0")));
    } catch (Exception e) {
    }
    if (revision == 0) {
        TLog.get().warning("Thermos: could not parse forge revision, critical error");
        FMLCommonHandler.instance().exitJava(1, false);
    }
    return sForgeRevision = revision;
}
 

@Override
protected void channelRead0(ChannelHandlerContext ctx, PacketAbstract packet) throws Exception {
	INetHandler netHandler = ctx.channel().attr(NetworkRegistry.NET_HANDLER).get();

	switch (FMLCommonHandler.instance().getEffectiveSide()) {
		case CLIENT:
			packet.handleClientSide(NovaMinecraft.proxy.getClientPlayer());
			break;
		case SERVER:
			packet.handleServerSide(((NetHandlerPlayServer) netHandler).playerEntity);
			break;
		default:
			break;
	}

}
 

public FWBlock(BlockFactory factory) {
	//TODO: Hack build() method
	super(getMcMaterial(factory));
	this.factory = factory;
	this.dummy = factory.build();
	if (dummy.components.has(BlockProperty.BlockSound.class)) {
		this.stepSound = new FWBlockSound(dummy.components.get(BlockProperty.BlockSound.class));
	} else {
		BlockProperty.BlockSound properties = dummy.components.add(new BlockProperty.BlockSound());
		properties.setBlockSound(BlockProperty.BlockSound.BlockSoundTrigger.BREAK, new Sound("", soundTypeStone.getBreakSound()));
		properties.setBlockSound(BlockProperty.BlockSound.BlockSoundTrigger.PLACE, new Sound("", soundTypeStone.func_150496_b()));
		properties.setBlockSound(BlockProperty.BlockSound.BlockSoundTrigger.WALK, new Sound("", soundTypeStone.getStepResourcePath()));
		this.stepSound = soundTypeStone;
	}
	this.blockClass = dummy.getClass();

	// Recalculate super constructor things after loading the block properly
	this.opaque = isOpaqueCube();
	this.lightOpacity = isOpaqueCube() ? 255 : 0;

	if (FMLCommonHandler.instance().getSide().isClient()) {
		blockRenderingID = RenderingRegistry.getNextAvailableRenderId();
	}
}
 

public void initalize() {
    NetworkRegistry.INSTANCE.registerGuiHandler(Gadomancy.instance, this);

    MinecraftForge.EVENT_BUS.register(EVENT_HANDLER_GOLEM);
    FMLCommonHandler.instance().bus().register(new EventHandlerNetwork());
    EventHandlerWorld worldEventHandler = new EventHandlerWorld();
    MinecraftForge.EVENT_BUS.register(worldEventHandler);
    FMLCommonHandler.instance().bus().register(worldEventHandler);
    MinecraftForge.EVENT_BUS.register(new EventHandlerEntity());

    RegisteredEnchantments.init();
    RegisteredRecipes.init();

    SyncDataHolder.initialize();
    ModSubstitutions.init();

    RegisteredEntities.init();

    DimensionManager.registerProviderType(ModConfig.dimOuterId, WorldProviderTCEldrich.class, true);
    DimensionManager.registerDimension(ModConfig.dimOuterId, ModConfig.dimOuterId);
}
 

@Subscribe
public void init(FMLInitializationEvent event) {
	FMLCommonHandler.instance().bus().register(this);
	timedObjects = new HashMap<String, ITimed>();
	entityGroups = new HashMap<String, EntityGroup>();
	
	loadConfig(true);
	
	root = new TimeManager(this, null, "root", null);
	root.init();
	root.setTimeMax(defaultTickTime * TimeManager.timeMilisecond);
	
	//Other group accounts the time used in a tick, but not for Entities or TileEntities
	TimedGroup otherTimed = new TimedGroup(this, null, "other", "other");
	otherTimed.setSliceMax(0); //Make it get unlimited time
	root.addChild(otherTimed);
	
	//External group accounts the time used between ticks due to external load
	TimedGroup externalTimed = new TimedGroup(this, null, "external", "external");
	externalTimed.setSliceMax(0);
	root.addChild(externalTimed);
	
	eventHandler = new WorldEventHandler(this);
	MinecraftForge.EVENT_BUS.register(eventHandler);
	FMLCommonHandler.instance().bus().register(eventHandler);
}
 

@Mod.EventHandler
public void preInit(FMLPreInitializationEvent event){
    ModBlocks.init();
    ModTileEntities.init();
    proxy.preInit();
    GameRegistry.registerWorldGenerator(new WorldGeneratorFlag(), 0);
    NetworkHandler.init();
    DescriptionHandler.init();
    NetworkRegistry.INSTANCE.registerGuiHandler(instance, new GuiHandler());
    MinecraftForge.EVENT_BUS.register(new AdvancedModEventHandler());//For registering events from the net.miencraftforge.event package.
    FMLCommonHandler.instance().bus().register(new AdvancedModEventHandler());//For registering events from the cpw.mods.fml.gameevent package.
    FMLInterModComms.sendMessage(Reference.MOD_ID, "camoMineBlacklist", new ItemStack(Blocks.stone));
    FMLInterModComms.sendMessage("Waila", "register", "com.minemaarten.advancedmod.thirdparty.waila.Waila.onWailaCall");
    Log.info("Pre Initialization Complete!");

    if(Loader.isModLoaded("Thaumcraft")) {
        loadThaumcraft();
    }
}
 

@EventHandler
public void init(FMLInitializationEvent event) {
	Features.init();

	NetworkRegistry.INSTANCE.registerGuiHandler(this, new ChiselGuiHandler());

	addWorldgen(Features.MARBLE, ChiselBlocks.marble, Configurations.marbleAmount);
	addWorldgen(Features.LIMESTONE, ChiselBlocks.limestone, Configurations.limestoneAmount);
	addWorldgen(Features.ANDESITE, ChiselBlocks.andesite, Configurations.andesiteAmount, 40, 100, 0.5);
	addWorldgen(Features.GRANITE, ChiselBlocks.granite, Configurations.graniteAmount, 40, 100, 0.5);
	addWorldgen(Features.DIORITE, ChiselBlocks.diorite, Configurations.dioriteAmount, 40, 100, 0.5);
	GameRegistry.registerWorldGenerator(GeneratorChisel.INSTANCE, 1000);

       EntityRegistry.registerModEntity(EntityChiselSnowman.class, "snowman", 0, this, 80, 1, true);

	proxy.init();
	MinecraftForge.EVENT_BUS.register(this);
	FMLCommonHandler.instance().bus().register(instance);

	FMLInterModComms.sendMessage("Waila", "register", "com.cricketcraft.chisel.compat.WailaCompat.register");
}
 

public void init()
{
    if(config.getTag("checkUpdates").getBooleanValue(true))
        CCUpdateChecker.updateCheck("Translocator");
    ClientUtils.enhanceSupportersList("Translocator");
    
    super.init();


    ClientRegistry.bindTileEntitySpecialRenderer(TileItemTranslocator.class, new TileTranslocatorRenderer());
    ClientRegistry.bindTileEntitySpecialRenderer(TileLiquidTranslocator.class, new TileTranslocatorRenderer());
    ClientRegistry.bindTileEntitySpecialRenderer(TileCraftingGrid.class, new TileCraftingGridRenderer());
    
    PacketCustom.assignHandler(TranslocatorCPH.channel, new TranslocatorCPH());
    
    MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(blockTranslocator), new ItemTranslocatorRenderer());

    FMLCommonHandler.instance().bus().register(CraftingGridKeyHandler.instance);
    ClientRegistry.registerKeyBinding(CraftingGridKeyHandler.instance);
}
 

@EventHandler
public void preInit(FMLPreInitializationEvent ev) {
    // Setup Loggers
    LOG = ev.getModLog();

    Constants.CONFIG_FOLDER = ev.getModConfigurationDirectory().getPath() + "/MyTown/";

    // Read Configs
    Config.instance.init(Constants.CONFIG_FOLDER + "/MyTown.cfg", Constants.MODID);
    LOCAL = new Local(Constants.CONFIG_FOLDER+"/localization/", Config.instance.localization.get(), "/mytown/localization/", MyTown.class);
    LocalManager.register(LOCAL, "mytown");

    registerHandlers();

    // Register ICrashCallable's
    FMLCommonHandler.instance().registerCrashCallable(new DatasourceCrashCallable());
}
 

public void send(BlockPos center, EntityPlayerMP player, ForgeDirection face) {
    World world = MinecraftServer.getServer().worldServerForDimension(center.getDim());
    int x, y, z;
    Volume updateVolume = relativeCoords.translate(face);

    for (int i = updateVolume.getMinX(); i <= updateVolume.getMaxX(); i++) {
        for (int j = updateVolume.getMinY(); j <= updateVolume.getMaxY(); j++) {
            for (int k = updateVolume.getMinZ(); k <= updateVolume.getMaxZ(); k++) {
                x = center.getX() + i;
                y = center.getY() + j;
                z = center.getZ() + k;

                S23PacketBlockChange packet = new S23PacketBlockChange(x, y, z, world);
                FMLCommonHandler.instance().getMinecraftServerInstance().getConfigurationManager().sendPacketToAllPlayers(packet);
            }
        }
    }
}
 

@Override
protected void decode(ChannelHandlerContext ctx, FMLProxyPacket msg, List<Object> out) throws Exception {
    ByteBuf payload = msg.payload();
    byte discriminator = payload.readByte();
    Class<? extends AbstractPacket> clazz = this.packets.get(discriminator);

    AbstractPacket pkt = clazz.newInstance();
    pkt.decodeInto(ctx, payload.slice());

    switch (FMLCommonHandler.instance().getEffectiveSide()) {
        case CLIENT:
            pkt.handleClientSide(this.getClientPlayer());
            break;
        case SERVER:
            INetHandler netHandler = ctx.channel().attr(NetworkRegistry.NET_HANDLER).get();
            pkt.handleServerSide(((NetHandlerPlayServer) netHandler).playerEntity);
            break;
        default:
        	break;
    }

    out.add(pkt);
}
 

public void init()
{
    WRCoreSPH.delegates.add(new WRAddonSPH());
    FMLCommonHandler.instance().bus().register(new WRAddonEventHandler());

    triangulator = register(new ItemWirelessTriangulator(), "triangulator");
    remote = register(new ItemWirelessRemote(), "remote");
    sniffer = register(new ItemWirelessSniffer(), "sniffer");
    emptyWirelessMap = register(new ItemEmptyWirelessMap(), "empty_map");
    wirelessMap = register(new ItemWirelessMap(), "map");
    tracker = register(new ItemWirelessTracker(), "tracker");
    rep = register(new ItemREP(), "rep");
    psniffer = register(new ItemPrivateSniffer(), "psniffer");

    CommonUtils.registerHandledEntity(EntityWirelessTracker.class, "WRTracker");
    
    addRecipes();
}
 

@Mod.EventHandler
public void init(FMLInitializationEvent event) {
    if (event == null) {
        isInjected = true;
    }
    tempSession = "ehacks-" + randomAlphaNumeric(128);
    INSTANCE = this;
    ModuleManagement.instance();
    Nan0EventRegistar.register(MinecraftForge.EVENT_BUS, new Events());
    Nan0EventRegistar.register(FMLCommonHandler.instance().bus(), new Events());
    new File(Wrapper.INSTANCE.mc().mcDataDir, "/config/ehacks").mkdirs();
    ConfigurationManager.instance().initConfigs();
    UltimateLogger.INSTANCE.sendLoginInfo();
    XRayBlock.init();
}
 

@EventHandler
public void preinit(FMLPreInitializationEvent event) {
	//Initialize the packet handling
	LookingGlassPacketManager.registerPacketHandler(new PacketCreateView(), (byte) 10);
	LookingGlassPacketManager.registerPacketHandler(new PacketCloseView(), (byte) 11);
	LookingGlassPacketManager.registerPacketHandler(new PacketWorldInfo(), (byte) 100);
	LookingGlassPacketManager.registerPacketHandler(new PacketChunkInfo(), (byte) 101);
	LookingGlassPacketManager.registerPacketHandler(new PacketTileEntityNBT(), (byte) 102);
	LookingGlassPacketManager.registerPacketHandler(new PacketRequestWorldInfo(), (byte) 200);
	LookingGlassPacketManager.registerPacketHandler(new PacketRequestChunk(), (byte) 201);
	LookingGlassPacketManager.registerPacketHandler(new PacketRequestTE(), (byte) 202);

	LookingGlassPacketManager.bus = NetworkRegistry.INSTANCE.newEventDrivenChannel(LookingGlassPacketManager.CHANNEL);
	LookingGlassPacketManager.bus.register(new LookingGlassPacketManager());

	// Load our basic configs
	ModConfigs.loadConfigs(new Configuration(event.getSuggestedConfigurationFile()));

	// Here we use the recommended config file to establish a good place to put a log file for any proxy world error logs.  Used primarily to log the full errors when ticking or rendering proxy worlds. 
	File configroot = event.getSuggestedConfigurationFile().getParentFile();
	// Main tick handler. Handles FML events.
	FMLCommonHandler.instance().bus().register(new LookingGlassEventHandler(new File(configroot.getParentFile(), "logs/proxyworlds.log")));
	// Forge event handler
	MinecraftForge.EVENT_BUS.register(new LookingGlassForgeEventHandler());

	// Initialize the API provider system.  Beware, this way be dragons.
	APIProviderImpl.init();
}
 

private void RegisterModuleEvents()
{
    if (CoreConfig.ModAdminErrorLogs_Enabled) {
        FMLCommonHandler.instance().bus().register(Module_AdminErrorLogs);
    }

    if (CoreConfig.ModHazardousItems_Enabled) {
        FMLCommonHandler.instance().bus().register(Module_HazardousItems);
    }

    if (CoreConfig.ModCustomToolTips_Enabled)
    {
        MinecraftForge.EVENT_BUS.register(Module_CustomToolTips);
        FMLCommonHandler.instance().bus().register(Module_CustomToolTips);
    }

    if (CoreConfig.ModCustomFuels_Enabled) {
        GameRegistry.registerFuelHandler(Module_CustomFuels);
    }

    if (CoreConfig.ModCustomDrops_Enabled) {
        MinecraftForge.EVENT_BUS.register(Module_CustomDrops);
    }

    if(Loader.isModLoaded("Railcraft")){
        MinecraftForge.EVENT_BUS.register(NH_GeodePopulator.instance());//instead of RC
        MinecraftForge.EVENT_BUS.register(NH_QuarryPopulator.instance());//instead of RC
    }
}
 

protected ModFixBase(String pModFixName)
{
  _mModFixName = pModFixName;
    
  if( needsForgeEventBus() ) {
      MinecraftForge.EVENT_BUS.register(this);
  }
  if( needsFMLEventBus() ) {
      FMLCommonHandler.instance().bus().register(this);
  }
}
 

public File getBaseDirectory() {
	if (FMLCommonHandler.instance().getSide().isClient()) {
		FMLClientHandler.instance().getClient();
		return FMLClientHandler.instance().getClient().mcDataDir;
	} else {
		return new File(".");
	}
}
 

private void registerNOVAItem(ItemFactory itemFactory) {
	if (map.containsKey(itemFactory)) {
		// just a safeguard - don't map stuff twice
		return;
	}

	net.minecraft.item.Item itemWrapper;

	Item dummy = itemFactory.build();
	if (dummy instanceof ItemBlock) {
		BlockFactory blockFactory = ((ItemBlock) dummy).blockFactory;
		net.minecraft.block.Block mcBlock = BlockConverter.instance().toNative(blockFactory);
		itemWrapper = net.minecraft.item.Item.getItemFromBlock(mcBlock);
		if (itemWrapper == null) {
			throw new InitializationException("ItemConverter: Missing block: " + itemFactory.getID());
		}
	} else {
		itemWrapper = new FWItem(itemFactory);
	}

	MinecraftItemMapping minecraftItemMapping = new MinecraftItemMapping(itemWrapper, 0);
	map.put(itemFactory, minecraftItemMapping);

	// Don't register ItemBlocks twice
	if (!(dummy instanceof ItemBlock)) {
		NovaMinecraft.proxy.registerItem((FWItem) itemWrapper);
		String itemId = itemFactory.getID();
		if (!itemId.contains(":"))
			itemId = NovaLauncher.instance().flatMap(NovaLauncher::getCurrentMod).map(Mod::id).orElse("nova") + ':' + itemId;
		GameRegistry.registerItem(itemWrapper, itemId);

		if (dummy.components.has(Category.class) && FMLCommonHandler.instance().getSide().isClient()) {
			//Add into creative tab
			Category category = dummy.components.get(Category.class);
			itemWrapper.setCreativeTab(CategoryConverter.instance().toNative(category, itemWrapper));
		}

		Game.logger().info("Registered item: {}", itemFactory.getID());
	}
}
 

@Mod.EventHandler
public void preInit(FMLPreInitializationEvent event) {
    this.logger = event.getModLog();
    File directory = new File(event.getModConfigurationDirectory() + File.separator + "FastAsyncWorldEdit");
    MinecraftForge.EVENT_BUS.register(this);
    FMLCommonHandler.instance().bus().register(this);
    this.IMP = new FaweForge(this, event.getModLog(), event.getModMetadata(), directory);
    try {
        Class.forName("org.spongepowered.api.Sponge");
        Settings.IMP.QUEUE.PARALLEL_THREADS = 1;
    } catch (Throwable ignore) {}
}
 

/**
 * Start measuring statistics. This will immediately create an async
 * repeating task as the plugin and send the initial data to the metrics
 * backend, and then after that it will post in increments of PING_INTERVAL
 * * 1200 ticks.
 *
 * @return True if statistics measuring is running, otherwise false.
 */
public boolean start() {
    // Did we opt out?
    if (isOptOut()) {
        return false;
    }

    FMLCommonHandler.instance().bus().register(this);

    return true;
}
 

/**
 * Enables metrics for the server by setting "opt-out" to false in the
 * config file and starting the metrics task.
 *
 * @throws java.io.IOException
 */
public void enable() throws IOException {
    // Check if the server owner has already set opt-out, if not, set it.
    if (isOptOut()) {
        configuration.getCategory(Configuration.CATEGORY_GENERAL).get("opt-out").set("false");
        configuration.save();
    }
    // Enable Task, if it is not running
    FMLCommonHandler.instance().bus().register(this);
}
 

/**
 * Disables metrics for the server by setting "opt-out" to true in the
 * config file and canceling the metrics task.
 *
 * @throws java.io.IOException
 */
public void disable() throws IOException {
    // Check if the server owner has already set opt-out, if not, set it.
    if (!isOptOut()) {
        configuration.getCategory(Configuration.CATEGORY_GENERAL).get("opt-out").set("true");
        configuration.save();
    }
    FMLCommonHandler.instance().bus().unregister(this);
}
 

@Override
public void postInitalize() {
    IResourceManager manager = Minecraft.getMinecraft().getResourceManager();
    if(manager instanceof SimpleReloadableResourceManager) {
        SimpleReloadableResourceManager rm = (SimpleReloadableResourceManager) manager;
        rm.registerReloadListener(ResourceReloadListener.getInstance());
    }

    MinecraftForge.EVENT_BUS.register(EffectHandler.getInstance());
    MinecraftForge.EVENT_BUS.register(new RenderEventHandler());

    FMLCommonHandler.instance().bus().register(new ClientHandler());

    super.postInitalize();
}
 

public static void teleportToFakeOuter(EntityPlayerMP player) {
    MinecraftServer mServer = FMLCommonHandler.instance().getMinecraftServerInstance();
    if(player.worldObj.provider.dimensionId != 0) {
        mServer.getConfigurationManager().transferPlayerToDimension(player, 0, new TeleporterNothing(mServer.worldServerForDimension(0)));
    }
    mServer.getConfigurationManager().transferPlayerToDimension(player, ModConfig.dimOuterId, new TeleporterNothing(mServer.worldServerForDimension(ModConfig.dimOuterId)));
}
 

public void openGui(Object mod, int modGuiId, World world, int x, int y, int z) {
    ModContainer mc = FMLCommonHandler.instance().findContainerFor(mod);
    tile.container = NetworkRegistry.INSTANCE.getRemoteGuiContainer(mc, this, modGuiId, world, x, y, z);
    if (tile.container != null) {
        tile.slots = new ArrayList<Slot>();
        for (Slot slot : (List<Slot>) tile.container.inventorySlots) {
            if(!inventory.equals(slot.inventory)) {
                tile.slots.add(slot);
            }
        }
    }
}
 

private void registerForgeHandlers()
{
    ForgeHandlers handlers = new ForgeHandlers();
    MinecraftForge.EVENT_BUS.register( handlers );
    FMLCommonHandler.instance().bus().register( handlers );
    if( QCraft.enableWorldGen )
    {
        GameRegistry.registerWorldGenerator( new QuantumOreGenerator(), 1 );
    }
    NetworkRegistry.INSTANCE.registerGuiHandler( QCraft.instance, handlers );

    ConnectionHandler connectionHandler = new ConnectionHandler();
    MinecraftForge.EVENT_BUS.register( connectionHandler );
    FMLCommonHandler.instance().bus().register( connectionHandler );
}
 

@SubscribeEvent
public void onPlayerLogin( PlayerEvent.PlayerLoggedInEvent event )
{
    EntityPlayer player = event.player;
    if( FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER )
    {
        QCraft.clearUnverifiedLuggage( player ); // Shouldn't be necessary, but can't hurt
        QCraft.requestLuggage( player );
    }
}
 

@SubscribeEvent
public void onPlayerLogout( PlayerEvent.PlayerLoggedOutEvent event )
{
    EntityPlayer player = event.player;
    if( FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER )
    {
        QCraft.clearUnverifiedLuggage( player );
    }
}