using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;
using ExitGames.Client.Photon.LoadBalancing;
using Photon;
using RecNet;
using RecRoom;
using RecRoom.Players;
using Steamworks;
using UnityEngine;
using UnityEngine.Rendering;

// Token: 0x02000CA7 RID: 3239
[RequireComponent(typeof(PlayerOutfit))]
[DisallowMultipleComponent]
[RequireComponent(typeof(PlayerLocomotion))]
[RequireComponent(typeof(PlayerUI))]
public class Player : global::Photon.MonoBehaviour
{
	// Token: 0x06019BB5 RID: 105397 RVA: 0x0072D6AC File Offset: 0x0072B8AC
	public void PushLocalPlayerStatus(string JBFKOEEKONI)
	{
		this.DPAHOMFBOFE.Push(JBFKOEEKONI);
	}

	// Token: 0x06019BB6 RID: 105398 RVA: 0x0072D6BC File Offset: 0x0072B8BC
	public static float EPGBLBAGJNP()
	{
		return Player.FCEGFOFFLJJ + Player.BHMHGMCEBDK;
	}

	// Token: 0x06019BB7 RID: 105399 RVA: 0x0072D6CC File Offset: 0x0072B8CC
	private IEnumerator Start()
	{
		if (this.NHDDPGADJPJ && this.PFGLMBNKPCO != SingletonMonoBehaviour<SettingsManager>.NCKMBFBMBFM.CIEACBKDCBJ)
		{
			this.PFGLMBNKPCO = SingletonMonoBehaviour<SettingsManager>.NCKMBFBMBFM.CIEACBKDCBJ;
		}
		else
		{
			this.HDNBFPPDIMP();
		}
		if (this.NHDDPGADJPJ)
		{
			foreach (GameObject gameObject in this.hideInFirstPerson)
			{
				if (gameObject.GetComponentInChildren<Collider>() != null)
				{
					global::UnityEngine.Debug.LogError("Hidable object has a collider.  Its layer will be changed to hidden in first person.");
				}
				Player.CreateFirstPersonShadowCaster(gameObject);
				gameObject.HLGPFLHHEEK(NILFAGNKNMH.HiddenInFirstPerson);
			}
			base.name += "_local";
			this.SetupControllerIOForHands();
			SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.SetTransform(base.transform.position, base.transform.rotation);
			SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.GAHBIMMKNPF();
			CameraStartPoint.UpdateChaperonePosition();
			this.ACAJJPKPKBH.SuppressAnimation = true;
			this.SpawnLocal();
			this.LGEHCGIGNBO();
			this.SetMuteFlag(Player.PPELPGLINBB.VOICE_TYPE_MUTE, SingletonMonoBehaviour<SettingsManager>.NCKMBFBMBFM.FPEGHDDDHCC == FPEGHDDDHCC.Mute);
			this.EAJABOECGNI = SingletonMonoBehaviour<SettingsManager>.NCKMBFBMBFM.EAJABOECGNI;
		}
		else
		{
			GLGMPGPNNBP.GGGHJGKGLOE += this.DHJLDKNHAPH;
			this.DHJLDKNHAPH(new long?(this.NAJBCPFNBAB));
			if (!DynamicUpdateManager.NCKMBFBMBFM.IsGroupRegistered("Player"))
			{
				int[] array2 = new int[] { 3, 0, 0, 0, 3 };
				array2[1] = int.MaxValue;
				array2[2] = int.MaxValue;
				array2[3] = int.MaxValue;
				DynamicUpdateManager.NCKMBFBMBFM.RegisterGroup("Player", 100f, array2);
			}
			this.PBMAODCJHIH = this.leftHand.GetComponentInChildren<Animator>(true);
			this.BCNKIKFJBHJ = this.leftHand.GetComponentInChildren<Renderer>(true);
			this.PIGACHDDMNA = this.rightHand.GetComponentInChildren<Animator>(true);
			this.ABINFEAPOHB = this.rightHand.GetComponentInChildren<Renderer>(true);
			this.CEKBCIBCMGP = this.head.GetComponent<Animator>();
			this.PGMLAPIMEMM = this.head.GetComponentInChildren<Renderer>(true);
			DynamicUpdateManager.NCKMBFBMBFM.RegisterObject("Player", base.gameObject, DynamicUpdateManager.DefaultCostFunction(new DynamicUpdateManager.IIEGGLHMOBH(this.BDGAOKJBCNJ), new DynamicUpdateManager.NLJIAHMEMLO(this.ONDILIDGOLP)), new DynamicUpdateManager.CGICDANJGLP(this.CGICDANJGLP));
		}
		this.NPKOIHBPNIK();
		this.JFMIIOMJMMB();
		this.CJKKIBMIKNH();
		this.BOCFJBNNEFP = true;
		if (this.NHDDPGADJPJ)
		{
			this.SavedVoiceChatSettings = SingletonMonoBehaviour<SettingsManager>.NCKMBFBMBFM.FPEGHDDDHCC;
		}
		if (Player.OnPlayerCreated != null)
		{
			Player.OnPlayerCreated.Invoke(this);
		}
		this.BMNADFIKDOE(this.NAJBCPFNBAB);
		yield break;
	}

	// Token: 0x06019BB8 RID: 105400 RVA: 0x0072D6E8 File Offset: 0x0072B8E8
	public PlayerAudio DMANGGLOHKH()
	{
		return this.playerAudio;
	}

	// Token: 0x06019BB9 RID: 105401 RVA: 0x0072D6F0 File Offset: 0x0072B8F0
	public bool DCAAPMDODJH(Tool ENBMEDIFBLM)
	{
		bool flag = true;
		if (ENBMEDIFBLM != null && ENBMEDIFBLM.OHGPCMJMFGC && ENBMEDIFBLM.GANDPDNCOKF() && ENBMEDIFBLM.FICBNMJECCH == this)
		{
			Vector3 vector = Vector3.ProjectOnPlane(this.BGOGBEPJGPJ.transform.forward, Vector3.up).normalized;
			Vector3 normalized = Vector3.Cross(Vector3.up, vector).normalized;
			float num = global::UnityEngine.Random.Range(244f, 1819f);
			float num2 = global::UnityEngine.Random.Range(560f, 1433f);
			vector = Quaternion.AngleAxis(num2, normalized) * Quaternion.AngleAxis(num, Vector3.up) * vector;
			ENBMEDIFBLM.BBGHKANFCHC = DDOFAPFDGNL.JPCIKFHMMED;
			ENBMEDIFBLM.BOLBONELAEF.AddForce(vector * 1390f, ForceMode.Acceleration);
			this.DEOBJENCBGG = Time.time;
			flag = true;
		}
		return flag;
	}

	// Token: 0x17000B7D RID: 2941
	// (get) Token: 0x06019BBA RID: 105402 RVA: 0x0072D7DC File Offset: 0x0072B9DC
	// (set) Token: 0x06019C47 RID: 105543 RVA: 0x0072FCC4 File Offset: 0x0072DEC4
	public PlayerHand MONEMFCPHDE
	{
		get
		{
			return this.IDGBDKLOLGN;
		}
		private set
		{
			if (value != null && value.ILGCMIFHJOJ == PlayerHand.AKCKIFINDJE.NOT_CONNECTED)
			{
				this.IDGBDKLOLGN = this.GetOtherHand(value.EEAOGJHMFII);
			}
			else
			{
				this.IDGBDKLOLGN = value;
			}
		}
	}

	// Token: 0x06019BBB RID: 105403 RVA: 0x0072D7E4 File Offset: 0x0072B9E4
	public bool TryDisarm(Tool ENBMEDIFBLM)
	{
		bool flag = false;
		if (ENBMEDIFBLM != null && ENBMEDIFBLM.OHGPCMJMFGC && ENBMEDIFBLM.BHCCHBHNHCG && ENBMEDIFBLM.FICBNMJECCH == this)
		{
			Vector3 vector = Vector3.ProjectOnPlane(this.BGOGBEPJGPJ.transform.forward, Vector3.up).normalized;
			Vector3 normalized = Vector3.Cross(Vector3.up, vector).normalized;
			float num = global::UnityEngine.Random.Range(-20f, 20f);
			float num2 = global::UnityEngine.Random.Range(-20f, 20f);
			vector = Quaternion.AngleAxis(num2, normalized) * Quaternion.AngleAxis(num, Vector3.up) * vector;
			ENBMEDIFBLM.BBGHKANFCHC = DDOFAPFDGNL.JPCIKFHMMED;
			ENBMEDIFBLM.BOLBONELAEF.AddForce(vector * 4f, ForceMode.VelocityChange);
			this.DEOBJENCBGG = Time.time;
			flag = true;
		}
		return flag;
	}

	// Token: 0x06019BBC RID: 105404 RVA: 0x0072D8D0 File Offset: 0x0072BAD0
	private void IGJGFFDGIMH(PlayerHand GAEKGDCFOJM, int HEFDOFBDJIF, string AIJGBGLAMGJ)
	{
		if (GAEKGDCFOJM == null)
		{
			return;
		}
		Tool tool = Tool.Find(HEFDOFBDJIF);
		if (tool == null || !GAEKGDCFOJM.TryPickupTool(tool, false))
		{
			return;
		}
		if (tool.NLNJOJLDEAE == null)
		{
			return;
		}
		if (!string.IsNullOrEmpty(AIJGBGLAMGJ))
		{
			tool.NLNJOJLDEAE.LocalApplySkin(AIJGBGLAMGJ, false);
		}
		tool.NLNJOJLDEAE.LocalApplyFavoriteSkin(false);
	}

	// Token: 0x17000BA0 RID: 2976
	// (get) Token: 0x06019BBD RID: 105405 RVA: 0x0072D944 File Offset: 0x0072BB44
	// (set) Token: 0x06019C53 RID: 105555 RVA: 0x0072FFDC File Offset: 0x0072E1DC
	public AGFCGHIFLIK.DKDCJMEPHCJ MMDAAHDKEGA { get; set; }

	// Token: 0x06019BBE RID: 105406 RVA: 0x0072D94C File Offset: 0x0072BB4C
	public void HJJDNCOOIGD()
	{
		this.DGEOJLGFGNG().ReleaseTool(true);
		this.KEJBPANGFKK.ReleaseTool(false);
	}

	// Token: 0x06019BBF RID: 105407 RVA: 0x0072D968 File Offset: 0x0072BB68
	[BCENPNOIAOM]
	public void RpcSetFacialExpression(int MOINACCKALB)
	{
		this.HGALPPFDCIO.PlayExpression(MOINACCKALB);
	}

	// Token: 0x17000B66 RID: 2918
	// (get) Token: 0x06019BC0 RID: 105408 RVA: 0x0072D978 File Offset: 0x0072BB78
	public static float BHMHGMCEBDK
	{
		get
		{
			return SingletonMonoBehaviour<CameraFade>.NCKMBFBMBFM.DOLNFIDCNOH;
		}
	}

	// Token: 0x06019BC1 RID: 105409 RVA: 0x0072D984 File Offset: 0x0072BB84
	[BCENPNOIAOM]
	public void RpcBroadcastSpawnPlayer()
	{
		this.DPLLNDECEMP = true;
		this.GADNKIIKPPD.OnPlayerSpawn();
		if (Player.PlayerSpawnEvent != null)
		{
			Player.PlayerSpawnEvent.Invoke(this);
		}
		if (this.IIEGGLHMOBH)
		{
			this.ACAJJPKPKBH.PlayEffect(true, null, null, false);
		}
	}

	// Token: 0x06019BC2 RID: 105410 RVA: 0x0072D9E4 File Offset: 0x0072BBE4
	private void DHJLDKNHAPH(long? GKPEOHGOGCF)
	{
		if (GKPEOHGOGCF == null || GKPEOHGOGCF == this.NAJBCPFNBAB)
		{
			bool flag = false;
			this.KPJILALFECN = GLGMPGPNNBP.CPIBGJLHLBL(this.NAJBCPFNBAB);
			if (this.KPJILALFECN != null)
			{
				flag = this.KPJILALFECN.KBOBNFHLABB != AGFCGHIFLIK.DKDCJMEPHCJ.None || this.KPJILALFECN.HKFLLFCMFOP == AGFCGHIFLIK.DKDCJMEPHCJ.Local || this.KPJILALFECN.HKFLLFCMFOP == AGFCGHIFLIK.DKDCJMEPHCJ.Mutual;
				this.MMDAAHDKEGA = this.KPJILALFECN.KBOBNFHLABB;
			}
			this.SetMuteFlag(Player.PPELPGLINBB.RELATIONSHIP_MUTE, flag);
		}
	}

	// Token: 0x06019BC3 RID: 105411 RVA: 0x0072DA8C File Offset: 0x0072BC8C
	protected override void Awake()
	{
		base.Awake();
		IHFKMIAHBFP.GFFDICBLOFJ += new Action<LNJFBGIBLHA>(this.OnPhotonPlayerConnected);
		IHFKMIAHBFP.DHLJAODEIEA += new Action<LNJFBGIBLHA>(this.OnPhotonPlayerDisconnected);
		LNPBGKENDPK.HBBDEELDEMH += this.BMNADFIKDOE;
		this.PALMENINGNL = this.BGOGBEPJGPJ.transform.localScale;
		this.LBMGHLBBKBJ = new GameObject("PlayerRoot");
		global::UnityEngine.Object.DontDestroyOnLoad(this.LBMGHLBBKBJ);
		this.SetParentPlayerRoot(base.transform);
		this.SetParentPlayerRoot(this.voiceObject);
		this.LNJFBGIBLHA.NIELBMEGFAH = this;
		this.NAJBCPFNBAB = this.LNJFBGIBLHA.KJOEMGEOBBA;
		if (this.NHDDPGADJPJ)
		{
			Player.LocalPlayer = this;
			Player.LocalPlayerExists = true;
		}
		this.playerChaperone.gameObject.SetActive(this.NHDDPGADJPJ);
		this.MLECOGMANBB = this.voiceObject.GetComponent<AudioSource>();
		PlayerCollider[] componentsInChildren = base.GetComponentsInChildren<PlayerCollider>(true);
		foreach (PlayerCollider playerCollider in componentsInChildren)
		{
			playerCollider.ThisPlayer = this;
		}
		if (this.NHDDPGADJPJ)
		{
			if (this.remotePlayerOnlyObjects != null && this.remotePlayerOnlyObjects.Length > 0)
			{
				for (int j = 0; j < this.remotePlayerOnlyObjects.Length; j++)
				{
					global::UnityEngine.Object.Destroy(this.remotePlayerOnlyObjects[j]);
				}
			}
			base.gameObject.LLOHMKAPBDK(NILFAGNKNMH.RemotePlayerPhysics, NILFAGNKNMH.LocalPlayerPhysics);
		}
		else
		{
			if (this.localPlayerOnlyObjects != null && this.localPlayerOnlyObjects.Length > 0)
			{
				for (int k = 0; k < this.localPlayerOnlyObjects.Length; k++)
				{
					global::UnityEngine.Object.Destroy(this.localPlayerOnlyObjects[k]);
				}
			}
			base.gameObject.LLOHMKAPBDK(NILFAGNKNMH.UICollider, NILFAGNKNMH.RemotePlayerPhysics);
		}
		this.BGIBHPOALJG.OFIHFCEOGGD += this.DLHPBAMGOHC;
		this.KEJBPANGFKK.OFIHFCEOGGD += this.DLHPBAMGOHC;
		this.IDGBDKLOLGN = this.KEJBPANGFKK;
		object[] instantiationData = base.OMNGGJICBBI.NFOKNEKLACK;
		Vector3 vector = this.BGOGBEPJGPJ.transform.InverseTransformPoint(this.NGFPOMIFLMF.transform.position);
		Quaternion quaternion = this.BGOGBEPJGPJ.transform.MCKNNGGGBDG(this.NGFPOMIFLMF.transform.rotation);
		this.BGOGBEPJGPJ.transform.position = base.transform.TransformPoint(((Vector3)instantiationData[0]).GGPAIPKFIIO());
		this.BGOGBEPJGPJ.transform.rotation = base.transform.PAFJLHMDIMO(((Quaternion)instantiationData[1]).KPGAMOAKJKF());
		this.BGIBHPOALJG.transform.position = base.transform.TransformPoint(((Vector3)instantiationData[2]).GGPAIPKFIIO());
		this.BGIBHPOALJG.transform.rotation = base.transform.PAFJLHMDIMO(((Quaternion)instantiationData[3]).KPGAMOAKJKF());
		this.KEJBPANGFKK.transform.position = base.transform.TransformPoint(((Vector3)instantiationData[4]).GGPAIPKFIIO());
		this.KEJBPANGFKK.transform.rotation = base.transform.PAFJLHMDIMO(((Quaternion)instantiationData[5]).KPGAMOAKJKF());
		this.DINLMMOJAPK = ((Vector3)instantiationData[6]).GGPAIPKFIIO();
		this.LMALFJDHFAJ = ((Quaternion)instantiationData[7]).KPGAMOAKJKF();
		this.NGFPOMIFLMF.transform.position = this.BGOGBEPJGPJ.transform.TransformPoint(vector);
		this.NGFPOMIFLMF.transform.rotation = this.BGOGBEPJGPJ.transform.PAFJLHMDIMO(quaternion);
		Player.All.Add(this);
		this.PushAfkKickToIntroTimeout(300f);
		this.PushAfkWarningStartTimeout(280f);
		this.MBEFNKNJEPH += this.NOCJEIEOACD;
		this.JPKCMDPEMDF = new DDOGCBFMKFO<PlatformManager.JNJEBIDGBNH>(base.HKLENNJOICH, "Platform", PlatformManager.JNJEBIDGBNH.STEAM, null);
		this.NGIIAOJHKAE = new DDOGCBFMKFO<ulong>(base.HKLENNJOICH, "PlatformId", 0UL, null);
		this.LCOKAJELKDA = new DDOGCBFMKFO<EAJABOECGNI>(base.HKLENNJOICH, "PlayerIgnoreBuffer", EAJABOECGNI.Disabled, new Action(this.CJKKIBMIKNH));
		this.ACKDJPKHKAP = new DDOGCBFMKFO<bool>(base.HKLENNJOICH, "UserInHeadset", true, new Action(this.NPKOIHBPNIK));
		this.BEPFHMHDCFJ = new DDOGCBFMKFO<AudioManager.PFGLMBNKPCO>(base.HKLENNJOICH, "PlayerVoiceFilter", AudioManager.PFGLMBNKPCO.None, new Action(this.HDNBFPPDIMP));
		this.PNFHHGHADMB = new DDOGCBFMKFO<int>(base.HKLENNJOICH, "PlayerPing", 300, null);
	}

