SVSimServer/SVSim.BattleEngine/Engine/PlayQueueViewBase.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using Wizard.Battle.View;
using Wizard.Battle.View.Vfx;

public abstract class PlayQueueViewBase
{
	protected const float REARRANGE_TIME = 0.5f;

	protected const float ACCELERATE_REARRANGE_TIME = 0.2f;

	private const float queueUpdateSpeed = 10f;

	private const float aspectRatio_4_3 = 1.333f;

	private const float SMOOTHING_AMOUNT = 0.01f;

	private const float DECAY_MULTIPLIER = 5f;

	private Action _computeCorners;

	private List<IBattleCardView> queuedCards = new List<IBattleCardView>();

	public Vector3 worldTopCornerPosition { get; private set; }

	public Vector3 worldBottomCornerPosition { get; private set; }

	protected abstract BattlePlayerBase BattlePlayerBase { get; }

	protected abstract float RotationAmount { get; }

	protected abstract Vector3 ScreenTopCornerPosition { get; }

	protected abstract Vector3 ScreenBottomCornerPosition { get; }

	public PlayQueueViewBase()
	{
	}

	public PlayQueueViewBase(BattleCamera battleCamera)
	{
		PlayQueueViewBase playQueueViewBase = this;
		Camera cutInCamera = battleCamera.m_CutInCamera.GetComponent<Camera>();
		_computeCorners = delegate
		{
			float aspect = cutInCamera.aspect;
			playQueueViewBase.worldTopCornerPosition = cutInCamera.ScreenToWorldPoint(playQueueViewBase.ScreenTopCornerPosition);
			playQueueViewBase.worldTopCornerPosition = playQueueViewBase.BattlePlayerBase.HandControl.Transform.InverseTransformPoint(playQueueViewBase.worldTopCornerPosition);
			playQueueViewBase.worldTopCornerPosition += playQueueViewBase.GetScreenTopCornerOffset(aspect);
			playQueueViewBase.worldTopCornerPosition = playQueueViewBase.BattlePlayerBase.HandControl.Transform.TransformPoint(playQueueViewBase.worldTopCornerPosition);
			playQueueViewBase.worldBottomCornerPosition = cutInCamera.ScreenToWorldPoint(playQueueViewBase.ScreenBottomCornerPosition);
			playQueueViewBase.worldBottomCornerPosition = playQueueViewBase.BattlePlayerBase.HandControl.Transform.InverseTransformPoint(playQueueViewBase.worldBottomCornerPosition);
			playQueueViewBase.worldBottomCornerPosition += playQueueViewBase.GetScreenBottomCornerOffset(aspect);
			playQueueViewBase.worldBottomCornerPosition = playQueueViewBase.BattlePlayerBase.HandControl.Transform.TransformPoint(playQueueViewBase.worldBottomCornerPosition);
		};
		_computeCorners();
	}

	public virtual void ForceClearPlayQueue()
	{
		queuedCards.Clear();
	}

	public int QueueCount()
	{
		return queuedCards.Count;
	}

	public virtual void RemoveCardFromView(IBattleCardView cardViewToRemove, bool keepLayer = false)
	{
		cardViewToRemove.ResetPlayQueueFlags();
		if (queuedCards.Count > 0 && queuedCards[0] == cardViewToRemove)
		{
			queuedCards.RemoveAt(0);
		}
	}

	public virtual void InsertCardFromView(IBattleCardView originalView, IBattleCardView insertView)
	{
		if (queuedCards.Count > 0 && queuedCards[0] == originalView && queuedCards.Any((IBattleCardView c) => c == originalView))
		{
			queuedCards.Insert(queuedCards.IndexOf(originalView), insertView);
		}
	}

	public virtual void ReplaceCard(IBattleCardView cardViewToAdd, IBattleCardView cardViewToRemove)
	{
		cardViewToAdd._hasCardEnteredPlayQueue = true;
		cardViewToAdd._waitUntilCardIsInQueueCoroutine = BattleCoroutine.GetInstance().StartCoroutine(WaitUntilCardIsInQueue(cardViewToAdd));
		cardViewToRemove.ResetPlayQueueFlags();
		if (queuedCards.Count > 0 && queuedCards[0] == cardViewToRemove)
		{
			queuedCards.RemoveAt(0);
			queuedCards.Insert(0, cardViewToAdd);
		}
	}

	public virtual void ForceRemoveCardFromView(IBattleCardView cardViewToRemove)
	{
		cardViewToRemove.ResetPlayQueueFlags();
		queuedCards.Remove(cardViewToRemove);
		iTween.Stop(cardViewToRemove.GameObject);
	}

