awale.py

Created on July 16, 2025

9.21 KB

Adaptation du jeu Awale.

Chaque joueur choisit une de ses 6 cases puis valide et les graines qu’elle contient sont alors distribuées dans les cases suivantes. Si la dernière graine distribuée est déposée dans une case de l’adversaire et que cette dernière contient 2 ou 3 graines, alors elles sont ramassées et données au joueur qui vient de jouer, puis on applique la même règle aux cases précédentes tant que les deux conditions sont vérifiées.

Le but est de ramasser plus de graines que son adversaire.

Lorsque l’adversaire n’a plus de graine dans ses 6 cases, il est obligatoire de le nourrir, c’est-à-dire de jouer un coup qui va déposer au moins une graine dans ses cases. S’il n’est pas possible de nourrir l’adversaire, alors la partie est terminée et le joueur récupère les graines restant dans ses cases.

Si un coup affame l’adversaire, c’est-à-dire un coup qui entraîne la récolte de toutes les graines qui sont dans les cases de l’adversaire, alors le coup est joué mais la récolte n’est pas effectuée et aucune graine n’est ramassée.

On joue avec les flèches et la touche OK. Avant le début du jeu, il est possible de choisir d’afficher les graines ou simplement leur nombre.

from kandinsky import *
from ion import *
from time import *
from random import *

clr_case=(220,160,0)
mode_nombres=0

def afficher_plateau():
  L=45*6-4-14#164
  dX=230-8-7-150 -50#65
  clr="brown"
  for dY in (119-4-3-34-16,119-4-3-34+34): # dessin de la boîte en bois
    fill_rect(dX+19,dY,L,1,clr)
    fill_rect(dX+15,dY+1,8+L,1,clr)
    fill_rect(dX+13,dY+2,12+L,1,clr)
    fill_rect(dX+11,dY+3,16+L,1,clr)
    fill_rect(dX+9,dY+4,20+L,1,clr)
    fill_rect(dX+8,dY+5,22+L,1,clr)
    fill_rect(dX+7,dY+6,24+L,1,clr)
    fill_rect(dX+6,dY+7,26+L,1,clr)
    fill_rect(dX+5,dY+8,28+L,1,clr)
    fill_rect(dX+4,dY+9,30+L,2,clr)
    fill_rect(dX+3,dY+11,32+L,2,clr)
    fill_rect(dX+2,dY+13,34+L,2,clr)
    fill_rect(dX+1,dY+15,36+L,4,clr)
    fill_rect(dX,dY+19,38+L,10,clr)
    
    fill_rect(dX+1,dY+29,36+L,4,clr)
    fill_rect(dX+2,dY+33,34+L,2,clr)
    fill_rect(dX+3,dY+35,32+L,2,clr)
    fill_rect(dX+4,dY+37,30+L,2,clr)
    fill_rect(dX+5,dY+39,28+L,1,clr)
    fill_rect(dX+6,dY+40,26+L,1,clr)
    fill_rect(dX+7,dY+41,24+L,1,clr)
    fill_rect(dX+8,dY+42,22+L,1,clr)
    fill_rect(dX+9,dY+43,20+L,1,clr)
    fill_rect(dX+11,dY+44,16+L,1,clr)
    fill_rect(dX+13,dY+45,12+L,1,clr)
    fill_rect(dX+15,dY+46,8+L,1,clr)
    fill_rect(dX+19,dY+47,L,1,clr)
  
  for k in (22,120+60+18): # dessin des charnières
    fill_rect(dX+k+31,dY-6,8,10,(200,200,200))
    fill_rect(dX+k+31,dY-3,8,1,(150,150,150))
    for i in (0,2,5,7):
      fill_rect(dX+k+31+i,dY-2,1,2,(150,150,150))
    fill_rect(dX+k+31,dY,8,1,(150,150,150))
    set_pixel(dX+k+32,dY-5,(150,150,150))
    set_pixel(dX+k+37,dY-5,(150,150,150))
    set_pixel(dX+k+32,dY+2,(150,150,150))
    set_pixel(dX+k+37,dY+2,(150,150,150))

  for k in range(12):
    remplissage_case(k,clr_case)
    actualise_case(k,"gk"[mode_nombres])
    
