rb2048 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bfd2e7bd56a12fbf552193b69014f17be9d094cadc5c2b31932693697d0a5bc9
+  data.tar.gz: d2558a8b1c94f5e98c66ccca187e0172deca3db52e72e514afdc6ae79deae21c
+SHA512:
+  metadata.gz: 3054b8b701af938df0200407eac694447aa8526b828d93aa3bfee2f908a5e34d8657b48003eeed74cadad0b144e5b1a1a99ffa9b45c738d50150e10eea08fe00
+  data.tar.gz: 43215747406b1805eada7ccff358ce3495ff3343011f16990b10c1e5e4e30c61fcab834e0fc51643dbad26553253069612fa85adae83c5a406884b358495c209

data/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in rb2048.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+gem "minitest", "~> 5.0"

data/Gemfile.lock

@@ -0,0 +1,26 @@
+PATH
+  remote: .
+  specs:
+    rb2048 (1.0.0)
+      curses (~> 1.4.4)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    curses (1.4.4)
+    minitest (5.16.2)
+    rake (13.0.6)
+
+PLATFORMS
+  arm64-darwin-21
+  ruby
+  x86_64-darwin
+  x86_64-linux
+
+DEPENDENCIES
+  minitest (~> 5.0)
+  rake (~> 13.0)
+  rb2048!
+
+BUNDLED WITH
+   2.3.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Mark24
+
+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.

data/README.md

@@ -0,0 +1,55 @@
+# Rb2048
+
+Ruby 2048 Game
+
+
+## Install
+
+`gem install rb2048`
+
+## Help
+
+```
+Usage: rb2048 [options]
+        --version                    verison
+        --size SIZE                  Size of board: 4-10
+        --level LEVEL                Hard Level 2-5
+```
+## Game Screen
+
+```
+
+           -- Ruby 2048 --
+
+ -------------------------------------
+ |    16  |    16  |     2  |    16  |
+ -------------------------------------
+ |     0  |     0  |     0  |     0  |
+ -------------------------------------
+ |     0  |     0  |     0  |     2  |
+ -------------------------------------
+ |     0  |     0  |     0  |     0  |
+ -------------------------------------
+
+ Score: 16              You:UP
+
+
+
+ Control: W(↑) A(←) S(↓) D(→) Q(quit) R(Restart)
+```
+
+## Game Model Lightspot
+
+Not just a main thread to create TUI Game.
+
+This is a experiment for just testing Ruby3 Thread & Queue.
+
+I build this game that UserI/O, Data Computing, TUI Render use 3 different threads & message channel to work together.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Mark24Code/rb2048.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task default: %i[test]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "rb2048"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/rb2048

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require_relative "../lib/rb2048"
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: rb2048 [options]"
+
+  opts.on("--version", "verison") do |v|
+    # optins[:verison] = v
+    puts "Ruby2048: v#{::Rb2048::VERSION}"
+    puts "author: Mark24"
+    puts "mail: mark.zhangyoung@qq.com"
+    puts "project: https://github.com/Mark24Code/rb2048"
+    return
+  end
+
+  opts.on("--size SIZE", Integer, "Size of board: 4-10") do |size|
+    if size < 4
+      puts "--size too small,it should in [4,10].Then will use size=4 as default"
+      sleep 1
+    elsif size > 10
+      puts "--size too small,it should in [4,10].It will use size=10."
+      sleep 1
+    end
+    options[:size] = size
+  end
+
+  opts.on("--level LEVEL", Integer, "Hard Level 2-5") do |level|
+    if level < 2
+      puts "--level too small,it should in [2,5].Then will use level=2 as default"
+      sleep 1
+    elsif level > 5
+      puts "--level too small,it should in [2,5].It will use size=5."
+      sleep 1
+    end
+    options[:level] = level
+  end
+
+end.parse!
+
+init_size = options[:size] || 4
+init_level = options[:level] || 2
+
+::Rb2048::Game.new(nil,init_size,init_level).run

data/lib/rb2048/game.rb

