Roxaq

BattleTable

Nov 9th, 2016
96
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 20.00 KB | None | 0 0
  1. using UnityEngine;
  2. using UnityEngine.UI;
  3. using System;
  4. using System.Collections;
  5. using UnityEngine.SceneManagement;
  6.  
  7. public class BattleTable : MonoBehaviour {
  8.  
  9.  
  10. AudioController audio;
  11.  
  12. Animator ChooseButton;
  13.  
  14. //Variaveis de acesso aos dados do script de persistencia
  15. private ConjurationData DATAHOLDER;
  16. private BattleAnimations bAnimations;
  17. private BattleConPlayer bConPlayer;
  18. private BattleConEnemy bConEnemy;
  19. private StartGameFade sGameFade;
  20. public Transform[] PlayerDeckPosition;
  21. public GameObject WarriorCard;
  22. public GameObject _EnemyBattleCard, _PlayerBattleCard;
  23.  
  24. public bool CanLoadScene;
  25.  
  26. //Variaveis de posicionamento de instancia;
  27. //public Transform playerCardPosition, enemyCardPosition;
  28.  
  29. //Variaveis dos jogadores
  30. public int playerCardNumber;
  31. public int playerHealth;
  32. public int ReceivedCard;
  33.  
  34. public int enemyCardNumber;
  35. public int enemyhealth;
  36.  
  37. public float gameTime;
  38. public float waitTime;
  39. public float disconnectTime;
  40.  
  41. public GameObject[] _BattleCardDeck = new GameObject[5];
  42.  
  43. private BattleCard playerCard;
  44. private BattleCard enemyCard;
  45.  
  46. public Canvas MainCanvas;
  47.  
  48. private bool IsFirstMove;
  49.  
  50. //Variaveis de condição de continuação
  51. private bool enemyHasCard;
  52. private bool playerHasCard;
  53.  
  54. //variaveis de condição de interação
  55. private bool canChooseCard;
  56. private bool canChooseAction;
  57.  
  58. private BattleController _BattleControllerLink;
  59. private MAINDATABATTLE mDATA;
  60.  
  61. public Animator DeckHolder;
  62.  
  63. //Variaveis de placeholder da carta do inimigo
  64. public int enmId, enmPod, enmCon, enmMaxCon, enmReady;
  65.  
  66. //Variaveis de interface
  67. public Text txt_PlayerHP, txt_PlayerCN;
  68.  
  69.  
  70. void Awake()
  71. {
  72. audio = GameObject.FindWithTag("AudioController").GetComponent<AudioController>();
  73. mDATA = GameObject.FindWithTag("MAINDATA").GetComponent<MAINDATABATTLE>();
  74. MultiplayerController.Instance.PickCardNumber = false;
  75. sGameFade = GameObject.FindWithTag("GameController").GetComponent<StartGameFade>();
  76. _BattleControllerLink = gameObject.GetComponent<BattleController>();
  77. bAnimations = GameObject.FindWithTag("GameController").GetComponent<BattleAnimations>();
  78. bConPlayer = GameObject.FindWithTag("PlayerCon").GetComponent<BattleConPlayer>();
  79. bConEnemy = GameObject.FindWithTag("EnemyCon").GetComponent<BattleConEnemy>();
  80. ChooseButton = GameObject.Find("CanvasCardTime").GetComponent<Animator>();
  81. ChooseButton.enabled = false;
  82. DeckHolder = GameObject.Find("DeckHolder").GetComponent<Animator>();
  83. DeckHolder.enabled = false;
  84. MainCanvas = GameObject.FindWithTag("ActionsButtons").GetComponent<Canvas>();
  85. SetDataHolder();
  86. SetupCards();
  87. SendMyDeckNumber();
  88. }
  89.  
  90. void Start()
  91. {
  92. audio.COMBATMUSIC();
  93. if (MultiplayerController.Instance.PickCardNumber)
  94. {
  95. enemyCardNumber = MultiplayerController.Instance.deckNumber;
  96. CheckCardNumbers();
  97. }else
  98. {
  99. //Nem precisa desse else ai
  100. }
  101. }
  102.  
  103. public void SetupCards()
  104. {
  105. gameTime = DATAHOLDER.GetGameTime();
  106. //Pega as cartas da mesa de conjuração
  107.  
  108. playerCardNumber = DATAHOLDER.GetCardNumber();
  109.  
  110. if (playerCardNumber > 0)
  111. {
  112. GetCards();
  113. }
  114. }
  115.  
  116. public void SendMyDeckNumber()
  117. {
  118. MultiplayerController.Instance.SendMyUpdateDeckNumber(playerCardNumber);
  119. }
  120.  
  121. void Update()
  122. {
  123. DebugData();
  124. //print("VIDA DO PLAYER: " + DATAHOLDER.GetHealth());
  125. //print("VIDA DO INIMIGO: " + DATAHOLDER.GetEnemyHealth());
  126. }
  127.  
  128. void SetDataHolder()
  129. {
  130. try
  131. {
  132. DATAHOLDER = GameObject.Find("DataHolder").GetComponent<ConjurationData>();
  133. }
  134. catch (Exception e)
  135. {
  136. print("nao existe data");
  137. }
  138. }
  139.  
  140. public void CheckCardNumbers()
  141. {
  142. print("Cartas do inimigo = " + enemyCardNumber);
  143.  
  144.  
  145. if (CheckHealthStatus() && CheckEnemyHealthStatus())
  146. {
  147. if (playerCardNumber <= 0 && enemyCardNumber <= 0)
  148. {
  149. print("Volta pra mesa de conjuração");
  150. audio.ENDTURNBACKCONJUR();
  151. StartCoroutine(ConjurationTableCheck());
  152. }
  153. else if (playerCardNumber > 0 && enemyCardNumber > 0)
  154. {
  155. //escolha de cartas
  156. if (!playerHasCard)
  157. {
  158. StartCoroutine(WaitForAnimationBeforeChooseCard());
  159. }
  160. else
  161. {
  162. StartCoroutine(EnemyCardChoice());
  163. }
  164.  
  165. }
  166. else if (playerCardNumber <= 0 && enemyCardNumber > 0)
  167. {
  168. print("Player Perde vida");
  169. //perda de vidas pelo player
  170. bAnimations.PlayerWasAttackedWithoutCard();
  171. StartCoroutine(WCLoss(1));
  172. }
  173. else if (playerCardNumber > 0 && enemyCardNumber <= 0)
  174. {
  175. print("Inimigo perde vida");
  176. StartCoroutine(WCLoss(2));
  177. //perda de vidas pelo inimigo
  178. bAnimations.EnemyWasAttackedWithoutCard();
  179. }
  180. }
  181. else
  182. {
  183. GameEnd();
  184. }
  185. }
  186.  
  187. public bool CheckHealthStatus()
  188. {
  189. if (DATAHOLDER.GetHealth() > 0)
  190. {
  191. return true;
  192. }
  193. else {
  194. return false;
  195. }
  196. }
  197.  
  198. public bool CheckEnemyHealthStatus()
  199. {
  200. if(DATAHOLDER.GetEnemyHealth() > 0)
  201. {
  202. return true;
  203. }
  204. else
  205. {
  206. return false;
  207. }
  208. }
  209.  
  210. IEnumerator WaitForAnimationBeforeChooseCard()
  211. {
  212. yield return new WaitForSeconds(1.5f);
  213. StartCoroutine(CardChoice());
  214. }
  215.  
  216. IEnumerator CardChoice()
  217. {
  218. float actionTime = gameTime;
  219. canChooseCard = true;
  220. print("Escolha sua Carta");
  221. while (!playerHasCard)
  222. {
  223. /*if(actionTime > 0)
  224. {
  225. GameObject.Find("txt_GameTime").GetComponent<Text>().text = "" + (int)actionTime;
  226. actionTime -= Time.deltaTime;
  227. }
  228. else
  229. {
  230. GameObject.Find("txt_GameTime").GetComponent<Text>().text = "" + 0;
  231. GetFirstCard();
  232. }*/
  233.  
  234. DeckHolder.enabled = true;
  235. DeckHolder.Play("DeckHolder");
  236. bAnimations.DeactiveCons();
  237. ChooseButton.enabled = true;
  238. ChooseButton.Play("ChooseButton");
  239. MainCanvas.enabled = false;
  240. yield return null;
  241. }
  242. canChooseCard = false;
  243. DeckHolder.Play("DeckHolderb");
  244. bAnimations.ActiveCons();
  245. ChooseButton.Play("ChooseButtonb");
  246. MainCanvas.enabled = true;
  247. print("Player escolheu !");
  248. StartCoroutine(EnemyCardChoice());
  249. }
  250.  
  251. IEnumerator EnemyCardChoice()
  252. {
  253. //2. Espera o oponente chegar
  254. print("Espere o Inimigo escolher a Carta");
  255. //SendMyCard();
  256. while (!enemyHasCard)
  257. {
  258. ReceiveEnemyCard();
  259. yield return null;
  260. }
  261. print("Inimigo escolheu, continue!");
  262. //Chamar o loop de batalha
  263. _BattleControllerLink.BattleStart();
  264.  
  265. }
  266.  
  267. void PseudoBattle()
  268. {
  269. print("O Poder do player é : " + playerCard.GetPod());
  270. print("A Concentração do Player é : " + playerCard.GetCon());
  271. print("O Poder do Inimigo é : " + enemyCard.GetPod());
  272. print("A Concentração do Inimigo é : " + enemyCard.GetCon());
  273.  
  274. enemyCard.ReceiveDamage(playerCard.GetPod());
  275. print("O Player ataca e o inimigo fica com : " + enemyCard.GetCon());
  276.  
  277. playerCard.ReceiveDamage(enemyCard.GetPod());
  278. print("O Inimigo ataca e o player fica com: " + playerCard.GetCon());
  279. }
  280.  
  281. IEnumerator WCLoss(int player)
  282. {
  283. float hitDelay = 5;
  284. int enemyCN = enemyCardNumber;
  285. int playerCN = playerCardNumber;
  286.  
  287. if(player == 1)
  288. {
  289. //Player recebe hit
  290. while(enemyCN > 0 )
  291. {
  292. //animação de perda de vida
  293. DATAHOLDER.ReduceHealth();
  294. enemyCN--;
  295. yield return new WaitForSeconds(hitDelay);
  296. }
  297. }else if (player == 2)
  298. {
  299. while(playerCN > 0)
  300. {
  301. //Animação do inimigo recebendo dano
  302. DATAHOLDER.ReduceEnemyHealth();
  303. playerCN--;
  304. yield return new WaitForSeconds(hitDelay);
  305. }
  306.  
  307. }
  308.  
  309. if (CheckHealthStatus() && CheckEnemyHealthStatus())
  310. {
  311. DATAHOLDER.SetHasGoneToBattle();
  312. print("Mesa de conjuração");
  313. audio.ENDTURNBACKCONJUR();
  314. //Voltar apra mesa de conjuração
  315. StartCoroutine(ConjurationTableCheck());
  316. }
  317. else {
  318. GameEnd();
  319. }
  320.  
  321. }
  322.  
  323. public void GameEnd()
  324. {
  325.  
  326. if(CheckHealthStatus() && !CheckEnemyHealthStatus())
  327. {
  328. print("vitória");
  329. StartCoroutine(VictoryScene());
  330. mDATA.WinBattle();
  331. mDATA.BattleWon();
  332. audio.ENDTURNWIN();
  333. }else if(!CheckHealthStatus() && CheckEnemyHealthStatus())
  334. {
  335. print("derrota");
  336. audio.ENDTURNLOSE();
  337. StartCoroutine(DefeatScene());
  338. mDATA.LoseBattle();
  339. mDATA.BattleLost();
  340. }
  341. else if(!CheckHealthStatus() && !CheckEnemyHealthStatus())
  342. {
  343. print("igualdade");
  344. audio.ENDTURNLOSE();
  345. StartCoroutine(DefeatScene());
  346. mDATA.LoseBattle();
  347. mDATA.BattleLost();
  348. }
  349. }
  350.  
  351. public void SetMainCard(BattleCard newCard)
  352. {
  353. if (canChooseCard == true)
  354. {
  355. playerCard = newCard;
  356. SendMyCard();
  357. canChooseCard = false;
  358. playerHasCard = true;
  359. _PlayerBattleCard.GetComponent<BattleCard>().Initialize(GetPlayerCard().GetId(), GetPlayerCard().GetPod(), GetPlayerCard().GetCon(), GetPlayerCard().GetMaxCon(), 0);
  360. bAnimations.PlayerPlaceCardOnBattle();
  361. bConPlayer.MaxCon(GetPlayerCard().GetMaxCon());
  362. }
  363. }
  364.  
  365. public void EnemyInfo()
  366. {
  367. print(enmId);
  368. print(enmPod);
  369. print(enmCon);
  370. }
  371.  
  372. public float GetGameTime()
  373. {
  374. return gameTime;
  375. }
  376.  
  377. /// <summary>
  378. /// Recebimento de dados do multiplayer controller
  379. /// </summary>
  380. /// <param name="id"></param>
  381.  
  382. public void ReceiveEnemyCardId(int id)
  383. {
  384. enmId = id;
  385. print(enmId);
  386. }
  387.  
  388. public void ReceiveEnemyCardPod(int pod)
  389. {
  390. enmPod = pod;
  391. print(enmPod);
  392. }
  393.  
  394. public void ReceiveEnemyCardCon(int con)
  395. {
  396. enmCon = con;
  397. print(enmCon);
  398. }
  399.  
  400. public void ReceiveEnemyCardMaxCon(int maxcon)
  401. {
  402. enmMaxCon = maxcon;
  403. print(enmMaxCon);
  404. }
  405.  
  406. public void ReceiveEnemyCardReady(int ready)
  407. {
  408. enmReady = ready;
  409. }
  410.  
  411. public void ReceiveEnemyDeckNumber(int enemyNumber)
  412. {
  413. print("ReceiveEnemyDeckNumber: " + enemyNumber);
  414. enemyCardNumber = enemyNumber;
  415. CheckCardNumbers();
  416. }
  417.  
  418. void ReceiveEnemyCard()
  419. {
  420. //GameObject enemyWarriorCard = Instantiate(WarriorCard, enemyCardPosition.position, Quaternion.Euler(90, 0, 0)) as GameObject;
  421.  
  422. //Atribua os valores recebidos via o SendMyCard a uma nova variavel do tipo BattleCard
  423. //Recebe os valores de id, poder e concentração e adiciona no BattleCard
  424. _EnemyBattleCard.GetComponent<BattleCard>().Initialize(enmId, enmPod, enmCon, enmMaxCon, 0);
  425. enemyCard = _EnemyBattleCard.GetComponent<BattleCard>();
  426. //Depois atribua a cartaRecebida a variavel enemyCard;
  427.  
  428. if (enmReady == 1 && enmId != 0 && enmPod != 0 && enmCon != 0 && enmMaxCon != 0)
  429. {
  430. print("Carta do inimigo Recebida");
  431. enemyHasCard = true;
  432. bAnimations.EnemyPlaceCardOnBattle();
  433. bConEnemy.MaxCon(enmMaxCon);
  434. }
  435. else
  436. {
  437. enemyHasCard = false;
  438. }
  439. //Depois atribua a cartaRecebida a variavel enemyCard;
  440.  
  441. }
  442.  
  443. /// <summary>
  444. /// Recebimento de dados do multiplayer controller
  445. /// </summary>
  446.  
  447. public void SendMyCard()
  448. {
  449. //use a playerCard para enviar os dados locais
  450. //a BattleCard.cs contem funções como (GetPod) (GetCon) (GetId)para retornar seus valores.
  451. //
  452. MultiplayerController.Instance.SendMyUpdateTypeCard(playerCard.GetId());
  453. MultiplayerController.Instance.SendMyUpdatePOD(playerCard.GetPod());
  454. MultiplayerController.Instance.SendMyUpdateCON(playerCard.GetCon());
  455. MultiplayerController.Instance.SendMyUpdateMAXCON(playerCard.GetMaxCon());
  456. MultiplayerController.Instance.SendMyUpdateTurnReady(1);
  457. }
  458.  
  459. /*void SendMyCleanCard()
  460. {
  461. MultiplayerController.Instance.SendMyUpdateTypeCard(0);
  462. MultiplayerController.Instance.SendMyUpdatePOD(0);
  463. MultiplayerController.Instance.SendMyUpdateCON(0);
  464. MultiplayerController.Instance.SendMyUpdateMAXCON(0);
  465. }*/
  466.  
  467. //Pega as cartas do DATAHOLDER
  468. void GetCards()
  469. {
  470.  
  471. try
  472. {
  473. GameObject nextCard;
  474. WarriorObject nextCardValues;
  475. for (int i = 0; i < 5; i++)
  476. {
  477. if (DATAHOLDER.GetWarriorCard(i) == null)
  478. {
  479. print("carta " + i + ": Vazia");
  480. }
  481. else
  482. {
  483. nextCardValues = DATAHOLDER.GetWarriorCard(i);
  484. nextCard = Instantiate(WarriorCard, PlayerDeckPosition[i].position, Quaternion.Euler(90, 0, 0)) as GameObject;
  485. nextCard.transform.parent = PlayerDeckPosition[i].transform;
  486. nextCard.GetComponent<BattleCard>().Initialize(nextCardValues.GetCardID(), nextCardValues.GetCardPOD(), nextCardValues.GetCardCON(), nextCardValues.GetCardMaxCon(), nextCardValues.GetCardIndex());
  487. _BattleCardDeck[nextCard.GetComponent<BattleCard>().GetIndex()] = nextCard;
  488. print("Carta tem indice: " + nextCard.GetComponent<BattleCard>().GetIndex() + " e esta no indice : " + i + " do Battle Card Deck");
  489.  
  490. }
  491. }
  492. }
  493. catch (Exception e)
  494. {
  495. print("nao existe data");
  496. }
  497. }
  498.  
  499.  
  500. public void PlayerCardDestroyed()
  501. {
  502. DATAHOLDER.ReduceHealth();
  503. playerCardNumber--;
  504. Destroy(_BattleCardDeck[playerCard.GetIndex()]);
  505. DATAHOLDER.KillCard(playerCard.GetIndex());
  506. playerCard = null;
  507. }
  508.  
  509.  
  510. public void EnemyCardDestroyed()
  511. {
  512. DATAHOLDER.ReduceEnemyHealth();
  513. enemyCardNumber--;
  514. enmCon = 0;
  515. enmId = 0;
  516. enmReady = 0;
  517. enmPod = 0;
  518. }
  519.  
  520. public void ConjurationTableReceiveCheck(int EnemyReady)
  521. {
  522. if (EnemyReady == 1)
  523. {
  524. CanLoadScene = true;
  525. }
  526. if (EnemyReady == 0)
  527. {
  528. CanLoadScene = false;
  529. }
  530. }
  531.  
  532. IEnumerator ConjurationTableCheck()
  533. {
  534. int IsReady = 1;
  535. waitTime = 10;
  536. disconnectTime = 70;
  537. MultiplayerController.Instance.SendMyUpdateReadyBattle(IsReady);
  538. Debug.Log("ficar pronto");
  539. while (!CanLoadScene)
  540. {
  541. if(waitTime > 0)
  542. {
  543. waitTime -= Time.deltaTime;
  544. }
  545. else if (waitTime <= 0)
  546. {
  547. ActiveRefresh();
  548. }
  549. if (disconnectTime > 0)
  550. {
  551. disconnectTime -= Time.deltaTime;
  552. _BattleControllerLink.vTime.text = "" + (int)disconnectTime;
  553. }
  554. else if (disconnectTime <= 0)
  555. {
  556. _BattleControllerLink.DisconnectTimeOut();
  557. }
  558. yield return null;
  559. }
  560. CanLoadScene = true;
  561. sGameFade.FadeOut();
  562. //FadeBatalha.Play("FadeBatalha");
  563. StartCoroutine(ConjurationTable());
  564. }
  565.  
  566. public void IncreaseWaitTime(float newTime)
  567. {
  568. waitTime = newTime;
  569. }
  570.  
  571. void ActiveRefresh()
  572. {
  573. _BattleControllerLink.SendMyCardAgain("A");
  574. _BattleControllerLink.NeedInfoRefresh.SetActive(true);
  575. }
  576.  
  577. IEnumerator VictoryScene()
  578. {
  579. yield return new WaitForSeconds(1);
  580. sGameFade.FadeOut();
  581. yield return new WaitForSeconds(2);
  582. SceneManager.LoadSceneAsync(11);
  583. GameObject mData = GameObject.FindWithTag("MAINDATA");
  584. DontDestroyOnLoad(mData);
  585. GameObject audio = GameObject.FindWithTag("AudioController");
  586. DontDestroyOnLoad(audio);
  587. }
  588.  
  589. IEnumerator DefeatScene()
  590. {
  591. yield return new WaitForSeconds(1);
  592. sGameFade.FadeOut();
  593. yield return new WaitForSeconds(2);
  594. SceneManager.LoadSceneAsync(12);
  595. GameObject mData = GameObject.FindWithTag("MAINDATA");
  596. DontDestroyOnLoad(mData);
  597. GameObject audio = GameObject.FindWithTag("AudioController");
  598. DontDestroyOnLoad(audio);
  599. }
  600.  
  601. IEnumerator ConjurationTable()
  602. {
  603. yield return new WaitForSeconds(1);
  604. SceneManager.LoadScene(7);
  605. GameObject mData = GameObject.FindWithTag("MAINDATA");
  606. DontDestroyOnLoad(mData);
  607. GameObject audio = GameObject.FindWithTag("AudioController");
  608. DontDestroyOnLoad(audio);
  609. }
  610.  
  611. public void LostConnOp()
  612. {
  613. MultiplayerController.Instance.LeaveRoom();
  614. sGameFade.FadeOut();
  615. //FadeBatalha.Play("FadeBatalha");
  616. StartCoroutine(LostConn());
  617. }
  618.  
  619. IEnumerator LostConn()
  620. {
  621. yield return new WaitForSeconds(1);
  622. SceneManager.LoadScene("levelDuelarConexao");
  623. GameObject audio = GameObject.FindWithTag("AudioController");
  624. DontDestroyOnLoad(audio);
  625. GameObject data = GameObject.FindWithTag("MAINDATA");
  626. Destroy(data);
  627. }
  628.  
  629. public BattleCard GetPlayerCard()
  630. {
  631. return playerCard;
  632. }
  633.  
  634. public BattleCard GetEnemyCard()
  635. {
  636. return enemyCard;
  637. }
  638.  
  639. public void SetPlayerHasCard(bool status)
  640. {
  641. playerHasCard = status;
  642. }
  643.  
  644. public void SetEnemyHasCard(bool status)
  645. {
  646. enemyHasCard = status;
  647. }
  648.  
  649. public void SendCardToDeck()
  650. {
  651. _BattleCardDeck[playerCard.GetIndex()].GetComponent<BattleCard>().UpdateValues(playerCard.GetPod(), playerCard.GetCon());
  652. DATAHOLDER.UpdateCard(playerCard, playerCard.GetIndex());
  653. }
  654.  
  655. void DebugData()
  656. {
  657.  
  658. txt_PlayerCN.text = "Cards: " + playerCardNumber;
  659.  
  660. txt_PlayerHP.text = "Player Health: +" + DATAHOLDER.GetHealth();
  661. }
  662.  
  663. public int plHealth()
  664. {
  665. return DATAHOLDER.GetHealth();
  666. }
  667.  
  668. public int enHealth()
  669. {
  670. return DATAHOLDER.GetEnemyHealth();
  671. }
  672.  
  673.  
  674. void GetFirstCard() {
  675.  
  676.  
  677. for(int i = _BattleCardDeck.Length; i >= 0; i--)
  678. {
  679. if (_BattleCardDeck[i].GetComponent<BattleCard>() != null)
  680. {
  681. SetMainCard(_BattleCardDeck[i].GetComponent<BattleCard>());
  682. }
  683. }
  684.  
  685.  
  686. }
  687.  
  688. public bool CanReceiveCards()
  689. {
  690. if (canChooseCard)
  691. {
  692. return true;
  693. }
  694. else
  695. {
  696. return false;
  697. }
  698. }
  699.  
  700. }
Advertisement
Add Comment
Please, Sign In to add comment