glimmer-dsl-swt 4.18.2.5 → 4.18.3.4

data/samples/elaborate/tetris.rb

@@ -25,60 +25,88 @@ require_relative 'tetris/model/game'
 
 require_relative 'tetris/view/playfield'
 require_relative 'tetris/view/score_lane'
-require_relative 'tetris/view/game_over_dialog'
+require_relative 'tetris/view/high_score_dialog'
+require_relative 'tetris/view/tetris_menu_bar'
 
 class Tetris
   include Glimmer::UI::CustomShell
   
   BLOCK_SIZE = 25
-  PLAYFIELD_WIDTH = 10
-  PLAYFIELD_HEIGHT = 20
-  PREVIEW_PLAYFIELD_WIDTH = 4
-  PREVIEW_PLAYFIELD_HEIGHT = 2
+  FONT_NAME = 'Menlo'
+  FONT_TITLE_HEIGHT = 32
+  FONT_TITLE_STYLE = :bold
+  BEVEL_CONSTANT = 20
+  
+  option :playfield_width, default: Model::Game::PLAYFIELD_WIDTH
+  option :playfield_height, default: Model::Game::PLAYFIELD_HEIGHT
+  
+  attr_reader :game
   
   before_body {
+    @mutex = Mutex.new
+    @game = Model::Game.new(playfield_width, playfield_height)
+        
+    @game.configure_beeper do
+      display.beep
+    end
+    
+    Display.app_name = 'Glimmer Tetris'
     display {
-      on_swt_keydown { |key_event|
+      @keyboard_listener = on_swt_keydown { |key_event|
         case key_event.keyCode
-        when swt(:arrow_down)
-          Model::Game.current_tetromino.down
-        when swt(:arrow_left)
-          Model::Game.current_tetromino.left
-        when swt(:arrow_right)
-          Model::Game.current_tetromino.right
-        when swt(:shift)
+        when swt(:arrow_down), 's'.bytes.first
+          game.down!
+        when swt(:arrow_up)
+          case game.up_arrow_action
+          when :instant_down
+            game.down!(instant: true)
+          when :rotate_right
+            game.rotate!(:right)
+          when :rotate_left
+            game.rotate!(:left)
+          end
+        when swt(:arrow_left), 'a'.bytes.first
+          game.left!
+        when swt(:arrow_right), 'd'.bytes.first
+          game.right!
+        when swt(:shift), swt(:alt)
           if key_event.keyLocation == swt(:right) # right shift key
-            Model::Game.current_tetromino.rotate(:right)
+            game.rotate!(:right)
           elsif key_event.keyLocation == swt(:left) # left shift key
-            Model::Game.current_tetromino.rotate(:left)
+            game.rotate!(:left)
           end
-        when 'd'.bytes.first, swt(:arrow_up)
-          Model::Game.current_tetromino.rotate(:right)
-        when 'a'.bytes.first
-          Model::Game.current_tetromino.rotate(:left)
+        when swt(:ctrl)
+          game.rotate!(:left)
         end
       }
+      
+      # if running in app mode, set the Mac app about dialog (ignored in platforms)
+      @about_observer = on_about {
+        show_about_dialog
+      }
+      
+      @quit_observer = on_quit {
+        exit(0)
+      }
     }
-    
-    Model::Game.configure_beeper do
-      display.beep
-    end
   }
   
   after_body {
-    Model::Game.start
-    
-    Thread.new {
-      loop {
-        sleep(Model::Game.delay)
-        sync_exec {
-          unless Model::Game.game_over?
-            Model::Game.current_tetromino.down
-            game_over_dialog(parent_shell: body_root).open if Model::Game.current_tetromino.row <= 0 && Model::Game.current_tetromino.stopped?
-          end
-        }
-      }
-    }
+    @game_over_observer = observe(@game, :game_over) do |game_over|
+      if game_over
+        show_high_score_dialog
+      else
+        start_moving_tetrominos_down
+      end
+    end
+    @show_high_scores_observer = observe(@game, :show_high_scores) do |show_high_scores|
+      if show_high_scores
+        show_high_score_dialog
+      else
+        @high_score_dialog.close unless @high_score_dialog.nil? || @high_score_dialog.disposed? || !@high_score_dialog.visible?
+      end
+    end
+    @game.start!
   }
   
   body {
@@ -92,15 +120,91 @@ class Tetris
       }
       
       text 'Glimmer Tetris'
-      background :gray
-            
-      playfield(game_playfield: Model::Game.playfield, playfield_width: PLAYFIELD_WIDTH, playfield_height: PLAYFIELD_HEIGHT, block_size: BLOCK_SIZE)
-      
-      score_lane(block_size: BLOCK_SIZE) {
-        layout_data(:fill, :fill, false, true)
+      minimum_size 475, 500
+      image tetris_icon
+
+      tetris_menu_bar(game: game)
+
+      playfield(game_playfield: game.playfield, playfield_width: playfield_width, playfield_height: playfield_height, block_size: BLOCK_SIZE)
+
+      score_lane(game: game, block_size: BLOCK_SIZE) {
+        layout_data(:fill, :fill, true, true)
+      }
+
+      on_widget_disposed {
+        deregister_observers
       }
     }
   }
