private void DrawCard(CardType cardType)
{
GameObject newCard = Instantiate(Card);
CardActions card = newCard.GetComponent <CardActions>();
card.DrawCard(cardType, transform.parent, new Vector3(transform.position.x - 320, transform.position.y));
}
private ChargeBeeApi()
{
Addon = new AddonActions(this);
Address = new AddressActions(this);
Card = new CardActions(this);
Comment = new CommentActions(this);
Coupon = new CouponActions(this);
CouponCode = new CouponCodeActions(this);
CreditNote = new CreditNoteActions(this);
Customer = new CustomerActions(this);
Estimate = new EstimateActions(this);
Event = new EventActions(this);
HostedPage = new HostedPageActions(this);
Invoice = new InvoiceActions(this);
Order = new OrderActions(this);
PaymentSource = new PaymentSourceActions(this);
Plan = new PlanActions(this);
PortalSession = new PortalSessionActions(this);
ResourceMigration = new ResourceMigrationActions(this);
SiteMigrationDetail = new SiteMigrationDetailActions(this);
Subscription = new SubscriptionActions(this);
TimeMachine = new TimeMachineActions(this);
Transaction = new TransactionActions(this);
UnbilledCharge = new UnbilledChargeActions(this);
}
private List <Card> SelectCardsFromTable(ScopaGame game, GameAction action, Card fromHand)
{
List <Card> fromTable = new List <Card>();
if (game.Table.Count > 0)
{
CardActions actions = game.PossibleActions[fromHand];
Console.Out.WriteLine(actions.PossibleTricks.Count + " trick(s) are possible with " + fromHand);
foreach (List <Card> possibleTrick in actions.PossibleTricks)
{
Console.Out.WriteLine("Possible Trick: " + Card.ToString(possibleTrick));
}
if (actions.PossibleTricks.Count == 1)
{
fromTable.AddRange(actions.PossibleTricks[0]);
}
else
{
int index;
Console.Out.WriteLine("Dal tavolo");
while (SelectWhichWithEscape(game.Table.Count, out index))
{
fromTable.Add(game.Table[index]);
// If the trick is valid do not wait for input from the user
if (game.ValidateTrick(fromHand, fromTable))
{
break;
}
}
}
}
return(fromTable);
}
public string TestCardActionsPresent(params string[] cardContent)
{
bool buttonFound = false;
string buttonsNotFound = string.Empty;
string action;
for (int i = 0; i < cardContent.Length; i++)
{
action = cardContent[i];
List <IWebElement> buttons = CardActions.FindElements(GetFindBy(LocatorTypes.CSS, "button"));
foreach (IWebElement Button in buttons)
{
if (Button.Text.Contains(action))
{
buttonFound = true;
break;
}
}
if (!buttonFound)
{
if (buttonsNotFound == null)
{
buttonsNotFound = action;
}
else
{
buttonsNotFound = buttonsNotFound + ":" + action;
}
}
}
return(buttonsNotFound);
}
public bool TestCardContents()
{
this.WaitTilIsVisible();
if (CardHeader.IsDisplayed() && CardTitle.IsDisplayed() && CardSubTitle.IsDisplayed() && CardContent.IsDisplayed() && CardActions.IsDisplayed())
{
return(true);
}
else
{
if (!CardHeader.WaitTilIsVisible())
{
BRLogger.LogInfo("Card Header is not available");
}
if (!CardTitle.WaitTilIsVisible())
{
BRLogger.LogInfo("Card Title is not available");
}
if (!CardSubTitle.WaitTilIsVisible())
{
BRLogger.LogInfo("Card Subtitle is not available");
}
if (!CardContent.WaitTilIsVisible())
{
BRLogger.LogInfo("Card Content is not available");
}
if (!CardActions.WaitTilIsVisible())
{
BRLogger.LogInfo("Card Action/s is not available");
}
return(false);
}
}
// Use this for initialization
new void Start()
{
Size = HandSize;
base.Start();
Destination = Discard.gDiscard;
CardActions.Add((CardData c) => c.ApplyEffects());
}
public override List <Card> SelectTrick(Card card)
{
game.PopulateActions();
CardActions actions = game.PossibleActions[card];
if (!actions.IsThrowable)
{
if (actions.PossibleTricks.Count == 1)
{
return(actions.PossibleTricks[0]);
}
List <Card> selectedTrick = new List <Card>();
int index;
Console.Out.WriteLine("Dal tavolo");
while (SelectWhichWithEscape(game.Table.Count, out index))
{
selectedTrick.Add(game.Table[index]);
// If the trick is valid do not wait for input from the user
if (game.ValidateTrick(card, selectedTrick))
{
break;
}
}
return(selectedTrick);
}
return(new List <Card>());
}
public override void Start()
{
Display = GetComponent <CardDisplay>();
for (int i = 0; i < Size; ++i)
{
Cards.Add(null);
}
CardActions.Add((CardData c) => Move(c));
}
public CardSerializer GetCardSerializer(CardActions requestedAction)
{
CardSerializer card;
do
{
card = cardMessageQueue.Last(c => c.Action == requestedAction);
}
while (card == null);
cardMessageQueue.Remove(card);
return card;
}
public CardActions getSelectableCardActions(CardGameObject cardGameObject, CardUiManager cardUiManager)
{
CardActions actions = new CardActions();
copyOverActions(cardGameObject, actions);
actions.onClickAction = (Card card) =>
{
cardUiManager.destroyCardSelect();
cardUiManager.cardSelect.SetActive(false);
deckService.addCardToDeck(card);
};
return(actions);
}
public CardActions getListCardActions(CardGameObject cardGameObject)
{
CardActions actions = new CardActions();
copyOverActions(cardGameObject, actions);
ScrollRect mainScroll = cardGameObject.transform.GetComponentInParent <ScrollRect>();
actions.onScrollAction = (PointerEventData data) =>
{
mainScroll.OnScroll(data);
};
return(actions);
}
void Awake()
{
cardDefs = new CardActions();
campIcon = Resources.Load <Texture2D>("camp");
waterIcon = Resources.Load <Texture2D>("water");
foodIcon = Resources.Load <Texture2D>("food");
goodStyle = new GUIStyle();
goodStyle.normal.textColor = Color.green;
goodStyle.fontSize = 50;
badStyle = new GUIStyle();
badStyle.normal.textColor = Color.red;
badStyle.fontSize = 50;
}
public virtual void OnAddCardModel(CardStack cardStack, CardModel cardModel)
{
if (cardModel == null)
{
return;
}
CardActions.ShowFaceup(cardModel);
CardActions.ResetRotation(cardModel);
cardModel.DoubleClickAction = CardActions.FlipFace;
cardModel.SecondaryDragAction = null;
UpdateCountText();
}
public CardCollection(Player player, Enemy enemy)
{
this.Player = player;
this.Enemy = enemy;
CurrentCardActions = new CardActions();
allCards = new Dictionary <string, Card>
{
{ "Strike", new Card(CardTypes.Offence, new List <Action> {
new Action(() => CurrentCardActions.Attack(Enemy, Player, 7))
}) },
{ "Shield & Bash", new Card(CardTypes.Offence, new List <Action> {
new Action(() => CurrentCardActions.Attack(Enemy, Player, 5)),
new Action(() => CurrentCardActions.Defend(Player, 3))
}, 2) },
{ "Strengthen", new Card(CardTypes.Skill, new List <Action> {
new Action(() => CurrentCardActions.AddStrength(Player, 2))
}) },
{ "Defend", new Card(CardTypes.Defence, new List <Action> {
new Action(() => CurrentCardActions.Defend(Player, 5))
}) },
{ "Heal", new Card(CardTypes.Skill, new List <Action> {
new Action(() => CurrentCardActions.Heal(Player, 3))
}) },
{ "Energize", new Card(CardTypes.Skill, new List <Action> {
new Action(() => CurrentCardActions.AddEnergy(Player, 0))
}, 0) },
{ "Life Drain", new Card(CardTypes.Offence, new List <Action> {
new Action(() => CurrentCardActions.Attack(Enemy, Player, 5)),
new Action(() => CurrentCardActions.Heal(Player, 5 + Player.StrengthPoints - Enemy.ShieldPoints))
}, 2) },
{ "Draw a card", new Card(CardTypes.Skill, new List <Action> {
new Action(() => CurrentCardActions.DrawCards(Player.UndeltDeck, Player.CurrentHand, 1))
}, 0) },
{ "Puncture", new Card(CardTypes.Offence, new List <Action> {
new Action(() => CurrentCardActions.Attack(Enemy, Player, 3))
}, 0) },
{ "Barrier", new Card(CardTypes.Defence, new List <Action> {
new Action(() => CurrentCardActions.ActivateShield(Player))
}, 3) },
{ "Mirror", new Card(CardTypes.Skill, new List <Action> {
new Action(() => CurrentCardActions.ActivateMirror(Player))
}, 3) },
{ "Sale", new Card(CardTypes.Skill, new List <Action> {
new Action(() => CurrentCardActions.ReduceCost(Player))
}) }
};
}
public void RunF()
{
string cardNameUI = Console.ReadLine();
// access child method at runtime based on user input
CardActions ccaction = cardNameUI switch
{
"titanium" => new TitaniumCardAction(5000),
"platinum" => new PlatinumCardAction(500, 10000),
_ => throw new NotImplementedException()
};
CreditCard creditCardUsed = ccaction.GetCreditCard();
Console.WriteLine($"Your card: {cardNameUI} details below:\n cardType: {creditCardUsed.CardType}, cardAnualCharge: {creditCardUsed.AnnualCharge}");
}
}
public LineCardTemplateResponseModel SetCardMessage(string messageDetail)
{
LineCardTemplateResponseModel message = new LineCardTemplateResponseModel();
CardActions ac = new CardActions();
CardDefaultAction da = new CardDefaultAction();
List <ButtonCardTemplate> btncard = new List <ButtonCardTemplate>();
ButtonCardTemplate subbtnCard = new ButtonCardTemplate();
CardTemplate card = new CardTemplate();
CardDefaultAction defaultCard = new CardDefaultAction();
subbtnCard.type = "template";
subbtnCard.altText = "This is a buttons template";
card.type = "buttons";
card.thumbnailImageUrl = "https://www.nextcapital.co.th/uploads/06F1/files/931961622604595acdf027417a2912ba.jpg";
card.imageAspecRatio = "rectangle";
card.imageSize = "cover";
card.imageBackgroundColor = "#FFFFFF";
card.title = "Menu";
card.text = "Please select";
defaultCard.type = "uri";
defaultCard.label = "View detail";
defaultCard.uri = "https://developers.line.biz";
card.defaultAction = defaultCard;
ac.type = "postback";
ac.label = "Buy";
ac.data = "test";
card.actions.Add(ac);
da.type = "uri";
da.label = "View detail";
da.uri = "https://line.me";
card.actions.Add(da);
subbtnCard.template = card;
btncard.Add(subbtnCard);
message.messages = btncard;
return(message);
}
public Enemy getSecondEnemy()
{
EnemyTurnData enemyTurnData = new EnemyTurnData();
CardData attackCardData = new CardData();
CardActions attackCardActions = new CardActions();
attackCardData.attack = 3;
attackCardData.isEnemycard = true;
attackCardData.description = "Add " + attackCardData.attack + " to enemies attack";
CardData multiplierCardData = new CardData();
CardActions multiplierCardActions = new CardActions();
multiplierCardData.attackMultiplier = 2;
multiplierCardData.isEnemycard = true;
multiplierCardData.description = "Repeat enemy attack " + (multiplierCardData.attackMultiplier - 1) + " times";
Card attackTurn1 = addCardToDeckTurn(new Card(attackCardData, attackCardActions));
attackTurn1.data.attack = 3;
Card attackTurn2 = addCardToDeckTurn(new Card(attackCardData, attackCardActions));
attackTurn2.data.attack = 3;
Card multiplierTurn = addCardToDeckTurn(new Card(multiplierCardData, multiplierCardActions));
multiplierTurn.data.attack = 3;
enemyTurnData.baseEnemyTurns.Add(attackTurn1);
enemyTurnData.baseEnemyTurns.Add(attackTurn2);
enemyTurnData.baseEnemyTurns.Add(multiplierTurn);
EnemyActions enemyActions = new EnemyActions();
//basicEnemy.animatorController = Resources.Load<RuntimeAnimatorController>(spritePath + "MaskManController");
EnemyData data = new EnemyData(new HealthBarData(55), enemyTurnData);
Enemy enemy = new Enemy(data, enemyActions);
return(enemy);
}
public bool CardActionClick(string buttonName)
{
bool buttonFound = false;
CardActions.WaitTilDoneLoading();
foreach (BRButton Button in CardActions.FindElements(GetFindBy(LocatorTypes.CSS, "button")))
{
if (Button.Text().Contains(buttonName))
{
Button.WaitTilIsClickable();
Button.Click();
buttonFound = true;
break;
}
}
if (buttonFound)
{
return(true);
}
else
{
return(false);
}
}
public void ExecuteAction(Guid playerId, CardActions action, Dictionary <string, object> parameters)
{
this._actions[action](playerId, parameters);
}
public Card getCardFromEnum(CardEnum cardEnum)
{
Card card = new Card(cardEnum);
CardData data = new CardData();
CardActions actions = new CardActions();
if (cardEnum == CardEnum.smack)
{
data.attack = 5;
data.playerCardData.needsTarget = true;
data.playerCardData.memoryCount = 1;
data.playerCardData.energyCost = 1;
actions.getDescriptionAction = () =>
{
return("Deal " + actions.getDamageAmount(card) + " damage.");
};
data.description = actions.getModifiedDescription(data);
data.name = "smack";
}
else if (cardEnum == CardEnum.defend)
{
data.defend = 5;
data.playerCardData.memoryCount = 1;
data.playerCardData.energyCost = 1;
actions.getDescriptionAction = () =>
{
return("Gain " + actions.getBlockAmount(card) + " block.");
};
data.description = actions.getModifiedDescription(data);
data.name = "defend";
}
else if (cardEnum == CardEnum.haymaker)
{
data.attack = 13;
data.playerCardData.energyCost = 1;
data.playerCardData.needsTarget = true;
data.name = "haymaker";
actions.getDescriptionAction = () =>
{
return("Deal " + actions.getDamageAmount(card) + " damage.");
};
data.description = actions.getModifiedDescription(data);
}
else if (cardEnum == CardEnum.turtle)
{
data.defend = 13;
data.playerCardData.energyCost = 2;
data.name = "turtle";
actions.getDescriptionAction = () =>
{
return("Gain " + actions.getBlockAmount(card) + " block.");
};
data.description = actions.getModifiedDescription(data);
}
else if (cardEnum == CardEnum.search)
{
data.cardsToDraw = 2;
data.description = "Draw " + data.cardsToDraw + " cards.";
data.name = "search";
}
else if (cardEnum == CardEnum.swordAndShield)
{
data.attack = 7;
data.defend = 4;
data.playerCardData.energyCost = 1;
data.playerCardData.needsTarget = true;
actions.getDescriptionAction = () =>
{
return("Gain " + actions.getBlockAmount(card) + " block" +
"\n" + "and deal " + actions.getDamageAmount(card) + " damage.");
};
data.description = actions.getModifiedDescription(data);
data.name = "swordNshield";
}
else if (cardEnum == CardEnum.firstStrike)
{
data.attack = 14;
data.playerCardData.energyCost = 1;
data.playerCardData.needsTarget = true;
data.playerCardData.firstCardPlayed = true;
actions.getDescriptionAction = () =>
{
return("Must be played first." + "\n" + "Deal " + actions.getDamageAmount(card) + " damage.");
};
data.description = actions.getModifiedDescription(data);
data.name = "first strike";
}
else if (cardEnum == CardEnum.sweep)
{
data.attack = 7;
data.playerCardData.energyCost = 1;
data.playerCardData.hitsAll = true;
actions.getDescriptionAction = () =>
{
return("Deal " + actions.getDamageAmount(card) + " damage to all enemies.");
};
data.description = actions.getModifiedDescription(data);
data.name = "sweep";
}
else if (cardEnum == CardEnum.followUp)
{
data.attack = 9;
data.cardsToDraw = 1;
data.playerCardData.energyCost = 1;
data.playerCardData.needsTarget = true;
actions.getDescriptionAction = () =>
{
return("Deal " + actions.getDamageAmount(card) + " damage and draw " + data.cardsToDraw + " card.");
};
data.description = actions.getModifiedDescription(data);
data.name = "follow up";
}
else if (cardEnum == CardEnum.deflect)
{
data.cardsToDraw = 1;
data.defend = 8;
data.playerCardData.energyCost = 1;
actions.getDescriptionAction = () =>
{
return("Gain " + actions.getBlockAmount(card) + " block and draw " + data.cardsToDraw + " card.");
};
data.description = actions.getModifiedDescription(data);
data.name = "deflect";
}
else if (cardEnum == CardEnum.doubleSmack)
{
data.attack = 4;
data.attackMultiplier = 2;
data.playerCardData.energyCost = 1;
data.playerCardData.needsTarget = true;
actions.getDescriptionAction = () =>
{
return("Deal " + actions.getDamageAmount(card) + " damage " + data.attackMultiplier + " times.");
};
data.description = actions.getModifiedDescription(data);
data.name = "double smack";
}
else if (cardEnum == CardEnum.threaten)
{
data.playerCardData.needsTarget = true;
data.playerCardData.energyCost = 1;
Status vulnerable = statusTypes.getStatusFromEnum(StatusTypes.StatusEnum.vulnerable);
data.statuses.Add(vulnerable);
Status weak = statusTypes.getStatusFromEnum(StatusTypes.StatusEnum.weak);
data.statuses.Add(weak);
actions.getDescriptionAction = () =>
{
return("Apply " + vulnerable.data.statusCount + " vulnerable and " + weak.data.statusCount + " weak.");
};
data.description = actions.getModifiedDescription(data);
data.name = "threaten";
}
else if (cardEnum == CardEnum.terrorize)
{
data.playerCardData.hitsAll = true;
data.exhaust = true;
data.playerCardData.energyCost = 2;
Status vulnerable = statusTypes.getStatusFromEnum(StatusTypes.StatusEnum.vulnerable);
vulnerable.data.statusCount = 2;
data.statuses.Add(vulnerable);
Status weak = statusTypes.getStatusFromEnum(StatusTypes.StatusEnum.weak);
weak.data.statusCount = 2;
data.statuses.Add(weak);
actions.getDescriptionAction = () =>
{
return("Apply " + vulnerable.data.statusCount + " vulnerable and " + weak.data.statusCount + " weak to all enemies. Exhaust.");
};
data.description = actions.getModifiedDescription(data);
data.name = "terrorize";
}
else if (cardEnum == CardEnum.fortify)
{
Status armor = statusTypes.getStatusFromEnum(StatusTypes.StatusEnum.armor);
armor.data.statusDeltaPerTurn = 0;
armor.data.statusCount = 4;
data.playerCardData.statuses.Add(armor);
data.exhaust = true;
data.playerCardData.energyCost = 1;
actions.getDescriptionAction = () =>
{
return(armor.actions.getModifiedDescription(armor.data, null, null) + "\n" + "Removed.");
};
data.description = actions.getModifiedDescription(data);
data.name = "fortify";
}
else if (cardEnum == CardEnum.sword)
{
data.attack = 5;
data.playerCardData.needsTarget = true;
actions.getDescriptionAction = () =>
{
return("Deal " + actions.getDamageAmount(card) + " damage.");
};
data.description = actions.getModifiedDescription(data);
data.name = "sword";
}
else if (cardEnum == CardEnum.shield)
{
data.defend = 3;
actions.getDescriptionAction = () =>
{
return("Gain " + actions.getBlockAmount(card) + " block.");
};
data.description = actions.getModifiedDescription(data);
data.name = "shield";
}
else if (cardEnum == CardEnum.shatter)
{
data.attack = 12;
data.exhaust = true;
data.playerCardData.energyCost = 1;
data.playerCardData.hitsAll = true;
actions.getDescriptionAction = () =>
{
return("Deal " + actions.getDamageAmount(card) + " damage to all enemies. Exhaust.");
};
data.description = actions.getModifiedDescription(data);
data.name = "shatter";
}
else if (cardEnum == CardEnum.hiddenDaggers)
{
data.attack = 8;
data.playerCardData.energyCost = 1;
data.playerCardData.needsTarget = true;
actions.getDescriptionAction = () =>
{
return("Deal " + actions.getDamageAmount(card) + " damage and add one dagger to your hand.");
};
actions.onCardPlayedAction = () =>
{
Card newDagger = getCardFromEnum(CardEnum.dagger);
GameData.getInstance().deckService.addCardToHand(newDagger);
GameData.getInstance().deckService.deckData.cardsToRemoveAfterFight.Add(newDagger);
};
data.description = actions.getModifiedDescription(data);
data.name = "hiddenDaggers";
}
else if (cardEnum == CardEnum.dagger)
{
data.attack = 3;
data.playerCardData.needsTarget = true;
actions.getDescriptionAction = () =>
{
return("Deal " + actions.getDamageAmount(card) + " damage.");
};
data.description = actions.getModifiedDescription(data);
data.name = "dagger";
}
else if (cardEnum == CardEnum.reload)
{
data.exhaust = true;
data.playerCardData.needsTarget = false;
actions.getDescriptionAction = () =>
{
return("Move all dagger cards from discard pile to your hand. Exhaust.");
};
actions.onCardPlayedAction = () =>
{
List <Card> daggerCards = new List <Card>();
foreach (Card discardCard in GameData.getInstance().deckData.discardCards)
{
if (discardCard.cardEnum == CardEnum.dagger)
{
daggerCards.Add(discardCard);
}
}
foreach (Card daggerCard in daggerCards)
{
GameData.getInstance().deckService.addCardToHand(daggerCard);
GameData.getInstance().deckService.deckData.discardCards.Remove(daggerCard);
}
};
data.description = actions.getModifiedDescription(data);
data.name = "reload";
}
else
{
throw new System.Exception("invalid status enum provided: " + cardEnum);
}
card.data = data;
card.actions = actions;
return(card);
}
private void copyOverActions(CardGameObject cardGameObject, CardActions cardActions)
{
cardActions.getDescriptionAction = cardGameObject.card.actions.getDescriptionAction;
cardActions.onCardDrawnAction = cardGameObject.card.actions.onCardDrawnAction;
cardActions.onCardPlayedAction = cardGameObject.card.actions.onCardPlayedAction;
}
public CardActions getCardInHandActions(CardGameObject cardGameObject)
{
CardActions actions = new CardActions();
copyOverActions(cardGameObject, actions);
Card card = cardGameObject.card;
CardData data = card.data;
Transform transform = cardGameObject.transform;
bool isDragging = false;
bool isHovering = false;
Vector3 startPosition = new Vector3(0, 0);
GameObject backgroundImage = cardGameObject.transform.Find("cardBackground").gameObject;
int yPositionForCardPlay = -250;
actions.onDragStartAction = () =>
{
card.data.targetedEnemy = null;
if (startPosition == null)
{
startPosition = cardGameObject.transform.position;
}
if (!(deckService.isCardPlayable(cardGameObject.card) && playerService.isCardPlayable(cardGameObject.card)))
{
backgroundImage.GetComponent <Image>().color = ColorUtils.cardUnplayable;
return;
}
isDragging = true;
};
actions.onDragEndAction = () =>
{
isDragging = false;
EnemyGameObject target = card.data.targetedEnemy;
if (data.playerCardData.needsTarget && transform.position.y >= yPositionForCardPlay && target != null)
{
cardService.onCardPlayed(card);
target.onNotTargeted();
card.data.targetedEnemy = null;
GameObject.Destroy(cardGameObject.gameObject);
}
else if (!data.playerCardData.needsTarget && transform.position.y >= yPositionForCardPlay)
{
cardService.onCardPlayed(card);
GameObject.Destroy(cardGameObject.gameObject);
}
else
{
if (target != null)
{
target.onNotTargeted();
card.data.targetedEnemy = null;
}
backgroundImage.GetComponent <Image>().color = ColorUtils.none;
if (transform.position != startPosition)
{
transform.localScale -= new Vector3(0.4f, 0.4f, 0);
transform.position = startPosition;
}
}
};
actions.onUpdateAction = () =>
{
if (!isDragging || data.isEnemycard)
{
return;
}
EnemyGameObject target = card.data.targetedEnemy;
if (transform.position.y >= yPositionForCardPlay && (!data.playerCardData.needsTarget || data.playerCardData.needsTarget && target != null))
{
backgroundImage.GetComponent <Image>().color = ColorUtils.cardPlayedGreen;
if (target != null)
{
target.onTargeted();
}
}
else
{
backgroundImage.GetComponent <Image>().color = ColorUtils.white;
if (target != null)
{
target.onNotTargeted();
}
}
RectTransform playerHandTransform = transform.parent.GetComponent <RectTransform>();
transform.localPosition = new Vector2(Input.mousePosition.x - Screen.width / 2, Input.mousePosition.y - playerHandTransform.rect.height / 2);
};
actions.onTriggerEnter2DAction = (Collider2D other) =>
{
if (data.playerCardData.needsTarget)
{
EnemyGameObject curr = other.transform.gameObject.GetComponent <EnemyGameObject>();
if (curr != null)
{
card.data.targetedEnemy = curr;
curr.onTargeted();
}
}
};
actions.onTriggerExit2DAction = (Collider2D other) =>
{
EnemyGameObject target = card.data.targetedEnemy;
if (target != null)
{
target.onNotTargeted();
}
card.data.targetedEnemy = null;
};
actions.onHoverEnter = () =>
{
if (isHovering)
{
return;
}
startPosition = transform.position;
transform.position += new Vector3(0, 140, 0);
transform.localScale += new Vector3(0.4f, 0.4f, 0);
cardGameObject.GetComponent <Canvas>().overrideSorting = true;
cardGameObject.GetComponent <Canvas>().sortingOrder = 10;
cardGameObject.GetComponent <Canvas>().sortingLayerName = "UI";
isHovering = true;
};
actions.onHoverExit = () =>
{
if (transform.position != startPosition)
{
transform.position -= new Vector3(0, 140, 0);
transform.localScale -= new Vector3(0.4f, 0.4f, 0);
}
cardGameObject.GetComponent <Canvas>().overrideSorting = false;
isHovering = false;
};
return(actions);
}
public Card(CardData data, CardActions actions)
{
this.actions = actions;
this.data = data;
}
public CardSerializer(string targetCard, CardActions action)
{
this.TargetCard = targetCard;
this.Action = action;
}
public Card(CardTypes.CardEnum cardEnum)
{
this.cardEnum = cardEnum;
this.actions = new CardActions();
this.data = new CardData();
}
void Awake()
{
cardDefs = new CardActions();
campIcon = Resources.Load<Texture2D>("camp");
waterIcon = Resources.Load<Texture2D>("water");
foodIcon = Resources.Load<Texture2D>("food");
goodStyle = new GUIStyle();
goodStyle.normal.textColor = Color.green;
goodStyle.fontSize = 50;
badStyle = new GUIStyle();
badStyle.normal.textColor = Color.red;
badStyle.fontSize = 50;
}
