コード例 #1
0
def checkEncadrementDirection(jeu, l, c, sud, est):
    """jeu*nat*nat*nat*nat*nat->bool
        Verifie si a partir d'une case l+sud,c+est de l'adversaire on peut trouver des pions au joueur courant dans la direction donnee avant de tomber sur une case vide
        Retourne False si l,c n'appartient pas a l'adversaire
        si sud est 1, on se deplace vers le bas
        si sud est -1, on se deplace vers le haut
        si est est 1, on se deplace vers la droite
        si est est -1, on se deplace vers la gauche
    """
    l += sud
    c += est
    if (l > 7) or (l < 0) or (c > 7) or (c < 0):
        return False
    j = game.getJoueur(jeu)
    v = game.getCaseVal(jeu, l, c)
    if (v == j) or (v == 0):
        return False
    while True:
        l += sud
        c += est
        #print str(l)+','+str(c)
        if (l > 7) or (l < 0) or (c > 7) or (c < 0):
            return False
        v = game.getCaseVal(jeu, l, c)
        if (v == 0):
            return False
        if (v == j):
            return True
    return False
コード例 #2
0
def joueCoup(jeu, coup):

    game.addCoupJoue(jeu, coup)
    j = game.getJoueur(jeu)
    s = jeu[-1]
    e = encadrements(jeu,coup,True)
    adv = (j%2) + 1
    game.setCaseVal(jeu, coup[0], coup[1], j)
    for d in e:
        l = coup[0]
        c = coup[1]
        while True :
            l+=d[0]
            c+=d[1]
            if game.getCaseVal(jeu,l,c)==j :
                break
            game.setCaseVal(jeu,l,c,j)
            s[j-1]+=1
            s[adv-1]-=1
    
    jeu[-1] = [0, 0]
    for i in range(8):
        for j in range(8):
            sc = game.getCaseVal(jeu, i, j)
            if (sc != 0):
                jeu[-1][sc - 1] += 1
    game.changeJoueur(jeu)
    game.resetCoupsValides(jeu)
コード例 #3
0
def Piege(jeu, joueur):
    L = game.getScores(jeu)
    eval = 0
    j1 = 0
    j2 = 0

    if (L[0] + L[1] > 48 - 15):
        for i in range(0, 6):
            j1 = game.getCaseVal(jeu, 0, i)
            j2 = game.getCaseVal(jeu, 1, i)

        if (joueur == 1):
            """
            if game.getCaseVal(jeu,1,1)<=1 and game.getCaseVal(jeu,1,0)==1:
                    eval=eval+2
            """
            eval = eval + j1 - j2

        else:
            """
            if game.getCaseVal(jeu,0,4)<=1 and game.getCaseVal(jeu,0,5)==1:
                    eval=eval+2
            """
            eval = eval + j2 - j1
    return eval
コード例 #4
0
ファイル: awele.py プロジェクト: claracvs/ProjetJeu
def manger (jeu,coup):
    """
    jeu*coup->jeu
    mange les graines de l'adversaire si c'est possible et renvoie le jeu modifie
    """
    
    jeu_bis=game.getCopieJeu(jeu)
    case_val = game.getCaseVal(jeu,coup[0],coup[1])

    while (case_val== 2) or (case_val== 3) and jeu[0][1]==game.getAdversaire(jeu)-1 :
    	#print "valeur de la case a manger  : {}, coordonnees {}".format(case_val, coup)
        jeu[4][jeu[1]-1] += case_val #mise a jour du score
        #print "score : {}".format (jeu[4][jeu[1]-1])
        #game.setCaseVal(jeu_bis, coup_bis[0], coup_bis[1],0)
        jeu[0][coup[0]][coup[1]] = 0
        #print "case mangee?  : {}, coordonnees {}".format(jeu[0][coup[0]][coup[1]], coup)
        if coup[0]==0 : #cas ou le joueur 2 mange
            if coup[1]<5:
                coup[1]+=1
        else : #cas ou le joueur 1 mange
            if coup [1]>0:
                coup[1]-=1
        case_val = game.getCaseVal(jeu,coup[0],coup[1])
        #print "valeur de la nouvelle case a manger  : {}, coordonnees {}".format(case_val, coup) 
    
    if estAffame(jeu, game.getAdversaire(jeu)) :
        #print "on n'a pas pu manger"
        for i in range(5):
            jeu[i]=jeu_bis[i]
コード例 #5
0
def nourrit(jeu, coup):
    """Retourne true si le coup peut nourrir l'adv, faux sinon"""
    j = game.getJoueur(jeu)
    if (j == 1):
        return coup[1] < game.getCaseVal(jeu, coup[0], coup[1])

    return game.getCaseVal(jeu, coup[0], coup[1]) > (5 - coup[1])
