public virtual CardPower GetPowerByDirection(CardDirection _targetDirection)
{
CardPower resultPower = CardPower.Zero;
switch (_targetDirection)
{
case CardDirection.Up:
resultPower = PowerUp;
break;
case CardDirection.Down:
resultPower = PowerDown;
break;
case CardDirection.Left:
resultPower = PowerLeft;
break;
case CardDirection.Right:
resultPower = PowerRight;
break;
}
return(resultPower);
}
private CardDirection GetOppositeDirection(CardDirection _targetDirection)
{
CardDirection _oppositeDirection = default;
switch (_targetDirection)
{
case CardDirection.Up:
_oppositeDirection = CardDirection.Down;
break;
case CardDirection.Down:
_oppositeDirection = CardDirection.Up;
break;
case CardDirection.Left:
_oppositeDirection = CardDirection.Right;
break;
case CardDirection.Right:
_oppositeDirection = CardDirection.Left;
break;
}
return(_oppositeDirection);
}
/// <summary>
/// Turns on/off the extra card indicators at the side of the screen, whenever a new card becomes centered
/// </summary>
/// <param name="direction"></param>
public void SetCardDirectionIndicators(CardDirection direction)
{
switch (direction)
{
case CardDirection.NO_CARDS:
MoreCardsLeft.SetActive(false);
MoreCardsRight.SetActive(false);
break;
case CardDirection.CARDS_LEFT:
MoreCardsLeft.SetActive(true);
MoreCardsRight.SetActive(false);
break;
case CardDirection.CARDS_RIGHT:
MoreCardsLeft.SetActive(false);
MoreCardsRight.SetActive(true);
break;
case CardDirection.CARDS_BOTH:
MoreCardsLeft.SetActive(true);
MoreCardsRight.SetActive(true);
break;
default:
Debug.LogError("Unrecognized card direction value " + direction);
break;
}
}
public TarotCard(string name, string engName, string keyword, CardDirection direction, Vector3 position)
{
Name = name;
EnglishName = engName;
Direction = direction;
Position = position;
Keyword = keyword;
}
private void SelectCard(int creatureId, CardDirection direction)
{
if (!Hands.ContainsKey(creatureId))
{
return;
}
StreamlootsHand hand = Hands[creatureId];
if (hand.Cards.Count == 0)
{
return;
}
if (!hand.IsShown)
{
hand.IsShown = true;
}
UpdateLastInteraction(creatureId);
int selectedCardIndex = hand.GetSelectedCardIndex();
if (selectedCardIndex == -1)
{
hand.SelectedCard = null;
StreamlootsCard firstCard;
if (direction == CardDirection.Next)
{
firstCard = hand.Cards.First();
SelectFirstAvailableCard(hand);
}
else
{
firstCard = hand.Cards.Last();
SelectLastAvailableCard(hand);
}
if (hand.SelectedCard == null) // Only secret cards in the hand.
{
hand.SelectedCard = firstCard;
}
}
else
{
if (direction == CardDirection.Next)
{
selectedCardIndex = GetNextCardIndex(hand, selectedCardIndex);
}
else
{
selectedCardIndex = SelectPreviousCardIndex(hand, selectedCardIndex);
}
hand.SelectedCard = hand.Cards[selectedCardIndex];
}
StateHasChanged();
}
private void ProcessPlusPhase(Card _playedCard, Dictionary <CardDirection, Card> _adjacentCardsByDirection, ref Dictionary <GamePhase, ResultPhaseData> _turnResultByPhase)
{
List <CardOnBoardWon> cardWonList = new List <CardOnBoardWon>();
Dictionary <int, List <CardOnBoardWon> > cardWonByAddPowers = new Dictionary <int, List <CardOnBoardWon> >();
foreach (KeyValuePair <CardDirection, Card> opponentCardItem in _adjacentCardsByDirection)
{
bool isRealCard = (opponentCardItem.Value.BoardPosition.HasValue);
if (isRealCard)
{
CardDirection opponentCardOppositeDirection = GetOppositeDirection(opponentCardItem.Key);
int powerAdd = ((int)_playedCard.GetPowerByDirection(opponentCardItem.Key)) + ((int)opponentCardItem.Value.GetPowerByDirection(opponentCardOppositeDirection));
List <CardOnBoardWon> powerAddCardWonList;
if (!cardWonByAddPowers.TryGetValue(powerAdd, out powerAddCardWonList))
{
powerAddCardWonList = new List <CardOnBoardWon>();
cardWonByAddPowers[powerAdd] = powerAddCardWonList;
}
powerAddCardWonList.Add(new CardOnBoardWon(opponentCardItem.Value, opponentCardOppositeDirection));
}
}
foreach (List <CardOnBoardWon> cardWonByAddPowerItem in cardWonByAddPowers.Values)
{
if (cardWonByAddPowerItem.Count > 1)
{
cardWonList.AddRange(cardWonByAddPowerItem);
}
}
bool allCardsAreOwnedByCurrentPlayer = true;
foreach (CardOnBoardWon cardItem in cardWonList)
{
if (cardItem.card.PlayerOwner != _playedCard.PlayerOwner)
{
allCardsAreOwnedByCurrentPlayer = false;
}
}
if (cardWonList.Count > 1 && !allCardsAreOwnedByCurrentPlayer)
{
ResultPhaseData plusResultPhaseData = new ResultPhaseData();
foreach (CardOnBoardWon cardItem in cardWonList)
{
cardItem.card.PlayerOwner = _playedCard.PlayerOwner;
}
plusResultPhaseData.cardWonList = cardWonList;
ProcessComboPhase(cardWonList, ref plusResultPhaseData.comboCardList);
_turnResultByPhase[GamePhase.Plus] = plusResultPhaseData;
}
}
public void ChangePlayerOwner(CardDirection _targetDirection, PlayerNumber _newPlayerOwner)
{
if (newPlayerOwner != _newPlayerOwner)
{
newPlayerOwner = _newPlayerOwner;
string formattedRotationTrigger = string.Format("Rotate{0}", _targetDirection.ToString());
Animator.SetTrigger(formattedRotationTrigger);
AudioManager.Instance.PlaySound(turnCardSound);
}
}
private List <CardOnBoardWon> CardFight(Card _targetCardOnBoard, Dictionary <CardDirection, Card> _adjacentCardsOnBoard)
{
List <CardOnBoardWon> cardsWonInFight = new List <CardOnBoardWon>();
foreach (KeyValuePair <CardDirection, Card> opponentCardItem in _adjacentCardsOnBoard)
{
bool isRealCard = (opponentCardItem.Value.BoardPosition.HasValue);
if (isRealCard)
{
CardDirection opponentCardOppositeDirection = GetOppositeDirection(opponentCardItem.Key);
int powerDiff = ((int)_targetCardOnBoard.GetPowerByDirection(opponentCardItem.Key)) - ((int)opponentCardItem.Value.GetPowerByDirection(opponentCardOppositeDirection));
if (opponentCardItem.Value.PlayerOwner != _targetCardOnBoard.PlayerOwner)
{
bool isTargetCardWon;
if (activeRules.HasFlag(GameRule.Reversed))
{
if (activeRules.HasFlag(GameRule.FallenAce) && powerDiff == (int)(CardPower.Ace - CardPower.One))
{
isTargetCardWon = true;
}
else
{
isTargetCardWon = powerDiff < 0;
}
}
else
{
if (activeRules.HasFlag(GameRule.FallenAce) && powerDiff == (int)(CardPower.One - CardPower.Ace))
{
isTargetCardWon = true;
}
else
{
isTargetCardWon = powerDiff > 0;
}
}
if (isTargetCardWon)
{
opponentCardItem.Value.PlayerOwner = _targetCardOnBoard.PlayerOwner;
cardsWonInFight.Add(new CardOnBoardWon(opponentCardItem.Value, opponentCardOppositeDirection));
}
}
}
}
return(cardsWonInFight);
}
/// <summary>
/// スプレッド認識用
/// </summary>
/// <param name="name">タロットの名前</param>
/// <param name="engName">英語の名前（データベース検索用）</param>
/// <param name="keyword">タロットのキーワード</param>
/// <param name="direction">タロットの向き（正位と逆位）</param>
/// <param name="position">タロットの位置（スプレッド認識用）</param>
/// <param name="currentSituation">現在の状況</param>
/// <param name="humanFeeling">人の気もち</param>
/// <param name="problemCause">問題の原因</param>
/// <param name="future">未来の行末</param>
/// <param name="advice">アドバイス</param>
/// <param name="love">恋愛</param>
/// <param name="work">仕事</param>
/// <param name="interpersonal">対人関係</param>
/// <param name="other">その他</param>
public TarotCard(string name, string engName, string keyword, CardDirection direction, Vector3 position,
string currentSituation, string humanFeeling,
string problemCause, string future, string advice, string love, string work, string interpersonal,
string other)
{
Name = name;
EnglishName = engName;
Direction = direction;
Position = position;
Keyword = keyword;
switch (direction)
{
case CardDirection.Default:
break;
case CardDirection.Upright:
CurrentSituationSituation_Up = currentSituation;
HumanFeelings_Up = humanFeeling;
ProblemCause_Up = problemCause;
Future_Up = future;
Advice_Up = advice;
Love_Up = love;
Work_Up = work;
Interpersonal_Up = interpersonal;
Other_Up = other;
break;
case CardDirection.Reversed:
CurrentSituationSituation_Re = currentSituation;
HumanFeelings_Re = humanFeeling;
ProblemCause_Re = problemCause;
Future_Re = future;
Advice_Re = advice;
Love_Re = love;
Work_Re = work;
Interpersonal_Re = interpersonal;
Other_Re = other;
break;
}
}
public TarotCard FindTarotCardByNameAndDirection(string cardName, CardDirection direction, Vector3 position)
{
if (TarotDatabaseObject == null)
{
ObtainDatabase();
}
try
{
var dummyTarot = new TarotCard();
foreach (var card in TarotDatabaseObject.database)
{
if (TryGetCardInformationInCardDataBase(card, cardName))
{
switch (direction)
{
case CardDirection.Default:
break;
case CardDirection.Upright:
dummyTarot = new TarotCard(card.cardName, card.cardEngName, card.keyword, direction, position,
card.curSituation_up, card.feelings_up, card.cause_up, card.future_up,
card.advice_up, card.love_up, card.work_up, card.interpersonal_up, card.other_up);
break;
case CardDirection.Reversed:
dummyTarot = new TarotCard(card.cardName, card.cardEngName, card.keyword, direction, position,
card.curSituation_re, card.feelings_re, card.cause_re, card.future_re,
card.advice_re, card.love_re, card.work_re, card.interpersonal_re, card.other_re);
break;
}
}
}
return(dummyTarot);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
private void ProcessSamePhase(Card _playedCard, Dictionary <CardDirection, Card> _adjacentCardsByDirection, ref Dictionary <GamePhase, ResultPhaseData> _turnResultByPhase)
{
List <CardOnBoardWon> cardWonList = new List <CardOnBoardWon>();
foreach (KeyValuePair <CardDirection, Card> opponentCardItem in _adjacentCardsByDirection)
{
CardDirection oppositeDirection = GetOppositeDirection(opponentCardItem.Key);
bool isSamePower = (_playedCard.GetPowerByDirection(opponentCardItem.Key) == opponentCardItem.Value.GetPowerByDirection(oppositeDirection));
bool isRealCard = (opponentCardItem.Value.BoardPosition.HasValue);
if (isSamePower && isRealCard)
{
cardWonList.Add(new CardOnBoardWon(opponentCardItem.Value, oppositeDirection));
}
}
bool allCardsAreOwnedByCurrentPlayer = true;
foreach (CardOnBoardWon cardItem in cardWonList)
{
if (cardItem.card.PlayerOwner != _playedCard.PlayerOwner)
{
allCardsAreOwnedByCurrentPlayer = false;
}
}
if (cardWonList.Count > 1 && !allCardsAreOwnedByCurrentPlayer)
{
ResultPhaseData sameResultPhaseData = new ResultPhaseData();
foreach (CardOnBoardWon cardItem in cardWonList)
{
cardItem.card.PlayerOwner = _playedCard.PlayerOwner;
}
sameResultPhaseData.cardWonList = cardWonList;
ProcessComboPhase(cardWonList, ref sameResultPhaseData.comboCardList);
_turnResultByPhase[GamePhase.Same] = sameResultPhaseData;
}
}
public CardPower GetPowerByDirection(CardDirection _targetDirection)
{
return(cardPowersByDirection[_targetDirection]);
}
public CardOnBoardWon(Card _card, CardDirection _direction)
{
card = _card;
direction = _direction;
}
