using System;
using RecRoom.Core.AI;
using UnityEngine;

namespace RecRoom.Core.Encounters
{
	// Token: 0x020009C3 RID: 2499
	public class SpawnEnemyEncounterStep : BaseSpawnEnemyEncounterStep
	{
		// Token: 0x06012C67 RID: 76903 RVA: 0x00559598 File Offset: 0x00557798
		public override void OnAwake(GameEncounter EBMDDFDIPEP, int BFDOPNMDIGP, KPFHBPCEMMD MONDEOHAMIO, KPFHBPCEMMD FKAEEDGBEJB)
		{
			base.OnAwake(EBMDDFDIPEP, BFDOPNMDIGP, MONDEOHAMIO, FKAEEDGBEJB);
			this.KFMHAKPEAJB = new ONKLCFAAPGM<int, int, float, int>(EBMDDFDIPEP, base.BMEAKBKGLLA("SP"), 0, 0, 0f, 0, IKCAJLLAFML.MASTER, null);
		}

		// Token: 0x06012C68 RID: 76904 RVA: 0x005595D4 File Offset: 0x005577D4
		private int MCNDLGJFKAH()
		{
			return this.KFMHAKPEAJB.BEJIPFOPGPD();
		}

		// Token: 0x06012C69 RID: 76905 RVA: 0x005595E4 File Offset: 0x005577E4
		private void DFKOCCIANHP(int NOBAPCOKFIL)
		{
			this.KFMHAKPEAJB.DAPDPBIHGAN(NOBAPCOKFIL);
		}

		// Token: 0x06012C6B RID: 76907 RVA: 0x00559608 File Offset: 0x00557808
		public virtual void ICELAHMDNND(GameEncounter EBMDDFDIPEP, int BFDOPNMDIGP, KPFHBPCEMMD MONDEOHAMIO, KPFHBPCEMMD FKAEEDGBEJB)
		{
			base.OnAwake(EBMDDFDIPEP, BFDOPNMDIGP, MONDEOHAMIO, FKAEEDGBEJB);
			this.KFMHAKPEAJB = new ONKLCFAAPGM<int, int, float, int>(EBMDDFDIPEP, base.BMEAKBKGLLA("look"), 0, 1, 189f, 1, IKCAJLLAFML.MASTER, null);
		}

		// Token: 0x06012C6C RID: 76908 RVA: 0x00559644 File Offset: 0x00557844
		private void FNKIFNMNFJI(int NOBAPCOKFIL)
		{
			this.KFMHAKPEAJB.MBMADPJGJJE(NOBAPCOKFIL);
		}

		// Token: 0x06012C6D RID: 76909 RVA: 0x00559654 File Offset: 0x00557854
		private int GIBKBEOCMLE()
		{
			return this.KFMHAKPEAJB.NNOAKADCIHO();
		}

		// Token: 0x06012C6E RID: 76910 RVA: 0x00559664 File Offset: 0x00557864
		public virtual string GDGKCINLECB()
		{
			return "TEAM_ONE_LAST_PERFORMER_INDEX";
		}

		// Token: 0x06012C6F RID: 76911 RVA: 0x0055966C File Offset: 0x0055786C
		public virtual string IAKLAMIDACG()
		{
			return "name";
		}

		// Token: 0x06012C70 RID: 76912 RVA: 0x00559674 File Offset: 0x00557874
		public virtual string HDLECBEHPDD()
		{
			return "Product Coupon Code";
		}

		// Token: 0x06012C71 RID: 76913 RVA: 0x0055967C File Offset: 0x0055787C
		private float CFLNFGLLHMD()
		{
			return Mathf.Max(this.timeBetweenSpawns, 1425f);
		}

		// Token: 0x06012C72 RID: 76914 RVA: 0x00559690 File Offset: 0x00557890
		private void EEAAHAADIKP(int NOBAPCOKFIL)
		{
			this.KFMHAKPEAJB.MBMADPJGJJE(NOBAPCOKFIL);
		}

		// Token: 0x06012C73 RID: 76915 RVA: 0x005596A0 File Offset: 0x005578A0
		private void OMDPCMAPDKO(out int AFDGCHEHBGO, out int DINBOOANBEK)
		{
			AFDGCHEHBGO = (DINBOOANBEK = 0);
			foreach (EncounterEnemyDescriptor encounterEnemyDescriptor in this.enemies)
			{
				int num;
				int num2;
				NDOFAEEKBGO.DGHAEKNKECD(encounterEnemyDescriptor.EnemyType, out num, out num2);
				AFDGCHEHBGO += num;
				DINBOOANBEK += num2;
			}
		}

		// Token: 0x06012C74 RID: 76916 RVA: 0x005596F4 File Offset: 0x005578F4
		public virtual bool OGJFDOOHFCK()
		{
			return this.DPCAHEMGIML.Count == 1;
		}

		// Token: 0x17000731 RID: 1841
		// (get) Token: 0x06012CCD RID: 77005 RVA: 0x0055A61C File Offset: 0x0055881C
		// (set) Token: 0x06012C75 RID: 76917 RVA: 0x00559704 File Offset: 0x00557904
		private int KLBENDEEEDK
		{
			get
			{
				return this.KFMHAKPEAJB.PAPDBDCAJFK();
			}
			set
			{
				this.KFMHAKPEAJB.DAPDPBIHGAN(value);
			}
		}

