Python Song类代码示例

  def run(self, ticks):
    SceneClient.run(self, ticks)

    if not self.wizardStarted:
      self.wizardStarted = True

      if not self.songName:
        while True:
          self.libraryName, self.songName = \
            Dialogs.chooseSong(self.engine, \
                               selectedLibrary = Config.get("game", "selected_library"),
                               selectedSong    = Config.get("game", "selected_song"))
        
          if not self.songName:
            self.session.world.finishGame()
            return

          Config.set("game", "selected_library", self.libraryName)
          Config.set("game", "selected_song",    self.songName)
          
          info = Song.loadSongInfo(self.engine, self.songName, library = self.libraryName)
          d = Dialogs.chooseItem(self.engine, info.difficulties,
                                 _("Choose a difficulty:"), selected = self.player.difficulty)
          if d:
            self.player.difficulty = d
            break
      else:
        info = Song.loadSongInfo(self.engine, self.songName, library = self.libraryName)

      # Make sure the difficulty we chose is available
      if not self.player.difficulty in info.difficulties:
        self.player.difficulty = info.difficulties[0]
        
      self.session.world.deleteScene(self)
      self.session.world.createScene("GuitarScene", libraryName = self.libraryName, songName = self.songName)

 def checkParts(self):
     info = Song.loadSongInfo(self.engine, self.songName, library=self.libraryName)
     guitars = []
     drums = []
     vocals = []
     for part in info.parts:
         if part.id == 4 or part.id == 7:
             drums.append(part)
         elif part.id == 5:
             vocals.append(part)
         else:
             guitars.append(part)
     if len(drums) == 0 and self.engine.input.gameDrums > 0:
         Dialogs.showMessage(
             self.engine, _("There are no drum parts in this song. Change your controllers to play.")
         )
         return False
     if len(guitars) == 0 and self.engine.input.gameGuitars > 0:
         Dialogs.showMessage(
             self.engine, _("There are no guitar parts in this song. Change your controllers to play.")
         )
         return False
     if len(vocals) == 0 and self.engine.input.gameMics > 0:
         Dialogs.showMessage(
             self.engine, _("There are no vocal parts in this song. Change your controllers to play.")
         )
         return False
     return True

    def previewSong(self):
        self.previewLoaded = True
        if isinstance(self.selectedItem, Song.SongInfo):
            song = self.selectedItem.songName  # TODO: SongDB
        else:
            return

        if self.careerMode and self.selectedItem.getLocked():  # TODO: SongDB
            if self.song:
                self.song.fadeout(1000)
            return
        if self.songLoader:
            try:
                self.songLoader.stop()
            except:
                self.songLoader = None

        self.songLoader = self.engine.resource.load(
            self,
            None,
            lambda: Song.loadSong(self.engine, song, playbackOnly=True, library=self.library),
            synch=True,
            onLoad=self.songLoaded,
            onCancel=self.songCanceled,
        )

  def createClient(self, libraryName, songName, players = None):
    self.libraryName     = libraryName
    self.songName        = songName
    self.stars           = [0 for i in players]
    self.accuracy        = [0 for i in players]
    self.counter         = 0
    self.showHighscores  = False
    self.highscoreIndex  = [None for i in players]
    self.taunt           = None
    self.uploadingScores = False
    self.nextScene       = None
    self.offset          = None
    self.pauseScroll     = None
    self.scorePart       = None
    self.scoreDifficulty = None
    self.playerList      = players

    self.spinnyDisabled   = self.engine.config.get("game", "disable_spinny")    

    items = [
      (_("Replay"),            self.replay),
      (_("Change Song"),       self.changeSong),
      (_("Quit to Main Menu"), self.quit),
    ]
    self.menu = Menu(self.engine, items, onCancel = self.quit, pos = (.2, .5))
      
    self.engine.resource.load(self, "song", lambda: Song.loadSong(self.engine, songName, library = self.libraryName, notesOnly = True, part = [player.part for player in self.playerList]), onLoad = self.songLoaded)
    self.engine.loadSvgDrawing(self, "background", "gameresults.svg")

    phrase = random.choice(Theme.resultsPhrase.split(","))
    if phrase == "None":
      phrase = _("Chilling...")
    Dialogs.showLoadingScreen(self.engine, lambda: self.song, text = phrase)

  def createClient(self, libraryName, songName, players = 1): #players = None
    Log.debug("GameResultsSceneClient class init...")
    self.libraryName     = libraryName
    self.songName        = songName
    self.stars           = [0 for i in players]
    self.accuracy        = [0 for i in players]
    self.counter         = 0
    self.showHighscores  = False
    self.highscoreIndex  = [-1 for i in players]
    self.taunt           = None
    self.uploadingScores = False
    self.uploadResult    = None
    self.nextScene       = None
    self.offset          = None
    self.pauseScroll     = None
    self.scorePart       = None
    self.scoreDifficulty = None
    self.playerList      = players
    self.spinnyDisabled   = True#NO SPINNY!!!    

    #myfingershurt: reordering so default is Change Song.
    items = [
      (_("Continue"),       self.changeSong),
      (_("Replay"),            self.replay),
      (_("Quit"), self.quit),
    ]
    self.menu = Menu(self.engine, items, onCancel = self.quit, pos = (.2, .5))
      
    self.engine.resource.load(self, "song", lambda: Song.loadSong(self.engine, songName, library = self.libraryName, notesOnly = True, part = [player.part for player in self.playerList]), onLoad = self.songLoaded)

    #Get theme
    themename = self.engine.data.themeLabel
    #now theme determination logic is only in data.py:
    self.theme = self.engine.data.theme
      
    self.starScoring = self.engine.config.get("game", "star_scoring")#MFH
    self.Congratphrase = self.engine.config.get("game", "congrats")#blazingamer

    self.resultCheerLoop = self.engine.config.get("game", "result_cheer_loop")#MFH
    self.cheerLoopDelay = self.engine.config.get("game", "cheer_loop_delay")#MFH
    self.cheerLoopCounter = self.cheerLoopDelay   #MFH - starts out ready to cheer
      
    self.engine.loadImgDrawing(self, "background", os.path.join("themes",themename,"gameresults.png"))

    phrase = random.choice(Theme.resultsPhrase.split("_"))
    if phrase == "None":
      i = random.randint(0,5)
      if i == 0:
        phrase = _("Relax, it was an excellent show.")
      elif i == 1:
        phrase = _("Truly Amazing!")
      elif i == 2:
        phrase = _("Thanks for playing!")
      elif i == 3:
        phrase = _("One more song can't hurt, can it?")
      elif i == 4:
        phrase = _("What an amazing performance!")
      else:
        phrase = _("That's how it's done!")
    Dialogs.showLoadingScreen(self.engine, lambda: self.song, text = phrase)

 def loadSongs(self, libraries):
     Log.debug("Loading songs in %s" % self.library)
     self.engine.resource.load(
         self,
         "songs",
         lambda: Song.getAvailableSongsAndTitles(self.engine, self.library, progressCallback=self.progressCallback),
         onLoad=self.prepareSetlist,
         synch=True,
     )

 def loadLibrary(self):
   Log.debug("Loading libraries in %s" % self.library)
   self.loaded = False
   self.tiersPresent = False
   if self.splash:
     Dialogs.changeLoadingSplashScreenText(self.engine, self.splash, _("Browsing Collection..."))
   else:
     self.splash = Dialogs.showLoadingSplashScreen(self.engine, _("Browsing Collection..."))
     self.loadStartTime = time.time()
   self.engine.resource.load(self, "libraries", lambda: Song.getAvailableLibraries(self.engine, self.library), onLoad = self.loadSongs, synch = True)

 def startQueue(self):
    firstSong = self.songQueue.nextSong(0)
    Config.set("game", "selected_song", firstSong[0])
    Config.set("game", "selected_library", firstSong[1])
    Config.set("game", "selected_players", firstSong[2])
    self.player.difficulty = firstSong[3]
    self.player2.difficulty =  firstSong[4]
    self.player.part = firstSong[5]
    self.player2.part = firstSong[6]
    self.info = Song.loadSongInfo(self.engine, firstSong[0])
    self.songName = firstSong[0]
    self.startGame(queueCounter =  1)

 def startQueue(self):
   #obviously a fair amount of work to be done on this anyway... But note that startGame will not work.
   firstSong = self.songQueue.nextSong(0)
   Config.set("game", "selected_song", firstSong[0])
   Config.set("game", "selected_library", firstSong[1])
   Config.set("game", "selected_players", firstSong[2])
   self.player.difficulty = firstSong[3]
   self.player2.difficulty =  firstSong[4]
   self.player.part = firstSong[5]
   self.player2.part = firstSong[6]
   self.info = Song.loadSongInfo(self.engine, firstSong[0])
   self.songName = firstSong[0]
   self.startGame(queueCounter =  1)

    def AutoMusic(self, parent, page_type, loadpic, waitpic,
                  incontainer, outcontainer, records, music):
        """
            This is a callback function for 'Generate' button.
            It takes the selected inputs from the listbox,
            make an AutoComposeSong object, and execute its functions
            to output a MIDI file.
            
            * See 'AutoComposeSong.py' for the detailed explanation
            on how these methods work.            
        """

        genre = self.genreList[int(self.gr_listbox.curselection()[0])]
        key = eval(self.keyList[int(self.key_listbox.curselection()[0])])
        cp = self.cpList[int(self.cp_listbox.curselection()[0])]
        title = self.title.get()
        
        mode = Tonics
        numPhrase = 4
        beat = 72

        if self.entry_field.get() == '':
            userInput = []
        else:
            userInput = Song()
            userInput.reset()
            userInputMelody = wrapNote(self.entry_field.get().split('-'))
            userInputTimes = constant_times(userInputMelody, 2, beat)
            userInput.wrapNotesAndTimes(userInputMelody, userInputTimes)
        
        autoSong = AutoComposeSong()
        autoSong.reset()
        autoSong.setTitle(title)
        autoSong.setup(genre, key, mode, cp, numPhrase, beat, userInput)
        autoSong.exportMidi(1, 'Output MIDIs/' + title + '.mid')

        self.page_factory(parent, page_type, loadpic, waitpic,
                          incontainer, outcontainer, records, autoSong)

  def playSelectedSong(self):
    song = self.getSelectedSong()
    if not song:
      return
    
    if self.songLoader:
      self.songLoader.cancel()
      # Don't start a new song loader until the previous one is finished
      if self.songLoader.isAlive():
        self.songCountdown = 256
        return

    if self.song:
      self.song.fadeout(1000)

    self.songLoader = self.engine.resource.load(self, None, lambda: Song.loadSong(self.engine, song, playbackOnly = True, library = self.library),
                                                onLoad = self.songLoaded)

 def createClient(self, libraryName, songName):
   self.libraryName     = libraryName
   self.songName        = songName
   self.stars           = 0
   self.accuracy        = 0
   self.counter         = 0
   self.showHighscores  = False
   self.highscoreIndex  = None
   self.taunt           = None
   self.uploadingScores = False
   self.nextScene       = None
   
   items = [
     (_("Replay"),            self.replay),
     (_("Change Song"),       self.changeSong),
     (_("Quit to Main Menu"), self.quit),
   ]
   self.menu = Menu(self.engine, items, onCancel = self.quit, pos = (.2, .5))
     
   self.engine.resource.load(self, "song", lambda: Song.loadSong(self.engine, songName, library = self.libraryName, notesOnly = True), onLoad = self.songLoaded)
   self.engine.loadSvgDrawing(self, "background", "keyboard.svg")
   Dialogs.showLoadingScreen(self.engine, lambda: self.song, text = _("Chilling..."))

 def libraryListLoaded(self, libraries):
   self.engine.resource.load(self, "songs",     lambda: Song.getAvailableSongs(self.engine, self.library), onLoad = self.songListLoaded)

