sixquiprend_0.py

Created by florian-allard

Created on August 20, 2024

17.9 KB

Adaptation du jeu : 6 Qui Prend


# Jeu du 6 qui prend
# on choisit 44 cartes parmis les 104 numérotées de 1 à 104
# on distribue 10 cartes à chacun des 4 joueurs
# on place les 4 cartes restantes sur le plateau, face visible
# elles constituent les 4 piles de jeu

# Le déroulement du jeu est le suivant : 
# après avoir observé ses cartes et les 4 piles de jeu, 
# chaque joueur choisit la carte qu'il va jouer
# ensuite, les 4 cartes (il y a 4 joueurs) désignées sont jouées dans l'ordre croissant
# des nombres qu'elles indiquent, en étant placées sur la pile qui correspond
# c'est-à-dire la pile qui contient le nombre inférieur le plus proche de la valeur
# de la carte à placer.

# si la carte posée devient la 6ème carte de la pile, alors le joueur récupère
# les 5 cartes de la pile et y laisse sa carte
# si la carte désignée ne peut pas être jouée parce que toutes les piles contiennent
# des nombres supérieurs, alors le joueur choisit une des piles et la récupère et place
# sa carte à la place.

# lorsque tous les joueurs on joué leurs 10 cartes, la manche est terminée
# on compte le nombre de têtes sur chacune des cartes récupérées par les joueurs
# On enchaîne les manches jusqu'à ce qu'un des joueurs atteigne ou dépasse 66 têtes.
# Celui qui a le plus petit nombre de têtes a gagné.

# Il y a 7 têtes sur la carte 55
# Il y a 5 têtes sur les cartes à double chiffre (multiple de 11, en fait)
# Il y a 3 têtes sur les cartes se terminant par 0
# Il y a 2 têtes sur les cartes se terminant par 5
# Il y a 1 tête sur les autres cartes

from random import randint
from kandinsky import *
from time import sleep
from ion import *

