Java 类net.minecraftforge.client.ClientCommandHandler 实例源码

/**
 * Needs to be instantiated somewhere in your mod's loading stage.
 */
public IGWSupportNotifier() {
    if (FMLCommonHandler.instance().getSide() == Side.CLIENT && !Loader.isModLoaded("IGWMod")) {
        File dir = new File(".", "config");
        Configuration config = new Configuration(new File(dir, "IGWMod.cfg"));
        config.load();

        if (config.get(Configuration.CATEGORY_GENERAL, "enable_missing_notification", true, "When enabled, this will notify players when IGW-Mod is not installed even though mods add support.").getBoolean()) {
            ModContainer mc = Loader.instance().activeModContainer();
            String modid = mc.getModId();
            List<ModContainer> loadedMods = Loader.instance().getActiveModList();
            for (ModContainer container : loadedMods) {
                if (container.getModId().equals(modid)) {
                    supportingMod = container.getName();
                    MinecraftForge.EVENT_BUS.register(this);
                    ClientCommandHandler.instance.registerCommand(new CommandDownloadIGW());
                    break;
                }
            }
        }
        config.save();
    }
}

@Mod.EventHandler
public void postInit(FMLPostInitializationEvent e)
{
    ClientCommandHandler.instance.registerCommand(new CommandChat());
    ClientCommandHandler.instance.registerCommand(new CommandSwitchChannel());
    ClientCommandHandler.instance.registerCommand(new CommandBlock());
    ClientCommandHandler.instance.registerCommand(new CommandUnblock());
    ClientCommandHandler.instance.registerCommand(new CommandAddFriend());
    ClientCommandHandler.instance.registerCommand(new CommandDeleteFriend());
    ClientCommandHandler.instance.registerCommand(new CommandFocus());
    ClientCommandHandler.instance.registerCommand(new CommandDM());

    ClientRegistry.registerKeyBinding(test = new KeyBinding("Open DiscordCE menu", Keyboard.KEY_Y, "DiscordCE"));

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

    // Tracking game start
    MixpanelUtil.setStartGameEvent(true);
}

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

  for (IConfigHandler c : configs) {
    c.initHook();
  }

  Handlers.register(event);
  CompatRegistry.INSTANCE.handle(event);
  ClientCommandHandler.instance.registerCommand(CommandReloadConfigs.CLIENT);
  if (event.getSide().isServer()) {
    ((CommandHandler) MinecraftServer.getServer().getCommandManager()).registerCommand(CommandReloadConfigs.SERVER);
  }

  IMCRegistry.INSTANCE.init();
}

@Override
public <T extends FMLStateEvent> boolean applyStateEventPatch(T event) {
    Field instance = ReflectionHelper.getField(ObfuscatedField.ClientCommandHandler_instance);
    Field modifiers = ReflectionHelper.getField(ObfuscatedField.Field_modifiers);

    try {
        modifiers.setInt(instance, instance.getModifiers() & ~Modifier.FINAL);
        instance.set(null, new ClientCommandManager((ClientCommandHandler) instance.get(null)));

        PatchManager.instance().getGlobalAppliedPatches().setPatchSuccessfullyApplied(this.displayName, true);
        return true;
    }
    catch (Exception ex)  {
        PatchManager.instance().getGlobalAppliedPatches().setPatchSuccessfullyApplied(this.displayName, false);
        return false;
    }
}

private void grabVarAndBlock(String command) {
    command = command.substring("var grab ".length() + (command.startsWith("/") ? 1 : 0));
    this.variable = command.split(" ")[0]; command = command.substring(this.variable.length()).trim();

    if (!isSenderOfEntityType(sender.getMinecraftISender(), com.mrnobody.morecommands.patch.PatchEntityPlayerSP.EntityPlayerSP.class))
        this.sender.sendLangfileMessage("command.generic.clientPlayerNotPatched", TextFormatting.RED);

    if (command.startsWith("macro") || command.startsWith("/macro"))
        this.sender.sendLangfileMessage("command.var.grabMacro", TextFormatting.RED);

    com.mrnobody.morecommands.patch.PatchEntityPlayerSP.EntityPlayerSP patchedPlayer = getSenderAsEntity(this.sender.getMinecraftISender(), com.mrnobody.morecommands.patch.PatchEntityPlayerSP.EntityPlayerSP.class);
    patchedPlayer.setCaptureNextCommandResult();

    if (ClientCommandHandler.instance.executeCommand(patchedPlayer, command) != 0) {
        if (patchedPlayer.getCmdSentToServer() != null) {
                String cmdSentToServer = patchedPlayer.getCmdSentToServer();
                patchedPlayer.getCapturedCommandResult(); //reset
                PacketHandlerClient.addPendingRemoteCommand(cmdSentToServer, this);
        }
        else setCommandResult(patchedPlayer.getCapturedCommandResult());
    }
    else {
        patchedPlayer.getCapturedCommandResult(); //reset
        PacketHandlerClient.addPendingRemoteCommand(command, this);
    }
}

