Picross est un jeu de puzzle dont le but est de colorier certaines cases d’une grille pour faire apparaître un dessin. Des nombres donnés respectivement en haut et à gauche de la grille donnent la taille des bandes de cases consécutives à colorier, respectivement en colonne et en ligne. Ces bandes de cases coloriées sont séparées par au moins une case blanche.
Le mode Dessin permet de dessiner son propre motif et de récupérer la liste qui correspond à sa version puzzle. Une fois le dessin terminé, un appui sur la touche HOME puis sur OK permet d’afficher la liste qui correspond au dessin (à insérer dans le script pour qu’il devienne jouable).
Le mode Jeu :) permet de choisir si l’on veut ou non de l’aide moyennant une pénalité en cas de case coloriée par erreur, puis de choisir le puzzle à résoudre. Les Règles expliquent les règles. :)
La touche OK (ou EXE) permet de valider les choix et de colorier (ou effacer) une case. La touche SHIFT permet de placer une croix dans une case pour symboliser qu’elle ne doit pas être coloriée.
Bon jeu ! :)
# Picross # par Afyu 10/2025 from kandinsky import * from ion import * from time import * from random import * chiffres_petits=("HFFFH", #('111','101','101','101','111'),\ "CGCCH", #('010','110','010','010','111'),\ "HBHEH", #('111','001','111','100','111'),\ "HBHBH", #('111','001','111','001','111'),\ "FFHBB", #('101','101','111','001','001'),\ "HEHBH", #('111','100','111','001','111'),\ "HEHFH", #('111','100','111','101','111'),\ "HBCEE", #('111','001','010','100','100'),\ "HFHFH", #('111','101','111','101','111'),\ "HFHBH") #('111','101','111','001','111')) chiffres_moyens=("ORRRRRRO", #('01110','10001','10001','10001','10001','10001','10001','01110'),\ "EMUEEEE`", #('00100','01100','10100','00100','00100','00100','00100','11111'),\ "ORRBCEI`", #('01110','10001','10001','00001','00010','00100','01000','11111'),\ "`CEOBBRO", #('11111','00010','00100','01110','00001','00001','10001','01110'),\ "GKKSS`CC", #('00110','01010','01010','10010','10010','11111','00010','00010'),\ "`QQ_BBRO", #('11111','10000','10000','11110','00001','00001','10001','01110'),\ "HIQ_RRRO", #('00111','01000','10000','11110','10001','10001','10001','01110'),\ "`BCCEEII", #('11111','00001','00010','00010','00100','00100','01000','01000'),\ "ORRORRRO", #('01110','10001','10001','01110','10001','10001','10001','01110'),\ "ORRRPBRO") #('01110','10001','10001','10001','01111','00001','10001','01110')) def DessineImage(truc,dX,dY,clr="b",clr_fond="w"): longueur=len(str(truc)) dX=dX-(3-1*mode_petits_chiffres)*(longueur>1) #dY=y if T>18: draw_string(str(truc),dX-10*(longueur>1),dY,clr,clr_fond) return #else: for element in range(longueur): # par Afyu 10/2025 motif=(chiffres_moyens,chiffres_petits)[mode_petits_chiffres][int(str(truc)[element])] motif=["0"*(7-2*mode_petits_chiffres-len(bin(ord(elt)-65)))+bin(ord(elt)-65)[2:] for elt in motif] for ligne in range(len(motif)): for colonne in range(len(motif[ligne])): set_pixel(dX+colonne+(1+len(motif[ligne]))*element,dY+ligne,(clr_fond,clr)[int(motif[ligne][colonne])]) def dessine_plateau(x,y): for D in (0,1): for ligne in range(0,len(image)+1,1+4*D): # par pas de 1 ou 5 fill_rect(x,y+T*ligne,len(image[0])*T+1,1,("pink","b")[D]) for colonne in range(0,len(image[0])+1,1+4*D): fill_rect(x+T*colonne,y,1,len(image)*T,("pink","b")[D]) #for ligne in range(0,len(image)+1,5): # fill_rect(x,y+T*ligne,len(image[0])*T+1,1,"b") #for colonne in range(0,len(image[0])+1,5): # fill_rect(x+T*colonne,y,1,len(image)*T,"b") def dessine_curseur(x,y,clr): dX=Xp+largeur_nombres+T*x dY=Yp+hauteur_nombres+T*y for k in (0,1): fill_rect(dX+1,dY+1+(T-2)*k,T-1,1,clr) fill_rect(dX+1+(T-2)*k,dY+1,1,T-2,clr) def analyse_par_ligne(image): # indices par ligne (nombres à gauche du tableau) Indices_lignes=[] for ligne in range(len(image)): Liste_ligne=[] N=0 for colonne in range(len(image[ligne])): if image[ligne][colonne]=="N": N+=1 else: if N>0: Liste_ligne.append(N) N=0 if N>0: Liste_ligne.append(N) Indices_lignes.append(Liste_ligne) return Indices_lignes def analyse_par_colonne(image): # indices par colonne (nombres en haut du tableau) return analyse_par_ligne(["".join(image[l][c] for l in range(len(image))) for c in range(len(image[0]))]) # Indices_colonnes=[] # for colonne in range(len(image[0])): # Liste_colonne=[] # N=0 # for ligne in range(len(image)): # if image[ligne][colonne]=="N": # N+=1 # else: # if N>0: # Liste_colonne.append(N) # N=0 # if N>0: # Liste_colonne.append(N) # Indices_colonnes.append(Liste_colonne) # return Indices_colonnes def afficher_indices_lignes_et_colonnes(clr="b"): for ligne in range(len(Indices_lignes)): for rang in range(len(Indices_lignes[ligne])): DessineImage(Indices_lignes[ligne][rang],Xp+(4+3*dizaines_dans_lignes+5-2*mode_petits_chiffres+5*(T>18))*rang,Yp+hauteur_nombres+1+(T-8+3*mode_petits_chiffres-10*(T>18))//2+T*ligne,clr) #def afficher_indices_colonnes(clr="b"): for colonne in range(len(Indices_colonnes)): for rang in range(len(Indices_colonnes[colonne])): DessineImage(Indices_colonnes[colonne][rang],Xp+largeur_nombres+1+(T-5+2*mode_petits_chiffres-5*(T>18))//2+T*colonne,Yp+(2+8-3*mode_petits_chiffres+10*(T>18))*rang,clr) def Analyse(image): # indices par ligne (nombres à gauche du tableau) : Indices_lignes=analyse_par_ligne(image) # indices par colonne (nombres en haut du tableau) : Indices_colonnes=analyse_par_colonne(image) dizaines_dans_colonnes = max([max(Indices_colonnes[k]) for k in range(len(Indices_colonnes)) if Indices_colonnes[k]!=[]])>9 dizaines_dans_lignes = max([max(Indices_lignes[k]) for k in range(len(Indices_lignes)) if Indices_lignes[k]!=[]])>9 longueur_max_listes_colonnes=max([len(Indices_colonnes[k]) for k in range(len(Indices_colonnes))]) longueur_max_listes_lignes=max([len(Indices_lignes[k]) for k in range(len(Indices_lignes))]) if pos==0: longueur_max_listes_colonnes=0 longueur_max_listes_lignes=0 mode_petits_chiffres = (len(image)>13 and dizaines_dans_colonnes) or (len(image)+longueur_max_listes_colonnes>20) or (len(image[0])+longueur_max_listes_lignes>30) hauteur_nombres = longueur_max_listes_colonnes*(2+8-3*mode_petits_chiffres)+2 largeur_nombres = longueur_max_listes_lignes*(4+3*dizaines_dans_lignes+5-2*mode_petits_chiffres) T=min((200-hauteur_nombres)//len(image),(320-20-largeur_nombres)//len(image[0])) if T>18: hauteur_nombres = longueur_max_listes_colonnes*(2+18)+2 largeur_nombres = longueur_max_listes_lignes*(2+10)+2 T=min((200-10-hauteur_nombres)//len(image),(320-20-largeur_nombres)//len(image[0])) largeur_plateau = len(image[0])*T hauteur_plateau = len(image)*T Xp=(320-largeur_plateau-largeur_nombres)//2 Yp=18+(222-18-hauteur_plateau-hauteur_nombres)//2 return Indices_lignes,Indices_colonnes,mode_petits_chiffres,hauteur_nombres,largeur_nombres,T,Xp,Yp def jeu(image): tentative=["B"*len(image[0]) for k in range(len(image))] penalites=0 Xc,Yc=1,0 chgX=-1 chgY=0 T0=monotonic() while 1: if chgX or chgY: dessine_curseur(Xc,Yc,get_pixel(Xp+largeur_nombres+T*Xc+2,Yp+hauteur_nombres+T*Yc+3)) # de la couleur des traits du plateau if pos==2: # si on n'est pas en mode Dessin, alors on réaffiche les nombres en bleu for rang in range(len(Indices_colonnes[Xc])): DessineImage(Indices_colonnes[Xc][rang],Xp+largeur_nombres+1+(T-5+2*mode_petits_chiffres-5*(T>18))//2+T*Xc,Yp+(2+8-3*mode_petits_chiffres+10*(T>18))*rang,"b") for rang in range(len(Indices_lignes[Yc])): DessineImage(Indices_lignes[Yc][rang],Xp+(4+3*dizaines_dans_lignes+5-2*mode_petits_chiffres+5*(T>18))*rang,Yp+hauteur_nombres+1+(T-8+3*mode_petits_chiffres-10*(T>18))//2+T*Yc,"b") Xc=(Xc+chgX)%len(image[0]) Yc=(Yc+chgY)%len(image) dessine_curseur(Xc,Yc,"g") Indices_lignes_tentative=analyse_par_ligne(tentative) Indices_colonnes_tentative=analyse_par_colonne(tentative) if pos==2: for ligne in range(len(image)): if Indices_lignes_tentative[ligne]==Indices_lignes[ligne]: for rang in range(len(Indices_lignes[ligne])): DessineImage(Indices_lignes[ligne][rang],Xp+(4+3*dizaines_dans_lignes+5-2*mode_petits_chiffres+5*(T>18))*rang,Yp+hauteur_nombres+1+(T-8+3*mode_petits_chiffres-10*(T>18))//2+T*ligne,"gray") for colonne in range(len(image[0])): if Indices_colonnes_tentative[colonne]==Indices_colonnes[colonne]: for rang in range(len(Indices_colonnes[colonne])): DessineImage(Indices_colonnes[colonne][rang],Xp+largeur_nombres+1+(T-5+2*mode_petits_chiffres-5*(T>18))//2+T*colonne,Yp+(2+8-3*mode_petits_chiffres+10*(T>18))*rang,"gray") for rang in range(len(Indices_colonnes[Xc])): DessineImage(Indices_colonnes[Xc][rang],Xp+largeur_nombres+1+(T-5+2*mode_petits_chiffres-5*(T>18))//2+T*Xc,Yp+(2+8-3*mode_petits_chiffres+10*(T>18))*rang,"g") for rang in range(len(Indices_lignes[Yc])): DessineImage(Indices_lignes[Yc][rang],Xp+(4+3*dizaines_dans_lignes+5-2*mode_petits_chiffres+5*(T>18))*rang,Yp+hauteur_nombres+1+(T-8+3*mode_petits_chiffres-10*(T>18))//2+T*Yc,"g") sleep(0.2) chgX=keydown(KEY_RIGHT)-keydown(KEY_LEFT) chgY=keydown(KEY_DOWN)-keydown(KEY_UP) if keydown(KEY_OK) or keydown(KEY_EXE): if get_pixel(Xp+largeur_nombres+T*Xc+2,Yp+hauteur_nombres+T*Yc+2)==(0,0,0): # si la case est déjà noircie ou contient une croix noire fill_rect(Xp+largeur_nombres+T*Xc+2,Yp+hauteur_nombres+T*Yc+2,T-3,T-3,"w") # alors on l'efface Liste=list(tentative[Yc]) Liste[Xc]="B" tentative[Yc]="".join(Liste) # if tentative==image: # ce cas n'arrive pas si on a activé la correction automatique des erreurs avec pénalités # draw_string("Gagné en "+str(int(monotonic()-T0)+duree_penalite*penalites*mode_penalite)+" sec !",70,2,"r") # break else: # si la case est blanche if image[Yc][Xc]=="B" and mode_penalite: # si elle est censée rester blanche et qu'on activé l'aide et les pénalités for i in range(T-3): # alors on affiche une croix rouge au lieu de la noircir set_pixel(Xp+largeur_nombres+T*Xc+2+i,Yp+hauteur_nombres+T*Yc+2+i,"r") set_pixel(Xp+largeur_nombres+T*Xc+2+T-4-i,Yp+hauteur_nombres+T*Yc+2+i,"r") penalites+=1 else: # sinon, c'est qu'on est sans aide et pénalité ou que la case est censée être noircie et donc tout va bien, on la noircit fill_rect(Xp+largeur_nombres+T*Xc+2,Yp+hauteur_nombres+T*Yc+2,T-3,T-3,"k") Liste=list(tentative[Yc]) Liste[Xc]="N" tentative[Yc]="".join(Liste) sleep(0.1) while (keydown(KEY_EXE) or keydown(KEY_OK)) and not any(keydown(k) for k in range(4)):1 if keydown(KEY_SHIFT): if get_pixel(Xp+largeur_nombres+T*Xc+2,Yp+hauteur_nombres+T*Yc+2)!=(0,0,0): # si la case n'est pas noire et ne contient pas de croix noire for i in range(T-3): # alors on dessine une croix noire set_pixel(Xp+largeur_nombres+T*Xc+2+i,Yp+hauteur_nombres+T*Yc+2+i,"k") set_pixel(Xp+largeur_nombres+T*Xc+2+T-4-i,Yp+hauteur_nombres+T*Yc+2+i,"k") else: # sinon (case noire ou croix), on blanchit la case fill_rect(Xp+largeur_nombres+T*Xc+2,Yp+hauteur_nombres+T*Yc+2,T-3,T-3,"w") Liste=list(tentative[Yc]) Liste[Xc]="B" tentative[Yc]="".join(Liste) sleep(0.1) while keydown(KEY_SHIFT) and not any(keydown(k) for k in range(4)):1 if tentative==image and pos==2: draw_string("Gagné en "+str(int(monotonic()-T0)+duree_penalite*penalites*mode_penalite)+" sec !",70,2,"r") if mode_penalite: draw_string("dont "+str(penalites)+" pénalités de "+str(duree_penalite)+" sec",30,22,"r") break if keydown(KEY_HOME) and pos==0: # mode Dessin print("Liste à copier dans le script du jeu : \n",tentative) #print(tentative) break # affichage du dessin complet, résolu # on efface les nombres afficher_indices_lignes_et_colonnes("w") #afficher_indices_colonnes("w") # on redessine les cases noircies, un peu plus grandes pour masquer les traits du plateau if pos==0: image=tentative affichage_puzzle_resolu(image) # for ligne in range(len(image)): # for colonne in range(len(image[0])): # fill_rect(Xp+largeur_nombres+T*colonne,Yp+hauteur_nombres+T*ligne,T,T,"wk"[image[ligne][colonne]=="N"]) #"br"[colonne%5==0]) # fill_rect(Xp+largeur_nombres,Yp+hauteur_nombres+T*len(image),len(image[0])*T+1,1,"w") # on efface la bordure basse de la grille # fill_rect(Xp+largeur_nombres+T*len(image[0]),Yp+hauteur_nombres,1,len(image)*T+1,"w") # on efface la bordure droite de la grille #if pos==0: # return True #return False def affichage_puzzle_resolu(image,D=0): for ligne in range(len(image)): for colonne in range(len(image[0])): fill_rect(Xp+largeur_nombres+D+T*colonne,Yp+hauteur_nombres+D+T*ligne,T-D,T-D,"wk"[image[ligne][colonne]=="N"]) #"br"[colonne%5==0]) fill_rect(Xp+largeur_nombres,Yp+hauteur_nombres+T*len(image),len(image[0])*T+1,1,"w") # on efface la bordure basse de la grille fill_rect(Xp+largeur_nombres+T*len(image[0]),Yp+hauteur_nombres,1,len(image)*T+1,"w") # on efface la bordure droite de la grille def affichage_puzzle_geant(GEANT,D=0): for X in range(len(GEANT[0])//10): for Y in range(len(GEANT)//10): if (X,Y) in morceaux_resolus: for k in range(10): for l in range(10): fill_rect(Xp+largeur_nombres+(T+D)*X+int(T/10)*k+1,Yp+hauteur_nombres+(T+D)*Y+int(T/10)*l+1,int(T/10),int(T/10),"wk"[GEANT[10*Y+l][10*X+k]=="N"]) def jeu_mode_geant(GEANT): global morceaux_resolus,morceaux_a_resoudre,Indices_lignes,Indices_colonnes,mode_petits_chiffres,hauteur_nombres,largeur_nombres,T,Xp,Yp,image morceaux_resolus=[]#(0,0),(0,1),(0,2),(0,3),(1,0),(1,1),(1,2),(1,3),(2,0),(2,1),(3,3),(2,3),(3,0),(3,1),(3,2)] morceaux_a_resoudre=sorted([(X,Y) for X in range(len(GEANT[0])//10) for Y in range(len(GEANT)//10)]) while sorted(morceaux_resolus)!=morceaux_a_resoudre: fill_rect(0,0,320,222,"w") image=["N"*(len(GEANT[0])//10) for k in range(len(GEANT)//10)] Indices_lignes,Indices_colonnes,mode_petits_chiffres,hauteur_nombres,largeur_nombres,T,Xp,Yp=Analyse(image) dessine_plateau(Xp+largeur_nombres,Yp+hauteur_nombres) affichage_puzzle_geant(GEANT) #N=1 Xc=1 Yc=0 chgX=-1 chgY=0 while keydown(KEY_EXE) or keydown(KEY_OK):1 while not (keydown(KEY_EXE) or keydown(KEY_OK)): # choix du morceau de puzzle à résoudre if chgX or chgY: dessine_curseur(Xc,Yc,"w")#get_pixel(Xp+largeur_nombres+T*Xc+2,Yp+hauteur_nombres+T*Yc+3)) # de la couleur des traits du plateau Xc=(Xc+chgX)%(len(GEANT[0])//10) Yc=(Yc+chgY)%(len(GEANT)//10) dessine_curseur(Xc,Yc,"g") sleep(0.2) chgX=keydown(KEY_RIGHT)-keydown(KEY_LEFT) chgY=keydown(KEY_DOWN)-keydown(KEY_UP) #dessine_plateau(Xp+largeur_nombres,Yp+hauteur_nombres) while keydown(KEY_EXE) or keydown(KEY_OK):1 fill_rect(0,0,320,222,"w") # on récupère le morceau de puzzle à résoudre image=["".join(GEANT[10*Yc+j][10*Xc+i] for i in range(10)) for j in range(10)] Xm,Ym=Xc,Yc # sauvegarde du numéro du morceau Indices_lignes,Indices_colonnes,mode_petits_chiffres,hauteur_nombres,largeur_nombres,T,Xp,Yp=Analyse(image) dessine_plateau(Xp+largeur_nombres,Yp+hauteur_nombres) # affiche les nombres (à gauche et en haut) afficher_indices_lignes_et_colonnes() #afficher_indices_colonnes() if keydown(KEY_UP): # triche/débug qui affiche le puzzle résolu affichage_puzzle_resolu(image) chgX=1 N-=1 while keydown(KEY_UP):1 while keydown(KEY_OK) or keydown(KEY_EXE):1 jeu(image) morceaux_resolus.append((Xm,Ym)) while keydown(KEY_EXE) or keydown(KEY_OK):1 while not (keydown(KEY_EXE) or keydown(KEY_OK)):1 # puzzle géant résolu ! fill_rect(0,0,320,222,"w") image=["N"*(len(GEANT[0])//10) for k in range(len(GEANT)//10)] Indices_lignes,Indices_colonnes,mode_petits_chiffres,hauteur_nombres,largeur_nombres,T,Xp,Yp=Analyse(image) affichage_puzzle_geant(GEANT,-2) #while keydown(KEY_EXE) or keydown(KEY_OK):1 #while not (keydown(KEY_EXE) or keydown(KEY_OK)):1 # Tailles : # Petit : de 5×5 à 10×10 # Moyen : de 10×15 ou 15×10 à 15×15 # Grand : 20×15 (ou 15×20 ou 20×20 ou 25×20 ? ou 30×20 possible ?) # Plateaux : L×H logo_Picross=['NNNBNBNNNBNNNBNNNBNNNBNNN', 'NBNBBBNBBBNBNBNBNBNBBBNBB', 'NNNBNBNBBBNNNBNBNBNNNBNNN', 'NBBBNBNBBBNNBBNBNBBBNBBBN', 'NBBBNBNNNBNBNBNNNBNNNBNNN'] Petits=( # Smiley 10×10 ["BBNNNNNNBB","BNNBBBBNNB","NNBBBBBBNN","NBBNBBNBBN","NBBBBBBBBN","NBBBBBBBBN","NBNBBBBNBN","NNBNNNNBNN","BNNBBBBNNB","BBNNNNNNBB"], # coeur 5×5 ['BNBNB', 'NNNNN', 'NNNNN', 'BNNNB', 'BBNBB'], # test9 5×10 ['NBBBB', 'NNNNN', 'NBBBB', 'NNBBB', 'NNNNN', 'NNNNB', 'NNNBB', 'NBBBB', 'NNNNN', 'NNNNB'], # test10 10×5 #['NNNNNBBBBB', 'NBBBBBBBBB', 'NNBBBBBBBB', 'NNNNNBBBBB', 'NNNNNNBBBB'], # logo Picross 25×5 logo_Picross ) Moyens=( # Limbo 12×15 ["BBBBNNNNNNNN","BBBNNNNNNNNN","BBNNNNNNNNNB","BBNNNNBNBNNB","BBNNNNNNNNBB","BBBNNNNNNNBB","BBBBNNNNNBBB","BBBBBNNBBBBB","BBBBNNNNBBBB","BBBNNNNNBBBB","BBNNNNNNBBBB","BBNNNNNNNBBB","BNNNNNNBNNBB","NNBNNNNBBNNB","BBBNNNNBBBBB"], # test5 10×15 ['NNNNNNNNNN', 'NNNNNBBBBB', 'NNBBBBBBBB', 'NNNNNNNNNN', 'NBBBBBBBBB', 'NNNNBBBBBB', 'NNNNNNNNNN', 'NNNNNNNNNN', 'NNNNNNNNNN', 'NNNNNNNNNB', 'NNNNNNNNBB', 'NNNNNNBBBB', 'NBBBBBBBBB', 'NNNNNBBBBB', 'NNNNNNBBBB'], # test6 15×15 #['NNNNNNNNNNNBBBB', 'NNNNNNNNBBBBBBB', 'NNNNNNNNBBBBBBB', 'NNNNNBBBBBBBBBB', 'NNNNNNNNNNNBBBB', 'NNNNNNNNNNNNNBB', 'BBNNNNNNNNNNNNB', 'NNBBBBBBBBBBBBB', 'NNNNNNNNNNNNNNB', 'NNNNNNNNNNBBBBB', 'NNNNNNNNNNNNNBB', 'NNNNNNBBBBBBBBB', 'NNNNNNNNBBBBBBB', 'NNNNNNNNNNNBBBB', 'NNNNNNNNBBBBBBB'], # test7 15×10 #['NNNNNNBBBBBBBBB', 'NNNNNNNNNBBBBBB', 'NNBBBBBBBBBBBBB', 'NNNBBBBBBBBBBBB', 'NNNNBBBBBBBBBBB', 'NNNNNNNBBBBBBBB', 'NNNNBBBBBBBBBBB', 'NNNNNNNNBBBBBBB', 'NNNNNNNNNNNNNNN', 'NNNNBBBBBBBBBBB'] ) Grands=( # Hollow Knight 19×14 ["NNNNNNNNNNNNNNNNNNN","NNNNNNNNNBBBBBBBNNN","NNBBBBBNBBBBBBBBBNN","NBNBNNBBBBBBBNNBBBN","NNNNNNNBBBBBNNNNBBN","NNNNNNNNBBBBBNNBBBN","NNNNNNNNBBBBBBBBBBN","NNNNNNNNBBBBBBBBBBN","NNNNNNNNBBBBBNNBBBN","NNNNNNNBBBBBNNNNBBN","NBNBNNBBBBBBBNNBBBN","NNBBBBBNBBBBBBBBBNN","NNNNNNNNNBBBBBBBNNN","NNNNNNNNNNNNNNNNNNN"], # test1 30×20 ['NNNNNNNNNNNNBNNNNNNNNNNBNNBNBN', 'NNNNNNNNNNBBBBBBBBBBBBBBBBBBBB', 'NNNNNNNNNNNNNNNNNNNNNNNNNNBBBB', 'NNNNNNNNNNNNNNNNNNNNNNNNNNBBBB', 'NNNNNNNNNNNNNNNNNNNNNNNNBBBBBB', 'NNNNNNNNNNNNNNNNNNNNBBBBBBBBBB', 'NNNNNNBBBBBBBBBBBBBBBBBBBBBBBB', 'NNNNNNNNNNNNNNNNNNNNNNNNNBBBBB', 'NNNNNNNNNNNNBBBBBBBBBBBBBBBBBB', 'NNNNNNNNNNNNNNNNNNBBBBBBBBBBBB', 'NNNNNNBBBBBBBBBBBBBBBBBBBBBBBB', 'NNNNNNNNNNNBBBBBBBBBBBBBBBBBBB', 'NNNBBBBBBBBBBBBBBBBBBBBBBBBBBB', 'NNNNNNNNNNBBBBBBBBBBBBBBBBBBBB', 'NNNNNNNNNNNNNNNNNNNNNNNNBBBBBB', 'NNNNNNNNNNNNBBBBBBBBBBBBBBBBBB', 'NNNNBBBBBBBBBBBBBBBBBBBBBBBBBB', 'NNNNNNNNBBBBBBBBBBBBBBBBBBBBBB', 'NNNNNNNBBBBBBBBBBBBBBBBBBBBBBB', 'NNNNNNNBBBBBBBBBBBBBBBBBBBBBBB'], # test2 30×15 #['NNNNNNNNNNNBBBBBBBBBBBBBBBBBBB', 'NNNNNNNNNNNNNNNNNNNNNNNNNNNBBB', 'NNBBBBBBBBBBBBBBBBBBBBBBBBBBBB', 'NNNNNNNNNNNNNNNNBBBBBBBBBBBBBB', 'NNNBBBBBBBBBBBBBBBBBBBBBBBBBBB', 'NNNNNNNNNNNNNNNBBBBBBBBBBBBBBB', 'NNNNNNNNNNNBBBBBBBBBBBBBBBBBBB', 'NNNNNNNNNNNNNNBBBBBBBBBBBBBBBB', 'NNNNNNNNNNNNNNNNNNBBBBBBBBBBBB', 'NNNNNNNNNNNNNNNNNNNNNNNNNNNNNB', 'NNBBBBBBBBBBBBBBBBBBBBBBBBBBBB', 'NNNNNNNNNNBBBBBBBBBBBBBBBBBBBB', 'NNNNNNNNNNNNNNNNNNNNBBBBBBBBBB', 'NBBBBBBBBBBBBBBBBBBBBBBBBBBBBB', 'NBBBBBBBBBBBBBBBBBBBBBBBBBBBBB'], # test3 25×20 #['NNNNNNNNNNNNNNNNNNNNNNBBB', 'NNNNNNNNNNNNNNNNNNNNNBBBB', 'NNNNNNNNNNNNNNNNNBBBBBBBB', 'NBBBBBBBBBBBBBBBBBBBBBBBB', 'NNNNNBBBBBBBBBBBBBBBBBBBB', 'NNNNNNNNBBBBBBBBBBBBBBBBB', 'NNNNNNNNNNNNNNNNNNNNNNBBB', 'NNNNNNBBBBBBBBBBBBBBBBBBB', 'NNNNNBBBBBBBBBBBBBBBBBBBB', 'NBBBBBBBBBBBBBBBBBBBBBBBB', 'NNNNNNNNNNNNNNNNNBBBBBBBB', 'NNNNNNNNBBBBBBBBBBBBBBBBB', 'NNNNNNNNNNNNNNNNBBBBBBBBB', 'NNNNNNNBBBBBBBBBBBBBBBBBB', 'NNNBBBBBBBBBBBBBBBBBBBBBB', 'NNNNNNNNNNNNNNNBBBBBBBBBB', 'NNNNNNNNNNNNNNNNNNNNNBBBB', 'NNNNNNNNNNNNNNNNNNNNNNNNB', 'NNNNNNNNNNNNNNNBBBBBBBBBB', 'NNNNNNNNNNNNNBBBBBBBBBBBB'], # test4 20×15 #['NNNNNNNNNBBBBBBBBBBB', 'NNNNNNNNNNNNNNBBBBBB', 'NNBBBBBBBBBBBBBBBBBB', 'NBBBBBBBBBBBBBBBBBBB', 'NNNNNNNBBBBBBBBBBBBB', 'NNNBBBBBBBBBBBBBBBBB', 'NNNNNNNNNNNNNNBBBBBB', 'NNNNNNNNNBBBBBBBBBBB', 'NBBBBBBBBBBBBBBBBBBB', 'NNNNBBBBBBBBBBBBBBBB', 'NBBBBBBBBBBBBBBBBBBB', 'NNNNNNNNNNNNNNNNBBBB', 'NNNNNNNNNNNNNNBBBBBB', 'NNNNNNNBBBBBBBBBBBBB', 'NNNNNNNNNNNNNNBBBBBB'] ) Geant=["NBBNNBBBNNBBNNNNNBBNNBBBNNBBNNNNNBBNNBBB", "NNNBBNNNBBNNNNNNNNNBBNNNBBNNNNNNNNNBBNNN", "BNNNBNNNBNNNBBBBBNNNBNNNBNNNBBBBBNNNBNNN", "NBNNNNBNNNNBNNNNNBNNNNNBNNNBNNNNNBNNNBNB", "NNBNBNBBNNBNNNNNNNBNNBNBBNBNNNNNNNNNBBBB", "NNBBNNBBNBBNNBBBNNBBNBNNNBBNNBBBBBBNNNNN", "BBNNNNBBBNNNNNNNBBNNBBNNNNNBBBBBBNNNNNNN", "BNNNBNBBNBBBBBBBNNNNBBNBBNBBBBBBNNNNNBBB", "NNNBNNBNBNNBBBBBBNNBBBNNNBBBBBBNNNNBNNNN", "BNBNNBNBNBBNBBBBBBNBBNBBNBBBBBBNBNBNNNNN", "NBBNNBNBNBBNBBNNBBNBNBBBNBBBBBNNNBBNNBBB", "NNNBNNBNBNNBBNBBNBNBBBBNBBBBBBNNNNNBBNNN", "BNNNNNBNBBBBBNBNNBNBBBBNBBBBBBNBBNNNBNNN", "NBNNNNNNBBBBBNNNNBNBBBBNBBBBBBNNNBNNNBNB", "NNBNBNNNNNNBBNNNNBNNBBBNBBBBBBNNNNBNBBBB", "NNBBNNNBBBBNNBNNBBBNNBBNBBBBBBNBNNBBNNNN", "BBNNNNBBBBBBBNBBBBNNNNNBBBBBBBBNBBNNNNNN", "BNNNBNBBBBBBBBNBBBNNBBNBBBBBBBBNBNNNBBBB", "NNNBNNBBBBBBBBNBBBNBNNNBBBBBBBBNNNNBNNNN", "BNBNNNNBBBBBBBNBBNNNNNBBBBBBBBBBNNBNNNNN", "NBBNNBBNBBBBNNNBBNNNNNBBBBBBBBBBNBBNNBBB", "NNNBBNNNNNNNBBNBBNNBBNBBBBBBBBBBNNNBBNNN", "BNNNBNNNBNBBBBBNBNNNBNBBBBBBBBBBNNNNBNNN", "NBNNNBNBNBBBBBBNBNNNNBBBBBBBBBBBNBNNNBNB", "NNBNBBBBNBBBBBBNBBNNNBBBBBBBBBBBNNBNBBBB", "NNBBNNNNNBBBBBBBNBBNBBBBBBBBBBBBNNBBNNNN", "BBNNNNNNBBBBBBBBNBBBNBBBBBBBBBBBNBNNNNNN", "BNNNBBBNBBBBBBBBNBBBBNBBBBBBBBBBNNNNBBBB", "NNNBNNNNBBBBBBBBBNBBBBBBBBBBBBBBNNNBNNNN", "BNBNNNNNBBBBBBBBBNBBBBBBBBBBBBBNBNBNNNNN", "NBBNNBBNBBBBBBBBBBNBBBBBBBBBBBBNNBBNNBBB", "NNNBBNNNNBBBBBBBBBNBBBBBBBBBBBNNNNNBBNNN", "BNNNBNNNNBBBBBBBBBBNBBBBBBBBBBNBBNNNBNNN", "NBNNNBNBNNBBBBBBBBBBNBBBBBBBBNNNNBNNNBNB", "NNBNBBBBBNNBBBBBBBBBBNBBBBBBNNNNNNBNBBBB", "NNBBNNNNNBBNBBBBBBBBBBNNBBBNNBBBNNBBNNNN", "BBNNNNNNNNNBNNBBBBBBBBBBNNNBBNNNBBNNNNNN", "BNNNBBBBBNNNBNNNBBBBBBNNBNNNBNNNBNNNBBBB", "NNNBNNNNNBNNNBNBNNNNNNNNNBNNNBNBNNNBNNNN", "BNBNNNNNNNBNBBBBBNBNNNNNNNBNBBBBBNBNNNNN"] # générateur de plateau aléatoire avec un seul nombre pour chaque ligne ##L=30 ##H=20 ##image=["N"*randint(1,L) for k in range(H)] ##for k in range(len(image)): ## l=len(image[k]) ## if l<L: ## image[k]+="B"*(L-l) # à supprimer pour gagner de la place ? pos=0 while 1: fill_rect(0,0,320,222,"w") draw_string("Picross",125,10,"purple") draw_string("(Nonogram)",110,30,"purple") draw_string("Valider avec OK",85,193,"purple") for k in range(2): fill_rect(60,55+k*122,200,1,"g") # affichage du logo Picross image=logo_Picross#['NNNBNBNNNBNNNBNNNBNNNBNNN', 'NBNBBBNBBBNBNBNBNBNBBBNBB', 'NNNBNBNBBBNNNBNBNBNNNBNNN', 'NBBBNBNBBBNNBBNBNBBBNBBBN', 'NBBBNBNNNBNBNBNNNBNNNBNNN'] Indices_lignes,Indices_colonnes,mode_petits_chiffres,hauteur_nombres,largeur_nombres,T,Xp,Yp=Analyse(image) ##Indices_lignes=analyse_par_ligne(image) ##Indices_colonnes=analyse_par_colonne(image) #dizaines_dans_colonnes = False dizaines_dans_lignes = False mode_petits_chiffres = True hauteur_nombres = 21 largeur_nombres = 62 T=7 #largeur_plateau = len(image[0])*T #hauteur_plateau = len(image)*T Xp=10 Yp=68 afficher_indices_lignes_et_colonnes() #afficher_indices_colonnes() affichage_puzzle_resolu(image,1) dessine_plateau(Xp+largeur_nombres,Yp+hauteur_nombres) draw_string("Dessin Règles Jeu :)",30,145,"b") chgX=1 while keydown(KEY_EXE) or keydown(KEY_OK):1 while not (keydown(KEY_EXE) or keydown(KEY_OK)): if chgX: for j in (1,0): for k in (0,1): draw_string("[]"[k],15+80*k+100*pos,145,"rw"[j]) pos=(pos+chgX*j)%3 sleep(0.2) chgX=keydown(KEY_RIGHT)-keydown(KEY_LEFT) while keydown(KEY_EXE) or keydown(KEY_OK):1 fill_rect(0,0,320,222-30*(pos==2),"w") mode_penalite=0 if pos == 1: # affichage des règles draw_string("Présentation",100,10,(80,150,50)) Regles=(("Le but est de colorier les","cases d'une grille pour faire","apparaître un dessin.","","Les nombres affichés en ligne","et en colonne indiquent le","nombre de cases consécutives","à colorier."),\ ("Deux blocs de cases coloriées","sont séparés par au moins une","case vide.","","En mode Dessin, on peut créer","son propre puzzle en colo-","riant les cases de son choix."),\ ("En mode Jeu, on choisit un","puzzle à résoudre.","","Au lancement d'un puzzle, on","choisit ou non la correction","automatique des cases colo-","riées par erreur contre une","pénalité sur le temps écoulé.")) 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)) while not (keydown(KEY_OK) or keydown(KEY_EXE)):1 while keydown(KEY_OK) or keydown(KEY_EXE):1 fill_rect(0,30,320,222-30,"w") elif pos==2: # choix d'un puzzle à résoudre duree_penalite=25 draw_string("Jeu :)",130,10,"g") #draw_string("OK pour valider",85,195,"purple") chgX=1 for i in range(6): draw_string(("Avec correction automatique","des cases coloriées par","erreur contre une pénalité","sur le temps écoulé : ","","Aide / pénalités :")[i],20,33+18*i,"b") draw_string("< >",210,123,"orange") while not (keydown(KEY_OK) or keydown(KEY_EXE)): if chgX: #draw_string(("avec","sans")[mode_penalite],230,123,"w") mode_penalite=1-mode_penalite draw_string(("sans","avec")[mode_penalite],230,123,"purple") sleep(0.3) chgX=keydown(KEY_RIGHT)-keydown(KEY_LEFT) while keydown(KEY_OK) or keydown(KEY_EXE):1 if mode_penalite: chgX=1 draw_string("Durée ajoutée",20,148,"b") draw_string("par pénalité :",20,168,"b") draw_string("< >",170,168,"orange") while not (keydown(KEY_OK) or keydown(KEY_EXE)): if chgX: #draw_string(str(duree_penalite)+" sec",190+5*(duree_penalite<10),168,"w") draw_string(" "*6,190,168,"w") duree_penalite=(duree_penalite+5*chgX)%100 draw_string(str(duree_penalite)+" sec",190+5*(duree_penalite<10),168,"purple") sleep(0.3) chgX=keydown(KEY_RIGHT)-keydown(KEY_LEFT) while keydown(KEY_OK) or keydown(KEY_EXE):1 if pos%2==0: fill_rect(0,0,320,222,"w") N1=len(Petits) N2=len(Moyens) N3=len(Grands) N4=1 N=1 chgX=-1 chgY=0 mode_geant=0 Hauteur_grille=5 # pour le mode Dessin Largeur_grille=5 # pour le mode Dessin while not (keydown(KEY_EXE) or keydown(KEY_OK)): if chgX or chgY: if pos==2 and chgX: fill_rect(0,0,320,222,"w") draw_string("<"+" "*11+">",95,2,"orange") N=(N+chgX)%(N1+N2+N3+N4) mode_geant=0 if N<N1: draw_string("Petit "+str(N+1)+"/"+str(N1),115,2,"b") image=Petits[N] elif N<N1+N2: draw_string("Moyen "+str(N-N1+1)+"/"+str(N2),115,2,"b") image=Moyens[N-N1] elif N<N1+N2+N3: draw_string("Grand "+str(N-N1-N2+1)+"/"+str(N3),115,2,"b") image=Grands[N-N1-N2] else: draw_string("Géant "+str(N-N1-N2-N3+1)+"/"+str(N4),115,2,"b") mode_geant=1#(N+1>N1+N2+N3) image=["N"*(len(Geant[0])//10) for k in range(len(Geant)//10)] if pos==0: fill_rect(0,0,320,222,"w") draw_string("Choix de la taille de la grille",5,2,"b") Hauteur_grille=min(20,max(5,Hauteur_grille+5*chgY)) Largeur_grille=min(30,max(5,Largeur_grille+5*chgX)) image=["N"*Largeur_grille for k in range(Hauteur_grille)] Indices_lignes,Indices_colonnes,mode_petits_chiffres,hauteur_nombres,largeur_nombres,T,Xp,Yp=Analyse(image) dessine_plateau(Xp+largeur_nombres,Yp+hauteur_nombres) if pos==2 and not mode_geant: # affiche les nombres (à gauche et en haut) afficher_indices_lignes_et_colonnes() #afficher_indices_colonnes() sleep(0.3) chgX=keydown(KEY_RIGHT)-keydown(KEY_LEFT) chgY=keydown(KEY_DOWN)-keydown(KEY_UP) if keydown(KEY_UP) and pos==2: # triche/débug qui affiche le puzzle résolu affichage_puzzle_resolu(image) chgX=1 N-=1 while keydown(KEY_UP):1 while keydown(KEY_OK) or keydown(KEY_EXE):1 draw_string("<",95,2,"w") draw_string(">",215,2,"w") if pos==0: draw_string(" Home puis OK pour quitter ",5,2,"b") if mode_geant: jeu_mode_geant(Geant) else: jeu(image) if pos==0: break while keydown(KEY_EXE) or keydown(KEY_OK):1 while not (keydown(KEY_EXE) or keydown(KEY_OK)):1