实践- 搬金盘的婆罗门

def hanoi(n, a, b, c):
    if n == 1:
        movements.append(a + " --> " + c)
    else:
        hanoi(n - 1, a, c, b)
        movements.append(a + " --> " + c)
        hanoi(n - 1, b, a, c)

movements = []
hanoi(5, 'A', 'B', 'C')
print("Steps count:",len(movements))
print("The first 3 steps are:", movements[:3])

#BasicPyGame.py
import sys,os
import pygame.locals
class App:
    def __init__(self):
        pygame.init()
        self.screen = pygame.display.set_mode((960, 540))
        pygame.display.set_caption("Tower of Hanoi")

        self.sResourcePath = "resource" + os.sep
        self.imgBackground = pygame.image.load(\
            self.sResourcePath + "background.png").convert()

        # self.bgm = pygame.mixer.music.load(self.sResourcePath+"Serenity.mp3")
        # pygame.mixer.music.play(loops = int(1e9), start = 0.0)

    def render(self):
        self.screen.blit(self.imgBackground, (0, 0))
        #...
        pygame.display.update()

    def mainLoop(self):
        while True:
            for event in pygame.event.get():
                if event.type == pygame.locals.QUIT:
                    sys.exit()

                elif event.type in (pygame.MOUSEBUTTONDOWN,\
                    pygame.MOUSEBUTTONUP,pygame.MOUSEMOTION):
                    print("Mouse event:",event)
                else:
                    print("Non-mouse event:",event)

            self.render()

if __name__ == '__main__':
    a = App()
    a.mainLoop()

#BasicPyGame.py
	...
    def render(self):
        self.screen.blit(self.imgBackground, (0, 0))
        #...
        pygame.display.update()

Non-mouse event: <Event(2-KeyDown {'unicode': '', 'key': 107, ...})>
Non-mouse event: <Event(3-KeyUp {'key': 107, 'mod': 0, 'scancode': 37})>
Mouse event: <Event(5-MouseButtonDown {'pos': (935, 11), 'button': 1})>
Mouse event: <Event(6-MouseButtonUp {'pos': (935, 11), 'button': 1})>
Mouse event: <Event(4- MouseMotion {'pos': (617, 444), ... 'buttons': (0, 0, 0)})>

from enum import Enum
import pygame

class ButtonState(Enum):
    normal = 0      #正常
    focused = 1     #高亮
    pushed = 2      #按下
    disabled = 3    #禁用

class Button:
    def __init__(self,screen,xCenter,yBottom,
                 fileNormal,fileFocused,filePushed,fileDisabled):
        self.screen = screen
        self.imgNormal = pygame.image.load(fileNormal)
        self.imgFocused = pygame.image.load(fileFocused)
        self.imgPushed = pygame.image.load(filePushed)
        self.imgDisabled = pygame.image.load(fileDisabled)
        self.state = ButtonState.normal

        self.rect = self.imgNormal.get_rect()
        self.rect.centerx = xCenter
        self.rect.bottom = yBottom

    def setEnabled(self,bEnabled):
        self.state = ButtonState.normal if bEnabled \
            else ButtonState.disabled
    ...

    def blit(self):
        img = None
        if self.state == ButtonState.normal:
            img = self.imgNormal
        elif self.state == ButtonState.focused:
            img = self.imgFocused
        elif self.state == ButtonState.disabled:
            img = self.imgDisabled
        elif self.state == ButtonState.pushed:
            img = self.imgPushed
        self.screen.blit(img,self.rect)

#Button.py
class Button:
	...
    def mouseEvent(self,e):
        x,y = pygame.mouse.get_pos()
        if e.type == pygame.MOUSEMOTION:
            return self.__mouseMotionEvent(x,y)

        if not self.rect.collidepoint(x,y):
            return

        if e.type == pygame.MOUSEBUTTONDOWN:
            return self.__mouseDownEvent()

        if e.type == pygame.MOUSEBUTTONUP:
            return self.__mouseUpEvent()

    def __mouseUpEvent(self):
        if self.state not in (ButtonState.disabled,):
            self.state = ButtonState.focused
            return self
        return None

    def __mouseDownEvent(self):
        if self.state in (ButtonState.normal,ButtonState.focused):
            self.state = ButtonState.pushed
        return

    def __mouseMotionEvent(self,x,y):
        if self.rect.collidepoint(x,y):
            if self.state == ButtonState.normal:
                self.state = ButtonState.focused
        else:
            if self.state == ButtonState.focused:
                self.state = ButtonState.normal

