public override void UpdateValuesUI(bool first = false, Transform[][] lines = null)
{
base.UpdateValuesUI(first, new Transform[][] { UICard.submissionValues.lines, UICard.submissionBigValues.lines });
UICard.SetAttackValue("staminaReduction", GetEffect.stamina, false);
UICard.SetAttackValue("breakCost", GetEffect.breakCost, false);
}
public void OnCardClick(UICard card, EntitiesDatabaseSO.EntityData cardData)
{
//We should check if we have the money!
if (PlayerData.Instance.CanAfford(cardData.cost))
{
if (cardData.name.Equals("Avatar"))
{
}
//We should check if we can actually place that card, some cards have requirements other than cost.
if (!GameManager.Instance.checkTreeRequirement(cardData.treeRequirement))
{
Debug.Log("You need at least " + cardData.treeRequirement + " trees conquered!");
return;
}
//check if we have builders
if (cardData.isBuilding)
{
if (!GameManager.Instance.CheckBuilders(GameManager.Instance.myTeam))
{
Debug.Log("You need at least 1 builder in your board!");
return;
}
}
PlayerData.Instance.SpendMoney(cardData.cost);
//card.gameObject.SetActive(false);
GameManager.Instance.OnEntityBought(cardData);
}
}
public void ClearCard()
{
RemoveCardListeners();
if (headerLabel != null)
{
headerLabel.text = "";
}
if (closeButton != null)
{
closeButton.gameObject.SetActive(false);
}
if (validateButton != null)
{
validateButton.gameObject.SetActive(false);
}
Transform[] fieldRootChildren = fieldInstancesRoot.GetComponentsInChildren <Transform>(true);
for (int i = 0, iend = fieldRootChildren.Length; i < iend; i++)
{
Transform child = fieldRootChildren[i];
if (child != null && child != fieldInstancesRoot)
{
DestroyImmediate(child.gameObject);
}
}
fieldInstancesRoot.sizeDelta = new Vector2(fieldInstancesRoot.sizeDelta.x, 0f);
if (fieldInstances != null)
{
fieldInstances.Clear();
}
CurrentCard = null;
currentDataType = "(null)";
onCardChange.Invoke();
}
void HandleInput(Vector3 tapPosition)
{
Ray ray = Camera.main.ScreenPointToRay(tapPosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit))
{
if (player.activeCard != null)
{
player.activeCardScript.HandleTap(Camera.main.ScreenToWorldPoint(tapPosition));
}
else
{
switch (hit.transform.tag)
{
case "CARD":
if ((player.activeCard == null && hit.transform.position.y < player.splitter.transform.position.y))
{
player.splitter.gameObject.SetActive(true);
player.activeCard = hit.transform;
UICard cardScript = hit.transform.GetComponent <UICard>();
player.activeCardScript = cardScript;
cardScript.HandleTap(Camera.main.ScreenToWorldPoint(tapPosition));
}
break;
}
}
}
}
private void OnCloseCard(UICard card)
{
if (card == CurrentCard)
{
ClearCard();
}
}
public void OnCardPressed(UICard cardUi)
{
if (selectedCardUi != null)
{
selectedCardUi.UnHighlight();
}
selectedCardUi = cardUi;
cardUi.Highlight();
timerSpeedMod = GameSettings.Instance.CardSelectTimerSpeedUpModifier;
AudioManager.PlaySFX("ui-select");
/*Card lowestCard = null;
* float lowestScore = float.MaxValue;
*
* // Get the lowest card score to add to the dictators score.
* for (int i = 0; i < cardUis.Length; i++)
* {
* if (cardUis[i].cardIndex != cardUi.cardIndex)
* {
* Card card = currentCards[cardUis[i].cardIndex];
* if (card.value < lowestScore)
* {
* lowestScore = card.value;
* lowestCard = card;
* }
* }
* }
* Debug.Log("Update dictator " + lowestCard.idealType.ToString() + " " + lowestCard.value);
* dictator.Ideals.AddToIdealValue(lowestCard.idealType, lowestCard.value);*/
}
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();
}
private static UICardDesk NewDatabaseDesk(Database database, out UICard dataBaseCard)
{
UICardPile[] cardPiles = new UICardPile[] { new UICardPile(), new UICardPile() };
dataBaseCard = UICard.NewCard(typeof(Database), false, false, database);
cardPiles[0].PileCard(dataBaseCard);
return(new UICardDesk(cardPiles));
}
private void OnEndEditCard(UICard card)
{
if (card == null || card != CurrentCard)
{
return;
}
}
public void ArrayHandCards(byte[] cards, byte count)
{
//计算间距
int nColSpace = CardColSpace;
if (gameObject.activeSelf == false)
{
gameObject.SetActive(true);
}
foreach (GameObject obj in _cardlist)
{
UICard car = obj.GetComponent <UICard>();
int nIdx = GetCardIndex(cards, count, car.CardData);
if (nIdx != -1)
{
float zValue = ((float)nIdx) / 100 + 1;
obj.transform.localScale = new Vector3(1, 1, zValue);
int nRow = (int)(nIdx / RowMaxCards);
int nCol = (int)(nIdx % RowMaxCards);
Vector3 NewPos = new Vector3(nColSpace * nCol, CardRowSpace * nRow * (-1), 0);
TweenPosition.Begin(obj, 0.6f, NewPos);
car.SetPos(NewPos);
car.recvclick = true;
obj.name = "card_" + nIdx.ToString();
UISlicedSprite sp = obj.GetComponentInChildren <UISlicedSprite>();
sp.depth = BaseDepth + nIdx;
}
}
}
private void OnEndEditCalulatorInputCard(UICardDesk desk, UICardPile pile, UICard card)
{
if (card != null && card == calculatorInputCard)
{
RefreshCalculator();
}
}
public void PileCard(UICard card)
{
if (card == null)
{
return;
}
if (cards == null)
{
cards = new List <UICard> {
card
};
AddCardListeners(card);
}
else
{
int indexInPile = cards.IndexOf(card);
if (indexInPile == -1)
{
cards.Add(card);
AddCardListeners(card);
}
else
{
cards.RemoveAt(indexInPile);
cards.Add(card);
}
}
if (onDealCard != null)
{
onDealCard?.Invoke(this, card);
}
}
public void DrawAssets()
{
foreach (GameObject go in AssetObjects)
{
Destroy(go);
}
AssetObjects.Clear();
float space = (StorageEnd.position.x - StorageStart.position.x) / 5.0f;
int i = 0;
foreach (Card card in GameLogicManager.Instance.PlayerAssets.Skip(CurrentAssetIndex).Take(6))
{
if (card == null)
{
++i;
continue;
}
GameObject go = GameObject.Instantiate(AssetPrefab, StorageStart.position + Vector3.right * space * i, Quaternion.identity, transform);
AssetObjects.Add(go);
UICard uiCard = go.GetComponent <UICard>();
uiCard.CardData = card;
uiCard.UpdateCardData();
uiCard.IsInAssets = true;
++i;
}
}
public void DrawRiver()
{
foreach (GameObject go in RiverObjects)
{
Destroy(go);
}
RiverObjects.Clear();
float space = (RiverEnd.position.x - RiverStart.position.x) / 6.0f;
int i = 0;
List <Card> cardsInBottomRow = IsRiverShown ? GameLogicManager.Instance.PlayerRiver : GameLogicManager.Instance.PlayerObjectives;
foreach (Card card in cardsInBottomRow)
{
if (card == null)
{
++i;
continue;
}
GameObject go = GameObject.Instantiate(CardPrefab, RiverStart.position + Vector3.right * space * i, Quaternion.identity, transform);
RiverObjects.Add(go);
UICard uiCard = go.GetComponent <UICard>();
uiCard.CardData = card;
uiCard.UpdateCardData();
++i;
}
if (IsRiverShown)
{
Vector3 linePos = Line.transform.position;
linePos.x = 3 * Mathf.Max(GameLogicManager.Instance.PlayerResources.RiverSize - 3, 0);
Line.transform.position = linePos;
}
Line.SetActive(IsRiverShown);
}
public void ResetAllShoot()
{
foreach (GameObject obj in _cardlist)
{
UICard card = obj.GetComponent <UICard>();
card.SetShoot(false);
}
}
//选择和取消选择UI卡牌
void SelectCard(UICard uiCard)
{
uiCard.Select(selectedUICards.Count + 1);
selectedUICards.Add(uiCard);
button_EndTurn.GetComponentInChildren <Text>().text = "打出手牌";
}
private void OnDealCard(UICardPile pile, UICard card)
{
if (pile == null || card == null || pile != CurrentPile)
{
return;
}
BuildBottomCard();
BuildTopCard();
}
private void OnBuildCard(UICard ui, Card card)
{
ui.SetCard(card);
if (onPlayCard != null)
{
ui.SetAction(onPlayCard);
}
}
private static UICardDesk NewCalculatorDesk(out UICard inputCard, out UICard outputCard)
{
UICardPile[] cardPiles = new UICardPile[] { new UICardPile(), new UICardPile() };
inputCard = UICard.NewCard(typeof(CalculatorInput), false, false);
cardPiles[0].PileCard(inputCard);
outputCard = UICard.NewCard(typeof(CalculatorOutput), true, false);
cardPiles[1].PileCard(outputCard);
return(new UICardDesk(cardPiles));
}
public void Init(CardType newType, int newNumber, UICard cardEditing)
{
type = newType;
number = newNumber;
textNumber.text = number.ToString();
ShowType();
Recalcul();
_currentCard = cardEditing;
}
public void RemoveCard(UICard card)
{
if (card == null || cards == null)
{
return;
}
RemoveCardListeners(card);
cards.Remove(card);
onDealCard?.Invoke(this, card);
}
private void OnEndEditDatabaseCard(UICardDesk desk, UICardPile pile, UICard card)
{
if (card != null && card == databaseCard)
{
Database editedData = databaseCard.Data as Database;
DatapackSerializer.Serialize(editedData, databaseSavePath);
databaseCard.Data = editedData;
//onSaveDatabase?.Invoke((Database)card.Data);
}
}
public override void UpdateValuesUI (bool first = false, Transform[][] lines = null) {
base.UpdateValuesUI (first, new Transform[][] { UICard.offensiveMoveValues.lines, UICard.offensiveMoveBigValues.lines });
UICard.SetAttackValue ("healthCost", GetCost.health, true);
UICard.SetAttackValue ("staminaDamage", GetEffect.stamina, false);
UICard.SetAttackValue ("healthDamage", GetEffect.health, true);
}
public void OnCardClick(UICard card, EntitiesDatabaseSO.EntityData cardData)
{
//We should check if we have the money!
if (PlayerData.Instance.CanAfford(cardData.cost))
{
PlayerData.Instance.SpendMoney(cardData.cost);
card.gameObject.SetActive(false);
GameManager.Instance.OnEntityBought(cardData);
}
}
void Drag()
{
if (UICard.draggedCard == null)
{
isDragging = true;
UICard.draggedCard = this;
isMoving = false;
// hand.SendMessage("Hide");
}
}
public void GetShootCard(ref byte[] cards, ref byte count)
{
foreach (GameObject obj in _cardlist)
{
UICard card = obj.GetComponent <UICard>();
if (card.Selected)
{
cards[count++] = card.CardData;
}
}
}
static public UICard GetInstance()
{
UICard self = UIManager.Singleton.GetUIWithoutLoad <UICard>();
if (self != null)
{
return(self);
}
self = UIManager.Singleton.LoadUI <UICard>("UI/UICard", UIManager.Anchor.Center);
return(self);
}
public void RemoveCard(CardStruct card)
{
UICard uicard = _cardsList.Find(a => a.UID == card.UID);
if (uicard != null)
{
_cardsList.Remove(uicard);
Destroy(uicard.gameObject);
_grid.enabled = true;
}
}
public void River(int cardIndex)
{
UICard card = cardManager.GetCards(cardIndex);
card.transform.SetParent(tableParent);
card.gameObject.SetActive(true);
card.transform.localScale = new Vector3(SCALE, SCALE, SCALE);
card.transform.localPosition = new Vector3(XPOSITIONS[4], YPOSITION);
card.SetFace(true);
cards[4] = card;
}
// Use this for initialization
void Start()
{
if (_lastUICard == null)
{
GameObject go = GameObject.Instantiate(ResUICard) as GameObject;
go.SetActive(true);
go.transform.parent = _container_cards.transform;
go.transform.localScale = Vector3.one;
_lastUICard = go.GetComponent <UICard>();
}
}
public void Update(Input.InputState inputState, Rectangle screenSize)
{
// for now, let's refresh the state every frame
NewGameState();
LayOutArea(viewingPlayer.Hand, new Rectangle(100, screenSize.Height - 100, screenSize.Width - 200, 100), handCardSize, 0);
int battlefieldHeight = (screenSize.Height - 130) / 2;
LayOutBattlefield(new Rectangle(10, battlefieldHeight, screenSize.Width-20, battlefieldHeight), viewingPlayer.Battlefield, false);
Player opponent = GetOpponent();
if(opponent != null)
{
LayOutBattlefield(new Rectangle(10, 0, screenSize.Width-20, battlefieldHeight), opponent.Battlefield, true);
}
Vector2 mousePos = inputState.MousePos;
if (hoveredCard != null)
{
if (!hoveredCard.Contains(mousePos))
hoveredCard = null;
}
bool hoveredCardMissing = (hoveredCard != null);
foreach (UICard c in gameStateRepresentation.Values)
{
if (c == hoveredCard)
hoveredCardMissing = false;
else if (hoveredCard == null && c.Contains(mousePos))
hoveredCard = c;
c.Update(hoveredCard == c);
}
if (hoveredCardMissing)
hoveredCard = null;
if (hoveredCard != null && inputState.WasMouseLeftJustPressed())
{
if (hoveredCard.card is HandCardReference)
{
viewingPlayer.Play((HandCardReference)hoveredCard.card);
}
else if (hoveredCard.card is BattlefieldCardReference)
{
bool activatedAnAbility = false;
foreach(AbilityInstance a in hoveredCard.card.Abilities)
{
if(a.ability is ActivatedAbility)
{
((ActivatedAbility)a.ability).Activate((BattlefieldCardReference)hoveredCard.card);
activatedAnAbility = true;
break;
}
}
if(!activatedAnAbility && hoveredCard.card.IsCreature && viewingPlayer.game.currentPhase == Phase.Attack)
{
BattlefieldCardReference battlefieldCard = (BattlefieldCardReference)hoveredCard.card;
if (viewingPlayer.IsAttacking(battlefieldCard))
{
viewingPlayer.WithdrawAttacker(battlefieldCard);
}
else
{
viewingPlayer.DeclareAttacker(battlefieldCard, GetOpponent());
}
}
// BattlefieldCardReference cardRef = ((BattlefieldCardReference)hoveredCard.card);
// cardRef.isTapped = !cardRef.isTapped;
}
}
foreach(UIButton button in buttons)
{
button.Update(inputState);
}
}
