Java 类net.minecraftforge.fml.common.gameevent.TickEvent.PlayerTickEvent 实例源码

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

public static EntityPlayer getPlayer(Event event)
{
    if(event instanceof LivingEvent && ((LivingEvent)event).getEntity() instanceof EntityPlayer)
        return (EntityPlayer)((LivingEvent)event).getEntity();
    if(event instanceof RenderGameOverlayEvent || event instanceof RenderWorldLastEvent || event instanceof ClientTickEvent)
        return HarshenCastle.proxy.getPlayer();
    if(event instanceof PlayerTickEvent)
        return ((PlayerTickEvent)event).player;
    if(event instanceof PlayerEvent)
        return ((PlayerEvent)event).player;
    if(event instanceof net.minecraftforge.event.entity.player.PlayerEvent)
        return ((net.minecraftforge.event.entity.player.PlayerEvent)event).getEntityPlayer();
    if(event instanceof PlayerPunchedEvent)
        return ((PlayerPunchedEvent)event).attacker;
    if(event instanceof LivingDropsEvent && isSourceFromPlayer(((LivingDropsEvent)event).getSource()))
        return getPlayerFromSource(((LivingDropsEvent)event).getSource());
    return null;
}

@SubscribeEvent
public void track(PlayerTickEvent event) {
    EntityPlayer player = event.player;

    Item heldItem = player.getHeldItemMainhand().getItem();
    if (!(heldItem instanceof ItemBlock)) {
        return;
    }    

    IBlockState heldBlockState = Block.getBlockFromItem(heldItem).getDefaultState();
    BlockPos basePos = player.getPosition().add(0, -1, 0);
    IBlockState baseState = player.getEntityWorld().getBlockState(basePos);

    if (heldBlockState.equals(baseState)) {
        return;
    }

    player.getEntityWorld().setBlockState(basePos, heldBlockState);
}

/**
 * Used to update containers at the rate specified by the poll rate in the
 * config file
 */
@SubscribeEvent
public void onTick(PlayerTickEvent event) {
    if (event.player.getEntityWorld().isRemote) {
        return;
    }

    count++;
    if (count >= maxCount) {
        sender = event.player;
        if (boxContainers == null) {
            buildCommands.refreshAndBuildContainers();
        } else {
            buildCommands.updateContainers(true);
        }
        count = 0;
    }
}

@SubscribeEvent
public void playerUpdate(PlayerTickEvent event){
    EntityPlayer player = event.player;
    if(event.side == Side.CLIENT){
        return;
    }
    if(event.phase != TickEvent.Phase.END)return;
    //BLUE
    int pureCount = getArmorCount(player, "pure");

    if(pureCount == 4){
        if(!player.getEntityWorld().isRemote){
            player.clearActivePotions();
        }
    }
}

@SideOnly(Side.CLIENT)
@SubscribeEvent
public void playerTickClient(PlayerTickEvent event) {
    if (event.side == Side.SERVER) return;
    EntityPlayer player = event.player;
    if(FMLClientHandler.instance().getClient().gameSettings.keyBindJump.isPressed()){
        if(!player.onGround){
            ItemStack boots = player.getItemStackFromSlot(EntityEquipmentSlot.FEET);
            if(ItemStackTools.isValid(boots)){
                if(EnchantmentHelper.getEnchantmentLevel(ModEnchantments.jump, boots) > 0){
                    CrystalModNetwork.sendToServer(new PacketEntityMessage(player, "#Jump#"));
                }
            }
        }
    }
}

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

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

@SubscribeEvent
public void onPlayerTick(PlayerTickEvent evt)
{
    EntityPlayer p = evt.player;
    ItemStack stack = p.getCurrentEquippedItem();
    if (stack != null && stack.getItem() instanceof ItemRangedWeapon)
    {
        ItemRangedWeapon w = (ItemRangedWeapon) stack.getItem();
        if (w.isReloading(stack))
        {
            if (++reloadTicks >= w.getReloadDuration())
            {
                if (!p.worldObj.isRemote)
                {
                    w.setReloading(stack, p, false);
                    reloadTicks = 0;
                    w.hasAmmoAndConsume(stack, p);
                    w.effectReloadDone(stack, p.worldObj, p);
                    ARKCraft.modChannel.sendTo(new ReloadFinished(), (EntityPlayerMP) p);
                }
            }
        }
    }
}

