public Handcard getOppositeCard(Playfield p, group Group, bool canWait = true, int gangSize = 5)
{
Handcard bestCard = null;
int bestVal = int.MinValue;
int tmpVal;
foreach (Handcard hc in p.ownHandCards)
{
if (canWait || hc.manacost <= p.ownMana)
{
tmpVal = 0;
int numAirTransport = Group.lowHPboAirTransport + Group.avgHPboAirTransport + Group.hiHPboAirTransport;
int groupSize = Group.lowHPbo.Count + Group.avgHPbo.Count + Group.hiHPbo.Count;
if (hc.card.aoeAir)
{
tmpVal += 3;
}
if (hc.card.type == boardObjType.MOB)
{
tmpVal += 2;
}
if (hc.card.Transport == transportType.AIR)
{
tmpVal += 3;
}
if (numAirTransport > 0)
{
if (hc.card.TargetType == targetType.ALL)
{
tmpVal += 20;
}
if (Group.lowHPboAirTransport >= gangSize && hc.card.aoeAir)
{
tmpVal += 5;
}
}
if (groupSize > numAirTransport)
{
if (Group.lowHPbo.Count - Group.lowHPboAirTransport >= gangSize)
{
if (hc.card.aoeAir)
{
tmpVal += 15;
}
if (hc.card.aoeGround)
{
tmpVal += 15;
}
}
if (hc.card.TargetType == targetType.GROUND)
{
tmpVal += 15;
}
if (hc.card.TargetType == targetType.ALL)
{
tmpVal += 15;
}
}
foreach (BoardObj tmp in Group.hiHPbo)
{
if (OppositeDB.ContainsKey(tmp.card.name))
{
var opp = OppositeDB[tmp.card.name];
if (opp.ContainsKey(hc.card.name))
{
tmpVal += opp[hc.card.name] / 10;
}
}
}
foreach (BoardObj tmp in Group.avgHPbo)
{
if (OppositeDB.ContainsKey(tmp.card.name))
{
var opp = OppositeDB[tmp.card.name];
if (opp.ContainsKey(hc.card.name))
{
tmpVal += opp[hc.card.name] / 10;
}
}
}
foreach (BoardObj tmp in Group.lowHPbo)
{
if (OppositeDB.ContainsKey(tmp.card.name))
{
var opp = OppositeDB[tmp.card.name];
if (opp.ContainsKey(hc.card.name))
{
tmpVal += opp[hc.card.name] / 15;
}
}
}
if (bestVal < tmpVal)
{
bestVal = tmpVal;
bestCard = hc;
bestCard.val = tmpVal;
}
}
}
return(bestCard);
}
public opposite getOppositeToAll(Playfield p, BoardObj defender, bool canWait = true)
{
opposite bestOpposite = null;
List <attackDef> attackersList = defender.getPossibleAttackers(p);
if (attackersList.Count < 1)
{
return(bestOpposite);
}
List <attackDef> defendersList;
CardDB.cardName aName;
CardDB.cardName dName;
Dictionary <CardDB.cardName, int> aopp;
Dictionary <CardDB.cardName, opposite> allOpposite = new Dictionary <CardDB.cardName, opposite>();
foreach (attackDef ad in attackersList)
{
if (OppositeDB.ContainsKey(ad.attacker.Name))
{
aopp = OppositeDB[ad.attacker.Name];
//-1.Get all obj on board
defendersList = ad.attacker.getPossibleAttackers(p);
foreach (var def in defendersList)
{
dName = def.attacker.Name;
if (aopp.ContainsKey(dName))
{
if (!allOpposite.ContainsKey(dName))
{
allOpposite.Add(dName, new opposite(dName, aopp[dName], def.attacker, ad.attacker));
}
else
{
allOpposite[dName].value += aopp[dName];
}
}
}
//-2.Get all cards
//TODO - enemy have opposite - it depends on his mana
if (defender.own)
{
foreach (Handcard hc in p.ownHandCards)
{
dName = hc.card.name;
if ((canWait || hc.manacost <= p.ownMana) && aopp.ContainsKey(dName))
{
if (!allOpposite.ContainsKey(dName))
{
allOpposite.Add(dName, new opposite(dName, aopp[dName], hc, ad.attacker));
}
else
{
allOpposite[dName].value += aopp[dName];
}
}
}
}
}
else
{
Handcard tmp = null;
int count = p.ownHandCards.Count;
//TODO automatic creation opposite list
if (ad.attacker.Transport == transportType.AIR)
{
foreach (Handcard hc in p.ownHandCards)
{
if (hc.card.TargetType == targetType.ALL)
{
if (ad.attacker.card.DamageRadius > 1000)
{
if (hc.card.MaxHP > ad.attacker.Atk)
{
if (tmp == null || tmp.card.MaxHP < hc.card.MaxHP)
{
tmp = hc;
}
}
}
else
{
if (hc.card.MaxHP > ad.attacker.Atk * 4 || hc.card.SpawnNumber > 3)
{
tmp = hc;
break;
}
}
}
}
}
else
{
if (ad.attacker.TargetType == targetType.ALL)
{
foreach (Handcard hc in p.ownHandCards)
{
if (ad.attacker.card.DamageRadius > 1000 && hc.card.MaxHP > ad.attacker.Atk)
{
if (tmp == null || tmp.card.MaxHP < hc.card.MaxHP)
{
tmp = hc;
}
}
else
{
if (hc.card.MaxHP > ad.attacker.Atk * 4 || hc.card.SpawnNumber > 3)
{
tmp = hc;
break;
}
}
}
}
else if (ad.attacker.TargetType == targetType.BUILDINGS)
{
foreach (Handcard hc in p.ownHandCards)
{
if (hc.card.Atk > ad.attacker.HP * 5 || hc.card.SpawnNumber > 3)
{
tmp = hc;
break;
}
}
}
else
{
foreach (Handcard hc in p.ownHandCards)
{
if (hc.card.Transport == transportType.AIR)
{
if (tmp == null || tmp.card.SpawnNumber < hc.card.SpawnNumber)
{
tmp = hc;
}
}
}
if (tmp == null)
{
foreach (Handcard hc in p.ownHandCards)
{
if (ad.attacker.card.DamageRadius > 1000)
{
if (hc.card.MaxHP > ad.attacker.Atk)
{
if (tmp == null || tmp.card.MaxHP < hc.card.MaxHP)
{
tmp = hc;
}
}
}
else
{
if (hc.card.MaxHP > ad.attacker.Atk * 4 || hc.card.SpawnNumber > 3)
{
tmp = hc;
break;
}
}
}
}
}
}
if (tmp == null)
{
foreach (Handcard hc in p.ownHandCards)
{
if (hc.card.type == boardObjType.PROJECTILE)
{
if (tmp == null || tmp.card.Atk < hc.card.Atk)
{
tmp = hc;
}
}
}
}
if (tmp == null && p.ownMana >= 9)
{
tmp = p.getCheapestCard(boardObjType.NONE, targetType.NONE);
}
if (tmp != null)
{
allOpposite.Add(tmp.card.name, new opposite(tmp.card.name, 10, tmp, ad.attacker));
}
}
}
int oppCount = allOpposite.Count;
if (oppCount > 0)
{
foreach (opposite opp in allOpposite.Values)
{
if (OppositeDB.ContainsKey(opp.name))
{
aopp = OppositeDB[opp.name];
foreach (attackDef ad in attackersList)
{
aName = ad.attacker.Name;
if (aopp.ContainsKey(aName))
{
opp.value -= aopp[aName];
//TODO: test - repeat for each or break;
}
}
}
else
{
Logger.Debug("!OppositeDB.ContainsKey");
}
if (bestOpposite != null)
{
if (bestOpposite.value < opp.value)
{
bestOpposite = opp;
}
}
else
{
bestOpposite = opp;
}
}
if (bestOpposite != null && bestOpposite.target != null)
{
bestOpposite.target.attacker = new BoardObj(bestOpposite.hc.card.name, bestOpposite.hc.lvl);
}
}
return(bestOpposite);
}
