codenjoy-client 0.1.006 → 0.1.007

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75013fae9cc5a55799da8ef5bc5575cd22c5b4480838e003facb7afb7020b85c
-  data.tar.gz: 4b9379e52b4e73270e8579d4b5975896b28e11cb0731d4e51762bfcbc8a2db46
+  metadata.gz: a4294e66ffc1a27e53301dd0f5e35988cdb569a6f6302251221d40bdcdbb2095
+  data.tar.gz: d0764a9de7c1fae7fcd4aa6c60a53a18cd919a6f92fd87edebc8b91e642193c9
 SHA512:
-  metadata.gz: 6ba6840c23438db3a065ee91fc67cfbd16b853768c783431628fd5ee0fbbea811da629037dec1c16103bcf18f9ddad8f5abdc239f80a2026de7530af39199fb8
-  data.tar.gz: 04ca47238dec98e7d7edca8d1eef97b800f6a408d2a7f63079552d3e7461aa213b0a49bd7e63199bfbb52e74182adb0d64c06b06ab240dbe466535841ad85f55
+  metadata.gz: 3f236bd121dfe6c3b75411f39e665a71ff0ab6bad931e480958bd01122913829220bbc4008e5b2b08b7e302e28223152b09a0f2d36a758828992a799d88477d2
+  data.tar.gz: 5d009ade6891ac661abc53e086318106e1c28b0ac92f670408cd4d03eea336563e19a6cbf5dbba24bc993073313067e8b611f723265f94e8c6cdfa85c61743af

data/bin/console

@@ -2,6 +2,7 @@
 
 require "bundler/setup"
 require "codenjoy/client"
+require "codenjoy/games/tetris/board"
 
 # 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.

data/exe/codenjoy-ruby-client

@@ -1,16 +1,29 @@
 #!/usr/bin/env ruby
 
-# require "pathname"
-require "codenjoy/client"
+require 'fileutils'
+require 'codenjoy/client'
 
 game = Codenjoy::Client::Game::new
 sourse = "#{game.source_path}/game_base_client.rb"
 dest = "#{Dir.pwd}/game_base_client.rb"
 
-p "#{sourse} ==> #{dest}"
-if File.exist?(dest)
-  p "File already exist"
-else
-  FileUtils.cp(sourse, dest)
+puts "codenjoy-ruby-client util for develop ruby client for https://dojorena.io/"
+puts "--game common cases"
+puts "--dev for dev mode"
+
+# def add_dev_line
+# end
+
+if ['--dev', '--game'].include?(ARGV[0])
+  p "#{sourse} ==> #{dest}"
+  if File.exist?(dest)
+    p "File already exist"
+  else
+    FileUtils.cp(sourse, dest)
+    if '--dev' == ARGV[0]
+      text = "require 'bundler/setup'\n#{File.read(dest)}"
+      File.open(dest, "w") { |file| file.write(text) }
+    end
+  end
 end
 

data/lib/codenjoy/base_board.rb

