src/battle/states/PerformAttacks.cpp

   1 #include "PerformAttacks.h"
   2
   3 #include "../BattleState.h"
   4 #include "../Hero.h"
   5 #include "../Monster.h"
   6 #include "../TargetSelection.h"
   7 #include "../../app/Application.h"
   8 #include "../../app/Input.h"
   9 #include "../../common/Ikari.h"
  10 #include "../../common/Item.h"
  11 #include "../../common/Spell.h"
  12 #include "../../graphics/Animation.h"
  13 #include "../../graphics/Font.h"
  14 #include "../../graphics/Frame.h"
  15
  16 #include <cstring>
  17
  18 using app::Application;
  19 using app::Input;
  20 using math::Vector;
  21 using graphics::AnimationRunner;
  22 using std::vector;
  23
  24 namespace battle {
  25
  26 void PerformAttacks::OnEnterState(SDL_Surface *screen) {
  27         battle->CalculateAttackOrder();
  28         numberAnimation.reserve(battle->MaxMonsters() > battle->NumHeroes() + 1 ? battle->MaxMonsters() : battle->NumHeroes() + 1);
  29         numberPosition.reserve(numberAnimation.size());
  30         OnResize(screen->w, screen->h);
  31 }
  32
  33 void PerformAttacks::OnExitState(SDL_Surface *screen) {
  34         battle->ClearAllAttacks();
  35 }
  36
  37 void PerformAttacks::OnResumeState(SDL_Surface *screen) {
  38
  39 }
  40
  41 void PerformAttacks::OnPauseState(SDL_Surface *screen) {
  42
  43 }
  44
  45
  46 void PerformAttacks::OnResize(int width, int height) {
  47         const Resources &res = battle->Res();
  48         framePosition = battle->ScreenOffset();
  49         frameSize = Vector<int>(
  50                         battle->Width(),
  51                         res.titleFrame->BorderHeight() * 2 + res.titleFont->CharHeight());
  52 }
  53
  54
  55 void PerformAttacks::HandleEvents(const Input &input) {
  56         CheckAnimations();
  57         if (HasAnimationsRunning()) return;
  58         ResetAnimation();
  59         battle->ApplyDamage();
  60         battle->NextAttack();
  61         if (battle->AttacksFinished()) {
  62                 Ctrl().PopState();
  63                 return;
  64         }
  65
  66         battle->CalculateDamage();
  67
  68         if (battle->CurrentAttack().IsMonster()) {
  69                 Monster &monster(battle->MonsterAt(battle->CurrentAttack().index));
  70                 titleBarText = monster.Name();
  71                 targetAnimation = AnimationRunner(monster.MeleeAnimation());
  72                 moveAnimation = AnimationRunner(monster.AttackAnimation());
  73                 monster.SetAnimation(moveAnimation);
  74                 AddNumberAnimations(battle->MonsterAt(battle->CurrentAttack().index).GetAttackChoice().Selection());
  75         } else if (battle->CurrentAttack().IsCapsule()) {
  76                 Capsule &capsule(battle->GetCapsule());
  77                 titleBarText = capsule.Name();
  78                 targetAnimation = AnimationRunner(capsule.MeleeAnimation());
  79                 moveAnimation = AnimationRunner(capsule.AttackAnimation());
  80                 capsule.SetAnimation(moveAnimation);
  81                 AddNumberAnimations(capsule.GetAttackChoice().Selection());
  82         } else {
  83                 Hero &hero(battle->HeroAt(battle->CurrentAttack().index));
  84                 const AttackChoice &ac(battle->HeroAt(battle->CurrentAttack().index).GetAttackChoice());
  85
  86                 switch (ac.GetType()) {
  87                         case AttackChoice::SWORD:
  88                                 if (hero.HasWeapon()) {
  89                                         titleBarText = hero.Weapon()->Name();
  90                                         targetAnimation = AnimationRunner(hero.Weapon()->AttackAnimation());
  91                                 } else {
  92                                         titleBarText = "Melee attack!";
  93                                         targetAnimation = AnimationRunner(hero.MeleeAnimation());
  94                                 }
  95                                 moveAnimation = AnimationRunner(hero.AttackAnimation());
  96                                 AddNumberAnimations(ac.Selection());
  97                                 break;
  98                         case AttackChoice::MAGIC:
  99                                 titleBarText = ac.GetSpell()->Name();
 100                                 moveAnimation = AnimationRunner(hero.SpellAnimation());
 101                                 break;
 102                         case AttackChoice::DEFEND:
 103                                 titleBarText = "Defends.";
 104                                 moveAnimation.Clear();
 105                                 break;
 106                         case AttackChoice::IKARI:
 107                                 if (ac.GetItem()->HasIkari()) {
 108                                         titleBarText = ac.GetItem()->GetIkari()->Name();
 109                                         if (ac.GetItem()->GetIkari()->IsMagical()) {
 110                                                 moveAnimation = AnimationRunner(hero.SpellAnimation());
 111                                         } else {
 112                                                 moveAnimation = AnimationRunner(hero.AttackAnimation());
 113                                         }
 114                                 }
 115                                 break;
 116                         case AttackChoice::ITEM:
 117                                 titleBarText = ac.GetItem()->Name();
 118                                 moveAnimation.Clear();
 119                                 break;
 120                         case AttackChoice::UNDECIDED:
 121                                 titleBarText = "UNDECIDED";
 122                                 moveAnimation.Clear();
 123                                 break;
 124                 }
 125         }
 126
 127         if (titleBarText) {
 128                 titleBarTimer = GraphicsTimers().StartCountdown(850);
 129                 textPosition = battle->ScreenOffset() + Vector<int>(
 130                                 (battle->Width() - std::strlen(titleBarText) * battle->Res().titleFont->CharWidth()) / 2,
 131                                 battle->Res().titleFrame->BorderHeight());
 132         }
 133         if (moveAnimation.Valid()) {
 134                 moveAnimation.Start(*this);
 135                 if (battle->CurrentAttack().IsMonster()) {
 136                         battle->MonsterAt(battle->CurrentAttack().index).SetAnimation(moveAnimation);
 137                 } else if (battle->CurrentAttack().IsHero()) {
 138                         battle->HeroAt(battle->CurrentAttack().index).SetAnimation(moveAnimation);
 139                 } else {
 140                         battle->GetCapsule().SetAnimation(moveAnimation);
 141                 }
 142         }
 143         if (targetAnimation.Valid()) {
 144                 targetAnimationTimer = GraphicsTimers().StartCountdown(150);
 145         } else {
 146                 targetAnimationTimer.Clear();
 147         }
 148 }
 149
 150 void PerformAttacks::AddNumberAnimations(const TargetSelection &ts) {
 151         if (ts.TargetsMonsters()) {
 152                 for (int i(0); i < battle->MaxMonsters(); ++i) {
 153                         if (ts.IsBad(i)) {
 154                                 numberAnimation.push_back(NumberAnimation(ts.GetAmount(i), battle->Res().numberAnimationPrototype, battle->Res().bigNumberSprite));
 155                                 numberPosition.push_back(
 156                                                 battle->MonsterAt(i).Position() + battle->ScreenOffset());
 157                         } else if (ts.IsGood(i)) {
 158                                 numberAnimation.push_back(NumberAnimation(ts.GetAmount(i), battle->Res().numberAnimationPrototype, battle->Res().greenNumberSprite));
 159                                 numberPosition.push_back(
 160                                                 battle->MonsterAt(i).Position() + battle->ScreenOffset());
 161                         }
 162                 }
 163         } else {
 164                 for (int i(0); i < battle->NumHeroes(); ++i) {
 165                         if (ts.IsBad(i)) {
 166                                 numberAnimation.push_back(NumberAnimation(ts.GetAmount(i), battle->Res().numberAnimationPrototype, battle->Res().bigNumberSprite));
 167                                 numberPosition.push_back(
 168                                                 battle->HeroAt(i).Position() + battle->ScreenOffset());
 169                         } else if (ts.IsGood(i)) {
 170                                 numberAnimation.push_back(NumberAnimation(ts.GetAmount(i), battle->Res().numberAnimationPrototype, battle->Res().greenNumberSprite));
 171                                 numberPosition.push_back(
 172                                                 battle->HeroAt(i).Position() + battle->ScreenOffset());
 173                         }
 174                 }
 175         }
 176 }
 177
 178 void PerformAttacks::CheckAnimations() {
 179         if (targetAnimation.Valid() && targetAnimationTimer.JustHit()) {
 180                 targetAnimation.Start(*this);
 181         }
 182         if (moveAnimation.Valid() && !moveAnimation.Finished()) return;
 183         if (targetAnimation.Valid() && !targetAnimation.Finished()) return;
 184         if (moveAnimation.Valid() || targetAnimation.Valid()) {
 185                 moveAnimation.Clear();
 186                 targetAnimation.Clear();
 187                 for (vector<NumberAnimation>::iterator i(numberAnimation.begin()), end(numberAnimation.end()); i != end; ++i) {
 188                         i->Start(*this);
 189                 }
 190         } else {
 191                 for (vector<NumberAnimation>::iterator i(numberAnimation.begin()), end(numberAnimation.end()); i != end; ++i) {
 192                         i->CheckTimers(*this);
 193                 }
 194         }
 195 }
 196
 197 bool PerformAttacks::HasAnimationsRunning() const {
 198         if (titleBarTimer.Running()) return true;
 199         if (moveAnimation.Valid() && moveAnimation.Running()) return true;
 200         if (targetAnimation.Valid() && targetAnimation.Running()) return true;
 201         for (vector<NumberAnimation>::const_iterator i(numberAnimation.begin()), end(numberAnimation.end()); i != end; ++i) {
 202                 if (i->Running()) return true;
 203         }
 204         return false;
 205 }
 206
 207 void PerformAttacks::ResetAnimation() {
 208         if (moveAnimation.Valid()) {
 209                 moveAnimation.Clear();
 210                 if (!battle->CurrentAttack().IsMonster()) {
 211                         battle->HeroAt(battle->CurrentAttack().index).GetAnimation().Clear();
 212                 }
 213         }
 214         if (targetAnimation.Valid()) {
 215                 targetAnimation.Clear();
 216         }
 217         titleBarTimer.Clear();
 218         numberAnimation.clear();
 219         numberPosition.clear();
 220 }
 221
 222
 223 void PerformAttacks::UpdateWorld(Uint32 deltaT) {
 224
 225 }
 226
 227 void PerformAttacks::Render(SDL_Surface *screen) {
 228         battle->RenderBackground(screen);
 229         battle->RenderMonsters(screen);
 230         battle->RenderHeroes(screen);
 231         battle->RenderCapsule(screen);
 232         battle->RenderSmallHeroTags(screen);
 233         RenderTitleBar(screen);
 234         RenderNumbers(screen);
 235         RenderTargetAnimation(screen);
 236 }
 237
 238 void PerformAttacks::RenderTitleBar(SDL_Surface *screen) const {
 239         if (!titleBarText || !titleBarTimer.Running()) return;
 240
 241         battle->Res().titleFrame->Draw(screen, framePosition, frameSize.X(), frameSize.Y());
 242
 243         battle->Res().titleFont->DrawString(titleBarText, screen, textPosition);
 244 }
 245
 246 void PerformAttacks::RenderNumbers(SDL_Surface *screen) const {
 247         for (vector<NumberAnimation>::size_type i(0), end(numberAnimation.size()); i < end; ++i) {
 248                 if (numberAnimation[i].Running()) {
 249                         Vector<int> align(numberAnimation[i].Width() / -2, numberAnimation[i].Height() * -3 / 4);
 250                         numberAnimation[i].Draw(screen, numberPosition[i] + align);
 251                 }
 252         }
 253 }
 254
 255 void PerformAttacks::RenderTargetAnimation(SDL_Surface *screen) const {
 256         if (!targetAnimation.Valid() || !targetAnimation.Running()) return;
 257         const TargetSelection &ts(battle->CurrentAttackAttackChoice().Selection());
 258         if (ts.TargetsHeroes()) {
 259                 for (vector<Vector<int> >::size_type i(0), end(battle->NumHeroes()); i < end; ++i) {
 260                         if (ts.IsSelected(i)) {
 261                                 targetAnimation.DrawCenter(screen, battle->HeroAt(i).Position() + battle->ScreenOffset());
 262                         }
 263                 }
 264         } else {
 265                 for (vector<Vector<int> >::size_type i(0), end(battle->MaxMonsters()); i < end; ++i) {
 266                         if (ts.IsSelected(i)) {
 267                                 targetAnimation.DrawCenter(screen, battle->MonsterAt(i).Position() + battle->ScreenOffset());
 268                         }
 269                 }
 270         }
 271 }
 272
 273 }