반갑습니다. 맹주헌입니다.

//====================
// 블럭 게임의 일부입니다
//====================
	void RestoreGameStatus(bool passAppResume=false)
	{
		string data = GameData.GetGameData();
		GameData.ClearGameData();
		
		// NOTE: 튜토리얼 이후 보드상태, 가운데에 4놓여있고 다음유닛은 4
		// data = "E?|1|6|0|1|1|0;2:2:0|0;2:2:6||0:2|13|0";
		
		// NOTE: 가운데 x인 환경
		// data = "E?|1|8|17|3|6|0;6:0:0|0;7:2:6,0;6:2:5,0;4:2:4,0;5:2:3,0;2:2:2,0;6:2:1,0;5:0:6|||14|0";
		
		// D.Log(data);
		// DebugTool.Report(data, false);
		
		if(!string.IsNullOrEmpty(data))
		{
			MakeSavedLevel(data, passAppResume);
		}
		else
		{
			if(Game.skipLevelId > 0)
			{
				int skippedGoal = Game.skipLevelId;
				
				int lastClearGoal = GameData.GetLastClearedGoal(GameSettings.initialGoalA);
				if(lastClearGoal < skippedGoal)
				{
					GameData.SetLastPlayedGoal(skippedGoal);
					GameData.SetLastClearedGoal(skippedGoal);
				}
				
				int skippedLevel = 1;
				for(int i = 0; i < skippedGoal + 10; i += 1)
				{
					if(skippedGoal != GetGoalLevel(i + 1))continue;
					
					skippedLevel = i + 1;
					break;
				}
				
				int nextLevel = skippedLevel + 1;
				
				OpenLevelStart(nextLevel, () => {
					MakeLevel(nextLevel, null, skippedGoal);
				});
			}
			else
			{
				OpenLevelStart(1);
			}
		}
		
		// D.Log(GameData.GetGameData());
	}
	void SaveGameStatus(bool isPlaying=true)
	{
		VUnit goalUnit = model.units.Find((u) => (u.type == UnitType.Block && u.level == goal));
		List remainUnits = model.units.Where((u) => (u != goalUnit && u != model.currUnit)).ToList();
		
		string serializedNextUnit = (model.currUnit == null ? "" : model.currUnit.GetSerializedData());
		if(model.isItemMode && model.keepedUnit != null)serializedNextUnit = model.keepedUnit.GetSerializedData();
		string serializedRemainUnits = remainUnits.Select((u) => u.GetSerializedData()).Join(",");
		string serializedGoalUnit = (goalUnit == null ? "" : goalUnit.GetSerializedData());
		string serializedQueueUnits = unitQueue.Select((u) => $"{((int)u.type)}:{u.level}").Join(",");
		
		string serializedReviceCount = GameData.GetReviveCount().ToString();
		
		GameData.SetGameData($"E?|{stage}|{goal}|{GameData.GetMergeCount()}|{GameData.GetUserLevel()}|{GameData.GetScore()}|{serializedNextUnit}|{serializedRemainUnits}|{serializedGoalUnit}|{serializedQueueUnits}|{GameData.guestId}|{serializedReviceCount}");
	}
}

//====================
	void MergeCoins(List mergeFrom, VUnit mergeTo)
	{
		mergeTo.SetDirty();
		
		Vector3 targetPos = mergeTo.localPos;
		
		//
		int mergeCount = mergeFrom.Count;
		
		int coinIncrAmount = 0;
		for(int i = 0; i < mergeCount; i += 1)
		{
			coinIncrAmount += mergeFrom[i].level - 1 + 3;
		}
		
		if(mergeFrom.Count == 0)
		{
			mergeTo.PlayAnim(VUnit.ANIM_STATE_MERGE_OUT, () => {
				mergeTo.IncrLevel(coinIncrAmount);
				
				mergeTo.PlayAnim(VUnit.ANIM_STATE_MERGE_NEW);
			});
			mergeTo.SetDirty(false);
		}
		else
		{
			for(int i = 0; i < mergeCount; i += 1)
			{
				if(i < mergeCount - 1)
				{
					MergeTo(mergeFrom[i], targetPos);
				}
				else
				{
					MergeTo(mergeFrom[i], targetPos, () => {
						mergeTo.PlayAnim(VUnit.ANIM_STATE_MERGE_OUT, () => {
							mergeTo.IncrLevel(coinIncrAmount);
							
							mergeTo.PlayAnim(VUnit.ANIM_STATE_MERGE_NEW);
						});
						mergeTo.SetDirty(false);
					});
				}
			}
		}
		
		//
		Effect.Spawn(VfxEffectType.Merge, targetPos);
		Effect.Play(model.GetComboSFX());
		Effect.Vibrate((model.GetCombo() > 2 ? VibrationStyle.HEAVY : VibrationStyle.MEDIUM));
		
		//
		model.ReorderUnits(mergeTo);
	}

