Java FMLLog.info方法代码示例

import cpw.mods.fml.common.FMLLog; //导入方法依赖的package包/类
public static void dumpMaterials() {
    if (MinecraftServer.getServer().cauldronConfig.dumpMaterials.getValue())
    {
        FMLLog.info("Cauldron Dump Materials is ENABLED. Starting dump...");
        for (int i = 0; i < 32000; i++)
        {
            Material material = Material.getMaterial(i);
            if (material != null)
            {
                FMLLog.info("Found material " + material + " with ID " + i);
            }
        }
        FMLLog.info("Cauldron Dump Materials complete.");
        FMLLog.info("To disable these dumps, set cauldron.dump-materials to false in bukkit.yml.");
    }
}
 

import cpw.mods.fml.common.FMLLog; //导入方法依赖的package包/类
private void detectOptifine()
{
    try
    {
        Class<?> optifineConfig = Class.forName("Config", false, Loader.instance().getModClassLoader());
        String optifineVersion = (String) optifineConfig.getField("VERSION").get(null);
        Map<String,Object> dummyOptifineMeta = ImmutableMap.<String,Object>builder().put("name", "Optifine").put("version", optifineVersion).build();
        ModMetadata optifineMetadata = MetadataCollection.from(getClass().getResourceAsStream("optifinemod.info"),"optifine").getMetadataForId("optifine", dummyOptifineMeta);
        optifineContainer = new DummyModContainer(optifineMetadata);
        FMLLog.info("Forge Mod Loader has detected optifine %s, enabling compatibility features",optifineContainer.getVersion());
    }
    catch (Exception e)
    {
        optifineContainer = null;
    }
}
 

import cpw.mods.fml.common.FMLLog; //导入方法依赖的package包/类
public static String checkModList(Map<String,String> listData, Side side)
{
    List<ModContainer> rejects = Lists.newArrayList();
    for (Entry<ModContainer, NetworkModHolder> networkMod : NetworkRegistry.INSTANCE.registry().entrySet())
    {
        boolean result = networkMod.getValue().check(listData, side);
        if (!result)
        {
            rejects.add(networkMod.getKey());
        }
    }
    if (rejects.isEmpty())
    {
        return null;
    }
    else
    {
        FMLLog.info("Rejecting connection %s: %s", side, rejects);
        return String.format("Mod rejections %s",rejects);
    }
}
 

import cpw.mods.fml.common.FMLLog; //导入方法依赖的package包/类
/**
 * @param objMap a map of the items required. Each entry should be an object of
 *               ItemStack, Item/Block or String(OreDict) and the amount of
 *               that item required
 */
public SpaceStationRecipe(HashMap<Object, Integer> objMap)
{
    for (final Object obj : objMap.keySet())
    {
        final Integer amount = objMap.get(obj);

        if (obj instanceof ItemStack)
        {
            this.input.put(((ItemStack) obj).copy(), amount);
        }
        else if (obj instanceof Item)
        {
            this.input.put(new ItemStack((Item) obj), amount);
        }
        else if (obj instanceof Block)
        {
            this.input.put(new ItemStack((Block) obj), amount);
        }
        else if (obj instanceof String)
        {
            FMLLog.info("While registering space station recipe, found " + OreDictionary.getOres((String) obj).size() + " type(s) of " + obj);
            this.input.put(OreDictionary.getOres((String) obj), amount);
        }
        else if (obj instanceof ArrayList)
        {
            this.input.put(obj, amount);
        }
        else
        {
            throw new RuntimeException("INVALID SPACE STATION RECIPE");
        }
    }
}
 

import cpw.mods.fml.common.FMLLog; //导入方法依赖的package包/类
@Override
public void fromBytes(ByteBuf buffer)
{
    serverProtocolVersion = buffer.readByte();
    // Extended dimension support during login
    if (serverProtocolVersion > 1)
    {
        overrideDimension = buffer.readInt();
        FMLLog.fine("Server FML protocol version %d, 4 byte dimension received %d", serverProtocolVersion, overrideDimension);
    }
    else
    {
        FMLLog.info("Server FML protocol version %d, no additional data received", serverProtocolVersion);
    }
}
 

import cpw.mods.fml.common.FMLLog; //导入方法依赖的package包/类
private void completeClientSideConnection(ConnectionType type)
{
    this.connectionType = type;
    FMLLog.info("[%s] Client side %s connection established", Thread.currentThread().getName(), this.connectionType.name().toLowerCase(Locale.ENGLISH));
    this.state = ConnectionState.CONNECTED;
    FMLCommonHandler.instance().bus().post(new FMLNetworkEvent.ClientConnectedToServerEvent(manager, this.connectionType.name()));
}
 

import cpw.mods.fml.common.FMLLog; //导入方法依赖的package包/类
private void completeServerSideConnection(ConnectionType type)
{
    this.connectionType = type;
    FMLLog.info("[%s] Server side %s connection established", Thread.currentThread().getName(), this.connectionType.name().toLowerCase(Locale.ENGLISH));
    this.state = ConnectionState.CONNECTED;
    FMLCommonHandler.instance().bus().post(new FMLNetworkEvent.ServerConnectionFromClientEvent(manager));
    scm.func_72355_a(manager, player, serverHandler);
}
 

import cpw.mods.fml.common.FMLLog; //导入方法依赖的package包/类
private boolean handleVanilla(Packet msg)
{
    if (state == ConnectionState.AWAITING_HANDSHAKE && msg instanceof S01PacketJoinGame)
    {
        handshakeChannel.pipeline().fireUserEventTriggered(msg);
    }
    else
    {
        FMLLog.info("Unexpected packet during modded negotiation - assuming vanilla or keepalives : %s", msg.getClass().getName());
    }
    return false;
}
 