@@ -0,0 +1,212 @@
+require "curses"
+require_relative './game_board'
+require "thread"
+require_relative './logger'
+
+
+trap("INT") { ::Rb2048::Game.quit_game; exit 0 }
+
+module Rb2048
+  class Game
+
+    def self.quit_game
+      Curses.close_screen
+      printf "Goodbye :P \n"
+    end
+
+    def initialize(init_elements = nil, size=4, level=2)
+      @logger = LoggerMan
+      
+      @level = level
+      @size = size 
+
+      @render = ::Rb2048::GameRender.new
+      @window = @render.window
+
+      @frame_data_channel = Queue.new
+      @refresh_rate = 60
+      @frame_delta = 1.0 / @refresh_rate
+
+      @io_data_channel = Queue.new
+      
+      init_game(init_elements)      
+    end
+
+    def run
+      init_game
+      main_loop
+    end
+
+    def init_game(init_elements=nil)
+      @backend = ::Rb2048::GameBoard.new(@size,@level)
+      @backend.create_elements(init_elements)
+
+      @logger.log("INIT", "start")
+      @frame_data_channel << @backend.tun_result
+    end
+
+    def main_loop
+      key_listener_thr = Thread.new { self.key_listener }
+      action_thr = Thread.new { self.action }
+      render_thr = Thread.new { self.render }
+
+      [key_listener_thr,action_thr, render_thr].map(&:join)
+    end
+
+    def action
+      while (command = @io_data_channel.shift)
+        if command == :QUIT
+          self.class.quit_game
+          exit 0
+        elsif command == :RESTART
+          self.init_game
+        else
+          @backend.__send__("#{command.to_s.downcase}_merge")
+          frame_data = @backend.tun_result
+          @frame_data_channel << frame_data
+        end
+      end
+
+    end
+
+    def key_listener()
+      while true
+        command = nil
+
+        k = @window.getch
+        if k ==  Curses::KEY_UP || k ==  "w"
+          command =  :UP
+        elsif k ==  Curses::KEY_DOWN || k ==  "s"
+          command =  :DOWN
+        elsif k ==  Curses::KEY_LEFT || k ==  "a"
+          command =  :LEFT
+        elsif k ==  Curses::KEY_RIGHT || k ==  "d"
+          command =  :RIGHT
+        elsif k ==  "q"
+          command = :QUIT
+        elsif k == "r"
+          command = :RESTART
+        else
+        end
+
+        @io_data_channel << command if command
+        sleep 0.08
+      end
+    end
+
+    def render
+      while (frame_data = @frame_data_channel.shift)
+        break if frame_data == :done
+        @render.draw(frame_data) if frame_data
+        sleep 0.16
+      end
+    end
+  end
+
+  class GameRender
+    attr :window
+    def initialize
+      @window = nil
+      @window_height = nil
+      @window_width = nil
+
+      init_screen
+    end
+
+    def init_screen
+      Curses.init_screen
+      Curses.cbreak
+      Curses.noecho
+      Curses.curs_set(0)  # Invisible cursor
+      Curses.stdscr.keypad = true
+
+      @window_height = Curses.lines
+      @window_width = Curses.cols
+
+      @window = Curses::Window.new(@window_height, @window_width, 0, 0)
+      @window.refresh
+    end
+
+    def draw(payload)
+      data = payload[:data]
+      size = payload[:size]
+
+      level = payload[:level]
+      score = payload[:score]
+      last_action = payload[:last_action]
+      status = payload[:status]
+
+      start_timestamp = payload[:start_timestamp]
+      end_timestamp = payload[:end_timestamp]
+
+      tun_new_value = payload[:tun_new_value]
+
+      @window.clear
+
+      # display board content buffer
+      buffer = []
+      number_width = score.to_s.length * 2
+      for row_index in (0..size-1)
+        row_text = "|"
+        for col_index in (0..size-1)
+
+          n = data[row_index][col_index]
+          n_text = " "*(number_width - n.to_s.length) + n.to_s
+          row_text +=" "*2+"#{n_text}"+" "*2+"|"
+        end
+        buffer.push(row_text)
+      end
+
+      # x,y offset counter
+      row,col = [0,1]
+
+      # title
+      content_width = buffer.first.length
+      title = "-- Ruby 2048 --"
+      left_offset = (content_width - title.length) / 2
+      row = row + 1
+      @window.setpos(row, left_offset)
+      @window.addstr("-- Ruby 2048 --")
+
+      # board
+      row = row + 2
+      start_row, start_col = [row,1]
+      @window.setpos(start_row, start_col)
+      @window.addstr("-"*buffer.first.length)
+      buffer.each_with_index do |line,index|
+        @window.setpos(start_row+index*2 + 2, start_col)
+        @window.addstr("-" * line.length)
+        @window.setpos(start_row+index*2 + 1, start_col)
+        @window.addstr(line)
+      end
+
+      # score
+      row = row + buffer.length * 2 + 2
+      @window.setpos(row, col)
+      @window.addstr("Score:\t#{score}\t\t#{"You:"+last_action.to_s if last_action}")
+
+      # status
+
+      row = row + 2
+      @window.setpos(row, col)
+      result_text = nil
+      if status == 1
+        result_text = "Congratulation! You have got 2048!!! :D"
+      elsif status == -1
+        result_text = "YOU LOST :("
+      end
+
+      if result_text
+        left_offset = (buffer.first.length - result_text.length )/2
+        @window.setpos(row, left_offset)
+        @window.addstr(result_text)
+      end
+
+      # control
+      row = row + 2
+      @window.setpos(row, col)
+      @window.addstr("Control: W(↑) A(←) S(↓) D(→) Q(quit) R(Restart)")
+      @window.refresh
+    end
+  end
+end