//====================
	async UniTask WaitEndOfMovingAsync()
	{
		while(true)
		{
			await UniTask.Yield();
			
			int bCount = model.units.Count((u) => u.isMoving);
			
			int kCount = model.removedUnits.Count((u) => u.isMoving);
			if(kCount == 0 && !model.removedUnits.IsNullOrEmpty())
			{
				model.removedUnits.ForEach((u) => u.Release());
				model.removedUnits = new List();
			}
			
			if(bCount + kCount == 0)break;
		}
		
		model.ReorderUnits();
		
		CheckArrows();
		
		SaveGameStatus();
	}
	
	async UniTaskVoid CheckMoveAsync(VUnit unit)
	{
		navigationController.ToggleBlockerPanel(true);
		
		//
		int currentMergeCount = GameData.GetMergeCount();
		
		//
		isWaitingDropAndHit = true;
		currDroppedUnit = unit;
		
		//
		if(model.units.Any((u) => u.isMoving))
		{
			await WaitEndOfMovingAsync();
		}
		
		//
		while(true)
		{
			int changed = 0;
			
			//
			if(DropUnit())
			{
				changed += 1;
				await WaitEndOfMovingAsync();
			}
			
			//
			if(CheckHit())
			{
				changed += 1;
				await WaitEndOfMovingAsync();
			}
			
			//
			if(changed == 0)break;
		}
		
		// NOTE: 딜레이 없고, 콤보는 한번 drop 에서만
		model.UpdateCombo();
		
		await WaitEndOfMovingAsync();
		
		//
		navigationController.ToggleBlockerPanel(false);
		
		//
		isWaitingDropAndHit = false;
		currDroppedUnit = null;
		
		//
		model.CalcActionIds();
		
		//
		CheckArrows();
		
		SaveGameStatus();
		
		//
		if(model.CheckDead() || model.isTimeOver)
		{
			WillGameOver();
			
			if(model.isTimeOver)
			{
				OnTimeOver();
			}
			else
			{
				Effect.Spawn(VfxUIEffectType.BoardFull, () => {
					OnGameOver();
				});
			}
		}
		else
		{
			// int x = (model.IsEmptyCol(model.centerCol, true) ? model.centerCol : -1);
			// NOTE: 마지막 떨어진 곳 사용, 안되면 빈곳
			int x = model.GetEmptyCol(model.lastCol);
			
			VUnit spawnedUnit = (x == -1 ? null : SpawnUnit(x));
			GameData.AddEarnedUnit(spawnedUnit.level);
			
			model.currUnit = spawnedUnit;
			
			//
			env.ShowNextUnit(GetNextUnit(true));
			
			FillNextUnits();
			
			model.ReorderUnits(model.currUnit, true);
			
			CheckArrows();
			
			SaveGameStatus();
		}
	}
					

