@Override
  public void attackEntityWithRangedAttack(EntityLivingBase target, float p_82196_2_) {

    double d0 = target.posY + (double) target.getEyeHeight() - 1.100000023841858D;
    double x = target.posX - this.posX;
    double y = d0 - this.posY - this.getEyeHeight();
    double z = target.posZ - this.posZ;
    float f = MathHelper.sqrt_double(x * x + z * z) * 0.2F;

    if (this.rand.nextInt(10) != 0) {
      EntityAttackSnoball entitysnowball = new EntityAttackSnoball(this.worldObj, this);
      entitysnowball.setThrowableHeading(x, y + (double) f, z, 1.6F, 5.0F);
      this.playSound(
          SoundEvents.ENTITY_SNOWMAN_SHOOT, 1.0F, 1.0F / (this.getRNG().nextFloat() * 0.4F + 0.8F));
      this.worldObj.spawnEntityInWorld(entitysnowball);
    } else {
      this.playSound(
          SoundEvents.ENTITY_CHICKEN_HURT, 1.0F, 1.0F / (this.getRNG().nextFloat() * 0.4F + 0.8F));

      this.motionX = x * 1.2f;
      this.motionY = y * 1.2f;
      this.motionZ = z * 1.2f;

      this.rotationYaw = (float) (MathHelper.atan2(x, z) * (180D / Math.PI));
      this.rotationPitch = (float) (MathHelper.atan2(x, (double) f) * (180D / Math.PI));
      this.prevRotationYaw = this.rotationYaw;
      this.prevRotationPitch = this.rotationPitch;
    }
  }
  /** Moves the entity based on the specified heading. */
  public void moveEntityWithHeading(float strafe, float forward) {
    Entity entity = this.getPassengers().isEmpty() ? null : (Entity) this.getPassengers().get(0);

    if (this.isBeingRidden() && this.canBeSteered()) {
      this.rotationYaw = entity.rotationYaw;
      this.prevRotationYaw = this.rotationYaw;
      this.rotationPitch = entity.rotationPitch * 0.5F;
      this.setRotation(this.rotationYaw, this.rotationPitch);
      this.renderYawOffset = this.rotationYaw;
      this.rotationYawHead = this.rotationYaw;
      this.stepHeight = 1.0F;
      this.jumpMovementFactor = this.getAIMoveSpeed() * 0.1F;

      if (this.canPassengerSteer()) {
        float f =
            (float)
                    this.getEntityAttribute(SharedMonsterAttributes.MOVEMENT_SPEED)
                        .getAttributeValue()
                * 0.225F;

        if (this.boosting) {
          if (this.boostTime++ > this.totalBoostTime) {
            this.boosting = false;
          }

          f +=
              f
                  * 1.15F
                  * MathHelper.sin(
                      (float) this.boostTime / (float) this.totalBoostTime * (float) Math.PI);
        }

        this.setAIMoveSpeed(f);
        super.moveEntityWithHeading(0.0F, 1.0F);
      } else {
        this.motionX = 0.0D;
        this.motionY = 0.0D;
        this.motionZ = 0.0D;
      }

      this.prevLimbSwingAmount = this.limbSwingAmount;
      double d1 = this.posX - this.prevPosX;
      double d0 = this.posZ - this.prevPosZ;
      float f1 = MathHelper.sqrt_double(d1 * d1 + d0 * d0) * 4.0F;

      if (f1 > 1.0F) {
        f1 = 1.0F;
      }

      this.limbSwingAmount += (f1 - this.limbSwingAmount) * 0.4F;
      this.limbSwing += this.limbSwingAmount;
    } else {
      this.stepHeight = 0.5F;
      this.jumpMovementFactor = 0.02F;
      super.moveEntityWithHeading(strafe, forward);
    }
  }
