using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace TrajectoryVisualizer
{
[BepInPlugin("com.syntx.stonewards.trajectoryvisualizer", "Trajectory Visualizer", "2.5.2")]
public class Plugin : BaseUnityPlugin
{
public const string PluginGuid = "com.syntx.stonewards.trajectoryvisualizer";
public const string PluginName = "Trajectory Visualizer";
public const string PluginVersion = "2.5.2";
internal static Plugin Instance;
internal static ManualLogSource Log;
internal static ConfigEntry<bool> ShowBombTrajectory;
internal static ConfigEntry<bool> ShowArrowTrajectory;
internal static ConfigEntry<float> Gravity;
internal static ConfigEntry<float> LineWidth;
internal static ConfigEntry<float> RightOffset;
internal static ConfigEntry<float> DownOffset;
internal static ConfigEntry<float> MarkerSize;
internal static ConfigEntry<float> DashLength;
internal static ConfigEntry<float> DashGap;
private Harmony _harmony;
private void Awake()
{
//IL_0194: Unknown result type (might be due to invalid IL or missing references)
//IL_019e: Expected O, but got Unknown
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
ShowBombTrajectory = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ShowBombTrajectory", true, "Show bomb arc while LMB is held.");
ShowArrowTrajectory = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ShowArrowTrajectory", true, "Show arrow arc while LMB is held.");
Gravity = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Gravity", 9.81f, "Same gravity as projectiles: v += down * g * dt.");
LineWidth = ((BaseUnityPlugin)this).Config.Bind<float>("General", "LineWidth", 0.025f, "Dash thickness.");
RightOffset = ((BaseUnityPlugin)this).Config.Bind<float>("General", "RightOffset", 0.22f, "Start slightly right of the crosshair.");
DownOffset = ((BaseUnityPlugin)this).Config.Bind<float>("General", "DownOffset", 0.22f, "Start slightly below the camera.");
MarkerSize = ((BaseUnityPlugin)this).Config.Bind<float>("General", "MarkerSize", 0.16f, "Impact marker size.");
DashLength = ((BaseUnityPlugin)this).Config.Bind<float>("General", "DashLength", 0.55f, "Length of each dash.");
DashGap = ((BaseUnityPlugin)this).Config.Bind<float>("General", "DashGap", 0.38f, "Gap between dashes.");
Log.LogInfo((object)"====================================================");
Log.LogInfo((object)"Trajectory Visualizer v2.5.2 loaded");
Log.LogInfo((object)"Dashed arc. Thin ray only (no fat overlap). Archer force at any charge.");
Log.LogInfo((object)"====================================================");
UnityCache.Init();
_harmony = new Harmony("com.syntx.stonewards.trajectoryvisualizer");
int num = 0;
num += Patch("FirstPersonController", "Update", "OnPlayerUpdate");
num += Patch("ThrowableTool", "OnPrimaryAction", "OnThrowPrimary");
num += Patch("BowTool", "OnPrimaryAction", "OnBowPrimary");
Log.LogInfo((object)("Patches applied: " + num));
}
private int Patch(string typeName, string methodName, string postfixName)
{
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Expected O, but got Unknown
Type type = AccessTools.TypeByName(typeName);
if (type == null)
{
Log.LogError((object)("Type not found: " + typeName));
return 0;
}
MethodInfo methodInfo = null;
MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
foreach (MethodInfo methodInfo2 in methods)
{
if (methodInfo2.Name == methodName)
{
methodInfo = methodInfo2;
break;
}
}
if (methodInfo == null)
{
Log.LogError((object)("Method not found: " + typeName + "." + methodName));
return 0;
}
try
{
MethodInfo method = typeof(Patches).GetMethod(postfixName, BindingFlags.Static | BindingFlags.Public);
_harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(method), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
Log.LogInfo((object)("OK " + typeName + "." + methodInfo.Name));
return 1;
}
catch (Exception ex)
{
Log.LogError((object)("FAIL " + typeName + "." + methodName + ": " + ex.Message));
return 0;
}
}
}
internal static class UnityCache
{
private const BindingFlags Inst = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
private const BindingFlags Stat = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
private const int MaxDashes = 28;
internal static Type Vector3Type;
internal static Type ColorType;
internal static Type LineRendererType;
internal static Type GameObjectType;
internal static Type ObjectType;
internal static Type ShaderType;
internal static Type MaterialType;
internal static Type PhysicsType;
internal static Type TransformType;
internal static Type RendererType;
internal static PropertyInfo CameraMain;
internal static PropertyInfo TransformProp;
internal static PropertyInfo PositionProp;
internal static PropertyInfo ForwardProp;
internal static PropertyInfo RightProp;
internal static PropertyInfo LocalScaleProp;
internal static PropertyInfo TimeSinceLevelLoad;
internal static MethodInfo InputGetMouseButton;
internal static MethodInfo ShaderFind;
internal static MethodInfo DontDestroyOnLoad;
internal static MethodInfo DestroyImmediate;
internal static MethodInfo AddComponentGeneric;
internal static MethodInfo AddComponentTyped;
internal static MethodInfo CreatePrimitive;
internal static MethodInfo GetComponentType;
internal static MethodInfo RaycastAll;
internal static MethodInfo OverlapSphere;
internal static MethodInfo MaterialSetColor;
internal static ConstructorInfo Vector3Ctor;
internal static ConstructorInfo ColorCtor;
internal static ConstructorInfo GameObjectCtor;
internal static ConstructorInfo MaterialCtor;
internal static FieldInfo VecX;
internal static FieldInfo VecY;
internal static FieldInfo VecZ;
internal static PropertyInfo HitCollider;
internal static PropertyInfo HitDistance;
internal static PropertyInfo HitPoint;
internal static PropertyInfo ColliderGameObject;
internal static PropertyInfo GameObjectName;
internal static PropertyInfo GameObjectTag;
internal static PropertyInfo GameObjectTransform;
internal static MethodInfo GetComponentInParentTyped;
internal static object QueryCollide;
internal static object PrimitiveSphere;
internal static Type EnemyHitboxType;
internal static Type EnemyControllerType;
internal static Type HitboxType;
internal static Type PlayerHitboxType;
internal static PropertyInfo HitboxTypeProp;
internal static object WhiteColor;
internal static object RedColor;
internal static object SharedMaterial;
internal static object[] DashLines = new object[28];
internal static object[] DashGos = new object[28];
internal static MethodInfo[] DashSetPositions = new MethodInfo[28];
internal static Array[] DashBuffers = new Array[28];
internal static object MarkerGo;
internal static object MarkerRenderer;
internal static object MarkerMaterial;
internal static bool Ready;
internal static bool DashesReady;
internal static bool LoggedFail;
internal static void Init()
{
try
{
Type type = AccessTools.TypeByName("UnityEngine.Camera");
TransformType = AccessTools.TypeByName("UnityEngine.Transform");
Type type2 = AccessTools.TypeByName("UnityEngine.Input");
Type type3 = AccessTools.TypeByName("UnityEngine.Time");
Vector3Type = AccessTools.TypeByName("UnityEngine.Vector3");
ColorType = AccessTools.TypeByName("UnityEngine.Color");
LineRendererType = AccessTools.TypeByName("UnityEngine.LineRenderer");
GameObjectType = AccessTools.TypeByName("UnityEngine.GameObject");
ObjectType = AccessTools.TypeByName("UnityEngine.Object");
ShaderType = AccessTools.TypeByName("UnityEngine.Shader");
MaterialType = AccessTools.TypeByName("UnityEngine.Material");
PhysicsType = AccessTools.TypeByName("UnityEngine.Physics");
RendererType = AccessTools.TypeByName("UnityEngine.Renderer");
Type type4 = AccessTools.TypeByName("UnityEngine.RaycastHit");
Type type5 = AccessTools.TypeByName("UnityEngine.Collider");
Type type6 = AccessTools.TypeByName("UnityEngine.QueryTriggerInteraction");
Type type7 = AccessTools.TypeByName("UnityEngine.PrimitiveType");
EnemyHitboxType = AccessTools.TypeByName("EnemyHitbox");
EnemyControllerType = AccessTools.TypeByName("EnemyController");
HitboxType = AccessTools.TypeByName("Hitbox");
PlayerHitboxType = AccessTools.TypeByName("PlayerHitbox");
if (HitboxType != null)
{
HitboxTypeProp = HitboxType.GetProperty("Type", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
}
if (type != null)
{
CameraMain = type.GetProperty("main", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
TransformProp = type.GetProperty("transform", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
}
if (TransformType != null)
{
PositionProp = TransformType.GetProperty("position", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
ForwardProp = TransformType.GetProperty("forward", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
RightProp = TransformType.GetProperty("right", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
LocalScaleProp = TransformType.GetProperty("localScale", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
}
if (type3 != null)
{
TimeSinceLevelLoad = type3.GetProperty("timeSinceLevelLoad", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
if (TimeSinceLevelLoad == null)
{
TimeSinceLevelLoad = type3.GetProperty("time", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
}
}
if (type2 != null)
{
InputGetMouseButton = type2.GetMethod("GetMouseButton", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(int) }, null);
}
if (ShaderType != null)
{
ShaderFind = ShaderType.GetMethod("Find", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null);
}
if (ObjectType != null)
{
DontDestroyOnLoad = ObjectType.GetMethod("DontDestroyOnLoad", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { ObjectType }, null);
DestroyImmediate = ObjectType.GetMethod("DestroyImmediate", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { ObjectType }, null);
if (DestroyImmediate == null)
{
DestroyImmediate = ObjectType.GetMethod("Destroy", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { ObjectType }, null);
}
}
if (GameObjectType != null)
{
GameObjectCtor = GameObjectType.GetConstructor(new Type[1] { typeof(string) });
AddComponentTyped = GameObjectType.GetMethod("AddComponent", new Type[1] { typeof(Type) });
GetComponentType = GameObjectType.GetMethod("GetComponent", new Type[1] { typeof(Type) });
GameObjectName = GameObjectType.GetProperty("name", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
GameObjectTag = GameObjectType.GetProperty("tag", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
GameObjectTransform = GameObjectType.GetProperty("transform", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
MethodInfo[] methods = GameObjectType.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (MethodInfo methodInfo in methods)
{
if (methodInfo.Name == "AddComponent" && methodInfo.IsGenericMethodDefinition && methodInfo.GetParameters().Length == 0)
{
AddComponentGeneric = methodInfo;
}
}
if (type7 != null)
{
PrimitiveSphere = Enum.ToObject(type7, 0);
CreatePrimitive = GameObjectType.GetMethod("CreatePrimitive", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { type7 }, null);
}
}
if (Vector3Type != null)
{
Vector3Ctor = Vector3Type.GetConstructor(new Type[3]
{
typeof(float),
typeof(float),
typeof(float)
});
VecX = Vector3Type.GetField("x");
VecY = Vector3Type.GetField("y");
VecZ = Vector3Type.GetField("z");
}
if (ColorType != null)
{
ColorCtor = ColorType.GetConstructor(new Type[4]
{
typeof(float),
typeof(float),
typeof(float),
typeof(float)
});
}
if (MaterialType != null && ShaderType != null)
{
MaterialCtor = MaterialType.GetConstructor(new Type[1] { ShaderType });
MaterialSetColor = MaterialType.GetMethod("SetColor", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
{
typeof(string),
ColorType
}, null);
}
if (type6 != null)
{
QueryCollide = Enum.ToObject(type6, 2);
}
if (PhysicsType != null && Vector3Type != null)
{
MethodInfo[] methods = PhysicsType.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
foreach (MethodInfo methodInfo2 in methods)
{
ParameterInfo[] parameters = methodInfo2.GetParameters();
if (methodInfo2.Name == "RaycastAll" && parameters.Length >= 3 && RaycastAll == null)
{
RaycastAll = methodInfo2;
}
if (methodInfo2.Name == "OverlapSphere" && parameters.Length >= 2 && OverlapSphere == null)
{
OverlapSphere = methodInfo2;
}
}
methods = PhysicsType.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
foreach (MethodInfo methodInfo3 in methods)
{
ParameterInfo[] parameters2 = methodInfo3.GetParameters();
if (methodInfo3.Name == "RaycastAll" && parameters2.Length == 5)
{
RaycastAll = methodInfo3;
}
if (methodInfo3.Name == "OverlapSphere" && parameters2.Length == 4)
{
OverlapSphere = methodInfo3;
}
}
}
if (type4 != null)
{
HitCollider = type4.GetProperty("collider", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
HitDistance = type4.GetProperty("distance", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
HitPoint = type4.GetProperty("point", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
}
if (type5 != null)
{
ColliderGameObject = type5.GetProperty("gameObject", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
MethodInfo[] methods = type5.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (MethodInfo methodInfo4 in methods)
{
if (methodInfo4.Name == "GetComponentInParent" && methodInfo4.GetParameters().Length == 1 && methodInfo4.GetParameters()[0].ParameterType == typeof(Type))
{
GetComponentInParentTyped = methodInfo4;
}
}
}
Ready = type != null && Vector3Type != null && GameObjectType != null && LineRendererType != null;
Plugin.Log.LogInfo((object)("Unity cache ready. timeSinceLevelLoad=" + (TimeSinceLevelLoad != null) + " RaycastAll=" + (RaycastAll != null)));
}
catch (Exception ex)
{
Plugin.Log.LogError((object)("UnityCache.Init failed: " + ex));
}
}
internal static float Now()
{
try
{
if (TimeSinceLevelLoad != null)
{
return Convert.ToSingle(TimeSinceLevelLoad.GetValue(null));
}
}
catch
{
}
return 0f;
}
internal static bool IsLmbHeld()
{
try
{
if (InputGetMouseButton != null)
{
return Convert.ToBoolean(InputGetMouseButton.Invoke(null, new object[1] { 0 }));
}
}
catch
{
}
if (!Patches.ThrowHeld)
{
return Patches.BowHeld;
}
return true;
}
internal static bool TryGetCamVectors(out Vec3 pos, out Vec3 forward, out Vec3 right)
{
pos = default(Vec3);
forward = default(Vec3);
right = default(Vec3);
try
{
object obj = ((CameraMain != null) ? CameraMain.GetValue(null) : null);
if (obj == null)
{
return false;
}
object obj2 = ((TransformProp != null) ? TransformProp.GetValue(obj) : null);
if (obj2 == null)
{
return false;
}
object value = PositionProp.GetValue(obj2);
object value2 = ForwardProp.GetValue(obj2);
object value3 = RightProp.GetValue(obj2);
if (value == null || value2 == null || value3 == null)
{
return false;
}
pos = Vec3.From(value);
forward = Vec3.From(value2);
right = Vec3.From(value3);
return true;
}
catch
{
return false;
}
}
internal static object MakeV3(float x, float y, float z)
{
return Vector3Ctor.Invoke(new object[3] { x, y, z });
}
internal static object MakeColor(float r, float g, float b, float a)
{
return ColorCtor.Invoke(new object[4] { r, g, b, a });
}
private static object FindShader()
{
if (ShaderFind == null)
{
return null;
}
string[] array = new string[4] { "Sprites/Default", "Hidden/Internal-Colored", "Unlit/Color", "Universal Render Pipeline/Unlit" };
foreach (string text in array)
{
object obj = ShaderFind.Invoke(null, new object[1] { text });
if (obj != null)
{
return obj;
}
}
return null;
}
private static object MakeMaterial()
{
object obj = FindShader();
if (MaterialCtor == null || obj == null)
{
return null;
}
return MaterialCtor.Invoke(new object[1] { obj });
}
internal static void EnsureVisuals()
{
if (DashesReady || !Ready)
{
return;
}
try
{
SharedMaterial = MakeMaterial();
WhiteColor = MakeColor(1f, 1f, 1f, 1f);
RedColor = MakeColor(1f, 0.08f, 0.08f, 1f);
for (int i = 0; i < 28; i++)
{
object obj = GameObjectCtor.Invoke(new object[1] { "SW_Dash_" + i });
object obj2 = ((!(AddComponentGeneric != null)) ? AddComponentTyped.Invoke(obj, new object[1] { LineRendererType }) : AddComponentGeneric.MakeGenericMethod(LineRendererType).Invoke(obj, null));
DashGos[i] = obj;
DashLines[i] = obj2;
DashBuffers[i] = Array.CreateInstance(Vector3Type, 2);
SetProp(obj2, "useWorldSpace", true);
SetProp(obj2, "shadowCastingMode", 0);
SetProp(obj2, "receiveShadows", false);
SetProp(obj2, "positionCount", 2);
SetProp(obj2, "enabled", false);
if (SharedMaterial != null)
{
SetProp(obj2, "material", SharedMaterial);
}
MethodInfo[] methods = obj2.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (MethodInfo methodInfo in methods)
{
if (methodInfo.Name == "SetPositions" && methodInfo.GetParameters().Length == 1)
{
DashSetPositions[i] = methodInfo;
break;
}
}
if (DontDestroyOnLoad != null)
{
DontDestroyOnLoad.Invoke(null, new object[1] { obj });
}
}
EnsureMarker();
DashesReady = true;
Plugin.Log.LogInfo((object)"Dashed trajectory ready.");
}
catch (Exception ex)
{
Plugin.Log.LogError((object)("EnsureVisuals failed: " + ex));
}
}
private static void EnsureMarker()
{
if (MarkerGo != null)
{
return;
}
try
{
if (CreatePrimitive != null && PrimitiveSphere != null)
{
MarkerGo = CreatePrimitive.Invoke(null, new object[1] { PrimitiveSphere });
SetProp(MarkerGo, "name", "SW_ImpactMarker");
object obj = ((GetComponentType != null) ? GetComponentType.Invoke(MarkerGo, new object[1] { AccessTools.TypeByName("UnityEngine.Collider") }) : null);
if (obj != null && DestroyImmediate != null)
{
DestroyImmediate.Invoke(null, new object[1] { obj });
}
MarkerRenderer = ((GetComponentType != null) ? GetComponentType.Invoke(MarkerGo, new object[1] { RendererType }) : null);
MarkerMaterial = MakeMaterial();
if (MarkerRenderer != null && MarkerMaterial != null)
{
SetProp(MarkerRenderer, "material", MarkerMaterial);
}
if (DontDestroyOnLoad != null)
{
DontDestroyOnLoad.Invoke(null, new object[1] { MarkerGo });
}
SetActive(MarkerGo, on: false);
}
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)("Marker failed: " + ex.Message));
}
}
private static void SetProp(object obj, string name, object value)
{
if (obj == null)
{
return;
}
try
{
PropertyInfo property = obj.GetType().GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property != null && property.CanWrite)
{
property.SetValue(obj, value, null);
}
}
catch
{
}
}
private static void SetActive(object go, bool on)
{
if (go == null)
{
return;
}
try
{
MethodInfo method = go.GetType().GetMethod("SetActive", new Type[1] { typeof(bool) });
if (method != null)
{
method.Invoke(go, new object[1] { on });
}
}
catch
{
}
}
internal static void HideLine()
{
if (DashesReady)
{
for (int i = 0; i < 28; i++)
{
SetProp(DashLines[i], "enabled", false);
}
SetActive(MarkerGo, on: false);
}
}
internal static void DrawArc(Vec3 origin, Vec3 dir, float speed, out bool hitsEnemy)
{
hitsEnemy = false;
EnsureVisuals();
if (!DashesReady)
{
return;
}
float value = Plugin.Gravity.Value;
float num = 0.03f;
int num2 = 70;
Vec3 vec = origin;
Vec3 p = origin;
bool flag = false;
Vec3[] array = new Vec3[num2];
int count = 0;
array[count++] = origin;
for (int i = 1; i < num2; i++)
{
if (flag)
{
break;
}
float num3 = (float)i * num;
Vec3 vec2 = new Vec3(origin.x + dir.x * speed * num3, origin.y + dir.y * speed * num3 - 0.5f * value * num3 * num3, origin.z + dir.z * speed * num3);
try
{
if (TryHit(vec, vec2, out var enemy, out var hitPoint))
{
vec2 = hitPoint;
hitsEnemy = enemy;
flag = true;
}
}
catch
{
}
if (i > 4 && vec2.y < origin.y - 80f)
{
flag = true;
}
array[count++] = vec2;
vec = vec2;
p = vec2;
}
object color = (hitsEnemy ? RedColor : WhiteColor);
ApplyColor(SharedMaterial, color);
DrawDashes(array, count, color);
DrawImpactMarker(p, color);
}
private static void DrawDashes(Vec3[] pts, int count, object color)
{
float num = Plugin.DashLength.Value;
float num2 = Plugin.DashGap.Value;
if (num < 0.08f)
{
num = 0.08f;
}
if (num2 < 0.05f)
{
num2 = 0.05f;
}
float num3 = num + num2;
int num4 = 0;
float num5 = 0f;
for (int i = 1; i < count; i++)
{
if (num4 >= 28)
{
break;
}
Vec3 a = pts[i - 1];
Vec3 b = pts[i];
float num6 = Dist(a, b);
if (num6 < 0.0001f)
{
continue;
}
float num7 = num5;
float num8 = num5 + num6;
int num9 = (int)Math.Floor(num7 / num3);
int num10 = (int)Math.Floor(num8 / num3);
for (int j = num9; j <= num10; j++)
{
if (num4 >= 28)
{
break;
}
float num11 = (float)j * num3;
float num12 = num11 + num;
float num13 = ((num7 > num11) ? num7 : num11);
float num14 = ((num8 < num12) ? num8 : num12);
if (num14 > num13 + 0.001f)
{
float t = (num13 - num7) / num6;
float t2 = (num14 - num7) / num6;
SetDash(num4++, Lerp(a, b, t), Lerp(a, b, t2), color);
}
}
num5 = num8;
}
for (int k = num4; k < 28; k++)
{
SetProp(DashLines[k], "enabled", false);
}
}
private static void SetDash(int i, Vec3 a, Vec3 b, object color)
{
object obj = DashLines[i];
if (obj != null)
{
SetProp(obj, "enabled", true);
SetProp(obj, "positionCount", 2);
float value = Plugin.LineWidth.Value;
SetProp(obj, "startWidth", value);
SetProp(obj, "endWidth", value);
SetProp(obj, "startColor", color);
SetProp(obj, "endColor", color);
Array array = DashBuffers[i];
array.SetValue(MakeV3(a.x, a.y, a.z), 0);
array.SetValue(MakeV3(b.x, b.y, b.z), 1);
if (DashSetPositions[i] != null)
{
DashSetPositions[i].Invoke(obj, new object[1] { array });
}
}
}
private static float Dist(Vec3 a, Vec3 b)
{
float num = a.x - b.x;
float num2 = a.y - b.y;
float num3 = a.z - b.z;
return (float)Math.Sqrt(num * num + num2 * num2 + num3 * num3);
}
private static Vec3 Lerp(Vec3 a, Vec3 b, float t)
{
return new Vec3(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t);
}
private static void ApplyColor(object mat, object color)
{
if (mat == null || color == null)
{
return;
}
SetProp(mat, "color", color);
if (!(MaterialSetColor != null))
{
return;
}
try
{
MaterialSetColor.Invoke(mat, new object[2] { "_Color", color });
}
catch
{
}
try
{
MaterialSetColor.Invoke(mat, new object[2] { "_BaseColor", color });
}
catch
{
}
}
private static void DrawImpactMarker(Vec3 p, object color)
{
if (MarkerGo == null)
{
return;
}
SetActive(MarkerGo, on: true);
object obj = ((GameObjectTransform != null) ? GameObjectTransform.GetValue(MarkerGo) : null);
if (obj != null)
{
if (PositionProp != null)
{
PositionProp.SetValue(obj, MakeV3(p.x, p.y, p.z), null);
}
float value = Plugin.MarkerSize.Value;
if (LocalScaleProp != null)
{
LocalScaleProp.SetValue(obj, MakeV3(value, value, value), null);
}
}
ApplyColor(MarkerMaterial, color);
if (MarkerRenderer != null)
{
SetProp(MarkerRenderer, "enabled", true);
}
}
private static object InvokeRaycastAll(object origin, object direction, float dist)
{
if (RaycastAll == null)
{
return null;
}
ParameterInfo[] parameters = RaycastAll.GetParameters();
if (parameters.Length >= 5)
{
return RaycastAll.Invoke(null, new object[5]
{
origin,
direction,
dist,
-1,
QueryCollide ?? ((object)2)
});
}
if (parameters.Length == 4)
{
return RaycastAll.Invoke(null, new object[4] { origin, direction, dist, -1 });
}
return RaycastAll.Invoke(null, new object[3] { origin, direction, dist });
}
private static object InvokeOverlap(object pos, float radius)
{
if (OverlapSphere == null)
{
return null;
}
ParameterInfo[] parameters = OverlapSphere.GetParameters();
if (parameters.Length >= 4)
{
return OverlapSphere.Invoke(null, new object[4]
{
pos,
radius,
-1,
QueryCollide ?? ((object)2)
});
}
if (parameters.Length == 3)
{
return OverlapSphere.Invoke(null, new object[3] { pos, radius, -1 });
}
return OverlapSphere.Invoke(null, new object[2] { pos, radius });
}
private static bool TryHit(Vec3 from, Vec3 to, out bool enemy, out Vec3 hitPoint)
{
enemy = false;
hitPoint = to;
Vec3 vec = new Vec3(to.x - from.x, to.y - from.y, to.z - from.z);
float num = (float)Math.Sqrt(vec.SqrMag());
if (num < 0.001f)
{
return false;
}
Vec3 vec2 = vec.Mul(1f / num);
try
{
object origin = MakeV3(from.x, from.y, from.z);
object direction = MakeV3(vec2.x, vec2.y, vec2.z);
Array array = InvokeRaycastAll(origin, direction, num + 0.01f) as Array;
object obj = null;
float num2 = float.MaxValue;
bool flag = false;
if (array != null)
{
for (int i = 0; i < array.Length; i++)
{
object value = array.GetValue(i);
if (value == null)
{
continue;
}
float num3 = ((HitDistance != null) ? Convert.ToSingle(HitDistance.GetValue(value)) : ((float)i));
if (!(num3 < 0.04f) && !IsPlayerHit(value))
{
bool flag2 = IsEnemyHitObject((HitCollider != null) ? HitCollider.GetValue(value) : null);
if (obj == null || (flag2 && !flag) || (!flag && num3 < num2))
{
obj = value;
num2 = num3;
flag = flag2;
}
if (flag2)
{
break;
}
}
}
}
if (obj == null)
{
return false;
}
enemy = flag;
object obj2 = ((HitPoint != null) ? HitPoint.GetValue(obj) : null);
if (obj2 != null)
{
hitPoint = Vec3.From(obj2);
}
return true;
}
catch
{
return false;
}
}
private static bool IsPlayerHit(object hit)
{
return IsPlayerHitCollider((HitCollider != null) ? HitCollider.GetValue(hit) : null);
}
private static bool IsPlayerHitCollider(object col)
{
if (col == null)
{
return false;
}
if (PlayerHitboxType != null && FindComponent(col, PlayerHitboxType) != null)
{
return true;
}
object obj = ((ColliderGameObject != null) ? ColliderGameObject.GetValue(col) : null);
string text = ((obj != null && GameObjectName != null) ? Convert.ToString(GameObjectName.GetValue(obj)) : "");
if (!string.IsNullOrEmpty(text))
{
return text.IndexOf("Player", StringComparison.OrdinalIgnoreCase) >= 0;
}
return false;
}
private static bool IsEnemyHitObject(object obj)
{
if (obj == null)
{
return false;
}
if (PlayerHitboxType != null && FindComponent(obj, PlayerHitboxType) != null)
{
return false;
}
if (EnemyHitboxType != null && FindComponent(obj, EnemyHitboxType) != null)
{
return true;
}
if (EnemyControllerType != null && FindComponent(obj, EnemyControllerType) != null)
{
return true;
}
object obj2 = ((HitboxType != null) ? FindComponent(obj, HitboxType) : null);
if (obj2 != null && HitboxTypeProp != null)
{
object value = HitboxTypeProp.GetValue(obj2);
string text = ((value != null) ? Convert.ToString(value) : "");
if (text.IndexOf("PLAYER", StringComparison.OrdinalIgnoreCase) >= 0)
{
return false;
}
if (text.IndexOf("NORMAL", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("ELITE", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("BOSS", StringComparison.OrdinalIgnoreCase) >= 0)
{
return true;
}
}
return false;
}
private static object FindComponent(object obj, Type type)
{
if (obj == null || type == null)
{
return null;
}
try
{
if (type.IsInstanceOfType(obj))
{
return obj;
}
MethodInfo method = obj.GetType().GetMethod("GetComponent", new Type[1] { typeof(Type) });
if (method != null)
{
object obj2 = method.Invoke(obj, new object[1] { type });
if (obj2 != null)
{
return obj2;
}
}
if (GetComponentInParentTyped != null)
{
object obj3 = GetComponentInParentTyped.Invoke(obj, new object[1] { type });
if (obj3 != null)
{
return obj3;
}
}
}
catch
{
}
return null;
}
}
public static class Patches
{
internal static bool ThrowHeld;
internal static bool BowHeld;
private static bool _wasLmb;
private static float _holdStart;
private static object _cachedItem;
private static int _equipTick;
private static int _hideFrames;
private static float _lastLoggedCharge = -1f;
public static void OnThrowPrimary(bool _B)
{
ThrowHeld = _B;
if (_B)
{
_holdStart = UnityCache.Now();
}
else
{
UnityCache.HideLine();
}
}
public static void OnBowPrimary(bool _B)
{
BowHeld = _B;
if (_B)
{
_holdStart = UnityCache.Now();
}
else
{
UnityCache.HideLine();
}
}
public static void OnPlayerUpdate(object __instance)
{
if (!IsLocalPlayer(__instance))
{
return;
}
bool num = UnityCache.IsLmbHeld();
if (num && !_wasLmb)
{
_holdStart = UnityCache.Now();
}
_wasLmb = num;
if (!num)
{
if (_hideFrames < 2)
{
UnityCache.HideLine();
_hideFrames++;
}
ThrowHeld = false;
BowHeld = false;
return;
}
_hideFrames = 0;
if ((_equipTick++ & 3) == 0 || _cachedItem == null)
{
_cachedItem = GetEquippedItem(__instance);
}
object cachedItem = _cachedItem;
string name = cachedItem?.GetType().Name;
bool flag = Plugin.ShowBombTrajectory.Value && IsBombTool(name);
bool flag2 = Plugin.ShowArrowTrajectory.Value && IsBowTool(name);
if (!flag && !flag2)
{
UnityCache.HideLine();
return;
}
if (!UnityCache.TryGetCamVectors(out var pos, out var forward, out var right))
{
UnityCache.HideLine();
return;
}
float charge = GetCharge01(cachedItem);
float speed = GetSpeed(cachedItem, __instance, flag, charge);
UnityCache.DrawArc(GetStart(cachedItem, pos, forward, right), forward.Normalized(), speed, out var _);
if (Math.Abs(charge - _lastLoggedCharge) > 0.24f)
{
_lastLoggedCharge = charge;
Plugin.Log.LogInfo((object)((flag ? "bomb" : "arrow") + " charge=" + charge.ToString("0.00") + " speed=" + speed.ToString("0.0") + " hold=" + (UnityCache.Now() - _holdStart).ToString("0.00")));
}
}
private static Vec3 GetStart(object item, Vec3 camPos, Vec3 forward, Vec3 right)
{
Vec3 result = camPos.Add(forward.Mul(0.35f)).Add(right.Mul(Plugin.RightOffset.Value)).Add(new Vec3(0f, 0f - Plugin.DownOffset.Value, 0f));
if (item == null)
{
return result;
}
try
{
object member = GetMember(item, "bowPosition");
if (member != null && UnityCache.PositionProp != null)
{
object value = UnityCache.PositionProp.GetValue(member);
if (value != null)
{
return Vec3.From(value).Add(forward.Mul(0.12f));
}
}
}
catch
{
}
return result;
}
private static float GetCharge01(object tool)
{
float num = UnityCache.Now();
float num2 = 0.75f;
float num3 = _holdStart;
bool flag = false;
if (tool != null)
{
float num4 = ToFloat(GetMember(tool, "aimingDuration"), 0f);
if (num4 > 0.05f)
{
num2 = num4;
}
if (GetMember(tool, "isFullyCharged") is bool flag2)
{
flag = flag2;
}
float num5 = ToFloat(GetMember(tool, "aimingStartTime"), 0f);
if (num5 > 0.05f)
{
num3 = num5;
}
}
if (flag)
{
return 1f;
}
float num6 = (num - num3) / num2;
if (num6 < 0f)
{
num6 = 0f;
}
if (num6 > 1f)
{
num6 = 1f;
}
return num6;
}
private static float GetSpeed(object item, object player, bool bomb, float charge)
{
float num = (bomb ? 8f : 18f);
float num2 = (bomb ? 22f : 42f);
if (bomb && item != null)
{
object member = GetMember(item, "forceRange");
if (member != null)
{
float num3 = ToFloat(GetMember(member, "x"), 0f);
float num4 = ToFloat(GetMember(member, "y"), 0f);
if (num3 > 0.1f)
{
num = num3;
}
if (num4 > 0.1f)
{
num2 = num4;
}
}
}
if (!bomb && player != null)
{
try
{
object obj = GetMember(player, "FPSSettingsSO") ?? GetMember(player, "fpsSettingsSo");
object obj2 = GetMember(obj, "BowForce") ?? GetMember(obj, "bowForce");
if (obj2 != null)
{
float num5 = ToFloat(GetMember(obj2, "x"), 0f);
float num6 = ToFloat(GetMember(obj2, "y"), 0f);
if (num5 > 0.1f)
{
num = num5;
}
if (num6 > 0.1f)
{
num2 = num6;
}
}
}
catch
{
}
}
float num7 = num + (num2 - num) * charge;
if (!bomb && player != null)
{
try
{
object obj4 = GetMember(player, "playerClass") ?? GetMember(player, "NetworkplayerClass");
int num8 = ((obj4 != null) ? Convert.ToInt32(obj4) : (-1));
object obj5 = GetMember(player, "PlayerArchetypeSO") ?? GetMember(player, "playerArchetypeSO");
object obj6 = GetMember(obj5, "ArcherStats") ?? GetMember(obj5, "archerStats");
float num9 = ToFloat(GetMember(obj6, "ArrowForceMultiplayer") ?? GetMember(obj6, "arrowForceMultiplayer"), 1f);
if (num9 > 0.05f && (num8 == 1 || obj6 != null))
{
num7 *= num9;
}
}
catch
{
}
}
float num10 = ToFloat(GetMember((player != null) ? (GetMember(player, "PlayerStats") ?? GetMember(player, "playerStats")) : null, "ProjectileSpeed"), 1f);
if (!bomb && num10 > 0.05f && num10 < 10f)
{
num7 *= num10;
}
return num7;
}
private static float ToFloat(object v, float fallback)
{
if (v == null)
{
return fallback;
}
try
{
return Convert.ToSingle(v);
}
catch
{
return fallback;
}
}
private static bool IsBombTool(string name)
{
if (!string.IsNullOrEmpty(name))
{
if (name.IndexOf("Throwable", StringComparison.OrdinalIgnoreCase) < 0)
{
return name.IndexOf("Bomb", StringComparison.OrdinalIgnoreCase) >= 0;
}
return true;
}
return false;
}
private static bool IsBowTool(string name)
{
if (!string.IsNullOrEmpty(name))
{
return name.IndexOf("Bow", StringComparison.OrdinalIgnoreCase) >= 0;
}
return false;
}
private static bool IsLocalPlayer(object player)
{
if (player == null)
{
return false;
}
try
{
PropertyInfo property = player.GetType().GetProperty("isLocalPlayer", BindingFlags.Instance | BindingFlags.Public);
if (property != null)
{
return Convert.ToBoolean(property.GetValue(player));
}
}
catch
{
}
return true;
}
private static object GetEquippedItem(object player)
{
try
{
object obj = GetMember(player, "PlayerEquipment") ?? GetMember(player, "playerEquipment");
if (obj == null)
{
return null;
}
return GetMember(obj, "CurrentEquippedItem") ?? GetMember(obj, "currentEquippedItem");
}
catch
{
return null;
}
}
private static object GetMember(object obj, string name)
{
if (obj == null)
{
return null;
}
PropertyInfo property = obj.GetType().GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property != null)
{
return property.GetValue(obj);
}
FieldInfo fieldInfo = AccessTools.Field(obj.GetType(), name);
if (!(fieldInfo != null))
{
return null;
}
return fieldInfo.GetValue(obj);
}
}
internal struct Vec3
{
public float x;
public float y;
public float z;
public Vec3(float x, float y, float z)
{
this.x = x;
this.y = y;
this.z = z;
}
public static Vec3 From(object obj)
{
return new Vec3(Convert.ToSingle(UnityCache.VecX.GetValue(obj)), Convert.ToSingle(UnityCache.VecY.GetValue(obj)), Convert.ToSingle(UnityCache.VecZ.GetValue(obj)));
}
public Vec3 Add(Vec3 o)
{
return new Vec3(x + o.x, y + o.y, z + o.z);
}
public Vec3 Mul(float s)
{
return new Vec3(x * s, y * s, z * s);
}
public float SqrMag()
{
return x * x + y * y + z * z;
}
public Vec3 Normalized()
{
float num = (float)Math.Sqrt(SqrMag());
if (num < 0.0001f)
{
return new Vec3(0f, 0f, 1f);
}
return new Vec3(x / num, y / num, z / num);
}
}
}
