Cacher is the code snippet organizer for pro developers

def pozicije():
    """Funkcija koja vraca sve validne pozicije na ploci"""
    return [i for i in xrange(11, 89) if 1 <= (i % 10) <= 8]

def init_ploca():
    """Stvara novu plocu sa inicijalnim potezima za crnog i bijelog igraca ispunjenim"""
    ploca = [obrub] * 100
    for i in pozicije():
        ploca[i] = prazno
    ploca[44], ploca[45] = bijeli, crni
    ploca[54], ploca[55] = crni, bijeli
    return ploca

def ispis_ploce(ploca):
    """Funkcija koja vraca string reprezentaciju plocu spremnu za ispis"""
    rep = ''
    rep += '  %s\n' % ' '.join(map(str, range(1, 9)))
    for row in xrange(1, 9):
        begin, end = 10*row + 1, 10*row + 9
        rep += '%d %s\n' % (row, ' '.join(ploca[begin:end]))
    return rep

def je_validan(move):
    """Da li je dani potez validan"""
    return isinstance(move, int) and move in pozicije()

def protivnik(igrajer):
    """Vrati suprotnog igraca"""
    return crni if igrajer is bijeli else bijeli

def pronadi_drzac(square, igrajer, ploca, direction):
    bracket = square + direction
    if ploca[bracket] == igrajer:
        return None
    opp = protivnik(igrajer)
    while ploca[bracket] == opp:
        bracket += direction
    return None if ploca[bracket] in (obrub, prazno) else bracket

def je_legalan(move, igrajer, ploca):
    """ Provjerava legalnost poteza"""
    hasbracket = lambda direction: pronadi_drzac(move, igrajer, ploca, direction)
    return ploca[move] == prazno and any(map(hasbracket, DIRECTIONS))


def napravi_potez(move, igrajer, ploca):
    ploca[move] = igrajer
    for d in DIRECTIONS:
        okreni_badzeve(move, igrajer, ploca, d)
    return ploca

def okreni_badzeve(move, igrajer, ploca, direction):
    bracket = pronadi_drzac(move, igrajer, ploca, direction)
    if not bracket:
        return
    square = move + direction
    while square != bracket:
        ploca[square] = igrajer
        square += direction


class IlegalniPotezErr(Exception):
    def __init__(self, igrajer, move, ploca):
        self.igrajer = igrajer
        self.move = move
        self.ploca = ploca
    
    def __str__(self):
        return '%s cannot move to square %d' % (igrajERS[self.igrajer], self.move)

def legalan_potez(igrajer, ploca):
    return [sq for sq in pozicije() if je_legalan(sq, igrajer, ploca)]

def bilokoji_lPotez(igrajer, ploca):
    return any(je_legalan(sq, igrajer, ploca) for sq in pozicije())


def igraj(crni_strategy, bijeli_strategy):
    ploca = init_ploca()
    igrajer = crni
    strategy = lambda who: crni_strategy if who == crni else bijeli_strategy
    while igrajer is not None:
        move = dohvati_potez(strategy(igrajer), igrajer, ploca)
        napravi_potez(move, igrajer, ploca)
        igrajer = sljedeci_igrac(ploca, igrajer)
    return ploca, rezultat(crni, ploca)


def sljedeci_igrac(ploca, prev_igrajer):
    opp = protivnik(prev_igrajer)
    if bilokoji_lPotez(opp, ploca):
        return opp
    elif bilokoji_lPotez(prev_igrajer, ploca):
        return prev_igrajer
    return None


def dohvati_potez(strategy, igrajer, ploca):
    copy = list(ploca) # copy the ploca to prevent cheating
    move = strategy(igrajer, copy)
    if not je_validan(move) or not je_legalan(move, igrajer, ploca):
        raise IlegalniPotezErr(igrajer, move, copy)
    return move

def rezultat(igrajer, ploca):
    mine, theirs = 0, 0
    opp = protivnik(igrajer)
    for sq in pozicije():
        piece = ploca[sq]
        if piece == igrajer: mine += 1
        elif piece == opp: theirs += 1
    return mine - theirs