data/lib/rb2048/game_board.rb

@@ -0,0 +1,291 @@
+require_relative './logger'
+
+module Rb2048
+  class GameBoard
+    attr :elements, :status
+    def initialize(size=4, level = 2,win_standard=2048)
+      @size = size
+      @elements = []
+
+      @level = level
+      @score = 0
+      @start_timestamp = nil
+      @end_timestamp = nil
+      @status = 0 # -1 lost, 0 init/running, 1 win
+      @win_standard = win_standard
+
+      @last_action = nil
+      @logger = LoggerMan
+    end
+
+    def create_init_value
+      total_count = @size ** 2
+      init_value_count = total_count * @level / 10
+      zero_value_count = total_count - init_value_count
+
+      values = []
+      for i in (0..init_value_count-1)
+        values.push(rand_init)
+      end
+
+      for i in (0..zero_value_count-1)
+        values.push(0)
+      end
+
+      values.shuffle
+    end
+
+    def create_elements(init_elements = nil)
+      pos_values = init_elements || create_init_value
+
+      max_nums = @size - 1
+      for i in (0..max_nums)
+        row = []
+        for j in (0..max_nums)
+          row.push(pos_values[i*@size+j])
+        end
+        @elements.push(row)
+      end
+      @elements
+    end
+
+    def bigger_then_zero(arr)
+      arr.filter { |e| e > 0}
+    end
+
+    def left_merge
+      @logger.log("Left", @elements)
+      for row_index in (0..@size-1)
+        row = @elements[row_index]
+        update_row = update_line(row)
+        @elements[row_index] = update_row
+      end
+      @last_action = :LEFT
+      @elements
+    end
+
+    def right_merge
+      @logger.log("Right", @elements)
+      for row_index in (0..@size-1)
+        row = @elements[row_index]
+        update_row = update_line(row.reverse)
+        @elements[row_index] = update_row.reverse
+      end
+      @last_action = :RIGHT
+      @elements
+    end
+
+
+    def up_merge
+      @logger.log("UP", @elements)
+      for col_index in (0..@size-1)
+        col = []
+        for row_index in (0..@size-1)
+          col.push(@elements[row_index][col_index])
+        end
+        update_col = update_line(col)
+
+        for row_index in (0..@size-1)
+          @elements[row_index][col_index] = update_col[row_index]
+        end
+      end
+      @last_action = :UP
+      @elements
+    end
+
+    def down_merge
+      @logger.log("Down", @elements)
+      for col_index in (0..@size-1)
+        col = []
+        for row_index in (0..@size-1)
+          col.push(@elements[row_index][col_index])
+        end
+
+        update_col = update_line(col.reverse).reverse
+        # update
+        for row_index in (0..@size-1)
+          @elements[row_index][col_index] = update_col[row_index]
+        end
+      end
+      @last_action = :DOWN
+      @elements
+    end
+
+    def merge_once(arr)
+
+      if arr.length <= 1
+        return arr
+      end
+
+      data = arr.clone
+      result = []
+      first = nil
+      next_ = nil
+
+      while !data.empty?
+        if first == nil
+          first = data.shift
+        end
+
+        if next_ == nil
+          next_ = data.shift
+        end
+
+        if first != next_
+          result.push(first)
+          if next_
+            data.unshift(next_)
+          end
+          first = nil
+          next_ = nil
+        else
+          result.push(first + next_)
+
+          first = nil
+          next_ = nil
+        end
+      end
+
+      return result
+    end
+
+    def collect_max_score(result)
+      max_ = result.max
+      if max_
+        @score = @score > result.max ? @score : result.max
+      end
+    end
+
+    def merge(arr)
+      if arr.length <= 0
+         return arr
+      end
+      result = arr.clone
+
+      while true
+        before = result.clone
+        result = merge_once(result)
+        break if before == result
+      end
+
+      return result
+    end
+
+    def create_zero_array(len)
+      Array.new(len,0)
+    end
+
+    def update_line(arr)
+      size = arr.length
+      compact = merge(bigger_then_zero(arr))
+      collect_max_score(compact)
+      compact.concat(create_zero_array(size - compact.length))
+    end
+
+    def start_timer
+      @start_timestamp = Time.now.to_i
+    end
+
+    def close_timer
+      @end_timestamp = Time.now.to_i
+    end
+
+    def check_dead_road
+      dead_road = @size * 2
+
+      for row_index in (0..@size-1)
+        row = @elements[row_index]
+        before = bigger_then_zero(row).clone
+        after = merge(before)
+        if before == after
+          dead_road -= 1
+        end
+      end
+
+      for col_index in (0..@size-1)
+        col = []
+        for row_index in (0..@size-1)
+          col.push(@elements[row_index][col_index])
+        end
+
+        before = bigger_then_zero(col).clone
+        after = merge(before)
+        if before == after
+          dead_road -= 1
+        end
+      end
+
+      dead_road
+    end
+
+    def check_game_status
+      if @score >= @win_standard
+        return @status = 1
+      else
+        if all_zero_pos.length == 0
+          dead_road = check_dead_road
+          if dead_road <= 0
+            @status = -1
+          end
+        end
+      end
+    end
+
+    def rand_init
+      2 ** rand(1..4)
+    end
+
+    def create_new_number
+      zeros = all_zero_pos
+      if zeros.length > 0
+        x,y = zeros.sample
+        new_number = rand_init
+        @elements[x][y] = new_number
+        {pos:[x,y], value: new_number}
+      end
+
+      return nil
+    end
+
+    def all_zero_pos
+      zeros = []
+      for i in (0..@size-1)
+        for j in (0..@size-1)
+          e = @elements[i][j]
+          if e == 0
+            zeros.push([i,j])
+          end
+        end
+      end
+
+      zeros
+    end
+
+    def tun_result
+      tun_new_value = create_new_number
+
+      check_game_status
+
+      data = []
+      for i in (0..@elements.length-1)
+        row = []
+        for j in (0..@elements.length-1)
+          row.push(@elements[i][j])
+        end
+        data.push(row)
+      end
+
+      return {
+        data: data,
+        size: @size,
+        level: @level,
+        score: @score,
+        last_action: @last_action,
+        start_timestamp: @start_timestamp,
+        end_timestamp: @end_timestamp,
+        status: @status,
+        tun_new_value: tun_new_value
+      }
+    end
+  end
+end

