Java 类net.minecraftforge.common.capabilities.CapabilityManager 实例源码

public void preinitializeMods()
{
    if (!modController.isInState(LoaderState.PREINITIALIZATION))
    {
        FMLLog.warning("There were errors previously. Not beginning mod initialization phase");
        return;
    }
    PersistentRegistryManager.fireCreateRegistryEvents();
    ObjectHolderRegistry.INSTANCE.findObjectHolders(discoverer.getASMTable());
    ItemStackHolderInjector.INSTANCE.findHolders(discoverer.getASMTable());
    CapabilityManager.INSTANCE.injectCapabilities(discoverer.getASMTable());
    PersistentRegistryManager.fireRegistryEvents();
    FMLCommonHandler.instance().fireSidedRegistryEvents();
    modController.distributeStateMessage(LoaderState.PREINITIALIZATION, discoverer.getASMTable(), canonicalConfigDir);
    ObjectHolderRegistry.INSTANCE.applyObjectHolders();
    ItemStackHolderInjector.INSTANCE.inject();
    modController.transition(LoaderState.INITIALIZATION, false);
    progressBar.step("Initializing Minecraft Engine");
}

@EventHandler
public void preInit(FMLPreInitializationEvent event)
{
    ConfigurationHandler.init(event.getSuggestedConfigurationFile());

    //Networking
    CHANNEL.registerMessage(CheckSheepChiseledRequestMessageHandler.class, CheckSheepChiseledRequestMessage.class, 0, Side.SERVER);
    CHANNEL.registerMessage(SheepChiseledMessageHandler.class, SheepChiseledMessage.class, 1, Side.CLIENT);
    CHANNEL.registerMessage(SpawnCustomParticleMessageHandler.class, SpawnCustomParticleMessage.class, 2, Side.CLIENT);
    CHANNEL.registerMessage(PlayCustomSoundMessageHandler.class, PlayCustomSoundMessage.class, 3, Side.CLIENT);

    //Capabilities
    CapabilityManager.INSTANCE.register(IChiseledSheepCapability.class, ChiseledSheepCapabilityStorage.instance, ChiseledSheepCapability::new);

    //Eventing
    MinecraftForge.EVENT_BUS.register(Proxies.forgeEventProxy);
    MinecraftForge.EVENT_BUS.register(Proxies.renderProxy);

    MinecraftForge.EVENT_BUS.post(new RegisterAdditionalCapabilitiesEvent());

    Proxies.blockProxy.registerBlocks();
    Proxies.audioProxy.registerSounds();
}

/**
 * Call this from pre-init if you want to use this capability.
 */
public static void enable()
{
    if (!enabled)
    {
        enabled = true;
        CapabilityManager.INSTANCE.register(ITweakable.class, new Storage(), new Callable<ITweakable>()
        {
            @Override
            public ITweakable call() throws Exception
            {
                return new Implementation();
            }
        });
    }
}

/**
 * Call this from pre-init if you want to use this capability.
 */
public static void enable()
{
    if (!enabled)
    {
        enabled = true;
        CapabilityManager.INSTANCE.register(IEnergyHandler.class, new Storage(), new Callable<IEnergyHandler>()
        {
            @Override
            public IEnergyHandler call() throws Exception
            {
                return new EnergyBuffer();
            }
        });
    }
}

@Mod.EventHandler
public void preInit(FMLPreInitializationEvent e) {
    MCFluxReport.handleErrors();
    L = e.getModLog();
    MC_DIR = e.getModConfigurationDirectory().getParentFile();
    MCFluxConfig.makeConfig(e.getSuggestedConfigurationFile());
    if (R.MF_VERSION.charAt(0) == '$')
        L.warn("You are running Minecraft-Flux with an unknown version (development maybe?)");
    CloudUtils.init();
    if (MCFluxConfig.UPDATE_CHECK)
        CloudUtils.executeTask(MCFlux::updateCheck);
    SpecialEventHandler.getEvents();
    MCFluxNetwork.registerAll();
    NetworkRegistry.INSTANCE.registerGuiHandler(this, new MCFluxGuiHandler());
    CapabilityManager cm = CapabilityManager.INSTANCE;
    cm.register(WorldChunkEnergy.class, CapStorage.getNBTStorage(), WorldChunkEnergy::new);
    cm.register(PlayerEnergy.class, CapStorage.getNBTStorage(), PlayerEnergy::new);
    cm.register(SpecialEventReceiver.class, CapStorage.getNBTStorage(), SpecialEventReceiver::new);
    MCFluxResources.preInit();
    PROXY.preInit();
    JavaUtils.eachAnnotatedClasses(e.getAsmData(), FluxCompat.Addon.class, FluxCompat::addAddon);
    FluxCompat.init();
    FMLInterModComms.sendFunctionMessage("theoneprobe", "getTheOneProbe", TOPInit.class.getName());
}

