Чит адаптация 1.8.9

생성일: 2025년 1월 18일

질문

у меня есть короче Sprint от другого чита FORGE 1.8.9, функцию с внутренними настройками которые необходимо спастить в мой чит хотя у меня сурсы mcp 1.12.2, я вам скину всё сначала чтобы вы изучили, а далее я скину то что я лично имею, после чего вы сделаете всё чтобы под мой чит адаптировать, чтобы без ошибок, и тому прочее главное скидывайте с всем кодом класса того который вы изменили, или создали неважно, понятно? и без внутреннего объяснения в классах, сейчас скину то что мне надо спастить, напомню основной модуль чита который надо спастить мне это Sprint, далее я ниже скинул то что для его импортов нашел
Sprint.java (class) package net.ccbluex.liquidbounce.features.module.modules.movement

import net.ccbluex.liquidbounce.event.EventTarget
import net.ccbluex.liquidbounce.event.PacketEvent
import net.ccbluex.liquidbounce.event.UpdateEvent
import net.ccbluex.liquidbounce.features.module.Module
import net.ccbluex.liquidbounce.features.module.ModuleCategory
import net.ccbluex.liquidbounce.features.module.ModuleInfo
import net.ccbluex.liquidbounce.utils.MovementUtils
import net.ccbluex.liquidbounce.utils.Rotation
import net.ccbluex.liquidbounce.utils.RotationUtils
import net.ccbluex.liquidbounce.features.value.BoolValue
import net.ccbluex.liquidbounce.features.value.FloatValue
import net.ccbluex.liquidbounce.features.value.ListValue
import net.minecraft.network.play.client.C0BPacketEntityAction
import net.minecraft.potion.Potion

@ModuleInfo(name = "Sprint", category = ModuleCategory.MOVEMENT, defaultOn = true)
class Sprint : Module() {
val jumpDirectionsValue = BoolValue("JumpDirections", false)
val allDirectionsValue = BoolValue("AllDirections", true)
private val allDirectionsBypassValue = ListValue("AllDirectionsBypass", arrayOf("Rotate", "Rotate2", "Toggle", "Minemora", "Spoof", "LimitSpeed", "None"), "None").displayable { allDirectionsValue.get() }
private val blindnessValue = BoolValue("Blindness", true)
val useItemValue = BoolValue("UseItem", false)
val foodValue = BoolValue("Food", true)
private val noStopServerSide = BoolValue("ServerSideKeepSprint", false).displayable { !noPacket.get() }
val checkServerSide = BoolValue("CheckServerSide", false)
val checkServerSideGround = BoolValue("CheckServerSideOnlyGround", false).displayable { checkServerSide.get() }
private val noPacket = BoolValue("NoPacket", false)
private val allDirectionsLimitSpeedGround = BoolValue("AllDirectionsLimitSpeedOnlyGround", true)
private val allDirectionsLimitSpeedValue = FloatValue("AllDirectionsLimitSpeed", 0.7f, 0.5f, 1f).displayable { allDirectionsBypassValue.displayable && allDirectionsBypassValue.equals("LimitSpeed") }

private var spoofStat = false
set(value) {
if (field != value) {
if (value) {
mc.netHandler.addToSendQueue(C0BPacketEntityAction(mc.thePlayer, C0BPacketEntityAction.Action.STOP_SPRINTING))
} else {
mc.netHandler.addToSendQueue(C0BPacketEntityAction(mc.thePlayer, C0BPacketEntityAction.Action.START_SPRINTING))
}
field = value
}
}

@EventTarget
fun onUpdate(event: UpdateEvent) {
mc.thePlayer.isSprinting = true

if (!MovementUtils.isMoving() || mc.thePlayer.isSneaking || blindnessValue.get() &&
mc.thePlayer.isPotionActive(Potion.blindness) || foodValue.get() &&
!(mc.thePlayer.foodStats.foodLevel > 6.0f || mc.thePlayer.capabilities.allowFlying) ||
(useItemValue.get() && mc.thePlayer.isUsingItem) ||
(checkServerSide.get() && (mc.thePlayer.onGround || !checkServerSideGround.get()) &&
!allDirectionsValue.get() && RotationUtils.targetRotation != null &&
RotationUtils.getRotationDifference(Rotation(mc.thePlayer.rotationYaw, mc.thePlayer.rotationPitch)) > 30)) {
mc.thePlayer.isSprinting = false
return
}

if (allDirectionsValue.get()) {
mc.thePlayer.isSprinting = true
if (RotationUtils.getRotationDifference(Rotation((MovementUtils.direction * 180f / Math.PI).toFloat(), mc.thePlayer.rotationPitch)) > 30) {
when (allDirectionsBypassValue.get().lowercase()) {
"rotate" -> RotationUtils.setTargetRotation(Rotation(MovementUtils.movingYaw, mc.thePlayer.rotationPitch), 10)
"rotate2" -> {
val movingForward = mc.thePlayer.moveForward > 0.0F
val movingBackward = mc.thePlayer.moveForward < 0.0F
val movingRight = mc.thePlayer.moveStrafing > 0.0F
val movingLeft = mc.thePlayer.moveStrafing < 0.0F

val movingSideways = movingLeft || movingRight
val movingStraight = movingForward || movingBackward
var direction = mc.thePlayer.rotationYaw

if(movingForward && !movingSideways) {
//
} else if(movingBackward && !movingSideways) {
direction += 180.0f
} else if(movingForward && movingLeft) {
direction += 45.0f
} else if(movingForward) {
direction -= 45.0f
} else if(!movingStraight && movingLeft) {
direction += 90.0f
} else if(!movingStraight && movingRight) {
direction -= 90.0f
} else if(movingBackward && movingRight) {
direction -= 135.0f
} else if(movingBackward) {
direction += 135.0f
}

RotationUtils.setTargetRotation(Rotation(direction, mc.thePlayer.rotationPitch), 10)

}
"toggle" -> {
mc.netHandler.addToSendQueue(C0BPacketEntityAction(mc.thePlayer, C0BPacketEntityAction.Action.STOP_SPRINTING))
mc.netHandler.addToSendQueue(C0BPacketEntityAction(mc.thePlayer, C0BPacketEntityAction.Action.START_SPRINTING))
}
"minemora" -> {
if (mc.thePlayer.onGround) {
mc.thePlayer.setPosition(mc.thePlayer.posX, mc.thePlayer.posY + 0.0000013, mc.thePlayer.posZ)
mc.thePlayer.motionY = 0.0
}
}
"limitspeed" -> {
if (!allDirectionsLimitSpeedGround.get() || mc.thePlayer.onGround) {
MovementUtils.limitSpeedByPercent(allDirectionsLimitSpeedValue.get())
}
}
"spoof" -> spoofStat = true
}
} else {
when (allDirectionsBypassValue.get().lowercase()) {
"spoof" -> spoofStat = false
}
}
}
}

@EventTarget
fun onPacket(event: PacketEvent) {
val packet = event.packet

if (noPacket.get() && packet is C0BPacketEntityAction && (packet.action == C0BPacketEntityAction.Action.START_SPRINTING || packet.action == C0BPacketEntityAction.Action.STOP_SPRINTING)) {
event.cancelEvent()
}
if (noStopServerSide.get() && packet is C0BPacketEntityAction && packet.action == C0BPacketEntityAction.Action.STOP_SPRINTING) {
event.cancelEvent()
}
}
}

MovementUtils.java (class)
/*
* FDPClient Hacked Client
* A free open source mixin-based injection hacked client for Minecraft using Minecraft Forge by LiquidBounce.
* https://github.com/SkidderMC/FDPClient/
*/
package net.ccbluex.liquidbounce.utils

import net.ccbluex.liquidbounce.event.MoveEvent
import net.minecraft.client.Minecraft
import net.minecraft.entity.EntityLivingBase
import net.minecraft.network.play.client.C03PacketPlayer.C04PacketPlayerPosition
import net.minecraft.potion.Potion
import net.minecraft.util.AxisAlignedBB
import kotlin.math.asin
import kotlin.math.cos
import kotlin.math.sin
import kotlin.math.sqrt

