Threes_object.vim

let s:suite = themis#suite('Threes object')
let s:assert = themis#helper('assert')

function! s:suite.tiles()
  let t = threes#new()
  call t.new_game()
  call s:assert.equals(t.width(), 4)
  call s:assert.equals(t.height(), 4)
  call s:assert.not_same(t._state.tiles[0], t._state.tiles[1])
endfunction

function! s:suite.tile_list()
  let t = threes#new()
  call t.new_game()
  let t._state.next = 0
  let t._state.tiles = [
  \   [0, 1, 2, 0],
  \   [1, 2, 0, 0],
  \   [3, 3, 3, 3],
  \   [6, 3, 3, 3],
  \ ]
  let expect = [
  \   [0, 1, 1],
  \   [0, 2, 3],
  \   [0, 3, 6],
  \   [1, 0, 1],
  \   [1, 1, 2],
  \   [1, 2, 3],
  \   [1, 3, 3],
  \   [2, 0, 2],
  \   [2, 2, 3],
  \   [2, 3, 3],
  \   [3, 2, 3],
  \   [3, 3, 3],
  \ ]
  call s:assert.equals(t.tile_list(), expect)

  let exclude_list = []
  for n in range(5)
    let exclude_list += [remove(expect, 3)]
  endfor
  call s:assert.equals(t.tile_list(exclude_list), expect)

  let exclude_list += [[-1, 3, 1]]
  call s:assert.equals(t.tile_list(exclude_list), expect)
endfunction

function! s:suite.append_tile()
  let t = threes#new()
  call s:assert.equals(t.append_tile(1,  2), 3)
  call s:assert.equals(t.append_tile(2,  2), 0)
  call s:assert.equals(t.append_tile(3,  3), 6)
  call s:assert.equals(t.append_tile(1,  0), 1)
  call s:assert.equals(t.append_tile(2,  0), 2)
  call s:assert.equals(t.append_tile(12, 0), 12)
  call s:assert.equals(t.append_tile(0,  1), 0)
endfunction

function! s:suite.move()
  let t = threes#new()
  call t.new_game()
  let t._state.next = 0
  let t._state.tiles = [
  \   [0, 1, 2, 0],
  \   [1, 2, 0, 0],
  \   [3, 3, 3, 3],
  \   [6, 3, 3, 3],
  \ ]
  let expect_left = [
  \   [1, 2, 0, 0],
  \   [3, 0, 0, 0],
  \   [6, 3, 3, 0],
  \   [6, 6, 3, 0],
  \ ]
  let expect_down = [
  \   [0, 0, 0, 0],
  \   [1, 1, 2, 0],
  \   [3, 2, 0, 0],
  \   [6, 6, 6, 6],
  \ ]
  let expect_up = [
  \   [1, 3, 2, 0],
  \   [3, 3, 3, 3],
  \   [6, 3, 3, 3],
  \   [0, 0, 0, 0],
  \ ]
  let expect_right = [
  \   [0, 0, 1, 2],
  \   [0, 1, 2, 0],
  \   [0, 3, 3, 6],
  \   [0, 6, 3, 6],
  \ ]

  call s:assert.equals(t.move(-1, 0).tiles, expect_left)
  call s:assert.equals(t.move(0, 1).tiles, expect_down)
  call s:assert.equals(t.move(0, -1).tiles, expect_up)
  call s:assert.equals(t.move(1, 0).tiles, expect_right)
endfunction

function! s:suite.is_gameover()
  let t = threes#new()
  call t.new_game()
  let t._state.next_tile = 2
  let t._state.deck = [2, 2]
  let t._state.tiles = [
  \   [3, 1, 1, 1],
  \   [2, 3, 1, 1],
  \   [2, 2, 3, 1],
  \   [2, 1, 2, 0],
  \ ]
  call s:assert.false(t.is_gameover())
  call t.next(1, 0)
  call s:assert.false(t.is_gameover())
  call t.next(1, 0)
  call s:assert.true(t.is_gameover())
endfunction

function! s:suite.exp()
  let t = threes#new()
  call s:assert.equals(t.exp(1), -1)
  call s:assert.equals(t.exp(2), -1)
  call s:assert.equals(t.exp(3), 0)
  call s:assert.equals(t.exp(6), 1)
  call s:assert.equals(t.exp(12), 2)
  call s:assert.equals(t.exp(24), 3)
  call s:assert.equals(t.exp(48), 4)
  call s:assert.equals(t.exp(96), 5)
  call s:assert.equals(t.exp(192), 6)
  call s:assert.equals(t.exp(384), 7)
  call s:assert.equals(t.exp(768), 8)
  call s:assert.equals(t.exp(1536), 9)
  call s:assert.equals(t.exp(3072), 10)
  call s:assert.equals(t.exp(6144), 11)
endfunction

function! s:suite.score()
  let t = threes#new()
  call s:assert.equals(t.score(1), 0)
  call s:assert.equals(t.score(2), 0)
  call s:assert.equals(t.score(3), 3)
  call s:assert.equals(t.score(6), 9)
  call s:assert.equals(t.score(12), 27)
  call s:assert.equals(t.score(24), 81)
  call s:assert.equals(t.score(48), 243)
  call s:assert.equals(t.score(96), 729)
  call s:assert.equals(t.score(192), 2187)
  call s:assert.equals(t.score(384), 6561)
  call s:assert.equals(t.score(768), 19683)
  call s:assert.equals(t.score(1536), 59049)
  call s:assert.equals(t.score(3072), 177147)
  call s:assert.equals(t.score(6144), 531441)
endfunction

function! s:suite.total_score()
  let t = threes#new()
  call t.new_game()
  let t._state.tiles = [
  \   [3, 1, 1, 1],
  \   [2, 3, 1, 1],
  \   [2, 2, 3, 1],
  \   [2, 2, 2, 3],
  \ ]
  call s:assert.equals(t.total_score(), 12)
endfunction

function! s:suite.tick()
  let t = threes#new()
  call t.new_game()
  let t._state.next = 0
  " Movable to right
  let t._state.tiles = [
  \   [0, 0, 0, 0],
  \   [1, 0, 0, 0],
  \   [3, 0, 0, 0],
  \   [6, 0, 0, 0],
  \ ]
  call s:assert.equals(t._state.tick, 0)
  call t.next(1, 0)
  call s:assert.equals(t._state.tick, 1)
  call t.next(1, 0)
  call s:assert.equals(t._state.tick, 2)
  call t.next(1, 0)
  call s:assert.equals(t._state.tick, 3)
endfunction