Example #3
0
  public MapGenVillage(Map<String, String> map) {
    this();

    for (Entry<String, String> entry : map.entrySet()) {
      if (((String) entry.getKey()).equals("size")) {
        this.size = MathHelper.parseIntWithDefaultAndMax((String) entry.getValue(), this.size, 0);
      } else if (((String) entry.getKey()).equals("distance")) {
        this.distance =
            MathHelper.parseIntWithDefaultAndMax((String) entry.getValue(), this.distance, 9);
      }
    }
  }
    public void renderIcon(float p_178663_1_, int alpha) {
      int i = -1;
      String s = FontRenderer.getFormatFromString(this.team.getColorPrefix());

      if (s.length() >= 2) {
        i = Minecraft.getMinecraft().fontRendererObj.getColorCode(s.charAt(1));
      }

      if (i >= 0) {
        float f = (float) (i >> 16 & 255) / 255.0F;
        float f1 = (float) (i >> 8 & 255) / 255.0F;
        float f2 = (float) (i & 255) / 255.0F;
        Gui.drawRect(
            1,
            1,
            15,
            15,
            MathHelper.rgb(f * p_178663_1_, f1 * p_178663_1_, f2 * p_178663_1_) | alpha << 24);
      }

      Minecraft.getMinecraft().getTextureManager().bindTexture(this.location);
      GlStateManager.color(p_178663_1_, p_178663_1_, p_178663_1_, (float) alpha / 255.0F);
      Gui.drawScaledCustomSizeModalRect(2, 2, 8.0F, 8.0F, 8, 8, 12, 12, 64.0F, 64.0F);
      Gui.drawScaledCustomSizeModalRect(2, 2, 40.0F, 8.0F, 8, 8, 12, 12, 64.0F, 64.0F);
    }
Example #5
0
 private static int getFlow(Optional<IExtendedBlockState> stateOption) {
   Float flow = -1000f;
   if (stateOption.isPresent()) {
     flow = stateOption.get().getValue(BlockFluidBase.FLOW_DIRECTION);
     if (flow == null) flow = -1000f;
   }
   int flowRound = (int) Math.round(Math.toDegrees(flow));
   flowRound = MathHelper.clamp_int(flowRound, -1000, 1000);
   return flowRound;
 }
 @SideOnly(Side.CLIENT)
 public EntityWandFireball(
     World worldIn, double x, double y, double z, double accelX, double accelY, double accelZ) {
   super(worldIn);
   this.setSize(1.0F, 1.0F);
   this.setLocationAndAngles(x, y, z, this.rotationYaw, this.rotationPitch);
   this.setPosition(x, y, z);
   double d0 =
       (double) MathHelper.sqrt_double(accelX * accelX + accelY * accelY + accelZ * accelZ);
   this.accelerationX = accelX / d0 * 0.1D;
   this.accelerationY = accelY / d0 * 0.1D;
   this.accelerationZ = accelZ / d0 * 0.1D;
 }
  protected void preRenderCallback(EntityAntiCreeper par1EntityAntiCreeper, float par2) {
    float f1 = par1EntityAntiCreeper.getCreeperFlashIntensity(par2);
    float f2 = 1.0F + MathHelper.sin(f1 * 100.0F) * f1 * 0.01F;

    if (f1 < 0.0F) f1 = 0.0F;

    if (f1 > 1.0F) f1 = 1.0F;

    f1 *= f1;
    f1 *= f1;
    float f3 = (1.0F + f1 * 0.4F) * f2;
    float f4 = (1.0F + f1 * 0.1F) / f2;
    GL11.glScalef(f3, f4, f3);
  }
