java类cpw.mods.fml.common.event.FMLServerStartingEvent的实例源码

@Mod.EventHandler
@SideOnly(Side.SERVER)
public void serverStart(FMLServerStartingEvent event)
{
    if (INSTANCE == null) INSTANCE = this;
    if (SERVER   == null) SERVER   = event.getServer();
    if (COMMAND  == null) COMMAND  = new WBCommand();

    // Load (or create new) config files
    Config.load(false);

    // our one real command, though it does also have aliases "wb" and "worldborder"
    event.registerServerCommand(COMMAND);

    if ( Config.preventBlockPlace() )
        enableBlockPlaceListener(true);

    if ( Config.preventMobSpawn() )
        enableMobSpawnListener(true);

    if ( Config.getDenyEnderpearl() )
        enableEnderPearlListener(true);

    DynMapFeatures.registerListener();
}

@EventHandler
public void serverStarting(FMLServerStartingEvent event)
{
    if(general.voiceServerEnabled)
    {
        voiceManager.start();
    }

    //Load cached furnace recipes
    Recipe.ENERGIZED_SMELTER.get().clear();

    for(Object obj : FurnaceRecipes.smelting().getSmeltingList().entrySet())
    {
        Map.Entry<ItemStack, ItemStack> entry = (Map.Entry<ItemStack, ItemStack>)obj;
        SmeltingRecipe recipe = new SmeltingRecipe(new ItemStackInput(entry.getKey()), new ItemStackOutput(entry.getValue()));
        Recipe.ENERGIZED_SMELTER.put(recipe);
    }

    event.registerServerCommand(new CommandMekanism());
}

@EventHandler
  public void serverLoad(FMLServerStartingEvent event)
  {
      // register server commands
    event.registerServerCommand(new CommandTeleport());
    event.registerServerCommand(new CommandSmoothMove());
    event.registerServerCommand(new CommandAStar());
    event.registerServerCommand(new CommandBFS());
    event.registerServerCommand(new CommandVI());
    event.registerServerCommand(new CommandRMax());
    event.registerServerCommand(new CommandCreateDungeons());
      event.registerServerCommand(new CommandInventory());
      event.registerServerCommand(new CommandCheckState());
      event.registerServerCommand(new CommandResetDungeon());
      event.registerServerCommand(new CommandCheckProps());
    event.registerServerCommand(new CommandTest());
    event.registerServerCommand(new CommandTerminalExplore());
      event.registerServerCommand(new CommandCurrentPath());
event.registerServerCommand(new CommandReachable());

  }

