src/battle/states/SelectAttackType.cpp

   1 #include "SelectAttackType.h"
   2
   3 #include "SelectIkari.h"
   4 #include "SelectItem.h"
   5 #include "SelectMoveAction.h"
   6 #include "SelectSpell.h"
   7 #include "SelectTarget.h"
   8 #include "../AttackChoice.h"
   9 #include "../BattleState.h"
  10 #include "../../app/Application.h"
  11 #include "../../app/Input.h"
  12 #include "../../common/Item.h"
  13 #include "../../math/Vector.h"
  14
  15 #include <stdexcept>
  16
  17 using app::Application;
  18 using app::Input;
  19 using common::Item;
  20 using math::Vector;
  21
  22 namespace battle {
  23
  24 SelectAttackType::SelectAttackType(Battle *battle, BattleState *parent)
  25 : battle(battle)
  26 , parent(parent) {
  27
  28 }
  29
  30
  31 void SelectAttackType::OnEnterState(SDL_Surface *screen) {
  32         OnResize(screen->w, screen->h);
  33 }
  34
  35 void SelectAttackType::OnExitState(SDL_Surface *screen) {
  36
  37 }
  38
  39 void SelectAttackType::OnResumeState(SDL_Surface *screen) {
  40         if (battle->ActiveHero().GetAttackChoice().Selection().HasSelected()) {
  41                 battle->ActiveHero().GetAttackChoice().SetType(parent->GetAttackTypeMenu().Selected());
  42                 battle->NextHero();
  43         }
  44         if (battle->AttackSelectionDone()) {
  45                 // pass through
  46                 Ctrl().PopState();
  47         }
  48 }
  49
  50 void SelectAttackType::OnPauseState(SDL_Surface *screen) {
  51
  52 }
  53
  54
  55 void SelectAttackType::OnResize(int width, int height) {
  56         Vector<int> offset(parent->ScreenOffset());
  57         Vector<int> position(
  58                         (parent->Width() - parent->GetAttackTypeMenu().Width()) / 2,
  59                         parent->Height() - parent->GetAttackTypeMenu().Height() - parent->GetAttackTypeMenu().Height() / 2);
  60         menuOffset = offset + position;
  61 }
  62
  63
  64 void SelectAttackType::HandleEvents(const Input &input) {
  65         if (input.IsDown(Input::PAD_UP)) {
  66                 parent->GetAttackTypeMenu().Select(AttackChoice::MAGIC);
  67         } else if (input.IsDown(Input::PAD_RIGHT)) {
  68                 parent->GetAttackTypeMenu().Select(AttackChoice::DEFEND);
  69         } else if (input.IsDown(Input::PAD_DOWN)) {
  70                 parent->GetAttackTypeMenu().Select(AttackChoice::IKARI);
  71         } else if (input.IsDown(Input::PAD_LEFT)) {
  72                 parent->GetAttackTypeMenu().Select(AttackChoice::ITEM);
  73         } else {
  74                 parent->GetAttackTypeMenu().Select(AttackChoice::SWORD);
  75         }
  76
  77         Hero &hero(battle->ActiveHero());
  78         AttackChoice &ac(hero.GetAttackChoice());
  79         if (input.JustPressed(Input::ACTION_A)) {
  80                 switch (parent->GetAttackTypeMenu().Selected()) {
  81                         case AttackChoice::SWORD:
  82                                 if (hero.HasWeapon()) {
  83                                         if (hero.Weapon()->GetTargetingMode().TargetsAll()) {
  84                                                 ac.SetType(AttackChoice::SWORD);
  85                                                 battle->NextHero();
  86                                                 break;
  87                                         } else {
  88                                                 ac.Selection().ReadMode(hero.Weapon()->GetTargetingMode());
  89                                         }
  90                                 } else {
  91                                         ac.Selection().SetSingle();
  92                                 }
  93                                 ac.Selection().Reset();
  94                                 Ctrl().PushState(new SelectTarget(battle, this, &ac.Selection(), parent->Res().weaponTargetCursor));
  95                                 break;
  96                         case AttackChoice::MAGIC:
  97                                 if (battle->ActiveHero().CanUseMagic()) {
  98                                         Ctrl().PushState(new SelectSpell(battle, this));
  99                                 }
 100                                 break;
 101                         case AttackChoice::DEFEND:
 102                                 ac.SetType(AttackChoice::DEFEND);
 103                                 battle->NextHero();
 104                                 break;
 105                         case AttackChoice::IKARI:
 106                                 Ctrl().PushState(new SelectIkari(battle, this));
 107                                 break;
 108                         case AttackChoice::ITEM:
 109                                 Ctrl().PushState(new SelectItem(battle, this));
 110                                 break;
 111                         default:
 112                                 throw std::logic_error("selected invalid attack type");
 113                 }
 114         } else if (input.JustPressed(Input::ACTION_B)) {
 115                 ac.Reset();
 116                 battle->PreviousHero();
 117                 if (battle->BeforeFirstHero()) {
 118                         Ctrl().ChangeState(new SelectMoveAction(battle, parent));
 119                 } else {
 120                         battle->ActiveHero().GetAttackChoice().Reset();
 121                 }
 122         }
 123
 124         if (battle->AttackSelectionDone()) {
 125                 Ctrl().PopState();
 126         }
 127 }
 128
 129 void SelectAttackType::UpdateWorld(Uint32 deltaT) {
 130
 131 }
 132
 133 void SelectAttackType::Render(SDL_Surface *screen) {
 134         parent->RenderBackground(screen);
 135         parent->RenderMonsters(screen);
 136         parent->RenderHeroTags(screen);
 137         RenderMenu(screen);
 138 }
 139
 140 void SelectAttackType::RenderMenu(SDL_Surface *screen) {
 141         parent->GetAttackTypeMenu().Render(screen, menuOffset);
 142 }
 143
 144
 145 const Resources &SelectAttackType::Res() const {
 146         return parent->Res();
 147 }
 148
 149 graphics::Menu<const Item *> &SelectAttackType::ItemMenu() {
 150         return parent->ItemMenu();
 151 }
 152
 153 const graphics::Menu<const Item *> &SelectAttackType::ItemMenu() const {
 154         return parent->ItemMenu();
 155 }
 156
 157 const HeroTag &SelectAttackType::HeroTagAt(int index) const {
 158         return parent->HeroTagAt(index);
 159 }
 160 const Vector<int> &SelectAttackType::HeroTagPositionAt(int index) const {
 161         return parent->HeroTagPositionAt(index);
 162 }
 163
 164 const Vector<int> &SelectAttackType::ScreenOffset() const {
 165         return parent->ScreenOffset();
 166 }
 167
 168 int SelectAttackType::Width() const {
 169         return parent->Width();
 170 }
 171
 172 int SelectAttackType::Height() const {
 173         return parent->Height();
 174 }
 175
 176 }