codenjoy-client 0.1.002 → 0.1.003

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a61b7902294632ba13ee721929b14d9c65fda4accda66cdd600bd36f6cf919a2
-  data.tar.gz: '0865df29d554e8238cbfe0c4ce86cea470970c7726d7b65f49092d8e88dd077a'
+  metadata.gz: 5f6e2b556f20d5339438bcc59a9669cfa865fda7ead39b17a4f0dcdbe5565882
+  data.tar.gz: 425311003e3a408417152608e497aa0ac3000a69dceaca9dfb80a57878b9e03c
 SHA512:
-  metadata.gz: 2156aaac83fd0376e0d0771258f295c9d587a2638f9f288c04a8a21bb32ea766ae585503d05330616acaa52ad05310fe6c992979a672a6a219bb320781aeb05b
-  data.tar.gz: cd9586a757c9bc527924638d075bdfcf2c6f624a35e2002371d9aa1b5debc737deb699b7a2c181f42ac406bfe5dc6a9422abc229c43ac8279731ce9e27086b27
+  metadata.gz: 97033b697c2ff85718b30178e1876b2e2a2bfacccd4d4dd9af3fd023fff7dc6942155e92e080afbe7d4c34fe30ee7433c4c21d17a604b620318875931086ad83
+  data.tar.gz: 04c31405fcaea56dd5732afff1396e00addd9c92ddc633bc6bbbbf40061e92d742f1e49feb4a43f5af1fa9d2a0fb9c33b62ff6bf1a908add579b1348cd77ac5b

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    codenjoy-client (0.1.002)
+    codenjoy-client (0.1.003)
       faye-websocket
 
 GEM

data/README.md

@@ -1,8 +1,6 @@
 # Codenjoy::Client
 
