accept A button to return from capsule change

[l2e.git] / src / menu / CapsuleChangeMenu.cpp

diff --git a/src/menu/CapsuleChangeMenu.cpp b/src/menu/CapsuleChangeMenu.cpp
index 3b161ad9df6ff6e0839a90c70166c52ce50a66f2..386d22cf79c891834633dfd4f5d4c2a7a8b3b06b 100644 (file)
--- a/src/menu/CapsuleChangeMenu.cpp
+++ b/src/menu/CapsuleChangeMenu.cpp
@@ -10,6 +10,7 @@
 #include "../common/GameState.h"
 #include "../graphics/Font.h"
 #include "../graphics/Frame.h"
+#include "../graphics/Texture.h"
 
 using app::Input;
 using common::Capsule;
@@ -50,11 +51,60 @@ void CapsuleChangeMenu::OnResize(int width, int height) {
 
 
 void CapsuleChangeMenu::HandleEvents(const Input &input) {
-       if (input.JustPressed(Input::ACTION_B)) {
+       if (input.JustPressed(Input::ACTION_A)
+                       || input.JustPressed(Input::ACTION_B)) {
                Ctrl().PopState();
        }
+
+       if (input.JustPressed(Input::PAD_UP)) {
+               NextClass();
+       }
+       if (input.JustPressed(Input::PAD_RIGHT)) {
+               NextCapsule();
+       }
+       if (input.JustPressed(Input::PAD_DOWN)) {
+               PreviousClass();
+       }
+       if (input.JustPressed(Input::PAD_LEFT)) {
+               PreviousCapsule();
+       }
+}
+
+void CapsuleChangeMenu::NextCapsule() {
+       int storedClass = parent->Game().state->GetCapsule().ClassIndex();
+       int &index = parent->Game().state->capsule;
+       ++index;
+       index %= parent->Game().state->NumCapsules();
+       // skip unexplored
+       while (parent->Game().state->GetCapsule().MaxClass() <= 0) {
+               ++index;
+               index %= parent->Game().state->NumCapsules();
+       }
+       parent->Game().state->GetCapsule().SetClass(storedClass);
+}
+
+void CapsuleChangeMenu::PreviousCapsule() {
+       int storedClass = parent->Game().state->GetCapsule().ClassIndex();
+       int &index = parent->Game().state->capsule;
+       --index;
+       if (index < 0) index += parent->Game().state->NumCapsules();
+       // skip unexplored
+       while (GetCapsule().MaxClass() <= 0) {
+               --index;
+               if (index < 0) index += parent->Game().state->NumCapsules();
+       }
+       parent->Game().state->GetCapsule().SetClass(storedClass);
+}
+
+void CapsuleChangeMenu::NextClass() {
+       GetCapsule().NextClass();
+}
+
+void CapsuleChangeMenu::PreviousClass() {
+       GetCapsule().PreviousClass();
 }
 
+
 void CapsuleChangeMenu::UpdateWorld(float deltaT) {
 
 }
@@ -69,18 +119,76 @@ void CapsuleChangeMenu::Render(SDL_Surface *screen) {
                        12 * font.CharWidth(),
                        2 * font.CharHeight() - font.CharHeight() / 8);
        // TODO: wheel offset: top left, center, or center bottom?
-       const Vector<int> wheelOffset;
+       const Vector<int> wheelOffset(
+                       6 * font.CharWidth(),
+                       19 * font.CharHeight() - font.CharHeight() / 8);
+       const Vector<int> classesOffset(
+                       12 * font.CharWidth(),
+                       13 * font.CharHeight() - font.CharHeight() / 8);
        const Vector<int> menuOffset(
-                               font.CharWidth(),
-                               24 * font.CharHeight() - font.CharHeight() / 8);
+                       font.CharWidth(),
+                       24 * font.CharHeight() - font.CharHeight() / 8);
 
        parent->RenderBackground(screen);
        parent->RenderCapsule(screen, offset + capsuleOffset);
        parent->RenderInfo(screen, offset + infoOffset);
        parent->RenderWheel(screen, offset + wheelOffset);
+       RenderClasses(screen, offset + classesOffset);
        parent->RenderMenu(screen, offset + menuOffset);
 }
 
+void CapsuleChangeMenu::RenderClasses(SDL_Surface *screen, const Vector<int> &offset) const {
+       Vector<int> cursor(offset);
+
+       int numClasses = 0;
+       for (int i = 0; i < parent->Game().state->NumCapsules(); ++i) {
+               if (numClasses < parent->Game().state->capsules[i].NumClasses()) {
+                       numClasses = parent->Game().state->capsules[i].NumClasses();
+               }
+       }
+
+       parent->Res().capsuleSelectTopLeft->Draw(screen, cursor);
+       cursor.Y() += parent->Res().capsuleSelectTopLeft->Height();
+       Vector<int> target(
+                       cursor.X() + parent->Res().capsuleSelectTopLeft->Width(),
+                       cursor.Y() + numClasses * parent->Res().capsuleSelectLadder->Height());
+       parent->Res().capsuleSelectLeftRepeat->Render(screen, cursor, target);
+       cursor.Y() = target.Y();
+       parent->Res().capsuleSelectBottomLeft->Draw(screen, cursor);
+       cursor.X() += parent->Res().capsuleSelectTopLeft->Width();
+
+       for (int i = 0; i < parent->Game().state->NumCapsules(); ++i) {
+               cursor.Y() = offset.Y();
+               parent->Res().capsuleSelectTopRepeat->Draw(screen, cursor);
+               cursor.Y() += parent->Res().capsuleSelectTopRepeat->Height();
+               for (int j = numClasses - 1; j >= 0; --j) {
+                       parent->Res().capsuleSelectLadder->Draw(
+                                       screen, cursor,
+                                       j < parent->Game().state->capsules[i].MaxClass(), j);
+                       if (i == parent->Game().state->capsule
+                                       && parent->Game().state->capsules[i].CurrentClass() == j) {
+                               parent->Res().capsuleSelectCursor->Draw(screen, cursor);
+                       }
+                       cursor.Y() += parent->Res().capsuleSelectLadder->Height();
+               }
+               parent->Res().capsuleSelectBottomRepeat->Draw(screen, cursor);
+               if (parent->Game().state->capsules[i].AlignmentSprite()) {
+                       parent->Game().state->capsules[i].AlignmentSprite()->Draw(screen, cursor);
+               }
+               cursor.X() += parent->Res().capsuleSelectLadder->Width();
+       }
+
+       cursor.Y() = offset.Y();
+       parent->Res().capsuleSelectTopRight->Draw(screen, cursor);
+       cursor.Y() += parent->Res().capsuleSelectTopRight->Height();
+       target = Vector<int>(
+                       cursor.X() + parent->Res().capsuleSelectTopRight->Width(),
+                       cursor.Y() + numClasses * parent->Res().capsuleSelectLadder->Height());
+       parent->Res().capsuleSelectRightRepeat->Render(screen, cursor, target);
+       cursor.Y() = target.Y();
+       parent->Res().capsuleSelectBottomRight->Draw(screen, cursor);
+}
+
 
 int CapsuleChangeMenu::Width() const {
        return parent->Width();
@@ -90,6 +198,10 @@ int CapsuleChangeMenu::Height() const {
        return parent->Height();
 }
 
+Capsule &CapsuleChangeMenu::GetCapsule() {
+       return parent->GetCapsule();
+}
+
 const Capsule &CapsuleChangeMenu::GetCapsule() const {
        return parent->GetCapsule();
 }