+  
+  def tetris_icon
+    icon_block_size = 64
+    icon_bevel_size = icon_block_size.to_f / 25.to_f
+    icon_bevel_pixel_size = 0.16*icon_block_size.to_f
+    icon_size = 8
+    icon_pixel_size = icon_block_size * icon_size
+    image(icon_pixel_size, icon_pixel_size) {
+      icon_size.times { |row|
+        icon_size.times { |column|
+          colored = row >= 1 && column.between?(1, 6)
+          color = colored ? color(([:white] + Model::Tetromino::LETTER_COLORS.values).sample) : color(:white)
+          x = column * icon_block_size
+          y = row * icon_block_size
+          rectangle(x, y, icon_block_size, icon_block_size, fill: true) {
+            background color
+          }
+          polygon(x, y, x + icon_block_size, y, x + icon_block_size - icon_bevel_pixel_size, y + icon_bevel_pixel_size, x + icon_bevel_pixel_size, y + icon_bevel_pixel_size, fill: true) {
+            background rgb(color.red + 4*BEVEL_CONSTANT, color.green + 4*BEVEL_CONSTANT, color.blue + 4*BEVEL_CONSTANT)
+          }
+          polygon(x + icon_block_size, y, x + icon_block_size - icon_bevel_pixel_size, y + icon_bevel_pixel_size, x + icon_block_size - icon_bevel_pixel_size, y + icon_block_size - icon_bevel_pixel_size, x + icon_block_size, y + icon_block_size, fill: true) {
+            background rgb(color.red - BEVEL_CONSTANT, color.green - BEVEL_CONSTANT, color.blue - BEVEL_CONSTANT)
+          }
+          polygon(x + icon_block_size, y + icon_block_size, x, y + icon_block_size, x + icon_bevel_pixel_size, y + icon_block_size - icon_bevel_pixel_size, x + icon_block_size - icon_bevel_pixel_size, y + icon_block_size - icon_bevel_pixel_size, fill: true) {
+            background rgb(color.red - 2*BEVEL_CONSTANT, color.green - 2*BEVEL_CONSTANT, color.blue - 2*BEVEL_CONSTANT)
+          }
+          polygon(x, y, x, y + icon_block_size, x + icon_bevel_pixel_size, y + icon_block_size - icon_bevel_pixel_size, x + icon_bevel_pixel_size, y + icon_bevel_pixel_size, fill: true) {
+            background rgb(color.red - BEVEL_CONSTANT, color.green - BEVEL_CONSTANT, color.blue - BEVEL_CONSTANT)
+          }
+        }
+      }
+    }
+  end
+  
+  def start_moving_tetrominos_down
+    Thread.new do
+      @mutex.synchronize do
+        loop do
+          time = Time.now
+          sleep @game.delay
+          break if @game.game_over? || body_root.disposed?
+          sync_exec {
+            @game.down! unless @game.paused?
+          }
+        end
+      end
+    end
+  end
+  
+  def show_high_score_dialog
+    return if @high_score_dialog&.visible?
+    @high_score_dialog = high_score_dialog(parent_shell: body_root, game: @game) if @high_score_dialog.nil? || @high_score_dialog.disposed?
+    @high_score_dialog.show
+  end
+  
+  def show_about_dialog
+    message_box {
+      text 'Glimmer Tetris'
+      message "Glimmer Tetris\n\nGlimmer DSL for SWT Sample\n\nCopyright (c) 2007-2021 Andy Maleh"
+    }.open
+  end
+  
+  def deregister_observers
+    @show_high_scores_observer&.deregister
+    @game_over_observer&.deregister
+    @keyboard_listener&.deregister
+    @about_observer&.deregister
+    @quit_observer&.deregister
+  end
 end
 
 Tetris.launch

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

