Games: Added solitaire

Added a solitaire game. Currently there are graphics missing on some of the cards, but the game is fully functional. Press F12 to show the game-over animation manually.
2025-07-25 21:27:35 +00:00 · 2020-03-09 16:09:22 +01:00 · 2020-03-09 16:09:22 +01:00 · fe5cc7ce68
commit fe5cc7ce68
parent c6e54d2a49
10 changed files with 1240 additions and 0 deletions
--- a/Games/Solitaire/SolitaireWidget.h
+++ b/Games/Solitaire/SolitaireWidget.h
@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2020, Till Mayer <till.mayer@web.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+#include "CardStack.h"
+#include <LibGUI/Painter.h>
+#include <LibGUI/Widget.h>
+
+class SolitaireWidget final : public GUI::Widget {
+    C_OBJECT(SolitaireWidget)
+public:
+    static constexpr int width = 640;
+    static constexpr int height = 480;
+
+    virtual ~SolitaireWidget() override;
+    void setup();
+
+private:
+    SolitaireWidget(GUI::Window&, Function<void(uint32_t)>&& on_score_update);
+
+    class Animation {
+    public:
+        Animation()
+        {
+        }
+
+        Animation(RefPtr<Card> animation_card, float gravity, int x_vel, float bouncyness)
+            : m_animation_card(animation_card)
+            , m_gravity(gravity)
+            , m_x_velocity(x_vel)
+            , m_bouncyness(bouncyness)
+        {
+        }
+
+        Card* card() { return m_animation_card; }
+
+        void tick()
+        {
+            ASSERT(!m_animation_card.is_null());
+            m_y_velocity += m_gravity;
+
+            if (m_animation_card->position().y() + Card::height + m_y_velocity > SolitaireWidget::height + 1
+                && m_y_velocity > 0) {
+                m_y_velocity = min((m_y_velocity * -m_bouncyness), -8.f);
+                m_animation_card->rect().set_y(SolitaireWidget::height - Card::height);
+                m_animation_card->rect().move_by(m_x_velocity, 0);
+            } else {
+                m_animation_card->rect().move_by(m_x_velocity, m_y_velocity);
+            }
+        }
+
+    private:
+        RefPtr<Card> m_animation_card;
+        float m_gravity { 0 };
+        int m_x_velocity { 0 };
+        float m_y_velocity { 0 };
+        float m_bouncyness { 0 };
+    };
+
+    enum StackLocation {
+        Stock,
+        Waste,
+        Foundation1,
+        Foundation2,
+        Foundation3,
+        Foundation4,
+        Pile1,
+        Pile2,
+        Pile3,
+        Pile4,
+        Pile5,
+        Pile6,
+        Pile7,
+        __Count
+    };
+
+    void mark_intersecting_stacks_dirty(Card& intersecting_card);
+    void update_score(int to_add);
+    void move_card(CardStack& from, CardStack& to);
+    void start_game_over_animation();
+    void stop_game_over_animation();
+    void create_new_animation_card();
+    void check_for_game_over();
+    void tick(GUI::Window&);
+
+    inline CardStack& stack(StackLocation location)
+    {
+        return m_stacks[location];
+    }
+
+    virtual void paint_event(GUI::PaintEvent&) override;
+    virtual void mousedown_event(GUI::MouseEvent&) override;
+    virtual void mouseup_event(GUI::MouseEvent&) override;
+    virtual void mousemove_event(GUI::MouseEvent&) override;
+    virtual void doubleclick_event(GUI::MouseEvent&) override;
+    virtual void keydown_event(GUI::KeyEvent&) override;
+
+    RefPtr<Core::Timer> m_timer;
+    NonnullRefPtrVector<Card> m_focused_cards;
+    Animation m_animation;
+    CardStack* m_focused_stack { nullptr };
+    CardStack m_stacks[StackLocation::__Count];
+    Gfx::Point m_mouse_down_location;
+    bool m_mouse_down { false };
+    bool m_repaint_all { true };
+    bool m_has_to_repaint { true };
+    bool m_game_over_animation { false };
+    uint32_t m_score { 0 };
+    Function<void(uint32_t)> m_on_score_update;
+};