data/lib/rb2048/logger.rb

@@ -0,0 +1,21 @@
+class Logger
+  def initialize(switch)
+    @switch = switch
+    if @switch == :on
+     @output = File.absolute_path("#{__dir__}/../../log")
+     @f = File.open("#{@output}/#{Time.now.to_s}.log","w+")
+    end
+  end
+
+  def log(component, info)
+    @f << "[#{component}]: #{Time.now.to_s}: #{info}\n" if @switch == :on
+  end
+
+  def close
+    @f.close if @switch == :on
+  end
+end
+
+LoggerMan = Logger.new(:off)
+
+at_exit { LoggerMan.close }

data/lib/rb2048/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rb2048
+  VERSION = "1.0.0"
+end

data/lib/rb2048.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "./rb2048/version"
+
+module Rb2048
+  class Error < StandardError; end
+
+  class InvalidValue < StandardError;end
+  # Your code goes here...
+end
+
+require_relative "./rb2048/game"

data/sig/rb2048.rbs

@@ -0,0 +1,4 @@
+module Rb2048
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: rb2048
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Mark24
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-07-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: curses
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.4
+description: 2048 command line game build by ruby.
+email:
+- mark.zhangyoung@qq.com
+executables:
+- rb2048
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/rb2048
+- lib/rb2048.rb
+- lib/rb2048/game.rb
+- lib/rb2048/game_board.rb
+- lib/rb2048/logger.rb
+- lib/rb2048/version.rb
+- sig/rb2048.rbs
+homepage: https://github.com/Mark24Code/rb2048
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Mark24Code/rb2048
+  source_code_uri: https://github.com/Mark24Code/rb2048
+  changelog_uri: https://github.com/Mark24Code/rb2048
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: Ruby Command line 2048 game
+test_files: []