ruby-go 0.4.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: bf963b32b745df2c152b2c7b3f29e71292087deb
-  data.tar.gz: 071b6bb76e230e17b17d5e3dfd7e21f19b78adae
+SHA256:
+  metadata.gz: '024418870e37d715d73c1ce299b3db4c59b231d8fea65b64870e280b9f439387'
+  data.tar.gz: 460d7dbde08c15c6aec3e067dcd50c11d1b2dfac31cd708a97826a3b7b585ad1
 SHA512:
-  metadata.gz: a16e13bc9751e9542bb4fb619a41a7ca6b45a0265148f627d20902e58a4a43fae580ed35ba674a94b43e082414f6f75f2a2227fcff2a438d7bdf8bbc12a5922e
-  data.tar.gz: d99a7e2ad8758315f11b49351820e91a5cffdcc138de51e858e51d142a5c3c66babe417f84549802002c88a6ec3cdfba6572f48eda30f35fabe03882e0ff02b3
+  metadata.gz: b2871316ce937e2df59f6ec8b912b51bb20cc1b37c3d257e3ddb6be0067f559d7a18feb6d8e292955257d910cfacb36aab945794912f61438d036c0d561269b3
+  data.tar.gz: bba3a81eac11819591ff71683b413a9679d06e15fc3334b3e874e415ec25886a600272e783f98495a578722ad8fc4c4514089e954cd2bdf73d6046c8e3836555

data/README.md

@@ -1,16 +1,30 @@
-Kata for the Game of Go
-=======================
-
-Objective
----------
-Build a go game object with all functionality and uses TDD: 
-  * Can print the board  
-  * Can place a black/white stone on board  
-  * Cannot place a stone on top of another stone   
-  * Captures group of stones with no liberties   
-  * Keeps track of captures   
-  * Can undo all moves   
-  * Can pass   
-  * Keeps track of passes in a row (I.e. passes reset to 0 if a stone is played and subtract by 1 if it is undo)   
-  * Cannot place a suicide stone  
-  * Cannot capture a ko
+# Ruby Go
+
+A gem that implements the rules of go (igo, weiqi, baduk).
+
+## Use
+
+```
+game = RubyGo::Game(board: 19)
+game.place_black(3,3)
+game.place_white(15,15)
+
+# ...
+
+game.pass_black
+game.pass_white
+```
+
+### Printers
+
+There are a few printers included in the gem, including `TextPrinter` and `HTMLPrinter`.
+
+The printer takes an `IO` like object, and can print the game.
+```
+printer = RubyGo::TextPrinter.new($stdout)
+printer.print_game(game)
+```
+
+### rubygo Command Line Interface
+
+The rubygo executable included in the gem is CLI that plays the game of go.

data/bin/rubygo

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+require 'ruby-go'
+require 'ruby-go/printers/text'
+
+game = RubyGo::Game.new
+printer = RubyGo::TextPrinter.new($stdout)
+
+Signal.trap("INTERUPT") do
+  puts "\nGoodbye"
+  exit 1
+end
+
+def prompt_for_turn(game)
+  loop do
+    print 'Enter "Pass" or enter coordinates x, y for move (e.g. "4, 4"): '
+    ans = gets.chomp.downcase.gsub(/\s/, '')
+
+    return if ans =~ /pass/
+
+    return ans.split(',').collect {|c| Integer(c)} if ans =~/\d+,\d+/
+  end
+end
+
+def update_terminal(printer, game)
+  system "clear"
+  printer.print_game(game)
+end
+
+update_terminal(printer, game)
+
+turn = 0
+until game.passes >= 2
+  begin
+    if turn % 2 == 0
+      #black's turn
+      puts "Black's turn"
+      move = prompt_for_turn(game)
+      move ? game.place_black(*move) : game.black_pass
+    else
+      #white's turn
+      puts "White's turn"
+      move = prompt_for_turn(game)
+      move ? game.place_white(*move) : game.white_pass
+    end
+
+    update_terminal(printer, game)
+
+    turn += 1
+  rescue RubyGo::Game::IllegalMove => e
+    puts e.message
+    next
+  end
+end
+
+puts "Game over"

