public override TaskState Process()
{
switch (Type)
{
case EntityType.HERO:
CardClass = Controller.HeroClass;
break;
case EntityType.OP_HERO:
CardClass = Controller.Opponent.HeroClass;
break;
case EntityType.INVALID:
break;
default:
throw new NotImplementedException();
}
var cards = Game.FormatType == FormatType.FT_STANDARD ? Cards.AllStandard : Cards.AllWild;
var cardsList = cards.Where(p =>
(CardType == CardType.INVALID || p.Type == CardType) &&
(CardClass == CardClass.INVALID || p.Class == CardClass) &&
(CardSet == CardSet.INVALID || p.Set == CardSet));
var randomCard = Entity.FromCard(Opposite ? Controller.Opponent : Controller, Util <Card> .Choose(cardsList.ToList()));
Playables.Add(randomCard);
return(TaskState.COMPLETE);
}
public override TaskState Process()
{
switch (Type)
{
case EntityType.HERO:
CardClass = Controller.HeroClass;
break;
case EntityType.OP_HERO:
CardClass = Controller.Opponent.HeroClass;
break;
case EntityType.INVALID:
break;
default:
throw new NotImplementedException();
}
IEnumerable <Card> cards = Game.FormatType == FormatType.FT_STANDARD ? Cards.AllStandard : Cards.AllWild;
IEnumerable <Card> cardsList = cards.Where(p =>
(CardType == CardType.INVALID || p.Type == CardType) &&
(CardClass == CardClass.INVALID || p.Class == CardClass) &&
(CardSet == CardSet.INVALID || p.Set == CardSet) &&
(GameTagFilter == null || GameTagFilter.TrueForAll(gameTag => p.Tags.ContainsKey(gameTag))));
IPlayable randomCard = Entity.FromCard(Opposite ? Controller.Opponent : Controller, Util.Choose <Card>(cardsList.ToList()));
Playables.Add(randomCard);
Game.OnRandomHappened(true);
return(TaskState.COMPLETE);
}
public override TaskState Process()
{
IPlayable drawedCard = Card != null?Generic.DrawCardBlock.Invoke(Controller.Opponent, Card) : Generic.Draw(Controller.Opponent);
if (ToStack && drawedCard != null)
{
Playables.Add(drawedCard);
}
return(TaskState.COMPLETE);
}
public override TaskState Process()
{
if (CardIds.Count == 0)
{
return(TaskState.STOP);
}
var randomCard = Entity.FromCard(Controller, Cards.FromId(Util <string> .Choose(CardIds)));
Playables.Add(randomCard);
return(TaskState.COMPLETE);
}
public override TaskState Process()
{
var source = Source as IPlayable;
if (source == null || source.Card.Entourage.Count < 1)
{
return(TaskState.STOP);
}
var randomCard = Entity.FromCard(Controller, Cards.FromId(Util <string> .Choose(source.Card.Entourage)));
Playables.Add(randomCard);
return(TaskState.COMPLETE);
}
public override TaskState Process()
{
if (CardIds.Count == 0)
{
return(TaskState.STOP);
}
IPlayable randomCard = Entity.FromCard(Controller, Cards.FromId(Util.Choose <string>(CardIds)));
Playables.Add(randomCard);
Game.OnRandomHappened(true);
return(TaskState.COMPLETE);
}
public override TaskState Process()
{
Model.Entities.IPlayable drawedCard = Generic.Draw(Controller);
if (drawedCard == null)
{
return(TaskState.STOP);
}
if (ToStack)
{
Playables.Add(drawedCard);
}
return(TaskState.COMPLETE);
}
public override TaskState Process()
{
//Model.Entities.IPlayable drawedCard = Generic.Draw(Controller);
var cards = new IPlayable[_count];
for (int i = 0; i < _count; i++)
{
cards[i] = Generic.Draw(Controller);
}
if (cards[0] == null)
{
return(TaskState.COMPLETE);
}
if (ToStack)
{
Playables.Add(cards[0]);
}
return(TaskState.COMPLETE);
}
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
public override TaskState Process()
{
if (Controller.BoardZone.IsFull)
{
return(TaskState.STOP);
}
IList <IPlayable> entities = IncludeTask.GetEntities(Type, Controller, Source, Target, Playables).ToList();
if (entities.Count < 1)
{
return(TaskState.STOP);
}
// shuffle list randomly if needed
entities = RandomFlag ? entities.OrderBy(x => Util.Random.Next()).ToList() : entities;
if (RandomFlag)
{
Game.OnRandomHappened(true);
}
int space = Controller.BoardZone.MaxSize - Controller.BoardZone.Count;
space = entities.Count > space ? space : entities.Count;
if (entities[0].Zone == null || entities[0].Zone.Type != Enums.Zone.PLAY)
{
for (int i = 0; i < space; i++)
{
// clone task here
var task = new SummonTask(_side, entities[i].Card)
{
Game = Controller.Game,
Controller = Controller,
Source = Source as IPlayable,
Target = Target as IPlayable
};
Controller.Game.TaskQueue.Enqueue(task);
}
}
else
{
for (int i = 0; i < entities.Count; i++)
{
if (Controller.BoardZone.IsFull)
{
break;
}
Minion target = (Minion)entities[i];
var tags = new EntityData.Data((EntityData.Data)target.NativeTags);
if (target.Controller != Controller)
{
tags[GameTag.CONTROLLER] = Controller.PlayerId;
}
IPlayable copy = Entity.FromCard(Controller, target.Card, tags, Controller.BoardZone);
target.AppliedEnchantments?.ForEach(e =>
{
Enchantment instance = Enchantment.GetInstance(Controller, copy, copy, e.Card);
if (e[GameTag.TAG_SCRIPT_DATA_NUM_1] > 0)
{
instance[GameTag.TAG_SCRIPT_DATA_NUM_1] = e[GameTag.TAG_SCRIPT_DATA_NUM_1];
if (e[GameTag.TAG_SCRIPT_DATA_NUM_2] > 0)
{
instance[GameTag.TAG_SCRIPT_DATA_NUM_2] = e[GameTag.TAG_SCRIPT_DATA_NUM_2];
}
}
});
if (target.OngoingEffect != null && copy.OngoingEffect == null)
{
target.OngoingEffect.Clone(copy);
}
if (_addToStack)
{
Playables.Add(copy);
}
}
}
return(TaskState.COMPLETE);
}
public override TaskState Process()
{
for (int i = 0; i < _amount; ++i)
{
if (Controller.BoardZone.IsFull)
{
if (Card == null && Playables.Count > 0)
{
var m = Playables[0] as Minion;
if (m.Zone == null && m.GetNativeGameTag(GameTag.ZONE) != 0)
{
Playables[0].Controller.GraveyardZone.Add(Playables[0]);
}
}
return(TaskState.STOP);
}
Minion summonEntity = null;
if (Card != null)
{
summonEntity = Entity.FromCard(Controller, Card,
new EntityData.Data
{
{ GameTag.ZONE, (int)Zone.PLAY },
{ GameTag.DISPLAYED_CREATOR, Source.Id }
}) as Minion;
if (_addToStack)
{
Playables.Add(summonEntity);
}
}
else if (Playables.Count > 0)
{
summonEntity = Playables[0] as Minion;
if (RemoveFromStack)
{
Playables.Remove(summonEntity);
}
}
if (summonEntity == null)
{
return(TaskState.STOP);
}
int summonPosition = -1;
switch (Side)
{
case SummonSide.LEFT:
if (Source.Zone.Type == Enums.Zone.PLAY)
{
summonPosition = ((Minion)Source).ZonePosition;
}
else
{
summonPosition = ((Minion)Source).LastBoardPosition;
}
break;
case SummonSide.RIGHT:
if (Source.Zone.Type == Enums.Zone.PLAY)
{
summonPosition = ((Minion)Source).ZonePosition + 1;
}
else
{
summonPosition = ((Minion)Source).LastBoardPosition;
}
break;
case SummonSide.DEATHRATTLE:
if (Source is Minion m)
{
summonPosition = m.LastBoardPosition;
}
else if
(Source is Enchantment e)
{
summonPosition = ((Minion)e.Target).LastBoardPosition;
}
break;
case SummonSide.NUMBER:
summonPosition = Number - 1;
break;
case SummonSide.SPELL:
summonPosition = -1;
break;
case SummonSide.DEFAULT:
summonPosition = -1;
break;
}
if (summonPosition > Controller.BoardZone.Count)
{
summonPosition = Controller.BoardZone.Count;
}
bool success = Generic.SummonBlock.Invoke(Controller, summonEntity, summonPosition);
}
return(TaskState.COMPLETE);
}
