def __init__(self):
self.personal_detail_fields = ["real_name", "address", "email", "password", "trusted_ips", "phone_number",
"verified", "pending_messages"]
self.stats_fields = ["win_streak", "loss_streak", "wins_total", "losses_total", "largest_loss_streak",
"largest_win_streak", "perfect_victory", "total_play_time_by_size", "total_moves_by_size",
"total_games_by_size", "iiq", "win_loss_ratio"]
# Identification Information
self.real_name = "" # Name of the person associated with this account
self.address = ""
self.email = ""
self.password = ""
self.trusted_ips = {}
self.phone_number = ""
self.pending_messages = {} # Dictionary containing message ID: message, timestamp
self.postgame_messages = {}
self.verified = False
# Account information
self.name = UsernameGenerator.generate_isogramic_username() # Username of the user
self.catchphrase = "" # Phrase to show to those starting a game with you.
# Cosmetic information
self.theme = Theme() # Theme the user has equipped
self.avatar = Avatar() # Link to avatar object, built from json, of course.
# Play-stats
self.last_active = 0
self.win_streak = 0
self.loss_streak = 0
self.wins_total = 0
self.losses_total = 0
self.largest_win_streak = 0
self.largest_loss_streak = 0
self.perfect_victory = 0
self.total_play_time_by_size = Profile.by_size(3, 17)
self.total_moves_by_size = Profile.by_size(3, 17)
self.total_games_by_size = Profile.by_size(3, 17)
# Important Stats
self.iiq = 2500 # Isogram Intelligence Quotient
self.win_loss_ratio = 0
self.level = 0 # Level
self.experience = 0 # Total experience
self.carousel_pages = "P" # Order of pages on this player's carousel.
self.game_pages = "LG" # Order of pages on this player's game carousel, visible during matches.
self.grams = 0 # Grams of stardust
self.scoins = 0 # Star coins
self.marques = 0 # "Sorry" tickets. Distributed to players upon unfortunate circumstances or at admin discretion.
# Redeemable 24 hours after distribution.
self.pending_marques = {}
self.rank = 0 # Default rank. 0 - Normal, 1 - Community Helper, 2 - Moderator, 3 - Admin
def __init__( self, theme ):
self.theme = 2
self.currentImage = -1
self.nextImage = 0
self.fadeTime = 2900
self.lobbyControlAlign = CENTER
self.lobbyControlFont = 'font'
self.lobbyControlImgPos = ( .5, .55 )
self.lobbyControlImgScale = .15
self.lobbyControlPos = ( .5, .15 )
self.lobbyControlScale = .0015
self.lobbyDisabledColor = ( .6, .6, .6 )
self.lobbyGameModeAlign = CENTER
self.lobbyGameModeColor = Theme.hexToColor( '#2891a6' )
self.lobbyGameModeFont = 'font'
self.lobbyGameModePos = ( .115, .715 )
self.lobbyGameModeScale = .0015
self.lobbyHeaderColor = Theme.hexToColor( '#2891a6' )
self.lobbyKeyboardImgPos = ( .8, .95 )
self.lobbyKeyboardImgScale = .1
self.lobbyOptionAlign = CENTER
self.lobbyOptionColor = Theme.hexToColor( '#2891a6' )
self.lobbyOptionFont = 'font'
self.lobbyOptionPos = ( .5, .26 )
self.lobbyOptionScale = .0015
self.lobbyOptionSpace = .035
self.lobbyPanelAvatarDimension = ( 0, 0 )
self.lobbyPanelNameAlign = LEFT
self.lobbyPanelNameFont = 'font'
self.lobbyPanelNamePos = ( 0, 0 )
self.lobbyPanelNameScale = .1
self.lobbyPanelPos = ( .1, .24 )
self.lobbyPanelSize = ( .15, .53 )
self.lobbyPanelSpacing = .215
self.lobbyPartPos = ( .5, .84 )
self.lobbyPartScale = .094
self.lobbySaveCharAlign = CENTER
self.lobbySaveCharColor = Theme.hexToColor( '#2891a6' )
self.lobbySaveCharFont = 'font'
self.lobbySaveCharScale = .0015
self.lobbySelectedColor = Theme.hexToColor( '#ffffff' )
self.lobbySelectLength = 4
self.lobbySubtitleText = _( 'CHOOSE YOUR CHARACTER' )
self.lobbySubtitleTextAlign = CENTER
self.lobbySubtitleTextFont = 'font'
self.lobbySubtitleTextPos = ( .5, .715 )
self.lobbySubtitleTextScale = .00098
self.lobbyTitleText = _( 'LOBBY -' )
self.lobbyTitleTextAlign = CENTER
self.lobbyTitleTextFont = 'font'
self.lobbyTitleTextPos = ( .05, .715 )
self.lobbyTitleTextScale = .0015
def __init__( self, theme ):
self.theme = theme
self.partDiffControlAlign = LEFT
self.partDiffControlFont = 'font'
self.partDiffControlPos = ( .25, .25 )
self.partDiffControlScale = .0015
self.partDiffGameModeAlign = LEFT
self.partDiffGameModeColor = Theme.hexToColor( '#2891a6' )
self.partDiffGameModeFont = 'font'
self.partDiffGameModePos = ( -5, 0 )
self.partDiffGameModeScale = .0015
self.partDiffHeaderColor = Theme.hexToColor( '#000000' )
self.partDiffKeyboardImgPos = ( 0, 0 )
self.partDiffKeyboardImgScale = .1
self.partDiffOptionAlign = LEFT
self.partDiffOptionColor = Theme.hexToColor( '#2891a6' )
self.partDiffOptionFont = 'font'
self.partDiffOptionPos = ( 0, 1 )
self.partDiffOptionScale = .0015
self.partDiffOptionSpace = 0
self.partDiffPanelNameAlign = LEFT
self.partDiffPanelNameFont = 'font'
self.partDiffPanelNamePos = ( 0, 0 )
self.partDiffPanelNameScale = .001
self.partDiffPanelPos = ( .05, .05 )
self.partDiffPanelSize = ( .05, .1 )
self.partDiffPanelSpacing = .24
# PART ICON
self.partDiffPartPos = ( -0.352, 0 )
self.partDiffPartScale = .035
self.partDiffSelectedColor = Theme.hexToColor( '#ffffff' )
self.partDiffSubtitleText = _( ' ' )
self.partDiffSubtitleTextAlign = LEFT
self.partDiffSubtitleTextFont = 'font'
self.partDiffSubtitleTextPos = ( .5, .15 )
self.partDiffSubtitleTextScale = .0015
self.partDiffTitleText = _( 'SELECT PART+DIFFICULTY' )
self.partDiffTitleTextAlign = LEFT
self.partDiffTitleTextFont = 'font'
self.partDiffTitleTextPos = ( .5, .95 )
self.partDiffTitleTextScale = .002
def __init__(self, token: str, url: str):
self.token = token
self.url = url
self.users_list = list()
self.themes_list = list()
themes_dict = load_json_data(themes_file)
for name, data in themes_dict.items():
new_theme = Theme()
new_theme.set(name, data)
self.themes_list.append(new_theme)
self.edit_theme_users = list()
self.edit_question_number_users = dict()
self.edit_right_answers_number_users = list()
self.users_test_dict = dict()
def from_json(self, json_text):
self.real_name = json_text["real_name"]
self.address = json_text["address"]
self.email = json_text["email"]
self.name = json_text["name"]
self.catchphrase = json_text["catchphrase"]
temp_theme = Theme()
temp_theme.from_json(json_text["theme"])
self.theme = temp_theme
temp_avatar = Avatar()
temp_avatar.from_json(json_text["avatar"])
self.avatar = temp_avatar
self.win_streak = json_text["win_streak"]
self.loss_streak = json_text["loss_streak"]
self.wins_total = json_text["wins_total"]
self.losses_total = json_text["losses_total"]
self.perfect_victory = json_text["perfect_victory"]
self.total_play_time_by_size = json_text["total_play_time_by_size"]
self.total_moves_by_size = json_text["total_moves_by_size"]
self.total_games_by_size = json_text["total_games_by_size"]
self.largest_loss_streak = json_text["largest_loss_streak"]
self.largest_win_streak = json_text["largest_win_streak"]
self.iiq = json_text["iiq"]
self.win_loss_ratio = json_text["win_loss_ratio"]
self.password = json_text["password"]
self.trusted_ips = json_text["trusted_ips"]
self.phone_number = json_text["phone_number"]
self.last_active = json_text["last_active"]
self.verified = json_text["verified"]
self.level = json_text["level"]
self.carousel_pages = json_text["carousel_pages"]
self.game_pages = json_text["game_pages"]
self.scoins = json_text["scoins"]
self.grams = json_text["grams"]
self.marques = json_text["marques"]
self.pending_marques = json_text["pending_marques"]
self.experience = json_text["experience"]
self.rank = json_text["rank"]
def story(self,
playerSprite_no,
story,
BGCOLOR=(0, 170, 255),
speed=250,
waitKey=True):
self.DISPLAYSURF.fill(BGCOLOR)
playerSprite = list(Player.CharacterSprites.values())[playerSprite_no]
playerSprite = pygame.transform.scale(playerSprite, (150, 150))
playerSprite1 = playerSprite.get_rect()
playerSprite1.centerx = int(self.WINWIDTH / 2)
playerSprite1.centery = int(self.WINHEIGHT / 2)
self.DISPLAYSURF.blit(playerSprite, playerSprite1)
boxImg = pygame.image.load('Images/dialogue/box150.png')
boxImg1 = boxImg.get_rect()
boxImg1.bottomleft = (0, self.WINHEIGHT)
#self.DISPLAYSURF.blit(boxImg,boxImg1)
pygame.display.update()
Font = Theme.getStoryFont()
for i in story:
Sentence = ""
for j in i.split(' '):
Sentence = Sentence + ' ' + j
self.DISPLAYSURF.blit(boxImg, boxImg1)
line = Font.render(Sentence, 1, (255, 255, 0))
lineRect = line.get_rect()
lineRect.center = (int(self.WINWIDTH / 2), self.WINHEIGHT - 75)
self.DISPLAYSURF.blit(line, lineRect)
pygame.time.wait(speed)
pygame.display.update()
if waitKey:
_ = self.waitKeyPressed()
def ingame(self, value):
Theme.setvariable(self.id_member, "cust_ingame", value)
def ingame(self):
return Theme.getvariable(self.id_member, "cust_ingame")
def __init__(
self,
path,
name,
iniFile = False,
):
Theme.__init__( self, path, name )
#new
self.menuPos = [0.5, 0.070000000000000007]
self.povTarget = ( 0.0, 1.0, 3.0 )
self.povOrigin = ( 0.0, 2.0, -3.5 )
self.countdownPosX = 0.5
self.countdownPosY = 0.30
self.boardFade = 2
artist_selected_color = '#ffffff'
artist_text_color = '#2891a6'
background_color = '#000000'
bars_color = '#2891a6'
base_color = '#2891a6'
career_title_color = '#2891a6'
character_create_font_color = '#2891a6'
character_create_help_color = '#2891a6'
character_create_select_color = '#ffffff'
fail_completed_color = '#2891a6'
fail_selected_color = '#ffffff'
fail_text_color = '#2891a6'
fret0_color = '#ffe788'
fret1_color = '#ffe788'
fret2_color = '#ffe788'
fret3_color = '#ffe788'
fret4_color = '#ffe788'
fret5_color = '#2891a6'
fretK_color = '#2891a6'
fretS_color = '#2891a6'
glow_color = '#2891a6'
hopo_color = '#2891a6'
hopo_indicator_active_color = '#2891a6'
hopo_indicator_inactive_color = '#2891a6'
ingame_stats_color = '#2891a6'
key2_color = '#2891a6'
key_color = '#2891a6'
library_selected_color = '#ffffff'
library_text_color = '#2891a6'
loading_text_color = '#2891a6'
menu_tip_text_color = '#2891a6'
mesh_color = '#2891a6'
opt_selected_color = '#ffffff'
opt_text_color = '#2891a6'
pause_selected_color = '#ffffff'
pause_text_color = '#2891a6'
rockmeter_score_color = '#2891a6'
selected_color = '#ffffff'
songlistcd_score_color = '#2891a6'
songlist_score_color = '#2891a6'
song_name_selected_color = '#ffffff'
song_name_text_color = '#2891a6'
song_rb2_diff_color = '#2891a6'
spot_color = '#2891a6'
star_fillup_color = '#2891a6'
tracks_color = '#2891a6'
vocal_glow_color = '#2891a6'
vocal_glow_color_star = '#2891a6'
vocal_lane_color = '#2891a6'
vocal_lane_color_star = '#2891a6'
vocal_shadow_color = '#2891a6'
vocal_shadow_color_star = '#2891a6'
self.shaderSolocolor = ( 1, 0.90588235294118, 0.53333333333333, 0.6 )
self.fail_bkg_pos = [1, 1, .00035]
self.fail_text_xPos = .5
self.fail_text_yPos = .5
self.fail_songname_xPos = .5
self.fail_songname_yPos = .6
self.result_score = [1, 1, .00035]
self.result_star = [1, 1, .00035]
self.result_song = [1, 1, .00035]
self.result_song_form = .5
self.result_song_text = "result_song_text"
self.result_stats_part = [1, 1, .00035]
self.result_stats_part_text = "result_stats_part_text"
self.result_stats_name = [1, 1, .00035]
self.result_stats_diff = [1, 1, .00035]
self.result_stats_diff_text = "result_stats_diff_text"
self.result_stats_accuracy = [1, 1, .00035]
self.result_stats_accuracy_text = "result_stats_accuracy_text"
self.result_stats_streak = [1, 1, .00035]
self.result_stats_streak_text = "result_stats_streak_text"
self.result_stats_notes = [1, 1, .00035]
self.result_stats_notes_text = "result_stats_notes_text"
self.result_cheats_info = [1, 1, .00035]
self.result_cheats_numbers = [1, 1, .00035]
self.result_cheats_percent = [1, 1, .00035]
self.result_cheats_score = [1, 1, .00035]
self.result_cheats_color = ( 1, 1, 1 )
self.result_cheats_font = 'font'
self.result_high_score_font = 'font'
self.result_menu_x = 'font'
self.result_menu_y = 'font'
self.result_star_type = 1
self.artist_selected_colorVar = \
self.hexToColor( artist_selected_color )
self.artist_text_colorVar = self.hexToColor( artist_text_color )
self.avatarSelectAvX = .75
self.avatarSelectAvY = .35
self.avatarSelectWheelY = 0.0
self.backgroundColor = self.hexToColor( background_color )
self.barsColor = self.hexToColor( bars_color )
self.baseColor = self.hexToColor( base_color )
self.career_title_colorVar = self.hexToColor( career_title_color )
self.characterCreateFontColor = \
self.hexToColor( character_create_font_color )
self.characterCreateHelpColor = \
self.hexToColor( character_create_help_color )
self.characterCreateHelpScale = 0.0009
self.characterCreateHelpX = 0.5
self.characterCreateHelpY = 0.72
self.characterCreateOptionX = .75
self.characterCreateScale = .0018
self.characterCreateSelectColor = \
self.hexToColor( character_create_select_color )
self.characterCreateSpace = .045
self.characterCreateX = .25
self.characterCreateY = 0.15
self.controlActivateFont = 'loadingFont'
self.controlActivatePartSize = 22.000
self.controlActivatePartX = .41
self.controlActivateScale = .0018
self.controlActivateSelectX = 0.5
self.controlActivateSpace = .045
self.controlActivateX = .645
self.controlActivateY = .18
self.controlCheckFont = 'loadingFont'
self.controlCheckPartMult = 2.8
self.controlCheckSpace = .23
self.controlCheckTextY = .61
self.controlCheckX = .16
self.controlCheckY = .26
self.controlDescriptionFont = 'font'
self.controlDescriptionScale = .002
self.controlDescriptionX = 0.5
self.controlDescriptionY = .617
self.displayAllGreyStars = False
self.fail_bkg_pos = [0.5, 0.5, 1.000, 1.000]
self.fail_completed_colorVar = \
self.hexToColor( fail_completed_color )
self.fail_selected_colorVar = \
self.hexToColor( fail_selected_color )
self.fail_songname_xPos = 0.5
self.fail_songname_yPos = .35
self.fail_text_colorVar = self.hexToColor( fail_text_color )
self.fail_text_xPos = None
self.fail_text_yPos = 0.40000000000000002
self.fret_press = True
self.glowColor = self.hexToColor( glow_color )
self.hopoColor = self.hexToColor( hopo_color )
self.hopoIndicatorActiveColor = \
self.hexToColor( hopo_indicator_active_color )
self.hopoIndicatorInactiveColor = \
self.hexToColor( hopo_indicator_inactive_color )
self.hopoIndicatorX = None
self.hopoIndicatorY = None
self.ingame_stats_colorVar = \
self.hexToColorResults( ingame_stats_color )
self.jurgTextPos = [1, 1, .00035]
self.key2Color = self.hexToColor( key2_color )
self.keyColor = self.hexToColor( key_color )
self.keypos = [-0.09, -0.09, -0.09, -0.09, -0.09]
self.killNoteColor = self.hexToColor( fretK_color )
self.library_selected_colorVar = \
self.hexToColor( library_selected_color )
self.library_text_colorVar = self.hexToColor( library_text_color )
self.loadingColor = self.hexToColor( loading_text_color )
self.loadingFScale = 0.0015
self.loadingLSpacing = 1
self.loadingRMargin = 1.000
self.loadingX = .5
self.loadingY = .070000000000000007
self.lobbyPanelAvatarDimension = ( 100.00, 55.00 )
self.lobbyPreviewX = 0.69999999999999996
self.lobbySelectFont = 'loadingFont'
self.lobbySelectImageX = 0.255
self.lobbySelectImageY = 0.335
self.lobbySelectLength = 4
self.lobbySelectScale = .0018
self.lobbySelectSpace = 0.040000000000000001
self.lobbySelectX = 0.40000000000000002
self.lobbySelectY = 0.32
self.lobbyTitleCharacterX = .26
self.lobbyTitleCharacterY = 0.24
self.lobbyTitleFont = 'font'
self.lobbyTitleScale = 0.0024
self.lobbyTitleX = 0.40000000000000002
self.lobbyTitleY = 0.59999999999999998
self.main_menu_scaleVar = 1
self.main_menu_vspacingVar = 0.000000
self.menuRB = True
self.menuTipTextColor = \
self.hexToColorResults( menu_tip_text_color )
self.menuTipTextDisplay = True
self.menuTipTextFont = 'font'
self.menuTipTextScale = 0.001
self.menuTipTextScrollMode = 0
self.menuTipTextScrollSpace = .25
self.menuTipTextY = .715
self.menuX = 0.5
self.menuY = 0.070000000000000007
self.meshColor = self.hexToColor( mesh_color )
self.oBarHScale = 0.69999999999999996
self.opt_bkg_size = [0.5, 0.5, 1.000, 1.000]
self.opt_selected_colorVar = self.hexToColor( opt_selected_color )
self.opt_text_colorVar = self.hexToColor( opt_text_color )
self.opt_text_xPos = None
self.opt_text_yPos = None
self.pause_bkg_pos = [0.5, 0.5, 1.000, 1.000]
self.pause_selected_colorVar = \
self.hexToColor( pause_selected_color )
self.pause_text_colorVar = self.hexToColor( pause_text_color )
self.pause_text_xPos = None
self.pause_text_yPos = None
self.povOriginX = 0
self.povOriginY = 2
self.povOriginZ = -3.5
self.povTargetX = 0
self.povTargetY = 1
self.povTargetZ = 3
self.power_up_name = None
self.rbmenu = True
self.result_menu_x = 0.40000000000000002
self.result_menu_y = .2
self.result_cheats_color = ( 1, 1, 1 )
self.result_cheats_font = 'font'
self.result_high_score_font = 'font'
self.result_song_text = '- %s -'
self.result_stats_accuracy_text = '%.1f%%'
self.result_stats_diff_text = ' %s'
self.result_stats_notes_text = '%s Hit'
self.result_stats_part_text = '%s'
self.result_stats_streak_text = '%d Streak'
self.result_song = ( .35, .2, .0008, None )
self.result_score = ( .35, .26, 0.0004 )
self.result_stats_diff = ( 0.5, .26, 0.0016, None )
self.result_stats_part = ( .65, .26, 0.0016, None )
self.result_stats_notes = ( .35, .34, .0018, None )
self.result_stats_accuracy = ( 0.5, .34, .0018, None )
self.result_stats_streak = ( .65, .34, .0018, None )
self.result_stats_name = ( 0.5, .42, 0.0025, None, None )
self.result_star = ( 0.5, .30, 0.070000000000000007, 1.000 )
self.result_cheats_info = ( .64, .26, .0013 )
self.result_cheats_numbers = ( .64, .28, .0013 )
self.result_cheats_percent = ( .64, 0.29999999999999999, .0013 )
self.result_song_form = 3
self.rockmeter_score_colorVar = \
self.hexToColorResults( rockmeter_score_color )
self.selectedColor = self.hexToColor( selected_color )
self.shadowoffsetx = 0.0
self.shadowoffsety = 0.0
self.songInfoDisplayScale = .0008
self.songInfoDisplayX = .05
self.songInfoDisplayY = .05
self.songlistcd_score_colorVar = \
self.hexToColor( songlistcd_score_color )
self.songListDisplay = 3
self.songlist_score_colorVar = \
self.hexToColor( songlist_score_color )
self.songSelectSubmenuOffsetLines = 4
self.songSelectSubmenuOffsetSpaces = 3
self.songSelectSubmenuX = 0.10000000000000001
self.songSelectSubmenuY = 0.075
self.song_cdscore_Xpos = 0.59999999999999998
self.song_cd_Xpos = 0.0
self.song_listcd_cd_Xpos = .25
self.song_listcd_cd_Ypos = 0.59999999999999998
self.song_listcd_list_Xpos = 0.5
self.song_listcd_score_xpos = 0.10000000000000001
self.song_listcd_score_ypos = 0.59999999999999998
self.song_listscore_Xpos = 0.69999999999999996
self.song_list_Xpos = 0.29999999999999999
self.song_name_selected_colorVar = \
self.hexToColor( song_name_selected_color )
self.song_name_text_colorVar = \
self.hexToColor( song_name_text_color )
self.song_rb2_diff_colorVar = \
self.hexToColor( song_rb2_diff_color )
self.noteColors = [self.hexToColor( fret0_color ), self.hexToColor( fret1_color ), self.hexToColor( fret2_color ), self.hexToColor( fret3_color ), self.hexToColor( fret4_color ), self.hexToColor( fret5_color )]
self.spNoteColor = self.hexToColor( fretS_color )
self.spotColor = self.hexToColor( spot_color )
self.starFillupCenterX = 139
self.starFillupCenterY = 151
self.starFillupColor = self.hexToColor( star_fillup_color )
self.starFillupInRadius = 121
self.starFillupOutRadius = 138
self.submenuScale['advsettingstext10'] = 1
self.submenuScale['careerfailtext4'] = 0.60
self.submenuScale['careerpausetext5'] = 0.9
self.submenuScale['careerpausetext6'] = 1
self.submenuScale['failtext3'] = 0.55
self.submenuScale['gameresulttext3'] = 0.55
self.submenuScale['multiplayertext3'] = 0.55
self.submenuScale['multiplayertext4'] = 0.60
self.submenuScale['multiplayertext7'] = 1
self.submenuScale['pausetext5'] = 0.80
self.submenuScale['pausetext6'] = 1
self.submenuScale['setlisttext8'] = 1
self.submenuScale['settingstext9'] = 1
self.submenuScale['solotext2'] = 0.5
self.submenuScale['trainingtext2'] = 0.5
self.submenuVSpace['advsettingstext10'] = 0.0000000000000000000000000000000000000
self.submenuVSpace['careerfailtext4'] = 0.00000000000000000000000000000000000000
self.submenuVSpace['careerpausetext5'] = 0.0000000000000000000000000000000000000
self.submenuVSpace['careerpausetext6'] = 0.0000000000000000000000000000000000000
self.submenuVSpace['failtext3'] = 0.0000000000000000000000000000000000000
self.submenuVSpace['gameresulttext3'] = 0.0000000000000000000000000000000000000
self.submenuVSpace['multiplayertext3'] = 0.0000000000000000000000000000000000000
self.submenuVSpace['multiplayertext4'] = 0.0000000000000000000000000000000000000
self.submenuVSpace['multiplayertext7'] = 0.0000000000000000000000000000000000000
self.submenuVSpace['pausetext5'] = 0.0000000000000000000000000000000000000
self.submenuVSpace['pausetext6'] = 0.0000000000000000000000000000000000000
self.submenuVSpace['setlisttext8'] = 0.0000000000000000000000000000000000000
self.submenuVSpace['settingstext9'] = 0.0000000000000000000000000000000000000
self.submenuVSpace['solotext2'] = 0.0000000000000000000000000000000000000
self.submenuVSpace['trainingtext2'] = 0.0000000000000000000000000000000000000
self.submenuX['advsettingstext10'] = 0.5
self.submenuX['careerfailtext4'] = 0.5
self.submenuX['careerpausetext5'] = 0.5
self.submenuX['careerpausetext6'] = 0.5
self.submenuX['failtext3'] = 0.5
self.submenuX['gameresulttext3'] = 0.5
self.submenuX['multiplayertext3'] = 0.5
self.submenuX['multiplayertext4'] = 0.5
self.submenuX['multiplayertext7'] = 0.5
self.submenuX['pausetext5'] = 0.5
self.submenuX['pausetext6'] = 0.5
self.submenuX['setlisttext8'] = 0.5
self.submenuX['settingstext9'] = 0.5
self.submenuX['solotext2'] = 0.5
self.submenuX['trainingtext2'] = 0.5
self.submenuY['advsettingstext10'] = 0.070000000000000007
self.submenuY['careerfailtext4'] = 0.070000000000000007
self.submenuY['careerpausetext5'] = 0.070000000000000007
self.submenuY['careerpausetext6'] = 0.070000000000000007
self.submenuY['failtext3'] = 0.070000000000000007
self.submenuY['gameresulttext3'] = 0.070000000000000007
self.submenuY['multiplayertext3'] = 0.070000000000000007
self.submenuY['multiplayertext4'] = 0.070000000000000007
self.submenuY['multiplayertext7'] = 0.070000000000000007
self.submenuY['pausetext5'] = 0.070000000000000007
self.submenuY['pausetext6'] = 0.070000000000000007
self.submenuY['setlisttext8'] = 0.070000000000000007
self.submenuY['settingstext9'] = 0.070000000000000007
self.submenuY['solotext2'] = 0.070000000000000007
self.submenuY['trainingtext2'] = 0.070000000000000007
self.sub_menu_xVar = 0.5
self.sub_menu_yVar = 0.070000000000000007
self.threeDspin = True
self.tracksColor = self.hexToColor( tracks_color )
self.twoDkeys = False
self.twoDnote = False
self.use_fret_colors = False
self.use_solo_submenu = True
self.versiontag = False
self.versiontagposX = 0.93
self.versiontagScale = 0.08
self.versiontagposY = 0.15
self.vocalCircularFillup = True
self.vocalFillupCenterX = 139
self.vocalFillupCenterY = 151
self.vocalFillupColor = self.hexToColorResults( '#2891a6' )
self.vocalFillupFactor = 300.000
self.vocalFillupInRadius = 25
self.vocalFillupOutRadius = 139
self.vocalGlowColor = self.hexToColorResults( vocal_glow_color )
self.vocalGlowColorStar = \
self.hexToColorResults( vocal_glow_color_star )
self.vocalGlowFade = 0.59999999999999998
self.vocalGlowSize = .008
self.vocalLaneColor = self.hexToColorResults( vocal_lane_color )
self.vocalLaneColorStar = \
self.hexToColorResults( vocal_lane_color_star )
self.vocalLaneSize = .0008
self.vocalMeterSize = 45.000
self.vocalMeterX = 0.5
self.vocalMeterY = .75
self.vocalMultX = 0.5
self.vocalMultY = .8
self.vocalPowerX = 0.5
self.vocalPowerY = .8
self.vocalShadowColor = \
self.hexToColorResults( vocal_shadow_color )
self.vocalShadowColorStar = \
self.hexToColorResults( vocal_shadow_color_star )
self.loadingPhrase = [
'',
"I'm an instant star. Just add water and stir. - David Bowie"
,
'',
'Forget all that macho shit, and learn how to play guitar. - John Mellencamp'
,
'Time you enjoy wasting, was not wasted. - John Lennon',
'Turn off your cheats already!',
"I don't know anything about music, In my line you don't have to. - Elvis Presley"
,
'',
'Onstage, I make love to 25,000 people, then I go home alone. - Janis Joplin'
,
"I've been imitated so well I've heard people copy my mistakes. - Jimi Hendrix"
,
"I'm just a musical prostitute, my dear. - Freddie Mercury"
,
'',
'The worst crime is faking it. - Kurt Cobain',
'',
]
self.themeLobby = self.loadThemeModule( 'CustomLobby' )
self.setlist = self.loadThemeModule( 'CustomSetlist' )
self.partDiff = self.loadThemeModule( 'CustomParts' )
def Selection(self, theme_no=0, playerSprite_no=0, themeSelect=True):
themelevel = Level("level/themeLevel.txt")
BGCOLOR = (0, 170, 255)
self.DISPLAYSURF.fill(BGCOLOR)
mapSurf = self.drawMap(themelevel.getCurLevelObj(),
Theme.Themes[theme_no])
mapSurf = self.drawCharacter(
mapSurf,
list(Player.CharacterSprites.values())[playerSprite_no],
themelevel.getCurLevelObj()['Start'])
Font = Theme.getTitleFont()
if themeSelect:
themeText = Font.render('Select Theme', 1, (25, 25, 25))
else:
themeText = Font.render('Select Character', 1, (25, 25, 25))
themeTextRect = themeText.get_rect()
themeTextRect.center = (self.WINWIDTH / 2, 90)
self.DISPLAYSURF.blit(themeText, themeTextRect)
Font2 = Theme.getInfoFont()
#text below selection
belowText = Font2.render('<<- use Arrow keys to change ->>', 1,
(0, 0, 0))
belowTextRect = belowText.get_rect()
belowTextRect.center = (self.WINWIDTH / 2, self.WINHEIGHT - 150)
self.DISPLAYSURF.blit(belowText, belowTextRect)
belowText2 = Font2.render('[Press Enter to select]', 1, (0, 0, 0))
belowTextRect2 = belowText2.get_rect()
belowTextRect2.center = (self.WINWIDTH / 2, self.WINHEIGHT - 120)
self.DISPLAYSURF.blit(belowText2, belowTextRect2)
mapSurfRect = mapSurf.get_rect()
mapSurfRect.center = (self.WINWIDTH / 2, self.WINHEIGHT / 2)
self.DISPLAYSURF.blit(mapSurf, mapSurfRect)
pygame.display.update()
while True:
Move = None
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
elif event.type == KEYDOWN:
KeyPressed = True
if event.key == K_LEFT or event.key == K_DOWN:
if themeSelect:
theme_no = (theme_no + 1) % len(Theme.Themes)
playerSprite_no = (playerSprite_no + 1) % len(
Player.CharacterSprites)
elif event.key == K_RIGHT or event.key == K_UP:
if themeSelect:
theme_no = (theme_no + 1) % len(Theme.Themes)
playerSprite_no = (playerSprite_no + 1) % len(
Player.CharacterSprites)
elif event.key == K_ESCAPE:
pygame.quit()
sys.exit()
elif event.key == K_RETURN:
return theme_no, playerSprite_no
mapSurf = self.drawMap(themelevel.getCurLevelObj(),
Theme.Themes[theme_no])
mapSurf = self.drawCharacter(
mapSurf,
list(
Player.CharacterSprites.values())[playerSprite_no],
themelevel.getCurLevelObj()['Start'])
mapSurfRect = mapSurf.get_rect()
mapSurfRect.center = (self.WINWIDTH / 2,
self.WINHEIGHT / 2)
self.DISPLAYSURF.blit(mapSurf, mapSurfRect)
pygame.display.update()
def __init__(self, path, name, iniFile = False): Theme.__init__(self, path, name) self.songListDisplay = 3 self.doNecksRender = False self.loadingPhrase = ["Loading"]
opts.ncolors = int(sys.argv[2])
opts.themeGtk2 = (sys.argv[3])
opts.themeGtk3 = (sys.argv[4])
userhome = os.path.expanduser("~")
nscdetheme = "NsCDE"
# nscdetheme="NsCDE-" + palettefile
if os.path.exists(userhome + "/.NsCDE/palettes/" + palettefile + ".dp"):
opts.currentpalettefile = (userhome + "/.NsCDE/palettes/" + palettefile +
".dp")
elif os.path.exists(nscde_root + "/share/palettes/" + palettefile + ".dp"):
opts.currentpalettefile = (nscde_root + "/share/palettes/" + palettefile +
".dp")
elif os.path.exists(palettefile):
opts.currentpalettefile = palettefile
# nscdetheme="NsCDE-" + os.path.basename(nscdetheme.replace(".dp", ""))
else:
print('Palette not found: ' + palettefile)
sys.exit()
Globals.themedir = nscde_root + "/share/templates/integration/gtk2_gtk3_qt"
Globals.userthemedir = os.path.join(userhome, '.themes', nscdetheme)
Globals.themesrcdir = Globals.themedir
Globals.palettedir = os.path.join(Globals.themedir, 'palettes')
theme = Theme(opts)
Globals.colorshash = readMotifColors2(opts.ncolors, opts.currentpalettefile)
theme.initTheme()
theme.updateThemeNow()
class Profile:
def __init__(self):
self.personal_detail_fields = ["real_name", "address", "email", "password", "trusted_ips", "phone_number",
"verified", "pending_messages"]
self.stats_fields = ["win_streak", "loss_streak", "wins_total", "losses_total", "largest_loss_streak",
"largest_win_streak", "perfect_victory", "total_play_time_by_size", "total_moves_by_size",
"total_games_by_size", "iiq", "win_loss_ratio"]
# Identification Information
self.real_name = "" # Name of the person associated with this account
self.address = ""
self.email = ""
self.password = ""
self.trusted_ips = {}
self.phone_number = ""
self.pending_messages = {} # Dictionary containing message ID: message, timestamp
self.postgame_messages = {}
self.verified = False
# Account information
self.name = UsernameGenerator.generate_isogramic_username() # Username of the user
self.catchphrase = "" # Phrase to show to those starting a game with you.
# Cosmetic information
self.theme = Theme() # Theme the user has equipped
self.avatar = Avatar() # Link to avatar object, built from json, of course.
# Play-stats
self.last_active = 0
self.win_streak = 0
self.loss_streak = 0
self.wins_total = 0
self.losses_total = 0
self.largest_win_streak = 0
self.largest_loss_streak = 0
self.perfect_victory = 0
self.total_play_time_by_size = Profile.by_size(3, 17)
self.total_moves_by_size = Profile.by_size(3, 17)
self.total_games_by_size = Profile.by_size(3, 17)
# Important Stats
self.iiq = 2500 # Isogram Intelligence Quotient
self.win_loss_ratio = 0
self.level = 0 # Level
self.experience = 0 # Total experience
self.carousel_pages = "P" # Order of pages on this player's carousel.
self.game_pages = "LG" # Order of pages on this player's game carousel, visible during matches.
self.grams = 0 # Grams of stardust
self.scoins = 0 # Star coins
self.marques = 0 # "Sorry" tickets. Distributed to players upon unfortunate circumstances or at admin discretion.
# Redeemable 24 hours after distribution.
self.pending_marques = {}
self.rank = 0 # Default rank. 0 - Normal, 1 - Community Helper, 2 - Moderator, 3 - Admin
def to_json(self, hide_personal_details=False, just_stats=False):
return_json = {
'verified': self.verified,
'last_active': self.last_active,
'real_name': self.real_name,
'phone_number': self.phone_number,
'address': self.address,
'email': self.email,
'name': self.name,
'catchphrase': self.catchphrase,
'theme': self.theme.to_json(),
'avatar': self.avatar.to_json(),
'win_streak': self.win_streak,
'loss_streak': self.loss_streak,
'wins_total': self.wins_total,
'losses_total': self.losses_total,
'largest_loss_streak': self.largest_loss_streak,
'largest_win_streak': self.largest_win_streak,
'perfect_victory': self.perfect_victory,
'total_play_time_by_size': self.total_play_time_by_size,
'total_moves_by_size': self.total_moves_by_size,
'total_games_by_size': self.total_games_by_size,
'iiq': self.iiq,
'win_loss_ratio': self.win_loss_ratio,
'password': self.password,
'trusted_ips': self.trusted_ips,
'level': self.level,
'carousel_pages': self.carousel_pages,
'game_pages': self.game_pages,
'grams': self.grams,
'scoins': self.scoins,
'marques': self.marques,
'pending_marques': self.pending_marques,
'experience': self.experience,
'rank': self.rank
}
if hide_personal_details:
for entry in self.personal_detail_fields:
return_json.pop(entry, None)
if just_stats:
for entry in return_json.keys():
if entry not in self.stats_fields:
return_json.pop(entry, None)
return return_json
@staticmethod
def by_size(start, end):
return_dict = {}
for x in xrange(start, end+1):
return_dict[x] = 0
return return_dict
def from_json(self, json_text):
self.real_name = json_text["real_name"]
self.address = json_text["address"]
self.email = json_text["email"]
self.name = json_text["name"]
self.catchphrase = json_text["catchphrase"]
temp_theme = Theme()
temp_theme.from_json(json_text["theme"])
self.theme = temp_theme
temp_avatar = Avatar()
temp_avatar.from_json(json_text["avatar"])
self.avatar = temp_avatar
self.win_streak = json_text["win_streak"]
self.loss_streak = json_text["loss_streak"]
self.wins_total = json_text["wins_total"]
self.losses_total = json_text["losses_total"]
self.perfect_victory = json_text["perfect_victory"]
self.total_play_time_by_size = json_text["total_play_time_by_size"]
self.total_moves_by_size = json_text["total_moves_by_size"]
self.total_games_by_size = json_text["total_games_by_size"]
self.largest_loss_streak = json_text["largest_loss_streak"]
self.largest_win_streak = json_text["largest_win_streak"]
self.iiq = json_text["iiq"]
self.win_loss_ratio = json_text["win_loss_ratio"]
self.password = json_text["password"]
self.trusted_ips = json_text["trusted_ips"]
self.phone_number = json_text["phone_number"]
self.last_active = json_text["last_active"]
self.verified = json_text["verified"]
self.level = json_text["level"]
self.carousel_pages = json_text["carousel_pages"]
self.game_pages = json_text["game_pages"]
self.scoins = json_text["scoins"]
self.grams = json_text["grams"]
self.marques = json_text["marques"]
self.pending_marques = json_text["pending_marques"]
self.experience = json_text["experience"]
self.rank = json_text["rank"]
def set_real_name(self, newname):
self.real_name = newname
def get_real_name(self):
return self.real_name
def set_address(self, naddress):
self.address = naddress
def get_address(self):
return self.address
def set_email(self, nemail):
self.email = nemail
def get_email(self):
return self.email
def set_account_name(self, naname):
self.name = naname
def get_account_name(self):
return self.name
def set_catchphrase(self, ncatchphrase):
self.catchphrase = ncatchphrase
def get_catchphrase(self):
return self.catchphrase
def set_theme(self, ntheme):
self.theme = ntheme
def get_theme(self):
return self.theme
def set_avatar(self, navatar):
self.avatar = navatar
def get_avatar(self):
return self.avatar
def set_win_streak(self, nwin):
self.win_streak = nwin
def get_win_streak(self):
return self.win_streak
def set_loss_streak(self, nloss):
self.loss_streak = nloss
def get_loss_streak(self):
return self.loss_streak
def set_wins_total(self, nwins):
self.wins_total = nwins
def get_wins_total(self):
return self.wins_total
def set_losses_total(self, nlosses):
self.losses_total = nlosses
def get_losses_total(self):
return self.losses_total
def set_perfect_victories(self, npvict):
self.perfect_victory = npvict
def get_perfect_victories(self):
return self.perfect_victory
def set_iiq(self, niiq):
self.iiq = niiq
def get_iiq(self):
return self.iiq
def set_win_loss_ratio(self, nwlr):
self.win_loss_ratio = nwlr
def get_win_loss_ratio(self):
return self.win_loss_ratio
def get_total_play_time_by_size(self):
return self.total_play_time_by_size
def set_total_play_time_by_size(self, dict):
self.total_play_time_by_size = dict
def get_total_games_by_size(self):
return self.total_games_by_size
def set_total_games_by_size(self, dict):
self.total_games_by_size = dict
def set_total_moves_by_size(self, dict):
self.total_moves_by_size = dict
def get_total_moves_by_size(self):
return self.total_moves_by_size
def set_password(self, passw):
self.password = passw
def get_password(self):
return self.password
def get_trusted_ips(self):
return self.trusted_ips
def set_trusted_ips(self, tips):
self.trusted_ips = tips
def get_phone_number(self):
return self.phone_number
def set_phone_number(self, phone):
self.phone_number = phone
def set_last_active(self, time):
self.last_active = time
def get_last_active(self):
return self.last_active
def get_verified(self):
return self.verified
def set_verified(self, bool):
self.verified = bool
def get_pending_messages(self):
return self.pending_messages
def get_postgame_messages(self):
return self.postgame_messages
def set_largest_loss_streak(self, nll):
self.largest_loss_streak = nll
def get_largest_loss_streak(self):
return self.largest_loss_streak
def set_largest_win_streak(self, nww):
self.largest_win_streak = nww
def get_largest_win_streak(self):
return self.largest_win_streak
def clear_pending_messages(self):
self.pending_messages.clear()
def add_server_message(self, string_message, is_json=False):
largest_key = 0
for key in self.pending_messages.keys():
if key > largest_key:
largest_key = key
self.pending_messages[largest_key + 1] = {
"message": string_message,
"timestamp": time.time(),
"is_json": is_json
}
def clear_postgame_messages(self):
self.postgame_messages.clear()
def add_postgame_message(self, string_message, is_json=False):
largest_key = 0
for key in self.postgame_messages.keys():
if key > largest_key:
largest_key = key
self.postgame_messages[largest_key + 1] = {
"message": string_message,
"timestamp": time.time(),
"is_json": is_json
}
def get_level(self):
return self.level
def set_level(self, level):
self.level = level
def get_carousel_pages(self):
return self.carousel_pages
def set_carousel_pages(self, target):
self.carousel_pages = target
def get_game_pages(self):
return self.game_pages
def set_game_pages(self, target):
self.game_pages = target
def set_scoins(self, scoins):
self.scoins = scoins
def get_scoins(self):
return self.scoins
def set_grams(self, gram):
self.grams = gram
def get_grams(self):
return self.grams
def get_marques(self):
return self.marques
def set_marques(self, newmarques):
self.marques = newmarques
def get_pending_marques(self):
return self.pending_marques
def set_pending_marques(self, newpend):
self.pending_marques = newpend
def distribute_marques(self, amount=1):
self.pending_marques[time.time()] = amount
def get_experience(self):
return self.experience
def set_experience(self, amount):
self.experience = amount
def get_rank(self):
return self.rank
def set_rank(self, newrank):
self.rank = newrank
def private_auth_key(self):
return Theme.getvariable(self.id_member, "cust_privat")
def public_auth_key(self):
return Theme.getvariable(self.id_member, "cust_public")
def __init__(
self,
path,
name,
iniFile=False,
):
Theme.__init__(self, path, name)
#main menu
self.menuPos = [0.235, 0.75]
self.main_menu_vspacingVar = 0.065
self.main_menu_scaleVar = 0.6
self.use_solo_submenu = False
#pov
self.neckLength = 6.5
self.neckWidth = 3.23
self.povTarget = [0.0, 1.0, 2.35]
self.povOrigin = [0.0, 3.4, -3.9]
# self.povTargetX = 0.0
# self.povTargetY = 1
# self.povTargetZ = 2.35
# self.povOriginX = 0.0
# self.povOriginY = 3.4
# self.povOriginZ = -3.9
self.povIntroAnimation = "rockband"
#3d fret settings
# self.keyrot = [4.00, 2.00, 0.00, -2.00, -4.00]
# self.keypos = [0.04, 0.01, 0.00, 0.01, 0.04]
self.twoDkeys = True
self.twoDnote = True
self.noteTailSpeedMulti = 2.5
#hitglows/hit images
self.hitFlameBlackRemove = False
self.hitFlameSize = .19
self.holdFlameSize = .19
self.hitFlamePos = (0, 1.15)
self.holdFlamePos = (0, .4)
self.HitFlameFrameLimit = 26
self.hitFlameRotation = (180, 0, 1, 0)
self.hitGlowsRotation = (180, 0, 1, 0)
self.hitGlowOffset = (.095, .025, .02, .025, .095)
self.hitFlameOffset = (.075, .05, .025, .05, .075)
#loading
self.loadingY = 20
self.loadingX = 20
self.loadingPhrase = ["hi"]
self.fpsRenderPos = (0.15, .055)
#setlist
self.songListDisplay = 3
self.songSelectSubmenuX = 0.5
self.songSelectSubmenuY = 0.075
self.setlist = self.loadThemeModule('CustomSetlist')
def runLevel(self, levelObj, theme_no=0, playerSprite_no=0):
#set font and theme
DisplayFont = Theme.getInfoFont()
selectedTheme, selectedPlayer = Theme.Themes[theme_no], list(
Player.CharacterSprites.values())[playerSprite_no]
#get level no and total levels in level_no tuple
level_no = self.level.levelInfo()
MapRefresh = True
LevelCompleted = False
#initialize all current level ghosts with speeds
cur_ghosts = []
for i in levelObj['Ghosts']:
if i['type'] == 'V':
tmpGhost = Ghost(i, 1.0, len(levelObj['map']))
else:
tmpGhost = Ghost(i, 1.0, len(levelObj['map'][0]))
cur_ghosts.append(tmpGhost)
tmpGhost.getinfo()
self.DISPLAYSURF.fill(Theme.Colors['LIGHTBLUE'])
levelSurf = DisplayFont.render('Level %s of %s' % level_no, 1,
Theme.Colors['BLACK'])
levelRect = levelSurf.get_rect()
levelRect.bottomleft = (20, self.WINHEIGHT - 35)
self.DISPLAYSURF.blit(levelSurf, levelRect)
mapSurf = self.drawMap(levelObj, selectedTheme)
mapSurf = self.drawCharacter(mapSurf, selectedPlayer,
levelObj['Start'])
mapSurfRect = mapSurf.get_rect()
mapSurfRect.center = (self.WINWIDTH / 2, self.WINHEIGHT / 2)
self.DISPLAYSURF.blit(mapSurf, mapSurfRect)
pygame.display.update()
self.Clock.tick()
time_passed = 0.0
levelPass = True
#main game loop for level
while not LevelCompleted:
Move = None
KeyPressed = True
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
elif event.type == KEYDOWN:
KeyPressed = True
if event.key == K_LEFT:
Move = 'left'
elif event.key == K_RIGHT:
Move = 'right'
elif event.key == K_UP:
Move = 'up'
elif event.key == K_DOWN:
Move = 'down'
elif event.key == K_ESCAPE:
pygame.quit()
sys.exit()
self.DISPLAYSURF.fill(Theme.Colors['LIGHTBLUE'])
timeSec = time_passed / 1000.0
if Move != None and not LevelCompleted:
moved, levelObj, LevelCompleted = self.level.makeMove(Move)
#print(moved,levelObj,LevelCompleted)
mapSurf = self.drawMap(levelObj, selectedTheme)
mapSurf = self.drawCharacter(mapSurf, selectedPlayer,
levelObj['Start'])
#check each ghost if moved and get new position
for ghst in cur_ghosts:
mvd, pos = ghst.Haunt(timeSec)
ghstSprite = ghst.getSprite()
mapSurf = self.drawCharacter(mapSurf, ghstSprite, pos)
if pos == list(levelObj['Start']):
LevelCompleted = True
levelPass = False
self.GameOver.play()
levelSurf = DisplayFont.render('Level %s of %s' % level_no, 1,
Theme.Colors['BLACK'])
levelRect = levelSurf.get_rect()
levelRect.bottomleft = (20, self.WINHEIGHT - 35)
self.DISPLAYSURF.blit(levelSurf, levelRect)
timeText = DisplayFont.render('Time %s' % int(timeSec), 1,
Theme.Colors['BLACK'])
timeRect = timeText.get_rect()
timeRect.topright = (self.WINWIDTH - 20, 35)
self.DISPLAYSURF.blit(timeText, timeRect)
#mapSurf = pygame.transform.scale(mapSurf,(400,500))
mapSurfRect = mapSurf.get_rect()
mapSurfRect.center = (self.WINWIDTH / 2, self.WINHEIGHT / 2)
self.DISPLAYSURF.blit(mapSurf, mapSurfRect)
pygame.display.update()
time_passed += self.Clock.tick()
return levelPass
def public_auth_key(self, value):
Theme.setvariable(self.id_member, "cust_public", value)
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.tasks = []
self.frameTasks = []
self.fps = fps
self.currentTask = None
self.paused = []
self.running = True
self.clock = pygame.time.Clock()
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.frames = 0
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.addTask(self.input, synchronized=False)
self.addTask(self.view, synchronized=False)
self.addTask(self.resource, synchronized=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] == ".png" or os.path.splitext(
aniFile
)[1] == ".jpg" or os.path.splitext(
aniFile
)[1] == ".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.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 private_auth_key(self, value):
Theme.setvariable(self.id_member, "cust_privat", value)
# emesene is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with emesene; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA import MarkupParser from Theme import Theme from Handler import * from Message import Message from ContactList import ContactList from Conversation import Conversation from LoginBase import LoginBase from ConversationManager import ConversationManager from AvatarManager import AvatarManager from PictureHandler import PictureHandler from ContactInformation import ContactInformation from BaseTray import BaseTray from MainWindowBase import MainWindowBase from Hotmail import Hotmail theme = Theme() import stock import extension import e3