#Disc.py
class Disc:
    "The said golden disc."
    iDiscHeight = 50
    def __init__(self,screen,number,imgFile):
        self.screen = screen
        self.iNo = number
        self.img = pygame.image.load(imgFile)
        self.rect = self.img.get_rect()

    def blit(self):
        self.screen.blit(self.img,self.rect)

from Disc import Disc
class Pole:
    def __init__(self,xPos):
        self.xPos = xPos
        self.discs = []   #disc 0 at bottom most

    def getDiscsTopPosition(self):
        return 481 - len(self.discs)*Disc.iDiscHeight

    def blit(self):
        for idx,disc in enumerate(self.discs):
            disc.rect.centerx = self.xPos
            disc.rect.bottom = 481 - Disc.iDiscHeight*idx
            disc.blit()

    def putDisc(self,disc):
        if self.discs:
            assert disc.iNo < self.discs[-1].iNo,"Rule violated."
        self.discs.append(disc)

    def popDisc(self):
        disc = self.discs.pop()
        assert disc != None, "No disc on pole."
        return disc

#HanoiTower.py
...
class HanoiTower:
    instance = None
    ...
    def __init__(self):
        assert HanoiTower.instance == None, "Only one HanoiTower object allowed."
        HanoiTower.instance = self
        ...
        self.initGame()

    def createButtons(self):
        self.btnReset = Button(self.screen,120,535,
                               self.sResourcePath+"resetNormal.png",
                               self.sResourcePath+"resetFocused.png",
                               self.sResourcePath+"resetPushed.png",
                               self.sResourcePath+"resetDisabled.png")
        ...
        self.buttons = [self.btnStep,self.btnRun,self.btnPause,self.btnReset]

    def createPolesDiscs(self):
        ...
        self.poles = []
        pole0 = Pole(150)
        pole0.putDisc(Disc(self.screen,4,self.sResourcePath + "gray.png"))
        ...
        pole0.putDisc(Disc(self.screen,0,self.sResourcePath + "blue.png"))

        self.poles.append(pole0)
        self.poles.append(Pole(480))
        self.poles.append(Pole(810))

    def initGame(self):
        pygame.init()
        self.screen = pygame.display.set_mode((960, 540), 0, 32)
        pygame.display.set_caption("Tower of Hanoi")
		...
		self.createPolesDiscs()
        self.createButtons()
        ...

    def render(self):
        self.screen.blit(self.imgBackground, (0, 0))

        for x in self.buttons + self.poles:
            x.blit()
		...
        pygame.display.update()

    def mouseEvent(self,event):
        ...

    def mainLoop(self):
        while (True):
            for event in pygame.event.get():
                if event.type == pygame.locals.QUIT:
                    sys.exit()
				...
                elif event.type in (pygame.MOUSEBUTTONDOWN,
                                  pygame.MOUSEBUTTONUP,pygame.MOUSEMOTION):
                    self.mouseEvent(event)

            self.render()

if __name__ == '__main__':
    t = HanoiTower()
    t.mainLoop()

#HanoiTower.py
class HanoiTower:
	...
    def mouseEvent(self,event):
        for b in self.buttons:
            r = b.mouseEvent(event)
            if r:
                break

        if r == None:
            return None

        if r == self.btnRun:
            self.run()
        elif r == self.btnStep:
            self.step()
        elif r == self.btnPause:
            self.pause()
        elif r == self.btnReset:
            self.reset()
        else:
            assert False, "Wrong return value from Button.mouseEvent()."

def hanoi(n, a, b, c):
    if n == 1:
        yield (a,c)
    else:
        for x in hanoi(n - 1, a, c, b):
            yield x
        yield (a,c)
        for x in hanoi(n - 1, b, a, c):
            yield x


if __name__ == '__main__':
    genHanoi = hanoi(5, 0, 1, 2)
    while True:
        try:
            a = next(genHanoi)
        except (StopIteration,Exception) as e:
            break
        else:
            print(a)

