/// <summary>
/// User requested card play.
/// Host will handle the request or cancel it if it was illegal.
/// </summary>
private void OnCardRequested(MatchMessageCardPlayRequest message)
{
if (message.PlayerId == NakamaSessionManager.Instance.Session.UserId)
{
if (MatchCommunicationManager.Instance.IsHost == true)
{
HandleCardRequest(message, _localHand, _localGold);
}
else
{
MatchCommunicationManager.Instance.SendMatchStateMessage(MatchMessageType.CardPlayRequest, message);
}
}
else
{
if (MatchCommunicationManager.Instance.IsHost == true)
{
HandleCardRequest(message, _opponentHand, _opponentGold);
}
else
{
// Only host can handle incomming card play requests; do nothing
}
}
}
/// <summary>
/// Cancels played card and returns it to its owner's hand.
/// </summary>
private void SendCardCanceledMessage(MatchMessageCardPlayRequest message)
{
MatchMessageCardCanceled cardCanceled = new MatchMessageCardCanceled(message.PlayerId, message.CardSlotIndex);
if (message.PlayerId == NakamaSessionManager.Instance.Session.UserId)
{
MatchCommunicationManager.Instance.SendMatchStateMessageSelf(MatchMessageType.CardCanceled, cardCanceled);
}
else
{
MatchCommunicationManager.Instance.SendMatchStateMessage(MatchMessageType.CardCanceled, cardCanceled);
}
}
/// <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);
}
/// <summary>
/// Invoked on card played.
/// Sends <see cref="MatchMessageCardPlayRequest"/> to host.
/// </summary>
private void PlayCard(CardGrabber grabber, Vector3 dropPosition)
{
grabber.OnDragStarted -= StartCardDrag;
grabber.OnCardReturned -= ReturnCard;
grabber.OnCardPlayed -= PlayCard;
string id = NakamaSessionManager.Instance.Session.UserId;
int index = _cardsInHand.IndexOf(grabber);
//_cardsInHand.RemoveAt(index);
MatchMessageCardPlayRequest message = new MatchMessageCardPlayRequest(
id, grabber.Card, index, dropPosition.x, dropPosition.y, dropPosition.z);
OnCardPlayed?.Invoke(message);
CurrentlyGrabbedCard = null;
//Destroy(grabber.gameObject);
}
/// <summary>
/// Handles card play request.
/// If user playing the card has insufficiend gold or used card can not be played on specified node,
/// a cancel message is sent to that card owner and its effects don't resolve.
/// </summary>
private void HandleCardRequest(MatchMessageCardPlayRequest message, Hand hand, Gold gold)
{
if (gold.CurrentGold < message.Card.GetCardInfo().Cost)
{
SendCardCanceledMessage(message);
}
else
{
bool isHost = MatchCommunicationManager.Instance.HostId == message.PlayerId;
Vector3 position = new Vector3(message.X, message.Y, message.Z);
Vector2Int nodePosition = ScreenToNodePos(position, isHost, message.Card.GetCardInfo().DropRegion);
Node node = Nodes[nodePosition.x, nodePosition.y];
if (node != null && (node.Unit == null || message.Card.GetCardInfo().CanBeDroppedOverOtherUnits == true))
{
SendCardPlayedMessage(message, hand, nodePosition);
}
else
{
SendCardCanceledMessage(message);
}
}
}
/// <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;
}
}
