Cleaned up BattleAnimationClasses file

client/battle/BattleAnimationClasses.cpp

@@ -10,9 +10,6 @@
 #include "StdInc.h"
 #include "BattleAnimationClasses.h"
 
-#include <boost/math/constants/constants.hpp>
-
-#include "BattleInterfaceClasses.h"
 #include "BattleInterface.h"
 #include "BattleProjectileController.h"
 #include "BattleSiegeController.h"
@@ -24,17 +21,13 @@
 #include "../CGameInfo.h"
 #include "../CMusicHandler.h"
 #include "../CPlayerInterface.h"
-#include "../Graphics.h"
-#include "../gui/CAnimation.h"
 #include "../gui/CCursorHandler.h"
 #include "../gui/CGuiHandler.h"
 
 #include "../../CCallback.h"
 #include "../../lib/CStack.h"
-#include "../../lib/CTownHandler.h"
-#include "../../lib/mapObjects/CGTownInstance.h"
 
-CBattleAnimation::CBattleAnimation(BattleInterface & owner)
+BattleAnimation::BattleAnimation(BattleInterface & owner)
 	: owner(owner),
 	  ID(owner.stacksController->animIDhelper++),
 	  initialized(false)
@@ -42,7 +35,7 @@ CBattleAnimation::CBattleAnimation(BattleInterface & owner)
 	logAnim->trace("Animation #%d created", ID);
 }
 
-bool CBattleAnimation::tryInitialize()
+bool BattleAnimation::tryInitialize()
 {
 	assert(!initialized);
 
@@ -54,12 +47,12 @@ bool CBattleAnimation::tryInitialize()
 	return false;
 }
 
-bool CBattleAnimation::isInitialized()
+bool BattleAnimation::isInitialized()
 {
 	return initialized;
 }
 
-CBattleAnimation::~CBattleAnimation()
+BattleAnimation::~BattleAnimation()
 {
 	logAnim->trace("Animation #%d ended, type is %s", ID, typeid(this).name());
 	for(auto & elem : pendingAnimations())
@@ -70,42 +63,37 @@ CBattleAnimation::~CBattleAnimation()
 	logAnim->trace("Animation #%d deleted", ID);
 }
 
-std::vector<CBattleAnimation *> & CBattleAnimation::pendingAnimations()
+std::vector<BattleAnimation *> & BattleAnimation::pendingAnimations()
 {
 	return owner.stacksController->currentAnimations;
 }
 
-std::shared_ptr<CreatureAnimation> CBattleAnimation::stackAnimation(const CStack * stack) const
+std::shared_ptr<CreatureAnimation> BattleAnimation::stackAnimation(const CStack * stack) const
 {
 	return owner.stacksController->stackAnimation[stack->ID];
 }
 
-bool CBattleAnimation::stackFacingRight(const CStack * stack)
+bool BattleAnimation::stackFacingRight(const CStack * stack)
 {
 	return owner.stacksController->stackFacingRight[stack->ID];
 }
 
-void CBattleAnimation::setStackFacingRight(const CStack * stack, bool facingRight)
+void BattleAnimation::setStackFacingRight(const CStack * stack, bool facingRight)
 {
 	owner.stacksController->stackFacingRight[stack->ID] = facingRight;
 }
 
-CBattleStackAnimation::CBattleStackAnimation(BattleInterface & owner, const CStack * stack)
-	: CBattleAnimation(owner),
+BattleStackAnimation::BattleStackAnimation(BattleInterface & owner, const CStack * stack)
+	: BattleAnimation(owner),
 	  myAnim(stackAnimation(stack)),
 	  stack(stack)
 {
 	assert(myAnim);
 }
 