data/lib/ruby-go/board.rb

@@ -1,31 +1,27 @@
 module RubyGo
   class Board
-    COLORS = { black: 'x', white: 'o', empty: '_' }.freeze
-
-    attr_accessor :internal_board, :size
+    attr_reader :rows, :size
 
     def initialize(size)
-      @internal_board = Array.new(size) { Array.new(size) { Liberty.new } }
+      @rows = Array.new(size) { Array.new(size) { Liberty.new } }
       @size = size
     end
 
-    private :internal_board
-
     def empty?
-      internal_board.flatten.all?(&:empty?)
+      rows.flatten.all?(&:empty?)
     end
 
     def at(x, y)
-      internal_board[y][x]
+      rows[y][x]
     end
 
     def around(x, y)
       intersections = []
 
       intersections << at(x-1, y) unless x == 0
-      intersections << at(x+1, y) unless x == (internal_board.length - 1)
+      intersections << at(x+1, y) unless x == (size - 1)
       intersections << at(x, y-1) unless y == 0
-      intersections << at(x, y+1) unless y == (internal_board.length - 1)
+      intersections << at(x, y+1) unless y == (size - 1)
       intersections
     end
 
@@ -34,14 +30,13 @@ module RubyGo
 
       x, y = stone.to_coord
 
-      internal_board[y][x] = Liberty.new
+      rows[y][x] = Liberty.new
     end
 
-    # Board shouldn't care about game rules
     def place(stone)
       x, y = stone.to_coord
 
-      internal_board[y][x] = stone
+      rows[y][x] = stone
     end
 
     def liberties(stone)
@@ -67,23 +62,5 @@ module RubyGo
 
       stones
     end
-
-    def to_s
-      out = ""
-      
-      if size < 11
-        out << "\s\s\s#{(0..size - 1).to_a.join(' ')}\n" 
-      else
-        out << "\s\s\s#{(0..10).to_a.join(' ')}" 
-        out << "#{(11..size - 1).to_a.join('')}\n"
-      end
-
-      internal_board.each_with_index do |row, i|
-        i = "\s#{i}" if i < 10
-        out << "#{i}\s#{(row.collect {|stn| stn.to_s}).join(' ')}\n"
-      end
-
-      out
-    end
   end
 end

data/lib/ruby-go/game.rb

@@ -24,19 +24,11 @@ module RubyGo
       sgf << ')'
     end
 
-    def view 
-      puts  board
-      puts  "   " + "_"*(board.size * 2)
-      print "   Prisoners || White: #{captures[:black]} |"
-      puts  " Black: #{captures[:white]}"
-      puts  "   " + "-"*(board.size * 2)
-    end
-
-    def black(x, y)
+    def place_black(x, y)
       play(Stone.new(x, y, :black))
     end
 
-    def white(x, y)
+    def place_white(x, y)
       play(Stone.new(x, y, :white))
     end
 
@@ -83,10 +75,21 @@ module RubyGo
     end
 
     def check_illegal_placement!(stone)
-      unless board.at(*stone.to_coord).empty? 
+      coord = stone.to_coord
+
+      if coord.any? { |i| i < 0 || i >= board.size }
+        raise(
+          Game::IllegalMove,
+          "You cannot place a stone off the board."
+        )
+      end
+
+      intersection = board.at(*coord)
+
+      unless intersection.empty?
         raise(
-          Game::IllegalMove, 
-          "You cannot place a stone on top of another stone."  
+          Game::IllegalMove,
+          "You cannot place a stone on top of another stone."
         )
       end
     end

data/lib/ruby-go/liberty.rb

@@ -4,8 +4,8 @@ module RubyGo
       true
     end
 
-    def to_s
-      Board::COLORS[:empty] 
+    def color
+      :empty
     end
   end
 end

data/lib/ruby-go/printers/html.rb

