вообщем проблема в том что я не могу написать нормальные ротации из за того что все ротации у них строятся на этом -
ну и вопрос как мне на этом говне написать ротацию?
вот вам для наглядности фулл код Urotate
help
рандом ротка с Excellent omni:
case "Плавные снапы" -> {
rotationRules = new RotateRules(
60.F,
true,
Easings.QUART_OUT,
.85F,
false,
false,
false,
5.F,
0.5F,
0.3F,
false,
.25F,
true,
true,
110.F,
25.F,
28.F,
20.F,
.5F,
.0F,
true,
.008F,
false,
false,
false,
0.F,
0.F);
}ну и вопрос как мне на этом говне написать ротацию?
вот вам для наглядности фулл код Urotate
Urotate.java:
package pulsar.tech.pulsar.client.impl.component.impl.attackaura;
import lombok.AllArgsConstructor;
import lombok.Getter;
import net.minecraft.client.Minecraft;
import net.minecraft.entity.LivingEntity;
import net.minecraft.util.math.vector.Vector2f;
import net.minecraft.util.math.vector.Vector3d;
import pulsar.tech.common.animation.Easing;
import pulsar.tech.common.animation.Easings;
import pulsar.tech.pulsar.client.impl.component.impl.rotation.Rotation;
import pulsar.tech.pulsar.client.impl.component.impl.rotation.RotationComponent;
import pulsar.tech.pulsar.client.impl.feature.impl.combat.AttackAura;
import pulsar.tech.pulsar.client.util.combat.RayTraceUtil;
import pulsar.tech.pulsar.client.util.combat.RotationUtil;
import pulsar.tech.pulsar.client.util.combat.SensUtil;
import pulsar.tech.pulsar.client.util.math.MathUtils;
import java.security.SecureRandom;
import static java.lang.Math.hypot;
import static java.lang.Math.toDegrees;
import static net.minecraft.util.math.MathHelper.atan2;
import static net.minecraft.util.math.MathHelper.wrapDegrees;
public class URotate {
private final Minecraft mc = Minecraft.getInstance();
private final SecureRandom random = new SecureRandom();
private final AttackAura aura;
private float returnSpeed = 50.F;
private URotate(AttackAura aura) {
this.aura = aura;
}
public static URotate create(AttackAura aura) {
return new URotate(aura);
}
@AllArgsConstructor
private class RotateRules {
private final float скорость_возращения_ротации_в_исходное_положение;
private final boolean всегда_использовать_мультипоинты_без_необходимости;
private final Easing изинг_ротации;
private final float сила_изинга_от_0_до_1;
private final boolean развернуть_формулу_изинга;
private final boolean отводиться_перед_ударом, отводиться_перед_ударом_если_игрок_за_стеной;
private final float опускать_питч_при_падении_на, дрожащий_рандоминг_Yaw, дрожащий_рандоминг_Pitch;
private final boolean не_позволять_Pitch_подниматься_при_падении;
private final float фактор_замедления_ротации_при_наводке_от_0_до_1;
private final boolean ротация_работает_только_перед_ударом, ротация_работает_только_во_время_удара;
private final float максимальная_скорость_Yaw, минимальная_скорость_Yaw, максимальная_скорость_Pitch, минимальная_скорость_Pitch, фактор_рандома_скорости_ротации_от_0_до_1, фактор_взамоисключения_скорости_Yaw_и_Pitch;
private final boolean учитывать_чувствительность_мыши;
private final float размер_области_рандомизации_поинта_для_ротации;
private final boolean остановить_ротацию_перед_тиком_удара, остановить_ротацию_в_тик_удара, остановить_ротацию_после_тика_удара;
private final float максимальное_взаимное_волновое_смещение_оси_от_противоположной;
private final float градус_постоянной_отводки_нетнет_и_включить_пулялку_питча_в_небо;
public float getReturnRotationSpeed() {
return скорость_возращения_ротации_в_исходное_положение;
}
public boolean isAlwaysUseMultiPoints() {
return всегда_использовать_мультипоинты_без_необходимости;
}
public Easing getEaseRotate() {
return изинг_ротации;
}
public float getEaseStrengthPercent() {
return сила_изинга_от_0_до_1;
}
public boolean isEasingOpposite() {
return развернуть_формулу_изинга;
}
public boolean isPreHitTurnAway() {
return отводиться_перед_ударом;
}
public boolean isBehindWallTurnAway() {
return отводиться_перед_ударом_если_игрок_за_стеной;
}
public float getOnHitPullDownPitch090() {
return опускать_питч_при_падении_на;
}
public float getRandRotDragYaw045() {
return дрожащий_рандоминг_Yaw;
}
public float getRandRotDragPitch030() {
return дрожащий_рандоминг_Pitch;
}
public boolean isNotDoUpPitchOnFall() {
return не_позволять_Pitch_подниматься_при_падении;
}
public float getSlowSpeedFactorPC01OnAnyEntity() {
return фактор_замедления_ротации_при_наводке_от_0_до_1;
}
public boolean isRotOnlyPreHitTick() {
return ротация_работает_только_перед_ударом;
}
public boolean isRotOnlyHitTick() {
return ротация_работает_только_во_время_удара;
}
public float getMaxYawSpeed0180() {
return максимальная_скорость_Yaw;
}
public float getMinYawSpeed0180() {
return минимальная_скорость_Yaw;
}
public float getMaxPitchSpeed090() {
return максимальная_скорость_Pitch;
}
public float getMinPitchSpeed090() {
return минимальная_скорость_Pitch;
}
public float getRotSpeedRandPC01() {
return фактор_рандома_скорости_ротации_от_0_до_1;
}
public float getMutualExclusionXYSpeedMul01() {
return фактор_взамоисключения_скорости_Yaw_и_Pitch;
}
public boolean isGcdFilter() {
return учитывать_чувствительность_мыши;
}
public float getVectorPointPosRandom0rec() {
return размер_области_рандомизации_поинта_для_ротации;
}
public boolean isPauseRotationPreHitTick() {
return остановить_ротацию_перед_тиком_удара;
}
public boolean isPauseRotationOnHitTick() {
return остановить_ротацию_в_тик_удара;
}
public boolean isPauseRotationPostHitTick() {
return остановить_ротацию_после_тика_удара;
}
public float getMutualAdditionOfOppositeRotationsFromDelta() {
return максимальное_взаимное_волновое_смещение_оси_от_противоположной;
}
public float getNONOAwayRadialYaw() {
return градус_постоянной_отводки_нетнет_и_включить_пулялку_питча_в_небо;
}
}
private RotateRules asRotationName(String rotationName) {
if (rotationName.equalsIgnoreCase("Без ротации")) return null;
RotateRules rotationRules = null;
switch (rotationName) {
case "По умолчанию" -> {
rotationRules = new RotateRules(
70.F,
true,
Easings.EXPO_IN_OUT,
.85F,
false,
false,
false,
0.F,
0.5F,
0.3F,
false,
.22F,
false,
false,
35.F,
28.F,
22.F,
16.F,
.15F,
.6F,
true,
.008F,
false,
false,
false,
0.F,
0.F);
}
case "SpookyTime" -> {
rotationRules = new RotateRules(
180.F,
true,
Easings.CUBIC_OUT,
0.4F,
false,
true,
false,
.0F,
2.5F,
.6F,
false,
.2F,
false,
false,
120.F,
85.F,
75.F,
48.F,
.08F,
.0F,
true,
.01F,
false,
false,
false,
0.F,
0.F);
}
case "Снапы" -> {
rotationRules = new RotateRules(
135.F,
true,
Easings.EXPO_OUT,
0.6F,
false,
false,
false,
.0F,
4.5F,
3.2F,
false,
.15F,
false,
true,
125.F,
82.F,
38.F,
30.F,
.25F,
.0F,
true,
.03F,
false,
false,
false,
0.F,
0.F);
}
case "Плавные снапы" -> {
rotationRules = new RotateRules(
60.F,
true,
Easings.QUART_OUT,
.85F,
false,
false,
false,
5.F,
0.5F,
0.3F,
false,
.25F,
true,
true,
110.F,
25.F,
28.F,
20.F,
.5F,
.0F,
true,
.008F,
false,
false,
false,
0.F,
0.F);
}
case "SpookyTime TEST" -> {
rotationRules = new RotateRules(
165.F,
true,
Easings.CUBIC_OUT,
0.46F,
false,
true,
true,
1.8F,
3.2F,
1.1F,
false,
0.28F,
false,
false,
132.F,
72.F,
68.F,
36.F,
0.22F,
0.35F,
true,
0.028F,
false,
false,
false,
2.6F,
0.F
);
}
case "Хвх" -> {
rotationRules = new RotateRules(
180.F,
true,
Easings.CUBIC_OUT,
0.4F,
false,
false,
false,
0.F,
2.5F,
.6F,
false,
.2F,
false,
false,
120.F,
85.F,
75.F,
48.F,
.08F,
.0F,
true,
.01F,
false,
false,
false,
0.F,
0.F);
}
}
return rotationRules;
}
@Getter
@AllArgsConstructor
public class Vector3d2fRB {
private final Vector3d vec3d;
private final Vector2f vec2f;
private final boolean toUse;
}
private double randomAroundD2(double value) {
return random.nextDouble(-value / 2.D, value / 2.D);
}
private float randomAroundF2(float value) {
return random.nextFloat(-value / 2.F, value / 2.F);
}
private float randomF(float valueMin, float valueMax) {
return random.nextFloat(valueMin, valueMax);
}
private static int ticksWave;
private float[] getRotationsWaveAdditions(float deltaYaw, float deltaPitch, float maxAddition, int tickWaveDelay) {
if (maxAddition == 0 || deltaYaw == 0.F && deltaPitch == 0.F) return null;
++ticksWave;
float mulWave = ticksWave % tickWaveDelay / (float) tickWaveDelay;
mulWave = (mulWave > .5F ? 1.F - mulWave : mulWave) * 2.F;
mulWave = -1.F + mulWave * 2.F;
return new float[]{
clamp(deltaPitch / 180.F * mulWave * maxAddition, -maxAddition, maxAddition),//yaw addition
clamp(deltaYaw / 45.F * mulWave * maxAddition, -maxAddition, maxAddition)//pitch addition
};
}
private Vector2f getVanillaRotate(Vector3d vec) {
final Vector3d eyesPos = mc.player.getEyePosition(1.F);
final Vector3d rot = vec.add(-eyesPos.x, -eyesPos.y, -eyesPos.z);
return new Vector2f((float) Math.atan2(rot.z, rot.x) * 180.F / (float) Math.PI - 90.F, (float) toDegrees(-Math.atan2(rot.y, Math.sqrt(rot.x * rot.x + rot.z * rot.z))));
}
private boolean anyEntityOnRay(LivingEntity livingIn, float yaw, float pitch, double range) {
return livingIn != null && RayTraceUtil.isViewEntity(livingIn, wrapDegrees(yaw), pitch, (float) range, true);
}
private Vector2f getTurnAwayOfRotate(Vector2f prevRotate, LivingEntity livingIn, double rangeCheck, int dopStep) {
float yawPlus = 0.F, pitchPlus = 0.F;
int randomIntRange01 = UAura.randomInt1PosibleOrNot(), attempts = 0;
for (float extYaw = 0.F; extYaw < 180.F; extYaw += 6.F) {
++attempts;
if (!anyEntityOnRay(livingIn, prevRotate.x + extYaw * randomIntRange01, prevRotate.y, rangeCheck)) {
if (attempts >= dopStep) {
yawPlus = extYaw * randomIntRange01;
break;
}
}
}
attempts = 0;
for (float extPitch = 0.F; extPitch < 90.F; extPitch += 3.F) {
++attempts;
if (!anyEntityOnRay(livingIn, prevRotate.x, prevRotate.y + extPitch * randomIntRange01, rangeCheck)) {
if (attempts >= dopStep) {
pitchPlus = extPitch * randomIntRange01;
break;
}
}
}
return Math.abs(yawPlus) <= Math.abs(pitchPlus) ? new Vector2f(prevRotate.x + yawPlus, prevRotate.y) : new Vector2f(prevRotate.x, prevRotate.y + pitchPlus);
}
public Vector3d2fRB updateRotationData(String rotationName, Vector2f prevRotation, double rangeRayCastCheck) {
RotateRules rotateRules = asRotationName(rotationName);
if (rotateRules == null)
return new Vector3d2fRB(aura.target().getEyePosition(mc.getRenderPartialTicks()), prevRotation, false);
final Vector3d rotatePointVector3d = UBoxPoints.getBestVector3dOnEntityBox(aura.target(), rotateRules.isAlwaysUseMultiPoints());
final boolean notAnyTopPoint = UBoxPoints.entityBoxVec3dsAlternates(aura.target()).isEmpty();
return updateRotationData(rotateRules, aura.target(), UAura.msCooldownReached(-100) && !UAura.msCooldownReached() && mc.player.getMotion().y <= .16470125793695456, UAura.msCooldownReached() && !UAura.msCooldownReached(50), !UAura.msCooldownHasMs(50), notAnyTopPoint, rotatePointVector3d, prevRotation, anyEntityOnRay(aura.target(), prevRotation.x, prevRotation.y, rangeRayCastCheck));
}
private Vector3d2fRB updateRotationData(RotateRules rules, LivingEntity entityTarget, boolean preHitTick, boolean hitTick, boolean postHitTick, boolean behindWall, Vector3d rotateTo, Vector2f rotation, boolean prevRayCasted) {
if (rules == null || entityTarget == null || entityTarget.getBoundingBox() == null)
return new Vector3d2fRB(rotateTo, rotation, false);
this.returnSpeed = rules.getReturnRotationSpeed();
if (rules.isRotOnlyPreHitTick() && !(preHitTick || UAura.msCooldownReached()) || rules.isRotOnlyHitTick() && !(hitTick || UAura.msCooldownReached(50))) {
return new Vector3d2fRB(rotateTo, rotation, false);
}
rotation = new Vector2f(rotation.x, rotation.y);
Easing easing = rules.getEaseRotate();
float easingPC = rules.getEaseStrengthPercent();
boolean easingIsOpposite = rules.isEasingOpposite();
double posRandomValue = rules.getVectorPointPosRandom0rec();
boolean forceTurnAway = rules.isPreHitTurnAway() && preHitTick || rules.isBehindWallTurnAway() && behindWall && preHitTick;
boolean forceStopRotation = rules.isPauseRotationPreHitTick() && preHitTick || rules.isPauseRotationOnHitTick() && hitTick || rules.isPauseRotationPostHitTick() && postHitTick;
float forcePullDownPitch = Math.min(rules.getOnHitPullDownPitch090(), 90.F);
if (forcePullDownPitch > 0.F) {
float forcePullDownPitchMul = Math.min(mc.player.fallDistance / 1.17F, 1.F);
forcePullDownPitchMul = (forcePullDownPitchMul > .5F ? 1.F - forcePullDownPitchMul : forcePullDownPitchMul) * 2.F;
if (easing != null && easingPC > 0.F) {
forcePullDownPitchMul = lerp(forcePullDownPitchMul, (float) easing.ease(forcePullDownPitchMul), easingPC);
}
forcePullDownPitch *= forcePullDownPitchMul;
}
float additionOfDeltasFromOpposite = rules.getMutualAdditionOfOppositeRotationsFromDelta();
float addRandomYaw = rules.getRandRotDragYaw045() == 0.F ? 0.F : randomAroundF2(rules.getRandRotDragYaw045()), addRandomPitch = rules.getRandRotDragPitch030() == 0.F ? 0.F : randomAroundF2(rules.getRandRotDragPitch030());
boolean forceLockupPitchUpping = rules.isNotDoUpPitchOnFall() && mc.player.fallDistance > 0 && mc.player.fallDistance < 1.3F;
float speedMul = (prevRayCasted ? Math.max(Math.min(1.F - rules.getSlowSpeedFactorPC01OnAnyEntity(), 1.F), 0.F) : 1.F) * (rules.getRotSpeedRandPC01() > 0.F ? (1.F + randomF(-.33333333F, .5F) * rules.getRotSpeedRandPC01()) : 1.F);
float mixYawSpeedAndPitchSpeedPC01 = Math.min(rules.getMutualExclusionXYSpeedMul01(), 1.F);
boolean gcdFix = rules.isGcdFilter();
if (posRandomValue > 0.F)
rotateTo = rotateTo.add(randomAroundD2(posRandomValue), randomAroundD2(posRandomValue), randomAroundD2(posRandomValue));
Vector2f virtRotateVanilla = getVanillaRotate(rotateTo);
if (forceTurnAway) virtRotateVanilla = getTurnAwayOfRotate(virtRotateVanilla, entityTarget, 6.F, 5);
if (forcePullDownPitch > 0.F) virtRotateVanilla.y = Math.min(virtRotateVanilla.y + forcePullDownPitch, 90.F);
if (addRandomYaw != 0.F || addRandomPitch != 0.F) {
virtRotateVanilla.x += addRandomYaw;
virtRotateVanilla.y += addRandomPitch;
}
float nonoYawAwayYaw = rules.getNONOAwayRadialYaw();
if (nonoYawAwayYaw > 0.F) {
float cooledPCPre = clamp((UAura.msCooldownReach() - 50.F) * 2.F / UAura.getMsCooldown(), 0.F, 2.F);
cooledPCPre = cooledPCPre > 1.F ? 2.F - cooledPCPre : cooledPCPre;
float waveM011 = MathUtils.valWave01(System.currentTimeMillis() % 600 / 600.F);
waveM011 -= .5F;
waveM011 *= 2.F;
float side = UAura.randomInt1PosibleOrNotOnHit;
float offMaxYaw = nonoYawAwayYaw, offWaveYaw = nonoYawAwayYaw / 9.F;
float offYaw = offWaveYaw * side * waveM011 + offMaxYaw * side * (float) Easings.powOut(1).ease(cooledPCPre);
virtRotateVanilla.x += offYaw;
if (mc.player.ticksExisted % 160 < 6)
virtRotateVanilla.y = -90.F;
}
if (additionOfDeltasFromOpposite > 0.F) {
final float yawDiffAtPrev = RotationUtil.getAngleDifference(rotation.x, virtRotateVanilla.x), pitchDiffAtPrev = Math.abs(rotation.y - virtRotateVanilla.y);
final float[] mouseEffectAddition = getRotationsWaveAdditions(yawDiffAtPrev, pitchDiffAtPrev, additionOfDeltasFromOpposite, 10);
virtRotateVanilla.x += mouseEffectAddition[0];
virtRotateVanilla.y += mouseEffectAddition[1];
}
virtRotateVanilla.x = wrapDegrees(virtRotateVanilla.x);
virtRotateVanilla.y = clamp(virtRotateVanilla.y, -90.F, 90.F);
if (forceLockupPitchUpping) virtRotateVanilla.y = Math.max(virtRotateVanilla.y, rotation.y);
final float yawDiffAtPrev = RotationUtil.getAngleDifference(rotation.x, virtRotateVanilla.x), pitchDiffAtPrev = Math.abs(rotation.y - virtRotateVanilla.y);
final float yawDiffPC01 = Math.min(yawDiffAtPrev / 180.F, 1.F), pitchDiffPC01 = Math.min(pitchDiffAtPrev / 90.F, 1.F);
final float yawDiffWavePC01P = (yawDiffPC01 > .5F ? 1.F - yawDiffPC01 : yawDiffPC01) * 2.F, pitchDiffWavePC01P = (pitchDiffPC01 > .5F ? 1.F - pitchDiffPC01 : pitchDiffPC01) * 2.F;
final float yawDiffWavePC01N = 1.F - yawDiffWavePC01P, pitchDiffWavePC01N = 1.F - pitchDiffWavePC01P;
float yawSpeedPC01Calc = yawDiffWavePC01P;
float pitchSpeedPC01Calc = pitchDiffWavePC01P;
if (easing != null && easingPC > 0.F) {
if (easingIsOpposite) {
yawSpeedPC01Calc = lerp(yawDiffWavePC01N, (float) easing.ease(yawDiffWavePC01N), easingPC);
pitchSpeedPC01Calc = lerp(pitchDiffWavePC01N, (float) easing.ease(pitchDiffWavePC01N), easingPC);
} else {
yawSpeedPC01Calc = lerp(yawDiffWavePC01P, (float) easing.ease(yawDiffWavePC01P), easingPC);
pitchSpeedPC01Calc = lerp(pitchDiffWavePC01P, (float) easing.ease(pitchDiffWavePC01P), easingPC);
}
}
//mutual exclusion yaw & pitch speed of 0 - 1 percent float
if (mixYawSpeedAndPitchSpeedPC01 > 0.F) {
float yawSpeedPC01CalcCopy = yawSpeedPC01Calc;
yawSpeedPC01Calc *= 1.F - pitchSpeedPC01Calc * mixYawSpeedAndPitchSpeedPC01;
pitchSpeedPC01Calc *= 1.F - yawSpeedPC01CalcCopy * mixYawSpeedAndPitchSpeedPC01;
}
float yawSpeed = lerp(rules.getMinYawSpeed0180(), rules.getMaxYawSpeed0180(), yawSpeedPC01Calc) * speedMul;
float pitchSpeed = lerp(rules.getMinPitchSpeed090(), rules.getMaxPitchSpeed090(), pitchSpeedPC01Calc) * speedMul;
final float yawDelta = wrapDegrees(virtRotateVanilla.x - rotation.x);
final float pitchDelta = virtRotateVanilla.y - mc.player.rotationPitch;
if (!forceStopRotation) {
rotation.x = wrapDegrees(rotation.x + clamp(yawDelta, -yawSpeed, yawSpeed));
rotation.y = mc.player.rotationPitch + clamp(pitchDelta, -pitchSpeed, pitchSpeed);
}
if (gcdFix) {
rotation.x = SensUtil.getSens(rotation.x);
rotation.y = SensUtil.getSens(rotation.y);
}
return new Vector3d2fRB(rotateTo, rotation, true);
}
public void rotatePrimitiveToSend(Vector2f rotateVector2f) {
if (rotateVector2f == null) {
RotationComponent.resetParentTimeout();
return;
}
RotationComponent.update(new Rotation(rotateVector2f.x, rotateVector2f.y), 360.F, this.returnSpeed, 1, 5);
}
public static Rotation getRotation(Vector3d vec) {
return new Rotation(
(float) wrapDegrees(toDegrees(atan2(vec.z, vec.x)) - 90),
(float) wrapDegrees(toDegrees(-atan2(vec.y, hypot(vec.x, vec.z))))
);
}
public static int clamp(int value, int min, int max) {
return Math.min(max, Math.max(value, min));
}
public static float clamp(float value, float min, float max) {
return Math.min(max, Math.max(value, min));
}
public static double clamp(double value, double min, double max) {
return Math.min(max, Math.max(value, min));
}
public static int lerp(int a, int b, float f) {
return a + (int) (f * (b - a));
}
public static float lerp(float a, float b, float f) {
return a + f * (b - a);
}
public static double lerp(double a, double b, double f) {
return a + f * (b - a);
}
}help