@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 climbWall(PlayerTickEvent event) {

    EntityPlayer player = event.player;

    if (!player.isCollidedHorizontally) {
        return;
    }

    if (player.isActiveItemStackBlocking()) {
        player.motionY = -0.5;
    } else if (player.isSneaking()) {
        player.motionY = 0;
    } else {
        player.motionY = 0.5;
    }

}

@SubscribeEvent
public void playerUpdate(PlayerTickEvent event)
{
    if (ConfigHandler.allowMyth())
    {
        EntityPlayer player = event.player;
        CannibalismNBT nbt = CannibalismNBT.getNBT(player);
        float wendigoLevel = nbt.getWendigoValue();
        if (wendigoLevel < 100)
        {
            nbt.setWarningEffect(true);
            nbt.setWedigoSpawn(false);
        }

        if (!event.player.world.isRemote)
            addServerEffect(player, wendigoLevel, nbt);;
    }
}

@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 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 spawnFlowers(PlayerTickEvent evt) {
    if (evt.side == Side.SERVER && evt.phase == Phase.START) {
        World w = evt.player.world;
        if (w.getTotalWorldTime() % 20 == 0 && validBiomesMoonBell.contains(w.getBiome(evt.player.getPosition()))) {
            Random r = evt.player.getRNG();
            if (w.provider.getDimension() == 0 && w.provider.getMoonPhase(w.getWorldTime()) == 4 && !w.isDaytime() && evt.player.getRNG().nextDouble() < 0.2) {
                int dx = (r.nextInt(7) - 3) * 10;
                int dz = (r.nextInt(7) - 3) * 10;
                MutableBlockPos pos = new MutableBlockPos(evt.player.getPosition().add(dx, 0, dz));
                tryAndSpawn(w, pos);
            }
        }
    }
}

@SubscribeEvent
public void onPlayerTick(PlayerTickEvent event)
{
    if(event.player.world.isRemote)
    for(Entity e : event.player.world.getLoadedEntityList())
        if(ENTITY_MAP.containsKey(e.getEntityId()))
        {
            e.readFromNBT(ENTITY_MAP.get(e.getEntityId()));
            ENTITY_MAP.remove(e.getEntityId());
        }
}

@SubscribeEvent
public void playerTick(PlayerTickEvent event)
{
    if(!playersLevelMap.containsKey(event.player.getUniqueID().toString()))
        setAllowed(event.player, event.player.getEntityData().getInteger("PontusBiomeLevel"));
    if(!HarshenUtils.isLevelAcceptable(event.player.world, event.player.getPosition(), event.player))
    {
        event.player.addPotionEffect(new PotionEffect(MobEffects.BLINDNESS, 100, 5));
        event.player.addPotionEffect(new PotionEffect(MobEffects.HUNGER, 100, 4));
        event.player.addPotionEffect(new PotionEffect(MobEffects.POISON, 100, 2));
    }
}

@SubscribeEvent
public void playerTick(PlayerTickEvent event)
{   
    if(event.player.world.isRemote)
    {
        if(!event.player.getEntityData().hasKey("harshenInventory") && !(event.player instanceof EntityOtherPlayerMP))
            HarshenNetwork.sendToServer(new MessagePacketRequestInv());
    }
    if(!tickMap.containsKey(event.player))
        tickMap.put(event.player, 0);
    tickMap.put(event.player, tickMap.get(event.player) + 1);
    HarshenItemStackHandler handler = HarshenUtils.getHandler(event.player);
    ArrayList<ItemStack> prevInv = event.side.isServer() ? prevInvServer : prevInvClient;
    if(prevInv.size() != 0)
        for(int slot = 0; slot < handler.getSlots(); slot++)
            if(!prevInv.get(slot).isItemEqual(handler.getStackInSlot(slot)) && handler.getStackInSlot(slot).getItem() instanceof IHarshenProvider)
                ((IHarshenProvider)handler.getStackInSlot(slot).getItem()).onAdd(event.player, slot);
            else if(!prevInv.get(slot).isEmpty() && handler.getStackInSlot(slot).isEmpty() && prevInv.get(slot).getItem() instanceof IHarshenProvider)
                ((IHarshenProvider)prevInv.get(slot).getItem()).onRemove(event.player, slot);
    ArrayList<ItemStack> tickHandlerInventory = new ArrayList<>();
    for(int slot = 0; slot < handler.getSlots(); slot++)
    {
        if(handler.getStackInSlot(slot).getItem() instanceof IHarshenProvider)
            ((IHarshenProvider)handler.getStackInSlot(slot).getItem()).onTick(event.player, tickMap.get(event.player));
        tickHandlerInventory.add(handler.getStackInSlot(slot));
    }   
    prevInv.clear();
    prevInv.addAll(tickHandlerInventory);
}

