public static RaycastInfo OV_raycast(Ray ray, float range, int mask)
{
switch (OV_DamageTool.OVType)
{
case OverrideType.Extended:
return(RaycastUtilities.GenerateOriginalRaycast(ray, MiscOptions.MeleeRangeExtension, mask));
case OverrideType.PlayerHit:
for (int i = 0; i < Provider.clients.Count; i++)
{
bool flag = VectorUtilities.GetDistance(Player.player.transform.position, Provider.clients[i].player.transform.position) > 15.5;
bool flag2 = !flag;
if (flag2)
{
RaycastInfo result;
RaycastUtilities.GenerateRaycast(out result);
return(result);
}
}
break;
case OverrideType.SilentAim:
{
RaycastInfo raycastInfo;
return(RaycastUtilities.GenerateRaycast(out raycastInfo) ? raycastInfo : RaycastUtilities.GenerateOriginalRaycast(ray, range, mask));
}
case OverrideType.SilentAimMelee:
{
RaycastInfo raycastInfo2;
return(RaycastUtilities.GenerateRaycast(out raycastInfo2) ? raycastInfo2 : RaycastUtilities.GenerateOriginalRaycast(ray, MiscOptions.MeleeRangeExtension, mask));
}
}
return(RaycastUtilities.GenerateOriginalRaycast(ray, range, mask));
}
public static void RotateObjectPerpendicularToTheGround(Transform myObject, LayerMask groundLayerMask)
{
Vector3 normal = RaycastUtilities.GetGroundNormal(myObject.position, groundLayerMask);
Vector3 forward = Vector3.Cross(myObject.right, normal);
Quaternion lookRotation = Quaternion.LookRotation(forward, normal);
myObject.rotation = lookRotation;
}
public static RaycastInfo OV_raycast(Ray ray, float range, int mask)
{
switch (OVType)
{
case OverrideType.Extended:
return(RaycastUtilities.GenerateOriginalRaycast(ray, MiscOptions.MeleeRangeExtension, mask));
case OverrideType.SilentAim: {
return(RaycastUtilities.GenerateRaycast(out RaycastInfo ri)
? ri
: RaycastUtilities.GenerateOriginalRaycast(ray, range, mask));
}
case OverrideType.SilentAimMelee: {
return(RaycastUtilities.GenerateRaycast(out RaycastInfo ri)
? ri
: RaycastUtilities.GenerateOriginalRaycast(ray, MiscOptions.MeleeRangeExtension, mask));
}
case OverrideType.PlayerHit:
for (int i = 0; i < Provider.clients.Count; i++)
{
if (VectorUtilities.GetDistance(Player.player.transform.position,
Provider.clients[i].player.transform.position) > 15.5)
{
continue;
}
RaycastUtilities.GenerateRaycast(out RaycastInfo ri2);
return(ri2);
}
break;
}
return(RaycastUtilities.GenerateOriginalRaycast(ray, range, mask));
}
public static bool GenerateRaycast(out RaycastInfo info)
{
ItemGunAsset itemGunAsset = OptimizationVariables.MainPlayer.equipment.asset as ItemGunAsset;
float num = (itemGunAsset != null) ? itemGunAsset.range : 15.5f;
info = RaycastUtilities.GenerateOriginalRaycast(new Ray(OptimizationVariables.MainPlayer.look.aim.position, OptimizationVariables.MainPlayer.look.aim.forward), num, RayMasks.DAMAGE_CLIENT);
if (RaycastOptions.EnablePlayerSelection && RaycastUtilities.TargetedPlayer != null)
{
GameObject gameObject = RaycastUtilities.TargetedPlayer.gameObject;
bool flag = true;
Vector3 position = OptimizationVariables.MainPlayer.look.aim.position;
if (Vector3.Distance(position, gameObject.transform.position) > num)
{
flag = false;
}
if (!SphereUtilities.GetRaycast(gameObject, position, out Vector3 point))
{
flag = false;
}
if (flag)
{
info = RaycastUtilities.GenerateRaycast(gameObject, point, info.collider);
return(true);
}
if (RaycastOptions.OnlyShootAtSelectedPlayer)
{
return(false);
}
}
if (RaycastUtilities.GetTargetObject(RaycastUtilities.Objects, out GameObject @object, out Vector3 point2, num))
{
info = RaycastUtilities.GenerateRaycast(@object, point2, info.collider);
return(true);
}
return(false);
}
private bool ProcessItem
(
ref Entity entity,
ref StVelocity velocity,
ref DefStJumpSettings setting,
ref DefStRunInput runInput,
ref DefStJumpInput input,
ref DefStWallJumpProcessData process,
ref CharacterControllerState state,
Transform transform
)
{
var action = input.State == InputState.Down && !MvUtils.OnGround(state, velocity) && Time.time > process.TimeBeforeNextWJ;
if (!action)
{
return(false);
}
var originalVelocity = velocity.Value;
var fwd = transform.forward;
var pos = transform.position + new Vector3(0, 0.4f + 0.1f); // hardcoded value (stepoffset)
var rot = transform.rotation;
var rd = 0.3f + 0.075f; // (radius)
var sw = 0.07f + 0.025f; // hardcoded value (skinwidth)
var height = 2f - 0.4f; // harcoded value (height and stepOffset)
var subheight = (height * 0.75f) - 0.005f;
CPhysicSettings.Active.SetGlobalCollision(transform.gameObject, false);
var direction = (Vector3)SrtComputeDirection(fwd, rot, runInput.Direction);
var rayTrace = UtilityWallRayTrace.RayTrace(ref direction, ref pos, ref rd, ref sw, ref height, ref subheight, transform.GetComponent <Collider>());
Debug.DrawRay(rayTrace.point, rayTrace.normal, Color.red, 10);
CPhysicSettings.Active.SetGlobalCollision(transform.gameObject, true);
var success = rayTrace.normal != Vector3.zero && Mathf.Abs(rayTrace.normal.y) < 0.2f;
if (success)
{
rayTrace.normal = rayTrace.normal.ToGrid(1).normalized;
velocity.Value = RaycastUtilities.SlideVelocityNoYChange(velocity.Value, rayTrace.normal);
velocity.Value.y = math.max(math.min(velocity.Value.y + 6.5f, 12f), 0);
var previousVelocity = velocity.Value;
var bounceDir = rayTrace.normal * 6f;
var minSpeed = bounceDir.magnitude;
velocity.Value += bounceDir;
var flatVelocity = velocity.Value.ToGrid(1);
var oldY = velocity.Value.y;
velocity.Value = Vector3.ClampMagnitude(flatVelocity, Mathf.Max(previousVelocity.magnitude, minSpeed));
velocity.Value.y = oldY;
process.TimeBeforeNextWJ = Time.time + DefaultCooldown;
input.TimeBeforeResetState = -1f;
input.State = InputState.None;
BroadcastNewEntity(PostUpdateCommands, true);
PostUpdateCommands.AddComponent(new DefStWallJumpEvent(Time.time, Time.frameCount, entity, originalVelocity, rayTrace.normal));
MvDelegateEvents.InvokeCharacterWalljump(entity);
}
return(success);
}
public static IEnumerator CheckTrigger()
{
for (; ;)
{
yield return(new WaitForSeconds(0.1f));
bool flag = !TriggerbotOptions.Enabled || !DrawUtilities.ShouldRun() || OptimizationVariables.MainPlayer.stance.stance == EPlayerStance.SPRINT || OptimizationVariables.MainPlayer.stance.stance == EPlayerStance.CLIMB || OptimizationVariables.MainPlayer.stance.stance == EPlayerStance.DRIVING;
if (flag)
{
TriggerbotOptions.IsFiring = false;
}
else
{
PlayerLook look = OptimizationVariables.MainPlayer.look;
Useable u = OptimizationVariables.MainPlayer.equipment.useable;
Useable useable = u;
Useable useable2 = useable;
if (useable2 == null)
{
TriggerbotOptions.IsFiring = false;
}
else
{
UseableGun useableGun;
UseableGun gun;
UseableMelee useableMelee;
if ((useableGun = (useable2 as UseableGun)) != null)
{
gun = useableGun;
ItemGunAsset PAsset = (ItemGunAsset)OptimizationVariables.MainPlayer.equipment.asset;
RaycastInfo ri = RaycastUtilities.GenerateOriginalRaycast(new Ray(look.aim.position, look.aim.forward), PAsset.range, RayMasks.DAMAGE_CLIENT);
if (AimbotCoroutines.LockedObject != null && AimbotCoroutines.IsAiming)
{
Ray r = OV_UseableGun.GetAimRay(look.aim.position, AimbotCoroutines.GetAimPosition(AimbotCoroutines.LockedObject.transform, "Skull"));
ri = RaycastUtilities.GenerateOriginalRaycast(new Ray(r.origin, r.direction), PAsset.range, RayMasks.DAMAGE_CLIENT);
r = default(Ray);
}
bool Valid = ri.player == null;
if (RaycastOptions.Enabled)
{
Valid = RaycastUtilities.GenerateRaycast(out ri);
}
if (Valid)
{
TriggerbotOptions.IsFiring = false;
continue;
}
EFiremode fire = (EFiremode)TriggerbotComponent.CurrentFiremode.GetValue(gun);
bool flag4 = fire == EFiremode.AUTO;
if (flag4)
{
TriggerbotOptions.IsFiring = true;
continue;
}
TriggerbotOptions.IsFiring = !TriggerbotOptions.IsFiring;
}
else if ((useableMelee = (useable2 as UseableMelee)) != null)
{
ItemMeleeAsset MAsset = (ItemMeleeAsset)OptimizationVariables.MainPlayer.equipment.asset;
RaycastInfo ri2 = RaycastUtilities.GenerateOriginalRaycast(new Ray(look.aim.position, look.aim.forward), MAsset.range, RayMasks.DAMAGE_CLIENT);
bool flag5 = AimbotCoroutines.LockedObject != null && AimbotCoroutines.IsAiming;
if (flag5)
{
Ray r2 = OV_UseableGun.GetAimRay(look.aim.position, AimbotCoroutines.GetAimPosition(AimbotCoroutines.LockedObject.transform, "Skull"));
ri2 = RaycastUtilities.GenerateOriginalRaycast(new Ray(r2.origin, r2.direction), MAsset.range, RayMasks.DAMAGE_CLIENT);
r2 = default(Ray);
}
bool Valid2 = ri2.player != null;
bool enabled2 = RaycastOptions.Enabled;
if (enabled2)
{
Valid2 = RaycastUtilities.GenerateRaycast(out ri2);
}
bool flag6 = !Valid2;
if (flag6)
{
TriggerbotOptions.IsFiring = false;
continue;
}
bool isRepeated = MAsset.isRepeated;
if (isRepeated)
{
TriggerbotOptions.IsFiring = true;
continue;
}
TriggerbotOptions.IsFiring = !TriggerbotOptions.IsFiring;
}
useable2 = null;
useableGun = null;
gun = null;
look = null;
u = null;
}
}
}
yield break;
}
private void SimulatePhysicStep(float dt)
{
for (int i = 0; i != m_Group.Length; i++)
{
var oldVelocity = m_Group.VelocityArray[i].Value;
var motor = m_Group.MotorArray[i];
var gameObject = m_Group.GameObjects[i];
var transform = m_Group.Transforms[i];
var slopeLimit = motor.CharacterController.slopeLimit;
var entity = m_Group.Entities[i];
var layerMask = CPhysicSettings.PhysicInteractionLayerMask;
var wasGrounded = motor.IsGrounded(layerMask);
var wasStableOnGround = motor.IsStableOnGround;
var wasSliding = motor.IsSliding;
if (!wasGrounded && !wasStableOnGround && !wasSliding)
{
oldVelocity += new Vector3(0, Physics.gravity.y, 0) * dt;
motor.CharacterController.stepOffset = 0.5f;
}
else if (wasGrounded && wasStableOnGround && !wasSliding)
{
motor.CharacterController.stepOffset = 0.5f;
//if (oldVelocity.y <= 0) oldVelocity.y = -motor.CharacterController.stepOffset;
if (oldVelocity.y <= 0)
{
oldVelocity.y = -1;
}
}
else
{
oldVelocity.y = -1;
}
if (!wasGrounded && Input.GetKey(KeyCode.LeftControl) && oldVelocity.y < -2f)
{
oldVelocity.y = Mathf.Lerp(oldVelocity.y, -0.25f, dt * 4f);
}
var oldPos = transform.position;
var velocity = oldVelocity * dt;
CPhysicSettings.Active.SetGlobalCollision(gameObject, true);
var previousPosition = transform.position;
var ev = motor.MoveBy(velocity);
CPhysicSettings.Active.SetGlobalCollision(gameObject, false);
var isGrounded = motor.IsGrounded(layerMask);
var correctVelocity = oldVelocity;
for (var j = ev.EventsStartIndex; j < ev.EventsLength; j++)
{
var hitEvent = ev.GetColliderHit(j);
if (OnControllerHasHitACollider(hitEvent, velocity.magnitude, oldPos, motor, transform,
ref correctVelocity))
{
break;
}
}
var newPosition = transform.position;
var momentum = (newPosition - previousPosition) / dt;
var previousMomentum = motor.Momentum;
// This is wrong, it should be done when sliding.
// In real life, we don't keep the height momentum when running.
/*if (wasGrounded && !isGrounded && previousMomentum.y > 0.5f && correctVelocity.y <= 0.1f)
* {
* isM = true;
*
* correctVelocity.y += previousMomentum.y;
*
* motor.MoveBy(Vector3.up * (previousMomentum.y * dt));
* }*/
// Slide on floor (done next frame)
Profiler.BeginSample("Slide on floor");
Profiler.BeginSample("Get angle");
var slideAngle = Vector3.Angle(motor.AngleDir, Vector3.up);
Debug.DrawRay(motor.transform.position, motor.AngleDir, Color.red, 5);
Profiler.EndSample();
if (slideAngle > motor.CharacterController.slopeLimit && slideAngle < 80 && isGrounded)
{
Debug.Log("Sliding");
var oldY = correctVelocity.y;
var undesiredMotion = motor.AngleDir * Vector3.Dot(correctVelocity, motor.AngleDir);
var desiredMotion = correctVelocity - undesiredMotion;
var leftOverInertia = desiredMotion * 0.5f * dt;
correctVelocity = desiredMotion + leftOverInertia;
/*var velocityToChoose = correctVelocity;
* if (Math.Abs(velocityToChoose.y) < 0.001)
* velocityToChoose.y = -1f;*/
//correctVelocity = RaycastUtilities.SlideVelocity(velocityToChoose, motor.AngleDir);
//correctVelocity.y = oldY;
correctVelocity += RaycastUtilities.SlideVelocity(new Vector3(0, Physics.gravity.y, 0) * dt * (slideAngle / 90), motor.AngleDir);
Debug.Log((slideAngle / 90));
//correctVelocity.y = oldY * dt;
//correctVelocity.y = Mathf.Clamp(correctVelocity.y, -10, 60);
motor.AngleDir = ProbeGround(motor, transform, motor.AngleDir, 90, 90);
motor.IsStableOnGround = false;
motor.IsSliding = true;
//motor.CharacterController.stepOffset = 0f;
}
else
{
Profiler.BeginSample("Set properties");
motor.IsStableOnGround = isGrounded;
motor.IsSliding = false;
Profiler.EndSample();
}
Profiler.EndSample();
Profiler.BeginSample("Set AngleDir");
if (isGrounded)
{
motor.AngleDir = GetAngleDir(motor, transform);
correctVelocity.y = Mathf.Max(correctVelocity.y, 0);
}
else if (wasGrounded && !isGrounded && correctVelocity.y < 0.001f)
{
motor.AngleDir = ProbeGround(motor, transform, motor.AngleDir,
slopeLimit - Mathf.Clamp(correctVelocity.ToGrid(1).magnitude, 0, 15) * 3 + 15, slopeLimit);
}
Profiler.EndSample();
motor.Momentum = momentum;
var events = motor.AllColliderHitsInFrame;
for (int x = 0; x != events.Count; x++)
{
var hitEvent = events[x];
// TODO Fire events
}
if (motor.IsGrounded(layerMask) && !wasGrounded)
{
MvDelegateEvents.InvokeCharacterLand(entity);
}
m_Group.States[i] = new CharacterControllerState(motor.IsGrounded(layerMask), motor.IsStableOnGround, motor.IsSliding, motor.AngleDir);
m_Group.VelocityArray[i] = new StVelocity(correctVelocity);
}
}
public void OV_ballistics()
{
Useable useable = OptimizationVariables.MainPlayer.equipment.useable;
bool isServer = Provider.isServer;
if (isServer)
{
OverrideUtilities.CallOriginal(useable, new object[0]);
}
else
{
bool flag = Time.realtimeSinceStartup - PlayerLifeUI.hitmarkers[0].lastHit > PlayerUI.HIT_TIME;
if (flag)
{
PlayerLifeUI.hitmarkers[0].image.isVisible = false;
//PlayerLifeUI.hitmarkers[0].hitCriticalImage.isVisible = false;
//PlayerLifeUI.hitmarkers[0].hitEntitiyImage.isVisible = false;
}
ItemGunAsset itemGunAsset = (ItemGunAsset)OptimizationVariables.MainPlayer.equipment.asset;
PlayerLook look = OptimizationVariables.MainPlayer.look;
bool flag2 = itemGunAsset.projectile != null;
if (!flag2)
{
List <BulletInfo> list = (List <BulletInfo>)OV_UseableGun.BulletsField.GetValue(useable);
bool flag3 = list.Count == 0;
if (!flag3)
{
RaycastInfo raycastInfo = null;
bool enabled = RaycastOptions.Enabled;
if (enabled)
{
RaycastUtilities.GenerateRaycast(out raycastInfo);
}
bool ballistics = Provider.modeConfigData.Gameplay.Ballistics;
if (ballistics)
{
bool flag4 = raycastInfo == null;
if (flag4)
{
bool noAimbotDrop = AimbotOptions.NoAimbotDrop;
if (noAimbotDrop)
{
bool flag5 = AimbotCoroutines.IsAiming && AimbotCoroutines.LockedObject != null;
if (flag5)
{
Vector3 aimPosition = AimbotCoroutines.GetAimPosition(AimbotCoroutines.LockedObject.transform, "Skull");
Ray aimRay = OV_UseableGun.GetAimRay(look.aim.position, aimPosition);
float maxDistance = (float)VectorUtilities.GetDistance(look.aim.position, aimPosition);
bool flag6 = !Physics.Raycast(aimRay, out RaycastHit raycastHit, maxDistance, RayMasks.DAMAGE_SERVER);
if (flag6)
{
raycastInfo = RaycastUtilities.GenerateOriginalRaycast(aimRay, itemGunAsset.range, RayMasks.ENEMY);
}
}
}
bool flag7 = WeaponOptions.NoDrop && raycastInfo == null;
if (flag7)
{
for (int i = 0; i < list.Count; i++)
{
BulletInfo bulletInfo = list[i];
Ray ray = new Ray(bulletInfo.pos, bulletInfo.dir);
RaycastInfo info = DamageTool.raycast(ray, itemGunAsset.ballisticTravel, RayMasks.DAMAGE_CLIENT);
bool flag8 = OV_UseableGun.IsRaycastInvalid(info);
if (flag8)
{
bulletInfo.pos += bulletInfo.dir * itemGunAsset.ballisticTravel;
}
else
{
EPlayerHit newHit = OV_UseableGun.CalcHitMarker(itemGunAsset, ref info);
PlayerUI.hitmark(0, Vector3.zero, false, newHit);
OptimizationVariables.MainPlayer.input.sendRaycast(info, ERaycastInfoUsage.Gun);
bulletInfo.steps = 254;
}
}
for (int j = list.Count - 1; j >= 0; j--)
{
BulletInfo bulletInfo2 = list[j];
BulletInfo bulletInfo3 = bulletInfo2;
bulletInfo3.steps += 1;
bool flag9 = bulletInfo2.steps >= itemGunAsset.ballisticSteps;
if (flag9)
{
list.RemoveAt(j);
}
}
return;
}
bool flag10 = raycastInfo == null;
if (flag10)
{
OverrideUtilities.CallOriginal(useable, new object[0]);
return;
}
}
for (int k = 0; k < list.Count; k++)
{
BulletInfo bulletInfo4 = list[k];
double distance = VectorUtilities.GetDistance(OptimizationVariables.MainPlayer.transform.position, raycastInfo.point);
bool flag11 = bulletInfo4.steps * itemGunAsset.ballisticTravel < distance;
if (!flag11)
{
EPlayerHit newHit2 = OV_UseableGun.CalcHitMarker(itemGunAsset, ref raycastInfo);
PlayerUI.hitmark(0, Vector3.zero, false, newHit2);
OptimizationVariables.MainPlayer.input.sendRaycast(raycastInfo, ERaycastInfoUsage.Gun);
bulletInfo4.steps = 254;
}
}
for (int l = list.Count - 1; l >= 0; l--)
{
BulletInfo bulletInfo5 = list[l];
BulletInfo bulletInfo6 = bulletInfo5;
bulletInfo6.steps += 1;
bool flag12 = bulletInfo5.steps >= itemGunAsset.ballisticSteps;
if (flag12)
{
list.RemoveAt(l);
}
}
}
else
{
bool flag13 = raycastInfo != null;
if (flag13)
{
for (int m = 0; m < list.Count; m++)
{
EPlayerHit newHit3 = OV_UseableGun.CalcHitMarker(itemGunAsset, ref raycastInfo);
PlayerUI.hitmark(0, Vector3.zero, false, newHit3);
OptimizationVariables.MainPlayer.input.sendRaycast(raycastInfo, ERaycastInfoUsage.Gun);
}
list.Clear();
}
else
{
OverrideUtilities.CallOriginal(useable, new object[0]);
}
}
}
}
}
}
public static IEnumerator CheckTrigger()
{
while (true)
{
yield return(new WaitForSeconds(0.1f));
if (!TriggerbotOptions.Enabled || !DrawUtilities.ShouldRun() ||
OptimizationVariables.MainPlayer.stance.stance == EPlayerStance.SPRINT ||
OptimizationVariables.MainPlayer.stance.stance == EPlayerStance.CLIMB ||
OptimizationVariables.MainPlayer.stance.stance == EPlayerStance.DRIVING)
{
TriggerbotOptions.IsFiring = false;
continue;
}
PlayerLook look = OptimizationVariables.MainPlayer.look;
Useable u = OptimizationVariables.MainPlayer.equipment.useable;
switch (u)
{
case null:
TriggerbotOptions.IsFiring = false;
continue;
case UseableGun gun:
{
ItemGunAsset PAsset = (ItemGunAsset)OptimizationVariables.MainPlayer.equipment.asset;
RaycastInfo ri = RaycastUtilities.GenerateOriginalRaycast(new Ray(look.aim.position, look.aim.forward), PAsset.range, RayMasks.DAMAGE_CLIENT);
if (AimbotCoroutines.LockedObject != null && AimbotCoroutines.IsAiming)
{
Ray r = OV_UseableGun.GetAimRay(look.aim.position, AimbotCoroutines.GetAimPosition(AimbotCoroutines.LockedObject.transform, "Skull"));
ri = RaycastUtilities.GenerateOriginalRaycast(new Ray(r.origin, r.direction), PAsset.range, RayMasks.DAMAGE_CLIENT);
}
bool Valid = ri.player != null;
if (RaycastOptions.Enabled)
{
Valid = RaycastUtilities.GenerateRaycast(out ri);
}
if (!Valid)
{
TriggerbotOptions.IsFiring = false;
continue;
}
EFiremode fire = (EFiremode)CurrentFiremode.GetValue(gun);
if (fire == EFiremode.AUTO)
{
TriggerbotOptions.IsFiring = true;
continue;
}
TriggerbotOptions.IsFiring = !TriggerbotOptions.IsFiring;
break;
}
case UseableMelee _:
{
ItemMeleeAsset MAsset = (ItemMeleeAsset)OptimizationVariables.MainPlayer.equipment.asset;
RaycastInfo ri = RaycastUtilities.GenerateOriginalRaycast(new Ray(look.aim.position, look.aim.forward), MAsset.range, RayMasks.DAMAGE_CLIENT);
if (AimbotCoroutines.LockedObject != null && AimbotCoroutines.IsAiming)
{
Ray r = OV_UseableGun.GetAimRay(look.aim.position, AimbotCoroutines.GetAimPosition(AimbotCoroutines.LockedObject.transform, "Skull"));
ri = RaycastUtilities.GenerateOriginalRaycast(new Ray(r.origin, r.direction), MAsset.range, RayMasks.DAMAGE_CLIENT);
}
bool Valid = ri.player != null;
if (RaycastOptions.Enabled)
{
Valid = RaycastUtilities.GenerateRaycast(out ri);
}
if (!Valid)
{
TriggerbotOptions.IsFiring = false;
continue;
}
if (MAsset.isRepeated)
{
TriggerbotOptions.IsFiring = true;
continue;
}
TriggerbotOptions.IsFiring = !TriggerbotOptions.IsFiring;
break;
}
}
}
}
private bool ProcessItem
(
ref Entity entity,
ref StVelocity velocity,
ref DefStDodgeOnGroundSettings setting,
ref DefStRunInput runInput,
ref DefStDodgeInput input,
ref DefStWallDodgeProcessData process,
ref DefStDodgeOnGroundProcessData groundProcess,
CharacterControllerMotor motor
)
{
var action = input.State != InputState.None && !MvUtils.OnGround(motor, velocity) && Time.time > process.TimeBeforeNextWD;
DiffuseCommand(m_CmdDoDodge, m_CmdDoDodgeResult, action, CmdState.Begin);
if (!m_CmdDoDodgeResult.GetComponentData <EntityCommandResult>().AsBool())
{
DiffuseCommand(m_CmdDoDodge, m_CmdDoDodgeResult, action, CmdState.End);
return(false);
}
var originalVelocity = velocity.Value;
var fwd = motor.transform.forward;
var pos = motor.transform.position + new Vector3(0, motor.CharacterController.stepOffset + 0.1f);
var rot = motor.transform.rotation;
var rd = motor.CharacterController.radius + 0.075f;
var sw = motor.CharacterController.skinWidth + 0.025f;
var height = motor.CharacterController.height - motor.CharacterController.stepOffset;
var subheight = (height * 0.75f) - 0.005f;
CPhysicSettings.Active.SetGlobalCollision(motor.gameObject, false);
var direction = (Vector3)SrtComputeDirection(fwd, rot, runInput.Direction);
direction = (velocity.Value.ToGrid(1).normalized + direction * 2).normalized;
var rayTrace = UtilityWallRayTrace.RayTrace(ref direction, ref pos, ref rd, ref sw, ref height, ref subheight, motor.CharacterController);
CPhysicSettings.Active.SetGlobalCollision(motor.gameObject, true);
var success = rayTrace.normal != Vector3.zero && Mathf.Abs(rayTrace.normal.y) < 0.2f;
if (success)
{
rayTrace.normal = rayTrace.normal.ToGrid(1).normalized;
var reflected = (Vector3.Reflect(direction, rayTrace.normal) + rayTrace.normal).normalized;
var oldY = velocity.Value.y;
var dirInertie = (reflected * (velocity.Value.magnitude + 1)) + rayTrace.normal * 3.5f;
dirInertie = RaycastUtilities.SlideVelocityNoYChange(velocity.Value, rayTrace.normal) + rayTrace.normal * 10;
var minSpeed = Mathf.Max(velocity.Value.ToGrid(1).magnitude + setting.AdditiveSpeed, setting.MinSpeed);
velocity.Value = dirInertie.ToGrid(1).normalized *(minSpeed);
velocity.Value.y = Mathf.Max(oldY + 2, 0);
process.TimeBeforeNextWD = Time.time + DefaultCooldown;
input.TimeBeforeResetState = -1f;
input.State = InputState.None;
groundProcess.CooldownBeforeNextDodge = 0.25f;
//groundProcess.InertieDelta = 0.5f;
groundProcess.Direction = dirInertie.normalized;
BroadcastNewEntity(PostUpdateCommands, true);
PostUpdateCommands.AddComponent(new DefStWallJumpEvent(Time.time, Time.frameCount, entity, originalVelocity, rayTrace.normal));
}
DiffuseCommand(m_CmdDoDodge, m_CmdDoDodgeResult, action, CmdState.End);
return(success);
}
void CameraMovement()
{
var zoom = Input.mouseScrollDelta.y;
var cursorPos = Input.mousePosition;
var cursorWorldPos = _cam.ScreenToWorldPoint(cursorPos);
var buttonDown = Input.GetMouseButtonDown(0); //* CONSIDER - also allow middle/right mouse?
var buttonHeld = Input.GetMouseButton(0);
if (zoom != 0)
{
var targetOrthoSize = Mathf.Clamp(_cam.orthographicSize + _data.MouseZoomSpeed * (-zoom), _zoomClamp.Min, _zoomClamp.Max);
// Change camera position to cursor if we're zooming in
// First check makes sure the camera wont move if min zoom value has been reached
if (targetOrthoSize != _cam.orthographicSize && zoom > 0)
{
MoveCameraToZoom(cursorWorldPos, zoom);
}
_cam.orthographicSize = targetOrthoSize;
}
if (buttonDown || buttonHeld && GameManager.GameInProgess && !GameManager.DraggingPuzzlePiece && !RaycastUtilities.IsPoint2DOverElementWithTag(cursorPos, "UIPuzzlePanel")) // IsPointerOverUIElement(cursorPos)
{
PanCamera(buttonDown, buttonHeld, cursorWorldPos);
//if (_hintBox.IsVisible) _hintBox.ToggleHintBoxVisibility(false); // TODO test if this is actually desireable
}
}
public void OV_ballistics()
{
Useable PlayerUse = OptimizationVariables.MainPlayer.equipment.useable;
if (Provider.isServer)
{
OverrideUtilities.CallOriginal(PlayerUse);
return;
}
if (Time.realtimeSinceStartup - PlayerLifeUI.hitmarkers[0].lastHit > PlayerUI.HIT_TIME)
{
PlayerLifeUI.hitmarkers[0].hitBuildImage.isVisible = false;
PlayerLifeUI.hitmarkers[0].hitCriticalImage.isVisible = false;
PlayerLifeUI.hitmarkers[0].hitEntitiyImage.isVisible = false;
}
ItemGunAsset PAsset = (ItemGunAsset)OptimizationVariables.MainPlayer.equipment.asset;
PlayerLook Look = OptimizationVariables.MainPlayer.look;
if (PAsset.projectile != null)
return;
List<BulletInfo> Bullets = (List<BulletInfo>)BulletsField.GetValue(PlayerUse);
if (Bullets.Count == 0)
return;
RaycastInfo ri = null;
if (RaycastOptions.Enabled && (!RaycastOptions.HoldKey || HotkeyUtilities.IsHotkeyHeld("_SilentAimKey")))
RaycastUtilities.GenerateRaycast(out ri);
if (Provider.modeConfigData.Gameplay.Ballistics)
{
if (ri == null)
{
if (WeaponOptions.NoDrop && ri == null)
{
for (int i = 0; i < Bullets.Count; i++)
{
BulletInfo bulletInfo = Bullets[i];
Ray ray = new Ray(bulletInfo.pos, bulletInfo.dir);
RaycastInfo rayInfo =
DamageTool.raycast(ray, PAsset.ballisticTravel, RayMasks.DAMAGE_CLIENT);
if (IsRaycastInvalid(rayInfo))
bulletInfo.pos += bulletInfo.dir * PAsset.ballisticTravel;
else
{
EPlayerHit playerHit = CalcHitMarker(PAsset, ref rayInfo);
PlayerUI.hitmark(0, Vector3.zero, false, playerHit);
OptimizationVariables.MainPlayer.input.sendRaycast(rayInfo);
bulletInfo.steps = 254;
}
}
for (int i = Bullets.Count - 1; i >= 0; i--)
{
BulletInfo bulletInfo = Bullets[i];
bulletInfo.steps += 1;
if (bulletInfo.steps >= PAsset.ballisticSteps)
Bullets.RemoveAt(i);
}
return;
}
if (ri == null)
{
OverrideUtilities.CallOriginal(PlayerUse);
return;
}
}
for (int i = 0; i < Bullets.Count; i++)
{
BulletInfo bulletInfo = Bullets[i];
double distance = VectorUtilities.GetDistance(OptimizationVariables.MainPlayer.transform.position, ri.point);
if (bulletInfo.steps * PAsset.ballisticTravel < distance)
continue;
EPlayerHit eplayerhit = CalcHitMarker(PAsset, ref ri);
PlayerUI.hitmark(0, Vector3.zero, false, eplayerhit);
OptimizationVariables.MainPlayer.input.sendRaycast(ri);
bulletInfo.steps = 254;
}
for (int k = Bullets.Count - 1; k >= 0; k--)
{
BulletInfo bulletInfo = Bullets[k];
bulletInfo.steps += 1;
if (bulletInfo.steps >= PAsset.ballisticSteps)
Bullets.RemoveAt(k);
}
}
else
{
if (ri != null)
{
for (int i = 0; i < Bullets.Count; i++)
{
EPlayerHit eplayerhit = CalcHitMarker(PAsset, ref ri);
PlayerUI.hitmark(0, Vector3.zero, false, eplayerhit);
OptimizationVariables.MainPlayer.input.sendRaycast(ri);
}
Bullets.Clear();
}
else
OverrideUtilities.CallOriginal(PlayerUse);
}
}
public static bool GetTargetObject(GameObject[] Objects, out GameObject Object, out Vector3 Point, double Range)
{
double num = Range + 1f;
double num2 = 180f;
Object = null;
Point = Vector3.zero;
Vector3 position = OptimizationVariables.MainPlayer.look.aim.position;
Vector3 forward = OptimizationVariables.MainPlayer.look.aim.forward;
foreach (GameObject gameObject in Objects)
{
if (!(gameObject == null))
{
Vector3 position2 = gameObject.transform.position;
Player component = gameObject.GetComponent <Player>();
if (!component || (!component.life.isDead && !FriendUtilities.IsFriendly(component) && (!RaycastOptions.NoShootthroughthewalls || RaycastUtilities.NoShootthroughthewalls(gameObject.transform))))
{
Zombie component2 = gameObject.GetComponent <Zombie>();
if (!component2 || !component2.isDead)
{
if (gameObject.GetComponent <RaycastComponent>() == null)
{
gameObject.AddComponent <RaycastComponent>();
}
else
{
double distance = VectorUtilities.GetDistance(position, position2);
if (distance <= Range)
{
if (RaycastOptions.SilentAimUseFOV)
{
double angleDelta = VectorUtilities.GetAngleDelta(position, forward, position2);
if (angleDelta > RaycastOptions.SilentAimFOV || angleDelta > num2)
{
goto IL_12A;
}
num2 = angleDelta;
}
else if (distance > num)
{
goto IL_12A;
}
if (SphereUtilities.GetRaycast(gameObject, position, out Vector3 vector))
{
Object = gameObject;
num = distance;
Point = vector;
}
}
}
}
}
}
IL_12A :;
}
return(Object != null);
}
