#!/usr/bin/ruby

require "io/console"

I = [[0, -1], [0, 1], [1, 0], [-1, 0], !1]

K = ["\e[0m"] + "#,'h_(e(#kek#df/)de/`(f)f.#j".scan(/../).map{|x|"\e[#{x.ord-5};#{x[1].ord}m"} + "##  []()@@OO%%XX++".scan(/../)

a = IO.console.winsize
R = a[0] - 2
U = ~-a[1] / 2

G =
   "aqqqyydraqqyfsaqqydrraqyfssaqyerrraygsssaydrrrayfsssaycpyybqyyerydryfsygsyetyguyjvykpyhvyipyhwyixyltymuycryycsyya".split(/y/).map{|x|
      x == "" ? a
              : a = x.bytes.map{|y| K[y - 97]} * ""
   }

A = (a = ARGV[0].to_f) >= 0.1 ? 1 / a : 0.2


if R < 10 || U < 19
   print "console too small\n"
   exit
end


r = 1
c = 1
d = 2
h = []
g = 2
s = 0
b = 8
m = 0
n = 0
l = 0
fc = 0
f = !1
e = !1

a = [0] * 8
j = 0
k = 0

u = [*1..(U - 2)].product([*1..(R - 2)]).shuffle
v = 0

o = []
R.times{|i|
   o += [[5] + [i > 0 && i < R - 1 ? 6 : 5] * (U - 2) + [5]]
}

o[q = R / 2][p = U / 4] = 9

o[q][U - p] = 8

z = 4

ef = ->(x, y) {
   f = z % 6 / 3 + 7

   r = *-1..1
   r.product(r).all?{|p, q|
      r = o[y + q][x + p]
      r == f || r == 6
   }
}

u.map{|x, y|
   if
      (y - q).abs > 1 &&
      rand < 0.1 &&
      ef.call(x, y)

      o[y][x] = f
      z += 1
   end
}


rf = -> {
   x = " #{s}"
   y = " " * (U * 2 - 6 - x.size)
   if n > 0
      y = "  %-#{U * 2 - 8 - x.size}s" % "#{n} chain"
      i = [y.size, n * 2].min
      y = K[n > 9 ? (y.upcase!; 14) : 13] +
          y[0, i] + "\e[0m" + y[i, y.size]
   end

   print "\e[#{R + 1}A\r" +
         G[m * 2 + b - 7] + y +
         "\e[1m" + x + "\e[0m\n\r" +
         o.map{|p|
            p.map{|q| G[q * 2 + c]} * ""
         } * "\e[0m\n\r" +
         "\n"
}


T = Thread.new{
   while r
      i = "\e[".index(y = STDIN.getch) ? !1 : ("AwBsCdDa".index(y) || 8) / 2

      if i
         a[x = -~j % 8] = i
         j = x
      end
   end
}


STDIN.echo = !1
print "\e[?25l\n" * R


rf.call

lt = Time::now
while r
   if m > 2
      print "\e[#{R + 1}A\r#{G[b - 1 + fc]}\e[#{R + 1}B"
      fc ^= 2
   end

   if k != j
      i = I[w = a[k = -~k % 8]]
      i = i ? o[q + i[1]][p + i[0]] : (c ^= 1)

      if i >= 6 && i <= 8
         d = w

         lt = Time.at(0)
      else
         rf.call
      end
   end

   ct = Time::now
   if ct - lt < A
      sleep 0.02
   else
      lt = ct

      h += t = [[p, q]]
      o[q][p] = 10
      t += [i = h[h.size / 2]]
      o[i[1]][i[0]] = 11
      t += [i = h[h.size / 4]]
      o[i[1]][i[0]] = 12

      i = I[d]
      i = o[q += i[1]][p += i[0]]
      if i != 6
         if i == c + 7
            s += 10
            if m % 3 > 0
               if b == i
                  m += 1
                  if m == 3
                     n += 1
                     l = [l, n].max
                     s += 2 ** [n - 1, 8].min * 100
                  end
               else
                  b = i
                  m = 1
                  n = 0
               end
            else
               b = i
               m = 1
            end
            g += 2

            o[q][p] = 9

            w = 0
            3.times{|i|
               u.size.times{
                  if (w & (1 << i)) < 1
                     x, y = u[v = -~v % u.size]

                     if [o[y][x] == 6,
                         (x - p).abs > 3 || (y - q).abs > 3,
                         ef.call(x, y)].take(3 - i).all?
                        e ||= i > 0 && (o[R - 1][U - 1] = f + 7)

                        o[y][x] = f

                        w = rand < 0.1 ? 6 : 7

                        z += e ? 0 : 1
                     end
                  end
               }
            }

            rf.call

         else
            o[q][p] = 13
            rf.call

            print "\e[#{R / 2 + 1}A\r\e[#{U - 8}C\e[0m    GAME OVER    ",
                  "\n\r" * (R / 2)
            r = !1
         end
      else
         o[q][p] = 9
         t += [[p, q]]

         if h.size > g
            x, y = h.shift
            o[y][x] = 6
            t += [[x, y]]

            if m == 3
               m = 0

               rf.call

            end
         end

         print "\e[#{R}A" +
               t.map{|x, y|
                  "\e[#{y}B\r\e[#{x * 2}C" +
                  G[o[y][x] * 2 + c] +
                  "\e[#{y}A"
               } * "" +
               "\e[#{R}B"
      end
   end
end

T.join

rf.call

x = (R - 2) * (U - 2)
g = "Dot eater"
if l > 0
   y = x / 2
   4.times{|i|
      if h.size > x * (i * 0.3 - 0.1) ||
         s > y * 10 + y / 3 * 100 * 2 ** (i * 3 - 2)
         g = "CBAS"[i]
      end
   }
end

print "\e[0m\e[?25h\nArea: \e[1m#{h.size * 100 / x}%\e[0m\nScore: \e[1m#{s}\e[0m\nMax: \e[1m#{l} chain\e[0m\nGrade: \e[1m#{g}\e[0m\n"

STDIN.echo = true