-void CBattleStackAnimation::shiftColor(const ColorShifter * shifter)
-{
-	assert(myAnim);
-	myAnim->shiftColor(shifter);
-}
-
-void CAttackAnimation::nextFrame()
+void AttackAnimation::nextFrame()
 {
+	assert(myAnim->getType() == group);
 	if(myAnim->getType() != group)
 	{
 		myAnim->setType(group);
@@ -114,20 +102,17 @@ void CAttackAnimation::nextFrame()
 
 	if(!soundPlayed)
 	{
-		if(shooting)
-			CCS->soundh->playSound(battle_sound(getCreature(), shoot));
-		else
-			CCS->soundh->playSound(battle_sound(getCreature(), attack));
+		playSound();
 		soundPlayed = true;
 	}
 }
 
-CAttackAnimation::~CAttackAnimation()
+AttackAnimation::~AttackAnimation()
 {
 	myAnim->setType(ECreatureAnimType::HOLDING);
 }
 
-const CCreature * CAttackAnimation::getCreature() const
+const CCreature * AttackAnimation::getCreature() const
 {
 	if (attackingStack->getCreature()->idNumber == CreatureID::ARROW_TOWERS)
 		return owner.siegeController->getTurretCreature();
@@ -135,101 +120,97 @@ const CCreature * CAttackAnimation::getCreature() const
 		return attackingStack->getCreature();
 }
 
-CAttackAnimation::CAttackAnimation(BattleInterface & owner, const CStack *attacker, BattleHex _dest, const CStack *defender)
-	: CBattleStackAnimation(owner, attacker),
-	  shooting(false),
+
+AttackAnimation::AttackAnimation(BattleInterface & owner, const CStack *attacker, BattleHex _dest, const CStack *defender)
+	: BattleStackAnimation(owner, attacker),
 	  group(ECreatureAnimType::SHOOT_FRONT),
 	  soundPlayed(false),
 	  dest(_dest),
-	  attackedStack(defender),
+	  defendingStack(defender),
 	  attackingStack(attacker)
 {
 	assert(attackingStack && "attackingStack is nullptr in CBattleAttack::CBattleAttack !\n");
 	attackingStackPosBeforeReturn = attackingStack->getPosition();
 }
 
-CDefenceAnimation::CDefenceAnimation(StackAttackedInfo _attackedInfo, BattleInterface & owner)
-	: CBattleStackAnimation(owner, _attackedInfo.defender),
-	  attacker(_attackedInfo.attacker),
-	  rangedAttack(_attackedInfo.indirectAttack),
-	  killed(_attackedInfo.killed)
+bool HittedAnimation::init()
+{
+	CCS->soundh->playSound(battle_sound(stack->getCreature(), wince));
+	myAnim->playOnce(ECreatureAnimType::HITTED);
+	myAnim->onAnimationReset += [&](){ delete this; };
+	return true;
+}
+
+HittedAnimation::HittedAnimation(BattleInterface & owner, const CStack * stack)
+	: BattleStackAnimation(owner, stack)
 {
-	logAnim->debug("Created defence anim for %s", _attackedInfo.defender->getName());
 }
 
-bool CDefenceAnimation::init()
+DefenceAnimation::DefenceAnimation(BattleInterface & owner, const CStack * stack)
+	: BattleStackAnimation(owner, stack)
 {
-	logAnim->info("CDefenceAnimation::init: stack %s", stack->getName());
+}
 
-	CCS->soundh->playSound(getMySound());
-	myAnim->setType(getMyAnimType());
+bool DefenceAnimation::init()
+{
+	CCS->soundh->playSound(battle_sound(stack->getCreature(), defend));
+	myAnim->playOnce(ECreatureAnimType::DEFENCE);
 	myAnim->onAnimationReset += [&](){ delete this; };
 
 	return true; //initialized successfuly
 }
 
-std::string CDefenceAnimation::getMySound()
+ECreatureAnimType::Type DeathAnimation::getMyAnimType()
 {
-	if(killed)
-		return battle_sound(stack->getCreature(), killed);
-	else if(stack->defendingAnim)
-		return battle_sound(stack->getCreature(), defend);
+	if(rangedAttack && myAnim->framesInGroup(ECreatureAnimType::DEATH_RANGED) > 0)
+		return ECreatureAnimType::DEATH_RANGED;
 	else
-		return battle_sound(stack->getCreature(), wince);
+		return ECreatureAnimType::DEATH;
 }
 
-ECreatureAnimType::Type CDefenceAnimation::getMyAnimType()
+bool DeathAnimation::init()
 {
-	if(killed)
-	{
-		if(rangedAttack && myAnim->framesInGroup(ECreatureAnimType::DEATH_RANGED) > 0)
-			return ECreatureAnimType::DEATH_RANGED;
-		else
-			return ECreatureAnimType::DEATH;
-	}
+	CCS->soundh->playSound(battle_sound(stack->getCreature(), killed));
+	myAnim->playOnce(getMyAnimType());
+	myAnim->onAnimationReset += [&](){ delete this; };
+	return true;
+}
 
-	if(stack->defendingAnim)
-		return ECreatureAnimType::DEFENCE;
-	else
-		return ECreatureAnimType::HITTED;
+DeathAnimation::DeathAnimation(BattleInterface & owner, const CStack * stack, bool ranged):
+	BattleStackAnimation(owner, stack),
+	rangedAttack(ranged)
+{
 }
 
-CDefenceAnimation::~CDefenceAnimation()
+DeathAnimation::~DeathAnimation()
 {
-	if(killed)
-	{
-		if(rangedAttack && myAnim->framesInGroup(ECreatureAnimType::DEAD_RANGED) > 0)
-			myAnim->setType(ECreatureAnimType::DEAD_RANGED);
-		else
-			myAnim->setType(ECreatureAnimType::DEAD);
-	}
+	if(rangedAttack && myAnim->framesInGroup(ECreatureAnimType::DEAD_RANGED) > 0)
+		myAnim->setType(ECreatureAnimType::DEAD_RANGED);
 	else
-	{
-		myAnim->setType(ECreatureAnimType::HOLDING);
-	}
+		myAnim->setType(ECreatureAnimType::DEAD);
 }
 
-CDummyAnimation::CDummyAnimation(BattleInterface & owner, int howManyFrames)
-	: CBattleAnimation(owner),
+DummyAnimation::DummyAnimation(BattleInterface & owner, int howManyFrames)
+	: BattleAnimation(owner),
 	  counter(0),
 	  howMany(howManyFrames)
 {
 	logAnim->debug("Created dummy animation for %d frames", howManyFrames);
 }
 
-bool CDummyAnimation::init()
+bool DummyAnimation::init()
 {
 	return true;
 }
 
-void CDummyAnimation::nextFrame()
+void DummyAnimation::nextFrame()
 {
 	counter++;
 	if(counter > howMany)
 		delete this;
 }
 
-bool CMeleeAttackAnimation::init()
+bool MeleeAttackAnimation::init()
 {
 	assert(attackingStack);
 	assert(!myAnim->isDeadOrDying());
@@ -240,10 +221,7 @@ bool CMeleeAttackAnimation::init()
 		return false;
 	}
 
-	logAnim->info("CMeleeAttackAnimation::init: stack %s -> stack %s", stack->getName(), attackedStack->getName());
-	//reversed
-
-	shooting = false;
+	logAnim->info("CMeleeAttackAnimation::init: stack %s -> stack %s", stack->getName(), defendingStack->getName());
 
 	static const ECreatureAnimType::Type mutPosToGroup[] =
 	{
@@ -270,15 +248,15 @@ bool CMeleeAttackAnimation::init()
 	int mutPos = BattleHex::mutualPosition(attackingStackPosBeforeReturn, dest);
 	if(mutPos == -1 && attackingStack->doubleWide())
 	{
-		mutPos = BattleHex::mutualPosition(attackingStackPosBeforeReturn + revShiftattacker, attackedStack->getPosition());
+		mutPos = BattleHex::mutualPosition(attackingStackPosBeforeReturn + revShiftattacker, defendingStack->getPosition());
 	}
-	if (mutPos == -1 && attackedStack->doubleWide())
+	if (mutPos == -1 && defendingStack->doubleWide())
 	{
-		mutPos = BattleHex::mutualPosition(attackingStackPosBeforeReturn, attackedStack->occupiedHex());
+		mutPos = BattleHex::mutualPosition(attackingStackPosBeforeReturn, defendingStack->occupiedHex());
 	}
-	if (mutPos == -1 && attackedStack->doubleWide() && attackingStack->doubleWide())
+	if (mutPos == -1 && defendingStack->doubleWide() && attackingStack->doubleWide())
 	{
-		mutPos = BattleHex::mutualPosition(attackingStackPosBeforeReturn + revShiftattacker, attackedStack->occupiedHex());
+		mutPos = BattleHex::mutualPosition(attackingStackPosBeforeReturn + revShiftattacker, defendingStack->occupiedHex());
 	}
 
 
@@ -308,7 +286,7 @@ bool CMeleeAttackAnimation::init()
 	return true;
 }
 
-void CMeleeAttackAnimation::nextFrame()
+void MeleeAttackAnimation::nextFrame()
 {
 	size_t currentFrame = stackAnimation(attackingStack)->getCurrentFrame();
 	size_t totalFrames = stackAnimation(attackingStack)->framesInGroup(group);
@@ -318,24 +296,28 @@ void CMeleeAttackAnimation::nextFrame()
 		if(owner.getAnimationCondition(EAnimationEvents::HIT) == false)
 			owner.setAnimationCondition(EAnimationEvents::HIT, true);
 	}
+	AttackAnimation::nextFrame();
+}
 
-	CAttackAnimation::nextFrame();
+void MeleeAttackAnimation::playSound()
+{
+	CCS->soundh->playSound(battle_sound(getCreature(), attack));
 }
 
-CMeleeAttackAnimation::CMeleeAttackAnimation(BattleInterface & owner, const CStack * attacker, BattleHex _dest, const CStack * _attacked)
-	: CAttackAnimation(owner, attacker, _dest, _attacked)
+MeleeAttackAnimation::MeleeAttackAnimation(BattleInterface & owner, const CStack * attacker, BattleHex _dest, const CStack * _attacked)
+	: AttackAnimation(owner, attacker, _dest, _attacked)
 {
 	logAnim->debug("Created melee attack anim for %s", attacker->getName());
 }
 
-CStackMoveAnimation::CStackMoveAnimation(BattleInterface & owner, const CStack * _stack, BattleHex _currentHex):
-	CBattleStackAnimation(owner, _stack),
+StackMoveAnimation::StackMoveAnimation(BattleInterface & owner, const CStack * _stack, BattleHex _currentHex):
+	BattleStackAnimation(owner, _stack),
 	currentHex(_currentHex)
 {
 
 }
 
-bool CMovementAnimation::init()
+bool MovementAnimation::init()
 {
 	assert(stack);
 	assert(!myAnim->isDeadOrDying());
@@ -395,7 +377,7 @@ bool CMovementAnimation::init()
 	return true;
 }
 
-void CMovementAnimation::nextFrame()
+void MovementAnimation::nextFrame()
 {
 	progress += float(GH.mainFPSmng->getElapsedMilliseconds()) / 1000 * timeToMove;
 
@@ -403,7 +385,7 @@ void CMovementAnimation::nextFrame()
 	myAnim->pos.x = static_cast<Sint16>(begX + distanceX * progress );
 	myAnim->pos.y = static_cast<Sint16>(begY + distanceY * progress );
 
-	CBattleAnimation::nextFrame();
+	BattleAnimation::nextFrame();
 
 	if(progress >= 1.0)
 	{
@@ -427,7 +409,7 @@ void CMovementAnimation::nextFrame()
 	}
 }
 
-CMovementAnimation::~CMovementAnimation()
+MovementAnimation::~MovementAnimation()
 {
 	assert(stack);
 
@@ -440,8 +422,8 @@ CMovementAnimation::~CMovementAnimation()
 	}
 }
 
-CMovementAnimation::CMovementAnimation(BattleInterface & owner, const CStack *_stack, std::vector<BattleHex> _destTiles, int _distance)
-	: CStackMoveAnimation(owner, _stack, _destTiles.front()),
+MovementAnimation::MovementAnimation(BattleInterface & owner, const CStack *_stack, std::vector<BattleHex> _destTiles, int _distance)
+	: StackMoveAnimation(owner, _stack, _destTiles.front()),
 	  destTiles(_destTiles),
 	  curentMoveIndex(0),
 	  oldPos(stack->getPosition()),
@@ -453,13 +435,13 @@ CMovementAnimation::CMovementAnimation(BattleInterface & owner, const CStack *_s
 	logAnim->debug("Created movement anim for %s", stack->getName());
 }
 
-CMovementEndAnimation::CMovementEndAnimation(BattleInterface & owner, const CStack * _stack, BattleHex destTile)
-: CStackMoveAnimation(owner, _stack, destTile)
+MovementEndAnimation::MovementEndAnimation(BattleInterface & owner, const CStack * _stack, BattleHex destTile)
+: StackMoveAnimation(owner, _stack, destTile)
 {
 	logAnim->debug("Created movement end anim for %s", stack->getName());
 }
 
