//public Dictionary<string, int> PlayerIds;
#endregion
#region Player
#pragma warning disable 4014
public async Task <bool> PlayerDraw(string cardId)
{
if (string.IsNullOrEmpty(_playingAs))
{
//Make sure the value get's cached as early as possible to avoid problems
//at the end of a game, in case the hero changes - e.g. to Jaraxxus.
PlayingAs.GetType();
}
PlayerHandCount++;
if (string.IsNullOrEmpty(cardId))
{
return(true);
}
var drawnCard = PlayerDrawn.FirstOrDefault(c => c.Id == cardId);
if (drawnCard != null)
{
drawnCard.Count++;
}
else
{
drawnCard = GetCardFromId(cardId);
PlayerDrawn.Add(drawnCard);
PlayerDrawnIdsTotal.Add(cardId);
}
drawnCard.InHandCount++;
drawnCard.JustDrawn();
var deckCard = PlayerDeck.FirstOrDefault(c => c.Id == cardId && c.Count > 0 && c.IsStolen)
?? PlayerDeck.FirstOrDefault(c => c.Id == cardId && c.Count > 0);
if (deckCard == null)
{
return(false);
}
deckCard.Count--;
deckCard.InHandCount++;
LogDeckChange(false, deckCard, true);
if (deckCard.Count == 0 && Config.Instance.RemoveCardsFromDeck && !Config.Instance.HighlightCardsInHand)
{
//wait for just-drawn highlight to be over, then doublecheck (coule be back in deck after e.g.) -> remove
await deckCard.JustDrawn();
if (deckCard.Count == 0)
{
PlayerDeck.Remove(deckCard);
Logger.WriteLine("Removed " + deckCard.Name + " from deck (count 0)", "Game");
}
}
else
{
deckCard.JustDrawn();
}
return(true);
}
public static bool PlayerDeckDiscard(string cardId)
{
if (string.IsNullOrEmpty(cardId))
{
return(true);
}
var drawnCard = PlayerDrawn.FirstOrDefault(c => c.Id == cardId);
if (drawnCard == null)
{
PlayerDrawn.Add(GetCardFromId(cardId));
}
else
{
drawnCard.Count++;
}
var deckCard = PlayerDeck.FirstOrDefault(c => c.Id == cardId && c.Count > 0 && c.IsStolen)
?? PlayerDeck.FirstOrDefault(c => c.Id == cardId && c.Count > 0);
if (deckCard == null)
{
return(false);
}
deckCard.Count--;
LogDeckChange(false, deckCard, true);
if (CanRemoveCard(deckCard))
{
PlayerDeck.Remove(deckCard);
}
return(true);
}
public static void PlayerMulligan(string cardId)
{
PlayerHandCount--;
if (string.IsNullOrEmpty(cardId))
{
return;
}
var drawnCard = PlayerDrawn.FirstOrDefault(c => c.Id == cardId);
if (drawnCard != null)
{
drawnCard.Count--;
if (drawnCard.Count < 1)
{
PlayerDrawn.Remove(drawnCard);
}
}
var deckCard = PlayerDeck.FirstOrDefault(c => c.Id == cardId);
if (deckCard != null)
{
deckCard.Count++;
deckCard.InHandCount--;
LogDeckChange(false, deckCard, false);
}
else if (Config.Instance.RemoveCardsFromDeck)
{
deckCard = GetCardFromId(cardId);
PlayerDeck.Add(deckCard);
Logger.WriteLine("Added " + deckCard.Name + " to deck (count was 0)", "Game");
}
}
public static List <PlayerDeck> CreateCityCardDeck()
{
List <PlayerDeck> cityCards = new List <PlayerDeck>();
PlayerDeck cityCard1 = new PlayerDeck("Paris", 100000, "Blue");
PlayerDeck cityCard2 = new PlayerDeck("New York", 200000, "Blue");
PlayerDeck cityCard3 = new PlayerDeck("San Fransisco", 300000, "Blue");
PlayerDeck cityCard4 = new PlayerDeck("Ontario", 50000, "Blue");
PlayerDeck cityCard5 = new PlayerDeck("Atlanta", 12345, "Blue");
PlayerDeck cityCard6 = new PlayerDeck("Paris", 100000, "Blue");
PlayerDeck cityCard7 = new PlayerDeck("New York", 200000, "Blue");
PlayerDeck cityCard8 = new PlayerDeck("San Fransisco", 300000, "Blue");
PlayerDeck cityCard9 = new PlayerDeck("Ontario", 50000, "Blue");
PlayerDeck cityCard10 = new PlayerDeck("Atlanta", 12345, "Blue");
cityCards.Add(cityCard1);
cityCards.Add(cityCard2);
cityCards.Add(cityCard3);
cityCards.Add(cityCard4);
cityCards.Add(cityCard5);
cityCards.Add(cityCard6);
cityCards.Add(cityCard7);
cityCards.Add(cityCard8);
cityCards.Add(cityCard9);
cityCards.Add(cityCard10);
return(cityCards);
}
public GameResponse SelectDeck(string connectionId, PlayerDeck deck)
{
if (!UsersByConnectionId.ContainsKey(connectionId))
{
Logger.LogError($"Got select deck message for unknown connection id '{connectionId}'");
return(GameResponse.Failure("An error occurred selecting your deck. Please try again later."));
}
var user = UsersByConnectionId[connectionId];
var game = FindGameForUser(user.Name);
if (game == null)
{
Logger.LogError($"Got select deck message for user '{user.Name}' with no game");
return(GameResponse.Failure("Could not select your deck because your game was not found. Please restart your game."));
}
if (!game.GetPlayers().ContainsKey(user.Name))
{
Logger.LogError($"Got select deck message for user '{user.Name}' game '{game.Id}' which they are not in.");
return(GameResponse.Failure("An error occurred selecting your deck. Please try again later."));
}
var player = game.GetPlayers()[user.Name];
var customData = JsonConvert.DeserializeObject <PlayerCustomData>(player.CustomData) ?? new PlayerCustomData();
customData.Deck = deck;
player.CustomData = JsonConvert.SerializeObject(customData);
return(GameResponse.Succeeded(game));
}
public void SaveGame()
{
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Create(Application.persistentDataPath + "/playerInfo.dat");
PlayerData data = new PlayerData();
for (int i = 0; i < player1Decks.Count; i++)
{
List <string> deckList = new List <string>();
foreach (GameObject card in player1Decks[i].GetComponent <Deck>().deck)
{
deckList.Add(card.GetComponent <CardBase>()._name);
}
PlayerDeck playerDeck = new PlayerDeck();
playerDeck._name = player1Decks[i].GetComponent <Deck>()._name;
playerDeck.DeckList = deckList;
data.savedDecks.Add(playerDeck);
player1Decks[i].transform.SetParent(GameManager.instance.transform);
}
bf.Serialize(file, data);
file.Close();
}
public static Deal CreateDeal()
{
var newDeal = new Deal();
var deck = new Deck();
var list = deck.GetAllShuffledCards();
// Draw on three players`
var player1Cards = new PlayerDeck();
var player2Cards = new PlayerDeck();
var player3Cards = new PlayerDeck();
for (var i = 0; i <= 4; i++)
{
player1Cards.AddRange(list.Skip(i * 6).Take(2));
player2Cards.AddRange(list.Skip(i * 6 + 2).Take(2));
player3Cards.AddRange(list.Skip(i * 6 + 4).Take(2));
}
newDeal.InitialCards.Add(player1Cards);
newDeal.InitialCards.Add(player2Cards);
newDeal.InitialCards.Add(player3Cards);
return(newDeal);
}
public Player(string PlayName)
{
_name = PlayName;
PlayerHand = new Hand();
PlayerDiscard = new Discard();
PlayerField = new Field();
PlayersDeck = new PlayerDeck();
}
public void PointsTestSingleCard()
{
PlayerDeck play = new PlayerDeck("player");
Card card = new Card(Card.CardValue.Two, Card.CardSuit.Heart);
play.AddCard(card);
Assert.AreEqual(play.Points(), 2, "Deck should be 2");
}
public void JockerPoint()
{
PlayerDeck play = new PlayerDeck("player");
Card card1 = new Card(Card.CardValue.Jocker, Card.CardSuit.None);
play.AddCard(card1);
Assert.AreEqual(play.Points(), 20, "Deck should be 20");
}
private void SetupNewGame()
{
gameState.ResetGameState();
PlayerDeck playerDeck = testPlayerDeck;
playerDeckManager.InitStartDeck(playerDeck);
}
void SetupGame()
{
//draw a card from infection deck,
PlayerDeck bDeck = infectDec;
bDeck.Draw();
//slide it over to discard deck
//spawn 3 infect on city
}
public void ShuffleIntoDeck(PlayerDeck pd)
{
if (pd)
{
Debug.Log("[Dis] Shuffling Discard into Deck");
pd.AddCardList(_discardContents);
_discardContents.Clear();
}
}
public static void SetPremadeDeck(Deck deck)
{
PlayerDeck.Clear();
foreach (var card in deck.GetSelectedDeckVersion().Cards)
{
PlayerDeck.Add((Card)card.Clone());
}
IsUsingPremade = true;
}
internal static long Part1(string input)
{
string[] lines = input.Split('\n');
PlayerDeck p1 = new PlayerDeck();
PlayerDeck p2 = new PlayerDeck();
bool playerone = true;
foreach (string ln in lines)
{
if (int.TryParse(ln, out int v))
{
if (playerone)
{
p1.cards.Enqueue(v);
}
else
{
p2.cards.Enqueue(v);
}
}
else if (ln == "")
{
playerone = false;
}
}
do
{
int card1 = p1.cards.Dequeue();
int card2 = p2.cards.Dequeue();
if (card1 > card2)
{
p1.GainCards(card1, card2);
}
else
{
p2.GainCards(card2, card1);
}
} while(!GameOver(p1, p2));
int score = 0;
if (p1.cards.Count == 0)
{
while (p2.cards.Count > 0)
{
score += p2.cards.Count * p2.cards.Dequeue();
}
}
else
{
while (p1.cards.Count > 0)
{
score += p1.cards.Count * p1.cards.Dequeue();
}
}
return(score);
}
public void DrawMakesDeckOneLess()
{
var newDeck = new PlayerDeck();
var originalCount = newDeck.Count;
newDeck.Draw();
Assert.Equal(originalCount - 1, newDeck.Count);
}
public PlayerDeck(PlayerDeck deck, int max)
{
cards = new Queue <int>();
for (int x = 0; x < max && x < deck.cards.Count; x++)
{
int xx = deck.cards.ElementAt(x);
cards.Enqueue(xx);
}
}
//public Dictionary<string, int> PlayerIds;
#endregion
#region Player
#pragma warning disable 4014
public async Task <bool> PlayerDraw(string cardId)
{
PlayerHandCount++;
if (string.IsNullOrEmpty(cardId))
{
return(true);
}
var drawnCard = PlayerDrawn.FirstOrDefault(c => c.Id == cardId);
if (drawnCard != null)
{
drawnCard.Count++;
}
else
{
drawnCard = GetCardFromId(cardId);
PlayerDrawn.Add(drawnCard);
PlayerDrawnIdsTotal.Add(cardId);
}
drawnCard.InHandCount++;
drawnCard.JustDrawn();
var deckCard = PlayerDeck.FirstOrDefault(c => c.Id == cardId && c.Count > 0 && c.IsStolen)
?? PlayerDeck.FirstOrDefault(c => c.Id == cardId && c.Count > 0);
if (deckCard == null)
{
return(false);
}
deckCard.Count--;
deckCard.InHandCount++;
LogDeckChange(false, deckCard, true);
if (deckCard.Count == 0 && Config.Instance.RemoveCardsFromDeck && !Config.Instance.HighlightCardsInHand)
{
//wait for just-drawn highlight to be over, then doublecheck (coule be back in deck after e.g.) -> remove
await deckCard.JustDrawn();
if (deckCard.Count == 0)
{
PlayerDeck.Remove(deckCard);
Logger.WriteLine("Removed " + deckCard.Name + " from deck (count 0)", "Game");
}
}
else
{
deckCard.JustDrawn();
}
return(true);
}
private void Start()
{
instance = this;
playerDeck = new List <CardInfo>();
hand = new CardInfo[5];
discardPile = new List <Card>();
lostPile = new List <Card>();
CreateCards();
InstantiateDeck();
DrawCards();
}
void Init(int id)
{
globalId = id;
players.Add(id, this);
if (photonView.IsMine)
{
local = this;
UpdateUI();
}
}
private void Start()
{
if (Instance == null)
{
DontDestroyOnLoad(this);
Instance = this;
}
else
{
Destroy(this);
}
}
public static List <PlayerDeck> AddingEventCards()
{
List <PlayerDeck> eventCards = new List <PlayerDeck>();
PlayerDeck eventCard1 = new PlayerDeck("Improved Sanitation", "Treat Disease removes 1 more cube of the same color, if present, until the player's next turn begins");
PlayerDeck eventCard2 = new PlayerDeck("Airlift", "Move any 1 pawn to any city. Get permission before moveing another player's pawn");
eventCards.Add(eventCard1);
eventCards.Add(eventCard2);
return(eventCards);
}
private void Start()
{
player = GameObject.FindGameObjectWithTag("Player");
playerDeckScript = player.GetComponent <PlayerDeck>();
cardsInventoryScript = player.GetComponent <PlayerCardsInventory>();
deckPos = GameObject.FindGameObjectWithTag("Deck").transform;
deckOrganizer = GameObject.FindGameObjectWithTag("DeckOrganizer"); // o nome deckOrganizer se refere a aba de organização no total
deckOrganizer.SetActive(false);
player.transform.position = playerPos.position;
}
void DeckDraw()
{
RaycastHit hitOut;
if (Utility.ScreenRaycast(out hitOut, DeckMask) && PlayersHand)
{
PlayerDeck dc = hitOut.collider.gameObject.GetComponent <PlayerDeck>();
if (dc)
{
dc.DrawCard(PlayersHand);
}
}
}
private bool CheckInfinite(PlayerDeck p1, PlayerDeck p2)
{
string a = p1.GetCards();
string b = p2.GetCards();
string s = a + "|" + b;
if (playerDecks.Contains(s))
{
return(true);
}
playerDecks.Add(s);
return(false);
}
void Awake()
{
playerDeck = GameObject.Find("PlayerDeck").GetComponent <PlayerDeck>();
playerCardDropZone = GameObject.Find("PlayerCardDropZone").GetComponent <PlayerCardDropZone>();
OnTurnChanged += delegate(object sender, EventArgs e)
{
UpdateTurnInfoText();
};
state = State.GameStart;
}
// Use this for initialization
void Start()
{
playerDeck = new PlayerDeck();
opponentDeck = new PlayerDeck();
ai = new SimpleRandomAI();
if (Application.platform != RuntimePlatform.WindowsPlayer ||
Application.platform != RuntimePlatform.WindowsEditor ||
Application.platform != RuntimePlatform.OSXPlayer ||
Application.platform != RuntimePlatform.OSXEditor)
{
delay = 0.3f;
}
}
public void PointsTestMultipleCardFigures()
{
PlayerDeck play = new PlayerDeck("player");
Card card1 = new Card(Card.CardValue.Jack, Card.CardSuit.Heart);
Card card2 = new Card(Card.CardValue.Queen, Card.CardSuit.Diamond);
Card card3 = new Card(Card.CardValue.King, Card.CardSuit.Club);
Card card4 = new Card(Card.CardValue.Ace, Card.CardSuit.Spade);
play.AddCard(card1);
play.AddCard(card2);
play.AddCard(card3);
play.AddCard(card4);
Assert.AreEqual(play.Points(), 45, "Deck should be 45");
}
public void PointsTestMultipleCard()
{
PlayerDeck play = new PlayerDeck("player");
Card card1 = new Card(Card.CardValue.Two, Card.CardSuit.Heart);
Card card2 = new Card(Card.CardValue.Three, Card.CardSuit.Diamond);
Card card3 = new Card(Card.CardValue.Four, Card.CardSuit.Club);
Card card4 = new Card(Card.CardValue.Five, Card.CardSuit.Spade);
play.AddCard(card1);
play.AddCard(card2);
play.AddCard(card3);
play.AddCard(card4);
Assert.AreEqual(play.Points(), 14, "Deck should be 14");
}
public void DrawCard(Card card)
{
GameObject cardObject = PlayerDeck.GetNewCard(card);
LSAnimation move1 = AnimationFactory.Instance.CreatMove(cardObject, RightShowTrans);
AnimationManager.Instance.AddAnimation(move1);
LSAnimation delay = AnimationFactory.Instance.CreatDelay(0.2f);
AnimationManager.Instance.AddAnimation(delay);
cardObject.AddComponent <HandDrag>();
PlayerHand.Add(cardObject.GetComponent <UICard>());
}
// Start is called before the first frame update
void Start()
{
if (!TheDeck)
{
TheDeck = GetComponentInChildren <PlayerDeck>();
}
if (!TheDiscard)
{
TheDiscard = GetComponentInChildren <PlayerDiscard>();
}
if (!TheDeck || !TheDiscard || !TheBoard)
{
Debug.LogError(this.gameObject.name + " does not have all the required components!");
}
}
//public int Mana { get { return mana; } }
//public int Energy { get { return energy; } }
/* public List<Card> CardSlot
{
get
{
return new List<Card>(cards);
}
set{cards = value;}
}
public List<MinionSlot> MinionSlots
{
get{return new List<MinionSlot>(minionSlots);}
set{MinionSlots = value;}
} */
/* public List<Card> Graveyard
{
get{return new List<Card>(graveyard);}
set{graveyard = value;}
} */
public void Init(PlayerType _playerType)
{
playerType = _playerType;
if(playerType == PlayerType.You)
{
//cardSlots = GameManager.Instance.YourCards;
//frontline = GameManager.Instance.YourFrontline;
//backline = GameManager.Instance.YourBackline;
playerDeck = GameManager.Instance.YourPlayerDeck;
}
else if(playerType == PlayerType.Opponent)
{
//cardSlots = GameManager.Instance.OpponentCards;
//frontline = GameManager.Instance.OpponentFrontline;
//backline = GameManager.Instance.OpponentBackline;
playerDeck = GameManager.Instance.OpponentPlayerDeck;
}
}
void Start ()
{
MinionManager.Instance.Init();
opponent = new Player();
you = new Player();
activePlayer = you;
yourPlayerDeck = new PlayerDeck();
opponentPlayerDeck = new PlayerDeck();
yourPlayerDeck.Init(PlayerType.You);
opponentPlayerDeck.Init(PlayerType.Opponent);
opponent.Init(PlayerType.Opponent);
you.Init(PlayerType.You);
opponent.GameStart();
you.GameStart();
activePlayer.FirstStartTurn();
NextTurnButton.ReleasedEvent += StartFight;
}