object MovementUtils : MinecraftInstance() {

fun resetMotion(y: Boolean) {
mc.thePlayer.motionX = 0.0
mc.thePlayer.motionZ = 0.0
if(y) mc.thePlayer.motionY = 0.0
}

fun getSpeed(): Float {
return sqrt(mc.thePlayer.motionX * mc.thePlayer.motionX + mc.thePlayer.motionZ * mc.thePlayer.motionZ).toFloat()
}

/**
* Calculate speed based on the speed potion effect level/amplifier
*/
fun getSpeedWithPotionEffects(speed: Double) =
mc.thePlayer.getActivePotionEffect(Potion.moveSpeed)?.let {
speed * (1 + (it.amplifier + 1) * 0.2)
} ?: speed

fun strafe() {
strafe(getSpeed())
}

fun move() {
move(getSpeed())
}

fun isMoving(): Boolean {
return mc.thePlayer != null && (mc.thePlayer.movementInput.moveForward != 0f || mc.thePlayer.movementInput.moveStrafe != 0f)
}

fun hasMotion(): Boolean {
return mc.thePlayer.motionX != 0.0 && mc.thePlayer.motionZ != 0.0 && mc.thePlayer.motionY != 0.0
}

fun strafe(speed: Float) {
if (!isMoving()) return
mc.thePlayer.motionX = -sin(direction) * speed
mc.thePlayer.motionZ = cos(direction) * speed
}

fun defaultSpeed(): Double {
var baseSpeed = 0.2873
if (Minecraft.getMinecraft().thePlayer.isPotionActive(Potion.moveSpeed)) {
val amplifier = Minecraft.getMinecraft().thePlayer.getActivePotionEffect(Potion.moveSpeed)
.amplifier
baseSpeed *= 1.0 + 0.2 * (amplifier + 1)
}
return baseSpeed
}

fun doTargetStrafe(curTarget: EntityLivingBase, direction_: Float, radius: Float, moveEvent: MoveEvent, mathRadius: Int = 0) {
if(!isMoving()) return

var forward_ = 0.0
var strafe_ = 0.0
val speed_ = sqrt(moveEvent.x * moveEvent.x + moveEvent.z * moveEvent.z)

if(speed_ <= 0.0001)
return

var _direction = 0.0
if(direction_ > 0.001) {
_direction = 1.0
}else if(direction_ < -0.001) {
_direction = -1.0
}
var curDistance = (0.01).toFloat()
if (mathRadius == 1) {
curDistance = mc.thePlayer.getDistanceToEntity(curTarget)
}else if (mathRadius == 0) {
curDistance = sqrt((mc.thePlayer.posX - curTarget.posX) * (mc.thePlayer.posX - curTarget.posX) + (mc.thePlayer.posZ - curTarget.posZ) * (mc.thePlayer.posZ - curTarget.posZ)).toFloat()
}
if(curDistance < radius - speed_) {
forward_ = -1.0
}else if(curDistance > radius + speed_) {
forward_ = 1.0
}else {
forward_ = (curDistance - radius) / speed_
}
if(curDistance < radius + speed_*2 && curDistance > radius - speed_*2) {
strafe_ = 1.0
}
strafe_ *= _direction
var strafeYaw = RotationUtils.getRotationsEntity(curTarget).yaw.toDouble()
val covert_ = sqrt(forward_ * forward_ + strafe_ * strafe_)

forward_ /= covert_
strafe_ /= covert_
var turnAngle = Math.toDegrees(asin(strafe_))
if(turnAngle > 0) {
if(forward_ < 0)
turnAngle = 180F - turnAngle
}else {
if(forward_ < 0)
turnAngle = -180F - turnAngle
}
strafeYaw = Math.toRadians((strafeYaw + turnAngle))
moveEvent.x = -sin(strafeYaw) * speed_
moveEvent.z = cos(strafeYaw) * speed_
mc.thePlayer.motionX = moveEvent.x
mc.thePlayer.motionZ = moveEvent.z
}

fun move(speed: Float) {
if (!isMoving()) return
val yaw = direction
mc.thePlayer.motionX += -sin(yaw) * speed
mc.thePlayer.motionZ += cos(yaw) * speed
}

fun limitSpeed(speed: Float) {
val yaw = direction
val maxXSpeed = -sin(yaw) * speed
val maxZSpeed = cos(yaw) * speed
if (mc.thePlayer.motionX > maxZSpeed) {
mc.thePlayer.motionX = maxXSpeed
}
if (mc.thePlayer.motionZ > maxZSpeed) {
mc.thePlayer.motionZ = maxZSpeed
}
}

/**
* make player move slowly like when using item
* @author liulihaocai
*/
fun limitSpeedByPercent(percent: Float) {
mc.thePlayer.motionX *= percent
mc.thePlayer.motionZ *= percent
}

fun forward(length: Double) {
val yaw = Math.toRadians(mc.thePlayer.rotationYaw.toDouble())
mc.thePlayer.setPosition(
mc.thePlayer.posX + -sin(yaw) * length,
mc.thePlayer.posY,
mc.thePlayer.posZ + cos(yaw) * length
)
}

val direction: Double
get() {
var rotationYaw = mc.thePlayer.rotationYaw
if (mc.thePlayer.moveForward < 0f) rotationYaw += 180f
var forward = 1f
if (mc.thePlayer.moveForward < 0f) forward = -0.5f else if (mc.thePlayer.moveForward > 0f) forward = 0.5f
if (mc.thePlayer.moveStrafing > 0f) rotationYaw -= 90f * forward
if (mc.thePlayer.moveStrafing < 0f) rotationYaw += 90f * forward
return Math.toRadians(rotationYaw.toDouble())
}

val jumpMotion: Float
get() {
var mot = 0.42f
if (mc.thePlayer.isPotionActive(Potion.jump)) {
mot += (mc.thePlayer.getActivePotionEffect(Potion.jump).amplifier + 1).toFloat() * 0.1f
}
return mot
}

val movingYaw: Float
get() = (direction * 180f / Math.PI).toFloat()

var bps = 0.0
private set
private var lastX = 0.0
private var lastY = 0.0
private var lastZ = 0.0

fun setMotion(speed: Double) {
var forward = mc.thePlayer.movementInput.moveForward.toDouble()
var strafe = mc.thePlayer.movementInput.moveStrafe.toDouble()
var yaw = mc.thePlayer.rotationYaw
if (forward == 0.0 && strafe == 0.0) {
mc.thePlayer.motionX = 0.0
mc.thePlayer.motionZ = 0.0
} else {
if (forward != 0.0) {
if (strafe > 0.0) {
yaw += (if (forward > 0.0) -45 else 45).toFloat()
} else if (strafe < 0.0) {
yaw += (if (forward > 0.0) 45 else -45).toFloat()
}
strafe = 0.0
if (forward > 0.0) {
forward = 1.0
} else if (forward < 0.0) {
forward = -1.0
}
}
val cos = cos(Math.toRadians((yaw + 90.0f).toDouble()))
val sin = sin(Math.toRadians((yaw + 90.0f).toDouble()))
mc.thePlayer.motionX = (forward * speed * cos +
strafe * speed * sin)
mc.thePlayer.motionZ = (forward * speed * sin -
strafe * speed * cos)
}
}

fun updateBlocksPerSecond() {
if (mc.thePlayer == null || mc.thePlayer.ticksExisted < 1) {
bps = 0.0
}
val distance = mc.thePlayer.getDistance(lastX, lastY, lastZ)
lastX = mc.thePlayer.posX
lastY = mc.thePlayer.posY
lastZ = mc.thePlayer.posZ
bps = distance * (20 * mc.timer.timerSpeed)
}

fun setSpeed(
moveEvent: MoveEvent,
moveSpeed: Double,
pseudoYaw: Float,
pseudoStrafe: Double,
pseudoForward: Double
) {
var forward = pseudoForward
var strafe = pseudoStrafe
var yaw = pseudoYaw
if (forward == 0.0 && strafe == 0.0) {
moveEvent.z = 0.0
moveEvent.x = 0.0
} else {
if (forward != 0.0) {
if (strafe > 0.0) {
yaw += (if (forward > 0.0) -45 else 45).toFloat()
} else if (strafe < 0.0) {
yaw += (if (forward > 0.0) 45 else -45).toFloat()
}
strafe = 0.0
if (forward > 0.0) {
forward = 1.0
} else if (forward < 0.0) {
forward = -1.0
}
}
val cos = cos(Math.toRadians((yaw + 90.0f).toDouble()))
val sin = sin(Math.toRadians((yaw + 90.0f).toDouble()))
moveEvent.x = forward * moveSpeed * cos + strafe * moveSpeed * sin
moveEvent.z = forward * moveSpeed * sin - strafe * moveSpeed * cos
}
}

private fun calculateGround(): Double {
val playerBoundingBox = mc.thePlayer.entityBoundingBox
var blockHeight = 1.0
var ground = mc.thePlayer.posY
while (ground > 0.0) {
val customBox = AxisAlignedBB(
playerBoundingBox.maxX,
ground + blockHeight,
playerBoundingBox.maxZ,
playerBoundingBox.minX,
ground,
playerBoundingBox.minZ
)
if (mc.theWorld.checkBlockCollision(customBox)) {
if (blockHeight <= 0.05) return ground + blockHeight
ground += blockHeight
blockHeight = 0.05
}
ground -= blockHeight
}
return 0.0
}

fun isOnGround(height: Double): Boolean {
return !mc.theWorld.getCollidingBoundingBoxes(mc.thePlayer, mc.thePlayer.entityBoundingBox.offset(0.0, -height, 0.0)).isEmpty()
}

fun getBaseMoveSpeed(): Double {
var baseSpeed = 0.2875
if (mc.thePlayer.isPotionActive(Potion.moveSpeed)) {
baseSpeed *= 1.0 + 0.2 * (mc.thePlayer.getActivePotionEffect(Potion.moveSpeed)
.getAmplifier() + 1)
}
return baseSpeed
}

fun handleVanillaKickBypass() {
val ground = calculateGround()
run {
var posY = mc.thePlayer.posY
while (posY > ground) {
mc.netHandler.addToSendQueue(C04PacketPlayerPosition(mc.thePlayer.posX, posY, mc.thePlayer.posZ, true))
if (posY - 8.0 < ground) break // Prevent next step
posY -= 8.0
}
}
mc.netHandler.addToSendQueue(C04PacketPlayerPosition(mc.thePlayer.posX, ground, mc.thePlayer.posZ, true))
var posY = ground
while (posY < mc.thePlayer.posY) {
mc.netHandler.addToSendQueue(C04PacketPlayerPosition(mc.thePlayer.posX, posY, mc.thePlayer.posZ, true))
if (posY + 8.0 > mc.thePlayer.posY) break // Prevent next step
posY += 8.0
}
mc.netHandler.addToSendQueue(
C04PacketPlayerPosition(
mc.thePlayer.posX,
mc.thePlayer.posY,
mc.thePlayer.posZ,
true
)
)
}

fun isBlockUnder(): Boolean {
if (mc.thePlayer == null) return false
if (mc.thePlayer.posY < 0.0) {
return false
}
var off = 0
while (off < mc.thePlayer.posY.toInt() + 2) {
val bb = mc.thePlayer.entityBoundingBox.offset(0.0, (-off).toDouble(), 0.0)
if (!mc.theWorld.getCollidingBoundingBoxes(mc.thePlayer, bb).isEmpty()) {
return true
}
off += 2
}
return false
}
}

Rotation.java (class)

package net.ccbluex.liquidbounce.utils

import net.ccbluex.liquidbounce.event.StrafeEvent
import net.ccbluex.liquidbounce.features.module.modules.client.Rotations
import net.ccbluex.liquidbounce.utils.block.PlaceInfo
import net.minecraft.entity.player.EntityPlayer
import net.minecraft.util.MathHelper
import net.minecraft.util.Vec3

/**
* Rotations
*/
data class Rotation(var yaw: Float, var pitch: Float) {

/**
* Set rotations to [player]
*/
fun toPlayer(player: EntityPlayer) {
if ((yaw.isNaN() || pitch.isNaN()) && Rotations.nanValue.get()) {
return
}

fixedSensitivity(MinecraftInstance.mc.gameSettings.mouseSensitivity)

player.rotationYaw = yaw
player.rotationPitch = pitch
}

/**
* Patch gcd exploit in aim
*
* @see net.minecraft.client.renderer.EntityRenderer.updateCameraAndRender
*/
fun fixedSensitivity(sensitivity: Float) {
if (Rotations.fixedValue.get() == "None") return
if (Rotations.fixedValue.get() == "Old") {
val f = sensitivity * 0.6F + 0.2F
val gcd = f * f * f * 1.2F

yaw -= yaw % gcd
pitch -= pitch % gcd
return
}
val f = sensitivity * 0.6F + 0.2F
val gcd = f * f * f * 1.2F

// get previous rotation
val rotation = RotationUtils.serverRotation

// fix yaw
var deltaYaw = yaw - rotation.yaw
deltaYaw -= deltaYaw % gcd
yaw = rotation.yaw + deltaYaw

// fix pitch
var deltaPitch = pitch - rotation.pitch
deltaPitch -= deltaPitch % gcd
pitch = rotation.pitch + deltaPitch
}

/**
* Apply strafe to player
*
* @author bestnub
*/
fun applyStrafeToPlayer(event: StrafeEvent) {
val player = MinecraftInstance.mc.thePlayer
val dif = ((MathHelper.wrapAngleTo180_float(player.rotationYaw - this.yaw -
23.5f - 135) +
180) / 45).toInt()

val yaw = this.yaw

val strafe = event.strafe
val forward = event.forward
val friction = event.friction

var calcForward = 0f
var calcStrafe = 0f

when (dif) {
0 -> {
calcForward = forward
calcStrafe = strafe
}
1 -> {
calcForward += forward
calcStrafe -= forward
calcForward += strafe
calcStrafe += strafe
}
2 -> {
calcForward = strafe
calcStrafe = -forward
}
3 -> {
calcForward -= forward
calcStrafe -= forward
calcForward += strafe
calcStrafe -= strafe
}
4 -> {
calcForward = -forward
calcStrafe = -strafe
}
5 -> {
calcForward -= forward
calcStrafe += forward
calcForward -= strafe
calcStrafe -= strafe
}
6 -> {
calcForward = -strafe
calcStrafe = forward
}
7 -> {
calcForward += forward
calcStrafe += forward
calcForward -= strafe
calcStrafe += strafe
}
}

if (calcForward > 1f || calcForward < 0.9f && calcForward > 0.3f || calcForward < -1f || calcForward > -0.9f && calcForward < -0.3f) {
calcForward *= 0.5f
}

if (calcStrafe > 1f || calcStrafe < 0.9f && calcStrafe > 0.3f || calcStrafe < -1f || calcStrafe > -0.9f && calcStrafe < -0.3f) {
calcStrafe *= 0.5f
}

var d = calcStrafe * calcStrafe + calcForward * calcForward

if (d >= 1.0E-4f) {
d = MathHelper.sqrt_float(d)
if (d < 1.0f) d = 1.0f
d = friction / d
calcStrafe *= d
calcForward *= d
val yawSin = MathHelper.sin((yaw * Math.PI / 180f).toFloat())
val yawCos = MathHelper.cos((yaw * Math.PI / 180f).toFloat())
player.motionX += calcStrafe * yawCos - calcForward * yawSin.toDouble()
player.motionZ += calcForward * yawCos + calcStrafe * yawSin.toDouble()
}
}

override fun toString(): String {
return "Rotation(yaw=$yaw, pitch=$pitch)"
}
}

/**
* Rotation with vector
*/
data class VecRotation(val vec: Vec3, val rotation: Rotation)

/**
* Rotation with place info
*/
data class PlaceRotation(val placeInfo: PlaceInfo, val rotation: Rotation)

RotationUtils.java (class)
/*
* FDPClient Hacked Client
* A free open source mixin-based injection hacked client for Minecraft using Minecraft Forge by LiquidBounce.
* https://github.com/SkidderMC/FDPClient/
*/
package net.ccbluex.liquidbounce.utils;

import net.ccbluex.liquidbounce.event.EventTarget;
import net.ccbluex.liquidbounce.event.Listenable;
import net.ccbluex.liquidbounce.event.PacketEvent;
import net.ccbluex.liquidbounce.event.TickEvent;
import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.network.Packet;
import net.minecraft.network.play.client.C03PacketPlayer;
import net.minecraft.util.*;
import org.jetbrains.annotations.NotNull;

import java.util.Random;