-bool CMovementEndAnimation::init()
+bool MovementEndAnimation::init()
 {
 	assert(stack);
 	assert(!myAnim->isDeadOrDying());
@@ -487,7 +469,7 @@ bool CMovementEndAnimation::init()
 	return true;
 }
 
-CMovementEndAnimation::~CMovementEndAnimation()
+MovementEndAnimation::~MovementEndAnimation()
 {
 	if(myAnim->getType() != ECreatureAnimType::DEAD)
 		myAnim->setType(ECreatureAnimType::HOLDING); //resetting to default
@@ -495,13 +477,13 @@ CMovementEndAnimation::~CMovementEndAnimation()
 	CCS->curh->show();
 }
 
-CMovementStartAnimation::CMovementStartAnimation(BattleInterface & owner, const CStack * _stack)
-	: CStackMoveAnimation(owner, _stack, _stack->getPosition())
+MovementStartAnimation::MovementStartAnimation(BattleInterface & owner, const CStack * _stack)
+	: StackMoveAnimation(owner, _stack, _stack->getPosition())
 {
 	logAnim->debug("Created movement start anim for %s", stack->getName());
 }
 
-bool CMovementStartAnimation::init()
+bool MovementStartAnimation::init()
 {
 	assert(stack);
 	assert(!myAnim->isDeadOrDying());
@@ -526,13 +508,13 @@ bool CMovementStartAnimation::init()
 	return true;
 }
 
-CReverseAnimation::CReverseAnimation(BattleInterface & owner, const CStack * stack, BattleHex dest)
-	: CStackMoveAnimation(owner, stack, dest)
+ReverseAnimation::ReverseAnimation(BattleInterface & owner, const CStack * stack, BattleHex dest)
+	: StackMoveAnimation(owner, stack, dest)
 {
 	logAnim->debug("Created reverse anim for %s", stack->getName());
 }
 
-bool CReverseAnimation::init()
+bool ReverseAnimation::init()
 {
 	assert(myAnim);
 	assert(!myAnim->isDeadOrDying());
@@ -547,7 +529,7 @@ bool CReverseAnimation::init()
 	if(myAnim->framesInGroup(ECreatureAnimType::TURN_L))
 	{
 		myAnim->playOnce(ECreatureAnimType::TURN_L);
-		myAnim->onAnimationReset += std::bind(&CReverseAnimation::setupSecondPart, this);
+		myAnim->onAnimationReset += std::bind(&ReverseAnimation::setupSecondPart, this);
 	}
 	else
 	{
@@ -556,14 +538,14 @@ bool CReverseAnimation::init()
 	return true;
 }
 
-void CBattleStackAnimation::rotateStack(BattleHex hex)
+void BattleStackAnimation::rotateStack(BattleHex hex)
 {
 	setStackFacingRight(stack, !stackFacingRight(stack));
 
 	stackAnimation(stack)->pos = owner.stacksController->getStackPositionAtHex(hex, stack);
 }
 
-void CReverseAnimation::setupSecondPart()
+void ReverseAnimation::setupSecondPart()
 {
 	assert(stack);
 
@@ -584,7 +566,7 @@ void CReverseAnimation::setupSecondPart()
 		delete this;
 }
 
-bool CResurrectionAnimation::init()
+bool ResurrectionAnimation::init()
 {
 	assert(stack);
 
@@ -601,19 +583,24 @@ bool CResurrectionAnimation::init()
 	return true;
 }
 
-CResurrectionAnimation::CResurrectionAnimation(BattleInterface & owner, const CStack * stack):
-	CBattleStackAnimation(owner, stack)
+ResurrectionAnimation::ResurrectionAnimation(BattleInterface & owner, const CStack * _stack):
+	BattleStackAnimation(owner, _stack)
 {
 
 }
 
-CRangedAttackAnimation::CRangedAttackAnimation(BattleInterface & owner, const CStack * attacker, BattleHex dest_, const CStack * defender)
-	: CAttackAnimation(owner, attacker, dest_, defender),
+RangedAttackAnimation::RangedAttackAnimation(BattleInterface & owner_, const CStack * attacker, BattleHex dest_, const CStack * defender)
+	: AttackAnimation(owner_, attacker, dest_, defender),
 	  projectileEmitted(false)
 {
 }
 
-bool CRangedAttackAnimation::init()
+void RangedAttackAnimation::playSound()
+{
+	CCS->soundh->playSound(battle_sound(getCreature(), shoot));
+}
+
+bool RangedAttackAnimation::init()
 {
 	assert(attackingStack);
 	assert(!myAnim->isDeadOrDying());
@@ -630,14 +617,13 @@ bool CRangedAttackAnimation::init()
 
 	setAnimationGroup();
 	initializeProjectile();
-	shooting = true;
 	return true;
 }
 
-void CRangedAttackAnimation::setAnimationGroup()
+void RangedAttackAnimation::setAnimationGroup()
 {
 	Point shooterPos = stackAnimation(attackingStack)->pos.topLeft();
-	Point shotTarget = owner.stacksController->getStackPositionAtHex(dest, attackedStack);
+	Point shotTarget = owner.stacksController->getStackPositionAtHex(dest, defendingStack);
 
 	//maximal angle in radians between straight horizontal line and shooting line for which shot is considered to be straight (absoulte value)
 	static const double straightAngle = 0.2;
@@ -653,10 +639,10 @@ void CRangedAttackAnimation::setAnimationGroup()
 		group = getForwardGroup();
 }
 
-void CRangedAttackAnimation::initializeProjectile()
+void RangedAttackAnimation::initializeProjectile()
 {
 	const CCreature *shooterInfo = getCreature();
-	Point shotTarget = owner.stacksController->getStackPositionAtHex(dest, attackedStack) + Point(225, 225);
+	Point shotTarget = owner.stacksController->getStackPositionAtHex(dest, defendingStack) + Point(225, 225);
 	Point shotOrigin = stackAnimation(attackingStack)->pos.topLeft() + Point(222, 265);
 	int multiplier = stackFacingRight(attackingStack) ? 1 : -1;
 
@@ -683,14 +669,14 @@ void CRangedAttackAnimation::initializeProjectile()
 	createProjectile(shotOrigin, shotTarget);
 }
 
-void CRangedAttackAnimation::emitProjectile()
+void RangedAttackAnimation::emitProjectile()
 {
 	logAnim->info("Ranged attack projectile emitted");
 	owner.projectilesController->emitStackProjectile(attackingStack);
 	projectileEmitted = true;
 }
 
-void CRangedAttackAnimation::nextFrame()
+void RangedAttackAnimation::nextFrame()
 {
 	// animation should be paused if there is an active projectile
 	if (projectileEmitted)
@@ -705,7 +691,7 @@ void CRangedAttackAnimation::nextFrame()
 		}
 	}
 
-	CAttackAnimation::nextFrame();
+	AttackAnimation::nextFrame();
 
 	if (!projectileEmitted)
 	{
@@ -719,7 +705,7 @@ void CRangedAttackAnimation::nextFrame()
 	}
 }
 
-CRangedAttackAnimation::~CRangedAttackAnimation()
+RangedAttackAnimation::~RangedAttackAnimation()
 {
 	//FIXME: this assert triggers under some unclear, rare conditions. Possibly - if game window is inactive and/or in foreground/minimized?
 	assert(!owner.projectilesController->hasActiveProjectile(attackingStack));
@@ -733,49 +719,49 @@ CRangedAttackAnimation::~CRangedAttackAnimation()
 	}
 }
 
-CShootingAnimation::CShootingAnimation(BattleInterface & owner, const CStack * attacker, BattleHex _dest, const CStack * _attacked)
-	: CRangedAttackAnimation(owner, attacker, _dest, _attacked)
+ShootingAnimation::ShootingAnimation(BattleInterface & owner, const CStack * attacker, BattleHex _dest, const CStack * _attacked)
+	: RangedAttackAnimation(owner, attacker, _dest, _attacked)
 {
 	logAnim->debug("Created shooting anim for %s", stack->getName());
 }
 
-void CShootingAnimation::createProjectile(const Point & from, const Point & dest) const
+void ShootingAnimation::createProjectile(const Point & from, const Point & dest) const
 {
 	owner.projectilesController->createProjectile(attackingStack, from, dest);
 }
 
