15-Puzzle mit Tkinter

Code-Stücke können hier veröffentlicht werden.
mawe
Python-Forum Veteran
Beiträge: 1209
Registriert: Montag 29. September 2003, 17:18
Wohnort: Purkersdorf (bei Wien [Austria])

15-Puzzle mit Tkinter

Beitragvon mawe » Dienstag 8. Februar 2005, 17:59

Hi!

Kleine Spielerei für zwischendurch (auf Wunsch von Francesco :)):

Code: Alles auswählen

from Tkinter import *
import random

def click(i):
    brow = int(buttons[i].grid_info()["row"])
    bcol = int(buttons[i].grid_info()["column"])
    lrow = int(empty.grid_info()["row"])
    lcol = int(empty.grid_info()["column"])
    if (abs(brow-lrow) == 1 and abs(bcol-lcol) == 0) or \
            (abs(brow-lrow) == 0 and abs(bcol-lcol) == 1):
        buttons[i].grid_configure(row=lrow,column=lcol)
        empty.grid_configure(row=brow,column=bcol)

root = Tk()

numbers = range(1,16)
random.shuffle(numbers)
buttons = []
i = 0
for row in range(4):
    for column in range(4):
        buttons.append(
            Button(
                text=numbers[i],
                width=1,
                command=lambda x = i: click(x)))
        buttons[-1].grid(row=row,column=column,sticky=W+E)
        i += 1
        if i == 15: break
empty = Label()
empty.grid(row=3,column=3)

root.mainloop()

Um was gehts: Durch anklicken kann man die Buttons auf das leere Feld verschieben, wenns genau daneben/darüber/darunter liegt. Das macht man so lange bis die Zahlen in der Richtigen Reihenfolge sind. (das ist nur ein schneller Hack, es wird also nicht geprüft ob das Ziel schon erreicht ist. Das müsst ihr selbst nachsehen :wink:).
Viel Spaß!

UPDATE: 16 kann jetzt nicht mehr vorkommen (danke wuf)

Gruß, mawe
Zuletzt geändert von mawe am Freitag 11. Februar 2005, 07:04, insgesamt 1-mal geändert.
Benutzeravatar
Leonidas
Administrator
Beiträge: 16023
Registriert: Freitag 20. Juni 2003, 16:30
Kontaktdaten:

Beitragvon Leonidas » Dienstag 8. Februar 2005, 19:20

Böse, mawe, jetzt kann ich gar nicht mehr aufhören, bis ich nicht fertig bin. Und das kann noch dauern, bei meinem Talent.
My god, it's full of CARs! | Leonidasvoice vs Modvoice
Francesco
User
Beiträge: 824
Registriert: Mittwoch 1. Dezember 2004, 12:35
Wohnort: Upper Austria

Beitragvon Francesco » Mittwoch 9. Februar 2005, 13:40

Danke Mawe,

ich dachte nur, ich hätte dieses Spiel (mit primitiver Grafik), hier
einmal gesehen, bin mir aber nicht mehr sicher.
Benutzeravatar
Leonidas
Administrator
Beiträge: 16023
Registriert: Freitag 20. Juni 2003, 16:30
Kontaktdaten:

Beitragvon Leonidas » Mittwoch 9. Februar 2005, 16:11

Francesco hat geschrieben:ich dachte nur, ich hätte dieses Spiel (mit primitiver Grafik), hier einmal gesehen, bin mir aber nicht mehr sicher.

Wer braucht schon Grafik wenn es doch auch Buttons gibt :)
My god, it's full of CARs! | Leonidasvoice vs Modvoice
Benutzeravatar
wuf
User
Beiträge: 1408
Registriert: Sonntag 8. Juni 2003, 09:50

Beitragvon wuf » Freitag 11. Februar 2005, 01:15

Hallo Mawe

Bei Deinem Spielchen erscheint manchmal
die Nummer 16 und z.B. fehlt dann die Nummer 3.

Die Mischmethode nur mit random.shuffle(x)
hinterlässt manchmal auch unlösbare Stein-
Konstellationen.