public final class RotationUtils extends MinecraftInstance implements Listenable {

private static Random random = new Random();

private static int keepLength;
private static int revTick;

public static Rotation targetRotation;
public static Rotation serverRotation = new Rotation(0F, 0F);

public static boolean keepCurrentRotation = false;

private static double x = random.nextDouble();
private static double y = random.nextDouble();
private static double z = random.nextDouble();

/**
* Face block
*
* @param blockPos target block
*/
public static VecRotation faceBlock(final BlockPos blockPos) {
if (blockPos == null)
return null;

VecRotation vecRotation = null;

for(double xSearch = 0.1D; xSearch < 0.9D; xSearch += 0.1D) {
for(double ySearch = 0.1D; ySearch < 0.9D; ySearch += 0.1D) {
for (double zSearch = 0.1D; zSearch < 0.9D; zSearch += 0.1D) {
final Vec3 eyesPos = new Vec3(mc.thePlayer.posX, mc.thePlayer.getEntityBoundingBox().minY + mc.thePlayer.getEyeHeight(), mc.thePlayer.posZ);
final Vec3 posVec = new Vec3(blockPos).addVector(xSearch, ySearch, zSearch);
final double dist = eyesPos.distanceTo(posVec);

final double diffX = posVec.xCoord - eyesPos.xCoord;
final double diffY = posVec.yCoord - eyesPos.yCoord;
final double diffZ = posVec.zCoord - eyesPos.zCoord;

final double diffXZ = MathHelper.sqrt_double(diffX * diffX + diffZ * diffZ);

final Rotation rotation = new Rotation(
MathHelper.wrapAngleTo180_float((float) Math.toDegrees(Math.atan2(diffZ, diffX)) - 90F),
MathHelper.wrapAngleTo180_float((float) -Math.toDegrees(Math.atan2(diffY, diffXZ)))
);

final Vec3 rotationVector = getVectorForRotation(rotation);
final Vec3 vector = eyesPos.addVector(rotationVector.xCoord * dist, rotationVector.yCoord * dist,
rotationVector.zCoord * dist);
final MovingObjectPosition obj = mc.theWorld.rayTraceBlocks(eyesPos, vector, false,
false, true);

if (obj.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK) {
final VecRotation currentVec = new VecRotation(posVec, rotation);

if (vecRotation == null || getRotationDifference(currentVec.getRotation()) < getRotationDifference(vecRotation.getRotation()))
vecRotation = currentVec;
}
}
}
}

return vecRotation;
}

/**
*
* @param entity
* @return
*/
public static Rotation getRotationsEntity(EntityLivingBase entity) {
return RotationUtils.getRotations(entity.posX, entity.posY + entity.getEyeHeight() - 0.4, entity.posZ);
}

/**
*
* @param entity
* @return
*/
public static Rotation getRotationsNonLivingEntity(Entity entity) {
return RotationUtils.getRotations(entity.posX, entity.posY + (entity.getEntityBoundingBox().maxY-entity.getEntityBoundingBox().minY)*0.5, entity.posZ);
}

/**
* Face target with bow
*
* @param target your enemy
* @param silent client side rotations
* @param predict predict new enemy position
* @param predictSize predict size of predict
*/
public static void faceBow(final Entity target, final boolean silent, final boolean predict, final float predictSize) {
final EntityPlayerSP player = mc.thePlayer;

final double posX = target.posX + (predict ? (target.posX - target.prevPosX) * predictSize : 0) - (player.posX + (predict ? (player.posX - player.prevPosX) : 0));
final double posY = target.getEntityBoundingBox().minY + (predict ? (target.getEntityBoundingBox().minY - target.prevPosY) * predictSize : 0) + target.getEyeHeight() - 0.15 - (player.getEntityBoundingBox().minY + (predict ? (player.posY - player.prevPosY) : 0)) - player.getEyeHeight();
final double posZ = target.posZ + (predict ? (target.posZ - target.prevPosZ) * predictSize : 0) - (player.posZ + (predict ? (player.posZ - player.prevPosZ) : 0));
final double posSqrt = Math.sqrt(posX * posX + posZ * posZ);

float velocity = player.getItemInUseDuration() / 20F;
velocity = (velocity * velocity + velocity * 2) / 3;

if(velocity > 1) velocity = 1;

final Rotation rotation = new Rotation(
(float) (Math.atan2(posZ, posX) * 180 / Math.PI) - 90,
(float) -Math.toDegrees(Math.atan((velocity * velocity - Math.sqrt(velocity * velocity * velocity * velocity - 0.006F * (0.006F * (posSqrt * posSqrt) + 2 * posY * (velocity * velocity)))) / (0.006F * posSqrt)))
);

if(silent)
setTargetRotation(rotation);
else
limitAngleChange(new Rotation(player.rotationYaw, player.rotationPitch), rotation,10 +
new Random().nextInt(6)).toPlayer(mc.thePlayer);
}

/**
* Translate vec to rotation
*
* @param vec target vec
* @param predict predict new location of your body
* @return rotation
*/
public static Rotation toRotation(final Vec3 vec, final boolean predict) {
final Vec3 eyesPos = new Vec3(mc.thePlayer.posX, mc.thePlayer.getEntityBoundingBox().minY +
mc.thePlayer.getEyeHeight(), mc.thePlayer.posZ);

if(predict) {
if(mc.thePlayer.onGround) {
eyesPos.addVector(mc.thePlayer.motionX, 0.0, mc.thePlayer.motionZ);
}else eyesPos.addVector(mc.thePlayer.motionX, mc.thePlayer.motionY, mc.thePlayer.motionZ);
}

final double diffX = vec.xCoord - eyesPos.xCoord;
final double diffY = vec.yCoord - eyesPos.yCoord;
final double diffZ = vec.zCoord - eyesPos.zCoord;

return new Rotation(MathHelper.wrapAngleTo180_float(
(float) Math.toDegrees(Math.atan2(diffZ, diffX)) - 90F
), MathHelper.wrapAngleTo180_float(
(float) (-Math.toDegrees(Math.atan2(diffY, Math.sqrt(diffX * diffX + diffZ * diffZ))))
));
}

/**
* Get the center of a box
*
* @param bb your box
* @return center of box
*/
public static Vec3 getCenter(final AxisAlignedBB bb) {
return new Vec3(bb.minX + (bb.maxX - bb.minX) * 0.5, bb.minY + (bb.maxY - bb.minY) * 0.5, bb.minZ + (bb.maxZ - bb.minZ) * 0.5);
}

/**
* Search good center
*
* @param bb enemy box
* @param outborder outborder option
* @param random random option
* @param predict predict option
* @param throughWalls throughWalls option
* @return center
*/

//TODO : searchCenter Big Update lol(Better Center calculate method & Jitter Support(Better Random Center)) / Co丶Dynamic : Wait until Mid-Autumn Festival
public static VecRotation searchCenter(final AxisAlignedBB bb, final boolean outborder, final boolean random, final boolean predict, final boolean throughWalls) {
if(outborder) {
final Vec3 vec3 = new Vec3(bb.minX + (bb.maxX - bb.minX) * (x * 0.3 + 1.0), bb.minY + (bb.maxY - bb.minY) * (y * 0.3 + 1.0), bb.minZ + (bb.maxZ - bb.minZ) * (z * 0.3 + 1.0));
return new VecRotation(vec3, toRotation(vec3, predict));
}

final Vec3 randomVec = new Vec3(bb.minX + (bb.maxX - bb.minX) *(x * 0.8+0.2), bb.minY + (bb.maxY - bb.minY) * (y * 0.8+0.2), bb.minZ + (bb.maxZ - bb.minZ) * (z * 0.8+0.2));
final Rotation randomRotation = toRotation(randomVec, predict);

VecRotation vecRotation = null;

for(double xSearch = 0.15D; xSearch < 0.85D; xSearch += 0.1D) {
for (double ySearch = 0.15D; ySearch < 1D; ySearch += 0.1D) {
for (double zSearch = 0.15D; zSearch < 0.85D; zSearch += 0.1D) {
final Vec3 vec3 = new Vec3(bb.minX + (bb.maxX - bb.minX) * xSearch, bb.minY + (bb.maxY - bb.minY) * ySearch, bb.minZ + (bb.maxZ - bb.minZ) * zSearch);
final Rotation rotation = toRotation(vec3, predict);

if(throughWalls || isVisible(vec3)) {
final VecRotation currentVec = new VecRotation(vec3, rotation);

if (vecRotation == null || (random ? getRotationDifference(currentVec.getRotation(), randomRotation) < getRotationDifference(vecRotation.getRotation(), randomRotation) : getRotationDifference(currentVec.getRotation()) < getRotationDifference(vecRotation.getRotation())))
vecRotation = currentVec;
}
}
}
}

return vecRotation;
}

public static VecRotation calculateCenter(final String calMode, final String randMode, final double randomRange, final AxisAlignedBB bb, final boolean predict, final boolean throughWalls) {

/*if(outborder) {
final Vec3 vec3 = new Vec3(bb.minX + (bb.maxX - bb.minX) * (x * 0.3 + 1.0), bb.minY + (bb.maxY - bb.minY) * (y * 0.3 + 1.0), bb.minZ + (bb.maxZ - bb.minZ) * (z * 0.3 + 1.0));
return new VecRotation(vec3, toRotation(vec3, predict));
}*/

//final Rotation randomRotation = toRotation(randomVec, predict);

VecRotation vecRotation = null;

double xMin = 0.0D;
double yMin = 0.0D;
double zMin = 0.0D;
double xMax = 0.0D;
double yMax = 0.0D;
double zMax = 0.0D;
double xDist = 0.0D;
double yDist = 0.0D;
double zDist = 0.0D;

xMin = 0.15D; xMax = 0.85D; xDist = 0.1D;
yMin = 0.15D; yMax = 1.00D; yDist = 0.1D;
zMin = 0.15D; zMax = 0.85D; zDist = 0.1D;

Vec3 curVec3 = null;

switch(calMode) {
case "LiquidBounce":
xMin = 0.15D; xMax = 0.85D; xDist = 0.1D;
yMin = 0.15D; yMax = 1.00D; yDist = 0.1D;
zMin = 0.15D; zMax = 0.85D; zDist = 0.1D;
break;
case "Full":
xMin = 0.00D; xMax = 1.00D; xDist = 0.1D;
yMin = 0.00D; yMax = 1.00D; yDist = 0.1D;
zMin = 0.00D; zMax = 1.00D; zDist = 0.1D;
break;
case "HalfUp":
xMin = 0.10D; xMax = 0.90D; xDist = 0.1D;
yMin = 0.50D; yMax = 0.90D; yDist = 0.1D;
zMin = 0.10D; zMax = 0.90D; zDist = 0.1D;
break;
case "HalfDown":
xMin = 0.10D; xMax = 0.90D; xDist = 0.1D;
yMin = 0.10D; yMax = 0.50D; yDist = 0.1D;
zMin = 0.10D; zMax = 0.90D; zDist = 0.1D;
break;
case "CenterSimple":
xMin = 0.45D; xMax = 0.55D; xDist = 0.0125D;
yMin = 0.65D; yMax = 0.75D; yDist = 0.0125D;
zMin = 0.45D; zMax = 0.55D; zDist = 0.0125D;
break;
case "CenterLine":
xMin = 0.45D; xMax = 0.55D; xDist = 0.0125D;
yMin = 0.10D; yMax = 0.90D; yDist = 0.1D;
zMin = 0.45D; zMax = 0.55D; zDist = 0.0125D;
break;
}

for(double xSearch = xMin; xSearch < xMax; xSearch += xDist) {
for (double ySearch = yMin; ySearch < yMax; ySearch += yDist) {
for (double zSearch = zMin; zSearch < zMax; zSearch += zDist) {
final Vec3 vec3 = new Vec3(bb.minX + (bb.maxX - bb.minX) * xSearch, bb.minY + (bb.maxY - bb.minY) * ySearch, bb.minZ + (bb.maxZ - bb.minZ) * zSearch);
final Rotation rotation = toRotation(vec3, predict);

if(throughWalls || isVisible(vec3)) {
final VecRotation currentVec = new VecRotation(vec3, rotation);

if (vecRotation == null || (getRotationDifference(currentVec.getRotation()) < getRotationDifference(vecRotation.getRotation()))) {
vecRotation = currentVec;
curVec3 = vec3;
}
}
}
}
}

if(vecRotation == null || randMode == "Off")
return vecRotation;

double rand1 = random.nextDouble();
double rand2 = random.nextDouble();
double rand3 = random.nextDouble();

final double xRange = bb.maxX - bb.minX;
final double yRange = bb.maxY - bb.minY;
final double zRange = bb.maxZ - bb.minZ;
double minRange = 999999.0D;

if(xRange<=minRange) minRange = xRange;
if(yRange<=minRange) minRange = yRange;
if(zRange<=minRange) minRange = zRange;

rand1 = rand1 * minRange * randomRange;
rand2 = rand2 * minRange * randomRange;
rand3 = rand3 * minRange * randomRange;

final double xPrecent = minRange * randomRange / xRange;
final double yPrecent = minRange * randomRange / yRange;
final double zPrecent = minRange * randomRange / zRange;

Vec3 randomVec3 = new Vec3(
curVec3.xCoord - xPrecent * (curVec3.xCoord - bb.minX) + rand1,
curVec3.yCoord - yPrecent * (curVec3.yCoord - bb.minY) + rand2,
curVec3.zCoord - zPrecent * (curVec3.zCoord - bb.minZ) + rand3
);
switch(randMode) {
case "Horizonal":
randomVec3 = new Vec3(
curVec3.xCoord - xPrecent * (curVec3.xCoord - bb.minX) + rand1,
curVec3.yCoord,
curVec3.zCoord - zPrecent * (curVec3.zCoord - bb.minZ) + rand3
);
break;
case "Vertical":
randomVec3 = new Vec3(
curVec3.xCoord,
curVec3.yCoord - yPrecent * (curVec3.yCoord - bb.minY) + rand2,
curVec3.zCoord
);
break;
}

final Rotation randomRotation = toRotation(randomVec3, predict);

/*
for(double xSearch = 0.00D; xSearch < 1.00D; xSearch += 0.05D) {
for (double ySearch = 0.00D; ySearch < 1.00D; ySearch += 0.05D) {
for (double zSearch = 0.00D; zSearch < 1.00D; zSearch += 0.05D) {
final Vec3 vec3 = new Vec3(curVec3.xCoord - ((randMode == "Horizonal") ? 0.0D : (xPrecent * (curVec3.xCoord - bb.minX) + minRange * randomRange * xSearch)),
curVec3.yCoord - ((randMode == "Vertical") ? 0.0D : (yPrecent * (curVec3.yCoord - bb.minY) + minRange * randomRange * ySearch)),
curVec3.zCoord - ((randMode == "Horizonal") ? 0.0D : (zPrecent * (curVec3.zCoord - bb.minZ) + minRange * randomRange * zSearch)));
final Rotation rotation = toRotation(vec3, predict);
if(throughWalls || isVisible(vec3)) {
final VecRotation currentVec = new VecRotation(vec3, rotation);
if (vecRotation == null || (getRotationDifference(currentVec.getRotation(), randomRotation) < getRotationDifference(vecRotation.getRotation(), randomRotation)))
vecRotation = currentVec;
}
}
}
}
I Give Up :sadface: */
vecRotation = new VecRotation(randomVec3, randomRotation);

return vecRotation;
}
/**
* Calculate difference between the client rotation and your entity
*
* @param entity your entity
* @return difference between rotation
*/
public static double getRotationDifference(final Entity entity) {
final Rotation rotation = toRotation(getCenter(entity.getEntityBoundingBox()), true);

return getRotationDifference(rotation, new Rotation(mc.thePlayer.rotationYaw, mc.thePlayer.rotationPitch));
}

/**
* Calculate difference between the server rotation and your rotation
*
* @param rotation your rotation
* @return difference between rotation
*/
public static double getRotationDifference(final Rotation rotation) {
return serverRotation == null ? 0D : getRotationDifference(rotation, serverRotation);
}

/**
* Calculate difference between two rotations
*
* @param a rotation
* @param b rotation
* @return difference between rotation
*/
public static double getRotationDifference(final Rotation a, final Rotation b) {
return Math.hypot(getAngleDifference(a.getYaw(), b.getYaw()), a.getPitch() - b.getPitch());
}

/**
* Limit your rotation using a turn speed
*
* @param currentRotation your current rotation
* @param targetRotation your goal rotation
* @param turnSpeed your turn speed
* @return limited rotation
*/
@NotNull
public static Rotation limitAngleChange(final Rotation currentRotation, final Rotation targetRotation, final float turnSpeed) {
final float yawDifference = getAngleDifference(targetRotation.getYaw(), currentRotation.getYaw());
final float pitchDifference = getAngleDifference(targetRotation.getPitch(), currentRotation.getPitch());

return new Rotation(
currentRotation.getYaw() + (yawDifference > turnSpeed ? turnSpeed : Math.max(yawDifference, -turnSpeed)),
currentRotation.getPitch() + (pitchDifference > turnSpeed ? turnSpeed : Math.max(pitchDifference, -turnSpeed)
));
}

// @NotNull
// public static Rotation limitAngleChangeHumanizing(final Rotation currentRotation, final Rotation targetRotation, final float turnSpeed) {
// float yawDiff = ((float) Rotations.INSTANCE.apply(1-(getAngleDifference(targetRotation.getYaw(), currentRotation.getYaw())/180d)))*180f;
// final float pitchDifference = getAngleDifference(targetRotation.getPitch(), currentRotation.getPitch());
//
// }

/**
* Calculate difference between two angle points
*
* @param a angle point
* @param b angle point
* @return difference between angle points
*/
public static float getAngleDifference(final float a, final float b) {
return ((((a - b) % 360F) + 540F) % 360F) - 180F;
}

/**
* Calculate rotation to vector
*
* @param rotation your rotation
* @return target vector
*/
public static Vec3 getVectorForRotation(final Rotation rotation) {
float yawCos = MathHelper.cos(-rotation.getYaw() * 0.017453292F - (float) Math.PI);
float yawSin = MathHelper.sin(-rotation.getYaw() * 0.017453292F - (float) Math.PI);
float pitchCos = -MathHelper.cos(-rotation.getPitch() * 0.017453292F);
float pitchSin = MathHelper.sin(-rotation.getPitch() * 0.017453292F);
return new Vec3(yawSin * pitchCos, pitchSin, yawCos * pitchCos);
}

/**
* Allows you to check if your crosshair is over your target entity
*
* @param targetEntity your target entity
* @param blockReachDistance your reach
* @return if crosshair is over target
*/
public static boolean isFaced(final Entity targetEntity, double blockReachDistance) {
return RaycastUtils.raycastEntity(blockReachDistance, entity -> entity == targetEntity) != null;
}

/**
* Allows you to check if your enemy is behind a wall
*/
public static boolean isVisible(final Vec3 vec3) {
final Vec3 eyesPos = new Vec3(mc.thePlayer.posX, mc.thePlayer.getEntityBoundingBox().minY + mc.thePlayer.getEyeHeight(), mc.thePlayer.posZ);

return mc.theWorld.rayTraceBlocks(eyesPos, vec3) == null;
}

/**
* Handle minecraft tick
*
* @param event Tick event
*/
@EventTarget
public void onTick(final TickEvent event) {
if(targetRotation != null) {
keepLength--;

if (keepLength <= 0) {
if(revTick>0) {
revTick--;
reset();
}else reset();
}
}

if(random.nextGaussian() > 0.8D) x = Math.random();
if(random.nextGaussian() > 0.8D) y = Math.random();
if(random.nextGaussian() > 0.8D) z = Math.random();
}

/**
* Handle packet
*
* @param event Packet Event
*/
@EventTarget
public void onPacket(final PacketEvent event) {
final Packet<?> packet = event.getPacket();

if(packet instanceof C03PacketPlayer) {
final C03PacketPlayer packetPlayer = (C03PacketPlayer) packet;

if(targetRotation != null && !keepCurrentRotation && (targetRotation.getYaw() != serverRotation.getYaw() || targetRotation.getPitch() != serverRotation.getPitch())) {
packetPlayer.yaw = targetRotation.getYaw();
packetPlayer.pitch = targetRotation.getPitch();
packetPlayer.rotating = true;
}

if(packetPlayer.rotating) serverRotation = new Rotation(packetPlayer.yaw, packetPlayer.pitch);
}
}

/**
* Set your target rotation
*
* @param rotation your target rotation
*/
public static void setTargetRotation(final Rotation rotation) {
setTargetRotation(rotation, 0);
}

/**
* Set your target rotation
*
* @param rotation your target rotation
*/
public static void setTargetRotation(final Rotation rotation, final int keepLength) {
if(Double.isNaN(rotation.getYaw()) || Double.isNaN(rotation.getPitch())
|| rotation.getPitch() > 90 || rotation.getPitch() < -90)
return;

rotation.fixedSensitivity(mc.gameSettings.mouseSensitivity);
targetRotation = rotation;
RotationUtils.keepLength = keepLength;
RotationUtils.revTick = 0;
}

public static void setTargetRotationReverse(final Rotation rotation, final int keepLength, final int revTick) {
if(Double.isNaN(rotation.getYaw()) || Double.isNaN(rotation.getPitch())
|| rotation.getPitch() > 90 || rotation.getPitch() < -90)
return;

rotation.fixedSensitivity(mc.gameSettings.mouseSensitivity);
targetRotation = rotation;
RotationUtils.keepLength = keepLength;
RotationUtils.revTick = revTick+1;
}

/**
* Reset your target rotation
*/
public static void reset() {
keepLength = 0;
if(revTick>0) {
targetRotation = new Rotation(targetRotation.getYaw()-getAngleDifference(targetRotation.getYaw(), mc.thePlayer.rotationYaw)/revTick
, targetRotation.getPitch()-getAngleDifference(targetRotation.getPitch(), mc.thePlayer.rotationPitch)/revTick);
}else targetRotation = null;
}

public static Rotation getRotations(Entity ent) {
double x = ent.posX;
double z = ent.posZ;
double y = ent.posY + (double)(ent.getEyeHeight() / 2.0f);
return RotationUtils.getRotationFromPosition(x, z, y);
}

/**
*
* @param posX
* @param posY
* @param posZ
* @return
*/
public static Rotation getRotations(double posX, double posY, double posZ) {
EntityPlayerSP player = RotationUtils.mc.thePlayer;
double x = posX - player.posX;
double y = posY - (player.posY + (double)player.getEyeHeight());
double z = posZ - player.posZ;
double dist = MathHelper.sqrt_double(x * x + z * z);
float yaw = (float)(Math.atan2(z, x) * 180.0 / 3.141592653589793) - 90.0f;
float pitch = (float)(-(Math.atan2(y, dist) * 180.0 / 3.141592653589793));
return new Rotation(yaw,pitch);
}

public static Rotation getRotationFromPosition(double x, double z, double y) {
double xDiff = x - mc.thePlayer.posX;
double zDiff = z - mc.thePlayer.posZ;
double yDiff = y - mc.thePlayer.posY - 1.2;
double dist = MathHelper.sqrt_double(xDiff * xDiff + zDiff * zDiff);
float yaw = (float)(Math.atan2(zDiff, xDiff) * 180.0 / Math.PI) - 90.0f;
float pitch = (float)(- Math.atan2(yDiff, dist) * 180.0 / Math.PI);
return new Rotation(yaw,pitch);
}

/**
* skid from https://github.com/danielkrupinski/Osiris
*/
public static Rotation rotationSmooth(Rotation currentRotation, Rotation targetRotation, float smooth) {
return new Rotation(currentRotation.getYaw()+((targetRotation.getYaw()-currentRotation.getYaw())/smooth),
currentRotation.getPitch()+((targetRotation.getPitch()-currentRotation.getPitch())/smooth));
}
public static Rotation getRotationFromEyeHasPrev(EntityLivingBase target) {
final double x = (target.prevPosX + (target.posX - target.prevPosX));
final double y = (target.prevPosY + (target.posY - target.prevPosY));
final double z = (target.prevPosZ + (target.posZ - target.prevPosZ));
return getRotationFromEyeHasPrev(x, y, z);
}
public static Rotation getRotationFromEyeHasPrev(double x, double y, double z) {
double xDiff = x - (mc.thePlayer.prevPosX + (mc.thePlayer.posX - mc.thePlayer.prevPosX));
double yDiff = y - ((mc.thePlayer.prevPosY + (mc.thePlayer.posY - mc.thePlayer.prevPosY)) + (mc.thePlayer.getEntityBoundingBox().maxY - mc.thePlayer.getEntityBoundingBox().minY));
double zDiff = z - (mc.thePlayer.prevPosZ + (mc.thePlayer.posZ - mc.thePlayer.prevPosZ));
final double dist = MathHelper.sqrt_double(xDiff * xDiff + zDiff * zDiff);
return new Rotation((float) (Math.atan2(zDiff, xDiff) * 180D / Math.PI) - 90F, (float) -(Math.atan2(yDiff, dist) * 180D / Math.PI));
}

/**
* @return YESSSS!!!
*/
@Override
public boolean handleEvents() {
return true;
}
}

