class HanoiEngine:
"""Play the Hanoi-game on a given TurtleScreen."""
def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None):
"""Sets Canvas to play on as well as default values for
number of discs and animation-speed.
moveCntDisplay is a function with 1 parameter, which communicates
the count of the actual move to the GUI containing the
Hanoi-engine-canvas."""
self.ts = canvas
self.ts.tracer(False)
# setup scene
self.designer = RawTurtle(canvas, shape="square")
self.designer.penup()
self.designer.shapesize(0.5, 21)
self.designer.goto(0,-80); self.designer.stamp()
self.designer.shapesize(7, 0.5)
self.designer.fillcolor('darkgreen')
for x in -140, 0, 140:
self.designer.goto(x,-5); self.designer.stamp()
self.nrOfDiscs = nrOfDiscs
self.speed = speed
self.moveDisplay = moveCntDisplay
self.running = False
self.moveCnt = 0
self.discs = [Disc(canvas) for i in range(10)]
self.towerA = Tower(-140)
self.towerB = Tower(0)
self.towerC = Tower(140)
self.ts.tracer(True)
def setspeed(self):
for disc in self.discs: disc.speed(self.speed)
def move(self, src_tower, dest_tower):
"""move uppermost disc of source tower to top of destination
tower."""
dest_tower.push(src_tower.pop())
self.moveCnt += 1
self.moveDisplay(self.moveCnt)
def reset(self):
"""Setup of (a new) game."""
self.ts.tracer(False)
self.moveCnt = 0
self.moveDisplay(0)
for t in self.towerA, self.towerB, self.towerC:
while t != []: t.pop(200)
for k in range(self.nrOfDiscs-1,-1,-1):
self.discs[k].config(k, self.nrOfDiscs)
self.towerA.push(self.discs[k])
self.ts.tracer(True)
def run(self):
"""run game ;-)
return True if game is over, else False"""
self.running = True
ex7.play_hanoi(self, self.nrOfDiscs,
self.towerA, self.towerC, self.towerB)
return True
class HanoiEngine:
"""Play the Hanoi-game on a given TurtleScreen."""
def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None):
"""Sets Canvas to play on as well as default values for
number of discs and animation-speed.
moveCntDisplay is a function with 1 parameter, which communicates
the count of the actual move to the GUI containing the
Hanoi-engine-canvas."""
self.ts = canvas
self.ts.tracer(False)
# setup scene
self.designer = RawTurtle(canvas, shape="square")
self.designer.penup()
self.designer.shapesize(0.5, 21)
self.designer.goto(0,-80); self.designer.stamp()
self.designer.shapesize(7, 0.5)
self.designer.fillcolor('darkgreen')
for x in -140, 0, 140:
self.designer.goto(x,-5); self.designer.stamp()
self.nrOfDiscs = nrOfDiscs
self.speed = speed
self.moveDisplay = moveCntDisplay
self.running = False
self.moveCnt = 0
self.discs = [Disc(canvas) for i in range(10)]
self.towerA = Tower(-140)
self.towerB = Tower(0)
self.towerC = Tower(140)
self.ts.tracer(True)
def setspeed(self):
for disc in self.discs: disc.speed(self.speed)
def move(self, src_tower, dest_tower):
"""move uppermost disc of source tower to top of destination
tower."""
dest_tower.push(src_tower.pop())
self.moveCnt += 1
self.moveDisplay(self.moveCnt)
def reset(self):
"""Setup of (a new) game."""
self.ts.tracer(False)
self.moveCnt = 0
self.moveDisplay(0)
for t in self.towerA, self.towerB, self.towerC:
while t != []: t.pop(200)
for k in range(self.nrOfDiscs-1,-1,-1):
self.discs[k].config(k, self.nrOfDiscs)
self.towerA.push(self.discs[k])
self.ts.tracer(True)
def run(self):
"""run game ;-)
return True if game is over, else False"""
self.running = True
ex7.play_hanoi(self, self.nrOfDiscs,
self.towerA, self.towerC, self.towerB)
return True
def draw_polygon(self, node, screen):
pen = RawTurtle(screen)
pen.speed(0)
pen.hideturtle()
pen.penup()
try:
linecolor = node.attrs['color']
except KeyError:
linecolor = None
try:
fillcolor = node.attrs['fillcolor']
except KeyError:
fillcolor = None
if linecolor is not None:
pen.pencolor(*linecolor)
else:
pen.pencolor(*(0, 0, 0))
polygon = node.data
polygon = [self.translate_coords(screen, x) for x in polygon]
points = to_tups(polygon)
pen.goto(*(points[0]))
pen.pendown()
if fillcolor:
pen.fillcolor(*fillcolor)
pen.pencolor(*fillcolor)
pen.begin_fill()
for point in points[::-1]:
pen.goto(*point)
if fillcolor:
pen.end_fill()
class HanoiEngine:
def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None):
self.ts = canvas
self.ts.tracer(False)
# setup scene
self.designer = RawTurtle(canvas, shape="square")
self.designer.penup()
self.designer.shapesize(0.5, 21)
self.designer.goto(0, -80);
self.designer.stamp()
self.designer.shapesize(7, 0.5)
self.designer.fillcolor('yellow')
for x in -140, 0, 140:
self.designer.goto(x, -5);
self.designer.stamp()
self.nrOfDiscs = nrOfDiscs
self.speed = speed
self.moveDisplay = moveCntDisplay
self.running = False
self.moveCnt = 0
self.discs = [Disc(canvas) for i in range(10)]
self.towerA = Pole(-140)
self.towerB = Pole(0)
self.towerC = Pole(140)
self.ts.tracer(True)
class HanoiEngine:
def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None):
self.ts = canvas
self.ts.tracer(False)
# setup scene
self.designer = RawTurtle(canvas, shape="square")
self.designer.penup()
self.designer.shapesize(0.5, 21)
self.designer.goto(0, -80)
self.designer.stamp()
self.designer.shapesize(7, 0.5)
self.designer.fillcolor('yellow')
for x in -140, 0, 140:
self.designer.goto(x, -5)
self.designer.stamp()
self.nrOfDiscs = nrOfDiscs
self.speed = speed
self.moveDisplay = moveCntDisplay
self.running = False
self.moveCnt = 0
self.discs = [Disc(canvas) for i in range(10)]
self.towerA = Pole(-140)
self.towerB = Pole(0)
self.towerC = Pole(140)
self.ts.tracer(True)
def setspeed(self):
for disc in self.discs:
disc.speed(self.speed)
def hanoi(self, n, src, dest, temp):
if n > 0:
for x in self.hanoi(n - 1, src, temp, dest):
yield None
yield self.move(src, dest)
for x in self.hanoi(n - 1, temp, dest, src):
yield None
def move(self, src_tower, dest_tower):
dest_tower.push(src_tower.pop())
self.moveCnt += 1
self.moveDisplay(self.moveCnt)
def reset(self):
self.ts.tracer(False)
self.moveCnt = 0
self.moveDisplay(0)
for t in self.towerA, self.towerB, self.towerC:
while t != []:
t.pop(200)
for k in range(self.nrOfDiscs - 1, -1, -1):
self.discs[k].config(k, self.nrOfDiscs)
self.towerA.push(self.discs[k])
self.ts.tracer(True)
self.HG = self.hanoi(self.nrOfDiscs, self.towerA, self.towerC,
self.towerB)
def run(self):
self.running = True
try:
while self.running:
result = self.step()
return result # True iff done
except StopIteration: # game over
return True
def step(self):
try:
next(self.HG)
return 2**self.nrOfDiscs - 1 == self.moveCnt
except TclError:
return False
def stop(self):
self.running = False
class HanoiEngine:
"""Play the Hanoi-game on a given TurtleScreen."""
def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None):
"""Sets Canvas to play on as well as default values for
number of discs and animation-speed.
moveCntDisplay is a function with 1 parameter, which communicates
the count of the actual move to the GUI containing the
Hanoi-engine-canvas."""
self.ts = canvas
self.ts.tracer(False)
# setup scene
self.designer = RawTurtle(canvas, shape="square")
self.designer.penup()
self.designer.shapesize(0.5, 21)
self.designer.goto(0, -80)
self.designer.stamp()
self.designer.shapesize(7, 0.5)
self.designer.fillcolor('darkgreen')
for x in -140, 0, 140:
self.designer.goto(x, -5)
self.designer.stamp()
self.nrOfDiscs = nrOfDiscs
self.speed = speed
self.moveDisplay = moveCntDisplay
self.running = False
self.moveCnt = 0
self.discs = [Disc(canvas) for i in range(10)]
self.towerA = Tower(-140)
self.towerB = Tower(0)
self.towerC = Tower(140)
self.ts.tracer(True)
def setspeed(self):
for disc in self.discs:
disc.speed(self.speed)
def hanoi(self, n, src, dest, temp):
"""The classical recursive Towers-Of-Hanoi algorithm,
implemented as a recursive generator, yielding always None
plus an 'important' side effect - the next Hanoi move."""
if n > 0:
for x in self.hanoi(n - 1, src, temp, dest):
yield None
yield self.move(src, dest)
for x in self.hanoi(n - 1, temp, dest, src):
yield None
def move(self, src_tower, dest_tower):
"""move uppermost disc of source tower to top of destination
tower."""
dest_tower.push(src_tower.pop())
self.moveCnt += 1
self.moveDisplay(self.moveCnt)
def reset(self):
"""Setup of (a new) game."""
self.ts.tracer(False)
self.moveCnt = 0
self.moveDisplay(0)
for t in self.towerA, self.towerB, self.towerC:
while t != []:
t.pop(200)
for k in range(self.nrOfDiscs - 1, -1, -1):
self.discs[k].config(k, self.nrOfDiscs)
self.towerA.push(self.discs[k])
self.ts.tracer(True)
self.HG = self.hanoi(self.nrOfDiscs, self.towerA, self.towerC,
self.towerB)
def run(self):
"""run game ;-)
return True if game is over, else False"""
self.running = True
try:
while self.running:
result = self.step()
return result # True iff done
except StopIteration: # game over
return True
def step(self):
"""perform one single step of the game,
returns True if finished, else False"""
try:
next(self.HG)
return 2**self.nrOfDiscs - 1 == self.moveCnt
except TclError:
return False
def stop(self):
""" ;-) """
self.running = False
class HanoiEngine:
def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None):
self.ts = canvas
self.ts.tracer(False)
self.designer = RawTurtle(canvas, shape="square")
self.designer.penup()
self.designer.shapesize(0.5, 21)
self.designer.goto(0,-80); self.designer.stamp()
self.designer.shapesize(7, 0.5)
self.designer.fillcolor('black')
for x in -140, 0, 140:
self.designer.goto(x,-5); self.designer.stamp()
self.nrOfDiscs = nrOfDiscs
self.speed = speed
self.moveDisplay = moveCntDisplay
self.running = False
self.moveCnt = 0
self.discs = [Disc(canvas) for i in range(10)]
self.towerA = Tower(-140)
self.towerB = Tower(0)
self.towerC = Tower(140)
self.ts.tracer(True)
def setspeed(self):
for disc in self.discs: disc.speed(self.speed)
def hanoi(self, n, src, dest, temp):
if n > 0:
for x in self.hanoi(n-1, src, temp, dest): yield None
yield self.move(src, dest)
for x in self.hanoi(n-1, temp, dest, src): yield None
def move(self, src_tower, dest_tower):
dest_tower.push(src_tower.pop())
self.moveCnt += 1
self.moveDisplay(self.moveCnt)
def reset(self):
self.ts.tracer(False)
self.moveCnt = 0
self.moveDisplay(0)
for t in self.towerA, self.towerB, self.towerC:
while t != []: t.pop(200)
for k in range(self.nrOfDiscs-1,-1,-1):
self.discs[k].config(k, self.nrOfDiscs)
self.towerA.push(self.discs[k])
self.ts.tracer(True)
self.HG = self.hanoi(self.nrOfDiscs,
self.towerA, self.towerC, self.towerB)
def run(self):
self.running = True
try:
while self.running:
result = self.step()
return result
except StopIteration:
return True
def step(self):
try:
next(self.HG)
return 2**self.nrOfDiscs-1 == self.moveCnt
except TclError:
return False
def stop(self):
self.running = False
class HanoiEngine:
"""Play the Hanoi-game on a given TurtleScreen."""
def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None):
"""Sets Canvas to play on as well as default values for
number of discs and animation-speed.
moveCntDisplay is a function with 1 parameter, which communicates
the count of the actual move to the GUI containing the
Hanoi-engine-canvas."""
self.ts = canvas
self.ts.tracer(False)
# setup scene
self.designer = RawTurtle(canvas, shape="square")
self.designer.penup()
self.designer.shapesize(0.5, 21)
self.designer.goto(0,-80); self.designer.stamp()
self.designer.shapesize(7, 0.5)
self.designer.fillcolor('darkgreen')
for x in -140, 0, 140:
self.designer.goto(x,-5); self.designer.stamp()
self.nrOfDiscs = nrOfDiscs
self.speed = speed
self.moveDisplay = moveCntDisplay
self.running = False
self.moveCnt = 0
self.discs = [Disc(canvas) for i in range(10)]
self.towerA = Tower(-140)
self.towerB = Tower(0)
self.towerC = Tower(140)
self.ts.tracer(True)
def setspeed(self):
for disc in self.discs: disc.speed(self.speed)
def hanoi(self, n, src, dest, temp):
"""The classical recursive Towers-Of-Hanoi algorithm,
implemented as a recursive generator, yielding always None
plus an 'important' side effect - the next Hanoi move."""
if n > 0:
for x in self.hanoi(n-1, src, temp, dest): yield None
yield self.move(src, dest)
for x in self.hanoi(n-1, temp, dest, src): yield None
def move(self, src_tower, dest_tower):
"""move uppermost disc of source tower to top of destination
tower."""
dest_tower.push(src_tower.pop())
self.moveCnt += 1
self.moveDisplay(self.moveCnt)
def reset(self):
"""Setup of (a new) game."""
self.ts.tracer(False)
self.moveCnt = 0
self.moveDisplay(0)
for t in self.towerA, self.towerB, self.towerC:
while t != []: t.pop(200)
for k in range(self.nrOfDiscs-1,-1,-1):
self.discs[k].config(k, self.nrOfDiscs)
self.towerA.push(self.discs[k])
self.ts.tracer(True)
self.HG = self.hanoi(self.nrOfDiscs,
self.towerA, self.towerC, self.towerB)
def run(self):
"""run game ;-)
return True if game is over, else False"""
self.running = True
try:
while self.running:
result = self.step()
return result # True iff done
except StopIteration: # game over
return True
def step(self):
"""perform one single step of the game,
returns True if finished, else False"""
try:
next(self.HG)
return 2**self.nrOfDiscs-1 == self.moveCnt
except TclError:
return False
def stop(self):
""" ;-) """
self.running = False
class HanoiEngine:
def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None):
self.ts = canvas
self.ts.tracer(False)
# setup scene
self.designer = RawTurtle(canvas, shape="square")
self.designer.penup()
self.designer.shapesize(0.4, 25)
self.designer.goto(0, -81)
self.designer.stamp()
self.designer.shapesize(4, 0.5)
self.designer.fillcolor('Black')
for x in -150, 0, 150:
self.designer.goto(x, -5)
self.designer.stamp()
self.nrOfDiscs = nrOfDiscs
self.speed = speed
self.moveDisplay = moveCntDisplay
self.running = False
self.moveCnt = 0
self.discs = [Disc(canvas) for i in range(10)]
self.towerA = Tower(-150)
self.towerB = Tower(0)
self.towerC = Tower(150)
self.ts.tracer(True)
def setspeed(self):
for disc in self.discs:
disc.speed(self.speed)
def hanoi(self, n, src, dest, temp):
#use of recurssion for movement
if n > 0:
for x in self.hanoi(n - 1, src, temp, dest):
yield None
yield self.move(src, dest)
for x in self.hanoi(n - 1, temp, dest, src):
yield None
def move(self, src_tower, dest_tower):
#movement of upper disks
dest_tower.push(src_tower.pop())
self.moveCnt += 1
self.moveDisplay(self.moveCnt)
def reset(self):
# start a new game
self.ts.tracer(False)
self.moveCnt = 0
self.moveDisplay(0)
for t in self.towerA, self.towerB, self.towerC:
while t != []:
t.pop(200)
for k in range(self.nrOfDiscs - 1, -1, -1):
self.discs[k].config(k, self.nrOfDiscs)
self.towerA.push(self.discs[k])
self.ts.tracer(True)
self.HG = self.hanoi(self.nrOfDiscs, self.towerA, self.towerC,
self.towerB)
def run(self):
#true if game is over else false
self.running = True
try:
while self.running:
result = self.step()
return result # True iff done
except StopIteration: # game over
return True
def step(self):
"""perform one single step of the game,
returns True if finished, else False"""
try:
next(self.HG)
return 2**self.nrOfDiscs - 1 == self.moveCnt
except TclError:
return False
def stop(self):
""" ;-) """
self.running = False
class HanoiEngine:
"""Play the Hanoi-game on a given TurtleScreen."""
def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None):
"""Sets Canvas to play on as well as default values for
number of discs and animation-speed.
moveCntDisplay is a function with 1 parameter, which communicates
the count of the actual move to the GUI containing the
Hanoi-engine-canvas."""
global gameStatus
self.highScoreArray = []
self.combinedArray = []
self.universalArray = []
self.setCanvas = canvas
self.ts = canvas
self.ts.tracer(False)
# setup scene
self.designer = RawTurtle(canvas, shape="square")
self.designer.penup()
self.designer.shapesize(0.5, 21)
self.designer.goto(0, -80)
self.designer.stamp()
self.designer.shapesize(7, 0.5)
self.designer.fillcolor('pink')
for x in -140, 0, 140:
self.designer.goto(x, -5)
self.designer.stamp()
self.nrOfDiscs = nrOfDiscs
self.speed = speed
self.moveDisplay = moveCntDisplay
self.running = False
self.moveCnt = 0
self.winCondition = False
''' elson code '''
gameStatus = "withoutTurtle"
self.currentStatus = "AI"
self.samplemoves = [] # The set of move generate by AI
self.usermoves = [] # The set of move user move
self.finalmoves = [] # The final set of move
self.minmoves = 0
self.totalmoves = 0
self.startsource = Tower(-140)
self.starthelper = Tower(0)
self.starttarget = Tower(140)
self.goaltarget = Tower(140)
self.AISource = Tower(-140)
self.AIHelper = Tower(0)
self.AITarget = Tower(140)
self.goalMoves = []
self.playerMoves = []
''' elson code '''
self.numValue = 0
self.discs = []
self.towerA = Tower(-140)
self.towerB = Tower(0)
self.towerC = Tower(140)
print "A:", self.towerA.size(), "value:", self.towerA.peek()
print "B:", self.towerB.size(), "value:", self.towerB.peek()
print "C:", self.towerC.size(), "value:", self.towerC.peek()
self.ts.tracer(True)
def getGameStatus(self):
return self.gameStatus
#elson code
def savestate(self, stack):
self.newstack = Tower(0)
self.newstack.copyFrom(stack)
return self.newstack
#elson code
# Restore the stack to start state
def startstate(self):
self.towerA.copyFrom(self.startsource)
self.towerB.copyFrom(self.starthelper)
self.towerC.copyFrom(self.starttarget)
#elson code
def moveTower(self, disc, Beg, Aux, End):
global gameStatus
if disc == 1:
self.moveDisk(Beg, End)
if getGameStatus() is "turtle":
self.moveCnt += 1
self.moveDisplay(self.moveCnt)
self.samplemoves.append(self.savestate(self.towerA))
self.samplemoves.append(self.savestate(self.towerB))
self.samplemoves.append(self.savestate(self.towerC))
#print (Beg, Aux, End)
else:
self.moveTower(disc - 1, Beg, End, Aux)
self.moveTower(1, Beg, Aux, End)
self.moveTower(disc - 1, Aux, Beg, End)
'''elson code'''
# Move disk from the src stack to dest stack
def moveDisk(self, frompole, topole):
# print("moving disk from",frompole.gettitle(),"to",topole.gettitle())
#if self.checkvalid(frompole, topole) is True:
#if getGameStatus() is "turtle":
if self.currentStatus is "AI":
self.goalMoves.append(MyMoves(frompole, topole))
else:
self.playerMoves.append(MyMoves(frompole, topole))
self.moveCnt += 1
self.moveDisplay(self.moveCnt)
print("moving disk from ", frompole.peek(), " to ", topole.peek())
topole.push(frompole.pop())
#self.moveCnt += 1
#self.moveDisplay(self.moveCnt)
'''elson code'''
# generate the sample set of solutions
def gensamplemove(self, source, helper, target):
self.moveTower(source.size(), source, helper, target)
'''elson code'''
# Check of the rules of Hanoi
def checkvalid(self, frompole, topole):
if (frompole.size() == 0 or frompole
== topole): # frompole is empty or frompole and topole is same
return False
else:
if (topole.peek() is None or frompole.peek() < topole.peek()
): # topole is empty or from is smaller than to
self.moveDisk(frompole, topole)
self.usermoves.append(self.savestate(self.towerA))
self.usermoves.append(self.savestate(self.towerB))
self.usermoves.append(self.savestate(self.towerC))
self.finalmoves.append(self.savestate(self.towerA))
self.finalmoves.append(self.savestate(self.towerB))
self.finalmoves.append(self.savestate(self.towerC))
return True
elif frompole.peek() > topole.peek():
return False
'''elson code'''
# Conver the string input to the variable of stack
'''def convert(self, word):
if(word == "a"):
return source
elif(word == "b"):
return helper
elif(word == "c"):
return target'''
'''elson code'''
def findmatch(self):
for i in range(len(self.usermoves) - 1, 0, -3):
#print (self.usermoves[i-2], self.usermoves[i-1], self.usermoves[i])
if (i != len(self.usermoves) - 1
): # append the backtrack state, only add after first i loop
self.finalmoves.append(self.usermoves[i - 2])
self.finalmoves.append(self.usermoves[i - 1])
self.finalmoves.append(self.usermoves[i])
for j in range(0, len(self.samplemoves), 3):
#print (self.samplemoves[i-2], self.samplemoves[i-1], self.samplemoves[i])
if (self.usermoves[i - 2].isEqual(self.samplemoves[j]) and
self.usermoves[i - 1].isEqual(self.samplemoves[j + 1])
and self.usermoves[i].isEqual(
self.samplemoves[j + 2])):
index = j
return j
'''elson code'''
def solve(self):
global gameStatus
gameStatus = "turtle"
'''
index = self.findmatch()
for j in range(index+3,len(self.samplemoves),3): # append state after the match
self.finalmoves.append(self.samplemoves[j])
self.finalmoves.append(self.samplemoves[j+1])
self.finalmoves.append(self.samplemoves[j+2])
'''
newArray = []
num = len(self.playerMoves) - 1
for q in range(0, len(self.playerMoves)):
temp = self.playerMoves[q].srcTower
self.playerMoves[q].srcTower = self.playerMoves[q].destTower
self.playerMoves[q].destTower = temp
newArray.append(self.playerMoves[num])
num -= 1
#print len(newArray)
self.speed = 8 % 10
self.setspeed()
for w in range(0, len(newArray)):
#print newArray[w]
self.move(newArray[w].srcTower, newArray[w].destTower)
self.speed = 3 % 10
self.setspeed()
for v in range(0, len(self.goalMoves)):
self.move(self.goalMoves[v].srcTower, self.goalMoves[v].destTower)
del newArray[:]
gameStatus = "turtle"
self.currentStatus = "AI"
return True
def getTowerA(self):
return self.towerA
def getTowerB(self):
return self.towerB
def getTowerC(self):
return self.towerC
def setspeed(self):
for disc in self.discs:
disc.speed(self.speed)
def move(self, src_tower, dest_tower):
"""move uppermost disc of source tower to top of destination
tower."""
self.winCondition = False
dest_tower.push(src_tower.pop())
self.moveCnt += 1
self.moveDisplay(self.moveCnt)
def reset(self):
"""Setup of (a new) game."""
self.ts.tracer(False)
global gameStatus, currentStatus
gameStatus = "turtle"
Hanoi.state = "START"
del self.playerMoves[:]
del self.goalMoves[:]
self.moveCnt = 0
self.moveDisplay(0)
self.resetTowers(self.towerA)
self.resetTowers(self.towerB)
self.resetTowers(self.towerC)
self.numValue = 0
del self.discs[:]
for x in range(self.nrOfDiscs):
self.numValue += 1
self.discs.append(Disc(self.setCanvas, self.numValue))
print self.numValue
for k in range(self.nrOfDiscs - 1, -1, -1):
self.discs[k].config(k, self.nrOfDiscs) #
self.towerA.push(self.discs[k])
gameStatus = "withoutTurtle"
''' elson code '''
self.startsource.copyFrom(self.towerA) # Save the start state
self.starthelper.copyFrom(self.towerB)
self.starttarget.copyFrom(self.towerC)
# Include the start state in sample moves set
self.samplemoves.append(self.startsource)
self.samplemoves.append(self.starthelper)
self.samplemoves.append(self.starttarget)
''' elson code '''
""" AI attempt to solve """
self.gensamplemove(self.towerA, self.towerB, self.towerC)
# Printing for checking sample moves set purpose
# print "Number of element:",len(samplemoves)
# print "Number of minimum steps:",minmoves
# for i in range(0, len(samplemoves), 3):
# printprogess(samplemoves[i], samplemoves[i+1], samplemoves[i+2])
""" Restore start state """
self.startstate()
# Include the start state in user moves set
self.usermoves.append(self.startsource)
self.usermoves.append(self.starthelper)
self.usermoves.append(self.starttarget)
self.finalmoves.append(self.startsource)
self.finalmoves.append(self.starthelper)
self.finalmoves.append(self.starttarget)
gameStatus = "turtle"
self.currentStatus = "user"
#for k in range(self.nrOfDiscs - 1, -1, -1):
# self.discs[k].config(k, self.nrOfDiscs)
# self.towerA.push(self.discs[k])
# self.AISource.push(self.discs[k])
print "A:", self.towerA.size()
print "B:", self.towerB.size()
print "C:", self.towerC.size()
self.ts.tracer(True)
#self.HG = self.hanoi(self.nrOfDiscs,
# self.towerA, self.towerC, self.towerB)
def resetTowers(self, tower):
if tower.size() > 0:
for x in range(0, tower.size()):
tower.pop(200)
def checkWin(self):
if self.towerC.size() is self.nrOfDiscs:
self.winCondition = True
Hanoi.state = "DONE"
return self.winCondition
def storeHighScore(self):
self.highScoreArray.append(WinData(self.nrOfDiscs, self.moveCnt))
for j in range(1, 11):
for i in range(0, len(self.highScoreArray)):
if self.highScoreArray[i].getNumOfDiscs() is j:
self.universalArray.append(self.highScoreArray[i])
if len(self.universalArray) > 0:
self.doSelectionSort(self.universalArray)
self.combinedArray = self.combinedArray + self.universalArray
del self.universalArray[:]
del self.highScoreArray[:]
for w in range(0, len(self.combinedArray)):
self.highScoreArray.append(self.combinedArray[w])
del self.combinedArray[:]
return self.highScoreArray
def doSelectionSort(self, universalArray):
n = len(universalArray)
for fillslot in range(n - 1, 0, -1):
positionOfMax = 0
for location in range(1, fillslot + 1):
if universalArray[location].getNumOfMove(
) > universalArray[positionOfMax].getNumOfMove():
positionOfMax = location
tmp = universalArray[fillslot]
universalArray[fillslot] = universalArray[positionOfMax]
universalArray[positionOfMax] = tmp
def stop(self):
""" ;-) """
self.running = False
def checkIfMoveValid(self, sourceTower, destTower):
if sourceTower.peek() < destTower.peek() or destTower.peek() is None:
#pop from sourceTower and push into destTower
return True
elif sourceTower.peek() > destTower.peek():
#return error message, do not pop from srcTower
return False
WIDTH, HEIGHT = 450, 450
canvas = Canvas(master, width=WIDTH, height=HEIGHT, bg="green")
canvas.pack(ipadx=30)
root = TurtleScreen(canvas)
turtle = RawTurtle(root, visible=False)
root.bgcolor("white")
turtle.color('#F09F13')
turtle.pensize(4)
turtle.speed(15)
turtle.hideturtle()
turtle.penup()
turtle.setposition(70, 90)
turtle.pendown()
turtle.fillcolor("#F09F13")
turtle.begin_fill()
turtle.circle(40)
turtle.end_fill()
turtle.hideturtle()
turtle.color('#fe7d96')
turtle.pensize(4)
turtle.speed(15)
turtle.hideturtle()
turtle.penup()
turtle.setposition(15, -20)
turtle.hideturtle()
turtle.pendown()
turtle.fillcolor("#fe7d96")
