glimmer-dsl-swt 4.18.2.3 → 4.18.3.2

data/samples/elaborate/tetris/model/past_game.rb

@@ -0,0 +1,26 @@
+# Copyright (c) 2007-2021 Andy Maleh
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+class Tetris
+  module Model
+    PastGame = Struct.new(:name, :score)
+  end
+end

data/samples/elaborate/tetris/model/tetromino.rb

@@ -38,16 +38,32 @@ class Tetris
         Z: :red,
       }
       
-      attr_reader :letter
+      attr_reader :game, :letter, :preview
+      alias preview? preview
       attr_accessor :orientation, :blocks, :row, :column
       
-      def initialize
+      def initialize(game)
+        @game = game
         @letter = LETTER_COLORS.keys.sample
         @orientation = :north
         @blocks = default_blocks
+        @preview = true
+        new_row = 0
+        new_column = (Model::Game::PREVIEW_PLAYFIELD_WIDTH - width)/2
+        update_playfield(new_row, new_column)
+      end
+      
+      def playfield
+        @preview ? game.preview_playfield : game.playfield
+      end
+      
+      def launch!
+        remove_from_playfield
+        @preview = false
         new_row = 1 - height
-        new_column = (PLAYFIELD_WIDTH - width)/2
+        new_column = (game.playfield_width - width)/2
         update_playfield(new_row, new_column)
+        game.tetrominoes << self
       end
       
       def update_playfield(new_row = nil, new_column = nil)
@@ -61,58 +77,103 @@ class Tetris
       
       def add_to_playfield
         update_playfield_block do |playfield_row, playfield_column, row_index, column_index|
-          Game.playfield[playfield_row][playfield_column].color = blocks[row_index][column_index].color if playfield_row >= 0 && Game.playfield[playfield_row][playfield_column].clear? && !blocks[row_index][column_index].clear?
+          playfield[playfield_row][playfield_column].color = blocks[row_index][column_index].color if playfield_row >= 0 && playfield[playfield_row][playfield_column]&.clear? && !blocks[row_index][column_index].clear? && playfield[playfield_row][playfield_column].color != blocks[row_index][column_index].color
         end
       end
       
       def remove_from_playfield
         return if @row.nil? || @column.nil?
         update_playfield_block do |playfield_row, playfield_column, row_index, column_index|
-          Game.playfield[playfield_row][playfield_column].clear if playfield_row >= 0 && !blocks[row_index][column_index].clear? && Game.playfield[playfield_row][playfield_column].color == color
+          playfield[playfield_row][playfield_column].clear if playfield_row >= 0 && !blocks[row_index][column_index].clear? && playfield[playfield_row][playfield_column]&.color == color
         end
       end
       
-      def stopped?(blocks: nil)
-        blocks ||= @blocks
-        playfield_remaining_heights = Game.playfield_remaining_heights(self)
-        result = bottom_blocks(blocks).any? do |bottom_block|
-          playfield_column = @column + bottom_block[:column_index]
-          !bottom_block[:block].clear? &&
-            (@row + bottom_block[:row]) >= playfield_remaining_heights[playfield_column] - 1
+      def stopped?
+        return true if @stopped || @preview
+        playfield_remaining_heights = game.playfield_remaining_heights(self)
+        result = bottom_most_blocks.any? do |bottom_most_block|
+          playfield_column = @column + bottom_most_block[:column_index]
+            playfield_remaining_heights[playfield_column] &&
+            @row + bottom_most_block[:row] >= playfield_remaining_heights[playfield_column] - 1
+        end
+        if result && !game.hypothetical?
+          @stopped = result
+          game.consider_eliminating_lines
+          @game.consider_adding_tetromino
         end
-        Game.consider_eliminating_lines if result
         result
       end
       
-      # Returns blocks at the bottom of a tetromino, which could be from multiple rows depending on shape (e.g. T)
-      def bottom_blocks(blocks = nil)
-        blocks ||= @blocks
+      # Returns bottom-most blocks of a tetromino, which could be from multiple rows depending on shape (e.g. T)
+      def bottom_most_blocks
         width.times.map do |column_index|
           row_blocks_with_row_index = @blocks.each_with_index.to_a.reverse.detect do |row_blocks, row_index|
             !row_blocks[column_index].clear?
           end
-          bottom_block = row_blocks_with_row_index[0][column_index]
-          bottom_block_row = row_blocks_with_row_index[1]
+          bottom_most_block = row_blocks_with_row_index[0][column_index]
+          bottom_most_block_row = row_blocks_with_row_index[1]
           {
-            block: bottom_block,
-            row: bottom_block_row,
+            block: bottom_most_block,
+            row: bottom_most_block_row,
             column_index: column_index
           }
         end
       end
       
-      def bottom_block_for_column(column)
-        bottom_blocks.detect {|bottom_block| (@column + bottom_block[:column_index]) == column}
+      def bottom_most_block_for_column(column)
+        bottom_most_blocks.detect {|bottom_most_block| (@column + bottom_most_block[:column_index]) == column}
       end
       
       def right_blocked?