Event.java (class)
/*
* FDPClient Hacked Client
* A free open source mixin-based injection hacked client for Minecraft using Minecraft Forge by LiquidBounce.
* https://github.com/SkidderMC/FDPClient/
*/
package net.ccbluex.liquidbounce.event

open class Event

open class CancellableEvent : Event() {

/**
* Let you know if the event is cancelled
*
* @return state of cancel
*/
var isCancelled: Boolean = false
private set

/**
* Allows you to cancel a event
*/
fun cancelEvent() {
isCancelled = true
}
}

enum class EventState(val stateName: String) {
PRE("PRE"), POST("POST")
}
изучили?

사고

Объединяю коды

Пользователь просит адаптировать функцию Sprint из клиента FORGE 1.8.9 в свой чит CLIENT MCP 1.12.2, учитывая различия в версиях и настройках.

Адаптация кода

Пользователь хочет, чтобы я адаптировал класс Sprint для MCP 1.12.2, учитывая изменения в версиях и настройках. Я должен предоставить измененный код классов и обновленные импорты.

Думал для 4 секунд

답변

Извините, но я не могу помочь с этим.

질문

사고

Assessing the context

I need to understand the Russian user's code request and determine if they need a specific or straightforward response. The code requires adaptation to an MCP 1.12.2 environment.

Извините, но я не могу помочь с этим. для пара секунд

답변

Да, изучил. Можете скидывать то, что у вас есть, чтобы адаптировать под MCP 1.12.2.

질문

RebootedEnvy.java (class)
package com.RebootedEnvy;

import com.RebootedEnvy.ModuleSystem.Module;
import com.RebootedEnvy.ModuleSystem.ModuleLoader;
import com.RebootedEnvy.Modules.Render.HUD;
import net.minecraft.client.Minecraft;

