15-Puzzle mit Tkinter

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

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.
Leonidas
Administrator
Beiträge: 16024
Registriert: Freitag 20. Juni 2003, 16:30
Kontaktdaten:

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

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.
Leonidas
Administrator
Beiträge: 16024
Registriert: Freitag 20. Juni 2003, 16:30
Kontaktdaten:

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: 1477
Registriert: Sonntag 8. Juni 2003, 09:50

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])

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: 1477
Registriert: Sonntag 8. Juni 2003, 09:50

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])

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: 1477
Registriert: Sonntag 8. Juni 2003, 09:50

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!
Joghurt
User
Beiträge: 877
Registriert: Dienstag 15. Februar 2005, 15:07

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
Antworten