-        (@column == PLAYFIELD_WIDTH - width) || Game.playfield[row][column + width].occupied?
+        (@column == game.playfield_width - width) ||
+          right_most_blocks.any? { |right_most_block|
+            (@row + right_most_block[:row_index]) >= 0 &&
+              playfield[@row + right_most_block[:row_index]][@column + right_most_block[:column_index] + 1].occupied?
+          }
       end
       
-      def left_blocked?
-        (@column == 0) || Game.playfield[row][column - 1].occupied?
+      # Returns right-most blocks of a tetromino, which could be from multiple columns depending on shape (e.g. T)
+      def right_most_blocks
+        @blocks.each_with_index.map do |row_blocks, row_index|
+          column_block_with_column_index = row_blocks.each_with_index.to_a.reverse.detect do |column_block, column_index|
+            !column_block.clear?
+          end
+          if column_block_with_column_index
+            right_most_block = column_block_with_column_index[0]
+            {
+              block: right_most_block,
+              row_index: row_index,
+              column_index: column_block_with_column_index[1]
+            }
+          end
+        end.compact
       end
       
+      def left_blocked?
+        (@column == 0) ||
+          left_most_blocks.any? { |left_most_block|
+            (@row + left_most_block[:row_index]) >= 0 &&
+              playfield[@row + left_most_block[:row_index]][@column + left_most_block[:column_index] - 1].occupied?
+          }
+      end
+
+      # Returns right-most blocks of a tetromino, which could be from multiple columns depending on shape (e.g. T)
+      def left_most_blocks
+        @blocks.each_with_index.map do |row_blocks, row_index|
+          column_block_with_column_index = row_blocks.each_with_index.to_a.detect do |column_block, column_index|
+            !column_block.clear?
+          end
+          if column_block_with_column_index
+            left_most_block = column_block_with_column_index[0]
+            {
+              block: left_most_block,
+              row_index: row_index,
+              column_index: column_block_with_column_index[1]
+            }
+          end
+        end.compact
+      end
+            
       def width
         @blocks[0].size
       end
@@ -121,21 +182,22 @@ class Tetris
         @blocks.size
       end
       
-      def down
+      def down!
+        launch! if preview?
         unless stopped?
           new_row = @row + 1
           update_playfield(new_row, @column)
         end
       end
       
-      def left
+      def left!
         unless left_blocked?
           new_column = @column - 1
           update_playfield(@row, new_column)
         end
       end
       
-      def right
+      def right!
         unless right_blocked?
           new_column = @column + 1
           update_playfield(@row, new_column)
@@ -143,21 +205,43 @@ class Tetris
       end
       
       # Rotate in specified direcation, which can be :right (clockwise) or :left (counterclockwise)
-      def rotate(direction)
+      def rotate!(direction)
         return if stopped?
-        array_rotation_value = direction == :right ? -1 : 1
-        self.orientation = ORIENTATIONS[ORIENTATIONS.rotate(array_rotation_value).index(@orientation)]
+        can_rotate = nil
+        new_blocks = nil
+        game.hypothetical do
+          hypothetical_rotated_tetromino = hypothetical_tetromino
+          new_blocks = hypothetical_rotated_tetromino.rotate_blocks(direction)
+          can_rotate = !hypothetical_rotated_tetromino.stopped? && !hypothetical_rotated_tetromino.right_blocked? && !hypothetical_rotated_tetromino.left_blocked?
+        end
+        if can_rotate
+          remove_from_playfield
+          self.orientation = ORIENTATIONS[ORIENTATIONS.rotate(direction == :right ? -1 : 1).index(@orientation)]
+          self.blocks = new_blocks
+          update_playfield(@row, @column)
+        end
+      rescue => e
+        puts e.full_message
+      end
+      
+      def rotate_blocks(direction)
         new_blocks = Matrix[*@blocks].transpose.to_a
         if direction == :right
           new_blocks = new_blocks.map(&:reverse)
         else
           new_blocks = new_blocks.reverse
         end
-        new_blocks = Matrix[*new_blocks].to_a
-        unless stopped?(blocks: new_blocks) || right_blocked? || left_blocked?
+        Matrix[*new_blocks].to_a
+      end
+      
+      def hypothetical_tetromino
+        clone.tap do |hypo_clone|
           remove_from_playfield
-          self.blocks = new_blocks
-          update_playfield(@row, @column)
+          hypo_clone.blocks = @blocks.map do |row_blocks|
+            row_blocks.map do |column_block|
+              column_block.clone
+            end
+          end
         end
       end
       
@@ -204,6 +288,10 @@ class Tetris
         LETTER_COLORS[@letter]
       end
       
+      def include_block?(block)
+        @blocks.flatten.include?(block)
+      end
+      
       private
       
       def block

data/samples/elaborate/tetris/view/block.rb

@@ -24,19 +24,44 @@ class Tetris
     class Block
       include Glimmer::UI::CustomWidget
   
