pythonでオセロプログラムを作っています。

今までにないものにしたく、端と端がつながった円柱型のオセロを作りたいです。（トーラスオセロの次元が少ない版）
__
①|盤 |②
①|＿ |②

(①と②がつながっている
以下のようなコードを実行しているのですが、おけるところの判定につながっている部分が出ません。
count_reversibleでxがsize以上になったらsizeを引くことでつながっているところを表現できていると思ったのですが…
よろしくお願い致します。

#!/usr/bin/env python3

-- coding:utf-8 --

import time
import random
import copy

class Othello:

def play(self):
    global computer
    global user
    start_time = time.time()
    board = Board()
    player1 = computer = Computer(BLACK, "PC")
    player2 = user = User(WHITE, "あなた")
    #player1 = user = User(BLACK, "あなた")
    #player2 = computer = Computer(WHITE, "PC")

    turn = 0
    hand1 = hand2 = None
    while board.is_playable() and not hand1 == hand2 == "pass":
        turn += 1
        print("TURN = %s" % turn)

        print(board)
        hand1 = player1.play(board)
        print("%sの手: %s" % (player1.name, hand1))

        print(board)
        hand2 = player2.play(board)
        print("%sの手: %s" % (player2.name, hand2))

    self.show_result(board)

    end_time = time.time()
    print("試合時間:" + str(end_time - start_time))

def show_result(self, board):
    print("------------------RESULT-------------------")  # 結果発表
    print(board)
    computer_stones = board.count(computer.stone)
    user_stones = board.count(user.stone)
    print("Computer: %s" % computer_stones)
    print("You: %s" % user_stones)
    print()
    if computer_stones > user_stones:
        print("YOU LOST!!!!!")
    elif computer_stones < user_stones:
        print("YOU WON!!!!!")
    else:
        print("DRAW")

class Stone(str):
pass

BLACK = Stone("b")
WHITE = Stone("w")
BLANK = Stone("x")
OPPONENT = {BLACK: WHITE, WHITE: BLACK}

class Board:
SIZE = 8
DIRECTIONS_XY = ((-1, -1), (+0, -1), (+1, -1),
(-1, +0), (+1, +0),
(-1, +1), (+0, +1), (+1, +1))

def __init__(self):
    size = self.SIZE
    center = size // 2
    square = [[BLANK for y in range(size)] for x in range(size)]  # 最初の盤面を定義
    square[center - 1][center - 1:center + 1] = [WHITE, BLACK]
    square[center + 0][center - 1:center + 1] = [BLACK, WHITE]
    self.square = square

def __str__(self):
    return '\n'.join(''.join(row) for row in self.square)

def __getitem__(self, x):
    return self.square[x]

def is_playable(self):
    return any(col != BLANK
               for row in self.square
               for col in row)

def count(self, stone):         # 石が何個あるかを返す関数
    return sum(col == stone     # True is 1, False is 0
               for row in self.square
               for col in row)

def put(self, x, y, stone):     # y,xは置く石の座標、stoneにはWHITEかBLACKが入る。
    self[x][y] = stone
    # reverse
    for dx, dy in Board.DIRECTIONS_XY:
        n = self.count_reversible(x, y, dx, dy, stone)
        for i in range(1, n + 1):
            self[x + i * dx][y + i * dy] = stone

def count_reversible(self, x, y, dx, dy, stone):
    size = self.SIZE
    for n in range(size):
        x += dx
        if size<=x:
            x-=size
            dx=dx*(-1)
        y += dy
        if not (0 <= x < size and 0 <= y < size):
            return 0
        if self[x][y] == BLANK:
            return 0
        if self[x][y] == stone:
            return n
        n +=1
    return 0

def is_available(self, x, y, stone):
    if self[x][y] != BLANK:
        return False
    flag=any(self.count_reversible(x, y, dx, dy, stone) > 0
               for dx, dy in self.DIRECTIONS_XY)
    return flag

def availables(self, stone):  # 打てる場所の探索
    return [(x, y)
            for x in range(self.SIZE)
            for y in range(self.SIZE)
            if self.is_available(x, y, stone)]

class Player: # abstract class

def __init__(self, stone, name):
    self.stone = stone
    self.name = name

def play(self, board):
    availables = board.availables(self.stone)
    if not availables:
        return "pass"
    return self.think(board, availables)

class Computer(Player):

def think(self, board, availables):
    starttime = time.time()
    print(availables)
    print("thinking……")
    own = self.stone
    opponent = OPPONENT[own]
    etc=availables
    x,y=etc[0]
    board.put(x, y, self.stone)
    endtime = time.time()
    interval = endtime - starttime
    print("%s秒" % interval)  # 計算時間を表示
    return x, y

class User(Player):

def think(self, board, availables):
    while True:
        print("打てる場所(Y, X): " + str(availables))   # 内部のx,yと表示のX,Yが逆なので注意
        try:
            line = input("Y X or quit: ")
        except:
            print("強制終了")
            exit(1)
        if line == "quit" or line == "exit":
            print("放棄終了")
            exit(1)
        try:
            x, y = map(int, line.split())
            if (x, y) in availables:
                board.put(x, y, self.stone)
                return x, y
            else:
                print("そこには置けません")
        except:
            print("意味不明")

if name == 'main':
Othello().play()