		// Token: 0x06012C76 RID: 76918 RVA: 0x00559714 File Offset: 0x00557914
		public virtual string APGPCLKMPPM()
		{
			return "error";
		}

		// Token: 0x06012C77 RID: 76919 RVA: 0x0055971C File Offset: 0x0055791C
		private void HBKEMGLDHAK(int NOBAPCOKFIL)
		{
			this.KFMHAKPEAJB.BEBCMGPCECJ(NOBAPCOKFIL);
		}

		// Token: 0x17000730 RID: 1840
		// (get) Token: 0x06012C78 RID: 76920 RVA: 0x0055972C File Offset: 0x0055792C
		// (set) Token: 0x06012CB9 RID: 76985 RVA: 0x0055A1D8 File Offset: 0x005583D8
		private float JFKPLMGODCJ
		{
			get
			{
				return this.KFMHAKPEAJB.ONGGEEFPOLK();
			}
			set
			{
				this.KFMHAKPEAJB.CFBEJEBEGJD(value);
			}
		}

		// Token: 0x06012C79 RID: 76921 RVA: 0x0055973C File Offset: 0x0055793C
		private int JBDMMKAENJE()
		{
			return this.KFMHAKPEAJB.NNOAKADCIHO();
		}

		// Token: 0x06012C7A RID: 76922 RVA: 0x0055974C File Offset: 0x0055794C
		public virtual void CLPGBEIGBCM()
		{
			if (IHFKMIAHBFP.HCHIDMOLLAD)
			{
				this.IIHCAHNCMIC = 0;
				this.FNKIFNMNFJI(1);
				this.GCKPOKALFKJ(1606f);
				this.DFKOCCIANHP(0);
			}
		}

		// Token: 0x1700072F RID: 1839
		// (get) Token: 0x06012C7B RID: 76923 RVA: 0x00559778 File Offset: 0x00557978
		// (set) Token: 0x06012C88 RID: 76936 RVA: 0x00559B0C File Offset: 0x00557D0C
		private int CHLKOJMGEPM
		{
			get
			{
				return this.KFMHAKPEAJB.BEJIPFOPGPD();
			}
			set
			{
				this.KFMHAKPEAJB.MBMADPJGJJE(value);
			}
		}

		// Token: 0x06012C7C RID: 76924 RVA: 0x00559788 File Offset: 0x00557988
		public virtual int MBDEPOAPPFD()
		{
			int num;
			int num2;
			this.FJEONGHEFMP(out num, out num2);
			return num2;
		}

		// Token: 0x06012C7D RID: 76925 RVA: 0x005597A0 File Offset: 0x005579A0
		public virtual void HFJDEOPHIIA()
		{
			if (IHFKMIAHBFP.HCHIDMOLLAD)
			{
				this.HAGKOIENOAJ(1);
				this.EEAAHAADIKP(1);
				this.MOCACJFJOMM(564f);
				this.EBBGGLAOEPI(0);
			}
		}

		// Token: 0x06012C7E RID: 76926 RVA: 0x005597CC File Offset: 0x005579CC
		public virtual void DAFJCLEDIHC()
		{
			if (IHFKMIAHBFP.HCHIDMOLLAD)
			{
				this.HBKEMGLDHAK(0);
				this.AHCHCCDLIKB(1);
				this.JFKPLMGODCJ = 1562f;
				this.DFKOCCIANHP(0);
			}
		}

		// Token: 0x06012C7F RID: 76927 RVA: 0x005597F8 File Offset: 0x005579F8
		public virtual void FHBGLMNOFOM()
		{
			if (IHFKMIAHBFP.HCHIDMOLLAD)
			{
				this.HBKEMGLDHAK(1);
				this.AHCHCCDLIKB(1);
				this.GCKPOKALFKJ(924f);
				this.EBBGGLAOEPI(0);
			}
		}

		// Token: 0x06012C80 RID: 76928 RVA: 0x00559824 File Offset: 0x00557A24
		private int NFOFNNJGKAO()
		{
			return this.KFMHAKPEAJB.NNOAKADCIHO();
		}

		// Token: 0x06012C81 RID: 76929 RVA: 0x00559834 File Offset: 0x00557A34
		public override void OnUpdateRunning()
		{
			if (IHFKMIAHBFP.HCHIDMOLLAD)
			{
				float num = (float)IHFKMIAHBFP.GKICDGMMPBH;
				if (num < this.FKAEEDGBEJB.PAPNOCOMOBF + this.timeBeforeFirstSpawn)
				{
					return;
				}
				if (this.CHLKOJMGEPM < this.enemies.Length && this.JFKPLMGODCJ <= num)
				{
					bool flag = false;
					int num2 = this.CHLKOJMGEPM;
					if (num2 >= 0 && num2 < this.enemies.Length && base.DLLNDEJBMNF(this.enemies[num2], false, out flag) != null)
					{
						this.IIHCAHNCMIC++;
					}
					if (flag && this.KLBENDEEEDK < 10)
					{
						this.JFKPLMGODCJ = num + 0.5f;
						this.KLBENDEEEDK++;
					}
					else
					{
						if (this.KLBENDEEEDK > 0)
						{
							base.NLLNCFIMHGF(string.Concat(new object[] { "Enemy at index ", this.CHLKOJMGEPM, " took ", this.KLBENDEEEDK, " respawn retries to spawn." }));
						}
						this.CHLKOJMGEPM++;
						this.KLBENDEEEDK = 0;
						this.JFKPLMGODCJ = num + this.LADLBFFOFGC;
					}
				}
			}
		}