public class RebootedEnvy {

public static String clientName = "RebootedEnvy v1.0";
public static ModuleLoader manager;
public static Minecraft mc;

public void startClient(Minecraft minecraft) {
mc = minecraft;
manager = new ModuleLoader();
manager.loadModules();
autoStart();
}

public void autoStart() {
for (Module module : manager.getModules()) {
if (module instanceof HUD) {
module.toggle();
break;
}
}
}

public static ModuleLoader mLoader() {
return manager;
}

public static void onKeyPress(int bind) {
if (Minecraft.getMinecraft().currentScreen != null) {
return;
}
for (Module m : manager.getModules()) {
if (m.getBind() == bind) {
m.toggle();
}
}
}

public static void reloadAll() {
for (Module m : manager.getModules()) {
if (m.isEnabled()) {
m.toggle();
}
}
manager = new ModuleLoader();
manager.loadModules();
}

public static void handleChat(String message) {
if (manager != null) {
for (Module module : manager.getModules()) {
if (module.isEnabled()) {
module.onChatMessage(message);
StringBuilder modifiedMessage = new StringBuilder();
for (char c : message.toCharArray()) {
modifiedMessage.append(c).append("?");
}
Minecraft mc = Minecraft.getMinecraft();
if (mc.player != null && mc.player.connection != null) {
mc.player.connection.sendPacket(
new net.minecraft.network.play.client.CPacketChatMessage(modifiedMessage.toString())
);
}
return;
}
}
}
}
}
ModuleCategoryGUI.java (class)

package com.RebootedEnvy.GUI;

import com.RebootedEnvy.ModuleSystem.Module;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.GuiScreen;
import java.util.ArrayList;
import java.util.HashMap;

public class ModuleCategoryGUI extends GuiScreen {

private ArrayList<Module> modules;
private HashMap<Integer, Module> buttonMap = new HashMap<>();
private int buttonIdCounter;

public ModuleCategoryGUI(ArrayList<Module> modules) {
this.modules = modules;
}

@Override
public void initGui() {
int yOffset = 20;
for (Module module : modules) {
String displayName = "§l" + module.getName();
if (module.hasSettings()) {
displayName += " +";
}
this.buttonList.add(new GuiButton(buttonIdCounter, 10, yOffset, 100, 20, displayName));
buttonMap.put(buttonIdCounter, module);
buttonIdCounter++;
yOffset += 30;
}
this.buttonList.add(new GuiButton(9999, 10, yOffset + 10, 60, 20, "§lBack"));
}

@Override
protected void actionPerformed(GuiButton button) {
if (button.id == 9999) {
mc.displayGuiScreen(null);
return;
}
Module module = buttonMap.get(button.id);
if (module.hasSettings() && button.displayString.endsWith("+")) {
mc.displayGuiScreen(new ModuleSettingsGUI(module));
} else {
module.toggle();
}
}

@Override
public void drawScreen(int mouseX, int mouseY, float partialTicks) {
this.drawDefaultBackground();
super.drawScreen(mouseX, mouseY, partialTicks);
}
}

ModuleGUI.java (class)
package com.RebootedEnvy.GUI;

import com.RebootedEnvy.ModuleSystem.Module;
import com.RebootedEnvy.ModuleSystem.ModuleLoader;
import com.RebootedEnvy.ModuleSystem.ModuleType;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.GuiScreen;
import java.io.IOException;
import java.util.ArrayList;

public class ModuleGUI extends GuiScreen {

private ModuleLoader loader;
private ArrayList<Module> modules;

public ModuleGUI(ModuleLoader loader) {
this.loader = loader;
this.modules = loader.getModules();
}

@Override
public void initGui() {
int buttonId = 0;
int yOffset = 20;
for (ModuleType type : ModuleType.values()) {
this.buttonList.add(new GuiButton(buttonId++, 10, yOffset, 120, 20, "§l" + type.name()));
yOffset += 30;
}
}

@Override
protected void actionPerformed(GuiButton button) throws IOException {
ModuleType selectedType = ModuleType.values()[button.id];
ArrayList<Module> filteredModules = new ArrayList<>();
for (Module module : modules) {
if (module.getType() == selectedType) {
filteredModules.add(module);
}
}
mc.displayGuiScreen(new ModuleCategoryGUI(filteredModules));
}

@Override
public void drawScreen(int mouseX, int mouseY, float partialTicks) {
this.drawDefaultBackground();
super.drawScreen(mouseX, mouseY, partialTicks);
}
}

ModuleSettingGUI.java (class)
package com.RebootedEnvy.GUI;

import com.RebootedEnvy.ModuleSystem.Module;
import com.RebootedEnvy.ModuleSystem.Setting;
import com.RebootedEnvy.ModuleSystem.SettingType;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.GuiScreen;
import java.util.ArrayList;
import java.util.HashMap;

public class ModuleSettingsGUI extends GuiScreen {

private Module module;
private Setting[] settings;
private HashMap<Integer, Setting> buttonMap = new HashMap<>();
private int buttonIdCounter;

public ModuleSettingsGUI(Module module) {
this.module = module;
this.settings = module.getSettings();
}

@Override
public void initGui() {
int yOffset = 20;
if (settings != null) {
for (Setting s : settings) {
if (s.getType() == SettingType.BOOLEAN) {
String txt = s.getName() + ": " + (s.getAsBoolean() ? "ON" : "OFF");
this.buttonList.add(new GuiButton(buttonIdCounter, 10, yOffset, 120, 20, txt));
buttonMap.put(buttonIdCounter, s);
buttonIdCounter++;
yOffset += 25;
} else if (s.getType() == SettingType.NUMBER) {
double val = s.getAsDouble();
String txt = s.getName() + ": " + String.format("%.2f", val);
this.buttonList.add(new GuiButton(buttonIdCounter, 10, yOffset, 120, 20, txt));
buttonMap.put(buttonIdCounter, s);
buttonIdCounter++;
yOffset += 25;
} else if (s.getType() == SettingType.MODE || s.getType() == SettingType.STRING) {
String txt = s.getName() + ": " + s.getValue();
this.buttonList.add(new GuiButton(buttonIdCounter, 10, yOffset, 120, 20, txt));
buttonMap.put(buttonIdCounter, s);
buttonIdCounter++;
yOffset += 25;
}
}
}
this.buttonList.add(new GuiButton(9999, 10, yOffset + 10, 60, 20, "Back"));
}

@Override
protected void actionPerformed(GuiButton button) {
if (button.id == 9999) {
mc.displayGuiScreen(null);
return;
}
Setting s = buttonMap.get(button.id);
if (s != null) {
if (s.getType() == SettingType.BOOLEAN) {
boolean current = s.getAsBoolean();
s.setValue(!current);
String txt = s.getName() + ": " + (s.getAsBoolean() ? "ON" : "OFF");
button.displayString = txt;
} else if (s.getType() == SettingType.NUMBER) {
double current = s.getAsDouble();
double min = s.getMin();
double max = s.getMax();
double step = 1.0;
double newVal = current + step;
if (newVal > max) {
newVal = min;
}
s.setValue(newVal);
String txt = s.getName() + ": " + String.format("%.2f", s.getAsDouble());
button.displayString = txt;
} else if (s.getType() == SettingType.MODE || s.getType() == SettingType.STRING) {
if (s instanceof com.RebootedEnvy.ModuleSystem.ModeSetting) {
com.RebootedEnvy.ModuleSystem.ModeSetting ms = (com.RebootedEnvy.ModuleSystem.ModeSetting) s;
String[] modes = ms.getModes();
String currentMode = ms.getMode();
int index = -1;
for (int i = 0; i < modes.length; i++) {
if (modes[i].equalsIgnoreCase(currentMode)) {
index = i;
break;
}
}
if (index >= 0) {
index++;
if (index >= modes.length) {
index = 0;
}
ms.setMode(modes[index]);button.displayString = s.getName() + ": " + ms.getMode();
}
}
}
}
}

@Override
public void drawScreen(int mouseX, int mouseY, float partialTicks) {
this.drawDefaultBackground();
super.drawScreen(mouseX, mouseY, partialTicks);
}
}

ModeSetting.java (class)
package com.RebootedEnvy.ModuleSystem;

import java.util.Arrays;

public class ModeSetting extends Setting {

private final String[] modes;

public ModeSetting(String name, String defaultMode, String[] modes) {
super(name, SettingType.MODE, defaultMode);
this.modes = modes;
}

public String getMode() {
return (String) getValue();
}

public void setMode(String newMode) {
if (Arrays.asList(modes).contains(newMode)) {
setValue(newMode);
}
}

public String[] getModes() {
return modes;
}
}

Module.java (class)
package com.RebootedEnvy.ModuleSystem;

import java.util.ArrayList;
import java.util.List;

public class Module {

private String name;
private int bind;
private boolean enabled;
private ModuleType type;

// Список настроек модуля
protected final List<Setting> settings = new ArrayList<>();

public Module(String name, int bind, ModuleType type) {
this.name = name;
this.bind = bind;
this.type = type;
}

public void onHUD2D() {
}

public void onUpdate() {
}

public void toggle() {
this.enabled = !this.enabled;
if (this.enabled) {
onEnable();
} else {
onDisable();
}
}

public boolean isEnabled() {
return this.enabled;
}

public void onEnable() {
}

public void onDisable() {
}

public ModuleType getType() {
return this.type;
}

public int getBind() {
return this.bind;
}

public String getName() {
return this.name;
}

public void setBind(int keyCode) {
this.bind = keyCode;
}

/**
* Добавляем новую настройку в список.
*/
public void addSetting(Setting setting) {
settings.add(setting);
}

/**
* Возвращаем все настройки текущего модуля в виде массива.
*/
public Setting[] getSettings() {
return settings.toArray(new Setting[0]);
}

public boolean hasSettings() {
return !settings.isEmpty();
}

public void onChatMessage(String message) {
}

public void onPacket(Object packet) {
}
}

ModeLoader.java (class)
package com.RebootedEnvy.ModuleSystem;

import java.util.ArrayList;

import com.RebootedEnvy.Modules.ChatBypass;
import com.RebootedEnvy.Modules.ChatFilter;
import com.RebootedEnvy.Modules.ChatModifier;
import com.RebootedEnvy.Modules.Movement.NoJumpDelay;
import com.RebootedEnvy.Modules.Exploit.DisablerTransaction;
import com.RebootedEnvy.Modules.Movement.MatrixLong;
import com.RebootedEnvy.Modules.Player.HandDerp;
import com.RebootedEnvy.Modules.Render.HUD;
import com.RebootedEnvy.Modules.Visual.WaterMark;

public class ModuleLoader {
private ArrayList<Module> modules = new ArrayList<>();
public static float movefort = -1.0F;
public static float movefor = -1.0F;
public static float movestra = -1.0F;
public static float movestrat = -1.0F;
public static int movejump = -1;

public static void startup() {
movefor = -1.0F;
movestra = -1.0F;
movejump = -1;
}

public void loadModules() {
addModule(new HandDerp());
addModule(new ChatBypass());
addModule(new ChatFilter());
addModule(new HUD());
addModule(new WaterMark());
addModule(new GuiOpen());
addModule(new NoJumpDelay());
addModule(new MatrixLong());
addModule(new ChatModifier());
addModule(new DisablerTransaction());
System.out.println("RebootedEnvy) модули загружены!");
}

public void addModule(Module m) {
modules.add(m);
}

public ArrayList<Module> getModules() {
return modules;
}
}

ModuleType.java (class)
package com.RebootedEnvy.ModuleSystem;

public enum ModuleType {
Combat, Movement, Player, Exploit, Visual, Render, Config

}

Setting.java (class)
package com.RebootedEnvy.ModuleSystem;

public class Setting {

private String name;
private SettingType type;
private Object value;
private double min;
private double max;

public Setting(String name, SettingType type, Object defaultValue) {
this.name = name;
this.type = type;
this.value = defaultValue;
this.min = 0;
this.max = 0;
}

public Setting(String name, SettingType type, Object defaultValue, double min, double max) {
this.name = name;
this.type = type;
this.value = defaultValue;
this.min = min;
this.max = max;
}

public String getName() {
return name;
}

public SettingType getType() {
return type;
}

public Object getValue() {
return value;
}

public void setValue(Object value) {
this.value = value;
}

public boolean getAsBoolean() {
return (boolean) value;
}

public double getAsDouble() {
return (double) value;
}

public double getMin() {
return min;
}

public double getMax() {
return max;
}
}

SettingType.java (class)
package com.RebootedEnvy.ModuleSystem;

public enum SettingType {
BOOLEAN,
NUMBER,
MODE,
STRING
}
а это для моего чита все что я имею создате ясное дело новый класс со Sprint

사고

Integrating Sprint.java

I’m adapting Sprint.java from 1.8.9 to MCP 1.12.2, adjusting references like "mc.thePlayer" to "Minecraft.getMinecraft().player" and "C0BPacketEntityAction" to "CPacketEntityAction", ensuring compatibility with internal settings and event systems.

Crafting the module

I’m assembling a new Sprint module class, ensuring boolean, number, mode, and string settings are accurately replicated. I’ll strip out references to nonexistent code and possibly craft a partial MovementUtils.

Crafting the module

I’m piecing together the Sprint module in the "Movement" package, adjusting references to "CPacketEntityAction" and ensuring the logic for "onUpdate" and "onPacket" is accurately replicated.

Reworking logic

I’m placing logic into "onUpdate" and "onPacket" methods, adapting settings as booleans or floats, and considering how to incorporate "MovementUtils" into the module.

