forked from aly/qstbak
muffin v7.5.11
This commit is contained in:
parent
addf2d530f
commit
3102923ce2
522 changed files with 41082 additions and 211592 deletions
|
|
@ -19,255 +19,116 @@ public static class WaterSurfaceDetector
|
|||
|
||||
public static (float Rotation, Vector3 HitPoint)? FindFishableRotation(Vector3 position, int searchSteps = 36)
|
||||
{
|
||||
float num = MathF.PI * 2f / (float)searchSteps;
|
||||
float num = (float)Math.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)
|
||||
for (int i = 0; i < searchSteps; i++)
|
||||
{
|
||||
int num4 = num3;
|
||||
int num5 = -766816580;
|
||||
int num6 = num4;
|
||||
int num7 = num6 + num5;
|
||||
int num8 = num6 & num5;
|
||||
switch (num7 - (num8 + num8))
|
||||
float rotation = (float)i * num;
|
||||
if (CheckFishableAtRotation(position, rotation, out var _))
|
||||
{
|
||||
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;
|
||||
list.Add(i);
|
||||
}
|
||||
}
|
||||
if (list.Count == 0)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
List<int> list2 = (from g in FindContiguousGroups(list, searchSteps)
|
||||
orderby g.Count descending
|
||||
select g).First();
|
||||
float num2 = ((float)list2[0] + (float)(list2.Count - 1) / 2f) % (float)searchSteps * num;
|
||||
if (CheckFishableAtRotation(position, num2, out var hitPoint2) && hitPoint2.HasValue)
|
||||
{
|
||||
return (num2, hitPoint2.Value);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
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)
|
||||
if (ptr == null || ptr->BGCollisionModule == null)
|
||||
{
|
||||
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;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
BGCollisionModule* bGCollisionModule = ptr->BGCollisionModule;
|
||||
float num = MathF.Cos(rotation);
|
||||
float num2 = MathF.Sin(rotation);
|
||||
Matrix4x4 matrix = new Matrix4x4
|
||||
{
|
||||
M11 = num,
|
||||
M13 = 0f - num2,
|
||||
M22 = 1f,
|
||||
M31 = num2,
|
||||
M33 = num
|
||||
};
|
||||
Vector3 vector = Vector3.Transform(new Vector3(0f, 0f, 2f), matrix) + position;
|
||||
vector.Y += 2f;
|
||||
Vector3 vector2 = new Vector3(position.X, position.Y + 0.87f, position.Z);
|
||||
Vector3 vector3 = Vector3.Normalize(vector - vector2);
|
||||
float maxDistance = Vector3.Distance(vector2, vector);
|
||||
byte* intPtr = stackalloc byte[16];
|
||||
ReadOnlySpan<int> readOnlySpan = new int[4] { 16384, 0, 16384, 0 };
|
||||
// IL cpblk instruction
|
||||
Unsafe.CopyBlockUnaligned(intPtr, ref readOnlySpan[0], 16);
|
||||
int* flags = (int*)intPtr;
|
||||
RaycastHit raycastHit = default(RaycastHit);
|
||||
if (bGCollisionModule->RaycastMaterialFilter(&raycastHit, &vector2, &vector3, maxDistance, 1, flags))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
Vector3 vector4 = Vector3.Transform(new Vector3(0f, -80f, 40f), matrix);
|
||||
float num3 = vector4.Length();
|
||||
Vector3 vector5 = vector4 / num3;
|
||||
byte* intPtr2 = stackalloc byte[16];
|
||||
readOnlySpan = new int[4] { 32768, 0, 32768, 0 };
|
||||
// IL cpblk instruction
|
||||
Unsafe.CopyBlockUnaligned(intPtr2, ref readOnlySpan[0], 16);
|
||||
int* flags2 = (int*)intPtr2;
|
||||
RaycastHit raycastHit2 = default(RaycastHit);
|
||||
if (bGCollisionModule->RaycastMaterialFilter(&raycastHit2, &vector, &vector5, num3, 1, flags2))
|
||||
{
|
||||
hitPoint = raycastHit2.Point;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
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)
|
||||
if (angles.Count == 0)
|
||||
{
|
||||
int num2 = num;
|
||||
int num3 = 1779780780;
|
||||
int num4 = num2;
|
||||
int num5 = num4 + num3;
|
||||
int num6 = num4 & num3;
|
||||
switch (num5 - (num6 + num6))
|
||||
return new List<List<int>>();
|
||||
}
|
||||
List<int> list = angles.OrderBy((int a) => a).ToList();
|
||||
List<List<int>> list2 = new List<List<int>>();
|
||||
List<int> list3 = new List<int> { list[0] };
|
||||
for (int num = 1; num < list.Count; num++)
|
||||
{
|
||||
if (list[num] - list[num - 1] == 1)
|
||||
{
|
||||
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;
|
||||
list3.Add(list[num]);
|
||||
continue;
|
||||
}
|
||||
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:
|
||||
list2.Add(list3);
|
||||
int num2 = 1;
|
||||
List<int> list4 = new List<int>(num2);
|
||||
CollectionsMarshal.SetCount(list4, num2);
|
||||
CollectionsMarshal.AsSpan(list4)[0] = list[num];
|
||||
list3 = list4;
|
||||
}
|
||||
list2.Add(list3);
|
||||
if (list2.Count > 1 && list[0] == 0)
|
||||
{
|
||||
if (list[list.Count - 1] == maxSteps - 1)
|
||||
{
|
||||
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();
|
||||
List<int> item = list2[list2.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);
|
||||
return list2;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue