Cleanup of ScriptAggregator class.

src/Battling/Models/Battle.cpp

@@ -85,7 +85,9 @@ bool Battle::CreatureInField(const Creature* creature) const {
 
 void Battle::ForceRecall(uint8_t side, uint8_t index) { _sides[side]->SetCreature(nullptr, index); }
 
-void Battle::GetActiveScripts(Arbutils::Collections::List<ScriptWrapper>& scripts) { scripts.Append(&_volatile); }
+void Battle::GetActiveScripts(Arbutils::Collections::List<ScriptWrapper>& scripts) {
+    scripts.Append(ScriptWrapper::FromSet(&_volatile));
+}
 
 void Battle::SwitchCreature(uint8_t sideIndex, uint8_t index, Creature* c) {
     auto side = this->_sides[sideIndex];

src/Battling/Models/BattleSide.cpp

@@ -70,7 +70,7 @@ bool BattleSide::CreatureOnSide(const Creature* creature) const {
 Creature* BattleSide::GetCreature(uint8_t index) const { return _creatures[index]; }
 
 void BattleSide::GetActiveScripts(Arbutils::Collections::List<ScriptWrapper>& scripts) {
-    scripts.Append(&_volatile);
+    scripts.Append(ScriptWrapper::FromSet(&_volatile));
     _battle->GetActiveScripts(scripts);
 }
 uint8_t BattleSide::GetRandomCreatureIndex() {

src/Battling/Models/Creature.cpp

@@ -167,9 +167,9 @@ bool Battling::Creature::HasType(uint8_t type) const noexcept {
 }
 
 void Battling::Creature::GetActiveScripts(Arbutils::Collections::List<ScriptWrapper>& scripts) {
-    scripts.Append(&_activeTalent);
-    scripts.Append(&_status);
-    scripts.Append(&_volatile);
+    scripts.Append(ScriptWrapper::FromScript(&_activeTalent));
+    scripts.Append(ScriptWrapper::FromScript(&_status));
+    scripts.Append(ScriptWrapper::FromSet(&_volatile));
     if (_side != nullptr) {
         _side->GetActiveScripts(scripts);
     }

src/Battling/Models/ExecutingAttack.hpp

@@ -87,7 +87,7 @@ namespace CreatureLib::Battling {
 
     protected:
         void GetActiveScripts(Arbutils::Collections::List<ScriptWrapper>& scripts) override {
-            scripts.Append(&_script);
+            scripts.Append(ScriptWrapper::FromScript(&_script));
             _user->GetActiveScripts(scripts);
         }
     };

src/Battling/ScriptHandling/ScriptAggregator.hpp

@@ -11,54 +11,54 @@ using namespace Arbutils::Collections;
 
 namespace CreatureLib::Battling {
     class ScriptAggregator {
-        List<ScriptWrapper> _scripts;
+        const ScriptWrapper* _scripts;
+        size_t _size;
         size_t _index = 0;
-        bool _isSetSet = false;
-        const List<Script*>* _setScripts = nullptr;
         size_t _setIndex = 0;
 
     public:
         ScriptAggregator(){};
-        explicit ScriptAggregator(const List<ScriptWrapper>& scripts) : _scripts(scripts){};
+        explicit ScriptAggregator(const List<ScriptWrapper>& scripts)
+            : _scripts(scripts.RawData()), _size(scripts.Count()){};
 
-        void Reset() {
+        inline void Reset() {
             _index = 0;
-            _isSetSet = false;
             _setIndex = 0;
         }
-        bool HasNext() { return _index < _scripts.Count() || (_isSetSet && _setIndex < _setScripts->Count()); }
+        inline bool HasNext() { return _index < _size; }
+
+        Script* GetNextNotNull() {
+            while (HasNext()) {
+                auto s = GetNext();
+                if (s != nullptr) {
+                    return s;
+                }
+            }
+            return nullptr;
+        }
 
         Script* GetNext() {
-            // We can probably do this in a cleaner version once C++ 20 drops with Coroutine support.
-            if (_isSetSet) {
-                if (_setIndex >= _setScripts->Count()) {
-                    _isSetSet = false;
-                    return GetNext();
-                }
-                auto s = _setScripts->At(_setIndex);
-                _setIndex++;
-                if (_setIndex >= _setScripts->Count()) {
-                    _isSetSet = false;
-                }
-                return s;
-            }
-            if (_index >= _scripts.Count())
-                return nullptr;
-            auto& next = _scripts[_index];
-            _index++;
-            if (!next.IsSet()) {
-                auto scriptPtr = next.GetScript();
-                if (scriptPtr == nullptr)
-                    return GetNext();
-                return *scriptPtr;
+            auto& current = _scripts[_index];
+            if (!current.IsSet()) {
+                _index++;
+                auto s = current.GetScript();
+                if (s == nullptr)
+                    return nullptr;
+                return *s;
             } else {
-                auto set = next.GetScriptSet();
-                if (set->Count() == 0)
-                    return GetNext();
-                _setScripts = set->GetIterator();
-                _isSetSet = true;
-                _setIndex = 0;
-                return GetNext();
+                auto& set = *current.GetScriptSet()->GetIterator();
+                auto count = set.Count();
+                if (_setIndex >= count) {
+                    _index++;
+                    _setIndex = 0;
+                    return nullptr;
+                }
+                auto v = set[_setIndex++];
+                if (_setIndex >= count) {
+                    _index++;
+                    _setIndex = 0;
+                }
+                return v;
             }
         }
     };

src/Battling/ScriptHandling/ScriptSet.hpp

@@ -66,7 +66,7 @@ namespace CreatureLib::Battling {
 
         bool Has(uint32_t keyHash) const { return _lookup.Has(keyHash); }
 
-        size_t Count() const { return _scripts.Count(); }
+        inline size_t Count() const { return _scripts.Count(); }
 
         const Arbutils::Collections::List<Script*>* GetIterator() const { return &_scripts; }
     };

src/Battling/ScriptHandling/ScriptSource.hpp

@@ -8,7 +8,8 @@
 namespace CreatureLib::Battling {
     class ScriptSource {
         bool _areScriptsInitialized = false;
-        ScriptAggregator _scripts;
+        List<ScriptWrapper> _scripts;
+        ScriptAggregator _scriptsIterator;
 
     protected:
         virtual void GetActiveScripts(Arbutils::Collections::List<ScriptWrapper>& scripts) = 0;
@@ -17,12 +18,11 @@ namespace CreatureLib::Battling {
     public:
         const ScriptAggregator& GetScriptIterator() {
             if (!_areScriptsInitialized) {
-                List<ScriptWrapper> scripts;
-                GetActiveScripts(scripts);
-                _scripts = ScriptAggregator(scripts);
+                GetActiveScripts(_scripts);
+                _scriptsIterator = ScriptAggregator(_scripts);
                 _areScriptsInitialized = true;
             }
-            return _scripts;
+            return _scriptsIterator;
         }
     };
 }

src/Battling/ScriptHandling/ScriptWrapper.hpp

@@ -7,20 +7,24 @@
 
 namespace CreatureLib::Battling {
     class ScriptWrapper {
-        union {
-            Script** _script;
-            ScriptSet* _scriptSet;
-        };
         bool _isSet;
 
+        union {
+            Script* const* _script;
+            const ScriptSet* _scriptSet;
+        };
+
+        ScriptWrapper(Script** s, bool isSet) : _isSet(isSet), _script(s){};
+        ScriptWrapper(ScriptSet* s, bool isSet) : _isSet(isSet), _scriptSet(s){};
+
     public:
-        ScriptWrapper(Script** s) : _script(s), _isSet(false) {}
-        ScriptWrapper(ScriptSet* s) : _scriptSet(s), _isSet(true) {}
+        static inline ScriptWrapper FromScript(Script** s) { return ScriptWrapper(s, false); }
+        static inline ScriptWrapper FromSet(ScriptSet* s) { return ScriptWrapper(s, true); }
 
         bool IsSet() const { return _isSet; }
 
-        Script** GetScript() const { return _script; }
-        ScriptSet* GetScriptSet() const { return _scriptSet; }
+        inline Script* const* GetScript() const { return _script; }
+        inline const ScriptSet* GetScriptSet() const { return _scriptSet; }
     };
 }
 

src/Battling/TurnChoices/AttackTurnChoice.hpp

@@ -56,7 +56,7 @@ namespace CreatureLib::Battling {
 
     protected:
         void GetActiveScripts(Arbutils::Collections::List<ScriptWrapper>& scripts) override {
-            scripts.Append(&_attackScript);
+            scripts.Append(ScriptWrapper::FromScript(&_attackScript));
             GetUser()->GetActiveScripts(scripts);
         }
     };