	// Token: 0x17000B79 RID: 2937
	// (get) Token: 0x06019BC4 RID: 105412 RVA: 0x0072DF40 File Offset: 0x0072C140
	public PlayerHand BGIBHPOALJG
	{
		get
		{
			return this.leftHand;
		}
	}

	// Token: 0x06019BC5 RID: 105413 RVA: 0x0072DF48 File Offset: 0x0072C148
	public bool DBPHMGFKJKB()
	{
		return this.<MGPJKIHNFMG>k__BackingField;
	}

	// Token: 0x17000B87 RID: 2951
	// (get) Token: 0x06019BC6 RID: 105414 RVA: 0x0072DF50 File Offset: 0x0072C150
	public bool LHKNKHPEPCJ
	{
		get
		{
			bool flag;
			if (this.NHDDPGADJPJ)
			{
				flag = this.voiceRecorder != null && this.voiceRecorder.JLJIAFFLJDP != null && this.voiceRecorder.JLJIAFFLJDP.FPCOECKKJGP;
			}
			else
			{
				flag = this.voiceSpeaker != null && this.voiceSpeaker.AGHIPKFOMIC && PhotonVoiceNetwork.CCNBAFJLBCH == ExitGames.Client.Photon.LoadBalancing.CCNBAFJLBCH.Joined;
			}
			return !this.HBFEAFMCBBC && flag;
		}
	}

	// Token: 0x06019BC7 RID: 105415 RVA: 0x0072DFE0 File Offset: 0x0072C1E0
	public static bool IsCloseToAnyPlayer(Vector3 CIGPHKLAAOD, float PFKMOBGLKNK = 2f)
	{
		if (PFKMOBGLKNK <= Mathf.Epsilon)
		{
			return false;
		}
		float num = PFKMOBGLKNK * PFKMOBGLKNK;
		foreach (Player player in Player.All)
		{
			if (player != null && player.IIEGGLHMOBH && (CIGPHKLAAOD - player.FGLFIJLGCKD).sqrMagnitude <= num)
			{
				return true;
			}
		}
		return false;
	}

	// Token: 0x06019BC8 RID: 105416 RVA: 0x0072E084 File Offset: 0x0072C284
	private void LLECGIDBBJG()
	{
		this.OCFAIFCGJJF = SingletonMonoBehaviour<SettingsManager>.NCKMBFBMBFM.GetIgnoreBufferSize(this.EAJABOECGNI);
	}

	// Token: 0x06019BC9 RID: 105417 RVA: 0x0072E09C File Offset: 0x0072C29C
	private void FDKCCPJKFDA(bool KCMKALAMJGK)
	{
		this.PBMAODCJHIH.enabled = KCMKALAMJGK;
		this.PIGACHDDMNA.enabled = KCMKALAMJGK;
		this.CEKBCIBCMGP.enabled = KCMKALAMJGK;
		this.HGALPPFDCIO.enabled = KCMKALAMJGK;
	}

	// Token: 0x06019BCA RID: 105418 RVA: 0x0072E0D0 File Offset: 0x0072C2D0
	public static bool OHCBAMAFIEO(Vector3 CIGPHKLAAOD, float PFKMOBGLKNK = 2f)
	{
		if (PFKMOBGLKNK <= Mathf.Epsilon)
		{
			return true;
		}
		float num = PFKMOBGLKNK * PFKMOBGLKNK;
		foreach (Player player in Player.All)
		{
			if (player != null && player.IIEGGLHMOBH && (CIGPHKLAAOD - player.FGLFIJLGCKD).sqrMagnitude <= num)
			{
				return true;
			}
		}
		return true;
	}

	// Token: 0x06019BCB RID: 105419 RVA: 0x0072E174 File Offset: 0x0072C374
	public static void SetPlatformPlayerId(PlatformManager.JNJEBIDGBNH ICKDNGMMBME, ulong MAEICDMIBCD)
	{
		HCLNFEIGLJP.GEPKBKIEBOM<PlatformManager.JNJEBIDGBNH>("Platform", ICKDNGMMBME);
		HCLNFEIGLJP.GEPKBKIEBOM<ulong>("PlatformId", MAEICDMIBCD);
	}

	// Token: 0x17000B84 RID: 2948
	// (get) Token: 0x06019BCC RID: 105420 RVA: 0x0072E18C File Offset: 0x0072C38C
	// (set) Token: 0x06019C19 RID: 105497 RVA: 0x0072F57C File Offset: 0x0072D77C
	public GameObject LBMGHLBBKBJ { get; private set; }

	// Token: 0x06019BCD RID: 105421 RVA: 0x0072E194 File Offset: 0x0072C394
	public float OGDCLJMCKLD()
	{
		return this.IBGGKPFNBKG.Peek();
	}

	// Token: 0x06019BCE RID: 105422 RVA: 0x0072E1A4 File Offset: 0x0072C3A4
	private void DLHPBAMGOHC(PlayerHand GAEKGDCFOJM, Tool ENBMEDIFBLM)
	{
		PlayerHand.HMMEBFHABKA type = GAEKGDCFOJM.EEAOGJHMFII;
		if (this.GetOtherHand(type).OOIMAEHGBIC != null)
		{
			return;
		}
		if (GAEKGDCFOJM != this.MONEMFCPHDE)
		{
			this.MONEMFCPHDE = GAEKGDCFOJM;
		}
	}

	// Token: 0x06019BCF RID: 105423 RVA: 0x0072E1E8 File Offset: 0x0072C3E8
	private void HDNBFPPDIMP()
	{
		if (!this.NHDDPGADJPJ)
		{
			this.IJPGLAKCCPN.SetFilterType(this.PFGLMBNKPCO);
		}
	}

	// Token: 0x06019BD0 RID: 105424 RVA: 0x0072E208 File Offset: 0x0072C408
	public PlayerModeration OHPLKCBJFEG()
	{
		return this.playerModeration;
	}

	// Token: 0x06019BD1 RID: 105425 RVA: 0x0072E210 File Offset: 0x0072C410
	public PlayerProgression FCDKACGKLHM()
	{
		return this.playerProgression;
	}

	// Token: 0x06019BD2 RID: 105426 RVA: 0x0072E218 File Offset: 0x0072C418
	public PlayerLocomotion HDDCIBBMPOD()
	{
		return this.playerLocomotion;
	}

	// Token: 0x06019BD3 RID: 105427 RVA: 0x0072E220 File Offset: 0x0072C420
	public void Despawn()
	{
		this.DespawnLocal(false, false);
	}

	// Token: 0x06019BD4 RID: 105428 RVA: 0x0072E22C File Offset: 0x0072C42C
	public PlayerHand GetHand(PlayerHand.HMMEBFHABKA HPCOKMAPCHB)
	{
		PlayerHand playerHand = null;
		if (HPCOKMAPCHB != PlayerHand.HMMEBFHABKA.Left)
		{
			if (HPCOKMAPCHB == PlayerHand.HMMEBFHABKA.Right)
			{
				playerHand = this.KEJBPANGFKK;
			}
		}
		else
		{
			playerHand = this.BGIBHPOALJG;
		}
		return playerHand;
	}

	// Token: 0x17000B9A RID: 2970
	// (get) Token: 0x06019BD5 RID: 105429 RVA: 0x0072E268 File Offset: 0x0072C468
	// (set) Token: 0x06019C15 RID: 105493 RVA: 0x0072F4FC File Offset: 0x0072D6FC
	public Quaternion LMALFJDHFAJ { get; private set; }

	// Token: 0x17000B72 RID: 2930
	// (get) Token: 0x06019BD6 RID: 105430 RVA: 0x0072E270 File Offset: 0x0072C470
	public PlayerProgression BJOBAMFKLGM
	{
		get
		{
			return this.playerProgression;
		}
	}

	// Token: 0x06019BD7 RID: 105431 RVA: 0x0072E278 File Offset: 0x0072C478
	private bool FACNGBJIIMM(Vector3 MIKPIBIENPH)
	{
		TeleportRestriction teleportRestriction = null;
		TeleportationPortal teleportationPortal = null;
		bool flag = false;
		int num = 159804416;
		int num2 = Physics.SphereCastNonAlloc(new Ray(MIKPIBIENPH, Vector3.down), this.outOfBoundsSpherecastRadius, Player.OKNPGANHGIH, this.outOfBoundsSpherecastHeight, num, QueryTriggerInteraction.Collide);
		bool flag2 = false;
		for (int i = 0; i < num2; i++)
		{
			if (ParabolicPointer.ColliderOnTeleportRegion(Player.OKNPGANHGIH[i].collider, ref teleportRestriction, ref teleportationPortal, ref flag) && flag && (teleportRestriction == null || teleportRestriction.JHLBKOMAGHD))
			{
				flag2 = true;
				break;
			}
		}
		return flag2;
	}

	// Token: 0x17000B6F RID: 2927
	// (get) Token: 0x06019BD8 RID: 105432 RVA: 0x0072E318 File Offset: 0x0072C518
	public PlayerChaperone FHFGGJIAIDE
	{
		get
		{
			return this.playerChaperone;
		}
	}

	// Token: 0x06019BD9 RID: 105433 RVA: 0x0072E320 File Offset: 0x0072C520
	public static Player GetTooClosePlayer(Vector3 AAOGGNMHJBB)
	{
		if (Player.LocalPlayer != null)
		{
			foreach (LNJFBGIBLHA lnjfbgiblha in IHFKMIAHBFP.EFDADFDIIIJ)
			{
				Player player = lnjfbgiblha.JHJGDFHNBLO();
				if (player != null)
				{
					float magnitude = (player.FGLFIJLGCKD - AAOGGNMHJBB).magnitude;
					if (magnitude <= player.GADNKIIKPPD.AHJNNLBMCIP)
					{
						return player;
					}
				}
			}
		}
		return null;
	}

	// Token: 0x06019BDA RID: 105434 RVA: 0x0072E39C File Offset: 0x0072C59C
	public PlayerHand GetHand(int HPCOKMAPCHB)
	{
		return this.GetHand((PlayerHand.HMMEBFHABKA)HPCOKMAPCHB);
	}

	// Token: 0x06019BDB RID: 105435 RVA: 0x0072E3A8 File Offset: 0x0072C5A8
	public void PopAfkKickToIntroTimeout()
	{
		this.IACLFMLCJDL.Pop();
	}

	// Token: 0x06019BDC RID: 105436 RVA: 0x0072E3B8 File Offset: 0x0072C5B8
	private void Update()
	{
		bool isLocal = this.NHDDPGADJPJ;
		if (isLocal)
		{
			this.MNAMPGHLECC();
			this.head.BOLBONELAEF.CIGPHKLAAOD = SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.KPGFMCHFLBM.transform.position;
			this.head.BOLBONELAEF.IJGPPOIJDKO = SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.KPGFMCHFLBM.transform.rotation;
			this.LGKEDKFPDHG();
		}
		this.CFKJBPKPJCM();
		if (isLocal)
		{
			this.OECFMIPHGDN();
		}
		this.HGALPPFDCIO.HBNAMKHAEEO = this.LHKNKHPEPCJ;
		this.voiceObject.transform.position = this.head.transform.position;
		this.voiceObject.transform.rotation = this.head.transform.rotation;
		this.LJNKFFDLKJG();
		if (isLocal && Time.time >= this.IBEMNCLJANE)
		{
			this.LGEHCGIGNBO();
		}
	}

	// Token: 0x06019BDD RID: 105437 RVA: 0x0072E4AC File Offset: 0x0072C6AC
	private void IMNFPGPBKDM()
	{
		bool flag = !IHFKMIAHBFP.HCOPIOOOFMN && IHFKMIAHBFP.FFPDCNMDEEO && RecRoomSceneManager.LEILGOOHEOI() != null && !SessionManager.LBLKKPKBOGD && !SessionManager.DEHIOHBDMEK && !SessionManager.FMECIDNEBGM;
		if (flag)
		{
			float num = Time.unscaledTime - this.LNGNNJGPDNE;
			this.DFHCKNMJADN = SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.ALDINPCHOBI();
			if (SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.HBKDHPCDFGD)
			{
				this.LNGNNJGPDNE = Time.unscaledTime;
				this.HHHOLAGBDBA = -1;
			}
			else if (num > this.ONOLOLOGPED)
			{
				RecRoomSceneManager.NCKMBFBMBFM.BootLocalPlayerToDormRoom(this.afkIntroMessage, SessionManager.PEECLKHFOCH.CHEAT);
				NECCOFKHCAA.MMOPDEJGCBD(num);
				this.LNGNNJGPDNE = Time.unscaledTime;
			}
			else if (num > this.DJNACAKPNEL)
			{
				int num2 = Mathf.CeilToInt(this.ONOLOLOGPED - num);
				if (this.HHHOLAGBDBA != num2)
				{
					SingletonMonoBehaviour<ScreenSpaceNotificationManager>.NCKMBFBMBFM.DHMODMENLCE(ScreenSpaceNotificationManager.DBNGPDFKLEK.Vital, this.afkWarningMessageTitle, this.NLMBOFIPFMH + num2.ToString(), 1900f, null, true);
					this.HHHOLAGBDBA = num2;
				}
			}
		}
		else
		{
			this.LNGNNJGPDNE = Time.unscaledTime;
			this.HHHOLAGBDBA = -1;
		}
	}

	// Token: 0x06019BDE RID: 105438 RVA: 0x0072E5F0 File Offset: 0x0072C7F0
	public static GameObject INIIJLHDADI(GameObject MKMCHJFIONM)
	{
		GameObject gameObject = null;
		SkinnedMeshRenderer componentInChildren = MKMCHJFIONM.GetComponentInChildren<SkinnedMeshRenderer>();
		if (componentInChildren && componentInChildren.shadowCastingMode != ShadowCastingMode.Off)
		{
			gameObject = new GameObject();
			gameObject.name = string.Format("y", MKMCHJFIONM.name);
			gameObject.transform.SetParent(MKMCHJFIONM.transform);
			gameObject.transform.localPosition = Vector3.zero;
			gameObject.transform.localRotation = Quaternion.identity;
			gameObject.transform.localScale = Vector3.one;
			gameObject.layer = 12;
			gameObject.tag = "scale";
			SkinnedMeshRenderer skinnedMeshRenderer = gameObject.AddComponent<SkinnedMeshRenderer>();
			skinnedMeshRenderer.shadowCastingMode = (ShadowCastingMode)5;
			skinnedMeshRenderer.sharedMesh = componentInChildren.sharedMesh;
			skinnedMeshRenderer.bones = componentInChildren.bones;
			skinnedMeshRenderer.rootBone = componentInChildren.rootBone;
			skinnedMeshRenderer.materials = componentInChildren.materials;
			skinnedMeshRenderer.quality = componentInChildren.quality;
			skinnedMeshRenderer.updateWhenOffscreen = componentInChildren.updateWhenOffscreen;
			skinnedMeshRenderer.skinnedMotionVectors = componentInChildren.skinnedMotionVectors;
			skinnedMeshRenderer.localBounds = componentInChildren.localBounds;
			for (int i = 0; i < componentInChildren.sharedMesh.blendShapeCount; i++)
			{
				skinnedMeshRenderer.SetBlendShapeWeight(i, componentInChildren.GetBlendShapeWeight(i));
			}
		}
		return gameObject;
	}