public void init() {
    StartUpCommon.InitCommon();

    NetworkRegistry.INSTANCE.registerGuiHandler(main.instance, new GuiHandler());
    System.out.println("STARTING BOOTING CAPABILITY SYSTEM");
    CapabilityManager.INSTANCE.register(IRadiationCapability.class, new RadsFactoryStorage(), RadsFactoryProvider::new);
    System.out.println("RADS--------------CHECK!");
    CapabilityManager.INSTANCE.register(ISpechialCapability.class, new SpechialFactoryStorage(), () -> new SpechialFactoryProvider());
    System.out.println("S.P.E.C.H.I.A.L--------------CHECK!");
    CapabilityManager.INSTANCE.register(ISkillsCapability.class, new SkillsFactoryStorage(), SkillsFactoryProvider::new);
    System.out.println("SKILLS--------------CHECK!");
    CapabilityManager.INSTANCE.register(ILevelCapability.class, new LevelFactoryStorage(), LevelFactoryProvider::new);
    System.out.println("LEVELS--------------CHECK!");
    CapabilityManager.INSTANCE.register(IFTJCapability.class, new FTJFactoryStorage(), FTJFactoryProvider::new);
    System.out.println("FTJ--------------CHECK!");
    CapabilityManager.INSTANCE.register(IWaterCapability.class, new WaterFactoryStorage(), WaterFactoryProvider::new);
    CapabilityManager.INSTANCE.register(IAdvInventory.class, new IAdvStorage(), IAdvProvider::new);
    CapabilityManager.INSTANCE.register(IAmmoInterface.class, new IAmmoStorage(),  AmmoFactoryProvider::new);
    CapabilityManager.INSTANCE.register(IGunInterface.class,new IGunStorage(), GunFactoryProvider::new);
    CapabilityManager.INSTANCE.register(ITrigger_item.class, new ITrigger_Item_Storage(), ITrigger_item_Provider::new);
    System.out.println("FINISHED BOOTING CAPABILITY SYSTEM");
    MinecraftForge.EVENT_BUS.register(new EventHandlerInit());
}

@EventHandler
public void preInit (FMLPreInitializationEvent event) {

    CapabilityManager.INSTANCE.register(ITeslaConsumer.class, new CapabilityTeslaConsumer<ITeslaConsumer>(), BaseTeslaContainer.class);
    CapabilityManager.INSTANCE.register(ITeslaProducer.class, new CapabilityTeslaProducer<ITeslaProducer>(), BaseTeslaContainer.class);
    CapabilityManager.INSTANCE.register(ITeslaHolder.class, new CapabilityTeslaHolder<ITeslaHolder>(), BaseTeslaContainer.class);
}

public void preInit(FMLPreInitializationEvent e) {
    RegistryBuilder ritualRegistryBuilder = new RegistryBuilder();
    ritualRegistryBuilder.setMaxID(512)
            .setType(RitualRecipe.class)
            .setName(new ResourceLocation(Constants.MODID, "ritual_registry"));
    ritualRegistryBuilder.create();

    CapabilityManager.INSTANCE.register(IFaerieInformation.class, new FaerieInformationStorage(), FaerieInformation.class);
    GeneraEntities.init();
    GeneraTileEntities.init();
    MinecraftForge.EVENT_BUS.register(new EventHandler());
}

