glimmer-dsl-libui 0.2.20 → 0.2.24

data/examples/snake/model/apple.rb

@@ -0,0 +1,33 @@
+class Snake
+  module Model
+    class Apple
+      attr_reader :game
+      attr_accessor :row, :column
+      
+      def initialize(game)
+        @game = game
+      end
+      
+      # generates a new location from scratch or via dependency injection of what cell is (for testing purposes)
+      def generate(initial_row: nil, initial_column: nil)
+        if initial_row && initial_column
+          self.row, self.column = initial_row, initial_column
+        else
+          self.row, self.column = @game.height.times.zip(@game.width.times).reject do |row, column|
+            @game.snake.vertebrae.map {|v| [v.row, v.column]}.include?([row, column])
+          end.sample
+        end
+      end
+      
+      def remove
+        self.row = nil
+        self.column = nil
+      end
+    
+      # inspect is overridden to prevent printing very long stack traces
+      def inspect
+        "#{super[0, 120]}... >"
+      end
+    end
+  end
+end

data/examples/snake/model/game.rb

@@ -0,0 +1,51 @@
+require 'fileutils'
+
+require_relative 'snake'
+require_relative 'apple'
+
+class Snake
+  module Model
+    class Game
+      WIDTH_DEFAULT = 40
+      HEIGHT_DEFAULT = 40
+      FILE_HIGH_SCORE = File.expand_path(File.join(Dir.home, '.glimmer-snake'))
+      
+      attr_reader :width, :height
+      attr_accessor :snake, :apple, :over, :score, :high_score
+      alias over? over
+      
+      def initialize(width = WIDTH_DEFAULT, height = HEIGHT_DEFAULT)
+        @width = width
+        @height = height
+        @snake = Snake.new(self)
+        @apple = Apple.new(self)
+        FileUtils.touch(FILE_HIGH_SCORE)
+        @high_score = File.read(FILE_HIGH_SCORE).to_i rescue 0
+      end
+      
+      def score=(new_score)
+        @score = new_score
+        self.high_score = @score if @score > @high_score
+      end
+      
+      def high_score=(new_high_score)
+        @high_score = new_high_score
+        File.write(FILE_HIGH_SCORE, @high_score.to_s)
+      rescue => e
+        puts e.full_message
+      end
+      
+      def start
+        self.over = false
+        self.score = 0
+        self.snake.generate
+        self.apple.generate
+      end
+      
+      # inspect is overridden to prevent printing very long stack traces
+      def inspect
+        "#{super[0, 75]}... >"
+      end
+    end
+  end
+end

data/examples/snake/model/snake.rb

@@ -0,0 +1,95 @@
+require_relative 'vertebra'
+  
+class Snake
+  module Model
+    class Snake
+      SCORE_EAT_APPLE = 50
+      RIGHT_TURN_MAP = {
+        north: :east,
+        east: :south,
+        south: :west,
+        west: :north
+      }
+      LEFT_TURN_MAP = RIGHT_TURN_MAP.invert
+      
+      attr_accessor :collided
+      alias collided? collided
+      
+      attr_reader :game
+      # vertebrae and joins are ordered from tail to head
+      attr_accessor :vertebrae
+      
+      def initialize(game)
+        @game = game
+      end
+      
+      # generates a new snake location and orientation from scratch or via dependency injection of what head_cell and orientation are (for testing purposes)
+      def generate(initial_row: nil, initial_column: nil, initial_orientation: nil)
+        self.collided = false
+        initial_vertebra = Vertebra.new(snake: self, row: initial_row, column: initial_column, orientation: initial_orientation)
+        self.vertebrae = [initial_vertebra]
+      end
+      
+      def length
+        @vertebrae.length
+      end
+      
+      def head
+        @vertebrae.last
+      end
+      
+      def tail
+        @vertebrae.first
+      end
+      
+      def remove
+        self.vertebrae.clear
+        self.joins.clear
+      end
+      
+      def move
+        @old_tail = tail.dup
+        @new_head = head.dup
+        case @new_head.orientation
+        when :east
+          @new_head.column = (@new_head.column + 1) % @game.width
+        when :west
+          @new_head.column = (@new_head.column - 1) % @game.width
+        when :south
+          @new_head.row = (@new_head.row + 1) % @game.height
+        when :north
+          @new_head.row = (@new_head.row - 1) % @game.height
+        end
+        if @vertebrae.map {|v| [v.row, v.column]}.include?([@new_head.row, @new_head.column])
+          self.collided = true
+          @game.over = true
+        else
+          @vertebrae.append(@new_head)
+          @vertebrae.delete(tail)
+          if head.row == @game.apple.row && head.column == @game.apple.column
+            grow
+            @game.apple.generate
+          end
+        end
+      end
+      
+      def turn_right
+        head.orientation = RIGHT_TURN_MAP[head.orientation]
+      end
+      
+      def turn_left
+        head.orientation = LEFT_TURN_MAP[head.orientation]
+      end
+      
+      def grow
+        @game.score += SCORE_EAT_APPLE
+        @vertebrae.prepend(@old_tail)
+      end
+      
+      # inspect is overridden to prevent printing very long stack traces
+      def inspect
+        "#{super[0, 150]}... >"
+      end
+    end
+  end
+end