//====================
// 포커 게임의 일부입니다.
//====================
	void ReplaceCard(Card target)
	{
		DoReplaceCardAsync(target).Forget();
	}
	async UniTaskVoid DoReplaceCardAsync(Card target)
	{
		CancellationToken ct = gameObject.GetCancellationTokenOnDestroy();
		
		//
		target.order = 301;
		
		int x = target.gx;
		int y = target.gy;
		
		float delay = 0.0f;
		
		await MoveBoardCardToTrash.Create(target, Vector3.zero, ref delay).Play().AwaitForComplete(cancellationToken: ct);
		
		model.RemoveCard(target);
		
		//
		Card card = null;
		Sequence seq = DOTween.Sequence();
		
		bool hasNextCard = model.hasNextCard;
		if(hasNextCard)
		{
			card = model.GetCardFromDeck(x, y);
			
			MoveDeckCardToBoard.Create(seq, card, new Vector3(env.GetRealX(x), env.GetRealY(y), 0), card.gy * env.cols + card.gx, ref delay);
			
			hasNextCard = model.hasNextCard;
		}
		if(hasNextCard)
		{
			card = model.GetCardFromDeck(-1, -1, true);
			
			if(!card.isFront)OpenDeckCard.Create(seq, card, ref delay);
		}
		if(seq.Duration() > 0.0f)
		{
			await seq.Play().AwaitForComplete(cancellationToken: ct);
		}
		
		//
		model.UpdateOrders();
		
		//
		if(!hasNextCard)
		{
			WillGameOver();
			
			OnOutOfCards();
		}
	}

