/// <summary>
/// Activates spell object of type given in message on node given in message
/// </summary>
/// <param name="message"></param>
private void ActivateSpell(MatchMessageCardPlayed message)
{
if (message.Card.cardType == CardType.Fireball)
{
GetNonactiveSpellOfType(SpellType.Fireball).Activate(GameManager.Instance.Nodes[message.NodeX, message.NodeY], message.PlayerId);
}
}
/// <summary>
/// Resolves card playing, then spawns unit of given type
/// </summary>
/// <param name="message"></param>
private void CardPlayed(MatchMessageCardPlayed message)
{
if (MatchCommunicationManager.Instance.IsHost == true)
{
MatchMessageUnitSpawned unitSpawned = null;
switch (message.Card.cardType)
{
case CardType.BigShip:
case CardType.AoEShip:
case CardType.Boats:
int id = _nextId + 1;
PlayerColor color = message.PlayerId == MatchCommunicationManager.Instance.HostId ? PlayerColor.Black : PlayerColor.Red;
unitSpawned = new MatchMessageUnitSpawned(message.PlayerId, color, id, message.Card, message.NodeX, message.NodeY);
break;
default:
break;
}
if (unitSpawned != null)
{
_nextId += 1;
MatchCommunicationManager.Instance.SendMatchStateMessage(MatchMessageType.UnitSpawned, unitSpawned);
MatchCommunicationManager.Instance.SendMatchStateMessageSelf(MatchMessageType.UnitSpawned, unitSpawned);
}
}
}
/// <summary>
/// Removes played card grabber from the game.
/// </summary>
public void ResolveCardPlay(MatchMessageCardPlayed message)
{
CardGrabber grabber = _cardsInHand[message.CardSlotIndex];
grabber.Resolve(message);
_cardsInHand.RemoveAt(message.CardSlotIndex);
Destroy(grabber.gameObject);
}
/// <summary>
/// Invoked whenever a card is played and it wan't canceled.
/// Removes that card from its owner's hand and reduces their gold count by <see cref="CardInfo.Cost"/>.
/// Card owner draws a new card from their deck.
/// </summary>
/// <param name="message"></param>
private void OnCardPlayed(MatchMessageCardPlayed message)
{
Debug.Log("playing " + message.Card.cardType);
if (message.PlayerId == NakamaSessionManager.Instance.Session.UserId)
{
_localHandPanel.ResolveCardPlay(message);
_localHandPanel.DrawCard(message.NewCard, message.CardSlotIndex);
_localGold.ChangeGoldCount(-message.Card.GetCardInfo().Cost);
}
else if (MatchCommunicationManager.Instance.IsHost == true)
{
_opponentGold.ChangeGoldCount(-message.Card.GetCardInfo().Cost);
}
}
/// <summary>
/// Requests card play.
/// </summary>
private void SendCardPlayedMessage(MatchMessageCardPlayRequest message, Hand userHand, Vector2Int nodePosition)
{
Card newCard = userHand.DrawCard();
MatchMessageCardPlayed matchMessageCardPlayed = new MatchMessageCardPlayed(
message.PlayerId,
message.Card,
message.CardSlotIndex,
newCard,
nodePosition.x,
nodePosition.y);
MatchCommunicationManager.Instance.SendMatchStateMessage(MatchMessageType.CardPlayed, matchMessageCardPlayed);
MatchCommunicationManager.Instance.SendMatchStateMessageSelf(MatchMessageType.CardPlayed, matchMessageCardPlayed);
userHand.CardPlayed(message.CardSlotIndex);
}
void AddCard(PlayableCard card, Vector3 pos)
{
//int cardNetID = card.networkID;
int cardNetID = GameManager.instance.currentNextID;
card.networkID = cardNetID;
GameManager.instance.currentNextID++;
int absPos = 0;
MatchMessageCardPlayed cardPlayed;
if (cards.Count == 0)
{
cards.Add(card);
OrganizeCards();
cardPlayed = new MatchMessageCardPlayed(card.baseCard.cardID, (int)card.baseCard.cardType, absPos, cardNetID);
MatchCommunicationManager.Instance.SendMatchStateMessage(MatchMessageType.CardPlayed, cardPlayed);
return;
}
if (pos.x < cards[0].transform.position.x)
{
cards.Insert(0, card);
OrganizeCards();
cardPlayed = new MatchMessageCardPlayed(card.baseCard.cardID, (int)card.baseCard.cardType, absPos, cardNetID);
MatchCommunicationManager.Instance.SendMatchStateMessage(MatchMessageType.CardPlayed, cardPlayed);
return;
}
for (int a = 0; a < cards.Count - 1; a++)
{
if (pos.x > cards[a].transform.position.x && pos.x < cards[a + 1].transform.position.x)
{
cards.Insert(a + 1, card);
OrganizeCards();
absPos = a + 1;
cardPlayed = new MatchMessageCardPlayed(card.baseCard.cardID, (int)card.baseCard.cardType, absPos, cardNetID);
MatchCommunicationManager.Instance.SendMatchStateMessage(MatchMessageType.CardPlayed, cardPlayed);
return;
}
}
cards.Add(card);
absPos = cards.Count - 1;
cardPlayed = new MatchMessageCardPlayed(card.baseCard.cardID, (int)card.baseCard.cardType, absPos, cardNetID);
MatchCommunicationManager.Instance.SendMatchStateMessage(MatchMessageType.CardPlayed, cardPlayed);
OrganizeCards();
}
/// <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;
//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;
}
}
/// <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;
*/
}
}