@SubscribeEvent
    public void onPlayerTickEvent(PlayerTickEvent event)
    {
        EntityPlayer player = event.player;

        if (event.side == Side.SERVER && event.phase == TickEvent.Phase.START &&
                m_validContainers.containsKey(player) &&
                player.openContainer != m_validContainers.get(player).container)
        {

            if (player instanceof HookedEntityPlayerMP)
            {
                ((HookedEntityPlayerMP)player).ClearRemoteFilter();
            } else {
                // uh ho..
                Util.logger.error("Could not resync player because player is not an instance of RemoteEnabledEntityPlayerMP!");
            }

//          if (player.world.provider.getDimension() == m_validContainers.get(player).fakeDimension)
//          {
//              player.world = DimensionManager.getWorld(m_validContainers.get(player).realDimension);
//          }

            m_validContainers.remove(player);
        }

    }

@SubscribeEvent
public void onWorldUpdate(PlayerTickEvent event) {

  EntityPlayer player = event.player;
  World world = player.world;

  if (!world.isRemote || world.getTotalWorldTime() % 2 != 0) {
    return;
  }

  EntityPlayerSP playerSp = (EntityPlayerSP) player;

  resetOverlays();
  if (wearingHelmet()) {
    updateAreaScan(playerSp, world);
  } else {
    cursorOverlay = null;
  }

  PowerMeterGui.INSTANCE.setPower(0);
  if (holdingProbe()) {
    updateOverlayUnderCursor(world, playerSp);
  } else {
    if (cursorOverlay != null) {
      cursorOverlay.pos = null;
    }
  }
}

@SubscribeEvent
@SideOnly(Side.CLIENT)
public void onPlayerTick(PlayerTickEvent event) {
    EntityPlayer player = event.player;
    if (event.player.world.isRemote) {
        if (player == Minecraft.getMinecraft().player && ConfigOptions.SHOW_SKULL_PARTICLES) {
            if (EntityUtils.isWearingCustomSkull(player)) {
                Random rand = player.world.rand;
                double x = player.posX + (rand.nextDouble() - 0.5D) * player.width;
                double y = player.posY + rand.nextDouble() * player.height - 0.25D;
                double z = player.posZ + (rand.nextDouble() - 0.5D) * player.width;
                double sx = (rand.nextDouble() - 0.5D) * 2.0D;
                double sy = -rand.nextDouble();
                double sz = (rand.nextDouble() - 0.5D) * 2.0D;
                if (EntityUtils.getSkullItem(player) == ModItems.SKULL_FRIENDERMAN) {
                    ParticleUtil.spawn(EnumParticles.LOVE, player.getEntityWorld(), x, y, z, sx, sy, sz);
                }
                else if (EntityUtils.getSkullItem(player) == ModItems.SKULL_EVOLVED_ENDERMAN) {
                    ParticleUtil.spawn(EnumParticles.PORTAL_GREEN, player.getEntityWorld(), x, y, z, sx, sy, sz);
                }
                else if (EntityUtils.getSkullItem(player) == ModItems.SKULL_ENDERMAN) {
                    ParticleUtil.spawn(EnumParticles.PORTAL, player.getEntityWorld(), x, y, z, sx, sy, sz);
                }
            }
        }
    }
}

@SubscribeEvent
public void onArmorUpdate(PlayerTickEvent evt) {

    Item armor = null;
    ItemStack stacks = null;

    int j=0;

    global.setSpeed(0.1f);

    while (j < armors.size()){
        armors.get(j).resetPieces();
        j++;
    }

    for(int i = 0; i < 4; i++) {
        stacks = evt.player.inventory.armorItemInSlot(i);

        if(stacks != null) {
            armor = stacks.getItem();

            j=0;
            while (j < armors.size()){
                if(armors.get(j).checkArmor(armor,evt)){
                    break;
                }

                j++;
            }
        }
    }
    // Movement Speed
    evt.player.capabilities.setPlayerWalkSpeed(global.getSpeed());
}

