niko
598 lines
18 KiB
C#
598 lines
18 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Runtime.CompilerServices;
|
|
using UnityEngine;
|
|
using UnityEngine.AI;
|
|
|
|
namespace Valve.VR.InteractionSystem
|
|
{
|
|
// Token: 0x020005DB RID: 1499
|
|
public static class OFPFHHLNHIC
|
|
{
|
|
// Token: 0x0600EE04 RID: 60932 RVA: 0x00471658 File Offset: 0x0046F858
|
|
public static float DNNJGEBICKH(float KCKJDFMJNFO, float KADFJBOMBIN, float FDMEAJDJDNK, float COMNKILGNCK, float EBBLBCIAHMJ)
|
|
{
|
|
return COMNKILGNCK + (KCKJDFMJNFO - KADFJBOMBIN) * (EBBLBCIAHMJ - COMNKILGNCK) / (FDMEAJDJDNK - KADFJBOMBIN);
|
|
}
|
|
|
|
// Token: 0x0600EE05 RID: 60933 RVA: 0x00471668 File Offset: 0x0046F868
|
|
public static float DKPCDKNIGLJ(float KCKJDFMJNFO, float KADFJBOMBIN, float FDMEAJDJDNK, float COMNKILGNCK, float EBBLBCIAHMJ)
|
|
{
|
|
return Mathf.Clamp(OFPFHHLNHIC.DNNJGEBICKH(KCKJDFMJNFO, KADFJBOMBIN, FDMEAJDJDNK, COMNKILGNCK, EBBLBCIAHMJ), Mathf.Min(COMNKILGNCK, EBBLBCIAHMJ), Mathf.Max(COMNKILGNCK, EBBLBCIAHMJ));
|
|
}
|
|
|
|
// Token: 0x0600EE06 RID: 60934 RVA: 0x0047168C File Offset: 0x0046F88C
|
|
public static float JJFNNGDDBGI(float MMEBLCBANIL, float NOBAPCOKFIL, float BGJNLBNEINL)
|
|
{
|
|
float num = MMEBLCBANIL - NOBAPCOKFIL;
|
|
if (num > BGJNLBNEINL)
|
|
{
|
|
NOBAPCOKFIL += BGJNLBNEINL;
|
|
}
|
|
else if (num < -BGJNLBNEINL)
|
|
{
|
|
NOBAPCOKFIL -= BGJNLBNEINL;
|
|
}
|
|
else
|
|
{
|
|
NOBAPCOKFIL = MMEBLCBANIL;
|
|
}
|
|
return NOBAPCOKFIL;
|
|
}
|
|
|
|
// Token: 0x0600EE07 RID: 60935 RVA: 0x004716C4 File Offset: 0x0046F8C4
|
|
public static Vector3 ECLNMBHNLNI(Vector3 NDGGMDGOPHJ, Vector3 PLOEDBBOLCB, Vector3 MLOLFOOLJMF, float LHMELEOKNBJ)
|
|
{
|
|
Vector3 vector = Vector3.Lerp(NDGGMDGOPHJ, PLOEDBBOLCB, LHMELEOKNBJ);
|
|
Vector3 vector2 = Vector3.Lerp(PLOEDBBOLCB, MLOLFOOLJMF, LHMELEOKNBJ);
|
|
return Vector3.Lerp(vector, vector2, LHMELEOKNBJ);
|
|
}
|
|
|
|
// Token: 0x0600EE08 RID: 60936 RVA: 0x004716EC File Offset: 0x0046F8EC
|
|
public static Vector3 PGIKIFIACDD(Vector3 NDGGMDGOPHJ, Vector3 PLOEDBBOLCB, Vector3 INEJAMKNCNJ, Vector3 MLOLFOOLJMF, float LHMELEOKNBJ)
|
|
{
|
|
Vector3 vector = Vector3.Lerp(NDGGMDGOPHJ, PLOEDBBOLCB, LHMELEOKNBJ);
|
|
Vector3 vector2 = Vector3.Lerp(PLOEDBBOLCB, INEJAMKNCNJ, LHMELEOKNBJ);
|
|
Vector3 vector3 = Vector3.Lerp(INEJAMKNCNJ, MLOLFOOLJMF, LHMELEOKNBJ);
|
|
Vector3 vector4 = Vector3.Lerp(vector, vector2, LHMELEOKNBJ);
|
|
Vector3 vector5 = Vector3.Lerp(vector2, vector3, LHMELEOKNBJ);
|
|
return Vector3.Lerp(vector4, vector5, LHMELEOKNBJ);
|
|
}
|
|
|
|
// Token: 0x0600EE09 RID: 60937 RVA: 0x00471738 File Offset: 0x0046F938
|
|
public static Vector3 PMJHFLAFNBL(string KCFHHIBIECA)
|
|
{
|
|
string[] array = KCFHHIBIECA.Substring(1, KCFHHIBIECA.Length - 1).Split(new char[] { ',' });
|
|
float num = float.Parse(array[0]);
|
|
float num2 = float.Parse(array[1]);
|
|
float num3 = float.Parse(array[2]);
|
|
Vector3 vector = new Vector3(num, num2, num3);
|
|
return vector;
|
|
}
|
|
|
|
// Token: 0x0600EE0A RID: 60938 RVA: 0x0047178C File Offset: 0x0046F98C
|
|
public static Vector2 BFKBCLHGDPH(string KCFHHIBIECA)
|
|
{
|
|
string[] array = KCFHHIBIECA.Substring(1, KCFHHIBIECA.Length - 1).Split(new char[] { ',' });
|
|
float num = float.Parse(array[0]);
|
|
float num2 = float.Parse(array[1]);
|
|
Vector3 vector = new Vector2(num, num2);
|
|
return vector;
|
|
}
|
|
|
|
// Token: 0x0600EE0B RID: 60939 RVA: 0x004717E0 File Offset: 0x0046F9E0
|
|
public static float JNJGNFPDHKC(float NOBAPCOKFIL, float MLCNKHEEDNL, float EGIPNAJLAGN)
|
|
{
|
|
return (NOBAPCOKFIL - MLCNKHEEDNL) / (EGIPNAJLAGN - MLCNKHEEDNL);
|
|
}
|
|
|
|
// Token: 0x0600EE0C RID: 60940 RVA: 0x004717F8 File Offset: 0x0046F9F8
|
|
public static Vector3 PBBFFIPCJAE(Vector2 MAIFPGCJJLG)
|
|
{
|
|
return new Vector3(MAIFPGCJJLG.x, 0f, MAIFPGCJJLG.y);
|
|
}
|
|
|
|
// Token: 0x0600EE0D RID: 60941 RVA: 0x00471814 File Offset: 0x0046FA14
|
|
public static Vector2 NJKEJMBMANF(Vector3 MAIFPGCJJLG)
|
|
{
|
|
return new Vector2(MAIFPGCJJLG.x, MAIFPGCJJLG.z);
|
|
}
|
|
|
|
// Token: 0x0600EE0E RID: 60942 RVA: 0x0047182C File Offset: 0x0046FA2C
|
|
public static float FLIGAABNOCE(Vector2 MAIFPGCJJLG)
|
|
{
|
|
float magnitude = MAIFPGCJJLG.magnitude;
|
|
if (MAIFPGCJJLG.y >= 0f)
|
|
{
|
|
return Mathf.Acos(MAIFPGCJJLG.x / magnitude);
|
|
}
|
|
return Mathf.Acos(-MAIFPGCJJLG.x / magnitude) + 3.1415927f;
|
|
}
|
|
|
|
// Token: 0x0600EE0F RID: 60943 RVA: 0x00471878 File Offset: 0x0046FA78
|
|
public static float MIOOEPMHMGH(Vector3 MAIFPGCJJLG)
|
|
{
|
|
float magnitude = MAIFPGCJJLG.magnitude;
|
|
if (MAIFPGCJJLG.z >= 0f)
|
|
{
|
|
return Mathf.Acos(MAIFPGCJJLG.x / magnitude);
|
|
}
|
|
return Mathf.Acos(-MAIFPGCJJLG.x / magnitude) + 3.1415927f;
|
|
}
|
|
|
|
// Token: 0x0600EE10 RID: 60944 RVA: 0x004718C4 File Offset: 0x0046FAC4
|
|
public static void ACGHJHGJKPK<T>(ref T DPIIIAGCMLK, ref T BDKNHBMMGPK)
|
|
{
|
|
T t = DPIIIAGCMLK;
|
|
DPIIIAGCMLK = BDKNHBMMGPK;
|
|
BDKNHBMMGPK = t;
|
|
}
|
|
|
|
// Token: 0x0600EE11 RID: 60945 RVA: 0x004718EC File Offset: 0x0046FAEC
|
|
public static void OFFICKPKMFJ<T>(T[] GDLLJBOEGNF)
|
|
{
|
|
for (int i = GDLLJBOEGNF.Length - 1; i > 0; i--)
|
|
{
|
|
int num = global::UnityEngine.Random.Range(0, i);
|
|
OFPFHHLNHIC.ACGHJHGJKPK<T>(ref GDLLJBOEGNF[i], ref GDLLJBOEGNF[num]);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600EE12 RID: 60946 RVA: 0x0047192C File Offset: 0x0046FB2C
|
|
public static void OFFICKPKMFJ<T>(List<T> MKEOFCIGBDG)
|
|
{
|
|
for (int i = MKEOFCIGBDG.Count - 1; i > 0; i--)
|
|
{
|
|
int num = global::UnityEngine.Random.Range(0, i);
|
|
T t = MKEOFCIGBDG[i];
|
|
MKEOFCIGBDG[i] = MKEOFCIGBDG[num];
|
|
MKEOFCIGBDG[num] = t;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600EE13 RID: 60947 RVA: 0x00471978 File Offset: 0x0046FB78
|
|
public static int FOLPBCCKANH(int MLCNKHEEDNL, int EGIPNAJLAGN, List<int> ELODGAIFIBE, int EBLJFNGHHPJ)
|
|
{
|
|
int num = global::UnityEngine.Random.Range(MLCNKHEEDNL, EGIPNAJLAGN - ELODGAIFIBE.Count);
|
|
for (int i = 0; i < ELODGAIFIBE.Count; i++)
|
|
{
|
|
if (num >= ELODGAIFIBE[i])
|
|
{
|
|
num++;
|
|
}
|
|
}
|
|
ELODGAIFIBE.Add(num);
|
|
if (ELODGAIFIBE.Count > EBLJFNGHHPJ)
|
|
{
|
|
ELODGAIFIBE.RemoveRange(0, ELODGAIFIBE.Count - EBLJFNGHHPJ);
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x0600EE14 RID: 60948 RVA: 0x004719E0 File Offset: 0x0046FBE0
|
|
public static Transform CPJGEOJDPHJ(Transform CNGOCFABIFK, string EKKMPHMGCLB)
|
|
{
|
|
if (CNGOCFABIFK.name == EKKMPHMGCLB)
|
|
{
|
|
return CNGOCFABIFK;
|
|
}
|
|
IEnumerator enumerator = CNGOCFABIFK.GetEnumerator();
|
|
try
|
|
{
|
|
while (enumerator.MoveNext())
|
|
{
|
|
object obj = enumerator.Current;
|
|
Transform transform = (Transform)obj;
|
|
Transform transform2 = OFPFHHLNHIC.CPJGEOJDPHJ(transform, EKKMPHMGCLB);
|
|
if (transform2 != null)
|
|
{
|
|
return transform2;
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
IDisposable disposable;
|
|
if ((disposable = enumerator as IDisposable) != null)
|
|
{
|
|
disposable.Dispose();
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600EE15 RID: 60949 RVA: 0x00471A6C File Offset: 0x0046FC6C
|
|
public static bool JJHMEPBDIBC<T>(T[] GDLLJBOEGNF)
|
|
{
|
|
return GDLLJBOEGNF == null || GDLLJBOEGNF.Length == 0;
|
|
}
|
|
|
|
// Token: 0x0600EE16 RID: 60950 RVA: 0x00471A84 File Offset: 0x0046FC84
|
|
public static bool BFACOODCBHF<T>(T[] GDLLJBOEGNF, int CIMNKHDEFOH)
|
|
{
|
|
return GDLLJBOEGNF != null && CIMNKHDEFOH >= 0 && CIMNKHDEFOH < GDLLJBOEGNF.Length;
|
|
}
|
|
|
|
// Token: 0x0600EE17 RID: 60951 RVA: 0x00471AA0 File Offset: 0x0046FCA0
|
|
public static bool BFACOODCBHF<T>(List<T> MKEOFCIGBDG, int CIMNKHDEFOH)
|
|
{
|
|
return MKEOFCIGBDG != null && MKEOFCIGBDG.Count != 0 && CIMNKHDEFOH >= 0 && CIMNKHDEFOH < MKEOFCIGBDG.Count;
|
|
}
|
|
|
|
// Token: 0x0600EE18 RID: 60952 RVA: 0x00471AC8 File Offset: 0x0046FCC8
|
|
public static int IAAOFLBPJAL<T>(List<T> MKEOFCIGBDG, T OKKMGANCMGB)
|
|
{
|
|
int num = MKEOFCIGBDG.IndexOf(OKKMGANCMGB);
|
|
if (num == -1)
|
|
{
|
|
MKEOFCIGBDG.Add(OKKMGANCMGB);
|
|
num = MKEOFCIGBDG.Count - 1;
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x0600EE19 RID: 60953 RVA: 0x00471AF8 File Offset: 0x0046FCF8
|
|
public static List<T> GGDGJLFOLBJ<T>(List<T> MKEOFCIGBDG, Predicate<T> CGIPLILNILF)
|
|
{
|
|
List<T> list = MKEOFCIGBDG.FindAll(CGIPLILNILF);
|
|
MKEOFCIGBDG.RemoveAll(CGIPLILNILF);
|
|
return list;
|
|
}
|
|
|
|
// Token: 0x0600EE1A RID: 60954 RVA: 0x00471B18 File Offset: 0x0046FD18
|
|
public static T JPCAJLJMJLK<T>(GameObject MKMCHJFIONM) where T : Component
|
|
{
|
|
T component = MKMCHJFIONM.GetComponent<T>();
|
|
if (component)
|
|
{
|
|
return component;
|
|
}
|
|
return MKMCHJFIONM.AddComponent<T>();
|
|
}
|
|
|
|
// Token: 0x0600EE1B RID: 60955 RVA: 0x00471B44 File Offset: 0x0046FD44
|
|
public static void DNNIECHLNOD<T>(List<T> MKEOFCIGBDG, int DMPGHHGCLFK)
|
|
{
|
|
MKEOFCIGBDG[DMPGHHGCLFK] = MKEOFCIGBDG[MKEOFCIGBDG.Count - 1];
|
|
MKEOFCIGBDG.RemoveAt(MKEOFCIGBDG.Count - 1);
|
|
}
|
|
|
|
// Token: 0x0600EE1C RID: 60956 RVA: 0x00471B6C File Offset: 0x0046FD6C
|
|
public static void JNAOHOIHJLC<T, U>(T OKIBEPPDAHI, U AKKPKCJLDDK) where T : MonoBehaviour where U : MonoBehaviour
|
|
{
|
|
OKIBEPPDAHI.gameObject.SetActive(false);
|
|
AKKPKCJLDDK.gameObject.SetActive(true);
|
|
}
|
|
|
|
// Token: 0x0600EE1D RID: 60957 RVA: 0x00471B94 File Offset: 0x0046FD94
|
|
public static void NMEMKBGMAED(Transform DKCNBKFJCLK, int CAEFCGKGGIM, int LOBLHPAKJCD)
|
|
{
|
|
if (DKCNBKFJCLK.gameObject.layer == CAEFCGKGGIM)
|
|
{
|
|
DKCNBKFJCLK.gameObject.layer = LOBLHPAKJCD;
|
|
}
|
|
int childCount = DKCNBKFJCLK.childCount;
|
|
for (int i = 0; i < childCount; i++)
|
|
{
|
|
OFPFHHLNHIC.NMEMKBGMAED(DKCNBKFJCLK.GetChild(i), CAEFCGKGGIM, LOBLHPAKJCD);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600EE1E RID: 60958 RVA: 0x00471BE8 File Offset: 0x0046FDE8
|
|
public static void MBFGIEJCDGO(Vector3 MIKPIBIENPH, Color CNJBINEPFMM, float KLEEKKMJPJK)
|
|
{
|
|
Vector3 vector = MIKPIBIENPH + Vector3.right * KLEEKKMJPJK;
|
|
Vector3 vector2 = MIKPIBIENPH - Vector3.right * KLEEKKMJPJK;
|
|
global::UnityEngine.Debug.DrawLine(vector, vector2, CNJBINEPFMM);
|
|
Vector3 vector3 = MIKPIBIENPH + Vector3.up * KLEEKKMJPJK;
|
|
Vector3 vector4 = MIKPIBIENPH - Vector3.up * KLEEKKMJPJK;
|
|
global::UnityEngine.Debug.DrawLine(vector3, vector4, CNJBINEPFMM);
|
|
Vector3 vector5 = MIKPIBIENPH + Vector3.forward * KLEEKKMJPJK;
|
|
Vector3 vector6 = MIKPIBIENPH - Vector3.forward * KLEEKKMJPJK;
|
|
global::UnityEngine.Debug.DrawLine(vector5, vector6, CNJBINEPFMM);
|
|
}
|
|
|
|
// Token: 0x0600EE1F RID: 60959 RVA: 0x00471C80 File Offset: 0x0046FE80
|
|
public static void GFHBCLGOCGB(Transform LHMELEOKNBJ, bool HEMIGBHDJCE = true)
|
|
{
|
|
LHMELEOKNBJ.localPosition = Vector3.zero;
|
|
LHMELEOKNBJ.localRotation = Quaternion.identity;
|
|
if (HEMIGBHDJCE)
|
|
{
|
|
LHMELEOKNBJ.localScale = new Vector3(1f, 1f, 1f);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600EE20 RID: 60960 RVA: 0x00471CB8 File Offset: 0x0046FEB8
|
|
public static Vector3 MFGMKCNAPHO(Vector3 MKPPJBFGPFJ, Vector3 MPAJLIKNBJM, Vector3 CHCAPBIPCGB)
|
|
{
|
|
Vector3 vector = CHCAPBIPCGB - MKPPJBFGPFJ;
|
|
Vector3 normalized = (MPAJLIKNBJM - MKPPJBFGPFJ).normalized;
|
|
float num = Vector3.Distance(MKPPJBFGPFJ, MPAJLIKNBJM);
|
|
float num2 = Vector3.Dot(normalized, vector);
|
|
if (num2 <= 0f)
|
|
{
|
|
return MKPPJBFGPFJ;
|
|
}
|
|
if (num2 >= num)
|
|
{
|
|
return MPAJLIKNBJM;
|
|
}
|
|
Vector3 vector2 = normalized * num2;
|
|
return MKPPJBFGPFJ + vector2;
|
|
}
|
|
|
|
// Token: 0x0600EE21 RID: 60961 RVA: 0x00471D1C File Offset: 0x0046FF1C
|
|
public static void BABGDGNJIBC(GameObject FMEGPDMNPED, float PLJBPCKADDK, Action JOINLHEALDL, bool MLGEGCEJKGB = false)
|
|
{
|
|
AfterTimer_Component afterTimer_Component = FMEGPDMNPED.AddComponent<AfterTimer_Component>();
|
|
afterTimer_Component.Init(PLJBPCKADDK, JOINLHEALDL, MLGEGCEJKGB);
|
|
}
|
|
|
|
// Token: 0x0600EE22 RID: 60962 RVA: 0x00471D3C File Offset: 0x0046FF3C
|
|
public static void ADBJDCPLFEM(Collider CINAFOGLFIB, string NFAFJOMABOK, SendMessageOptions NDFLNNONDNJ)
|
|
{
|
|
Rigidbody attachedRigidbody = CINAFOGLFIB.attachedRigidbody;
|
|
if (attachedRigidbody && attachedRigidbody.gameObject != CINAFOGLFIB.gameObject)
|
|
{
|
|
attachedRigidbody.SendMessage(NFAFJOMABOK, NDFLNNONDNJ);
|
|
}
|
|
CINAFOGLFIB.SendMessage(NFAFJOMABOK, NDFLNNONDNJ);
|
|
}
|
|
|
|
// Token: 0x0600EE23 RID: 60963 RVA: 0x00471D84 File Offset: 0x0046FF84
|
|
public static void ADBJDCPLFEM(Collider CINAFOGLFIB, string NFAFJOMABOK, object IHFMLNLKIJA, SendMessageOptions NDFLNNONDNJ)
|
|
{
|
|
Rigidbody attachedRigidbody = CINAFOGLFIB.attachedRigidbody;
|
|
if (attachedRigidbody && attachedRigidbody.gameObject != CINAFOGLFIB.gameObject)
|
|
{
|
|
attachedRigidbody.SendMessage(NFAFJOMABOK, IHFMLNLKIJA, NDFLNNONDNJ);
|
|
}
|
|
CINAFOGLFIB.SendMessage(NFAFJOMABOK, IHFMLNLKIJA, NDFLNNONDNJ);
|
|
}
|
|
|
|
// Token: 0x0600EE24 RID: 60964 RVA: 0x00471DCC File Offset: 0x0046FFCC
|
|
public static void JFNHMIKNMPI(GameObject OIBCGACJGBM, GameObject CGGMBKFGABP)
|
|
{
|
|
Collider[] componentsInChildren = OIBCGACJGBM.GetComponentsInChildren<Collider>();
|
|
Collider[] componentsInChildren2 = CGGMBKFGABP.GetComponentsInChildren<Collider>();
|
|
if (componentsInChildren.Length == 0 || componentsInChildren2.Length == 0)
|
|
{
|
|
return;
|
|
}
|
|
foreach (Collider collider in componentsInChildren)
|
|
{
|
|
foreach (Collider collider2 in componentsInChildren2)
|
|
{
|
|
if (collider.enabled && collider2.enabled)
|
|
{
|
|
Physics.IgnoreCollision(collider, collider2, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600EE25 RID: 60965 RVA: 0x00471E5C File Offset: 0x0047005C
|
|
public static IEnumerator ILLNIILJPCJ(IEnumerator APGHHOPCDJE, Action DIOECBJAKPC)
|
|
{
|
|
while (APGHHOPCDJE.MoveNext())
|
|
{
|
|
object obj = APGHHOPCDJE.Current;
|
|
yield return obj;
|
|
}
|
|
DIOECBJAKPC();
|
|
yield break;
|
|
}
|
|
|
|
// Token: 0x0600EE26 RID: 60966 RVA: 0x00471E80 File Offset: 0x00470080
|
|
public static Color JBGCJCBPOOF(this Color HNOPCLEFEIG, float ELFEPDAKCDL)
|
|
{
|
|
HNOPCLEFEIG.a = ELFEPDAKCDL;
|
|
return HNOPCLEFEIG;
|
|
}
|
|
|
|
// Token: 0x0600EE27 RID: 60967 RVA: 0x00471E8C File Offset: 0x0047008C
|
|
public static void NGODENFOFGO()
|
|
{
|
|
Process.GetCurrentProcess().Kill();
|
|
}
|
|
|
|
// Token: 0x0600EE28 RID: 60968 RVA: 0x00471E98 File Offset: 0x00470098
|
|
public static decimal GOHOINDBPML(float NOBAPCOKFIL, int MPOLODEEAJC = 2)
|
|
{
|
|
return Math.Round((decimal)NOBAPCOKFIL, MPOLODEEAJC);
|
|
}
|
|
|
|
// Token: 0x0600EE29 RID: 60969 RVA: 0x00471EA8 File Offset: 0x004700A8
|
|
public static T PFEBENHDBDH<T>(this IEnumerable<T> ECFENKBBJOK)
|
|
{
|
|
if (ECFENKBBJOK == null)
|
|
{
|
|
throw new ArgumentException("Argument cannot be null.", "source");
|
|
}
|
|
int num = ECFENKBBJOK.Count<T>();
|
|
if (num == 0)
|
|
{
|
|
throw new InvalidOperationException("Enumerable must contain at least one element.");
|
|
}
|
|
return ECFENKBBJOK.OrderBy(new Func<T, T>(OFPFHHLNHIC.KJPPOMNPIAJ<T>)).ElementAt(num / 2);
|
|
}
|
|
|
|
// Token: 0x0600EE2A RID: 60970 RVA: 0x00471F00 File Offset: 0x00470100
|
|
public static void ODNPKKKGGNF<T>(this IEnumerable<T> ECFENKBBJOK, Action<T> HJNJOGJJMOF)
|
|
{
|
|
if (ECFENKBBJOK == null)
|
|
{
|
|
throw new ArgumentException("Argument cannot be null.", "source");
|
|
}
|
|
foreach (T t in ECFENKBBJOK)
|
|
{
|
|
HJNJOGJJMOF(t);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600EE2B RID: 60971 RVA: 0x00471F6C File Offset: 0x0047016C
|
|
public static string AGELNFMNHCG(string NALMLHMBHPM)
|
|
{
|
|
bool flag = true;
|
|
while (flag)
|
|
{
|
|
int num = NALMLHMBHPM.IndexOf("\\n");
|
|
if (num == -1)
|
|
{
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
NALMLHMBHPM = NALMLHMBHPM.Remove(num - 1, 3);
|
|
NALMLHMBHPM = NALMLHMBHPM.Insert(num - 1, "\n");
|
|
}
|
|
}
|
|
return NALMLHMBHPM;
|
|
}
|
|
|
|
// Token: 0x0600EE2C RID: 60972 RVA: 0x00471FC0 File Offset: 0x004701C0
|
|
public static float CILLJGIOPMH(NavMeshPath KHKFPPAPDOP)
|
|
{
|
|
if (KHKFPPAPDOP.corners.Length < 2)
|
|
{
|
|
return 0f;
|
|
}
|
|
Vector3 vector = KHKFPPAPDOP.corners[0];
|
|
float num = 0f;
|
|
for (int i = 1; i < KHKFPPAPDOP.corners.Length; i++)
|
|
{
|
|
Vector3 vector2 = KHKFPPAPDOP.corners[i];
|
|
num += Vector3.Distance(vector, vector2);
|
|
vector = vector2;
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x0600EE2D RID: 60973 RVA: 0x00472034 File Offset: 0x00470234
|
|
public static bool MGECMNIFHKG(string LMIIJBLEJFI)
|
|
{
|
|
string[] commandLineArgs = Environment.GetCommandLineArgs();
|
|
for (int i = 0; i < commandLineArgs.Length; i++)
|
|
{
|
|
if (commandLineArgs[i].Equals(LMIIJBLEJFI))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Token: 0x0600EE2E RID: 60974 RVA: 0x0047206C File Offset: 0x0047026C
|
|
public static int ICENBHIOOCB(string LMIIJBLEJFI, int DFKKJBNEBGF)
|
|
{
|
|
string[] commandLineArgs = Environment.GetCommandLineArgs();
|
|
int i = 0;
|
|
while (i < commandLineArgs.Length)
|
|
{
|
|
if (commandLineArgs[i].Equals(LMIIJBLEJFI))
|
|
{
|
|
if (i == commandLineArgs.Length - 1)
|
|
{
|
|
return DFKKJBNEBGF;
|
|
}
|
|
return int.Parse(commandLineArgs[i + 1]);
|
|
}
|
|
else
|
|
{
|
|
i++;
|
|
}
|
|
}
|
|
return DFKKJBNEBGF;
|
|
}
|
|
|
|
// Token: 0x0600EE2F RID: 60975 RVA: 0x004720BC File Offset: 0x004702BC
|
|
public static float ICENBHIOOCB(string LMIIJBLEJFI, float PGBGKLCKHLM)
|
|
{
|
|
string[] commandLineArgs = Environment.GetCommandLineArgs();
|
|
int i = 0;
|
|
while (i < commandLineArgs.Length)
|
|
{
|
|
if (commandLineArgs[i].Equals(LMIIJBLEJFI))
|
|
{
|
|
if (i == commandLineArgs.Length - 1)
|
|
{
|
|
return PGBGKLCKHLM;
|
|
}
|
|
return (float)double.Parse(commandLineArgs[i + 1]);
|
|
}
|
|
else
|
|
{
|
|
i++;
|
|
}
|
|
}
|
|
return PGBGKLCKHLM;
|
|
}
|
|
|
|
// Token: 0x0600EE30 RID: 60976 RVA: 0x0047210C File Offset: 0x0047030C
|
|
public static void ACLHHKNALMJ(GameObject MKMCHJFIONM, bool CAAAFEKOAAF)
|
|
{
|
|
if (MKMCHJFIONM != null)
|
|
{
|
|
MKMCHJFIONM.SetActive(CAAAFEKOAAF);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600EE31 RID: 60977 RVA: 0x00472124 File Offset: 0x00470324
|
|
public static string CBJEHGMDFFP(params string[] EJEOGJJCBOP)
|
|
{
|
|
if (EJEOGJJCBOP.Length == 0)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
string text = EJEOGJJCBOP[0];
|
|
for (int i = 1; i < EJEOGJJCBOP.Length; i++)
|
|
{
|
|
text = Path.Combine(text, EJEOGJJCBOP[i]);
|
|
}
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x0600EE32 RID: 60978 RVA: 0x00472164 File Offset: 0x00470364
|
|
[CompilerGenerated]
|
|
private static T KJPPOMNPIAJ<T>(T ILFEPFCLLFJ)
|
|
{
|
|
return ILFEPFCLLFJ;
|
|
}
|
|
|
|
// Token: 0x04002241 RID: 8769
|
|
public const float OHJDAFEIOPP = 0.3048f;
|
|
|
|
// Token: 0x04002242 RID: 8770
|
|
public const float NEBKNGMDNGC = 30.48f;
|
|
|
|
// Token: 0x04002243 RID: 8771
|
|
public const float AEEGDDIIMHL = 0.0254f;
|
|
|
|
// Token: 0x04002244 RID: 8772
|
|
public const float IEKEGJCCPMA = 2.54f;
|
|
|
|
// Token: 0x04002245 RID: 8773
|
|
public const float EPFLBECNNIB = 3.28084f;
|
|
|
|
// Token: 0x04002246 RID: 8774
|
|
public const float DOGEGAPECEL = 39.3701f;
|
|
|
|
// Token: 0x04002247 RID: 8775
|
|
public const float BGAJBEINGAB = 0.0328084f;
|
|
|
|
// Token: 0x04002248 RID: 8776
|
|
public const float DGFCDGHPCHE = 0.393701f;
|
|
|
|
// Token: 0x04002249 RID: 8777
|
|
public const float KKDEMFNLOHG = 0.621371f;
|
|
|
|
// Token: 0x0400224A RID: 8778
|
|
public const float CIJBGMBDDOO = 1.60934f;
|
|
}
|
|
}
|