//====================
	async UniTaskVoid DoNextAsync(List hands)
	{
		IncrQuest(hands.Count);
		
		//
		await DoMoveHandsToTrashAsync(hands);
		
		await DoDropBoardCardsAsync();
		
		await DoMoveDeckToBoardAsync();
		
		//
		if(!model.hasNextCard)
		{
			WillGameOver();
			OnOutOfCards();
		}
	}
	async UniTask DoMoveHandsToTrashAsync(List hands)
	{
		List cards;
		HandType result = HandSolver.Solve(ref hands, out cards);
		
		if(hands[0].data.Equals(CardData.JOKER))hands[0].SetData(cards[0]);
		hands.Sort();
		
		if(result != HandType.ROYAL_STRAIGHT_FLUSH_NO_WILD && result != HandType.ROYAL_STRAIGHT_FLUSH && result != HandType.STRAIGHT_FLUSH && result != HandType.STRAIGHT)hands.Reverse();
		
		for(int i = 0; i < hands.Count; i += 1)hands[i].order = Mathf.RoundToInt(301 + i);
		
		Dictionary> groups = new Dictionary>();
		Dictionary ranks;
		int[] rks;
		switch(result)
		{
			case HandType.ROYAL_STRAIGHT_FLUSH_NO_WILD:
			case HandType.FIVE_OF_A_KIND:
			case HandType.ROYAL_STRAIGHT_FLUSH:
			case HandType.STRAIGHT_FLUSH:
			case HandType.FLUSH:
			case HandType.STRAIGHT:
				groups[1] = hands;
				break;
				
			case HandType.FOUR_OF_A_KIND:
			case HandType.THREE_OF_A_KIND:
			case HandType.ONE_PAIR:
				ranks = new Dictionary();
				hands.ForEach((c) => {
					if(!ranks.ContainsKey(c.data.rank))ranks[c.data.rank] = 0;
					ranks[c.data.rank] += 1;
				});
				rks = ranks.Keys.OrderBy((r) => -ranks[r]).ToArray();
				
				groups[1] = hands.Where((c) => (c.data.rank == rks[0])).ToList();
				break;
				
			case HandType.FULL_HOUSE:
			case HandType.TWO_PAIR:
				ranks = new Dictionary();
				hands.ForEach((c) => {
					if(!ranks.ContainsKey(c.data.rank))ranks[c.data.rank] = 0;
					ranks[c.data.rank] += 1;
				});
				rks = ranks.Keys.OrderBy((r) => -ranks[r]).ToArray();
				
				groups[1] = hands.Where((c) => (c.data.rank == rks[0])).ToList();
				groups[2] = hands.Where((c) => (c.data.rank == rks[1])).ToList();
				break;
		}
		
		Sequence seq = DOTween.Sequence();
		
		float margin = -env.cardMargin;
		float cardWidth = -env.cardWidth;
		float groupScale = -env.groupScale;
		float sx = ((hands.Count - 1) * margin) * 0.5f;
		float delay = 0.0f;
		
		env.SetHandBackground(true);
		env.SetHandGroup1(false);
		env.SetHandGroup2(false);
		if(groups.ContainsKey(1))
		{
			env.SetHandGroup1(
				true,
				groups[1].Select((c) => new Vector3(sx + hands.IndexOf(c) * cardWidth, 0.0f, 0.0f)).Avg(),
				new Vector3(groups[1].Count * groupScale, groupScale, 0.0f)
			);
		}
		if(groups.ContainsKey(2))
		{
			env.SetHandGroup2(
				true,
				groups[2].Select((c) => new Vector3(sx + hands.IndexOf(c) * cardWidth, 0.0f, 0.0f)).Avg(),
				new Vector3(groups[2].Count * groupScale, groupScale, 0.0f)
			);
		}
		ShowResult.Create(seq, env.handBackground);
		
		for(int i = 0; i < hands.Count; i += 1)
		{
			MoveBoardCardToResult.Create(seq, hands[i], new Vector3(sx + i * 6.0f, 0.0f, 0.0f), ref delay);
		}
		await seq.Play().AwaitForComplete(cancellationToken: ct);
		
		await UniTask.Delay(600, cancellationToken: ct);
		
		hands.ForEach((c) => c.Release());
		
		env.SetHandBackground(false);
	}
	async UniTask DoDropBoardCardsAsync()
	{
		Card card = null;
		
		//
		float delay = 0.0f;
		
		Sequence seq = DOTween.Sequence();
		
		for(int y = env.rows - 1; y > -1; y -= 1)
		{
			for(int x = 0; x < env.cols; x += 1)
			{
				card = model.GetCard(x, y);
				if(card == null)continue;
				
				int ny = -1;
				for(int by = y + 1; by < env.rows; by += 1)
				{
					if(env.IsInside(x, by) && model.GetCard(x, by) != null)break;
					
					ny = by;
				}
				if(ny == -1)continue;
				
				if(card.gy == ny)continue;
				
				model.MoveCard(card, x, ny);
				
				DropBoardCard.Create(seq, card, env.GetRealY(card.gy), card.gy - y, ref delay);
			}
		}
		await seq.Play().AwaitForComplete(cancellationToken: ct);
		
		//
		model.UpdateOrders();
	}
	async UniTask DoMoveDeckToBoardAsync()
	{
		Card card = null;
		
		//
		float delay = 0.0f;
		
		Sequence seq = DOTween.Sequence();
		
		bool hasNextCard = model.hasNextCard;
		if(hasNextCard)
		{
			int loopLimit = model.gridPositions.Count;
			int x, y;
			for(int i = 0; i < loopLimit; i += 1)
			{
				x = model.gridPositions[i].x;
				y = model.gridPositions[i].y;
				
				if(model.GetCard(x, y) != null)continue;
				
				//
				card = model.GetCardFromDeck(x, y);
				
				if(card.isFront)
				{
					MoveDeckCardToBoard.Create(seq, card, new Vector3(env.GetRealX(x), env.GetRealY(y), 0), card.gy * env.cols + card.gx, delay);
					delay += MoveDeckCardToBoard.NextDelay();
				}
				else
				{
					OpenDeckCard.Create(seq, card, delay);
					MoveDeckCardToBoard.Create(seq, card, new Vector3(env.GetRealX(x), env.GetRealY(y), 0), card.gy * env.cols + card.gx, delay + OpenDeckCard.NextDelay());
					delay += MoveDeckCardToBoard.NextDelay();
				}
				
				hasNextCard = model.hasNextCard;
				
				//
				if(!hasNextCard)break;
			}
		}
		
		if(hasNextCard)
		{
			card = model.GetCardFromDeck(-1, -1, true);
			
			if(!card.isFront)OpenDeckCard.Create(seq, card, ref delay);
		}
		
		if(seq.Duration() > 0.0f)
		{
			await seq.Play().AwaitForComplete(cancellationToken: ct);
		}
		
		//
		model.UpdateOrders();
	}
	async UniTask _DoMoveTrashToDeck()
	{
		model.MovePoolToDeck();
		
		//
		float delay = 0.0f;
		
		Sequence seq = DOTween.Sequence();
		
		for(int i = 0; i < model.decks.Count; i += 1)
		{
			MoveTrashCardToDeck.Create(model.decks[i], new Vector3(env.deckX + i * env.deckSpan, env.deckY, 0), ref delay);
		}
		await seq.Play().AwaitForComplete(cancellationToken: ct);
		
		//
		await OpenDeckCard.Create(model.GetCardFromDeck(-1, -1, true)).Play().AwaitForComplete(cancellationToken: ct);
	}
					