	// Token: 0x06019BDF RID: 105439 RVA: 0x0072E728 File Offset: 0x0072C928
	public PlayerHand GetOtherHand(PlayerHand.HMMEBFHABKA PBBIFICIMFM)
	{
		PlayerHand playerHand = null;
		if (PBBIFICIMFM != PlayerHand.HMMEBFHABKA.Left)
		{
			if (PBBIFICIMFM == PlayerHand.HMMEBFHABKA.Right)
			{
				playerHand = this.BGIBHPOALJG;
			}
		}
		else
		{
			playerHand = this.KEJBPANGFKK;
		}
		if (playerHand.ILGCMIFHJOJ == PlayerHand.AKCKIFINDJE.NOT_CONNECTED)
		{
			playerHand = this.GetHand(PBBIFICIMFM);
		}
		return playerHand;
	}

	// Token: 0x17000B7B RID: 2939
	// (get) Token: 0x06019BE0 RID: 105440 RVA: 0x0072E778 File Offset: 0x0072C978
	public Texture2D DFIICNHNHNL
	{
		get
		{
			return this.defaultProfileImage;
		}
	}

	// Token: 0x140000E2 RID: 226
	// (add) Token: 0x06019BE1 RID: 105441 RVA: 0x0072E780 File Offset: 0x0072C980
	// (remove) Token: 0x06019C8A RID: 105610 RVA: 0x00730A80 File Offset: 0x0072EC80
	[field: DebuggerBrowsable(DebuggerBrowsableState.Never)]
	public event Action<bool> MBEFNKNJEPH;

	// Token: 0x06019BE2 RID: 105442 RVA: 0x0072E7B8 File Offset: 0x0072C9B8
	public void LNLCAKNIMAF(Action<bool> NOBAPCOKFIL)
	{
		Action<bool> action = this.MBEFNKNJEPH;
		Action<bool> action2;
		do
		{
			action2 = action;
			action = Interlocked.CompareExchange<Action<bool>>(ref this.MBEFNKNJEPH, (Action<bool>)Delegate.Remove(action2, NOBAPCOKFIL), action);
		}
		while (action != action2);
	}

	// Token: 0x17000B96 RID: 2966
	// (get) Token: 0x06019BE3 RID: 105443 RVA: 0x0072E7F0 File Offset: 0x0072C9F0
	public float ONOLOLOGPED
	{
		get
		{
			return this.IACLFMLCJDL.Peek();
		}
	}

	// Token: 0x17000B95 RID: 2965
	// (get) Token: 0x06019BE4 RID: 105444 RVA: 0x0072E800 File Offset: 0x0072CA00
	public string FMPONAKDOAB
	{
		get
		{
			return (this.DPAHOMFBOFE.Count <= 0) ? string.Empty : this.DPAHOMFBOFE.Peek();
		}
	}

	// Token: 0x06019BE5 RID: 105445 RVA: 0x0072E828 File Offset: 0x0072CA28
	public float GEBOCHEIJCE()
	{
		return this.IBGGKPFNBKG.Peek();
	}

	// Token: 0x17000B88 RID: 2952
	// (get) Token: 0x06019BE6 RID: 105446 RVA: 0x0072E838 File Offset: 0x0072CA38
	// (set) Token: 0x06019C6D RID: 105581 RVA: 0x00730460 File Offset: 0x0072E660
	public EAJABOECGNI EAJABOECGNI
	{
		get
		{
			return this.LCOKAJELKDA.CPIBGJLHLBL();
		}
		set
		{
			this.LCOKAJELKDA.MEAINJPIECA(value);
		}
	}

	// Token: 0x06019BE7 RID: 105447 RVA: 0x0072E848 File Offset: 0x0072CA48
	public void GGLCGLOFLLA(Action<bool> NOBAPCOKFIL)
	{
		Action<bool> action = this.MBEFNKNJEPH;
		Action<bool> action2;
		do
		{
			action2 = action;
			action = Interlocked.CompareExchange<Action<bool>>(ref this.MBEFNKNJEPH, (Action<bool>)Delegate.Remove(action2, NOBAPCOKFIL), action);
		}
		while (action != action2);
	}

	// Token: 0x17000B80 RID: 2944
	// (get) Token: 0x06019BE8 RID: 105448 RVA: 0x0072E880 File Offset: 0x0072CA80
	public Transform INFOKIDJHMG
	{
		get
		{
			return this.trackingSpaceOrigin;
		}
	}

	// Token: 0x17000B64 RID: 2916
	// (get) Token: 0x06019BE9 RID: 105449 RVA: 0x0072E888 File Offset: 0x0072CA88
	public static float MBHIHIEEFKN
	{
		get
		{
			return Player.FCEGFOFFLJJ + Player.BHMHGMCEBDK;
		}
	}

	// Token: 0x06019BEA RID: 105450 RVA: 0x0072E898 File Offset: 0x0072CA98
	public void AFHPFHMNNID()
	{
		if (this.HMAHAJNCJKH())
		{
			this.KPLHGNDKGGM().JPLBPKAACFB(true, null, null, true);
		}
		this.GADNKIIKPPD.BENJOEIPOCN();
		this.DPLLNDECEMP = true;
	}

	// Token: 0x06019BEB RID: 105451 RVA: 0x0072E8E4 File Offset: 0x0072CAE4
	public void HMEANKHDDJP()
	{
		this.IBGGKPFNBKG.Pop();
	}

	// Token: 0x06019BEC RID: 105452 RVA: 0x0072E8F4 File Offset: 0x0072CAF4
	public ulong CNDAGKMAKIE()
	{
		return this.NGIIAOJHKAE.CPIBGJLHLBL();
	}

	// Token: 0x06019BED RID: 105453 RVA: 0x0072E904 File Offset: 0x0072CB04
	private void LJNKFFDLKJG()
	{
		if (this.NHDDPGADJPJ && SingletonMonoBehaviour<SettingsManager>.NCKMBFBMBFM.FPEGHDDDHCC == FPEGHDDDHCC.PushToTalk && this.DFHCKNMJADN)
		{
			bool flag = this.BGIBHPOALJG != null && this.BGIBHPOALJG.JKNCHBFALCJ != null && this.BGIBHPOALJG.ILGCMIFHJOJ != PlayerHand.AKCKIFINDJE.NOT_CONNECTED && this.BGIBHPOALJG.JKNCHBFALCJ.AMNICMMDJJO;
			bool flag2 = this.KEJBPANGFKK != null && this.KEJBPANGFKK.JKNCHBFALCJ != null && this.KEJBPANGFKK.ILGCMIFHJOJ != PlayerHand.AKCKIFINDJE.NOT_CONNECTED && this.KEJBPANGFKK.JKNCHBFALCJ.AMNICMMDJJO;
			bool flag3 = flag || flag2;
			bool flag4 = this.SetMuteFlag(Player.PPELPGLINBB.PTT_MUTE, !flag3);
			if (flag4)
			{
				this.IJPGLAKCCPN.OnPushToTalk(flag3);
			}
		}
	}

	// Token: 0x17000B89 RID: 2953
	// (get) Token: 0x06019BEE RID: 105454 RVA: 0x0072E9F8 File Offset: 0x0072CBF8
	// (set) Token: 0x06019C20 RID: 105504 RVA: 0x0072F674 File Offset: 0x0072D874
	public IgnoreBufferSize OCFAIFCGJJF { get; private set; }

	// Token: 0x06019BEF RID: 105455 RVA: 0x0072EA00 File Offset: 0x0072CC00
	public Coroutine SpawnLocal()
	{
		if (!this.NHDDPGADJPJ)
		{
			global::UnityEngine.Debug.LogError("Player.SpawnLocal() can only be called on the LocalPlayer!");
		}
		this.DPLLNDECEMP = true;
		this.GADNKIIKPPD.OnPlayerSpawn();
		base.OMNGGJICBBI.RPC("RpcBroadcastSpawnPlayer", IHCPDNLJMMD.Others, new object[0]);
		IHFKMIAHBFP.CJLBNLENHLI();
		if (Player.PlayerSpawnEvent != null)
		{
			Player.PlayerSpawnEvent.Invoke(this);
		}
		if (Player.LocalPlayerSpawnEvent != null)
		{
			Player.LocalPlayerSpawnEvent.Invoke();
		}
		RaycastHit raycastHit;
		if (!Physics.Raycast(this.BGOGBEPJGPJ.transform.position + new Vector3(0f, 2f, 0f), Vector3.down, out raycastHit, 7f, 18433))
		{
			global::UnityEngine.Debug.LogErrorFormat("Player.SpawnLocal() - Player spawned without static geometry to stand on! CurrentScene: {0}", new object[] { RecRoomSceneManager.HHJEDBFEAFP });
		}
		SingletonMonoBehaviour<SessionManager>.NCKMBFBMBFM.LocalPlayerSpawned();
		return SingletonMonoBehaviour<CameraFade>.NCKMBFBMBFM.Fade(true, false, false, 0f);
	}

	// Token: 0x06019BF0 RID: 105456 RVA: 0x0072EAF4 File Offset: 0x0072CCF4
	public PlayerHead HFDJIFFPEFM()
	{
		return this.head;
	}

	// Token: 0x06019BF1 RID: 105457 RVA: 0x0072EAFC File Offset: 0x0072CCFC
	public void OnRecRoomSceneManagerDestroyed()
	{
		this.ReleaseToolsFromBothHands();
	}

	// Token: 0x06019BF2 RID: 105458 RVA: 0x0072EB04 File Offset: 0x0072CD04
	public bool POBPBLHJKIJ()
	{
		return this.DPLLNDECEMP && this.BBIJDJPGPKA && Time.time - this.DEOBJENCBGG < 1605f;
	}

	// Token: 0x17000B78 RID: 2936
	// (get) Token: 0x06019BF3 RID: 105459 RVA: 0x0072EB38 File Offset: 0x0072CD38
	public PlayerBody NGFPOMIFLMF
	{
		get
		{
			return this.body;
		}
	}

	// Token: 0x17000B8F RID: 2959
	// (get) Token: 0x06019BF4 RID: 105460 RVA: 0x0072EB40 File Offset: 0x0072CD40
	public CSteamID AMJFOJIDALF
	{
		get
		{
			return (this.GHCKJIELEDP != PlatformManager.JNJEBIDGBNH.STEAM) ? CSteamID.Nil : new CSteamID(this.AMHOBPCPMCL);
		}
	}

	// Token: 0x06019BF5 RID: 105461 RVA: 0x0072EB64 File Offset: 0x0072CD64
	public void LGODIMNHFHG()
	{
		this.DPLLNDECEMP = true;
		this.CBLLEJGBAAM().OnPlayerSpawn();
		if (Player.PlayerSpawnEvent != null)
		{
			Player.PlayerSpawnEvent.Invoke(this);
		}
		if (this.HMAHAJNCJKH())
		{
			this.ACAJJPKPKBH.INPNOAALNFI(false, null, null, false);
		}
	}

	// Token: 0x06019BF6 RID: 105462 RVA: 0x0072EBC4 File Offset: 0x0072CDC4
	public static void SavePlayerIgnored(long GKPEOHGOGCF, bool KIMJICHGKHE)
	{
		Player player = Player.FindLocalPlayer(GKPEOHGOGCF);
		if (player != null)
		{
		}
		bool flag;
		if (KIMJICHGKHE)
		{
			flag = GLGMPGPNNBP.GEIJPGNENMM(GKPEOHGOGCF, null);
		}
		else
		{
			flag = GLGMPGPNNBP.JNDKFBHOLKM(GKPEOHGOGCF, null);
		}
		if (flag)
		{
			NECCOFKHCAA.OPEHMABCNBP(GKPEOHGOGCF, KIMJICHGKHE);
		}
	}

	// Token: 0x06019BF7 RID: 105463 RVA: 0x0072EC10 File Offset: 0x0072CE10
	private void LGKEDKFPDHG()
	{
		bool gdpfnajdlpd = this.GDPFNAJDLPD;
		Vector3 vector;
		if (this.WorldCollisionMode != Player.DHIHPJGOAJJ.DISABLED && this.AONCNCOIGAC(out vector))
		{
			this.GDPFNAJDLPD = true;
			this.PAGDMPLDHNM = Time.time;
			this.GADNKIIKPPD.MoveCameraRig(this.FGLFIJLGCKD + vector, false);
		}
		else if (Time.time - this.PAGDMPLDHNM >= 0.2f)
		{
			this.GDPFNAJDLPD = false;
		}
		if (gdpfnajdlpd != this.GDPFNAJDLPD && SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM != null && SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.EKGFLDNPEJL != null)
		{
			if (this.GDPFNAJDLPD)
			{
				SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.EKGFLDNPEJL.StartWorldCollisionVignette(0.02f);
			}
			else
			{
				SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.EKGFLDNPEJL.StopWorldCollisionVignette(0.1f);
			}
		}
	}

	// Token: 0x06019BF8 RID: 105464 RVA: 0x0072ECF4 File Offset: 0x0072CEF4
	public void PopLocalPlayerStatus()
	{
		this.DPAHOMFBOFE.Pop();
	}

	// Token: 0x06019BF9 RID: 105465 RVA: 0x0072ED04 File Offset: 0x0072CF04
	public PlayerHand DGEOJLGFGNG()
	{
		return this.leftHand;
	}

	// Token: 0x06019BFA RID: 105466 RVA: 0x0072ED0C File Offset: 0x0072CF0C
	protected override void OnDestroy()
	{
		base.OnDestroy();
		if (this.NHDDPGADJPJ)
		{
			Player.LocalPlayerExists = false;
			Player.LocalPlayer = null;
			if (SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM != null && SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.EKGFLDNPEJL != null)
			{
				SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.EKGFLDNPEJL.StopWorldCollisionVignette(0.1f);
			}
		}
		else
		{
			DynamicUpdateManager.NCKMBFBMBFM.UnregisterObject("Player", base.gameObject);
		}
		if (this.LBMGHLBBKBJ != null)
		{
			global::UnityEngine.Object.Destroy(this.LBMGHLBBKBJ);
		}
		this.MBEFNKNJEPH -= this.NOCJEIEOACD;
		Player.All.Remove(this);
		if (Player.OnPlayerDestroyed != null)
		{
			Player.OnPlayerDestroyed.Invoke(this);
		}
		IHFKMIAHBFP.GFFDICBLOFJ -= new Action<LNJFBGIBLHA>(this.OnPhotonPlayerConnected);
		IHFKMIAHBFP.DHLJAODEIEA -= new Action<LNJFBGIBLHA>(this.OnPhotonPlayerDisconnected);
		LNPBGKENDPK.HBBDEELDEMH -= this.BMNADFIKDOE;
		GLGMPGPNNBP.GGGHJGKGLOE -= this.DHJLDKNHAPH;
	}

	// Token: 0x06019BFB RID: 105467 RVA: 0x0072EE30 File Offset: 0x0072D030
	public bool FMIODHIDJJP()
	{
		return this.LMDEFPDOGKA != Player.PPELPGLINBB.RELATIONSHIP_MUTE;
	}

	// Token: 0x06019BFC RID: 105468 RVA: 0x0072EE40 File Offset: 0x0072D040
	private void OnPhotonPlayerDisconnected(LNJFBGIBLHA JBEPFCIKALP)
	{
		this.EDFMCBBELAM = true;
	}

	// Token: 0x17000B8B RID: 2955
	// (get) Token: 0x06019BFD RID: 105469 RVA: 0x0072EE4C File Offset: 0x0072D04C
	public LNJFBGIBLHA LNJFBGIBLHA
	{
		get
		{
			return (!(base.OMNGGJICBBI != null)) ? null : base.OMNGGJICBBI.HKLENNJOICH;
		}
	}

	// Token: 0x06019BFE RID: 105470 RVA: 0x0072EE70 File Offset: 0x0072D070
	public void PopAfkWarningStartTimeout()
	{
		this.IBGGKPFNBKG.Pop();
	}

	// Token: 0x06019BFF RID: 105471 RVA: 0x0072EE80 File Offset: 0x0072D080
	public static void AAFOEFHFBBI(PlatformManager.JNJEBIDGBNH ICKDNGMMBME, ulong MAEICDMIBCD)
	{
		HCLNFEIGLJP.GEPKBKIEBOM<PlatformManager.JNJEBIDGBNH>("{0}v2/uploadsaved", ICKDNGMMBME);
		HCLNFEIGLJP.GEPKBKIEBOM<ulong>("/home", MAEICDMIBCD);
	}

