glimmer-dsl-swt 4.20.13.6 → 4.20.13.10

data/samples/elaborate/klondike_solitaire/model/dealt_pile.rb

@@ -0,0 +1,25 @@
+class KlondikeSolitaire
+  module Model
+    class DealtPile
+      def initialize(game)
+        @game = game
+      end
+      
+      def reset!
+        playing_cards.clear
+      end
+    
+      def push!(playing_card)
+        playing_cards.push(playing_card)
+      end
+      
+      def remove!(card)
+        playing_cards.delete(card)
+      end
+      
+      def playing_cards
+        @playing_cards ||= []
+      end
+    end
+  end
+end

data/samples/elaborate/klondike_solitaire/model/foundation_pile.rb

@@ -0,0 +1,40 @@
+class KlondikeSolitaire
+  module Model
+    class FoundationPile
+      attr_reader :suit
+    
+      def initialize(game, suit)
+        @game = game
+        @suit = suit
+        reset!
+      end
+      
+      def reset!
+        playing_cards.clear
+      end
+    
+      # adds a card
+      # validates if it is a card that belongs to the suit
+      def add!(playing_card)
+        if playing_card.suit == suit &&
+          (
+            (playing_cards.empty? && playing_card.rank == 1) ||
+            playing_card.rank == (playing_cards.last.rank + 1)
+          )
+          playing_cards.push(playing_card)
+        else
+          raise "Cannot add #{playing_card} to #{self}"
+        end
+      end
+      
+      def playing_cards
+        @playing_cards ||= []
+      end
+            
+      def to_s
+        "Foundation Pile #{suit} (#{playing_cards.map {|card| "#{card.rank}#{card.suit.to_s[0].upcase}"}.join(" | ")})"
+      end
+      
+    end
+  end
+end

data/samples/elaborate/klondike_solitaire/model/game.rb

@@ -0,0 +1,37 @@
+require_relative 'playing_card'
+require_relative 'dealt_pile'
+require_relative 'dealing_pile'
+require_relative 'column_pile'
+require_relative 'foundation_pile'
+
+class KlondikeSolitaire
+  module Model
+    class Game
+      COLUMN_PILE_COUNT = 7
+        
+      attr_reader :deck, :dealing_pile, :dealt_pile, :column_piles, :foundation_piles
+      
+      def initialize
+        @deck = new_deck
+        @dealt_pile = DealtPile.new(self)
+        @dealing_pile = DealingPile.new(self)
+        @column_piles = COLUMN_PILE_COUNT.times.map {|n| ColumnPile.new(self, n + 1)}
+        @foundation_piles = PlayingCard::SUITS.map {|suit| FoundationPile.new(self, suit)}
+      end
+                  
+      def restart!
+        @deck = new_deck
+        @dealt_pile.reset!
+        @dealing_pile.reset!
+        @column_piles.each(&:reset!)
+        @foundation_piles.each(&:reset!)
+      end
+        
+      private
+      
+      def new_deck
+        PlayingCard.deck.shuffle
+      end
+    end
+  end
+end

data/samples/elaborate/klondike_solitaire/model/playing_card.rb