-uint32_t CShootingAnimation::getAttackClimaxFrame() const
+uint32_t ShootingAnimation::getAttackClimaxFrame() const
 {
 	const CCreature *shooterInfo = getCreature();
 	return shooterInfo->animation.attackClimaxFrame;
 }
 
-ECreatureAnimType::Type CShootingAnimation::getUpwardsGroup() const
+ECreatureAnimType::Type ShootingAnimation::getUpwardsGroup() const
 {
 	return ECreatureAnimType::SHOOT_UP;
 }
 
-ECreatureAnimType::Type CShootingAnimation::getForwardGroup() const
+ECreatureAnimType::Type ShootingAnimation::getForwardGroup() const
 {
 	return ECreatureAnimType::SHOOT_FRONT;
 }
 
-ECreatureAnimType::Type CShootingAnimation::getDownwardsGroup() const
+ECreatureAnimType::Type ShootingAnimation::getDownwardsGroup() const
 {
 	return ECreatureAnimType::SHOOT_DOWN;
 }
 
-CCatapultAnimation::CCatapultAnimation(BattleInterface & owner, const CStack * attacker, BattleHex _dest, const CStack * _attacked, int _catapultDmg)
-	: CShootingAnimation(owner, attacker, _dest, _attacked),
+CatapultAnimation::CatapultAnimation(BattleInterface & owner, const CStack * attacker, BattleHex _dest, const CStack * _attacked, int _catapultDmg)
+	: ShootingAnimation(owner, attacker, _dest, _attacked),
 	catapultDamage(_catapultDmg),
 	explosionEmitted(false)
 {
 	logAnim->debug("Created shooting anim for %s", stack->getName());
 }
 
-void CCatapultAnimation::nextFrame()
+void CatapultAnimation::nextFrame()
 {
-	CShootingAnimation::nextFrame();
+	ShootingAnimation::nextFrame();
 
 	if ( explosionEmitted)
 		return;
@@ -787,21 +773,21 @@ void CCatapultAnimation::nextFrame()
 		return;
 
 	explosionEmitted = true;
-	Point shotTarget = owner.stacksController->getStackPositionAtHex(dest, attackedStack) + Point(225, 225) - Point(126, 105);
+	Point shotTarget = owner.stacksController->getStackPositionAtHex(dest, defendingStack) + Point(225, 225) - Point(126, 105);
 
 	if(catapultDamage > 0)
-		owner.stacksController->addNewAnim( new CPointEffectAnimation(owner, "WALLHIT", "SGEXPL.DEF", shotTarget));
+		owner.stacksController->addNewAnim( new PointEffectAnimation(owner, "WALLHIT", "SGEXPL.DEF", shotTarget));
 	else
-		owner.stacksController->addNewAnim( new CPointEffectAnimation(owner, "WALLMISS", "CSGRCK.DEF", shotTarget));
+		owner.stacksController->addNewAnim( new PointEffectAnimation(owner, "WALLMISS", "CSGRCK.DEF", shotTarget));
 }
 
-void CCatapultAnimation::createProjectile(const Point & from, const Point & dest) const
+void CatapultAnimation::createProjectile(const Point & from, const Point & dest) const
 {
 	owner.projectilesController->createCatapultProjectile(attackingStack, from, dest);
 }
 
-CCastAnimation::CCastAnimation(BattleInterface & owner, const CStack * attacker, BattleHex dest_, const CStack * defender, const CSpell * spell)
-	: CRangedAttackAnimation(owner, attacker, dest_, defender),
+CastAnimation::CastAnimation(BattleInterface & owner_, const CStack * attacker, BattleHex dest_, const CStack * defender, const CSpell * spell)
+	: RangedAttackAnimation(owner_, attacker, dest_, defender),
 	  spell(spell)
 {
 	assert(dest.isValid());// FIXME: when?
@@ -810,7 +796,7 @@ CCastAnimation::CCastAnimation(BattleInterface & owner, const CStack * attacker,
 		dest = defender->getPosition();
 }
 
-ECreatureAnimType::Type CCastAnimation::findValidGroup( const std::vector<ECreatureAnimType::Type> candidates ) const
+ECreatureAnimType::Type CastAnimation::findValidGroup( const std::vector<ECreatureAnimType::Type> candidates ) const
 {
 	for ( auto group : candidates)
 	{
@@ -822,7 +808,7 @@ ECreatureAnimType::Type CCastAnimation::findValidGroup( const std::vector<ECreat
 	return ECreatureAnimType::HOLDING;
 }
 
-ECreatureAnimType::Type CCastAnimation::getUpwardsGroup() const
+ECreatureAnimType::Type CastAnimation::getUpwardsGroup() const
 {
 	return findValidGroup({
 		ECreatureAnimType::VCMI_CAST_UP,
@@ -832,7 +818,7 @@ ECreatureAnimType::Type CCastAnimation::getUpwardsGroup() const
 	});
 }
 
-ECreatureAnimType::Type CCastAnimation::getForwardGroup() const
+ECreatureAnimType::Type CastAnimation::getForwardGroup() const
 {
 	return findValidGroup({
 		ECreatureAnimType::VCMI_CAST_FRONT,
@@ -842,7 +828,7 @@ ECreatureAnimType::Type CCastAnimation::getForwardGroup() const
 	});
 }
 
-ECreatureAnimType::Type CCastAnimation::getDownwardsGroup() const
+ECreatureAnimType::Type CastAnimation::getDownwardsGroup() const
 {
 	return findValidGroup({
 		ECreatureAnimType::VCMI_CAST_DOWN,
@@ -852,13 +838,13 @@ ECreatureAnimType::Type CCastAnimation::getDownwardsGroup() const
 	});
 }
 
-void CCastAnimation::createProjectile(const Point & from, const Point & dest) const
+void CastAnimation::createProjectile(const Point & from, const Point & dest) const
 {
 	if (!spell->animationInfo.projectile.empty())
 		owner.projectilesController->createSpellProjectile(attackingStack, from, dest, spell);
 }
 
-uint32_t CCastAnimation::getAttackClimaxFrame() const
+uint32_t CastAnimation::getAttackClimaxFrame() const
 {
 	//FIXME: allow defining this parameter in config file, separately from attackClimaxFrame of missile attacks
 	uint32_t maxFrames = stackAnimation(attackingStack)->framesInGroup(group);
@@ -868,8 +854,8 @@ uint32_t CCastAnimation::getAttackClimaxFrame() const
 	return 0;
 }
 
-CPointEffectAnimation::CPointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, int effects):
-	CBattleAnimation(owner),
+PointEffectAnimation::PointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, int effects):
+	BattleAnimation(owner),
 	animation(std::make_shared<CAnimation>(animationName)),
 	soundName(soundName),
 	effectFlags(effects),
@@ -880,40 +866,40 @@ CPointEffectAnimation::CPointEffectAnimation(BattleInterface & owner, std::strin
 	logAnim->info("CPointEffectAnimation::init: effect %s", animationName);
 }
 
-CPointEffectAnimation::CPointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, std::vector<BattleHex> hex, int effects):
-	CPointEffectAnimation(owner, soundName, animationName, effects)
+PointEffectAnimation::PointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, std::vector<BattleHex> hex, int effects):
+	PointEffectAnimation(owner, soundName, animationName, effects)
 {
 	battlehexes = hex;
 }
 
-CPointEffectAnimation::CPointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, BattleHex hex, int effects):
-	CPointEffectAnimation(owner, soundName, animationName, effects)
+PointEffectAnimation::PointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, BattleHex hex, int effects):
+	PointEffectAnimation(owner, soundName, animationName, effects)
 {
 	assert(hex.isValid());
 	battlehexes.push_back(hex);
 }
 
-CPointEffectAnimation::CPointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, std::vector<Point> pos, int effects):
-	CPointEffectAnimation(owner, soundName, animationName, effects)
+PointEffectAnimation::PointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, std::vector<Point> pos, int effects):
+	PointEffectAnimation(owner, soundName, animationName, effects)
 {
 	positions = pos;
 }
 
-CPointEffectAnimation::CPointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, Point pos, int effects):
-	CPointEffectAnimation(owner, soundName, animationName, effects)
+PointEffectAnimation::PointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, Point pos, int effects):
+	PointEffectAnimation(owner, soundName, animationName, effects)
 {
 	positions.push_back(pos);
 }
 
