mirror of
https://github.com/vcmi/vcmi.git
synced 2025-11-29 23:07:48 +02:00
Fixed crash occurring after casting Armageddon and killing all stacks.
Removed some commented-out code.
This commit is contained in:
Michał W. Urbańczyk
@@ -36,157 +36,6 @@ const CStack * BattleInfo::getNextStack() const
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
// const CStack * BattleInfo::getStackT(BattleHex tileID, bool onlyAlive) const
|
||||
// {
|
||||
// return const_cast<BattleInfo * const>(this)->getStackT(tileID, onlyAlive);
|
||||
// }
|
||||
|
||||
// void BattleInfo::getAccessibilityMap(bool *accessibility, bool twoHex, bool attackerOwned, bool addOccupiable, std::set<BattleHex> & occupyable, bool flying, const CStack * stackToOmmit) const
|
||||
// {
|
||||
// memset(accessibility, 1, GameConstants::BFIELD_SIZE); //initialize array with trues
|
||||
//
|
||||
// //removing accessibility for side columns of hexes
|
||||
// for(int v = 0; v < GameConstants::BFIELD_SIZE; ++v)
|
||||
// {
|
||||
// if( v % GameConstants::BFIELD_WIDTH == 0 || v % GameConstants::BFIELD_WIDTH == (GameConstants::BFIELD_WIDTH - 1) )
|
||||
// accessibility[v] = false;
|
||||
// }
|
||||
//
|
||||
// for(ui32 g=0; g<stacks.size(); ++g)
|
||||
// {
|
||||
// if(!stacks[g]->alive() || (stackToOmmit && stacks[g]->ID==stackToOmmit->ID) || stacks[g]->position < 0) //we don't want to lock position of this stack (eg. if it's a turret)
|
||||
// continue;
|
||||
//
|
||||
// accessibility[stacks[g]->position] = false;
|
||||
// if(stacks[g]->doubleWide()) //if it's a double hex creature
|
||||
// {
|
||||
// if(stacks[g]->attackerOwned)
|
||||
// accessibility[stacks[g]->position-1] = false;
|
||||
// else
|
||||
// accessibility[stacks[g]->position+1] = false;
|
||||
// }
|
||||
// }
|
||||
// //obstacles
|
||||
// BOOST_FOREACH(const auto &obstacle, obstacles)
|
||||
// {
|
||||
// BOOST_FOREACH(BattleHex hex, obstacle->getBlockedTiles())
|
||||
// {
|
||||
// assert(hex.isValid());
|
||||
// accessibility[hex] = false;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// //walls
|
||||
// if(siege > 0)
|
||||
// {
|
||||
// static const int permanentlyLocked[] = {12, 45, 78, 112, 147, 165};
|
||||
// for(int b=0; b<ARRAY_COUNT(permanentlyLocked); ++b)
|
||||
// {
|
||||
// accessibility[permanentlyLocked[b]] = false;
|
||||
// }
|
||||
//
|
||||
// static const std::pair<int, BattleHex> lockedIfNotDestroyed[] = //(which part of wall, which hex is blocked if this part of wall is not destroyed
|
||||
// {std::make_pair(2, BattleHex(182)), std::make_pair(3, BattleHex(130)),
|
||||
// std::make_pair(4, BattleHex(62)), std::make_pair(5, BattleHex(29))};
|
||||
// for(int b=0; b<ARRAY_COUNT(lockedIfNotDestroyed); ++b)
|
||||
// {
|
||||
// if(si.wallState[lockedIfNotDestroyed[b].first] < 3)
|
||||
// {
|
||||
// accessibility[lockedIfNotDestroyed[b].second] = false;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// //gate
|
||||
// if(attackerOwned && si.wallState[7] < 3) //if it attacker's unit and gate is not destroyed
|
||||
// {
|
||||
// accessibility[95] = accessibility[96] = false; //block gate's hexes
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// //occupyability
|
||||
// if(addOccupiable && twoHex)
|
||||
// {
|
||||
// std::set<BattleHex> rem; //tiles to unlock
|
||||
// for(int h=0; h<GameConstants::BFIELD_HEIGHT; ++h)
|
||||
// {
|
||||
// for(int w=1; w<GameConstants::BFIELD_WIDTH-1; ++w)
|
||||
// {
|
||||
// BattleHex hex(w, h);
|
||||
// if(!isAccessible(hex, accessibility, twoHex, attackerOwned, flying, true)
|
||||
// && (attackerOwned ? isAccessible(hex+1, accessibility, twoHex, attackerOwned, flying, true) : isAccessible(hex-1, accessibility, twoHex, attackerOwned, flying, true) )
|
||||
// )
|
||||
// rem.insert(hex);
|
||||
// }
|
||||
// }
|
||||
// occupyable = rem;
|
||||
// /*for(std::set<int>::const_iterator it = rem.begin(); it != rem.end(); ++it)
|
||||
// {
|
||||
// accessibility[*it] = true;
|
||||
// }*/
|
||||
// }
|
||||
// }
|
||||
|
||||
// bool BattleInfo::isAccessible(BattleHex hex, bool * accessibility, bool twoHex, bool attackerOwned, bool flying, bool lastPos)
|
||||
// {
|
||||
// if(flying && !lastPos)
|
||||
// return true;
|
||||
//
|
||||
// if(twoHex)
|
||||
// {
|
||||
// //if given hex is accessible and appropriate adjacent one is free too
|
||||
// return accessibility[hex] && accessibility[hex + (attackerOwned ? -1 : 1 )];
|
||||
// }
|
||||
// else
|
||||
// {
|
||||
// return accessibility[hex];
|
||||
// }
|
||||
// }
|
||||
|
||||
// void BattleInfo::makeBFS(BattleHex start, bool *accessibility, BattleHex *predecessor, int *dists, bool twoHex, bool attackerOwned, bool flying, bool fillPredecessors) const //both pointers must point to the at least 187-elements int arrays
|
||||
// {
|
||||
// std::set<BattleHex> quicksands = getStoppers(!attackerOwned);
|
||||
//
|
||||
// //inits
|
||||
// for(int b=0; b<GameConstants::BFIELD_SIZE; ++b)
|
||||
// predecessor[b] = -1;
|
||||
// for(int g=0; g<GameConstants::BFIELD_SIZE; ++g)
|
||||
// dists[g] = 100000000;
|
||||
//
|
||||
// std::queue< std::pair<BattleHex, bool> > hexq; //bfs queue <hex, accessible> (second filed used only if fillPredecessors is true)
|
||||
// hexq.push(std::make_pair(start, true));
|
||||
// dists[hexq.front().first] = 0;
|
||||
// int curNext = -1; //for bfs loop only (helper var)
|
||||
// while(!hexq.empty()) //bfs loop
|
||||
// {
|
||||
// std::pair<BattleHex, bool> curHex = hexq.front();
|
||||
// std::vector<BattleHex> neighbours = curHex.first.neighbouringTiles();
|
||||
// hexq.pop();
|
||||
// if(curHex.first != start && !flying && vstd::contains(quicksands, curHex.first)) //walking stack can't step past the quicksands
|
||||
// continue;
|
||||
//
|
||||
// for(ui32 nr=0; nr<neighbours.size(); nr++)
|
||||
// {
|
||||
// curNext = neighbours[nr]; //if(!accessibility[curNext] || (dists[curHex]+1)>=dists[curNext])
|
||||
// bool accessible = isAccessible(curNext, accessibility, twoHex, attackerOwned, flying, dists[curHex.first]+1 == dists[curNext]);
|
||||
// if( dists[curHex.first]+1 >= dists[curNext] )
|
||||
// continue;
|
||||
// if(accessible && curHex.second)
|
||||
// {
|
||||
// hexq.push(std::make_pair(curNext, true));
|
||||
// dists[curNext] = dists[curHex.first] + 1;
|
||||
// }
|
||||
// else if(fillPredecessors && !(accessible && !curHex.second))
|
||||
// {
|
||||
// hexq.push(std::make_pair(curNext, false));
|
||||
// dists[curNext] = dists[curHex.first] + 1;
|
||||
// }
|
||||
// predecessor[curNext] = curHex.first;
|
||||
// }
|
||||
// }
|
||||
// };
|
||||
//
|
||||
|
||||
BattleHex BattleInfo::getClosestTile(bool attackerOwned, BattleHex initialPos, std::set<BattleHex> & possibilities) const
|
||||
{
|
||||
std::vector<BattleHex> sortedTiles (possibilities.begin(), possibilities.end()); //set can't be sorted properly :(
|
||||
@@ -460,56 +309,6 @@ CStack * BattleInfo::generateNewStack(const CStackBasicDescriptor &base, bool at
|
||||
return ret;
|
||||
}
|
||||
|
||||
// std::pair<const CStack *, BattleHex> BattleInfo::getNearestStack(const CStack * closest, boost::logic::tribool attackerOwned) const
|
||||
// {
|
||||
// bool ac[GameConstants::BFIELD_SIZE];
|
||||
// std::set<BattleHex> occupyable;
|
||||
//
|
||||
// getAccessibilityMap(ac, closest->doubleWide(), closest->attackerOwned, false, occupyable, closest->hasBonusOfType(Bonus::FLYING), closest);
|
||||
//
|
||||
// BattleHex predecessor[GameConstants::BFIELD_SIZE];
|
||||
// int dist[GameConstants::BFIELD_SIZE];
|
||||
// makeBFS(closest->position, ac, predecessor, dist, closest->doubleWide(), closest->attackerOwned, closest->hasBonusOfType(Bonus::FLYING), true);
|
||||
//
|
||||
// std::vector< std::pair< std::pair<int, int>, const CStack *> > stackPairs; //pairs <<distance, hex>, stack>
|
||||
// for(int g=0; g<GameConstants::BFIELD_SIZE; ++g)
|
||||
// {
|
||||
// const CStack * atG = getStackT(g);
|
||||
// if(!atG || atG->ID == closest->ID) //if there is not stack or we are the closest one
|
||||
// continue;
|
||||
// if(boost::logic::indeterminate(attackerOwned) || atG->attackerOwned == attackerOwned)
|
||||
// {
|
||||
// if(predecessor[g] == -1) //TODO: is it really the best solution?
|
||||
// continue;
|
||||
// stackPairs.push_back( std::make_pair( std::make_pair(dist[predecessor[g]], g), atG) );
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// if(stackPairs.size() > 0)
|
||||
// {
|
||||
// std::vector< std::pair< std::pair<int, int>, const CStack *> > minimalPairs;
|
||||
// minimalPairs.push_back(stackPairs[0]);
|
||||
//
|
||||
// for(int b=1; b<stackPairs.size(); ++b)
|
||||
// {
|
||||
// if(stackPairs[b].first.first < minimalPairs[0].first.first)
|
||||
// {
|
||||
// minimalPairs.clear();
|
||||
// minimalPairs.push_back(stackPairs[b]);
|
||||
// }
|
||||
// else if(stackPairs[b].first.first == minimalPairs[0].first.first)
|
||||
// {
|
||||
// minimalPairs.push_back(stackPairs[b]);
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// std::pair< std::pair<int, int>, const CStack *> minPair = minimalPairs[minimalPairs.size()/2];
|
||||
//
|
||||
// return std::make_pair(minPair.second, predecessor[minPair.first.second]);
|
||||
// }
|
||||
//
|
||||
// return std::make_pair<const CStack * , BattleHex>(NULL, BattleHex::INVALID);
|
||||
// }
|
||||
ui32 BattleInfo::calculateSpellBonus(ui32 baseDamage, const CSpell * sp, const CGHeroInstance * caster, const CStack * affectedCreature) const
|
||||
{
|
||||
ui32 ret = baseDamage;
|
||||
|
||||
Reference in New Issue
Block a user