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);
}