def remplissage_case(k,clr,mode_accueil=0):
  dX=230+28-8-44*int(abs(5.5-k))+230*mode_accueil
  dY=119-3-50*(k//6)+95*mode_accueil
  #clr=clr_case
  fill_rect(dX+15,dY,10,1,clr)
  fill_rect(dX+12,dY+1,16,1,clr)
  fill_rect(dX+10,dY+2,20,1,clr)
  fill_rect(dX+8,dY+3,24,1,clr)
  fill_rect(dX+7,dY+4,26,1,clr)
  fill_rect(dX+6,dY+5,28,1,clr)
  fill_rect(dX+5,dY+6,30,1,clr)
  fill_rect(dX+4,dY+7,32,1,clr)
  fill_rect(dX+3,dY+8,34,2,clr)
  fill_rect(dX+2,dY+10,36,2,clr)
  fill_rect(dX+1,dY+12,38,3,clr)
  fill_rect(dX,dY+15,40,10,clr)

  fill_rect(dX+1,dY+25,38,3,clr)
  fill_rect(dX+2,dY+28,36,2,clr)
  fill_rect(dX+3,dY+30,34,2,clr)
  fill_rect(dX+4,dY+32,32,1,clr)
  fill_rect(dX+5,dY+33,30,1,clr)
  fill_rect(dX+6,dY+34,28,1,clr)
  fill_rect(dX+7,dY+35,26,1,clr)
  fill_rect(dX+8,dY+36,24,1,clr)
  fill_rect(dX+10,dY+37,20,1,clr)
  fill_rect(dX+12,dY+38,16,1,clr)
  fill_rect(dX+15,dY+39,10,1,clr)

  #actualise_case(k,"g",clr)

def actualise_case(k,clr="gk"[mode_nombres],clr_fond=clr_case,mode_accueil=0):
  Positions=((17,17),(7,7),(27,27),(7,27),(27,7),(7,17),(27,17),(17,27),(17,7),\
  (12,12),(22,22),(12,22),(22,12),(12,17),(22,17),(17,12),(17,22),\
  (12,7),(22,27),(22,7),(12,27),(7,22),(27,12),(7,12),(27,22),\
  (2,17),(32,17),(17,2),(17,32),(12,2),(22,32),(2,22),(32,12),(22,2),(12,32),(2,12),(32,22))
  #(7,2),(27,32),(2,27),(32,7),(27,2),(7,32),(2,7),(32,27)]

  dX=230+28-8-44*int(abs(5.5-k))+230*mode_accueil
  dY=119-3-50*(k//6)+95*mode_accueil
  if mode_nombres:
    draw_string(str(Jeu[k]),dX+15-5*(Jeu[k]>9),dY+11,clr,clr_fond)
  else:
    seed(k)
    for i in range(Jeu[k]):
      fill_rect(dX+Positions[i%37][0],dY+Positions[i%37][1],6,6,"k")
      fill_rect(dX+Positions[i%37][0]+1,dY+Positions[i%37][1]+1,4,4,((10*randint(0,3),10*randint(15,25),10*randint(0,3)),clr)[clr=="r"])


draw_string("Awale",135,20,"purple")
draw_string("Valider avec OK",85,180,"purple")
for k in range(2): 
  fill_rect(60,50+k*121,200,1,"g")

Jeu=[4 for k in range(12)]#[0,1,2,3]+[3]*6+[2,4]
Score=[0,0]
joueur=0
chg=1

afficher_plateau()

while not (keydown(KEY_OK) or keydown(KEY_EXE)):1
while keydown(KEY_OK) or keydown(KEY_EXE):1

fill_rect(0,0,320,222,"w")

mode_nombres=1
draw_string("Présentation",100,10,(80,150,50))
Regles=(("Chaque joueur choisit une de","ses 6 cases et ses graines","sont distribuées.","","Ensuite, on récolte les","graines dans la dernière case","de distribution si elle est","du côté adverse et contient","2 ou 3 graines et on fait de"),\
("même dans toutes les cases","précédentes tant qu'elles vé-","rifient les mêmes conditions.","Le but est de récolter plus","de graines que l'adversaire.","","Si l'adversaire n'a plus de","graines, alors il faut le","nourrir, si possible,"),\
("sinon la partie est terminée","et chaque joueur récupère les","graines de ses cases.","","Si une récolte affame","l'adversaire, alors aucune","graine n'est récoltée.","","Affichage d'une case : "))
for i in range(3):
  for k in range(len(Regles[i])):
    draw_string(Regles[i][k],20,33+18*k,"b")

  draw_string("Page "+str(i+1)+"/3       → OK",120,200,(80,150,50))

  if i==2:
    draw_string("<     >",245,177,"orange")

  while not (keydown(KEY_EXE) or keydown(KEY_OK)):
    if i==2:
      if chg:
        remplissage_case(11,clr_case,1)
        #actualise_case(11,"y","y",1)
        mode_nombres=1-mode_nombres
        remplissage_case(11,clr_case,1)
        actualise_case(11,"gk"[mode_nombres],clr_case,1)
        sleep(0.2)
      chg=keydown(KEY_RIGHT)-keydown(KEY_LEFT)
  while keydown(KEY_EXE) or keydown(KEY_OK):1

  fill_rect(0,30,320,222,"w")


fill_rect(0,0,320,222,"w")
draw_string("Awale",135,10,"purple")
afficher_plateau()
x=2+7*joueur
for j in (0,1):
  draw_string("J"+str(j+1)+" : "+str(Score[j]),125,165-125*j,"b")
chg=1

while Jeu!=[0,0,0,0,0,1]*2 and not (sum(Jeu[6-6*joueur:12-6*joueur])==0 and all(k+Jeu[k]<6+6*joueur for k in range(6*joueur,6+6*joueur))): # tant qu'il n'est pas impossible de nourrir l'adversaire
  if chg:
    remplissage_case(x,clr_case)
    actualise_case(x,"gk"[mode_nombres],clr_case)
    x=(x+chg*(-1)**joueur)%6+6*joueur
    remplissage_case(x,"y")
    actualise_case(x,"gk"[mode_nombres],"y")
    sleep(0.2)
  chg=keydown(KEY_RIGHT)-keydown(KEY_LEFT)
  if keydown(KEY_OK) or keydown(KEY_EXE):
    while keydown(KEY_OK) or keydown(KEY_EXE):1
    if Jeu[x]!=0 and (sum(Jeu[6-6*joueur:12-6*joueur])==0 and x+Jeu[x]<6+6*joueur):
      draw_string("Il faut nourrir l'adversaire !",10,185,"r")
      sleep(2)
      draw_string("Il faut nourrir l'adversaire !",10,185,"w") 
    if Jeu[x]!=0 and not (sum(Jeu[6-6*joueur:12-6*joueur])==0 and x+Jeu[x]<6+6*joueur): # si la case n'est pas vide, on distribue, en s'assurant de ne pas affamer l'adversaire
      #actualise_case(x,"y","y")#draw_string(str(Jeu[x]),230-30*int(abs(5.5-x))-5*(Jeu[x]>9),100-30*(x//6),"w")
      remplissage_case(x,"y")
      dec=0
      while Jeu[x]>0:# dec in range(N): # distribution
        sleep(0.3)
        dec+=1
        if dec%12==0:
          dec+=1
        Jeu[(x+dec)%12]+=1
        Jeu[x]-=1
        actualise_case((x+dec)%12,"r")
        sleep(0.2)
        actualise_case((x+dec)%12,"gk"[mode_nombres])#draw_string(str(Jeu[(x+1+dec)%12]),230-30*int(abs(5.5-(x+1+dec)%12))-5*(Jeu[(x+1+dec)%12]>9),100-30*((x+1+dec)%12//6),"b")
      #sleep(0.5)
      #actualise_case(x,"w")
      #Jeu[x]=0
      #actualise_case(x,"k","y")
      #afficher_plateau()
      # à la fin de la distribution, on regarde si on récupère les graines
      # on vérifie qu'on ne va pas affamer l'adversaire avec la récolte
      Xr=(x+dec)%12
      recolte_qui_affame=False
      if 6-6*joueur<=Xr<12-6*joueur: # on vérifie si la dernière graine est semée chez l'adversaire
        if sum(Jeu[6-6*joueur:Xr+1])==sum(Jeu[6-6*joueur:12-6*joueur]) and all(Jeu[k] in (2,3) for k in range(6-6*joueur,Xr+1)):
          recolte_qui_affame=True
          draw_string("Récolte affamant l'adversaire !",5,185,"r")
          sleep(4)
          draw_string("Récolte affamant l'adversaire !",5,185,"w")
      while Xr>=0 and Xr//6 != joueur and Jeu[Xr] in (2,3) and not recolte_qui_affame: # on récolte
        #sleep(0.5)
        remplissage_case(Xr,"g")
        actualise_case(Xr,"r","g")
        sleep(0.5)
        Score[joueur]+=Jeu[Xr]
        draw_string("J"+str(joueur+1)+" : "+str(Score[joueur]),125,165-125*joueur,"b")
        Jeu[Xr]=0
        remplissage_case(Xr,clr_case)
        actualise_case(Xr,"k",clr_case)
        Xr -= 1
        sleep(0.5)
      sleep(0.5)
      remplissage_case(x,clr_case)
      actualise_case(x,"gk"[mode_nombres])#,"k",clr_case)
      joueur=1-joueur
      x=2+7*joueur
      chg=1
if Jeu==[0,0,0,0,0,1]*2:
  draw_string("Jeu qui se répète.",70,185,"r")
  draw_string("Partie terminée.",80,204,"r")
else:
  draw_string("Impossible de nourrir",55,185,"r")
  draw_string("l'adversaire. Partie terminée.",10,204,"r")
sleep(3)
for joueur in (0,1):
  for k in range(6*joueur,6+6*joueur):
    if Jeu[k] != 0:
      sleep(0.5)
      remplissage_case(k,"g")
      actualise_case(k,"r","g")
      sleep(0.5)
      Score[joueur]+=Jeu[k]
      draw_string("J"+str(joueur+1)+" : "+str(Score[joueur]),125,165-125*joueur,"b")
      Jeu[k]=0
      remplissage_case(k,clr_case)
      actualise_case(k,"k",clr_case)
draw_string("Jeu qui se répète.",70,185,"w")
draw_string("Partie terminée.",80,204,"w")
draw_string("Impossible de nourrir",55,185,"w")
draw_string("l'adversaire. Partie terminée.",10,204,"w")
if Score[0]==Score[1]:
  draw_string("Égalité !",115,190,"r")
else:
  draw_string("J"+str(1+(Score[1]>Score[0]))+" a gagné !",100,190,"r")