@@ -19,167 +19,288 @@
 # 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 'fileutils'
+require 'etc'
+require 'glimmer/data_binding/observer'
+require 'glimmer/config'
+
 require_relative 'block'
 require_relative 'tetromino'
+require_relative 'past_game'
 
 class Tetris
   module Model
     class Game
+      PLAYFIELD_WIDTH = 10
+      PLAYFIELD_HEIGHT = 20
+      PREVIEW_PLAYFIELD_WIDTH = 4
+      PREVIEW_PLAYFIELD_HEIGHT = 2
       SCORE_MULTIPLIER = {1 => 40, 2 => 100, 3 => 300, 4 => 1200}
       
-      class << self
-        attr_accessor :game_over, :preview_tetromino, :lines, :score, :level
-        alias game_over? game_over
-        
-        def consider_adding_tetromino
-          if tetrominoes.empty? || Game.current_tetromino.stopped?
-            preview_tetromino.launch!
-            preview_next_tetromino!
-          end
-        end
-        
-        def current_tetromino
-          tetrominoes.last
-        end
+      attr_reader :playfield_width, :playfield_height
+      attr_accessor :game_over, :paused, :preview_tetromino, :lines, :score, :level, :high_scores, :beeping, :added_high_score, :show_high_scores, :up_arrow_action
+      alias game_over? game_over
+      alias paused? paused
+      alias beeping? beeping
+      alias added_high_score? added_high_score
       
-        def tetrominoes
-          @tetrominoes ||= reset_tetrominoes
+      def initialize(playfield_width = PLAYFIELD_WIDTH, playfield_height = PLAYFIELD_HEIGHT)
+        @playfield_width = playfield_width
+        @playfield_height = playfield_height
+        @high_scores = []
+        @show_high_scores = false
+        @beeping = true
+        @up_arrow_action = :instant_down
+        load_high_scores!
+      end
+      
+      def configure_beeper(&beeper)
+        @beeper = beeper
+      end
+      
+      def game_in_progress?
+        !game_over? && !paused?
+      end
+      
+      def start!
+        self.show_high_scores = false
+        self.paused = false
+        self.level = 1
+        self.score = 0
+        self.lines = 0
+        reset_playfield
+        reset_preview_playfield
+        reset_tetrominoes
+        preview_next_tetromino!
+        consider_adding_tetromino
+        self.game_over = false
+      end
+      alias restart! start!
+      
+      def game_over!
+        add_high_score!
+        beep
+        self.game_over = true
+      end
+      
+      def clear_high_scores!
+        high_scores.clear
+      end
+      
+      def add_high_score!
+        self.added_high_score = true
+        high_scores.prepend(PastGame.new("Player #{high_scores.count + 1}", score, lines, level))
+      end
+      
+      def save_high_scores!
+        high_score_file_content = @high_scores.map {|past_game| past_game.to_a.join("\t") }.join("\n")
+        FileUtils.mkdir_p(tetris_dir)
+        File.write(tetris_high_score_file, high_score_file_content)
+      rescue => e
+        # Fail safely by keeping high scores in memory if unable to access disk
+        Glimmer::Config.logger.error {"Failed to save high scores in: #{tetris_high_score_file}\n#{e.full_message}"}
+      end
+      
+      def load_high_scores!
+        if File.exist?(tetris_high_score_file)
+          self.high_scores = File.read(tetris_high_score_file).split("\n").map {|line| PastGame.new(*line.split("\t")) }
         end