images={"grande":('&$6$&#', '%%&$.$&%%#', "$%'%+&'%$#", "$%'&*&'%$#", '$%(&$%%&(&#', "#&(.''#", "#'&7#", '#=$#', "$9'#", '&4*#', '(1+#', "'3*#", "'3*#", "'3*#", '(1+#', ')/,#', '*--#', '*--#', ')/,#', '(1+#', "'3*#", "'3*#", '(1+#', ')/,#', '++.#', '++.#', ',)/#'),\
"0":("%'%#", "$$'$$#", '#$%%%$#', '#$$$%$$$#', '#$$$%$$$#', '#$$$%$$$#', '#$$$%$$$#', '#$$$%$$$#', '#$$$%$$$#', '#$%%%$#', "$$'$$#", "%'%#"),"1":('&&%#', '%$%$%#', '$$&$%#', '#$%$$$%#', "#'$$%#", '&$$$%#', '&$$$%#', '&$$$%#', '&$$$%#', '$&$&#', '$$($#', '$*#'),"2":("%'%#", "$$'$$#", '#$%%%$#', '#$$$%$$$#', '#&%$$$#', "'$%$#", '&$%$$#', '%$%$%#', '$$%$&#', '#$%(#', '#$)$#', '#+###'),"3":('$)$#', '#$)$#', '#)$$#', '($$$#', '%&%$#', "$$'$$#", "$'%$#", '($$$#', '$%%$$$#', '#$%%%$#', "$$'$$#", "%'%#"),"4":("'&$#", '&$%$$#', '%$&$$#', '$$%$$$$#', '#$%%$$$#', '#$$$$$$$$#', '#$$%%%#', '#$)$#', '#($%#', "'$$$$#", "'$$$$#", "'&$#"),"5":('$*#', '#$)$#', '#$$)#', '#$$$(#', "#$$'%#", '#$($$#', '#(%$#', '($$$#', '#&%$$$#', '#$%%%$#', "$$'$$#", "%'%#"),"6":('%($#', '$$($#', "#$%'$#", '#$$$(#', "#$$'%#", '#$($$#', '#$$&%$#', '#$$$%$$$#', '#$$$%$$$#', '#$%%%$#', "$$'$$#", "%'%#"),"7":('#+###', '#$)$#', '#(%$#', "'$$$$#", '&$%$$#', '&$$$%#', '%$%$%#', '%$$$&#', '$$%$&#', "$$$$'#", "$$$$'#", "$&'#"),"8":("%'%#", "$$'%#", '#$%%%$#', '#$$$%$$$#', '#$%%%$#', "$$'$$#", '#$%%%$#', '#$$$%$$$#', '#$$$%$$$#', '#$%%%$#', "#%'$$#", "%'%#"),"9":("%'%#", "$$'$$#", '#$%%%$#', '#$$$%$$$#', '#$$$%$$$#', '#$%%%$#', '$$($#', "%'$$#", '($$$#', '#(%$#', '#$($$#', '#)%#'),\
"0_":('#&###', '#$$$#', '#$$$#', '#$$$#', '#&###'),"1_":('$$$#', '#%$#', '$$$#', '$$$#', '#&###'),"2_":('#&###', '%$#', '#&###', '#$%#', '#&###'),"3_":('#&###', '%$#', '#&###', '%$#', '#&###'),"4_":('#$$$#', '#$$$#', '#&###', '%$#', '%$#'),"5_":('#&###', '#$%#', '#&###', '%$#', '#&###'),"6_":('#&###', '#$%#', '#&###', '#$$$#', '#&###'),"7_":('#&###', '%$#', '$$$#', '#$%#', '#$%#'),"8_":('#&###', '#$$$#', '#&###', '#$$$#', '#&###'),"9_":('#&###', '#$$$#', '#&###', '%$#', '#&###'),\
"0i":('+#', "%'%#", '$%%%$#', "$$'$$#", "$$'$$#", "$$'$$#", "$$'$$#", "$$'$$#", "$$'$$#", '$%%%$#', "%'%#", '+#'),"1i":('+#', '&%&#', '%&&#', '$%$$&#', "'$&#", "'$&#", "'$&#", "'$&#", "'$&#", "'$&#", '%($#', '+#'),"2i":('+#', "%'%#", '$%%%$#', "$$'$$#", ')$$#', '(%$#', "'%%#", '&%&#', "%%'#", '$%(#', '$)$#', '+#'),"3i":('+#', '$)$#', ')$$#', ')$$#', '(%$#', "%'%#", '(%$#', ')$$#', ')$$#', '$%%%$#', "%'%#", '+#'),"4i":('+#', "'%%#", '&&%#', '%%$$%#', '$%%$%#', '$$&$%#', '$$%%%#', '$)$#', '($%#', '($%#', '($%#', '+#'),"5i":('+#', '$)$#', '$$)#', '$$)#', '$$)#', '$(%#', '(%$#', ')$$#', ')$$#', '$%%%$#', "%'%#", '+#'),"6i":('+#', '%($#', '$%(#', '$$)#', '$$)#', '$(%#', '$$&%$#', "$$'$$#", "$$'$$#", '$%%%$#', "%'%#", '+#'),"7i":('+#', '$)$#', '(%$#', '($%#', "'%%#", "'$&#", '&%&#', "&$'#", "%%'#", '%$(#', '%$(#', '+#'),"8i":('+#', "%'%#", '$%%%$#', "$$'$$#", '$%%%$#', "%'%#", '$%%%$#', "$$'$$#", "$$'$$#", '$%%%$#', "%'%#", '+#'),"9i":('+#', "%'%#", '$%%%$#', "$$'$$#", "$$'$$#", '$%%%$#', '%($#', ')$$#', ')$$#', '(%$#', '$(%#', '+#')}

def cadre_carte(X,Y,clr):
  fill_rect(X+1,Y,37,1,clr)
  fill_rect(X,Y+1,1,49,clr)
  fill_rect(X+1,Y+50,37,1,clr)
  fill_rect(X+38,Y+1,1,49,clr)

def couleurs(carte): # couleur_nombre,couleur_tete,couleur_fond,couleur_tetes,couleur_nombres
  if carte==55:
    return ("y","r","purple","r","orange")
  elif carte%11==0:
    return ((50,255,100),"b","r","g","r")
  elif carte%10==0:
    return ("y","g",(50,255,100),(200,200,0),"g")
  elif carte%10==5:
    return ("cyan","b","cyan","cyan","b")
  else:
    return ((230,210,255),"purple","w",(180,150,255),"purple")


def minitete(x,y,clr,renversee=False):
  fill_rect(x,y,1,3,clr)
  fill_rect(x+1,y+1-2*renversee,2,3,clr)
  fill_rect(x+3,y,1,3,clr)