コード例 #6
0
ファイル: awele.py プロジェクト: MarijaLaz/Awele_Othello
def nourrit(jeu, coup):
    """ jeu, coup -> bool
        checks if a coup reaches opponents row
    """
    j = game.getJoueur(jeu)
    if (j==1):
        return coup[1]<game.getCaseVal(jeu, coup[0], coup[1])
    return game.getCaseVal(jeu, coup[0], coup[1]) + coup[1] > 5
コード例 #7
0
def placePion(jeu, joueur):
    val = 0
    for i in Coin:
        if game.getCaseVal(jeu, i[0], i[1]) == joueur:
            val = val + ValCoin
        elif game.getCaseVal(jeu, i[0], i[1]) == joueur:
            val = val + 0
        else:
            val = val - ValCoin
    return val
コード例 #8
0
def VCoin(jeu, joueur):
    eval = 0
    for i in Coin:
        if game.getCaseVal(jeu, i[0], i[1]) == 0:
            eval = eval + 0
        elif game.getCaseVal(jeu, i[0], i[1]) == joueur:
            eval = eval + 1
        else:
            eval = eval - 1

    return eval
コード例 #9
0
def VCoteCoin(jeu, joueur):
    eval = 0
    for i in CoteCoin:
        #while i <len(CoteCoin):
        #if (game.getCaseVal(jeu,CoteCoin[i/3][0],getCaseVal(jeu,CoteCoin[i//3][0])
        if game.getCaseVal(jeu, i[0], i[1]) == 0:
            eval = eval + 0
        elif game.getCaseVal(jeu, i[0], i[1]) == joueur:
            eval = eval + 1
        else:
            eval = eval - 1
    return eval
コード例 #10
0
def entourageVide(jeu, l, c):
    """Return cases vides autour du parametre case"""

    res = []
    if (l > 0):

        if (game.getCaseVal(jeu, l - 1, c) == 0):
            res.append([l - 1, c])
            if (c > 0):
                if (game.getCaseVal(jeu, l - 1, c - 1) == 0):
                    res.append([l - 1, c - 1])
            if (c < 7):
                if (game.getCaseVal(jeu, l - 1, c + 1) == 0):
                    res.append([l - 1, c + 1])
    if (l < 7):

        if (game.getCaseVal(jeu, l + 1, c) == 0):
            res.append([l + 1, c])

            if (c > 0):
                if (game.getCaseVal(jeu, l + 1, c - 1) == 0):
                    res.append([l + 1, c - 1])
            if (c < 7):
                if (game.getCaseVal(jeu, l + 1, c + 1) == 0):
                    res.append([l + 1, c + 1])

    if (c < 7):
        if (game.getCaseVal(jeu, l, c + 1) == 0):
            res.append([l, c + 1])

    if (c > 0):
        if (game.getCaseVal(jeu, l, c - 1) == 0):
            res.append([l, c - 1])

    return res
コード例 #11
0
def entourageVide(jeu, case):
    """Pair[nat nat] -> Set[str]
        Retourne l'ensemble des chaines de caracteres reppresentant des cases vides contigues a la case passee en parametre
    """
    ret = set()
    l = case[0]
    c = case[1]
    if (l > 0):
        if (game.getCaseVal(jeu, l - 1, c) == 0):
            ret.add(str([l - 1, c]))
        if (c > 0):
            if (game.getCaseVal(jeu, l - 1, c - 1) == 0):
                ret.add(str([l - 1, c - 1]))
        if (c < 7):
            if (game.getCaseVal(jeu, l - 1, c + 1) == 0):
                ret.add(str([l - 1, c + 1]))
    if (l < 7):
        if (game.getCaseVal(jeu, l + 1, c) == 0):
            ret.add(str([l + 1, c]))
        if (c > 0):
            if (game.getCaseVal(jeu, l + 1, c - 1) == 0):
                ret.add(str([l + 1, c - 1]))
        if (c < 7):
            if (game.getCaseVal(jeu, l + 1, c + 1) == 0):
                ret.add(str([l + 1, c + 1]))
    if (c > 0):
        if (game.getCaseVal(jeu, l, c - 1) == 0):
            ret.add(str([l, c - 1]))
    if (c < 7):
        if (game.getCaseVal(jeu, l, c + 1) == 0):
            ret.add(str([l, c + 1]))
    return ret
コード例 #12
0
def joueCoup(jeu,coup):
    v=game.getCaseVal(jeu,coup[0],coup[1])
    game.setCaseVal(jeu,coup[0],coup[1],0)
    distribue(jeu,coup,v)
    game.addCoupJoues(jeu,coup)
    jeu[2]=None
    game.changeJoueur(jeu)