-        
-        # Returns blocks in the playfield
-        def playfield
-          @playfield ||= @original_playfield = PLAYFIELD_HEIGHT.times.map {
-            PLAYFIELD_WIDTH.times.map {
-              Block.new
-            }
+      rescue => e
+        # Fail safely by keeping high scores in memory if unable to access disk
+        Glimmer::Config.logger.error {"Failed to load high scores from: #{tetris_high_score_file}\n#{e.full_message}"}
+      end
+      
+      def tetris_dir
+        @tetris_dir ||= File.join(Etc.getpwuid.dir, '.glimmer-tetris')
+      end
+      
+      def tetris_high_score_file
+        File.join(tetris_dir, "high_scores.txt")
+      end
+      
+      def down!(instant: false)
+        return unless game_in_progress?
+        current_tetromino.down!(instant: instant)
+        game_over! if current_tetromino.row <= 0 && current_tetromino.stopped?
+      end
+      
+      def right!
+        return unless game_in_progress?
+        current_tetromino.right!
+      end
+      
+      def left!
+        return unless game_in_progress?
+        current_tetromino.left!
+      end
+      
+      def rotate!(direction)
+        return unless game_in_progress?
+        current_tetromino.rotate!(direction)
+      end
+      
+      def current_tetromino
+        tetrominoes.last
+      end
+    
+      def tetrominoes
+        @tetrominoes ||= reset_tetrominoes
+      end
+      
+      # Returns blocks in the playfield
+      def playfield
+        @playfield ||= @original_playfield = @playfield_height.times.map {
+          @playfield_width.times.map {
+            Block.new
           }
-        end
-        
-        def hypothetical(&block)
-          @playfield = hypothetical_playfield
-          block.call
-          @playfield = @original_playfield
-        end
-        
-        def hypothetical?
-          @playfield != @original_playfield
-        end
-        
-        def hypothetical_playfield
-          PLAYFIELD_HEIGHT.times.map { |row|
-            PLAYFIELD_WIDTH.times.map { |column|
-              playfield[row][column].clone
-            }
+        }
+      end
+      
+      # Executes a hypothetical scenario without truly changing playfield permanently
+      def hypothetical(&block)
+        @playfield = hypothetical_playfield
+        block.call
+        @playfield = @original_playfield
+      end
+      
+      # Returns whether currently executing a hypothetical scenario
+      def hypothetical?
+        @playfield != @original_playfield
+      end
+      
+      def hypothetical_playfield
+        @playfield_height.times.map { |row|
+          @playfield_width.times.map { |column|
+            playfield[row][column].clone
           }
-        end
-        
-        def preview_playfield
-          @preview_playfield ||= PREVIEW_PLAYFIELD_HEIGHT.times.map {|row|
-            PREVIEW_PLAYFIELD_WIDTH.times.map {|column|
-              Block.new
-            }
+        }
+      end
+      
+      def preview_playfield
+        @preview_playfield ||= PREVIEW_PLAYFIELD_HEIGHT.times.map {|row|
+          PREVIEW_PLAYFIELD_WIDTH.times.map {|column|
+            Block.new
           }
-        end
-        
-        def preview_next_tetromino!
-          self.preview_tetromino = Tetromino.new
-        end
-        
-        def calculate_score!(eliminated_lines)
-          new_score = SCORE_MULTIPLIER[eliminated_lines] * (level + 1)
-          self.score += new_score
-        end
-        
-        def level_up!
-          self.level += 1 if lines >= self.level*10
-        end
-        
-        def delay
-          [1.1 - (level.to_i * 0.1), 0.001].max
-        end
-        
-        def consider_eliminating_lines
-          eliminated_lines = 0
-          playfield.each_with_index do |row, playfield_row|
-            if row.all? {|block| !block.clear?}
-              eliminated_lines += 1
-              shift_blocks_down_above_row(playfield_row)
-            end
-          end
-          if eliminated_lines > 0
-            beep
-            self.lines += eliminated_lines
-            level_up!
-            calculate_score!(eliminated_lines)
+        }
+      end
+      
+      def preview_next_tetromino!
+        self.preview_tetromino = Tetromino.new(self)
+      end
+      
+      def calculate_score!(eliminated_lines)
+        new_score = SCORE_MULTIPLIER[eliminated_lines] * (level + 1)
+        self.score += new_score
+      end
+      
+      def level_up!
+        self.level += 1 if lines >= self.level*10
+      end
+      
+      def delay
+        [1.1 - (level.to_i * 0.1), 0.001].max
+      end
+      
+      def beep
+        @beeper&.call if beeping
+      end
+      
+      def instant_down_on_up=(value)
+        self.up_arrow_action = :instant_down if value
+      end
+      
+      def instant_down_on_up
+        self.up_arrow_action == :instant_down
+      end
+      
+      def rotate_right_on_up=(value)
+        self.up_arrow_action = :rotate_right if value
+      end
+      
+      def rotate_right_on_up
+        self.up_arrow_action == :rotate_right
+      end
+      
+      def rotate_left_on_up=(value)
+        self.up_arrow_action = :rotate_left if value
+      end
+      
+      def rotate_left_on_up
+        self.up_arrow_action == :rotate_left
+      end
+      
+      def reset_tetrominoes
+        @tetrominoes = []
+      end
+      
+      def reset_playfield
+        playfield.each do |row|
+          row.each do |block|
+            block.clear
           end
         end
-        
-        def beep
-          @beeper&.call
-        end
-        
-        def configure_beeper(&beeper)
-          @beeper = beeper
-        end
-        
-        def shift_blocks_down_above_row(row)
-          row.downto(0) do |playfield_row|
-             playfield[playfield_row].each_with_index do |block, playfield_column|
-               previous_row = playfield[playfield_row - 1]
-               previous_block = previous_row[playfield_column]
-               block.color = previous_block.color unless block.color == previous_block.color
-             end
+      end
+      
+      def reset_preview_playfield
+        preview_playfield.each do |row|
+          row.each do |block|
+            block.clear
           end
-          playfield[0].each(&:clear)
         end
-        
-        def start
-          self.level = 1
-          self.score = 0
-          self.lines = @previoius_lines = 0
-          reset_playfield
-          reset_preview_playfield
-          reset_tetrominoes
+      end
+      
+      def consider_adding_tetromino
+        if tetrominoes.empty? || current_tetromino.stopped?
+          preview_tetromino.launch!
           preview_next_tetromino!
-          consider_adding_tetromino
-          self.game_over = false
-        end
-        alias restart start
-        
-        def reset_tetrominoes
-          @tetrominoes = []
         end
-        
-        def reset_playfield
-          playfield.each do |row|
-            row.each do |block|
-              block.clear
-            end
+      end
+      
+      def consider_eliminating_lines
+        eliminated_lines = 0
+        playfield.each_with_index do |row, playfield_row|
+          if row.all? {|block| !block.clear?}
+            eliminated_lines += 1
+            shift_blocks_down_above_row(playfield_row)
           end
         end
-        
-        def reset_preview_playfield
-          preview_playfield.each do |row|
-            row.each do |block|
-              block.clear
-            end
-          end
+        if eliminated_lines > 0
+          beep
+          self.lines += eliminated_lines
+          level_up!
+          calculate_score!(eliminated_lines)
         end
-        
-        def playfield_remaining_heights(tetromino = nil)
-          PLAYFIELD_WIDTH.times.map do |playfield_column|
-            (playfield.each_with_index.detect do |row, playfield_row|
-              !row[playfield_column].clear? &&
-              (
-                tetromino.nil? ||
-                (bottom_most_block = tetromino.bottom_most_block_for_column(playfield_column)).nil? ||
-                (playfield_row > tetromino.row + bottom_most_block[:row])
-              )
-            end || [nil, PLAYFIELD_HEIGHT])[1]
-          end.to_a
+      end
+            
+      def playfield_remaining_heights(tetromino = nil)
+        @playfield_width.times.map do |playfield_column|
+          bottom_most_block = tetromino.bottom_most_block_for_column(playfield_column)
+          (playfield.each_with_index.detect do |row, playfield_row|
+            !row[playfield_column].clear? &&
+            (
+              tetromino.nil? ||
+              bottom_most_block.nil? ||
+              (playfield_row > tetromino.row + bottom_most_block[:row_index])
+            )
+          end || [nil, @playfield_height])[1]
+        end.to_a
+      end
+      
+      private
+      
+      def shift_blocks_down_above_row(row)
+        row.downto(0) do |playfield_row|
+           playfield[playfield_row].each_with_index do |block, playfield_column|
+             previous_row = playfield[playfield_row - 1]
+             previous_block = previous_row[playfield_column]
+             block.color = previous_block.color unless block.color == previous_block.color
+           end
         end
+        playfield[0].each(&:clear)
       end
+      
     end
+  
   end
+
 end
-