-CPointEffectAnimation::CPointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, Point pos, BattleHex hex,   int effects):
-	CPointEffectAnimation(owner, soundName, animationName, effects)
+PointEffectAnimation::PointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, Point pos, BattleHex hex,   int effects):
+	PointEffectAnimation(owner, soundName, animationName, effects)
 {
 	assert(hex.isValid());
 	battlehexes.push_back(hex);
 	positions.push_back(pos);
 }
 
-bool CPointEffectAnimation::init()
+bool PointEffectAnimation::init()
 {
 	animation->preload();
 
@@ -971,7 +957,7 @@ bool CPointEffectAnimation::init()
 	return true;
 }
 
-void CPointEffectAnimation::nextFrame()
+void PointEffectAnimation::nextFrame()
 {
 	playSound();
 	playEffect();
@@ -984,37 +970,37 @@ void CPointEffectAnimation::nextFrame()
 	}
 }
 
-bool CPointEffectAnimation::alignToBottom() const
+bool PointEffectAnimation::alignToBottom() const
 {
 	return effectFlags & ALIGN_TO_BOTTOM;
 }
 
-bool CPointEffectAnimation::waitForSound() const
+bool PointEffectAnimation::waitForSound() const
 {
 	return effectFlags & WAIT_FOR_SOUND;
 }
 
-bool CPointEffectAnimation::forceOnTop() const
+bool PointEffectAnimation::forceOnTop() const
 {
 	return effectFlags & FORCE_ON_TOP;
 }
 
-bool CPointEffectAnimation::screenFill() const
+bool PointEffectAnimation::screenFill() const
 {
 	return effectFlags & SCREEN_FILL;
 }
 
-void CPointEffectAnimation::onEffectFinished()
+void PointEffectAnimation::onEffectFinished()
 {
 	effectFinished = true;
 }
 
-void CPointEffectAnimation::onSoundFinished()
+void PointEffectAnimation::onSoundFinished()
 {
 	soundFinished = true;
 }
 
-void CPointEffectAnimation::playSound()
+void PointEffectAnimation::playSound()
 {
 	if (soundPlayed)
 		return;
@@ -1034,7 +1020,7 @@ void CPointEffectAnimation::playSound()
 		CCS->soundh->setCallback(channel, [&](){ onSoundFinished(); });
 }
 
-void CPointEffectAnimation::playEffect()
+void PointEffectAnimation::playEffect()
 {
 	if ( effectFinished )
 		return;
@@ -1055,7 +1041,7 @@ void CPointEffectAnimation::playEffect()
 	}
 }
 
-void CPointEffectAnimation::clearEffect()
+void PointEffectAnimation::clearEffect()
 {
 	auto & effects = owner.effectsController->battleEffects;
 
@@ -1064,17 +1050,13 @@ void CPointEffectAnimation::clearEffect()
 	});
 }
 
-CPointEffectAnimation::~CPointEffectAnimation()
+PointEffectAnimation::~PointEffectAnimation()
 {
 	assert(effectFinished);
 	assert(soundFinished);
 }
 
-CWaitingAnimation::CWaitingAnimation(BattleInterface & owner):
-	CBattleAnimation(owner)
-{}
-
-void CWaitingAnimation::nextFrame()
+void WaitingProjectileAnimation::nextFrame()
 {
 	// initialization conditions fulfilled, delay is over
 	if(owner.getAnimationCondition(EAnimationEvents::HIT) == false)
@@ -1083,16 +1065,16 @@ void CWaitingAnimation::nextFrame()
 	delete this;
 }
 
-CWaitingProjectileAnimation::CWaitingProjectileAnimation(BattleInterface & owner, const CStack * shooter):
-	CWaitingAnimation(owner),
+WaitingProjectileAnimation::WaitingProjectileAnimation(BattleInterface & owner_, const CStack * shooter):
+	BattleAnimation(owner_),
 	shooter(shooter)
 {}
 
