Module 没有名为'；型号'；，python 3.5.2

从互联网上获得了这个Arkanoid克隆代码，但是即使在安装pygame二进制文件后仍然不想工作（“ImportError:没有名为‘Models’的模块”）。我正在使用Spyder Python 3.5，并从中克隆了所有repo

导入pygame
导入系统
输入数学
随机输入
从pygame.locals导入*
导入游戏模块
从GameModule.Models导入*
从GameModule.Constants导入*
班级游戏：
def播放声音（自身，文件名）：
sound=pygame.mixer.sound（文件名）
播放
定义初始化（自）：
pygame.init（）
pygame.mixer.init（11025）
self.actualState=状态[“开始”]
self.display=pygame.display.set_模式（gfx[“屏幕”]）
pygame.display.set_标题（“Arkanoid v”+版本）
#4个基本对象，用于定义游戏
##画师-在屏幕上绘制实际情况
##映射器-加载映射
##状态-保持游戏的姿态：点数、寿命、实际加电等
##物品-持有实际游戏的物品：球、砖块、垫子等
self.objects=GameModule.objects（）
self.mapper=GameModule.mapper（self.objects）
self.status=status（）
self.painter=GameModule.painter（self.display、self.objects、self.status）
self.lastState=None
self.fps=pygame.time.Clock（）
self.newLevel（）
def回路（自）：
self.fps.tick（gfx[“帧率”]）
对于pygame.event.get（）中的事件：
self.handleGlobalEvents（事件）
自手动事件（事件）
self.handleKeyboard（）
self.updateState（）
如果self.actualState！=州[“GAMEOVER”]：
self.painter.draw（）
其他：
self.display.fill（（0,0,0））
bigFont=pygame.font.SysFont（“无衬线”，32）
gameOver=bigFont.render（“游戏结束！”，True，（255255））
smallFont=pygame.font.SysFont（“无衬线”，18）
points=smallFont.render（“Punktow:+str（self.status.points），True，（255255））
self.display.blit（gameOver，（gfx[“屏幕”][0]/2-gameOver.get_size（）[0]/2，gfx[“屏幕”][1]/2-gameOver.get_size（）[1]/2））
self.display.blit（点数，（gfx[“屏幕”][0]/2-points.get_size（）[0]/2，gfx[“屏幕”][1]/2-gameOver.get_size（）[1]/2-40））
pygame.display.update（）
def handleEvents（自身、事件）：
如果self.actualState！=状态[“暂停”]：
如果event.type==KEYDOWN：
如果event.key==K_p：
self.lastState=self.actualState
self.actualState=状态[“暂停”]
self.painter.paintered=True
其他：
如果event.type==KEYDOWN：
如果event.key==K_p：
self.actualState=self.lastState
self.painter.paintered=False
如果self.actualState==状态[“开始”]：
如果event.type==KEYDOWN：
如果event.key==K_空间：
self.actualState=状态[“进度”]
（self.objects.balls（））[0]。速度更改（int（math.copysign（5.，float（self.objects.pad（）.lastMove）），-5）
def handleGlobalEvents（自身、事件）：
如果event.type==退出：
sys.exit（）
def手持键盘（自身）：
pressed=pygame.key.get_pressed（）
如果self.actualState==状态[“进度”]或self.actualState==状态[“开始”]：
如果按下[K_LEFT]：
如果self.objects.pad（）.move（-10）和self.actualState==状态[“开始”]：
（self.objects.balls（））[0]。移动（-10,0）
如果按下[K_RIGHT]：
如果self.objects.pad（）.move（10）和self.actualState==状态[“开始”]：
（self.objects.balls（））[0]。移动（10,0）
房地产（自）：
如果self.actualState==状态[“暂停”]：
返回
如果self.actualState==状态[“进度”]：
self.objects.updatePowerups（）
对于self.objects.balls（）中的球：
速度=球。速度（）
球移动（速度[0]，速度[1]）
如果ball.CollizewithWall（）：
pos=ball.pos（）
如果pos[0]==0或pos[0]>=gfx[“屏幕”][0]-球.图像.get_size（）[0]-1:
ball.xInvert（）
如果位置[1]==0：
ball.yInvert（）
如果pos[1]>=gfx[“屏幕”][1]-ball.image.get_size（）[1]-1:
self.status.lifes-=1
self.actualState=状态[“开始”]
self.playSound（“参考资料/snd/chord.wav”）
而len（self.objects.balls（））！=1:
self.objects.removeBall（（self.objects.balls（））[0]）
对于self.objects.powerups（）中的通电：
self.objects.deletePowerup（通电）
self.objects.balls（）[0].reset（）
self.objects.pad（）.reset（）
对于self.objects.grid（）中的obj：
如果发生碰撞（obj）：
self.status.points+=100
如果obj.realx=球位置[0]：
ball.yInvert（）
如果obj.realy=球位置[1]：
ball.xInvert（）
自行车把碰撞（obj）
如果ball.collision（self.objects.pad（））：
ball.yInvert（）
如果self.objects.pad（）.position[1]=ball.position[1]：
ball.xInvert（）
对于self.objects.powerups（）中的通电：
pad=self.objects.pad（）
如果通电。碰撞（焊盘）：
self.objects.deletePowerup（通电）
self.generatePowerup（）
如果powerup.y==gfx[“屏幕”][1]-1-powerup.image.get_size（）[1]：
self.objects.deletePowerup（通电）
如果self.status.lifes==0：
self.actualState=状态[“GAMEOVER”]
如果self.objects.grid（）=[]：
self.status.level+=1
如果len（levels）=self.status.level：
self.actualStatus=状态[“
    import pygame
    import sys
    import math
    import random
    from pygame.locals import *


    import GameModule
    from GameModule.Models import *
    from GameModule.Constants import *

    class Game:
      def playSound( self, fileName ):
        sound = pygame.mixer.Sound(fileName)
        sound.play()

      def __init__(self):
        pygame.init()
        pygame.mixer.init(11025)


        self.actualState = states["START"]

        self.display = pygame.display.set_mode( gfx["screen"] )
        pygame.display.set_caption( "Arkanoid v" + version )
        # 4 basic objects, which define the game
        ## Painter - drawing actual situation on screen
        ## Mapper - loading the map
        ## Status - holding stance of the game: points, lifes, actual powerups etc
        ## Objects - holding actual game's objects: balls, bricks, pad etc

        self.objects = GameModule.Objects() 
        self.mapper =  GameModule.Mapper( self.objects )
        self.status =  Status()
        self.painter = GameModule.Painter( self.display, self.objects, self.status )
        self.lastState = None 
        self.fps = pygame.time.Clock()
        self.newLevel()

      def loop(self):

        self.fps.tick( gfx["framerate"] )
        for event in pygame.event.get():
          self.handleGlobalEvents( event )
          self.handleEvents( event )
        self.handleKeyboard()
        self.updateState()
        if self.actualState != states["GAMEOVER"]:
          self.painter.draw()
        else:
          self.display.fill( (0,0,0) )
          bigFont = pygame.font.SysFont( "sans-serif", 32 )
          gameOver = bigFont.render( "GAME OVER!", True, (255,255,255) )
          smallFont = pygame.font.SysFont( "sans-serif", 18 )
          points = smallFont.render( "Punktow: " + str(self.status.points), True, (255,255,255) )
          self.display.blit( gameOver, (gfx["screen"][0]/2 - gameOver.get_size()[0]/2, gfx["screen"][1]/2 - gameOver.get_size()[1]/2) )
          self.display.blit( points, (gfx["screen"][0]/2 - points.get_size()[0]/2, gfx["screen"][1]/2 - gameOver.get_size()[1]/2 - 40) )
        pygame.display.update()

      def handleEvents( self, event ):
        if self.actualState != states["PAUSE"]:
          if event.type == KEYDOWN:
            if event.key == K_p:
              self.lastState = self.actualState
              self.actualState = states["PAUSE"]
              self.painter.paused = True
        else:
          if event.type == KEYDOWN:
            if event.key == K_p:
              self.actualState = self.lastState
              self.painter.paused = False

        if self.actualState == states["START"]:
          if event.type == KEYDOWN:
            if event.key == K_SPACE:
              self.actualState = states["PROGRESS"]
              (self.objects.balls())[0].speedChange( int( math.copysign( 5., float(self.objects.pad().lastMove) ) ), -5 )

      def handleGlobalEvents( self, event ):
        if event.type == QUIT:
          sys.exit()

      def handleKeyboard(self):
        pressed = pygame.key.get_pressed()

        if self.actualState == states["PROGRESS"] or self.actualState == states["START"]:
          if pressed[K_LEFT]:
            if self.objects.pad().move(-10) and self.actualState == states["START"]:
              (self.objects.balls())[0].move(-10,0)
          if pressed[K_RIGHT]:
            if self.objects.pad().move(10) and self.actualState == states["START"]:
              (self.objects.balls())[0].move(10,0) 


      def updateState(self):
        if self.actualState == states["PAUSE"]:
          return
        if self.actualState == states["PROGRESS"]:
          self.objects.updatePowerups()
          for ball in self.objects.balls():
            speed = ball.speed()
            ball.move( speed[0], speed[1] )
            if ball.collideWithWall():
              pos = ball.pos()
              if pos[0] == 0 or pos[0] >= gfx["screen"][0] - ball.image.get_size()[0] - 1:
                ball.xInvert()
              if pos[1] == 0:
                ball.yInvert()
              if pos[1] >= gfx["screen"][1] - ball.image.get_size()[1] - 1:
                self.status.lives -= 1
                self.actualState = states["START"]
                self.playSound( "Resources/snd/chord.wav" )
                while len(self.objects.balls()) != 1:
                  self.objects.removeBall((self.objects.balls())[0])
                for powerup in self.objects.powerups():
                  self.objects.deletePowerup(powerup)

                self.objects.balls()[0].reset()
                self.objects.pad().reset()

            for obj in self.objects.grid():
              if ball.collision(obj):
                self.status.points += 100
                if obj.realx <= ball.position[0] and obj.realx + gfx["grid"][0] >= ball.position[0]:
                  ball.yInvert()
                if obj.realy <= ball.position[1] and obj.realy + gfx["grid"][1] >= ball.position[1]:
                  ball.xInvert()
                self.handleBrickCollision(obj)

            if ball.collision(self.objects.pad()):
              ball.yInvert()
              if self.objects.pad().position[1] <= ball.position[1] and self.objects.pad().position[1] + gfx["grid"][1] >= ball.position[1]:
                ball.xInvert()

          for powerup in self.objects.powerups():
            pad = self.objects.pad()
            if powerup.collision(pad):
              self.objects.deletePowerup(powerup)
              self.generatePowerup()
            if powerup.y == gfx["screen"][1] - 1 - powerup.image.get_size()[1]:
              self.objects.deletePowerup(powerup)

        if self.status.lives == 0:
          self.actualState = states["GAMEOVER"]
        if self.objects.grid() == []:
          self.status.level += 1
          if len(levels) == self.status.level:
            self.actualStatus = states["GAMEOVER"]
          else:
            self.newLevel()

        for modifier in self.status.modifiers:
          modifier[1] -= 1
          if modifier[1] == 0:
            if modifier[0] == "big_pad":
              self.objects.pad().setWidth(3)
              del modifier

      def generatePowerup(self):
        r = random.randint(1,3)
        # 3 possible powerups:
        # 1 - +1 life
        # 2 - for 30 sec the pad is larger
        # 3 - additional ball
        print (r)
        if r == 1:
          self.status.lives += 1
        elif r == 2:
          self.status.modifiers.append( [ "big_pad", gfx["framerate"] * 30 ] )
          self.objects.pad().setWidth(5)
        elif r == 3:
          ball = Ball()
          ball.position[0] = self.objects.pad().position[0] + (gfx["grid"][0]*self.objects.pad().gridWidth/2)
          ball.speedChange( int( math.copysign( 5., float(self.objects.pad().lastMove) ) ), -5 )
          self.objects.addBall(ball)

      def handleBrickCollision(self,obj):
        brickType = obj.getType()
        if brickType == "simple":
          self.objects.setGrid( obj.x, obj.y, None )
          rand = random.randint( 0, 9 )
          if rand == 9: # 1/10 chance for powerup
            self.objects.spawnPowerup( obj.x, obj.y )

        elif brickType == "solid":
          self.objects.setGrid( obj.x, obj.y, SimpleBrick(obj.x,obj.y) )
        elif brickType == "ghost":
          newType = random.randint( 0, 1 )
          if newType == 0:
            self.objects.setGrid( obj.x, obj.y, SimpleBrick(obj.x,obj.y) )
          elif newType == 1:
            self.objects.setGrid( obj.x, obj.y, SolidBrick(obj.x,obj.y) )

        self.playSound( "Resources/snd/ding.wav" )

      def newLevel(self):
        self.playSound( "Resources/snd/tada.wav" )
        self.mapper.load( self.status.level ) 
        self.objects.pad().reset() 
        while len(self.objects.balls()) != 1:
          self.objects.removeBall((self.objects.balls())[0])
        self.objects.balls()[0].reset()
        self.actualState = states["START"]

    class Status:
      def __init__(self):
        self.level = 0
        self.points = 0
        self.lives = startState["lives"]
        self.modifiers = []

    game = Game()

    while True:
      game.loop()