void BeginAttack(PlayableCard card)
    {
        //LOTS OF PLACEHOLDER CODE HERE
        SetToReady(false);
        PlayableMinion me = GetComponent <PlayableMinion>();

        card.RecieveAttack(me);
        me.RecieveAttack(card);
        MatchMessageHandleCombat combat = new MatchMessageHandleCombat(me.networkID, card.networkID);

        MatchCommunicationManager.Instance.SendMatchStateMessage(MatchMessageType.UnitAttacked, combat);
    }
Example #2
0
        /// <summary>
        /// Reads match messages sent by other players, and fires locally events basing on opCode.
        /// </summary>
        /// <param name="opCode"></param>
        /// <param name="messageJson"></param>
        public void ReceiveMatchStateHandle(long opCode, string messageJson)
        {
            if (GameStarted == false)
            {
                _incommingMessages.Enqueue(new IncommingMessageState(opCode, messageJson));
                return;
            }

            //Choosing which event should be invoked basing on opCode, then parsing json to MatchMessage class and firing event
            switch ((MatchMessageType)opCode)
            {
            //GAME
            case MatchMessageType.MatchEnded:
                MatchMessageGameEnded matchMessageGameEnded = MatchMessageGameEnded.Parse(messageJson);
                OnGameEnded?.Invoke(matchMessageGameEnded);
                break;

            case MatchMessageType.TurnEnded:
                //MatchMessageEndTurn matchMessageTurnEnded = MatchMessageEndTurn.Parse(messageJson);
                //OnTurnEnded?.Invoke(matchMessageTurnEnded);
                GameManager.instance.StartTurn();
                break;

            case MatchMessageType.CardPlayed:
                MatchMessageCardPlayed cardPlayed = MatchMessageCardPlayed.Parse(messageJson);
                //OnTurnEnded?.Invoke(matchMessageTurnEnded);
                GameManager.instance.playHandler.OpponentPlayedMinion(cardPlayed.cardID, cardPlayed.cardType, cardPlayed.absPos, cardPlayed.netID);
                break;

            case MatchMessageType.CardDrawn:
                GameManager.instance.playHandler.OpponentDrewCard();
                break;

            case MatchMessageType.SpellActivated:
                MatchMessageSpellCast cast = MatchMessageSpellCast.Parse(messageJson);
                GameManager.instance.playHandler.OpponentCastSpell(cast.cardID, cast.targeted, cast.targetID, cast.modifier);
                break;

            case MatchMessageType.UnitAttacked:
                MatchMessageHandleCombat combat = MatchMessageHandleCombat.Parse(messageJson);
                //OnTurnEnded?.Invoke(matchMessageTurnEnded);
                GameManager.instance.playHandler.HandleIncomingCombat(combat.myNetID, combat.enemyNetID);
                break;

            case MatchMessageType.MatchStarted:
                Debug.Log("Recieved message: Match started!");
                if (GameManager.instance != null)
                {
                }
                //GameManager.instance.StartFirstTurn(IsHost);
                else
                {
                    Debug.Log("NULL GAME MANAGER");
                }
                break;

                /*
                 *              //UNITS
                 *              case MatchMessageType.UnitSpawned:
                 *                  MatchMessageUnitSpawned matchMessageUnitSpawned = MatchMessageUnitSpawned.Parse(messageJson);
                 *                  OnUnitSpawned?.Invoke(matchMessageUnitSpawned);
                 *                  break;
                 *
                 *              case MatchMessageType.UnitMoved:
                 *                  MatchMessageUnitMoved matchMessageUnitMoved = MatchMessageUnitMoved.Parse(messageJson);
                 *                  OnUnitMoved?.Invoke(matchMessageUnitMoved);
                 *                  break;
                 *
                 *              case MatchMessageType.UnitAttacked:
                 *                  MatchMessageUnitAttacked matchMessageUnitAttacked = MatchMessageUnitAttacked.Parse(messageJson);
                 *                  OnUnitAttacked?.Invoke(matchMessageUnitAttacked);
                 *                  break;
                 *
                 *              //SPELLS
                 *              case MatchMessageType.SpellActivated:
                 *                  MatchMessageSpellActivated matchMessageSpellActivated = MatchMessageSpellActivated.Parse(messageJson);
                 *                  OnSpellActivated?.Invoke(matchMessageSpellActivated);
                 *                  break;
                 *
                 *              //CARDS
                 *              case MatchMessageType.CardPlayRequest:
                 *                  if (IsHost == true)
                 *                  {
                 *                      MatchMessageCardPlayRequest matchMessageCardPlayRequest = MatchMessageCardPlayRequest.Parse(messageJson);
                 *                      OnCardRequested?.Invoke(matchMessageCardPlayRequest);
                 *                  }
                 *                  break;
                 *
                 *              case MatchMessageType.CardPlayed:
                 *                  MatchMessageCardPlayed matchMessageCardPlayed = MatchMessageCardPlayed.Parse(messageJson);
                 *                  OnCardPlayed?.Invoke(matchMessageCardPlayed);
                 *                  break;
                 *
                 *
                 *              case MatchMessageType.CardCanceled:
                 *                  MatchMessageCardCanceled matchMessageCardCancelled = MatchMessageCardCanceled.Parse(messageJson);
                 *                  OnCardCancelled?.Invoke(matchMessageCardCancelled);
                 *                  break;
                 *
                 *              case MatchMessageType.StartingHand:
                 *                  MatchMessageStartingHand matchMessageStartingHand = MatchMessageStartingHand.Parse(messageJson);
                 *                  OnStartingHandReceived?.Invoke(matchMessageStartingHand);
                 *                  break;
                 */
            }
        }