genHanoi = hanoi(5,0,1,2)
for poleFrom,poleTo in genHanoi:
    move a disc from poleFrom to poleTo
    time.sleep(1.0)
    render()      #更新界面

#HanoiTower.py
class HanoiTower:
    ...
    userEventDiscMoveInterval = pygame.USEREVENT + 1
    ...
    def intervalTimerStart(self):
        pygame.time.set_timer(HanoiTower.userEventDiscMoveInterval, 100)

    def intervalTimerStop(self):
        pygame.time.set_timer(HanoiTower.userEventDiscMoveInterval, 0)

    def mainLoop(self):
        while (True):
            for event in pygame.event.get():
                if event.type == pygame.locals.QUIT:
                    sys.exit()
                ...
                elif event.type == HanoiTower.userEventDiscMoveInterval:
                     self.runNextMove()  #移动下一个盘

                elif event.type in (pygame.MOUSEBUTTONDOWN,
                                  pygame.MOUSEBUTTONUP,pygame.MOUSEMOTION):
                    self.mouseEvent(event)

            self.render()

class HanoiTower:
    ...
	def moveDisc(self,iPoleFrom,iPoleTo):
        disc = self.poles[iPoleFrom].popDisc()  #从poleFrom弹出取下顶盘
        self.poles[iPoleTo].putDisc(disc)       #将盘放至iPoleTo

class FlyingDisc:
    "The disc in moving..."
    verticalUpStage = 0                      #飞盘抬升阶段
    horizontalMoveStage = 1                  #飞盘平移阶段
    verticalDownStage = 2                    #飞盘下降阶段

    def __init__(self,disc,poleFrom,poleTo):
        self.disc = disc                 #包含的盘对象
        self.poleFrom = poleFrom         #源柱
        self.poleTo = poleTo             #目标柱

        self.xCurrent = poleFrom.xPos    #飞盘的当前x坐标 = 源柱的x坐标
        self.xTo = poleTo.xPos			 #飞盘的目标x坐标 = 目标柱的x坐标
        self.yCurrent = poleFrom.getDiscsTopPosition()  #飞盘当前y坐标
        self.yCeiling = Disc.iDiscHeight + 20           #飞盘平移时的y坐标
        self.yTo = poleTo.getDiscsTopPosition() 		#飞盘的目标y坐标
        self.xStep = (self.xTo - self.xCurrent)/50		#平移单步x偏移量
        self.yUpStep = (self.yCeiling - self.yCurrent) / 50  #抬升单步y偏移量
        self.yDownStep = (self.yTo - self.yCeiling) / 50	 #下降单步y偏移量

        self.stageMove = self.verticalUpStage  #当前所处阶段 = 抬升阶段

    def blit(self):    #飞盘将自己画出来
        self.disc.rect.centerx = self.xCurrent
        self.disc.rect.bottom = self.yCurrent
        self.disc.blit()

    def flyMove(self): #飞盘移动一步，如果飞行已至目的地，返回True,否则False
        assert self.stageMove in (self.verticalDownStage,self.horizontalMoveStage,self.verticalUpStage)
        if self.stageMove == self.verticalUpStage:
            if abs(self.yCurrent-self.yCeiling) <= abs(self.yUpStep):
                self.yCurrent = self.yCeiling
                self.stageMove = self.horizontalMoveStage
            else:
                self.yCurrent += self.yUpStep
            return False

        if self.stageMove == self.horizontalMoveStage:
            if abs(self.xCurrent-self.xTo) <= abs(self.xStep):
                self.xCurrent = self.xTo
                self.stageMove = self.verticalDownStage
            else:
                self.xCurrent += self.xStep
            return False

        if self.stageMove == self.verticalDownStage:
            if abs(self.yCurrent-self.yTo) <= abs(self.yDownStep):
                self.yCurrent = self.yTo
                self.poleTo.putDisc(self.disc)    #飞行表演结束，放至目标柱
                return True
            else:
                self.yCurrent += self.yDownStep
            return False