//====================
// 퍼즐 게임의 일부입니다.
//====================
	HashSet checkedPairs = new HashSet();
	HashSet cachedRemovableUnits = new HashSet();
	
	VUnit[] targetUnits;
	
	bool waitRemoveConnectUnits = false;
	
	void UpdateJoints()
	{
		bool hasRemovableUnits = (!removableUnits.IsNullOrEmpty());
		if(hasRemovableUnits)removableUnitJoints = new List();
		
		cachedRemovableUnits.Clear();
		for(int i = 0; i < removableUnits.Count; i += 1)cachedRemovableUnits.Add(removableUnits[i]);
		
		checkedPairs.Clear();
		int pairId = 0;
		
		VUnit unit1 = null;
		VUnit unit2 = null;
		UnitBallJoint joint = null;
		
		Vector3 pos1 = Constants.V0;
		Vector3 pos2 = Constants.V0;
		
		bool forceRemoveJoint = false;
		float dist = 0.0f;
		int distCache = 0;
		float distPxl = 0.0f;
		float distSpanPxl = 0.0f;
		int jointType = 0;
		
		targetUnits = units.Where((u) => (u.type == UnitType.Ball)).ToArray();
		
		int total = targetUnits.Length;
		int i, j;
		for(i = 0; i < total; i += 1)
		{
			unit1 = targetUnits[i];
			
			for(j = total - 1; j > -1; j -= 1)
			{
				if(i == j)continue;
				
				//
				unit2 = targetUnits[j];
				
				pairId = (1 + Mathf.Max(unit1.hash, unit2.hash)) * 1000 + (1 + Mathf.Min(unit1.hash, unit2.hash));
				if(checkedPairs.Contains(pairId))continue;
				checkedPairs.Add(pairId);
				
				if(!unit1.Equals(unit2))continue;
				
				if(!VUnit.CanConnect(unit1, unit2))
				{
					RemoveJoint(pairId);
					continue;
				}
				
				if(!unit1.isReady || !unit2.isReady)
				{
					RemoveJoint(pairId);
					continue;
				}
				
				if(unit1.willRemove || unit2.willRemove)
				{
					RemoveJoint(pairId);
					continue;
				}
				
				//
				forceRemoveJoint = (hasRemovableUnits ? (cachedRemovableUnits.Contains(unit1) || cachedRemovableUnits.Contains(unit2)) : false);
				
				pos1 = unit1.pos;
				pos2 = unit2.pos;
				
				dist = Vector3.Distance(pos1, pos2);
				if(dist > env.unitDistanceMax || forceRemoveJoint)
				{
					RemoveJoint(pairId, forceRemoveJoint);
					continue;
				}
				
				distCache = Mathf.FloorToInt(dist * 10000);
				if(cachedJointDistances.ContainsKey(pairId) && cachedJointDistances[pairId] == distCache)continue;
				cachedJointDistances[pairId] = distCache;
				
				distPxl = dist * env.TO_PXL;
				distSpanPxl = distPxl - env.unitPxlSize;
				
				//
				if(!cachedJoints.ContainsKey(pairId))cachedJoints[pairId] = SpawnJoint(env.canvas, unit1.shape);
				joint = cachedJoints[pairId];
				
				jointType = env.CalcJointType(distSpanPxl);
				joint.UpdateLinks(unit1.shape, jointType, pos1, pos2, (distPxl - env.unitSpansEx[jointType]) * env.TO_UNT);
			}
		}
		
		if(hasRemovableUnits)
		{
			waitRemoveConnectUnits = true;
			
			units = units.Except(removableUnits).ToList();
			
			units.ForEach((u) => {
				u.isEnabled = false;
				u.ResetAllVelocity();
			});
			
			//
			removableUnits.ForEach((u) => u.isEnabled = false);
			
			RemoveConnected(
				new List(removableUnits.ToArray()),
				new List(removableUnitJoints.ToArray())
			);
			
			removableUnits.Clear();
			removableConnectedUnits.Clear();
			removableUnitJoints.Clear();
		}
		else
		{
			if(waitRemoveConnectUnits)
			{
				units.ForEach((u) => u.isEnabled = true);
				
				waitRemoveConnectUnits = false;
			}
		}
	}
	void UpdateRemovableUnitJoints()
	{
		if(removableConnectedUnits.IsNullOrEmpty())return;
		
		//
		checkedPairs.Clear();
		int pairId = 0;
		
		VUnit unit1 = null;
		VUnit unit2 = null;
		UnitBallJoint joint = null;
		
		Vector3 pos1 = Constants.V0;
		Vector3 pos2 = Constants.V0;
		
		float dist = 0.0f;
		int distCache = 0;
		float distPxl = 0.0f;
		float distSpanPxl = 0.0f;
		int jointType = 0;
		
		int total = removableConnectedUnits.Count;
		int i, j;
		for(i = 0; i < total; i += 1)
		{
			unit1 = removableConnectedUnits[i];
			
			for(j = total - 1; j > -1; j -= 1)
			{
				if(i == j)continue;
				
				//
				unit2 = removableConnectedUnits[j];
				
				pairId = (1 + Mathf.Max(unit1.hash, unit2.hash)) * 1000 + (1 + Mathf.Min(unit1.hash, unit2.hash));
				if(checkedPairs.Contains(pairId))continue;
				checkedPairs.Add(pairId);
				
				//
				pos1 = unit1.pos;
				pos2 = unit2.pos;
				
				dist = Vector3.Distance(pos1, pos2);
				if(dist > env.unitDistanceMax)
				{
					RemoveJoint(pairId);
					continue;
				}
				
				distCache = Mathf.FloorToInt(dist * 10000);
				if(cachedJointDistances.ContainsKey(pairId) && cachedJointDistances[pairId] == distCache)continue;
				cachedJointDistances[pairId] = distCache;
				
				distPxl = dist * env.TO_PXL;
				distSpanPxl = distPxl - env.unitPxlSize;
				
				//
				if(!cachedJoints.ContainsKey(pairId))cachedJoints[pairId] = SpawnJoint(env.canvas, unit1.shape);
				joint = cachedJoints[pairId];
				
				jointType = env.CalcJointType(distSpanPxl);
				joint.UpdateLinks(unit1.shape, jointType, pos1, pos2, (distPxl - env.unitSpansEx[jointType]) * env.TO_UNT);
			}
		}
	}
	
	void RemoveJoint(int pairId, bool forceRemoveJoint=false)
	{
		if(cachedJointDistances.ContainsKey(pairId))cachedJointDistances.Remove(pairId);
		if(cachedJoints.ContainsKey(pairId))
		{
			if(forceRemoveJoint)
			{
				removableUnitJoints.Add(cachedJoints[pairId]);
			}
			else
			{
				cachedJoints[pairId].Release();
			}
			
			cachedJoints.Remove(pairId);
		}
	}
	void RemoveConnected(List units, List joints)
	{
		// TODO: 이 흐름을 더 합리적으로
		List sideEffectedUnits = new List();
		
		units.ForEach((u) => {
			if(u.type != UnitType.Stone && u.type != UnitType.Minion)
			{
				sideEffectedUnits.AddRange(FindNeighborUnits(units, u, env.explodeDistanceMax));
			}
			
			KillUnit(u);
			
			ReleaseUnit(u);
		});
		joints.ForEach((j) => j.Release(false));
		
		//
		sideEffectedUnits = sideEffectedUnits.Distinct().Where((u) => (u != null && !u.willRemove)).ToList();
		if(sideEffectedUnits.IsNullOrEmpty())
		{
			units.ForEach((u) => u.isEnabled = true);
			
			waitRemoveConnectUnits = false;
		}
		else
		{
			TaskUtil.DelayCall(0.15f, () => {
				sideEffectedUnits.ForEach((u) => {
					// if(u.type == UnitType.Ball && (u.behavior == UnitBehaviorType.Anchor || u.behavior == UnitBehaviorType.Freeze))
					if(u.behavior == UnitBehaviorType.Anchor || u.behavior == UnitBehaviorType.Freeze)
					{
						ActKillUnit(u);
					}
					else if(u.type == UnitType.Bomb)
					{
						ActBomb(u);
					}
					else if(u.type == UnitType.Stone)
					{
						ActKillUnit(u);
					}
				});
			});
		}
	}
					