@@ -0,0 +1,76 @@
+require 'erb'
+
+module RubyGo
+  class HTMLPrinter
+    LETTERS = ('A'..'Z').to_a.freeze
+    COLORS = { black: 'black stone', white: 'white stone', empty: 'liberty' }.freeze
+    TEMPLATE = ERB.new(<<~ERB).freeze
+      <style>
+      .board { max-width: 100%; padding: 16px; }
+      .row { display: flex; margin: 0; }
+      .intersection { display: inline-block; height: 32px; width: 32px; border-top: 2px solid black; border-left: 2px solid black; }
+      .intersection:last-child { border-top-width: 0px; height: 34px; }
+      .row:last-child .intersection { border-left-width: 0px; width: 34px; }
+      .row:last-child .intersection:last-child { width: 2px; height: 2px; background: black; }
+      .stone, .liberty { display: inline-block; width: 30px; height: 30px; border-radius: 100%; margin: 0; position: relative; top: -18px; left: -18px; }
+      .stone { border: 2px solid black; }
+      .black.stone { background: black; }
+      .white.stone { background: white; }
+      .liberty:hover { border: 2px solid red; }
+      .row-num, .column-num { display: inline-block; width: 34px; height: 34px; margin: 0; position: relative; }
+      .row-num { top: -0.5em; }
+      .column-num { left: -0.3em; }
+      </style>
+      <div class="game">
+        <div class="board">
+          <div class="row">
+            <div class="column-num row-num"></div>
+            <% size.times do |i| %>
+            <div class="column-num"><%= letters[i] %></div>
+            <% end %>
+          </div>
+          <% rows.each_with_index do |row, i| %>
+          <div class="row">
+            <div class="row-num"><%= letters[i] %></div>
+            <% row.each do |stn| %>
+              <div class="intersection">
+                <div class="<%= colors[stn.color] %>"></div>
+              </div>
+            <% end %>
+          </div>
+          <% end %>
+        </div>
+
+        <div class="info">
+          <table>
+            <tbody>
+              <tr>
+                <th>Prisoners</th>
+                <th>White</th>
+                <td><%= captures[:black] %></td>
+                <th>Black</th>
+                <td><%= captures[:white] %></td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+      </div>
+    ERB
+
+    attr_reader :io
+
+    def initialize(io)
+      @io = io
+    end
+
+    def print_game(game)
+      html = TEMPLATE.result_with_hash(
+        size: game.board.size,
+        captures: game.captures,
+        rows: game.board.rows,
+        colors: COLORS, letters: LETTERS
+      )
+      io.write(html)
+    end
+  end
+end

data/lib/ruby-go/printers/text.rb

@@ -0,0 +1,40 @@
+module RubyGo
+  class TextPrinter
+    COLORS = { black: 'x', white: 'o', empty: '_' }.freeze
+
+    attr_reader :io
+
+    def initialize(io)
+      @io = io
+    end
+
+    def print_game(game)
+      print_board(game.board)
+      io.puts  "   " + "_"*(game.board.size * 2)
+      io.print "   Prisoners || White: #{game.captures[:black]} |"
+      io.puts  " Black: #{game.captures[:white]}"
+      io.puts  "   " + "-"*(game.board.size * 2)
+    end
+
+    private
+
+    def print_board(board)
+      if board.size < 11
+        io.puts "   #{(0..board.size - 1).to_a.join(' ')}"
+      else
+        io.puts "   #{(0..10).to_a.join(' ')}#{(11..board.size - 1).to_a.join('')}"
+      end
+
+      board.rows.each_with_index do |row, i|
+        i = " #{i}" if i < 10
+        io.print "#{i} "
+        row.each { |stn| print_stone(stn) }
+        io.puts
+      end
+    end
+
+    def print_stone(stone)
+      io.print "#{COLORS[stone.color]} "
+    end
+  end
+end

data/lib/ruby-go/stone.rb

@@ -6,7 +6,7 @@ module RubyGo
 
     def initialize(x_coord, y_coord, color)
       @x_coord = x_coord
-      @y_coord = y_coord 
+      @y_coord = y_coord
       @color = color
     end
 
@@ -24,10 +24,6 @@ module RubyGo
       [x_coord, y_coord]
     end
 
-    def to_s
-      Board::COLORS[color] 
-    end
-
     def ==(other)
       other.is_a?(Stone) &&
         (color == other.color) &&