	// Token: 0x17000B9C RID: 2972
	// (get) Token: 0x06019C00 RID: 105472 RVA: 0x0072EE98 File Offset: 0x0072D098
	// (set) Token: 0x06019C88 RID: 105608 RVA: 0x00730954 File Offset: 0x0072EB54
	private bool DPLLNDECEMP
	{
		get
		{
			return this.HIBPBKGMMLG;
		}
		set
		{
			this.HIBPBKGMMLG = value;
			if (!this.NHDDPGADJPJ && this.MBEFNKNJEPH != null)
			{
				this.MBEFNKNJEPH(this.IIEGGLHMOBH);
			}
		}
	}

	// Token: 0x06019C01 RID: 105473 RVA: 0x0072EEA0 File Offset: 0x0072D0A0
	private void FGADMCKGCIP(bool NOBAPCOKFIL)
	{
		this.<JIGCCJJFFCC>k__BackingField = NOBAPCOKFIL;
	}

	// Token: 0x06019C02 RID: 105474 RVA: 0x0072EEAC File Offset: 0x0072D0AC
	private bool LFJHGEDONPM(Vector3 HBEIOKIPCFB, Quaternion MACBJLGIODA, float EEDEPEEHOLF, float MAMIHILGFJI, int DBIOCLFPOBM, Collider[] JJADIOKDICA, out Vector3 AEONOMINPGG)
	{
		Player.HEEECBPLLEE.radius = EEDEPEEHOLF + this.collisionHeadEpsilon;
		Player.HEEECBPLLEE.height = MAMIHILGFJI;
		bool flag = false;
		AEONOMINPGG = Vector3.zero;
		for (int i = 0; i < DBIOCLFPOBM; i++)
		{
			Vector3 vector;
			float num;
			if (Physics.ComputePenetration(Player.HEEECBPLLEE, HBEIOKIPCFB, MACBJLGIODA, JJADIOKDICA[i], JJADIOKDICA[i].transform.position, JJADIOKDICA[i].transform.rotation, out vector, out num))
			{
				flag = true;
				Vector3 vector2 = vector * Mathf.Max(this.minHeadCollisionDepenetrationDistance, num - this.collisionHeadEpsilon);
				AEONOMINPGG += Vector3.ProjectOnPlane(vector2, Vector3.up);
			}
		}
		return flag;
	}

	// Token: 0x06019C03 RID: 105475 RVA: 0x0072EF6C File Offset: 0x0072D16C
	private void CGICDANJGLP(bool KCMKALAMJGK)
	{
		this.PBMAODCJHIH.enabled = KCMKALAMJGK;
		this.PIGACHDDMNA.enabled = KCMKALAMJGK;
		this.CEKBCIBCMGP.enabled = KCMKALAMJGK;
		this.HGALPPFDCIO.enabled = KCMKALAMJGK;
	}

	// Token: 0x06019C04 RID: 105476 RVA: 0x0072EFA0 File Offset: 0x0072D1A0
	public PlayerHand IPHIIAOHINN(PlayerHand.HMMEBFHABKA PBBIFICIMFM)
	{
		PlayerHand playerHand = null;
		if (PBBIFICIMFM != PlayerHand.HMMEBFHABKA.Left)
		{
			if (PBBIFICIMFM == PlayerHand.HMMEBFHABKA.Left)
			{
				playerHand = this.DGEOJLGFGNG();
			}
		}
		else
		{
			playerHand = this.KEJBPANGFKK;
		}
		if (playerHand.ILGCMIFHJOJ == PlayerHand.AKCKIFINDJE.NOT_CONNECTED)
		{
			playerHand = this.GetHand(PBBIFICIMFM);
		}
		return playerHand;
	}

	// Token: 0x17000B6D RID: 2925
	// (get) Token: 0x06019C05 RID: 105477 RVA: 0x0072EFF0 File Offset: 0x0072D1F0
	public PlayerLocomotion GADNKIIKPPD
	{
		get
		{
			return this.playerLocomotion;
		}
	}

	// Token: 0x17000B76 RID: 2934
	// (get) Token: 0x06019C06 RID: 105478 RVA: 0x0072EFF8 File Offset: 0x0072D1F8
	public AnimateInOut ACAJJPKPKBH
	{
		get
		{
			return this.animateInOut;
		}
	}

	// Token: 0x06019C07 RID: 105479 RVA: 0x0072F000 File Offset: 0x0072D200
	public static void SpawnLocalPlayerAt(Vector3 CIGPHKLAAOD, Quaternion IJGPPOIJDKO)
	{
		if (!Player.LocalPlayerExists)
		{
			Vector3 vector = SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.transform.InverseTransformPoint(SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.KPGFMCHFLBM.transform.position);
			Vector3 vector2 = SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.transform.InverseTransformPoint(SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.CKKHCDNOAHJ.transform.position);
			Vector3 vector3 = SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.transform.InverseTransformPoint(SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.AAJLDBOOGIM.transform.position);
			Quaternion quaternion = SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.transform.MCKNNGGGBDG(SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.KPGFMCHFLBM.transform.rotation);
			Quaternion quaternion2 = SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.transform.MCKNNGGGBDG(SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.CKKHCDNOAHJ.transform.rotation);
			Quaternion quaternion3 = SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.transform.MCKNNGGGBDG(SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.AAJLDBOOGIM.transform.rotation);
			Quaternion quaternion4 = Quaternion.identity;
			if (SingletonMonoBehaviour<PlatformManager>.NCKMBFBMBFM.LPFJJFHGLDP == PlatformManager.EOKBLHACIHA.THREE_SIXTY_DEGREE)
			{
				quaternion4 = Quaternion.Euler(0f, quaternion.eulerAngles.y, 0f);
			}
			object[] array = new object[] { vector, quaternion, vector2, quaternion2, vector3, quaternion3, CIGPHKLAAOD, IJGPPOIJDKO };
			IJGPPOIJDKO *= Quaternion.Inverse(quaternion4);
			CIGPHKLAAOD -= IJGPPOIJDKO * SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.LHBELLMJDID;
			IHFKMIAHBFP.ICHFNPOCOEJ("[Player]", CIGPHKLAAOD, IJGPPOIJDKO, 0, array);
		}
	}

	// Token: 0x06019C08 RID: 105480 RVA: 0x0072F1B4 File Offset: 0x0072D3B4
	public IEnumerator ABMCGIBOGIA(Vector3 CIGPHKLAAOD, Quaternion IJGPPOIJDKO, bool DGMJGABBCFP, int CJNMGLONBAC, string MCENGEGABKD, int LPMDEEDBMMP, string DILOKKAHNEI, bool DMDPGGPKEMN)
	{
		yield return this.DespawnLocal(false, DGMJGABBCFP);
		PlayerLocomotion.BLICPEPKKHI blicpepkkhi = PlayerLocomotion.BLICPEPKKHI.PLAYER_SPACE;
		if (SingletonMonoBehaviour<PlatformManager>.NCKMBFBMBFM.LPFJJFHGLDP == PlatformManager.EOKBLHACIHA.ONE_EIGHTY_DEGREE)
		{
			blicpepkkhi = PlayerLocomotion.BLICPEPKKHI.TRACKING_SPACE;
		}
		this.GADNKIIKPPD.MoveCameraRig(CIGPHKLAAOD, IJGPPOIJDKO * Vector3.forward, true, blicpepkkhi, true);
		this.DINLMMOJAPK = CIGPHKLAAOD;
		this.LMALFJDHFAJ = IJGPPOIJDKO;
		yield return this.SpawnLocal();
		this.IGJGFFDGIMH(this.BGIBHPOALJG, CJNMGLONBAC, MCENGEGABKD);
		this.IGJGFFDGIMH(this.KEJBPANGFKK, LPMDEEDBMMP, DILOKKAHNEI);
		if (DMDPGGPKEMN)
		{
			SingletonMonoBehaviour<GiftManager>.NCKMBFBMBFM.StartReceiveGiftsCoroutine();
		}
		yield break;
	}

	// Token: 0x17000B97 RID: 2967
	// (get) Token: 0x06019C09 RID: 105481 RVA: 0x0072F20C File Offset: 0x0072D40C
	public float DJNACAKPNEL
	{
		get
		{
			return this.IBGGKPFNBKG.Peek();
		}
	}

	// Token: 0x06019C0A RID: 105482 RVA: 0x0072F21C File Offset: 0x0072D41C
	public Coroutine DespawnLocal(bool JJIACNOGAEC, bool DGMJGABBCFP = true)
	{
		if (!this.NHDDPGADJPJ)
		{
			global::UnityEngine.Debug.LogError("Player.DespawnLocal() can only be called on the LocalPlayer!");
		}
		if (!this.DPLLNDECEMP)
		{
			return base.StartCoroutine(this.HENCEDFLABJ());
		}
		this.GADNKIIKPPD.OnPlayerDespawn();
		this.DPLLNDECEMP = false;
		if (DGMJGABBCFP)
		{
			this.ReleaseToolsFromBothHands();
		}
		base.OMNGGJICBBI.RPC("RpcBroadcastDespawnPlayer", IHCPDNLJMMD.Others, new object[0]);
		IHFKMIAHBFP.CJLBNLENHLI();
		SingletonMonoBehaviour<SessionManager>.NCKMBFBMBFM.LocalPlayerDespawned();
		return SingletonMonoBehaviour<CameraFade>.NCKMBFBMBFM.Fade(false, JJIACNOGAEC, false, 0f);
	}

	// Token: 0x06019C0B RID: 105483 RVA: 0x0072F2AC File Offset: 0x0072D4AC
	public void SetParentPlayerRoot(Transform JGJGCFPENJK)
	{
		JGJGCFPENJK.SetParent(this.LBMGHLBBKBJ.transform, true);
	}

	// Token: 0x17000B8C RID: 2956
	// (get) Token: 0x06019C0C RID: 105484 RVA: 0x0072F2C0 File Offset: 0x0072D4C0
	// (set) Token: 0x06019C28 RID: 105512 RVA: 0x0072F71C File Offset: 0x0072D91C
	public long NAJBCPFNBAB { get; private set; }

	// Token: 0x17000B7E RID: 2942
	// (get) Token: 0x06019C0D RID: 105485 RVA: 0x0072F2C8 File Offset: 0x0072D4C8
	// (set) Token: 0x06019C2F RID: 105519 RVA: 0x0072F838 File Offset: 0x0072DA38
	public bool MFFGGGFFDAD
	{
		get
		{
			return this.DPLLNDECEMP && this.BBIJDJPGPKA && Time.time - this.DEOBJENCBGG >= 1f;
		}
		set
		{
			if (value != this.BBIJDJPGPKA)
			{
				this.BBIJDJPGPKA = value;
				if (!this.BBIJDJPGPKA)
				{
					this.ReleaseToolsFromBothHands();
				}
			}
		}
	}

	// Token: 0x06019C0E RID: 105486 RVA: 0x0072F2FC File Offset: 0x0072D4FC
	public void OEDOLGPLIDG()
	{
		this.leftHand.JKNCHBFALCJ = SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.CKKHCDNOAHJ;
		this.rightHand.JKNCHBFALCJ = SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.AAJLDBOOGIM;
	}

	// Token: 0x06019C0F RID: 105487 RVA: 0x0072F328 File Offset: 0x0072D528
	public IEnumerator RespawnLocal(Vector3 CIGPHKLAAOD, Quaternion IJGPPOIJDKO, bool DGMJGABBCFP, int CJNMGLONBAC, string MCENGEGABKD, int LPMDEEDBMMP, string DILOKKAHNEI, bool DMDPGGPKEMN)
	{
		yield return this.DespawnLocal(false, DGMJGABBCFP);
		blicpepkkhi = PlayerLocomotion.BLICPEPKKHI.PLAYER_SPACE;
		if (SingletonMonoBehaviour<PlatformManager>.NCKMBFBMBFM.LPFJJFHGLDP == PlatformManager.EOKBLHACIHA.ONE_EIGHTY_DEGREE)
		{
			blicpepkkhi = PlayerLocomotion.BLICPEPKKHI.TRACKING_SPACE;
		}
		this.GADNKIIKPPD.MoveCameraRig(CIGPHKLAAOD, IJGPPOIJDKO * Vector3.forward, true, blicpepkkhi, true);
		this.DINLMMOJAPK = CIGPHKLAAOD;
		this.LMALFJDHFAJ = IJGPPOIJDKO;
		yield return this.SpawnLocal();
		this.IGJGFFDGIMH(this.BGIBHPOALJG, CJNMGLONBAC, MCENGEGABKD);
		this.IGJGFFDGIMH(this.KEJBPANGFKK, LPMDEEDBMMP, DILOKKAHNEI);
		if (DMDPGGPKEMN)
		{
			SingletonMonoBehaviour<GiftManager>.NCKMBFBMBFM.StartReceiveGiftsCoroutine();
		}
		yield break;
	}

	// Token: 0x17000B8A RID: 2954
	// (get) Token: 0x06019C10 RID: 105488 RVA: 0x0072F380 File Offset: 0x0072D580
	public string GNLMCJKALBJ
	{
		get
		{
			return (this.LNJFBGIBLHA == null) ? "UNKNOWN" : this.LNJFBGIBLHA.KODHOHBEAOP;
		}
	}

	// Token: 0x06019C11 RID: 105489 RVA: 0x0072F3A4 File Offset: 0x0072D5A4
	public Quaternion PCDONKBIMJH()
	{
		return this.<KDDBBOHIDKP>k__BackingField;
	}

	// Token: 0x17000B6C RID: 2924
	// (get) Token: 0x06019C12 RID: 105490 RVA: 0x0072F3AC File Offset: 0x0072D5AC
	public PlayerParty NMHFBAEBEAM
	{
		get
		{
			return this.playerParty;
		}
	}

	// Token: 0x06019C13 RID: 105491 RVA: 0x0072F3B4 File Offset: 0x0072D5B4
	public static GameObject CreateFirstPersonShadowCaster(GameObject MKMCHJFIONM)
	{
		GameObject gameObject = null;
		SkinnedMeshRenderer componentInChildren = MKMCHJFIONM.GetComponentInChildren<SkinnedMeshRenderer>();
		if (componentInChildren && componentInChildren.shadowCastingMode != ShadowCastingMode.Off)
		{
			gameObject = new GameObject();
			gameObject.name = string.Format("{0} (FirstPersonShadowCaster)", MKMCHJFIONM.name);
			gameObject.transform.SetParent(MKMCHJFIONM.transform);
			gameObject.transform.localPosition = Vector3.zero;
			gameObject.transform.localRotation = Quaternion.identity;
			gameObject.transform.localScale = Vector3.one;
			gameObject.layer = 29;
			gameObject.tag = "LayerIsLocked";
			SkinnedMeshRenderer skinnedMeshRenderer = gameObject.AddComponent<SkinnedMeshRenderer>();
			skinnedMeshRenderer.shadowCastingMode = ShadowCastingMode.ShadowsOnly;
			skinnedMeshRenderer.sharedMesh = componentInChildren.sharedMesh;
			skinnedMeshRenderer.bones = componentInChildren.bones;
			skinnedMeshRenderer.rootBone = componentInChildren.rootBone;
			skinnedMeshRenderer.materials = componentInChildren.materials;
			skinnedMeshRenderer.quality = componentInChildren.quality;
			skinnedMeshRenderer.updateWhenOffscreen = componentInChildren.updateWhenOffscreen;
			skinnedMeshRenderer.skinnedMotionVectors = componentInChildren.skinnedMotionVectors;
			skinnedMeshRenderer.localBounds = componentInChildren.localBounds;
			for (int i = 0; i < componentInChildren.sharedMesh.blendShapeCount; i++)
			{
				skinnedMeshRenderer.SetBlendShapeWeight(i, componentInChildren.GetBlendShapeWeight(i));
			}
		}
		return gameObject;
	}

	// Token: 0x06019C14 RID: 105492 RVA: 0x0072F4EC File Offset: 0x0072D6EC
	public bool MutedBy(Player.PPELPGLINBB EANNKIELDCM)
	{
		return (this.LMDEFPDOGKA & EANNKIELDCM) == EANNKIELDCM;
	}

	// Token: 0x17000B69 RID: 2921
	// (get) Token: 0x06019C16 RID: 105494 RVA: 0x0072F508 File Offset: 0x0072D708
	public PlayerOutfit NMPMNBCNGBE
	{
		get
		{
			return this.playerOutfit;
		}
	}