@Mod.EventHandler()
public void eventHandler(FMLServerStartingEvent event)
{
    RecipeRegistry.setConfigFromServer(listType, list);

    recipeFile = new File(DimensionManager.getCurrentSaveRootDirectory(), MODID + ".dat");
    if (recipeFile.exists())
    {
        try
        {
            RecipeRegistry.loadRecipesFromNBT(CompressedStreamTools.read(recipeFile));
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
    else
    {
        RecipeRegistry.randomizeRecipes(recipeFile);
    }

    if (timer > 0) setupTimer();
}

@EventHandler
public void serverLoad(FMLServerStartingEvent event) {
    instance = this;
    event.registerServerCommand(new RedGenCommand());
    event.registerServerCommand(new ClearCommand());
    event.registerServerCommand(new PosCommand());
    event.registerServerCommand(new Pos1Command());
    event.registerServerCommand(new Pos2Command());
    event.registerServerCommand(new RouteCommand());
    event.registerServerCommand(new MetaCommand());
    event.registerServerCommand(new CopyCommand());
    event.registerServerCommand(new PasteCommand());
    event.registerServerCommand(new UndoCommand());
    event.registerServerCommand(new RedoCommand());
    event.registerServerCommand(new MazeGenCommand());
}

@Mod.EventHandler
public void serverStartingEvent(FMLServerStartingEvent e){
    info("Starting ServerForge...");
    this.serverStartingEvent = e;

    eventManager = new EventManager();
    eventManager.onServerStart();

    permissionsManager = new PermissionsManager();
    permissionsManager.onServerStart();

    pluginLoader = new PluginLoader();
    pluginLoader.onServerStart();

    this.serverStartingEvent = null;
    info("ServerForge started");
}

@EventHandler
public void serverStarting(FMLServerStartingEvent event) {
    if (event.getServer().isDedicatedServer()) return;

    File worldConfigDir = new File(DimensionManager.getCurrentSaveRootDirectory(), "config");
    File worldConfigFile = new File(worldConfigDir, MOD_ID + ".cfg");

    worldConfig = new AHOWorldConfig(worldConfigFile);
    worldConfig.load(globalConfig);

    // If the world was just created using the  
    // create world screen, use the selected preset.
    EnumPreset preset = AHOGuiCreateWorld.getAndResetPreset();
    if (preset != EnumPreset.CUSTOM) {
        worldConfig.usePreset(preset);
        worldConfig.save();
    // Save the world config file if it's already created, in case the
    // preset setting was changed or the mod updated with new settings.
    } else if (worldConfigFile.exists())
        worldConfig.save();

    if (worldConfig.exists())
        config.add(Priority.WORLD, worldConfig);
}

@EventHandler
public void serverStarting(FMLServerStartingEvent ev) {
    EconomyProxy.init();
    checkConfig();
    registerCommands();
    Commands.populateCompletionMap();

    jsonConfigs.add(new WildPermsConfig(Constants.CONFIG_FOLDER + "/WildPerms.json"));
    jsonConfigs.add(new FlagsConfig(Constants.CONFIG_FOLDER + "/DefaultFlags.json"));
    jsonConfigs.add(new RanksConfig(Constants.CONFIG_FOLDER + "/DefaultTownRanks.json"));
    for (JsonConfig jsonConfig : jsonConfigs) {
        jsonConfig.init();
    }

    ProtectionParser.start();
    //SafemodeHandler.setSafemode(!DatasourceProxy.start(config));
    datasource = new MyTownDatasource();
    LOG.info("Started");
}

public void serverStarting(FMLServerStartingEvent event) { 
    RecipeHelper.parseRecipes();
    Physis.oooBuilder.start();

    if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER) {
        World world = MinecraftServer.getServer().worldServers[0];
        PhysisWorldSavedData.load(world);
    }
    ServerData.reload(false);

    // set up the story!
    long seed = event.getServer().worldServers[0].getWorldInfo().getSeed();
    Random r = new Random(seed);
    long storySeed = Math.abs(r.nextLong());

    Physis.logger.info("Starting story engine: overworld seed: "+seed+", storyseed: "+storySeed);

    StoryEngine.reload(storySeed, false);
}

@Mod.EventHandler
public void serverStarting(FMLServerStartingEvent event)
{
    event.registerServerCommand(new CommandInvite());
    event.registerServerCommand(new CommandPregen());
    deserializePreload(new File(getSaveFolder(), "pregenData.json"));
}

@EventHandler
public void serverStarting(FMLServerStartingEvent event)
{
    event.registerServerCommand(new CommandSpaceStationAddOwner());
    event.registerServerCommand(new CommandSpaceStationChangeOwner());
    event.registerServerCommand(new CommandSpaceStationRemoveOwner());
    event.registerServerCommand(new CommandPlanetTeleport());
    event.registerServerCommand(new CommandKeepDim());
    event.registerServerCommand(new CommandGCInv());
    event.registerServerCommand(new CommandGCHelp());
    event.registerServerCommand(new CommandGCEnergyUnits());
    event.registerServerCommand(new CommandJoinSpaceRace());

    WorldUtil.initialiseDimensionNames();
    WorldUtil.registerSpaceStations(event.getServer().worldServerForDimension(0).getSaveHandler().getMapFileFromName("dummy").getParentFile());

    ArrayList<CelestialBody> cBodyList = new ArrayList<CelestialBody>();
    cBodyList.addAll(GalaxyRegistry.getRegisteredPlanets().values());
    cBodyList.addAll(GalaxyRegistry.getRegisteredMoons().values());

    for (CelestialBody body : cBodyList)
    {
        if (body.shouldAutoRegister())
        {
            if (!WorldUtil.registerPlanet(body.getDimensionID(), body.getReachable(), 0))
                body.setUnreachable();
        }
    }

    RecipeManagerGC.setConfigurableRecipes();
}

@EventHandler
public void         serverLoad(FMLServerStartingEvent event)
{
event.registerServerCommand(new Command());
  MinecraftForge.EVENT_BUS.register(new ForgeEventHooksHandler());
    CommandLoader.load(event);
}

@Mod.EventHandler
public void serverLoading(FMLServerStartingEvent event) {
    logger.info("Registering commands.");
    event.registerServerCommand(new CreateIslandsCommand());
    event.registerServerCommand(new DeleteIslandCommand());
    event.registerServerCommand(new JoinIslandCommand());
    event.registerServerCommand(new ListIslandsCommand());
    event.registerServerCommand(new RenameIslandCommand());
    event.registerServerCommand(new SaveIslandsCommand());
    event.registerServerCommand(new SetIslandSpawnCommand());
    logger.info("Finished registering commands.");
    loadIslands();
    loadChestLoot();
}

@EventHandler
public void serverStarting(FMLServerStartingEvent event)
{
    ICommandManager commandManager = MinecraftServer.getServer().getCommandManager();
    ServerCommandManager serverCommandManager = ((ServerCommandManager) commandManager);
    addCommands(serverCommandManager);
}

@EventHandler
public void serverStart(FMLServerStartingEvent event)
{
     MinecraftServer server = MinecraftServer.getServer();
     // Get's the current server instance

     ICommandManager command = server.getCommandManager();
     ServerCommandManager manager = (ServerCommandManager) command;

     //manager.registerCommand(new CommandModInfo());
     manager.registerCommand(new CommandChangelog());
     manager.registerCommand(new CommandAbilities());
}

@Mod.EventHandler
public void serverStart(FMLServerStartingEvent e)
{
    MinecraftServer server = getServer();
    ICommandManager iCommandManager = server.getCommandManager();
    ServerCommandManager serverCommandManager = (ServerCommandManager)iCommandManager;

    serverCommandManager.registerCommand(new CommandHandler());
}

@Override
public void serverLoad(final FMLServerStartingEvent event) {
    super.serverLoad(event);
    RootCommand.INSTANCE.addChildCommand(new CommandAuth());
    final Boolean bool = (Boolean) Launch.blackboard.get("fml.deobfuscatedEnvironment");
    if (bool)
        RootCommand.INSTANCE.addChildCommand(new CommandDebug());
}

@SuppressWarnings("javadoc")
@EventHandler
public static final void addCommandsToServer(FMLServerStartingEvent evt) {
    echo("Loading server commands");
    for (CommandBase command : commands) {
        evt.registerServerCommand(command);
        debug("Command registered to server: " + command.getCommandName());
    }
}

@EventHandler
public void serverStart(FMLServerStartingEvent event)
{
    //Thread.currentThread().setName("EpicProportionsMod");
     MinecraftServer server = MinecraftServer.getServer();
     // Get's the current server instance

     ICommandManager command = server.getCommandManager();
     ServerCommandManager manager = (ServerCommandManager) command;

     manager.registerCommand(new CommandModInfo());
     manager.registerCommand(new CommandChangelog());
}

@EventHandler
public void serverLoad(FMLServerStartingEvent event)
{
    // register server commands

event.registerServerCommand(new CommandModInfo());
}

@Mod.EventHandler
@SuppressWarnings("unused")
public void serverStarting(FMLServerStartingEvent event) {
    event.registerServerCommand(new ExclusiveDeleteBlock());
    event.registerServerCommand(new Createsphere());

}

public void serverInit( FMLServerStartingEvent event )
  {
if( Config.LimitedBlocks.isEnabled )
{
    event.registerServerCommand( new LimitedResourcesCommand( Config.Commands.shortAlias ) );
}
  }

public void serverStarting(final FMLServerStartingEvent event) {
    if (ModOptions.getCommandTeleportEnable())
        event.registerServerCommand(new TeleportCommand());

    if (ModOptions.getCommandConfigureEnable())
        event.registerServerCommand(new ConfigureCommand());
}

@EventHandler
public void serverStart(FMLServerStartingEvent event) {
    MinecraftServer mcserver = event.getServer();
    // Register commands
    ((ServerCommandManager) mcserver.getCommandManager()).registerCommand(new CommandCreateView());
    // Start up the packet dispatcher we use for throttled data to client.
    ServerPacketDispatcher.getInstance().start(); //Note: This might need to be preceded by a force init of the ServerPacketDispatcher.  Doesn't seem to currently have any issues, though.
}

@EventHandler
public void serverLoad(FMLServerStartingEvent event) {
    // Register our commands
    if (ModOptions.getEnableCommands()) {
        ModLog.info("Registering command handlers");
        CommandHelper.registerCommands(event);
    } else {
        ModLog.info("Not registering command handlers");
    }
}

@EventHandler
public void serverInit(FMLServerStartingEvent event){
    event.registerServerCommand(new PreGenCommand());
    if(ConfigChunkPreGen.x != null && ConfigChunkPreGen.z != null && ConfigChunkPreGen.height != null && ConfigChunkPreGen.width != null && ConfigChunkPreGen.height > 0 && ConfigChunkPreGen.width > 0) {
        ChunkGenUtils.generateChunks(ConfigChunkPreGen.x, ConfigChunkPreGen.z, ConfigChunkPreGen.width, ConfigChunkPreGen.height, 0);
    }
}

public NetworkManager(FMLServerStartingEvent event) {
    server = event.getServer();

    portalCoords = new BidiMap<String, WorldPos>();
    portalNetwrks = new BidiArrayMap<String, String>();

    portalFile = new File(EnhancedPortals.proxy.getWorldDir(), "EP3_PortalLocations.json");
    networkFile = new File(EnhancedPortals.proxy.getWorldDir(), "EP3_PortalNetworks.json");

    try {
        loadAllData();
    } catch (Exception e) {
        EnhancedPortals.instance.getLogger().catching(e);
    }
}

@EventHandler
public void serverLoad(FMLServerStartingEvent evt) {
    Debug.mark();
    evt.registerServerCommand(new CommandEditBlacklist());
    if(FMLCommonHandler.instance().getEffectiveSide() == Side.CLIENT) {
        SafeDraw.init();
    }
}

@EventHandler
public void serverLoad(FMLServerStartingEvent event) {
    ServerCommandManager manager = (ServerCommandManager) event.getServer().getCommandManager();
    manager.registerCommand(new BfsrSpawnCommand());
    manager.registerCommand(new BfsrGotoNurseryCommand());
    manager.registerCommand(new BfsrRegenTutorialDimension());
    manager.registerCommand(new BfsrTeleportCommand());
}

@EventHandler
public void serverLoad(FMLServerStartingEvent event)
{
  event.registerServerCommand(new CRModListForgePersistentChunks());
  event.registerServerCommand(new CRModListLoadedChunks());
  event.registerServerCommand(new CRModToggleInfoLogging());
}