@@ -36,7 +32,7 @@ module RubyGo
   end
 
   # This can be changed to a Pass object
-  class NullStone < Stone 
+  class NullStone < Stone
     def initialize(color = :empty)
       @x_coord = nil
       @y_coord = nil
@@ -46,7 +42,7 @@ module RubyGo
     def to_sgf
       ";#{color.to_s[0].upcase}[]"
     end
-    
+
     def empty?
       true
     end

data/lib/ruby-go/version.rb

@@ -1,3 +1,3 @@
 module RubyGo
-  VERSION = "0.4.0"
+  VERSION = "1.0.0"
 end

data/test/go_test.rb

@@ -4,10 +4,7 @@ require 'stringio'
 module RubyGo
   class GoTest < Minitest::Test
     def setup
-      b,w = Board::COLORS[:black], Board::COLORS[:white]
-      e   = Board::COLORS[:empty]
-
-      @row_9_str = "_ _ _ _ _ _ _ _ _\n"
+      @row_9_str = " 8 _ _ _ _ _ _ _ _ _ \n"
 
       @game = Game.new(board: 9)
     end
@@ -16,102 +13,96 @@ module RubyGo
       assert @game.board.empty?
     end
 
-    def test_empty_board_looks_like_empty_board
-      assert_includes @game.board.to_s, @row_9_str
-    end
-
-    def test_game_can_print_the_board
+    def test_printer_can_print_the_game
       out = StringIO.new
-      temp = $stdout
-      $stdout = out
-      @game.view
-      $stdout = temp
+      printer = RubyGo::TextPrinter.new(out)
+      printer.print_game(@game)
       out.rewind
       assert_includes out.read, @row_9_str
     end
 
     def test_game_can_place_a_stone
       game = Game.new(board: 9)
-      game.black(2,2)
+      game.place_black(2,2)
       assert_equal :black, game.board.at(2,2).color
     end
 
     def test_cannot_place_a_stone_on_top_of_another_stone
       game = Game.new(board: 9)
-      game.black(2,2)
+      game.place_black(2,2)
       assert_raises(Game::IllegalMove) do
-        game.white(2,2)
+        game.place_white(2,2)
       end
     end
 
     def test_can_capture_one_stone
       game = Game.new(board: 9)
-      game.black(2,2)
-      game.white(2,1)
-      game.white(2,3)
-      game.white(1,2)
-      game.white(3,2)
+      game.place_black(2,2)
+      game.place_white(2,1)
+      game.place_white(2,3)
+      game.place_white(1,2)
+      game.place_white(3,2)
       assert_equal 1, game.captures[:black]
     end
 
     def test_capture_removes_stone
       game = Game.new(board: 9)
-      game.black(2,2)
-      game.white(2,1)
-      game.white(2,3)
-      game.white(1,2)
-      game.white(3,2)
+      game.place_black(2,2)
+      game.place_white(2,1)
+      game.place_white(2,3)
+      game.place_white(1,2)
+      game.place_white(3,2)
       assert game.board.at(2,2).empty?
     end
 
     def test_capture_three_stones
       game = Game.new(board: 9)
-      game.black(2,1)
-      game.black(2,2)
-      game.black(2,3)
-      game.white(2,0)
-      game.white(2,4)
-      game.white(1,1)
-      game.white(1,2)
-      game.white(1,3)
-      game.white(3,1)
-      game.white(3,2)
-      game.white(3,3)
+      game.place_black(2,1)
+      game.place_black(2,2)
+      game.place_black(2,3)
+      game.place_white(2,0)
+      game.place_white(2,4)
+      game.place_white(1,1)
+      game.place_white(1,2)
+      game.place_white(1,3)
+      game.place_white(3,1)
+      game.place_white(3,2)
+      game.place_white(3,3)
       assert_equal 3, game.captures[:black]
     end
 
     def test_snap_back
       game = Game.new(board: 9)
