/** * 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(); } }
@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(); } } }