コード例 #13
0
def estaffame(jeu,joueur) :
    testjeu = game.getCopieJeu(jeu)
    if joueur==1:
        for i in range (6):
            coup = [1,i]
            game.joueCoup(testjeu,coup)
            if ((game.getCaseVal(testjeu,0,i)!=2) and (game.getCaseVal(testjeu,0,i)!=3)):
                return False
        return True
    if joueur==2:
        for i in range (6):
            coup = [0,i]
            game.joueCoup(testjeu,coup)
            if ((game.getCaseVal(testjeu,1,i)!=2) and (game.getCaseVal(testjeu,1,i)!=3)):
                return False
        return True
コード例 #14
0
def f3(jeu):
    """
                Retourne le nombre de cases sur les côtés appartenant au joueur
        """
    return len([[x, y] for x in range(8) for y in range(8)
                if (x == 0 or y == 0 or x == 7 or y == 7)
                and game.getCaseVal(jeu, x, y) == 1])
コード例 #15
0
def joueCoup(jeu, coup):
    v = game.getCaseVal(jeu, coup[0], coup[1])
    game.setCaseVal(jeu, coup[0], coup[1], 0)
    distribue(jeu, coup, v)
    game.addCoupJoue(jeu, coup)
    game.changeJoueur(jeu)
    game.resetCoupsValides(jeu)
コード例 #16
0
def retournePieces(jeu, coup, direction):
    """jeu * coup* Pair[int int] -> Pair[nat nat]
        Attribue au joueur courant les pieces encadres selon la direction donnee a partir du coup
        Retourne le nombre de pieces perdues ou gagnees par chacun des deux joueurs
        La direction est definie de la meme maniere que dans la fonction checkEncadrement
    """
    ret = [0, 0]
    sud = direction[0]
    est = direction[1]
    l = coup[0]
    c = coup[1]
    l += sud
    c += est
    if (l > 7) or (l < 0) or (c > 7) or (c < 0):
        raise Exception('Pas d encadrement ici!')
    j = game.getJoueur(jeu)
    v = game.getCaseVal(jeu, l, c)
    if (v == j) or (v == 0):
        raise Exception('Pas d encadrement ici !')
    game.setCaseVal(jeu, l, c, j)
    if (j == 1):
        ret[0] += 1
        ret[1] -= 1
    else:
        ret[0] -= 1
        ret[1] += 1
    while True:
        l += sud
        c += est
        #print str(l)+','+str(c)
        if (l > 7) or (l < 0) or (c > 7) or (c < 0):
            raise Exception('Pas d encadrement ici !')
        v = game.getCaseVal(jeu, l, c)
        if (v == 0):
            raise Exception('Pas d encadrement ici !')
        #print str(v)+','+str(j)
        if (v == j):
            return ret
        else:
            game.setCaseVal(jeu, l, c, j)
            if (j == 1):
                ret[0] += 1
                ret[1] -= 1
            else:
                ret[0] -= 1
                ret[1] += 1
    return ret
コード例 #17
0
def Krou(jeu, joueur):
    eval = 0
    for i in range(0, 6):
        if game.getCaseVal(jeu, joueur - 1, i) >= 12:
            eval = eval + 1
    return eval

    return case
コード例 #18
0
ファイル: awele.py プロジェクト: claracvs/ProjetJeu
def joueCoup(jeu, coup) : 
    """jeu*coup->jeu
    re-initialise le jeu en fonction du coup joue    
    """
    nb_graines = game.getCaseVal(jeu, coup[0], coup[1])
    game.setCaseVal(jeu, coup[0], coup[1], 0)
    distribueJeu(jeu, coup, nb_graines)
    jeu[3].append(coup)
    jeu[2]=None
    game.changeJoueur(jeu)
コード例 #19
0
def defense(jeu1, jeu2):
    """
		jeu*jeu -> float
		Retourne un nombre compris entre [0,1] qui evalue l'effacite d'un coup joue par rapport au nombre de cases à 0 , 1 ou 2 graines chez le joueur
	"""
    nbCases = 0
    for i in range(6):
        if game.getCaseVal(jeu2, moi - 1, i) < 3:
            nbCases += 1
    return 1.0 - float(nbCases) / 6
コード例 #20
0
 def coupValide(jeu,coup,checknourrit):
     v=game.getCaseVal(jeu,coup[0],coup[1])
     if v==0:
         return False
     if checknourrit:
         if coup[0]==0:
             return v>coup[1]
         else:
             return v>5-coup[1]
     return True
コード例 #21
0
ファイル: puissance.py プロジェクト: mdeville/2I013
def getCoupsValides (jeu):
    
    coups = []
    for i in range(7):
        j = 0
        while j < 6 and game.getCaseVal(jeu, j, i) == 0:
            j += 1
        if j != 0:
            coups.append([j-1, i])
    return coups