@@ -0,0 +1,61 @@
+require "codenjoy/utils"
+
+class BaseBoard
+  def xyl
+    @xyl ||= LengthToXY.new(size);
+  end
+
+  def size
+    @size ||= Math.sqrt(@raw.length);
+  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_at(x, y)
+    return false if Point.new(x, y).out_of?(size)
+    @raw[xyl.getLength(x, y)]
+  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;
+  end
+
+  def near?(x, y, element)
+    return false if Point.new(x, y).out_of?(size)
+    at?(x + 1, y, element) || at?(x - 1, y, element) || at?(x, y + 1, element) || at?(x, y - 1, element)
+  end
+
+  def at?(x, y, element)
+    return false if Point.new(x, y).out_of?(size)
+    get_at(x, y) == element;
+  end
+
+  def find_all(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 find_by_list(list)
+    list.map{ |e| find_all(e) }.flatten.map{ |e| [e.x, e.y] }
+  end
+
+  def count_near(x, y, element)
+    return 0 if Point.new(x, y).out_of?(size)
+    count = 0
+    count += 1 if at?(x - 1, y    , element)
+    count += 1 if at?(x + 1, y    , element)
+    count += 1 if at?(x    , y - 1, element)
+    count += 1 if at?(x    , y + 1, element)
+    count
+  end
+end

data/lib/codenjoy/client/version.rb

@@ -1,5 +1,5 @@
 module Codenjoy
   module Client
-    VERSION = "0.1.006"
+    VERSION = "0.1.007"
   end
 end

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

@@ -21,34 +21,7 @@
 ###
 
 require "codenjoy/utils"
-require 'json'
-
-class LengthToXY
-  def initialize(board_size)
-    @board_size = board_size
-  end
-
-  def inversionY(y)
-    @board_size - 1 - y;
-  end
-
-  def inversionX(x)
-    x;
-  end
-
-  def getXY(length)
-    return nil if (length == -1)
-    x = inversionX(length % @board_size);
-    y = inversionY((length / @board_size).floor);
-    return Point.new(x, y);
-  end
-
-  def getLength(x, y)
-      xx = inversionX(x);
-      yy = inversionY(y);
-      yy * @board_size + xx;
-  end
-end
+require "codenjoy/base_board"
 
 module Codenjoy
   module Client
@@ -59,7 +32,7 @@ module Codenjoy
   end
 end
 
-class Codenjoy::Client::Games::Battlecity::Board
+class Codenjoy::Client::Games::Battlecity::Board < BaseBoard
 
   ELEMENTS = {
     NONE: ' ',
@@ -147,33 +120,10 @@ class Codenjoy::Client::Games::Battlecity::Board
     @raw = data
   end
 
-  def size
-    @size ||= Math.sqrt(@raw.length);
-  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 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;
-  end
-
   def get_me
     me = find_by_list(TANK)
     return nil if me.nil?
@@ -181,7 +131,7 @@ class Codenjoy::Client::Games::Battlecity::Board
   end
 
   def find_by_list(list)
-    result = list.map{ |e| findAll(e) }.flatten.map{ |e| [e.x, e.y] }
+    result = list.map{ |e| find_all(e) }.flatten.map{ |e| [e.x, e.y] }
     return nil if (result.length == 0)
     result
   end
@@ -200,7 +150,7 @@ class Codenjoy::Client::Games::Battlecity::Board
     (-1..1).each do |dx|
       (-1..1).each do |dy|
           next if (dx == 0 && dy == 0)
-          result.push(getAt(x + dx, y + dy))
+          result.push(get_at(x + dx, y + dy))
       end
     end
     result;
@@ -223,7 +173,7 @@ class Codenjoy::Client::Games::Battlecity::Board
 
   def bullet_at?(x, y)
     return false if Point.new(x, y).out_of?(size)
-    getAt(x, y) == ELEMENTS[:BULLET]
+    get_at(x, y) == ELEMENTS[:BULLET]
   end
 
   def any_of_at?(x, y, elements = [])
@@ -238,10 +188,6 @@ class Codenjoy::Client::Games::Battlecity::Board
     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 get_barriers
     find_by_list(BARRIERS)
   end

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

@@ -0,0 +1,223 @@
+###
+# #%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 "codenjoy/utils"
+require "codenjoy/base_board"
+
+module Codenjoy
+  module Client
+    module Games
+      module Icancode
+      end
+    end
+  end
+end
+
+class Layer < BaseBoard
+  def initialize(data)
+    @raw = data
+  end
+end
+
+class Codenjoy::Client::Games::Icancode::Board
+
+  ELEMENT = {
+    EMPTY: '-',
+    FLOOR: '.',
+
+    ANGLE_IN_LEFT: '╔',
+    WALL_FRONT: '═',
+    ANGLE_IN_RIGHT: '┐',
+    WALL_RIGHT: '│',
+    ANGLE_BACK_RIGHT: '┘',
+    WALL_BACK: '─',
+    ANGLE_BACK_LEFT: '└',
+    WALL_LEFT: '║',
+    WALL_BACK_ANGLE_LEFT: '┌',
+    WALL_BACK_ANGLE_RIGHT: '╗',
+    ANGLE_OUT_RIGHT: '╝',
+    ANGLE_OUT_LEFT: '╚',
+    SPACE: ' ',
+
+    LASER_MACHINE_CHARGING_LEFT: '˂',
+    LASER_MACHINE_CHARGING_RIGHT: '˃',
+    LASER_MACHINE_CHARGING_UP: '˄',
+    LASER_MACHINE_CHARGING_DOWN: '˅',
+
+    LASER_MACHINE_READY_LEFT: '◄',
+    LASER_MACHINE_READY_RIGHT: '►',
+    LASER_MACHINE_READY_UP: '▲',
+    LASER_MACHINE_READY_DOWN: '▼',
+
+    START: 'S',
+    EXIT: 'E',
+    HOLE: 'O',
+    BOX: 'B',
+    ZOMBIE_START: 'Z',
+    GOLD: '$',
+
+    ROBOT: '☺',
+    ROBOT_FALLING: 'o',
+    ROBOT_FLYING: '*',
+    ROBOT_LASER: '☻',
+
+    ROBOT_OTHER: 'X',
+    ROBOT_OTHER_FALLING: 'x',
+    ROBOT_OTHER_FLYING: '^',
+    ROBOT_OTHER_LASER: '&',
+
+    LASER_LEFT: '←',
+    LASER_RIGHT: '→',
+    LASER_UP: '↑',
+    LASER_DOWN: '↓',
+
+    FEMALE_ZOMBIE: '♀',
+    MALE_ZOMBIE: '♂',
+    ZOMBIE_DIE: '✝'
+  }
+
+  WALLS = [
+    :ANGLE_IN_LEFT, :WALL_FRONT, :ANGLE_IN_RIGHT, :WALL_RIGHT, :ANGLE_BACK_RIGHT,
+    :WALL_BACK, :ANGLE_BACK_LEFT, :WALL_LEFT, :WALL_BACK_ANGLE_LEFT, :WALL_BACK_ANGLE_RIGHT,
+    :ANGLE_OUT_RIGHT, :ANGLE_OUT_LEFT, :SPACE
+  ]
+
+  attr_accessor :l1, :l2, :l3 # short names for layers
+
+  def command
+    # 'up'                // you can move
+    # 'down'
+    # 'left'
+    # 'right'
+    # 'act(1)'            // jump
+    # 'act(2)'            // pull box
+    # 'act(3)'            // fire
+    # 'act(0)'            // die
+  end
+
+  def process(data)
+    @data = JSON.parse(data)
+    @raw = @data["layers"][0]
+    @l1 = Layer.new(@data["layers"][0])
+    @l2 = Layer.new(@data["layers"][1])
+    @l3 = Layer.new(@data["layers"][2])
+  end
+
+  def nline(i)
+    return " 0" if 0 == i
+    format("%02.0d", i)
+  end
+
+  def numberinline(length)
+    Array.new(length) { |i| (i % 10).to_s }.join
+  end
+
+  def headfoot
+    Array.new(3).map{ |i| "  " + numberinline(size) }.join
+  end
+
+  def headlayers
+    spaces = ([' '] * (size - 6)).join()
+    @data["layers"].each_with_index.map{ |e, n| " Layers#{n + 1}#{spaces}" }.join('')
+  end
+
+  def get_me
+    [@data['heroPosition']['x'], @data['heroPosition']['y']]
+  end
+
+  def get_other_heroes
+    l2.find_by_list([
+      :ROBOT_OTHER, :ROBOT_OTHER_FALLING, :ROBOT_OTHER_LASER
+    ].map{ |e| ELEMENT[e] }) + l3.find_by_list([ELEMENT[:ROBOT_OTHER_FLYING]])
+  end
+
+  def get_gold
+    l1.find_by_list([ELEMENT[:GOLD]])
+  end
+
+  def get_starts
+    l1.find_by_list([ELEMENT[:START]])
+  end
+
+  def get_exits
+    l1.find_by_list([ELEMENT[:EXIT]])
+  end
+
+  def get_boxes
+    l2.find_by_list([ELEMENT[:BOX]])
+  end
+
+  def get_holes
+    l1.find_by_list([ELEMENT[:HOLE]])
+  end
+
+  def get_laser_machines
+    l1.find_by_list([:LASER_MACHINE_CHARGING_LEFT, :LASER_MACHINE_CHARGING_RIGHT,
+    :LASER_MACHINE_CHARGING_UP, :LASER_MACHINE_CHARGING_DOWN,
+    :LASER_MACHINE_READY_LEFT, :LASER_MACHINE_READY_RIGHT,
+    :LASER_MACHINE_READY_UP, :LASER_MACHINE_READY_DOWN].map{ |e| ELEMENT[e] })
+  end
+
+  def get_lasers
+    l2.find_by_list([:LASER_LEFT, :LASER_RIGHT, :LASER_UP, :LASER_DOWN].map{ |e| ELEMENT[e] })
+  end
+
+  def get_zombies
+    l2.find_by_list([:FEMALE_ZOMBIE, :MALE_ZOMBIE, :ZOMBIE_DIE].map{ |e| ELEMENT[e] })
+  end
+
+  def get_walls
+    l1.find_by_list(WALLS.map{ |e| ELEMENT[e] })
+  end
+
+  def wall_at?(x, y)
+    WALLS.map{ |e| ELEMENT[e] }.include?(l1.get_at(x,y))
+  end
+
+  def infoline(n)
+    res = [
+      " Robots: #{get_me}, #{get_other_heroes}",
+      " Gold: #{get_gold}",
+      " Starts: #{get_starts}",
+      " Exits: #{get_exits}",
+      " Boxes: #{get_boxes}",
+      " Holes: #{get_holes}",
+      " LaserMachine: #{get_laser_machines}",
+      " Lasers: #{get_lasers}",
+      " Zombies: #{get_zombies}"
+    ]
+    d = 1
+    return res[n - d] if d <= n && n < res.size + d
+    ""
+  end
+
+  def board_to_s
+    ([headlayers, headfoot] +
+    Array.new(size).each_with_index.map do |e, n|
+      @data["layers"].map{ |l| nline(size - n - 1) + l[(n * size)..((n + 1) * size - 1)] }.join + infoline(n)
+    end + [headfoot]).join("\n")
+  end
+
+  def to_s
+    board_to_s
+  end
+end

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

@@ -0,0 +1,190 @@
+###
+# #%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 "codenjoy/utils"
+require "codenjoy/base_board"
+
+module Codenjoy
+  module Client
+    module Games
+      module Loderunner
+      end
+    end
+  end
+end
+
+class Codenjoy::Client::Games::Loderunner::Board < BaseBoard
+
+  ELEMENTS = {
+    # a void
+    NONE: ' ',
+
+    # walls
+    BRICK: '#',
+    PIT_FILL_1: '1',
+    PIT_FILL_2: '2',
+    PIT_FILL_3: '3',
+    PIT_FILL_4: '4',
+    UNDESTROYABLE_WALL: '☼',
+
+    DRILL_PIT: '*',
+
+    # this is enemy
+    ENEMY_LADDER: 'Q',
+    ENEMY_LEFT: '«',
+    ENEMY_RIGHT: '»',
+    ENEMY_PIPE_LEFT: '<',
+    ENEMY_PIPE_RIGHT: '>',
+    ENEMY_PIT: 'X',
+
+    # gold ;)
+    GOLD: '$',
+
+    # this is you
+    HERO_DIE: 'Ѡ',
+    HERO_DRILL_LEFT: 'Я',
+    HERO_DRILL_RIGHT: 'R',
+    HERO_LADDER: 'Y',
+    HERO_LEFT: '◄',
+    HERO_RIGHT: '►',
+    HERO_FALL_LEFT: ']',
+    HERO_FALL_RIGHT: '[',
+    HERO_PIPE_LEFT: '{',
+    HERO_PIPE_RIGHT: '}',
+
+    # this is other players
+    OTHER_HERO_DIE: 'Z',
+    OTHER_HERO_LEFT: ')',
+    OTHER_HERO_RIGHT: '(',
+    OTHER_HERO_LADDER: 'U',
+    OTHER_HERO_PIPE_LEFT: 'Э',
+    OTHER_HERO_PIPE_RIGHT: 'Є',
+
+    # ladder and pipe - you can walk
+    LADDER: 'H',
+    PIPE: '~'
+  };
+
+  HERO = [
+    :HERO_DIE, :HERO_DRILL_LEFT, :HERO_DRILL_RIGHT,
+    :HERO_FALL_RIGHT, :HERO_FALL_LEFT, :HERO_LADDER,
+    :HERO_LEFT, :HERO_RIGHT, :HERO_PIPE_LEFT, :HERO_PIPE_RIGHT
+  ]
+
+  OTHER_HERO = [
+    :OTHER_HERO_LEFT, :OTHER_HERO_RIGHT, :OTHER_HERO_LADDER, :OTHER_HERO_PIPE_LEFT, :OTHER_HERO_PIPE_RIGHT
+  ]
+
+  ENEMY = [
+    :ENEMY_LADDER, :ENEMY_LADDER, :ENEMY_LEFT, :ENEMY_PIPE_LEFT, :ENEMY_PIPE_RIGHT, :ENEMY_RIGHT, :ENEMY_PIT
+  ]
+
+  PIPE = [
+    :PIPE, :HERO_PIPE_LEFT, :HERO_PIPE_RIGHT, :OTHER_HERO_PIPE_LEFT, :OTHER_HERO_PIPE_RIGHT
+  ]
+
+  def process(data)
+    @raw = data
+  end
+
+  def to_s
+    [
+      "Board:",
+      board_to_s,
+      "Me at: #{get_me}",
+      "Other heroes at: #{get_other_heroes}",
+      "Enemies at: #{get_enemies}",
+      "Gold at: #{get_gold}"
+    ].join("\n")
+  end
+
+  def get_me
+    find_by_list(HERO.map{ |e| ELEMENTS[e] })
+  end
+
+  def get_other_heroes
+    find_by_list(OTHER_HERO.map{ |e| ELEMENTS[e] })
+  end
+
+  def get_enemies
+    find_by_list(ENEMY.map{ |e| ELEMENTS[e] })
+  end
+
+  def get_gold
+    find_by_list([ELEMENTS[:GOLD]])
+  end
+
+  def get_walls
+    find_by_list([ELEMENTS[:BRICK], ELEMENTS[:UNDESTROYABLE_WALL]])
+  end
+
+  def get_ladders
+    find_by_list([ELEMENTS[:LADDER], ELEMENTS[:HERO_LADDER], ELEMENTS[:ENEMY_LADDER]])
+  end
+
+  def get_pipes
+    find_by_list(PIPE.map{ |e| ELEMENTS[e] })
+  end
+
+  def game_over?
+    !@raw.index(ELEMENTS[:HERO_DIE]).nil?
+  end
+
+  def get_barriers
+    [get_enemies, get_other_heroes, get_walls].flatten(1)
+  end
+
+  def barrier_at?(x, y)
+    return false if Point.new(x, y).out_of?(size)
+    !get_barriers.index([x, y]).nil?
+  end
+
+  def enemy_at?(x, y)
+    return false if Point.new(x, y).out_of?(size)
+    any_of_at?(x, y, ENEMY.map{ |e| ELEMENTS[e] })
+  end
+
+  def other_hero_at?(x, y)
+    return false if Point.new(x, y).out_of?(size)
+    any_of_at?(x, y, OTHER_HERO.map{ |e| ELEMENTS[e] })
+  end
+
+  def wall_at?(x, y)
+    return false if Point.new(x, y).out_of?(size)
+    any_of_at?(x, y, [ELEMENTS[:BRICK], ELEMENTS[:UNDESTROYABLE_WALL]])
+  end
+
+  def ladder_at?(x, y)
+    return false if Point.new(x, y).out_of?(size)
+    any_of_at?(x, y, [ELEMENTS[:LADDER], ELEMENTS[:HERO_LADDER], ELEMENTS[:ENEMY_LADDER]])
+  end
+
+  def gold_at?(x, y)
+    return false if Point.new(x, y).out_of?(size)
+    at?(x, y, ELEMENTS[:GOLD])
+  end
+
+  def pipe_at?(x, y)
+    return false if Point.new(x, y).out_of?(size)
+    any_of_at?(x, y, PIPE.map{ |e| ELEMENTS[e] })
+  end
+end

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

@@ -0,0 +1,89 @@
+require "codenjoy/utils"
+require "codenjoy/base_board"
+
+module Codenjoy
+  module Client
+    module Games
+      module Snake
+      end
+    end
+  end
+end
+
+class Codenjoy::Client::Games::Snake::Board < BaseBoard
+  ELEMENTS = {
+    BAD_APPLE: '☻',
+    GOOD_APPLE: '☺',
+
+    BREAK: '☼',
+
+    HEAD_DOWN: '▼',
+    HEAD_LEFT: '◄',
+    HEAD_RIGHT: '►',
+    HEAD_UP: '▲',
+
+    TAIL_END_DOWN: '╙',
+    TAIL_END_LEFT: '╘',
+    TAIL_END_UP: '╓',
+    TAIL_END_RIGHT: '╕',
+    TAIL_HORIZONTAL: '═',
+    TAIL_VERTICAL: '║',
+    TAIL_LEFT_DOWN: '╗',
+    TAIL_LEFT_UP: '╝',
+    TAIL_RIGHT_DOWN: '╔',
+    TAIL_RIGHT_UP: '╚',
+
+    NONE: ' '
+  }
+
+  def process(str)
+    puts "-------------------------------------------------------------------------------------------"
+    puts str
+    @raw = str
+  end
+
+  def get_my_head
+    find_by_list([:HEAD_DOWN, :HEAD_UP, :HEAD_RIGHT, :HEAD_LEFT].map{ |e| ELEMENTS[e] })
+  end
+
+  def get_my_body
+    find_by_list([
+      :HEAD_DOWN, :HEAD_LEFT, :HEAD_RIGHT, :HEAD_UP,
+      :TAIL_END_DOWN, :TAIL_END_LEFT, :TAIL_END_UP,
+      :TAIL_END_RIGHT, :TAIL_HORIZONTAL, :TAIL_VERTICAL,
+      :TAIL_LEFT_DOWN, :TAIL_LEFT_UP, :TAIL_RIGHT_DOWN, :TAIL_RIGHT_UP
+    ].map{ |e| ELEMENTS[e] })
+  end
+
+  def get_apple
+    find_by_list([ELEMENTS[:GOOD_APPLE]])
+  end
+
+  def get_stone
+    find_by_list([ELEMENTS[:BAD_APPLE]])
+  end
+
+  def get_walls
+    find_by_list([ELEMENTS[:BREAK]])
+  end
+
+  def get_barriers
+    find_by_list([ELEMENTS[:BREAK], ELEMENTS[:BAD_APPLE]])
+  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 to_s
+    [
+      "Board:",
+      board_to_s,
+      "My head at: #{get_my_head}",
+      "My body at: #{get_my_body}",
+      "Apple at: #{get_apple}",
+      "Stone at: #{get_stone}"
+    ].join("\n")
+  end
+end

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

@@ -22,54 +22,6 @@
 require "codenjoy/utils"
 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
@@ -80,12 +32,39 @@ module Codenjoy
 end
 
 class Codenjoy::Client::Games::Tetris::Board
+  # This is glass content
+  ELEMENTS = {
+    :I_BLUE => 'I',
+    :J_CYAN => 'J',
+    :L_ORANGE => 'L',
+    :O_YELLOW => 'O',
+    :S_GREEN => 'S',
+    :T_PURPLE => 'T',
+    :Z_RED => 'Z',
+    :NONE => '.',
+  }
+
+  FIGURES = [:I_BLUE, :J_CYAN, :L_ORANGE, :O_YELLOW, :S_GREEN, :T_PURPLE, :Z_RE]
+              .map{ |e| Codenjoy::Client::Games::Tetris::Board::ELEMENTS[e] }
+
   attr_accessor :board
   attr_accessor :size
   attr_accessor :current_figure_type
   attr_accessor :future_figures
   attr_accessor :current_figure_point
 
+  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
+
   def process(str)
     puts "-------------------------------------------------------------------------------------------"
     json = JSON.parse(str)
@@ -212,7 +191,7 @@ class Codenjoy::Client::Games::Tetris::Board
   #
   # @return [Array[Point]] array of walls positions
   def get_free_space
-    get(ELEMENTS[:NONE])
+    get(Codenjoy::Client::Games::Tetris::Board::ELEMENTS[:NONE])
   end
 
   # How far specified element from position (strait direction)
@@ -238,7 +217,7 @@ class Codenjoy::Client::Games::Tetris::Board
           )
       )
 
