public static void PlayCard(Card card, int playedBy, RemoteNetworkPlayer networkPlayer)
{
destinationPosition = Cards[playedCardCount].position;
destinationRotation = Cards[playedCardCount].rotation;
GameObject newCardObject = Instantiate(cardPrefab, playerPositions[playedBy].position, cardPrefab.transform.rotation) as GameObject;
newCardObject.transform.parent = playedCardsTransform;
UICard cardScript = newCardObject.transform.GetComponent <UICard>();
newCardObject.transform.GetComponent <SpriteRenderer>().sortingOrder = 8;
cardScript.BindCard(card);
Cards[playedCardCount] = newCardObject.transform;
playedCardCount++;
cardToPlay = card;
cardPlayer2 = networkPlayer;
moveCard2 = true;
UIDeck deck = GameObject.FindGameObjectWithTag("DECK").GetComponent <UIDeck>();
deck.playedCard = cardScript;
SoundManagerInstance.PlayCardPlaySound();
}
/// <summary>
/// Sends a user data message to the a remote player in the current room.
/// </summary>
/// <param name="messageToSend">The message to be sent.</param>
/// <param name="remotePlayer">The remote player that should receive the message.</param>
/// <param name="deliveryMethod">The delivery method.</param>
/// <returns>If the message can be sent to the current room (impossible while not in a room).</returns>
public bool SendToPlayer(OutgoingMessage messageToSend, RemoteNetworkPlayer remotePlayer, DeliveryMethod deliveryMethod)
{
this.CheckClientIsReady();
if (this.State != ClientStates.Joined)
{
return(false);
}
var userDataMsg = this.CreateClientMessage(ServerIncomingMessageTypes.UserDataToOtherClient);
userDataMsg.Write(remotePlayer.Id);
userDataMsg.Write(messageToSend);
this.networkClient.Send(userDataMsg, deliveryMethod);
return(true);
}
/// <summary>
/// Refresh the player list based on the given message.
/// </summary>
/// <param name="message">The received message</param>
internal void ReadSyncPlayersListFromMessage(IncomingMessage message)
{
var removedPlayersCount = message.ReadInt32();
for (int i = 0; i < removedPlayersCount; i++)
{
var playerId = message.ReadPlayerId();
var remotePlayer = this.GetPlayer <RemoteNetworkPlayer>(playerId);
this.PlayerLeaving?.Invoke(this, remotePlayer);
this.InternalRemovePlayer(playerId);
this.PlayerLeft?.Invoke(this, remotePlayer);
}
var includedPlayersCount = message.ReadInt32();
for (int i = 0; i < includedPlayersCount; i++)
{
var remotePlayer = RemoteNetworkPlayer.FromMessage(message);
this.PlayerJoining?.Invoke(this, remotePlayer);
this.InternalAddPlayer(remotePlayer);
this.PlayerJoined?.Invoke(this, remotePlayer);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LocalNetworkRoom" /> class based on the given message.
/// </summary>
/// <param name="message">The received message</param>
/// <param name="localPlayer">The client local player</param>
/// <param name="roomOptions">The room options for the new room</param>
/// <returns>A new <see cref="LocalNetworkRoom" /> instance</returns>
internal static LocalNetworkRoom FromJoinMessage(IncomingMessage message, LocalNetworkPlayer localPlayer, RoomOptions roomOptions)
{
var playerRoom = new LocalNetworkRoom(roomOptions);
playerRoom.ReadFromMessage(message);
var playerCount = message.ReadInt32();
for (int i = 0; i < playerCount; i++)
{
var playerId = message.ReadPlayerId();
var remotePlayer = RemoteNetworkPlayer.FromMessage(message);
playerRoom.InternalAddPlayer(remotePlayer, playerId);
}
var localPlayerId = message.ReadPlayerId();
playerRoom.InternalAddPlayer(localPlayer, localPlayerId);
playerRoom.CustomProperties.ReadFromMessage(message);
return(playerRoom);
}
public override NetworkPlayerBase InitializeNetworkPlayer()
{
player = new RemoteNetworkPlayer(gameTable.gameTable, this);
return(player);
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageFromPlayerEventArgs" /> class.
/// </summary>
/// <param name="fromPlayer">The players that sent the message</param>
/// <param name="receivedMessage">The received message</param>
public MessageFromPlayerEventArgs(RemoteNetworkPlayer fromPlayer, IncomingMessage receivedMessage)
{
this.FromPlayer = fromPlayer;
this.ReceivedMessage = receivedMessage;
}
public void onBytes(byte[] msg)
{
string networkMessage = ByteHelper.GetString(msg);
LogManager.Log("Received Update: " + networkMessage);
string[] messageArgs = networkMessage.Split('-');
string messageCommand;
if (messageArgs.Length == 0)
{
messageCommand = networkMessage;
}
else
{
messageCommand = messageArgs[0];
}
switch (messageCommand)
{
case "SIT":
if (LobbyPlayerStats.RoomData.getRoomOwner() == NonStaticPlayer.GetInternalPlayer().PlayerName)
{
int seat = -1;
if (int.TryParse(messageArgs[1], out seat))
{
string playerName = messageArgs[2];
// SET ROOM PROPERTY
Dictionary <string, object> tableProperties = new Dictionary <string, object>();
tableProperties.Add("SEAT" + seat.ToString(), playerName);
List <string> removeProperties = new List <string>();
object seat0, seat1, seat2, seat3;
if (LobbyPlayerStats.RoomProperties.TryGetValue("SEAT0", out seat0) && seat0.ToString() == playerName)
{
removeProperties.Add("SEAT0");
NonStaticPlayer.gameTable.gameTable.LeaveTable(0);
}
if (LobbyPlayerStats.RoomProperties.TryGetValue("SEAT1", out seat1) && seat1.ToString() == playerName)
{
removeProperties.Add("SEAT1");
NonStaticPlayer.gameTable.gameTable.LeaveTable(1);
}
if (LobbyPlayerStats.RoomProperties.TryGetValue("SEAT2", out seat2) && seat2.ToString() == playerName)
{
removeProperties.Add("SEAT2");
NonStaticPlayer.gameTable.gameTable.LeaveTable(2);
}
if (LobbyPlayerStats.RoomProperties.TryGetValue("SEAT3", out seat3) && seat3.ToString() == playerName)
{
removeProperties.Add("SEAT3");
NonStaticPlayer.gameTable.gameTable.LeaveTable(3);
}
if (removeProperties.Count == 0)
{
removeProperties = null;
}
WarpClient.GetInstance().UpdateRoomProperties(LobbyPlayerStats.RoomData.getId(), tableProperties, removeProperties);
}
}
break;
case "ROOMDLT":
WarpClient.GetInstance().LeaveRoom(LobbyPlayerStats.RoomData.getId());
LobbyPlayerStats.Hide();
RoomSelectionMenu.Show("ROOMDLT");
break;
case "PLAY":
int playerSeat, cardType, cardValue;
if (int.TryParse(messageArgs[1], out playerSeat))
{
if (playerSeat != NonStaticPlayer.GetInternalPlayer().GetPlayersSeat())
{
if (int.TryParse(messageArgs[2], out cardType))
{
if (int.TryParse(messageArgs[3], out cardValue))
{
RemoteNetworkPlayer networkPlayer = MultiplayerGamers.GetPlayerBySeat(playerSeat) as RemoteNetworkPlayer;
Card cardToPlay = new Card(cardValue, cardType);
networkPlayer.PlayCard(cardToPlay);
}
}
}
}
break;
case "BID":
int bidPlayerSeat, bid;
if (int.TryParse(messageArgs[1], out bidPlayerSeat))
{
if (bidPlayerSeat != NonStaticPlayer.GetInternalPlayer().GetPlayersSeat())
{
if (int.TryParse(messageArgs[2], out bid))
{
NetworkPlayerBase networkPlayer = MultiplayerGamers.GetPlayerBySeat(bidPlayerSeat);
if (bid == 999)
{
networkPlayer.Bid(-1);
}
else
{
networkPlayer.Bid(bid);
}
}
}
}
break;
case "SETTRMP":
int trumpPlayerSeat, trumpType;
if (int.TryParse(messageArgs[1], out trumpPlayerSeat))
{
if (trumpPlayerSeat != NonStaticPlayer.GetInternalPlayer().GetPlayersSeat())
{
if (int.TryParse(messageArgs[2], out trumpType))
{
NetworkPlayerBase networkPlayer = MultiplayerGamers.GetPlayerBySeat(trumpPlayerSeat);
networkPlayer.SetTrumpType(CardHelper.GetCardTypeFromValue(trumpType));
}
}
}
break;
case "DEALCALLBACK":
IncreaseDealCallback();
break;
case "START":
if (LobbyPlayerStats.RoomData.getRoomOwner() != NonStaticPlayer.GetInternalPlayer().PlayerName)
{
MultiplayerGamers.GameTable.gameTable.PlayersReadyCallback();
}
break;
}
LogManager.Log(networkMessage);
}
private void CurrentRoom_PlayerLeaving(object sender, RemoteNetworkPlayer remotePlayer)
{
this.RemovePlayer(remotePlayer);
}
private void CurrentRoom_PlayerJoined(object sender, RemoteNetworkPlayer remotePlayer)
{
this.AddPlayer(remotePlayer);
}