IEnumerator DoActionDealGlobalCard(List <sbyte> _valueCards)
{
List <ICardInfo> _tmpListCardInfo = new List <ICardInfo>();
ICardInfo _cardInfo = null;
List <PanelCardDetailController> _tmpListCard = new List <PanelCardDetailController>();
PanelCardDetailController _card = null;
for (int i = 0; i < _valueCards.Count; i++)
{
_cardInfo = Poker_GamePlay_Manager.instance.GetCardInfo(_valueCards[i]);
if (_cardInfo == null)
{
#if TEST
Debug.LogError("_cardInfo is NULL : " + _valueCards[i]);
#endif
continue;
}
_tmpListCardInfo.Add(_cardInfo);
_card = LeanPool.Spawn(cardPrefab, Vector3.zero, Quaternion.identity, Poker_GamePlay_Manager.instance.panelCardContainer).GetComponent <PanelCardDetailController>();
_card.transform.position = placeHolder_SpawnCard_Catched.position;
_card.ResizeAgain(Poker_GamePlay_Manager.instance.sizeCard.x, Poker_GamePlay_Manager.instance.sizeCard.y);
_tmpListCard.Add(_card);
}
yield return(Yielders.Get(0.1f));
for (int i = 0; i < _tmpListCard.Count; i++)
{
CoroutineChain.Start
.Sequential(_tmpListCard[i].Move(placeHolder_GlobalCards_Catched[globalCardsPoolManager.listObjects.Count].position, 0.1f, LeanTweenType.easeOutSine, Poker_GamePlay_Manager.instance.CanPlayMusicAndSfx() ? Poker_GamePlay_Manager.instance.myAudioInfo.sfx_DealCard : null)
, _tmpListCard[i].Show(_tmpListCardInfo[i]));
globalCardsPoolManager.AddObject((MySimplePoolObjectController)_tmpListCard[i]);
yield return(Yielders.Get(0.1f));
}
}
public void Free(AudioSource audioSource, float delay = 0f)
{
if (audioSource != null)
{
LeanPool.Despawn(audioSource.gameObject, delay);
}
}
public void AutoSpawnAndDespawn(GameObject prefab, Vector3 position, float timeDestroy, Transform parent = null)
{
if (parent != null)
{
ParticleSystem fx = LeanPool.Spawn(prefab, position, Quaternion.identity, parent).GetComponent <ParticleSystem>();
//GameObject fx = LeanPool.Spawn(prefab, position, Quaternion.identity, parent);
//if (fx.GetComponent<ParticleSystem>() != null) {
// fx.GetComponent<ParticleSystem>().Play();
//}
if (fx != null)
{
fx.Play();
}
StartCoroutine(DelayDespawn(fx.gameObject, timeDestroy));
}
else
{
ParticleSystem fx = LeanPool.Spawn(prefab, position, Quaternion.identity).GetComponent <ParticleSystem>();
//GameObject fx = LeanPool.Spawn(prefab, position, Quaternion.identity);
//if (fx.GetComponent<ParticleSystem>() != null) {
// fx.GetComponent<ParticleSystem>().Play();
//}
if (fx != null)
{
fx.Play();
}
StartCoroutine(DelayDespawn(fx.gameObject, timeDestroy));
}
}
private void myAddTiles()
{
foreach (GameObject o in _tiles)
{
LeanPool.Despawn(o);
}
_tiles.Clear();
LeanPool.Despawn(_tileContainer);
_tileContainer = LeanPool.Spawn(TileContainerPrefab);
Vector2 camPos = new Vector2(Camera.main.transform.position.x, Camera.main.transform.position.y);
float height = 2f * Camera.main.orthographicSize;
float width = height * Camera.main.aspect;
for (int y = 0; y < MapSize.y; y++)
{
for (int x = 0; x < MapSize.x; x++)
{
var yActual = y - (MapSize.y / 2) + 1;
var xActual = x - (MapSize.x / 2) + 1;
// print("x, y : " + xActual + ", " + yActual);
var t = LeanPool.Spawn(TilePrefab);
t.transform.position = new Vector3(xActual, yActual, 0);
t.transform.SetParent(_tileContainer.transform);
var rend = t.GetComponent <SpriteRenderer>();
rend.sprite = _map[(int)x, (int)y].TileImage;
_tiles.Add(t);
}
}
}
void spawnPowerUps()
{
if (GameManager.Instance.getGameState().Equals(GameState.States.GamePlay))
{
LeanPool.Spawn(Health_Powerup, powerupSpawnPositions[Random.Range(0, powerupSpawnPositions.Length)].position, Quaternion.identity);
}
}
private TrackSection AddSection(Transform endpoint)
{
var position = new Vector3(0, 0, endpoint.position.z + sectionBuilder.laneLength / 2f);
var newSection = LeanPool.Spawn(trackSection, position, Quaternion.identity, transform);
return(newSection);
}
private void ChanceSpawnAsteroids(AsteroidSpawnerChance asteroidList)
{
float chance = Random.Range(0.0f, asteroidList.totalChance);
float chanceAcc = 0.0f;
var spawnList = asteroidList.asteroids;
// switch (_tier)
// {
// case 1: spawnList = asteroidTier2;
// break;
// }
foreach (var asteroid in spawnList)
{
if (chance < asteroid.spawnChance + chanceAcc)
{
var asteroidObject = LeanPool.Spawn(asteroid.asteroidPrefab,
new Vector3(Random.Range(minBounds.x, maxBounds.x), Random.Range(minBounds.y, maxBounds.y), Random.Range(minBounds.z, maxBounds.z)),
Quaternion.identity);
asteroidObject.AddForce(Vector3.down * asteroid.asteroidFallVelocity, ForceMode.Impulse);
// LeanPool.Despawn(asteroidObject.gameObject, asteroid.asteroidLifeDuration);
return;
}
chanceAcc += asteroid.spawnChance;
}
}
public void ShowFinish()
{
Debugs.LogBlue(" finish game");
for (int i = 0; i < 3; i++)
{
currentPiece.transform.GetChild(i).GetComponent <SpriteRenderer>().sprite = null;
}
StopMoveVertical();
countNextPiece = 0;
countPiece = 0;
for (int i = 0; i < 12; i++)
{
for (int j = 0; j < 8; j++)
{
matrix[i, j] = 0;
listObjectBreak[i, j] = null;
LeanPool.Despawn(matrixGameOject[i, j]);
matrixGameOject[i, j] = null;
}
}
BOL_Battle_Screen.instance.SelfDestruction();
BOL_MainControl_Offline.instance.Back2LastScene();
//StartCoroutine(CountDownStart());
}
public override void Attack_Q()
{
base.Attack_Q();
animatorHero.SetTrigger(Constant.attackQ);
vectorBow = bowObject.transform.position;
Delay(0.7f, () =>
{
GameObject fxskill = LeanPool.Spawn(ListFXSkill[1].gameObject, vectorBow, Quaternion.identity);
if (vector_competitor.x < 0 && fxskill.transform.localScale.x > 0)
{
fxskill.transform.localScale = new Vector3(fxskill.transform.localScale.x * -1, fxskill.transform.localScale.y);
}
else if (vector_competitor.x > 0 && fxskill.transform.localScale.x < 0)
{
fxskill.transform.localScale = new Vector3(fxskill.transform.localScale.x * -1, fxskill.transform.localScale.y);
}
Delay(2, () =>
{
LeanPool.Despawn(fxskill);
});
//Auto_SelfDestruction_Object_Pool(ListFXSkill[1].gameObject, vectorBow, 2);
});
AsheHeroQ(18, 0.7f, 0.5f, new Vector3(0, vectorBow.y, 0));
AsheHeroQ(10, 0.7f, 0.5f, new Vector3(0, vectorBow.y + 0.5f, 0));
AsheHeroQ(0, 0.7f, 0.5f, new Vector3(0, vectorBow.y + 1f, 0));
AsheHeroQ(-10, 0.7f, 0.5f, new Vector3(0, vectorBow.y - 0.5f, 0));
AsheHeroQ(-18, 0.7f, 0.5f, new Vector3(0, vectorBow.y - 1f, 0));
Delay(1.5f, ResetData);
}
private void OnTriggerExit2D(Collider2D collision)
{
if (collision.tag == "Bound")
{
LeanPool.Despawn(this.gameObject);
}
}
private void StopAndAnimateAsteroidDestruction(bool wasHit = true)
{
_audioSource.Play();
if (particleSystem != null)
{
var particles = LeanPool.Spawn(particleSystem, transform.position, Quaternion.identity);
LeanPool.Despawn(particles, 0.5f);
}
if (wasHit)
{
_rigidbody.velocity = Vector3.zero;
}
else
{
_rigidbody.velocity = _rigidbody.velocity * 0.1f;
}
DOTween.To(() => _material.GetFloat(uniformName),
value => _material.SetFloat(uniformName, value),
_lightIntensity * lightEffectPower, lightEffectTimer).OnComplete(
() =>
{
DOTween.To(() => _material.GetFloat(transparencyName),
value => _material.SetFloat(transparencyName, value),
0.0f, despawnTimer * 0.9f);
LeanPool.Despawn(gameObject, despawnTimer);
});
}
// Use this for initialization
void Start()
{
KInt timestep = 0.25f;
Simulator.Instance.setTimeStep(timestep);
Simulator.Instance.SetSingleTonMode(true);
Simulator.Instance.setAgentDefaults(15, 10, 5, 5, 2, 2, KInt2.zero);
for (int i = 0; i < agentCount; i++)
{
float angle = ((float)i / agentCount) * (float)System.Math.PI * 2;
Vector3 pos = new Vector3((float)System.Math.Cos(angle), 0, (float)System.Math.Sin(angle)) * ringSize;
Vector3 antipodal = -pos + goalOffset;
int sid = Simulator.Instance.addAgent((KInt2)pos, neighborDist, maxNeighbors, timeHorizon, timeHorizonObst, radius, maxSpeed, velocity);
if (sid >= 0)
{
GameObject go = LeanPool.Spawn(agentPrefab, new Vector3(pos.x, 0, pos.y), Quaternion.Euler(0, angle + 180, 0));
go.transform.parent = transform;
go.transform.position = pos;
GameAgent ga = go.GetComponent <GameAgent>();
Assert.IsNotNull(ga);
ga.sid = sid;
m_agentMap.Add(sid, ga);
}
}
Simulator.Instance.SetNumWorkers(0);
}
void RefreshGlobalCardUINow()
{
if (pokerGamePlayData.globalCards.Count == 0)
{
return;
}
ICardInfo _cardInfo = null;
PanelCardDetailController _card = null;
Vector3 _pos = Vector3.zero;
for (int i = 0; i < pokerGamePlayData.globalCards.Count; i++)
{
_cardInfo = Poker_GamePlay_Manager.instance.GetCardInfo(pokerGamePlayData.globalCards[i]);
if (_cardInfo == null)
{
#if TEST
Debug.LogError("_cardInfo is NULL : " + pokerGamePlayData.globalCards[i]);
#endif
continue;
}
_pos = placeHolder_GlobalCards_Catched[globalCardsPoolManager.listObjects.Count].position;
_card = LeanPool.Spawn(cardPrefab, Vector3.zero, Quaternion.identity, Poker_GamePlay_Manager.instance.panelCardContainer).GetComponent <PanelCardDetailController>();
_card.transform.position = _pos;
_card.ResizeAgain(Poker_GamePlay_Manager.instance.sizeCard.x, Poker_GamePlay_Manager.instance.sizeCard.y);
_card.ShowNow(_cardInfo);
globalCardsPoolManager.AddObject(_card);
}
}
IEnumerator DoActionDealPlayerCard(Poker_PlayerGroup _playerGroup)
{
List <PanelCardDetailController> _tmpListCard = new List <PanelCardDetailController>();
PanelCardDetailController _card = null;
for (int i = 0; i < 2; i++)
{
_card = LeanPool.Spawn(cardPrefab, Vector3.zero, Quaternion.identity, Poker_GamePlay_Manager.instance.panelCardContainer).GetComponent <PanelCardDetailController>();
_card.transform.position = placeHolder_SpawnCard_Catched.position;
_card.ResizeAgain(Poker_GamePlay_Manager.instance.sizeCard.x, Poker_GamePlay_Manager.instance.sizeCard.y);
_tmpListCard.Add(_card);
}
yield return(Yielders.Get(0.1f));
for (int i = 0; i < _tmpListCard.Count; i++)
{
if (!_playerGroup.isMe)
{
if (Poker_GamePlay_Manager.instance.CanPlayMusicAndSfx())
{
MyAudioManager.instance.PlaySfx(Poker_GamePlay_Manager.instance.myAudioInfo.sfx_DealCard);
}
CoroutineChain.Start
.Parallel(_tmpListCard[i].Move(_playerGroup.cardCoverHoldersCatched[i].position, 0.1f, LeanTweenType.easeOutSine)
, _tmpListCard[i].Rotate(_playerGroup.cardCoverHoldersCatched[i].rotation.eulerAngles, 0.1f)
, _tmpListCard[i].ScaleTo(_playerGroup.cardCoverHoldersCatched[i].localScale, 0.1f, LeanTweenType.notUsed));
}
else
{
ICardInfo _cardInfo = null;
for (int j = 0; j < pokerGamePlayData.listPlayerPlayingData.Count; j++)
{
if (pokerGamePlayData.listPlayerPlayingData[j].isMe &&
pokerGamePlayData.listPlayerPlayingData[j].userData.IsEqual(_playerGroup.userData))
{
_cardInfo = Poker_GamePlay_Manager.instance.GetCardInfo(pokerGamePlayData.listPlayerPlayingData[j].ownCards[i]);
if (_cardInfo == null)
{
#if TEST
Debug.LogError("_cardInfo is NULL : " + pokerGamePlayData.listPlayerPlayingData[j].ownCards[i]);
#endif
continue;
}
break;
}
}
CoroutineChain.Start
.Parallel(_tmpListCard[i].Move(_playerGroup.ownCardHoldersCatched[i].position, 0.1f, LeanTweenType.easeOutSine
, Poker_GamePlay_Manager.instance.CanPlayMusicAndSfx() ? Poker_GamePlay_Manager.instance.myAudioInfo.sfx_DealCard : null)
, _tmpListCard[i].Rotate(_playerGroup.ownCardHoldersCatched[i].rotation.eulerAngles, 0.1f)
, _tmpListCard[i].ScaleTo(_playerGroup.ownCardHoldersCatched[i].localScale, 0.1f, LeanTweenType.notUsed))
.Sequential(_tmpListCard[i].Show(_cardInfo));
}
_playerGroup.ownCardPoolManager.AddObject(_tmpListCard[i]);
yield return(Yielders.Get(0.1f));
}
}
public void CreateToast(string _textInfo, Vector3 _pos, Color _colorText, float _maxSizeW)
{
if (myCanvas.worldCamera == null && CoreGameManager.instance.currentSceneManager != null)
{
myCanvas.worldCamera = CoreGameManager.instance.currentSceneManager.cameraForConsumableScreen.mainCamera;
}
else
{
myCanvas.worldCamera = Camera.main;
}
//gpRaycaster.enabled = true;
ToastController _tmpPopup = LeanPool.Spawn(toastPrefab, Vector3.zero, Quaternion.identity, pool.transform).GetComponent <ToastController>();
_tmpPopup.transform.position = _pos;
_tmpPopup.Init(_textInfo, _colorText, _maxSizeW, () => {
if (toasts != null && toasts.Count > 0)
{
toasts.Remove(_tmpPopup);
}
RemovePopupActive(_tmpPopup);
});
MyAudioManager.instance.PlaySfx(PopupManager.Instance.myInfoAudio.sfx_Popup);
if (toasts == null)
{
toasts = new List <ToastController>();
}
for (int i = 0; i < toasts.Count; i++)
{
toasts[i].SetSpeedUp();
}
toasts.Add(_tmpPopup);
AddPopupActive(_tmpPopup);
}
private void DespawnAllWorldObjects()
{
for (int i = World_T.childCount - 1; i >= 0; i--)
{
LeanPool.Despawn(World_T.GetChild(i));
}
}
private IEnumerator Spawn(int obstacleAmount, Transform parent, float delay = 1f)
{
yield return(null);// new WaitForSeconds(delay);
for (int i = 0; i < obstacleAmount; i++)
{
Vector3 pos = transform.position + center + new Vector3(Random.Range(-size.x / 2, size.x / 2), Random.Range(-size.y / 2, size.y / 2), Random.Range(-size.z / 2, size.z / 2));
//Vector3 groundHitPos = new Vector3();
Ray ray = new Ray(pos, Vector3.down * 5f);
if (Physics.Raycast(ray, out RaycastHit hitInfo, 5f))
{
pos = hitInfo.point;
}
pos = new Vector3(pos.x, pos.y + spawnHeight, pos.z);
int choice = Random.Range(0, obstacles.Count);
GameObject newObstacle = LeanPool.Spawn(obstacles[choice], pos, Quaternion.identity);
currentObstacles++;
newObstacle.transform.parent = parent;
Debug.Log("Spawn Object");
}
}
private void OnTriggerEnter(Collider other)
{
if (!other.CompareTag("Player"))
{
LeanPool.Despawn(gameObject);
}
}
private void Update()
{
if (transform.position.x - _car.transform.position.x < DestroyThreshold)
{
LeanPool.Despawn(gameObject);
}
}
ANode SpawnNode(int x, int y, NodeType type)
{
var node = LeanPool.Spawn(nodePrefabs[(int)type], boardParent).GetComponent <ANode>();
ActiveNodes[x, y] = node;
var point = new Vector2Int(x, y);
node.name = point.ToString();
switch (type)
{
case NodeType.ATTACK:
(node as AttackNode).Init(attr.Atk, point, (NodeType)type, this);
break;
case NodeType.MANA:
(node as ManaNode).Init(attr.Mana, point, (NodeType)type, this);
break;
case NodeType.ENERGY:
(node as EnergyNode).Init(attr.Energy, point, (NodeType)type, this);
break;
case NodeType.DEFENSE:
(node as DefenseNode).Init(attr.Def, point, (NodeType)type, this);
break;
case NodeType.CHEST:
//var chestType = Random.Range(0, System.Enum.GetNames(typeof(ChestType)).Length);
var chestType = ChestType.HP_RECOVER;
(node as ChestNode).Init(attr.ChestNodeAttr, (ChestType)chestType, point, (NodeType)type, this);
break;
}
return(node);
}
async void HandlePlayerVFXPlay(OnPlayerVFXPlay e)
{
switch (e.Type)
{
case NodeType.ATTACK:
await LeanPool.Spawn(starPrefab, gamePanel).GetComponent <PlayerVFX>().Attack(e.StartPos, damageRectTF.position, starColors[(int)e.Type], fireballVel);
break;
case NodeType.MANA:
await LeanPool.Spawn(starPrefab, gamePanel).GetComponent <PlayerVFX>().Attack(e.StartPos, damageRectTF.position, starColors[(int)e.Type], fireballVel);
break;
case NodeType.DEFENSE:
await LeanPool.Spawn(starPrefab, gamePanel).GetComponent <PlayerVFX>().Attack(e.StartPos, defRectTF.position, starColors[(int)e.Type], fireballVel);
break;
case NodeType.ENERGY:
await LeanPool.Spawn(starPrefab, gamePanel).GetComponent <PlayerVFX>().Attack(e.StartPos, energyRectTF.position, starColors[(int)e.Type], fireballVel);
break;
}
}
void SpawnNextBlock()
{
//_blocksQueue.Enqueue(Instantiate(_levelBlock, CountBlockSpawnPos(), Quaternion.identity));
_blocksQueue.Enqueue(LeanPool.Spawn(_levelBlock, CountBlockSpawnPos(), Quaternion.identity));
_blocksSpawned++;
_levelLength = _blocksSpawned * _blockLength;
}
private void ResolveCollision(GameObject other)
{
if (other.CompareTag("BorderCollider"))
{
LeanPool.Despawn(this);
}
}
/// <summary>
/// 生成手牌
/// </summary>
/// <param name="card"></param>
/// <param name="index"></param>
/// <param name="isSelected"></param>
/// <param name="type"></param>
public void CreateCardUI(Card card, int index, bool isSelected, ShowPoint type)
{
//
GameObject temp = LeanPool.Spawn(m_Prefab);
temp.transform.localScale = new Vector3(1, 1, 1);
CardUI cardUI = temp.GetComponent <CardUI>();
cardUI.Card = card;
cardUI.IsSelected = isSelected;
if (type == ShowPoint.Player)
{
cardUI.SetCardPosition(PlayPoint, index);
}
else if (type == ShowPoint.ComputerRight)
{
cardUI.SetCardPosition(ComputerRightPoint, index);
}
else if (type == ShowPoint.ComputerLeft)
{
cardUI.SetCardPosition(ComputerLeftPoint, index);
}
else if (type == ShowPoint.Desk)
{
cardUI.SetCardPosition(CreatePoint, index);
}
}
public void DespawnAll()
{
foreach (Transform trans in rootCanvas.transform)
{
LeanPool.Despawn(trans.gameObject);
}
}
override protected async void HandleShootPerformed(InputAction.CallbackContext c)
{
var buttonControll = c.control as ButtonControl;
if (buttonControll.wasPressedThisFrame)
{
// if player can shoot face to Crosshair first and spawn trajectory and bullet
if (Timer.IsFinished && !bShootPerformed)
{
Parent.ChangeState(EHumanoidState.SHOOT_START);
await Parent.LookAtCrosshairAsync();
hs = LeanPool.Spawn(BulletPrefab).GetComponent <Hitscan>();
RayAttr passAttr = new RayAttr(ShootPoint.position,
(Crosshair.position - ShootPoint.position).normalized, attr.Dis);
hs.UpdateTrajectory(passAttr, this);
bShootPerformed = true;
}
}
if (buttonControll.wasReleasedThisFrame)
{
// if player released shoot button and have shot bullet before update the bullet
if (bShootPerformed && Timer.IsFinished)
{
bShootPerformed = false;
Timer.Reset();
Parent.LookAtCrosshair();
RayAttr passAttr = new RayAttr(ShootPoint.position,
(Crosshair.position - ShootPoint.position).normalized, attr.Dis);
hs.Fire <RayAttr>(passAttr, this);
Parent.ChangeState(EHumanoidState.SHOOT_END);
hs = null;
}
}
}
public IEnumerator InitAllSubchapterNode()
{
//StartCoroutine(CheckChapterChildCount());
DespawnAllSubchapterNode();
if (GameManager.Instance.allSubchapterData.Count > 0)
{
Sequence sequence = DOTween.Sequence();
SubchapterNode subchapterNode;
for (int i = 0; i < GameManager.Instance.allSubchapterData.Count; i++)
{
string currentSubchapterKey = GameManager.Instance.allSubchapterData.Keys.ElementAt(i);
string chapterKey = currentSubchapterKey.Substring(0, currentSubchapterKey.IndexOf("|"));
Debug.Log(currentSubchapterKey);
Debug.Log(chapterKey);
if (chapterKey == DataManager.Instance.currentChapterName)
{
SubchapterSO subchapterSO = GameManager.Instance.allSubchapterData[currentSubchapterKey];
subchapterNode = LeanPool.Spawn(subchapterNodePrefab, subchapterNodeParent).GetComponent <SubchapterNode>();
subchapterNode.InitSubchapter(subchapterSO);
sequence.Join(subchapterNode.transform.DOPunchScale(Vector3.one * 0.2f, 0.2f, 3, 1));
yield return(new WaitForSeconds(0.1f));
}
}
}
}
private void CannonShoot()
{
var tipPosition = turretAimTip.transform.position;
var vector = tipPosition - turretAimBase.transform.position;
vector.Normalize();
void GenerateBullet(Vector3 vector3)
{
var bullet = LeanPool.Spawn(bulletGameObject, vector3, Quaternion.identity);
bullet.transform.localScale = projectileScaling;
bullet.AddForce(vector * ProjectileForce, ForceMode.Impulse);
Destroy(bullet.gameObject, ProjectileLife);
}
GenerateBullet(tipPosition);
if (_unlockedTripleCannon)
{
GenerateBullet(turretExtraLeft.transform.position);
GenerateBullet(turretExtraRight.transform.position);
}
_canShoot = false;
cannonAudioSource.Play();
cooldownImage.fillAmount = 0.0f;
cooldownImage.DOFillAmount(1.0f, CannonCoolDownTimer).OnComplete(CanShootAgain);
}
public void ShowHPMNSH(int valueShow, Vector3 posShow, Color colorShow)
{
GameObject objectShow = LeanPool.Spawn(txtShowHPMNSH, new Vector3(posShow.x, posShow.y + 1), Quaternion.identity);
if (valueShow != 0)
{
objectShow.transform.GetComponent <TextMeshPro>().text = valueShow.ToString();
}
else
{
objectShow.transform.GetComponent <TextMeshPro>().text = string.Empty;
}
objectShow.transform.GetComponent <TextMeshPro>().color = colorShow;
LeanTween.alpha(objectShow, 0, 0.01f).setOnComplete(() =>
{
LeanTween.moveLocalY(objectShow, objectShow.transform.localPosition.y + 0.5f, 0.5f).setEase(LeanTweenType.easeInBack);
LeanTween.scale(objectShow, new Vector3(2, 2), 0.5f).setOnComplete(() =>
{
LeanTween.scale(objectShow, new Vector3(0.2f, 0.2f), 0.5f);
});
LeanTween.alpha(objectShow, 1, 0.5f).setOnComplete(() =>
{
LeanTween.alpha(objectShow, 0, 0.5f).setOnComplete(() =>
{
LeanPool.Despawn(objectShow);
});
});
});
}
IEnumerator DoActionDealCards(float _timeDelay)
{
System.TimeSpan _tmpDeltaTime = dragonTigerCasinoData.nextTimeToShowResult - System.DateTime.Now;
if (_tmpDeltaTime.TotalSeconds <= 5)
{
cardDragon = LeanPool.Spawn(cardPrefab, cardDragonDealPlaceHolder.position, Quaternion.identity, panelCardContainer).GetComponent <PanelCardDetailController>();
cardDragon.transform.position = cardDragonDealPlaceHolder.position;
cardDragon.ResizeAgain(100, 150f);
cardTiger = LeanPool.Spawn(cardPrefab, cardTigerDealPlaceHolder.position, Quaternion.identity, panelCardContainer).GetComponent <PanelCardDetailController>();
cardTiger.transform.position = cardTigerDealPlaceHolder.position;
cardTiger.ResizeAgain(100, 150f);
}
else
{
cardDragon = LeanPool.Spawn(cardPrefab, Vector3.zero, Quaternion.identity, panelCardContainer).GetComponent <PanelCardDetailController>();
cardDragon.transform.position = posistionSpawnCard;
cardDragon.ResizeAgain(100, 150f);
cardTiger = LeanPool.Spawn(cardPrefab, Vector3.zero, Quaternion.identity, panelCardContainer).GetComponent <PanelCardDetailController>();
cardTiger.transform.position = posistionSpawnCard;
cardTiger.ResizeAgain(100, 150f);
yield return(Yielders.Get(_timeDelay));
yield return(CoroutineChain.Start
.Sequential(
cardDragon.Move(cardDragonDealPlaceHolder.position, 0.3f, LeanTweenType.easeOutSine, myAudioInfo.sfx_DealCard),
cardTiger.Move(cardTigerDealPlaceHolder.position, 0.3f, LeanTweenType.easeOutSine, myAudioInfo.sfx_DealCard)));
}
}