@EventHandler
public void preInit(FMLPreInitializationEvent event) {
    PacketHandler.registerMessages();

    File directory = event.getModConfigurationDirectory();
       config = new Configuration(new File(directory.getPath(), "etheric.cfg"));
       Config.readConfig();

       CapabilityManager.INSTANCE.register(IQuintessenceCapability.class, new QuintessenceCapabilityStorage(), DefaultQuintessenceCapability.class);

    proxy.preInit(event);

    GameRegistry.registerWorldGenerator(new EthericWorldGenerator(), 0);
}

@EventHandler
public void preInit (FMLPreInitializationEvent event) {

    // Packets
    NETWORK.register(PacketStage.class, Side.CLIENT);
    NETWORK.register(PacketStageAll.class, Side.CLIENT);
    NETWORK.register(PacketRequestClientSync.class, Side.SERVER);

    CapabilityManager.INSTANCE.register(IStageData.class, new Storage(), DefaultStageData.class);
    MinecraftForge.EVENT_BUS.register(new PlayerDataHandler());
    BookshelfRegistry.addCommand(COMMAND);
    BookshelfRegistry.addGameRule(GAME_RULE_SHARE_STAGES);
}

public void onPreInit() {
    MinecraftForge.EVENT_BUS.register(new ServerEventHandler());
    PossessHandler.onPreInit();
    ItemRegistry.onPreInit();
    BlockRegistry.onPreInit();

    NetworkRegistry.INSTANCE.registerGuiHandler(Possessed.getInstance(), this);

    GameRegistry.registerWorldGenerator(new PossessedWorldGenerator(), 0);

    CapabilityManager.INSTANCE.register(PossessCapability.class, new PossessCapability.Storage(), new PossessCapability.Factory());
}

public void init(FMLPreInitializationEvent e) {
  CapabilityManager.INSTANCE.register(IEnergyHandler.class, new MvesStorage<IEnergyHandler>(), MvesDefaultImpl.class);
  CapabilityManager.INSTANCE.register(IEnergySupplier.class, new MvesStorage<IEnergySupplier>(), MvesDefaultImpl.class);
  CapabilityManager.INSTANCE.register(IEnergyTransporter.class, new MvesStorage<IEnergyTransporter>(), MvesDefaultImpl.class);
  CapabilityManager.INSTANCE.register(IEnergyAcceptor.class, new MvesStorage<IEnergyAcceptor>(), MvesDefaultImpl.class);

  if (Config.enableFurnaceHooking.getBoolean()) {
    MinecraftForge.EVENT_BUS.register(new FurnaceCapabilityAttacher());
  }
  if (Config.enableRainbowWire.getBoolean()) {
    BlockMvesWire.create();
  }
}

/**
 * Load stuff
 * 
 * Add event listeners, register morphing capability and also load user 
 * configuration. I don't know how it's going to work in multiplayer, 
 * probably won't lol
 */
public void load()
{
    /* Event listeners */
    MinecraftForge.EVENT_BUS.register(this.config);
    MinecraftForge.EVENT_BUS.register(new MorphHandler());
    MinecraftForge.EVENT_BUS.register(new CapabilityHandler());
    MinecraftForge.EVENT_BUS.register(new RegisterHandler());

    /* Morphing manager and capabilities */
    CapabilityManager.INSTANCE.register(IMorphing.class, new MorphingStorage(), Morphing.class);

    /* Register morph factories */
    RegisterHandler.registerAbilities(MorphManager.INSTANCE);
    MorphManager.INSTANCE.register();

    /* User configuration */
    if (!morphs.exists())
    {
        MorphUtils.generateFile(morphs, "{}");
    }

    if (!blacklist.exists())
    {
        MorphUtils.generateFile(blacklist, "[]");
    }
}

public static void register() {
    CapabilityManager.INSTANCE.register(PlayerCivilizationCapability.class, new PlayerCivilizationStorage(), new Callable<PlayerCivilizationCapability>() {
        @Override
        public PlayerCivilizationCapability call() throws Exception {
            return null;
        }
    });
}

public static void initialization()
{
    CapabilityManager.INSTANCE.register(PlayerAether.class, new PlayerAetherStorage(), PlayerAether.class);

    AetherRankings.initialization();

    CommonProxy.registerEvent(new PlayerAetherEvents());
}