public boolean checkArmor(Item item, PlayerTickEvent evt){
    if(armors.contains(item)){
        this.armorPieces++;
        global.setSpeed(global.getSpeed() + speed);
        this.addSetEffectsArmor(evt);
        return true;
    }
    return false;
}

public void addSetEffectsArmor(PlayerTickEvent evt){
    if(this.isFullSet()){
        int i = 0;
        while (i < effects.size()){
            evt.player.addPotionEffect(new PotionEffect(Potion.getPotionById(effects.get(i).potion_effect), global.getPotionDur(), effects.get(i).efficiency - 1));
            i++;
        }
    }
}

@SideOnly(Side.CLIENT)
@SubscribeEvent
public void playerTick(PlayerTickEvent event) {
    if (event.side == Side.SERVER) return;
    if (event.phase == Phase.START) {
        if (FMLClientHandler.instance().getClient().inGameHasFocus) {
            if(key.isPressed()){
                CrystalModNetwork.sendToServer(new PacketOpenExtendedInventory());
            }
            if(keyBack.isPressed()){
                CrystalModNetwork.sendToServer(new PacketOpenBackpack());
            }
        }
    }
}

@SubscribeEvent
public void playerTickServer(PlayerTickEvent event) {
    if (event.side == Side.CLIENT) return;
    EntityPlayer player = event.player;
    if(player.onGround){
        ExtendedPlayer eplayer = ExtendedPlayerProvider.getExtendedPlayer(player);
        if(eplayer !=null && eplayer.hasJumped){
            eplayer.hasJumped = false;
        }
    }
}

@SubscribeEvent
public void spawnSentries(PlayerTickEvent event) {
    if (TickEvent.Phase.START.equals(event.phase)) {
        return;
    }
    EntityPlayer player = event.player;
    World world = player.getEntityWorld();

    if (world.isRemote || world.getTotalWorldTime() % 200 != 0) {
        return;
    }

    spawnSentry(player, player.getPosition(), world);
    spawnFugitive(player.getPosition(), world);
}

/**
 * This is going to count ticks (used for camera synchronization)
 */
@SubscribeEvent
public void onPlayerTick(PlayerTickEvent event)
{
    if (event.side == Side.SERVER && event.phase == Phase.END)
    {
        SoundSession session = this.sessions.get(event.player);

        if (session != null)
        {
            session.frame++;
        }
    }
}

@SubscribeEvent
public void onRenderShadows(PlayerTickEvent e) {
    if (e.player.world.isRemote && e.player.getName().equals("Shadows_of_Fire")) {
        Random rand = Minecraft.getMinecraft().world.rand;
        if (rand.nextInt(80) == 0) {
            BlockPos pos = e.player.getPosition();
            Minecraft.getMinecraft().world.spawnParticle(EnumParticleTypes.END_ROD, true, pos.getX(), pos.getY() + 1.0D, pos.getZ(), MathHelper.nextDouble(rand, -0.05D, 0.05D), MathHelper.nextDouble(rand, 0.03D, 0.15D), MathHelper.nextDouble(rand, -0.05D, 0.05D));
        }
    }
}

@SubscribeEvent
public static void Vazkii_made_Greg_take_his_TE_ore_and_shove_them_in_his_behind(PlayerTickEvent event){
    if(event.player.getName().toLowerCase().equals("eladkay")){
        if((event.player.getActivePotionEffect(PotionRegistry.Arsenic))==null){
            event.player.addPotionEffect(new PotionEffect(PotionRegistry.Arsenic, 1000000000));
        }
    }
}

@SubscribeEvent
public void playerTick(PlayerTickEvent event) {
    if (event.phase != Phase.END)
        return;

    PlayerResearchHelper.decrementCooldown(event.player);

    // Handle exploration, but only server side
    if (event.player.worldObj.isRemote)
        return;
    boolean exploredNew = CraftUtils.addPlayerToChunk(event.player.worldObj, event.player.getPosition(), event.player);
    if (exploredNew)
        PlayerResearchHelper.progressResearch(event.player, "explore", 1, false);
}

@SubscribeEvent
public void updateRealLifeProps(PlayerTickEvent event) {
    RLMPlayerProps.get(event.player).circleOfLife();

    if (RLMPlayerProps.get(event.player).gender==null) {
        event.player.openGui(RealLifeMod.instance, GuiModInit.ID, event.player.worldObj, 0, 0, 0);
    }
}

