rb-snake 0.0.1 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d226ce857ed8de1e615d68cbc27d4e4ef6cd136ff154d6a44917dfb4ffd7735f
-  data.tar.gz: 23d3352ff62318377681d43caee10a018fb77ccefcabdac03c416986a5a76041
+  metadata.gz: 529079a6646e1e0bfc700fa65d4a8fe80d01f85c5e3871790797fe628d5b5a07
+  data.tar.gz: 5eb2921b933580848c2c5a7d7a51127ea1b02d64e36b998704477975978261ff
 SHA512:
-  metadata.gz: a32fc0bdf90147f87ca693194ab85537be1b2ded3988ae86cdf609a0ed93211718a2b68cecd2618e85e25928af606f1dcf919e59f4d753204c4c04460f972256
-  data.tar.gz: 601e241bcc4e4bfc51aa8db50b5360047dc50a5969a47b92352e95fc48c1c8dcbeb010b2d54f87da00d4b92f2deced545e1908b9f679b3ea2dd51f6ca0bb23b9
+  metadata.gz: 57b85516859d4bf5ba21ad80ced31eb8d7acaef84fb09b3e15a15629b1e7f4dfc155c6c783462608e5cdf8eb2cba944da9d75c4aab35c7242c80e132e5c78f88
+  data.tar.gz: 4a1262d36a8146d3fdf3937ffd0ae8bca0356eefe2e59bbd98d11ba8f5ba251d5e1774a80f2965c3e5ccee0a997514cfd6f534aa33c59fde8035c7d714bbbf75

data/.rubocop.yml

@@ -2,7 +2,7 @@ require:
   - rubocop-rspec
 
 AllCops:
-  TargetRubyVersion: 3.1.2
+  TargetRubyVersion: 2.6.0
 
 Style/StringLiterals:
   Enabled: true
@@ -14,3 +14,15 @@ Style/StringLiteralsInInterpolation:
 
 Layout/LineLength:
   Max: 120
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 17
+
+Metrics/ParameterLists:
+  Enabled: false
+
+RSpec/MultipleMemoizedHelpers:
+  Enabled: false

data/README.md

