'''
Projekt: Clovece nezlobsa
Vypracoval: Ivan Rener
'''

from random import SystemRandom
import math


############### Poznamka: Kazdy hrac na zaciatku hry maju sancu 3x zavrtiet kocku pokial nedostanu 6 a nevihodia figurku na cestu
# Cistenie obrazovky tak ze naspamujeme nove riadky
def ocist():
    print('\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n');  # 20x novy riadok, urobi vec :P


# Pauzu urobime v skripte aby sme dali cas hracu precitat si navod
def pauza():
    input('Stlacte ENTER pre pokracovanie...')


# Pred ako co zacneme potrebujeme si vicistit command line
ocist()

# Vstup pre dosku, aka bude velka (minimum je 5)
print('Vstupna hodnota pre velkost dosky')
print('Poznamka: Hodnota musi byt 5 alebo vecie a neparne cislo\n\n\r')

nsize = int(input('N = '))
# nsize = 9 # Debug pre test, aby som nemusel vzdy zadavat istu hodnotu

### N musi byt aspon 5 aby nasledovalo rovnicu (n-3)/2 domcekov pre hracov
if (nsize < 5):
    print('N musi byt neparne cislo a vacsie ako 4,')
    print('kedze ste zadali nespravne cislo, vygeneruje sa cislo 9.')
    nsize = 9

if (nsize % 2 == 0):
    print('N musi byt neparne cislo,')
    print('namiesto poskytnuteho cisla ', nsize, ' pouzijeme ', nsize + 1)
    nsize += 1

# Zvazime to, ze su toto konstanty
MAX_PANACIKOV = int((nsize - 3) / 2)
STREDNA_POLOHA = int((nsize - 1) / 2)
DLZKA_CESTY = (STREDNA_POLOHA * 8)

# V sucasnosti hrajuci hrac (moze byt 0 do 1 a to je A,B)
hracHra = int(0)  # 0 = A, 1 = B
hracovPanacik = {0: 'A', 1: 'B'}

# -2 = v domceku, -1 = nie je na ceste, 0 to (n-1) = pole na ceste
hracovPanacikPrecestoval = [[int(-1) for x in range(MAX_PANACIKOV)], [int(-1) for x in range(MAX_PANACIKOV)]]

### definovanie premennej kocky tak, aby sme ju mohli použit neskor (0 je invalidna hodnota/nenastavenne)
kocka = int(0)  # Hodnoty kocky (hodnoty od 1 - 6)

# Deklarujeme premennu dosky, ale teraz len ako zastupny symbol (takže možeme odkazovat vo funkciach)
doska = None


#################################################################################################
#################################################################################################

### Generuje dosku s veľkosťou n * n, vyplni cesty a domy
def genSachovnica(n):
    # Generuje prazdnu dosku
    sachovnica = [[' ' for x in range(nsize)] for y in range(nsize)]

    for i in range(n):
        for x in range(n):
            # Malo by byt prazno miesto ale nastavime zase v kazdom pripade ( neuskodi :D)
            sachovnica[i][x] = ' '

            # kontroluvanie vsetkych 4 smerov (hore/dolu/lavo/pravo)
            if (n - 1) / 2 == i + 1 or (n - 1) / 2 == x + 1 or (n + 1) / 2 == i or (n + 1) / 2 == x:
                sachovnica[i][x] = '*'

    # V tomto kroku  potrebujeme iba naplnit medzeri ( spojit cestu )
    sachovnica[0][STREDNA_POLOHA] = '*'
    sachovnica[STREDNA_POLOHA][0] = '*'
    sachovnica[n - 1][STREDNA_POLOHA] = '*'
    sachovnica[STREDNA_POLOHA][n - 1] = '*'

    # Domceky
    for i in range(1, MAX_PANACIKOV + 1):
        # Hore
        sachovnica[i][STREDNA_POLOHA] = 'D'
        # Dolu
        sachovnica[n - (i + 1)][STREDNA_POLOHA] = 'D'
        # Lavo
        sachovnica[STREDNA_POLOHA][i] = 'D'
        # Vpravo
        sachovnica[STREDNA_POLOHA][n - (i + 1)] = 'D'

    # Naplnanie nasho vstredu s X
    sachovnica[STREDNA_POLOHA][STREDNA_POLOHA] = 'X'

    return sachovnica;


#################################################################################################
#################################################################################################


