Expermental Feature Pull (WIP)

BattleNetwork/battlescene/States/bnCardSelectBattleState.cpp

@@ -212,7 +212,8 @@ void CardSelectBattleState::onUpdate(double elapsed)
             }
             else {
               // Send off the remaining hands to any scene implementations that need it
-              scene.OnSelectNewCards(player, ui->GetRemainingCards());
+              std::vector<Battle::Card> cards = ui->GetRemainingCards();
+              scene.OnSelectNewCards(player, cards);
             }
           }
 

BattleNetwork/battlescene/States/bnTimeFreezeBattleState.cpp

@@ -64,6 +64,10 @@ void TimeFreezeBattleState::ProcessInputs()
   for (std::shared_ptr<Player>& p : this->GetScene().GetAllPlayers()) {
     p->InputState().Process();
 
+    if (summonTick < tfcStartFrame) {
+      continue;
+    }
+
     if (p->InputState().Has(InputEvents::pressed_use_chip)) {
       Logger::Logf(LogLevel::info, "InputEvents::pressed_use_chip for player %i", player_idx);
       std::shared_ptr<PlayerSelectedCardsUI> cardsUI = p->GetFirstComponent<PlayerSelectedCardsUI>();
@@ -81,8 +85,6 @@ void TimeFreezeBattleState::ProcessInputs()
             }
           }
         }
-
-        p->GetChargeComponent().SetCharging(false);
       }
     }
     player_idx++;
@@ -196,6 +198,7 @@ void TimeFreezeBattleState::onUpdate(double elapsed)
       }
       else{
         first->user->Reveal();
+        first->action->EndAction();
         scene.UntrackMobCharacter(first->stuntDouble);
         scene.GetField()->DeallocEntity(first->stuntDouble->GetID());
 
@@ -216,6 +219,11 @@ void TimeFreezeBattleState::onUpdate(double elapsed)
     }
     break;
   }
+
+  for (std::shared_ptr<Player>& player : GetScene().GetAllPlayers()) {
+    ChargeEffectSceneNode& chargeNode = player->GetChargeComponent();
+    chargeNode.Animate(elapsed);
+  }
 }
 
 void TimeFreezeBattleState::onDraw(sf::RenderTexture& surface)
@@ -228,15 +236,24 @@ void TimeFreezeBattleState::onDraw(sf::RenderTexture& surface)
   BattleSceneBase& scene = GetScene();
   const auto& first = tfEvents.begin();
 
-  double tfcTimerScale = swoosh::ease::linear(summonTick.asSeconds().value, summonTextLength.asSeconds().value, 1.0);
+  double tfcTimerScale = 0;
+
+  double summonTickSeconds = summonTick.asSeconds().value;
+  double fadeSeconds = fadeInOutLength.asSeconds().value;
+
+
+  if (summonTickSeconds > fadeSeconds) {
+    tfcTimerScale = swoosh::ease::linear((summonTickSeconds - fadeSeconds), (double)(summonTextLength.asSeconds().value - fadeSeconds), 1.0);
+  }
+
   double scale = swoosh::ease::linear(summonTick.asSeconds().value, fadeInOutLength.asSeconds().value, 1.0);
   scale = std::min(scale, 1.0);
 
   bar = sf::RectangleShape({ 100.f * static_cast<float>(1.0 - tfcTimerScale), 2.f });
   bar.setScale(2.f, 2.f);
 