/**
 * Registers all client commands
 * 
 * @return Whether the client commands were registered successfully
 */
private void registerClientCommands() throws Exception {
    List<Class<? extends StandardCommand>> clientCommands = this.mod.getClientCommandClasses();
    if (clientCommands == null) throw new RuntimeException("Client Command Classes not loaded");

    for (Class<? extends StandardCommand> cmdClass : clientCommands) {
        try {
            StandardCommand cmd = cmdClass.newInstance();

            if (cmd instanceof MultipleCommands) {
                Constructor<? extends StandardCommand> ctr = cmdClass.getConstructor(int.class);

                for (int i = 0; i < ((MultipleCommands) cmd).getCommandNames().length; i++)
                    if (this.mod.isCommandEnabled(((MultipleCommands) cmd).getCommandNames()[i]))
                        ClientCommandHandler.instance.registerCommand(new ClientCommand(ClientCommand.upcast(ctr.newInstance(i))));
            }
            else if (this.mod.isCommandEnabled(cmd.getCommandName()))
                ClientCommandHandler.instance.registerCommand(new ClientCommand(ClientCommand.upcast(cmd)));
        }
        catch (Exception ex) {
            this.mod.getLogger().warn("Skipping Client Command " + cmdClass.getName() + " due to the following exception during loading", ex);
        }
    }
}

@Override
public void preInit(FMLPreInitializationEvent event)
{
    // try stuff
    ClientCommandHandler.instance.registerCommand(new CommandCelestialBodyInfo());

    /*GalacticraftPlanets.clientModules.put(GalacticraftPlanets.MODULE_KEY_MARS, new MarsModuleClient());
    GalacticraftPlanets.clientModules.put(GalacticraftPlanets.MODULE_KEY_ASTEROIDS, new AsteroidsModuleClient());

    super.preInit(event);

    for (IPlanetsModuleClient module : GalacticraftPlanets.clientModules.values())
    {
        module.preInit(event);
    }*/
}

@EventHandler
@SuppressWarnings("unused")
public void preinit(FMLPreInitializationEvent event) {

    if (event.getSide() == Side.CLIENT) {


        ClientCommandHandler.instance.registerCommand(new CommandToggle());

        try {
            Class.forName("voce.Utils");//Let's see if we have our libraries, hopefully gradle has this shit covered :D
        } catch (ClassNotFoundException e) {
            //voce isn't around, DOWNLOAD ALL THE LIBS!
            downloadLib("http://www.creeperrepo.net/ci/ModJam4-CreeperHost/libs/cmulex.jar");
            downloadLib("http://www.creeperrepo.net/ci/ModJam4-CreeperHost/libs/en_us.jar");
            downloadLib("http://www.creeperrepo.net/ci/ModJam4-CreeperHost/libs/freetts.jar");
            downloadLib("http://www.creeperrepo.net/ci/ModJam4-CreeperHost/libs/jsapi.jar");
            downloadLib("http://www.creeperrepo.net/ci/ModJam4-CreeperHost/libs/sphinx4.jar");
            downloadLib("http://www.creeperrepo.net/ci/ModJam4-CreeperHost/libs/voce.jar");
            downloadLib("http://www.creeperrepo.net/ci/ModJam4-CreeperHost/libs/cmu_us_kal.jar");
            downloadLib("http://www.creeperrepo.net/ci/ModJam4-CreeperHost/libs/WSJ_8gau_13dCep_16k_40mel_130Hz_6800Hz.jar");
        }
    }
    ModItems.init();
}