-      options :block_size, :row, :column
+      options :game_playfield, :block_size, :row, :column
+  
+      before_body {
+        @bevel_constant = 20
+      }
   
       body {
-        composite {
+        canvas {
           layout nil
-          layout_data {
-            width_hint block_size
-            height_hint block_size
+          background bind(game_playfield[row][column], :color)
+          polygon(0, 0, block_size, 0, block_size - 4, 4, 4, 4, fill: true) {
+            background bind(game_playfield[row][column], :color) { |color_value|
+              color = color(color_value)
+              rgb(color.red + 4*@bevel_constant, color.green + 4*@bevel_constant, color.blue + 4*@bevel_constant)
+            }
+          }
+          polygon(block_size, 0, block_size - 4, 4, block_size - 4, block_size - 4, block_size, block_size, fill: true) {
+            background bind(game_playfield[row][column], :color) { |color_value|
+              color = color(color_value)
+              rgb(color.red - @bevel_constant, color.green - @bevel_constant, color.blue - @bevel_constant)
+            }
+          }
+          polygon(block_size, block_size, 0, block_size, 4, block_size - 4, block_size - 4, block_size - 4, fill: true) {
+            background bind(game_playfield[row][column], :color) { |color_value|
+              color = color(color_value)
+              rgb(color.red - 2*@bevel_constant, color.green - 2*@bevel_constant, color.blue - 2*@bevel_constant)
+            }
+          }
+          polygon(0, 0, 0, block_size, 4, block_size - 4, 4, 4, fill: true) {
+            background bind(game_playfield[row][column], :color) { |color_value|
+              color = color(color_value)
+              rgb(color.red - @bevel_constant, color.green - @bevel_constant, color.blue - @bevel_constant)
+            }
           }
-          background bind(Model::Game.playfield[row][column], :color)
-          rectangle(0, 0, block_size, block_size)
-          rectangle(3, 3, block_size - 6, block_size - 6) {
-            foreground :gray
+          rectangle(0, 0, block_size, block_size) {
+            foreground bind(game_playfield[row][column], :color) { |color_value|
+              color_value == Model::Block::COLOR_CLEAR ? :gray : color_value
+            }
           }
         }
       }

data/samples/elaborate/tetris/view/high_score_dialog.rb

@@ -0,0 +1,114 @@
+# Copyright (c) 2007-2021 Andy Maleh
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require_relative 'tetris_menu_bar'
+
+class Tetris
+  module View
+    class HighScoreDialog
+      include Glimmer::UI::CustomShell
+  
+      options :parent_shell, :game
+      
+      after_body {
+        @game_over_observer = observe(game, :game_over) do |game_over|
+          close if !game_over
+        end
+      }
+      
+      body {
+        dialog(parent_shell) {
+          row_layout {
+            type :vertical
+            center true
+          }
+          text 'Tetris'
+          
+          tetris_menu_bar(game: game)
+          
+          label(:center) {
+            text bind(game, :game_over) {|game_over| game_over ? 'Game Over!' : 'High Scores'}
+            font name: FONT_NAME, height: FONT_TITLE_HEIGHT, style: FONT_TITLE_STYLE
+          }
+          @high_score_table = table {
+            layout_data {
+              height 100
+            }
+            
+            table_column {
+              text 'Name'
+            }
+            table_column {
+              text 'Score'
+            }
+            
+            items bind(game, :high_scores), column_properties(:name, :score)
+          }
+          composite {
+            row_layout :horizontal
+                        
+            button {
+              text 'Clear'
+              
+              on_widget_selected {
+                game.clear_high_scores!
+              }
+            }
+            @play_close_button = button {
+              text bind(game, :game_over) {|game_over| game_over ? 'Play Again?' : 'Close'}
+              focus true # initial focus
+              
+              on_widget_selected {
+                close
+                game.restart! if game.game_over?
+              }
+            }
+          }
+          
+          on_swt_show {
+            if game.game_over? && game.added_high_score?
+              game.added_high_score = false
+              @high_score_table.edit_table_item(
+                @high_score_table.items.first, # row item
+                0, # column
+                after_write: -> {
+                  game.save_high_scores!
+                  @play_close_button.set_focus
+                },
+                after_cancel: -> {
+                  @play_close_button.set_focus
+                },
+              )
+            end
+          }
+          
+          on_shell_closed {
+            @high_score_table.cancel_edit!
+          }
+          
+          on_widget_disposed {
+            @game_over_observer.deregister
+          }
+        }
+      }
+    end
+  end
+end

data/samples/elaborate/tetris/view/playfield.rb

@@ -26,20 +26,27 @@ class Tetris
     class Playfield
       include Glimmer::UI::CustomWidget
   
-      options :playfield_width, :playfield_height, :block_size
+      options :game_playfield, :playfield_width, :playfield_height, :block_size
   
       body {
-        composite {
-          grid_layout(playfield_width, true) {
+        canvas {
+          grid_layout {
+            num_columns playfield_width
+            make_columns_equal_width true
             margin_width block_size
             margin_height block_size
             horizontal_spacing 0
             vertical_spacing 0
           }
-          
+
           playfield_height.times { |row|
             playfield_width.times { |column|
-              block(block_size: block_size, row: row, column: column)
+              block(game_playfield: game_playfield, block_size: block_size, row: row, column: column) {
+                layout_data {
+                  width_hint block_size
+                  height_hint block_size
+                }
+              }
             }
           }
         }