# Logika pre znazornenie figuriek na poli
# Nie je hlupe ak to robi :D
def prikazPanacika(hrac=0, pole=0):
    # Hrac A startuje od 0, ale hrac 2 musi zacat s druhej strany ceste
    if (hrac == 1):
        pole = (pole + (DLZKA_CESTY / 2))
        pole = pole % DLZKA_CESTY

    a = 0
    b = STREDNA_POLOHA - 1

    # Mozno je lepsia cesta na toto ale robi to aj takto :D
    if (pole >= 0 and pole < 2):
        a = 0
        b = STREDNA_POLOHA - 1 + (pole)
    elif (pole < (2 + STREDNA_POLOHA)):
        a = (pole - 2)
        b = STREDNA_POLOHA + 1
    elif (pole < (2 + STREDNA_POLOHA + STREDNA_POLOHA) - 1):
        a = STREDNA_POLOHA - 1
        b = STREDNA_POLOHA + 1 + (pole - (2 + STREDNA_POLOHA) + 1)
    elif (pole < (3 + STREDNA_POLOHA + STREDNA_POLOHA)):
        a = STREDNA_POLOHA - 1 + (pole - (2 + STREDNA_POLOHA + STREDNA_POLOHA - 2))
        b = nsize - 1
    elif (pole < (2 + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA)):
        x = (2 + STREDNA_POLOHA + STREDNA_POLOHA)
        a = STREDNA_POLOHA + 1
        b = nsize - 1 - (pole - x)
    elif (pole < (2 + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA) - 1):
        x = (2 + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA) - 1
        a = STREDNA_POLOHA + 1 + (pole - x)
        b = STREDNA_POLOHA + 1
    elif (pole < (3 + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA)):
        x = (STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA)
        a = nsize - 1
        b = STREDNA_POLOHA + 1 - (pole - x)
    elif (pole < (2 + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA)):
        x = (2 + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA)
        a = nsize - 1 - (pole - x)
        b = STREDNA_POLOHA - 1
    elif (pole < (
            1 + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA)):
        x = (2 + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA) - 1
        a = STREDNA_POLOHA + 1
        b = STREDNA_POLOHA - 1 - (pole - x)
    elif (pole < (
            3 + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA)):
        x = (STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA)
        a = STREDNA_POLOHA + 1 - (pole - x)
        b = 0
    elif (pole < (
            2 + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA)):
        x = (2 + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA)
        a = STREDNA_POLOHA - 1
        b = 0 + (pole - x)
    elif (pole < (
            STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA)):
        x = (
                        2 + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA + STREDNA_POLOHA) - 1
        a = STREDNA_POLOHA - 1 - (pole - x)
        b = STREDNA_POLOHA - 1
    elif (pole >= DLZKA_CESTY):
        print('Domcek!!!')
        return
    doska[int(a)][int(b)] = hracovPanacik[hrac]
    return


#################################################################################################
####	Hlavna funckia pre prikazovanie
#################################################################################################
def tlacSachovnicu(sachovnica):
    # Vytlačime nove riadky, aby sme vymazali obrazovku a vytvorili novu mriežku
    ocist()

    # Zotieranie figuriek s mriezky
    for i in range(nsize):
        for x in range(nsize):
            if (((i >= 1 and i <= 4) or (i <= (nsize - 2) and i >= (nsize - 5))) and (x == STREDNA_POLOHA)):
                continue

            if (sachovnica[i][x] == 'A' or sachovnica[i][x] == 'B'):
                sachovnica[i][x] = '*'

    # Pridavanie vsetkych figuriek na ceste do matice
    for hrac in range(2):
        for figurka in range(MAX_PANACIKOV):
            if (hracovPanacikPrecestoval[hrac][figurka] >= 0) and (
                    hracovPanacikPrecestoval[hrac][figurka] < DLZKA_CESTY):
                prikazPanacika(hrac, hracovPanacikPrecestoval[hrac][figurka])

    ### Tlač najvyššieho poradoveho čisla
    print('', end=' ')
    for i in range(nsize):
        ### Limitujeme ich od 0-9
        print(i % 10, end=' ')
    print('')

    # Prikazovanie matice
    for i in range(nsize):
        print(i % 10, end=' ')
        for x in range(nsize):
            print(str(sachovnica[i][x]), end='')
            print(' ', end='')
        print('')  # Po defaulte python dava \n na konci print

    print('')
    print('')