コード例 #22
0
ファイル: puissance.py プロジェクト: mdeville/2I013
def joueCoup(jeu, coup):

    game.addCoupJoue(jeu, coup)
    j = game.getJoueur(jeu)
    i = 0
    while i < 6 and game.getCaseVal(jeu, i, coup[1]) == 0:
    	i += 1
    game.setCaseVal(jeu, i - 1, coup[1], j)
    game.changeJoueur(jeu)
    game.resetCoupsValides(jeu)
コード例 #23
0
def adversaireAffame(jeu):
    """jeu->bool
        Retourne vrai si l'adversaire n'a aucune graine dans son jeu
    """
    j=game.getJoueur(jeu)
    j=j%2+1
    for i in range(0,6):
        x=game.getCaseVal(jeu,j-1,i)
        if x!=0:
            return False
    return True
コード例 #24
0
def joueCoup(jeu,coup):
    """jeu*coup->void
        Joue un coup a l'aide de la fonction distribue
        Hypothese:le coup est valide
    """
    v=game.getCaseVal(jeu,coup[0],coup[1])
    game.setCaseVal(jeu,coup[0],coup[1],0)
    distribue(jeu,coup,v)
    game.addCoupJoue(jeu,coup)
    game.changeJoueur(jeu)
    game.razCoupsValides(jeu)
コード例 #25
0
def Bord(jeu, joueur):
    eval = 0
    for i in range(2, 6):
        for j in [0, 7]:
            p = game.getCaseVal(jeu, j, i)
            if (p == joueur):
                eval = eval + 1
            elif (p == 0):
                continue
            else:
                eval = eval - 1
        for j in [0, 7]:
            p = game.getCaseVal(jeu, i, j)
            if (p == joueur):
                eval = eval + 1
            elif (p == 0):
                continue
            else:
                eval = eval - 1

    return eval
コード例 #26
0
ファイル: awele.py プロジェクト: claracvs/ProjetJeu
def coupValide (jeu, coup, affame = False) : 
    """jeu*coup*bool -> bool
    permet de savoir si un coup est valide"""
    nb_graines = game.getCaseVal(jeu, coup[0], coup[1])
    if nb_graines == 0 : 
        return False
    if affame : #permet de savoir s'il est possible de nourrir l'adversaire et donc si on doit le faire
        if coup[0]==0 : 
            return nb_graines > coup[1]
        else : 
            return nb_graines > 5-coup[1]
    return True
コード例 #27
0
def peutManger(jeu,c):
    """jeu * Pair[nat nat] -> bool
        Retourne vrai si on peut manger le contenu de la case:
            - c'est une case appartenant a l'adversaire du joueur courant
            - La case contient 2 ou 3 graines
    """
    if c[0]==(game.getJoueur(jeu)-1):
        return False
    v=game.getCaseVal(jeu,c[0],c[1])
    if(v!=2) and (v!=3):
        return False
    return True
コード例 #28
0
def Coups(jeu):
    """adv=jeu[1]%2+1
    s=[entourageVide(jeu,l,c)for l in range(8) for c in range(8) if jeu[0][l][c]==adv]
    s=reduce(lambda a,b : a|b,s,s)
    return 0"""
    adv = jeu[1] % 2 + 1
    s = []
    for l in range(8):
        for c in range(8):
            for coup in entourageVide(jeu, l, c):
                if coup not in s and game.getCaseVal(jeu, l, c) == adv:
                    s.append(coup)
    return s
コード例 #29
0
ファイル: awele.py プロジェクト: MarijaLaz/Awele_Othello
def joueCoup(jeu, coup):
    l,c = distribue(jeu, coup)
    save = game.getCopieJeu(jeu)
    j = game.getJoueur(jeu)
    v = game.getCaseVal(jeu,l, c)
  
    while(l == (j%2) and ((v == 2) or (v == 3))):
        #print("in")
        jeu[0][l][c] = 0
        #print(jeu[0][l][c])
        jeu[-1][j-1] += v
        #print(jeu[-1][j-1])
        l,c = nextCase(l,c,True)
        v = game.getCaseVal(jeu, l, c)

    if advaffame(jeu):
        jeu[0] = save[0]
        jeu[-1] = save[-1]

    game.changeJoueur(jeu)
    jeu[2] = None
    jeu[3].append(coup)
コード例 #30
0
 def estValide(jeu,coup,checkNourrit=True):
     """jeu*coup*bool->bool
     """
     l=coup[0]
     c=coup[1]
     g=game.getCaseVal(jeu,l,c)
     if(g==0):
         return False
     if(checkNourrit):
         if(l==0):
             return (g>c)
         else:
             return (g>(5-c))
     return True