from NoteSequence import *
from MidiNote import *

def initialSongUI():
    trackCount = raw_input('Enter track count: ')
    tempo = raw_input('Enter a tempo: ')
    key = raw_input('Enter a key: ')
    length = raw_input('Enter a song length: ')
    return (int(trackCount), int(tempo), str(key), str(length))

#Supports up to four tracks
#TODO: Make this a little more elegant
def determineVoice(currentTrackCount):
    if currentTrackCount == 0: return ALTO
    if currentTrackCount == 1: return BASS
    if currentTrackCount == 2: return SOPRANO
    if currentTrackCount == 3: return TENOR

if __name__ == '__main__':
    choices = initialSongUI()
    song = Song(choices[0],         #Track Count
                choices[1])         #Tempo
    key = choices[2]                #Key
    length = int(choices[3])        #Length
    for i in range(song.trackCount):
        seq = NoteSequence(key, determineVoice(i), length)
        seq.writeSequenceToTrack(song, i)

    song.markSongEnd()
    midi.write_midifile("example.mid", song.pattern)

 def loadCollection(self):
   self.loaded = False
   self.engine.resource.load(self, "libraries", lambda: Song.getAvailableLibraries(self.engine, self.library), onLoad = self.libraryListLoaded)
   showLoadingScreen(self.engine, lambda: self.loaded, text = _("Browsing Collection..."))