#################################################################################################
#################################################################################################


def najdiHracovogPanacikaNaCeste(hrac, figurka):  # 1 - 4 | 1 = prvy, 2 = druhy,...

    pocitat = 1
    for i in range(MAX_PANACIKOV):
        if (-1 < hracovPanacikPrecestoval[hracHra][i] < DLZKA_CESTY):
            if (pocitat == figurka):
                return i
            else:
                pocitat += 1
    return -1


#################################################################################################
#################################################################################################


def hracoviPanacikoviaNaCeste(hracHra=0):
    pocitat = int(0)
    for i in range(MAX_PANACIKOV):
        if (-1 < hracovPanacikPrecestoval[hracHra][i] < DLZKA_CESTY):
            pocitat += 1
    return pocitat


def hracoviPanacikoviaVDome(hracHra=0):
    pocitat = int(0)
    for i in range(MAX_PANACIKOV):
        if (hracovPanacikPrecestoval[hracHra][i] >= DLZKA_CESTY):
            pocitat += 1
    return pocitat


#################################################################################################
#################################################################################################


# Return
#	Figurky v poli
# 		-1 - prazdno
# 		0 - hrac A
# 		1 - hrac B
#	ID Figurky (-1 ak nieto)

def preverPolia(pole):
    for i in range(MAX_PANACIKOV):
        if (hracovPanacikPrecestoval[0][i] != -1 and hracovPanacikPrecestoval[0][i] == pole):
            return 0, i
        elif (hracovPanacikPrecestoval[1][i] != -1 and int(
                (hracovPanacikPrecestoval[1][i] + (DLZKA_CESTY / 2)) % DLZKA_CESTY) == pole):
            return 1, i
    return -1, -1


#################################################################################################
#################################################################################################

def polozNovehoPanacikaNaCestu(hrac):
    protihrac = (hrac + 1) % 2
    for i in range(MAX_PANACIKOV):
        # Ak figurka nie je v domceku ani na ceste, tak ju chceme vyhodit von
        if (hracovPanacikPrecestoval[hrac][i] == -1):
            preverofset = 0
            if (hrac == 1):
                preverofset = DLZKA_CESTY / 2
            pole = preverPolia(preverofset)
            if (pole[0] == protihrac):
                # Zotriet protihracovu figurku
                hracovPanacikPrecestoval[protihrac][pole[1]] = 0

            if (pole[0] == hrac):
                # Pole je pouzite s nasov figurkov(nechceme ziest nasho, ci hej?)
                return -1

            # Poloz nasu figurku na zaciatok
            hracovPanacikPrecestoval[hrac][i] = 0
            return i
    return -1


# Ocakvania:
#	hrac - Id hraca (0 = A, 1 = B)
#	figurky - 0 do 3
#	pos - Za kolko poli nak sa posunie (zohladom na terajsie)
# Returns:
# 	0 ak hrac nemoze posunut tu figurku(hon uz ma figurku na tej pozicii)
# 	1 ak posunul figurku
# 	2 - Ak posunul jeho figurku a ziedol/znicil protihracovu figurku
# 	-1 do -3 v pripade ak hrac moze posunut svoju figurku do domceka
# pripomienka:
#	funkcia neukazuje nic, iba pocita pozicie od zaciatocneho bodu

def posunHracovogPanacika(hrac, figurka, pos):
    # ak jeho nova pozicia je vecia ako dlzka ceste (znamena ze zichadza do domu alebo jeho figurka je zablokovana)
    if (hracovPanacikPrecestoval[hrac][figurka] + pos >= DLZKA_CESTY):
        # Vyrataj kolko pozicii vchadza
        domcek = ((DLZKA_CESTY - 1) - (hracovPanacikPrecestoval[hrac][figurka] + pos))
        # tam su iba MAX_PANACIKOV miesta v domceku, pozor na to (return 0 ak mimoisiel vsetky miesta v domceku)
        if (domcek < -MAX_PANACIKOV):
            return 0

        uspech = postavVDomcek(hrac, figurka, domcek)
        return uspech

    preverofset = 0
    if (hrac == 1):
        preverofset = DLZKA_CESTY / 2

    pole = preverPolia((hracovPanacikPrecestoval[hrac][figurka] + pos + preverofset) % DLZKA_CESTY)

    # Preverim ci mam svoju figurku na tej pozicii a vratim 0 ak mam
    if (pole[0] == hrac):
        print('Blokuje vas vaša vlastna figurka!')
        return 0

    # Preverim ak protihrac ma figurku na tej pozicii a ziem ho ak ano.
    protihrac = (hrac + 1) % 2
    if (pole[0] == protihrac):
        # protihrac nema figurku na tej pozicii, tak zotri ju.
        hracovPanacikPrecestoval[protihrac][pole[1]] = -1
        # a poloz nasu figurku tam
        hracovPanacikPrecestoval[hrac][figurka] += pos
        return 2
    # posun figurku a vrat uspesne
    hracovPanacikPrecestoval[hrac][figurka] += pos
    return 1