public static void preInit() {
    CapabilityManager.INSTANCE.register(INetworkGraphVertexBase.class, new StorageEmpty<INetworkGraphVertexBase>(),
        INetworkGraphVertexBase.class);
    CapabilityManager.INSTANCE.register(IIWTechEnergyConsumer.class, new StorageEmpty<IIWTechEnergyConsumer>(),
        IIWTechEnergyConsumer.class);
    CapabilityManager.INSTANCE.register(IIWTechAbyssEnergyProducer.class,
        new StorageEmpty<IIWTechAbyssEnergyProducer>(), IIWTechAbyssEnergyProducer.class);
    CapabilityManager.INSTANCE.register(IIWTechSourceEnergyProducer.class,
        new StorageEmpty<IIWTechSourceEnergyProducer>(), IIWTechSourceEnergyProducer.class);
}

@EventHandler
public void preInit (FMLPreInitializationEvent event) {

    CapabilityManager.INSTANCE.register(ITeslaConsumer.class, new CapabilityTeslaConsumer<>(), BaseTeslaContainer.class);
    CapabilityManager.INSTANCE.register(ITeslaProducer.class, new CapabilityTeslaProducer<>(), BaseTeslaContainer.class);
    CapabilityManager.INSTANCE.register(ITeslaHolder.class, new CapabilityTeslaHolder<>(), BaseTeslaContainer.class);
}

public static void init()
{
    CapabilityManager.INSTANCE.register(IHunterRank.class, new Storage<IHunterRank>(), new Callable<IHunterRank>()
    {
        @Override
        public IHunterRank call() throws Exception
        {
            return new CapabilityHunterRank();
        }
    });

    CapabilityManager.INSTANCE.register(IQuest.class, new Storage<IQuest>(), new Callable<IQuest>()
    {
        @Override
        public IQuest call() throws Exception
        {
            return new CapabilityQuest();
        }
    });

    CapabilityManager.INSTANCE.register(IMonsters.class, new Storage<IMonsters>(), new Callable<IMonsters>()
    {
        @Override
        public IMonsters call() throws Exception
        {
            return new CapabilityMonsters();
        }
    });
}

@SuppressWarnings("unchecked")
public void registerCapability(ICapabilityImplementation implementation) {
    if(!this.map.containsKey(implementation.getCarrierClass())) {
        this.map.put(implementation.getCarrierClass(), new ArrayList<>());
    }
    this.map.get(implementation.getCarrierClass()).add(implementation);
    CapabilityManager.INSTANCE.register(implementation.getCapabilityClass(), new CapabilityStorage(), () -> null);
}

public static void registerCapabilities() {
    CapabilityManager.INSTANCE.register(IMunny.class, new MunnyCapability.Storage(), MunnyCapability.Default.class);
    CapabilityManager.INSTANCE.register(IPlayerStats.class, new PlayerStatsCapability.Storage(), PlayerStatsCapability.Default.class);
    CapabilityManager.INSTANCE.register(ISummonKeyblade.class, new SummonKeybladeCapability.Storage(), SummonKeybladeCapability.Default.class);
    CapabilityManager.INSTANCE.register(IDriveState.class, new DriveStateCapability.Storage(), DriveStateCapability.Default.class);
    CapabilityManager.INSTANCE.register(IMagicState.class, new MagicStateCapability.Storage(), MagicStateCapability.Default.class);
    CapabilityManager.INSTANCE.register(IFirstTimeJoin.class, new FirstTimeJoinCapability.Storage(), FirstTimeJoinCapability.Default.class);
    CapabilityManager.INSTANCE.register(ISynthesisRecipe.class, new SynthesisRecipeCapability.Storage(), SynthesisRecipeCapability.Default.class);
    CapabilityManager.INSTANCE.register(ISynthesisMaterial.class, new SynthesisMaterialCapability.Storage(), SynthesisMaterialCapability.Default.class);
    CapabilityManager.INSTANCE.register(ICheatMode.class, new CheatModeCapability.Storage(), CheatModeCapability.Default.class);
    CapabilityManager.INSTANCE.register(IOrganizationXIII.class, new OrganizationXIIICapability.Storage(), OrganizationXIIICapability.Default.class);
}

