def popLayer(self, layer):
Log.debug("View: Pop: %s" % layer.__class__.__name__)
if layer in self.incoming:
self.incoming.remove(layer)
if layer in self.layers and layer not in self.outgoing:
self.outgoing.append(layer)
def disableScreensaver(self):
if os.name == 'nt':
# See the DisableScreensaver and RestoreScreensaver functions in
# modules/video_output/msw/common.c in the source code for VLC.
import win32gui
import win32con
import atexit
Log.debug('Disabling screensaver.')
old_lowpowertimeout = win32gui.SystemParametersInfo(win32con.SPI_GETLOWPOWERTIMEOUT)
if old_lowpowertimeout != 0:
atexit.register(lambda: win32gui.SystemParametersInfo(win32con.SPI_SETLOWPOWERTIMEOUT, old_lowpowertimeout))
win32gui.SystemParametersInfo(win32con.SPI_SETLOWPOWERTIMEOUT, 0)
old_powerofftimeout = win32gui.SystemParametersInfo(win32con.SPI_GETPOWEROFFTIMEOUT)
if old_powerofftimeout != 0:
atexit.register(lambda: win32gui.SystemParametersInfo(win32con.SPI_SETPOWEROFFTIMEOUT, old_powerofftimeout))
win32gui.SystemParametersInfo(win32con.SPI_SETPOWEROFFTIMEOUT, 0)
old_screensavetimeout = win32gui.SystemParametersInfo(win32con.SPI_GETSCREENSAVETIMEOUT)
if old_screensavetimeout != 0:
atexit.register(lambda: win32gui.SystemParametersInfo(win32con.SPI_SETSCREENSAVETIMEOUT, old_screensavetimeout))
win32gui.SystemParametersInfo(win32con.SPI_SETSCREENSAVETIMEOUT, 0)
else:
Log.debug('Screensaver disabling is not implemented on this platform.')
def popLayer(self, layer):
Log.debug("View: Pop: %s" % layer.__class__.__name__)
if layer in self.incoming:
self.incoming.remove(layer)
if layer in self.layers and not layer in self.outgoing:
self.outgoing.append(layer)
def loadVideo(self, libraryName, songName):
vidSource = None
if self.songStage == 1:
songBackgroundVideoPath = os.path.join(libraryName, songName,
"background.ogv")
if os.path.isfile(songBackgroundVideoPath):
vidSource = songBackgroundVideoPath
loop = False
else:
Log.warn("Video not found: %s" % songBackgroundVideoPath)
if vidSource is None:
vidSource = os.path.join(self.pathfull, "default.ogv")
loop = True
if not os.path.isfile(vidSource):
Log.warn("Video not found: %s" % vidSource)
Log.warn("Falling back to default stage mode.")
self.mode = 1 # Fallback
return
try: # Catches invalid video files or unsupported formats
Log.debug("Attempting to load video: %s" % vidSource)
self.vidPlayer = VideoLayer(self.engine,
vidSource,
mute=True,
loop=loop)
self.engine.view.pushLayer(self.vidPlayer)
except (IOError, VideoPlayerError):
self.mode = 1
Log.error(
"Failed to load song video (falling back to default stage mode):"
)
def loadVideo(self, libraryName, songName):
vidSource = None
if self.songStage == 1:
songBackgroundVideoPath = os.path.join(libraryName, songName, "background.ogv")
if os.path.isfile(songBackgroundVideoPath):
vidSource = songBackgroundVideoPath
loop = False
else:
Log.warn("Video not found: %s" % songBackgroundVideoPath)
if vidSource is None:
vidSource = os.path.join(self.pathfull, "default.ogv")
loop = True
if not os.path.isfile(vidSource):
Log.warn("Video not found: %s" % vidSource)
Log.warn("Falling back to default stage mode.")
self.mode = 1 # Fallback
return
try: # Catches invalid video files or unsupported formats
Log.debug("Attempting to load video: %s" % vidSource)
self.vidPlayer = VideoLayer(self.engine, vidSource,
mute = True, loop = loop)
self.engine.view.pushLayer(self.vidPlayer)
except (IOError, VideoPlayerError):
self.mode = 1
Log.error("Failed to load song video (falling back to default stage mode):")
def __init__(self, engine, controlnum, samprate=44100):
Task.__init__(self)
self.engine = engine
self.controlnum = controlnum
devnum = self.engine.input.controls.micDevice[controlnum]
if devnum == -1:
devnum = None
self.devname = pa.get_default_input_device_info()['name']
else:
self.devname = pa.get_device_info_by_index(devnum)['name']
self.mic = pa.open(samprate, 1, pyaudio.paFloat32, input=True, input_device_index=devnum, start=False)
self.analyzer = pypitch.Analyzer(samprate)
self.mic_started = False
self.lastPeak = 0
self.detectTaps = True
self.tapStatus = False
self.tapThreshold = -self.engine.input.controls.micTapSensitivity[controlnum]
self.passthroughQueue = []
passthroughVolume = self.engine.input.controls.micPassthroughVolume[controlnum]
if passthroughVolume > 0.0:
Log.debug('Microphone: creating passthrough stream at %d%% volume' % round(passthroughVolume * 100))
self.passthroughStream = Audio.MicrophonePassthroughStream(engine, self)
self.passthroughStream.setVolume(passthroughVolume)
else:
Log.debug('Microphone: not creating passthrough stream')
self.passthroughStream = None
def start(self):
if not self.mic_started:
self.mic_started = True
self.mic.start_stream()
self.engine.addTask(self)
Log.debug('Microphone: started %s' % self.devname)
if self.passthroughStream is not None:
Log.debug('Microphone: starting passthrough stream')
self.passthroughStream.play()
def stop(self):
if self.mic_started:
if self.passthroughStream is not None:
Log.debug('Microphone: stopping passthrough stream')
self.passthroughStream.stop()
self.engine.removeTask(self)
self.mic.stop_stream()
self.mic_started = False
Log.debug('Microphone: stopped %s' % self.devname)
def stop(self):
if self.mic_started:
if self.passthroughStream is not None:
Log.debug('Microphone: stopping passthrough stream')
self.passthroughStream.stop()
self.engine.removeTask(self)
self.mic.stop_stream()
self.mic_started = False
Log.debug('Microphone: stopped %s' % self.devname)
def start(self):
if not self.mic_started:
self.mic_started = True
self.mic.start_stream()
self.engine.addTask(self, synchronized=False)
Log.debug('Microphone: started %s' % self.devname)
if self.passthroughStream is not None:
Log.debug('Microphone: starting passthrough stream')
self.passthroughStream.play()
def getSoundObjectList(self, soundPath, soundPrefix, numSounds, soundExtension = ".ogg"): #MFH
Log.debug("{0}1{2} - {0}{1}{2} found in {3}".format(soundPrefix, numSounds, soundExtension, soundPath))
sounds = []
for i in xrange(1, numSounds+1):
filePath = os.path.join(soundPath, "%s%d%s" % (soundPrefix, i, soundExtension) )
soundObject = Sound(self.resource.fileName(filePath))
sounds.append(soundObject)
return sounds
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 showTutorial(self):
# evilynux - Make sure tutorial exists before launching
tutorialpath = self.engine.tutorialFolder
if not os.path.isdir(self.engine.resource.fileName(tutorialpath)):
Log.debug("No folder found: %s" % tutorialpath)
Dialogs.showMessage(self.engine, _("No tutorials found!"))
return
self.engine.startWorld(1, None, 0, 0, tutorial = True)
self.launchLayer(lambda: Lobby(self.engine))
def showTutorial(self):
# evilynux - Make sure tutorial exists before launching
tutorialpath = self.engine.tutorialFolder
if not os.path.isdir(self.engine.resource.fileName(tutorialpath)):
Log.debug("No folder found: %s" % tutorialpath)
Dialogs.showMessage(self.engine, _("No tutorials found!"))
return
self.engine.startWorld(1, None, 0, 0, tutorial = True)
self.launchLayer(lambda: Lobby(self.engine))
def pushLayer(self, layer):
Log.debug("View: Push: %s" % layer.__class__.__name__)
if not layer in self.layers:
self.layers.append(layer)
self.incoming.append(layer)
self.visibility[layer] = 0.0
layer.shown()
elif layer in self.outgoing:
layer.hidden()
layer.shown()
self.outgoing.remove(layer)
self.engine.addTask(layer)
def pushLayer(self, layer):
Log.debug("View: Push: %s" % layer.__class__.__name__)
if layer not in self.layers:
self.layers.append(layer)
self.incoming.append(layer)
self.visibility[layer] = 0.0
layer.shown()
elif layer in self.outgoing:
layer.hidden()
layer.shown()
self.outgoing.remove(layer)
self.engine.addTask(layer)
def init_oneshot(self):
""" Determine if oneshot mode is valid. """
# I think this code can be moved elsewhere...
self.engine.cmdPlay = 0
# Check for a valid invocation of one-shot mode.
if self.playing is not None:
Log.debug("Validating song directory for one-shot mode.")
library = Config.get("setlist", "base_library")
basefolder = os.path.join(Version.dataPath(), library, "songs", self.playing)
if not os.path.exists(os.path.join(basefolder, "song.ini")):
if not (
os.path.exists(os.path.join(basefolder, "notes.mid"))
or os.path.exists(os.path.join(basefolder, "notes-unedited.mid"))
):
if not (
os.path.exists(os.path.join(basefolder, "song.ogg"))
or os.path.exists(os.path.join(basefolder, "guitar.ogg"))
):
Log.warn(
"Song directory provided ('%s') is not a valid song directory. Starting up FoFiX in standard mode."
% self.playing
)
self.engine.startupMessages.append(
_(
"Song directory provided ('%s') is not a valid song directory. Starting up FoFiX in standard mode."
)
% self.playing
)
return
# Set up one-shot mode
Log.debug("Entering one-shot mode.")
Config.set("setlist", "selected_song", playing)
self.engine.cmdPlay = 1
if diff is not None:
self.engine.cmdDiff = int(diff)
if part is not None:
self.engine.cmdPart = int(part)
if players == 1:
self.engine.cmdMode = players, mode, 0
else:
self.engine.cmdMode = players, 0, mode
def __init__(self, name, number):
self.logClassInits = Config.get("game", "log_class_inits")
if self.logClassInits == 1:
Log.debug("Player class init (Player.py)...")
self.name = name
self.reset()
self.keyList = None
self.progressKeys = []
self.drums = []
self.keys = []
self.soloKeys = []
self.soloShift = None
self.soloSlide = False
self.actions = []
self.yes = []
self.no = []
self.conf = []
self.up = []
self.down = []
self.left = []
self.right = []
self.controller = -1
self.controlType = -1
self.guitarNum = None
self.number = number
self.bassGrooveEnabled = False
self.currentTheme = 1
self.lefty = _playerDB.execute('SELECT `lefty` FROM `players` WHERE `name` = ?', [self.name]).fetchone()[0]
self.twoChordMax = _playerDB.execute('SELECT `twochord` FROM `players` WHERE `name` = ?', [self.name]).fetchone()[0]
self.drumflip = _playerDB.execute('SELECT `drumflip` FROM `players` WHERE `name` = ?', [self.name]).fetchone()[0]
self.assistMode = _playerDB.execute('SELECT `assist` FROM `players` WHERE `name` = ?', [self.name]).fetchone()[0]
self.autoKick = _playerDB.execute('SELECT `autokick` FROM `players` WHERE `name` = ?', [self.name]).fetchone()[0]
self.neck = _playerDB.execute('SELECT `neck` FROM `players` WHERE `name` = ?', [self.name]).fetchone()[0]
self.neckType = _playerDB.execute('SELECT `necktype` FROM `players` WHERE `name` = ?', [self.name]).fetchone()[0]
self.whichPart = _playerDB.execute('SELECT `part` FROM `players` WHERE `name` = ?', [self.name]).fetchone()[0]
self._upname = _playerDB.execute('SELECT `upname` FROM `players` WHERE `name` = ?', [self.name]).fetchone()[0]
self._difficulty = _playerDB.execute('SELECT `difficulty` FROM `players` WHERE `name` = ?', [self.name]).fetchone()[0]
#MFH - need to store selected practice mode and start position here
self.practiceMode = False
self.practiceSpeed = 1.0
self.practiceSection = None
self.startPos = 0.0
self.hopoFreq = None
def init_oneshot(self):
''' Determine if oneshot mode is valid. '''
# I think this code can be moved elsewhere...
self.engine.cmdPlay = 0
# Check for a valid invocation of one-shot mode.
if self.playing is not None:
Log.debug('Validating song directory for one-shot mode.')
library = Config.get("setlist", "base_library")
basefolder = os.path.join(Version.dataPath(), library, "songs",
self.playing)
if not os.path.exists(os.path.join(basefolder, "song.ini")):
if not (os.path.exists(os.path.join(basefolder, "notes.mid"))
or os.path.exists(
os.path.join(basefolder, "notes-unedited.mid"))):
if not (os.path.exists(os.path.join(
basefolder, "song.ogg")) or os.path.exists(
os.path.join(basefolder, "guitar.ogg"))):
Log.warn(
"Song directory provided ('%s') is not a valid song directory. Starting up FoFiX in standard mode."
% self.playing)
self.engine.startupMessages.append(
_("Song directory provided ('%s') is not a valid song directory. Starting up FoFiX in standard mode."
) % self.playing)
return
# Set up one-shot mode
Log.debug('Entering one-shot mode.')
Config.set("setlist", "selected_song", playing)
self.engine.cmdPlay = 1
if diff is not None:
self.engine.cmdDiff = int(diff)
if part is not None:
self.engine.cmdPart = int(part)
if players == 1:
self.engine.cmdMode = players, mode, 0
else:
self.engine.cmdMode = players, 0, mode
def gcDump(self):
before = len(gc.get_objects())
coll = gc.collect()
after = len(gc.get_objects())
Log.debug("%d GC objects collected, total %d -> %d." % (coll, before, after))
fn = "gcdump.txt"
f = open(fn, "w")
n = 0
gc.collect()
for obj in gc.garbage:
try:
print >>f, obj
n += 1
except:
pass
f.close()
Log.debug("Wrote a dump of %d GC garbage objects to %s." % (n, fn))
def loadTex2D(self, fname, type = GL_RGB):
file = os.path.join(self.workdir,fname)
if os.path.exists(file):
img = pygame.image.load(file)
noise = pygame.image.tostring(img, "RGB")
else:
Log.debug("Can't load %s; generating random 2D noise instead." % fname)
return self.makeNoise2D(16)
texture = 0
glBindTexture(GL_TEXTURE_2D, texture)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexImage2D(GL_TEXTURE_2D, 0, 1, img.get_width(), img.get_height(), 0, type, GL_UNSIGNED_BYTE, noise)
return texture
def open(self, frequency = 22050, bits = 16, stereo = True, bufferSize = 1024):
try:
pygame.mixer.quit()
except:
pass
try:
pygame.mixer.init(frequency, -bits, stereo and 2 or 1, bufferSize)
except:
Log.warn("Audio setup failed. Trying with default configuration.")
pygame.mixer.init()
Log.debug("Audio configuration: %s" % str(pygame.mixer.get_init()))
#myfingershurt: ensuring we have enough audio channels!
pygame.mixer.set_num_channels(10)
return True
def open(self, frequency = 22050, bits = 16, stereo = True, bufferSize = 1024):
try:
pygame.mixer.quit()
except:
pass
try:
pygame.mixer.init(frequency, -bits, stereo and 2 or 1, bufferSize)
except:
Log.warn("Audio setup failed. Trying with default configuration.")
pygame.mixer.init()
Log.debug("Audio configuration: %s" % str(pygame.mixer.get_init()))
#myfingershurt: ensuring we have enough audio channels!
pygame.mixer.set_num_channels(10)
return True
def make(self, fname, name = ""):
"""Compile a shader.
fname = base filename for shader files
name = name to use for this shader (defaults to fname)
Returns nothing, or raises an exception on error."""
if name == "":
name = fname
fullname = os.path.join(self.workdir, fname)
vertname, fragname = fullname+".vert", fullname+".frag"
Log.debug('Compiling shader "%s" from %s and %s.' % (name, vertname, fragname))
program = self.compile(open(vertname), open(fragname))
sArray = {"program": program, "name": name, "textures": []}
self.getVars(vertname, program, sArray)
self.getVars(fragname, program, sArray)
self.shaders[name] = sArray
if "Noise3D" in self.shaders[name]:
self.setTexture("Noise3D",self.noise3D,name)
def loadTex2D(self, fname, type=GL_RGB):
file = os.path.join(self.workdir, fname)
if os.path.exists(file):
img = pygame.image.load(file)
noise = pygame.image.tostring(img, "RGB")
else:
Log.debug("Can't load %s; generating random 2D noise instead." %
fname)
return self.makeNoise2D(16)
texture = 0
glBindTexture(GL_TEXTURE_2D, texture)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexImage2D(GL_TEXTURE_2D, 0, 1, img.get_width(), img.get_height(), 0,
type, GL_UNSIGNED_BYTE, noise)
return texture
def make(self, fname, name=""):
"""Compile a shader.
fname = base filename for shader files
name = name to use for this shader (defaults to fname)
Returns nothing, or raises an exception on error."""
if name == "":
name = fname
fullname = os.path.join(self.workdir, fname)
vertname, fragname = fullname + ".vert", fullname + ".frag"
Log.debug('Compiling shader "%s" from %s and %s.' %
(name, vertname, fragname))
program = self.compile(open(vertname), open(fragname))
sArray = {"program": program, "name": name, "textures": []}
self.getVars(vertname, program, sArray)
self.getVars(fragname, program, sArray)
self.shaders[name] = sArray
if self.shaders[name].has_key("Noise3D"):
self.setTexture("Noise3D", self.noise3D, name)
def loadTex3D(self, fname, type = GL_RED):
file = os.path.join(self.workdir,fname)
if os.path.exists(file):
noise = open(file).read()
size = int(len(noise)**(1/3.0))
else:
Log.debug("Can't load %s; generating random 3D noise instead." % file)
return self.makeNoise3D(16)
texture = 0
glBindTexture(GL_TEXTURE_3D_EXT, texture)
glTexParameterf(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_S, GL_REPEAT)
glTexParameterf(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_T, GL_REPEAT)
glTexParameterf(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_R_EXT, GL_REPEAT)
glTexParameterf(GL_TEXTURE_3D_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameterf(GL_TEXTURE_3D_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexImage3DEXT(GL_TEXTURE_3D_EXT, 0, 1,size, size, size, 0, type, GL_UNSIGNED_BYTE, noise)
return texture
def loadTex3D(self, fname, type=GL_RED):
file = os.path.join(self.workdir, fname)
if os.path.exists(file):
noise = open(file).read()
size = int(len(noise)**(1 / 3.0))
else:
Log.debug("Can't load %s; generating random 3D noise instead." %
file)
return self.makeNoise3D(16)
texture = 0
glBindTexture(GL_TEXTURE_3D_EXT, texture)
glTexParameterf(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_S, GL_REPEAT)
glTexParameterf(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_T, GL_REPEAT)
glTexParameterf(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_R_EXT, GL_REPEAT)
glTexParameterf(GL_TEXTURE_3D_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameterf(GL_TEXTURE_3D_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexImage3DEXT(GL_TEXTURE_3D_EXT, 0, 1, size, size, size, 0, type,
GL_UNSIGNED_BYTE, noise)
return texture
def getImgDrawing(self, fileName, openImage=True):
imgDrawing = None
for dataPath in self.resource.dataPaths:
fileName1 = os.path.join(dataPath, fileName)
if self.logLoadings == 1:
if openImage:
Log.notice("Trying to load image: %s" % fileName1)
else:
Log.notice("Checking image: %s" % fileName1)
#check if fileName1 exists (has extension)
if os.path.exists(fileName1):
if openImage:
try:
imgDrawing = ImgDrawing(self.svg, fileName1)
return imgDrawing
except IOError:
Log.warn("Unable to load image file: %s" % fileName1)
except OverflowError:
Log.warn("Unable to read image file: %s" % fileName1)
else:
return True
else:
#find extension
fileName1 = os.path.splitext(fileName1)[0]
files = glob.glob('%s.*' % fileName1)
if openImage:
for i in range(len(files)):
try:
imgDrawing = ImgDrawing(self.svg, files[i])
return imgDrawing
except IOError:
Log.warn("Unable to load image file: %s" %
files[i])
elif len(files) > 0:
return True
#image not found
if self.logImageNotFound:
Log.debug("Image not found: %s" % fileName)
return False
def getImgDrawing(self, fileName, openImage=True):
imgDrawing = None
for dataPath in self.resource.dataPaths:
fileName1 = os.path.join(dataPath, fileName)
if self.logLoadings == 1:
if openImage:
Log.notice("Trying to load image: %s" % fileName1)
else:
Log.notice("Checking image: %s" % fileName1)
#check if fileName1 exists (has extension)
if os.path.exists(fileName1):
if openImage == True:
try:
imgDrawing = ImgDrawing(self.svg, fileName1)
return imgDrawing
except IOError:
Log.warn("Unable to load image file: %s" % fileName1)
except OverflowError:
Log.warn("Unable to read image file: %s" % fileName1)
else:
return True
else:
#find extension
fileName1 = os.path.splitext(fileName1)[0]
files = glob.glob('%s.*' % fileName1)
if openImage == True:
for i in range(len(files)):
try:
imgDrawing = ImgDrawing(self.svg, files[i])
return imgDrawing
except IOError:
Log.warn("Unable to load image file: %s" % files[i])
elif len(files) > 0:
return True
#image not found
if self.logImageNotFound:
Log.debug("Image not found: %s" % fileName)
return False
def __init__(self, engine, controlnum, samprate=44100):
Task.__init__(self)
self.engine = engine
self.controlnum = controlnum
devnum = self.engine.input.controls.micDevice[controlnum]
if devnum == -1:
devnum = None
self.devname = pa.get_default_input_device_info()['name']
else:
self.devname = pa.get_device_info_by_index(devnum)['name']
self.mic = pa.open(samprate,
1,
pyaudio.paFloat32,
input=True,
input_device_index=devnum,
start=False)
self.analyzer = pypitch.Analyzer(samprate)
self.mic_started = False
self.lastPeak = 0
self.detectTaps = True
self.tapStatus = False
self.tapThreshold = -self.engine.input.controls.micTapSensitivity[
controlnum]
self.passthroughQueue = []
passthroughVolume = self.engine.input.controls.micPassthroughVolume[
controlnum]
if passthroughVolume > 0.0:
Log.debug(
'Microphone: creating passthrough stream at %d%% volume' %
round(passthroughVolume * 100))
self.passthroughStream = Audio.MicrophonePassthroughStream(
engine, self)
self.passthroughStream.setVolume(passthroughVolume)
else:
Log.debug('Microphone: not creating passthrough stream')
self.passthroughStream = None
def __init__(self, engine, instrument, playerObj):
self.engine = engine
self.player = instrument.player
self.instrument = instrument
self.isDrum = self.instrument.isDrum
self.isBassGuitar = self.instrument.isBassGuitar
self.isVocal = self.instrument.isVocal
self.oNeckovr = None #MFH - needs to be here to prevent crashes!
self.staticStrings = self.engine.config.get("performance", "static_strings")
self.indexFps = self.engine.config.get("video", "fps") #QQstarS
self.neckAlpha=[] # necks transparency
self.neckAlpha.append( self.engine.config.get("game", "necks_alpha") ) # all necks
self.neckAlpha.append( self.neckAlpha[0] * self.engine.config.get("game", "neck_alpha") ) # normal neck
self.neckAlpha.append( self.neckAlpha[0] * self.engine.config.get("game", "solo_neck_alpha") ) # solo neck
self.neckAlpha.append( self.neckAlpha[0] * self.engine.config.get("game", "bg_neck_alpha") ) # bass groove neck
self.neckAlpha.append( self.neckAlpha[0] * self.engine.config.get("game", "overlay_neck_alpha") ) # overlay neck
self.neckAlpha.append( self.neckAlpha[0] * self.engine.config.get("game", "fail_neck_alpha") ) # fail neck
self.neckAlpha.append( self.neckAlpha[0] * self.engine.config.get("game", "4x_neck_alpha") ) # 4x multi neck
self.boardWidth = self.engine.theme.neckWidth
self.boardLength = self.engine.theme.neckLength
self.shaderSolocolor = self.engine.theme.shaderSolocolor
self.boardFadeAmount = self.engine.theme.boardFade
self.doNecksRender = self.engine.theme.doNecksRender
#death_au: fixed neck size
if self.isDrum and self.engine.config.get("game", "large_drum_neck"):
self.boardWidth = 4.0
self.boardLength = 12.0
self.beatsPerBoard = 5.0
self.beatsPerUnit = self.beatsPerBoard / self.boardLength
color = (1,1,1)
self.vis = 1
size = 0
# evilynux - Neck color
self.board_col = np.array([[color[0],color[1],color[2], 0],
[color[0],color[1],color[2], 0],
[color[0],color[1],color[2], self.vis],
[color[0],color[1],color[2], self.vis],
[color[0],color[1],color[2], self.vis],
[color[0],color[1],color[2], self.vis],
[color[0],color[1],color[2], 0],
[color[0],color[1],color[2], 0]], dtype=np.float32)
w = self.boardWidth
l = self.boardLength
# evilynux - Neck vertices
self.board_vtx = np.array([[-w / 2, 0, -2],
[w / 2, 0, -2],
[-w/ 2, 0, -1],
[w / 2, 0, -1],
[-w / 2, 0, l * .7],
[w / 2, 0, l * .7],
[-w / 2, 0, l],
[w / 2, 0, l]], dtype=np.float32)
self.shader_neck_vtx = np.array([[-w / 2, 0.1, -2],
[w / 2, 0.1, -2],
[-w / 2, 0.1, l],
[w / 2, 0.1, l]], dtype=np.float32)
self.track_vtx = np.array([[-w / 2, 0, -2+size],
[w / 2, 0, -2+size],
[-w / 2, 0, -1+size],
[w / 2, 0, -1+size],
[-w / 2, 0, l * .7],
[w / 2, 0, l * .7],
[-w / 2, 0, l],
[w / 2, 0, l]], dtype=np.float32)
self.soloLightVtx1 = np.array([[w / 2-1.0, 0.4, -2],
[w / 2+1.0, 0.4, -2],
[w / 2-1.0, 0.4, l],
[w / 2+1.0, 0.4, l]], dtype=np.float32)
self.soloLightVtx2 = np.array([[-w / 2+1.0, 0.4, -2],
[-w / 2-1.0, 0.4, -2],
[-w / 2+1.0, 0.4, l],
[-w / 2-1.0, 0.4, l]], dtype=np.float32)
self.bpm_vtx = np.array([[-(w / 2), 0, 0],
[-(w / 2), 0, 0],
[(w / 2), 0, 0],
[(w / 2), 0, 0]], dtype=np.float32)
self.board_scroll_vtx = np.array([[-w / 2, 0, 0],
[w / 2, 0, 0],
[-w/ 2, 0, 0],
[w / 2, 0, 0],
[-w/ 2, 0, 0],
[w / 2, 0, 0],
[-w/ 2, 0, 0],
[w / 2, 0, 0]], dtype=np.float32)
# evilynux - Sidebars vertices
w += 0.15
self.sidebars_vtx = np.array([[-w / 2, 0, -2],
[w / 2, 0, -2],
[-w/ 2, 0, -1],
[w / 2, 0, -1],
[-w / 2, 0, l * .7],
[w / 2, 0, l * .7],
[-w / 2, 0, l],
[w / 2, 0, l]], dtype=np.float32)
self.sidebars_scroll_vtx = np.array([[-w / 2, 0, 0],
[w / 2, 0, 0],
[-w/ 2, 0, 0],
[w / 2, 0, 0],
[-w/ 2, 0, 0],
[w / 2, 0, 0],
[-w/ 2, 0, 0],
[w / 2, 0, 0]], dtype=np.float32)
self.bpm_tex = np.array([[0.0, 1.0],
[0.0, 0.0],
[1.0, 1.0],
[1.0, 0.0]], dtype=np.float32)
self.bpm_col = np.array([[1, 1, 1, self.vis],
[1, 1, 1, self.vis],
[1, 1, 1, self.vis],
[1, 1, 1, self.vis]], dtype=np.float32)
self.board_col_flash = np.array([[color[0],color[1],color[2], 0],
[color[0],color[1],color[2], 0],
[color[0],color[1],color[2], self.vis],
[color[0],color[1],color[2], self.vis],
[color[0],color[1],color[2], self.vis],
[color[0],color[1],color[2], self.vis],
[color[0],color[1],color[2], 0],
[color[0],color[1],color[2], 0]], dtype=np.float32)
self.board_tex_static = np.array([[0.0, self.project(-2 * self.beatsPerUnit)],
[1.0, self.project(-2 * self.beatsPerUnit)],
[0.0, self.project(-1 * self.beatsPerUnit)],
[1.0, self.project(-1 * self.beatsPerUnit)],
[0.0, self.project(l * self.beatsPerUnit * .7)],
[1.0, self.project(l * self.beatsPerUnit * .7)],
[0.0, self.project(l * self.beatsPerUnit)],
[1.0, self.project(l * self.beatsPerUnit)]], dtype=np.float32)
self.board_tex = np.array([[0.0, 0],
[1.0, 0],
[0.0, 0],
[1.0, 0],
[0.0, 0],
[1.0, 0],
[0.0, 0],
[1.0, 0]], dtype=np.float32)
# evilynux - Just in case the type has became double, convert to float32
self.board_col = self.board_col.astype(np.float32)
self.board_vtx = self.board_vtx.astype(np.float32)
self.sidebars_vtx = self.sidebars_vtx.astype(np.float32)
self.sidebars_scroll_vtx = self.sidebars_scroll_vtx.astype(np.float32)
self.bpm_tex = self.bpm_tex.astype(np.float32)
self.bpm_col = self.bpm_col.astype(np.float32)
self.soloLightVtx1 = self.soloLightVtx1.astype(np.float32)
self.soloLightVtx2 = self.soloLightVtx2.astype(np.float32)
self.shader_neck_vtx = self.shader_neck_vtx.astype(np.float32)
self.track_vtx = self.track_vtx.astype(np.float32)
self.board_col_flash = self.board_col_flash.astype(np.float32)
self.bpm_vtx = self.bpm_vtx.astype(np.float32)
self.board_tex_static = self.board_tex_static.astype(np.float32)
self.board_tex = self.board_tex.astype(np.float32)
self.board_scroll_vtx = self.board_scroll_vtx.astype(np.float32)
self.neckType = playerObj.neckType
if self.neckType == 0:
self.neck = engine.mainMenu.chosenNeck
else:
self.neck = str(playerObj.neck)
playerObj = None
#Get theme
themename = self.engine.data.themeLabel
#now theme determination logic is only in data.py:
self.theme = self.engine.data.theme
self.incomingNeckMode = self.engine.config.get("game", "incoming_neck_mode")
#blazingamer
self.failcount = 0
self.failcount2 = False
self.spcount = 0
self.spcount2 = 0
self.bgcount = 0
self.fourXcount = 0
self.ovrneckoverlay = self.engine.config.get("fretboard", "ovrneckoverlay")
self.ocount = 0
self.currentPeriod = 60000.0 / self.instrument.currentBpm
self.lastBpmChange = -1.0
self.baseBeat = 0.0
#myfingershurt:
self.bassGrooveNeckMode = self.engine.config.get("game", "bass_groove_neck")
self.guitarSoloNeckMode = self.engine.config.get("game", "guitar_solo_neck")
self.fourxNeckMode = self.engine.config.get("game", "4x_neck")
self.useMidiSoloMarkers = False
self.markSolos = 0
neckFind = True
themeNeckPath = os.path.join(self.engine.resource.fileName("themes", themename, "necks"))
if self.neckType == 1 and os.path.exists(themeNeckPath):
themeNeck = []
neckfiles = [ f for f in os.listdir(themeNeckPath) if os.path.isfile(os.path.join(themeNeckPath, f)) ]
neckfiles.sort()
for i in neckfiles:
themeNeck.append(str(i))
if len(themeNeck) > 0:
i = random.randint(0,len(themeNeck)-1)
if engine.loadImgDrawing(self, "neckDrawing", os.path.join("themes", themename, "necks", themeNeck[i]), textureSize = (256, 256)):
neckFind = False
Log.debug("Random theme neck chosen: " + themeNeck[i])
else:
Log.error("Unable to load theme neck: " + themeNeck[i])
# fall back to defaultneck
self.neck = "defaultneck"
if neckFind:
# evilynux - Fixed random neck -- MFH: further fixing random neck
if self.neck == "0" or self.neck == "Neck_0" or self.neck == "randomneck":
self.neck = []
# evilynux - improved loading logic to support arbitrary filenames
path = self.engine.resource.fileName("necks")
neckfiles = [ f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f)) ]
neckfiles.sort()
for i in neckfiles:
# evilynux - Special cases, ignore these...
if( os.path.splitext(i)[0] == "randomneck" or os.path.splitext(i)[0] == "overdriveneck" ):
continue
else:
self.neck.append(str(i)[:-4]) # evilynux - filename w/o extension
i = random.randint(0,len(self.neck)-1)
if engine.loadImgDrawing(self, "neckDrawing", os.path.join("necks",self.neck[i]+".png"), textureSize = (256, 256)):
Log.debug("Random neck chosen: " + self.neck[i])
else:
Log.error("Unable to load neck: " + self.neck[i])
self.neck = "defaultneck"
engine.loadImgDrawing(self, "neckDrawing", os.path.join("necks",self.neck+".png"), textureSize = (256, 256))
else:
# evilynux - first assume the self.neck contains the full filename
if not engine.loadImgDrawing(self, "neckDrawing", os.path.join("necks",self.neck+".png"), textureSize = (256, 256)):
if not engine.loadImgDrawing(self, "neckDrawing", os.path.join("necks","Neck_"+self.neck+".png"), textureSize = (256, 256)):
engine.loadImgDrawing(self, "neckDrawing", os.path.join("necks","defaultneck.png"), textureSize = (256, 256))
#blazingamer:
#this helps me clean up the code a bit
#what it does is if you're using drums or bass
#it checks that directory first, if it doesn't
#exist, then it goes back to the default directory
if self.isDrum:
self.extension = "drums"
elif self.isBassGuitar:
self.extension = "bass"
else:
self.extension = None
themepath = os.path.join("themes", themename, "board")
def loadImage(name, file):
if self.extension:
if not engine.loadImgDrawing(self, name, os.path.join(themepath, self.extension, file)):
engine.loadImgDrawing(self, name, os.path.join(themepath, file))
else:
engine.loadImgDrawing(self, name, os.path.join(themepath, file))
loadImage("sideBars", "side_bars.png")
loadImage("oSideBars", "overdrive_side_bars.png")
loadImage("oSoloSideBars", "overdrive_solo_side_bars.png")
loadImage("failSideBars", "fail_side_bars.png")
loadImage("soloSideBars", "solo_side_bars.png")
loadImage("oCenterLines", "overdrive_center_lines.png")
loadImage("centerLines", "center_lines.png")
loadImage("oNeck", "overdriveneck.png")
loadImage("oFlash", "overdrive_string_flash.png")
loadImage("bpm_halfbeat", "bpm_halfbeat.png")
loadImage("bpm_beat", "bpm_beat.png")
loadImage("bpm_measure", "bpm_measure.png")
loadImage("failNeck", "failneck.png")
if not self.failNeck:
engine.loadImgDrawing(self, "failNeck", os.path.join("failneck.png"))
if self.ovrneckoverlay:
loadImage("oNeckovr", "overdriveneckovr.png")
#myfingershurt: Bass Groove neck:
self.bassGrooveNeck = None
if self.isBassGuitar and self.bassGrooveNeckMode > 0:
if self.bassGrooveNeckMode == 2: #overlay neck
engine.loadImgDrawing(self, "bassGrooveNeck", os.path.join(themepath, "bass", "bassgrooveneckovr.png"))
if self.bassGrooveNeckMode == 1 or not self.bassGrooveNeck: #replace neck
engine.loadImgDrawing(self, "bassGrooveNeck", os.path.join(themepath, "bass", "bassgrooveneck.png"))
#myfingershurt: Guitar Solo neck:
self.soloNeck = None
if not self.isVocal:
if self.guitarSoloNeckMode > 0:
if self.guitarSoloNeckMode == 1 or not engine.loadImgDrawing(self, "soloNeck", os.path.join(themepath, "soloneckovr.png")): #replace neck
loadImage("soloNeck", "soloneck.png")
elif self.guitarSoloNeckMode == 2 or not engine.loadImgDrawing(self, "soloNeck", os.path.join(themepath, "soloneck.png")): #overlay neck
loadImage("soloNeck", "soloneckovr.png")
self.fourMultiNeck = None
if not self.isBassGuitar and self.fourxNeckMode > 0:
if self.fourxNeckMode == 1: #replace neck
engine.loadImgDrawing(self, "fourMultiNeck", os.path.join(themepath, "fourmultineck.png"))
if self.fourxNeckMode == 2: #overlay neck
engine.loadImgDrawing(self, "fourMultiNeck", os.path.join(themepath, "fourmultineckovr.png"))
self.isFailing = False
self.canGuitarSolo = self.instrument.canGuitarSolo
self.guitarSolo = False
self.scoreMultiplier = 1
self.overdriveFlashCounts = self.indexFps/4 #how many cycles to display the oFlash: self.indexFps/2 = 1/2 second
self.overdriveFlashCount = self.overdriveFlashCounts
self.ocount = 0
self.paused = False
def prepareSetlist(self, songs):
if self.songLoader:
self.songLoader.stop()
msg = self.engine.setlistMsg
self.engine.setlistMsg = None
self.selectedIndex = 0
if self.listingMode == 0 or self.careerMode:
self.items = self.libraries + self.songs
else:
self.items = self.songs
self.itemRenderAngles = [0.0] * len(self.items)
self.itemLabels = [None] * len(self.items)
self.searching = False
self.searchText = ""
shownItems = []
for item in self.items: #remove things we don't want to see. Some redundancy, but that's okay.
if isinstance(item, Song.TitleInfo) or isinstance(item, Song.SortTitleInfo):
if self.showCareerTiers == 2:
if isinstance(item, Song.TitleInfo):
if len(shownItems) > 0:
if isinstance(shownItems[-1], Song.TitleInfo):
shownItems.pop()
shownItems.append(item)
elif isinstance(item, Song.SortTitleInfo):
continue
else:
if isinstance(item, Song.TitleInfo):
continue
elif isinstance(item, Song.SortTitleInfo):
if not self.showSortTiers:
continue
if len(shownItems) > 0:
if isinstance(shownItems[-1], Song.SortTitleInfo):
shownItems.pop()
shownItems.append(item)
elif isinstance(item, Song.SongInfo):
if self.careerMode and (not self.showLockedSongs) and item.getLocked():
continue
else:
shownItems.append(item)
else:
shownItems.append(item)
if len(shownItems) > 0:
if isinstance(shownItems[-1], Song.TitleInfo) or isinstance(shownItems[-1], Song.SortTitleInfo):
shownItems.pop()
if len(self.items) > 0 and len(shownItems) == 0:
msg = _("No songs in this setlist are available to play!")
if self.careerMode:
msg = msg + " " + _("Make sure you have a working career pack!")
Dialogs.showMessage(self.engine, msg)
elif len(shownItems) > 0:
for item in shownItems:
if isinstance(item, Song.SongInfo) or isinstance(item, Song.LibraryInfo):
self.items = shownItems #make sure at least one item is selectable
break
else:
msg = _("No songs in this setlist are available to play!")
if self.careerMode:
msg = msg + " " + _("Make sure you have a working career pack!")
Dialogs.showMessage(self.engine, msg)
self.items = []
if self.items == []: #MFH: Catch when there ain't a damn thing in the current folder - back out!
if self.library != Song.DEFAULT_LIBRARY:
Dialogs.hideLoadingSplashScreen(self.engine, self.splash)
self.splash = None
self.startingSelected = self.library
self.library = os.path.dirname(self.library)
self.selectedItem = None
self.loadLibrary()
return
Log.debug("Setlist loaded.")
self.loaded = True
if self.setlistStyle == 1:
for i in range(self.headerSkip):
self.items.insert(0, Song.BlankSpaceInfo())
for i in range(self.footerSkip):
self.items.append(Song.BlankSpaceInfo())
if self.startingSelected is not None:
for i, item in enumerate(self.items):
if isinstance(item, Song.SongInfo) and self.startingSelected == item.songName: #TODO: SongDB
self.selectedIndex = i
break
elif isinstance(item, Song.LibraryInfo) and self.startingSelected == item.libraryName:
self.selectedIndex = i
break
for item in self.items:
if isinstance(item, Song.SongInfo):
item.name = Song.removeSongOrderPrefixFromName(item.name) #TODO: I don't like this.
elif not self.tiersPresent and (isinstance(item, Song.TitleInfo) or isinstance(item, Song.SortTitleInfo)):
self.tiersPresent = True
while isinstance(self.items[self.selectedIndex], Song.BlankSpaceInfo) or ((isinstance(self.items[self.selectedIndex], Song.TitleInfo) or isinstance(self.items[self.selectedIndex], Song.SortTitleInfo)) and not self.selectTiers):
self.selectedIndex += 1
if self.selectedIndex >= len(self.items):
self.selectedIndex = 0
self.itemRenderAngles = [0.0] * len(self.items)
self.itemLabels = [None] * len(self.items)
if self.preloadSongLabels:
for i in range(len(self.items)):
self.loadStartTime = time.time()
Dialogs.changeLoadingSplashScreenText(self.engine, self.splash, _("Loading Album Artwork..."))
self.loadItemLabel(i, preload = True)
self.updateSelection()
Dialogs.hideLoadingSplashScreen(self.engine, self.splash)
self.splash = None
def __init__(self):
self.logClassInits = Config.get("game", "log_class_inits")
if self.logClassInits == 1:
Log.debug("Input class init (Input.py)...")
Task.__init__(self)
self.mouse = pygame.mouse
self.mouseListeners = []
self.keyListeners = []
self.systemListeners = []
self.priorityKeyListeners = []
self.controls = Controls()
self.activeGameControls = []
self.p2Nav = self.controls.p2Nav
self.type1 = self.controls.type[0]
self.keyCheckerMode = Config.get("game","key_checker_mode")
self.disableKeyRepeat()
self.gameGuitars = 0
self.gameDrums = 0
self.gameMics = 0
self.gameBots = 0
# Initialize joysticks
pygame.joystick.init()
self.joystickNames = {}
self.joystickAxes = {}
self.joystickHats = {}
self.joysticks = [pygame.joystick.Joystick(id) for id in range(pygame.joystick.get_count())]
for j in self.joysticks:
j.init()
self.joystickNames[j.get_id()] = j.get_name()
self.joystickAxes[j.get_id()] = [0] * j.get_numaxes()
self.joystickHats[j.get_id()] = [(0, 0)] * j.get_numhats()
Log.debug("%d joysticks found." % len(self.joysticks))
# Enable music events
Audio.Music.setEndEvent(MusicFinished)
#Audio.Music.setEndEvent() #MFH - no event required?
# Custom key names
self.getSystemKeyName = pygame.key.name
pygame.key.name = self.getKeyName
self.midi = []
if haveMidi:
pygame.midi.init()
for i in range(pygame.midi.get_count()):
interface, name, is_input, is_output, is_opened = pygame.midi.get_device_info(i)
Log.debug("Found MIDI device: %s on %s" % (name, interface))
if not is_input:
Log.debug("MIDI device is not an input device.")
continue
try:
self.midi.append(pygame.midi.Input(i))
Log.debug("Device opened as device number %d." % len(self.midi))
except pygame.midi.MidiException:
Log.error("Error opening device for input.")
if len(self.midi) == 0:
Log.debug("No MIDI input ports found.")
else:
Log.notice("MIDI input support is not available; install at least pygame 1.9 to get it.")
def __init__(self, engine):
self.engine = engine
self.logClassInits = Config.get("game", "log_class_inits")
if self.logClassInits == 1:
Log.debug("MainMenu class init (MainMenu.py)...")
self.time = 0.0
self.nextLayer = None
self.visibility = 0.0
self.active = False
self.showStartupMessages = False
self.gfxVersionTag = Config.get("game", "gfx_version_tag")
self.chosenNeck = Config.get("game", "default_neck")
exists = 0
if engine.loadImgDrawing(self, "ok", os.path.join("necks",self.chosenNeck+".png")):
exists = 1
elif engine.loadImgDrawing(self, "ok", os.path.join("necks","Neck_"+self.chosenNeck+".png")):
exists = 1
#MFH - fallback logic now supports a couple valid default neck filenames
#MFH - check for Neck_1
if exists == 0:
if engine.loadImgDrawing(self, "ok", os.path.join("necks","Neck_1.png")):
Config.set("game", "default_neck", "1")
Log.warn("Default chosen neck not valid; fallback Neck_1.png forced.")
exists = 1
#MFH - check for defaultneck
if exists == 0:
if engine.loadImgDrawing(self, "ok", os.path.join("necks","defaultneck.png")):
Log.warn("Default chosen neck not valid; fallback defaultneck.png forced.")
Config.set("game", "default_neck", "defaultneck")
exists = 1
else:
Log.error("Default chosen neck not valid; fallbacks Neck_1.png and defaultneck.png also not valid!")
#Get theme
self.theme = self.engine.data.theme
self.themeCoOp = self.engine.data.themeCoOp
self.themename = self.engine.data.themeLabel
self.useSoloMenu = self.engine.theme.use_solo_submenu
allowMic = True
self.menux = self.engine.theme.menuPos[0]
self.menuy = self.engine.theme.menuPos[1]
self.rbmenu = self.engine.theme.menuRB
#MFH
self.main_menu_scale = self.engine.theme.main_menu_scaleVar
self.main_menu_vspacing = self.engine.theme.main_menu_vspacingVar
if not self.engine.loadImgDrawing(self, "background", os.path.join("themes",self.themename,"menu","mainbg.png")):
self.background = None
self.engine.loadImgDrawing(self, "BGText", os.path.join("themes",self.themename,"menu","maintext.png"))
self.engine.loadImgDrawing(self, "optionsBG", os.path.join("themes",self.themename,"menu","optionsbg.png"))
self.engine.loadImgDrawing(self, "optionsPanel", os.path.join("themes",self.themename,"menu","optionspanel.png"))
#racer: added version tag
if self.gfxVersionTag or self.engine.theme.versiontag:
if not self.engine.loadImgDrawing(self, "version", os.path.join("themes",self.themename,"menu","versiontag.png")):
if not self.engine.loadImgDrawing(self, "version", "versiontag.png"): #falls back on default versiontag.png in data\ folder
self.version = None
else:
self.version = None
#myfingershurt: random main menu music function, menu.ogg and menuXX.ogg (any filename with "menu" as the first 4 letters)
self.files = None
filepath = self.engine.getPath(os.path.join("themes",self.themename,"sounds"))
if os.path.isdir(filepath):
self.files = []
allfiles = os.listdir(filepath)
for name in allfiles:
if os.path.splitext(name)[1] == ".ogg":
if string.find(name,"menu") > -1:
self.files.append(name)
if self.files:
i = random.randint(0,len(self.files)-1)
filename = self.files[i]
sound = os.path.join("themes",self.themename,"sounds",filename)
self.menumusic = True
engine.menuMusic = True
self.song = Audio.Music(self.engine.resource.fileName(sound))
self.song.setVolume(self.engine.config.get("audio", "menu_volume"))
self.song.play(0) #no loop
else:
self.menumusic = False
self.opt_text_color = self.engine.theme.opt_text_colorVar
self.opt_selected_color = self.engine.theme.opt_selected_colorVar
trainingMenu = [
(_("Tutorials"), self.showTutorial),
(_("Practice"), lambda: self.newLocalGame(mode1p = 1)),
]
self.opt_bkg_size = [float(i) for i in self.engine.theme.opt_bkg_size]
self.opt_text_color = self.engine.theme.opt_text_colorVar
self.opt_selected_color = self.engine.theme.opt_selected_colorVar
if self.BGText:
strCareer = ""
strQuickplay = ""
strSolo = ""
strMultiplayer = ""
strTraining = ""
strSettings = ""
strQuit = ""
else:
strCareer = "Career"
strQuickplay = "Quickplay"
strSolo = "Solo"
strMultiplayer = "Multiplayer"
strTraining = "Training"
strSettings = "Settings"
strQuit = "Quit"
multPlayerMenu = [
(_("Face-Off"), lambda: self.newLocalGame(players = 2, maxplayers = 4)),
(_("Pro Face-Off"), lambda: self.newLocalGame(players = 2, mode2p = 1, maxplayers = 4)),
(_("Party Mode"), lambda: self.newLocalGame( mode2p = 2)),
(_("FoFiX Co-Op"), lambda: self.newLocalGame(players = 2, mode2p = 3, maxplayers = 4, allowMic = allowMic)),
(_("RB Co-Op"), lambda: self.newLocalGame(players = 2, mode2p = 4, maxplayers = 4, allowMic = allowMic)),
(_("GH Co-Op"), lambda: self.newLocalGame(players = 2, mode2p = 5, maxplayers = 4)),
(_("GH Battle"), lambda: self.newLocalGame(players = 2, mode2p = 6, allowDrum = False)), #akedrou- so you can block drums
]
if not self.useSoloMenu:
mainMenu = [
(strCareer, lambda: self.newLocalGame(mode1p = 2, allowMic = allowMic)),
(strQuickplay, lambda: self.newLocalGame(allowMic = allowMic)),
((strMultiplayer,"multiplayer"), multPlayerMenu),
((strTraining,"training"), trainingMenu),
((strSettings,"settings"), self.settingsMenu),
(strQuit, self.quit),
]
else:
soloMenu = [
(_("Solo Tour"), lambda: self.newLocalGame(mode1p = 2, allowMic = allowMic)),
(_("Quickplay"), lambda: self.newLocalGame(allowMic = allowMic)),
]
mainMenu = [
((strSolo,"solo"), soloMenu),
((strMultiplayer,"multiplayer"), multPlayerMenu),
((strTraining,"training"), trainingMenu),
((strSettings,"settings"), self.settingsMenu),
(strQuit, self.quit),
]
w, h, = self.engine.view.geometry[2:4]
self.menu = Menu(self.engine, mainMenu, onClose = lambda: self.engine.view.popLayer(self), pos = (self.menux, .75-(.75*self.menuy)))
engine.mainMenu = self #Points engine.mainMenu to the one and only MainMenu object instance
## whether the main menu has come into view at least once
self.shownOnce = False
def __init__(self, engine, choices, name = None, onClose = None, onCancel = None, pos = (.2, .31), viewSize = 6, fadeScreen = False, font = "font", mainMenu = None, textColor = None, selectedColor = None, append_submenu_char = True, selectedIndex = None, showTips = True, selectedBox = False):
self.engine = engine
self.logClassInits = self.engine.config.get("game", "log_class_inits")
if self.logClassInits == 1:
Log.debug("Menu class init (Menu.py)...")
#Get theme
self.themename = self.engine.data.themeLabel
self.theme = self.engine.data.theme
self.choices = []
self.currentIndex = 0
#MFH
if selectedIndex:
self.currentIndex = selectedIndex
self.time = 0
self.onClose = onClose
self.onCancel = onCancel
self.viewOffset = 0
self.name = name # akedrou - for graphical support
self.mainMenu = False
self.graphicMenu = False
self.useSelectedBox = selectedBox
self.useGraphics = self.engine.config.get("game", "use_graphical_submenu")
self.gfxText = None
self.scrolling = 0
self.delay = 0
self.rate = 0
self.scroller = [0, self.scrollUp, self.scrollDown, self.scrollLeft, self.scrollRight]
self.textColor = textColor
self.selectedColor = selectedColor
self.tipColor = self.engine.theme.menuTipTextColor
self.drumNav = self.engine.config.get("game", "drum_navigation") #MFH
if self.name and self.useGraphics > 0:
try:
if self.engine.loadImgDrawing(self, "menuBackground", os.path.join("themes",self.themename,"menu","%s.png" % self.name)):
if self.menuBackground.height1() == 1:
raise KeyError
else:
raise KeyError
self.gfxText = "%stext%d" % (self.name, len(choices))
if not self.engine.loadImgDrawing(self, "menuText", os.path.join("themes",self.themename,"menu","%s.png" % self.gfxText)):
raise KeyError
self.graphicMenu = True
self.menux = self.engine.theme.submenuX[self.gfxText]
self.menuy = self.engine.theme.submenuY[self.gfxText]
self.menuScale = self.engine.theme.submenuScale[self.gfxText]
self.vSpace = self.engine.theme.submenuVSpace[self.gfxText]
if str(self.menux) != "None" and str(self.menuy) != "None":
self.menux = float(self.menux)
self.menuy = float(self.menuy)
else:
self.menux = .4
self.menuy = .4
if str(self.menuScale) != "None":
self.menuScale = float(self.menuScale)
else:
self.menuScale = .5
if str(self.vSpace) != "None":
self.vSpace = float(self.vSpace)
else:
self.vSpace = .08
Log.debug("Graphic menu enabled for submenu: %s" % self.name)
except KeyError:
Log.warn("Your theme does not appear to properly support the %s graphical submenu. Check to be sure you have the latest version of your theme." % self.name)
self.menuBackground = None
self.menuText = None
if pos == (.2, .66 - .35): #MFH - default position, not called with a special one - this is a submenu:
self.sub_menu_x = self.engine.theme.sub_menu_xVar
self.sub_menu_y = self.engine.theme.sub_menu_yVar
if engine.data.theme == 0:
if self.sub_menu_x is None:
self.sub_menu_x = .44
if self.sub_menu_y is None:
self.sub_menu_y = .14
elif engine.data.theme == 1:
if self.sub_menu_x is None:
self.sub_menu_x = .38
if self.sub_menu_y is None:
self.sub_menu_y = .15
elif engine.data.theme == 2:
if self.sub_menu_x is None:
self.sub_menu_x = .25
if self.sub_menu_y is None:
self.sub_menu_y = .14
pos = (self.sub_menu_x, self.sub_menu_y)
if viewSize == 6: #MFH - default viewsize
if self.theme in [0, 1, 2]:#8bit
viewSize = 10
self.pos = pos
self.viewSize = viewSize
self.fadeScreen = fadeScreen
self.font = font
if self.font == "font":
self.font = self.engine.data.font
self.tipFont = self.engine.theme.menuTipTextFont
if self.tipFont == "None":
self.tipFont = self.font
else:
self.tipFont = self.engine.data.fontDict[self.tipFont]
self.active = False
self.mainMenu = mainMenu
self.showTips = showTips
if self.showTips:
self.showTips = self.engine.theme.menuTipTextDisplay
self.tipDelay = 700
self.tipTimerEnabled = False
self.tipScroll = 0
self.tipScrollB = None
self.tipScrollSpace = self.engine.theme.menuTipTextScrollSpace
self.tipScale = self.engine.theme.menuTipTextScale
self.tipDir = 0
self.tipSize = 0
self.tipY = self.engine.theme.menuTipTextY
self.tipScrollMode = self.engine.theme.menuTipTextScrollMode # - 0 for constant scroll; 1 for back and forth
for c in choices:
try:
text, callback = c
if isinstance(text, tuple):
if len(text) == 2: # a submenu's name
c = Choice(text[0], callback, name = text[1], append_submenu_char = append_submenu_char)
else: # Dialogs menus - FileChooser, NeckChooser, ItemChooser - this last to be changed soon
c = Choice(text[0], callback, values = text[2], valueIndex = text[1], append_submenu_char = append_submenu_char)
else:
c = Choice(text, callback, append_submenu_char = append_submenu_char)
except ValueError:
text, callback, tipText = c
if isinstance(text, tuple):
if len(text) == 2: # a submenu's name
c = Choice(text[0], callback, name = text[1], append_submenu_char = append_submenu_char, tipText = tipText)
else: # Dialogs menus - FileChooser, NeckChooser, ItemChooser - this last to be changed soon
c = Choice(text[0], callback, values = text[2], valueIndex = text[1], append_submenu_char = append_submenu_char, tipText = tipText)
else:
c = Choice(text, callback, append_submenu_char = append_submenu_char, tipText = tipText)
except TypeError:
pass
self.choices.append(c)
self.setTipScroll()
def __init__(self, engine, playerObj, scene, player = 0, bass = False):
super(Guitar, self).__init__(engine, playerObj, scene, player=player)
self.isDrum = False
self.isBassGuitar = bass
self.isVocal = False
self.strings = 5
self.strings2 = 5
self.debugMode = False
self.gameMode2p = self.engine.world.multiMode
self.matchingNotes = []
self.logClassInits = self.engine.config.get("game", "log_class_inits")
if self.logClassInits == 1:
Log.debug("Guitar class init...")
self.lastPlayedNotes = [] #MFH - for reverting when game discovers it implied incorrectly
self.missedNotes = []
self.missedNoteNums = []
self.freestyleHitFlameCounts = [0 for n in range(self.strings+1)] #MFH
self.fretWeight = [0.0] * self.strings
self.fretActivity = [0.0] * self.strings
self.drumFretButtons = None
#myfingershurt:
self.hopoStyle = self.engine.config.get("game", "hopo_system")
self.gh2sloppy = self.engine.config.get("game", "gh2_sloppy")
if self.gh2sloppy == 1:
self.hopoStyle = 4
self.sfxVolume = self.engine.config.get("audio", "SFX_volume")
#blazingamer
self.killfx = self.engine.config.get("performance", "killfx")
self.killCount = 0
self.bigMax = 1
#Get theme
#now theme determination logic is only in data.py:
self.theme = self.engine.data.theme
self.oFlash = None
self.lanenumber = float(5)
self.fretImgColNumber = float(3)
#myfingershurt:
self.bassGrooveNeckMode = self.engine.config.get("game", "bass_groove_neck")
self.tailsEnabled = True
self.loadImages()
self.twoChordMax = False
self.rockLevel = 0.0
self.neck = Neck(self.engine, self, playerObj)
def __init__(self, instrument, coOpType = False):
self.coOpType = coOpType
logClassInits = Config.get("game", "log_class_inits")
if logClassInits == 1:
Log.debug("ScoreCard class init...")
self.starScoring = Config.get("game", "star_scoring")
self.updateOnScore = Config.get("performance", "star_score_updates")
self.avMult = 0.0
self.hitAccuracy = 0.0
self.score = 0
if instrument == [5]:
self.baseScore = 0
else:
self.baseScore = 50
self.notesHit = 0
self.percNotesHit = 0
self.notesMissed = 0
self.instrument = instrument # 0 = Guitar, 2 = Bass, 4 = Drum
self.bassGrooveEnabled = False
self.hiStreak = 0
self._streak = 0
self.cheats = []
self.scalable = []
self.earlyHitWindowSizeHandicap = 1.0
self.handicap = 0
self.longHandicap = ""
self.handicapValue = 100.0
self.totalStreakNotes = 0
self.totalNotes = 0
self.totalPercNotes = 0
self.cheatsApply = False
self.stars = 0
self.starRatio = 0.0
self.star = [0 for i in range(7)]
if self.starScoring == 1: #GH-style (mult thresholds, hit threshold for 5/6 stars)
self.star[5] = 2.8
self.star[4] = 2.0
self.star[3] = 1.2
self.star[2] = 0.4
self.star[1] = 0.2 #akedrou - GH may start with 1 star, but why do we need to?
self.star[0] = 0.0
elif self.starScoring > 1: #RB-style (mult thresholds, optional 100% gold star)
if self.starScoring == 4:
if self.instrument[0] == Song.BASS_PART and not self.coOpType:
self.star[6] = 6.78
self.star[5] = 4.62
self.star[4] = 2.77
self.star[3] = 0.90
self.star[2] = 0.50
self.star[1] = 0.21
self.star[0] = 0.0
else:
if self.instrument[0] == Song.DRUM_PART and not self.coOpType:
self.star[6] = 4.29
elif self.instrument[0] == Song.VOCAL_PART and not self.coOpType:
self.star[6] = 4.18
else:
self.star[6] = 4.52
self.star[5] = 3.08
self.star[4] = 1.85
self.star[3] = 0.77
self.star[2] = 0.46
self.star[1] = 0.21
self.star[0] = 0.0
else:
self.star[5] = 3.0
self.star[4] = 2.0
self.star[3] = 1.0
self.star[2] = 0.5
self.star[1] = 0.25
self.star[0] = 0.0
if self.coOpType:
self.star[6] = 4.8
elif self.instrument[0] == Song.BASS_PART: # bass
self.star[6] = 4.8
elif self.instrument[0] == Song.DRUM_PART: # drum
self.star[6] = 4.65
else:
self.star[6] = 5.3
else: #hit accuracy thresholds
self.star[6] = 100
self.star[5] = 95
self.star[4] = 75
self.star[3] = 50
self.star[2] = 30
self.star[1] = 10
self.star[0] = 0
self.endingScore = 0 #MFH
self.endingStreakBroken = False #MFH
self.endingAwarded = False #MFH
self.lastNoteEvent = None #MFH
self.lastNoteTime = 0.0
self.freestyleWasJustActive = False #MFH
def __init__(self, engine, playerObj, editorMode = False, player = 0, bass = False):
super(Guitar, self).__init__(engine, playerObj, player)
self.isDrum = False
self.isBassGuitar = bass
self.isVocal = False
self.strings = 5
self.strings2 = 5
self.debugMode = False
self.gameMode2p = self.engine.world.multiMode
self.matchingNotes = []
self.logClassInits = self.engine.config.get("game", "log_class_inits")
if self.logClassInits == 1:
Log.debug("Guitar class init...")
self.lastPlayedNotes = [] #MFH - for reverting when game discovers it implied incorrectly
self.missedNotes = []
self.missedNoteNums = []
self.editorMode = editorMode
self.freestyleHitFlameCounts = [0 for n in range(self.strings+1)] #MFH
self.fretWeight = [0.0] * self.strings
self.fretActivity = [0.0] * self.strings
self.drumFretButtons = None
#myfingershurt:
self.hopoStyle = self.engine.config.get("game", "hopo_system")
self.gh2sloppy = self.engine.config.get("game", "gh2_sloppy")
if self.gh2sloppy == 1:
self.hopoStyle = 4
self.sfxVolume = self.engine.config.get("audio", "SFX_volume")
#blazingamer
self.killfx = self.engine.config.get("performance", "killfx")
self.killCount = 0
self.bigMax = 1
#Get theme
#now theme determination logic is only in data.py:
self.theme = self.engine.data.theme
self.oFlash = None
self.lanenumber = float(5)
self.fretImgColNumber = float(3)
#myfingershurt:
self.bassGrooveNeckMode = self.engine.config.get("game", "bass_groove_neck")
self.tailsEnabled = True
self.loadImages()
self.twoChordMax = False
self.rockLevel = 0.0
self.neck = Neck(self.engine, self, playerObj)
def popAllLayers(self):
Log.debug("View: Pop all")
[self.popLayer(l) for l in list(self.layers)]
def load(self, libraryName, songName, practiceMode=False):
if self.scene.coOpType:
rm = os.path.join("themes", self.themename, "rockmeter_coop.ini")
elif self.scene.battle or self.scene.battleGH:
rm = os.path.join("themes", self.themename,
"rockmeter_profaceoff.ini")
elif self.scene.gamePlayers > 1:
rm = os.path.join("themes", self.themename,
"rockmeter_faceoff.ini")
else:
rm = os.path.join("themes", self.themename, "rockmeter.ini")
if os.path.exists(os.path.join("..", "data", rm)):
rockmeter = self.engine.resource.fileName(rm)
else:
rockmeter = self.engine.resource.fileName(
os.path.join("themes", self.themename, "rockmeter.ini"))
self.rockmeter = Rockmeter.Rockmeter(self.scene, rockmeter,
self.scene.coOpType)
# evilynux - Fixes a self.background not defined crash
self.background = None
#MFH - new background stage logic:
if self.mode == 2: #blank / no stage
self.songStage = 0
self.rotationMode = 0
elif practiceMode: #check for existing practice stage; always disable stage rotation here
self.songStage = 0
self.rotationMode = 0
self.mode = 1
#separated practice stages for the instruments by k.i.d
if self.scene.instruments[0].isDrum:
background = "practicedrum"
elif self.scene.instruments[0].isBassGuitar:
background = "practicebass"
else:
background = "practice"
if not self.engine.loadImgDrawing(
self, "background",
os.path.join("themes", self.themename, "backgrounds",
background)):
#MFH - must first fall back on the old practice.png before forcing blank stage mode!
if not self.engine.loadImgDrawing(
self, "background",
os.path.join("themes", self.themename, "backgrounds",
"practice")):
Log.warn(
"No practice stage, falling back on a forced Blank stage mode"
) # evilynux
self.mode = 2 #if no practice stage, just fall back on a forced Blank stage mode
elif self.songStage == 1: #check for song-specific background
test = True
if not self.engine.loadImgDrawing(
self, "background",
os.path.join(libraryName, songName, "background")):
Log.notice("No song-specific stage found") # evilynux
test = False
if test: #does a song-specific background exist?
self.rotationMode = 0
self.mode = 1
else:
self.songStage = 0
#MFH - now, after the above logic, we can run the normal stage mode logic
# only worrying about checking for Blank, song-specific and
# practice stage modes
if self.mode != 2 and self.mode != 3 and self.songStage == 0 and not practiceMode: #still need to load stage(s)
#myfingershurt: assign this first
if self.mode == 1: #just use Default.png
if not self.engine.loadImgDrawing(
self, "background", os.path.join(self.path,
"default")):
Log.warn(
"No default stage; falling back on a forced Blank stage mode"
) # evilynux
self.mode = 2 #if no practice stage, just fall back on a forced Blank stage mode
##This checks how many Stage-background we have to select from
if self.mode == 0 and self.rotationMode == 0: #MFH: just display a random stage
files = []
fileIndex = 0
allfiles = os.listdir(self.pathfull)
for name in allfiles:
if os.path.splitext(name)[0].lower(
) != "practice" and os.path.splitext(name)[0].lower(
) != "practicedrum" and os.path.splitext(name)[0].lower(
) != "practicebass" and name != ".svn":
Log.debug("Valid background found, index (" +
str(fileIndex) + "): " + name)
files.append(name)
fileIndex += 1
else:
Log.debug("Practice background filtered: " + name)
# evilynux - improved error handling, fallback to blank background if no background are found
if fileIndex == 0:
Log.warn("No valid stage found!")
self.mode = 2
else:
i = random.randint(0, len(files) - 1)
filename = files[i]
##End check number of Stage-backgrounds
if not self.engine.loadImgDrawing(
self, "background",
os.path.join(self.path, filename)):
self.mode = 2
elif self.rotationMode > 0 and self.mode != 2:
files = []
fileIndex = 0
if self.animatedFolder == "Random": #Select one of the subfolders under stages\ to animate randomly
numAniStageFolders = len(self.engine.stageFolders)
if numAniStageFolders > 0:
self.animatedFolder = random.choice(
self.engine.stageFolders)
else:
self.animatedFolder = "Normal"
elif self.animatedFolder == "None":
self.mode = 2
if self.animatedFolder != "Normal" and self.mode != 2: #just use the base Stages folder for rotation
self.path = os.path.join("themes", self.themename,
"backgrounds",
self.animatedFolder)
self.pathfull = self.engine.getPath(self.path)
self.animation = True
allfiles = os.listdir(self.pathfull)
for name in allfiles:
if os.path.splitext(
name)[1].lower() == ".png" or os.path.splitext(
name)[1].lower() == ".jpg" or os.path.splitext(
name)[1].lower() == ".jpeg":
if os.path.splitext(name)[0].lower(
) != "practice" and os.path.splitext(name)[0].lower(
) != "practicedrum" and os.path.splitext(
name)[0].lower() != "practicebass":
Log.debug("Valid background found, index (" +
str(fileIndex) + "): " + name)
files.append(name)
fileIndex += 1
else:
Log.debug("Practice background filtered: " + name)
files.sort()
if self.rotationMode > 0 and self.mode != 2: #alarian: blank stage option is not selected
#myfingershurt: just populate the image array in order, they are pulled in whatever order requested:
for j in range(len(files)):
self.engine.loadImgDrawing(
self, "backgroundA", os.path.join(self.path, files[j]))
self.imgArr.append(
getattr(self, "backgroundA",
os.path.join(self.path, files[j])))
if self.rotationMode > 0 and len(self.imgArr) == 0:
self.rotationMode = 0
def __init__(self, config=None):
Log.debug("GameEngine class init (GameEngine.py)...")
self.mainMenu = None #placeholder for main menu object - to prevent reinstantiation
self.currentScene = None
self.versionString = version #stump: other version stuff moved to allow full version string to be retrieved without instantiating GameEngine
self.uploadVersion = "%s-4.0" % Version.PROGRAM_NAME #akedrou - the version passed to the upload site.
self.dataPath = Version.dataPath()
Log.debug(self.versionString + " starting up...")
Log.debug("Python version: " + sys.version.split(' ')[0])
Log.debug("Pygame version: " + str(pygame.version.ver))
Log.debug("PyOpenGL version: " + OpenGL.__version__)
Log.debug("Numpy version: " + np.__version__)
Log.debug("PIL version: " + Image.VERSION)
Log.debug("sys.argv: " + repr(sys.argv))
Log.debug("os.name: " + os.name)
Log.debug("sys.platform: " + sys.platform)
if os.name == 'nt':
import win32api
Log.debug("win32api.GetVersionEx(1): " +
repr(win32api.GetVersionEx(1)))
elif os.name == 'posix':
Log.debug("os.uname(): " + repr(os.uname()))
"""
Constructor.
@param config: L{Config} instance for settings
"""
self.tutorialFolder = "tutorials"
if not config:
config = Config.load()
self.config = config
fps = self.config.get("video", "fps")
self.fps = fps
self.running = True
self.clock = FpsTimer()
self.tickDelta = 0
self.task = TaskEngine(self)
# Compatiblity task management
self.addTask = self.task.addTask
self.removeTask = self.task.removeTask
self.pauseTask = self.task.pauseTask
self.resumeTask = self.task.resumeTask
self.title = self.versionString
self.restartRequested = False
# evilynux - Check if theme icon exists first, then fallback on FoFiX icon.
themename = self.config.get("coffee", "themename")
themeicon = os.path.join(Version.dataPath(), "themes", themename,
"icon.png")
fofixicon = os.path.join(Version.dataPath(), "fofix_icon.png")
icon = None
if os.path.exists(themeicon):
icon = themeicon
elif os.path.exists(fofixicon):
icon = fofixicon
self.video = Video(self.title, icon)
if self.config.get("video", "disable_screensaver"):
self.video.disableScreensaver()
self.audio = Audio()
self.fpsEstimate = 0
self.priority = self.config.get("engine", "highpriority")
self.show_fps = self.config.get("video", "show_fps")
self.advSettings = self.config.get("game", "adv_settings")
self.restartRequired = False
self.quicksetRestart = False
self.quicksetPerf = self.config.get("quickset", "performance")
self.scrollRate = self.config.get("game", "scroll_rate")
self.scrollDelay = self.config.get("game", "scroll_delay")
Log.debug("Initializing audio.")
frequency = self.config.get("audio", "frequency")
bits = self.config.get("audio", "bits")
stereo = self.config.get("audio", "stereo")
bufferSize = self.config.get("audio", "buffersize")
self.audio.open(frequency=frequency,
bits=bits,
stereo=stereo,
bufferSize=bufferSize)
self.cmdPlay = 0
self.cmdMode = None
self.cmdDiff = None
self.cmdPart = None
self.gameStarted = False
self.world = None
self.audioSpeedFactor = 1.0
Log.debug("Initializing video.")
#myfingershurt: ensuring windowed mode starts up in center of the screen instead of cascading positions:
os.environ['SDL_VIDEO_WINDOW_POS'] = 'center'
width, height = [
int(s) for s in self.config.get("video", "resolution").split("x")
]
fullscreen = self.config.get("video", "fullscreen")
multisamples = self.config.get("video", "multisamples")
self.video.setMode((width, height),
fullscreen=fullscreen,
multisamples=multisamples)
Log.debug("OpenGL version: " + glGetString(GL_VERSION))
Log.debug("OpenGL vendor: " + glGetString(GL_VENDOR))
Log.debug("OpenGL renderer: " + glGetString(GL_RENDERER))
Log.debug("OpenGL extensions: " +
' '.join(sorted(glGetString(GL_EXTENSIONS).split())))
if self.video.default:
self.config.set("video", "fullscreen", False)
self.config.set("video", "resolution", "800x600")
if self.config.get("video", "shader_use"):
shaders.set(os.path.join(Version.dataPath(), "shaders"))
# Enable the high priority timer if configured
if self.priority:
Log.debug("Enabling high priority timer.")
self.fps = 0 # High priority
# evilynux - This was generating an error on the first pass (at least under
# GNU/Linux) as the Viewport was not set yet.
try:
viewport = glGetIntegerv(GL_VIEWPORT)
except:
viewport = [0, 0, width, height]
h = viewport[3] - viewport[1]
w = viewport[2] - viewport[0]
geometry = (0, 0, w, h)
self.svg = SvgContext(geometry)
glViewport(int(viewport[0]), int(viewport[1]), int(viewport[2]),
int(viewport[3]))
self.startupMessages = self.video.error
self.input = Input()
self.view = View(self, geometry)
self.resizeScreen(w, h)
self.resource = Resource(Version.dataPath())
self.mainloop = self.loading
self.menuMusic = False
self.setlistMsg = None
# Load game modifications
Mod.init(self)
self.task.addTask(self.input, synced=False)
self.task.addTask(self.view, synced=False)
self.task.addTask(self.resource, synced=False)
self.data = Data(self.resource, self.svg)
##MFH: Animated stage folder selection option
#<themename>\Stages still contains the backgrounds for when stage rotation is off, and practice.png
#subfolders under Stages\ will each be treated as a separate animated stage set
self.stageFolders = []
currentTheme = themename
stagespath = os.path.join(Version.dataPath(), "themes", currentTheme,
"backgrounds")
themepath = os.path.join(Version.dataPath(), "themes", currentTheme)
if os.path.exists(stagespath):
self.stageFolders = []
allFolders = os.listdir(
stagespath
) #this also includes all the stage files - so check to see if there is at least one .png file inside each folder to be sure it's an animated stage folder
for name in allFolders:
aniStageFolderListing = []
thisIsAnAnimatedStageFolder = False
try:
aniStageFolderListing = os.listdir(
os.path.join(stagespath, name))
except Exception:
thisIsAnAnimatedStageFolder = False
for aniFile in aniStageFolderListing:
if os.path.splitext(aniFile)[1] in [
".png", ".jpg", ".jpeg"
]:
# we've found at least one .png file here, chances are this is a valid animated stage folder
thisIsAnAnimatedStageFolder = True
if thisIsAnAnimatedStageFolder:
self.stageFolders.append(name)
i = len(self.stageFolders)
if i > 0: #only set default to first animated subfolder if one exists - otherwise use Normal!
defaultAniStage = str(self.stageFolders[0])
else:
defaultAniStage = "Normal"
Log.debug("Default animated stage for " + currentTheme +
" theme = " + defaultAniStage)
aniStageOptions = dict([(str(self.stageFolders[n]),
self.stageFolders[n])
for n in range(0, i)])
aniStageOptions.update({"Normal": _("Slideshow")})
if i > 1: #only add Random setting if more than one animated stage exists
aniStageOptions.update({"Random": _("Random")})
Config.define("game",
"animated_stage_folder",
str,
defaultAniStage,
text=_("Animated Stage"),
options=aniStageOptions)
#MFH: here, need to track and check a new ini entry for last theme - so when theme changes we can re-default animated stage to first found
lastTheme = self.config.get("game", "last_theme")
if lastTheme == "" or lastTheme != currentTheme: #MFH - no last theme, and theme just changed:
self.config.set("game", "animated_stage_folder",
defaultAniStage) #force defaultAniStage
self.config.set("game", "last_theme", currentTheme)
selectedAnimatedStage = self.config.get("game",
"animated_stage_folder")
if selectedAnimatedStage != "Normal" and selectedAnimatedStage != "Random":
if not os.path.exists(
os.path.join(stagespath, selectedAnimatedStage)):
Log.warn("Selected animated stage folder " +
selectedAnimatedStage +
" does not exist, forcing Normal.")
self.config.set(
"game", "animated_stage_folder", "Normal"
) #MFH: force "Standard" currently selected animated stage folder is invalid
else:
Config.define("game",
"animated_stage_folder",
str,
"None",
text=_("Animated Stage"),
options=["None", _("None")])
Log.warn(
"No stages\ folder found, forcing None setting for Animated Stage."
)
self.config.set(
"game", "animated_stage_folder",
"None") #MFH: force "None" when Stages folder can't be found
try:
fp, pathname, description = imp.find_module(
"CustomTheme", [themepath])
theme = imp.load_module("CustomTheme", fp, pathname, description)
self.theme = theme.CustomTheme(themepath, themename)
except ImportError:
self.theme = Theme(themepath, themename)
self.task.addTask(self.theme)
self.input.addKeyListener(FullScreenSwitcher(self), priority=True)
self.input.addSystemEventListener(SystemEventHandler(self))
self.debugLayer = None
self.startupLayer = None
self.loadingScreenShown = False
self.graphicMenuShown = False
Log.debug("Ready.")
def popAllLayers(self):
Log.debug("View: Pop all")
[self.popLayer(l) for l in list(self.layers)]
def __init__(self):
self.logClassInits = Config.get("game", "log_class_inits")
if self.logClassInits == 1:
Log.debug("Controls class init (Player.py)...")
self.controls = []
self.controls.append(Config.get("game", "control0"))
self.controls.append(Config.get("game", "control1"))
self.controls.append(Config.get("game", "control2"))
self.controls.append(Config.get("game", "control3"))
self.config = []
self.controlList = []
self.maxplayers = 0
self.guitars = 0
self.drums = 0
self.mics = 0
self.overlap = []
self.p2Nav = Config.get("game", "p2_menu_nav")
self.drumNav = Config.get("game", "drum_navigation")
self.keyCheckerMode = Config.get("game","key_checker_mode")
if VFS.isfile(_makeControllerIniName(self.controls[0])):
self.config.append(Config.load(VFS.resolveRead(_makeControllerIniName(self.controls[0])), type = 1))
if VFS.isfile(_makeControllerIniName(self.controls[1])) and self.controls[1] != "None":
self.config.append(Config.load(VFS.resolveRead(_makeControllerIniName(self.controls[1])), type = 1))
else:
self.config.append(None)
Config.set("game", "control1", None)
self.controls[1] = "None"
if VFS.isfile(_makeControllerIniName(self.controls[2])) and self.controls[2] != "None":
self.config.append(Config.load(VFS.resolveRead(_makeControllerIniName(self.controls[2])), type = 1))
else:
self.config.append(None)
Config.set("game", "control2", None)
self.controls[2] = "None"
if VFS.isfile(_makeControllerIniName(self.controls[3])) and self.controls[3] != "None":
self.config.append(Config.load(VFS.resolveRead(_makeControllerIniName(self.controls[3])), type = 1))
else:
self.config.append(None)
Config.set("game", "control3", None)
self.controls[3] = "None"
else:
confM = None
if Microphone.supported:
confM = Config.load(VFS.resolveRead(_makeControllerIniName("defaultm")), type = 1)
self.config.append(Config.load(VFS.resolveRead(_makeControllerIniName("defaultg")), type = 1))
self.config.append(Config.load(VFS.resolveRead(_makeControllerIniName("defaultd")), type = 1))
self.config.append(confM)
self.config.append(None)
Config.set("game", "control0", "defaultg")
Config.set("game", "control1", "defaultd")
self.controls = ["defaultg", "defaultd"]
if confM is not None:
Config.set("game", "control2", "defaultm")
self.controls.append("defaultm")
else:
Config.set("game", "control2", None)
self.controls.append("None")
Config.set("game", "control3", None)
self.controls.append("None")
self.type = []
self.analogKill = []
self.analogSP = []
self.analogSPThresh = []
self.analogSPSense = []
self.analogDrum = [] #FIXME: Analog Drum
self.analogSlide = []
self.analogFX = [] #FIXME: Analog FX
self.twoChord = []
self.micDevice = [] #stump
self.micTapSensitivity = []
self.micPassthroughVolume = []
self.flags = 0
for i in self.config:
if i:
type = i.get("controller", "type")
if type == 5:
self.mics += 1
elif type > 1:
self.guitars += 1
else:
self.drums += 1
self.type.append(type)
self.analogKill.append(i.get("controller", "analog_kill"))
self.analogSP.append(i.get("controller", "analog_sp"))
self.analogSPThresh.append(i.get("controller", "analog_sp_threshold"))
self.analogSPSense.append(i.get("controller", "analog_sp_sensitivity"))
self.analogDrum.append(i.get("controller", "analog_drum")) #FIXME: Analog Drum
self.analogSlide.append(i.get("controller", "analog_slide"))
self.analogFX.append(i.get("controller", "analog_fx")) #FIXME: Analog FX
self.micDevice.append(i.get("controller", "mic_device")) #stump
self.micTapSensitivity.append(i.get("controller", "mic_tap_sensitivity"))
self.micPassthroughVolume.append(i.get("controller", "mic_passthrough_volume"))
self.twoChord.append(i.get("controller", "two_chord_max"))
self.controlList.append(i.get("controller", "name"))
else:
self.type.append(None)
self.analogKill.append(None)
self.analogSP.append(None)
self.analogFX.append(None) #FIXME: Analog FX
self.twoChord.append(None)
def keycode(name, config):
if not config:
return "None"
k = config.get("controller", name)
if k == "None":
return "None"
try:
return int(k)
except:
return getattr(pygame, k)
self.controlMapping = {}
global menuUp, menuDown, menuNext, menuPrev, menuYes, menuNo
global drum1s, drum2s, drum3s, drum4s, drum5s, bassdrums
global key1s, key2s, key3s, key4s, key5s, keysolos, action1s, action2s, kills
menuUp = []
menuDown = []
menuNext = []
menuPrev = []
menuYes = []
menuNo = []
drum1s = []
drum2s = []
drum3s = []
drum4s = []
drum5s = []
bassdrums = []
key1s = []
key2s = []
key3s = []
key4s = []
key5s = []
keysolos = []
action1s = []
action2s = []
kills = []
for i, config in enumerate(self.config):
if self.type[i] in DRUMTYPES: #drum set
drum1s.extend([CONTROLS[i][DRUM1], CONTROLS[i][DRUM1A]])
drum2s.extend([CONTROLS[i][DRUM2], CONTROLS[i][DRUM2A]])
drum3s.extend([CONTROLS[i][DRUM3], CONTROLS[i][DRUM3A]])
drum4s.extend([CONTROLS[i][DRUM4], CONTROLS[i][DRUM4A]])
drum5s.extend([CONTROLS[i][DRUM5], CONTROLS[i][DRUM5A]])
bassdrums.extend([CONTROLS[i][DRUMBASS], CONTROLS[i][DRUMBASSA]])
if self.p2Nav == 1 or (self.p2Nav == 0 and i == 0):
if self.drumNav:
menuUp.extend([CONTROLS[i][DRUM2], CONTROLS[i][DRUM2A]])
if self.type[i] == 3:
menuDown.extend([CONTROLS[i][DRUM4], CONTROLS[i][DRUM4A]])
else:
menuDown.extend([CONTROLS[i][DRUM3], CONTROLS[i][DRUM3A]])
menuYes.extend([CONTROLS[i][DRUM5], CONTROLS[i][DRUM5A]])
menuNo.extend([CONTROLS[i][DRUM1], CONTROLS[i][DRUM1A]])
menuYes.append(CONTROLS[i][START])
menuNo.append(CONTROLS[i][CANCEL])
menuUp.append(CONTROLS[i][UP])
menuDown.append(CONTROLS[i][DOWN])
menuNext.append(CONTROLS[i][RIGHT])
menuPrev.append(CONTROLS[i][LEFT])
elif self.type[i] in MICTYPES: #stump: it's a mic
if self.p2Nav == 1 or (self.p2Nav == 0 and i == 0):
menuUp.append(CONTROLS[i][UP])
menuDown.append(CONTROLS[i][DOWN])
menuNext.append(CONTROLS[i][RIGHT])
menuPrev.append(CONTROLS[i][LEFT])
menuYes.append(CONTROLS[i][START])
menuNo.append(CONTROLS[i][CANCEL])
elif self.type[i] in GUITARTYPES:
if self.type[i] == 0:
key1s.extend([CONTROLS[i][KEY1], CONTROLS[i][KEY1A]])
else:
key1s.extend([CONTROLS[i][KEY1]])
key2s.extend([CONTROLS[i][KEY2], CONTROLS[i][KEY2A]])
key3s.extend([CONTROLS[i][KEY3], CONTROLS[i][KEY3A]])
key4s.extend([CONTROLS[i][KEY4], CONTROLS[i][KEY4A]])
key5s.extend([CONTROLS[i][KEY5], CONTROLS[i][KEY5A]])
keysolos.extend([CONTROLS[i][KEY1A], CONTROLS[i][KEY2A], CONTROLS[i][KEY3A], CONTROLS[i][KEY4A], CONTROLS[i][KEY5A]])
action1s.extend([CONTROLS[i][ACTION1]])
action2s.extend([CONTROLS[i][ACTION2]])
kills.extend([CONTROLS[i][KILL]])
if self.p2Nav == 1 or (self.p2Nav == 0 and i == 0):
menuUp.extend([CONTROLS[i][ACTION1], CONTROLS[i][UP]])
menuDown.extend([CONTROLS[i][ACTION2], CONTROLS[i][DOWN]])
menuNext.extend([CONTROLS[i][RIGHT], CONTROLS[i][KEY4], CONTROLS[i][KEY4A]])
menuPrev.extend([CONTROLS[i][LEFT], CONTROLS[i][KEY3], CONTROLS[i][KEY3A]])
menuYes.extend([CONTROLS[i][KEY1], CONTROLS[i][KEY1A], CONTROLS[i][START]])
menuNo.extend([CONTROLS[i][KEY2], CONTROLS[i][KEY2A], CONTROLS[i][CANCEL]])
if self.type[i] == 3:
controlMapping = { #akedrou - drums do not need special declarations!
keycode("key_left", config): CONTROLS[i][LEFT],
keycode("key_right", config): CONTROLS[i][RIGHT],
keycode("key_up", config): CONTROLS[i][UP],
keycode("key_down", config): CONTROLS[i][DOWN],
keycode("key_star", config): CONTROLS[i][STAR],
keycode("key_cancel", config): CONTROLS[i][CANCEL],
keycode("key_1a", config): CONTROLS[i][DRUM5A], #order is important. This minimizes key conflicts.
keycode("key_2a", config): CONTROLS[i][DRUM1A],
keycode("key_3a", config): CONTROLS[i][DRUM2A],
keycode("key_4a", config): CONTROLS[i][DRUM3A],
keycode("key_5a", config): CONTROLS[i][DRUM4A],
keycode("key_action2", config): CONTROLS[i][DRUMBASSA],
keycode("key_1", config): CONTROLS[i][DRUM5],
keycode("key_2", config): CONTROLS[i][DRUM1],
keycode("key_3", config): CONTROLS[i][DRUM2],
keycode("key_4", config): CONTROLS[i][DRUM3],
keycode("key_5", config): CONTROLS[i][DRUM4],
keycode("key_action1", config): CONTROLS[i][DRUMBASS],
keycode("key_start", config): CONTROLS[i][START],
}
elif self.type[i] == 2:
controlMapping = { #akedrou - drums do not need special declarations!
keycode("key_left", config): CONTROLS[i][LEFT],
keycode("key_right", config): CONTROLS[i][RIGHT],
keycode("key_up", config): CONTROLS[i][UP],
keycode("key_down", config): CONTROLS[i][DOWN],
keycode("key_star", config): CONTROLS[i][STAR],
keycode("key_cancel", config): CONTROLS[i][CANCEL],
keycode("key_1a", config): CONTROLS[i][DRUM5A], #order is important. This minimizes key conflicts.
keycode("key_2a", config): CONTROLS[i][DRUM1A],
keycode("key_3a", config): CONTROLS[i][DRUM2A],
keycode("key_4a", config): CONTROLS[i][DRUM3A],
keycode("key_action2", config): CONTROLS[i][DRUMBASSA],
keycode("key_1", config): CONTROLS[i][DRUM5],
keycode("key_2", config): CONTROLS[i][DRUM1],
keycode("key_3", config): CONTROLS[i][DRUM2],
keycode("key_4", config): CONTROLS[i][DRUM3],
keycode("key_action1", config): CONTROLS[i][DRUMBASS],
keycode("key_start", config): CONTROLS[i][START],
}
elif self.type[i] > -1:
controlMapping = { #akedrou - drums do not need special declarations!
keycode("key_left", config): CONTROLS[i][LEFT],
keycode("key_right", config): CONTROLS[i][RIGHT],
keycode("key_up", config): CONTROLS[i][UP],
keycode("key_down", config): CONTROLS[i][DOWN],
keycode("key_cancel", config): CONTROLS[i][CANCEL],
keycode("key_star", config): CONTROLS[i][STAR],
keycode("key_kill", config): CONTROLS[i][KILL],
keycode("key_1a", config): CONTROLS[i][KEY1A], #order is important. This minimizes key conflicts.
keycode("key_2a", config): CONTROLS[i][KEY2A],
keycode("key_3a", config): CONTROLS[i][KEY3A],
keycode("key_4a", config): CONTROLS[i][KEY4A],
keycode("key_5a", config): CONTROLS[i][KEY5A],
keycode("key_1", config): CONTROLS[i][KEY1],
keycode("key_2", config): CONTROLS[i][KEY2],
keycode("key_3", config): CONTROLS[i][KEY3],
keycode("key_4", config): CONTROLS[i][KEY4],
keycode("key_5", config): CONTROLS[i][KEY5],
keycode("key_action2", config): CONTROLS[i][ACTION2],
keycode("key_action1", config): CONTROLS[i][ACTION1],
keycode("key_start", config): CONTROLS[i][START],
}
else:
controlMapping = {}
controlMapping = self.checkMapping(controlMapping, i)
self.controlMapping.update(controlMapping)
self.reverseControlMapping = dict((value, key) for key, value in self.controlMapping.iteritems() )
# Multiple key support
self.heldKeys = {}
def __init__(self, config = None):
Log.debug("GameEngine class init (GameEngine.py)...")
self.mainMenu = None #placeholder for main menu object - to prevent reinstantiation
self.currentScene = None
self.versionString = version #stump: other version stuff moved to allow full version string to be retrieved without instantiating GameEngine
self.uploadVersion = "%s-4.0" % Version.PROGRAM_NAME #akedrou - the version passed to the upload site.
self.dataPath = Version.dataPath()
Log.debug(self.versionString + " starting up...")
Log.debug("Python version: " + sys.version.split(' ')[0])
Log.debug("Pygame version: " + str(pygame.version.ver) )
Log.debug("PyOpenGL version: " + OpenGL.__version__)
Log.debug("Numpy version: " + np.__version__)
Log.debug("PIL version: " + Image.VERSION)
Log.debug("sys.argv: " + repr(sys.argv))
Log.debug("os.name: " + os.name)
Log.debug("sys.platform: " + sys.platform)
if os.name == 'nt':
import win32api
Log.debug("win32api.GetVersionEx(1): " + repr(win32api.GetVersionEx(1)))
elif os.name == 'posix':
Log.debug("os.uname(): " + repr(os.uname()))
"""
Constructor.
@param config: L{Config} instance for settings
"""
self.tutorialFolder = "tutorials"
if not config:
config = Config.load()
self.config = config
fps = self.config.get("video", "fps")
self.fps = fps
self.running = True
self.clock = FpsTimer()
self.tickDelta = 0
self.task = TaskEngine(self)
# Compatiblity task management
self.addTask = self.task.addTask
self.removeTask = self.task.removeTask
self.pauseTask = self.task.pauseTask
self.resumeTask = self.task.resumeTask
self.title = self.versionString
self.restartRequested = False
# evilynux - Check if theme icon exists first, then fallback on FoFiX icon.
themename = self.config.get("coffee", "themename")
themeicon = os.path.join(Version.dataPath(), "themes", themename, "icon.png")
fofixicon = os.path.join(Version.dataPath(), "fofix_icon.png")
icon = None
if os.path.exists(themeicon):
icon = themeicon
elif os.path.exists(fofixicon):
icon = fofixicon
self.video = Video(self.title, icon)
if self.config.get("video", "disable_screensaver"):
self.video.disableScreensaver()
self.audio = Audio()
self.fpsEstimate = 0
self.priority = self.config.get("engine", "highpriority")
self.show_fps = self.config.get("video", "show_fps")
self.advSettings = self.config.get("game", "adv_settings")
self.restartRequired = False
self.quicksetRestart = False
self.quicksetPerf = self.config.get("quickset", "performance")
self.scrollRate = self.config.get("game", "scroll_rate")
self.scrollDelay = self.config.get("game", "scroll_delay")
Log.debug("Initializing audio.")
frequency = self.config.get("audio", "frequency")
bits = self.config.get("audio", "bits")
stereo = self.config.get("audio", "stereo")
bufferSize = self.config.get("audio", "buffersize")
self.audio.open(frequency = frequency, bits = bits, stereo = stereo, bufferSize = bufferSize)
self.cmdPlay = 0
self.cmdMode = None
self.cmdDiff = None
self.cmdPart = None
self.gameStarted = False
self.world = None
self.audioSpeedFactor = 1.0
Log.debug("Initializing video.")
#myfingershurt: ensuring windowed mode starts up in center of the screen instead of cascading positions:
os.environ['SDL_VIDEO_WINDOW_POS'] = 'center'
width, height = [int(s) for s in self.config.get("video", "resolution").split("x")]
fullscreen = self.config.get("video", "fullscreen")
multisamples = self.config.get("video", "multisamples")
self.video.setMode((width, height), fullscreen = fullscreen, multisamples = multisamples)
Log.debug("OpenGL version: " + glGetString(GL_VERSION))
Log.debug("OpenGL vendor: " + glGetString(GL_VENDOR))
Log.debug("OpenGL renderer: " + glGetString(GL_RENDERER))
Log.debug("OpenGL extensions: " + ' '.join(sorted(glGetString(GL_EXTENSIONS).split())))
if self.video.default:
self.config.set("video", "fullscreen", False)
self.config.set("video", "resolution", "800x600")
if self.config.get("video", "shader_use"):
shaders.set(os.path.join(Version.dataPath(), "shaders"))
# Enable the high priority timer if configured
if self.priority:
Log.debug("Enabling high priority timer.")
self.fps = 0 # High priority
# evilynux - This was generating an error on the first pass (at least under
# GNU/Linux) as the Viewport was not set yet.
try:
viewport = glGetIntegerv(GL_VIEWPORT)
except:
viewport = [0, 0, width, height]
h = viewport[3] - viewport[1]
w = viewport[2] - viewport[0]
geometry = (0, 0, w, h)
self.svg = SvgContext(geometry)
glViewport(int(viewport[0]), int(viewport[1]), int(viewport[2]), int(viewport[3]))
self.startupMessages = self.video.error
self.input = Input()
self.view = View(self, geometry)
self.resizeScreen(w, h)
self.resource = Resource(Version.dataPath())
self.mainloop = self.loading
self.menuMusic = False
self.setlistMsg = None
# Load game modifications
Mod.init(self)
self.task.addTask(self.input, synced = False)
self.task.addTask(self.view, synced = False)
self.task.addTask(self.resource, synced = False)
self.data = Data(self.resource, self.svg)
##MFH: Animated stage folder selection option
#<themename>\Stages still contains the backgrounds for when stage rotation is off, and practice.png
#subfolders under Stages\ will each be treated as a separate animated stage set
self.stageFolders = []
currentTheme = themename
stagespath = os.path.join(Version.dataPath(), "themes", currentTheme, "backgrounds")
themepath = os.path.join(Version.dataPath(), "themes", currentTheme)
if os.path.exists(stagespath):
self.stageFolders = []
allFolders = os.listdir(stagespath) #this also includes all the stage files - so check to see if there is at least one .png file inside each folder to be sure it's an animated stage folder
for name in allFolders:
aniStageFolderListing = []
thisIsAnAnimatedStageFolder = False
try:
aniStageFolderListing = os.listdir(os.path.join(stagespath,name))
except Exception:
thisIsAnAnimatedStageFolder = False
for aniFile in aniStageFolderListing:
if os.path.splitext(aniFile)[1] in [".png", ".jpg", ".jpeg"]:
# we've found at least one .png file here, chances are this is a valid animated stage folder
thisIsAnAnimatedStageFolder = True
if thisIsAnAnimatedStageFolder:
self.stageFolders.append(name)
i = len(self.stageFolders)
if i > 0: #only set default to first animated subfolder if one exists - otherwise use Normal!
defaultAniStage = str(self.stageFolders[0])
else:
defaultAniStage = "Normal"
Log.debug("Default animated stage for " + currentTheme + " theme = " + defaultAniStage)
aniStageOptions = dict([(str(self.stageFolders[n]),self.stageFolders[n]) for n in range(0, i)])
aniStageOptions.update({"Normal":_("Slideshow")})
if i > 1: #only add Random setting if more than one animated stage exists
aniStageOptions.update({"Random":_("Random")})
Config.define("game", "animated_stage_folder", str, defaultAniStage, text = _("Animated Stage"), options = aniStageOptions )
#MFH: here, need to track and check a new ini entry for last theme - so when theme changes we can re-default animated stage to first found
lastTheme = self.config.get("game","last_theme")
if lastTheme == "" or lastTheme != currentTheme: #MFH - no last theme, and theme just changed:
self.config.set("game","animated_stage_folder",defaultAniStage) #force defaultAniStage
self.config.set("game","last_theme",currentTheme)
selectedAnimatedStage = self.config.get("game", "animated_stage_folder")
if selectedAnimatedStage != "Normal" and selectedAnimatedStage != "Random":
if not os.path.exists(os.path.join(stagespath,selectedAnimatedStage)):
Log.warn("Selected animated stage folder " + selectedAnimatedStage + " does not exist, forcing Normal.")
self.config.set("game","animated_stage_folder","Normal") #MFH: force "Standard" currently selected animated stage folder is invalid
else:
Config.define("game", "animated_stage_folder", str, "None", text = _("Animated Stage"), options = ["None",_("None")])
Log.warn("No stages\ folder found, forcing None setting for Animated Stage.")
self.config.set("game","animated_stage_folder", "None") #MFH: force "None" when Stages folder can't be found
try:
fp, pathname, description = imp.find_module("CustomTheme",[themepath])
theme = imp.load_module("CustomTheme", fp, pathname, description)
self.theme = theme.CustomTheme(themepath, themename)
except ImportError:
self.theme = Theme(themepath, themename)
self.task.addTask(self.theme)
self.input.addKeyListener(FullScreenSwitcher(self), priority = True)
self.input.addSystemEventListener(SystemEventHandler(self))
self.debugLayer = None
self.startupLayer = None
self.loadingScreenShown = False
self.graphicMenuShown = False
Log.debug("Ready.")
def renderNotes(self, visibility, song, pos):
if not song:
return
if not song.readyToGo:
return
self.bigMax = 0
# Update dynamic period
self.currentPeriod = self.neckSpeed
self.targetPeriod = self.neckSpeed
self.killPoints = False
w = self.boardWidth / self.strings
self.starNotesInView = False
self.openStarNotesInView = False
renderedNotes = reversed(self.getRequiredNotesForRender(song,pos))
for time, event in renderedNotes:
if isinstance(event, Tempo):
self.tempoBpm = event.bpm
if self.lastBpmChange > 0 and self.disableVBPM == True:
continue
if (pos - time > self.currentPeriod or self.lastBpmChange < 0) and time > self.lastBpmChange:
self.baseBeat += (time - self.lastBpmChange) / self.currentPeriod
self.targetBpm = event.bpm
self.lastBpmChange = time
self.neck.lastBpmChange = time
self.neck.baseBeat = self.baseBeat
continue
if not isinstance(event, Note):
continue
if (event.noteBpm == 0.0):
event.noteBpm = self.tempoBpm
if event.number == 0 and self.isDrum: #MFH - skip all open notes
continue
if self.coOpFailed:
if self.coOpRestart:
if time - self.coOpRescueTime < (self.currentPeriod * self.beatsPerBoard * 2):
continue
elif self.coOpRescueTime + (self.currentPeriod * self.beatsPerBoard * 2) < pos:
self.coOpFailed = False
self.coOpRestart = False
Log.debug("Turning off coOpFailed. Rescue successful.")
else:
continue #can't break. Tempo.
x = (self.strings / 2 - (event.number)) * w
c = self.fretColors[event.number]
if event.number == 4 and self.isDrum:
c = self.fretColors[0] #myfingershurt: need to swap note 0 and note 4 colors for drums:
z = ((time - pos) / self.currentPeriod) / self.beatsPerUnit
z2 = ((time + event.length - pos) / self.currentPeriod) / self.beatsPerUnit
if z > self.boardLength * .8:
f = (self.boardLength - z) / (self.boardLength * .2)
elif z < 0:
f = min(1, max(0, 1 + z2))
else:
f = 1.0
#volshebnyi - hide notes in BRE zone if BRE enabled
if self.freestyleEnabled:
if time > self.freestyleStart - self.freestyleOffset and time < self.freestyleStart + self.freestyleOffset + self.freestyleLength:
z = -2.0
if self.twoDnote == True and not self.useFretColors:
color = (1,1,1, 1 * visibility * f)
else:
color = (.1 + .8 * c[0], .1 + .8 * c[1], .1 + .8 * c[2], 1 * visibility * f)
if event.length > 120:
length = (event.length - 50) / self.currentPeriod / self.beatsPerUnit
else:
length = 0
tailOnly = False
spNote = False
#myfingershurt: user setting for starpower refill / replenish notes
if self.starPowerActive:
if self.spRefillMode == 0: #mode 0 = no starpower / overdrive refill notes
self.spEnabled = False
elif self.spRefillMode == 1 and self.theme != 2: #mode 1 = overdrive refill notes in RB themes only
self.spEnabled = False
elif self.spRefillMode == 2 and song.midiStyle != 1: #mode 2 = refill based on MIDI type
self.spEnabled = False
if event.star:
self.starNotesInView = True
if event.finalStar:
self.finalStarSeen = True
self.starNotesInView = True
if event.star and self.spEnabled:
spNote = True
if event.finalStar and self.spEnabled:
spNote = True
if event.played or event.hopod:
if event.flameCount < 1 and not self.starPowerGained:
if self.starPower < 50: #not enough starpower to activate yet, kill existing drumfills
for dfEvent in self.drumFillEvents:
dfEvent.happened = True
Log.debug("star power added")
if self.gameMode2p == 6 and not self.isDrum:
if self.battleSuddenDeath:
self.battleObjects = [1] + self.battleObjects[:2]
else:
self.battleObjects = [self.battleObjectsEnabled[random.randint(0,len(self.battleObjectsEnabled)-1)]] + self.battleObjects[:2]
self.battleGetTime = pos
self.battleObjectGained = True
Log.debug("Battle Object Gained, Objects %s" % str(self.battleObjects))
else:
if self.starPower < 100:
self.starPower += 25
if self.starPower > 100:
self.starPower = 100
self.overdriveFlashCount = 0 #MFH - this triggers the oFlash strings & timer
self.starPowerGained = True
if event.tappable < 2:
isTappable = False
else:
isTappable = True
if (event.played or event.hopod): #if the note is hit
continue
elif z < 0: #Notes past frets
#if none of the below they keep on going, it would be self.notedisappear == 1
if self.notedisappear == 0: #Notes disappear
continue
elif self.notedisappear == 2: #Notes turn red
color = (1, 0, 0, 1)#turn note red
if z + length < -1.0:
continue
if event.length <= 120:
length = None
sustain = False
if event.length > (1.4 * (60000.0 / event.noteBpm) / 4):
sustain = True
glPushMatrix()
glTranslatef(x, 0, z)
if shaders.turnon:
shaders.setVar("note_position",(x, (1.0 - visibility) ** (event.number + 1), z),"notes")
if self.battleStatus[8]:
renderNote = random.randint(0,2)
else:
renderNote = 0
if renderNote == 0:
self.renderNote(length, sustain = sustain, color = color, tailOnly = tailOnly, isTappable = isTappable, string = event.lane, fret = event.number, spNote = spNote)
glPopMatrix()
#myfingershurt: end FOR loop / note rendering loop
if (not self.openStarNotesInView) and (not self.starNotesInView) and self.finalStarSeen:
self.spEnabled = True
self.isStarPhrase = False
self.finalStarSeen = False
def __init__(self, engine):
self.engine = engine
self.logClassInits = Config.get("game", "log_class_inits")
if self.logClassInits == 1:
Log.debug("MainMenu class init (MainMenu.py)...")
self.time = 0.0
self.nextLayer = None
self.visibility = 0.0
self.active = False
self.showStartupMessages = False
self.gfxVersionTag = Config.get("game", "gfx_version_tag")
self.chosenNeck = Config.get("game", "default_neck")
exists = 0
if engine.loadImgDrawing(self, "ok", os.path.join("necks",self.chosenNeck+".png")):
exists = 1
elif engine.loadImgDrawing(self, "ok", os.path.join("necks","Neck_"+self.chosenNeck+".png")):
exists = 1
#MFH - fallback logic now supports a couple valid default neck filenames
#MFH - check for Neck_1
if exists == 0:
if engine.loadImgDrawing(self, "ok", os.path.join("necks","Neck_1.png")):
Config.set("game", "default_neck", "1")
Log.warn("Default chosen neck not valid; fallback Neck_1.png forced.")
exists = 1
#MFH - check for defaultneck
if exists == 0:
if engine.loadImgDrawing(self, "ok", os.path.join("necks","defaultneck.png")):
Log.warn("Default chosen neck not valid; fallback defaultneck.png forced.")
Config.set("game", "default_neck", "defaultneck")
exists = 1
else:
Log.error("Default chosen neck not valid; fallbacks Neck_1.png and defaultneck.png also not valid!")
#Get theme
self.theme = self.engine.data.theme
self.themeCoOp = self.engine.data.themeCoOp
self.themename = self.engine.data.themeLabel
self.useSoloMenu = self.engine.theme.use_solo_submenu
allowMic = True
self.menux = self.engine.theme.menuPos[0]
self.menuy = self.engine.theme.menuPos[1]
self.rbmenu = self.engine.theme.menuRB
#MFH
self.main_menu_scale = self.engine.theme.main_menu_scaleVar
self.main_menu_vspacing = self.engine.theme.main_menu_vspacingVar
if not self.engine.loadImgDrawing(self, "background", os.path.join("themes",self.themename,"menu","mainbg.png")):
self.background = None
self.engine.loadImgDrawing(self, "BGText", os.path.join("themes",self.themename,"menu","maintext.png"))
self.engine.loadImgDrawing(self, "optionsBG", os.path.join("themes",self.themename,"menu","optionsbg.png"))
self.engine.loadImgDrawing(self, "optionsPanel", os.path.join("themes",self.themename,"menu","optionspanel.png"))
#racer: added version tag
if self.gfxVersionTag or self.engine.theme.versiontag:
if not self.engine.loadImgDrawing(self, "version", os.path.join("themes",self.themename,"menu","versiontag.png")):
if not self.engine.loadImgDrawing(self, "version", "versiontag.png"): #falls back on default versiontag.png in data\ folder
self.version = None
else:
self.version = None
#myfingershurt: random main menu music function, menu.ogg and menuXX.ogg (any filename with "menu" as the first 4 letters)
self.files = None
filepath = self.engine.getPath(os.path.join("themes",self.themename,"sounds"))
if os.path.isdir(filepath):
self.files = []
allfiles = os.listdir(filepath)
for name in allfiles:
if os.path.splitext(name)[1] == ".ogg":
if string.find(name,"menu") > -1:
self.files.append(name)
if self.files:
i = random.randint(0,len(self.files)-1)
filename = self.files[i]
sound = os.path.join("themes",self.themename,"sounds",filename)
self.menumusic = True
engine.menuMusic = True
self.song = Audio.Music(self.engine.resource.fileName(sound))
self.song.setVolume(self.engine.config.get("audio", "menu_volume"))
self.song.play(0) #no loop
else:
self.menumusic = False
self.opt_text_color = self.engine.theme.opt_text_colorVar
self.opt_selected_color = self.engine.theme.opt_selected_colorVar
trainingMenu = [
(_("Tutorials"), self.showTutorial),
(_("Practice"), lambda: self.newLocalGame(mode1p = 1)),
]
self.opt_bkg_size = [float(i) for i in self.engine.theme.opt_bkg_size]
self.opt_text_color = self.engine.theme.opt_text_colorVar
self.opt_selected_color = self.engine.theme.opt_selected_colorVar
if self.BGText:
strCareer = ""
strQuickplay = ""
strSolo = ""
strMultiplayer = ""
strTraining = ""
strSettings = ""
strQuit = ""
else:
strCareer = "Career"
strQuickplay = "Quickplay"
strSolo = "Solo"
strMultiplayer = "Multiplayer"
strTraining = "Training"
strSettings = "Settings"
strQuit = "Quit"
multPlayerMenu = [
(_("Face-Off"), lambda: self.newLocalGame(players = 2, maxplayers = 4)),
(_("Pro Face-Off"), lambda: self.newLocalGame(players = 2, mode2p = 1, maxplayers = 4)),
(_("FoFiX Co-Op"), lambda: self.newLocalGame(players = 2, mode2p = 3, maxplayers = 4, allowMic = allowMic)),
(_("RB Co-Op"), lambda: self.newLocalGame(players = 2, mode2p = 4, maxplayers = 4, allowMic = allowMic)),
(_("GH Co-Op"), lambda: self.newLocalGame(players = 2, mode2p = 5, maxplayers = 4)),
(_("GH Battle"), lambda: self.newLocalGame(players = 2, mode2p = 6, allowDrum = False)), #akedrou- so you can block drums
]
if not self.useSoloMenu:
mainMenu = [
(strCareer, lambda: self.newLocalGame(mode1p = 2, allowMic = allowMic)),
(strQuickplay, lambda: self.newLocalGame(allowMic = allowMic)),
((strMultiplayer,"multiplayer"), multPlayerMenu),
((strTraining,"training"), trainingMenu),
((strSettings,"settings"), self.settingsMenu),
(strQuit, self.quit),
]
else:
soloMenu = [
(_("Solo Tour"), lambda: self.newLocalGame(mode1p = 2, allowMic = allowMic)),
(_("Quickplay"), lambda: self.newLocalGame(allowMic = allowMic)),
]
mainMenu = [
((strSolo,"solo"), soloMenu),
((strMultiplayer,"multiplayer"), multPlayerMenu),
((strTraining,"training"), trainingMenu),
((strSettings,"settings"), self.settingsMenu),
(strQuit, self.quit),
]
w, h, = self.engine.view.geometry[2:4]
self.menu = Menu(self.engine, mainMenu, onClose = lambda: self.engine.view.popLayer(self), pos = (self.menux, .75-(.75*self.menuy)))
engine.mainMenu = self #Points engine.mainMenu to the one and only MainMenu object instance
## whether the main menu has come into view at least once
self.shownOnce = False
def __init__(self):
self.logClassInits = Config.get("game", "log_class_inits")
if self.logClassInits == 1:
Log.debug("Input class init (Input.py)...")
Task.__init__(self)
self.mouse = pygame.mouse
self.mouseListeners = []
self.keyListeners = []
self.systemListeners = []
self.priorityKeyListeners = []
self.controls = Controls()
self.activeGameControls = []
self.p2Nav = self.controls.p2Nav
self.type1 = self.controls.type[0]
self.keyCheckerMode = Config.get("game", "key_checker_mode")
self.disableKeyRepeat()
self.gameGuitars = 0
self.gameDrums = 0
self.gameMics = 0
self.gameBots = 0
# Initialize joysticks
pygame.joystick.init()
self.joystickNames = {}
self.joystickAxes = {}
self.joystickHats = {}
self.joysticks = [
pygame.joystick.Joystick(id)
for id in range(pygame.joystick.get_count())
]
for j in self.joysticks:
j.init()
self.joystickNames[j.get_id()] = j.get_name()
self.joystickAxes[j.get_id()] = [0] * j.get_numaxes()
self.joystickHats[j.get_id()] = [(0, 0)] * j.get_numhats()
Log.debug("%d joysticks found." % len(self.joysticks))
# Enable music events
Audio.Music.setEndEvent(MusicFinished)
#Audio.Music.setEndEvent() #MFH - no event required?
# Custom key names
self.getSystemKeyName = pygame.key.name
pygame.key.name = self.getKeyName
self.midi = []
if haveMidi:
pygame.midi.init()
for i in range(pygame.midi.get_count()):
interface, name, is_input, is_output, is_opened = pygame.midi.get_device_info(
i)
Log.debug("Found MIDI device: %s on %s" % (name, interface))
if not is_input:
Log.debug("MIDI device is not an input device.")
continue
try:
self.midi.append(pygame.midi.Input(i))
Log.debug("Device opened as device number %d." %
len(self.midi))
except pygame.midi.MidiException:
Log.error("Error opening device for input.")
if len(self.midi) == 0:
Log.debug("No MIDI input ports found.")
else:
Log.notice(
"MIDI input support is not available; install at least pygame 1.9 to get it."
)
def keyPressed(self, key, unicode):
self.lastTime = self.time
c = self.engine.input.controls.getMapping(key)
if key == pygame.K_SLASH and not self.searching:
self.searching = True
elif (key in range(30,123) or key == pygame.K_BACKSPACE) and not self.moreInfo:
if self.searching:
if key == pygame.K_BACKSPACE:
self.searchText = self.searchText[:-1]
else:
self.searchText += unicode
return
else:
if unicode:
for i, item in enumerate(self.items):
if isinstance(item, Song.SongInfo):
if self.sortOrder in [0, 2, 5]:
sort = item.name.lower()
elif self.sortOrder == 1:
sort = item.artist.lower()
elif self.sortOrder == 3:
sort = item.album.lower()
elif self.sortOrder == 4:
sort = item.genre.lower()
elif self.sortOrder == 6:
sort = str(item.diffSong)
elif self.sortOrder == 7:
sort = str(instrumentDiff[self.scorePart.id](item))
elif self.sortOrder == 8:
sort = item.icon.lower()
else:
sort = ""
if sort.startswith(unicode):
self.selectedIndex = i
self.updateSelection()
break
elif (c in Player.menuNo and not c in Player.cancels) or key == pygame.K_ESCAPE:
self.engine.data.cancelSound.play()
if self.searching:
self.searchText = ""
self.searching = False
return
if self.moreInfo:
self.moreInfo = False
if self.moreInfoTime > 500:
self.moreInfoTime = 500
return
if self.songLoader:
self.songLoader.stop()
self.songLoader = None
return
if self.song:
self.song.fadeout(1000)
if self.library != Song.DEFAULT_LIBRARY and not self.tut and (self.listingMode == 0 or self.careerMode):
self.initialItem = self.library
self.library = os.path.dirname(self.library)
if self.library == os.path.join("..", self.engine.config.get("setlist", "base_library")):
self.quit()
return
self.selectedItem = None
self.loadLibrary()
else:
self.quit()
elif (c in Player.menuYes and not c in Player.starts) or key == pygame.K_RETURN:
if self.searching:
self.searching = False
text = self.searchText.lower()
for i, item in enumerate(self.items):
sort = item.name.lower()
if sort.startswith(text):
self.selectedIndex = i
self.updateSelection()
break
self.searchText = ""
return
self.engine.data.acceptSound.play()
if isinstance(self.selectedItem, Song.LibraryInfo):
self.library = self.selectedItem.libraryName
self.startingSelected = None
Log.debug("New library selected: " + str(self.library) )
self.loadLibrary()
elif isinstance(self.selectedItem, Song.SongInfo) and not self.selectedItem.getLocked():
if self.listingMode == 1 and not self.careerMode:
self.library = self.selectedItem.libraryNam #TODO: SongDB
self.libraryName = self.selectedItem.libraryNam
self.songName = self.selectedItem.songName
self.engine.config.set("setlist", "selected_library", self.libraryName)
self.engine.config.set("setlist", "selected_song", self.songName)
if self.checkParts():
if self.queueFormat == 0:
self.engine.world.songQueue.addSong(self.songName, self.libraryName)
self.startGame()
elif self.queueFormat == 1:
if self.engine.world.songQueue.addSongCheckReady(self.songName, self.libraryName):
self.startGame()
elif c in Player.menuYes and c in Player.starts:
self.engine.data.acceptSound.play()
if self.queueFormat == 0:
self.engine.world.songQueue.addSong(self.songName, self.libraryName)
self.startGame()
elif c in Player.menuDown or key == pygame.K_DOWN:
self.scrolling = 2
self.scrollTime = self.scrollDelay
self.scrollDown()
elif c in Player.menuUp or key == pygame.K_UP:
self.scrolling = 1
self.scrollTime = self.scrollDelay
self.scrollUp()
elif c in Player.key3s or key == pygame.K_F3:
self.previewDelay = 0
elif c in Player.key4s or key == pygame.K_F12:
if isinstance(self.selectedItem, Song.SongInfo):
self.moreInfo = True
elif c in Player.menuNo and c in Player.cancels:
self.engine.view.pushLayer(self.menu)
def __init__(self, resource, svg):
self.logClassInits = Config.get("game", "log_class_inits")
if self.logClassInits == 1:
Log.debug("Data class init (Data.py)...")
self.logLoadings = Config.get("game", "log_loadings")
self.logImageNotFound = Config.get("log", "log_image_not_found")
self.resource = resource
self.svg = svg
self.sfxVolume = Config.get("audio", "SFX_volume")
self.crowdVolume = Config.get("audio", "crowd_volume")
#Get theme
themename = Config.get("coffee", "themename")
self.themeLabel = themename
self.themeCoOp = False
self.players = None
self.players = Player.loadPlayers()
#myfingershurt: check for existence of theme path
themepath = os.path.join(Version.dataPath(), "themes")
self.themepath = themepath
self.path = Version.dataPath()
if not self.checkImgDrawing(os.path.join("themes",themename,"notes","notes.png")):
#myfingershurt: here need to ensure an existing theme is selected
themes = []
defaultTheme = None #myfingershurt
allthemes = os.listdir(themepath)
for name in allthemes:
if self.checkImgDrawing(os.path.join("themes",name,"notes","notes.png")):
themes.append(name)
if name == "MegaLight V4": #myfingershurt
defaultTheme = name #myfingershurt
if defaultTheme != "MegaLight V4": #myfingershurt
defaultTheme = themes[0] #myfingershurt
#not a valid theme if notes.png isn't there! Force default theme:
Config.set("coffee", "themename",defaultTheme)
#re-init Data with new default
themename = defaultTheme
self.themeLabel = themename
if not os.path.exists(os.path.join(Version.dataPath(), "themes", themename, "vocals")):
self.vocalPath = "vocals"
else:
self.vocalPath = os.path.join("themes",themename,"vocals")
self.theme = 2
self.themeCoOp = True
self.fontScreenBottom = 0.75 #from our current viewport's constant 3:4 aspect ratio (which is always stretched to fill the video resolution)
self.loadPartImages()
#myfingershurt: multi-OS compatibility file access fixes using os.path.join()
# load font customization images
#Worldrave - Use new defined Star3 and star4. Using star1 and star2 as a fallback.
#MFH - no more custom glyphs, these are wasting memory.
#MFH - but we do need these star1-4 images anyway. Leaving them loaded here in the Data object.
self.loadImgDrawing(self, "star1", os.path.join("themes",themename,"star1.png"), textureSize = (128, 128))
self.loadImgDrawing(self, "star2", os.path.join("themes",themename,"star2.png"), textureSize = (128, 128))
#MFH - let's not rely on errors here if we don't have to...
if not self.loadImgDrawing(self, "star3", os.path.join("themes",themename,"star3.png"), textureSize = (128, 128)):
self.star3 = self.star1
if not self.loadImgDrawing(self, "star4", os.path.join("themes",themename,"star4.png"), textureSize = (128, 128)):
self.star4 = self.star2
if self.loadImgDrawing(self, "starPerfect", os.path.join("themes",themename,"starperfect.png"), textureSize = (128, 128)):
self.perfectStars = True
self.maskStars = False
else:
self.starPerfect = self.star2
self.fcStars = False
self.starFC = self.star2
self.maskStars = True
self.perfectStars = False
if self.perfectStars:
if self.loadImgDrawing(self, "starFC", os.path.join("themes",themename,"starfc.png"), textureSize = (128, 128)):
self.fcStars = True
else:
self.starFC = self.starPerfect
self.fcStars = False
# load misc images
self.loadImgDrawing(self, "loadingImage", os.path.join("themes",themename,"loadingbg.png"), textureSize = (256,256))
self.loadImgDrawing(self, "optionsBG", os.path.join("themes",themename,"menu","optionsbg.png"))
if self.loadImgDrawing(self, "submenuSelect", os.path.join("themes",themename,"submenuselect.png")):
subSelectImgW = self.submenuSelect.width1()
self.submenuSelectFound = True
self.subSelectWFactor = 640.000/subSelectImgW
self.subSelectImgH = self.submenuSelect.height1()
else:
self.submenuSelectFound = False
self.loadImgDrawing(self, "submenuSelect", os.path.join("themes",themename,"menu","selected.png"))
self.subSelectWFactor = 0
# load all the data in parallel
# asciiOnly = not bool(Language.language) or Language.language == "Custom"
# reversed = _("__lefttoright__") == "__righttoleft__" and True or False
asciiOnly = True
reversed = False
scale = 1
# evilynux - Load bigger fonts so they're nicer when scaled, scaling readjusted
fontSize = [44, 132, 34, 32, 30]
w, h = [int(s) for s in Config.get("video", "resolution").split("x")]
aspectRatio = float(w)/float(h)
self.fontList = [
["font1","font","default.ttf",fontSize[4]],
["font2","bigFont","title.ttf",fontSize[1]],
["font3","pauseFont","pause.ttf",fontSize[2]],
["font4","scoreFont","score.ttf",fontSize[3]],
["font5","streakFont","streak.ttf",fontSize[3]],
["font6","loadingFont","loading.ttf",fontSize[3]],
["font7","songFont","song.ttf",fontSize[4]],
["font8","songListFont","songlist.ttf",fontSize[3]],
["font9","shadowFont","songlist.ttf",fontSize[3]],
["font10","streakFont2","streakphrase.ttf",fontSize[2]]
]
for f in self.fontList:
if self.fileExists(os.path.join("themes",themename,"fonts",f[2])):
fn = resource.fileName(os.path.join("themes",themename,"fonts",f[2]))
f[0] = lambda: Font(fn, f[3], scale = scale*.5, reversed = reversed, systemFont = not asciiOnly, outline = False, aspectRatio = aspectRatio)
resource.load(self,f[1],f[0], synch = True)
elif self.fileExists(os.path.join("themes",themename,"fonts","default.ttf")):
Log.debug("Theme font not found: " + f[2])
fn = resource.fileName(os.path.join("themes",themename,"fonts","default.ttf"))
f[0] = lambda: Font(fn, f[3], scale = scale*.5, reversed = reversed, systemFont = not asciiOnly, outline = False, aspectRatio = aspectRatio)
resource.load(self,f[1],f[0], synch = True)
else:
Log.debug("Default theme font not found: %s - using built-in default" % str(f[2]))
fn = resource.fileName(os.path.join("fonts","default.ttf"))
f[0] = lambda: Font(fn, f[3], scale = scale*.5, reversed = reversed, systemFont = not asciiOnly, outline = False, aspectRatio = aspectRatio)
resource.load(self,f[1],f[0], synch = True)
self.fontDict = {"font": self.font, "bigFont": self.bigFont, "pauseFont": self.pauseFont, "scoreFont": self.scoreFont, \
"streakFont": self.streakFont, "songFont": self.songFont, "streakFont2": self.streakFont2, \
"songListFont": self.songListFont, "shadowFont": self.shadowFont, "loadingFont": self.loadingFont}
assert self.fontDict['font'] == self.font
# load sounds asynchronously
resource.load(self, "screwUpsounds", self.loadScrewUpsounds)
resource.load(self, "screwUpsoundsBass", self.loadScrewUpsoundsBass)
resource.load(self, "screwUpsoundsDrums", self.loadScrewUpsoundsDrums)
resource.load(self, "acceptSounds", self.loadAcceptSounds)
resource.load(self, "cancelSounds", self.loadBackSounds)
# loadSoundEffect asynchronously
self.syncSounds = [
["bassDrumSound","bassdrum.ogg"],
["battleUsedSound","battleused.ogg"],
["CDrumSound","crash.ogg"],
["clapSound","clapsound.ogg"],
["coOpFailSound","coopfail.ogg"],
#["crowdSound","crowdcheers.ogg"],
["failSound","failsound.ogg"],
["rescueSound","rescue.ogg"],
["rockSound","rocksound.ogg"],
["selectSound1","select1.ogg"],
["selectSound2","select2.ogg"],
["selectSound3","select3.ogg"],
["starActivateSound","staractivate.ogg"],
["starDeActivateSound","stardeactivate.ogg"],
["starDingSound","starding.ogg"],
["starLostSound","starlost.ogg"],
["starReadySound","starpowerready.ogg"],
["starSound","starpower.ogg"],
["startSound","start.ogg"],
["T1DrumSound","tom01.ogg"],
["T2DrumSound","tom02.ogg"],
["T3DrumSound","tom03.ogg"]
]
for self.sounds in self.syncSounds:
if self.fileExists(os.path.join("themes",themename,"sounds",self.sounds[1])):
self.loadSoundEffect(self, self.sounds[0], os.path.join("themes",themename,"sounds",self.sounds[1]))
elif self.fileExists(os.path.join("sounds", self.sounds[1])):
Log.debug("Theme sound not found: " + self.sounds[1])
self.loadSoundEffect(self, self.sounds[0], os.path.join("sounds",self.sounds[1]))
else:
Log.warn("File " + self.sounds[1] + " not found using default instead.")
self.loadSoundEffect(self, self.sounds[0], os.path.join("sounds","default.ogg"))
#TODO: Simplify crowdSound stuff so it can join the rest of us.
#MFH - fallback on sounds/crowdcheers.ogg, and then starpower.ogg. Note if the fallback crowdcheers was used or not.
if self.fileExists(os.path.join("themes",themename,"sounds","crowdcheers.ogg")):
self.loadSoundEffect(self, "crowdSound", os.path.join("themes",themename,"sounds","crowdcheers.ogg"), crowd = True)
self.cheerSoundFound = 2
elif self.fileExists(os.path.join("sounds","crowdcheers.ogg")):
self.loadSoundEffect(self, "crowdSound", os.path.join("sounds","crowdcheers.ogg"), crowd = True)
self.cheerSoundFound = 1
Log.warn(themename + "/sounds/crowdcheers.ogg not found -- using data/sounds/crowdcheers.ogg instead.")
else:
self.cheerSoundFound = 0
Log.warn("crowdcheers.ogg not found -- no crowd cheering.")
def __init__(self, engine, playerObj, editorMode=False, player=0):
super(Drum, self).__init__(engine, playerObj, player)
self.isDrum = True
self.isBassGuitar = False
self.isVocal = False
self.drumsHeldDown = [0, 0, 0, 0, 0]
self.gameMode2p = self.engine.world.multiMode
self.lastFretWasBassDrum = False
self.lastFretWasT1 = False #Faaa Drum sound
self.lastFretWasT2 = False
self.lastFretWasT3 = False
self.lastFretWasC = False
self.matchingNotes = None
#MFH - I do not understand fully how the handicap scorecard works at the moment, nor do I have the time to figure it out.
#... so for now, I'm just writing some extra code here for the early hitwindow size handicap.
self.earlyHitWindowSizeFactor = 0.5
self.starNotesInView = False
self.openStarNotesInView = False
self.drumFillsCount = 0
self.drumFillsTotal = 0
self.drumFillsHits = 0
self.drumFillsReady = False
self.drumFillEvents = []
self.drumFillWasJustActive = False
self.strings = 4
self.strings2 = 5
self.playedSound = [True, True, True, True, True]
self.openFretActivity = 0.0
self.openFretColor = self.fretColors[5]
self.editorMode = editorMode
self.lanenumber = float(4)
self.fretImgColNumber = float(6)
self.logClassInits = self.engine.config.get("game", "log_class_inits")
if self.logClassInits == 1:
Log.debug("Drum class initialization!")
self.freestyleHitFlameCounts = [0
for n in range(self.strings + 1)] #MFH
self.fretWeight = [0.0] * self.strings
self.fretActivity = [0.0] * self.strings
#myfingershurt:
self.hopoStyle = 0
self.drumFretButtons = None
#blazingamer
self.opencolor = self.fretColors[5]
self.rockLevel = 0.0
self.bigMax = 1
if self.engine.config.get("game", "large_drum_neck"):
self.boardWidth *= (4.0 / 3.0)
self.boardLength *= (4.0 / 3.0)
#Get theme
#now theme determination logic is only in data.py:
self.theme = self.engine.data.theme
self.tailsEnabled = False
self.loadImages()
self.barsColor = self.engine.theme.barsColor
self.neck = Neck(self.engine, self, playerObj)
def checkCmdPlay(self):
info = Song.loadSongInfo(self.engine, self.songName, library = self.libraryName)
guitars = []
drums = []
vocals = []
autoPart = None
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 self.engine.cmdPlay == 2 and self.engine.cmdPart is not None and len(self.playerList) == 1:
if self.engine.cmdPart == part.id:
Log.debug("Command-line mode: Part found!")
if part.id == 4 and self.engine.input.gameDrums > 0:
autoPart = part.id
elif part.id == 5 and self.engine.input.gameMics > 0:
autoPart = part.id
elif self.engine.input.gameGuitars > 0:
autoPart = part.id
if autoPart is None:
if len(drums) == 0 and self.engine.input.gameDrums > 0:
if self.splash:
Dialogs.hideLoadingSplashScreen(self.engine, self.splash)
self.splash = None
Dialogs.showMessage(self.engine, _("There are no drum parts in this song. Change your controllers to play."))
if self.engine.cmdPlay == 2:
self.engine.cmdPlay = 0
return False
if len(guitars) == 0 and self.engine.input.gameGuitars > 0:
if self.splash:
Dialogs.hideLoadingSplashScreen(self.engine, self.splash)
self.splash = None
Dialogs.showMessage(self.engine, _("There are no guitar parts in this song. Change your controllers to play."))
if self.engine.cmdPlay == 2:
self.engine.cmdPlay = 0
return False
if len(vocals) == 0 and self.engine.input.gameMics > 0:
if self.splash:
Dialogs.hideLoadingSplashScreen(self.engine, self.splash)
self.splash = None
Dialogs.showMessage(self.engine, _("There are no vocal parts in this song. Change your controllers to play."))
if self.engine.cmdPlay == 2:
self.engine.cmdPlay = 0
return False
# Make sure the difficulty we chose is available
p = self.playerList[0].part
player = self.playerList[0]
if self.engine.cmdDiff is not None:
diff = Song.difficulties[self.engine.cmdDiff]
if diff in info.partDifficulties[p.id]:
self.playerList[0].difficulty = diff
else:
self.playerList[0].difficulty = info.partDifficulties[p.id][0]
else:
if self.splash:
Dialogs.hideLoadingSplashScreen(self.engine, self.splash)
self.splash = None
self.playerList[0].difficulty = Dialogs.chooseItem(self.engine, info.partDifficulties[p.id],
"%s \n %s" % (Song.removeSongOrderPrefixFromName(info.name), _("%s Choose a difficulty:") % player.name), selected = player.difficulty)
return True