@Mod.EventHandler
public void init(FMLInitializationEvent event) {
    WizardryRegistry.initCrafting();
    WizardryRegistry.registerDustInfusion();
    proxy.registerTESRs();

    if (event.getSide() == Side.CLIENT) {
        //client commands
        ClientCommandHandler.instance.registerCommand(new CommandExportPattern());
        proxy.registerColors();
    }
    if(ConfigHandler.registerTestRunes){
        DustRegistry.registerRune(new RuneTesting(),"runetesting");
        DustRegistry.registerRune(new RuneTest2(),"runeTest2");
        DustRegistry.registerRune(new RuneStarBeam(), "runeStarbeam");
    }
    if(!ConfigHandler.disableInscriptionCharge){
        DustRegistry.registerRune(new RuneChargeInscription(), "runeChargeInscription");
    }
    if(ConfigHandler.registerTestRunes){
        DustRegistry.registerInscription(new InscriptionTest(), "inscriptiontest");
    }
    initNetwork();
    // the GUI handler
    NetworkRegistry.INSTANCE.registerGuiHandler(RunesOfWizardry.instance,new GuiHandler());
}

/**
 * Needs to be instantiated somewhere in your mod's loading stage.
 */
public IGWSupportNotifier(){
    if(FMLCommonHandler.instance().getSide() == Side.CLIENT && !Loader.isModLoaded("IGWMod")) {
        File dir = new File(".", "config");
        Configuration config = new Configuration(new File(dir, "IGWMod.cfg"));
        config.load();

        if(config.get(Configuration.CATEGORY_GENERAL, "enable_missing_notification", true, "When enabled, this will notify players when IGW-Mod is not installed even though mods add support.").getBoolean()) {
            ModContainer mc = Loader.instance().activeModContainer();
            String modid = mc.getModId();
            List<ModContainer> loadedMods = Loader.instance().getActiveModList();
            for(ModContainer container : loadedMods) {
                if(container.getModId().equals(modid)) {
                    supportingMod = container.getName();
                    MinecraftForge.EVENT_BUS.register(this);
                    ClientCommandHandler.instance.registerCommand(new CommandDownloadIGW());
                    break;
                }
            }
        }
        config.save();
    }
}

@Mod.EventHandler
public void init(FMLInitializationEvent event) throws MalformedURLException
{
    ServerTickHandler.INSTANCE.init();

    TypeRegistry.doConfig(config.configuration);
    config.save();

    rewardsDB = new RewardsDB(getRewardDBFile());

    if (event.getSide().isClient())
    {
        CheckerHandler.init();
        new EventHandler();
        ClientCommandHandler.instance.registerCommand(new CommandP2S());
        DevCapes.getInstance().addGroup(Constants.MODID, Constants.CAPEURL);
    }

    ClientTickHandler.INSTANCE.init();
    ConnectionHandler.INSTANCE.init();
}

private static void initialise() {
    updateMap = new HashMap<String, UpdateEntry>();
    /*
     * The time between update checks in minutes.
     * A value <=0 will only run the updater when a player joins the world.
     */
    int Timer = 60*60*20;
    try{
     config = new Configuration(new File(Loader.instance().getConfigDir(), "MUD.cfg"));
     Timer = config.get(Configuration.CATEGORY_GENERAL, "Update Time", 60, "The time in minutes between update checks").getInt() * 60 * 20;
        check = config.get(Configuration.CATEGORY_GENERAL, "Update Check Enabled", true, "Should MUD automatically check for updates");
     verbose = config.getBoolean("Chat stats", Configuration.CATEGORY_GENERAL, false, "Should MUD print in chat its status");
        enabled = check.getBoolean();
        deleteOld = config.getBoolean("Remove old file", Configuration.CATEGORY_GENERAL, true, "Should MUD try to remove old file when download is complete");
        deleteFailed = config.getBoolean("Remove failed download", Configuration.CATEGORY_GENERAL, true, "Should MUD try to remove the new file created if download is failed");
     if(config.hasChanged()){
         config.save();
     }
    }catch(Exception handled){
        handled.printStackTrace();
    }
    Object listener = new ModUpdateDetectorTickHandeler(Timer);
    MinecraftForge.EVENT_BUS.register(listener);
    ClientCommandHandler.instance.registerCommand(new MudCommands());
}

/**
 * Needs to be instantiated somewhere in your mod's loading stage.
 */