	protected virtual bool IsCardPlayedInstantly(bool forceCardIntoPlayQueue)
	{
		return !forceCardIntoPlayQueue;
	}

	public bool IsCardInQueue(IBattleCardView battleCardView)
	{
		return queuedCards.Contains(battleCardView);
	}

	public void UpdatePlayQueuePositions(float deltaTime)
	{
		if (_computeCorners != null)
		{
			_computeCorners();
		}
		Vector3 delta = worldBottomCornerPosition - worldTopCornerPosition;
		for (int i = 0; i < queuedCards.Count; i++)
		{
			float t = (float)i / (float)queuedCards.Count;
			if (queuedCards[i].GameObject.activeSelf)
			{
				Vector3 b = CalculatePositionInQueue(t, delta, worldTopCornerPosition);
				queuedCards[i].Transform.position = Vector3.Lerp(queuedCards[i].Transform.position, b, MotionUtils.CalculateFrameRateIndependantDampingConstant(0.01f, 5f));
			}
		}
	}

	private Vector3 CalculatePositionInQueue(float t, Vector3 delta, Vector3 queueTopPosition)
	{
		return new Vector3(delta.x * MotionUtils.GetEase(t, MotionUtils.EaseType.easeOutQuad), delta.y * MotionUtils.GetEase(t, MotionUtils.EaseType.linear), delta.z * MotionUtils.GetEase(t, MotionUtils.EaseType.linear)) + queueTopPosition;
	}

	protected float CalculateAspectRatioMultiplier(float aspectRatio)
	{
		if (aspectRatio <= 1.333f)
		{
			aspectRatio = 1.333f;
		}
		return aspectRatio - 1f;
	}

	protected float CalculateInverseAspectRatioMultiplier(float aspectRatio)
	{
		if (aspectRatio <= 1.333f)
		{
			aspectRatio = 1.333f;
		}
		return 1f / (aspectRatio - 1f);
	}

	protected void AddCardToQueue(IBattleCardView playedCardView)
	{
		queuedCards.Add(playedCardView);
		if (!BattleManagerBase.GetIns().IsRecovery)
		{
			GameMgr.GetIns().GetSoundMgr().PlaySe(Se.TYPE.SYS_HAND_MOVE_CENTER);
			iTween.Stop(playedCardView.GameObject);
			if (playedCardView.GameObject.activeSelf)
			{
				iTween.RotateAdd(playedCardView.GameObject, iTween.Hash("y", RotationAmount, "time", 0.5f, "islocal", true, "easetype", iTween.EaseType.easeOutExpo));
				iTween.ScaleTo(playedCardView.GameObject, iTween.Hash("scale", Global.CARD_BATTLE_SCALE, "time", 0.5f, "islocal", true, "easetype", iTween.EaseType.easeOutExpo));
			}
		}
	}

	protected VfxBase WaitUntilCardIsInQueueVfx(IBattleCardView playedCardView)
	{
		if (!BattleManagerBase.GetIns().IsRecovery)
		{
			playedCardView._hasCardEnteredPlayQueue = true;
		}
		return InstantVfx.Create(delegate
		{
			playedCardView._waitUntilCardIsInQueueCoroutine = BattleCoroutine.GetInstance().StartCoroutine(WaitUntilCardIsInQueue(playedCardView));
		});
	}

	private IEnumerator WaitUntilCardIsInQueue(IBattleCardView playedCardView)
	{
		yield return new WaitForSeconds(0.5f);
		playedCardView._isCardQueuedToBePlayed = true;
	}

	public abstract VfxBase AddCardToViewVfx(IBattleCardView playedCardView, bool forceCardIntoPlayQueue, bool isSelectTarget, bool isChoice, bool isChoiceBrave = false);

	public abstract VfxBase InstantAddCardToViewVfx(IBattleCardView playedCardView, bool forceCardIntoPlayQueue, bool isChoice);

	protected abstract Vector3 GetScreenTopCornerOffset(float aspectRatio);

	protected abstract Vector3 GetScreenBottomCornerOffset(float aspectRatio);

	protected void PlayPlayedCardEffect(IBattleCardView playedCardView)
	{
		GameMgr.GetIns().GetEffectMgr().Start(EffectMgr.EffectType.CMN_CARD_SET_1, playedCardView.GameObject.transform.position, playedCardView.GameObject.transform.rotation);
	}
}