-      game.black(3,2)
-      game.black(2,3)
-      game.black(4,3)
-      game.black(2,4)
-      game.black(5,4)
-      game.black(3,5)
-      game.black(4,5)
-      game.white(4,2)
-      game.white(5,3)
-      game.white(3,4)
-      game.white(4,4)
-      game.white(3,3)
+      game.place_black(3,2)
+      game.place_black(2,3)
+      game.place_black(4,3)
+      game.place_black(2,4)
+      game.place_black(5,4)
+      game.place_black(3,5)
+      game.place_black(4,5)
+      game.place_white(4,2)
+      game.place_white(5,3)
+      game.place_white(3,4)
+      game.place_white(4,4)
+      game.place_white(3,3)
       assert_equal 1, game.captures[:black]
       assert_equal 0, game.captures[:white]
-      game.black(4,3)
+      game.place_black(4,3)
       assert_equal 1, game.captures[:black]
       assert_equal 3, game.captures[:white]
     end
 
     def test_can_undo
       game = Game.new()
-      game.black(2,2)
-      game.white(2,3)
+      game.place_black(2,2)
+      game.place_white(2,3)
       game.undo
       assert game.board.at(2,3).empty?
     end
 
     def test_can_undo_pass
       game = Game.new
-      game.black(2,2)
+      game.place_black(2,2)
       game.white_pass
       game.undo
       assert_equal 0, game.passes
@@ -119,9 +110,9 @@ module RubyGo
 
     def test_can_undo_until_beginning
       game = Game.new()
-      game.black(2,2)
-      game.white(3,2)
-      game.black(3,3)
+      game.place_black(2,2)
+      game.place_white(3,2)
+      game.place_black(3,3)
       3.times {game.undo}
       assert game.board.at(2,2).empty?
     end
@@ -135,57 +126,57 @@ module RubyGo
 
     def test_cannot_play_a_suicide
       game = Game.new
-      game.black(3,3)
-      game.white(2,3)
-      game.white(4,3)
-      game.white(3,4)
-      game.white(3,2)
+      game.place_black(3,3)
+      game.place_white(2,3)
+      game.place_white(4,3)
+      game.place_white(3,4)
+      game.place_white(3,2)
       assert_raises(Game::IllegalMove) do
-        game.black(3,3)
+        game.place_black(3,3)
       end
     end
 
     def test_cannot_play_a_ko
       game = Game.new
-      game.black(3,3)
-      game.white(2,3)
-      game.white(4,3)
-      game.white(3,4)
-      game.white(3,2)
-      game.black(4,2)
-      game.black(4,4)
-      game.black(5,3)
-      game.black(3,3)
+      game.place_black(3,3)
+      game.place_white(2,3)
+      game.place_white(4,3)
+      game.place_white(3,4)
+      game.place_white(3,2)
+      game.place_black(4,2)
+      game.place_black(4,4)
+      game.place_black(5,3)
+      game.place_black(3,3)
       assert_raises(Game::IllegalMove) do
-        game.white(4,3)
+        game.place_white(4,3)
       end
     end
 
     def big_capture_area_game
       game = Game.new
-      game.black(0,0)
-      game.white(1,1)
-      game.black(0,1)
-      game.white(0,2)
-      game.black(1,0)
-      game.white(2,0)
+      game.place_black(0,0)
+      game.place_white(1,1)
+      game.place_black(0,1)
+      game.place_white(0,2)
+      game.place_black(1,0)
+      game.place_white(2,0)
       game
     end
 
     def test_can_play_in_previous_capture_area_that_is_not_a_ko
       game = big_capture_area_game
       assert game.board.at(0,0).empty?
-      game.black(0,0)
+      game.place_black(0,0)
       assert_equal :black, game.board.at(0,0).color
 
       game = big_capture_area_game
       assert game.board.at(0,1).empty?
-      game.black(0,1)
+      game.place_black(0,1)
       assert_equal :black, game.board.at(0,1).color
 
       game = big_capture_area_game
       assert game.board.at(1,0).empty?
-      game.black(1,0)
+      game.place_black(1,0)
       assert_equal :black, game.board.at(1,0).color
     end
   end

data/test/sgf_test.rb

@@ -11,26 +11,26 @@ module RubyGo
 
     def test_game_converts_to_sgf_with_moves
       game = Game.new