data/examples/snake/model/vertebra.rb

@@ -0,0 +1,22 @@
+class Snake
+  module Model
+    class Vertebra
+      ORIENTATIONS = %i[north east south west]
+      # orientation is needed for snake occuppied cells (but not apple cells)
+      attr_reader :snake
+      attr_accessor :row, :column, :orientation
+      
+      def initialize(snake: , row: , column: , orientation: )
+        @row = row || rand(snake.game.height)
+        @column = column || rand(snake.game.width)
+        @orientation = orientation || ORIENTATIONS.sample
+        @snake = snake
+      end
+      
+      # inspect is overridden to prevent printing very long stack traces
+      def inspect
+        "#{super[0, 150]}... >"
+      end
+    end
+  end
+end

data/examples/snake/presenter/cell.rb

@@ -0,0 +1,27 @@
+class Snake
+  module Presenter
+    class Cell
+      COLOR_CLEAR = :white
+      COLOR_SNAKE = :green
+      COLOR_APPLE = :red
+    
+      attr_reader :row, :column, :grid
+      attr_accessor :color
+      
+      def initialize(grid: ,row: ,column: )
+        @row = row
+        @column = column
+        @grid = grid
+      end
+      
+      def clear
+        self.color = COLOR_CLEAR unless color == COLOR_CLEAR
+      end
+      
+      # inspect is overridden to prevent printing very long stack traces
+      def inspect
+        "#{super[0, 150]}... >"
+      end
+    end
+  end
+end

data/examples/snake/presenter/grid.rb

@@ -0,0 +1,47 @@
+require 'glimmer/data_binding/observer'
+require_relative '../model/game'
+require_relative 'cell'
+
+class Snake
+  module Presenter
+    class Grid
+      attr_reader :game, :cells
+      
+      def initialize(game = Model::Game.new)
+        @game = game
+        @cells = @game.height.times.map do |row|
+          @game.width.times.map do |column|
+            Cell.new(grid: self, row: row, column: column)
+          end
+        end
+        Glimmer::DataBinding::Observer.proc do |new_vertebrae|
+          occupied_snake_positions = @game.snake.vertebrae.map {|v| [v.row, v.column]}
+          @cells.each_with_index do |row_cells, row|
+            row_cells.each_with_index do |cell, column|
+              if [@game.apple.row, @game.apple.column] == [row, column]
+                cell.color = Cell::COLOR_APPLE
+              elsif occupied_snake_positions.include?([row, column])
+                cell.color = Cell::COLOR_SNAKE
+              else
+                cell.clear
+              end
+            end
+          end
+        end.observe(@game.snake, :vertebrae)
+      end
+      
+      def clear
+        @cells.each do |row_cells|
+          row_cells.each do |cell|
+            cell.clear
+          end
+        end
+      end
+      
+      # inspect is overridden to prevent printing very long stack traces
+      def inspect
+        "#{super[0, 75]}... >"
+      end
+    end
+  end
+end

data/examples/snake.rb

