niko
1318 lines
41 KiB
C#
1318 lines
41 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Text.RegularExpressions;
|
|
using CodeStage.AntiCheat.ObscuredTypes;
|
|
using ExitGames.Client.Photon;
|
|
using RecNet;
|
|
using RecRoom;
|
|
using RecRoom.Core.AI;
|
|
using UnityEngine;
|
|
|
|
// Token: 0x0200111E RID: 4382
|
|
public static class NNGFEGAEJPG
|
|
{
|
|
// Token: 0x060257B1 RID: 153521 RVA: 0x00A685C4 File Offset: 0x00A667C4
|
|
public static bool DLANDAIDPMK(this string EJDAIKFLCCL)
|
|
{
|
|
Regex regex = new Regex("^[a-zA-Z0-9]+$");
|
|
return regex.IsMatch(EJDAIKFLCCL);
|
|
}
|
|
|
|
// Token: 0x060257B2 RID: 153522 RVA: 0x00A685E4 File Offset: 0x00A667E4
|
|
public static IEnumerator ENKBDIADIDE(AltTextureSet KIJPCHOHGMM, Vector2 BHIKEGFDJEI, int LKBONMAHEJO, Action<AltTextureSet> JELOLDLOAGA)
|
|
{
|
|
NNGFEGAEJPG.BLOEAKCEOCK.GJDMPELAFBA gjdmpelafba = new NNGFEGAEJPG.BLOEAKCEOCK.GJDMPELAFBA();
|
|
gjdmpelafba.MEPGOLIKLOL = this;
|
|
gjdmpelafba.JFPPGIEIMFP = new AltTextureSet();
|
|
yield return NNGFEGAEJPG.LDHGEHBJOLM(KIJPCHOHGMM.MainTexture, BHIKEGFDJEI, LKBONMAHEJO, new Action<Texture2D>(gjdmpelafba.OJKNBNGGBEC));
|
|
yield return NNGFEGAEJPG.LDHGEHBJOLM(KIJPCHOHGMM.AltTexture, BHIKEGFDJEI, LKBONMAHEJO, new Action<Texture2D>(gjdmpelafba.JAFGLCBFOHM));
|
|
if (JELOLDLOAGA != null)
|
|
{
|
|
JELOLDLOAGA(gjdmpelafba.JFPPGIEIMFP);
|
|
}
|
|
yield break;
|
|
}
|
|
|
|
// Token: 0x060257B3 RID: 153523 RVA: 0x00A68614 File Offset: 0x00A66814
|
|
public static IEnumerator LDHGEHBJOLM(Texture2D KIJPCHOHGMM, Vector2 BHIKEGFDJEI, int LKBONMAHEJO, Action<Texture2D> JELOLDLOAGA)
|
|
{
|
|
int width = KIJPCHOHGMM.width;
|
|
int height = KIJPCHOHGMM.height;
|
|
Texture2D texture2D = global::UnityEngine.Object.Instantiate<Texture2D>(KIJPCHOHGMM);
|
|
int num = (int)((float)width - BHIKEGFDJEI.x) / LKBONMAHEJO;
|
|
int num2 = (int)((float)height - BHIKEGFDJEI.y) / LKBONMAHEJO;
|
|
for (int i = 1; i < LKBONMAHEJO - 1; i++)
|
|
{
|
|
PJGGFELBOAL.GAFBBDJNJIK(texture2D, width - i * num, height - i * num2);
|
|
yield return null;
|
|
}
|
|
PJGGFELBOAL.GAFBBDJNJIK(texture2D, (int)BHIKEGFDJEI.x, (int)BHIKEGFDJEI.y);
|
|
JELOLDLOAGA(texture2D);
|
|
yield break;
|
|
}
|
|
|
|
// Token: 0x060257B4 RID: 153524 RVA: 0x00A68644 File Offset: 0x00A66844
|
|
public static int BOBCLCMGBBE(this string EJDAIKFLCCL)
|
|
{
|
|
uint num = 2166136261U;
|
|
for (int i = 0; i < EJDAIKFLCCL.Length; i++)
|
|
{
|
|
num ^= (uint)EJDAIKFLCCL[i];
|
|
num *= 16777619U;
|
|
num = 1664525U * num + 1013904223U;
|
|
}
|
|
return (int)num;
|
|
}
|
|
|
|
// Token: 0x060257B5 RID: 153525 RVA: 0x00A68690 File Offset: 0x00A66890
|
|
public static IEnumerable<T> JFOBNGODCBD<T>(this IEnumerable<T> MICDNLAAKGP, int BGBGAKOFIMJ, int DJLDMFKFEFN)
|
|
{
|
|
if (BGBGAKOFIMJ > 0)
|
|
{
|
|
MICDNLAAKGP = MICDNLAAKGP.Skip(BGBGAKOFIMJ);
|
|
}
|
|
return MICDNLAAKGP.Take(DJLDMFKFEFN);
|
|
}
|
|
|
|
// Token: 0x060257B6 RID: 153526 RVA: 0x00A686AC File Offset: 0x00A668AC
|
|
public static void ADBOBGMIDLE<T>(this Component NCOHNOPAIOG, T NOBAPCOKFIL, string NFAFJOMABOK) where T : class
|
|
{
|
|
if (NOBAPCOKFIL == null)
|
|
{
|
|
throw new NullReferenceException(NFAFJOMABOK);
|
|
}
|
|
}
|
|
|
|
// Token: 0x060257B7 RID: 153527 RVA: 0x00A686C0 File Offset: 0x00A668C0
|
|
public static void HLGPFLHHEEK(this GameObject MKMCHJFIONM, NILFAGNKNMH KCKJODPANGP)
|
|
{
|
|
if (!MKMCHJFIONM.CompareTag("LayerIsLocked"))
|
|
{
|
|
MKMCHJFIONM.layer = (int)KCKJODPANGP;
|
|
}
|
|
IEnumerator enumerator = MKMCHJFIONM.transform.GetEnumerator();
|
|
try
|
|
{
|
|
while (enumerator.MoveNext())
|
|
{
|
|
object obj = enumerator.Current;
|
|
Transform transform = (Transform)obj;
|
|
transform.gameObject.HLGPFLHHEEK(KCKJODPANGP);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
IDisposable disposable;
|
|
if ((disposable = enumerator as IDisposable) != null)
|
|
{
|
|
disposable.Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x060257B8 RID: 153528 RVA: 0x00A68744 File Offset: 0x00A66944
|
|
public static void OCMFPLEAONC(this GameObject MKMCHJFIONM, string KPOAMFIAODF)
|
|
{
|
|
MKMCHJFIONM.tag = KPOAMFIAODF;
|
|
IEnumerator enumerator = MKMCHJFIONM.transform.GetEnumerator();
|
|
try
|
|
{
|
|
while (enumerator.MoveNext())
|
|
{
|
|
object obj = enumerator.Current;
|
|
Transform transform = (Transform)obj;
|
|
transform.gameObject.OCMFPLEAONC(KPOAMFIAODF);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
IDisposable disposable;
|
|
if ((disposable = enumerator as IDisposable) != null)
|
|
{
|
|
disposable.Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x060257B9 RID: 153529 RVA: 0x00A687B8 File Offset: 0x00A669B8
|
|
public static void PHBDKOCCIOG(this GameObject MKMCHJFIONM, bool FDKECOEFNCB)
|
|
{
|
|
MKMCHJFIONM.isStatic = FDKECOEFNCB;
|
|
IEnumerator enumerator = MKMCHJFIONM.transform.GetEnumerator();
|
|
try
|
|
{
|
|
while (enumerator.MoveNext())
|
|
{
|
|
object obj = enumerator.Current;
|
|
Transform transform = (Transform)obj;
|
|
transform.gameObject.PHBDKOCCIOG(FDKECOEFNCB);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
IDisposable disposable;
|
|
if ((disposable = enumerator as IDisposable) != null)
|
|
{
|
|
disposable.Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x060257BA RID: 153530 RVA: 0x00A6882C File Offset: 0x00A66A2C
|
|
public static void LLOHMKAPBDK(this GameObject MKMCHJFIONM, NILFAGNKNMH JKKOJPNLIPC, NILFAGNKNMH FMAEBBIKIKJ)
|
|
{
|
|
if (MKMCHJFIONM.layer == (int)JKKOJPNLIPC && !MKMCHJFIONM.CompareTag("LayerIsLocked"))
|
|
{
|
|
MKMCHJFIONM.layer = (int)FMAEBBIKIKJ;
|
|
}
|
|
IEnumerator enumerator = MKMCHJFIONM.transform.GetEnumerator();
|
|
try
|
|
{
|
|
while (enumerator.MoveNext())
|
|
{
|
|
object obj = enumerator.Current;
|
|
Transform transform = (Transform)obj;
|
|
transform.gameObject.LLOHMKAPBDK(JKKOJPNLIPC, FMAEBBIKIKJ);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
IDisposable disposable;
|
|
if ((disposable = enumerator as IDisposable) != null)
|
|
{
|
|
disposable.Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x060257BB RID: 153531 RVA: 0x00A688BC File Offset: 0x00A66ABC
|
|
public static bool OPJBDKJDLFF(this GameObject MKMCHJFIONM, LCIGHPPLKCA FIHIEFMGDCI)
|
|
{
|
|
return NNGFEGAEJPG.CCAOLOGMGJF(MKMCHJFIONM.layer, (int)FIHIEFMGDCI);
|
|
}
|
|
|
|
// Token: 0x060257BC RID: 153532 RVA: 0x00A688CC File Offset: 0x00A66ACC
|
|
public static bool CCAOLOGMGJF(int NOBAPCOKFIL, int HOBKFDJFIEM)
|
|
{
|
|
return ((1 << NOBAPCOKFIL) & HOBKFDJFIEM) != 0;
|
|
}
|
|
|
|
// Token: 0x060257BD RID: 153533 RVA: 0x00A688DC File Offset: 0x00A66ADC
|
|
public static Color FNNAJBFGBAI(this Color HNOPCLEFEIG, float ELFEPDAKCDL)
|
|
{
|
|
return new Color(HNOPCLEFEIG.r, HNOPCLEFEIG.g, HNOPCLEFEIG.b, ELFEPDAKCDL);
|
|
}
|
|
|
|
// Token: 0x060257BE RID: 153534 RVA: 0x00A688FC File Offset: 0x00A66AFC
|
|
public static int NGJMDEALIKA(this NILFAGNKNMH KCKJODPANGP)
|
|
{
|
|
return 1 << (int)KCKJODPANGP;
|
|
}
|
|
|
|
// Token: 0x060257BF RID: 153535 RVA: 0x00A68904 File Offset: 0x00A66B04
|
|
public static void INDKEOIJENP(this Camera CENLMCHLIKM, NILFAGNKNMH KCKJODPANGP)
|
|
{
|
|
CENLMCHLIKM.KBNFBFGBAMM(KCKJODPANGP.NGJMDEALIKA());
|
|
}
|
|
|
|
// Token: 0x060257C0 RID: 153536 RVA: 0x00A68914 File Offset: 0x00A66B14
|
|
public static void ABNNOGDFFCP(this Camera CENLMCHLIKM, NILFAGNKNMH KCKJODPANGP)
|
|
{
|
|
CENLMCHLIKM.AOAHMEHDHKC(KCKJODPANGP.NGJMDEALIKA());
|
|
}
|
|
|
|
// Token: 0x060257C1 RID: 153537 RVA: 0x00A68924 File Offset: 0x00A66B24
|
|
public static void KBNFBFGBAMM(this Camera CENLMCHLIKM, int FIHIEFMGDCI)
|
|
{
|
|
CENLMCHLIKM.cullingMask &= ~FIHIEFMGDCI;
|
|
}
|
|
|
|
// Token: 0x060257C2 RID: 153538 RVA: 0x00A68938 File Offset: 0x00A66B38
|
|
public static void AOAHMEHDHKC(this Camera CENLMCHLIKM, int FIHIEFMGDCI)
|
|
{
|
|
CENLMCHLIKM.cullingMask |= FIHIEFMGDCI;
|
|
}
|
|
|
|
// Token: 0x060257C3 RID: 153539 RVA: 0x00A68948 File Offset: 0x00A66B48
|
|
public static AnimationCurve GMNHOPPHOGH()
|
|
{
|
|
return AnimationCurve.Linear(0f, 0f, 1f, 1f);
|
|
}
|
|
|
|
// Token: 0x060257C4 RID: 153540 RVA: 0x00A68964 File Offset: 0x00A66B64
|
|
public static IEnumerator MOKPENMLOLP(this Animator FIOLBHFJENN, int ODDJBELKCAD)
|
|
{
|
|
float length = FIOLBHFJENN.GetCurrentAnimatorStateInfo(ODDJBELKCAD).length;
|
|
float num = 0f;
|
|
while (num < length)
|
|
{
|
|
num += Time.deltaTime;
|
|
yield return null;
|
|
}
|
|
yield break;
|
|
}
|
|
|
|
// Token: 0x060257C5 RID: 153541 RVA: 0x00A68988 File Offset: 0x00A66B88
|
|
public static void MBIHFMAMIBG(this Rigidbody EAEAFPMBPNL)
|
|
{
|
|
EAEAFPMBPNL.velocity = Vector3.zero;
|
|
EAEAFPMBPNL.angularVelocity = Vector3.zero;
|
|
}
|
|
|
|
// Token: 0x060257C6 RID: 153542 RVA: 0x00A689A0 File Offset: 0x00A66BA0
|
|
public static Vector3 POMGOGCFHKI(Vector3 ECFENKBBJOK, Plane OLNDEBNCLIJ)
|
|
{
|
|
return ECFENKBBJOK - Vector3.Dot(ECFENKBBJOK, OLNDEBNCLIJ.normal) * OLNDEBNCLIJ.normal;
|
|
}
|
|
|
|
// Token: 0x060257C7 RID: 153543 RVA: 0x00A689C4 File Offset: 0x00A66BC4
|
|
public static Quaternion IGNMFLLDHLN(Quaternion FLKMJFAOABP, Quaternion MABKDDJKKPL)
|
|
{
|
|
return MABKDDJKKPL * Quaternion.Inverse(FLKMJFAOABP);
|
|
}
|
|
|
|
// Token: 0x060257C8 RID: 153544 RVA: 0x00A689D4 File Offset: 0x00A66BD4
|
|
public static Quaternion HOIKNHDPMLN(Vector3 CCHAEPGJJLI)
|
|
{
|
|
return Quaternion.AngleAxis(CCHAEPGJJLI.magnitude * 57.29578f, CCHAEPGJJLI.normalized);
|
|
}
|
|
|
|
// Token: 0x060257C9 RID: 153545 RVA: 0x00A689F0 File Offset: 0x00A66BF0
|
|
public static Vector3 PGPNGNDCJKL(Quaternion FLKMJFAOABP, Quaternion MABKDDJKKPL)
|
|
{
|
|
float num;
|
|
Vector3 vector;
|
|
NNGFEGAEJPG.IGNMFLLDHLN(FLKMJFAOABP, MABKDDJKKPL).ToAngleAxis(out num, out vector);
|
|
if (num > 180f)
|
|
{
|
|
num -= 360f;
|
|
}
|
|
return num * vector * 0.017453292f;
|
|
}
|
|
|
|
// Token: 0x060257CA RID: 153546 RVA: 0x00A68A34 File Offset: 0x00A66C34
|
|
public static Quaternion MCKNNGGGBDG(this Transform DKCNBKFJCLK, Quaternion IJGPPOIJDKO)
|
|
{
|
|
return Quaternion.Inverse(DKCNBKFJCLK.rotation) * IJGPPOIJDKO;
|
|
}
|
|
|
|
// Token: 0x060257CB RID: 153547 RVA: 0x00A68A48 File Offset: 0x00A66C48
|
|
public static Quaternion PAFJLHMDIMO(this Transform DKCNBKFJCLK, Quaternion IJGPPOIJDKO)
|
|
{
|
|
return DKCNBKFJCLK.rotation * IJGPPOIJDKO;
|
|
}
|
|
|
|
// Token: 0x060257CC RID: 153548 RVA: 0x00A68A58 File Offset: 0x00A66C58
|
|
public static Transform OJKEFDBGNAM(this Transform DKCNBKFJCLK, string EKKMPHMGCLB)
|
|
{
|
|
for (int i = 0; i < DKCNBKFJCLK.childCount; i++)
|
|
{
|
|
Transform child = DKCNBKFJCLK.GetChild(i);
|
|
if (child != null)
|
|
{
|
|
if (child.name == EKKMPHMGCLB)
|
|
{
|
|
return child;
|
|
}
|
|
Transform transform = child.OJKEFDBGNAM(EKKMPHMGCLB);
|
|
if (transform != null)
|
|
{
|
|
return transform;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060257CD RID: 153549 RVA: 0x00A68ABC File Offset: 0x00A66CBC
|
|
public static bool PIPKFEDEJCM(this Transform DKCNBKFJCLK, Transform EAMJGJFJPNL)
|
|
{
|
|
for (;;)
|
|
{
|
|
DKCNBKFJCLK = DKCNBKFJCLK.parent;
|
|
if (DKCNBKFJCLK == EAMJGJFJPNL)
|
|
{
|
|
break;
|
|
}
|
|
if (!(DKCNBKFJCLK != null))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x060257CE RID: 153550 RVA: 0x00A68AE4 File Offset: 0x00A66CE4
|
|
public static bool OGGIHOOBPJF(this Transform DKCNBKFJCLK)
|
|
{
|
|
Vector3 lossyScale = DKCNBKFJCLK.lossyScale;
|
|
float num = Mathf.Sign(DKCNBKFJCLK.lossyScale.x * DKCNBKFJCLK.lossyScale.y * DKCNBKFJCLK.lossyScale.z);
|
|
return num < 0f;
|
|
}
|
|
|
|
// Token: 0x060257CF RID: 153551 RVA: 0x00A68B34 File Offset: 0x00A66D34
|
|
public static Quaternion PAFJLHMDIMO(this Quaternion CNGOCFABIFK, Quaternion IJGPPOIJDKO)
|
|
{
|
|
return CNGOCFABIFK * IJGPPOIJDKO;
|
|
}
|
|
|
|
// Token: 0x060257D0 RID: 153552 RVA: 0x00A68B40 File Offset: 0x00A66D40
|
|
public static Vector3 HMMMACNKENN(this Quaternion OCDHMDJIKGG)
|
|
{
|
|
float num;
|
|
Vector3 vector;
|
|
OCDHMDJIKGG.ToAngleAxis(out num, out vector);
|
|
if (num > 180f)
|
|
{
|
|
num -= 360f;
|
|
}
|
|
return num * vector * 0.017453292f;
|
|
}
|
|
|
|
// Token: 0x060257D1 RID: 153553 RVA: 0x00A68B7C File Offset: 0x00A66D7C
|
|
public static void NIACFDCMGLG<T>(this global::PLOPPLAOICD FIIFPLCNFHJ, string GPGKLIKBKDO, T HOEHLPOCEBP, T CHCNPBDOPHH)
|
|
{
|
|
if (FIIFPLCNFHJ != null)
|
|
{
|
|
FIIFPLCNFHJ.NIACFDCMGLG(new ExitGames.Client.Photon.Hashtable { { GPGKLIKBKDO, HOEHLPOCEBP } }, new ExitGames.Client.Photon.Hashtable { { GPGKLIKBKDO, CHCNPBDOPHH } }, false);
|
|
}
|
|
}
|
|
|
|
// Token: 0x060257D2 RID: 153554 RVA: 0x00A68BC0 File Offset: 0x00A66DC0
|
|
public static void NIACFDCMGLG<T>(this global::PLOPPLAOICD FIIFPLCNFHJ, string GPGKLIKBKDO, T HOEHLPOCEBP)
|
|
{
|
|
if (FIIFPLCNFHJ != null)
|
|
{
|
|
FIIFPLCNFHJ.NIACFDCMGLG(new ExitGames.Client.Photon.Hashtable { { GPGKLIKBKDO, HOEHLPOCEBP } }, null, false);
|
|
}
|
|
}
|
|
|
|
// Token: 0x060257D3 RID: 153555 RVA: 0x00A68BF0 File Offset: 0x00A66DF0
|
|
public static string MHALLOPCFCB(this LNJFBGIBLHA JEFGMHBLLKI, string GPGKLIKBKDO)
|
|
{
|
|
if (JEFGMHBLLKI != null && JEFGMHBLLKI.BAHICKLKKHB.ContainsKey(GPGKLIKBKDO))
|
|
{
|
|
return JEFGMHBLLKI.BAHICKLKKHB[GPGKLIKBKDO] as string;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060257D4 RID: 153556 RVA: 0x00A68C1C File Offset: 0x00A66E1C
|
|
public static void NIACFDCMGLG<T>(this LNJFBGIBLHA JEFGMHBLLKI, string GPGKLIKBKDO, T HOEHLPOCEBP, T CHCNPBDOPHH)
|
|
{
|
|
if (JEFGMHBLLKI != null)
|
|
{
|
|
JEFGMHBLLKI.NIACFDCMGLG(new ExitGames.Client.Photon.Hashtable { { GPGKLIKBKDO, HOEHLPOCEBP } }, new ExitGames.Client.Photon.Hashtable { { GPGKLIKBKDO, CHCNPBDOPHH } }, false);
|
|
}
|
|
}
|
|
|
|
// Token: 0x060257D5 RID: 153557 RVA: 0x00A68C60 File Offset: 0x00A66E60
|
|
public static void NIACFDCMGLG<T>(this LNJFBGIBLHA JEFGMHBLLKI, string GPGKLIKBKDO, T HOEHLPOCEBP)
|
|
{
|
|
if (JEFGMHBLLKI != null)
|
|
{
|
|
JEFGMHBLLKI.NIACFDCMGLG(new ExitGames.Client.Photon.Hashtable { { GPGKLIKBKDO, HOEHLPOCEBP } }, null, false);
|
|
}
|
|
}
|
|
|
|
// Token: 0x060257D6 RID: 153558 RVA: 0x00A68C90 File Offset: 0x00A66E90
|
|
public static void BBGLKFCJAID(this LNJFBGIBLHA JEFGMHBLLKI, string GPGKLIKBKDO)
|
|
{
|
|
if (JEFGMHBLLKI != null)
|
|
{
|
|
JEFGMHBLLKI.NIACFDCMGLG(new ExitGames.Client.Photon.Hashtable { { GPGKLIKBKDO, null } }, null, false);
|
|
}
|
|
}
|
|
|
|
// Token: 0x060257D7 RID: 153559 RVA: 0x00A68CBC File Offset: 0x00A66EBC
|
|
public static void BBGLKFCJAID(this global::PLOPPLAOICD FIIFPLCNFHJ, string GPGKLIKBKDO)
|
|
{
|
|
FIIFPLCNFHJ.NIACFDCMGLG(new ExitGames.Client.Photon.Hashtable { { GPGKLIKBKDO, null } }, null, false);
|
|
}
|
|
|
|
// Token: 0x060257D8 RID: 153560 RVA: 0x00A68CE0 File Offset: 0x00A66EE0
|
|
public static Player JHJGDFHNBLO(this LNJFBGIBLHA GGMIDKPEEME)
|
|
{
|
|
return (GGMIDKPEEME == null) ? null : (GGMIDKPEEME.NIELBMEGFAH as Player);
|
|
}
|
|
|
|
// Token: 0x060257D9 RID: 153561 RVA: 0x00A68CFC File Offset: 0x00A66EFC
|
|
public static T HIJBMFKBBFN<T>(this List<T> MKEOFCIGBDG)
|
|
{
|
|
if (MKEOFCIGBDG.Count > 0)
|
|
{
|
|
return MKEOFCIGBDG[global::UnityEngine.Random.Range(0, MKEOFCIGBDG.Count - 1)];
|
|
}
|
|
return default(T);
|
|
}
|
|
|
|
// Token: 0x060257DA RID: 153562 RVA: 0x00A68D34 File Offset: 0x00A66F34
|
|
public static void DLPNNHIDILF<T>(this List<T> MKEOFCIGBDG, T OKKMGANCMGB)
|
|
{
|
|
if (!MKEOFCIGBDG.Contains(OKKMGANCMGB))
|
|
{
|
|
MKEOFCIGBDG.Add(OKKMGANCMGB);
|
|
}
|
|
}
|
|
|
|
// Token: 0x060257DB RID: 153563 RVA: 0x00A68D4C File Offset: 0x00A66F4C
|
|
public static T HIJBMFKBBFN<T>(this T[] MKEOFCIGBDG)
|
|
{
|
|
if (MKEOFCIGBDG.Length > 0)
|
|
{
|
|
return MKEOFCIGBDG[global::UnityEngine.Random.Range(0, MKEOFCIGBDG.Length - 1)];
|
|
}
|
|
return default(T);
|
|
}
|
|
|
|
// Token: 0x060257DC RID: 153564 RVA: 0x00A68D80 File Offset: 0x00A66F80
|
|
public static void JCJAECDEILG<T>(this List<T> JDOHGLGFDEO) where T : class
|
|
{
|
|
JDOHGLGFDEO.RemoveAll(new Predicate<T>(NNGFEGAEJPG.AEKHOOMLIKM<T>));
|
|
}
|
|
|
|
// Token: 0x060257DD RID: 153565 RVA: 0x00A68D98 File Offset: 0x00A66F98
|
|
public static void LOHNNOLPNCD<T1, T2>(this Dictionary<T1, T2> KIJPCHOHGMM, ref Dictionary<T1, T2> DJCNCPKHANK)
|
|
{
|
|
foreach (KeyValuePair<T1, T2> keyValuePair in KIJPCHOHGMM)
|
|
{
|
|
if (!DJCNCPKHANK.ContainsKey(keyValuePair.Key))
|
|
{
|
|
DJCNCPKHANK.Add(keyValuePair.Key, keyValuePair.Value);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x060257DE RID: 153566 RVA: 0x00A68E10 File Offset: 0x00A67010
|
|
public static float CDGLLOMEAFJ(this PhysicMaterial EHINGKOJOFN, PhysicMaterial EMMFHBJONFM)
|
|
{
|
|
if (EHINGKOJOFN == null && EMMFHBJONFM == null)
|
|
{
|
|
return 0f;
|
|
}
|
|
if (EMMFHBJONFM == null)
|
|
{
|
|
return EHINGKOJOFN.staticFriction;
|
|
}
|
|
if (EHINGKOJOFN == null)
|
|
{
|
|
return EMMFHBJONFM.staticFriction;
|
|
}
|
|
return NNGFEGAEJPG.MGCJFNPJJNC(EHINGKOJOFN.staticFriction, EMMFHBJONFM.staticFriction, EHINGKOJOFN.frictionCombine);
|
|
}
|
|
|
|
// Token: 0x060257DF RID: 153567 RVA: 0x00A68E78 File Offset: 0x00A67078
|
|
public static float DNHJPDHHKJI(this PhysicMaterial EHINGKOJOFN, PhysicMaterial EMMFHBJONFM)
|
|
{
|
|
if (EHINGKOJOFN == null && EMMFHBJONFM == null)
|
|
{
|
|
return 0f;
|
|
}
|
|
if (EMMFHBJONFM == null)
|
|
{
|
|
return EHINGKOJOFN.dynamicFriction;
|
|
}
|
|
if (EHINGKOJOFN == null)
|
|
{
|
|
return EMMFHBJONFM.dynamicFriction;
|
|
}
|
|
return NNGFEGAEJPG.MGCJFNPJJNC(EHINGKOJOFN.dynamicFriction, EMMFHBJONFM.dynamicFriction, EHINGKOJOFN.frictionCombine);
|
|
}
|
|
|
|
// Token: 0x060257E0 RID: 153568 RVA: 0x00A68EE0 File Offset: 0x00A670E0
|
|
public static float AGAGLEIJFEF(this Collider NEKKGHFALPO, Collider OIDJDLBOIAD)
|
|
{
|
|
PhysicMaterial physicMaterial = ((!(NEKKGHFALPO == null)) ? NEKKGHFALPO.material : null);
|
|
PhysicMaterial physicMaterial2 = ((!(OIDJDLBOIAD == null)) ? OIDJDLBOIAD.material : null);
|
|
return physicMaterial.AGAGLEIJFEF(physicMaterial2);
|
|
}
|
|
|
|
// Token: 0x060257E1 RID: 153569 RVA: 0x00A68F28 File Offset: 0x00A67128
|
|
public static float AGAGLEIJFEF(this PhysicMaterial EHINGKOJOFN, PhysicMaterial EMMFHBJONFM)
|
|
{
|
|
if (EHINGKOJOFN == null && EMMFHBJONFM == null)
|
|
{
|
|
return 1f;
|
|
}
|
|
if (EMMFHBJONFM == null)
|
|
{
|
|
return EHINGKOJOFN.bounciness;
|
|
}
|
|
if (EHINGKOJOFN == null)
|
|
{
|
|
return EMMFHBJONFM.bounciness;
|
|
}
|
|
return NNGFEGAEJPG.MGCJFNPJJNC(EHINGKOJOFN.bounciness, EMMFHBJONFM.bounciness, EHINGKOJOFN.bounceCombine);
|
|
}
|
|
|
|
// Token: 0x060257E2 RID: 153570 RVA: 0x00A68F90 File Offset: 0x00A67190
|
|
private static float MGCJFNPJJNC(float DPIIIAGCMLK, float BDKNHBMMGPK, PhysicMaterialCombine BIAMHGOBDGB)
|
|
{
|
|
float num = 0f;
|
|
switch (BIAMHGOBDGB)
|
|
{
|
|
case PhysicMaterialCombine.Average:
|
|
num = (DPIIIAGCMLK + BDKNHBMMGPK) / 2f;
|
|
break;
|
|
case PhysicMaterialCombine.Multiply:
|
|
num = DPIIIAGCMLK * BDKNHBMMGPK;
|
|
break;
|
|
case PhysicMaterialCombine.Minimum:
|
|
num = Mathf.Min(DPIIIAGCMLK, BDKNHBMMGPK);
|
|
break;
|
|
case PhysicMaterialCombine.Maximum:
|
|
num = Mathf.Max(DPIIIAGCMLK, BDKNHBMMGPK);
|
|
break;
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x060257E3 RID: 153571 RVA: 0x00A68FF4 File Offset: 0x00A671F4
|
|
public static void NAGFLOBIOCK(this RaycastHit[] AJDJKDELMKL, int CEFMEFIIMIC)
|
|
{
|
|
if (CEFMEFIIMIC > 1)
|
|
{
|
|
float[] array = new float[CEFMEFIIMIC];
|
|
for (int i = 0; i < CEFMEFIIMIC; i++)
|
|
{
|
|
array[i] = (AJDJKDELMKL[i].collider.transform.position - AJDJKDELMKL[i].point).sqrMagnitude;
|
|
}
|
|
for (int j = 1; j < CEFMEFIIMIC; j++)
|
|
{
|
|
int num = j;
|
|
while (num > 0 && array[num] < array[num - 1])
|
|
{
|
|
AJDJKDELMKL.GBJPIAHGKGK(num, j);
|
|
array.GBJPIAHGKGK(num, j);
|
|
num--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x060257E4 RID: 153572 RVA: 0x00A69098 File Offset: 0x00A67298
|
|
public static void GBJPIAHGKGK<T>(this T[] GDLLJBOEGNF, int CIMNKHDEFOH, int OJAJLHFPAIB)
|
|
{
|
|
T t = GDLLJBOEGNF[CIMNKHDEFOH];
|
|
GDLLJBOEGNF[CIMNKHDEFOH] = GDLLJBOEGNF[OJAJLHFPAIB];
|
|
GDLLJBOEGNF[OJAJLHFPAIB] = t;
|
|
}
|
|
|
|
// Token: 0x060257E5 RID: 153573 RVA: 0x00A690C4 File Offset: 0x00A672C4
|
|
public static Tool OBFMDIEKHAN(this Collision PDCJEBJGFNF)
|
|
{
|
|
ToolCollider toolCollider = null;
|
|
return PDCJEBJGFNF.collider.OBFMDIEKHAN(out toolCollider);
|
|
}
|
|
|
|
// Token: 0x060257E6 RID: 153574 RVA: 0x00A690E0 File Offset: 0x00A672E0
|
|
public static Tool OBFMDIEKHAN(this Collider CINAFOGLFIB)
|
|
{
|
|
ToolCollider toolCollider = null;
|
|
return CINAFOGLFIB.OBFMDIEKHAN(out toolCollider);
|
|
}
|
|
|
|
// Token: 0x060257E7 RID: 153575 RVA: 0x00A690F8 File Offset: 0x00A672F8
|
|
public static Tool OBFMDIEKHAN(this Collider CINAFOGLFIB, out ToolCollider DDEFNDJJPPK)
|
|
{
|
|
DDEFNDJJPPK = CINAFOGLFIB.GetComponent<ToolCollider>();
|
|
if (DDEFNDJJPPK == null)
|
|
{
|
|
return null;
|
|
}
|
|
return DDEFNDJJPPK.Tool;
|
|
}
|
|
|
|
// Token: 0x060257E8 RID: 153576 RVA: 0x00A69118 File Offset: 0x00A67318
|
|
public static Player KAPJACICAEC(this Collision PDCJEBJGFNF, out Player.HDOICGIKKAO ACAHIJEJKLC)
|
|
{
|
|
return PDCJEBJGFNF.collider.KAPJACICAEC(out ACAHIJEJKLC);
|
|
}
|
|
|
|
// Token: 0x060257E9 RID: 153577 RVA: 0x00A69128 File Offset: 0x00A67328
|
|
public static Player KAPJACICAEC(this Collider CINAFOGLFIB, out Player.HDOICGIKKAO ACAHIJEJKLC)
|
|
{
|
|
PlayerCollider component = CINAFOGLFIB.GetComponent<PlayerCollider>();
|
|
if (component == null)
|
|
{
|
|
ACAHIJEJKLC = Player.HDOICGIKKAO.None;
|
|
return null;
|
|
}
|
|
ACAHIJEJKLC = component.HDOICGIKKAO;
|
|
return component.ThisPlayer;
|
|
}
|
|
|
|
// Token: 0x060257EA RID: 153578 RVA: 0x00A6915C File Offset: 0x00A6735C
|
|
public static PlayerHand HLBBAALDKLM(this Collider CINAFOGLFIB)
|
|
{
|
|
PlayerHand playerHand = null;
|
|
Player.HDOICGIKKAO hdoicgikkao;
|
|
Player player = CINAFOGLFIB.KAPJACICAEC(out hdoicgikkao);
|
|
if (player != null && hdoicgikkao.PLKCJINIPMP())
|
|
{
|
|
playerHand = player.GetHand(hdoicgikkao);
|
|
}
|
|
return playerHand;
|
|
}
|
|
|
|
// Token: 0x060257EB RID: 153579 RVA: 0x00A69194 File Offset: 0x00A67394
|
|
public static Enemy AICMDAMIEBP(this Collision PDCJEBJGFNF, out MHEBDODJGOA OMPOICMBDBP)
|
|
{
|
|
return PDCJEBJGFNF.collider.AICMDAMIEBP(out OMPOICMBDBP);
|
|
}
|
|
|
|
// Token: 0x060257EC RID: 153580 RVA: 0x00A691A4 File Offset: 0x00A673A4
|
|
public static Enemy AICMDAMIEBP(this Collider CINAFOGLFIB, out MHEBDODJGOA OMPOICMBDBP)
|
|
{
|
|
EnemyCollider component = CINAFOGLFIB.GetComponent<EnemyCollider>();
|
|
if (component == null)
|
|
{
|
|
OMPOICMBDBP = MHEBDODJGOA.NORMAL;
|
|
return null;
|
|
}
|
|
OMPOICMBDBP = component.EPOLDOJECMI;
|
|
return component.ThisEnemy;
|
|
}
|
|
|
|
// Token: 0x060257ED RID: 153581 RVA: 0x00A691D8 File Offset: 0x00A673D8
|
|
public static Trap JFFLOIPFGPE(this Collision PDCJEBJGFNF)
|
|
{
|
|
return PDCJEBJGFNF.collider.JFFLOIPFGPE();
|
|
}
|
|
|
|
// Token: 0x060257EE RID: 153582 RVA: 0x00A691E8 File Offset: 0x00A673E8
|
|
public static Trap JFFLOIPFGPE(this Collider CINAFOGLFIB)
|
|
{
|
|
TrapCollider component = CINAFOGLFIB.GetComponent<TrapCollider>();
|
|
return (!(component != null)) ? null : component.ThisTrap;
|
|
}
|
|
|
|
// Token: 0x060257EF RID: 153583 RVA: 0x00A69214 File Offset: 0x00A67414
|
|
public static PhotonView DNGLEMHICPL(this Collision PDCJEBJGFNF)
|
|
{
|
|
return PDCJEBJGFNF.collider.DNGLEMHICPL();
|
|
}
|
|
|
|
// Token: 0x060257F0 RID: 153584 RVA: 0x00A69224 File Offset: 0x00A67424
|
|
public static PhotonView DNGLEMHICPL(this Collider CINAFOGLFIB)
|
|
{
|
|
return CINAFOGLFIB.gameObject.GetComponentInParent<PhotonView>();
|
|
}
|
|
|
|
// Token: 0x060257F1 RID: 153585 RVA: 0x00A69234 File Offset: 0x00A67434
|
|
public static Killzone ACCPNLDEPFO(this Collider CINAFOGLFIB)
|
|
{
|
|
return CINAFOGLFIB.gameObject.GetComponent<Killzone>();
|
|
}
|
|
|
|
// Token: 0x060257F2 RID: 153586 RVA: 0x00A69244 File Offset: 0x00A67444
|
|
public static int BILCNCNIFDJ(this BoxCollider CINAFOGLFIB, int FIHIEFMGDCI, QueryTriggerInteraction NCNLFKOECLJ, Collider[] JPOEPEOCGHB)
|
|
{
|
|
Vector3 vector = CINAFOGLFIB.transform.TransformPoint(CINAFOGLFIB.center);
|
|
Quaternion rotation = CINAFOGLFIB.transform.rotation;
|
|
Vector3 vector2 = CINAFOGLFIB.size / 2f;
|
|
return Physics.OverlapBoxNonAlloc(vector, vector2, JPOEPEOCGHB, rotation, FIHIEFMGDCI, NCNLFKOECLJ);
|
|
}
|
|
|
|
// Token: 0x060257F3 RID: 153587 RVA: 0x00A6928C File Offset: 0x00A6748C
|
|
public static bool HLMMPOAOLAP(this BoxCollider CINAFOGLFIB, int FIHIEFMGDCI, QueryTriggerInteraction NCNLFKOECLJ)
|
|
{
|
|
Vector3 vector = CINAFOGLFIB.transform.TransformPoint(CINAFOGLFIB.center);
|
|
Quaternion rotation = CINAFOGLFIB.transform.rotation;
|
|
Vector3 vector2 = CINAFOGLFIB.size / 2f;
|
|
return Physics.CheckBox(vector, vector2, rotation, FIHIEFMGDCI, NCNLFKOECLJ);
|
|
}
|
|
|
|
// Token: 0x060257F4 RID: 153588 RVA: 0x00A692D4 File Offset: 0x00A674D4
|
|
public static bool FOHLEHDCHCA(this BoxCollider ANOPKHFFLNF, Vector3 FHFHOMKFHCI)
|
|
{
|
|
FHFHOMKFHCI = ANOPKHFFLNF.transform.InverseTransformPoint(FHFHOMKFHCI) - ANOPKHFFLNF.center;
|
|
float num = ANOPKHFFLNF.size.x * 0.5f;
|
|
float num2 = ANOPKHFFLNF.size.y * 0.5f;
|
|
float num3 = ANOPKHFFLNF.size.z * 0.5f;
|
|
return FHFHOMKFHCI.x < num && FHFHOMKFHCI.x > -num && FHFHOMKFHCI.y < num2 && FHFHOMKFHCI.y > -num2 && FHFHOMKFHCI.z < num3 && FHFHOMKFHCI.z > -num3;
|
|
}
|
|
|
|
// Token: 0x060257F5 RID: 153589 RVA: 0x00A69394 File Offset: 0x00A67594
|
|
public static bool HLMMPOAOLAP(this CapsuleCollider CINAFOGLFIB, int FIHIEFMGDCI, QueryTriggerInteraction NCNLFKOECLJ)
|
|
{
|
|
Vector3 vector = Vector3.right;
|
|
if (CINAFOGLFIB.direction == 1)
|
|
{
|
|
vector = Vector3.up;
|
|
}
|
|
else if (CINAFOGLFIB.direction == 2)
|
|
{
|
|
vector = Vector3.forward;
|
|
}
|
|
Vector3 normalized = CINAFOGLFIB.transform.TransformDirection(vector).normalized;
|
|
float num = Mathf.Max(0f, CINAFOGLFIB.height - 2f * CINAFOGLFIB.radius);
|
|
Vector3 vector2 = CINAFOGLFIB.transform.TransformPoint(CINAFOGLFIB.center);
|
|
return Physics.CheckCapsule(vector2 - normalized * num, vector2 + normalized * num, CINAFOGLFIB.radius, FIHIEFMGDCI, NCNLFKOECLJ);
|
|
}
|
|
|
|
// Token: 0x060257F6 RID: 153590 RVA: 0x00A69440 File Offset: 0x00A67640
|
|
public static Quaternion AHDFJMAJNBC(Quaternion LEAIIPBJMLG, Quaternion MMEBLCBANIL, ref Vector3 GALFDIHLNGC, float CJEDMBMEDML)
|
|
{
|
|
Vector3 eulerAngles = LEAIIPBJMLG.eulerAngles;
|
|
Vector3 eulerAngles2 = MMEBLCBANIL.eulerAngles;
|
|
eulerAngles.x = Mathf.SmoothDampAngle(eulerAngles.x, eulerAngles2.x, ref GALFDIHLNGC.x, CJEDMBMEDML);
|
|
eulerAngles.y = Mathf.SmoothDampAngle(eulerAngles.y, eulerAngles2.y, ref GALFDIHLNGC.y, CJEDMBMEDML);
|
|
eulerAngles.z = Mathf.SmoothDampAngle(eulerAngles.z, eulerAngles2.z, ref GALFDIHLNGC.z, CJEDMBMEDML);
|
|
return Quaternion.Euler(eulerAngles);
|
|
}
|
|
|
|
// Token: 0x060257F7 RID: 153591 RVA: 0x00A694C8 File Offset: 0x00A676C8
|
|
public static T2[] GEFFEAHKFHB<T1, T2>(this Dictionary<T1, T2>.ValueCollection MNAHFGFIDHN)
|
|
{
|
|
if (MNAHFGFIDHN.Count > 0)
|
|
{
|
|
T2[] array = new T2[MNAHFGFIDHN.Count];
|
|
MNAHFGFIDHN.CopyTo(array, 0);
|
|
return array;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060257F8 RID: 153592 RVA: 0x00A694F8 File Offset: 0x00A676F8
|
|
public static int CFGOGHLOALK<T>(this T[] GDLLJBOEGNF, T NOBAPCOKFIL)
|
|
{
|
|
for (int i = 0; i < GDLLJBOEGNF.Length; i++)
|
|
{
|
|
if (GDLLJBOEGNF[i].Equals(NOBAPCOKFIL))
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// Token: 0x060257F9 RID: 153593 RVA: 0x00A6953C File Offset: 0x00A6773C
|
|
public static int KDGFIHEPNFP<T>(this T[] GDLLJBOEGNF, T NOBAPCOKFIL)
|
|
{
|
|
int num = -1;
|
|
for (int i = 0; i < GDLLJBOEGNF.Length; i++)
|
|
{
|
|
if (GDLLJBOEGNF[i].Equals(NOBAPCOKFIL))
|
|
{
|
|
num = i;
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x060257FA RID: 153594 RVA: 0x00A69584 File Offset: 0x00A67784
|
|
public static Quaternion KPGAMOAKJKF(this Quaternion CHNGFKBEEHF)
|
|
{
|
|
return (!CHNGFKBEEHF.AJHIAHGEGDD() && !CHNGFKBEEHF.JMDMDLFCMND()) ? CHNGFKBEEHF : Quaternion.identity;
|
|
}
|
|
|
|
// Token: 0x060257FB RID: 153595 RVA: 0x00A695A8 File Offset: 0x00A677A8
|
|
public static bool AJHIAHGEGDD(this Quaternion CHNGFKBEEHF)
|
|
{
|
|
return float.IsNaN(CHNGFKBEEHF.x) || float.IsNaN(CHNGFKBEEHF.y) || float.IsNaN(CHNGFKBEEHF.z) || float.IsNaN(CHNGFKBEEHF.w);
|
|
}
|
|
|
|
// Token: 0x060257FC RID: 153596 RVA: 0x00A695F8 File Offset: 0x00A677F8
|
|
public static bool JMDMDLFCMND(this Quaternion CHNGFKBEEHF)
|
|
{
|
|
return float.IsInfinity(CHNGFKBEEHF.x) || float.IsInfinity(CHNGFKBEEHF.y) || float.IsInfinity(CHNGFKBEEHF.z) || float.IsInfinity(CHNGFKBEEHF.w);
|
|
}
|
|
|
|
// Token: 0x060257FD RID: 153597 RVA: 0x00A69648 File Offset: 0x00A67848
|
|
public static float HCGEDPDBPBG(float BFLJBMLDMJL, float EGCFIACLGJO, float LHMELEOKNBJ)
|
|
{
|
|
return (EGCFIACLGJO - BFLJBMLDMJL * LHMELEOKNBJ) / (1f - LHMELEOKNBJ);
|
|
}
|
|
|
|
// Token: 0x060257FE RID: 153598 RVA: 0x00A69658 File Offset: 0x00A67858
|
|
public static float NDNGIHGFNPC(float DKDPAJEBOFN, float EGCFIACLGJO, float LHMELEOKNBJ)
|
|
{
|
|
return (EGCFIACLGJO - DKDPAJEBOFN * (1f - LHMELEOKNBJ)) / LHMELEOKNBJ;
|
|
}
|
|
|
|
// Token: 0x060257FF RID: 153599 RVA: 0x00A69668 File Offset: 0x00A67868
|
|
public static float HEIIJOEPPDH(float FKOFGIJFIKA, float GNNBOMAEBGK, float EGNBFLPNLNC)
|
|
{
|
|
float num;
|
|
float num2;
|
|
NNGFEGAEJPG.BOOANNLKMAP(FKOFGIJFIKA, GNNBOMAEBGK, EGNBFLPNLNC, out num, out num2);
|
|
return Mathf.Max(num, num2);
|
|
}
|
|
|
|
// Token: 0x06025800 RID: 153600 RVA: 0x00A69688 File Offset: 0x00A67888
|
|
public static float OPGEJJFFOII(float FKOFGIJFIKA, float GNNBOMAEBGK, float EGNBFLPNLNC)
|
|
{
|
|
float num;
|
|
float num2;
|
|
NNGFEGAEJPG.BOOANNLKMAP(FKOFGIJFIKA, GNNBOMAEBGK, EGNBFLPNLNC, out num, out num2);
|
|
return Mathf.Min(num, num2);
|
|
}
|
|
|
|
// Token: 0x06025801 RID: 153601 RVA: 0x00A696A8 File Offset: 0x00A678A8
|
|
public static void BOOANNLKMAP(float FKOFGIJFIKA, float GNNBOMAEBGK, float EGNBFLPNLNC, out float KECICANEEFK, out float GKFJNBLIIOM)
|
|
{
|
|
float num = Mathf.Sqrt(GNNBOMAEBGK * GNNBOMAEBGK - 4f * FKOFGIJFIKA * EGNBFLPNLNC);
|
|
KECICANEEFK = (-GNNBOMAEBGK - num) / (2f * FKOFGIJFIKA);
|
|
GKFJNBLIIOM = (-GNNBOMAEBGK + num) / (2f * FKOFGIJFIKA);
|
|
}
|
|
|
|
// Token: 0x06025802 RID: 153602 RVA: 0x00A696E8 File Offset: 0x00A678E8
|
|
public static bool KFLBKDPEHEN<T>(this T[] GDLLJBOEGNF, T OKKMGANCMGB)
|
|
{
|
|
for (int i = 0; i < GDLLJBOEGNF.Length; i++)
|
|
{
|
|
if (object.Equals(GDLLJBOEGNF[i], OKKMGANCMGB))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Token: 0x06025803 RID: 153603 RVA: 0x00A69728 File Offset: 0x00A67928
|
|
public static bool CCECMJEACMN(this Vector2 LCCDPOBCNCH, float NOBAPCOKFIL)
|
|
{
|
|
float num;
|
|
float num2;
|
|
if (LCCDPOBCNCH.x > LCCDPOBCNCH.y)
|
|
{
|
|
num = LCCDPOBCNCH.y;
|
|
num2 = LCCDPOBCNCH.x;
|
|
}
|
|
else
|
|
{
|
|
num = LCCDPOBCNCH.x;
|
|
num2 = LCCDPOBCNCH.y;
|
|
}
|
|
return NOBAPCOKFIL >= num && NOBAPCOKFIL <= num2;
|
|
}
|
|
|
|
// Token: 0x06025804 RID: 153604 RVA: 0x00A69780 File Offset: 0x00A67980
|
|
public static bool PLKCJINIPMP(this Player.HDOICGIKKAO AJLJKOMBJGP)
|
|
{
|
|
return AJLJKOMBJGP == Player.HDOICGIKKAO.LeftHand || AJLJKOMBJGP == Player.HDOICGIKKAO.RightHand;
|
|
}
|
|
|
|
// Token: 0x06025805 RID: 153605 RVA: 0x00A69790 File Offset: 0x00A67990
|
|
public static void OFFICKPKMFJ<T>(this IList<T> MKEOFCIGBDG)
|
|
{
|
|
int i = MKEOFCIGBDG.Count;
|
|
global::System.Random random = new global::System.Random((int)DateTime.UtcNow.Ticks);
|
|
while (i > 1)
|
|
{
|
|
int num = random.Next(0, i);
|
|
i--;
|
|
T t = MKEOFCIGBDG[num];
|
|
MKEOFCIGBDG[num] = MKEOFCIGBDG[i];
|
|
MKEOFCIGBDG[i] = t;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06025806 RID: 153606 RVA: 0x00A697F4 File Offset: 0x00A679F4
|
|
public static T KDPEEIFOANI<T>(this IList<T> MKEOFCIGBDG)
|
|
{
|
|
return MKEOFCIGBDG[MKEOFCIGBDG.Count - 1];
|
|
}
|
|
|
|
// Token: 0x06025807 RID: 153607 RVA: 0x00A69804 File Offset: 0x00A67A04
|
|
public static void GBNCHJLPJPI<T>(T[] GDLLJBOEGNF)
|
|
{
|
|
NNGFEGAEJPG.GBNCHJLPJPI<T>(GDLLJBOEGNF, (int)DateTime.UtcNow.Ticks);
|
|
}
|
|
|
|
// Token: 0x06025808 RID: 153608 RVA: 0x00A69828 File Offset: 0x00A67A28
|
|
public static void GBNCHJLPJPI<T>(T[] GDLLJBOEGNF, int NIAMELDPIIF)
|
|
{
|
|
int i = GDLLJBOEGNF.Length;
|
|
global::UnityEngine.Random.InitState(NIAMELDPIIF);
|
|
while (i > 1)
|
|
{
|
|
int num = global::UnityEngine.Random.Range(0, i--);
|
|
T t = GDLLJBOEGNF[i];
|
|
GDLLJBOEGNF[i] = GDLLJBOEGNF[num];
|
|
GDLLJBOEGNF[num] = t;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06025809 RID: 153609 RVA: 0x00A69878 File Offset: 0x00A67A78
|
|
public static string KEPBEPDOIHJ(this GameObject FMEGPDMNPED)
|
|
{
|
|
Transform transform = FMEGPDMNPED.transform;
|
|
string text = transform.name;
|
|
transform = transform.parent;
|
|
while (transform != null)
|
|
{
|
|
text = transform.name + " -> " + text;
|
|
transform = transform.parent;
|
|
}
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x0602580A RID: 153610 RVA: 0x00A698C8 File Offset: 0x00A67AC8
|
|
public static float ELJDEEGMFHN(this float NOBAPCOKFIL, Vector2 FCKDMLHHFJJ, Vector2 IBNHADMMGBG)
|
|
{
|
|
float num = FCKDMLHHFJJ.y - FCKDMLHHFJJ.x;
|
|
float num2 = (NOBAPCOKFIL - FCKDMLHHFJJ.x) / num;
|
|
float num3 = IBNHADMMGBG.y - IBNHADMMGBG.x;
|
|
return IBNHADMMGBG.x + num3 * num2;
|
|
}
|
|
|
|
// Token: 0x0602580B RID: 153611 RVA: 0x00A6990C File Offset: 0x00A67B0C
|
|
public static string MJIIFCDDNMM(this Guid JAGNIKELELP)
|
|
{
|
|
return JAGNIKELELP.ToString("N");
|
|
}
|
|
|
|
// Token: 0x0602580C RID: 153612 RVA: 0x00A6991C File Offset: 0x00A67B1C
|
|
public static bool KOMMBHNFFDN(List<Renderer> LLMACEFNAKG, out Bounds LCCDPOBCNCH, List<Renderer> ECILHIMDMDC = null)
|
|
{
|
|
bool flag = false;
|
|
LCCDPOBCNCH = default(Bounds);
|
|
if (ECILHIMDMDC == null)
|
|
{
|
|
ECILHIMDMDC = new List<Renderer>();
|
|
}
|
|
foreach (Renderer renderer in LLMACEFNAKG.Concat(ECILHIMDMDC))
|
|
{
|
|
if (!(renderer is ParticleSystemRenderer) && !(renderer is TrailRenderer))
|
|
{
|
|
if (!flag)
|
|
{
|
|
LCCDPOBCNCH = renderer.bounds;
|
|
flag = true;
|
|
}
|
|
else if (renderer != null)
|
|
{
|
|
LCCDPOBCNCH.Encapsulate(renderer.bounds);
|
|
}
|
|
}
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x0602580D RID: 153613 RVA: 0x00A699D4 File Offset: 0x00A67BD4
|
|
public static void GNEPMJNCMKL(this RenderTexture KPMMDGIAGPC, ref Texture2D JBGLHECEOPE)
|
|
{
|
|
RenderTexture active = RenderTexture.active;
|
|
RenderTexture.active = KPMMDGIAGPC;
|
|
if (JBGLHECEOPE == null)
|
|
{
|
|
JBGLHECEOPE = new Texture2D(KPMMDGIAGPC.width, KPMMDGIAGPC.height, TextureFormat.ARGB32, false);
|
|
}
|
|
JBGLHECEOPE.ReadPixels(new Rect(0f, 0f, (float)JBGLHECEOPE.width, (float)JBGLHECEOPE.height), 0, 0);
|
|
JBGLHECEOPE.Apply();
|
|
RenderTexture.active = active;
|
|
}
|
|
|
|
// Token: 0x0602580E RID: 153614 RVA: 0x00A69A44 File Offset: 0x00A67C44
|
|
public static string PPKOEKKHJAG(this float FOEOKCHPILL)
|
|
{
|
|
int num = Mathf.RoundToInt(FOEOKCHPILL);
|
|
return (num / 60).ToString("D2") + ":" + (num % 60).ToString("D2");
|
|
}
|
|
|
|
// Token: 0x0602580F RID: 153615 RVA: 0x00A69A84 File Offset: 0x00A67C84
|
|
public static void BMPDLKPAPGK(this Renderer IFEDGEGIPFC, float ELFEPDAKCDL)
|
|
{
|
|
Color color = IFEDGEGIPFC.material.color;
|
|
color.a = ELFEPDAKCDL;
|
|
IFEDGEGIPFC.material.color = color;
|
|
}
|
|
|
|
// Token: 0x06025810 RID: 153616 RVA: 0x00A69AB4 File Offset: 0x00A67CB4
|
|
public static int MLAKEDFEFGM(this TextAnchor MKINBKJIKOC)
|
|
{
|
|
switch (MKINBKJIKOC)
|
|
{
|
|
case TextAnchor.UpperLeft:
|
|
case TextAnchor.UpperCenter:
|
|
case TextAnchor.UpperRight:
|
|
return 1;
|
|
case TextAnchor.LowerLeft:
|
|
case TextAnchor.LowerCenter:
|
|
case TextAnchor.LowerRight:
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Token: 0x06025811 RID: 153617 RVA: 0x00A69AEC File Offset: 0x00A67CEC
|
|
public static float MOEHLAHMPFE(this Vector2 FLKMJFAOABP, Vector2 MABKDDJKKPL)
|
|
{
|
|
Vector3 vector = FLKMJFAOABP;
|
|
Vector3 vector2 = MABKDDJKKPL;
|
|
return vector.PJBALLOOEOF(vector2, new Vector3?(Vector3.forward));
|
|
}
|
|
|
|
// Token: 0x06025812 RID: 153618 RVA: 0x00A69B18 File Offset: 0x00A67D18
|
|
public static bool DFFGNHPIPJB(string CCBDPEIAHMM)
|
|
{
|
|
Regex regex = new Regex("^[\\w!#$%&'*+\\-/=?\\^_`{|}~]+(\\.[\\w!#$%&'*+\\-/=?\\^_`{|}~]+)*@((([\\-\\w]+\\.)+[a-zA-Z]{2,4})|(([0-9]{1,3}\\.){3}[0-9]{1,3}))$");
|
|
Match match = regex.Match(CCBDPEIAHMM);
|
|
return match.Success;
|
|
}
|
|
|
|
// Token: 0x06025813 RID: 153619 RVA: 0x00A69B40 File Offset: 0x00A67D40
|
|
public static string HDDFDDFHEHB(this string NOBAPCOKFIL, int NPKFFOECKCN, string MMCEMOILEBI = "")
|
|
{
|
|
if (string.IsNullOrEmpty(NOBAPCOKFIL))
|
|
{
|
|
return NOBAPCOKFIL;
|
|
}
|
|
return (NOBAPCOKFIL.Length > NPKFFOECKCN) ? (NOBAPCOKFIL.Substring(0, NPKFFOECKCN) + MMCEMOILEBI) : NOBAPCOKFIL;
|
|
}
|
|
|
|
// Token: 0x06025814 RID: 153620 RVA: 0x00A69B70 File Offset: 0x00A67D70
|
|
public static Color OACAENEBKNN(this Color HNOPCLEFEIG, float POHIMKLKLHK)
|
|
{
|
|
Color color = HNOPCLEFEIG;
|
|
color.a = POHIMKLKLHK;
|
|
return color;
|
|
}
|
|
|
|
// Token: 0x06025815 RID: 153621 RVA: 0x00A69B88 File Offset: 0x00A67D88
|
|
public static V LCPJBBBPLEH<T, V>(this T LHMELEOKNBJ, Func<T, V> ENCDNMEMIIF, V FJIHPPGEJCF = default(V)) where T : class
|
|
{
|
|
if (LHMELEOKNBJ != null)
|
|
{
|
|
return ENCDNMEMIIF(LHMELEOKNBJ);
|
|
}
|
|
return FJIHPPGEJCF;
|
|
}
|
|
|
|
// Token: 0x06025816 RID: 153622 RVA: 0x00A69BA0 File Offset: 0x00A67DA0
|
|
public static void LAMMJKLHNOL<T>(this T LHMELEOKNBJ, Action<T> ENCDNMEMIIF) where T : class
|
|
{
|
|
if (LHMELEOKNBJ != null)
|
|
{
|
|
ENCDNMEMIIF(LHMELEOKNBJ);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06025817 RID: 153623 RVA: 0x00A69BB4 File Offset: 0x00A67DB4
|
|
public static float PEKFJINKCPD()
|
|
{
|
|
return (global::UnityEngine.Random.Range(0, 2) != 0) ? 1f : (-1f);
|
|
}
|
|
|
|
// Token: 0x06025818 RID: 153624 RVA: 0x00A69BD4 File Offset: 0x00A67DD4
|
|
public static bool GECFBNNMHCE(float LNDKODPHOCP)
|
|
{
|
|
return global::UnityEngine.Random.value <= LNDKODPHOCP;
|
|
}
|
|
|
|
// Token: 0x06025819 RID: 153625 RVA: 0x00A69BE4 File Offset: 0x00A67DE4
|
|
public static bool NMKGGNNEIDC(this EEBPLECPEGD HPMPJMIOMCK)
|
|
{
|
|
AGFCGHIFLIK agfcghiflik = ((HPMPJMIOMCK == null) ? null : GLGMPGPNNBP.CPIBGJLHLBL(ObscuredLong.EDHNDLCFIOL(HPMPJMIOMCK.PKJFPDJKJAH)));
|
|
return agfcghiflik == null || (agfcghiflik.EEAOGJHMFII == AGFCGHIFLIK.AHHAANFJKJA.None && agfcghiflik.KBOBNFHLABB == AGFCGHIFLIK.DKDCJMEPHCJ.None);
|
|
}
|
|
|
|
// Token: 0x0602581A RID: 153626 RVA: 0x00A69C30 File Offset: 0x00A67E30
|
|
public static bool OJOCDJLADNI(this EEBPLECPEGD HPMPJMIOMCK)
|
|
{
|
|
if (HPMPJMIOMCK == null || HPMPJMIOMCK.HPLFAJMJKGO)
|
|
{
|
|
return false;
|
|
}
|
|
bool flag = ObscuredInt.EDHNDLCFIOL(HPMPJMIOMCK.EFHLFMMGAGP) >= 3;
|
|
bool flag2 = HPMPJMIOMCK.NBBBIJDAFCF() <= 0;
|
|
return flag && flag2;
|
|
}
|
|
|
|
// Token: 0x0602581B RID: 153627 RVA: 0x00A69C7C File Offset: 0x00A67E7C
|
|
public static TValue IFIIFGLDHJK<TKey, TValue>(this IDictionary<TKey, TValue> NILLMCJCHJH, TKey ANOFFEKMECJ) where TValue : new()
|
|
{
|
|
TValue tvalue;
|
|
if (!NILLMCJCHJH.TryGetValue(ANOFFEKMECJ, out tvalue))
|
|
{
|
|
tvalue = new TValue();
|
|
NILLMCJCHJH.Add(ANOFFEKMECJ, tvalue);
|
|
}
|
|
return tvalue;
|
|
}
|
|
|
|
// Token: 0x0602581C RID: 153628 RVA: 0x00A69CA8 File Offset: 0x00A67EA8
|
|
public static Texture2D PGDCDGKDMBE(this Texture2D MOLHGDEPNKN, Vector2 BHIKEGFDJEI, int PKKMPHIOBNB = 2)
|
|
{
|
|
int width = MOLHGDEPNKN.width;
|
|
int height = MOLHGDEPNKN.height;
|
|
Texture2D texture2D = global::UnityEngine.Object.Instantiate<Texture2D>(MOLHGDEPNKN);
|
|
int num = (int)((float)width - BHIKEGFDJEI.x) / PKKMPHIOBNB;
|
|
int num2 = (int)((float)height - BHIKEGFDJEI.y) / PKKMPHIOBNB;
|
|
for (int i = 1; i < PKKMPHIOBNB - 1; i++)
|
|
{
|
|
PJGGFELBOAL.GAFBBDJNJIK(texture2D, width - i * num, height - i * num2);
|
|
}
|
|
PJGGFELBOAL.GAFBBDJNJIK(texture2D, (int)BHIKEGFDJEI.x, (int)BHIKEGFDJEI.y);
|
|
return texture2D;
|
|
}
|
|
|
|
// Token: 0x0602581D RID: 153629 RVA: 0x00A69D2C File Offset: 0x00A67F2C
|
|
public static void MOFFLDPKFHI(this Material PNPJBLJGEAM, string FDOPLANONDH, bool KELIMOCDMOD)
|
|
{
|
|
if (KELIMOCDMOD)
|
|
{
|
|
PNPJBLJGEAM.EnableKeyword(FDOPLANONDH);
|
|
}
|
|
else
|
|
{
|
|
PNPJBLJGEAM.DisableKeyword(FDOPLANONDH);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0602581E RID: 153630 RVA: 0x00A69D48 File Offset: 0x00A67F48
|
|
public static void MMEHIAJOEHA(this Animator FIOLBHFJENN, int HPCOKMAPCHB, bool NOBAPCOKFIL)
|
|
{
|
|
if (FIOLBHFJENN.gameObject.activeInHierarchy)
|
|
{
|
|
FIOLBHFJENN.SetBool(HPCOKMAPCHB, NOBAPCOKFIL);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0602581F RID: 153631 RVA: 0x00A69D64 File Offset: 0x00A67F64
|
|
public static void MMEHIAJOEHA(this Animator FIOLBHFJENN, string EKKMPHMGCLB, bool NOBAPCOKFIL)
|
|
{
|
|
if (FIOLBHFJENN.gameObject.activeInHierarchy)
|
|
{
|
|
FIOLBHFJENN.SetBool(EKKMPHMGCLB, NOBAPCOKFIL);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06025820 RID: 153632 RVA: 0x00A69D80 File Offset: 0x00A67F80
|
|
public static void HPAOJHHCBNG(this Animator FIOLBHFJENN, string EKKMPHMGCLB, float NOBAPCOKFIL)
|
|
{
|
|
if (FIOLBHFJENN.gameObject.activeInHierarchy)
|
|
{
|
|
FIOLBHFJENN.SetFloat(EKKMPHMGCLB, NOBAPCOKFIL);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06025821 RID: 153633 RVA: 0x00A69D9C File Offset: 0x00A67F9C
|
|
public static void HPAOJHHCBNG(this Animator FIOLBHFJENN, int HPCOKMAPCHB, float NOBAPCOKFIL)
|
|
{
|
|
if (FIOLBHFJENN.gameObject.activeInHierarchy)
|
|
{
|
|
FIOLBHFJENN.SetFloat(HPCOKMAPCHB, NOBAPCOKFIL);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06025822 RID: 153634 RVA: 0x00A69DB8 File Offset: 0x00A67FB8
|
|
public static void HPAOJHHCBNG(this Animator FIOLBHFJENN, string EKKMPHMGCLB, float NOBAPCOKFIL, float APOAFCDCHIO, float KGNAMMELBPH)
|
|
{
|
|
if (FIOLBHFJENN.gameObject.activeInHierarchy)
|
|
{
|
|
FIOLBHFJENN.SetFloat(EKKMPHMGCLB, NOBAPCOKFIL, APOAFCDCHIO, KGNAMMELBPH);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06025823 RID: 153635 RVA: 0x00A69DD8 File Offset: 0x00A67FD8
|
|
public static void HPAOJHHCBNG(this Animator FIOLBHFJENN, int HPCOKMAPCHB, float NOBAPCOKFIL, float APOAFCDCHIO, float KGNAMMELBPH)
|
|
{
|
|
if (FIOLBHFJENN.gameObject.activeInHierarchy)
|
|
{
|
|
FIOLBHFJENN.SetFloat(HPCOKMAPCHB, NOBAPCOKFIL, APOAFCDCHIO, KGNAMMELBPH);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06025824 RID: 153636 RVA: 0x00A69DF8 File Offset: 0x00A67FF8
|
|
public static void EGCMHABOLCA(this Animator FIOLBHFJENN, int HPCOKMAPCHB, int NOBAPCOKFIL)
|
|
{
|
|
if (FIOLBHFJENN.gameObject.activeInHierarchy)
|
|
{
|
|
FIOLBHFJENN.SetInteger(HPCOKMAPCHB, NOBAPCOKFIL);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06025825 RID: 153637 RVA: 0x00A69E14 File Offset: 0x00A68014
|
|
public static void EGCMHABOLCA(this Animator FIOLBHFJENN, string EKKMPHMGCLB, int NOBAPCOKFIL)
|
|
{
|
|
if (FIOLBHFJENN.gameObject.activeInHierarchy)
|
|
{
|
|
FIOLBHFJENN.SetInteger(EKKMPHMGCLB, NOBAPCOKFIL);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06025826 RID: 153638 RVA: 0x00A69E30 File Offset: 0x00A68030
|
|
public static string IJBOOEEOOFO(this FileInfo JEPOCDGJGDP, string FOJIAJNLIPA, string MBKKEHIEELJ)
|
|
{
|
|
string text = string.Empty;
|
|
if (JEPOCDGJGDP != null && JEPOCDGJGDP.Exists)
|
|
{
|
|
using (StreamReader streamReader = JEPOCDGJGDP.OpenText())
|
|
{
|
|
bool flag = false;
|
|
string text2 = string.Empty;
|
|
while ((text2 = streamReader.ReadLine()) != null)
|
|
{
|
|
if (flag)
|
|
{
|
|
if (!string.IsNullOrEmpty(MBKKEHIEELJ) && text2.Contains(MBKKEHIEELJ))
|
|
{
|
|
break;
|
|
}
|
|
text = text + text2 + Environment.NewLine;
|
|
}
|
|
else if (!string.IsNullOrEmpty(FOJIAJNLIPA) && text2.Contains(FOJIAJNLIPA))
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return text.Trim();
|
|
}
|
|
|
|
// Token: 0x06025827 RID: 153639 RVA: 0x00A69EEC File Offset: 0x00A680EC
|
|
public static string IJBOOEEOOFO(this FileInfo JEPOCDGJGDP, int CONHODCIPKD, int IDDLEKGOAEM)
|
|
{
|
|
string text = string.Empty;
|
|
if (JEPOCDGJGDP != null && JEPOCDGJGDP.Exists)
|
|
{
|
|
using (StreamReader streamReader = JEPOCDGJGDP.OpenText())
|
|
{
|
|
int num = 0;
|
|
string text2 = string.Empty;
|
|
while ((text2 = streamReader.ReadLine()) != null)
|
|
{
|
|
if (num >= CONHODCIPKD + IDDLEKGOAEM)
|
|
{
|
|
break;
|
|
}
|
|
if (num >= CONHODCIPKD)
|
|
{
|
|
text = text + text2 + Environment.NewLine;
|
|
}
|
|
num++;
|
|
}
|
|
}
|
|
}
|
|
return text.Trim();
|
|
}
|
|
|
|
// Token: 0x06025828 RID: 153640 RVA: 0x00A69F80 File Offset: 0x00A68180
|
|
public static void CILPLBJMEMP(string NFAFJOMABOK, global::UnityEngine.Object CGMIJJGJJLH = null)
|
|
{
|
|
Debug.Log(NFAFJOMABOK, CGMIJJGJJLH);
|
|
Console.WriteLine(NFAFJOMABOK);
|
|
}
|
|
|
|
// Token: 0x0602582A RID: 153642 RVA: 0x00A69FA8 File Offset: 0x00A681A8
|
|
[CompilerGenerated]
|
|
private static bool AEKHOOMLIKM<T>(T ILFEPFCLLFJ) where T : class
|
|
{
|
|
return ILFEPFCLLFJ == null;
|
|
}
|
|
|
|
// Token: 0x04005EC7 RID: 24263
|
|
public static float JBAKMBLDAHC = 0.0001f;
|
|
|
|
// Token: 0x04005EC8 RID: 24264
|
|
public static float LFKLNKJBNEI = 1f;
|
|
}
|