public void SetSelectedMingming(Mingming _mingming)
{
if (_activeController.HasMingming(_mingming))
{
_selectedMingming = (Mingming)SetSelectable(_selectedMingming, _mingming);
EventManager.Instance.OnUpdateSelectedMingmingTrigger(_selectedMingming);
}
}
private void Logic_OnStatusRemoved(Mingming mingming, BaseStatus status)
{
var effectStatus = status as EffectStatus;
if (effectStatus != null)
{
TurnStateMachine[effectStatus.TurnState].RemoveListener(effectStatus.GetEffect(mingming.Logic));
}
}
public IEnumerator InvokeActionCoroutine(Mingming source, Mingming target)
{
PlayedThisTurn = true;
yield return(null);
ToggleInteractions?.Invoke(false);
yield return(InvokeActions(source.Logic, target.Logic));
EventManager.Instance.OnDiscardCardTrigger(this);
}
private void UpdateSelectedMingmingListener(Mingming mingming)
{
disableCover.gameObject.SetActive(false);
if (mingming != null)
{
UserMessage.Instance.CanSendMessage = false;
bool isCardPlayable = card.CanUseCard(mingming.Logic);
disableCover.gameObject.SetActive(!isCardPlayable);
dragAndDrop.enabled = isCardPlayable;
UserMessage.Instance.CanSendMessage = true;
}
}
private void TargetSelected(Mingming target, Card card)
{
if (card.IsValidAction(_selectedMingming, target))
{
string source = _selectedMingming?.name ?? target.name;
UserMessage.Instance.SendMessageToUser($"{source} used {card.name} on {target.name}");
StartCoroutine(card.InvokeActionCoroutine(_selectedMingming, target));
}
else
{
//give message and return card to normal position
OnCardError?.Invoke();
}
}
public override bool IsValidTarget(Mingming source, Mingming target, Card card)
{
bool notNullTarget = target != null;
bool rightSource = (source == null || source == target);
if (!notNullTarget)
{
UserMessage.Instance.SendMessageToUser("Target Mingming is null");
}
else if (!target.IsTurn)
{
UserMessage.Instance.SendMessageToUser($"It is not {target.name}'s turn!");
}
else if (!rightSource)
{
UserMessage.Instance.SendMessageToUser($"Card must target itself");
}
return(notNullTarget && target.IsTurn && rightSource);
}
public virtual bool IsValidTarget(Mingming source, Mingming target, Card card)
{
bool notNullSource = source != null;
bool notNullTarget = target != null;
if (!notNullSource)
{
UserMessage.Instance.SendMessageToUser("Source Mingming is null");
}
else if (!notNullTarget)
{
UserMessage.Instance.SendMessageToUser("Target Mingming is null");
}
else if (!source.IsTurn)
{
UserMessage.Instance.SendMessageToUser($"It is not {source.name}'s turn!");
}
return(notNullSource && notNullTarget && source.IsTurn);
}
public bool GetNextAttack()
{
bool hasAttack = EnemyBehaviourHelper.CanAttack(OwnedParty, OtherParty, Hand);
if (hasAttack)
{
int minCardEnergy = Hand.Any() ? Hand.Min(x => x.EnergyCost) : int.MaxValue;
Mingming source = GetRandomMingming(OwnedParty);
Mingming target = GetRandomMingming(OtherParty);
Card _card = GetCard(source);
List<Mingming> availableMingmings = new List<Mingming>(OtherParty);
while (!_card.IsValidAction(source, target))
{
availableMingmings.Remove(target);
if (availableMingmings.Count == 0)
{
target = source;
break;
}
target = GetRandomMingming(availableMingmings);
}
if (_card.IsValidAction(source, target))
{
UserMessage.Instance.CanSendMessage = true;
EventManager.Instance.OnSelectMingmingTrigger(source);
EventManager.Instance.OnSelectTargetTrigger(target, _card);
EventManager.Instance.OnSelectMingmingTrigger(source); //to deselect
//disable user message so not to get bombarded by failed attempts
UserMessage.Instance.CanSendMessage = false;
}
hasAttack = EnemyBehaviourHelper.CanAttack(OwnedParty, OtherParty, Hand);
}
return hasAttack;
}
private void Instance_MingmingDied(Mingming _mingming)
{
if (HasMingming(_mingming))
{
if (!Mingmings.Any(m => m.IsInPlay))
{ //if all mingmings are not in play
EventManager.Instance.OnBattleOverTrigger(this);
}
}
else
{
int totalXP = _mingming.Logic.GetDeathExp();
int xpPerMingming = Mathf.CeilToInt((float)totalXP / Mingmings.Count(m => m.IsInPlay));
foreach (var mingming in Mingmings)
{
mingming.AddExperience(xpPerMingming);
}
}
}
public void BattleSetUp(IEnumerable <MingmingInstance> datas, List <CardData> deck)
{
bool isWildDeck = deck.Count == 0;
CardDraw = 0;
foreach (Mingming _mingming in Mingmings)
{
Destroy(_mingming);
}
Mingmings.Clear();
int index = 0; //for loop doesn't work with IEnumerable ?
foreach (MingmingInstance _data in datas)
{
Mingming _mingming = Instantiate(mingmingPrefab, transform);
_mingming.SetData(_data, isFacingRight);
Mingmings.Add(_mingming);
_mingming.Logic.OnStatusAdded += (status, _) => Logic_OnStatusAdded(_mingming, status);
_mingming.Logic.OnStatusRemoved += (status) => Logic_OnStatusRemoved(_mingming, status);
//Refactor adding listeners
TurnStateMachine[TurnStateEnum.PreTurn].AddListener(_mingming.StartTurn);
TurnStateMachine[TurnStateEnum.PostTurn].AddListener(delegate { _mingming.SetIsTurn(false); });
CardDraw += _data.CardDraw - index;
if (isWildDeck)
{
deck.AddRange(_data.WildDeck);
}
index++;
}
CardDraw = Mathf.Clamp(CardDraw, 0, Rules.HAND_MAX);
deckController.SetCardDraw(CardDraw);
deckController.AddCardsToDeck(deck);
}
public bool IsValidAction(Mingming source, Mingming target) => IsValidTarget(source, target) && CanUseCard(source.Logic);
public bool IsValidTarget(Mingming source, Mingming target) => Data.TargetType.IsValidTarget(source, target, this);
public bool HasMingming(Mingming mingming)
{
return(Mingmings.Contains(mingming));
}
public void OnSelectTargetTrigger(Mingming target, Card card)
{
SelectTarget?.Invoke(target, card);
}
public void OnMingmingDiedTrigger(Mingming _mingming)
{
MingmingDied?.Invoke(_mingming);
}
public void OnUpdateSelectedMingmingTrigger(Mingming _mingming)
{
UpdateSelectedMingming?.Invoke(_mingming);
}
public void OnSelectMingmingTrigger(Mingming _mingming)
{
SelectMingming?.Invoke(_mingming);
}
private Card GetCard(Mingming attacker)
{
var possiblecards = Hand.Where(x => x.EnergyCost <= attacker.Logic.EnergyAvailable).ToList();
return possiblecards[Random.Range(0, possiblecards.Count())];
}
