273 lines
7.6 KiB
C#
273 lines
7.6 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Numerics;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
using FFXIVClientStructs.FFXIV.Client.System.Framework;
|
|
using FFXIVClientStructs.FFXIV.Common.Component.BGCollision;
|
|
|
|
namespace LLib.Fishing;
|
|
|
|
public static class WaterSurfaceDetector
|
|
{
|
|
public static bool IsFishable(Vector3 position, float rotation)
|
|
{
|
|
Vector3? hitPoint;
|
|
return CheckFishableAtRotation(position, rotation, out hitPoint);
|
|
}
|
|
|
|
public static (float Rotation, Vector3 HitPoint)? FindFishableRotation(Vector3 position, int searchSteps = 36)
|
|
{
|
|
float num = MathF.PI * 2f / (float)searchSteps;
|
|
List<int> list = new List<int>();
|
|
int num2 = 0;
|
|
int num3 = -766816580;
|
|
Vector3? hitPoint = default(Vector3?);
|
|
float num9 = default(float);
|
|
while (true)
|
|
{
|
|
int num4 = num3;
|
|
int num5 = -766816580;
|
|
int num6 = num4;
|
|
int num7 = num6 + num5;
|
|
int num8 = num6 & num5;
|
|
switch (num7 - (num8 + num8))
|
|
{
|
|
case 3:
|
|
return null;
|
|
case 0:
|
|
num3 = ((num2 < searchSteps) ? (-766816579) : (-766816582));
|
|
break;
|
|
case 9:
|
|
num3 = ((!hitPoint.HasValue) ? (-766816584) : (-766816588));
|
|
break;
|
|
case 1:
|
|
{
|
|
float rotation = (float)num2 * num;
|
|
num3 = ((!CheckFishableAtRotation(position, rotation, out var _)) ? (-766816578) : (-766816583));
|
|
break;
|
|
}
|
|
case 8:
|
|
return (num9, hitPoint.Value);
|
|
case 6:
|
|
num3 = ((list.Count != 0) ? (-766816581) : (-766816577));
|
|
break;
|
|
case 4:
|
|
return null;
|
|
case 2:
|
|
{
|
|
int num10 = num2;
|
|
num5 = 1;
|
|
num6 = num10;
|
|
num2 = (num6 | num5) + (num6 & num5);
|
|
num3 = -766816580;
|
|
break;
|
|
}
|
|
case 5:
|
|
list.Add(num2);
|
|
num3 = -766816578;
|
|
break;
|
|
case 7:
|
|
{
|
|
List<int> list2 = (from g in FindContiguousGroups(list, searchSteps)
|
|
orderby g.Count descending
|
|
select g).First();
|
|
num9 = ((float)list2[0] + (float)(list2.Count - 1) / 2f) % (float)searchSteps * num;
|
|
num3 = ((!CheckFishableAtRotation(position, num9, out hitPoint)) ? (-766816584) : (-766816587));
|
|
break;
|
|
}
|
|
case 10:
|
|
num3 = -766816580;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private unsafe static bool CheckFishableAtRotation(Vector3 position, float rotation, out Vector3? hitPoint)
|
|
{
|
|
hitPoint = null;
|
|
Framework* ptr = Framework.Instance();
|
|
int num = ((ptr == null) ? (-9575683) : (-9575687));
|
|
BGCollisionModule* bGCollisionModule = default(BGCollisionModule*);
|
|
Matrix4x4 matrix = default(Matrix4x4);
|
|
Vector3 vector3 = default(Vector3);
|
|
RaycastHit raycastHit2 = default(RaycastHit);
|
|
RaycastHit raycastHit = default(RaycastHit);
|
|
while (true)
|
|
{
|
|
int num2 = num;
|
|
int num3 = -9575688;
|
|
int num4 = num2;
|
|
int num5 = num4 + num3;
|
|
int num6 = num4 & num3;
|
|
ReadOnlySpan<int> readOnlySpan;
|
|
switch (num5 - (num6 + num6))
|
|
{
|
|
case 0:
|
|
{
|
|
bGCollisionModule = ptr->BGCollisionModule;
|
|
float num8 = _200B_202E_206E_202C_202E_202E_202E_200D_206A_202D_206E_206B_202C_206E_202E_206D_206D_200E_206B_202B_202D_202E_206D_202A_206F_200E_202C_206A_206F_206A_202C_200B_200F_206F_206A_202E_202E_206F_200F_202B_202E(rotation);
|
|
float num9 = _202A_206D_202E_200E_200F_202D_206D_202A_206C_206C_206A_200D_206B_206E_206D_200E_206B_202B_206F_206F_206E_206D_206B_202B_200E_200D_206F_202B_206E_202E_206F_200D_202E_202D_206A_202B_200F_206C_202D_206F_202E(rotation);
|
|
matrix = new Matrix4x4
|
|
{
|
|
M11 = num8,
|
|
M13 = 0f - num9,
|
|
M22 = 1f,
|
|
M31 = num9,
|
|
M33 = num8
|
|
};
|
|
vector3 = Vector3.Transform(new Vector3(0f, 0f, 2f), matrix) + position;
|
|
vector3.Y += 2f;
|
|
Vector3 vector4 = new Vector3(position.X, position.Y + 0.87f, position.Z);
|
|
Vector3 vector5 = Vector3.Normalize(vector3 - vector4);
|
|
float maxDistance = Vector3.Distance(vector4, vector3);
|
|
byte* intPtr2 = stackalloc byte[16];
|
|
readOnlySpan = new int[4] { 16384, 0, 16384, 0 };
|
|
// IL cpblk instruction
|
|
Unsafe.CopyBlockUnaligned(intPtr2, ref readOnlySpan[0], 16);
|
|
int* flags2 = (int*)intPtr2;
|
|
num = ((!bGCollisionModule->RaycastMaterialFilter(&raycastHit2, &vector4, &vector5, maxDistance, 1, flags2)) ? (-9575686) : (-9575681));
|
|
break;
|
|
}
|
|
case 5:
|
|
return false;
|
|
case 1:
|
|
num = ((ptr->BGCollisionModule != null) ? (-9575688) : (-9575683));
|
|
break;
|
|
case 6:
|
|
num = -9575687;
|
|
break;
|
|
case 7:
|
|
return false;
|
|
case 4:
|
|
hitPoint = raycastHit.Point;
|
|
return true;
|
|
case 3:
|
|
return false;
|
|
case 2:
|
|
{
|
|
Vector3 vector = Vector3.Transform(new Vector3(0f, -80f, 40f), matrix);
|
|
float num7 = vector.Length();
|
|
Vector3 vector2 = vector / num7;
|
|
byte* intPtr = stackalloc byte[16];
|
|
readOnlySpan = new int[4] { 32768, 0, 32768, 0 };
|
|
// IL cpblk instruction
|
|
Unsafe.CopyBlockUnaligned(intPtr, ref readOnlySpan[0], 16);
|
|
int* flags = (int*)intPtr;
|
|
num = ((!bGCollisionModule->RaycastMaterialFilter(&raycastHit, &vector3, &vector2, num7, 1, flags)) ? (-9575685) : (-9575684));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static List<List<int>> FindContiguousGroups(List<int> angles, int maxSteps)
|
|
{
|
|
int num = ((angles.Count != 0) ? 1779780775 : 1779780774);
|
|
List<int> list3 = default(List<int>);
|
|
List<int> list5 = default(List<int>);
|
|
int num8 = default(int);
|
|
List<List<int>> list2 = default(List<List<int>>);
|
|
while (true)
|
|
{
|
|
int num2 = num;
|
|
int num3 = 1779780780;
|
|
int num4 = num2;
|
|
int num5 = num4 + num3;
|
|
int num6 = num4 & num3;
|
|
switch (num5 - (num6 + num6))
|
|
{
|
|
case 4:
|
|
list3.Add(list5[num8]);
|
|
num = 1779780783;
|
|
break;
|
|
case 6:
|
|
num = ((list5[0] != 0) ? 1779780777 : 1779780772);
|
|
break;
|
|
case 0:
|
|
{
|
|
int num12 = list5[num8];
|
|
List<int> list6 = list5;
|
|
int num13 = num8;
|
|
num3 = 1;
|
|
num4 = num13;
|
|
num = ((num12 - list6[~(~num4 + num3)] != 1) ? 1779780779 : 1779780776);
|
|
break;
|
|
}
|
|
case 1:
|
|
list2.Add(list3);
|
|
num = ((list2.Count <= 1) ? 1779780777 : 1779780778);
|
|
break;
|
|
case 9:
|
|
num = ((num8 < list5.Count) ? 1779780780 : 1779780781);
|
|
break;
|
|
case 2:
|
|
num = 1779780774;
|
|
break;
|
|
case 8:
|
|
{
|
|
List<int> list7 = list5;
|
|
int num14 = list7[list7.Count - 1];
|
|
num3 = 1;
|
|
num4 = maxSteps;
|
|
num = ((num14 != ~(~num4 + num3)) ? 1779780777 : 1779780768);
|
|
break;
|
|
}
|
|
case 5:
|
|
return list2;
|
|
case 10:
|
|
return new List<List<int>>();
|
|
case 11:
|
|
list5 = angles.OrderBy((int a) => a).ToList();
|
|
list2 = new List<List<int>>();
|
|
list3 = new List<int> { list5[0] };
|
|
num8 = 1;
|
|
num = 1779780773;
|
|
break;
|
|
case 7:
|
|
{
|
|
list2.Add(list3);
|
|
int num11 = 1;
|
|
List<int> list4 = new List<int>(num11);
|
|
CollectionsMarshal.SetCount(list4, num11);
|
|
CollectionsMarshal.AsSpan(list4)[0] = list5[num8];
|
|
list3 = list4;
|
|
num = 1779780783;
|
|
break;
|
|
}
|
|
case 12:
|
|
{
|
|
List<List<int>> list = list2;
|
|
List<int> item = list[list.Count - 1].Concat(list2[0]).ToList();
|
|
list2.RemoveAt(list2.Count - 1);
|
|
list2.RemoveAt(0);
|
|
list2.Add(item);
|
|
num = 1779780777;
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
int num7 = num8;
|
|
num3 = 1;
|
|
num4 = num7;
|
|
int num9 = num4 ^ num3;
|
|
int num10 = num4 & num3;
|
|
num8 = num9 + (num10 + num10);
|
|
num = 1779780773;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static float _200B_202E_206E_202C_202E_202E_202E_200D_206A_202D_206E_206B_202C_206E_202E_206D_206D_200E_206B_202B_202D_202E_206D_202A_206F_200E_202C_206A_206F_206A_202C_200B_200F_206F_206A_202E_202E_206F_200F_202B_202E(float P_0)
|
|
{
|
|
return MathF.Cos(P_0);
|
|
}
|
|
|
|
static float _202A_206D_202E_200E_200F_202D_206D_202A_206C_206C_206A_200D_206B_206E_206D_200E_206B_202B_206F_206F_206E_206D_206B_202B_200E_200D_206F_202B_206E_202E_206F_200D_202E_202D_206A_202B_200F_206C_202D_206F_202E(float P_0)
|
|
{
|
|
return MathF.Sin(P_0);
|
|
}
|
|
}
|