def postavVDomcek(hrac, figurka, pos):
    # posunHracovogPanacika vrati negativne cislo za kazdi domcek, takze ho iba zmenime na pozitivne (rataj to ako math.abs(figurka))
    if (pos < 0):
        pos = int(pos * (-1))

    if (hrac == 0):
        # Prever ci je domcek plny
        if (doska[pos][STREDNA_POLOHA] != 'D'):
            return 0
        doska[pos][STREDNA_POLOHA] = hracovPanacik[hrac]
    else:
        if (doska[int((nsize - 1) - pos)][STREDNA_POLOHA] != 'D'):
            return 0
        doska[int((nsize - 1) - pos)][STREDNA_POLOHA] = hracovPanacik[hrac]

    # Poloz ho do domceku nie kdekolvek
    hracovPanacikPrecestoval[hrac][figurka] = -2

    panacikoviaVDomcekus = 0
    for i in range(MAX_PANACIKOV):
        if (hracovPanacikPrecestoval[hrac][figurka] == -2):
            panacikoviaVDomcekus
    if (panacikoviaVDomcekus == MAX_PANACIKOV):
        print('Hrac', hracovPanacik[hrac], 'zvytazil!')
        pauza()
        quit()

    tlacSachovnicu(doska)
    return 1


#################################################################################################
#################################################################################################

# Inicializuj maticu ktoru sme uz urobili
doska = genSachovnica(nsize)


### Počkaj na vstup a uisti sa, že je skutočne číslo, ak nie, odmietni ho a čakaj na vstup znova
def vnesCislo():
    cislo = int(-1)

    # Loop kim vneseneCislo je zmeneny (kim nestlacime cislove tlacitko)
    while (cislo == -1):
        char = input()

        # prever ci je character cislo
        if (char.isdigit() == True):
            cislo = int(char)

    return cislo


# Generujeme random cislo od 1 do 6
def hodKocku():
    kocka = SystemRandom().randint(1, 6)
    # print('[TEST] Vloz hodnotu kocky: ') #Debugger
    # kocka = vnesCislo()
    return kocka


#################################################################################################
#################################################################################################


