public void play(Player player)
{
if(player != localPlayer){
throw new InvalidOperationException("Not the local player. Only one local player is allowed.");
}
gameObserver.trigger(Events.LOCAL_PLAYERS_TURN, player);
}
public void play(Player player)
{
//socket.sendMessage<Player>(new Message<Player>(
// "ShouldPlay",
// player,
// player.GetType().FullName
//));
}
public void addPlayer(Player player)
{
if(currentRoom.players.Count == MAX_PLAYERS){
throw new InvalidOperationException("Max players on turn already reached.\nWhat's That?");
}
if(currentRoom.players.Contains(player)){
throw new InvalidOperationException("Player already playing.\nWhat's That?");
}
currentRoom.players.Add(player);
}
public void play(Player player)
{
gameObserver.trigger(Events.NPC_TURN, player);
if (player.cards.Count > 0) {
Card bestCard = player.cards[player.cards.Count - 1];
Property selectedProperty = turnService.currentProperty == Property.NONE ? getBestProperty(bestCard) : turnService.currentProperty;
turnService.selectProperty(selectedProperty, player);
turnService.play(bestCard, player);
}
}
public void endTurn()
{
List<Card> cards = cardsOnTable.Keys.ToList();
Card winner = getBiggest(cards, currentProperty);
currentHand = 1;
currentProperty = Property.NONE;
if (winner == null) {
cardsIdle.AddRange(cardsOnTable.Keys);
cardsOnTable.Clear();
Random r = new Random();
currentPlayer = currentRoom.players[r.Next(0, currentRoom.players.Count)];
gameObserver.trigger(Events.NEXT_PLAYERS_TURN, currentPlayer);
} else {
Player turnWinner = cardsOnTable[winner];
turnWinner.cards.InsertRange(0, cards);
turnWinner.cards.InsertRange(0, cardsIdle);
currentPlayer = turnWinner;
cardsOnTable.Clear();
cardsIdle.Clear();
gameObserver.trigger(Events.TURN_WINNER, turnWinner);
}
gameObserver.trigger(Events.END_TURN , this);
}
private void showCards()
{
var cardPrefab = Resources.Load("Card");
var cardOnTablePrefab = Resources.Load("CardOnTable");
localPlayer = turnService.currentPlayer;
GameObject[] cardsGame = GameObject.FindGameObjectsWithTag("Card");
foreach(var card in cardsGame){
Destroy(card);
}
Card cardOnTop = localPlayer.cards[localPlayer.cards.Count -1];
var cardObject = Instantiate(cardPrefab) as GameObject;
PlayLocalController cardCtrl = (PlayLocalController)cardObject.GetComponent<PlayLocalController>();
cardCtrl.inactiveTex = (Texture2D) Resources.Load(String.Format("Images/Card/{0}/{1}",cardOnTop.id[0],cardOnTop.id));
cardCtrl.activeTex = (Texture2D) Resources.Load(String.Format("Images/Card/{0}/{1}", cardOnTop.id[0], cardOnTop.id));
cardCtrl.eventMessage = cardOnTop;
cardObject.guiTexture.texture = cardCtrl.inactiveTex;
var index = turnService.currentPlayer.cards.IndexOf(cardOnTop);
cardObject.transform.position = new Vector3(0.1F, cardObject.transform.position.y, cardObject.transform.position.z);
turnService.cardsOnTable.Keys.ToList().TrueForAll((cardOnTable) => {
cardObject = Instantiate(cardOnTablePrefab) as GameObject;
cardCtrl = (PlayLocalController)cardObject.GetComponent<PlayLocalController>();
cardCtrl.inactiveTex = (Texture2D)Resources.Load(String.Format("Images/Card/{0}/{1}", cardOnTable.id[0], cardOnTable.id));
cardCtrl.activeTex = (Texture2D)Resources.Load(String.Format("Images/Card/{0}/{1}", cardOnTable.id[0], cardOnTable.id));
cardCtrl.eventMessage = cardOnTable;
cardObject.guiTexture.texture = cardCtrl.inactiveTex;
index = turnService.cardsOnTable.Keys.ToList().IndexOf(cardOnTable);
var x = 0.1F + index * 0.2F;
cardObject.transform.position = new Vector3(x, cardObject.transform.position.y, cardObject.transform.position.z);
return index < 4;
});
}
public Play(Player player, Card card)
{
this.player = player;
this.selectedCard = card;
}
public void startGame()
{
if(GameState.NOT_STARTED != gameState){
throw new InvalidOperationException("Already started the game.\nWhat's That?");
}
if(currentRoom.players.Count < MIN_PLAYERS){
throw new InvalidOperationException("Not enough players on turn.\nWhat's That?");
}
gameState = GameState.PLAYING;
deck = cardStrategy.getAll();
if(isMaster)
cardsToPlayers();
currentPlayer = currentRoom.players[0];
currentProperty = Property.NONE;
}
public void selectProperty(Property property, Player player)
{
if (player == currentPlayer && property != Property.NONE) {
currentProperty = property;
gameObserver.trigger(Events.SELECT_PROPERTY, property);
}
else {
throw new InvalidOperationException("Invalid player or property already assined or both.");
}
}
public void play(Card chosenCard, Player player)
{
if (currentPlayer != player){
throw new InvalidOperationException("That's not the current player.\nWhat's That?");
}
if (currentPlayer.cards.IndexOf(chosenCard) == -1){
throw new InvalidOperationException("Current Player does not have that card.\nWhat's That?");
}
if (cardsOnTable.Values.Contains(currentPlayer)) {
throw new InvalidOperationException("Current Player already chose his card for this turn.\nWhat's That?");
}
gameObserver.trigger(Events.CARD_TO_TABLE, new Play(player, chosenCard));
if (isTrumph(chosenCard)) {
gameObserver.trigger(Events.TRUMPH_ON_GAME, player);
}
cardsOnTable[chosenCard] = currentPlayer;
currentPlayer.cards.Remove(chosenCard);
currentPlayer = nextPlayer;
currentHand++;
if(currentHand > currentRoom.players.Count){
endTurn();
} else {
gameObserver.trigger(Events.NEXT_PLAYERS_TURN, currentPlayer);
}
}
public JoinRoom(Player player, Room room)
{
this.player = player;
this.room = room;
}