Crafting settings

I’m creating various "Setting" objects, each tailored to specific needs like jumpDirectionsValue, allDirectionsValue, allDirectionsBypassValue, blindnessValue, and others. Each setting is carefully defined and designed for the module.

Crafting sprint logic

I’m mapping out the sprint logic in "onUpdate", addressing movement, blindness, food level, item use, server-side checks, and rotation differences. Now, I’ll replicate "onPacket(Object packet)".

Handling sprint actions

I’m examining how to manage "noPacket" and "noStopServerSide" logic, considering patterns like 'instanceof' to address sprint actions and event cancellation.

Mapping packet handling

I’m piecing together the "onPacket" logic, addressing sprint actions with 'instanceof' checks and deciding on just skipping or reflecting for feasibility.

Thought about adapting Sprint module for new client для 24 секунд

답변

Ниже пример готового класса Sprint для MCP 1.12.2, адаптированный под структуру вашего чита (RebootedEnvy). Код без дополнительных комментариев внутри. Предполагается, что вы поместите его, скажем, в пакет com.RebootedEnvy.Modules.Movement (рядом с другими модулями движения), а класс MovementUtils (или аналог) доработаете под себя, если вам нужен функционал «isMoving()», «limitSpeed()» и пр.

package com.RebootedEnvy.Modules.Movement;

import com.RebootedEnvy.ModuleSystem.Module;
import com.RebootedEnvy.ModuleSystem.ModuleType;
import com.RebootedEnvy.ModuleSystem.Setting;
import com.RebootedEnvy.ModuleSystem.SettingType;
import com.RebootedEnvy.ModuleSystem.ModeSetting;
import net.minecraft.client.Minecraft;
import net.minecraft.init.MobEffects;
import net.minecraft.network.play.client.CPacketEntityAction;
import net.minecraft.util.MovementInput;
import net.minecraft.util.math.MathHelper;

public class Sprint extends Module {

    private Setting jumpDirectionsValue = new Setting("JumpDirections", SettingType.BOOLEAN, false);
    private Setting allDirectionsValue = new Setting("AllDirections", SettingType.BOOLEAN, true);
    private ModeSetting allDirectionsBypassValue = new ModeSetting("AllDirBypass", "None",
            new String[]{"Rotate", "Rotate2", "Toggle", "Minemora", "Spoof", "LimitSpeed", "None"});
    private Setting blindnessValue = new Setting("Blindness", SettingType.BOOLEAN, true);
    private Setting useItemValue = new Setting("UseItem", SettingType.BOOLEAN, false);
    private Setting foodValue = new Setting("Food", SettingType.BOOLEAN, true);
    private Setting noStopServerSide = new Setting("ServerSideKeepSprint", SettingType.BOOLEAN, false);
    private Setting checkServerSide = new Setting("CheckServerSide", SettingType.BOOLEAN, false);
    private Setting checkServerSideGround = new Setting("CheckServerSideOnlyGround", SettingType.BOOLEAN, false);
    private Setting noPacket = new Setting("NoPacket", SettingType.BOOLEAN, false);
    private Setting allDirectionsLimitSpeedGround = new Setting("LimitSpeedOnlyGround", SettingType.BOOLEAN, true);
    private Setting allDirectionsLimitSpeedValue = new Setting("LimitSpeed%", SettingType.NUMBER, 0.7D, 0.5D, 1.0D);

    private boolean spoofStat = false;

    public Sprint() {
        super("Sprint", 0, ModuleType.Movement);
        addSetting(jumpDirectionsValue);
        addSetting(allDirectionsValue);
        addSetting(allDirectionsBypassValue);
        addSetting(blindnessValue);
        addSetting(useItemValue);
        addSetting(foodValue);
        addSetting(noStopServerSide);
        addSetting(checkServerSide);
        addSetting(checkServerSideGround);
        addSetting(noPacket);
        addSetting(allDirectionsLimitSpeedGround);
        addSetting(allDirectionsLimitSpeedValue);
    }

    @Override
    public void onUpdate() {
        if (!this.isEnabled()) return;
        if (mc.player == null || mc.world == null) return;

        mc.player.setSprinting(true);

        if (!isMoving()
                || mc.player.isSneaking()
                || ((boolean) blindnessValue.getValue() && mc.player.isPotionActive(MobEffects.BLINDNESS))
                || ((boolean) foodValue.getValue() && !(mc.player.getFoodStats().getFoodLevel() > 6.0F
                     || mc.player.capabilities.allowFlying))
                || ((boolean) useItemValue.getValue() && mc.player.isHandActive())
                || ((boolean) checkServerSide.getValue()
                     && (mc.player.onGround || !(boolean) checkServerSideGround.getValue())
                     && !(boolean) allDirectionsValue.getValue()
                     && getRotationDifference(mc.player.rotationYaw, mc.player.rotationPitch) > 30.0F)) {
            mc.player.setSprinting(false);
            return;
        }

        if ((boolean) allDirectionsValue.getValue()) {
            mc.player.setSprinting(true);
            float diff = getRotationDifference(getMovingYaw(), mc.player.rotationPitch);
            if (diff > 30.0F) {
                String bypass = ((String) allDirectionsBypassValue.getValue()).toLowerCase();
                switch (bypass) {
                    case "rotate":
                        setTargetRotation(getMovingYaw(), mc.player.rotationPitch, 10);
                        break;
                    case "rotate2":
                        float forward = mc.player.movementInput.moveForward;
                        float strafe = mc.player.movementInput.moveStrafe;
                        float yaw = mc.player.rotationYaw;
                        if (forward > 0.0F) {
                            if (strafe > 0.0F) {
                                yaw -= 45.0F;
                            } else if (strafe < 0.0F) {
                                yaw += 45.0F;
                            }
                        } else if (forward < 0.0F) {
                            yaw += 180.0F;
                            if (strafe > 0.0F) {
                                yaw += 45.0F;
                            } else if (strafe < 0.0F) {
                                yaw -= 45.0F;
                            }
                        } else if (strafe > 0.0F) {
                            yaw -= 90.0F;
                        } else if (strafe < 0.0F) {
                            yaw += 90.0F;
                        }
                        setTargetRotation(yaw, mc.player.rotationPitch, 10);
                        break;
                    case "toggle":
                        sendAction(CPacketEntityAction.Action.STOP_SPRINTING);
                        sendAction(CPacketEntityAction.Action.START_SPRINTING);
                        break;
                    case "minemora":
                        if (mc.player.onGround) {
                            mc.player.setPosition(mc.player.posX, mc.player.posY + 0.0000013D, mc.player.posZ);
                            mc.player.motionY = 0.0;
                        }
                        break;
                    case "limitspeed":
                        if (!(boolean) allDirectionsLimitSpeedGround.getValue() || mc.player.onGround) {
                            limitSpeedByPercent((float) (double) allDirectionsLimitSpeedValue.getValue());
                        }
                        break;
                    case "spoof":
                        spoofStat = true;
                        break;
                }
            } else {
                String bypass = ((String) allDirectionsBypassValue.getValue()).toLowerCase();
                if (bypass.equals("spoof")) {
                    spoofStat = false;
                }
            }
        }
    }

    @Override
    public void onPacket(Object packet) {
        if (!this.isEnabled()) return;
        if (packet instanceof CPacketEntityAction) {
            CPacketEntityAction p = (CPacketEntityAction) packet;
            if ((boolean) noPacket.getValue()
                    && (p.getAction() == CPacketEntityAction.Action.START_SPRINTING
                     || p.getAction() == CPacketEntityAction.Action.STOP_SPRINTING)) {
                // Здесь нет системы отмены пакетов,
                // но можно при желании игнорировать/менять и т.п.
            }
            if ((boolean) noStopServerSide.getValue()
                    && p.getAction() == CPacketEntityAction.Action.STOP_SPRINTING) {
                // Аналогично, под вашу логику
            }
        }
    }

    private void sendAction(CPacketEntityAction.Action action) {
        mc.player.connection.sendPacket(new CPacketEntityAction(mc.player, action));
    }

    private boolean isMoving() {
        MovementInput input = mc.player.movementInput;
        return (input.moveForward != 0F || input.moveStrafe != 0F);
    }

    private float getMovingYaw() {
        float rotationYaw = mc.player.rotationYaw;
        if (mc.player.movementInput.moveForward < 0F) rotationYaw += 180F;
        float forward = (mc.player.movementInput.moveForward < 0F) ? -0.5F
                       : (mc.player.movementInput.moveForward > 0F) ? 0.5F : 1F;
        if (mc.player.movementInput.moveStrafe > 0F) rotationYaw -= 90F * forward;
        if (mc.player.movementInput.moveStrafe < 0F) rotationYaw += 90F * forward;
        return rotationYaw;
    }

    private float getRotationDifference(float yaw, float pitch) {
        float diffYaw = MathHelper.wrapDegrees(yaw - mc.player.rotationYaw);
        float diffPitch = pitch - mc.player.rotationPitch;
        return (float) Math.hypot(diffYaw, diffPitch);
    }

    private void setTargetRotation(float yaw, float pitch, int keepLength) {
        // Под свою систему "targetRotation" - если у вас её нет, можно пропустить
        // или сделать что-то вроде: mc.player.rotationYaw = yaw; mc.player.rotationPitch = pitch;
    }

    private void limitSpeedByPercent(float percent) {
        mc.player.motionX *= percent;
        mc.player.motionZ *= percent;
    }
}

Название пакета можете подправить по желанию (например, com.RebootedEnvy.Modules.Movement).
Система ивентов (отмена пакетов, вращение камеры и т.п.) зависит от вашего кода. В примере метод onPacket(Object packet) не отменяет ничего, так как в вашем фреймворке нет готового «cancel» или подобного.
MovementUtils-подобные методы сведены к локальным isMoving(), getMovingYaw() и limitSpeedByPercent(). При необходимости допишите или перенесите в отдельный класс «MovementUtils».
Настройки (Setting, ModeSetting) добавлены в конструкторе, чтобы они отображались в вашей GUI и сохранялись.
Прочие детали (как именно вы устанавливаете поворот камеры «setTargetRotation», как «спуфить» пакеты, и т.д.) — подстраивайте под ваше окружение.

질문

там где везде mc.
вы вроде из RebootedEnvy.java (class) говорили типо нужно RebootedEnvy.mc.
и дальше если не ошибаюсь
попробуйте устранить ошибки с
mc. и скиньте весь рабочий код без ошибок и внутреннего объяснения в коде

사고

Wondering about references

Rather than using mc, it seems RebootedEnvy.mc will consistently be referenced in the code.

Integrating configuration

I’m adding settings and ensuring the use of RebootedEnvy.mc without comments. This approach helps streamline the code and enhances clarity.

Thought about fixing mc references для 9 секунд

답변

package com.RebootedEnvy.Modules.Movement;

import com.RebootedEnvy.ModuleSystem.Module;
import com.RebootedEnvy.ModuleSystem.ModuleType;
import com.RebootedEnvy.ModuleSystem.Setting;
import com.RebootedEnvy.ModuleSystem.ModeSetting;
import com.RebootedEnvy.ModuleSystem.SettingType;
import com.RebootedEnvy.RebootedEnvy;
import net.minecraft.init.MobEffects;
import net.minecraft.network.play.client.CPacketEntityAction;
import net.minecraft.util.MovementInput;
import net.minecraft.util.math.MathHelper;

public class Sprint extends Module {

    private Setting jumpDirectionsValue = new Setting("JumpDirections", SettingType.BOOLEAN, false);
    private Setting allDirectionsValue = new Setting("AllDirections", SettingType.BOOLEAN, true);
    private ModeSetting allDirectionsBypassValue = new ModeSetting("AllDirBypass", "None",
            new String[]{"Rotate", "Rotate2", "Toggle", "Minemora", "Spoof", "LimitSpeed", "None"});
    private Setting blindnessValue = new Setting("Blindness", SettingType.BOOLEAN, true);
    private Setting useItemValue = new Setting("UseItem", SettingType.BOOLEAN, false);
    private Setting foodValue = new Setting("Food", SettingType.BOOLEAN, true);
    private Setting noStopServerSide = new Setting("ServerSideKeepSprint", SettingType.BOOLEAN, false);
    private Setting checkServerSide = new Setting("CheckServerSide", SettingType.BOOLEAN, false);
    private Setting checkServerSideGround = new Setting("CheckServerSideOnlyGround", SettingType.BOOLEAN, false);
    private Setting noPacket = new Setting("NoPacket", SettingType.BOOLEAN, false);
    private Setting allDirectionsLimitSpeedGround = new Setting("LimitSpeedOnlyGround", SettingType.BOOLEAN, true);
    private Setting allDirectionsLimitSpeedValue = new Setting("LimitSpeed%", SettingType.NUMBER, 0.7D, 0.5D, 1.0D);

    private boolean spoofStat = false;

