Merge branch 'master' into wp8

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:

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<CardRep> 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_

projects/mtg/include/Easing.h

@@ -95,7 +95,7 @@ public:
      */
     void update(float dt)
     {
-        if(duration > 0)
+        if(time_acc < duration)
         {
             time_acc += dt;
 
@@ -167,6 +167,50 @@ public:
     }
 };
 
+/*! \brief This class defines an easing with quadratic acceleration
+ */
+class InQuadEasing : public Easing
+{
+public:
+    /*! \brief Calls Easing::Easing(val).
+     *
+     * \see Easing::Easing(float& val)
+     */
+    InQuadEasing(float& val): Easing(val) {}
+
+    /*! \brief Implements the value calculation.
+     *
+     * \see Easing::updateValue()
+     */
+    void updateValue()
+    {
+        float time_tmp = time_acc / duration;
+        value = delta_value * time_tmp * time_tmp + start_value;
+    }
+};
+
+/*! \brief This class defines an easing with quadratic decceleration
+ */
+class OutQuadEasing : public Easing
+{
+public:
+    /*! \brief Calls Easing::Easing(val).
+     *
+     * \see Easing::Easing(float& val)
+     */
+    OutQuadEasing(float& val): Easing(val) {}
+
+    /*! \brief Implements the value calculation.
+     *
+     * \see Easing::updateValue()
+     */
+    void updateValue()
+    {
+        float time_tmp = time_acc / duration;
+        value = (-delta_value) * time_tmp * (time_tmp - 2.0f) + start_value;
+    }
+};
+
 /*! \brief This class defines an easing with quadratic acceleration and decceleration.
  */
 class InOutQuadEasing : public Easing

projects/mtg/include/GameStateShop.h

@@ -65,7 +65,6 @@ private:
     JQuadPtr pspIcons[8];
     WSrcCards * srcCards;
     TaskList * taskList;
-    float mElapsed;
     WGuiMenu * shopMenu;
     WGuiFilters * filterMenu; //Filter menu slides in sideways from right, or up from bottom.
     WGuiCardImage * bigDisplay;

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

projects/mtg/include/GuiPhaseBar.h

@@ -4,15 +4,25 @@
 #include "GuiLayers.h"
 #include "PhaseRing.h"
 #include "WEvent.h"
+#include "PlayGuiObject.h"
+
+#include "Easing.h"
 
 class GuiPhaseBar: public GuiLayer, public PlayGuiObject
 {
-protected:
-    Phase* phase;
+private:
+    static const float zoom_big;
+    static const float zoom_small;
+    static const float step;
+
+    int displayedPhaseId;
     float angle;
     float zoomFactor;
-	DuelLayers* mpDuelLayers;
+    OutQuadEasing angleEasing;
+    InOutQuadEasing zoomFactorEasing;
+    DuelLayers* mpDuelLayers;
 
+    void DrawGlyph(JQuad *inQuad, int phaseId, float x, float y, float scale);
 public:
     GuiPhaseBar(DuelLayers* duelLayers);
     ~GuiPhaseBar();

projects/mtg/include/Tasks.h

@@ -2,8 +2,15 @@
 #define TASK_H
 
 #include <vector>
+#include <string>
+
+#include "Easing.h"
+
+using namespace std;
 
 class GameObserver;
+class JQuad;
+class JTexture;
 
 // Task type constant
 
@@ -72,8 +79,11 @@ class TaskList
 {
 protected:
     string fileName;
+
     float vPos;
-    float mElapsed;
+    OutQuadEasing vPosInEasing;
+    InQuadEasing vPosOutEasing;
+
     int mState;
     JQuad * mBg[9];
     JTexture * mBgTex;
@@ -97,7 +107,6 @@ public:
     {
         return mState;
     }
-    ;
     void addTask(string params, bool rand = false);
     void addTask(Task *task);
     void addRandomTask(int diff = 100);