Gruss wuf :wink:
Take it easy Mates!
mawe
Python-Forum Veteran
Beiträge: 1209
Registriert: Montag 29. September 2003, 17:18
Wohnort: Purkersdorf (bei Wien [Austria])

Beitragvon mawe » Freitag 11. Februar 2005, 07:09

Hi wuf!

wuf hat geschrieben:Bei Deinem Spielchen erscheint manchmal
die Nummer 16 und z.B. fehlt dann die Nummer 3.

Danke für den Hinweis. Ich glaube das Problem hab ich gelöst (jedenfalls hoff ich das, es is noch ziemlich früh ... :) )

wuf hat geschrieben:Die Mischmethode nur mit random.shuffle(x)
hinterlässt manchmal auch unlösbare Stein-
Konstellationen.

Woran erkennt man das?

Gruß, mawe
Benutzeravatar
wuf
User
Beiträge: 1408
Registriert: Sonntag 8. Juni 2003, 09:50

Beitragvon wuf » Dienstag 15. Februar 2005, 00:54

Hi Mawe

Ich Habe festgestellt, wenn nur die Liste mit
allen Nummern mit shuffle() gemischt wird kann
es vorkommen, dass es unmöglich ist die untersten
zwei Reihen 9..12 und 13..15 der Matrix in der
richtigen Reihenfolge ein zuordnen.

Dieses Spiel war früher normalerweise in einem
Plastikrahmen verfügbar. Bevor man ein neues
Spiel startete mussten die Nummern-Steine durch
Verschieben von Hand gemischt werden. Da die
Steine nicht aus dem Rahmen genommen werden
konnten entstand somit auch keine unlösbare
Situation.

Mein Lösungsansatz für das Mischen der Nummern-
Steine ist folgender:

Man schaut immer, welche Nummern-Steine um das
leere Feld verfügbar sind. Dies können 2, 3 oder
oder 4 Steine sein je nach Position des leeren
Feldes. (z.B in einer Ecke, an einem Rand oder
im mittleren Teil der Matrix) Nun wählt man einer
der 2 bis 4 Steine mittels der shuffle-Methode
aus. Ich mache es so, dass die verfügbaren Steine
um das leere Feld in eine Liste übertragen werden,
mische dann dies Liste mittels shuffle(Liste), nehme
das Element[0] der gemischten Liste als die Stein-
nummer die in das leere Feld verschoben wird. Da bei
dieser Prozess nur ein Stein verschoben wird muss
er mittels einer Iteration wiederholt werden. Je
nach Performance Deiner Maschine können dies 500 bis
1000 Durchläufe sein. Diese Art kommt der manuellen
Methode der Mischung durch Verschieben der Steine
am nächsten.

Ich finde Dein Grafischen Lösungsansatz mittels
Buttons und der grid-Methode sehr interessant. Habe
beim Durchschauen Deines Skriptes auch wieder einige
gute Ideen in meine biologische Datenbank übernehmen
können Hi.

Mein grafischer Lösungsansatz des Spieles beruht auf der
Implementierung von Canvas-Objekten und deren verfügbaren
Canvas-Methoden.

OK Mawe, hoffe ich habe Dir einiges offenbaren können.
Es gibt sicher noch andere Methoden dieses Mischen zu
realisieren. Viel Spass beim Programmieren. Ich habe
mit Python die richtige Sprache gefunden um meine Ideen
umzusetzen, was mir mit anderen VooDoo-Sprachen Mühe
bereitete Hi.

Gruss :wink:
Take it easy Mates!
mawe
Python-Forum Veteran
Beiträge: 1209
Registriert: Montag 29. September 2003, 17:18
Wohnort: Purkersdorf (bei Wien [Austria])

Beitragvon mawe » Dienstag 15. Februar 2005, 11:29

Hi wuf!