public void preInit() {
    MinecraftForge.EVENT_BUS.register(this);
    MinecraftForge.EVENT_BUS.register(WearableBackpacks.CONFIG);
    MinecraftForge.EVENT_BUS.register(WearableBackpacks.CONTENT);
    MinecraftForge.EVENT_BUS.register(new DyeWashingHandler());

    CapabilityManager.INSTANCE.register(IBackpack.class,
        new BackpackCapability.Storage(), BackpackCapability.class);
}

public void preInit() {
    CapabilityManager.INSTANCE.register(IHacking.class, new HackingImpl.Storage(), HackingImpl::new);
    AdvancementTriggers.registerTriggers();
}

public static void init() {
    CapabilityManager.INSTANCE.register(CapabilityDivination.class, new DivinationStorage(), Impl::new);
}

public static void register()
{
    CapabilityManager.INSTANCE.register(IAnimaStorage.class, storage, AnimaStorage.class);
    CapabilityManager.INSTANCE.register(INotebookInfo.class, info, NotebookInfo.class);
}

public static void register() {
    CapabilityManager.INSTANCE.register(AccountCapability.class, new AccountCapability.Storage(), new AccountCapability.Factory());
}

public static void register() {
    CapabilityManager.INSTANCE.register(CartCapability.class, new CartCapability.Storage(), new CartCapability.Factory());
}

@EventHandler
public void preInit (FMLPreInitializationEvent event) {

    CapabilityManager.INSTANCE.register(ICurio.class, new StorageCurio(), CurioDefault.class);
}

public void registerBase() {
    CapabilityManager.INSTANCE.register(ITeslaEnergyStorage.class, new BasicStorage<ITeslaEnergyStorage>(), TeslaEnergyStorage.class);
}

public static void register() {
    CapabilityManager.INSTANCE.register(IRevival.class, new CapaReviveStorage(), DefaultImpl::new);
}

public static void registerCapabilities() {
    CapabilityManager.INSTANCE.register(IWork.class, new CapabilityWorker(), Worker.class);
}

public static void register()
{
    CapabilityManager.INSTANCE.register(IAnimaStorage.class, new AnimaNBTStorage(), new AnimaFactory());
}

@Load
public static void registerCapabilities() {
    CapabilityManager.INSTANCE.register(FoodStats.class, new CapabilityFood.Storage(), CapabilityFood.Implementation.class);
}

public static void register() {
    CapabilityManager.INSTANCE.register(IDailiesCapability.class, new DailiesStorage(), DailiesCapabilityImpl.class);
    MinecraftForge.EVENT_BUS.register(new Events());
}

public void preInit(FMLPreInitializationEvent e) {
    modConfigDir = e.getModConfigurationDirectory();
       mainConfig = new Configuration(new File(modConfigDir.getPath() + File.separator + "crystalmod", "crystalmod.cfg"));
       readMainConfig();

       MinecraftForge.EVENT_BUS.register(new Config());
       MinecraftForge.EVENT_BUS.register(new MissingItemHandler());


       ModFluids.registerFluids();
    ModBlocks.init();
    ModItems.init();
    ModCrops.init();
    ModCrafting.preInit();
    ModEntites.init();
       ItemMobEssence.initDefaultMobs();
       ModBats.registerBats();
       ModBats.registerUpgrades();


       CapabilityManager.INSTANCE.register(ExtendedPlayer.class, new ExtendedPlayerProvider.Storage(), ExtendedPlayer.class);
       CapabilityCrystalEnergy.register();

       CrystalModWorldGenerator generator = CrystalModWorldGenerator.instance;
       GameRegistry.registerWorldGenerator(generator, 5);

       MapGenStructureIO.registerStructure(MapGenFusionTemple.Start.class, CrystalMod.resource("fusiontemplestart"));
       MapGenStructureIO.registerStructureComponent(FusionTempleStructure.class, CrystalMod.resource("fusiontemple"));
       MapGenStructureIO.registerStructure(MapGenCrystexiumSpike.Start.class, CrystalMod.resource("crystexiumspikestart"));
       MapGenStructureIO.registerStructureComponent(CrystexiumSpikeStructure.class, CrystalMod.resource("crystexiumspike"));
       MapGenStructureIO.registerStructureComponent(VillageCornField.class, CrystalMod.resource("villagecornfield"));



       MinecraftForge.EVENT_BUS.register(generator);

       MinecraftForge.EVENT_BUS.register(DropCapture.instance);

       MinecraftForge.EVENT_BUS.register(new DisguiseHandler());

       PlayerCubeChunkLoaderManager.init();
       ForgeChunkManager.setForcedChunkLoadingCallback(CrystalMod.instance, new WorksiteChunkLoader());

       ModIntegration.register();
       ModIntegration.preInit();
}