-      return size if element == ELEMENTS[:WALL]
+      return size if element == Codenjoy::Client::Games::Tetris::Board::ELEMENTS[:WALL]
       return distance if element == el
     end
 

data/lib/codenjoy/utils.rb

@@ -45,3 +45,30 @@ class Point
     x >= board_size || y >= board_size || x < 0 || y < 0;
   end
 end
+
+class LengthToXY
+  def initialize(board_size)
+    @board_size = board_size
+  end
+
+  def inversionY(y)
+    @board_size - 1 - y;
+  end
+
+  def inversionX(x)
+    x;
+  end
+
+  def getXY(length)
+    return nil if (length == -1)
+    x = inversionX(length % @board_size);
+    y = inversionY((length / @board_size).floor);
+    return Point.new(x, y);
+  end
+
+  def getLength(x, y)
+      xx = inversionX(x);
+      yy = inversionY(y);
+      yy * @board_size + xx;
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: codenjoy-client
 version: !ruby/object:Gem::Version
-  version: 0.1.006
+  version: 0.1.007
 platform: ruby
 authors:
 - vgulaev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-02-27 00:00:00.000000000 Z
+date: 2020-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faye-websocket
@@ -58,10 +58,14 @@ files:
 - bin/setup
 - codenjoy-client.gemspec
 - exe/codenjoy-ruby-client
+- lib/codenjoy/base_board.rb
 - lib/codenjoy/client.rb
 - lib/codenjoy/client/version.rb
 - lib/codenjoy/game_base_client.rb
 - lib/codenjoy/games/battlecity/board.rb
+- lib/codenjoy/games/icancode/board.rb
+- lib/codenjoy/games/loderunner/board.rb
+- lib/codenjoy/games/snake/board.rb
 - lib/codenjoy/games/tetris/board.rb
 - lib/codenjoy/utils.rb
 homepage: https://github.com/vgulaev/codenjoy-client