tkinter_hanoi.py

# https://www.sololearn.com/Discuss/1745310/which-one-is-better-kivy-or-tkinter-for-gui-in-python-why
# https://code.sololearn.com/c5xdEo7f46pr/?ref=app#py
# by Rick Shiffman

#!/usr/bin/python
#
# *** Your system must have TK wigits (garphics)  installed ***
#
# Animated Towers of Hanoi using Tk with optional bitmap file in
# background.
# Modified by Richard Shiffman, rrs0@earthlink.net on 02-17-2018
#
# Usage: hanoi3.py [n [bitmapfile] [&]]
#
# n is the number of pieces to animate; default is 4, maximum 15.
#
# The bitmap file can be any X11 bitmap file (look in
# /usr/include/X11/bitmaps for samples); it is displayed as the
# background of the animation.  Default is no bitmap.

# This uses Steen Lumholt's Tk interface
from tkinter import *

# define 'c's printf function
def printf( format, *vals ):
	print( format % vals )

#define C's sprintf functgion
def sprintf( format, *vals ):
	return( format % vals )


#wrapper for hanoi
def callhanoi(n, a, b, c, report, canvas):
	#canvas.winfo_toplevel().title('Towers of Hanoi from '+str(a)+' to '+str(b))
	outstr = sprintf( "Towers of Hanoi from %d to %d", a, b)
	canvas.winfo_toplevel().title( outstr )
	hanoi(n, a, b, c, report)

# Basic Towers-of-Hanoi algorithm: move n pieces from a to b, using c
# as temporary storage.  For each move, call report()
# Note: there are (2**n)-1 moves for n pieces and
# the ring number is also the ring size.
def hanoi(n, a, b, c, report):
	if n <= 0: return
	hanoi(n-1, a, c, b, report)	# move n-1 rings from peg a to peg c
	report(n, a, b)				# move the nth ring from peg a to peg b
	hanoi(n-1, c, b, a, report)	# move n-1 rings from peg c to peg b


# The graphical interface
class Tkhanoi:

	# Create our objects
	def __init__(self, n, bitmap = None):
		self.n = n
		self.tk = tk = Tk()
		self.canvas = c = Canvas(tk)
		c.pack()
		c.winfo_toplevel().title('Towers of Hanoi')
		width, height = tk.getint(c['width']), tk.getint(c['height'])

		# Add background bitmap
		if bitmap:
			self.bitmap = c.create_bitmap(width/2, height/2,
						      bitmap=bitmap,
						      foreground='blue')

		# Generate pegs
		pegwidth = 10
		pegheight = height/2
		pegdist = width/3
		x1, y1 = (pegdist-pegwidth)/2, height*1/3
		x2, y2 = x1+pegwidth, y1+pegheight
		self.pegs = []
		p = c.create_rectangle(x1, y1, x2, y2, fill='black')
		self.pegs.append(p)
		x1, x2 = x1+pegdist, x2+pegdist
		p = c.create_rectangle(x1, y1, x2, y2, fill='black')
		self.pegs.append(p)
		x1, x2 = x1+pegdist, x2+pegdist
		p = c.create_rectangle(x1, y1, x2, y2, fill='black')
		self.pegs.append(p)
		self.tk.update()

		# Generate pieces
		pieceheight = pegheight/16
		maxpiecewidth = pegdist*2/3
		minpiecewidth = 2*pegwidth
		self.pegstate = [[], [], []]
		self.pieces = {}
		x1, y1 = (pegdist-maxpiecewidth)/2, y2-pieceheight-2
		x2, y2 = x1+maxpiecewidth, y1+pieceheight
		dx = (maxpiecewidth-minpiecewidth) / (2*max(1, n-1))
		for i in range(n, 0, -1):
			p = c.create_rectangle(x1, y1, x2, y2, fill='red')
			self.pieces[i] = p
			self.pegstate[0].append(i)
			x1, x2 = x1 + dx, x2-dx
			y1, y2 = y1 - pieceheight-2, y2-pieceheight-2
			self.tk.update()
			self.tk.after(25)


	# Run -- now returns
	def run(self):
		while 1:
			# do a complete towers of hanoi
			callhanoi(self.n, 0, 1, 2, self.report, self.canvas)
			print("\07")
			# add 2 sec delay after 1 complete call to hanoi
			self.tk.after(2025)
			callhanoi(self.n, 1, 2, 0, self.report, self.canvas)
			print("\07")
			# add 2 sec delay
			self.tk.after(2025)
			callhanoi(self.n, 2, 0, 1, self.report, self.canvas)
			print("\07")
			# add 2 sec delay
			self.tk.after(2025)
			callhanoi(self.n, 0, 2, 1, self.report, self.canvas)
			print("\07")
			# add 2 sec delay
			self.tk.after(2025)
			callhanoi(self.n, 2, 1, 0, self.report, self.canvas)
			print("\07")
			# add 2 sec delay
			self.tk.after(2025)
			callhanoi(self.n, 1, 0, 2, self.report, self.canvas)
			print("\07")
			print("\07")
			# add 5 sec delay before ending
			self.tk.after(5025)
			break				#comment out break to run forever
			#self.quit()

	# Reporting callback for the actual hanoi function
	def report(self, i, a, b):
		if self.pegstate[a][-1] != i: raise RuntimeError # Assertion
		del self.pegstate[a][-1]
		p = self.pieces[i]
		c = self.canvas

		# Lift the piece above peg a
		ax1, ay1, ax2, ay2 = c.bbox(self.pegs[a])
		while 1:
			x1, y1, x2, y2 = c.bbox(p)
			if y2 < ay1: break
			c.move(p, 0, -1)
			self.tk.update()

		# Move it towards peg b
		bx1, by1, bx2, by2 = c.bbox(self.pegs[b])
		newcenter = (bx1+bx2)/2
		while 1:
			x1, y1, x2, y2 = c.bbox(p)
			center = (x1+x2)/2
			if center == newcenter: break
			if center > newcenter: c.move(p, -1, 0)
			else: c.move(p, 1, 0)
			self.tk.update()

		# Move it down on top of the previous piece
		pieceheight = y2-y1
		newbottom = by2 - pieceheight*len(self.pegstate[b]) - 2
		while 1:
			x1, y1, x2, y2 = c.bbox(p)
			if y2 >= newbottom: break
			c.move(p, 0, 1)
			self.tk.update()

		# Update peg state
		self.pegstate[b].append(i)


# Main program
def main():
	import sys, string

	# First argument is number of pieces, default 4
	if sys.argv[1:]:
		n = string.atoi(sys.argv[1])
	else:
		n = 4

	# Second argument is bitmap file, default none
	if sys.argv[2:]:
		bitmap = sys.argv[2]
		# Reverse meaning of leading '@' compared to Tk
		if bitmap[0] == '@': bitmap = bitmap[1:]
		else: bitmap = '@' + bitmap
	else:
		bitmap = None

	# Create the graphical objects...
	h = Tkhanoi(n, bitmap)

	# ...and run!
	h.run()


# Call main when run as script
if __name__ == '__main__':
	main()