	// Token: 0x17000B92 RID: 2962
	// (get) Token: 0x06019C17 RID: 105495 RVA: 0x0072F510 File Offset: 0x0072D710
	// (set) Token: 0x06019C39 RID: 105529 RVA: 0x0072F984 File Offset: 0x0072DB84
	public AudioManager.PFGLMBNKPCO PFGLMBNKPCO
	{
		get
		{
			return this.BEPFHMHDCFJ.CPIBGJLHLBL();
		}
		set
		{
			this.BEPFHMHDCFJ.MEAINJPIECA(value);
		}
	}

	// Token: 0x06019C18 RID: 105496 RVA: 0x0072F520 File Offset: 0x0072D720
	public int IHKPMNJEPHE()
	{
		if (this.EDFMCBBELAM)
		{
			for (int i = 0; i < IHFKMIAHBFP.NCLHHNLDGNE.Length; i++)
			{
				if (IHFKMIAHBFP.NCLHHNLDGNE[i] == this.LNJFBGIBLHA)
				{
					this.BBAKCCCBOEP = i;
					this.EDFMCBBELAM = true;
					break;
				}
			}
		}
		return this.BBAKCCCBOEP;
	}

	// Token: 0x06019C1A RID: 105498 RVA: 0x0072F588 File Offset: 0x0072D788
	public PlayerEmotes NIGJPLPPOEI()
	{
		return this.playerEmotes;
	}

	// Token: 0x17000B6E RID: 2926
	// (get) Token: 0x06019C1B RID: 105499 RVA: 0x0072F590 File Offset: 0x0072D790
	public PlayerModeration APGABCILCML
	{
		get
		{
			return this.playerModeration;
		}
	}

	// Token: 0x06019C1C RID: 105500 RVA: 0x0072F598 File Offset: 0x0072D798
	public void KEKCAGFMAHM()
	{
		this.DespawnLocal(true, false);
	}

	// Token: 0x17000B7F RID: 2943
	// (get) Token: 0x06019C1D RID: 105501 RVA: 0x0072F5A4 File Offset: 0x0072D7A4
	public Vector3 FGLFIJLGCKD
	{
		get
		{
			Vector3 position = this.BGOGBEPJGPJ.transform.position;
			position.y = this.trackingSpaceOrigin.position.y;
			return position;
		}
	}

	// Token: 0x06019C1E RID: 105502 RVA: 0x0072F5E0 File Offset: 0x0072D7E0
	public PlayerOutfit MOEABJNNBLK()
	{
		return this.playerOutfit;
	}

	// Token: 0x17000B93 RID: 2963
	// (get) Token: 0x06019C29 RID: 105513 RVA: 0x0072F728 File Offset: 0x0072D928
	// (set) Token: 0x06019C21 RID: 105505 RVA: 0x0072F680 File Offset: 0x0072D880
	public int BIJIAOGNBPD
	{
		get
		{
			return this.PNFHHGHADMB.CPIBGJLHLBL();
		}
		private set
		{
			this.PNFHHGHADMB.MEAINJPIECA(value);
		}
	}

	// Token: 0x06019C22 RID: 105506 RVA: 0x0072F690 File Offset: 0x0072D890
	private Transform ONDILIDGOLP()
	{
		return this.BGOGBEPJGPJ.transform;
	}

	// Token: 0x17000B9D RID: 2973
	// (get) Token: 0x06019C23 RID: 105507 RVA: 0x0072F6A0 File Offset: 0x0072D8A0
	public bool IIEGGLHMOBH
	{
		get
		{
			return this.NHDDPGADJPJ || this.DPLLNDECEMP;
		}
	}

	// Token: 0x17000B83 RID: 2947
	// (get) Token: 0x06019C24 RID: 105508 RVA: 0x0072F6B8 File Offset: 0x0072D8B8
	public float AMFPOBKJIBJ
	{
		get
		{
			return this.BGOGBEPJGPJ.transform.position.y - this.trackingSpaceOrigin.position.y;
		}
	}

	// Token: 0x17000B71 RID: 2929
	// (get) Token: 0x06019C25 RID: 105509 RVA: 0x0072F6F4 File Offset: 0x0072D8F4
	public PlayerObjectiveTracker CPGIIKCMNHN
	{
		get
		{
			return this.newPlayerPunchCardObjectiveTracker;
		}
	}

	// Token: 0x06019C26 RID: 105510 RVA: 0x0072F6FC File Offset: 0x0072D8FC
	private void IJAIJHDBBKN(int NOBAPCOKFIL)
	{
		this.PNFHHGHADMB.MEAINJPIECA(NOBAPCOKFIL);
	}

	// Token: 0x06019C27 RID: 105511 RVA: 0x0072F70C File Offset: 0x0072D90C
	public void PushAfkWarningStartTimeout(float ABPJFFBGJBF)
	{
		this.IBGGKPFNBKG.Push(ABPJFFBGJBF);
	}

	// Token: 0x17000B6A RID: 2922
	// (get) Token: 0x06019C2A RID: 105514 RVA: 0x0072F738 File Offset: 0x0072D938
	public PlayerUI POJAICMNOFI
	{
		get
		{
			return this.playerUI;
		}
	}

	// Token: 0x06019C2B RID: 105515 RVA: 0x0072F740 File Offset: 0x0072D940
	public static Player FindClosest(Vector3 CIGPHKLAAOD, List<LNJFBGIBLHA> NLNGMBJHODH = null)
	{
		Player player = null;
		float num = float.MaxValue;
		LNJFBGIBLHA[] array = ((NLNGMBJHODH == null) ? IHFKMIAHBFP.NCLHHNLDGNE : NLNGMBJHODH.ToArray());
		foreach (LNJFBGIBLHA lnjfbgiblha in array)
		{
			if (lnjfbgiblha != null)
			{
				Player player2 = lnjfbgiblha.JHJGDFHNBLO();
				if (!(player2 == null))
				{
					float sqrMagnitude = (player2.BGOGBEPJGPJ.transform.position - CIGPHKLAAOD).sqrMagnitude;
					if (sqrMagnitude < num)
					{
						player = player2;
						num = sqrMagnitude;
					}
				}
			}
		}
		return player;
	}

	// Token: 0x06019C2C RID: 105516 RVA: 0x0072F7E4 File Offset: 0x0072D9E4
	public void COGOICMCFIH()
	{
		this.HJJDNCOOIGD();
	}

	// Token: 0x17000B7C RID: 2940
	// (get) Token: 0x06019C2D RID: 105517 RVA: 0x0072F7EC File Offset: 0x0072D9EC
	public List<PlayerHand> JPICHJGANKL
	{
		get
		{
			if (this.BDIKLIKEBIM == null)
			{
				this.BDIKLIKEBIM = new List<PlayerHand>();
				this.BDIKLIKEBIM.Add(this.BGIBHPOALJG);
				this.BDIKLIKEBIM.Add(this.KEJBPANGFKK);
			}
			return this.BDIKLIKEBIM;
		}
	}

	// Token: 0x06019C2E RID: 105518 RVA: 0x0072F82C File Offset: 0x0072DA2C
	private void OnPhotonPlayerConnected(LNJFBGIBLHA BBLGGOBKKMC)
	{
		this.EDFMCBBELAM = true;
	}

	// Token: 0x06019C30 RID: 105520 RVA: 0x0072F860 File Offset: 0x0072DA60
	public PlayerOutfit ELADFPJEEJO()
	{
		return this.playerOutfit;
	}

	// Token: 0x06019C31 RID: 105521 RVA: 0x0072F868 File Offset: 0x0072DA68
	public static void SavePlayerMuted(long GKPEOHGOGCF, bool JANOCPFGBLB)
	{
		bool flag;
		if (JANOCPFGBLB)
		{
			flag = GLGMPGPNNBP.OOENNPPMMNN(GKPEOHGOGCF, null);
		}
		else
		{
			flag = GLGMPGPNNBP.EFBNHEFBOLD(GKPEOHGOGCF, null);
		}
		if (flag)
		{
			NECCOFKHCAA.OLEIBFDJIMF(GKPEOHGOGCF, JANOCPFGBLB);
		}
	}

	// Token: 0x06019C32 RID: 105522 RVA: 0x0072F8A0 File Offset: 0x0072DAA0
	public PlayerChaperone EKBAGBEDLLF()
	{
		return this.playerChaperone;
	}

	// Token: 0x06019C33 RID: 105523 RVA: 0x0072F8A8 File Offset: 0x0072DAA8
	private IEnumerator HENCEDFLABJ()
	{
		Player.KNLGKLEJEIE.OIPFMJBLDLO oipfmjbldlo = new Player.KNLGKLEJEIE.OIPFMJBLDLO();
		oipfmjbldlo.JBDLCPGODKK = Time.time;
		yield return new WaitWhile(new Func<bool>(oipfmjbldlo.OJKNBNGGBEC));
		yield break;
	}

	// Token: 0x17000B91 RID: 2961
	// (get) Token: 0x06019C34 RID: 105524 RVA: 0x0072F8BC File Offset: 0x0072DABC
	// (set) Token: 0x06019C54 RID: 105556 RVA: 0x0072FFE8 File Offset: 0x0072E1E8
	public bool BOCFJBNNEFP { get; private set; }

	// Token: 0x06019C35 RID: 105525 RVA: 0x0072F8C4 File Offset: 0x0072DAC4
	public void SetupControllerIOForHands()
	{
		this.leftHand.JKNCHBFALCJ = SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.CKKHCDNOAHJ;
		this.rightHand.JKNCHBFALCJ = SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.AAJLDBOOGIM;
	}

	// Token: 0x06019C36 RID: 105526 RVA: 0x0072F8F0 File Offset: 0x0072DAF0
	public void BLGJFKPHOBI(AudioManager.PFGLMBNKPCO NOBAPCOKFIL)
	{
		this.BEPFHMHDCFJ.MEAINJPIECA(NOBAPCOKFIL);
	}

	// Token: 0x06019C37 RID: 105527 RVA: 0x0072F900 File Offset: 0x0072DB00
	public bool AGAPJFILBPP(Player.PPELPGLINBB EANNKIELDCM)
	{
		return (this.LMDEFPDOGKA & EANNKIELDCM) == EANNKIELDCM;
	}

	// Token: 0x06019C38 RID: 105528 RVA: 0x0072F910 File Offset: 0x0072DB10
	private void NOCJEIEOACD(bool KGFFJGKOJKD)
	{
		for (int i = 0; i < this.head.transform.childCount; i++)
		{
			this.head.transform.GetChild(i).gameObject.SetActive(KGFFJGKOJKD);
		}
		this.NGFPOMIFLMF.HEGHBOOMIOG = KGFFJGKOJKD;
		this.ACAJJPKPKBH.SuppressAnimation = this.NHDDPGADJPJ || !KGFFJGKOJKD;
	}

	// Token: 0x17000B67 RID: 2919
	// (get) Token: 0x06019C3A RID: 105530 RVA: 0x0072F994 File Offset: 0x0072DB94
	private static CapsuleCollider HEEECBPLLEE
	{
		get
		{
			if (Player.GKKCHJFANKK == null)
			{
				GameObject gameObject = new GameObject("LocalPlayerWorldCapsuleCollider");
				Player.GKKCHJFANKK = gameObject.AddComponent<CapsuleCollider>();
				Player.GKKCHJFANKK.gameObject.layer = 27;
				Player.GKKCHJFANKK.isTrigger = true;
				Player.GKKCHJFANKK.center = Vector3.zero;
			}
			return Player.GKKCHJFANKK;
		}
	}

	// Token: 0x06019C3B RID: 105531 RVA: 0x0072F9F8 File Offset: 0x0072DBF8
	private void MNAMPGHLECC()
	{
		bool flag = !IHFKMIAHBFP.HCOPIOOOFMN && IHFKMIAHBFP.FFPDCNMDEEO && RecRoomSceneManager.NCKMBFBMBFM != null && !SessionManager.LBLKKPKBOGD && !SessionManager.DEHIOHBDMEK && !SessionManager.FMECIDNEBGM;
		if (flag)
		{
			float num = Time.unscaledTime - this.LNGNNJGPDNE;
			this.DFHCKNMJADN = SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.HBKDHPCDFGD;
			if (SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.HBKDHPCDFGD)
			{
				this.LNGNNJGPDNE = Time.unscaledTime;
				this.HHHOLAGBDBA = -1;
			}
			else if (num > this.ONOLOLOGPED)
			{
				RecRoomSceneManager.NCKMBFBMBFM.BootLocalPlayerToDormRoom(this.afkIntroMessage, SessionManager.PEECLKHFOCH.AFK);
				NECCOFKHCAA.MMOPDEJGCBD(num);
				this.LNGNNJGPDNE = Time.unscaledTime;
			}
			else if (num > this.DJNACAKPNEL)
			{
				int num2 = Mathf.CeilToInt(this.ONOLOLOGPED - num);
				if (this.HHHOLAGBDBA != num2)
				{
					SingletonMonoBehaviour<ScreenSpaceNotificationManager>.NCKMBFBMBFM.Play(ScreenSpaceNotificationManager.DBNGPDFKLEK.Major, this.afkWarningMessageTitle, this.NLMBOFIPFMH + num2.ToString(), 2f, null, true);
					this.HHHOLAGBDBA = num2;
				}
			}
		}
		else
		{
			this.LNGNNJGPDNE = Time.unscaledTime;
			this.HHHOLAGBDBA = -1;
		}
	}

	// Token: 0x06019C3C RID: 105532 RVA: 0x0072FB3C File Offset: 0x0072DD3C
	public bool FBMBCPINAPH(Player.PPELPGLINBB EANNKIELDCM)
	{
		return (this.LMDEFPDOGKA & EANNKIELDCM) == EANNKIELDCM;
	}

	// Token: 0x17000B65 RID: 2917
	// (get) Token: 0x06019C3D RID: 105533 RVA: 0x0072FB4C File Offset: 0x0072DD4C
	public static float FCEGFOFFLJJ
	{
		get
		{
			return SingletonMonoBehaviour<CameraFade>.NCKMBFBMBFM.PBIEEPJMFMK;
		}
	}

	// Token: 0x06019C3E RID: 105534 RVA: 0x0072FB58 File Offset: 0x0072DD58
	public static Player OOMJBKLFKBN(int JMJCIHCLECE)
	{
		LNJFBGIBLHA lnjfbgiblha = LNJFBGIBLHA.DGIBFHDCGHH(JMJCIHCLECE);
		if (lnjfbgiblha != null)
		{
			return lnjfbgiblha.NIELBMEGFAH as Player;
		}
		return null;
	}

	// Token: 0x06019C3F RID: 105535 RVA: 0x0072FB80 File Offset: 0x0072DD80
	public void PushAfkKickToIntroTimeout(float ABPJFFBGJBF)
	{
		this.IACLFMLCJDL.Push(ABPJFFBGJBF);
	}

	// Token: 0x17000B8D RID: 2957
	// (get) Token: 0x06019C40 RID: 105536 RVA: 0x0072FB90 File Offset: 0x0072DD90
	public PlatformManager.JNJEBIDGBNH GHCKJIELEDP
	{
		get
		{
			return this.JPKCMDPEMDF.CPIBGJLHLBL();
		}
	}

	// Token: 0x17000B90 RID: 2960
	// (get) Token: 0x06019C79 RID: 105593 RVA: 0x00730680 File Offset: 0x0072E880
	// (set) Token: 0x06019C41 RID: 105537 RVA: 0x0072FBA0 File Offset: 0x0072DDA0
	public AudioSource MLECOGMANBB { get; private set; }

	// Token: 0x06019C42 RID: 105538 RVA: 0x0072FBAC File Offset: 0x0072DDAC
	private void LGEHCGIGNBO()
	{
		if (this.NHDDPGADJPJ)
		{
			this.BIJIAOGNBPD = SingletonMonoBehaviour<PlayerInputManager>.NCKMBFBMBFM.PHNHNNNMHMH.GJEHLAIMOHP;
			this.IBEMNCLJANE = Time.time + this.KKDGFOAAEID;
		}
	}

	// Token: 0x06019C43 RID: 105539 RVA: 0x0072FBE0 File Offset: 0x0072DDE0
	public PlayerChaperone NLIIOLAOPBD()
	{
		return this.playerChaperone;
	}

	// Token: 0x17000B98 RID: 2968
	// (get) Token: 0x06019C74 RID: 105588 RVA: 0x0073053C File Offset: 0x0072E73C
	// (set) Token: 0x06019C44 RID: 105540 RVA: 0x0072FBE8 File Offset: 0x0072DDE8
	public bool DFHCKNMJADN
	{
		get
		{
			return this.ACKDJPKHKAP.CPIBGJLHLBL();
		}
		set
		{
			if (this.DFHCKNMJADN != value)
			{
				this.ACKDJPKHKAP.MEAINJPIECA(value);
			}
		}
	}