@@ -0,0 +1,90 @@
+require 'glimmer-dsl-libui'
+require 'glimmer/data_binding/observer'
+
+require_relative 'snake/presenter/grid'
+
+class Snake
+  CELL_SIZE = 15
+  SNAKE_MOVE_DELAY = 0.1
+  include Glimmer
+  
+  def initialize
+    @game = Model::Game.new
+    @grid = Presenter::Grid.new(@game)
+    @game.start
+    create_gui
+    register_observers
+  end
+  
+  def launch
+    @main_window.show
+  end
+  
+  def register_observers
+    @game.height.times do |row|
+      @game.width.times do |column|
+        Glimmer::DataBinding::Observer.proc do |new_color|
+          @cell_grid[row][column].fill = new_color
+        end.observe(@grid.cells[row][column], :color)
+      end
+    end
+    
+    Glimmer::DataBinding::Observer.proc do |game_over|
+      Glimmer::LibUI.queue_main do
+        if game_over
+          msg_box('Game Over!', "Score: #{@game.score} | High Score: #{@game.high_score}")
+          @game.start
+        end
+      end
+    end.observe(@game, :over)
+    
+    Glimmer::LibUI.timer(SNAKE_MOVE_DELAY) do
+      unless @game.over?
+        @game.snake.move
+        @main_window.title = "Glimmer Snake (Score: #{@game.score} | High Score: #{@game.high_score})"
+      end
+    end
+  end
+  
+  def create_gui
+    @cell_grid = []
+    @main_window = window('Glimmer Snake', @game.width * CELL_SIZE, @game.height * CELL_SIZE) {
+      resizable false
+      
+      vertical_box {
+        padded false
+        
+        @game.height.times do |row|
+          @cell_grid << []
+          horizontal_box {
+            padded false
+            
+            @game.width.times do |column|
+              area {
+                @cell_grid.last << path {
+                  square(0, 0, CELL_SIZE)
+                  
+                  fill Presenter::Cell::COLOR_CLEAR
+                }
+                
+                on_key_up do |area_key_event|
+                  orientation_and_key = [@game.snake.head.orientation, area_key_event[:ext_key]]
+                  case orientation_and_key
+                  in [:north, :right] | [:east, :down] | [:south, :left] | [:west, :up]
+                    @game.snake.turn_right
+                  in [:north, :left] | [:west, :down] | [:south, :right] | [:east, :up]
+                    @game.snake.turn_left
+                  else
+                    # No Op
+                  end
+                end
+              }
+            end
+          }
+        end
+      }
+    }
+  end
+end
+
+Snake.new.launch

data/examples/tetris/model/game.rb

@@ -113,7 +113,7 @@ class Tetris
       end
       
       def tetris_dir
-        @tetris_dir ||= File.join(File.expand_path('~'), '.glimmer-tetris')
+        @tetris_dir ||= File.join(Dir.home, '.glimmer-tetris')
       end
       
       def tetris_high_score_file

data/examples/tetris.rb