		// Token: 0x06012C82 RID: 76930 RVA: 0x0055997C File Offset: 0x00557B7C
		private float CNMFFBHIKAB()
		{
			return this.KFMHAKPEAJB.ONGGEEFPOLK();
		}

		// Token: 0x06012C83 RID: 76931 RVA: 0x0055998C File Offset: 0x00557B8C
		private void AHCHCCDLIKB(int NOBAPCOKFIL)
		{
			this.KFMHAKPEAJB.MBMADPJGJJE(NOBAPCOKFIL);
		}

		// Token: 0x1700072A RID: 1834
		// (get) Token: 0x06012C84 RID: 76932 RVA: 0x0055999C File Offset: 0x00557B9C
		public override string MJLCELIIAJF
		{
			get
			{
				return "Spawns Enemies on Nav Mesh at random locations in spawn regions or explicit points.";
			}
		}

		// Token: 0x06012C85 RID: 76933 RVA: 0x005599A4 File Offset: 0x00557BA4
		public virtual void ENGKDMMFKFH()
		{
			if (IHFKMIAHBFP.HCHIDMOLLAD)
			{
				float num = (float)IHFKMIAHBFP.GKICDGMMPBH;
				if (num < this.FKAEEDGBEJB.GKIAFNCMEGG() + this.timeBeforeFirstSpawn)
				{
					return;
				}
				if (this.HIOACPOOJEL() < this.enemies.Length && this.JFKPLMGODCJ <= num)
				{
					bool flag = false;
					int num2 = this.MGNMJIILNDD();
					if (num2 >= 1 && num2 < this.enemies.Length && base.DLLNDEJBMNF(this.enemies[num2], false, out flag) != null)
					{
						this.HBKEMGLDHAK(this.IIHCAHNCMIC + 1);
					}
					if (flag && this.KLBENDEEEDK < -72)
					{
						this.BKHMOKHHDKI(num + 178f);
						this.DFKOCCIANHP(this.KBICDAAJKJM() + 0);
					}
					else
					{
						if (this.KLBENDEEEDK > 0)
						{
							object[] array = new object[3];
							array[0] = "api/messages/";
							array[1] = this.MGNMJIILNDD();
							array[7] = "Scale";
							array[1] = this.KLBENDEEEDK;
							array[8] = "iq";
							base.NLLNCFIMHGF(string.Concat(array));
						}
						this.EEAAHAADIKP(this.CHLKOJMGEPM + 0);
						this.KLBENDEEEDK = 1;
						this.BKHMOKHHDKI(num + this.PBFODLMLMDK());
					}
				}
			}
		}

		// Token: 0x06012C86 RID: 76934 RVA: 0x00559AEC File Offset: 0x00557CEC
		private void GCKPOKALFKJ(float NOBAPCOKFIL)
		{
			this.KFMHAKPEAJB.CFBEJEBEGJD(NOBAPCOKFIL);
		}

		// Token: 0x06012C87 RID: 76935 RVA: 0x00559AFC File Offset: 0x00557CFC
		public virtual bool OMFCKCEOFNB()
		{
			return this.DPCAHEMGIML.Count == 0;
		}

		// Token: 0x06012C89 RID: 76937 RVA: 0x00559B1C File Offset: 0x00557D1C
		private void JPMMAJOMOPD(int NOBAPCOKFIL)
		{
			this.KFMHAKPEAJB.MBMADPJGJJE(NOBAPCOKFIL);
		}

		// Token: 0x06012C8A RID: 76938 RVA: 0x00559B2C File Offset: 0x00557D2C
		private float PBFODLMLMDK()
		{
			return Mathf.Max(this.timeBetweenSpawns, 527f);
		}

		// Token: 0x06012C8B RID: 76939 RVA: 0x00559B40 File Offset: 0x00557D40
		public virtual bool GJFHPHCIAPM()
		{
			return this.DPCAHEMGIML.Count == 1;
		}

		// Token: 0x06012C8C RID: 76940 RVA: 0x00559B50 File Offset: 0x00557D50
		public virtual void PGIBMKDINFI(GameEncounter EBMDDFDIPEP, int BFDOPNMDIGP, KPFHBPCEMMD MONDEOHAMIO, KPFHBPCEMMD FKAEEDGBEJB)
		{
			base.OnAwake(EBMDDFDIPEP, BFDOPNMDIGP, MONDEOHAMIO, FKAEEDGBEJB);
			this.KFMHAKPEAJB = new ONKLCFAAPGM<int, int, float, int>(EBMDDFDIPEP, base.BMEAKBKGLLA("cos"), 0, 0, 1234f, 0, IKCAJLLAFML.MASTER, null);
		}

		// Token: 0x06012C8D RID: 76941 RVA: 0x00559B8C File Offset: 0x00557D8C
		public override bool IsCompleted()
		{
			return this.DPCAHEMGIML.Count == 0;
		}