Example #8
0
 /**
  * Returns the euler angles from position 1 to position 2.
  *
  * <p>The returned vector has Y for yaw, and X for pitch. Measurements are in radians.
  *
  * @param pos1 Where we are
  * @param pos2 Where to look at
  */
 public static Vector getRotations(Vector pos1, Vector pos2) {
   Vector diff = pos2.minus(pos1);
   diff.normalize();
   double x = diff.x();
   double y = diff.y();
   double z = diff.z();
   double d0 = x;
   double d1 = y;
   double d2 = z;
   double d3 = (double) MathHelper.sqrt_double(d0 * d0 + d2 * d2);
   double rotY = Math.atan2(d2, d0) - Math.PI / 2;
   double rotX = -Math.atan2(d1, d3);
   double rotZ = 0;
   return new Vector(rotX, rotY, rotZ);
 }
  @Override
  protected void rotateCorpse(
      EntityDragonMinion par1EntityDragonMinion, float par2, float par3, float par4) {
    float f3 = (float) par1EntityDragonMinion.getMovementOffsets(7, par4)[0];
    float f4 =
        (float)
            (par1EntityDragonMinion.getMovementOffsets(5, par4)[1]
                - par1EntityDragonMinion.getMovementOffsets(10, par4)[1]);
    GL11.glRotatef(-f3, 0.0F, 1.0F, 0.0F);
    GL11.glRotatef(f4 * 10.0F, 1.0F, 0.0F, 0.0F);
    GL11.glTranslatef(0.0F, 0.0F, 1.0F);

    if (par1EntityDragonMinion.deathTime > 0) {
      float f5 = (par1EntityDragonMinion.deathTime + par4 - 1.0F) / 20.0F * 1.6F;
      f5 = MathHelper.sqrt_float(f5);

      if (f5 > 1.0F) f5 = 1.0F;

      GL11.glRotatef(f5 * getDeathMaxRotation(par1EntityDragonMinion), 0.0F, 0.0F, 1.0F);
    }
  }
 public void renderParticle(
     VertexBuffer worldRendererIn,
     Entity entityIn,
     float partialTicks,
     float rotationX,
     float rotationZ,
     float rotationYZ,
     float rotationXY,
     float rotationXZ) {
   float f = ((float) this.particleAge + partialTicks) / (float) this.particleMaxAge * 32.0F;
   f = MathHelper.clamp_float(f, 0.0F, 1.0F);
   this.particleScale = this.smokeParticleScale * f;
   super.renderParticle(
       worldRendererIn,
       entityIn,
       partialTicks,
       rotationX,
       rotationZ,
       rotationYZ,
       rotationXY,
       rotationXZ);
 }
 @Override
 public void onBlockPlacedBy(
     World world, BlockPos pos, IBlockState state, EntityLivingBase player, ItemStack stack) {
   int l = MathHelper.floor_double((double) (player.rotationYaw * 4.0F / 360.0F) + 2.5D) & 3;
   world.setBlockState(pos, getDefaultState().withProperty(FACING, EnumFacing.fromAngle(90 * l)));
 }
Example #12
0
 public byte getByte() {
   return (byte) (MathHelper.floor_float(this.data) & 255);
 }
Example #13
0
 public short getShort() {
   return (short) (MathHelper.floor_float(this.data) & 65535);
 }
Example #14
0
 public int getInt() {
   return MathHelper.floor_float(this.data);
 }
