Java 类net.minecraft.util.Timer 实例源码

public MilkCrits() {
    super("Milk Crits", 0xFFE2FB, ModuleCategory.TWEAKS);

    listeners.add(new Listener<PlayerUpdate>() {
        @Override
        public void call(PlayerUpdate event) {
            Timer timer = ((MinecraftExtension) mc).getTimer();
            timer.timerSpeed = 1F;

            if (Math.abs(mc.thePlayer.motionY) > 0.1) {
                if (mc.thePlayer.motionY > 0) {
                    timer.timerSpeed = 1.5F;
                } else if (mc.thePlayer.motionY < 0) {
                    timer.timerSpeed = 0.6F;
                }
            }
        }
    });
}

@Override
protected final void drawGuiContainerForegroundLayer(int mouseX, int mouseY) {
  drawForegroundImpl(mouseX, mouseY);

  Timer t = RenderUtil.getTimer();

  if (t != null) {
    GL11.glPushMatrix();
    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    GL11.glDisable(GL11.GL_DEPTH_TEST);
    for (IGuiOverlay overlay : overlays) {
      if (overlay != null && overlay.isVisible()) {
        overlay.draw(realMx, realMy, t.renderPartialTicks);
      }
    }
    GL11.glEnable(GL11.GL_DEPTH_TEST);
    GL11.glPopMatrix();
  }
}

@Override
protected void doEnable() {
    Timer defaultTimer = minecraftGetTimer(MC);

    // check if it's modified already
    if (defaultTimer instanceof FixedTimer) {
        L.warn("Timer is already modified!");
        return;
    }

    // get default ticks per second if possible
    if (defaultTimer != null) {
        defaultTps = timerGetTicksPerSecond(defaultTimer);
    }

    float fps = cfg.frameRate.get().floatValue();
    float speed = cfg.engineSpeed.get().floatValue();

    // set fixed delay timer
    minecraftSetTimer(MC, new FixedTimer(defaultTps, fps, speed));
}

@Override
public void controlClient(EntityPlayerCustom playerCustom, EntityPlayer player) {
    if (keyPressedSlow && !playerCustom.slow) {
        ObfuscationReflectionHelper.setPrivateValue(Timer.class,
                ((Timer) ObfuscationReflectionHelper.getPrivateValue(
                        Minecraft.class, Minecraft.getMinecraft(), 16)),
                5F, 0);
        playerCustom.slow = true;
    }
    if (playerCustom.slow) {
        playerCustom.slowTime++;
    }
    if (playerCustom.slowTime == 25 && playerCustom.slow) {
        ObfuscationReflectionHelper.setPrivateValue(Timer.class,
                ((Timer) ObfuscationReflectionHelper.getPrivateValue(
                        Minecraft.class, Minecraft.getMinecraft(), 16)),
                20F, 0);
        playerCustom.slowTime = 0;
        Minecraft.getMinecraft().gameSettings.mouseSensitivity = defaultSensitivity;
        keyPressedSlow = false;
        playerCustom.slow = false;
    }
}

@Override
public void onEnable() {
    Timer.timerSpeed = 1.0f;
    this.cancel = false;
    this.stage = 1;
    this.moveSpeed = ((this.mc.thePlayer == null) ? 0.2873 : this.getBaseMoveSpeed());
    if (!this.disabling || !OptionManager.getOption("Boost", this).value || !OptionManager.getOption("Bhop", this).value) {
        super.onEnable();
    }
}

@Override
public void onDisable() {
    Timer.timerSpeed = 1.0f;
    this.moveSpeed = this.getBaseMoveSpeed();
    if (OptionManager.getOption("Boost", this).value) {
        this.spedUp = false;
        this.disabling = true;
    }
    else {
        Speed.yOffset = 0.0;
        this.stage = 0;
        this.disabling = false;
        super.onDisable();
    }
}

@Nullable
public static Timer getTimer() {
  if (timerField == null) {
    return null;
  }
  try {
    return (Timer) timerField.get(Minecraft.getMinecraft());
  } catch (Exception e) {
    e.printStackTrace();
    return null;
  }
}

public static float getPartialTick()
{
    try {
        Timer t = (Timer)MekanismUtils.getPrivateValue(Minecraft.getMinecraft(), Minecraft.class, ObfuscatedNames.Minecraft_timer);
        return t.renderPartialTicks;
    } catch(Exception e) {}

    return 0;
}

@Override
protected void doDisable() {
    // check if it's still modified
    if (!(minecraftGetTimer(MC) instanceof FixedTimer)) {
        L.warn("Timer is already restored!");
        return;
    }

    // restore default timer
    minecraftSetTimer(MC, new Timer(defaultTps));
}

default Timer minecraftGetTimer(Minecraft mc) {
    try {
        return ReflectionHelper.getPrivateValue(Minecraft.class, mc, PrivateAccessor.MINECRAFT_TIMER);
    } catch (Exception ex) {
        throw new RuntimeException("Can't get timer", ex);
    }
}

