public static void log(String par1, boolean isSevereError) { if (mod_SecurityCraft.debuggingMode) { System.out.println( isSevereError ? "{SecurityCraft} {" + FMLCommonHandler.instance().getEffectiveSide() + "} {Severe}: " + par1 : "[SecurityCraft] [" + FMLCommonHandler.instance().getEffectiveSide() + "] " + par1); } }
@Override public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception { if (side == Side.CLIENT) { FMLCommonHandler.instance() .bus() .post(new FMLNetworkEvent.ClientDisconnectionFromServerEvent(manager)); } else { FMLCommonHandler.instance() .bus() .post(new FMLNetworkEvent.ServerDisconnectionFromClientEvent(manager)); } cleanAttributes(ctx); ctx.close(promise); }
@Override public void onPickupFromSlot(EntityPlayer player, ItemStack craftedItem) { if (player.capabilities.isCreativeMode && ConfigurationManager.ENABLE_FREECRAFTING || craftedItem == null) { FMLCommonHandler.instance().firePlayerCraftingEvent(player, craftedItem, matrix); super.onCrafting(craftedItem); return; } CraftRecipe recipe = getRecipe(); if (recipe == null) return; handler.doCraft(recipe, player, craftedItem); FMLCommonHandler.instance().firePlayerCraftingEvent(player, craftedItem, matrix); super.onCrafting(craftedItem); }
public void interact(EntityPlayer player) { // can't interact if liquid inside if (tank.getFluidAmount() > 0) { return; } // completely empty -> insert current item into input if (!isStackInSlot(0) && !isStackInSlot(1)) { ItemStack stack = player.inventory.decrStackSize(player.inventory.currentItem, stackSizeLimit); setInventorySlotContents(0, stack); } // take item out else { // take out of stack 1 if something is in there, 0 otherwise int slot = isStackInSlot(1) ? 1 : 0; // Additional Info: Only 1 item can only be put into the casting block usually, however // recipes // can have Itemstacks with stacksize > 1 as output // we therefore spill the whole contents on extraction ItemStack stack = getStackInSlot(slot); if (slot == 1) { FMLCommonHandler.instance().firePlayerSmeltedEvent(player, stack); } PlayerHelper.spawnItemAtPlayer(player, stack); setInventorySlotContents(slot, null); } }
@SuppressWarnings("deprecation") private void registerKeyBindings() { LogHelper.info("Watching your keys"); FMLCommonHandler.instance().bus().register(new KeyHandler()); ClientRegistry.registerKeyBinding(KeyHandler.drafting); ClientRegistry.registerKeyBinding(KeyHandler.makeSelection); }
@Override protected void decode( ChannelHandlerContext channelHandlerContext, FMLProxyPacket fmlProxyPacket, List<Object> out) throws Exception { ByteBuf payload = fmlProxyPacket.payload(); byte discriminator = payload.readByte(); Class<? extends AbstractPacketOld> clazz = this.packets.get(discriminator); if (clazz == null) { throw new NullPointerException("No packet registered for discriminator: " + discriminator); } AbstractPacketOld packet = clazz.newInstance(); packet.decodeInto(channelHandlerContext, payload.slice()); EntityPlayer player; switch (FMLCommonHandler.instance().getEffectiveSide()) { case CLIENT: player = PacketHandlerOld.getClientPlayer(); packet.handleClientSide(player); break; case SERVER: INetHandler netHandler = channelHandlerContext.channel().attr(NetworkRegistry.NET_HANDLER).get(); player = ((NetHandlerPlayServer) netHandler).playerEntity; packet.handleServerSide(player); break; default: } out.add(packet); }
public static void init() { if (!initialized) { FMLCommonHandler.instance().bus().register(new AchievementGiver.OnCraftEvent()); SpartanMod.log( Level.INFO, "OnCraftEvent has been registered with FMLCommonHandler's eventbus."); } }
@EventHandler public void init(FMLInitializationEvent event) { MinecraftForge.EVENT_BUS.register(new ExampleTurtleMod()); MinecraftForge.EVENT_BUS.register(new TurtleTips()); MinecraftForge.EVENT_BUS.register(new TurtleChatMod()); if (event.getSide() == Side.CLIENT) { RenderItem renderItem = Minecraft.getMinecraft().getRenderItem(); renderItem .getItemModelMesher() .register( PurpleSword.instance, 0, new ModelResourceLocation(MODID + ":" + PurpleSword.instance.name, "inventory")); renderItem .getItemModelMesher() .register( Item.getItemFromBlock(PurpleBlock.instance), 0, new ModelResourceLocation(MODID + ":" + PurpleBlock.instance.name, "inventory")); } // Register all the devoxx4kids mods MinecraftForge.EVENT_BUS.register(new ArrowShotgun()); MinecraftForge.EVENT_BUS.register(new ChatItems()); MinecraftForge.EVENT_BUS.register(new CreeperSpawnAlert()); MinecraftForge.EVENT_BUS.register(new DragonSpawner()); MinecraftForge.EVENT_BUS.register(new EnchantmentArrowFast()); MinecraftForge.EVENT_BUS.register(new OverpoweredIronGolems()); MinecraftForge.EVENT_BUS.register(new RainWater()); MinecraftForge.EVENT_BUS.register(new SharpSnowballs()); MinecraftForge.EVENT_BUS.register(new SkeletonWar()); MinecraftForge.EVENT_BUS.register(new WallClimber()); FMLCommonHandler.instance().bus().register(new WallClimber()); }
public void onPickupFromSlot(EntityPlayer playerIn, ItemStack stack) { net.minecraftforge.fml.common.FMLCommonHandler.instance() .firePlayerCraftingEvent(playerIn, stack, craftMatrix); this.onCrafting(stack); net.minecraftforge.common.ForgeHooks.setCraftingPlayer(playerIn); ItemStack[] aitemstack = AltarCraftingManager.getInstance().func_180303_b(this.craftMatrix, playerIn.worldObj); net.minecraftforge.common.ForgeHooks.setCraftingPlayer(null); for (int i = 0; i < aitemstack.length; ++i) { ItemStack itemstack1 = this.craftMatrix.getStackInSlot(i); ItemStack itemstack2 = aitemstack[i]; if (itemstack1 != null) { this.craftMatrix.decrStackSize(i, 1); } if (itemstack2 != null) { if (this.craftMatrix.getStackInSlot(i) == null) { this.craftMatrix.setInventorySlotContents(i, itemstack2); } else if (!this.thePlayer.inventory.addItemStackToInventory(itemstack2)) { this.thePlayer.dropPlayerItemWithRandomChoice(itemstack2, false); } } } }
@Override public void registerEventHandlers() { super.registerEventHandlers(); WMClientEventHandler eventhandler = new WMClientEventHandler(); FMLCommonHandler.instance().bus().register(eventhandler); MinecraftForge.EVENT_BUS.register(eventhandler); MinecraftForge.EVENT_BUS.register( new GuiOverlayReloaded(FMLClientHandler.instance().getClient())); }
@EventHandler public void init(FMLInitializationEvent event) throws Exception { packetPipeline.registerMessage( AnvilTechniquePacket.Handler.class, AnvilTechniquePacket.class, 0, Side.SERVER); packetPipeline.registerMessage( ChunkPutNbtPacket.Handler.class, ChunkPutNbtPacket.class, 1, Side.CLIENT); packetPipeline.registerMessage( ChunkRemoveNbtPacket.Handler.class, ChunkRemoveNbtPacket.class, 2, Side.CLIENT); packetPipeline.registerMessage( SoundEffectToServerPacket.Handler.class, SoundEffectToServerPacket.class, 3, Side.SERVER); packetPipeline.registerMessage( MechanicalNetworkNBTPacket.ClientHandler.class, MechanicalNetworkNBTPacket.class, 4, Side.CLIENT); packetPipeline.registerMessage( StartMeteorShowerPacket.ClientHandler.class, StartMeteorShowerPacket.class, 5, Side.CLIENT); packetPipeline.registerMessage( WorldDataPacket.ClientHandler.class, WorldDataPacket.class, 6, Side.CLIENT); packetPipeline.registerMessage( CarpentryTechniquePacket.Handler.class, CarpentryTechniquePacket.class, 7, Side.SERVER); BlocksVC.init(); ItemsVC.init(); AchievementsVC.init(); FMLCommonHandler.instance().bus().register(this); MinecraftForge.EVENT_BUS.register(this); proxy.registerTileEntities(); NetworkRegistry.INSTANCE.registerGuiHandler(instance, proxy); System.out.println("vcraft has init."); GameRegistry.registerWorldGenerator(new WorldGenDeposits(), 4); WorldType.DEFAULT = WorldTypeVC.DEFAULT; WorldType.FLAT = WorldTypeVC.FLAT; // DimensionManager.unregisterDimension(-1); DimensionManager.unregisterDimension(0); DimensionManager.unregisterDimension(1); // DimensionManager.unregisterProviderType(-1); DimensionManager.unregisterProviderType(0); DimensionManager.unregisterProviderType(1); DimensionManager.registerProviderType(0, WorldProviderVC.class, true); DimensionManager.registerProviderType(1, WorldProviderVC.class, false); // DimensionManager.registerDimension(-1, -1); DimensionManager.registerDimension(0, 0); DimensionManager.registerDimension(1, 1); proxy.init(event); }
@Override public void decodeInto(ChannelHandlerContext ctx, ByteBuf source, DimensionSyncPacket msg) { msg.consumePacket(source); switch (FMLCommonHandler.instance().getEffectiveSide()) { case CLIENT: msg.execute(); break; case SERVER: break; } }
private void completeClientSideConnection(ConnectionType type) { this.connectionType = type; FMLLog.info( "[%s] Client side %s connection established", Thread.currentThread().getName(), this.connectionType.name().toLowerCase(Locale.ENGLISH)); this.state = ConnectionState.CONNECTED; FMLCommonHandler.instance() .bus() .post( new FMLNetworkEvent.ClientConnectedToServerEvent(manager, this.connectionType.name())); }
@Override public void handlePacketData(ByteBuf data) { if (FMLCommonHandler.instance().getEffectiveSide().isClient()) { int gasID = data.readInt(); if (gasID < 0) { collectedGas.setGas(null); } else { collectedGas.setGas(new GasStack(gasID, data.readInt())); } } }
/** * @author blood - May 21st, 2016 * @reason - adjusted to support {@link DisplaceEntityEvent.Teleport.Portal} * @param playerIn The player teleporting to another dimension * @param targetDimensionId The id of target dimension. * @param teleporter The teleporter used to transport and create the portal */ public void transferPlayerToDimension( EntityPlayerMP playerIn, int targetDimensionId, net.minecraft.world.Teleporter teleporter) { DisplaceEntityEvent.Teleport.Portal event = SpongeCommonEventFactory.handleDisplaceEntityPortalEvent( playerIn, targetDimensionId, teleporter); if (event == null || event.isCancelled()) { return; } WorldServer fromWorld = (WorldServer) event.getFromTransform().getExtent(); WorldServer toWorld = (WorldServer) event.getToTransform().getExtent(); playerIn.dimension = toWorld.provider.getDimensionId(); // Support vanilla clients teleporting to custom dimensions int dimension = DimensionManager.getClientDimensionToSend( toWorld.provider.getDimensionId(), toWorld, playerIn); if (((IMixinEntityPlayerMP) playerIn).usesCustomClient()) { DimensionManager.sendDimensionRegistration(toWorld, playerIn, dimension); } playerIn.playerNetServerHandler.sendPacket( new S07PacketRespawn( playerIn.dimension, fromWorld.getDifficulty(), fromWorld.getWorldInfo().getTerrainType(), playerIn.theItemInWorldManager.getGameType())); fromWorld.removePlayerEntityDangerously(playerIn); playerIn.isDead = false; // we do not need to call transferEntityToWorld as we already have the correct transform and // created the portal in handleDisplaceEntityPortalEvent ((IMixinEntity) playerIn).setLocationAndAngles(event.getToTransform()); toWorld.spawnEntityInWorld(playerIn); toWorld.updateEntityWithOptionalForce(playerIn, false); playerIn.setWorld(toWorld); this.preparePlayer(playerIn, fromWorld); playerIn.playerNetServerHandler.setPlayerLocation( playerIn.posX, playerIn.posY, playerIn.posZ, playerIn.rotationYaw, playerIn.rotationPitch); playerIn.theItemInWorldManager.setWorld(toWorld); this.updateTimeAndWeatherForPlayer(playerIn, toWorld); this.syncPlayerInventory(playerIn); for (PotionEffect potioneffect : playerIn.getActivePotionEffects()) { playerIn.playerNetServerHandler.sendPacket( new S1DPacketEntityEffect(playerIn.getEntityId(), potioneffect)); } ((IMixinEntityPlayerMP) playerIn).refreshXpHealthAndFood(); // Forge needs to know when a player changes to new a dimension // This cannot be mapped to DisplaceEntityEvent.Teleport as this event must be called AFTER // transfer. net.minecraftforge.fml.common.FMLCommonHandler.instance() .firePlayerChangedDimensionEvent( playerIn, fromWorld.provider.getDimensionId(), toWorld.provider.getDimensionId()); }
@EventHandler public void init(FMLInitializationEvent event) { FMLCommonHandler.instance().bus().register(this); ItemModelMesher mesher = Minecraft.getMinecraft().getRenderItem().getItemModelMesher(); for (Entry<Item, String> entry : itemModels.entrySet()) mesher.register(entry.getKey(), 0, new ModelResourceLocation(entry.getValue(), "inventory")); for (Entry<Block, String> entry : blockModels.entrySet()) mesher.register( Item.getItemFromBlock(entry.getKey()), 0, new ModelResourceLocation(entry.getValue(), "inventory")); }
public Material(String identifier, int color) { this.identifier = Util.sanitizeLocalizationString(identifier); // lowercases and removes whitespaces // if invisible, make it fully opaque. if (((color >> 24) & 0xFF) == 0) { color |= 0xFF << 24; } this.materialTextColor = color; if (FMLCommonHandler.instance().getSide().isClient()) { setRenderInfo(color); } }
private synchronized void completeServerSideConnection(ConnectionType type) { this.connectionType = type; FMLLog.info( "[%s] Server side %s connection established", Thread.currentThread().getName(), this.connectionType.name().toLowerCase(Locale.ENGLISH)); this.state = ConnectionState.CONNECTED; FMLCommonHandler.instance() .bus() .post(new FMLNetworkEvent.ServerConnectionFromClientEvent(manager)); if (DEBUG_HANDSHAKE) manager.closeChannel( new ChatComponentText("Handshake Complete review log file for details.")); scm.initializeConnectionToPlayer(manager, player, serverHandler); }
@SubscribeEvent public void onServerTick(TickEvent.WorldTickEvent event) { if (FMLCommonHandler.instance().getMinecraftServerInstance() == null || event.phase == TickEvent.Phase.END || event.world.provider.getDimensionId() != 0) return; if (MechnicalNetworkManager.getNetworkManagerForWorld(event.world) == null) { VCraftWorldSavedData worlddata = getOrCreateWorldData(event.world); worlddata.setWorld(event.world); MechnicalNetworkManager.addManager(event.world, worlddata.getNetworks()); } long worldtime = event.world.getTotalWorldTime(); long timeofday = event.world.getWorldTime() / 24000L; if (worldtime % 6000L == 0) { VintageCraftMobTweaker.setSpawnCap( EnumCreatureType.MONSTER, VintageCraftMobTweaker.spawnCapByDay(worldtime / 24000L, event.world.getDifficulty())); VintageCraftConfig.saveConfig(); } int moonphase = event.world.provider.getMoonPhase(event.world.getWorldTime()); boolean cannotSleeptonight = moonphase == 0 || (event.world.getDifficulty() == EnumDifficulty.HARD && (moonphase == 7 || moonphase == 1)); if (cannotSleeptonight) { for (Object obj : event.world.playerEntities) { EntityPlayer player = (EntityPlayer) obj; if (player.isPlayerSleeping() && getSleepTimer(player) > 80) { player.wakeUpPlayer(true, true, true); player.addChatMessage( new ChatComponentText( "You tried to fall sleep, but something is keeping you awake tonight.")); } } } long day = worldtime / 24000L; if (day > 0 && day % 20 == 0 && timeofday % 24000L == 14000) { packetPipeline.sendToAll(new StartMeteorShowerPacket(10000)); MinecraftServer.getServer() .getConfigurationManager() .sendChatMsg(new ChatComponentText("Something strange is happening in the night sky")); } }
private Object verify(Object obj) { if (obj instanceof String) AbyssalCraftAPI.getInternalNDHandler().verifyImageURL((String) obj); if (!(obj instanceof ResourceLocation)) return obj; if (FMLCommonHandler.instance().getSide().isServer()) return obj; ResourceLocation res = (ResourceLocation) obj; if (res.toString().equals("abyssalcraft:textures/gui/necronomicon/missing.png")) return obj; try { TextureUtil.readBufferedImage( Minecraft.getMinecraft().getResourceManager().getResource(res).getInputStream()); } catch (IOException e) { return new ResourceLocation("abyssalcraft", "textures/gui/necronomicon/missing.png"); } return res; }
@Override public void init(FMLInitializationEvent event) { super.init(event); ClientCommandHandler.instance.registerCommand(new ClientCommandsVC()); MinecraftForge.EVENT_BUS.register(this); FMLCommonHandler.instance().bus().register(this); MinecraftForge.EVENT_BUS.register(new RenderFog()); if (VintageCraftConfig.rearrangeCreativeTabs) { int i = 0; CreativeTabs[] tabs = new CreativeTabs[CreativeTabs.creativeTabArray.length]; for (CreativeTabs tab : CreativeTabs.creativeTabArray) { if (tab instanceof CreativeTabsVC) { if (i == 5 || i == 11) i++; // don't touch search tab or inventory tab tab.tabIndex = i; tabs[i++] = tab; } } tabs[5] = CreativeTabs.tabAllSearch; tabs[11] = CreativeTabs.tabInventory; i = 7; for (CreativeTabs tab : CreativeTabs.creativeTabArray) { if (!(tab instanceof CreativeTabsVC) && !tab.getTabLabel().equals("search") && !tab.getTabLabel().equals("inventory")) { if (i == 11) i++; tab.tabIndex = i; tabs[i++] = tab; } } CreativeTabs.creativeTabArray = tabs; /*for (CreativeTabs tab : CreativeTabs.creativeTabArray) { System.out.println(tab.getTabLabel() + ": " + tab.tabIndex); }*/ } }
public static WhoAmI whoAmI(World world) { Side side = FMLCommonHandler.instance().getSide(); if (side == Side.CLIENT) { if (Minecraft.getMinecraft().isIntegratedServerRunning()) { if (world.isRemote) { return SPCLIENT; } else { return SPSERVER; } } else { return MPCLIENT; } } else if (side == Side.SERVER) { if (MinecraftServer.getServer().isDedicatedServer()) { return MPSERVER; } else if (Minecraft.getMinecraft().isIntegratedServerRunning()) { return SPSERVER; } } return OTHER; }
@Mod.EventHandler public void init(FMLInitializationEvent event) { addHandler(modeHandler = new ModeHandler()); addHandler(eventHandler = new EventHandler()); addHandler(commandHandler = new CommandHandler()); FMLCommonHandler.instance().bus().register(eventHandler); MinecraftForge.EVENT_BUS.register(eventHandler); modeUtils = new ModeUtils(this); commandUtils = new CommandUtils(this); final ModSettings settings = new ModSettings(this); settings.loadValues(); settings.loadKeyBinds(); Runtime.getRuntime() .addShutdownHook( new Thread(MOD_NAME + " Shutdown Thread") { @Override public void run() { settings.saveKeyBinds(); settings.saveValues(); } }); }
@Override public void handlePacketData(ByteBuf dataStream) { super.handlePacketData(dataStream); if (FMLCommonHandler.instance().getEffectiveSide().isClient()) { FluidTankTier prevTier = tier; tier = FluidTankTier.values()[dataStream.readInt()]; fluidTank.setCapacity(tier.storage); clientActive = dataStream.readBoolean(); valve = dataStream.readInt(); editMode = ContainerEditMode.values()[dataStream.readInt()]; if (valve > 0) { valveFluid = FluidRegistry.getFluid(PacketHandler.readString(dataStream)); } else { valveFluid = null; } if (dataStream.readInt() == 1) { fluidTank.setFluid( new FluidStack( FluidRegistry.getFluid(PacketHandler.readString(dataStream)), dataStream.readInt())); } else { fluidTank.setFluid(null); } if (prevTier != tier || (updateDelay == 0 && clientActive != isActive)) { updateDelay = general.UPDATE_DELAY; isActive = clientActive; MekanismUtils.updateBlock(worldObj, getPos()); } } }
public EventHandler() { MinecraftForge.EVENT_BUS.register(this); FMLCommonHandler.instance().bus().register(this); }
@EventHandler public void init(FMLInitializationEvent event) { FMLCommonHandler.instance().bus().register(new PlayerUpdateHandler()); final AIController controller = new AIController(); controller.initialize(); }
// ******************************// // define member methods. // ******************************// public static void postEvent() { FMLCommonHandler.instance().bus().post(new F2PressedEvent()); }
/** * An event driven network channel, using {@link FMLNetworkEvent.CustomPacketEvent} and {@link * FMLNetworkEvent.CustomNetworkEvent} to deliver messages to an event listener. There is one "bus" * for each channel, due to the impossibility of filtering a bus for specific events. * * <p>This event driven system completely wraps the netty code. Mod code deals with FMLProxyPackets * directly. It is not possible to enhance the netty pipeline, and I would expect highly unexpected * results if it were modified reflectively. Use a real ChannelHandler if you want to use netty. * * @author cpw */ public class FMLEventChannel { private EnumMap<Side, FMLEmbeddedChannel> channels; private EventBus eventBus; /* * This is done this way so that the CLIENT specific code in the factory only loads on the client */ private enum EventFactory { SERVER() { @Override FMLNetworkEvent.CustomPacketEvent<?> make(FMLProxyPacket msg) { FMLNetworkEvent.CustomPacketEvent<?> event = null; if (msg.handler() instanceof NetHandlerPlayServer) { NetHandlerPlayServer server = (NetHandlerPlayServer) msg.handler(); event = new FMLNetworkEvent.ServerCustomPacketEvent(server.getNetworkManager(), msg); } return event; } }, CLIENT() { @Override FMLNetworkEvent.CustomPacketEvent<?> make(FMLProxyPacket msg) { FMLNetworkEvent.CustomPacketEvent<?> event = null; if (msg.handler() instanceof NetHandlerPlayClient) { NetHandlerPlayClient client = (NetHandlerPlayClient) msg.handler(); event = new FMLNetworkEvent.ClientCustomPacketEvent(client.getNetworkManager(), msg); } else if (msg.handler() instanceof NetHandlerPlayServer) { NetHandlerPlayServer server = (NetHandlerPlayServer) msg.handler(); event = new FMLNetworkEvent.ServerCustomPacketEvent(server.getNetworkManager(), msg); } return event; } }; abstract FMLNetworkEvent.CustomPacketEvent<?> make(FMLProxyPacket msg); } private static EventFactory factory = FMLCommonHandler.instance().getSide() == Side.CLIENT ? EventFactory.CLIENT : EventFactory.SERVER; FMLEventChannel(String name) { this.channels = NetworkRegistry.INSTANCE.newChannel(name, new NetworkEventFiringHandler(this)); this.eventBus = new EventBus(); } /** * Register an event listener with this channel and bus. See {@link SubscribeEvent} * * @param object */ public void register(Object object) { this.eventBus.register(object); } /** * Unregister an event listener from the bus. * * @param object */ public void unregister(Object object) { this.eventBus.unregister(object); } void fireRead(FMLProxyPacket msg, ChannelHandlerContext ctx) { FMLNetworkEvent.CustomPacketEvent<?> event = factory.make(msg); if (event != null) { this.eventBus.post(event); if (event.getReply() != null) { ctx.channel() .attr(FMLOutboundHandler.FML_MESSAGETARGET) .set(FMLOutboundHandler.OutboundTarget.REPLY); ctx.writeAndFlush(event.getReply()) .addListener(ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE); } } } public void fireUserEvent(Object evt, ChannelHandlerContext ctx) { FMLNetworkEvent.CustomNetworkEvent event = new FMLNetworkEvent.CustomNetworkEvent(evt); this.eventBus.post(event); } /** * Send a packet to all on the server * * @param pkt */ public void sendToAll(FMLProxyPacket pkt) { channels .get(Side.SERVER) .attr(FMLOutboundHandler.FML_MESSAGETARGET) .set(FMLOutboundHandler.OutboundTarget.ALL); channels .get(Side.SERVER) .writeAndFlush(pkt) .addListener(ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE); } /** * Send to a specific player * * @param pkt * @param player */ public void sendTo(FMLProxyPacket pkt, EntityPlayerMP player) { channels .get(Side.SERVER) .attr(FMLOutboundHandler.FML_MESSAGETARGET) .set(FMLOutboundHandler.OutboundTarget.PLAYER); channels.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).set(player); channels .get(Side.SERVER) .writeAndFlush(pkt) .addListener(ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE); } /** * Send to all around a point * * @param pkt * @param point */ public void sendToAllAround(FMLProxyPacket pkt, NetworkRegistry.TargetPoint point) { channels .get(Side.SERVER) .attr(FMLOutboundHandler.FML_MESSAGETARGET) .set(FMLOutboundHandler.OutboundTarget.ALLAROUNDPOINT); channels.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).set(point); channels .get(Side.SERVER) .writeAndFlush(pkt) .addListener(ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE); } /** * Send to all in a dimension * * @param pkt * @param dimensionId */ public void sendToDimension(FMLProxyPacket pkt, int dimensionId) { channels .get(Side.SERVER) .attr(FMLOutboundHandler.FML_MESSAGETARGET) .set(FMLOutboundHandler.OutboundTarget.DIMENSION); channels.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).set(dimensionId); channels .get(Side.SERVER) .writeAndFlush(pkt) .addListener(ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE); } /** * Send to the server * * @param pkt */ public void sendToServer(FMLProxyPacket pkt) { channels .get(Side.CLIENT) .attr(FMLOutboundHandler.FML_MESSAGETARGET) .set(FMLOutboundHandler.OutboundTarget.TOSERVER); channels .get(Side.CLIENT) .writeAndFlush(pkt) .addListener(ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE); } }
public static List<String> injectSnapshot( GameDataSnapshot snapshot, boolean injectFrozenData, boolean isLocalWorld) { FMLLog.info( "Injecting existing block and item data into this %s instance", FMLCommonHandler.instance().getEffectiveSide().isServer() ? "server" : "client"); Map<String, Integer[]> remapBlocks = Maps.newHashMap(); Map<String, Integer[]> remapItems = Maps.newHashMap(); LinkedHashMap<String, Integer> missingBlocks = new LinkedHashMap<String, Integer>(); LinkedHashMap<String, Integer> missingItems = new LinkedHashMap<String, Integer>(); getMain().testConsistency(); getMain().iBlockRegistry.dump(); getMain().iItemRegistry.dump(); getMain().iItemRegistry.resetSubstitutionDelegates(); GameDataSnapshot.Entry blocks = snapshot.entries.get("fml:blocks"); GameDataSnapshot.Entry items = snapshot.entries.get("fml:items"); GameData newData = new GameData(); for (int id : blocks.blocked) { newData.block(id); } for (Map.Entry<String, String> entry : blocks.aliases.entrySet()) { newData.iBlockRegistry.addAlias(entry.getKey(), entry.getValue()); } for (Map.Entry<String, String> entry : items.aliases.entrySet()) { newData.iItemRegistry.addAlias(entry.getKey(), entry.getValue()); } for (String entry : blocks.substitutions) { newData.iBlockRegistry.activateSubstitution(entry); } for (String entry : items.substitutions) { newData.iItemRegistry.activateSubstitution(entry); } if (injectFrozenData) { for (String newBlockSubstitution : getMain().blockSubstitutions.keySet()) { if (!blocks.substitutions.contains(newBlockSubstitution)) { newData.iBlockRegistry.activateSubstitution(newBlockSubstitution); } } for (String newItemSubstitution : getMain().itemSubstitutions.keySet()) { if (!items.substitutions.contains(newItemSubstitution)) { newData.iItemRegistry.activateSubstitution(newItemSubstitution); } } } // Clear State map for it's ready for us to register below. GameData.BLOCKSTATE_TO_ID.clear(); // process blocks and items in the world, blocks in the first pass, items in the second // blocks need to be added first for proper ItemBlock handling for (int pass = 0; pass < 2; pass++) { boolean isBlock = (pass == 0); Map<String, Integer> ids = (isBlock ? blocks.ids : items.ids); for (Entry<String, Integer> entry : ids.entrySet()) { String itemName = entry.getKey(); int newId = entry.getValue(); int currId = isBlock ? getMain().iBlockRegistry.getId(itemName) : getMain().iItemRegistry.getId(itemName); if (currId == -1) { FMLLog.info("Found a missing id from the world %s", itemName); (isBlock ? missingBlocks : missingItems).put(entry.getKey(), newId); continue; // no block/item -> nothing to add } else if (currId != newId) { FMLLog.fine( "Fixed %s id mismatch %s: %d (init) -> %d (map).", isBlock ? "block" : "item", itemName, currId, newId); (isBlock ? remapBlocks : remapItems).put(itemName, new Integer[] {currId, newId}); } // register if (isBlock) { currId = newData.registerBlock(getMain().iBlockRegistry.getRaw(itemName), itemName, newId); } else { currId = newData.registerItem(getMain().iItemRegistry.getRaw(itemName), itemName, newId); } if (currId != newId) { throw new IllegalStateException( String.format( "Can't map %s %s to id %d (seen at: %d), already occupied by %s, blocked %b, ItemBlock %b", isBlock ? "block" : "item", itemName, newId, currId, isBlock ? newData.iBlockRegistry.getRaw(newId) : newData.iItemRegistry.getRaw(newId), newData.blockedIds.contains(newId), isBlock ? false : (getMain().iItemRegistry.getRaw(currId) instanceof ItemBlock))); } } } List<String> missedMappings = Loader.instance() .fireMissingMappingEvent( missingBlocks, missingItems, isLocalWorld, newData, remapBlocks, remapItems); if (!missedMappings.isEmpty()) return missedMappings; // If we got here - the load was accepted. We'll load generic repositories here. // Generic registries can fail by returning a missing mapping. missedMappings = newData.loadGenericRegistries(snapshot, getMain()); if (!missedMappings.isEmpty()) return missedMappings; if (injectFrozenData) // add blocks + items missing from the map { Map<String, Integer> newBlocks = frozen.iBlockRegistry.getEntriesNotIn(newData.iBlockRegistry); Map<String, Integer> newItems = frozen.iItemRegistry.getEntriesNotIn(newData.iItemRegistry); if (!newBlocks.isEmpty() || !newItems.isEmpty()) { FMLLog.info("Injecting new block and item data into this server instance."); for (int pass = 0; pass < 2; pass++) { boolean isBlock = pass == 0; Map<String, Integer> missing = (pass == 0) ? newBlocks : newItems; Map<String, Integer[]> remaps = (isBlock ? remapBlocks : remapItems); for (Entry<String, Integer> entry : missing.entrySet()) { String itemName = entry.getKey(); int currId = entry.getValue(); int newId; if (isBlock) { newId = newData.registerBlock(frozen.iBlockRegistry.getRaw(itemName), itemName, currId); } else { newId = newData.registerItem(frozen.iItemRegistry.getRaw(itemName), itemName, currId); } FMLLog.info( "Injected new block/item %s: %d (init) -> %d (map).", itemName, currId, newId); if (newId != currId) // a new id was assigned { remaps.put(itemName, new Integer[] {entry.getValue(), newId}); } } } } } newData.testConsistency(); getMain().set(newData); getMain().iBlockRegistry.dump(); getMain().iItemRegistry.dump(); Loader.instance().fireRemapEvent(remapBlocks, remapItems); // The id map changed, ensure we apply object holders ObjectHolderRegistry.INSTANCE.applyObjectHolders(); return ImmutableList.of(); }
@Override public void init(FMLInitializationEvent event) { super.init(event); FMLCommonHandler.instance().bus().register(PlayerHandler.INSTANCE); }