def position_minitetes(carte):
  if carte==55:
    return ((10,2),(15,2),(20,2),(25,2),(13,7),(18,7),(23,7))
  elif carte%11==0:
    return ((13,2),(18,2),(23,2),(15,7),(20,7))
  elif carte%10==0:
    return ((15,2),(20,2),(18,7))
  elif carte%10==5:
    return ((15,2),(20,2))
  else:
    return ((17,2),)


def IMG(carte,x,y): # dessin d'une carte
  couleur_nombre,couleur_tete,couleur_fond,couleur_tetes,couleur_nombres=couleurs(carte)
  
  fill_rect(x+1,y+1,37,49,"w") # on efface avant de dessiner la carte
  # cadre
  cadre_carte(x,y,"purple")
  # petites têtes
  print(position_minitetes(carte))
  for (X,Y) in position_minitetes(carte):
    minitete(x+X,y+(carte%11!=0 and carte%10!=0)+Y,couleur_tetes)
    minitete(x+35-X,y-(carte%11!=0 and carte%10!=0)+48-Y,couleur_tetes,True) #renversee
  #for k in range(2):
  #  minitete(x+10,y+2+38*k,"b")
  #  minitete(x+15,y+2+38*k,"b")
  #  minitete(x+20,y+2+38*k,"b")
  #  minitete(x+25,y+2+38*k,"b")
  #  minitete(x+13,y+7+38*k,"b")
  #  minitete(x+18,y+7+38*k,"b")
  #  minitete(x+23,y+7+38*k,"b")
  
  # petits numéros
  for chiffre in range(len(str(carte))):
    motif=images[str(carte)[chiffre]+"_"]
    dec=-4*(carte>99)+4*(carte<10)
    for ligne in range(len(motif)):
        elt=motif[ligne]
        rang=4*chiffre
        for pos in range(0,len(elt)-1,2):
          #fill_rect(x+2+rang,y+3+ligne,ord(elt[pos])-35,1,"w")
          #fill_rect(x+2+rang,y+3+ligne,ord(elt[pos])-35,1,"w")
          #fill_rect(x+2+rang,y+3+ligne,ord(elt[pos])-35,1,"w")
          #fill_rect(x+2+rang,y+3+ligne,ord(elt[pos])-35,1,"w")

          rang+=ord(elt[pos])-35
          fill_rect(x+2+rang,y+3+ligne,ord(elt[pos+1])-35,1,couleur_nombres)
          fill_rect(x+2+28+dec+rang,y+3+ligne,ord(elt[pos+1])-35,1,couleur_nombres)
          fill_rect(x+79-dec-ord(elt[pos+1])-35-rang,y+43+5-ligne,ord(elt[pos+1])-35,1,couleur_nombres)
          fill_rect(x+79+28-ord(elt[pos+1])-35-rang,y+43+5-ligne,ord(elt[pos+1])-35,1,couleur_nombres)
          #fill_rect(x+2+rang,y+43+ligne,ord(elt[pos+1])-35,1,clr)
          #fill_rect(x+2+dec+rang,y+43+ligne,ord(elt[pos+1])-35,1,clr)
          
          rang+=ord(elt[pos+1])-35
  #draw_string(str(carte),x+5,y+5,"b")
  #draw_string(str(carte),x+25-10*(len(str(carte))),y+5,"b")
  #draw_string(str(carte),x+5,y+45,"b")
  #draw_string(str(carte),x+25-10*len(str(carte)),y+45,"b")
  
  # grande tête
  motif=images["grande"]
  for ligne in range(len(motif)):
      elt=motif[ligne]
      rang=6
      for pos in range(0,len(elt)-1,2):
        fill_rect(x+rang,y+12+ligne,ord(elt[pos])-35,1,couleur_fond)
        rang+=ord(elt[pos])-35
        fill_rect(x+rang,y+12+ligne,ord(elt[pos+1])-35,1,couleur_tete)
        rang+=ord(elt[pos+1])-35
  
  # grand numéro
  for chiffre in range(len(str(carte))):
    
    motif=images[str(carte)[chiffre]] #contour
    for ligne in range(len(motif)):
        elt=motif[ligne]
        rang=10-4*(carte>99)+4*(carte<10)+8*chiffre
        for pos in range(0,len(elt)-1,2):
          #fill_rect(x+rang,y+25+ligne,ord(elt[pos])-35,1,"w")
          rang+=ord(elt[pos])-35
          fill_rect(x+rang,y+25+ligne,ord(elt[pos+1])-35,1,"purple")
          rang+=ord(elt[pos+1])-35
    
    motif=images[str(carte)[chiffre]+"i"] #intérieur du chiffre
    for ligne in range(len(motif)):
        elt=motif[ligne]
        rang=10-4*(carte>99)+4*(carte<10)+8*chiffre
        for pos in range(0,len(elt)-1,2):
          #fill_rect(x+rang,y+25+ligne,ord(elt[pos])-35,1,"w")
          rang+=ord(elt[pos])-35
          fill_rect(x+rang,y+25+ligne,ord(elt[pos+1])-35,1,couleur_nombre)
          rang+=ord(elt[pos+1])-35