	// Token: 0x06019C45 RID: 105541 RVA: 0x0072FC04 File Offset: 0x0072DE04
	public static float DistanceSqrBetweenPlayers(Player DPIIIAGCMLK, Player BDKNHBMMGPK)
	{
		if (DPIIIAGCMLK == null || BDKNHBMMGPK == null)
		{
			return float.MaxValue;
		}
		return Vector3.ProjectOnPlane(DPIIIAGCMLK.BGOGBEPJGPJ.transform.position - BDKNHBMMGPK.BGOGBEPJGPJ.transform.position, Vector3.up).sqrMagnitude;
	}

	// Token: 0x17000B63 RID: 2915
	// (get) Token: 0x06019C46 RID: 105542 RVA: 0x0072FC68 File Offset: 0x0072DE68
	public int HONPHANMLDG
	{
		get
		{
			if (this.EDFMCBBELAM)
			{
				for (int i = 0; i < IHFKMIAHBFP.NCLHHNLDGNE.Length; i++)
				{
					if (IHFKMIAHBFP.NCLHHNLDGNE[i] == this.LNJFBGIBLHA)
					{
						this.BBAKCCCBOEP = i;
						this.EDFMCBBELAM = false;
						break;
					}
				}
			}
			return this.BBAKCCCBOEP;
		}
	}

	// Token: 0x06019C48 RID: 105544 RVA: 0x0072FCFC File Offset: 0x0072DEFC
	public IgnoreBufferSize HPCEPOCOIAI()
	{
		return this.<EEIIIOOCBEK>k__BackingField;
	}

	// Token: 0x06019C49 RID: 105545 RVA: 0x0072FD04 File Offset: 0x0072DF04
	public static void DNNIENGKAJD(long GKPEOHGOGCF, bool JANOCPFGBLB)
	{
		bool flag;
		if (JANOCPFGBLB)
		{
			flag = GLGMPGPNNBP.OOENNPPMMNN(GKPEOHGOGCF, null);
		}
		else
		{
			flag = GLGMPGPNNBP.EFBNHEFBOLD(GKPEOHGOGCF, null);
		}
		if (flag)
		{
			NECCOFKHCAA.OLEIBFDJIMF(GKPEOHGOGCF, JANOCPFGBLB);
		}
	}

	// Token: 0x06019C4A RID: 105546 RVA: 0x0072FD3C File Offset: 0x0072DF3C
	public AnimateInOut KPLHGNDKGGM()
	{
		return this.animateInOut;
	}

	// Token: 0x06019C4B RID: 105547 RVA: 0x0072FD44 File Offset: 0x0072DF44
	public bool HMAHAJNCJKH()
	{
		return this.EEHCAMCMPAG() || this.DPLLNDECEMP;
	}

	// Token: 0x06019C4C RID: 105548 RVA: 0x0072FD5C File Offset: 0x0072DF5C
	private void OnDisable()
	{
		if (this.NHDDPGADJPJ && SingletonMonoBehaviour<SettingsManager>.NCKMBFBMBFM != null)
		{
			SingletonMonoBehaviour<SettingsManager>.NCKMBFBMBFM.FPEGHDDDHCC = this.SavedVoiceChatSettings;
		}
		if (IHFKMIAHBFP.FFPDCNMDEEO)
		{
			this.ReleaseToolsFromBothHands();
		}
	}

	// Token: 0x06019C4D RID: 105549 RVA: 0x0072FD9C File Offset: 0x0072DF9C
	public string NMCGFMOFNNL()
	{
		return this.BCABNDFAKPD.Peek();
	}

	// Token: 0x06019C4E RID: 105550 RVA: 0x0072FDAC File Offset: 0x0072DFAC
	private void OECFMIPHGDN()
	{
		bool lbkllblmago = this.LBKLLBLMAGO;
		bool flag = false;
		if (lbkllblmago && PEDNLMAHGBP.KGKNIMECEKH.KAPOBAEMBKL != PGOPAPIFECA.ROOM_CALIBRATION && !this.GADNKIIKPPD.AIMBNBAEGJD && !this.ONCLKAJIHGK)
		{
			flag = this.BGOGBEPJGPJ.IHJHIMGJCKC || (!this.FACNGBJIIMM(this.BGOGBEPJGPJ.transform.position) && !this.FACNGBJIIMM(this.NGFPOMIFLMF.transform.position));
		}
		Player.ADFKLFKJEFH fdpdonbhmec = this.FDPDONBHMEC;
		if (fdpdonbhmec != Player.ADFKLFKJEFH.IN_BOUNDS)
		{
			if (fdpdonbhmec != Player.ADFKLFKJEFH.OUT_OF_BOUNDS_GRACE_PERIOD)
			{
				if (fdpdonbhmec == Player.ADFKLFKJEFH.OUT_OF_BOUNDS)
				{
					if (!flag)
					{
						SingletonMonoBehaviour<ScreenSpaceNotificationManager>.NCKMBFBMBFM.StopPersistent();
						this.FDPDONBHMEC = Player.ADFKLFKJEFH.IN_BOUNDS;
					}
				}
			}
			else if (!flag)
			{
				SingletonMonoBehaviour<ScreenSpaceNotificationManager>.NCKMBFBMBFM.StopPersistent();
				this.FDPDONBHMEC = Player.ADFKLFKJEFH.IN_BOUNDS;
			}
			else if (Time.time - this.EKECEFNDDAC >= 1f)
			{
				SingletonMonoBehaviour<ScreenSpaceNotificationManager>.NCKMBFBMBFM.Play(ScreenSpaceNotificationManager.DBNGPDFKLEK.Major, "Out of bounds!", 2f, null, false);
				SingletonMonoBehaviour<ScreenSpaceNotificationManager>.NCKMBFBMBFM.PlayPersistent("Walk back to the play area");
				this.FDPDONBHMEC = Player.ADFKLFKJEFH.OUT_OF_BOUNDS;
			}
		}
		else if (flag)
		{
			this.EKECEFNDDAC = Time.time;
			this.FDPDONBHMEC = Player.ADFKLFKJEFH.OUT_OF_BOUNDS_GRACE_PERIOD;
		}
	}

	// Token: 0x17000B74 RID: 2932
	// (get) Token: 0x06019C4F RID: 105551 RVA: 0x0072FF00 File Offset: 0x0072E100
	public PlayerFacialAnimator HGALPPFDCIO
	{
		get
		{
			return this.playerFacialAnimator;
		}
	}

	// Token: 0x06019C50 RID: 105552 RVA: 0x0072FF08 File Offset: 0x0072E108
	public static Player GetRecRoomPlayer(int BBAKCCCBOEP)
	{
		Player player = null;
		if (BBAKCCCBOEP < IHFKMIAHBFP.NCLHHNLDGNE.Length)
		{
			player = IHFKMIAHBFP.NCLHHNLDGNE[BBAKCCCBOEP].NIELBMEGFAH as Player;
		}
		return player;
	}

	// Token: 0x06019C51 RID: 105553 RVA: 0x0072FF38 File Offset: 0x0072E138
	private void BMNADFIKDOE(long HPCOKMAPCHB)
	{
		if (HPCOKMAPCHB == this.NAJBCPFNBAB && this.BGOGBEPJGPJ != null)
		{
			DBHHFILLFLC dbhhfillflc = LNPBGKENDPK.CPIBGJLHLBL(this.NAJBCPFNBAB);
			if (dbhhfillflc != null && dbhhfillflc.EHLBEFKJLHJ != null && dbhhfillflc.EHLBEFKJLHJ.GDIECAFDIMC == "DKMode")
			{
				this.BGOGBEPJGPJ.transform.localScale = this.PALMENINGNL * 3f;
			}
			else
			{
				this.BGOGBEPJGPJ.transform.localScale = this.PALMENINGNL;
			}
		}
	}

	// Token: 0x17000B68 RID: 2920
	// (get) Token: 0x06019C52 RID: 105554 RVA: 0x0072FFD4 File Offset: 0x0072E1D4
	public PlayerAudio IJPGLAKCCPN
	{
		get
		{
			return this.playerAudio;
		}
	}

	// Token: 0x06019C55 RID: 105557 RVA: 0x0072FFF4 File Offset: 0x0072E1F4
	public void OCJJBPDGKAB()
	{
		this.DPAHOMFBOFE.Pop();
	}

	// Token: 0x06019C56 RID: 105558 RVA: 0x00730004 File Offset: 0x0072E204
	public PlayerLocomotion CBLLEJGBAAM()
	{
		return this.playerLocomotion;
	}

	// Token: 0x06019C57 RID: 105559 RVA: 0x0073000C File Offset: 0x0072E20C
	public bool MHDNJHHBNOD()
	{
		return !this.DPLLNDECEMP || !this.BBIJDJPGPKA || Time.time - this.DEOBJENCBGG >= 1964f;
	}

	// Token: 0x17000B77 RID: 2935
	// (get) Token: 0x06019C58 RID: 105560 RVA: 0x00730040 File Offset: 0x0072E240
	public PlayerHead BGOGBEPJGPJ
	{
		get
		{
			return this.head;
		}
	}

	// Token: 0x17000B75 RID: 2933
	// (get) Token: 0x06019C59 RID: 105561 RVA: 0x00730048 File Offset: 0x0072E248
	public PlayerEvents DIJMEKHCJBP
	{
		get
		{
			return this.playerEvents;
		}
	}

	// Token: 0x06019C5A RID: 105562 RVA: 0x00730050 File Offset: 0x0072E250
	private bool BDGAOKJBCNJ()
	{
		return this.BCNKIKFJBHJ.isPartOfStaticBatch || this.ABINFEAPOHB.isVisible || this.PGMLAPIMEMM.isVisible;
	}

	// Token: 0x17000B9B RID: 2971
	// (get) Token: 0x06019C5B RID: 105563 RVA: 0x00730080 File Offset: 0x0072E280
	public bool ONCLKAJIHGK
	{
		get
		{
			return !this.DPLLNDECEMP;
		}
	}

	// Token: 0x06019C5C RID: 105564 RVA: 0x0073008C File Offset: 0x0072E28C
	public static float MJCHKEOKAJA(Player DPIIIAGCMLK, Player BDKNHBMMGPK)
	{
		if (DPIIIAGCMLK == null || BDKNHBMMGPK == null)
		{
			return 391f;
		}
		return Vector3.ProjectOnPlane(DPIIIAGCMLK.BGOGBEPJGPJ.transform.position - BDKNHBMMGPK.HFDJIFFPEFM().transform.position, Vector3.up).sqrMagnitude;
	}

	// Token: 0x06019C5D RID: 105565 RVA: 0x007300F0 File Offset: 0x0072E2F0
	public bool SetMuteFlag(Player.PPELPGLINBB EANNKIELDCM, bool KELIMOCDMOD = true)
	{
		Player.PPELPGLINBB lmdefpdogka = this.LMDEFPDOGKA;
		if (KELIMOCDMOD)
		{
			this.LMDEFPDOGKA |= EANNKIELDCM;
		}
		else
		{
			this.LMDEFPDOGKA &= ~EANNKIELDCM;
		}
		bool flag = lmdefpdogka != this.LMDEFPDOGKA;
		if (flag)
		{
			this.JFMIIOMJMMB();
			this.DIJMEKHCJBP.MicrophoneMuted(this.HBFEAFMCBBC);
		}
		return flag;
	}

	// Token: 0x06019C5E RID: 105566 RVA: 0x00730158 File Offset: 0x0072E358
	public void ReleaseToolsFromBothHands()
	{
		this.BGIBHPOALJG.ReleaseTool(false);
		this.KEJBPANGFKK.ReleaseTool(false);
	}

	// Token: 0x17000B81 RID: 2945
	// (get) Token: 0x06019C5F RID: 105567 RVA: 0x00730174 File Offset: 0x0072E374
	public bool IHJHIMGJCKC
	{
		get
		{
			return this.FDPDONBHMEC == Player.ADFKLFKJEFH.OUT_OF_BOUNDS;
		}
	}

	// Token: 0x06019C60 RID: 105568 RVA: 0x00730180 File Offset: 0x0072E380
	private void NPKOIHBPNIK()
	{
		this.SetMuteFlag(Player.PPELPGLINBB.AFK_MUTE, !this.DFHCKNMJADN);
	}

	// Token: 0x17000B86 RID: 2950
	// (get) Token: 0x06019C61 RID: 105569 RVA: 0x00730194 File Offset: 0x0072E394
	public float IMMBPAFHGKP
	{
		get
		{
			if (this.NHDDPGADJPJ)
			{
				if (this.voiceRecorder != null && this.voiceRecorder.enabled && !this.HBFEAFMCBBC)
				{
					return this.voiceRecorder.JLJIAFFLJDP.CHJGBEDPICD * 3.1622f;
				}
			}
			else if (this.voiceSpeaker != null && this.voiceSpeaker.enabled && !this.HBFEAFMCBBC)
			{
				return this.voiceSpeaker.CHJGBEDPICD;
			}
			return 0f;
		}
	}

	// Token: 0x06019C62 RID: 105570 RVA: 0x00730234 File Offset: 0x0072E434
	private void HILDOEMDEDK()
	{
		if (this.PCGELLFCMPB())
		{
			this.voiceRecorder.ACHJBEJKAPA = !this.FMIODHIDJJP();
		}
		else
		{
			this.voiceSpeaker.enabled = !this.FMIODHIDJJP();
			if (!this.voiceSpeaker.enabled)
			{
				this.voiceSpeaker.Pause();
			}
		}
	}

	// Token: 0x17000B70 RID: 2928
	// (get) Token: 0x06019C63 RID: 105571 RVA: 0x00730294 File Offset: 0x0072E494
	public PlayerObjectiveTracker HMMHODMJJNG
	{
		get
		{
			return this.dailiesObjectiveTracker;
		}
	}

	// Token: 0x06019C64 RID: 105572 RVA: 0x0073029C File Offset: 0x0072E49C
	public PlayerUI LNKGAAEPMEO()
	{
		return this.playerUI;
	}

	// Token: 0x06019C65 RID: 105573 RVA: 0x007302A4 File Offset: 0x0072E4A4
	private bool PCNEFMNGEHN()
	{
		return this.BCNKIKFJBHJ.isPartOfStaticBatch || this.ABINFEAPOHB.isVisible || this.PGMLAPIMEMM.isVisible;
	}

	// Token: 0x06019C66 RID: 105574 RVA: 0x007302D4 File Offset: 0x0072E4D4
	public bool PHPNPFNHLPC()
	{
		return this.BGOGBEPJGPJ.HDLLKGIHDMI();
	}

	// Token: 0x06019C67 RID: 105575 RVA: 0x007302E4 File Offset: 0x0072E4E4
	public PlayerHead AJHHFNCFKNF()
	{
		return this.head;
	}

	// Token: 0x17000B9E RID: 2974
	// (get) Token: 0x06019C68 RID: 105576 RVA: 0x007302EC File Offset: 0x0072E4EC
	public bool OFAHEPODABI
	{
		get
		{
			return this.ECDPLOAPKLG || this.MMDAAHDKEGA != AGFCGHIFLIK.DKDCJMEPHCJ.None;
		}
	}

	// Token: 0x06019C69 RID: 105577 RVA: 0x00730308 File Offset: 0x0072E508
	protected void OnEnable()
	{
		this.LNGNNJGPDNE = Time.unscaledTime;
	}

	// Token: 0x06019C6A RID: 105578 RVA: 0x00730318 File Offset: 0x0072E518
	[BCENPNOIAOM]
	public void RpcBroadcastDespawnPlayer()
	{
		if (this.IIEGGLHMOBH)
		{
			this.ACAJJPKPKBH.PlayEffect(false, null, null, false);
		}
		this.GADNKIIKPPD.OnPlayerDespawn();
		this.DPLLNDECEMP = false;
	}

	// Token: 0x06019C6B RID: 105579 RVA: 0x00730364 File Offset: 0x0072E564
	private void OFKGLPOECEG()
	{
		bool flag = this.HKDNGBPNDDD();
		if (flag)
		{
			this.KLIHPNEEBIK();
			this.head.MCJBCNHLBCH().CIGPHKLAAOD = SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.KPGFMCHFLBM.transform.position;
			this.head.PJKENHEAOHP().IJGPPOIJDKO = SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.KPGFMCHFLBM.transform.rotation;
			this.LGKEDKFPDHG();
		}
		this.CFKJBPKPJCM();
		if (flag)
		{
			this.OECFMIPHGDN();
		}
		this.HGALPPFDCIO.FKAHFBMFPAB(this.LHKNKHPEPCJ);
		this.voiceObject.transform.position = this.head.transform.position;
		this.voiceObject.transform.rotation = this.head.transform.rotation;
		this.LJNKFFDLKJG();
		if (flag && Time.time >= this.IBEMNCLJANE)
		{
			this.LGEHCGIGNBO();
		}
	}