Danke für Deine Antwort. Ich hab mich auch mal schlau gemacht (naja, ich hab's wenigstens versucht), und eine Erklärung gefunden, wo von Parität und so weiter die Rede war. Hm, ich bin so klug wie vorher :?

Ich werde mich mal näher mit Deiner Mischmethode beschäftigen :wink:

wuf hat geschrieben:Mein grafischer Lösungsansatz des Spieles beruht auf der
Implementierung von Canvas-Objekten und deren verfügbaren
Canvas-Methoden.

Herzeigen!

Gruß, mawe
Benutzeravatar
wuf
User
Beiträge: 1408
Registriert: Sonntag 8. Juni 2003, 09:50

Beitragvon wuf » Dienstag 15. Februar 2005, 23:33

Hi mawe!

Hier ist das gewünschte Python-Programm-Skrip,
mit meinem grafischen Lösungsansatz. Die Spiel-
fläche realisierte ich explizit nur mit Tkinter-
Canvas-Objekten. Die Programmiermethode bei
diesem Prototypen basiert noch nicht auf OOP.

Das Programm ist noch nicht meine endgültige
Variante des ganzen Matrix-Spiels. Es kann nat-
ürlich noch mit diversen features erweitert werden.
Aber es lässt schon mit sich spielen Hi.

Code: Alles auswählen

#!/usr/bin/env python
# -*- coding: UTF-8 -*-

""" Skriptname    : fwsMatrixGame-05.py
    Version       : 1.05
    Autor         : Fritz Wüst
    Copyright     : wuest59@dial.centralnet.ch
    Erstellt      : 13.12.2004
    Geändert      : 15.12.2004
    Lizenz        : GNU/GPL
    Entwicklungs- : OS       :SuSE91
    Plattform       Editor   :KWrite
                    Debugger :Bash-Shell
                    Sprache  :Python 2.3.3
                    GUI      :Tkinter
   
    Funktion      : Matrix-Game

                  ** Spielregel **
                  Die Game-Boxen (Rechtecke mit Ziffern) müssen mit
                  aufsteigender Nummernfolge horizontal aneinander
                  gereiht in möglichst kurzer Zeit und mit möglichst
                  wenig Bewegungen platziert werden. Das Matrix-Feld
                  unten rechts bleibt am Ende des Spiels leer, so wie
                  es sich vor einem Spielbeginn präsentiert!

                  ** Verschieben der Game-Boxen **
                  Durch Anklicken einer der um das leere Matrix-Feld
                  platzierten Game-Boxen, mit der linken Maustaste,
                  verschiebt sich diese automatisch aufs leere Matrix-Feld.
                  Es können auch mehrere Game-Boxen gleichzeitig horizontal
                  oder vertikal verschoben werden indem eine vom leeren
                  Matrix-Feld entfernte Game-Box, welche in der gleichen
                  Reihe bzw. Kolonne liegt, angeklickt wird. Diese Aktion
                  bewertet das Spiel nur als eine Bewegung.

                  ** Schwierigkeitsgrad **
                  Kann mit setzen höherer Werte für Variable 'gridsperrow'
                  erreicht werden.
                 
                  ** Mögliche Matrix-Abmessungen **
                  Matrixen von 3x3 bis 8x8 sind möglich.
"""

from     Tkinter   import*
from     time      import time
from     random    import shuffle

def GameTimer():
   global starttime,runflag
   #~~ Timer-Aktualisierungintervall
   if runflag == 1 and startflag == 1:
      timervalue['text']= ('%5.1f') % (time()-starttime)

   platform.after(reptime,GameTimer)

def ChangeBoxEnter(event):
   #~~ Ändert Kursor-Symbol von Pfeil in Hand um.
   cursor = platform['cursor']
   platform['cursor'] = 'hand1'
   
def ChangeBoxLeave(event):
   #~~ Ändert Kursor-Symbol von Hand in Pfeil um.
   platform['cursor'] = root['cursor']

def MoveBox(event=None,gamebox=None):
   #~~ Verschiebt die selektierte Game-Box
   #   auf die leere Grid-Box
   global movecount,shuffleflag,runflag,startflag,starttime
   
   if not(runflag ^ shuffleflag):
      return
      
   if startflag == 0 and event != None:
      startflag = 1
      starttime = time()
      timervalue['text']= ('%d') % (time()-starttime)
      butstart['text'] = 'Spiel läuft!'
      butstart.update_idletasks()
         
      
   #~~ Suche die leere Grid-BoxGameTimer()
   emptygridbox = FindEmptyGridBox()
   
   #~~ Koordinaten der leeren Grid-Box
   x1e,y1e,x2e,y2e = platform.bbox(emptygridbox)
   
   #~~ Koordinaten der aktivierten Game-Box14
   x1s,y1s,x2s,y2s = platform.bbox(gamebox)

   if y1e == y1s:
      #~~ Horizontalverschiebung der Game-Box
      if (x1e - x1s) >= 0:
         boxlist = list(platform.find_enclosed(x1s,y1s,x1e,y2s))
         boxlist.reverse()
         for box in boxlist:
            if box > gridboxes and box < 2*gridboxes:
               #~~ Verschiebe die Game-Box nach rechts
               platform.move(box,gridwidth,0)
               #~~ Verschiebe die Game-Box Ziffer nach rechts
               platform.move(box+gridboxes-1,gridwidth,0)
         movecount += 1
         
      if (x1e - x1s) < 0:
         boxlist = list(platform.find_enclosed(x2s,y1s,x2e,y2s))
         for box in boxlist:
            if box > gridboxes and box < 2*gridboxes:
               #~~ Verschiebe die Game-Box nach links
               platform.move(box,-gridwidth,0)
               #~~ Verschiebe die Game-Box Ziffer nach links
               platform.move(box+gridboxes-1,-gridwidth,0)
         movecount += 1
      
   if x1e == x1s:
      #~~ Vertikalverschiebung der Game-Box
      if (y1e - y1s) >= 0:
         boxlist = list(platform.find_enclosed(x1s,y1s,x2s,y1e))
         for box in boxlist:
            if box > gridboxes and box < 2*gridboxes:
               #~~ Verschiebe die Game-Box nach unten
               platform.move(box,0,gridwidth)
               #~~ Verschiebe die Game-Box Ziffer nach unten
               platform.move(box+gridboxes-1,0,gridwidth)
         movecount += 1
         
      if (y1e - y1s) < 0:
         boxlist = list(platform.find_enclosed(x1s,y2s,x2s,y2e))
         boxlist.reverse()
         for box in boxlist:
            if box > gridboxes and box < 2*gridboxes:
               #~~ Verschiebe die Game-Box nach oben
               platform.move(box,0,-gridwidth)
               #~~ Verschiebe die Game-Box Ziffer nach oben
               platform.move(box+gridboxes-1,0,-gridwidth)
         movecount += 1

   if shuffleflag == 0:
      movevalue['text']= str(movecount)
      #~~ Kontrolle ob das Spiel erfolgreich beendet wurde
      CheckGame()

def FindEmptyGridBox():
   #~~ Finde die unbelegte Grid-Box
   for gridbox in xrange(1,gridboxes+1):
      #~~ Lade Koordinaten der Grid-Box
      x1,y1,x2,y2 = platform.bbox(gridbox)
      #~~ Lade die Objektnummern der Canvasobjekte,welche
      #   sich in der Grid-Box befinden
      gridboxstack = platform.find_overlapping(x1,y1,x2,y2)
      
      #~~ Suche der leeren Grid-Box
      if len(gridboxstack) == 1:
         #~~ Die unbelegte Gridbox wurde gefunden!
#          x11,y11,x22,y22 = platform.bbox(gridboxstack[0])
         return gridboxstack[0]
         
def CheckGame():
   #~~ Kontrolle ob sich alle Game-Boxen auf den zugehörigen
   #   Grid-Boxen befinden
   global runflag
   
   gamewonflag = 1
   for gridbox in xrange(1,gridboxes+1):
      x1,y1,x2,y2 = platform.bbox(gridbox)
      gridboxstack = platform.find_overlapping(x1,y1,x2,y2)
      if len(gridboxstack) == 1:
         #~~ Dies war die unbelegte Grid-Box
         continue   
      if gridboxstack[0] != gridboxstack[1]-gridboxes:
         #~~ Es liegt eine Falschbelegung vor
         gamewonflag = 0
         break
         
   if gamewonflag == 1:
      runflag   = 0
      startflag = 0
      butstart['text'] = 'Starte neues Spiel'
      butstart['fg']   = 'gray40'
      butstart.update_idletasks()
      wondisplay['fg'] ='salmon2'
      print 'Das Matrix-Spiel wurde erfolgreich beendet!'

def RealShuffle(event=None):
   #~~ Die Game-Boxen werden wie von Hand durch verschieben gemischt.
   #   Auf diese Art wird verhindert, dass eine unlösbare Konstellation
   #   der Game-Boxen entstehen kann
   #   Die Mischtiefe wird über die Konstante SHUFFLE_DEPTH bestimmt.

   global starttime,runflag,movecount,shuffleflag,SHUFFLE_DEPTH,shufftimecnt,TimerObj
   global startflag
   
   #~~ Verhindert das klebenbleiben der Startschaltfläche
   butstart.update_idletasks()
   butstart['text'] = 'Moment ich mische!'
   butstart['fg'] = 'red'
   #butstart['state'] = DISABLED
   
   wondisplay['fg'] ='gray'
   
   runflag            = 0
   startflag          = 0
   shuffleflag        = 1
   timervalue['text'] = '0'
   movevalue['text']  = '0'
   root.update_idletasks()
   
   for iteration in xrange(SHUFFLE_DEPTH):
      Shuffle()
      
   shuffleflag  =  0
   
   runflag   = 1
   movecount = 0
   movevalue['text'] = str(movecount)
   
   butstart['state'] = NORMAL
   butstart['text']  = 'Spiel ist bereit!'
   butstart['fg']    = 'darkgreen'
   butstart.update_idletasks()

def Shuffle():
   #~~ Mischprozess
   global gridwidth
   
   enclosed   = ()
   liste      = []
   neighbours = []
   
   emptygridbox = FindEmptyGridBox()
   x11,y11,x22,y22 = platform.bbox(emptygridbox)
   enclosed += platform.find_enclosed(x11-gridwidth,y11,x22,y22)
   enclosed += platform.find_enclosed(x11,y11-gridwidth,x22,y22)
   enclosed += platform.find_enclosed(x11,y11,x22+gridwidth,y22)
   enclosed += platform.find_enclosed(x11,y11,x22,y22+gridwidth)
   liste = list(enclosed)
   liste.sort()
   
   for item in liste:
      #~~ Sucht die benachbarten Game-Boxen
      #   um die leere Gridbox
      if item == emptygridbox:
         #~~ Objek ist die leere Grid-Box
         continue
      if item <= gridboxes:
         #~~ Objektnummer ist keine Grid-Box
         continue
      if item >= (2*gridboxes):
         #~~ Objektnummer ist keine Grid-Box
         continue
      neighbours.append(item)
      
   #~~ Mische die gefundenen benachbarten Game-Boxen
   shuffle(neighbours)
   #~~ Verschiebe eine Game-Box
   MoveBox(gamebox=neighbours[0])

#**********************************************
#* Matrix-Game Startup
#**********************************************
if __name__ == "__main__":
   root = Tk()
      
   gridsperrow   = 5    # Anzahl Spiel-Felder auf einer Reihe min.3 max.8
   gridwidth     = 80   # Seitenlänge eines Matrix-Feldes (nur gerade Zahlen!)
   reptime       = 100  # Aktualisierung der Zeitmessung (ms)
   SHUFFLE_DEPTH = 800  # Anzahl Iterationen zum durchmischen der Game-Boxen
   COLOR_GAMEBOX = 'steelblue3'
   COLOR_MAINFRM = 'gray'
   COLOR_GAMEFRM = 'darkgreen'

   FONT_GAMEBOX  = ('Utopia', 30, 'bold')
   FONT_VALUE    = ('Helvetica', 15, 'normal')

   sequence      = []
   xptr          = 0
   yptr          = 0
   movecount     = 0
   startflag     = 0
   runflag       = 0
   shuffleflag   = 0
   
   starttime     = time()
   startflag     = 0
   
   #~~ Begrenzt Matrixgrösse
   if gridsperrow > 8:
      gridsperrow = 8
   if gridsperrow < 3:
      gridsperrow = 3
   gridboxes     = gridsperrow * gridsperrow
   
   gameboxwidth  = gridwidth-2
   
   root.title('Matrix-Spiel ' + str(gridsperrow) +'x' + str(gridsperrow))
   
   #~~ Liste für Game-Boxen Ziffern#
   for number in xrange(1,gridboxes):
      sequence.append(number)
      
   #~~ Anzeigerahmen
   gameframe = Frame(root,
                 relief  = 'raised',
                 bd      = 6,
                 bg      = COLOR_MAINFRM,
#                 highlightbackground ='black',
                 highlightthickness  = 1,
                 )
   gameframe.pack(fill=BOTH,expand=YES)
   
   #~~ Rahmen für Daten-Ausgabe
   timerframe = Frame(gameframe,
                  bg = gameframe['bg'],
                  bd = 2,
                  )
   timerframe.pack(side=TOP,fill=X,padx=5,pady=5)
   
   #~~ Label für die Zeitmessung
   timerdisplay = Label(timerframe,
                   text   = 'Zeitmessung (sek): ',
                   width  = 17,
                   bg     = 'gray80',
                   fg     = 'gray40',
                   font   = FONT_VALUE,
                   anchor = E,
                   )
   timerdisplay.grid(row=0,column=0,pady=4)
   
   #~~ Ausgabe der Zeitmessung
   timervalue = Label(timerframe,
                   text   = '0',
                   width  = 8,
                   bg     = 'gray35',
                   fg     = 'white',
                   font   = FONT_VALUE,
                   )
   timervalue.grid(row=0,column=1,pady=4)
   
   #~~ Label für die Anzahl Bewegungen
   movedisplay = Label(timerframe,
                  text    ='Bewegungen: ',
                  width   = 17,
                  bg      = 'gray80',
                  fg      = 'gray40',
                  font    = FONT_VALUE,
                  anchor  = E,
                  )
   movedisplay.grid(row=1,column=0,pady=4)
   
   #~~ Ausgabe der Bewegungen
   movevalue = Label(timerframe,
                   text    = '0',
                   width   = 8,
                   bg      = 'gray35',
                   fg      = 'white',
                   font    = FONT_VALUE,
                   )
   movevalue.grid(row=1,column=1,pady=4)

   #~~ Anzeige für OK
   wondisplay = Label(timerframe,
                  text    = 'OK !',
                  width   = 4,
                  bg      = 'gray',
                  fg      = 'salmon2',
                  font    = FONT_GAMEBOX,
                  anchor  = CENTER,
                  )
   wondisplay.grid(row=0,rowspan=2,column=2,sticky='we',padx=10)

   #~~ Slogan
   sloglabel = Label(gameframe,
                  bg=gameframe['bg'],
                  fg='darkgreen',
                  text='Matrix-Game 1.05\n(powered by Python & Tkinter)',
                  width=20,
                  pady=2,
                  )
   sloglabel.pack(side=TOP,fill=X,pady=5)
   
   #~~ Canvas für die Aufnahme der Game-Boxen
   platform = Canvas(gameframe,
                 bg=COLOR_GAMEFRM,
                 relief='groove',
                 bd=8,
                 highlightthickness=0,
                 )
   platform.pack(padx=20,pady=5)
   
   platform['width']  = gridwidth * gridsperrow + 3
   platform['height'] = gridwidth * gridsperrow + 3
   
   #~~ Rahmen für Schaltflächen
   buttonframe = Frame(gameframe,
                  bg=gameframe['bg']
                  )
   buttonframe.pack(side=BOTTOM,fill=X,padx=5,pady=8)
   
   butstart = Button(buttonframe,
                 bg='gray85',
                 fg='gray40',
                 text='Starte neues Spiel',
                 command=RealShuffle,
                 font=FONT_VALUE,
                 highlightthickness=0,
                 width = 20,
                 cursor  = 'hand1',
                 )
   butstart.grid(row=0, column=0, padx=10)
      
   butend   = Button(buttonframe,
                 bg='gray85',
                 fg='gray40',
                 text='Beenden',
                 command=root.quit,
                 font=FONT_VALUE,
                 highlightthickness=0,
                 width = 10,
                 cursor  = 'hand1',
                 )
   butend.grid(row=0, column=1, padx=10)
   
   root.update_idletasks()
   
   #~~ Zentriert das Root-Fenster
   width,height,left,top  = tuple(map(int,root.winfo_geometry().replace("x","+").split("+")))
   xpos   = (root.winfo_screenwidth()-width)/2
   ypos   = (root.winfo_screenheight()-height)/2
   root.wm_geometry("+%d+%d" % (xpos,ypos))
   root.update_idletasks()

   #~~ Erzeuge die fixen Grid-Boxen
   gridtab = gridsperrow-1
   for index in xrange(gridboxes):
      x1 = xptr+10
      y1 = yptr+10
            
      gridbox = platform.create_rectangle(x1,
                                 y1,
                                 x1+gameboxwidth,
                                 y1+gameboxwidth,
                                 fill='gray',
                                 stipple='gray25',
                                 )
      
      if index == gridtab:
         gridtab += gridsperrow
         xptr = 0
         yptr += gridwidth
      else:
         xptr += gridwidth
   
   #~~ Erzeugt die beweglichen Game-Boxen
   #   Eine Box weniger als die maximale Anzahl Grid-Boxen
   for boxobj in platform.find_all():
      x1,y1,x2,y2 = platform.bbox(boxobj)
      
      gamebox = platform.create_rectangle(x1+1,
                                 y1+1,
                                 x1+1+gameboxwidth,
                                 y1+1+gameboxwidth,
                                 fill=COLOR_GAMEBOX,
                                 )
      platform.tag_bind(gamebox,"<Button-1>",lambda e,obj=gamebox:MoveBox(e,obj))
      platform.tag_bind(gamebox,"<Enter>"   ,ChangeBoxEnter)
      platform.tag_bind(gamebox,"<Leave>"   ,ChangeBoxLeave)

      if boxobj == gridboxes-1:
         break
                            
   #~~ Nummeriert die Game-Boxen
   for gridobj in xrange(1,gridboxes):
      x1,y1,x2,y2 = platform.bbox(gridobj)
      numberobj = platform.create_text(x1+(gridwidth/2),
                               y1+(gridwidth/2),
                               text=str(gridobj),
                               font=FONT_GAMEBOX,
                               fill='white',
                              )
      platform.tag_bind(numberobj,"<Button-1>",lambda e,obj=numberobj-(gridboxes-1):MoveBox(e,obj))
      platform.tag_bind(numberobj,"<Enter>"   ,ChangeBoxEnter)
      platform.tag_bind(numberobj,"<Leave>"   ,ChangeBoxLeave)
      
   GameTimer()
   
   root = mainloop()


Gruss wuf :wink:
Take it easy Mates!
Benutzeravatar
Joghurt
User
Beiträge: 877
Registriert: Dienstag 15. Februar 2005, 15:07

Beitragvon Joghurt » Samstag 19. Februar 2005, 04:23

mawe hat geschrieben:Danke für Deine Antwort. Ich hab mich auch mal schlau gemacht (naja, ich hab's wenigstens versucht), und eine Erklärung gefunden, wo von Parität und so weiter die Rede war. Hm, ich bin so klug wie vorher :?
Ich habe auch mal nachgeforscht, und nach dieser Seite müsste es wie folgt gehen:

Code: Alles auswählen

def inversions(list):
    inv = 0
    prev = 0
    for i in list:
        if i<prev: inv += 1
        prev = i
    return inv

[...]
numbers = range(1,16)
while 1:
  random.shuffle(numbers)
  if inversions(numbers)%2 == 0: break

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder