@SubscribeEvent public static void onClientTick(ClientTickEvent event) throws Throwable { if (event.phase == Phase.START && (!Configs.creativeOnly || Minecraft.getMinecraft().player.isCreative())) { int timer = (int) getDelayTimer.invoke(Minecraft.getMinecraft()); RayTraceResult hover = Minecraft.getMinecraft().objectMouseOver; if (hover != null && hover.typeOfHit == Type.BLOCK) { BlockPos pos = hover.getBlockPos(); if (timer > 0 && !pos.equals(lastTargetPos) && (lastTargetPos == null || !pos.equals(lastTargetPos.offset(lastTargetSide)))) { setDelayTimer.invoke(Minecraft.getMinecraft(), 0); } else if (Configs.forceNewLoc && timer == 0 && pos.equals(lastTargetPos) && hover.sideHit == lastTargetSide) { setDelayTimer.invoke(Minecraft.getMinecraft(), 4); } lastTargetPos = pos.toImmutable(); lastTargetSide = hover.sideHit; } } }
@SubscribeEvent public void onLivingTick(PlayerTickEvent evt) { if (!evt.player.world.isRemote && evt.phase == Phase.END) { CapabilityDivination data = evt.player.getCapability(CapabilityDivination.CAPABILITY, null); Fortune f = data.getFortune(); if (f != null) { if (data.isRemovable()) { data.setFortune(null); } else { if (!data.isActive() && f.canShouldBeAppliedNow(evt.player)) { data.setActive(); if (f.apply(evt.player)) data.setFortune(null); } } } } }
/** Tick event called on the Client.<br> * Used to simulate pressing and releasing of our additional keys.<br> * This is about as close as we can (easily) get in the call stack to the point when Minecraft does the equivalent code for its own keys. * @param ev ClientTickEvent for this tick. */ @SubscribeEvent public void onClientTick(TickEvent.ClientTickEvent ev) { if (ev != null && ev.phase == Phase.START) { for (InternalKey binding : this.additionalKeys) { if (binding.isKeyDown()) { binding.onKeyDown(); } if (binding.isPressed()) { binding.onPressed(); } } } }
/** Called for each screen redraw - approximately three times as often as the other tick events, * under normal conditions.<br> * This is where we want to update our yaw/pitch, in order to get smooth panning etc * (which is how Minecraft itself does it). * The speed of the render ticks is not guaranteed, and can vary from machine to machine, so * we try to account for this in the calculations. * @param ev the RenderTickEvent object for this tick */ @SubscribeEvent public void onRenderTick(TickEvent.RenderTickEvent ev) { if (ev.phase == Phase.START) { if (this.isOverriding()) { EntityPlayerSP player = Minecraft.getMinecraft().thePlayer; if (player != null) { updateYawAndPitch(); player.rotationPitch = this.mCameraPitch; player.rotationYaw = this.mYaw; } } } }
@SideOnly(Side.CLIENT) @SubscribeEvent public void tickEvent(TickEvent.ClientTickEvent event) { if(event.phase==Phase.START){ EntityPlayer player=Minecraft.getMinecraft().player; if(player != null && player.getDataManager().get(SPIN_TIME) && !player.getHeldItemMainhand().isEmpty()){ player.getEntityData().setInteger("SpinTime", player.getEntityData().getInteger("SpinTime")-1); if(player.getEntityData().getInteger("SpinTime")<=0) player.getEntityData().setInteger("SpinTime", this.getDuration(player.getHeldItemMainhand(), player)); if(Minecraft.getMinecraft().gameSettings.thirdPersonView==0 ){ Minecraft.getMinecraft().gameSettings.thirdPersonView=1; player.getEntityData().setBoolean("SetFirstpersonAfter", true); } } if(player != null && !player.getDataManager().get(SPIN_TIME) && player.getEntityData().getBoolean("SetFirstpersonAfter")){ Minecraft.getMinecraft().gameSettings.thirdPersonView=0; player.getEntityData().setBoolean("SetFirstpersonAfter",false); } } }
@SubscribeEvent public void renderTick(TickEvent.RenderTickEvent event) { tickTime = event.renderTickTime; Minecraft minecraft = Minecraft.getMinecraft(); if (event.phase == Phase.END) if (minecraft.player != null && minecraft.player.getHeldItemMainhand() != null) if (minecraft.player.getHeldItemMainhand().getItem() instanceof ItemUsable) { Mouse.poll(); minecraft.player.rotationYawHead = minecraft.player.rotationYaw; moveEntities = true; keyPressUpdate(Mouse.isButtonDown(minecraft.gameSettings.keyBindAttack.getKeyCode() + 100), Mouse.isButtonDown(minecraft.gameSettings.keyBindUseItem.getKeyCode() + 100)); moveEntities = false; } }
@SubscribeEvent public void onServerTick(ServerTickEvent event) { if (event.phase != Phase.END) { return; } // Only doing it once if (event.side == Side.CLIENT) { return; } dayTick += 1; // Ticking up if (dayTick >= Main.getControlRefreshTick()) // A day has passed. Refreshing faction chunk health now { TerritoryHandler.refreshChunkControl(); dayTick = 0; // Reset } saveTick += 1; if (saveTick >= Main.getSaveTick()) // Autosave { SaveHandler.saveFactionsToFile(); saveTick = 0; // Reset } }
@SubscribeEvent public void onServerTick(ServerTickEvent event) { if (event.phase != Phase.END) { return; } // Only doing it once if (event.side == Side.CLIENT) { return; } // Chunk upkeep if (Main.shouldCheckUpkeep()) { TerritoryHandler.checkUpkeep(); } // Chunk control regeneration TerritoryHandler.checkChunkControl(); // Autosave Main.checkAutoSave(); Main.checkDisplayTick(); }
@SubscribeEvent public void onPlayerTick(TickEvent.PlayerTickEvent event){ if(event.phase == Phase.END){ EntityPlayer player = event.player; ExtendedPlayer playerEx = ExtendedPlayerProvider.getExtendedPlayer(player); float width = 0.6F; float height = 1.8F; float stepSize = 0.5F; float eyeHeight = player.getDefaultEyeHeight(); boolean doFunc = false; if(playerEx.isMini()){ width /= 2F; height /= 3F; eyeHeight/=3; stepSize/=2; doFunc = true; } if(doFunc && (player.width !=width || player.height !=height)){ EntityUtil.setSize(player, width, height, stepSize, eyeHeight, false); } } }
@SubscribeEvent public void tick(PlayerTickEvent event) { if(event.phase != Phase.END) return; if(event.side != Side.SERVER) return; IPlayerData data = event.player.getCapability(CapabilityProvider.PLAYER_DATA, null); Item item = data.getHoldItem(); if(item != null) { int holdTicks = data.getHoldTicks() + 1; data.setHoldTicks(holdTicks); System.out.println("TICK: " + holdTicks); // TODO fix if(holdTicks > 10) { System.out.println("STOP"); data.setHoldItem(null); //event.player.getCooldownTracker().setCooldown(item, ((IItemSpell)item).getCooldown()); } } }
@SubscribeEvent public void playerTick(final TickEvent.PlayerTickEvent event) { if (event.side == Side.SERVER || event.phase == Phase.END || Minecraft.getMinecraft().isGamePaused()) return; if (event.player == null || event.player.world == null) return; if (event.player != Minecraft.getMinecraft().player) return; final int tickRef = EnvironState.getTickCounter(); for (int i = 0; i < this.overlays.size(); i++) this.overlays.get(i).doTick(tickRef); }
@SubscribeEvent public void tickEvent(@Nonnull final TickEvent.PlayerTickEvent event) { if (event.phase == Phase.END && event.side == Side.SERVER) { final EntityPlayer player = event.player; final VillageCollection villageCollection = player.getEntityWorld().getVillageCollection(); boolean inVillage = false; if (villageCollection != null) { final List<Village> villages = villageCollection.getVillageList(); if (villages != null && villages.size() > 0) { final BlockPos pos = player.getPosition(); for (final Village v : villages) if (v.isBlockPosWithinSqVillageRadius(pos)) { inVillage = true; break; } } } final PacketEnvironment packet = new PacketEnvironment(inVillage); Network.sendToPlayer((EntityPlayerMP) player, packet); } }
/** * Collect tick performance data for the loaded dimensions and broadcast to * attached players. * * @param event */ @SubscribeEvent public void tickEvent(@Nonnull final TickEvent.ServerTickEvent event) { if (!ModOptions.reportServerStats || event.phase != Phase.END) return; // Spam once a second if ((++tpsCount % 20) != 0) return; MinecraftServer server = FMLCommonHandler.instance().getMinecraftServerInstance(); final TIntDoubleHashMap map = new TIntDoubleHashMap(); for (Integer dim : DimensionManager.getIDs()) { map.put(dim.intValue(), mean((long[]) server.worldTickTimes.get(dim)) / 1000000D); } final double meanTickTime = mean(server.tickTimeArray) / 1000000D; final int total = (int) (Runtime.getRuntime().totalMemory() / 1024L / 1024L); final int max = (int) (Runtime.getRuntime().maxMemory() / 1024L / 1024L); final int free = (int) (Runtime.getRuntime().freeMemory() / 1024L / 1024L); final PacketServerData packet = new PacketServerData(map, meanTickTime, free, total, max); Network.sendToAll(packet); }
/** Called for each screen redraw - approximately three times as often as the other tick events, * under normal conditions.<br> * This is where we want to update our yaw/pitch, in order to get smooth panning etc * (which is how Minecraft itself does it). * The speed of the render ticks is not guaranteed, and can vary from machine to machine, so * we try to account for this in the calculations. * @param ev the RenderTickEvent object for this tick */ @SubscribeEvent public void onRenderTick(TickEvent.RenderTickEvent ev) { if (ev.phase == Phase.START) { if (this.isOverriding()) { EntityPlayerSP player = Minecraft.getMinecraft().player; if (player != null) { updateYawAndPitch(); player.rotationPitch = this.mCameraPitch; player.rotationYaw = this.mYaw; } } } }
/** * This is going to record the player actions */ @SubscribeEvent public void onPlayerTick(PlayerTickEvent event) { EntityPlayer player = event.player; if (event.phase == Phase.START) { return; } if (!player.worldObj.isRemote && CommonProxy.manager.recorders.containsKey(player)) { RecordRecorder recorder = CommonProxy.manager.recorders.get(player); if (player.isDead) { CommonProxy.manager.stopRecording(player, true, true); Utils.broadcastInfo("recording.dead", recorder.record.filename); return; } recorder.record(player); } }
/** * This is going to record the player actions */ @SubscribeEvent public void onPlayerTick(PlayerTickEvent event) { EntityPlayer player = event.player; if (event.phase == Phase.START) { return; } if (player.worldObj.isRemote && ClientProxy.manager.recorders.containsKey(player)) { ClientProxy.manager.recorders.get(player).record(player); } }
public static void onTickEnd(TickEvent event) { if (event.phase == Phase.END) { if (CodeChickenLib.proxy.isClient()) { if (event.type == Type.CLIENT) { synchronized (tickMessages) { tickMessages.clear(); } } } else { if (event.type == Type.SERVER) { synchronized (tickMessages) { tickMessages.clear(); } } } } }
/** * This is used to increment the ticks in game value. * @param event The event object. */ @SubscribeEvent public static void ClientTickEnd(ClientTickEvent event) { if (event.phase == Phase.END) { GuiScreen gui = Minecraft.getMinecraft().currentScreen; if (gui == null || !gui.doesGuiPauseGame()) { // Reset the ticks in game if we are getting close to the maximum value of an integer. if (Integer.MAX_VALUE - 100 == ClientEventHandler.ticksInGame) { ClientEventHandler.ticksInGame = 1; } ClientEventHandler.ticksInGame++; } } }
public static void update(Phase phase) { switch (phase) { case END: online.forEach(p -> p.update1()); break; case START: profile = false; online.forEach(p -> p.update0()); if (!profile && profiled) { FMLCommonHandler.instance().getMinecraftServerInstance().profiler.profilingEnabled = false; profiled = false; } break; default: break; } }
public static void addDelayedRunnable(Side side, IPhaseRunnable runnable, int tick) { addContinuedRunnable(side, new IContinuedRunnable() { int c_tick = tick; @Override public boolean run(Phase phase) { if (c_tick < 1 || phase == Phase.START && --c_tick < 1) { runnable.run(phase); return true; } return false; } }); }
public static void addCounterRunnable(Side side, IPhaseRunnable runnable, Counter counter, int total) { addContinuedRunnable(side, new IContinuedRunnable() { int count = -1; @Override public boolean run(Phase phase) { if (counter.getAsBoolean() && ++count < total) { runnable.run(phase); return false; } return count >= total; } }); }
@SubscribeEvent public void onWorldTick(TickEvent.WorldTickEvent event) { if (event.phase == Phase.START) { World world = event.world; if (!BlockSystems.PROXY.isPaused(world)) { ServerBlockSystemHandler handler = BlockSystems.PROXY.getBlockSystemHandler(world); if (handler != null) { handler.update(); } if (world instanceof WorldServer) { BlockSystemTrackingHandler trackingHandler = BlockSystemTrackingHandler.get((WorldServer) world); trackingHandler.update(); } } } }
@SubscribeEvent public void tick(ClientTickEvent event) { // NORELEASE: Just move everything to the proxy? // NORELEASE: Can't this be done in DseRayTarget? if (event.phase != Phase.START) return; if (current_attacking_target == null) { resetProgress(); return; } if (current_attacking_target.typeOfHit != MovingObjectPosition.MovingObjectType.BLOCK) { resetProgress(); return; } MovingObjectPosition hit = Hammer.proxy.getShadowHit(); if (!current_attacking_target.getBlockPos().equals(hit.getBlockPos()) || current_attacking_target.subHit != hit.subHit) { resetClick(); resetProgress(); return; } tickClickBlock(hit); }
@SubscribeEvent public void tickServer(TickEvent.ServerTickEvent event) { if (event.phase != TickEvent.Phase.START) return; MinecraftServer ms = MinecraftServer.getServer(); if (ms.getTickCounter() < ms.tickTimeArray.length) { //Ignore startup return; } if (measurements++ != FzConfig.tps_reporting_interval) { return; } measurements = 0; float tps = getTpsRatio(); if (tps != last_tps) { FMLProxyPacket packet = MiscellaneousNonsense.net.makeTpsReportPacket(getTpsRatio()); MiscNet.channel.sendToAll(packet); last_tps = tps; } }
@Override public void tick(TickEvent event) { super.tick(event); if(event instanceof ClientTickEvent) { while(!clientTickQeue.isEmpty()) clientTickQeue.poll().run(); } if(event instanceof RenderTickEvent) { RenderTickEvent revt = (RenderTickEvent) event; // Pre-Scene Render if(revt.phase == Phase.START) { clientRenderer.on_render_world_terrain_pre(revt); } else // Post-World >> Pre-HUD Render if(revt.phase == Phase.END) { clientRenderer.on_render_world_terrain_post(revt); } } }
@SubscribeEvent public void onServerWorldTick(WorldTickEvent event) { World world = event.world; if(event.phase == Phase.START) { if(WorldGen.getInstance() != null) { if(world.provider.getDimension() == 0) { WorldGen.getInstance().trimCache(); WorldGen.getInstance().buildFromQueue(); WorldGen.getInstance().runUpdateLoop(event.world); } } } }
@SubscribeEvent public void onClientTick(TickEvent.ClientTickEvent event) { World world = Minecraft.getMinecraft().world; if(event.phase == Phase.START) { if(WorldGen.getInstance() != null) { if(world != null && world.provider.getDimension() == 0) { WorldGen.getInstance().trimCache(); WorldGen.getInstance().buildFromQueue(); //We don't update on the client //WorldGen.getInstance().runUpdateLoop(); } } } }
@SubscribeEvent public void onCreateWeapon(PlayerTickEvent event) { if (!event.player.getEntityWorld().isRemote) { if (event.phase == Phase.START) { for (ItemStack stack : event.player.inventory.mainInventory) { if (stack != null && (stack.getItem() instanceof ItemSword || stack.getItem() instanceof ItemBow || stack.getItem() instanceof ItemArmor || stack.getItem() instanceof ItemShield)) { create(stack, event.player); } } } } }
@SubscribeEvent public void onRenderTick(RenderTickEvent e) { if (!isEnabled()) { return; } // only record at the end of the frame if (e.phase == Phase.START) { return; } // stop at frame limit if (frameLimit > 0 && time.getNumFrames() >= frameLimit) { disable(); } // skip frames if the capturing framerate is not synchronized with the // rendering framerate if (!cfg.isSyncEngine() && !time.isNextFrame()) { // Game renders faster than necessary for recording? return; } postFrameEvent(new FrameImportEvent(frame, time, movieDir)); }
@SubscribeEvent public void onClientTick(ClientTickEvent evt) { if (!isEnabled() || evt.phase != Phase.START) { return; } // client is ready now if (!clientReady.get()) { L.info("Client tick sync ready"); clientReady.set(true); clientTick.set(0); } // wait for server side if (!serverReady.get()) { return; } // don't wait for the server while the game is paused! if (MC.isGamePaused()) { return; } // now sync with the server waitFor(evt.side, clientTick, serverTick, clientAhead, serverAhead); }
@SubscribeEvent public void onServerTick(ServerTickEvent evt) { if (!isEnabled() || evt.phase != Phase.START) { return; } // server is ready now if (!serverReady.get()) { L.info("Server tick sync ready"); serverReady.set(true); serverTick.set(0); } // wait for client side if (!clientReady.get()) { return; } // now sync with the client waitFor(evt.side, serverTick, clientTick, serverAhead, clientAhead); }
@SideOnly(Side.CLIENT) @SubscribeEvent public void onPlayerTickClient(PlayerTickEvent evt) { if (evt.side != Side.CLIENT || evt.phase != Phase.END) { return; } RayTraceResult mo = Minecraft.getMinecraft().objectMouseOver; if (mo != null && mo.entityHit != null && mo.entityHit instanceof EntityLivingBase) { EntityLivingBase el = (EntityLivingBase) mo.entityHit; if (el != lastMouseOver) { double baseAttack = 0; double attack = 0; IAttributeInstance damAtt = el.getAttributeMap().getAttributeInstance(SharedMonsterAttributes.ATTACK_DAMAGE); if (damAtt != null) { baseAttack = damAtt.getBaseValue(); attack = damAtt.getAttributeValue(); } System.out.println("DebugUtil.onPlayerTickClient: Health: " + el.getMaxHealth() + " Base Damage: " + baseAttack + " Damage: " + attack); } lastMouseOver = el; } else { lastMouseOver = null; } }
@SubscribeEvent public static void onServerTick(@Nonnull TickEvent.ServerTickEvent event) { final Profiler profiler = FMLCommonHandler.instance().getMinecraftServerInstance().profiler; profiler.startSection("root"); // this event is fired outside the profiler's normal coverage... profiler.startSection("ServerTickEvent"); for (Entry<ITickListener, String> entry : listeners.entrySet()) { profiler.startSection(NullHelper.first(entry.getValue(), "(unnamed)")); if (event.phase == Phase.START) { entry.getKey().tickStart(event, profiler); } else { entry.getKey().tickEnd(event, profiler); } profiler.endSection(); } profiler.endSection(); // ServerTickEvent profiler.endSection(); // root }
@SubscribeEvent public static void onAbilityTick(PlayerTickEvent event) { if (event.phase == Phase.START && !event.player.getEntityWorld().isRemote) { for (Ability ability : AbilityHelper.abilities) { if (ability.isActive()) { ability.onTick(); } } } }
@SubscribeEvent public void onTick(ServerTickEvent event) { if (event.phase == Phase.START) { SessionManager.getInstance().getAllSessions().forEachRemaining(sess -> { sess.taskManager.runTasks(); }); } }