	// Token: 0x17000B73 RID: 2931
	// (get) Token: 0x06019C6C RID: 105580 RVA: 0x00730458 File Offset: 0x0072E658
	public PlayerEmotes NKHGHMNEGIM
	{
		get
		{
			return this.playerEmotes;
		}
	}

	// Token: 0x06019C6E RID: 105582 RVA: 0x00730470 File Offset: 0x0072E670
	public static Player LDODNGDENKE(int MLAHLLNCFLA)
	{
		PhotonView photonView = PhotonView.Find(MLAHLLNCFLA);
		return (!(photonView == null)) ? photonView.GetComponent<Player>() : null;
	}

	// Token: 0x06019C6F RID: 105583 RVA: 0x0073049C File Offset: 0x0072E69C
	public float ENGPOJCPJBO()
	{
		return this.HFDJIFFPEFM().transform.position.y - this.trackingSpaceOrigin.position.y;
	}

	// Token: 0x17000B8E RID: 2958
	// (get) Token: 0x06019C70 RID: 105584 RVA: 0x007304D8 File Offset: 0x0072E6D8
	public ulong AMHOBPCPMCL
	{
		get
		{
			return this.NGIIAOJHKAE.CPIBGJLHLBL();
		}
	}

	// Token: 0x06019C71 RID: 105585 RVA: 0x007304E8 File Offset: 0x0072E6E8
	public void MCPAKKCIEFN(Transform JGJGCFPENJK)
	{
		JGJGCFPENJK.SetParent(this.LBMGHLBBKBJ.transform, false);
	}

	// Token: 0x06019C72 RID: 105586 RVA: 0x007304FC File Offset: 0x0072E6FC
	private void CJKKIBMIKNH()
	{
		this.OCFAIFCGJJF = SingletonMonoBehaviour<SettingsManager>.NCKMBFBMBFM.GetIgnoreBufferSize(this.EAJABOECGNI);
	}

	// Token: 0x06019C73 RID: 105587 RVA: 0x00730514 File Offset: 0x0072E714
	public void Respawn(Vector3 CIGPHKLAAOD, Quaternion IJGPPOIJDKO, bool DGMJGABBCFP = true, int CJNMGLONBAC = -1, string OBKEDGCOEPE = null, int LPMDEEDBMMP = -1, string AJPKEHBANIN = null, bool DMDPGGPKEMN = false)
	{
		base.StartCoroutine(this.RespawnLocal(CIGPHKLAAOD, IJGPPOIJDKO, DGMJGABBCFP, CJNMGLONBAC, OBKEDGCOEPE, LPMDEEDBMMP, AJPKEHBANIN, DMDPGGPKEMN));
	}

	// Token: 0x06019C75 RID: 105589 RVA: 0x0073054C File Offset: 0x0072E74C
	public static Player FindLocalPlayer(long GKPEOHGOGCF)
	{
		foreach (Player player in Player.All)
		{
			if (player.NAJBCPFNBAB == GKPEOHGOGCF)
			{
				return player;
			}
		}
		return null;
	}

	// Token: 0x06019C76 RID: 105590 RVA: 0x007305B8 File Offset: 0x0072E7B8
	public PlayerHand DGJKLOOHMMP(Player.HDOICGIKKAO ACAHIJEJKLC)
	{
		PlayerHand playerHand = null;
		if (ACAHIJEJKLC != Player.HDOICGIKKAO.LeftHand)
		{
			if (ACAHIJEJKLC == Player.HDOICGIKKAO.Torso)
			{
				playerHand = this.KEJBPANGFKK;
			}
		}
		else
		{
			playerHand = this.DGEOJLGFGNG();
		}
		return playerHand;
	}

	// Token: 0x17000B82 RID: 2946
	// (get) Token: 0x06019C77 RID: 105591 RVA: 0x007305F4 File Offset: 0x0072E7F4
	public bool DKPLHPADIAH
	{
		get
		{
			return this.BGOGBEPJGPJ.DKPLHPADIAH;
		}
	}

	// Token: 0x06019C78 RID: 105592 RVA: 0x00730604 File Offset: 0x0072E804
	public static Player PLKGBDNIKKE(Vector3 AAOGGNMHJBB)
	{
		if (Player.LocalPlayer != null)
		{
			foreach (LNJFBGIBLHA lnjfbgiblha in IHFKMIAHBFP.EFDADFDIIIJ)
			{
				Player player = lnjfbgiblha.JHJGDFHNBLO();
				if (player != null)
				{
					float magnitude = (player.FGLFIJLGCKD - AAOGGNMHJBB).magnitude;
					if (magnitude <= player.CBLLEJGBAAM().AHJNNLBMCIP)
					{
						return player;
					}
				}
			}
		}
		return null;
	}

	// Token: 0x06019C7A RID: 105594 RVA: 0x00730688 File Offset: 0x0072E888
	public IgnoreBufferSize EEJEAILBHJM()
	{
		return this.<EEIIIOOCBEK>k__BackingField;
	}

	// Token: 0x06019C7B RID: 105595 RVA: 0x00730690 File Offset: 0x0072E890
	public PlayerHand GetHand(Player.HDOICGIKKAO ACAHIJEJKLC)
	{
		PlayerHand playerHand = null;
		if (ACAHIJEJKLC != Player.HDOICGIKKAO.LeftHand)
		{
			if (ACAHIJEJKLC == Player.HDOICGIKKAO.RightHand)
			{
				playerHand = this.KEJBPANGFKK;
			}
		}
		else
		{
			playerHand = this.BGIBHPOALJG;
		}
		return playerHand;
	}

	// Token: 0x06019C7C RID: 105596 RVA: 0x007306CC File Offset: 0x0072E8CC
	private void FGNAFJFHOKC(Quaternion NOBAPCOKFIL)
	{
		this.<KDDBBOHIDKP>k__BackingField = NOBAPCOKFIL;
	}

	// Token: 0x17000B94 RID: 2964
	// (get) Token: 0x06019C7D RID: 105597 RVA: 0x007306D8 File Offset: 0x0072E8D8
	public string IHHBIFJGBPD
	{
		get
		{
			return this.BCABNDFAKPD.Peek();
		}
	}

	// Token: 0x06019C7E RID: 105598 RVA: 0x007306E8 File Offset: 0x0072E8E8
	public void PopRichPresence()
	{
		this.BCABNDFAKPD.Pop();
		if (SingletonMonoBehaviour<PlatformManager>.NCKMBFBMBFM != null)
		{
			SingletonMonoBehaviour<PlatformManager>.NCKMBFBMBFM.SetRichPresenceStatus(this.IHHBIFJGBPD);
		}
	}

	// Token: 0x06019C7F RID: 105599 RVA: 0x00730718 File Offset: 0x0072E918
	public void EnableOutOfBoundsCheck(bool ELKJPGDLAII)
	{
		this.LBKLLBLMAGO = ELKJPGDLAII;
	}

	// Token: 0x17000B99 RID: 2969
	// (get) Token: 0x06019C8D RID: 105613 RVA: 0x00730ACC File Offset: 0x0072ECCC
	// (set) Token: 0x06019C80 RID: 105600 RVA: 0x00730724 File Offset: 0x0072E924
	public Vector3 DINLMMOJAPK { get; private set; }

	// Token: 0x06019C81 RID: 105601 RVA: 0x00730730 File Offset: 0x0072E930
	public static Player Find(int JMJCIHCLECE)
	{
		LNJFBGIBLHA lnjfbgiblha = LNJFBGIBLHA.FDOBBLFBBBK(JMJCIHCLECE);
		if (lnjfbgiblha != null)
		{
			return lnjfbgiblha.NIELBMEGFAH as Player;
		}
		return null;
	}

	// Token: 0x06019C82 RID: 105602 RVA: 0x00730758 File Offset: 0x0072E958
	private void CFKJBPKPJCM()
	{
		if (!this.NHDDPGADJPJ)
		{
			this.playerIdentity.transform.position = this.head.transform.position;
		}
		else
		{
			Vector3 up = Vector3.up;
			Vector3 normalized = Vector3.ProjectOnPlane(SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.KPGFMCHFLBM.transform.forward, up).normalized;
			Vector3 normalized2 = Vector3.ProjectOnPlane(SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.KPGFMCHFLBM.transform.right, up).normalized;
			Vector3 vector = normalized2 * this.localIdentityOffset.x + up * this.localIdentityOffset.y + normalized * this.localIdentityOffset.z;
			this.playerIdentity.transform.position = this.head.transform.position + vector;
		}
	}

	// Token: 0x06019C83 RID: 105603 RVA: 0x00730848 File Offset: 0x0072EA48
	public bool OFEOKAMFFFD(Player.PPELPGLINBB EANNKIELDCM, bool KELIMOCDMOD = true)
	{
		Player.PPELPGLINBB lmdefpdogka = this.LMDEFPDOGKA;
		if (KELIMOCDMOD)
		{
			this.LMDEFPDOGKA |= EANNKIELDCM;
		}
		else
		{
			this.LMDEFPDOGKA &= ~EANNKIELDCM;
		}
		bool flag = lmdefpdogka != this.LMDEFPDOGKA;
		if (flag)
		{
			this.JFMIIOMJMMB();
			this.DIJMEKHCJBP.IEKLIHCPLNK(this.HBFEAFMCBBC);
		}
		return flag;
	}

	// Token: 0x06019C84 RID: 105604 RVA: 0x007308B0 File Offset: 0x0072EAB0
	private void CLMLJBEGAOL(GameObject NOBAPCOKFIL)
	{
		this.<HIMIKBOKGMI>k__BackingField = NOBAPCOKFIL;
	}

	// Token: 0x06019C85 RID: 105605 RVA: 0x007308BC File Offset: 0x0072EABC
	private void JFMIIOMJMMB()
	{
		if (this.NHDDPGADJPJ)
		{
			this.voiceRecorder.ACHJBEJKAPA = !this.HBFEAFMCBBC;
		}
		else
		{
			this.voiceSpeaker.enabled = !this.HBFEAFMCBBC;
			if (!this.voiceSpeaker.enabled)
			{
				this.voiceSpeaker.Pause();
			}
		}
	}

	// Token: 0x17000B6B RID: 2923
	// (get) Token: 0x06019C86 RID: 105606 RVA: 0x0073091C File Offset: 0x0072EB1C
	public PlayerBackpack OFGGECBANNE
	{
		get
		{
			return this.playerBackpack;
		}
	}

	// Token: 0x06019C87 RID: 105607 RVA: 0x00730924 File Offset: 0x0072EB24
	private bool CPPJOMMOPDD()
	{
		return this.BCNKIKFJBHJ.isPartOfStaticBatch || this.ABINFEAPOHB.isVisible || this.PGMLAPIMEMM.isVisible;
	}

	// Token: 0x06019C8B RID: 105611 RVA: 0x00730AB8 File Offset: 0x0072ECB8
	public bool MHKNMFHJAIK()
	{
		return this.<MGPJKIHNFMG>k__BackingField;
	}

	// Token: 0x17000B9F RID: 2975
	// (get) Token: 0x06019C93 RID: 105619 RVA: 0x00730D2C File Offset: 0x0072EF2C
	// (set) Token: 0x06019C8C RID: 105612 RVA: 0x00730AC0 File Offset: 0x0072ECC0
	public bool ECDPLOAPKLG { get; set; }

	// Token: 0x06019C8E RID: 105614 RVA: 0x00730AD4 File Offset: 0x0072ECD4
	public PlayerParty NMMEHHPHPIJ()
	{
		return this.playerParty;
	}

	// Token: 0x06019C8F RID: 105615 RVA: 0x00730ADC File Offset: 0x0072ECDC
	private void MDGPLNDHKCI()
	{
		bool flag = this.PJNKKFHLGKI();
		if (flag)
		{
			this.IMNFPGPBKDM();
			this.head.PADBOOGDIPG().CIGPHKLAAOD = SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.KPGFMCHFLBM.transform.position;
			this.head.IGPBEPDJEJB().IJGPPOIJDKO = SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.KPGFMCHFLBM.transform.rotation;
			this.LGKEDKFPDHG();
		}
		this.CFKJBPKPJCM();
		if (flag)
		{
			this.OECFMIPHGDN();
		}
		this.HGALPPFDCIO.HHKKIJLFBJP(this.LHKNKHPEPCJ);
		this.voiceObject.transform.position = this.head.transform.position;
		this.voiceObject.transform.rotation = this.head.transform.rotation;
		this.LJNKFFDLKJG();
		if (flag && Time.time >= this.IBEMNCLJANE)
		{
			this.LGEHCGIGNBO();
		}
	}

	// Token: 0x17000B85 RID: 2949
	// (get) Token: 0x06019C90 RID: 105616 RVA: 0x00730BD0 File Offset: 0x0072EDD0
	public bool HBFEAFMCBBC
	{
		get
		{
			return this.LMDEFPDOGKA != Player.PPELPGLINBB.NONE;
		}
	}

	// Token: 0x17000B7A RID: 2938
	// (get) Token: 0x06019C91 RID: 105617 RVA: 0x00730BE0 File Offset: 0x0072EDE0
	public PlayerHand KEJBPANGFKK
	{
		get
		{
			return this.rightHand;
		}
	}

	// Token: 0x06019C92 RID: 105618 RVA: 0x00730BE8 File Offset: 0x0072EDE8
	private void KLIHPNEEBIK()
	{
		bool flag = IHFKMIAHBFP.HCOPIOOOFMN || !IHFKMIAHBFP.FFPDCNMDEEO || !(RecRoomSceneManager.LEILGOOHEOI() != null) || SessionManager.LBLKKPKBOGD || SessionManager.DEHIOHBDMEK || !SessionManager.FMECIDNEBGM;
		if (flag)
		{
			float num = Time.unscaledTime - this.LNGNNJGPDNE;
			this.DFHCKNMJADN = SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.HBKDHPCDFGD;
			if (SingletonMonoBehaviour<CameraRig>.NCKMBFBMBFM.HBKDHPCDFGD)
			{
				this.LNGNNJGPDNE = Time.unscaledTime;
				this.HHHOLAGBDBA = -1;
			}
			else if (num > this.ONOLOLOGPED)
			{
				RecRoomSceneManager.NCKMBFBMBFM.BootLocalPlayerToDormRoom(this.afkIntroMessage, SessionManager.PEECLKHFOCH.NOT_SET);
				NECCOFKHCAA.MMOPDEJGCBD(num);
				this.LNGNNJGPDNE = Time.unscaledTime;
			}
			else if (num > this.DJNACAKPNEL)
			{
				int num2 = Mathf.CeilToInt(this.ONOLOLOGPED - num);
				if (this.HHHOLAGBDBA != num2)
				{
					SingletonMonoBehaviour<ScreenSpaceNotificationManager>.NCKMBFBMBFM.Play(ScreenSpaceNotificationManager.DBNGPDFKLEK.Vital, this.afkWarningMessageTitle, this.NLMBOFIPFMH + num2.ToString(), 1968f, null, true);
					this.HHHOLAGBDBA = num2;
				}
			}
		}
		else
		{
			this.LNGNNJGPDNE = Time.unscaledTime;
			this.HHHOLAGBDBA = -1;
		}
	}

	// Token: 0x06019C94 RID: 105620 RVA: 0x00730D34 File Offset: 0x0072EF34
	private bool AONCNCOIGAC(out Vector3 AEONOMINPGG)
	{
		AEONOMINPGG = Vector3.zero;
		Vector3 position = this.BGOGBEPJGPJ.transform.position;
		Vector3 vector = this.FGLFIJLGCKD + Vector3.up * this.collisionHeadRadius;
		Vector3 vector2 = position - vector;
		if (vector2.sqrMagnitude > 0.0625f)
		{
			vector += Vector3.up * 0.25f;
			vector2 = position - vector;
		}
		Vector3 vector3 = vector + vector2 / 2f;
		float num = vector2.magnitude + 2f * this.collisionHeadRadius;
		float num2 = num / 2f;
		int num3 = Physics.OverlapSphereNonAlloc(vector3, num2 + this.collisionHeadEpsilon, Player.ODIPNIIFFAF, 2048, QueryTriggerInteraction.Ignore);
		if (num3 <= 0)
		{
			return false;
		}
		int num4 = 0;
		int num5 = 0;
		for (int i = 0; i < num3; i++)
		{
			Player.DHIHPJGOAJJ dhihpjgoajj = this.WorldCollisionMode;
			PlayerWorldCollisionConfig component = Player.ODIPNIIFFAF[i].gameObject.GetComponent<PlayerWorldCollisionConfig>();
			if (component != null)
			{
				dhihpjgoajj = component.ENLLNBMNAOK;
			}
			if (dhihpjgoajj == Player.DHIHPJGOAJJ.HEAD_ONLY && num4 < Player.DDLPLBEELBP.Length)
			{
				Player.DDLPLBEELBP[num4++] = Player.ODIPNIIFFAF[i];
			}
			else if (dhihpjgoajj == Player.DHIHPJGOAJJ.HEAD_AND_BODY && num5 < Player.JENPFDJDGME.Length)
			{
				Player.JENPFDJDGME[num5++] = Player.ODIPNIIFFAF[i];
			}
		}
		Vector3 zero = Vector3.zero;
		Vector3 zero2 = Vector3.zero;
		float num6 = this.collisionHeadRadius * 2f;
		bool flag = false;
		flag |= this.LFJHGEDONPM(this.BGOGBEPJGPJ.transform.position, this.BGOGBEPJGPJ.transform.rotation, this.collisionHeadRadius, num6, num4, Player.DDLPLBEELBP, out zero);
		flag |= this.LFJHGEDONPM(vector3, Quaternion.identity, this.collisionHeadRadius, num, num5, Player.JENPFDJDGME, out zero2);
		if (flag)
		{
			AEONOMINPGG = zero + zero2;
			return true;
		}
		return false;
	}