//====================
// BusJam 류의 퍼즐 게임의 일부입니다.
//====================
	async UniTaskVoid CheckReady(Action onChecked=null)
	{
		waitGameReady = true;
		
		//
		ctsCheckReady = new CancellationTokenSource();
		var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(ctsCheckReady.Token, gameObject.GetCancellationTokenOnDestroy());
		
		// unit이 움직이고
		if(refUnits.Any((g) => g.isBusy))
		{
			await UniTask.WaitUntil(() => !refUnits.Any((g) => g.isBusy), cancellationToken: linkedTokenSource.Token);
			
			UpdateMovable();
		}
		
		//
		while(true)
		{
			// box가 클리어면 나가고 다음것 들어오고
			if(boxes[0].isComplete)
			{
				MoveBox();
				
				if(boxes.Any((g) => g.isBusy))
				{
					await UniTask.WaitUntil(() => !boxes.Any((g) => g.isBusy), cancellationToken: linkedTokenSource.Token);
					
					UpdateMovable();
				}
				
				boxes.RemoveAt(0);
				
				// 새로운 box에 맞는 unit이 슬롯에 있으면 이동시키고
				if(!boxes.IsNullOrEmpty())
				{
					CheckSlotUnitMove();
					
					if(refUnits.Any((g) => g.isBusy))
					{
						await UniTask.WaitUntil(() => !refUnits.Any((g) => g.isBusy), cancellationToken: linkedTokenSource.Token);
						
						UpdateMovable();
					}
				}
				
				// 다음 box가 없으면 클리어
				if(boxes.IsNullOrEmpty())
				{
					ResetCancellationTokenSource();
					
					WillGameClear();
					return;
				}
			}
			
			if(!boxes[0].isComplete)break;
		}
		
		// slot이 꽉찼으면 게임오버
		if(env.slot.slotRemain == 0)
		{
			ResetCancellationTokenSource();
			
			WillGameOver();
			return;
		}
		
		// unit 상태 변경
		UpdateSecretState();
		UpdateChainState();
		UpdateFreezeState();
		UpdateBombState();
		
		await UniTask.WaitUntil(() => !refUnits.Any((g) => g.isBusy), cancellationToken: linkedTokenSource.Token);
		
		// bomb터진 unit 있으면 게임오버
		if(refUnits.Any((u) => u.isDead))
		{
			ResetCancellationTokenSource();
			
			WillGameOver();
			return;
		}
		
		// lock 상태 변경
		if(lockGroups.Count > 0)
		{
			UpdateLockGroupState();
			
			if(refUnits.Any((g) => g.isBusy))
			{
				await UniTask.WaitUntil(() => !refUnits.Any((g) => g.isBusy), cancellationToken: linkedTokenSource.Token);
			}
			if(refSpawners.Any((g) => g.isBusy))
			{
				await UniTask.WaitUntil(() => !refSpawners.Any((g) => g.isBusy), cancellationToken: linkedTokenSource.Token);
			}
		}
		
		// spawner 동작
		if(refSpawners.Count > 0 && refSpawners.Any((g) => g.canSpawn))
		{
			SpawnUnit();
			
			// unit 상태 변경: 이건 생성된 유닛의 이동이 secret해제 애니랑 관계없다는 가정
			UpdateSecretState();
			
			if(refUnits.Any((g) => g.isBusy))
			{
				await UniTask.WaitUntil(() => !refUnits.Any((g) => g.isBusy), cancellationToken: linkedTokenSource.Token);
				
				UpdateMovable();
			}
			if(refSpawners.Any((g) => g.isBusy))
			{
				await UniTask.WaitUntil(() => !refSpawners.Any((g) => g.isBusy), cancellationToken: linkedTokenSource.Token);
			}
		}
		
		//
		waitGameReady = false;
		
		//
		// NOTE: 최초 레벨 생성할때와 continue에서만 사용
		if(onChecked != null)onChecked();
	}