diff --git a/CMakeLists.txt b/CMakeLists.txt
index e89b8f28..bddf2075 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -238,7 +238,6 @@ if(ENABLE_TESTING)
       tests/Moves/FuryAttack.cpp
       tests/Moves/KnockOff.cpp
       tests/PokedexTest.cpp
-      tests/RegistryContainerTests.cpp
       tests/SimulateTurnsTest.cpp
       tests/SimulationSetupTest.cpp
       tests/Tests.cpp
diff --git a/CMakePresets.json b/CMakePresets.json
index e070bbb6..168e51c5 100644
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -80,9 +80,22 @@
     {
       "name": "benchmark-release-with-checks",
       "inherits": [
-        "test",
         "benchmark-release"
-      ]
+      ],
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "RelWithDebInfo",
+        "ENABLE_TESTING": "ON"
+      }
+    },
+    {
+      "name": "profile",
+      "inherits": [
+        "benchmark",
+        "default"
+      ],
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "RelWithDebInfo"
+      }
     }
   ],
   "buildPresets": [
@@ -127,6 +140,11 @@
       "name": "benchmark-release-with-checks",
       "inherits": "benchmark",
       "configurePreset": "benchmark-release-with-checks"
+    },
+    {
+      "name": "profile",
+      "inherits": "benchmark",
+      "configurePreset": "profile"
     }
   ]
 }
diff --git a/extras/PokeSim.cpp b/extras/PokeSim.cpp
index c2f00292..b970eda8 100644
--- a/extras/PokeSim.cpp
+++ b/extras/PokeSim.cpp
@@ -209,12 +209,20 @@ void checkStat(types::stat stat, bool hp = false) {
   }
 }
 
-void checkEffectiveStat(types::stat stat, bool hp = false) {
-  if (hp) {
-    checkBounds<Constants::PokemonHpStat>(stat);
-  }
-  else {
-    checkBounds<Constants::PokemonEffectiveStat>(stat);
+void checkEffectiveStat(types::stat stat, dex::Stat name = dex::Stat::NONE) {
+  switch (name) {
+    case dex::Stat::HP: {
+      checkBounds<Constants::PokemonCurrentHpStat>(stat);
+      break;
+    }
+    case dex::Stat::SPE: {
+      checkBounds<Constants::PokemonEffectiveSpeStat>(stat);
+      break;
+    }
+    default: {
+      checkBounds<Constants::PokemonEffectiveStat>(stat);
+      break;
+    }
   }
 }
 
@@ -1259,32 +1267,32 @@ void check(const stat::Spe& spe) {
 
 template <>
 void check(const stat::CurrentHp& hp) {
-  checkBounds<Constants::PokemonCurrentHpStat>(hp.val);
+  checkEffectiveStat(hp.val, dex::Stat::HP);
 }
 
 template <>
 void check(const stat::EffectiveAtk& atk) {
-  checkEffectiveStat(atk.val);
+  checkEffectiveStat(atk.val, dex::Stat::ATK);
 }
 
 template <>
 void check(const stat::EffectiveDef& def) {
-  checkEffectiveStat(def.val);
+  checkEffectiveStat(def.val, dex::Stat::DEF);
 }
 
 template <>
 void check(const stat::EffectiveSpa& spa) {
-  checkEffectiveStat(spa.val);
+  checkEffectiveStat(spa.val, dex::Stat::SPA);
 }
 
 template <>
 void check(const stat::EffectiveSpd& spd) {
-  checkEffectiveStat(spd.val);
+  checkEffectiveStat(spd.val, dex::Stat::SPD);
 }
 
 template <>
 void check(const stat::EffectiveSpe& spe) {
-  checkEffectiveStat(spe.val);
+  checkEffectiveStat(spe.val, dex::Stat::SPE);
 }
 
 template <>
@@ -1587,10 +1595,10 @@ types::sides<SideStateSetup> Simulation::createInitialBattle(
   if (battleInfo.runWithSimulateTurn) {
     battleStateSetup.setProperty<tags::SimulateTurn>();
   }
-  if (battleInfo.runWithCalculateDamage || !battleInfo.damageCalculations.empty()) {
+  if (battleInfo.runWithCalculateDamage) {
     battleStateSetup.setProperty<tags::CalculateDamage>();
   }
-  if (battleInfo.runWithAnalyzeEffect || !battleInfo.effectsToAnalyze.empty()) {
+  if (battleInfo.runWithAnalyzeEffect) {
     battleStateSetup.setProperty<tags::AnalyzeEffect>();
   }
 
@@ -1901,32 +1909,17 @@ void Simulation::run() {
   analyzeEffect();
 }
 
-types::entityVector Simulation::selectedBattleEntities() const {
-  if (hasActiveSelection<tags::SelectedForViewBattle>()) {
-    auto view = registry.view<tags::SelectedForViewBattle, tags::Battle>();
-    return {view.begin(), view.end()};
-  }
-
+types::entityVector Simulation::battleEntities() const {
   auto view = registry.view<tags::Battle>();
   return {view.begin(), view.end()};
 }
 
-types::entityVector Simulation::selectedMoveEntities() const {
-  if (hasActiveSelection<tags::SelectedForViewMove>()) {
-    auto view = registry.view<tags::SelectedForViewMove, tags::CurrentActionMove>();
-    return {view.begin(), view.end()};
-  }
-
+types::entityVector Simulation::moveEntities() const {
   auto view = registry.view<tags::CurrentActionMove>();
   return {view.begin(), view.end()};
 }
 
-types::entityVector Simulation::selectedPokemonEntities() const {
-  if (hasActiveSelection<tags::SelectedForViewPokemon>()) {
-    auto view = registry.view<tags::SelectedForViewPokemon, tags::Pokemon>();
-    return {view.begin(), view.end()};
-  }
-
+types::entityVector Simulation::pokemonEntities() const {
   auto view = registry.view<tags::Pokemon>();
   return {view.begin(), view.end()};
 }
@@ -1936,8 +1929,6 @@ types::entityVector Simulation::selectedPokemonEntities() const {
 
 ///////////////////// START OF src/Simulation/RunEvent.cpp /////////////////////
 
-#include <type_traits>
-
 // TODO(aed3) Autogenerate?
 
 namespace pokesim {
@@ -1947,37 +1938,6 @@ void applyEventModifier(ModifiedComponent& component, EventModifier eventModifie
   component.val = applyChainedModifier(component.val, eventModifier.val);
 }
 
-template <typename... PokemonSpecifiers>
-internal::RegistryContainer::SelectionFunction getMoveEventPokemonSelector() {
-  static const size_t SelectAnyPokemon = sizeof...(PokemonSpecifiers) == 0U;
-  return internal::RegistryContainer::SelectionFunction{
-    [](const void*, const types::registry& registry) -> types::entityVector {
-      entt::dense_set<types::entity> entities;
-      auto selectedMoveView = registry.view<tags::SelectedForViewMove>();
-      auto begin = selectedMoveView.begin();
-      auto end = selectedMoveView.end();
-      if (selectedMoveView.empty()) {
-        auto anyMoveView = registry.view<tags::CurrentActionMove>();
-        begin = anyMoveView.begin();
-        end = anyMoveView.end();
-      }
-
-      std::for_each(begin, end, [&registry, &entities](types::entity entity) {
-        if constexpr (
-          SelectAnyPokemon || std::disjunction_v<std::is_same<PokemonSpecifiers, tags::CurrentActionMoveSource>...>) {
-          entities.insert(registry.get<CurrentActionSource>(entity).val);
-        }
-
-        if constexpr (
-          SelectAnyPokemon || std::disjunction_v<std::is_same<PokemonSpecifiers, tags::CurrentActionMoveTarget>...>) {
-          entities.insert(registry.get<CurrentActionTarget>(entity).val);
-        }
-      });
-
-      return {entities.begin(), entities.end()};
-    }};
-}
-
 void applyBasePowerEventModifier(types::handle moveHandle, BasePower basePower, EventModifier eventModifier) {
   calc_damage::Power& power = moveHandle.emplace<calc_damage::Power>(basePower.val);
   power.val = applyChainedModifier(power.val, eventModifier.val);
@@ -1990,32 +1950,28 @@ void runBeforeMove(Simulation& simulation) {
 }
 
 void runResidual(Simulation& simulation) {
-  pokesim::internal::SelectForPokemonView<tags::ActivePokemon> selectedPokemon{simulation};
-  if (selectedPokemon.hasNoneSelected()) {
-    return;
-  }
   dex::Burn::onResidual(simulation);
 }
 
 void runAccuracyEvent(Simulation&) {}
 
 void runModifyAccuracyEvent(Simulation& simulation) {
-  simulation.addToEntities<EventModifier, tags::SelectedForViewMove, Accuracy>();
+  simulation.addToEntities<EventModifier, tags::CurrentMoveHit, Accuracy>();
 
   dex::BrightPowder::onModifyAccuracy(simulation);
 
-  simulation.viewForSelectedMoves<applyEventModifier<Accuracy>>();
+  simulation.view<applyEventModifier<Accuracy>>();
   simulation.registry.clear<EventModifier>();
 }
 
 void runModifyCritBoostEvent(Simulation&) {}
 
 void runBasePowerEvent(Simulation& simulation) {
-  simulation.addToEntities<EventModifier, tags::SelectedForViewMove, BasePower>();
+  simulation.addToEntities<EventModifier, tags::CurrentMoveHit, BasePower>();
 
   dex::KnockOff::onBasePower(simulation);
 
-  simulation.viewForSelectedMoves<applyBasePowerEventModifier>();
+  simulation.view<applyBasePowerEventModifier>();
   simulation.registry.clear<EventModifier>();
 }
 
@@ -2075,10 +2031,6 @@ template void runAfterEachBoostEvent<SpeBoost>(Simulation&);
 void runAfterBoostEvent(Simulation&) {}
 
 void runModifyMove(Simulation& simulation) {
-  // internal::SelectForPokemonView<> selectedPokemon{
-  //   simulation,
-  //   getMoveEventPokemonSelector<tags::CurrentActionMoveSource>()};
-
   dex::ChoiceScarf::onSourceModifyMove(simulation);
   dex::ChoiceSpecs::onSourceModifyMove(simulation);
 }
@@ -2092,7 +2044,7 @@ void runModifyAtk(Simulation&) {}
 void runModifyDef(Simulation&) {}
 
 void runModifySpa(Simulation& simulation) {
-  simulation.addToEntities<EventModifier, tags::SelectedForViewPokemon>();
+  simulation.addToEntities<EventModifier, tags::SpaStatUpdateRequired>();
 
   // Priority 1
   dex::ChoiceSpecs::onModifySpa(simulation);
@@ -2100,25 +2052,25 @@ void runModifySpa(Simulation& simulation) {
   // Priority 5
   dex::Plus::onModifySpA(simulation);
 
-  simulation.viewForSelectedPokemon<applyEventModifier<stat::EffectiveSpa>>();
+  simulation.view<applyEventModifier<stat::EffectiveSpa>>();
   simulation.registry.clear<EventModifier>();
 }
 
 void runModifySpd(Simulation& simulation) {
-  simulation.addToEntities<EventModifier, tags::SelectedForViewPokemon>();
+  simulation.addToEntities<EventModifier, tags::SpdStatUpdateRequired>();
 
   dex::AssaultVest::onModifySpd(simulation);
 
-  simulation.viewForSelectedPokemon<applyEventModifier<stat::EffectiveSpd>>();
+  simulation.view<applyEventModifier<stat::EffectiveSpd>>();
   simulation.registry.clear<EventModifier>();
 }
 
 void runModifySpe(Simulation& simulation) {
-  simulation.addToEntities<EventModifier, tags::SelectedForViewPokemon>();
+  simulation.addToEntities<EventModifier, tags::SpeStatUpdateRequired>();
 
   dex::ChoiceScarf::onModifySpe(simulation);
 
-  simulation.viewForSelectedPokemon<applyEventModifier<stat::EffectiveSpe>>();
+  simulation.view<applyEventModifier<stat::EffectiveSpe>>();
   simulation.registry.clear<EventModifier>();
 
   dex::Paralysis::onModifySpe(simulation);
@@ -2165,15 +2117,13 @@ void removeHitCountFromFaintedTargets(types::handle moveHandle, CurrentActionTar
 
 template <auto Function>
 void runMoveHitCheck(Simulation& simulation) {
-  simulation.addToEntities<tags::CurrentMoveHit, tags::CurrentActionMove>();
-
-  internal::SelectForCurrentActionMoveView<tags::CurrentMoveHit> selectedMoves{simulation};
-  if (selectedMoves.hasNoneSelected()) {
+  if (simulation.registry.view<tags::CurrentActionMove>().empty()) {
     return;
   }
 
+  simulation.addToEntities<tags::CurrentMoveHit, tags::CurrentActionMove>();
+
   Function(simulation);
-  selectedMoves.deselect();
 
   simulation.view<setFailedActionMove, Tags<tags::FailedCurrentMoveHit>>();
   simulation.registry.clear<tags::CurrentMoveHit, tags::FailedCurrentMoveHit>();
@@ -2199,14 +2149,14 @@ void setEffectTarget(types::handle handle, TargetEntityHolder target) {
 }
 
 void runMoveEffects(Simulation& simulation) {
-  internal::SelectForCurrentActionMoveView<internal::tags::RunEffect> selectedMoves{simulation};
-  if (selectedMoves.hasNoneSelected()) {
+  internal::EntityFilter<internal::tags::RunEffect> moveFilter{simulation};
+  if (moveFilter.hasNoneSelected()) {
     return;
   }
 
-  simulation.viewForSelectedMoves<setEffectSource>();
-  simulation.viewForSelectedMoves<setEffectTarget<CurrentActionSource>, Tags<move::effect::tags::MoveSource>>();
-  simulation.viewForSelectedMoves<setEffectTarget<CurrentActionTarget>, Tags<move::effect::tags::MoveTarget>>();
+  moveFilter.view<setEffectSource>();
+  moveFilter.view<setEffectTarget<CurrentActionSource>, Tags<move::effect::tags::MoveSource>>();
+  moveFilter.view<setEffectTarget<CurrentActionTarget>, Tags<move::effect::tags::MoveTarget>>();
 
   tryBoost(simulation);
   trySetStatus(simulation);
@@ -2245,17 +2195,15 @@ void removeFaintedSecondaryEffectTarget(
 // exists that has a random chance to add a side or field affect regardless of the target's HP, then this function will
 // need to be reworked.
 void removeFaintedSecondaryEffectTargets(Simulation& simulation) {
-  internal::SelectForCurrentActionMoveView<move::effect::tags::Secondary> selectedMoves{simulation};
-  if (selectedMoves.hasNoneSelected()) {
+  internal::EntityFilter<move::effect::tags::Secondary> moveFilter{simulation};
+  if (moveFilter.hasNoneSelected()) {
     return;
   }
 
-  simulation.viewForSelectedMoves<
-    removeFaintedSecondaryEffectTarget<CurrentActionSource>,
-    Tags<move::effect::tags::MoveSource>>(simulation.simulateTurnOptions);
-  simulation.viewForSelectedMoves<
-    removeFaintedSecondaryEffectTarget<CurrentActionTarget>,
-    Tags<move::effect::tags::MoveTarget>>(simulation.simulateTurnOptions);
+  moveFilter.view<removeFaintedSecondaryEffectTarget<CurrentActionSource>, Tags<move::effect::tags::MoveSource>>(
+    simulation.simulateTurnOptions);
+  moveFilter.view<removeFaintedSecondaryEffectTarget<CurrentActionTarget>, Tags<move::effect::tags::MoveTarget>>(
+    simulation.simulateTurnOptions);
 }
 
 // TODO(aed3): When adding damage source, change this to accept the move's handle and CurrentActionSource to pass to
@@ -2281,7 +2229,7 @@ void setMoveHitCount(Simulation& simulation) {
 }
 
 void applyDamage(Simulation& simulation) {
-  simulation.viewForSelectedMoves<applyDamageToTarget>();
+  simulation.view<applyDamageToTarget>();
 
   auto view = simulation.registry.view<tags::CurrentMoveHit>(entt::exclude<Damage, move::tags::Status>);
   simulation.registry.insert<tags::FailedCurrentMoveHit>(view.begin(), view.end());
@@ -2326,11 +2274,6 @@ void moveHitLoop(Simulation& simulation) {
   while (!simulation.registry.view<HitCount>().empty()) {
     POKESIM_REQUIRE(iterations <= MoveHitLimits::MAX, "More hits were ran more than possible.");
 
-    internal::SelectForCurrentActionMoveView<HitCount> selectedMoves{simulation};
-    POKESIM_REQUIRE(
-      !selectedMoves.hasNoneSelected(),
-      "HitCount should only be present on active moves, meaning this loop should only be entered if there are moves to "
-      "select.");
     calc_damage::run(simulation);  // 1. call to this.battle.getDamage
     runDamageEvent(simulation);
 
@@ -2368,6 +2311,10 @@ void runMoveHitChecks(Simulation& simulation) {
 
 namespace pokesim::simulate_turn {
 namespace {
+auto getBattleFilter(Simulation& simulation) {
+  return pokesim::internal::EntityFilter<pokesim::tags::SimulateTurn, pokesim::tags::Battle>{simulation};
+}
+
 void addTargetAllyToTargets(types::registry& registry, const Battle& battle) {
   const Sides& sides = registry.get<Sides>(battle.val);
   const TargetSlotName& targetSlotName = registry.get<TargetSlotName>(registry.get<CurrentAction>(battle.val).val);
@@ -2419,6 +2366,7 @@ void getMoveTargets(Simulation& simulation) {
     simulation
       .view<addUserAllyToTargets, Tags<pokesim::tags::CurrentActionMove, move::added_targets::tags::UserAlly>>();
   }
+
   simulation.view<resolveMoveTargets, Tags<pokesim::tags::CurrentActionMove>, entt::exclude_t<AddedTargets>>();
   simulation.view<
     createActionMoveForTargets,
@@ -2445,7 +2393,7 @@ void removeActionBySource(types::handle sourceHandle, Battle battle) {
 }
 
 void runMoveAction(Simulation& simulation) {
-  simulation.viewForSelectedBattles<setCurrentActionSource, Tags<action::tags::Move>>();
+  getBattleFilter(simulation).view<setCurrentActionSource, Tags<action::tags::Move>>();
 
   simulation.view<
     removeActionBySource<action::tags::Move>,
@@ -2455,11 +2403,13 @@ void runMoveAction(Simulation& simulation) {
     Tags<pokesim::tags::CurrentActionMoveSource>,
     entt::exclude_t<pokesim::tags::ActivePokemon>>();
 
-  pokesim::internal::SelectForBattleView<action::tags::Move> selectedBattle{simulation};
-  if (selectedBattle.hasNoneSelected()) return;
+  pokesim::internal::EntityFilter<action::tags::Move, pokesim::tags::Battle> battleFilter{simulation};
+  if (battleFilter.hasNoneSelected()) {
+    return;
+  }
 
-  simulation.viewForSelectedBattles<setCurrentActionTarget>(simulation);
-  simulation.viewForSelectedBattles<setCurrentActionMove>(simulation.pokedex());
+  battleFilter.view<setCurrentActionTarget>(simulation);
+  battleFilter.view<setCurrentActionMove>(simulation.pokedex());
 
   runBeforeMove(simulation);
 
@@ -2470,10 +2420,12 @@ void runMoveAction(Simulation& simulation) {
 }
 
 void runResidualAction(Simulation& simulation) {
-  pokesim::internal::SelectForBattleView<action::tags::Residual> selectedBattle{simulation};
-  if (selectedBattle.hasNoneSelected()) return;
+  pokesim::internal::EntityFilter<action::tags::Residual, pokesim::tags::Battle> battleFilter{simulation};
+  if (battleFilter.hasNoneSelected()) {
+    return;
+  }
 
-  simulation.viewForSelectedBattles<speedSort, Tags<tags::SpeedSortNeeded>>();
+  battleFilter.view<speedSort, Tags<tags::SpeedSortNeeded>>();
   simulation.registry.clear<tags::SpeedSortNeeded>();
 
   runResidual(simulation);
@@ -2509,6 +2461,11 @@ void checkWin(types::handle battleHandle, const Sides& sides) {
 }
 
 void faintPokemon(Simulation& simulation) {
+  auto battleFilter = getBattleFilter(simulation);
+  if (battleFilter.hasNoneSelected()) {
+    return;
+  }
+
   using LoopLimits = Constants::ActivePokemon;
   types::activePokemonIndex iterations = LoopLimits::MIN;
   while (!simulation.registry.view<FaintQueue>().empty()) {
@@ -2516,27 +2473,31 @@ void faintPokemon(Simulation& simulation) {
       iterations <= LoopLimits::MAX,
       "More Pokemon were queued to faint in at least one battle than possible.");
 
-    simulation.viewForSelectedBattles<setFainting>();
+    battleFilter.view<setFainting>();
 
-    pokesim::internal::SelectForPokemonView<pokesim::tags::Fainting> selectedPokemon{simulation};
+    pokesim::internal::EntityFilter<pokesim::tags::Fainting> pokemonFilter{simulation};
     POKESIM_REQUIRE(
-      !selectedPokemon.hasNoneSelected(),
+      !pokemonFilter.hasNoneSelected(),
       "This loop should only be run if setFainting had Pokemon to set as fainting.");
 
     runFaintEvent(simulation);
     runEndAbilityEvent(simulation);
+
+    pokemonFilter.addToSelected<pokesim::tags::EndItem>();
     runEndItemEvent(simulation);
-    simulation.viewForSelectedPokemon<clearVolatiles>();
+    simulation.registry.clear<pokesim::tags::EndItem>();
+
+    pokemonFilter.view<clearVolatiles>();
 
     simulation.addToEntities<pokesim::tags::Fainted, pokesim::tags::Fainting>();
     simulation.removeFromEntities<pokesim::tags::ActivePokemon, pokesim::tags::Fainting>();
     simulation.removeFromEntities<pokesim::tags::Fainting>();
 
-    simulation.viewForSelectedBattles<clearFaintQueue>();
+    battleFilter.view<clearFaintQueue>();
     iterations++;
   }
 
-  simulation.viewForSelectedBattles<checkWin, Tags<>, entt::exclude_t<Winner>>();
+  battleFilter.view<checkWin, Tags<>, entt::exclude_t<Winner>>();
 
   runAfterFaintEvent(simulation);
 }
@@ -2552,7 +2513,7 @@ void runCurrentAction(Simulation& simulation) {
   // Switch requests
 
   updateAllStats(simulation);
-  simulation.viewForSelectedBattles<speedSort, Tags<tags::SpeedSortNeeded>>();
+  getBattleFilter(simulation).view<speedSort, Tags<tags::SpeedSortNeeded>>();
   simulation.registry.clear<tags::SpeedSortNeeded>();
 }
 
@@ -2565,13 +2526,15 @@ void updateActivePokemonPostTurn(types::registry& registry, const pokesim::MoveS
 }
 
 void nextTurn(Simulation& simulation) {
-  simulation.viewForSelectedBattles<incrementTurn>();
+  getBattleFilter(simulation).view<incrementTurn>();
 
-  pokesim::internal::SelectForPokemonView<pokesim::tags::SimulateTurn, pokesim::tags::ActivePokemon> selectedPokemon{
-    simulation};
-  if (!selectedPokemon.hasNoneSelected()) {
-    simulation.viewForSelectedPokemon<updateActivePokemonPostTurn>();
+  pokesim::internal::EntityFilter<pokesim::tags::SimulateTurn, pokesim::tags::ActivePokemon> pokemonFilter{simulation};
+  if (!pokemonFilter.hasNoneSelected()) {
+    pokemonFilter.view<updateActivePokemonPostTurn>();
+
+    pokemonFilter.addToSelected<pokesim::tags::DisableMove>();
     runDisableMove(simulation);
+    simulation.registry.clear<pokesim::tags::DisableMove>();
   }
 }
 
@@ -2586,35 +2549,33 @@ void simulateTurn(Simulation& simulation) {
     "Rebuild PokeSim with the flag POKESIM_ALL_DAMAGE_ALL_BRANCHES to enable this option combination.");
 #endif
 
+  auto battleFilter = getBattleFilter(simulation);
+  if (battleFilter.hasNoneSelected()) {
+    return;
+  }
+
   if (!options.getApplyChangesToInputBattle()) {
-    simulation.addToEntities<pokesim::tags::CloneFrom, pokesim::tags::Battle, pokesim::tags::SimulateTurn>();
+    simulation.addToEntities<pokesim::tags::CloneFrom, pokesim::tags::SimulateTurn, pokesim::tags::Battle>();
     const auto entityMap = clone(simulation.registry, 1U);
     for (const auto& inputBattleMapping : entityMap) {
       simulation.registry.emplace<tags::Input>(inputBattleMapping.first);
+      simulation.registry.remove<pokesim::tags::SimulateTurn>(inputBattleMapping.first);
     }
   }
 
-  pokesim::internal::SelectForBattleView<pokesim::tags::SimulateTurn> selectedBattles{
-    simulation,
-    entt::exclude<tags::Input>};
-  pokesim::internal::SelectForSideView<pokesim::tags::SimulateTurn> selectedSides{
-    simulation,
-    entt::exclude<tags::Input>};
-  if (selectedBattles.hasNoneSelected() || selectedSides.hasNoneSelected()) return;
-
-  simulation.viewForSelectedBattles<assignRootBattle>();
+  battleFilter.view<assignRootBattle>();
 
   updateAllStats(simulation);
-  simulation.viewForSelectedSides<resolveDecision>();
-  simulation.removeFromEntities<SideDecision, pokesim::tags::SelectedForViewSide>();
+  simulation.view<resolveDecision, Tags<pokesim::tags::SimulateTurn>>();
+  simulation.removeFromEntities<SideDecision, pokesim::tags::SimulateTurn>();
 
-  // simulation.viewForSelectedBattles<addBeforeTurnAction, Tags<>, entt::exclude_t<pokesim::tags::BattleMidTurn>>();
-  simulation.viewForSelectedBattles<speedSort>();
-  simulation.viewForSelectedBattles<addResidualAction, Tags<>, entt::exclude_t<pokesim::tags::BattleMidTurn>>();
+  // battleFilter.view<addBeforeTurnAction, Tags<>, entt::exclude_t<pokesim::tags::BattleMidTurn>>();
+  battleFilter.view<speedSort>();
+  battleFilter.view<addResidualAction, Tags<>, entt::exclude_t<pokesim::tags::BattleMidTurn>>();
 
-  simulation.addToEntities<pokesim::tags::BattleMidTurn, Turn, pokesim::tags::SelectedForViewBattle>();
+  simulation.addToEntities<pokesim::tags::BattleMidTurn, Turn, pokesim::tags::SimulateTurn, pokesim::tags::Battle>();
 
-  simulation.viewForSelectedBattles<setCurrentAction>();
+  battleFilter.view<setCurrentAction>();
   using ActionsLimit = Constants::ActionQueueLength;
   types::actionQueueIndex actionsTaken = ActionsLimit::MIN;
   while (!simulation.registry.view<action::tags::Current>().empty()) {
@@ -2623,14 +2584,17 @@ void simulateTurn(Simulation& simulation) {
       "More actions in a turn were queued to be taken than in at least one battle than are possible.");
 
     runCurrentAction(simulation);
-    simulation.viewForSelectedBattles<setCurrentAction, Tags<>, entt::exclude_t<Winner>>();
+    battleFilter.view<setCurrentAction, Tags<>, entt::exclude_t<Winner>>();
     actionsTaken++;
   }
 
   nextTurn(simulation);
 
-  simulation.removeFromEntities<pokesim::tags::BattleMidTurn, Turn, pokesim::tags::SelectedForViewBattle>();
-  simulation.viewForSelectedBattles<collectTurnOutcomeBattles>();
+  simulation
+    .removeFromEntities<pokesim::tags::BattleMidTurn, Turn, pokesim::tags::SimulateTurn, pokesim::tags::Battle>();
+  battleFilter.view<collectTurnOutcomeBattles>();
+
+  simulation.addToEntities<pokesim::tags::SimulateTurn, tags::Input>();
   simulation.registry.clear<tags::Input>();
 }
 }  // namespace
@@ -2650,6 +2614,7 @@ void run(Simulation& simulation) {
 ////////////////// START OF src/SimulateTurn/RandomChance.cpp //////////////////
 
 #include <optional>
+#include <type_traits>
 
 namespace pokesim::internal {
 namespace {
@@ -3269,6 +3234,7 @@ void resolveTeamDecision(types::registry& registry, const types::teamOrder& team
   battleActionQueue.val.push_back(actionHandle.entity());
 }
 }  // namespace
+
 void resolveDecision(types::handle sideHandle, const SideDecision& sideDecision) {
   POKESIM_REQUIRE(sideDecision.sideId != PlayerSideId::NONE, "Decisions must be assigned to a player.");
   POKESIM_REQUIRE(!sideDecision.decisions.valueless_by_exception(), "Decisions must be non-empty.");
@@ -3332,7 +3298,7 @@ void speedSort(types::handle handle, ActionQueue& actionQueue) {
     speedSortList.push_back({registry->get<SpeedSort>(entity), entity});
   }
 
-  // TODO (aed3): Test how different sorting algorithms affect speed
+  // TODO(aed3): Test how different sorting algorithms affect speed
   std::sort(speedSortList.begin(), speedSortList.end(), [](const auto& pairA, const auto& pairB) {
     if (pairA.first.order != pairB.first.order) {
       return pairA.first.order < pairB.first.order;
@@ -3496,44 +3462,39 @@ types::eventPossibilities countUniqueDamageRolls(types::handle moveHandle) {
 }
 
 void updateAllDamageRollProbabilities(Simulation& simulation) {
-  simulation.viewForSelectedMoves<assignAllDamageRollProbability>();
+  simulation.view<assignAllDamageRollProbability>();
 }
 
 void updatePartialProbabilities(Simulation& simulation) {
-  simulation.viewForSelectedMoves<assignPartialProbability>();
+  simulation.view<assignPartialProbability>();
 }
 }  // namespace
 
 void cloneFromDamageRolls(Simulation& simulation, DamageRollKind damageRollKind) {
-  pokesim::internal::SelectForCurrentActionMoveView<pokesim::tags::SimulateTurn, DamageRolls> selectedMoves{simulation};
-  if (selectedMoves.hasNoneSelected()) return;
+  pokesim::internal::EntityFilter<pokesim::internal::tags::CloneFromDamageRolls> moveFilter{simulation};
+  moveFilter.applySelectionTags<pokesim::tags::SimulateTurn, DamageRolls>();
+  if (moveFilter.hasNoneSelected()) return;
 
   bool forAllDamageRolls = damageRollKind & DamageRollKind::ALL_DAMAGE_ROLLS;
   bool forRequiredDamageRolls = simulation.simulateTurnOptions.getMakeBranchesOnRandomEvents() || forAllDamageRolls;
-  auto applyChoices = [](Simulation& sim) { sim.viewForSelectedMoves<applyDamageRollIndex>(); };
+  auto applyChoices = [](Simulation& sim) { sim.view<applyDamageRollIndex>(); };
   auto updateProbabilities = forAllDamageRolls ? updateAllDamageRollProbabilities : updatePartialProbabilities;
 
-  runRandomEventCount<pokesim::tags::SelectedForViewMove>(
+  runRandomEventCount<pokesim::internal::tags::CloneFromDamageRolls>(
     simulation,
     countUniqueDamageRolls,
     applyChoices,
     updateProbabilities,
     forRequiredDamageRolls);
 
-  simulation.removeFromEntities<DamageRolls, pokesim::tags::SelectedForViewMove>();
+  simulation.removeFromEntities<DamageRolls, pokesim::internal::tags::CloneFromDamageRolls>();
+  moveFilter.clearSelectionTags();
 }
 
 void setIfMoveCrits(Simulation& simulation) {
-  pokesim::internal::SelectForCurrentActionMoveView<pokesim::tags::SimulateTurn> selectedMoves{simulation};
-  if (selectedMoves.hasNoneSelected()) return;
-
-  runReciprocalRandomBinaryChance<calc_damage::CritChanceDivisor, pokesim::tags::SelectedForViewMove>(
-    simulation,
-    [](Simulation& sim) {
-      sim.addToEntities<calc_damage::tags::Crit, pokesim::internal::tags::RandomEventCheckPassed>();
-    });
-
-  simulation.registry.clear<calc_damage::CritChanceDivisor>();
+  runReciprocalRandomBinaryChance<calc_damage::CritChanceDivisor>(simulation, [](Simulation& sim) {
+    sim.addToEntities<calc_damage::tags::Crit, pokesim::internal::tags::RandomEventCheckPassed>();
+  });
 }
 }  // namespace pokesim::simulate_turn
 
@@ -4243,7 +4204,7 @@ void Pokedex::loadForBattleInfo(const std::vector<BattleCreationInfo>& battleInf
 namespace pokesim::dex {
 namespace {
 void knockOffOnBasePowerCheckRemovableItem(
-  types::registry& registry, CurrentActionSource source, CurrentActionTarget target) {
+  types::registry& registry, CurrentActionSource source, CurrentActionTarget target, EventModifier&) {
   if (registry.get<stat::CurrentHp>(source.val).val > Constants::PokemonCurrentHpStat::MIN) {
     registry.emplace_or_replace<tags::CanRemoveItem>(target.val);
   }
@@ -4267,15 +4228,15 @@ void knockOffOnBasePower(
 
 void KnockOff::onBasePower(Simulation& simulation) {
   const auto modifier = simulation.pokedex().getStaticValue<KnockOff::onBasePowerMultiplier>();
-  simulation.viewForSelectedMoves<knockOffOnBasePowerCheckRemovableItem, Tags<move::tags::KnockOff>>();
+  simulation.view<knockOffOnBasePowerCheckRemovableItem, Tags<move::tags::KnockOff>>();
   checkIfCanRemoveItem(simulation);
-  simulation.viewForSelectedMoves<knockOffOnBasePower, Tags<move::tags::KnockOff>>(modifier);
+  simulation.view<knockOffOnBasePower, Tags<move::tags::KnockOff>>(modifier);
 
   simulation.registry.clear<tags::CanRemoveItem>();
 }
 
 void KnockOff::onAfterHit(Simulation& simulation) {
-  simulation.viewForSelectedMoves<knockOffOnAfterHitCheckRemovableItem, Tags<move::tags::KnockOff>>();
+  simulation.view<knockOffOnAfterHitCheckRemovableItem, Tags<move::tags::KnockOff, tags::CurrentMoveHit>>();
   tryRemoveItem(simulation);
   simulation.registry.clear<tags::CanRemoveItem>();
 }
@@ -4321,8 +4282,7 @@ void sourceModifyDamage(
 template <typename SimulationTag>
 struct FocusSashOnAfterModifyDamage {
   static void run(Simulation& simulation, types::damage hpToKeep) {
-    simulation.viewForSelectedPokemon<modifyDamage, Tags<item::tags::FocusSash, SimulationTag, tags::CanUseItem>>(
-      hpToKeep);
+    simulation.view<modifyDamage, Tags<item::tags::FocusSash, SimulationTag, tags::CanUseItem>>(hpToKeep);
   }
 
   static void modifyDamage(
@@ -4334,6 +4294,10 @@ struct FocusSashOnAfterModifyDamage {
 
     types::registry& registry = *pokemonHandle.registry();
     for (types::entity move : moves.val) {
+      if (!registry.all_of<pokesim::tags::CurrentMoveHit>(move)) {
+        continue;
+      }
+
       if constexpr (std::is_same_v<tags::SimulateTurn, SimulationTag>) {
         Damage& damage = registry.get<Damage>(move);
         if (damage.val < hp.val) {
@@ -4362,7 +4326,9 @@ void lifeOrbOnAfterMove(
   bool onlyStatusMoves = true;
   types::registry& registry = *pokemonHandle.registry();
   for (types::entity move : moves.val) {
-    onlyStatusMoves &= registry.all_of<move::tags::Status>(move);
+    if (registry.all_of<pokesim::tags::CurrentActionMove>(move)) {
+      onlyStatusMoves &= registry.all_of<move::tags::Status>(move);
+    }
   }
 
   if (!onlyStatusMoves) {
@@ -4373,28 +4339,25 @@ void lifeOrbOnAfterMove(
 
 void AssaultVest::onModifySpd(Simulation& simulation) {
   const auto modifier = simulation.pokedex().getStaticValue<AssaultVest::onModifySpdModifier>();
-  simulation.viewForSelectedPokemon<chainComponentToModifier<types::effectMultiplier>, Tags<item::tags::AssaultVest>>(
-    modifier,
-    1U);
+
+  simulation.view<chainComponentToModifier<types::effectMultiplier>, Tags<item::tags::AssaultVest>>(modifier, 1U);
 }
 
 void AssaultVest::onEnd(Simulation& simulation) {
-  simulation.addToEntities<tags::SpdStatUpdateRequired, tags::SelectedForViewPokemon, item::tags::AssaultVest>();
+  simulation.addToEntities<tags::SpdStatUpdateRequired, tags::EndItem, item::tags::AssaultVest>();
 }
 
 void BrightPowder::onModifyAccuracy(Simulation& simulation) {
   const auto numerator = simulation.pokedex().getStaticValue<BrightPowder::onModifyAccuracyNumerator>();
   const auto denominator = simulation.pokedex().getStaticValue<BrightPowder::onModifyAccuracyDenominator>();
-  simulation.viewForSelectedPokemon<setMoveTargetModifier<types::eventModifier>, Tags<item::tags::BrightPowder>>(
-    numerator,
-    denominator);
+
+  simulation.view<setMoveTargetModifier<types::eventModifier>, Tags<item::tags::BrightPowder>>(numerator, denominator);
 }
 
 void ChoiceScarf::onModifySpe(Simulation& simulation) {
   const auto modifier = simulation.pokedex().getStaticValue<ChoiceScarf::onModifySpeModifier>();
-  simulation.viewForSelectedPokemon<chainComponentToModifier<types::effectMultiplier>, Tags<item::tags::ChoiceScarf>>(
-    modifier,
-    1U);
+
+  simulation.view<chainComponentToModifier<types::effectMultiplier>, Tags<item::tags::ChoiceScarf>>(modifier, 1U);
 }
 
 void ChoiceScarf::onSourceModifyMove(Simulation& simulation) {
@@ -4403,14 +4366,13 @@ void ChoiceScarf::onSourceModifyMove(Simulation& simulation) {
 }
 
 void ChoiceScarf::onEnd(Simulation& simulation) {
-  simulation.addToEntities<tags::SpeStatUpdateRequired, tags::SelectedForViewPokemon, item::tags::ChoiceScarf>();
+  simulation.addToEntities<tags::SpeStatUpdateRequired, tags::EndItem, item::tags::ChoiceScarf>();
 }
 
 void ChoiceSpecs::onModifySpa(Simulation& simulation) {
   const auto modifier = simulation.pokedex().getStaticValue<ChoiceSpecs::onModifySpaModifier>();
-  simulation.viewForSelectedPokemon<chainComponentToModifier<types::effectMultiplier>, Tags<item::tags::ChoiceSpecs>>(
-    modifier,
-    1U);
+
+  simulation.view<chainComponentToModifier<types::effectMultiplier>, Tags<item::tags::ChoiceSpecs>>(modifier, 1U);
 }
 
 void ChoiceSpecs::onSourceModifyMove(Simulation& simulation) {
@@ -4419,11 +4381,12 @@ void ChoiceSpecs::onSourceModifyMove(Simulation& simulation) {
 }
 
 void ChoiceSpecs::onEnd(Simulation& simulation) {
-  simulation.addToEntities<tags::SpaStatUpdateRequired, tags::SelectedForViewPokemon, item::tags::ChoiceSpecs>();
+  simulation.addToEntities<tags::SpaStatUpdateRequired, tags::EndItem, item::tags::ChoiceSpecs>();
 }
 
 void FocusSash::onAfterModifyDamage(Simulation& simulation) {
   const auto hpToKeep = simulation.pokedex().getStaticValue<FocusSash::onAfterModifyDamageHpToKeep>();
+
   simulation.addToEntities<tags::CanUseItem, tags::CurrentActionMoveTarget, item::tags::FocusSash>();
   checkIfCanUseItem(simulation);
 
@@ -4440,14 +4403,14 @@ void FocusSash::onDamage(Simulation& simulation) {
 void LifeOrb::onModifyDamage(Simulation& simulation) {
   const auto numerator = simulation.pokedex().getStaticValue<LifeOrb::onModifyDamageNumerator>();
   const auto denominator = simulation.pokedex().getStaticValue<LifeOrb::onModifyDamageDenominator>();
-  simulation.viewForSelectedPokemon<sourceModifyDamage<types::eventModifier>, Tags<item::tags::LifeOrb>>(
-    numerator,
-    denominator);
+
+  simulation.view<sourceModifyDamage<types::eventModifier>, Tags<item::tags::LifeOrb>>(numerator, denominator);
 }
 
 void LifeOrb::onAfterMoveUsed(Simulation& simulation) {
   const auto divisor = simulation.pokedex().getStaticValue<LifeOrb::onAfterMoveUsedHpDecreaseDivisor>();
-  simulation.viewForSelectedPokemon<lifeOrbOnAfterMove, Tags<item::tags::LifeOrb>>(divisor);
+
+  simulation.view<lifeOrbOnAfterMove, Tags<item::tags::LifeOrb>>(divisor);
 }
 }  // namespace pokesim::dex
 
@@ -4506,21 +4469,24 @@ void choiceLockOnDisableMove(
 }  // namespace
 
 void Burn::onSetDamageRollModifiers(Simulation& simulation) {
-  simulation
-    .viewForSelectedPokemon<applyBurnModifier, Tags<status::tags::Burn> /*, entt::exclude<ability::tags::Guts> */>();
+  simulation.view<applyBurnModifier, Tags<status::tags::Burn> /*, entt::exclude<ability::tags::Guts> */>();
 }
 
 void Burn::onResidual(Simulation& simulation) {
   const auto divisor = simulation.pokedex().getStaticValue<Burn::onResidualHpDecreaseDivisor>();
-  simulation.viewForSelectedPokemon<damageByHpDivisor, Tags<status::tags::Burn>>(divisor);
+
+  simulation.view<damageByHpDivisor, Tags<status::tags::Burn, tags::ActivePokemon>>(divisor);
 }
 
 void Paralysis::onModifySpe(Simulation& simulation) {
   const auto speedDivisor = simulation.pokedex().getStaticValue<Paralysis::speedDivisor>();
   const auto speedDividend = simulation.pokedex().getStaticValue<Paralysis::speedDividend>();
-  simulation.viewForSelectedPokemon<
+
+  simulation.view<
     paralysisOnModifySpeed,
-    Tags<status::tags::Paralysis> /*, entt::exclude_t<ability::tags::QuickFeet>*/>(speedDivisor, speedDividend);
+    Tags<status::tags::Paralysis, tags::SpeStatUpdateRequired> /*, entt::exclude_t<ability::tags::QuickFeet>*/>(
+    speedDivisor,
+    speedDividend);
 }
 
 void Paralysis::onBeforeMove(Simulation& simulation) {
@@ -4532,23 +4498,26 @@ void Paralysis::onBeforeMove(Simulation& simulation) {
 
   pokesim::internal::randomBinaryChance(
     simulation,
-    [](Simulation& sim) {
-      sim.viewForSelectedPokemon<paralysisOnBeforeMove, Tags<pokesim::internal::tags::RandomEventCheckPassed>>();
-    },
+    [](Simulation& sim) { sim.view<paralysisOnBeforeMove, Tags<pokesim::internal::tags::RandomEventCheckPassed>>(); },
     std::nullopt);
   simulation.view<setFailedActionMove, Tags<pokesim::tags::FailedCurrentMoveHit>>();
-  simulation.registry.clear<tags::FailedCurrentMoveHit>();
+  simulation.registry.clear<pokesim::tags::FailedCurrentMoveHit>();
 }
 
 void ChoiceLock::onBeforeMove(Simulation& simulation) {
-  simulation.viewForSelectedPokemon<choiceLockRemoveWithoutItem, Tags<>, entt::exclude_t<ItemName>>();
-  simulation.viewForSelectedPokemon<choiceLockRemoveWithItem>(simulation.pokedex());
+  simulation.view<choiceLockRemoveWithoutItem, Tags<>, entt::exclude_t<ItemName>>();
+  simulation.view<choiceLockRemoveWithItem>(simulation.pokedex());
 }
 
 void ChoiceLock::onDisableMove(Simulation& simulation) {
-  simulation.viewForSelectedPokemon<choiceLockRemoveWithoutItem, Tags<>, entt::exclude_t<ItemName>>();
-  simulation.viewForSelectedPokemon<choiceLockRemoveWithItem>(simulation.pokedex());
-  simulation.viewForSelectedPokemon<choiceLockOnDisableMove>();
+  pokesim::internal::EntityFilter<tags::DisableMove> filter{simulation};
+  if (filter.hasNoneSelected()) {
+    return;
+  }
+
+  filter.view<choiceLockRemoveWithoutItem, Tags<>, entt::exclude_t<ItemName>>();
+  filter.view<choiceLockRemoveWithItem>(simulation.pokedex());
+  filter.view<choiceLockOnDisableMove>();
 }
 }  // namespace pokesim::dex
 
@@ -4596,13 +4565,13 @@ void Plus::onModifySpA(Simulation& simulation) {
   if (simulation.isBattleFormat(BattleFormat::SINGLES)) {
     return;
   }
-  simulation.viewForSelectedPokemon<plusOnModifySpa, Tags<ability::tags::Plus>>();
+  simulation.view<plusOnModifySpa, Tags<ability::tags::Plus>>();
 }
 
 void Static::onDamagingHit(Simulation& simulation) {
   const auto chanceOfStatic = simulation.pokedex().getStaticValue<dex::Static::onDamagingHitChance>();
 
-  simulation.viewForSelectedPokemon<staticOnDamagingHit, Tags<ability::tags::Static>>(chanceOfStatic, simulation);
+  simulation.view<staticOnDamagingHit, Tags<ability::tags::Static>>(chanceOfStatic, simulation);
 
   // TODO(aed3): This is now inefficient since the random chance will happen for move sources that cannot have their
   // status changed.
@@ -4650,6 +4619,10 @@ types::entity InputSetup::entity() const {
 
 namespace pokesim::calc_damage {
 namespace {
+auto getMoveFilter(Simulation& simulation) {
+  return pokesim::internal::EntityFilter<pokesim::tags::CurrentMoveHit>{simulation};
+}
+
 void clearRunVariables(Simulation& simulation) {
   simulation.registry.clear<
     tags::Crit,
@@ -4696,10 +4669,6 @@ void setDefendingSide(types::handle moveHandle, Defender defender) {
   types::registry& registry = *moveHandle.registry();
   PlayerSideId playerSide = registry.get<PlayerSide>(registry.get<Side>(defender.val).val).val;
   switch (playerSide) {
-    case PlayerSideId::NONE: {
-      POKESIM_REQUIRE_FAIL("Player side wasn't set properly.");
-      break;
-    }
     case PlayerSideId::P1: {
       moveHandle.emplace<tags::P1Defending>();
       break;
@@ -4708,6 +4677,10 @@ void setDefendingSide(types::handle moveHandle, Defender defender) {
       moveHandle.emplace<tags::P2Defending>();
       break;
     }
+    default: {
+      POKESIM_REQUIRE_FAIL("Player side wasn't set properly.");
+      break;
+    }
   }
 }
 
@@ -4728,6 +4701,7 @@ void modifyDamage(Damage& damage, const DamageRollModifiers& modifiers, const Po
 
   if (modifiers.burn) {
     const auto multiplier = pokedex.getStaticValue<dex::Burn::physicalDamageMultiplier>();
+
     damage.val = (types::damage)fixedPointMultiply(damage.val, multiplier);
   }
 
@@ -4830,7 +4804,7 @@ void setIgnoreDefendingBoostIfPositive(types::handle moveHandle, Defender defend
 void calculateBaseDamage(
   types::handle moveHandle, Power power, AttackingLevel level, AttackingStat attack, DefendingStat defense) {
   types::damage damage = computeBaseDamage(power.val, level.val, attack.val, defense.val);
-  moveHandle.emplace_or_replace<Damage>(damage);
+  moveHandle.emplace<Damage>(damage);
 }
 
 void applyUsesUntilKo(types::handle moveHandle, const DamageRolls& damageRolls, Defender defender) {
@@ -4861,8 +4835,8 @@ void applySideDamageRollOptions(Simulation& simulation) {
     isSimulateTurn || isCalculateDamage || isAnalyzeEffect,
     "Using a type that isn't a valid simulation tag.");
 
-  pokesim::internal::SelectForCurrentActionMoveView<SimulationTag> selectedMoves{simulation};
-  if (selectedMoves.hasNoneSelected()) {
+  pokesim::internal::EntityFilter<SimulationTag, pokesim::tags::CurrentMoveHit> moveFilter{simulation};
+  if (moveFilter.hasNoneSelected()) {
     return;
   }
 
@@ -4887,55 +4861,57 @@ void applySideDamageRollOptions(Simulation& simulation) {
   }
 
   if (damageRollOptions.sidesMatch()) {
+    moveFilter.template addToSelected<internal::tags::ApplySideDamageRollOptions>();
+    simulation.removeFromEntities<internal::tags::ApplySideDamageRollOptions, move::tags::Status>();
     if constexpr (onlyPassDamageRoll) {
       ApplyDamageRollKind(simulation, damageRollOptions.getP1());
     }
     else {
       ApplyDamageRollKind(simulation, damageRollOptions.getP1(), calculateUpToFoeHp, noKoChanceCalculation);
     }
+    simulation.registry.clear<internal::tags::ApplySideDamageRollOptions>();
   }
   else {
-    simulation.viewForSelectedMoves<setDefendingSide>();
-    pokesim::internal::SelectForCurrentActionMoveView<tags::P1Defending> p1DefendingMoves{simulation};
-    if (!p1DefendingMoves.hasNoneSelected()) {
-      if constexpr (onlyPassDamageRoll) {
-        ApplyDamageRollKind(simulation, damageRollOptions.getP1());
-      }
-      else {
-        ApplyDamageRollKind(simulation, damageRollOptions.getP1(), calculateUpToFoeHp, noKoChanceCalculation);
-      }
-    }
-    p1DefendingMoves.deselect();
+    moveFilter.template view<setDefendingSide>();
 
-    pokesim::internal::SelectForCurrentActionMoveView<tags::P2Defending> p2DefendingMoves{simulation};
-    if (!p2DefendingMoves.hasNoneSelected()) {
-      if constexpr (onlyPassDamageRoll) {
-        ApplyDamageRollKind(simulation, damageRollOptions.getP2());
-      }
-      else {
-        ApplyDamageRollKind(simulation, damageRollOptions.getP2(), calculateUpToFoeHp, noKoChanceCalculation);
-      }
+    simulation.addToEntities<internal::tags::ApplySideDamageRollOptions, tags::P1Defending>();
+    simulation.removeFromEntities<internal::tags::ApplySideDamageRollOptions, move::tags::Status>();
+    if constexpr (onlyPassDamageRoll) {
+      ApplyDamageRollKind(simulation, damageRollOptions.getP1());
+    }
+    else {
+      ApplyDamageRollKind(simulation, damageRollOptions.getP1(), calculateUpToFoeHp, noKoChanceCalculation);
     }
+    simulation.registry.clear<internal::tags::ApplySideDamageRollOptions, tags::P1Defending>();
 
-    simulation.registry.clear<tags::P1Defending, tags::P2Defending>();
+    simulation.addToEntities<internal::tags::ApplySideDamageRollOptions, tags::P2Defending>();
+    simulation.removeFromEntities<internal::tags::ApplySideDamageRollOptions, move::tags::Status>();
+    if constexpr (onlyPassDamageRoll) {
+      ApplyDamageRollKind(simulation, damageRollOptions.getP2());
+    }
+    else {
+      ApplyDamageRollKind(simulation, damageRollOptions.getP2(), calculateUpToFoeHp, noKoChanceCalculation);
+    }
+    simulation.registry.clear<internal::tags::ApplySideDamageRollOptions, tags::P2Defending>();
   }
 }
 
 template <typename SimulationTag>
 void setIfMoveCrits(Simulation& simulation, DamageRollKind damageRollKind) {
   if (damageRollKind & DamageRollKind::GUARANTEED_CRIT_CHANCE) {
-    simulation.addToEntities<tags::Crit, pokesim::tags::SelectedForViewMove>();
+    simulation.addToEntities<tags::Crit, internal::tags::ApplySideDamageRollOptions>();
     return;
   }
 
   if constexpr (std::is_same_v<SimulationTag, pokesim::tags::SimulateTurn>) {
-    simulation.addToEntities<calc_damage::CritBoost, pokesim::tags::SelectedForViewMove, pokesim::tags::SimulateTurn>();
+    simulation.addToEntities<calc_damage::CritBoost, internal::tags::ApplySideDamageRollOptions>();
     runModifyCritBoostEvent(simulation);
-    simulation.viewForSelectedMoves<assignCritChanceDivisor>(
+    simulation.view<assignCritChanceDivisor>(
       simulation.pokedex().getStaticValue<MechanicConstants::CRIT_CHANCE_DIVISORS>());
     simulation.registry.clear<CritBoost>();
 
     simulate_turn::setIfMoveCrits(simulation);
+    simulation.registry.clear<CritChanceDivisor>();
   }
 }
 
@@ -4949,37 +4925,42 @@ void applyDamageRollsAndModifiers(
     damageRollKind != DamageRollKind::GUARANTEED_CRIT_CHANCE,
     "Must pick a damage roll kind to go along with crits.");
 
-  simulation.addToEntities<DamageRolls, DamageRollModifiers, pokesim::tags::SelectedForViewMove>();
+  pokesim::internal::EntityFilter<internal::tags::ApplySideDamageRollOptions> moveFilter{simulation};
+  if (moveFilter.hasNoneSelected()) {
+    return;
+  }
+
+  simulation.addToEntities<DamageRolls, DamageRollModifiers, internal::tags::ApplySideDamageRollOptions>();
   if (damageRollKind & DamageRollKind::ALL_DAMAGE_ROLLS) {
-    simulation.viewForSelectedMoves<calculateAllDamageRolls>(simulation.pokedex());
+    moveFilter.view<calculateAllDamageRolls>(simulation.pokedex());
   }
   else {
     if (damageRollKind & DamageRollKind::MAX_DAMAGE) {
-      simulation.viewForSelectedMoves<applyDamageRollModifier>(simulation.pokedex());
+      moveFilter.view<applyDamageRollModifier>(simulation.pokedex());
     }
 
     if (damageRollKind & DamageRollKind::AVERAGE_DAMAGE) {
-      simulation.viewForSelectedMoves<applyAverageDamageRollModifier>(simulation.pokedex());
+      moveFilter.view<applyAverageDamageRollModifier>(simulation.pokedex());
     }
 
     if (damageRollKind & DamageRollKind::MIN_DAMAGE) {
-      simulation.viewForSelectedMoves<applyMinDamageRollModifier>(simulation.pokedex());
+      moveFilter.view<applyMinDamageRollModifier>(simulation.pokedex());
     }
   }
 
   if constexpr (std::is_same_v<pokesim::tags::SimulateTurn, SimulationTag>) {
     if (calculateUpToFoeHp) {
-      simulation.viewForSelectedMoves<reduceDamageRollsToDefenderHp>();
+      moveFilter.view<reduceDamageRollsToDefenderHp>();
     }
     simulate_turn::cloneFromDamageRolls(simulation, damageRollKind);
   }
   else {
-    simulation.viewForSelectedMoves<modifyDamage>(simulation.pokedex());
+    moveFilter.view<modifyDamage>(simulation.pokedex());
     if (calculateUpToFoeHp) {
-      simulation.viewForSelectedMoves<reduceDamageRollsToDefenderHp>();
+      moveFilter.view<reduceDamageRollsToDefenderHp>();
     }
     if (!noKoChanceCalculation && damageRollKind & DamageRollKind::ALL_DAMAGE_ROLLS) {
-      simulation.viewForSelectedMoves<applyUsesUntilKo, Tags<SimulationTag>>();
+      moveFilter.view<applyUsesUntilKo, Tags<SimulationTag>>();
     }
   }
 }
@@ -5013,68 +4994,66 @@ void resetEffectiveAndDefendingStat(types::registry& registry, Defender defender
 template <typename EffectiveStat, typename IgnoresBoostTag, typename UsesStatTag>
 void setUnboostedStat(Simulation& simulation) {
   static constexpr bool forAttacker = std::is_same_v<IgnoresBoostTag, tags::IgnoresAttackingBoost>;
+  auto moveFilter = getMoveFilter(simulation);
+
   if constexpr (forAttacker) {
-    simulation.viewForSelectedMoves<saveRealEffectiveAttackerStat<EffectiveStat>, Tags<IgnoresBoostTag, UsesStatTag>>();
+    moveFilter.view<saveRealEffectiveAttackerStat<EffectiveStat>, Tags<IgnoresBoostTag, UsesStatTag>>();
   }
   else {
-    simulation.viewForSelectedMoves<saveRealEffectiveDefenderStat<EffectiveStat>, Tags<IgnoresBoostTag, UsesStatTag>>();
+    moveFilter.view<saveRealEffectiveDefenderStat<EffectiveStat>, Tags<IgnoresBoostTag, UsesStatTag>>();
   }
 
-  internal::SelectForPokemonView<RealEffectiveStat> selectedPokemon{simulation};
-  if (selectedPokemon.hasNoneSelected()) {
+  if (simulation.registry.view<RealEffectiveStat>().empty()) {
     return;
   }
 
   if constexpr (std::is_same_v<UsesStatTag, tags::UsesAtk>) {
-    simulation.viewForSelectedPokemon<resetEffectiveAtk>();
-    runModifyAtk(simulation);
+    simulation.addToEntities<pokesim::tags::AtkStatUpdateRequired, RealEffectiveStat>();
+    updateAtk(simulation, true);
   }
   else if constexpr (
     std::is_same_v<UsesStatTag, tags::UsesDef> || std::is_same_v<UsesStatTag, tags::UsesDefAsOffense>) {
-    simulation.viewForSelectedPokemon<resetEffectiveDef>();
-    runModifyDef(simulation);
+    simulation.addToEntities<pokesim::tags::DefStatUpdateRequired, RealEffectiveStat>();
+    updateDef(simulation, true);
   }
   else if constexpr (std::is_same_v<UsesStatTag, tags::UsesSpa>) {
-    simulation.viewForSelectedPokemon<resetEffectiveSpa>();
-    runModifySpa(simulation);
+    simulation.addToEntities<pokesim::tags::SpaStatUpdateRequired, RealEffectiveStat>();
+    updateSpa(simulation, true);
   }
   else if constexpr (std::is_same_v<UsesStatTag, tags::UsesSpd>) {
-    simulation.viewForSelectedPokemon<resetEffectiveSpd>();
-    runModifySpd(simulation);
+    simulation.addToEntities<pokesim::tags::SpdStatUpdateRequired, RealEffectiveStat>();
+    updateSpd(simulation, true);
   }
   else {
     static_assert("No other stat is used as the attacking or defending stat.");
   }
 
   if constexpr (forAttacker) {
-    simulation
-      .viewForSelectedMoves<resetEffectiveAndAttackingStat<EffectiveStat>, Tags<IgnoresBoostTag, UsesStatTag>>();
+    moveFilter.view<resetEffectiveAndAttackingStat<EffectiveStat>, Tags<IgnoresBoostTag, UsesStatTag>>();
   }
   else {
-    simulation
-      .viewForSelectedMoves<resetEffectiveAndDefendingStat<EffectiveStat>, Tags<IgnoresBoostTag, UsesStatTag>>();
+    moveFilter.view<resetEffectiveAndDefendingStat<EffectiveStat>, Tags<IgnoresBoostTag, UsesStatTag>>();
   }
 
   simulation.registry.clear<RealEffectiveStat>();
 }
 
 void setDamageFormulaVariables(Simulation& simulation) {
-  simulation.viewForSelectedMoves<setSourceLevel>();
+  auto moveFilter = getMoveFilter(simulation);
+  moveFilter.view<setSourceLevel>();
 
-  simulation.viewForSelectedMoves<setUsedAttackStat<move::tags::Physical>, Tags<move::tags::Physical>>();
-  simulation.viewForSelectedMoves<setUsedAttackStat<move::tags::Special>, Tags<move::tags::Special>>();
-  simulation.viewForSelectedMoves<setUsedDefenseStat<move::tags::Physical>, Tags<move::tags::Physical>>();
-  simulation.viewForSelectedMoves<setUsedDefenseStat<move::tags::Special>, Tags<move::tags::Special>>();
+  moveFilter.view<setUsedAttackStat<move::tags::Physical>, Tags<move::tags::Physical>>();
+  moveFilter.view<setUsedAttackStat<move::tags::Special>, Tags<move::tags::Special>>();
+  moveFilter.view<setUsedDefenseStat<move::tags::Physical>, Tags<move::tags::Physical>>();
+  moveFilter.view<setUsedDefenseStat<move::tags::Special>, Tags<move::tags::Special>>();
 
-  simulation.viewForSelectedMoves<setIgnoreAttackingBoostIfNegative<AtkBoost>, Tags<tags::Crit, tags::UsesAtk>>();
-  simulation.viewForSelectedMoves<setIgnoreAttackingBoostIfNegative<SpaBoost>, Tags<tags::Crit, tags::UsesSpa>>();
-  simulation.viewForSelectedMoves<setIgnoreDefendingBoostIfPositive<DefBoost>, Tags<tags::Crit, tags::UsesDef>>();
-  simulation.viewForSelectedMoves<setIgnoreDefendingBoostIfPositive<SpdBoost>, Tags<tags::Crit, tags::UsesSpd>>();
-  // simulation.viewForSelectedMoves<setIgnoreAttackingBoostIfNegative<DefBoost>, Tags<tags::Crit,
-  // tags::UsesDefAsOffense>>();
+  moveFilter.view<setIgnoreAttackingBoostIfNegative<AtkBoost>, Tags<tags::Crit, tags::UsesAtk>>();
+  moveFilter.view<setIgnoreAttackingBoostIfNegative<SpaBoost>, Tags<tags::Crit, tags::UsesSpa>>();
+  moveFilter.view<setIgnoreDefendingBoostIfPositive<DefBoost>, Tags<tags::Crit, tags::UsesDef>>();
+  moveFilter.view<setIgnoreDefendingBoostIfPositive<SpdBoost>, Tags<tags::Crit, tags::UsesSpd>>();
+  // moveFilter.view<setIgnoreAttackingBoostIfNegative<DefBoost>, Tags<tags::Crit, tags::UsesDefAsOffense>>();
 
-  // simulation.viewForSelectedPokemon<dex::latest::Unaware::onUsesBoost, Tags<ability::tags::Unaware,
-  // tags::Attacker>>();
+  // moveFilter.view<dex::latest::Unaware::onUsesBoost, Tags<ability::tags::Unaware, tags::Attacker>>();
 
   setUnboostedStat<stat::EffectiveAtk, tags::IgnoresAttackingBoost, tags::UsesAtk>(simulation);
   setUnboostedStat<stat::EffectiveSpa, tags::IgnoresAttackingBoost, tags::UsesSpa>(simulation);
@@ -5084,15 +5063,16 @@ void setDamageFormulaVariables(Simulation& simulation) {
 }
 
 void setDamageRollModifiers(Simulation& simulation) {
-  simulation.viewForSelectedMoves<checkForAndApplyStab>();
-  simulation.viewForSelectedMoves<checkForAndApplyTypeEffectiveness>(simulation.pokedex());
+  auto moveFilter = getMoveFilter(simulation);
+  moveFilter.view<checkForAndApplyStab>();
+  moveFilter.view<checkForAndApplyTypeEffectiveness>(simulation.pokedex());
   dex::Burn::onSetDamageRollModifiers(simulation);
   runModifyDamageEvent(simulation);
 }
 
 void calcDamage(Simulation& simulation) {
-  pokesim::internal::SelectForCurrentActionMoveView<> selectedMoves{simulation, entt::exclude<move::tags::Status>};
-  if (selectedMoves.hasNoneSelected()) {
+  auto moveFilter = getMoveFilter(simulation);
+  if (moveFilter.hasNoneSelected()) {
     return;
   }
 
@@ -5107,11 +5087,11 @@ void calcDamage(Simulation& simulation) {
   runBasePowerEvent(simulation);
   setDamageFormulaVariables(simulation);
 
-  simulation.viewForSelectedMoves<calculateBaseDamage>();
-  simulation.viewForSelectedMoves<applyCritDamageIncrease, Tags<tags::Crit>>(
+  moveFilter.view<calculateBaseDamage>();
+  moveFilter.view<applyCritDamageIncrease, Tags<tags::Crit>>(
     simulation.pokedex().getStaticValue<MechanicConstants::CRIT_MULTIPLIER>());
 
-  simulation.addToEntities<DamageRollModifiers, pokesim::tags::SelectedForViewMove>();
+  simulation.addToEntities<DamageRollModifiers, Damage, pokesim::tags::CurrentMoveHit>();
   setDamageRollModifiers(simulation);
 
   applySideDamageRollOptions<SimulateTurn, applyDamageRollsAndModifiers<SimulateTurn>>(simulation);
@@ -5476,7 +5456,7 @@ void removeItemTags(types::handle handle, ItemName item) {
 
 template <typename SelectionTag>
 void removeItemComponents(Simulation& simulation) {
-  simulation.viewForSelectedPokemon<removeItemTags>();
+  simulation.view<removeItemTags, Tags<SelectionTag>>();
   simulation.removeFromEntities<ItemName, SelectionTag>();
   simulation.registry.clear<SelectionTag>();
 }
@@ -5588,11 +5568,6 @@ void checkIfCanUseItem(Simulation& simulation) {
 }
 
 void useItem(Simulation& simulation) {
-  pokesim::internal::SelectForPokemonView<tags::CanUseItem> selectedPokemon{simulation};
-  if (selectedPokemon.hasNoneSelected()) {
-    return;
-  }
-
   runAfterUseItemEvent(simulation);
   removeItemComponents<tags::CanUseItem>(simulation);
 }
@@ -5608,12 +5583,10 @@ void checkIfCanRemoveItem(Simulation& simulation) {
 }
 
 void removeItem(Simulation& simulation) {
-  pokesim::internal::SelectForPokemonView<tags::CanRemoveItem> selectedPokemon{simulation};
-  if (selectedPokemon.hasNoneSelected()) {
-    return;
-  }
-
+  simulation.addToEntities<tags::EndItem, tags::CanRemoveItem>();
   runEndItemEvent(simulation);
+  simulation.registry.clear<tags::EndItem>();
+
   removeItemComponents<tags::CanRemoveItem>(simulation);
 }
 
@@ -5741,73 +5714,83 @@ void tryBoost(Simulation& simulation) {
 }
 
 void updateAllStats(Simulation& simulation) {
-  updateAtk(simulation);
-  updateDef(simulation);
-  updateSpa(simulation);
-  updateSpd(simulation);
-  updateSpe(simulation);
+  updateAtk(simulation, false);
+  updateDef(simulation, false);
+  updateSpa(simulation, false);
+  updateSpd(simulation, false);
+  updateSpe(simulation, false);
 }
 
-void updateAtk(Simulation& simulation) {
-  internal::SelectForPokemonView<tags::AtkStatUpdateRequired> selectedAtkUpdateRequired{simulation};
-  if (selectedAtkUpdateRequired.hasNoneSelected()) return;
+void updateAtk(Simulation& simulation, bool ignoreBoosts) {
+  internal::EntityFilter<tags::AtkStatUpdateRequired> filter{simulation};
+  if (filter.hasNoneSelected()) return;
 
-  simulation.viewForSelectedPokemon<resetEffectiveAtk>();
+  filter.view<resetEffectiveAtk>();
 
-  simulation.viewForSelectedPokemon<applyBoostToEffectiveStat<stat::EffectiveAtk, AtkBoost>>();
+  if (!ignoreBoosts) {
+    filter.view<applyBoostToEffectiveStat<stat::EffectiveAtk, AtkBoost>>();
+  }
   runModifyAtk(simulation);
 
-  simulation.registry.clear<tags::AtkStatUpdateRequired>();
+  filter.clearSelectionTags();
 }
 
-void updateDef(Simulation& simulation) {
-  internal::SelectForPokemonView<tags::DefStatUpdateRequired> selectedDefUpdateRequired{simulation};
-  if (selectedDefUpdateRequired.hasNoneSelected()) return;
+void updateDef(Simulation& simulation, bool ignoreBoosts) {
+  internal::EntityFilter<tags::DefStatUpdateRequired> filter{simulation};
+  if (filter.hasNoneSelected()) return;
 
-  simulation.viewForSelectedPokemon<resetEffectiveDef>();
+  filter.view<resetEffectiveDef>();
 
-  simulation.viewForSelectedPokemon<applyBoostToEffectiveStat<stat::EffectiveDef, DefBoost>>();
+  if (!ignoreBoosts) {
+    filter.view<applyBoostToEffectiveStat<stat::EffectiveDef, DefBoost>>();
+  }
   runModifyDef(simulation);
 
-  simulation.registry.clear<tags::DefStatUpdateRequired>();
+  filter.clearSelectionTags();
 }
 
-void updateSpa(Simulation& simulation) {
-  internal::SelectForPokemonView<tags::SpaStatUpdateRequired> selectedSpaUpdateRequired{simulation};
-  if (selectedSpaUpdateRequired.hasNoneSelected()) return;
+void updateSpa(Simulation& simulation, bool ignoreBoosts) {
+  internal::EntityFilter<tags::SpaStatUpdateRequired> filter{simulation};
+  if (filter.hasNoneSelected()) return;
 
-  simulation.viewForSelectedPokemon<resetEffectiveSpa>();
+  filter.view<resetEffectiveSpa>();
 
-  simulation.viewForSelectedPokemon<applyBoostToEffectiveStat<stat::EffectiveSpa, SpaBoost>>();
+  if (!ignoreBoosts) {
+    filter.view<applyBoostToEffectiveStat<stat::EffectiveSpa, SpaBoost>>();
+  }
   runModifySpa(simulation);
 
-  simulation.registry.clear<tags::SpaStatUpdateRequired>();
+  filter.clearSelectionTags();
 }
 
-void updateSpd(Simulation& simulation) {
-  internal::SelectForPokemonView<tags::SpdStatUpdateRequired> selectedSpdUpdateRequired{simulation};
-  if (selectedSpdUpdateRequired.hasNoneSelected()) return;
+void updateSpd(Simulation& simulation, bool ignoreBoosts) {
+  internal::EntityFilter<tags::SpdStatUpdateRequired> filter{simulation};
+  if (filter.hasNoneSelected()) return;
 
-  simulation.viewForSelectedPokemon<resetEffectiveSpd>();
+  filter.view<resetEffectiveSpd>();
 
-  simulation.viewForSelectedPokemon<applyBoostToEffectiveStat<stat::EffectiveSpd, SpdBoost>>();
+  if (!ignoreBoosts) {
+    filter.view<applyBoostToEffectiveStat<stat::EffectiveSpd, SpdBoost>>();
+  }
   runModifySpd(simulation);
 
-  simulation.registry.clear<tags::SpdStatUpdateRequired>();
+  filter.clearSelectionTags();
 }
 
-void updateSpe(Simulation& simulation) {
-  internal::SelectForPokemonView<tags::SpeStatUpdateRequired> selectedSpeUpdateRequired{simulation};
-  if (selectedSpeUpdateRequired.hasNoneSelected()) return;
+void updateSpe(Simulation& simulation, bool ignoreBoosts) {
+  internal::EntityFilter<tags::SpeStatUpdateRequired> filter{simulation};
+  if (filter.hasNoneSelected()) return;
 
-  simulation.viewForSelectedPokemon<resetEffectiveSpe>();
+  filter.view<resetEffectiveSpe>();
 
-  simulation.viewForSelectedPokemon<applyBoostToEffectiveStat<stat::EffectiveSpe, SpeBoost>>();
+  if (!ignoreBoosts) {
+    filter.view<applyBoostToEffectiveStat<stat::EffectiveSpe, SpeBoost>>();
+  }
   runModifySpe(simulation);
   // trick room
 
-  simulation.viewForSelectedPokemon<setSpeedSortNeeded, Tags<tags::SimulateTurn>>();
-  simulation.registry.clear<tags::SpeStatUpdateRequired>();
+  filter.view<setSpeedSortNeeded, Tags<tags::SimulateTurn>>();
+  filter.clearSelectionTags();
 }
 }  // namespace pokesim
 
@@ -5969,7 +5952,7 @@ void clearCurrentAction(Simulation& simulation) {
   registry.destroy(failedActionMoves.begin(), failedActionMoves.end());
   registry.destroy(currentActions.begin(), currentActions.end());
 
-  auto battles = simulation.selectedBattleEntities();
+  auto battles = simulation.battleEntities();
   registry.remove<
     action::tags::Item,
     ItemName,
@@ -7046,15 +7029,14 @@ void clearRunVariables(Simulation& simulation) {
 }
 
 void analyzeEffect(Simulation& simulation) {
-  pokesim::internal::SelectForPokemonView<pokesim::tags::AnalyzeEffect> selectedPokemon(simulation);
-  pokesim::internal::SelectForBattleView<pokesim::tags::AnalyzeEffect> selectedBattle(simulation);
+  pokesim::internal::EntityFilter<pokesim::tags::AnalyzeEffect> battleFilter(simulation);
 
-  if (selectedPokemon.hasNoneSelected() || selectedBattle.hasNoneSelected()) {
+  if (battleFilter.hasNoneSelected()) {
     return;
   }
 
   simulation.view<ignoreStatusMoves>(simulation.pokedex());
-  simulation.viewForSelectedBattles<groupSimilarInputs>();
+  battleFilter.view<groupSimilarInputs>();
 
   if (!simulation.analyzeEffectOptions.getReconsiderActiveEffects()) {
     ignoreBattlesWithEffectActive(simulation);
diff --git a/extras/PokeSim.hpp b/extras/PokeSim.hpp
index 7267240f..de47dd94 100644
--- a/extras/PokeSim.hpp
+++ b/extras/PokeSim.hpp
@@ -166,6 +166,7 @@
  * src/Components/Tags/MoveTags.hpp
  * src/Components/Tags/NatureTags.hpp
  * src/Components/Tags/PokemonTags.hpp
+ * src/Components/Tags/RunEventTags.hpp
  * src/Components/Tags/Selection.hpp
  * src/Components/Tags/SimulationTags.hpp
  * src/Components/Tags/StatusTags.hpp
@@ -197,7 +198,6 @@
  * src/Simulation/Formulas.hpp
  * src/Utilities/Tags.hpp
  * src/Utilities/RegistryLoop.hpp
- * src/Simulation/RegistryContainer.hpp
  * src/Simulation/Simulation.hpp
  * src/Utilities/DebugChecks.hpp
  * src/Simulation/SimulationSetupDebugChecks.hpp
@@ -236,10 +236,10 @@
  * src/Pokedex/Moves/Thunderbolt.hpp
  * src/Pokedex/Moves/WillOWisp.hpp
  * src/Simulation/RunEvent.hpp
- * src/Utilities/SelectForView.hpp
  * src/Battle/ManageBattleState.hpp
  * src/SimulateTurn/RandomChance.hpp
  * src/Simulation/MoveHitSteps.hpp
+ * src/Utilities/EntityFilter.hpp
  * src/Battle/Side/ManageSideState.hpp
  * src/SimulateTurn/ManageActionQueue.hpp
  * src/SimulateTurn/SimulateTurnDebugChecks.hpp
@@ -17219,6 +17219,14 @@ struct Constants {
     static constexpr std::uint16_t DEFAULT = 1U;
   };
 
+  struct PokemonEffectiveSpeStat {
+    static constexpr std::uint16_t MAX = 65535U;
+    // A Pokemon with a speed stat of 7 or less (i.e. level 1 Shuckle) that is paralyzed with -6 speed boosts can have
+    // no speed.
+    static constexpr std::uint16_t MIN = 0U;
+    static constexpr std::uint16_t DEFAULT = 1U;
+  };
+
   struct PokemonEv {
     static constexpr std::uint8_t MAX = 255U;
     static constexpr std::uint8_t MIN = 0U;
@@ -18442,7 +18450,7 @@ struct MovePair {
 };
 
 struct SkippedInputCount {
-  types::eventPossibilities val = 0U;
+  types::entityIndex val = 0U;
 };
 
 namespace tags {
@@ -19839,15 +19847,22 @@ struct CanSetStatus {};
 
 ////////////////// END OF src/Components/Tags/PokemonTags.hpp //////////////////
 
-////////////////// START OF src/Components/Tags/Selection.hpp //////////////////
+//////////////// START OF src/Components/Tags/RunEventTags.hpp /////////////////
 
 namespace pokesim::tags {
-struct SelectedForViewBattle {};
-struct SelectedForViewSide {};
-struct SelectedForViewPokemon {};
-struct SelectedForViewMove {};
+struct DisableMove {};
+struct EndItem {};
 }  // namespace pokesim::tags
 
+///////////////// END OF src/Components/Tags/RunEventTags.hpp //////////////////
+
+////////////////// START OF src/Components/Tags/Selection.hpp //////////////////
+
+namespace pokesim::internal::tags {
+struct CloneFromDamageRolls {};
+struct ApplySideDamageRollOptions {};
+}  // namespace pokesim::internal::tags
+
 /////////////////// END OF src/Components/Tags/Selection.hpp ///////////////////
 
 /////////////// START OF src/Components/Tags/SimulationTags.hpp ////////////////
@@ -22410,336 +22425,6 @@ struct RegistryLoop<
 
 //////////////////// END OF src/Utilities/RegistryLoop.hpp /////////////////////
 
-//////////////// START OF src/Simulation/RegistryContainer.hpp /////////////////
-
-namespace pokesim::internal {
-class RegistryContainer {
- public:
-  using SelectionFunction = entt::delegate<types::entityVector(const types::registry&)>;
-
- private:
-  template <typename, typename, typename...>
-  friend struct SelectForView;
-
-  using SelectionFunctionList = internal::maxSizedVector<SelectionFunction>;
-  SelectionFunctionList battleSelection{};
-  SelectionFunctionList sideSelection{};
-  SelectionFunctionList pokemonSelection{};
-  SelectionFunctionList moveSelection{};
-
-  template <typename Selection>
-  SelectionFunctionList& selectedFunctions() {
-    if constexpr (std::is_same_v<pokesim::tags::SelectedForViewBattle, Selection>) {
-      return battleSelection;
-    }
-    else if constexpr (std::is_same_v<pokesim::tags::SelectedForViewSide, Selection>) {
-      return sideSelection;
-    }
-    else if constexpr (std::is_same_v<pokesim::tags::SelectedForViewPokemon, Selection>) {
-      return pokemonSelection;
-    }
-    else {
-      return moveSelection;
-    }
-  }
-
-  template <typename Selection>
-  const SelectionFunctionList& selectedFunctions() const {
-    if constexpr (std::is_same_v<pokesim::tags::SelectedForViewBattle, Selection>) {
-      return battleSelection;
-    }
-    else if constexpr (std::is_same_v<pokesim::tags::SelectedForViewSide, Selection>) {
-      return sideSelection;
-    }
-    else if constexpr (std::is_same_v<pokesim::tags::SelectedForViewPokemon, Selection>) {
-      return pokemonSelection;
-    }
-    else {
-      return moveSelection;
-    }
-  }
-
-  template <typename Selection, typename GetNewSelection, typename GetUnmatchedSelection>
-  std::size_t select(
-    GetNewSelection getNewSelection, GetUnmatchedSelection getUnmatchedSelection, SelectionFunction selectionFunction,
-    bool isEmptySelection = false) {
-    auto list = getNewSelection(registry);
-    if (list.empty()) {
-      return 0U;
-    }
-
-    bool narrowSelection = hasActiveSelection<Selection>();
-    std::size_t finalSelectionSize = 0U;
-
-    if (narrowSelection && isEmptySelection) {
-      selectedFunctions<Selection>().push_back(selectionFunction);
-      return registry.view<Selection>().size();
-    }
-    if (narrowSelection) {
-      auto unmatchedSelections = getUnmatchedSelection(registry);
-      std::size_t totalSelected = registry.view<Selection>().size();
-      std::size_t unmatchedSelectionSize = unmatchedSelections.size();
-      if (unmatchedSelectionSize == totalSelected) {
-        return 0U;
-      }
-
-      registry.remove<Selection>(unmatchedSelections.begin(), unmatchedSelections.end());
-
-      POKESIM_REQUIRE(
-        unmatchedSelectionSize < totalSelected,
-        "The number of elements removed from the active selection must be less than the number of elements selected.");
-      finalSelectionSize = totalSelected - unmatchedSelectionSize;
-    }
-    else {
-      registry.clear<Selection>();
-      registry.insert<Selection>(list.begin(), list.end());
-      finalSelectionSize = list.size();
-    }
-
-    selectedFunctions<Selection>().push_back(selectionFunction);
-
-    return finalSelectionSize;
-  }
-
-  template <typename Selection, typename Required, typename... ComponentsToSelect, typename... ComponentsToExclude>
-  std::size_t select(entt::exclude_t<ComponentsToExclude...> exclude) {
-    auto getNewSelection = [&exclude](types::registry& reg) {
-      auto view = reg.view<Required, ComponentsToSelect...>(exclude);
-      return types::entityVector{view.begin(), view.end()};
-    };
-    auto getUnmatchedSelection = [](types::registry& reg) {
-      auto view = reg.view<Selection, ComponentsToExclude...>(entt::exclude<ComponentsToSelect...>);
-      return types::entityVector{view.begin(), view.end()};
-    };
-    SelectionFunction selectionFunction{[](const void*, const types::registry& reg) {
-      auto view = reg.view<Required, ComponentsToSelect...>(entt::exclude<ComponentsToExclude...>);
-      return types::entityVector{view.begin(), view.end()};
-    }};
-
-    return select<Selection>(
-      getNewSelection,
-      getUnmatchedSelection,
-      selectionFunction,
-      sizeof...(ComponentsToSelect) == 0U);
-  }
-
-  template <typename Selection>
-  std::size_t select(SelectionFunction selectionFunction) {
-    auto getUnmatchedSelections = [&selectionFunction](const types::registry& reg) -> types::entityVector {
-      auto upcomingSelection = selectionFunction(reg);
-      auto currentSelection = reg.view<Selection>();
-      auto end =
-        std::remove_if(upcomingSelection.begin(), upcomingSelection.end(), [&currentSelection](types::entity entity) {
-          return !currentSelection.contains(entity);
-        });
-      return {upcomingSelection.begin(), end};
-    };
-
-    return select<Selection>(selectionFunction, getUnmatchedSelections, selectionFunction);
-  }
-
-  template <typename Selection>
-  void deselect() {
-    POKESIM_REQUIRE(hasActiveSelection<Selection>(), "Selections must be present to deselect.");
-
-    registry.clear<Selection>();
-    SelectionFunctionList& functions = selectedFunctions<Selection>();
-    functions.pop_back();
-
-    if (functions.empty()) {
-      return;
-    }
-
-    types::entityVector filteredEntityList = functions[0](registry);
-    auto end = filteredEntityList.end();
-    for (std::size_t i = 1U; i < functions.size(); i++) {
-      types::entityVector previouslySelected = functions[i](registry);
-      end = std::remove_if(filteredEntityList.begin(), end, [&previouslySelected](types::entity entity) {
-        return std::find(previouslySelected.begin(), previouslySelected.end(), entity) == previouslySelected.end();
-      });
-    }
-
-    registry.insert<Selection>(filteredEntityList.begin(), end);
-  }
-
- protected:
-  template <typename Selection>
-  bool hasActiveSelection() const {
-    return !selectedFunctions<Selection>().empty();
-  }
-
- private:
-  template <typename Selected, typename Required, auto Function, typename...>
-  struct ForSelected;
-
-  template <
-    typename Selected, typename Required, auto Function, typename ExcludeContainer, typename IncludeContainer,
-    typename... ExtraTags>
-  struct ForSelected<Selected, Required, Function, Tags<ExtraTags...>, ExcludeContainer, IncludeContainer> {
-    template <typename... PassedInArgs>
-    static void view(RegistryContainer* container, const PassedInArgs&... passedInArgs) {
-      if (container->hasActiveSelection<Selected>()) {
-        container->view<Function, Tags<Selected, Required, ExtraTags...>, ExcludeContainer, IncludeContainer>(
-          passedInArgs...);
-      }
-      else {
-        container->view<Function, Tags<Required, ExtraTags...>, ExcludeContainer, IncludeContainer>(passedInArgs...);
-      }
-    }
-
-    template <typename... PassedInArgs>
-    static void group(RegistryContainer* container, const PassedInArgs&... passedInArgs) {
-      if (container->hasActiveSelection<Selected>()) {
-        container->view<Function, Tags<Selected, ExtraTags...>, ExcludeContainer, IncludeContainer>(passedInArgs...);
-      }
-      else {
-        container->group<Function, Tags<ExtraTags...>, ExcludeContainer, IncludeContainer>(passedInArgs...);
-      }
-    }
-  };
-
- public:
-  template <
-    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
-    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
-  void viewForSelectedBattles(const PassedInArgs&... passedInArgs) {
-    ForSelected<
-      pokesim::tags::SelectedForViewBattle,
-      pokesim::tags::Battle,
-      Function,
-      TagContainer,
-      ExcludeContainer,
-      IncludeContainer>::view(this, passedInArgs...);
-  }
-
-  template <
-    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
-    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
-  void groupForSelectedBattles(const PassedInArgs&... passedInArgs) {
-    ForSelected<
-      pokesim::tags::SelectedForViewBattle,
-      pokesim::tags::Battle,
-      Function,
-      TagContainer,
-      ExcludeContainer,
-      IncludeContainer>::group(this, passedInArgs...);
-  }
-
-  template <
-    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
-    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
-  void viewForSelectedSides(const PassedInArgs&... passedInArgs) {
-    ForSelected<
-      pokesim::tags::SelectedForViewSide,
-      pokesim::tags::Side,
-      Function,
-      TagContainer,
-      ExcludeContainer,
-      IncludeContainer>::view(this, passedInArgs...);
-  }
-
-  template <
-    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
-    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
-  void groupForSelectedSides(const PassedInArgs&... passedInArgs) {
-    ForSelected<
-      pokesim::tags::SelectedForViewSide,
-      pokesim::tags::Side,
-      Function,
-      TagContainer,
-      ExcludeContainer,
-      IncludeContainer>::group(this, passedInArgs...);
-  }
-
-  template <
-    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
-    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
-  void viewForSelectedPokemon(const PassedInArgs&... passedInArgs) {
-    ForSelected<
-      pokesim::tags::SelectedForViewPokemon,
-      pokesim::tags::Pokemon,
-      Function,
-      TagContainer,
-      ExcludeContainer,
-      IncludeContainer>::view(this, passedInArgs...);
-  }
-
-  template <
-    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
-    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
-  void groupForSelectedPokemon(const PassedInArgs&... passedInArgs) {
-    ForSelected<
-      pokesim::tags::SelectedForViewPokemon,
-      pokesim::tags::Pokemon,
-      Function,
-      TagContainer,
-      ExcludeContainer,
-      IncludeContainer>::group(this, passedInArgs...);
-  }
-
-  template <
-    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
-    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
-  void viewForSelectedMoves(const PassedInArgs&... passedInArgs) {
-    ForSelected<
-      pokesim::tags::SelectedForViewMove,
-      pokesim::tags::CurrentActionMove,
-      Function,
-      TagContainer,
-      ExcludeContainer,
-      IncludeContainer>::view(this, passedInArgs...);
-  }
-
-  template <
-    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
-    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
-  void groupForSelectedMoves(const PassedInArgs&... passedInArgs) {
-    ForSelected<
-      pokesim::tags::SelectedForViewMove,
-      pokesim::tags::CurrentActionMove,
-      Function,
-      TagContainer,
-      ExcludeContainer,
-      IncludeContainer>::group(this, passedInArgs...);
-  }
-
-  template <
-    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
-    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
-  auto view(const PassedInArgs&... passedInArgs) {
-    return internal::RegistryLoop<Function, TagContainer, ExcludeContainer, IncludeContainer, PassedInArgs...>::view(
-      registry,
-      passedInArgs...);
-  }
-
-  template <
-    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
-    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
-  auto group(const PassedInArgs&... passedInArgs) {
-    return internal::RegistryLoop<Function, TagContainer, ExcludeContainer, IncludeContainer, PassedInArgs...>::group(
-      registry,
-      passedInArgs...);
-  }
-
- public:
-  types::registry registry{};
-
-  template <typename Type, typename... ViewComponents, typename... Args>
-  void addToEntities(const Args&... args) {
-    auto view = registry.view<ViewComponents...>();
-    registry.insert<Type>(view.begin(), view.end(), args...);
-  }
-
-  template <typename Type, typename... ViewComponents, typename... ExcludeComponents>
-  void removeFromEntities(entt::exclude_t<ExcludeComponents...> exclude = entt::exclude_t{}) {
-    auto view = registry.view<Type, ViewComponents...>(exclude);
-    registry.remove<Type>(view.begin(), view.end());
-  }
-};
-}  // namespace pokesim::internal
-
-///////////////// END OF src/Simulation/RegistryContainer.hpp //////////////////
-
 //////////////////// START OF src/Simulation/Simulation.hpp ////////////////////
 
 namespace pokesim {
@@ -22767,7 +22452,7 @@ struct SimulationSetupChecks;
  * @details Each `Simulation` instance will only simulate for either single or double battles. This class is optimized
  * for running multiple simulations of the same battle, where each battle state has completed the same number of turns.
  */
-class Simulation : public internal::RegistryContainer {
+class Simulation {
  private:
   types::entityVector createInitialMoves(const std::vector<MoveCreationInfo>& moveInfoList);
   PokemonStateSetup createInitialPokemon(const PokemonCreationInfo& pokemonInfo);
@@ -22838,9 +22523,9 @@ class Simulation : public internal::RegistryContainer {
   void clearCalculateDamageResults();
   void clearAnalyzeEffectResults();
 
-  types::entityVector selectedBattleEntities() const;
-  types::entityVector selectedMoveEntities() const;
-  types::entityVector selectedPokemonEntities() const;
+  types::entityVector battleEntities() const;
+  types::entityVector moveEntities() const;
+  types::entityVector pokemonEntities() const;
 
   template <template <typename> typename RunStruct, typename... RunFunctionArgs>
   static void forEachSimulationTag(RunFunctionArgs&&... args) {
@@ -22848,6 +22533,38 @@ class Simulation : public internal::RegistryContainer {
     RunStruct<tags::CalculateDamage>::run(std::forward<RunFunctionArgs>(args)...);
     RunStruct<tags::AnalyzeEffect>::run(std::forward<RunFunctionArgs>(args)...);
   }
+
+ public:
+  types::registry registry{};
+
+  template <
+    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
+    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
+  auto view(const PassedInArgs&... passedInArgs) {
+    return internal::RegistryLoop<Function, TagContainer, ExcludeContainer, IncludeContainer, PassedInArgs...>::view(
+      registry,
+      passedInArgs...);
+  }
+
+  template <
+    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
+    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
+  auto group(const PassedInArgs&... passedInArgs) {
+    return internal::RegistryLoop<Function, TagContainer, ExcludeContainer, IncludeContainer, PassedInArgs...>::group(
+      registry,
+      passedInArgs...);
+  }
+  template <typename Type, typename... ViewComponents, typename... Args>
+  void addToEntities(const Args&... args) {
+    auto view = registry.view<ViewComponents...>();
+    registry.insert<Type>(view.begin(), view.end(), args...);
+  }
+
+  template <typename Type, typename... ViewComponents, typename... ExcludeComponents>
+  void removeFromEntities(entt::exclude_t<ExcludeComponents...> exclude = entt::exclude_t{}) {
+    auto view = registry.view<Type, ViewComponents...>(exclude);
+    registry.remove<Type>(view.begin(), view.end());
+  }
 };
 }  // namespace pokesim
 
@@ -23631,11 +23348,11 @@ void applyStatBoost(types::stat& stat, types::boost boost);
 void tryBoost(Simulation& simulation);
 
 void updateAllStats(Simulation& simulation);
-void updateAtk(Simulation& simulation);
-void updateDef(Simulation& simulation);
-void updateSpa(Simulation& simulation);
-void updateSpd(Simulation& simulation);
-void updateSpe(Simulation& simulation);
+void updateAtk(Simulation& simulation, bool ignoreBoosts);
+void updateDef(Simulation& simulation, bool ignoreBoosts);
+void updateSpa(Simulation& simulation, bool ignoreBoosts);
+void updateSpd(Simulation& simulation, bool ignoreBoosts);
+void updateSpe(Simulation& simulation, bool ignoreBoosts);
 }  // namespace pokesim
 
 /////////////// END OF src/Battle/Pokemon/ManagePokemonState.hpp ///////////////
@@ -24429,61 +24146,6 @@ void runAfterFaintEvent(Simulation& simulation);
 
 ////////////////////// END OF src/Simulation/RunEvent.hpp //////////////////////
 
-/////////////////// START OF src/Utilities/SelectForView.hpp ///////////////////
-
-namespace pokesim::internal {
-template <typename Selection, typename Required, typename... ComponentsToSelect>
-struct SelectForView {
-  template <typename... ComponentsToExclude>
-  SelectForView(
-    RegistryContainer& registryContainer_,
-    entt::exclude_t<ComponentsToExclude...> exclude = entt::exclude<ComponentsToExclude...>)
-      : registryContainer(&registryContainer_),
-        constantSelectedCount(registryContainer->select<Selection, Required, ComponentsToSelect...>(exclude)) {
-    if (hasNoneSelected()) {
-      registryContainer = nullptr;
-    }
-  }
-
-  SelectForView(RegistryContainer& registryContainer_, RegistryContainer::SelectionFunction selectionFunction)
-      : registryContainer(&registryContainer_),
-        constantSelectedCount(registryContainer->select<Selection>(selectionFunction)) {
-    if (hasNoneSelected()) {
-      registryContainer = nullptr;
-    }
-  }
-
-  ~SelectForView() { deselect(); }
-
-  void deselect() {
-    if (registryContainer) {
-      registryContainer->deselect<Selection>();
-      registryContainer = nullptr;
-    }
-  }
-
-  bool hasNoneSelected() const { return constantSelectedCount == 0U; }
-
- private:
-  RegistryContainer* registryContainer = nullptr;
-  std::size_t constantSelectedCount = 0U;
-};
-
-template <typename... ComponentsToSelect>
-using SelectForBattleView =
-  SelectForView<pokesim::tags::SelectedForViewBattle, pokesim::tags::Battle, ComponentsToSelect...>;
-template <typename... ComponentsToSelect>
-using SelectForSideView = SelectForView<pokesim::tags::SelectedForViewSide, pokesim::tags::Side, ComponentsToSelect...>;
-template <typename... ComponentsToSelect>
-using SelectForPokemonView =
-  SelectForView<pokesim::tags::SelectedForViewPokemon, pokesim::tags::Pokemon, ComponentsToSelect...>;
-template <typename... ComponentsToSelect>
-using SelectForCurrentActionMoveView =
-  SelectForView<pokesim::tags::SelectedForViewMove, pokesim::tags::CurrentActionMove, ComponentsToSelect...>;
-}  // namespace pokesim::internal
-
-//////////////////// END OF src/Utilities/SelectForView.hpp ////////////////////
-
 ////////////////// START OF src/Battle/ManageBattleState.hpp ///////////////////
 
 namespace pokesim {
@@ -24630,6 +24292,77 @@ void runMoveHitChecks(Simulation& simulation);
 
 //////////////////// END OF src/Simulation/MoveHitSteps.hpp ////////////////////
 
+/////////////////// START OF src/Utilities/EntityFilter.hpp ////////////////////
+
+namespace pokesim::internal {
+template <typename SelectionTag, typename... OtherSelectionTags>
+struct EntityFilter {
+ private:
+  template <auto Function, typename...>
+  struct Filter;
+
+  template <auto Function, typename ExcludeContainer, typename IncludeContainer, typename... ExtraTags>
+  struct Filter<Function, Tags<ExtraTags...>, ExcludeContainer, IncludeContainer> {
+    template <typename... PassedInArgs>
+    static void view(Simulation* simulation, const PassedInArgs&... passedInArgs) {
+      simulation
+        ->view<Function, Tags<SelectionTag, OtherSelectionTags..., ExtraTags...>, ExcludeContainer, IncludeContainer>(
+          passedInArgs...);
+    }
+
+    template <typename... PassedInArgs>
+    static void group(Simulation* simulation, const PassedInArgs&... passedInArgs) {
+      simulation
+        ->group<Function, Tags<SelectionTag, OtherSelectionTags..., ExtraTags...>, ExcludeContainer, IncludeContainer>(
+          passedInArgs...);
+    }
+  };
+
+ public:
+  EntityFilter(Simulation& simulation_) : simulation(&simulation_) {}
+
+  template <
+    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
+    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
+  auto view(const PassedInArgs&... passedInArgs) {
+    Filter<Function, TagContainer, ExcludeContainer, IncludeContainer>::view(simulation, passedInArgs...);
+  }
+
+  template <
+    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
+    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
+  auto group(const PassedInArgs&... passedInArgs) {
+    Filter<Function, TagContainer, ExcludeContainer, IncludeContainer>::group(simulation, passedInArgs...);
+  }
+
+  template <typename... IncludeComponents, typename... ExcludeComponents>
+  void applySelectionTags(entt::exclude_t<ExcludeComponents...> exclude = entt::exclude_t{}) {
+    static_assert(
+      !(sizeof...(ExcludeComponents) == 0U && std::conjunction_v<std::is_empty<IncludeComponents>...>),
+      "If there are no excludes and all included components are tags, use those tags as the SelectionTags directly.");
+    auto view = simulation->registry.view<IncludeComponents...>(exclude);
+    simulation->registry.insert<SelectionTag, OtherSelectionTags...>(view.begin(), view.end());
+  }
+
+  bool hasNoneSelected() {
+    auto view = simulation->registry.view<SelectionTag, OtherSelectionTags...>();
+    return view.begin() == view.end();
+  }
+
+  void clearSelectionTags() { simulation->registry.clear<SelectionTag, OtherSelectionTags...>(); }
+
+  template <typename Type, typename... ViewComponents, typename... Args>
+  void addToSelected(const Args&... args) {
+    simulation->addToEntities<Type, SelectionTag, OtherSelectionTags..., ViewComponents...>(args...);
+  }
+
+ private:
+  Simulation* simulation = nullptr;
+};
+}  // namespace pokesim::internal
+
+//////////////////// END OF src/Utilities/EntityFilter.hpp /////////////////////
+
 ///////////////// START OF src/Battle/Side/ManageSideState.hpp /////////////////
 
 namespace pokesim {
@@ -24690,7 +24423,7 @@ struct Checks : pokesim::debug::Checks {
 
  private:
   void check() const {
-    for (types::entity battleEntity : simulation->selectedBattleEntities()) {
+    for (types::entity battleEntity : registry->view<pokesim::tags::Battle, pokesim::tags::SimulateTurn>()) {
       checkBattle(battleEntity);
       for (types::entity sideEntity : registry->get<Sides>(battleEntity).val) {
         checkSide(sideEntity);
@@ -25204,8 +24937,17 @@ struct Checks : pokesim::debug::Checks {
   std::size_t calcDamageCount = 0U;
   std::size_t analyzeEffectCount = 0U;
 
+  types::entityVector getMoveList() const {
+    auto view = registry->view<pokesim::tags::CurrentMoveHit>();
+    return {view.begin(), view.end()};
+  }
+
   void checkMoveInputs() {
-    CurrentActionMovesAsSource moves{simulation->selectedMoveEntities()};
+    CurrentActionMovesAsSource moves{getMoveList()};
+    if (moves.val.empty()) {
+      return;
+    }
+
     for (types::entity move : moves.val) {
       if (has<pokesim::move::tags::Status>(move)) continue;
 
@@ -25221,7 +24963,7 @@ struct Checks : pokesim::debug::Checks {
   }
 
   types::entityVector getPokemonList(bool forAttacker) const {
-    types::entityVector selectedPokemon = simulation->selectedPokemonEntities();
+    types::entityVector selectedPokemon = simulation->pokemonEntities();
     auto end = std::remove_if(selectedPokemon.begin(), selectedPokemon.end(), [&](types::entity entity) {
       if (forAttacker) {
         return !this->has<tags::Attacker>(entity);
@@ -25289,7 +25031,7 @@ struct Checks : pokesim::debug::Checks {
   }
 
   void checkBattleInputs() {
-    for (types::entity battle : simulation->selectedBattleEntities()) {
+    for (types::entity battle : simulation->battleEntities()) {
       copyEntity(battle);
       checkBattle(battle);
       for (types::entity side : registry->get<Sides>(battle).val) {
@@ -25411,7 +25153,7 @@ struct Checks : pokesim::debug::Checks {
   }
 
   void checkMoveOutputs() const {
-    for (types::entity move : simulation->selectedMoveEntities()) {
+    for (types::entity move : getMoveList()) {
       if (has<pokesim::move::tags::Status>(move)) continue;
 
       pokesim::debug::TypesToIgnore typesToIgnore{};
@@ -25455,7 +25197,7 @@ struct Checks : pokesim::debug::Checks {
   }
 
   void checkBattleOutputs() const {
-    for (types::entity battle : simulation->selectedBattleEntities()) {
+    for (types::entity battle : simulation->battleEntities()) {
       pokesim::debug::TypesToIgnore typesToIgnore;
       if (has<pokesim::tags::SimulateTurn>(battle)) {
         typesToIgnore.add<Probability, RngSeed, ParentBattle>();
@@ -25775,7 +25517,7 @@ struct Checks : pokesim::debug::Checks {
     }
     pokesim::debug::check(Inputs{inputs}, *registry);
 
-    for (types::entity battle : simulation->selectedBattleEntities()) {
+    for (types::entity battle : simulation->battleEntities()) {
       checkBattle(battle);
       for (types::entity side : registry->get<Sides>(battle).val) {
         checkSide(side);
diff --git a/extras/RecentBenchmarkResults.md b/extras/RecentBenchmarkResults.md
index cc3315b9..76211671 100644
--- a/extras/RecentBenchmarkResults.md
+++ b/extras/RecentBenchmarkResults.md
@@ -7,286 +7,286 @@
 ## SV-SingleBattle-MonteCarlo-SimulateTurn-VerticalSlice1
 | Inputs | Samples | Iterations / Sample | Estimated Completion Time | Mean of Samples | Standard Deviation | Mean / Input Count | Mean Lower Bound / Input Count | Mean Upper Bound / Input Count |
 | ---    | ---     | ---                 | ---                       | ---             | ---                | ---                | ---                            | ---                            |
-| 1      | 100     | 1                   | 44.159300ms               | 80.600140us     | 10.684301us        | 80.600140us        | 79.031460us                    | 83.585840us                    |
-| 2      | 100     | 1                   | 45.586300ms               | 93.450710us     | 24.697756us        | 46.725355us        | 45.029685us                    | 50.614455us                    |
-| 4      | 100     | 1                   | 48.509200ms               | 107.834870us    | 17.156260us        | 26.958717us        | 26.326602us                    | 28.158610us                    |
-| 8      | 100     | 1                   | 51.811500ms               | 131.404320us    | 14.351892us        | 16.425540us        | 16.161313us                    | 16.928846us                    |
-| 16     | 100     | 1                   | 57.059900ms               | 173.630810us    | 14.640605us        | 10.851926us        | 10.718998us                    | 11.113308us                    |
-| 32     | 100     | 1                   | 66.234800ms               | 243.442500us    | 14.971327us        | 7.607578us         | 7.540566us                     | 7.743035us                     |
-| 64     | 100     | 1                   | 80.830900ms               | 390.677600us    | 11.606306us        | 6.104337us         | 6.074578us                     | 6.148195us                     |
-| 128    | 100     | 1                   | 81.206700ms               | 652.101280us    | 11.488310us        | 5.094541us         | 5.083141us                     | 5.126186us                     |
-| 256    | 100     | 1                   | 137.446300ms              | 1.232455ms      | 15.764140us        | 4.814276us         | 4.804512us                     | 4.829797us                     |
-| 512    | 100     | 1                   | 260.105600ms              | 2.498638ms      | 37.449864us        | 4.880152us         | 4.867261us                     | 4.896160us                     |
-| 1024   | 100     | 1                   | 592.781600ms              | 5.774650ms      | 128.533829us       | 5.639307us         | 5.615753us                     | 5.665155us                     |
-| 2048   | 100     | 1                   | 1482.497100ms             | 14.826539ms     | 397.708795us       | 7.239521us         | 7.203694us                     | 7.280765us                     |
-| 4096   | 100     | 1                   | 4253.900100ms             | 42.523669ms     | 692.866636us       | 10.381755us        | 10.350908us                    | 10.417247us                    |
-| 8192   | 100     | 1                   | 15309.124900ms            | 152.293990ms    | 4.100020ms         | 18.590575us        | 18.482211us                    | 18.680722us                    |
-| 16384  | 100     | 1                   | 55189.572100ms            | 549.043187ms    | 10.911039ms        | 33.510937us        | 33.369244us                    | 33.632609us                    |
-| 32768  | 100     | 1                   | 209324.731900ms           | 2059.850197ms   | 56.494758ms        | 62.861639us        | 62.469338us                    | 63.156512us                    |
-| 65536  | 100     | 1                   | 779451.892100ms           | 8044.359627ms   | 160.517558ms       | 122.747187us       | 122.124865us                   | 123.135658us                   |
+| 1      | 100     | 1                   | 42.686600ms               | 71.677420us     | 12.397813us        | 71.677420us        | 69.971260us                    | 75.555430us                    |
+| 2      | 100     | 1                   | 43.637700ms               | 81.768690us     | 14.135944us        | 40.884345us        | 39.940000us                    | 43.185170us                    |
+| 4      | 100     | 1                   | 47.456800ms               | 94.351630us     | 15.499108us        | 23.587908us        | 23.051030us                    | 24.776653us                    |
+| 8      | 100     | 1                   | 51.027000ms               | 114.655950us    | 12.443183us        | 14.331994us        | 14.091234us                    | 14.737929us                    |
+| 16     | 100     | 1                   | 55.206500ms               | 155.018130us    | 12.876058us        | 9.688633us         | 9.569308us                     | 9.909428us                     |
+| 32     | 100     | 1                   | 65.644000ms               | 219.742430us    | 11.755610us        | 6.866951us         | 6.811495us                     | 6.965010us                     |
+| 64     | 100     | 1                   | 78.471600ms               | 347.097550us    | 14.043183us        | 5.423399us         | 5.387873us                     | 5.477365us                     |
+| 128    | 100     | 1                   | 105.135400ms              | 568.687200us    | 10.294603us        | 4.442869us         | 4.431304us                     | 4.466204us                     |
+| 256    | 100     | 1                   | 148.946300ms              | 1.023886ms      | 11.716033us        | 3.999556us         | 3.991984us                     | 4.010497us                     |
+| 512    | 100     | 1                   | 239.104800ms              | 1.873348ms      | 55.333180us        | 3.658883us         | 3.643921us                     | 3.691891us                     |
+| 1024   | 100     | 1                   | 436.389900ms              | 3.622736ms      | 42.548706us        | 3.537828us         | 3.531145us                     | 3.548062us                     |
+| 2048   | 100     | 1                   | 849.179100ms              | 7.121922ms      | 75.966519us        | 3.477501us         | 3.470775us                     | 3.485435us                     |
+| 4096   | 100     | 1                   | 1661.602700ms             | 14.142980ms     | 158.758946us       | 3.452876us         | 3.445977us                     | 3.461268us                     |
+| 8192   | 100     | 1                   | 2939.969000ms             | 28.937484ms     | 376.175091us       | 3.532408us         | 3.524270us                     | 3.542405us                     |
+| 16384  | 100     | 1                   | 5991.517100ms             | 59.653404ms     | 545.711054us       | 3.640955us         | 3.634894us                     | 3.647996us                     |
+| 32768  | 100     | 1                   | 12380.215000ms            | 123.621082ms    | 982.954473us       | 3.772616us         | 3.767070us                     | 3.778850us                     |
+| 65536  | 100     | 1                   | 28598.221500ms            | 255.883671ms    | 6.538011ms         | 3.904475us         | 3.887244us                     | 3.926714us                     |
 
 
 ## SV-SingleBattle-Branching-SimulateTurn-VerticalSlice1
 | Inputs | Samples | Iterations / Sample | Estimated Completion Time | Mean of Samples | Standard Deviation | Mean / Input Count | Mean Lower Bound / Input Count | Mean Upper Bound / Input Count |
 | ---    | ---     | ---                 | ---                       | ---             | ---                | ---                | ---                            | ---                            |
-| 1      | 100     | 1                   | 63.906000ms               | 230.666510us    | 11.794619us        | 230.666510us       | 229.165030us                   | 234.879310us                   |
-| 2      | 100     | 1                   | 41.620700ms               | 310.707600us    | 12.103863us        | 155.353800us       | 154.605690us                   | 157.630185us                   |
-| 4      | 100     | 1                   | 55.206100ms               | 468.816100us    | 12.868521us        | 117.204025us       | 116.706913us                   | 118.043375us                   |
-| 8      | 100     | 1                   | 83.873000ms               | 727.924290us    | 10.768952us        | 90.990536us        | 90.808982us                    | 91.424048us                    |
-| 16     | 100     | 1                   | 139.356800ms              | 1.253190ms      | 24.734092us        | 78.324361us        | 78.102555us                    | 78.768078us                    |
-| 32     | 100     | 1                   | 247.923300ms              | 2.270335ms      | 33.858994us        | 70.947972us        | 70.756280us                    | 71.172515us                    |
-| 64     | 100     | 1                   | 463.719100ms              | 4.282177ms      | 57.815520us        | 66.909017us        | 66.747450us                    | 67.104927us                    |
-| 128    | 100     | 1                   | 892.971000ms              | 8.314907ms      | 89.407211us        | 64.960215us        | 64.836344us                    | 65.110081us                    |
-| 256    | 100     | 1                   | 1761.395600ms             | 16.749997ms     | 189.385297us       | 65.429675us        | 65.297498us                    | 65.588621us                    |
-| 512    | 100     | 1                   | 3489.890900ms             | 34.342734ms     | 383.319688us       | 67.075652us        | 66.936020us                    | 67.230902us                    |
-| 1024   | 100     | 1                   | 7914.606100ms             | 77.980365ms     | 1.108212ms         | 76.152700us        | 75.954778us                    | 76.383248us                    |
-| 2048   | 100     | 1                   | 20117.202700ms            | 201.626442ms    | 3.778727ms         | 98.450411us        | 98.105876us                    | 98.830696us                    |
-| 4096   | 100     | 1                   | 60400.428100ms            | 609.360636ms    | 13.300748ms        | 148.769686us       | 148.126273us                   | 149.405330us                   |
-| 8192   | 100     | 1                   | 200557.296000ms           | 1993.421535ms   | 46.247720ms        | 243.337590us       | 242.201733us                   | 244.417870us                   |
+| 1      | 100     | 1                   | 60.685900ms               | 214.916300us    | 13.059062us        | 214.916300us       | 213.182120us                   | 219.265460us                   |
+| 2      | 100     | 1                   | 41.047000ms               | 299.930550us    | 16.395717us        | 149.965275us       | 148.758430us                   | 152.232750us                   |
+| 4      | 100     | 1                   | 54.396800ms               | 438.564760us    | 14.642541us        | 109.641190us       | 109.152398us                   | 110.826992us                   |
+| 8      | 100     | 1                   | 84.344400ms               | 726.544370us    | 18.529752us        | 90.818046us        | 90.493310us                    | 91.508447us                    |
+| 16     | 100     | 1                   | 140.344700ms              | 1.218861ms      | 14.648183us        | 76.178809us        | 76.038477us                    | 76.420934us                    |
+| 32     | 100     | 1                   | 247.554800ms              | 2.216142ms      | 17.651782us        | 69.254430us        | 69.153987us                    | 69.370142us                    |
+| 64     | 100     | 1                   | 461.344200ms              | 4.183938ms      | 40.049227us        | 65.374038us        | 65.267205us                    | 65.516310us                    |
+| 128    | 100     | 1                   | 879.518900ms              | 8.043609ms      | 87.995843us        | 62.840699us        | 62.719146us                    | 62.990218us                    |
+| 256    | 100     | 1                   | 1670.127000ms             | 15.655372ms     | 150.340349us       | 61.153797us        | 61.048648us                    | 61.278528us                    |
+| 512    | 100     | 1                   | 3110.317300ms             | 30.370697ms     | 389.345804us       | 59.317767us        | 59.178821us                    | 59.476225us                    |
+| 1024   | 100     | 1                   | 6128.363900ms             | 60.103176ms     | 2.193512ms         | 58.694508us        | 58.385339us                    | 59.318821us                    |
+| 2048   | 100     | 1                   | 12111.434600ms            | 121.666626ms    | 1.407967ms         | 59.407532us        | 59.285462us                    | 59.557427us                    |
+| 4096   | 100     | 1                   | 26226.142800ms            | 268.925574ms    | 7.613842ms         | 65.655658us        | 65.365416us                    | 66.126693us                    |
+| 8192   | 100     | 1                   | 59750.197600ms            | 586.434134ms    | 2.541032ms         | 71.586198us        | 71.527706us                    | 71.648953us                    |
 
 
 ## SV-DoubleBattle-MonteCarlo-SimulateTurn-VerticalSlice1
 | Inputs | Samples | Iterations / Sample | Estimated Completion Time | Mean of Samples | Standard Deviation | Mean / Input Count | Mean Lower Bound / Input Count | Mean Upper Bound / Input Count |
 | ---    | ---     | ---                 | ---                       | ---             | ---                | ---                | ---                            | ---                            |
-| 1      | 100     | 1                   | 57.124300ms               | 121.271020us    | 17.380266us        | 121.271020us       | 118.956500us                   | 127.021260us                   |
-| 2      | 100     | 1                   | 58.721900ms               | 143.260570us    | 19.295710us        | 71.630285us        | 70.311800us                    | 74.662130us                    |
-| 4      | 100     | 1                   | 61.981100ms               | 169.881470us    | 17.995256us        | 42.470368us        | 41.871832us                    | 43.973997us                    |
-| 8      | 100     | 1                   | 67.485300ms               | 217.720110us    | 22.230134us        | 27.215014us        | 26.816649us                    | 28.019099us                    |
-| 16     | 100     | 1                   | 44.942100ms               | 296.246370us    | 17.447534us        | 18.515398us        | 18.373011us                    | 18.889347us                    |
-| 32     | 100     | 1                   | 59.721600ms               | 429.490630us    | 11.727622us        | 13.421582us        | 13.370172us                    | 13.529308us                    |
-| 64     | 100     | 1                   | 87.589800ms               | 672.213670us    | 12.726807us        | 10.503339us        | 10.476837us                    | 10.568265us                    |
-| 128    | 100     | 1                   | 127.537200ms              | 1.161001ms      | 14.643718us        | 9.070317us         | 9.052986us                     | 9.100872us                     |
-| 256    | 100     | 1                   | 229.431900ms              | 2.155918ms      | 27.638082us        | 8.421553us         | 8.403378us                     | 8.446666us                     |
-| 512    | 100     | 1                   | 449.733900ms              | 4.304782ms      | 56.231430us        | 8.407777us         | 8.390082us                     | 8.434659us                     |
-| 1024   | 100     | 1                   | 957.718100ms              | 9.169605ms      | 124.301938us       | 8.954692us         | 8.932312us                     | 8.979940us                     |
-| 2048   | 100     | 1                   | 2267.598900ms             | 21.777567ms     | 431.527787us       | 10.633577us        | 10.593698us                    | 10.676943us                    |
-| 4096   | 100     | 1                   | 5939.797500ms             | 58.067230ms     | 1.414114ms         | 14.176570us        | 14.110200us                    | 14.245706us                    |
+| 1      | 100     | 1                   | 55.964400ms               | 115.877490us    | 16.720004us        | 115.877490us       | 113.554910us                   | 120.909400us                   |
+| 2      | 100     | 1                   | 59.530400ms               | 135.605040us    | 19.475652us        | 67.802520us        | 66.362530us                    | 70.517680us                    |
+| 4      | 100     | 1                   | 62.759800ms               | 162.073490us    | 18.959391us        | 40.518372us        | 39.811813us                    | 41.817232us                    |
+| 8      | 100     | 1                   | 66.891000ms               | 201.089840us    | 18.976933us        | 25.136230us        | 24.801624us                    | 25.833714us                    |
+| 16     | 100     | 1                   | 48.290200ms               | 278.583320us    | 14.929359us        | 17.411458us        | 17.268964us                    | 17.657396us                    |
+| 32     | 100     | 1                   | 62.537900ms               | 405.417060us    | 16.080762us        | 12.669283us        | 12.593608us                    | 12.804263us                    |
+| 64     | 100     | 1                   | 89.560900ms               | 635.639520us    | 13.649220us        | 9.931868us         | 9.902686us                     | 9.996860us                     |
+| 128    | 100     | 1                   | 121.084400ms              | 1.079786ms      | 24.897752us        | 8.435828us         | 8.412213us                     | 8.511360us                     |
+| 256    | 100     | 1                   | 210.715100ms              | 1.951523ms      | 27.945863us        | 7.623136us         | 7.603233us                     | 7.646388us                     |
+| 512    | 100     | 1                   | 387.840800ms              | 3.671426ms      | 44.252494us        | 7.170753us         | 7.156522us                     | 7.191479us                     |
+| 1024   | 100     | 1                   | 724.431500ms              | 6.931923ms      | 58.466017us        | 6.769456us         | 6.759651us                     | 6.782334us                     |
+| 2048   | 100     | 1                   | 1419.421800ms             | 13.719796ms     | 165.763638us       | 6.699119us         | 6.685875us                     | 6.718696us                     |
+| 4096   | 100     | 1                   | 2779.198700ms             | 27.414956ms     | 326.448162us       | 6.693105us         | 6.679361us                     | 6.710962us                     |
 
 
 ## SV-DoubleBattle-Branching-SimulateTurn-VerticalSlice1
 | Inputs | Samples | Iterations / Sample | Estimated Completion Time | Mean of Samples | Standard Deviation | Mean / Input Count | Mean Lower Bound / Input Count | Mean Upper Bound / Input Count |
 | ---    | ---     | ---                 | ---                       | ---             | ---                | ---                | ---                            | ---                            |
-| 1      | 100     | 1                   | 72.628500ms               | 526.785670us    | 14.926157us        | 526.785670us       | 524.914080us                   | 532.220120us                   |
-| 2      | 100     | 1                   | 90.442400ms               | 782.887180us    | 13.638621us        | 391.443590us       | 390.507085us                   | 393.541070us                   |
-| 4      | 100     | 1                   | 141.188300ms              | 1.253413ms      | 13.552514us        | 313.353200us       | 312.823218us                   | 314.233333us                   |
-| 8      | 100     | 1                   | 238.959000ms              | 2.176636ms      | 32.573711us        | 272.079526us       | 271.406250us                   | 273.048455us                   |
-| 16     | 100     | 1                   | 421.161400ms              | 3.881687ms      | 34.896655us        | 242.605467us       | 242.205616us                   | 243.068250us                   |
-| 32     | 100     | 1                   | 798.252700ms              | 7.375732ms      | 94.594706us        | 230.491630us       | 229.952454us                   | 231.117446us                   |
-| 64     | 100     | 1                   | 1515.810000ms             | 14.479536ms     | 166.512718us       | 226.242753us       | 225.785570us                   | 226.813491us                   |
-| 128    | 100     | 1                   | 3102.217200ms             | 29.942898ms     | 428.335411us       | 233.928891us       | 233.348150us                   | 234.668954us                   |
-| 256    | 100     | 1                   | 6660.912200ms             | 66.802683ms     | 1.036226ms         | 260.947980us       | 260.211671us                   | 261.804191us                   |
-| 512    | 100     | 1                   | 16423.007500ms            | 160.754512ms    | 3.393378ms         | 313.973656us       | 312.666810us                   | 315.273651us                   |
-| 1024   | 100     | 1                   | 44383.479000ms            | 443.869309ms    | 9.722236ms         | 433.466122us       | 431.575613us                   | 435.294232us                   |
-| 2048   | 100     | 1                   | 136541.548900ms           | 1357.189935ms   | 44.096279ms        | 662.690398us       | 658.385504us                   | 666.772893us                   |
-| 4096   | 100     | 1                   | 452116.171300ms           | 4610.059697ms   | 151.429759ms       | 1.125503ms         | 1.118127ms                     | 1.132599ms                     |
+| 1      | 100     | 1                   | 75.270800ms               | 508.602400us    | 17.345902us        | 508.602400us       | 506.139640us                   | 513.742420us                   |
+| 2      | 100     | 1                   | 91.073600ms               | 766.268280us    | 20.822925us        | 383.134140us       | 381.601245us                   | 386.056480us                   |
+| 4      | 100     | 1                   | 140.884600ms              | 1.234372ms      | 25.630393us        | 308.593075us       | 307.718875us                   | 310.627845us                   |
+| 8      | 100     | 1                   | 237.525100ms              | 2.126358ms      | 29.208138us        | 265.794692us       | 265.265781us                   | 266.844206us                   |
+| 16     | 100     | 1                   | 412.565900ms              | 3.843884ms      | 45.760242us        | 240.242774us       | 239.807671us                   | 240.998281us                   |
+| 32     | 100     | 1                   | 779.825300ms              | 7.227782ms      | 91.403858us        | 225.868190us       | 225.368616us                   | 226.491117us                   |
+| 64     | 100     | 1                   | 1466.020600ms             | 13.838717ms     | 148.317962us       | 216.229960us       | 215.824493us                   | 216.743195us                   |
+| 128    | 100     | 1                   | 2793.256300ms             | 27.019668ms     | 296.437375us       | 211.091153us       | 210.685697us                   | 211.600460us                   |
+| 256    | 100     | 1                   | 5608.744500ms             | 54.398256ms     | 878.712537us       | 212.493188us       | 211.899317us                   | 213.258705us                   |
+| 512    | 100     | 1                   | 10780.813800ms            | 108.080436ms    | 1.030936ms         | 211.094601us       | 210.750078us                   | 211.552514us                   |
+| 1024   | 100     | 1                   | 22096.036300ms            | 224.556038ms    | 1.926193ms         | 219.293006us       | 218.949630us                   | 219.691322us                   |
+| 2048   | 100     | 1                   | 46172.211500ms            | 462.778756ms    | 2.329673ms         | 225.966190us       | 225.765048us                   | 226.215252us                   |
+| 4096   | 100     | 1                   | 98078.403600ms            | 974.312828ms    | 3.124922ms         | 237.869343us       | 237.719071us                   | 238.017367us                   |
 
 
 ## SV-SingleBattle-CalcDamage-VerticalSlice1
 | Inputs | Samples | Iterations / Sample | Estimated Completion Time | Mean of Samples | Standard Deviation | Mean / Input Count | Mean Lower Bound / Input Count | Mean Upper Bound / Input Count |
 | ---    | ---     | ---                 | ---                       | ---             | ---                | ---                | ---                            | ---                            |
-| 1      | 100     | 1                   | 8.171500ms                | 12.185760us     | 4.664592us         | 12.185760us        | 11.556070us                    | 13.647530us                    |
-| 2      | 100     | 1                   | 8.101600ms                | 13.874650us     | 4.464294us         | 6.937325us         | 6.632270us                     | 7.654705us                     |
-| 4      | 100     | 1                   | 8.322700ms                | 14.232210us     | 4.549089us         | 3.558052us         | 3.402165us                     | 3.915707us                     |
-| 8      | 100     | 1                   | 8.727700ms                | 15.452620us     | 3.367733us         | 1.931578us         | 1.879295us                     | 2.096155us                     |
-| 16     | 100     | 1                   | 9.120600ms                | 20.020820us     | 3.867226us         | 1.251301us         | 1.218841us                     | 1.332433us                     |
-| 32     | 100     | 1                   | 9.838000ms                | 26.533890us     | 3.290730us         | 829.184062ns       | 816.025938ns                   | 866.045000ns                   |
-| 64     | 100     | 1                   | 11.360800ms               | 40.405300us     | 10.062522us        | 631.332813ns       | 612.032656ns                   | 692.257031ns                   |
-| 128    | 100     | 1                   | 14.191300ms               | 65.185590us     | 4.793460us         | 509.262422ns       | 504.013516ns                   | 520.417266ns                   |
-| 256    | 100     | 1                   | 20.021300ms               | 115.041910us    | 4.814528us         | 449.382461ns       | 446.467812ns                   | 454.300313ns                   |
-| 512    | 100     | 1                   | 37.134800ms               | 214.125370us    | 4.611208us         | 418.213613ns       | 416.762754ns                   | 420.457734ns                   |
-| 1024   | 100     | 1                   | 65.411900ms               | 407.856070us    | 5.943468us         | 398.296943ns       | 397.404502ns                   | 399.814746ns                   |
-| 2048   | 100     | 1                   | 123.941600ms              | 802.082340us    | 12.921079us        | 391.641768ns       | 390.658716ns                   | 393.296689ns                   |
-| 4096   | 100     | 1                   | 237.681200ms              | 1.588086ms      | 22.723295us        | 387.716206ns       | 386.752214ns                   | 388.957664ns                   |
-| 8192   | 100     | 1                   | 471.637000ms              | 3.285880ms      | 48.884377us        | 401.108433ns       | 400.074252ns                   | 402.461996ns                   |
-| 16384  | 100     | 1                   | 937.698100ms              | 6.689690ms      | 69.886446us        | 408.306268ns       | 407.551823ns                   | 409.232678ns                   |
-| 32768  | 100     | 1                   | 1869.394900ms             | 13.677662ms     | 181.642466us       | 417.409124ns       | 416.420208ns                   | 418.611198ns                   |
-| 65536  | 100     | 1                   | 3779.991800ms             | 28.300153ms     | 245.361268us       | 431.826064ns       | 431.165085ns                   | 432.635974ns                   |
+| 1      | 100     | 1                   | 7.642500ms                | 10.398820us     | 3.063497us         | 10.398820us        | 9.960560us                     | 11.298590us                    |
+| 2      | 100     | 1                   | 7.745100ms                | 11.103900us     | 3.392469us         | 5.551950us         | 5.325755us                     | 6.119065us                     |
+| 4      | 100     | 1                   | 8.026200ms                | 12.309900us     | 3.474284us         | 3.077475us         | 2.952238us                     | 3.325508us                     |
+| 8      | 100     | 1                   | 8.227500ms                | 13.864170us     | 6.102111us         | 1.733021us         | 1.641125us                     | 2.042768us                     |
+| 16     | 100     | 1                   | 8.736000ms                | 16.692990us     | 2.016397us         | 1.043312us         | 1.024764us                     | 1.078439us                     |
+| 32     | 100     | 1                   | 9.535100ms                | 23.858510us     | 2.491570us         | 745.578437ns       | 733.193750ns                   | 765.090312ns                   |
+| 64     | 100     | 1                   | 10.809900ms               | 35.511910us     | 2.702795us         | 554.873594ns       | 548.341563ns                   | 565.851094ns                   |
+| 128    | 100     | 1                   | 13.653200ms               | 59.022540us     | 3.580700us         | 461.113594ns       | 456.618906ns                   | 468.037812ns                   |
+| 256    | 100     | 1                   | 19.013100ms               | 103.848520us    | 3.291804us         | 405.658281ns       | 403.589570ns                   | 408.820000ns                   |
+| 512    | 100     | 1                   | 35.826100ms               | 198.899650us    | 10.628629us        | 388.475879ns       | 385.709844ns                   | 395.332734ns                   |
+| 1024   | 100     | 1                   | 61.840800ms               | 377.479570us    | 6.132247us         | 368.632393ns       | 367.592744ns                   | 369.981914ns                   |
+| 2048   | 100     | 1                   | 116.708700ms              | 738.333260us    | 9.389160us         | 360.514287ns       | 359.715317ns                   | 361.544409ns                   |
+| 4096   | 100     | 1                   | 227.340000ms              | 1.466441ms      | 25.817565us        | 358.017773ns       | 357.047986ns                   | 359.668740ns                   |
+| 8192   | 100     | 1                   | 449.032500ms              | 3.033444ms      | 38.899051us        | 370.293453ns       | 369.446519ns                   | 371.316660ns                   |
+| 16384  | 100     | 1                   | 898.235700ms              | 6.182320ms      | 72.195765us        | 377.338885ns       | 376.564456ns                   | 378.326620ns                   |
+| 32768  | 100     | 1                   | 1824.083300ms             | 12.557321ms     | 152.288220us       | 383.219027ns       | 382.413417ns                   | 384.258423ns                   |
+| 65536  | 100     | 1                   | 3600.715800ms             | 26.273869ms     | 259.742839us       | 400.907430ns       | 400.211568ns                   | 401.774471ns                   |
 
 
 ## SV-SingleBattle-AnalyzeEffect-VerticalSlice1
 | Inputs | Samples | Iterations / Sample | Estimated Completion Time | Mean of Samples | Standard Deviation | Mean / Input Count | Mean Lower Bound / Input Count | Mean Upper Bound / Input Count |
 | ---    | ---     | ---                 | ---                       | ---             | ---                | ---                | ---                            | ---                            |
-| 1      | 100     | 1                   | 28.061100ms               | 60.185880us     | 12.342484us        | 60.185880us        | 58.516460us                    | 64.341600us                    |
-| 2      | 100     | 1                   | 29.451700ms               | 72.548790us     | 11.152138us        | 36.274395us        | 35.605450us                    | 38.521820us                    |
-| 4      | 100     | 1                   | 16.827300ms               | 97.392810us     | 10.627352us        | 24.348202us        | 24.036580us                    | 25.453925us                    |
-| 8      | 100     | 1                   | 18.715700ms               | 132.414760us    | 10.472112us        | 16.551845us        | 16.398824us                    | 17.097264us                    |
-| 16     | 100     | 1                   | 26.405800ms               | 204.107930us    | 9.572984us         | 12.756746us        | 12.679703us                    | 12.962532us                    |
-| 32     | 100     | 1                   | 41.755000ms               | 337.257220us    | 7.533201us         | 10.539288us        | 10.506163us                    | 10.609633us                    |
-| 64     | 100     | 1                   | 73.067200ms               | 602.509010us    | 9.215405us         | 9.414203us         | 9.390775us                     | 9.449238us                     |
-| 128    | 100     | 1                   | 134.864500ms              | 1.127214ms      | 16.757135us        | 8.806362us         | 8.785029us                     | 8.838245us                     |
-| 256    | 100     | 1                   | 243.950000ms              | 2.101577ms      | 28.288963us        | 8.209285us         | 8.188709us                     | 8.232149us                     |
-| 512    | 100     | 1                   | 470.095400ms              | 4.087662ms      | 44.907696us        | 7.983714us         | 7.968309us                     | 8.003291us                     |
-| 1024   | 100     | 1                   | 903.023500ms              | 8.101871ms      | 107.030190us       | 7.911983us         | 7.893976us                     | 7.935669us                     |
-| 2048   | 100     | 1                   | 1797.548100ms             | 16.090363ms     | 169.356888us       | 7.856623us         | 7.841833us                     | 7.874416us                     |
-| 4096   | 100     | 1                   | 3675.571200ms             | 32.410274ms     | 406.745409us       | 7.912664us         | 7.895053us                     | 7.934453us                     |
-| 8192   | 100     | 1                   | 8275.707100ms             | 75.684189ms     | 1.553756ms         | 9.238793us         | 9.207035us                     | 9.283297us                     |
+| 1      | 100     | 1                   | 24.481600ms               | 54.964360us     | 7.044274us         | 54.964360us        | 53.911850us                    | 56.880880us                    |
+| 2      | 100     | 1                   | 25.104900ms               | 65.947320us     | 7.352050us         | 32.973660us        | 32.435185us                    | 34.000945us                    |
+| 4      | 100     | 1                   | 30.405900ms               | 88.159770us     | 7.485760us         | 22.039943us        | 21.764252us                    | 22.565152us                    |
+| 8      | 100     | 1                   | 20.583600ms               | 123.633890us    | 8.698520us         | 15.454236us        | 15.308336us                    | 15.811117us                    |
+| 16     | 100     | 1                   | 26.535300ms               | 193.958910us    | 10.594951us        | 12.122432us        | 12.035806us                    | 12.347179us                    |
+| 32     | 100     | 1                   | 43.723100ms               | 324.832140us    | 7.827796us         | 10.151004us        | 10.113281us                    | 10.214358us                    |
+| 64     | 100     | 1                   | 73.957000ms               | 576.465210us    | 11.948879us        | 9.007269us         | 8.983196us                     | 9.071728us                     |
+| 128    | 100     | 1                   | 130.907300ms              | 1.085209ms      | 9.193191us         | 8.478199us         | 8.464917us                     | 8.493125us                     |
+| 256    | 100     | 1                   | 247.298500ms              | 2.050264ms      | 21.500260us        | 8.008845us         | 7.993296us                     | 8.026267us                     |
+| 512    | 100     | 1                   | 462.560900ms              | 4.014678ms      | 47.820052us        | 7.841167us         | 7.825207us                     | 7.862244us                     |
+| 1024   | 100     | 1                   | 900.050500ms              | 7.961406ms      | 96.532561us        | 7.774810us         | 7.758503us                     | 7.796074us                     |
+| 2048   | 100     | 1                   | 1755.826000ms             | 15.702850ms     | 163.978679us       | 7.667407us         | 7.653746us                     | 7.685741us                     |
+| 4096   | 100     | 1                   | 3541.823000ms             | 31.940608ms     | 565.817260us       | 7.798000us         | 7.774238us                     | 7.829396us                     |
+| 8192   | 100     | 1                   | 7715.873300ms             | 72.500488ms     | 962.395195us       | 8.850157us         | 8.829439us                     | 8.876009us                     |
 
 
 ## SV-SingleBattle-MonteCarlo-SimulateTurn-RandomInputs-OneRandomBattle-OneRandomInput
 | Inputs | Samples | Iterations / Sample | Estimated Completion Time | Mean of Samples | Standard Deviation | Mean / Input Count | Mean Lower Bound / Input Count | Mean Upper Bound / Input Count |
 | ---    | ---     | ---                 | ---                       | ---             | ---                | ---                | ---                            | ---                            |
-| 1      | 100     | 1                   | 33.188200ms               | 85.123010us     | 18.712165us        | 85.123010us        | 81.985060us                    | 89.444570us                    |
-| 2      | 100     | 1                   | 34.232600ms               | 94.069440us     | 20.673891us        | 47.034720us        | 45.242665us                    | 49.342230us                    |
-| 4      | 100     | 1                   | 35.896000ms               | 107.386860us    | 22.679940us        | 26.846715us        | 25.890705us                    | 28.172487us                    |
-| 8      | 100     | 1                   | 39.617900ms               | 127.475140us    | 25.527736us        | 15.934392us        | 15.372860us                    | 16.633737us                    |
-| 16     | 100     | 1                   | 46.247000ms               | 171.373600us    | 33.401579us        | 10.710850us        | 10.329899us                    | 11.157187us                    |
-| 32     | 100     | 1                   | 55.920000ms               | 239.186940us    | 44.412022us        | 7.474592us         | 7.222417us                     | 7.769731us                     |
-| 64     | 100     | 1                   | 53.917000ms               | 374.085620us    | 77.167251us        | 5.845088us         | 5.629496us                     | 6.105192us                     |
-| 128    | 100     | 1                   | 107.641600ms              | 654.903640us    | 151.095723us       | 5.116435us         | 4.907649us                     | 5.372729us                     |
-| 256    | 100     | 1                   | 268.785300ms              | 1.206087ms      | 309.829812us       | 4.711279us         | 4.502672us                     | 4.983029us                     |
-| 512    | 100     | 1                   | 338.452000ms              | 2.416206ms      | 744.179317us       | 4.719152us         | 4.468171us                     | 5.044560us                     |
-| 1024   | 100     | 1                   | 663.913700ms              | 5.758951ms      | 1.955589ms         | 5.623976us         | 5.296538us                     | 6.056937us                     |
-| 2048   | 100     | 1                   | 2729.702200ms             | 14.161424ms     | 5.825275ms         | 6.914758us         | 6.424338us                     | 7.564891us                     |
-| 4096   | 100     | 1                   | 3176.307200ms             | 37.403266ms     | 18.536068ms        | 9.131657us         | 8.351837us                     | 10.150621us                    |
-| 8192   | 100     | 1                   | 9960.079200ms             | 119.422677ms    | 76.649005ms        | 14.577963us        | 12.975770us                    | 16.695299us                    |
+| 1      | 100     | 1                   | 31.405100ms               | 79.627850us     | 16.798804us        | 79.627850us        | 77.065170us                    | 83.995270us                    |
+| 2      | 100     | 1                   | 32.859500ms               | 88.241610us     | 15.014696us        | 44.120805us        | 42.811545us                    | 45.790660us                    |
+| 4      | 100     | 1                   | 35.227800ms               | 103.868940us    | 18.084822us        | 25.967235us        | 25.181938us                    | 26.963115us                    |
+| 8      | 100     | 1                   | 38.356900ms               | 122.526940us    | 20.410842us        | 15.315867us        | 14.861446us                    | 15.872014us                    |
+| 16     | 100     | 1                   | 44.109700ms               | 164.399640us    | 26.805288us        | 10.274978us        | 9.967774us                     | 10.627374us                    |
+| 32     | 100     | 1                   | 53.756800ms               | 227.502310us    | 36.652149us        | 7.109447us         | 6.900819us                     | 7.349929us                     |
+| 64     | 100     | 1                   | 52.178500ms               | 356.978230us    | 62.386717us        | 5.577785us         | 5.399720us                     | 5.782223us                     |
+| 128    | 100     | 1                   | 95.395700ms               | 602.104090us    | 109.546264us       | 4.703938us         | 4.549463us                     | 4.885052us                     |
+| 256    | 100     | 1                   | 227.800100ms              | 1.082499ms      | 199.611478us       | 4.228510us         | 4.087883us                     | 4.396125us                     |
+| 512    | 100     | 1                   | 282.668800ms              | 2.028465ms      | 392.856219us       | 3.961846us         | 3.823944us                     | 4.125946us                     |
+| 1024   | 100     | 1                   | 525.508800ms              | 4.363781ms      | 782.736717us       | 4.261505us         | 4.124087us                     | 4.425017us                     |
+| 2048   | 100     | 1                   | 1306.134100ms             | 9.276676ms      | 1.583899ms         | 4.529627us         | 4.388070us                     | 4.692534us                     |
+| 4096   | 100     | 1                   | 2807.882000ms             | 19.656655ms     | 3.300202ms         | 4.798988us         | 4.652843us                     | 4.970605us                     |
+| 8192   | 100     | 1                   | 4096.550900ms             | 43.108654ms     | 7.323969ms         | 5.262287us         | 5.097864us                     | 5.448632us                     |
 
 
 ## SV-SingleBattle-MonteCarlo-SimulateTurn-RandomInputs-OneRandomBattle-ManyRandomInputs
 | Inputs | Samples | Iterations / Sample | Estimated Completion Time | Mean of Samples | Standard Deviation | Mean / Input Count | Mean Lower Bound / Input Count | Mean Upper Bound / Input Count |
 | ---    | ---     | ---                 | ---                       | ---             | ---                | ---                | ---                            | ---                            |
-| 1      | 100     | 1                   | 33.085100ms               | 87.963980us     | 18.537446us        | 87.963980us        | 84.748580us                    | 92.088660us                    |
-| 2      | 100     | 1                   | 38.641500ms               | 95.647650us     | 23.906903us        | 47.823825us        | 45.878840us                    | 50.757790us                    |
-| 4      | 100     | 1                   | 40.233200ms               | 107.402140us    | 22.096871us        | 26.850535us        | 25.887713us                    | 28.075155us                    |
-| 8      | 100     | 1                   | 43.339000ms               | 125.820720us    | 24.633706us        | 15.727590us        | 15.177531us                    | 16.393408us                    |
-| 16     | 100     | 1                   | 50.044000ms               | 164.760150us    | 29.771415us        | 10.297509us        | 9.955033us                     | 10.685868us                    |
-| 32     | 100     | 1                   | 58.572300ms               | 233.841200us    | 45.014948us        | 7.307538us         | 7.053797us                     | 7.610035us                     |
-| 64     | 100     | 1                   | 50.555600ms               | 356.087340us    | 76.196533us        | 5.563865us         | 5.352337us                     | 5.822784us                     |
-| 128    | 100     | 1                   | 90.204700ms               | 586.007640us    | 143.978249us       | 4.578185us         | 4.382177us                     | 4.826925us                     |
-| 256    | 100     | 1                   | 163.452300ms              | 1.080185ms      | 303.001477us       | 4.219471us         | 4.015233us                     | 4.483735us                     |
-| 512    | 100     | 1                   | 210.477400ms              | 2.190487ms      | 736.391147us       | 4.278295us         | 4.029337us                     | 4.603700us                     |
-| 1024   | 100     | 1                   | 439.489500ms              | 4.732864ms      | 1.914342ms         | 4.621937us         | 4.302314us                     | 5.045020us                     |
-| 2048   | 100     | 1                   | 2344.529400ms             | 11.524619ms     | 5.777880ms         | 5.627255us         | 5.148593us                     | 6.269513us                     |
-| 4096   | 100     | 1                   | 2560.654300ms             | 30.992854ms     | 18.315189ms        | 7.566615us         | 6.798617us                     | 8.572416us                     |
-| 8192   | 100     | 1                   | 8313.251000ms             | 101.990547ms    | 74.932897ms        | 12.450018us        | 10.878347us                    | 14.499153us                    |
+| 1      | 100     | 1                   | 30.121100ms               | 80.781340us     | 17.367615us        | 80.781340us        | 78.041950us                    | 85.083140us                    |
+| 2      | 100     | 1                   | 44.880900ms               | 89.919410us     | 17.300855us        | 44.959705us        | 43.482080us                    | 46.933715us                    |
+| 4      | 100     | 1                   | 47.803300ms               | 101.938520us    | 17.789255us        | 25.484630us        | 24.714028us                    | 26.474287us                    |
+| 8      | 100     | 1                   | 48.867600ms               | 118.753320us    | 20.122918us        | 14.844165us        | 14.396960us                    | 15.390319us                    |
+| 16     | 100     | 1                   | 55.006100ms               | 158.468110us    | 25.199222us        | 9.904257us         | 9.612741us                     | 10.235304us                    |
+| 32     | 100     | 1                   | 40.038700ms               | 221.400650us    | 34.847082us        | 6.918770us         | 6.719167us                     | 7.146684us                     |
+| 64     | 100     | 1                   | 71.996500ms               | 338.960440us    | 62.560404us        | 5.296257us         | 5.118236us                     | 5.501753us                     |
+| 128    | 100     | 1                   | 83.615600ms               | 554.975250us    | 105.748969us       | 4.335744us         | 4.185573us                     | 4.510324us                     |
+| 256    | 100     | 1                   | 143.709600ms              | 980.446730us    | 195.124015us       | 3.829870us         | 3.693816us                     | 3.993576us                     |
+| 512    | 100     | 1                   | 187.946600ms              | 1.833044ms      | 368.229964us       | 3.580164us         | 3.450057us                     | 3.732975us                     |
+| 1024   | 100     | 1                   | 355.572500ms              | 3.523513ms      | 733.367483us       | 3.440930us         | 3.313001us                     | 3.596060us                     |
+| 2048   | 100     | 1                   | 738.497200ms              | 6.929981ms      | 1.441611ms         | 3.383780us         | 3.258147us                     | 3.533939us                     |
+| 4096   | 100     | 1                   | 1951.701100ms             | 14.028916ms     | 2.828331ms         | 3.425028us         | 3.301326us                     | 3.574195us                     |
+| 8192   | 100     | 1                   | 2650.411700ms             | 28.507829ms     | 5.423487ms         | 3.479960us         | 3.361519us                     | 3.622731us                     |
 
 
 ## SV-SingleBattle-MonteCarlo-SimulateTurn-RandomInputs-ManyRandomBattles-ManyRandomInputs
 | Inputs | Samples | Iterations / Sample | Estimated Completion Time | Mean of Samples | Standard Deviation | Mean / Input Count | Mean Lower Bound / Input Count | Mean Upper Bound / Input Count |
 | ---    | ---     | ---                 | ---                       | ---             | ---                | ---                | ---                            | ---                            |
-| 1      | 100     | 1                   | 35.654700ms               | 87.223070us     | 24.454599us        | 87.223070us        | 83.402200us                    | 93.431780us                    |
-| 2      | 100     | 1                   | 52.886400ms               | 112.037860us    | 26.869550us        | 56.018930us        | 53.940330us                    | 59.496340us                    |
-| 4      | 100     | 1                   | 54.138200ms               | 146.361950us    | 26.006770us        | 36.590488us        | 35.579192us                    | 38.278498us                    |
-| 8      | 100     | 1                   | 70.569100ms               | 195.996200us    | 27.557118us        | 24.499525us        | 23.995902us                    | 25.460600us                    |
-| 16     | 100     | 1                   | 83.449700ms               | 264.626080us    | 27.886136us        | 16.539130us        | 16.281619us                    | 17.015632us                    |
-| 32     | 100     | 1                   | 54.978400ms               | 376.505600us    | 28.736422us        | 11.765800us        | 11.633740us                    | 12.020367us                    |
-| 64     | 100     | 1                   | 81.473200ms               | 590.567710us    | 27.552985us        | 9.227620us         | 9.158724us                     | 9.335392us                     |
-| 128    | 100     | 1                   | 137.951300ms              | 973.915290us    | 29.664272us        | 7.608713us         | 7.571823us                     | 7.666565us                     |
-| 256    | 100     | 1                   | 236.633000ms              | 1.769238ms      | 39.705402us        | 6.911086us         | 6.884464us                     | 6.946459us                     |
-| 512    | 100     | 1                   | 470.894900ms              | 3.586476ms      | 89.355774us        | 7.004836us         | 6.974048us                     | 7.043012us                     |
-| 1024   | 100     | 1                   | 980.644400ms              | 9.019708ms      | 217.776144us       | 8.808308us         | 8.768729us                     | 8.852249us                     |
-| 2048   | 100     | 1                   | 2252.439500ms             | 21.553633ms     | 336.342723us       | 10.524235us        | 10.494450us                    | 10.559130us                    |
-| 4096   | 100     | 1                   | 5740.125300ms             | 56.454492ms     | 884.065906us       | 13.782835us        | 13.743062us                    | 13.828210us                    |
-| 8192   | 100     | 1                   | 16652.251700ms            | 165.212523ms    | 1.691477ms         | 20.167544us        | 20.127728us                    | 20.208632us                    |
+| 1      | 100     | 1                   | 42.553000ms               | 81.108080us     | 17.442912us        | 81.108080us        | 78.372810us                    | 85.496630us                    |
+| 2      | 100     | 1                   | 56.405400ms               | 102.116280us    | 19.137545us        | 51.058140us        | 49.529410us                    | 53.432670us                    |
+| 4      | 100     | 1                   | 40.246900ms               | 132.205090us    | 16.053161us        | 33.051272us        | 32.334255us                    | 33.923702us                    |
+| 8      | 100     | 1                   | 54.914100ms               | 175.955640us    | 18.210563us        | 21.994455us        | 21.617350us                    | 22.540533us                    |
+| 16     | 100     | 1                   | 65.440000ms               | 230.539240us    | 19.357769us        | 14.408702us        | 14.221073us                    | 14.716801us                    |
+| 32     | 100     | 1                   | 81.031300ms               | 332.951890us    | 24.534449us        | 10.404747us        | 10.285364us                    | 10.602595us                    |
+| 64     | 100     | 1                   | 79.207200ms               | 516.057330us    | 34.829066us        | 8.063396us         | 7.986856us                     | 8.226971us                     |
+| 128    | 100     | 1                   | 189.169300ms              | 836.859850us    | 24.604275us        | 6.537968us         | 6.510081us                     | 6.591978us                     |
+| 256    | 100     | 1                   | 266.100100ms              | 1.472600ms      | 36.437895us        | 5.752344us         | 5.730479us                     | 5.789780us                     |
+| 512    | 100     | 1                   | 447.265800ms              | 2.819624ms      | 79.202500us        | 5.507079us         | 5.481025us                     | 5.543039us                     |
+| 1024   | 100     | 1                   | 774.171300ms              | 6.699105ms      | 235.055795us       | 6.542095us         | 6.501089us                     | 6.591319us                     |
+| 2048   | 100     | 1                   | 1582.866400ms             | 14.667931ms     | 276.069397us       | 7.162076us         | 7.139669us                     | 7.193820us                     |
+| 4096   | 100     | 1                   | 3213.526200ms             | 31.844605ms     | 425.335216us       | 7.774562us         | 7.756775us                     | 7.798163us                     |
+| 8192   | 100     | 1                   | 7243.663300ms             | 72.859805ms     | 912.702451us       | 8.894019us         | 8.873635us                     | 8.917347us                     |
 
 
 ## SV-SingleBattle-CalcDamage-RandomInputs-OneRandomBattle-OneRandomInput
 | Inputs | Samples | Iterations / Sample | Estimated Completion Time | Mean of Samples | Standard Deviation | Mean / Input Count | Mean Lower Bound / Input Count | Mean Upper Bound / Input Count |
 | ---    | ---     | ---                 | ---                       | ---             | ---                | ---                | ---                            | ---                            |
-| 1      | 100     | 1                   | 10.744700ms               | 13.758060us     | 6.767953us         | 13.758060us        | 12.554200us                    | 15.248050us                    |
-| 2      | 100     | 1                   | 11.100800ms               | 15.459920us     | 7.974394us         | 7.729960us         | 7.019030us                     | 8.584765us                     |
-| 4      | 100     | 1                   | 11.699700ms               | 20.055020us     | 16.116064us        | 5.013755us         | 4.448317us                     | 6.215110us                     |
-| 8      | 100     | 1                   | 12.832800ms               | 21.755510us     | 9.508098us         | 2.719439us         | 2.477778us                     | 2.945245us                     |
-| 16     | 100     | 1                   | 9.838400ms                | 29.510680us     | 13.378797us        | 1.844418us         | 1.672779us                     | 2.000944us                     |
-| 32     | 100     | 1                   | 11.216200ms               | 45.603210us     | 22.880815us        | 1.425100us         | 1.282887us                     | 1.563792us                     |
-| 64     | 100     | 1                   | 19.644000ms               | 78.087080us     | 39.925976us        | 1.220111us         | 1.096246us                     | 1.339988us                     |
-| 128    | 100     | 1                   | 50.036400ms               | 138.506060us    | 75.091767us        | 1.082079us         | 965.331406ns                   | 1.195239us                     |
-| 256    | 100     | 1                   | 89.268300ms               | 263.545300us    | 144.754148us       | 1.029474us         | 916.427656ns                   | 1.138227us                     |
-| 512    | 100     | 1                   | 171.303900ms              | 482.103700us    | 292.297865us       | 941.608789ns       | 828.409844ns                   | 1.053561us                     |
-| 1024   | 100     | 1                   | 336.844600ms              | 1.151822ms      | 681.248031us       | 1.124826us         | 990.824912ns                   | 1.252073us                     |
-| 2048   | 100     | 1                   | 658.284400ms              | 2.419491ms      | 1.392018ms         | 1.181392us         | 1.043910us                     | 1.311011us                     |
-| 4096   | 100     | 1                   | 1281.540100ms             | 5.109368ms      | 3.011059ms         | 1.247404us         | 1.099312us                     | 1.387562us                     |
-| 8192   | 100     | 1                   | 2692.442700ms             | 11.179306ms     | 6.656857ms         | 1.364661us         | 1.201349us                     | 1.518977us                     |
+| 1      | 100     | 1                   | 10.154500ms               | 12.770960us     | 4.757985us         | 12.770960us        | 12.039660us                    | 14.012200us                    |
+| 2      | 100     | 1                   | 10.565400ms               | 14.725520us     | 5.558946us         | 7.362760us         | 6.899630us                     | 8.024930us                     |
+| 4      | 100     | 1                   | 11.151500ms               | 17.530480us     | 8.261466us         | 4.382620us         | 4.081207us                     | 4.972752us                     |
+| 8      | 100     | 1                   | 12.139000ms               | 21.268460us     | 7.591241us         | 2.658557us         | 2.477965us                     | 2.851915us                     |
+| 16     | 100     | 1                   | 13.902100ms               | 29.751230us     | 11.831791us        | 1.859452us         | 1.717234us                     | 2.006126us                     |
+| 32     | 100     | 1                   | 10.695700ms               | 45.104220us     | 18.879927us        | 1.409507us         | 1.292444us                     | 1.523793us                     |
+| 64     | 100     | 1                   | 18.719600ms               | 77.782920us     | 37.174636us        | 1.215358us         | 1.103153us                     | 1.330819us                     |
+| 128    | 100     | 1                   | 50.457000ms               | 139.299200us    | 69.197438us        | 1.088275us         | 983.970312ns                   | 1.194662us                     |
+| 256    | 100     | 1                   | 87.918000ms               | 267.140260us    | 135.958140us       | 1.043517us         | 939.459375ns                   | 1.147468us                     |
+| 512    | 100     | 1                   | 166.691000ms              | 477.188810us    | 270.771916us       | 932.009395ns       | 827.687539ns                   | 1.034706us                     |
+| 1024   | 100     | 1                   | 329.279600ms              | 1.148998ms      | 644.517873us       | 1.122068us         | 997.091611ns                   | 1.242825us                     |
+| 2048   | 100     | 1                   | 652.648300ms              | 2.493000ms      | 1.377171ms         | 1.217285us         | 1.084202us                     | 1.346281us                     |
+| 4096   | 100     | 1                   | 1268.678400ms             | 5.106965ms      | 2.778428ms         | 1.246818us         | 1.111135us                     | 1.376692us                     |
+| 8192   | 100     | 1                   | 2610.247200ms             | 11.288210ms     | 6.208669ms         | 1.377955us         | 1.226488us                     | 1.523966us                     |
 
 
 ## SV-SingleBattle-CalcDamage-RandomInputs-OneRandomBattle-ManyRandomInputs
 | Inputs | Samples | Iterations / Sample | Estimated Completion Time | Mean of Samples | Standard Deviation | Mean / Input Count | Mean Lower Bound / Input Count | Mean Upper Bound / Input Count |
 | ---    | ---     | ---                 | ---                       | ---             | ---                | ---                | ---                            | ---                            |
-| 1      | 100     | 1                   | 10.665700ms               | 13.781530us     | 7.391359us         | 13.781530us        | 12.526040us                    | 15.473970us                    |
-| 2      | 100     | 1                   | 11.023500ms               | 17.909010us     | 13.254475us        | 8.954505us         | 8.159460us                     | 11.647815us                    |
-| 4      | 100     | 1                   | 10.721400ms               | 19.140620us     | 4.511333us         | 4.785155us         | 4.631085us                     | 5.150353us                     |
-| 8      | 100     | 1                   | 12.090500ms               | 25.107920us     | 12.046176us        | 3.138490us         | 2.954605us                     | 3.724584us                     |
-| 16     | 100     | 1                   | 12.711800ms               | 32.112720us     | 5.182708us         | 2.007045us         | 1.960869us                     | 2.102531us                     |
-| 32     | 100     | 1                   | 14.979200ms               | 47.444390us     | 5.348342us         | 1.482637us         | 1.455933us                     | 1.524522us                     |
-| 64     | 100     | 1                   | 17.156400ms               | 75.611210us     | 6.259646us         | 1.181425us         | 1.164573us                     | 1.203320us                     |
-| 128    | 100     | 1                   | 24.329300ms               | 131.749350us    | 6.865227us         | 1.029292us         | 1.019109us                     | 1.040077us                     |
-| 256    | 100     | 1                   | 36.431000ms               | 246.316270us    | 10.774616us        | 962.172930ns       | 954.257656ns                   | 970.687461ns                   |
-| 512    | 100     | 1                   | 42.346200ms               | 480.128430us    | 25.383141us        | 937.750840ns       | 930.996387ns                   | 953.196602ns                   |
-| 1024   | 100     | 1                   | 90.927300ms               | 938.477800us    | 22.260166us        | 916.482227ns       | 912.397783ns                   | 920.905020ns                   |
-| 2048   | 100     | 1                   | 192.435300ms              | 1.839090ms      | 35.274810us        | 897.993271ns       | 894.696958ns                   | 901.448525ns                   |
-| 4096   | 100     | 1                   | 377.462600ms              | 3.648053ms      | 52.832295us        | 890.638010ns       | 888.178291ns                   | 893.253059ns                   |
-| 8192   | 100     | 1                   | 742.231700ms              | 7.298594ms      | 110.461215us       | 890.941626ns       | 888.412839ns                   | 893.696354ns                   |
+| 1      | 100     | 1                   | 10.165300ms               | 12.867020us     | 5.372350us         | 12.867020us        | 12.042290us                    | 14.271810us                    |
+| 2      | 100     | 1                   | 10.584700ms               | 14.700520us     | 4.379222us         | 7.350260us         | 7.037065us                     | 7.986950us                     |
+| 4      | 100     | 1                   | 10.471400ms               | 17.385130us     | 3.858959us         | 4.346283us         | 4.208570us                     | 4.629733us                     |
+| 8      | 100     | 1                   | 11.471500ms               | 22.025650us     | 4.468590us         | 2.753206us         | 2.668673us                     | 2.901986us                     |
+| 16     | 100     | 1                   | 12.061500ms               | 32.931470us     | 27.521200us        | 2.058217us         | 1.869211us                     | 2.842650us                     |
+| 32     | 100     | 1                   | 14.285100ms               | 45.614030us     | 17.271659us        | 1.425438us         | 1.362060us                     | 1.652059us                     |
+| 64     | 100     | 1                   | 16.516300ms               | 70.599020us     | 6.197957us         | 1.103110us         | 1.086095us                     | 1.124418us                     |
+| 128    | 100     | 1                   | 23.737300ms               | 121.761450us    | 6.389777us         | 951.261328ns       | 941.613125ns                   | 961.178437ns                   |
+| 256    | 100     | 1                   | 36.062100ms               | 229.622680us    | 9.427472us         | 896.963594ns       | 889.899727ns                   | 904.331094ns                   |
+| 512    | 100     | 1                   | 41.619800ms               | 441.194690us    | 10.889678us        | 861.708379ns       | 857.538359ns                   | 865.855410ns                   |
+| 1024   | 100     | 1                   | 87.522900ms               | 857.297990us    | 17.392077us        | 837.205068ns       | 833.891895ns                   | 840.563203ns                   |
+| 2048   | 100     | 1                   | 176.454500ms              | 1.684521ms      | 30.232978us        | 822.519824ns       | 819.682109ns                   | 825.468745ns                   |
+| 4096   | 100     | 1                   | 347.414500ms              | 3.375787ms      | 66.124234us        | 824.166746ns       | 821.349736ns                   | 827.720208ns                   |
+| 8192   | 100     | 1                   | 689.636000ms              | 6.763567ms      | 123.313306us       | 825.630715ns       | 822.868110ns                   | 828.783402ns                   |
 
 
 ## SV-SingleBattle-CalcDamage-RandomInputs-ManyRandomBattles-ManyRandomInputs
 | Inputs | Samples | Iterations / Sample | Estimated Completion Time | Mean of Samples | Standard Deviation | Mean / Input Count | Mean Lower Bound / Input Count | Mean Upper Bound / Input Count |
 | ---    | ---     | ---                 | ---                       | ---             | ---                | ---                | ---                            | ---                            |
-| 1      | 100     | 1                   | 10.602000ms               | 13.589110us     | 7.013665us         | 13.589110us        | 12.393990us                    | 15.189510us                    |
-| 2      | 100     | 1                   | 10.216800ms               | 17.086420us     | 7.000266us         | 8.543210us         | 8.089265us                     | 9.766645us                     |
-| 4      | 100     | 1                   | 11.504100ms               | 20.936800us     | 5.974662us         | 5.234200us         | 5.010980us                     | 5.648335us                     |
-| 8      | 100     | 1                   | 11.876300ms               | 26.403980us     | 8.006266us         | 3.300498us         | 3.168466us                     | 3.639432us                     |
-| 16     | 100     | 1                   | 14.307600ms               | 36.956230us     | 8.526090us         | 2.309764us         | 2.241067us                     | 2.493859us                     |
-| 32     | 100     | 1                   | 17.556800ms               | 56.394100us     | 5.521727us         | 1.762316us         | 1.733937us                     | 1.804324us                     |
-| 64     | 100     | 1                   | 30.827900ms               | 101.227870us    | 31.297704us        | 1.581685us         | 1.527072us                     | 1.800853us                     |
-| 128    | 100     | 1                   | 53.685300ms               | 179.129640us    | 12.346563us        | 1.399450us         | 1.384641us                     | 1.425097us                     |
-| 256    | 100     | 1                   | 95.504100ms               | 347.871100us    | 35.358631us        | 1.358871us         | 1.342382us                     | 1.414127us                     |
-| 512    | 100     | 1                   | 183.961200ms              | 664.510840us    | 35.243896us        | 1.297873us         | 1.287120us                     | 1.315717us                     |
-| 1024   | 100     | 1                   | 348.070700ms              | 1.676014ms      | 49.664134us        | 1.636732us         | 1.627792us                     | 1.646840us                     |
-| 2048   | 100     | 1                   | 720.045700ms              | 3.781840ms      | 79.316729us        | 1.846601us         | 1.839896us                     | 1.855427us                     |
-| 4096   | 100     | 1                   | 1429.753000ms             | 8.591502ms      | 112.874157us       | 2.097535us         | 2.092472us                     | 2.103329us                     |
-| 8192   | 100     | 1                   | 2858.205700ms             | 19.513900ms     | 236.506909us       | 2.382068us         | 2.376933us                     | 2.388366us                     |
+| 1      | 100     | 1                   | 10.118900ms               | 13.196670us     | 5.623242us         | 13.196670us        | 12.315860us                    | 14.632450us                    |
+| 2      | 100     | 1                   | 9.975600ms                | 15.488890us     | 5.499116us         | 7.744445us         | 7.380100us                     | 8.653995us                     |
+| 4      | 100     | 1                   | 10.843200ms               | 18.572920us     | 5.870794us         | 4.643230us         | 4.446508us                     | 5.119195us                     |
+| 8      | 100     | 1                   | 11.280200ms               | 23.194170us     | 4.497054us         | 2.899271us         | 2.816280us                     | 3.057430us                     |
+| 16     | 100     | 1                   | 13.639600ms               | 33.864060us     | 7.773025us         | 2.116504us         | 2.050127us                     | 2.269154us                     |
+| 32     | 100     | 1                   | 16.975300ms               | 51.248510us     | 4.918828us         | 1.601516us         | 1.576967us                     | 1.639746us                     |
+| 64     | 100     | 1                   | 30.069900ms               | 91.563110us     | 6.391016us         | 1.430674us         | 1.413829us                     | 1.454109us                     |
+| 128    | 100     | 1                   | 51.995000ms               | 169.878430us    | 22.184326us        | 1.327175us         | 1.302509us                     | 1.378400us                     |
+| 256    | 100     | 1                   | 89.286100ms               | 319.688410us    | 16.598105us        | 1.248783us         | 1.237859us                     | 1.263646us                     |
+| 512    | 100     | 1                   | 171.896500ms              | 610.812870us    | 32.852947us        | 1.192994us         | 1.183824us                     | 1.211806us                     |
+| 1024   | 100     | 1                   | 336.640100ms              | 1.578508ms      | 67.384991us        | 1.541512us         | 1.529491us                     | 1.555314us                     |
+| 2048   | 100     | 1                   | 670.177100ms              | 3.641640ms      | 327.045601us       | 1.778144us         | 1.748979us                     | 1.812021us                     |
+| 4096   | 100     | 1                   | 1331.147100ms             | 8.074754ms      | 261.307612us       | 1.971375us         | 1.960577us                     | 1.986096us                     |
+| 8192   | 100     | 1                   | 2690.146400ms             | 17.813892ms     | 242.845050us       | 2.174547us         | 2.169275us                     | 2.180981us                     |
 
 
 ## SV-SingleBattle-AnalyzeEffect-RandomInputs-OneRandomBattle-OneRandomInput
 | Inputs | Samples | Iterations / Sample | Estimated Completion Time | Mean of Samples | Standard Deviation | Mean / Input Count | Mean Lower Bound / Input Count | Mean Upper Bound / Input Count |
 | ---    | ---     | ---                 | ---                       | ---             | ---                | ---                | ---                            | ---                            |
-| 1      | 100     | 1                   | 31.600600ms               | 114.651550us    | 38.611395us        | 114.651550us       | 106.092200us                   | 121.420440us                   |
-| 2      | 100     | 1                   | 38.221100ms               | 167.613490us    | 55.456582us        | 83.806745us        | 77.383115us                    | 88.468040us                    |
-| 4      | 100     | 1                   | 39.260300ms               | 262.240810us    | 87.002271us        | 65.560203us        | 60.471310us                    | 69.186200us                    |
-| 8      | 100     | 1                   | 62.681000ms               | 446.481610us    | 149.386706us       | 55.810201us        | 51.431925us                    | 58.910618us                    |
-| 16     | 100     | 1                   | 121.760200ms              | 789.037830us    | 279.283688us       | 49.314864us        | 45.239582us                    | 52.233214us                    |
-| 32     | 100     | 1                   | 185.872400ms              | 1.449048ms      | 513.000027us       | 45.282742us        | 41.568798us                    | 47.956709us                    |
-| 64     | 100     | 1                   | 383.857300ms              | 2.801388ms      | 994.828087us       | 43.771693us        | 40.094598us                    | 46.366161us                    |
-| 128    | 100     | 1                   | 785.160800ms              | 5.366773ms      | 1.911315ms         | 41.927918us        | 38.465781us                    | 44.415775us                    |
-| 256    | 100     | 1                   | 1494.570500ms             | 10.664093ms     | 3.804651ms         | 41.656615us        | 38.179331us                    | 44.155145us                    |
-| 512    | 100     | 1                   | 3182.276800ms             | 22.294825ms     | 7.999210ms         | 43.544579us        | 39.873389us                    | 46.145017us                    |
-| 1024   | 100     | 1                   | 7763.162500ms             | 56.110320ms     | 20.099699ms        | 54.795235us        | 50.257554us                    | 58.109714us                    |
-| 2048   | 100     | 1                   | 13854.959600ms            | 130.346536ms    | 46.490337ms        | 63.645770us        | 58.361525us                    | 67.448483us                    |
-| 4096   | 100     | 1                   | 29807.685000ms            | 279.730628ms    | 99.713010ms        | 68.293610us        | 62.563582us                    | 72.343266us                    |
+| 1      | 100     | 1                   | 42.531000ms               | 109.316270us    | 38.460601us        | 109.316270us       | 100.665190us                   | 115.998430us                   |
+| 2      | 100     | 1                   | 24.734500ms               | 159.139560us    | 53.088410us        | 79.569780us        | 73.441425us                    | 84.020155us                    |
+| 4      | 100     | 1                   | 36.997300ms               | 249.772020us    | 83.730606us        | 62.443005us        | 57.521828us                    | 65.933352us                    |
+| 8      | 100     | 1                   | 60.052200ms               | 436.180360us    | 146.308428us       | 54.522545us        | 50.184251us                    | 57.547200us                    |
+| 16     | 100     | 1                   | 117.921000ms              | 761.197030us    | 271.738756us       | 47.574814us        | 43.601292us                    | 50.407463us                    |
+| 32     | 100     | 1                   | 183.921600ms              | 1.408681ms      | 500.568681us       | 44.021271us        | 40.370078us                    | 46.649134us                    |
+| 64     | 100     | 1                   | 371.654900ms              | 2.710436ms      | 964.963685us       | 42.350570us        | 38.844759us                    | 44.865624us                    |
+| 128    | 100     | 1                   | 766.951700ms              | 5.243822ms      | 1.870609ms         | 40.967362us        | 37.561996us                    | 43.412360us                    |
+| 256    | 100     | 1                   | 1469.585900ms             | 10.420130ms     | 3.731715ms         | 40.703634us        | 37.301496us                    | 43.143086us                    |
+| 512    | 100     | 1                   | 3099.200000ms             | 21.713813ms     | 7.821248ms         | 42.409791us        | 38.857384us                    | 44.979531us                    |
+| 1024   | 100     | 1                   | 7386.275000ms             | 54.349521ms     | 19.476992ms        | 53.075705us        | 48.617242us                    | 56.244592us                    |
+| 2048   | 100     | 1                   | 13506.667400ms            | 125.996615ms    | 44.999922ms        | 61.521785us        | 56.316566us                    | 65.176185us                    |
+| 4096   | 100     | 1                   | 28557.440000ms            | 268.259960ms    | 95.773962ms        | 65.493154us        | 60.013779us                    | 69.396059us                    |
 
 
 ## SV-SingleBattle-AnalyzeEffect-RandomInputs-OneRandomBattle-ManyRandomInputs
 | Inputs | Samples | Iterations / Sample | Estimated Completion Time | Mean of Samples | Standard Deviation | Mean / Input Count | Mean Lower Bound / Input Count | Mean Upper Bound / Input Count |
 | ---    | ---     | ---                 | ---                       | ---             | ---                | ---                | ---                            | ---                            |
-| 1      | 100     | 1                   | 43.635600ms               | 115.169950us    | 42.431582us        | 115.169950us       | 106.235880us                   | 122.831400us                   |
-| 2      | 100     | 1                   | 28.271900ms               | 151.704150us    | 26.346074us        | 75.852075us        | 72.544940us                    | 77.936180us                    |
-| 4      | 100     | 1                   | 29.714000ms               | 208.666330us    | 23.249470us        | 52.166582us        | 51.012180us                    | 53.294555us                    |
-| 8      | 100     | 1                   | 41.959100ms               | 305.797080us    | 27.478856us        | 38.224635us        | 37.499849us                    | 38.853590us                    |
-| 16     | 100     | 1                   | 60.999900ms               | 501.787380us    | 39.559579us        | 31.361711us        | 30.887658us                    | 31.855696us                    |
-| 32     | 100     | 1                   | 102.275100ms              | 900.287000us    | 54.223063us        | 28.133969us        | 27.805171us                    | 28.471155us                    |
-| 64     | 100     | 1                   | 182.789700ms              | 1.717193ms      | 87.963885us        | 26.831141us        | 26.562752us                    | 27.100686us                    |
-| 128    | 100     | 1                   | 578.987900ms              | 5.264351ms      | 159.166529us       | 41.127742us        | 40.889016us                    | 41.376450us                    |
-| 256    | 100     | 1                   | 1169.876800ms             | 11.415804ms     | 321.842534us       | 44.592986us        | 44.344346us                    | 44.837218us                    |
-| 512    | 100     | 1                   | 2886.487900ms             | 28.449537ms     | 639.393680us       | 55.565501us        | 55.320456us                    | 55.811677us                    |
-| 1024   | 100     | 1                   | 6999.906300ms             | 70.785388ms     | 2.041090ms         | 69.126356us        | 68.746386us                    | 69.529979us                    |
-| 2048   | 100     | 1                   | 16471.971200ms            | 169.111225ms    | 3.058662ms         | 82.573840us        | 82.279594us                    | 82.863901us                    |
-| 4096   | 100     | 1                   | 38151.893800ms            | 392.791796ms    | 5.167571ms         | 95.896435us        | 95.652068us                    | 96.147046us                    |
+| 1      | 100     | 1                   | 41.637000ms               | 109.643980us    | 41.596182us        | 109.643980us       | 100.861190us                   | 117.269310us                   |
+| 2      | 100     | 1                   | 23.129500ms               | 148.812360us    | 27.161198us        | 74.406180us        | 71.138555us                    | 76.643275us                    |
+| 4      | 100     | 1                   | 23.123600ms               | 197.375650us    | 20.619914us        | 49.343913us        | 48.258955us                    | 50.280367us                    |
+| 8      | 100     | 1                   | 41.765200ms               | 296.526250us    | 26.812168us        | 37.065781us        | 36.350027us                    | 37.670425us                    |
+| 16     | 100     | 1                   | 62.517200ms               | 492.483370us    | 39.648213us        | 30.780211us        | 30.307544us                    | 31.277875us                    |
+| 32     | 100     | 1                   | 99.103600ms               | 874.124690us    | 49.750100us        | 27.316397us        | 27.019154us                    | 27.628301us                    |
+| 64     | 100     | 1                   | 182.087300ms              | 1.669714ms      | 87.652872us        | 26.089282us        | 25.818790us                    | 26.357352us                    |
+| 128    | 100     | 1                   | 384.885300ms              | 3.322508ms      | 139.562149us       | 25.957095us        | 25.748588us                    | 26.175857us                    |
+| 256    | 100     | 1                   | 746.072400ms              | 7.409611ms      | 291.348554us       | 28.943793us        | 28.721938us                    | 29.167358us                    |
+| 512    | 100     | 1                   | 1831.934600ms             | 18.025901ms     | 599.538927us       | 35.206838us        | 34.982078us                    | 35.442248us                    |
+| 1024   | 100     | 1                   | 4495.163900ms             | 44.641554ms     | 1.175760ms         | 43.595268us        | 43.378296us                    | 43.830676us                    |
+| 2048   | 100     | 1                   | 10321.920600ms            | 105.533562ms    | 2.592880ms         | 51.530060us        | 51.279321us                    | 51.774961us                    |
+| 4096   | 100     | 1                   | 23177.237100ms            | 233.712622ms    | 4.984853ms         | 57.058746us        | 56.822787us                    | 57.301496us                    |
 
 
 ## SV-SingleBattle-AnalyzeEffect-RandomInputs-ManyRandomBattles-ManyRandomInputs
 | Inputs | Samples | Iterations / Sample | Estimated Completion Time | Mean of Samples | Standard Deviation | Mean / Input Count | Mean Lower Bound / Input Count | Mean Upper Bound / Input Count |
 | ---    | ---     | ---                 | ---                       | ---             | ---                | ---                | ---                            | ---                            |
-| 1      | 100     | 1                   | 30.650200ms               | 115.719860us    | 38.771977us        | 115.719860us       | 107.077670us                   | 122.446520us                   |
-| 2      | 100     | 1                   | 52.638100ms               | 185.437690us    | 32.682785us        | 92.718845us        | 89.086665us                    | 95.558150us                    |
-| 4      | 100     | 1                   | 44.016600ms               | 304.045200us    | 32.978319us        | 76.011300us        | 74.313033us                    | 77.529430us                    |
-| 8      | 100     | 1                   | 67.043000ms               | 525.890810us    | 46.921605us        | 65.736351us        | 64.505540us                    | 66.803462us                    |
-| 16     | 100     | 1                   | 124.804000ms              | 963.416700us    | 64.780664us        | 60.213544us        | 59.401251us                    | 60.988066us                    |
-| 32     | 100     | 1                   | 227.785000ms              | 1.798079ms      | 86.224966us        | 56.189967us        | 55.655719us                    | 56.709748us                    |
-| 64     | 100     | 1                   | 447.283100ms              | 3.453214ms      | 140.986003us       | 53.956466us        | 53.499700us                    | 54.370247us                    |
-| 128    | 100     | 1                   | 820.533100ms              | 6.438475ms      | 195.923757us       | 50.300583us        | 49.997983us                    | 50.597004us                    |
-| 256    | 100     | 1                   | 1700.924400ms             | 12.749874ms     | 407.698990us       | 49.804197us        | 49.509155us                    | 50.135285us                    |
-| 512    | 100     | 1                   | 3379.099100ms             | 27.614083ms     | 895.610539us       | 53.933757us        | 53.606237us                    | 54.296005us                    |
-| 1024   | 100     | 1                   | 7877.656500ms             | 73.610019ms     | 1.919481ms         | 71.884785us        | 71.546163us                    | 72.286915us                    |
-| 2048   | 100     | 1                   | 16777.903700ms            | 165.887471ms    | 2.169109ms         | 80.999742us        | 80.799219us                    | 81.213883us                    |
-| 4096   | 100     | 1                   | 35072.874700ms            | 352.523815ms    | 3.224057ms         | 86.065384us        | 85.911196us                    | 86.220355us                    |
+| 1      | 100     | 1                   | 42.558300ms               | 107.964890us    | 38.505708us        | 107.964890us       | 99.406580us                    | 114.627270us                   |
+| 2      | 100     | 1                   | 28.954100ms               | 173.803840us    | 30.404899us        | 86.901920us        | 83.405830us                    | 89.482370us                    |
+| 4      | 100     | 1                   | 45.509200ms               | 291.029400us    | 34.254968us        | 72.757350us        | 71.033250us                    | 74.395245us                    |
+| 8      | 100     | 1                   | 67.321700ms               | 504.829130us    | 44.757951us        | 63.103641us        | 61.929281us                    | 64.125856us                    |
+| 16     | 100     | 1                   | 124.245500ms              | 921.545720us    | 65.010962us        | 57.596607us        | 56.780442us                    | 58.371183us                    |
+| 32     | 100     | 1                   | 221.935600ms              | 1.700471ms      | 81.624776us        | 53.139726us        | 52.624607us                    | 53.627066us                    |
+| 64     | 100     | 1                   | 435.242300ms              | 3.309236ms      | 136.302712us       | 51.706820us        | 51.273590us                    | 52.106788us                    |
+| 128    | 100     | 1                   | 819.701900ms              | 6.258337ms      | 180.803823us       | 48.893258us        | 48.614581us                    | 49.166315us                    |
+| 256    | 100     | 1                   | 1696.559600ms             | 12.474110ms     | 434.037386us       | 48.726991us        | 48.410046us                    | 49.076310us                    |
+| 512    | 100     | 1                   | 3393.983800ms             | 27.957184ms     | 1.081162ms         | 54.603874us        | 54.210460us                    | 55.037221us                    |
+| 1024   | 100     | 1                   | 7789.308400ms             | 72.546752ms     | 2.116763ms         | 70.846437us        | 70.455347us                    | 71.267056us                    |
+| 2048   | 100     | 1                   | 16209.502400ms            | 161.259813ms    | 2.107425ms         | 78.740143us        | 78.547132us                    | 78.947634us                    |
+| 4096   | 100     | 1                   | 33531.482700ms            | 340.105325ms    | 2.852476ms         | 83.033527us        | 82.898180us                    | 83.170424us                    |
 
 
diff --git a/src/AnalyzeEffect/AnalyzeEffect.cpp b/src/AnalyzeEffect/AnalyzeEffect.cpp
index 36c6d882..aef9ce6c 100644
--- a/src/AnalyzeEffect/AnalyzeEffect.cpp
+++ b/src/AnalyzeEffect/AnalyzeEffect.cpp
@@ -26,6 +26,7 @@
 #include <Components/SimulationResults.hpp>
 #include <Components/Tags/Current.hpp>
 #include <Components/Tags/MovePropertyTags.hpp>
+#include <Components/Tags/PokemonTags.hpp>
 #include <Components/Tags/SimulationTags.hpp>
 #include <Config/Require.hpp>
 #include <Pokedex/Pokedex.hpp>
@@ -35,7 +36,7 @@
 #include <Types/Event.hpp>
 #include <Types/Random.hpp>
 #include <Types/Registry.hpp>
-#include <Utilities/SelectForView.hpp>
+#include <Utilities/EntityFilter.hpp>
 #include <cstdint>
 #include <entt/container/dense_map.hpp>
 #include <vector>
@@ -569,15 +570,14 @@ void clearRunVariables(Simulation& simulation) {
 }
 
 void analyzeEffect(Simulation& simulation) {
-  pokesim::internal::SelectForPokemonView<pokesim::tags::AnalyzeEffect> selectedPokemon(simulation);
-  pokesim::internal::SelectForBattleView<pokesim::tags::AnalyzeEffect> selectedBattle(simulation);
+  pokesim::internal::EntityFilter<pokesim::tags::AnalyzeEffect> battleFilter(simulation);
 
-  if (selectedPokemon.hasNoneSelected() || selectedBattle.hasNoneSelected()) {
+  if (battleFilter.hasNoneSelected()) {
     return;
   }
 
   simulation.view<ignoreStatusMoves>(simulation.pokedex());
-  simulation.viewForSelectedBattles<groupSimilarInputs>();
+  battleFilter.view<groupSimilarInputs>();
 
   if (!simulation.analyzeEffectOptions.getReconsiderActiveEffects()) {
     ignoreBattlesWithEffectActive(simulation);
diff --git a/src/AnalyzeEffect/AnalyzeEffectDebugChecks.hpp b/src/AnalyzeEffect/AnalyzeEffectDebugChecks.hpp
index cfd2715d..39314787 100644
--- a/src/AnalyzeEffect/AnalyzeEffectDebugChecks.hpp
+++ b/src/AnalyzeEffect/AnalyzeEffectDebugChecks.hpp
@@ -47,7 +47,7 @@ struct Checks : pokesim::debug::Checks {
     }
     pokesim::debug::check(Inputs{inputs}, *registry);
 
-    for (types::entity battle : simulation->selectedBattleEntities()) {
+    for (types::entity battle : simulation->battleEntities()) {
       checkBattle(battle);
       for (types::entity side : registry->get<Sides>(battle).val) {
         checkSide(side);
diff --git a/src/Battle/ManageBattleState.cpp b/src/Battle/ManageBattleState.cpp
index 8091f4b0..35f2cd12 100644
--- a/src/Battle/ManageBattleState.cpp
+++ b/src/Battle/ManageBattleState.cpp
@@ -177,7 +177,7 @@ void clearCurrentAction(Simulation& simulation) {
   registry.destroy(failedActionMoves.begin(), failedActionMoves.end());
   registry.destroy(currentActions.begin(), currentActions.end());
 
-  auto battles = simulation.selectedBattleEntities();
+  auto battles = simulation.battleEntities();
   registry.remove<
     action::tags::Item,
     ItemName,
diff --git a/src/Battle/Pokemon/ManagePokemonState.cpp b/src/Battle/Pokemon/ManagePokemonState.cpp
index badedb67..cc484321 100644
--- a/src/Battle/Pokemon/ManagePokemonState.cpp
+++ b/src/Battle/Pokemon/ManagePokemonState.cpp
@@ -15,6 +15,7 @@
 #include <Components/SimulateTurn/SimulateTurnTags.hpp>
 #include <Components/Stats.hpp>
 #include <Components/Tags/PokemonTags.hpp>
+#include <Components/Tags/RunEventTags.hpp>
 #include <Components/Tags/SimulationTags.hpp>
 #include <Components/Tags/StatusTags.hpp>
 #include <Components/Tags/TypeTags.hpp>
@@ -24,7 +25,7 @@
 #include <Simulation/Simulation.hpp>
 #include <Types/Entity.hpp>
 #include <Types/Registry.hpp>
-#include <Utilities/SelectForView.hpp>
+#include <Utilities/EntityFilter.hpp>
 #include <cmath>
 #include <entt/entity/handle.hpp>
 #include <entt/entity/registry.hpp>
@@ -42,7 +43,7 @@ void removeItemTags(types::handle handle, ItemName item) {
 
 template <typename SelectionTag>
 void removeItemComponents(Simulation& simulation) {
-  simulation.viewForSelectedPokemon<removeItemTags>();
+  simulation.view<removeItemTags, Tags<SelectionTag>>();
   simulation.removeFromEntities<ItemName, SelectionTag>();
   simulation.registry.clear<SelectionTag>();
 }
@@ -154,11 +155,6 @@ void checkIfCanUseItem(Simulation& simulation) {
 }
 
 void useItem(Simulation& simulation) {
-  pokesim::internal::SelectForPokemonView<tags::CanUseItem> selectedPokemon{simulation};
-  if (selectedPokemon.hasNoneSelected()) {
-    return;
-  }
-
   runAfterUseItemEvent(simulation);
   removeItemComponents<tags::CanUseItem>(simulation);
 }
@@ -174,12 +170,10 @@ void checkIfCanRemoveItem(Simulation& simulation) {
 }
 
 void removeItem(Simulation& simulation) {
-  pokesim::internal::SelectForPokemonView<tags::CanRemoveItem> selectedPokemon{simulation};
-  if (selectedPokemon.hasNoneSelected()) {
-    return;
-  }
-
+  simulation.addToEntities<tags::EndItem, tags::CanRemoveItem>();
   runEndItemEvent(simulation);
+  simulation.registry.clear<tags::EndItem>();
+
   removeItemComponents<tags::CanRemoveItem>(simulation);
 }
 
@@ -307,72 +301,82 @@ void tryBoost(Simulation& simulation) {
 }
 
 void updateAllStats(Simulation& simulation) {
-  updateAtk(simulation);
-  updateDef(simulation);
-  updateSpa(simulation);
-  updateSpd(simulation);
-  updateSpe(simulation);
+  updateAtk(simulation, false);
+  updateDef(simulation, false);
+  updateSpa(simulation, false);
+  updateSpd(simulation, false);
+  updateSpe(simulation, false);
 }
 
-void updateAtk(Simulation& simulation) {
-  internal::SelectForPokemonView<tags::AtkStatUpdateRequired> selectedAtkUpdateRequired{simulation};
-  if (selectedAtkUpdateRequired.hasNoneSelected()) return;
+void updateAtk(Simulation& simulation, bool ignoreBoosts) {
+  internal::EntityFilter<tags::AtkStatUpdateRequired> filter{simulation};
+  if (filter.hasNoneSelected()) return;
 
-  simulation.viewForSelectedPokemon<resetEffectiveAtk>();
+  filter.view<resetEffectiveAtk>();
 
-  simulation.viewForSelectedPokemon<applyBoostToEffectiveStat<stat::EffectiveAtk, AtkBoost>>();
+  if (!ignoreBoosts) {
+    filter.view<applyBoostToEffectiveStat<stat::EffectiveAtk, AtkBoost>>();
+  }
   runModifyAtk(simulation);
 
-  simulation.registry.clear<tags::AtkStatUpdateRequired>();
+  filter.clearSelectionTags();
 }
 
-void updateDef(Simulation& simulation) {
-  internal::SelectForPokemonView<tags::DefStatUpdateRequired> selectedDefUpdateRequired{simulation};
-  if (selectedDefUpdateRequired.hasNoneSelected()) return;
+void updateDef(Simulation& simulation, bool ignoreBoosts) {
+  internal::EntityFilter<tags::DefStatUpdateRequired> filter{simulation};
+  if (filter.hasNoneSelected()) return;
 
-  simulation.viewForSelectedPokemon<resetEffectiveDef>();
+  filter.view<resetEffectiveDef>();
 
-  simulation.viewForSelectedPokemon<applyBoostToEffectiveStat<stat::EffectiveDef, DefBoost>>();
+  if (!ignoreBoosts) {
+    filter.view<applyBoostToEffectiveStat<stat::EffectiveDef, DefBoost>>();
+  }
   runModifyDef(simulation);
 
-  simulation.registry.clear<tags::DefStatUpdateRequired>();
+  filter.clearSelectionTags();
 }
 
-void updateSpa(Simulation& simulation) {
-  internal::SelectForPokemonView<tags::SpaStatUpdateRequired> selectedSpaUpdateRequired{simulation};
-  if (selectedSpaUpdateRequired.hasNoneSelected()) return;
+void updateSpa(Simulation& simulation, bool ignoreBoosts) {
+  internal::EntityFilter<tags::SpaStatUpdateRequired> filter{simulation};
+  if (filter.hasNoneSelected()) return;
 
-  simulation.viewForSelectedPokemon<resetEffectiveSpa>();
+  filter.view<resetEffectiveSpa>();
 
-  simulation.viewForSelectedPokemon<applyBoostToEffectiveStat<stat::EffectiveSpa, SpaBoost>>();
+  if (!ignoreBoosts) {
+    filter.view<applyBoostToEffectiveStat<stat::EffectiveSpa, SpaBoost>>();
+  }
   runModifySpa(simulation);
 
-  simulation.registry.clear<tags::SpaStatUpdateRequired>();
+  filter.clearSelectionTags();
 }
 
-void updateSpd(Simulation& simulation) {
-  internal::SelectForPokemonView<tags::SpdStatUpdateRequired> selectedSpdUpdateRequired{simulation};
-  if (selectedSpdUpdateRequired.hasNoneSelected()) return;
+void updateSpd(Simulation& simulation, bool ignoreBoosts) {
+  internal::EntityFilter<tags::SpdStatUpdateRequired> filter{simulation};
+  if (filter.hasNoneSelected()) return;
 
-  simulation.viewForSelectedPokemon<resetEffectiveSpd>();
+  filter.view<resetEffectiveSpd>();
 
-  simulation.viewForSelectedPokemon<applyBoostToEffectiveStat<stat::EffectiveSpd, SpdBoost>>();
+  if (!ignoreBoosts) {
+    filter.view<applyBoostToEffectiveStat<stat::EffectiveSpd, SpdBoost>>();
+  }
   runModifySpd(simulation);
 
-  simulation.registry.clear<tags::SpdStatUpdateRequired>();
+  filter.clearSelectionTags();
 }
 
-void updateSpe(Simulation& simulation) {
-  internal::SelectForPokemonView<tags::SpeStatUpdateRequired> selectedSpeUpdateRequired{simulation};
-  if (selectedSpeUpdateRequired.hasNoneSelected()) return;
+void updateSpe(Simulation& simulation, bool ignoreBoosts) {
+  internal::EntityFilter<tags::SpeStatUpdateRequired> filter{simulation};
+  if (filter.hasNoneSelected()) return;
 
-  simulation.viewForSelectedPokemon<resetEffectiveSpe>();
+  filter.view<resetEffectiveSpe>();
 
-  simulation.viewForSelectedPokemon<applyBoostToEffectiveStat<stat::EffectiveSpe, SpeBoost>>();
+  if (!ignoreBoosts) {
+    filter.view<applyBoostToEffectiveStat<stat::EffectiveSpe, SpeBoost>>();
+  }
   runModifySpe(simulation);
   // trick room
 
-  simulation.viewForSelectedPokemon<setSpeedSortNeeded, Tags<tags::SimulateTurn>>();
-  simulation.registry.clear<tags::SpeStatUpdateRequired>();
+  filter.view<setSpeedSortNeeded, Tags<tags::SimulateTurn>>();
+  filter.clearSelectionTags();
 }
 }  // namespace pokesim
diff --git a/src/Battle/Pokemon/ManagePokemonState.hpp b/src/Battle/Pokemon/ManagePokemonState.hpp
index 4dfbe175..6c3b4b5b 100644
--- a/src/Battle/Pokemon/ManagePokemonState.hpp
+++ b/src/Battle/Pokemon/ManagePokemonState.hpp
@@ -52,9 +52,9 @@ void applyStatBoost(types::stat& stat, types::boost boost);
 void tryBoost(Simulation& simulation);
 
 void updateAllStats(Simulation& simulation);
-void updateAtk(Simulation& simulation);
-void updateDef(Simulation& simulation);
-void updateSpa(Simulation& simulation);
-void updateSpd(Simulation& simulation);
-void updateSpe(Simulation& simulation);
+void updateAtk(Simulation& simulation, bool ignoreBoosts);
+void updateDef(Simulation& simulation, bool ignoreBoosts);
+void updateSpa(Simulation& simulation, bool ignoreBoosts);
+void updateSpd(Simulation& simulation, bool ignoreBoosts);
+void updateSpe(Simulation& simulation, bool ignoreBoosts);
 }  // namespace pokesim
diff --git a/src/CalcDamage/CalcDamage.cpp b/src/CalcDamage/CalcDamage.cpp
index 88913ec0..6ff2cf18 100644
--- a/src/CalcDamage/CalcDamage.cpp
+++ b/src/CalcDamage/CalcDamage.cpp
@@ -23,6 +23,7 @@
 #include <Components/SpeciesTypes.hpp>
 #include <Components/Stats.hpp>
 #include <Components/Tags/MovePropertyTags.hpp>
+#include <Components/Tags/PokemonTags.hpp>
 #include <Components/Tags/Selection.hpp>
 #include <Components/Tags/SimulationTags.hpp>
 #include <Components/Tags/StatusTags.hpp>
@@ -41,7 +42,7 @@
 #include <Types/Event.hpp>
 #include <Types/MechanicConstants.hpp>
 #include <Types/Registry.hpp>
-#include <Utilities/SelectForView.hpp>
+#include <Utilities/EntityFilter.hpp>
 #include <cmath>
 #include <cstddef>
 #include <type_traits>
@@ -50,6 +51,10 @@
 
 namespace pokesim::calc_damage {
 namespace {
+auto getMoveFilter(Simulation& simulation) {
+  return pokesim::internal::EntityFilter<pokesim::tags::CurrentMoveHit>{simulation};
+}
+
 void clearRunVariables(Simulation& simulation) {
   simulation.registry.clear<
     tags::Crit,
@@ -96,10 +101,6 @@ void setDefendingSide(types::handle moveHandle, Defender defender) {
   types::registry& registry = *moveHandle.registry();
   PlayerSideId playerSide = registry.get<PlayerSide>(registry.get<Side>(defender.val).val).val;
   switch (playerSide) {
-    case PlayerSideId::NONE: {
-      POKESIM_REQUIRE_FAIL("Player side wasn't set properly.");
-      break;
-    }
     case PlayerSideId::P1: {
       moveHandle.emplace<tags::P1Defending>();
       break;
@@ -108,6 +109,10 @@ void setDefendingSide(types::handle moveHandle, Defender defender) {
       moveHandle.emplace<tags::P2Defending>();
       break;
     }
+    default: {
+      POKESIM_REQUIRE_FAIL("Player side wasn't set properly.");
+      break;
+    }
   }
 }
 
@@ -128,6 +133,7 @@ void modifyDamage(Damage& damage, const DamageRollModifiers& modifiers, const Po
 
   if (modifiers.burn) {
     const auto multiplier = pokedex.getStaticValue<dex::Burn::physicalDamageMultiplier>();
+
     damage.val = (types::damage)fixedPointMultiply(damage.val, multiplier);
   }
 
@@ -230,7 +236,7 @@ void setIgnoreDefendingBoostIfPositive(types::handle moveHandle, Defender defend
 void calculateBaseDamage(
   types::handle moveHandle, Power power, AttackingLevel level, AttackingStat attack, DefendingStat defense) {
   types::damage damage = computeBaseDamage(power.val, level.val, attack.val, defense.val);
-  moveHandle.emplace_or_replace<Damage>(damage);
+  moveHandle.emplace<Damage>(damage);
 }
 
 void applyUsesUntilKo(types::handle moveHandle, const DamageRolls& damageRolls, Defender defender) {
@@ -261,8 +267,8 @@ void applySideDamageRollOptions(Simulation& simulation) {
     isSimulateTurn || isCalculateDamage || isAnalyzeEffect,
     "Using a type that isn't a valid simulation tag.");
 
-  pokesim::internal::SelectForCurrentActionMoveView<SimulationTag> selectedMoves{simulation};
-  if (selectedMoves.hasNoneSelected()) {
+  pokesim::internal::EntityFilter<SimulationTag, pokesim::tags::CurrentMoveHit> moveFilter{simulation};
+  if (moveFilter.hasNoneSelected()) {
     return;
   }
 
@@ -287,55 +293,57 @@ void applySideDamageRollOptions(Simulation& simulation) {
   }
 
   if (damageRollOptions.sidesMatch()) {
+    moveFilter.template addToSelected<internal::tags::ApplySideDamageRollOptions>();
+    simulation.removeFromEntities<internal::tags::ApplySideDamageRollOptions, move::tags::Status>();
     if constexpr (onlyPassDamageRoll) {
       ApplyDamageRollKind(simulation, damageRollOptions.getP1());
     }
     else {
       ApplyDamageRollKind(simulation, damageRollOptions.getP1(), calculateUpToFoeHp, noKoChanceCalculation);
     }
+    simulation.registry.clear<internal::tags::ApplySideDamageRollOptions>();
   }
   else {
-    simulation.viewForSelectedMoves<setDefendingSide>();
-    pokesim::internal::SelectForCurrentActionMoveView<tags::P1Defending> p1DefendingMoves{simulation};
-    if (!p1DefendingMoves.hasNoneSelected()) {
-      if constexpr (onlyPassDamageRoll) {
-        ApplyDamageRollKind(simulation, damageRollOptions.getP1());
-      }
-      else {
-        ApplyDamageRollKind(simulation, damageRollOptions.getP1(), calculateUpToFoeHp, noKoChanceCalculation);
-      }
+    moveFilter.template view<setDefendingSide>();
+
+    simulation.addToEntities<internal::tags::ApplySideDamageRollOptions, tags::P1Defending>();
+    simulation.removeFromEntities<internal::tags::ApplySideDamageRollOptions, move::tags::Status>();
+    if constexpr (onlyPassDamageRoll) {
+      ApplyDamageRollKind(simulation, damageRollOptions.getP1());
     }
-    p1DefendingMoves.deselect();
-
-    pokesim::internal::SelectForCurrentActionMoveView<tags::P2Defending> p2DefendingMoves{simulation};
-    if (!p2DefendingMoves.hasNoneSelected()) {
-      if constexpr (onlyPassDamageRoll) {
-        ApplyDamageRollKind(simulation, damageRollOptions.getP2());
-      }
-      else {
-        ApplyDamageRollKind(simulation, damageRollOptions.getP2(), calculateUpToFoeHp, noKoChanceCalculation);
-      }
+    else {
+      ApplyDamageRollKind(simulation, damageRollOptions.getP1(), calculateUpToFoeHp, noKoChanceCalculation);
     }
+    simulation.registry.clear<internal::tags::ApplySideDamageRollOptions, tags::P1Defending>();
 
-    simulation.registry.clear<tags::P1Defending, tags::P2Defending>();
+    simulation.addToEntities<internal::tags::ApplySideDamageRollOptions, tags::P2Defending>();
+    simulation.removeFromEntities<internal::tags::ApplySideDamageRollOptions, move::tags::Status>();
+    if constexpr (onlyPassDamageRoll) {
+      ApplyDamageRollKind(simulation, damageRollOptions.getP2());
+    }
+    else {
+      ApplyDamageRollKind(simulation, damageRollOptions.getP2(), calculateUpToFoeHp, noKoChanceCalculation);
+    }
+    simulation.registry.clear<internal::tags::ApplySideDamageRollOptions, tags::P2Defending>();
   }
 }
 
 template <typename SimulationTag>
 void setIfMoveCrits(Simulation& simulation, DamageRollKind damageRollKind) {
   if (damageRollKind & DamageRollKind::GUARANTEED_CRIT_CHANCE) {
-    simulation.addToEntities<tags::Crit, pokesim::tags::SelectedForViewMove>();
+    simulation.addToEntities<tags::Crit, internal::tags::ApplySideDamageRollOptions>();
     return;
   }
 
   if constexpr (std::is_same_v<SimulationTag, pokesim::tags::SimulateTurn>) {
-    simulation.addToEntities<calc_damage::CritBoost, pokesim::tags::SelectedForViewMove, pokesim::tags::SimulateTurn>();
+    simulation.addToEntities<calc_damage::CritBoost, internal::tags::ApplySideDamageRollOptions>();
     runModifyCritBoostEvent(simulation);
-    simulation.viewForSelectedMoves<assignCritChanceDivisor>(
+    simulation.view<assignCritChanceDivisor>(
       simulation.pokedex().getStaticValue<MechanicConstants::CRIT_CHANCE_DIVISORS>());
     simulation.registry.clear<CritBoost>();
 
     simulate_turn::setIfMoveCrits(simulation);
+    simulation.registry.clear<CritChanceDivisor>();
   }
 }
 
@@ -349,37 +357,42 @@ void applyDamageRollsAndModifiers(
     damageRollKind != DamageRollKind::GUARANTEED_CRIT_CHANCE,
     "Must pick a damage roll kind to go along with crits.");
 
-  simulation.addToEntities<DamageRolls, DamageRollModifiers, pokesim::tags::SelectedForViewMove>();
+  pokesim::internal::EntityFilter<internal::tags::ApplySideDamageRollOptions> moveFilter{simulation};
+  if (moveFilter.hasNoneSelected()) {
+    return;
+  }
+
+  simulation.addToEntities<DamageRolls, DamageRollModifiers, internal::tags::ApplySideDamageRollOptions>();
   if (damageRollKind & DamageRollKind::ALL_DAMAGE_ROLLS) {
-    simulation.viewForSelectedMoves<calculateAllDamageRolls>(simulation.pokedex());
+    moveFilter.view<calculateAllDamageRolls>(simulation.pokedex());
   }
   else {
     if (damageRollKind & DamageRollKind::MAX_DAMAGE) {
-      simulation.viewForSelectedMoves<applyDamageRollModifier>(simulation.pokedex());
+      moveFilter.view<applyDamageRollModifier>(simulation.pokedex());
     }
 
     if (damageRollKind & DamageRollKind::AVERAGE_DAMAGE) {
-      simulation.viewForSelectedMoves<applyAverageDamageRollModifier>(simulation.pokedex());
+      moveFilter.view<applyAverageDamageRollModifier>(simulation.pokedex());
     }
 
     if (damageRollKind & DamageRollKind::MIN_DAMAGE) {
-      simulation.viewForSelectedMoves<applyMinDamageRollModifier>(simulation.pokedex());
+      moveFilter.view<applyMinDamageRollModifier>(simulation.pokedex());
     }
   }
 
   if constexpr (std::is_same_v<pokesim::tags::SimulateTurn, SimulationTag>) {
     if (calculateUpToFoeHp) {
-      simulation.viewForSelectedMoves<reduceDamageRollsToDefenderHp>();
+      moveFilter.view<reduceDamageRollsToDefenderHp>();
     }
     simulate_turn::cloneFromDamageRolls(simulation, damageRollKind);
   }
   else {
-    simulation.viewForSelectedMoves<modifyDamage>(simulation.pokedex());
+    moveFilter.view<modifyDamage>(simulation.pokedex());
     if (calculateUpToFoeHp) {
-      simulation.viewForSelectedMoves<reduceDamageRollsToDefenderHp>();
+      moveFilter.view<reduceDamageRollsToDefenderHp>();
     }
     if (!noKoChanceCalculation && damageRollKind & DamageRollKind::ALL_DAMAGE_ROLLS) {
-      simulation.viewForSelectedMoves<applyUsesUntilKo, Tags<SimulationTag>>();
+      moveFilter.view<applyUsesUntilKo, Tags<SimulationTag>>();
     }
   }
 }
@@ -413,68 +426,66 @@ void resetEffectiveAndDefendingStat(types::registry& registry, Defender defender
 template <typename EffectiveStat, typename IgnoresBoostTag, typename UsesStatTag>
 void setUnboostedStat(Simulation& simulation) {
   static constexpr bool forAttacker = std::is_same_v<IgnoresBoostTag, tags::IgnoresAttackingBoost>;
+  auto moveFilter = getMoveFilter(simulation);
+
   if constexpr (forAttacker) {
-    simulation.viewForSelectedMoves<saveRealEffectiveAttackerStat<EffectiveStat>, Tags<IgnoresBoostTag, UsesStatTag>>();
+    moveFilter.view<saveRealEffectiveAttackerStat<EffectiveStat>, Tags<IgnoresBoostTag, UsesStatTag>>();
   }
   else {
-    simulation.viewForSelectedMoves<saveRealEffectiveDefenderStat<EffectiveStat>, Tags<IgnoresBoostTag, UsesStatTag>>();
+    moveFilter.view<saveRealEffectiveDefenderStat<EffectiveStat>, Tags<IgnoresBoostTag, UsesStatTag>>();
   }
 
-  internal::SelectForPokemonView<RealEffectiveStat> selectedPokemon{simulation};
-  if (selectedPokemon.hasNoneSelected()) {
+  if (simulation.registry.view<RealEffectiveStat>().empty()) {
     return;
   }
 
   if constexpr (std::is_same_v<UsesStatTag, tags::UsesAtk>) {
-    simulation.viewForSelectedPokemon<resetEffectiveAtk>();
-    runModifyAtk(simulation);
+    simulation.addToEntities<pokesim::tags::AtkStatUpdateRequired, RealEffectiveStat>();
+    updateAtk(simulation, true);
   }
   else if constexpr (
     std::is_same_v<UsesStatTag, tags::UsesDef> || std::is_same_v<UsesStatTag, tags::UsesDefAsOffense>) {
-    simulation.viewForSelectedPokemon<resetEffectiveDef>();
-    runModifyDef(simulation);
+    simulation.addToEntities<pokesim::tags::DefStatUpdateRequired, RealEffectiveStat>();
+    updateDef(simulation, true);
   }
   else if constexpr (std::is_same_v<UsesStatTag, tags::UsesSpa>) {
-    simulation.viewForSelectedPokemon<resetEffectiveSpa>();
-    runModifySpa(simulation);
+    simulation.addToEntities<pokesim::tags::SpaStatUpdateRequired, RealEffectiveStat>();
+    updateSpa(simulation, true);
   }
   else if constexpr (std::is_same_v<UsesStatTag, tags::UsesSpd>) {
-    simulation.viewForSelectedPokemon<resetEffectiveSpd>();
-    runModifySpd(simulation);
+    simulation.addToEntities<pokesim::tags::SpdStatUpdateRequired, RealEffectiveStat>();
+    updateSpd(simulation, true);
   }
   else {
     static_assert("No other stat is used as the attacking or defending stat.");
   }
 
   if constexpr (forAttacker) {
-    simulation
-      .viewForSelectedMoves<resetEffectiveAndAttackingStat<EffectiveStat>, Tags<IgnoresBoostTag, UsesStatTag>>();
+    moveFilter.view<resetEffectiveAndAttackingStat<EffectiveStat>, Tags<IgnoresBoostTag, UsesStatTag>>();
   }
   else {
-    simulation
-      .viewForSelectedMoves<resetEffectiveAndDefendingStat<EffectiveStat>, Tags<IgnoresBoostTag, UsesStatTag>>();
+    moveFilter.view<resetEffectiveAndDefendingStat<EffectiveStat>, Tags<IgnoresBoostTag, UsesStatTag>>();
   }
 
   simulation.registry.clear<RealEffectiveStat>();
 }
 
 void setDamageFormulaVariables(Simulation& simulation) {
-  simulation.viewForSelectedMoves<setSourceLevel>();
+  auto moveFilter = getMoveFilter(simulation);
+  moveFilter.view<setSourceLevel>();
 
-  simulation.viewForSelectedMoves<setUsedAttackStat<move::tags::Physical>, Tags<move::tags::Physical>>();
-  simulation.viewForSelectedMoves<setUsedAttackStat<move::tags::Special>, Tags<move::tags::Special>>();
-  simulation.viewForSelectedMoves<setUsedDefenseStat<move::tags::Physical>, Tags<move::tags::Physical>>();
-  simulation.viewForSelectedMoves<setUsedDefenseStat<move::tags::Special>, Tags<move::tags::Special>>();
+  moveFilter.view<setUsedAttackStat<move::tags::Physical>, Tags<move::tags::Physical>>();
+  moveFilter.view<setUsedAttackStat<move::tags::Special>, Tags<move::tags::Special>>();
+  moveFilter.view<setUsedDefenseStat<move::tags::Physical>, Tags<move::tags::Physical>>();
+  moveFilter.view<setUsedDefenseStat<move::tags::Special>, Tags<move::tags::Special>>();
 
-  simulation.viewForSelectedMoves<setIgnoreAttackingBoostIfNegative<AtkBoost>, Tags<tags::Crit, tags::UsesAtk>>();
-  simulation.viewForSelectedMoves<setIgnoreAttackingBoostIfNegative<SpaBoost>, Tags<tags::Crit, tags::UsesSpa>>();
-  simulation.viewForSelectedMoves<setIgnoreDefendingBoostIfPositive<DefBoost>, Tags<tags::Crit, tags::UsesDef>>();
-  simulation.viewForSelectedMoves<setIgnoreDefendingBoostIfPositive<SpdBoost>, Tags<tags::Crit, tags::UsesSpd>>();
-  // simulation.viewForSelectedMoves<setIgnoreAttackingBoostIfNegative<DefBoost>, Tags<tags::Crit,
-  // tags::UsesDefAsOffense>>();
+  moveFilter.view<setIgnoreAttackingBoostIfNegative<AtkBoost>, Tags<tags::Crit, tags::UsesAtk>>();
+  moveFilter.view<setIgnoreAttackingBoostIfNegative<SpaBoost>, Tags<tags::Crit, tags::UsesSpa>>();
+  moveFilter.view<setIgnoreDefendingBoostIfPositive<DefBoost>, Tags<tags::Crit, tags::UsesDef>>();
+  moveFilter.view<setIgnoreDefendingBoostIfPositive<SpdBoost>, Tags<tags::Crit, tags::UsesSpd>>();
+  // moveFilter.view<setIgnoreAttackingBoostIfNegative<DefBoost>, Tags<tags::Crit, tags::UsesDefAsOffense>>();
 
-  // simulation.viewForSelectedPokemon<dex::latest::Unaware::onUsesBoost, Tags<ability::tags::Unaware,
-  // tags::Attacker>>();
+  // moveFilter.view<dex::latest::Unaware::onUsesBoost, Tags<ability::tags::Unaware, tags::Attacker>>();
 
   setUnboostedStat<stat::EffectiveAtk, tags::IgnoresAttackingBoost, tags::UsesAtk>(simulation);
   setUnboostedStat<stat::EffectiveSpa, tags::IgnoresAttackingBoost, tags::UsesSpa>(simulation);
@@ -484,15 +495,16 @@ void setDamageFormulaVariables(Simulation& simulation) {
 }
 
 void setDamageRollModifiers(Simulation& simulation) {
-  simulation.viewForSelectedMoves<checkForAndApplyStab>();
-  simulation.viewForSelectedMoves<checkForAndApplyTypeEffectiveness>(simulation.pokedex());
+  auto moveFilter = getMoveFilter(simulation);
+  moveFilter.view<checkForAndApplyStab>();
+  moveFilter.view<checkForAndApplyTypeEffectiveness>(simulation.pokedex());
   dex::Burn::onSetDamageRollModifiers(simulation);
   runModifyDamageEvent(simulation);
 }
 
 void calcDamage(Simulation& simulation) {
-  pokesim::internal::SelectForCurrentActionMoveView<> selectedMoves{simulation, entt::exclude<move::tags::Status>};
-  if (selectedMoves.hasNoneSelected()) {
+  auto moveFilter = getMoveFilter(simulation);
+  if (moveFilter.hasNoneSelected()) {
     return;
   }
 
@@ -507,11 +519,11 @@ void calcDamage(Simulation& simulation) {
   runBasePowerEvent(simulation);
   setDamageFormulaVariables(simulation);
 
-  simulation.viewForSelectedMoves<calculateBaseDamage>();
-  simulation.viewForSelectedMoves<applyCritDamageIncrease, Tags<tags::Crit>>(
+  moveFilter.view<calculateBaseDamage>();
+  moveFilter.view<applyCritDamageIncrease, Tags<tags::Crit>>(
     simulation.pokedex().getStaticValue<MechanicConstants::CRIT_MULTIPLIER>());
 
-  simulation.addToEntities<DamageRollModifiers, pokesim::tags::SelectedForViewMove>();
+  simulation.addToEntities<DamageRollModifiers, Damage, pokesim::tags::CurrentMoveHit>();
   setDamageRollModifiers(simulation);
 
   applySideDamageRollOptions<SimulateTurn, applyDamageRollsAndModifiers<SimulateTurn>>(simulation);
diff --git a/src/CalcDamage/CalcDamageDebugChecks.hpp b/src/CalcDamage/CalcDamageDebugChecks.hpp
index 04741d6b..9066349d 100644
--- a/src/CalcDamage/CalcDamageDebugChecks.hpp
+++ b/src/CalcDamage/CalcDamageDebugChecks.hpp
@@ -85,8 +85,17 @@ struct Checks : pokesim::debug::Checks {
   std::size_t calcDamageCount = 0U;
   std::size_t analyzeEffectCount = 0U;
 
+  types::entityVector getMoveList() const {
+    auto view = registry->view<pokesim::tags::CurrentMoveHit>();
+    return {view.begin(), view.end()};
+  }
+
   void checkMoveInputs() {
-    CurrentActionMovesAsSource moves{simulation->selectedMoveEntities()};
+    CurrentActionMovesAsSource moves{getMoveList()};
+    if (moves.val.empty()) {
+      return;
+    }
+
     for (types::entity move : moves.val) {
       if (has<pokesim::move::tags::Status>(move)) continue;
 
@@ -102,7 +111,7 @@ struct Checks : pokesim::debug::Checks {
   }
 
   types::entityVector getPokemonList(bool forAttacker) const {
-    types::entityVector selectedPokemon = simulation->selectedPokemonEntities();
+    types::entityVector selectedPokemon = simulation->pokemonEntities();
     auto end = std::remove_if(selectedPokemon.begin(), selectedPokemon.end(), [&](types::entity entity) {
       if (forAttacker) {
         return !this->has<tags::Attacker>(entity);
@@ -170,7 +179,7 @@ struct Checks : pokesim::debug::Checks {
   }
 
   void checkBattleInputs() {
-    for (types::entity battle : simulation->selectedBattleEntities()) {
+    for (types::entity battle : simulation->battleEntities()) {
       copyEntity(battle);
       checkBattle(battle);
       for (types::entity side : registry->get<Sides>(battle).val) {
@@ -292,7 +301,7 @@ struct Checks : pokesim::debug::Checks {
   }
 
   void checkMoveOutputs() const {
-    for (types::entity move : simulation->selectedMoveEntities()) {
+    for (types::entity move : getMoveList()) {
       if (has<pokesim::move::tags::Status>(move)) continue;
 
       pokesim::debug::TypesToIgnore typesToIgnore{};
@@ -336,7 +345,7 @@ struct Checks : pokesim::debug::Checks {
   }
 
   void checkBattleOutputs() const {
-    for (types::entity battle : simulation->selectedBattleEntities()) {
+    for (types::entity battle : simulation->battleEntities()) {
       pokesim::debug::TypesToIgnore typesToIgnore;
       if (has<pokesim::tags::SimulateTurn>(battle)) {
         typesToIgnore.add<Probability, RngSeed, ParentBattle>();
diff --git a/src/Components/AnalyzeEffect/AnalyzeEffectInputs.hpp b/src/Components/AnalyzeEffect/AnalyzeEffectInputs.hpp
index 0a088015..51930c16 100644
--- a/src/Components/AnalyzeEffect/AnalyzeEffectInputs.hpp
+++ b/src/Components/AnalyzeEffect/AnalyzeEffectInputs.hpp
@@ -2,7 +2,6 @@
 
 #include <Types/Entity.hpp>
 #include <Types/Enums/Move.hpp>
-#include <Types/Random.hpp>
 #include <Types/State.hpp>
 #include <Utilities/MaxSizedVector.hpp>
 
@@ -43,7 +42,7 @@ struct MovePair {
 };
 
 struct SkippedInputCount {
-  types::eventPossibilities val = 0U;
+  types::entityIndex val = 0U;
 };
 
 namespace tags {
diff --git a/src/Components/Tags/RunEventTags.hpp b/src/Components/Tags/RunEventTags.hpp
new file mode 100644
index 00000000..c220c2b4
--- /dev/null
+++ b/src/Components/Tags/RunEventTags.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+namespace pokesim::tags {
+struct DisableMove {};
+struct EndItem {};
+}  // namespace pokesim::tags
diff --git a/src/Components/Tags/Selection.hpp b/src/Components/Tags/Selection.hpp
index fbae7ff1..15cf44db 100644
--- a/src/Components/Tags/Selection.hpp
+++ b/src/Components/Tags/Selection.hpp
@@ -1,11 +1,6 @@
 #pragma once
 
-#include <Types/Entity.hpp>
-#include <entt/signal/delegate.hpp>
-
-namespace pokesim::tags {
-struct SelectedForViewBattle {};
-struct SelectedForViewSide {};
-struct SelectedForViewPokemon {};
-struct SelectedForViewMove {};
-}  // namespace pokesim::tags
+namespace pokesim::internal::tags {
+struct CloneFromDamageRolls {};
+struct ApplySideDamageRollOptions {};
+}  // namespace pokesim::internal::tags
diff --git a/src/Components/Tags/headers.hpp b/src/Components/Tags/headers.hpp
index ba913574..bca4e2ea 100644
--- a/src/Components/Tags/headers.hpp
+++ b/src/Components/Tags/headers.hpp
@@ -11,6 +11,7 @@
 #include "MoveTags.hpp"
 #include "NatureTags.hpp"
 #include "PokemonTags.hpp"
+#include "RunEventTags.hpp"
 #include "Selection.hpp"
 #include "SimulationTags.hpp"
 #include "StatusTags.hpp"
diff --git a/src/Components/headers.hpp b/src/Components/headers.hpp
index ba1c68f3..ff533d34 100644
--- a/src/Components/headers.hpp
+++ b/src/Components/headers.hpp
@@ -81,6 +81,7 @@
 #include "Tags/MoveTags.hpp"
 #include "Tags/NatureTags.hpp"
 #include "Tags/PokemonTags.hpp"
+#include "Tags/RunEventTags.hpp"
 #include "Tags/Selection.hpp"
 #include "Tags/SimulationTags.hpp"
 #include "Tags/StatusTags.hpp"
diff --git a/src/Pokedex/Events/AbilityEvents.cpp b/src/Pokedex/Events/AbilityEvents.cpp
index 57532a88..188adccd 100644
--- a/src/Pokedex/Events/AbilityEvents.cpp
+++ b/src/Pokedex/Events/AbilityEvents.cpp
@@ -6,6 +6,7 @@
 #include <Components/Tags/AbilityTags.hpp>
 #include <Components/Tags/Current.hpp>
 #include <Components/Tags/MovePropertyTags.hpp>
+#include <Components/Tags/PokemonTags.hpp>
 #include <Components/Tags/StatusTags.hpp>
 #include <Pokedex/Pokedex.hpp>
 #include <SimulateTurn/RandomChance.hpp>
@@ -58,13 +59,13 @@ void Plus::onModifySpA(Simulation& simulation) {
   if (simulation.isBattleFormat(BattleFormat::SINGLES)) {
     return;
   }
-  simulation.viewForSelectedPokemon<plusOnModifySpa, Tags<ability::tags::Plus>>();
+  simulation.view<plusOnModifySpa, Tags<ability::tags::Plus>>();
 }
 
 void Static::onDamagingHit(Simulation& simulation) {
   const auto chanceOfStatic = simulation.pokedex().getStaticValue<dex::Static::onDamagingHitChance>();
 
-  simulation.viewForSelectedPokemon<staticOnDamagingHit, Tags<ability::tags::Static>>(chanceOfStatic, simulation);
+  simulation.view<staticOnDamagingHit, Tags<ability::tags::Static>>(chanceOfStatic, simulation);
 
   // TODO(aed3): This is now inefficient since the random chance will happen for move sources that cannot have their
   // status changed.
diff --git a/src/Pokedex/Events/EffectEvents.cpp b/src/Pokedex/Events/EffectEvents.cpp
index 8430af30..de412c16 100644
--- a/src/Pokedex/Events/EffectEvents.cpp
+++ b/src/Pokedex/Events/EffectEvents.cpp
@@ -11,11 +11,14 @@
 #include <Components/Tags/Current.hpp>
 #include <Components/Tags/ItemPropertyTags.hpp>
 #include <Components/Tags/MovePropertyTags.hpp>
+#include <Components/Tags/PokemonTags.hpp>
+#include <Components/Tags/RunEventTags.hpp>
 #include <Components/Tags/StatusTags.hpp>
 #include <Config/Require.hpp>
 #include <Pokedex/Pokedex.hpp>
 #include <SimulateTurn/RandomChance.hpp>
 #include <Simulation/Simulation.hpp>
+#include <Utilities/EntityFilter.hpp>
 #include <entt/entity/registry.hpp>
 
 #include "../Effects/headers.hpp"
@@ -71,21 +74,24 @@ void choiceLockOnDisableMove(
 }  // namespace
 
 void Burn::onSetDamageRollModifiers(Simulation& simulation) {
-  simulation
-    .viewForSelectedPokemon<applyBurnModifier, Tags<status::tags::Burn> /*, entt::exclude<ability::tags::Guts> */>();
+  simulation.view<applyBurnModifier, Tags<status::tags::Burn> /*, entt::exclude<ability::tags::Guts> */>();
 }
 
 void Burn::onResidual(Simulation& simulation) {
   const auto divisor = simulation.pokedex().getStaticValue<Burn::onResidualHpDecreaseDivisor>();
-  simulation.viewForSelectedPokemon<damageByHpDivisor, Tags<status::tags::Burn>>(divisor);
+
+  simulation.view<damageByHpDivisor, Tags<status::tags::Burn, tags::ActivePokemon>>(divisor);
 }
 
 void Paralysis::onModifySpe(Simulation& simulation) {
   const auto speedDivisor = simulation.pokedex().getStaticValue<Paralysis::speedDivisor>();
   const auto speedDividend = simulation.pokedex().getStaticValue<Paralysis::speedDividend>();
-  simulation.viewForSelectedPokemon<
+
+  simulation.view<
     paralysisOnModifySpeed,
-    Tags<status::tags::Paralysis> /*, entt::exclude_t<ability::tags::QuickFeet>*/>(speedDivisor, speedDividend);
+    Tags<status::tags::Paralysis, tags::SpeStatUpdateRequired> /*, entt::exclude_t<ability::tags::QuickFeet>*/>(
+    speedDivisor,
+    speedDividend);
 }
 
 void Paralysis::onBeforeMove(Simulation& simulation) {
@@ -97,22 +103,25 @@ void Paralysis::onBeforeMove(Simulation& simulation) {
 
   pokesim::internal::randomBinaryChance(
     simulation,
-    [](Simulation& sim) {
-      sim.viewForSelectedPokemon<paralysisOnBeforeMove, Tags<pokesim::internal::tags::RandomEventCheckPassed>>();
-    },
+    [](Simulation& sim) { sim.view<paralysisOnBeforeMove, Tags<pokesim::internal::tags::RandomEventCheckPassed>>(); },
     std::nullopt);
   simulation.view<setFailedActionMove, Tags<pokesim::tags::FailedCurrentMoveHit>>();
-  simulation.registry.clear<tags::FailedCurrentMoveHit>();
+  simulation.registry.clear<pokesim::tags::FailedCurrentMoveHit>();
 }
 
 void ChoiceLock::onBeforeMove(Simulation& simulation) {
-  simulation.viewForSelectedPokemon<choiceLockRemoveWithoutItem, Tags<>, entt::exclude_t<ItemName>>();
-  simulation.viewForSelectedPokemon<choiceLockRemoveWithItem>(simulation.pokedex());
+  simulation.view<choiceLockRemoveWithoutItem, Tags<>, entt::exclude_t<ItemName>>();
+  simulation.view<choiceLockRemoveWithItem>(simulation.pokedex());
 }
 
 void ChoiceLock::onDisableMove(Simulation& simulation) {
-  simulation.viewForSelectedPokemon<choiceLockRemoveWithoutItem, Tags<>, entt::exclude_t<ItemName>>();
-  simulation.viewForSelectedPokemon<choiceLockRemoveWithItem>(simulation.pokedex());
-  simulation.viewForSelectedPokemon<choiceLockOnDisableMove>();
+  pokesim::internal::EntityFilter<tags::DisableMove> filter{simulation};
+  if (filter.hasNoneSelected()) {
+    return;
+  }
+
+  filter.view<choiceLockRemoveWithoutItem, Tags<>, entt::exclude_t<ItemName>>();
+  filter.view<choiceLockRemoveWithItem>(simulation.pokedex());
+  filter.view<choiceLockOnDisableMove>();
 }
 }  // namespace pokesim::dex
diff --git a/src/Pokedex/Events/ItemEvents.cpp b/src/Pokedex/Events/ItemEvents.cpp
index 0ad95efc..54b6bdd7 100644
--- a/src/Pokedex/Events/ItemEvents.cpp
+++ b/src/Pokedex/Events/ItemEvents.cpp
@@ -7,8 +7,11 @@
 #include <Components/EntityHolders/Current.hpp>
 #include <Components/EventModifier.hpp>
 #include <Components/Stats.hpp>
+#include <Components/Tags/Current.hpp>
 #include <Components/Tags/ItemTags.hpp>
 #include <Components/Tags/MovePropertyTags.hpp>
+#include <Components/Tags/PokemonTags.hpp>
+#include <Components/Tags/RunEventTags.hpp>
 #include <Components/Tags/SimulationTags.hpp>
 #include <Pokedex/Pokedex.hpp>
 #include <Simulation/Simulation.hpp>
@@ -53,8 +56,7 @@ void sourceModifyDamage(
 template <typename SimulationTag>
 struct FocusSashOnAfterModifyDamage {
   static void run(Simulation& simulation, types::damage hpToKeep) {
-    simulation.viewForSelectedPokemon<modifyDamage, Tags<item::tags::FocusSash, SimulationTag, tags::CanUseItem>>(
-      hpToKeep);
+    simulation.view<modifyDamage, Tags<item::tags::FocusSash, SimulationTag, tags::CanUseItem>>(hpToKeep);
   }
 
   static void modifyDamage(
@@ -66,6 +68,10 @@ struct FocusSashOnAfterModifyDamage {
 
     types::registry& registry = *pokemonHandle.registry();
     for (types::entity move : moves.val) {
+      if (!registry.all_of<pokesim::tags::CurrentMoveHit>(move)) {
+        continue;
+      }
+
       if constexpr (std::is_same_v<tags::SimulateTurn, SimulationTag>) {
         Damage& damage = registry.get<Damage>(move);
         if (damage.val < hp.val) {
@@ -94,7 +100,9 @@ void lifeOrbOnAfterMove(
   bool onlyStatusMoves = true;
   types::registry& registry = *pokemonHandle.registry();
   for (types::entity move : moves.val) {
-    onlyStatusMoves &= registry.all_of<move::tags::Status>(move);
+    if (registry.all_of<pokesim::tags::CurrentActionMove>(move)) {
+      onlyStatusMoves &= registry.all_of<move::tags::Status>(move);
+    }
   }
 
   if (!onlyStatusMoves) {
@@ -105,28 +113,25 @@ void lifeOrbOnAfterMove(
 
 void AssaultVest::onModifySpd(Simulation& simulation) {
   const auto modifier = simulation.pokedex().getStaticValue<AssaultVest::onModifySpdModifier>();
-  simulation.viewForSelectedPokemon<chainComponentToModifier<types::effectMultiplier>, Tags<item::tags::AssaultVest>>(
-    modifier,
-    1U);
+
+  simulation.view<chainComponentToModifier<types::effectMultiplier>, Tags<item::tags::AssaultVest>>(modifier, 1U);
 }
 
 void AssaultVest::onEnd(Simulation& simulation) {
-  simulation.addToEntities<tags::SpdStatUpdateRequired, tags::SelectedForViewPokemon, item::tags::AssaultVest>();
+  simulation.addToEntities<tags::SpdStatUpdateRequired, tags::EndItem, item::tags::AssaultVest>();
 }
 
 void BrightPowder::onModifyAccuracy(Simulation& simulation) {
   const auto numerator = simulation.pokedex().getStaticValue<BrightPowder::onModifyAccuracyNumerator>();
   const auto denominator = simulation.pokedex().getStaticValue<BrightPowder::onModifyAccuracyDenominator>();
-  simulation.viewForSelectedPokemon<setMoveTargetModifier<types::eventModifier>, Tags<item::tags::BrightPowder>>(
-    numerator,
-    denominator);
+
+  simulation.view<setMoveTargetModifier<types::eventModifier>, Tags<item::tags::BrightPowder>>(numerator, denominator);
 }
 
 void ChoiceScarf::onModifySpe(Simulation& simulation) {
   const auto modifier = simulation.pokedex().getStaticValue<ChoiceScarf::onModifySpeModifier>();
-  simulation.viewForSelectedPokemon<chainComponentToModifier<types::effectMultiplier>, Tags<item::tags::ChoiceScarf>>(
-    modifier,
-    1U);
+
+  simulation.view<chainComponentToModifier<types::effectMultiplier>, Tags<item::tags::ChoiceScarf>>(modifier, 1U);
 }
 
 void ChoiceScarf::onSourceModifyMove(Simulation& simulation) {
@@ -135,14 +140,13 @@ void ChoiceScarf::onSourceModifyMove(Simulation& simulation) {
 }
 
 void ChoiceScarf::onEnd(Simulation& simulation) {
-  simulation.addToEntities<tags::SpeStatUpdateRequired, tags::SelectedForViewPokemon, item::tags::ChoiceScarf>();
+  simulation.addToEntities<tags::SpeStatUpdateRequired, tags::EndItem, item::tags::ChoiceScarf>();
 }
 
 void ChoiceSpecs::onModifySpa(Simulation& simulation) {
   const auto modifier = simulation.pokedex().getStaticValue<ChoiceSpecs::onModifySpaModifier>();
-  simulation.viewForSelectedPokemon<chainComponentToModifier<types::effectMultiplier>, Tags<item::tags::ChoiceSpecs>>(
-    modifier,
-    1U);
+
+  simulation.view<chainComponentToModifier<types::effectMultiplier>, Tags<item::tags::ChoiceSpecs>>(modifier, 1U);
 }
 
 void ChoiceSpecs::onSourceModifyMove(Simulation& simulation) {
@@ -151,11 +155,12 @@ void ChoiceSpecs::onSourceModifyMove(Simulation& simulation) {
 }
 
 void ChoiceSpecs::onEnd(Simulation& simulation) {
-  simulation.addToEntities<tags::SpaStatUpdateRequired, tags::SelectedForViewPokemon, item::tags::ChoiceSpecs>();
+  simulation.addToEntities<tags::SpaStatUpdateRequired, tags::EndItem, item::tags::ChoiceSpecs>();
 }
 
 void FocusSash::onAfterModifyDamage(Simulation& simulation) {
   const auto hpToKeep = simulation.pokedex().getStaticValue<FocusSash::onAfterModifyDamageHpToKeep>();
+
   simulation.addToEntities<tags::CanUseItem, tags::CurrentActionMoveTarget, item::tags::FocusSash>();
   checkIfCanUseItem(simulation);
 
@@ -172,13 +177,13 @@ void FocusSash::onDamage(Simulation& simulation) {
 void LifeOrb::onModifyDamage(Simulation& simulation) {
   const auto numerator = simulation.pokedex().getStaticValue<LifeOrb::onModifyDamageNumerator>();
   const auto denominator = simulation.pokedex().getStaticValue<LifeOrb::onModifyDamageDenominator>();
-  simulation.viewForSelectedPokemon<sourceModifyDamage<types::eventModifier>, Tags<item::tags::LifeOrb>>(
-    numerator,
-    denominator);
+
+  simulation.view<sourceModifyDamage<types::eventModifier>, Tags<item::tags::LifeOrb>>(numerator, denominator);
 }
 
 void LifeOrb::onAfterMoveUsed(Simulation& simulation) {
   const auto divisor = simulation.pokedex().getStaticValue<LifeOrb::onAfterMoveUsedHpDecreaseDivisor>();
-  simulation.viewForSelectedPokemon<lifeOrbOnAfterMove, Tags<item::tags::LifeOrb>>(divisor);
+
+  simulation.view<lifeOrbOnAfterMove, Tags<item::tags::LifeOrb>>(divisor);
 }
 }  // namespace pokesim::dex
diff --git a/src/Pokedex/Events/MoveEvents.cpp b/src/Pokedex/Events/MoveEvents.cpp
index 277134df..b843ddc8 100644
--- a/src/Pokedex/Events/MoveEvents.cpp
+++ b/src/Pokedex/Events/MoveEvents.cpp
@@ -3,6 +3,7 @@
 #include <Components/EntityHolders/Current.hpp>
 #include <Components/Names/ItemNames.hpp>
 #include <Components/Stats.hpp>
+#include <Components/Tags/Current.hpp>
 #include <Components/Tags/MoveTags.hpp>
 #include <Components/Tags/PokemonTags.hpp>
 #include <Pokedex/Pokedex.hpp>
@@ -16,7 +17,7 @@
 namespace pokesim::dex {
 namespace {
 void knockOffOnBasePowerCheckRemovableItem(
-  types::registry& registry, CurrentActionSource source, CurrentActionTarget target) {
+  types::registry& registry, CurrentActionSource source, CurrentActionTarget target, EventModifier&) {
   if (registry.get<stat::CurrentHp>(source.val).val > Constants::PokemonCurrentHpStat::MIN) {
     registry.emplace_or_replace<tags::CanRemoveItem>(target.val);
   }
@@ -40,15 +41,15 @@ void knockOffOnBasePower(
 
 void KnockOff::onBasePower(Simulation& simulation) {
   const auto modifier = simulation.pokedex().getStaticValue<KnockOff::onBasePowerMultiplier>();
-  simulation.viewForSelectedMoves<knockOffOnBasePowerCheckRemovableItem, Tags<move::tags::KnockOff>>();
+  simulation.view<knockOffOnBasePowerCheckRemovableItem, Tags<move::tags::KnockOff>>();
   checkIfCanRemoveItem(simulation);
-  simulation.viewForSelectedMoves<knockOffOnBasePower, Tags<move::tags::KnockOff>>(modifier);
+  simulation.view<knockOffOnBasePower, Tags<move::tags::KnockOff>>(modifier);
 
   simulation.registry.clear<tags::CanRemoveItem>();
 }
 
 void KnockOff::onAfterHit(Simulation& simulation) {
-  simulation.viewForSelectedMoves<knockOffOnAfterHitCheckRemovableItem, Tags<move::tags::KnockOff>>();
+  simulation.view<knockOffOnAfterHitCheckRemovableItem, Tags<move::tags::KnockOff, tags::CurrentMoveHit>>();
   tryRemoveItem(simulation);
   simulation.registry.clear<tags::CanRemoveItem>();
 }
diff --git a/src/SimulateTurn/CalcDamageSpecifics.cpp b/src/SimulateTurn/CalcDamageSpecifics.cpp
index 8350615c..d4429953 100644
--- a/src/SimulateTurn/CalcDamageSpecifics.cpp
+++ b/src/SimulateTurn/CalcDamageSpecifics.cpp
@@ -1,8 +1,5 @@
 #include "CalcDamageSpecifics.hpp"
 
-#include <CalcDamage/CalcDamage.hpp>
-#include <CalcDamage/Helpers.hpp>
-#include <Components/CalcDamage/Aliases.hpp>
 #include <Components/CalcDamage/CriticalHit.hpp>
 #include <Components/Damage.hpp>
 #include <Components/Probability.hpp>
@@ -17,7 +14,7 @@
 #include <Types/Damage.hpp>
 #include <Types/Enums/DamageRollKind.hpp>
 #include <Types/Random.hpp>
-#include <Utilities/SelectForView.hpp>
+#include <Utilities/EntityFilter.hpp>
 
 namespace pokesim::simulate_turn {
 namespace {
@@ -73,43 +70,38 @@ types::eventPossibilities countUniqueDamageRolls(types::handle moveHandle) {
 }
 
 void updateAllDamageRollProbabilities(Simulation& simulation) {
-  simulation.viewForSelectedMoves<assignAllDamageRollProbability>();
+  simulation.view<assignAllDamageRollProbability>();
 }
 
 void updatePartialProbabilities(Simulation& simulation) {
-  simulation.viewForSelectedMoves<assignPartialProbability>();
+  simulation.view<assignPartialProbability>();
 }
 }  // namespace
 
 void cloneFromDamageRolls(Simulation& simulation, DamageRollKind damageRollKind) {
-  pokesim::internal::SelectForCurrentActionMoveView<pokesim::tags::SimulateTurn, DamageRolls> selectedMoves{simulation};
-  if (selectedMoves.hasNoneSelected()) return;
+  pokesim::internal::EntityFilter<pokesim::internal::tags::CloneFromDamageRolls> moveFilter{simulation};
+  moveFilter.applySelectionTags<pokesim::tags::SimulateTurn, DamageRolls>();
+  if (moveFilter.hasNoneSelected()) return;
 
   bool forAllDamageRolls = damageRollKind & DamageRollKind::ALL_DAMAGE_ROLLS;
   bool forRequiredDamageRolls = simulation.simulateTurnOptions.getMakeBranchesOnRandomEvents() || forAllDamageRolls;
-  auto applyChoices = [](Simulation& sim) { sim.viewForSelectedMoves<applyDamageRollIndex>(); };
+  auto applyChoices = [](Simulation& sim) { sim.view<applyDamageRollIndex>(); };
   auto updateProbabilities = forAllDamageRolls ? updateAllDamageRollProbabilities : updatePartialProbabilities;
 
-  runRandomEventCount<pokesim::tags::SelectedForViewMove>(
+  runRandomEventCount<pokesim::internal::tags::CloneFromDamageRolls>(
     simulation,
     countUniqueDamageRolls,
     applyChoices,
     updateProbabilities,
     forRequiredDamageRolls);
 
-  simulation.removeFromEntities<DamageRolls, pokesim::tags::SelectedForViewMove>();
+  simulation.removeFromEntities<DamageRolls, pokesim::internal::tags::CloneFromDamageRolls>();
+  moveFilter.clearSelectionTags();
 }
 
 void setIfMoveCrits(Simulation& simulation) {
-  pokesim::internal::SelectForCurrentActionMoveView<pokesim::tags::SimulateTurn> selectedMoves{simulation};
-  if (selectedMoves.hasNoneSelected()) return;
-
-  runReciprocalRandomBinaryChance<calc_damage::CritChanceDivisor, pokesim::tags::SelectedForViewMove>(
-    simulation,
-    [](Simulation& sim) {
-      sim.addToEntities<calc_damage::tags::Crit, pokesim::internal::tags::RandomEventCheckPassed>();
-    });
-
-  simulation.registry.clear<calc_damage::CritChanceDivisor>();
+  runReciprocalRandomBinaryChance<calc_damage::CritChanceDivisor>(simulation, [](Simulation& sim) {
+    sim.addToEntities<calc_damage::tags::Crit, pokesim::internal::tags::RandomEventCheckPassed>();
+  });
 }
 }  // namespace pokesim::simulate_turn
diff --git a/src/SimulateTurn/ManageActionQueue.cpp b/src/SimulateTurn/ManageActionQueue.cpp
index 422cacd6..ce747c4b 100644
--- a/src/SimulateTurn/ManageActionQueue.cpp
+++ b/src/SimulateTurn/ManageActionQueue.cpp
@@ -88,6 +88,7 @@ void resolveTeamDecision(types::registry& registry, const types::teamOrder& team
   battleActionQueue.val.push_back(actionHandle.entity());
 }
 }  // namespace
+
 void resolveDecision(types::handle sideHandle, const SideDecision& sideDecision) {
   POKESIM_REQUIRE(sideDecision.sideId != PlayerSideId::NONE, "Decisions must be assigned to a player.");
   POKESIM_REQUIRE(!sideDecision.decisions.valueless_by_exception(), "Decisions must be non-empty.");
@@ -151,7 +152,7 @@ void speedSort(types::handle handle, ActionQueue& actionQueue) {
     speedSortList.push_back({registry->get<SpeedSort>(entity), entity});
   }
 
-  // TODO (aed3): Test how different sorting algorithms affect speed
+  // TODO(aed3): Test how different sorting algorithms affect speed
   std::sort(speedSortList.begin(), speedSortList.end(), [](const auto& pairA, const auto& pairB) {
     if (pairA.first.order != pairB.first.order) {
       return pairA.first.order < pairB.first.order;
diff --git a/src/SimulateTurn/SimulateTurn.cpp b/src/SimulateTurn/SimulateTurn.cpp
index 7d853091..96c844e2 100644
--- a/src/SimulateTurn/SimulateTurn.cpp
+++ b/src/SimulateTurn/SimulateTurn.cpp
@@ -27,6 +27,7 @@
 #include <Components/Tags/Current.hpp>
 #include <Components/Tags/MovePropertyTags.hpp>
 #include <Components/Tags/PokemonTags.hpp>
+#include <Components/Tags/RunEventTags.hpp>
 #include <Components/Tags/SimulationTags.hpp>
 #include <Components/Tags/TargetTags.hpp>
 #include <Components/Turn.hpp>
@@ -37,7 +38,7 @@
 #include <Simulation/RunEvent.hpp>
 #include <Simulation/Simulation.hpp>
 #include <Types/Registry.hpp>
-#include <Utilities/SelectForView.hpp>
+#include <Utilities/EntityFilter.hpp>
 #include <Utilities/Tags.hpp>
 
 #include "ManageActionQueue.hpp"
@@ -45,6 +46,10 @@
 
 namespace pokesim::simulate_turn {
 namespace {
+auto getBattleFilter(Simulation& simulation) {
+  return pokesim::internal::EntityFilter<pokesim::tags::SimulateTurn, pokesim::tags::Battle>{simulation};
+}
+
 void addTargetAllyToTargets(types::registry& registry, const Battle& battle) {
   const Sides& sides = registry.get<Sides>(battle.val);
   const TargetSlotName& targetSlotName = registry.get<TargetSlotName>(registry.get<CurrentAction>(battle.val).val);
@@ -96,6 +101,7 @@ void getMoveTargets(Simulation& simulation) {
     simulation
       .view<addUserAllyToTargets, Tags<pokesim::tags::CurrentActionMove, move::added_targets::tags::UserAlly>>();
   }
+
   simulation.view<resolveMoveTargets, Tags<pokesim::tags::CurrentActionMove>, entt::exclude_t<AddedTargets>>();
   simulation.view<
     createActionMoveForTargets,
@@ -122,7 +128,7 @@ void removeActionBySource(types::handle sourceHandle, Battle battle) {
 }
 
 void runMoveAction(Simulation& simulation) {
-  simulation.viewForSelectedBattles<setCurrentActionSource, Tags<action::tags::Move>>();
+  getBattleFilter(simulation).view<setCurrentActionSource, Tags<action::tags::Move>>();
 
   simulation.view<
     removeActionBySource<action::tags::Move>,
@@ -132,11 +138,13 @@ void runMoveAction(Simulation& simulation) {
     Tags<pokesim::tags::CurrentActionMoveSource>,
     entt::exclude_t<pokesim::tags::ActivePokemon>>();
 
-  pokesim::internal::SelectForBattleView<action::tags::Move> selectedBattle{simulation};
-  if (selectedBattle.hasNoneSelected()) return;
+  pokesim::internal::EntityFilter<action::tags::Move, pokesim::tags::Battle> battleFilter{simulation};
+  if (battleFilter.hasNoneSelected()) {
+    return;
+  }
 
-  simulation.viewForSelectedBattles<setCurrentActionTarget>(simulation);
-  simulation.viewForSelectedBattles<setCurrentActionMove>(simulation.pokedex());
+  battleFilter.view<setCurrentActionTarget>(simulation);
+  battleFilter.view<setCurrentActionMove>(simulation.pokedex());
 
   runBeforeMove(simulation);
 
@@ -147,10 +155,12 @@ void runMoveAction(Simulation& simulation) {
 }
 
 void runResidualAction(Simulation& simulation) {
-  pokesim::internal::SelectForBattleView<action::tags::Residual> selectedBattle{simulation};
-  if (selectedBattle.hasNoneSelected()) return;
+  pokesim::internal::EntityFilter<action::tags::Residual, pokesim::tags::Battle> battleFilter{simulation};
+  if (battleFilter.hasNoneSelected()) {
+    return;
+  }
 
-  simulation.viewForSelectedBattles<speedSort, Tags<tags::SpeedSortNeeded>>();
+  battleFilter.view<speedSort, Tags<tags::SpeedSortNeeded>>();
   simulation.registry.clear<tags::SpeedSortNeeded>();
 
   runResidual(simulation);
@@ -186,6 +196,11 @@ void checkWin(types::handle battleHandle, const Sides& sides) {
 }
 
 void faintPokemon(Simulation& simulation) {
+  auto battleFilter = getBattleFilter(simulation);
+  if (battleFilter.hasNoneSelected()) {
+    return;
+  }
+
   using LoopLimits = Constants::ActivePokemon;
   types::activePokemonIndex iterations = LoopLimits::MIN;
   while (!simulation.registry.view<FaintQueue>().empty()) {
@@ -193,27 +208,31 @@ void faintPokemon(Simulation& simulation) {
       iterations <= LoopLimits::MAX,
       "More Pokemon were queued to faint in at least one battle than possible.");
 
-    simulation.viewForSelectedBattles<setFainting>();
+    battleFilter.view<setFainting>();
 
-    pokesim::internal::SelectForPokemonView<pokesim::tags::Fainting> selectedPokemon{simulation};
+    pokesim::internal::EntityFilter<pokesim::tags::Fainting> pokemonFilter{simulation};
     POKESIM_REQUIRE(
-      !selectedPokemon.hasNoneSelected(),
+      !pokemonFilter.hasNoneSelected(),
       "This loop should only be run if setFainting had Pokemon to set as fainting.");
 
     runFaintEvent(simulation);
     runEndAbilityEvent(simulation);
+
+    pokemonFilter.addToSelected<pokesim::tags::EndItem>();
     runEndItemEvent(simulation);
-    simulation.viewForSelectedPokemon<clearVolatiles>();
+    simulation.registry.clear<pokesim::tags::EndItem>();
+
+    pokemonFilter.view<clearVolatiles>();
 
     simulation.addToEntities<pokesim::tags::Fainted, pokesim::tags::Fainting>();
     simulation.removeFromEntities<pokesim::tags::ActivePokemon, pokesim::tags::Fainting>();
     simulation.removeFromEntities<pokesim::tags::Fainting>();
 
-    simulation.viewForSelectedBattles<clearFaintQueue>();
+    battleFilter.view<clearFaintQueue>();
     iterations++;
   }
 
-  simulation.viewForSelectedBattles<checkWin, Tags<>, entt::exclude_t<Winner>>();
+  battleFilter.view<checkWin, Tags<>, entt::exclude_t<Winner>>();
 
   runAfterFaintEvent(simulation);
 }
@@ -229,7 +248,7 @@ void runCurrentAction(Simulation& simulation) {
   // Switch requests
 
   updateAllStats(simulation);
-  simulation.viewForSelectedBattles<speedSort, Tags<tags::SpeedSortNeeded>>();
+  getBattleFilter(simulation).view<speedSort, Tags<tags::SpeedSortNeeded>>();
   simulation.registry.clear<tags::SpeedSortNeeded>();
 }
 
@@ -242,13 +261,15 @@ void updateActivePokemonPostTurn(types::registry& registry, const pokesim::MoveS
 }
 
 void nextTurn(Simulation& simulation) {
-  simulation.viewForSelectedBattles<incrementTurn>();
+  getBattleFilter(simulation).view<incrementTurn>();
 
-  pokesim::internal::SelectForPokemonView<pokesim::tags::SimulateTurn, pokesim::tags::ActivePokemon> selectedPokemon{
-    simulation};
-  if (!selectedPokemon.hasNoneSelected()) {
-    simulation.viewForSelectedPokemon<updateActivePokemonPostTurn>();
+  pokesim::internal::EntityFilter<pokesim::tags::SimulateTurn, pokesim::tags::ActivePokemon> pokemonFilter{simulation};
+  if (!pokemonFilter.hasNoneSelected()) {
+    pokemonFilter.view<updateActivePokemonPostTurn>();
+
+    pokemonFilter.addToSelected<pokesim::tags::DisableMove>();
     runDisableMove(simulation);
+    simulation.registry.clear<pokesim::tags::DisableMove>();
   }
 }
 
@@ -263,35 +284,33 @@ void simulateTurn(Simulation& simulation) {
     "Rebuild PokeSim with the flag POKESIM_ALL_DAMAGE_ALL_BRANCHES to enable this option combination.");
 #endif
 
+  auto battleFilter = getBattleFilter(simulation);
+  if (battleFilter.hasNoneSelected()) {
+    return;
+  }
+
   if (!options.getApplyChangesToInputBattle()) {
-    simulation.addToEntities<pokesim::tags::CloneFrom, pokesim::tags::Battle, pokesim::tags::SimulateTurn>();
+    simulation.addToEntities<pokesim::tags::CloneFrom, pokesim::tags::SimulateTurn, pokesim::tags::Battle>();
     const auto entityMap = clone(simulation.registry, 1U);
     for (const auto& inputBattleMapping : entityMap) {
       simulation.registry.emplace<tags::Input>(inputBattleMapping.first);
+      simulation.registry.remove<pokesim::tags::SimulateTurn>(inputBattleMapping.first);
     }
   }
 
-  pokesim::internal::SelectForBattleView<pokesim::tags::SimulateTurn> selectedBattles{
-    simulation,
-    entt::exclude<tags::Input>};
-  pokesim::internal::SelectForSideView<pokesim::tags::SimulateTurn> selectedSides{
-    simulation,
-    entt::exclude<tags::Input>};
-  if (selectedBattles.hasNoneSelected() || selectedSides.hasNoneSelected()) return;
-
-  simulation.viewForSelectedBattles<assignRootBattle>();
+  battleFilter.view<assignRootBattle>();
 
   updateAllStats(simulation);
-  simulation.viewForSelectedSides<resolveDecision>();
-  simulation.removeFromEntities<SideDecision, pokesim::tags::SelectedForViewSide>();
+  simulation.view<resolveDecision, Tags<pokesim::tags::SimulateTurn>>();
+  simulation.removeFromEntities<SideDecision, pokesim::tags::SimulateTurn>();
 
-  // simulation.viewForSelectedBattles<addBeforeTurnAction, Tags<>, entt::exclude_t<pokesim::tags::BattleMidTurn>>();
-  simulation.viewForSelectedBattles<speedSort>();
-  simulation.viewForSelectedBattles<addResidualAction, Tags<>, entt::exclude_t<pokesim::tags::BattleMidTurn>>();
+  // battleFilter.view<addBeforeTurnAction, Tags<>, entt::exclude_t<pokesim::tags::BattleMidTurn>>();
+  battleFilter.view<speedSort>();
+  battleFilter.view<addResidualAction, Tags<>, entt::exclude_t<pokesim::tags::BattleMidTurn>>();
 
-  simulation.addToEntities<pokesim::tags::BattleMidTurn, Turn, pokesim::tags::SelectedForViewBattle>();
+  simulation.addToEntities<pokesim::tags::BattleMidTurn, Turn, pokesim::tags::SimulateTurn, pokesim::tags::Battle>();
 
-  simulation.viewForSelectedBattles<setCurrentAction>();
+  battleFilter.view<setCurrentAction>();
   using ActionsLimit = Constants::ActionQueueLength;
   types::actionQueueIndex actionsTaken = ActionsLimit::MIN;
   while (!simulation.registry.view<action::tags::Current>().empty()) {
@@ -300,14 +319,17 @@ void simulateTurn(Simulation& simulation) {
       "More actions in a turn were queued to be taken than in at least one battle than are possible.");
 
     runCurrentAction(simulation);
-    simulation.viewForSelectedBattles<setCurrentAction, Tags<>, entt::exclude_t<Winner>>();
+    battleFilter.view<setCurrentAction, Tags<>, entt::exclude_t<Winner>>();
     actionsTaken++;
   }
 
   nextTurn(simulation);
 
-  simulation.removeFromEntities<pokesim::tags::BattleMidTurn, Turn, pokesim::tags::SelectedForViewBattle>();
-  simulation.viewForSelectedBattles<collectTurnOutcomeBattles>();
+  simulation
+    .removeFromEntities<pokesim::tags::BattleMidTurn, Turn, pokesim::tags::SimulateTurn, pokesim::tags::Battle>();
+  battleFilter.view<collectTurnOutcomeBattles>();
+
+  simulation.addToEntities<pokesim::tags::SimulateTurn, tags::Input>();
   simulation.registry.clear<tags::Input>();
 }
 }  // namespace
diff --git a/src/SimulateTurn/SimulateTurnDebugChecks.hpp b/src/SimulateTurn/SimulateTurnDebugChecks.hpp
index ec7bd60e..f9bcdfd0 100644
--- a/src/SimulateTurn/SimulateTurnDebugChecks.hpp
+++ b/src/SimulateTurn/SimulateTurnDebugChecks.hpp
@@ -8,6 +8,8 @@
 #include <Components/EntityHolders/MoveSlots.hpp>
 #include <Components/EntityHolders/Sides.hpp>
 #include <Components/EntityHolders/Team.hpp>
+#include <Components/Tags/BattleTags.hpp>
+#include <Components/Tags/Current.hpp>
 #include <Components/Tags/SimulationTags.hpp>
 #include <Simulation/Simulation.hpp>
 #include <Types/Registry.hpp>
@@ -38,7 +40,7 @@ struct Checks : pokesim::debug::Checks {
 
  private:
   void check() const {
-    for (types::entity battleEntity : simulation->selectedBattleEntities()) {
+    for (types::entity battleEntity : registry->view<pokesim::tags::Battle, pokesim::tags::SimulateTurn>()) {
       checkBattle(battleEntity);
       for (types::entity sideEntity : registry->get<Sides>(battleEntity).val) {
         checkSide(sideEntity);
diff --git a/src/Simulation/MoveHitSteps.cpp b/src/Simulation/MoveHitSteps.cpp
index 39471a06..0cead7b0 100644
--- a/src/Simulation/MoveHitSteps.cpp
+++ b/src/Simulation/MoveHitSteps.cpp
@@ -21,7 +21,7 @@
 #include <Types/Constants.hpp>
 #include <Types/Enums/BattleFormat.hpp>
 #include <Types/Registry.hpp>
-#include <Utilities/SelectForView.hpp>
+#include <Utilities/EntityFilter.hpp>
 #include <Utilities/Tags.hpp>
 
 #include "RunEvent.hpp"
@@ -45,15 +45,13 @@ void removeHitCountFromFaintedTargets(types::handle moveHandle, CurrentActionTar
 
 template <auto Function>
 void runMoveHitCheck(Simulation& simulation) {
-  simulation.addToEntities<tags::CurrentMoveHit, tags::CurrentActionMove>();
-
-  internal::SelectForCurrentActionMoveView<tags::CurrentMoveHit> selectedMoves{simulation};
-  if (selectedMoves.hasNoneSelected()) {
+  if (simulation.registry.view<tags::CurrentActionMove>().empty()) {
     return;
   }
 
+  simulation.addToEntities<tags::CurrentMoveHit, tags::CurrentActionMove>();
+
   Function(simulation);
-  selectedMoves.deselect();
 
   simulation.view<setFailedActionMove, Tags<tags::FailedCurrentMoveHit>>();
   simulation.registry.clear<tags::CurrentMoveHit, tags::FailedCurrentMoveHit>();
@@ -79,14 +77,14 @@ void setEffectTarget(types::handle handle, TargetEntityHolder target) {
 }
 
 void runMoveEffects(Simulation& simulation) {
-  internal::SelectForCurrentActionMoveView<internal::tags::RunEffect> selectedMoves{simulation};
-  if (selectedMoves.hasNoneSelected()) {
+  internal::EntityFilter<internal::tags::RunEffect> moveFilter{simulation};
+  if (moveFilter.hasNoneSelected()) {
     return;
   }
 
-  simulation.viewForSelectedMoves<setEffectSource>();
-  simulation.viewForSelectedMoves<setEffectTarget<CurrentActionSource>, Tags<move::effect::tags::MoveSource>>();
-  simulation.viewForSelectedMoves<setEffectTarget<CurrentActionTarget>, Tags<move::effect::tags::MoveTarget>>();
+  moveFilter.view<setEffectSource>();
+  moveFilter.view<setEffectTarget<CurrentActionSource>, Tags<move::effect::tags::MoveSource>>();
+  moveFilter.view<setEffectTarget<CurrentActionTarget>, Tags<move::effect::tags::MoveTarget>>();
 
   tryBoost(simulation);
   trySetStatus(simulation);
@@ -125,17 +123,15 @@ void removeFaintedSecondaryEffectTarget(
 // exists that has a random chance to add a side or field affect regardless of the target's HP, then this function will
 // need to be reworked.
 void removeFaintedSecondaryEffectTargets(Simulation& simulation) {
-  internal::SelectForCurrentActionMoveView<move::effect::tags::Secondary> selectedMoves{simulation};
-  if (selectedMoves.hasNoneSelected()) {
+  internal::EntityFilter<move::effect::tags::Secondary> moveFilter{simulation};
+  if (moveFilter.hasNoneSelected()) {
     return;
   }
 
-  simulation.viewForSelectedMoves<
-    removeFaintedSecondaryEffectTarget<CurrentActionSource>,
-    Tags<move::effect::tags::MoveSource>>(simulation.simulateTurnOptions);
-  simulation.viewForSelectedMoves<
-    removeFaintedSecondaryEffectTarget<CurrentActionTarget>,
-    Tags<move::effect::tags::MoveTarget>>(simulation.simulateTurnOptions);
+  moveFilter.view<removeFaintedSecondaryEffectTarget<CurrentActionSource>, Tags<move::effect::tags::MoveSource>>(
+    simulation.simulateTurnOptions);
+  moveFilter.view<removeFaintedSecondaryEffectTarget<CurrentActionTarget>, Tags<move::effect::tags::MoveTarget>>(
+    simulation.simulateTurnOptions);
 }
 
 // TODO(aed3): When adding damage source, change this to accept the move's handle and CurrentActionSource to pass to
@@ -161,7 +157,7 @@ void setMoveHitCount(Simulation& simulation) {
 }
 
 void applyDamage(Simulation& simulation) {
-  simulation.viewForSelectedMoves<applyDamageToTarget>();
+  simulation.view<applyDamageToTarget>();
 
   auto view = simulation.registry.view<tags::CurrentMoveHit>(entt::exclude<Damage, move::tags::Status>);
   simulation.registry.insert<tags::FailedCurrentMoveHit>(view.begin(), view.end());
@@ -206,11 +202,6 @@ void moveHitLoop(Simulation& simulation) {
   while (!simulation.registry.view<HitCount>().empty()) {
     POKESIM_REQUIRE(iterations <= MoveHitLimits::MAX, "More hits were ran more than possible.");
 
-    internal::SelectForCurrentActionMoveView<HitCount> selectedMoves{simulation};
-    POKESIM_REQUIRE(
-      !selectedMoves.hasNoneSelected(),
-      "HitCount should only be present on active moves, meaning this loop should only be entered if there are moves to "
-      "select.");
     calc_damage::run(simulation);  // 1. call to this.battle.getDamage
     runDamageEvent(simulation);
 
diff --git a/src/Simulation/RegistryContainer.hpp b/src/Simulation/RegistryContainer.hpp
deleted file mode 100644
index 72318c32..00000000
--- a/src/Simulation/RegistryContainer.hpp
+++ /dev/null
@@ -1,342 +0,0 @@
-#pragma once
-
-#include <Components/Tags/BattleTags.hpp>
-#include <Components/Tags/Current.hpp>
-#include <Components/Tags/PokemonTags.hpp>
-#include <Components/Tags/Selection.hpp>
-#include <Config/Require.hpp>
-#include <Types/Entity.hpp>
-#include <Types/Registry.hpp>
-#include <Utilities/MaxSizedVector.hpp>
-#include <Utilities/RegistryLoop.hpp>
-#include <Utilities/Tags.hpp>
-#include <cstddef>
-#include <entt/signal/delegate.hpp>
-#include <type_traits>
-#include <vector>
-
-namespace pokesim::internal {
-class RegistryContainer {
- public:
-  using SelectionFunction = entt::delegate<types::entityVector(const types::registry&)>;
-
- private:
-  template <typename, typename, typename...>
-  friend struct SelectForView;
-
-  using SelectionFunctionList = internal::maxSizedVector<SelectionFunction>;
-  SelectionFunctionList battleSelection{};
-  SelectionFunctionList sideSelection{};
-  SelectionFunctionList pokemonSelection{};
-  SelectionFunctionList moveSelection{};
-
-  template <typename Selection>
-  SelectionFunctionList& selectedFunctions() {
-    if constexpr (std::is_same_v<pokesim::tags::SelectedForViewBattle, Selection>) {
-      return battleSelection;
-    }
-    else if constexpr (std::is_same_v<pokesim::tags::SelectedForViewSide, Selection>) {
-      return sideSelection;
-    }
-    else if constexpr (std::is_same_v<pokesim::tags::SelectedForViewPokemon, Selection>) {
-      return pokemonSelection;
-    }
-    else {
-      return moveSelection;
-    }
-  }
-
-  template <typename Selection>
-  const SelectionFunctionList& selectedFunctions() const {
-    if constexpr (std::is_same_v<pokesim::tags::SelectedForViewBattle, Selection>) {
-      return battleSelection;
-    }
-    else if constexpr (std::is_same_v<pokesim::tags::SelectedForViewSide, Selection>) {
-      return sideSelection;
-    }
-    else if constexpr (std::is_same_v<pokesim::tags::SelectedForViewPokemon, Selection>) {
-      return pokemonSelection;
-    }
-    else {
-      return moveSelection;
-    }
-  }
-
-  template <typename Selection, typename GetNewSelection, typename GetUnmatchedSelection>
-  std::size_t select(
-    GetNewSelection getNewSelection, GetUnmatchedSelection getUnmatchedSelection, SelectionFunction selectionFunction,
-    bool isEmptySelection = false) {
-    auto list = getNewSelection(registry);
-    if (list.empty()) {
-      return 0U;
-    }
-
-    bool narrowSelection = hasActiveSelection<Selection>();
-    std::size_t finalSelectionSize = 0U;
-
-    if (narrowSelection && isEmptySelection) {
-      selectedFunctions<Selection>().push_back(selectionFunction);
-      return registry.view<Selection>().size();
-    }
-    if (narrowSelection) {
-      auto unmatchedSelections = getUnmatchedSelection(registry);
-      std::size_t totalSelected = registry.view<Selection>().size();
-      std::size_t unmatchedSelectionSize = unmatchedSelections.size();
-      if (unmatchedSelectionSize == totalSelected) {
-        return 0U;
-      }
-
-      registry.remove<Selection>(unmatchedSelections.begin(), unmatchedSelections.end());
-
-      POKESIM_REQUIRE(
-        unmatchedSelectionSize < totalSelected,
-        "The number of elements removed from the active selection must be less than the number of elements selected.");
-      finalSelectionSize = totalSelected - unmatchedSelectionSize;
-    }
-    else {
-      registry.clear<Selection>();
-      registry.insert<Selection>(list.begin(), list.end());
-      finalSelectionSize = list.size();
-    }
-
-    selectedFunctions<Selection>().push_back(selectionFunction);
-
-    return finalSelectionSize;
-  }
-
-  template <typename Selection, typename Required, typename... ComponentsToSelect, typename... ComponentsToExclude>
-  std::size_t select(entt::exclude_t<ComponentsToExclude...> exclude) {
-    auto getNewSelection = [&exclude](types::registry& reg) {
-      auto view = reg.view<Required, ComponentsToSelect...>(exclude);
-      return types::entityVector{view.begin(), view.end()};
-    };
-    auto getUnmatchedSelection = [](types::registry& reg) {
-      auto view = reg.view<Selection, ComponentsToExclude...>(entt::exclude<ComponentsToSelect...>);
-      return types::entityVector{view.begin(), view.end()};
-    };
-    SelectionFunction selectionFunction{[](const void*, const types::registry& reg) {
-      auto view = reg.view<Required, ComponentsToSelect...>(entt::exclude<ComponentsToExclude...>);
-      return types::entityVector{view.begin(), view.end()};
-    }};
-
-    return select<Selection>(
-      getNewSelection,
-      getUnmatchedSelection,
-      selectionFunction,
-      sizeof...(ComponentsToSelect) == 0U);
-  }
-
-  template <typename Selection>
-  std::size_t select(SelectionFunction selectionFunction) {
-    auto getUnmatchedSelections = [&selectionFunction](const types::registry& reg) -> types::entityVector {
-      auto upcomingSelection = selectionFunction(reg);
-      auto currentSelection = reg.view<Selection>();
-      auto end =
-        std::remove_if(upcomingSelection.begin(), upcomingSelection.end(), [&currentSelection](types::entity entity) {
-          return !currentSelection.contains(entity);
-        });
-      return {upcomingSelection.begin(), end};
-    };
-
-    return select<Selection>(selectionFunction, getUnmatchedSelections, selectionFunction);
-  }
-
-  template <typename Selection>
-  void deselect() {
-    POKESIM_REQUIRE(hasActiveSelection<Selection>(), "Selections must be present to deselect.");
-
-    registry.clear<Selection>();
-    SelectionFunctionList& functions = selectedFunctions<Selection>();
-    functions.pop_back();
-
-    if (functions.empty()) {
-      return;
-    }
-
-    types::entityVector filteredEntityList = functions[0](registry);
-    auto end = filteredEntityList.end();
-    for (std::size_t i = 1U; i < functions.size(); i++) {
-      types::entityVector previouslySelected = functions[i](registry);
-      end = std::remove_if(filteredEntityList.begin(), end, [&previouslySelected](types::entity entity) {
-        return std::find(previouslySelected.begin(), previouslySelected.end(), entity) == previouslySelected.end();
-      });
-    }
-
-    registry.insert<Selection>(filteredEntityList.begin(), end);
-  }
-
- protected:
-  template <typename Selection>
-  bool hasActiveSelection() const {
-    return !selectedFunctions<Selection>().empty();
-  }
-
- private:
-  template <typename Selected, typename Required, auto Function, typename...>
-  struct ForSelected;
-
-  template <
-    typename Selected, typename Required, auto Function, typename ExcludeContainer, typename IncludeContainer,
-    typename... ExtraTags>
-  struct ForSelected<Selected, Required, Function, Tags<ExtraTags...>, ExcludeContainer, IncludeContainer> {
-    template <typename... PassedInArgs>
-    static void view(RegistryContainer* container, const PassedInArgs&... passedInArgs) {
-      if (container->hasActiveSelection<Selected>()) {
-        container->view<Function, Tags<Selected, Required, ExtraTags...>, ExcludeContainer, IncludeContainer>(
-          passedInArgs...);
-      }
-      else {
-        container->view<Function, Tags<Required, ExtraTags...>, ExcludeContainer, IncludeContainer>(passedInArgs...);
-      }
-    }
-
-    template <typename... PassedInArgs>
-    static void group(RegistryContainer* container, const PassedInArgs&... passedInArgs) {
-      if (container->hasActiveSelection<Selected>()) {
-        container->view<Function, Tags<Selected, ExtraTags...>, ExcludeContainer, IncludeContainer>(passedInArgs...);
-      }
-      else {
-        container->group<Function, Tags<ExtraTags...>, ExcludeContainer, IncludeContainer>(passedInArgs...);
-      }
-    }
-  };
-
- public:
-  template <
-    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
-    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
-  void viewForSelectedBattles(const PassedInArgs&... passedInArgs) {
-    ForSelected<
-      pokesim::tags::SelectedForViewBattle,
-      pokesim::tags::Battle,
-      Function,
-      TagContainer,
-      ExcludeContainer,
-      IncludeContainer>::view(this, passedInArgs...);
-  }
-
-  template <
-    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
-    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
-  void groupForSelectedBattles(const PassedInArgs&... passedInArgs) {
-    ForSelected<
-      pokesim::tags::SelectedForViewBattle,
-      pokesim::tags::Battle,
-      Function,
-      TagContainer,
-      ExcludeContainer,
-      IncludeContainer>::group(this, passedInArgs...);
-  }
-
-  template <
-    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
-    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
-  void viewForSelectedSides(const PassedInArgs&... passedInArgs) {
-    ForSelected<
-      pokesim::tags::SelectedForViewSide,
-      pokesim::tags::Side,
-      Function,
-      TagContainer,
-      ExcludeContainer,
-      IncludeContainer>::view(this, passedInArgs...);
-  }
-
-  template <
-    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
-    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
-  void groupForSelectedSides(const PassedInArgs&... passedInArgs) {
-    ForSelected<
-      pokesim::tags::SelectedForViewSide,
-      pokesim::tags::Side,
-      Function,
-      TagContainer,
-      ExcludeContainer,
-      IncludeContainer>::group(this, passedInArgs...);
-  }
-
-  template <
-    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
-    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
-  void viewForSelectedPokemon(const PassedInArgs&... passedInArgs) {
-    ForSelected<
-      pokesim::tags::SelectedForViewPokemon,
-      pokesim::tags::Pokemon,
-      Function,
-      TagContainer,
-      ExcludeContainer,
-      IncludeContainer>::view(this, passedInArgs...);
-  }
-
-  template <
-    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
-    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
-  void groupForSelectedPokemon(const PassedInArgs&... passedInArgs) {
-    ForSelected<
-      pokesim::tags::SelectedForViewPokemon,
-      pokesim::tags::Pokemon,
-      Function,
-      TagContainer,
-      ExcludeContainer,
-      IncludeContainer>::group(this, passedInArgs...);
-  }
-
-  template <
-    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
-    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
-  void viewForSelectedMoves(const PassedInArgs&... passedInArgs) {
-    ForSelected<
-      pokesim::tags::SelectedForViewMove,
-      pokesim::tags::CurrentActionMove,
-      Function,
-      TagContainer,
-      ExcludeContainer,
-      IncludeContainer>::view(this, passedInArgs...);
-  }
-
-  template <
-    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
-    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
-  void groupForSelectedMoves(const PassedInArgs&... passedInArgs) {
-    ForSelected<
-      pokesim::tags::SelectedForViewMove,
-      pokesim::tags::CurrentActionMove,
-      Function,
-      TagContainer,
-      ExcludeContainer,
-      IncludeContainer>::group(this, passedInArgs...);
-  }
-
-  template <
-    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
-    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
-  auto view(const PassedInArgs&... passedInArgs) {
-    return internal::RegistryLoop<Function, TagContainer, ExcludeContainer, IncludeContainer, PassedInArgs...>::view(
-      registry,
-      passedInArgs...);
-  }
-
-  template <
-    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
-    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
-  auto group(const PassedInArgs&... passedInArgs) {
-    return internal::RegistryLoop<Function, TagContainer, ExcludeContainer, IncludeContainer, PassedInArgs...>::group(
-      registry,
-      passedInArgs...);
-  }
-
- public:
-  types::registry registry{};
-
-  template <typename Type, typename... ViewComponents, typename... Args>
-  void addToEntities(const Args&... args) {
-    auto view = registry.view<ViewComponents...>();
-    registry.insert<Type>(view.begin(), view.end(), args...);
-  }
-
-  template <typename Type, typename... ViewComponents, typename... ExcludeComponents>
-  void removeFromEntities(entt::exclude_t<ExcludeComponents...> exclude = entt::exclude_t{}) {
-    auto view = registry.view<Type, ViewComponents...>(exclude);
-    registry.remove<Type>(view.begin(), view.end());
-  }
-};
-}  // namespace pokesim::internal
diff --git a/src/Simulation/RunEvent.cpp b/src/Simulation/RunEvent.cpp
index 71b1fde2..eb45d1a5 100644
--- a/src/Simulation/RunEvent.cpp
+++ b/src/Simulation/RunEvent.cpp
@@ -13,20 +13,19 @@
 #include <Components/EventModifier.hpp>
 #include <Components/Stats.hpp>
 #include <Components/Tags/AbilityTags.hpp>
+#include <Components/Tags/Current.hpp>
 #include <Components/Tags/ItemTags.hpp>
+#include <Components/Tags/PokemonTags.hpp>
+#include <Components/Tags/RunEventTags.hpp>
 #include <Components/Tags/StatusTags.hpp>
 #include <Pokedex/Abilities/headers.hpp>
 #include <Pokedex/Effects/headers.hpp>
 #include <Pokedex/Items/headers.hpp>
 #include <Pokedex/Moves/headers.hpp>
-#include <Simulation/RegistryContainer.hpp>
 #include <Types/Enums/GameMechanics.hpp>
-#include <Utilities/SelectForView.hpp>
 #include <Utilities/Tags.hpp>
-#include <cstddef>
 #include <entt/container/dense_set.hpp>
 #include <entt/entity/registry.hpp>
-#include <type_traits>
 
 #include "Simulation.hpp"
 
@@ -39,37 +38,6 @@ void applyEventModifier(ModifiedComponent& component, EventModifier eventModifie
   component.val = applyChainedModifier(component.val, eventModifier.val);
 }
 
-template <typename... PokemonSpecifiers>
-internal::RegistryContainer::SelectionFunction getMoveEventPokemonSelector() {
-  static const size_t SelectAnyPokemon = sizeof...(PokemonSpecifiers) == 0U;
-  return internal::RegistryContainer::SelectionFunction{
-    [](const void*, const types::registry& registry) -> types::entityVector {
-      entt::dense_set<types::entity> entities;
-      auto selectedMoveView = registry.view<tags::SelectedForViewMove>();
-      auto begin = selectedMoveView.begin();
-      auto end = selectedMoveView.end();
-      if (selectedMoveView.empty()) {
-        auto anyMoveView = registry.view<tags::CurrentActionMove>();
-        begin = anyMoveView.begin();
-        end = anyMoveView.end();
-      }
-
-      std::for_each(begin, end, [&registry, &entities](types::entity entity) {
-        if constexpr (
-          SelectAnyPokemon || std::disjunction_v<std::is_same<PokemonSpecifiers, tags::CurrentActionMoveSource>...>) {
-          entities.insert(registry.get<CurrentActionSource>(entity).val);
-        }
-
-        if constexpr (
-          SelectAnyPokemon || std::disjunction_v<std::is_same<PokemonSpecifiers, tags::CurrentActionMoveTarget>...>) {
-          entities.insert(registry.get<CurrentActionTarget>(entity).val);
-        }
-      });
-
-      return {entities.begin(), entities.end()};
-    }};
-}
-
 void applyBasePowerEventModifier(types::handle moveHandle, BasePower basePower, EventModifier eventModifier) {
   calc_damage::Power& power = moveHandle.emplace<calc_damage::Power>(basePower.val);
   power.val = applyChainedModifier(power.val, eventModifier.val);
@@ -82,32 +50,28 @@ void runBeforeMove(Simulation& simulation) {
 }
 
 void runResidual(Simulation& simulation) {
-  pokesim::internal::SelectForPokemonView<tags::ActivePokemon> selectedPokemon{simulation};
-  if (selectedPokemon.hasNoneSelected()) {
-    return;
-  }
   dex::Burn::onResidual(simulation);
 }
 
 void runAccuracyEvent(Simulation&) {}
 
 void runModifyAccuracyEvent(Simulation& simulation) {
-  simulation.addToEntities<EventModifier, tags::SelectedForViewMove, Accuracy>();
+  simulation.addToEntities<EventModifier, tags::CurrentMoveHit, Accuracy>();
 
   dex::BrightPowder::onModifyAccuracy(simulation);
 
-  simulation.viewForSelectedMoves<applyEventModifier<Accuracy>>();
+  simulation.view<applyEventModifier<Accuracy>>();
   simulation.registry.clear<EventModifier>();
 }
 
 void runModifyCritBoostEvent(Simulation&) {}
 
 void runBasePowerEvent(Simulation& simulation) {
-  simulation.addToEntities<EventModifier, tags::SelectedForViewMove, BasePower>();
+  simulation.addToEntities<EventModifier, tags::CurrentMoveHit, BasePower>();
 
   dex::KnockOff::onBasePower(simulation);
 
-  simulation.viewForSelectedMoves<applyBasePowerEventModifier>();
+  simulation.view<applyBasePowerEventModifier>();
   simulation.registry.clear<EventModifier>();
 }
 
@@ -167,10 +131,6 @@ template void runAfterEachBoostEvent<SpeBoost>(Simulation&);
 void runAfterBoostEvent(Simulation&) {}
 
 void runModifyMove(Simulation& simulation) {
-  // internal::SelectForPokemonView<> selectedPokemon{
-  //   simulation,
-  //   getMoveEventPokemonSelector<tags::CurrentActionMoveSource>()};
-
   dex::ChoiceScarf::onSourceModifyMove(simulation);
   dex::ChoiceSpecs::onSourceModifyMove(simulation);
 }
@@ -184,7 +144,7 @@ void runModifyAtk(Simulation&) {}
 void runModifyDef(Simulation&) {}
 
 void runModifySpa(Simulation& simulation) {
-  simulation.addToEntities<EventModifier, tags::SelectedForViewPokemon>();
+  simulation.addToEntities<EventModifier, tags::SpaStatUpdateRequired>();
 
   // Priority 1
   dex::ChoiceSpecs::onModifySpa(simulation);
@@ -192,25 +152,25 @@ void runModifySpa(Simulation& simulation) {
   // Priority 5
   dex::Plus::onModifySpA(simulation);
 
-  simulation.viewForSelectedPokemon<applyEventModifier<stat::EffectiveSpa>>();
+  simulation.view<applyEventModifier<stat::EffectiveSpa>>();
   simulation.registry.clear<EventModifier>();
 }
 
 void runModifySpd(Simulation& simulation) {
-  simulation.addToEntities<EventModifier, tags::SelectedForViewPokemon>();
+  simulation.addToEntities<EventModifier, tags::SpdStatUpdateRequired>();
 
   dex::AssaultVest::onModifySpd(simulation);
 
-  simulation.viewForSelectedPokemon<applyEventModifier<stat::EffectiveSpd>>();
+  simulation.view<applyEventModifier<stat::EffectiveSpd>>();
   simulation.registry.clear<EventModifier>();
 }
 
 void runModifySpe(Simulation& simulation) {
-  simulation.addToEntities<EventModifier, tags::SelectedForViewPokemon>();
+  simulation.addToEntities<EventModifier, tags::SpeStatUpdateRequired>();
 
   dex::ChoiceScarf::onModifySpe(simulation);
 
-  simulation.viewForSelectedPokemon<applyEventModifier<stat::EffectiveSpe>>();
+  simulation.view<applyEventModifier<stat::EffectiveSpe>>();
   simulation.registry.clear<EventModifier>();
 
   dex::Paralysis::onModifySpe(simulation);
diff --git a/src/Simulation/Simulation.cpp b/src/Simulation/Simulation.cpp
index bae8f82d..ad9b730e 100644
--- a/src/Simulation/Simulation.cpp
+++ b/src/Simulation/Simulation.cpp
@@ -6,6 +6,9 @@
 #include <Components/EntityHolders/Sides.hpp>
 #include <Components/HitCount.hpp>
 #include <Components/SimulationResults.hpp>
+#include <Components/Tags/BattleTags.hpp>
+#include <Components/Tags/Current.hpp>
+#include <Components/Tags/PokemonTags.hpp>
 #include <Pokedex/Pokedex.hpp>
 #include <SimulateTurn/SimulateTurn.hpp>
 
@@ -118,32 +121,17 @@ void Simulation::run() {
   analyzeEffect();
 }
 
-types::entityVector Simulation::selectedBattleEntities() const {
-  if (hasActiveSelection<tags::SelectedForViewBattle>()) {
-    auto view = registry.view<tags::SelectedForViewBattle, tags::Battle>();
-    return {view.begin(), view.end()};
-  }
-
+types::entityVector Simulation::battleEntities() const {
   auto view = registry.view<tags::Battle>();
   return {view.begin(), view.end()};
 }
 
-types::entityVector Simulation::selectedMoveEntities() const {
-  if (hasActiveSelection<tags::SelectedForViewMove>()) {
-    auto view = registry.view<tags::SelectedForViewMove, tags::CurrentActionMove>();
-    return {view.begin(), view.end()};
-  }
-
+types::entityVector Simulation::moveEntities() const {
   auto view = registry.view<tags::CurrentActionMove>();
   return {view.begin(), view.end()};
 }
 
-types::entityVector Simulation::selectedPokemonEntities() const {
-  if (hasActiveSelection<tags::SelectedForViewPokemon>()) {
-    auto view = registry.view<tags::SelectedForViewPokemon, tags::Pokemon>();
-    return {view.begin(), view.end()};
-  }
-
+types::entityVector Simulation::pokemonEntities() const {
   auto view = registry.view<tags::Pokemon>();
   return {view.begin(), view.end()};
 }
diff --git a/src/Simulation/Simulation.hpp b/src/Simulation/Simulation.hpp
index 8178530b..d2bcce15 100644
--- a/src/Simulation/Simulation.hpp
+++ b/src/Simulation/Simulation.hpp
@@ -2,13 +2,14 @@
 
 #include <Components/Tags/SimulationTags.hpp>
 #include <Types/Enums/BattleFormat.hpp>
+#include <Types/Registry.hpp>
 #include <Types/State.hpp>
+#include <Utilities/RegistryLoop.hpp>
 #include <entt/entity/registry.hpp>
 #include <optional>
 #include <utility>
 
 #include "BattleCreationInfo.hpp"
-#include "RegistryContainer.hpp"
 #include "SimulationOptions.hpp"
 
 namespace pokesim {
@@ -36,7 +37,7 @@ struct SimulationSetupChecks;
  * @details Each `Simulation` instance will only simulate for either single or double battles. This class is optimized
  * for running multiple simulations of the same battle, where each battle state has completed the same number of turns.
  */
-class Simulation : public internal::RegistryContainer {
+class Simulation {
  private:
   types::entityVector createInitialMoves(const std::vector<MoveCreationInfo>& moveInfoList);
   PokemonStateSetup createInitialPokemon(const PokemonCreationInfo& pokemonInfo);
@@ -107,9 +108,9 @@ class Simulation : public internal::RegistryContainer {
   void clearCalculateDamageResults();
   void clearAnalyzeEffectResults();
 
-  types::entityVector selectedBattleEntities() const;
-  types::entityVector selectedMoveEntities() const;
-  types::entityVector selectedPokemonEntities() const;
+  types::entityVector battleEntities() const;
+  types::entityVector moveEntities() const;
+  types::entityVector pokemonEntities() const;
 
   template <template <typename> typename RunStruct, typename... RunFunctionArgs>
   static void forEachSimulationTag(RunFunctionArgs&&... args) {
@@ -117,5 +118,37 @@ class Simulation : public internal::RegistryContainer {
     RunStruct<tags::CalculateDamage>::run(std::forward<RunFunctionArgs>(args)...);
     RunStruct<tags::AnalyzeEffect>::run(std::forward<RunFunctionArgs>(args)...);
   }
+
+ public:
+  types::registry registry{};
+
+  template <
+    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
+    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
+  auto view(const PassedInArgs&... passedInArgs) {
+    return internal::RegistryLoop<Function, TagContainer, ExcludeContainer, IncludeContainer, PassedInArgs...>::view(
+      registry,
+      passedInArgs...);
+  }
+
+  template <
+    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
+    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
+  auto group(const PassedInArgs&... passedInArgs) {
+    return internal::RegistryLoop<Function, TagContainer, ExcludeContainer, IncludeContainer, PassedInArgs...>::group(
+      registry,
+      passedInArgs...);
+  }
+  template <typename Type, typename... ViewComponents, typename... Args>
+  void addToEntities(const Args&... args) {
+    auto view = registry.view<ViewComponents...>();
+    registry.insert<Type>(view.begin(), view.end(), args...);
+  }
+
+  template <typename Type, typename... ViewComponents, typename... ExcludeComponents>
+  void removeFromEntities(entt::exclude_t<ExcludeComponents...> exclude = entt::exclude_t{}) {
+    auto view = registry.view<Type, ViewComponents...>(exclude);
+    registry.remove<Type>(view.begin(), view.end());
+  }
 };
 }  // namespace pokesim
diff --git a/src/Simulation/SimulationSetup.cpp b/src/Simulation/SimulationSetup.cpp
index 88ea39aa..19520208 100644
--- a/src/Simulation/SimulationSetup.cpp
+++ b/src/Simulation/SimulationSetup.cpp
@@ -282,10 +282,10 @@ types::sides<SideStateSetup> Simulation::createInitialBattle(
   if (battleInfo.runWithSimulateTurn) {
     battleStateSetup.setProperty<tags::SimulateTurn>();
   }
-  if (battleInfo.runWithCalculateDamage || !battleInfo.damageCalculations.empty()) {
+  if (battleInfo.runWithCalculateDamage) {
     battleStateSetup.setProperty<tags::CalculateDamage>();
   }
-  if (battleInfo.runWithAnalyzeEffect || !battleInfo.effectsToAnalyze.empty()) {
+  if (battleInfo.runWithAnalyzeEffect) {
     battleStateSetup.setProperty<tags::AnalyzeEffect>();
   }
 
diff --git a/src/Simulation/headers.hpp b/src/Simulation/headers.hpp
index 270e0463..2053d4bc 100644
--- a/src/Simulation/headers.hpp
+++ b/src/Simulation/headers.hpp
@@ -5,7 +5,6 @@
 #include "BattleCreationInfo.hpp"
 #include "Formulas.hpp"
 #include "MoveHitSteps.hpp"
-#include "RegistryContainer.hpp"
 #include "RunEvent.hpp"
 #include "Simulation.hpp"
 #include "SimulationOptions.hpp"
diff --git a/src/Types/Constants.hpp b/src/Types/Constants.hpp
index c9332107..f481a080 100644
--- a/src/Types/Constants.hpp
+++ b/src/Types/Constants.hpp
@@ -56,6 +56,14 @@ struct Constants {
     static constexpr std::uint16_t DEFAULT = 1U;
   };
 
+  struct PokemonEffectiveSpeStat {
+    static constexpr std::uint16_t MAX = 65535U;
+    // A Pokemon with a speed stat of 7 or less (i.e. level 1 Shuckle) that is paralyzed with -6 speed boosts can have
+    // no speed.
+    static constexpr std::uint16_t MIN = 0U;
+    static constexpr std::uint16_t DEFAULT = 1U;
+  };
+
   struct PokemonEv {
     static constexpr std::uint8_t MAX = 255U;
     static constexpr std::uint8_t MIN = 0U;
diff --git a/src/Utilities/ArgumentChecks.cpp b/src/Utilities/ArgumentChecks.cpp
index 6b601868..3bdeb307 100644
--- a/src/Utilities/ArgumentChecks.cpp
+++ b/src/Utilities/ArgumentChecks.cpp
@@ -51,12 +51,20 @@ void checkStat(types::stat stat, bool hp = false) {
   }
 }
 
-void checkEffectiveStat(types::stat stat, bool hp = false) {
-  if (hp) {
-    checkBounds<Constants::PokemonHpStat>(stat);
-  }
-  else {
-    checkBounds<Constants::PokemonEffectiveStat>(stat);
+void checkEffectiveStat(types::stat stat, dex::Stat name = dex::Stat::NONE) {
+  switch (name) {
+    case dex::Stat::HP: {
+      checkBounds<Constants::PokemonCurrentHpStat>(stat);
+      break;
+    }
+    case dex::Stat::SPE: {
+      checkBounds<Constants::PokemonEffectiveSpeStat>(stat);
+      break;
+    }
+    default: {
+      checkBounds<Constants::PokemonEffectiveStat>(stat);
+      break;
+    }
   }
 }
 
@@ -1101,32 +1109,32 @@ void check(const stat::Spe& spe) {
 
 template <>
 void check(const stat::CurrentHp& hp) {
-  checkBounds<Constants::PokemonCurrentHpStat>(hp.val);
+  checkEffectiveStat(hp.val, dex::Stat::HP);
 }
 
 template <>
 void check(const stat::EffectiveAtk& atk) {
-  checkEffectiveStat(atk.val);
+  checkEffectiveStat(atk.val, dex::Stat::ATK);
 }
 
 template <>
 void check(const stat::EffectiveDef& def) {
-  checkEffectiveStat(def.val);
+  checkEffectiveStat(def.val, dex::Stat::DEF);
 }
 
 template <>
 void check(const stat::EffectiveSpa& spa) {
-  checkEffectiveStat(spa.val);
+  checkEffectiveStat(spa.val, dex::Stat::SPA);
 }
 
 template <>
 void check(const stat::EffectiveSpd& spd) {
-  checkEffectiveStat(spd.val);
+  checkEffectiveStat(spd.val, dex::Stat::SPD);
 }
 
 template <>
 void check(const stat::EffectiveSpe& spe) {
-  checkEffectiveStat(spe.val);
+  checkEffectiveStat(spe.val, dex::Stat::SPE);
 }
 
 template <>
diff --git a/src/Utilities/EntityFilter.hpp b/src/Utilities/EntityFilter.hpp
new file mode 100644
index 00000000..2a6a66e2
--- /dev/null
+++ b/src/Utilities/EntityFilter.hpp
@@ -0,0 +1,71 @@
+#pragma once
+
+#include <Simulation/Simulation.hpp>
+#include <type_traits>
+
+namespace pokesim::internal {
+template <typename SelectionTag, typename... OtherSelectionTags>
+struct EntityFilter {
+ private:
+  template <auto Function, typename...>
+  struct Filter;
+
+  template <auto Function, typename ExcludeContainer, typename IncludeContainer, typename... ExtraTags>
+  struct Filter<Function, Tags<ExtraTags...>, ExcludeContainer, IncludeContainer> {
+    template <typename... PassedInArgs>
+    static void view(Simulation* simulation, const PassedInArgs&... passedInArgs) {
+      simulation
+        ->view<Function, Tags<SelectionTag, OtherSelectionTags..., ExtraTags...>, ExcludeContainer, IncludeContainer>(
+          passedInArgs...);
+    }
+
+    template <typename... PassedInArgs>
+    static void group(Simulation* simulation, const PassedInArgs&... passedInArgs) {
+      simulation
+        ->group<Function, Tags<SelectionTag, OtherSelectionTags..., ExtraTags...>, ExcludeContainer, IncludeContainer>(
+          passedInArgs...);
+    }
+  };
+
+ public:
+  EntityFilter(Simulation& simulation_) : simulation(&simulation_) {}
+
+  template <
+    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
+    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
+  auto view(const PassedInArgs&... passedInArgs) {
+    Filter<Function, TagContainer, ExcludeContainer, IncludeContainer>::view(simulation, passedInArgs...);
+  }
+
+  template <
+    auto Function, typename TagContainer = Tags<>, typename ExcludeContainer = entt::exclude_t<>,
+    typename IncludeContainer = entt::get_t<>, typename... PassedInArgs>
+  auto group(const PassedInArgs&... passedInArgs) {
+    Filter<Function, TagContainer, ExcludeContainer, IncludeContainer>::group(simulation, passedInArgs...);
+  }
+
+  template <typename... IncludeComponents, typename... ExcludeComponents>
+  void applySelectionTags(entt::exclude_t<ExcludeComponents...> exclude = entt::exclude_t{}) {
+    static_assert(
+      !(sizeof...(ExcludeComponents) == 0U && std::conjunction_v<std::is_empty<IncludeComponents>...>),
+      "If there are no excludes and all included components are tags, use those tags as the SelectionTags directly.");
+    auto view = simulation->registry.view<IncludeComponents...>(exclude);
+    simulation->registry.insert<SelectionTag, OtherSelectionTags...>(view.begin(), view.end());
+  }
+
+  bool hasNoneSelected() {
+    auto view = simulation->registry.view<SelectionTag, OtherSelectionTags...>();
+    return view.begin() == view.end();
+  }
+
+  void clearSelectionTags() { simulation->registry.clear<SelectionTag, OtherSelectionTags...>(); }
+
+  template <typename Type, typename... ViewComponents, typename... Args>
+  void addToSelected(const Args&... args) {
+    simulation->addToEntities<Type, SelectionTag, OtherSelectionTags..., ViewComponents...>(args...);
+  }
+
+ private:
+  Simulation* simulation = nullptr;
+};
+}  // namespace pokesim::internal
diff --git a/src/Utilities/SelectForView.hpp b/src/Utilities/SelectForView.hpp
deleted file mode 100644
index 8909c2c7..00000000
--- a/src/Utilities/SelectForView.hpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#pragma once
-
-#include <Components/Tags/BattleTags.hpp>
-#include <Components/Tags/Current.hpp>
-#include <Components/Tags/PokemonTags.hpp>
-#include <Components/Tags/Selection.hpp>
-#include <Simulation/RegistryContainer.hpp>
-#include <Types/Entity.hpp>
-#include <cstddef>
-#include <entt/container/dense_set.hpp>
-
-namespace pokesim::internal {
-template <typename Selection, typename Required, typename... ComponentsToSelect>
-struct SelectForView {
-  template <typename... ComponentsToExclude>
-  SelectForView(
-    RegistryContainer& registryContainer_,
-    entt::exclude_t<ComponentsToExclude...> exclude = entt::exclude<ComponentsToExclude...>)
-      : registryContainer(&registryContainer_),
-        constantSelectedCount(registryContainer->select<Selection, Required, ComponentsToSelect...>(exclude)) {
-    if (hasNoneSelected()) {
-      registryContainer = nullptr;
-    }
-  }
-
-  SelectForView(RegistryContainer& registryContainer_, RegistryContainer::SelectionFunction selectionFunction)
-      : registryContainer(&registryContainer_),
-        constantSelectedCount(registryContainer->select<Selection>(selectionFunction)) {
-    if (hasNoneSelected()) {
-      registryContainer = nullptr;
-    }
-  }
-
-  ~SelectForView() { deselect(); }
-
-  void deselect() {
-    if (registryContainer) {
-      registryContainer->deselect<Selection>();
-      registryContainer = nullptr;
-    }
-  }
-
-  bool hasNoneSelected() const { return constantSelectedCount == 0U; }
-
- private:
-  RegistryContainer* registryContainer = nullptr;
-  std::size_t constantSelectedCount = 0U;
-};
-
-template <typename... ComponentsToSelect>
-using SelectForBattleView =
-  SelectForView<pokesim::tags::SelectedForViewBattle, pokesim::tags::Battle, ComponentsToSelect...>;
-template <typename... ComponentsToSelect>
-using SelectForSideView = SelectForView<pokesim::tags::SelectedForViewSide, pokesim::tags::Side, ComponentsToSelect...>;
-template <typename... ComponentsToSelect>
-using SelectForPokemonView =
-  SelectForView<pokesim::tags::SelectedForViewPokemon, pokesim::tags::Pokemon, ComponentsToSelect...>;
-template <typename... ComponentsToSelect>
-using SelectForCurrentActionMoveView =
-  SelectForView<pokesim::tags::SelectedForViewMove, pokesim::tags::CurrentActionMove, ComponentsToSelect...>;
-}  // namespace pokesim::internal
diff --git a/src/Utilities/headers.hpp b/src/Utilities/headers.hpp
index 2feb89e0..062b5688 100644
--- a/src/Utilities/headers.hpp
+++ b/src/Utilities/headers.hpp
@@ -5,11 +5,11 @@
 #include "ArgumentChecks.hpp"
 #include "AssertComponentsEqual.hpp"
 #include "DebugChecks.hpp"
+#include "EntityFilter.hpp"
 #include "FixedMemoryVector.hpp"
 #include "MaxSizedVector.hpp"
 #include "NumberToType.hpp"
 #include "RNG.hpp"
 #include "RegistryLoop.hpp"
-#include "SelectForView.hpp"
 #include "Tags.hpp"
 #include "Variant.hpp"
diff --git a/tests/CalcDamageTest.cpp b/tests/CalcDamageTest.cpp
index 29a291a2..630e19b6 100644
--- a/tests/CalcDamageTest.cpp
+++ b/tests/CalcDamageTest.cpp
@@ -41,31 +41,52 @@ TEST_CASE("Calculate Damage: Vertical Slice 1", "[Simulation][CalculateDamage]")
   static Pokedex pokedex{GameMechanics::SCARLET_VIOLET};
   BattleCreationInfo battleCreationInfo;
   battleCreationInfo.runWithCalculateDamage = true;
-  Simulation simulation = createSingleBattleSimulation(pokedex, battleCreationInfo);
-
-  auto& p2Info = battleCreationInfo.sides.p2().team[0];
-  p2Info.nature = dex::Nature::MODEST;
-
-  bool useSpecsInsteadOfBoost = GENERATE(false, true);
-  if (useSpecsInsteadOfBoost) {
-    p2Info.item = dex::Item::CHOICE_SPECS;
-    p2Info.currentBoosts.spa = (types::boost)0U;
-  }
-  else {
-    p2Info.item = dex::Item::NO_ITEM;
-    p2Info.currentBoosts.spa = (types::boost)1U;
-  }
-
   battleCreationInfo.damageCalculations = {
     {Slot::P1A, Slot::P2A, {dex::Move::FURY_ATTACK}},
     {Slot::P2A, Slot::P1A, {dex::Move::THUNDERBOLT}},
   };
 
+  Simulation simulation = createSingleBattleSimulation(pokedex, battleCreationInfo);
+  std::vector<BattleCreationInfo> battleInfoList{8, battleCreationInfo};
+
+  for (std::size_t i = 0; i < battleInfoList.size(); i++) {
+    auto& p1Info = battleInfoList[i].sides.p1().team[0];
+    auto& p2Info = battleInfoList[i].sides.p2().team[0];
+
+    if (i & 1U) {
+      p1Info.item = dex::Item::ASSAULT_VEST;
+    }
+    else {
+      p1Info.item = std::nullopt;
+    }
+
+    if (i & 2U) {
+      p1Info.currentBoosts.spd = std::nullopt;
+    }
+    else {
+      p1Info.currentBoosts.spd = (types::boost)1U;
+    }
+
+    p2Info.nature = dex::Nature::MODEST;
+    if (i & 4U) {
+      p2Info.item = dex::Item::CHOICE_SPECS;
+      p2Info.currentBoosts.spa = std::nullopt;
+    }
+    else {
+      p2Info.item = std::nullopt;
+      p2Info.currentBoosts.spa = (types::boost)1U;
+    }
+  }
+
   const IdealDamageValues furyAttackBaseDamage(
     {13U, 12U, 12U, 12U, 12U, 12U, 12U, 12U, 11U, 11U, 11U, 11U, 11U, 11U, 11U, 11U},
     {{{23U, 1U}, {25U, 7U}, {27U, 8U}}},
     12U);
   const IdealDamageValues thunderboltBaseDamage(
+    {420U, 414U, 410U, 404U, 402U, 398U, 392U, 390U, 384U, 380U, 378U, 372U, 368U, 362U, 360U, 356U},
+    {{{1U, 16U}}},
+    388U);
+  const IdealDamageValues thunderboltAVDamage(
     {282U, 278U, 276U, 272U, 270U, 266U, 264U, 260U, 258U, 254U, 252U, 248U, 246U, 242U, 240U, 236U},
     {{{1U, 3U}, {2U, 13U}}},
     260U);
@@ -75,24 +96,33 @@ TEST_CASE("Calculate Damage: Vertical Slice 1", "[Simulation][CalculateDamage]")
     {{{16U, 1U}, {17U, 5U}, {18U, 5U}, {19U, 5U}}},
     17U);
   const IdealDamageValues thunderboltCritDamage(
+    {630U, 620U, 614U, 608U, 602U, 596U, 590U, 584U, 578U, 572U, 566U, 558U, 552U, 546U, 540U, 534U},
+    {{{1U, 16U}}},
+    582U);
+  const IdealDamageValues thunderboltCritAVDamage(
     {422U, 416U, 414U, 408U, 404U, 398U, 396U, 392U, 386U, 384U, 378U, 374U, 372U, 366U, 362U, 356U},
     {{{1U, 16U}}},
     390U);
 
+  const IdealDamageValues thunderboltSpdBoostAVDamage(
+    {188U, 186U, 182U, 182U, 180U, 176U, 176U, 174U, 170U, 170U, 168U, 168U, 164U, 162U, 162U, 158U},
+    {{{2U, 16U}}},
+    173U);
+
   DamageRollOptions damageRollOptions;
   bool getKoUses = GENERATE(false, true);
   bool calculateUpToFoeHp = GENERATE(false, true);
   damageRollOptions.setP1(GENERATE(from_range(damageRollKindCombinations)));
   damageRollOptions.setP2(GENERATE(from_range(damageRollKindCombinations)));
 
-  CAPTURE(useSpecsInsteadOfBoost, getKoUses, calculateUpToFoeHp, damageRollOptions.getP1(), damageRollOptions.getP2());
+  CAPTURE(getKoUses, calculateUpToFoeHp);
 
   auto& options = simulation.calculateDamageOptions;
   options.setCalculateUpToFoeHp(calculateUpToFoeHp);
   options.setNoKoChanceCalculation(!getKoUses);
   options.setDamageRollOptions(damageRollOptions);
 
-  simulation.createInitialStates({battleCreationInfo});
+  simulation.createInitialStates(battleInfoList);
   auto result = simulation.calculateDamage();
 
   const auto damageRolls = result.damageRollResults();
@@ -100,7 +130,7 @@ TEST_CASE("Calculate Damage: Vertical Slice 1", "[Simulation][CalculateDamage]")
   const auto hpRecovered = result.hpRecoveredResults();
   const auto koUses = result.usesUntilKoResults();
 
-  REQUIRE(damageRolls.size() == 2U);
+  REQUIRE(damageRolls.size() == battleInfoList.size() * 2U);
   REQUIRE(hpLost.empty());
   REQUIRE(hpRecovered.empty());
 
@@ -108,17 +138,21 @@ TEST_CASE("Calculate Damage: Vertical Slice 1", "[Simulation][CalculateDamage]")
     REQUIRE(koUses.empty());
   }
   else {
-    types::damageRollIndex idealKoUsesSize = 0U;
+    std::size_t idealKoUsesSize = 0U;
     if (damageRollOptions.getP1() & DamageRollKind::ALL_DAMAGE_ROLLS) {
-      idealKoUsesSize++;
+      idealKoUsesSize += battleInfoList.size();
     }
     if (damageRollOptions.getP2() & DamageRollKind::ALL_DAMAGE_ROLLS) {
-      idealKoUsesSize++;
+      idealKoUsesSize += battleInfoList.size();
     }
     REQUIRE(koUses.size() == idealKoUsesSize);
   }
 
-  auto pickIdealDamageValues = [&](dex::Move move, DamageRollKind damageRollKind) -> const IdealDamageValues& {
+  auto pickIdealDamageValues = [&](
+                                 dex::Move move,
+                                 DamageRollKind damageRollKind,
+                                 bool targetHasAssaultVest,
+                                 bool targetHasSpdBoost) -> const IdealDamageValues& {
     REQUIRE((move == dex::Move::FURY_ATTACK || move == dex::Move::THUNDERBOLT));
     bool isCrit = damageRollKind & DamageRollKind::GUARANTEED_CRIT_CHANCE;
 
@@ -126,19 +160,34 @@ TEST_CASE("Calculate Damage: Vertical Slice 1", "[Simulation][CalculateDamage]")
       return isCrit ? furyAttackCritDamage : furyAttackBaseDamage;
     }
 
-    return isCrit ? thunderboltCritDamage : thunderboltBaseDamage;
+    if (isCrit) {
+      return targetHasAssaultVest ? thunderboltCritAVDamage : thunderboltCritDamage;
+    }
+    if (targetHasSpdBoost) {
+      return targetHasAssaultVest ? thunderboltSpdBoostAVDamage : thunderboltAVDamage;
+    }
+    return targetHasAssaultVest ? thunderboltAVDamage : thunderboltBaseDamage;
   };
 
   const types::registry& registry = simulation.registry;
   damageRolls.each([&](types::entity entity, const DamageRolls& trueDamageRolls) {
+    types::entity source = registry.get<CurrentActionSource>(entity).val;
     types::entity target = registry.get<CurrentActionTarget>(entity).val;
     types::stat targetHp = registry.get<stat::CurrentHp>(target).val;
+    dex::Move move = registry.get<MoveName>(entity).val;
 
     PlayerSideId sideId = registry.get<PlayerSide>(registry.get<Side>(target).val).val;
     DamageRollKind damageRollKind = sideId == PlayerSideId::P1 ? damageRollOptions.getP1() : damageRollOptions.getP2();
 
-    dex::Move move = registry.get<MoveName>(entity).val;
-    const IdealDamageValues& idealDamageValues = pickIdealDamageValues(move, damageRollKind);
+    bool sourceHasChoiceSpecs = registry.all_of<item::tags::ChoiceSpecs>(source);
+    bool sourceHasSpaBoost = registry.all_of<SpaBoost>(source);
+    bool targetHasAssaultVest = registry.all_of<item::tags::AssaultVest>(target);
+    bool targetHasSpdBoost = registry.all_of<SpdBoost>(target);
+
+    CAPTURE(move, damageRollKind, sourceHasChoiceSpecs, sourceHasSpaBoost, targetHasAssaultVest, targetHasSpdBoost);
+
+    const IdealDamageValues& idealDamageValues =
+      pickIdealDamageValues(move, damageRollKind, targetHasAssaultVest, targetHasSpdBoost);
 
     if (damageRollKind & DamageRollKind::ALL_DAMAGE_ROLLS) {
       REQUIRE(trueDamageRolls.val.size() == idealDamageValues.rolls.val.size());
@@ -157,7 +206,7 @@ TEST_CASE("Calculate Damage: Vertical Slice 1", "[Simulation][CalculateDamage]")
 
         REQUIRE(trueKosUses.minUses() == idealKoUses.val[0]);
         REQUIRE(trueKosUses.maxUses() == idealKoUses.val.back());
-        REQUIRE(trueKosUses.guaranteedKo() == (idealKoUses.val.size() == 1U));
+        REQUIRE(trueKosUses.guaranteedKo() == (idealKoUses.val.size() == 1U && idealKoUses.val[0].hits == 1U));
 
         REQUIRE(trueKosUses.val.size() == idealKoUses.val.size());
         for (types::damageRollIndex i = 0U; i < trueKosUses.val.size(); i++) {
diff --git a/tests/RegistryContainerTests.cpp b/tests/RegistryContainerTests.cpp
deleted file mode 100644
index 2abee66c..00000000
--- a/tests/RegistryContainerTests.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-#include "Tests.hpp"
-
-namespace pokesim {
-struct FilterA {};
-struct FilterB {};
-struct FilterC {};
-struct Select {};
-struct Required {};
-
-template <typename... Components>
-using SelectForTest = internal::SelectForView<Select, Required, Components...>;
-
-TEST_CASE("Selection Levels", "[RegistryContainer]") {
-  internal::RegistryContainer container;
-
-  types::entity filtersABC = container.registry.create();
-  types::entity filtersAB = container.registry.create();
-  types::entity filterA = container.registry.create();
-  container.registry.emplace<Required>(filtersABC);
-  container.registry.emplace<Required>(filtersAB);
-  container.registry.emplace<Required>(filterA);
-
-  container.registry.emplace<FilterA>(filtersABC);
-  container.registry.emplace<FilterA>(filtersAB);
-  container.registry.emplace<FilterA>(filterA);
-
-  container.registry.emplace<FilterB>(filtersABC);
-  container.registry.emplace<FilterB>(filtersAB);
-
-  container.registry.emplace<FilterC>(filtersABC);
-
-  SECTION("Largest To Smallest") {
-    SelectForTest<FilterA> stageOne{container};
-    REQUIRE_FALSE(stageOne.hasNoneSelected());
-    REQUIRE(container.registry.view<Select>().size() == 3U);
-
-    SelectForTest<FilterB> stageTwo{container};
-    REQUIRE_FALSE(stageTwo.hasNoneSelected());
-    REQUIRE(container.registry.view<Select>().size() == 2U);
-
-    SelectForTest<FilterC> stageThree{container};
-    REQUIRE_FALSE(stageThree.hasNoneSelected());
-    REQUIRE(container.registry.view<Select>().size() == 1U);
-
-    stageThree.deselect();
-    REQUIRE(container.registry.view<Select>().size() == 2U);
-
-    stageTwo.deselect();
-    REQUIRE(container.registry.view<Select>().size() == 3U);
-
-    stageOne.deselect();
-    REQUIRE(container.registry.view<Select>().empty());
-  }
-
-  SECTION("Smallest to Largest") {
-    SelectForTest<FilterC> stageOne{container};
-    REQUIRE_FALSE(stageOne.hasNoneSelected());
-    REQUIRE(container.registry.view<Select>().size() == 1U);
-
-    SelectForTest<FilterB> stageTwo{container};
-    REQUIRE_FALSE(stageTwo.hasNoneSelected());
-    REQUIRE(container.registry.view<Select>().size() == 1U);
-
-    SelectForTest<FilterA> stageThree{container};
-    REQUIRE_FALSE(stageThree.hasNoneSelected());
-    REQUIRE(container.registry.view<Select>().size() == 1U);
-
-    stageThree.deselect();
-    REQUIRE(container.registry.view<Select>().size() == 1U);
-
-    stageTwo.deselect();
-    REQUIRE(container.registry.view<Select>().size() == 1U);
-
-    stageOne.deselect();
-    REQUIRE(container.registry.view<Select>().empty());
-  }
-
-  SECTION("Blank Selection") {
-    SelectForTest<> stageZero{container};
-    REQUIRE_FALSE(stageZero.hasNoneSelected());
-    REQUIRE(container.registry.view<Select>().size() == 3U);
-
-    stageZero.deselect();
-
-    SelectForTest<FilterB> stageOne{container};
-    REQUIRE_FALSE(stageOne.hasNoneSelected());
-    REQUIRE(container.registry.view<Select>().size() == 2U);
-
-    SelectForTest<> stageTwo{container};
-    REQUIRE_FALSE(stageTwo.hasNoneSelected());
-    REQUIRE(container.registry.view<Select>().size() == 2U);
-
-    stageTwo.deselect();
-
-    REQUIRE(container.registry.view<Select>().size() == 2U);
-  }
-}
-}  // namespace pokesim
\ No newline at end of file
diff --git a/tests/SimulationSetupTest.cpp b/tests/SimulationSetupTest.cpp
index c3050d4e..7c20d587 100644
--- a/tests/SimulationSetupTest.cpp
+++ b/tests/SimulationSetupTest.cpp
@@ -223,6 +223,7 @@ TEST_CASE("Simulation Setup: Calc Damage", "[Simulation][CalculateDamage][Setup]
   Pokedex pokedex{GameMechanics::SCARLET_VIOLET};
   BattleCreationInfo battleInfo = createBaseBattleInfo(pokedex);
 
+  battleInfo.runWithCalculateDamage = true;
   battleInfo.damageCalculations = {
     {
       Slot::P1A,
@@ -258,14 +259,21 @@ TEST_CASE("Simulation Setup: Calc Damage", "[Simulation][CalculateDamage][Setup]
   auto battles = registry.view<Sides>();
   REQUIRE(battles.size() == 1U);
 
-  auto view = registry.view<tags::CalculateDamage>();
-  REQUIRE(view.size() == 7U);
+  std::size_t calcDamageTagCount = registry.view<tags::CalculateDamage>().size();
+  std::size_t idealCalcDamageTagCount = 1U +  // Battle
+                                        2U +  // Sides
+                                        6U +  // Pokemon
+                                        6U +  // Moves
+                                        6U;   // Damage calculation move inputs
+
+  REQUIRE(calcDamageTagCount == idealCalcDamageTagCount);
 }
 
 TEST_CASE("Simulation Setup: Analyze Effect", "[Simulation][AnalyzeEffect][Setup]") {
   Pokedex pokedex{GameMechanics::SCARLET_VIOLET};
   BattleCreationInfo battleInfo = createBaseBattleInfo(pokedex);
 
+  battleInfo.runWithAnalyzeEffect = true;
   battleInfo.effectsToAnalyze = {
     {Slot::P1A, Slot::P1B, Slot::P1A, {dex::Move::FURY_ATTACK, dex::Move::KNOCK_OFF}, dex::Status::BRN},
     {Slot::P1B, Slot::P1A, Slot::P1A, {dex::Move::FURY_ATTACK}, std::nullopt, {{dex::Stat::DEF, 2}}},
@@ -290,6 +298,13 @@ TEST_CASE("Simulation Setup: Analyze Effect", "[Simulation][AnalyzeEffect][Setup
 
   auto view = registry.view<analyze_effect::tags::Input>();
   REQUIRE(view.size() == 6U);
+
+  std::size_t analyzeEffectTagCount = registry.view<tags::AnalyzeEffect>().size();
+  std::size_t idealAnalyzeEffectTagCount = 1U +  // Battle
+                                           2U +  // Sides
+                                           6U +  // Pokemon
+                                           6U;   // Moves
+  REQUIRE(analyzeEffectTagCount == idealAnalyzeEffectTagCount);
 }
 
 TEST_CASE("Simulation Setup: Ignored Pokemon Options", "[Simulation][Setup]") {
diff --git a/tests/Tests.hpp b/tests/Tests.hpp
index 31b4c3bb..96c9e601 100644
--- a/tests/Tests.hpp
+++ b/tests/Tests.hpp
@@ -239,19 +239,19 @@ struct StringMaker<pokesim::DamageRollKind> {
 
   static std::string convert(const pokesim::DamageRollKind& value) {
     std::string fullName;
-    if ((int)value & (int)pokesim::DamageRollKind::AVERAGE_DAMAGE) {
+    if (value & pokesim::DamageRollKind::AVERAGE_DAMAGE) {
       append(fullName, "AVERAGE_DAMAGE");
     }
-    if ((int)value & (int)pokesim::DamageRollKind::MIN_DAMAGE) {
+    if (value & pokesim::DamageRollKind::MIN_DAMAGE) {
       append(fullName, "MIN_DAMAGE");
     }
-    if ((int)value & (int)pokesim::DamageRollKind::MAX_DAMAGE) {
+    if (value & pokesim::DamageRollKind::MAX_DAMAGE) {
       append(fullName, "MAX_DAMAGE");
     }
-    if ((int)value & (int)pokesim::DamageRollKind::GUARANTEED_CRIT_CHANCE) {
+    if (value & pokesim::DamageRollKind::GUARANTEED_CRIT_CHANCE) {
       append(fullName, "GUARANTEED_CRIT_CHANCE");
     }
-    if ((int)value & (int)pokesim::DamageRollKind::ALL_DAMAGE_ROLLS) {
+    if (value & pokesim::DamageRollKind::ALL_DAMAGE_ROLLS) {
       append(fullName, "ALL_DAMAGE_ROLLS");
     }
 
diff --git a/tests/VerticalSlices.cpp b/tests/VerticalSlices.cpp
index 9a3ebabc..3829f3f4 100644
--- a/tests/VerticalSlices.cpp
+++ b/tests/VerticalSlices.cpp
@@ -462,7 +462,7 @@ TEST_CASE(
 
   simulation.createInitialStates(battleCreationInfoList);
   updateAllStats(simulation);
-  const auto originalBattles = simulation.selectedBattleEntities();
+  const auto originalBattles = simulation.battleEntities();
 
   const types::registry& registry = simulation.registry;
 
@@ -810,7 +810,7 @@ TEST_CASE(
   simulation.createInitialStates(battleCreationInfoList);
   updateAllStats(simulation);
 
-  const auto originalBattles = simulation.selectedBattleEntities();
+  const auto originalBattles = simulation.battleEntities();
   const types::registry& registry = simulation.registry;
 
   types::entityVector specificallyCheckedEntities;
diff --git a/tools/updateBenchmarkResultsFile.js b/tools/updateBenchmarkResultsFile.js
index 0995baba..56d4413a 100644
--- a/tools/updateBenchmarkResultsFile.js
+++ b/tools/updateBenchmarkResultsFile.js
@@ -1,8 +1,10 @@
 const fs = require('fs');
 const os = require('os');
+const util = require('util');
 const {execSync, exec} = require('child_process');
 const {getFullPath} = require('./utils.js');
 
+console.time('Total Time');
 const currentOsType = os.type();
 const currentCpus = os.cpus();
 const currentMemory = Math.floor(os.totalmem() / 1e6);
@@ -86,8 +88,10 @@ const parseExistingBenchmarkFile = () => {
 };
 
 const buildBenchmarks = () => {
+  console.time('Build Time');
   execSync('cmake --preset benchmark-release', {cwd: getFullPath(), stdio: 'inherit'});
   execSync('cmake --build --preset benchmark-release', {cwd: getFullPath(), stdio: 'inherit'});
+  console.timeEnd('Build Time');
 };
 
 const previousTest = parseExistingBenchmarkFile();
@@ -100,10 +104,13 @@ let newFile = `# Benchmarks
 # Results
 `;
 
+console.time('Benchmark Time');
 const benchmarkProcess = exec('./build/bin/release/PokeSimBenchmarks', {cwd: getFullPath()}, (error) => {
+  console.timeEnd('Benchmark Time');
   if (!error) {
     fs.writeFileSync(benchmarkFilePath, newFile);
   }
+  console.timeEnd('Total Time');
 });
 
 const current = {
@@ -129,23 +136,42 @@ benchmarkProcess.stdout.on('data', (chunk) => {
       const newInfo = newInfoPerLine[i];
       const previousInfo = previousTest?.[newInfo?.test]?.[newInfo?.Inputs];
       if (newInfo?.['Mean / Input Count'] && previousInfo?.['Mean / Input Count']) {
-        let diff = newInfo?.['Mean / Input Count'] - previousInfo?.['Mean / Input Count'];
+        const diff = newInfo['Mean / Input Count'] - previousInfo['Mean / Input Count'];
+        const percentDiff = Math.abs(diff / previousInfo['Mean / Input Count']);
+        let valueDiff = diff;
+
         let unit = 'ns';
-        if (diff >= 1e6) {
-          diff /= 1e6;
+        if (Math.abs(valueDiff) >= 1e6) {
+          valueDiff /= 1e6;
           unit = 'ms';
         }
-        else if (diff >= 1e3) {
-          diff /= 1e3;
+        else if (Math.abs(valueDiff) >= 1e3) {
+          valueDiff /= 1e3;
           unit = 'us';
         }
 
-        diff = diff.toFixed(6);
-        if (diff > 0) {
-          diff = '+' + diff;
+        valueDiff = valueDiff.toFixed(3);
+        let timesDiff = '';
+        let color = '';
+        let suffix = '';
+        if (valueDiff > 0) {
+          valueDiff = '+' + valueDiff;
+          timesDiff = (1 / percentDiff).toFixed(3);
+          suffix = '% slower';
+          color = 'red';
+        }
+        else {
+          timesDiff = (1 / (1 - percentDiff)).toFixed(3);
+          suffix = '% faster';
+          color = 'green';
+        }
+
+        if (percentDiff <= 0.05) {
+          color = 'reset';
         }
 
-        process.stdout.write('    ' + diff + unit);
+        process.stdout.write(
+          util.styleText(color, (100 * percentDiff).toFixed(3).padStart(10) + suffix + ', ' + valueDiff + unit));
       }
       process.stdout.write('\n');
     }