@@ -0,0 +1,86 @@
+class KlondikeSolitaire
+  module Model
+    class PlayingCard
+      SUITS = [:spades, :hearts, :clubs, :diamonds]
+      BLACK_SUITS = [:spades, :clubs]
+      RED_SUITS = [:hearts, :diamonds]
+      RANK_COUNT = 13
+      
+      class << self
+        def deck
+          suit_decks.flatten
+        end
+        
+        def suit_decks
+          SUITS.map do |suit|
+            suit_deck(suit)
+          end
+        end
+        
+        def suit_deck(suit)
+          1.upto(RANK_COUNT).map do |rank|
+            new(rank, suit)
+          end
+        end
+        
+        def rank_text(rank)
+          case rank
+          when 1
+            'A'
+          when 11
+            'J'
+          when 12
+            'Q'
+          when 13
+            'K'
+          else
+            rank
+          end
+        end
+        
+        def suit_text(suit)
+          case suit
+          when :spades
+            "♠"
+          when :hearts
+            "♥"
+          when :clubs
+            "♣"
+          when :diamonds
+            "♦"
+          end
+        end
+      end
+      
+      attr_reader :rank, :suit
+      attr_accessor :hidden
+      alias hidden? hidden
+      
+      def initialize(rank, suit, hidden = false)
+        @rank = rank
+        @suit = suit
+        @hidden = hidden
+      end
+      
+      def color
+        if BLACK_SUITS.include?(suit)
+          :black
+        elsif RED_SUITS.include?(suit)
+          :red
+        end
+      end
+      
+      def to_s
+        "Playing Card #{rank}#{suit.to_s[0].upcase}"
+      end
+      
+      def suit_text
+        self.class.suit_text(suit)
+      end
+      
+      def rank_text
+        self.class.rank_text(rank)
+      end
+    end
+  end
+end

data/samples/elaborate/klondike_solitaire/view/action_panel.rb

@@ -0,0 +1,30 @@
+class KlondikeSolitaire
+  module View
+    class ActionPanel
+      include Glimmer::UI::CustomWidget
+
+      option :game
+      
+      body {
+        composite {
+          grid_layout(1, false) {
+            margin_width 0
+            margin_height 0
+          }
+          
+          background :dark_green
+          
+          button {
+            layout_data :center, :center, true, false
+            
+            text 'Restart Game'
+            
+            on_widget_selected {
+              game.restart!
+            }
+          }
+        }
+      }
+    end
+  end
+end

data/samples/elaborate/klondike_solitaire/view/column_pile.rb

@@ -0,0 +1,66 @@
+require_relative '../model/column_pile'
+
+require_relative 'playing_card'
+
+class KlondikeSolitaire
+  module View
+    class ColumnPile
+      include Glimmer::UI::CustomShape
+  
+      IMAGE_EMPTY = image(50, 80) {
+        rectangle(0, 0, 50, 80) {
+          background :dark_green
+          
+          rectangle(0, 0, 49, 79, 15, 15) {
+            foreground :gray
+          }
+        }
+      }
+      
+      options :pile_x, :pile_y, :model
+      
+      after_body {
+        observe(model, 'playing_cards.last.hidden') do
+          build_column_pile(model.playing_cards)
+        end
+        build_column_pile(model.playing_cards)
+      }
+      
+      body {
+        shape(pile_x, pile_y) {
+          on_drop do |drop_event|
+            begin
+              card_shape = drop_event.dragged_shape.get_data('custom_shape')
+              card = card_shape.model
+              model.add!(card)
+              card_parent_pile = card_shape.parent_pile
+              card_source_model = card_parent_pile.model
+              cards = card_source_model.remove!(card)
+              if cards.is_a?(Array) # if it is a column pile
+                cards[1..-1].each do |card|
+                  model.add!(card)
+                end
+              end
+              drop_event.dragged_shape.dispose
+            rescue => e
+#               pd e
+              drop_event.doit = false
+            end
+          end
+        }
+      }
+  
+      def build_column_pile(playing_cards)
+        body_root.shapes.to_a.each(&:dispose)
+        current_parent = body_root
+        playing_cards.each_with_index do |card, i|
+          current_parent.content {
+            current_parent = playing_card(card_x: 0, card_y: 20, model: card, parent_pile: self) {
+              drag_source true unless card.hidden?
+            }.body_root
+          }
+        end
+      end
+    end
+  end
+end

data/samples/elaborate/klondike_solitaire/view/dealing_pile.rb

@@ -0,0 +1,36 @@
+require_relative '../model/dealing_pile'
+
+require_relative 'empty_playing_card'
+require_relative 'hidden_playing_card'
+
+class KlondikeSolitaire
+  module View
+    class DealingPile
+      include Glimmer::UI::CustomShape
+      
+      options :pile_x, :pile_y, :model
+      
+      after_body {
+        observe(model, 'playing_cards.empty?') do |empty_value|
+          body_root.shapes.to_a.each(&:dispose)
+          if empty_value
+            body_root.content {
+              empty_playing_card
+            }
+          else
+            body_root.content {
+              hidden_playing_card
+            }
+          end
+        end
+      }
+  
+      body {
+        shape(pile_x, pile_y) {
+          hidden_playing_card
+        }
+      }
+  
+    end
+  end
+end

