games/vcmi
1
0
Fork 0
mirror of https://github.com/vcmi/vcmi.git synced 2025-10-31 00:07:39 +02:00
Code Issues Releases Activity

Changes according to review

Browse Source
This commit is contained in:
Ivan Savenko
2022-12-13 15:10:31 +02:00
parent 264f5c91e8
commit 99e5569ab5
11 changed files with 45 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
Global.h
View File

@@ -543,6 +543,12 @@ namespace vstd
return *itr; return *itr;
} }
template <typename Container, typename Item>
bool erase(Container &c, const Item &item)
{
c.erase(boost::remove(c, item), c.end());
}
template<typename Range, typename Predicate> template<typename Range, typename Predicate>
void erase_if(Range &vec, Predicate pred) void erase_if(Range &vec, Predicate pred)
{ {
@@ -704,12 +710,6 @@ namespace vstd
return false; return false;
} }
template <typename Container, typename Pred>
void erase(Container &c, Pred pred)
{
c.erase(boost::remove_if(c, pred), c.end());
}
template<typename T> template<typename T>
void removeDuplicates(std::vector<T> &vec) void removeDuplicates(std::vector<T> &vec)
{ {

10
client/battle/BattleAnimationClasses.cpp
View File

@@ -1176,13 +1176,9 @@ void CPointEffectAnimation::clearEffect()
{ {
auto & effects = owner.effectsController->battleEffects; auto & effects = owner.effectsController->battleEffects;
for ( auto it = effects.begin(); it != effects.end(); ) vstd::erase_if(effects, [&](const BattleEffect & effect){
{ return effect.effectID == ID;
if (it->effectID == ID) });
it = effects.erase(it);
else
it++;
}
} }
CPointEffectAnimation::~CPointEffectAnimation() CPointEffectAnimation::~CPointEffectAnimation()

2
client/battle/BattleEffectsController.cpp
View File

@@ -127,7 +127,7 @@ void BattleEffectsController::collectRenderableObjects(BattleRenderer & renderer
{ {
for (auto & elem : battleEffects) for (auto & elem : battleEffects)
{ {
renderer.insert( EBattleFieldLayer::EFFECTS, elem.position, [&elem](BattleRenderer::RendererPtr canvas) renderer.insert( EBattleFieldLayer::EFFECTS, elem.position, [&elem](BattleRenderer::RendererRef canvas)
{ {
int currentFrame = static_cast<int>(floor(elem.currentFrame)); int currentFrame = static_cast<int>(floor(elem.currentFrame));
currentFrame %= elem.animation->size(); currentFrame %= elem.animation->size();

4
client/battle/BattleInterface.cpp
View File

@@ -918,14 +918,14 @@ void BattleInterface::collectRenderableObjects(BattleRenderer & renderer)
{ {
if (attackingHero) if (attackingHero)
{ {
renderer.insert(EBattleFieldLayer::HEROES, BattleHex(0),[this](BattleRenderer::RendererPtr canvas) renderer.insert(EBattleFieldLayer::HEROES, BattleHex(0),[this](BattleRenderer::RendererRef canvas)
{ {
attackingHero->render(canvas); attackingHero->render(canvas);
}); });
} }
if (defendingHero) if (defendingHero)
{ {
renderer.insert(EBattleFieldLayer::HEROES, BattleHex(GameConstants::BFIELD_WIDTH-1),[this](BattleRenderer::RendererPtr canvas) renderer.insert(EBattleFieldLayer::HEROES, BattleHex(GameConstants::BFIELD_WIDTH-1),[this](BattleRenderer::RendererRef canvas)
{ {
defendingHero->render(canvas); defendingHero->render(canvas);
}); });

2
client/battle/BattleObstacleController.cpp
View File

@@ -138,7 +138,7 @@ void BattleObstacleController::collectRenderableObjects(BattleRenderer & rendere
if (obstacle->obstacleType == CObstacleInstance::MOAT) if (obstacle->obstacleType == CObstacleInstance::MOAT)
continue; continue;
renderer.insert(EBattleFieldLayer::OBSTACLES, obstacle->pos, [this, obstacle]( BattleRenderer::RendererPtr canvas ){ renderer.insert(EBattleFieldLayer::OBSTACLES, obstacle->pos, [this, obstacle]( BattleRenderer::RendererRef canvas ){
auto img = getObstacleImage(*obstacle); auto img = getObstacleImage(*obstacle);
if(img) if(img)
{ {

10
client/battle/BattleProjectileController.cpp
View File

@@ -230,13 +230,11 @@ void BattleProjectileController::showProjectiles(Canvas & canvas)
auto projectile = *it; auto projectile = *it;
if ( projectile->playing ) if ( projectile->playing )
projectile->show(canvas); projectile->show(canvas);
// finished flying
if ( projectile->step > projectile->steps)
it = projectiles.erase(it);
else
it++;
} }
vstd::erase_if(projectiles, [&](const std::shared_ptr<ProjectileBase> & projectile){
return projectile->step > projectile->steps;
});
} }
bool BattleProjectileController::hasActiveProjectile(const CStack * stack) const bool BattleProjectileController::hasActiveProjectile(const CStack * stack) const

4
client/battle/BattleRenderer.cpp
View File

@@ -47,7 +47,7 @@ void BattleRenderer::sortObjects()
}); });
} }
void BattleRenderer::renderObjects(BattleRenderer::RendererPtr targetCanvas) void BattleRenderer::renderObjects(BattleRenderer::RendererRef targetCanvas)
{ {
for (auto const & object : objects) for (auto const & object : objects)
object.functor(targetCanvas); object.functor(targetCanvas);
@@ -63,7 +63,7 @@ void BattleRenderer::insert(EBattleFieldLayer layer, BattleHex tile, BattleRende
objects.push_back({functor, layer, tile}); objects.push_back({functor, layer, tile});
} }
void BattleRenderer::execute(BattleRenderer::RendererPtr targetCanvas) void BattleRenderer::execute(BattleRenderer::RendererRef targetCanvas)
{ {
collectObjects(); collectObjects();
sortObjects(); sortObjects();

8
client/battle/BattleRenderer.h
View File

@@ -29,8 +29,8 @@ enum class EBattleFieldLayer {
class BattleRenderer class BattleRenderer
{ {
public: public:
using RendererPtr = Canvas &; using RendererRef = Canvas &;
using RenderFunctor = std::function<void(RendererPtr)>; using RenderFunctor = std::function<void(RendererRef)>;
private: private:
BattleInterface & owner; BattleInterface & owner;
@@ -45,10 +45,10 @@ private:
void collectObjects(); void collectObjects();
void sortObjects(); void sortObjects();
void renderObjects(RendererPtr targetCanvas); void renderObjects(RendererRef targetCanvas);
public: public:
BattleRenderer(BattleInterface & owner); BattleRenderer(BattleInterface & owner);
void insert(EBattleFieldLayer layer, BattleHex tile, RenderFunctor functor); void insert(EBattleFieldLayer layer, BattleHex tile, RenderFunctor functor);
void execute(RendererPtr targetCanvas); void execute(RendererRef targetCanvas);
}; };

6
client/battle/BattleSiegeController.cpp
View File

@@ -297,14 +297,14 @@ void BattleSiegeController::collectRenderableObjects(BattleRenderer & renderer)
wallPiece == EWallVisual::BOTTOM_BATTLEMENT || wallPiece == EWallVisual::BOTTOM_BATTLEMENT ||
wallPiece == EWallVisual::UPPER_BATTLEMENT) wallPiece == EWallVisual::UPPER_BATTLEMENT)
{ {
renderer.insert( EBattleFieldLayer::STACKS, getWallPiecePosition(wallPiece), [this, wallPiece](BattleRenderer::RendererPtr canvas){ renderer.insert( EBattleFieldLayer::STACKS, getWallPiecePosition(wallPiece), [this, wallPiece](BattleRenderer::RendererRef canvas){
owner.stacksController->showStack(canvas, getTurretStack(wallPiece)); owner.stacksController->showStack(canvas, getTurretStack(wallPiece));
}); });
renderer.insert( EBattleFieldLayer::BATTLEMENTS, getWallPiecePosition(wallPiece), [this, wallPiece](BattleRenderer::RendererPtr canvas){ renderer.insert( EBattleFieldLayer::BATTLEMENTS, getWallPiecePosition(wallPiece), [this, wallPiece](BattleRenderer::RendererRef canvas){
showWallPiece(canvas, wallPiece, owner.pos.topLeft()); showWallPiece(canvas, wallPiece, owner.pos.topLeft());
}); });
} }
renderer.insert( EBattleFieldLayer::WALLS, getWallPiecePosition(wallPiece), [this, wallPiece](BattleRenderer::RendererPtr canvas){ renderer.insert( EBattleFieldLayer::WALLS, getWallPiecePosition(wallPiece), [this, wallPiece](BattleRenderer::RendererRef canvas){
showWallPiece(canvas, wallPiece, owner.pos.topLeft()); showWallPiece(canvas, wallPiece, owner.pos.topLeft());
}); });

41
client/battle/BattleStacksController.cpp
View File

@@ -93,9 +93,9 @@ BattleStacksController::BattleStacksController(BattleInterface & owner):
} }
} }
BattleHex BattleStacksController::getStackCurrentPosition(const CStack * stack) BattleHex BattleStacksController::getStackCurrentPosition(const CStack * stack) const
{ {
if ( !stackAnimation[stack->ID]->isMoving()) if ( !stackAnimation.at(stack->ID)->isMoving())
return stack->getPosition(); return stack->getPosition();
if (stack->hasBonusOfType(Bonus::FLYING)) if (stack->hasBonusOfType(Bonus::FLYING))
@@ -132,13 +132,13 @@ void BattleStacksController::collectRenderableObjects(BattleRenderer & renderer)
auto layer = stackAnimation[stack->ID]->isDead() ? EBattleFieldLayer::CORPSES : EBattleFieldLayer::STACKS; auto layer = stackAnimation[stack->ID]->isDead() ? EBattleFieldLayer::CORPSES : EBattleFieldLayer::STACKS;
auto location = getStackCurrentPosition(stack); auto location = getStackCurrentPosition(stack);
renderer.insert(layer, location, [this, stack]( BattleRenderer::RendererPtr renderer ){ renderer.insert(layer, location, [this, stack]( BattleRenderer::RendererRef renderer ){
showStack(renderer, stack); showStack(renderer, stack);
}); });
if (stackNeedsAmountBox(stack)) if (stackNeedsAmountBox(stack))
{ {
renderer.insert(EBattleFieldLayer::STACK_AMOUNTS, location, [this, stack]( BattleRenderer::RendererPtr renderer ){ renderer.insert(EBattleFieldLayer::STACK_AMOUNTS, location, [this, stack]( BattleRenderer::RendererRef renderer ){
showStackAmountBox(renderer, stack); showStackAmountBox(renderer, stack);
}); });
} }
@@ -172,6 +172,9 @@ void BattleStacksController::stackReset(const CStack * stack)
void BattleStacksController::stackAdded(const CStack * stack) void BattleStacksController::stackAdded(const CStack * stack)
{ {
// Tower shooters have only their upper half visible
static const int turretCreatureAnimationHeight = 235;
stackFacingRight[stack->ID] = stack->side == BattleSide::ATTACKER; // must be set before getting stack position stackFacingRight[stack->ID] = stack->side == BattleSide::ATTACKER; // must be set before getting stack position
Point coords = getStackPositionAtHex(stack->getPosition(), stack); Point coords = getStackPositionAtHex(stack->getPosition(), stack);
@@ -183,7 +186,7 @@ void BattleStacksController::stackAdded(const CStack * stack)
const CCreature *turretCreature = owner.siegeController->getTurretCreature(); const CCreature *turretCreature = owner.siegeController->getTurretCreature();
stackAnimation[stack->ID] = AnimationControls::getAnimation(turretCreature); stackAnimation[stack->ID] = AnimationControls::getAnimation(turretCreature);
stackAnimation[stack->ID]->pos.h = 235; stackAnimation[stack->ID]->pos.h = turretCreatureAnimationHeight;
coords = owner.siegeController->getTurretCreaturePosition(stack->initialPosition); coords = owner.siegeController->getTurretCreaturePosition(stack->initialPosition);
} }
@@ -236,7 +239,7 @@ void BattleStacksController::setHoveredStack(const CStack *stack)
mouseHoveredStack = nullptr; mouseHoveredStack = nullptr;
} }
bool BattleStacksController::stackNeedsAmountBox(const CStack * stack) bool BattleStacksController::stackNeedsAmountBox(const CStack * stack) const
{ {
BattleHex currentActionTarget; BattleHex currentActionTarget;
if(owner.curInt->curAction) if(owner.curInt->curAction)
@@ -347,13 +350,7 @@ void BattleStacksController::updateBattleAnimations()
} }
bool hadAnimations = !currentAnimations.empty(); bool hadAnimations = !currentAnimations.empty();
for (auto it = currentAnimations.begin(); it != currentAnimations.end();) vstd::erase(currentAnimations, nullptr);
{
if (*it == nullptr)
it = currentAnimations.erase(it);
else
++it;
}
if (hadAnimations && currentAnimations.empty()) if (hadAnimations && currentAnimations.empty())
{ {
@@ -379,19 +376,15 @@ void BattleStacksController::stackActivated(const CStack *stack) //TODO: check i
void BattleStacksController::stackRemoved(uint32_t stackID) void BattleStacksController::stackRemoved(uint32_t stackID)
{ {
if (getActiveStack() != nullptr) if (getActiveStack() && getActiveStack()->ID == stackID)
{ {
if (getActiveStack()->ID == stackID) BattleAction *action = new BattleAction();
{ action->side = owner.defendingHeroInstance ? (owner.curInt->playerID == owner.defendingHeroInstance->tempOwner) : false;
BattleAction *action = new BattleAction(); action->actionType = EActionType::CANCEL;
action->side = owner.defendingHeroInstance ? (owner.curInt->playerID == owner.defendingHeroInstance->tempOwner) : false; action->stackNumber = getActiveStack()->ID;
action->actionType = EActionType::CANCEL; owner.givenCommand.setn(action);
action->stackNumber = getActiveStack()->ID; setActiveStack(nullptr);
owner.givenCommand.setn(action);
setActiveStack(nullptr);
}
} }
//todo: ensure that ghost stack animation has fadeout effect
} }
void BattleStacksController::stacksAreAttacked(std::vector<StackAttackedInfo> attackedInfos) void BattleStacksController::stacksAreAttacked(std::vector<StackAttackedInfo> attackedInfos)

4
client/battle/BattleStacksController.h
View File

@@ -71,9 +71,9 @@ class BattleStacksController
/// for giving IDs for animations /// for giving IDs for animations
ui32 animIDhelper; ui32 animIDhelper;
bool stackNeedsAmountBox(const CStack * stack); bool stackNeedsAmountBox(const CStack * stack) const;
void showStackAmountBox(Canvas & canvas, const CStack * stack); void showStackAmountBox(Canvas & canvas, const CStack * stack);
BattleHex getStackCurrentPosition(const CStack * stack); BattleHex getStackCurrentPosition(const CStack * stack) const;
std::shared_ptr<IImage> getStackAmountBox(const CStack * stack); std::shared_ptr<IImage> getStackAmountBox(const CStack * stack);