public static void preInit() {
    CapabilityManager.INSTANCE.register(IWizardryCapability.class, new WizardryCapabilityStorage(), DefaultWizardryCapability.class);
}

@SubscribeEvent
@Optional.Method(modid = ChanceCubesReference.CHANCE_CUBES_MODID)
public static void onRegisterAdditionalCapabilities(RegisterAdditionalCapabilitiesEvent event) {
    CapabilityManager.INSTANCE.register(IChanceCubeParticipationCapability.class, ChanceCubeParticipationStorage.instance, com.github.atomicblom.shearmadness.variations.chancecubes.capability.ChanceCubeParticipationCapability::new);
}

public void prepare() {
    CapabilityManager.INSTANCE.register(IPlayerData.class, new PlayerDataStorage(), new PlayerDataFactory());
}

public static void register()
{
    CapabilityManager.INSTANCE.register(ISteamHandler.class, new DefaultSteamHandlerStorage<>(),
            () -> new SteamTank(0, 10000, SteamUtil.BASE_PRESSURE * 2));
}

@Mod.EventHandler
public void preInit(FMLPreInitializationEvent event) {
    ExtendedConfig.getInstance(event.getModConfigurationDirectory().getAbsolutePath() + "/GraveStoneMod/", "GraveStone.cfg");

    FluidRegistry.registerFluid(FluidToxicWater.INSTANCE);
    FluidRegistry.addBucketForFluid(FluidToxicWater.INSTANCE);

    GSStructures.preInit();

    MessageHandler.init();

    GSTabs.registration();
    TileEntity.registration();

    CapabilityManager.INSTANCE.register(IChoke.class, new ChokeStorage(), Choke.class);
}

/**
 * Registers network messages (and their handlers), items, blocks, director
 * block tile entities and actor entity.
 */
public void preLoad(FMLPreInitializationEvent event)
{
    Dispatcher.register();
    NetworkRegistry.INSTANCE.registerGuiHandler(Blockbuster.instance, new GuiHandler());

    /* Configuration */
    File config = new File(event.getModConfigurationDirectory(), "blockbuster/config.cfg");

    this.forge = new Configuration(config);
    this.config = new BlockbusterConfig(this.forge);

    MinecraftForge.EVENT_BUS.register(this.config);
    MinecraftForge.EVENT_BUS.register(new EventHandler());

    /* Creative tab */
    Blockbuster.blockbusterTab = new BlockbusterTab();

    /* Items */
    this.registerItem(Blockbuster.registerItem = new ItemRegister());
    this.registerItem(Blockbuster.playbackItem = new ItemPlayback());
    this.registerItem(Blockbuster.actorConfigItem = new ItemActorConfig());

    /* Blocks */
    this.registerBlock(Blockbuster.directorBlock = new BlockDirector());

    /* Entities */
    this.registerEntityWithEgg(EntityActor.class, "Actor", 0xffc1ab33, 0xffa08d2b);

    /* Tile Entities */
    GameRegistry.registerTileEntity(TileEntityDirector.class, "blockbuster_director_tile_entity");

    /* Capabilities */
    CapabilityManager.INSTANCE.register(IRecording.class, new RecordingStorage(), Recording.class);

    /* Morphing */
    MorphManager.INSTANCE.factories.add(this.factory = new BlockbusterFactory());

    /* Load models */
    this.models = new ModelHandler();
    this.loadModels(this.getPack());
}