# Nas hlavny loop  kde budeme robit vsetko( prikazovanie, cakanie na input a ratat vsetko)
while 1 == 1:

    panacikoviaNaCeste = int(hracoviPanacikoviaNaCeste(hracHra))
    panacikoviaVDomceku = int(hracoviPanacikoviaVDome(hracHra))

    # Hrac ktory nema figurky na ceste ma 3 pokusy dostat 6
    pocetHraniZostalo = 3

    # Ale ak hrac ma figurky na ceste, on moze hadzat kocku iba raz
    if (panacikoviaNaCeste > 0):
        pocetHraniZostalo = 1

    # pokial hrac ma este pokusy
    while pocetHraniZostalo > 0:

        # panacikoviaNaCeste a panacikoviaVDomceku mozu sa premenit na tomto mieste a aby neboli aktualizovane v hlavnom loope
        panacikoviaNaCeste = int(hracoviPanacikoviaNaCeste(hracHra))
        panacikoviaVDomceku = int(hracoviPanacikoviaVDome(hracHra))

        tlacSachovnicu(doska)

        print('Hrac\'i ', hracovPanacik[hracHra], ' na rade.')

        print('Stlac 1 aby si zavrtel kocku')
        vneseneCislo = vnesCislo()
        if (vneseneCislo == 1):

            # Hod kocku a printuj hodnotu
            kocka = int(hodKocku())
            print('Dostal si ', kocka, '!')

            if (kocka == 6):

                if (panacikoviaNaCeste == 0):
                    pocetHraniZostalo = 1  # On nemal figurky na ceste, ma jeden pokus maximalne (pokial nedostane 6 zase)
                else:
                    pocetHraniZostalo += 1  # Dostal 6 tak hra zas!

                # Nemame figurky na ceste, tak polozim prveho ktoreho najdeme
                if (panacikoviaNaCeste == 0):
                    figurka = polozNovehoPanacikaNaCestu(hracHra)
                    tlacSachovnicu(doska)
                    print('Dostal si 6 a vylozil si novu figurku (', figurka, ') na cestu')
                    pauza()
                    continue

                # Iba jedna figurka na ceste, a nieto viac novych ktore sa daju pridat
                elif (panacikoviaNaCeste == 1 and (panacikoviaVDomceku == 3)):
                    figurka = najdiHracovogPanacikaNaCeste(hracHra, 1)
                    posunHracovogPanacika(hracHra, figurka, kocka)
                    tlacSachovnicu(doska)
                    print('Dostal si 6 a posunul si svoju figurku')

                # On ma figurk(u)y na ceste (a moze polozit novu)
                else:
                    if (panacikoviaNaCeste == 1):
                        print('Stlac 1 aby si posunul tvoju figurku')
                    else:
                        print('Stlac 1-', panacikoviaNaCeste, 'aby si posunul figurku')

                    preverofset = 0
                    if (hracHra != 0):
                        preverofset = DLZKA_CESTY / 2
                    pole = preverPolia(preverofset)

                    if (pole[0] != hracHra):
                        print('Stlac 0 aby si vylozil novu figurku na cestu')

                    # Spravuj input ale iba povoli 0 ( ked moze vybrat novu figurku) alebo index figurky (pocitat)
                    vneseneCislo = -1
                    while (vneseneCislo == -1):
                        vneseneCislo = vnesCislo()
                        if (vneseneCislo == 0 and pole[0] == hracHra):
                            vneseneCislo = -1
                            continue

                        if (vneseneCislo != 0 and vneseneCislo > panacikoviaNaCeste):
                            vneseneCislo = -1

                    if (vneseneCislo == 0):
                        figurka = polozNovehoPanacikaNaCestu(hracHra)
                        tlacSachovnicu(doska)
                        print('Vylozili ste novu figurku (', figurka, ') na cestu')
                        pauza()
                        continue
                    else:
                        figurka = najdiHracovogPanacikaNaCeste(hracHra, vneseneCislo)
                        uspech = posunHracovogPanacika(hracHra, figurka, kocka)
                        tlacSachovnicu(doska)

                        if (uspech == 0):
                            print('nemozete posunut tu figurku')

                print('Dostal si 6, hraj znovu!')

            #########################################################################################################################################
            #########################################################################################################################################
            #########################################################################################################################################

            # ak nie je 6, a hrac ma figurku na ceste
            elif (panacikoviaNaCeste > 0):
                # Ak jesto iba jedna figurka na ceste, to je jedina s ktorou moze hrat(a moze? - blokovany domcek? :D)
                if (panacikoviaNaCeste == 1):
                    figurka = najdiHracovogPanacikaNaCeste(hracHra, 1)
                    uspech = posunHracovogPanacika(hracHra, figurka, kocka)
                    tlacSachovnicu(doska)
                    print('Dostal si ', kocka, '!')

                else:
                    print('Stlac 1-', panacikoviaNaCeste,
                          'aby si posunul figurku (V smere hodinových ručičiek od počiatočnej pozicie)')

                    # Spravuj input vnesCislo ale iba indexi figuriek (pocitat)
                    vneseneCislo = -1
                    while (vneseneCislo == -1):
                        vneseneCislo = vnesCislo()
                        if (vneseneCislo == 0 or vneseneCislo > panacikoviaNaCeste):
                            vneseneCislo = -1

                    figurka = najdiHracovogPanacikaNaCeste(hracHra, vneseneCislo)
                    uspech = posunHracovogPanacika(hracHra, figurka, kocka)
                    tlacSachovnicu(doska)

            # zmensi hracove pokusy
            pocetHraniZostalo -= 1
            pauza()
    tlacSachovnicu(doska)
    hracHra = (hracHra + 1) % 2
    print('Nasledovny hrac\'i na rade')
    pauza()