-bool CWaitingProjectileAnimation::init()
+bool WaitingProjectileAnimation::init()
 {
 	for(auto & elem : pendingAnimations())
 	{
-		auto * attackAnim = dynamic_cast<CRangedAttackAnimation *>(elem);
+		auto * attackAnim = dynamic_cast<RangedAttackAnimation *>(elem);
 
 		if( attackAnim && shooter && attackAnim->stack->ID == shooter->ID && !attackAnim->isInitialized() )
 		{

client/battle/BattleAnimationClasses.h

@@ -10,7 +10,6 @@
 #pragma once
 
 #include "../../lib/battle/BattleHex.h"
-#include "../../lib/CSoundBase.h"
 #include "BattleConstants.h"
 
 VCMI_LIB_NAMESPACE_BEGIN
@@ -24,21 +23,17 @@ VCMI_LIB_NAMESPACE_END
 class CAnimation;
 class BattleInterface;
 class CreatureAnimation;
-class CBattleAnimation;
-struct CatapultProjectileInfo;
 struct StackAttackedInfo;
 struct Point;
-class ColorShifter;
 
 /// Base class of battle animations
-class CBattleAnimation
+class BattleAnimation
 {
-
 protected:
 	BattleInterface & owner;
 	bool initialized;
 
-	std::vector<CBattleAnimation *> & pendingAnimations();
+	std::vector<BattleAnimation *> & pendingAnimations();
 	std::shared_ptr<CreatureAnimation> stackAnimation(const CStack * stack) const;
 	bool stackFacingRight(const CStack * stack);
 	void setStackFacingRight(const CStack * stack, bool facingRight);
@@ -51,63 +46,71 @@ public:
 	bool isInitialized();
 	bool tryInitialize();
 	virtual void nextFrame() {} //call every new frame
-	virtual ~CBattleAnimation();
+	virtual ~BattleAnimation();
 
-	CBattleAnimation(BattleInterface & owner);
+	BattleAnimation(BattleInterface & owner);
 };
 
 /// Sub-class which is responsible for managing the battle stack animation.
-class CBattleStackAnimation : public CBattleAnimation
+class BattleStackAnimation : public BattleAnimation
 {
 public:
 	std::shared_ptr<CreatureAnimation> myAnim; //animation for our stack, managed by BattleInterface
 	const CStack * stack; //id of stack whose animation it is
 
-	CBattleStackAnimation(BattleInterface & owner, const CStack * _stack);
+	BattleStackAnimation(BattleInterface & owner, const CStack * _stack);
 
-	void shiftColor(const ColorShifter * shifter);
 	void rotateStack(BattleHex hex);
 };
 
 /// This class is responsible for managing the battle attack animation
-class CAttackAnimation : public CBattleStackAnimation
+class AttackAnimation : public BattleStackAnimation
 {
 	bool soundPlayed;
-
 protected:
 	BattleHex dest; //attacked hex
-	bool shooting;
-	ECreatureAnimType::Type group; //if shooting is true, print this animation group
-	const CStack *attackedStack;
+	ECreatureAnimType::Type group;
+	const CStack *defendingStack;
 	const CStack *attackingStack;
 	int attackingStackPosBeforeReturn; //for stacks with return_after_strike feature
 
 	const CCreature * getCreature() const;
 public:
-	void nextFrame() override;
+	virtual void playSound() = 0;
 
-	CAttackAnimation(BattleInterface & owner, const CStack *attacker, BattleHex _dest, const CStack *defender);
-	~CAttackAnimation();
+	void nextFrame() override;
+	AttackAnimation(BattleInterface & owner, const CStack *attacker, BattleHex _dest, const CStack *defender);
+	~AttackAnimation();
 };
 
 /// Animation of a defending unit
-class CDefenceAnimation : public CBattleStackAnimation
+class DefenceAnimation : public BattleStackAnimation
 {
-	ECreatureAnimType::Type getMyAnimType();
-	std::string getMySound();
-
-	const CStack * attacker; //attacking stack
-	bool rangedAttack; //if true, stack has been attacked by shooting
-	bool killed; //if true, stack has been killed
+public:
+	bool init() override;
+	DefenceAnimation(BattleInterface & owner, const CStack * stack);
+};
 
+/// Animation of a hit unit
+class HittedAnimation : public BattleStackAnimation
+{
 public:
+	HittedAnimation(BattleInterface & owner, const CStack * stack);
 	bool init() override;
+};
 
-	CDefenceAnimation(StackAttackedInfo _attackedInfo, BattleInterface & owner);
-	~CDefenceAnimation();
+/// Animation of a dying unit
+class DeathAnimation : public BattleStackAnimation
+{
+	bool rangedAttack;
+	ECreatureAnimType::Type getMyAnimType();
+public:
+	bool init() override;
+	DeathAnimation(BattleInterface & owner, const CStack * stack, bool ranged);
+	~DeathAnimation();
 };
 
-class CDummyAnimation : public CBattleAnimation
+class DummyAnimation : public BattleAnimation
 {
 private:
 	int counter;
@@ -116,31 +119,32 @@ public:
 	bool init() override;
 	void nextFrame() override;
 
-	CDummyAnimation(BattleInterface & owner, int howManyFrames);
+	DummyAnimation(BattleInterface & owner, int howManyFrames);
 };
 
 /// Hand-to-hand attack
-class CMeleeAttackAnimation : public CAttackAnimation
+class MeleeAttackAnimation : public AttackAnimation
 {
 public:
 	bool init() override;
 	void nextFrame() override;
+	void playSound() override;
 
-	CMeleeAttackAnimation(BattleInterface & owner, const CStack * attacker, BattleHex _dest, const CStack * _attacked);
+	MeleeAttackAnimation(BattleInterface & owner, const CStack * attacker, BattleHex _dest, const CStack * _attacked);
 };
 
 /// Base class for all animations that play during stack movement
-class CStackMoveAnimation : public CBattleStackAnimation
+class StackMoveAnimation : public BattleStackAnimation
 {
 public:
 	BattleHex currentHex;
 
 protected:
-	CStackMoveAnimation(BattleInterface & owner, const CStack * _stack, BattleHex _currentHex);
+	StackMoveAnimation(BattleInterface & owner, const CStack * _stack, BattleHex _currentHex);
 };
 
 /// Move animation of a creature
-class CMovementAnimation : public CStackMoveAnimation
+class MovementAnimation : public StackMoveAnimation
 {
 private:
 	std::vector<BattleHex> destTiles; //full path, includes already passed hexes
@@ -158,49 +162,49 @@ public:
 	bool init() override;
 	void nextFrame() override;
 
-	CMovementAnimation(BattleInterface & owner, const CStack *_stack, std::vector<BattleHex> _destTiles, int _distance);
-	~CMovementAnimation();
+	MovementAnimation(BattleInterface & owner, const CStack *_stack, std::vector<BattleHex> _destTiles, int _distance);
+	~MovementAnimation();
 };
 
 /// Move end animation of a creature
-class CMovementEndAnimation : public CStackMoveAnimation
+class MovementEndAnimation : public StackMoveAnimation
 {
 public:
 	bool init() override;
 
-	CMovementEndAnimation(BattleInterface & owner, const CStack * _stack, BattleHex destTile);
-	~CMovementEndAnimation();
+	MovementEndAnimation(BattleInterface & owner, const CStack * _stack, BattleHex destTile);
+	~MovementEndAnimation();
 };
 
 /// Move start animation of a creature
-class CMovementStartAnimation : public CStackMoveAnimation
+class MovementStartAnimation : public StackMoveAnimation
 {
 public:
 	bool init() override;
 
-	CMovementStartAnimation(BattleInterface & owner, const CStack * _stack);
+	MovementStartAnimation(BattleInterface & owner, const CStack * _stack);
 };
 
 /// Class responsible for animation of stack chaning direction (left <-> right)
-class CReverseAnimation : public CStackMoveAnimation
+class ReverseAnimation : public StackMoveAnimation
 {
 	void setupSecondPart();
 public:
 	bool init() override;
 
-	CReverseAnimation(BattleInterface & owner, const CStack * stack, BattleHex dest);
+	ReverseAnimation(BattleInterface & owner, const CStack * stack, BattleHex dest);
 };
 
 /// Resurrects stack from dead state
-class CResurrectionAnimation : public CBattleStackAnimation
+class ResurrectionAnimation : public BattleStackAnimation
 {
 public:
 	bool init() override;
 
-	CResurrectionAnimation(BattleInterface & owner, const CStack * _stack);
+	ResurrectionAnimation(BattleInterface & owner, const CStack * _stack);
 };
 
-class CRangedAttackAnimation : public CAttackAnimation
+class RangedAttackAnimation : public AttackAnimation
 {
 
 	void setAnimationGroup();
@@ -219,15 +223,16 @@ protected:
 	virtual uint32_t getAttackClimaxFrame() const = 0;
 
 public:
-	CRangedAttackAnimation(BattleInterface & owner, const CStack * attacker, BattleHex dest, const CStack * defender);
-	~CRangedAttackAnimation();
+	RangedAttackAnimation(BattleInterface & owner, const CStack * attacker, BattleHex dest, const CStack * defender);
+	~RangedAttackAnimation();
 
 	bool init() override;
 	void nextFrame() override;
+	void playSound() override;
 };
 
 /// Shooting attack
-class CShootingAnimation : public CRangedAttackAnimation
+class ShootingAnimation : public RangedAttackAnimation
 {
 	ECreatureAnimType::Type getUpwardsGroup() const override;
 	ECreatureAnimType::Type getForwardGroup() const override;
@@ -237,25 +242,25 @@ class CShootingAnimation : public CRangedAttackAnimation
 	uint32_t getAttackClimaxFrame() const override;
 
 public:
-	CShootingAnimation(BattleInterface & owner, const CStack * attacker, BattleHex dest, const CStack * defender);
+	ShootingAnimation(BattleInterface & owner, const CStack * attacker, BattleHex dest, const CStack * defender);
 
 };
 
 /// Catapult attack
-class CCatapultAnimation : public CShootingAnimation
+class CatapultAnimation : public ShootingAnimation
 {
 private:
 	bool explosionEmitted;
 	int catapultDamage;
 
 public:
-	CCatapultAnimation(BattleInterface & owner, const CStack * attacker, BattleHex dest, const CStack * defender, int _catapultDmg = 0);
+	CatapultAnimation(BattleInterface & owner, const CStack * attacker, BattleHex dest, const CStack * defender, int _catapultDmg = 0);
 
 	void createProjectile(const Point & from, const Point & dest) const override;
 	void nextFrame() override;
 };
 
-class CCastAnimation : public CRangedAttackAnimation
+class CastAnimation : public RangedAttackAnimation
 {
 	const CSpell * spell;
 
@@ -268,24 +273,11 @@ class CCastAnimation : public CRangedAttackAnimation
 	uint32_t getAttackClimaxFrame() const override;
 
 public:
-	CCastAnimation(BattleInterface & owner, const CStack * attacker, BattleHex dest_, const CStack * defender, const CSpell * spell);
-};
-
-struct CPointEffectParameters
-{
-	std::vector<Point> positions;
-	std::vector<BattleHex> tiles;
-	std::string animation;
-
-	soundBase::soundID sound = soundBase::invalid;
-	BattleHex boundHex = BattleHex::INVALID;
-	bool aligntoBottom = false;
-	bool waitForSound = false;
-	bool screenFill = false;
+	CastAnimation(BattleInterface & owner, const CStack * attacker, BattleHex dest_, const CStack * defender, const CSpell * spell);
 };
 
 /// Class that plays effect at one or more positions along with (single) sound effect
-class CPointEffectAnimation : public CBattleAnimation
+class PointEffectAnimation : public BattleAnimation
 {
 	std::string soundName;
 	bool soundPlayed;
@@ -313,44 +305,36 @@ public:
 	enum EEffectFlags
 	{
 		ALIGN_TO_BOTTOM = 1,
-		WAIT_FOR_SOUND  = 2,
+		WAIT_FOR_SOUND  = 2, // Unused, can be removed
 		FORCE_ON_TOP    = 4,
 		SCREEN_FILL     = 8,
 	};
 
 	/// Create animation with screen-wide effect
-	CPointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, int effects = 0);
+	PointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, int effects = 0);
 
 	/// Create animation positioned at point(s). Note that positions must be are absolute, including battleint position offset
-	CPointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, Point pos                 , int effects = 0);
-	CPointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, std::vector<Point> pos    , int effects = 0);
+	PointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, Point pos                 , int effects = 0);
+	PointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, std::vector<Point> pos    , int effects = 0);
 
 	/// Create animation positioned at certain hex(es)
-	CPointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, BattleHex hex             , int effects = 0);
-	CPointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, std::vector<BattleHex> hex, int effects = 0);
+	PointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, BattleHex hex             , int effects = 0);
+	PointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, std::vector<BattleHex> hex, int effects = 0);
 