#HanoiTower.py
class HanoiTower:
    ...
    userEventFlyDiscMove = pygame.USEREVENT + 2
    def moveDiscStart(self,iPoleFrom,iPoleTo):
        disc = self.poles[iPoleFrom].popDisc()            #从源柱取下一个盘
        assert self.flyingDisc == None
        #先不放至目标柱，让它化身为飞盘
        self.flyingDisc = FlyingDisc(disc,self.poles[iPoleFrom],self.poles[iPoleTo])
        self.flyTimerStart()         #开启飞行定时器

    def moveDiscEnd(self):
        self.flyingDisc = None  
        self.flyTimerStop()         #停止飞行定时器
        if self.appState == AppState.running:
            self.intervalTimerStart()

    def flyTimerStart(self):
        pygame.time.set_timer(HanoiTower.userEventFlyDiscMove, 10)

    def flyTimerStop(self):
        pygame.time.set_timer(HanoiTower.userEventFlyDiscMove, 0)

    def flyMove(self):						#飞行定时器到，移动飞盘
        if not self.flyingDisc:
            self.flyTimerStop()
            return

        if self.flyingDisc.flyMove():
            self.moveDiscEnd()      		#关闭相关定时器，酌情开始下轮移盘

    def render(self):
        self.screen.blit(self.imgBackground, (0, 0))
		...
        if self.flyingDisc:					#如有飞盘，画之
            self.flyingDisc.blit()
		...
        pygame.display.update()

    def mainLoop(self):
        while (True):
            for event in pygame.event.get():
                ...
                elif event.type == HanoiTower.userEventFlyDiscMove:
                    self.flyMove()
				...

            self.render()

#HanoiTower.py
class HanoiTower:
    ...
    def runNextMove(self):
        assert self.hanoiGenerator != None
        self.intervalTimerStop()
        try:
            nextAction = next(self.hanoiGenerator)
        except (StopIteration, Exception) as e:
            self.hanoiGenerator = None
            self.intervalTimerStop()
            self.syncState(AppState.finished)
            print("Iteration over, not more actions.")
        else:
            poleFrom, poleTo = nextAction
            self.moveDiscStart(poleFrom, poleTo)

    def run(self):                  #btnRun触发时执行该函数
        if not self.hanoiGenerator:
            self.reset()
            self.hanoiGenerator = HanoiGenerator.hanoi(5, 0, 1, 2)
        self.syncState(AppState.running)
        if not self.flyingDisc:
            self.runNextMove()

    def mainLoop(self):
       while (True):
         for event in pygame.event.get():
             ...
             elif event.type==HanoiTower.userEventFlyDiscMove:
                 self.flyMove()       #飞行定时器

             elif event.type==HanoiTower.userEventDiscMoveInterval:
                 self.runNextMove() #移盘间隔定时器
             ...

         self.render()

#HanoiTower.py
class AppState(Enum):
    idle = 0                #空闲
    running = 1            #自动运行
    finished = 2          #执行完成

class HanoiTower:
    def syncState(self, state):
        if state == AppState.idle:
            self.btnReset.setEnabled(True)
            self.btnRun.setEnabled(True)
            self.btnStep.setEnabled(True)
            self.btnPause.setEnabled(False)
        elif state == AppState.running:
            self.btnReset.setEnabled(False)
            self.btnRun.setEnabled(False)
            self.btnStep.setEnabled(False)
            self.btnPause.setEnabled(True)
        elif state == AppState.finished:
            self.btnReset.setEnabled(True)
            self.btnRun.setEnabled(False)
            self.btnStep.setEnabled(False)
            self.btnPause.setEnabled(False)
        else:
            assert False, "syncState():Unrecognized state parameter."
        self.appState = state

#HanoiTower.py
class HanoiTower:
    ...
    def run(self):
        if not self.hanoiGenerator:
            self.reset()
            self.hanoiGenerator = HanoiGenerator.hanoi(5, 0, 1, 2)
        self.syncState(AppState.running)
        if not self.flyingDisc:
            self.runNextMove()

    def reset(self):
        if self.flyingDisc:
            print("One disc still in moving...")
            return
 
        self.hanoiGenerator = None
        self.createPolesDiscs()
        self.syncState(AppState.idle)

    def pause(self):
        self.intervalTimerStop()
        self.syncState(AppState.idle)

    def step(self):
        if self.flyingDisc:
            print("One disc still in moving...")
            return

        if not self.hanoiGenerator:
            self.createPolesDiscs()
            self.hanoiGenerator = HanoiGenerator.hanoi(5, 0, 1, 2)

        self.runNextMove()