public IGWSupportNotifier(){
    if(FMLCommonHandler.instance().getSide() == Side.CLIENT && !Loader.isModLoaded("IGWMod")) {
        File dir = new File(".", "config");
        Configuration config = new Configuration(new File(dir, "IGWMod.cfg"));
        config.load();

        if(config.get(Configuration.CATEGORY_GENERAL, "enable_missing_notification", true, "When enabled, this will notify players when IGW-Mod is not installed even though mods add support.").getBoolean()) {
            ModContainer mc = Loader.instance().activeModContainer();
            String modid = mc.getModId();
            List<ModContainer> loadedMods = Loader.instance().getActiveModList();
            for(ModContainer container : loadedMods) {
                if(container.getModId().equals(modid)) {
                    supportingMod = container.getName();
                    FMLCommonHandler.instance().bus().register(this);
                    ClientCommandHandler.instance.registerCommand(new CommandDownloadIGW());
                    break;
                }
            }
        }
        config.save();
    }
}

/**
 * Needs to be instantiated somewhere in your mod's loading stage.
 */
public IGWSupportNotifier(){
    if(FMLCommonHandler.instance().getSide() == Side.CLIENT && !Loader.isModLoaded("IGWMod")) {
        File dir = new File(".", "config");
        Configuration config = new Configuration(new File(dir, "IGWMod.cfg"));
        config.load();

        if(config.get(Configuration.CATEGORY_GENERAL, "enable_missing_notification", true, "When enabled, this will notify players when IGW-Mod is not installed even though mods add support.").getBoolean()) {
            ModContainer mc = Loader.instance().activeModContainer();
            String modid = mc.getModId();
            List<ModContainer> loadedMods = Loader.instance().getActiveModList();
            for(ModContainer container : loadedMods) {
                if(container.getModId().equals(modid)) {
                    supportingMod = container.getName();
                    MinecraftForge.EVENT_BUS.register(this);
                    ClientCommandHandler.instance.registerCommand(new CommandDownloadIGW());
                    break;
                }
            }
        }
        config.save();
    }
}