-  if (summonTick >= summonTextLength - fadeInOutLength) {
-    scale = swoosh::ease::linear((summonTextLength - summonTick).asSeconds().value, fadeInOutLength.asSeconds().value, 1.0);
+  if (summonTick >= summonTextLength) {
+    scale = swoosh::ease::linear((summonTextLength - summonTick).asSeconds().value, fadeSeconds, 1.0);
     scale = std::max(scale, 0.0);
   }
 
@@ -267,7 +284,7 @@ void TimeFreezeBattleState::onDraw(sf::RenderTexture& surface)
   summonsLabel.setPosition(position);
   scene.DrawWithPerspective(summonsLabel, surface);
 
-  if (currState == state::display_name) {
+  if (currState == state::display_name && first->action->GetMetaData().counterable) {
     // draw TF bar underneath
     bar.setPosition(position + sf::Vector2f(0.f + 2.f, 12.f + 2.f));
     bar.setFillColor(sf::Color::Black);
@@ -276,6 +293,7 @@ void TimeFreezeBattleState::onDraw(sf::RenderTexture& surface)
     bar.setPosition(position + sf::Vector2f(0.f, 12.f));
 
     sf::Uint8 b = (sf::Uint8)swoosh::ease::interpolate((1.0-tfcTimerScale), 0.0, 255.0);
+
     bar.setFillColor(sf::Color(255, 255, b));
     scene.DrawWithPerspective(bar, surface);
   }
@@ -416,21 +434,26 @@ const bool TimeFreezeBattleState::CanCounter(std::shared_ptr<Character> user)
   // tfc window ended
   if (summonTick > summonTextLength) return false;
 
-  bool addEvent = true;
+  // bool addEvent = true;
 
   if (!tfEvents.empty()) {
+    std::shared_ptr<CardAction> action = tfEvents.begin()->action;
+
+    // some actions cannot be countered
+    if (!action->GetMetaData().counterable) return false;
+
     // only opposing players can counter
-    std::shared_ptr<Character> lastActor = tfEvents.begin()->action->GetActor();
+    std::shared_ptr<Character> lastActor = action->GetActor();
     if (!lastActor->Teammate(user->GetTeam())) {
       playerCountered = true;
       Logger::Logf(LogLevel::info, "Player was countered!");
     }
     else {
-      addEvent = false;
+      return false;
     }
   }
 
-  return addEvent;
+  return true;
 }
 
 void TimeFreezeBattleState::HandleTimeFreezeCounter(std::shared_ptr<CardAction> action, uint64_t timestamp)

BattleNetwork/battlescene/bnBattleSceneBase.cpp

@@ -230,27 +230,7 @@ void BattleSceneBase::OnCounter(Entity& victim, Entity& aggressor)
     victim.ToggleCounter(false); // disable counter frame for the victim
     victim.Stun(frames(150));
 
-    if (p->IsInForm() == false && p->GetEmotion() != Emotion::evil) {
-      if (p == localPlayer) {
-        field->RevealCounterFrames(true);
-      }
-
-      // node positions are relative to the parent node's origin
-      sf::FloatRect bounds = p->getLocalBounds();
-      counterReveal->setPosition(0, -bounds.height / 4.0f);
-      p->AddNode(counterReveal);
-
-      std::shared_ptr<PlayerSelectedCardsUI> cardUI = p->GetFirstComponent<PlayerSelectedCardsUI>();
-
-      if (cardUI) {
-        cardUI->SetMultiplier(2);
-      }
-
-      p->SetEmotion(Emotion::full_synchro);
-
-      // when players get hit by impact, battle scene takes back counter blessings
-      p->AddDefenseRule(counterCombatRule);
-    }
+    PreparePlayerFullSynchro(p);
   }
 }
 
@@ -410,7 +390,9 @@ std::shared_ptr<Player> BattleSceneBase::GetPlayerFromEntityID(Entity::ID_t ID)
 
 void BattleSceneBase::OnCardActionUsed(std::shared_ptr<CardAction> action, uint64_t timestamp)
 {
-  HandleCounterLoss(*action->GetActor(), true);
+  if (action->GetMetaData().canBoost) {
+    HandleCounterLoss(*action->GetActor(), true);
+  }
 }
 
 sf::Vector2f BattleSceneBase::PerspectiveOffset(const sf::Vector2f& pos)
@@ -472,6 +454,10 @@ void BattleSceneBase::SpawnLocalPlayer(int x, int y)
   allPlayerTeamHash[localPlayer.get()] = team;
 
   HitListener::Subscribe(*localPlayer);
+
+  if (localPlayer->GetEmotion() == Emotion::full_synchro) {
+    PreparePlayerFullSynchro(localPlayer);
+  }
 }
 
 void BattleSceneBase::SpawnOtherPlayer(std::shared_ptr<Player> player, int x, int y)
@@ -498,6 +484,10 @@ void BattleSceneBase::SpawnOtherPlayer(std::shared_ptr<Player> player, int x, in
   allPlayerTeamHash[player.get()] = team;
 
   HitListener::Subscribe(*player);
+
+  if (player->GetEmotion() == Emotion::full_synchro) {
+    PreparePlayerFullSynchro(player);
+  }
 }
 
 void BattleSceneBase::LoadRedTeamMob(Mob& mob)
@@ -566,18 +556,39 @@ void BattleSceneBase::FilterSupportCards(const std::shared_ptr<Player>& player,
             meta.filterHandStep(cards[i].props, adjCards);
           }
 