-	CPointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, Point pos, BattleHex hex,   int effects = 0);
-	 ~CPointEffectAnimation();
+	PointEffectAnimation(BattleInterface & owner, std::string soundName, std::string animationName, Point pos, BattleHex hex,   int effects = 0);
+	 ~PointEffectAnimation();
 
 	bool init() override;
 	void nextFrame() override;
 };
 
-/// Base class (e.g. for use in dynamic_cast's) for "animations" that wait for certain event
-class CWaitingAnimation : public CBattleAnimation
-{
-protected:
-	CWaitingAnimation(BattleInterface & owner);
-public:
-	void nextFrame() override;
-};
-
 /// Class that waits till projectile of certain shooter hits a target
-class CWaitingProjectileAnimation : public CWaitingAnimation
+class WaitingProjectileAnimation : public BattleAnimation
 {
 	const CStack * shooter;
 public:
-	CWaitingProjectileAnimation(BattleInterface & owner, const CStack * shooter);
+	WaitingProjectileAnimation(BattleInterface & owner, const CStack * shooter);
 
+	void nextFrame() override;
 	bool init() override;
 };

client/battle/BattleEffectsController.cpp

@@ -44,7 +44,7 @@ void BattleEffectsController::displayEffect(EBattleEffect::EBattleEffect effect,
 {
 	std::string customAnim = graphics->battleACToDef[effect][0];
 
-	owner.stacksController->addNewAnim(new CPointEffectAnimation(owner, soundBase::stringsList()[soundID], customAnim, destTile));
+	owner.stacksController->addNewAnim(new PointEffectAnimation(owner, soundBase::stringsList()[soundID], customAnim, destTile));
 }
 
 void BattleEffectsController::displayCustomEffects(const std::vector<CustomEffectInfo> & customEffects)

client/battle/BattleEffectsController.h

@@ -24,7 +24,7 @@ class CAnimation;
 class Canvas;
 class BattleInterface;
 class BattleRenderer;
-class CPointEffectAnimation;
+class PointEffectAnimation;
 
 /// Struct for battle effect animation e.g. morale, prayer, armageddon, bless,...
 struct BattleEffect
@@ -59,5 +59,5 @@ public:
 
 	void collectRenderableObjects(BattleRenderer & renderer);
 
-	friend class CPointEffectAnimation;
+	friend class PointEffectAnimation;
 };

client/battle/BattleInterface.cpp

@@ -514,7 +514,7 @@ void BattleInterface::spellCast(const BattleSpellCast * sc)
 		{
 			executeOnAnimationCondition(EAnimationEvents::BEFORE_HIT, true, [=]()
 			{
-				stacksController->addNewAnim(new CCastAnimation(*this, casterStack, targetedTile, curInt->cb->battleGetStackByPos(targetedTile), spell));
+				stacksController->addNewAnim(new CastAnimation(*this, casterStack, targetedTile, curInt->cb->battleGetStackByPos(targetedTile), spell));
 				displaySpellCast(spellID, casterStack->getPosition());
 			});
 		}
@@ -533,7 +533,7 @@ void BattleInterface::spellCast(const BattleSpellCast * sc)
 			{
 				projectilesController->createSpellProjectile( nullptr, srccoord, destcoord, spell);
 				projectilesController->emitStackProjectile( nullptr );
-				stacksController->addNewAnim(new CWaitingProjectileAnimation(*this, nullptr));
+				stacksController->addNewAnim(new WaitingProjectileAnimation(*this, nullptr));
 			});
 		}
 	}
@@ -576,8 +576,8 @@ void BattleInterface::spellCast(const BattleSpellCast * sc)
 		bool side = sc->side;
 
 		executeOnAnimationCondition(EAnimationEvents::AFTER_HIT, true, [=](){
-			stacksController->addNewAnim(new CPointEffectAnimation(*this, "", side ? "SP07_A.DEF" : "SP07_B.DEF", leftHero));
-			stacksController->addNewAnim(new CPointEffectAnimation(*this, "", side ? "SP07_B.DEF" : "SP07_A.DEF", rightHero));
+			stacksController->addNewAnim(new PointEffectAnimation(*this, "", side ? "SP07_A.DEF" : "SP07_B.DEF", leftHero));
+			stacksController->addNewAnim(new PointEffectAnimation(*this, "", side ? "SP07_B.DEF" : "SP07_A.DEF", rightHero));
 		});
 	}
 }
@@ -618,24 +618,24 @@ void BattleInterface::displaySpellAnimationQueue(const CSpell::TAnimationQueue &
 	for(const CSpell::TAnimation & animation : q)
 	{
 		if(animation.pause > 0)
-			stacksController->addNewAnim(new CDummyAnimation(*this, animation.pause));
+			stacksController->addNewAnim(new DummyAnimation(*this, animation.pause));
 		else
 		{
 			int flags = 0;
 
 			if (isHit)
-				flags |= CPointEffectAnimation::FORCE_ON_TOP;
+				flags |= PointEffectAnimation::FORCE_ON_TOP;
 
 			if (animation.verticalPosition == VerticalPosition::BOTTOM)
-				flags |= CPointEffectAnimation::ALIGN_TO_BOTTOM;
+				flags |= PointEffectAnimation::ALIGN_TO_BOTTOM;
 
 			if (!destinationTile.isValid())
-				flags |= CPointEffectAnimation::SCREEN_FILL;
+				flags |= PointEffectAnimation::SCREEN_FILL;
 
 			if (!destinationTile.isValid())
-				stacksController->addNewAnim(new CPointEffectAnimation(*this, "", animation.resourceName, flags));
+				stacksController->addNewAnim(new PointEffectAnimation(*this, "", animation.resourceName, flags));
 			else
-				stacksController->addNewAnim(new CPointEffectAnimation(*this, "", animation.resourceName, destinationTile, flags));
+				stacksController->addNewAnim(new PointEffectAnimation(*this, "", animation.resourceName, destinationTile, flags));
 		}
 	}
 }

client/battle/BattleObstacleController.cpp

@@ -100,7 +100,7 @@ void BattleObstacleController::obstaclePlaced(const std::vector<std::shared_ptr<
 		//we assume here that effect graphics have the same size as the usual obstacle image
 		// -> if we know how to blit obstacle, let's blit the effect in the same place
 		Point whereTo = getObstaclePosition(first, *oi);
-		owner.stacksController->addNewAnim(new CPointEffectAnimation(owner, spellObstacle->appearSound, spellObstacle->appearAnimation, whereTo, oi->pos));
+		owner.stacksController->addNewAnim(new PointEffectAnimation(owner, spellObstacle->appearSound, spellObstacle->appearAnimation, whereTo, oi->pos));
 
 		//so when multiple obstacles are added, they show up one after another
 		owner.waitForAnimationCondition(EAnimationEvents::ACTION, false);

client/battle/BattleSiegeController.cpp

@@ -336,7 +336,7 @@ void BattleSiegeController::stackIsCatapulting(const CatapultAttack & ca)
 		const CStack *stack = owner.curInt->cb->battleGetStackByID(ca.attacker);
 		for (auto attackInfo : ca.attackedParts)
 		{
-			owner.stacksController->addNewAnim(new CCatapultAnimation(owner, stack, attackInfo.destinationTile, nullptr, attackInfo.damageDealt));
+			owner.stacksController->addNewAnim(new CatapultAnimation(owner, stack, attackInfo.destinationTile, nullptr, attackInfo.damageDealt));
 		}
 	}
 	else
@@ -347,7 +347,7 @@ void BattleSiegeController::stackIsCatapulting(const CatapultAttack & ca)
 		for (auto attackInfo : ca.attackedParts)
 			positions.push_back(owner.stacksController->getStackPositionAtHex(attackInfo.destinationTile, nullptr) + Point(99, 120));
 
-		owner.stacksController->addNewAnim(new CPointEffectAnimation(owner, "WALLHIT", "SGEXPL.DEF", positions));
+		owner.stacksController->addNewAnim(new PointEffectAnimation(owner, "WALLHIT", "SGEXPL.DEF", positions));
 	}
 
 	owner.waitForAnimationCondition(EAnimationEvents::ACTION, false);

client/battle/BattleStacksController.cpp

@@ -107,7 +107,7 @@ BattleHex BattleStacksController::getStackCurrentPosition(const CStack * stack)
 		// stack position will be updated only *after* movement is finished
 		// before this - stack is always at its initial position. Thus we need to find
 		// its current position. Which can be found only in this class