#for n in range(32):
#  IMG(4+3*n,40*(n%8),50*(n//8),"b")
#sleep(200)

# Début d'une partie
while 1:
  fill_rect(0,0,320,222,"w")
  Jeu=[k for k in range(1,104+1)]
  Mains=[[],[],[],[]]
  for joueur in range(4):
    for k in range(10):
      Mains[joueur].append(Jeu.pop(randint(0,len(Jeu)-1)))
    Mains[joueur]=sorted(Mains[joueur])

  Piles=[[],[],[],[]]
  for k in range(4):
    Piles[k].append(Jeu.pop(randint(0,len(Jeu)-1)))
    IMG(Piles[k][-1],60+50*k,10)

  for i in range(4):
    X=10+260*(i>1)
    Y=80-60*(0<i<3)
    fill_rect(X+1,Y+1,37,49,"w") # on efface avant de dessiner la carte
    # cadre
    cadre_carte(X,Y,"purple")

  # le joueur sera le joueur numéro 0
  # il faudra répéter 10 fois les instructions d'un tour de jeu
  Cartes_recuperees=[[],[],[],[]]
  scores=[0,0,0,0]

  #fill_rect(0,160,320,52,"w")
  for j in range(len(Mains[0])):
    IMG(Mains[0][j],5+min(45,270//max(1,len(Mains[0])-1))*j,160)

  for tour in range(10):
    Cartes_jouees=[0,0,0,0]
    for j in range(4): # on affiche le nombre de têtes pour chaque joueur
      X=20+255*(j>1)
      Y=70-60*(0<j<3)
      minitete(X+5+4*(scores[j]>9)+4*(scores[j]>99),Y+4,"w")
      fill_rect(X,Y+2,39,7,"w")
      scores[j]=0
      for carte in Cartes_recuperees[j]:
        scores[j] += 1+1*(carte%10==5)+2*(carte%10==0)+4*(carte%11==0)+1*(carte==55)
      for chiffre in range(len(str(scores[j]))):
        motif=images[str(scores[j])[chiffre]+"_"]
        #dec=-4*(carte>99)+4*(carte<10)
        for ligne in range(len(motif)):
            elt=motif[ligne]
            rang=4*chiffre
            for pos in range(0,len(elt)-1,2):
              rang+=ord(elt[pos])-35
              fill_rect(X+2+rang,Y+3+ligne,ord(elt[pos+1])-35,1,"b")
              rang+=ord(elt[pos+1])-35
      minitete(X+7+4*(scores[j]>9)+4*(scores[j]>99),Y+4,"b")

    for joueur in range(4):
      if joueur==0:
        
        #sleep(1)
        #choix de la carte à jouer
        choix=0
        chg=1
        while not (keydown(KEY_EXE) or keydown(KEY_OK)):
          if chg:
            #cadre(choix,"w")
            fill_rect(5+min(45,270//max(1,len(Mains[joueur])-1))*choix,150,39,10,"w")
            IMG(Mains[joueur][choix],5+min(45,270//max(1,len(Mains[joueur])-1))*choix,160)
            choix=(choix+chg)%(len(Mains[joueur]))
            IMG(Mains[joueur][choix],5+min(45,270//max(1,len(Mains[joueur])-1))*choix,150)
            fill_rect(5+min(45,270//max(1,len(Mains[joueur])-1))*choix,201,39,10,"w")
            sleep(0.3)
            #cadre(choix,"r")
          chg=keydown(KEY_RIGHT)-keydown(KEY_LEFT)
        while keydown(KEY_EXE) or keydown(KEY_OK):1

        fill_rect(5+min(45,270//max(1,len(Mains[joueur])-1))*choix,150,39,51,"w") #on efface la carte jouée
        sleep(0.5)

        Cartes_jouees[joueur]=Mains[joueur].pop(choix)#randint(0,len(Mains[joueur])-1)) # à retirer
        
        fill_rect(0,160,320,52,"w")
        for j in range(len(Mains[joueur])):
          IMG(Mains[joueur][j],5+min(45,270//max(1,len(Mains[joueur])-1))*j,160)
        
        #choix de la carte à jouer
        #Cartes_jouees[joueur]=choix
      else:
        Cartes_jouees[joueur]=Mains[joueur].pop(randint(0,len(Mains[joueur])-1)) # à modifier pour au moins éviter de jouer une carte qui suit immédiatement la dernière carte d'une pile de 5 cartes

    for i in range(4):
      X=10+260*(i>1)
      Y=80-60*(0<i<3)
      fill_rect(X+1,Y+1,37,49,"w") # on efface avant de dessiner la carte
      # cadre
      cadre_carte(X,Y,"purple")
    sleep(2)

    for i in range(4): # on affiche les 4 cartes jouées
      IMG(Cartes_jouees[i],10+260*(i>1),80-60*(0<i<3))
    sleep(2)

    # on traite les cartes jouées dans l'ordre croissant
    Ordre=[Cartes_jouees.index(k) for k in sorted(Cartes_jouees)]

    #print(*Piles)
    for i in range(4):
      print(Piles[i])
    print("Cartes jouées : ",*Cartes_jouees)
    
    for i in range(4):
      X=20+255*(Ordre[i]>1)
      Y=70-60*(0<Ordre[i]<3)
      Carte=Cartes_jouees[Ordre[i]] # on traite la carte à placer sur une pile
      if Carte < min([Piles[k][-1] for k in range(4)]):
        # la carte est trop petite et il va falloir choisir une pile à récupérer
        if Ordre[i]==0: #choix de la pile à récupérer
          draw_string("choisir la pile à récupérer",25,140,"b")
          Choix_Pile=1
          chg=-1
          while not (keydown(KEY_EXE) or keydown(KEY_OK)):
            if chg:
              draw_string("^",60+15+50*Choix_Pile,124,"w")
              Choix_Pile=(Choix_Pile+chg)%4
              draw_string("^",60+15+50*Choix_Pile,124,"r")
              sleep(0.3)
            chg=keydown(KEY_RIGHT)-keydown(KEY_LEFT)
          while keydown(KEY_EXE) or keydown(KEY_OK):1
          draw_string("choisir la pile à récupérer",25,140,"w")
          draw_string("^",60+15+50*Choix_Pile,124,"w")
        else:
          Tetes=[sum(1+1*(Piles[N][c]%10==5)+2*(Piles[N][c]%10==0)+4*(Piles[N][c]%11==0)+1*(Piles[N][c]==55) for c in range(len(Piles[N]))) for N in range(4)] # penalités des 4 piles
        #print(Carte)
        #print(Piles)
        #print("Tetes : ",Tetes)
          Choix_Pile=Tetes.index(min(Tetes)) # on détermine la pile qui a le moins de têtes
        
        Cartes_recuperees[Ordre[i]]+=Piles[Choix_Pile] # puis on la récupère
        fill_rect(60+50*Choix_Pile,10,40,31+20*len(Piles[Choix_Pile]),"w") # on efface la pile
        #sleep(0.5)
        
        score=0
        for carte in Piles[Choix_Pile]:
          score += 1+1*(carte%10==5)+2*(carte%10==0)+4*(carte%11==0)+1*(carte==55)
        if score>0:
          fill_rect(X+11+7+4*(scores[Ordre[i]]>9)+4*(scores[Ordre[i]]>99),Y+4,1,3,"r")
          fill_rect(X+10+7+4*(scores[Ordre[i]]>9)+4*(scores[Ordre[i]]>99),Y+5,3,1,"r")
          for chiffre in range(len(str(score))):
            motif=images[str(score)[chiffre]+"_"]
            #dec=-4*(carte>99)+4*(carte<10)
            for ligne in range(len(motif)):
                elt=motif[ligne]
                rang=4*chiffre
                for pos in range(0,len(elt)-1,2):
                  rang+=ord(elt[pos])-35
                  fill_rect(X+21+2+rang,Y+3+ligne,ord(elt[pos+1])-35,1,"r")
                  rang+=ord(elt[pos+1])-35
          minitete(X+21+7+4*(score>9)+4*(score>99),Y+4,"r")

        Piles[Choix_Pile]=[Carte] # et à la place on y place la carte jouée
        #print(Cartes_recuperees)
      else:
        differences=[Carte-Piles[k][-1]+200*(Carte<Piles[k][-1]) for k in range(4)] # le +200 permet d'exclure les piles qui contiennent des cartes trop grandes
        Choix_Pile=differences.index(min(differences))
        if len(Piles[Choix_Pile]) == 5: # si la pile choisie contient 5 cartes
          Cartes_recuperees[Ordre[i]]+=Piles[Choix_Pile] # alors on la récupère
          
          score=0
          for carte in Piles[Choix_Pile]:
            score += 1+1*(carte%10==5)+2*(carte%10==0)+4*(carte%11==0)+1*(carte==55)
          if score>0:
            fill_rect(X+11+7+4*(scores[Ordre[i]]>9)+4*(scores[Ordre[i]]>99),Y+4,1,3,"r")
            fill_rect(X+10+7+4*(scores[Ordre[i]]>9)+4*(scores[Ordre[i]]>99),Y+5,3,1,"r")
            for chiffre in range(len(str(score))):
              motif=images[str(score)[chiffre]+"_"]
              #dec=-4*(carte>99)+4*(carte<10)
              for ligne in range(len(motif)):
                  elt=motif[ligne]
                  rang=4*chiffre
                  for pos in range(0,len(elt)-1,2):
                    rang+=ord(elt[pos])-35
                    fill_rect(X+21+2+rang,Y+3+ligne,ord(elt[pos+1])-35,1,"r")
                    rang+=ord(elt[pos+1])-35
            minitete(X+21+7+4*(score>9)+4*(score>99),Y+4,"r")
          
          Piles[Choix_Pile]=[Carte] # et à la place on y place la carte jouée
          fill_rect(60+50*Choix_Pile,10,40,131,"w") # on efface la pile
          #print(Cartes_recuperees)
        else:
          Piles[Choix_Pile].append(Carte) # si la pile contient moins de 5 cartes, alors on y ajoute la carte jouée
      sleep(0.5)

      X=10+260*(Ordre[i]>1)
      Y=80-60*(0<Ordre[i]<3)
      fill_rect(X+1,Y+1,37,49,"w") # on efface la carte jouée
      IMG(Piles[Choix_Pile][-1],60+50*Choix_Pile,-5+15*len(Piles[Choix_Pile])) # on affiche la nouevlle carte posée sur une pile
      sleep(1)
      #IMG(Piles[Choix_Pile][-1],60+50*Choix_Pile,-10+20*len(Piles[Choix_Pile]))
      #sleep(2)

        #print(Carte)
        #print(Choix_Pile,Piles[Choix_Pile])
        #print(Ordre)
    #print(Mains)
    #print(*Piles)
    #print(Jeu)
    #for joueur in range(4):
    #  print(*Mains[joueur])

  # calcul des scores
  scores=[0,0,0,0]
  for joueur in range(4):
    #X=10+260*(joueur>1)
    #Y=80-60*(0<joueur<3)
    for carte in Cartes_recuperees[joueur]:
      scores[joueur] += 1+1*(carte%10==5)+2*(carte%10==0)+4*(carte%11==0)+1*(carte==55)
    
  # affichage des scores
  for joueur in range(4):
    X=10+260*(joueur>1)
    Y=80-60*(0<joueur<3)
    clr=(("b","r")[scores[joueur]==max(scores)],"g")[scores[joueur]==min(scores)]
    cadre_carte(X,Y,clr)
    draw_string("J"+str(joueur),X+10,Y+5,clr)
    draw_string(str(scores[joueur]),X+2,Y+20,clr)
    minitete(X+25,Y+30,clr)

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

During your visit to our site, NumWorks needs to install "cookies" or use other technologies to collect data about you in order to:

With the exception of Cookies essential to the operation of the site, NumWorks leaves you the choice: you can accept Cookies for audience measurement by clicking on the "Accept and continue" button, or refuse these Cookies by clicking on the "Continue without accepting" button or by continuing your browsing. You can update your choice at any time by clicking on the link "Manage my cookies" at the bottom of the page. For more information, please consult our cookies policy.