	// Token: 0x06019C95 RID: 105621 RVA: 0x00730F48 File Offset: 0x0072F148
	public void PushRichPresence(string PBHBNOKCCCB)
	{
		this.BCABNDFAKPD.Push(PBHBNOKCCCB);
		if (SingletonMonoBehaviour<PlatformManager>.NCKMBFBMBFM != null)
		{
			SingletonMonoBehaviour<PlatformManager>.NCKMBFBMBFM.SetRichPresenceStatus(this.IHHBIFJGBPD);
		}
	}

	// Token: 0x06019C96 RID: 105622 RVA: 0x00730F78 File Offset: 0x0072F178
	public float PLGFIGCHFMA()
	{
		return this.AJHHFNCFKNF().transform.position.y - this.trackingSpaceOrigin.position.y;
	}

	// Token: 0x06019C97 RID: 105623 RVA: 0x00730FB4 File Offset: 0x0072F1B4
	public static Player GetFromViewId(int MLAHLLNCFLA)
	{
		PhotonView photonView = PhotonView.Find(MLAHLLNCFLA);
		return (!(photonView == null)) ? photonView.GetComponent<Player>() : null;
	}

	// Token: 0x06019C98 RID: 105624 RVA: 0x00730FE0 File Offset: 0x0072F1E0
	public string NGKELOAKGPD()
	{
		return (this.LNJFBGIBLHA == null) ? "X2" : this.LNJFBGIBLHA.HCPJJFHNCGC();
	}

	// Token: 0x0400460A RID: 17930
	public static List<Player> All = new List<Player>();

	// Token: 0x0400460B RID: 17931
	public static ActionEvent<Player> OnPlayerCreated = new ActionEvent<Player>(32, false);

	// Token: 0x0400460C RID: 17932
	public static ActionEvent<Player> OnPlayerDestroyed = new ActionEvent<Player>(32, false);

	// Token: 0x0400460D RID: 17933
	public static ActionEvent<Player> PlayerSpawnEvent = new ActionEvent<Player>(32, false);

	// Token: 0x0400460E RID: 17934
	public static ActionEvent LocalPlayerSpawnEvent = new ActionEvent(32, false);

	// Token: 0x0400460F RID: 17935
	private const string OODGBFOJPPP = "Player";

	// Token: 0x04004610 RID: 17936
	private const float GMPLCPKGGBP = 10f;

	// Token: 0x04004611 RID: 17937
	public static Player LocalPlayer = null;

	// Token: 0x04004612 RID: 17938
	public static bool LocalPlayerExists = false;

	// Token: 0x04004613 RID: 17939
	private static Collider[] ODIPNIIFFAF = new Collider[16];

	// Token: 0x04004614 RID: 17940
	private static Collider[] DDLPLBEELBP = new Collider[8];

	// Token: 0x04004615 RID: 17941
	private static Collider[] JENPFDJDGME = new Collider[8];

	// Token: 0x04004616 RID: 17942
	private bool EDFMCBBELAM = true;

	// Token: 0x04004617 RID: 17943
	private int BBAKCCCBOEP = -1;

	// Token: 0x04004618 RID: 17944
	private static CapsuleCollider GKKCHJFANKK = null;

	// Token: 0x04004619 RID: 17945
	[SerializeField]
	private Transform trackingSpaceOrigin;

	// Token: 0x0400461A RID: 17946
	[SerializeField]
	private PlayerHead head;

	// Token: 0x0400461B RID: 17947
	private Vector3 PALMENINGNL = Vector3.one;

	// Token: 0x0400461C RID: 17948
	[SerializeField]
	private PlayerBody body;

	// Token: 0x0400461D RID: 17949
	[SerializeField]
	private PlayerHand leftHand;

	// Token: 0x0400461E RID: 17950
	[SerializeField]
	private PlayerHand rightHand;

	// Token: 0x0400461F RID: 17951
	[SerializeField]
	private GameObject[] hideInFirstPerson;

	// Token: 0x04004620 RID: 17952
	[SerializeField]
	private Transform voiceObject;

	// Token: 0x04004621 RID: 17953
	[SerializeField]
	private Texture2D defaultProfileImage;

	// Token: 0x04004622 RID: 17954
	[HideInInspector]
	public FPEGHDDDHCC SavedVoiceChatSettings;

	// Token: 0x04004623 RID: 17955
	[SerializeField]
	[Header("AFK settings")]
	private string afkWarningMessageTitle = "Looks like you are inactive!";

	// Token: 0x04004624 RID: 17956
	private string NLMBOFIPFMH = "Returning to lobby in ";

	// Token: 0x04004625 RID: 17957
	[SerializeField]
	private string afkIntroMessage = "You have been inactive for a long time.\nPlease enter the game again if you wish to continue playing.";

	// Token: 0x04004626 RID: 17958
	[SerializeField]
	private Transform playerIdentity;

	// Token: 0x04004627 RID: 17959
	[SerializeField]
	private Vector3 localIdentityOffset = new Vector3(0f, -0.1f, 0.5f);

	// Token: 0x04004628 RID: 17960
	[Header("Out of Bounds")]
	[SerializeField]
	private float outOfBoundsSpherecastHeight = 2.5f;

	// Token: 0x04004629 RID: 17961
	[SerializeField]
	private float outOfBoundsSpherecastRadius = 0.45f;

	// Token: 0x0400462A RID: 17962
	[SerializeField]
	[Header("Remote vs Local Player Objects")]
	private GameObject[] localPlayerOnlyObjects;

	// Token: 0x0400462B RID: 17963
	[SerializeField]
	private GameObject[] remotePlayerOnlyObjects;

	// Token: 0x0400462C RID: 17964
	[SerializeField]
	[Header("World Collision")]
	private float collisionHeadRadius = 0.35f;

	// Token: 0x0400462D RID: 17965
	[SerializeField]
	private float collisionHeadEpsilon = 0.001f;

	// Token: 0x0400462E RID: 17966
	[SerializeField]
	private float minHeadCollisionDepenetrationDistance = 0.001f;

	// Token: 0x0400462F RID: 17967
	[ENMFCLPAKBJ(FOGKDGELKHN.Self, false)]
	[SerializeField]
	private AnimateInOut animateInOut;

	// Token: 0x04004630 RID: 17968
	[ENMFCLPAKBJ(FOGKDGELKHN.Self, false)]
	[SerializeField]
	private PlayerAudio playerAudio;

	// Token: 0x04004631 RID: 17969
	[SerializeField]
	[ENMFCLPAKBJ(FOGKDGELKHN.Self, false)]
	private PlayerOutfit playerOutfit;

	// Token: 0x04004632 RID: 17970
	[ENMFCLPAKBJ(FOGKDGELKHN.Self, false)]
	[SerializeField]
	private PlayerUI playerUI;

	// Token: 0x04004633 RID: 17971
	[SerializeField]
	[ENMFCLPAKBJ(FOGKDGELKHN.Self, false)]
	private PlayerBackpack playerBackpack;

	// Token: 0x04004634 RID: 17972
	[SerializeField]
	[ENMFCLPAKBJ(FOGKDGELKHN.Self, false)]
	private PlayerParty playerParty;

	// Token: 0x04004635 RID: 17973
	[ENMFCLPAKBJ(FOGKDGELKHN.Self, false)]
	[SerializeField]
	private PlayerLocomotion playerLocomotion;

	// Token: 0x04004636 RID: 17974
	[SerializeField]
	[ENMFCLPAKBJ(FOGKDGELKHN.Self, false)]
	private PlayerModeration playerModeration;

	// Token: 0x04004637 RID: 17975
	[SerializeField]
	private PlayerObjectiveTracker dailiesObjectiveTracker;

	// Token: 0x04004638 RID: 17976
	[SerializeField]
	private PlayerObjectiveTracker newPlayerPunchCardObjectiveTracker;

	// Token: 0x04004639 RID: 17977
	[SerializeField]
	[ENMFCLPAKBJ(FOGKDGELKHN.Self, false)]
	private PlayerProgression playerProgression;

	// Token: 0x0400463A RID: 17978
	[SerializeField]
	[ENMFCLPAKBJ(FOGKDGELKHN.Self, false)]
	private PlayerEmotes playerEmotes;

	// Token: 0x0400463B RID: 17979
	[ENMFCLPAKBJ(FOGKDGELKHN.Self, false)]
	[SerializeField]
	private PlayerEvents playerEvents;

	// Token: 0x0400463C RID: 17980
	[ENMFCLPAKBJ(FOGKDGELKHN.Children, false)]
	[SerializeField]
	private PlayerChaperone playerChaperone;

	// Token: 0x0400463D RID: 17981
	[ENMFCLPAKBJ(FOGKDGELKHN.Children, false)]
	[SerializeField]
	private PlayerFacialAnimator playerFacialAnimator;

	// Token: 0x0400463E RID: 17982
	[ENMFCLPAKBJ(FOGKDGELKHN.Children, false)]
	[SerializeField]
	private PhotonVoiceRecorder voiceRecorder;

	// Token: 0x0400463F RID: 17983
	[ENMFCLPAKBJ(FOGKDGELKHN.Children, false)]
	[SerializeField]
	private PhotonVoiceSpeaker voiceSpeaker;

	// Token: 0x04004640 RID: 17984
	private float IBEMNCLJANE;

	// Token: 0x04004641 RID: 17985
	private float KKDGFOAAEID = 60f;

	// Token: 0x04004642 RID: 17986
	private List<PlayerHand> BDIKLIKEBIM;

	// Token: 0x04004643 RID: 17987
	private PlayerHand IDGBDKLOLGN;

	// Token: 0x04004644 RID: 17988
	private float DEOBJENCBGG = -1f;

	// Token: 0x04004645 RID: 17989
	private bool BBIJDJPGPKA = true;

	// Token: 0x04004646 RID: 17990
	private Player.ADFKLFKJEFH FDPDONBHMEC;

	// Token: 0x04004647 RID: 17991
	private float EKECEFNDDAC;

	// Token: 0x04004648 RID: 17992
	private bool LBKLLBLMAGO = true;

	// Token: 0x0400464A RID: 17994
	[NonSerialized]
	public Player.DHIHPJGOAJJ WorldCollisionMode;

	// Token: 0x0400464B RID: 17995
	private bool GDPFNAJDLPD;

	// Token: 0x0400464C RID: 17996
	private float PAGDMPLDHNM;

	// Token: 0x0400464D RID: 17997
	private Player.PPELPGLINBB LMDEFPDOGKA;

	// Token: 0x0400464E RID: 17998
	private DDOGCBFMKFO<EAJABOECGNI> LCOKAJELKDA;

	// Token: 0x04004651 RID: 18001
	private const string FFIOMHLGBFD = "Platform";

	// Token: 0x04004652 RID: 18002
	private const string NHOPMIEPHNJ = "PlatformId";

	// Token: 0x04004653 RID: 18003
	private const float BIDFKIMHBCB = 4f;

	// Token: 0x04004654 RID: 18004
	private const float OFLOJMLEHJG = 20f;

	// Token: 0x04004655 RID: 18005
	private const float KBHANAAHOOA = 1f;

	// Token: 0x04004656 RID: 18006
	private const float AJGMPKGBGOE = 0.2f;

	// Token: 0x04004657 RID: 18007
	private const float NBFOJKENJCE = 0.02f;

	// Token: 0x04004658 RID: 18008
	private const float HMIONHJILHM = 0.1f;

	// Token: 0x04004659 RID: 18009
	private DDOGCBFMKFO<PlatformManager.JNJEBIDGBNH> JPKCMDPEMDF;

	// Token: 0x0400465A RID: 18010
	private DDOGCBFMKFO<ulong> NGIIAOJHKAE;

	// Token: 0x0400465D RID: 18013
	private DDOGCBFMKFO<AudioManager.PFGLMBNKPCO> BEPFHMHDCFJ;

	// Token: 0x0400465E RID: 18014
	private DDOGCBFMKFO<int> PNFHHGHADMB;

	// Token: 0x0400465F RID: 18015
	private Animator PBMAODCJHIH;

	// Token: 0x04004660 RID: 18016
	private Renderer BCNKIKFJBHJ;

	// Token: 0x04004661 RID: 18017
	private Animator PIGACHDDMNA;

	// Token: 0x04004662 RID: 18018
	private Renderer ABINFEAPOHB;

	// Token: 0x04004663 RID: 18019
	private Animator CEKBCIBCMGP;

	// Token: 0x04004664 RID: 18020
	private Renderer PGMLAPIMEMM;

	// Token: 0x04004665 RID: 18021
	private AGFCGHIFLIK KPJILALFECN;

	// Token: 0x04004666 RID: 18022
	private const float EEILCEFNOBN = 1f;

	// Token: 0x04004667 RID: 18023
	private static RaycastHit[] OKNPGANHGIH = new RaycastHit[30];

	// Token: 0x04004668 RID: 18024
	private Stack<string> DPAHOMFBOFE = new Stack<string>();

	// Token: 0x04004669 RID: 18025
	private Stack<string> BCABNDFAKPD = new Stack<string>();

	// Token: 0x0400466A RID: 18026
	private Stack<float> IACLFMLCJDL = new Stack<float>();

	// Token: 0x0400466B RID: 18027
	private Stack<float> IBGGKPFNBKG = new Stack<float>();

	// Token: 0x0400466C RID: 18028
	private DDOGCBFMKFO<bool> ACKDJPKHKAP;

	// Token: 0x0400466D RID: 18029
	private int HHHOLAGBDBA = -1;

	// Token: 0x0400466E RID: 18030
	private float LNGNNJGPDNE;

	// Token: 0x04004672 RID: 18034
	private bool HIBPBKGMMLG = true;

	// Token: 0x02000CA8 RID: 3240
	public enum HDOICGIKKAO
	{
		// Token: 0x04004676 RID: 18038
		None = -1,
		// Token: 0x04004677 RID: 18039
		Head,
		// Token: 0x04004678 RID: 18040
		Torso,
		// Token: 0x04004679 RID: 18041
		LeftHand,
		// Token: 0x0400467A RID: 18042
		RightHand,
		// Token: 0x0400467B RID: 18043
		Mouth
	}

	// Token: 0x02000CA9 RID: 3241
	public enum DHIHPJGOAJJ
	{
		// Token: 0x0400467D RID: 18045
		DISABLED,
		// Token: 0x0400467E RID: 18046
		HEAD_ONLY,
		// Token: 0x0400467F RID: 18047
		HEAD_AND_BODY
	}

	// Token: 0x02000CAA RID: 3242
	[Flags]
	public enum PPELPGLINBB
	{
		// Token: 0x04004681 RID: 18049
		NONE = 0,
		// Token: 0x04004682 RID: 18050
		RELATIONSHIP_MUTE = 1,
		// Token: 0x04004683 RID: 18051
		VOICE_TYPE_MUTE = 2,
		// Token: 0x04004684 RID: 18052
		GESTURE_MUTE = 4,
		// Token: 0x04004685 RID: 18053
		PTT_MUTE = 8,
		// Token: 0x04004686 RID: 18054
		AFK_MUTE = 16
	}

	// Token: 0x02000CAB RID: 3243
	private enum ADFKLFKJEFH
	{
		// Token: 0x04004688 RID: 18056
		IN_BOUNDS,
		// Token: 0x04004689 RID: 18057
		OUT_OF_BOUNDS_GRACE_PERIOD,
		// Token: 0x0400468A RID: 18058
		OUT_OF_BOUNDS
	}
}