Example #15
0
    public BakedFluid(
        Optional<TRSRTransformation> transformation,
        ImmutableMap<TransformType, TRSRTransformation> transforms,
        VertexFormat format,
        int color,
        TextureAtlasSprite still,
        TextureAtlasSprite flowing,
        boolean gas,
        boolean statePresent,
        int[] cornerRound,
        int flowRound) {
      this.transformation = transformation;
      this.transforms = transforms;
      this.format = format;
      this.color = color;
      this.still = still;
      this.flowing = flowing;
      this.gas = gas;

      faceQuads = Maps.newEnumMap(EnumFacing.class);
      for (EnumFacing side : EnumFacing.values()) {
        faceQuads.put(side, ImmutableList.<BakedQuad>of());
      }

      if (statePresent) {
        float[] y = new float[4];
        for (int i = 0; i < 4; i++) {
          if (gas) {
            y[i] = 1 - cornerRound[i] / 768f;
          } else {
            y[i] = cornerRound[i] / 768f;
          }
        }

        float flow = (float) Math.toRadians(flowRound);

        // top

        TextureAtlasSprite topSprite = flowing;
        float scale = 4;
        if (flow < -17F) {
          flow = 0;
          scale = 8;
          topSprite = still;
        }

        float c = MathHelper.cos(flow) * scale;
        float s = MathHelper.sin(flow) * scale;

        EnumFacing side = gas ? EnumFacing.DOWN : EnumFacing.UP;
        UnpackedBakedQuad.Builder builder;
        ImmutableList.Builder<BakedQuad> topFaceBuilder = ImmutableList.builder();
        for (int k = 0; k < 2; k++) {
          builder = new UnpackedBakedQuad.Builder(format);
          builder.setQuadOrientation(side);
          builder.setTexture(topSprite);
          for (int i = gas ? 3 : 0; i != (gas ? -1 : 4); i += (gas ? -1 : 1)) {
            int l = (k * 3) + (1 - 2 * k) * i;
            putVertex(
                builder,
                side,
                x[l],
                y[l],
                z[l],
                topSprite.getInterpolatedU(8 + c * (x[l] * 2 - 1) + s * (z[l] * 2 - 1)),
                topSprite.getInterpolatedV(
                    8 + c * (x[(l + 1) % 4] * 2 - 1) + s * (z[(l + 1) % 4] * 2 - 1)));
          }
          topFaceBuilder.add(builder.build());
        }
        faceQuads.put(side, topFaceBuilder.build());

        // bottom

        side = side.getOpposite();
        builder = new UnpackedBakedQuad.Builder(format);
        builder.setQuadOrientation(side);
        builder.setTexture(still);
        for (int i = gas ? 3 : 0; i != (gas ? -1 : 4); i += (gas ? -1 : 1)) {
          putVertex(
              builder,
              side,
              z[i],
              gas ? 1 : 0,
              x[i],
              still.getInterpolatedU(z[i] * 16),
              still.getInterpolatedV(x[i] * 16));
        }
        faceQuads.put(side, ImmutableList.<BakedQuad>of(builder.build()));

        // sides

        for (int i = 0; i < 4; i++) {
          side = EnumFacing.getHorizontal((5 - i) % 4);
          BakedQuad q[] = new BakedQuad[2];

          for (int k = 0; k < 2; k++) {
            builder = new UnpackedBakedQuad.Builder(format);
            builder.setQuadOrientation(side);
            builder.setTexture(flowing);
            for (int j = 0; j < 4; j++) {
              int l = (k * 3) + (1 - 2 * k) * j;
              float yl = z[l] * y[(i + x[l]) % 4];
              if (gas && z[l] == 0) yl = 1;
              putVertex(
                  builder,
                  side,
                  x[(i + x[l]) % 4],
                  yl,
                  z[(i + x[l]) % 4],
                  flowing.getInterpolatedU(x[l] * 8),
                  flowing.getInterpolatedV((gas ? yl : 1 - yl) * 8));
            }
            q[k] = builder.build();
          }
          faceQuads.put(side, ImmutableList.of(q[0], q[1]));
        }
      } else {
        // 1 quad for inventory
        UnpackedBakedQuad.Builder builder = new UnpackedBakedQuad.Builder(format);
        builder.setQuadOrientation(EnumFacing.UP);
        builder.setTexture(still);
        for (int i = 0; i < 4; i++) {
          putVertex(
              builder,
              EnumFacing.UP,
              z[i],
              x[i],
              0,
              still.getInterpolatedU(z[i] * 16),
              still.getInterpolatedV(x[i] * 16));
        }
        faceQuads.put(EnumFacing.SOUTH, ImmutableList.<BakedQuad>of(builder.build()));
      }
    }