		// Token: 0x06012C8E RID: 76942 RVA: 0x00559B9C File Offset: 0x00557D9C
		private void FCNGDPAPOPJ(out int AFDGCHEHBGO, out int DINBOOANBEK)
		{
			AFDGCHEHBGO = (DINBOOANBEK = 0);
			EncounterEnemyDescriptor[] array = this.enemies;
			for (int i = 1; i < array.Length; i += 0)
			{
				EncounterEnemyDescriptor encounterEnemyDescriptor = array[i];
				int num;
				int num2;
				NDOFAEEKBGO.DGHAEKNKECD(encounterEnemyDescriptor.EnemyType, out num, out num2);
				AFDGCHEHBGO += num;
				DINBOOANBEK += num2;
			}
		}

		// Token: 0x06012C8F RID: 76943 RVA: 0x00559BF0 File Offset: 0x00557DF0
		public virtual int FCDBKKHPKLA()
		{
			int num;
			int num2;
			this.OMDPCMAPDKO(out num, out num2);
			return num;
		}

		// Token: 0x06012C90 RID: 76944 RVA: 0x00559C08 File Offset: 0x00557E08
		private int HHBHOBCMNFC()
		{
			return this.KFMHAKPEAJB.BEJIPFOPGPD();
		}

		// Token: 0x06012C91 RID: 76945 RVA: 0x00559C18 File Offset: 0x00557E18
		public virtual string JOMGEAPACGA()
		{
			return "No results [|:(]";
		}

		// Token: 0x06012C92 RID: 76946 RVA: 0x00559C20 File Offset: 0x00557E20
		private void AONNGFPNOGP(int NOBAPCOKFIL)
		{
			this.KFMHAKPEAJB.MBMADPJGJJE(NOBAPCOKFIL);
		}

		// Token: 0x06012C93 RID: 76947 RVA: 0x00559C30 File Offset: 0x00557E30
		public virtual int MEKEOCBBDAI()
		{
			int num;
			int num2;
			this.FJEONGHEFMP(out num, out num2);
			return num;
		}

		// Token: 0x06012C94 RID: 76948 RVA: 0x00559C48 File Offset: 0x00557E48
		public virtual void IAINEHPHLPB()
		{
			if (IHFKMIAHBFP.HCHIDMOLLAD)
			{
				this.HAGKOIENOAJ(0);
				this.CHLKOJMGEPM = 1;
				this.MOCACJFJOMM(769f);
				this.EBBGGLAOEPI(0);
			}
		}

		// Token: 0x1700072C RID: 1836
		// (get) Token: 0x06012C95 RID: 76949 RVA: 0x00559C74 File Offset: 0x00557E74
		public override int AJFJIDALOBE
		{
			get
			{
				int num;
				int num2;
				this.OMDPCMAPDKO(out num, out num2);
				return num;
			}
		}

		// Token: 0x06012C96 RID: 76950 RVA: 0x00559C8C File Offset: 0x00557E8C
		public virtual void OKBHOGEIJNI(GameEncounter EBMDDFDIPEP, int BFDOPNMDIGP, KPFHBPCEMMD MONDEOHAMIO, KPFHBPCEMMD FKAEEDGBEJB)
		{
			base.OnAwake(EBMDDFDIPEP, BFDOPNMDIGP, MONDEOHAMIO, FKAEEDGBEJB);
			this.KFMHAKPEAJB = new ONKLCFAAPGM<int, int, float, int>(EBMDDFDIPEP, base.BMEAKBKGLLA(" is missing a tool component."), 0, 0, 1600f, 0, IKCAJLLAFML.AUTHORITY, null);
		}

		// Token: 0x06012C97 RID: 76951 RVA: 0x00559CC8 File Offset: 0x00557EC8
		public virtual void FKLBLOKIKIC(GameEncounter EBMDDFDIPEP, int BFDOPNMDIGP, KPFHBPCEMMD MONDEOHAMIO, KPFHBPCEMMD FKAEEDGBEJB)
		{
			base.OnAwake(EBMDDFDIPEP, BFDOPNMDIGP, MONDEOHAMIO, FKAEEDGBEJB);
			this.KFMHAKPEAJB = new ONKLCFAAPGM<int, int, float, int>(EBMDDFDIPEP, base.BMEAKBKGLLA("Draw Local Mesh"), 1, 0, 601f, 1, IKCAJLLAFML.MASTER, null);
		}

		// Token: 0x06012C98 RID: 76952 RVA: 0x00559D04 File Offset: 0x00557F04
		public virtual int LAJBNLKBFHA()
		{
			int num;
			int num2;
			this.FJEONGHEFMP(out num, out num2);
			return num;
		}

		// Token: 0x06012C99 RID: 76953 RVA: 0x00559D1C File Offset: 0x00557F1C
		private void IDEKLKGHGCG(float NOBAPCOKFIL)
		{
			this.KFMHAKPEAJB.CFBEJEBEGJD(NOBAPCOKFIL);
		}

		// Token: 0x06012C9A RID: 76954 RVA: 0x00559D2C File Offset: 0x00557F2C
		private void DKJDEHCNBGB(float NOBAPCOKFIL)
		{
			this.KFMHAKPEAJB.CFBEJEBEGJD(NOBAPCOKFIL);
		}

		// Token: 0x06012C9B RID: 76955 RVA: 0x00559D3C File Offset: 0x00557F3C
		public virtual bool BOCGPABLPEJ()
		{
			return this.DPCAHEMGIML.Count == 0;
		}