@@ -1,22 +1,18 @@
-# Rb::Snake
+# rb-snake
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/rb/snake`. To experiment with that code, run `bin/console` for an interactive prompt.
+This is a Ruby adapted version of the Snake classic game, using [Ruby2d](https://www.ruby2d.com) gem
 
-TODO: Delete this and the text above, and describe your gem
+![](https://i.imgur.com/wC6W4VH.png)
 
 ## Installation
 
-Install the gem and add to the application's Gemfile by executing:
-
-    $ bundle add rb-snake
-
-If bundler is not being used to manage dependencies, install the gem by executing:
+Install the gem
 
     $ gem install rb-snake
 
 ## Usage
 
-TODO: Write usage instructions here
+Run `rb-snake` on your terminal to start the game. Use the arrow keys on the keyboard to move the snake. Try to feed your snake as much as possible without hitting your own body!
 
 ## Development
 

data/bin/rb-snake

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "rb_snake/app"
+
+app = RbSnake::App.new
+app.start

data/lib/rb_snake/actions/change_direction.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "rb_snake/models/direction"
+
+module RbSnake
+  module Actions
+    class ChangeDirection
+      class << self
+        def call(state, new_direction:)
+          return unless valid_direction?(state.current_direction, new_direction)
+
+          state.update_direction(new_direction)
+        end
+
+        private
+
+        def valid_direction?(current_direction, new_direction)
+          case current_direction
+          when RbSnake::Models::Direction::UP
+            !new_direction.eql?(RbSnake::Models::Direction::DOWN)
+          when RbSnake::Models::Direction::DOWN
+            !new_direction.eql?(RbSnake::Models::Direction::UP)
+          when RbSnake::Models::Direction::LEFT
+            !new_direction.eql?(RbSnake::Models::Direction::RIGHT)
+          when RbSnake::Models::Direction::RIGHT
+            !new_direction.eql?(RbSnake::Models::Direction::LEFT)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rb_snake/actions/move_snake.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RbSnake
+  module Actions
+    class MoveSnake
+      class << self
+        def call(state, window)
+          snake = state.snake
+          current_direction = state.current_direction
+          food = state.food
+          grid = state.grid
+
+          make_next_move(snake, current_direction, food, grid, state)
+
+          window.render(state)
+        end
+
+        private
+
+        def make_next_move(snake, current_direction, food, grid, state)
+          next_position = snake.next_position(current_direction, grid)
+          if next_position.eql?(food.location)
+            snake.eat(food)
+            food.regenerate(snake, grid)
+            state.increase_speed if (snake.body.length % 10).zero?
+          elsif snake.body.any? { |body_pos| body_pos.eql?(next_position) }
+            state.finish_game!
+          else
+            snake.move_to(next_position)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rb_snake/app.rb

@@ -1,42 +1,19 @@
 # frozen_string_literal: true
 
-require_relative 'view/ruby2d'
-require_relative 'model/state'
-require_relative 'actions/actions'
+require "rb_snake/models/state"
+require "rb_snake/views/window"
 
-class App
-  def initialize
-    @state = Model.initial_state
-  end
-
-  def start
-    @view = View::Ruby2dView.new(self)
-    timer_thread = Thread.new { init_timer(@view) }
-    @view.start(@state)
-    timer_thread.join
-  end
+module RbSnake
+  class App
+    attr_reader :state, :window
 
-  def init_timer(view)
-    loop do
-      if @state.game_finished
-        puts 'Juego Finalizado'
-        puts "Puntaje: #{@state.snake.positions.length}"
-        break
-      end
-      @state = Actions::move_snake(@state)
-      view.render(@state)
-      sleep 0.1
+    def initialize
+      @state = Models::State.initial_state
     end
-  end
 
-  def send_action(action, params)
-    new_state = Actions.send(action, @state, params)
-    if new_state.hash != @state
-      @state = new_state
-      @view.render(@state)
+    def start
+      @window = Views::Window.new
+      window.start(state)
     end
   end
 end
-
-app = App.new
-app.start

data/lib/rb_snake/models/coordinate.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RbSnake
+  module Models
+    class Coordinate
+      attr_accessor :row, :col
+
+      def initialize(row:, col:)
+        @row = row
+        @col = col
+      end
+
+      def eql?(other)
+        row == other.row && col == other.col
+      end
+    end
+  end
+end

data/lib/rb_snake/models/direction.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RbSnake
+  module Models
+    module Direction
+      UP = :up
+      RIGHT = :right
+      DOWN = :down
+      LEFT = :left
+    end
+  end
+end

data/lib/rb_snake/models/food.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "rb_snake/models/coordinate"
+
+module RbSnake
+  module Models
+    class Food
+      attr_reader :location
+
+      RenderedElement = Struct.new(:elem, :location)
+
+      def initialize(row:, col:)
+        @location = Coordinate.new(row: row, col: col)
+      end
+
+      def render(window)
+        return if rendered_element&.location == location
+
+        window.remove(rendered_element.elem) if rendered_element
+
+        elem = yield(location.row, location.col)
+        @rendered_element = RenderedElement.new(elem, location)
+      end
+
+      def regenerate(snake, grid)
+        loop do
+          new_row = rand(0...grid.rows)
+          new_col = rand(0...grid.cols)
+
+          if snake.body.none? { |position| position.row == new_row && position.col == new_col }
+            @location = Coordinate.new(row: new_row, col: new_col)
+            break
+          end
+        end
+      end
+
+      private
+
+      attr_reader :rendered_element
+    end
+  end
+end

data/lib/rb_snake/models/grid.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RbSnake
+  module Models
+    class Grid
+      attr_reader :rows, :cols
+
+      def initialize(rows:, cols:)
+        @rows = rows
+        @cols = cols
+      end
+    end
+  end
+end

data/lib/rb_snake/models/snake.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "rb_snake/models/direction"
+require "rb_snake/models/coordinate"
+
+module RbSnake
+  module Models
+    class Snake
+      RenderedBodyElem = Struct.new(:elem, :position)
+
+      attr_reader :body
+
+      def initialize(body:)
+        @body = body
+      end
+
+      def render(window, &block)
+        return build_rendered_body(&block) if rendered_body.nil?
+
+        update_last_rendered_position(window)
+        update_first_rendered_position(&block)
+      end
+
+      def next_position(direction, grid)
+        new_row = head.row
+        new_col = head.col
+
+        case direction
+        when Direction::UP
+          new_row -= 1
+        when Direction::RIGHT
+          new_col += 1
+        when Direction::DOWN
+          new_row += 1
+        when Direction::LEFT
+          new_col -= 1
+        else
+          raise StandardError, "direction #{direction} not recognized"
+        end
+
+        new_row = truncate_row(new_row, grid)
+        new_col = truncate_col(new_col, grid)
+
+        Coordinate.new(row: new_row, col: new_col)
+      end
+
+      def eat(food)
+        body.unshift(food.location)
+      end
+
+      def move_to(position)
+        body.unshift(position)
+        body.pop
+      end
+
+      private
+
+      def head
+        body.first
+      end
+
+      def build_rendered_body(&block)
+        @rendered_body = body.map do |position|
+          elem = block.call(position.row, position.col)
+          RenderedBodyElem.new(elem, position)
+        end
+      end
+
+      def update_last_rendered_position(window)
+        return if rendered_body.last.position == body.last
+
+        window.remove(rendered_body.last.elem)
+        rendered_body.pop
+      end
+
+      def update_first_rendered_position(&block)
+        return if rendered_body.first.position == body.first
+
+        new_position = body.first
+        elem = block.call(new_position.row, new_position.col)
+        rendered_body.unshift(RenderedBodyElem.new(elem, new_position))
+      end
+
+      def truncate_row(new_row, grid)
+        return 0 if new_row >= grid.rows
+        return grid.rows - 1 if new_row.negative?
+
+        new_row
+      end
+
+      def truncate_col(new_col, grid)
+        return 0 if new_col >= grid.cols
+        return grid.cols - 1 if new_col.negative?
+
+        new_col
+      end
+
+      attr_reader :rendered_body
+    end
+  end
+end

data/lib/rb_snake/models/state.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "rb_snake/models/coordinate"
+require "rb_snake/models/snake"
+require "rb_snake/models/food"
+require "rb_snake/models/grid"
+require "rb_snake/models/direction"
+
+module RbSnake
+  module Models
+    class State
+      attr_reader :snake, :food, :grid, :current_direction, :game_finished, :speed_factor
+
+      def initialize(snake:, food:, grid:, current_direction:, game_finished:, speed_factor:)
+        @snake = snake
+        @food = food
+        @grid = grid
+        @current_direction = current_direction
+        @game_finished = game_finished
+        @speed_factor = speed_factor
+      end
+
+      def self.initial_state
+        new(
+          snake: Snake.new(
+            body: [Coordinate.new(row: 1, col: 1), Coordinate.new(row: 0, col: 1)]
+          ),
+          food: Food.new(row: 10, col: 1),
+          grid: Grid.new(rows: 12, cols: 24),
+          current_direction: Direction::DOWN,
+          game_finished: false,
+          speed_factor: 6
+        )
+      end
+
+      def finish_game!
+        @game_finished = true
+      end
+
+      def game_score
+        snake.body.length
+      end
+
+      def update_direction(new_direction)
+        @current_direction = new_direction
+      end
+
+      def increase_speed
+        @speed_factor = [speed_factor - 1, 1].max # the lower, the faster
+      end
+    end
+  end
+end

data/lib/rb_snake/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RbSnake
-  VERSION = "0.0.1"
+  VERSION = '1.0.1'
 end

data/lib/rb_snake/views/window.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "ruby2d"
+require "rb_snake/models/direction"
+require "rb_snake/actions/move_snake"
+require "rb_snake/actions/change_direction"
+
+module RbSnake
+  module Views
+    class Window
+      PIXEL_SIZE = 50
+
+      def initialize
+        @ruby2d_window = Ruby2D::Window.new
+      end
+
+      def start(state)
+        setup_window(state.grid)
+        add_key_listener(state)
+        render_on_each_frame(state)
+
+        ruby2d_window.show
+      end
+
+      def render(state)
+        state.food.render(ruby2d_window) do |row, col|
+          render_square(row: row, col: col, color: "yellow")
+        end
+
+        state.snake.render(ruby2d_window) do |row, col|
+          render_square(row: row, col: col, color: "green")
+        end
+      end
+
+      private
+
+      attr_reader :ruby2d_window
+
+      def setup_window(grid)
+        ruby2d_window.set(
+          title: "Snake",
+          width: PIXEL_SIZE * grid.cols,
+          height: PIXEL_SIZE * grid.rows
+        )
+      end
+
+      def add_key_listener(state)
+        ruby2d_window.on :key_down do |event|
+          handle_key_event(event, state)
+        end
+      end
+
+      def render_on_each_frame(state)
+        tick = 0
+
+        ruby2d_window.update do
+          Actions::MoveSnake.call(state, self) if (tick % state.speed_factor).zero?
+
+          if state.game_finished
+            ruby2d_window.close
+
+            puts "Game Over"
+            puts "Score: #{state.game_score}"
+          end
+
+          tick += 1
+        end
+      end
+
+      def render_square(row:, col:, color:)
+        square = Ruby2D::Square.new(
+          x: col * PIXEL_SIZE,
+          y: row * PIXEL_SIZE,
+          size: PIXEL_SIZE,
+          color: color
+        )
+
+        ruby2d_window.add(square)
+        square
+      end
+
+      def handle_key_event(event, state)
+        case event.key
+        when "up"
+          Actions::ChangeDirection.call(state, new_direction: Models::Direction::UP)
+        when "down"
+          Actions::ChangeDirection.call(state, new_direction: Models::Direction::DOWN)
+        when "left"
+          Actions::ChangeDirection.call(state, new_direction: Models::Direction::LEFT)
+        when "right"
+          Actions::ChangeDirection.call(state, new_direction: Models::Direction::RIGHT)
+        end
+      end
+    end
+  end
+end

data/lib/rb_snake.rb

@@ -4,5 +4,4 @@ require_relative "rb_snake/version"
 
 module RbSnake
   class Error < StandardError; end
-  # Your code goes here...
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rb-snake
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.1
 platform: ruby
 authors:
 - Miguel Prada
-autorequire:
-bindir: exe
+autorequire: 
+bindir: bin
 cert_chain: []
-date: 2023-04-17 00:00:00.000000000 Z
+date: 2023-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby2d
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.12.0
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -83,11 +97,11 @@ dependencies:
 description: The classic snake game recreated using ruby
 email:
 - mapra99@gmail.com
-executables: []
+executables:
+- rb-snake
 extensions: []
 extra_rdoc_files: []
 files:
-- ".byebug_history"
 - ".rspec"
 - ".rubocop.yml"
 - ".stickler.yml"
@@ -97,13 +111,19 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/rb-snake
 - lib/rb_snake.rb
-- lib/rb_snake/actions/actions.rb
+- lib/rb_snake/actions/change_direction.rb
+- lib/rb_snake/actions/move_snake.rb
 - lib/rb_snake/app.rb
-- lib/rb_snake/model/state.rb
+- lib/rb_snake/models/coordinate.rb
+- lib/rb_snake/models/direction.rb
+- lib/rb_snake/models/food.rb
+- lib/rb_snake/models/grid.rb
+- lib/rb_snake/models/snake.rb
+- lib/rb_snake/models/state.rb
 - lib/rb_snake/version.rb
-- lib/rb_snake/view/ruby2d.rb
-- rb-snake.gemspec
+- lib/rb_snake/views/window.rb
 - sig/rb/snake.rbs
 homepage: https://github.com/mapra99/rb-snake
 licenses:
@@ -111,7 +131,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/mapra99/rb-snake
   source_code_uri: https://github.com/mapra99/rb-snake
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -126,8 +146,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 3.3.26
+signing_key: 
 specification_version: 4
 summary: The classic snake game recreated using ruby
 test_files: []

data/.byebug_history

@@ -1,4 +0,0 @@
-exit
-actual_state
-n
-expected_state.snake

data/lib/rb_snake/actions/actions.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-module Actions
-  def self.move_snake(state)
-    next_direction = state.curr_direction
-    next_position = calc_next_position(state)
-
-    if position_is_food? state, next_position
-      state = grow_snake_to state, next_position
-      generate_food state
-    elsif position_is_valid? state, next_position
-      move_snake_to state, next_position
-    else
-      end_game state
-    end
-  end
-  
-  def self.change_direction(state, direction)
-    if next_direction_is_valid? state, direction
-      state.curr_direction = direction
-    else
-      puts "Invalid direction"
-    end
-
-    state
-  end
-
-  private
-
-  def self.generate_food(state)
-    new_food = Model::Food.new(rand(state.grid.rows), rand(state.grid.cols))
-    state.food = new_food
-    state
-  end
-
-  def self.calc_next_position(state)
-    curr_position = state.snake.positions.first
-    case state.curr_direction
-    when Model::Direction::UP
-      Model::Coord.new(curr_position.row - 1,
-                       curr_position.col)
-    when Model::Direction::RIGHT
-      Model::Coord.new(curr_position.row,
-                       curr_position.col + 1)
-    when Model::Direction::DOWN
-      Model::Coord.new(curr_position.row + 1,
-                       curr_position.col)
-    when Model::Direction::LEFT
-      Model::Coord.new(curr_position.row,
-                       curr_position.col - 1)
-    end
-  end
-
-  def self.position_is_food?(state, next_position)
-    (state.food.row == next_position.row) && (state.food.col == next_position.col)
-  end
-
-  def self.position_is_valid?(state, position)
-    # verificar que este en la grilla
-    is_invalid = ((position.row >= state.grid.rows) || (position.row < 0)) ||
-                 ((position.col >= state.grid.cols) || (position.col < 0))
-
-    return false if is_invalid
-
-    # verificar que no este superponiendo a la serpiente
-    !(state.snake.positions.include? position)
-  end
-
-  def self.grow_snake_to(state, next_position)
-    state.snake.positions = [next_position] + state.snake.positions
-    state
-  end
-
-  def self.move_snake_to(state, next_position)
-    new_positions = [next_position] + state.snake.positions[0...-1]
-    state.snake.positions = new_positions
-
-    state
-  end
-
-  def self.end_game(state)
-    state.game_finished = true
-    state
-  end
-
-  def self.next_direction_is_valid?(state, direction)
-    case state.curr_direction
-    when Model::Direction::UP
-      direction != Model::Direction::DOWN
-    when Model::Direction::RIGHT
-      direction != Model::Direction::LEFT
-    when Model::Direction::DOWN
-      direction != Model::Direction::UP
-    when Model::Direction::LEFT
-      direction != Model::Direction::RIGHT
-    else
-      false
-    end
-  end
-end

data/lib/rb_snake/model/state.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-# Representation of Game State
-module Model
-  module Direction
-    UP = :up
-    RIGHT = :right
-    DOWN = :down
-    LEFT = :left
-  end
-
-  class Coord < Struct.new(:row, :col)
-  end
-
-  class Food < Coord
-  end
-
-  class Snake < Struct.new(:positions)
-  end
-
-  class Grid < Struct.new(:rows, :cols)
-  end
-
-  class State < Struct.new(:snake, :food, :grid, :curr_direction, :game_finished)
-  end
-
-  def self.initial_state
-    Model::State.new(
-      Model::Snake.new([Model::Coord.new(1, 1),
-                        Model::Coord.new(0, 1)]),
-      Model::Food.new(4, 4),
-      Model::Grid.new(8, 12),
-      Direction::DOWN,
-      false
-    )
-  end
-end

data/lib/rb_snake/view/ruby2d.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require 'ruby2d'
-module View
-  class Ruby2dView
-    def initialize(app)
-      @pixel_size = 50
-      @app = app
-    end
-
-    def start(state)
-      extend Ruby2D::DSL
-      set(title: 'Snake',
-          width: @pixel_size * state.grid.cols,
-          height: @pixel_size * state.grid.rows)
-      on :key_down do |event|
-        handle_key_event event
-      end
-      show
-    end
-
-    def render(state)
-      close if state.game_finished
-      render_food(state)
-      render_snake(state)
-    end
-
-    private
-
-    def render_food(state)
-      @food.remove if @food
-      extend Ruby2D::DSL
-      food = state.food
-      @food = Square.new(
-        x: food.col * @pixel_size,
-        y: food.row * @pixel_size,
-        size: @pixel_size,
-        color: 'yellow'
-      )
-    end
-
-    def render_snake(state)
-      @snake.each(&:remove) if @snake
-      extend Ruby2D::DSL
-      snake = state.snake
-      @snake = snake.positions.map do |pos|
-        Square.new(
-          x: pos.col * @pixel_size,
-          y: pos.row * @pixel_size,
-          size: @pixel_size,
-          color: 'green'
-        )
-      end
-    end
-
-    def handle_key_event(event)
-      case event.key
-      when "up"
-        @app.send_action(:change_direction, Model::Direction::UP)
-      when "down"
-        @app.send_action(:change_direction, Model::Direction::DOWN)
-      when "left"
-        @app.send_action(:change_direction, Model::Direction::LEFT)
-      when "right"
-        @app.send_action(:change_direction, Model::Direction::RIGHT)
-      end
-    end
-  end
-end

data/rb-snake.gemspec

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "lib/rb_snake/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "rb-snake"
-  spec.version = RbSnake::VERSION
-  spec.authors = ["Miguel Prada"]
-  spec.email = ["mapra99@gmail.com"]
-
-  spec.summary = "The classic snake game recreated using ruby"
-  spec.description = "The classic snake game recreated using ruby"
-  spec.homepage = "https://github.com/mapra99/rb-snake"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.6.0"
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
-    end
-  end
-  spec.bindir = "exe"
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  # Uncomment to register a new dependency of your gem
-  spec.add_dependency 'ruby2d', '~> 0.12.0'
-
-  spec.add_development_dependency 'rake', '~> 13.0'
-  spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'rubocop', '~> 1.21'
-  spec.add_development_dependency 'rubocop-rspec', '~> 2.16.0'
-
-  # For more information and examples about making a new gem, check out our
-  # guide at: https://bundler.io/guides/creating_gem.html
-end