• Explore
• My scripts
• Calculator

Explications en vidéo

from kandinsky import fill_rect, draw_string, set_pixel
from random import *
from time import sleep
from ion import *

R,N,B,F,G = (255,0,0), 3*(0,), 3*(255,), (80,130,50), 3*(80,)
BTS = [48,42,43,44,36,37,38,30,31,32,49,5]
FIG = [[16,56,124,254,511,254,124,56,16],[56,56,56,471,511,471,16,56,511],\
[16,56,124,254,511,511,443,56,511],[198,495,511,511,511,254,124,56,16]]
COUL = [R,N,N,R]
VAL = [1,2,3,4,5,6,7,8,9,10,'V','D','R']

X = [0,2,4,6,8,10,12,14,16,18,1,3,5,7,9,11,13,15,17,2,4,8,10,14,16,3,9,15]
Y = [3] * 10 + [2] * 9 + [1] * 6 + [0,0,0]
E = [1] * 10 + [[0,1],[1,2],[2,3],[3,4],[4,5],[5,6],[6,7],[7,8],[8,9],\
[10,11],[11,12],[13,14],[14,15],[16,17],[17,18],[19,20],[21,22],[23,24]] 

jeu = sorted(list(range(52)), key = lambda x:random())
cHaut = jeu[:28]
cPile = jeu[28:-1]
cSortie = jeu[-1:]
del jeu

def efface(a,b): fill_rect(0,a,320,b,F)

def milieu(l,t): return (l - 10 * len(t)) // 2

def dos(x,y):
     fill_rect(x,y,25,45,G)
     fill_rect(x,y,25,1,B)
     fill_rect(x,y,1,45,B) 

def carte(x, y, f, t, coul):
  fill_rect(x, y, 25, 45, B)
  for c in range(9):
    for l in range(9):
        if f[l] >> c & 1: 
            set_pixel(x + 2 + c, y + 2 + l, coul)
            set_pixel(x + 14 + c, y + 34 + l, coul)                
  draw_string(t, x + milieu(25, t), y + 14, N, B) 

def touche(x,y,v):
    t = str(v)
    draw_string(t, x + milieu(25, t), 135, B, F) 

def visuel(v):
    return [COUL[v // 13], FIG[v // 13], str(VAL[v % 13])]

def haut():
    efface(0,160)
    nb_visibles = len([i for i in E if i == 1])
    possibles = []
    k = 1
    for n in reversed(range(28)):
        v = cHaut[n]
        x, y = 12 + 15 * X[n], 10 + 25 * Y[n]
        if type(E[n]) == type([]): dos(x,y) 
        elif E[n] == 1: 
            possibles = [n] + possibles
            touche(x, y, nb_visibles - k)
            [coul, f, t] = visuel(v)
            carte(x, y, f, t, coul)
            k += 1
    return possibles

def pile():
    efface(160,220)
    for i in range(len(cPile)): dos(40 + 3 * i, 160)

def sortie():
    [coul, f, t] = visuel(cSortie[-1])
    carte(150,160,f,t,coul)

def jouer():
 while True:
  for i in BTS:
   if keydown(i): 
        sleep(.2)
        return BTS.index(i)

def legal(n):
    return (cSortie[-1] - n) % 13 in [1, 12]

def suivant(v):
    n = cHaut[v]
    if legal(n):
        E[v] = 0
        cSortie.append(n)
        for k in range(28):
          if type(E[k]) == type([]):
            try: 
                E[k].remove(v)
                if len(E[k]) == 0: E[k] = 1
            except: continue

def pioche():
    if len(cPile) > 0: 
        cSortie.append(cPile.pop(0))
        return True
    return False

def perdu(possibles):
    if len(cPile) > 0 or any([legal(cHaut[v]) for v in possibles]): return False
    t = "=== PERDU ==="
    draw_string(t, milieu(320,t), 110, B, R)
    return True

def gagne(): 
    if all(E[n] == 0 for n in range(28)):
        t = "=== GAGNE ==="
        draw_string(t, milieu(320,t), 110, B, N)
        return True
    return False

def go():
   majHaut = majPile = True
   while True: 
    if majHaut: possibles = haut()
    if majPile: pile()
    sortie()
    if perdu(possibles): break
    if gagne(): break  
    t = jouer()
    majHaut = majPile = False
    if t == 11: break
    elif t == 10: majPile = pioche()
    elif t < len(possibles): 
        suivant(possibles[t])  
        majHaut = True   

go()