Mahtan/wagic
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "Update AIPlayerBaka.cpp"

Browse Source 
This reverts commit 3555ddba33.
This commit is contained in:
Eduardo MG
2025-04-23 19:16:43 -06:00
parent 3555ddba33
commit c0e2a1fe40
1 changed files with 196 additions and 340 deletions
Download Patch File Download Diff File Expand all files Collapse all files

274
projects/mtg/src/AIPlayerBaka.cpp
View File

@@ -654,7 +654,7 @@ int OrderedAIAction::getEfficiency()
}
else if (GenericRevealAbility * grA = dynamic_cast<GenericRevealAbility *>(a))
{
if(grA->source->getAICustomCode().size())
if(grA->source->getAICustomCode().size() && grA->source->alias != 185709)//Sphinx of Jwar Isle so the ai will ignore it
{
//efficiency = 45 + (owner->getRandomGenerator()->random() % 50);
AbilityFactory af(g);
@@ -4012,98 +4012,46 @@ int AIPlayerBaka::chooseAttackers()
MTGCardInstance * card = NULL;
while ((card = cd.nextmatch(game->inPlay, card)))
{
if (shouldAIForceAttack(card, attack))
if ((hints && hints->HintSaysAlwaysAttack(observer, card)) || card->has(Constants::UNBLOCKABLE))
{
if (!card->isAttacker())
{
if (card->attackCost)
{
MTGAbility* a = observer->mLayers->actionLayer()->getAbility(MTGAbility::ATTACK_COST);
MTGAbility * a = observer->mLayers->actionLayer()->getAbility(MTGAbility::ATTACK_COST);
doAbility(a,card);
observer->cardClick(card, MTGAbility::ATTACK_COST);
}
}
observer->cardClick(card, MTGAbility::MTG_ATTACK_RULE);
}
}
if (attack)
{
CardDescriptor cd;
cd.init();
cd.setType("creature");
MTGCardInstance * card = NULL;
while ((card = cd.nextmatch(game->inPlay, card)))
{
if(hints && hints->HintSaysDontAttack(observer,card))
continue;
if (!card->isAttacker())
{
if (card->attackCost)
{
MTGAbility * a = observer->mLayers->actionLayer()->getAbility(MTGAbility::ATTACK_COST);
doAbility(a, card);
observer->cardClick(card, MTGAbility::ATTACK_COST);
}
observer->cardClick(card, MTGAbility::MTG_ATTACK_RULE);
}
}
}
return 1;
}
bool AIPlayerBaka::shouldAIForceAttack(MTGCardInstance* card, bool globalAttack)
{
if (globalAttack)
return true;
if (!card || card->isAttacker())
return false;
if (hints)
{
if (hints->HintSaysDontAttack(observer, card))
return false;
if (hints->HintSaysAlwaysAttack(observer, card))
return true;
}
if (card->has(Constants::UNBLOCKABLE))
return true;
// Flags for opponent defenses
bool oppHasShadow = false;
bool oppHasAirDefense = false;
bool oppHasHorsemanship = false;
bool oppHasBlackOrArtifact = false;
bool oppHasMatchingColorOrArtifact = false;
// Flags for landwalk checks
bool oppHasSwamp = opponent()->game->inPlay->hasType("Swamp");
bool oppHasIsland = opponent()->game->inPlay->hasType("Island");
bool oppHasForest = opponent()->game->inPlay->hasType("Forest");
bool oppHasMountain = opponent()->game->inPlay->hasType("Mountain");
bool oppHasPlains = opponent()->game->inPlay->hasType("Plains");
MTGCardInstance* oppCard = NULL;
CardDescriptor desc;
desc.init();
desc.setType("creature");
while ((oppCard = desc.nextmatch(opponent()->game->inPlay, oppCard)))
{
if (oppCard->isTapped())
continue;
if (oppCard->has(Constants::SHADOW))
oppHasShadow = true;
if (oppCard->has(Constants::FLYING) || oppCard->has(Constants::REACH))
oppHasAirDefense = true;
if (oppCard->has(Constants::HORSEMANSHIP))
oppHasHorsemanship = true;
if (oppCard->hasColor(Constants::MTG_COLOR_BLACK) || oppCard->hasType("Artifact"))
oppHasBlackOrArtifact = true;
// Intimidate check: artifact or shares color
if (oppCard->hasType("Artifact") || (oppCard->colors & card->colors))
oppHasMatchingColorOrArtifact = true;
}
// Decision logic based on evasion
if ((card->has(Constants::SHADOW) && !oppHasShadow) ||
(card->has(Constants::FLYING) && !oppHasAirDefense) ||
(card->has(Constants::HORSEMANSHIP) && !oppHasHorsemanship) ||
(card->has(Constants::FEAR) && !oppHasBlackOrArtifact) ||
(card->has(Constants::INTIMIDATE) && !oppHasMatchingColorOrArtifact))
return true;
// Landwalk abilities
if ((card->has(Constants::SWAMPWALK) && oppHasSwamp) ||
(card->has(Constants::ISLANDWALK) && oppHasIsland) ||
(card->has(Constants::FORESTWALK) && oppHasForest) ||
(card->has(Constants::MOUNTAINWALK) && oppHasMountain) ||
(card->has(Constants::PLAINSWALK) && oppHasPlains))
return true;
return false;
}
/* Can I first strike my oponent and get away with murder ? */
int AIPlayerBaka::canFirstStrikeKill(MTGCardInstance * card, MTGCardInstance *ennemy)
{
@@ -4122,36 +4070,35 @@ int AIPlayerBaka::canFirstStrikeKill(MTGCardInstance * card, MTGCardInstance *en
int AIPlayerBaka::chooseBlockers()
{
//Should not block during my own turn...
if (observer->currentPlayer == this)
return 0;
map<MTGCardInstance*, int> opponentsToughness;
map<MTGCardInstance *, int> opponentsToughness;
int opponentForce = getCreaturesInfo(opponent(), INFO_CREATURESPOWER);
//Initialize the list of opponent's attacking cards toughness
CardDescriptor cdAttackers;
cdAttackers.init();
cdAttackers.setType("Creature");
MTGCardInstance* card = NULL;
// Gather all attacking creatures and store their toughness
MTGCardInstance * card = NULL;
while ((card = cdAttackers.nextmatch(opponent()->game->inPlay, card)))
{
if (card->isAttacker())
opponentsToughness[card] = card->toughness;
}
//A Descriptor to find untapped creatures in our game
CardDescriptor cd;
cd.init();
cd.setType("Creature");
cd.unsecureSetTapped(-1);
card = NULL;
// First pass: auto-block top 3 threats if can be killed
// We first try to block the major threats, those that are marked in the Top 3 of our stats
while ((card = cd.nextmatch(game->inPlay, card)))
{
if (hints && hints->HintSaysDontBlock(observer, card))
if(hints && hints->HintSaysDontBlock(observer,card))
continue;
observer->cardClick(card, MTGAbility::MTG_BLOCK_RULE);
int set = 0;
while (!set)
@@ -4162,8 +4109,8 @@ int AIPlayerBaka::chooseBlockers()
}
else
{
MTGCardInstance* attacker = card->defenser;
map<MTGCardInstance*, int>::iterator it = opponentsToughness.find(attacker);
MTGCardInstance * attacker = card->defenser;
map<MTGCardInstance *, int>::iterator it = opponentsToughness.find(attacker);
if (it == opponentsToughness.end())
{
opponentsToughness[attacker] = attacker->toughness;
@@ -4178,7 +4125,7 @@ int AIPlayerBaka::chooseBlockers()
{
if (card->blockCost)
{
MTGAbility* a = observer->mLayers->actionLayer()->getAbility(MTGAbility::BLOCK_COST);
MTGAbility * a = observer->mLayers->actionLayer()->getAbility(MTGAbility::BLOCK_COST);
doAbility(a, card);
observer->cardClick(card, MTGAbility::BLOCK_COST);
}
@@ -4188,13 +4135,13 @@ int AIPlayerBaka::chooseBlockers()
}
}
// Second pass: unassign if attacker is not expected to die
//If blocking one of the major threats is not enough to kill it,
// We change strategy, first we unassign its blockers that where assigned above
card = NULL;
while ((card = cd.nextmatch(game->inPlay, card)))
{
if (hints && hints->HintSaysDontBlock(observer, card))
if(hints && hints->HintSaysDontBlock(observer,card))
continue;
if (card->defenser && opponentsToughness[card->defenser] > 0)
{
while (card->defenser)
@@ -4204,139 +4151,48 @@ int AIPlayerBaka::chooseBlockers()
}
}
// Third pass: intelligent blocking
//Assign the "free" potential blockers to attacking creatures that are not blocked enough
card = NULL;
while ((card = cd.nextmatch(game->inPlay, card)))
{
if (hints && hints->HintSaysDontBlock(observer, card))
if(hints && hints->HintSaysDontBlock(observer,card))
continue;
if (card->defenser)
continue;
MTGCardInstance* bestAttacker = NULL;
int bestScore = -1;
for (map<MTGCardInstance*, int>::iterator it = opponentsToughness.begin(); it != opponentsToughness.end(); ++it)
{
MTGCardInstance* attacker = it->first;
if (!attacker)
continue;
int currentBlockers = (int)attacker->blockers.size();
int totalAssignedDamage = 0;
list<MTGCardInstance*>::iterator itb;
for (itb = attacker->blockers.begin(); itb != attacker->blockers.end(); ++itb)
{
MTGCardInstance* blocker = *itb;
if (blocker)
totalAssignedDamage += blocker->power;
}
int maxBlockers = 1;
if (attacker->basicAbilities[Constants::MENACE]) maxBlockers = 2;
if (attacker->basicAbilities[Constants::THREEBLOCKERS]) maxBlockers = 3;
if (totalAssignedDamage >= attacker->toughness || currentBlockers >= maxBlockers)
continue;
bool canKill = (card->power >= attacker->toughness);
bool survives = (card->toughness > attacker->power);
if (!canKill && !survives)
continue;
if (!canKill && survives)
{
int estimatedDamage = opponentForce;
if ((estimatedDamage - attacker->power) < life)
continue;
}
int score = attacker->power * 2 + attacker->toughness;
if (getStats() && getStats()->isInTop(attacker, 3, false))
score += 100;
if (score > bestScore)
{
bestScore = score;
bestAttacker = attacker;
}
}
if (bestAttacker)
{
int requiredBlockers = 1;
if (bestAttacker->basicAbilities[Constants::MENACE]) requiredBlockers = 2;
if (bestAttacker->basicAbilities[Constants::THREEBLOCKERS]) requiredBlockers = 3;
int currentBlockers = (int)bestAttacker->blockers.size();
if (currentBlockers >= requiredBlockers)
continue;
bool canKill = (card->power >= bestAttacker->toughness);
bool survives = (card->toughness > bestAttacker->power);
bool hasFirstStrike = card->has(Constants::FIRSTSTRIKE) || card->has(Constants::DOUBLESTRIKE);
// Block alone if this card is strong enough (e.g., first strike + power)
if (hasFirstStrike && canKill)
if (!card->defenser)
{
if (card->blockCost)
{
MTGAbility* a = observer->mLayers->actionLayer()->getAbility(MTGAbility::BLOCK_COST);
MTGAbility * a = observer->mLayers->actionLayer()->getAbility(MTGAbility::BLOCK_COST);
doAbility(a, card);
}
observer->cardClick(card, MTGAbility::MTG_BLOCK_RULE);
opponentsToughness[bestAttacker] -= card->power;
continue;
}
vector<MTGCardInstance*> extraBlockers;
if (requiredBlockers > 1)
int set = 0;
while (!set)
{
CardDescriptor cd2;
cd2.init();
cd2.setType("Creature");
cd2.unsecureSetTapped(-1);
MTGCardInstance* c2 = NULL;
while ((c2 = cd2.nextmatch(game->inPlay, c2)))
if (!card->defenser)
{
if (c2 == card || c2->defenser || (hints && hints->HintSaysDontBlock(observer, c2)))
continue;
int combinedPower = c2->power + card->power;
bool combinedCanKill = (combinedPower >= bestAttacker->toughness);
bool eitherSurvives = (c2->toughness > bestAttacker->power || card->toughness > bestAttacker->power);
if (combinedCanKill || eitherSurvives)
set = 1;
}
else
{
extraBlockers.push_back(c2);
if ((int)extraBlockers.size() + currentBlockers + 1 >= requiredBlockers)
break;
}
}
}
if (currentBlockers + (int)extraBlockers.size() + 1 >= requiredBlockers)
MTGCardInstance * attacker = card->defenser;
if (opponentsToughness[attacker] <= 0 || (card->toughness <= attacker->power && opponentForce * 2 < life && !canFirstStrikeKill(card, attacker)) || attacker->nbOpponents() > 1)
{
if (card->blockCost)
{
MTGAbility* a = observer->mLayers->actionLayer()->getAbility(MTGAbility::BLOCK_COST);
MTGAbility * a = observer->mLayers->actionLayer()->getAbility(MTGAbility::BLOCK_COST);
doAbility(a, card);
}
if((!attacker->basicAbilities[Constants::MENACE] && !attacker->basicAbilities[Constants::THREEBLOCKERS]) ||
(attacker->basicAbilities[Constants::MENACE] && attacker->blockers.size() > 2) ||
(attacker->basicAbilities[Constants::THREEBLOCKERS] && attacker->blockers.size() > 3))
observer->cardClick(card, MTGAbility::MTG_BLOCK_RULE);
opponentsToughness[bestAttacker] -= card->power;
for (size_t i = 0; i < extraBlockers.size(); ++i)
{
MTGCardInstance* extra = extraBlockers[i];
if (extra->blockCost)
{
MTGAbility* a = observer->mLayers->actionLayer()->getAbility(MTGAbility::BLOCK_COST);
doAbility(a, extra);
else
set = 1;
}
else
{
set = 1;
}
observer->cardClick(extra, MTGAbility::MTG_BLOCK_RULE);
opponentsToughness[bestAttacker] -= extra->power;
}
}
}
@@ -4413,7 +4269,7 @@ int AIPlayerBaka::receiveEvent(WEvent * event)
AIPlayerBaka::AIPlayerBaka(GameObserver *observer, string file, string fileSmall, string avatarFile, MTGDeck * deck) :
AIPlayer(observer, file, fileSmall, deck)
AIPlayer(observer, file, fileSmall, deck)
{
nextCardToPlay = NULL;