public void AddPanel(CardPanel.IAssignedPanel data, bool addedFromLibrary, bool draggedOn)
{
CardPanel newPanel = Instantiate(cardPanelPrefab, panelParent);
newPanel.Setup(data, cardManager, this, popups);
panels.Add(newPanel);
if (addedFromLibrary)
{
if (draggedOn)
{
Vector2 localPos;
RectTransformUtility.ScreenPointToLocalPointInRectangle(newPanel.parentRect, Input.mousePosition, null, out localPos);
newPanel.SetPosition(localPos);
// The user dragged this on, so remember the position. Note that we
// don't give an undo label. We don't actually want this to be
// undo-able, otherwise it would take *2* undos to undo the add.
newPanel.SetUseMetadata(null);
}
else
{
StartCoroutine(PlaceNewlyAddedPanelRoutine(newPanel, ZoomOutToAllPanels));
}
}
}
public IEnumerator AsyncMove(CardPanel newPanel, CardPanel oldPanel, Action <bool> callback)
{
StartNewMove();
yield return(SpecialMove(newPanel, oldPanel));
callback(IsCompleted);
}
void PlacePanel(CardPanel panel, System.Action onComplete = null)
{
bool hadMetadata = panel.TrySetupFromMetadata();
if (!hadMetadata)
{
float width = panel.GetReferenceRectTransform().rect.width;
panel.SetPosition(Vector2.zero);
/* if (panels.Count == 0)
* {
* panel.SetPosition(Vector2.zero);
* }
* else
* {
* panel.SetPosition(panels[panels.Count - 1].rectTransform.anchoredPosition + new Vector2(panels[panels.Count - 1].GetReferenceRectTransform().rect.width, 0) + new Vector2(width / 2f, 0));
* } */
//addPanelRect.anchoredPosition += new Vector2(width, 0);
// Save position metadata, but don't create an undo item. The user didn't
// do this.
panel.SetUseMetadata(null);
}
onComplete?.Invoke();
}
public void CopyPanel(CardPanel panel)
{
CardPanel.IAssignedPanel newPanel = panel.GetModel().Duplicate();
panelManager.SetOrganizedPanels(false);
panelManager.AddPanel(newPanel, false /*added from library*/, false /*draggedOn */);
panelManager.SetupPanelPlacementAndNotes(model);
}
private IEnumerator WinCard(CardPlayer winner, string playerId, CardPanel cardPanel, CardPanel[] wonPanels)
{
if (cardPanel == null)
{
if (wonPanels.Length > 1)
{
CardManager.Instance.HoldPlace(cardPanel = wonPanels[0]);
yield return(CardManager.Instance.TranslateCard(cardPanel, wonPanels[1]));
}
}
else
{
ColorManager.Instance.SetCardFocused(wonPanels);
ColorManager.Instance.SetCardPlayed(cardPanel);
cardPanel.Details.Player.RemoveCard(cardPanel);
if (!cardPanel.IsRevealed)
{
StartCoroutine(CardManager.Instance.TurnCard(cardPanel));
}
if (wonPanels.Length > 0)
{
yield return(CardManager.Instance.TranslateCard(cardPanel, wonPanels[0]));
}
}
if (PlayerExists(playerId))
{
Debug.Log(playerId + " - - - - - -");
}
var list = wonPanels.ToList();
list.Insert(0, cardPanel);
yield return(CardManager.Instance.WinCards(winner, list.ToArray()));
}
public void AddPlayer(Player player, CardPanel cardPanel)
{
_playerControls.Add(new PlayerControls()
{
Player = player, CardPanel = cardPanel
});
}
protected override void Show()
{
base.Show();
ConfirmButton.onClick.AddListener(DiscardAndDoAction);
CancelButton.onClick.AddListener(Cancel);
CardPanel.SetActive(true);
}
public void update()
{
listBoxCards.Text = "";
listBoxCards.DataSource = null;
listBoxCards.Text = "";
listBoxCards.DataSource = null;
listBoxCards.ResetText();
listBoxCards.DataSource = connection;
listBoxCards.Update();
this.Update();
flowLayoutPanelCards.Controls.Clear();
foreach (Card c in connection)
{
CardPanel p = new CardPanel();
p.Width = Math.Max(45, Math.Min(106, 425 / connection.Count));
if (c == connection.Last())
{
p.Width = 106;
}
p.Height = 150;
p.BackgroundImage = ResizeImage(GetCardImage(c), 106, 150);
p.BackgroundImageLayout = ImageLayout.None;
p.heldCard = c;
p.MouseClick += CardClick;
p.MouseDoubleClick += listBoxCards_MouseDoubleClick;
p.Margin = new Padding()
{
All = 0
};
flowLayoutPanelCards.Controls.Add(p);
}
listBoxCards_SelectedIndexChanged(null, null);
}
public override void PlayCard(CardPanel cardPanel)
{
Debug.Log("Play Card : " + cardPanel.Card);
if (cardPanel.Details.Player.Id.Equals(_currentPlayer))
{
_roomManager.SendMessage(Message.Create("PlayCard", GetCard(cardPanel.Card)));
}
}
public void SetCard(Card c, CardPanel cardPanel)
{
this.card = c;
nameText.text = c.name;
manaText.text = c.manaCost.ToString();
button.onClick.AddListener(() => cardPanel.RemoveCardFromDeck(this));
}
// public IEnumerator WinCards(CardPlayer player, CardPanel cardPanel, params CardPanel[] cardPanels)
// {
// if (cardPanel == null || cardPanels == null) yield break;
// for (var i = cardPanels.Length - 1; i > 0; i--) HoldPlace(cardPanels[i]);
//
// yield return null;
// var offset = Vector3.Scale(previewOffset, canvas.localScale);
// if (cardPanels.Length > 0) cardPanel.Root.SetParent(cardPanels[0].Root);
//
// for (var i = 0; i < cardPanels.Length - 1; i++)
// {
// yield return TranslateWorld(cardPanels[i].Root, cardPanels[i + 1].Root.position + offset);
// cardPanels[i].Root.SetParent(cardPanels[i+1].Root);
// SoundManager.Instance.PlayClip(SoundManager.Instance.CardFriction);
// }
//
// StartCoroutine(DeleteCards(player.Pivot, cardPanels));
// GameManager.Instance.CardsWon(player, cardPanels);
// }
public void HoldPlace(CardPanel cardPanel)
{
var placeHolder = new GameObject(cardPanel.ToString(), typeof(RectTransform));
placeHolder.transform.SetParent(cardPanel.Root.parent);
placeHolder.transform.SetSiblingIndex(cardPanel.Root.GetSiblingIndex());
cardPanel.Root.SetParent(tempGroup);
}
public void PlayCard(CardPanel cardPanel)
{
if (!cardPanel.IsRevealed)
{
StartCoroutine(CardManager.Instance.TurnCard(cardPanel));
}
StartCoroutine(PlayTurn(cardPanel));
}
public IEnumerator CardPlayed(CardPanel newPanel)
{
var oldPanel = CardManager.Instance.GetCards()
.Where(panel => panel.Card.number == newPanel.Card.number)
.OrderBy(panel => panel.Details.Index)
.FirstOrDefault();
if (oldPanel)
{
var number = newPanel.Card.number;
var groups = CardManager.Instance.GetCards().Where(panel => panel.Card.number >= number)
.OrderBy(panel => panel.Card.number)
.GroupBy(panel => panel.Card.number)
.TakeWhile(group => group.First().Card.number == number++);
var cards = groups.Select(group => group.First()).ToList();
cards.Insert(0, newPanel);
var list = cards.ToArray();
ColorManager.Instance.SetCardFocused(list);
ColorManager.Instance.SetCardPlayed(newPanel);
yield return(CardManager.Instance.TranslateCard(newPanel, oldPanel));
StartNewMove();
if (oldPanel.Details.Turn == newPanel.Details.Turn &&
oldPanel.Details.Index == newPanel.Details.Index - 1 &&
oldPanel.Details.Player is CardMainPlayer)
{
yield return(SpecialMove(newPanel, oldPanel));
if (IsCompleted)
{
if (!_countDictionary.ContainsKey(oldPanel.Details.Player))
{
_countDictionary.Add(oldPanel.Details.Player, 0);
}
_countDictionary[oldPanel.Details.Player]++;
}
}
else
{
SetCompleted(false);
}
if (!IsCompleted)
{
_lastWinner = newPanel.Details.Player;
yield return(CardManager.Instance.WinCards(_lastWinner, list));
_lastWinner.ReportScore(list.Length);
yield break;
}
ColorManager.Instance.SetCardDefault(list);
}
yield return(CardManager.Instance.AddCard(newPanel));
}
IEnumerator PlaceNewlyAddedPanelRoutine(CardPanel panel, System.Action onComplete)
{
yield return(null);
PlacePanel(panel);
yield return(null);
onComplete?.Invoke();
}
public IEnumerator TranslateCard(CardPanel newPanel, CardPanel oldPanel)
{
newPanel.Root.SetParent(tempGroup, true);
var offset = Vector3.Scale(previewOffset, canvas.localScale);
yield return(TranslateCard(newPanel, oldPanel.Root.position + offset));
SoundManager.Instance.PlayClip(SoundManager.Instance.CardFriction);
}
private IEnumerator PlayTurn(CardPanel cardPanel)
{
yield return(Play(cardPanel));
if (cardsPerTurns.y > 0 && CardsPlayed >= cardsPerTurns.y)
{
PassPlayerTurn();
}
}
private IEnumerator SpecialMove(CardPanel newPanel, CardPanel oldPanel)
{
if (_countDictionary.ContainsKey(oldPanel.Details.Player) && _countDictionary[oldPanel.Details.Player] > maxMoves)
{
Debug.LogWarning("Max moves reached");
SetCompleted(false);
yield break;
}
specialPanel.SetActive(true);
oldCardPanel.gameObject.SetActive(false);
newCardPanel.gameObject.SetActive(false);
actionsPanel.gameObject.SetActive(false);
oldCardPanel.SetCard(oldPanel.Card);
newCardPanel.SetCard(newPanel.Card);
StartCoroutine(Utils.Scale(oldCardPanel.transform, animationDuration, animationCurve,
Vector3.one * startScale, Vector3.one));
yield return(null);
oldCardPanel.gameObject.SetActive(true);
yield return(new WaitForSeconds(.2f));
StartCoroutine(Utils.Scale(newCardPanel.transform, animationDuration, animationCurve,
Vector3.one * startScale, Vector3.one));
yield return(null);
newCardPanel.gameObject.SetActive(true);
yield return(new WaitForSeconds(.2f));
StartCoroutine(Utils.Scale(actionsPanel.transform, animationDuration, animationCurve,
Vector3.one * startScale, Vector3.one));
yield return(null);
actionsPanel.gameObject.SetActive(true);
yield return(new WaitWhile(() => _isWaiting && !_isHerraf));
if (_isHerraf)
{
yield return(quizManager.StartQuiz(newPanel.Card, SetCompleted));
}
if (_isCompleted)
{
if (!_countDictionary.ContainsKey(oldPanel.Details.Player))
{
_countDictionary.Add(oldPanel.Details.Player, 0);
}
_countDictionary[oldPanel.Details.Player]++;
}
specialPanel.SetActive(false);
}
public IEnumerator TurnCard(CardPanel cardPanel)
{
var card = cardPanel.transform;
var angles = card.eulerAngles;
yield return(Utils.Rotate(card, animationDuration / 2, animationCurve, angles, angles + Vector3.up * 90));
cardPanel.SetRevealed(!cardPanel.IsRevealed);
yield return(Utils.Rotate(card, animationDuration / 2, animationCurve, card.localEulerAngles, Vector3.zero));
}
// private bool locked;
public void SetCard(Card card, CardPanel cardPanel)
{
nameText.text = card.name;
descriptionText.text = card.description;
manaCostText.text = card.manaCost.ToString();
loreText.text = card.lore.ToString();
art.sprite = card.sprite;
addButton.onClick.AddListener(() => cardPanel.AddCardToDeck(card));
}
protected override void Hide()
{
base.Hide();
_discardingCards.Clear();
CardPanel.SetActive(false);
if (_previousCardPanel != null)
{
_previousCardPanel.SetActive(true);
}
Description.Hide();
}
public void CardClicked(CardPanel panel)
{
if (panel != null)
{
if (panel.NewNotifyObject != null)
{
Destroy(panel.NewNotifyObject);
CardsBaseComponent.CardChecked(panel.PanelCardName);
}
}
}
private void DisplayPanel(string panelName, bool visibility)
{
GameObject panel = GameObject.Find(panelName);
panel.GetComponent <CanvasGroup>().alpha = (visibility) ? 1 : 0;
// if it's a card panel, show/hide its cards
CardPanel cardPanel = panel.GetComponent <CardPanel>();
cardPanel.SetVisible(visibility);
}
internal void OnPanelEndDrag(CardPanel cardPanel)
{
// Debug.Assert(cardPanel == draggedPanel);
if (IsPanelOverTrash())
{
cardPanel.DeletePanel();
}
else
{
cardPanel.SetDeleteFeedback(false);
}
draggedPanel = null;
}
public void BanSpecificCard(Card newCard)
{
for (int i = 0; i < L_Cards_visible.Count; i++)
{
if (L_Cards_visible [i].GetComponent <CardPanel> ().card.uId == newCard.uId)
{
CardPanel cardScript = L_Cards_visible [i].GetComponent <CardPanel> ();
cardScript.RemoveCard(killCardPos);
this.UpdateCardList(newCard);
return;
}
}
}
public void GenerateCard(Card newCard)
{
GameObject hiddenCard = Instantiate(this.cardInvisiblePrefab, this.cardHiddenContainer.transform.position, this.transform.rotation, this.cardHiddenContainer.transform) as GameObject;
L_Cards_hidden.Add(hiddenCard);
this.UpdateSpacing();
GameObject card = Instantiate(this.cardPrefab, this.instantiateCardPos.transform.position, this.transform.rotation, this.cardVisibleContainer.transform) as GameObject;
CardPanel cardScript = card.GetComponent <CardPanel> ();
cardScript.Init(newCard, L_Cards_hidden.Count - 1, hiddenCard);
L_Cards_visible.Add(card);
}
public override void PlayCard(CardPanel cardPanel)
{
if (!CanPlayCard(cardPanel))
{
return;
}
cardPanel.Details.Player.RemoveCard(cardPanel);
if (!cardPanel.IsRevealed)
{
StartCoroutine(CardManager.Instance.TurnCard(cardPanel));
}
StartCoroutine(PlayCardTurn(cardPanel));
}
public void ClearPanels()
{
HidePanelCanvas();
draggedPanel = null;
foreach (var panel in panels)
{
if (panel != null)
{
// CardPanel may destroy itself..whatever
GameObject.Destroy(panel.gameObject);
}
}
panels.Clear();
}
public void Initialise()
{
var tempCard = _cardPrototype;
_currentHand.Clear();
placeholderCardPanel = tempCard.GetComponent <CardPanel>();
placeholderCardPanel.GetComponent <Card>().CreateBlankCard();
placeholderCardPanel.SetToBlankCard();
//_currentHand = new Dictionary<int, CardPanel>();
_currentHand.Add(0, tempCard);
_currentHand.Add(1, tempCard);
_currentHand.Add(2, tempCard);
_currentHand.Add(3, tempCard);
}
private IEnumerator Play(CardPanel cardPanel)
{
if (State == GameState.Playing)
{
yield break;
}
SoundManager.Instance.PlayClip(SoundManager.Instance.CardPlay);
State = GameState.Playing;
cardPanel.Details.Index = ++Index;
cardPanel.Details.Turn = Turn;
yield return(GameManager.Instance.CardPlayed(cardPanel));
State = GameState.Waiting;
CardsPlayed++;
}
public IEnumerator AddCard(CardPanel cardPanel)
{
Transform placeholder = null;
foreach (Transform child in cardGroup)
{
if (child.childCount != 0)
{
continue;
}
placeholder = child;
break;
}
yield return(DealCard(cardPanel, cardGroup, placeholder));
}