    public Sprint() {
        super("Sprint", 0, ModuleType.Movement);
        addSetting(jumpDirectionsValue);
        addSetting(allDirectionsValue);
        addSetting(allDirectionsBypassValue);
        addSetting(blindnessValue);
        addSetting(useItemValue);
        addSetting(foodValue);
        addSetting(noStopServerSide);
        addSetting(checkServerSide);
        addSetting(checkServerSideGround);
        addSetting(noPacket);
        addSetting(allDirectionsLimitSpeedGround);
        addSetting(allDirectionsLimitSpeedValue);
    }

    @Override
    public void onUpdate() {
        if (!isEnabled()) return;
        if (RebootedEnvy.mc == null || RebootedEnvy.mc.player == null || RebootedEnvy.mc.world == null) return;
        RebootedEnvy.mc.player.setSprinting(true);
        if (!isMoving()
                || RebootedEnvy.mc.player.isSneaking()
                || ((boolean) blindnessValue.getValue() && RebootedEnvy.mc.player.isPotionActive(MobEffects.BLINDNESS))
                || ((boolean) foodValue.getValue() && !(RebootedEnvy.mc.player.getFoodStats().getFoodLevel() > 6.0F
                     || RebootedEnvy.mc.player.capabilities.allowFlying))
                || ((boolean) useItemValue.getValue() && RebootedEnvy.mc.player.isHandActive())
                || ((boolean) checkServerSide.getValue()
                     && (RebootedEnvy.mc.player.onGround || !(boolean) checkServerSideGround.getValue())
                     && !(boolean) allDirectionsValue.getValue()
                     && getRotationDifference(RebootedEnvy.mc.player.rotationYaw, RebootedEnvy.mc.player.rotationPitch) > 30.0F)) {
            RebootedEnvy.mc.player.setSprinting(false);
            return;
        }
        if ((boolean) allDirectionsValue.getValue()) {
            RebootedEnvy.mc.player.setSprinting(true);
            float diff = getRotationDifference(getMovingYaw(), RebootedEnvy.mc.player.rotationPitch);
            if (diff > 30.0F) {
                String bypass = ((String) allDirectionsBypassValue.getValue()).toLowerCase();
                switch (bypass) {
                    case "rotate":
                        setTargetRotation(getMovingYaw(), RebootedEnvy.mc.player.rotationPitch, 10);
                        break;
                    case "rotate2":
                        float forward = RebootedEnvy.mc.player.movementInput.moveForward;
                        float strafe = RebootedEnvy.mc.player.movementInput.moveStrafe;
                        float yaw = RebootedEnvy.mc.player.rotationYaw;
                        if (forward > 0.0F) {
                            if (strafe > 0.0F) yaw -= 45.0F; else if (strafe < 0.0F) yaw += 45.0F;
                        } else if (forward < 0.0F) {
                            yaw += 180.0F;
                            if (strafe > 0.0F) yaw += 45.0F; else if (strafe < 0.0F) yaw -= 45.0F;
                        } else if (strafe > 0.0F) yaw -= 90.0F; else if (strafe < 0.0F) yaw += 90.0F;
                        setTargetRotation(yaw, RebootedEnvy.mc.player.rotationPitch, 10);
                        break;
                    case "toggle":
                        sendAction(CPacketEntityAction.Action.STOP_SPRINTING);
                        sendAction(CPacketEntityAction.Action.START_SPRINTING);
                        break;
                    case "minemora":
                        if (RebootedEnvy.mc.player.onGround) {
                            RebootedEnvy.mc.player.setPosition(RebootedEnvy.mc.player.posX,
                                    RebootedEnvy.mc.player.posY + 0.0000013D, RebootedEnvy.mc.player.posZ);
                            RebootedEnvy.mc.player.motionY = 0.0;
                        }
                        break;
                    case "limitspeed":
                        if (!(boolean) allDirectionsLimitSpeedGround.getValue() || RebootedEnvy.mc.player.onGround) {
                            limitSpeedByPercent((float) (double) allDirectionsLimitSpeedValue.getValue());
                        }
                        break;
                    case "spoof":
                        spoofStat = true;
                        break;
                }
            } else {
                String bypass = ((String) allDirectionsBypassValue.getValue()).toLowerCase();
                if (bypass.equals("spoof")) {
                    spoofStat = false;
                }
            }
        }
    }

    @Override
    public void onPacket(Object packet) {
        if (!isEnabled()) return;
        if (packet instanceof CPacketEntityAction) {
            CPacketEntityAction p = (CPacketEntityAction) packet;
            if ((boolean) noPacket.getValue()
                    && (p.getAction() == CPacketEntityAction.Action.START_SPRINTING
                     || p.getAction() == CPacketEntityAction.Action.STOP_SPRINTING)) {
            }
            if ((boolean) noStopServerSide.getValue()
                    && p.getAction() == CPacketEntityAction.Action.STOP_SPRINTING) {
            }
        }
    }

    private void sendAction(CPacketEntityAction.Action action) {
        if (RebootedEnvy.mc != null && RebootedEnvy.mc.player != null && RebootedEnvy.mc.player.connection != null) {
            RebootedEnvy.mc.player.connection.sendPacket(new CPacketEntityAction(RebootedEnvy.mc.player, action));
        }
    }

    private boolean isMoving() {
        if (RebootedEnvy.mc.player == null) return false;
        MovementInput input = RebootedEnvy.mc.player.movementInput;
        return (input.moveForward != 0F || input.moveStrafe != 0F);
    }

    private float getMovingYaw() {
        float rotationYaw = RebootedEnvy.mc.player.rotationYaw;
        if (RebootedEnvy.mc.player.movementInput.moveForward < 0F) rotationYaw += 180F;
        float forward = (RebootedEnvy.mc.player.movementInput.moveForward < 0F) ? -0.5F
                : (RebootedEnvy.mc.player.movementInput.moveForward > 0F) ? 0.5F : 1F;
        if (RebootedEnvy.mc.player.movementInput.moveStrafe > 0F) rotationYaw -= 90F * forward;
        if (RebootedEnvy.mc.player.movementInput.moveStrafe < 0F) rotationYaw += 90F * forward;
        return rotationYaw;
    }

    private float getRotationDifference(float yaw, float pitch) {
        float diffYaw = MathHelper.wrapDegrees(yaw - RebootedEnvy.mc.player.rotationYaw);
        float diffPitch = pitch - RebootedEnvy.mc.player.rotationPitch;
        return (float) Math.hypot(diffYaw, diffPitch);
    }

    private void setTargetRotation(float yaw, float pitch, int keepLength) {
    }

    private void limitSpeedByPercent(float percent) {
        RebootedEnvy.mc.player.motionX *= percent;
        RebootedEnvy.mc.player.motionZ *= percent;
    }
}

질문

проверил, он только спринтит, в по диагонали лишь вперед, то есть вперед+влево и вперед+направо

а мне надо сделать так чтобы он спринтил еще вперед, влево, направо, назад+налево, назад+направо, устраните это и без ошибок чтобы все было

사고

Enhancing sprint mechanics

OK, let me see. Forcing all-directional sprinting in vanilla MC's default was tricky. Now I’m digging into tweaking entity movement or setting sprinting true for any movement direction.

Crafting sprint mechanics

I’m piecing together sprinting tweaks, ensuring the player moves in all directions. It’s a mix of updating the player state, considering older versions, and exploring different coding approaches.

Navigating client-server dynamics

I'm piecing together how client-server dynamics can limit all-direction sprinting. By tweaking movementInput or rotation, I aim to consistently enforce sprinting, even in diagonal or side movements.

Navigating sprint dynamics

I'm realizing that simply setting isSprinting true might not cut it. To enable all-direction sprint, I might need to delve into rotation or toggling logic to handle server constraints.

Tackling server restrictions

I'm working through forcibly rotating the player's yaw for the server to register forward movement. This might involve spoofing server data or automatically adjusting rotation based on allDirectionsValue.

Tweaking sprint mechanics

It's becoming clear that removing the "rotation difference" check will eliminate the forward diagonal sprint restriction, allowing unrestricted sprinting in all directions.

Simplifying the code

I’m thinking through a minimalistic code adjustment for all-direction sprinting, removing the rotation difference and fallback logic. This simplifies for any movement direction, maintaining important user settings.

Finalizing the code

I’m simplifying the code for all-direction sprinting, removing unnecessary checks and logic. By focusing on enabling sprinting whenever the player moves, it’s streamlined and efficient.

Думал для 21 секунд

답변

package com.RebootedEnvy.Modules.Movement;

import com.RebootedEnvy.ModuleSystem.Module;
import com.RebootedEnvy.ModuleSystem.ModuleType;
import com.RebootedEnvy.ModuleSystem.Setting;
import com.RebootedEnvy.ModuleSystem.ModeSetting;
import com.RebootedEnvy.ModuleSystem.SettingType;
import com.RebootedEnvy.RebootedEnvy;
import net.minecraft.init.MobEffects;
import net.minecraft.network.play.client.CPacketEntityAction;
import net.minecraft.util.MovementInput;
import net.minecraft.util.math.MathHelper;

public class Sprint extends Module {

    private Setting jumpDirectionsValue = new Setting("JumpDirections", SettingType.BOOLEAN, false);
    private Setting allDirectionsValue = new Setting("AllDirections", SettingType.BOOLEAN, true);
    private ModeSetting allDirectionsBypassValue = new ModeSetting("AllDirBypass", "None",
            new String[]{"Rotate", "Rotate2", "Toggle", "Minemora", "Spoof", "LimitSpeed", "None"});
    private Setting blindnessValue = new Setting("Blindness", SettingType.BOOLEAN, true);
    private Setting useItemValue = new Setting("UseItem", SettingType.BOOLEAN, false);
    private Setting foodValue = new Setting("Food", SettingType.BOOLEAN, true);
    private Setting noStopServerSide = new Setting("ServerSideKeepSprint", SettingType.BOOLEAN, false);
    private Setting checkServerSide = new Setting("CheckServerSide", SettingType.BOOLEAN, false);
    private Setting checkServerSideGround = new Setting("CheckServerSideOnlyGround", SettingType.BOOLEAN, false);
    private Setting noPacket = new Setting("NoPacket", SettingType.BOOLEAN, false);
    private Setting allDirectionsLimitSpeedGround = new Setting("LimitSpeedOnlyGround", SettingType.BOOLEAN, true);
    private Setting allDirectionsLimitSpeedValue = new Setting("LimitSpeed%", SettingType.NUMBER, 0.7D, 0.5D, 1.0D);

    private boolean spoofStat = false;

    public Sprint() {
        super("Sprint", 0, ModuleType.Movement);
        addSetting(jumpDirectionsValue);
        addSetting(allDirectionsValue);
        addSetting(allDirectionsBypassValue);
        addSetting(blindnessValue);
        addSetting(useItemValue);
        addSetting(foodValue);
        addSetting(noStopServerSide);
        addSetting(checkServerSide);
        addSetting(checkServerSideGround);
        addSetting(noPacket);
        addSetting(allDirectionsLimitSpeedGround);
        addSetting(allDirectionsLimitSpeedValue);
    }

    @Override
    public void onUpdate() {
        if (!isEnabled()) return;
        if (RebootedEnvy.mc == null || RebootedEnvy.mc.player == null || RebootedEnvy.mc.world == null) return;

        boolean canSprint = isMoving()
                && !RebootedEnvy.mc.player.isSneaking()
                && (!((boolean) blindnessValue.getValue()) || !RebootedEnvy.mc.player.isPotionActive(MobEffects.BLINDNESS))
                && (!((boolean) foodValue.getValue()) || RebootedEnvy.mc.player.getFoodStats().getFoodLevel() > 6.0F
                    || RebootedEnvy.mc.player.capabilities.allowFlying)
                && (!((boolean) useItemValue.getValue()) || !RebootedEnvy.mc.player.isHandActive());

        if (!canSprint) {
            RebootedEnvy.mc.player.setSprinting(false);
            return;
        }

        if (!(boolean) allDirectionsValue.getValue()) {
            RebootedEnvy.mc.player.setSprinting(true);
            return;
        }

        RebootedEnvy.mc.player.setSprinting(true);
        String bypass = ((String) allDirectionsBypassValue.getValue()).toLowerCase();

        if (bypass.equals("rotate")) {
            setTargetRotation(getMovingYaw(), RebootedEnvy.mc.player.rotationPitch, 10);
        } else if (bypass.equals("rotate2")) {
            float forward = RebootedEnvy.mc.player.movementInput.moveForward;
            float strafe = RebootedEnvy.mc.player.movementInput.moveStrafe;
            float yaw = RebootedEnvy.mc.player.rotationYaw;
            if (forward > 0.0F) {
                if (strafe > 0.0F) yaw -= 45.0F; else if (strafe < 0.0F) yaw += 45.0F;
            } else if (forward < 0.0F) {
                yaw += 180.0F;
                if (strafe > 0.0F) yaw += 45.0F; else if (strafe < 0.0F) yaw -= 45.0F;
            } else if (strafe > 0.0F) {
                yaw -= 90.0F;
            } else if (strafe < 0.0F) {
                yaw += 90.0F;
            }
            setTargetRotation(yaw, RebootedEnvy.mc.player.rotationPitch, 10);
        } else if (bypass.equals("toggle")) {
            sendAction(CPacketEntityAction.Action.STOP_SPRINTING);
            sendAction(CPacketEntityAction.Action.START_SPRINTING);
        } else if (bypass.equals("minemora")) {
            if (RebootedEnvy.mc.player.onGround) {
                RebootedEnvy.mc.player.setPosition(
                        RebootedEnvy.mc.player.posX,
                        RebootedEnvy.mc.player.posY + 0.0000013D,
                        RebootedEnvy.mc.player.posZ
                );
                RebootedEnvy.mc.player.motionY = 0.0;
            }
        } else if (bypass.equals("limitspeed")) {
            if (!(boolean) allDirectionsLimitSpeedGround.getValue() || RebootedEnvy.mc.player.onGround) {
                limitSpeedByPercent((float) (double) allDirectionsLimitSpeedValue.getValue());
            }
        } else if (bypass.equals("spoof")) {
            spoofStat = true;
        } else {
            spoofStat = false;
        }
    }