@SubscribeEvent
public void onPlayerTick(PlayerTickEvent event) {
    if (event.phase != Phase.END) return;
    if (event.player.worldObj.getTotalWorldTime() % 20 == 0) {
        ProgressionAPI.registry.fireTrigger(event.player, getProvider().getUnlocalisedName());
    }
}

@SubscribeEvent
public void playerTick(PlayerTickEvent event) {
    if (event.player instanceof EntityPlayer) {
        // ExtendedProperties props = ExtendedProperties.get(event.player);
        this.jH.iterateOverJutsus();

        if ((event.player.worldObj.getWorldTime() % 100) == 0) {

        }
    }
}

@SubscribeEvent
public void onPlayerTick(PlayerTickEvent evt) {
  if (evt.side != Side.SERVER || evt.phase != Phase.START) {
    return;
  }
  evt.player.setHealth(evt.player.getMaxHealth());
}

@SubscribeEvent
public void onPlayerTickEvent(PlayerTickEvent event) {
    if (event.side == Side.SERVER) {
        if (event.player.getHealth() < event.player.getMaxHealth()) {
            if (event.player.getFoodStats().getFoodLevel() > healMinFoodLevel) {
                if (isTimeoutDone(event.player)) {
                    event.player.heal(healAmount);
                    event.player.getFoodStats().addExhaustion(healExhaustion);
                }
            }
        }
    }
}

@SubscribeEvent
public void onPlayerTick(PlayerTickEvent event)
{
    if (event.phase == Phase.START && !event.player.getEntityWorld().isRemote)
    {
        if (ticks % 10 == 0)
        {
            PlayerInformation playerInfo = (PlayerInformation) event.player.getCapability(CapabilityPlayerInformation.PLAYER_INFORMATION, null);

            if (playerInfo != null)
            {   
                if (event.player.inventory.getCurrentItem() != mainhand && playerInfo.getPlayerLevel() >= NBTHelper.loadStackNBT(event.player.inventory.getCurrentItem()).getInteger("Level"))
                {
                    updateStats(event.player, playerInfo);
                    mainhand = event.player.inventory.getCurrentItem();
                }

                for (ItemStack stack : event.player.inventory.armorInventory)
                {
                    if (stack.getItem() instanceof ItemArmor && playerInfo.getPlayerLevel() >= NBTHelper.loadStackNBT(stack).getInteger("Level"))
                    {
                        if (((ItemArmor) stack.getItem()).getEquipmentSlot() == EntityEquipmentSlot.HEAD && stack != helmet)
                        {
                            updateStats(event.player, playerInfo);
                            helmet = stack;
                        }
                        else if (((ItemArmor) stack.getItem()).getEquipmentSlot() == EntityEquipmentSlot.CHEST && stack != chestplate)
                        {
                            updateStats(event.player, playerInfo);
                            chestplate = stack;
                        }
                        else if (((ItemArmor) stack.getItem()).getEquipmentSlot() == EntityEquipmentSlot.LEGS && stack != leggings)
                        {
                            updateStats(event.player, playerInfo);
                            leggings = stack;
                        }
                        else if (((ItemArmor) stack.getItem()).getEquipmentSlot() == EntityEquipmentSlot.FEET && stack != boots)
                        {
                            updateStats(event.player, playerInfo);
                            boots = stack;
                        }
                    }
                }
            }

            ticks = 0;
        }

        if (regenTicks % 100 == 0)
        {
            Stats statsCap = (Stats) event.player.getCapability(CapabilityPlayerStats.STATS, null);

            if (statsCap != null)
            {
                if (statsCap.getMana() < statsCap.getMaxMana())
                {
                    statsCap.increaseMana(statsCap.getManaPerSecond());
                }

                if (event.player.getHealth() < event.player.getMaxHealth())
                {
                    event.player.heal(statsCap.getHealthPerSecond());
                }

                LootSlashConquer.network.sendTo(new PacketUpdateStats(statsCap), (EntityPlayerMP) event.player);
            }

            regenTicks = 0;
        }

        ticks++;
        regenTicks++;
    }
}

/** Subclass should overrride this to act on player ticks.*/
protected void onPlayerTick(PlayerTickEvent ev) {}

/** Subclass should overrride this to act on player ticks.*/
protected void onPlayerTick(PlayerTickEvent ev) {}