From 9ac67be0e49a654575547193f4f5f08f07154f43 Mon Sep 17 00:00:00 2001 From: Jarod42 Date: Wed, 27 Sep 2023 10:35:20 +0200 Subject: [PATCH] Clean up missile.h --- src/include/missile.h | 175 +++++++++-------- src/missile/missile.cpp | 184 ++++-------------- src/missile/missile_cliptotarget.cpp | 2 +- src/missile/missile_continuous.cpp | 2 +- src/missile/missile_cycleonce.cpp | 2 +- src/missile/missile_deathcoil.cpp | 2 +- src/missile/missile_fire.cpp | 2 +- src/missile/missile_flameshield.cpp | 4 +- src/missile/missile_hit.cpp | 2 +- src/missile/missile_landmine.cpp | 2 +- src/missile/missile_none.cpp | 2 +- src/missile/missile_parabolic.cpp | 2 +- src/missile/missile_pointotpointwithhit.cpp | 2 +- src/missile/missile_pointtopoint.cpp | 2 +- src/missile/missile_pointtopointbounce.cpp | 2 +- src/missile/missile_pointtopointcycleonce.cpp | 2 +- src/missile/missile_stay.cpp | 2 +- src/missile/missile_straightfly.cpp | 2 +- src/missile/missile_tracer.cpp | 2 +- src/missile/missile_whirlwind.cpp | 2 +- src/missile/script_missile.cpp | 25 ++- 21 files changed, 162 insertions(+), 260 deletions(-) diff --git a/src/include/missile.h b/src/include/missile.h index ff95b64ca4..22274514ce 100644 --- a/src/include/missile.h +++ b/src/include/missile.h @@ -295,12 +295,15 @@ -- Includes ----------------------------------------------------------------------------*/ +#include "luacallback.h" #include "missileconfig.h" #include "script.h" #include "unitptr.h" #include "unitsound.h" #include "vec2i.h" +#include + /*---------------------------------------------------------------------------- -- Declarations ----------------------------------------------------------------------------*/ @@ -322,21 +325,21 @@ enum class MissileClass { None, /// Missile does nothing PointToPoint, /// Missile flies from x,y to x1,y1 - PointToPointWithHit, /// Missile flies from x,y to x1,y1 than shows hit animation. + PointToPointWithHit, /// Missile flies from x,y to x1,y1 then shows hit animation. PointToPointCycleOnce, /// Missile flies from x,y to x1,y1 and animates ONCE from start to finish and back PointToPointBounce, /// Missile flies from x,y to x1,y1 than bounces three times. - Stay, /// Missile appears at x,y, does it's anim and vanishes. + Stay, /// Missile appears at x,y, does its anim and vanishes. CycleOnce, /// Missile appears at x,y, then cycle through the frames once. - Fire, /// Missile doesn't move, than checks the source unit for HP. + Fire, /// Missile doesn't move, then checks the source unit for HP. Hit, /// Missile shows the hit points. Parabolic, /// Missile flies from x,y to x1,y1 using a parabolic path - LandMine, /// Missile wait on x,y until a non-air unit comes by, the explodes. + LandMine, /// Missile wait on x,y until a non-air unit comes by, then explodes. Whirlwind, /// Missile appears at x,y, is whirlwind FlameShield, /// Missile surround x,y DeathCoil, /// Missile is death coil. Tracer, /// Missile seeks towards to target unit - ClipToTarget, /// Missile remains clipped to target's current goal and plays his animation once - Continuous, /// Missile stays and plays it's animation several times + ClipToTarget, /// Missile remains clipped to target's current goal and plays its animation once + Continuous, /// Missile stays and plays its animation several times StraightFly /// Missile flies from x,y to x1,y1 then continues to fly, until incompatible terrain is detected }; @@ -344,7 +347,7 @@ enum class MissileClass class MissileType { public: - explicit MissileType(const std::string &ident); + explicit MissileType(const std::string &ident) : Ident(ident) {} ~MissileType(); /// load the graphics for a missile type @@ -359,51 +362,51 @@ class MissileType //private: std::string Ident; /// missile name - int Transparency; /// missile transparency - PixelSize size; /// missile size in pixels - int DrawLevel; /// Level to draw missile at - int SpriteFrames; /// number of sprite frames in graphic - int NumDirections; /// number of directions missile can face - int ChangeVariable; /// variable to change - int ChangeAmount; /// how many to change - bool ChangeMax; /// modify the max, if value will exceed it + int Transparency = 0; /// missile transparency + PixelSize size{0, 0}; /// missile size in pixels + int DrawLevel = 0; /// Level to draw missile at + int SpriteFrames = 0; /// number of sprite frames in graphic + int NumDirections = 0; /// number of directions missile can face + int ChangeVariable = -1; /// variable to change + int ChangeAmount = 0; /// how many to change + bool ChangeMax = false; /// modify the max, if value will exceed it SoundConfig FiredSound; /// fired sound SoundConfig ImpactSound; /// impact sound for this missile-type - bool CorrectSphashDamage; /// restricts the radius damage depending on land, air, naval - bool Flip; /// flip image when facing left - bool CanHitOwner; /// missile can hit the owner - bool FriendlyFire; /// missile can't hit own units - bool AlwaysFire; /// missile will always fire (even if target is dead) - bool Pierce; /// missile will hit every unit on his way - bool PierceOnce; /// pierce every target only once - bool IgnoreWalls; /// missile ignores Wall units on it's way - bool KillFirstUnit; /// missile kills first unit blocking it's way - - MissileClass Class; /// missile class - int NumBounces; /// number of bounces - int ParabolCoefficient; /// parabol coefficient in parabolic missile - int StartDelay; /// missile start delay - int Sleep; /// missile sleep - int Speed; /// missile speed - int BlizzardSpeed; /// speed for blizzard shards - int TTL; /// missile time-to-live - int ReduceFactor; /// Multiplier for reduce or increase damage dealt to the next unit - int SmokePrecision; /// How frequently the smoke missile will generate itself - int MissileStopFlags; /// On which terrain types missile won't fly + bool CorrectSphashDamage = false; /// restricts the radius damage depending on land, air, naval + bool Flip = false; /// flip image when facing left + bool CanHitOwner = false; /// missile can hit the owner + bool FriendlyFire = false; /// missile can't hit own units + bool AlwaysFire = false; /// missile will always fire (even if target is dead) + bool Pierce = false; /// missile will hit every unit on his way + bool PierceOnce = false; /// pierce every target only once + bool IgnoreWalls = true; /// missile ignores Wall units on it's way + bool KillFirstUnit = false; /// missile kills first unit blocking it's way + + MissileClass Class = MissileClass::None; /// missile class + int NumBounces = 0; /// number of bounces + int ParabolCoefficient = 2048; /// parabol coefficient in parabolic missile + int StartDelay = 0; /// missile start delay + int Sleep = 0; /// missile sleep + int Speed = 0; /// missile speed + int BlizzardSpeed = 0; /// speed for blizzard shards + int TTL = -1; /// missile time-to-live + int ReduceFactor = 100; /// Multiplier for reduce or increase damage dealt to the next unit + int SmokePrecision = 0; /// How frequently the smoke missile will generate itself + int MissileStopFlags = 0; /// On which terrain types missile won't fly std::unique_ptr Damage; /// missile damage (used for non-direct missiles, e.g. impacts) - int Range; /// missile damage range - int SplashFactor; /// missile splash divisor - std::vector Impact; /// missile produces an impact + int Range = 0; /// missile damage range + int SplashFactor = 0; /// missile splash divisor + std::vector Impact; /// missile produces an impact MissileConfig Smoke; /// trailing missile - LuaCallback *ImpactParticle; /// impact particle - LuaCallback *SmokeParticle; /// smoke particle - LuaCallback *OnImpact; /// called when + std::unique_ptr ImpactParticle; /// impact particle + std::unique_ptr SmokeParticle; /// smoke particle + std::unique_ptr OnImpact; /// called when // --- FILLED UP --- - CGraphic *G; /// missile graphic + CGraphic *G = nullptr; /// missile graphic }; /*---------------------------------------------------------------------------- @@ -414,12 +417,13 @@ class MissileType class Missile { protected: - Missile(); + Missile() { this->Slot = Missile::Count++; } public: - virtual ~Missile(); + virtual ~Missile() = default; - static Missile *Init(const MissileType &mtype, const PixelPos &startPos, const PixelPos &destPos); + static std::unique_ptr + Init(const MissileType &mtype, const PixelPos &startPos, const PixelPos &destPos); virtual void Action() = 0; @@ -430,34 +434,33 @@ class Missile void NextMissileFrameCycle(); void MissileNewHeadingFromXY(const PixelPos &delta); - //private: - PixelPos source; /// Missile source position - PixelPos position; /// missile pixel position - PixelPos destination; /// missile pixel destination - const MissileType *Type; /// missile-type pointer - int SpriteFrame; /// sprite frame counter - int State; /// state - int AnimWait; /// Animation wait. - int Wait; /// delay between frames - int Delay; /// delay to show up + PixelPos source{0, 0}; /// Missile source position + PixelPos position{0, 0}; /// missile pixel position + PixelPos destination{0, 0}; /// missile pixel destination + const MissileType *Type = nullptr; /// missile-type pointer + int SpriteFrame = 0; /// sprite frame counter + int State = 0; /// state + int AnimWait = 0; /// Animation wait. + int Wait = 0; /// delay between frames + int Delay = 0; /// delay to show up CUnitPtr SourceUnit; /// unit that fires (could be killed) CUnitPtr TargetUnit; /// target unit, used for spells - std::vector PiercedUnits; /// Units which are already pierced by this missile + std::vector PiercedUnits; /// Units which are already pierced by this missile - int Damage; /// direct damage that missile applies + int Damage = 0; /// direct damage that missile applies - int TTL; /// time to live (ticks) used for spells - int Hidden; /// If this is 1 then the missile is invisible - int DestroyMissile; /// this tells missile-class-straight-fly, that it's time to die + int TTL = -1; /// time to live (ticks) used for spells + int Hidden = 0; /// If this is 1 then the missile is invisible + int DestroyMissile = 0; /// this tells missile-class-straight-fly, that it's time to die // Internal use: - int CurrentStep; /// Current step (0 <= x < TotalStep). - int TotalStep; /// Total step. + int CurrentStep = 0; /// Current step (0 <= x < TotalStep). + int TotalStep = 0; /// Total step. - unsigned Local: 1; /// missile is a local missile + bool Local = false; /// missile is a local missile unsigned int Slot; /// unique number for draw level. static unsigned int Count; /// slot number generator. @@ -471,113 +474,113 @@ extern bool MissileHandleBlocking(Missile &missile, const PixelPos &position); class MissileNone : public Missile { public: - virtual void Action(); + void Action() override; }; class MissilePointToPoint : public Missile { public: - virtual void Action(); + void Action() override; }; class MissilePointToPointWithHit : public Missile { public: - virtual void Action(); + void Action() override; }; class MissilePointToPointCycleOnce : public Missile { public: - virtual void Action(); + void Action() override; }; class MissilePointToPointBounce : public Missile { public: - virtual void Action(); + void Action() override; }; class MissileStay : public Missile { public: - virtual void Action(); + void Action() override; }; class MissileCycleOnce : public Missile { public: - virtual void Action(); + void Action() override; }; class MissileFire : public Missile { public: - virtual void Action(); + void Action() override; }; class MissileHit : public Missile { public: - virtual void Action(); + void Action() override; }; class MissileParabolic : public Missile { public: - virtual void Action(); + void Action() override; }; class MissileLandMine : public Missile { public: - virtual void Action(); + void Action() override; }; class MissileWhirlwind : public Missile { public: - virtual void Action(); + void Action() override; }; class MissileFlameShield : public Missile { public: - virtual void Action(); + void Action() override; }; class MissileDeathCoil : public Missile { public: - virtual void Action(); + void Action() override; }; class MissileTracer : public Missile { public: - virtual void Action(); + void Action() override; }; class MissileClipToTarget : public Missile { public: - virtual void Action(); + void Action() override; }; class MissileContinious : public Missile { public: - virtual void Action(); + void Action() override; }; class MissileStraightFly : public Missile { public: - virtual void Action(); + void Action() override; }; class BurningBuildingFrame { public: - BurningBuildingFrame() : Percent(0), Missile(nullptr) {}; + BurningBuildingFrame() = default; - int Percent; /// HP percent - MissileType *Missile; /// Missile to draw + int Percent = 0; /// HP percent + MissileType *Missile = nullptr; /// Missile to draw } ; /*---------------------------------------------------------------------------- -- Variables ----------------------------------------------------------------------------*/ -extern std::vector BurningBuildingFrames; /// Burning building frames +extern std::vector> BurningBuildingFrames; /// Burning building frames /*---------------------------------------------------------------------------- -- Functions diff --git a/src/missile/missile.cpp b/src/missile/missile.cpp index 1c4f121ed9..12e4ff8b81 100644 --- a/src/missile/missile.cpp +++ b/src/missile/missile.cpp @@ -63,14 +63,14 @@ unsigned int Missile::Count = 0; -static std::vector GlobalMissiles; /// all global missiles on map -static std::vector LocalMissiles; /// all local missiles on map +static std::vector> GlobalMissiles; /// all global missiles on map +static std::vector> LocalMissiles; /// all local missiles on map /// lookup table for missile names -using MissileTypeMap = std::map>; +using MissileTypeMap = std::map, std::less<>>; static MissileTypeMap MissileTypes; -std::vector BurningBuildingFrames; /// Burning building frames +std::vector> BurningBuildingFrames; /// Burning building frames extern std::unique_ptr Damage; /// Damage calculation for missile. @@ -137,30 +137,11 @@ MissileType *NewMissileTypeSlot(const std::string &ident) auto &res = MissileTypes[ident]; if (res == nullptr) { - res = new MissileType(ident); + res = std::make_unique(ident); } else { DebugPrint("Redefining missile-type '%s'\n", ident.c_str()); } - return res; -} - -/** -** Constructor -*/ -Missile::Missile() : - Type(nullptr), SpriteFrame(0), State(0), AnimWait(0), Wait(0), - Delay(0), SourceUnit(), TargetUnit(), Damage(0), - TTL(-1), Hidden(0), DestroyMissile(0), - CurrentStep(0), TotalStep(0), - Local(0) -{ - position.x = 0; - position.y = 0; - destination.x = 0; - destination.y = 0; - source.x = 0; - source.y = 0; - this->Slot = Missile::Count++; + return res.get(); } /** @@ -172,65 +153,30 @@ Missile::Missile() : ** ** @return created missile. */ -/* static */ Missile *Missile::Init(const MissileType &mtype, const PixelPos &startPos, const PixelPos &destPos) +/* static */ std::unique_ptr +Missile::Init(const MissileType &mtype, const PixelPos &startPos, const PixelPos &destPos) { - Missile *missile = nullptr; + std::unique_ptr missile; switch (mtype.Class) { - case MissileClass::None : - missile = new MissileNone; - break; - case MissileClass::PointToPoint : - missile = new MissilePointToPoint; - break; - case MissileClass::PointToPointWithHit : - missile = new MissilePointToPointWithHit; - break; - case MissileClass::PointToPointCycleOnce : - missile = new MissilePointToPointCycleOnce; - break; - case MissileClass::PointToPointBounce : - missile = new MissilePointToPointBounce; - break; - case MissileClass::Stay : - missile = new MissileStay; - break; - case MissileClass::CycleOnce : - missile = new MissileCycleOnce; - break; - case MissileClass::Fire : - missile = new MissileFire; - break; - case MissileClass::Hit : - missile = new ::MissileHit; - break; - case MissileClass::Parabolic : - missile = new MissileParabolic; - break; - case MissileClass::LandMine : - missile = new MissileLandMine; - break; - case MissileClass::Whirlwind : - missile = new MissileWhirlwind; - break; - case MissileClass::FlameShield : - missile = new MissileFlameShield; - break; - case MissileClass::DeathCoil : - missile = new MissileDeathCoil; - break; - case MissileClass::Tracer : - missile = new MissileTracer; - break; - case MissileClass::ClipToTarget : - missile = new MissileClipToTarget; - break; - case MissileClass::Continuous : - missile = new MissileContinious; - break; - case MissileClass::StraightFly : - missile = new MissileStraightFly; - break; + case MissileClass::None: missile = std::make_unique(); break; + case MissileClass::PointToPoint: missile = std::make_unique(); break; + case MissileClass::PointToPointWithHit: missile = std::make_unique(); break; + case MissileClass::PointToPointCycleOnce: missile = std::make_unique(); break; + case MissileClass::PointToPointBounce: missile = std::make_unique(); break; + case MissileClass::Stay: missile = std::make_unique(); break; + case MissileClass::CycleOnce: missile = std::make_unique(); break; + case MissileClass::Fire: missile = std::make_unique(); break; + case MissileClass::Hit: missile = std::make_unique<::MissileHit>(); break; + case MissileClass::Parabolic: missile = std::make_unique(); break; + case MissileClass::LandMine: missile = std::make_unique(); break; + case MissileClass::Whirlwind: missile = std::make_unique(); break; + case MissileClass::FlameShield: missile = std::make_unique(); break; + case MissileClass::DeathCoil: missile = std::make_unique(); break; + case MissileClass::Tracer: missile = std::make_unique(); break; + case MissileClass::ClipToTarget: missile = std::make_unique(); break; + case MissileClass::Continuous: missile = std::make_unique(); break; + case MissileClass::StraightFly: missile = std::make_unique(); break; } const PixelPos halfSize = mtype.size / 2; missile->position = startPos - halfSize; @@ -258,10 +204,10 @@ Missile::Missile() : */ Missile *MakeMissile(const MissileType &mtype, const PixelPos &startPos, const PixelPos &destPos) { - Missile *missile = Missile::Init(mtype, startPos, destPos); + auto missile = Missile::Init(mtype, startPos, destPos); - GlobalMissiles.push_back(missile); - return missile; + GlobalMissiles.push_back(std::move(missile)); + return GlobalMissiles.back().get(); } /** @@ -275,11 +221,11 @@ Missile *MakeMissile(const MissileType &mtype, const PixelPos &startPos, const P */ Missile *MakeLocalMissile(const MissileType &mtype, const PixelPos &startPos, const PixelPos &destPos) { - Missile *missile = Missile::Init(mtype, startPos, destPos); + auto missile = Missile::Init(mtype, startPos, destPos); missile->Local = 1; - LocalMissiles.push_back(missile); - return missile; + LocalMissiles.push_back(std::move(missile)); + return LocalMissiles.back().get(); } /** @@ -581,7 +527,7 @@ std::vector FindAndSortMissiles(const CViewport &vp) { std::vector table; // Loop through global missiles, then through locals. - for (auto* missilePtr : GlobalMissiles) { + for (auto& missilePtr : GlobalMissiles) { Missile &missile = *missilePtr; if (missile.Delay || missile.Hidden) { continue; // delayed or hidden -> aren't shown @@ -592,7 +538,7 @@ std::vector FindAndSortMissiles(const CViewport &vp) } } - for (auto* missilePtr : LocalMissiles) { + for (auto& missilePtr : LocalMissiles) { Missile &missile = *missilePtr; if (missile.Delay || missile.Hidden) { continue; // delayed or hidden -> aren't shown @@ -920,8 +866,8 @@ void Missile::MissileHit(CUnit *unit) // The impact generates a new missile. // if (mtype.Impact.empty() == false) { - for (MissileConfig *mc : mtype.Impact) { - Missile *impact = MakeMissile(*mc->Missile, pixelPos, pixelPos); + for (const auto &mc : mtype.Impact) { + Missile *impact = MakeMissile(*mc.Missile, pixelPos, pixelPos); if (impact && impact->Type->Damage) { impact->SourceUnit = this->SourceUnit; } @@ -1154,7 +1100,7 @@ void Missile::NextMissileFrameCycle() ** ** @param missiles Table of missiles. */ -static void MissilesActionLoop(std::vector &missiles) +static void MissilesActionLoop(std::vector> &missiles) { for (size_t i = 0; i != missiles.size(); /* empty */) { Missile &missile = *missiles[i]; @@ -1168,7 +1114,6 @@ static void MissilesActionLoop(std::vector &missiles) missile.TTL--; // overall time to live if specified } if (missile.TTL == 0) { - delete &missile; missiles.erase(missiles.begin() + i); continue; } @@ -1179,7 +1124,6 @@ static void MissilesActionLoop(std::vector &missiles) } missile.Action(); // may create other missiles, and so modifies the array if (missile.TTL == 0) { - delete &missile; missiles.erase(missiles.begin() + i); continue; } @@ -1220,7 +1164,7 @@ int ViewPointDistanceToMissile(const Missile &missile) */ MissileType *MissileBurningBuilding(int percent) { - for (BurningBuildingFrame *frame : BurningBuildingFrames) { + for (auto &frame : BurningBuildingFrames) { if (percent > frame->Percent) { return frame->Missile; } @@ -1281,10 +1225,10 @@ void SaveMissiles(CFile &file) file.printf("\n--- -----------------------------------------\n"); file.printf("--- MODULE: missiles\n\n"); - for (const Missile *missile : GlobalMissiles) { + for (const auto &missile : GlobalMissiles) { missile->SaveMissile(file); } - for (const Missile *missile : LocalMissiles) { + for (const auto &missile : LocalMissiles) { missile->SaveMissile(file); } } @@ -1297,8 +1241,8 @@ void MissileType::Init() // Resolve impact missiles and sounds. this->FiredSound.MapSound(); this->ImpactSound.MapSound(); - for (MissileConfig *mc : this->Impact) { - mc->MapMissile(); + for (auto &mc : this->Impact) { + mc.MapMissile(); } this->Smoke.MapMissile(); } @@ -1313,34 +1257,12 @@ void InitMissileTypes() } } -/** -** Constructor. -*/ -MissileType::MissileType(const std::string &ident) : - Ident(ident), Transparency(0), DrawLevel(0), - SpriteFrames(0), NumDirections(0), ChangeVariable(-1), ChangeAmount(0), ChangeMax(false), - CorrectSphashDamage(false), Flip(false), CanHitOwner(false), FriendlyFire(false), - AlwaysFire(false), Pierce(false), PierceOnce(false), IgnoreWalls(true), KillFirstUnit(false), - Class(), NumBounces(0), ParabolCoefficient(2048), StartDelay(0), - Sleep(0), Speed(0), BlizzardSpeed(0), TTL(-1), ReduceFactor(100), SmokePrecision(0), - MissileStopFlags(0), Range(0), SplashFactor(0), - ImpactParticle(nullptr), SmokeParticle(nullptr), OnImpact(nullptr), - G(nullptr) -{ - size.x = 0; - size.y = 0; -} - /** ** Destructor. */ MissileType::~MissileType() { CGraphic::Free(this->G); - Impact.clear(); - delete ImpactParticle; - delete SmokeParticle; - delete OnImpact; } /** @@ -1348,9 +1270,6 @@ MissileType::~MissileType() */ void CleanMissileTypes() { - for (auto &[key, value] : MissileTypes) { - delete value; - } MissileTypes.clear(); } @@ -1361,34 +1280,17 @@ void InitMissiles() { } -/** -** Missile destructior. -*/ -Missile::~Missile() -{ - PiercedUnits.clear(); -} - /** ** Clean up missiles. */ void CleanMissiles() { - for (Missile *missile : GlobalMissiles) { - delete missile; - } GlobalMissiles.clear(); - for (Missile *missile : LocalMissiles) { - delete missile; - } LocalMissiles.clear(); } void FreeBurningBuildingFrames() { - for (BurningBuildingFrame *frame : BurningBuildingFrames) { - delete frame; - } BurningBuildingFrames.clear(); } diff --git a/src/missile/missile_cliptotarget.cpp b/src/missile/missile_cliptotarget.cpp index 30fe66e56a..cc508f0c27 100644 --- a/src/missile/missile_cliptotarget.cpp +++ b/src/missile/missile_cliptotarget.cpp @@ -43,7 +43,7 @@ /** ** Missile remains clipped to target's current goal and plays his animation once */ -void MissileClipToTarget::Action() +void MissileClipToTarget::Action() /* override */ { this->Wait = this->Type->Sleep; diff --git a/src/missile/missile_continuous.cpp b/src/missile/missile_continuous.cpp index d181f4a39f..b4d286fa73 100644 --- a/src/missile/missile_continuous.cpp +++ b/src/missile/missile_continuous.cpp @@ -40,7 +40,7 @@ /** ** Missile don't move, than disappears when TTL is 0 */ -void MissileContinious::Action() +void MissileContinious::Action() /* override */ { this->Wait = this->Type->Sleep; this->MissileHit(); diff --git a/src/missile/missile_cycleonce.cpp b/src/missile/missile_cycleonce.cpp index ac3a5fd7ac..ed9f033c76 100644 --- a/src/missile/missile_cycleonce.cpp +++ b/src/missile/missile_cycleonce.cpp @@ -41,7 +41,7 @@ ** Missile doesn't move, it will just cycle once and vanish. ** Used for ui missiles (cross shown when you give and order) */ -void MissileCycleOnce::Action() +void MissileCycleOnce::Action() /* override */ { this->Wait = this->Type->Sleep; switch (this->State) { diff --git a/src/missile/missile_deathcoil.cpp b/src/missile/missile_deathcoil.cpp index 843b8805d3..52bc891567 100644 --- a/src/missile/missile_deathcoil.cpp +++ b/src/missile/missile_deathcoil.cpp @@ -47,7 +47,7 @@ ** ** @todo do it configurable. */ -void MissileDeathCoil::Action() +void MissileDeathCoil::Action() /* override */ { this->Wait = this->Type->Sleep; if (PointToPointMissile(*this) == false) { diff --git a/src/missile/missile_fire.cpp b/src/missile/missile_fire.cpp index 23c64f1edf..9a7c24c97a 100644 --- a/src/missile/missile_fire.cpp +++ b/src/missile/missile_fire.cpp @@ -43,7 +43,7 @@ /** ** Missile don't move, than checks the source unit for HP. */ -void MissileFire::Action() +void MissileFire::Action() /* override */ { CUnit &unit = *this->SourceUnit; diff --git a/src/missile/missile_flameshield.cpp b/src/missile/missile_flameshield.cpp index 56c1ee74fc..bb6f426dfa 100644 --- a/src/missile/missile_flameshield.cpp +++ b/src/missile/missile_flameshield.cpp @@ -44,9 +44,9 @@ /** ** FlameShield controller */ -void MissileFlameShield::Action() +void MissileFlameShield::Action() /* override */ { - static int fs_dc[] = { + static const int fs_dc[] = { 0, 32, 5, 31, 10, 30, 16, 27, 20, 24, 24, 20, 27, 15, 30, 10, 31, 5, 32, 0, 31, -5, 30, -10, 27, -16, 24, -20, 20, -24, 15, -27, 10, -30, 5, -31, 0, -32, -5, -31, -10, -30, -16, -27, -20, -24, -24, -20, diff --git a/src/missile/missile_hit.cpp b/src/missile/missile_hit.cpp index 92164cc22d..8a0711052c 100644 --- a/src/missile/missile_hit.cpp +++ b/src/missile/missile_hit.cpp @@ -40,7 +40,7 @@ /** ** Missile shows hit points? */ -void MissileHit::Action() +void MissileHit::Action() /* override */ { this->Wait = this->Type->Sleep; if (PointToPointMissile(*this)) { diff --git a/src/missile/missile_landmine.cpp b/src/missile/missile_landmine.cpp index a0183527d0..3191bf5641 100644 --- a/src/missile/missile_landmine.cpp +++ b/src/missile/missile_landmine.cpp @@ -64,7 +64,7 @@ struct LandMineTargetFinder { ** @todo start-finish-start cyclic animation.(anim scripts!) ** @todo missile should disappear for a while. */ -void MissileLandMine::Action() +void MissileLandMine::Action() /* override */ { const Vec2i pos = Map.MapPixelPosToTilePos(this->position); diff --git a/src/missile/missile_none.cpp b/src/missile/missile_none.cpp index 188c58cd74..69d7ad6ecb 100644 --- a/src/missile/missile_none.cpp +++ b/src/missile/missile_none.cpp @@ -40,7 +40,7 @@ /** ** Missile does nothing */ -void MissileNone::Action() +void MissileNone::Action() /* override */ { this->Wait = this->Type->Sleep; // Busy doing nothing. diff --git a/src/missile/missile_parabolic.cpp b/src/missile/missile_parabolic.cpp index 3a966b5b23..70be6a31c9 100644 --- a/src/missile/missile_parabolic.cpp +++ b/src/missile/missile_parabolic.cpp @@ -114,7 +114,7 @@ static bool ParabolicMissile(Missile &missile) /** ** Missile flies from x,y to x1,y1 using a parabolic path */ -void MissileParabolic::Action() +void MissileParabolic::Action() /* override */ { this->Wait = this->Type->Sleep; if (ParabolicMissile(*this)) { diff --git a/src/missile/missile_pointotpointwithhit.cpp b/src/missile/missile_pointotpointwithhit.cpp index d70615d984..d80c7cc308 100644 --- a/src/missile/missile_pointotpointwithhit.cpp +++ b/src/missile/missile_pointotpointwithhit.cpp @@ -41,7 +41,7 @@ ** Missile flies from x,y to x1,y1 showing the first frame ** and then shows a hit animation. */ -void MissilePointToPointWithHit::Action() +void MissilePointToPointWithHit::Action() /* override */ { this->Wait = this->Type->Sleep; if (PointToPointMissile(*this)) { diff --git a/src/missile/missile_pointtopoint.cpp b/src/missile/missile_pointtopoint.cpp index 6eac6fa9aa..271ca468dd 100644 --- a/src/missile/missile_pointtopoint.cpp +++ b/src/missile/missile_pointtopoint.cpp @@ -40,7 +40,7 @@ /** ** Missile flies from x,y to x1,y1 animation on the way */ -void MissilePointToPoint::Action() +void MissilePointToPoint::Action() /* override */ { this->Wait = this->Type->Sleep; if (PointToPointMissile(*this)) { diff --git a/src/missile/missile_pointtopointbounce.cpp b/src/missile/missile_pointtopointbounce.cpp index 6dfc57bd80..b5c6ee8496 100644 --- a/src/missile/missile_pointtopointbounce.cpp +++ b/src/missile/missile_pointtopointbounce.cpp @@ -42,7 +42,7 @@ /** ** Missile flies from x,y to x1,y1 than bounces NumBounces times */ -void MissilePointToPointBounce::Action() +void MissilePointToPointBounce::Action() /* override */ { this->Wait = this->Type->Sleep; if (PointToPointMissile(*this)) { diff --git a/src/missile/missile_pointtopointcycleonce.cpp b/src/missile/missile_pointtopointcycleonce.cpp index 0cdea12d41..ff4b8b5f0b 100644 --- a/src/missile/missile_pointtopointcycleonce.cpp +++ b/src/missile/missile_pointtopointcycleonce.cpp @@ -40,7 +40,7 @@ /** ** Missile flies from x,y to x1,y1 and stays there for a moment */ -void MissilePointToPointCycleOnce::Action() +void MissilePointToPointCycleOnce::Action() /* override */ { this->Wait = this->Type->Sleep; if (PointToPointMissile(*this)) { diff --git a/src/missile/missile_stay.cpp b/src/missile/missile_stay.cpp index ab135beb23..309e05a22c 100644 --- a/src/missile/missile_stay.cpp +++ b/src/missile/missile_stay.cpp @@ -40,7 +40,7 @@ /** ** Missile don't move, than disappears */ -void MissileStay::Action() +void MissileStay::Action() /* override */ { this->Wait = this->Type->Sleep; if (this->NextMissileFrame(1, 0)) { diff --git a/src/missile/missile_straightfly.cpp b/src/missile/missile_straightfly.cpp index cfa6746f44..09c59969bd 100644 --- a/src/missile/missile_straightfly.cpp +++ b/src/missile/missile_straightfly.cpp @@ -42,7 +42,7 @@ /** ** Missile flies from x,y to x1,y1 then continues to fly, until incompatible terrain is detected */ -void MissileStraightFly::Action() +void MissileStraightFly::Action() /* override */ { this->Wait = this->Type->Sleep; if (PointToPointMissile(*this)) { diff --git a/src/missile/missile_tracer.cpp b/src/missile/missile_tracer.cpp index 97153eaa77..d411489ac0 100644 --- a/src/missile/missile_tracer.cpp +++ b/src/missile/missile_tracer.cpp @@ -115,7 +115,7 @@ static bool TracerMissile(Missile &missile) /** ** Missile flies from x,y to the target position, changing direction on the way */ -void MissileTracer::Action() +void MissileTracer::Action() /* override */ { this->Wait = this->Type->Sleep; if (TracerMissile(*this)) { diff --git a/src/missile/missile_whirlwind.cpp b/src/missile/missile_whirlwind.cpp index 8f6136a9f0..f9933b4f46 100644 --- a/src/missile/missile_whirlwind.cpp +++ b/src/missile/missile_whirlwind.cpp @@ -44,7 +44,7 @@ ** ** @todo do it more configurable. */ -void MissileWhirlwind::Action() +void MissileWhirlwind::Action() /* override */ { // Animate, move. if (!this->AnimWait--) { diff --git a/src/missile/script_missile.cpp b/src/missile/script_missile.cpp index ea55f4ae8c..ba5dd66883 100644 --- a/src/missile/script_missile.cpp +++ b/src/missile/script_missile.cpp @@ -161,25 +161,25 @@ void MissileType::Load(lua_State *l) this->Range = LuaToNumber(l, -1); } else if (value == "ImpactMissile") { if (!lua_istable(l, -1)) { - MissileConfig *mc = new MissileConfig(); - mc->Name = LuaToString(l, -1); - this->Impact.push_back(mc); + MissileConfig mc{}; + mc.Name = LuaToString(l, -1); + this->Impact.push_back(std::move(mc)); } else { const int impacts = lua_rawlen(l, -1); for (int i = 0; i < impacts; ++i) { - MissileConfig *mc = new MissileConfig(); - mc->Name = LuaToString(l, -1, i + 1); - this->Impact.push_back(mc); + MissileConfig mc{}; + mc.Name = LuaToString(l, -1, i + 1); + this->Impact.push_back(std::move(mc)); } } } else if (value == "SmokeMissile") { this->Smoke.Name = LuaToString(l, -1); } else if (value == "ImpactParticle") { - this->ImpactParticle = new LuaCallback(l, -1); + this->ImpactParticle = std::make_unique(l, -1); } else if (value == "SmokeParticle") { - this->SmokeParticle = new LuaCallback(l, -1); + this->SmokeParticle = std::make_unique(l, -1); } else if (value == "OnImpact") { - this->OnImpact = new LuaCallback(l, -1); + this->OnImpact = std::make_unique(l, -1); } else if (value == "CanHitOwner") { this->CanHitOwner = LuaToBoolean(l, -1); } else if (value == "AlwaysFire") { @@ -336,9 +336,6 @@ static int CclMissile(lua_State *l) */ static int CclDefineBurningBuilding(lua_State *l) { - for (BurningBuildingFrame *frame : BurningBuildingFrames) { - delete frame; - } BurningBuildingFrames.clear(); const int args = lua_gettop(l); @@ -346,7 +343,7 @@ static int CclDefineBurningBuilding(lua_State *l) if (!lua_istable(l, j + 1)) { LuaError(l, "incorrect argument"); } - BurningBuildingFrame *ptr = new BurningBuildingFrame; + auto ptr = std::make_unique(); const int subargs = lua_rawlen(l, j + 1); for (int k = 0; k < subargs; ++k) { @@ -359,7 +356,7 @@ static int CclDefineBurningBuilding(lua_State *l) ptr->Missile = &MissileTypeByIdent(LuaToString(l, j + 1, k + 1)); } } - BurningBuildingFrames.insert(BurningBuildingFrames.begin(), ptr); + BurningBuildingFrames.insert(BurningBuildingFrames.begin(), std::move(ptr)); } return 0; }