def build(self):
Window.size = (320, 480)
sm = ScreenManager()
sm.add_widget(
SplashScreen(name='SplashScreen', sm=sm, switchTo='_2048Game'))
sm.add_widget(_2048Game(name='_2048Game'))
sm.current = 'SplashScreen'
#sm.current = '_2048Game'
return sm
def appStarted(app):
app.splashScreen = SplashScreen()
app.suit = Suit()
app.informationScreen = InformationScreen()
app.draft = DraftMode()
app.teamPage = TeamPage()
app.simulateGame = SimulateGame()
app.gameOverScreen = GameOverScreen()
app.setActiveMode(app.splashScreen)
def __init__(self, argv, hidden=False):
super(CollectorApplication, self).__init__(argv)
# Create and display the splash screen
if not hidden:
self.splash = SplashScreen()
self.splash.show()
self.processEvents()
self.view = None
self.uri = None
self.home = None
if argv is not None:
self.parse_args(argv)
# Launch collector
self.collector = Collector(self.home)
self.load_translations(":/lang")
# Create the main window
# FIXME: Some view variables are language dependent,
# is needed to import them after load the language settings
from mainwindow import MainWindow
self.main = MainWindow()
self.main.views = CollectorApplication.get_views(self.main)
self.main.display_view('dashboard')
if not hidden:
# Show main window
self.main.show()
# Hide splash
self.splash.finish(self.main)
# Bring window to front if development
if 'COLLECTION_PATH' in os.environ:
self.main.raise_()
if self.view is not None:
self.main.display_view(self.view)
elif self.uri is not None:
self.main.collector_uri_call(self.uri)
def __init__(self, profile):
self._splash = SplashScreen()
QMainWindow.__init__(self)
self.setupUi(self)
self._profile = profile
self.rollback_button.clicked.connect(self.load)
self.commit_button.clicked.connect(self.commit)
self.key_list.currentItemChanged.connect(self.key_item_selected)
self.key_list.itemChanged.connect(self.key_item_changed)
self.server_tree.itemChanged.connect(self.server_item_selected)
self.add_key_button.clicked.connect(self.import_key)
self.remove_key_button.clicked.connect(self.remove_key)
self.action_import_key.triggered.connect(self.import_key)
self.action_profiles.triggered.connect(self.open_profiles)
self.action_exit.triggered.connect(self.close)
self.action_about.triggered.connect(self.about)
self.load()
self.move(self._splash.pos() + self._splash.rect().center() - self.rect().center());
class CollectorApplication(QtGui.QApplication):
"""The GUI Application for Collector"""
translators = {}
current = None
collector = None
def __init__(self, argv, hidden=False):
super(CollectorApplication, self).__init__(argv)
# Create and display the splash screen
if not hidden:
self.splash = SplashScreen()
self.splash.show()
self.processEvents()
self.view = None
self.uri = None
self.home = None
if argv is not None:
self.parse_args(argv)
# Launch collector
self.collector = Collector(self.home)
self.load_translations(":/lang")
# Create the main window
# FIXME: Some view variables are language dependent,
# is needed to import them after load the language settings
from mainwindow import MainWindow
self.main = MainWindow()
self.main.views = CollectorApplication.get_views(self.main)
self.main.display_view('dashboard')
if not hidden:
# Show main window
self.main.show()
# Hide splash
self.splash.finish(self.main)
# Bring window to front if development
if 'COLLECTION_PATH' in os.environ:
self.main.raise_()
if self.view is not None:
self.main.display_view(self.view)
elif self.uri is not None:
self.main.collector_uri_call(self.uri)
def parse_args(self, argv):
"""Parse argv, the input arguments"""
if '--view' in argv:
self.view = argv[argv.index('--view') + 1]
elif '--uri' in argv:
self.uri = argv[argv.index('--uri') + 1]
if '--home' in argv:
self.home = self._checkhome(argv[argv.index('--home') + 1])
elif '-h' in argv:
self.home = self._checkhome(argv[argv.index('-h') + 1])
def _checkhome(self, value):
"""Checks the home value"""
truehome = os.path.realpath(value)
if truehome is None:
raise Exception("Wrong home folder")
self.quit()
return truehome
# The language code selector is from:
# "switch translations dynamically in a PyQt4 application"
#
# PyQt version by Hans-Peter Jansen <*****@*****.**>
def load_translations(self, folder):
"""Loads the transaltions from the parameter folder, the translations
must match the pattern *_*.qm"""
if not isinstance(folder, QtCore.QDir):
folder = QtCore.QDir(folder)
pattern = "*_*.qm" # <language>_<country>.qm
filters = QtCore.QDir.Files | QtCore.QDir.Readable
sort = QtCore.QDir.SortFlags(QtCore.QDir.Name)
for lang_file in folder.entryInfoList([pattern], filters, sort):
# pick country and language out of the file name
language, country = lang_file.baseName().split("_", 1)
language = language.toLower()
country = country.toUpper()
locale = language + "_" + country
# only load translation, if it does not exist already
if not locale in CollectorApplication.translators:
# create and load translator
translator = QtCore.QTranslator(self.instance())
if translator.load(lang_file.absoluteFilePath()):
CollectorApplication.translators[locale] = translator
system = QtCore.QLocale.system()
# Get user language from collector.conf
user_language = self.collector.conf('lang')
# if user_language is ':system:' or is empty, use the system language
if user_language in [':system:', '']:
user_language = system.name()
# Look if the user_language exists, then set as current language
for lang in CollectorApplication.available_languages():
if str(lang) == user_language:
# language match the current system
CollectorApplication.set_language(lang)
@staticmethod
def available_languages():
""" Returns the avaible languages (code_country) as a list"""
return sorted(CollectorApplication.translators.keys())
@staticmethod
def set_language(locale):
""" Sets the language of the application using the deseired locale"""
app = CollectorApplication
if app.current:
app.removeTranslator(app.current)
app.current = app.translators.get(locale, None)
if app.current is not None:
app.installTranslator(app.current)
qt_qm = app.translators.get('qt' + locale[2:], None)
if qt_qm is not None:
app.installTranslator(qt_qm)
@staticmethod
def get_views(parent):
""" Initialize the avaible views, each view is loaded by a provider"""
return {
'dashboard': DashboardView(parent),
'fitxa': FitxaView(parent),
'edit': FitxaEditView(parent),
'collection': CollectionView(parent),
'add': FitxaNewView(parent),
'search': SearchView(parent),
'discover': DiscoverView(parent),
'preferences': PreferencesView(parent),
'quicksearch': SearchDialog(parent),
'properties': PropertiesView(parent),
'pluginfile': PluginFileView(parent),
'filters': AdvancedSearch(parent),
'import': ImportView(parent),
'export': ExportView(parent),
}
def __init__(self, x, y, width, height):
SplashScreen.__init__(self, x, y, width, height)
self.logo = PhysicsBody(0, 0, width, height, ASSET.studio_logo)
self.state = STATE.logo
self.assemble()
class MainWindow(QMainWindow, Ui_main):
_servers = {}
_keys = {}
_commit_keys = {}
_items = {}
_splash = None
_profile = None
_selected_key_name = None
_reload_profiles = False
def __init__(self, profile):
self._splash = SplashScreen()
QMainWindow.__init__(self)
self.setupUi(self)
self._profile = profile
self.rollback_button.clicked.connect(self.load)
self.commit_button.clicked.connect(self.commit)
self.key_list.currentItemChanged.connect(self.key_item_selected)
self.key_list.itemChanged.connect(self.key_item_changed)
self.server_tree.itemChanged.connect(self.server_item_selected)
self.add_key_button.clicked.connect(self.import_key)
self.remove_key_button.clicked.connect(self.remove_key)
self.action_import_key.triggered.connect(self.import_key)
self.action_profiles.triggered.connect(self.open_profiles)
self.action_exit.triggered.connect(self.close)
self.action_about.triggered.connect(self.about)
self.load()
self.move(self._splash.pos() + self._splash.rect().center() - self.rect().center());
def load(self, action=u'load'):
self.key_list.blockSignals(True)
if action == u'commit':
self._commit_keys = self._keys
else:
self._commit_keys = {}
self._keys = {}
self._items = {}
self.hide()
self._splash.setProgress(0.0, u'Loading server list...')
self._splash.show()
for _ in range(20):
time.sleep(0.001)
QApplication.processEvents()
try:
self.load_server_list()
self.load_key_list(action)
self._splash.hide()
self.show()
self.key_list.blockSignals(False)
item = self.key_list.item(0)
item.setSelected(True)
self.key_item_selected(item)
except (jsonschema.SchemaError, jsonschema.ValidationError) as ex:
self.key_list.blockSignals(False)
self.server_tree.blockSignals(False)
self._splash.close()
raise ex
def load_server_list(self):
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
try:
ssh.connect(self._profile[u'host'], username=self._profile[u'user'],
key_filename=self._profile[u'key'] if self._profile[u'key'] else None,
timeout=self._profile[u'timeout'])
except socket.error as ex:
self._splash.close()
raise ex
_, stdout, stderr = ssh.exec_command('cat %s' % self._profile['file'])
error = stderr.read()
if error:
raise NameError(error)
schema_file = open('media/servers-schema-1.0.json', 'r')
schema = json.load(schema_file)
schema_file.close()
self._servers = json.load(stdout)
validate(self._servers, schema)
ssh.close()
self.server_tree.blockSignals(True)
self._items = {}
while self.server_tree.topLevelItemCount() > 0:
self.server_tree.takeTopLevelItem(0)
for group, servers in self._servers[u'servers'].items():
group_item = self.add_server_tree_item(group)
for server_name, server in servers.items():
server_item = self.add_server_tree_item(server_name, group_item)
for user in server[u'users']:
item = self.add_server_tree_item(user, server_item, True)
self._items[server_name] = {user: item}
self.server_tree.expandAll()
self.server_tree.blockSignals(False)
def add_server_tree_item(self, label, parent=None, is_leaf=False):
item = QTreeWidgetItem(parent)
item.setText(0, unicode(label))
if is_leaf:
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsUserCheckable)
self.server_tree.addTopLevelItem(item)
return item
def load_key_list(self, action):
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
total = 1
for servers in self._servers[u'servers'].values():
for server in servers.values():
total += len(server[u'users'])
i=0
for servers in self._servers[u'servers'].values():
for server_name, server in sorted(servers.items()):
for user in server[u'users']:
i += 1
self._splash.setProgress(float(i)/float(total), u'%s %s %s settings...' % (u'Writing' if action == u'commit' else u'Loading', server_name, user))
self.load_key_list_from(ssh, server_name, server[u'host'], user, action)
self.reload_key_list()
def reload_key_list(self):
while self.key_list.count() > 0:
self.key_list.takeItem(0)
for key in sorted(self._keys.keys()):
item = QListWidgetItem(unicode(key))
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsEditable)
item.setData(Qt.UserRole, unicode(key))
self.key_list.addItem(item)
def load_key_list_from(self, ssh, server_name, host, user, action):
try:
ssh.connect(host, username=user, key_filename=self._profile[u'key'] if self._profile[u'key'] else None,
timeout=self._profile[u'timeout'])
except:
ssh.close()
self.server_tree.blockSignals(True)
self._items[server_name][user].setDisabled(True)
self.server_tree.blockSignals(False)
return
if action == u'commit':
sftp = ssh.open_sftp()
keyfile = sftp.open('./.ssh/authorized_keys.new', 'w')
content = u''
for keyname, key in self._commit_keys.items():
if (server_name, user) in key[u'servers']:
content += (key[u'full'] + u'\n' )
keyfile.write(content)
keyfile.close()
sftp.close()
ssh.exec_command('mv ./.ssh/authorized_keys.new ./.ssh/authorized_keys')
_, stdout, _ = ssh.exec_command('cat ./.ssh/authorized_keys')
for line in stdout.readlines():
keyline = unicode(line).split(' ')
if len(keyline) == 3:
proto = keyline[0].rstrip()
key = keyline[1].rstrip()
keyname = keyline[2].rstrip()
for i_keyname, i_key in self._keys.items():
if i_keyname != keyname and i_key[u'proto'] == proto and i_key[u'key'] == key:
keyname = i_keyname
i = 1
while self._keys.has_key(keyname):
if self._keys[keyname][u'proto'] != proto or self._keys[keyname][u'key'] != key:
i += 1
keyname = keyline[2] + u'_%s' % i
else:
if not (server_name, user) in self._keys[keyname][u'servers']:
self._keys[keyname][u'servers'].append((server_name, user))
break
if not self._keys.has_key(keyname):
self._keys[keyname] = {u'proto' : proto, u'key' : key, u'full' : line.rstrip(), u'servers' : [(server_name, user)]}
ssh.close()
def key_item_selected(self, item):
if not item:
return
self.server_tree.blockSignals(True)
self._selected_key_name = unicode(item.text())
key = self._keys[self._selected_key_name]
self.key_edit.setText(key[u'full'])
for server, users in self._items.items():
for user, item in users.items():
if (server, user) in key[u'servers']:
item.setCheckState(0, Qt.Checked)
else:
item.setCheckState(0, Qt.Unchecked)
self.server_tree.blockSignals(False)
def key_item_changed(self, item):
if unicode(item.text()) != unicode(item.data(Qt.UserRole).toString()):
self._keys[unicode(item.text())] = self._keys.pop(unicode(item.data(Qt.UserRole).toString()))
self._keys[unicode(item.text())][u'full'] = '%s %s %s' % (self._keys[unicode(item.text())][u'proto'],
self._keys[unicode(item.text())][u'key'],
unicode(item.text()))
item.setData(Qt.UserRole, unicode(item.text()))
def server_item_selected(self, item):
user = unicode(item.text(0))
server_name = unicode(item.parent().text(0))
if item.checkState(0) == Qt.Checked:
if (server_name, user) not in self._keys[self._selected_key_name][u'servers']:
self._keys[self._selected_key_name][u'servers'].append((server_name, user))
else:
if (server_name, user) in self._keys[self._selected_key_name][u'servers']:
self._keys[self._selected_key_name][u'servers'].remove((server_name, user))
def commit(self):
self.load(u'commit')
def import_key(self):
add_key_dialog = AddKeyDialog()
add_key_dialog.exec_()
new_key = add_key_dialog.key()
if new_key:
self._keys[new_key['keyname']] = {
u'proto' : new_key['proto'],
u'key' : new_key['key'],
u'full' : new_key['full'],
u'servers' : []
}
item = QListWidgetItem(unicode(new_key[u'keyname']))
self.key_list.addItem(item)
self.key_list.sortItems()
item.setSelected(True)
self.key_item_selected(item)
def remove_key(self):
del self._keys[self._selected_key_name]
self.reload_key_list()
item = self.key_list.item(0)
item.setSelected(True)
self.key_item_selected(item)
def reload_profiles(self):
if self._reload_profiles:
self._reload_profiles = False
return True
return False
def open_profiles(self):
self._reload_profiles = True
self.close()
def about(self):
QMessageBox.about(self.parent(), u"About SSH key manager",
u"<big><b>SSH key manager</b></big><br/><i>v1.0_alpha1</i><br/><br/>" +
u"<b>Author:</b>" + u"<br/>Hervé Martinet<br/><br/>" +
u'<b>Splashscreen Photo:</b><br/>Joel Bennett<br/><a href="http://www.flickr.com/photos/jaykul/">http://www.flickr.com/photos/jaykul/</a>' +
u'<br/><i>licensed under a Creative Commons (CC BY-NC-SA 2.0)</i><br/><br/>' +
u'<b>Icon Set:</b><br/>Default Icon by interactivemania<br/><a href="http://www.defaulticon.com/">http://www.defaulticon.com/</a>' +
u'<br/><i>licensed under a Creative Commons (CC BY-ND 3.0)</i>')
def __init__(self):
pygame.init()
pygame.font.init()
pygame.mixer.init()
os.environ["SDL_VIDEO_CENTERED"] = "1"
self.screen = SCREEN.display
self.fpsClock = pygame.time.Clock()
self.fps = GAME.fps
self.ticks = 0
self.firstrun = True
self.music = Music("mainmenu.ogg", 0.5, -1)
self.menu_music = False
self.game_music = False
self.game_time = GameText("0", 24, True)
self.game_time.font_file = FONT.default
self.game_time.centerx = SCREEN.width/2
self.game_time.y = 18
self.game_time.color = COLOR.white
self.game_time.create()
self.timer_red = False
self.flash_timer = 0
self.p1_score = GameText("0", 24, True)
self.p1_score.font_file = FONT.default
self.p1_score.left = 30
self.p1_score.y = 18
self.p1_score.color = COLOR.blue_sea
self.p1_score.create()
self.p2_score = GameText("0", 24, True)
self.p2_score.font_file = FONT.default
self.p2_score.right = SCREEN.width - 30
self.p2_score.y = 18
self.p2_score.color = COLOR.petal_green
self.p2_score.create()
self.bg_text = GameText("01", 72, True)
self.bg_text.font_file = FONT.kenpixel_blocks
self.bg_text.centerx = SCREEN.width/2
self.bg_text.centery = SCREEN.height/2
self.bg_text.color = COLOR.gray7
self.bg_text.create()
self.state = STATE.logo
self.stage_number = 1
self.stage = Stage(self.stage_number)
self.hi_score = 0
self.splashscreen = SplashScreen(0, 0, SPLASHSCREEN.width, SPLASHSCREEN.height)
self.logoscreen = LogoScreen(0, 0, LOGO.width, LOGO.height)
self.timer = GAME.time
self.totalscore = 0
self.p1_scores = {}
self.p2_scores = {}
self.camera = Camera(self.complex_camera, self.stage.level.width, self.stage.level.height)
self.bg = SCREEN.bg
self.screen_color = (choice(COLOR.colors))
self.menu = Menu(SCREEN.width, SCREEN.height, self.screen_color)
self.score_screen = ScoreScreen()
self.controls_screen = Controls()
self.screen_number = 1
self.capture_video = False
self.countdownOverlay = CountDownOverlay()
self.intro = True
self.intro_countdown = self.fps * 4
self.scanlines = ScanLines()
self.controller_present = False
try:
self.player1_joy = pygame.joystick.Joystick(0)
self.player1_joy.init()
self.controller_present = True
except:
pass
class GameEngine(object):
def __init__(self):
pygame.init()
pygame.font.init()
pygame.mixer.init()
os.environ["SDL_VIDEO_CENTERED"] = "1"
self.screen = SCREEN.display
self.fpsClock = pygame.time.Clock()
self.fps = GAME.fps
self.ticks = 0
self.firstrun = True
self.music = Music("mainmenu.ogg", 0.5, -1)
self.menu_music = False
self.game_music = False
self.game_time = GameText("0", 24, True)
self.game_time.font_file = FONT.default
self.game_time.centerx = SCREEN.width/2
self.game_time.y = 18
self.game_time.color = COLOR.white
self.game_time.create()
self.timer_red = False
self.flash_timer = 0
self.p1_score = GameText("0", 24, True)
self.p1_score.font_file = FONT.default
self.p1_score.left = 30
self.p1_score.y = 18
self.p1_score.color = COLOR.blue_sea
self.p1_score.create()
self.p2_score = GameText("0", 24, True)
self.p2_score.font_file = FONT.default
self.p2_score.right = SCREEN.width - 30
self.p2_score.y = 18
self.p2_score.color = COLOR.petal_green
self.p2_score.create()
self.bg_text = GameText("01", 72, True)
self.bg_text.font_file = FONT.kenpixel_blocks
self.bg_text.centerx = SCREEN.width/2
self.bg_text.centery = SCREEN.height/2
self.bg_text.color = COLOR.gray7
self.bg_text.create()
self.state = STATE.logo
self.stage_number = 1
self.stage = Stage(self.stage_number)
self.hi_score = 0
self.splashscreen = SplashScreen(0, 0, SPLASHSCREEN.width, SPLASHSCREEN.height)
self.logoscreen = LogoScreen(0, 0, LOGO.width, LOGO.height)
self.timer = GAME.time
self.totalscore = 0
self.p1_scores = {}
self.p2_scores = {}
self.camera = Camera(self.complex_camera, self.stage.level.width, self.stage.level.height)
self.bg = SCREEN.bg
self.screen_color = (choice(COLOR.colors))
self.menu = Menu(SCREEN.width, SCREEN.height, self.screen_color)
self.score_screen = ScoreScreen()
self.controls_screen = Controls()
self.screen_number = 1
self.capture_video = False
self.countdownOverlay = CountDownOverlay()
self.intro = True
self.intro_countdown = self.fps * 4
self.scanlines = ScanLines()
self.controller_present = False
try:
self.player1_joy = pygame.joystick.Joystick(0)
self.player1_joy.init()
self.controller_present = True
except:
pass
def reset(self):
self.stage_number += 1
if self.stage_number > self.stage.number_of_levels:
self.stage_number = 1
self.state = STATE.menu
self.score_screen = ScoreScreen()
self.controls_screen = Controls()
self.firstrun = True
else:
self.firstrun = False
self.state = STATE.game
self.stage = Stage(self.stage_number)
self.timer = GAME.time
self.camera = Camera(self.complex_camera, self.stage.level.width, self.stage.level.height)
self.screen_color = (choice(COLOR.colors))
self.menu = Menu(SCREEN.width, SCREEN.height, self.screen_color)
self.countdownOverlay = CountDownOverlay()
self.intro = True
self.intro_countdown = self.fps * 4
def handle_events(self):
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
self.state = STATE.menu
if event.key == K_p:
if not self.capture_video:
self.capture_video = True # change to True and press p to capture screenshots
else:
self.capture_video = False
if event.key == K_q:
#self.stage.level.spawn_data()
pass
elif event.type == JOYBUTTONDOWN:
if self.player1_joy.get_button(9) == 1:
self.state = STATE.menu
if self.state == STATE.game:
if self.stage.level.timer == 0:
self.stage.level.timer = pygame.time.get_ticks()/1000.0
self.stage.level.player1.handle_events(event)
self.stage.level.player2.handle_events(event)
elif self.state == STATE.menu:
self.menu.handle_events(event)
self.state = self.menu.state
elif self.state == STATE.controls:
self.controls_screen.handle_events(event)
self.state = self.controls_screen.state
elif self.state == STATE.scorescreen:
self.score_screen.handle_events(event)
self.state = self.score_screen.state
elif self.state == STATE.exit:
pygame.quit()
sys.exit()
def update(self):
if self.state == STATE.nextlevel:
self.reset()
return
if self.capture_video:
self.makeVideo()
if self.timer == 0:
self.state = STATE.scorescreen
if self.state == STATE.logo:
self.logoscreen.update()
self.state = self.logoscreen.state
if self.state == STATE.splashscreen:
self.splashscreen.update()
self.state = self.splashscreen.state
elif self.state == STATE.controls:
self.controls_screen.update()
elif self.state == STATE.menu:
self.menu.update()
if self.game_music:
self.game_music = False
mixer.music.fadeout(2000)
elif self.state == STATE.scorescreen:
self.p1_scores[self.stage_number-1] = self.stage.level.p1_data
self.p2_scores[self.stage_number-1] = self.stage.level.p2_data
self.score_screen.p1_scores[self.stage_number-1].text = self.stage.level.p1_data
self.score_screen.p2_scores[self.stage_number-1].text = self.stage.level.p2_data
self.score_screen.update(self.stage_number, 1, self.hi_score)
elif self.state == STATE.game:
if not self.game_music:
mixer.music.load(os.path.join('assets', 'music', 'cyberspine.ogg'))
mixer.music.play(-1)
self.game_music = True
self.camera.update(self.stage.level.player1)
if self.intro_countdown <= GAME.fps:
self.intro = False
self.intro_countdown = 0
if self.intro:
self.countdownOverlay.update(self.intro_countdown)
self.intro_countdown -= 1
else:
self.stage.level.update()
if self.stage.level.intro:
self.timer = GAME.time
if self.ticks > self.fps:
self.ticks = 0
self.timer -= 1
else:
self.ticks += 1
display_time = self.format_timer(self.timer)
self.game_time.text = display_time
if self.timer_red:
self.animate_flash()
else:
self.game_time.color = COLOR.white
self.game_time.update()
self.p1_score.text = str(self.stage.level.p1_data)
self.p1_score.update()
self.p2_score.text = str(self.stage.level.p2_data)
self.p2_score.update()
self.bg_text.text = "0" + str(self.stage_number)
self.bg_text.update()
def draw(self):
self.screen.fill(COLOR.black)
if self.state == STATE.logo:
self.logoscreen.draw(self.screen)
elif self.state == STATE.splashscreen:
self.splashscreen.draw(self.screen)
elif self.state == STATE.scorescreen:
self.score_screen.draw(self.screen)
elif self.state == STATE.controls:
self.controls_screen.draw(self.screen)
elif self.state == STATE.game:
self.screen.blit(SCREEN.bg, (0, 0))
self.bg_text.draw_to(self.screen)
self.screen.blit(ASSET.score_bg, (0, 0))
self.stage.draw(self.screen)
for particle in self.stage.level.particles:
self.screen.blit(particle.image, self.camera.apply(particle))
self.game_time.draw_to(self.screen)
self.p1_score.draw_to(self.screen)
self.p2_score.draw_to(self.screen)
if self.intro:
self.countdownOverlay.draw(self.screen)
elif self.state == STATE.menu:
self.menu.draw(self.screen)
if not self.firstrun:
pass
self.scanlines.draw(self.screen)
def run_game(self, fps=30):
self.fps = fps
while True:
self.handle_events()
self.update()
self.draw()
pygame.display.update()
pygame.display.set_caption("CleanerBots v0.1 - " + str(int(self.fpsClock.get_fps())) + " fps")
self.fpsClock.tick(self.fps)
def complex_camera(self, camera_rect, target_rect):
x, y, dummy, dummy = target_rect
dummy, dummy, w, h = camera_rect
x, y = int(SCREEN.width/2)-x, int(SCREEN.height/2) - y
x = min(0, x)
x = max(-(camera_rect.width-SCREEN.width), x)
y = max(-(camera_rect.height-SCREEN.height), y)
y = min(0, y)
return pygame.Rect(x, y, w, h)
def format_timer(self, timer):
self.timer_red = False
minutes = timer/60
seconds = timer % 60
if minutes == 0 and seconds < 10:
self.timer_red = True
if seconds < 10:
seconds = "0" + str(seconds)
return str(minutes)+":"+str(seconds)
def makeVideo(self):
pygame.image.save(self.screen, os.path.join("screenshots", "screenshot%d.jpg" %self.screen_number))
self.screen_number += 1
def animate_flash(self):
self.flash_timer += 1
if self.flash_timer < GAME.fps/4:
self.game_time.color = COLOR.white
elif self.flash_timer < GAME.fps/2:
self.game_time.color = COLOR.red
else:
self.flash_timer = 0