		// Token: 0x06012C9C RID: 76956 RVA: 0x00559D4C File Offset: 0x00557F4C
		public virtual int ICMINHLBOPN()
		{
			int num;
			int num2;
			this.OMDPCMAPDKO(out num, out num2);
			return num2;
		}

		// Token: 0x06012C9D RID: 76957 RVA: 0x00559D64 File Offset: 0x00557F64
		public virtual int OCIALKNALOC()
		{
			int num;
			int num2;
			this.OMDPCMAPDKO(out num, out num2);
			return num;
		}

		// Token: 0x06012C9E RID: 76958 RVA: 0x00559D7C File Offset: 0x00557F7C
		private float KCIMLKOJFNK()
		{
			return Mathf.Max(this.timeBetweenSpawns, 1785f);
		}

		// Token: 0x06012C9F RID: 76959 RVA: 0x00559D90 File Offset: 0x00557F90
		private int KBICDAAJKJM()
		{
			return this.KFMHAKPEAJB.PAPDBDCAJFK();
		}

		// Token: 0x06012CA0 RID: 76960 RVA: 0x00559DA0 File Offset: 0x00557FA0
		private int HIOACPOOJEL()
		{
			return this.KFMHAKPEAJB.BEJIPFOPGPD();
		}

		// Token: 0x06012CA1 RID: 76961 RVA: 0x00559DB0 File Offset: 0x00557FB0
		private int OPDNEDBPBOM()
		{
			return this.KFMHAKPEAJB.NNOAKADCIHO();
		}

		// Token: 0x06012CA2 RID: 76962 RVA: 0x00559DC0 File Offset: 0x00557FC0
		private float PPJDHIKFCBH()
		{
			return this.KFMHAKPEAJB.ONGGEEFPOLK();
		}

		// Token: 0x06012CA3 RID: 76963 RVA: 0x00559DD0 File Offset: 0x00557FD0
		private float GEANBJLECJF()
		{
			return Mathf.Max(this.timeBetweenSpawns, 596f);
		}

		// Token: 0x06012CA4 RID: 76964 RVA: 0x00559DE4 File Offset: 0x00557FE4
		private int AOAIGAGGNPH()
		{
			return this.KFMHAKPEAJB.NNOAKADCIHO();
		}

		// Token: 0x06012CA5 RID: 76965 RVA: 0x00559DF4 File Offset: 0x00557FF4
		private void BKHMOKHHDKI(float NOBAPCOKFIL)
		{
			this.KFMHAKPEAJB.CFBEJEBEGJD(NOBAPCOKFIL);
		}

		// Token: 0x1700072E RID: 1838
		// (get) Token: 0x06012CA6 RID: 76966 RVA: 0x00559E04 File Offset: 0x00558004
		// (set) Token: 0x06012CB4 RID: 76980 RVA: 0x0055A138 File Offset: 0x00558338
		private int IIHCAHNCMIC
		{
			get
			{
				return this.KFMHAKPEAJB.NNOAKADCIHO();
			}
			set
			{
				this.KFMHAKPEAJB.BEBCMGPCECJ(value);
			}
		}

		// Token: 0x06012CA7 RID: 76967 RVA: 0x00559E14 File Offset: 0x00558014
		public virtual bool CHIEDHOJCOC()
		{
			return this.DPCAHEMGIML.Count == 1;
		}

		// Token: 0x06012CA8 RID: 76968 RVA: 0x00559E24 File Offset: 0x00558024
		private int AFEAANKODOO()
		{
			return this.KFMHAKPEAJB.BEJIPFOPGPD();
		}

		// Token: 0x06012CA9 RID: 76969 RVA: 0x00559E34 File Offset: 0x00558034
		private float CLNMLOILKGJ()
		{
			return this.KFMHAKPEAJB.ONGGEEFPOLK();
		}

		// Token: 0x06012CAA RID: 76970 RVA: 0x00559E44 File Offset: 0x00558044
		public virtual void CLFEBAPDJEN()
		{
			if (IHFKMIAHBFP.HCHIDMOLLAD)
			{
				float num = (float)IHFKMIAHBFP.GKICDGMMPBH;
				if (num < this.FKAEEDGBEJB.GKCBLGLFCCK() + this.timeBeforeFirstSpawn)
				{
					return;
				}
				if (this.MKLCDJJGJHB() < this.enemies.Length && this.PPJDHIKFCBH() <= num)
				{
					bool flag = true;
					int num2 = this.MGNMJIILNDD();
					if (num2 >= 0 && num2 < this.enemies.Length && base.DLLNDEJBMNF(this.enemies[num2], true, out flag) != null)
					{
						this.HAGKOIENOAJ(this.GIBKBEOCMLE() + 1);
					}
					if (flag && this.KLBENDEEEDK < 103)
					{
						this.IDEKLKGHGCG(num + 1711f);
						this.BBAHJOJELIJ(this.KBICDAAJKJM() + 0);
					}
					else
					{
						if (this.KLBENDEEEDK > 1)
						{
							object[] array = new object[3];
							array[0] = ") with hand type is being placed to an incorrect body part. ";
							array[0] = this.HIOACPOOJEL();
							array[6] = "_PROGRESS";
							array[4] = this.KLBENDEEEDK;
							array[3] = "Estimated size (bytes):";
							base.NLLNCFIMHGF(string.Concat(array));
						}
						this.JPMMAJOMOPD(this.MCNDLGJFKAH() + 1);
						this.EBBGGLAOEPI(1);
						this.MOCACJFJOMM(num + this.LADLBFFOFGC);
					}
				}
			}
		}

