/// <summary>
/// 卡片接受消息
/// </summary>
/// <param name="message">接受到的消息</param>
public void Read(Message message)
{
ListUtils.Clone(AttachableList).ForEach(item =>
{
item.Read(message);
});
}
public async Task <List <Card> > ChooseDiscardedCardsSameNameProcess(List <Card> units, string name)
{
ReadyForSameNameProcessPartialMessage readyForSameNameProcessMessage = Game.TryMessage(new ReadyForSameNameProcessPartialMessage()
{
Targets = units,
Name = name
}) as ReadyForSameNameProcessPartialMessage;
if (readyForSameNameProcessMessage != null && readyForSameNameProcessMessage.Targets.Count > 1)
{
Card savedUnit;
if (readyForSameNameProcessMessage.Targets.Contains(Hero))
{
savedUnit = Hero;
}
else
{
savedUnit = await Request.ChooseOne(readyForSameNameProcessMessage.Targets, this);
}
List <Card> confirmedTarget = ListUtils.Clone(readyForSameNameProcessMessage.Targets);
confirmedTarget.Remove(savedUnit);
return(confirmedTarget);
}
else
{
return(new List <Card>());
}
}
public List <Card> GetCostsForAvoid(Skill reason = null)
{
var targets = Controller.Hand.Filter(card => card.HasSameUnitNameWith(this));
foreach (var card in ListUtils.Clone(targets))
{
var message = Game.TryMessage(new AvoidMessage()
{
AttackingUnit = Game.AttackingUnit,
DefendingUnit = this,
Cost = card
}) as AvoidMessage;
if (message == null || message.Cost != card)
{
targets.Remove(card);
}
}
return(targets);
}
public List <Card> GetDeployableCards(List <Card> targets, ref Dictionary <Card, bool> toFrontFieldDict, ref Dictionary <Card, bool> actionedDict, Skill reason = null)
{
var targets_new = ListUtils.Clone(targets);
foreach (var card in targets)
{
Area area = null;
if (toFrontFieldDict.ContainsKey(card))
{
if (toFrontFieldDict[card])
{
area = card.Controller.FrontField;
}
else
{
area = card.Controller.BackField;
}
}
bool actioned = actionedDict.ContainsKey(card) ? actionedDict[card] : false;
bool canDeploy;
if (area == null)
{
canDeploy = card.CheckDeployment(card.Controller.FrontField, actioned, reason) ||
card.CheckDeployment(card.Controller.BackField, actioned, reason);
}
else
{
canDeploy = card.CheckDeployment(area, actioned, reason);
}
if (!canDeploy)
{
targets_new.Remove(card);
toFrontFieldDict.Remove(card);
actionedDict.Remove(card);
}
}
return(targets_new);
}
public List <Card> GetLevelUpableUnits(Skill reason = null)
{
var baseUnits = Controller.Field.Filter(unit =>
{
if (unit.HasSameUnitNameWith(this))
{
return(true);
}
if (unit.HasSubSkill(typeof(CanLevelUpToOthers)))
{
foreach (var item in unit.FindAllSubSkills(typeof(CanLevelUpToOthers)))
{
if (HasUnitNameOf(((CanLevelUpToOthers)item).UnitName))
{
return(true);
}
}
}
return(false);
});
foreach (var unit in ListUtils.Clone(baseUnits))
{
var message = Game.TryMessage(new LevelUpMessage()
{
Target = this,
BaseUnit = unit,
Reason = reason
}) as LevelUpMessage;
if (message == null || message.BaseUnit != unit)
{
baseUnits.Remove(unit);
}
}
return(baseUnits);
}
public Message Clone()
{
Type messageType = GetType();
Message clone = Activator.CreateInstance(messageType) as Message;
clone.SendBySelf = SendBySelf;
for (int i = 0; i < fieldNumber; i++)
{
dynamic field = GetType().GetField("field" + (i + 1).ToString(), BindingFlags.NonPublic | BindingFlags.Instance).GetValue(this);
if (field != null)
{
if (field is System.Collections.IList)
{
clone.GetType().GetField("field" + (i + 1).ToString(), BindingFlags.NonPublic | BindingFlags.Instance).SetValue(clone, ListUtils.Clone(field));
}
else
{
clone.GetType().GetField("field" + (i + 1).ToString(), BindingFlags.NonPublic | BindingFlags.Instance).SetValue(clone, field);
}
}
}
return(clone);
}
public List <Card> GetAttackableUnits()
{
var targets = new List <Card>();
if (IsHorizontal)
{
return(targets);
}
bool canAttackFront = false;
bool canAttackBack = false;
if (BelongedRegion is FrontField)
{
if (HasRange(RangeEnum.One))
{
canAttackFront = true;
}
if (HasRange(RangeEnum.Two))
{
canAttackBack = true;
}
if (HasRange(RangeEnum.OnetoTwo) || HasRange(RangeEnum.OnetoThree))
{
canAttackFront = true;
canAttackBack = true;
}
}
else if (BelongedRegion is BackField)
{
if (HasRange(RangeEnum.Two) || HasRange(RangeEnum.OnetoTwo))
{
canAttackFront = true;
}
if (HasRange(RangeEnum.Three))
{
canAttackBack = true;
}
if (HasRange(RangeEnum.OnetoThree))
{
canAttackFront = true;
canAttackBack = true;
}
}
//TO DO: 无视射程攻击
if (canAttackFront)
{
targets.AddRange(Opponent.FrontField.Cards);
}
if (canAttackBack)
{
targets.AddRange(Opponent.BackField.Cards);
}
foreach (var unit in ListUtils.Clone(targets))
{
var message = Game.TryMessage(new AttackMessage()
{
AttackingUnit = this,
DefendingUnit = unit
}) as AttackMessage;
if (message == null || message.DefendingUnit != unit)
{
targets.Remove(unit);
}
}
return(targets);
}
