glimmer-dsl-swt 4.18.2.3 → 4.18.3.2

data/samples/elaborate/tetris.rb

@@ -24,79 +24,134 @@
 require_relative 'tetris/model/game'
 
 require_relative 'tetris/view/playfield'
+require_relative 'tetris/view/score_lane'
+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
+  FONT_NAME = 'Menlo'
+  FONT_TITLE_HEIGHT = 32
+  FONT_TITLE_STYLE = :bold
+  
+  option :playfield_width, default: Model::Game::PLAYFIELD_WIDTH
+  option :playfield_height, default: Model::Game::PLAYFIELD_HEIGHT
+  
+  attr_reader :game
   
   before_body {
-    Model::Game.configure_beeper do
+    @mutex = Mutex.new
+    @game = Model::Game.new(playfield_width, playfield_height)
+        
+    @game.configure_beeper do
       display.beep
     end
     
-    Model::Game.start
-    
+    Display.app_name = 'Glimmer Tetris'
     display {
-      on_swt_keydown { |key_event|
-        unless Model::Game.current_tetromino.stopped?
-          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)
-            if key_event.keyLocation == swt(:right) # right shift key
-              Model::Game.current_tetromino.rotate(:right)
-            elsif key_event.keyLocation == swt(:left) # left shift key
-              Model::Game.current_tetromino.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)
+      @keyboard_listener = on_swt_keydown { |key_event|
+        case key_event.keyCode
+        when swt(:arrow_down), 's'.bytes.first
+          game.down!
+        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
+            game.rotate!(:right)
+          elsif key_event.keyLocation == swt(:left) # left shift key
+            game.rotate!(:left)
           end
+        when swt(:arrow_up)
+          game.rotate!(:right)
+        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
+      }
     }
   }
   
   after_body {
-    Thread.new {
-      loop {
-        sleep(0.9)
-        sync_exec {
-          unless @game_over
-            Model::Game.current_tetromino.down
-            if Model::Game.current_tetromino.stopped? && Model::Game.current_tetromino.row <= 0
-              @game_over = true
-              display.beep
-              message_box(:icon_error) {
-                text 'Tetris'
-                message 'Game Over!'
-              }.open
-              Model::Game.restart
-              @game_over = false
-            end
-            Model::Game.consider_adding_tetromino
-          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
+    @game.start!
   }
   
   body {
     shell(:no_resize) {
+      grid_layout {
+        num_columns 2
+        make_columns_equal_width false
+        margin_width 0
+        margin_height 0
+        horizontal_spacing 0
+      }
+
       text 'Glimmer Tetris'
+      minimum_size 475, 500
       background :gray
-      
-      playfield(playfield_width: PLAYFIELD_WIDTH, playfield_height: PLAYFIELD_HEIGHT, block_size: BLOCK_SIZE)
+
+      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 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
+  end
 end
 
 Tetris.launch

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

@@ -31,8 +31,9 @@ class Tetris
         @color = color
       end
       
+      # Clears block color. `quietly` option indicates if it should not notify observers by setting value quietly via variable not attribute writer.
       def clear
-        self.color = COLOR_CLEAR
+        self.color = COLOR_CLEAR unless self.color == COLOR_CLEAR
       end
       
       def clear?
@@ -45,4 +46,3 @@ class Tetris
     end
   end
 end
-

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

@@ -19,98 +19,260 @@
 # 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
-      class << self
-        def consider_adding_tetromino
-          if tetrominoes.empty? || Game.current_tetromino.stopped?
-            tetrominoes << Tetromino.new
-          end
-        end
-        
-        def current_tetromino
-          tetrominoes.last
-        end
+      PLAYFIELD_WIDTH = 10
+      PLAYFIELD_HEIGHT = 20
+      PREVIEW_PLAYFIELD_WIDTH = 4
+      PREVIEW_PLAYFIELD_HEIGHT = 2
+      SCORE_MULTIPLIER = {1 => 40, 2 => 100, 3 => 300, 4 => 1200}
+      
+      attr_reader :playfield_width, :playfield_height
+      attr_accessor :game_over, :paused, :preview_tetromino, :lines, :score, :level, :high_scores, :beeping, :added_high_score
+      alias game_over? game_over
+      alias paused? paused
+      alias beeping? beeping
+      alias added_high_score? added_high_score
+      
+      def initialize(playfield_width = PLAYFIELD_WIDTH, playfield_height = PLAYFIELD_HEIGHT)
+        @playfield_width = playfield_width
+        @playfield_height = playfield_height
+        @high_scores = []
+        @beeping = true
+        load_high_scores!
+      end
+    
+      def configure_beeper(&beeper)
+        @beeper = beeper
+      end
+      
+      def game_in_progress?
+        !game_over? && !paused?
+      end
+      
+      def start!
+        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))
+      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 tetrominoes
-          @tetrominoes ||= reset_tetrominoes
+      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 ||= 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!
+        return unless game_in_progress?
+        current_tetromino.down!
+        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 consider_eliminating_lines
-          cleared_line = false
-          playfield.each_with_index do |row, playfield_row|
-            if row.all? {|block| !block.clear?}
-              cleared_line = true
-              shift_blocks_down_above_row(playfield_row)
-            end
+        }
+      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_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 reset_tetrominoes
+        @tetrominoes = []
+      end
+      
+      def reset_playfield
+        playfield.each do |row|
+          row.each do |block|
+            block.clear
           end
-          beep if cleared_line
-        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
-             end
+      end
+      
+      def reset_preview_playfield
+        preview_playfield.each do |row|
+          row.each do |block|
+            block.clear
           end
-          playfield[0].each(&:clear)
-        end
-        
-        def restart
-          reset_playfield
-          reset_tetrominoes
         end
-        alias start restart
-        
-        def reset_tetrominoes
-          @tetrominoes = [Tetromino.new]
+      end
+      
+      def consider_adding_tetromino
+        if tetrominoes.empty? || current_tetromino.stopped?
+          preview_tetromino.launch!
+          preview_next_tetromino!
         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 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? ||
-                tetromino.bottom_block_for_column(playfield_column).nil? ||
-                (playfield_row > tetromino.row + tetromino.bottom_block_for_column(playfield_column)[:row])
-              )
-            end || [nil, PLAYFIELD_HEIGHT])[1]
-          end.to_a
+        if eliminated_lines > 0
+          beep
+          self.lines += eliminated_lines
+          level_up!
+          calculate_score!(eliminated_lines)
+        end
+      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
+      
+      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
-