Billybishop
commented
3 years ago Hi all, great news! It's done. (I was drunk and patching things together from other projects, and trying stuff on my own. Please forgive me if this is not well credited)
1. I finished implementing and testing a fast visibility check that is very accurate - I added the following to the CameraExtensions (Note the importance of the layer mask here):
private static RaycastHit _ray; private static readonly LayerMask _layer_mask = 1 << 12 | 1 << 16 | 1 << 18 | 1 << 31 | 1 << 22; public static bool IsPlayerBoneVisible(this Camera camera, Player player, Vector3 target_bone) { return (Physics.Linecast(camera.transform.position, target_bone, out _ray, _layer_mask) && _ray.collider && _ray.collider.gameObject.transform.root.gameObject == player.gameObject.transform.root.gameObject); }
2. And then I wrote a nearly perfect method for scanning and returning the best bone to target out of only the parts of the Player that is currently visible:
public static Vector3 GetBestVisibleBone(Player player, float cached_distance = 0.0f) { Vector3 null_position = Vector3.zero; if (Aimbot._camera == null) return null_position; PlayerBones bones = player.PlayerBones; if (bones == null) return null_position; float null_distance = 3.0f; float min_distance = 7.5f; float distance = (cached_distance != 0.0f) ? cached_distance : Vector3.Distance(Aimbot._camera.transform.position, player.Transform.position); //Don't check for visibility if player is extremely close to the camera because visibility has weird behavior at this distance if (distance <= null_distance) { render_text_player_visible = $"TARGET TOO CLOSE"; return player.PlayerBones.Spine1.position; } if (distance <= min_distance && Aimbot._camera.IsPlayerBoneVisible(player, player.PlayerBones.Spine1.position)) //Stick to one bone if we're very close to the player { //Visibility debug render_text_player_visible = $"TARGET: [{player.name}->{player.PlayerBones.Spine1.name}]"; return player.PlayerBones.Spine1.position; } else if (distance > min_distance) { //Make a collection of target bones starting with the most important followed by the other bones in order of vitality IEnumerable<AimBone> target_bones = new AimBone[16] { new AimBone(bones.Neck), new AimBone(bones.Head), new AimBone(bones.Shoulders[0]), new AimBone(bones.Shoulders[1]), new AimBone(bones.Spine1), new AimBone(bones.Upperarms[0]), new AimBone(bones.Upperarms[1]), new AimBone(bones.Forearms[0]), new AimBone(bones.Forearms[1]), new AimBone(bones.Pelvis), new AimBone(bones.LeftPalm), new AimBone(bones.LeftThigh1), new AimBone(bones.RightThigh1), new AimBone(bones.LeftThigh2), new AimBone(bones.RightThigh2), new AimBone(bones.KickingFoot) }; //Hybrid AimBone class is necessary due to differing bone transform types that do not share interfaces/inheritance //Scan the desired bones for visibility foreach (AimBone bone_info in target_bones) { bool is_visible = Aimbot._camera.IsPlayerBoneVisible(player, bone_info.Position); if (is_visible) { //Visibility debug render_text_player_visible = $"TARGET: [{player.name}->{bone_info.Name}]"; return bone_info.Position; } } } return null_position; }
3. The above method uses a translation class I wrote that can accept the different Transform types (This is necessary because Transform and BifacialTransform do not share an interface or inheritance). So, this just simplifies the work needed to use the different types which represent the bones. Please note the comment about C# dynamic type, as it was tried and found not to be supported with the current EFT/AKI binaries - even with CSharp and ReflectionType libraries provided - which is why this simple class is so convoluted.
//NOTE: This used to use dynamic type originally but that requires Microsoft.CSharp.dll v4 and related dependencies which are not currently supported in EFT/AKI public class AimBone { private readonly string _name; public string Name { get { return _name; } } private readonly object _bone; public object Bone { get { return _bone; } } private readonly Vector3 _bone_position; public Vector3 Position { get { return _bone_position; } } public AimBone(object aim_bone) { if (aim_bone is Transform) { _name = ((Transform)aim_bone).name; _bone_position = ((Transform)aim_bone).position; } else if (aim_bone is BifacialTransform) { _name = ((BifacialTransform)aim_bone).Original.name; _bone_position = ((BifacialTransform)aim_bone).position; } else { _name = "Unsupported Bone Type"; _bone_position = Vector3.zero; } _bone = aim_bone; } }
@sailro, I would very much appreciate if this could be implemented in the master branch. Also, if anyone would like please feel free to optimize these methods if you find a faster/simpler way to do something, I gave it my best effort. Lastly, you may notice how I strongly type all of my variables, I prefer it this way for readability but it has no runtime impact either way AFAIK.
sailro
Updated this enhancement in respect to latest code changes and documented the current goals in comment #75.
Goals reference, as described in my update comment:
Old description:
The Aimbot should only acquire targets that are visible from your camera and not behind geometry. We already have a way to verify if a world position is within your viewport so now we need a way to verify the player is physically visible. The visibility check for a player object should ideally consider the best bone position but in the event that only part of the player is visible, such as a limb, then the visibility method should be capable of returning the best bone out of what is visible...~~If only a right arm and right leg are visible of a given player, the visibility check will return the best bone out of those visibly available which would be in this order as a general example : right upper arm > right thigh > right forearm. So, in conclusion the visibility check would return the upper arm first in this visibility case.~~
The visibility check should do a physics raycast check from the player's camera position (in the main thread) to the provided bone position to determine if there is any blocking geometry. If the raycast fails, then there is no geometry in the way. The distance the ray cast travels should be limited by a small degree so as to not collide with the geometry of armor or items that the potential target player is wearing (such as armor, weapon, backpack, vests, etc) since understandably this geometry will always be present.This design should suffice in 99% of cases to check for visibility, however the best 1:1 approach would be not to limit the ray cast's travel distance for checking geometry collision, and instead include player equipped items/armor as part of the potentially visible player component.I started working on this enhancement and still need to test/debug - I will be sure to post in this thread with any updates or successes.