-		if (CStackMoveAnimation *move = dynamic_cast<CStackMoveAnimation*>(anim))
+		if (StackMoveAnimation *move = dynamic_cast<StackMoveAnimation*>(anim))
 		{
 			if (move->stack == stack)
 				return move->currentHex;
@@ -168,7 +168,7 @@ void BattleStacksController::stackReset(const CStack * stack)
 	{
 		owner.executeOnAnimationCondition(EAnimationEvents::HIT, true, [=]()
 		{
-			addNewAnim(new CResurrectionAnimation(owner, stack));
+			addNewAnim(new ResurrectionAnimation(owner, stack));
 		});
 	}
 
@@ -275,7 +275,7 @@ bool BattleStacksController::stackNeedsAmountBox(const CStack * stack) const
 
 	for(auto anim : currentAnimations) //no matter what other conditions below are, hide box when creature is playing hit animation
 	{
-		auto hitAnimation = dynamic_cast<CDefenceAnimation*>(anim);
+		auto hitAnimation = dynamic_cast<DefenceAnimation*>(anim);
 		if(hitAnimation && (hitAnimation->stack->ID == stack->ID))
 			return false;
 	}
@@ -372,7 +372,7 @@ void BattleStacksController::updateBattleAnimations()
 	}
 }
 
-void BattleStacksController::addNewAnim(CBattleAnimation *anim)
+void BattleStacksController::addNewAnim(BattleAnimation *anim)
 {
 	currentAnimations.push_back(anim);
 	owner.setAnimationCondition(EAnimationEvents::ACTION, true);
@@ -418,20 +418,26 @@ void BattleStacksController::stacksAreAttacked(std::vector<StackAttackedInfo> at
 		{
 			owner.executeOnAnimationCondition(EAnimationEvents::MOVEMENT, true, [=]()
 			{
-				addNewAnim(new CReverseAnimation(owner, attackedInfo.defender, attackedInfo.defender->getPosition()));
+				addNewAnim(new ReverseAnimation(owner, attackedInfo.defender, attackedInfo.defender->getPosition()));
 			});
 		}
 	}
 
 	for(auto & attackedInfo : attackedInfos)
 	{
+		bool useDeathAnim   = attackedInfo.killed;
 		bool useDefenceAnim = attackedInfo.defender->defendingAnim && !attackedInfo.indirectAttack && !attackedInfo.killed;
 
 		EAnimationEvents usedEvent = useDefenceAnim ? EAnimationEvents::ATTACK : EAnimationEvents::HIT;
 
 		owner.executeOnAnimationCondition(usedEvent, true, [=]()
 		{
-			addNewAnim(new CDefenceAnimation(attackedInfo, owner));
+			if (useDeathAnim)
+				addNewAnim(new DeathAnimation(owner, attackedInfo.defender, attackedInfo.indirectAttack));
+			else if(useDefenceAnim)
+				addNewAnim(new DefenceAnimation(owner, attackedInfo.defender));
+			else
+				addNewAnim(new HittedAnimation(owner, attackedInfo.defender));
 
 			if (attackedInfo.battleEffect != EBattleEffect::INVALID)
 				owner.effectsController->displayEffect(EBattleEffect::EBattleEffect(attackedInfo.battleEffect), attackedInfo.defender->getPosition());
@@ -447,7 +453,7 @@ void BattleStacksController::stacksAreAttacked(std::vector<StackAttackedInfo> at
 		{
 			owner.executeOnAnimationCondition(EAnimationEvents::AFTER_HIT, true, [=](){
 				owner.effectsController->displayEffect(EBattleEffect::RESURRECT, soundBase::RESURECT, attackedInfo.defender->getPosition());
-				addNewAnim(new CResurrectionAnimation(owner, attackedInfo.defender));
+				addNewAnim(new ResurrectionAnimation(owner, attackedInfo.defender));
 			});
 		}
 
@@ -469,16 +475,15 @@ void BattleStacksController::stackMoved(const CStack *stack, std::vector<BattleH
 	assert(owner.getAnimationCondition(EAnimationEvents::ACTION) == false);
 
 	if(shouldRotate(stack, stack->getPosition(), destHex[0]))
-		addNewAnim(new CReverseAnimation(owner, stack, destHex[0]));
-
-	addNewAnim(new CMovementStartAnimation(owner, stack));
+		addNewAnim(new ReverseAnimation(owner, stack, destHex[0]));
 
+	addNewAnim(new MovementStartAnimation(owner, stack));
 	owner.waitForAnimationCondition(EAnimationEvents::ACTION, false);
 
-	addNewAnim(new CMovementAnimation(owner, stack, destHex, distance));
+	addNewAnim(new MovementAnimation(owner, stack, destHex, distance));
 	owner.waitForAnimationCondition(EAnimationEvents::ACTION, false);
 
-	addNewAnim(new CMovementEndAnimation(owner, stack, destHex.back()));
+	addNewAnim(new MovementEndAnimation(owner, stack, destHex.back()));
 	owner.waitForAnimationCondition(EAnimationEvents::ACTION, false);
 }
 
@@ -504,7 +509,7 @@ void BattleStacksController::stackAttacking( const StackAttackInfo & info )
 	{
 		owner.executeOnAnimationCondition(EAnimationEvents::MOVEMENT, true, [=]()
 		{
-			addNewAnim(new CReverseAnimation(owner, attacker, attacker->getPosition()));
+			addNewAnim(new ReverseAnimation(owner, attacker, attacker->getPosition()));
 		});
 	}
 
@@ -543,11 +548,11 @@ void BattleStacksController::stackAttacking( const StackAttackInfo & info )
 	{
 		if (info.indirectAttack)
 		{
-			addNewAnim(new CShootingAnimation(owner, attacker, tile, defender));
+			addNewAnim(new ShootingAnimation(owner, attacker, tile, defender));
 		}
 		else
 		{
-			addNewAnim(new CMeleeAttackAnimation(owner, attacker, tile, defender));
+			addNewAnim(new MeleeAttackAnimation(owner, attacker, tile, defender));
 		}
 	});
 
@@ -609,7 +614,6 @@ bool BattleStacksController::shouldRotate(const CStack * stack, const BattleHex
 	return false;
 }
 
-
 void BattleStacksController::endAction(const BattleAction* action)
 {
 	//FIXME: there should be no more ongoing animations. If not - then some other method created animations but did not wait for them to end
@@ -625,7 +629,7 @@ void BattleStacksController::endAction(const BattleAction* action)
 
 		if (s && facingRight(s) != shouldFaceRight && s->alive() && stackAnimation[s->ID]->isIdle())
 		{
-			addNewAnim(new CReverseAnimation(owner, s, s->getPosition()));
+			addNewAnim(new ReverseAnimation(owner, s, s->getPosition()));
 		}
 	}
 	owner.waitForAnimationCondition(EAnimationEvents::ACTION, false);

client/battle/BattleStacksController.h

@@ -25,9 +25,9 @@ struct StackAttackInfo;
 
 class Canvas;
 class BattleInterface;
-class CBattleAnimation;
+class BattleAnimation;
 class CreatureAnimation;
-class CBattleAnimation;
+class BattleAnimation;
 class BattleRenderer;
 class IImage;
 
@@ -45,7 +45,7 @@ class BattleStacksController
 	std::shared_ptr<IImage> amountEffNeutral;
 
 	/// currently displayed animations <anim, initialized>
-	std::vector<CBattleAnimation *> currentAnimations;
+	std::vector<BattleAnimation *> currentAnimations;
 
 	/// animations of creatures from fighting armies (order by BattleInfo's stacks' ID)
 	std::map<int32_t, std::shared_ptr<CreatureAnimation>> stackAnimation;
@@ -110,7 +110,7 @@ public:
 
 	void collectRenderableObjects(BattleRenderer & renderer);
 
-	void addNewAnim(CBattleAnimation *anim); //adds new anim to pendingAnims
+	void addNewAnim(BattleAnimation *anim); //adds new anim to pendingAnims
 	void updateBattleAnimations();
 
 	const CStack* getActiveStack() const;
@@ -119,5 +119,5 @@ public:
 	/// returns position of animation needed to place stack in specific hex
 	Point getStackPositionAtHex(BattleHex hexNum, const CStack * creature) const;
 
-	friend class CBattleAnimation; // for exposing pendingAnims/creAnims/creDir to animations
+	friend class BattleAnimation; // for exposing pendingAnims/creAnims/creDir to animations
 };