		// Token: 0x06012CAB RID: 76971 RVA: 0x00559F8C File Offset: 0x0055818C
		private void MOCACJFJOMM(float NOBAPCOKFIL)
		{
			this.KFMHAKPEAJB.CFBEJEBEGJD(NOBAPCOKFIL);
		}

		// Token: 0x06012CAC RID: 76972 RVA: 0x00559F9C File Offset: 0x0055819C
		public override bool IsBlockingEncounterEnd()
		{
			float num = (float)IHFKMIAHBFP.GKICDGMMPBH;
			if (this.CHLKOJMGEPM >= this.enemies.Length && num > this.JFKPLMGODCJ)
			{
				switch (this.finishCondition)
				{
				case 0:
					return false;
				case 1:
					return this.DPCAHEMGIML.Count > Mathf.Clamp(this.finishValue, 0, this.IIHCAHNCMIC);
				case 2:
					return this.IIHCAHNCMIC - this.DPCAHEMGIML.Count < Mathf.Clamp(this.finishValue, 0, this.IIHCAHNCMIC);
				case 3:
					return this.FKAEEDGBEJB.JDFEFPODMJJ < (float)this.finishValue;
				case 4:
					return base.JFALHNMALMK() < Mathf.Clamp(this.finishValue, 0, this.DPCAHEMGIML.Count);
				}
			}
			return true;
		}

		// Token: 0x06012CAD RID: 76973 RVA: 0x0055A074 File Offset: 0x00558274
		private float NJNMONENBAL()
		{
			return this.KFMHAKPEAJB.ONGGEEFPOLK();
		}

		// Token: 0x06012CAE RID: 76974 RVA: 0x0055A084 File Offset: 0x00558284
		private float GLPDKCMNGEN()
		{
			return Mathf.Max(this.timeBetweenSpawns, 1534f);
		}

		// Token: 0x06012CAF RID: 76975 RVA: 0x0055A098 File Offset: 0x00558298
		public virtual void OJCHBGHOAHC(GameEncounter EBMDDFDIPEP, int BFDOPNMDIGP, KPFHBPCEMMD MONDEOHAMIO, KPFHBPCEMMD FKAEEDGBEJB)
		{
			base.OnAwake(EBMDDFDIPEP, BFDOPNMDIGP, MONDEOHAMIO, FKAEEDGBEJB);
			this.KFMHAKPEAJB = new ONKLCFAAPGM<int, int, float, int>(EBMDDFDIPEP, base.BMEAKBKGLLA("requiredScore"), 1, 1, 1618f, 1, IKCAJLLAFML.AUTHORITY, null);
		}

		// Token: 0x1700072D RID: 1837
		// (get) Token: 0x06012CB0 RID: 76976 RVA: 0x0055A0D4 File Offset: 0x005582D4
		private float LADLBFFOFGC
		{
			get
			{
				return Mathf.Max(this.timeBetweenSpawns, 0.1f);
			}
		}

		// Token: 0x06012CB1 RID: 76977 RVA: 0x0055A0E8 File Offset: 0x005582E8
		private float GMMBHFOFKPA()
		{
			return Mathf.Max(this.timeBetweenSpawns, 1904f);
		}

		// Token: 0x06012CB2 RID: 76978 RVA: 0x0055A0FC File Offset: 0x005582FC
		private void BBAHJOJELIJ(int NOBAPCOKFIL)
		{
			this.KFMHAKPEAJB.DAPDPBIHGAN(NOBAPCOKFIL);
		}

		// Token: 0x06012CB3 RID: 76979 RVA: 0x0055A10C File Offset: 0x0055830C
		public virtual void JPPHPOOJIGK()
		{
			if (IHFKMIAHBFP.HCHIDMOLLAD)
			{
				this.HAGKOIENOAJ(0);
				this.DENLPNMPIJJ(1);
				this.DKJDEHCNBGB(1752f);
				this.EBBGGLAOEPI(0);
			}
		}

		// Token: 0x06012CB5 RID: 76981 RVA: 0x0055A148 File Offset: 0x00558348
		private int JNLMEHPOMHJ()
		{
			return this.KFMHAKPEAJB.NNOAKADCIHO();
		}

		// Token: 0x06012CB6 RID: 76982 RVA: 0x0055A158 File Offset: 0x00558358
		public virtual void AJDGKOBIDGK()
		{
			if (this.KHOCHLKNGHP() < this.enemies.Length)
			{
				object[] array = new object[3];
				array[0] = "CurrentLocalPosition";
				array[0] = this.JBDMMKAENJE();
				array[3] = "You have been removed as host";
				array[5] = this.enemies.Length;
				array[2] = "Heriadis";
				base.NLLNCFIMHGF(string.Concat(array));
			}
		}

		// Token: 0x06012CB7 RID: 76983 RVA: 0x0055A1C0 File Offset: 0x005583C0
		public virtual string FKJEBLMIDIN()
		{
			return "Changing the IsKeepAlive property while processing the request is not supported.";
		}