+          size_t this_card = i;
+          /* 
+            Whether or not to do another loop on this index.
+            True when left, right, or this card were deleted.
+
+            By setting true on left and right delete, the filter 
+            step will run for this card again so that it can run 
+            with the new adjacent cards.
+
+            By setting true when deleting itself, the new card 
+            coming into this index won't be skipped.
+          */
+          bool check_again = false;
+
           if (adjCards.deleteLeft) {
-            cards.erase(cards.begin() + i - 1u);
-            i--;
+            cards.erase(cards.begin() + this_card - 1u);
+            this_card--;
+            check_again = true;
           }
 
           if (adjCards.deleteRight) {
-            cards.erase(cards.begin() + i + 1u);
-            i--;
+            cards.erase(cards.begin() + this_card + 1u);
+            // This card index hasn't changed
+
+            check_again = true;
           }
 
           if (adjCards.deleteThisCard) {
-            cards.erase(cards.begin() + i);
+            cards.erase(cards.begin() + this_card);
+            check_again = true;
+          }
+
+          if (check_again) {
             i--;
           }
         }
@@ -1035,6 +1046,30 @@ void BattleSceneBase::DrawWithPerspective(sf::Shape& shape, sf::RenderTarget& su
   shape.setOrigin(origin);
 }
 
+void BattleSceneBase::PreparePlayerFullSynchro(const std::shared_ptr<Player>& player) {
+  if (player->IsInForm() == true || player->GetEmotion() == Emotion::evil) return;
+
+  if (player == localPlayer) {
+    field->RevealCounterFrames(true);
+  }
+
+  // node positions are relative to the parent node's origin
+  sf::FloatRect bounds = player->getLocalBounds();
+  counterReveal->setPosition(0, -bounds.height / 4.0f);
+  player->AddNode(counterReveal);
+
+  std::shared_ptr<PlayerSelectedCardsUI> cardUI = player->GetFirstComponent<PlayerSelectedCardsUI>();
+
+  if (cardUI) {
+    cardUI->SetMultiplier(2);
+  }
+
+  player->SetEmotion(Emotion::full_synchro);
+
+  // when players get hit by impact, battle scene takes back counter blessings
+  player->AddDefenseRule(counterCombatRule);
+}
+
 void BattleSceneBase::DrawWithPerspective(sf::Sprite& sprite, sf::RenderTarget& surf)
 {
   sf::Vector2f position = sprite.getPosition();
@@ -1097,6 +1132,14 @@ std::vector<std::shared_ptr<Player>> BattleSceneBase::GetAllPlayers()
   return result;
 }
 
+Mob* BattleSceneBase::GetRedTeamMob() {
+  return redTeamMob;
+}
+
+Mob* BattleSceneBase::GetBlueTeamMob() {
+  return blueTeamMob;
+}
+
 
 std::shared_ptr<Field> BattleSceneBase::GetField()
 {
@@ -1242,6 +1285,7 @@ std::vector<std::reference_wrapper<const Character>> BattleSceneBase::BlueTeamMo
 
 void BattleSceneBase::Quit(const FadeOut& mode) {
   if(quitting) return; 
+  quitting = true;
 
   // end the current state
   if(current) {
@@ -1252,7 +1296,6 @@ void BattleSceneBase::Quit(const FadeOut& mode) {
   // NOTE: swoosh quirk
   if (getController().getStackSize() == 1) {
     getController().pop();
-    quitting = true;
     return;
   }
 
@@ -1268,8 +1311,6 @@ void BattleSceneBase::Quit(const FadeOut& mode) {
     // mode == FadeOut::pixelate
     getController().pop<segue<PixelateBlackWashFade>>();
   }
-
-  quitting = true;
 }
 
 

BattleNetwork/battlescene/bnBattleSceneBase.h

@@ -383,12 +383,15 @@ class BattleSceneBase :
   bool TrackOtherPlayer(std::shared_ptr<Player>& other);
   void UntrackOtherPlayer(std::shared_ptr<Player>& other);
   void UntrackMobCharacter(std::shared_ptr<Character>& character);
+  void PreparePlayerFullSynchro(const std::shared_ptr<Player>& player);
   bool IsPlayerDeleted() const;
 
   std::shared_ptr<Player> GetLocalPlayer();
   const std::shared_ptr<Player> GetLocalPlayer() const;
   std::vector<std::shared_ptr<Player>> GetOtherPlayers();
   std::vector<std::shared_ptr<Player>> GetAllPlayers();
+  Mob* GetRedTeamMob();
+  Mob* GetBlueTeamMob();
   std::shared_ptr<Field> GetField();
   const std::shared_ptr<Field> GetField() const;
   CardSelectionCust& GetCardSelectWidget();