Example #16
0
  // Copied from vanila skull itemBlock. Relevant edits are indicated.
  @Nonnull
  @Override
  public EnumActionResult onItemUse(
      ItemStack stack,
      EntityPlayer playerIn,
      World worldIn,
      BlockPos pos,
      EnumHand hand,
      EnumFacing facing,
      float hitX,
      float hitY,
      float hitZ) {
    if (facing == EnumFacing.DOWN) {
      return EnumActionResult.FAIL;
    } else {
      if (worldIn.getBlockState(pos).getBlock().isReplaceable(worldIn, pos)) {
        facing = EnumFacing.UP;
        pos = pos.down();
      }
      IBlockState iblockstate = worldIn.getBlockState(pos);
      Block block = iblockstate.getBlock();
      boolean flag = block.isReplaceable(worldIn, pos);

      if (!flag) {
        if (!worldIn.getBlockState(pos).getMaterial().isSolid()
            && !worldIn.isSideSolid(pos, facing, true)) {
          return EnumActionResult.FAIL;
        }

        pos = pos.offset(facing);
      }

      if (playerIn.canPlayerEdit(pos, facing, stack)
          && Blocks.SKULL.canPlaceBlockAt(worldIn, pos)) {
        if (worldIn.isRemote) {
          return EnumActionResult.SUCCESS;
        } else {
          worldIn.setBlockState(
              pos,
              ModBlocks.gaiaHead.getDefaultState().withProperty(BlockSkull.FACING, facing),
              11); // Botania - skull -> gaia head
          int i = 0;

          if (facing == EnumFacing.UP) {
            i = MathHelper.floor_double(playerIn.rotationYaw * 16.0F / 360.0F + 0.5D) & 15;
          }

          TileEntity tileentity = worldIn.getTileEntity(pos);

          if (tileentity instanceof TileEntitySkull) {
            TileEntitySkull tileentityskull = (TileEntitySkull) tileentity;

            if (stack.getMetadata() == 3) // Botania - do not retrieve skins
            {
              /*GameProfile gameprofile = null;

              if (stack.hasTagCompound())
              {
              	NBTTagCompound nbttagcompound = stack.getTagCompound();

              	if (nbttagcompound.hasKey("SkullOwner", 10))
              	{
              		gameprofile = NBTUtil.readGameProfileFromNBT(nbttagcompound.getCompoundTag("SkullOwner"));
              	}
              	else if (nbttagcompound.hasKey("SkullOwner", 8) && !nbttagcompound.getString("SkullOwner").isEmpty())
              	{
              		gameprofile = new GameProfile((UUID)null, nbttagcompound.getString("SkullOwner"));
              	}
              }

              tileentityskull.setPlayerProfile(gameprofile);*/
            } else {
              tileentityskull.setType(3); // Botania - Force type to 3 (humanoid)
            }

            tileentityskull.setSkullRotation(i);
            Blocks.SKULL.checkWitherSpawn(worldIn, pos, tileentityskull);
          }

          --stack.stackSize;
          return EnumActionResult.SUCCESS;
        }
      } else {
        return EnumActionResult.FAIL;
      }
    }
  }
  /** Renders the desired {@code T} type Entity. */
  public void doRender(
      EntityFishHook entity, double x, double y, double z, float entityYaw, float partialTicks) {
    GlStateManager.pushMatrix();
    GlStateManager.translate((float) x, (float) y, (float) z);
    GlStateManager.enableRescaleNormal();
    GlStateManager.scale(0.5F, 0.5F, 0.5F);
    this.bindEntityTexture(entity);
    Tessellator tessellator = Tessellator.getInstance();
    VertexBuffer vertexbuffer = tessellator.getBuffer();
    int i = 1;
    int j = 2;
    float f = 0.0625F;
    float f1 = 0.125F;
    float f2 = 0.125F;
    float f3 = 0.1875F;
    float f4 = 1.0F;
    float f5 = 0.5F;
    float f6 = 0.5F;
    GlStateManager.rotate(180.0F - this.renderManager.playerViewY, 0.0F, 1.0F, 0.0F);
    GlStateManager.rotate(
        (float) (this.renderManager.options.thirdPersonView == 2 ? -1 : 1)
            * -this.renderManager.playerViewX,
        1.0F,
        0.0F,
        0.0F);

    if (this.renderOutlines) {
      GlStateManager.enableColorMaterial();
      GlStateManager.enableOutlineMode(this.getTeamColor(entity));
    }

    vertexbuffer.begin(7, DefaultVertexFormats.POSITION_TEX_NORMAL);
    vertexbuffer.pos(-0.5D, -0.5D, 0.0D).tex(0.0625D, 0.1875D).normal(0.0F, 1.0F, 0.0F).endVertex();
    vertexbuffer.pos(0.5D, -0.5D, 0.0D).tex(0.125D, 0.1875D).normal(0.0F, 1.0F, 0.0F).endVertex();
    vertexbuffer.pos(0.5D, 0.5D, 0.0D).tex(0.125D, 0.125D).normal(0.0F, 1.0F, 0.0F).endVertex();
    vertexbuffer.pos(-0.5D, 0.5D, 0.0D).tex(0.0625D, 0.125D).normal(0.0F, 1.0F, 0.0F).endVertex();
    tessellator.draw();

    if (this.renderOutlines) {
      GlStateManager.disableOutlineMode();
      GlStateManager.disableColorMaterial();
    }

    GlStateManager.disableRescaleNormal();
    GlStateManager.popMatrix();

    if (entity.angler != null && !this.renderOutlines) {
      int k = entity.angler.getPrimaryHand() == EnumHandSide.RIGHT ? 1 : -1;
      float f7 = entity.angler.getSwingProgress(partialTicks);
      float f8 = MathHelper.sin(MathHelper.sqrt_float(f7) * (float) Math.PI);
      float f9 =
          (entity.angler.prevRenderYawOffset
                  + (entity.angler.renderYawOffset - entity.angler.prevRenderYawOffset)
                      * partialTicks)
              * 0.017453292F;
      double d0 = (double) MathHelper.sin(f9);
      double d1 = (double) MathHelper.cos(f9);
      double d2 = (double) k * 0.35D;
      double d3 = 0.8D;
      double d4;
      double d5;
      double d6;
      double d7;

      if ((this.renderManager.options == null || this.renderManager.options.thirdPersonView <= 0)
          && entity.angler == Minecraft.getMinecraft().thePlayer) {
        Vec3d vec3d = new Vec3d((double) k * -0.36D, -0.05D, 0.4D);
        vec3d =
            vec3d.rotatePitch(
                -(entity.angler.prevRotationPitch
                        + (entity.angler.rotationPitch - entity.angler.prevRotationPitch)
                            * partialTicks)
                    * 0.017453292F);
        vec3d =
            vec3d.rotateYaw(
                -(entity.angler.prevRotationYaw
                        + (entity.angler.rotationYaw - entity.angler.prevRotationYaw)
                            * partialTicks)
                    * 0.017453292F);
        vec3d = vec3d.rotateYaw(f8 * 0.5F);
        vec3d = vec3d.rotatePitch(-f8 * 0.7F);
        d4 =
            entity.angler.prevPosX
                + (entity.angler.posX - entity.angler.prevPosX) * (double) partialTicks
                + vec3d.xCoord;
        d5 =
            entity.angler.prevPosY
                + (entity.angler.posY - entity.angler.prevPosY) * (double) partialTicks
                + vec3d.yCoord;
        d6 =
            entity.angler.prevPosZ
                + (entity.angler.posZ - entity.angler.prevPosZ) * (double) partialTicks
                + vec3d.zCoord;
        d7 = (double) entity.angler.getEyeHeight();
      } else {
        d4 =
            entity.angler.prevPosX
                + (entity.angler.posX - entity.angler.prevPosX) * (double) partialTicks
                - d1 * d2
                - d0 * 0.8D;
        d5 =
            entity.angler.prevPosY
                + (double) entity.angler.getEyeHeight()
                + (entity.angler.posY - entity.angler.prevPosY) * (double) partialTicks
                - 0.45D;
        d6 =
            entity.angler.prevPosZ
                + (entity.angler.posZ - entity.angler.prevPosZ) * (double) partialTicks
                - d0 * d2
                + d1 * 0.8D;
        d7 = entity.angler.isSneaking() ? -0.1875D : 0.0D;
      }

      double d13 = entity.prevPosX + (entity.posX - entity.prevPosX) * (double) partialTicks;
      double d8 = entity.prevPosY + (entity.posY - entity.prevPosY) * (double) partialTicks + 0.25D;
      double d9 = entity.prevPosZ + (entity.posZ - entity.prevPosZ) * (double) partialTicks;
      double d10 = (double) ((float) (d4 - d13));
      double d11 = (double) ((float) (d5 - d8)) + d7;
      double d12 = (double) ((float) (d6 - d9));
      GlStateManager.disableTexture2D();
      GlStateManager.disableLighting();
      vertexbuffer.begin(3, DefaultVertexFormats.POSITION_COLOR);
      int l = 16;

      for (int i1 = 0; i1 <= 16; ++i1) {
        float f10 = (float) i1 / 16.0F;
        vertexbuffer
            .pos(
                x + d10 * (double) f10,
                y + d11 * (double) (f10 * f10 + f10) * 0.5D + 0.25D,
                z + d12 * (double) f10)
            .color(0, 0, 0, 255)
            .endVertex();
      }

      tessellator.draw();
      GlStateManager.enableLighting();
      GlStateManager.enableTexture2D();
      super.doRender(entity, x, y, z, entityYaw, partialTicks);
    }
  }
 public int getRedstoneLevel() {
   double fractionFull = (float) fluidTank.getFluidAmount() / (float) fluidTank.getCapacity();
   return MathHelper.floor_float((float) (fractionFull * 14.0F)) + (fractionFull > 0 ? 1 : 0);
 }
Example #19
0
 public static float calcAttackSpeedMod(EntityLivingBase entity) {
   int ticks = StatsUtil.getAttackTimer(entity);
   float scale = MathHelper.clamp_float((ticks + 0.5F) / getAttackCooldown(entity), 0.0F, 1.0F);
   return 0.2F + scale * scale * 0.8F;
 }