-      game.black(15,3)
-      game.white(3,3)
-      game.black(3,15)
-      game.white(15,15)
+      game.place_black(15,3)
+      game.place_white(3,3)
+      game.place_black(3,15)
+      game.place_white(15,15)
       assert_equal "(;GM[1]FF[4]CA[UTF-8]AP[jphager2]SZ[19]PW[White]PB[Black];B[pd];W[dd];B[dp];W[pp])",
         game.to_sgf
     end
 
     def test_game_converts_correctly_with_capture
       game = Game.new
-      game.black(15,3)
-      game.white(16,3)
-      game.black(16,2)
-      game.white(15,2)
-      game.black(14,2)
-      game.white(14,3)
-      game.black(17,3)
-      game.white(15,4)
-      game.black(16,4)
-      game.white(15,3)
+      game.place_black(15,3)
+      game.place_white(16,3)
+      game.place_black(16,2)
+      game.place_white(15,2)
+      game.place_black(14,2)
+      game.place_white(14,3)
+      game.place_black(17,3)
+      game.place_white(15,4)
+      game.place_black(16,4)
+      game.place_white(15,3)
 
       assert_equal "(;GM[1]FF[4]CA[UTF-8]AP[jphager2]SZ[19]PW[White]PB[Black];B[pd];W[qd];B[qc];W[pc];B[oc];W[od];B[rd];W[pe];B[qe];W[pd])",
         game.to_sgf
@@ -41,10 +41,10 @@ module RubyGo
       path = File.expand_path('../../*.sgf', __FILE__)
       File.delete(file) if File.exist?(file)
       game = Game.new
-      game.black(15,3)
-      game.white(16,3)
-      game.black(16,2)
-      game.white(15,2)
+      game.place_black(15,3)
+      game.place_white(16,3)
+      game.place_black(16,2)
+      game.place_white(15,2)
       game.save
       assert_includes Dir.glob(path), file
     end

data/test/test_helper.rb

@@ -1,3 +1,4 @@
-require_relative '../lib/ruby-go.rb'
+require_relative '../lib/ruby-go'
+require_relative '../lib/ruby-go/printers/text'
 
 require 'minitest/autorun'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-go
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 1.0.0
 platform: ruby
 authors:
 - jphager2
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-28 00:00:00.000000000 Z
+date: 2020-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: SgfParser
@@ -27,19 +27,21 @@ dependencies:
 description: A gem to play go and save games as sgf
 email: jphager2@gmail.com
 executables:
-- ruby-go.rb
+- rubygo
 extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
 - Rakefile
-- bin/ruby-go.rb
+- bin/rubygo
 - lib/ruby-go.rb
 - lib/ruby-go/board.rb
 - lib/ruby-go/game.rb
 - lib/ruby-go/liberty.rb
 - lib/ruby-go/moves.rb
+- lib/ruby-go/printers/html.rb
+- lib/ruby-go/printers/text.rb
 - lib/ruby-go/stone.rb
 - lib/ruby-go/version.rb
 - test/go_test.rb
@@ -64,8 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: The game of Go, writen in Ruby

data/bin/ruby-go.rb

@@ -1,45 +0,0 @@
-#!/usr/bin/env ruby
-
-require_relative '../lib/ruby-go'
-
-game = RubyGo::Game.new
-
-def game.prompt_for_turn
-  print "Pass or enter coordinates x, y for move (e.g. 4, 4): "
-  ans = gets.chomp.downcase.gsub(/\s/, '')
-
-  if ans =~ /pass/
-    self.pass 
-    nil
-  else
-    ans.split(',').collect {|c| Integer(c)}
-  end
-end 
-
-system "clear"
-game.view
-turn = 0
-until game.passes >= 2
-  begin 
-    if turn % 2 == 0
-      #black's turn
-      puts "Black's turn"
-      ans = game.prompt_for_turn
-      game.black(*ans) if ans
-    else
-      #white's turn 
-      puts "white's turn"
-      ans = game.prompt_for_turn 
-      game.white(*ans) if ans
-    end
-
-    system "clear"
-    game.view
-
-    turn += 1
-  rescue RubyGo::Game::IllegalMove
-    next
-  end
-end
-
-system "clear"