-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/codenjoy/client`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+This is ruby client for https://github.com/codenjoyme/codenjoy project. It uses for playing dojorena.io.
 
 ## Installation
 
@@ -22,7 +20,11 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+After you install gem, you can create base client:
+
+    $ codenjoy-ruby-client
+
+The file `game_base_client.rb` created at current folder. You should replace `url` and write your own code at `YourSolver` class.
 
 ## Development
 
@@ -30,6 +32,8 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+For add new game crate new folder at `lib/codenjoy/games` and add necessary classes.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/codenjoy-client.

data/lib/codenjoy/client/version.rb

@@ -1,5 +1,5 @@
 module Codenjoy
   module Client
-    VERSION = "0.1.002"
+    VERSION = "0.1.003"
   end
 end

data/lib/codenjoy/game_base_client.rb

@@ -24,7 +24,8 @@ class YourSolver
 end
 
 game = Codenjoy::Client::Game.new
-board = Codenjoy::Client::Games::Battlecity::Board.new
+# board = Codenjoy::Client::Games::Battlecity::Board.new
+board = Codenjoy::Client::Games::Tetris::Board.new
 
 url = "https://dojorena.io/codenjoy-contest/board/player/70xewv6o7ddy9yphm1u0?code=2603484461919438773&gameName=battlecity"
 count = 0

data/lib/codenjoy/games/battlecity/board.rb

@@ -20,57 +20,9 @@
 # #L%
 ###
 
+require "codenjoy/utils"
 require 'json'
 
-# Point class
-class Point
-  attr_accessor :x
-  attr_accessor :y
-
-  # Coords (1,1) - upper left side of field
-  #
-  # @param [Integer] x X coord
-  # @param [Integer] y Y coord
-  def initialize(x, y)
-    @x = x
-    @y = y
-  end
-
-  # Override of compare method for Point
-  def == (other_object)
-    other_object.x == @x && other_object.y == @y
-  end
-
-  # For better +.inspect+ output
-  def to_s
-    "[#{@x},#{@y}]"
-  end
-
-  # Position of point above current
-  def up
-    Point.new(@x, @y + 1)
-  end
-
-  # Position of point below current
-  def down
-    Point.new(@x, @y - 1)
-  end
-
-  # Position of point on the left side
-  def left
-    Point.new(@x - 1, @y)
-  end
-
-  # Position of point on the right side
-  def right
-    Point.new(@x + 1, @y)
-  end
-
-  def out_of?(board_size)
-    x >= board_size || y >= board_size || x < 0 || y < 0;
-  end
-end
-
 class LengthToXY
   def initialize(board_size)
     @board_size = board_size
@@ -101,205 +53,205 @@ end
 module Codenjoy
   module Client
     module Games
+      module Battlecity
+      end
     end
   end
 end
 
-module Codenjoy::Client::Games::Battlecity
-  class Board
-
-    ELEMENTS = {
-      NONE: ' ',
-      BATTLE_WALL: '☼',
-      BANG: 'Ѡ',
-
-      CONSTRUCTION: '╬',
-
-      CONSTRUCTION_DESTROYED_DOWN: '╩',
-      CONSTRUCTION_DESTROYED_UP: '╦',
-      CONSTRUCTION_DESTROYED_LEFT: '╠',
-      CONSTRUCTION_DESTROYED_RIGHT: '╣',
-
-      CONSTRUCTION_DESTROYED_DOWN_TWICE: '╨',
-      CONSTRUCTION_DESTROYED_UP_TWICE: '╥',
-      CONSTRUCTION_DESTROYED_LEFT_TWICE: '╞',
-      CONSTRUCTION_DESTROYED_RIGHT_TWICE: '╡',
-
-      CONSTRUCTION_DESTROYED_LEFT_RIGHT: '│',
-      CONSTRUCTION_DESTROYED_UP_DOWN: '─',
-
-      CONSTRUCTION_DESTROYED_UP_LEFT: '┌',
-      CONSTRUCTION_DESTROYED_RIGHT_UP: '┐',
-      CONSTRUCTION_DESTROYED_DOWN_LEFT: '└',
-      CONSTRUCTION_DESTROYED_DOWN_RIGHT: '┘',
-
-      CONSTRUCTION_DESTROYED: ' ',
-
-      BULLET: '•',
-
-      TANK_UP: '▲',
-      TANK_RIGHT: '►',
-      TANK_DOWN: '▼',
-      TANK_LEFT: '◄',
-
-      OTHER_TANK_UP: '˄',
-      OTHER_TANK_RIGHT: '˃',
-      OTHER_TANK_DOWN: '˅',
-      OTHER_TANK_LEFT: '˂',
-
-      AI_TANK_UP: '?',
-      AI_TANK_RIGHT: '»',
-      AI_TANK_DOWN: '¿',
-      AI_TANK_LEFT: '«'
-    }
-
-    ENEMIES = [
-      ELEMENTS[:AI_TANK_UP],
-      ELEMENTS[:AI_TANK_DOWN],
-      ELEMENTS[:AI_TANK_LEFT],
-      ELEMENTS[:AI_TANK_RIGHT],
-      ELEMENTS[:OTHER_TANK_UP],
-      ELEMENTS[:OTHER_TANK_DOWN],
-      ELEMENTS[:OTHER_TANK_LEFT],
-      ELEMENTS[:OTHER_TANK_RIGHT]
-    ]
-
-    TANK = [
-      ELEMENTS[:TANK_UP],
-      ELEMENTS[:TANK_DOWN],
-      ELEMENTS[:TANK_LEFT],
-      ELEMENTS[:TANK_RIGHT]
-    ]
-
-    BARRIERS = [
-      ELEMENTS[:BATTLE_WALL],
-      ELEMENTS[:CONSTRUCTION],
-      ELEMENTS[:CONSTRUCTION_DESTROYED_DOWN],
-      ELEMENTS[:CONSTRUCTION_DESTROYED_UP],
-      ELEMENTS[:CONSTRUCTION_DESTROYED_LEFT],
-      ELEMENTS[:CONSTRUCTION_DESTROYED_RIGHT],
-      ELEMENTS[:CONSTRUCTION_DESTROYED_DOWN_TWICE],
-      ELEMENTS[:CONSTRUCTION_DESTROYED_UP_TWICE],
-      ELEMENTS[:CONSTRUCTION_DESTROYED_LEFT_TWICE],
-      ELEMENTS[:CONSTRUCTION_DESTROYED_RIGHT_TWICE],
-      ELEMENTS[:CONSTRUCTION_DESTROYED_LEFT_RIGHT],
-      ELEMENTS[:CONSTRUCTION_DESTROYED_UP_DOWN],
-      ELEMENTS[:CONSTRUCTION_DESTROYED_UP_LEFT],
-      ELEMENTS[:CONSTRUCTION_DESTROYED_RIGHT_UP],
-      ELEMENTS[:CONSTRUCTION_DESTROYED_DOWN_LEFT],
-      ELEMENTS[:CONSTRUCTION_DESTROYED_DOWN_RIGHT]
-    ]
-
-    def process(data)
-      @raw = data
-    end
+class Codenjoy::Client::Games::Battlecity::Board
+
+  ELEMENTS = {
+    NONE: ' ',
+    BATTLE_WALL: '☼',
+    BANG: 'Ѡ',
+
+    CONSTRUCTION: '╬',
+
+    CONSTRUCTION_DESTROYED_DOWN: '╩',
+    CONSTRUCTION_DESTROYED_UP: '╦',
+    CONSTRUCTION_DESTROYED_LEFT: '╠',
+    CONSTRUCTION_DESTROYED_RIGHT: '╣',
+
+    CONSTRUCTION_DESTROYED_DOWN_TWICE: '╨',
+    CONSTRUCTION_DESTROYED_UP_TWICE: '╥',
+    CONSTRUCTION_DESTROYED_LEFT_TWICE: '╞',
+    CONSTRUCTION_DESTROYED_RIGHT_TWICE: '╡',
+
+    CONSTRUCTION_DESTROYED_LEFT_RIGHT: '│',
+    CONSTRUCTION_DESTROYED_UP_DOWN: '─',
+
+    CONSTRUCTION_DESTROYED_UP_LEFT: '┌',
+    CONSTRUCTION_DESTROYED_RIGHT_UP: '┐',
+    CONSTRUCTION_DESTROYED_DOWN_LEFT: '└',
+    CONSTRUCTION_DESTROYED_DOWN_RIGHT: '┘',
+
+    CONSTRUCTION_DESTROYED: ' ',
+
+    BULLET: '•',
+
+    TANK_UP: '▲',
+    TANK_RIGHT: '►',
+    TANK_DOWN: '▼',
+    TANK_LEFT: '◄',
+
+    OTHER_TANK_UP: '˄',
+    OTHER_TANK_RIGHT: '˃',
+    OTHER_TANK_DOWN: '˅',
+    OTHER_TANK_LEFT: '˂',
+
+    AI_TANK_UP: '?',
+    AI_TANK_RIGHT: '»',
+    AI_TANK_DOWN: '¿',
+    AI_TANK_LEFT: '«'
+  }
+
+  ENEMIES = [
+    ELEMENTS[:AI_TANK_UP],
+    ELEMENTS[:AI_TANK_DOWN],
+    ELEMENTS[:AI_TANK_LEFT],
+    ELEMENTS[:AI_TANK_RIGHT],
+    ELEMENTS[:OTHER_TANK_UP],
+    ELEMENTS[:OTHER_TANK_DOWN],
+    ELEMENTS[:OTHER_TANK_LEFT],
+    ELEMENTS[:OTHER_TANK_RIGHT]
+  ]
+
+  TANK = [
+    ELEMENTS[:TANK_UP],
+    ELEMENTS[:TANK_DOWN],
+    ELEMENTS[:TANK_LEFT],
+    ELEMENTS[:TANK_RIGHT]
+  ]
+
+  BARRIERS = [
+    ELEMENTS[:BATTLE_WALL],
+    ELEMENTS[:CONSTRUCTION],
+    ELEMENTS[:CONSTRUCTION_DESTROYED_DOWN],
+    ELEMENTS[:CONSTRUCTION_DESTROYED_UP],
+    ELEMENTS[:CONSTRUCTION_DESTROYED_LEFT],
+    ELEMENTS[:CONSTRUCTION_DESTROYED_RIGHT],
+    ELEMENTS[:CONSTRUCTION_DESTROYED_DOWN_TWICE],
+    ELEMENTS[:CONSTRUCTION_DESTROYED_UP_TWICE],
+    ELEMENTS[:CONSTRUCTION_DESTROYED_LEFT_TWICE],
+    ELEMENTS[:CONSTRUCTION_DESTROYED_RIGHT_TWICE],
+    ELEMENTS[:CONSTRUCTION_DESTROYED_LEFT_RIGHT],
+    ELEMENTS[:CONSTRUCTION_DESTROYED_UP_DOWN],
+    ELEMENTS[:CONSTRUCTION_DESTROYED_UP_LEFT],
+    ELEMENTS[:CONSTRUCTION_DESTROYED_RIGHT_UP],
+    ELEMENTS[:CONSTRUCTION_DESTROYED_DOWN_LEFT],
+    ELEMENTS[:CONSTRUCTION_DESTROYED_DOWN_RIGHT]
+  ]
+
+  def process(data)
+    @raw = data
+  end
 
-    def size
-      @size ||= Math.sqrt(@raw.length);
-    end
+  def size
+    @size ||= Math.sqrt(@raw.length);
+  end
 
-    def xyl
-      @xyl ||= LengthToXY.new(size);
-    end
+  def xyl
+    @xyl ||= LengthToXY.new(size);
+  end
 
-    def getAt(x, y)
-      return false if Point.new(x, y).out_of?(size)
-      @raw[xyl.getLength(x, y)];
-    end
+  def getAt(x, y)
+    return false if Point.new(x, y).out_of?(size)
+    @raw[xyl.getLength(x, y)];
+  end
 
-    def at?(x, y, element)
-      return false if Point.new(x, y).out_of?(size)
-      getAt(x, y) == element;
-    end
+  def at?(x, y, element)
+    return false if Point.new(x, y).out_of?(size)
+    getAt(x, y) == element;
+  end
 
-    def findAll(element)
-      result = []
-      @raw.length.times do |i|
-        point = xyl.getXY(i);
-        result.push(point) if at?(point.x, point.y, element)
-      end
-      result;
+  def findAll(element)
+    result = []
+    @raw.length.times do |i|
+      point = xyl.getXY(i);
+      result.push(point) if at?(point.x, point.y, element)
     end
+    result;
+  end
 
-    def get_me
-      me = find_by_list(TANK)
-      return nil if me.nil?
-      find_by_list(TANK).flatten
-    end
+  def get_me
+    me = find_by_list(TANK)
+    return nil if me.nil?
+    find_by_list(TANK).flatten
+  end
 
-    def find_by_list(list)
-      result = list.map{ |e| findAll(e) }.flatten.map{ |e| [e.x, e.y] }
-      return nil if (result.length == 0)
-      result
-    end
+  def find_by_list(list)
+    result = list.map{ |e| findAll(e) }.flatten.map{ |e| [e.x, e.y] }
+    return nil if (result.length == 0)
+    result
+  end
 
-    def get_enemies
-      find_by_list(ENEMIES)
-    end
+  def get_enemies
+    find_by_list(ENEMIES)
+  end
 
-    def get_bullets
-      find_by_list([ELEMENTS[:BULLET]])
-    end
+  def get_bullets
+    find_by_list([ELEMENTS[:BULLET]])
+  end
 
-    def get_near(x, y)
-      return false if Point.new(x, y).out_of?(size)
-      result = []
-      (-1..1).each do |dx|
-        (-1..1).each do |dy|
-            next if (dx == 0 && dy == 0)
-            result.push(getAt(x + dx, y + dy))
-        end
+  def get_near(x, y)
+    return false if Point.new(x, y).out_of?(size)
+    result = []
+    (-1..1).each do |dx|
+      (-1..1).each do |dy|
+          next if (dx == 0 && dy == 0)
+          result.push(getAt(x + dx, y + dy))
       end
-      result;
     end
+    result;
+  end
 
-    def barrier_at?(x, y)
-      return false if Point.new(x, y).out_of?(size)
-      get_barriers.include?([x.to_f, y.to_f]);
-    end
+  def barrier_at?(x, y)
+    return false if Point.new(x, y).out_of?(size)
+    get_barriers.include?([x.to_f, y.to_f]);
+  end
 
-    def count_near(x, y, element)
-      get_near(x, y).select{ |e| e == element}.size
-    end
+  def count_near(x, y, element)
+    get_near(x, y).select{ |e| e == element}.size
+  end
 
-    def near?(x, y, element)
-      n = get_near(x, y)
-      return false if !n
-      n.include?(element);
-    end
+  def near?(x, y, element)
+    n = get_near(x, y)
+    return false if !n
+    n.include?(element);
+  end
 
-    def bullet_at?(x, y)
-      return false if Point.new(x, y).out_of?(size)
-      getAt(x, y) == ELEMENTS[:BULLET]
-    end
+  def bullet_at?(x, y)
+    return false if Point.new(x, y).out_of?(size)
+    getAt(x, y) == ELEMENTS[:BULLET]
+  end
 
-    def any_of_at?(x, y, elements = [])
-      return false if Point.new(x, y).out_of?(size)
-      elements.each do |e|
-        return true if at?(x, y, e)
-      end
-      false;
+  def any_of_at?(x, y, elements = [])
+    return false if Point.new(x, y).out_of?(size)
+    elements.each do |e|
+      return true if at?(x, y, e)
     end
+    false;
+  end
 
-    def game_over?
-      get_me.nil?;
-    end
+  def game_over?
+    get_me.nil?;
+  end
 
-    def board_to_s
-      Array.new(size).each_with_index.map{ |e, n| @raw[(n * size)..((n + 1) * size - 1)]}.join("\n")
-    end
+  def board_to_s
+    Array.new(size).each_with_index.map{ |e, n| @raw[(n * size)..((n + 1) * size - 1)]}.join("\n")
+  end
 
-    def get_barriers
-      find_by_list(BARRIERS)
-    end
+  def get_barriers
+    find_by_list(BARRIERS)
+  end
 
-    def to_s
-      [
-        "Board:\n#{board_to_s}",
-        "My tank at: #{get_me}",
-        "Enemies at: #{get_enemies}",
-        "Bullets at: #{get_bullets}"
-      ].join("\n")
-    end
+  def to_s
+    [
+      "Board:\n#{board_to_s}",
+      "My tank at: #{get_me}",
+      "Enemies at: #{get_enemies}",
+      "Bullets at: #{get_bullets}"
+    ].join("\n")
   end
 end

data/lib/codenjoy/games/tetris/board.rb

@@ -0,0 +1,265 @@
+###
+# #%L
+# Codenjoy - it's a dojo-like platform from developers to developers.
+# %%
+# Copyright (C) 2018 Codenjoy
+# %%
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with this program.  If not, see
+# <http://www.gnu.org/licenses/gpl-3.0.html>.
+# #L%
+###
+require 'json'
+
+##################################### ELEMENTS TYPES #########################################################
+
+ELEMENTS = Hash.new
+
+# This is glass content
+ELEMENTS[:I_BLUE] = 'I'
+ELEMENTS[:J_CYAN] = 'J'
+ELEMENTS[:L_ORANGE] = 'L'
+ELEMENTS[:O_YELLOW] = 'O'
+ELEMENTS[:S_GREEN] = 'S'
+ELEMENTS[:T_PURPLE] = 'T'
+ELEMENTS[:Z_RED] = 'Z'
+ELEMENTS[:NONE] = '.'
+
+# List of figures
+FIGURES = [
+    ELEMENTS[:I_BLUE],
+    ELEMENTS[:J_CYAN],
+    ELEMENTS[:L_ORANGE],
+    ELEMENTS[:O_YELLOW],
+    ELEMENTS[:S_GREEN],
+    ELEMENTS[:T_PURPLE],
+    ELEMENTS[:Z_RED]
+]
+
+##################################### END OF ELEMENTS TYPES #########################################################
+
+# Return list of indexes of char +char+ in string +s+ ("STR".index returns only first char/string appear)
+#
+# @param [String] s string to search in
+# @param [String] char substring to search
+# @return [Array] list of indexes
+def indexes(s, char)
+  (0 ... s.length).find_all { |i| s[i,1] == char }
+end
+
+def compare(pt1, pt2)
+  if (pt1.x <=> pt2.x) != 0
+    pt1.x <=> pt2.x
+  else
+    pt1.y <=> pt2.y
+  end
+end
+
+def sort(array)
+  array.sort { |pt1, pt2| compare(pt1, pt2) }
+end
+
+module Codenjoy
+  module Client
+    module Games
+      module Tetris
+      end
+    end
+  end
+end
+
+class Codenjoy::Client::Games::Tetris::Board
+  attr_accessor :board
+  attr_accessor :size
+  attr_accessor :current_figure_type
+  attr_accessor :future_figures
+  attr_accessor :current_figure_point
+
+  def process(str)
+    puts "-------------------------------------------------------------------------------------------"
+    json = JSON.parse(str)
+    @board = json["layers"][0]
+    @size = Math.sqrt(@board.length).round
+    @current_figure_type = json["currentFigureType"]
+    @future_figures = json["futureFigures"]
+    @current_figure_point = Point.new(json["currentFigurePoint"]["x"], json["currentFigurePoint"]["y"])
+  end
+
+  def to_s
+    return ("currentFigure: \"" + @current_figure_type + "\" at: " + @current_figure_point.to_s + "\n" +
+       "futureFigures: " + @future_figures.to_s + "\n" +
+       "board:" + "\n" +
+       @board.scan(/.{#{@size}}|.+/).join("\n"))
+  end
+
+  # Returns board size
+  # @return [Integer] board size
+  def size
+    Math.sqrt(board.length).to_i
+  end
+
+  # Get object at position
+  #
+  # @param [Point] point position
+  # @return [String] char with object, compare with +ELEMENTS[...]+
+  def get_at(point)
+    board[coords_to_pos(point)]
+  end
+
+  # Is element type/s is at specified X,Y?
+  #
+  # @param [Point] point position
+  # @param [String, Array] element one or array of +ELEMENTS[...]+
+  # @return [Boolean] if +element+ at position
+  def is_at?(point, element)
+    if element.is_a?(Array)
+      element.include?(get_at(point))
+    elsif element.is_a?(String)
+      get_at(point) == element
+    else
+      raise ArgumentError.new("Invalid argument type #{element.class}")
+    end
+  end
+
+  # Check if element is near position
+  #
+  # @param [Point] point position
+  # @param [String, Array] element one or array of +ELEMENTS[...]+
+  def get_near(point)
+    res = []
+
+    for dx in -1..1
+      for dy in -1..1
+        if dx == 0 && dy == 0
+          next
+        end
+        res << get_at(Point.new(point.x + dx, point.y + dy))
+      end
+    end
+
+    res.empty? ? nil : res
+  end
+
+  # Count how many objects of specified type around position
+  #
+  # @param [Point] point position
+  # @param [String, Array] element  one or array of +ELEMENTS[...]+
+  # @return [Integer] number of objects around
+  def count_near(point, element)
+    elements = get_near(point)
+    elements.count { |it| it == element }
+  end
+
+  # Count how many objects of specified type around position
+  #
+  # @param [Point] point position
+  # @param [String, Array] element  one or array of +ELEMENTS[...]+
+  # @return [Integer] number of objects around
+  def is_near?(point, element)
+    elements = get_near(point)
+    elements.find { |it| it == element } != nil
+  end
+
+  # Check if figures (elements of +FIGURES+ array) at position
+  #
+  # @param [Point] point position
+  # @return [Boolean] true if barrier at
+  def is_free?(point)
+    element = board[coords_to_pos(point)]
+    !FIGURES.include? element
+  end
+
+  # List of given elements
+  #
+  # @param [String, Array] element  one or array of +ELEMENTS[...]+
+  # @return [Array[Point]] list of barriers on the filed
+  def get(element)
+    res = []
+    pos = 0
+    board.chars.each do |ch|
+      if element.is_a?(Array)
+        res << pos_to_coords(pos) if element.include? ch
+      elsif element.is_a?(String)
+        res << pos_to_coords(pos) if element == ch
+      else
+        raise ArgumentError.new("Invalid argument type #{element.class}")
+      end
+      pos += 1
+    end
+
+    sort(res)
+  end
+
+  # List of busy spaces in the glass
+  #
+  # @return [Array[Point]] list of barriers on the filed
+  def get_figures
+    get(FIGURES)
+  end
+
+  # Return list of free spaces in the glass
+  #
+  # @return [Array[Point]] array of walls positions
+  def get_free_space
+    get(ELEMENTS[:NONE])
+  end
+
+  # How far specified element from position (strait direction)
+  # Return +size+ if wall in specified direction
+  #
+  # @param [Point] point position
+  # @param [String] direction direction 'UP', 'DOWN', 'LEFT', 'RIGHT'
+  # @param [String] element on of +ELEMENTS[...]+
+  # @return [Integer] distance
+  def next_element_in_direction(point, direction, element)
+    dirs = {
+        'UP'    => [0, -1],
+        'DOWN'  => [0, +1],
+        'LEFT'  => [-1, 0],
+        'RIGHT' => [+1, 0],
+    }
+
+    (1..size).each do |distance|
+      el = get_at(
+          Point.new(
+              (point.x + distance * dirs[direction].first),
+              (point.y + distance * dirs[direction].last)
+          )
+      )
+
+      return size if element == ELEMENTS[:WALL]
+      return distance if element == el
+    end
+
+    size
+  end
+
+  # Converts position in +board+ string to coords
+  #
+  # @param [Integer] pos position in string
+  # @return [Point] point object
+  def pos_to_coords(pos)
+    x = (pos % size)
+    y = size - 1 - (pos / size).to_i
+
+    Point.new x, y
+  end
+
+  # Converts position in +board+ string to coords
+  #
+  # @param [Point] point position
+  # @return [Integer] position in +board+ string
+  def coords_to_pos(point)
+    (size - 1 - point.y) * size + point.x
+  end
+end

data/lib/codenjoy/utils.rb

@@ -0,0 +1,47 @@
+class Point
+  attr_accessor :x
+  attr_accessor :y
+
+  # Coords (1,1) - upper left side of field
+  #
+  # @param [Integer] x X coord
+  # @param [Integer] y Y coord
+  def initialize(x, y)
+    @x = x
+    @y = y
+  end
+
+  # Override of compare method for Point
+  def == (other_object)
+    other_object.x == @x && other_object.y == @y
+  end
+
+  # For better +.inspect+ output
+  def to_s
+    "[#{@x},#{@y}]"
+  end
+
+  # Position of point above current
+  def up
+    Point.new(@x, @y + 1)
+  end
+
+  # Position of point below current
+  def down
+    Point.new(@x, @y - 1)
+  end
+
+  # Position of point on the left side
+  def left
+    Point.new(@x - 1, @y)
+  end
+
+  # Position of point on the right side
+  def right
+    Point.new(@x + 1, @y)
+  end
+
+  def out_of?(board_size)
+    x >= board_size || y >= board_size || x < 0 || y < 0;
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: codenjoy-client
 version: !ruby/object:Gem::Version
-  version: 0.1.002
+  version: 0.1.003
 platform: ruby
 authors:
 - vgulaev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-02-23 00:00:00.000000000 Z
+date: 2020-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faye-websocket
@@ -63,6 +63,8 @@ files:
 - lib/codenjoy/client/version.rb
 - lib/codenjoy/game_base_client.rb
 - lib/codenjoy/games/battlecity/board.rb
+- lib/codenjoy/games/tetris/board.rb
+- lib/codenjoy/utils.rb
 homepage: https://github.com/vgulaev/codenjoy-client
 licenses:
 - MIT