default void minecraftSetTimer(Minecraft mc, Timer timer) {
    try {
        ReflectionHelper.setPrivateValue(Minecraft.class, mc, timer, PrivateAccessor.MINECRAFT_TIMER);
    } catch (Exception ex) {
        throw new RuntimeException("Can't set timer", ex);
    }
}

default float timerGetTicksPerSecond(Timer timer) {
    try {
        return ReflectionHelper.getPrivateValue(Timer.class, timer, PrivateAccessor.TIMER_TICKSPERSECOND);
    } catch (Exception ex) {
        // hard-coded default
        return 20;
    }
}

default Timer getTimer(Minecraft mc) {
    try {
        return ReflectionHelper.getPrivateValue(Minecraft.class, mc, MINECRAFT_TIMER);
    } catch (Exception ex) {
        L.error("getTimer() failed", ex);
        return null;
    }
}

@Override
public void initRenders() {
    ClientRegistry.bindTileEntitySpecialRenderer(TileEntityPumpkin.class, new TileEntityPumpkinRenderer());

    ItemRendererPumpkin itemRendererPumpkin = new ItemRendererPumpkin();
    MinecraftForgeClient.registerItemRenderer(PumpkinCarvier.item_pumpkin, itemRendererPumpkin);
    MinecraftForgeClient.registerItemRenderer(PumpkinCarvier.item_lit_pumpkin, itemRendererPumpkin);

    mcTimer = (Timer) ReflectionHelper.getPrivateValue(Minecraft.class, Minecraft.getMinecraft(), PumpkinCarvier.F_TIMER);

    FMLCommonHandler.instance().bus().register(new TickHandlerPumpkin());
}

@Override
public Timer getTimer() {
    return timer;
}

private Timer getTimer() {
    return this.timer == null ? this.timer = ReflectionHelper.getPrivateValue(Minecraft.class, mc, "timer", "field_71428_T") : this.timer;
}

@SideOnly(Side.CLIENT)
public static Timer getTimer() {
    return ((mcTimer == null) ? (mcTimer = ReflectionHelper.getPrivateValue(
            Minecraft.class, Minecraft.getMinecraft(), "field_71428_T", "timer")) : mcTimer);
}

@Override
public void write() throws IOException {
    Dimension dim = fbc.getCaptureDimension();
    int widthViewport = dim.getWidth();
    int heightViewport = dim.getHeight();
    int bpp = fbc.getBytesPerPixel();

    double tilesX = widthTiled / (double) widthViewport;
    double tilesY = heightTiled / (double) heightViewport;

    int numTilesX = (int) Math.ceil(tilesX);
    int numTilesY = (int) Math.ceil(tilesY);

    Projection.zoom = tilesX <= tilesY ? tilesY : tilesX;

    EntityRenderer entityRenderer = MC.entityRenderer;
    Timer timer = getTimer(MC);

    fbc.setFlipColors(true);
    fbc.setFlipLines(false);

    modifySettings();

    try (FileChannel fc = FileChannel.open(file, READ, WRITE, CREATE)) {
        fc.write(buildTargaHeader(widthTiled, heightTiled, bpp * 8));

        long nanoTime = System.nanoTime();
        float partialTicks = timer == null ? 0 : timer.renderPartialTicks;

        for (int y = 0; y < numTilesY; y++) {
            for (int x = 0; x < numTilesX; x++) {
                // clip the captured frame if too big
                int tileWidth = Math.min(widthViewport, widthTiled - (widthViewport * x));
                int tileHeight = Math.min(heightViewport, heightTiled - (heightViewport * y));

                // update camera offset and zoom
                Projection.offsetX = (widthTiled - widthViewport - (widthViewport * x) * 2) / (double) widthViewport;
                Projection.offsetY = (heightTiled - heightViewport - (heightViewport * (tilesY - y - 1)) * 2) / (double) heightViewport;

                // render the tile
                entityRenderer.updateCameraAndRender(partialTicks, nanoTime);

                // get framebuffer
                fbc.capture();
                ByteBuffer frameBuffer = fbc.getByteBuffer();

                // copy viewport buffer into the tile buffer, row by row
                for (int i = 0; i < tileHeight; i++) {
                    // read row from viewport buffer
                    frameBuffer.clear();
                    frameBuffer.position(i * widthViewport * bpp);
                    frameBuffer.limit((i * widthViewport + tileWidth) * bpp);

                    // write row at tiled position
                    long o1 = (long) widthTiled * i;
                    long o2 = (long) widthTiled * heightViewport * y;
                    long o3 = (long) widthViewport * x;
                    fc.position((o1 + o2 + o3) * bpp + HEADER_SIZE);
                    fc.write(frameBuffer);
                }
            }
        }
    } finally {
        // restore camera settings
        Projection.zoom = 1;
        Projection.offsetX = 0;
        Projection.offsetY = 0;

        // restore game settings
        restoreSettings();
    }
}

@SideOnly(Side.CLIENT)
@Getter(field = F_TIMER, srg = true)
Timer getTimer(Minecraft mc);

/**
 * @return Returns the Game's Timer
 */
Timer getTimer();

@Accessor @Override public abstract Timer getTimer();

Timer getTimer();