    @Override
    public void onPacket(Object packet) {
        if (!isEnabled()) return;
        if (packet instanceof CPacketEntityAction) {
            CPacketEntityAction p = (CPacketEntityAction) packet;
            if ((boolean) noPacket.getValue()
                    && (p.getAction() == CPacketEntityAction.Action.START_SPRINTING
                     || p.getAction() == CPacketEntityAction.Action.STOP_SPRINTING)) {
            }
            if ((boolean) noStopServerSide.getValue()
                    && p.getAction() == CPacketEntityAction.Action.STOP_SPRINTING) {
            }
        }
    }

    private void sendAction(CPacketEntityAction.Action action) {
        if (RebootedEnvy.mc != null && RebootedEnvy.mc.player != null && RebootedEnvy.mc.player.connection != null) {
            RebootedEnvy.mc.player.connection.sendPacket(new CPacketEntityAction(RebootedEnvy.mc.player, action));
        }
    }

    private boolean isMoving() {
        if (RebootedEnvy.mc.player == null) return false;
        MovementInput input = RebootedEnvy.mc.player.movementInput;
        return (input.moveForward != 0F || input.moveStrafe != 0F);
    }

    private float getMovingYaw() {
        float rotationYaw = RebootedEnvy.mc.player.rotationYaw;
        if (RebootedEnvy.mc.player.movementInput.moveForward < 0F) rotationYaw += 180F;
        float forward = (RebootedEnvy.mc.player.movementInput.moveForward < 0F) ? -0.5F
                : (RebootedEnvy.mc.player.movementInput.moveForward > 0F) ? 0.5F : 1F;
        if (RebootedEnvy.mc.player.movementInput.moveStrafe > 0F) rotationYaw -= 90F * forward;
        if (RebootedEnvy.mc.player.movementInput.moveStrafe < 0F) rotationYaw += 90F * forward;
        return rotationYaw;
    }

    private void setTargetRotation(float yaw, float pitch, int keepLength) {
    }

    private void limitSpeedByPercent(float percent) {
        RebootedEnvy.mc.player.motionX *= percent;
        RebootedEnvy.mc.player.motionZ *= percent;
    }
}

질문

забыл сказать, что там где AllDirections: None моды почему то нельзя менять может в каком-то классе отдельном можно добавить возможность изменения мода еще если есть такая возможность измените этот класс или создайте, и заново под адаптацию этого спринта с этим же самим классом сделайте чтобы я смог менять мод сам еще спринта ну вы поняли типо и отправляйте опять же во всем коде да

답변

Для добавления возможности изменения режима (AllDirectionsBypass) потребуется немного изменить/доработать систему настроек в вашем проекте. В частности, в классе ModeSetting и в обработке его изменения.

Изменённый `ModeSetting.java`

package com.RebootedEnvy.ModuleSystem;

import java.util.Arrays;

public class ModeSetting extends Setting {

    private final String[] modes;

    public ModeSetting(String name, String defaultMode, String[] modes) {
        super(name, SettingType.MODE, defaultMode);
        this.modes = modes;
    }

    public String getMode() {
        return (String) getValue();
    }

    public void setMode(String newMode) {
        if (Arrays.asList(modes).contains(newMode)) {
            setValue(newMode);
        }
    }

    public void cycleMode() {
        int currentIndex = Arrays.asList(modes).indexOf(getMode());
        if (currentIndex == -1) return; // Если текущий режим не найден
        currentIndex = (currentIndex + 1) % modes.length; // Переход к следующему режиму
        setValue(modes[currentIndex]);
    }

    public String[] getModes() {
        return modes;
    }
}

Теперь ModeSetting включает метод cycleMode(), который позволяет переключать режимы по кругу. Это пригодится в GUI для изменения настроек.

Обновление класса `Sprint`

Теперь добавим обработку изменения режима в спринте.

package com.RebootedEnvy.Modules.Movement;

import com.RebootedEnvy.ModuleSystem.Module;
import com.RebootedEnvy.ModuleSystem.ModuleType;
import com.RebootedEnvy.ModuleSystem.Setting;
import com.RebootedEnvy.ModuleSystem.ModeSetting;
import com.RebootedEnvy.ModuleSystem.SettingType;
import com.RebootedEnvy.RebootedEnvy;
import net.minecraft.init.MobEffects;
import net.minecraft.network.play.client.CPacketEntityAction;
import net.minecraft.util.MovementInput;
import net.minecraft.util.math.MathHelper;

public class Sprint extends Module {

    private Setting jumpDirectionsValue = new Setting("JumpDirections", SettingType.BOOLEAN, false);
    private Setting allDirectionsValue = new Setting("AllDirections", SettingType.BOOLEAN, true);
    private ModeSetting allDirectionsBypassValue = new ModeSetting("AllDirBypass", "None",
            new String[]{"Rotate", "Rotate2", "Toggle", "Minemora", "Spoof", "LimitSpeed", "None"});
    private Setting blindnessValue = new Setting("Blindness", SettingType.BOOLEAN, true);
    private Setting useItemValue = new Setting("UseItem", SettingType.BOOLEAN, false);
    private Setting foodValue = new Setting("Food", SettingType.BOOLEAN, true);
    private Setting noStopServerSide = new Setting("ServerSideKeepSprint", SettingType.BOOLEAN, false);
    private Setting checkServerSide = new Setting("CheckServerSide", SettingType.BOOLEAN, false);
    private Setting checkServerSideGround = new Setting("CheckServerSideOnlyGround", SettingType.BOOLEAN, false);
    private Setting noPacket = new Setting("NoPacket", SettingType.BOOLEAN, false);
    private Setting allDirectionsLimitSpeedGround = new Setting("LimitSpeedOnlyGround", SettingType.BOOLEAN, true);
    private Setting allDirectionsLimitSpeedValue = new Setting("LimitSpeed%", SettingType.NUMBER, 0.7D, 0.5D, 1.0D);

    private boolean spoofStat = false;

    public Sprint() {
        super("Sprint", 0, ModuleType.Movement);
        addSetting(jumpDirectionsValue);
        addSetting(allDirectionsValue);
        addSetting(allDirectionsBypassValue);
        addSetting(blindnessValue);
        addSetting(useItemValue);
        addSetting(foodValue);
        addSetting(noStopServerSide);
        addSetting(checkServerSide);
        addSetting(checkServerSideGround);
        addSetting(noPacket);
        addSetting(allDirectionsLimitSpeedGround);
        addSetting(allDirectionsLimitSpeedValue);
    }

    @Override
    public void onUpdate() {
        if (!isEnabled()) return;
        if (RebootedEnvy.mc == null || RebootedEnvy.mc.player == null || RebootedEnvy.mc.world == null) return;

        boolean canSprint = isMoving()
                && !RebootedEnvy.mc.player.isSneaking()
                && (!((boolean) blindnessValue.getValue()) || !RebootedEnvy.mc.player.isPotionActive(MobEffects.BLINDNESS))
                && (!((boolean) foodValue.getValue()) || RebootedEnvy.mc.player.getFoodStats().getFoodLevel() > 6.0F
                    || RebootedEnvy.mc.player.capabilities.allowFlying)
                && (!((boolean) useItemValue.getValue()) || !RebootedEnvy.mc.player.isHandActive());

        if (!canSprint) {
            RebootedEnvy.mc.player.setSprinting(false);
            return;
        }

        if (!(boolean) allDirectionsValue.getValue()) {
            RebootedEnvy.mc.player.setSprinting(true);
            return;
        }

        RebootedEnvy.mc.player.setSprinting(true);
        String bypass = allDirectionsBypassValue.getMode().toLowerCase();

        if (bypass.equals("rotate")) {
            setTargetRotation(getMovingYaw(), RebootedEnvy.mc.player.rotationPitch, 10);
        } else if (bypass.equals("rotate2")) {
            float forward = RebootedEnvy.mc.player.movementInput.moveForward;
            float strafe = RebootedEnvy.mc.player.movementInput.moveStrafe;
            float yaw = RebootedEnvy.mc.player.rotationYaw;
            if (forward > 0.0F) {
                if (strafe > 0.0F) yaw -= 45.0F; else if (strafe < 0.0F) yaw += 45.0F;
            } else if (forward < 0.0F) {
                yaw += 180.0F;
                if (strafe > 0.0F) yaw += 45.0F; else if (strafe < 0.0F) yaw -= 45.0F;
            } else if (strafe > 0.0F) {
                yaw -= 90.0F;
            } else if (strafe < 0.0F) {
                yaw += 90.0F;
            }
            setTargetRotation(yaw, RebootedEnvy.mc.player.rotationPitch, 10);
        } else if (bypass.equals("toggle")) {
            sendAction(CPacketEntityAction.Action.STOP_SPRINTING);
            sendAction(CPacketEntityAction.Action.START_SPRINTING);
        } else if (bypass.equals("minemora")) {
            if (RebootedEnvy.mc.player.onGround) {
                RebootedEnvy.mc.player.setPosition(
                        RebootedEnvy.mc.player.posX,
                        RebootedEnvy.mc.player.posY + 0.0000013D,
                        RebootedEnvy.mc.player.posZ
                );
                RebootedEnvy.mc.player.motionY = 0.0;
            }
        } else if (bypass.equals("limitspeed")) {
            if (!(boolean) allDirectionsLimitSpeedGround.getValue() || RebootedEnvy.mc.player.onGround) {
                limitSpeedByPercent((float) (double) allDirectionsLimitSpeedValue.getValue());
            }
        } else if (bypass.equals("spoof")) {
            spoofStat = true;
        } else {
            spoofStat = false;
        }
    }

    @Override
    public void onPacket(Object packet) {
        if (!isEnabled()) return;
        if (packet instanceof CPacketEntityAction) {
            CPacketEntityAction p = (CPacketEntityAction) packet;
            if ((boolean) noPacket.getValue()
                    && (p.getAction() == CPacketEntityAction.Action.START_SPRINTING
                     || p.getAction() == CPacketEntityAction.Action.STOP_SPRINTING)) {
            }
            if ((boolean) noStopServerSide.getValue()
                    && p.getAction() == CPacketEntityAction.Action.STOP_SPRINTING) {
            }
        }
    }

    private void sendAction(CPacketEntityAction.Action action) {
        if (RebootedEnvy.mc != null && RebootedEnvy.mc.player != null && RebootedEnvy.mc.player.connection != null) {
            RebootedEnvy.mc.player.connection.sendPacket(new CPacketEntityAction(RebootedEnvy.mc.player, action));
        }
    }

    private boolean isMoving() {
        if (RebootedEnvy.mc.player == null) return false;
        MovementInput input = RebootedEnvy.mc.player.movementInput;
        return (input.moveForward != 0F || input.moveStrafe != 0F);
    }

    private float getMovingYaw() {
        float rotationYaw = RebootedEnvy.mc.player.rotationYaw;
        if (RebootedEnvy.mc.player.movementInput.moveForward < 0F) rotationYaw += 180F;
        float forward = (RebootedEnvy.mc.player.movementInput.moveForward < 0F) ? -0.5F
                : (RebootedEnvy.mc.player.movementInput.moveForward > 0F) ? 0.5F : 1F;
        if (RebootedEnvy.mc.player.movementInput.moveStrafe > 0F) rotationYaw -= 90F * forward;
        if (RebootedEnvy.mc.player.movementInput.moveStrafe < 0F) rotationYaw += 90F * forward;
        return rotationYaw;
    }

    private void setTargetRotation(float yaw, float pitch, int keepLength) {
    }

    private void limitSpeedByPercent(float percent) {
        RebootedEnvy.mc.player.motionX *= percent;
        RebootedEnvy.mc.player.motionZ *= percent;
    }
}

Теперь ModeSetting позволяет циклически переключать режимы. Для изменения режима, например, в GUI, можно просто вызвать allDirectionsBypassValue.cycleMode().

질문

사고

답변

질문

사고

답변

질문

사고

답변

질문

사고

답변

질문

사고

답변

질문

답변

Изменённый ModeSetting.java

Обновление класса Sprint

이 Q&A 공유하기

Изменённый `ModeSetting.java`

Обновление класса `Sprint`