import cpw.mods.fml.common.FMLLog; //导入方法依赖的package包/类
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception
{
    if (evt instanceof ConnectionType && side == Side.SERVER)
    {
        FMLLog.info("Timeout occurred, assuming a vanilla client");
        kickVanilla();
    }
}
 

import cpw.mods.fml.common.FMLLog; //导入方法依赖的package包/类
@Override
protected void testMessageValidity(FMLProxyPacket msg)
{
    if (msg.payload().getByte(0) == 0 && msg.payload().readableBytes() > 2)
    {
        FMLLog.severe("The connection appears to have sent an invalid FML packet of type 0, this is likely because it think's it's talking to 1.6.4 FML");
        FMLLog.info("Bad data :");
        for (String l : Splitter.on('\n').split(ByteBufUtils.getContentDump(msg.payload()))) {
            FMLLog.info("\t%s",l);
        }
        throw new FMLNetworkException("Invalid FML packet");
    }
}
 

import cpw.mods.fml.common.FMLLog; //导入方法依赖的package包/类
public List<ModContainer> explore(ASMDataTable table)
{
    this.table = table;
    this.mods = sourceType.findMods(this, table);
    if (!baseModCandidateTypes.isEmpty())
    {
        FMLLog.info("Attempting to reparse the mod container %s", getModContainer().getName());
        this.mods = sourceType.findMods(this, table);
    }
    return this.mods;
}
 

import cpw.mods.fml.common.FMLLog; //导入方法依赖的package包/类
private static int getPriority(IRecipe recipe)
{
    Class<?> cls = recipe.getClass();
    Integer ret = priorities.get(cls);

    if (ret == null)
    {
        if (!warned.contains(cls))
        {
            FMLLog.info("  Unknown recipe class! %s Modder please refer to %s", cls.getName(), RecipeSorter.class.getName());
            warned.add(cls);
        }
        cls = cls.getSuperclass();
        while (cls != Object.class)
        {
            ret = priorities.get(cls);
            if (ret != null)
            {
                priorities.put(recipe.getClass(), ret);
                FMLLog.fine("    Parent Found: %d - %s", ret.intValue(), cls.getName());
                return ret.intValue();
            }
        }
    }

    return ret == null ? 0 : ret.intValue();
}
 

import cpw.mods.fml.common.FMLLog; //导入方法依赖的package包/类
/**
 * Request a chunkloading ticket of the appropriate type for the supplied mod
 *
 * @param mod The mod requesting a ticket
 * @param world The world in which it is requesting the ticket
 * @param type The type of ticket
 * @return A ticket with which to register chunks for loading, or null if no further tickets are available
 */
public static Ticket requestTicket(Object mod, World world, Type type)
{
    ModContainer container = getContainer(mod);
    if (container == null)
    {
        FMLLog.log(Level.ERROR, "Failed to locate the container for mod instance %s (%s : %x)", mod, mod.getClass().getName(), System.identityHashCode(mod));
        return null;
    }
    String modId = container.getModId();
    if (!callbacks.containsKey(modId))
    {
        FMLLog.severe("The mod %s has attempted to request a ticket without a listener in place", modId);
        throw new RuntimeException("Invalid ticket request");
    }

    int allowedCount = getMaxTicketLengthFor(modId);

    if (tickets.get(world).get(modId).size() >= allowedCount)
    {
        if (!warnedMods.contains(modId))
        {
            FMLLog.info("The mod %s has attempted to allocate a chunkloading ticket beyond it's currently allocated maximum : %d", modId, allowedCount);
            warnedMods.add(modId);
        }
        return null;
    }
    Ticket ticket = new Ticket(modId, type, world);
    tickets.get(world).put(modId, ticket);

    return ticket;
}
 

import cpw.mods.fml.common.FMLLog; //导入方法依赖的package包/类
public static void setWorld(int id, WorldServer world)
{
    if (world != null)
    {
        worlds.put(id, world);
        weakWorldMap.put(world, world);
        MinecraftServer.func_71276_C().worldTickTimes.put(id, new long[100]);
        FMLLog.info("Loading dimension %d (%s) (%s)", id, world.func_72912_H().func_76065_j(), world.func_73046_m());
    }
    else
    {
        worlds.remove(id);
        MinecraftServer.func_71276_C().worldTickTimes.remove(id);
        FMLLog.info("Unloading dimension %d", id);
    }

    ArrayList<WorldServer> tmp = new ArrayList<WorldServer>();
    if (worlds.get( 0) != null)
        tmp.add(worlds.get( 0));
    if (worlds.get(-1) != null)
        tmp.add(worlds.get(-1));
    if (worlds.get( 1) != null)
        tmp.add(worlds.get( 1));

    for (Entry<Integer, WorldServer> entry : worlds.entrySet())
    {
        int dim = entry.getKey();
        if (dim >= -1 && dim <= 1)
        {
            continue;
        }
        tmp.add(entry.getValue());
    }

    MinecraftServer.func_71276_C().field_71305_c = tmp.toArray(new WorldServer[tmp.size()]);
}
 

import cpw.mods.fml.common.FMLLog; //导入方法依赖的package包/类
private static void scan(final LaunchClassLoader loader, final List<DiscoverCandidate> candidates, final DataScanner scanner) {
    for (final DiscoverCandidate candidate : candidates) {
        FastDiscoverer.sNeedInjection = false;
        for (final InputStream is : candidate) {
            scanner.scanClass(is);
        }
        if (FastDiscoverer.sNeedInjection) {
            FMLLog.info("Found Fan in " + candidate + ", injecting into classloader...", new Object[0]);
            candidate.injectClassLoader(loader);
        }
    }
}