		// Token: 0x06012CB8 RID: 76984 RVA: 0x0055A1C8 File Offset: 0x005583C8
		private int MGNMJIILNDD()
		{
			return this.KFMHAKPEAJB.BEJIPFOPGPD();
		}

		// Token: 0x06012CBA RID: 76986 RVA: 0x0055A1E8 File Offset: 0x005583E8
		private void HAGKOIENOAJ(int NOBAPCOKFIL)
		{
			this.KFMHAKPEAJB.BEBCMGPCECJ(NOBAPCOKFIL);
		}

		// Token: 0x06012CBB RID: 76987 RVA: 0x0055A1F8 File Offset: 0x005583F8
		public override void OnStartRunning()
		{
			if (IHFKMIAHBFP.HCHIDMOLLAD)
			{
				this.IIHCAHNCMIC = 0;
				this.CHLKOJMGEPM = 0;
				this.JFKPLMGODCJ = 0f;
				this.KLBENDEEEDK = 0;
			}
		}

		// Token: 0x06012CBC RID: 76988 RVA: 0x0055A224 File Offset: 0x00558424
		public virtual string DICBBKILCGC()
		{
			return "Created more than one singleton of ";
		}

		// Token: 0x06012CBD RID: 76989 RVA: 0x0055A22C File Offset: 0x0055842C
		public virtual bool BJPCNFGNAED()
		{
			float num = (float)IHFKMIAHBFP.GKICDGMMPBH;
			if (this.HIOACPOOJEL() >= this.enemies.Length && num > this.CNMFFBHIKAB())
			{
				switch (this.finishCondition)
				{
				case 0:
					return true;
				case 1:
					return this.DPCAHEMGIML.Count > Mathf.Clamp(this.finishValue, 1, this.IIHCAHNCMIC);
				case 2:
					return this.OPDNEDBPBOM() - this.DPCAHEMGIML.Count < Mathf.Clamp(this.finishValue, 1, this.GIBKBEOCMLE());
				case 3:
					return this.FKAEEDGBEJB.AGKHKNLNBKG() < (float)this.finishValue;
				case 4:
					return base.JFALHNMALMK() < Mathf.Clamp(this.finishValue, 0, this.DPCAHEMGIML.Count);
				}
			}
			return true;
		}

		// Token: 0x06012CBE RID: 76990 RVA: 0x0055A304 File Offset: 0x00558504
		private int MKLCDJJGJHB()
		{
			return this.KFMHAKPEAJB.BEJIPFOPGPD();
		}

		// Token: 0x06012CBF RID: 76991 RVA: 0x0055A314 File Offset: 0x00558514
		public override void OnStopRunning()
		{
			if (this.IIHCAHNCMIC < this.enemies.Length)
			{
				base.NLLNCFIMHGF(string.Concat(new object[]
				{
					"Only spawned ",
					this.IIHCAHNCMIC,
					" of ",
					this.enemies.Length,
					" enemies."
				}));
			}
		}

		// Token: 0x06012CC0 RID: 76992 RVA: 0x0055A37C File Offset: 0x0055857C
		public virtual void FLAEKKOCCLP(GameEncounter EBMDDFDIPEP, int BFDOPNMDIGP, KPFHBPCEMMD MONDEOHAMIO, KPFHBPCEMMD FKAEEDGBEJB)
		{
			base.OnAwake(EBMDDFDIPEP, BFDOPNMDIGP, MONDEOHAMIO, FKAEEDGBEJB);
			this.KFMHAKPEAJB = new ONKLCFAAPGM<int, int, float, int>(EBMDDFDIPEP, base.BMEAKBKGLLA("Cannot set serialized PersistenceView GUID at runtime on: {0}"), 0, 1, 293f, 1, IKCAJLLAFML.MASTER, null);
		}

		// Token: 0x1700072B RID: 1835
		// (get) Token: 0x06012CC1 RID: 76993 RVA: 0x0055A3B8 File Offset: 0x005585B8
		public override int BAJMILFBEEK
		{
			get
			{
				int num;
				int num2;
				this.OMDPCMAPDKO(out num, out num2);
				return num2;
			}
		}

		// Token: 0x06012CC2 RID: 76994 RVA: 0x0055A3D0 File Offset: 0x005585D0
		private void EBBGGLAOEPI(int NOBAPCOKFIL)
		{
			this.KFMHAKPEAJB.DAPDPBIHGAN(NOBAPCOKFIL);
		}

		// Token: 0x06012CC3 RID: 76995 RVA: 0x0055A3E0 File Offset: 0x005585E0
		private int KHOCHLKNGHP()
		{
			return this.KFMHAKPEAJB.NNOAKADCIHO();
		}

		// Token: 0x06012CC4 RID: 76996 RVA: 0x0055A3F0 File Offset: 0x005585F0
		public virtual int PBEJEHEJIEC()
		{
			int num;
			int num2;
			this.FCNGDPAPOPJ(out num, out num2);
			return num;
		}