@EventHandler
   public void init(FMLInitializationEvent event) {
    MinecraftForge.EVENT_BUS.register(this);
    ClientCommandHandler.instance.registerCommand(new RenderPlayer());

    File file = new File("config/renderplayermod.txt");
    if(!file.exists()) {
        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

@Mod.EventHandler
public void init(FMLInitializationEvent event) {
    MessageParser.remake();
    ClientCommandHandler.instance.registerCommand(new TextCommand());
    MinecraftForge.EVENT_BUS.register(events = new TextEvents());

    Minecraft.getMinecraft().addScheduledTask(() -> {
        websiteUtils.begin();
        loader.begin();
    });
}

@Override
public void registerClientCommands() {
    if (XUHelper.deObf || XUHelper.isTema(Minecraft.getMinecraft().getSession().func_148256_e())) {
        ClientCommandHandler.instance.registerCommand((ICommand)new CommandDumpNEIInfo());
        ClientCommandHandler.instance.registerCommand((ICommand)new CommandDumpNEIInfo2());
        ClientCommandHandler.instance.registerCommand((ICommand)new CommandDumpTextureSheet());
    }
    ClientCommandHandler.instance.registerCommand((ICommand)CommandTPSTimer.INSTANCE);
}

@Override
public void registerEventHandler() {
    MinecraftForge.EVENT_BUS.register((Object)new EventHandlerClient());
    FMLCommonHandler.instance().bus().register((Object)new EventHandlerClient());
    ((IReloadableResourceManager)Minecraft.getMinecraft().getResourceManager()).registerReloadListener((IResourceManagerReloadListener)new LiquidColorRegistry());
    ((IReloadableResourceManager)Minecraft.getMinecraft().getResourceManager()).registerReloadListener((IResourceManagerReloadListener)new ParticleHelperClient());
    ExtraUtils.handlesClientMethods = true;
    if (Loader.isModLoaded("ForgeMultipart")) {
        RenderBlockConnectedTextures.fakeRender = new FakeRenderBlocksMultiPart();
    }
    ClientCommandHandler.instance.registerCommand((ICommand)new CommandHologram());
    ClientCommandHandler.instance.registerCommand((ICommand)new CommandUUID());
    KeyHandler.INSTANCE.register();
    super.registerEventHandler();
}

@Override
public void init(final @Nonnull FMLInitializationEvent event) {
    super.init(event);

    // Replace Sign Renderer
    ClientRegistry.bindTileEntitySpecialRenderer(TileEntitySign.class, Client.renderer);
    MinecraftForgeClient.registerItemRenderer(Items.sign, new CustomItemSignRenderer());

    // Event Register
    Client.handler.init();
    ClientCommandHandler.instance.registerCommand(Client.rootCommand);
}

@Mod.EventHandler
public void onLoad(FMLInitializationEvent event) {
    //new PlayerMonitor(); //Because that receives TickEvent. Should be off for now so that we could save cpu a bit
    ClientCommandHandler.instance.registerCommand(new Command());

    t = new Thread(new BiliLiveMonitor(Integer.toString(ModSettings.liveRoom)));
    t.start();
}

@Override
public void init(@Nonnull final FMLInitializationEvent event) {
    super.init(event);

    KeyHandler.init();
    ParticleDripOverride.register();

    ClientCommandHandler.instance.registerCommand(new CommandCalc());

    if(ModOptions.disableWaterSuspendParticle)
        Minecraft.getMinecraft().effectRenderer.registerParticle(EnumParticleTypes.SUSPENDED.getParticleID(), null);
}

/**
 * Subscribe all event listeners to EVENT_BUS and attach any client-side
 * commands to the ClientCommandRegistry.
 */
@Override
public void load(FMLInitializationEvent event)
{
    Minecraft mc = Minecraft.getMinecraft();

    recordingOverlay = new GuiRecordingOverlay(mc);
    actorRenderer = new RenderCustomActor(mc.getRenderManager(), null, 0);

    super.load(event);

    /* Event listeners */
    MinecraftForge.EVENT_BUS.register(new MainMenuHandler());
    MinecraftForge.EVENT_BUS.register(new FrameHandler());
    MinecraftForge.EVENT_BUS.register(keys = new KeyboardHandler());
    MinecraftForge.EVENT_BUS.register(new RenderingHandler(recordingOverlay));

    if (CameraHandler.isApertureLoaded())
    {
        CameraHandler.register();
    }

    /* Client commands */
    ClientCommandHandler.instance.registerCommand(new CommandModel());
    ClientCommandHandler.instance.registerCommand(new CommandLoadChunks());

    /* Metamorph morph builder panel */
    GuiMorphBuilder.BUILDERS.put("blockbuster", new GuiCustomModelMorphBuilder());
}

@Override
public void preInit() {
    super.preInit();

    OpenGLUtils.loadCaps();
    CustomParticleHandler.init();
    CCBlockStateLoader.initialize();
    ModelBakery.init();
    CCRenderEventHandler.init();

    MinecraftForge.EVENT_BUS.register(new TextureUtils());
    MinecraftForge.EVENT_BUS.register(new MapRenderRegistry());
    MinecraftForge.EVENT_BUS.register(new ModelRegistryHelper());

    ModelLoaderRegistry.registerLoader(CCCubeLoader.INSTANCE);
    ModelLoaderRegistry.registerLoader(CCBakeryModelLoader.INSTANCE);

    PacketCustom.assignHandler(PacketDispatcher.NET_CHANNEL, new ClientPacketHandler());

    ClientCommandHandler.instance.registerCommand(new DumpModelLocationsCommand());
    ClientCommandHandler.instance.registerCommand(new NukeCCModelCacheCommand());
    ClientCommandHandler.instance.registerCommand(new DumpItemInfoCommand());

    RenderingRegistry.registerEntityRenderingHandler(DummyEntity.class, manager -> {
        sanitizeEntityRenderers(manager);
        return new Render<DummyEntity>(manager) {
            @Override
            protected ResourceLocation getEntityTexture(DummyEntity entity) {
                return null;
            }
        };
    });
}

@Override
public void init() {
    MinecraftForge.EVENT_BUS.register(new KeyInputHandler());
    MinecraftForge.EVENT_BUS.register(new EventHandlerClient());
    ClientCommandHandler.instance.registerCommand(new CommandProfiler());
    if (CoreInit.isDebugging)
        ClientCommandHandler.instance.registerCommand(new CommandJEI());
}

@Override
void initializeClient() {
    Core.loadBus(this);
    ClientCommandHandler.instance.registerCommand(new MiscClientCommands());
    Core.loadBus(cth);
    new NeptuneCape();

    GameSettings gameSettings = Minecraft.getMinecraft().gameSettings;
    gameSettings.setOptionValue(GameSettings.Options.REALMS_NOTIFICATIONS, 0);
}

@Override
public void init(final FMLInitializationEvent event) {
    super.init(event);

    MinecraftForge.EVENT_BUS.register(ConfigurationHandler.INSTANCE);
    MinecraftForge.EVENT_BUS.register(TraceHandler.INSTANCE);
    MinecraftForge.EVENT_BUS.register(TraceRenderer.INSTANCE);
    ClientCommandHandler.instance.registerCommand(new CommandTracer());
}

/**
 * Replaces client side variables and then sends the message to the server
 * (if it is not a client side command)
 */
private static void processChat(Minecraft mc, String chat, boolean addToChat) {
    if (addToChat) mc.ingameGUI.getChatGUI().addToSentMessages(chat);

    if (MoreCommandsConfig.enablePlayerVars) {
        ClientPlayerSettings settings = mc.player.getCapability(PlayerSettings.SETTINGS_CAP_CLIENT, null);

        if (settings != null) {
            boolean replaceIgnored;
            AppliedPatches patches = PatchManager.instance().getGlobalAppliedPatches();

            if (chat.length() > 1 && chat.charAt(0) == '%') {
                int end = chat.indexOf('%', 1);
                String val = end > 0 ? settings.variables.get(chat.substring(1, end)) : null;

                replaceIgnored = val != null && val.startsWith("/") &&
                                (chat.length() - 1 == end || chat.charAt(end + 1) == ' ') &&
                                ClientCommandHandler.instance.getCommands().containsKey(val.substring(1)) 
                        ? false : !patches.wasPatchSuccessfullyApplied(PatchList.SERVER_MODDED);
            }
            else replaceIgnored = chat.startsWith("/") && ClientCommandHandler.instance.getCommands().containsKey(chat.substring(1).split(" ")[0]) ?
                                    false : !patches.wasPatchSuccessfullyApplied(PatchList.SERVER_MODDED);

            try {chat = Variables.replaceVars(chat, replaceIgnored, settings.variables);}
            catch (Variables.VariablesCouldNotBeResolvedException e) {chat = e.getNewString();}
        }
    }

    if (chat.trim().startsWith("/") && ClientCommandHandler.instance.executeCommand(mc.player, chat) != 0) return;
    else mc.player.sendChatMessage(chat);
}

/**
 * Runs a thread waiting for a handshake from the server <br>
 * to execute startup commands. If it isn't received after a <br>
 * certain time, they are executed nevertheless
 */
public static void runStartupCommandsThread() {
    final int timeout = MoreCommandsConfig.startupTimeout < 0 ? 10000 : MoreCommandsConfig.startupTimeout > 10 ? 10000 : MoreCommandsConfig.startupTimeout * 1000;

    new Thread(new Runnable() {
        @Override
        public void run() { 
            long t = System.currentTimeMillis() + timeout;
            boolean added = false;
            AppliedPatches appliedPatches = PatchManager.instance().getGlobalAppliedPatches();

            while (t > System.currentTimeMillis()) {
                if (!added && appliedPatches.wasPatchSuccessfullyApplied(PatchList.SERVER_MODDED)) {
                    t = System.currentTimeMillis() + timeout; added = true;
                }

                if (appliedPatches.wasPatchSuccessfullyApplied(PatchList.HANDSHAKE_FINISHED)) break;
            }

            if (Minecraft.getMinecraft().player == null) return;
            notifyPlayerAboutUpdate();

            try {Thread.sleep(MoreCommandsConfig.startupDelay * 1000);}
            catch (InterruptedException ex) {}

            for (String command : ClientPlayerSettings.getInstance(Minecraft.getMinecraft().player).startupCommands) {
                if (ClientCommandHandler.instance.executeCommand(Minecraft.getMinecraft().player, command) == 0)
                    Minecraft.getMinecraft().player.sendChatMessage(command.startsWith("/") ? command : "/" + command);
                MoreCommands.INSTANCE.getLogger().info("Executed startup command '" + command + "'");
            }
        }
    }, "MoreCommands Startup Commands Thread (Client)").start();
}

/**
 * Is called if the client receives a handshake packet
 * @param version the server's MorCommands version
 */
public void handshake(String version) {
    if (!Reference.VERSION.equals(version)) {
        MoreCommands.INSTANCE.getLogger().warn("Server has incompatible MoreCommands version: " + version + ", version " + Reference.VERSION + " is required");
        return;
    }

    PatchManager.instance().getGlobalAppliedPatches().setPatchSuccessfullyApplied(PatchList.SERVER_MODDED, true);

    //Remove commands, which shall be removed if the server side version shall be used
    List<String> remove = new ArrayList<String>();
    for (Object command : ClientCommandHandler.instance.getCommands().keySet()) {
        if (ClientCommandHandler.instance.getCommands().get((String) command) instanceof ClientCommand<?>) {
            ClientCommand<?> cmd = (ClientCommand<?>) ClientCommandHandler.instance.getCommands().get((String) command);
            if (!cmd.registerIfServerModded()) {remove.add(cmd.getCommandName()); PacketHandlerClient.removedCmds.add(cmd);}
        }
    }

    if (!remove.isEmpty()) {
        for (String rem : remove)
            ClientCommandHandler.instance.getCommands().remove(rem);

        MoreCommands.INSTANCE.getLogger().info("Unregistered following client commands because server side versions are used:\n" + remove);
    }

    //Let the server know that the mod is installed client side
    MoreCommands.INSTANCE.getLogger().info("Sending client handshake");
    MoreCommands.INSTANCE.getPacketDispatcher().sendC00Handshake(
            PatchManager.instance().getGlobalAppliedPatches().wasPatchSuccessfullyApplied(PatchList.PATCH_ENTITYPLAYERSP),
            PatchManager.instance().getGlobalAppliedPatches().wasPatchSuccessfullyApplied(PatchList.PATCH_RENDERGLOBAL));
}

@Override
public String execute(CommandSender sender, String[] params) throws CommandException {
    if (params.length > 1) {
        if (params[0].equalsIgnoreCase("enable")) {
            ICommand enable = this.disabledCommands.get(params[1]);

            if (enable == null && PatchManager.instance().getGlobalAppliedPatches().wasPatchSuccessfullyApplied(PatchList.SERVER_MODDED))
                Minecraft.getMinecraft().player.sendChatMessage("/command enable " + params[1]);
            else if (enable != null) {
                ClientCommandHandler.instance.registerCommand(enable);
                this.disabledCommands.remove(params[1]);
                sender.sendLangfileMessage("command.command.enabled");
            }
            else throw new CommandException("command.command.serverNotModded", sender);
        }
        else if (params[0].equalsIgnoreCase("disable")) {
            if (params[1].equals(this.getCommandName())) throw new CommandException("command.command.wantedToDisable", sender);

            ICommand disable = (ICommand) ClientCommandHandler.instance.getCommands().get(params[1]);

            if (disable == null && PatchManager.instance().getGlobalAppliedPatches().wasPatchSuccessfullyApplied(PatchList.SERVER_MODDED))
                Minecraft.getMinecraft().player.sendChatMessage("/command disable " + params[1]);
            else if (disable != null) {
                this.disabledCommands.put(disable.getName(), disable);
                ClientCommandHandler.instance.getCommands().remove(params[1]);
                sender.sendLangfileMessage("command.command.disabled");
            }
            else throw new CommandException("command.command.serverNotModded", sender);
        }
        else throw new CommandException("command.generic.invalidUsage", sender, this.getCommandName());
    }
    else throw new CommandException("command.generic.invalidUsage", sender, this.getCommandName());

    return null;
}

public void continueExecution() {
    for (; this.execIdx < this.commands.size(); this.execIdx++) {
        if (this.commands.get(this.execIdx).startsWith("/var grab ") || this.commands.get(this.execIdx).startsWith("var grab")) {
            grabVarAndBlock(this.commands.get(this.execIdx++));
            break;
        }
        else {
            String command = this.commands.get(this.execIdx);

            if (ClientCommandHandler.instance.executeCommand(Minecraft.getMinecraft().player, command) == 0)
                Minecraft.getMinecraft().player.sendChatMessage(command.startsWith("/") ? command : "/" + command);
        }
    }
}

private void enableClientCommands() {
    for (ClientCommand command : this.clientCommands.values()) 
        if (command.getDelegate() != this) ClientCommandHandler.instance.registerCommand(command);

    this.clientCommands.clear();
    enabled = ClientCommand.clientCommandsEnabled = true;
}

private void disableClientCommands() {
    if (this.clientCommands.size() != 0) return;
    this.clientCommands.clear();

    for (Map.Entry<String, ICommand> entry : (Set<Map.Entry<String, ICommand>>) ClientCommandHandler.instance.getCommands().entrySet())
        if (entry.getValue() instanceof ClientCommand<?> && ((ClientCommand<?>) entry.getValue()).getDelegate() != this)
            this.clientCommands.put(entry.getKey(), (ClientCommand<?>) entry.getValue());

    for (String command : this.clientCommands.keySet()) 
        ClientCommandHandler.instance.getCommands().remove(command);

    enabled = ClientCommand.clientCommandsEnabled = false;
}

@Override
public void preInit(FMLPreInitializationEvent event) {
    super.preInit(event);

    FMLCommonHandler.instance().bus().register(new ClientTickHandler());
    MinecraftForge.EVENT_BUS.register(new ClientEventHandler());

    ClientCommandHandler.instance.registerCommand(new CommandCinematic());

    MinecraftForge.EVENT_BUS.register(SoundHandler.INSTANCE);
    FMLCommonHandler.instance().bus().register(SoundHandler.INSTANCE);
}

@Override
public void postInitClientSide() {
    FMLCommonHandler.instance().bus().register(new ClientPlayerTickEventHandler());
    ClientCommandHandler.instance.registerCommand(new RenderTweakCommand());

    ClientPlayerTickEventHandler.hideStuffFromNEI = Loader.isModLoaded("NotEnoughItems");
}

@Override
public boolean onClicked() {
    EntityPlayerSP player = Minecraft.getMinecraft().player;
    String parsedCommand = command.replace("@p", player.getName());

    if (ClientCommandHandler.instance.executeCommand(player, parsedCommand) == 0) {
        if (clipboard) {
            GuiConfirmOpenLink.setClipboardString(parsedCommand);
            player.sendStatusMessage(new TextComponentString("Command copied to clipboard"), true);
        } else {
            player.sendChatMessage(parsedCommand);
        }
    }
    return false;
}

@Override
public void register() {
    registerRenderers();
    startFileInit();

    ClientCommandHandler.instance.registerCommand(new QAClientCommand());
}

@SideOnly(Side.CLIENT)
@Mod.EventHandler
public void init(@SuppressWarnings("UnusedParameters") FMLInitializationEvent event) {
    FMLInterModComms.sendMessage("Waila", "register", "me.exz.wailanbt.handler.BlockHandler.callbackRegister");
    FMLInterModComms.sendMessage("Waila", "register", "me.exz.wailanbt.handler.EntityHandler.callbackRegister");
    ClientCommandHandler.instance.registerCommand(new CommandReload());
    ClientCommandHandler.instance.registerCommand(new CommandName());
    ClientCommandHandler.instance.registerCommand(new CommandEntity());
    MinecraftForge.EVENT_BUS.register(new ConfigEvent());
}

private void func_73893_a(String par1Str, String par2Str)
{
    if (par1Str.length() >= 1)
    {
        ClientCommandHandler.instance.autoComplete(par1Str, par2Str);
        this.mc.thePlayer.sendQueue.addToSendQueue(new Packet203AutoComplete(par1Str));
        this.field_73905_m = true;
    }
}

public void func_73894_a(String[] par1ArrayOfStr)
{
    if (this.field_73905_m)
    {
        this.field_73904_o.clear();
        String[] astring1 = par1ArrayOfStr;
        int i = par1ArrayOfStr.length;

        String[] complete = ClientCommandHandler.instance.latestAutoComplete;
        if (complete != null)
        {
            astring1 = ObjectArrays.concat(complete, astring1, String.class);
            i = astring1.length;
        }

        for (int j = 0; j < i; ++j)
        {
            String s = astring1[j];

            if (s.length() > 0)
            {
                this.field_73904_o.add(s);
            }
        }

        if (this.field_73904_o.size() > 0)
        {
            this.field_73897_d = true;
            this.completePlayerName();
        }
    }
}