public void ExportThread()
{
WaitDialog zWait = WaitDialog.Instance;
for (int nIdx = ExportLayoutStartIndex; nIdx < ExportLayoutEndIndex; nIdx++)
{
IssueManager.Instance.FireChangeCardInfoEvent(nIdx, 1);
IssueManager.Instance.FireChangeElementEvent(string.Empty);
ChangeExportLayoutIndex(nIdx);
zWait.ProgressReset(1, 0, CurrentDeck.CardCount, 0);
UpdateBufferBitmap(CurrentDeck.CardLayout.width, CurrentDeck.CardLayout.height);
var zGraphics = Graphics.FromImage(m_zExportCardBuffer);
for (var nCardIdx = 0; nCardIdx < CurrentDeck.CardCount; nCardIdx++)
{
IssueManager.Instance.FireChangeCardInfoEvent(nIdx, nCardIdx + 1);
CurrentDeck.CardPrintIndex = nCardIdx;
CardRenderer.DrawPrintLineToGraphics(zGraphics);
zWait.ProgressStep(1);
}
zWait.ProgressStep(0);
}
zWait.ThreadSuccess = true;
zWait.CloseWaitDialog();
}
public override bool Render(ProjectLayoutElement zElement, Graphics zGraphics)
{
var zFormat = new StringFormat
{
Alignment = StringAlignment.Near,
LineAlignment = StringAlignment.Near,
};
// indicate any text being cut off
if (zElement.height < TargetRect.Y + TargetRect.Height)
{
// completely end the draw
return(false);
}
// NOTE: when rendering there is no need for a target rect as that information has already been processed
float targetX = TargetRect.X + m_fXOffset;
float targetY = TargetRect.Y + m_fYOffset;
// draw border (debugging)
if (CardMakerInstance.DrawFormattedTextBorder)
{
zGraphics.DrawRectangle(Pens.Green, targetX, targetY, TargetRect.Width, TargetRect.Height);
}
// when a string is measured there is a bit of an offset to where it renders (into the target rect a few pixels right ---->)
targetX -= m_rectMeasuredRectangle.X;
if (0 == zElement.outlinethickness)
{
try
{
zGraphics.DrawString(m_sVariable, m_zFont, m_zFontBrush, targetX, targetY, zFormat);
}
catch (Exception)
{
Logger.AddLogLine("Unable to render text (font issue?)");
}
}
else
{
// prepare to draw text
var zPath = new GraphicsPath();
try
{
zPath.AddString(m_sVariable, m_zFont.FontFamily, (int)m_zFont.Style, m_fFontOutlineSize,
new PointF(targetX, targetY), zFormat);
CardRenderer.DrawPathOutline(zElement, zGraphics, zPath);
}
catch (Exception)
{
Logger.AddLogLine("Unable to render text (font issue?)");
}
// fill in the outline
zGraphics.FillPath(m_zFontBrush, zPath);
}
return(true);
}
public override void ExportThread()
{
var progressLayoutIdx = ProgressReporter.GetProgressIndex(ProgressName.LAYOUT);
var progressCardIdx = ProgressReporter.GetProgressIndex(ProgressName.CARD);
ProgressReporter.ProgressReset(progressLayoutIdx, 0, ExportLayoutIndices.Length, 0);
foreach (var nIdx in ExportLayoutIndices)
{
IssueManager.Instance.FireChangeCardInfoEvent(nIdx, 1);
IssueManager.Instance.FireChangeElementEvent(string.Empty);
ChangeExportLayoutIndex(nIdx);
ProgressReporter.ProgressReset(progressCardIdx, 0, CurrentDeck.CardCount, 0);
UpdateBufferBitmap(CurrentDeck.CardLayout.width, CurrentDeck.CardLayout.height);
var zGraphics = Graphics.FromImage(m_zExportCardBuffer);
for (var nCardIdx = 0; nCardIdx < CurrentDeck.CardCount; nCardIdx++)
{
IssueManager.Instance.FireChangeCardInfoEvent(nIdx, nCardIdx + 1);
CurrentDeck.CardPrintIndex = nCardIdx;
CardRenderer.DrawPrintLineToGraphics(zGraphics);
ProgressReporter.ProgressStep(progressCardIdx);
}
ProgressReporter.ProgressStep(progressLayoutIdx);
}
ProgressReporter.ThreadSuccess = true;
ProgressReporter.Shutdown();
}
public void Awake()
{
CardIndex = FindObjectOfType <CardIndex>();
DiscardPile = FindObjectOfType <IndexDiscardPile>();
var notDummyCardRenderers =
from r in FindObjectsOfType <CardRenderer>()
where r.DummyRenderer == false
select r;
CardsInPlay.Clear();
CardsInPlay.AddRange(notDummyCardRenderers);
for (int i = 0; i < CardsInPlay.Count; i++)
{
CardRenderer capturedRenderer = CardsInPlay[i];
CardsInPlay[i].Background.GetComponent <RightClickListener>().rightClick.AddListener(
delegate {
OnAnyCardButtonUI(capturedRenderer.Index, true);
}
);
}
collectionViewer.OnAnyCardClickedDelegate = (b) => {
OnAnyCardButtonUI(b, false);
};
}
/// <summary>
/// Update the transforms of all the cards in the hand, as well as the render order
/// </summary>
public void UpdatePositions()
{
int numberOfCards = cardsInHand.Count;
float distBetween = width / (numberOfCards + 1);
float totalDistance = distBetween * numberOfCards;
float currentX = (-rect.rect.width / 2.0f) + distBetween;
for (int i = 0; i < numberOfCards; i++)
{
CardRenderer card = cardsInHand[i];
LeanTween.cancel(card.gameObject);
float desiredY = 0;
if (holdCardsDown)
{
desiredY = hiddenY;
}
else if (highlightedCard != -1)
{
desiredY = (highlightedCard == i) ? highlightedY : hiddenY;
}
int dist = Math.Abs(lastHighlightedCard - i);
LeanTween.moveLocal(card.gameObject,
new Vector2(currentX, desiredY - verticalStray * dist), cardMoveTime);
LeanTween.rotateZ(card.gameObject, rotationalStray * (lastHighlightedCard - i)
, cardMoveTime);
currentX += distBetween;
}
UpdateCardOrder();
}
/// <summary>
/// The event cards trigger when they're clicked on
/// </summary>
/// <param name="cr"></param>
public void OnCardMouseClick(CardRenderer cr)
{
if (!holdCardsDown)
{
manager.OnPlayerSelectCard(cr);
}
}
public void Awake()
{
networking = FindObjectOfType <GameplayNetworking>();
AnimatedHands.AddRange(networking.ClockwiseHands);
gameTimer = FindObjectOfType <GameTimer>();
var notDummyCardRenderers =
from r in FindObjectsOfType <CardRenderer>()
where r.DummyRenderer == false
select r;
CardsInPlay.Clear();
CardsInPlay.AddRange(notDummyCardRenderers);
for (int i = 0; i < CardsInPlay.Count; i++)
{
//CardsInPlay[i].Background.gameObject.name = "SET LISTENER";
CardRenderer capturedRenderer = CardsInPlay[i];
CardsInPlay[i].Background.GetComponent <Button>().onClick.AddListener(
delegate {
OnAnyCardButtonUI(capturedRenderer.Index);
}
);
}
CardsNotInPlay.OnAnyCardClickedDelegate = (index) => { OnAnyCardButtonUI(index); };
}
/// <summary>
/// Create a new CardRenderer object and based on a specific CardData
/// </summary>
/// <param name="basedOn"></param>
/// <returns>A CardRenderer component, attached to new card prefab</returns>
public CardRenderer CreateCardRenderer(CardData basedOn)
{
//construct new card prefab based on the input carddata
CardRenderer instance = Instantiate(cardPrefab);
instance.ShowCardData(basedOn);
return(instance);
}
protected CardExportBase(int[] arrayExportLayoutIndices)
{
ExportLayoutIndices = arrayExportLayoutIndices;
CardRenderer = new CardRenderer
{
CurrentDeck = new Deck()
};
}
private static Brush GetFillBrush(ProjectLayoutElement zElement)
{
// prefer the background color
return(CardRenderer.GetElementOpacityBrush(zElement,
zElement.GetElementBackgroundColor() != CardMakerConstants.NoColor
? zElement.GetElementBackgroundColor()
: zElement.GetElementColor()));
}
public void ReanimateCard(byte index)
{
CardRenderer newCard = Instantiate(Prefab);
newCard.Index = index;
newCard.rectTransform.position = Discard.transform.position;
AddCardRenderer(newCard);
}
//New style add and remove
public void DrawCard(byte index)
{
CardRenderer newCard = Instantiate(Prefab);
newCard.Index = index;
newCard.rectTransform.position = Deck.position;
AddCardRenderer(newCard);
}
/// <summary>
/// The event cards trigger when the mouse leaves a card
/// </summary>
/// <param name="cr"></param>
public void OnCardMouseLeave(CardRenderer cr)
{
if (highlightedCard == cardsInHand.IndexOf(cr))
{
highlightedCard = -1;
UpdatePositions();
}
}
IEnumerator DamageTakenRoutine(CardRenderer cardRenderer, int damage, EnergyTypes damageType)
{
cardRenderer.SpawnDamageEffect(damageType);
cardRenderer.StartOnDamageTaken(damage);
yield return(new WaitForSeconds(1f));
GameEventHandler.Instance.EventCompleted();
}
protected CardExportBase(int nLayoutStartIndex, int nLayoutEndIndex)
{
ExportLayoutStartIndex = nLayoutStartIndex;
ExportLayoutEndIndex = nLayoutEndIndex;
CardRenderer = new CardRenderer
{
CurrentDeck = new Deck()
};
}
/// <summary>
/// Create a new CardRenderer object and tie it to a card
/// </summary>
/// <param name="forCard"></param>
/// <returns>A CardRenderer component, attached to new card prefab</returns>
public CardRenderer CreateCardRenderer(Card forCard)
{
//construct new card prefab based on the input card
CardRenderer instance = Instantiate(cardPrefab);
instance.TieTo(forCard);
return(instance);
}
private void SelectedOpponentPokemon(CardRenderer cardController)
{
if (cardController.card.Owner.Id.Equals(myId) || !(cardController.card is PokemonCard) || !currentDeckFilters.All(f => f.IsCardValid(cardController.card)))
{
return;
}
ToggleCardSelected(cardController);
}
protected CardExportBase(int nLayoutStartIndex, int nLayoutEndIndex)
{
ExportLayoutStartIndex = nLayoutStartIndex;
ExportLayoutEndIndex = nLayoutEndIndex;
CardRenderer = new CardRenderer
{
CurrentDeck = new Deck()
};
}
public void Clicked(CardRenderer cardRenderer)
{
if (cardRenderer.card.Owner.Id.Equals(GameController.Instance.myId) || !(cardRenderer.card is PokemonCard))
{
return;
}
cardRenderer.SetSelected(true);
selectedCards.Add(cardRenderer);
}
internal void AddCard(CardRenderer card)
{
if (cardRenderers.ContainsKey(card.card.Id))
{
cardRenderers[card.card.Id] = card;
return;
}
cardRenderers.Add(card.card.Id, card);
}
public void SetLayoutForView(CardRenderer cardRenderer)
{
var layoutElement = cardRenderer.GetComponent <LayoutElement>();
layoutElement.preferredHeight = 540;
layoutElement.preferredWidth = 440;
var canvas = cardRenderer.GetComponent <Canvas>();
canvas.sortingOrder = canvas.sortingOrder + 1;
}
private void CreateCardPreview(CardData card, int count)
{
CardRenderer preview = Instantiate(cardPreviewTemplate, previewContainer);
preview.ShowCardData(card);
preview.gameObject.SetActive(true);
Text counttext = preview.transform.Find("CountText")?.GetComponent <Text>();
counttext.text = string.Format("(x{0})", count);
activePreviews.Add(preview);
}
public void OnCardButtonUI(CardRenderer renderer)
{
for (int i = 0; i < currentChoice.Indices.Length; i++)
{
if (currentChoice.Indices[i] == renderer.Index)
{
currentChoice.Facings[i] = !currentChoice.Facings[i];
renderer.RefreshCardImage(currentChoice.Facings[i]);
}
}
}
private void SelectedPlayerBenchedPokemon(CardRenderer cardController)
{
if (!playerBench.GetComponentsInChildren <CardRenderer>().Any(controller => controller.card.Id.Equals(cardController.card.Id)) ||
!(cardController.card is PokemonCard) ||
!currentDeckFilters.All(f => f.IsCardValid(cardController.card)))
{
return;
}
ToggleCardSelected(cardController);
}
private void OnRetreatTargetSelected(CardRenderer clickedCard)
{
if (clickedCard.card.Id.Equals(Player.ActivePokemonCard.Id))
{
return;
}
SpecialState = SpecialGameState.None;
NetworkManager.Instance.gameService.RetreatPokemon(gameField.Id, clickedCard.card.Id, selectedCards.Select(card => card.Id).ToList());
selectedCards.Clear();
EnableButtons();
}
// GameManager event responders
/// <summary>
/// Creates a new <see cref="CardRenderer"/> to match the input card and adds it to the hand.
/// </summary>
/// <remarks>Used to respond to <see cref="GameManager.OnCardDrawn"/></remarks>
/// <param name="card">The card to create a <c>CardRenderer</c> for</param>
public void VisualiseNewCard(Card card)
{
CardRenderer cr = card.tiedTo;
if (card.tiedTo is null)
{
cr = cardFactory.CreateCardRenderer(card);
cr.gameObject.name = "Renderer for " + card.cardData.title;
cr.updateCostColour = true;
}
hand.AddCardToHand(cr);
}
//TODO: make this order correct
/// <summary>
/// Sort the render order of the cards in the hand from back to front, so the highlighted card
/// is at the front
/// </summary>
private void UpdateCardOrder()
{
int cardToUse = (highlightedCard == -1) ? lastHighlightedCard : highlightedCard;
int numberOfCards = cardsInHand.Count;
for (int i = 0; i < numberOfCards; i++)
{
CardRenderer card = cardsInHand[i];
int dist = Math.Abs(cardToUse - i);
card.transform.SetSiblingIndex(numberOfCards - 1 - dist);
}
}
private void ToggleCardSelected(CardRenderer clickedCard)
{
clickedCard.SetSelected(!clickedCard.isSelected);
if (clickedCard.isSelected)
{
selectedCards.Add(clickedCard.card);
}
else
{
selectedCards.Remove(clickedCard.card);
}
}
CardRenderer AddCard()
{
CardRenderer retval = Instantiate(rendererPrefab);
retval.transform.parent = layoutGroup.transform;
allRenderers.Add(retval);
retval.Background.GetComponent <Button>().onClick.AddListener(
delegate
{
OnAnyCardClicked((byte)retval.Index);
});
return(retval);
}
/// <summary>
/// Add a card to hand
/// </summary>
/// <param name="card">The CardRenderer tied to the card to add</param>
public void AddCardToHand(CardRenderer card)
{
if (!cardsInHand.Contains(card))
{
cardsInHand.Add(card);
card.OnClick += OnCardMouseClick;
card.OnMouseEnter += OnCardMouseOver;
card.OnMouseExit += OnCardMouseLeave;
card.transform.SetParent(transform);
card.transform.localScale = Vector3.one * 1.2f; //TODO: found out why this is happening
UpdatePositions();
}
}
/// <summary>
/// Moves the <see cref="CardRenderer"/> that matches this card into the active card location
/// </summary>
/// <remarks>Used to respond to <see cref="GameManager.OnCardSelected"/></remarks>
/// <param name="card">The card that was selected</param>
public void SelectCardFromHand(Card card)
{
CardRenderer cr = card.tiedTo;
hand.RemoveCardFromHand(cr);
cr.transform.SetParent(activeCardLocation);
LeanTween.cancel(cr.gameObject);
LeanTween.rotateZ(cr.gameObject, 0f, 0.2f);
LeanTween.move(cr.gameObject, activeCardLocation.position, 0.2f);
cancelCardButton.gameObject.SetActive(true);
hand.HoldCardsDown = true;
activeCardRenderer = cr;
//PlaySoundGroup(cardTouchNoises); TODO: fix me
}