@@ -153,6 +153,8 @@ class Tetris
         end
       }
       radio_menu_item('Rotate Left on Up Arrow') {
+        checked true
+
         on_clicked do
           @game.rotate_left_on_up = true
         end
@@ -235,7 +237,19 @@ class Tetris
       on_key_down do |key_event|
         case key_event
         in ext_key: :down
-          @game.down!
+          if OS.windows?
+            # rate limit downs in Windows as they go too fast when key is held
+            @queued_downs ||= 0
+            if @queued_downs < 2
+              @queued_downs += 1
+              Glimmer::LibUI.timer(0.01, repeat: false) do
+                @game.down! if @queued_downs < 2
+                @queued_downs -= 1
+              end
+            end
+          else
+            @game.down!
+          end
         in key: ' '
           @game.down!(instant: true)
         in ext_key: :up
@@ -319,8 +333,11 @@ class Tetris
   end
   
   def start_moving_tetrominos_down
-    Glimmer::LibUI.timer(@game.delay) do
-      @game.down! if !@game.game_over? && !@game.paused?
+    unless @tetrominos_start_moving_down
+      @tetrominos_start_moving_down = true
+      Glimmer::LibUI.timer(@game.delay) do
+        @game.down! if !@game.game_over? && !@game.paused?
+      end
     end
   end
   
@@ -333,6 +350,8 @@ class Tetris
   
   def show_high_scores
     Glimmer::LibUI.queue_main do
+      game_paused = !!@game.paused
+      @game.paused = true
       if @game.high_scores.empty?
         high_scores_string = "No games have been scored yet."
       else
@@ -341,6 +360,7 @@ class Tetris
         end.join("\n")
       end
       msg_box('High Scores', high_scores_string)
+      @game.paused = game_paused
     end
   end
   

data/examples/tic_tac_toe/board.rb

@@ -0,0 +1,145 @@
+# 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 'cell'
+
+class TicTacToe
+  class Board
+    DRAW = :draw
+    IN_PROGRESS = :in_progress
+    WIN = :win
+    attr :winning_sign
+    attr_accessor :game_status
+  
+    def initialize
+      @sign_state_machine = {nil => "X", "X" => "O", "O" => "X"}
+      build_grid
+      @winning_sign = Cell::EMPTY
+      @game_status = IN_PROGRESS
+    end
+  
+    #row and column numbers are 1-based
+    def mark(row, column)
+      self[row, column].mark(current_sign)
+      game_over? #updates winning sign
+    end
+  
+    def current_sign
+      @current_sign = @sign_state_machine[@current_sign]
+    end
+  
+    def [](row, column)
+      @grid[row-1][column-1]
+    end
+  
+    def game_over?
+       win? or draw?
+    end
+  
+    def win?
+      win = (row_win? or column_win? or diagonal_win?)
+      self.game_status=WIN if win
+      win
+    end
+  
+    def reset!
+      (1..3).each do |row|
+        (1..3).each do |column|
+          self[row, column].reset!
+        end
+      end
+      @winning_sign = Cell::EMPTY
+      @current_sign = nil
+      self.game_status=IN_PROGRESS
+    end
+  
+    private
+  
+    def build_grid
+      @grid = []
+      3.times do |row_index| #0-based
+        @grid << []
+        3.times { @grid[row_index] << Cell.new }
+      end
+    end
+  
+    def row_win?
+      (1..3).each do |row|
+        if row_has_same_sign(row)
+          @winning_sign = self[row, 1].sign
+          return true
+        end
+      end
+      false
+    end
+  
+    def column_win?
+      (1..3).each do |column|
+        if column_has_same_sign(column)
+          @winning_sign = self[1, column].sign
+          return true
+        end
+      end
+      false
+    end
+  
+    #needs refactoring if we ever decide to make the board size dynamic
+    def diagonal_win?
+      if (self[1, 1].sign == self[2, 2].sign) and (self[2, 2].sign == self[3, 3].sign) and self[1, 1].marked
+        @winning_sign = self[1, 1].sign
+        return true
+      end
+      if (self[3, 1].sign == self[2, 2].sign) and (self[2, 2].sign == self[1, 3].sign) and self[3, 1].marked
+        @winning_sign = self[3, 1].sign
+        return true
+      end
+      false
+    end
+  
+    def draw?
+      @board_full = true
+      3.times do |x|
+        3.times do |y|
+          @board_full = false if self[x, y].empty
+        end
+      end
+      self.game_status = DRAW if @board_full
+      @board_full
+    end
+  
+    def row_has_same_sign(number)
+      row_sign = self[number, 1].sign
+      [2, 3].each do |column|
+        return false unless row_sign == (self[number, column].sign)
+      end
+      true if self[number, 1].marked
+    end
+  
+    def column_has_same_sign(number)
+      column_sign = self[1, number].sign
+      [2, 3].each do |row|
+        return false unless column_sign == (self[row, number].sign)
+      end
+      true if self[1, number].marked
+    end
+  
+  end
+end

data/examples/tic_tac_toe/cell.rb

@@ -0,0 +1,48 @@
+# 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 TicTacToe
+  class Cell
+    EMPTY = ""
+    attr_accessor :sign, :empty
+  
+    def initialize
+      reset!
+    end
+  
+    def mark(sign)
+      self.sign = sign
+    end
+  
+    def reset!
+      self.sign = EMPTY
+    end
+  
+    def sign=(sign_symbol)
+      @sign = sign_symbol
+      self.empty = sign == EMPTY
+    end
+  
+    def marked
+      !empty
+    end
+  end
+end