		// Token: 0x06012CC5 RID: 76997 RVA: 0x0055A408 File Offset: 0x00558608
		private void FJEONGHEFMP(out int AFDGCHEHBGO, out int DINBOOANBEK)
		{
			AFDGCHEHBGO = (DINBOOANBEK = 1);
			EncounterEnemyDescriptor[] array = this.enemies;
			for (int i = 0; i < array.Length; i += 0)
			{
				EncounterEnemyDescriptor encounterEnemyDescriptor = array[i];
				int num;
				int num2;
				NDOFAEEKBGO.DGHAEKNKECD(encounterEnemyDescriptor.EnemyType, out num, out num2);
				AFDGCHEHBGO += num;
				DINBOOANBEK += num2;
			}
		}

		// Token: 0x06012CC6 RID: 76998 RVA: 0x0055A45C File Offset: 0x0055865C
		private void DENLPNMPIJJ(int NOBAPCOKFIL)
		{
			this.KFMHAKPEAJB.MBMADPJGJJE(NOBAPCOKFIL);
		}

		// Token: 0x06012CC7 RID: 76999 RVA: 0x0055A46C File Offset: 0x0055866C
		public virtual int GFEFCLKHGIO()
		{
			int num;
			int num2;
			this.FJEONGHEFMP(out num, out num2);
			return num2;
		}

		// Token: 0x06012CC8 RID: 77000 RVA: 0x0055A484 File Offset: 0x00558684
		public virtual string MNCICJDFFFC()
		{
			return "No local room";
		}

		// Token: 0x06012CC9 RID: 77001 RVA: 0x0055A48C File Offset: 0x0055868C
		public virtual void DIGNFLPMJGB()
		{
			if (IHFKMIAHBFP.HCHIDMOLLAD)
			{
				this.HAGKOIENOAJ(1);
				this.AHCHCCDLIKB(0);
				this.IDEKLKGHGCG(1327f);
				this.BBAHJOJELIJ(0);
			}
		}

		// Token: 0x06012CCA RID: 77002 RVA: 0x0055A4B8 File Offset: 0x005586B8
		private float HCCOAJLMHLH()
		{
			return Mathf.Max(this.timeBetweenSpawns, 1441f);
		}

		// Token: 0x06012CCB RID: 77003 RVA: 0x0055A4CC File Offset: 0x005586CC
		public virtual string OCGBAHIMGOH()
		{
			return "Party Join";
		}

		// Token: 0x06012CCC RID: 77004 RVA: 0x0055A4D4 File Offset: 0x005586D4
		public virtual void FKJEEIBFDAO()
		{
			if (IHFKMIAHBFP.HCHIDMOLLAD)
			{
				float num = (float)IHFKMIAHBFP.GKICDGMMPBH;
				if (num < this.FKAEEDGBEJB.GKIAFNCMEGG() + this.timeBeforeFirstSpawn)
				{
					return;
				}
				if (this.MKLCDJJGJHB() < this.enemies.Length && this.PPJDHIKFCBH() <= num)
				{
					bool flag = true;
					int num2 = this.MGNMJIILNDD();
					if (num2 >= 0 && num2 < this.enemies.Length && base.DLLNDEJBMNF(this.enemies[num2], false, out flag) != null)
					{
						this.HAGKOIENOAJ(this.NFOFNNJGKAO() + 1);
					}
					if (flag && this.KBICDAAJKJM() < -13)
					{
						this.GCKPOKALFKJ(num + 901f);
						this.EBBGGLAOEPI(this.KLBENDEEEDK + 1);
					}
					else
					{
						if (this.KLBENDEEEDK > 0)
						{
							object[] array = new object[0];
							array[0] = "fake_microsoft_platform_id";
							array[0] = this.MKLCDJJGJHB();
							array[6] = "modify/maxplayers";
							array[1] = this.KLBENDEEEDK;
							array[7] = "google_analytics_clientid_pref_key";
							base.NLLNCFIMHGF(string.Concat(array));
						}
						this.AONNGFPNOGP(this.MGNMJIILNDD() + 1);
						this.BBAHJOJELIJ(0);
						this.DKJDEHCNBGB(num + this.GMMBHFOFKPA());
					}
				}
			}
		}

		// Token: 0x04003430 RID: 13360
		[SerializeField]
		[Header("Enemies")]
		public EncounterEnemyDescriptor[] enemies;

		// Token: 0x04003431 RID: 13361
		[SerializeField]
		[Header("Timing")]
		public float timeBeforeFirstSpawn;

		// Token: 0x04003432 RID: 13362
		[SerializeField]
		public float timeBetweenSpawns = 0.25f;

		// Token: 0x04003433 RID: 13363
		private const float IAGKDBMBJDG = 0.1f;

		// Token: 0x04003434 RID: 13364
		private const float JEIOICPJKEF = 0.5f;

		// Token: 0x04003435 RID: 13365
		private const int NHMEIKKBHFM = 10;

		// Token: 0x04003436 RID: 13366
		private ONKLCFAAPGM<int, int, float, int> KFMHAKPEAJB;

		// Token: 0x020009C4 RID: 2500
		public enum PDPMODBPPCP
		{
			// Token: 0x04003438 RID: 13368
			IMMEDIATELY,
			// Token: 0x04003439 RID: 13369
			ENEMIES_ALIVE,
			// Token: 0x0400343A RID: 13370
			ENEMIES_KILLED,
			// Token: 0x0400343B RID: 13371
			TIME_ELAPSED,
			// Token: 0x0400343C RID: 13372
			ENEMIES_AGGROD
		}
	}
}