diff --git a/projects/mtg/include/CarouselDeckView.h b/projects/mtg/include/CarouselDeckView.h index 9348dcd7b..7514ed62d 100644 --- a/projects/mtg/include/CarouselDeckView.h +++ b/projects/mtg/include/CarouselDeckView.h @@ -11,6 +11,7 @@ private: static const float x_center; static const float right_border; static const float slide_animation_duration; + static const float scroll_animation_duration; public: CarouselDeckView(); @@ -18,19 +19,21 @@ public: void Reset(); void UpdateViewState(float dt); - void UpdateCardPosition(CardRep &rep, int index); + void UpdateCardPosition(int index); void renderCard(int index) { - int alpha = (int) (255 * (getCardRep(index).scale + 1.0 - max_scale)); + int alpha = (int) (255 * (mCards[index].scale + 1.0 - max_scale)); DeckView::renderCard(index, alpha); } void Render(); + bool ButtonPressed(Buttons button); MTGCard * Click(int x, int y); + MTGCard * Click(); - void changePosition(int offset); - void changeFilter(int offset); + void changePositionAnimated(int offset); + void changeFilterAnimated(int offset); MTGCard *getActiveCard(); private: diff --git a/projects/mtg/include/DeckView.h b/projects/mtg/include/DeckView.h index 268581a31..7feec1226 100644 --- a/projects/mtg/include/DeckView.h +++ b/projects/mtg/include/DeckView.h @@ -9,55 +9,233 @@ #include "WResourceManager.h" #include "Pos.h" - +/*! \brief A abstract base class for deck views + * + * The deck editor uses a deck view to present the cards + * e.g. in a circular "Carousel" layout or in a flat grid + * layout. Both layouts inherit this base class to ensure + * a common interface which the deck editor can rely on. + */ class DeckView { protected: + /*! \brief defines the delay until additional card informations get shown + * + * \note I am not entirely sure about that + */ static const float no_user_activity_show_card_delay; -public: + /*! \brief Represents a card for internal use in the deck view + * + * It stores positional information and a pointer to the actual card structure. + */ struct CardRep{ float x; float y; float scale; MTGCard * card; }; - +public: + /*! \brief Defines if the filter needs an update + * + * The owner of the deck that is shown is responsible for updating the filters. + */ bool dirtyFilters; + + /*! \brief Defines if the card positions need an update + * + * If the card positions are dirty, UpdateCardPosition will get called on + * all cards during Update(float dt); + * + * \see Update + * \see UpdateCardPosition + */ bool dirtyCardPos; + /*! \brief Constructs the view and initializes datamembers + * + * It sets the dirty states to true, the currently shown deck to NULL and selects filter 0. + * + * \param numberOfCards the number of cards the view handles (this includes hidden cards for caching) + */ DeckView(int numberOfCards); + + /*! \brief Does nothing but is needed to ensure proper deletion of derived classes. + */ virtual ~DeckView(); + + /*! \brief Resets nearly all datamembers to their initial values + * + * Does not reset mCards. + */ virtual void Reset(); - //advances the view and card representations + /*! \brief Advances the view by dt time units + * + * This method calls UpdateViewState unconditionally and UpdateCardPosition on every card + * if dirtyCardPos is set. It then resets dirtyCardPos. + * + * \param dt the number of time units to advance + * \see UpdateViewState + * \see UpdateCardPosition + */ void Update(float dt); - virtual void SetDeck(DeckDataWrapper *toShow); + + /*! \brief Sets the deck that this view shows + * + * This method replaces the currently shown deck with toShow, sets all dirty states and + * reloads the mtg cards. No ownership changes. + * + * \param toShow the deck to show + * \see reloadIndexes + */ + void SetDeck(DeckDataWrapper *toShow); + + /*! \brief Returns a pointer to the current deck. + */ DeckDataWrapper *deck(); - void SwitchFilter(int delta); - void SwitchPosition(int delta); + + /*! \brief Performs an immediate switch of the filter without animations + * + * This method rotates the currently selected filter by delta and sets dirtyFilters. + * + * \param delta the filter to select relatively to the currently selected filter + * \see dirtyFilters + */ + void changeFilter(int delta); + + /*! \brief Performs an immediate switch of the position without animations + * + * If the i-th card stored in mCards points to the j-th card in the deck, it will point + * to the (j+delta)-th card after this method is called. No dirty states are set. + * + * \param delta the number of cards to advances + * \see mCards + */ + void changePosition(int delta); + + /*! \brief Returns the number of the currently selected filter + * + * \return the currently selected filter + */ int filter(); + + /*! \brief Reloads the mtg card pointers of mCards from the deck + * + * This is called when: We change the position in the deck or the deck structure changes + * (due to filtering or addition or removal of cards). + */ void reloadIndexes(); + + /*! \brief Returns the current position in the deck + */ int getPosition(); + /*! \brief Renders the view + */ virtual void Render() = 0; + + /*! \brief Reacts to selections by a pointer device (e. g. mouse, touch) + * + * If the selection in view internal i. e. a card got selected, there is + * no outside action performed and this method will return NULL. If a action got + * triggered i. e. a selected card was activated, it returns that card + * for further handling by the caller. + * + * \param x the x coordinate of the pointer during the action + * \param y the y coordinate of the pointer during the action + * \returns the card the action corresponds to + */ virtual MTGCard * Click(int x, int y) = 0; - bool ButtonPressed(Buttons button); + + /*! \brief Reacts to selections by pointerless devices (e. g. buttons) + * + * \see Click(int x, int y) + * \returns the card the actions corresponds to + */ + virtual MTGCard * Click() = 0; + + /*! \brief Handles ordinary button presses + * + * \param the pressed JButton + * \returns true if the view reacted to the button and false otherwise + */ + virtual bool ButtonPressed(Buttons button) = 0; + + /*! \brief Returns the currently active card + */ virtual MTGCard *getActiveCard() = 0; - virtual void changePosition(int offset) = 0; - virtual void changeFilter(int offset) = 0; + + /*! \brief Changes the position by a given offset + * + * Advances the view by offset cards and animates the change. + * + * \param offset the number of positions to advance + */ + virtual void changePositionAnimated(int offset) = 0; + + /*! \brief Changes the filter by a given offset + * + * Rotates the selected filter by the given offset and animates the change. + */ + virtual void changeFilterAnimated(int offset) = 0; protected: + + /*! \brief The number of time units since an user activity occurred + */ float last_user_activity; + + /*! \brief The currently selected filter + */ int mFilter; + + /*! \brief The currently selected deck + * + * This class does not take ownership of the deck + */ DeckDataWrapper *mCurrentDeck; + + /*! \brief The card positions and pointers + */ vector mCards; - CardRep& getCardRep(unsigned int index); + /*! \brief Renders a card with given alpha value + * + * \param index of the card in mCards to render + * \param alpha the alpha value of the card + * \param asThumbnail renders the thumbnail image of the card if set to true + * + * \see mCards + */ void renderCard(int index, int alpha, bool asThumbnail = false); + + /*! \brief Returns the index in mCards of the card that is nearest to the given point + * + * \note This method uses the euclidian distance to the center of the card + * + * \param x the reference points x coordinate + * \param y the reference points y coordinate + * \returns the index of the nearest card to the reference point and -1 of mCards is empty + */ int getCardIndexNextTo(int x, int y); private: + + /*! \brief Updates the state of the view e. g. view transitions + * + * \param dt the passes time since the last update + */ virtual void UpdateViewState(float dt) = 0; - virtual void UpdateCardPosition(CardRep& rep, int index) = 0; + + /*! \brief Updates the given card reps positional members + * + * This method is called from Update when dirtyCardPos is set + * + * \param index the index in mCards of the card to update + * + * \see Update + * \see mCards + */ + virtual void UpdateCardPosition(int index) = 0; }; #endif // _DECK_VIEW_H_ diff --git a/projects/mtg/include/GridDeckView.h b/projects/mtg/include/GridDeckView.h index 1e59d4079..0c164f1f1 100644 --- a/projects/mtg/include/GridDeckView.h +++ b/projects/mtg/include/GridDeckView.h @@ -4,6 +4,15 @@ #include "DeckView.h" #include "Easing.h" +/*! \brief Implements a grid view + * + * This view displays 12 cards in two rows as thumbnails. The currently + * selected card is dislayed bigger than the rest and uses the fullsize + * image. Scrolling the view horizontally and toggeling filters is + * animated and uses quadratic easing. + * + * It also implements a button mode for pointerless devices. + */ class GridDeckView : public DeckView { private: @@ -12,27 +21,134 @@ private: static const float card_scale_small; static const float card_scale_big; public: + /*! \brief Constructs a grid view with no decks set + */ GridDeckView(); + + /*! \brief Does nothing but is needed to ensure proper deletion of derived classes. + */ virtual ~GridDeckView(); + + /*! \brief Resets almost all member variables but mRows and mCols + */ void Reset(); + /*! \brief Advances scrolling and sliding animations + * + * \param dt the time since the last update + * + * \see DeckView::UpdateViewState() + */ void UpdateViewState(float dt); - void UpdateCardPosition(CardRep &rep, int index); + /*! \brief Updates the cards position + * + * \see DeckView::UpdateCardPosition() + */ + void UpdateCardPosition(int index); + + /*! \brief Renders the view + * + * This method prefetches all rendered cards as thumbnails except the + * selected card to reduce cache pressure. + */ void Render(); + + /*! \brief Handles button presses + * + * The mapping is as follows: + * JGE_BTN_LEFT moves the position to the left if not in button mode + * moves the selection otherwise + * JGE_BTN_RIGHT move the position to the right if not in button mode + * moves the selection otherwise + * JGE_BTN_UP select the previous filter if not in button mode + * moves the selection otherwise + * JGE_BTN_DOWN select the next filter if not in button mode + * moves the selection otherwise + * JGE_BTN_CTRL deactivate button mode + * + * \param button the pressed button + * \returns if the view handled the button + */ + bool ButtonPressed(Buttons button); + + /*! \brief Handles clicks and triggers scrolling and the selection of cards + * + * This method deactivates the button mode and searches for the nearest + * card to the given position. If this card is in column 0 or 1 it scrolls + * left. If it is in column (mCols-1) or (mCols-2) it scrolls to the right. + * In any other case, it selects the card. + * + * \param x the clicks x coordinate + * \param y the clicks y coordinate + * + * \return selected card c if c was already selected and no animation is running, NULL otherwise + */ MTGCard * Click(int x, int y); - void changePosition(int offset); - void changeFilter(int offset); + /*! \brief Handles pointerless clicks (JGE_BTN_OK) + * + * If no card is selected, this method activates button mode and selects a card. + * + * \returns selected card, NULL otherwise + */ + MTGCard * Click(); + /*! \brief Scrolls the view horizontally + * + * \param offset the number of columns to scroll + */ + void changePositionAnimated(int offset); + + /*! \brief Rotates the selected filter and slides vertically + * + * \param the number of filters to rotate + */ + void changeFilterAnimated(int offset); + + /*! \brief Returns the currently selected card + * + * \returns card c if c is selected and in column 4 to 6 and NULL otherwise*/ MTGCard *getActiveCard(); private: - int mCols; - int mRows; - float mScrollOffset, mSlideOffset; + /*! \brief The amount of columns (visible and hidden) + */ + const int mCols; + + /*! \brief The amount of rows + */ + const int mRows; + + /*! \brief The current scrolling offset + */ + float mScrollOffset; + + /*! \brief The current sliding offset + */ + float mSlideOffset; + + /*! \brief The easing functor that gets applied while scrolling + */ InOutQuadEasing mScrollEasing; + + /*! \brief The easing functor that gets applied while sliding + */ InOutQuadEasing mSlideEasing; + + /*! \brief The current selected card index + */ int mCurrentSelection; + + /*! \brief Stores if we are in button mode. + */ + bool mButtonMode; + + /*! \brief Moves the card selection by an offset. + * + * \param offset the offset to move the selection + * \param alignIfOutOfBounds the view will scroll if the selection moves out of bound if set to true + */ + void moveSelection(int offset, bool alignIfOutOfBounds); }; #endif //_GRID_DECK_VIEW_H diff --git a/projects/mtg/src/CarouselDeckView.cpp b/projects/mtg/src/CarouselDeckView.cpp index 0499f7aff..7a219dfc0 100644 --- a/projects/mtg/src/CarouselDeckView.cpp +++ b/projects/mtg/src/CarouselDeckView.cpp @@ -4,6 +4,7 @@ const float CarouselDeckView::max_scale = 0.96f; const float CarouselDeckView::x_center = 180; const float CarouselDeckView::right_border = SCREEN_WIDTH + 180; const float CarouselDeckView::slide_animation_duration = 0.6f; +const float CarouselDeckView::scroll_animation_duration = 0.3f; CarouselDeckView::CarouselDeckView() : DeckView(10), mScrollOffset(0), mSlideOffset(0), mScrollEasing(mScrollOffset), mSlideEasing(mSlideOffset) @@ -21,12 +22,12 @@ void CarouselDeckView::UpdateViewState(float dt) if(mScrollOffset <= -1.0f) { - SwitchPosition(-1); + changePosition(-1); mScrollEasing.translate(1.0f); } else if(mScrollOffset >= 1.0f) { - SwitchPosition(1); + changePosition(1); mScrollEasing.translate(-1.0f); } @@ -43,7 +44,7 @@ void CarouselDeckView::UpdateViewState(float dt) if(mSlideOffset < -1.0f) { mSlideEasing.translate(2.0f); - SwitchFilter(1); + changeFilter(1); } } else if(mSlideOffset > mSlideEasing.start_value) @@ -52,7 +53,7 @@ void CarouselDeckView::UpdateViewState(float dt) if(mSlideOffset > 1.0f) { mSlideEasing.translate(-2.0f); - SwitchFilter(-1); + changeFilter(-1); } } @@ -60,8 +61,10 @@ void CarouselDeckView::UpdateViewState(float dt) } } -void CarouselDeckView::UpdateCardPosition(CardRep &rep, int index) +void CarouselDeckView::UpdateCardPosition(int index) { + CardRep &rep = mCards[index]; + float rotation = mScrollOffset + 8 - index; rep.x = x_center + cos((rotation) * M_PI / 12) * (right_border - x_center); @@ -84,13 +87,13 @@ void CarouselDeckView::Render() // in a different order, ie the center card should appear first, then the adjacent ones if (WResourceManager::Instance()->IsThreaded()) { - WResourceManager::Instance()->RetrieveCard(getCardRep(0).card); - WResourceManager::Instance()->RetrieveCard(getCardRep(3).card); - WResourceManager::Instance()->RetrieveCard(getCardRep(4).card); - WResourceManager::Instance()->RetrieveCard(getCardRep(2).card); - WResourceManager::Instance()->RetrieveCard(getCardRep(5).card); - WResourceManager::Instance()->RetrieveCard(getCardRep(1).card); - WResourceManager::Instance()->RetrieveCard(getCardRep(6).card); + WResourceManager::Instance()->RetrieveCard(mCards[0].card); + WResourceManager::Instance()->RetrieveCard(mCards[3].card); + WResourceManager::Instance()->RetrieveCard(mCards[4].card); + WResourceManager::Instance()->RetrieveCard(mCards[2].card); + WResourceManager::Instance()->RetrieveCard(mCards[5].card); + WResourceManager::Instance()->RetrieveCard(mCards[1].card); + WResourceManager::Instance()->RetrieveCard(mCards[6].card); } renderCard(6); @@ -118,6 +121,31 @@ void CarouselDeckView::Render() } } +bool CarouselDeckView::ButtonPressed(Buttons button) +{ + switch(button) + { + case JGE_BTN_LEFT: + changePositionAnimated(-1); + last_user_activity = 0; + break; + case JGE_BTN_RIGHT: + changePositionAnimated(1); + last_user_activity = 0; + break; + case JGE_BTN_UP: + changeFilterAnimated(1); + last_user_activity = 0; + break; + case JGE_BTN_DOWN: + changeFilterAnimated(-1); + last_user_activity = 0; + break; + default: + return false; + } + return true; +} MTGCard * CarouselDeckView::Click(int x, int y) { int n = getCardIndexNextTo(x, y); @@ -132,35 +160,41 @@ MTGCard * CarouselDeckView::Click(int x, int y) } else { - changePosition(n - 2); + changePositionAnimated(n - 2); } } return NULL; } -void CarouselDeckView::changePosition(int offset) +MTGCard *CarouselDeckView::Click() { - mScrollEasing.start((float)offset, (float)(0.3f*abs(offset))); + if(mSlideEasing.finished() && mScrollEasing.finished()) + { + return getActiveCard(); + } + else + { + return NULL; + } +} +void CarouselDeckView::changePositionAnimated(int offset) +{ + if(mScrollEasing.finished()) + mScrollEasing.start((float)offset, (float)(scroll_animation_duration * abs(offset))); last_user_activity = 0; } -void CarouselDeckView::changeFilter(int offset) +void CarouselDeckView::changeFilterAnimated(int offset) { - if(offset < 0) - { - mSlideEasing.start(-2.0f, slide_animation_duration); - } - else if(offset > 0) - { - mSlideEasing.start(2.0f, slide_animation_duration); - } + if(mSlideEasing.finished()) + mSlideEasing.start(2.0f * float(offset), float(slide_animation_duration * abs(offset))); last_user_activity = 0; } MTGCard *CarouselDeckView::getActiveCard() { - return getCardRep(2).card; + return mCards[2].card; } diff --git a/projects/mtg/src/DeckView.cpp b/projects/mtg/src/DeckView.cpp index 14cb4d5be..682b75957 100644 --- a/projects/mtg/src/DeckView.cpp +++ b/projects/mtg/src/DeckView.cpp @@ -35,38 +35,12 @@ void DeckView::Update(float dt) { for(unsigned int i = 0; i < mCards.size(); ++i) { - UpdateCardPosition(mCards[i], i); + UpdateCardPosition(i); } dirtyCardPos = false; } } -bool DeckView::ButtonPressed(Buttons button) -{ - switch(button) - { - case JGE_BTN_LEFT: - changePosition(-1); - last_user_activity = 0; - break; - case JGE_BTN_RIGHT: - changePosition(1); - last_user_activity = 0; - break; - case JGE_BTN_UP: - changeFilter(1); - last_user_activity = 0; - break; - case JGE_BTN_DOWN: - changeFilter(-1); - last_user_activity = 0; - break; - default: - return false; - } - return true; -} - void DeckView::SetDeck(DeckDataWrapper *toShow) { mCurrentDeck = toShow; @@ -80,14 +54,14 @@ DeckDataWrapper* DeckView::deck() return mCurrentDeck; } -void DeckView::SwitchFilter(int delta) +void DeckView::changeFilter(int delta) { unsigned int FilterCount = Constants::NB_Colors + 1; mFilter = (FilterCount + mFilter + delta) % FilterCount; dirtyFilters = true; } -void DeckView::SwitchPosition(int delta) +void DeckView::changePosition(int delta) { for(int i = 0; i < delta; ++i) { @@ -118,16 +92,11 @@ void DeckView::reloadIndexes() } } -DeckView::CardRep& DeckView::getCardRep(unsigned int index) -{ - return mCards[index]; -} - void DeckView::renderCard(int index, int alpha, bool asThumbnail) { WFont * mFont = WResourceManager::Instance()->GetWFont(Fonts::MAIN_FONT); - const CardRep& cardPosition = getCardRep(index); + const CardRep& cardPosition = mCards[index]; if (!cardPosition.card) return; @@ -213,7 +182,7 @@ int DeckView::getCardIndexNextTo(int x, int y) for(unsigned int i = 0; i < mCards.size(); i++) { - const CardRep& cardPosition = getCardRep(i); + const CardRep& cardPosition = mCards[i]; float dx = (x - cardPosition.x); float dy = (y - cardPosition.y); diff --git a/projects/mtg/src/GameStateDeckViewer.cpp b/projects/mtg/src/GameStateDeckViewer.cpp index 7e048775b..90ced365f 100644 --- a/projects/mtg/src/GameStateDeckViewer.cpp +++ b/projects/mtg/src/GameStateDeckViewer.cpp @@ -407,9 +407,8 @@ void GameStateDeckViewer::Update(float dt) case JGE_BTN_RIGHT: case JGE_BTN_UP: case JGE_BTN_DOWN: - if(last_user_activity > 0.2) + if(mView->ButtonPressed(button)) { - mView->ButtonPressed(button); last_user_activity = 0; mStage = STAGE_WAITING; } @@ -443,19 +442,21 @@ void GameStateDeckViewer::Update(float dt) int x, y; if (mEngine->GetLeftClickCoordinates(x, y)) { - last_user_activity = 0; mEngine->LeftClickedProcessed(); - if(mView->Click(x, y) == mView->getActiveCard()) + if(mView->Click(x, y) != NULL) { addRemove(mView->getActiveCard()); } } else { - last_user_activity = 0; - addRemove(mView->getActiveCard()); + if(mView->Click() != NULL) + { + addRemove(mView->getActiveCard()); + } } + last_user_activity = 0; mStage = STAGE_WAITING; break; } @@ -468,17 +469,20 @@ void GameStateDeckViewer::Update(float dt) buildEditorMenu(); break; case JGE_BTN_CTRL: - mStage = STAGE_FILTERS; - if (!filterMenu) + if(!mView->ButtonPressed(JGE_BTN_CTRL)) { - filterMenu = NEW WGuiFilters("Filter by...", NULL); - if (source) - SAFE_DELETE(source); - source = NEW WSrcDeckViewer(myDeck, myCollection); - filterMenu->setSrc(source); - if (mView->deck() != myDeck) source->swapSrc(); + mStage = STAGE_FILTERS; + if (!filterMenu) + { + filterMenu = NEW WGuiFilters("Filter by...", NULL); + if (source) + SAFE_DELETE(source); + source = NEW WSrcDeckViewer(myDeck, myCollection); + filterMenu->setSrc(source); + if (mView->deck() != myDeck) source->swapSrc(); + } + filterMenu->Entering(JGE_BTN_NONE); } - filterMenu->Entering(JGE_BTN_NONE); break; case JGE_BTN_PREV: if (last_user_activity < NO_USER_ACTIVITY_HELP_DELAY) @@ -1527,11 +1531,18 @@ void GameStateDeckViewer::OnScroll(int inXVelocity, int inYVelocity) { //FIXME: this 500 is a bit arbitrary int numCards = (magnitude / 500) % 8; - mView->changePosition(flickRight ? numCards : - numCards); + mView->changePositionAnimated(flickRight ? numCards : - numCards); } } else - mView->changeFilter(flickUp ? 1 : -1); + { + if(abs(inYVelocity) > 300) + { + //FIXME: this 500 is a bit arbitrary + int numFilters = (magnitude / 500); + mView->changeFilterAnimated(flickUp ? numFilters : - numFilters); + } + } last_user_activity = 0; } diff --git a/projects/mtg/src/GridDeckView.cpp b/projects/mtg/src/GridDeckView.cpp index 1f976eab1..cfe750448 100644 --- a/projects/mtg/src/GridDeckView.cpp +++ b/projects/mtg/src/GridDeckView.cpp @@ -7,7 +7,8 @@ const float GridDeckView::card_scale_big = 0.7f; GridDeckView::GridDeckView() : DeckView(16), mCols(8), mRows(2), mScrollOffset(0), mSlideOffset(0), - mScrollEasing(mScrollOffset), mSlideEasing(mSlideOffset), mCurrentSelection(-1) + mScrollEasing(mScrollOffset), mSlideEasing(mSlideOffset), mCurrentSelection(-1), + mButtonMode(false) { } @@ -23,6 +24,7 @@ void GridDeckView::Reset() mScrollEasing.finish(); mCurrentSelection = 0; + mButtonMode = false; DeckView::Reset(); } @@ -35,15 +37,15 @@ void GridDeckView::UpdateViewState(float dt) if(mScrollOffset <= -1.0f) { - SwitchPosition(2); + changePosition(2); + moveSelection(-2, false); mScrollEasing.translate(1.0f); - mCurrentSelection = (mCurrentSelection >= 6) ? mCurrentSelection - 2 : -1; } else if(mScrollOffset >= 1.0f) { - SwitchPosition(-2); + changePosition(-2); + moveSelection(2, false); mScrollEasing.translate(-1.0f); - mCurrentSelection = (mCurrentSelection >= 0 && mCurrentSelection < 10) ? mCurrentSelection + 2 : -1; } dirtyCardPos = true; @@ -56,20 +58,22 @@ void GridDeckView::UpdateViewState(float dt) if(mSlideOffset < -1.0f) { mSlideEasing.translate(2.0f); - SwitchFilter(1); + changeFilter(1); } else if(mSlideOffset > 1.0f) { mSlideEasing.translate(-2.0f); - SwitchFilter(-1); + changeFilter(-1); } dirtyCardPos = true; } } -void GridDeckView::UpdateCardPosition(CardRep &rep, int index) +void GridDeckView::UpdateCardPosition(int index) { + CardRep &rep = mCards[index]; + int col = index / mRows; int row = index % mRows; float colWidth = SCREEN_WIDTH_F / (mCols - 3); @@ -119,7 +123,7 @@ void GridDeckView::Render() { if (WResourceManager::Instance()->IsThreaded()) { - WResourceManager::Instance()->RetrieveCard(getCardRep(i).card, RETRIEVE_THUMB); + WResourceManager::Instance()->RetrieveCard(mCards[i].card, RETRIEVE_THUMB); } renderCard(i, 255, true); } @@ -127,7 +131,7 @@ void GridDeckView::Render() { if (WResourceManager::Instance()->IsThreaded()) { - WResourceManager::Instance()->RetrieveCard(getCardRep(i).card); + WResourceManager::Instance()->RetrieveCard(mCards[i].card); } } } @@ -138,10 +142,50 @@ void GridDeckView::Render() } } +bool GridDeckView::ButtonPressed(Buttons button) +{ + switch(button) + { + case JGE_BTN_LEFT: + if(mButtonMode && mScrollEasing.finished()) moveSelection(-2, true); + else if(!mButtonMode) changePositionAnimated(-1); + last_user_activity = 0; + break; + case JGE_BTN_RIGHT: + if(mButtonMode && mScrollEasing.finished()) moveSelection(2, true); + else if(!mButtonMode) changePositionAnimated(1); + last_user_activity = 0; + break; + case JGE_BTN_UP: + if(mButtonMode && mScrollEasing.finished()) moveSelection(-1, true); + else if(!mButtonMode) changeFilterAnimated(1); + last_user_activity = 0; + break; + case JGE_BTN_DOWN: + if(mButtonMode && mScrollEasing.finished()) moveSelection(1, true); + else if(!mButtonMode) changeFilterAnimated(-1); + last_user_activity = 0; + break; + case JGE_BTN_CTRL: + if(mButtonMode) + { + mButtonMode = false; + dirtyCardPos = true; + mCurrentSelection = -1; + } + else return false; + break; + default: + return false; + } + return true; +} + MTGCard * GridDeckView::Click(int x, int y) { int n = getCardIndexNextTo(x, y); last_user_activity = 0; + mButtonMode = false; if(mScrollEasing.finished() && mSlideEasing.finished()) { //clicked and no animations running @@ -151,11 +195,11 @@ MTGCard * GridDeckView::Click(int x, int y) } else if(n < 4) { - changePosition(-1); + changePositionAnimated(-1); } else if(n >= 12) { - changePosition(1); + changePositionAnimated(1); } else { @@ -167,28 +211,43 @@ MTGCard * GridDeckView::Click(int x, int y) return NULL; } -void GridDeckView::changePosition(int offset) +MTGCard * GridDeckView::Click() { - mScrollEasing.start(-1.0f * offset, scroll_animation_duration * abs(offset)); + if(mScrollEasing.finished() && mSlideEasing.finished()) + { + MTGCard *active = getActiveCard(); + if(active != NULL) + { + return active; + } + else + { + mButtonMode = true; + dirtyCardPos = true; + mCurrentSelection = 4; + } + } + + return NULL; +} + +void GridDeckView::changePositionAnimated(int offset) +{ + if(mScrollEasing.finished()) + mScrollEasing.start(-1.0f * offset, scroll_animation_duration * abs(offset)); last_user_activity = 0; } -void GridDeckView::changeFilter(int offset) +void GridDeckView::changeFilterAnimated(int offset) { - if(offset < 0) - { - mSlideEasing.start(-2.0f, slide_animation_duration); - } - else if(offset > 0) - { - mSlideEasing.start(2.0f, slide_animation_duration); - } + if(mSlideEasing.finished()) + mSlideEasing.start(2.0f * offset, float(slide_animation_duration * abs(offset))); last_user_activity = 0; } MTGCard* GridDeckView::getActiveCard() { - if(mCurrentSelection >= 0 && mCurrentSelection < int(mCards.size())) + if(mCurrentSelection >= 4 && mCurrentSelection < int(mCards.size())-4) { return mCards[mCurrentSelection].card; } @@ -197,3 +256,29 @@ MTGCard* GridDeckView::getActiveCard() return NULL; } } + +void GridDeckView::moveSelection(int offset, bool alignIfOutOfBounds) +{ + mCurrentSelection += offset; + + if(alignIfOutOfBounds) + { + if(mCurrentSelection < 4) + { + changePositionAnimated(-1); + } + else if(mCurrentSelection >= 12) + { + changePositionAnimated(1); + } + } + else + { + if(mCurrentSelection < 4 || mCurrentSelection >= 12) + { + mCurrentSelection = -1; + } + } + + dirtyCardPos = true; +}