data/samples/elaborate/klondike_solitaire/view/dealt_pile.rb

@@ -0,0 +1,38 @@
+require_relative '../model/dealt_pile'
+
+require_relative 'empty_playing_card'
+require_relative 'playing_card'
+
+class KlondikeSolitaire
+  module View
+    class DealtPile
+      include Glimmer::UI::CustomShape
+      
+      options :pile_x, :pile_y, :model
+      
+      after_body do
+        observe(model, 'playing_cards.empty?') do |empty_value|
+          if empty_value
+            body_root.shapes.to_a.dup.each(&:dispose)
+            body_root.content {
+              empty_playing_card
+            }
+          else
+            body_root.content {
+              playing_card(model: model.playing_cards.last, parent_pile: self) {
+                drag_source true
+              }
+            }
+          end
+        end
+      end
+  
+      body {
+        shape(pile_x, pile_y) {
+          empty_playing_card
+        }
+      }
+                                
+    end
+  end
+end

data/samples/elaborate/klondike_solitaire/view/empty_playing_card.rb

@@ -0,0 +1,33 @@
+require_relative '../model/playing_card'
+
+class KlondikeSolitaire
+  module View
+    class EmptyPlayingCard
+      include Glimmer::UI::CustomShape
+      
+      options :card_x, :card_y, :suit
+      
+      before_body do
+        self.card_x ||= 0
+        self.card_y ||= 0
+      end
+      
+      body {
+        rectangle(card_x, card_y, 49, 79, 15, 15) {
+          foreground :gray
+          
+          if suit
+            text {
+              string Model::PlayingCard.suit_text(suit)
+              x :default
+              y :default
+              is_transparent true
+              foreground Model::PlayingCard::BLACK_SUITS.include?(suit) ? :black : :red
+            }
+          end
+        }
+      }
+  
+    end
+  end
+end

data/samples/elaborate/klondike_solitaire/view/foundation_pile.rb

@@ -0,0 +1,59 @@
+require_relative '../model/playing_card'
+require_relative '../model/foundation_pile'
+
+class KlondikeSolitaire
+  module View
+    class FoundationPile
+      include Glimmer::UI::CustomShape
+      
+      options :pile_x, :pile_y, :game, :suit
+      
+      attr_accessor :current_image, :model
+      
+      before_body do
+        self.current_image = image(50, 80) {empty_playing_card(suit: suit)}
+        self.model = game.foundation_piles[Model::PlayingCard::SUITS.index(suit)]
+      end
+  
+      after_body do
+        observe(model, 'playing_cards.last') do |last_card|
+          if last_card
+            body_root.content {
+              playing_card(model: last_card)
+            }
+          else
+            body_root.clear_shapes
+            body_root.content {
+              empty_playing_card(suit: suit)
+            }
+          end
+        end
+      end
+      
+      body {
+        shape(pile_x, pile_y) {
+          empty_playing_card(suit: suit)
+          
+          on_drop do |drop_event|
+            begin
+              # TODO make sure one cannot drag a column pile of cards here
+              card_shape = drop_event.dragged_shape.get_data('custom_shape')
+              card = card_shape.model
+              card_parent_pile = card_shape.parent_pile
+              card_source_model = card_parent_pile.model
+              raise 'Cannot accept multiple cards' if card_source_model.playing_cards.index(card) != (card_source_model.playing_cards.size - 1)
+              model.add!(card)
+              card_source_model.remove!(card)
+              drop_event.dragged_shape.dispose
+            rescue => e
+#               pd e
+              drop_event.doit = false
+            end
+          end
+        }
+      }
+    end
+    
+  end
+  
+end